commit 47d817e61c0a67350bd05e1e9e4e943604374448 Author: Lorenz Cuno Klopfenstein Date: Fri May 3 18:16:42 2013 +0200 Updated text files for max 80 columns. diff --git a/.hgignore b/.hgignore new file mode 100644 index 0000000..6d66599 --- /dev/null +++ b/.hgignore @@ -0,0 +1,9 @@ +glob:OnTopReplica.suo +glob:bin/* +glob:obj/* +glob:publish/* +glob:*Thumbs.db +glob:*.psd +glob:Installer/OnTopReplica-Setup.exe +syntax: glob +*.Designer.cs diff --git a/Docs/Settings List.txt b/Docs/Settings List.txt new file mode 100644 index 0000000..b54e994 --- /dev/null +++ b/Docs/Settings List.txt @@ -0,0 +1,7 @@ +OPTIONS + ++ Language + Drop down list with icons + Restart notice + ++ Shortcuts \ No newline at end of file diff --git a/Installer/DotNet.nsh b/Installer/DotNet.nsh new file mode 100644 index 0000000..055b392 --- /dev/null +++ b/Installer/DotNet.nsh @@ -0,0 +1,32 @@ +# .NET Installation checker + +!macro HasDotNet4 OutVar + Push "Install" ;reg key + Push "Software\Microsoft\NET Framework Setup\NDP\v4\Client" ;v4.0 client reg node + Call HasDotNet4Core + Pop ${OutVar} +!macroend + +!define HasDotNet4 "!insertmacro HasDotNet4" + +Function HasDotNet4Core + Pop $R0 ;reg node to check + Pop $R1 ;reg key + + ReadRegDWORD $R3 HKLM $R0 $R1 + + ;MessageBox MB_OK "$R0 \ $R1 value is $R3" + ;IntOp $R8 $R3 % 1 ;logical AND with 1 (should evaluate to 1 in $R8) + + IntCmp $R3 1 has hasNot has ;jump if >= 1 + + has: + Push 1 + Goto exit + + hasNot: + Push 0 + Goto exit + + exit: +FunctionEnd diff --git a/Installer/header.bmp b/Installer/header.bmp new file mode 100644 index 0000000..7326b9c Binary files /dev/null and b/Installer/header.bmp differ diff --git a/Installer/script.nsi b/Installer/script.nsi new file mode 100644 index 0000000..611c9c3 --- /dev/null +++ b/Installer/script.nsi @@ -0,0 +1,140 @@ +# INCLUDES +!include MUI2.nsh ;Modern interface +!include LogicLib.nsh ;nsDialogs +!include "DotNet.nsh" + +# INIT +Name "OnTopReplica" +InstallDir "$LOCALAPPDATA\OnTopReplica" +OutFile "OnTopReplica-Setup.exe" +RequestExecutionLevel user + +# REFS +!define REG_UNINSTALL "Software\Microsoft\Windows\CurrentVersion\Uninstall\OnTopReplica" +!define START_LINK_DIR "$STARTMENU\Programs\OnTopReplica" +!define START_LINK_RUN "$STARTMENU\Programs\OnTopReplica\OnTopReplica.lnk" +!define START_LINK_UNINSTALLER "$STARTMENU\Programs\OnTopReplica\Uninstall OnTopReplica.lnk" +!define UNINSTALLER_NAME "OnTopReplica-Uninstall.exe" +!define WEBSITE_LINK "http://www.klopfenstein.net/lorenz.aspx/ontopreplica" + +# GRAPHICS +!define MUI_ICON "..\OnTopReplica\Assets\icon-new.ico" +!define MUI_UNICON "..\OnTopReplica\Assets\icon-new-red.ico" +!define MUI_HEADERIMAGE +!define MUI_HEADERIMAGE_RIGHT +!define MUI_HEADERIMAGE_BITMAP "header.bmp" +!define MUI_HEADERIMAGE_UNBITMAP "header.bmp" +#!define MUI_WELCOMEFINISHPAGE_BITMAP "banner.bmp" +#!define MUI_UNWELCOMEFINISHPAGE_BITMAP "banner.bmp" + +# TEXT AND SETTINGS +!define MUI_PAGE_HEADER_TEXT "OnTopReplica" + +!define MUI_FINISHPAGE_RUN "$INSTDIR\OnTopReplica.exe" +;!define MUI_FINISHPAGE_RUN_TEXT "Run OnTopReplica now." + +;Do not skip to finish automatially +!define MUI_FINISHPAGE_NOAUTOCLOSE +!define MUI_UNFINISHPAGE_NOAUTOCLOSE + +# PAGE DEFINITIONS +!insertmacro MUI_PAGE_WELCOME +!insertmacro MUI_PAGE_INSTFILES +!insertmacro MUI_PAGE_FINISH + +!insertmacro MUI_UNPAGE_CONFIRM +!insertmacro MUI_UNPAGE_INSTFILES + +# LANGUAGES +!insertmacro MUI_LANGUAGE "English" + +# INITIALIZATION AND ERROR CHECKING +Function .onInit + ${HasDotNet4} $R0 + ${If} $R0 == 1 + ;noop + ${Else} + MessageBox MB_OKCANCEL|MB_ICONEXCLAMATION "Microsoft .NET Framework 4.0 appears not to be installed.$\n$\nOnTopReplica requires .NET 4.0 to run: please install it before running the installer.$\n$\nDo you wish to proceed anyway?" IDOK proceedAnyway + Abort ".NET 4.0 required to install" + proceedAnyway: + ${EndIf} +FunctionEnd + +# CALLBACKS +Function RegisterApplication + ;Register uninstaller into Add/Remove panel (for local user only) + WriteRegStr HKCU "${REG_UNINSTALL}" "DisplayName" "OnTopReplica" + WriteRegStr HKCU "${REG_UNINSTALL}" "DisplayIcon" "$\"$INSTDIR\OnTopReplica.exe$\"" + WriteRegStr HKCU "${REG_UNINSTALL}" "Publisher" "Lorenz Cuno Klopfenstein" + WriteRegStr HKCU "${REG_UNINSTALL}" "DisplayVersion" "3.4" + WriteRegDWord HKCU "${REG_UNINSTALL}" "EstimatedSize" 992 ;KB + WriteRegStr HKCU "${REG_UNINSTALL}" "HelpLink" "${WEBSITE_LINK}" + WriteRegStr HKCU "${REG_UNINSTALL}" "URLInfoAbout" "${WEBSITE_LINK}" + WriteRegStr HKCU "${REG_UNINSTALL}" "InstallLocation" "$\"$INSTDIR$\"" + WriteRegStr HKCU "${REG_UNINSTALL}" "InstallSource" "$\"$EXEDIR$\"" + WriteRegDWord HKCU "${REG_UNINSTALL}" "NoModify" 1 + WriteRegDWord HKCU "${REG_UNINSTALL}" "NoRepair" 1 + WriteRegStr HKCU "${REG_UNINSTALL}" "UninstallString" "$\"$INSTDIR\${UNINSTALLER_NAME}$\"" + WriteRegStr HKCU "${REG_UNINSTALL}" "Comments" "Uninstalls OnTopReplica." + + ;Links + SetShellVarContext current + CreateDirectory "${START_LINK_DIR}" + CreateShortCut "${START_LINK_RUN}" "$INSTDIR\OnTopReplica.exe" + CreateShortCut "${START_LINK_UNINSTALLER}" "$INSTDIR\${UNINSTALLER_NAME}" +FunctionEnd + +Function un.DeregisterApplication + ;Deregister uninstaller from Add/Remove panel + DeleteRegKey HKCU "${REG_UNINSTALL}" + + ;Start menu links + SetShellVarContext current + RMDir /r "${START_LINK_DIR}" +FunctionEnd + +# INSTALL SECTIONS +Section "!OnTopReplica" OnTopReplica + SectionIn RO + + SetOutPath $INSTDIR + SetOverwrite on + + ;Ensure that old VistaControls.dll is removed + Delete "$INSTDIR\VistaControls.dll" + + ;Main installation + File "..\OnTopReplica\bin\Release\OnTopReplica.exe" + File "..\OnTopReplica\bin\Release\OnTopReplica.exe.config" + File "..\OnTopReplica\bin\Release\WindowsFormsAero.dll" + + ;Text stuff + File "..\OnTopReplica\bin\Release\CREDITS.txt" + File "..\OnTopReplica\bin\Release\LICENSE.txt" + + ;Install localization files + SetOutPath "$INSTDIR\it" + File "..\OnTopReplica\bin\Release\it\OnTopReplica.resources.dll" + SetOutPath "$INSTDIR\cs" + File "..\OnTopReplica\bin\Release\cs\OnTopReplica.resources.dll" + SetOutPath "$INSTDIR\da" + File "..\OnTopReplica\bin\Release\da\OnTopReplica.resources.dll" + SetOutPath "$INSTDIR\de" + File "..\OnTopReplica\bin\Release\de\OnTopReplica.resources.dll" + SetOutPath "$INSTDIR\es" + File "..\OnTopReplica\bin\Release\es\OnTopReplica.resources.dll" + SetOutPath "$INSTDIR\pl" + File "..\OnTopReplica\bin\Release\pl\OnTopReplica.resources.dll" + + ;Uninstaller + WriteUninstaller "$INSTDIR\${UNINSTALLER_NAME}" + Call RegisterApplication +SectionEnd + +Section "Uninstall" + ;Remove whole directory (no data is stored there anyway) + RMDir /r "$INSTDIR" + + ;Remove uninstaller + Call un.DeregisterApplication +SectionEnd diff --git a/Installer/update.xml b/Installer/update.xml new file mode 100644 index 0000000..e2a1f35 --- /dev/null +++ b/Installer/update.xml @@ -0,0 +1,6 @@ + + + 3.3.2.0 + 2011-06-07T01:00:00Z + http://www.klopfenstein.net/lorenz.aspx/ontopreplica + \ No newline at end of file diff --git a/Lib/WindowsFormsAero.dll b/Lib/WindowsFormsAero.dll new file mode 100644 index 0000000..3148026 Binary files /dev/null and b/Lib/WindowsFormsAero.dll differ diff --git a/Lib/WindowsFormsAero.pdb b/Lib/WindowsFormsAero.pdb new file mode 100644 index 0000000..15f1856 Binary files /dev/null and b/Lib/WindowsFormsAero.pdb differ diff --git a/Lib/WindowsFormsAero.xml b/Lib/WindowsFormsAero.xml new file mode 100644 index 0000000..17ac4eb --- /dev/null +++ b/Lib/WindowsFormsAero.xml @@ -0,0 +1,1131 @@ + + + + WindowsFormsAero + + + + + Base form class that automatically sets its font according to the Windows UX guidelines. + + + + + Constructs a new Aero styled form. + + + + Common Task Dialog buttons. OK is the default button. + + + Stores a Task Dialog message that will be sent to a dialog in order to update its state. + + + Simple int, int message. + + + Simple int, bool message. + + + Simple bool, bool message. + + + Simple bool, int message. + + + Simple int, long (hi word and lo word) message. + + + Text updating message. + The string will be marshaled: the Message must be correctly disposed after use. + + + Navigation message. + The config structure will be marshaled: must be correctly disposed after use. + + + Text values that can be updated. + + + + Control style and notification constants + + + + Occurs when the split label is clicked. + + + Occurs when the split label is clicked, but before the associated + context menu is displayed by the control. + + + Gets or sets the associated context menu that is displayed when the split + glyph of the button is clicked. + + + Gets or sets the associated context menu that is displayed when the split + glyph of the button is clicked. Exposed for backward compatibility. + + + Provides data for the clicking of split buttons and the opening + of context menus. + + + Represents the bounding box of the clicked button. + A menu should be opened, with top-left coordinates in the left-bottom point of + the rectangle and with width equal (or greater) than the width of the rectangle. + + + Set to true if you want to prevent the menu from opening. + + + Margins structure for the Glass Sheet effect. + + + + Returns whether a point in client coordinates is outside the margins defined by this instance. + + Point in client coordinates. + + + + Gets the margins value as a padding instance. + + + + + + Gets a static readonly 0-pixel margin. + This margin returns true on the IsNull property. + + + + + Gets whether this margin represents a negative measure on each side. + + + Used to specify non-existing margins on glass frames. + + + + + Gets whether this margin measures 0 pixels on each side. + + + + Displays a dialog box that can contain text, icons, buttons, command links, radio buttons and/or a progress bar. + + + Displays a task dialog that has a message. + The text to display. + + + Displays a task dialog that has a message and a title. + The text to display. + The title bar caption of the dialog. + + + Displays a task dialog that has a message, a title and an instruction. + The text to display. + The title bar caption of the dialog. + The instruction shown below the main text. + + + Displays a task dialog that has a message, a title, an instruction and one or more buttons. + The text to display. + The title bar caption of the dialog. + The instruction shown below the main text. + Value that specifies which button or buttons to display. + + + Displays a task dialog that has a message, a title, an instruction, one or more buttons and an icon. + The text to display. + The title bar caption of the dialog. + The instruction shown below the main text. + Value that specifies which button or buttons to display. + The icon to display. + + + Initializes a new Task Dialog instance without text. + + + Initializes a new Task Dialog instance with text. + The main instruction to display. + + + Initializes a new Task Dialog instance with an instruction and a title. + The main instruction to display. + The title of the Task Dialog. + + + Initializes a new Task Dialog instance with an instruction, a title and some content text. + The main instruction to display. + The title of the Task Dialog. + The content text that will be displayes below the main instruction. + + + Initializes a new Task Dialog instance with an instruction, a title, some content text and a specific button. + The main instruction to display. + The title of the Task Dialog. + The content text that will be displayes below the main instruction. + Specifies one or more buttons to be displayed on the bottom of the dialog, instead of the default OK button. + + + Initializes a new Task Dialog instance with an instruction, a title, some content text, a specific button and an icon. + The main instruction to display. + The title of the Task Dialog. + The content text that will be displayes below the main instruction. + Specifies one or more buttons to be displayed on the bottom of the dialog, instead of the default OK button. + The icon to display. + + + Injects a virtual button click. + Numeric id of the clicked button. + + + Injects a virtual radio button click. + Numeric id of the clicked radio button. + + + Injects a virtual checkbox click. + New state of the verification checkbox. + Sets whether the checkbox should have focus after state change. + + + Enables or disables a button of the dialog. + Id of the button whose state will be changed. + New state of the button. + + + Enables or disables a radio button of the dialog. + Id of the radio button whose state will be changed. + New state of the button. + + + Creates a new Task Dialog setup and replaces the existing one. Note that the window will not be + destroyed and that you should keep the existing TaskDialog reference (event handlers will still be + registered). The existing Task Dialog will simply reset and use the options of the new one. + An instance of Task Dialog, whose settings will be copied into the existing dialog. + You may safely destroy the nextDialog instance after use (do not register to events on it). + + + Adds or removes an UAC Shield icon from a button. + Id of the button. + Sets whether to display a Shield icon or not. + + + Sets whether the dialog's progress bar should be in standard or in marquee mode. + True if the progress bar should be displayed in marquee mode (no explicit progress). + + + Sets whether the dialog's progress bar should be in standard or in marquee mode and sets its marquee speed. + True if the progress bar should be displayed in marquee mode (no explicit progress). + Speed of the progress bar in marquee mode. + + + Common native callback for Task Dialogs. Will route events to the user event handler. + TODO: Currently unused, would need complex marshaling of data. + + + Prepares the internal configuration structure. + Allocates some unmanaged memory, must always be followed by a PostConfig() call. + + + Frees the unmanages memory allocated by PreConfig(). + + + Displays the task dialog without an explicit parent. + + + Displays the task dialog with an explicit parent window. + Handle to the dialog's parent window. + + + Displays the task dialog with an explicit parent form. + Instance of the dialog's parent form. + + + Is true if the task dialog is currently displayed. + + + Gets or sets the title of the dialog. + + + Gets or sets the icon of the dialog, from a set of common icons. + + + Gets or sets the icon of the dialog, from a custom Icon instance. + + + Gets or sets the dialog's buttons, from one or more common button types. + + + Gets or sets a set of custom buttons which will be displayed on the dialog. + These buttons can also be shown as Command Links optionally. + + + Gets or sets the integer identificator of the dialog's default button. + + + Gets or sets a set of custom buttons which will be displayed as radio buttons. + + + Gets or sets the identificator of the enabled radio button by default. + + + Gets or sets the text that will be shown next to a verification checkbox. + + + Gets or sets the text displayed on the control that enables the user to expand and collapse the dialog, + when the dialog is in expanded mode. + + + Gets or sets the text displayed on the control that enables the user to expand and collapse the dialog, + when the dialog is in collapsed mode. + + + Gets or sets the icon shown in the dialog's footer, from a set of common icons. + + + Gets or sets the icon shown in the dialog's footer, from a custom Icon instance. + + + Explicitly sets the desiderd width in pixels of the dialog. + Will be set automatically by the task dialog to an optimal size. + + + Gets or Sets the Main Instruction text of the TaskDialog. + Text written in blue and slightly bigger font in Windows Aero. + + + Gets or sets the Content text of the TaskDialog. + Text written with standard font, right below the Main instruction. + + + Gets or Sets the expanded information text, that will be optionally shown + by clicking on the Expand control. + + + Gets or Sets the Footer text. + + + Gets or sets the current Progress bar value. + + + Gets of sets the minimum value allowed by the Progress bar. + + + Gets or sets the maximum value allowed by the Progress bar. + + + Gets or sets the current Progress bar state. + Determines the bar's color and behavior. + + + Enables or disables Hyperlinks in the content (in the form of <A HREF="link">). + + + Gets or sets whether the dialog can be cancelled (ESC, ALT+F4 and X button) even if no Cancel button has been specified. + + + Gets or sets whether Command Link buttons should be used instead of standard custom buttons (doesn't apply to custom buttons, like OK or Cancel). + + + Gets or sets whether Command Link buttons wihtout icon should be used instead of standard custom buttons (doesn't apply to custom buttons, like OK or Cancel). + + + Gets or sets whether the ExpandedInformation should be shown in the Footer area (instead of under the Content text). + + + Gets or sets whether the ExpandedInformation is visible on dialog creation. + + + Gets or sets whether the Verification checkbox should be checked when the dialog is shown. + + + Gets or sets whether a progress bar should be displayed on the dialog. + + + Sets or gets whether the user specified callback (if any) should be called every 200ms. + + + Gets or sets whether the dialog should be positioned centered on the parent window. + + + Enables or disables right to left reading order. + + + Gets or sets whether there should be a selected radio button by default when the dialog is shown. + + + Gets or sets whether the dialog may be minimized or not. + + + Occurs when the Task Dialog is first created and before it is displayed (is sent after Construction event). + + + Occurs when the user clicks a button or a command link. By default the Dialog is closed after the notification. + + + Occurs when the user clicks on a Hyperlink in the Content text. + + + Occurs when a navigation event is raised. + + + Occurs approximately every 200ms if the Task Dialog callback timer is enabled. + + + Occurs when the Task Dialog is destroyed and the handle to the dialog is not valid anymore. + + + Occurs when the user selects a radio button. + + + Occurs when the Task Dialog is constructed and before it is displayed (is sent before Creation event). + + + Occurs when the user switches the state of the Verification Checkbox. + + + Occurs when the user presses F1 when the Task Dialog has focus. + + + Occurs when the user clicks on the expand button of the dialog, before the dialog is expanded. + + + A standard WinForms text box presenting the common Vista "search" interface. + Reacts on user input by raising "SearchStarted" events. + + + + Clean up any resources being used. + + true if managed resources should be disposed; otherwise, false. + + + + Required method for Designer support - do not modify + the contents of this method with the code editor. + + + + Puts the focus on the text box and moves the caret to the end of the text, without selecting it. + + + + Raised when the Text of the search box has changed. + + + + + Raised after an interval after the last user input. + + + + + Raised when the user clicks on the X to cancel the search. + + + + Gets or sets the background Color of the button when the mouse hovers on it. + + + Gets or sets the ForeColor of the control when the search box is active. + + + Gets or sets the BackColor of the control when the search box is active. + + + Gets or sets the ForeColor of the control when the search box is inactive. + + + Gets or sets the BackColor of the control when the search box is inactive. + + + Temporary ForeColor property of the control. You should use InactiveForeColor and ActiveForeColor instead. + + + Temporary BackColor property of the control. You should use InactiveBackColor and ActiveBackColor instead. + + + Gets or sets the text that is shown on top of the text box when the user hasn't entered any text. + + + Gets or sets the font used in the search text box. + Equals to the Font property. + + + Gets or sets the font used to write the "inactivity label" on top of the control when the user hasn't entered any text. + + + + Overall Font property of the control. + Property changes are forwarded to the ActiveFont and InactiveFont property. + + + + Returns true if the user entered some text in the search textbox. + + + + Gets or sets the delay in milliseconds between when the text is edited + and the search event is raised. + + + + + Gets or sets whether the control raises a SearchStarted event after user input. + + + + + Gets or sets whether the control raises a SearchStarted event when the user hits the Enter key. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + Represents a custom button shown on a Task Dialog. + + + Instantiates a new custom button with an ID and a text. + Unique ID that will be returned by the Task Dialog if the button is clicked. + Use values greater than 8 to prevent conflicts with common buttons. + Text label shown on the button. If you enable Command Links, a newline here + separates the upper from the lower string on the button. + + + Instantiates a new custom button with an ID and a text. + Common ID that will be returned by the Task Dialog if the button is clicked. + Text label shown on the button. If you enable Command Links, a newline here + separates the upper from the lower string on the button. + + + Unique ID that will be returned by the Task Dialog if the button is clicked. + + + Text label shown on the button. If you enable Command Links, a newline here + separates the upper from the lower string on the button. + + + + A Label containing some text that will be drawn with glowing border on top of the Glass Sheet effect. + + + + Size of the glow effect around the text. + + + Enables or disables the glow effect around the text. + + + Shadow type. + + + Gets or sets the horizontal text alignment setting. + + + Gets or sets the vertical text alignment setting. + + + Gets or sets whether the text will be laid out on a single line or on multiple lines. + + + Gets or sets whether the text lines over the label's border should be trimmed with an ellipsis. + + + Gets or sets whether the text should break only at the end of a word. + + + Gets or sets whether the text should be trimmed to the last word and an ellipse should be placed at the end of the line. + + + + A horizontal panel which resembles what is used for information and navigation in the Control Panel of Windows 7 and Vista. + + + This control is meant to be used on the left hand side of a form, it creates a graphic border on the right hand side. Also + I have VB code for this control if anyone needs it, just send me an e-mail at bpell@indiana.edu or blakepell@hotmail.com. + + + + + Constructor + + + We are by default setting the background color to Color.Transparent. The reason for this is that a lot of controls that will + be used with this, namingly the Label and LinkLabel default their back color to the color of the panel and for those controls + to display properly on this panel, their BackColor will need to be Color.Transparent (otherwise, they'll display as a black + box). This should help to isolate the developer from having to research this. + + To reduce flicker, especially when glass is enabled, I had to set all three of the below styles. + + + + + + When a control is added, we will check the type and if it meets certain criteria will change some default behaviors of + the control so that it fits our theme by default. The developer can still change this as they desire after it's added. + + + + + + The actual painting of the background of our control. + + + + The colors in use here were extracted from an image of the Control Panel taken from a Windows 7 RC1 installation. + + + + + This procedure will redraw any control, given it's handl as an image on the form. This is necessary if you want to lay this + control on top of the glass surface of an Aero form. + + + + + + Handles incoming Windows Messages. + + + + On the paint event and if the RenderOnGlass is set to true, we will redraw the control as an image directly on + the form. This has a little extra overhead but also provides the ability to lay this control directly on the + glass and have it rendered correctly. + + + + + Whether or not the control needs to be rendered on the Glass surface. + + + This is false by default, it should only be toggled to true if the control needs to lay directly on + the glass surface of the form. + + + + + Adds a handler on the Form that enables the user to move the window around + by clicking on a glass margin (or the title bar, as usual). + + The form that will be controlled. + Margins of the glass sheet. + + Eventual UI elements on the glass sheet will prevent the handler from receiving events + (except the ThemeText control, which manually redirects mouse events to the form). + + + + + Adds a handler on the Form that automatically paints the glass background black + + The form that will be controlled. + Margins of the glass sheet. + + + + + + + Handler will be kept alive by the event references on the form. + As soon as the form is disposed, the handler will be disposed as well. + + + + + + + + Handler will be kept alive by the event references on the form. + As soon as the form is disposed, the handler will be disposed as well. + + + + + The labeled divider provides a Aero styled divider with an optional caption, + similiar to what is seen in the Control Panel dialogs of Windows 7 and Vista. + + + + + Constructor + + + + + The actual painting of the background of our control. + + + + The colors in use here were extracted from an image of the Control Panel taken from a Windows 7 RC1 installation. + + + + + The position of the divider line. + + + The default value is the center position which is consistent on how this type of divider has been used throughout the Windows + 7 and Vista UI's. + + + + + The color of the divider line. + + + + + The text that should be used for the caption. If the caption is set to blank and the divider position is set to center then + a simple divider line will be drawn. + + + After a change is made to the text property we want to invalidate the control so it triggers a new paint message being sent. + + + + + The positions that the divider line can be drawn in + + + + + The divider will be centered after the text caption and will begin drawing after the string. This is the default behavior. + + + + + The divider will be drawn below the text caption. + + + + + A vertical panel which resembles what is used for information and navigation in the Control Panel of Windows 7 and Vista. + + + This control is meant to be used on the left hand side of a form, it creates a graphic border on the right hand side. Also + I have VB code for this control if anyone needs it, just send me an e-mail at bpell@indiana.edu or blakepell@hotmail.com. + + + + + Constructor + + + We are by default setting the background color to Color.Transparent. The reason for this is that a lot of controls that will + be used with this, namingly the Label and LinkLabel default their back color to the color of the panel and for those controls + to display properly on this panel, their BackColor will need to be Color.Transparent (otherwise, they'll display as a black + box). This should help to isolate the developer from having to research this. + + To reduce flicker, especially when glass is enabled, I had to set all three of the below styles. + + + + + + When a control is added, we will check the type and if it meets certain criteria will change some default behaviors of + the control so that it fits our theme by default. The developer can still change this as they desire after it's added. + + + + + + The actual painting of the background of our control. + + + + The colors in use here were extracted from an image of the Control Panel taken from a Windows 7 RC1 installation. + + + + + This procedure will redraw any control, given it's handl as an image on the form. This is necessary if you want to lay this + control on top of the glass surface of an Aero form. + + + + + + Handles incoming Windows Messages. + + + + On the paint event and if the RenderOnGlass is set to true, we will redraw the control as an image directly on + the form. This has a little extra overhead but also provides the ability to lay this control directly on the + glass and have it rendered correctly. + + + + + Whether or not the control needs to be rendered on the Glass surface. + + + This is false by default, it should only be toggled to true if the control needs to lay directly on + the glass surface of the form. + + + + Handle to a DWM Thumbnail. + + + Updates the thumbnail's display settings. + Drawing region on destination window. + Origin region from source window. + Opacity. 0 is transparent, 255 opaque. + Visibility flag. + If true, only the client area of the window will be rendered. Otherwise, the borders will be be rendered as well. + + + Updates the thumbnail's display settings. + Drawing region on destination window. + Opacity. 0 is transparent, 255 opaque. + Visibility flag. + If true, only the client area of the window will be rendered. Otherwise, the borders will be be rendered as well. + + + Returns true if the handle is valid, false if the handle has been closed or hasn't been initialized. + + + Sets the thumbnail opacity value, from 0 to 255 (opaque). + + + Sets whether only the client area of the thumbnailed window should be shown or + the entire window area. + + + Area in the destination window on which the thumbnail should be drawn. + + + Region of the source window that should be drawn. + + + Sets whether the thumbnail should be drawn or not. + + + Gets the thumbnail's original size. + + + Main DWM class, provides Thumbnail registration, glass sheet effect and blur behind. + + + Registers a thumbnail to be drawn on a Windows Form. + The thumbnail will not be drawn until you update the thumbnail's properties calling Update(). + The Windows Form instance on which to draw the thumbnail. + The handle (HWND) of the window that has to be drawn. + A Thumbnail instance, needed to unregister and to update properties. + + + Registers a thumbnail to be drawn on a window. + The thumbnail will not be drawn until you update the thumbnail's properties calling Update(). + The handle (HWND) of the window on which the thumbnail will be drawn. + The handle (HWND) of the window that has to be drawn. + A Thumbnail instance, needed to unregister and to update properties. + + + Unregisters the thumbnail handle. + The handle is unvalid after the call and should not be used again. + A handle to a registered thumbnail. + + + Enable the Aero "Blur Behind" effect on the whole client area. Background must be black. + + + Enable the Aero "Blur Behind" effect on the whole client area. Background must be black. + + + + Enable the Aero "Blur Behind" effect on a specific region. Background of the region must be black. + + + Disables the Aero "Blur Behind" effect. + + + Extends the Aero "Glass Frame" into the client area. Background must be black. + + + Extends the Aero "Glass Frame" into the client area. Background must be black. + + + Extends the Aero "Glass Frame" to the whole client area ("Glass Sheet" effect). Background must be black. + + + Extends the Aero "Glass Frame" to the whole client area ("Glass Sheet" effect). Background must be black. + + + Disables the Aero "Glass Frame". + + + Disables the Aero "Glass Frame". + + + + Sets a window's Flip 3D policy. + + Form whose policy is to be set. + Desired Flip 3D policy. + Is ignored on OSs that do not support Aero. + + + + Disallows Aero Peek on a window (or allows it). + + Form whose Aero Peek preview should be disabled. + True if Aero Peek should be disabled for the window. + Is ignored on OSs that do not support Aero Peek. + + + + Sets a window's state in order to exclude (or include) it in Aero Peek. + + Form whose Aero Peek exclusion state is to be set. + Set to true to exlude the window from Aero Peek. + Is ignored on OSs that do not support Aero Peek. + + + + Sets a window's state in order to exclude (or include) it in Aero Peek. + + Form whose Aero Peek exclusion state is to be set. + Set to true to exlude the window from Aero Peek. + Is ignored on OSs that do not support Aero Peek. + + + Returns the active windows on the current thread. + + + Sets the origin of the thumbnail and shows the thumbnail on the control. + The Form instance that will be thumbnailed. + True if the control should automatically update itself in case the thumbnailed + form changes size or is closed. + + + Forces and update of the thumbnail. + Use this method if you know that the thumbnailed window has been resized and the thumbnail control should react to these changes. + + + + Static class providing information about the current support for Vista-only features. + + + + + Gets whether the running operating system is Windows Vista or a more recent version. + + + + + Gets whether the running operating system is Windows Seven or a more recent version. + + + + + Gets whether the running operating system is Windows 8 or a more recent version. + + + + Is true if the DWM composition engine is currently enabled. + + + + Form that automatically handles glass margins and mouse dragging. + + + + + Construct a new form without glass margins. + + + + Gets or sets the glass margins of the form. + This property should be used when setting the margins from code. + + + Gets or sets the glass margins of the form. + This property should be used when setting the margins through the designer. + + + Gets or sets whether mouse dragging should be handled automatically. + + + Gets or sets whether the extended glass margin is enabled or not. + + + + Gets or sets whether the window title and icon should be hidden. + + + The window caption will still be visible, but title text and icon will not be. + A form with a hidden title will look like an Explorer window on Windows Vista or Windows 7. + + + + + Gets or sets whether the window caption should be hidden altogether. + + + Should be set before handle creation. + + + + + Applies a glow on the themed text. + + + + + Default glow size. + + + + + Glow size used commonly by Office 2007 in titles. + + + + + Precise glow effect. + + + + + Instantiates a new glow effect for themed text. + + Size of the glow effect. + + + + Gets or sets the size of the glow effect. + + + + Direct Task Dialog call. + + + Indirect Task Dialog call. Allows complex dialogs with interaction logic (via callback). + + + The Task Dialog config structure. + + + Flags used in TaskDialogConfig struct. + From CommCtrl.h. + + + Notifications returned by Task Dialogs to the callback. + From CommCtrl.h. + + + Messages that can be sent to Task Dialogs. + From CommCtrl.h. + + + + Determines a window's Flip 3D policy. + + + + + Default Flip 3D behavior. + + + + + Excludes the window from Flip 3D and hides it behind the animation. + + + + + Excludes the window from Flip 3D and shows it above the animation. + + + + Common Task Dialog icons. Determine the look of the main instruction. + + + Class that aggregates the results of an "indirect" Task Dialog. + + + Results returned by Task Dialogs when closed by the user. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Common Controls library version 6.0 not loaded. Must run on Vista and must provide a manifest.. + + + + + Looks up a localized string similar to Desktop composition is not enabled.. + + + + + Looks up a localized string similar to Desktop composition is not supported by operating system.. + + + + + Looks up a localized string similar to Unable to get thumbnail's original size.. + + + + + Looks up a localized string similar to Unable to update thumbnail properties.. + + + + + Looks up a localized string similar to Source and target windows cannot be the same.. + + + + + Looks up a localized string similar to Native call to {0} failed.. + + + + + Looks up a localized string similar to Failed to create TaskDialog.. + + + + Gets or sets the cue text that is displayed on the TextBox control. + + + Gets or sets whether the Cue text should be displyed even when the control has keybord focus. + If true, the Cue text will disappear as soon as the user starts typing. + + + diff --git a/OnTopReplica.sln b/OnTopReplica.sln new file mode 100644 index 0000000..1c732a8 --- /dev/null +++ b/OnTopReplica.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 11.00 +# Visual C# Express 2010 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OnTopReplica", "OnTopReplica\OnTopReplica.csproj", "{E626BD6E-BF38-4EB7-A128-5CA6F40EF557}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E626BD6E-BF38-4EB7-A128-5CA6F40EF557}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E626BD6E-BF38-4EB7-A128-5CA6F40EF557}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E626BD6E-BF38-4EB7-A128-5CA6F40EF557}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E626BD6E-BF38-4EB7-A128-5CA6F40EF557}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/OnTopReplica/AspectRatioForm.cs b/OnTopReplica/AspectRatioForm.cs new file mode 100644 index 0000000..9701e3c --- /dev/null +++ b/OnTopReplica/AspectRatioForm.cs @@ -0,0 +1,238 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Windows.Forms; +using OnTopReplica.Native; +using WindowsFormsAero.Dwm.Helpers; + +namespace OnTopReplica { + + /// + /// Form that automatically keeps a certain aspect ratio and resizes without flickering. + /// + public class AspectRatioForm : GlassForm { + + bool _keepAspectRatio = true; + + /// + /// Gets or sets whether the form should keep its aspect ratio. + /// + /// + /// Refreshes the window's size if set to true. + /// + [Description("Enables fixed aspect ratio for this form."), Category("Appearance"), DefaultValue(true)] + public bool KeepAspectRatio { + get { + return _keepAspectRatio; + } + set { + _keepAspectRatio = value; + + if (value) + RefreshAspectRatio(); + } + } + + double _aspectRatio = 1.0; + + /// + /// Gets or sets the form's aspect ratio that will be kept automatically when resizing. + /// + [Description("Determines this form's fixed aspect ratio."), Category("Appearance"), DefaultValue(1.0)] + public double AspectRatio { + get { + return _aspectRatio; + } + set { + if (value <= 0.0 || Double.IsInfinity(value)) + return; + + _aspectRatio = value; + } + } + + Padding _extraPadding; + + /// + /// Gets or sets some additional internal padding of the form that is ignored when keeping the aspect ratio. + /// + [Description("Sets some padding inside the form's client area that is ignored when keeping the aspect ratio."), + Category("Appearance")] + public Padding ExtraPadding { + get { + return _extraPadding; + } + set { + _extraPadding = value; + + if(KeepAspectRatio) + RefreshAspectRatio(); + } + } + + /// + /// Forces the form to update its height based on the current aspect ratio setting. + /// + public void RefreshAspectRatio() { + int newWidth = ClientSize.Width; + int newHeight = (int)((ClientSize.Width - ExtraPadding.Horizontal) / AspectRatio) + ExtraPadding.Vertical; + + //Adapt height if it doesn't respect the form's minimum size + Size clientMinimumSize = FromSizeToClientSize(MinimumSize); + if (newHeight < clientMinimumSize.Height) { + newHeight = clientMinimumSize.Height; + newWidth = (int)((newHeight - ExtraPadding.Vertical) * AspectRatio) + ExtraPadding.Horizontal; + } + + //Adapt height if it exceeds the screen's height + var workingArea = Screen.GetWorkingArea(this); + if (newHeight >= workingArea.Height) { + newHeight = workingArea.Height; + newWidth = (int)((newHeight - ExtraPadding.Vertical) * AspectRatio) + ExtraPadding.Horizontal; + } + + //Update size + ClientSize = new Size(newWidth, newHeight); + + //Move form vertically to adapt to new size + //REMOVED: allows the window to correctly be restored slightly off screen + /*if (Location.Y + Size.Height > workingArea.Y + workingArea.Height) { + int offsetY = (workingArea.Y + workingArea.Height) - (Location.Y + Size.Height); + Location = new Point(Location.X, Location.Y - offsetY); + }*/ + } + + /// + /// Adjusts the size of the form by a pixel increment while keeping its aspect ratio. + /// + /// Change of size in pixels. + public void AdjustSize(int pixelOffset) { + Size origSize = Size; + + //Resize to new width (clamped to max allowed size and minimum form size) + int newWidth = Math.Max(Math.Min(origSize.Width + pixelOffset, + SystemInformation.MaxWindowTrackSize.Width), + MinimumSize.Width); + + //Determine new height while keeping aspect ratio + int newHeight = (int)((newWidth - ExtraPadding.Horizontal - clientSizeConversionWidth) / AspectRatio) + ExtraPadding.Vertical + clientSizeConversionHeight; + + //Apply and move form to recenter + Size = new Size(newWidth, newHeight); + int deltaX = Size.Width - origSize.Width; + int deltaY = Size.Height - origSize.Height; + Location = new System.Drawing.Point(Location.X - (deltaX / 2), Location.Y - (deltaY / 2)); + } + + /// + /// Updates the aspect ratio of the form and optionally forces a refresh. + /// + /// Size from which aspect ratio should be computed. + /// True if the size of the form should be refreshed to match the new aspect ratio. + public void SetAspectRatio(Size aspectRatioSource, bool forceRefresh) { + AspectRatio = ((double)aspectRatioSource.Width / (double)aspectRatioSource.Height); + _keepAspectRatio = true; + +#if DEBUG + System.Diagnostics.Trace.WriteLine(string.Format("Setting aspect ratio of {0} (for {1}).", AspectRatio, aspectRatioSource)); +#endif + + if (forceRefresh) { + RefreshAspectRatio(); + } + } + + #region Event overriding + + protected override void OnResizeEnd(EventArgs e) { + base.OnResizeEnd(e); + + //Ensure that the ClientSize of the form is always respected + //(not ensured by the WM_SIZING message alone because of rounding errors and the chrome space) + if (KeepAspectRatio) { + var newHeight = (int)Math.Round(((ClientSize.Width - ExtraPadding.Horizontal) / AspectRatio) + ExtraPadding.Vertical); + ClientSize = new Size(ClientSize.Width, newHeight); + } + } + + /// + /// Override WM_SIZING message to restrict resizing. + /// Taken from: http://www.vcskicks.com/maintain-aspect-ratio.php + /// Improved with code from: http://stoyanoff.info/blog/2010/06/27/resizing-forms-while-keeping-aspect-ratio/ + /// + protected override void WndProc(ref Message m) { + if (KeepAspectRatio && m.Msg == WM.SIZING) { + var rc = (Native.NRectangle)Marshal.PtrToStructure(m.LParam, typeof(Native.NRectangle)); + int res = m.WParam.ToInt32(); + + int width = (rc.Right - rc.Left) - clientSizeConversionWidth - ExtraPadding.Horizontal; + int height = (rc.Bottom - rc.Top) - clientSizeConversionHeight - ExtraPadding.Vertical; + + if (res == WMSZ.LEFT || res == WMSZ.RIGHT) { + //Left or right resize, adjust top and bottom + int targetHeight = (int)(width / AspectRatio); + int diffHeight = height - targetHeight; + + rc.Top += (int)(diffHeight / 2.0); + rc.Bottom = rc.Top + targetHeight + ExtraPadding.Vertical + clientSizeConversionHeight; + } + else if (res == WMSZ.TOP || res == WMSZ.BOTTOM) { + //Up or down resize, adjust left and right + int targetWidth = (int)(height * AspectRatio); + int diffWidth = width - targetWidth; + + rc.Left += (int)(diffWidth / 2.0); + rc.Right = rc.Left + targetWidth + ExtraPadding.Horizontal + clientSizeConversionWidth; + } + else if (res == WMSZ.RIGHT + WMSZ.BOTTOM || res == WMSZ.LEFT + WMSZ.BOTTOM) { + //Lower corner resize, adjust bottom + rc.Bottom = rc.Top + (int)(width / AspectRatio) + ExtraPadding.Vertical + clientSizeConversionHeight; + } + else if (res == WMSZ.LEFT + WMSZ.TOP || res == WMSZ.RIGHT + WMSZ.TOP) { + //Upper corner resize, adjust top + rc.Top = rc.Bottom - (int)(width / AspectRatio) - ExtraPadding.Vertical - clientSizeConversionHeight; + } + + Marshal.StructureToPtr(rc, m.LParam, false); + } + + base.WndProc(ref m); + } + + #endregion + + #region ClientSize/Size conversion helpers + + int clientSizeConversionWidth, clientSizeConversionHeight; + + /// + /// Converts a client size measurement to a window size measurement. + /// + /// Size of the window's client area. + /// Size of the whole window. + public Size FromClientSizeToSize(Size clientSize) { + return new Size(clientSize.Width + clientSizeConversionWidth, clientSize.Height + clientSizeConversionHeight); + } + + /// + /// Converts a window size measurement to a client size measurement. + /// + /// Size of the whole window. + /// Size of the window's client area. + public Size FromSizeToClientSize(Size size) { + return new Size(size.Width - clientSizeConversionWidth, size.Height - clientSizeConversionHeight); + } + + protected override void OnShown(EventArgs e) { + base.OnShown(e); + + clientSizeConversionWidth = Size.Width - ClientSize.Width; + clientSizeConversionHeight = Size.Height - ClientSize.Height; + } + + #endregion + + } + +} diff --git a/OnTopReplica/Assets/25.png b/OnTopReplica/Assets/25.png new file mode 100644 index 0000000..e98a5dd Binary files /dev/null and b/OnTopReplica/Assets/25.png differ diff --git a/OnTopReplica/Assets/arrow_down.png b/OnTopReplica/Assets/arrow_down.png new file mode 100644 index 0000000..bfbfe35 Binary files /dev/null and b/OnTopReplica/Assets/arrow_down.png differ diff --git a/OnTopReplica/Assets/arrow_up.png b/OnTopReplica/Assets/arrow_up.png new file mode 100644 index 0000000..b34489e Binary files /dev/null and b/OnTopReplica/Assets/arrow_up.png differ diff --git a/OnTopReplica/Assets/back.png b/OnTopReplica/Assets/back.png new file mode 100644 index 0000000..d5cfc9f Binary files /dev/null and b/OnTopReplica/Assets/back.png differ diff --git a/OnTopReplica/Assets/clickforwarding.png b/OnTopReplica/Assets/clickforwarding.png new file mode 100644 index 0000000..66d9bc8 Binary files /dev/null and b/OnTopReplica/Assets/clickforwarding.png differ diff --git a/OnTopReplica/Assets/component.png b/OnTopReplica/Assets/component.png new file mode 100644 index 0000000..c179614 Binary files /dev/null and b/OnTopReplica/Assets/component.png differ diff --git a/OnTopReplica/Assets/desktop.png b/OnTopReplica/Assets/desktop.png new file mode 100644 index 0000000..1f6a7f4 Binary files /dev/null and b/OnTopReplica/Assets/desktop.png differ diff --git a/OnTopReplica/Assets/empty-window.ico b/OnTopReplica/Assets/empty-window.ico new file mode 100644 index 0000000..ca5edce Binary files /dev/null and b/OnTopReplica/Assets/empty-window.ico differ diff --git a/OnTopReplica/Assets/flag_czech.png b/OnTopReplica/Assets/flag_czech.png new file mode 100644 index 0000000..8308ed8 Binary files /dev/null and b/OnTopReplica/Assets/flag_czech.png differ diff --git a/OnTopReplica/Assets/flag_danish.png b/OnTopReplica/Assets/flag_danish.png new file mode 100644 index 0000000..d39d4c1 Binary files /dev/null and b/OnTopReplica/Assets/flag_danish.png differ diff --git a/OnTopReplica/Assets/flag_germany.png b/OnTopReplica/Assets/flag_germany.png new file mode 100644 index 0000000..5557fa9 Binary files /dev/null and b/OnTopReplica/Assets/flag_germany.png differ diff --git a/OnTopReplica/Assets/flag_ita.png b/OnTopReplica/Assets/flag_ita.png new file mode 100644 index 0000000..6254b92 Binary files /dev/null and b/OnTopReplica/Assets/flag_ita.png differ diff --git a/OnTopReplica/Assets/flag_poland.png b/OnTopReplica/Assets/flag_poland.png new file mode 100644 index 0000000..9a7d5f6 Binary files /dev/null and b/OnTopReplica/Assets/flag_poland.png differ diff --git a/OnTopReplica/Assets/flag_spanish.png b/OnTopReplica/Assets/flag_spanish.png new file mode 100644 index 0000000..4463433 Binary files /dev/null and b/OnTopReplica/Assets/flag_spanish.png differ diff --git a/OnTopReplica/Assets/flag_usa.png b/OnTopReplica/Assets/flag_usa.png new file mode 100644 index 0000000..aed8f11 Binary files /dev/null and b/OnTopReplica/Assets/flag_usa.png differ diff --git a/OnTopReplica/Assets/flags.pdn b/OnTopReplica/Assets/flags.pdn new file mode 100644 index 0000000..9e53b80 Binary files /dev/null and b/OnTopReplica/Assets/flags.pdn differ diff --git a/OnTopReplica/Assets/fullscreen.png b/OnTopReplica/Assets/fullscreen.png new file mode 100644 index 0000000..b1f8a2b Binary files /dev/null and b/OnTopReplica/Assets/fullscreen.png differ diff --git a/OnTopReplica/Assets/groupmode.png b/OnTopReplica/Assets/groupmode.png new file mode 100644 index 0000000..39afe5a Binary files /dev/null and b/OnTopReplica/Assets/groupmode.png differ diff --git a/OnTopReplica/Assets/icon-new-red.ico b/OnTopReplica/Assets/icon-new-red.ico new file mode 100644 index 0000000..c5549f8 Binary files /dev/null and b/OnTopReplica/Assets/icon-new-red.ico differ diff --git a/OnTopReplica/Assets/icon-new.ico b/OnTopReplica/Assets/icon-new.ico new file mode 100644 index 0000000..1836299 Binary files /dev/null and b/OnTopReplica/Assets/icon-new.ico differ diff --git a/OnTopReplica/Assets/icon.ico b/OnTopReplica/Assets/icon.ico new file mode 100644 index 0000000..791a5e2 Binary files /dev/null and b/OnTopReplica/Assets/icon.ico differ diff --git a/OnTopReplica/Assets/icon.png b/OnTopReplica/Assets/icon.png new file mode 100644 index 0000000..d87244e Binary files /dev/null and b/OnTopReplica/Assets/icon.png differ diff --git a/OnTopReplica/Assets/list.png b/OnTopReplica/Assets/list.png new file mode 100644 index 0000000..33b1ff0 Binary files /dev/null and b/OnTopReplica/Assets/list.png differ diff --git a/OnTopReplica/Assets/newicon.png b/OnTopReplica/Assets/newicon.png new file mode 100644 index 0000000..37017ad Binary files /dev/null and b/OnTopReplica/Assets/newicon.png differ diff --git a/OnTopReplica/Assets/pos_bottomleft.pdn b/OnTopReplica/Assets/pos_bottomleft.pdn new file mode 100644 index 0000000..6658542 Binary files /dev/null and b/OnTopReplica/Assets/pos_bottomleft.pdn differ diff --git a/OnTopReplica/Assets/pos_bottomleft.png b/OnTopReplica/Assets/pos_bottomleft.png new file mode 100644 index 0000000..cf10183 Binary files /dev/null and b/OnTopReplica/Assets/pos_bottomleft.png differ diff --git a/OnTopReplica/Assets/pos_bottomright.png b/OnTopReplica/Assets/pos_bottomright.png new file mode 100644 index 0000000..96ba618 Binary files /dev/null and b/OnTopReplica/Assets/pos_bottomright.png differ diff --git a/OnTopReplica/Assets/pos_center.png b/OnTopReplica/Assets/pos_center.png new file mode 100644 index 0000000..d672a20 Binary files /dev/null and b/OnTopReplica/Assets/pos_center.png differ diff --git a/OnTopReplica/Assets/pos_null.png b/OnTopReplica/Assets/pos_null.png new file mode 100644 index 0000000..ea30195 Binary files /dev/null and b/OnTopReplica/Assets/pos_null.png differ diff --git a/OnTopReplica/Assets/pos_topleft.png b/OnTopReplica/Assets/pos_topleft.png new file mode 100644 index 0000000..184d202 Binary files /dev/null and b/OnTopReplica/Assets/pos_topleft.png differ diff --git a/OnTopReplica/Assets/pos_topright.png b/OnTopReplica/Assets/pos_topright.png new file mode 100644 index 0000000..1e1365f Binary files /dev/null and b/OnTopReplica/Assets/pos_topright.png differ diff --git a/OnTopReplica/Assets/reduce.png b/OnTopReplica/Assets/reduce.png new file mode 100644 index 0000000..7705718 Binary files /dev/null and b/OnTopReplica/Assets/reduce.png differ diff --git a/OnTopReplica/Assets/regions.png b/OnTopReplica/Assets/regions.png new file mode 100644 index 0000000..b5be09e Binary files /dev/null and b/OnTopReplica/Assets/regions.png differ diff --git a/OnTopReplica/Assets/regions_new.png b/OnTopReplica/Assets/regions_new.png new file mode 100644 index 0000000..25947b9 Binary files /dev/null and b/OnTopReplica/Assets/regions_new.png differ diff --git a/OnTopReplica/Assets/screenshot-icon.ico b/OnTopReplica/Assets/screenshot-icon.ico new file mode 100644 index 0000000..3251e44 Binary files /dev/null and b/OnTopReplica/Assets/screenshot-icon.ico differ diff --git a/OnTopReplica/Assets/window16.png b/OnTopReplica/Assets/window16.png new file mode 100644 index 0000000..0d594cb Binary files /dev/null and b/OnTopReplica/Assets/window16.png differ diff --git a/OnTopReplica/Assets/window_border16.png b/OnTopReplica/Assets/window_border16.png new file mode 100644 index 0000000..b9bc0b0 Binary files /dev/null and b/OnTopReplica/Assets/window_border16.png differ diff --git a/OnTopReplica/Assets/window_multiple.pdn b/OnTopReplica/Assets/window_multiple.pdn new file mode 100644 index 0000000..2641e32 Binary files /dev/null and b/OnTopReplica/Assets/window_multiple.pdn differ diff --git a/OnTopReplica/Assets/window_multiple16.ico b/OnTopReplica/Assets/window_multiple16.ico new file mode 100644 index 0000000..6c48346 Binary files /dev/null and b/OnTopReplica/Assets/window_multiple16.ico differ diff --git a/OnTopReplica/Assets/window_multiple16.png b/OnTopReplica/Assets/window_multiple16.png new file mode 100644 index 0000000..776f692 Binary files /dev/null and b/OnTopReplica/Assets/window_multiple16.png differ diff --git a/OnTopReplica/Assets/window_multiple48.png b/OnTopReplica/Assets/window_multiple48.png new file mode 100644 index 0000000..ddbb96d Binary files /dev/null and b/OnTopReplica/Assets/window_multiple48.png differ diff --git a/OnTopReplica/Assets/window_opacity16.png b/OnTopReplica/Assets/window_opacity16.png new file mode 100644 index 0000000..1d865b9 Binary files /dev/null and b/OnTopReplica/Assets/window_opacity16.png differ diff --git a/OnTopReplica/Assets/window_opacity_new.png b/OnTopReplica/Assets/window_opacity_new.png new file mode 100644 index 0000000..1a334bd Binary files /dev/null and b/OnTopReplica/Assets/window_opacity_new.png differ diff --git a/OnTopReplica/Assets/window_switch.pdn b/OnTopReplica/Assets/window_switch.pdn new file mode 100644 index 0000000..72bcc91 Binary files /dev/null and b/OnTopReplica/Assets/window_switch.pdn differ diff --git a/OnTopReplica/Assets/window_switch.png b/OnTopReplica/Assets/window_switch.png new file mode 100644 index 0000000..987ef8e Binary files /dev/null and b/OnTopReplica/Assets/window_switch.png differ diff --git a/OnTopReplica/Assets/windows.png b/OnTopReplica/Assets/windows.png new file mode 100644 index 0000000..2b9a717 Binary files /dev/null and b/OnTopReplica/Assets/windows.png differ diff --git a/OnTopReplica/Assets/x-oblique.png b/OnTopReplica/Assets/x-oblique.png new file mode 100644 index 0000000..198981a Binary files /dev/null and b/OnTopReplica/Assets/x-oblique.png differ diff --git a/OnTopReplica/Assets/xiao_add.png b/OnTopReplica/Assets/xiao_add.png new file mode 100644 index 0000000..36b1f03 Binary files /dev/null and b/OnTopReplica/Assets/xiao_add.png differ diff --git a/OnTopReplica/Assets/xiao_arrow.png b/OnTopReplica/Assets/xiao_arrow.png new file mode 100644 index 0000000..ca39d48 Binary files /dev/null and b/OnTopReplica/Assets/xiao_arrow.png differ diff --git a/OnTopReplica/Assets/xiao_delete.png b/OnTopReplica/Assets/xiao_delete.png new file mode 100644 index 0000000..4f7e3c0 Binary files /dev/null and b/OnTopReplica/Assets/xiao_delete.png differ diff --git a/OnTopReplica/Assets/xiao_down.png b/OnTopReplica/Assets/xiao_down.png new file mode 100644 index 0000000..fdf7a5d Binary files /dev/null and b/OnTopReplica/Assets/xiao_down.png differ diff --git a/OnTopReplica/Assets/xiao_help.png b/OnTopReplica/Assets/xiao_help.png new file mode 100644 index 0000000..df861f9 Binary files /dev/null and b/OnTopReplica/Assets/xiao_help.png differ diff --git a/OnTopReplica/Assets/xiao_ok.png b/OnTopReplica/Assets/xiao_ok.png new file mode 100644 index 0000000..fc5029a Binary files /dev/null and b/OnTopReplica/Assets/xiao_ok.png differ diff --git a/OnTopReplica/Assets/xiao_up.png b/OnTopReplica/Assets/xiao_up.png new file mode 100644 index 0000000..4a32677 Binary files /dev/null and b/OnTopReplica/Assets/xiao_up.png differ diff --git a/OnTopReplica/Assets/xiao_wrench.png b/OnTopReplica/Assets/xiao_wrench.png new file mode 100644 index 0000000..b15bcf0 Binary files /dev/null and b/OnTopReplica/Assets/xiao_wrench.png differ diff --git a/OnTopReplica/CREDITS.txt b/OnTopReplica/CREDITS.txt new file mode 100644 index 0000000..36c6de9 --- /dev/null +++ b/OnTopReplica/CREDITS.txt @@ -0,0 +1,17 @@ +OnTopReplica credits +-------------------- + +This application was inspired by Switcher (http://insentient.net) and other +DWM based application. + +All Aero controls are part of the open-source WindowsFormsAero +(http://windowsformsaero.codeplex.com) library for .NET. + +Some DWM example code has ben taken from user Ookii (http://www.ookii.org) on +Channel 9 MSDN. + +The NativeToolstripRenderer class has been taken from asztal.net +(http://wp.asztal.net/2007/12/vista-style-menus-in-dotnet). + +Some of the icons used by OnTopReplica have been taken from VistaICO.com and +the Xiao icon set. diff --git a/OnTopReplica/CloneClickEventArgs.cs b/OnTopReplica/CloneClickEventArgs.cs new file mode 100644 index 0000000..2c137fe --- /dev/null +++ b/OnTopReplica/CloneClickEventArgs.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Windows.Forms; + +namespace OnTopReplica { + /// + /// EventArgs structure for clicks on a cloned window. + /// + public class CloneClickEventArgs : EventArgs { + + public Point ClientClickLocation { get; set; } + + public bool IsDoubleClick { get; set; } + + public MouseButtons Buttons { get; set; } + + public CloneClickEventArgs(Point location, MouseButtons buttons) { + ClientClickLocation = location; + Buttons = buttons; + IsDoubleClick = false; + } + + public CloneClickEventArgs(Point location, MouseButtons buttons, bool doubleClick) { + ClientClickLocation = location; + Buttons = buttons; + IsDoubleClick = doubleClick; + } + + } +} diff --git a/OnTopReplica/CloseRequestEventArgs.cs b/OnTopReplica/CloseRequestEventArgs.cs new file mode 100644 index 0000000..377ce99 --- /dev/null +++ b/OnTopReplica/CloseRequestEventArgs.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; + +namespace OnTopReplica { + public class CloseRequestEventArgs : EventArgs { + + public WindowHandle LastWindowHandle { get; set; } + + public Rectangle? LastRegion { get; set; } + + } +} diff --git a/OnTopReplica/FocusedTextBox.cs b/OnTopReplica/FocusedTextBox.cs new file mode 100644 index 0000000..b2a2cc6 --- /dev/null +++ b/OnTopReplica/FocusedTextBox.cs @@ -0,0 +1,70 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using WindowsFormsAero; +using System.Windows.Forms; + +namespace OnTopReplica { + + class FocusedTextBox : System.Windows.Forms.TextBox { + + protected override bool IsInputChar(char charCode) { + if (charCode == '\n' || charCode == '\r') + return true; + + return base.IsInputChar(charCode); + } + + protected override void OnKeyUp(KeyEventArgs e) { + if (e.KeyCode == Keys.Return) { + if(!string.IsNullOrEmpty(Text)) + OnConfirmInput(); + + e.Handled = true; + e.SuppressKeyPress = true; + } + else if (e.KeyCode == Keys.Escape) { + OnAbortInput(); + + e.Handled = true; + e.SuppressKeyPress = true; + } + + //Console.WriteLine("{0} ({1})", e.KeyCode, e.KeyValue); + + base.OnKeyUp(e); + } + + //List of characters to ignore on KeyPress events (because they generate bell rings) + readonly char[] IgnoreChars = new char[] { + (char)27, (char)13 + }; + + protected override void OnKeyPress(KeyPressEventArgs e) { + if (IgnoreChars.Contains(e.KeyChar)) { + e.Handled = true; + } + + base.OnKeyPress(e); + } + + public event EventHandler ConfirmInput; + + protected virtual void OnConfirmInput() { + var evt = ConfirmInput; + if (evt != null) + evt(this, EventArgs.Empty); + } + + public event EventHandler AbortInput; + + protected virtual void OnAbortInput() { + var evt = AbortInput; + if (evt != null) + evt(this, EventArgs.Empty); + } + + } + +} diff --git a/OnTopReplica/GeometryExtensions.cs b/OnTopReplica/GeometryExtensions.cs new file mode 100644 index 0000000..5f61feb --- /dev/null +++ b/OnTopReplica/GeometryExtensions.cs @@ -0,0 +1,74 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Windows.Forms; + +namespace OnTopReplica { + + /// + /// Common geometry extension methods. + /// + static class GeometryExtensions { + + /// + /// Returns the difference (offset vector) between two points. + /// + public static Point Difference(this Point a, Point b) { + return new Point(a.X - b.X, a.Y - b.Y); + } + + /// + /// Expands a size value by a padding distance. + /// + public static Size Expand(this Size size, Padding padding) { + return new Size(size.Width + padding.Horizontal, size.Height + padding.Vertical); + } + + /// + /// Expands a size value by a size distance. + /// + public static Size Expand(this Size size, Size expandSize) { + return new Size(size.Width + expandSize.Width, size.Height + expandSize.Height); + } + + /// + /// Computes the difference between two size values. + /// + public static Size Difference(this Size a, Size b) { + return new Size(a.Width - b.Width, a.Height - b.Height); + } + + /// + /// Ensures that the minimum size of a control respects a minimum + /// client size area. + /// + /// Control whose MinimumSize should be altered. + /// Minimum client size value to ensure. + public static void EnsureMinimumClientSize(this Control ctrl, Size minimumClientSize) { + Size offset = ctrl.Size.Difference(ctrl.ClientSize); + ctrl.MinimumSize = minimumClientSize.Expand(offset); + } + + /// + /// Attempts to fit a size structure to another fixed destination size, by maintaining + /// the original aspect ratio. + /// + public static Size Fit(this Size sourceSize, Size destinationSize) { + double sourceRatio = (double)sourceSize.Width / (double)sourceSize.Height; + double clientRatio = (double)destinationSize.Width / (double)destinationSize.Height; + + Size ret; + if (sourceRatio >= clientRatio) { + ret = new Size(destinationSize.Width, (int)((double)destinationSize.Width / sourceRatio)); + } + else { + ret = new Size((int)((double)destinationSize.Height * sourceRatio), destinationSize.Height); + } + + return ret; + } + + } + +} diff --git a/OnTopReplica/HotKeyTextBox.cs b/OnTopReplica/HotKeyTextBox.cs new file mode 100644 index 0000000..9abcead --- /dev/null +++ b/OnTopReplica/HotKeyTextBox.cs @@ -0,0 +1,56 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica { + + class HotKeyTextBox : TextBox { + + protected override void OnCreateControl() { + ReadOnly = true; + + base.OnCreateControl(); + } + + readonly Keys[] IgnoredKeys = new Keys[] { + Keys.ControlKey, + Keys.Control, + Keys.Alt, + Keys.Menu, + Keys.ShiftKey, + Keys.Shift, + Keys.LWin, + Keys.RWin + }; + + readonly Keys[] CancelKeys = new Keys[] { + Keys.Back, + Keys.Escape + }; + + protected override void OnKeyUp(KeyEventArgs e) { + if (CancelKeys.Contains(e.KeyCode)) { + Text = string.Empty; + } + else if (!IgnoredKeys.Contains(e.KeyCode)) { + var sb = new StringBuilder(); + if (e.Control) + sb.Append("[CTRL]+"); + if (e.Alt) + sb.Append("[ALT]+"); + if (e.Shift) + sb.Append("[SHIFT]+"); + sb.Append(e.KeyCode.ToString()); + + Text = sb.ToString(); + } + + e.Handled = true; + base.OnKeyUp(e); + } + + } + +} diff --git a/OnTopReplica/IMessagePumpProcessor.cs b/OnTopReplica/IMessagePumpProcessor.cs new file mode 100644 index 0000000..824b9e5 --- /dev/null +++ b/OnTopReplica/IMessagePumpProcessor.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica { + + interface IMessagePumpProcessor : IDisposable { + + void Initialize(MainForm form); + + bool Process(ref Message msg); + + } +} diff --git a/OnTopReplica/ImageComboBox.cs b/OnTopReplica/ImageComboBox.cs new file mode 100644 index 0000000..c68522f --- /dev/null +++ b/OnTopReplica/ImageComboBox.cs @@ -0,0 +1,77 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using System.Drawing; + +namespace OnTopReplica { + class ImageComboBox : ComboBox { + + public ImageComboBox() { + DrawMode = DrawMode.OwnerDrawFixed; + } + + protected override void OnDrawItem(DrawItemEventArgs ea) { + ea.DrawBackground(); + ea.DrawFocusRectangle(); + + if (ea.Index == -1) + return; + + Rectangle bounds = ea.Bounds; + var foreBrush = new SolidBrush(ea.ForeColor); + int textLeftBound = (IconList == null) ? bounds.Left : bounds.Left + IconList.ImageSize.Width; + + var drawObject = Items[ea.Index]; + if (drawObject is ImageComboBoxItem) { + var drawItem = (ImageComboBoxItem)drawObject; + + if (drawItem.ImageListIndex != -1 && IconList != null) { + //ea.Graphics.FillRectangle(Brushes.Gray, bounds.Left, bounds.Top, IconList.ImageSize.Width, IconList.ImageSize.Height); + ea.Graphics.DrawImage(IconList.Images[drawItem.ImageListIndex], bounds.Left, bounds.Top); + } + + ea.Graphics.DrawString(drawItem.Text, ea.Font, foreBrush, textLeftBound, bounds.Top); + } + else { + ea.Graphics.DrawString(drawObject.ToString(), ea.Font, foreBrush, textLeftBound, bounds.Top); + } + + base.OnDrawItem(ea); + } + + public ImageList IconList { get; set; } + + } + + class ImageComboBoxItem { + + public ImageComboBoxItem() { + Text = ""; + ImageListIndex = -1; + } + + public ImageComboBoxItem(string text) { + if (text == null) + throw new ArgumentNullException(); + + Text = text; + ImageListIndex = -1; + } + + public ImageComboBoxItem(string text, int imageListIndex) { + if (text == null) + throw new ArgumentNullException(); + + Text = text; + ImageListIndex = imageListIndex; + } + + public string Text { get; private set; } + + public int ImageListIndex { get; private set; } + + public object Tag { get; set; } + + } +} diff --git a/OnTopReplica/LICENSE.txt b/OnTopReplica/LICENSE.txt new file mode 100644 index 0000000..78db0fb --- /dev/null +++ b/OnTopReplica/LICENSE.txt @@ -0,0 +1,54 @@ +Microsoft Reciprocal License (Ms-RL) + +This license governs use of the accompanying software. If you use the +software, you accept this license. If you do not accept the license, do not +use the software. + +1. Definitions +The terms "reproduce," "reproduction," "derivative works," and "distribution" +have the same meaning here as under U.S. copyright law. +A "contribution" is the original software, or any additions or changes to the +software. +A "contributor" is any person that distributes its contribution under this +license. +"Licensed patents" are a contributor's patent claims that read directly on its +contribution. + +2. Grant of Rights +(A) Copyright Grant- Subject to the terms of this license, including the +license conditions and limitations in section 3, each contributor grants you a +non-exclusive, worldwide, royalty-free copyright license to reproduce its +contribution, prepare derivative works of its contribution, and distribute its +contribution or any derivative works that you create. +(B) Patent Grant- Subject to the terms of this license, including the license +conditions and limitations in section 3, each contributor grants you a +non-exclusive, worldwide, royalty-free license under its licensed patents to +make, have made, use, sell, offer for sale, import, and/or otherwise dispose +of its contribution in the software or derivative works of the contribution +in the software. + +3. Conditions and Limitations +(A) Reciprocal Grants- For any file you distribute that contains code from the +software (in source code or binary format), you must provide recipients the +source code to that file along with a copy of this license, which license will +govern that file. You may license other files that are entirely your own work +and do not contain code from the software under any terms you choose. +(B) No Trademark License- This license does not grant you rights to use any +contributors' name, logo, or trademarks. +(C) If you bring a patent claim against any contributor over patents that you +claim are infringed by the software, your patent license from such contributor +to the software ends automatically. +(D) If you distribute any portion of the software, you must retain all +copyright, patent, trademark, and attribution notices that are present in the +software. +(E) If you distribute any portion of the software in source code form, you may +do so only under this license by including a complete copy of this license +with your distribution. If you distribute any portion of the software in +compiled or object code form, you may only do so under a license that complies +with this license. +(F) The software is licensed "as-is." You bear the risk of using it. The +contributors give no express warranties, guarantees or conditions. You may +have additional consumer rights under your local laws which this license +cannot change. To the extent permitted under your local laws, the contributors +exclude the implied warranties of merchantability, fitness for a particular +purpose and non-infringement. diff --git a/OnTopReplica/MainForm.Designer.cs b/OnTopReplica/MainForm.Designer.cs new file mode 100644 index 0000000..1c0ec00 --- /dev/null +++ b/OnTopReplica/MainForm.Designer.cs @@ -0,0 +1,560 @@ +namespace OnTopReplica +{ + partial class MainForm + { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.components = new System.ComponentModel.Container(); + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); + this.menuContext = new System.Windows.Forms.ContextMenuStrip(this.components); + this.menuContextWindows = new System.Windows.Forms.ToolStripMenuItem(); + this.menuWindows = new System.Windows.Forms.ContextMenuStrip(this.components); + this.noneToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.fullSelectWindowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.switchToWindowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.selectRegionToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.advancedToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.clickForwardingToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.clickThroughToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.groupSwitchModeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.restoreLastClonedWindowToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.menuContextOpacity = new System.Windows.Forms.ToolStripMenuItem(); + this.menuOpacity = new System.Windows.Forms.ContextMenuStrip(this.components); + this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem3 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripMenuItem4 = new System.Windows.Forms.ToolStripMenuItem(); + this.resizeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.menuResize = new System.Windows.Forms.ContextMenuStrip(this.components); + this.doubleToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.fitToWindowToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.halfToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.quarterToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator3 = new System.Windows.Forms.ToolStripSeparator(); + this.fullscreenToolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator2 = new System.Windows.Forms.ToolStripSeparator(); + this.restorePositionAndSizeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.dockToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.disabledToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.topLeftToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.topRightToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.centerToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.bottomLeftToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.bottomRightToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.chromeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.reduceToIconToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator1 = new System.Windows.Forms.ToolStripSeparator(); + this.settingsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.aboutToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.menuContextClose = new System.Windows.Forms.ToolStripMenuItem(); + this.fullOpacityToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.menuFullscreenContext = new System.Windows.Forms.ContextMenuStrip(this.components); + this.enableClickthroughToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.fullExitToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.menuContext.SuspendLayout(); + this.menuWindows.SuspendLayout(); + this.menuOpacity.SuspendLayout(); + this.menuResize.SuspendLayout(); + this.menuFullscreenContext.SuspendLayout(); + this.SuspendLayout(); + // + // menuContext + // + this.menuContext.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.menuContextWindows, + this.switchToWindowToolStripMenuItem, + this.selectRegionToolStripMenuItem, + this.advancedToolStripMenuItem, + this.menuContextOpacity, + this.resizeToolStripMenuItem, + this.dockToolStripMenuItem, + this.chromeToolStripMenuItem, + this.reduceToIconToolStripMenuItem, + this.toolStripSeparator1, + this.settingsToolStripMenuItem, + this.aboutToolStripMenuItem, + this.menuContextClose}); + this.menuContext.Name = "menuContext"; + this.menuContext.Size = new System.Drawing.Size(187, 296); + this.menuContext.Opening += new System.ComponentModel.CancelEventHandler(this.Menu_opening); + // + // menuContextWindows + // + this.menuContextWindows.DropDown = this.menuWindows; + this.menuContextWindows.Image = global::OnTopReplica.Properties.Resources.list; + this.menuContextWindows.Name = "menuContextWindows"; + this.menuContextWindows.Size = new System.Drawing.Size(186, 22); + this.menuContextWindows.Text = global::OnTopReplica.Strings.MenuWindows; + this.menuContextWindows.ToolTipText = global::OnTopReplica.Strings.MenuWindowsTT; + // + // menuWindows + // + this.menuWindows.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.noneToolStripMenuItem}); + this.menuWindows.Name = "menuWindows"; + this.menuWindows.OwnerItem = this.menuContextWindows; + this.menuWindows.Size = new System.Drawing.Size(118, 26); + // + // noneToolStripMenuItem + // + this.noneToolStripMenuItem.Name = "noneToolStripMenuItem"; + this.noneToolStripMenuItem.Size = new System.Drawing.Size(117, 22); + this.noneToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuWindowsNone; + // + // fullSelectWindowToolStripMenuItem + // + this.fullSelectWindowToolStripMenuItem.DropDown = this.menuWindows; + this.fullSelectWindowToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.list; + this.fullSelectWindowToolStripMenuItem.Name = "fullSelectWindowToolStripMenuItem"; + this.fullSelectWindowToolStripMenuItem.Size = new System.Drawing.Size(189, 22); + this.fullSelectWindowToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuWindows; + this.fullSelectWindowToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuWindowsTT; + // + // switchToWindowToolStripMenuItem + // + this.switchToWindowToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.xiao_arrow; + this.switchToWindowToolStripMenuItem.Name = "switchToWindowToolStripMenuItem"; + this.switchToWindowToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.switchToWindowToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuSwitch; + this.switchToWindowToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuSwitchTT; + this.switchToWindowToolStripMenuItem.Click += new System.EventHandler(this.Menu_Switch_click); + // + // selectRegionToolStripMenuItem + // + this.selectRegionToolStripMenuItem.Enabled = false; + this.selectRegionToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.regions; + this.selectRegionToolStripMenuItem.Name = "selectRegionToolStripMenuItem"; + this.selectRegionToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.selectRegionToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuRegion; + this.selectRegionToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuRegionTT; + this.selectRegionToolStripMenuItem.Click += new System.EventHandler(this.Menu_Region_click); + // + // advancedToolStripMenuItem + // + this.advancedToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.clickForwardingToolStripMenuItem, + this.clickThroughToolStripMenuItem, + this.groupSwitchModeToolStripMenuItem, + this.restoreLastClonedWindowToolStripMenuItem}); + this.advancedToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.xiao_wrench; + this.advancedToolStripMenuItem.Name = "advancedToolStripMenuItem"; + this.advancedToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.advancedToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuAdvanced; + this.advancedToolStripMenuItem.DropDownOpening += new System.EventHandler(this.Menu_Advanced_opening); + // + // clickForwardingToolStripMenuItem + // + this.clickForwardingToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.clickforwarding; + this.clickForwardingToolStripMenuItem.Name = "clickForwardingToolStripMenuItem"; + this.clickForwardingToolStripMenuItem.Size = new System.Drawing.Size(218, 22); + this.clickForwardingToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuClickForwarding; + this.clickForwardingToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuClickForwardingTT; + this.clickForwardingToolStripMenuItem.Click += new System.EventHandler(this.Menu_ClickForwarding_click); + // + // clickThroughToolStripMenuItem + // + this.clickThroughToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.window_opacity; + this.clickThroughToolStripMenuItem.Name = "clickThroughToolStripMenuItem"; + this.clickThroughToolStripMenuItem.Size = new System.Drawing.Size(218, 22); + this.clickThroughToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuClickThrough; + this.clickThroughToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuClickThroughTT; + this.clickThroughToolStripMenuItem.Click += new System.EventHandler(this.Menu_ClickThrough_click); + // + // groupSwitchModeToolStripMenuItem + // + this.groupSwitchModeToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.groupmode; + this.groupSwitchModeToolStripMenuItem.Name = "groupSwitchModeToolStripMenuItem"; + this.groupSwitchModeToolStripMenuItem.Size = new System.Drawing.Size(218, 22); + this.groupSwitchModeToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuGroupSwitch; + this.groupSwitchModeToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuGroupSwitchTT; + this.groupSwitchModeToolStripMenuItem.Click += new System.EventHandler(this.Menu_GroupSwitchMode_click); + // + // restoreLastClonedWindowToolStripMenuItem + // + this.restoreLastClonedWindowToolStripMenuItem.Name = "restoreLastClonedWindowToolStripMenuItem"; + this.restoreLastClonedWindowToolStripMenuItem.Size = new System.Drawing.Size(218, 22); + this.restoreLastClonedWindowToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuRestoreLast; + this.restoreLastClonedWindowToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuRestoreLastTT; + this.restoreLastClonedWindowToolStripMenuItem.Click += new System.EventHandler(this.Menu_RestoreLastWindow_click); + // + // menuContextOpacity + // + this.menuContextOpacity.DropDown = this.menuOpacity; + this.menuContextOpacity.Image = global::OnTopReplica.Properties.Resources.window_opacity; + this.menuContextOpacity.Name = "menuContextOpacity"; + this.menuContextOpacity.Size = new System.Drawing.Size(186, 22); + this.menuContextOpacity.Text = global::OnTopReplica.Strings.MenuOpacity; + // + // menuOpacity + // + this.menuOpacity.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.toolStripMenuItem1, + this.toolStripMenuItem2, + this.toolStripMenuItem3, + this.toolStripMenuItem4}); + this.menuOpacity.Name = "menuOpacity"; + this.menuOpacity.OwnerItem = this.fullOpacityToolStripMenuItem; + this.menuOpacity.ShowCheckMargin = true; + this.menuOpacity.ShowImageMargin = false; + this.menuOpacity.Size = new System.Drawing.Size(154, 92); + this.menuOpacity.Opening += new System.ComponentModel.CancelEventHandler(this.Menu_Opacity_opening); + // + // toolStripMenuItem1 + // + this.toolStripMenuItem1.Checked = true; + this.toolStripMenuItem1.CheckState = System.Windows.Forms.CheckState.Checked; + this.toolStripMenuItem1.Name = "toolStripMenuItem1"; + this.toolStripMenuItem1.Size = new System.Drawing.Size(153, 22); + this.toolStripMenuItem1.Tag = 1D; + this.toolStripMenuItem1.Text = global::OnTopReplica.Strings.MenuOp100; + this.toolStripMenuItem1.ToolTipText = global::OnTopReplica.Strings.MenuOp100TT; + this.toolStripMenuItem1.Click += new System.EventHandler(this.Menu_Opacity_click); + // + // toolStripMenuItem2 + // + this.toolStripMenuItem2.Name = "toolStripMenuItem2"; + this.toolStripMenuItem2.Size = new System.Drawing.Size(153, 22); + this.toolStripMenuItem2.Tag = 0.75D; + this.toolStripMenuItem2.Text = global::OnTopReplica.Strings.MenuOp75; + this.toolStripMenuItem2.ToolTipText = global::OnTopReplica.Strings.MenuOp75TT; + this.toolStripMenuItem2.Click += new System.EventHandler(this.Menu_Opacity_click); + // + // toolStripMenuItem3 + // + this.toolStripMenuItem3.Name = "toolStripMenuItem3"; + this.toolStripMenuItem3.Size = new System.Drawing.Size(153, 22); + this.toolStripMenuItem3.Tag = 0.5D; + this.toolStripMenuItem3.Text = global::OnTopReplica.Strings.MenuOp50; + this.toolStripMenuItem3.ToolTipText = global::OnTopReplica.Strings.MenuOp50TT; + this.toolStripMenuItem3.Click += new System.EventHandler(this.Menu_Opacity_click); + // + // toolStripMenuItem4 + // + this.toolStripMenuItem4.Name = "toolStripMenuItem4"; + this.toolStripMenuItem4.Size = new System.Drawing.Size(153, 22); + this.toolStripMenuItem4.Tag = 0.25D; + this.toolStripMenuItem4.Text = global::OnTopReplica.Strings.MenuOp25; + this.toolStripMenuItem4.ToolTipText = global::OnTopReplica.Strings.MenuOp25TT; + this.toolStripMenuItem4.Click += new System.EventHandler(this.Menu_Opacity_click); + // + // resizeToolStripMenuItem + // + this.resizeToolStripMenuItem.DropDown = this.menuResize; + this.resizeToolStripMenuItem.Enabled = false; + this.resizeToolStripMenuItem.Name = "resizeToolStripMenuItem"; + this.resizeToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.resizeToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuResize; + // + // menuResize + // + this.menuResize.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.doubleToolStripMenuItem1, + this.fitToWindowToolStripMenuItem1, + this.halfToolStripMenuItem1, + this.quarterToolStripMenuItem1, + this.toolStripSeparator3, + this.fullscreenToolStripMenuItem1, + this.toolStripSeparator2, + this.restorePositionAndSizeToolStripMenuItem}); + this.menuResize.Name = "menuResize"; + this.menuResize.OwnerItem = this.resizeToolStripMenuItem; + this.menuResize.Size = new System.Drawing.Size(218, 170); + this.menuResize.Opening += new System.ComponentModel.CancelEventHandler(this.Menu_Resize_opening); + // + // doubleToolStripMenuItem1 + // + this.doubleToolStripMenuItem1.Name = "doubleToolStripMenuItem1"; + this.doubleToolStripMenuItem1.Size = new System.Drawing.Size(217, 22); + this.doubleToolStripMenuItem1.Text = global::OnTopReplica.Strings.MenuFitDouble; + this.doubleToolStripMenuItem1.Click += new System.EventHandler(this.Menu_Resize_Double); + // + // fitToWindowToolStripMenuItem1 + // + this.fitToWindowToolStripMenuItem1.Name = "fitToWindowToolStripMenuItem1"; + this.fitToWindowToolStripMenuItem1.Size = new System.Drawing.Size(217, 22); + this.fitToWindowToolStripMenuItem1.Text = global::OnTopReplica.Strings.MenuFitOriginal; + this.fitToWindowToolStripMenuItem1.Click += new System.EventHandler(this.Menu_Resize_FitToWindow); + // + // halfToolStripMenuItem1 + // + this.halfToolStripMenuItem1.Name = "halfToolStripMenuItem1"; + this.halfToolStripMenuItem1.Size = new System.Drawing.Size(217, 22); + this.halfToolStripMenuItem1.Text = global::OnTopReplica.Strings.MenuFitHalf; + this.halfToolStripMenuItem1.Click += new System.EventHandler(this.Menu_Resize_Half); + // + // quarterToolStripMenuItem1 + // + this.quarterToolStripMenuItem1.Name = "quarterToolStripMenuItem1"; + this.quarterToolStripMenuItem1.Size = new System.Drawing.Size(217, 22); + this.quarterToolStripMenuItem1.Text = global::OnTopReplica.Strings.MenuFitQuarter; + this.quarterToolStripMenuItem1.Click += new System.EventHandler(this.Menu_Resize_Quarter); + // + // toolStripSeparator3 + // + this.toolStripSeparator3.Name = "toolStripSeparator3"; + this.toolStripSeparator3.Size = new System.Drawing.Size(214, 6); + // + // fullscreenToolStripMenuItem1 + // + this.fullscreenToolStripMenuItem1.Image = global::OnTopReplica.Properties.Resources.fullscreen; + this.fullscreenToolStripMenuItem1.Name = "fullscreenToolStripMenuItem1"; + this.fullscreenToolStripMenuItem1.Size = new System.Drawing.Size(217, 22); + this.fullscreenToolStripMenuItem1.Text = global::OnTopReplica.Strings.MenuFitFullscreen; + this.fullscreenToolStripMenuItem1.Click += new System.EventHandler(this.Menu_Resize_Fullscreen); + // + // toolStripSeparator2 + // + this.toolStripSeparator2.Name = "toolStripSeparator2"; + this.toolStripSeparator2.Size = new System.Drawing.Size(214, 6); + // + // restorePositionAndSizeToolStripMenuItem + // + this.restorePositionAndSizeToolStripMenuItem.Name = "restorePositionAndSizeToolStripMenuItem"; + this.restorePositionAndSizeToolStripMenuItem.Size = new System.Drawing.Size(217, 22); + this.restorePositionAndSizeToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuRecall; + this.restorePositionAndSizeToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuRecallTT; + this.restorePositionAndSizeToolStripMenuItem.Click += new System.EventHandler(this.Menu_Resize_RecallPosition_click); + // + // dockToolStripMenuItem + // + this.dockToolStripMenuItem.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.disabledToolStripMenuItem, + this.topLeftToolStripMenuItem, + this.topRightToolStripMenuItem, + this.centerToolStripMenuItem, + this.bottomLeftToolStripMenuItem, + this.bottomRightToolStripMenuItem}); + this.dockToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_null; + this.dockToolStripMenuItem.Name = "dockToolStripMenuItem"; + this.dockToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.dockToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosition; + this.dockToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuPositionTT; + this.dockToolStripMenuItem.DropDownOpening += new System.EventHandler(this.Menu_Position_Opening); + // + // disabledToolStripMenuItem + // + this.disabledToolStripMenuItem.Checked = true; + this.disabledToolStripMenuItem.CheckState = System.Windows.Forms.CheckState.Checked; + this.disabledToolStripMenuItem.Name = "disabledToolStripMenuItem"; + this.disabledToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.disabledToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosDisabled; + this.disabledToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_Disable); + // + // topLeftToolStripMenuItem + // + this.topLeftToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_topleft; + this.topLeftToolStripMenuItem.Name = "topLeftToolStripMenuItem"; + this.topLeftToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.topLeftToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosTopLeft; + this.topLeftToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_TopLeft); + // + // topRightToolStripMenuItem + // + this.topRightToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_topright; + this.topRightToolStripMenuItem.Name = "topRightToolStripMenuItem"; + this.topRightToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.topRightToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosTopRight; + this.topRightToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_TopRight); + // + // centerToolStripMenuItem + // + this.centerToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_center; + this.centerToolStripMenuItem.Name = "centerToolStripMenuItem"; + this.centerToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.centerToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosCenter; + this.centerToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_Center); + // + // bottomLeftToolStripMenuItem + // + this.bottomLeftToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_bottomleft; + this.bottomLeftToolStripMenuItem.Name = "bottomLeftToolStripMenuItem"; + this.bottomLeftToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.bottomLeftToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosBottomLeft; + this.bottomLeftToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_BottomLeft); + // + // bottomRightToolStripMenuItem + // + this.bottomRightToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.pos_bottomright; + this.bottomRightToolStripMenuItem.Name = "bottomRightToolStripMenuItem"; + this.bottomRightToolStripMenuItem.Size = new System.Drawing.Size(145, 22); + this.bottomRightToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuPosBottomRight; + this.bottomRightToolStripMenuItem.Click += new System.EventHandler(this.Menu_Position_BottomRight); + // + // chromeToolStripMenuItem + // + this.chromeToolStripMenuItem.Name = "chromeToolStripMenuItem"; + this.chromeToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.chromeToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuChrome; + this.chromeToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuChromeTT; + this.chromeToolStripMenuItem.Click += new System.EventHandler(this.Menu_Chrome_click); + // + // reduceToIconToolStripMenuItem + // + this.reduceToIconToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.reduce; + this.reduceToIconToolStripMenuItem.Name = "reduceToIconToolStripMenuItem"; + this.reduceToIconToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.reduceToIconToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuReduce; + this.reduceToIconToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuReduceTT; + this.reduceToIconToolStripMenuItem.Click += new System.EventHandler(this.Menu_Reduce_click); + // + // toolStripSeparator1 + // + this.toolStripSeparator1.Name = "toolStripSeparator1"; + this.toolStripSeparator1.Size = new System.Drawing.Size(183, 6); + // + // settingsToolStripMenuItem + // + this.settingsToolStripMenuItem.Name = "settingsToolStripMenuItem"; + this.settingsToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.settingsToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuSettings; + this.settingsToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuSettingsTT; + this.settingsToolStripMenuItem.Click += new System.EventHandler(this.Menu_Settings_click); + // + // aboutToolStripMenuItem + // + this.aboutToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.xiao_help; + this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + this.aboutToolStripMenuItem.Size = new System.Drawing.Size(186, 22); + this.aboutToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuAbout; + this.aboutToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuAboutTT; + this.aboutToolStripMenuItem.Click += new System.EventHandler(this.Menu_About_click); + // + // menuContextClose + // + this.menuContextClose.Image = global::OnTopReplica.Properties.Resources.close_new; + this.menuContextClose.Name = "menuContextClose"; + this.menuContextClose.Size = new System.Drawing.Size(186, 22); + this.menuContextClose.Text = global::OnTopReplica.Strings.MenuClose; + this.menuContextClose.Click += new System.EventHandler(this.Menu_Close_click); + // + // fullOpacityToolStripMenuItem + // + this.fullOpacityToolStripMenuItem.DropDown = this.menuOpacity; + this.fullOpacityToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.window_opacity; + this.fullOpacityToolStripMenuItem.Name = "fullOpacityToolStripMenuItem"; + this.fullOpacityToolStripMenuItem.Size = new System.Drawing.Size(189, 22); + this.fullOpacityToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuOpacity; + // + // menuFullscreenContext + // + this.menuFullscreenContext.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { + this.fullSelectWindowToolStripMenuItem, + this.fullOpacityToolStripMenuItem, + this.enableClickthroughToolStripMenuItem, + this.fullExitToolStripMenuItem}); + this.menuFullscreenContext.Name = "menuFullscreenContext"; + this.menuFullscreenContext.Size = new System.Drawing.Size(190, 92); + // + // enableClickthroughToolStripMenuItem + // + this.enableClickthroughToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.clickforwarding; + this.enableClickthroughToolStripMenuItem.Name = "enableClickthroughToolStripMenuItem"; + this.enableClickthroughToolStripMenuItem.Size = new System.Drawing.Size(189, 22); + this.enableClickthroughToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuClickThrough; + this.enableClickthroughToolStripMenuItem.ToolTipText = global::OnTopReplica.Strings.MenuClickThroughTT; + this.enableClickthroughToolStripMenuItem.Click += new System.EventHandler(this.Menu_ClickThrough_click); + // + // fullExitToolStripMenuItem + // + this.fullExitToolStripMenuItem.Image = global::OnTopReplica.Properties.Resources.close_new; + this.fullExitToolStripMenuItem.Name = "fullExitToolStripMenuItem"; + this.fullExitToolStripMenuItem.Size = new System.Drawing.Size(189, 22); + this.fullExitToolStripMenuItem.Text = global::OnTopReplica.Strings.MenuQuitFullscreen; + this.fullExitToolStripMenuItem.Click += new System.EventHandler(this.Menu_Fullscreen_ExitFullscreen_click); + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 15F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.Control; + this.ClientSize = new System.Drawing.Size(318, 226); + this.ControlBox = false; + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.SizableToolWindow; + this.HideCaption = true; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.MinimumSize = new System.Drawing.Size(44, 44); + this.Name = "MainForm"; + this.Text = "OnTopReplica"; + this.TopMost = true; + this.menuContext.ResumeLayout(false); + this.menuWindows.ResumeLayout(false); + this.menuOpacity.ResumeLayout(false); + this.menuResize.ResumeLayout(false); + this.menuFullscreenContext.ResumeLayout(false); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.ContextMenuStrip menuContext; + private System.Windows.Forms.ToolStripMenuItem menuContextWindows; + private System.Windows.Forms.ToolStripMenuItem menuContextClose; + private System.Windows.Forms.ContextMenuStrip menuWindows; + private System.Windows.Forms.ToolStripMenuItem menuContextOpacity; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator1; + private System.Windows.Forms.ContextMenuStrip menuOpacity; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem2; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem3; + private System.Windows.Forms.ToolStripMenuItem toolStripMenuItem4; + private System.Windows.Forms.ToolStripMenuItem aboutToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem reduceToIconToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem selectRegionToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem resizeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem noneToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem switchToWindowToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem dockToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem topLeftToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem topRightToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem bottomLeftToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem bottomRightToolStripMenuItem; + private System.Windows.Forms.ContextMenuStrip menuResize; + private System.Windows.Forms.ToolStripMenuItem doubleToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem fitToWindowToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem halfToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem quarterToolStripMenuItem1; + private System.Windows.Forms.ToolStripMenuItem fullscreenToolStripMenuItem1; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator3; + private System.Windows.Forms.ToolStripMenuItem chromeToolStripMenuItem; + private System.Windows.Forms.ContextMenuStrip menuFullscreenContext; + private System.Windows.Forms.ToolStripMenuItem fullSelectWindowToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem fullOpacityToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem fullExitToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem advancedToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem clickForwardingToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem clickThroughToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem groupSwitchModeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem enableClickthroughToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem centerToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem disabledToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator2; + private System.Windows.Forms.ToolStripMenuItem restorePositionAndSizeToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem restoreLastClonedWindowToolStripMenuItem; + private System.Windows.Forms.ToolStripMenuItem settingsToolStripMenuItem; + } +} + diff --git a/OnTopReplica/MainForm.cs b/OnTopReplica/MainForm.cs new file mode 100644 index 0000000..45b6a24 --- /dev/null +++ b/OnTopReplica/MainForm.cs @@ -0,0 +1,474 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; +using OnTopReplica.Native; +using OnTopReplica.Properties; +using OnTopReplica.StartupOptions; +using OnTopReplica.Update; +using OnTopReplica.WindowSeekers; +using WindowsFormsAero.Dwm; +using WindowsFormsAero.TaskDialog; + +namespace OnTopReplica { + + partial class MainForm : AspectRatioForm { + + //GUI elements + ThumbnailPanel _thumbnailPanel; + + //Managers + MessagePumpManager _msgPumpManager = new MessagePumpManager(); + WindowListMenuManager _windowListManager; + + Options _startupOptions; + + public MainForm(Options startupOptions) { + _startupOptions = startupOptions; + + //WinForms init pass + InitializeComponent(); + + //Store default values + DefaultNonClickTransparencyKey = this.TransparencyKey; + DefaultBorderStyle = this.FormBorderStyle; + + //Thumbnail panel + _thumbnailPanel = new ThumbnailPanel { + Location = Point.Empty, + Dock = DockStyle.Fill + }; + _thumbnailPanel.CloneClick += new EventHandler(Thumbnail_CloneClick); + Controls.Add(_thumbnailPanel); + + //Set native renderer on context menus + Asztal.Szótár.NativeToolStripRenderer.SetToolStripRenderer( + menuContext, menuWindows, menuOpacity, menuResize, menuFullscreenContext + ); + + //Set to Key event preview + this.KeyPreview = true; + } + + #region Event override + + protected override void OnHandleCreated(EventArgs e){ + base.OnHandleCreated(e); + + //Window init + KeepAspectRatio = false; + GlassEnabled = true; + GlassMargins = new Margins(-1); + + //Managers + _msgPumpManager.Initialize(this); + _windowListManager = new WindowListMenuManager(this, menuWindows); + _windowListManager.ParentMenus = new System.Windows.Forms.ContextMenuStrip[] { + menuContext, menuFullscreenContext + }; + + //Platform specific form initialization + Program.Platform.PostHandleFormInit(this); + } + + protected override void OnShown(EventArgs e) { + base.OnShown(e); + + //Apply startup options + _startupOptions.Apply(this); + } + + protected override void OnClosing(CancelEventArgs e) { + //Store last thumbnail, if any + if (_thumbnailPanel.IsShowingThumbnail && CurrentThumbnailWindowHandle != null) { + Settings.Default.RestoreLastWindowTitle = CurrentThumbnailWindowHandle.Title; + Settings.Default.RestoreLastWindowHwnd = CurrentThumbnailWindowHandle.Handle.ToInt64(); + Settings.Default.RestoreLastWindowClass = CurrentThumbnailWindowHandle.Class; + } + else { + Settings.Default.RestoreLastWindowTitle = string.Empty; + Settings.Default.RestoreLastWindowHwnd = 0; + Settings.Default.RestoreLastWindowClass = string.Empty; + } + + _msgPumpManager.Dispose(); + Program.Platform.CloseForm(this); + + base.OnClosing(e); + } + + protected override void OnMove(EventArgs e) { + base.OnMove(e); + + AdjustSidePanelLocation(); + } + + protected override void OnResizeEnd(EventArgs e) { + base.OnResizeEnd(e); + + RefreshScreenLock(); + } + + protected override void OnActivated(EventArgs e) { + base.OnActivated(e); + + //Deactivate click-through if form is reactivated + if (ClickThroughEnabled) { + ClickThroughEnabled = false; + } + + Program.Platform.RestoreForm(this); + } + + protected override void OnDeactivate(EventArgs e) { + base.OnDeactivate(e); + + //HACK: sometimes, even if TopMost is true, the window loses its "always on top" status. + // This is a fix attempt that probably won't work... + if (!IsFullscreen) { //fullscreen mode doesn't use TopMost + TopMost = false; + TopMost = true; + } + } + + protected override void OnMouseWheel(MouseEventArgs e) { + base.OnMouseWheel(e); + + if (!IsFullscreen) { + int change = (int)(e.Delta / 6.0); //assumes a mouse wheel "tick" is in the 80-120 range + AdjustSize(change); + RefreshScreenLock(); + } + } + + protected override void OnMouseDoubleClick(MouseEventArgs e) { + base.OnMouseDoubleClick(e); + + //This is handled by the WM_NCLBUTTONDBLCLK msg handler usually (because the GlassForm translates + //clicks on client to clicks on caption). But if fullscreen mode disables GlassForm dragging, we need + //this auxiliary handler to switch mode. + IsFullscreen = !IsFullscreen; + } + + protected override void OnMouseClick(MouseEventArgs e) { + base.OnMouseClick(e); + + //Same story as above (OnMouseDoubleClick) + if (e.Button == System.Windows.Forms.MouseButtons.Right) { + OpenContextMenu(null); + } + } + + protected override void WndProc(ref Message m) { + if (_msgPumpManager != null) { + if (_msgPumpManager.PumpMessage(ref m)) { + return; + } + } + + switch (m.Msg) { + case WM.NCRBUTTONUP: + //Open context menu if right button clicked on caption (i.e. all of the window area because of glass) + if (m.WParam.ToInt32() == HT.CAPTION) { + OpenContextMenu(null); + + m.Result = IntPtr.Zero; + return; + } + break; + + case WM.NCLBUTTONDBLCLK: + //Toggle fullscreen mode if double click on caption (whole glass area) + if (m.WParam.ToInt32() == HT.CAPTION) { + IsFullscreen = !IsFullscreen; + + m.Result = IntPtr.Zero; + return; + } + break; + + case WM.NCHITTEST: + //Make transparent to hit-testing if in click through mode + if (ClickThroughEnabled && (ModifierKeys & Keys.Alt) != Keys.Alt) { + m.Result = (IntPtr)HT.TRANSPARENT; + return; + } + break; + } + + base.WndProc(ref m); + } + + #endregion + + #region Keyboard event handling + + protected override void OnKeyUp(KeyEventArgs e) { + base.OnKeyUp(e); + + //ALT + if (e.Modifiers == Keys.Alt) { + if (e.KeyCode == Keys.Enter) { + e.Handled = true; + IsFullscreen = !IsFullscreen; + } + + else if (e.KeyCode == Keys.D1 || e.KeyCode == Keys.NumPad1) { + FitToThumbnail(0.25); + } + + else if (e.KeyCode == Keys.D2 || e.KeyCode == Keys.NumPad2) { + FitToThumbnail(0.5); + } + + else if (e.KeyCode == Keys.D3 || e.KeyCode == Keys.NumPad3 || + e.KeyCode == Keys.D0 || e.KeyCode == Keys.NumPad0) { + FitToThumbnail(1.0); + } + + else if (e.KeyCode == Keys.D4 || e.KeyCode == Keys.NumPad4) { + FitToThumbnail(2.0); + } + } + + //F11 Fullscreen switch + else if (e.KeyCode == Keys.F11) { + e.Handled = true; + IsFullscreen = !IsFullscreen; + } + + //ESCAPE + else if (e.KeyCode == Keys.Escape) { + //Disable click-through + if (ClickThroughEnabled) { + ClickThroughEnabled = false; + } + //Toggle fullscreen + else if (IsFullscreen) { + IsFullscreen = false; + } + //Disable click forwarding + else if (ClickForwardingEnabled) { + ClickForwardingEnabled = false; + } + } + } + + #endregion + + #region Fullscreen + + bool _isFullscreen = false; + Point _preFullscreenLocation; + Size _preFullscreenSize; + FormBorderStyle _preFullscreenBorderStyle; + + public bool IsFullscreen { + get { + return _isFullscreen; + } + set { + if (IsFullscreen == value) + return; + if (value && !_thumbnailPanel.IsShowingThumbnail) + return; + + CloseSidePanel(); //on switch, always hide side panels + + //Location and size + if (value) { + _preFullscreenLocation = Location; + _preFullscreenSize = ClientSize; + _preFullscreenBorderStyle = FormBorderStyle; + + FormBorderStyle = FormBorderStyle.None; + var currentScreen = Screen.FromControl(this); + Size = currentScreen.WorkingArea.Size; + Location = currentScreen.WorkingArea.Location; + } + else { + FormBorderStyle = _preFullscreenBorderStyle; + Location = _preFullscreenLocation; + ClientSize = _preFullscreenSize; + RefreshAspectRatio(); + } + + //Common + GlassEnabled = !value; + TopMost = !value; + HandleMouseMove = !value; + + _isFullscreen = value; + + Program.Platform.OnFormStateChange(this); + } + } + + #endregion + + #region Thumbnail operation + + /// + /// Sets a new thumbnail. + /// + /// Handle to the window to clone. + /// Region of the window to clone or null. + public void SetThumbnail(WindowHandle handle, ThumbnailRegion region) { + try { + System.Diagnostics.Trace.WriteLine(string.Format("Cloning window HWND {0} of class {1}.", handle.Handle, handle.Class)); + + CurrentThumbnailWindowHandle = handle; + _thumbnailPanel.SetThumbnailHandle(handle, region); + + //Set aspect ratio (this will resize the form), do not refresh if in fullscreen + SetAspectRatio(_thumbnailPanel.ThumbnailPixelSize, !IsFullscreen); + } + catch (Exception ex) { + System.Diagnostics.Trace.Fail("Unable to set thumbnail.", ex.ToString()); + + ThumbnailError(ex, false, Strings.ErrorUnableToCreateThumbnail); + _thumbnailPanel.UnsetThumbnail(); + } + } + + /// + /// Enables group mode on a list of window handles. + /// + /// List of window handles. + public void SetThumbnailGroup(IList handles) { + if (handles.Count == 0) + return; + + //At last one thumbnail + SetThumbnail(handles[0], null); + + //Handle if no real group + if (handles.Count == 1) + return; + + CurrentThumbnailWindowHandle = null; + _msgPumpManager.Get().EnableGroupMode(handles); + } + + /// + /// Disables the cloned thumbnail. + /// + public void UnsetThumbnail() { + //Unset handle + CurrentThumbnailWindowHandle = null; + _thumbnailPanel.UnsetThumbnail(); + + //Disable aspect ratio + KeepAspectRatio = false; + } + + /// + /// Gets or sets the region displayed of the current thumbnail. + /// + public ThumbnailRegion SelectedThumbnailRegion { + get { + if (!_thumbnailPanel.IsShowingThumbnail || !_thumbnailPanel.ConstrainToRegion) + return null; + + return _thumbnailPanel.SelectedRegion; + } + set { + if (!_thumbnailPanel.IsShowingThumbnail) + return; + + _thumbnailPanel.SelectedRegion = value; + + SetAspectRatio(_thumbnailPanel.ThumbnailPixelSize, true); + + FixPositionAndSize(); + } + } + + const int FixMargin = 10; + + /// + /// Fixes the form's position and size, ensuring it is fully displayed in the current screen. + /// + private void FixPositionAndSize() { + var screen = Screen.FromControl(this); + + if (Width > screen.WorkingArea.Width) { + Width = screen.WorkingArea.Width - FixMargin; + } + if (Height > screen.WorkingArea.Height) { + Height = screen.WorkingArea.Height - FixMargin; + } + if (Location.X + Width > screen.WorkingArea.Right) { + Location = new Point(screen.WorkingArea.Right - Width - FixMargin, Location.Y); + } + if (Location.Y + Height > screen.WorkingArea.Bottom) { + Location = new Point(Location.X, screen.WorkingArea.Bottom - Height - FixMargin); + } + } + + private void ThumbnailError(Exception ex, bool suppress, string title) { + if (!suppress) { + ShowErrorDialog(title, Strings.ErrorGenericThumbnailHandleError, ex.Message); + } + + UnsetThumbnail(); + } + + /// Automatically sizes the window in order to accomodate the thumbnail p times. + /// Scale of the thumbnail to consider. + private void FitToThumbnail(double p) { + try { + Size originalSize = _thumbnailPanel.ThumbnailPixelSize; + Size fittedSize = new Size((int)(originalSize.Width * p), (int)(originalSize.Height * p)); + ClientSize = fittedSize; + RefreshScreenLock(); + } + catch (Exception ex) { + ThumbnailError(ex, false, Strings.ErrorUnableToFit); + } + } + + #endregion + + #region Accessors + + /// + /// Gets the form's thumbnail panel. + /// + public ThumbnailPanel ThumbnailPanel { + get { + return _thumbnailPanel; + } + } + + /// + /// Gets the form's message pump manager. + /// + public MessagePumpManager MessagePumpManager { + get { + return _msgPumpManager; + } + } + + /// + /// Gets the form's window list drop down menu. + /// + public ContextMenuStrip MenuWindows { + get { + return menuWindows; + } + } + + /// + /// Retrieves the window handle of the currently cloned thumbnail. + /// + public WindowHandle CurrentThumbnailWindowHandle { + get; + private set; + } + + #endregion + + } +} diff --git a/OnTopReplica/MainForm.resx b/OnTopReplica/MainForm.resx new file mode 100644 index 0000000..5ef7664 --- /dev/null +++ b/OnTopReplica/MainForm.resx @@ -0,0 +1,321 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 142, 17 + + + 275, 17 + + + 578, 17 + + + 399, 17 + + + + + AAABAAIAMDAAAAEAIACoJQAAJgAAABAQAAABACAAaAQAAM4lAAAoAAAAMAAAAGAAAAABACAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAYAAAAOAAAAFwAAACAAAAAnAAAAKwAAACwAAAAsAAAALAAA + ACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAA + ACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAA + ACwAAAAsAAAAKwAAACcAAAAfAAAAFwAAAA0AAAAGAAAABgAAAA4AAAAdAAAALQAAAD0AAABIAAAATgAA + AE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAA + AE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAA + AE8AAABPAAAATwAAAE8AAABPAAAATgAAAEgAAAA9AAAALQAAABwAAAANAAAACwAAABkAAAAwAAAARwAA + AFsAAABpAAAAcAAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcAAAAGkAAABdAAAASAAAAC8AAAAYAAAAEQAA + ACQAAABBAAAAbAoKC6QYGBiyFhcXtBcXF7QXFxe0FxcXtBcXF7UXFxi0FxcYtBcYGLQXGBi0FxgYtBgY + GLQXGBi0FxcYtBcXF7QXFxe0FxcXtBcXF7QXFxe0FxcXtRcXF7UXFxe1FxcXtBcXF7QXFxe0FxcXtBYX + F7QWFhe0FhYXtBYWFrQWFhe0FxcXtBcXF7QXFxe0FxcXtBcXF7QXFxe0GBgYtQEBAqYAAAB5AAAAXwAA + AEEAAAAkAAAAFwAAACwAAABdOTk3u46IgKWTjIKUkYiAk4yEepKHf3WQhHtyj4B5b45+eG2NfHVrjHly + Z4t5cmeLeXFni3huZot5b2aLe3JoioB3bIuDe3KMiH92jIyCeIyMhXqNjYZ7jo2HfI+Ph36PkId/j5GI + f4+SiX+PkomAj5OLgJCTjIKQk4yCkJSMgpCTi4GQj4h+joyEeo2LgniMjIN5jY+HfY6RiYCPkoqAjn55 + c7IXFxe1AAAAcQAAAFAAAAAuAAAAGwAAADAJCQmJkoyGrJ6ViXCypp2Fv7OskL2yq5G6r6ePt6yljbWr + o4yzqqGLsaefirClnYmupJ2JrqOdia6inYqvpJ2JsqafibSqo4m4raeKu7Gqiryyq4u8s6uLu7OsjLyz + rYy8s62MvbOujb20ro29ta6NvbWujry2ro67tq6OvLaujr23r468ta6OurOsjLiyq4u3sayLubOvjLu0 + so20ramGnpWNdJ+ViGxnZWG9AAAAiQAAAFYAAAAzAAAAHAAAADIREhKSqaGapbK4splz3ePrceDn8nPg + 5/N14OfzduDm83nh5fN84uXyf+Lk8oLj5PKF4+Lyh+Pi8onk4PKM5d/yj+Xf8pPm3/KX6ODynOni8qDq + 4/Kk7OLyqO7i863w4vKy8+Hytvbh87z44fPE+uHzzvvk89776vPs+/Pz+fv58//7/fP/+/7z//v98v/7 + 9/L8++3y9/vi8/b70fPz+b7u1da5u6mim3V/fHe1AAAAkQAAAFkAAAA2AAAAHQAAADMQEBCRsKiirMLO + ybBI3eT/PNnf/z3Z2v8+2df/P9nV/0HZ0/9G2tL/StvQ/0vbzv9O28v/UNzJ/1Pcx/9W3sX/WuHD/13k + wv9i6ML/aO/E/3D1x/99+s7/jP3W/53/4P+y/+r/xf/x/9r/+f/v//3/9//8//n//P/6//r/8v/r/+H/ + 3v+//dr/t/3Z/8L+zv/K/7H/1f2b/9r8jv/X/Yz/0Oa+1r2zsYJ+e3e4AAAAkQAAAFoAAAA3AAAAHQAA + ADMPDw+RtKumr8bSz7Y809n/L9DT/zLQ0f8zz8//NNDL/zfQyf860Mj/PNHF/z3Sw/9A1cH/RdnC/0re + xP9S5cj/W+zN/2by0/9x+Nj/e/3d/4L/4P+L/+T/mf/o/6n/6/+5/+z/xP/n/8f/2/+//8z/tPy//6X5 + tf+Z96//jPar/3j1rP9z97j/gvrD/4X9yf+Q/cv/qvu5/7jtkf+112f/z9mt2cW9u4iAfXm5AAAAkQAA + AFoAAAA3AAAAHQAAADMPDw+Rta6osMfT0Lc40tX/LM/Q/zHQz/8y0c7/NdTO/znXz/8/29H/ROHV/0zo + 2P9T7tz/WvTg/2D54v9l++H/avzf/27+3f90/9v/ev/a/4H/1/+K/tT/kPzL/5H4v/+N87D/he6f/4Dp + k/+B5o3/huWK/4/liP+W5of/muaG/5zihv+e2ob/pNeJ/6ncjP+s5pD/pO6U/5/wlv+h4oX/ytu32si/ + vYuCf3u6AAAAkQAAAFoAAAA2AAAAHQAAADMPDw+Rt6+qscnV0bk+2Nf/M9nV/zrd2P9A4tz/Rejf/0jq + 4P9J6tv/TOrW/07o0P9P5sn/UefD/1Xqwf9c8ML/ZPXC/2v3wP9v8rn/cOqv/27iof9r25X/a9mN/3TZ + jP9924v/gtuH/4fbgv+I2n7/itR6/4nNdP+HxW3/iL5o/4y4YP+St1X/k7ZL/5S1Tv+ZtlX/pL5d/67L + Yv+x123/0uC828rCwI2DgHy7AAAAkAAAAFoAAAA2AAAAHQAAADMPDw+RuLCss8rX07pG4dz/Od7W/zzb + 0f8/2s3/P9jI/0DUwv8/0Ln/Q9G2/0rXuP9S3rr/WuS9/1/kuf9f3rD/X9ai/1/Pl/9hzJD/Zc+M/2zT + if9x1oj/d9eE/37Vg/+D0X//fshz/3m+aP95uGP/e7Nf/3+wXP+FsFb/jLVR/4+8Uv+QwFv/k8Rk/5zF + Zf+hw2D/pMBY/6i7Uv+ps0D/0M+i3M3Hx5CEgX68AAAAkAAAAFoAAAA2AAAAHQAAADMPDw+RubKutMvW + 0rs/ysH/MsS3/zbDtP87x7b/Qc27/0bVwP9L2b//Ttq7/1HWs/9T0Kn/Vcqh/1jImv9dy5X/Y9CS/2nT + kP9u1Yz/cNOG/3DOfv9wx3X/cMJv/3vDcf+GxnH/gsFl/4G/Xv+Iv17/jMNc/5DHXP+QzGH/jM9u/4vL + c/+OwWz/j7lg/5GyVP+SqEn/lqJB/5icOv+WkSr/yMOb3NDMypGFgn+9AAAAkAAAAFoAAAA2AAAAHQAA + ADIPDw+RurOvtszW0bxCxbj/OMa2/0DNu/9F0r3/SdS9/0rSt/9LzKz/TMik/1HLoP9a0aH/Y9ih/2vc + nv9w3Jf/cdqP/3PXiP931YH/etV8/37Vdv+A1HD/hdNq/5XUbv+Z027/icll/4HGYv+Dx1z/hcJU/4K3 + VP99qVX/fJ1J/3yTPP97izT/fIYv/4CDK/+EgSj/iIAn/4uBJv+MfBr/xr2W3dPPzZOHhIG9AAAAkAAA + AFoAAAA2AAAAHQAAADIPDw+RvLWwts7Z071K0L7/Psq0/0LKr/9HzK3/T9Ox/1jdtv9f5bf/Y+q0/2rt + r/9y7Kn/eeqj/4Hmnf+C4pT/gNyK/3/Tfv99zHP/e8Rp/3e7Yf9ysl3/b69h/3e2cf9zuHD/aa9Z/3Gn + Qv94nDT/dI4v/3KGKv90gyb/doIk/3d/I/94fCH/enog/3x4IP+AeCD/g3kg/4d6Iv+Idhf/xLuW3tbR + 0JWHhIG+AAAAkAAAAFoAAAA2AAAAHQAAADIPDw+RvLWxuM/Z075W173/Utq7/1riv/9h6cL/aOzC/23t + v/9s6bP/aeCl/2nVl/9pzIz/bcSB/3C8d/9ts23/Z6lj/2SiXf9hnVv/XZpb/1yZXP9cnFv/ZaVZ/3aw + U/94pjv/cY8n/2+EJP9sgCX/bH4k/3B+I/92gCL/en8f/3p7Hv95eB7/eXcd/3t1Hv9+dR7/gHYf/4R3 + H/+FchX/w7qW3tfT0peHhYK/AAAAkAAAAFoAAAA2AAAAHQAAADIPDw+RvbazuNHb1b9k3r//WNez/1bP + qP9Tx5z/U7+U/1O5jv9Ss4T/UKp2/1Cha/9Tnmb/Wp5j/2ChZP9gn2L/XJld/1yYXP9cmFf/XphQ/2Sa + R/9nmDr/cJkv/32dKf92jyT/an0h/2p9If9ufyD/cn4e/3V+Hf98gB3/fX8c/3t6HP95dhz/eHQb/3lz + HP97cxz/fXQc/4J0Hf+CbxL/wrmV3tjU1JiIhoPAAAAAkAAAAFoAAAA2AAAAHQAAADIPDw+Qvbe1udDY + 0sBPt5b/QauH/0Khff9CnXT/RZ1y/0iecP9Lnm3/S5pn/0yVYv9QlGD/WZlf/2KhXv9ln1n/YplS/2WZ + TP9nmEP/aJQ5/2aNLP9mhST/dI0i/3+WI/9yhx//aXkc/2x7G/9xfhr/dYEa/3qAGv+Agxr/f4AZ/3x7 + Gv95dhr/eHIZ/3hxGv95cRn/fHEa/4ByG/+AbBD/wbiU39nW1pqIhoPAAAAAkAAAAFoAAAA2AAAAHQAA + ADIPDw+Qvrq2utDW0MFJo4D/P5xz/0KVbP9BkWb/RJJl/0eVZ/9LmGb/TZZh/0+TW/9UlFf/X5pU/2ui + U/9uoUz/bZtD/2+YO/9oji//ZIQl/2Z/IP9ugB3/e40e/32QHv9xgRv/a3kY/298F/90gRf/eYMY/36D + F/+Ehhj/g4IY/358GP96dhj/d3IY/3dwGP94bxj/em8Y/31wGf99ag7/wbiU4NzY15uJh4TBAAAAkAAA + AFoAAAA2AAAAHQAAADIPDw6Qv7q3u9DWz8FJnnT/QJdq/0KPZP9Di1//RYxd/0mQXP9Ok1r/UJNW/1OS + Uf9ak0z/aJxI/3ilRP96oT3/b5Qx/2yMKP9pgyH/a4Ac/219Gf9wfhj/eosa/3yOGv9xfxf/bnwW/3J/ + Ff96hBX/fYMW/4GFFv+Hhxb/hYMW/398Ff97dRb/eHIW/3dvFv93bhb/eG4W/3xuF/97aAz/wLiU4N3Z + 2JuJh4TBAAAAkAAAAFoAAAA2AAAAHQAAADIPDg6Qv7u4u9DWz8JLmm3/QpRh/0SNWv9Fh1P/SYhR/0yL + T/9Rjk7/V5RK/12XRv9mmUD/dqI8/4GmNf93mCz/booj/3OKHv9yhBr/cH8V/257FP9ygBb/fY8Y/36P + GP9ygBT/cn4U/3iDFP+AiBT/foUT/4aIFP+IiBT/hYMU/398E/98dhP/eXMU/3hwFP93bRX/d20V/3tt + Ff94Zgr/wLeT4N3Z2p2KiIXBAAAAkAAAAFoAAAA2AAAAHQAAADIODg6QwLy5vNHWz8JOmGP/RpNW/0eK + UP9Igkj/SoJG/1CIQ/9blEL/ZJs+/2qfO/9zoTX/eJ0s/32aJP95kiD/doob/3uMGf92hRb/cYAU/258 + Ev92hRP/g5MV/4WSFf92gxL/eIMS/3+HEv+EjBL/gYcR/4mKEf+IiRL/hIMS/4B8EP98dxH/e3QS/3lx + E/93bhP/eG0T/3lsFP93ZQn/wLeT4d7a252KiIXCAAAAkAAAAFoAAAA2AAAAHQAAADIPDg6QwLy5vNHW + zcNRlFj/SZJN/0yIR/9MgD//VYs8/2CXOv9lmDf/bqU1/3CgL/9tjiX/d5Eg/4OaHv9/khz/e4sX/4KN + Fv96hhT/dIAS/3N/Ef9/ixP/i5kU/4qVFP98hhH/fogR/4WNEf+GjRH/hYkO/4mLD/+IiA//hIEQ/398 + D/99eA//fXYQ/3xzEf96bxL/eW0S/3ptEv93Zgf/wLiS4d7a256LiIbCAAAAkAAAAFoAAAA2AAAAHQAA + ADIPDg6QwLy6vNLVzcNUklD/S5BD/1OOP/9elTr/YZQ0/2WYMf9urC//apgn/2WCIP9wiR7/f5Uc/4qb + Gv+Fkhr/gIsV/4SNE/98hhL/eIEP/3mDEP+GkhL/kp4S/4uWEf+Aig//gosO/4qREP+IjQ//iYsN/4uM + Df+Ihgz/hIEO/4B7Df9/eA3/gXgP/4B1D/9+chD/fW4R/3xtEf95aAb/wbmS4d/c3J+LiYbCAAAAjwAA + AFoAAAA2AAAAHQAAADIPDw+Rwby6vdLVzMRVkUf/WZ89/2WjOv9gjzD/ZKAu/2muLf9ljST/ZH0f/2uE + Hf93jRv/hZYY/4+bF/+Ikhr/gooS/4OMEP99hg7/eoIO/36HDv+NlxD/l6AQ/42VD/+FjQ3/h44N/4+U + D/+IjA7/jYwM/46KDP+JhAr/gn8M/396C/+BeAz/g3gN/4J1Df+Acw7/fm8P/31uD/98awT/wruS4d/c + 3J+LiYbDAAAAkAAAAFoAAAA2AAAAHQAAADIPDw+RwLy7vtPWzMRjo0L/YaY2/1+XMf9lri7/YqQp/1x+ + If9lgB7/aoIc/2+FGv99jRf/i5YV/5KaFv+JkBj/gogP/4OLDf9/hgz/fIML/4OKDP+Umw7/nKEP/42T + Df+Ijgz/jJEM/5CWDf+Liwz/kY4K/4+KC/+Jgwn/gn0K/4B5Cv+CeAv/g3gM/4N2Df+Acw3/f28N/35v + Df9+bgP/w72S4d7c3KCLiYbDAAAAjwAAAFoAAAA2AAAAHQAAADIPDw+Rwr27vdTYzMRfmTv/W6Ew/2a+ + M/9emCj/WHUf/197Hf9ogxv/bIIY/3KFF/+AjhT/jZcT/5KZFv+IjhX/gogM/4WJDP+AhQr/f4UJ/4iO + C/+ang3/naEN/42SC/+LkAv/kZUL/5KUC/+OjAn/lI8J/4+JCf+Jgwj/g30J/4F5CP+DeQj/g3gK/4J2 + C/9/cgz/fm8L/4BxDP+AcQL/xL6R4d/b3KCLiIXEAAAAjwAAAFoAAAA2AAAAHQAAADIPDw+Qwr28vtPU + y8Rgojn/YcEx/1uXKf9Zdx//W3gb/2F8Gf9rgxf/bYEV/3WFE/+DjhL/j5YP/5KXE/+HjBL/g4gK/4WJ + Cf+ChQj/gYYI/46SCP+eoQv/naAL/42RCf+OkQr/lpgK/5ORCf+Sjgj/lI8I/4+JCP+Jggf/g30G/4F6 + Bv+DeQf/gncJ/4F0Cv9+cQr/fW8J/4ByC/+BcwD/xL+R4t3a26GKiIXEAAAAjwAAAFoAAAA2AAAAHQAA + ADIPDw+Qwby8v9XczMVhuDf/VpEl/1qFIv9bfBz/XHcZ/2J7Fv9rgRT/b4AR/3eFEP+FjRD/jpUL/5GV + EP+GihD/g4YH/4WIB/+ChAf/hIYH/5SVB/+hogr/nJ0J/5GRB/+Tkgj/mZgJ/5KPCP+VkAf/lY8H/4+I + B/+Jggb/hH0F/4J6Bf+CeAb/gnYH/350CP97cAj/e3AI/4F0Cv+BdQD/xL+R4t3Y26KKiIXEAAAAjwAA + AFoAAAA2AAAAHQAAADIPDw+Qwb69v9TWy8ZZhCz/Voof/1yJIP9cexn/XHYW/2N5FP9sfxH/bn8O/3mE + Df+EjQz/jZMI/5GUEP+FiQ3/hIUF/4aGBf+ChAb/hocF/5iYBv+jpAb/m5oH/5ORB/+WlQb/mZcH/5KP + Bf+XkQb/lY4F/46HBv+IgQX/hHwE/4N7BP+CeAX/f3UG/3xyBv96bwb/e3EG/4J2Cf+CdwD/xL+Q4tzZ + 26KKiIXEAAAAjwAAAFoAAAA2AAAAHQAAADIPDw6Qw769v9TVy8ZXgin/V4sc/1yKHv9behj/XXQV/2N3 + Ev9rfA//b30N/3mCDP+Eiwv/jJEI/5CSEv+Ehgz/g4QD/4WFBf+CgwX/iokF/5uaBv+jpAX/mJYF/5OQ + Bv+Ylgb/lpMG/5SPBf+YkQb/k4sG/42EBv+HfwT/hHwD/4N7BP+AeAX/fXQE/3pwBf93bgb/enEG/4B2 + CP+CdwD/xMCP49zZ26OKiIXFAAAAjwAAAFoAAAA2AAAAHQAAADIPDw6Qw7++wNXVzMZYgCj/Voob/12K + G/9cehb/XXIT/2J1EP9rew7/bXwM/3iBC/+Eigr/io8H/46RE/+ChAn/gYID/4ODBf+Cggb/jYsF/52c + Bf+iogb/lZMF/5OQBv+YlQb/k48G/5WOBv+Xjwb/kIkG/4uCBv+FfQT/g3wD/4N6Bf9/dQX/enEE/3Vu + BP90bgX/eHEG/393CP+BeQD/xMGO49vZ26SKiIXFAAAAjwAAAFoAAAA2AAAAHQAAADIPDg6RxMC+wNXW + zMZZfib/V4kY/16KGf9behX/W3AS/2JzD/9peQz/bHoL/3eACf+DiQj/io0H/46QFf+Aggj/gIED/4GC + BP+BgQX/j40F/5+dBv+hngX/lI8G/5WQBv+YkwX/kosF/5aOBf+VjAb/j4YF/4iABf+EewP/g3sE/4J4 + Bf9+dAT/d3AE/3JtBP9ybQT/d3IF/3x3B/+AeQD/wb6N49vY26SJiIXGAAAAjwAAAFoAAAA2AAAAHQAA + ADIODg6QxMC/wNbWzMZZfCP/WIYV/16KGP9ceRT/XG8Q/2FxDf9odwz/bXgK/3Z/CP+Bhwj/iYsH/42O + Ff9+gAf/f4AE/3+AA/+CgQT/ko8G/6CeBv+emQb/kowH/5WPBv+VkAX/kYkG/5eMBv+TiQX/jYMF/4d+ + BP+DegP/g3kE/4B2BP98cgT/dW4E/3BrA/9xbQT/dXEF/3t4Bv97dwD/vbqN49za26WJiIXGAAAAjwAA + AFoAAAA2AAAAHQAAADIODg6QxcG/wNbXzcdXeiH/V4QT/16JFv9deRL/W24N/19wDP9ndAv/bHYJ/3V9 + B/+Bhgf/iIkH/4yNFv98fgX/fn4D/35+A/+DgAT/lJEF/6GeBv+alAb/kYkH/5WOBf+SiwX/kIcH/5aK + Bv+QhQX/i4EF/4Z8BP+CeAX/gXYF/35zBP96cAT/c2wE/29qA/9xbQP/dHEE/3t6Bf9zcAD/uriN493a + 26WKiIXGAAAAjwAAAFoAAAA2AAAAHQAAADIPDg6Qx8PBwdbXzcdWeB//V4IS/16IE/9ceRD/WmwN/15u + C/9lcgn/anUH/3V8B/+BhAb/hocG/4uLGP96ewX/fH0E/3x8A/+EgQT/lZMF/6GdBv+Vjwb/kIgF/5ON + Bf+PhwX/kYYG/5OHBf+MggX/ioAE/4R5BP+BdwX/gHUE/3xyBP92bgT/cGsE/29qA/9wbAP/c3ED/3l4 + Bf9taQD/ubWN493a26WKiIbGAAAAjwAAAFoAAAA2AAAAHQAAADIODg6Qx8PCwdjYzsdWdR//VX8P/12G + Ef9cdw7/WWoN/15sCv9jcQj/anMG/3R7Bv9/gwX/hIUG/4mJGf94eAP/ensE/3p6BP+FggT/l5QE/56b + Bf+PigX/j4YG/5CJBf+MgwX/kYUG/5CDBf+KfwT/iH8D/4F3Bf+AdQT/fnME/3pwBP9zbAT/cGoD/29q + A/9vbAP/dHID/3RzBf9nYgD/trOM493a3KaKiIbGAAAAjwAAAFoAAAA2AAAAHQAAADIODg6Qx8TDwdjY + zsdVch3/U3oN/1yEEP9cdg3/WWkL/11rCP9icAf/aXEG/3N5Bv9+gQT/goQH/4aHGf91dgL/eHgF/3l4 + BP+GgwP/mZQF/5uXBf+MhQX/jYYF/42FBP+JgAT/j4ME/4uABP+JfgT/hXsE/390BP9/dAT/fHIE/3du + BP9yawP/b2oD/29rA/9vbAP/c3MD/25tA/9hXQD/tLKM493a3KaKiIbGAAAAjwAAAFoAAAA2AAAAHQAA + ADIODg6QycXEwdnZz8dUbxv/UnYM/1uBDv9cdQv/WWkJ/1tpB/9gbgX/aHEF/3J3Bv97fgP/gIII/4SF + GP9ycwL/dnYF/3h3BP+IhAT/mJQF/5aSBP+IggX/ioMF/4iAA/+IfwT/jYEE/4d9BP+HfgT/gXgE/39z + BP99cgT/enAE/3RtBP9wagP/bmoD/25rA/9wbQP/cXED/2lnAv9cWAD/s7CL497a3KaKiIbGAAAAjwAA + AFoAAAA2AAAAHQAAADIODg6QysfFwdna0MhTbRn/UXIL/1t+Df9bdAr/WGgI/1pnB/9fbAb/Zm8F/3F2 + BP95fAL/f4EK/4KCFv9wcQL/dXQE/3d2BP+JhQT/mJQF/5GMBf+GfwX/hn8E/4N7BP+IfgT/iX4E/4V7 + A/+GfAT/fXQE/31yBP97cQT/d24E/3FrA/9uaQL/bWoC/21qAv9xbwP/bWwD/2RiA/9XVAD/sa6L5N/b + 3KiKiIbHAAAAjwAAAFoAAAA2AAAAGwAAADEODg6PysfFwdjYzsZRaRb/TW0G/1d6Cf9YcQb/VGUE/1dk + BP9caAP/ZGwB/25zAP92eQD/fX8K/31+Ev9sbQD/cXAB/3Z1Af+IhQL/lZEC/4uEAf+BewL/f3gB/393 + Av+EewH/hHoB/4N4Af+CeAH/eG8B/3lvAv93bgH/cmsC/21oAP9rZwD/a2cA/2tpAP9ubQD/ZmUA/2Bd + AP9STgD/rquJ497b3KeKiIbHAAAAjQAAAFgAAAA1AAAAGAAAACwQDw+MysbEv9LRx71WbR3+U3AP/1x7 + EP9ddQ7/WmoN/11pDv9jbQz/anEK/3N4C/96fAr/gYMX/36BGv9wcQj/dXQL/3t7DP+Niw3/l5QN/4qE + Df+Efg3/f3kM/4N8DP+IgAv/hnwM/4h/DP+CeQz/fXQM/310DP95cwz/dW8L/3JtCv9xbQn/cW0K/3Jx + Cv9xcAr/aWgL/2RiCv9WUgf/qaaH2tjV1aGMiojGAAAAiQAAAFIAAAAwAAAAFAAAACQLCwuCv7y4v9XR + y6PMzcDB0tTGzNTWx87V1sfO1NXHztXVx87V1cfP1tbHztjXx87Y18fO2dfIztfWx8zV1MXL1dPDytXU + w8nX1cPJ2NbDydbUw8jW08PI1dPDydbTw8nX1MPJ1tPDytfUxMrW1MTK1tPDytbTxMvW08TL1tTFy9bT + xcvV0sPL1NHDzNPRwszS0cLM0c/CzNHOwszJx7vFxsK7sM3IxJmEgoDGAAAAewAAAEYAAAAoAAAADgAA + ABoAAABTaWhmx9jUzrLg3Nmr4t3br+Ld26/j3tuv497br+Pf26/i39uw4d/br+He26/h3duv4Nvart7a + 2Kzc2Nap29bTqNnV0qfY1NGn2NPRp9jV0abZ1NGm2tTRpdnV0abZ1NKn2dTTqNrW1Kjb1tSo29bUqdzW + 1and2Nap3dnWqd3X1qra1tSq2NTTrNfU0qzX09Ks19PSrNfT0q3W0c+r0MvHp766tr0xMTC4AAAAVwAA + ADUAAAAeAAAACQAAABIAAAAnAAAAZzMzMqtPTk20TEtKs0tLSrRMS0q0TEtKtExLSrRMS0q0S0tKtEtL + SrRLS0q0S0tKs0tKSbNKSUmzS0pIs0pKSbNKSkizSkpIs0pKSLNLSUizS0pJsktKSbJLSkmzS0pJs0tK + SbNLSkmzTEpJs0xKSbNMSkmzTEpJs0xKSbNLSkmzS0pJs0tKSbNLSkmzS0pJs0tJSbNLSkm0TUxLth4d + HaMAAABeAAAAOAAAACUAAAATAAAABQAAAAsAAAAWAAAAIQAAAC0AAAA3AAAAOgAAADoAAAA6AAAAOgAA + ADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADoAAAA7AAAAOgAAADMAAAArAAAAIQAAABUAAAALAAAAAgAAAAQAAAAJAAAADgAAABMAAAAXAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGAAAABcAAAATAAAADgAAAAgAAAAEAAAAAAAAAAEAAAACAAAABAAA + AAcAAAAJAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAkAAAAHAAAABAAAAAIAAAABAAAAAAAA + 8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAA + AAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA + 8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAA + AAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA + 8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAA + AAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA8gQAAAAAAADyBAAAAAAAAPIEAAAAAAAA + 8gQAAAAAAADyBIAAAAAAAPIEKAAAABAAAAAgAAAAAQAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ABEAAABAAAAAVwAAAFUAAABVAAAAVQAAAFUAAABVAAAAVQAAAFUAAABVAAAAVQAAAFUAAABXAAAATAAA + AB8EBAQ+VlRQlXNybqFqamaeZ2dinWZkYJxqaGOdcG5pnXFwa550cm2feXRxn350c597cW+efHVwnU1K + RZgAAQFUFw4NUI+5uMNY4+b0Xt7b9Gbh2PRv59bzf/La9JP84vSx/+r0z//p9Nv/4vTP/930yv/Z9N// + ufKnp5OvAwEEZRkPDk6Eu7nPLtvX/zrbz/9F4Mn/VOrF/2Xuvf9y667/guWe/4nciP+K1Hf/jM5v/5bO + b/+v2HT/paeTuwQCBmIZDxBPirmy0D/Wwf9Q273/W9yt/2vZm/9x0IT/csZw/33Eav99tlT/fqdG/4Cb + QP+FjjH/mZAz/6SfjL0FBQhjGBAST5G6rtFOyqT/VsCS/1mze/9mrGv/ZqFZ/2WXRP9zmDT/bYIh/3V9 + HP96eBn/d28X/4p7Jf+kno3ABQYJYxkTFlCOq5vTPpFi/0eLV/9WlE//b51B/26NKv9tgBn/d4YX/3N+ + Ff+ChhX/gH0W/3ZuFP+FdyH/pZ+OwQYGCWMZFBhQkKiR1EuNRv9dlDr/bZgu/4CWHv98iBT/eoUR/4SQ + Ev+CihD/iYoP/4F9D/97cQ//hHYc/6Wgj8MGBgljGBQZUJasidReozD/Y40i/3OHGP+MlRX/gYgO/4iP + Df+RmA3/jZEM/42JCv+Cewr/gXQK/4l6F/+noo/EBgYJYxgUGlCXroXVWI8f/2J4Ff97iBD/jZIO/4OF + CP+TlQf/mJkI/5WSCP+PiAb/g3oF/31yBf+KfhP/p6OOxQYGCWMZFhtQlaOB1VeCFf9idRD/eoQK/4qM + C/+CggT/mJYF/5iVBv+WkAX/jIQF/4J4BP92bgP/h4AR/6ajjcYGBgljGRYcUJaif9ZYgA//YHAM/3d/ + CP+Ghwv/gIAE/5mVBv+UjQb/kogG/4h9BP99cwT/cGsB/4B+D/+joYzGBgYKYxoXHVCWoH7XU3cG/1tq + Bf9yeAL/fX4I/317AP+TjgH/ioIB/4p+Af+AdQD/dWwA/21pAP90cgn/oJ2MyAcHCmQaGB1RoaiK1maC + HP9teh3/gYYb/4mKIf+Nixr/m5Yb/5KKG/+Uihv/i4Eb/4F7Gv9+exf/fHoi/6WilMcHBwpjBgYHMXp5 + dKCcnZG2mZiNtJqZjbWZl4yzmJaIsJiWiLCYlYiwmZaJsZmVirGYlYqylpSJs5mXjbRqaGadAQEBPQAA + AAUAAAAeAAAAKgAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAArAAAAIwAA + AAoAAKxBAACsQQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAA + rEEAAKxB + + + \ No newline at end of file diff --git a/OnTopReplica/MainForm_ChildForms.cs b/OnTopReplica/MainForm_ChildForms.cs new file mode 100644 index 0000000..b9cdbac --- /dev/null +++ b/OnTopReplica/MainForm_ChildForms.cs @@ -0,0 +1,93 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using System.Drawing; + +namespace OnTopReplica { + + partial class MainForm { + + //SidePanel _currentSidePanel = null; + SidePanelContainer _sidePanelContainer = null; + + /// + /// Opens a new side panel. + /// + /// The side panel to embed. + public void SetSidePanel(SidePanel panel) { + if (IsSidePanelOpen) { + CloseSidePanel(); + } + + _sidePanelContainer = new SidePanelContainer(this); + _sidePanelContainer.SetSidePanel(panel); + _sidePanelContainer.Location = ComputeSidePanelLocation(_sidePanelContainer); + _sidePanelContainer.Show(this); + } + + /// + /// Closes the current side panel. + /// + public void CloseSidePanel() { + if (_sidePanelContainer == null || _sidePanelContainer.IsDisposed) { + _sidePanelContainer = null; + return; + } + + _sidePanelContainer.Hide(); + _sidePanelContainer.FreeSidePanel(); + } + + /// + /// Gets whether a side panel is currently shown. + /// + public bool IsSidePanelOpen { + get { + if (_sidePanelContainer == null) + return false; + if (_sidePanelContainer.IsDisposed) { + _sidePanelContainer = null; + return false; + } + + return _sidePanelContainer.Visible; + } + } + + /// + /// Moves the side panel based on the main form's current location. + /// + protected void AdjustSidePanelLocation() { + if (!IsSidePanelOpen) + return; + + _sidePanelContainer.Location = ComputeSidePanelLocation(_sidePanelContainer); + } + + /// + /// Computes the target location of a side panel form that ensures it is visible on the current + /// screen that contains the main form. + /// + private Point ComputeSidePanelLocation(Form sidePanel) { + //Check if moving the panel on the form's right would put it off-screen + var screen = Screen.FromControl(this); + if (Location.X + Width + sidePanel.Width > screen.WorkingArea.Right) { + return new Point(Location.X - sidePanel.Width, Location.Y); + } + else { + return new Point(Location.X + Width, Location.Y); + } + } + + void SidePanel_RequestClosing(object sender, EventArgs e) { + CloseSidePanel(); + } + + void Thumbnail_CloneClick(object sender, CloneClickEventArgs e) { + Win32Helper.InjectFakeMouseClick(CurrentThumbnailWindowHandle.Handle, e); + } + + } + +} diff --git a/OnTopReplica/MainForm_Features.cs b/OnTopReplica/MainForm_Features.cs new file mode 100644 index 0000000..2e2586a --- /dev/null +++ b/OnTopReplica/MainForm_Features.cs @@ -0,0 +1,130 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Properties; +using WindowsFormsAero.TaskDialog; +using System.Drawing; +using System.Windows.Forms; + +namespace OnTopReplica { + //Contains some feature implementations of MainForm + partial class MainForm { + + #region Click forwarding + + public bool ClickForwardingEnabled { + get { + return _thumbnailPanel.ReportThumbnailClicks; + } + set { + if (value && Settings.Default.FirstTimeClickForwarding) { + TaskDialog dlg = new TaskDialog(Strings.InfoClickForwarding, Strings.InfoClickForwardingTitle, Strings.InfoClickForwardingContent) { + CommonButtons = TaskDialogButton.Yes | TaskDialogButton.No + }; + if (dlg.Show(this).CommonButton == Result.No) + return; + + Settings.Default.FirstTimeClickForwarding = false; + } + + _thumbnailPanel.ReportThumbnailClicks = value; + } + } + + #endregion + + #region Click-through + + bool _clickThrough = false; + readonly Color DefaultNonClickTransparencyKey; + + public bool ClickThroughEnabled { + get { + return _clickThrough; + } + set { + //Adjust opacity if fully opaque + /*if (value && Opacity == 1.0) + Opacity = 0.75; + if (!value) + Opacity = 1.0;*/ + + //Enable transparency and force as top-most + TransparencyKey = (value) ? Color.Black : DefaultNonClickTransparencyKey; + if (value) + TopMost = true; + + _clickThrough = value; + } + } + + #endregion + + #region Chrome + + readonly FormBorderStyle DefaultBorderStyle; // = FormBorderStyle.Sizable; // FormBorderStyle.SizableToolWindow; + + public bool IsChromeVisible { + get { + return (FormBorderStyle == DefaultBorderStyle); + } + set { + //Cancel hiding chrome if no thumbnail is shown + if (!value && !_thumbnailPanel.IsShowingThumbnail) + return; + + if (!value) { + Location = new Point { + X = Location.X + SystemInformation.FrameBorderSize.Width, + Y = Location.Y + SystemInformation.FrameBorderSize.Height + }; + FormBorderStyle = FormBorderStyle.None; + } + else if(value) { + Location = new Point { + X = Location.X - SystemInformation.FrameBorderSize.Width, + Y = Location.Y - SystemInformation.FrameBorderSize.Height + }; + FormBorderStyle = DefaultBorderStyle; + } + + Program.Platform.OnFormStateChange(this); + Invalidate(); + } + } + + #endregion + + #region Position lock + + ScreenPosition? _positionLock = null; + + /// + /// Gets or sets the screen position where the window is currently locked in. + /// + public ScreenPosition? PositionLock { + get { + return _positionLock; + } + set { + if (value != null) + this.SetScreenPosition(value.Value); + + _positionLock = value; + } + } + + /// + /// Refreshes window position if in lock mode. + /// + private void RefreshScreenLock() { + //If locked in position, move accordingly + if (PositionLock.HasValue) { + this.SetScreenPosition(PositionLock.Value); + } + } + + #endregion + + } +} diff --git a/OnTopReplica/MainForm_Gui.cs b/OnTopReplica/MainForm_Gui.cs new file mode 100644 index 0000000..39141fb --- /dev/null +++ b/OnTopReplica/MainForm_Gui.cs @@ -0,0 +1,118 @@ +using System.Drawing; +using System.Windows.Forms; +using WindowsFormsAero.TaskDialog; + +namespace OnTopReplica { + partial class MainForm { + + /// + /// Opens the context menu. + /// + /// Optional position of the mouse, relative to which the menu is shown. + public void OpenContextMenu(Point? position) { + Point menuPosition = MousePosition; + if (position.HasValue) + menuPosition = position.Value; + + if (IsFullscreen) { + menuFullscreenContext.Show(menuPosition); + } + else { + menuContext.Show(menuPosition); + } + } + + /// + /// Gets the window's vertical chrome size. + /// + public int ChromeBorderVertical { + get { + if (IsChromeVisible) + return SystemInformation.FrameBorderSize.Height; + else + return 0; + } + } + + /// + /// Gets the window's horizontal chrome size. + /// + public int ChromeBorderHorizontal { + get { + if (IsChromeVisible) + return SystemInformation.FrameBorderSize.Width; + else + return 0; + } + } + + /// + /// Displays an error task dialog. + /// + /// Main instruction of the error dialog. + /// Detailed informations about the error. + /// Expanded error codes/messages. + private void ShowErrorDialog(string mainInstruction, string explanation, string errorMessage) { + TaskDialog dlg = new TaskDialog(mainInstruction, Strings.ErrorGenericTitle, explanation) { + CommonIcon = TaskDialogIcon.Stop, + IsExpanded = false + }; + + if (!string.IsNullOrEmpty(errorMessage)) { + dlg.ExpandedInformation = Strings.ErrorGenericInfoText + errorMessage; + dlg.ExpandedControlText = Strings.ErrorGenericInfoButton; + } + + dlg.Show(this); + } + + /// + /// Ensures that the main form is visible (either closing the fullscreen mode or reactivating from task icon). + /// + public void EnsureMainFormVisible() { + //Reset special modes + IsFullscreen = false; + ClickThroughEnabled = false; + Opacity = 1.0; + + //Restore main form in a platform-dependent method + Program.Platform.RestoreForm(this); + } + + /// + /// Opens a confirmation dialog to confirm whether to reset the main form or not. + /// + public void ResetMainFormWithConfirmation() { + var dlg = new TaskDialog(Strings.AskReset, Strings.AskResetTitle, Strings.AskResetContent); + dlg.UseCommandLinks = true; + dlg.CustomButtons = new CustomButton[] { + new CustomButton(Result.OK, Strings.AskResetButtonOk), + new CustomButton(Result.Cancel, Strings.ButtonCancel) + }; + dlg.CommonIcon = TaskDialogIcon.Information; + + if (dlg.Show(this).CommonButton == Result.OK) { + ResetMainForm(); + } + } + + /// + /// Resets the main form to its initial state. + /// + public void ResetMainForm() { + //Reset form settings + UnsetThumbnail(); + CloseSidePanel(); + + //Reset location and size (edge of the screen, min size) + Point nuLoc = Screen.PrimaryScreen.WorkingArea.Location; + nuLoc.Offset(40, 40); + Location = nuLoc; + Size = new Size(240, 220); + + this.Show(); + this.Activate(); + } + + } +} diff --git a/OnTopReplica/MainForm_MenuEvents.cs b/OnTopReplica/MainForm_MenuEvents.cs new file mode 100644 index 0000000..fbf6d99 --- /dev/null +++ b/OnTopReplica/MainForm_MenuEvents.cs @@ -0,0 +1,180 @@ +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; +using OnTopReplica.Properties; +using WindowsFormsAero.TaskDialog; +using OnTopReplica.SidePanels; + +namespace OnTopReplica { + partial class MainForm { + + private void Menu_opening(object sender, CancelEventArgs e) { + //Cancel if currently in "fullscreen" mode or a side panel is open + if (IsFullscreen || IsSidePanelOpen) { + e.Cancel = true; + return; + } + + bool showing = _thumbnailPanel.IsShowingThumbnail; + + selectRegionToolStripMenuItem.Enabled = showing; + switchToWindowToolStripMenuItem.Enabled = showing; + resizeToolStripMenuItem.Enabled = showing; + chromeToolStripMenuItem.Checked = IsChromeVisible; + clickForwardingToolStripMenuItem.Checked = ClickForwardingEnabled; + chromeToolStripMenuItem.Enabled = showing; + clickThroughToolStripMenuItem.Enabled = showing; + clickForwardingToolStripMenuItem.Enabled = showing; + } + + private void Menu_Switch_click(object sender, EventArgs e) { + if (CurrentThumbnailWindowHandle == null) + return; + + Program.Platform.HideForm(this); + Native.WindowManagerMethods.SetForegroundWindow(CurrentThumbnailWindowHandle.Handle); + } + + private void Menu_Advanced_opening(object sender, EventArgs e) { + restoreLastClonedWindowToolStripMenuItem.Checked = Settings.Default.RestoreLastWindow; + } + + private void Menu_GroupSwitchMode_click(object sender, EventArgs e) { + SetSidePanel(new SidePanels.GroupSwitchPanel()); + } + + private void Menu_RestoreLastWindow_click(object sender, EventArgs e) { + Settings.Default.RestoreLastWindow = !Settings.Default.RestoreLastWindow; + } + + private void Menu_ClickForwarding_click(object sender, EventArgs e) { + ClickForwardingEnabled = !ClickForwardingEnabled; + } + + private void Menu_ClickThrough_click(object sender, EventArgs e) { + ClickThroughEnabled = true; + } + + private void Menu_Opacity_opening(object sender, CancelEventArgs e) { + ToolStripMenuItem[] items = { + toolStripMenuItem1, + toolStripMenuItem2, + toolStripMenuItem3, + toolStripMenuItem4 + }; + + foreach (ToolStripMenuItem i in items) { + if (((double)i.Tag) == this.Opacity) + i.Checked = true; + else + i.Checked = false; + } + } + + private void Menu_Opacity_click(object sender, EventArgs e) { + //Get clicked menu item + ToolStripMenuItem tsi = sender as ToolStripMenuItem; + + if (tsi != null && this.Visible) { + //Get opacity from the tag + this.Opacity = (double)tsi.Tag; + Program.Platform.OnFormStateChange(this); + } + } + + private void Menu_Region_click(object sender, EventArgs e) { + SetSidePanel(new OnTopReplica.SidePanels.RegionPanel()); + } + + private void Menu_Resize_opening(object sender, CancelEventArgs e) { + if (!_thumbnailPanel.IsShowingThumbnail) + e.Cancel = true; + + restorePositionAndSizeToolStripMenuItem.Checked = Settings.Default.RestoreSizeAndPosition; + } + + private void Menu_Resize_Double(object sender, EventArgs e) { + FitToThumbnail(2.0); + } + + private void Menu_Resize_FitToWindow(object sender, EventArgs e) { + FitToThumbnail(1.0); + } + + private void Menu_Resize_Half(object sender, EventArgs e) { + FitToThumbnail(0.5); + } + + private void Menu_Resize_Quarter(object sender, EventArgs e) { + FitToThumbnail(0.25); + } + + private void Menu_Resize_Fullscreen(object sender, EventArgs e) { + IsFullscreen = true; + } + + private void Menu_Resize_RecallPosition_click(object sender, EventArgs e) { + Settings.Default.RestoreSizeAndPosition = !Settings.Default.RestoreSizeAndPosition; + } + + private void Menu_Position_Opening(object sender, EventArgs e) { + disabledToolStripMenuItem.Checked = (PositionLock == null); + topLeftToolStripMenuItem.Checked = (PositionLock == ScreenPosition.TopLeft); + topRightToolStripMenuItem.Checked = (PositionLock == ScreenPosition.TopRight); + centerToolStripMenuItem.Checked = (PositionLock == ScreenPosition.Center); + bottomLeftToolStripMenuItem.Checked = (PositionLock == ScreenPosition.BottomLeft); + bottomRightToolStripMenuItem.Checked = (PositionLock == ScreenPosition.BottomRight); + } + + private void Menu_Position_Disable(object sender, EventArgs e) { + PositionLock = null; + } + + private void Menu_Position_TopLeft(object sender, EventArgs e) { + PositionLock = ScreenPosition.TopLeft; + } + + private void Menu_Position_TopRight(object sender, EventArgs e) { + PositionLock = ScreenPosition.TopRight; + } + + private void Menu_Position_Center(object sender, EventArgs e) { + PositionLock = ScreenPosition.Center; + } + + private void Menu_Position_BottomLeft(object sender, EventArgs e) { + PositionLock = ScreenPosition.BottomLeft; + } + + private void Menu_Position_BottomRight(object sender, EventArgs e) { + PositionLock = ScreenPosition.BottomRight; + } + + private void Menu_Reduce_click(object sender, EventArgs e) { + //Hide form in a platform specific way + Program.Platform.HideForm(this); + } + + private void Menu_Chrome_click(object sender, EventArgs e) { + IsChromeVisible = !IsChromeVisible; + } + + private void Menu_Settings_click(object sender, EventArgs e) { + this.SetSidePanel(new OptionsPanel()); + } + + private void Menu_About_click(object sender, EventArgs e) { + this.SetSidePanel(new AboutPanel()); + } + + private void Menu_Close_click(object sender, EventArgs e) { + this.Close(); + } + + private void Menu_Fullscreen_ExitFullscreen_click(object sender, EventArgs e) { + IsFullscreen = false; + } + + } +} diff --git a/OnTopReplica/MessagePumpManager.cs b/OnTopReplica/MessagePumpManager.cs new file mode 100644 index 0000000..ad2b48d --- /dev/null +++ b/OnTopReplica/MessagePumpManager.cs @@ -0,0 +1,84 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; +using OnTopReplica.MessagePumpProcessors; +using OnTopReplica.Native; + +namespace OnTopReplica { + class MessagePumpManager : IDisposable { + + Dictionary _processors = new Dictionary(); + + public MainForm Form { get; private set; } + + private void Register(IMessagePumpProcessor processor, MainForm form) { + _processors[processor.GetType()] = processor; + processor.Initialize(form); + + System.Diagnostics.Trace.WriteLine(string.Format("Registered message pump processor: {0}", processor.GetType())); + } + + /// + /// Instantiates all message pump processors and registers them on the main form. + /// + /// + public void Initialize(MainForm form) { + Form = form; + + //Register window shell hook + if (!HookMethods.RegisterShellHookWindow(form.Handle)) { + Console.Error.WriteLine("Failed to register shell hook window."); + } + else { + System.Diagnostics.Trace.WriteLine("Shell hook window registered successfully."); + } + + //Register message pump processors + Register(new WindowKeeper(), form); + Register(new HotKeyManager(), form); + Register(new GroupSwitchManager(), form); + } + + /// + /// Run the registered message pump processors. + /// + /// Message to process. + /// True if the message has been handled internally. + public bool PumpMessage(ref Message msg) { + foreach (var processor in _processors.Values) { + if (processor.Process(ref msg)) + return true; + } + + return false; + } + + /// + /// Get the instance of a registered message pump processor. + /// Throws if instance not found. + /// + public T Get() { + return (T)_processors[typeof(T)]; + } + + #region IDisposable Members + + public void Dispose() { + if (!HookMethods.DeregisterShellHookWindow(Form.Handle)) { + Console.Error.WriteLine("Failed to deregister shell hook window."); + } + else { + System.Diagnostics.Trace.WriteLine("Deregistered shell hook window successfully."); + } + + foreach (var processor in _processors.Values) { + processor.Dispose(); + } + _processors.Clear(); + } + + #endregion + + } + +} diff --git a/OnTopReplica/MessagePumpProcessors/BaseMessagePumpProcessor.cs b/OnTopReplica/MessagePumpProcessors/BaseMessagePumpProcessor.cs new file mode 100644 index 0000000..cfb2c5a --- /dev/null +++ b/OnTopReplica/MessagePumpProcessors/BaseMessagePumpProcessor.cs @@ -0,0 +1,39 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica.MessagePumpProcessors { + abstract class BaseMessagePumpProcessor : IMessagePumpProcessor { + + protected MainForm Form { get; private set; } + + #region IMessagePumpProcessor Members + + public virtual void Initialize(MainForm form) { + Form = form; + } + + public abstract bool Process(ref Message msg); + + #endregion + + protected abstract void Shutdown(); + + bool _isDisposed = false; + + #region IDisposable Members + + public void Dispose() { + if (_isDisposed) + return; + + Shutdown(); + + _isDisposed = true; + } + + #endregion + + } +} diff --git a/OnTopReplica/MessagePumpProcessors/GroupSwitchManager.cs b/OnTopReplica/MessagePumpProcessors/GroupSwitchManager.cs new file mode 100644 index 0000000..e665ef9 --- /dev/null +++ b/OnTopReplica/MessagePumpProcessors/GroupSwitchManager.cs @@ -0,0 +1,136 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; +using System.Reflection; +using System.IO; +using System.Windows.Forms; +using OnTopReplica.Native; + +namespace OnTopReplica.MessagePumpProcessors { + + class GroupSwitchManager : BaseMessagePumpProcessor { + + bool _active = false; + List _lruHandles; + + /// + /// Enables group switch mode. + /// + /// List of window handles to track. + public void EnableGroupMode(IList handles) { + if (handles == null || handles.Count == 0) + return; + + //Okey dokey, will now track handles + TrackHandles(handles); + _active = true; + } + + /// + /// Initializes the LRU sorted list of window handles. + /// + private void TrackHandles(IList handles) { + _lruHandles = new List(handles.Count); + var now = DateTime.Now; + + foreach(var h in handles){ + _lruHandles.Add(new WindowHandleWrapper { + WindowHandle = h, + LastTimeUsed = now + }); + } + } + + /// + /// Disables group switch mode. + /// + public void Disable() { + if (!_active) + return; + + _lruHandles = null; + _active = false; + } + + /// + /// Processes the message pump. + /// + public override bool Process(ref Message msg) { + if (_active && msg.Msg == HookMethods.WM_SHELLHOOKMESSAGE) { + int hookCode = msg.WParam.ToInt32(); + if (hookCode == HookMethods.HSHELL_WINDOWACTIVATED || + hookCode == HookMethods.HSHELL_RUDEAPPACTIVATED) { + + IntPtr activeHandle = msg.LParam; + HandleForegroundWindowChange(activeHandle); + } + } + + return false; + } + + private void HandleForegroundWindowChange(IntPtr activeWindow) { + System.Diagnostics.Trace.WriteLine(string.Format("New active window (h {0}). ", activeWindow)); + + //Seek window in tracked handles + WindowHandleWrapper activated = null; + foreach (var i in _lruHandles) { + if (i.WindowHandle.Handle == activeWindow) + activated = i; + } + + if (activated == null) { + //New foreground window is not tracked + System.Diagnostics.Trace.WriteLine("Active window is not tracked."); + return; + } + + //Update tracked handle + activated.LastTimeUsed = DateTime.Now; + _lruHandles.Sort(new LruDateTimeComparer()); + + //Get least recently used + var next = _lruHandles[0]; + + System.Diagnostics.Trace.WriteLine(string.Format("Tracked. Switching to {0} (last use: {1}).", next.WindowHandle.Title, next.LastTimeUsed)); + + Form.SetThumbnail(next.WindowHandle, null); + } + + protected override void Shutdown() { + Disable(); + } + + /// + /// Gets whether the group switch manager ia active. + /// + public bool IsActive { + get { + return _active; + } + } + + #region List sorting stuff + + class WindowHandleWrapper { + public WindowHandle WindowHandle { get; set; } + public DateTime LastTimeUsed { get; set; } + } + + class LruDateTimeComparer : IComparer { + + #region IComparer Members + + public int Compare(WindowHandleWrapper x, WindowHandleWrapper y) { + return x.LastTimeUsed.CompareTo(y.LastTimeUsed); + } + + #endregion + } + + #endregion + + } + +} diff --git a/OnTopReplica/MessagePumpProcessors/HotKeyManager.cs b/OnTopReplica/MessagePumpProcessors/HotKeyManager.cs new file mode 100644 index 0000000..7b1b93e --- /dev/null +++ b/OnTopReplica/MessagePumpProcessors/HotKeyManager.cs @@ -0,0 +1,168 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Native; +using OnTopReplica.Properties; + +namespace OnTopReplica.MessagePumpProcessors { + + /// + /// HotKey registration helper. + /// + class HotKeyManager : BaseMessagePumpProcessor { + + public HotKeyManager() { + Enabled = true; + } + + delegate void HotKeyHandler(); + + /// + /// Wraps hot key handler registration data. + /// + private class HotKeyHandlerRegistration : IDisposable { + private HotKeyHandlerRegistration() { + } + + private HotKeyHandlerRegistration(IntPtr hwnd, int key, HotKeyHandler handler) { + if (hwnd == IntPtr.Zero) + throw new ArgumentException(); + if (handler == null) + throw new ArgumentNullException(); + + _hwnd = hwnd; + RegistrationKey = key; + Handler = handler; + } + + static int _lastUsedKey = 0; + + /// + /// Registers a new hotkey and returns a handle to the registration. + /// + /// Returns null on failure. + public static HotKeyHandlerRegistration Register(Form owner, int keyCode, int modifiers, HotKeyHandler handler) { + var key = ++_lastUsedKey; + + if (!HotKeyMethods.RegisterHotKey(owner.Handle, key, modifiers, keyCode)) { + Console.Error.WriteLine("Failed to create hotkey on keys {0}.", keyCode); + return null; + } + + return new HotKeyHandlerRegistration(owner.Handle, key, handler); + } + + IntPtr _hwnd; + public int RegistrationKey { get; private set; } + public HotKeyHandler Handler { get; private set; } + + public void Dispose() { + if (!HotKeyMethods.UnregisterHotKey(_hwnd, RegistrationKey)) { + Console.Error.WriteLine("Failed to unregister hotkey #{0}.", RegistrationKey); + } + } + } + + Dictionary _handlers = new Dictionary(); + + public override void Initialize(MainForm form) { + base.Initialize(form); + + RefreshHotkeys(); + } + + public override bool Process(ref Message msg) { + if (Enabled && msg.Msg == HotKeyMethods.WM_HOTKEY) { + int keyId = msg.WParam.ToInt32(); + if (!_handlers.ContainsKey(keyId)) + return false; + + _handlers[keyId].Handler.Invoke(); + } + + return false; + } + + public bool Enabled { get; set; } + + /// + /// Refreshes registered hotkeys from Settings. + /// + /// + /// Application settings contain hotkey registration strings that are used + /// automatically by this registration process. + /// + public void RefreshHotkeys() { + ClearHandlers(); + + RegisterHandler(Settings.Default.HotKeyCloneCurrent, HotKeyCloneHandler); + RegisterHandler(Settings.Default.HotKeyShowHide, HotKeyShowHideHandler); + } + + private void RegisterHandler(string spec, HotKeyHandler handler) { + if (string.IsNullOrEmpty(spec)) + return; //this can happen and is allowed => simply don't register + if (handler == null) + throw new ArgumentNullException(); + + int modifiers = 0, keyCode = 0; + + try { + HotKeyMethods.TranslateStringToKeyValues(spec, out modifiers, out keyCode); + } + catch (ArgumentException) { + //TODO: swallowed exception + return; + } + + var reg = HotKeyHandlerRegistration.Register(Form, keyCode, modifiers, handler); + if(reg != null) + _handlers.Add(reg.RegistrationKey, reg); + } + + private void ClearHandlers() { + foreach (var hotkey in _handlers) { + hotkey.Value.Dispose(); + } + _handlers.Clear(); + } + + protected override void Shutdown() { + ClearHandlers(); + } + + #region Hotkey callbacks + + /// + /// Handles "show/hide" hotkey. Ensures the form is in restored state and switches + /// between shown and hidden states. + /// + void HotKeyShowHideHandler() { + if (Form.IsFullscreen) + Form.IsFullscreen = false; + + if (!Program.Platform.IsHidden(Form)) { + Program.Platform.HideForm(Form); + } + else { + Form.EnsureMainFormVisible(); + } + } + + /// + /// Handles the "clone current" hotkey. + /// + void HotKeyCloneHandler() { + var handle = Win32Helper.GetCurrentForegroundWindow(); + if (handle.Handle == Form.Handle) + return; + + Form.SetThumbnail(handle, null); + } + + #endregion + + } + +} diff --git a/OnTopReplica/MessagePumpProcessors/ShellInterceptProcessor.cs b/OnTopReplica/MessagePumpProcessors/ShellInterceptProcessor.cs new file mode 100644 index 0000000..ca95066 --- /dev/null +++ b/OnTopReplica/MessagePumpProcessors/ShellInterceptProcessor.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Native; + +namespace OnTopReplica.MessagePumpProcessors { + +#if DEBUG + + /// + /// Basic shell message interceptor to use for debugging. + /// + class ShellInterceptProcessor : BaseMessagePumpProcessor { + + public override bool Process(ref Message msg) { + if (msg.Msg == HookMethods.WM_SHELLHOOKMESSAGE) { + int hookCode = msg.WParam.ToInt32(); + + System.Diagnostics.Trace.WriteLine(string.Format("Hook msg #{0}: {1}", hookCode, msg.LParam)); + } + + return false; + } + + protected override void Shutdown() { + + } + + } + +#endif + +} diff --git a/OnTopReplica/MessagePumpProcessors/WindowKeeper.cs b/OnTopReplica/MessagePumpProcessors/WindowKeeper.cs new file mode 100644 index 0000000..4a0c548 --- /dev/null +++ b/OnTopReplica/MessagePumpProcessors/WindowKeeper.cs @@ -0,0 +1,40 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Native; + +namespace OnTopReplica.MessagePumpProcessors { + + /// + /// Listens for shell events and closes the thumbnail if a cloned window is destroyed. + /// + class WindowKeeper : BaseMessagePumpProcessor { + + public override bool Process(ref Message msg) { + if (Form.CurrentThumbnailWindowHandle != null && + msg.Msg == HookMethods.WM_SHELLHOOKMESSAGE) { + int hookCode = msg.WParam.ToInt32(); + + if (hookCode == HookMethods.HSHELL_WINDOWDESTROYED) { + //Check whether the destroyed window is the one we were cloning + IntPtr destroyedHandle = msg.LParam; + if (destroyedHandle == Form.CurrentThumbnailWindowHandle.Handle) { + //Disable group switch mode, since a window of the group has been destroyed + Form.MessagePumpManager.Get().Disable(); + + //Disable cloning + Form.UnsetThumbnail(); + } + } + } + + return false; + } + + protected override void Shutdown() { + + } + } + +} diff --git a/OnTopReplica/NDesk/Options/Options.cs b/OnTopReplica/NDesk/Options/Options.cs new file mode 100644 index 0000000..24c4552 --- /dev/null +++ b/OnTopReplica/NDesk/Options/Options.cs @@ -0,0 +1,1042 @@ +// +// Options.cs (version 0.2.1) +// +// Authors: +// Jonathan Pryor +// +// Copyright (C) 2008 Novell (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Compile With: +// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll +// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll +// +// The LINQ version just changes the implementation of +// OptionSet.Parse(IEnumerable), and confers no semantic changes. + +// +// A Getopt::Long-inspired option parsing library for C#. +// +// NDesk.Options.OptionSet is built upon a key/value table, where the +// key is a option format string and the value is a delegate that is +// invoked when the format string is matched. +// +// Option format strings: +// Regex-like BNF Grammar: +// name: .+ +// type: [=:] +// sep: ( [^{}]+ | '{' .+ '}' )? +// aliases: ( name type sep ) ( '|' name type sep )* +// +// Each '|'-delimited name is an alias for the associated action. If the +// format string ends in a '=', it has a required value. If the format +// string ends in a ':', it has an optional value. If neither '=' or ':' +// is present, no value is supported. `=' or `:' need only be defined on one +// alias, but if they are provided on more than one they must be consistent. +// +// Each alias portion may also end with a "key/value separator", which is used +// to split option values if the option accepts > 1 value. If not specified, +// it defaults to '=' and ':'. If specified, it can be any character except +// '{' and '}' OR the *string* between '{' and '}'. If no separator should be +// used (i.e. the separate values should be distinct arguments), then "{}" +// should be used as the separator. +// +// Options are extracted either from the current option by looking for +// the option name followed by an '=' or ':', or is taken from the +// following option IFF: +// - The current option does not contain a '=' or a ':' +// - The current option requires a value (i.e. not a Option type of ':') +// +// The `name' used in the option format string does NOT include any leading +// option indicator, such as '-', '--', or '/'. All three of these are +// permitted/required on any named option. +// +// Option bundling is permitted so long as: +// - '-' is used to start the option group +// - all of the bundled options are a single character +// - at most one of the bundled options accepts a value, and the value +// provided starts from the next character to the end of the string. +// +// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' +// as '-Dname=value'. +// +// Option processing is disabled by specifying "--". All options after "--" +// are returned by OptionSet.Parse() unchanged and unprocessed. +// +// Unprocessed options are returned from OptionSet.Parse(). +// +// Examples: +// int verbose = 0; +// OptionSet p = new OptionSet () +// .Add ("v", v => ++verbose) +// .Add ("name=|value=", v => Console.WriteLine (v)); +// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); +// +// The above would parse the argument string array, and would invoke the +// lambda expression three times, setting `verbose' to 3 when complete. +// It would also print out "A" and "B" to standard output. +// The returned array would contain the string "extra". +// +// C# 3.0 collection initializers are supported and encouraged: +// var p = new OptionSet () { +// { "h|?|help", v => ShowHelp () }, +// }; +// +// System.ComponentModel.TypeConverter is also supported, allowing the use of +// custom data types in the callback type; TypeConverter.ConvertFromString() +// is used to convert the value option to an instance of the specified +// type: +// +// var p = new OptionSet () { +// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, +// }; +// +// Random other tidbits: +// - Boolean options (those w/o '=' or ':' in the option format string) +// are explicitly enabled if they are followed with '+', and explicitly +// disabled if they are followed with '-': +// string a = null; +// var p = new OptionSet () { +// { "a", s => a = s }, +// }; +// p.Parse (new string[]{"-a"}); // sets v != null +// p.Parse (new string[]{"-a+"}); // sets v != null +// p.Parse (new string[]{"-a-"}); // sets v == null +// + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Globalization; +using System.IO; +using System.Runtime.Serialization; +using System.Security.Permissions; +using System.Text; +using System.Text.RegularExpressions; + +#if LINQ +using System.Linq; +#endif + +#if TEST +using NDesk.Options; +#endif + +namespace NDesk.Options { + + public class OptionValueCollection : IList, IList { + + List values = new List(); + OptionContext c; + + internal OptionValueCollection(OptionContext c) { + this.c = c; + } + + #region ICollection + void ICollection.CopyTo(Array array, int index) { (values as ICollection).CopyTo(array, index); } + bool ICollection.IsSynchronized { get { return (values as ICollection).IsSynchronized; } } + object ICollection.SyncRoot { get { return (values as ICollection).SyncRoot; } } + #endregion + + #region ICollection + public void Add(string item) { values.Add(item); } + public void Clear() { values.Clear(); } + public bool Contains(string item) { return values.Contains(item); } + public void CopyTo(string[] array, int arrayIndex) { values.CopyTo(array, arrayIndex); } + public bool Remove(string item) { return values.Remove(item); } + public int Count { get { return values.Count; } } + public bool IsReadOnly { get { return false; } } + #endregion + + #region IEnumerable + IEnumerator IEnumerable.GetEnumerator() { return values.GetEnumerator(); } + #endregion + + #region IEnumerable + public IEnumerator GetEnumerator() { return values.GetEnumerator(); } + #endregion + + #region IList + int IList.Add(object value) { return (values as IList).Add(value); } + bool IList.Contains(object value) { return (values as IList).Contains(value); } + int IList.IndexOf(object value) { return (values as IList).IndexOf(value); } + void IList.Insert(int index, object value) { (values as IList).Insert(index, value); } + void IList.Remove(object value) { (values as IList).Remove(value); } + void IList.RemoveAt(int index) { (values as IList).RemoveAt(index); } + bool IList.IsFixedSize { get { return false; } } + object IList.this[int index] { get { return this[index]; } set { (values as IList)[index] = value; } } + #endregion + + #region IList + public int IndexOf(string item) { return values.IndexOf(item); } + public void Insert(int index, string item) { values.Insert(index, item); } + public void RemoveAt(int index) { values.RemoveAt(index); } + + private void AssertValid(int index) { + if (c.Option == null) + throw new InvalidOperationException("OptionContext.Option is null."); + if (index >= c.Option.MaxValueCount) + throw new ArgumentOutOfRangeException("index"); + if (c.Option.OptionValueType == OptionValueType.Required && + index >= values.Count) + throw new OptionException(string.Format( + c.OptionSet.MessageLocalizer("Missing required value for option '{0}'."), c.OptionName), + c.OptionName); + } + + public string this[int index] { + get { + AssertValid(index); + return index >= values.Count ? null : values[index]; + } + set { + values[index] = value; + } + } + #endregion + + public List ToList() { + return new List(values); + } + + public string[] ToArray() { + return values.ToArray(); + } + + public override string ToString() { + return string.Join(", ", values.ToArray()); + } + } + + public class OptionContext { + private Option option; + private string name; + private int index; + private OptionSet set; + private OptionValueCollection c; + + public OptionContext(OptionSet set) { + this.set = set; + this.c = new OptionValueCollection(this); + } + + public Option Option { + get { return option; } + set { option = value; } + } + + public string OptionName { + get { return name; } + set { name = value; } + } + + public int OptionIndex { + get { return index; } + set { index = value; } + } + + public OptionSet OptionSet { + get { return set; } + } + + public OptionValueCollection OptionValues { + get { return c; } + } + } + + public enum OptionValueType { + None, + Optional, + Required, + } + + public abstract class Option { + string prototype, description; + string[] names; + OptionValueType type; + int count; + string[] separators; + + protected Option(string prototype, string description) + : this(prototype, description, 1) { + } + + protected Option(string prototype, string description, int maxValueCount) { + if (prototype == null) + throw new ArgumentNullException("prototype"); + if (prototype.Length == 0) + throw new ArgumentException("Cannot be the empty string.", "prototype"); + if (maxValueCount < 0) + throw new ArgumentOutOfRangeException("maxValueCount"); + + this.prototype = prototype; + this.names = prototype.Split('|'); + this.description = description; + this.count = maxValueCount; + this.type = ParsePrototype(); + + if (this.count == 0 && type != OptionValueType.None) + throw new ArgumentException( + "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + + "OptionValueType.Optional.", + "maxValueCount"); + if (this.type == OptionValueType.None && maxValueCount > 1) + throw new ArgumentException( + string.Format("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), + "maxValueCount"); + if (Array.IndexOf(names, "<>") >= 0 && + ((names.Length == 1 && this.type != OptionValueType.None) || + (names.Length > 1 && this.MaxValueCount > 1))) + throw new ArgumentException( + "The default option handler '<>' cannot require values.", + "prototype"); + } + + public string Prototype { get { return prototype; } } + public string Description { get { return description; } } + public OptionValueType OptionValueType { get { return type; } } + public int MaxValueCount { get { return count; } } + + public string[] GetNames() { + return (string[])names.Clone(); + } + + public string[] GetValueSeparators() { + if (separators == null) + return new string[0]; + return (string[])separators.Clone(); + } + + protected static T Parse(string value, OptionContext c) { + TypeConverter conv = TypeDescriptor.GetConverter(typeof(T)); + T t = default(T); + try { + if (value != null) + t = (T)conv.ConvertFromString(value); + } + catch (Exception e) { + throw new OptionException( + string.Format( + c.OptionSet.MessageLocalizer("Could not convert string `{0}' to type {1} for option `{2}'."), + value, typeof(T).Name, c.OptionName), + c.OptionName, e); + } + return t; + } + + internal string[] Names { get { return names; } } + internal string[] ValueSeparators { get { return separators; } } + + static readonly char[] NameTerminator = new char[] { '=', ':' }; + + private OptionValueType ParsePrototype() { + char type = '\0'; + List seps = new List(); + for (int i = 0; i < names.Length; ++i) { + string name = names[i]; + if (name.Length == 0) + throw new ArgumentException("Empty option names are not supported.", "prototype"); + + int end = name.IndexOfAny(NameTerminator); + if (end == -1) + continue; + names[i] = name.Substring(0, end); + if (type == '\0' || type == name[end]) + type = name[end]; + else + throw new ArgumentException( + string.Format("Conflicting option types: '{0}' vs. '{1}'.", type, name[end]), + "prototype"); + AddSeparators(name, end, seps); + } + + if (type == '\0') + return OptionValueType.None; + + if (count <= 1 && seps.Count != 0) + throw new ArgumentException( + string.Format("Cannot provide key/value separators for Options taking {0} value(s).", count), + "prototype"); + if (count > 1) { + if (seps.Count == 0) + this.separators = new string[] { ":", "=" }; + else if (seps.Count == 1 && seps[0].Length == 0) + this.separators = null; + else + this.separators = seps.ToArray(); + } + + return type == '=' ? OptionValueType.Required : OptionValueType.Optional; + } + + private static void AddSeparators(string name, int end, ICollection seps) { + int start = -1; + for (int i = end + 1; i < name.Length; ++i) { + switch (name[i]) { + case '{': + if (start != -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + start = i + 1; + break; + case '}': + if (start == -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + seps.Add(name.Substring(start, i - start)); + start = -1; + break; + default: + if (start == -1) + seps.Add(name[i].ToString()); + break; + } + } + if (start != -1) + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + + public void Invoke(OptionContext c) { + OnParseComplete(c); + c.OptionName = null; + c.Option = null; + c.OptionValues.Clear(); + } + + protected abstract void OnParseComplete(OptionContext c); + + public override string ToString() { + return Prototype; + } + } + + [Serializable] + public class OptionException : Exception { + private string option; + + public OptionException() { + } + + public OptionException(string message, string optionName) + : base(message) { + this.option = optionName; + } + + public OptionException(string message, string optionName, Exception innerException) + : base(message, innerException) { + this.option = optionName; + } + + protected OptionException(SerializationInfo info, StreamingContext context) + : base(info, context) { + this.option = info.GetString("OptionName"); + } + + public string OptionName { + get { return this.option; } + } + + [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)] + public override void GetObjectData(SerializationInfo info, StreamingContext context) { + base.GetObjectData(info, context); + info.AddValue("OptionName", option); + } + } + + public delegate void OptionAction(TKey key, TValue value); + + public class OptionSet : KeyedCollection { + public OptionSet() + : this(delegate(string f) { return f; }) { + } + + public OptionSet(Converter localizer) { + this.localizer = localizer; + } + + Converter localizer; + + public Converter MessageLocalizer { + get { return localizer; } + } + + protected override string GetKeyForItem(Option item) { + if (item == null) + throw new ArgumentNullException("option"); + if (item.Names != null && item.Names.Length > 0) + return item.Names[0]; + // This should never happen, as it's invalid for Option to be + // constructed w/o any names. + throw new InvalidOperationException("Option has no names!"); + } + + [Obsolete("Use KeyedCollection.this[string]")] + protected Option GetOptionForName(string option) { + if (option == null) + throw new ArgumentNullException("option"); + try { + return base[option]; + } + catch (KeyNotFoundException) { + return null; + } + } + + protected override void InsertItem(int index, Option item) { + base.InsertItem(index, item); + AddImpl(item); + } + + protected override void RemoveItem(int index) { + base.RemoveItem(index); + Option p = Items[index]; + // KeyedCollection.RemoveItem() handles the 0th item + for (int i = 1; i < p.Names.Length; ++i) { + Dictionary.Remove(p.Names[i]); + } + } + + protected override void SetItem(int index, Option item) { + base.SetItem(index, item); + RemoveItem(index); + AddImpl(item); + } + + private void AddImpl(Option option) { + if (option == null) + throw new ArgumentNullException("option"); + List added = new List(option.Names.Length); + try { + // KeyedCollection.InsertItem/SetItem handle the 0th name. + for (int i = 1; i < option.Names.Length; ++i) { + Dictionary.Add(option.Names[i], option); + added.Add(option.Names[i]); + } + } + catch (Exception) { + foreach (string name in added) + Dictionary.Remove(name); + throw; + } + } + + public new OptionSet Add(Option option) { + base.Add(option); + return this; + } + + sealed class ActionOption : Option { + Action action; + + public ActionOption(string prototype, string description, int count, Action action) + : base(prototype, description, count) { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) { + action(c.OptionValues); + } + } + + public OptionSet Add(string prototype, Action action) { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action action) { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 1, + delegate(OptionValueCollection v) { action(v[0]); }); + base.Add(p); + return this; + } + + public OptionSet Add(string prototype, OptionAction action) { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction action) { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 2, + delegate(OptionValueCollection v) { action(v[0], v[1]); }); + base.Add(p); + return this; + } + + sealed class ActionOption : Option { + Action action; + + public ActionOption(string prototype, string description, Action action) + : base(prototype, description, 1) { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) { + action(Parse(c.OptionValues[0], c)); + } + } + + sealed class ActionOption : Option { + OptionAction action; + + public ActionOption(string prototype, string description, OptionAction action) + : base(prototype, description, 2) { + if (action == null) + throw new ArgumentNullException("action"); + this.action = action; + } + + protected override void OnParseComplete(OptionContext c) { + action( + Parse(c.OptionValues[0], c), + Parse(c.OptionValues[1], c)); + } + } + + public OptionSet Add(string prototype, Action action) { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action action) { + return Add(new ActionOption(prototype, description, action)); + } + + public OptionSet Add(string prototype, OptionAction action) { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction action) { + return Add(new ActionOption(prototype, description, action)); + } + + protected virtual OptionContext CreateOptionContext() { + return new OptionContext(this); + } + +#if LINQ + public List Parse (IEnumerable arguments) + { + bool process = true; + OptionContext c = CreateOptionContext (); + c.OptionIndex = -1; + var def = GetOptionForName ("<>"); + var unprocessed = + from argument in arguments + where ++c.OptionIndex >= 0 && (process || def != null) + ? process + ? argument == "--" + ? (process = false) + : !Parse (argument, c) + ? def != null + ? Unprocessed (null, def, c, argument) + : true + : false + : def != null + ? Unprocessed (null, def, c, argument) + : true + : true + select argument; + List r = unprocessed.ToList (); + if (c.Option != null) + c.Option.Invoke (c); + return r; + } +#else + public List Parse(IEnumerable arguments) { + OptionContext c = CreateOptionContext(); + c.OptionIndex = -1; + bool process = true; + List unprocessed = new List(); + Option def = Contains("<>") ? this["<>"] : null; + foreach (string argument in arguments) { + ++c.OptionIndex; + if (argument == "--") { + process = false; + continue; + } + if (!process) { + Unprocessed(unprocessed, def, c, argument); + continue; + } + if (!Parse(argument, c)) + Unprocessed(unprocessed, def, c, argument); + } + if (c.Option != null) + c.Option.Invoke(c); + return unprocessed; + } +#endif + + private static bool Unprocessed(ICollection extra, Option def, OptionContext c, string argument) { + if (def == null) { + extra.Add(argument); + return false; + } + c.OptionValues.Add(argument); + c.Option = def; + c.Option.Invoke(c); + return false; + } + + private readonly Regex ValueOption = new Regex( + @"^(?--|-|/)(?[^:=]+)((?[:=])(?.*))?$"); + + protected bool GetOptionParts(string argument, out string flag, out string name, out string sep, out string value) { + if (argument == null) + throw new ArgumentNullException("argument"); + + flag = name = sep = value = null; + Match m = ValueOption.Match(argument); + if (!m.Success) { + return false; + } + flag = m.Groups["flag"].Value; + name = m.Groups["name"].Value; + if (m.Groups["sep"].Success && m.Groups["value"].Success) { + sep = m.Groups["sep"].Value; + value = m.Groups["value"].Value; + } + return true; + } + + protected virtual bool Parse(string argument, OptionContext c) { + if (c.Option != null) { + ParseValue(argument, c); + return true; + } + + string f, n, s, v; + if (!GetOptionParts(argument, out f, out n, out s, out v)) + return false; + + Option p; + if (Contains(n)) { + p = this[n]; + c.OptionName = f + n; + c.Option = p; + switch (p.OptionValueType) { + case OptionValueType.None: + c.OptionValues.Add(n); + c.Option.Invoke(c); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + ParseValue(v, c); + break; + } + return true; + } + // no match; is it a bool option? + if (ParseBool(argument, n, c)) + return true; + // is it a bundled option? + if (ParseBundledValue(f, string.Concat(n + s + v), c)) + return true; + + return false; + } + + private void ParseValue(string option, OptionContext c) { + if (option != null) + foreach (string o in c.Option.ValueSeparators != null + ? option.Split(c.Option.ValueSeparators, StringSplitOptions.None) + : new string[] { option }) { + c.OptionValues.Add(o); + } + if (c.OptionValues.Count == c.Option.MaxValueCount || + c.Option.OptionValueType == OptionValueType.Optional) + c.Option.Invoke(c); + else if (c.OptionValues.Count > c.Option.MaxValueCount) { + throw new OptionException(localizer(string.Format( + "Error: Found {0} option values when expecting {1}.", + c.OptionValues.Count, c.Option.MaxValueCount)), + c.OptionName); + } + } + + private bool ParseBool(string option, string n, OptionContext c) { + Option p; + string rn; + if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') && + Contains((rn = n.Substring(0, n.Length - 1)))) { + p = this[rn]; + string v = n[n.Length - 1] == '+' ? option : null; + c.OptionName = option; + c.Option = p; + c.OptionValues.Add(v); + p.Invoke(c); + return true; + } + return false; + } + + private bool ParseBundledValue(string f, string n, OptionContext c) { + if (f != "-") + return false; + for (int i = 0; i < n.Length; ++i) { + Option p; + string opt = f + n[i].ToString(); + string rn = n[i].ToString(); + if (!Contains(rn)) { + if (i == 0) + return false; + throw new OptionException(string.Format(localizer( + "Cannot bundle unregistered option '{0}'."), opt), opt); + } + p = this[rn]; + switch (p.OptionValueType) { + case OptionValueType.None: + Invoke(c, opt, n, p); + break; + case OptionValueType.Optional: + case OptionValueType.Required: { + string v = n.Substring(i + 1); + c.Option = p; + c.OptionName = opt; + ParseValue(v.Length != 0 ? v : null, c); + return true; + } + default: + throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType); + } + } + return true; + } + + private static void Invoke(OptionContext c, string name, string value, Option option) { + c.OptionName = name; + c.Option = option; + c.OptionValues.Add(value); + option.Invoke(c); + } + + private const int OptionWidth = 29; + + public void WriteOptionDescriptions(TextWriter o) { + foreach (Option p in this) { + int written = 0; + if (!WriteOptionPrototype(o, p, ref written)) + continue; + + if (written < OptionWidth) + o.Write(new string(' ', OptionWidth - written)); + else { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + List lines = GetLines(localizer(GetDescription(p.Description))); + o.WriteLine(lines[0]); + string prefix = new string(' ', OptionWidth + 2); + for (int i = 1; i < lines.Count; ++i) { + o.Write(prefix); + o.WriteLine(lines[i]); + } + } + } + + bool WriteOptionPrototype(TextWriter o, Option p, ref int written) { + string[] names = p.Names; + + int i = GetNextOptionIndex(names, 0); + if (i == names.Length) + return false; + + if (names[i].Length == 1) { + Write(o, ref written, " -"); + Write(o, ref written, names[0]); + } + else { + Write(o, ref written, " --"); + Write(o, ref written, names[0]); + } + + for (i = GetNextOptionIndex(names, i + 1); + i < names.Length; i = GetNextOptionIndex(names, i + 1)) { + Write(o, ref written, ", "); + Write(o, ref written, names[i].Length == 1 ? "-" : "--"); + Write(o, ref written, names[i]); + } + + if (p.OptionValueType == OptionValueType.Optional || + p.OptionValueType == OptionValueType.Required) { + if (p.OptionValueType == OptionValueType.Optional) { + Write(o, ref written, localizer("[")); + } + Write(o, ref written, localizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description))); + string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 + ? p.ValueSeparators[0] + : " "; + for (int c = 1; c < p.MaxValueCount; ++c) { + Write(o, ref written, localizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description))); + } + if (p.OptionValueType == OptionValueType.Optional) { + Write(o, ref written, localizer("]")); + } + } + return true; + } + + static int GetNextOptionIndex(string[] names, int i) { + while (i < names.Length && names[i] == "<>") { + ++i; + } + return i; + } + + static void Write(TextWriter o, ref int n, string s) { + n += s.Length; + o.Write(s); + } + + private static string GetArgumentName(int index, int maxIndex, string description) { + if (description == null) + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + string[] nameStart; + if (maxIndex == 1) + nameStart = new string[] { "{0:", "{" }; + else + nameStart = new string[] { "{" + index + ":" }; + for (int i = 0; i < nameStart.Length; ++i) { + int start, j = 0; + do { + start = description.IndexOf(nameStart[i], j); + } while (start >= 0 && j != 0 ? description[j++ - 1] == '{' : false); + if (start == -1) + continue; + int end = description.IndexOf("}", start); + if (end == -1) + continue; + return description.Substring(start + nameStart[i].Length, end - start - nameStart[i].Length); + } + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + + private static string GetDescription(string description) { + if (description == null) + return string.Empty; + StringBuilder sb = new StringBuilder(description.Length); + int start = -1; + for (int i = 0; i < description.Length; ++i) { + switch (description[i]) { + case '{': + if (i == start) { + sb.Append('{'); + start = -1; + } + else if (start < 0) + start = i + 1; + break; + case '}': + if (start < 0) { + if ((i + 1) == description.Length || description[i + 1] != '}') + throw new InvalidOperationException("Invalid option description: " + description); + ++i; + sb.Append("}"); + } + else { + sb.Append(description.Substring(start, i - start)); + start = -1; + } + break; + case ':': + if (start < 0) + goto default; + start = i + 1; + break; + default: + if (start < 0) + sb.Append(description[i]); + break; + } + } + return sb.ToString(); + } + + private static List GetLines(string description) { + List lines = new List(); + if (string.IsNullOrEmpty(description)) { + lines.Add(string.Empty); + return lines; + } + int length = 80 - OptionWidth - 2; + int start = 0, end; + do { + end = GetLineEnd(start, length, description); + bool cont = false; + if (end < description.Length) { + char c = description[end]; + if (c == '-' || (char.IsWhiteSpace(c) && c != '\n')) + ++end; + else if (c != '\n') { + cont = true; + --end; + } + } + lines.Add(description.Substring(start, end - start)); + if (cont) { + lines[lines.Count - 1] += "-"; + } + start = end; + if (start < description.Length && description[start] == '\n') + ++start; + } while (end < description.Length); + return lines; + } + + private static int GetLineEnd(int start, int length, string description) { + int end = Math.Min(start + length, description.Length); + int sep = -1; + for (int i = start; i < end; ++i) { + switch (description[i]) { + case ' ': + case '\t': + case '\v': + case '-': + case ',': + case '.': + case ';': + sep = i; + break; + case '\n': + return i; + } + } + if (sep == -1 || end == description.Length) + return end; + return sep; + } + } +} + diff --git a/OnTopReplica/Native/CommonControls.cs b/OnTopReplica/Native/CommonControls.cs new file mode 100644 index 0000000..bf2123c --- /dev/null +++ b/OnTopReplica/Native/CommonControls.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + public static class CommonControls { + + [DllImport("comctl32.dll", EntryPoint = "InitCommonControlsEx", CallingConvention = CallingConvention.StdCall)] + static extern bool InitCommonControlsEx(ref INITCOMMONCONTROLSEX iccex); + + const int ICC_STANDARD_CLASSES = 0x00004000; + const int ICC_WIN95_CLASSES = 0x000000FF; + + public static bool InitStandard() { + INITCOMMONCONTROLSEX ex = new INITCOMMONCONTROLSEX(); + ex.dwSize = 8; + ex.dwICC = ICC_STANDARD_CLASSES | ICC_WIN95_CLASSES; + + return InitCommonControlsEx(ref ex); + } + + } + + struct INITCOMMONCONTROLSEX { + public int dwSize; + public int dwICC; + } + +} diff --git a/OnTopReplica/Native/ErrorMethods.cs b/OnTopReplica/Native/ErrorMethods.cs new file mode 100644 index 0000000..f1863eb --- /dev/null +++ b/OnTopReplica/Native/ErrorMethods.cs @@ -0,0 +1,37 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + /// + /// Common Win32 error handling methods. + /// + static class ErrorMethods { + + [DllImport("kernel32.dll")] + static extern uint FormatMessage(uint dwFlags, IntPtr lpSource, + int dwMessageId, uint dwLanguageId, [Out] StringBuilder lpBuffer, + uint nSize, IntPtr Arguments); + + /// + /// Gets a string representation of a Win32 error code. + /// + /// ID of the Win32 error code. + /// String representation of the error. + public static string GetErrorMessage(int msgCode) { + var sb = new StringBuilder(300); + FormatMessage((uint)(0x00001000), IntPtr.Zero, msgCode, 0, sb, 299, IntPtr.Zero); + return sb.ToString(); + } + + /// + /// Gets a string representation of the last Win32 error on this thread. + /// + public static string GetLastErrorMessage() { + int errorCode = Marshal.GetLastWin32Error(); + return GetErrorMessage(errorCode); + } + + } +} diff --git a/OnTopReplica/Native/FilesystemMethods.cs b/OnTopReplica/Native/FilesystemMethods.cs new file mode 100644 index 0000000..d48d741 --- /dev/null +++ b/OnTopReplica/Native/FilesystemMethods.cs @@ -0,0 +1,51 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; +using System.IO; + +namespace OnTopReplica.Native { + + /// + /// Native methods for filesystem interop. + /// + static class FilesystemMethods { + + /// + /// Gets the path to the current user's download path. + /// + /// + /// Code taken from http://stackoverflow.com/questions/3795023/downloads-folder-not-special-enough + /// + public static string DownloadsPath { + get { + string path = null; + + //Requires Vista or superior + if (Environment.OSVersion.Version.Major >= 6) { + IntPtr pathPtr; + Guid folderId = FolderDownloads; + int hr = SHGetKnownFolderPath(ref folderId, 0, IntPtr.Zero, out pathPtr); + if (hr == 0) { + path = Marshal.PtrToStringUni(pathPtr); + Marshal.FreeCoTaskMem(pathPtr); + return path; + } + } + + //Fallback code + path = Path.GetDirectoryName(Environment.GetFolderPath(Environment.SpecialFolder.Personal)); + path = Path.Combine(path, "Downloads"); + return path; + } + } + + + static readonly Guid FolderDownloads = new Guid("374DE290-123F-4565-9164-39C4925E467B"); + + [DllImport("shell32.dll", CharSet = CharSet.Auto)] + private static extern int SHGetKnownFolderPath(ref Guid id, int flags, IntPtr token, out IntPtr path); + + } + +} diff --git a/OnTopReplica/Native/HT.cs b/OnTopReplica/Native/HT.cs new file mode 100644 index 0000000..231e928 --- /dev/null +++ b/OnTopReplica/Native/HT.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Native { + /// + /// Native Win32 Hit Testing codes. + /// + static class HT { + public const int TRANSPARENT = -1; + public const int CLIENT = 1; + public const int CAPTION = 2; + } +} diff --git a/OnTopReplica/Native/HookMethods.cs b/OnTopReplica/Native/HookMethods.cs new file mode 100644 index 0000000..ea24f29 --- /dev/null +++ b/OnTopReplica/Native/HookMethods.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; + +namespace OnTopReplica.Native { + + /// + /// Helpers for interop with native Windows hooks. + /// + static class HookMethods { + + static HookMethods() { + WM_SHELLHOOKMESSAGE = RegisterWindowMessage("SHELLHOOK"); + if (WM_SHELLHOOKMESSAGE == 0) + Console.Error.WriteLine("Failed to register SHELLHOOK Windows message."); + } + + public static int WM_SHELLHOOKMESSAGE { + get; + private set; + } + + public const int HSHELL_WINDOWACTIVATED = 4; + public const int HSHELL_RUDEAPPACTIVATED = HSHELL_WINDOWACTIVATED | HSHELL_HIGHBIT; + const int HSHELL_HIGHBIT = 0x8000; + public const int HSHELL_WINDOWDESTROYED = 2; + public const int HSHELL_WINDOWCREATED = 1; + + /// + /// Registers the WM_ID for a window message. + /// + /// Name of the window message. + [DllImport("User32.dll")] + public static extern int RegisterWindowMessage(string wndMessageName); + + /// + /// Registers a window as a shell hook window. + /// + [DllImport("User32.dll")] + public static extern bool RegisterShellHookWindow(IntPtr hwnd); + + /// + /// Deregisters a window as a shell hook window. + /// + [DllImport("User32.dll")] + public static extern bool DeregisterShellHookWindow(IntPtr hwnd); + + } +} diff --git a/OnTopReplica/Native/HotKeyMethods.cs b/OnTopReplica/Native/HotKeyMethods.cs new file mode 100644 index 0000000..d40fee4 --- /dev/null +++ b/OnTopReplica/Native/HotKeyMethods.cs @@ -0,0 +1,78 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; +using System.Windows.Forms; + +namespace OnTopReplica.Native { + + [Flags] + public enum HotKeyModifiers : int { + Alt = 0x1, + Control = 0x2, + Shift = 0x4, + Windows = 0x8 + } + + /// + /// Static native methods for HotKey management. + /// + static class HotKeyMethods { + + public const int WM_HOTKEY = 0x312; + + [DllImport("user32.dll")] + public static extern bool RegisterHotKey(IntPtr hWnd, int id, int fsModifiers, int vlc); + + [DllImport("user32.dll")] + public static extern bool UnregisterHotKey(IntPtr hWnd, int id); + + /// + /// Translates a key combination specification into key code values. + /// + /// Key combination specification (see remarks). + /// Modifier values. + /// Key values. + /// + /// Specification can contain one single key value (from the enumeration System.Windows.Forms.Keys) + /// preceded by modifier strings (each one separated by a single '+'). + /// For instance: + /// [CTRL]+[ALT]+A + /// or + /// [ALT]+[SHIFT]+O + /// + public static void TranslateStringToKeyValues(string hotkeySpec, out int modifiers, out int keys) { + if (string.IsNullOrEmpty(hotkeySpec)) + throw new ArgumentNullException(); + + modifiers = 0; + keys = 0; + + if (ExtractModifier(ref hotkeySpec, "[CTRL]+")) + modifiers |= (int)HotKeyModifiers.Control; + if (ExtractModifier(ref hotkeySpec, "[ALT]+")) + modifiers |= (int)HotKeyModifiers.Alt; + if (ExtractModifier(ref hotkeySpec, "[SHIFT]+")) + modifiers |= (int)HotKeyModifiers.Shift; + + //Attempt to translate last part (should be single key) + try { + var keyValue = Enum.Parse(typeof(Keys), hotkeySpec, true); + keys = (int)keyValue; + } + catch (ArgumentException) { + throw new ArgumentException("Couldn't parse key value '" + hotkeySpec + "'."); + } + } + + private static bool ExtractModifier(ref string spec, string modifier) { + int modIndex = spec.IndexOf(modifier); + if (modIndex == -1) + return false; + + spec = spec.Remove(modIndex, modifier.Length); + return true; + } + + } +} diff --git a/OnTopReplica/Native/ITaskBarList.cs b/OnTopReplica/Native/ITaskBarList.cs new file mode 100644 index 0000000..e4a53bb --- /dev/null +++ b/OnTopReplica/Native/ITaskBarList.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + [ComImport, + Guid("56fdf342-fd6d-11d0-958a-006097c9a090"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface ITaskbarList { + /// + /// Initializes the taskbar list object. This method must be called before any other ITaskbarList methods can be called. + /// + void HrInit(); + + /// + /// Adds an item to the taskbar. + /// + /// A handle to the window to be added to the taskbar. + void AddTab([In] IntPtr hWnd); + + /// + /// Deletes an item from the taskbar. + /// + /// A handle to the window to be deleted from the taskbar. + void DeleteTab([In] IntPtr hWnd); + + /// + /// Activates an item on the taskbar. The window is not actually activated; the window's item on the taskbar is merely displayed as active. + /// + /// A handle to the window on the taskbar to be displayed as active. + void ActivateTab([In] IntPtr hWnd); + + /// + /// Marks a taskbar item as active but does not visually activate it. + /// + /// A handle to the window to be marked as active. + void SetActiveAlt([In] IntPtr hWnd); + } + + [ComImport] + [Guid("56fdf344-fd6d-11d0-958a-006097c9a090")] + public class CoTaskbarList { + } +} diff --git a/OnTopReplica/Native/InputMethods.cs b/OnTopReplica/Native/InputMethods.cs new file mode 100644 index 0000000..fe8233e --- /dev/null +++ b/OnTopReplica/Native/InputMethods.cs @@ -0,0 +1,25 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + static class InputMethods { + + [DllImport("user32.dll")] + static extern short GetKeyState(VirtualKeyState nVirtKey); + + const int KeyToggled = 0x1; + + const int KeyPressed = 0x8000; + + public static bool IsKeyPressed(VirtualKeyState virtKey) { + return (GetKeyState(virtKey) & KeyPressed) != 0; + } + + public static bool IsKeyToggled(VirtualKeyState virtKey) { + return (GetKeyState(virtKey) & KeyToggled) != 0; + } + + } +} diff --git a/OnTopReplica/Native/MK.cs b/OnTopReplica/Native/MK.cs new file mode 100644 index 0000000..90c7e90 --- /dev/null +++ b/OnTopReplica/Native/MK.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Native { + /// + /// Native Mouse click codes. + /// + static class MK { + public const int LBUTTON = 0x0001; + public const int RBUTTON = 0x0002; + public const int MBUTTON = 0x0010; + } +} diff --git a/OnTopReplica/Native/MessagingMethods.cs b/OnTopReplica/Native/MessagingMethods.cs new file mode 100644 index 0000000..cabe03e --- /dev/null +++ b/OnTopReplica/Native/MessagingMethods.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + /// + /// Common methods for Win32 messaging. + /// + static class MessagingMethods { + + [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = false)] + public static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam); + + [Flags] + public enum SendMessageTimeoutFlags : uint { + AbortIfHung = 2, + Block = 1, + Normal = 0 + } + + [DllImport("user32.dll")] + public static extern IntPtr SendMessageTimeout(IntPtr hwnd, uint message, IntPtr wparam, IntPtr lparam, SendMessageTimeoutFlags flags, uint timeout, out IntPtr result); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("user32.dll", SetLastError = false)] + public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam); + + public static IntPtr MakeLParam(int LoWord, int HiWord) { + return new IntPtr((HiWord << 16) | (LoWord & 0xffff)); + } + + } +} diff --git a/OnTopReplica/Native/Point.cs b/OnTopReplica/Native/Point.cs new file mode 100644 index 0000000..c34db85 --- /dev/null +++ b/OnTopReplica/Native/Point.cs @@ -0,0 +1,36 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + /// + /// Native Point structure. + /// + [StructLayout(LayoutKind.Sequential)] + public struct NPoint { + public int X, Y; + + public NPoint(int x, int y) { + X = x; + Y = y; + } + + public NPoint(NPoint copy) { + X = copy.X; + Y = copy.Y; + } + + public static NPoint FromPoint(System.Drawing.Point point) { + return new NPoint(point.X, point.Y); + } + + public System.Drawing.Point ToPoint() { + return new System.Drawing.Point(X, Y); + } + + public override string ToString() { + return "{" + X + "," + Y + "}"; + } + } +} diff --git a/OnTopReplica/Native/Rectangle.cs b/OnTopReplica/Native/Rectangle.cs new file mode 100644 index 0000000..cb138c8 --- /dev/null +++ b/OnTopReplica/Native/Rectangle.cs @@ -0,0 +1,55 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + /// A native Rectangle Structure. + [StructLayout(LayoutKind.Sequential)] + struct NRectangle { + public NRectangle(int left, int top, int right, int bottom) { + Left = left; + Top = top; + Right = right; + Bottom = bottom; + } + + public NRectangle(System.Drawing.Rectangle rect) { + Left = rect.X; + Top = rect.Y; + Right = rect.Right; + Bottom = rect.Bottom; + } + + public int Left; + public int Top; + public int Right; + public int Bottom; + + public int Width { + get { + return Right - Left; + } + } + public int Height { + get { + return Bottom - Top; + } + } + + public System.Drawing.Rectangle ToRectangle() { + return new System.Drawing.Rectangle(Left, Top, Right - Left, Bottom - Top); + } + + public System.Drawing.Size Size { + get { + return new System.Drawing.Size(Width, Height); + } + } + + public override string ToString() { + return string.Format("{{{0},{1},{2},{3}}}", Left, Top, Right, Bottom); + } + + } +} diff --git a/OnTopReplica/Native/VirtualKeyState.cs b/OnTopReplica/Native/VirtualKeyState.cs new file mode 100644 index 0000000..91e94a0 --- /dev/null +++ b/OnTopReplica/Native/VirtualKeyState.cs @@ -0,0 +1,193 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Native { + enum VirtualKeyState : int { + VK_LBUTTON = 0x01, + VK_RBUTTON = 0x02, + VK_CANCEL = 0x03, + VK_MBUTTON = 0x04, + // + VK_XBUTTON1 = 0x05, + VK_XBUTTON2 = 0x06, + // + VK_BACK = 0x08, + VK_TAB = 0x09, + // + VK_CLEAR = 0x0C, + VK_RETURN = 0x0D, + // + VK_SHIFT = 0x10, + VK_CONTROL = 0x11, + VK_MENU = 0x12, + VK_PAUSE = 0x13, + VK_CAPITAL = 0x14, + // + VK_KANA = 0x15, + VK_HANGEUL = 0x15, /* old name - should be here for compatibility */ + VK_HANGUL = 0x15, + VK_JUNJA = 0x17, + VK_FINAL = 0x18, + VK_HANJA = 0x19, + VK_KANJI = 0x19, + // + VK_ESCAPE = 0x1B, + // + VK_CONVERT = 0x1C, + VK_NONCONVERT = 0x1D, + VK_ACCEPT = 0x1E, + VK_MODECHANGE = 0x1F, + // + VK_SPACE = 0x20, + VK_PRIOR = 0x21, + VK_NEXT = 0x22, + VK_END = 0x23, + VK_HOME = 0x24, + VK_LEFT = 0x25, + VK_UP = 0x26, + VK_RIGHT = 0x27, + VK_DOWN = 0x28, + VK_SELECT = 0x29, + VK_PRINT = 0x2A, + VK_EXECUTE = 0x2B, + VK_SNAPSHOT = 0x2C, + VK_INSERT = 0x2D, + VK_DELETE = 0x2E, + VK_HELP = 0x2F, + // + VK_LWIN = 0x5B, + VK_RWIN = 0x5C, + VK_APPS = 0x5D, + // + VK_SLEEP = 0x5F, + // + VK_NUMPAD0 = 0x60, + VK_NUMPAD1 = 0x61, + VK_NUMPAD2 = 0x62, + VK_NUMPAD3 = 0x63, + VK_NUMPAD4 = 0x64, + VK_NUMPAD5 = 0x65, + VK_NUMPAD6 = 0x66, + VK_NUMPAD7 = 0x67, + VK_NUMPAD8 = 0x68, + VK_NUMPAD9 = 0x69, + VK_MULTIPLY = 0x6A, + VK_ADD = 0x6B, + VK_SEPARATOR = 0x6C, + VK_SUBTRACT = 0x6D, + VK_DECIMAL = 0x6E, + VK_DIVIDE = 0x6F, + VK_F1 = 0x70, + VK_F2 = 0x71, + VK_F3 = 0x72, + VK_F4 = 0x73, + VK_F5 = 0x74, + VK_F6 = 0x75, + VK_F7 = 0x76, + VK_F8 = 0x77, + VK_F9 = 0x78, + VK_F10 = 0x79, + VK_F11 = 0x7A, + VK_F12 = 0x7B, + VK_F13 = 0x7C, + VK_F14 = 0x7D, + VK_F15 = 0x7E, + VK_F16 = 0x7F, + VK_F17 = 0x80, + VK_F18 = 0x81, + VK_F19 = 0x82, + VK_F20 = 0x83, + VK_F21 = 0x84, + VK_F22 = 0x85, + VK_F23 = 0x86, + VK_F24 = 0x87, + // + VK_NUMLOCK = 0x90, + VK_SCROLL = 0x91, + // + VK_OEM_NEC_EQUAL = 0x92, // '=' key on numpad + // + VK_OEM_FJ_JISHO = 0x92, // 'Dictionary' key + VK_OEM_FJ_MASSHOU = 0x93, // 'Unregister word' key + VK_OEM_FJ_TOUROKU = 0x94, // 'Register word' key + VK_OEM_FJ_LOYA = 0x95, // 'Left OYAYUBI' key + VK_OEM_FJ_ROYA = 0x96, // 'Right OYAYUBI' key + // + VK_LSHIFT = 0xA0, + VK_RSHIFT = 0xA1, + VK_LCONTROL = 0xA2, + VK_RCONTROL = 0xA3, + VK_LMENU = 0xA4, + VK_RMENU = 0xA5, + // + VK_BROWSER_BACK = 0xA6, + VK_BROWSER_FORWARD = 0xA7, + VK_BROWSER_REFRESH = 0xA8, + VK_BROWSER_STOP = 0xA9, + VK_BROWSER_SEARCH = 0xAA, + VK_BROWSER_FAVORITES = 0xAB, + VK_BROWSER_HOME = 0xAC, + // + VK_VOLUME_MUTE = 0xAD, + VK_VOLUME_DOWN = 0xAE, + VK_VOLUME_UP = 0xAF, + VK_MEDIA_NEXT_TRACK = 0xB0, + VK_MEDIA_PREV_TRACK = 0xB1, + VK_MEDIA_STOP = 0xB2, + VK_MEDIA_PLAY_PAUSE = 0xB3, + VK_LAUNCH_MAIL = 0xB4, + VK_LAUNCH_MEDIA_SELECT = 0xB5, + VK_LAUNCH_APP1 = 0xB6, + VK_LAUNCH_APP2 = 0xB7, + // + VK_OEM_1 = 0xBA, // ';:' for US + VK_OEM_PLUS = 0xBB, // '+' any country + VK_OEM_COMMA = 0xBC, // ',' any country + VK_OEM_MINUS = 0xBD, // '-' any country + VK_OEM_PERIOD = 0xBE, // '.' any country + VK_OEM_2 = 0xBF, // '/?' for US + VK_OEM_3 = 0xC0, // '`~' for US + // + VK_OEM_4 = 0xDB, // '[{' for US + VK_OEM_5 = 0xDC, // '\|' for US + VK_OEM_6 = 0xDD, // ']}' for US + VK_OEM_7 = 0xDE, // ''"' for US + VK_OEM_8 = 0xDF, + // + VK_OEM_AX = 0xE1, // 'AX' key on Japanese AX kbd + VK_OEM_102 = 0xE2, // "<>" or "\|" on RT 102-key kbd. + VK_ICO_HELP = 0xE3, // Help key on ICO + VK_ICO_00 = 0xE4, // 00 key on ICO + // + VK_PROCESSKEY = 0xE5, + // + VK_ICO_CLEAR = 0xE6, + // + VK_PACKET = 0xE7, + // + VK_OEM_RESET = 0xE9, + VK_OEM_JUMP = 0xEA, + VK_OEM_PA1 = 0xEB, + VK_OEM_PA2 = 0xEC, + VK_OEM_PA3 = 0xED, + VK_OEM_WSCTRL = 0xEE, + VK_OEM_CUSEL = 0xEF, + VK_OEM_ATTN = 0xF0, + VK_OEM_FINISH = 0xF1, + VK_OEM_COPY = 0xF2, + VK_OEM_AUTO = 0xF3, + VK_OEM_ENLW = 0xF4, + VK_OEM_BACKTAB = 0xF5, + // + VK_ATTN = 0xF6, + VK_CRSEL = 0xF7, + VK_EXSEL = 0xF8, + VK_EREOF = 0xF9, + VK_PLAY = 0xFA, + VK_ZOOM = 0xFB, + VK_NONAME = 0xFC, + VK_PA1 = 0xFD, + VK_OEM_CLEAR = 0xFE + } +} diff --git a/OnTopReplica/Native/WM.cs b/OnTopReplica/Native/WM.cs new file mode 100644 index 0000000..eddcd01 --- /dev/null +++ b/OnTopReplica/Native/WM.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Native { + /// + /// Native Windows Message codes. + /// + static class WM { + public const int GETICON = 0x7f; + public const int SIZING = 0x214; + public const int NCHITTEST = 0x84; + public const int NCPAINT = 0x0085; + public const int LBUTTONDOWN = 0x0201; + public const int LBUTTONUP = 0x0202; + public const int LBUTTONDBLCLK = 0x0203; + public const int RBUTTONDOWN = 0x0204; + public const int RBUTTONUP = 0x0205; + public const int RBUTTONDBLCLK = 0x0206; + public const int NCLBUTTONUP = 0x00A2; + public const int NCLBUTTONDOWN = 0x00A1; + public const int NCLBUTTONDBLCLK = 0x00A3; + public const int NCRBUTTONUP = 0x00A5; + public const int SYSCOMMAND = 0x0112; + public const int GETTEXT = 0x000D; + public const int GETTEXTLENGTH = 0x000E; + } +} diff --git a/OnTopReplica/Native/WMSZ.cs b/OnTopReplica/Native/WMSZ.cs new file mode 100644 index 0000000..2052280 --- /dev/null +++ b/OnTopReplica/Native/WMSZ.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Native { + /// + /// Native Win32 sizing codes (used by WM_SIZING message). + /// + static class WMSZ { + public const int LEFT = 1; + public const int RIGHT = 2; + public const int TOP = 3; + public const int BOTTOM = 6; + } +} diff --git a/OnTopReplica/Native/WindowManagerMethods.cs b/OnTopReplica/Native/WindowManagerMethods.cs new file mode 100644 index 0000000..fdf4cb2 --- /dev/null +++ b/OnTopReplica/Native/WindowManagerMethods.cs @@ -0,0 +1,103 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + /// + /// Common Win32 Window Manager native methods. + /// + static class WindowManagerMethods { + + [DllImport("user32.dll")] + public static extern IntPtr GetForegroundWindow(); + + [DllImport("user32.dll")] + public static extern IntPtr RealChildWindowFromPoint(IntPtr parent, NPoint point); + + [return: MarshalAs(UnmanagedType.Bool)] + public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam); + + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam); + + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool EnumChildWindows(IntPtr hWnd, EnumWindowsProc lpEnumFunc, IntPtr lParam); + + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool IsWindowVisible(IntPtr hWnd); + + [DllImport("user32.dll")] + public static extern IntPtr GetDesktopWindow(); + + [DllImport("user32.dll")] + static extern bool ClientToScreen(IntPtr hwnd, ref NPoint point); + + /// + /// Converts a point in client coordinates of a window to screen coordinates. + /// + /// Handle to the window of the original point. + /// Point expressed in client coordinates. + /// Point expressed in screen coordinates. + public static NPoint ClientToScreen(IntPtr hwnd, NPoint clientPoint) { + NPoint localCopy = new NPoint(clientPoint); + + if (ClientToScreen(hwnd, ref localCopy)) + return localCopy; + else + return new NPoint(); + } + + [DllImport("user32.dll")] + static extern bool ScreenToClient(IntPtr hwnd, ref NPoint point); + + /// + /// Converts a point in screen coordinates in client coordinates relative to a window. + /// + /// Handle of the window whose client coordinate system should be used. + /// Point expressed in screen coordinates. + /// Point expressed in client coordinates. + public static NPoint ScreenToClient(IntPtr hwnd, NPoint screenPoint) { + NPoint localCopy = new NPoint(screenPoint); + + if (ScreenToClient(hwnd, ref localCopy)) + return localCopy; + else + return new NPoint(); + } + + [DllImport("user32.dll", CharSet = CharSet.Auto)] + public static extern IntPtr GetParent(IntPtr hWnd); + + [DllImport("user32.dll", SetLastError = false)] + public static extern bool SetForegroundWindow(IntPtr hwnd); + + public enum GetWindowMode : uint { + GW_HWNDFIRST = 0, + GW_HWNDLAST = 1, + GW_HWNDNEXT = 2, + GW_HWNDPREV = 3, + GW_OWNER = 4, + GW_CHILD = 5, + GW_ENABLEDPOPUP = 6 + } + + [DllImport("user32.dll")] + public static extern IntPtr GetWindow(IntPtr hwnd, GetWindowMode mode); + + /// + /// Checks whether a window is a top-level window (has no owner nor parent window). + /// + /// Handle to the window to check. + public static bool IsTopLevel(IntPtr hwnd) { + bool hasParent = WindowManagerMethods.GetParent(hwnd).ToInt64() != 0; + bool hasOwner = WindowManagerMethods.GetWindow(hwnd, WindowManagerMethods.GetWindowMode.GW_OWNER).ToInt64() != 0; + + return (!hasParent && !hasOwner); + } + + } +} diff --git a/OnTopReplica/Native/WindowMethods.cs b/OnTopReplica/Native/WindowMethods.cs new file mode 100644 index 0000000..06caede --- /dev/null +++ b/OnTopReplica/Native/WindowMethods.cs @@ -0,0 +1,141 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + /// + /// Common Win32 methods for operating on windows. + /// + static class WindowMethods { + + [DllImport("user32.dll", SetLastError = true)] + public static extern bool GetClientRect(IntPtr handle, out NRectangle rect); + + [DllImport("user32.dll", SetLastError = true)] + public static extern bool GetWindowRect(IntPtr handle, out NRectangle rect); + + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] + static extern int GetWindowText(IntPtr hWnd, [Out] StringBuilder lpString, int nMaxCount); + + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] + static extern int GetWindowTextLength(IntPtr hWnd); + + /// + /// Gets a window's text via API call. + /// + /// Window handle. + /// Title of the window. + public static string GetWindowText(IntPtr hwnd) { + int length = GetWindowTextLength(hwnd); + + if (length > 0) { + StringBuilder sb = new StringBuilder(length + 1); + if (WindowMethods.GetWindowText(hwnd, sb, sb.Capacity) > 0) + return sb.ToString(); + else + return String.Empty; + } + else + return String.Empty; + } + + const int MaxClassLength = 255; + + public static string GetWindowClass(IntPtr hwnd) { + var sb = new StringBuilder(MaxClassLength + 1); + RealGetWindowClass(hwnd, sb, MaxClassLength); + return sb.ToString(); + } + + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] + static extern uint RealGetWindowClass(IntPtr hwnd, [Out] StringBuilder lpString, uint maxCount); + + public enum WindowLong { + WndProc = (-4), + HInstance = (-6), + HwndParent = (-8), + Style = (-16), + ExStyle = (-20), + UserData = (-21), + Id = (-12) + } + + public enum ClassLong { + Icon = -14, + IconSmall = -34 + } + + [Flags] + public enum WindowStyles : long { + None = 0, + Disabled = 0x8000000L, + Minimize = 0x20000000L, + MinimizeBox = 0x20000L, + Visible = 0x10000000L + } + + [Flags] + public enum WindowExStyles : long { + AppWindow = 0x40000, + Layered = 0x80000, + NoActivate = 0x8000000L, + ToolWindow = 0x80, + TopMost = 8, + Transparent = 0x20 + } + + public static IntPtr GetWindowLong(IntPtr hWnd, WindowLong i) { + if (IntPtr.Size == 8) { + return GetWindowLongPtr64(hWnd, i); + } + else { + return new IntPtr(GetWindowLong32(hWnd, i)); + } + } + + [DllImport("user32.dll", EntryPoint = "GetWindowLong")] + static extern int GetWindowLong32(IntPtr hWnd, WindowLong nIndex); + + [DllImport("user32.dll", EntryPoint = "GetWindowLongPtr")] + static extern IntPtr GetWindowLongPtr64(IntPtr hWnd, WindowLong nIndex); + + public static IntPtr SetWindowLong(IntPtr hWnd, WindowLong i, IntPtr dwNewLong) { + if (IntPtr.Size == 8) { + return SetWindowLongPtr64(hWnd, i, dwNewLong); + } + else { + return new IntPtr(SetWindowLong32(hWnd, i, dwNewLong.ToInt32())); + } + } + + [DllImport("user32.dll", EntryPoint = "SetWindowLong")] + static extern int SetWindowLong32(IntPtr hWnd, WindowLong nIndex, int dwNewLong); + + [DllImport("user32.dll", EntryPoint = "SetWindowLongPtr")] + static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, WindowLong nIndex, IntPtr dwNewLong); + + #region Class styles + + [DllImport("user32.dll", EntryPoint = "GetClassLongPtrW")] + static extern IntPtr GetClassLong64(IntPtr hWnd, int nIndex); + + [DllImport("user32.dll", EntryPoint = "GetClassLongW")] + static extern int GetClassLong32(IntPtr hWnd, int nIndex); + + public static IntPtr GetClassLong(IntPtr hWnd, ClassLong i) { + if (IntPtr.Size == 8) { + return GetClassLong64(hWnd, (int)i); + } + else { + return new IntPtr(GetClassLong32(hWnd, (int)i)); + } + } + + #endregion + + [DllImport("user32.dll")] + public static extern IntPtr GetMenu(IntPtr hwnd); + + } +} diff --git a/OnTopReplica/Native/WindowsSevenMethods.cs b/OnTopReplica/Native/WindowsSevenMethods.cs new file mode 100644 index 0000000..88e5cf5 --- /dev/null +++ b/OnTopReplica/Native/WindowsSevenMethods.cs @@ -0,0 +1,20 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; + +namespace OnTopReplica.Native { + + static class WindowsSevenMethods { + + [DllImport("shell32.dll")] + internal static extern void SetCurrentProcessExplicitAppUserModelID( + [MarshalAs(UnmanagedType.LPWStr)] string appId); + + [DllImport("shell32.dll")] + internal static extern void GetCurrentProcessExplicitAppUserModelID( + [Out(), MarshalAs(UnmanagedType.LPWStr)] out string appId); + + } + +} diff --git a/OnTopReplica/NativeToolStripRenderer.cs b/OnTopReplica/NativeToolStripRenderer.cs new file mode 100644 index 0000000..4427e04 --- /dev/null +++ b/OnTopReplica/NativeToolStripRenderer.cs @@ -0,0 +1,601 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using System.Diagnostics.CodeAnalysis; +using System.Windows.Forms; +using System.Windows.Forms.VisualStyles; +using System.Runtime.InteropServices; + +namespace Asztal.Szótár { + public enum ToolbarTheme { + Toolbar, + MediaToolbar, + CommunicationsToolbar, + BrowserTabBar + } + + /// + /// Renders a toolstrip using the UxTheme API via VisualStyleRenderer. Visual styles must be supported for this to work; if you need to support other operating systems use + /// + class UXThemeToolStripRenderer : ToolStripSystemRenderer { + /// + /// It shouldn't be necessary to P/Invoke like this, however a bug in VisualStyleRenderer.GetMargins forces my hand. + /// + static internal class NativeMethods { + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct MARGINS { + public int cxLeftWidth; + public int cxRightWidth; + public int cyTopHeight; + public int cyBottomHeight; + } + + [DllImport("uxtheme", ExactSpelling = true)] + public extern static Int32 GetThemeMargins(IntPtr hTheme, IntPtr hdc, int iPartId, int iStateId, int iPropId, IntPtr rect, out MARGINS pMargins); + } + + //See http://msdn2.microsoft.com/en-us/library/bb773210.aspx - "Parts and States" + #region Parts and States + + enum MenuParts : int { + MENU_MENUITEM_TMSCHEMA = 1, + MENU_MENUDROPDOWN_TMSCHEMA = 2, + MENU_MENUBARITEM_TMSCHEMA = 3, + MENU_MENUBARDROPDOWN_TMSCHEMA = 4, + MENU_CHEVRON_TMSCHEMA = 5, + MENU_SEPARATOR_TMSCHEMA = 6, + MENU_BARBACKGROUND = 7, + MENU_BARITEM = 8, + MENU_POPUPBACKGROUND = 9, + MENU_POPUPBORDERS = 10, + MENU_POPUPCHECK = 11, + MENU_POPUPCHECKBACKGROUND = 12, + MENU_POPUPGUTTER = 13, + MENU_POPUPITEM = 14, + MENU_POPUPSEPARATOR = 15, + MENU_POPUPSUBMENU = 16, + MENU_SYSTEMCLOSE = 17, + MENU_SYSTEMMAXIMIZE = 18, + MENU_SYSTEMMINIMIZE = 19, + MENU_SYSTEMRESTORE = 20 + } + + enum MenuBarStates : int { + MB_ACTIVE = 1, + MB_INACTIVE = 2 + } + + enum MenuBarItemStates : int { + MBI_NORMAL = 1, + MBI_HOT = 2, + MBI_PUSHED = 3, + MBI_DISABLED = 4, + MBI_DISABLEDHOT = 5, + MBI_DISABLEDPUSHED = 6 + } + + enum MenuPopupItemStates : int { + MPI_NORMAL = 1, + MPI_HOT = 2, + MPI_DISABLED = 3, + MPI_DISABLEDHOT = 4 + } + + enum MenuPopupCheckStates : int { + MC_CHECKMARKNORMAL = 1, + MC_CHECKMARKDISABLED = 2, + MC_BULLETNORMAL = 3, + MC_BULLETDISABLED = 4 + } + + enum MenuPopupCheckBackgroundStates : int { + MCB_DISABLED = 1, + MCB_NORMAL = 2, + MCB_BITMAP = 3 + } + + enum MenuPopupSubMenuStates : int { + MSM_NORMAL = 1, + MSM_DISABLED = 2 + } + + enum MarginTypes : int { + TMT_SIZINGMARGINS = 3601, + TMT_CONTENTMARGINS = 3602, + TMT_CAPTIONMARGINS = 3603 + } + + const int RP_BACKGROUND = 6; + + #endregion + + #region Theme helpers + + Padding GetThemeMargins(IDeviceContext dc, MarginTypes marginType) { + NativeMethods.MARGINS margins; + try { + IntPtr hDC = dc.GetHdc(); + if (0 == NativeMethods.GetThemeMargins(renderer.Handle, hDC, renderer.Part, renderer.State, (int)marginType, IntPtr.Zero, out margins)) + return new Padding(margins.cxLeftWidth, margins.cyTopHeight, margins.cxRightWidth, margins.cyBottomHeight); + return new Padding(-1); + } finally { + dc.ReleaseHdc(); + } + } + + private static int GetItemState(ToolStripItem item) { + bool pressed = item.Pressed; + bool hot = item.Selected; + + if (item.Owner.IsDropDown) { + if (item.Enabled) + return hot ? (int)MenuPopupItemStates.MPI_HOT : (int)MenuPopupItemStates.MPI_NORMAL; + return hot ? (int)MenuPopupItemStates.MPI_DISABLEDHOT : (int)MenuPopupItemStates.MPI_DISABLED; + } else { + if (pressed) + return item.Enabled ? (int)MenuBarItemStates.MBI_PUSHED : (int)MenuBarItemStates.MBI_DISABLEDPUSHED; + if (item.Enabled) + return hot ? (int)MenuBarItemStates.MBI_HOT : (int)MenuBarItemStates.MBI_NORMAL; + return hot ? (int)MenuBarItemStates.MBI_DISABLEDHOT : (int)MenuBarItemStates.MBI_DISABLED; + } + } + + #endregion + + #region Theme subclasses + + public ToolbarTheme Theme { + get; set; + } + + private string RebarClass { + get { + return SubclassPrefix + "Rebar"; + } + } + + private string ToolbarClass { + get { + return SubclassPrefix + "ToolBar"; + } + } + + private string MenuClass { + get { + return SubclassPrefix + "Menu"; + } + } + + private string SubclassPrefix { + get { + switch (Theme) { + case ToolbarTheme.MediaToolbar: return "Media::"; + case ToolbarTheme.CommunicationsToolbar: return "Communications::"; + case ToolbarTheme.BrowserTabBar: return "BrowserTabBar::"; + default: return string.Empty; + } + } + } + + private VisualStyleElement Subclass(VisualStyleElement element) { + return VisualStyleElement.CreateElement(SubclassPrefix + element.ClassName, + element.Part, element.State); + } + + #endregion + + VisualStyleRenderer renderer; + + public UXThemeToolStripRenderer(ToolbarTheme theme) { + Theme = theme; + renderer = new VisualStyleRenderer(VisualStyleElement.Button.PushButton.Normal); + } + + #region Borders + protected override void OnRenderToolStripBorder(ToolStripRenderEventArgs e) { + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPBORDERS, 0); + if (e.ToolStrip.IsDropDown) { + Region oldClip = e.Graphics.Clip; + + //Tool strip borders are rendered *after* the content, for some reason. + //So we have to exclude the inside of the popup otherwise we'll draw over it. + Rectangle insideRect = e.ToolStrip.ClientRectangle; + insideRect.Inflate(-1, -1); + e.Graphics.ExcludeClip(insideRect); + + renderer.DrawBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.AffectedBounds); + + //Restore the old clip in case the Graphics is used again (does that ever happen?) + e.Graphics.Clip = oldClip; + } + } + #endregion + + #region Backgrounds + protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e) { + int partId = e.Item.Owner.IsDropDown ? (int)MenuParts.MENU_POPUPITEM : (int)MenuParts.MENU_BARITEM; + renderer.SetParameters(MenuClass, partId, GetItemState(e.Item)); + + Rectangle bgRect = e.Item.ContentRectangle; + + Padding content = GetThemeMargins(e.Graphics, MarginTypes.TMT_CONTENTMARGINS), + sizing = GetThemeMargins(e.Graphics, MarginTypes.TMT_SIZINGMARGINS), + caption = GetThemeMargins(e.Graphics, MarginTypes.TMT_CAPTIONMARGINS); + + if (!e.Item.Owner.IsDropDown) { + bgRect.Y = 0; + bgRect.Height = e.ToolStrip.Height; + bgRect.Inflate(-1, -1); //GetMargins here perhaps? + } + + renderer.DrawBackground(e.Graphics, bgRect, bgRect); + } + + protected override void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e) { + //Draw the background using Rebar & RP_BACKGROUND (or, if that is not available, fall back to + //Rebar.Band.Normal) + if (VisualStyleRenderer.IsElementDefined(VisualStyleElement.CreateElement(RebarClass, RP_BACKGROUND, 0))) { + renderer.SetParameters(RebarClass, RP_BACKGROUND, 0); + } else { + renderer.SetParameters(RebarClass, 0, 0); + //renderer.SetParameters(VisualStyleElement.Taskbar.BackgroundBottom.Normal); + //renderer.SetParameters(Subclass(VisualStyleElement.Rebar.Band.Normal)); + } + + if (renderer.IsBackgroundPartiallyTransparent()) + renderer.DrawParentBackground(e.Graphics, e.ToolStripPanel.ClientRectangle, e.ToolStripPanel); + + renderer.DrawBackground(e.Graphics, e.ToolStripPanel.ClientRectangle); + + //Draw the etched edges of each row. + //renderer.SetParameters(Subclass(VisualStyleElement.Rebar.Band.Normal)); + //foreach (ToolStripPanelRow row in e.ToolStripPanel.Rows) { + // Rectangle rowBounds = row.Bounds; + // rowBounds.Offset(0, -1); + // renderer.DrawEdge(e.Graphics, rowBounds, Edges.Top, EdgeStyle.Etched, EdgeEffects.None); + //} + + e.Handled = true; + } + + //Render the background of an actual menu bar, dropdown menu or toolbar. + protected override void OnRenderToolStripBackground(System.Windows.Forms.ToolStripRenderEventArgs e) { + if (e.ToolStrip.IsDropDown) { + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPBACKGROUND, 0); + } else { + //It's a MenuStrip or a ToolStrip. If it's contained inside a larger panel, it should have a + //transparent background, showing the panel's background. + + if (e.ToolStrip.Parent is ToolStripPanel) { + //The background should be transparent, because the ToolStripPanel's background will be visible. + //(Of course, we assume the ToolStripPanel is drawn using the same theme, but it's not my fault + //if someone does that.) + return; + } else { + //A lone toolbar/menubar should act like it's inside a toolbox, I guess. + //Maybe I should use the MenuClass in the case of a MenuStrip, although that would break + //the other themes... + if(VisualStyleRenderer.IsElementDefined(VisualStyleElement.CreateElement(RebarClass, RP_BACKGROUND, 0))) + renderer.SetParameters(RebarClass, RP_BACKGROUND, 0); + else + renderer.SetParameters(RebarClass, 0, 0); + } + } + + if (renderer.IsBackgroundPartiallyTransparent()) + renderer.DrawParentBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.ToolStrip); + + renderer.DrawBackground(e.Graphics, e.ToolStrip.ClientRectangle, e.AffectedBounds); + } + + protected override void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e) { + //e.Graphics.FillRectangle(Brushes.RosyBrown, e.ToolStripContentPanel.ClientRectangle); + //base.OnRenderToolStripContentPanelBackground(e); + } + + //Some sort of chevron thing? + //protected override void OnRenderOverflowButtonBackground(ToolStripItemRenderEventArgs e) { + // base.OnRenderOverflowButtonBackground(e); + //} + #endregion + + #region Text + protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e) { + int partId = e.Item.Owner.IsDropDown ? (int)MenuParts.MENU_POPUPITEM : (int)MenuParts.MENU_BARITEM; + renderer.SetParameters(MenuClass, partId, GetItemState(e.Item)); + Color color = renderer.GetColor(ColorProperty.TextColor); + + if(e.Item.Owner.IsDropDown || e.Item.Owner is MenuStrip) + e.TextColor = color; + + base.OnRenderItemText(e); + } + #endregion + + #region Glyphs + + //protected override void OnRenderGrip(ToolStripGripRenderEventArgs e) { + // if (e.GripStyle == ToolStripGripStyle.Visible) { + // renderer.SetParameters(VisualStyleElement.Rebar.Gripper.Normal); + // renderer.DrawBackground(e.Graphics, e.GripBounds, e.AffectedBounds); + // } + //} + + protected override void OnRenderImageMargin(ToolStripRenderEventArgs e) { + if (e.ToolStrip.IsDropDown) { + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPGUTTER, 0); + Rectangle displayRect = e.ToolStrip.DisplayRectangle, + marginRect = new Rectangle(0, displayRect.Top, displayRect.Left, displayRect.Height); + //e.Graphics.DrawRectangle(Pens.Black, marginRect); + renderer.DrawBackground(e.Graphics, marginRect, marginRect); + } + } + + protected override void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e) { + if (e.ToolStrip.IsDropDown) { + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPSEPARATOR, 0); + Rectangle rect = new Rectangle(e.ToolStrip.DisplayRectangle.Left, 0, e.ToolStrip.DisplayRectangle.Width, e.Item.Height); + renderer.DrawBackground(e.Graphics, rect, rect); + } else { + base.OnRenderSeparator(e); + } + } + + protected override void OnRenderItemCheck(ToolStripItemImageRenderEventArgs e) { + ToolStripMenuItem item = e.Item as ToolStripMenuItem; + if (item != null) { + if (item.Checked) { + Rectangle rect = e.Item.ContentRectangle; + rect.Width = rect.Height; + + //Center the checkmark horizontally in the gutter (looks ugly, though) + //rect.X = (e.ToolStrip.DisplayRectangle.Left - rect.Width) / 2; + + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPCHECKBACKGROUND, e.Item.Enabled ? (int)MenuPopupCheckBackgroundStates.MCB_NORMAL : (int)MenuPopupCheckBackgroundStates.MCB_DISABLED); + renderer.DrawBackground(e.Graphics, rect); + + Padding margins = GetThemeMargins(e.Graphics, MarginTypes.TMT_SIZINGMARGINS); + + rect = new Rectangle(rect.X + margins.Left, rect.Y + margins.Top, + rect.Width - margins.Horizontal, + rect.Height - margins.Vertical); + + //I don't think ToolStrip even supports radio box items. So no need to render them. + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPCHECK, e.Item.Enabled ? (int)MenuPopupCheckStates.MC_CHECKMARKNORMAL : (int)MenuPopupCheckStates.MC_CHECKMARKDISABLED); + + renderer.DrawBackground(e.Graphics, rect); + } + } else { + base.OnRenderItemCheck(e); + } + } + + //This is broken for RTL + protected override void OnRenderArrow(ToolStripArrowRenderEventArgs e) { + int stateId = e.Item.Enabled ? (int)MenuPopupSubMenuStates.MSM_NORMAL : (int)MenuPopupSubMenuStates.MSM_DISABLED; + renderer.SetParameters(MenuClass, (int)MenuParts.MENU_POPUPSUBMENU, stateId); + renderer.DrawBackground(e.Graphics, e.ArrowRectangle); + } + + protected override void OnRenderOverflowButtonBackground(ToolStripItemRenderEventArgs e) { + renderer.SetParameters(RebarClass, VisualStyleElement.Rebar.Chevron.Normal.Part, VisualStyleElement.Rebar.Chevron.Normal.State); + renderer.DrawBackground(e.Graphics, e.Item.ContentRectangle); + + //base.OnRenderOverflowButtonBackground(e); + } + #endregion + + private static bool? _isSupportedCache = null; + + public static bool IsSupported { + get { + if (_isSupportedCache.HasValue) + return _isSupportedCache.Value; + + if (!VisualStyleRenderer.IsSupported) { + _isSupportedCache = false; + return false; + } + + _isSupportedCache = VisualStyleRenderer.IsElementDefined(VisualStyleElement.CreateElement("MENU", (int)MenuParts.MENU_BARBACKGROUND, (int)MenuBarStates.MB_ACTIVE)); + return _isSupportedCache.Value; + } + } + } + + /// + /// Renders a toolstrip using UXTheme if possible, and switches back to the default + /// ToolStripRenderer when UXTheme-based rendering is not available. + /// Designed for menu bars and context menus - it is not guaranteed to work with anything else. + /// + /// + /// NativeToolStripRenderer.SetToolStripRenderer(toolStrip1, toolStrip2, contextMenuStrip1); + /// + /// + /// toolStrip1.Renderer = new NativeToolStripRenderer(); + /// + public class NativeToolStripRenderer : ToolStripRenderer { + UXThemeToolStripRenderer nativeRenderer; + ToolStripRenderer defaultRenderer; + ToolStrip toolStrip; + + //NativeToolStripRenderer looks best with no padding - but keep the old padding in case the + //visual styles become unsupported again (e.g. user changes to windows classic skin) + Padding defaultPadding; + + #region Constructors + /// + /// Creates a NativeToolStripRenderer for a particular ToolStrip. NativeToolStripRenderer will subscribe to some events + /// of this ToolStrip. + /// + /// The toolstrip for this NativeToolStripRenderer. NativeToolStripRenderer will subscribe to some events + /// of this ToolStrip. + public NativeToolStripRenderer(ToolStrip toolStrip, ToolbarTheme theme) { + if (toolStrip == null) + throw new ArgumentNullException("toolStrip", "ToolStrip cannot be null."); + + Theme = theme; + + this.toolStrip = toolStrip; + defaultRenderer = toolStrip.Renderer; + + defaultPadding = toolStrip.Padding; + toolStrip.SystemColorsChanged += new EventHandler(toolStrip_SystemColorsChanged); + + //Can't initialize here - constructor throws if visual styles not enabled + //nativeRenderer = new NativeToolStripRenderer(); + } + + public NativeToolStripRenderer(ToolStripPanel panel, ToolbarTheme theme) { + if (panel == null) + throw new ArgumentNullException("panel", "Panel cannot be null."); + + Theme = theme; + + this.toolStrip = null; + defaultRenderer = panel.Renderer; + } + #endregion + + public ToolbarTheme Theme { get; set; } + + void toolStrip_SystemColorsChanged(object sender, EventArgs e) { + if (toolStrip == null) + return; + + if (UXThemeToolStripRenderer.IsSupported) + toolStrip.Padding = Padding.Empty; + else + toolStrip.Padding = defaultPadding; + } + + //This is indeed called every time a menu part is rendered, but I can't + //find a way of caching it that I can be sure has no race conditions. + //The check is no longer very costly, anyway. + protected ToolStripRenderer ActualRenderer { + get { + bool nativeSupported = UXThemeToolStripRenderer.IsSupported; + + if (nativeSupported) { + if (nativeRenderer == null) + nativeRenderer = new UXThemeToolStripRenderer(Theme); + return nativeRenderer; + } + + return defaultRenderer; + } + } + + #region InitializeXXX + protected override void Initialize(ToolStrip toolStrip) { + base.Initialize(toolStrip); + + toolStrip.Padding = Padding.Empty; + + if (/*!(toolStrip is MenuStrip) &&*/ toolStrip.Parent is ToolStripPanel) { + toolStrip.BackColor = Color.Transparent; + } + } + + protected override void InitializePanel(ToolStripPanel toolStripPanel) { + base.InitializePanel(toolStripPanel); + } + + protected override void InitializeItem(ToolStripItem item) { + base.InitializeItem(item); + } + #endregion + + #region SetToolStripRenderer + /// + /// Sets the renderer of each ToolStrip to a NativeToolStripRenderer. A convenience method. + /// + /// A parameter list of ToolStrips. + [SuppressMessage("Microsoft.Design", "CA1062")] //The parameter array is actually checked. + public static void SetToolStripRenderer(ToolbarTheme theme, params Control[] toolStrips) { + foreach (Control ts in toolStrips) { + if (ts == null) + throw new ArgumentNullException("toolStrips", "ToolStrips cannot contain a null reference."); + } + + foreach (Control ts in toolStrips) { + if (ts is ToolStrip) { + ToolStrip t = (ToolStrip)ts; + t.Renderer = new NativeToolStripRenderer(t, theme); + } else if (ts is ToolStripPanel) { + ToolStripPanel t = (ToolStripPanel)ts; + t.Renderer = new NativeToolStripRenderer(t, theme); + } else + throw new ArgumentException("Can't set the renderer for a " + ts.GetType().Name); + } + } + + public static void SetToolStripRenderer(params Control[] toolStrips) { + SetToolStripRenderer(ToolbarTheme.Toolbar, toolStrips); + } + #endregion + + #region Overridden Methods - Deferred to actual renderer + protected override void OnRenderArrow(ToolStripArrowRenderEventArgs e) { + ActualRenderer.DrawArrow(e); + } + + protected override void OnRenderButtonBackground(ToolStripItemRenderEventArgs e) { + ActualRenderer.DrawButtonBackground(e); + } + + protected override void OnRenderDropDownButtonBackground(ToolStripItemRenderEventArgs e) { + ActualRenderer.DrawDropDownButtonBackground(e); + } + + protected override void OnRenderGrip(ToolStripGripRenderEventArgs e) { + ActualRenderer.DrawGrip(e); + } + + protected override void OnRenderImageMargin(ToolStripRenderEventArgs e) { + ActualRenderer.DrawImageMargin(e); + } + + protected override void OnRenderItemBackground(ToolStripItemRenderEventArgs e) { + ActualRenderer.DrawItemBackground(e); + } + + protected override void OnRenderItemCheck(ToolStripItemImageRenderEventArgs e) { + ActualRenderer.DrawItemCheck(e); + } + + protected override void OnRenderItemImage(ToolStripItemImageRenderEventArgs e) { + ActualRenderer.DrawItemImage(e); + } + + protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e) { + ActualRenderer.DrawItemText(e); + } + + protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e) { + ActualRenderer.DrawMenuItemBackground(e); + } + + protected override void OnRenderSeparator(ToolStripSeparatorRenderEventArgs e) { + ActualRenderer.DrawSeparator(e); + } + + protected override void OnRenderToolStripBackground(ToolStripRenderEventArgs e) { + ActualRenderer.DrawToolStripBackground(e); + } + + protected override void OnRenderToolStripBorder(ToolStripRenderEventArgs e) { + ActualRenderer.DrawToolStripBorder(e); + } + + protected override void OnRenderToolStripContentPanelBackground(ToolStripContentPanelRenderEventArgs e) { + ActualRenderer.DrawToolStripContentPanelBackground(e); + } + + protected override void OnRenderToolStripPanelBackground(ToolStripPanelRenderEventArgs e) { + ActualRenderer.DrawToolStripPanelBackground(e); + } + #endregion + } +} diff --git a/OnTopReplica/NotificationIcon.cs b/OnTopReplica/NotificationIcon.cs new file mode 100644 index 0000000..08292ae --- /dev/null +++ b/OnTopReplica/NotificationIcon.cs @@ -0,0 +1,85 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Properties; + +namespace OnTopReplica { + /// + /// Notification icon that installs itself in the "tray" and manipulates the OnTopReplica main form. + /// + class NotificationIcon : IDisposable { + + public NotificationIcon(MainForm form) { + Form = form; + Install(); + } + + public MainForm Form { get; private set; } + + NotifyIcon _taskIcon; + ContextMenuStrip _contextMenu; + + private void Install() { + _contextMenu = new ContextMenuStrip(); + _contextMenu.Items.AddRange(new ToolStripItem[] { + new ToolStripMenuItem(Strings.MenuOpen, Resources.icon, TaskIconOpen_click) { + ToolTipText = Strings.MenuOpenTT, + }, + new ToolStripMenuItem(Strings.MenuWindows, Resources.list){ + DropDown = Form.MenuWindows, + ToolTipText = Strings.MenuWindowsTT + }, + new ToolStripMenuItem(Strings.MenuReset, null, TaskIconReset_click){ + ToolTipText = Strings.MenuResetTT + }, + new ToolStripMenuItem(Strings.MenuClose, Resources.close_new, TaskIconExit_click){ + ToolTipText = Strings.MenuCloseTT + } + }); + Asztal.Szótár.NativeToolStripRenderer.SetToolStripRenderer(_contextMenu); + + _taskIcon = new NotifyIcon { + Text = Strings.ApplicationName, + Icon = Resources.icon_new, + Visible = true, + ContextMenuStrip = _contextMenu + }; + _taskIcon.DoubleClick += new EventHandler(TaskIcon_doubleclick); + } + + #region IDisposable Members + + public void Dispose() { + //Destroy NotifyIcon + if (_taskIcon != null) { + _taskIcon.Visible = false; + _taskIcon.Dispose(); + _taskIcon = null; + } + } + + #endregion + + #region Task Icon events + + void TaskIcon_doubleclick(object sender, EventArgs e) { + Form.EnsureMainFormVisible(); + } + + private void TaskIconOpen_click(object sender, EventArgs e) { + Form.EnsureMainFormVisible(); + } + + private void TaskIconReset_click(object sender, EventArgs e) { + Form.ResetMainFormWithConfirmation(); + } + + private void TaskIconExit_click(object sender, EventArgs e) { + Form.Close(); + } + + #endregion + + } +} diff --git a/OnTopReplica/OnTopReplica.csproj b/OnTopReplica/OnTopReplica.csproj new file mode 100644 index 0000000..0a59067 --- /dev/null +++ b/OnTopReplica/OnTopReplica.csproj @@ -0,0 +1,532 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {E626BD6E-BF38-4EB7-A128-5CA6F40EF557} + WinExe + Properties + OnTopReplica + OnTopReplica + v4.0 + 512 + Assets\icon-new.ico + false + false + Internet + OnTopReplica.Program + + + false + A305A505E19CF40E069521C80C13AB3C900EDB7C + OnTopReplica_1_TemporaryKey.pfx + false + + + + + 3.5 + + + + publish\ + true + Disk + true + Background + 1 + Weeks + true + false + true + http://www.klopfenstein.net/public/Uploads/ontopreplica/ + http://www.klopfenstein.net/lorenz.aspx/ontopreplica + en + OnTopReplica + Lorenz Cuno Klopfenstein + true + publish.htm + false + 0 + 3.4.0.%2a + false + true + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + false + true + + + pdbonly + true + bin\Release\ + + + prompt + 4 + + + true + false + + + + + + + + + OnTopReplica.exe.manifest + + + + + + + + + ..\Lib\WindowsFormsAero.dll + + + + + Form + + + + + + Component + + + Component + + + Form + + + Form + + + Form + + + Form + + + + + + + + + + + + + + + + + True + True + Resources.resx + + + True + True + Settings.settings + + + Form + + + SidePanelContainer.cs + + + UserControl + + + AboutPanel.cs + + + UserControl + + + AboutPanelContents.cs + + + UserControl + + + OptionsPanel.cs + + + UserControl + + + GroupSwitchPanel.cs + + + + + True + True + Strings.resx + + + + + + + + + + + + + SidePanelContainer.cs + + + AboutPanel.cs + + + AboutPanelContents.cs + + + ResXFileCodeGenerator + Strings.pl.Designer.cs + + + ResXFileCodeGenerator + Strings.Designer.cs + + + ResXFileCodeGenerator + Strings.ru.Designer.cs + + + + + + + + + + + + + + + + + UserControl + + + + Form + + + CommandLineReportForm.cs + + + + + + + + + + + + + + + + + Component + + + Form + + + MainForm.cs + + + + + + GroupSwitchPanel.cs + + + OptionsPanel.cs + + + CommandLineReportForm.cs + + + ResXFileCodeGenerator + Strings.cs.Designer.cs + + + ResXFileCodeGenerator + Strings.da.Designer.cs + + + ResXFileCodeGenerator + Strings.de.Designer.cs + + + ResXFileCodeGenerator + Strings.es.Designer.cs + + + ResXFileCodeGenerator + Strings.fi.Designer.cs + + + ResXFileCodeGenerator + Strings.it.Designer.cs + Designer + + + MainForm.cs + Designer + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + RegionPanel.cs + Designer + + + ResXFileCodeGenerator + Strings.no.Designer.cs + + + ResXFileCodeGenerator + Strings.pt-BR.Designer.cs + + + ResXFileCodeGenerator + Strings.pt.Designer.cs + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + UserControl + + + RegionPanel.cs + + + + + Component + + + + + + + + + + + + + + + + + + + + + + + + + + + + Always + + + Always + + + + + + + + + + + + + + + + + + + + + + + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 2.0 %28x86%29 + true + + + False + .NET Framework 3.0 %28x86%29 + false + + + False + .NET Framework 3.5 + false + + + False + .NET Framework 3.5 SP1 + false + + + + + + + + + + + + + + + + + + + + + + + + + + + False + + + + + Exclude + True + File + + + False + + + + + Exclude + True + File + + + False + + + + + Exclude + True + File + + + False + + + + + Exclude + True + File + + + False + + + + + Include + True + Satellite + + + False + + + + + Include + True + Satellite + + + False + + + + + Include + True + Satellite + + + + + + + + + \ No newline at end of file diff --git a/OnTopReplica/OnTopReplica.csproj.user b/OnTopReplica/OnTopReplica.csproj.user new file mode 100644 index 0000000..4b61895 --- /dev/null +++ b/OnTopReplica/OnTopReplica.csproj.user @@ -0,0 +1,23 @@ + + + + publish\ + http://www.klopfenstein.net/public/Uploads/ontopreplica/|http://www.klopfenstein.net/download.aspx%3ffile=ontopreplica%252fsetup.exe/|http://www.klopfenstein.net/lorenz/programming/ontopreplica/|http://www.klopfenstein.net/lorenz/programming/|http://lorenz.klopfenstein.net/ + http://www.klopfenstein.net/lorenz.aspx/ontopreplica|http://www.klopfenstein.net/loader.php%3fsection=lorenz&page=on_top_replica|http://www.klopfenstein.net/loader.php%3fsection=lorenz&page=programming_on_top_replica + http://www.klopfenstein.net/public/Uploads/ontopreplica/|http://www.klopfenstein.net/lorenz/programming/ontopreplica/ + + + en-US + false + + + ProjectFiles + + + false + + + + + + \ No newline at end of file diff --git a/OnTopReplica/OnTopReplica.exe.manifest b/OnTopReplica/OnTopReplica.exe.manifest new file mode 100644 index 0000000..0928f9f --- /dev/null +++ b/OnTopReplica/OnTopReplica.exe.manifest @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + Lightweight clone of a window. + + + + + + \ No newline at end of file diff --git a/OnTopReplica/PlatformSupport.cs b/OnTopReplica/PlatformSupport.cs new file mode 100644 index 0000000..5ecb432 --- /dev/null +++ b/OnTopReplica/PlatformSupport.cs @@ -0,0 +1,93 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Platforms; +using System.Windows.Forms; + +namespace OnTopReplica { + + abstract class PlatformSupport { + + /// + /// Creates a concrete PlatformSupport instance based on the OS the app is running on. + /// + public static PlatformSupport Create() { + var os = Environment.OSVersion; + + if (os.Platform != PlatformID.Win32NT) + return new Other(); + + if (os.Version.Major == 6) { + if (os.Version.Minor >= 2) + return new WindowsEight(); + else if (os.Version.Minor == 1) + return new WindowsSeven(); + else + return new WindowsVista(); + } + else if (os.Version.Major > 6) { + //Ensures forward compatibility + return new WindowsSeven(); + } + else { + //Generic NT + return new WindowsXp(); + } + } + + /// + /// Checks whether OnTopReplica is compatible with the platform. + /// + /// Returns false if OnTopReplica cannot run and should terminate right away. + public abstract bool CheckCompatibility(); + + /// + /// Initializes a form before it is fully constructed and before the window handle has been created. + /// + public virtual void PreHandleFormInit() { + } + + /// + /// Initializes a form after its handle has been created. + /// + /// Form to initialize. + public virtual void PostHandleFormInit(MainForm form) { + } + + /// + /// Called before closing a form. Called once during a form's lifetime. + /// + public virtual void CloseForm(MainForm form) { + } + + /// + /// Hides the main form in a way that it can be restored later by the user. + /// + /// Form to hide. + public virtual void HideForm(MainForm form) { + } + + /// + /// Gets whether the form is currently hidden or not. + /// + public virtual bool IsHidden(MainForm form) { + return false; + } + + /// + /// Restores the main form to its default state after is has been hidden. + /// Can be called whether the form is hidden or not. + /// + /// Form to restore. + public virtual void RestoreForm(MainForm form) { + } + + /// + /// Called when the form changes its state, without calling into or . + /// Enables inheritors to update the form's state on each state change. + /// + public virtual void OnFormStateChange(MainForm form) { + } + + } +} diff --git a/OnTopReplica/Platforms/DebugPlatform.cs b/OnTopReplica/Platforms/DebugPlatform.cs new file mode 100644 index 0000000..8b8da3a --- /dev/null +++ b/OnTopReplica/Platforms/DebugPlatform.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Platforms { + +#if DEBUG + + /// + /// Fake platform for debugging. + /// + class DebugPlatform : PlatformSupport { + + public override bool CheckCompatibility() { + return true; + } + + } + +#endif + +} diff --git a/OnTopReplica/Platforms/Other.cs b/OnTopReplica/Platforms/Other.cs new file mode 100644 index 0000000..abd253d --- /dev/null +++ b/OnTopReplica/Platforms/Other.cs @@ -0,0 +1,16 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica.Platforms { + class Other : PlatformSupport { + + public override bool CheckCompatibility() { + MessageBox.Show(Strings.ErrorNoDwm, Strings.ErrorNoDwmTitle, + MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + } +} diff --git a/OnTopReplica/Platforms/WindowsEight.cs b/OnTopReplica/Platforms/WindowsEight.cs new file mode 100644 index 0000000..c305954 --- /dev/null +++ b/OnTopReplica/Platforms/WindowsEight.cs @@ -0,0 +1,12 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Native; + +namespace OnTopReplica.Platforms { + class WindowsEight : WindowsSeven { + + } +} diff --git a/OnTopReplica/Platforms/WindowsSeven.cs b/OnTopReplica/Platforms/WindowsSeven.cs new file mode 100644 index 0000000..9d768a9 --- /dev/null +++ b/OnTopReplica/Platforms/WindowsSeven.cs @@ -0,0 +1,61 @@ +using System; +using System.Windows.Forms; +using OnTopReplica.Native; +using WindowsFormsAero.Dwm; + +namespace OnTopReplica.Platforms { + + class WindowsSeven : WindowsVista { + + public override void PreHandleFormInit() { + //Set Application ID + WindowsSevenMethods.SetCurrentProcessExplicitAppUserModelID("LorenzCunoKlopfenstein.OnTopReplica.MainForm"); + } + + public override void PostHandleFormInit(MainForm form) { + DwmManager.SetWindowFlip3dPolicy(form, Flip3DPolicy.ExcludeAbove); + DwmManager.SetExcludeFromPeek(form, true); + DwmManager.SetDisallowPeek(form, true); + } + + public override void HideForm(MainForm form) { + form.Opacity = 0; + } + + public override bool IsHidden(MainForm form) { + return (form.Opacity == 0.0); + } + + public override void RestoreForm(MainForm form) { + if (form.Opacity == 0.0) + form.Opacity = 1.0; + + form.Show(); + } + + /*public override void OnFormStateChange(MainForm form) { + //SetWindowStyle(form); + }*/ + + /// + /// Used to alter the window style. Not used anymore. + /// + private void SetWindowStyle(MainForm form) { + if (!form.IsFullscreen) { + //This hides the app from ALT+TAB + //Note that when minimized, it will be shown as an (ugly) minimized tool window + //thus we do not minimize, but set to transparent when hiding + long exStyle = WindowMethods.GetWindowLong(form.Handle, WindowMethods.WindowLong.ExStyle).ToInt64(); + + exStyle |= (long)(WindowMethods.WindowExStyles.ToolWindow); + //exStyle &= ~(long)(WindowMethods.WindowExStyles.AppWindow); + + WindowMethods.SetWindowLong(form.Handle, WindowMethods.WindowLong.ExStyle, new IntPtr(exStyle)); + + //WindowMethods.SetWindowLong(form.Handle, WindowMethods.WindowLong.HwndParent, WindowManagerMethods.GetDesktopWindow()); + } + } + + } + +} diff --git a/OnTopReplica/Platforms/WindowsVista.cs b/OnTopReplica/Platforms/WindowsVista.cs new file mode 100644 index 0000000..368db7f --- /dev/null +++ b/OnTopReplica/Platforms/WindowsVista.cs @@ -0,0 +1,52 @@ +using System; +using System.Windows.Forms; +using WindowsFormsAero.Dwm; + +namespace OnTopReplica.Platforms { + + class WindowsVista : PlatformSupport { + + public override bool CheckCompatibility() { + if (!WindowsFormsAero.OsSupport.IsCompositionEnabled) { + MessageBox.Show(Strings.ErrorDwmOffContent, Strings.ErrorDwmOff, MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + return true; + } + + NotificationIcon _icon; + + public override void PostHandleFormInit(MainForm form) { + //Do not show in task bar, but display notify icon + //NOTE: this effectively makes Windows ignore the Flip 3D policy set above (on Windows 7) + //NOTE: this also makes HotKey registration critically fail on Windows 7 + form.ShowInTaskbar = false; + + DwmManager.SetWindowFlip3dPolicy(form, Flip3DPolicy.ExcludeAbove); + + _icon = new NotificationIcon(form); + } + + public override void CloseForm(MainForm form) { + if (_icon != null) { + _icon.Dispose(); + _icon = null; + } + } + + public override bool IsHidden(MainForm form) { + return !form.Visible; + } + + public override void HideForm(MainForm form) { + form.Hide(); + } + + public override void RestoreForm(MainForm form) { + form.Show(); + } + + } + +} diff --git a/OnTopReplica/Platforms/WindowsXp.cs b/OnTopReplica/Platforms/WindowsXp.cs new file mode 100644 index 0000000..88d3895 --- /dev/null +++ b/OnTopReplica/Platforms/WindowsXp.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica.Platforms { + class WindowsXp : PlatformSupport { + + public override bool CheckCompatibility() { + MessageBox.Show(Strings.ErrorNoDwm, Strings.ErrorNoDwmTitle, MessageBoxButtons.OK, MessageBoxIcon.Error); + return false; + } + + } +} diff --git a/OnTopReplica/PluginRegionLocator.cs b/OnTopReplica/PluginRegionLocator.cs new file mode 100644 index 0000000..eaebb70 --- /dev/null +++ b/OnTopReplica/PluginRegionLocator.cs @@ -0,0 +1,102 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using OnTopReplica.Native; + +namespace OnTopReplica { + /// + /// Facility class that attempts to locate the region occupied by plugins inside another window. + /// + class PluginRegionLocator { + + static PluginRegionLocator() { + _pluginClassNames = new HashSet() { + //Opera 11 Flash plugin + "aPluginWinClass", + + //IE 9 Flash plugin + "MacromediaFlashPlayerActiveX", + + //Google Chrome + "NativeWindowClass", //Flash plugin + "Chrome_RenderWidgetHostHWND", //Tab content + + //Firefox 9 Flash plugin + "GeckoPluginWindow", + }; + } + + static readonly HashSet _pluginClassNames; + + /// + /// Attempts to locate a plugin region inside a window. + /// + /// The handle to the parent window. + /// The region where a plugin window is located or null if none found. + public Rectangle? LocatePluginRegion(WindowHandle handle) { + if (handle == null) + throw new ArgumentNullException(); + + WindowManagerMethods.EnumChildWindows(handle.Handle, LocatingWndProc, IntPtr.Zero); + + if (_selectedHandle != null) { + Console.Out.WriteLine("Selected {0} '{1}' (class {2})", _selectedHandle.Handle, _selectedHandle.Title, _selectedHandle.Class); + + NRectangle rect; + WindowMethods.GetWindowRect(_selectedHandle.Handle, out rect); + + NRectangle clientRect; + WindowMethods.GetClientRect(_selectedHandle.Handle, out clientRect); + + Console.Out.WriteLine("WindowRect: {0}", rect); + + NRectangle ownerRect; + WindowMethods.GetWindowRect(handle.Handle, out ownerRect); + + Console.Out.WriteLine("Owner WindowRect: {0}", ownerRect); + + var ret = new Rectangle { + X = rect.Left - ownerRect.Left, + Y = rect.Top - ownerRect.Top, + Width = clientRect.Width, + Height = clientRect.Height + }; + + //Safety check (this may happen when the plugin client area is 0 pixel large) + if (ret.Width < 0 || ret.Height < 0) + return null; + + Console.Out.WriteLine("Selected region: {0}", ret); + + return ret; + } + else { + Console.Out.WriteLine("None found."); + return null; + } + } + + WindowHandle _selectedHandle = null; + + private bool LocatingWndProc(IntPtr handle, IntPtr lParam) { + //Skip non visible windows + if (!WindowManagerMethods.IsWindowVisible(handle)) { + return true; + } + + //Class name check + string cl = WindowMethods.GetWindowClass(handle); + System.Diagnostics.Trace.WriteLine(string.Format("Child window, class {0}", cl)); + + if (_pluginClassNames.Contains(cl)) { + //Found plugin window, stop now + _selectedHandle = new WindowHandle(handle); + return false; + } + + return true; + } + + } +} diff --git a/OnTopReplica/Program.cs b/OnTopReplica/Program.cs new file mode 100644 index 0000000..12971ee --- /dev/null +++ b/OnTopReplica/Program.cs @@ -0,0 +1,128 @@ +using System; +using System.IO; +using System.Reflection; +using System.Threading; +using System.Windows.Forms; +using OnTopReplica.Properties; +using OnTopReplica.StartupOptions; +using OnTopReplica.Update; + +namespace OnTopReplica { + + static class Program { + + public static PlatformSupport Platform { get; private set; } + + public static UpdateManager Update { get; private set; } + + static MainForm _mainForm; + + /// + /// The main entry point for the application. + /// + [STAThread] + static void Main(string[] args) { + //Hook fatal abort handler + AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException); + + //Initialize and check for platform support + Platform = PlatformSupport.Create(); + if (!Platform.CheckCompatibility()) + return; + Platform.PreHandleFormInit(); + + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + + //Update settings if needed + if (Settings.Default.MustUpdate) { + Settings.Default.Upgrade(); + Settings.Default.MustUpdate = false; + } + + //Load startup options + var options = StartupOptions.Factory.CreateOptions(args); + string optionsMessage = options.DebugMessage; + if (!string.IsNullOrEmpty(optionsMessage)) { //show dialog if debug message present or if parsing failed + var dlg = new CommandLineReportForm(options.Status, optionsMessage); + dlg.ShowDialog(); + } + if (options.Status == CliStatus.Information || options.Status == CliStatus.Error) + return; + + //Load language + Thread.CurrentThread.CurrentUICulture = Settings.Default.Language; + + //Show form + using (_mainForm = new MainForm(options)) { + Application.Idle += _handlerIdleUpdater; + + //Enter GUI loop + Application.Run(_mainForm); + + //HACK: re-enable chrome to fix position persistence (ideally, chrome status should be stored and restored - but this is not always possible) + if (!_mainForm.IsChromeVisible) + _mainForm.IsChromeVisible = true; + + //Persist settings + System.Diagnostics.Trace.WriteLine(string.Format("Persisting {0} size {1} to settings.", _mainForm.Location, _mainForm.ClientSize)); + Settings.Default.RestoreLastPosition = _mainForm.Location; + Settings.Default.RestoreLastSize = _mainForm.ClientSize; + Settings.Default.Save(); + } + } + + private static EventHandler _handlerIdleUpdater = new EventHandler(Application_Idle); + + /// + /// Callback detecting application idle time. + /// + static void Application_Idle(object sender, EventArgs e) { + Application.Idle -= _handlerIdleUpdater; + + Update = new UpdateManager(_mainForm); + Update.UpdateCheckCompleted += new EventHandler(UpdateManager_CheckCompleted); + Update.CheckForUpdate(); + } + + /// + /// Callback that handles update checking. + /// + static void UpdateManager_CheckCompleted(object sender, UpdateCheckCompletedEventArgs e) { + if (e.Success && e.Information != null) { + if (e.Information.IsNewVersion) { + Update.ConfirmAndInstall(); + } + } + else { + System.Diagnostics.Trace.WriteLine(string.Format("Failed to check updates. {0}", e.Error)); + } + } + + static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e) { + string dump = string.Format("OnTopReplica-dump-{0}{1}{2}-{3}{4}.txt", + DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, + DateTime.Now.Hour, DateTime.Now.Minute); + string path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), dump); + + using (var s = new FileStream(path, FileMode.Create)) { + using (var sw = new StreamWriter(s)) { + sw.WriteLine("OnTopReplica Dump file"); + sw.WriteLine("This file has been created because OnTopReplica crashed."); + sw.WriteLine("Please send it to lck@klopfenstein.net to help fix the bug that caused the crash."); + sw.WriteLine(); + sw.WriteLine("Last exception:"); + sw.WriteLine(e.ExceptionObject.ToString()); + sw.WriteLine(); + sw.WriteLine("OnTopReplica v.{0}", Assembly.GetEntryAssembly().GetName().Version); + sw.WriteLine("OS: {0}", Environment.OSVersion.ToString()); + sw.WriteLine(".NET: {0}", Environment.Version.ToString()); + sw.WriteLine("Aero DWM: {0}", WindowsFormsAero.OsSupport.IsCompositionEnabled); + sw.WriteLine("Launch command: {0}", Environment.CommandLine); + sw.WriteLine("UTC time: {0} {1}", DateTime.UtcNow.ToShortDateString(), DateTime.UtcNow.ToShortTimeString()); + } + } + } + + } +} diff --git a/OnTopReplica/Properties/AssemblyInfo.cs b/OnTopReplica/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..f58a612 --- /dev/null +++ b/OnTopReplica/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("OnTopReplica")] +[assembly: AssemblyDescription("Real-time, always on top thumbnail of a window of your choice.")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Lorenz Cuno Klopfenstein")] +[assembly: AssemblyProduct("OnTopReplica")] +[assembly: AssemblyCopyright("Copyright © Lorenz Cuno Klopfenstein 2010")] +//[assembly: AssemblyCopyright("Copyright © Lorenz Cuno Klopfenstein 2007")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("015090d1-7559-4c59-b9d1-e7e066c4a948")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("3.4.0.0")] +[assembly: AssemblyFileVersion("3.4.0.0")] diff --git a/OnTopReplica/Properties/Resources.resx b/OnTopReplica/Properties/Resources.resx new file mode 100644 index 0000000..b097806 --- /dev/null +++ b/OnTopReplica/Properties/Resources.resx @@ -0,0 +1,239 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + ..\Assets\flag_ita.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_add.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\x-oblique.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\component.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\25.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\window_multiple16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_delete.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\regions_new.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_null.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\window_opacity_new.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_topleft.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_bottomleft.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_topright.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\clickforwarding.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\newicon.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_help.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\back.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_up.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\window16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\flag_czech.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_bottomright.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\window_switch.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\desktop.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\flag_danish.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\reduce.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_ok.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_wrench.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\list.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\icon-new.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\fullscreen.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_down.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\xiao_arrow.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\window_border16.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\flag_usa.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\groupmode.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\pos_center.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\flag_spanish.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Assets\flag_poland.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + + ..\Assets\flag_germany.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/OnTopReplica/Properties/Settings.settings b/OnTopReplica/Properties/Settings.settings new file mode 100644 index 0000000..fb6e917 --- /dev/null +++ b/OnTopReplica/Properties/Settings.settings @@ -0,0 +1,57 @@ + + + + + + + + + 255 + + + (Default) + + + True + + + True + + + True + + + True + + + False + + + False + + + 0, 0 + + + 0, 0 + + + False + + + + + + + + + 0 + + + [CTRL]+[SHIFT]+C + + + [CTRL]+[SHIFT]+O + + + \ No newline at end of file diff --git a/OnTopReplica/Properties/app.manifest b/OnTopReplica/Properties/app.manifest new file mode 100644 index 0000000..c29c96a --- /dev/null +++ b/OnTopReplica/Properties/app.manifest @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/OnTopReplica/ScreenPosition.cs b/OnTopReplica/ScreenPosition.cs new file mode 100644 index 0000000..0a99d6c --- /dev/null +++ b/OnTopReplica/ScreenPosition.cs @@ -0,0 +1,87 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using System.Drawing; + +namespace OnTopReplica { + + /// + /// Describes a resolution independent screen position. + /// + enum ScreenPosition { + TopLeft, + TopRight, + BottomLeft, + BottomRight, + Center + } + + /// + /// Extension methods for ScreenPositions. + /// + static class ScreenPositionExtensions { + + /// + /// Gets the coordinates point matching an independent screen position value. + /// + /// Screen position value. + /// Pixel point in screen coordinates. + public static Point ResolveScreenPosition(this Screen screen, ScreenPosition position) { + var rect = screen.WorkingArea; + + return ResolveScreenPositionToRectangle(rect, position); + } + + /// + /// Gets the coordinates matching an independent screen position value. + /// + /// Target control for which the coordinates should be resolved. + /// Screen position value. + /// Pixel point in screen coordinates. + public static Point ResolveScreenPositionEdge(this Control ctrl, ScreenPosition position) { + var ctrlRegion = ctrl.RectangleToScreen(ctrl.ClientRectangle); + + return ResolveScreenPositionToRectangle(ctrlRegion, position); + } + + private static Point ResolveScreenPositionToRectangle(Rectangle rect, ScreenPosition position) { + switch (position) { + case ScreenPosition.TopLeft: + return new Point(rect.X, rect.Y); + case ScreenPosition.TopRight: + return new Point(rect.X + rect.Width, rect.Y); + case ScreenPosition.BottomLeft: + return new Point(rect.X, rect.Y + rect.Height); + case ScreenPosition.BottomRight: + return new Point(rect.X + rect.Width, rect.Y + rect.Height); + case ScreenPosition.Center: + return new Point(rect.X + (rect.Width / 2), rect.Y + (rect.Height / 2)); + default: + throw new ArgumentException("Invalid ScreenPosition value."); + } + } + + /// + /// Sets the form's screen position in independent coordinates. + /// + /// + /// Position is set relative to the form's current screen. + /// + public static void SetScreenPosition(this MainForm form, ScreenPosition position) { + var screen = Screen.FromControl(form); + + var start = form.ResolveScreenPositionEdge(position); + var end = screen.ResolveScreenPosition(position); + + var move = end.Difference(start); + + System.Diagnostics.Trace.WriteLine(string.Format("From {0} to {1} => {2}.", start, end, move)); + + var original = form.Location; + form.Location = new Point(original.X + move.X, original.Y + move.Y); + } + + } + +} diff --git a/OnTopReplica/SidePanel.cs b/OnTopReplica/SidePanel.cs new file mode 100644 index 0000000..d66f010 --- /dev/null +++ b/OnTopReplica/SidePanel.cs @@ -0,0 +1,73 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using WindowsFormsAero.Dwm; +using System.Drawing; + +namespace OnTopReplica { + + /// + /// Represents a side panel that can be embedded in OnTopReplica. + /// + class SidePanel : UserControl { + + protected override void OnCreateControl() { + if (!DesignMode) { + Dock = DockStyle.Fill; + } + + base.OnCreateControl(); + } + + /// + /// Gets the panel's parent form. + /// + protected MainForm ParentForm { get; private set; } + + /// + /// Raised when the side panel requests to be closed. + /// + public event EventHandler RequestClosing; + + protected virtual void OnRequestClosing() { + var evt = RequestClosing; + if (evt != null) + evt(this, EventArgs.Empty); + } + + /// + /// Is called when the side panel is embedded and first shown. + /// + /// Parent form that is embedding the side panel. + public virtual void OnFirstShown(MainForm form) { + ParentForm = form; + } + + /// + /// Is called before removing the side panel. + /// + /// Parent form that is embedding the side panel. + public virtual void OnClosing(MainForm form) { + } + + /// + /// Gets the side panel's title. + /// + public virtual string Title { + get { + return "Side panel"; + } + } + + /// + /// Gets the panel's desired glass margins or null if no glass surface is required. + /// + public virtual Margins? GlassMargins { + get { + return null; + } + } + + } +} diff --git a/OnTopReplica/SidePanelContainer.Designer.cs b/OnTopReplica/SidePanelContainer.Designer.cs new file mode 100644 index 0000000..56103f0 --- /dev/null +++ b/OnTopReplica/SidePanelContainer.Designer.cs @@ -0,0 +1,46 @@ +namespace OnTopReplica { + partial class SidePanelContainer { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.SuspendLayout(); + // + // SidePanelContainer + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(246, 300); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.SizableToolWindow; + this.MinimizeBox = false; + this.Name = "SidePanelContainer"; + this.ShowInTaskbar = false; + this.StartPosition = System.Windows.Forms.FormStartPosition.Manual; + this.Text = "Side Panel container"; + this.TopMost = true; + this.ResumeLayout(false); + + } + + #endregion + } +} \ No newline at end of file diff --git a/OnTopReplica/SidePanelContainer.cs b/OnTopReplica/SidePanelContainer.cs new file mode 100644 index 0000000..9a195a6 --- /dev/null +++ b/OnTopReplica/SidePanelContainer.cs @@ -0,0 +1,108 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using WindowsFormsAero.Dwm.Helpers; + +namespace OnTopReplica { + /// + /// Acts as a form that can contain a SidePanel instance. + /// + partial class SidePanelContainer : GlassForm { + + EventHandler RequestClosingHandler; + + MainForm _parent; + + public SidePanelContainer(MainForm mainForm) { + InitializeComponent(); + + _parent = mainForm; + RequestClosingHandler = new EventHandler(Panel_RequestClosing); + } + + void Panel_RequestClosing(object sender, EventArgs e) { + FreeSidePanel(); + this.Close(); + } + + protected override void OnClosing(CancelEventArgs e) { + base.OnClosing(e); + + //Ensure side panel closing code is run + FreeSidePanel(); + } + + /// + /// Sets a new side panel and refreshes the window. The panel is + /// managed by the SidePanelContainer from now on. + /// + /// SidePanel to embed and to manage. + public void SetSidePanel(SidePanel panel) { + panel.OnFirstShown(_parent); + + this.SuspendLayout(); + + //Title + this.Text = panel.Title; + + //Set panel + CurrentSidePanel = panel; + panel.RequestClosing += RequestClosingHandler; + this.Controls.Add(panel); + + var minSize = panel.MinimumSize.Expand(this.Padding); + this.ClientSize = minSize; + this.EnsureMinimumClientSize(minSize); + + //Enable glass if needed + var margins = panel.GlassMargins; + if (margins.HasValue) { + this.GlassMargins = margins.Value; + this.GlassEnabled = true; + } + else + this.GlassEnabled = false; + + this.ResumeLayout(); + } + + /// + /// Removes the current side panel and disposes it. + /// + public void FreeSidePanel() { + if (CurrentSidePanel == null) + return; + + this.SuspendLayout(); + + FreeSidePanelCore(); + + this.ResumeLayout(); + } + + /// + /// Removes the current side panel and disposes it (doesn't suspend layout). + /// + private void FreeSidePanelCore() { + CurrentSidePanel.OnClosing(_parent); + + //Free hook + CurrentSidePanel.RequestClosing -= RequestClosingHandler; + + //Remove + this.Controls.Remove(CurrentSidePanel); + + //Free + CurrentSidePanel.Dispose(); + CurrentSidePanel = null; + } + + public SidePanel CurrentSidePanel { + get; + private set; + } + } +} diff --git a/OnTopReplica/SidePanelContainer.resx b/OnTopReplica/SidePanelContainer.resx new file mode 100644 index 0000000..5ea0895 --- /dev/null +++ b/OnTopReplica/SidePanelContainer.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/OnTopReplica/SidePanels/AboutPanel.Designer.cs b/OnTopReplica/SidePanels/AboutPanel.Designer.cs new file mode 100644 index 0000000..fc86628 --- /dev/null +++ b/OnTopReplica/SidePanels/AboutPanel.Designer.cs @@ -0,0 +1,74 @@ +namespace OnTopReplica.SidePanels { + partial class AboutPanel { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.labelVersion = new WindowsFormsAero.ThemeText.ThemedLabel(); + this.panelContents = new OnTopReplica.SidePanels.AboutPanelContents(); + this.SuspendLayout(); + // + // labelVersion + // + this.labelVersion.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labelVersion.Location = new System.Drawing.Point(0, 270); + this.labelVersion.Name = "labelVersion"; + this.labelVersion.Padding = new System.Windows.Forms.Padding(0, 0, 0, 3); + this.labelVersion.Size = new System.Drawing.Size(265, 20); + this.labelVersion.TabIndex = 0; + this.labelVersion.Text = "Version"; + this.labelVersion.TextAlign = System.Windows.Forms.HorizontalAlignment.Center; + this.labelVersion.TextAlignVertical = System.Windows.Forms.VisualStyles.VerticalAlignment.Bottom; + // + // panelContents + // + this.panelContents.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.panelContents.AutoScroll = true; + this.panelContents.Location = new System.Drawing.Point(6, 6); + this.panelContents.Margin = new System.Windows.Forms.Padding(6); + this.panelContents.Name = "panelContents"; + this.panelContents.Size = new System.Drawing.Size(253, 255); + this.panelContents.TabIndex = 1; + // + // AboutPanel + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.panelContents); + this.Controls.Add(this.labelVersion); + this.MinimumSize = new System.Drawing.Size(265, 290); + this.Name = "AboutPanel"; + this.Size = new System.Drawing.Size(265, 290); + this.ResumeLayout(false); + + } + + #endregion + + private WindowsFormsAero.ThemeText.ThemedLabel labelVersion; + private AboutPanelContents panelContents; + + } +} diff --git a/OnTopReplica/SidePanels/AboutPanel.cs b/OnTopReplica/SidePanels/AboutPanel.cs new file mode 100644 index 0000000..87da71a --- /dev/null +++ b/OnTopReplica/SidePanels/AboutPanel.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using WindowsFormsAero.Dwm; + +namespace OnTopReplica.SidePanels { + partial class AboutPanel : SidePanel { + + public AboutPanel() { + InitializeComponent(); + + //Display version number + labelVersion.Text = string.Format(Strings.AboutVersion, Application.ProductVersion); + } + + public override string Title { + get { + return Strings.AboutTitle; + } + } + + public override Margins? GlassMargins { + get { + return new Margins(0, 0, 0, labelVersion.Height); + } + } + + } +} diff --git a/OnTopReplica/SidePanels/AboutPanel.resx b/OnTopReplica/SidePanels/AboutPanel.resx new file mode 100644 index 0000000..5ea0895 --- /dev/null +++ b/OnTopReplica/SidePanels/AboutPanel.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/OnTopReplica/SidePanels/AboutPanelContents.Designer.cs b/OnTopReplica/SidePanels/AboutPanelContents.Designer.cs new file mode 100644 index 0000000..819852c --- /dev/null +++ b/OnTopReplica/SidePanels/AboutPanelContents.Designer.cs @@ -0,0 +1,265 @@ +namespace OnTopReplica.SidePanels { + partial class AboutPanelContents { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.labelTranslators = new System.Windows.Forms.Label(); + this.linkCredits = new System.Windows.Forms.LinkLabel(); + this.progressUpdate = new WindowsFormsAero.ProgressBar(); + this.buttonUpdate = new System.Windows.Forms.Button(); + this.lblUpdateDisclaimer = new System.Windows.Forms.Label(); + this.labeledDivider2 = new WindowsFormsAero.LabeledDivider(); + this.labeledDivider1 = new WindowsFormsAero.LabeledDivider(); + this.linkHomepage = new System.Windows.Forms.LinkLabel(); + this.linkAuthor = new System.Windows.Forms.LinkLabel(); + this.lblSlogan = new System.Windows.Forms.Label(); + this.labeledDivider3 = new WindowsFormsAero.LabeledDivider(); + this.linkLicense = new System.Windows.Forms.LinkLabel(); + this.labeledDivider4 = new WindowsFormsAero.LabeledDivider(); + this.linkContribute = new System.Windows.Forms.LinkLabel(); + this.SuspendLayout(); + // + // labelTranslators + // + this.labelTranslators.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labelTranslators.AutoEllipsis = true; + this.labelTranslators.Location = new System.Drawing.Point(0, 289); + this.labelTranslators.Name = "labelTranslators"; + this.labelTranslators.Size = new System.Drawing.Size(240, 101); + this.labelTranslators.TabIndex = 31; + this.labelTranslators.Text = "Translators:"; + // + // linkCredits + // + this.linkCredits.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.linkCredits.AutoEllipsis = true; + this.linkCredits.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkCredits.Location = new System.Drawing.Point(0, 223); + this.linkCredits.Name = "linkCredits"; + this.linkCredits.Size = new System.Drawing.Size(240, 57); + this.linkCredits.TabIndex = 30; + this.linkCredits.TabStop = true; + this.linkCredits.Text = "%CREDITS%"; + this.linkCredits.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.LinkCredits_click); + // + // progressUpdate + // + this.progressUpdate.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.progressUpdate.Location = new System.Drawing.Point(0, 155); + this.progressUpdate.Name = "progressUpdate"; + this.progressUpdate.Size = new System.Drawing.Size(132, 23); + this.progressUpdate.Style = System.Windows.Forms.ProgressBarStyle.Marquee; + this.progressUpdate.TabIndex = 29; + this.progressUpdate.Visible = false; + // + // buttonUpdate + // + this.buttonUpdate.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.buttonUpdate.Location = new System.Drawing.Point(138, 155); + this.buttonUpdate.Name = "buttonUpdate"; + this.buttonUpdate.Size = new System.Drawing.Size(102, 23); + this.buttonUpdate.TabIndex = 28; + this.buttonUpdate.Text = global::OnTopReplica.Strings.AboutUpdatesCheckNow; + this.buttonUpdate.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; + this.buttonUpdate.UseVisualStyleBackColor = true; + this.buttonUpdate.Click += new System.EventHandler(this.UpdateButton_click); + // + // lblUpdateDisclaimer + // + this.lblUpdateDisclaimer.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.lblUpdateDisclaimer.AutoEllipsis = true; + this.lblUpdateDisclaimer.Location = new System.Drawing.Point(0, 108); + this.lblUpdateDisclaimer.Name = "lblUpdateDisclaimer"; + this.lblUpdateDisclaimer.Size = new System.Drawing.Size(240, 44); + this.lblUpdateDisclaimer.TabIndex = 27; + this.lblUpdateDisclaimer.Text = "OnTopReplica automatically checks for updates at every start up."; + // + // labeledDivider2 + // + this.labeledDivider2.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labeledDivider2.DividerColor = System.Drawing.Color.FromArgb(((int)(((byte)(176)))), ((int)(((byte)(191)))), ((int)(((byte)(222))))); + this.labeledDivider2.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(51)))), ((int)(((byte)(170))))); + this.labeledDivider2.Location = new System.Drawing.Point(0, 197); + this.labeledDivider2.Name = "labeledDivider2"; + this.labeledDivider2.Size = new System.Drawing.Size(240, 23); + this.labeledDivider2.TabIndex = 26; + this.labeledDivider2.Text = global::OnTopReplica.Strings.AboutDividerCredits; + // + // labeledDivider1 + // + this.labeledDivider1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labeledDivider1.DividerColor = System.Drawing.Color.FromArgb(((int)(((byte)(176)))), ((int)(((byte)(191)))), ((int)(((byte)(222))))); + this.labeledDivider1.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(51)))), ((int)(((byte)(170))))); + this.labeledDivider1.Location = new System.Drawing.Point(0, 82); + this.labeledDivider1.Name = "labeledDivider1"; + this.labeledDivider1.Size = new System.Drawing.Size(240, 23); + this.labeledDivider1.TabIndex = 25; + this.labeledDivider1.Text = global::OnTopReplica.Strings.AboutDividerUpdates; + // + // linkHomepage + // + this.linkHomepage.AutoSize = true; + this.linkHomepage.BackColor = System.Drawing.Color.Transparent; + this.linkHomepage.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkHomepage.Location = new System.Drawing.Point(0, 54); + this.linkHomepage.Name = "linkHomepage"; + this.linkHomepage.Size = new System.Drawing.Size(167, 17); + this.linkHomepage.TabIndex = 23; + this.linkHomepage.TabStop = true; + this.linkHomepage.Text = "http://ontopreplica.codeplex.com"; + this.linkHomepage.UseCompatibleTextRendering = true; + this.linkHomepage.VisitedLinkColor = System.Drawing.Color.Blue; + this.linkHomepage.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.LinkHomepage_clicked); + // + // linkAuthor + // + this.linkAuthor.AutoSize = true; + this.linkAuthor.BackColor = System.Drawing.Color.Transparent; + this.linkAuthor.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkAuthor.LinkColor = System.Drawing.Color.Blue; + this.linkAuthor.Location = new System.Drawing.Point(0, 33); + this.linkAuthor.Name = "linkAuthor"; + this.linkAuthor.Size = new System.Drawing.Size(72, 17); + this.linkAuthor.TabIndex = 22; + this.linkAuthor.TabStop = true; + this.linkAuthor.Text = "%AUTHOR%"; + this.linkAuthor.UseCompatibleTextRendering = true; + this.linkAuthor.VisitedLinkColor = System.Drawing.Color.Blue; + this.linkAuthor.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.LinkAuthor_clicked); + // + // lblSlogan + // + this.lblSlogan.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.lblSlogan.AutoEllipsis = true; + this.lblSlogan.BackColor = System.Drawing.Color.Transparent; + this.lblSlogan.Location = new System.Drawing.Point(0, 0); + this.lblSlogan.Name = "lblSlogan"; + this.lblSlogan.Size = new System.Drawing.Size(240, 33); + this.lblSlogan.TabIndex = 24; + this.lblSlogan.Text = "A lightweight, real-time, always on top thumbnail of a window of your choice."; + // + // labeledDivider3 + // + this.labeledDivider3.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labeledDivider3.DividerColor = System.Drawing.Color.FromArgb(((int)(((byte)(176)))), ((int)(((byte)(191)))), ((int)(((byte)(222))))); + this.labeledDivider3.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(51)))), ((int)(((byte)(170))))); + this.labeledDivider3.Location = new System.Drawing.Point(0, 393); + this.labeledDivider3.Name = "labeledDivider3"; + this.labeledDivider3.Size = new System.Drawing.Size(240, 23); + this.labeledDivider3.TabIndex = 32; + this.labeledDivider3.Text = "License"; + // + // linkLicense + // + this.linkLicense.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.linkLicense.AutoEllipsis = true; + this.linkLicense.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkLicense.Location = new System.Drawing.Point(0, 419); + this.linkLicense.Name = "linkLicense"; + this.linkLicense.Size = new System.Drawing.Size(240, 81); + this.linkLicense.TabIndex = 33; + this.linkLicense.TabStop = true; + this.linkLicense.Text = "%LICENSE%"; + this.linkLicense.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.LinkLicense_click); + // + // labeledDivider4 + // + this.labeledDivider4.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labeledDivider4.DividerColor = System.Drawing.Color.FromArgb(((int)(((byte)(176)))), ((int)(((byte)(191)))), ((int)(((byte)(222))))); + this.labeledDivider4.ForeColor = System.Drawing.Color.FromArgb(((int)(((byte)(0)))), ((int)(((byte)(51)))), ((int)(((byte)(170))))); + this.labeledDivider4.Location = new System.Drawing.Point(0, 503); + this.labeledDivider4.Name = "labeledDivider4"; + this.labeledDivider4.Size = new System.Drawing.Size(240, 23); + this.labeledDivider4.TabIndex = 34; + this.labeledDivider4.Text = "Contribute"; + // + // linkContribute + // + this.linkContribute.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.linkContribute.AutoEllipsis = true; + this.linkContribute.LinkBehavior = System.Windows.Forms.LinkBehavior.HoverUnderline; + this.linkContribute.Location = new System.Drawing.Point(0, 529); + this.linkContribute.Name = "linkContribute"; + this.linkContribute.Size = new System.Drawing.Size(240, 84); + this.linkContribute.TabIndex = 35; + this.linkContribute.TabStop = true; + this.linkContribute.Text = "%CONTRIBUTE%"; + this.linkContribute.LinkClicked += new System.Windows.Forms.LinkLabelLinkClickedEventHandler(this.LinkContribute_clicked); + // + // AboutPanelContents + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.AutoScroll = true; + this.Controls.Add(this.linkContribute); + this.Controls.Add(this.labeledDivider4); + this.Controls.Add(this.linkLicense); + this.Controls.Add(this.labeledDivider3); + this.Controls.Add(this.labelTranslators); + this.Controls.Add(this.linkCredits); + this.Controls.Add(this.progressUpdate); + this.Controls.Add(this.buttonUpdate); + this.Controls.Add(this.lblUpdateDisclaimer); + this.Controls.Add(this.labeledDivider2); + this.Controls.Add(this.labeledDivider1); + this.Controls.Add(this.linkHomepage); + this.Controls.Add(this.linkAuthor); + this.Controls.Add(this.lblSlogan); + this.Margin = new System.Windows.Forms.Padding(6); + this.Name = "AboutPanelContents"; + this.Size = new System.Drawing.Size(243, 613); + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Label labelTranslators; + private System.Windows.Forms.LinkLabel linkCredits; + private WindowsFormsAero.ProgressBar progressUpdate; + private System.Windows.Forms.Button buttonUpdate; + private System.Windows.Forms.Label lblUpdateDisclaimer; + private WindowsFormsAero.LabeledDivider labeledDivider2; + private WindowsFormsAero.LabeledDivider labeledDivider1; + private System.Windows.Forms.LinkLabel linkHomepage; + private System.Windows.Forms.LinkLabel linkAuthor; + private System.Windows.Forms.Label lblSlogan; + private WindowsFormsAero.LabeledDivider labeledDivider3; + private System.Windows.Forms.LinkLabel linkLicense; + private WindowsFormsAero.LabeledDivider labeledDivider4; + private System.Windows.Forms.LinkLabel linkContribute; + + } +} diff --git a/OnTopReplica/SidePanels/AboutPanelContents.cs b/OnTopReplica/SidePanels/AboutPanelContents.cs new file mode 100644 index 0000000..84738b2 --- /dev/null +++ b/OnTopReplica/SidePanels/AboutPanelContents.cs @@ -0,0 +1,99 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Update; +using System.Diagnostics; +using WindowsFormsAero.TaskDialog; +using System.IO; + +namespace OnTopReplica.SidePanels { + public partial class AboutPanelContents : UserControl { + + EventHandler _updateHandler; + + public AboutPanelContents() { + InitializeComponent(); + + LocalizePanel(); + } + + private void LocalizePanel() { + lblSlogan.Text = Strings.AboutSlogan; + linkAuthor.Internationalize(Strings.AboutAuthor, Strings.AboutAuthorContent); + labeledDivider1.Text = Strings.AboutDividerUpdates; + lblUpdateDisclaimer.Text = Strings.AboutUpdatesDisclaimer; + buttonUpdate.Text = Strings.AboutUpdatesCheckNow; + labeledDivider2.Text = Strings.AboutDividerCredits; + linkCredits.Internationalize(Strings.AboutCreditsSources, Strings.AboutCreditsSourcesContent); + labelTranslators.Text = string.Format(Strings.AboutTranslators, Strings.AboutTranslatorsContent); + labeledDivider3.Text = Strings.AboutDividerLicense; + linkLicense.Internationalize(Strings.AboutLicense, Strings.AboutLicenseContent); + labeledDivider4.Text = Strings.AboutDividerContribute; + linkContribute.Internationalize(Strings.AboutContribute, Strings.AboutContributeContent); + } + + protected override void OnHandleCreated(EventArgs e) { + base.OnHandleCreated(e); + + if (!DesignMode) { + //Updating + _updateHandler = new EventHandler(UpdateCheckCompleted); + Program.Update.UpdateCheckCompleted += _updateHandler; + } + } + + protected override void OnHandleDestroyed(EventArgs e) { + base.OnHandleDestroyed(e); + + if (!DesignMode) { + Program.Update.UpdateCheckCompleted -= _updateHandler; + } + } + + private void LinkHomepage_clicked(object sender, LinkLabelLinkClickedEventArgs e) { + Process.Start("http://ontopreplica.codeplex.com"); + } + + private void LinkAuthor_clicked(object sender, LinkLabelLinkClickedEventArgs e) { + Process.Start("http://lorenz.klopfenstein.net"); + } + + private void LinkCredits_click(object sender, LinkLabelLinkClickedEventArgs e) { + var exeDir = Path.GetDirectoryName(Application.ExecutablePath); + var filePath = Path.Combine(exeDir, "CREDITS.txt"); + + Process.Start(filePath); + } + + void UpdateButton_click(object sender, System.EventArgs e) { + progressUpdate.Visible = true; + + Program.Update.CheckForUpdate(); + } + + void UpdateCheckCompleted(object sender, UpdateCheckCompletedEventArgs e) { + this.Invoke(new Action(() => { + if (!e.Success || e.Information == null) { + //TODO + MessageBox.Show("Failed to download update info."); + } + else if (!e.Information.IsNewVersion) { + Program.Update.DisplayInfo(); + } + + progressUpdate.Visible = false; + })); + } + + private void LinkLicense_click(object sender, LinkLabelLinkClickedEventArgs e) { + Process.Start("http://opensource.org/licenses/ms-rl.html"); + } + + private void LinkContribute_clicked(object sender, LinkLabelLinkClickedEventArgs e) { + Process.Start("http://ontopreplica.codeplex.com/SourceControl/list/changesets"); + } + } +} diff --git a/OnTopReplica/SidePanels/AboutPanelContents.resx b/OnTopReplica/SidePanels/AboutPanelContents.resx new file mode 100644 index 0000000..5ea0895 --- /dev/null +++ b/OnTopReplica/SidePanels/AboutPanelContents.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/OnTopReplica/SidePanels/GroupSwitchPanel.Designer.cs b/OnTopReplica/SidePanels/GroupSwitchPanel.Designer.cs new file mode 100644 index 0000000..c3d8cc6 --- /dev/null +++ b/OnTopReplica/SidePanels/GroupSwitchPanel.Designer.cs @@ -0,0 +1,131 @@ +namespace OnTopReplica.SidePanels { + partial class GroupSwitchPanel { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.groupBox1 = new System.Windows.Forms.GroupBox(); + this.labelStatus = new System.Windows.Forms.Label(); + this.buttonCancel = new System.Windows.Forms.Button(); + this.buttonEnable = new System.Windows.Forms.Button(); + this.listWindows = new System.Windows.Forms.ListView(); + this.colName = ((System.Windows.Forms.ColumnHeader)(new System.Windows.Forms.ColumnHeader())); + this.groupBox1.SuspendLayout(); + this.SuspendLayout(); + // + // groupBox1 + // + this.groupBox1.Controls.Add(this.labelStatus); + this.groupBox1.Controls.Add(this.buttonCancel); + this.groupBox1.Controls.Add(this.buttonEnable); + this.groupBox1.Controls.Add(this.listWindows); + this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupBox1.Location = new System.Drawing.Point(6, 6); + this.groupBox1.Name = "groupBox1"; + this.groupBox1.Size = new System.Drawing.Size(271, 325); + this.groupBox1.TabIndex = 1; + this.groupBox1.TabStop = false; + this.groupBox1.Text = "Group switch mode:"; + // + // labelStatus + // + this.labelStatus.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.labelStatus.Location = new System.Drawing.Point(3, 276); + this.labelStatus.Name = "labelStatus"; + this.labelStatus.Size = new System.Drawing.Size(262, 17); + this.labelStatus.TabIndex = 3; + this.labelStatus.Text = "-"; + this.labelStatus.TextAlign = System.Drawing.ContentAlignment.BottomRight; + // + // buttonCancel + // + this.buttonCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonCancel.Location = new System.Drawing.Point(195, 296); + this.buttonCancel.Name = "buttonCancel"; + this.buttonCancel.Size = new System.Drawing.Size(70, 23); + this.buttonCancel.TabIndex = 2; + this.buttonCancel.Text = global::OnTopReplica.Strings.GroupSwitchModeDisableButton; + this.buttonCancel.UseVisualStyleBackColor = true; + this.buttonCancel.Click += new System.EventHandler(this.Cancel_click); + // + // buttonEnable + // + this.buttonEnable.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonEnable.Image = global::OnTopReplica.Properties.Resources.xiao_ok; + this.buttonEnable.Location = new System.Drawing.Point(55, 296); + this.buttonEnable.Name = "buttonEnable"; + this.buttonEnable.Size = new System.Drawing.Size(134, 23); + this.buttonEnable.TabIndex = 1; + this.buttonEnable.Text = global::OnTopReplica.Strings.GroupSwitchModeEnableButton; + this.buttonEnable.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; + this.buttonEnable.UseVisualStyleBackColor = true; + this.buttonEnable.Click += new System.EventHandler(this.Enable_click); + // + // listWindows + // + this.listWindows.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.listWindows.Columns.AddRange(new System.Windows.Forms.ColumnHeader[] { + this.colName}); + this.listWindows.FullRowSelect = true; + this.listWindows.GridLines = true; + this.listWindows.HeaderStyle = System.Windows.Forms.ColumnHeaderStyle.None; + this.listWindows.HideSelection = false; + this.listWindows.LabelWrap = false; + this.listWindows.Location = new System.Drawing.Point(6, 19); + this.listWindows.Name = "listWindows"; + this.listWindows.Size = new System.Drawing.Size(259, 254); + this.listWindows.TabIndex = 0; + this.listWindows.UseCompatibleStateImageBehavior = false; + this.listWindows.View = System.Windows.Forms.View.List; + // + // colName + // + this.colName.Text = global::OnTopReplica.Strings.GroupSwitchModeWindows; + this.colName.Width = 187; + // + // GroupSwitchPanel + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.groupBox1); + this.MinimumSize = new System.Drawing.Size(240, 240); + this.Name = "GroupSwitchPanel"; + this.Padding = new System.Windows.Forms.Padding(6); + this.Size = new System.Drawing.Size(283, 337); + this.groupBox1.ResumeLayout(false); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox groupBox1; + private System.Windows.Forms.Label labelStatus; + private System.Windows.Forms.Button buttonCancel; + private System.Windows.Forms.Button buttonEnable; + private System.Windows.Forms.ListView listWindows; + private System.Windows.Forms.ColumnHeader colName; + } +} diff --git a/OnTopReplica/SidePanels/GroupSwitchPanel.cs b/OnTopReplica/SidePanels/GroupSwitchPanel.cs new file mode 100644 index 0000000..66183f5 --- /dev/null +++ b/OnTopReplica/SidePanels/GroupSwitchPanel.cs @@ -0,0 +1,89 @@ +using System; +using System.Collections.Generic; +using System.Windows.Forms; +using OnTopReplica.MessagePumpProcessors; +using OnTopReplica.WindowSeekers; + +namespace OnTopReplica.SidePanels { + partial class GroupSwitchPanel : SidePanel { + public GroupSwitchPanel() { + InitializeComponent(); + + LocalizePanel(); + } + + private void LocalizePanel() { + groupBox1.Text = Strings.GroupSwitchModeTitle; + buttonEnable.Text = Strings.GroupSwitchModeEnableButton; + buttonCancel.Text = Strings.GroupSwitchModeDisableButton; + } + + public override string Title { + get { + return Strings.MenuGroupSwitch; + } + } + + public override void OnFirstShown(MainForm form) { + base.OnFirstShown(form); + + LoadWindowList(); + + labelStatus.Text = (ParentForm.MessagePumpManager.Get().IsActive) ? + Strings.GroupSwitchModeStatusEnabled : + Strings.GroupSwitchModeStatusDisabled; + } + + private void LoadWindowList() { + var manager = new TaskWindowSeeker { + SkipNotVisibleWindows = true + }; + manager.Refresh(); + + var imageList = new ImageList(); + imageList.ColorDepth = ColorDepth.Depth32Bit; + foreach (var w in manager.Windows) { + var item = new ListViewItem(w.Title) { + Tag = w + }; + + if (w.Icon != null) { + imageList.Images.Add(w.Icon); + item.ImageIndex = imageList.Images.Count - 1; + } + + listWindows.Items.Add(item); + } + listWindows.SmallImageList = imageList; + } + + public override void OnClosing(MainForm form) { + base.OnClosing(form); + + if (_enableOnClose && listWindows.SelectedItems.Count > 0) { + List ret = new List(); + foreach (ListViewItem i in listWindows.SelectedItems) { + ret.Add((WindowHandle)i.Tag); + } + + form.SetThumbnailGroup(ret); + } + else { + form.MessagePumpManager.Get().Disable(); + } + } + + bool _enableOnClose = false; + + private void Enable_click(object sender, EventArgs e) { + _enableOnClose = true; + OnRequestClosing(); + } + + private void Cancel_click(object sender, EventArgs e) { + OnRequestClosing(); + } + + } + +} diff --git a/OnTopReplica/SidePanels/GroupSwitchPanel.resx b/OnTopReplica/SidePanels/GroupSwitchPanel.resx new file mode 100644 index 0000000..5ea0895 --- /dev/null +++ b/OnTopReplica/SidePanels/GroupSwitchPanel.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/OnTopReplica/SidePanels/OptionsPanel.Designer.cs b/OnTopReplica/SidePanels/OptionsPanel.Designer.cs new file mode 100644 index 0000000..601eb05 --- /dev/null +++ b/OnTopReplica/SidePanels/OptionsPanel.Designer.cs @@ -0,0 +1,200 @@ +namespace OnTopReplica.SidePanels { + partial class OptionsPanel { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.btnClose = new System.Windows.Forms.Button(); + this.panelMain = new System.Windows.Forms.Panel(); + this.groupHotkeys = new System.Windows.Forms.GroupBox(); + this.label1 = new System.Windows.Forms.Label(); + this.lblHotKeyShowHide = new System.Windows.Forms.Label(); + this.txtHotKeyShowHide = new OnTopReplica.HotKeyTextBox(); + this.lblHotKeyClone = new System.Windows.Forms.Label(); + this.txtHotKeyClone = new OnTopReplica.HotKeyTextBox(); + this.groupLanguage = new System.Windows.Forms.GroupBox(); + this.comboLanguage = new OnTopReplica.ImageComboBox(); + this.lblLanguage = new System.Windows.Forms.Label(); + this.panelMain.SuspendLayout(); + this.groupHotkeys.SuspendLayout(); + this.groupLanguage.SuspendLayout(); + this.SuspendLayout(); + // + // btnClose + // + this.btnClose.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.btnClose.Location = new System.Drawing.Point(189, 211); + this.btnClose.Name = "btnClose"; + this.btnClose.Size = new System.Drawing.Size(75, 23); + this.btnClose.TabIndex = 0; + this.btnClose.Text = global::OnTopReplica.Strings.MenuClose; + this.btnClose.UseVisualStyleBackColor = true; + this.btnClose.Click += new System.EventHandler(this.Close_click); + // + // panelMain + // + this.panelMain.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.panelMain.AutoScroll = true; + this.panelMain.Controls.Add(this.groupHotkeys); + this.panelMain.Controls.Add(this.groupLanguage); + this.panelMain.Location = new System.Drawing.Point(6, 6); + this.panelMain.Name = "panelMain"; + this.panelMain.Size = new System.Drawing.Size(258, 199); + this.panelMain.TabIndex = 1; + // + // groupHotkeys + // + this.groupHotkeys.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.groupHotkeys.Controls.Add(this.label1); + this.groupHotkeys.Controls.Add(this.lblHotKeyShowHide); + this.groupHotkeys.Controls.Add(this.txtHotKeyShowHide); + this.groupHotkeys.Controls.Add(this.lblHotKeyClone); + this.groupHotkeys.Controls.Add(this.txtHotKeyClone); + this.groupHotkeys.Location = new System.Drawing.Point(3, 77); + this.groupHotkeys.Name = "groupHotkeys"; + this.groupHotkeys.Size = new System.Drawing.Size(252, 113); + this.groupHotkeys.TabIndex = 1; + this.groupHotkeys.TabStop = false; + this.groupHotkeys.Text = "Hot keys:"; + // + // label1 + // + this.label1.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.label1.Location = new System.Drawing.Point(6, 68); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(156, 43); + this.label1.TabIndex = 4; + this.label1.Text = "These system-wide shortcuts can also be used when OnTopReplica is not in focus."; + // + // lblHotKeyShowHide + // + this.lblHotKeyShowHide.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.lblHotKeyShowHide.Location = new System.Drawing.Point(168, 22); + this.lblHotKeyShowHide.Name = "lblHotKeyShowHide"; + this.lblHotKeyShowHide.Size = new System.Drawing.Size(78, 17); + this.lblHotKeyShowHide.TabIndex = 3; + this.lblHotKeyShowHide.Text = "Show/Hide"; + // + // txtHotKeyShowHide + // + this.txtHotKeyShowHide.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtHotKeyShowHide.Location = new System.Drawing.Point(6, 19); + this.txtHotKeyShowHide.Name = "txtHotKeyShowHide"; + this.txtHotKeyShowHide.ReadOnly = true; + this.txtHotKeyShowHide.Size = new System.Drawing.Size(156, 20); + this.txtHotKeyShowHide.TabIndex = 2; + // + // lblHotKeyClone + // + this.lblHotKeyClone.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.lblHotKeyClone.Location = new System.Drawing.Point(168, 48); + this.lblHotKeyClone.Name = "lblHotKeyClone"; + this.lblHotKeyClone.Size = new System.Drawing.Size(78, 29); + this.lblHotKeyClone.TabIndex = 1; + this.lblHotKeyClone.Text = "Clone current window"; + // + // txtHotKeyClone + // + this.txtHotKeyClone.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtHotKeyClone.Location = new System.Drawing.Point(6, 45); + this.txtHotKeyClone.Name = "txtHotKeyClone"; + this.txtHotKeyClone.ReadOnly = true; + this.txtHotKeyClone.Size = new System.Drawing.Size(156, 20); + this.txtHotKeyClone.TabIndex = 0; + // + // groupLanguage + // + this.groupLanguage.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.groupLanguage.Controls.Add(this.comboLanguage); + this.groupLanguage.Controls.Add(this.lblLanguage); + this.groupLanguage.Location = new System.Drawing.Point(3, 3); + this.groupLanguage.Name = "groupLanguage"; + this.groupLanguage.Size = new System.Drawing.Size(252, 68); + this.groupLanguage.TabIndex = 0; + this.groupLanguage.TabStop = false; + this.groupLanguage.Text = "Language:"; + // + // comboLanguage + // + this.comboLanguage.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.comboLanguage.DrawMode = System.Windows.Forms.DrawMode.OwnerDrawFixed; + this.comboLanguage.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboLanguage.FormattingEnabled = true; + this.comboLanguage.IconList = null; + this.comboLanguage.Location = new System.Drawing.Point(9, 19); + this.comboLanguage.Name = "comboLanguage"; + this.comboLanguage.Size = new System.Drawing.Size(237, 21); + this.comboLanguage.TabIndex = 2; + this.comboLanguage.SelectedIndexChanged += new System.EventHandler(this.LanguageBox_IndexChange); + // + // lblLanguage + // + this.lblLanguage.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.lblLanguage.Location = new System.Drawing.Point(6, 43); + this.lblLanguage.Name = "lblLanguage"; + this.lblLanguage.Size = new System.Drawing.Size(240, 22); + this.lblLanguage.TabIndex = 1; + this.lblLanguage.Text = "Requires a restart."; + // + // OptionsPanel + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.AutoScroll = true; + this.Controls.Add(this.panelMain); + this.Controls.Add(this.btnClose); + this.MinimumSize = new System.Drawing.Size(270, 240); + this.Name = "OptionsPanel"; + this.Padding = new System.Windows.Forms.Padding(6); + this.Size = new System.Drawing.Size(270, 240); + this.panelMain.ResumeLayout(false); + this.groupHotkeys.ResumeLayout(false); + this.groupHotkeys.PerformLayout(); + this.groupLanguage.ResumeLayout(false); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Button btnClose; + private System.Windows.Forms.Panel panelMain; + private System.Windows.Forms.GroupBox groupLanguage; + private System.Windows.Forms.Label lblLanguage; + private ImageComboBox comboLanguage; + private System.Windows.Forms.GroupBox groupHotkeys; + private HotKeyTextBox txtHotKeyClone; + private System.Windows.Forms.Label lblHotKeyShowHide; + private HotKeyTextBox txtHotKeyShowHide; + private System.Windows.Forms.Label lblHotKeyClone; + private System.Windows.Forms.Label label1; + } +} diff --git a/OnTopReplica/SidePanels/OptionsPanel.cs b/OnTopReplica/SidePanels/OptionsPanel.cs new file mode 100644 index 0000000..d09cdaa --- /dev/null +++ b/OnTopReplica/SidePanels/OptionsPanel.cs @@ -0,0 +1,127 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.Properties; +using System.Globalization; + +namespace OnTopReplica.SidePanels { + partial class OptionsPanel : SidePanel { + + public OptionsPanel() { + InitializeComponent(); + + LocalizePanel(); + } + + private void LocalizePanel() { + groupLanguage.Text = Strings.SettingsLanguageTitle; + lblLanguage.Text = Strings.SettingsRestartRequired; + + groupHotkeys.Text = Strings.SettingsHotKeyTitle; + lblHotKeyShowHide.Text = Strings.SettingsHotKeyShowHide; + lblHotKeyClone.Text = Strings.SettingsHotKeyClone; + label1.Text = Strings.SettingsHotKeyDescription; + + btnClose.Text = Strings.MenuClose; + } + + public override void OnFirstShown(MainForm form) { + base.OnFirstShown(form); + + PopulateLanguageComboBox(); + + //Stop hotkey handling and load current shortcuts + form.MessagePumpManager.Get().Enabled = false; + txtHotKeyShowHide.Text = Settings.Default.HotKeyShowHide; + txtHotKeyClone.Text = Settings.Default.HotKeyCloneCurrent; + } + + private void Close_click(object sender, EventArgs e) { + OnRequestClosing(); + } + + public override string Title { + get { + return Strings.SettingsTitle; + } + } + + public override void OnClosing(MainForm form) { + base.OnClosing(form); + + //Update hotkey settings and update processor + Settings.Default.HotKeyShowHide = txtHotKeyShowHide.Text; + Settings.Default.HotKeyCloneCurrent = txtHotKeyClone.Text; + var manager = form.MessagePumpManager.Get(); + manager.RefreshHotkeys(); + manager.Enabled = true; + } + + #region Language + + class CultureWrapper { + public CultureWrapper(string name, CultureInfo culture, Image img) { + Culture = culture; + Image = img; + Name = name; + } + public CultureInfo Culture { get; set; } + public Image Image { get; set; } + public string Name { get; set; } + } + + CultureWrapper[] _languageList = { + new CultureWrapper("English", new CultureInfo("en-US"), Resources.flag_usa), + new CultureWrapper("Čeština", new CultureInfo("cs-CZ"), Resources.flag_czech), + new CultureWrapper("Dansk", new CultureInfo("da-DK"), Resources.flag_danish), + new CultureWrapper("Deutsch", new CultureInfo("de-DE"), Resources.flag_germany), + new CultureWrapper("Español", new CultureInfo("es-ES"), Resources.flag_spanish), + new CultureWrapper("Italiano", new CultureInfo("it-IT"), Resources.flag_ita), + new CultureWrapper("Polski", new CultureInfo("pl-PL"), Resources.flag_poland), + }; + + private void PopulateLanguageComboBox() { + comboLanguage.Items.Clear(); + + var imageList = new ImageList() { + ImageSize = new Size(16, 16), + ColorDepth = ColorDepth.Depth32Bit + }; + comboLanguage.IconList = imageList; + + int selectedIndex = -1; + foreach (var langPair in _languageList) { + var item = new ImageComboBoxItem(langPair.Name, imageList.Images.Count) { + Tag = langPair.Culture + }; + imageList.Images.Add(langPair.Image); + comboLanguage.Items.Add(item); + + if (langPair.Culture.Equals(CultureInfo.CurrentUICulture)) { + selectedIndex = comboLanguage.Items.Count - 1; + } + } + + //Handle case when there is not explicitly set culture (default to first one, i.e. english) + if (CultureInfo.CurrentUICulture.Equals(CultureInfo.InvariantCulture)) + selectedIndex = 0; + + comboLanguage.SelectedIndex = selectedIndex; + } + + private void LanguageBox_IndexChange(object sender, EventArgs e) { + var item = comboLanguage.SelectedItem as ImageComboBoxItem; + if (item == null) + return; + + Settings.Default.Language = item.Tag as CultureInfo; + } + + #endregion + + } + +} diff --git a/OnTopReplica/SidePanels/OptionsPanel.resx b/OnTopReplica/SidePanels/OptionsPanel.resx new file mode 100644 index 0000000..5ea0895 --- /dev/null +++ b/OnTopReplica/SidePanels/OptionsPanel.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/OnTopReplica/SidePanels/RegionPanel.Designer.cs b/OnTopReplica/SidePanels/RegionPanel.Designer.cs new file mode 100644 index 0000000..f716e1c --- /dev/null +++ b/OnTopReplica/SidePanels/RegionPanel.Designer.cs @@ -0,0 +1,339 @@ +namespace OnTopReplica.SidePanels { + partial class RegionPanel { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Component Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + this.components = new System.ComponentModel.Container(); + this.groupRegions = new System.Windows.Forms.GroupBox(); + this.checkRelative = new System.Windows.Forms.CheckBox(); + this.textRegionName = new OnTopReplica.FocusedTextBox(); + this.numH = new System.Windows.Forms.NumericUpDown(); + this.numW = new System.Windows.Forms.NumericUpDown(); + this.numY = new System.Windows.Forms.NumericUpDown(); + this.numX = new System.Windows.Forms.NumericUpDown(); + this.buttonDone = new System.Windows.Forms.Button(); + this.buttonReset = new System.Windows.Forms.Button(); + this.labelHeight = new System.Windows.Forms.Label(); + this.labelWidth = new System.Windows.Forms.Label(); + this.labelY = new System.Windows.Forms.Label(); + this.labelX = new System.Windows.Forms.Label(); + this.labelCurrentRegion = new System.Windows.Forms.Label(); + this.buttonDelete = new System.Windows.Forms.Button(); + this.buttonSave = new System.Windows.Forms.Button(); + this.comboRegions = new WindowsFormsAero.ComboBox(); + this.toolTip = new System.Windows.Forms.ToolTip(this.components); + this.groupRegions.SuspendLayout(); + ((System.ComponentModel.ISupportInitialize)(this.numH)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.numW)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.numY)).BeginInit(); + ((System.ComponentModel.ISupportInitialize)(this.numX)).BeginInit(); + this.SuspendLayout(); + // + // groupRegions + // + this.groupRegions.Controls.Add(this.checkRelative); + this.groupRegions.Controls.Add(this.textRegionName); + this.groupRegions.Controls.Add(this.numH); + this.groupRegions.Controls.Add(this.numW); + this.groupRegions.Controls.Add(this.numY); + this.groupRegions.Controls.Add(this.numX); + this.groupRegions.Controls.Add(this.buttonDone); + this.groupRegions.Controls.Add(this.buttonReset); + this.groupRegions.Controls.Add(this.labelHeight); + this.groupRegions.Controls.Add(this.labelWidth); + this.groupRegions.Controls.Add(this.labelY); + this.groupRegions.Controls.Add(this.labelX); + this.groupRegions.Controls.Add(this.labelCurrentRegion); + this.groupRegions.Controls.Add(this.buttonDelete); + this.groupRegions.Controls.Add(this.buttonSave); + this.groupRegions.Controls.Add(this.comboRegions); + this.groupRegions.Dock = System.Windows.Forms.DockStyle.Fill; + this.groupRegions.Location = new System.Drawing.Point(6, 6); + this.groupRegions.Name = "groupRegions"; + this.groupRegions.Size = new System.Drawing.Size(218, 180); + this.groupRegions.TabIndex = 0; + this.groupRegions.TabStop = false; + this.groupRegions.Text = "Regions:"; + // + // checkRelative + // + this.checkRelative.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.checkRelative.CheckAlign = System.Drawing.ContentAlignment.MiddleRight; + this.checkRelative.Location = new System.Drawing.Point(6, 119); + this.checkRelative.Name = "checkRelative"; + this.checkRelative.Size = new System.Drawing.Size(206, 18); + this.checkRelative.TabIndex = 12; + this.checkRelative.Text = "Relative to border"; + this.checkRelative.TextAlign = System.Drawing.ContentAlignment.MiddleRight; + this.checkRelative.UseVisualStyleBackColor = true; + this.checkRelative.CheckedChanged += new System.EventHandler(this.CheckRelative_checked); + // + // textRegionName + // + this.textRegionName.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.textRegionName.BackColor = System.Drawing.SystemColors.ActiveCaption; + this.textRegionName.ForeColor = System.Drawing.SystemColors.ActiveCaptionText; + this.textRegionName.Location = new System.Drawing.Point(6, 44); + this.textRegionName.Name = "textRegionName"; + this.textRegionName.Size = new System.Drawing.Size(208, 20); + this.textRegionName.TabIndex = 11; + this.textRegionName.Visible = false; + this.textRegionName.ConfirmInput += new System.EventHandler(this.Save_confirm); + this.textRegionName.AbortInput += new System.EventHandler(this.Save_lost); + // + // numH + // + this.numH.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.numH.Enabled = false; + this.numH.Location = new System.Drawing.Point(169, 93); + this.numH.Maximum = new decimal(new int[] { + 100000, + 0, + 0, + 0}); + this.numH.Minimum = new decimal(new int[] { + 100000, + 0, + 0, + -2147483648}); + this.numH.Name = "numH"; + this.numH.Size = new System.Drawing.Size(43, 20); + this.numH.TabIndex = 7; + this.numH.ValueChanged += new System.EventHandler(this.RegionValueSpinner_value_change); + // + // numW + // + this.numW.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.numW.Enabled = false; + this.numW.Location = new System.Drawing.Point(169, 67); + this.numW.Maximum = new decimal(new int[] { + 100000, + 0, + 0, + 0}); + this.numW.Minimum = new decimal(new int[] { + 100000, + 0, + 0, + -2147483648}); + this.numW.Name = "numW"; + this.numW.Size = new System.Drawing.Size(43, 20); + this.numW.TabIndex = 6; + this.numW.ValueChanged += new System.EventHandler(this.RegionValueSpinner_value_change); + // + // numY + // + this.numY.Enabled = false; + this.numY.Location = new System.Drawing.Point(55, 93); + this.numY.Maximum = new decimal(new int[] { + 100000, + 0, + 0, + 0}); + this.numY.Minimum = new decimal(new int[] { + 100000, + 0, + 0, + -2147483648}); + this.numY.Name = "numY"; + this.numY.Size = new System.Drawing.Size(43, 20); + this.numY.TabIndex = 5; + this.numY.ValueChanged += new System.EventHandler(this.RegionValueSpinner_value_change); + // + // numX + // + this.numX.Enabled = false; + this.numX.Location = new System.Drawing.Point(55, 67); + this.numX.Maximum = new decimal(new int[] { + 100000, + 0, + 0, + 0}); + this.numX.Minimum = new decimal(new int[] { + 100000, + 0, + 0, + -2147483648}); + this.numX.Name = "numX"; + this.numX.Size = new System.Drawing.Size(43, 20); + this.numX.TabIndex = 4; + this.numX.ValueChanged += new System.EventHandler(this.RegionValueSpinner_value_change); + // + // buttonDone + // + this.buttonDone.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonDone.Image = global::OnTopReplica.Properties.Resources.xiao_ok; + this.buttonDone.ImageAlign = System.Drawing.ContentAlignment.MiddleLeft; + this.buttonDone.Location = new System.Drawing.Point(142, 151); + this.buttonDone.Name = "buttonDone"; + this.buttonDone.Size = new System.Drawing.Size(70, 23); + this.buttonDone.TabIndex = 9; + this.buttonDone.Text = global::OnTopReplica.Strings.RegionsDoneButton; + this.buttonDone.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText; + this.buttonDone.UseVisualStyleBackColor = true; + this.buttonDone.Click += new System.EventHandler(this.Close_click); + // + // buttonReset + // + this.buttonReset.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonReset.Location = new System.Drawing.Point(66, 151); + this.buttonReset.Name = "buttonReset"; + this.buttonReset.Size = new System.Drawing.Size(70, 23); + this.buttonReset.TabIndex = 8; + this.buttonReset.Text = global::OnTopReplica.Strings.RegionsResetButton; + this.buttonReset.UseVisualStyleBackColor = true; + this.buttonReset.Click += new System.EventHandler(this.Reset_click); + // + // labelHeight + // + this.labelHeight.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.labelHeight.ForeColor = System.Drawing.SystemColors.ControlDark; + this.labelHeight.Location = new System.Drawing.Point(104, 95); + this.labelHeight.Name = "labelHeight"; + this.labelHeight.Size = new System.Drawing.Size(60, 18); + this.labelHeight.TabIndex = 9; + this.labelHeight.Text = "Height"; + this.labelHeight.TextAlign = System.Drawing.ContentAlignment.TopRight; + // + // labelWidth + // + this.labelWidth.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.labelWidth.ForeColor = System.Drawing.SystemColors.ControlDark; + this.labelWidth.Location = new System.Drawing.Point(107, 69); + this.labelWidth.Name = "labelWidth"; + this.labelWidth.Size = new System.Drawing.Size(57, 18); + this.labelWidth.TabIndex = 8; + this.labelWidth.Text = "Width"; + this.labelWidth.TextAlign = System.Drawing.ContentAlignment.TopRight; + // + // labelY + // + this.labelY.ForeColor = System.Drawing.SystemColors.ControlDark; + this.labelY.Location = new System.Drawing.Point(6, 96); + this.labelY.Name = "labelY"; + this.labelY.Size = new System.Drawing.Size(43, 17); + this.labelY.TabIndex = 5; + this.labelY.Text = "Y"; + this.labelY.TextAlign = System.Drawing.ContentAlignment.TopRight; + // + // labelX + // + this.labelX.ForeColor = System.Drawing.SystemColors.ControlDark; + this.labelX.Location = new System.Drawing.Point(6, 70); + this.labelX.Name = "labelX"; + this.labelX.Size = new System.Drawing.Size(43, 17); + this.labelX.TabIndex = 4; + this.labelX.Text = "X"; + this.labelX.TextAlign = System.Drawing.ContentAlignment.TopRight; + // + // labelCurrentRegion + // + this.labelCurrentRegion.AutoSize = true; + this.labelCurrentRegion.Font = new System.Drawing.Font("Microsoft Sans Serif", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.labelCurrentRegion.Location = new System.Drawing.Point(6, 47); + this.labelCurrentRegion.Name = "labelCurrentRegion"; + this.labelCurrentRegion.Size = new System.Drawing.Size(76, 13); + this.labelCurrentRegion.TabIndex = 3; + this.labelCurrentRegion.Text = "Current region:"; + // + // buttonDelete + // + this.buttonDelete.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.buttonDelete.Enabled = false; + this.buttonDelete.Image = global::OnTopReplica.Properties.Resources.xiao_delete; + this.buttonDelete.Location = new System.Drawing.Point(191, 18); + this.buttonDelete.Name = "buttonDelete"; + this.buttonDelete.Size = new System.Drawing.Size(23, 23); + this.buttonDelete.TabIndex = 3; + this.buttonDelete.UseVisualStyleBackColor = true; + this.buttonDelete.Click += new System.EventHandler(this.Delete_click); + // + // buttonSave + // + this.buttonSave.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right))); + this.buttonSave.Enabled = false; + this.buttonSave.Image = global::OnTopReplica.Properties.Resources.xiao_add; + this.buttonSave.Location = new System.Drawing.Point(168, 18); + this.buttonSave.Name = "buttonSave"; + this.buttonSave.Size = new System.Drawing.Size(23, 23); + this.buttonSave.TabIndex = 1; + this.buttonSave.UseVisualStyleBackColor = false; + this.buttonSave.Click += new System.EventHandler(this.Save_click); + // + // comboRegions + // + this.comboRegions.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.comboRegions.CueBannerText = global::OnTopReplica.Strings.RegionsStoredRegions; + this.comboRegions.DropDownStyle = System.Windows.Forms.ComboBoxStyle.DropDownList; + this.comboRegions.FlatStyle = System.Windows.Forms.FlatStyle.System; + this.comboRegions.FormattingEnabled = true; + this.comboRegions.Location = new System.Drawing.Point(6, 19); + this.comboRegions.Name = "comboRegions"; + this.comboRegions.Size = new System.Drawing.Size(160, 21); + this.comboRegions.TabIndex = 0; + this.comboRegions.SelectedIndexChanged += new System.EventHandler(this.RegionCombo_index_change); + // + // RegionPanel + // + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.Controls.Add(this.groupRegions); + this.MinimumSize = new System.Drawing.Size(230, 185); + this.Name = "RegionPanel"; + this.Padding = new System.Windows.Forms.Padding(6); + this.Size = new System.Drawing.Size(230, 192); + this.groupRegions.ResumeLayout(false); + this.groupRegions.PerformLayout(); + ((System.ComponentModel.ISupportInitialize)(this.numH)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.numW)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.numY)).EndInit(); + ((System.ComponentModel.ISupportInitialize)(this.numX)).EndInit(); + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.GroupBox groupRegions; + private System.Windows.Forms.Button buttonDelete; + private System.Windows.Forms.Button buttonSave; + private WindowsFormsAero.ComboBox comboRegions; + private System.Windows.Forms.Button buttonDone; + private System.Windows.Forms.Button buttonReset; + private System.Windows.Forms.Label labelHeight; + private System.Windows.Forms.Label labelWidth; + private System.Windows.Forms.Label labelY; + private System.Windows.Forms.Label labelX; + private System.Windows.Forms.Label labelCurrentRegion; + private System.Windows.Forms.NumericUpDown numH; + private System.Windows.Forms.NumericUpDown numW; + private System.Windows.Forms.NumericUpDown numY; + private System.Windows.Forms.NumericUpDown numX; + private FocusedTextBox textRegionName; + private System.Windows.Forms.ToolTip toolTip; + private System.Windows.Forms.CheckBox checkRelative; + } +} diff --git a/OnTopReplica/SidePanels/RegionPanel.cs b/OnTopReplica/SidePanels/RegionPanel.cs new file mode 100644 index 0000000..521cbda --- /dev/null +++ b/OnTopReplica/SidePanels/RegionPanel.cs @@ -0,0 +1,321 @@ +using System; +using System.Drawing; +using System.Windows.Forms; +using OnTopReplica.Properties; + +namespace OnTopReplica.SidePanels { + + partial class RegionPanel : SidePanel { + + public RegionPanel() { + InitializeComponent(); + + Localize(); + + //Copy settings into combo box + if (Settings.Default.SavedRegions != null) { + foreach (object o in Settings.Default.SavedRegions) { + comboRegions.Items.Add(o); + } + } + + _regionDrawnHandler = new ThumbnailPanel.RegionDrawnHandler(ThumbnailPanel_RegionDrawn); + } + + /// + /// Localizes the dialog's labels. + /// + private void Localize() { + this.SuspendLayout(); + + groupRegions.Text = Strings.RegionsTitle; + comboRegions.CueBannerText = Strings.RegionsStoredRegions; + labelCurrentRegion.Text = Strings.RegionsCurrentRegion; + buttonReset.Text = Strings.RegionsResetButton; + buttonDone.Text = Strings.RegionsDoneButton; + UpdateRegionLabels(); + + toolTip.SetToolTip(buttonSave, Strings.RegionsSaveButton); + toolTip.SetToolTip(buttonDelete, Strings.RegionsDeleteButton); + + this.ResumeLayout(); + } + + /// + /// Updates the labels for the region value selectors and the relative mode checkbox. + /// + private void UpdateRegionControls(ThumbnailRegion region) { + checkRelative.Checked = region.Relative; + + if (region.Relative) { + Padding p = region.BoundsAsPadding; + numX.Value = p.Left; + numY.Value = p.Top; + numW.Value = p.Right; + numH.Value = p.Bottom; + } + else { + Rectangle r = region.Bounds; + numX.Value = r.X; + numY.Value = r.Y; + numW.Value = r.Width; + numH.Value = r.Height; + } + + UpdateRegionLabels(); + } + + /// + /// Updates the labels of region selectors based on the dialog's state. + /// + private void UpdateRegionLabels() { + if (checkRelative.Checked) { + labelX.Text = Strings.RegionsLeft; + labelY.Text = Strings.RegionsTop; + labelWidth.Text = Strings.RegionsRight; + labelHeight.Text = Strings.RegionsBottom; + } + else { + labelX.Text = Strings.RegionsX; + labelY.Text = Strings.RegionsY; + labelWidth.Text = Strings.RegionsWidth; + labelHeight.Text = Strings.RegionsHeight; + } + } + + public override string Title { + get { + return Strings.MenuRegion; + } + } + + ThumbnailPanel.RegionDrawnHandler _regionDrawnHandler; + + public override void OnFirstShown(MainForm form) { + base.OnFirstShown(form); + + //Init shown region if current thumbnail is clipped to region + if (form.SelectedThumbnailRegion != null) { + SetRegion(form.SelectedThumbnailRegion); + } + + //Enable region drawing + form.ThumbnailPanel.DrawMouseRegions = true; + form.ThumbnailPanel.RegionDrawn += _regionDrawnHandler; + } + + public override void OnClosing(MainForm form) { + base.OnClosing(form); + + //Reset region drawing + form.ThumbnailPanel.DrawMouseRegions = false; + form.ThumbnailPanel.RegionDrawn -= _regionDrawnHandler; + } + + void ThumbnailPanel_RegionDrawn(object sender, ThumbnailRegion region) { + SetRegion(region); + } + + #region Interface + + /// + /// Sets the current selected region to a specific instance of a stored region. + /// + /// A stored region instance or null to reset. + public void SetRegion(StoredRegion region) { + if (region == null) { + Reset(); + return; + } + + SetRegion(region.Region); + + //Select right combobox + if (comboRegions.Items.Contains(region)) { + comboRegions.SelectedItem = region; + } + } + + /// + /// Sets the current selected region to a specific region rectangle. + /// + /// The region boundaries. + public void SetRegion(ThumbnailRegion region) { + try { + _ignoreValueChanges = true; + + UpdateRegionControls(region); + + numX.Enabled = numY.Enabled = numW.Enabled = numH.Enabled = true; + } + finally { + _ignoreValueChanges = false; + } + + OnRegionSet(region); + } + + /// + /// Resets the selected region and disables the num spinners. + /// + public void Reset() { + try { + _ignoreValueChanges = true; + + numX.Value = numY.Value = numW.Value = numH.Value = 0; + numX.Enabled = numY.Enabled = numW.Enabled = numH.Enabled = false; + checkRelative.Checked = false; + UpdateRegionLabels(); + + buttonSave.Enabled = false; + + comboRegions.SelectedIndex = -1; + } + finally { + _ignoreValueChanges = false; + } + } + + #endregion + + /// + /// Constructs a ThumbnailRegion from the dialog's current state. + /// + protected ThumbnailRegion ConstructCurrentRegion() { + Rectangle bounds = new Rectangle { + X = (int)numX.Value, + Y = (int)numY.Value, + Width = (int)numW.Value, + Height = (int)numH.Value + }; + + ThumbnailRegion newRegion = new ThumbnailRegion(bounds, checkRelative.Checked); + + return newRegion; + } + + /// + /// Adds a new stored region. + /// + /// Region bounds. + /// Name of the region. + /// Whether the region is relative to the border. + private void StoreCurrentRegion(string regionName) { + StoredRegion storedRegion = new StoredRegion(this.ConstructCurrentRegion(), regionName); + + int index = comboRegions.Items.Add(storedRegion); + comboRegions.SelectedIndex = index; + + if (Settings.Default.SavedRegions == null) + Settings.Default.SavedRegions = new StoredRegionArray(); + Settings.Default.SavedRegions.Add(storedRegion); + } + + /// + /// Internal event raised when a change occurs in the selected region. + /// + /// Region bounds. + protected virtual void OnRegionSet(ThumbnailRegion region) { + //Forward region to thumbnail + ParentForm.SelectedThumbnailRegion = region; + + //Have region, allowed to save + buttonSave.Enabled = true; + } + + #region GUI event handlers + + private void Close_click(object sender, EventArgs e) { + OnRequestClosing(); + } + + private void Reset_click(object sender, EventArgs e) { + Reset(); + ParentForm.SelectedThumbnailRegion = null; + } + + private void Delete_click(object sender, EventArgs e) { + if (comboRegions.SelectedIndex < 0) + return; + + var origIndex = comboRegions.SelectedIndex; + Settings.Default.SavedRegions.RemoveAt(origIndex); + comboRegions.Items.RemoveAt(origIndex); + + if (comboRegions.Items.Count > 0) + comboRegions.SelectedIndex = 0; + } + + private void Save_click(object sender, EventArgs e) { + //Display textbox instead of button + buttonSave.Enabled = buttonDelete.Enabled = false; + textRegionName.Visible = true; + textRegionName.Focus(); + } + + private void Save_confirm(object sender, EventArgs e) { + if (!string.IsNullOrEmpty(textRegionName.Text)) { + StoreCurrentRegion(textRegionName.Text); + } + + //Hide textbox and show button again + textRegionName.Visible = false; + textRegionName.Text = string.Empty; + + buttonSave.Enabled = buttonDelete.Enabled = true; + } + + private void Save_lost(object sender, EventArgs e) { + //Reset textbox + textRegionName.Visible = false; + textRegionName.Text = string.Empty; + + buttonSave.Enabled = buttonDelete.Enabled = true; + buttonSave.Focus(); + } + + // Used to signal to the value change handler that all events should be temporarily ignored. + bool _ignoreValueChanges = false; + + private void RegionValueSpinner_value_change(object sender, EventArgs e) { + if (_ignoreValueChanges) + return; + + OnRegionSet(ConstructCurrentRegion()); + } + + private void RegionCombo_index_change(object sender, EventArgs e) { + buttonDelete.Enabled = (comboRegions.SelectedIndex >= 0); + + if (comboRegions.SelectedIndex >= 0) { + //Load region + var region = comboRegions.SelectedItem as StoredRegion; + + if (region == null) + return; + + SetRegion(region.Region); + } + } + + private void CheckRelative_checked(object sender, EventArgs e) { + if (_ignoreValueChanges) + return; + + //Get current region and switch mode + var region = ConstructCurrentRegion(); + region.Relative = !region.Relative; //this must be reversed because the GUI has already switched state when calling ConstructCurrentRegion() + if (checkRelative.Checked) + region.SwitchToRelative(ParentForm.ThumbnailPanel.ThumbnailOriginalSize); + else + region.SwitchToAbsolute(ParentForm.ThumbnailPanel.ThumbnailOriginalSize); + + //Update GUI + SetRegion(region); + } + + #endregion + + } + +} diff --git a/OnTopReplica/SidePanels/RegionPanel.resx b/OnTopReplica/SidePanels/RegionPanel.resx new file mode 100644 index 0000000..026c576 --- /dev/null +++ b/OnTopReplica/SidePanels/RegionPanel.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + \ No newline at end of file diff --git a/OnTopReplica/StartupOptions/CliStatus.cs b/OnTopReplica/StartupOptions/CliStatus.cs new file mode 100644 index 0000000..a445e68 --- /dev/null +++ b/OnTopReplica/StartupOptions/CliStatus.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.StartupOptions { + public enum CliStatus { + /// + /// No errors while parsing. + /// + Ok, + /// + /// User asked for help. + /// + Information, + /// + /// Error while parsing. + /// + Error + } + +} diff --git a/OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs b/OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs new file mode 100644 index 0000000..9a2ec68 --- /dev/null +++ b/OnTopReplica/StartupOptions/CommandLineReportForm.Designer.cs @@ -0,0 +1,116 @@ +namespace OnTopReplica.StartupOptions { + partial class CommandLineReportForm { + /// + /// Required designer variable. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// Clean up any resources being used. + /// + /// true if managed resources should be disposed; otherwise, false. + protected override void Dispose(bool disposing) { + if (disposing && (components != null)) { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form Designer generated code + + /// + /// Required method for Designer support - do not modify + /// the contents of this method with the code editor. + /// + private void InitializeComponent() { + System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(CommandLineReportForm)); + this.buttonOk = new System.Windows.Forms.Button(); + this.labelInstruction = new System.Windows.Forms.Label(); + this.txtDescription = new System.Windows.Forms.TextBox(); + this.label1 = new System.Windows.Forms.Label(); + this.txtCliArgs = new System.Windows.Forms.TextBox(); + this.SuspendLayout(); + // + // buttonOk + // + this.buttonOk.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Right))); + this.buttonOk.DialogResult = System.Windows.Forms.DialogResult.OK; + this.buttonOk.Location = new System.Drawing.Point(440, 200); + this.buttonOk.Name = "buttonOk"; + this.buttonOk.Size = new System.Drawing.Size(75, 23); + this.buttonOk.TabIndex = 0; + this.buttonOk.Text = "OK"; + this.buttonOk.UseVisualStyleBackColor = true; + // + // labelInstruction + // + this.labelInstruction.AutoSize = true; + this.labelInstruction.Font = new System.Drawing.Font("Segoe UI", 12F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.labelInstruction.ForeColor = System.Drawing.SystemColors.HotTrack; + this.labelInstruction.Location = new System.Drawing.Point(12, 10); + this.labelInstruction.Name = "labelInstruction"; + this.labelInstruction.Size = new System.Drawing.Size(112, 21); + this.labelInstruction.TabIndex = 1; + this.labelInstruction.Text = "Command line"; + // + // txtDescription + // + this.txtDescription.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) + | System.Windows.Forms.AnchorStyles.Left) + | System.Windows.Forms.AnchorStyles.Right))); + this.txtDescription.Font = new System.Drawing.Font("Consolas", 8.25F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0))); + this.txtDescription.Location = new System.Drawing.Point(12, 42); + this.txtDescription.Multiline = true; + this.txtDescription.Name = "txtDescription"; + this.txtDescription.ReadOnly = true; + this.txtDescription.ScrollBars = System.Windows.Forms.ScrollBars.Vertical; + this.txtDescription.Size = new System.Drawing.Size(503, 152); + this.txtDescription.TabIndex = 2; + // + // label1 + // + this.label1.AutoSize = true; + this.label1.Location = new System.Drawing.Point(13, 205); + this.label1.Name = "label1"; + this.label1.Size = new System.Drawing.Size(60, 13); + this.label1.TabIndex = 3; + this.label1.Text = "Arguments:"; + // + // txtCliArgs + // + this.txtCliArgs.Location = new System.Drawing.Point(79, 202); + this.txtCliArgs.Name = "txtCliArgs"; + this.txtCliArgs.ReadOnly = true; + this.txtCliArgs.Size = new System.Drawing.Size(355, 20); + this.txtCliArgs.TabIndex = 4; + // + // CommandLineReportForm + // + this.AcceptButton = this.buttonOk; + this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.ControlLightLight; + this.ClientSize = new System.Drawing.Size(527, 235); + this.Controls.Add(this.txtCliArgs); + this.Controls.Add(this.label1); + this.Controls.Add(this.txtDescription); + this.Controls.Add(this.labelInstruction); + this.Controls.Add(this.buttonOk); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.Icon = ((System.Drawing.Icon)(resources.GetObject("$this.Icon"))); + this.Name = "CommandLineReportForm"; + this.Text = "Command line parameters"; + this.ResumeLayout(false); + this.PerformLayout(); + + } + + #endregion + + private System.Windows.Forms.Button buttonOk; + private System.Windows.Forms.Label labelInstruction; + private System.Windows.Forms.TextBox txtDescription; + private System.Windows.Forms.Label label1; + private System.Windows.Forms.TextBox txtCliArgs; + } +} \ No newline at end of file diff --git a/OnTopReplica/StartupOptions/CommandLineReportForm.cs b/OnTopReplica/StartupOptions/CommandLineReportForm.cs new file mode 100644 index 0000000..e3315ca --- /dev/null +++ b/OnTopReplica/StartupOptions/CommandLineReportForm.cs @@ -0,0 +1,30 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica.StartupOptions { + public partial class CommandLineReportForm : Form { + + public CommandLineReportForm(CliStatus status, string message) { + InitializeComponent(); + + switch (status) { + case CliStatus.Information: + labelInstruction.Text = "Command line help"; + break; + + case CliStatus.Error: + labelInstruction.Text = "Command line parsing error"; + break; + } + + txtDescription.Text = message; + + txtCliArgs.Text = Environment.CommandLine; + } + + } +} diff --git a/OnTopReplica/StartupOptions/CommandLineReportForm.resx b/OnTopReplica/StartupOptions/CommandLineReportForm.resx new file mode 100644 index 0000000..b6de04b --- /dev/null +++ b/OnTopReplica/StartupOptions/CommandLineReportForm.resx @@ -0,0 +1,1574 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAYAgIAAAAEAIAAoCAEAZgAAADAwAAABACAAqCUAAI4IAQAgIAAAAQAgAKgQAAA2LgEAGBgAAAEA + IACICQAA3j4BABQUAAABACAAuAYAAGZIAQAQEAAAAQAgAGgEAAAeTwEAKAAAAIAAAAAAAQAAAQAgAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAgAAAAMAAAAGAAAABwAAAAoAAAANAAAADwAA + ABEAAAAVAAAAGAAAABoAAAAdAAAAHgAAACAAAAAhAAAAIgAAACIAAAAjAAAAIwAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAAACIAAAAiAAAAIgAA + ACAAAAAfAAAAHgAAABwAAAAZAAAAFwAAABMAAAAQAAAADgAAAAsAAAAIAAAABwAAAAQAAAACAAAAAgAA + AAMAAAAEAAAABQAAAAkAAAALAAAADgAAABIAAAAWAAAAGQAAAB0AAAAgAAAAJAAAACcAAAAqAAAAKwAA + AC0AAAAvAAAALwAAADAAAAAwAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAvAAAALwAA + AC8AAAAvAAAALwAAAC8AAAAvAAAALwAAAC8AAAAuAAAALQAAACsAAAApAAAAJgAAACIAAAAfAAAAHAAA + ABgAAAAUAAAAEAAAAAwAAAAKAAAABwAAAAQAAAADAAAABAAAAAYAAAAIAAAADAAAAA8AAAATAAAAGAAA + AB0AAAAiAAAAJgAAACoAAAAuAAAAMQAAADQAAAA2AAAAOAAAADoAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOgAA + ADkAAAA4AAAANgAAADMAAAAwAAAALAAAACgAAAAlAAAAIAAAABsAAAAWAAAAEQAAAA4AAAAKAAAABwAA + AAQAAAAFAAAACAAAAAsAAAAPAAAAEwAAABkAAAAfAAAAJQAAACoAAAAvAAAANQAAADoAAAA+AAAAQQAA + AEQAAABGAAAASAAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABJAAAASQAA + AEkAAABJAAAASQAAAEkAAABJAAAASQAAAEkAAABIAAAARwAAAEUAAABDAAAAQAAAADwAAAA4AAAAMwAA + AC0AAAAoAAAAIgAAABwAAAAWAAAAEgAAAA0AAAAJAAAABQAAAAcAAAALAAAADQAAABIAAAAYAAAAIAAA + ACYAAAAtAAAANAAAADoAAABAAAAARgAAAEsAAABPAAAAUQAAAFQAAABWAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAAAFcAAABXAAAAVwAA + AFYAAABVAAAAUwAAAFAAAABOAAAASQAAAEQAAAA+AAAAOAAAADEAAAAqAAAAIwAAAB0AAAAWAAAAEAAA + AAsAAAAGAAAACAAAAA0AAAARAAAAFwAAAB8AAAAmAAAALgAAADcAAAA+AAAARgAAAEwAAABSAAAAVwAA + AFwAAABfAAAAYgAAAGMAAABkAAAAZQAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAA + AGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAYwAAAGMAAABhAAAAXgAAAFoAAABVAAAAUAAA + AEoAAABDAAAAOgAAADIAAAAqAAAAIwAAABwAAAAVAAAADgAAAAgAAAAKAAAAEAAAABUAAAAdAAAAJAAA + AC0AAAA2AAAAQAAAAEkAAABRAAAAWAAAAF4AAABkAAAAaQAAAGwAAABuAAAAcAAAAHEAAAByAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABwAAAAbwAAAG4AAABqAAAAZwAAAGIAAABcAAAAVQAAAE4AAABFAAAAPAAAADIAAAApAAAAIAAA + ABoAAAASAAAACQAAAA0AAAATAAAAGQAAACEAAAArAAAANQAAAD8AAABJAAAAUwAAAFwAAABlAAAAawAA + AHEAAAB2AAAAeQAAAHsAAAB9AAAAfwAAAH8AAAB+AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAA + AH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH8AAAB/AAAAfwAAAH0AAAB8AAAAfAAAAHcAAAB0AAAAbQAA + AGcAAABgAAAAWAAAAE8AAABFAAAAOgAAADAAAAAmAAAAHgAAABUAAAALAAAADwAAABYAAAAeAAAAJgAA + ADAAAAA8AAAASAAAAFQAAABeAAAAagAAAHQAAAB8AAAAgwAAAIcAAACLAAAAjAAAAI0AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAAAI4AAACOAAAAjgAA + AI4AAACOAAAAjQAAAI0AAACLAAAAhwAAAIEAAAB6AAAAcgAAAGoAAABiAAAAWAAAAE0AAABCAAAANwAA + ACwAAAAiAAAAGQAAAA0AAAARAAAAGQAAACEAAAAqAAAANQAAAEIAAABPAAAAXgAAAG0AAAB8AAAAkAAA + AKAAAACkAAAAqAAAAKoAAACrAAAArAAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAA + AK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACtAAAArQAAAK0AAACsAAAAqwAAAKoAAAChAAAAlAAA + AIgAAAB9AAAAcwAAAGoAAABgAAAAVQAAAEkAAAA9AAAAMQAAACYAAAAdAAAADwAAABQAAAAbAAAAJQAA + AC4AAAA5AAAARwAAAFcAAABpAAAAgwAAALMMDAzWTk5O8FxcXOxZWVjrWVlY61lZWetaWVnrWllZ61pZ + WetbWlrrWlpa61paWutaWlrrW1pa61paW+taW1vrW1tb61tbW+tbW1vrW1tb61tbW+tbW1vqW1tb6ltb + W+pcW1zqXFtb6lxbW+pcW1vqXFtb6lxbW+pcW1vqXFtb6lxcXOpcXFzqXFxc6lxbW+pcW1vqW1tb6ltb + W+pbW1vqW1tb6lpaW+paWlrqWlpa6lpaWupaWlrqWlpa6lpaWupZWVrqWlla6lpZWepaWlrqWlpa6lpb + WutaW1rrWlta61pbWutaWlrrWlpa61taWutaWlrrWlpa61paWutaWlrrWlpa61paWutaWlrrWlpa61pa + WutaWlrrWlpa61paWutaWlnqWlpZ6lpZWepaWVnqWllZ6lpZWepaWVnqWllZ6lpaWepaWlnqWVlZ61pa + WepaWlnrWlpZ6lpaWupaWlrqWlpa6ltaWupbWlvqWlpa6lpaWupaWlrqWlpa6ltaWupaWlrqWlpa6lpa + WepaWlnqWlpZ6lpaWepbW1vrVFRU7RcXFuEAAADEAAAAngAAAIMAAAB4AAAAcgAAAGYAAABbAAAATwAA + AEMAAAA2AAAAKwAAACEAAAAQAAAAFgAAAB8AAAAoAAAAMgAAAEAAAABRAAAAZQAAAIEAAADLWVlY8ZmY + lc/HwburzsfBp8rGvafKxL2oycO7psbAuaXFvrilxL62pMO+taPBurKjvbiwo7+4r6G9tq6iu7Wtoby0 + rKG6s6yhubOrobeyqqG3s6qgt7KpoLeyqZ62saietK+mnrKupJ6zrqWes66lnrOupZ6zrqWes66lnrOt + pZ6zrKWesquknbKrpJ2yq6Sds6ylnrKspZ60raWdtK6lnbavp524saieurGpn7qzq5+7ta2fvLevnr63 + sZ/AubGfwbqxn8K6sp/FvbSew7yzoMS+tZ/EvrSfxL+1oMS/taHEv7WhxL+1ocW/tqLFv7aixsC4ocfA + uaHHwLmhx8C5ocfAuaHHwLmhyMG5ocjBuaHIwbmhyMG5ocjBuaHIwrqiycK6osnCuaDJwrmhycO7ocnD + u6HJw7uhycO7ocnDu6HJw7uhycK6ocnCuqHKw7uhycK7ocjCuqHHw7mgxsG4oMa+tqDEvbagxLy0nsO7 + sp7BurGew7yznsK7s5/EvLSfxb21nsW+tZ/Gv7igxsC5oMjDuqLJwrqiycO7os3GvqPIw7uloZ6cxWZl + ZO0JCQjdAAAAogAAAIQAAAB7AAAAbQAAAGAAAABUAAAASAAAADsAAAAvAAAAIwAAABIAAAAYAAAAIQAA + ACoAAAA1AAAARAAAAFgAAAB7BQUExHBvbu/Lx8Ktpp2Qd3xxY2RxZVhjcmdZY3JnW2JzZlhhcGZXYW1h + VmBqYFFeZ1xMXmRZSl1hV0hdYVZFXGBURFtdUEFaW01AWlhNP1lXTT1ZVUs7WFJKOlhSSTlYU0g5V1FH + N1dORTRWS0IxVkxBMVZMQTFWTEExVkxBMVZMQTFWTD8xVkw/MVZLPTBWSjwvVUo9MFZMPzFWTEAxVU5B + MVVRQzNVUkU0VVVIOVZZSztWWk09VltPQVdfU0VXYlVIV2NXSFdmWUlXaFpKV2pdTlhqX05YaWBPWGlf + TlhqYE9YamBPWWpgT1lrYVFZbGFSWmxhUlpuYVVabmFVWm9iVlpvYlZab2JWWnBjVlpyZVZacmVWWnJl + VlpyZVZacmVWWnNmV1xzZ1hcdGdYXHRnWF11altddWpbXXVqW111altddWpbXXVqW110aVtddmlaXXZq + Wlx1aVtddGdZXG9lV1twZFRabGBSWmpeUVlqXU1XZ1xMV2lcS1dpXUxXZltMWGleTlhrX09YbWFRWm1i + VFpvZFdbcmVYXHBkVltwZFdccGNVXHNpWluflIdszcfCn4WEg+kODg3XAAAAnQAAAIMAAABzAAAAZgAA + AFkAAABLAAAAPQAAADIAAAAmAAAAFAAAABoAAAAjAAAALQAAADkAAABJAAAAYQAAAI8cGxrmz83JwI2E + eG2Bd2ptioB1dJGIfHeUiYF5l46EepmQh3yakYh8mZKIe5aPhXuUjIJ6k4uAepGJf3mPiH14kId7d46E + e3aLgnh2ioN5doqDeHWKgnd0h4B1dISAdXSFgHV0hn90c4N8cXODe3FygnpvcoJ6b3KCem9ygnpvcoJ5 + b3KCd29ygndvcoJ3b3J/d21ygHducoJ3b3KDem9xhXxwcYZ8cXGGfXJyiYB1couCd3KMhHhyjYZ7c4+G + fXOSiX9zk4p/c5WMgHOWjYF0lo2CdJaPhHSWj4N0lo+EdJeQhXWXkIV1l5GFdpiRhnaYkYd2mZGIdpqR + iHaakIh2mpCIdpqQiHaakIh2m5GIdpySiHackoh2nJKIdpySiHackoh2nZOJd52UiXedlYl4nZWJeJ2W + i3idlot4nZaLeJ2Wi3idlot4nZaLeJ+YjXiflot4npaLeJ2Ui3iblIl3mpKIdpmQh3aYj4d2mJCEdJWN + gnSTjIJ0l4+EdJWNg3WVjoN1mJCEdZmRhXaakId2mpOId5qRiHaZj4Z1lIyCdJKJfnKLg3hvh3xwbH91 + Z2eCeGxi1NDLrjY1NOoAAAC0AAAAjAAAAHgAAABpAAAAXQAAAE4AAABAAAAANQAAACgAAAAUAAAAGQAA + ACMAAAAuAAAAOgAAAE0AAABkAAAAt4OCgeKupp+JiX9zcpGJf3iZk4d8o5yTg6qknYmwqqOMtK2nkLaw + qpK4sauTt7GqkrWvqZK0r6iRs62nkbOspY+xrKSPsaqkjq+po46vqqKOrqmija6poYyuqaGMrKigjKuo + oIyrqKCMq6Wdi6qlnYqqpZ2KqaOciqmjnIqpopyKqaKciqminIqpopyKqaKciqmjnIupo5yLqaKciqqk + nYqtpp6Kraaeiq6noIqvqaGKr6uii7GspIuzrKaLs66ni7Wvp4u3sKmLuLGqi7ewqYy3sKmMt7KrjLey + qoy3sqqMt7Krjbeyq423squNt7KrjbiyrI24sqyNuLKsjbmzrY65s62OubOtjrmzrY66tK2OurStjrq0 + rY66tK2OurStjru0rY67ta2PurWtj7q1rY+6ta6PurWuj7q1ro+6ta6PurWuj7q1ro+8t6+PvLWuj7y2 + ro+7ta6PubStj7m0rY65s6yOuLKsjbiyqoy4squMtbCpjLewqYu1samMtrCpjLeyq4y4sauNubOtjrq0 + rY64sauOtrGqjLOtpYmuqKCFpqCXgJ2Ui3mUjIF0joR5cIF3bGmknZR4lpST1wcHB8wAAACRAAAAfgAA + AGwAAABfAAAAUAAAAEIAAAA2AAAAKgAAABYAAAAcAAAAJQAAAC8AAAA8AAAAUAAAAGkAAADJ0tHP2pWM + g3eWjIJ6nZWNgKijm4m+saqOzLy2l9PFv6HZy8Wm3M/Kq97RzK3dz8ut3c/KrNzPyqvczsmr287JqtvN + yarazcep2s7IqdnMyKnZzMep2MzGqNjMxqjYzMan18vGp9XKxafVysWn1srFp9XKxabVysWm1MnEptTI + xKbUyMSm1MjEptPIxKbTyMSm08nEp9PJxKfUycWn1srFptbKxabWysam18vHptfMyKbXzcmn2M7Jp9nO + yqfZzsqn2c/Kp9vRy6fb0Mun2tDLp9rQzKfa0cyn2tHMqNrQzKjZ0M2o2dDNqNnQzKjZ0Myo2tDNqNrQ + zajZ0M6o2tDOqdrQzqna0M6p2tDPqdrRz6nZ0c+p2dHPqdnRz6nZ0c+p2NDOqdnRzqrZ0c6q2NHOqtjR + zqrY0c6q19HOqtfRzarX0c2q1tLOqtXRzarW0c2q1dHMqtTQzKnU0cyq1NDLqdTPzKnTz8uo08/KqNLO + yqjTz8qn0s7Jp9LOyqjTz8qn0s7KqNPQy6jU0cyp1NDNqtPPzajPzMqky8fFnsO/vpa5s7GLrqehhqOa + kXyXjoR2jIR5cYqBdWvf29jHExIS2gAAAJUAAACAAAAAbgAAAGAAAABSAAAARAAAADgAAAArAAAAFgAA + ABsAAAAlAAAAMAAAAD0AAABUAAAAbAAAAMjT0c/fnZOJe52Vi3+qo5yJvbStk6TJyrqi1NbKq9rc0LDf + 4dey4eTasuLl3LHh49yx4OTcseDj27Lg49uw4eLcseDi27Hg49uy4OLbsuDi2rLg4dqy4OHas+Di2rTh + 4dq04OHateDg2rXg4dq24OHatuDg2bbg4Nm24eDZtt/f2bfg39m44N/ZueDf2brg39q54N7auuDe2rrh + 39m74d/ZvOHf2b3h4Nm+4uHZveLh2sDj4trB5OLawuXj2sPl5NrF5eTaxubk2sbl49rG5eTaxuXi2sbl + 4trG5eHax+Xh2sjm4trJ5eLayuXi2srm4trM5uHazObh2s3n4NrO59/azuff2s7o39rQ6d/a0erf2tHr + 39rT697a0+ze2tXt3trX7d/b1+7g29nu4dvb7uLb3e7i293u4tve7uPb4e7j2+Xu5dvp7ufb7O7n2+7v + 6tvw7urb7+7s2+/u7Nvv7uza7u3s2u7t7Nrv7eza7u3s2u/t7Nru7eza7+7t2u3u7tru7e7a7+7w2u/t + 7tvw7uvb7u3l2uzr3Nbp59TR5ePKy93bv8LCvbWYsKuhh6GakXyVjIF1jYV6bt7d2swTExLaAAAAmAAA + AIEAAABvAAAAYQAAAFMAAABFAAAAOQAAACwAAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAydTS + 0d+hmZCAp5+XhbeyqpLTxL+fW9vm9jjg7f8/3ur/P97r/z/c6f8+2+f/Pdvn/z7b6P8+2+j/Qdzm/0Hc + 5v9B3Ob/Qtvm/0Pc5v9E3OX/Rtzk/0je5f9L3uX/TN/k/03f5P9Q3+T/Ud7k/1Hf4v9T3+P/VeDi/1bg + 4f9Y4OH/WuHh/1zh4P9e4eH/X+Hf/17h3/9g4d7/YuLe/2Pi3v9l4t7/Z+Te/2nj3v9q497/bebe/3Hm + 4P9y59//defh/3nn4v976OL/fOnj/37p4/+B6eP/guni/4Lq4f+G6+H/iezg/4rs3v+M7N//j+3e/5Pv + 3v+V8d//mPPe/5r13f+c9t3/nvjd/6L73P+k/Nv/qf3b/67+2/+w/9v/s//a/7X/2/+3/9v/vP/d/8T/ + 4P/N/+T/1v/n/9//7v/o//T/8P/3//f/+v/8//v////+//////////////////////////////////// + ///////////////////////////9////9v////D////n////2////87////C////t////67///+q/9PQ + xKy9ubOSraWdhJqTiXmRiX1w4N3azBMSEtoAAACYAAAAggAAAHAAAABiAAAAVAAAAEYAAAA6AAAALAAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADJ1NPR36WfloOspZ6KwLu0mt3Qy6xm2+LyQdvk/0bb + 4/9F2uP/Rtni/0fa4f9H2uH/SNvi/0nb4v9K2+D/S9vh/0vb3/9M29//Tdvf/03b3v9P3N3/Utze/1Pd + 3f9U3d3/Vt7d/1fe3P9X3dz/WN7b/1zf2v9e4Nn/YN/Z/2Dg2v9f39n/YN/X/2Hf1v9g4Nb/YuDW/2Th + 1f9m4dX/Z+LU/2rh0/9s4tP/beLT/27j0v9w5ND/ceXQ/3Ll0f9059D/debS/3jo1P976tX/f+zX/4Ts + 2f+F7tv/ifDc/43w3f+R8t7/kvXf/5P23/+W997/mvne/5z83v+f/d7/o/3g/6f+4f+r/+L/rf/j/6// + 4v+z/+P/uP/j/7z/5P/C/+b/yf7m/9L+6f/b/uv/5v7w/+/+9P/3/vn//P/9//////////////////// + ///////////////+///7/v//+P78//r+/v///v/////7///+8f/8/uf/+v7d//j+1P/2/sv/8/6//+/+ + tP/s/6z/7P+m/+z+o//s/6H/6f+j/+r/n//n/53/2tnOuMfCvpyzr6aKoJmPfJSMgnLg3dvNExIS2gAA + AJgAAACDAAAAcQAAAGMAAABUAAAARgAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbgAA + AMnU09Hfp6CYhbGro47FwLuf5djUtWLa3/Q62N7/Qdjd/0HY3f9B2dz/Q9na/0PZ2/9E2dv/Rdna/0Xa + 2f9H2tj/R9nY/0ja2P9I2tj/SNrY/0ra1v9L29X/TNvV/03c1f9Q3NX/UtzV/1Td1P9U3dP/Vd7S/1bd + 0f9W3dD/V97P/1fezv9Y3s3/Wd7M/1nezP9c3sv/Xd/K/1/fyv9h4Mn/Y+DJ/2Liyf9j48j/ZuTI/2jm + x/9p5sj/a+bI/2zox/9u6cf/cOrI/3HsyP9178f/d/DI/3nyyf999cv/gvjO/4f60f+L/df/k//a/5n/ + 3v+d/+L/o//k/6j/5P+t/uT/tP/k/7r+5f/B/uj/yv3t/9T+8v/d/vb/6f74//P++v/5//z/+//9//3/ + /v///////////////////////////////v////v////6////+f////b/+/3y/+v87v/g/ez/3v3p/9f8 + 4//i/d//6f3Q/+P+u//f/63/2P+k/9L/nf/N/5j/zv2V/8/9kv/Q/Y//0PyN/9P8jP/V+pD/wPac/6T3 + pv/Z3tbBzsnFo7mzrI+lnpR+mI+GdOHd3M0TEhLaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAyAAAAPgAAAFQAAABuAAAAydTT0eCqpJqGs66okcnFwKXq3Nm7bN/l9UXd + 5f9M3eX/Td3l/0zd4v9L297/SNvc/0Xa2f9F2dj/RNrV/0PZ0v9E2dL/RdnR/0TY0P9F2ND/RtnP/0na + zv9M3M//TtzP/1Hbzv9Q3Mz/TtvK/07Zyf9P2sn/UNrH/1Dbxv9S28X/VNvF/1XcxP9V3MT/Vt3E/1je + xP9Y3sP/Wd/C/1vhwv9c4sL/X+LB/2Dlwf9j5sD/ZebB/2Xowv9n6sH/aevC/2ruwf9s8cH/bvPC/3D2 + w/9y+cT/dvzE/3n+xv99/8j/gf/I/4f+zP+Q/s//mv7W/6v+3/+8/ur/yv3y/9b+9v/e/vn/5v77/+r+ + /P/t/v7/7P7///H////4///////////////////////////////////////+//3/+f/5//T/9P7n/+z/ + 2f/l/s7/3v/F/9D+wf+5+8L/ofrD/5n8xf+X+8b/l/rF/577yf+j+83/pvvH/7D9uv+8/af/yPyb/8v7 + lv/K+ZL/yfiP/8v2jP/S94//2viS/+T6kv/c+ZX/rfKe/93i2sfSzcqovbexkqihmICakYh14N3bzhMS + EtoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAdAAAAJwAAADIAAAA+AAAAVAAA + AG4AAADJ1NPR4KulnIa2sauSzMfEqO/h3sFc19n2MdLU/zjS1P850tT/OtPT/znS0f850dH/OdLP/znR + zf860sz/O9LM/zrSyv870cr/PNHJ/z3Syf8+0cf/PtHG/0LRxv9D0cX/QdDD/0HSwf9B0sH/RNLA/0XR + wP9G0sD/RtO//0bUvv9J1L3/Sta+/0zVvf9O1rz/Tti7/07Xu/9P2bz/Udu7/1Ldu/9V3br/VuG7/1jj + u/9Z5rv/Wum8/1ztvP9e8b7/YvW+/2X5v/9p/MH/b/3G/3X+yf98/s3/h/7U/5X93f+g/eT/p/3p/639 + 6f+z/ev/t/7s/7j+7v+z/e3/s/7r/7b+7v+9/vT/y/73/9z+/P/w////+//8//r/+//2/vf/7/7x/+b+ + 6f/e/uL/2P7f/9L/3f/P/tb/y/7N/8n/x/+//sD/r/26/6n9tv+j+7H/gfmx/2z4sv9o97P/aPi2/2j4 + tv9v+Lj/ffq//376wP97+8P/hfvL/4j6yP+k+r7/w/iy/9j5qP/d+Z7/2/eV/9r1j//U9IT/z/B5/83t + cP++5G7/4uTazdTQzqzAu7SVqqOagpyTinbh3tzPExIS2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAAB0AAAAnAAAAMgAAAD4AAABUAAAAbgAAAMnU09HgrqafiLizrJPNycap8OLfwlPU + 2fYlzNT/Lc3T/y3O0/8tzdH/LczQ/yzN0P8uztD/Ls7P/y/Nz/8wzM7/MM7M/zHMyv8wzMr/MM3I/zPM + x/8zzcf/Nc3H/zfOxv84zsX/Oc/F/zvPxf860MP/O9DD/zvQw/880MH/PNLA/z/Tv/9A1MD/Q9XA/0bW + v/9G2MD/R9nA/0fbwf9J38H/S+LB/03mv/9N6sH/Uu3D/1jxxf9f9Mn/Z/fM/2z50P90+tb/gPzc/4v+ + 4/+R/ej/kv3s/5T98P+Y/fL/mv3x/5f+7/+S/+r/jf/i/47/3v+P/97/lf/f/6L+5P+x/un/wP7t/8z+ + 8f/U/u7/1v7o/9H+3v/I/tP/vv/N/7b/x/+x/8T/rv+//67/uf+h/7b/i/+0/4T+sv+B/rH/g/2u/3/8 + r/9w+bD/Zfex/2Hyr/9c8K7/WfGx/2bzuP9t9bv/bve7/3j6vv9++8H/fvq+/4H7wf+S+8j/kvvM/5j7 + 1f+b/dT/qP3E/7T4o/+864X/u990/7bZbf+z1mr/sNFl/6/LX//j5NnO19PQrsG8tZasppyDnpWNd+Lf + 3M4TEhLaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAyAAAAPgAA + AFQAAABuAAAAydTT0uGtp6CKubSulc7Lxqrw4t/DVtbd9ijQ1/8v0Nf/L9DW/y/Q1v8x0dX/MdLU/zLR + 1P8y0NT/MtDT/zLR0P8z0tD/NNHP/zXSz/83087/OdTO/zrUz/881c7/PNXN/z3Wzf881sz/P9fL/z/W + yv9A2Mv/QdnL/0Payf9F3cr/R97K/0jhyv9I5Mv/SOfK/0nry/9N7s7/UvDP/1n10v9h+tf/afzb/3H9 + 4/97/ej/hP/u/4v/8/+N//b/jf/3/47/+P+Q//j/jv73/4j/8f+F/uz/gf/l/3//4f+B/tv/hP/Z/4z/ + 3v+X/+T/pv/t/7f+8//F/fb/0P3z/8/+6v/I/t7/vv/V/7P/yv+m/77/mv+0/5T/rv+S/6j/kP6k/5H8 + oP+S+p7/lfed/5b0nP+U8pz/kPGc/43vnv+G7Z//gOyf/37qof9566T/de2o/3jxsf+A9bn/jvXC/5n3 + yf+c+cz/qfrQ/6H7zP+S/Mf/lPrK/4/6yf+J+sT/lPrB/5b5vP+X+Lr/mfe3/5vyp/+k5pD/rtV6/7LL + b/+xym//rshr/+Tk2s7X1NCuwby2lq6mnoWgl4944+HdzxMTEtoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1dPS4bCpoYq5s66VzsvHqvHk + 4MNW1dn3J87T/y/P1P8vztP/L8/S/zHP0v8x0ND/MdDQ/zLQ0P800dD/NdLP/zbUzv821M7/N9TO/znU + zv861c7/OtXN/zvWzP871sz/PNfN/z3Xzf9A2sz/QdzL/0Lezf9D38z/ReLL/0bmy/9I6M3/TuvS/1Tw + 1v9c9Nr/ZPfh/2r56P9z++3/e/vy/3z98/97/fX/fP30/3v98/96/fH/eP3t/3f96P90/eT/dP3e/3L+ + 2v9x/9b/c//R/3j+0P98/tH/gv/Z/4/+4f+d/uj/qP7r/7P96v+1/eT/sP7a/6j+z/+g/8b/l/+8/47/ + sv+K/6r/if2n/4j7pP+I96D/h/Sb/4jvl/+H7ZX/h+mR/4fnjv+F44z/huCJ/4jehf+J24P/kNuD/5je + h/+g5Iv/qOqO/6/wkv+39Zn/tveb/67zmP+q7Jv/seql/7brsv+x7bL/rfC2/6/0vv+w98L/qfe7/6P1 + sf+i9Kv/mvWi/5z0n/+e86L/m/Wn/5r0pv+c65X/nth+/6DEav+lu2P/4+Paz9jU0a/DvreYrqighaKa + kHnj4N3PExIS2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjU09LhsKqii7u1r5bOy8ir8ePhxFXU1vcnzdD/L87R/y/P0f8w0ND/M9DR/zPS + z/8z0tD/NNPQ/zPTzv810s3/NNPN/zbUzf821M3/ONbN/zrVzf87183/O9jM/zzZzP89283/P97M/0Lg + z/9G49D/TOfT/1Pr2P9a7t7/XvLk/2L16v9q+O//bvrx/2778f9r/PD/aPzt/2f96f9n/OT/Zvzg/2X9 + 3f9k/dj/ZP3V/2T90v9l/s7/af7K/2v+yP9s/sf/b/7I/3T+zP98/tH/h/7Y/5H+3v+a/+L/nf7d/5n/ + 0v+T/sX/iv66/4X9s/+D/K//gfqp/3/3pP9/86L/fvCe/4Dsmv+B6Zb/gOaS/4DikP+A343/gNyM/4Da + iv+A2Ij/gtiF/4bZhf+O3of/l+SK/57qjP+k747/qfKQ/6fxjP+i7ob/n+iD/53jgP+a3Hv/mth3/5nV + df+a0XL/mdBz/5rPcv+gznb/rNR+/7bdhP+85Yj/wO2M/77wkf+w8ZH/pu+Q/57ujv+c7o7/ou6Y/6Tx + m/+n8Jf/ouaI/5rOcP/i5NrO19TRr8S/uZmwqaKHopuSe+Ti3c8TEhLaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNTS0uKzrKOLu7awl9DM + yKvx4+DEVtXW9ynP0f8w0NL/MdHS/zHT0P8z0tD/M9LO/zPSzf8z0s7/MtTN/zTTzv811c//N9fP/znY + zv872s7/PNvR/z7d0/9C4dX/SeXZ/1Dp3f9V7uP/V/Hn/1316/9h9+//Yfru/1/66/9c+ej/Wvrj/1n5 + 3f9Y+dj/VvjV/1f50f9X+M7/WvjL/1v3yf9c9sb/XfXD/171wv9g9sH/Y/nB/2b8wf9r/sT/cP/H/3r/ + zv+C/9f/if7Y/4z+1f+L/Mz/gvu9/3z5sv9396z/dPWm/3Pxov9z7Z7/deqc/3jom/975Zj/fOGW/3re + k/9424//eteN/3jWif971ob/fNWG/37WhP+D2IT/i96J/5Pki/+Z6oz/n+6O/6Lvjf+e7Ir/l+aG/5Xg + gP+R23z/j9Z4/5DRd/+Qz3X/kMxz/5DKcf+Rx23/kcZq/5HDaP+TwWX/l8Bh/5m/Wv+bvlP/m71Q/52+ + U/+kwl3/q81q/7XZdP+6437/teh+/6voef+n6Xv/pumD/6zskv+y75v/r++a/+Tn38/X1NGwxL65mbCq + o4ilnpN85OLe0BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI1dPS4rOtpIy9ubGX0M3IrPHj4cVZ19j3KtHQ/zHSz/8v0s7/MNLN/zHT + zv8x083/NNTO/zbVz/8419H/O9rT/z7f1/9D5Nv/SOjg/03s5f9R7uj/UvLr/1T17f9W9+3/Vvbr/1H1 + 5/9Q9OH/TPPZ/0zx1f9L79D/S+7M/07syP9P7Mb/UerD/1Lqwv9T6cH/U+m//1Xovv9V57v/V+m6/1nr + uf9d77r/YvW//2j5xP9v/cr/d/7Q/33+0v+B/c7/gfrK/3v2v/9086//be6l/2rpoP9q5J3/a+Gb/2vf + mP9t3ZT/bduS/27Zkf9x15D/c9WP/3TTjf9304r/eNGI/3nSh/981Yb/gtiG/4veiP+S5Yv/lOqK/5fs + i/+Y7In/lOmG/47ggv+J13z/htJ4/4jOdf+IzHT/iclx/4rGb/+Kxm3/i8Nr/4vCav+NwGn/jL1o/427 + Zv+QumP/krpe/5e5Vv+cuVD/mrlO/5e6Tv+WuVL/k7ZV/5G1VP+Ss1P/lbRU/6C8XP+tyGT/t9Rp/7rc + a/+1327/suB5/7Lkjv+565//5efgz9jU0bDEv7qasquliKefln3j4d7QExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjV09LitK2mjL23 + spjRzcmt8uTixVbX1fcp0c3/M9PP/zTV0f8219P/OtrW/z3e2v9D4t7/R+bj/0rr6P9N7+z/UPPu/1H0 + 7v9Q9e3/TvHp/0vv4/9H7N3/Q+nV/0Hlz/9C5Mv/Q+HH/0bhxf9H38P/Sd7C/0ndwP9L3L//TNy+/03d + uv9O3bf/UNy3/1Hdtv9S37X/VeS2/1rruv9h8sH/Z/jH/2/7y/91/dD/dvvN/3f2xv9z8r3/be2w/2jo + pf9k4p//ZN2c/2Xamf9l2Jf/aNeU/2nVk/9p05D/adKN/2fQif9pzYb/acuF/23Nh/930Yj/fNWL/4Pa + jP+K4Y7/j+aN/5Dojf+S6Yv/keeI/4zhgv+G233/gdN6/3/Mdv+ByHP/gsZx/4PEb/+ExG7/hMJr/4PA + av+EvWj/hLxl/4a6Zf+Gt2P/h7di/4e1Yf+LtF//j7Ra/5W1Vf+Yt07/mLdI/5a3Sv+RtlD/j7ZT/5C2 + Vv+Ttlj/lbZY/5u2Wf+duFv/m7dZ/56zVv+jtVj/q7xa/7PFWf+4y1z/ts1i/7rUd//l5t7P2dXSscXA + vJuyraWJqKCWfeTi3tATEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNXU0uK0raiOvreymdLOyq7x5OLGX9/d9zff3f9B5OH/Q+fk/0Lq + 5v9E6+j/RO3p/0Xu6f9G7OX/ROjg/0Pm2/9B4tb/P+HR/z/fzv8+38z/QN3J/0Daxv9A2cT/QdjB/0TW + v/9F1Lz/RdS7/0fTu/9J1Lr/SdS2/0vVtf9L1bT/TNex/07asf9U4Lb/Wui9/2DxxP9m98v/bPnO/3D4 + zv9u9MX/bO68/2jns/9i4af/YNye/13Ymf9f05b/YNOX/2LRlv9k0ZP/Y9CP/2XPjf9kzIr/ZMmI/2PH + hf9myYT/a86G/3XUh/972ov/g+KO/4zokf+M6JD/jOeP/43ki/+I3oT/gtZ+/33PeP95yXP/esZw/3vE + b/98wm3/fcFs/3++af9/vWf/f7tl/3+5ZP+At2P/gLdh/4G1YP+Ds17/g7Jd/4SwXf+Hslv/jLJX/5Oy + T/+Vtkn/lrdH/5G4Sf+Nt07/irZT/4u2WP+SuFr/lrpc/5q8Xv+evF//oL1d/6G9Xf+jvlz/p7xa/6e7 + WP+muVX/qrlU/6y3Uv+ttUz/tbVI/+bk2dDa1tSyx8G9nLStp4unoJh/5OLf0RMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tTT47Sw + qI++ubSZ0c3KrvDi4MZj6eb3N+jk/z7o4P895d3/O+HY/zrd0/852c7/ONfL/znWyP871sj/PdfJ/z/Y + yv8+2Mr/QdnJ/0DXxf8/0r7/QdC7/0DQuv9B0bn/RNG4/0TQtv9E0bT/RtC0/0fRs/9J0rD/TNaw/1Dd + tv9Y5r//X+/H/2X0zP9p9c7/afHH/2Xrvv9h47P/Xtur/1zWov9b0p3/WtCZ/1zOlf9ezJT/YMyT/1/K + kf9hy5D/YcmN/1/Hif9fx4b/ZMiF/2nMh/9v1In/dNuL/33ijf+C55H/gOaO/4Hjif+C3oj/gdqG/3/V + gv9/0H//f8t6/3zIdf97xXL/esFu/3i/av95vmj/erxm/3q7ZP96uGP/fLdh/3y2X/9+tF7/frNd/3+y + Xf+BsFv/gbBa/4OwWv+GsFn/i7JU/5G0Tv+Vtkf/k7lF/4+8SP+JvFL/ibxZ/429YP+SwWT/mMRl/57F + Zv+ix2b/o8Zl/6LDYf+iwV3/o75a/6O9WP+kulb/pLhT/6S2UP+mtE7/qLRL/6mySv+ssUX/5eTa0NnX + 1LLGwr2dtq6ojKmimYDk4uDRExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjW1NPjtbCqj7+6tJrRzcqv8eTjx13c1Pcw1Mv/ONLK/zfR + x/840cf/N9HG/zjRxP850MX/OtLF/z3SxP88z8H/PM28/zzKuf89yrr/QM27/0HPvP9Bz7v/Qc65/0HO + tv9CzbP/Rc2w/0bPsP9J1LL/T926/1fmxP9d7cj/YvDM/2Lvyv9g6L//Xd+1/1rarP9X1ab/WNCi/1fN + nP9Xy5j/V8uX/1rJlf9cyJP/XceR/1/Gjv9exYz/YMSL/2LGiP9nzIr/bdON/3Tbjv954pH/feaS/3zm + jv944Iv/d9qG/3TTgP9xz3z/dM16/3bJef94yHr/fMd5/4HHd/+AxHT/fMJv/3q+a/94u2f/eLlj/3m3 + Yf96tWD/e7Rg/3y0Xv97s1z/fbJb/3+xWv+CsVn/g7FY/4OxV/+GsFf/i7NT/5C2Tv+Uu0n/k79K/43E + U/+Kxl7/i8Vn/5DGbP+Tx27/lshv/5jJbf+Zx2n/m8Rm/5vAZP+cv2D/nL9c/5+/WP+jv1b/psBW/6fD + U/+rw1L/rsJP/66/Tf+wvUn/r7tG/7C3Q//m5NnQ2tbVs8jEvp63saiMq6OagOTi4NETEhHaAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNbU + 0+O2sauQv7u0m9LOyq/y5uPHXdPM9y/Lw/81zcP/NszC/zbMwP80yr3/Nsi6/znEuP84xLb/Ose3/zzL + uv8/z7z/QM6+/0HQvv9Czrz/Qcu2/0HIsf9EyrD/RtCz/0nVuP9Q38D/VOjI/1rrzP9d68r/W+bD/1ff + t/9U163/VNKn/1TOpP9VyqD/VMme/1bInP9YyJn/VsaX/1fHk/9XxpH/WMaP/13Fjf9fx4z/Y8yN/2nT + kf9w25P/deGS/3rllf9545L/dN+L/3HYh/9w0oP/bs9//2/Le/9vyHf/bcZ0/3DDcv90w3L/dsNz/3rE + dP9/xXP/g8N0/4HCcP99vmr/e7tn/3q3Y/95tV//erVe/3u0Xf99tF3/f7Vb/3+1Wf+BtVj/g7ZZ/4e2 + WP+Lt1j/j7lW/5S9T/+Wwkz/lMhQ/4/NWv+Mz2r/itB1/4zNeP+Qy3X/k8p0/5XKcv+Xym//l8xp/5rM + Z/+ezmT/oM1i/6DKXv+hyFv/o8VX/6TBUv+kvU7/o7dL/6KxSf+iq0P/naQ+/5yeOv+cmTf/nJY2/+Th + 2dHc2dWzycS+nrexqo2rpZyB5OLg0hMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tTT47axq5HBvLWc0s/Lr/Lm5Mdbzsb3LcO4/zXD + uf84wrj/NsK2/zbEtv84xbn/Oca3/zjHt/88yLj/Pci3/z3Fs/8/w7D/QMax/0HMt/9H1b7/TNzD/1Dk + yf9U6c7/VujN/1blx/9T3r7/T9ax/07OqP9PyqP/UMqi/1HIof9Tx5//U8ed/1PFmf9TxJf/VsOV/1jD + k/9bxZT/X8iU/2LNk/9o1ZX/bNyV/3Hglv9z5Jf/dOSU/3LekP9v1or/btCH/23Og/9tzH7/bsp7/2/H + ef9ux3b/b8V0/2/Ecf9vwW//cMBt/3XAbv93wW//fcNx/4TDb/+Gw2//hMFr/4G+Z/9/vWT/fbpg/326 + Xf9+vF7/grtc/4a8XP+Jv1z/i8Fc/4/CWv+SxFr/l8VY/5nJVv+ZzlP/ldNW/4/VZf+J13T/idd//4vW + gf+P1n7/k9V7/5LSdf+TzXD/kshq/5HCZv+PvmD/j7la/4+0Vf+Nq0//i6JK/4qcRv+KmEH/i5Q9/4uS + O/+MkTj/jpA3/5OPNf+UjzT/lZAz/5ePMv+YjjD/5OLZ0dzZ1bTJxL6euLOrjqylnYLk4uDTExIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjW1NPjtrGrksC8tp3T0Muw8+flx1vJwfcwv7T/N8K2/zXDtv82wrX/NsOz/zjBsv84wK//Ob+t/zu/ + rv8+xbT/Q9K+/0fZxP9M4cv/UOfS/1Hq0f9R5sz/UN/E/07Yuv9M0LD/SMmm/0jHo/9LxqL/TsWf/07F + nv9QxJz/UcGa/1HBmP9Vw5j/V8eY/1zMmf9h0Jv/aNef/27dn/9v4J7/ceOb/3LimP9v3pX/bdiP/2zT + iv9s0If/bM2C/23LgP9uyn7/b8l7/23Jev9vyHf/ccV0/3HFcv9xxG//csJt/3HAav9zv2n/eMFq/33E + bf+FxnH/jclx/47Lb/+Mymz/i8to/4nLZP+JzGL/is1h/4zNYv+R0GP/lNJi/5jRYP+b0GD/nNFc/5nV + W/+U2F7/jttk/4rabv+F1Xr/g9CC/4TLgP+GxHf/iL9t/4e4Zv+FsGD/gqdY/36hUP9+mkv/fpVH/32R + RP98j0D/f409/4GMPP+EjTn/h4w3/4iNNf+LjDX/jYwz/4+MMP+PjC7/kYot/5OLLf+UiSz/loks/5iJ + Kv/k4tnS3NrWtcnFv5+3squPr6ifgubj4tITEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNXU0+S3sayTwbu3nNPQzLDy5+XIXce/9zC9 + sP83v7H/N7+u/za9rv83vq7/OcGw/z3Jt/9C0b7/R9jE/0vgy/9P5M//TeLN/07hyP9O28P/S9S6/0jM + rv9Hx6X/SMek/0jGpf9JxqP/SsWg/0vDnP9OwZr/TsOb/1PHmv9YzZ7/XNKi/2TapP9q3qf/a+Gk/23i + o/9v4qD/cN+b/27alv9r15H/atKL/2nQif9rzof/bc6F/3DOgf9wzn//csx9/3LMef9yy3f/csp2/3PJ + cv9zxnH/dcdu/3THbP93yGv/e8tr/4DPa/+J023/kthx/5rcd/+h4Xz/oeF6/57gdP+a3m//ltxq/5PZ + Zv+U1WL/ltJe/5fQW/+Ry13/islf/4XLX/+Az17/fM5g/33HZP9/v2j/fbVs/32uZ/99qF7/f6NU/36d + Tv98mUj/e5VD/3qRP/97jjv/e445/3uMNv99jTP/f4wz/3+KMv+EiTD/hYgu/4WILf+Hhiv/iIYr/4uF + Kv+LhCr/jIQq/42EJ/+OhCf/j4Qn/5KEJ/+UhSf/lYUl/+Th2dLd2de1ysTAoLm0rI+wqaGE5uXi0hMS + EdkAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI1dXT5LmzrZLBvLed1NHMsfLn5chcyLz3L7ys/ze/rv85xLL/Psu6/0LRwP9F1sX/SdvI/0nd + yf9J28P/SNe+/0rUu/9IzbT/Rser/0fGp/9IyKn/Ssqs/0rKqv9KyKb/Scah/0vDnf9Ox57/U82h/1fU + pf9e2qr/ZOCr/2Tiqv9o4qj/auKm/2zgo/9t3p3/bdyZ/27Ylf9w1pP/cNeP/2/UjP9w1Ir/cNOI/3PT + hv9y04T/ctN//3TRfP930Hr/eNB2/3nRdv9+1Xb/gtl3/4bedv+J4Xb/jOV3/5Dpd/+R6Xf/j+V0/5Tj + dP+a4XT/nd92/5/ddv+c13D/lc5l/43EWv+IvVP/hLZP/4C0Uv93tV//brlk/2m8Yv9svlz/dLtS/3q2 + Tf9/rkv/gaZK/3+hSf99nET/fJk//3yVO/97kzf/eZAz/3qPM/96jDD/fIou/3yILP97hyz/e4cr/3yF + Kv9+hSn/f4Mp/4GCJ/+Cgib/goEm/4SAJf+GgCb/h4Al/4h/Jf+JgCX/i38k/4yBJf+NgCX/kYEl/5OB + JP+SgSP/5eLZ0t3Z1rbLxcGhu7Suj7GrooTm5eLSExIR2QAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjV1dPkurStksO9t57U0cyx8ublyV/Q + wvc3zLv/Q9PB/0bWxv9H2cf/RdfC/0LRu/9Bzrb/Qsux/0TGrP9Ew6f/Q8Om/0fHq/9Ky67/S82y/0zM + sP9Nyab/T8mj/1POp/9X1az/Wtyw/17isf9h47D/Y+Os/2Xiqv9m4qf/aOGk/2vgof9q3p7/bd2c/3Hb + mf9z3Jf/dduV/3fbk/933Y//dd2N/3bdiv953Yn/fd6E/4Ddhf+C4Yb/h+WG/4rphv+O7Yb/ke2G/4/t + g/+O6X//jOJ5/4fbcv+D1W3/gc1n/37FX/98vVv/g7tZ/4e8Wf+Lu1j/jbpY/4m3Wf+Aslv/da9j/2mu + a/9fsHL/WrZ0/1+5af9tuFP/f7NC/4WvPf+GqDr/hKE4/3+ZN/97lDX/d5Ey/3aOLv92iy3/doos/3eJ + LP94iCv/eIcq/3mGKv95hSn/eIMn/3mCJ/95gSb/eYAl/3x/Jf99fSX/fHwj/358I/9/eyL/gXsi/4J7 + Iv+DeyL/g3wj/4Z7I/+IfSP/i30j/419JP+NfST/j34j/5B9Iv/k4dnT3NrYtszHwqG9t6+Qsqujhebk + 4tMTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNbV0+S6tK2Sw764ntTRzbLx5uPJatvP90DWxP9D077/Qcu2/z/Isf9Axq3/QMKq/0HA + qP9Cwaj/Q8Wq/0fIrf9Ky6//S82v/07Nq/9S0qr/V9ix/1zguP9h57z/Yuu8/2Hqt/9g6LP/Y+ev/2Pm + q/9j5ar/ZuWm/2rjpP9t5KD/cOOf/3TkoP945p3/fOab/4DonP+D6pv/huya/4fvmP+J8Jj/je+Y/4/t + lv+N6JH/i+OM/4nghv+F2oL/gdR8/3zLc/94w2n/crli/3KzXP9yrlj/catU/3CpUP9wp0//b6dN/3Kp + UP93rFf/eK9j/3iycv90t3//Z7eI/1+2iP9atn//W7Vt/2WxV/90sEP/gas1/4WnM/+DoDL/fpky/3iT + MP90jS//cIou/3GHLf9xhyr/c4Yq/3OGKf91hin/d4Uo/3eDKP93gif/eIEm/3Z/Jf92fiT/dn0j/3h8 + I/96eyP/e3oi/3x6Iv97eSH/fnkh/394If+AeiH/gXoh/4N5If+EeiL/hHoi/4Z7I/+HfCP/iX0j/418 + I/+PfST/kH0i/+Th2dPd2ti2zMjDob23sJGyqqOF5uTi0xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tXT5Lu0rpPDv7mf1dLOsvPm + 5clj0L/3OMWu/0DErf8/xKz/QMOq/0HEqv9Dxqv/RMes/0bMrP9K0a3/UNSu/1TZsf9a4bn/YOq//2Tw + xP9l8sX/ZPHB/2Tvu/9j77j/ZO+0/2Tvs/9n7rD/au2r/2ztqv9y76n/d++p/3zyqP+A86f/hfSm/4ny + pf+N8aL/j+6i/47nnf+K4pf/hduR/4LTiP99zIL/eMV4/3K7cP9ttGj/arBh/2qtXP9rq1v/a6lX/2up + Vf9uqFP/bqZU/2ylU/9so1T/aaJY/2WgXf9joWL/YqVv/2GrfP9isIb/Y7iK/2m7hP9rt3H/brRb/3Kv + Rf92qjb/eqQx/32fMP97mS7/dpIt/3KMLf9uiCz/bIUr/2yEK/9tgyr/b4Mp/2+DJ/9xgib/coIm/3SC + Jf91gST/dYAk/3d/JP92fiP/d30j/3p7If95eiD/eXkg/3p5H/96eR//e3ge/3p3IP98eCD/f3cg/393 + IP+AeCD/gXkf/4J4IP+DeSH/hXkh/4Z5If+JeiL/inoh/417Iv+OeyH/5eHZ097c2bfNycOivbawkrOs + pIbm5OLTExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjW1dPkvLavlMO+uKDV0s2y8+fnyWTNvPg5xaz/Qciw/0TMsv9Hz7D/StOw/03Y + sv9Q3LT/VOG3/1rnv/9d7MT/YO7H/2TwyP9l8cb/aPDF/2vxw/9r8b7/bfK+/2/yu/9v8bb/c/K0/3by + sv969LD/fvKt/3zup/9966T/feei/3vgm/962ZP/edGO/3bKhv9zxIH/cLx6/225dP9ptW7/aLFp/2av + Zv9ormL/a61f/2usW/9qqln/aqhX/2mmVv9oo1b/ZaBZ/2SfWf9inWD/XZxi/12dZP9bn2j/V59q/1qj + a/9fqGz/Za1r/22wZv92tV3/fbZQ/3+xQv97qzn/d6Iy/3WZLv9zkCr/cIso/2+HKf9uhCn/bIQp/2qD + KP9qgij/bYIn/26AJv9vgCX/cYAk/3KAI/91gCP/d4Ei/3iAIv94fyH/en8f/3l9H/96fCD/enof/3l5 + H/94eB7/eXge/3h4Hv95eB7/e3cf/3t2Hv98dR7/fnYf/4B3IP+Adx//gXcf/4J4IP+EeCD/h3ch/4l3 + IP+JeCH/i3kh/416If/k4dnT3tvZt83Iw6O9uLGRs62khefl4tMTEhHZAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNXU0+W+uLGVxL+6n9TR + zrPx5ubKa9nA90XWtP9Q27r/VN+7/1bivP9Z5cH/XebG/1/ox/9j6cj/ZerL/2bqy/9q68n/a+rF/23q + wv9x68D/c+7A/3Lvvv9y7Lj/ceas/3Dlq/9v4qf/atqf/2fRlf9lyY3/YcWJ/2DAhf9gu4D/YLZ5/2Kz + df9ksnP/ZrFv/2exbf9psmv/abFo/2isZP9mqWD/Zqdd/2elXP9mo1r/ZaFa/2KfXf9hm2D/X5th/1ya + Yf9ammL/Wppj/1ubY/9am2H/W55f/12fXf9doFn/YqJT/2mlT/9yqUz/e65K/4GzRf+BsDz/e6Y0/3Wa + L/9wkCr/bYcn/2yCJf9qgSb/bIIn/22CJv9tgib/bYEm/22AJf9vgCT/bn4j/3F/I/90fyP/coAi/3aA + Iv95fyH/e38g/3t+H/96fh7/e3we/3t7IP95eR7/eXge/3h3Hf94dx3/eHYd/3l2H/96dR3/fHUe/3x1 + Hv99dR7/fnUe/392Hv+AdiD/gHYe/4J3H/+Fdx//hncg/4l3IP+LeCH/jHgg/+Xh2tTf29m4zcrEor+5 + s5KyraaH5eXj1BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI1tXT5b62sZXEv7uh1dHPtPDm5sp54sj3WODB/2PhyP9m5Mr/ZeTM/2bi + yv9l4sj/ZeLE/2Tiwv9i47v/ZOCz/2bgsv9m4LL/aN+w/2rfsf9n2qf/YtKf/1/Om/9by5n/WcOR/1a6 + hv9TtoL/UrN+/1Wve/9VrXf/WKx0/1mrc/9crG//YKts/2Ksa/9mrGn/aKtm/2ipZP9np2L/ZKNf/2Cg + Xf9fnV//X5xg/12bYv9cmmP/XJlj/1qYYv9amGL/WZld/1qYW/9cmVv/XJtY/16bVf9fnFH/YpxN/2Ob + R/9pnkP/cqVA/3qpP/99qzz/fqg3/3mgMP91lir/c40o/22IJf9qgiT/bIEk/2uAJf9sgCX/aoEk/2yA + I/9tgCP/boAj/25+I/9wfiH/cn4h/3N+If91gCD/eIAg/3qAH/98fh7/fH4e/3t9Hf96fB3/enkd/3l4 + Hf95eB3/eHcd/3d2HP94dhz/eXUd/3p0Hf97dB3/e3Qd/3x0Hf99dR3/fnYd/391Hv+Adh7/gnYe/4J2 + Hv+Edx//iHYf/4p4H/+Jdx7/5OHa1N/d2rjPysWjvrmzk7Gtpojm5ePUExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjW1dPlvLexlsTA + u6HV0s+08Obly33hz/hZ3cT/Xt3C/1zevf9b3rj/Wty2/1resv9Y3K3/Wdmo/1vWpv9b1KT/WNCk/1XG + m/9TvZD/U7uO/1K9kv9UvpP/UreJ/1Gygv9RsX//UbB9/1GreP9Sp3P/UqZw/1Smbv9WpGr/WKNn/1ui + Zv9epGP/YqVi/2OlY/9lpWT/ZaNl/2GgZ/9dnWb/Wppj/1qZYv9dml//XJpg/1yZXv9cmVr/W5dZ/1yY + Vv9cmFX/XJdT/12YUP9gmE3/ZJlI/2SZRf9lmkD/apw9/3CfOf90oDb/dp0y/3adLv96nS3/epgq/3iS + J/9ziyX/bYQj/2l/I/9pfiL/aX4j/2t/Iv9tfyL/bX8i/25/If9wgCD/cn4f/3J+Hv90fR7/dn4e/3p+ + Hv97gB7/fIAd/3yAHP98fhz/fH0d/3t8Hf96ehv/eXgc/3h3Hf93dhz/eHQc/3h0HP94dRz/eXUc/3ly + G/95cxz/e3Mc/310Hf98dBz/fnUe/351Hv+AdR3/g3Yd/4Z1Hv+Hdh//iXcf/4l1Hv/k4trU39zauM7K + xaS9uLOUtK+oiOfl49QSEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNbV1OW/ubOWxMC7odXTz7Tx5ufLdt/B+FHasv9Y2bL/V9eu/1jU + q/9WzaX/VMae/1C/lv9JupP/SLiR/0mxi/9KsIb/S7GG/020i/9PtYz/T66D/06sf/9OrX7/UK9//0+o + dv9Po2//T6Jt/1Cha/9Qn2b/Upxk/1SdY/9VnWH/WZxh/1mdZP9bn2b/XqBo/1+gav9goWb/YJ9k/12d + Yf9dml3/XJhb/12YWf9dmFj/XplW/16ZVP9dmVP/X5hQ/2CYTv9gl0v/YphG/2WYQv9omj//apo7/2ya + Nv9sljL/aZEu/2uSKv9zlSn/e5so/4CdJ/99lif/d5Am/3KIJP9rgCH/aX0h/2l8IP9pfSD/a34g/21/ + IP9ufx//b34f/3F+Hf9zfx3/c34c/3V+Hf92fhz/en8d/3yCHP9+ghv/fYAc/31+HP98fRz/fHsc/3p6 + HP95eBz/eXYc/3h1G/94dBv/eHQb/3hzG/95chv/eXIb/3lyG/96chv/e3Ib/3xyG/9+cxz/f3Md/4B0 + Hf+DdB3/hXQd/4V0Hf+HdR//iHUe/+Ti2tTf3Nq5zsrFpMC6s5S0sKiJ5uXj1RMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tXU5b65 + s5bEwryg1dPPtPLo6Mty0LT4S8Kg/029nP9JuZf/R7aT/0WxkP9ErYv/RauI/0Wog/9GqoH/RamB/0ir + g/9IqH//SKZ7/0qlef9Kp3z/Tap9/02kdf9NoHH/TKFt/02ia/9PnGX/UJlh/0+aYf9PlmP/UJZl/1CX + ZP9TmGX/V5tm/1udZf9dn2T/YKBj/2KhYf9joF3/YZ1a/2CYWP9emVb/YJlV/2GZVP9gmVL/YJhP/2CY + TP9il0j/ZJdF/2SXQv9olz7/a5k7/2yZN/9pkzD/ZYsr/2SGJv9niSb/cJAm/3mVJP+AmyT/f5kl/3qT + I/91jCP/b4Qg/2p8H/9pex3/aHse/2p8Hv9sfR7/bn0c/29+HP9yfR3/c38b/3V/G/90fhz/dX4c/3d/ + G/99gBz/foIc/3+CGv9+ghr/fn8b/319G/98exv/enka/3l3Gf95dhv/eHQb/3dzGv93cxr/d3Ea/3ly + G/95chv/eXIb/3pyG/97chv/fHIb/31zG/9/chz/f3Ic/4JzHf+Ecxz/hXQd/4d1Hv+HdB3/5OLZ1d7c + 2rnPysWkv7u0lbOwqInm5ePVExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjW1dTlvbi0l8XCvaLW09C18urqy2S7ovg7rYv/RLCO/0Ov + jP9DrIn/RKiF/0Slgv9EpH7/QqB7/0Khef9DoHb/RKB1/0addP9In3T/SaF0/0mgc/9Lnmz/TZ9s/02h + bP9MnWj/S5hl/02YZ/9LlmT/SpNj/02TZf9NlGT/UZZh/1WYYf9aml//Xp1f/2CgXv9joV3/ZaJd/2Wg + Wv9jnFf/YZpU/2CZUf9imlH/ZZtP/2SYTP9kl0f/ZpZE/2aWQP9plz7/apg7/22XN/9pkTD/ZIoq/2CE + Jv9igyT/Z4Uk/26KI/91jyP/fJUk/3+YJf99liT/eY8h/3SJIP9tgh3/aXod/2h6HP9pexz/bHoc/258 + HP9vfRn/cH0Z/3J+HP91gRz/dYAa/3WAGf94fhr/fIAc/3+CGv+Agxv/f4Ma/3+CGf9/fxn/fn4a/318 + Gv97eRn/eXcZ/3l2Gf94dBv/d3Ma/3dzGf93cRr/eXEb/3lyG/96cBn/enAZ/3twGf98chv/e3Ea/39y + HP9/chz/gnEb/4RzHP+Dchv/hXMc/4VyG//l4tnV4N3buc7Lx6a/vbaWta+piufl49UTEhHZAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNbW + 1OW+uLSXxcK+otbTz7Xz6+vLZred+DumhP9CqYf/Q6eE/0Gkgf9BoX3/Qp94/0CbdP9BmXP/Q5pw/0OZ + bP9EmW3/RJpt/0ecbf9ImWj/Spto/0ufbP9LnWr/Spdo/0ubaf9KmGn/SpNm/0uVY/9MlGL/T5Nf/1GU + Xf9Tllz/WJhc/1ybXP9gnlr/Y6Ba/2aiWf9po1j/aKFW/2adUv9lmk//ZZlM/2eaS/9pm0n/Z5lE/2mY + QP9qlz//bJg8/2yYOP9nkDL/ZIgr/2GDJ/9ggiP/Y4Mj/2aCI/9shCL/dIki/3mOIf99kyL/f5Yj/3yT + If94jSD/c4ce/2x/G/9peRv/ankb/2t5Gf9sehr/bnwa/3B9GP9wfhj/c4Aa/3WDGv92ghr/d4EY/3qA + GP99ghr/gIQa/4GEGf+Bgxr/gYIZ/4CBGf9/gBj/fnwY/3x5Gf97eBr/encZ/3h1Gv95dBn/eHMY/3hx + Gf93cBn/eHEa/3lwGf95cBn/eXAZ/3pwGf98cRv/fXAa/31wGv+AcRv/gnEa/4NyG/+Fcxz/hXIb/+Xi + 2tXg3du6zszHpr+8tpa2r6mK5+Xj1hISEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tbV5b+8tZfGwr2j19TRtvTs7MxksZX4OZ56/0Gi + f/9Aon3/QZ94/0Kcdf9CmnL/QJhw/0GTa/9Bkmf/Q5Vn/0OYaf9ElGX/RpRl/0aZaP9ImWv/R5Vn/0mZ + af9KnGv/SZdk/0uXY/9Nl2L/TZNf/06TXP9QlFv/U5NZ/1WWWf9amVj/X5tX/2OeV/9moVb/aaNX/22k + U/9solL/ap5N/2maSf9pmkf/a5pE/22ZQv9tmT//bpk8/26YOP9qkjP/Y4gs/2CEKP9igiX/ZIIj/2WC + Iv9ngSH/an8g/3CEH/93iB7/eo0e/36SIf9/lCH/fI8g/3eJH/9yhBz/bXsa/2p4Gf9reRj/a3oY/257 + Gf9vfRn/cH4W/3KAFv91ghj/d4QZ/3aDGf94gBf/fIEX/32DGP+AhRj/goYY/4SEGf+Dgxn/goIY/4GA + GP9/fRf/fXoY/3x4Gf97dxn/eXQZ/3l0Gf94chn/d3EY/3ZwF/93cRj/eXEY/3lwGf95bxj/eW8Y/3tw + Gf99cBr/fXAa/4BwGv+CcRv/g3Ia/4RxGv+EcRn/5eLZ1eDd3LvQzMemwr23lrexq4vn5ePWEhIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjW1tXlwLy1mMbEvqPX1NG29OzszGSukPg4mnT/P5x3/0Gedv9CnXT/Qppx/0GVa/9Ckmf/Q5Jn/0KT + Z/9CkGT/RI9j/0SSaP9FlWr/RZFl/0iTaP9Mm2r/TJdl/0uVY/9OmWP/TZZf/06TXP9QlFz/T5NZ/1CS + V/9Vk1b/WJZV/1yYVP9gmlX/ZZ9T/2qhUv9to1L/b6RP/2+hSv9tnkb/a5pD/2yaQf9vmj//cZo8/3KZ + Ov9ukzT/ZYst/2OFJ/9jgyX/ZYIl/2SAI/9mgCH/aIAf/2mAHf9vfhz/coIc/3aIHf97jR//fpIe/3+R + H/97ix7/eIgd/3GCGv9sexn/a3kY/2t6GP9texn/b3sZ/3B9F/9xfxb/c4EX/3eEGP96gxn/eYEY/3qA + F/99ghf/f4QX/4KFF/+Ehhj/hIQX/4ODGP+Cghj/gYAY/399F/99ehf/e3gY/3p2F/95dBf/eHMY/3dy + GP93chf/d3AX/3hwF/95cBn/eG8Y/3hvGP95bxj/enAZ/3xvGf98bxn/fHAZ/39xGf+CcBn/hHEa/4Rx + Gf/l4tnW4N3cu9HMx6bDvbiXuLOsi+fl49YSEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNfW1eXAvLWYx8O+o9fU0bb07O3MY6qL+DiW + bf9BnHT/Qpxz/0Gab/9Cl2v/Q5Rp/0KTZv9DjmT/QYxj/0GOZv9DkWb/RY9j/0WQYv9HlWX/SZVk/0mS + X/9NmGL/Tphh/02UW/9Oll3/UJRb/1GRVv9Sk1f/U5JU/1eSU/9ZlVH/XJhQ/2KbUP9nnk7/baFO/3Kj + Tf90o0n/dKFF/3CdQv9umj7/cJo8/3ScO/9xmTb/a48v/2WIKf9lhSf/ZoQl/2aDIv9ngiD/aIAe/2l/ + Hf9rfhz/bH4b/29+G/9ygxv/dogc/3uMHf99kBz/fpAd/3qKHP93hxv/cIEY/2t7Gf9rehj/bHoY/258 + F/9wfhX/cH4U/3J/Ff91gRf/eoUY/3yEGP97ghj/fIEX/36DF/+BhRf/hIYY/4SGGP+Fhhj/hIQY/4OB + F/+CgBj/gH0X/356Fv98eBj/eXUX/3l0F/94cxj/d3IX/3ZxF/93cBf/eHAX/3dvF/94bxj/eG8Y/3hu + GP95bxj/e24Y/3xvGf98bxn/f3AZ/4FvGf+EcRr/g3AZ/+Xh2dbg3ty70c3JpsS/uJe5tKyL5+Xj1hIS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI19bV5cC8tpnHw76j19TRtvTs7cxiqon4OJZo/0Cabf9Cm23/Qplt/0GWav9BkWf/Qo1j/0CN + Y/9CjWH/Q41f/0OLX/9Gj2D/SJFf/0eOXv9JkV3/S5de/0uSWv9PlFv/TpZc/1CSVv9Sk1b/VJNU/1WQ + Uv9XklH/WJJP/1uVT/9gmEv/ZZxJ/2ygSf9xo0j/d6RF/3qkQv94okH/dp89/3OZOf9ylzb/bpQy/2mN + LP9piij/aIgn/2iEJP9ogyL/aIIf/2qAHf9rfxz/bH8b/21+Gv9tfBn/b34Z/3OBGP92hxr/eYob/32Q + HP99jxr/eosa/3eIGv9wgBj/bHsY/2x6F/9ufBf/b30X/3B+Ff9xfxX/dIEU/3mDFv98hRf/fYQX/3uC + Fv98ghX/foQW/4KGFf+GiBb/hocX/4aGF/+GhRb/hIEY/4OAF/+BfhX/f3oV/3x3F/97dhb/eXQW/3lz + F/93chb/d3EW/3hwF/94cBf/d28W/3huFv94bhb/d20W/3luF/97bhj/fG8Y/35uGP+Abxj/gG8Z/4Jw + Gf+Cbxf/5eLZ1uHe3LvRzsmmxL+4l7myrIzn5eTWEhIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjX1tXlv723msjEv6XY1dK39e3tzWOo + hPg5lGX/QZlr/0KZbf9Dl2z/QpNp/0KQZf9CjGH/Qoxd/0SLXP9Filz/Rotd/0eLW/9Hi1n/SZBb/0qP + WP9NkFb/UJRZ/0+TVv9RkVb/U5VW/1KSUf9Uk1D/VpBN/1eSTP9Zk0z/X5ZJ/2SaRv9snUX/cqBF/3ak + Qf97pj//faY9/32kPP95njf/cJQx/2uOLP9qjCn/bYwn/22LJP9rhyD/bIMg/2yBHv9sgB3/bX8c/25+ + Gv9ufRn/b3wX/257Fv9vfRf/c4IZ/3eGGf96ihv/fpAb/32PG/96jBn/d4gY/3B/F/9texb/bnsU/29+ + FP9xfxX/cX8U/3KBFP93ghT/fIQV/36HF/9+hBX/fYIV/32CFf9/hhX/g4YV/4eIFf+Hhxb/h4YV/4aF + Fv+Eghf/gn8V/4F+FP9+exP/fXcV/3x2Ff96dBX/enMW/3hxFP94cRX/d28W/3dvFv93bxb/d28W/3du + Fv93bRb/eW4V/3ptF/96bhb/fW8X/39uF/+Abxf/gHAZ/4JvF//l49rW4d/cvNLNyafDvriYuLKsjebl + 5NcSEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNfW1eXAvbeax8W/pdjV0rf07O7NZKeD+DiRZP9Clmr/RJlr/0OXaP9Dk2T/RJBg/0SN + Xv9EiVr/RIlY/0WKWf9Fh1f/R4pW/0mMVf9Ji1T/TI5U/0+RVP9QjlP/UpNS/1KSUf9Uk0//VZVN/1WS + S/9Ykkr/WpJH/16WRf9lmUP/bJ1B/3KfQf92oj7/e6U8/4GnPP+Epzn/fqE1/3KVL/9rjCj/a4wm/26M + Jf9xjSL/cIoi/26GIP9uhB3/boEc/25/G/9ufhn/cH8W/299Ff9uehb/bnoW/3B+F/9zgxj/eIkZ/3uO + Gf9/khr/fY8a/3qNGP93hxf/cH4V/258E/9vfRT/cH4U/3OAFf90gBX/dIEU/3mDE/99hxT/f4cW/36G + FP99hBT/f4MT/4KHFf+FiBb/iIkV/4iIFf+GhhX/hoQW/4WCFv+CgBT/gH0U/398E/99eBT/fHYW/3p0 + Ff95cxX/eXIV/3hxFf93bxb/d28V/3dvFv93bhX/d20V/3dtFf94bRX/eW0W/3ltFf99bhb/f20W/39t + Fv9/bhf/gW4W/+bi2tbh3ty80c3JqMO+uJm6tK6N5+bl1hISEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI1tXV5sG9t5rIxb+l19bSt/Tt + 7s1jo4H4O5Bi/0SWZ/9ElmX/RZVj/0WUYf9Djlz/RYpY/0SJV/9Eh1X/RYZS/0mJU/9JiFL/SohP/02N + Uf9NjE//To1O/1KQUP9Tj0z/VZNN/1STSf9Yk0n/WpRH/16WRv9hl0P/ZJpC/2qbQP9vnT3/dKA7/3uj + Of+Bpzj/hKg3/3+jMv94mS7/cJAo/2yKJP9uiiP/cowi/3ONIP9zih7/cYYe/3CFGf9ygxj/cYEX/3B/ + Ff9vfhT/bn0U/256Fv9uexT/cX8W/3WFF/95ixf/fpAY/4GTGP9+jxf/fo8X/3mIFv9wfRT/b30T/3F+ + Ff9yfhb/dIAV/3iCFP95ghX/fIYU/4GKFf+AiBX/foQT/32DEv9/hRP/hYgV/4mKFv+HiBX/h4gU/4eH + FP+GgxX/hIEV/4OAE/+BfRP/f3wU/316Ev98eBT/enQT/3lzFP95cxT/eXMU/3hxFP94bxX/eG8V/3dt + Ff93bRX/d20V/3htFf95bRX/eW0V/3xtFf9+bRb/fm0W/39uF/+AbRX/5uLa1uHe3LzQzcmoxL+6mb21 + r43o5+XWEhIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjX1dXmw723msjFv6XY1dK39OzvzWWkfvg7jlv/RJRi/0eXY/9JlmD/RZBc/0aN + Wf9GjFb/Q4ZQ/0SEUP9IiE//SYVN/0mGTv9LiEz/TIdJ/0+MS/9PjUr/Uo1K/1WPSv9WkEf/WpZF/16X + Rf9hm0P/ZJtC/2aaQP9omz7/bZs7/3OeOf96ojf/g6Y2/4GmMv99oiz/epsp/3mVKP9yjyT/bYki/3KK + If92jB7/dYse/3WJHP91hxn/coQZ/3OCF/9ygRX/b34U/3B+FP9vfRT/bnsV/257E/9xfxX/doUW/3qL + Fv+AkRf/gJMY/36PFv+CkBj/eIcV/3B+FP9wfxX/cn8T/3OAE/93gRP/eYIU/3yEE/+AiRT/gYsU/4GJ + E/9+hBP/fYMS/4CGE/+GiRT/iIkT/4mKFP+HiBT/h4cV/4aEFP+EgRP/g4AT/4F9E/9+ehL/fHoR/3t3 + Ev96dBP/enMU/3lzFP95chP/eHAU/3hvFP93bhT/d20V/3dtFf93bBX/eG0V/3ltFf95bBX/em0V/3xs + Ff9+bRb/f24X/4BtFf/m4trX4d7dvdHOyajFv7qZvLWvjejn5dYSEhHZAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNbW1ebDvbeaycXApdfW + 0bf07u/NZqJ6+DyOWP9Gll//RpVc/0iVWv9Hklr/RYxX/0WIUP9Ghk7/R4RL/0qCS/9Lhkr/SoVK/0yG + R/9OiUf/T4hG/1CKR/9TjEP/V5FD/12XRP9jnEP/Zp5B/2aeQP9mnD3/aZo6/22aOf9znzj/e6Y1/36m + Mv98oS//eJsq/3qaJf98mST/epUm/3OOIv9xiR7/dYod/3iMGv96jBr/eYoZ/3eHGf91hBj/dIMW/3KB + FP9wfxP/cH0U/298E/9ufBP/bnwT/3OCE/94iBT/fI0V/4KTFv+Bkhb/gpEV/4aUFv95hxX/cIAU/3KB + E/90gRP/d4IS/3mCEv95gxL/fIUS/4KKEv+EjBP/gooR/3+GEv9/hBH/gocS/4iKE/+JixL/iYoS/4iI + Ev+HhhP/hoUT/4SCEv+DgBP/gX0Q/396EP99ehD/fHcS/3t0E/97dRH/e3MT/3pyFP95cRT/eHAT/3dv + E/93bhT/d24U/3dsFP94bBT/eW0V/3htFP95bRX/em0V/31sFf99bRb/gG0V/+bi2tfi3929087KqMTA + upm7ta6N6efl1hISEdkAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI1tbV5sK+uJvJxcCl19bRt/Pu781mo3j4PIxU/0aTWP9Jlln/SJVY/0aR + Vf9GjVL/R4hO/0iDSf9Igkf/S4RI/0uDRv9NhEX/TIVF/06EQ/9QiEL/U4xA/1yTQf9gmkD/ZZ9A/2if + Pv9lnjz/ZZs7/2mYOf9umzj/dqQ2/3mpMf93oy3/dZkq/3WVJ/96mST/fpoi/36aJP98lCP/dYwd/3SJ + G/93ihr/eo0Z/3uNGf96ixj/eYgY/3aEFf90hBX/coIU/3F/FP9wfhP/bn0T/298Ev9wfhP/dYYS/3uL + FP9/jxT/hpQV/4aTFP+FlBX/iJUW/3eGE/91gRH/dYMS/3iEEf96hBH/e4US/3yFEf9/iBH/hIwT/4aN + FP+DihH/gIYR/4GFEP+GhxD/iYsR/4mLEf+JihL/iIkQ/4aHEf+FhRL/hIIS/4OBEf+Bfg//f3sR/315 + Ef98dxH/e3YQ/3t2EP96dRL/e3QT/3lxFP95cBP/eHAS/3duE/93bhT/eW4T/3htE/94bRP/eG0U/3ts + E/99axX/fWwV/31tFv+AbhT/5uLb1+Lf3b3TzsqpxMC6mbu2sI7p5+XWEhIR2QAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjX1tXmw764m8jF + v6bY1tK49O7wzmiidPg/i0//R5JV/0iUVP9KlFT/SZBR/0qMTf9Kh0r/SYRG/0mCRP9KgUP/TYNC/0yC + QP9Og0D/UIc//1qOPv9gmD7/ZJw+/2efPP9mnTv/Zps4/2aZOP9qmTj/c6E1/3itNf93qS//b5kp/26Q + Jv90kCP/eZUi/3+aIP+AmSL/gJkg/36TIP93ixv/dYob/3qMGP98jBn/fY0Z/36MGP98hxb/eIUV/3aE + E/9zgRX/c4EU/3J/Ev9wfhH/cX4R/3OAEv95hhL/gIwT/4STFf+Jlxb/hpQW/4qXFf+KlhX/eYUS/3iC + Ef95hBD/e4YS/32GEv99hxL/f4cS/4KLEP+HjxL/ho4S/4OKEf+Ahw//gYcO/4aKD/+JixD/iYsQ/4mL + EP+HiBD/h4UR/4aEEf+DghD/gX8P/4B9Dv9+ehH/fXgR/3x2EP97dxH/e3YQ/3x0Ev99cxP/e3IS/3tx + Ev96bxP/eW4S/3luEv95bhT/eG0T/3htE/94bRP/e20T/31sE/98bRP/fm4V/4BuE//m4tvX4d/dvdLO + y6rFwLuavLawjunn5dYSEhHZAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNfW1ebCvribx8XAptjW0rn07e/OaKBw+ECJS/9JkVH/SpNR/0yU + Uf9NkE//S4xJ/0yHRv9MgkP/S4FA/0uAP/9LgT7/ToQ9/1WKPP9clTz/Yps8/2aePf9mmzr/Zpk4/2OY + Nf9mmDX/bZw1/3erNf94tDL/b58s/2yMJ/9siCX/cI0i/3eTIP99lyD/gJkf/4ObHv+BmB3/f5Me/3mM + Gv94iRj/eYsY/3+NF/+Cjhj/gYsX/3+IFf97hRT/doQT/3SCFP90gRP/cn8R/3J/Ef9yfxH/doIT/32I + E/+CjhP/iJUU/4uYFf+IlRT/j5wU/4qVFP98hRL/e4US/3yFEf9+hxL/focS/3+HEf+AiRD/hI4R/4qQ + E/+HjhL/gooP/4KHDv+DiA//h4sP/4mLD/+Jiw//iIsQ/4iIEP+IhRD/hYMR/4OBEP+CgBD/gH0P/356 + D/98eBD/fHcP/352EP9+dxD/fXUP/310EP98cxD/e3IS/3twE/96bxP/eW4S/3htEv94bRL/eG0T/3ht + E/96bRP/fGwT/3xsE/9+bhX/gG4T/+bi29fh392+0s7LqsXAu5q9tq+O6efl1hISEdkAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI19bV5sK/ + uZzGxb+m19XSufTt785soHD4QopJ/0iQTP9LlE7/TJVO/02QTP9MjUf/TYdD/02DQv9MgD//ToA8/1OG + PP9ZkDr/YJk5/2WeOf9knTn/Ypg4/2OUNv9llDL/aZky/3OmMv95uTP/c7Av/2mRKP9mgiX/a4Uj/3GL + If91kCD/fJQe/3+YH/+CmR//hZwc/4SaHP+DlB3/fIsZ/3qIGP99ixf/g44V/4SPFv+CjBX/f4gU/3uG + Ev95hBP/d4IS/3Z/Ef90fxD/c4AR/3aCEf96hhL/gIsT/4WSFP+LlxX/jJoT/4qXEv+TnxX/iJMT/32H + Ef99hxL/fokR/4CKEP+Aig//gIgR/4OMEP+JkBL/ipES/4eNEf+EiQ7/g4cM/4aJDv+Kiw//iowQ/4mL + D/+Jig7/iYgO/4eFEP+GgxH/hIAP/4N/D/+BfRD/f3oP/314D/9+eA//fncP/353EP9+dxD/fXYP/3x0 + Ef97chL/e3IR/3pwEv96cBL/eW4Q/3ttEP97bRL/e20S/3ttEv98bBP/fWwT/39uFP+AbxL/5ePb1+Lf + 3b7TzsuqxcC7mry2r4/p5+XWEhIR2QAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjX1tXmw764m8jFwKbW1dK58+3wzmudbPhDiEP/S5BL/0qU + S/9LlEr/T5JI/06LRP9OhkH/TIM9/1CDPP9YjDv/YJc6/2SdOf9lnTj/ZJg3/2OUNP9hkDL/Y5Ix/2ye + L/92tTL/eb8w/2yiK/9kgiT/ZoAi/2eFIv9tiCD/c40f/3eRH/99lB7/gpgd/4eaHP+Imxr/hpkc/4SU + Hv97ixn/eogX/4CLFv+DjxX/hI8V/4KMFP9/iBP/e4YT/3qEEv94gRH/d4AQ/3aBD/90gRD/eIMR/3yI + Ef+CjRP/iZQU/42aEv+NmxP/jJkS/5WgFf+GkRL/fogR/3+HEf9/iQ//gIsP/4GLD/+BiQ//hY0Q/4uT + Ef+MlBH/h40R/4WJD/+EiA3/iIoO/4uLDv+LjA//iYoO/4mJDf+Ihw3/hoUO/4WDD/+EgA//g34O/4F8 + Dv+Aeg3/fngO/354Dv9+eA7/f3YP/393EP9+dg//fXQQ/31zEf98cxD/fHER/3twEv97bxL/fG0R/3xt + Ef98bRH/fG0S/3xsEv99bRT/gG8T/4FwEv/l49vX4t/dvtPOyqrFwLubvLawkOnn5dYSEhHZAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNfW + 1ebDv7mcyMbBptjW07nz7fDOa55o+ESHQP9Lj0f/TZRH/06VRv9QkEP/UIs//1GIPv9Uizv/XZM7/2ac + Of9mnzj/Y5w2/1+TNf9ejjH/X44v/2eSL/9xqzD/eMMy/3G6Lv9kjib/Ynsg/2R/If9mgyH/aYce/3CK + Hv92jR7/eZEe/4CVHf+DmRr/h5kZ/4ebGf+KmRv/iJUf/36LF/99iBX/gYsV/4SNFP+FjhX/gosU/3+J + E/97hhL/eYMR/3iDEP93gg//d4EP/3eCD/95hBH/fokR/4WQEf+LlhL/kJwR/4+bEv+RnBL/lqEU/4SO + EP9/ig//gIoO/4GMDv+DjBD/g4sP/4OKD/+HjxD/jJQQ/4uTEf+GjRH/hIkO/4aJDP+IjA3/i40N/4yN + Dv+Kiw3/iYkN/4iHDf+HhQ3/hYQM/4SADv+Dfw//gX0N/4B6DP9+eAz/f3kO/354Df+Cdw7/gncP/4J2 + D/+BdRD/gHQP/4B0Dv9/chD/f3AR/31uEf99bhH/fG0Q/3xtEf98bRH/fG0R/35uE/+AcBL/gXAS/+bj + 29ji392908/KqsXBu5u9uLGP6Obl1xIREdkAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI19bV5sO/uZzJxsGm2NbTufTu8c5snGb4RIY9/02Q + RP9Ok0T/UZND/1GQQf9TkT7/XZU8/2KcPP9moTr/Zp43/2GXM/9ejzH/W4sw/1+LLv9pmC3/dr0x/3bK + Mv9qqSv/YYEj/2F7IP9kgSD/ZoIg/2eFH/9uhx3/cowd/3ePHf9+kRz/gZYa/4WYGf+KmRj/i5oX/4yZ + HP+KlR//gYsV/3+IFP+BjBT/hI8S/4SOE/+CihL/gIgQ/32GEv97hRD/eoMP/3qDD/95gw//eYMP/3yG + EP+BixH/h5IR/46ZEv+TnRL/kZsT/5WfE/+VnxH/go0P/4GLDv+Diw//hI4O/4SMD/+Diw7/hYwP/4yQ + EP+PlBH/jJIQ/4iMEP+Gig3/h4kN/4qMDP+NjQ3/jYwO/4mKDP+IiA3/ioUM/4iFDP+Egw3/g38N/4J+ + Dv+Aew3/f3kN/354Df9+eA3/f3gN/4J4Df+CeA7/gncP/4F1D/+AdA7/gHQO/39yEP9+cBD/fm8Q/31u + Ef99bRD/fG0Q/3xtEP9+bRL/gXAS/4JyEf+DchH/5uPb2OHg3b7Sz8urxsO8m725sY/o5uXXEhER2QAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjZ19bnwr64m8rGwabZ19O59O7yzmybY/hFhzn/TY5A/0+RP/9SlkH/WZpA/2GiP/9opDz/Z6M5/2Ka + NP9ekjH/XIsv/1yJLf9hjCz/bKUt/3bPMv9xxy//Y5Qn/2F6Iv9ifSL/ZIAh/2WBIP9ogx7/bIQd/3GH + Hv90jB3/epAd/3+TGv+Clhn/h5kY/42bGP+NmhX/jpoc/4uVIf+AihT/fogS/4KNFP+FjhL/ho4R/4KK + EP9/iBD/fYUR/3yFD/97gw7/e4MO/3qDDv97gw7/fogP/4SOD/+KlA//kJsR/5WfEv+SnBH/maES/5Kc + EP+CjQ//g4wO/4SMDv+Gjg//ho0O/4WMDf+Hjw7/jpQQ/5CWEP+MkhD/iIwP/4WKDP+Jiwz/jo0N/5CM + DP+PjAz/jIoK/4uHC/+KhAv/hoQL/4OBDf+Dfw7/gX0M/397C/9+egz/f3gM/4F3DP+CeQ3/gngN/4J4 + Df+CeA3/gHYO/4B1Dv9/dA7/f3MO/39yEP9+cBH/fW8P/3xuD/98bRD/fW0Q/39vEv+BcBH/gnIS/4V0 + D//m5NrY4uDevtTRzKvHw72bu7avjuno5tkTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNrY1+jCvbecysbBqNnX07n07/LObJtg+ESF + NP9NjD3/VJc+/12kQP9mq0D/aas8/2ikN/9imDP/XI0w/1uJLf9diiz/Y5It/2+2L/9x1zH/ZrIt/2GF + Jf9ifCL/ZIEg/2SBH/9lgR7/aIEd/2qDHv9uhRv/cYob/3eMGv98kBv/gJMa/4eWGf+Jmhj/jZoW/46a + FP+Qmh7/jJUh/4GKEf+AiBL/g4oR/4WNEv+FjRD/gooO/4CJD/99hg7/fIQP/3uDD/97gw7/e4MO/3uE + D/+BiQ7/h5AP/42XD/+TnhD/l6AP/5OcD/+cpBL/kZkQ/4WODf+Gjgz/hY4M/4ePDv+Gjg7/hYwN/4mP + Dv+Plg7/kJcP/4uQDv+Hig7/hokM/4qLDP+OjQz/kY0N/4+LDP+NiQv/jIcL/4mEC/+Hgwr/hYEL/4F9 + Df+AfAz/f3oL/355C/+AeQz/gncM/4N4DP+CeA3/g3gN/4N3Dv+CdQ3/gnUN/4JzDf+Acw7/f3IO/4Bw + Dv9/bw//fW4O/3xuDv9+bg7/gHAQ/4BxEP+CcxH/hnUR/+bk29jj4N6+1NHMq8bDvZy5tK6N6unn2hMS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI2djX6MG9t5zKxsGn2dfTuvTv8s9rmV74RYUx/1SWO/9gpj7/Z7E//2mvPf9mpTn/YJgz/16O + L/9ciCz/X4os/2idLv9xyjH/bNIx/2CYKf9deyP/YX4i/2WDIf9lgx//Z4Ie/2iCH/9qgh3/bYMd/3CG + G/9zihn/eIwZ/32QGv+Ekxf/ipYY/4yaF/+QmhX/kJoT/5GaHv+MlCD/f4gR/4CHEv+EihH/hY0Q/4OM + D/+Ciw//gIkM/36GDf99hQ7/e4QN/3uEDf97hAz/foUN/4KKDf+JkQ7/kJgP/5WdEP+Wng7/lJwP/52k + Ev+Olg7/ho4N/4aODP+Ijwz/iI8M/4eODf+IjQ7/jJMO/5GYDf+Qlg7/i44O/4eJDf+JiQv/jYwL/4+O + Cv+RjAv/kIoM/4yIC/+Lhgv/iYQL/4iBCv+EgAr/gX0M/4B8DP+AeQr/f3gK/4F4DP+Bdwv/gngM/4J4 + Df+Ddwz/hHcM/4N1Df+CdA3/gXQN/4B0Dv9/cg3/gHAN/39wDv9+bw//fW8P/35vD/+AcBD/gnIP/4R1 + EP+GdxH/5uTb2OPg3r7U0MurxsS9nLi0rY7q6efaExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2NfowL24ncnHwqjZ1tO59O7yz3Cd + XPhPkjL/YKc7/2auO/9nrjv/Y6U4/16ZNP9bkS//XIst/2COLP9qrS7/cNoy/2bDLf9bgyP/Wncj/15+ + Iv9igSD/ZYIf/2eDIP9ogx//aoId/2qCHP9sghz/cYUZ/3WKGP96jBj/gJAY/4eTF/+Klhb/jZkV/5GY + Ff+QmRL/kpsf/4uUH/9/hxD/gIcS/4OJEP+Fiw//hIwP/4GKDv+AiA3/f4YN/36FDP98hAv/e4QL/3yE + C/9/hwv/hIwO/4uSDv+SmRD/mJ8Q/5idDv+ang7/nqQQ/4uUDv+Gjg3/ho4M/4mPDP+Jjwz/iI0L/4mP + Df+PlQ7/lJkN/5CVDf+Jjg7/h4oM/4yKDP+Qjgz/kI4K/5GNC/+Pigv/jIgL/4uGC/+JhAr/iIEK/4R/ + Cf+BfQv/gHwM/4F5Cv+CeAv/gngM/4J4DP+CeAz/gngM/4N4DP+Edwz/g3YN/4J1Df9/dQz/f3MN/4Bz + Df+AcAz/fnAM/31vD/9/bw//f28P/4BwD/+Ccw//hXYR/4d4EP/m5NvY4+Dev9TQy6vIxL2cubStjurp + 59oTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNnY1+jBvbidyMfCqdnW1Lrz7fLPd6pc+FmeMP9jqTj/Y6k2/2CjNv9dmzX/XJUx/12Q + Lv9ili7/bsAx/2zhMv9grir/WHgj/1l4IP9bfCH/Xn8f/2SCHv9mgh7/aYMe/2qCHP9rghr/a4QY/2+E + Gv9zhhr/d4oY/32NF/+DkBX/h5QU/4uWFP+OmBX/kZgV/5GYE/+UmSH/jJId/4GJDP+Bhw7/hIkP/4WL + Dv+Fiw7/g4gM/4KHDf+AhQz/foUL/32EC/99hAv/fYUL/4CIC/+GjQ3/jZQN/5SbD/+ZoQ7/l54N/56i + Dv+eog//jJEN/4mPDP+Kjwz/i5AN/4qPDP+Kjgv/jZAM/5GWDf+UmQ3/kZUN/4qNC/+JiQv/j4wL/5KO + Cf+Sjgr/ko0L/5CKCv+OiAn/i4cJ/4mECv+HgQr/hn8K/4N9Cv9/fAr/gXkJ/4J4Cf+CeQv/g3gL/4R5 + Cv+EeAz/hHgM/4N3C/+Ddg3/gnUN/4F1DP+Bcw3/gHIM/4BxDf9+bwz/fm4N/35vDP9/cAz/gXIN/4N0 + D/+FdhD/h3kO/+bk2tji4N6/1NDLq8XDvZ24s62O7Onn2hMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2djX6MO+uJzJx8Ko2NbTuvLs + 8s96sFv4V58t/1ygM/9cnjT/W5w0/1yaM/9flzD/ZqIw/27TNP9p2zH/XJon/1dxIf9ZeSD/WHog/1x6 + IP9ffh3/Y4Ee/2aCHP9oghz/aYEb/2uBGP9sghn/boQZ/3KHF/95ihf/fo0V/4OPFP+GkxP/i5YT/5CX + FP+SmRT/kJcT/5OXIf+Mkhr/gYgK/3+GDf+DiA7/hYwO/4WLDf+DiQ3/gYcK/4CFCv99hQr/foQJ/36E + Cf+AhAv/g4kK/4iPDP+QlQ3/mJwN/5ygDf+anQ3/oaQO/5yeDf+MkAz/i48L/4uQDP+LkAz/jI4M/4yP + C/+OkQ3/kpcN/5SZDP+Okgz/iYwL/4uJCv+Qjgr/kpAJ/5KPCv+RjQr/kIoK/46ICf+Lhwn/iIMI/4eC + Cf+Gfwr/gnwJ/357CP+AeQj/gXkI/4F5Cf+CeQr/gnkK/4N4Cf+DeAv/hHgM/4J1C/+CdQv/gXQM/39z + Df9+cgz/f3EL/35vDP9+bgv/fnAM/4ByDf+CdA7/hHYQ/4Z3Ef+HeQ//5uTa2OPg3r/T0MusxsO8nbu0 + ro3r6efaExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjZ2dfow7+5nMvIw6fa2NS68+zzz3erWfhRlCr/VZUw/1eXMv9anDL/YJ8x/2my + Mv9u4Df/Zc0y/1qJJv9XciH/WXoh/1p7H/9aeR7/Xnoe/2F+Hv9kgR3/aIQa/2qDGv9qghn/bIMX/22C + GP9vhBj/dIgW/3qKFf9+jRX/hJEU/4iVE/+MmBP/kZkU/5GZEv+QlxL/k5cj/4uQGf+Ahgr/gIYO/4SJ + Df+Giw3/hooN/4SIC/+Chwr/gIUK/3+GCv9/hQr/gIUK/4GGCf+Fiwv/i5EM/5GXDf+anQ3/naAO/5ue + Df+ipg3/lpwL/4uRC/+LkAv/i5EL/4yRCv+Mjwv/jJAL/5CUC/+WmQv/lZkL/46RCv+Liwr/josK/5KO + Cv+Tjwr/k44K/5KMCv+Qigr/jogJ/4yGCf+KhAn/h4EI/4R+Cf+DfAn/gHsI/4F5CP+Begj/gnoJ/4J5 + Cv+DeQr/g3gJ/4N3Cv+Ddwz/gnYL/4J1C/+BdAz/gHIM/39xC/9/cAv/fm8L/39vDP9/cAz/gHIN/4J0 + Dv+FdhD/h3kQ/4l7D//n5NvY4+Dev9PRy6vIxL2cubStjuro5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnZ1+jDv7mcy8fDp9rY + 1Lr07/TPdKJV+E2IJf9VkC7/V5cw/1+jMv9qwDb/bOk5/2C/MP9Zgif/WHYk/1p6If9Zeh//W3kd/1t4 + HP9dehv/Yn4d/2aBG/9pgxj/bIIY/2uDF/9sghf/boIW/3KDFv91hxT/e4oU/4CNFP+HkRP/ipUS/4+X + E/+RmBH/kZgP/4+WEf+TmSL/iI8V/3+FCP+Bhgz/hIoN/4aKC/+FiQr/g4cJ/4OHCf+BhQj/f4QJ/3+E + Cf+AhQn/g4cJ/4eMCv+Nkwv/lJkM/5ufDP+coA3/nJ8M/6OmDv+TmQv/i5IK/4uRCv+Nkgv/jpEK/4yQ + Cv+OkQr/k5gK/5qaC/+Wlgz/j48K/42MCf+QjQj/k44K/5SQCf+Ujwn/kowJ/4+KCP+Nhwj/jIYJ/4qD + CP+HgQj/hH8I/4N8CP+Cewj/gXoH/4J6B/+DeQj/g3kH/4N5CP+DeAn/gncJ/4N3Cf+BdQr/gHQK/4Bz + C/9/cwv/fnIL/31xCv99bwr/fnAM/39wC/+Bcwz/g3UN/4V3Dv+Ieg//inwO/+bk2tji4N6/1NHMq8fD + vJ23sayQ6ejm2xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI2djX6MS+up3MxsOp2tfUuvTv9M9xnFT4TIQl/1iQLv9gozH/a882/2vo + Of9gsS//WYQm/1l/JP9afSH/W3of/1t6Hv9beRz/W3gb/117Gv9hfhv/Z4EZ/2qDGP9sghf/a4MX/22C + Ff9vghT/coMV/3WGE/98ixT/go0T/4aREv+MlBL/kJYR/5GXEP+Rlw//kJYR/5OYIf+HjhL/gIUJ/4GF + DP+Eig3/howL/4aJCv+Ehwn/g4cJ/4GFCP+AhAn/gIQI/4CFCP+Dhwn/h40J/4+UC/+Ymgv/naAM/5yg + DP+eoA3/oaUN/5KXCf+LkQn/jJEK/42RCv+NkQr/jJEJ/4+UCv+VmQr/mpoL/5WUC/+Qjgr/jowJ/5KO + CP+Ujwn/lJEH/5SPCf+SjQj/kIsI/46ICP+MhQj/ioMI/4eCB/+EgAb/g3wH/4F6CP+Begf/gnoH/4N5 + B/+DeQb/g3kI/4N4Cf+DeAn/g3cJ/4F1Cv+AdAr/fnML/35zC/99cQr/fXAK/31vCv99cAv/fnEL/4F0 + DP+Ddg3/hXgN/4h7D/+KfA3/5uTa2eLg3r/U0MysxsG8nrexrJDp6ObbExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2NfoxL66nczH + xKna1tO69O/zz3GaVPhNhiT/XaIv/2jWN/9o5Dn/XKUt/1mGJ/9Zhib/WYIi/1t9H/9beh3/XHoc/115 + G/9deBr/XnoZ/2F+Gv9ogRj/bIMW/2uCFv9rghb/boEU/3CBE/9zgxT/d4cT/3qLEv+CjhP/h5AR/4uT + Ef+Olg//kZYQ/5CWDv+PlRH/lJgh/4eMEf9+hQf/gYYL/4aKC/+Gigr/hokK/4SHCf+Dhwn/goYJ/4GF + Cf+Chgj/gYUH/4OJBv+Jjwf/kpUH/5qbCf+foQz/nKAL/6CkCv+hpAr/kJQJ/42QCf+NkAn/jpEK/42R + Cv+Okgn/k5UJ/5qYC/+ZmQr/k5MK/4+NCf+PjAj/ko4I/5SRBv+UkQf/k48I/5GLB/+Qign/jogI/4yF + CP+JgQj/hoEH/4N/Bf+DfAf/gnsI/4F6Bv+Aegf/gnkI/4J3B/+DeAj/gncJ/4N4Cf+Bdgj/gXQK/4Bz + Cf+Acwv/f3IK/31wCP99bwn/fW8J/39wCv9/cgv/gHMK/4N1DP+Gdw3/iHoN/4t+Df/n5drZ4uHev9LP + y6zFv7yft7KskOro5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNnY1+jDvrqdzMfEqNrW1Lr17vPPcp1S+FWfJf9k3DX/YNk1/1qZ + LP9ZiSj/W4wn/1qHJP9ZgiD/WXwd/1t5HP9cehv/XXka/114Gv9gexn/ZX4X/2iBFv9rghb/a4IV/2yB + Ff9wgBT/cYET/3OEEv95hxH/fYsR/4ONEP+IjxH/i5IP/4+WD/+Qlg3/j5YK/5CVEP+TliD/hooO/4GD + B/+BhQr/hYkL/4WJCf+FiQj/hIcI/4OGCf+ChQf/goUH/4KFB/+ChQf/hYoI/4uQCP+Ulgf/m50I/5+g + DP+cnwv/pKYK/56hC/+Skwj/kZII/5GRCP+Skgn/kZAK/5GRCf+Wlgv/mpoK/5maCv+Tkgj/j40I/5GM + CP+Ujwj/l5EI/5aRCP+Tjgj/kYwI/5CLB/+OiAf/i4QI/4mCB/+HgAX/hX4G/4J8Bf+CfAb/gXsE/4B6 + Bf+Cegf/gngG/4J4Bv+Cdwf/gncI/4F2CP+AdAn/f3QJ/35zCP99cgn/fHAJ/3tvCP98cAn/fXEJ/39y + Cf+BdAr/hHcN/4Z6DP+Iew3/in0N/+bk2tni4d6/0s/LrcXAvJ+3sqyQ6ejm2xMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2djX6MO+ + up7Lx8Sp2tbUu/Ts8896ulX4Wt0r/1rKMf9VjSj/V4op/1mQKP9aiiX/Wocj/1mAH/9Zexz/XHob/114 + G/9ceBr/XHcY/196F/9lfRX/aIAV/2uCFv9tgRX/boEU/29/Ev9xgRL/c4QQ/3qGD/9/ihH/g4wR/4iP + EP+Lkg7/j5YN/4+WC/+QlAj/kZUR/5KWIf+EiA3/gYQH/4KFCf+Fhwr/h4gJ/4aIB/+Fhwj/hIUI/4KF + B/+DhQf/goUH/4KFCP+Iigf/j5AI/5aYCP+cngj/n6EL/52fCv+mpwv/nZwL/5GSB/+RkQf/kpII/5KS + CP+RkAj/k5EJ/5iWC/+bmwn/mJcI/5KQBv+QjQf/ko4G/5WRCP+XkQb/lpAH/5ONCP+Riwj/kIoF/46H + Bv+Mgwj/iYMG/4iABv+Ffgf/hHwF/4F8Bf+CeQb/gnkH/4J4B/+DeQj/gngH/4J3B/+Cdwb/gXYJ/390 + Cf9+cwn/fHEI/3twCP97cAj/e28I/3pvCP99cgr/gHMJ/4N1C/+Edw7/hnoN/4h9DP+Kfw3/5uXb2eLg + 3r/Sz8utxcC8n7exq5Hp6ObbExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2dfow767nsvHw6na1tS69Ojy0HzoWvhQuCX/UYIl/1aG + Jf9ZkCf/Wo4m/1uLI/9ahSH/WoAd/1t8G/9beRn/XHgZ/1x4GP9cdxf/XnkW/2R8Ff9ofxT/bIEU/26B + E/9tgBH/boAQ/3CCEP90gw7/e4YP/3+KEP+EjRH/iJAO/4yTDf+OlQv/jpUJ/4+UCP+QkxD/kZUh/4OI + C/+AhAb/gYUI/4SICP+Ghwf/hocG/4WGBv+Dhgb/goQH/4KEBv+BhAb/hIYH/4mMBv+Rkgb/mJoG/52e + B/+enwn/np8J/6WnCv+amgf/kpEI/5KSCP+TkQf/kpII/5KRB/+Vkwj/mZgJ/5qbCv+WlAn/kY4H/5CM + CP+Tjgf/lpAH/5aRBv+Wjwf/lI0I/5KKB/+QiAX/jYYH/4uECP+IggX/hn8F/4V9B/+EfAX/g3wF/4N6 + Bv+DeQX/gngF/4N4CP+Bdgb/gXYG/4F2Bv9/dQf/fXMI/3xyCP98cQn/e3AI/3pvB/96bwf/em8I/31y + Cf9/cgj/gnYK/4R4DP+FeQz/iX0N/4p/Df/m5dvZ4uDfwNLOy67Fv7yft7KskOro5tsTEhHaAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnZ + 1+jCv7ueysfDqdjX07v17fPQcaxQ+Ep2G/9UfyT/Vooj/1qPJf9ajiX/XIsi/1uGIP9bgB3/XXwb/1x5 + Gf9ceBj/XHgW/1x3Fv9geRb/ZHsU/2h+E/9tgRP/bYAS/21/EP9vgA//cYIO/3eED/98hg7/f4kP/4SN + Dv+IkQ3/i5MM/42UCv+PlQr/j5MI/5CTE/+RlR//g4gI/4CEBv+ChQj/hYgH/4eIB/+Ghwb/hIYG/4OG + Bv+ChAb/goQG/4OFB/+Fhwf/i40G/5OTB/+amwb/np8H/5+gCP+iogj/p6cK/5iXCP+Tkgj/k5MI/5SS + CP+Skgj/k5EH/5aUCP+amQj/mpkJ/5WTCP+Rjgf/kI0G/5SPB/+XkQf/l5EG/5eRB/+Ujgb/kosG/5CJ + B/+Nhwf/i4MG/4iBBv+GfwX/hX0F/4R8BP+EfAT/g3sE/4N7A/+DegT/gnkG/4J3Bv+AdQX/gXYG/4B1 + Bv99cwf/e3EH/3twB/97cAf/em8H/3pvB/97cQf/fXMI/4F1CP+Ddwr/hHkL/4Z7C/+Kfg3/in8M/+Xl + 2tng397A0s3KrsXAu5+3sqyQ6ujm2xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2dnX6MK/up7LyMSp2tfUu/Xw89BvjEv4SnYa/1KC + If9WiSL/Wo8j/1qPI/9ciyH/XIUf/1yBHf9cfBv/XXgY/1t3F/9beBX/XHcU/2F2Ff9lehP/aX0T/2x/ + Ef9tfw//bX4P/29/Dv9wgA3/doMN/3qGDf+AiA3/g4wN/4eQC/+KkQr/jpMJ/4+UCP+Nkgf/kZMU/5GU + Hv+Chwb/foMF/4OEBv+Ghgb/iYgG/4eGBf+EhQX/hIUG/4OEBv+DhAb/g4UG/4eHBf+OjQX/lZUG/5ub + B/+goQX/oJ8G/6WjB/+lpAj/lpQF/5ORBv+Ukwf/lJMH/5SSB/+Ukwb/lpYH/5yaCP+amAf/lJIE/5GN + BP+Sjgb/lpEG/5eSB/+YkQb/l5AF/5ONBP+RiwX/j4gF/4yGBf+LhAX/iIEF/4Z+Bf+FfQT/hHwD/4R8 + A/+DewT/g3sE/4J7A/+CeQT/gXcF/4F2Bv+Bdgb/f3MF/31yB/97cQb/e3EF/3pvBv96bwf/enAH/3xy + Bv9/cwf/gXUJ/4N3Cv+Fegr/h3wM/4l+DP+LgQr/5eXa2eDf3cDSzsquxcG8n7eyrJDp6ObbExIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMja2dfow7+6nsvIxKna19W89fD10G+RS/hJdxj/UoEg/1aIIf9ajyD/XJAg/12LH/9chR//XIEc/1x8 + GP9ceRb/W3YW/112FP9fdBT/YXcU/2R6E/9ofRH/bH8Q/21/EP9tfg//bn4O/3F/Df94gg3/e4UO/3+I + DP+DjAz/h48L/4yRC/+PlAr/j5MH/5CRBv+SlBX/kJId/4GGBf9/ggX/goMF/4SGBP+IhwX/h4YF/4SF + Bf+DhAX/g4QG/4OEBv+DhQT/h4kE/4+NBf+WlQX/m5wG/6CiBv+foAX/paUG/6OiB/+Vkwb/k5IG/5ST + B/+Ukwf/lJIH/5WTBf+Zlwb/nJoH/5mVBv+TkAX/kY4E/5SPBf+XkQb/mJEG/5iRBv+Wjgb/lIwF/5KK + Bf+PiAb/jIUH/4uCBv+IgQX/hn4F/4V9A/+EfAP/hHwD/4N7BP+DewT/gnkF/4J4Bv+AdgT/gXYG/350 + Bf99cwX/fHIH/3txBv96bwf/eW4G/3lvBv96cQX/fHIH/31zB/9/dQn/gncK/4V6Cv+HfAv/iX4N/4uB + C//m5NrZ4t/dwNHOy67FwbyftbCrkeno5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNrZ1+jFv7yezMjEqdrX1bz18PXQbpBJ+Eh1 + F/9SgB//Vocg/1mPH/9ckCD/XIwe/1yFH/9bgBv/WnsY/1t3Fv9bdhb/XnUU/190Ff9hdhP/ZHkS/2h8 + Ef9rfBD/bX4Q/21+D/9vfQ7/dH8N/3iCDf97hA3/f4gL/4OLC/+Ijgn/ipEK/4yTCP+Pkgf/kY4I/5KU + Gf+Okhz/gYUE/3+BBf+ChAX/hIcE/4iGBf+GhQT/hIUG/4OEBv+DhAb/g4QG/4OFBf+IiQT/j5AF/5eW + B/+enQX/oaIG/6CgBP+npwb/n58F/5SSBv+UkQb/k5EG/5SSB/+Tkgb/lZQF/5uZBv+bmgj/lZIF/5GO + A/+SjgT/lJAF/5eRBv+YkQb/mJEG/5WOBP+Tiwb/kYkF/4+HBf+LhAb/ioEG/4eABf+FfgX/hHwD/4R8 + BP+EfAX/hHwF/4N7A/+CeQX/gXcG/393BP9+dgP/fXQF/3xzBP97cQX/e3EG/3puB/95bgb/eW8G/3px + Bf98cgf/fXMH/351CP+CeAj/hHkK/4Z8C/+Ifw3/jIEL/+bk2tng3t7B0c7LrsXBvZ+3squR6ujm2xMS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI2tjX6MTAvJ7MyMWp29jWvPXw9dBtkEj4R3QX/1GAHv9Whx7/Wo8g/1yRIP9cjB3/XIYc/1yA + G/9cehj/W3YW/1x0Ff9dcxX/XnQV/2F1Ev9jeRH/Z3wQ/2p7D/9sfBD/bnwN/298Df90fg3/d4EN/3qE + DP9+iAv/hIoK/4iNCv+KkAn/jZIJ/42RCP+Ojwj/k5Qc/46RG/+BgwL/f4AG/4KCBP+EhQT/h4UF/4aF + Bf+ChAb/goMF/4KDBf+DhAX/hIUF/4uKBf+RkAb/mJgG/5+eBv+goQb/oKAF/6inBv+cmwX/k5EG/5OQ + Bf+UkQb/lJEG/5SRBv+WlQb/m5kH/5mYBv+Tkgb/kY4E/5ONBv+Vjwb/mJEG/5iRBv+XjwX/lIwF/5KL + Bv+QiQf/joUG/4qCBf+JgQX/h4AF/4V+A/+EfAP/hHwD/4R7Bf+EfAX/g3sD/4J5BP+BdwX/fncF/311 + BP99cwX/e3EF/3twBf96bwX/d28G/3ZuBf93bwX/eXEF/3xxBv98cgb/f3YH/4B3CP+Eewn/hn0K/4iA + Cv+Mgwn/5uPa2uDf3cDS0MquxMG8oLayrJLq6ObbExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMja2dfoxcC8ns3Jxanb2Na89vD20G6O + SfhIdBX/UX8d/1WGHf9bjR7/XJAe/12MHf9bhhr/XH8Z/117F/9cdxX/XXMU/15zFP9echP/X3QS/2N3 + Ef9oeg//a3wO/2x9Dv9tew3/bnsN/3J+DP91gAv/eoMM/3+HCv+DiQr/ho0J/4mPCf+MkAr/jI8J/4uO + B/+TlR3/jY8Z/3+BAv9/fwX/goIE/4KEA/+GhAT/hYQG/4KDBf+Cgwb/goIG/4KDBf+Hhgb/jYsF/5OR + Bf+ZmAX/n58G/5+fBv+hoQb/p6UG/5mXBP+SkAX/lJEG/5SRBv+TkAb/lJEF/5iVBv+bmAb/mJYF/5KQ + Bf+QjAb/k4sH/5eQBf+YkQb/mJAG/5WOBv+TjAb/kYoH/4+HBv+NhAf/ioIG/4mBBf+GfwT/hHwD/4R8 + A/+EfAP/g3sE/4N7BP+DegT/gXgF/4B2BP9+dQT/fHMF/3tyBP97cQb/em8F/3duBP90bgX/dG4F/3Ru + Bf93cAX/enIH/31zB/9/dgf/gHgI/4N7Cf+FfAn/iYAI/4uDCf/l49ra4N/ewdHPy67EwLugtrKrkuro + 5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNrZ1+jFwLyfzcnFqdvY1rz28PbQcI1I+Eh0FP9Rfhz/VYUe/1qNHf9djx7/XYwc/1yH + Gf9dgBn/XHsW/1t3FP9ccxT/XnMU/15yE/9edBH/YncQ/2d5D/9qfA3/a3wN/2x8Df9tfA3/c30L/3WA + DP96ggv/f4YK/4SJCv+HjQn/iI8J/4qPCP+Ljwn/io4I/5KWIP+Ljhb/f4EC/35/BP+BggT/g4QD/4OE + BP+DhAT/goMF/4KDBv+Cggb/goMF/4eGBv+NiwX/lJIF/5uYBv+fnwb/n54G/6SiB/+lpQf/lZMF/5KQ + Bf+TkAX/lJEG/5OQBf+UkQX/mZQF/5qXBv+WkwX/ko0G/5CLB/+TjAf/l5AF/5iRBv+XjwX/lY0F/5OL + Bv+RigX/j4YG/4yDBv+JgQX/iIAF/4V9BP+EfAP/hHwD/4N7A/+DewT/g3sE/4N5Bv+Bdwb/gHYE/390 + BP98cwT/enEE/3pwBf93bgT/dG4F/3RuBf90bgX/dG4F/3VvBP93cQb/fHMH/392B/+BeAj/gXoI/4R9 + Cf+JgQj/i4QJ/+Xk2trg397B0c/LrsTAu6C2sqyS6ejm2xMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2tnX6MXAvJ/NyMWq29jWvPbx + 9tBvjUf4R3IV/1F9Hf9VhR7/Wo0d/12QHf9djRv/XIgZ/12BFv9cexb/W3YU/1xzE/9echP/XnET/2Bz + EP9kdhD/aHkP/2t7DP9rewz/bHwM/2x8DP9xfQv/dn4L/3mDCP9/hQn/g4kJ/4eMCf+IjQr/io8I/4uP + CP+LjQj/k5Yi/4uMFP9/gAD/fn8E/4GCA/+DhAP/g4QE/4OEBP+Cggb/goIG/4KCBv+CgwX/h4YG/46M + Bf+Ukwb/nJoF/5+fBv+fngb/o6QF/6GiBv+TkQX/k5AG/5OQBf+UkQb/k5AG/5WSBv+ZlQb/mZYF/5SR + Bf+RjQb/kosG/5ONBf+XkAX/mJEG/5aPBv+UjAj/kokH/5CHBv+OhQb/jIMG/4mBBf+IgAX/hX0E/4R8 + A/+EfAT/g3sE/4N7BP+DewT/gnkF/4B2Bv9/dAX/fXQF/3xyBv93cQT/dnAE/3RuBP90bgX/dG4F/3Ru + Bf90bgX/dXAE/3dyBf95dAf/fnYH/4F4CP+Bewn/hH0L/4mCCv+Kgwj/5eTa2uDg3sHRz8uuw8C7obWy + rJPq6ObbExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMjZ2NfpxcC8n83Jxarc2ta89vH20G+MR/hIcRT/UHwc/1SEG/9ZjBz/W5Ac/12M + G/9dhxj/XYAW/1x7Fv9bdhT/W3MT/11xEv9dcRH/X3IQ/2R1D/9peQ3/a3oN/2p6C/9rewz/bHoL/298 + Cv91fwr/eoII/36FCf+CiQn/howJ/4iOCP+Ljgn/io0I/4qNCP+UliT/iYsS/32AAP99fgP/gYEE/4KD + A/+CgwT/goME/4GBBf+BgQX/gYEF/4KCBv+HhwX/jo0F/5WTBf+cmwX/oJ8G/6CdBf+mpgX/n54F/5OP + Bf+TkAb/lJAF/5SQBf+Tjwb/lpMF/5mVBv+ZlQb/lI8E/5GLBf+SigX/lI0F/5eQBv+XkAX/lo0G/5OL + B/+RiQX/j4YE/42EBf+LggX/iIAF/4Z+BP+EfAP/hHwD/4N7BP+DewT/g3sE/4N7BP+CeAX/gXYG/390 + BP98cwX/e3EF/3dwBP90bgP/dG4E/3NtBP9zbQT/c20E/3VvBf93cQX/d3IF/3l0B/97dQf/f3gH/4J6 + CP+Ffgj/ioMJ/4mAB//l5Nra4N/dwdHNyq/DwLuhtbKsk+ro5tsTEhHaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnY1+nGwbyfzsvGqdza + 1rz28fXQb4tG+ElyEv9SfBr/VYQb/1qMG/9dkBv/Xowb/12HGP9dgBf/XHsW/1p2E/9bchL/XHES/11x + Ef9fchD/ZHUP/2d4Df9qeQ3/anoM/2t7DP9teQz/cXsJ/3V/Cv95ggn/foUI/4GICf+GjAn/iY0I/4qO + Cf+KjQf/io0J/5SWJ/+IiQ//fYAA/31+A/+BgQT/goMD/4KDBP+BggT/gYEF/4GBBf+BgQX/gYIG/4mI + Bf+RjQX/lpQH/52bBv+hngb/oJ0F/6imBv+cmAX/k48E/5OQBv+VkAb/lY8F/5aPBf+ZkwX/mpUG/5eT + BP+TjQX/kYsE/5KKBf+VjQX/mJAG/5ePBf+WjQb/lIsG/5GIBf+PhgX/jIMF/4qCBf+IfwX/hn0E/4R8 + Av+EfAP/g3sE/4N7BP+DewT/gnoF/4F4Bf+AdQX/f3QE/3xzA/97cQX/d3AE/3NtA/9zbQT/c20E/3Fr + BP9ybQT/dG8F/3dwBf93cgX/eXQG/3p2B/98eAf/gXoJ/4aBB/+Iggf/hXsH/+Xj2trg3t3C0c3Kr8PA + u6G1sqyT6efm3BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI2djX6cfDvp7Py8aq3drWvPfy99BwikX4SXER/1N8Gf9Wgxn/Wowa/2CP + Gf9fjBn/XYYZ/1yAF/9cexb/WnYT/1pyEv9dcBL/XG8Q/2BxEP9kdA7/ZncM/2l4DP9peQz/ankL/2t5 + Cv9xfAr/dX4J/3iBCP99hQj/gYgI/4WKCP+JjAj/i44I/4qMBv+KjQr/lJUp/4aGDf99fgD/fH4E/3+A + BP+BggT/gYIE/4CCBP+AgQT/gIAE/4GBBf+Dgwb/i4kE/5KPBf+Ylgf/nZwF/6GeB/+gnwX/qKQH/5mU + Bf+Tjgb/kpAG/5SOBf+Vjwb/lZAF/5iSBf+alAX/lZAE/5KKBv+RiQb/k4wG/5eOBf+XjgX/lo4G/5WM + Bf+TiQb/kYYE/4+EBv+Lgwb/iYEF/4d+Bf+EfAT/g3wD/4R7BP+DewX/g3sE/4N7A/+CeAb/gHYF/350 + BP99cwX/fHID/3pwBP93bwP/cm4D/3JsBf9ybQX/cGsD/3FtBP9zbgX/d3EE/3dzBf95dQX/enYG/3t3 + B/+Aewj/hoEH/4aBCP+Aegb/5OLZ2uDe3cLRzcqvw8C7obWyrJTp5+bcExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2Nfpx8O+oM/K + xqvd2da89/L30G+KRfhJbxH/U3oZ/1WCGf9aixn/X48Y/16LGP9dhxj/XH8W/1x7E/9bdRL/XHER/11v + EP9dbg//YHAP/2NzDf9mdgz/aHgM/2l4DP9pdwv/a3gJ/3B7Cf91fQj/eIAI/32EB/+Bhwj/hIkJ/4iL + CP+LjAf/iIwH/4uMDP+VlSr/hIUK/3x9Av97fAT/f4EE/4GCBP+BggT/gIAD/39/BP+AgAP/gIAE/4WD + BP+MiAX/k5AG/5iYBf+enQX/n5wH/6KgBv+mogb/l5EE/5SNBv+Ujgb/lI0G/5ONBv+VkAX/l5MF/5iT + Bv+UjwX/kYkF/5GJBv+UjAb/lo4G/5iOBv+XjAb/lIoG/5GHBv+PhQX/jYUF/4qCBv+IgAT/hn4D/4R7 + Av+DegT/g3oD/4N6A/+CegP/gXkD/4F4BP+AdQT/fXQF/3xzBf96cAT/eXAE/3VuA/9ybQP/cGwD/3Bs + A/9wbAP/cW0E/3NvBP91cQX/dnIE/3h0Bv96dgb/fHkH/4F9Bv+GgAb/gn4H/3x4Bv/k4tna4N/ewtHP + y6/EwbyhtbKslOnn5twTEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNnY1+nHw72gz8rHq93a17z38vbQbotF+EhuD/9Rehj/VoEY/1uJ + GP9ejhf/XowW/1yHF/9cgBb/XXoU/110Ev9ccBH/XXAP/11vDv9fbw7/YnIN/2V1Df9odwv/aXcL/2t3 + C/9vdwn/cnoJ/3R9B/94fwj/fIQH/4CGB/+FiQj/iIoJ/4mLB/+HiwX/i4sP/5SVKv+ChAf/fHwB/3t7 + A/9/gAT/gIAE/4CABP+AgAT/f38D/39/A/+BgQX/hoMF/4yJBf+SkAb/mZgG/6CdBf+fmwX/paEH/6Ke + Bv+TjgT/k40F/5OMB/+UjQj/k4wH/5aQBf+ZkgX/lpEG/5KMBP+QiAX/kYgF/5SMBv+VjAf/mIwI/5WK + Bv+SiAX/kIYG/46EBf+Nggb/ioEG/4h/Bf+GfQT/g3sC/4R6A/+DeQP/hHoD/4J4BP+BdwX/gHYE/4B1 + BP99cwT/fHIE/3pwBP91bwT/dG4E/3JtBP9wawP/b2oD/3BsA/9xbQT/cm8E/3NxBP91cgX/dnMG/3l1 + Bv98eQf/gn0I/4R/B/99egj/eXQG/+Ti2drg4N7C0c/Lr8PAu6K1sqyU6efm3BMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2dnX6cfD + vaDPyser3drYvPfy99FuiUT5SG4P/1J5GP9WgBf/WogY/16OF/9fixb/XYcX/1yAFv9eeRP/XXUR/1xx + D/9cbw7/XG8N/19vDf9icgz/ZXUL/2h2DP9odgv/anYK/293Cf9xeQj/dHwH/3iABv98gwb/f4YH/4SJ + CP+Hign/iIoI/4iJBf+LjBH/lJQp/4CDBP97fAL/e3sF/35+BP+AgAT/gIAE/4B/BP9/fgT/f38E/4CA + BP+Ggwb/jYoF/5SRBf+blwb/oJwH/5+bBv+logb/n5sF/5KMBf+RjAf/kowH/5OMB/+TjQf/lpAF/5iR + BP+Vjwb/kYoF/5CHBv+Qhwb/lIoG/5eLB/+Xiwf/lIkF/5GHBf+PhQX/jYMF/4uBBP+KgQX/iH8E/4V7 + Bf+EegT/g3kD/4J4BP+DeAX/gncF/4F3Bf+AdQX/f3QE/31zBP97cgP/eW8D/3htBf90bQT/cWwD/29q + A/9vagP/cGwD/3FtBP9ybwT/c3AD/3RxBP92cwb/eXQG/3x7Bv+Afgb/gH0H/3t3CP94cgf/5OPa2uDg + 3sLRz8uvw8C7orWyrJTp5+bcExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAA + ABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjZ2dfpx8O9oM/MyKvd29i89/L30W6IRPlHbQ7/UngW/1Z/ + F/9aiBf/XY4Y/16KFv9chhb/XoEW/115E/9ddBD/W3AO/1tuDf9cbgz/X3AN/2JyDP9ldAv/Z3UL/2h2 + C/9qdgr/a3YJ/3F5Cf90fAf/eIAG/3yDB/9/hQb/hIkI/4iKCP+Iigj/h4gF/4yNFf+UlCj/gIME/3t8 + A/97fAT/fX8E/4CAA/+AgAT/fn4D/359BP9/fgT/gIAE/4eDBP+Oiwb/lJIF/5uYBf+gnAb/n5sG/6ak + Bf+blgb/kYwG/5GLB/+TjAf/kosG/5KLBv+WkAX/l5EE/5ONBv+PiAb/kIcG/5CHB/+UiQb/losH/5aK + Bv+ThwX/kYUG/4+DBf+MgwX/i4EE/4uBBf+JgAP/hHoE/4R6BP+DeQX/gngF/4J3Bv+CdwX/gXcF/4B0 + Bf9/cwT/fHME/3pxA/94bgT/dm0E/3JsBP9xawP/b2oD/29qA/9vawL/cW0D/3JvBP9zcAP/c3EE/3Zz + Bf94dQb/fXwF/39+B/97eAj/d3QH/3VxBv/k4tra4N/dwtDOyrDFwLuiuLKslOnn5twTEhHaAAAAmQAA + AIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNnZ + 1+nIxL+g0M3Jq93b2L338/fRbYdD+UdsDf9ReBb/VX0W/1uIF/9djBb/XooW/12HFf9egBT/XXoR/1x0 + D/9bbg7/W24N/1ttDP9ebg3/YXEL/2RzCv9mdAv/aHUK/2h0Cf9rdgn/cHgI/3R7B/93gAf/eoIH/3+E + B/+FiQj/iIoH/4iKCP+FhwT/jo4Y/5KSKP+AgQL/ensD/3l7BP99fgT/gH8D/39/BP9/fgT/fn0D/39+ + BP+BgAT/iIMD/4+LBf+Vkwb/nJkF/5+bBv+fmwb/p6QG/5aSBP+Riwb/kooG/5KLBv+RigX/k4wF/5aQ + Bf+VjwT/kYoE/46FBv+OhQb/kIcH/5SKB/+WigX/lYkF/5KGBv+QhAX/jIIF/4uBBf+LgQX/i4AE/4h+ + A/+DegP/g3kE/4N4Bv+Cdwb/gXcF/4F2Bf+AdQX/f3QE/31zA/97cQT/enAE/3huA/90bgT/cmsD/3Fr + BP9vagP/b2oD/29rAv9xbgP/cm8D/3JvA/90cQT/dnQE/3h3Bf9+fQX/fXsG/3h1B/92cgj/c24G/+Ti + 2trf393C0M7KsMXAu6K3sqyU6efm3BMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAA + ABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2dnY6cnFv6DRzcmr3dvYvffz99Fth0L5RmwL/1B2 + FP9WfhX/XIcX/1+LFv9eihX/XYcT/16AEv9cfA//XHMO/1tuDv9abQ3/WmwL/1xuDP9hcAz/ZHIK/2V0 + Cv9odQv/Z3MJ/2x1B/9veAf/c3wH/3Z/CP96ggb/gIUI/4OICP+HiQj/hogH/4SFAv+PkBz/kJIm/35/ + AP94eQX/enoG/319Bf9+fQT/fn4E/319A/99fAP/fn0F/4CABP+JhQX/kIwE/5WUBf+dmgb/n5sG/6Cd + B/+loAb/lI4E/5CKBv+RiQf/kYkH/5GKBf+SjQP/lJAE/5ONBv+QiAX/joUG/4+GBv+Rhwf/k4oG/5aK + Bv+ThwX/kIYF/46EBf+Lggb/in8G/4uBBf+LgQT/hnwE/4N4A/+Bdwb/gncF/4F4Bf+AdgX/gXYF/390 + BP9/cwT/fHME/3lxA/94bwX/d24E/3JsBP9ybAT/cWoD/29rA/9vagP/cGwD/3FsBP9wbQT/c28D/3Ry + A/92dAT/enkF/318Bv96eAb/dXIG/3RwB/9xbAX/4+LZ2uDf3cLRzsqwxcC7oreyrJTp5+bcExIR2gAA + AJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAA + AMjb2tnoy8bAoNHOyKve29i9+PP40W6GQvlFagv/T3YU/1V9Ff9ahhX/XosV/16KFP9ehRH/XIAS/1t7 + D/9acw//Wm0M/1trDf9bawz/XG0M/19vDP9kcQr/ZXMK/2VyCP9ncwj/aXUH/3B4B/9zewf/dnwI/3yB + B/+AhAf/g4cG/4aIB/+Fhgb/hIQD/4+QIf+OkCP/fX4A/3d4Bf95egX/fX0E/359A/98fQL/fH0D/318 + BP9/fQX/g4AE/4iGBP+QjAT/lpQG/5yaBf+dmQb/o54H/6KcBf+Riwb/kIoF/5GJBv+QiAb/kYkF/5KM + BP+TjgT/kowG/42GBf+NhAX/j4UG/5KHB/+TiAX/lYgF/5KHBv+PhAX/jYIE/4qABf+KgAT/i4EF/4qA + BP+FeQP/gncF/4F3Bf+BdwX/gXcF/4B2BP9/dAT/f3QE/31zBP97cQP/em8E/3hvBP90bQT/cmsE/3Br + BP9vawT/b2oD/3BrA/9wbAP/cW0E/3BtA/9ybwP/c3EE/3Z0Bf96eQb/e3sH/3d0Bv9zcQX/cm0G/29p + Bf/j4tna4N/dwtHOyrDFwLuit7KtlOnn5t0TEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAA + AC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNva2ejLxsGh0M7JrN7b2b348/jRbIVB+UZp + Cv9QdRT/VHwU/1qEFf9eihT/XokT/1yGEP9dgBH/XHgQ/1tzD/9abQ3/WWsN/1lqDP9bbQv/YG0L/2Ny + Cf9kcwn/ZXII/2dzCP9rdAb/b3cF/3J5B/91fAj/fIEF/4CEBv+ChQX/hIYE/4WGBv+EhAL/kZIl/4yO + If99fQD/d3gE/3h6BP98fAT/fXwE/3x8BP97fAT/e3wE/399Bf+EgAT/ioYE/5COA/+YlQX/nZkF/5yY + BP+loAb/nZcG/5CKBf+PiAX/kYkF/5CIBf+RiAX/kYoG/5KMBv+QiAX/jYQG/4yDBP+PhQb/kYYG/5KI + Bf+Thgb/kIQF/46CBv+MgQX/iX8E/4l/A/+LgQX/iH8E/4J4Bf+CdwX/gXcF/4F3Bf+AdQX/f3QE/390 + BP9+cwT/fHMD/3lwA/95bwT/d24D/3JsA/9yawT/cGoD/29qA/9vagP/cGsE/3BsA/9vbAP/cG0D/3Fv + Av9zcgT/dnUF/3l5Bv94dgX/c3EF/3JvBv9wbAX/bmcG/+Pi2drg393C0c7KsMTAvKK2sq2V6efm3RMS + EdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAA + AG0AAADI29rZ6MvHwqHRzsqs39zZvfj0+NFthED5RmgL/1B0E/9UexL/WYMU/12JE/9diBL/XIUQ/11/ + EP9ceBD/W3IP/1psDv9Yagz/WWoL/1xrCv9gbgv/Y3EJ/2RyCf9lcgj/Z3II/2t0Bf9vdwb/cnkH/3R8 + B/97gAX/f4MG/4GEBP+DhQT/hIUF/4KDAv+Rkyf/iosd/3x8AP92dgX/eHkE/3t8BP98fAT/e3wE/3p7 + A/97fAT/fnwE/4WAA/+KhgT/kY4E/5iVBP+bmQX/m5gF/6SgBf+YlAX/jokF/46HBv+PhwX/j4cG/5CI + Bf+Rigb/kosG/46GBf+Mgwb/jIIF/4+EBv+RhQb/k4cG/5GGBf+PhAX/jYEF/4qABP+JfgP/iYAD/4uB + BP+GfAT/gXcF/4F3Bf+BdwX/gHYE/4B2Bf9/dAT/f3QE/31zBP97cQP/enAD/3duBf90bQT/cmsE/3Jr + BP9wagP/b2oD/29qA/9vagP/b2wD/29sA/9wbQP/cW8C/3NxA/93dQX/eHkF/3VzBP9ybwX/cW0H/29p + Bv9sZQX/4+LZ2uHf3MLRzsqwxMC8o7ayrZXp5+bdExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAA + ADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMjb2tnoy8fCodPPyqzf3Nm9+PT40W6E + QflFZgv/UHIT/1R5Ev9YghP/W4gS/1yIEv9cgw//XH4O/1x4Dv9bcw7/Wm0N/1hqDP9Zagv/XGoK/15u + Cv9icQj/ZHIJ/2RxCP9ncgf/a3MG/252Bf9xeAf/c3wG/3t/Bf9/gwb/gYQE/4OEBP+DhAT/goMD/5KT + LP+IiBr/enoA/3R1BP94eAT/ensE/3t8BP96ewT/eXoE/3p7Bf99fAT/hYED/4uIBP+SjgT/mZUE/5uY + Bv+bmAb/o6AE/5OOA/+NiAX/jYYG/4+GBv+Phgb/kIgF/5GKBv+RiQX/jYUE/4yCBv+Ngwf/j4QG/5GE + Bv+Thgb/kYUF/46DBP+MgAT/iX4D/4l+BP+KgQT/ioED/4R6BP+BdgX/gXYF/4B2BP+AdgT/f3UE/390 + BP9+cwP/fHME/3txBf96cAT/dm8E/3JtBP9yawT/cGoD/3BqA/9vagP/b2oD/29rA/9vbAP/b2wD/29t + A/9xbwP/dHEC/3h2BP93dgX/cnAF/3BuBf9vawb/bWYH/2pkBP/j4tna4d/dw9HNyrDEwLyjtrKtlenn + 5t0TEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAA + AFQAAABtAAAAyNrZ2enLx8Oh08/MrN/d2r349fjRbYNB+UVmCf9OcRL/U3cT/1Z/Ev9ahxH/XIcR/12C + D/9bfg3/XHgN/1tyDf9ZbQv/WGkM/1ppC/9cagr/X20I/2JxCP9icQf/ZHEI/2ZyBv9rcwX/bnUG/3F3 + B/92ewX/fH8G/36ABf+AgwX/goMD/4OEBP+CggX/k5Mw/4aHF/95eQD/dHQE/3d3Bf95egX/ensE/3p6 + Bf95eQX/eXoG/3x8BP+EgQP/jIkD/5OPBf+alQX/nJcG/56ZBv+gnQX/j4sE/4yHBP+Lhgb/jocF/4+F + Bf+QiAT/kYkF/4+HBf+KgwX/iYIF/4yDBv+Pgwb/kIUG/5GGBv+PgwT/jYEE/4t/BP+IfQP/iH0D/4yB + Bf+IfwX/gXgD/4B2Bf+AdQX/gHUF/4B1Bf9/dAT/f3QF/31zBP97cgP/enAE/3luBP92bQP/c20E/3Jr + BP9vagP/b2oD/29qA/9vawL/cGwD/3BsA/9vbAP/cG4D/3FvA/9zcgL/d3cE/3RzBf9vbQX/bWwD/21o + Bf9rZQf/aGEE/+Lh2dvh393D0c3KsMTAvKO2sq2V6ejm3RMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAA + AEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI2trZ6cvIxKLTz8yt4N3avfj1 + +NFsgkD5RWQJ/05vEf9RdRH/Vn0Q/1qEEf9chRD/XIEQ/1x9D/9cdg7/XHEO/1lsDP9YaAr/WmkK/1xq + Cf9fbQj/YXAH/2JwB/9icAb/ZXAG/2pxB/9tdQb/cHkG/3Z8Bf96fwT/fYAD/3+CBP+CggT/gYID/4CC + Bf+TlDH/g4UT/3Z5AP9zdAT/eHYE/3l5Bf95eQX/eHgE/3l5Bf95eQX/fXsD/4WCBP+MiQP/k48E/5uW + Bv+alQX/oJsG/56aBP+NiQP/i4UF/4yEBv+MhQb/jYUE/4+HA/+PhwT/jYQE/4iBBf+IgAT/ioID/46D + BP+QhQT/j4UE/42BA/+LfwT/iX4E/4d8A/+KfwT/jIEF/4Z8Bf9/dQP/f3QE/4B1Bf9/dAT/f3QE/35z + BP99cgP/e3ED/3pwBP96cAT/eG0E/3RsBP9ybAP/cWoD/29qA/9vagP/b2oD/25rA/9vbAP/b2sC/29s + A/9wbQP/cXAC/3R0A/91dQP/b24D/2xrBP9raQT/a2UE/2ljBf9mYQX/4uDZ2+Hf3cPRzcqwxL+8o7ay + rZXp6ObdExIR2gAAAJkAAACDAAAAcQAAAGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAA + AD4AAABUAAAAbQAAAMja2tnpzMjEodTQzKzg3dq9+PX40WuBP/lEYwj/T24R/1FzEP9VfQ//WoMP/1yE + D/9agRD/W3wO/1t1D/9ccQ3/WmwK/1hoCv9ZaAn/XGoJ/19sCf9hbQn/Ym8H/2JwBv9lcAb/anEH/21y + B/9xeAj/dXsH/3p8BP99gQT/foEE/3+BBP9+gQL/gYIH/5SUMv+Bgw7/dXgB/3JzBP93dQX/eHgF/3h5 + BP94eAT/eHgE/3h4BP9+fAT/hoIF/42JA/+UkAT/mZUH/5eTBf+hnQT/mpUF/4yIBP+LhAX/i4QF/4qE + BP+LhQX/j4cD/46HBP+KggX/h38D/4d/BP+KggP/jYIE/46CBP+NggT/ioAE/4l/A/+HfQT/hnwE/4t/ + BP+KgAT/g3kD/350BP9/dAT/f3QE/390BP9+cwP/fnME/31yBP96cAT/enAE/3lvA/91bgP/c2wF/3Jr + BP9xagP/b2oD/29qA/9vaQP/b2oD/29sAv9uawL/b2wD/3BtBP9ycQP/dXQD/3JyAv9sawP/a2oD/2lm + BP9oZAX/ZmIE/2RgA//i4Nnb4d/dw9HNyrDEv7yjtrKtleno5t0TEhHaAAAAmQAAAIMAAABxAAAAYwAA + AFUAAABHAAAAOgAAAC0AAAAXAAAAHAAAACYAAAAxAAAAPgAAAFQAAABtAAAAyNra2enMyMSh1NDMrODe + 27359fnRbIE/+URjB/9NbBD/UXIQ/1Z6D/9ZgRD/W4MP/1uAD/9cewz/XXYL/1xxDP9abAr/WGgJ/1lo + Cv9baQj/XmsJ/2BtB/9hbwb/Ym8G/2VvBf9qcQb/bHQF/3B2Bv90eQb/eX0E/3x/BP99gAT/foED/31/ + Av+Bgwr/lJQ0/3+BDf91dwP/cnEE/3Z1BP93dwX/eHcF/3d3BP93dwT/eHgF/358A/+GgwT/jYkE/5SQ + Bf+YlQX/l5QF/6GeBf+UkAT/i4UE/4uEBf+LgwX/ioIF/4qEBP+MhgT/jIUE/4iABP+GfwP/h4AE/4qB + BP+NggT/joIE/42BBf+KgAX/iH4E/4Z8A/+GfQP/ioAE/4d9Bf+AdgT/f3QE/390BP9/dAT/f3QF/35z + A/99cgT/fHEF/3pwBP96cAX/dW4E/3RtBP9zbAT/cGoD/3BqA/9vagP/bmoC/29rA/9vawP/bmsD/25r + Av9vbAP/cG4E/3NyA/90cwP/b24D/2tqA/9raQP/aWUE/2diBf9lYAX/ZF4D/+Lg2dvi393D0c7KsMS/ + vKO2sq2V6ejm3RMSEdoAAACZAAAAgwAAAHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAA + ADEAAAA+AAAAVAAAAG0AAADI2trZ6c7JxaHV0cys4d7bvvn2+dFsgT/4RGEG/01sD/9RcQ//VXkO/1iA + EP9bgg//XH8O/1x6Df9ddgr/W3EL/1psCv9YaAn/WWgK/1ppB/9dagj/X2wG/2FvBf9ibwb/ZG8F/2lw + Bv9scwX/cHYG/3R5Bv94fAT/e34D/3yABP9+gQP/fH4B/4KDDP+TlDP/fX8K/3R1A/9xcQT/dHUE/3d3 + Bf93dwX/d3YE/3d2BP94dwX/fnwE/4aDA/+OigT/lZAG/5eTBP+YlAX/n50E/5GMBP+KgwX/ioMF/4qD + Bv+JgQb/ioIE/4qEBP+KggP/h34D/4Z9A/+HfwX/ioAE/42CBf+OggT/i4AF/4l+BP+HfAT/hHsD/4Z9 + A/+KgAT/hXwF/311BP9/dAT/f3QE/390BP9/dAX/fXID/3xwBP97cAX/enAD/3lvA/90bQT/cmwE/3Js + BP9xaQP/bmoD/29qA/9uagP/bmsC/29rA/9uawP/bmsC/29sA/9xbgP/c3MC/3NyA/9sbAL/a2gC/2lm + A/9nYwT/ZGEF/2NfBP9iXAL/4uHZ2+Lf3cPRzcqxxL+8o7ayrZXp6ObdExIR2gAAAJkAAACDAAAAcQAA + AGMAAABVAAAARwAAADoAAAAtAAAAFwAAABwAAAAmAAAAMQAAAD4AAABUAAAAbQAAAMja2tnpzsnGodXR + zKzh3tu++fb60WyAPvhEYAX/TWsN/09wD/9VeA//WX4O/1yADv9cfg7/WnoM/1x2Cv9bcAn/WWsJ/1dn + Cv9YZwj/WmgG/11pCP9ebAj/YG4F/2FuBf9jbgb/aHAF/21zBv9udgb/dHgE/3h7Bf97fgP/fIAD/32A + A/97fQD/g4UQ/5GRMv97fQb/dHQE/3BxBf9zcwT/dnYE/3Z1BP92dQP/dnUE/3l3Bf9/fAT/h4QE/46K + BP+VkAb/lpIE/5qWBf+emwT/jogD/4mDBf+IggX/iIEF/4mABP+KgwT/ioME/4eAA/+FfAL/hnwE/4h+ + BP+KgAT/i4EF/4uABP+JfgT/h30D/4V7BP+EegX/iH8D/4qABP+DeQP/e3MD/31zBP9+cwT/fnMD/35z + A/99cQX/e3AF/3pwBP94bwP/d24D/3NtBP9ybAT/cmoE/3BpAv9uaQL/bmkC/25qAv9tagL/bmsD/25r + A/9uawL/b2wD/3FuA/90cwP/cG8C/2tpAv9oaAH/Z2QC/2ViBP9iYAP/YV4E/19aAv/i4dnb4d7dw9HN + yrHEv7yjt7Ktluno590TEhHaAAAAmQAAAIMAAABxAAAAYwAAAFUAAABHAAAAOgAAAC0AAAAXAAAAHAAA + ACYAAAAxAAAAPgAAAFQAAABtAAAAyNva2enQy8ai1tPOreHe27759frRa389+ENgBf9Nag3/UG8N/1N3 + D/9YfA//W38N/1t9Df9Zegz/XHYK/1twCf9Zagn/V2cJ/1ZlB/9aZgf/W2kG/11rBv9gbQX/YG0E/2Nt + Bf9obwX/bHIG/291Bv90eAT/eHkG/3p8BP98gAL/fH4C/3l7AP+EhhX/kJAx/3t8A/9xcwP/cHAF/3N0 + BP92dAX/dXQE/3V0BP91dAT/eHcF/399BP+GhAT/j4oF/5WRBP+VkAX/nJgF/5qXA/+MhQX/iYIF/4iB + Bf+GgAb/iIAF/4iBBP+HgAX/hX0E/4R8A/+GfAP/iH4E/4qABP+KgAT/iYAE/4l+BP+FfAP/g3oE/4V6 + Bf+KfwX/iH0F/391Bf98cgT/fXME/35zBP99cwT/fXID/3xxBf96cQX/eW8D/3dtBP90bgX/c20E/3Jr + A/9vagL/bmoD/25pAv9uaQL/bmoC/25rA/9uawP/bmsD/25rAv9wbQL/cnED/3NyBP9tbAP/amgC/2Zm + Av9kYwT/Y2AD/2JfBP9gXQT/XlgD/+Lh2dvh3t3D0c3KscTAvKS4sq2X6ejn3RMSEdoAAACZAAAAgwAA + AHEAAABjAAAAVQAAAEcAAAA6AAAALQAAABcAAAAcAAAAJgAAADEAAAA+AAAAVAAAAG0AAADI29rZ6dDL + xqHW086s4d/cvvr2+tFrfz34Ql4G/0xpDf9Pbg3/VHUO/1h7Dv9afwz/W3wM/1p5C/9adgn/Wm8I/1lq + CP9WZgn/VmUH/1lmCP9caAf/XmoG/2BrBv9hawb/Y24E/2hwBP9scQX/b3QE/3N3BP93egX/ensD/3p+ + A/97fgP/eHsA/4aGGv+Ojy//eXwC/29xA/9vcQT/c3QE/3V0BP91dAT/dHMD/3V0BP93eQP/gH0D/4iE + BP+PiwX/k5AF/5OPBP+dmQX/l5IF/4iBBf+HgAX/h4EF/4aABP+GfwT/hn8D/4V9A/+DegP/gnoD/4R8 + A/+GfwT/iX4E/4l+BP+IfgP/iH0D/4R6BP+DeQP/hnsE/4p/BP+DewX/e3MF/3xyA/99cgP/fXID/3ty + A/97cQT/enAE/3pwBP94bgT/d20F/3NtBP9yawP/cmoD/29pAv9uaQL/bWgC/21qAv9tagP/bWoD/21q + Av9uawP/bmsC/3BtAv9zcgP/cXAD/2tqA/9oZgP/ZWQE/2NiBP9hXgP/YFwD/15bAv9bVwH/4eDZ2+Hf + 3cTRzsuyxcC8pLeyrZbp6OfdExIR2gAAAJgAAACCAAAAcAAAAGIAAABUAAAARgAAADoAAAAtAAAAFgAA + ABsAAAAlAAAAMAAAAD4AAABUAAAAbQAAAMjb2tnp0MzHodbTz63h39y9+fb60mp+PPlBXQX/S2gN/09s + Df9Tcw3/V3oN/1p8DP9afAz/WnkK/1pzCf9abgn/WWoI/1ZmCP9WZQf/WWYI/1xoB/9daQj/XmoG/2Bs + Bv9jbQT/Z28F/2lxBf9vdAT/cncD/3Z6A/93fAP/eX0C/3p9Av93egD/iIke/4yMLP94eQH/bnED/25w + A/9ycgT/dHMF/3RzBf90cwP/dXQD/3l5BP+BfgT/iIQE/4+LBP+TjwX/lI8E/56ZBf+RjgT/hoEE/4Z/ + Bf+GfgT/hX0E/4V+A/+FfQP/gnoE/4F4Bf+CeAX/hXsE/4Z+BP+IfgT/iX4F/4h9A/+FegT/g3gD/4N4 + A/+HfAP/ioAE/4B4A/96cQP/e3ID/3txBP97cQT/e3EE/3pwBP96cAT/enAE/3huBP93bQX/c2wF/3Jr + A/9vagP/bmkD/21oAv9uaQP/bWkD/21pA/9saAH/bWoC/25rA/9vbAP/cnAC/3JxA/9tbQP/aWcC/2dl + A/9lYwP/Yl8E/2FdA/9fWwP/XVkD/1pWAf/i4Nnb4d7dw9HPy7LFwLykt7Ktluno590TEhHaAAAAmAAA + AIIAAABwAAAAYgAAAFQAAABGAAAAOQAAACsAAAAWAAAAGwAAACUAAAAwAAAAPQAAAFMAAABsAAAAyNva + 2enQzMeh1tLOreDe2r349PrRan47+UJdAv9LaA7/Tm0N/1JzDP9WeQz/WnsM/1p7DP9ZeAr/WnMJ/1pu + Cf9Zagj/VWUH/1ZlB/9YZgj/WmcH/1xpCP9eagb/X2wF/2JsBP9obgb/anEF/250A/9zdwP/dXoC/3h8 + Av96fAL/enwD/3Z5AP+JiyP/i4so/3Z4AP9tbwL/bm8D/3JxBf9zcwX/c3IF/3RzBf91dAP/eXkD/4F/ + BP+IhQX/kIwF/5KPBf+UkAT/nZgF/46JBP+GfwT/hn8F/4Z+BP+DfAX/g3wE/4J7A/+AeQX/gHgF/4N5 + Bf+FewT/hnwE/4h+BP+HfgP/hnwD/4R6BP+CeAT/hHkD/4l/BP+IfgT/fXUD/3tyA/96cQT/e3EF/3tx + Bf96cAT/enAE/3pwBP95bwX/eG4E/3VsBf9ybAX/cGoD/29qA/9taQP/bWgC/25pA/9taAP/bWkD/2xp + Av9tawP/bWsE/29tA/9ycAT/cG4E/2poA/9oZgP/ZmQD/2RhA/9hXgT/X10C/1xZAv9bWAP/WVUC/+Hf + 2Nrg3tzC0c3LssTAvKS3sq2W6ejn3RMSEdoAAACXAAAAgQAAAG8AAABhAAAAUwAAAEUAAAA5AAAALAAA + ABYAAAAbAAAAJQAAAC8AAAA8AAAAUgAAAGsAAADI3Nva6dDMxqHU0s2s393ZvPfz+M5rfjv4Q10C/0tn + Df9Oawz/UHEL/1V3C/9Zegv/WXoL/1h3Cf9acwn/Wm4I/1hpB/9VZQf/VWQG/1dlBv9ZZgf/XGgG/15q + Bv9fawT/Y2wE/2htBf9qcAP/bXQD/3J3A/91eQL/d3wD/3l7A/95ewP/dXgA/4mLJ/+IiSX/dHYA/2xv + Av9tbwP/cHAD/3JyBP9zcgT/c3IE/3R0BP95eAP/gH4E/4mGBv+Piwb/kI0F/5WSBf+blwX/i4UF/4Z+ + BP+EfQT/g3wF/4F7Bf+BegT/f3gF/353BP9/dwT/gnkG/4N8A/+FfQT/hn4D/4V9A/+EewP/g3kE/4F3 + Bf+DegT/iX8E/4V8A/98cQT/e3AE/3pwBP97cQX/enAE/3pwBP96cAT/eG8E/3dtBf91bQT/cmwD/3Fq + A/9vagP/bmkC/21oAv9taAL/bGgC/2xoAv9saAL/bWkC/21rA/9sawL/bm4C/3FvA/9ubQP/aWcD/2hl + A/9lYgT/Y2AE/2FdA/9eWwL/W1kC/1pXAv9YVAL/397X19/c28DQzMmxw8C7pLeyrpfp6OfdExIR2gAA + AJcAAACBAAAAbgAAAGAAAABSAAAARAAAADgAAAArAAAAFAAAABkAAAAjAAAALgAAADoAAABPAAAAaQAA + AMjc29rp0MvGodTQy6rd2ti59PD0yWp8O/dDWwL/TGYM/09pDP9Rbgz/VHUK/1h6Cv9YeAr/WHUJ/1px + B/9Ybgf/VmgG/1VlBv9VZAb/V2UG/1pmBv9cZgb/XWkG/19rBP9jbAT/aG0D/2pwA/9scwT/cHYC/3Z3 + BP92eQX/eHoD/3h6Af91dwD/iowr/4aHIf9zdQH/am0D/21uBP9wcAP/cXED/3JyBP9zcgT/dHME/3l5 + A/+AgAX/iYYG/4+LBP+QjAP/lpME/5eTBf+IgQX/hH0E/4J9BP+BfAT/gHoF/4B5Bv99dgT/fXUE/391 + BP+CeAT/g3sE/4V8A/+FfAP/hHoE/4N5BP+BdwX/gHYE/4V7BP+IfwT/f3cE/3lvBP96cAT/enAE/3pw + BP96cAT/eXAD/3hvBP92bwT/c20D/3NsBP9xagP/b2oD/29qAv9uaQL/bWgC/21oAv9saAL/bGgC/2xo + Av9taQL/bGoC/2xrA/9vbwL/b28D/2ppAv9oZgL/ZmUC/2NiA/9hXwT/YVwD/11ZAv9bWAP/WVUC/1dS + Av/c2tPT3NnYvc7Lx67Dv7ujt7Kuluno590TEhHaAAAAlQAAAH8AAABsAAAAXwAAAFAAAABCAAAANgAA + ACkAAAAUAAAAGgAAACIAAAAsAAAAOAAAAE0AAABnAAAAx9zb2unPy8Sf0s3JqNnX1LXw7PDCaHo69UJb + Av9MZAv/TmkL/1BsC/9Vcwv/V3cK/1d3Cv9XdQj/WXIH/1dtB/9WaAb/VGQF/1NkBv9XZAb/WmUG/1xn + B/9daAT/YGoE/2JrA/9mbAP/aW8C/2xxBP9vdQP/c3cE/3Z4BP94eQT/eHgE/3R3AP+LjS//g4Uc/3N1 + AP9pbQL/bW0D/29vA/9vbwP/cHAD/3FyA/90cwT/eXkE/4CABf+Jhgb/jowF/46LBv+WkwX/k48E/4Z/ + Bf+DfQX/gnwE/4F7Bf+AeQb/fncF/3l0BP97dQT/fncE/4B4BP+DewP/hXsF/4V6BP+DeAX/g3cF/4B2 + Bf+AdwX/h34E/4Z+Bf99cwT/em8E/3pwBP96bwP/em8D/3pwBP94bwP/dm8E/3RuBf9zbgT/cmwD/3Bq + A/9uaQL/bmkC/25oA/9saAL/bGgC/2xoAv9saAL/bGgC/2xoA/9raQL/bWwC/3BvAv9tbAP/Z2YC/2Zl + A/9kYwP/YmAC/19eA/9eWwT/W1kB/1lWAv9XVAT/VVEB/9fWzszY1tS4y8fEq8K9uKG2sq2V6ejn3RMS + EdoAAACTAAAAfAAAAGkAAABcAAAATgAAAEAAAAA0AAAAKAAAABIAAAAYAAAAIAAAACkAAAA1AAAASgAA + AGMAAADG29rZ6M3JxJ/Oysam19PPsOzn67hgcy32OFQA/0BcAP9CXwD/RWUA/0prAP9MbgD/TG0A/01t + AP9QagD/TWQA/0xgAP9KWwD/SlsA/01bAP9QXAD/Ul4A/1VgAP9VYAD/V2IA/1xkAP9hZwD/ZGoA/2dt + AP9rbwD/bnAA/29xAP9vcAD/bG8A/4SHJf94egv/aWwA/2FjAP9jZgD/ZmcA/2dnAP9oaAD/aWkA/2xs + AP9xcgD/e3oA/4KBAP+HhQD/iIUA/5KPAP+HgwD/e3QA/3p0AP96dAD/eXIA/3ZvAP9xbAD/cGwA/3Ns + AP92bwD/eXEA/3xzAP99cwD/fXIA/3twAP96bwD/eW0A/3txAP+AeAD/fHQA/3FpAP9yaAD/cmgA/3Fn + AP9xZwD/cmgA/3FnAP9tZwD/bGYA/2tlAP9qYwD/Z2IA/2ZhAP9mYQD/ZGAA/2RgAP9jYAD/ZGAA/2Rg + AP9jXwD/Y2AA/2NiAP9mZgD/amcA/2NhAP9fXQD/XVsA/1tZAP9ZVwD/VVUA/1NRAP9RTgD/UEwA/05L + AP9MSAD/0c/GxNPQzrLIxMCnwLu2n7Wwq5bp6OfdExIR2QAAAI8AAAB5AAAAZgAAAFcAAABKAAAAPAAA + ADEAAAAmAAAAEAAAABUAAAAeAAAAJgAAADEAAABGAAAAXgAAAMXb2tnpy8fDn8vGwqLTz8qp3dnVssnK + u8fGybbRy9C82M7SvtzQ1cDg0tfB4tPYweLT18Hi0tjB4tPXweLT1sHi09XB4tLUwOLS1MDi0tTB4tPU + weLT1cDi1NXA4tTVwOLU1sDi1dbB4tbXweLX18Hi19jB4tjYweLY2MHi2NjB4tjYwOLY18Di3dzJ4dnZ + xOHX1r/h1tW/4dbWwODW1r/g19a/39bWv9/W1r/f19a/39jXv9/Z2L/f29m/39vZv9/c2r/e3ty/3tva + v97Z17/e2de/3tnXv97Z17/e2Na/3tfWvt7X1r/e2Na+3tjWv97Z17/e2de+3trXv97a177f2de/39nW + v9/Z1r/f2de+39rZv9/Z2L/f19bA39fWv9/Y1b/f2NW/39jVv9/Y1b/f2NW/4NjVv+DX1b/g19W+4NfU + vuDW1b/g1tW/4NbVv+DW1L/g1tS/4NbUvuDV077g1dO+4NXTvuDV077g1NO+4dXUvuHV1L7h1NO+4dPS + vuHT0r7h09G+4dLRvuHS0b3h0M+94M7Mu93LybjZx8W008G+rcvSzsu2y8fFq8O/vKO9uLSdtrGrlevp + 5twTEhHYAAAAiwAAAHIAAABgAAAAUwAAAEYAAAA4AAAALQAAACMAAAAOAAAAEwAAABsAAAAjAAAALgAA + AEEAAABWAAAAxdLRz93LxsGcyMTAn87KxaTU0Mqq3trYsOPg4Lfn5OS+6ubowuzo6sXs6evG7Onrxuzp + 68bs6evG7Onrxuzp68bs6evG7Onrxuzq68bs6evG7errxuzp68fs6evH7Onrx+zq68br6uvG7Orrxuzq + 68bs6uvG7Orrxuzq68bs6erG7Onqxuvo6sbq6OjF6efpxero6sTq6OnE6+jpw+ro6cPo5ufC6ebnwejl + 58Lo5ufB6Obnwefk58Hn5OfB5+Tnwefk58Hm5efA5uXnwOfl58Dn5efA5+XnwOfm58Dn5ufA5+bnwOfm + 58Dn5ufA6ObnwOfm58Dn5efA5+bnwefm58Hn5ufB5+bnwefm58Hn5efC6Obnwejm58Hp5ufB6Obnwujm + 58Lo5ufC6Obnwujm6MPo5ujD6Obow+jm6MPo5+jD6ejpw+ro6cPq6OnD6ujpw+ro6cPp5+jD6efow+fl + 58Tn5efE5+XnxOfl58Tm5ebE5uXmxObl5sTm5ebE5uXmxObl5sTn5ebF5+Xmxefl5sXn5ObE5OLiwuDf + 4L7d29q419TUscvHxavFwb2lwLu3oLq1sZu3sayV4uDf0REQENYAAACEAAAAbQAAAFoAAABNAAAAQQAA + ADUAAAAqAAAAIAAAAA0AAAASAAAAGQAAACAAAAApAAAAOgAAAE8AAACtcG9u5NzZ1a/EwLmYy8fBoM7J + xKPRzsmo1dLOrdfU0LDZ1dOz3NfVtdzZ1bbc2dW23NnVttzZ1bbb2NW23NnVttzY1bbb2NW23NnVttvY + 1bbc2dW23NjUttvY1Lfa2NS33NnVttzZ1bbb2dW23NnVttzZ1bbc2dW229nUttvZ1Lbb2NS22tfVtdvX + 1LXZ1tO02tbTs9nW07HZ1dOy2NXRsdfU0LDX1NCw1tLQsNXTz6/V08+v1dPOrtXSzq7V0s6u1dLOrtXS + zq7W0s6u1tLOrtbSzq7W0s6u1tLOrtbSzq7W0s6u1tLOrtbSzq7W0s6u1tLOrtbSzq7V086v1dPPr9XT + z7DW0tCw1tLQsNbT0LDX1NCw19TQsNfU0LDX1NCw19TQsNfU0LHX09Cx19PQsdfT0LHX1NCx19XRsdjV + 0rHY1dKx2NXSsdjW0rHY1dKx2NXRsdfU0LHX09Cx1tLPstbSz7LW0s+z1dHPs9TRzrPU0c2z1NHNs9TR + zrPU0c2z1NHOtNTRzrTU0c601NHOtNPQzbPRzsyzz8zJsMzJxazIxcGpw7+8o8C7t6C9uLOdtK+qldLN + yaaHhoXfBQUFxAAAAHkAAABkAAAAUwAAAEYAAAA7AAAAMAAAACYAAAAdAAAACwAAAA8AAAAVAAAAHAAA + ACUAAAAyAAAARwAAAHkSERDm29nX19DMxpzDvreXysS+ncrIwqDNyMSjzsvFpc/Lx6bRzcin0c3Ip9HN + yKfRzcin0c3Ip9LOyKfSzsin0s7Ip9LOyKfRzcin0s7Ip9LOyKfSzsin0s3IqNHNyajRzsin0c7Ip9HO + yKfRzsin0c7Ip9HOyKfRzsmn0c7Jp9HMx6fQzMimz8vHps/LxaXPy8WkzsrFos7JxKPMxsOizMbBocvH + waDKx8GgycXAoMnFvp/Jxb+fyca/n8nFv5/JxL+fycS/n8nEv5/Jxr+eycW/nsnFv57Jxb+eycW/nsnF + v57Jxb+eycW/nsnGv57Jxr+fyca/n8nGwKDJxcCgycXBocnFwaHJxcGhysbBoMzGwaHMxsGhzMbBocvH + waHLxsGhy8XCosvFwqLLxcKiy8XCoszJw6LNycSizcnEos3JxKLNycSizcjEos3Hw6LNx8OizMfCosvG + waPJxcGjycXBo8jEwaTIxMCkx8S/pMfEv6THxMCkyMTApMfDv6XHw7+lx8O/pcfDv6XHw7+lx8O/pcXB + vaXDwLykwr66o7+7t5+9ubWdu7axnLSvqZW+urSV4+DeyyspKO0AAAChAAAAbAAAAFoAAABLAAAAQAAA + ADUAAAArAAAAIgAAABkAAAAJAAAADQAAABMAAAAZAAAAIQAAACoAAAA6AAAAXgMCAqdVVVT13tzZz+fk + 3arHwruWwr63lcPAuZbFwbuXx8G8mMfCvJjHwbyYx8G8mMfBvJjHwryYyMO8mMjDvJjIw7yYyMO8mMfC + vJjIw7yYyMO8mMjDvJjIxLyZx8S9mcfEvJnHw7yYx8O8mMfDvJjHw7yYxsG7mMbBu5jGwbuYxsC6l8XA + upbDvrmVw764lcG8tpTBu7WTwLu0k765spK+ubGQvbexj763sY+9uLGPvbiwjry4r467t6+Ou7evjru2 + r467tq+Ou7avjru3r468tq+Ovbavjb22r428tq+NvLavjby2r428tq+Nu7avjru2r467tq+OvLawj7y2 + sJC8tbCQvLawkL23sZC+ubGPvrixkL64sZC+uLGQvriykb63spG+t7KRvreykb63spG/ubOQwLu0kcC7 + s5HAu7ORwLuzkcG6tJLBubSSwbm0kr+5s5K+uLKTvLexk7u2sZS7trGUurWwlLm1sJS4ta+UurWvlLm1 + sJW5tK+VubSvlbm0r5W5tK+VubSvlbizr5W4s66WuLOulrezrpa3sq2VtrCrlLSvqpK3sa2T1tHOpOPi + 38hsbGrzCQgIwQAAAHsAAABfAAAATgAAAEIAAAA4AAAALwAAACUAAAAeAAAAFQAAAAgAAAALAAAAEAAA + ABQAAAAbAAAAIwAAAC4AAABLAAAAYQAAAKk3NzfxgoF/4eHg3tH39vPS8vHu0vPx79Lz8u/S8/Hv0vPx + 79Lz8e/S8/Hv0vPy79Lz8u/S8/Lv0vPy79Lz8u/S8/Lv0vXy79L08u/S8/Lv0vPy79Lz8u/S8/Lv0vPy + 79Lz8u/S8/Lv0vPy79Ly8e7S8/Hu0vPw7tLz8O/S8/Hu0fLx7tDx8O3Q8e/tz/Hu7NDv7uvQ7+3rz/Du + 687w7evO8O3rzu/t687w7uvO7+3rzu/t687v7evO7+3rzu/t687v7evO7+3rzu/t687v7erN7+3qzfHt + 683y7uzM8u7szPLu7M3y7uzN8e7szfDt7M7x7ezO8e3szvHu7M7x7+zO8e/szvHv7M7x7+zO8e/szvLv + 7M7z7+3O8+/tzvPv7c7z7+3O8+/tzvPw7c7z8O3O8/DtzvPw7c7z8O3O8+/tz/Pw7c/z8O3P8vDsz/Lv + 7M/y7+zP8e7sz/Hu7M/x7uzP7+7r0PHu7M/x7uvQ8O3r0PDt69Dw7evQ8O3r0PDt69Dw7evQ8O3r0fDt + 69Hw7evR8O3r0fDt69Dw7evR8/Dt0Ojl49CPjYzdQD8/8gEBAcMAAAB5AAAAXwAAAFAAAABCAAAAOQAA + ADAAAAAoAAAAIAAAABkAAAASAAAABgAAAAgAAAANAAAAEAAAABUAAAAcAAAAJAAAADcAAABMAAAAYAAA + AIYEAwO9KSko6TEwMOMvLy7jLy8u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8u + LuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8uLuMvLi7jLy4u4y8vLuMvLy7jLy4u4y8u + LuMvLy7jLy8u4y8vLuMwLy7jLy8u4y8vLuMvLy7jMC8u4zAvLuMwLy7jLy8u4y8vLuMvLy7jLy8u4y8v + LuMvLy7jLy8u4y8vLuMvLy7jLy8u4y8vLuMvLy7jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAv + L+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy/jMC8v4zAv + L+MwLy/jMC8v4zAvL+MwLy7jMC8u4zAvLuMwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MwLy7jMS8v4zAv + LuMwLy7jMC8u4zAvLuMwLy7jMC8u4zAvLuMwLy/jMC8v4zAvL+MwLy/jMC8v4zAvL+MxMDDjLS0s5woJ + CMwAAACWAAAAdAAAAFsAAABOAAAAQgAAADgAAAAwAAAAKAAAACIAAAAbAAAAFAAAAA4AAAAHAAAACAAA + AAwAAAAQAAAAFQAAABsAAAAiAAAALAAAADkAAABGAAAAUAAAAGAAAABsAAAAcAAAAHIAAABzAAAAdQAA + AHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAA + AHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHcAAAB2AAAAdgAA + AHYAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAA + AHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAA + AHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAA + AHcAAAB3AAAAdwAAAHcAAAB3AAAAdwAAAHYAAAB3AAAAdgAAAHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAA + AHYAAAB2AAAAdgAAAHYAAAB2AAAAdgAAAHUAAAB0AAAAbAAAAGAAAABXAAAATAAAAEIAAAA4AAAAMQAA + ACsAAAAkAAAAHwAAABkAAAATAAAADgAAAAUAAAAGAAAACQAAAAwAAAAQAAAAFQAAABoAAAAhAAAAKAAA + ADEAAAA4AAAAPwAAAEMAAABIAAAASwAAAEwAAABOAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAA + AFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAAUAAAAFAAAABQAAAATwAA + AE0AAABJAAAARQAAAD4AAAA4AAAAMwAAAC0AAAAoAAAAIwAAAB0AAAAYAAAAEwAAAA4AAAAKAAAABAAA + AAUAAAAHAAAACQAAAAwAAAAPAAAAFAAAABgAAAAdAAAAIgAAACYAAAArAAAALgAAADEAAAAzAAAANQAA + ADYAAAA3AAAAOAAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANwAA + ADcAAAA3AAAANwAAADcAAAA3AAAANwAAADcAAAA3AAAANgAAADMAAAAyAAAALgAAACoAAAAnAAAAIwAA + AB8AAAAbAAAAFgAAABEAAAAOAAAACwAAAAgAAAACAAAAAwAAAAUAAAAHAAAACQAAAAsAAAAPAAAAEwAA + ABUAAAAYAAAAHAAAAB8AAAAhAAAAJAAAACYAAAAnAAAAKAAAACkAAAAqAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAAACkAAAApAAAAKQAA + ACkAAAAoAAAAJgAAACUAAAAjAAAAIAAAAB4AAAAaAAAAFwAAABQAAAARAAAADQAAAAoAAAAJAAAABgAA + AAEAAAACAAAAAwAAAAQAAAAHAAAACAAAAAsAAAAOAAAAEAAAABEAAAAVAAAAFwAAABkAAAAcAAAAHQAA + AB0AAAAfAAAAHwAAACAAAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAA + AB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAfAAAAHwAAAB8AAAAdAAAAHQAAABsAAAAYAAAAFgAA + ABMAAAARAAAADwAAAA0AAAAJAAAABwAAAAcAAAADAAAAAQAAAAEAAAACAAAAAwAAAAQAAAAFAAAABwAA + AAkAAAALAAAADAAAAA4AAAAQAAAAEgAAABQAAAAVAAAAFQAAABcAAAAXAAAAGAAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAAABcAAAAXAAAAFwAA + ABcAAAAXAAAAFwAAABUAAAAVAAAAEwAAABEAAAAPAAAADgAAAAwAAAAKAAAACAAAAAYAAAAFAAAABAAA + AAIAAAABAAAAAQAAAAEAAAACAAAAAwAAAAMAAAAFAAAABgAAAAcAAAAIAAAACgAAAAsAAAAMAAAADQAA + AA8AAAAPAAAADwAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAA + ABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAPAAAADwAAAA4AAAANAAAACwAA + AAsAAAAJAAAACAAAAAYAAAAFAAAABAAAAAMAAAADAAAAAQAAAAAAAAABAAAAAQAAAAEAAAABAAAAAgAA + AAIAAAADAAAABAAAAAQAAAAFAAAABwAAAAcAAAAIAAAACQAAAAkAAAAJAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAkAAAAJAAAACQAAAAcAAAAHAAAABgAAAAUAAAAEAAAABAAAAAIAAAACAAAAAgAA + AAEAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAIAAAADAAAAAwAAAAQAAAAFAAAABQAA + AAYAAAAHAAAABwAAAAcAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAA + AAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABgAAAAYAAAAGAAAABwAAAAcAAAAHAAAABQAA + AAUAAAAFAAAABAAAAAMAAAADAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAA4AAAAAAAAAAAAAAAAAAAACgAAAAwAAAAYAAAAAEA + IAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAABgAAAA4AAAAXAAAAIAAAACcAAAArAAAALAAA + ACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAA + ACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAAACwAAAAsAAAALAAA + ACwAAAAsAAAALAAAACwAAAArAAAAJwAAAB8AAAAXAAAADQAAAAYAAAAGAAAADgAAAB0AAAAtAAAAPQAA + AEgAAABOAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAA + AE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABPAAAATwAA + AE8AAABPAAAATwAAAE8AAABPAAAATwAAAE8AAABOAAAASAAAAD0AAAAtAAAAHAAAAA0AAAALAAAAGQAA + ADAAAABHAAAAWwAAAGkAAABwAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAA + AHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABxAAAAcQAAAHEAAABwAAAAaQAAAF0AAABIAAAALwAA + ABgAAAARAAAAJAAAAEEAAABsCgoLpBgYGLIWFxe0FxcXtBcXF7QXFxe0FxcXtRcXGLQXFxi0FxgYtBcY + GLQXGBi0GBgYtBcYGLQXFxi0FxcXtBcXF7QXFxe0FxcXtBcXF7QXFxe1FxcXtRcXF7UXFxe0FxcXtBcX + F7QXFxe0FhcXtBYWF7QWFhe0FhYWtBYWF7QXFxe0FxcXtBcXF7QXFxe0FxcXtBcXF7QYGBi1AQECpgAA + AHkAAABfAAAAQQAAACQAAAAXAAAALAAAAF05OTe7joiApZOMgpSRiICTjIR6kod/dZCEe3KPgHlvjn54 + bY18dWuMeXJni3lyZ4t5cWeLeG5mi3lvZot7cmiKgHdsi4N7coyIf3aMjIJ4jIyFeo2NhnuOjYd8j4+H + fo+Qh3+PkYh/j5KJf4+SiYCPk4uAkJOMgpCTjIKQlIyCkJOLgZCPiH6OjIR6jYuCeIyMg3mNj4d9jpGJ + gI+SioCOfnlzshcXF7UAAABxAAAAUAAAAC4AAAAbAAAAMAkJCYmSjIasnpWJcLKmnYW/s6yQvbKrkbqv + p4+3rKWNtaujjLOqoYuxp5+KsKWdia6knYmuo52JrqKdiq+knYmypp+JtKqjibitp4q7saqKvLKri7yz + q4u7s6yMvLOtjLyzrYy9s66NvbSujb21ro29ta6OvLaujru2ro68tq6Ovbevjry1ro66s6yMuLKri7ex + rIu5s6+Mu7SyjbStqYaelY10n5WIbGdlYb0AAACJAAAAVgAAADMAAAAcAAAAMhESEpKpoZqlsriymXPd + 4+tx4Ofyc+Dn83Xg5/N24ObzeeHl83zi5fJ/4uTyguPk8oXj4vKH4+LyieTg8ozl3/KP5d/yk+bf8pfo + 4PKc6eLyoOrj8qTs4vKo7uLzrfDi8rLz4fK29uHzvPjh88T64fPO++Tz3vvq8+z78/P5+/nz//v98//7 + /vP/+/3y//v38vz77fL3++Lz9vvR8/P5vu7V1rm7qaKbdX98d7UAAACRAAAAWQAAADYAAAAdAAAAMxAQ + EJGwqKKsws7JsEjd5P882d//Pdna/z7Z1/8/2dX/QdnT/0ba0v9K29D/S9vO/07by/9Q3Mn/U9zH/1be + xf9a4cP/XeTC/2Lowv9o78T/cPXH/336zv+M/db/nf/g/7L/6v/F//H/2v/5/+///f/3//z/+f/8//r/ + +v/y/+v/4f/e/7/92v+3/dn/wv7O/8r/sf/V/Zv/2vyO/9f9jP/Q5r7WvbOxgn57d7gAAACRAAAAWgAA + ADcAAAAdAAAAMw8PD5G0q6avxtLPtjzT2f8v0NP/MtDR/zPPz/800Mv/N9DJ/zrQyP880cX/PdLD/0DV + wf9F2cL/St7E/1LlyP9b7M3/ZvLT/3H42P97/d3/gv/g/4v/5P+Z/+j/qf/r/7n/7P/E/+f/x//b/7// + zP+0/L//pfm1/5n3r/+M9qv/ePWs/3P3uP+C+sP/hf3J/5D9y/+q+7n/uO2R/7XXZ//P2a3Zxb27iIB9 + ebkAAACRAAAAWgAAADcAAAAdAAAAMw8PD5G1rqiwx9PQtzjS1f8sz9D/MdDP/zLRzv811M7/OdfP/z/b + 0f9E4dX/TOjY/1Pu3P9a9OD/YPni/2X74f9q/N//bv7d/3T/2/96/9r/gf/X/4r+1P+Q/Mv/kfi//43z + sP+F7p//gOmT/4Hmjf+G5Yr/j+WI/5bmh/+a5ob/nOKG/57ahv+k14n/qdyM/6zmkP+k7pT/n/CW/6Hi + hf/K27fayL+9i4J/e7oAAACRAAAAWgAAADYAAAAdAAAAMw8PD5G3r6qxydXRuT7Y1/8z2dX/Ot3Y/0Di + 3P9F6N//SOrg/0nq2/9M6tb/TujQ/0/myf9R58P/VerB/1zwwv9k9cL/a/fA/2/yuf9w6q//buKh/2vb + lf9r2Y3/dNmM/33bi/+C24f/h9uC/4jafv+K1Hr/ic10/4fFbf+Ivmj/jLhg/5K3Vf+Ttkv/lLVO/5m2 + Vf+kvl3/rsti/7HXbf/S4LzbysLAjYOAfLsAAACQAAAAWgAAADYAAAAdAAAAMw8PD5G4sKyzytfTukbh + 3P853tb/PNvR/z/azf8/2Mj/QNTC/z/Quf9D0bb/Ste4/1Leuv9a5L3/X+S5/1/esP9f1qL/X8+X/2HM + kP9lz4z/bNOJ/3HWiP9314T/ftWD/4PRf/9+yHP/eb5o/3m4Y/97s1//f7Bc/4WwVv+MtVH/j7xS/5DA + W/+TxGT/nMVl/6HDYP+kwFj/qLtS/6mzQP/Qz6LczcfHkISBfrwAAACQAAAAWgAAADYAAAAdAAAAMw8P + D5G5sq60y9bSuz/Kwf8yxLf/NsO0/zvHtv9Bzbv/RtXA/0vZv/9O2rv/Udaz/1PQqf9VyqH/WMia/13L + lf9j0JL/adOQ/27VjP9w04b/cM5+/3DHdf9wwm//e8Nx/4bGcf+CwWX/gb9e/4i/Xv+Mw1z/kMdc/5DM + Yf+Mz27/i8tz/47BbP+PuWD/kbJU/5KoSf+WokH/mJw6/5aRKv/Iw5vc0MzKkYWCf70AAACQAAAAWgAA + ADYAAAAdAAAAMg8PD5G6s6+2zNbRvELFuP84xrb/QM27/0XSvf9J1L3/StK3/0vMrP9MyKT/Ucug/1rR + of9j2KH/a9ye/3Dcl/9x2o//c9eI/3fVgf961Xz/ftV2/4DUcP+F02r/ldRu/5nTbv+JyWX/gcZi/4PH + XP+FwlT/grdU/32pVf98nUn/fJM8/3uLNP98hi//gIMr/4SBKP+IgCf/i4Em/4x8Gv/GvZbd08/Nk4eE + gb0AAACQAAAAWgAAADYAAAAdAAAAMg8PD5G8tbC2ztnTvUrQvv8+yrT/Qsqv/0fMrf9P07H/WN22/1/l + t/9j6rT/au2v/3Lsqf956qP/gead/4LilP+A3Ir/f9N+/33Mc/97xGn/d7th/3KyXf9vr2H/d7Zx/3O4 + cP9pr1n/cadC/3icNP90ji//coYq/3SDJv92giT/d38j/3h8If96eiD/fHgg/4B4IP+DeSD/h3oi/4h2 + F//Eu5be1tHQlYeEgb4AAACQAAAAWgAAADYAAAAdAAAAMg8PD5G8tbG4z9nTvlbXvf9S2rv/WuK//2Hp + wv9o7ML/be2//2zps/9p4KX/adWX/2nMjP9txIH/cLx3/22zbf9nqWP/ZKJd/2GdW/9dmlv/XJlc/1yc + W/9lpVn/drBT/3imO/9xjyf/b4Qk/2yAJf9sfiT/cH4j/3aAIv96fx//ense/3l4Hv95dx3/e3Ue/351 + Hv+Adh//hHcf/4VyFf/Dupbe19PSl4eFgr8AAACQAAAAWgAAADYAAAAdAAAAMg8PD5G9trO40dvVv2Te + v/9Y17P/Vs+o/1PHnP9Tv5T/U7mO/1KzhP9Qqnb/UKFr/1OeZv9anmP/YKFk/2CfYv9cmV3/XJhc/1yY + V/9emFD/ZJpH/2eYOv9wmS//fZ0p/3aPJP9qfSH/an0h/25/IP9yfh7/dX4d/3yAHf99fxz/e3oc/3l2 + HP94dBv/eXMc/3tzHP99dBz/gnQd/4JvEv/CuZXe2NTUmIiGg8AAAACQAAAAWgAAADYAAAAdAAAAMg8P + D5C9t7W50NjSwE+3lv9Bq4f/QqF9/0KddP9FnXL/SJ5w/0uebf9Lmmf/TJVi/1CUYP9ZmV//YqFe/2Wf + Wf9imVL/ZZlM/2eYQ/9olDn/Zo0s/2aFJP90jSL/f5Yj/3KHH/9peRz/bHsb/3F+Gv91gRr/eoAa/4CD + Gv9/gBn/fHsa/3l2Gv94chn/eHEa/3lxGf98cRr/gHIb/4BsEP/BuJTf2dbWmoiGg8AAAACQAAAAWgAA + ADYAAAAdAAAAMg8PD5C+ura60NbQwUmjgP8/nHP/QpVs/0GRZv9EkmX/R5Vn/0uYZv9NlmH/T5Nb/1SU + V/9fmlT/a6JT/26hTP9tm0P/b5g7/2iOL/9khCX/Zn8g/26AHf97jR7/fZAe/3GBG/9reRj/b3wX/3SB + F/95gxj/foMX/4SGGP+Dghj/fnwY/3p2GP93chj/d3AY/3hvGP96bxj/fXAZ/31qDv/BuJTg3NjXm4mH + hMEAAACQAAAAWgAAADYAAAAdAAAAMg8PDpC/ure70NbPwUmedP9Al2r/Qo9k/0OLX/9FjF3/SZBc/06T + Wv9Qk1b/U5JR/1qTTP9onEj/eKVE/3qhPf9vlDH/bIwo/2mDIf9rgBz/bX0Z/3B+GP96ixr/fI4a/3F/ + F/9ufBb/cn8V/3qEFf99gxb/gYUW/4eHFv+Fgxb/f3wV/3t1Fv94chb/d28W/3duFv94bhb/fG4X/3to + DP/AuJTg3dnYm4mHhMEAAACQAAAAWgAAADYAAAAdAAAAMg8ODpC/u7i70NbPwkuabf9ClGH/RI1a/0WH + U/9JiFH/TItP/1GOTv9XlEr/XZdG/2aZQP92ojz/gaY1/3eYLP9uiiP/c4oe/3KEGv9wfxX/bnsU/3KA + Fv99jxj/fo8Y/3KAFP9yfhT/eIMU/4CIFP9+hRP/hogU/4iIFP+FgxT/f3wT/3x2E/95cxT/eHAU/3dt + Ff93bRX/e20V/3hmCv/At5Pg3dnanYqIhcEAAACQAAAAWgAAADYAAAAdAAAAMg4ODpDAvLm80dbPwk6Y + Y/9Gk1b/R4pQ/0iCSP9Kgkb/UIhD/1uUQv9kmz7/ap87/3OhNf94nSz/fZok/3mSIP92ihv/e4wZ/3aF + Fv9xgBT/bnwS/3aFE/+DkxX/hZIV/3aDEv94gxL/f4cS/4SMEv+BhxH/iYoR/4iJEv+EgxL/gHwQ/3x3 + Ef97dBL/eXET/3duE/94bRP/eWwU/3dlCf/At5Ph3trbnYqIhcIAAACQAAAAWgAAADYAAAAdAAAAMg8O + DpDAvLm80dbNw1GUWP9Jkk3/TIhH/0yAP/9Vizz/YJc6/2WYN/9upTX/cKAv/22OJf93kSD/g5oe/3+S + HP97ixf/go0W/3qGFP90gBL/c38R/3+LE/+LmRT/ipUU/3yGEf9+iBH/hY0R/4aNEf+FiQ7/iYsP/4iI + D/+EgRD/f3wP/314D/99dhD/fHMR/3pvEv95bRL/em0S/3dmB//AuJLh3trbnouIhsIAAACQAAAAWgAA + ADYAAAAdAAAAMg8ODpDAvLq80tXNw1SSUP9LkEP/U44//16VOv9hlDT/ZZgx/26sL/9qmCf/ZYIg/3CJ + Hv9/lRz/ipsa/4WSGv+AixX/hI0T/3yGEv94gQ//eYMQ/4aSEv+SnhL/i5YR/4CKD/+Ciw7/ipEQ/4iN + D/+Jiw3/i4wN/4iGDP+EgQ7/gHsN/394Df+BeA//gHUP/35yEP99bhH/fG0R/3loBv/BuZLh39zcn4uJ + hsIAAACPAAAAWgAAADYAAAAdAAAAMg8PD5HBvLq90tXMxFWRR/9Znz3/ZaM6/2CPMP9koC7/aa4t/2WN + JP9kfR//a4Qd/3eNG/+Flhj/j5sX/4iSGv+CihL/g4wQ/32GDv96gg7/focO/42XEP+XoBD/jZUP/4WN + Df+Hjg3/j5QP/4iMDv+NjAz/jooM/4mECv+Cfwz/f3oL/4F4DP+DeA3/gnUN/4BzDv9+bw//fW4P/3xr + BP/Cu5Lh39zcn4uJhsMAAACQAAAAWgAAADYAAAAdAAAAMg8PD5HAvLu+09bMxGOjQv9hpjb/X5cx/2Wu + Lv9ipCn/XH4h/2WAHv9qghz/b4Ua/32NF/+LlhX/kpoW/4mQGP+CiA//g4sN/3+GDP98gwv/g4oM/5Sb + Dv+coQ//jZMN/4iODP+MkQz/kJYN/4uLDP+Rjgr/j4oL/4mDCf+CfQr/gHkK/4J4C/+DeAz/g3YN/4Bz + Df9/bw3/fm8N/35uA//DvZLh3tzcoIuJhsMAAACPAAAAWgAAADYAAAAdAAAAMg8PD5HCvbu91NjMxF+Z + O/9boTD/Zr4z/16YKP9YdR//X3sd/2iDG/9sghj/coUX/4COFP+NlxP/kpkW/4iOFf+CiAz/hYkM/4CF + Cv9/hQn/iI4L/5qeDf+doQ3/jZIL/4uQC/+RlQv/kpQL/46MCf+Ujwn/j4kJ/4mDCP+DfQn/gXkI/4N5 + CP+DeAr/gnYL/39yDP9+bwv/gHEM/4BxAv/EvpHh39vcoIuIhcQAAACPAAAAWgAAADYAAAAdAAAAMg8P + D5DCvby+09TLxGCiOf9hwTH/W5cp/1l3H/9beBv/YXwZ/2uDF/9tgRX/dYUT/4OOEv+Plg//kpcT/4eM + Ev+DiAr/hYkJ/4KFCP+Bhgj/jpII/56hC/+doAv/jZEJ/46RCv+WmAr/k5EJ/5KOCP+Ujwj/j4kI/4mC + B/+DfQb/gXoG/4N5B/+Cdwn/gXQK/35xCv99bwn/gHIL/4FzAP/Ev5Hi3drboYqIhcQAAACPAAAAWgAA + ADYAAAAdAAAAMg8PD5DBvLy/1dzMxWG4N/9WkSX/WoUi/1t8HP9cdxn/YnsW/2uBFP9vgBH/d4UQ/4WN + EP+OlQv/kZUQ/4aKEP+Dhgf/hYgH/4KEB/+Ehgf/lJUH/6GiCv+cnQn/kZEH/5OSCP+ZmAn/ko8I/5WQ + B/+Vjwf/j4gH/4mCBv+EfQX/gnoF/4J4Bv+Cdgf/fnQI/3twCP97cAj/gXQK/4F1AP/Ev5Hi3djbooqI + hcQAAACPAAAAWgAAADYAAAAdAAAAMg8PD5DBvr2/1NbLxlmELP9Wih//XIkg/1x7Gf9cdhb/Y3kU/2x/ + Ef9ufw7/eYQN/4SNDP+Nkwj/kZQQ/4WJDf+EhQX/hoYF/4KEBv+GhwX/mJgG/6OkBv+bmgf/k5EH/5aV + Bv+Zlwf/ko8F/5eRBv+VjgX/jocG/4iBBf+EfAT/g3sE/4J4Bf9/dQb/fHIG/3pvBv97cQb/gnYJ/4J3 + AP/Ev5Di3NnbooqIhcQAAACPAAAAWgAAADYAAAAdAAAAMg8PDpDDvr2/1NXLxleCKf9Xixz/XIoe/1t6 + GP9ddBX/Y3cS/2t8D/9vfQ3/eYIM/4SLC/+MkQj/kJIS/4SGDP+DhAP/hYUF/4KDBf+KiQX/m5oG/6Ok + Bf+YlgX/k5AG/5iWBv+Wkwb/lI8F/5iRBv+Tiwb/jYQG/4d/BP+EfAP/g3sE/4B4Bf99dAT/enAF/3du + Bv96cQb/gHYI/4J3AP/EwI/j3Nnbo4qIhcUAAACPAAAAWgAAADYAAAAdAAAAMg8PDpDDv77A1dXMxliA + KP9Wihv/XYob/1x6Fv9dchP/YnUQ/2t7Dv9tfAz/eIEL/4SKCv+Kjwf/jpET/4KECf+BggP/g4MF/4KC + Bv+NiwX/nZwF/6KiBv+VkwX/k5AG/5iVBv+Tjwb/lY4G/5ePBv+QiQb/i4IG/4V9BP+DfAP/g3oF/391 + Bf96cQT/dW4E/3RuBf94cQb/f3cI/4F5AP/EwY7j29nbpIqIhcUAAACPAAAAWgAAADYAAAAdAAAAMg8O + DpHEwL7A1dbMxll+Jv9XiRj/XooZ/1t6Ff9bcBL/YnMP/2l5DP9segv/d4AJ/4OJCP+KjQf/jpAV/4CC + CP+AgQP/gYIE/4GBBf+PjQX/n50G/6GeBf+Ujwb/lZAG/5iTBf+SiwX/lo4F/5WMBv+PhgX/iIAF/4R7 + A/+DewT/gngF/350BP93cAT/cm0E/3JtBP93cgX/fHcH/4B5AP/Bvo3j29jbpImIhcYAAACPAAAAWgAA + ADYAAAAdAAAAMg4ODpDEwL/A1tbMxll8I/9YhhX/XooY/1x5FP9cbxD/YXEN/2h3DP9teAr/dn8I/4GH + CP+Jiwf/jY4V/36AB/9/gAT/f4AD/4KBBP+Sjwb/oJ4G/56ZBv+SjAf/lY8G/5WQBf+RiQb/l4wG/5OJ + Bf+NgwX/h34E/4N6A/+DeQT/gHYE/3xyBP91bgT/cGsD/3FtBP91cQX/e3gG/3t3AP+9uo3j3NrbpYmI + hcYAAACPAAAAWgAAADYAAAAdAAAAMg4ODpDFwb/A1tfNx1d6If9XhBP/XokW/115Ev9bbg3/X3AM/2d0 + C/9sdgn/dX0H/4GGB/+IiQf/jI0W/3x+Bf9+fgP/fn4D/4OABP+UkQX/oZ4G/5qUBv+RiQf/lY4F/5KL + Bf+Qhwf/looG/5CFBf+LgQX/hnwE/4J4Bf+BdgX/fnME/3pwBP9zbAT/b2oD/3FtA/90cQT/e3oF/3Nw + AP+6uI3j3drbpYqIhcYAAACPAAAAWgAAADYAAAAdAAAAMg8ODpDHw8HB1tfNx1Z4H/9XghL/XogT/1x5 + EP9abA3/Xm4L/2VyCf9qdQf/dXwH/4GEBv+Ghwb/i4sY/3p7Bf98fQT/fHwD/4SBBP+VkwX/oZ0G/5WP + Bv+QiAX/k40F/4+HBf+Rhgb/k4cF/4yCBf+KgAT/hHkE/4F3Bf+AdQT/fHIE/3ZuBP9wawT/b2oD/3Bs + A/9zcQP/eXgF/21pAP+5tY3j3drbpYqIhsYAAACPAAAAWgAAADYAAAAdAAAAMg4ODpDHw8LB2NjOx1Z1 + H/9Vfw//XYYR/1x3Dv9Zag3/XmwK/2NxCP9qcwb/dHsG/3+DBf+EhQb/iYkZ/3h4A/96ewT/enoE/4WC + BP+XlAT/npsF/4+KBf+Phgb/kIkF/4yDBf+RhQb/kIMF/4p/BP+IfwP/gXcF/4B1BP9+cwT/enAE/3Ns + BP9wagP/b2oD/29sA/90cgP/dHMF/2diAP+2s4zj3drcpoqIhsYAAACPAAAAWgAAADYAAAAdAAAAMg4O + DpDHxMPB2NjOx1VyHf9Teg3/XIQQ/1x2Df9ZaQv/XWsI/2JwB/9pcQb/c3kG/36BBP+ChAf/hocZ/3V2 + Av94eAX/eXgE/4aDA/+ZlAX/m5cF/4yFBf+NhgX/jYUE/4mABP+PgwT/i4AE/4l+BP+FewT/f3QE/390 + BP98cgT/d24E/3JrA/9vagP/b2sD/29sA/9zcwP/bm0D/2FdAP+0sozj3drcpoqIhsYAAACPAAAAWgAA + ADYAAAAdAAAAMg4ODpDJxcTB2dnPx1RvG/9Sdgz/W4EO/1x1C/9ZaQn/W2kH/2BuBf9ocQX/cncG/3t+ + A/+Aggj/hIUY/3JzAv92dgX/eHcE/4iEBP+YlAX/lpIE/4iCBf+KgwX/iIAD/4h/BP+NgQT/h30E/4d+ + BP+BeAT/f3ME/31yBP96cAT/dG0E/3BqA/9uagP/bmsD/3BtA/9xcQP/aWcC/1xYAP+zsIvj3trcpoqI + hsYAAACPAAAAWgAAADYAAAAdAAAAMg4ODpDKx8XB2drQyFNtGf9Rcgv/W34N/1t0Cv9YaAj/WmcH/19s + Bv9mbwX/cXYE/3l8Av9/gQr/goIW/3BxAv91dAT/d3YE/4mFBP+YlAX/kYwF/4Z/Bf+GfwT/g3sE/4h+ + BP+JfgT/hXsD/4Z8BP99dAT/fXIE/3txBP93bgT/cWsD/25pAv9tagL/bWoC/3FvA/9tbAP/ZGID/1dU + AP+xrovk39vcqIqIhscAAACPAAAAWgAAADYAAAAbAAAAMQ4ODo/Kx8XB2NjOxlFpFv9NbQb/V3oJ/1hx + Bv9UZQT/V2QE/1xoA/9kbAH/bnMA/3Z5AP99fwr/fX4S/2xtAP9xcAH/dnUB/4iFAv+VkQL/i4QB/4F7 + Av9/eAH/f3cC/4R7Af+EegH/g3gB/4J4Af94bwH/eW8C/3duAf9yawL/bWgA/2tnAP9rZwD/a2kA/25t + AP9mZQD/YF0A/1JOAP+uq4nj3tvcp4qIhscAAACNAAAAWAAAADUAAAAYAAAALBAPD4zKxsS/0tHHvVZt + Hf5TcA//XHsQ/111Dv9aag3/XWkO/2NtDP9qcQr/c3gL/3p8Cv+Bgxf/foEa/3BxCP91dAv/e3sM/42L + Df+XlA3/ioQN/4R+Df9/eQz/g3wM/4iAC/+GfAz/iH8M/4J5DP99dAz/fXQM/3lzDP91bwv/cm0K/3Ft + Cf9xbQr/cnEK/3FwCv9paAv/ZGIK/1ZSB/+ppofa2NXVoYyKiMYAAACJAAAAUgAAADAAAAAUAAAAJAsL + C4K/vLi/1dHLo8zNwMHS1MbM1NbHztXWx87U1cfO1dXHztXVx8/W1sfO2NfHztjXx87Z18jO19bHzNXU + xcvV08PK1dTDydfVw8nY1sPJ1tTDyNbTw8jV08PJ1tPDydfUw8nW08PK19TEytbUxMrW08PK1tPEy9bT + xMvW1MXL1tPFy9XSw8vU0cPM09HCzNLRwszRz8LM0c7CzMnHu8XGwruwzcjEmYSCgMYAAAB7AAAARgAA + ACgAAAAOAAAAGgAAAFNpaGbH2NTOsuDc2avi3duv4t3br+Pe26/j3tuv49/br+Lf27Dh39uv4d7br+Hd + 26/g29qu3trYrNzY1qnb1tOo2dXSp9jU0afY09Gn2NXRptnU0aba1NGl2dXRptnU0qfZ1NOo2tbUqNvW + 1Kjb1tSp3NbVqd3Y1qnd2dap3dfWqtrW1KrY1NOs19TSrNfT0qzX09Ks19PSrdbRz6vQy8envrq2vTEx + MLgAAABXAAAANQAAAB4AAAAJAAAAEgAAACcAAABnMzMyq09OTbRMS0qzS0tKtExLSrRMS0q0TEtKtExL + SrRLS0q0S0tKtEtLSrRLS0qzS0pJs0pJSbNLSkizSkpJs0pKSLNKSkizSkpIs0tJSLNLSkmyS0pJsktK + SbNLSkmzS0pJs0tKSbNMSkmzTEpJs0xKSbNMSkmzTEpJs0tKSbNLSkmzS0pJs0tKSbNLSkmzS0lJs0tK + SbRNTEu2Hh0dowAAAF4AAAA4AAAAJQAAABMAAAAFAAAACwAAABYAAAAhAAAALQAAADcAAAA6AAAAOgAA + ADoAAAA6AAAAOgAAADoAAAA6AAAAOgAAADoAAAA6AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAAADsAAAA7AAAAOwAA + ADsAAAA7AAAAOgAAADsAAAA6AAAAMwAAACsAAAAhAAAAFQAAAAsAAAACAAAABAAAAAkAAAAOAAAAEwAA + ABcAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAZAAAAGQAA + ABkAAAAZAAAAGQAAABkAAAAZAAAAGQAAABkAAAAYAAAAFwAAABMAAAAOAAAACAAAAAQAAAAAAAAAAQAA + AAIAAAAEAAAABwAAAAkAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAA + AAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACgAAAAoAAAAKAAAACQAAAAcAAAAEAAAAAgAA + AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAoAAAAIAAAAEAAAAABACAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAABAAAAA4AAAAfAAAALQAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAA + ADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAAADQAAAA0AAAANAAA + ADIAAAApAAAAGQAAAAoAAAAMAAAAJAAAAEQAAABhAAAAawAAAGsAAABrAAAAawAAAGwAAABsAAAAbAAA + AGwAAABsAAAAbAAAAGwAAABsAAAAawAAAGsAAABrAAAAawAAAGsAAABrAAAAawAAAGsAAABrAAAAbAAA + AGwAAABsAAAAaAAAAFcAAAA7AAAAGgAAABcAAAA+ExMSkD07OKo7ODWpODUyqDczMKg1Mi+nNDEupzMw + LaczMC2nMzAtpzQxLqY2MzCnODUypzk2M6c5NzOoOjc0qDs3Nag7ODWoOzg1qDs4Nag7ODWoOzg1qDk3 + NKc4NTKnOTYypzs5Nqg5NzSuCQkJlwAAAFsAAAAuAAAAHAYGBmmCfHamr6adhbevp5GyqqKQraWdjami + mYumn5aKpJyUiaSalImkm5OJqJ+Xia6lnoq0qqOKta2li7WtpYy1rqaNtq6njbawpo22saeOt7Opj7mz + q4+8squPua+ojLWsp4u4rquNt62oiaiek3llYVysAAAAfAAAADoAAAAeEA8PdbClnqGF19nWY+Hn9mng + 5PZs3+L1cOHh9XXi3/V44t31e+La9X/j2PWE5Nf1iefX9ZDr2fWY8Nv1o/Tf9bL35PXB+un11Pzu9eX9 + 8vX2/fn1/v759fX99vXu/PL18P3e9fD9x/bu/bfzy860qIiBfp0AAACHAAAAPQAAAB4ODg1zvbGsrmza + 3uwp09b/MtLR/zTSzf8508r/PdTH/0HXxf9H3MX/UOPI/1rry/9m89D/c/vV/4P/3f+Z/+X/s//s/8f/ + 6v/P/9//yf7R/7z8yP+p/Lz/jfq+/5D9yf+f/8T/ufyk/8Dre//P17a/j4iIowAAAIYAAAA+AAAAHg4O + DXPAtK+xadjZ6yfR0f811tP/O9vV/0Hg1v9H5tf/T+vX/1fx1v9f99f/af3X/3L/1f96+8//f/XF/4Xx + uP+J7ar/humY/4Tmi/+I4oT/jN5//4/YfP+U0Hj/nc12/6HVfv+j4ob/p+SD/8/YvcGTjIumAAAAhgAA + AD4AAAAeDg4Nc8G2srNx4dzrMtzV/z/c0v9C3dD/RNvI/0jcwf9P377/V+O7/1zjtP9h3qn/Zdmd/2nW + kv9s1In/ctOC/37SgP9+y3X/fsJr/4G7Zf+Ft13/i7hY/5G9WP+Vv1r/nL5a/6W8Vf+uv1H/09S0w5SQ + kKgAAACFAAAAPgAAAB4ODg5zw7m1tW/RyewuxLb/PMq4/0PQvP9I0rj/TNCv/1PPqP9az6H/YdCZ/2fS + j/9u1In/c9OB/3bPd/99y3D/jcxw/4XEZP+Ewl//i8Vb/4vDX/+IvmP/h7Rd/4qpUP+PoEL/kpg4/5aQ + K//OyKrFmJWVqwAAAIUAAAA+AAAAHg4ODXPEura2ddTG7DjKs/9H0LX/Udi4/1netf9f4a7/aeWo/3bl + of994Zb/fNmH/3vPeP96x23/d79l/3q+af+Bwm//dbZY/3mrQ/94mzn/dY40/3eFLP94fiT/enoh/395 + IP+EeSD/inod/83FqcabmJisAAAAhQAAAD4AAAAeDg4Nc8W7uLiE4MztUNy6/1zfuP9j37X/Zdyq/2LP + lf9jwoP/arl4/2uxbf9kpWP/YJ1c/16aWP9fmlL/bKNM/3aiO/9tiCb/bH8j/258If91fh//en0e/3l4 + Hf95dRz/fHQd/4B2Hv+GdRr/zcWqx5yamq0AAACFAAAAPgAAAB4ODg5zxr27uYDOtu1DtY//R6mB/0ik + ef9LonP/S5pn/06UYP9aml//Yp5c/2CYVP9jmEv/ZJQ8/2aMK/93kyP/d40g/2l6Hf9ufRz/dX8b/36B + G/9/fxr/eXca/3hyGv96cRr/fXIb/4JxF//MxKrJnZubrwAAAIUAAAA+AAAAHg4ODnPHwL66draa7jiU + av9Bj2T/RJFj/0qWY/9Nk13/U5JV/2SdUf9xo0r/bpk8/2qNLf9mgSH/bH4b/3yNHf90hRv/bHoX/3SB + Fv97gxf/g4YX/4OBF/97dxf/d3EX/3hvF/96bhj/f20U/83FqsmfnJ2wAAAAhQAAAD4AAAAeDg4Oc8jB + wLx4sZHuO5Bd/0SJWP9IiVP/T45R/1aUTP9hl0X/dqM9/3ueMv9wjCT/cIUc/259Fv9wfhb/fY4Y/3WE + Fv9xfhT/fIUU/4CGFP+HiBX/hIEU/3x4E/94cRX/d24V/3htFf98axH/zMWqyqCenrEAAACFAAAAPgAA + AB4ODg5zyMLBvHuvhu5AjU3/SIJH/06GQv9bkj//aKA8/3CeMv96mif/e5Qf/3mLGf96hxb/cH4S/3aD + E/+GlRX/fIkT/3uEEv+DixH/hYkQ/4mKEf+DgRH/fXgQ/3t0Ev95bxP/eGwT/3pqDv/MxarLoZ6fsgAA + AIUAAAA+AAAAHg4ODnPJw8K9fat87kaMP/9XjTz/YJQ1/2qjMv9qmCn/bYkg/4CWHP+FlRr/gYwV/36I + Ev92gBD/gYwR/5CcE/+DjRD/hIwP/4iPEP+Jiw3/iYkO/4N/Dv9+eA7/gHcP/35yEP97bRH/e2sM/83G + qsyhn6CzAAAAhQAAAD4AAAAeDg4Oc8jCw76Dr3PuV5w0/2OcMv9lpCz/ZZAk/2d/Hf91ihr/ipkY/4yV + Gf+DixH/f4gO/3uDDf+LlA//lp4Q/4ePDf+LkQ7/i48O/46MC/+Khgv/gX0L/4F4DP+Ddw3/gXQO/35u + Dv9/bgr/z8mqzKGfoLMAAACFAAAAPgAAAB4ODg5zyMPEvomzbe5apyv/YqYs/1uAIP9kfRv/bYMZ/3yM + Fv+PmBT/jJIW/4OJDf+Bhgr/gIYK/5WaDf+ZnQ3/ipAL/5GVDP+Pjwr/ko0K/4uFCf+CfAj/gnkJ/4N3 + C/+Acwz/fm8L/4FyCP/QyqrNoZ+gswAAAIUAAAA+AAAAHg4ODnPJwsW+ib9r7leoJf9afyD/XHca/2iB + F/9wghT/gIwR/5CXD/+KjxH/hIcJ/4OGCP+FiQj/nJ4K/5mbCv+PkQn/lpYK/5OPCP+Tjgj/ioQH/4N8 + Bv+CeQf/gnYI/31yCf98cAn/g3YG/9DKqc2gnZ+1AAAAhQAAAD4AAAAeDg4Oc8nExr+Fr2TvUYYZ/1t+ + HP9ddxb/aX4S/3GBD/+Ciw3/kJUL/4mMD/+EhgX/g4UG/4qLBv+goQf/mZgH/5WTB/+WlAf/lZAG/5SN + Bv+Kggb/hHwE/4J5Bf9/dQb/enAH/3xxB/+EeAX/z8qozp+dn7UAAACEAAAAPgAAAB4ODg5zy8XHv4Ke + X+9ShhT/XH8Z/15zE/9oeg//cX4N/4GJCv+Okgv/iIoO/4ODA/+CgwX/j44F/6GhBv+XlAX/lpQG/5WR + Bf+XkAb/kYkG/4iABf+EfAP/gXgF/3tyBP92bgX/e3IG/4N6A//Py6fOn52ftQAAAIQAAAA+AAAAHg4O + DnPLxsjAg55d71OFEf9dfxb/XXER/2d3Df9vfAr/gIcI/4yQDP+Ghw3/gIEC/4GBBf+TkQX/oZ8G/5WQ + Bv+XkgX/lI4F/5aOBv+OhQX/hX0E/4N7BP9/dQX/dm8E/3JtBP93cwX/gXsB/87Kp8+fnZ+2AAAAhAAA + AD4AAAAeDg4Oc8zHycCDnFzvU4MN/11+FP9dbw//ZnQM/295Cf9+hQf/i40N/4OEDP9+fgL/gYAE/5eU + Bv+fmwb/k40G/5WPBf+Tigb/lIkG/4uCBf+EewT/gngE/31yBP9zbAP/cGwD/3ZzBP98eAD/ysemz5+d + n7cAAACEAAAAPgAAAB4ODg5zzcnKwYKaWe9TgQr/XX4R/1tsDP9jcgr/bXcH/32CBv+Jiw3/gIEM/3t7 + A/+CgAT/mpYF/5uVBv+Rigb/kYoF/5KHBv+QhAX/iX8E/4J3Bf9/dQT/eXAE/3BrBP9wbAP/dnQD/3Rx + AP/HxKbPoJ6gtwAAAIQAAAA+AAAAHg4ODnPPyszBgpdZ71B8B/9cfA//WmoL/2FvCP9sdQb/fIAE/4eI + Dv99fgz/eHgD/4KABP+blwX/lI8F/46GBf+NhAX/kIQF/4yABP+FewT/f3UE/31yBP91bQT/b2oD/29s + A/90cwP/a2gA/8XBptCgnqC3AAAAhAAAAD4AAAAeDg4Oc9HMzsGBlFbvTnYE/1x5Df9aaQn/X2wG/2py + Bv95fQP/hIUO/3l6C/91dQP/g4AE/5qWBf+OiAX/ioIE/4mABP+LgAT/iH0E/4F3BP9+cgT/eW8E/3Fr + A/9uagP/cG0D/29vAv9jXwD/w8Cm0KGeoLgAAACEAAAAPgAAAB4ODg5z0s7Pwn6RU/FKbgD/WXUH/1Vl + Bf9baAP/Z28B/3V4AP9/gQz/c3QF/3FwAP+DgAH/lZEB/4aAAf+CegH/hHsA/4Z7AP+DeQD/e3EA/3lv + Af9zawH/bGcA/2toAP9ubAD/aGYA/1pXAP/BvqXRop+guAAAAIQAAAA9AAAAGhAPD3HRzM69g5JZ7FNy + DP9hexT/Xm0S/2RvEf9vdg//e38O/4WHHf93ehP/eHgP/4yKEf+XkxH/iIIR/4R9EP+KgRD/ioAR/4d/ + EP+AdxD/fXYQ/3dyD/90cA7/dHEO/3V0D/9sag//X1wM/725o8qjoKG3AAAAgAAAADgAAAARCAgIX7e0 + sL3e3dK13NzOxd7ez8bd3M/G3t3Pxt/ez8bh3s/G4N3Pxd3azMLc2crB3drJv93ayb/c2Mm/3NjIv93Z + yb/d2crB3drKwd3YysHd2cvB3drMwtzYysLa1snD2dbIw9jVycTT0MTA19LMqoqHhbsAAABpAAAAKwAA + AAsAAAAqLy4tj3t5d698eXmte3h4rXt5eK17eXitenl4rXp4eK15d3eseHV2q3d1dap2dHSpdXN0qXZ0 + dKl3dHSodnR1qXd1dap3dXWqeHV2qnh2dqp5dnaqeHV1q3Z0dat2dHSsdnR0rHh2dqxubGqwGhkZiAAA + ADgAAAAaAAAABQAAAA4AAAAdAAAAMAAAADUAAAA1AAAANQAAADUAAAA1AAAANQAAADUAAAA1AAAANQAA + ADUAAAA1AAAANQAAADYAAAA1AAAANQAAADUAAAA1AAAANQAAADUAAAA1AAAANQAAADUAAAA1AAAANQAA + ADQAAAAlAAAAGAAAAAsAAAABAAAAAwAAAAYAAAAKAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAA + AAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAA + AAwAAAAMAAAADAAAAAoAAAAGAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAABgAAAAwAAAAAQAgAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAcAAAAaAAAAMQAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAA + ADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADwAAAA8AAAAPAAAADgAAAAnAAAADwAAABUAAABKDAsKhg8N + DI8ODAuODQsKjg0LCo4MCwqODAsKjg0LCo4NCwuODQwLjg4MC44ODAyODgwMjg0MDI4NDAyODQwMjg0M + C44MDAuODg0NjwkJCY4AAABhAAAAKgAAACYyMC6KmpSMnKGclZ2alY6blZGKmZKOhpeQi4SXkYqEl5WO + iJeclZCYoJmTmJ+ak5mgm5SaoJ2UmqKelZumn5mbq5+bm6ebl5mkmpeZpZyYlo+Hf5YgHx6XAAAAQgAA + AC9kWVWRm9nZy1vg5fRi3t/0Zt7c9Gze2fNw3tXzdeHT833l0/OH7NbzlPPb86f55PTB/O702v/y9Oj/ + 8/Tv//P04f/u9Nj/6/Pj/8706Puu8svNtKc9OjuaAAAASgAAAC5pXVqVid3d4CPS1P8x1ND/ONjP/z/d + z/9I5c//VO7S/2L41v9y/9j/gP/Y/5T91P+k+sr/qPa3/6TyqP+b757/jOmb/5Ppo/+j8qH/seyH/87T + ub1APD6aAAAASgAAAC1qXluWjuHd4C/a1P8/3NL/RN7O/0rgyP9U5MP/XOe9/2Tlsf9q4KT/btuU/3XY + if99037/fMpv/4LDaP+KwGH/ksBd/5m/Wv+hwFv/rMhg/9HSub5BPkCcAAAASQAAAC1rYF6XkNnR4S/H + t/9Bzrn/SdO3/1DTrv9c1qb/Z9ec/27Wjv901IH/d890/4LLcP+IyG3/gcBc/4a7VP+EtFb/g6pR/4ie + RP+NlDb/lo4t/87HrsFDQkSdAAAASQAAAC1rYF+YmuDS4kXXuf9Y3rv/YuO2/2XepP9v15T/d82F/3K+ + c/9ts2b/aqxe/3SyXv91qUv/cZQy/3GHKv92gCT/eHke/3l1HP9/dRz/iXgf/87Hr8NFREaeAAAASQAA + AC1rYmKZn9vI40a+l/9OtIn/Ua5//0+hbf9Wm2L/YZ5e/2CYVP9glEj/Y441/3aWKP9wgx7/a3oc/3V+ + G/9+gBr/enga/3hyGv97cRr/hHQc/87HsMVFRUafAAAASQAAACxtZmaalsWu5DeQZP9CjGD/SZJf/06R + WP9dmFD/cqJI/26VNv9phSP/bX4a/3qLG/9vfhj/c38W/36EF/+FhRf/fXkW/3dwF/94bhb/gHAX/8/I + scZHRkifAAAASQAAACxtZ2ibmcKl5TyLUv9Hg0z/Uo1I/2GaQ/9ynjf/fJsp/3WKHP9ygRb/cn8U/3+P + Fv91ghP/fYcT/4WJEv+HhhP/fnoS/3lxE/93bRP/fG0U/8/IssdHRkifAAAASQAAACxtZ2mbnL+b5UWK + Pv9YjDr/Zp40/2uXKv92kR//g5Ua/4GMFf94gxH/fYkR/4yYE/+BihD/h44Q/4mLDv+GhA7/f3kO/391 + EP97bhD/fW0R/9DJsslHR0mgAAAASQAAACxsZ2ucosKS5lidMP9joS3/ZI8k/2mBG/+Bkhf/jZYY/4OK + EP98hAz/ipIO/5ObD/+Ijw3/jZEN/46LC/+GgQr/gXkL/4N3Df9/cAz/gXEO/9HMsslHR0mgAAAASQAA + ACxtZ2ycpsqN5linJv9bgyD/Y3sZ/3GEFv+JkxL/jpMT/4OIC/+AhQn/lJgL/5aaC/+Pkwv/k5EJ/5GM + Cf+GgAj/gnkI/4J2Cv99cAn/g3UL/9LMsspHRkmhAAAASAAAACxtaG2do8WJ5lGJGf9beBn/ZnwT/3SD + D/+KkQz/jI8O/4SFBv+Ehgb/m5wH/5iYB/+VlAf/lZEH/5KLBv+GfwX/gnkF/390B/96bwb/hXkJ/9HM + sMtHRkmhAAAASAAAACxuaW6dobWE51GDEf9cdxX/ZngQ/3SADP+Ijgr/iowN/4GCBP+HhwX/np0F/5eU + Bv+Wkwb/lo8G/4+HBv+FfQT/gXkE/3lwBP92bwT/hHsH/9HNr8xGRkmhAAAASAAAACxuam6dorWD51KC + Df9cdhP/ZHQN/3J9Cf+Hiwn/h4gN/35/A/+KiQX/n5wG/5WQBv+VjgX/lYsG/4uCBf+DewT/f3UE/3Nt + A/9zbwP/gHsG/87Lr8xGRkmiAAAASAAAACxva2+dorSB51J/Cf9cdA//YXAL/3F6B/+FiAn/hIQN/3t7 + A/+OiwT/nJgG/5KLBv+SiQb/kYYF/4h+BP+BdwX/e3EE/3BrA/9ybwL/eHYE/8vIr81HRkmiAAAASAAA + ACxwbXGeorGB51B6BP9bcg3/X2wI/293Bv+ChQj/f4AN/3h4A/+QjAT/lpEF/42FBf+OgwX/jIEE/4R5 + BP9+cwT/dm0E/29qA/9xbwL/b2wD/8jFr81IR0miAAAASAAAACxyb3Keoa5+6UtwAP9YbQb/WmcD/2px + AP99fwT/eHkJ/3NyAP+OiwH/jogB/4R8AP+HfQD/hXsA/31yAP94bgD/b2kA/2xoAP9tawD/Yl8A/8bD + rs9IR0mjAAAASAAAACl0cXScprGE41Z1D/9idhb/ZG8U/3R6Ef+Ehhj/fn8Z/3x8Ev+WkxP/jokT/4eA + E/+NgxP/ioET/4N6E/99dhL/dnIR/3d0Ef9zchH/ZmMP/sbCsMlLSkuiAAAARAAAABhKSEeN09HJw9DR + w8rR0MPK0dDDy9PRw8rU0cPK0c7Bx8/MvsXQzb3E0My9xM/MvcTQzL3F0c2+xdDMvsbQzb/Gz8y/x83K + vcjMyb3Jyse8xsK+uLwtLSyQAAAALgAAAAgAAAAyJCMjbSwrLHErKitwKyorcCoqK3AqKStwKSkqcCko + Km8oKCpvKSgqbykoKm8pKCpvKSgqbykpKm8qKSpvKikqcCkoKnApKCpwKyoscR0cHG8AAAA6AAAAFAAA + AAIAAAAFAAAACAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAwAAAAMAAAADAAA + AAwAAAAMAAAADAAAAAwAAAAMAAAADAAAAAsAAAAKAAAABAAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAA + AEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAA + AEEAAABBAAAAQSgAAAAUAAAAKAAAAAEAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAJgAA + AEMAAABIAAAARwAAAEcAAABHAAAARwAAAEcAAABHAAAARwAAAEcAAABHAAAARwAAAEcAAABHAAAARwAA + AEcAAAA0AAAAFQAAACIWFRN0PzUxlDwwLJI4LSqQNiwokDUqJ481KiiPOC4rkDowLpA5MS6RODEvkTcx + L5E1Mi+RNjIvkTQwLpA0MDCQNjIylRAPDoQAAAA5AAAAPXd1cJyfzsy9k8rIxZLGwsOTxL7BlMG6wZjD + usGhyr/BqtHEwrTWycPC2c/D0dzTxN7e2MTg3tnE2NvRwtvbwcPS0bOsX1xYnAAAAFYAAAA9jI+Mqk/h + 5v8w2Nn/O9zW/0Tg1f9O6NT/XPLX/2382v+A/9//nP/j/7b/3v/B/8//vf3D/6f5vf+n+8L/vP+m/9Pv + qOh1b3CeAAAAVwAAADyNkI2tUuHd+jbZ0v9B3c//SeDJ/1XmxP9g6r3/auix/3Hhof973ZH/gNZ//3/N + b/+Gx2f/jsVj/5jEYv+gyF//xdeT5nh0daIAAABWAAAAPI6Rjq5X1cf6Pc66/0zXuv9V2a//ZNqk/27Y + lP9z04L/dsxy/4HJcP+CwmX/gbdR/4KtTv+Bo0n/hpc8/4uJJ/+4rm3nfHp7pQAAAFYAAAA8kZOQsGvg + xvpT17H/X9ep/2DMkv9rwYD/bbVw/2eoYf9lolT/c6hL/3CVM/9vgyX/dX4g/3h4HP95chv/fG8T/7Gj + aOh/fX6nAAAAVgAAADySlJCyYruZ+0Gccf9Jmmv/TJJf/1yYV/9om03/ZI86/2iGJf94jB3/bXsY/3R/ + GP+Agxn/fXoY/3dxGf93axD/rqFm6YB/gKgAAABVAAAAPJKUj7Nfpnv7QIVS/02MT/9cl0n/c6A7/3eV + Kv9wgxr/cH4V/3uLF/90gBT/f4YU/4eHFP9/exP/eHAU/3NnC/+rnmPqgoCCqQAAAFUAAAA8kpOPs2aj + Z/tPiTz/Ypo2/2yXK/98lR//gpAY/3uFEv97hxH/iJUS/4GKEf+IjA//iIcO/4B7Dv99dBD/dmgH/6uf + YeqDgYOqAAAAVQAAADyTk4+0da9X+1+gLP9kjiP/bYMa/4mVF/+JkBT/foUM/4mQDv+SmQ7/ipAN/4+O + DP+KhQr/gXkL/4N2DP96awP/rqNg6oOBg6sAAABVAAAAPJSVj7V2uE37WIcd/2J6F/91hhP/jZUR/4iM + Dv+BhQf/k5YJ/5eZCv+Tkwn/lI8I/4qDB/+Cegf/gXUJ/3lsAP+xp17rgoCDrAAAAFUAAAA8lJSPtXCd + QfxYexX/ZHkS/3eDDf+MkQz/hogJ/4SEBf+amgb/mZcG/5aTBv+Vjgb/iYEF/4J6BP97cQX/d20A/7Gq + XOuBgIOtAAAAVQAAADyVlJC1cZg8/Fl7Ef9jdA7/dX8J/4qNDP+Cgwj/hIQE/52aBv+XkgX/lY8F/5KJ + Bv+GfgT/gHYE/3RtBP9zbgD/r6pa7IGAg64AAABVAAAAPJaVkLZxlTj8WXkM/2BvC/9zfAf/h4oM/35/ + B/+GhAP/nJcG/5OMBv+TiQb/jYMF/4N5Bf98cgT/cGsD/3BtAP+no1nsgoCDrgAAAFUAAAA8l5aStm+P + NPxXdgj/XmsI/3F4Bf+EhQv/eXkH/4eFBP+XkgX/jIQF/42DBf+IfQT/f3QE/3ZuBP9vawP/a2oA/56a + WOyCgIOuAAAAVQAAADyZmJS4ZYIm/01qAP9TYAD/Z24A/3h6AP9tbQD/goAA/4qDAP9+dgD/gngA/3tx + AP90aQD/amMA/2dlAP9dWwD/kY5P8ISDha8AAABVAAAAM5eVkbGyvY7jo7B16aasd+mwsnXouLd66LCv + dOa8uXPlvLdz5beyc+W7tHPmt7F05rOudOavq3Pmrqty56akcei/u5vWe3l5rQAAAEgAAAASKikoaG5r + bpFtam6PbGptj2tpbY9pZ2yOaGZqjGZkaYtmZGmLZ2Vqi2dlaoxoZmuMaWdrjGlna41nZmqNaWdrjmVj + ZJAdHBtrAAAAHwAAAAMAAAAJAAAAFQAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAABYAAAAWAAAAFgAA + ABYAAAAWAAAAFgAAABYAAAAWAAAAFgAAAA4AAAAGAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAA + AEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEAAABBAAAAQQAAAEEoAAAAEAAAACAA + AAABACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQAAAEAAAABXAAAAVQAAAFUAAABVAAAAVQAA + AFUAAABVAAAAVQAAAFUAAABVAAAAVQAAAFcAAABMAAAAHwQEBD5WVFCVc3JuoWpqZp5nZ2KdZmRgnGpo + Y51wbmmdcXBrnnRybZ95dHGffnRzn3txb558dXCdTUpFmAABAVQXDg1Qj7m4w1jj5vRe3tv0ZuHY9G/n + 1vN/8tr0k/zi9LH/6vTP/+n02//i9M//3fTK/9n03/+58qenk68DAQRlGQ8OToS7uc8u29f/OtvP/0Xg + yf9U6sX/Ze69/3Lrrv+C5Z7/idyI/4rUd/+Mzm//ls5v/6/YdP+lp5O7BAIGYhkPEE+KubLQP9bB/1Db + vf9b3K3/a9mb/3HQhP9yxnD/fcRq/322VP9+p0b/gJtA/4WOMf+ZkDP/pJ+MvQUFCGMYEBJPkbqu0U7K + pP9WwJL/WbN7/2asa/9moVn/ZZdE/3OYNP9tgiH/dX0c/3p4Gf93bxf/insl/6SejcAFBgljGRMWUI6r + m9M+kWL/R4tX/1aUT/9vnUH/bo0q/22AGf93hhf/c34V/4KGFf+AfRb/dm4U/4V3If+ln47BBgYJYxkU + GFCQqJHUS41G/12UOv9tmC7/gJYe/3yIFP96hRH/hJAS/4KKEP+Jig//gX0P/3txD/+Edhz/paCPwwYG + CWMYFBlQlqyJ1F6jMP9jjSL/c4cY/4yVFf+BiA7/iI8N/5GYDf+NkQz/jYkK/4J7Cv+BdAr/iXoX/6ei + j8QGBgljGBQaUJeuhdVYjx//YngV/3uIEP+Nkg7/g4UI/5OVB/+YmQj/lZII/4+IBv+DegX/fXIF/4p+ + E/+no47FBgYJYxkWG1CVo4HVV4IV/2J1EP96hAr/iowL/4KCBP+YlgX/mJUG/5aQBf+MhAX/gngE/3Zu + A/+HgBH/pqONxgYGCWMZFhxQlqJ/1liAD/9gcAz/d38I/4aHC/+AgAT/mZUG/5SNBv+SiAb/iH0E/31z + BP9wawH/gH4P/6OhjMYGBgpjGhcdUJagftdTdwb/W2oF/3J4Av99fgj/fXsA/5OOAf+KggH/in4B/4B1 + AP91bAD/bWkA/3RyCf+gnYzIBwcKZBoYHVGhqIrWZoIc/216Hf+Bhhv/iYoh/42LGv+blhv/koob/5SK + G/+LgRv/gXsa/357F/98eiL/paKUxwcHCmMGBgcxenl0oJydkbaZmI20mpmNtZmXjLOYloiwmJaIsJiV + iLCZlomxmZWKsZiVirKWlImzmZeNtGpoZp0BAQE9AAAABQAAAB4AAAAqAAAAKQAAACkAAAApAAAAKQAA + ACkAAAApAAAAKQAAACkAAAApAAAAKQAAACsAAAAjAAAACgAArEEAAKxBAACsQQAArEEAAKxBAACsQQAA + rEEAAKxBAACsQQAArEEAAKxBAACsQQAArEEAAKxBAACsQQAArEE= + + + \ No newline at end of file diff --git a/OnTopReplica/StartupOptions/Factory.cs b/OnTopReplica/StartupOptions/Factory.cs new file mode 100644 index 0000000..ee44ca2 --- /dev/null +++ b/OnTopReplica/StartupOptions/Factory.cs @@ -0,0 +1,123 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Drawing; +using System.ComponentModel; +using OnTopReplica.Properties; +using OnTopReplica.WindowSeekers; +using System.Windows.Forms; + +namespace OnTopReplica.StartupOptions { + class Factory { + + static Factory() { + //Custom type conversion attributes + TypeDescriptor.AddAttributes(typeof(Size), new TypeConverterAttribute(typeof(SizeConverter))); + TypeDescriptor.AddAttributes(typeof(ScreenPosition), new TypeConverterAttribute(typeof(ScreenPositionConverter))); + TypeDescriptor.AddAttributes(typeof(Rectangle), new TypeConverterAttribute(typeof(RectangleConverter))); + TypeDescriptor.AddAttributes(typeof(Padding), new TypeConverterAttribute(typeof(PaddingConverter))); + } + + public static Options CreateOptions(string[] args) { + var options = new Options(); + + LoadSettings(options); + + ParseCommandLine(args, options); + + return options; + } + + private static void LoadSettings(Options options) { + if (Settings.Default.RestoreSizeAndPosition) { + options.StartLocation = Settings.Default.RestoreLastPosition; + options.StartSize = Settings.Default.RestoreLastSize; + + System.Diagnostics.Trace.WriteLine(string.Format("Restoring window at {0} size {1}.", Settings.Default.RestoreLastPosition, Settings.Default.RestoreLastSize)); + } + + if (Settings.Default.RestoreLastWindow) { + var handle = Settings.Default.RestoreLastWindowHwnd; + var title = Settings.Default.RestoreLastWindowTitle; + var className = Settings.Default.RestoreLastWindowClass; + + var seeker = new RestoreWindowSeeker(new IntPtr(handle), title, className); + seeker.SkipNotVisibleWindows = true; + seeker.Refresh(); + var resultHandle = seeker.Windows.FirstOrDefault(); + + if (resultHandle != null) { + //Load window + options.WindowId = resultHandle.Handle; + } + else { + System.Diagnostics.Trace.WriteLine("Couldn't find window to restore."); + } + } + } + + private static void ParseCommandLine(string[] args, Options options) { + var cmdOptions = new NDesk.Options.OptionSet() + .Add("windowId=", "Window handle ({HWND}) to be cloned.", id => { + options.WindowId = new IntPtr(id); + }) + .Add("windowTitle=", "Partial {TITLE} of the window to be cloned.", s => { + options.WindowTitle = s; + }) + .Add("windowClass=", "{CLASS} of the window to be cloned.", s => { + options.WindowClass = s; + }) + .Add("v|visible", "If set, only clones windows that are visible.", s => { + options.MustBeVisible = true; + }) + .Add("size=", "Target {WIDTH,HEIGHT} of the cloned thumbnail.", s => { + options.StartSize = s; + }) + .Add("position=", "Target {X,Y} of the OnTopReplica window.", s => { + options.StartLocation = new Point(s.Width, s.Height); + options.StartPositionLock = null; + }) + .Add("screenPosition=", "Resolution independent window position on current screen, with locking. Values: {TR|TL|C|BR|BL}.", pos => { + options.StartLocation = null; + options.StartPositionLock = pos; + }) + .Add("r|region=", "Region {X,Y,W,H} of the cloned window.", region => { + options.Region = new ThumbnailRegion(region); + }) + .Add("p|padding=", "Region padding {LEFT,TOP,RIGHT,BOTTOM} of the clone.", padding => { + options.Region = new ThumbnailRegion(padding); + }) + .Add("o|opacity=", "Opacity of the window: {0-255}.", opacity => { + options.Opacity = opacity; + }) + .Add("clickForwarding", "Enables click forwarding.", s => { + options.EnableClickForwarding = true; + }) + .Add("chromeOff", "Disables the window's chrome (border).", s => { + options.DisableChrome = true; + }) + .Add("fs|fullscreen", "Starts up in fullscreen mode.", s => { + options.Fullscreen = true; + }) + .Add("h|help|?", "Show command line help.", s => { + options.Status = CliStatus.Information; + }); + + List values; + try { + values = cmdOptions.Parse(args); + } + catch (NDesk.Options.OptionException ex) { + options.DebugMessageWriter.WriteLine(ex.Message); + options.DebugMessageWriter.WriteLine("Try 'OnTopReplica /help' for more information."); + options.Status = CliStatus.Error; + } + + if (options.Status == CliStatus.Information) { + cmdOptions.WriteOptionDescriptions(options.DebugMessageWriter); + } + } + + } +} diff --git a/OnTopReplica/StartupOptions/FourValueTypeConverter.cs b/OnTopReplica/StartupOptions/FourValueTypeConverter.cs new file mode 100644 index 0000000..17029d4 --- /dev/null +++ b/OnTopReplica/StartupOptions/FourValueTypeConverter.cs @@ -0,0 +1,71 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.ComponentModel; +using System.Text.RegularExpressions; + +namespace OnTopReplica.StartupOptions { + abstract class FourValueTypeConverter : TypeConverter { + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + if (value != null) { + var sVal = value.ToString(); + return Convert(sVal); + } + else + return base.ConvertFrom(context, culture, value); + } + + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + return sourceType == typeof(string); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + return destinationType == typeof(T); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (value != null && destinationType == typeof(T)) { + var sVal = value.ToString(); + return Convert(sVal); + } + else + return base.ConvertTo(context, culture, value, destinationType); + } + + static Regex _sizeRegex = new Regex("^\\D*(?\\d*)\\s*,\\s*(?\\d*)\\s*,\\s*(?\\d*)\\s*,\\s*(?\\d*)\\D*$", + RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.Singleline); + + private T Convert(string s) { + var match = _sizeRegex.Match(s); + + var v1 = match.Groups["one"]; + var v2 = match.Groups["two"]; + var v3 = match.Groups["three"]; + var v4 = match.Groups["four"]; + + if (match.Success && v1.Success && v2.Success && v3.Success && v4.Success) { + int v1v, v2v, v3v, v4v; + bool v1b, v2b, v3b, v4b; + v1b = Int32.TryParse(v1.Value, out v1v); + v2b = Int32.TryParse(v2.Value, out v2v); + v3b = Int32.TryParse(v3.Value, out v3v); + v4b = Int32.TryParse(v4.Value, out v4v); + + if (v1b && v2b && v3b && v4b) { + return CreateValue(v1v, v2v, v3v, v4v); + } + else { + throw new ArgumentException("Argument '" + s + "' contains a non numeric value."); + } + } + else { + throw new ArgumentException("Argument '" + s + "' is in the wrong format."); + } + } + + protected abstract T CreateValue(int v1, int v2, int v3, int v4); + + } +} diff --git a/OnTopReplica/StartupOptions/Options.cs b/OnTopReplica/StartupOptions/Options.cs new file mode 100644 index 0000000..d36e2bb --- /dev/null +++ b/OnTopReplica/StartupOptions/Options.cs @@ -0,0 +1,163 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Drawing; +using System.IO; +using OnTopReplica.WindowSeekers; + +namespace OnTopReplica.StartupOptions { + + /// + /// Represents startup options that can be set via CLI scripting (or other stuff). + /// + class Options { + + public Options() { + Status = CliStatus.Ok; + Opacity = 255; + DisableChrome = false; + MustBeVisible = false; + Fullscreen = false; + } + + #region Position and size + + public Point? StartLocation { get; set; } + + public ScreenPosition? StartPositionLock { get; set; } + + public Size? StartSize { get; set; } + + #endregion + + #region Window cloning + + public IntPtr? WindowId { get; set; } + + public string WindowTitle { get; set; } + + public string WindowClass { get; set; } + + public ThumbnailRegion Region { get; set; } + + public bool MustBeVisible { get; set; } + + #endregion + + #region Options + + public bool EnableClickForwarding { get; set; } + + public byte Opacity { get; set; } + + public bool DisableChrome { get; set; } + + public bool Fullscreen { get; set; } + + #endregion + + #region Debug info + + StringBuilder _sb = new StringBuilder(); + TextWriter _sbWriter; + + public CliStatus Status { get; set; } + + /// + /// Gets a debug message writer. + /// + public TextWriter DebugMessageWriter { + get { + if (_sbWriter == null) { + _sbWriter = new StringWriter(_sb); + } + return _sbWriter; + } + } + + /// + /// Gets the debug message. + /// + public string DebugMessage { + get { + if(_sbWriter != null) + _sbWriter.Flush(); + return _sb.ToString(); + } + } + + #endregion + + #region Application + + public void Apply(MainForm form) { + //GUI + form.IsChromeVisible = !DisableChrome; + form.Opacity = (double)Opacity / 255.0; + + //Seek handle for thumbnail cloning + WindowHandle handle = null; + if (WindowId.HasValue) { + handle = WindowHandle.FromHandle(WindowId.Value); + } + else if (WindowTitle != null) { + var seeker = new ByTitleWindowSeeker(WindowTitle) { + OwnerHandle = form.Handle, + SkipNotVisibleWindows = MustBeVisible + }; + seeker.Refresh(); + + handle = seeker.Windows.FirstOrDefault(); + } + else if (WindowClass != null) { + var seeker = new ByClassWindowSeeker(WindowClass) { + OwnerHandle = form.Handle, + SkipNotVisibleWindows = MustBeVisible + }; + seeker.Refresh(); + + handle = seeker.Windows.FirstOrDefault(); + } + + //Position lock + if (StartPositionLock.HasValue) { + form.PositionLock = StartPositionLock.Value; + } + + //Size and location start values + if (StartLocation.HasValue && StartSize.HasValue) { + form.StartPosition = System.Windows.Forms.FormStartPosition.Manual; + form.Location = StartLocation.Value; + form.ClientSize = StartSize.Value; + } + else if (StartLocation.HasValue) { + form.StartPosition = System.Windows.Forms.FormStartPosition.WindowsDefaultBounds; + form.Location = StartLocation.Value; + } + else if (StartSize.HasValue) { + form.StartPosition = System.Windows.Forms.FormStartPosition.WindowsDefaultLocation; + form.ClientSize = StartSize.Value; + } + + //Clone any found handle + if (handle != null) { + form.SetThumbnail(handle, Region); + } + + //Other features + if (EnableClickForwarding) { + form.ClickForwardingEnabled = true; + } + + //Fullscreen + if (Fullscreen) { + form.IsFullscreen = true; + } + } + + #endregion + + } + +} diff --git a/OnTopReplica/StartupOptions/PaddingConverter.cs b/OnTopReplica/StartupOptions/PaddingConverter.cs new file mode 100644 index 0000000..777394f --- /dev/null +++ b/OnTopReplica/StartupOptions/PaddingConverter.cs @@ -0,0 +1,21 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.ComponentModel; +using System.Windows.Forms; + +namespace OnTopReplica.StartupOptions { + class PaddingConverter : FourValueTypeConverter { + + protected override Padding CreateValue(int v1, int v2, int v3, int v4) { + return new Padding { + Left = v1, + Top = v2, + Right = v3, + Bottom = v4 + }; + } + + } +} diff --git a/OnTopReplica/StartupOptions/RectangleConverter.cs b/OnTopReplica/StartupOptions/RectangleConverter.cs new file mode 100644 index 0000000..624fee1 --- /dev/null +++ b/OnTopReplica/StartupOptions/RectangleConverter.cs @@ -0,0 +1,23 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.ComponentModel; +using System.Drawing; +using System.Text.RegularExpressions; + +namespace OnTopReplica.StartupOptions { + + class RectangleConverter : FourValueTypeConverter { + + protected override Rectangle CreateValue(int v1, int v2, int v3, int v4) { + return new Rectangle { + X = v1, + Y = v2, + Width = v3, + Height = v4 + }; + } + + } + +} diff --git a/OnTopReplica/StartupOptions/ScreenPositionConverter.cs b/OnTopReplica/StartupOptions/ScreenPositionConverter.cs new file mode 100644 index 0000000..18ca1a5 --- /dev/null +++ b/OnTopReplica/StartupOptions/ScreenPositionConverter.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.ComponentModel; + +namespace OnTopReplica.StartupOptions { + class ScreenPositionConverter : TypeConverter { + + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + if (sourceType == typeof(string)) + return true; + + return base.CanConvertFrom(context, sourceType); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + if (destinationType == typeof(ScreenPosition)) + return true; + + return base.CanConvertTo(context, destinationType); + } + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + var sValue = value.ToString(); + + switch (sValue) { + case "TL": + return ScreenPosition.TopLeft; + case "TR": + return ScreenPosition.TopRight; + case "BL": + return ScreenPosition.BottomLeft; + case "BR": + return ScreenPosition.BottomRight; + case "C": + return ScreenPosition.Center; + default: + throw new ArgumentException("Invalid screen position value '" + sValue + "'."); + } + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (destinationType == typeof(ScreenPosition)) + return ConvertFrom(context, culture, value); + + return base.ConvertTo(context, culture, value, destinationType); + } + + } +} diff --git a/OnTopReplica/StartupOptions/SizeConverter.cs b/OnTopReplica/StartupOptions/SizeConverter.cs new file mode 100644 index 0000000..9dd018e --- /dev/null +++ b/OnTopReplica/StartupOptions/SizeConverter.cs @@ -0,0 +1,69 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.ComponentModel; +using System.Drawing; +using System.Text.RegularExpressions; + +namespace OnTopReplica.StartupOptions { + + class SizeConverter : TypeConverter { + + public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value) { + if (value != null) { + var sVal = value.ToString(); + return StringToSize(sVal); + } + else + return base.ConvertFrom(context, culture, value); + } + + public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) { + return (sourceType == typeof(string) || sourceType == typeof(Size)); + } + + public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) { + return (destinationType == typeof(Size) || destinationType == typeof(string)); + } + + public override object ConvertTo(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value, Type destinationType) { + if (value == null) + return base.ConvertTo(context, culture, value, destinationType); + + if (destinationType == typeof(Size)) { + var sVal = value.ToString(); + return StringToSize(sVal); + } + else if (destinationType == typeof(string)) { + if (value is Size) { + Size sValue = (Size)value; + return string.Format("{0}, {1}", sValue.Width, sValue.Height); + } + + return value.ToString(); + } + else + return base.ConvertTo(context, culture, value, destinationType); + } + + static Regex _sizeRegex = new Regex("^\\D*(?\\d*)\\s*,\\s*(?\\d*)\\D*$", + RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.Singleline); + + private Size StringToSize(string s) { + var match = _sizeRegex.Match(s); + + var x = match.Groups["x"]; + var y = match.Groups["y"]; + + if (!match.Success || !x.Success || !y.Success) + throw new ArgumentException("Cannot convert '" + s + "' to coordinates pair."); + + var xVal = Int32.Parse(x.Value); + var yVal = Int32.Parse(y.Value); + + return new Size(xVal, yVal); + } + + } + +} diff --git a/OnTopReplica/StoredRegion.cs b/OnTopReplica/StoredRegion.cs new file mode 100644 index 0000000..d2d6894 --- /dev/null +++ b/OnTopReplica/StoredRegion.cs @@ -0,0 +1,32 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Xml.Serialization; +using System.Drawing; + +namespace OnTopReplica { + + public class StoredRegion { + + public StoredRegion(ThumbnailRegion r, string name) { + Region = r; + Name = name; + } + + public ThumbnailRegion Region { + get; + set; + } + + public string Name { + get; + set; + } + + public override string ToString() { + return Name; + } + + } + +} diff --git a/OnTopReplica/StoredRegionArray.cs b/OnTopReplica/StoredRegionArray.cs new file mode 100644 index 0000000..f140178 --- /dev/null +++ b/OnTopReplica/StoredRegionArray.cs @@ -0,0 +1,147 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; +using System.Xml.Serialization; +using System.Xml; +using System.Xml.Linq; + +namespace OnTopReplica { + + /// + /// Strongly styped array of StoredRegion elements. + /// + /// + /// Handles XML serialization. + /// + public class StoredRegionArray : List, IXmlSerializable { + + #region IXmlSerializable Members + + public System.Xml.Schema.XmlSchema GetSchema() { + return null; + } + + public void ReadXml(System.Xml.XmlReader reader) { + this.Clear(); + + var doc = XDocument.Load(reader); + foreach (var xmlRegion in doc.Descendants("StoredRegion")) { + System.Diagnostics.Debug.WriteLine(string.Format("Found region '{0}'.", xmlRegion.Attribute("name"))); + + StoredRegion parsedRegion = ParseStoredRegion(xmlRegion); + if (parsedRegion != null) { + this.Add(parsedRegion); + } + } + } + + private StoredRegion ParseStoredRegion(XElement xmlRegion) { + var xName = xmlRegion.Attribute("name"); + if (xName == null || string.IsNullOrWhiteSpace(xName.Value)) { + System.Diagnostics.Debug.Fail("Parsed stored region has no name attribute."); + return null; + } + + ThumbnailRegion region = ParseRegion(xmlRegion); + if (region == null) { + System.Diagnostics.Debug.Fail("Parsed stored region has no valid region."); + return null; + } + + return new StoredRegion(region, xName.Value); + } + + private ThumbnailRegion ParseRegion(XElement xmlRegion) { + var xRectangle = xmlRegion.Element("Rectangle"); + if (xRectangle != null) { + System.Drawing.Rectangle rectangle = ParseRectangle(xRectangle); + return new ThumbnailRegion(rectangle); + } + + var xPadding = xmlRegion.Element("Padding"); + if (xPadding != null) { + System.Windows.Forms.Padding padding = ParsePadding(xPadding); + return new ThumbnailRegion(padding); + } + + return null; + } + + private System.Windows.Forms.Padding ParsePadding(XElement xPadding) { + var p = new System.Windows.Forms.Padding(); + try { + p.Left = Int32.Parse(xPadding.Element("Left").Value); + p.Top = Int32.Parse(xPadding.Element("Top").Value); + p.Right = Int32.Parse(xPadding.Element("Right").Value); + p.Bottom = Int32.Parse(xPadding.Element("Bottom").Value); + } + catch (Exception ex) { + System.Diagnostics.Debug.Fail("Failure while parsing padding data.", ex.ToString()); + } + return p; + } + + private System.Drawing.Rectangle ParseRectangle(XElement xRectangle) { + var r = new System.Drawing.Rectangle(); + try { + r.X = Int32.Parse(xRectangle.Element("X").Value); + r.Y = Int32.Parse(xRectangle.Element("Y").Value); + r.Width = Int32.Parse(xRectangle.Element("Width").Value); + r.Height = Int32.Parse(xRectangle.Element("Height").Value); + } + catch (Exception ex) { + System.Diagnostics.Debug.Fail("Failure while parsing rectangle data.", ex.ToString()); + } + return r; + } + + public void WriteXml(System.Xml.XmlWriter writer) { + foreach (var region in this) { + WriteRegion(writer, region); + } + } + + private void WriteRegion(XmlWriter writer, StoredRegion region) { + writer.WriteStartElement("StoredRegion"); + writer.WriteAttributeString("name", region.Name); + + if (region.Region.Relative) { + WriteRelativeRegion(writer, region); + } + else { + WriteAbsoluteRegion(writer, region); + } + + writer.WriteEndElement(); + } + + private void WriteAbsoluteRegion(XmlWriter writer, StoredRegion region) { + writer.WriteStartElement("Rectangle"); + + var bounds = region.Region.Bounds; + writer.WriteElementString("X", bounds.X.ToString()); + writer.WriteElementString("Y", bounds.Y.ToString()); + writer.WriteElementString("Width", bounds.Width.ToString()); + writer.WriteElementString("Height", bounds.Height.ToString()); + + writer.WriteEndElement(); + } + + private void WriteRelativeRegion(XmlWriter writer, StoredRegion region) { + writer.WriteStartElement("Padding"); + + var padding = region.Region.BoundsAsPadding; + writer.WriteElementString("Left", padding.Left.ToString()); + writer.WriteElementString("Top", padding.Top.ToString()); + writer.WriteElementString("Right", padding.Right.ToString()); + writer.WriteElementString("Bottom", padding.Bottom.ToString()); + + writer.WriteEndElement(); + } + + #endregion + + } + +} diff --git a/OnTopReplica/StoredRegionComparer.cs b/OnTopReplica/StoredRegionComparer.cs new file mode 100644 index 0000000..cfc9438 --- /dev/null +++ b/OnTopReplica/StoredRegionComparer.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Collections; + +namespace OnTopReplica { + + /// + /// Compares two StoredRegions based on their name. + /// + class StoredRegionComparer : IComparer { + + #region IComparer Members + + public int Compare(object x, object y) { + StoredRegion a = x as StoredRegion; + StoredRegion b = y as StoredRegion; + + if (a == null || b == null) + return -1; //this is wrong, but anyway + + return a.Name.CompareTo(b.Name); + } + + #endregion + + } +} diff --git a/OnTopReplica/Strings.cs.resx b/OnTopReplica/Strings.cs.resx new file mode 100644 index 0000000..2360dd2 --- /dev/null +++ b/OnTopReplica/Strings.cs.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Vytvořil: % + Link % is replaced by string AboutAuthorContent. + + + Přerušit aktualizaci. + + + Zobrazit podrobnosti o aplikaci OnTopReplica. + + + Resetovat nastavení OnTopReplica. + + + Aktualizovat OnTopReplica. + + + Rádi byste přispěli k vývoji projektu? Jste vřele vítáni při spolupráci na stávajících nebo nových překladech, případně si můžete stáhnout % ze serveru CodePlex. + + + zdrojové kódy + + + OnTopReplica je založena na knihovně WindowsFormsAero a několika dalších knihovnách a zdrojích. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Více informací + + + Spolupráce + + + Zásluhy + + + Licence + + + Aktualizace + + + Aplikace je vydána pod % licencí, která splňuje požadavky "open-source" definice dle OSI. + + + Nenáročný a instantní náhled libovolného otevřeného okna (nebo jeho výřezu) v systému. + + + O programu OnTopReplica + + + Překlady: % + {0} translators (do not end with period) + + + Aktualizuj! + + + Aplikace OnTopReplica automaticky kontroluje dostupné aktualizace. + + + Verze: % + + + Resetovat nastavení okna? + + + &Resetovat +Všechna nastavení budou ztracena. + + + Operace "Resetovat okno" je vhodná k inicializaci všech nastavení pokud jste například ztratili kontrolu nad oknem nebo jej přesunuli mimo viditelnou plochu obrazovky. + + + Resetovat + + + Resetovat nastavení? + + + Operace "Resetovat nastavení" smaže veškerá uživatelská nastavení aplikace OnTopReplica a vrátí nastavení do stejného stavu jako po instalaci (všechny uložené informace, jako například uložené výřezy oken, budou ztraceny). + + + Resetovat nastavení + + + &Storno + & marks the ALT+[] shortcut + + + Označte výřez pomocí myši. + + + Podrobnosti + + + Podrobnosti k Windows Aero + + + Windows Aero je k dispozici pouze na systémech Windows Vista Home Premium a vyšších. + + + Funkce 'Desktop Composition' není povolena. + + + Pro pokračování je nutné povolit funkci "Desktop Composition" výběrem tématu 'Windows Aero' v nastavení vzhledu Windows. + +Uvedené lze provést například kliknutním pravým tlačítkem myši na plochu a zvolením akce "Přizpůsobit". + + + Podrobnosti k chybě + + + Chyba: + + + Zvolené okno bylo zavřeno nebo již není platné z jiných důvodů. + + + Chyba + + + Funkce 'Desktop Composition' není ve vašem systému podporována. +Tuto aplikaci je možné spouštět pouze na systémech Windows Vista Home Premium a vyšších. + + + Funkce Desktop Composition není podporována + + + Náhled nebyl nahrán. + + + Nelze vytvořit náhled. + + + Nelze vložit okno. + + + Kontrola aktualizací se nezdařila. + + + Zdá se, že aplikace OnTopReplica nebyla nainstalována pomocí 'ClickOnce'. Aktualizaci musíte provést ručně (navštivte <a href="http://ontopreplica.codeplex.com">domácí stránku aplikace OnTopReplica</a>). + + + Aplikaci OnTopReplica se nepodařilo zjistit, zda existuje nová verze. Zkontrolujte, zda jste připojeni k síti Internet. Pokud ano, je možné, že webové stránky projektu jsou dočasně mimo provoz. + + + Režim + + + Vždy na vrchu + + + Nastaví aplikaci OnTopReplica, aby zůstávala vždy na vrchu. + + + Proklikávání + + + Aplikace OnTopReplica se bude chovat jako průhledná vrstva přes kterou bude možno proklikávat do podložených oken. + + + Standardní + + + Aplikace OnTopReplica se bude chovat jako běžné okno. Jiná okna mohou překrýt okno aplikace. + + + Aplikace OnTopReplica přes celou obrazovku + + + Zrušit + + + Povolit seskupení + + + Výběrem více položek aktivujete seskupení + + + Seskupení je aktivní + + + Seskupení + + + Okna + Column Header of list, simply refers to available windows to be cloned + + + Domácí stránka: www.codeplex.com/ontopreplica. + + + Přejete si povolit "přeposílání kliknutí"? + + + V tomto režimu aplikace OnTopReplica přeposílá kliknutí levého tlačítka myši do zdrojového okna (je tedy možné provádět základní ovládání zdrojového okna bez nutnosti jej aktivovat). + +Ukončit režim "přeposíání kliknutí" je možné opětovným vyvolání položky v menu. + + + Přeposílání kliknutí + + + Povolit "Proklikávání" v celoobrazovkovém režimu? + + + "Proklikávání" funguje pouze pokud je povoleno v menu a okno má nastavenou průhlednost. + + + V tomto režimu se bude okno roztažené přes celou obrazovku chovat jako poloprůhledná vrstva, přes kterou bude možné "proklikávat" na podložená okna. + +K návratu do standardního režimu je možné přejít kdykoli dvojklikem na ikonu v oznamovací oblasti (traye). + + + Ne. +Režim "Proklikávání" je možné zvolit později v menu + + + Používat "Proklikávání" + + + Režim "Proklikávání" + + + Aplikace OnTopReplica byla aktualizována. + + + Pro použití aktualizací je potřeba aplikaci OnTopReplica restartovat. + + + Aktualizace proběhla úspěšně + + + OnTopReplica je aktuální. + + + Žádná aktualizace není k dispozici. + + + Jazyk + + + O aplikaci... + + + Skryje hlavní okno a zobrazí informace "O aplikaci". + + + Okraj + + + Přepínač, který definuje, zda má aplikace OnTopReplica viditelný okraj okna. + + + Přeposílání kliknutí + + + Zapne "přeposílání kliknutí" do zdrojového okna. + + + Proklikávání + + + Aplikace OnTopReplica se bude chovat jako průhledná vrstva přes kterou bude možno proklikávat do podložených oken. + + + Zavřít + + + Ukončí aplikaci OnTopReplica. + + + 2:1 Dvojnásobná + + + Celá obrazovka + + + 1:2 Poloviční + + + 1:1 Jako zdroj + + + 1:4 Čtvrtinová + + + Seskupení + + + OnTopReplica bude automaticky přepínat mezi okny z uživatelsky definované skupiny tak, že zobrazeno bude vždy to naposledy deaktivované okno. + + + 100% (neprůhledné) + + + Nastaví aplikaci OnTopReplica jako neprůhlednou. + + + 25% + + + Nastaví průhlednost na 25%. + + + 50% + + + Nastaví průhlednost na 50%. + + + 75% + + + Nastaví průhlednost na 75%. + + + Průhlednost + + + Otevřít + + + Zobrazí aplikaci OnTopReplica. + + + Dolní levý roh + + + Dolní pravý roh + + + Uprostřed + + + Vypnuto + + + Umístění + + + Automatická pozice aplikace OnTopReplica vzhledem k obrazovce. + + + Horní levý roh + + + Horní pravý rok + + + Opustit celoobrazovkový režim + + + Ukládat pozici a velikost okna + + + Přepínač, který definuje, zda si má aplikace OnTopReplica ukládat poslední pozici a velikost okna a obnovovat tyto údaje po restartování aplikace. + + + Minimalizovat do traye + + + Minimalizuje aplikaci OnTopReplica jako ikonu v systémové oblasti. + + + Vybrat výřez... + + + Přepne do režimu "výřezu", který umožní zvolit pouze část okna jako náhled. + + + Resetovat nastavení okna + + + Resetuje nastavení a pozici okna aplikace OnTopReplica. + + + Velikost + + + Obnovit naposledy zobrazené okno + + + Pokud je zatrženo, OnTopReplica se pokusí po spuštění obnovit naposledy zobrazované okno. + + + Nastavení... + + + Zobrazí okno s nastavením. + + + Přepnout do okna + + + Přepne do zdrojového okna a skryje aplikaci OnTopReplica. + + + Vybrat okno + + + - žádné - + + + Zobrazí seznam oken, které je možné použít jako zdroj. + + + - celé okno - + + + Aktuální výřez: + + + Smazat + + + Hotovo + + + Výška + + + Reset + + + Uložit + + + Uložené výřezy + + + Výřezy: + + + Šířka + + + Začněte klepnutím sem pravým tlačítkem myši... + + + Zavřít toto okno + + + Tyto klávesové zkratky jsou platné napříč systémem a je možné je použít i pokud OnTopReplica není aktivním oknem. + + + Zobrazit/Skrýt + + + Klávesové zkratky: + + + Jazyk: + + + Vyžaduje restart. + + + Nastavení + + + Zrušit aktualizaci +Aplikace OnTopReplica vás vyzve k aktualizaci při dalším startu. + + + Pokračovat +Instalovat OnTopReplica {0}. + + + Nová verze bude automaticky stažena a nainstalována. + + + Nainstalovaná verze: {0} +Dostupná verze: {1} + + + Verze {0} je k dispozici + + + staženo {0}/{1} bajtů. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Stahování... + + + Poslední verze aplikace OnTopReplica je již nainstalována. Aktualizace se kontrolují automaticky při každém spuštění. + +Na <a href="website">oficiálních stránkách</a> můžete sledovat aktuální vývoj aplikace nebo hlásit chyby či navrhovat vylepšení. + The website link should be enclosed in <a href="website"></a> tags. + + + Poslední stabilní verze byla vydána {0}. + {0} last version release date + + + OnTopReplica je aktuální + + + Instalovat +OnTopReplica bude nyní ukončena a spustí se aktualizace. + + + Nová verze {0} OnTopReplica je připravena k instalaci. + + + Aktualizace je připravena + + + Aktualizace OnTopReplica + + + + Must not be localized. Leave blank in non-default languages. + + + + Can be left blank. + + + + Must not be localized. Leave blank in non-default languages. + + + + Probably doesn't need localization. :) + + + Advanced + + \ No newline at end of file diff --git a/OnTopReplica/Strings.da.resx b/OnTopReplica/Strings.da.resx new file mode 100644 index 0000000..ea2a6a7 --- /dev/null +++ b/OnTopReplica/Strings.da.resx @@ -0,0 +1,650 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Annuller updateringen. + + + Vis detaljer om OnTopReplica. + + + Nulstil alle OnTopReplica indstillinger. + + + Opdater OnTopReplica nu. + + + En letvægts, live, miniature udgave af et vindue du vælger, der altid er øverst. + + + Opdater nu! + + + OnTopReplica checker automatiskt for opdateringer. + + + + Probably doesn't need localization. :) + + + Nulstil vinduet helt? + + + &NulstilAlle ændringer vil blive tabt. + + + Kan bruges til at nulstille alle indstillinger hvis du mister kontrollen over vinduet eller hvis det er flyttet uden for skærmen. + + + Nulstil + + + Nulstil indstillinger? + + + Dette nulstiller OnTopReplica til standard indstillingerne (alle gemte informationer, som gemte områder, vil blive slettet). + + + Nulstil indstillingerne + + + &Annuller + & marks the ALT+[] shortcut + + + Tegn områder med musen + + + Detaljer + + + Detaljer om Windows Aero + + + Windows Aero er kun tilgængelig op Windows Vista Home Premium eller højere. + + + Windows Aero effekter er ikke slået til + + + Du skal aktiverere "Windows Aero" som tema i Windows.For at gøre dette skal du højreklikke på skrivebordet og vælge personlige indstillinger. + + + Fejl detaljer. + + + Fejl: + + + Vinduet du har valgt er lukket eller er ikke gyldigt mere. + + + Fejl + + + Windows Aero effekter er ikke understøttet af dit styresystem. +Dette program kræver Windows Vista Home Premium eller bedre. + + + Skrivebords komposition ikke understøttet + + + Ingen miniature indlæst. + + + Kan ikke lave miniature. + + + Kunne ikke passes til vinduet. + + + Kan ikke søge efter opdateringer. + + + OnTopReplica blev ikke installeret ved hjælp af 'ClickOnce'. Du bliver nødt til at opdatere manuelt (besøg <a href="http://ontopreplica.codeplex.com">OnTopReplica's hjemmeside</a>). + + + Tilstande + + + Altid øverst + + + Får OnTopReplica til altid at være øverst. + + + Klikke igennem + + + OnTopReplica vil opføre sig som en gennemsigtig film der lader dig klikke igennem til de underliggende vinduer. + + + Standard + + + Opfører sig som et almindeligt vindue. Du kan trække andre viduer ind over OnTopReplica. + + + OnTopReplica fuld skærm + + + Hjemmeside: www.codeplex.com/ontopreplica. + + + Ønsker du at aktivere "click forwarding"? + + + Hvis denne funktion er aktiveret vil OnTopReplica vidersende alle venstr museklik til det klonede vindue (dette gør dig i stand til at udføre basis musefunktioner i det klonede vindue uden at skulle aktivere det). + +For at afslutte denne funktion skal du højreklikke på OnTopReplica og deaktivere "Click forwarding" i menuen. + + + Click forwarding + + + Ønskes gennem klik i fuldskærms tilstand? + + + Gennem klik virker kun hvis det er blevet aktiveret i gendan undermenuen og hvis vinduet er delvist gennemsigtigt. + + + I denne tilstand vil fuld skærm vinduet opføre sig som et delvist gennemsigtigt lag, hvilket gør dig i stand til at klikke på de underliggende vinduer. + +For at komme tilbage til normal tilstand, dobbeltklik på OnTopReplica ikonet i meddelelsesområdet på proceslinjen. + + + Nej. +Du kan aktivere gennem klik senere. + + + Brug gennem klik. + + + Gennem klik tilstand + + + OnTopReplica er blevet opdateret. + + + For at benytte den opdaterede udgave af OnTopReplica skal du genstarte programmet. + + + Opdatering fuldført + + + OnTopReplice er opdateret. + + + Ingen opdateringer er tilgængelige + + + Sprog + + + Om... + + + Skjuler hoved vinduet og viser om boxen. + + + Krom + + + Vælger Chrome kanten rundt om vinduet til/fra + + + Click forwarding + + + Aktiver "click forwarding" til det klonede vindue + + + Klikke igennem + + + OnTopReplica vil opføre sig som en gennemsigtig film der lader dig klikke igennem til de underliggende vinduer. + + + Luk + + + Lukker OnTopReplica. + + + 2:1 dobbelt + + + Fuld skærm + + + 1:2 halv + + + 1:1 Pas til vinduet + + + 1:4 kvart + + + 100% (uigennemsigtig) + + + Sæt OnTopReplica til at være helt uigennemsigtig. + + + 25% + + + Sætter OnTopReplica til 25% uigennemsigtighed. + + + 50% + + + Sætter OnTopReplica til 50% uigennemsigtighed. + + + 75% + + + Sætter OnTopReplica til 75% uigennemsigtighed. + + + Uigennemsigtighed + + + åben + + + Viser OnTopReplica. + + + Nederst venstre + + + Nederst højre + + + Position + + + Sæt OnTopReplica automatiskt på den aktuelle skærm. + + + Øverst venstre + + + Øverst højre + + + Afslut fuldskærm tilstand. + + + Gendan sidste position og størrelse + + + Vælger om OnTopReplica skal gemme sidst brugte størrelse og position, til næste gang det starter op. + + + Minimer til systembakken. + + + Minimere OnTopReplica til systembakken. + + + Vælg område... + + + Skifter til "område tilstand", der tillader dig at vælge et begrænset område af kildens vindue som miniature. + + + Nulstil vinduet + + + Nulstiller OnTopReplica indstillingerne og hoved vinduet. + + + Genskab + + + Skift til vindue + + + Skifter til kilde vinduet og gemmer OnTopReplica. + + + Vælg vindue + + + - ingen - + + + Viser en liste af vinduer du kan bruge som miniature kilde. + + + - hele - + + + Aktuelt område: + + + Slet + + + Færdig + + + Højde + + + Nulstil + + + Gem + + + Gemte områder + + + Områder: + + + Bredde + + + Højreklik her for at starte... + + + Annuller opdateringenOnTopReplica påminder dig igen næste gang det startes. + + + FortsætInstaller OnTopReplica + + + Den nye version vil automatiskt blive downloaded og installeret. + + + Installeret version: {0} +Tilgængelig version: {1} + + + Created by: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Care to contribute to the project? You are welcome to improve available translations, start a new one for your native language or to check out the % from CodePlex. + + + source code + + + OnTopReplica is based upon the WindowsFormsAero library and some other libraries and code sources. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Read the full credits + + + Contribute + + + Credits + + + License + + + Updates + + + The application is licensed under the % license, which meets the terms of the "open-source" definition specified by OSI. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + About OnTopReplica + + + Translators: {0} + {0} translators (do not end with period) + + + Christian Olaechea M., Daniel Zeus.EX, Federico Lorenzo, Goran Brecelj, Jan Romanczyk, Marco Kraxner, Patrik (batupata), Raúl Morillo, René Mihula, Roberto Leiro, Rodrigo Lourenço, Thomas Amundsen, Eric Hoffmann. + Must not be localized. Leave blank in non-default languages. + + + Version {0} + + + OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. + + + Disable + + + Enable Group mode + + + Select multiple windows to enable. + + + Group switch mode is enabled. + + + Group switch mode: + + + Windows + Column Header of list, simply refers to available windows to be cloned + + + Advanced + + + Group Switch mode + + + OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. + + + Center + + + Disabled + + + Restore last cloned window + + + When enabled, OnTopReplica will attempt to restore the last cloned window on start up. + + + Settings... + + + Displays the settings panel. + + + Clone current window + + + These system-wide shortcuts can also be used when OnTopReplica is not in focus. + + + Show/Hide + + + Hot keys: + + + Language: + + + Requires a restart. + + + Settings + + + Version {0} available + + + {0}/{1} bytes downloaded. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Downloading... + + + The latest version of OnTopReplica is already installed. The program automatically checks for updates at every start. + +You can keep up to date about OnTopReplica's development, suggest improvements and new features by <a href="website">visiting the official website</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Latest stable version released on {0}. + {0} last version release date + + + OnTopReplica is up to date + + + Install +OnTopReplica will be closed and the update installed. + + + OnTopReplica version {0} is ready to be installed on your computer. + + + Update ready + + + OnTopReplica updates + + \ No newline at end of file diff --git a/OnTopReplica/Strings.de.resx b/OnTopReplica/Strings.de.resx new file mode 100644 index 0000000..5197922 --- /dev/null +++ b/OnTopReplica/Strings.de.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Aktualisierungsprozess abbrechen. + + + Details über OnTopReplica anzeigen. + + + Alle Einstellungen zurücksetzen. + + + OnTopReplica jetzt aktualisieren. + + + Möchtest du dem Projekt helfen? Du kannst gerne existierende Übersetzungen verbessern, einen neue für deine Sprache hinzufügen, oder den % von CodePlex herunterladen. + + + Quelltext + + + OnTopReplica basiert auf der WindowsFormsAero Bibliothek und ein paar anderen Bibliotheken und Codequellen. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Lies die vollständige Quellenliste + + + Mitwirken + + + Quellen + + + Lizenz + + + Aktualisierungen + + + Das Programm ist unter der % Lizenz lizensiert, welche die Bedingungen der Definition von "open-source" nach OSI erfüllt. + + + Ein kleines echtzeit-Vorschaubild eines Fensters deiner Wahl, welches immer im Vordergrund bleibt. + + + Über OnTopReplica + + + Übersetzer: {0} + {0} translators (do not end with period) + + + Jetzt prüfen! + + + OnTopReplica sucht automatisch bei jedem Start nach Aktualisierungen. + + + Version {0} + + + + Probably doesn't need localization. :) + + + Fenster vollständig zurücksetzen? + + + &Zurücksetzen +Alle Einstellungen werden gelöscht. + + + Dies kann helfen, wenn die Kontrolle über das Fenster verloren wurde, oder es sich ausserhalb des sichtbaren Bereichs des Monitors befindet. + + + Zurücksetzen + + + Einstellungen zurücksetzen? + + + Dies wird alle Einstellungen löschen und OnTopReplica in den Installationszustand zurückführen (alle gespeicherten Daten, wie zum Beispiel gespeicherte Bereiche, gehen verloren). + + + Einstellungen zurücksetzen + + + {0}/{1} bytes heruntergeladen. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Version {0} ist verfügbar + + + Installieren +OnTopReplica wird geschlossen und die Aktualisierung installiert. + + + Eine neue Version kann von der offiziellen Webseite heruntergeladen und installiert werden. + + + OnTopReplica version {0} ist zur Installation auf dem Computer bereit. + + + &Abbrechen + & marks the ALT+[] shortcut + + + Zeichne Bereiche mit der Maus. + + + Details + + + Details zu Windows Aero + + + Windows Aero ist nur mit Windows Vista Home Premium or höher verfügbar. + + + 'Desktop-Gestaltung' ist nicht aktiviert. + + + Sie müssen die Desktop-Gestaltung aktivieren, indem sie 'Windows Aero' als das von Windows benutzte Anzeigeschema auswählen. + +Um dies zu tung rechtsklicken die auf den Desktop und wählen sie 'Anpassen'. + + + Fehler-details + + + Fehler: + + + Es scheint als wäre das gewählte Fenster geschlossen oder nicht länger gültig. + + + Fehler + + + Desktop-Gestaltung' wird auf diesem Betriebssystem nicht unterstützt. +Dieses Programm benötigt Windows Vista Home Premium oder besser. + + + Desktop-Gestaltung nicht unterstützt + + + Kein Vorschaubild geladen. + + + Vorschaubild konnte nicht erstellt werden + + + Das Fenster passt nicht in das Vorschaufenster. + + + Es konnte nicht nach Aktualisierungen gesucht werden. + + + Es scheint als wäre OnTopReplica nicht mittels 'ClickOnce' installiert. Sie werden manuell aktualisieren müssen (Besuchen sie <a href="http://ontopreplica.codeplex.com">OnTopReplica's Homepage</a>). + + + OnTopReplica konnte nicht nach einer Aktualisierung suchen. Stellen sie Sicher, dass sie mit dem Internet verbunden sind. Wenn sie mit dem Internet verbunden sind, könnte die Webseite temporäre Probleme haben. + + + Mode + + + Immer im Vordergrund + + + Erzwingt, dass OnTopReplica immer im Vordergrund bleibt. + + + Durchklicken + + + OnTopReplica wird alle Klicks an das darunterliegende Fenster weiterreichen. + + + Standard + + + Verhält sich wie ein normales Fenster. Andere Fenster können OnTopReplica verdecken. + + + OnTopReplica Vollbild + + + Deaktivieren + + + Modus aktivieren + + + Mehrere Fenster zum aktivieren auswählen. + + + Der Gruppenmodus ist aktiv. + + + Gruppenmodus: + + + Fenster + Column Header of list, simply refers to available windows to be cloned + + + Homepage: www.codeplex.com/ontopreplica. + + + Klickweiterleitung aktivieren? + + + OnTopReplica wird alle Linksklicks an das geklonte Fenster weiterreichen (dies erlaubt simple Interaktion ohne das andere Fenster zu aktivieren). + +Um diese Modus zu beenden ESC drücken. + + + Klickweiterleitung + + + Durchklickmodus aktivieren? + + + Durchklicken funktioniert nur, wenn es im "Grössen"-Menü aktiviert wurde und das Fenster semi-transparent ist. + + + In diesem Modus verhält sich das Vollbild-Fenster wie ein durchsichtiges Overlay und erlaubt es, die Fenster dahinter anzuklicken. + +Um zum normalen Modus zurückzukehren, reicht es, OnTopReplica über die Taskleiste oder das Benachrichtigungssymbol zu aktivieren. + + + Nein danke. +Durchklicken kann später aktiviert werden + + + Durchklicken aktivieren + + + Durchklick-Modus + + + OnTopReplica wurde aktualisiert. + + + Um die aktualisierte Version zu nutzen, muss OnTopReplica neu gestartet werden. + + + Aktualisierung abgeschlossen + + + OnTopReplica ist auf dem neuesten Stand. + + + Keine Aktualisierung verfügbar + + + Sprache + + + Über... + + + Versteckt das Hauptfenster und zeigt das Informationsfenster. + + + Erweitert + + + Fensterrahmen anzeigen + + + Schaltet den Fensterrahmen an und aus. + + + Klickweiterleitung aktivieren + + + Leitet klicks an das geklonte Fenster weiter. + + + Durchklicken aktivieren + + + OnTopReplica wird alle klicks an die darunterliegenden Fenster weiterleiten. + + + Schliessen + + + Schliesst OnTopReplica. + + + 2:1 Verdoppeln + + + Vollbild + + + 1:2 Halbieren + + + 1:1 An Fenster anpassen + + + 1:4 Vierteln + + + Gruppenmodus + + + OnTopReplica wird automatisch das zuletzt aktive Fenster aus einer benutzerdefinierten Gruppe klonen. + + + 100% (Undurchsichtig) + + + OnTopReplica ist völlig undurchsichtig. + + + 25% + + + OnTopReplica auf 25% Sichtbarkeit setzen. + + + 50% + + + OnTopReplica auf 50% Sichtbarkeit setzen. + + + 75% + + + OnTopReplica auf 75% Sichtbarkeit setzen. + + + Deckkraft + + + Öffnen + + + OnTopReplica anzeigen. + + + Unten Links + + + Unten Rechts + + + Mitte + + + Deaktiviert + + + Position feststlegen + + + OnTopReplica automatisch auf dem aktiven Bildschirm positionieren. + + + Oben Links + + + Oben Rechts + + + Vollbildmodus beenden + + + Letzte Position und Grösse merken + + + Legt fest, ob OnTopReplica beim Start die gleiche Position und Grösse haben soll, wie beim letzten Beenden. + + + Minimieren + + + Minimiert OnTopReplica in die Taskleiste (oder die Benachrichtigungsleiste). + + + Bereich wählen... + + + Wechselt zum "Bereichsmodus" welcher es erlaubt, nur einen ausgewählten Teil eines Fensters zu klonen. + + + Fenster zurücksetzen + + + Setzt OnTopReplica Einstellungen und das Fenster zurück. + + + Grösse + + + Letztes Fenster wieder wählen + + + OnTopReplica wird beim Start versuchen, das gleiche Fenster wie beim letzten beenden zu klonen. + + + Einstellungen... + + + Zeigt den Einstellungsdialog an. + + + Zum Fenster Wechseln + + + Wechselt zum geklonten Fenster und versteckt OnTopReplica. + + + Fenster wählen + + + - Keins - + + + Zeigt eine Liste von Fenstern die als Klonquelle gewählt werden können. + + + - Alles - + + + Aktueller Bereich: + + + Löschen + + + Fertig + + + Höhe + + + Zurücksetzen + + + Speichern + + + Gespeicherte Bereiche + + + Bereiche: + + + Breite + + + Hier rechtsklicken um zu beginnen... + + + Aktuelles Fenster klonen + + + Diese Tastenkombinationen können auch benutzt werden, wenn OnTopReplica nicht das aktive Fenster ist. + + + Zeigen/Verstecken + + + Tastenkombinationen: + + + Sprache: + + + Benötigt einen Neustart. + + + Herunterladen... + + + Aktualisierung bereit + + + Herunterladen +OnTopReplica {0} instalieren. + + + Aktualisierung abbrechen +OnTopReplica wird beim nächsten Start darauf hinweisen. + + + OnTopReplica ist aktuell + + + Neuste stabile Programmversion vom {0}. + {0} last version release date + + + Die aktuelle Version vom OnTopReplica ist schon installiert. Das Programm sucht automatisch bei jedem Start nach Aktualisierungen. + +Sie können über die Entwicklung von OnTopReplica auf dem Laufenden bleiben und verbesserungen vorschlagen indem sie die <a href="website">offizielle Webseite besuchen</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Einstellungen + + + OnTopReplica Aktualisierungen + + + Installierte Version: {0} +Verfügbare Version: {1} + + + Autor: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + + Must not be localized. Leave blank in non-default languages. + + \ No newline at end of file diff --git a/OnTopReplica/Strings.es.resx b/OnTopReplica/Strings.es.resx new file mode 100644 index 0000000..673af94 --- /dev/null +++ b/OnTopReplica/Strings.es.resx @@ -0,0 +1,650 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Cancela el progreso de actualización. + + + Muestra detalles acerca de OnTopReplica. + + + Reinicia la configuración de OnTopReplica a sus valores iniciales. + + + Actualiza OnTopReplica ahora. + + + Una copia liviana, en tiempo real y siempre encima de cualquier ventana. + + + Actualizar ahora! + + + OnTopReplica busca actualizaciones automáticamente. + + + + Probably doesn't need localization. :) + + + ¿Reiniciar la ventana? + + + &Reiniciar +Todos los ajustes se perderán. + + + Puede ser usado para reiniciar todos los ajustes si se ha perdido el control sobre las ventanas o se ha movido más allá de los bordes de la pantalla. + + + Reiniciar + + + ¿Reiniciar los ajustes? + + + Esta acción borrará todos los ajustes de OnTopReplica tras la instalación, volviendo a la configuración inicial (toda la información guardada, como las regiones personalizadas se perderán). + + + Reiniciar ajustes + + + &Cancelar + & marks the ALT+[] shortcut + + + Crea una región utilizando el ratón. + + + Detalles + + + Detalles en Windows Aero + + + Windows Aero sólo está disponible en Windows Vista o 7, en su versión Home Premium o superior. + + + La Composición de Escritorio no está activada. + + + Debe activar la Composición de Escritorio seleccionando "Windows Aero" como tema utilizado en Windows. + +Para ello, click derecho en el escritorio y buscar la opción en Personalizar. + + + Detalles del error + + + Error: + + + Parece que la ventana seleccionada ha sido cerrada o ya no es válida. + + + Error + + + La Composición de Escritorio no está soportada en su Sistema Operativo. +Es necesario utilizar Windows Vista o 7 en su versión Home Premium o superior. + + + Composición de Escritorio no soportada + + + No se ha clonado ninguna ventana. + + + Imposible clonar la ventana. + + + Imposible adaptar la ventana. + + + No se ha podido buscar actualizaciones. + + + Parece que OnTopReplica no ha podido ser instalado mediante "ClickOnce". Tendrá que actualizar manualmente visitando <a href="http://ontopreplica.codeplex.com">la homepage del progetto</a>. + + + OnTopReplica no ha podido comprobar si hay una actualización disponible. Asegúrese de que está conectado a Internet. Si lo está, quizá la página oficial está temporalmente no disponible. + + + Modo + + + Siempre encima + + + OnTopReplica permanece siempre encima. + + + Click a través + + + OnTopReplica se comporta como una ventana transparente a través de la cual puede clickar lo que se encuentra detrás. + + + Ventana standard + + + OnTopReplica se comporta como una ventana corriente de Windows, por lo tanto puede estar en segundo plano. + + + OnTopReplica a pantalla completa + + + Desactivar + + + Activar modo + + + Seleccionar varias ventanas para activar. + + + Modo en grupo activado + + + Modo en grupo: + + + Ventanas + Column Header of list, simply refers to available windows to be cloned + + + Sitio oficial: www.codeplex.com/ontopreplica. + + + Desea activar el "Click en la ventana clonada"? + + + Si este modo está activado, OnTopReplica permitirá hacer click en la ventana clonada (de esta forma se podrán hacer operaciones básicas con el ratón sin tener que activar la ventana original). + +Para salir de este modo, pulsar ESC. + + + Click en la ventana clonada + + + Activar el modo Click a través? + + + Click a través solo funciona si se ha activado y la ventana es semi-transparente. + + + En este modo, la ventana clonada se volverá ventana parcialmente transparente, permitiendo hacer click en las otras ventanas de detrás. + +Para volver al modo normal en cualquier momento, activar OnTopReplica clickando en la barra de tareas (o en el icono del sistema). + + + No, gracias. +Se podrá activar Click a través más tarde + + + Utilizar Click a través + + + Modo Click a través + + + OnTopReplica ha sido actualizado. + + + Para poder utilizar la versión actualizada de OnTopReplica se ha de reiniciar la aplicación. + + + Actualización correcta. + + + OnTopReplica está actualizado. + + + No hay actualizaciones disponibles + + + Idioma + + + Acerca de + + + Oculta la ventana principal y muestra la ventana de "Acerca de" + + + Avanzado + + + Marco + + + Activa o desactiva el marco de la ventana. + + + Activar Click en la ventana clonada + + + Activa "Click en la ventana clonada" en la ventana que se ha clonado. + + + Activar Click a través + + + OnTopReplica se comporta como una ventana transparente a través de la cual puede hacer click sobre lo que se encuentra detrás. + + + Cerrar + + + Cierra OnToopReplica + + + 2:1 Doble + + + Pantalla completa + + + 1:2 Mitad + + + 1:1 Tamaño original + + + 1:4 Un cuarto + + + Modo en grupo + + + OnTopReplica clonará automáticamente una ventana de un grupo definido, eligiendo la que no ha estado en primer plano durante más tiempo. + + + 100% (opaco) + + + OnTopReplica será totalmente opaco. + + + Establece OnTopReplica al 25% de opacidad. + + + Establece OnTopReplica al 50% de opacidad. + + + Establece OnTopReplica al 75% de opacidad. + + + Opacidad + + + Abrir + + + Muestra OnTopReplica. + + + Abajo a la izquierda + + + Abajo a la derecha + + + Centrado + + + Desactivado + + + Posición + + + Posiciona automáticamente OnTopReplica sobre el monitor actual. + + + Arriba a la izquierda + + + Arriba a la derecha + + + Salir del modo pantalla completa + + + Restaurar última posición y tamaño + + + Activa o desactiva si OnTopReplica debe guardar la última posición y tamaño y usarla cuando se reinicie. + + + Minimizar + + + Minimiza OnTopReplica a la barra de tareas (o de sistema). + + + Seleccionar región + + + Activa o desactiva "Seleccionar región", que permite seleccionar una región específica de la ventana clonada. + + + Reiniciar ventana + + + Reinicia los ajustes de OnTopReplica y la ventana principal + + + Cambiar tamaño + + + Ir a la ventana original + + + Activa la ventana original y oculta OnTopReplica. + + + Seleccionar ventana + + + - ninguna - + + + Muestra una lista de ventanas que se pueden clonar. + + + - entera - + + + Región actual: + + + Borrar + + + Hecho + + + Altura + + + Reiniciar ventana + + + Guardar + + + Regiones guardadas + + + Regiones: + + + Anchura + + + Click derecho para empezar... + + + Cancelar actualización +OnTopReplica le preguntará la próxima vez que se ejecute. + + + Descargar +Instalar OnTopReplica {0} + + + La nueva versión puede ser descargada e instalada del sitio oficial. + + + Versión instalada: {0} +Versión disponible: {1} + + + Autor: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Contribuye con el proyecto. + Unfinished. + + + código fuente + + + OnTopReplica está basado en la librería WindowsFormsAero y otras librerías y códigos fuente. %. + + + Leer los créditos completos + + + Contribuir + + + Créditos + + + Licencia + + + Actualizaciones + + + La aplicación está bajo la licencia %, por lo que rigen los términos de la definición "open-source" especificada por OSI. + + + + Can be left blank. + + + Acerca de OnTopReplica + + + Traductores: {0} + {0} translators (do not end with period) + + + + Must not be localized. Leave blank in non-default languages. + + + Versión: {0} + + + 25% + + + 50% + + + 75% + + + Restaurar la última ventana clonada + + + Si está activado, OnTopReplica intentará restaurar la última ventana clonada al iniciarse. + + + Ajustes... + + + Muestra el panel de ajustes. + + + Clona ventana actual + + + Los atajos de teclado pueden ser utilizados aunque OnTopReplica no esté en primer plano. + + + Mostrar/ocultar + + + Atajos de teclado: + + + Idioma: + + + Requiere reinicio. + + + Ajustes + + + Versión {0} disponible + + + {0}/{1} bytes descargados. + + + Descargando... + + + La última versión de OnTopReplica ya está instalada. El programa buscará actualizaciones automáticamente con cada inicio. + +Puedes mantenerte informado del desarrollo de OnTopReplica, sugerir mejoras y nuevas características <a href="website">visitando la web oficial</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Última versión estable liberada en {0}. + {0} last version release date + + + OnTopReplica está actualizado + + + Instalar +OnTopReplica se cerrará y se instalará la actualización. + + + La versión de OnTopReplica {0} está lista para ser instalada en su ordenador. + + + Actualización lista + + + Actualizaciones de OnTopReplica + + \ No newline at end of file diff --git a/OnTopReplica/Strings.fi.resx b/OnTopReplica/Strings.fi.resx new file mode 100644 index 0000000..f50a611 --- /dev/null +++ b/OnTopReplica/Strings.fi.resx @@ -0,0 +1,15 @@ + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/OnTopReplica/Strings.it.resx b/OnTopReplica/Strings.it.resx new file mode 100644 index 0000000..a2177be --- /dev/null +++ b/OnTopReplica/Strings.it.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Creato da: %. + Link % is replaced by string AboutAuthorContent. + + + Annulla il processo di aggiornamento. + + + Mostra dettagli su OnTopReplica. + + + Resetta tutte le impostazioni di OnTopReplica. + + + Aggiorna OnTopReplica ora. + + + T'interessa partecipare? Ogni aiuto è ben accetto, sia che tu voglia migliorare una traduzione, aggiungerne una nuova oppure dare un'occhiata al % su CodePlex. + + + codice sorgente + + + OnTopReplica è basato sulla libreria WindowsFormsAero ed il codice di altri progetti open-source. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Leggi tutti i riferimenti + + + Contribuisci + + + Ringraziamenti + + + Licenza d'uso + + + Aggiornamenti + + + Questa applicazione è rilasciata sotto la licenza %, che rientra nella definizione di "open-source" data dal consorzio OSI. + + + Una copia in tempo reale e sempre in primo piano di una finestra a tua scelta. + + + A proposito di OnTopReplica + + + Traduttori: {0} + {0} translators (do not end with period) + + + Controlla! + + + OnTopReplica controlla automaticamente la presenza di aggiornamenti ad ogni avvio. + + + Versione {0} + + + + Probably doesn't need localization. :) + + + Ripristinare completamente la finestra? + + + &Ripristina +Tutte le impostazioni saranno perse. + + + Può essere usato se si è perso il controllo della finestra o si è spostata oltre ai bordi dello schermo. + + + Ripristino + + + Resettare impostazioni? + + + Questa procedura resetterà tutte le impostazioni di OnTopReplica e cancellerà tutte le informazioni memorizzate (come, ad esempio, le regioni salvate). + + + Reimposta + + + &Annulla + & marks the ALT+[] shortcut + + + Disegna una regione usando il mouse. + + + Dettagli + + + Dettagli su Windows Aero + + + Windows Aero è disponibile soltanto su Windows Vista Home Premium o superiore. + + + Il servizio di Desktop Composition Aero non è attivo. + + + È necessario attivare la "composizione del desktop" (DWM) selezionando "Windows Aero" come tema utilizzato da Windows. + +Per farlo, clicca col tasto destro del mouse sul desktop e poi su Personalizza. + + + Dettagli errore + + + Errore: + + + Sembra che la finestra selezionata sia stata chiusa o che non sia più valida. + + + Errore + + + La "composzione del desktop" non è supportata dal tuo sistema operativo. +È necessario utilizzare Windows Vista o superiore per avviare OnTopReplica. + + + Desktop Composition (DWM) non supportato + + + Nessuna finestra clonata al momento. + + + Impossibile clonare la finestra + + + Impossibile adattare la finestra. + + + Impossibile controllare gli aggiornamenti. + + + Sembra che OnTopReplica non sia stato installato usando 'ClickOnce'. Sarà necessario aggiornare manualmente il programma visitando <a href="http://ontopreplica.codeplex.com">la homepage del progetto</a>. + + + Non è stato possibile controllare se esiste una versione più aggiornata di OnTopReplica. Verificare di essere connessi ad Internet. Se la connessione è attiva, è possibile che il sito ufficiale sia temporaneamente offline. + + + Modalità + + + Sempre in cima + + + OnTopReplica sarà sempre la finestra sopra a tutte le altre. + + + Click through + + + OnTopReplica si comporterà come uno schermo trasparente, che permette di cliccare sulle finestre al di sotto. + + + Normale + + + Si comporta come una finestra normale. Puoi portare altre finestre sopra OnTopReplica. + + + OnTopReplica a pieno schermo + + + Disattiva + + + Abilita modalità + + + Seleziona più finestre per attivare. + + + Modalità Gruppo attivata. + + + Modalità Gruppo di finestre: + + + Finestre + Column Header of list, simply refers to available windows to be cloned + + + Sito internet: www.codeplex.com/ontopreplica. + + + Attivare la modalità di inoltro dei clic? + + + In questa modalità, OnTopReplica inoltrerà tutti i clic del pulsante sinistro sul clone della finestra alla finestra originale (questo permetterà di interagire in maniera basilare con la finestra clonata, senza averla in primo piano). + +Per uscire da questa modalità, usa il tasto ESC. + + + Inoltro dei clic + + + Attivare la modalità Click-Through? + + + La modalità "Click-Through" funziona solo se l'opzione è stata attivata e se la finestra è semitrasparente. + + + In questa modalità la finestra clonata si comporterà come una maschera semitrasparente che permette di cliccare sulle finestre dietro di essa. + +Per tornare alla modalità normale in qualsiasi momento, attiva OnTopReplica (dalla barra delle applicazioni). + + + No, grazie. +Puoi abilitare il Click-Through in futuro + + + Abilita Click-Through + + + Modalità Click-Through + + + OnTopReplica è stato aggiornato. + + + Per utilizzare la nuova versione di OnTopReplica è necessario riavviare l'applicazione. + + + Aggiornamento completato + + + La versione più aggiornata è già installata. + + + Nessun aggiornamento disponibile + + + Lingua + + + A proposito di... + + + Nasconde la finestra principale e mostra una schermata di informazioni. + + + Avanzate + + + Bordo + + + Abilita o disabilita il bordo della finestra. + + + Inoltro dei clic + + + Attiva la modalità di "inoltro dei clic" alla finestra clonata. + + + Abilita Click-Through + + + OnTopReplica si comporterà come una schermata trasparente, permettendo di cliccare sulle finestre al di sotto di essa. + + + Chiudi + + + Termina OnTopReplica. + + + 2:1 Doppio + + + Tutto schermo + + + 1:2 Metà + + + 1:1 Clone esatto + + + 1:4 Quarto + + + Modalità Gruppo di finestre + + + OnTopReplica clonerà automaticamente una finestra di un gruppo, scegliendo quella che non è stata in primo piano da più tempo. + + + 100% (opaco) + + + Imposta OnTopReplica come finestra completamente opaca. + + + 25% + + + Imposta l'opacità di OnTopReplica al 25%. + + + 50% + + + Imposta l'opacità di OnTopReplica al 50%. + + + 75% + + + Imposta l'opacità di OnTopReplica al 75%. + + + Opacità + + + Apri + + + Attiva la finestra di OnTopReplica. + + + In basso a sinistra + + + In basso a destra + + + Centrato + + + Disabilitato + + + Blocco posizione + + + Posiziona automaticamente OnTopReplica sul monitor corrente. + + + In alto a sinistra + + + In alto a destra + + + Esci da tutto schermo + + + Ripristina posizione e grandezza + + + Imposta se, al prossimo avvio di OnTopReplica, debbano essere ripristinati i valori di grandezza e posizione della finestra alla chiusura. + + + Minimizza + + + Riduce OnTopReplica ad un'icona nella barra delle applicazioni. + + + Seleziona regione... + + + Passa alla modalità di "selezione di regione", che permette di limitare la porzione di finestra che viene clonata. + + + Reimposta finestra + + + Reimposta OnTopReplica e la sua finestra principale. + + + Ridimensionamento + + + Ripristina ultima finestra + + + Se abilitato, all'avvio OnTopReplica tenterà di ripristinare l'ultima finestra precedentemente clonata. + + + Impostazioni... + + + Mostra il pannello delle impostazioni. + + + Vai alla finestra originale + + + Mostra la finestra originale e nasconde OnTopReplica. + + + Seleziona finestra + + + - nessuna - + + + Mostra una lista di finestre che è possibile clonare. + + + - intera - + + + Regione corrente: + + + Cancella + + + Chiudi + + + Altezza + + + Reset + + + Salva + + + Regioni memorizzate + + + Regioni: + + + Larghezza + + + Clic destro qui per iniziare... + + + Clona finestra corrente + + + Queste scorciatoie possono essere usate quando OnTopReplica non è attivo. + + + Nascondi + + + Scorciatoie: + + + Lingua: + + + Richiede un riavvio. + + + Impostazioni + + + Annulla aggiornamento +OnTopReplica si aggiornerà in un secondo momento. + + + Continua +Scarica OnTopReplica {0}. + + + Sarà possibile scaricare la nuova versione ed installarla. + + + Versione installata: {0} +Versione disponibile: {1} + + + Disponibile la versione {0} + + + Scaricati {0} byte su {1}. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Download in corso... + + + L'ultima versione di OnTopReplica è già installata. Il programma controllo automaticamente la presenza di aggiornamenti ad ogni avvio. + +Per tenersi aggiornati sullo sviluppo di OnTopReplica o suggerire miglioramenti, <a href="website">visitare il sito ufficiale</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Ultima versione stabile rilasciata il {0}. + {0} last version release date + + + OnTopReplica è aggiornato + + + Installa +OnTopReplica verrà chiuso e l'aggiornamento sarà installato. + + + La versione {0} di OnTopReplica è pronta ad essere installata sul tuo computer. + + + Aggiornamento pronto + + + Aggiornamenti di OnTopReplica + + + + Must not be localized. Leave blank in non-default languages. + + + + Can be left blank. + + + + Must not be localized. Leave blank in non-default languages. + + \ No newline at end of file diff --git a/OnTopReplica/Strings.no.resx b/OnTopReplica/Strings.no.resx new file mode 100644 index 0000000..3f04f24 --- /dev/null +++ b/OnTopReplica/Strings.no.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Created by: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Abort update process. + + + Show details about OnTopReplica. + + + Reset all OnTopReplica settings. + + + Update OnTopReplica now. + + + Care to contribute to the project? You are welcome to improve available translations, start a new one for your native language or to check out the % from CodePlex. + + + source code + + + OnTopReplica is based upon the WindowsFormsAero library and some other libraries and code sources. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Read the full credits + + + Contribute + + + Credits + + + License + + + Updates + + + The application is licensed under the % license, which meets the terms of the "open-source" definition specified by OSI. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + A lightweight, real-time, always on top thumbnail of a window of your choice. + + + About OnTopReplica + + + Translators: {0} + {0} translators (do not end with period) + + + Christian Olaechea M., Daniel Zeus.EX, Federico Lorenzo, Goran Brecelj, Jan Romanczyk, Marco Kraxner, Patrik (batupata), Raúl Morillo, René Mihula, Roberto Leiro, Rodrigo Lourenço, Thomas Amundsen, Eric Hoffmann. + Must not be localized. Leave blank in non-default languages. + + + Check now! + + + OnTopReplica automatically checks for updates at every start up. + + + Version {0} + + + + Probably doesn't need localization. :) + + + Reset window completely? + + + &Reset +All settings will be lost. + + + Can be used to reset all settings if you lost control over the window or moved it beyond the screen boundary. + + + Reset + + + Reset settings? + + + This will erase all settings of OnTopReplica, returning it to the original state right after installation (all saved information, like stored regions, will be lost). + + + Reset settings + + + &Cancel + & marks the ALT+[] shortcut + + + Draw regions using mouse. + + + Details + + + Details on Windows Aero + + + Windows Aero is only available on Windows Vista Home Premium or higher. + + + 'Desktop Composition' is not enabled. + + + You must enable desktop composition, by selecting 'Windows Aero' as the theme used by Windows. + +To do so, right-click on the desktop and click on Personalize. + + + Error details + + + Error: + + + It appears that the selected window has been closed or is not valid anymore. + + + Error + + + Desktop Composition' is not supported on your Operating System. +You must run this application on Windows Vista Home Premium or better. + + + Desktop Composition unsupported + + + No thumbnail loaded. + + + Unable to create thumbnail + + + Unable to fit window. + + + Unable to check for updates. + + + It appears that OnTopReplica wasn't installed using 'ClickOnce'. You'll have to update manually (visit <a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>). + + + OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. + + + Mode + + + Always on top + + + Forces OnTopReplica to stay always on top. + + + Click through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Standard + + + Behaves like an ordinary window. You can bring other windows above OnTopReplica. + + + OnTopReplica fullscreen + + + Disable + + + Enable Group mode + + + Select multiple windows to enable. + + + Group switch mode is enabled. + + + Group switch mode: + + + Windows + Column Header of list, simply refers to available windows to be cloned + + + Homepage: www.codeplex.com/ontopreplica. + + + Do you want to enable "click forwarding"? + + + If this mode is enabled, OnTopReplica will forward all left mouse clicks to the window that is being cloned (this will allow you to do basic mouse operations on the cloned window without having to activate it). + +To exit this mode, push ESC. + + + Click forwarding + + + Enable Click-Through mode? + + + Click-through only works if it has been enabled in the Resize submenu and if the window is semi-transparent. + + + In this mode the fullscreen window will behave as a partially transparent overlay, allowing you to click on the other windows behind it. + +To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). + + + No, thank you. +You can enable click-through later + + + Use Click-Through + + + Click-Through mode + + + OnTopReplica has been updated. + + + In order to use the updated version of OnTopReplica you'll have to restart the application. + + + Update successful + + + OnTopReplica is up to date. + + + No update available + + + Language + + + About... + + + Hides the main window and displays the "about" box. + + + Advanced + + + Show window border + + + Toggles the display of the window border. + + + Enable Click forwarding + + + Enable "click forwarding" to the cloned window. + + + Enable Click-Through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Close + + + Closes OnTopReplica. + + + 2:1 Double + + + Fullscreen + + + 1:2 Half + + + 1:1 Fit to window + + + 1:4 Quarter + + + Group Switch mode + + + OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. + + + 100% (opaque) + + + Sets OnTopReplica to be completely opaque. + + + 25% + + + Sets OnTopReplica to 25% opacity. + + + 50% + + + Sets OnTopReplica to 50% opacity. + + + 75% + + + Sets OnTopReplica to 75% opacity. + + + Opacity + + + Open + + + Displays OnTopReplica. + + + Bottom Left + + + Bottom Right + + + Center + + + Disabled + + + Position lock + + + Automatically position OnTopReplica on the current screen. + + + Top Left + + + Top Right + + + Quit fullscreen mode + + + Recall last position and size + + + Toggles whether OnTopReplica should store its last position and size and use them when it is restarted. + + + Minimize + + + Minimizes OnTopReplica to the task bar (or the tray). + + + Select region... + + + Switches to "region mode", that allows you to select a limited region of the source's window as thumbnail. + + + Reset window + + + Resets OnTopReplica settings and its main window. + + + Resize + + + Restore last cloned window + + + When enabled, OnTopReplica will attempt to restore the last cloned window on start up. + + + Settings... + + + Displays the settings panel. + + + Switch to window + + + Switches to the source window and hides OnTopReplica. + + + Select window + + + - none - + + + Displays a list of window you can select as thumbnail source. + + + - whole - + + + Current region: + + + Delete + + + Done + + + Height + + + Reset + + + Save + + + Stored regions + + + Regions: + + + Width + + + Right-click here to start... + + + Clone current window + + + These system-wide shortcuts can also be used when OnTopReplica is not in focus. + + + Show/Hide + + + Hot keys: + + + Language: + + + Requires a restart. + + + Settings + + + Cancel update +OnTopReplica will prompt you the next time it is started. + + + Download +Install OnTopReplica {0}. + + + The new version can be downloaded and installed from the official website. + + + Installed version: {0} +Available version: {1} + + + Version {0} available + + + {0}/{1} bytes downloaded. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Downloading... + + + The latest version of OnTopReplica is already installed. The program automatically checks for updates at every start. + +You can keep up to date about OnTopReplica's development, suggest improvements and new features by <a href="website">visiting the official website</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Latest stable version released on {0}. + {0} last version release date + + + OnTopReplica is up to date + + + Install +OnTopReplica will be closed and the update installed. + + + OnTopReplica version {0} is ready to be installed on your computer. + + + Update ready + + + OnTopReplica updates + + \ No newline at end of file diff --git a/OnTopReplica/Strings.pl.resx b/OnTopReplica/Strings.pl.resx new file mode 100644 index 0000000..bf277d9 --- /dev/null +++ b/OnTopReplica/Strings.pl.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Autor: %. + Link % is replaced by string AboutAuthorContent. + + + Przerwij proces aktualizacji. + + + Pokaż szczegóły dotyczące OnTopReplica. + + + Resetuj wszystkie ustawienia OnTopReplica. + + + Aktualizuj teraz OnTopReplica + + + Chcesz wesprzeć projekt? Możesz ulepszyć istniejące tłumaczenia, utworzyć nowe dla Twojego rodzimego języka lub sprawdzić % na CodePlex. + + + kod źródłowy + + + OnTopReplica jest oparty na bibliotece WindowsFormsAero oraz innych bibliotekach i kodzie źródłowym. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Przeczytaj więcej + + + Wsparcie + + + Zasługi + + + Licencja + + + Aktualizacje + + + Aplikacja jest licencjonowana na warunkach licencji %, która spełnia warunki definicji "open-source" definiowane przez OSI. + + + Miniatura "zawsze na wierzchu" pokazująca "na żywo" podgląd wybranego okna. + + + O programie OnTopReplica + + + Tłumaczenie: {0} + {0} translators (do not end with period) + + + Sprawdź teraz! + + + OnTopReplica automatycznie sprawdza dostępność aktualizacji po każdym uruchomieniu. + + + Wersja {0} + + + + Probably doesn't need localization. :) + + + Całkowicie zresetować okno? + + + &Zresetuj +Wszystkie ustawienia zostaną utracone. + + + Może być użyte do zresetowania ustawień, jeśli została utracona kontrola nad oknem, lub zostało ono przesunięte poza granice ekranu. + + + Zresetuj + + + Zresetować ustawienia? + + + Ta opcja usunie wszystkie ustawienia spersonalizowane OnTopReplica i przywróci program do stanu jak po instalacji (wszystkie zapisane ustawienia, jak regiony, zostaną utracone). + + + Zresetuj ustawienia + + + &Anuluj + & marks the ALT+[] shortcut + + + Utwórz region używając myszy. + + + Szczegóły + + + Szczegóły dot. Windows Aero + + + Windows Aero jest dostępne w wersji Windows Vista Home Premium i nowszych. + + + Kompozycje pulpitu są wyłączone. + + + Musisz włączyć kompozycje pulpitu wybierając 'Windows Aero' jako schemat używany przez Windows. + +Aby to uczynić kliknij prawym przyciskiem na pulpicie i wybierz 'Personalizuj'. + + + Szczegóły błędu + + + Błąd: + + + Wygląda na to, że wybrane okno zostało zamknięte lub nie jest już dostępne. + + + Błąd + + + Kompozycje pulpitu nie są wspierane przez Twój system operacyjny. +Aplikacja działa na Windows Vista Home Premium i nowszych. + + + Niewspierana kompozycja pulpitu + + + Nie załadowano miniatury. + + + Nie można utworzyć miniatury. + + + Nie można dopasować okna. + + + Nie można sprawdzić aktualizacji. + + + Wygląda na to, że OnTopReplica nie została zainstalowana przy użyciu 'ClickOnce'. Musisz ręcznie zaktualizować program (odwiedź <a href="http://ontopreplica.codeplex.com">stronę domową OnTopReplica's</a>). + + + Program OnTopReplica nie był w stanie sprawdzić, czy jest dostępna nowa wersja. Upewnij się, że Twoje połączenie z Internetem pracuje poprawnie. Jeśli tak, być może strona programu jest chwilowo niedostępna. + + + Tryb + + + Zawsze na wierzchu + + + Wymusza położenie okna OnTopReplica zawsze na wierzchu. + + + Kliknij-przez + + + OnTopReplica będzie się zachowywać jak półprzeźroczysta warstwa, co pozwoli Ci klikać na oknie położonym pod spodem. + + + Standardowe + + + Zachowanie jak normalne okno. Możesz przeciągnąć inne okna ponad OnTopReplica. + + + Pełny ekran OnTopReplica + + + Wyłącz + + + Włącz tryb grupowy + + + Wybierz kilka okien aby uaktywnić. + + + Tryb grupowy jest aktywny. + + + Tryb grupowy: + + + Okna + Column Header of list, simply refers to available windows to be cloned + + + Strona domowa: www.codeplex.com/ontopreplica. + + + Czy uaktywnić "przekazywanie kliknięć"? + + + Kiedy ten tryb jest aktywny, OnTopReplica będzie przekazywać kliknięcia przycisków myszy do okna, które jest klonowane (dzięki temu możesz wykonywać na tym oknie podstawowe operacje bez konieczności uaktywniania go). + +Naciśnij ESC aby zakończyć ten tryb. + + + Przekazywanie kliknięć + + + Włączyć tryb kliknij-przez? + + + Kliknij-przez działa tylko wtedy, gdy zostało włączone w podmenu 'Zmień rozmiar' i kiedy okno jest półprzeźroczyste. + + + W tym trybie okno na pełnym ekranie będzie się zachowywać jak półprzeźroczysta warstwa i będziesz w stanie kliknąć na oknie znajdującym się pod nim. + +Aby w dowolnym momencie powrócić do normalnego trybu aktywuj OnTopReplica klikając na pasku zadań (lub na ikonce w tacce systemowej). + + + Nie, dziękuję. +Możesz włączyć kliknij-przez później + + + Użyj kliknij-przez + + + Tryb kliknij-przez + + + Program OnTopReplica został zaktualizowany. + + + Aby używać zaktualizowanej wersji OnTopReplica musisz zrestartować aplikację. + + + Aktualizacja zakończona powodzeniem + + + Program OnTopReplica jest aktualny. + + + Brak dostępnych aktualizacji + + + Język + + + O... + + + Wyświetla informacje o programie. + + + Zaawansowane + + + Pokazuj ramkę okna + + + Przełącznik wyświetlania ramki okna. + + + Włącz przekazywanie kliknięć + + + Uaktywnia przekazywanie kliknięć do klonowanego okna. + + + Włącz kliknij-przez + + + OnTopReplica będzie się zachowywać jak półprzeźroczysta warstwa i będziesz w stanie kliknąć na oknie znajdującym się pod nim. + + + Zamknij + + + Zamyka OnTopReplica. + + + 2:1 Podwójny + + + Pełny ekran + + + 1:2 Połowa + + + 1:1 Rozmiar oryginalny + + + 1:4 Ćwiartka + + + Tryb grupowy + + + OnTopReplica automatycznie sklonuje okno ze zdefiniowanej przez użytkownika grupy przełączając na to, które było najwcześniej zdeaktywowane. + + + 100% (nieprzeźroczyste) + + + Ustawia OnTopReplica jako całkowicie nieprzeźroczyste. + + + 25% + + + Ustawia przeźroczystość OnTopReplica na 25%. + + + 50% + + + Ustawia przeźroczystość OnTopReplica na 50%. + + + 75% + + + Ustawia przeźroczystość OnTopReplica na 75%. + + + Przeźroczystość + + + Otwórz + + + Wyświetla OnTopReplica. + + + Dół Lewo + + + Dół Prawo + + + Środek + + + Wyłączone + + + Zablokuj pozycję + + + Automatycznie ustawia pozycję OnTopReplica na bieżącym ekranie. + + + Góra Lewo + + + Góra Prawo + + + Wyjdź z trybu pełnoekranowego + + + Zapamiętaj ostatnią pozycję i rozmiar + + + Wybierz, czy OnTopReplica powinien zapamiętać ostatnią pozycję i rozmiar i użyć ich ponownie przy kolejnym uruchomieniu. + + + Minimalizuj + + + Minimalizuje OnTopReplica do paska zadań (lub tacki systemowej). + + + Wybierz region... + + + Przełącza na "tryb regionu", w którym można zaznaczyć jako miniaturę określony obszar okna źródłowego. + + + Resetuj okno + + + Resetuje ustawienia OnTopReplica i okna głównego. + + + Zmień rozmiar + + + Przywróć ostatnio klonowane okno + + + Kiedy włączone, OnTopReplica będzie próbować podczas uruchomienia przywrócić ostatnio klonowane okno. + + + Ustawienia... + + + Wyświetla okno konfiguracji. + + + Przełącz na okno + + + Przełącza na okno źródłowe i ukrywa okno OnTopReplica. + + + Wybierz okno + + + - żadne - + + + Wyświetla listę okien, które możesz wybrać jako źródło miniatur. + + + - całe - + + + Bieżący region: + + + Usuń + + + Gotowe + + + Wysokość + + + Zresetuj + + + Zapisz + + + Zapisane regiony + + + Regiony: + + + Szerokość + + + Kliknij prawym tutaj aby rozpocząć... + + + Sklonuj bieżące okno + + + Skróty klawiszowe działają również wtedy, gdy okno OnTopReplica nie jest aktywne. + + + Pokaż/Ukryj + + + Klawisze skrótu: + + + Język: + + + Wymaga restartu. + + + Ustawienia + + + Anuluj aktualizację +OnTopReplica zapyta Cię przy następnym uruchomieniu. + + + Pobierz +Zainstaluj OnTopReplica {0}. + + + Nowa wersja może zostać pobrana i zainstalowana z oficjalnej strony programu. + + + Zainstalowana wersja: {0} +Dostępna wersja: {1} + + + Dostępna jest wersja {0} + + + pobrano {0}/{1} bajtów. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Pobieram... + + + Najnowsza wersja OnTopReplica jest już zainstalowana. Program automatycznie sprawdza dostępność aktualizacji po każdym uruchomieniu. + +Na <a href="website">oficjalnej stronie domowej</a> możesz znaleźć informacje o rozwoju OnTopReplica's oraz zaproponować nowe funkcje. + The website link should be enclosed in <a href="website"></a> tags. + + + Ostatnia wersja stabilna wydana {0}. + {0} last version release date + + + OnTopReplica jest aktualna + + + Zainstaluj +Aktualizacje zostaną zainstalowane po ponownym uruchomieniu OnTopReplica. + + + Wersja {0} OnTopReplica jest gotowa do zainstalowania. + + + Aktualizacja ukończona + + + Aktualizacje OnTopReplica + + + + Must not be localized. Leave blank in non-default languages. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + + Must not be localized. Leave blank in non-default languages. + + \ No newline at end of file diff --git a/OnTopReplica/Strings.pt-BR.resx b/OnTopReplica/Strings.pt-BR.resx new file mode 100644 index 0000000..6f4f6c9 --- /dev/null +++ b/OnTopReplica/Strings.pt-BR.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Created by: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Abort update process. + + + Show details about OnTopReplica. + + + Reset all OnTopReplica settings. + + + Update OnTopReplica now. + + + Care to contribute to the project? You are welcome to improve available translations, start a new one for your native language or to check out the % from CodePlex. + + + source code + + + OnTopReplica is based upon the WindowsFormsAero library and some other libraries and code sources. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Read the full credits + + + Contribute + + + Credits + + + License + + + Updates + + + The application is licensed under the % license, which meets the terms of the "open-source" definition specified by OSI. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + A lightweight, real-time, always on top thumbnail of a window of your choice. + + + About OnTopReplica + + + Translators: {0} + {0} translators (do not end with period) + + + Christian Olaechea M., Daniel Zeus.EX, Federico Lorenzo, Goran Brecelj, Jan Romanczyk, Marco Kraxner, Patrik (batupata), Raúl Morillo, René Mihula, Roberto Leiro, Rodrigo Lourenço, Thomas Amundsen, Eric Hoffmann. + Must not be localized. Leave blank in non-default languages. + + + Check now! + + + OnTopReplica automatically checks for updates at every start up. + + + Version {0} + + + OnTopReplica + Probably doesn't need localization. :) + + + Reset window completely? + + + &Reset +All settings will be lost. + + + Can be used to reset all settings if you lost control over the window or moved it beyond the screen boundary. + + + Reset + + + Reset settings? + + + This will erase all settings of OnTopReplica, returning it to the original state right after installation (all saved information, like stored regions, will be lost). + + + Reset settings + + + &Cancel + & marks the ALT+[] shortcut + + + Draw regions using mouse. + + + Details + + + Details on Windows Aero + + + Windows Aero is only available on Windows Vista Home Premium or higher. + + + 'Desktop Composition' is not enabled. + + + You must enable desktop composition, by selecting 'Windows Aero' as the theme used by Windows. + +To do so, right-click on the desktop and click on Personalize. + + + Error details + + + Error: + + + It appears that the selected window has been closed or is not valid anymore. + + + Error + + + Desktop Composition' is not supported on your Operating System. +You must run this application on Windows Vista Home Premium or better. + + + Desktop Composition unsupported + + + No thumbnail loaded. + + + Unable to create thumbnail + + + Unable to fit window. + + + Unable to check for updates. + + + It appears that OnTopReplica wasn't installed using 'ClickOnce'. You'll have to update manually (visit <a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>). + + + OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. + + + Mode + + + Always on top + + + Forces OnTopReplica to stay always on top. + + + Click through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Standard + + + Behaves like an ordinary window. You can bring other windows above OnTopReplica. + + + OnTopReplica fullscreen + + + Disable + + + Enable Group mode + + + Select multiple windows to enable. + + + Group switch mode is enabled. + + + Group switch mode: + + + Windows + Column Header of list, simply refers to available windows to be cloned + + + Homepage: www.codeplex.com/ontopreplica. + + + Do you want to enable "click forwarding"? + + + If this mode is enabled, OnTopReplica will forward all left mouse clicks to the window that is being cloned (this will allow you to do basic mouse operations on the cloned window without having to activate it). + +To exit this mode, push ESC. + + + Click forwarding + + + Enable Click-Through mode? + + + Click-through only works if it has been enabled in the Resize submenu and if the window is semi-transparent. + + + In this mode the fullscreen window will behave as a partially transparent overlay, allowing you to click on the other windows behind it. + +To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). + + + No, thank you. +You can enable click-through later + + + Use Click-Through + + + Click-Through mode + + + OnTopReplica has been updated. + + + In order to use the updated version of OnTopReplica you'll have to restart the application. + + + Update successful + + + OnTopReplica is up to date. + + + No update available + + + Language + + + About... + + + Hides the main window and displays the "about" box. + + + Advanced + + + Show window border + + + Toggles the display of the window border. + + + Enable Click forwarding + + + Enable "click forwarding" to the cloned window. + + + Enable Click-Through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Close + + + Closes OnTopReplica. + + + 2:1 Double + + + Fullscreen + + + 1:2 Half + + + 1:1 Fit to window + + + 1:4 Quarter + + + Group Switch mode + + + OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. + + + 100% (opaque) + + + Sets OnTopReplica to be completely opaque. + + + 25% + + + Sets OnTopReplica to 25% opacity. + + + 50% + + + Sets OnTopReplica to 50% opacity. + + + 75% + + + Sets OnTopReplica to 75% opacity. + + + Opacity + + + Open + + + Displays OnTopReplica. + + + Bottom Left + + + Bottom Right + + + Center + + + Disabled + + + Position lock + + + Automatically position OnTopReplica on the current screen. + + + Top Left + + + Top Right + + + Quit fullscreen mode + + + Recall last position and size + + + Toggles whether OnTopReplica should store its last position and size and use them when it is restarted. + + + Minimize + + + Minimizes OnTopReplica to the task bar (or the tray). + + + Select region... + + + Switches to "region mode", that allows you to select a limited region of the source's window as thumbnail. + + + Reset window + + + Resets OnTopReplica settings and its main window. + + + Resize + + + Restore last cloned window + + + When enabled, OnTopReplica will attempt to restore the last cloned window on start up. + + + Settings... + + + Displays the settings panel. + + + Switch to window + + + Switches to the source window and hides OnTopReplica. + + + Select window + + + - none - + + + Displays a list of window you can select as thumbnail source. + + + - whole - + + + Current region: + + + Delete + + + Done + + + Height + + + Reset + + + Save + + + Stored regions + + + Regions: + + + Width + + + Right-click here to start... + + + Clone current window + + + These system-wide shortcuts can also be used when OnTopReplica is not in focus. + + + Show/Hide + + + Hot keys: + + + Language: + + + Requires a restart. + + + Settings + + + Cancel update +OnTopReplica will prompt you the next time it is started. + + + Download +Install OnTopReplica {0}. + + + The new version can be downloaded and installed from the official website. + + + Installed version: {0} +Available version: {1} + + + Version {0} available + + + {0}/{1} bytes downloaded. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Downloading... + + + The latest version of OnTopReplica is already installed. The program automatically checks for updates at every start. + +You can keep up to date about OnTopReplica's development, suggest improvements and new features by <a href="website">visiting the official website</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Latest stable version released on {0}. + {0} last version release date + + + OnTopReplica is up to date + + + Install +OnTopReplica will be closed and the update installed. + + + OnTopReplica version {0} is ready to be installed on your computer. + + + Update ready + + + OnTopReplica updates + + \ No newline at end of file diff --git a/OnTopReplica/Strings.pt.resx b/OnTopReplica/Strings.pt.resx new file mode 100644 index 0000000..018dc88 --- /dev/null +++ b/OnTopReplica/Strings.pt.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Created by: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Abort update process. + + + Show details about OnTopReplica. + + + Reset all OnTopReplica settings. + + + Update OnTopReplica now. + + + Care to contribute to the project? You are welcome to improve available translations, start a new one for your native language or to check out the % from CodePlex. + + + source code + + + OnTopReplica is based upon the WindowsFormsAero library and some other libraries and code sources. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Read the full credits + + + Contribute + + + Credits + + + License + + + Updates + + + The application is licensed under the % license, which meets the terms of the "open-source" definition specified by OSI. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + A lightweight, real-time, always on top thumbnail of a window of your choice. + + + About OnTopReplica + + + Translators: {0} + {0} translators (do not end with period) + + + + Must not be localized. Leave blank in non-default languages. + + + Check now! + + + OnTopReplica automatically checks for updates at every start up. + + + Version {0} + + + + Probably doesn't need localization. :) + + + Reset window completely? + + + &Reset +All settings will be lost. + + + Can be used to reset all settings if you lost control over the window or moved it beyond the screen boundary. + + + Reset + + + Reset settings? + + + This will erase all settings of OnTopReplica, returning it to the original state right after installation (all saved information, like stored regions, will be lost). + + + Reset settings + + + &Cancel + & marks the ALT+[] shortcut + + + Draw regions using mouse. + + + Details + + + Details on Windows Aero + + + Windows Aero is only available on Windows Vista Home Premium or higher. + + + 'Desktop Composition' is not enabled. + + + You must enable desktop composition, by selecting 'Windows Aero' as the theme used by Windows. + +To do so, right-click on the desktop and click on Personalize. + + + Error details + + + Error: + + + It appears that the selected window has been closed or is not valid anymore. + + + Error + + + Desktop Composition' is not supported on your Operating System. +You must run this application on Windows Vista Home Premium or better. + + + Desktop Composition unsupported + + + No thumbnail loaded. + + + Unable to create thumbnail + + + Unable to fit window. + + + Unable to check for updates. + + + It appears that OnTopReplica wasn't installed using 'ClickOnce'. You'll have to update manually (visit <a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>). + + + OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. + + + Mode + + + Always on top + + + Forces OnTopReplica to stay always on top. + + + Click through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Standard + + + Behaves like an ordinary window. You can bring other windows above OnTopReplica. + + + OnTopReplica fullscreen + + + Disable + + + Enable Group mode + + + Select multiple windows to enable. + + + Group switch mode is enabled. + + + Group switch mode: + + + Windows + Column Header of list, simply refers to available windows to be cloned + + + Homepage: www.codeplex.com/ontopreplica. + + + Do you want to enable "click forwarding"? + + + If this mode is enabled, OnTopReplica will forward all left mouse clicks to the window that is being cloned (this will allow you to do basic mouse operations on the cloned window without having to activate it). + +To exit this mode, push ESC. + + + Click forwarding + + + Enable Click-Through mode? + + + Click-through only works if it has been enabled in the Resize submenu and if the window is semi-transparent. + + + In this mode the fullscreen window will behave as a partially transparent overlay, allowing you to click on the other windows behind it. + +To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). + + + No, thank you. +You can enable click-through later + + + Use Click-Through + + + Click-Through mode + + + OnTopReplica has been updated. + + + In order to use the updated version of OnTopReplica you'll have to restart the application. + + + Update successful + + + OnTopReplica is up to date. + + + No update available + + + Language + + + About... + + + Hides the main window and displays the "about" box. + + + Advanced + + + Show window border + + + Toggles the display of the window border. + + + Enable Click forwarding + + + Enable "click forwarding" to the cloned window. + + + Enable Click-Through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Close + + + Closes OnTopReplica. + + + 2:1 Double + + + Fullscreen + + + 1:2 Half + + + 1:1 Fit to window + + + 1:4 Quarter + + + Group Switch mode + + + OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. + + + 100% (opaque) + + + Sets OnTopReplica to be completely opaque. + + + 25% + + + Sets OnTopReplica to 25% opacity. + + + 50% + + + Sets OnTopReplica to 50% opacity. + + + 75% + + + Sets OnTopReplica to 75% opacity. + + + Opacity + + + Open + + + Displays OnTopReplica. + + + Bottom Left + + + Bottom Right + + + Center + + + Disabled + + + Position lock + + + Automatically position OnTopReplica on the current screen. + + + Top Left + + + Top Right + + + Quit fullscreen mode + + + Recall last position and size + + + Toggles whether OnTopReplica should store its last position and size and use them when it is restarted. + + + Minimize + + + Minimizes OnTopReplica to the task bar (or the tray). + + + Select region... + + + Switches to "region mode", that allows you to select a limited region of the source's window as thumbnail. + + + Reset window + + + Resets OnTopReplica settings and its main window. + + + Resize + + + Restore last cloned window + + + When enabled, OnTopReplica will attempt to restore the last cloned window on start up. + + + Settings... + + + Displays the settings panel. + + + Switch to window + + + Switches to the source window and hides OnTopReplica. + + + Select window + + + - none - + + + Displays a list of window you can select as thumbnail source. + + + - whole - + + + Current region: + + + Delete + + + Done + + + Height + + + Reset + + + Save + + + Stored regions + + + Regions: + + + Width + + + Right-click here to start... + + + Clone current window + + + These system-wide shortcuts can also be used when OnTopReplica is not in focus. + + + Show/Hide + + + Hot keys: + + + Language: + + + Requires a restart. + + + Settings + + + Cancel update +OnTopReplica will prompt you the next time it is started. + + + Download +Install OnTopReplica {0}. + + + The new version can be downloaded and installed from the official website. + + + Installed version: {0} +Available version: {1} + + + Version {0} available + + + {0}/{1} bytes downloaded. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Downloading... + + + The latest version of OnTopReplica is already installed. The program automatically checks for updates at every start. + +You can keep up to date about OnTopReplica's development, suggest improvements and new features by <a href="website">visiting the official website</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Latest stable version released on {0}. + {0} last version release date + + + OnTopReplica is up to date + + + Install +OnTopReplica will be closed and the update installed. + + + OnTopReplica version {0} is ready to be installed on your computer. + + + Update ready + + + OnTopReplica updates + + \ No newline at end of file diff --git a/OnTopReplica/Strings.resx b/OnTopReplica/Strings.resx new file mode 100644 index 0000000..d778409 --- /dev/null +++ b/OnTopReplica/Strings.resx @@ -0,0 +1,673 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Created by: %. + Link % is replaced by string AboutAuthorContent. + + + Lorenz Cuno Klopfenstein + Must not be localized. Leave blank in non-default languages. + + + Abort update process. + + + Show details about OnTopReplica. + + + Reset all OnTopReplica settings. + + + Update OnTopReplica now. + + + Care to contribute to the project? You are welcome to improve available translations, start a new one for your native language or to check out the % from CodePlex. + + + source code + + + OnTopReplica is based upon the WindowsFormsAero library and some other libraries and code sources. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Read the full credits + + + Contribute + + + Credits + + + License + + + Updates + + + The application is licensed under the % license, which meets the terms of the "open-source" definition specified by OSI. + + + Microsoft Reciprocal (MS-RL) + Can be left blank. + + + A lightweight, real-time, always on top thumbnail of a window of your choice. + + + About OnTopReplica + + + Translators: {0} + {0} translators (do not end with period) + + + Christian Olaechea M., Daniel Zeus.EX, Federico Lorenzo, Goran Brecelj, Jan Romanczyk, Marco Kraxner, Patrik (batupata), Raúl Morillo, René Mihula, Roberto Leiro, Rodrigo Lourenço, Thomas Amundsen, Eric Hoffmann. + Must not be localized. Leave blank in non-default languages. + + + Check now! + + + OnTopReplica automatically checks for updates at every start up. + + + Version {0} + + + OnTopReplica + Probably doesn't need localization. :) + + + Reset window completely? + + + &Reset +All settings will be lost. + + + Can be used to reset all settings if you lost control over the window or moved it beyond the screen boundary. + + + Reset + + + Reset settings? + + + This will erase all settings of OnTopReplica, returning it to the original state right after installation (all saved information, like stored regions, will be lost). + + + Reset settings + + + &Cancel + & marks the ALT+[] shortcut + + + Draw regions using mouse. + + + Details + + + Details on Windows Aero + + + Windows Aero is only available on Windows Vista Home Premium or higher. + + + 'Desktop Composition' is not enabled. + + + You must enable desktop composition, by selecting 'Windows Aero' as the theme used by Windows. + +To do so, right-click on the desktop and click on Personalize. + + + Error details + + + Error: + + + It appears that the selected window has been closed or is not valid anymore. + + + Error + + + Desktop Composition' is not supported on your Operating System. +You must run this application on Windows Vista Home Premium or better. + + + Desktop Composition unsupported + + + No thumbnail loaded. + + + Unable to create thumbnail + + + Unable to fit window. + + + Unable to check for updates. + + + It appears that OnTopReplica wasn't installed using 'ClickOnce'. You'll have to update manually (visit <a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>). + + + OnTopReplica was unable to check whether an updated version is available. Make sure you are connected to the Internet. If you are, the website may be temporarily down. + + + Mode + + + Always on top + + + Forces OnTopReplica to stay always on top. + + + Click through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Standard + + + Behaves like an ordinary window. You can bring other windows above OnTopReplica. + + + OnTopReplica fullscreen + + + Disable + + + Enable Group mode + + + Select multiple windows to enable. + + + Group switch mode is enabled. + + + Group switch mode: + + + Windows + Column Header of list, simply refers to available windows to be cloned + + + Homepage: www.codeplex.com/ontopreplica. + + + Do you want to enable "click forwarding"? + + + If this mode is enabled, OnTopReplica will forward all left mouse clicks to the window that is being cloned (this will allow you to do basic mouse operations on the cloned window without having to activate it). + +To exit this mode, push ESC. + + + Click forwarding + + + Enable Click-Through mode? + + + Click-through only works if it has been enabled in the Resize submenu and if the window is semi-transparent. + + + In this mode the fullscreen window will behave as a partially transparent overlay, allowing you to click on the other windows behind it. + +To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). + + + No, thank you. +You can enable click-through later + + + Use Click-Through + + + Click-Through mode + + + OnTopReplica has been updated. + + + In order to use the updated version of OnTopReplica you'll have to restart the application. + + + Update successful + + + OnTopReplica is up to date. + + + No update available + + + Language + + + About... + + + Hides the main window and displays the "about" box. + + + Advanced + + + Show window border + + + Toggles the display of the window border. + + + Enable Click forwarding + + + Enable "click forwarding" to the cloned window. + + + Enable Click-Through + + + OnTopReplica will behave like a transparent overlay that lets your clicks through to the windows below. + + + Close + + + Closes OnTopReplica. + + + 2:1 Double + + + Fullscreen + + + 1:2 Half + + + 1:1 Fit to window + + + 1:4 Quarter + + + Group Switch mode + + + OnTopReplica will automatically clone a window from an user defined group, switching to the one least recently activated to the foreground. + + + 100% (opaque) + + + Sets OnTopReplica to be completely opaque. + + + 25% + + + Sets OnTopReplica to 25% opacity. + + + 50% + + + Sets OnTopReplica to 50% opacity. + + + 75% + + + Sets OnTopReplica to 75% opacity. + + + Opacity + + + Open + + + Displays OnTopReplica. + + + Bottom Left + + + Bottom Right + + + Center + + + Disabled + + + Position lock + + + Automatically position OnTopReplica on the current screen. + + + Top Left + + + Top Right + + + Quit fullscreen mode + + + Recall last position and size + + + Toggles whether OnTopReplica should store its last position and size and use them when it is restarted. + + + Minimize + + + Minimizes OnTopReplica to the task bar (or the tray). + + + Select region... + + + Switches to "region mode", that allows you to select a limited region of the source's window as thumbnail. + + + Reset window + + + Resets OnTopReplica settings and its main window. + + + Resize + + + Restore last cloned window + + + When enabled, OnTopReplica will attempt to restore the last cloned window on start up. + + + Settings... + + + Displays the settings panel. + + + Switch to window + + + Switches to the source window and hides OnTopReplica. + + + Select window + + + - none - + + + Displays a list of window you can select as thumbnail source. + + + - whole - + + + Current region: + + + Delete + + + Done + + + Height + + + Reset + + + Save + + + Stored regions + + + Regions: + + + Width + + + Right-click here to start... + + + Clone current window + + + These system-wide shortcuts can also be used when OnTopReplica is not in focus. + + + Show/Hide + + + Hot keys: + + + Language: + + + Requires a restart. + + + Settings + + + Cancel update +OnTopReplica will prompt you the next time it is started. + + + Download +Install OnTopReplica {0}. + + + The new version can be downloaded and installed from the official website. + + + Installed version: {0} +Available version: {1} + + + Version {0} available + + + {0}/{1} bytes downloaded. + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + Downloading... + + + The latest version of OnTopReplica is already installed. The program automatically checks for updates at every start. + +You can keep up to date about OnTopReplica's development, suggest improvements and new features by <a href="website">visiting the official website</a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Latest stable version released on {0}. + {0} last version release date + + + OnTopReplica is up to date + + + Install +OnTopReplica will be closed and the update installed. + + + OnTopReplica version {0} is ready to be installed on your computer. + + + Update ready + + + OnTopReplica updates + + + Bottom + + + Left + + + Right + + + Top + + + X + + + Y + + \ No newline at end of file diff --git a/OnTopReplica/Strings.ru.resx b/OnTopReplica/Strings.ru.resx new file mode 100644 index 0000000..bb3d36d --- /dev/null +++ b/OnTopReplica/Strings.ru.resx @@ -0,0 +1,647 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Автор: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Остановить обновление + + + О программе + + + Установить настройки по умолчанию + + + Обновить программу + + + Хотите поддержать проект? Примите участие в улучшении готовых переводов, создайте свой на вашем родном языке или помогите улучшить % на «CodePlex». + + + источниках кода + + + Программа основана на библиотеке «WindowsFormsAero» и некоторых других библиотеках и источниках кода. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Прочитайте полные сведения об источниках + + + Принять участие в разработке + + + Сведения об источниках + + + Соглашение + + + Обновление + + + Программа выпущена в соответствии с лицензией %, которая подходит под определение программы с открытым исходом кодом в представлении OSI. + + + + Can be left blank. + + + Просмотр части выбранного вами окна — просто и легко, в реальном времени, всегда поверх остальных окон. + + + О программе + + + Переводчики: {0} + {0} translators (do not end with period) + + + + Must not be localized. Leave blank in non-default languages. + + + Обновить сейчас + + + Программа автоматически проверяет наличие обновлений при запуске + + + Версия {0} + + + + Probably doesn't need localization. :) + + + Сбросить окно? + + + &Сброс +Все настройки будут удалены. + + + Можно использовать для сброса всех настроек, если Вы утратили контроль над окном либо поместили его за пределы экрана. + + + Сброс + + + Сбросить настройки? + + + по умолчанию (вся сохраненная после установки информация вроде сохраненных областей будет утрачена). + + + Сбросить настройки + + + &Отмена + & marks the ALT+[] shortcut + + + Выберите области мышью + + + Подробности + + + Подробности о «Windows Aero» + + + Функция «Windows Aero» доступна только на системах «Windows», начиная с «Vista Home Premium», кроме версий «Starter» и «Home Basic» (по умолчанию). + + + Композиция слоев рабочего стола недоступна. + + + Для включения правой кнопкой мыши по рабочему столу и выберите «Персонализацию». + + + Описание ошибки + + + Ошибка: + + + Вероятно, выбранное окно было закрыто или больше не отвечает. + + + Ошибка + + + Для запуска программы требуется «Windows Vista Home Premium» или другие версии «Windows» с поддержкой «Aero». + + + Композиция слоев рабочего стола не поддерживается. + + + Окно просмотра не загружено. + + + Невозможно создать окно просмотра. + + + Невозможно уместить в окне. + + + Невозможно проверить обновления. + + + Вероятно, программа была установлена с использованием функции «ClickOnce». Вам необходимо обновить ее самостоятельно. (Посетите <a href="http://ontopreplica.codeplex.com"> домашнюю страницу программы</a>). + + + Программе не удалось проверить доступность новой версии. Удостоверьтесь, что подключение к Интернету присутствует. Если присутствует, сайт может временно не работать. + + + Режим + + + Всегда поверх других окон + + + Всегда удерживать программу поверх других окон. + + + Пропускать щелчки мышью + + + Программа будет работать, как прозрачный слой, позволяющий щелкать мышью по нижележащим окнам. + + + Обычный + + + Программа будет работать, как обычное окно. Вы сможете помещать другие окна поверх окна программы. + + + Полноэкранный режим + + + Отключить + + + Включить групповой режим + + + Для включения выберите несколько окон. + + + Групповой режим включен. + + + Групповой режим: + + + Окна + Column Header of list, simply refers to available windows to be cloned + + + Домашняя страница: www.codeplex.com/ontopreplica. + + + Хотите включить передачу щелчков мышью главному окну? + + + Нажать Esc для выхода из этого режима. + There appears to be a missing part. + + + Передача щелчков мышью главному окну. + This appears to be wrong. + + + Включить режим сквозных щелчков мышью? + + + Режим сквозных щелчков мышью работает, только когда он включен в подменю «Изменить размер» и окно полупрозрачно. + + + Для возвращения в обычный режим в любое время, разверните программу щелчком по ней в панели задач (или лотке). + + + Нет, спасибо +Вы можете включить сквозные щелчки мышью в другой раз. + + + Использовать сквозные щелчки мышью + + + Режим сквозных щелчков мышью + + + Программа обновлена. + + + Для использования обновленной версии программы ее необходимо перезапустить. + + + Обновление успешно + + + Используется последняя версия программы. + + + Обновлений нет + + + Язык + + + О программе... + + + Сворачивает главное окно и показывает окно «О программе». + + + Дополнительно + + + Показывать границу окна + + + Изменяет видимость границы окна. + + + Включить передачу щелчков мышью главному окну + + + Включить передачу щелчков мышью скопированному окну. + + + Включить сквозные щелчки мышью + + + Программа будет работать, как прозрачный слой, позволяющий щелкать мышью по нижележащим окнам. + + + Закрыть + + + Закрыть программу. + + + 2:1 Двойной + + + Полноэкранный режим + + + 1:2 Половина + + + 1:1 По размерам окна + + + 1:4 Четверть + + + Групповой режим + + + Программа автоматически скопирует окно из группы, определенной пользователем, переключаясь на то, которое побывало на переднем плане первым из всех. + Fixed + + + 100% (непрозрачный) + + + Делает программу полностью непрозрачной. + + + 25% + + + Делает программу прозрачной на 25%. + + + 50% + + + Делает программу прозрачной на 50%. + + + 75% + + + Делает программу прозрачной на 75%. + + + Прозрачность + + + Открыть + + + Показывает программу. + + + Снизу слева + + + Снизу справа + + + В центре + + + Отключено + + + Закрепить положение + + + Автоматически разместить программу на текущем экране. + + + Сверху слева + + + Сверху справа + + + Выйти из полноэкранного режима + + + Использовать последнее положение и размер + + + Сохранение программой своего последнего положения и размера с их использованием при запуске. + + + Свернуть + + + Сворачивает программу в панель задач (или лоток). + + + Выбрать область... + + + Переключается в «режим области», позволяющий выбирать для показа ограниченную область исходного окна. + + + Сбросить окно + + + Сбрасывает настройки программы и ее главное окно. + + + Изменить размер + + + Восстанавливать последнее копированное окно + + + Если включено, программа попытается при запуске восстановить окно, скопированное последним. + + + Настройки... + + + Показывает панель настроек. + + + Переключиться на окно + + + Переключается на исходное окно и скрывает программу. + + + Выбрать окно + + + - пусто - + + + Показывает список окон, которые можно выбрать в качестве источников для копирования. + + + - полностью - + + + Выбранная область: + + + Удалить + + + Готово + + + Высота + + + Сбросить + + + Сохранить + + + Сохраненные области + + + Области: + + + Ширина + + + Для начала щелкните тут правой кнопкой мыши... + + + Скопировать текущее окно + + + Эти глобальные сочетания клавиш можно использовать также когда программа на заднем плане. + + + Показать/Скрыть + + + Сочетания клавиш: + + + Язык: + + + Требуется перезапуск. + + + Настройки + + + Отменить обновление +Программа уведомит Вас об обновлении при следующем запуске. + + + Скачать +Установить программу «OnTopReplica» {0}. + + + Новую версию можно скачать и установить с официального сайта. + + + Установленная версия: {0}. +Доступная версия: {0}. + + + Доступна версия {0} + + + Скачано {0} из {1} + {0} downloaded bytes {1} total bytes + + + Загрузка... + + + Установлена последняя версия программы «OnTopReplica». Программа автоматически проверяет обновления при каждом запуске. + +Вы можете следить за обновлениями программы, предлагать улучшения и новые функции на <a href="website">сайте программы </a>. + The website link should be enclosed in <a href="website"></a> tags. + + + Последняя стабильная версия выпущена {0}. + {0} last version release date + + + Вы пользуетесь последней версией программы + + + Установить +Программа будет закрыта для установки обновления. + + + «OnTopReplica» (версия {0}) готова к установке на вашем компьютере. + + + Обновление готово + + + Программа обновляется + + \ No newline at end of file diff --git a/OnTopReplica/Strings.tr.resx b/OnTopReplica/Strings.tr.resx new file mode 100644 index 0000000..aad4cfb --- /dev/null +++ b/OnTopReplica/Strings.tr.resx @@ -0,0 +1,652 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Yazar Hakkında: %. + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + Güncellemeyi iptal et. + + + OnTopRelica hakkında ayrıntıları görüntüle. + + + Bütün OnTopRelica ayarlarını sıfırla. + + + OnTopRelica'yı güncelle. + + + Programa katkıda bulunmak ister misiniz? Mevcut çevirileri geliştirmenizi memnuniyetle karşılarız, programı kendi dilinize çevirin veya %'e CodePlex'ten bir göz atın. + + + kaynak kod + + + OnTopReplica'nın temelinde WindowsFormsAero kütüphanesi ve bazı diğer kütüphaneler ile kaynak kodları vardır. %. + Link % is replaced by string AboutCreditsSourcesContent. + + + Tüm Yapımcıları Gör + + + Katkı + + + Yapımcılar + + + Lisans + + + Güncellemeler + + + Bu uygulama OSI tarafından belirtilmiş "açık-kaynak" tanımının koşullarını yerine getiren % lisansı tarafından lisanslanmıştır. + + + + Can be left blank. + + + Seçtiğiniz pencerenin hafif, gerçek zamanlı ve her zaman en üstteki küçük resmi. + + + OnTopReplica hakkında + + + Çevirmenler: {0} + {0} translators (do not end with period) + + + + Must not be localized. Leave blank in non-default languages. + + + Kontrol Et! + + + OnTopReplica her başlangıçta güncellemeleri otomatik olarak kontrol eder. + + + Versiyon {0} + + + OnTopReplica + Probably doesn't need localization. :) + + + Pencereyi tamamen yeniden ayarla? + + + &Reset +Bütün ayarlar kaybolacak. + + + Eğer pencere üzerindeki denetimizi kaybettiyseniz veya pencere ekran sınırları dışına çıktı ise kullanılabilir. + + + Sıfırla + + + Ayarları sıfırla? + + + Bu OnTopReplica'nın bütün ayarlarını silip, yüklemeden hemen sonraki haline geri döndürecektir (bütün kaydedilen bilgi, saklı bölgeler kaybolacaktır). + + + Ayarları sıfırla + + + &Vazgeç + & marks the ALT+[] shortcut + + + Farenizi kullarak bölgeler çizin. + + + Ayrıntılar + + + Windows Aero'da ki ayrıntılar + + + Windows Aero sadece Windows Vista Home Premium veya daha yüksek sürümlerde bulunmaktadır. + + + Masaüstü bileşimi aktif değil. + + + Windows tarafından kullanılan 'Windows Aero'yu tema olarak seçerek masaüstü bileşimini aktif etmelisiniz. + +Bunu yapmak için, masaüstüne sağ tıklayın ve Kişiselleştir'e tıklayın. + + + Hata detayları + + + Hata: + + + Seçtiğiniz pencere kapatılmış veya artık geçerli değil gibi görünüyor. + + + Hata + + + Masaüstü bileşimi İşletim Sisteminiz tarafından desteklenmiyor. +Bu programı Windows Vista Home Premium veya daha iyisinde çalıştırmalısınız. + + + Masaüstü Bileşimi Desteklenmiyor + + + Hiçbir küçükresim yüklenmedi. + + + Küçükresim yaratılamıyor + + + Pencereye oturtulamıyor. + + + Güncellemeler kontrol edilemiyor. + + + OnTopReplica 'ClickOnce' kullanılara yüklenmemiş gözüküyor. Elle güncellemeniz gerek (<a href="http://ontopreplica.codeplex.com">OnTopReplica's homepage</a>'i ziyaret edin). + + + OnTopReplica güncellenmiş bir versiyonun mevcut olup olmadığını denetleyemiyor. İnternete bağlı olduğunuzdan emin olun. Eğer bağlı iseniz websitesi geçici olarak servis dışı olabilir. + + + Mod + + + Her zaman üstte + + + OnTopReplica'nın her zaman en üstte kalması için zorlar. + + + Tıkla + + + OnTopReplica arkadaki pencerelere direkt tıklamanıza izin veren transparan bir kaplama gibi davranır. + + + Standart + + + Normal bir pencere gibi davranır. Diğer pencereleri OnTopReplica'nın üstüne getirebilirsiniz. + + + OnTopReplica tam ekran + + + Etkisizleştir + + + Grup modu etkinleştir + + + Etkinleştirilecek çoklu pencereleri seçiniz. + + + Grup değiştirme modu etkin. + + + Grup değiştirme modu: + + + Pencereler + Column Header of list, simply refers to available windows to be cloned + + + Anasayfa: www.codeplex.com/ontopreplica. + + + "tıkla yönlendir"'i etkinleştirmek ister misiniz? + Should be capitalized? + + + Eğer bu mod etkinleştirilmiş ise, OnTopReplica bütün sol fare tıklamalarını klonlanmış pencereye iletecektir(bu size klonlanmış pencere üzerinde onu aktifleştirmeden temel fare işlemlerinizi yapabilmenize izin verir). + +Bu moddan çıkmak için, ESC'ye basınız. + + + Tıkla yönlendir + + + Direkt-Tıkla modunu etkinleştir? + + + Direk-tıkla sadece Yeniden boyutlandır altmenüsünde etkinleştirildiyse ve pencere yarı-transparan ise çalışır. + + + Bu modda tamekran pencere kısmen transparan kaplama gibi davranır, arkasındaki pencerelere tıklamanıza izin verir. + +Herhangi bir zamanda normal moda dönmek için, OnTopReplica görev çubuğuna (veya sistem simgesine) tıklayarak aktifleştirin. + + + Hayır, teşekkür ederim +direkt-tıklayı daha sonra etkinleştirebilirsiniz. + Second sentence capitalized? + + + Direkt-Tıkla kullan + + + Direkt-Tıkla modu + + + OnTopReplica güncellendi. + + + OnTopReplica'nın güncellenmiş versiyonunu kullanmak için uygulamayı yeniden başlatmalısınız. + + + Güncelleme başarılı + + + OnTopReplica güncel. + + + Güncelleme mevcut değil + + + Dil + + + Hakkında... + + + Ana pencereyi gizler ve "hakkında" kutusunu gösterir. + + + Gelişmiş + + + Pencere kenarlığı göster + + + Pencere kenarlığı gösterimini değiştirir. + + + Tıkla yönlendir'i etkinleştir + + + Klonlanmış pencerede "tıkla yönlendir"'i etkinleştir. + + + Direkt-Tıkla'yı etkinleştir + + + OnTopReplica arkadaki pencerelere direkt tıklamanıza izin veren transparan bir kaplama gibi davranır. + + + Kapat + + + OnTopReplica'yı kapatır. + + + 2:1 Çift + + + Tamekran + + + 1:2 Yarım + + + 1:1 pencereye sığdır + + + 1:4 Çeyrek + + + Grup Değiştirme modu + + + OnTopReplica kullanıcı tanımlı gruptan bir pencereyi kopyalayıp, arkaplanda en son aktifleştirilen biri ile değiştirecektir. + + + 100% (opak) + + + OnTopReplica'yı tamamen opak olarak ayarlar. + + + 25% + + + OnTopReplica'yı 25% opaklığına ayarlar. + + + 50% + + + OnTopReplica'yı 50% opaklığına ayarlar. + + + 75% + + + OnTopReplica'yı 75% opaklığına ayarlar. + + + Opaklık + + + Aç + + + OnTopReplica'yı görüntüler. + + + Sol Alt + + + Sağ Alt + + + Merkez + + + Devredışı + + + Konum kilidi + + + OnTopReplica'yı otomatik olarak şu anki ekrana konumlandırır. + + + Sol Üst + + + Sağ Üst + + + Tamekran modundan çık + + + Son pozisyona dön ve boyutlandır + + + OnTopReplica'nın son konumunu kaydedip kaydetmeyeceğini değiştirir ve boyutlandırıp bunu yeniden başladığında kullanır. + + + Küçült + + + OnTopReplica'yı görev çubuğuna (veya sistem kısayollarına) küçültür. + + + Bölge seçiniz... + + + "bölge modu"na geçer, bu size kaynak penceresinin küçük resminin kısıtlı bir bölgesini seçmenize izin verir. + + + Pencereyi sıfırla + + + OnTopReplica'nın ayarlarını ve ana penceresini sıfırlar. + + + Yeniden boyutlandır + + + Son klonlanan pencereyi geri yükle + + + Etkinleştirildiği zaman, OnTopReplica son klonlanan pencereyi başlangıçta yeniden yüklemeye çalışır. + + + Ayarlar... + + + Ayarlar panelini görüntüler. + + + Pencereye geç + + + Kaynak pencereye geçer ve OnTopReplica'yı gizler. + + + Pencere seç + + + - yok - + + + Küçük resim kaynağı halinde seçebileceğiniz pencere listesini görüntüler. + + + - tamamen - + + + Şu anki bölge: + + + Sil + + + Tamamlandı + + + Yükseklik + + + Sıfırla + + + Kaydet + + + Kayıtlı bölgeler + + + Bölgeler: + + + Genişlik + + + Başlamak için buraya sağ tıklayın... + + + Şu anki pencereyi klonla + + + Bu sistem genelinde kısayollar ayrıca OnTopReplica üstte olmadığı zaman kullanılabilir. + + + Göster/Gizle + + + Kısayollar: + + + Dil: + + + Yeniden başlatma gerektirir. + + + Ayarlar + + + Güncellemeden vazgeç +OnTopReplica sizi yeniden başlatıldığında uyaracaktır. + + + İndir +OnTopReplica {0} Yükle. + + + Yeni versiyon resmi siteden indirilebilir ve yüklenebilir. + + + Yüklü versiyon: {0}. +Kullanılabilir versiyon: {1}. + + + Versiyon {0} mevcut + + + {0}/{1} byte indirildi. + + + İndiriliyor... + + + OnTopReplica'nın en son sürümü zaten yüklenmiş. Program her başlangıçta güncellemeleri otomatik olarak denetler. + +OnTopReplica'nın geliştirilmesi, yeni özellik ve geliştirme önerileri hakkında by <a href="website">resmi internet sitesini ziyaret ederek</a> güncel kalabilirsiniz. + The website link should be enclosed in <a href="website"></a> tags. + + + En son kararlı versiyon {0} tarihinde yayınlandı. + {0} last version release date + + + OnTopReplica güncel + + + Yükle +OnTopReplica kapatılınca güncelleme yüklenmiş olacaktır. + + + OnTopReplica versiyon {0} bilgisayarınızda yüklenmeye hazır. + + + Güncelleme hazır + + + OnTopReplica güncellemeleri + + \ No newline at end of file diff --git a/OnTopReplica/Strings.zh-Hans.resx b/OnTopReplica/Strings.zh-Hans.resx new file mode 100644 index 0000000..b68ff04 --- /dev/null +++ b/OnTopReplica/Strings.zh-Hans.resx @@ -0,0 +1,655 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 作者 % + Link % is replaced by string AboutAuthorContent. + + + + Must not be localized. Leave blank in non-default languages. + + + 终止更新过程 + + + 展开关于OnTopReplica的详细内容 + + + 重置OnTopReplica的所有设定 + + + 现在更新OnTopReplica + + + 想为本项目出一份力吗？欢迎你参与到翻译工作中来，抑或检视从CodePlex处取得的 % + + + 源代码 + + + OnTopReplica基于WindowsFormsAero库和其他库及代码。% + Link % is replaced by string AboutCreditsSourcesContent. + + + 了解全部 + + + 贡献 + + + 制作 + + + 授权 + + + 更新 + + + 应用程序根据%许可获得授权，即指遵循OSI界定的“开源”条款 + + + 微软互惠授权(MS-RL) + Can be left blank. + + + 一个轻量级、实时、窗口缩略图置顶工具 + + + 关于OnTopReplica + + + 译者：{0} + {0} translators (do not end with period) + + + + Must not be localized. Leave blank in non-default languages. + + + 检查更新！ + + + OnTopReplica自动在每次开启时检查更新 + + + 版本{0} + + + + Probably doesn't need localization. :) + + + 完全重置窗口吗？ + + + &重置 +所有设定均会丢失 + + + 可以在没辙的时候用来重置所有设定 + + + 重置 + + + 重置设定吗？ + + + 这将清除所有OnTopReplica的设定，并回到刚安装完的状态（所有保存的信息、保存的选区，均会丢失） + + + 重置设定 + + + &取消 + & marks the ALT+[] shortcut + + + 使用鼠标划出区域 + + + 详细信息 + + + Windows Aero的详细信息 + + + 为什么Windows Aero特效只在Windows Vista Home Premium或更高级版本中出现 + + + 未启用桌面组合 + + + 程序需要系统的Aero主题配合 + +桌面右击，个性化，选择主题 + + + 详细错误 + + + 错误： + + + 选中的窗口似乎已经关闭或已失效 + + + 错误 + + + 您的操作系统不支持桌面组合 +请在Windows Vista Home Premium或更高版本中运行 + + + 不支持桌面组合 + + + 无缩略图可加载 + + + 无法创建缩略图 + + + 无法适应窗口 + + + 无法检查更新 + + + OnTopReplica不是用“ClickOnce”方式安装的。您不得不手动更新了（访问 <a href="http://ontopreplica.codeplex.com">OnTopReplica的主页</a>） + + + OnTopReplica无法检测更新，请确保已连接到互联网。当然，也有可能是网站暂时关闭 + + + 模式 + + + 总是置顶 + + + 强制OnTopReplica置顶 + + + 点击穿过 + + + OnTopReplica会像一个透明的覆盖层并允许您点击其后面的窗口 + + + 标准模式 + + + 变回普通窗口，OnTopReplica会被其他窗口阻挡 + + + OnTopReplica全屏幕 + + + 取消 + + + 激活组模式 + + + 选择多个窗口以启用 + + + 自切换组模式已激活 + + + 自切换组模式： + + + 窗口 + Column Header of list, simply refers to available windows to be cloned + + + 主页：www.codeplex.com/ontopreplica + + + 您想启用“点击转发”吗？ + + + 如果启用此模式，OnTopReplica会将所有鼠标点击转发到被克隆的窗口上（这将允许您绕过窗口激活直接对被克隆的窗口做一些基本的鼠标操作） + +想退出此模式，按ESC + + + 点击转发 + + + 启用点击穿过模式吗？ + + + 点击穿过功能仅在缩放启用或窗口半透明的状态下方能工作 + + + In this mode the fullscreen window will behave as a partially transparent overlay, allowing you to click on the other windows behind it. + +To return to normal mode anytime, activate OnTopReplica by clicking on the task bar (or the tray icon). + + + 不了，谢谢 +等下再启用点击穿过 + + + 使用点击穿过 + + + 点击穿过模式 + + + OnTopReplica已更新 + + + 为能使用新版OnTopReplica，您必须重新启动本程序 + + + 更新成功 + + + OnTopReplica是最新的 + + + 没有可用的更新 + + + 语言 + + + 关于... + + + 隐藏著窗口，并显示“关于”对话框 + + + 高级 + + + 显示窗口边框 + + + 切换显示窗口边框 + + + 启用点击转发 + + + 对被克隆的窗口启用“点击转发” + + + 启用点击穿过 + + + OnTopReplica会像一个透明的覆盖层并允许您点击其后面的窗口 + + + 退出 + + + 关闭OnTopReplica + + + 200% + + + 全屏 + + + 50% + + + 100% + + + 25% + + + 自切换组模式 + + + OnTopReplica会自动定位到自切换组中最不活跃的那个程序，并克隆其窗口 + + + 100% + + + 把OnTopReplica设为完全不透明状态 + + + 25% + + + 把OnTopReplica的不透明度设为25% + + + 50% + + + 把OnTopReplica的不透明度设为50% + + + 75% + + + 把OnTopReplica的不透明度设为75% + + + 不透明度 + + + 打开 + + + 显示OnTopReplica + + + 左下 + + + 右下 + + + 中央 + + + 取消 + + + 锁定位置 + + + 自动在当前屏幕定位OnTopReplica + + + 左上 + + + 右上 + + + 退出全屏模式 + + + 记忆窗口大小和位置 + + + 选择是否记忆窗口大小和位置，并在下次运行时恢复 + + + 最小化 + + + 最小化到任务栏上 + + + 选择区域... + + + 截取部分窗口内容 + + + 重置窗口 + + + 重置OnTopReplica的设定及其主窗口 + + + 缩放 + + + 恢复上次克隆的窗口 + + + 激活此项，程序开启时将尝试恢复最后克隆的窗口 + + + 设置... + + + 显示设置面板 + + + 切换到窗口 + + + 切换到源窗口并隐藏OnTopReplica + + + 选取窗口 + + + - 无 - + + + 显示窗口列表以选择缩略图来源 + + + - 全部 - + + + 当前选区： + + + 删除 + + + 完成 + + + 高度 + + + 重来 + + + 保存 + + + 保存选区 + + + 选区： + + + 宽度 + + + 点击右键以开始... + + + 克隆当前窗口 + + + 全局快捷键，前后台运行均会响应 + + + 显示/隐藏 + + + 快捷键： + + + 语言： + + + 需要重启本程序 + + + 设置 + + + 取消更新 +OnTopReplica会在下次开启的时候提示更新 + + + 下载 +安装OnTopReplica{0} + + + 可以从官网上下载和安装程序的最新版 + + + 安装的版本：{0} +可用的版本：{1} + + + 版本{0}可用 + + + 下载了{0}/{1}字节 + {0} downloaded bytes {1} total bytes +{0} bytes geladen von {1} bytes gesamt +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes +{0} downloaded bytes {1} total bytes + + + 下载中... + + + 已安装最新版的OnTopReplica，程序每次开启都会自动检查更新。 + +你可以<a href="website">访问官网</a>来了解OnTopReplica的最新进展并提出自己的建议 + The website link should be enclosed in <a href="website"></a> tags. + + + 最新稳定版于{0}释出 + {0} last version release date + + + OnTopReplica是最新的 + + + 安装 +OnTopReplica将被关闭以安装更新 + + + 版本{0}的OnTopReplica已经准备在你电脑上安装 + + + 准备更新 + + + OnTopReplica更新 + + \ No newline at end of file diff --git a/OnTopReplica/ThumbnailPanel.cs b/OnTopReplica/ThumbnailPanel.cs new file mode 100644 index 0000000..bd0b81d --- /dev/null +++ b/OnTopReplica/ThumbnailPanel.cs @@ -0,0 +1,484 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using WindowsFormsAero.Dwm; +using WindowsFormsAero.ThemeText; +using System.Drawing; +using System.Windows.Forms.VisualStyles; +using OnTopReplica.Native; + +namespace OnTopReplica { + + class ThumbnailPanel : Panel { + + //DWM Thumbnail stuff + Thumbnail _thumbnail = null; + + //Labels + ThemedLabel _labelGlass; + + public ThumbnailPanel() { + InitFormComponents(); + } + + private void InitFormComponents() { + BackColor = Color.Black; + + //Themed Label + _labelGlass = new ThemedLabel { + Dock = DockStyle.Fill, + ForeColor = SystemColors.ControlText, + Location = Point.Empty, + Size = ClientSize, + Name = "labelGlass", + Text = Strings.RightClick, + TextAlign = HorizontalAlignment.Center, + TextAlignVertical = VerticalAlignment.Center + }; + this.Controls.Add(_labelGlass); + } + + #region Properties and settings + + ThumbnailRegion _currentRegion; + + /// + /// Gets or sets the region that is currently shown on the thumbnail. When set, also enables region constrain. + /// + public ThumbnailRegion SelectedRegion { + get { + return _currentRegion; + } + set { + _currentRegion = value; + _regionEnabled = (value != null); + UpdateThubmnail(); + } + } + + bool _regionEnabled = false; + + /// + /// Gets or sets whether the thumbnail is constrained to a region or not. + /// + public bool ConstrainToRegion { + get { + return _regionEnabled; + } + set { + if (_regionEnabled != value) { + _regionEnabled = value; + UpdateThubmnail(); + } + } + } + + bool _drawMouseRegions = false; + + /// + /// Gets or sets whether the control is is "region drawing" mode and reports them via events. + /// + public bool DrawMouseRegions { + get { + return _drawMouseRegions; + } + set { + //Set mode and reset region + _drawMouseRegions = value; + _drawingRegion = false; + + //Cursor change + Cursor = (value) ? Cursors.Cross : Cursors.Default; + + //Refresh gui + UpdateThubmnail(); + _labelGlass.Visible = !value; + this.Invalidate(); + } + } + + /// + /// Gets the target opacity of the thumbnail, depending on the control's state. + /// + protected byte ThumbnailOpacity { + get { + return (_drawMouseRegions) ? (byte)130 : (byte)255; + } + } + + /// + /// Gets or sets whether the control should report clicks made on the cloned thumbnail. + /// + public bool ReportThumbnailClicks { + get; + set; + } + + /// + /// Gets the thumbnail's size (in effectively thumbnailed pixels). + /// + /// + /// This size varies if the thumbnail has been cropped to a region. + /// + public Size ThumbnailPixelSize { + get { + if (_thumbnail != null && !_thumbnail.IsInvalid) { + if (_regionEnabled) { + return _currentRegion.ComputeRegionSize(_thumbnail.SourceSize); + } + else { + //Thumbnail is not cropped, return full thumbnail source size + return _thumbnail.SourceSize; + } + } + else { +#if DEBUG + throw new InvalidOperationException(Strings.ErrorNoThumbnail); +#else + return Size.Empty; +#endif + } + } + } + + /// + /// Gets the thumbnailed window's original size. + /// + /// + /// This size is not influenced by the region cropping applied to the thumbnail. + /// + public Size ThumbnailOriginalSize { + get { + if (_thumbnail != null && !_thumbnail.IsInvalid) { + return _thumbnail.SourceSize; + } + else { +#if DEBUG + throw new InvalidOperationException(Strings.ErrorNoThumbnail); +#else + return Size.Empty; +#endif + } + } + } + + #endregion + + #region GUI event handling + + protected override void OnResize(EventArgs eventargs) { + base.OnResize(eventargs); + UpdateThubmnail(); + } + + protected override void WndProc(ref Message m) { + base.WndProc(ref m); + + //Check whether this is a hit-test on "client" surface + if (m.Msg == WM.NCHITTEST && m.Result.ToInt32() == HT.CLIENT) { + //Check whether clicks must be reported + if(!DrawMouseRegions && !ReportThumbnailClicks /*&& !InputMethods.IsKeyPressed(VirtualKeyState.VK_SHIFT)*/){ + m.Result = new IntPtr(HT.TRANSPARENT); + } + } + } + + #endregion + + #region Thumbnail interface + + /// + /// Creates a new thumbnail of a certain window. + /// + /// Handle of the window to clone. + /// Optional region. + public void SetThumbnailHandle(WindowHandle handle, ThumbnailRegion region) { + System.Diagnostics.Trace.WriteLine(string.Format("Setting thumbnail to handle {0}, with region {1}.", handle, region), "ThumbnailPanel"); + + if (_thumbnail != null && !_thumbnail.IsInvalid) { + _thumbnail.Close(); + _thumbnail = null; + } + + //Get form and register thumbnail on it + Form owner = this.TopLevelControl as Form; + if(owner == null) + throw new Exception("Internal error: ThumbnailPanel.TopLevelControl is not a Form."); + + _labelGlass.Visible = false; + + //Register new thumbnail, disable regioning directly and refresh + _thumbnail = DwmManager.Register(owner, handle.Handle); + _currentRegion = region; + _regionEnabled = (region != null); + UpdateThubmnail(); + } + + /// + /// Disposes current thumbnail and enters stand-by mode. + /// + public void UnsetThumbnail() { + System.Diagnostics.Trace.WriteLine("Unsetting thumbnail."); + + if (_thumbnail != null && !_thumbnail.IsInvalid) { + _thumbnail.Close(); + } + + _thumbnail = null; + _labelGlass.Visible = true; + } + + /// + /// Gets whether the control is currently displaying a thumbnail. + /// + public bool IsShowingThumbnail { + get { + return (_thumbnail != null && !_thumbnail.IsInvalid); + } + } + + int _padWidth = 0; + int _padHeight = 0; + Size _thumbnailSize; + + /// + /// Updates the thumbnail options and the right-click label. + /// + private void UpdateThubmnail() { + if (_thumbnail != null && !_thumbnail.IsInvalid){ + try { + //Get thumbnail size and attempt to fit to control, with padding + Size sourceSize = ThumbnailPixelSize; + _thumbnailSize = sourceSize.Fit(Size); + _padWidth = (Size.Width - _thumbnailSize.Width) / 2; + _padHeight = (Size.Height - _thumbnailSize.Height) / 2; + + System.Diagnostics.Debug.WriteLine("Fitting {0} inside {1} as {2}. Padding {3},{4}.", sourceSize, Size, _thumbnailSize, _padWidth, _padHeight); + + var target = new Rectangle(_padWidth, _padHeight, _thumbnailSize.Width, _thumbnailSize.Height); + Rectangle source = (_regionEnabled) ? _currentRegion.ComputeRegionRectangle(_thumbnail.SourceSize) : new Rectangle(Point.Empty, _thumbnail.SourceSize); + + _thumbnail.Update(target, source, ThumbnailOpacity, true, true); + } + catch { + //Any error updating the thumbnail forces to unset (handle may not be valid anymore) + UnsetThumbnail(); + return; + } + } + } + + #endregion + + #region Region drawing + + const int MinimumRegionSize = 1; + + //Set if currently drawing a window (first click/drag was initiated) + bool _drawingRegion = false; + //Set if drawing was suspended because the mouse left the control + bool _drawingSuspended = false; + Point _regionStartPoint; + Point _regionLastPoint; + + public delegate void RegionDrawnHandler(object sender, ThumbnailRegion region); + + public event RegionDrawnHandler RegionDrawn; + + protected virtual void OnRegionDrawn(Rectangle region) { + //Fix region if necessary (bug report by Gunter, via comment) + if (region.Width < MinimumRegionSize) + region.Width = MinimumRegionSize; + if (region.Height < MinimumRegionSize) + region.Height = MinimumRegionSize; + + var evt = RegionDrawn; + if (evt != null) + evt(this, new ThumbnailRegion(region)); + } + + /// + /// Raises a RegionDrawn event, given a starting and an ending point of the drawn region. + /// + protected void RaiseRegionDrawn(Point start, Point end) { + if (_thumbnailSize.Width < 1 || _thumbnailSize.Height < 1) //causes DivBy0 + return; + + //Compute bounds and clip to boundaries + int left = Math.Min(start.X, end.X); + int right = Math.Max(start.X, end.X); + int top = Math.Min(start.Y, end.Y); + int bottom = Math.Max(start.Y, end.Y); + + //Clip to boundaries + left = Math.Max(0, left); + right = Math.Min(_thumbnailSize.Width, right); + top = Math.Max(0, top); + bottom = Math.Min(_thumbnailSize.Height, bottom); + + //Compute region rectangle in thumbnail coordinates + var startPoint = ClientToThumbnail(new Point(left, top)); + var endPoint = ClientToThumbnail(new Point(right, bottom)); + var final = new Rectangle( + startPoint.X, + startPoint.Y, + endPoint.X - startPoint.X, + endPoint.Y - startPoint.Y + ); + + System.Diagnostics.Trace.WriteLine(string.Format("Drawn from {0} to {1}, as region {2}.", start, end, final)); + + //Signal + OnRegionDrawn(final); + } + + protected override void OnMouseDown(MouseEventArgs e) { + if (DrawMouseRegions && e.Button == MouseButtons.Left) { + //Start new region drawing + _drawingRegion = true; + _drawingSuspended = false; + _regionStartPoint = _regionLastPoint = e.Location; + + this.Invalidate(); + } + + base.OnMouseDown(e); + } + + protected override void OnMouseUp(MouseEventArgs e) { + if (DrawMouseRegions && e.Button == MouseButtons.Left) { + //Region completed + _drawingRegion = false; + _drawingSuspended = false; + RaiseRegionDrawn(_regionStartPoint, _regionLastPoint); + + this.Invalidate(); + } + + base.OnMouseUp(e); + } + + protected override void OnMouseLeave(EventArgs e) { + _drawingSuspended = true; + + this.Invalidate(); + + base.OnMouseLeave(e); + } + + protected override void OnMouseEnter(EventArgs e) { + _drawingSuspended = false; + + this.Invalidate(); + + base.OnMouseEnter(e); + } + + protected override void OnMouseMove(MouseEventArgs e) { + if (_drawingRegion && e.Button == MouseButtons.Left) { + //Continue drawing + _regionLastPoint = e.Location; + + this.Invalidate(); + } + else if(DrawMouseRegions && !_drawingRegion){ + //Keep track of region start point + _regionLastPoint = e.Location; + + this.Invalidate(); + } + + base.OnMouseMove(e); + } + + readonly static Pen RedPen = new Pen(Color.FromArgb(255, Color.Red), 1.5f); //TODO: check width + + protected override void OnPaint(PaintEventArgs e) { + if (_drawingRegion) { + //Is currently drawing, show rectangle + int left = Math.Min(_regionStartPoint.X, _regionLastPoint.X); + int right = Math.Max(_regionStartPoint.X, _regionLastPoint.X); + int top = Math.Min(_regionStartPoint.Y, _regionLastPoint.Y); + int bottom = Math.Max(_regionStartPoint.Y, _regionLastPoint.Y); + + e.Graphics.DrawRectangle(RedPen, left, top, right - left, bottom - top); + } + else if (DrawMouseRegions && ! _drawingSuspended) { + //Show cursor coordinates + e.Graphics.DrawLine(RedPen, new Point(0, _regionLastPoint.Y), new Point(ClientSize.Width, _regionLastPoint.Y)); + e.Graphics.DrawLine(RedPen, new Point(_regionLastPoint.X, 0), new Point(_regionLastPoint.X, ClientSize.Height)); + } + + base.OnPaint(e); + } + + #endregion + + #region Thumbnail clone click + + protected override void OnMouseClick(MouseEventArgs e) { + base.OnMouseClick(e); + + if (_thumbnail == null) + return; + + //Raise clicking event to allow click forwarding + if (ReportThumbnailClicks) { + OnCloneClick(ClientToThumbnail(e.Location), e.Button, false); + } + } + + protected override void OnMouseDoubleClick(MouseEventArgs e) { + base.OnMouseDoubleClick(e); + + if (_thumbnail == null) + return; + + //Raise double clicking event to allow click forwarding + if (ReportThumbnailClicks) { + OnCloneClick(ClientToThumbnail(e.Location), e.Button, true); + } + } + + /// + /// Is raised when the thumbnail clone is clicked. + /// + public event EventHandler CloneClick; + + protected virtual void OnCloneClick(Point location, MouseButtons buttons, bool doubleClick){ + var evt = CloneClick; + if(evt != null) + evt(this, new CloneClickEventArgs(location, buttons, doubleClick)); + } + + #endregion + + /// + /// Convert a point in client coordinates to a point expressed in terms of a cloned thumbnail window. + /// + /// Point in client coordinates. + protected Point ClientToThumbnail(Point position) { + //Compensate padding + position.X -= _padWidth; + position.Y -= _padHeight; + + //Determine position in fractional terms (on the size of the thumbnail control) + PointF proportionalPosition = new PointF( + (float)position.X / _thumbnailSize.Width, + (float)position.Y / _thumbnailSize.Height + ); + + //Get real pixel region info + Size source = ThumbnailPixelSize; + Point offset = (_regionEnabled) ? SelectedRegion.Offset : Point.Empty; + + return new Point( + (int)((proportionalPosition.X * source.Width) + offset.X), + (int)((proportionalPosition.Y * source.Height) + offset.Y) + ); + } + + } + +} diff --git a/OnTopReplica/ThumbnailRegion.cs b/OnTopReplica/ThumbnailRegion.cs new file mode 100644 index 0000000..20cfcf9 --- /dev/null +++ b/OnTopReplica/ThumbnailRegion.cs @@ -0,0 +1,222 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Drawing; +using System.Windows.Forms; + +namespace OnTopReplica { + + /// + /// Represents a thumbnail region. + /// + /// + /// A ThumbnailRegion can work in absolute or in relative mode. + /// In absolute mode, the region is expressed in absolute pixel values, as expressed by the value of the + /// property. + /// In relative mode, the region is expressed in padding pixels from the borders of the source. Internally this + /// is still represented by the property. Properties of the Rectangle value are mapped as follows: + /// Rectangle.X = Padding.Left + /// Rectangle.Y = Padding.Top + /// Rectangle.Width = Padding.Right + /// Rectangle.Height = Padding.Bottom + /// + public class ThumbnailRegion { + + /// + /// Creates a ThumbnailRegion from a padding value relative to the thumbnail borders. + /// + public ThumbnailRegion(Padding padding) { + _bounds = new Rectangle { + X = padding.Left, + Y = padding.Top, + Width = padding.Right, + Height = padding.Bottom + }; + Relative = true; + } + + /// + /// Creates a ThumbnailRegion from a bounds rectangle (in absolute terms). + /// + public ThumbnailRegion(Rectangle rectangle) { + _bounds = rectangle; + Relative = false; + } + + /// + /// Creates a ThumbnailRegion from a rectangle, either expressing values in relative or in absolute terms. + /// + public ThumbnailRegion(Rectangle paddingOrBounds, bool relative) { + _bounds = paddingOrBounds; + Relative = relative; + } + + private Rectangle _bounds; + + /// + /// Gets or sets the bounds of the thumbnail region. + /// + public Rectangle Bounds { + get { +#if DEBUG + if (Relative) + throw new InvalidOperationException("Not allowed to use ThumbnailRegion Bounds as Rectangle value (in relative mode)."); +#endif + + return _bounds; + } + set { + _bounds = value; + Relative = false; + } + } + + /// + /// Gets or sets whether the bounds are expressed relative to the thumbnail borders. + /// + public bool Relative { + get; + set; + } + + /// + /// Sets the relative bounds of the region. Switches to relative mode. + /// + /// Padding in relative terms from the borders. + public void SetRelativeBounds(Padding padding) { + Bounds = new Rectangle { + X = padding.Left, + Y = padding.Top, + Width = padding.Right, + Height = padding.Bottom + }; + Relative = true; + } + + /// + /// Gets the bounds of the thumbnail region as relative padding from the thumbnail borders. + /// + /// Makes sense only in relative mode. + public Padding BoundsAsPadding { + get { +#if DEBUG + if (!Relative) + throw new InvalidOperationException("Not allowed to use ThumbnailRegion Bounds as Padding value (not in relative mode)."); +#endif + + return new Padding { + Left = _bounds.X, + Top = _bounds.Y, + Right = _bounds.Width, + Bottom = _bounds.Height + }; + } + } + + /// + /// Gets the offset of the region. + /// + /// + /// The offset is expressed as a point of displacement from the up-right corner (0,0) of the original source. + /// + public Point Offset { + get { + //This is equal in both absolute and relative mode + return _bounds.Location; + } + } + + const int MinimumRegionSize = 8; + + /// + /// Computes the effective region representing the bounds inside a source thumbnail of a certain size. + /// + /// Size of the full thumbnail source. + /// Bounds inside the thumbnail. + protected Rectangle ComputeRegion(Size sourceSize) { + Rectangle ret; + + //Compute + if (Relative) { + ret = new Rectangle { + X = _bounds.X, + Y = _bounds.Y, + Width = sourceSize.Width - _bounds.X - _bounds.Width, + Height = sourceSize.Height - _bounds.Y - _bounds.Height + }; + } + else { + ret = _bounds; + } + + //Constrain to bounds + if (ret.X + ret.Width > sourceSize.Width) + ret.Width = sourceSize.Width - ret.X; + if (ret.Y + ret.Height > sourceSize.Height) + ret.Height = sourceSize.Height - ret.Y; + + return ret; + } + + /// + /// Computes a rectangle representing the bounds of the region inside a source thumbnail of a certain size. + /// + /// Size of the full thumbnail source. + /// Bounds inside the thumbnail. + public Rectangle ComputeRegionRectangle(Size sourceSize) { + return ComputeRegion(sourceSize); + } + + /// + /// Computes a value representing the size of the region inside a source thumbnail of a certain size. + /// + /// Size of the full thumbnail source. + /// Size of the bounds inside the thumbnail. + public Size ComputeRegionSize(Size sourceSize) { + return ComputeRegion(sourceSize).Size; + } + + /// + /// Switches the region to relative mode, according to a source thumbnail of a given size. + /// + /// Size of the full thumbnail source. + public void SwitchToRelative(Size sourceSize) { + if (Relative) + return; + + var relativeBounds = new Padding { + Left = _bounds.X, + Top = _bounds.Y, + Right = sourceSize.Width - (_bounds.X + _bounds.Width), + Bottom = sourceSize.Height - (_bounds.Y + _bounds.Height) + }; + + this.SetRelativeBounds(relativeBounds); + } + + /// + /// Switches the region to absolute mode, according to a source thumbnail of a given size. + /// + /// Size of the full thumbnail source. + public void SwitchToAbsolute(Size sourceSize) { + if (!Relative) + return; + + var absoluteBounds = new Rectangle { + X = _bounds.X, + Y = _bounds.Y, + Width = (sourceSize.Width - _bounds.Width) - _bounds.X, + Height = (sourceSize.Height - _bounds.Height) - _bounds.Y + }; + + Bounds = absoluteBounds; + } + + public override string ToString() { + return string.Format("({0}, {1})", _bounds, (Relative) ? "relative" : "absolute"); + } + + } + +} diff --git a/OnTopReplica/Update/UpdateCheckCompletedEventArgs.cs b/OnTopReplica/Update/UpdateCheckCompletedEventArgs.cs new file mode 100644 index 0000000..6482835 --- /dev/null +++ b/OnTopReplica/Update/UpdateCheckCompletedEventArgs.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Text; + +namespace OnTopReplica.Update { + class UpdateCheckCompletedEventArgs : EventArgs { + + public UpdateInformation Information { get; set; } + + public bool Success { get; set; } + + public Exception Error { get; set; } + + } +} diff --git a/OnTopReplica/Update/UpdateInformation.cs b/OnTopReplica/Update/UpdateInformation.cs new file mode 100644 index 0000000..662c8c4 --- /dev/null +++ b/OnTopReplica/Update/UpdateInformation.cs @@ -0,0 +1,101 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Xml.Serialization; +using System.IO; +using System.Xml; +using System.Reflection; + +namespace OnTopReplica.Update { + + /// + /// Contains information about the latest OnTopReplica update available. + /// + public class UpdateInformation { + + Version _latestVersion; + + /// + /// Gets the latest available version of the software. + /// + [XmlIgnore] + public Version LatestVersion { + get { + return _latestVersion; + } + set { + _latestVersion = value; + } + } + + [XmlElement("latestVersion")] + public string LatestVersionInternal { + get { + return _latestVersion.ToString(); + } + set { + _latestVersion = new Version(value); + } + } + + /// + /// Returns whether this update information instance represents data about + /// a new available version. + /// + public bool IsNewVersion { + get { + var currentVersion = CurrentVersion; + + return (LatestVersion > currentVersion); + } + } + + /// + /// Gets the currently installed version. + /// + public Version CurrentVersion { + get { + return Assembly.GetExecutingAssembly().GetName().Version; + } + } + + /// + /// Indicates when the latest version was released. + /// + [XmlElement("latestVersionRelease")] + public DateTime LatestVersionRelease { get; set; } + + /// + /// Gets the URL of the page that allows the user to download the updated installer. + /// + [XmlElement("downloadPage")] + public string DownloadPage { get; set; } + + /// + /// Gets the URL of the installer executable. + /// + /// New after version 3.3.1. + [XmlElement("downloadInstaller")] + public string DownloadInstaller { get; set; } + + /// + /// Deserializes an UpdateInformation object from a stream. + /// + public static UpdateInformation Deserialize(Stream source) { + var serializer = new XmlSerializer(typeof(UpdateInformation)); + var info = serializer.Deserialize(source) as UpdateInformation; + return info; + } + + public static string Serialize(UpdateInformation information) { + var serializer = new XmlSerializer(typeof(UpdateInformation)); + var sb = new StringBuilder(); + using(var writer = new StringWriter(sb)){ + serializer.Serialize(writer, information); + } + return sb.ToString(); + } + + } + +} diff --git a/OnTopReplica/Update/UpdateManager.cs b/OnTopReplica/Update/UpdateManager.cs new file mode 100644 index 0000000..826481a --- /dev/null +++ b/OnTopReplica/Update/UpdateManager.cs @@ -0,0 +1,278 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Net; +using System.Net.Cache; +using System.Windows.Forms; +using WindowsFormsAero.TaskDialog; + +namespace OnTopReplica.Update { + + /// + /// Handles update checking and information display. + /// + class UpdateManager { + + /// + /// Constructs a new update manager with an attached form. + /// + /// Form through which all GUI calls are made. Closing this form should terminate the application. + public UpdateManager(Form attachedForm) { + if (attachedForm == null) + throw new ArgumentNullException(); + + AttachedForm = attachedForm; + } + + /// + /// Gets or sets the attached form (through which all GUI calls are made). + /// + protected Form AttachedForm { get; private set; } + + #region Checking + + const string UpdateManifestUrl = "http://www.klopfenstein.net/public/Uploads/ontopreplica/update.xml"; + + /// + /// Gets the latest update information available. + /// + public UpdateInformation LastInformation { get; private set; } + + HttpWebRequest _checkRequest; + + /// + /// Checks for update asynchronously, updating update information. + /// When check is completed, raises update events. + /// + public void CheckForUpdate() { + if (_checkRequest != null) { + _checkRequest.Abort(); + } + + //Build web request + _checkRequest = (HttpWebRequest)HttpWebRequest.Create(UpdateManifestUrl); + _checkRequest.AllowAutoRedirect = true; + _checkRequest.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip; + _checkRequest.CachePolicy = new RequestCachePolicy(RequestCacheLevel.BypassCache); + + _checkRequest.BeginGetResponse(CheckForUpdateCallback, null); + } + + /// + /// Asynchronous callback that handles the update check request. + /// + private void CheckForUpdateCallback(IAsyncResult result) { + if (_checkRequest == null) + return; + + try { + var response = _checkRequest.EndGetResponse(result); + LastInformation = UpdateInformation.Deserialize(response.GetResponseStream()); + + OnUpdateCheckSuccess(LastInformation); + } + catch (Exception ex) { + OnUpdateCheckError(ex); + } + + _checkRequest = null; + } + + #endregion + + #region Eventing + + public event EventHandler UpdateCheckCompleted; + + protected virtual void OnUpdateCheckError(Exception ex) { + var evt = UpdateCheckCompleted; + if (evt != null) { + evt(this, new UpdateCheckCompletedEventArgs { + Success = false, + Error = ex + }); + } + } + + protected virtual void OnUpdateCheckSuccess(UpdateInformation information) { + var evt = UpdateCheckCompleted; + if (evt != null) { + evt(this, new UpdateCheckCompletedEventArgs { + Success = true, + Information = information + }); + } + } + + #endregion + + #region Updating + + HttpWebRequest _downloadRequest; + TaskDialog _updateDialog; + bool _updateDownloaded = false; + + /// + /// Asks confirmation for an update and installs the update. + /// + public void ConfirmAndInstall() { + if (LastInformation == null || !LastInformation.IsNewVersion) + return; + + AttachedForm.SafeInvoke(new Action(ConfirmAndInstallCore)); + } + + /// + /// Core delegate that asks for update confirmation and installs. Must be called from GUI thread. + /// + private void ConfirmAndInstallCore() { + _updateDialog = new TaskDialog { + Title = Strings.UpdateTitle, + Instruction = string.Format(Strings.UpdateAvailableInstruction, LastInformation.LatestVersion), + Content = Strings.UpdateAvailableContent, + CustomButtons = new CustomButton[] { + new CustomButton(Result.OK, string.Format(Strings.UpdateAvailableCommandOk, LastInformation.LatestVersion)), + new CustomButton(Result.Cancel, Strings.UpdateAvailableCommandCancel) + }, + UseCommandLinks = true, + CommonIcon = TaskDialogIcon.Information, + ExpandedInformation = string.Format(Strings.UpdateAvailableExpanded, LastInformation.CurrentVersion, LastInformation.LatestVersion), + }; + _updateDialog.ButtonClick += delegate(object sender, ClickEventArgs args) { + if (args.ButtonID == (int)Result.OK) { + args.PreventClosing = true; + + if (_updateDownloaded) { + //Terminate application + AttachedForm.Close(); + + //Launch updater + Process.Start(UpdateInstallerPath); + } + else { + var downDlg = new TaskDialog { + Title = Strings.UpdateTitle, + Instruction = Strings.UpdateDownloadingInstruction, + ShowProgressBar = true, + ProgressBarMinRange = 0, + ProgressBarMaxRange = 100, + ProgressBarPosition = 0, + CommonButtons = TaskDialogButton.Cancel + }; + _updateDialog.Navigate(downDlg); + + _downloadRequest = (HttpWebRequest)HttpWebRequest.Create(LastInformation.DownloadInstaller); + _downloadRequest.BeginGetResponse(DownloadAsyncCallback, null); + } + } + }; + + _updateDialog.Show(AttachedForm); + } + + /// + /// Gets the target filename used when downloading the update from the Internet. + /// + private string UpdateInstallerPath { + get { + var downloadPath = Native.FilesystemMethods.DownloadsPath; + + string versionName = (LastInformation != null) ? + LastInformation.LatestVersion.ToString() : string.Empty; + string filename = string.Format("OnTopReplica-Update-{0}.exe", versionName); + + return Path.Combine(downloadPath, filename); + } + } + + /// + /// Handles background downloading. + /// + private void DownloadAsyncCallback(IAsyncResult result) { + if (_downloadRequest == null || _updateDialog == null) + return; + + try { + var response = _downloadRequest.EndGetResponse(result); + var responseStream = response.GetResponseStream(); + long total = response.ContentLength; + + byte[] buffer = new byte[1024]; + + using (var stream = new FileStream(UpdateInstallerPath, FileMode.Create)) { + int readTotal = 0; + while (true) { + int read = responseStream.Read(buffer, 0, buffer.Length); + readTotal += read; + + if (read <= 0) //EOF + break; + + stream.Write(buffer, 0, read); + + _updateDialog.Content = string.Format(Strings.UpdateDownloadingContent, readTotal, total); + _updateDialog.ProgressBarPosition = (int)((readTotal * 100.0) / total); + } + } + } + catch (Exception ex) { + DownloadShowError(ex.Message); + return; + } + + _updateDownloaded = true; + + var okDlg = new TaskDialog { + Title = Strings.UpdateTitle, + Instruction = Strings.UpdateReadyInstruction, + Content = string.Format(Strings.UpdateReadyContent, LastInformation.LatestVersion), + UseCommandLinks = true, + CommonButtons = TaskDialogButton.Cancel, + CustomButtons = new CustomButton[] { + new CustomButton(Result.OK, Strings.UpdateReadyCommandOk) + } + }; + _updateDialog.Navigate(okDlg); + } + + private void DownloadShowError(string msg) { + if (_updateDialog == null) + return; + + _updateDialog.ProgressBarState = WindowsFormsAero.ProgressBar.States.Error; + _updateDialog.Content = msg; + } + + /// + /// Displays some information about the current installation and available updates. + /// + public void DisplayInfo() { + AttachedForm.SafeInvoke(new Action(DisplayInfoCore)); + } + + /// + /// Displays info. Called from GUI thread. + /// + private void DisplayInfoCore() { + //No updates, but need to inform the user + var dlg = new TaskDialog { + Title = Strings.UpdateTitle, + Instruction = Strings.UpdateInfoInstruction, + Content = Strings.UpdateInfoContent, + EnableHyperlinks = true, + CommonButtons = TaskDialogButton.Close, + AllowDialogCancellation = true, + CommonIcon = TaskDialogIcon.Information, + Footer = string.Format(Strings.UpdateInfoFooter, LastInformation.LatestVersionRelease.ToLongDateString()) + }; + dlg.HyperlinkClick += delegate(object sender, HyperlinkEventArgs args) { + Process.Start("http://ontopreplica.codeplex.com"); + }; + dlg.Show(AttachedForm); + } + + #endregion + + } + +} diff --git a/OnTopReplica/Win32Helper.cs b/OnTopReplica/Win32Helper.cs new file mode 100644 index 0000000..618c69e --- /dev/null +++ b/OnTopReplica/Win32Helper.cs @@ -0,0 +1,126 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Native; +using System.Drawing; +using System.Windows.Forms; + +namespace OnTopReplica { + public static class Win32Helper { + + #region Injection + + /// Inject a fake left mouse click on a target window, on a location expressed in client coordinates. + /// Target window to click on. + /// Location of the mouse click expressed in client coordiantes of the target window. + /// True if a double click should be injected. + public static void InjectFakeMouseClick(IntPtr window, CloneClickEventArgs clickArgs) { + NPoint clientClickLocation = NPoint.FromPoint(clickArgs.ClientClickLocation); + NPoint scrClickLocation = WindowManagerMethods.ClientToScreen(window, clientClickLocation); + + //HACK (?) + //If target window has a Menu (which appears on the thumbnail) move the clicked location down + //in order to adjust (the menu isn't part of the window's client rect). + IntPtr hMenu = WindowMethods.GetMenu(window); + if (hMenu != IntPtr.Zero) + scrClickLocation.Y -= SystemInformation.MenuHeight; + + IntPtr hChild = GetRealChildControlFromPoint(window, scrClickLocation); + NPoint clntClickLocation = WindowManagerMethods.ScreenToClient(hChild, scrClickLocation); + + if (clickArgs.Buttons == MouseButtons.Left) { + if(clickArgs.IsDoubleClick) + InjectDoubleLeftMouseClick(hChild, clntClickLocation); + else + InjectLeftMouseClick(hChild, clntClickLocation); + } + else if (clickArgs.Buttons == MouseButtons.Right) { + if(clickArgs.IsDoubleClick) + InjectDoubleRightMouseClick(hChild, clntClickLocation); + else + InjectRightMouseClick(hChild, clntClickLocation); + } + } + + private static void InjectLeftMouseClick(IntPtr child, NPoint clientLocation) { + IntPtr lParamClickLocation = MessagingMethods.MakeLParam(clientLocation.X, clientLocation.Y); + + MessagingMethods.PostMessage(child, WM.LBUTTONDOWN, new IntPtr(MK.LBUTTON), lParamClickLocation); + MessagingMethods.PostMessage(child, WM.LBUTTONUP, new IntPtr(MK.LBUTTON), lParamClickLocation); + +#if DEBUG + System.Diagnostics.Debug.WriteLine("Left click on window #" + child.ToString() + " at " + clientLocation.ToString()); +#endif + } + + private static void InjectRightMouseClick(IntPtr child, NPoint clientLocation) { + IntPtr lParamClickLocation = MessagingMethods.MakeLParam(clientLocation.X, clientLocation.Y); + + MessagingMethods.PostMessage(child, WM.RBUTTONDOWN, new IntPtr(MK.RBUTTON), lParamClickLocation); + MessagingMethods.PostMessage(child, WM.RBUTTONUP, new IntPtr(MK.RBUTTON), lParamClickLocation); + +#if DEBUG + System.Diagnostics.Debug.WriteLine("Right click on window #" + child.ToString() + " at " + clientLocation.ToString()); +#endif + } + + private static void InjectDoubleLeftMouseClick(IntPtr child, NPoint clientLocation) { + IntPtr lParamClickLocation = MessagingMethods.MakeLParam(clientLocation.X, clientLocation.Y); + + MessagingMethods.PostMessage(child, WM.LBUTTONDBLCLK, new IntPtr(MK.LBUTTON), lParamClickLocation); + +#if DEBUG + System.Diagnostics.Debug.WriteLine("Double left click on window #" + child.ToString() + " at " + clientLocation.ToString()); +#endif + } + + private static void InjectDoubleRightMouseClick(IntPtr child, NPoint clientLocation) { + IntPtr lParamClickLocation = MessagingMethods.MakeLParam(clientLocation.X, clientLocation.Y); + + MessagingMethods.PostMessage(child, WM.RBUTTONDBLCLK, new IntPtr(MK.RBUTTON), lParamClickLocation); + +#if DEBUG + System.Diagnostics.Debug.WriteLine("Double right click on window #" + child.ToString() + " at " + clientLocation.ToString()); +#endif + } + + #endregion + + /// Returns the child control of a window corresponding to a screen location. + /// Parent window to explore. + /// Child control location in screen coordinates. + private static IntPtr GetRealChildControlFromPoint(IntPtr parent, NPoint scrClickLocation) { + IntPtr curr = parent, child = IntPtr.Zero; + do { + child = WindowManagerMethods.RealChildWindowFromPoint(curr, + WindowManagerMethods.ScreenToClient(curr, scrClickLocation)); + + if (child == IntPtr.Zero || child == curr) + break; + + //Update for next loop + curr = child; + } + while (true); + + //Safety check, shouldn't happen + if (curr == IntPtr.Zero) + curr = parent; + + return curr; + } + + /// + /// Gets a handle to the window that currently is in the foreground. + /// + /// May return null if call fails or no valid window selected. + public static WindowHandle GetCurrentForegroundWindow() { + IntPtr handle = WindowManagerMethods.GetForegroundWindow(); + if (handle == IntPtr.Zero) + return null; + + return new WindowHandle(handle); + } + + } +} diff --git a/OnTopReplica/WindowHandle.cs b/OnTopReplica/WindowHandle.cs new file mode 100644 index 0000000..e2d4851 --- /dev/null +++ b/OnTopReplica/WindowHandle.cs @@ -0,0 +1,141 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Drawing; +using OnTopReplica.Native; + +namespace OnTopReplica { + + /// + /// Helper class that keeps a window handle (HWND), + /// the title of the window and can load its icon. + /// + public class WindowHandle : System.Windows.Forms.IWin32Window { + + IntPtr _handle; + string _title; + + /// + /// Creates a new WindowHandle instance. The handle pointer must be valid, the title + /// may be null or empty and will be updated as requested. + /// + public WindowHandle(IntPtr p, string title) { + _handle = p; + _title = title; + } + + /// + /// Creates a new WindowHandle instance. Additional features of the handle will be queried as needed. + /// + /// + public WindowHandle(IntPtr p) { + _handle = p; + _title = null; + } + + public string Title { + get { + if (_title == null) { + _title = WindowMethods.GetWindowText(_handle) ?? string.Empty; + } + + return _title; + } + } + + Icon _icon = null; + bool _iconFetched = false; + public Icon Icon { + get { + if (!_iconFetched) { + //Fetch icon from window + IntPtr hIcon; + + if (MessagingMethods.SendMessageTimeout(_handle, WM.GETICON, new IntPtr(2), new IntPtr(0), + MessagingMethods.SendMessageTimeoutFlags.AbortIfHung | MessagingMethods.SendMessageTimeoutFlags.Block, 500, out hIcon) == IntPtr.Zero) { + hIcon = IntPtr.Zero; + } + + if (hIcon != IntPtr.Zero) { + _icon = Icon.FromHandle(hIcon); + } + else { + //Fetch icon from window class + hIcon = (IntPtr)WindowMethods.GetClassLong(_handle, WindowMethods.ClassLong.IconSmall); + + if (hIcon.ToInt64() != 0) { + _icon = Icon.FromHandle(hIcon); + } + } + } + + _iconFetched = true; + + return _icon; + } + } + + string _class = null; + + /// + /// Gets the window's class name. + /// + /// + /// This value is cached and is never null. + /// + public string Class { + get { + if (_class == null) { + _class = Native.WindowMethods.GetWindowClass(Handle) ?? string.Empty; + } + return _class; + } + } + + #region Object override + + public override string ToString() { + if (string.IsNullOrWhiteSpace(_title)) { + return string.Format("#{0}", _handle.ToInt64()); + } + else { + return string.Format("#{0} ({1})", _handle.ToInt64(), _title); + } + } + + public override bool Equals(object obj) { + if (ReferenceEquals(obj, this)) + return true; + + System.Windows.Forms.IWin32Window win = obj as System.Windows.Forms.IWin32Window; + + if (win == null) + return false; + + return (win.Handle == _handle); + } + + public override int GetHashCode() { + return _handle.GetHashCode(); + } + + #endregion + + #region IWin32Window Members + + public IntPtr Handle { + get { return _handle; } + } + + #endregion + + /// + /// Creates a new windowHandle instance from a given IntPtr handle. + /// + /// Handle value. + public static WindowHandle FromHandle(IntPtr handle) { + return new WindowHandle(handle, null); + } + + } +} diff --git a/OnTopReplica/WindowListMenuManager.cs b/OnTopReplica/WindowListMenuManager.cs new file mode 100644 index 0000000..a79fa74 --- /dev/null +++ b/OnTopReplica/WindowListMenuManager.cs @@ -0,0 +1,202 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; +using OnTopReplica.WindowSeekers; +using OnTopReplica.Properties; + +namespace OnTopReplica { + /// + /// Manages the window list displayed when allowing the user to select a window to clone. + /// + class WindowListMenuManager { + + const int MaxWindowTitleLength = 55; + + readonly MainForm _owner; + readonly ContextMenuStrip _windowsMenu; + + public WindowListMenuManager(MainForm owner, ContextMenuStrip windowsMenu) { + _owner = owner; + _windowsMenu = windowsMenu; + + WindowSeeker = new TaskWindowSeeker() { + OwnerHandle = owner.Handle, + SkipNotVisibleWindows = true + }; + + //Bind events + windowsMenu.Opening += new System.ComponentModel.CancelEventHandler(WindowsMenu_opening); + } + + void WindowsMenu_opening(object sender, System.ComponentModel.CancelEventArgs e) { + WindowSeeker.Refresh(); + PopulateMenu(_owner.CurrentThumbnailWindowHandle); + } + + /// + /// Populates the menu with windows from the window seeker instance. + /// + /// Handle of the currently selected window or null if none selected. + private void PopulateMenu(WindowHandle currentSelection) { + var regions = GetStoredRegions(); + + _windowsMenu.Items.Clear(); + + //"None" selection + var nullTsi = new ToolStripMenuItem(Strings.MenuWindowsNone); + nullTsi.Tag = null; + nullTsi.Click += MenuWindowClickHandler; + nullTsi.Checked = (currentSelection == null); + _windowsMenu.Items.Add(nullTsi); + + //Add an item for each window + foreach (WindowHandle h in WindowSeeker.Windows) { + var tsi = new ToolStripMenuItem(); + + //Window title + if (h.Title.Length > MaxWindowTitleLength) { + tsi.Text = h.Title.Substring(0, MaxWindowTitleLength) + "..."; + tsi.ToolTipText = h.Title; + } + else + tsi.Text = h.Title; + + //Icon + if (h.Icon != null) { + try { + tsi.Image = h.Icon.ToBitmap(); + } + catch (Exception) { + tsi.Image = null; + } + } + + //Check if this is the currently displayed window + tsi.Checked = h.Equals(currentSelection); + + //Click handler + tsi.Tag = h; + tsi.Click += MenuWindowClickHandler; + + PopulateRegionsDropdown(tsi, h, regions); + + _windowsMenu.Items.Add(tsi); + } + } + + private void PopulateRegionsDropdown(ToolStripMenuItem parent, WindowHandle parentHandle, StoredRegion[] regions) { + parent.DropDownItems.Clear(); + + //No region + var nullRegionItem = new ToolStripMenuItem(Strings.MenuWindowsWholeRegion); + nullRegionItem.Tag = parentHandle; + nullRegionItem.Image = Resources.regions; + nullRegionItem.Click += MenuWindowClickHandler; + parent.DropDownItems.Add(nullRegionItem); + + //Video detector + /*var detectorItem = new ToolStripMenuItem("Autodetect plugin"); + detectorItem.Tag = parentHandle; + detectorItem.Click += MenuVideoCropperClickHandler; + parent.DropDownItems.Add(detectorItem);*/ + + //Regions (if any) + if (regions == null || regions.Length == 0) + return; + + parent.DropDownItems.Add(new ToolStripSeparator()); + + foreach (StoredRegion region in regions) { + var regionItem = new ToolStripMenuItem(region.Name); + regionItem.Tag = new Tuple(parentHandle, region); + regionItem.Click += MenuRegionWindowClickHandler; + + parent.DropDownItems.Add(regionItem); + } + } + + private void MenuWindowClickHandler(object sender, EventArgs args) { + CommonClickHandler(); + + var tsi = (ToolStripMenuItem)sender; + if (tsi.Tag == null) { + _owner.UnsetThumbnail(); + } + else { + var handle = (WindowHandle)tsi.Tag; + _owner.SetThumbnail(handle, null); + } + } + + private void MenuRegionWindowClickHandler(object sender, EventArgs args) { + CommonClickHandler(); + + var tsi = (ToolStripMenuItem)sender; + var tuple = (Tuple)tsi.Tag; + _owner.SetThumbnail(tuple.Item1, + (tuple.Item2 != null) ? (ThumbnailRegion)tuple.Item2.Region : null); + } + + /*PluginRegionLocator _pluginRegionLocator = null; + + private void MenuVideoCropperClickHandler(object sender, EventArgs args){ + CommonClickHandler(); + + var tsi = (ToolStripMenuItem)sender; + var handle = (WindowHandle)tsi.Tag; + + if (_pluginRegionLocator == null) + _pluginRegionLocator = new PluginRegionLocator(); + + var detectedRegion = _pluginRegionLocator.LocatePluginRegion(handle); + _owner.SetThumbnail(handle, detectedRegion); + }*/ + + private void CommonClickHandler() { + _windowsMenu.Close(); + foreach (ContextMenuStrip menu in _parentMenus) + menu.Close(); + } + + /// + /// Gets an array of stored regions. + /// + private StoredRegion[] GetStoredRegions() { + if (Settings.Default.SavedRegions == null || Settings.Default.SavedRegions.Count == 0) + return null; + + StoredRegion[] ret = new StoredRegion[Settings.Default.SavedRegions.Count]; + Settings.Default.SavedRegions.CopyTo(ret); + + Array.Sort(ret, (a, b) => { + return a.Name.CompareTo(b.Name); + }); + + return ret; + } + + /// + /// Gets or sets the window seeker instance used to list windows. + /// + public BaseWindowSeeker WindowSeeker { get; set; } + + ContextMenuStrip[] _parentMenus = new ContextMenuStrip[0]; + + /// + /// Gets the parent menus which are bound to the context menu handled by this manager. + /// + public ContextMenuStrip[] ParentMenus { + get { + return (ContextMenuStrip[])_parentMenus.Clone(); + } + set { + if(value == null) + _parentMenus = new ContextMenuStrip[0]; + else + _parentMenus = (ContextMenuStrip[])value.Clone(); + } + } + + } +} diff --git a/OnTopReplica/WindowSeekers/BaseWindowSeeker.cs b/OnTopReplica/WindowSeekers/BaseWindowSeeker.cs new file mode 100644 index 0000000..6a00ed5 --- /dev/null +++ b/OnTopReplica/WindowSeekers/BaseWindowSeeker.cs @@ -0,0 +1,68 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Native; + +namespace OnTopReplica.WindowSeekers { + + /// + /// Base class for window seekers that can populate a list of window handles based on some criteria and with basic filtering. + /// + abstract class BaseWindowSeeker : IWindowSeeker { + + #region IWindowSeeker + + /// + /// Get the matching windows from the last refresh. + /// + public abstract IList Windows { + get; + } + + /// + /// Forces a window list refresh. + /// + public virtual void Refresh() { + WindowManagerMethods.EnumWindows(RefreshCallback, IntPtr.Zero); + } + + #endregion + + private bool RefreshCallback(IntPtr hwnd, IntPtr lParam) { + //Skip owner + if (hwnd == OwnerHandle) + return true; + + if (SkipNotVisibleWindows && !WindowManagerMethods.IsWindowVisible(hwnd)) + return true; + + //Extract basic properties + string title = WindowMethods.GetWindowText(hwnd); + var handle = new WindowHandle(hwnd, title); + + return InspectWindow(handle); + } + + /// + /// Inspects a window and return whether inspection should continue. + /// + /// Handle of the window. + /// True if inspection should continue. False stops current refresh operation. + protected abstract bool InspectWindow(WindowHandle handle); + + /// + /// Gets or sets the window handle of the owner. + /// + /// + /// Windows with this handle will be automatically skipped. + /// + public IntPtr OwnerHandle { get; set; } + + /// + /// Gets or sets whether not visible windows should be skipped. + /// + public bool SkipNotVisibleWindows { get; set; } + + } + +} diff --git a/OnTopReplica/WindowSeekers/ByClassWindowSeeker.cs b/OnTopReplica/WindowSeekers/ByClassWindowSeeker.cs new file mode 100644 index 0000000..e6e73dc --- /dev/null +++ b/OnTopReplica/WindowSeekers/ByClassWindowSeeker.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Native; + +namespace OnTopReplica.WindowSeekers { + /// + /// Seeks a single window by matching its window class. + /// + /// + /// Class matching is case-sensitive and prefers perfect matches, also accepting + /// partial matches (when the class matches the beginning of the target class name). + /// + class ByClassWindowSeeker : PointBasedWindowSeeker { + + public ByClassWindowSeeker(string className) { + if (className == null) + throw new ArgumentNullException(); + + ClassName = className; + } + + public string ClassName { get; private set; } + + protected override int EvaluatePoints(WindowHandle handle) { + if(string.IsNullOrEmpty(handle.Class)) + return -1; + + int points = 0; + + //Partial match + if (handle.Class.StartsWith(ClassName, StringComparison.InvariantCulture)) + points += 10; + + if (handle.Class.Equals(ClassName, StringComparison.InvariantCulture)) + points += 10; + + return points; + } + } +} diff --git a/OnTopReplica/WindowSeekers/ByTitleWindowSeeker.cs b/OnTopReplica/WindowSeekers/ByTitleWindowSeeker.cs new file mode 100644 index 0000000..c551392 --- /dev/null +++ b/OnTopReplica/WindowSeekers/ByTitleWindowSeeker.cs @@ -0,0 +1,46 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Native; + +namespace OnTopReplica.WindowSeekers { + /// + /// Seeks a single window by approximately matching its title. + /// + /// + /// Title search is case-insensitive and matches only the beginning of the windows' titles. + /// + class ByTitleWindowSeeker : PointBasedWindowSeeker { + + public ByTitleWindowSeeker(string titleSeekString) { + if (titleSeekString == null) + throw new ArgumentNullException(); + + TitleMatch = titleSeekString.Trim(); + } + + public string TitleMatch { get; private set; } + + protected override int EvaluatePoints(WindowHandle handle) { + //Skip empty titles + if (string.IsNullOrEmpty(handle.Title)) + return -1; + + //Skip non top-level windows + if (!WindowManagerMethods.IsTopLevel(handle.Handle)) + return -1; + + int points = 0; + + //Give points for partial match + if (handle.Title.StartsWith(TitleMatch, StringComparison.InvariantCultureIgnoreCase)) + points += 10; + + //Give points for exact match + if (handle.Title.Equals(TitleMatch, StringComparison.InvariantCultureIgnoreCase)) + points += 10; + + return points; + } + } +} diff --git a/OnTopReplica/WindowSeekers/IWindowSeeker.cs b/OnTopReplica/WindowSeekers/IWindowSeeker.cs new file mode 100644 index 0000000..42e4024 --- /dev/null +++ b/OnTopReplica/WindowSeekers/IWindowSeeker.cs @@ -0,0 +1,23 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OnTopReplica.WindowSeekers { + /// + /// Interface for window seekers. + /// + interface IWindowSeeker { + + /// + /// Get the list of matching windows, ordered by priority (optionally). + /// + IList Windows { get; } + + /// + /// Refreshes the list of windows. + /// + void Refresh(); + + } +} diff --git a/OnTopReplica/WindowSeekers/PointBasedWindowSeeker.cs b/OnTopReplica/WindowSeekers/PointBasedWindowSeeker.cs new file mode 100644 index 0000000..92241f7 --- /dev/null +++ b/OnTopReplica/WindowSeekers/PointBasedWindowSeeker.cs @@ -0,0 +1,55 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +namespace OnTopReplica.WindowSeekers { + /// + /// Window seeker that uses a point system to get a list of matching windows listed by optimality. + /// + abstract class PointBasedWindowSeeker : BaseWindowSeeker { + + IList _currentWindowList = new List(); + + public override IList Windows { + get { + return _currentWindowList; + } + } + + List> _sortingList = null; + + public override void Refresh() { + _sortingList = new List>(); + + base.Refresh(); + + //Sort and store + _currentWindowList = (from t in _sortingList + orderby t.Item1 descending + select t.Item2).ToList(); + + _sortingList = null; + } + + protected override bool InspectWindow(WindowHandle handle) { + int points = EvaluatePoints(handle); + if(points >= 0){ + _sortingList.Add(new Tuple(points, handle)); + } + + return true; + } + + /// + /// Evalutes the points for a window handle. + /// + /// Handle to the window. + /// + /// Number of points. Higher points identify better suited windows. + /// Windows with negative points are discarded altogether. + /// + protected abstract int EvaluatePoints(WindowHandle handle); + + } +} diff --git a/OnTopReplica/WindowSeekers/RestoreWindowSeeker.cs b/OnTopReplica/WindowSeekers/RestoreWindowSeeker.cs new file mode 100644 index 0000000..5c06e05 --- /dev/null +++ b/OnTopReplica/WindowSeekers/RestoreWindowSeeker.cs @@ -0,0 +1,61 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Native; + +namespace OnTopReplica.WindowSeekers { + + /// + /// Window seeker that attempts to locate a window to restore (by class, title and ID). + /// + class RestoreWindowSeeker : PointBasedWindowSeeker { + + public RestoreWindowSeeker(IntPtr handle, string title, string className){ + Handle = handle; + Title = title; + Class = className; + } + + public IntPtr Handle { get; private set; } + + public string Title { get; private set; } + + public string Class { get; private set; } + + protected override int EvaluatePoints(WindowHandle handle) { + if (!WindowManagerMethods.IsTopLevel(handle.Handle)) { + return -1; + } + + int points = 0; + + //Class exact match + if (!string.IsNullOrEmpty(Class)) { + string wndClass = handle.Class; + if (wndClass.StartsWith(Class, StringComparison.InvariantCulture)){ + points += 10; + } + } + + //Title match (may not be exact, but let's try) + if (!string.IsNullOrEmpty(Title) && !string.IsNullOrEmpty(handle.Title)) { + if (handle.Title.StartsWith(Title, StringComparison.InvariantCultureIgnoreCase)) { + points += 10; + } + if (handle.Title.Equals(Title, StringComparison.InvariantCultureIgnoreCase)) { + points += 5; + } + } + + //Handle match (will probably not work, but anyhow) + if (Handle != IntPtr.Zero) { + if (Handle == handle.Handle) { + points += 10; + } + } + + return points; + } + } + +} diff --git a/OnTopReplica/WindowSeekers/TaskWindowSeeker.cs b/OnTopReplica/WindowSeekers/TaskWindowSeeker.cs new file mode 100644 index 0000000..c074da9 --- /dev/null +++ b/OnTopReplica/WindowSeekers/TaskWindowSeeker.cs @@ -0,0 +1,52 @@ +using System; +using System.Collections.Generic; +using System.Text; +using OnTopReplica.Native; + +namespace OnTopReplica.WindowSeekers { + /// + /// Window seeker that attempts to mimic ALT+TAB behavior in filtering windows to show. + /// + class TaskWindowSeeker : BaseWindowSeeker { + + List _list = new List(); + + public override IList Windows { + get { + return _list; + } + } + + public override void Refresh() { + _list.Clear(); + + base.Refresh(); + } + + protected override bool InspectWindow(WindowHandle handle) { + //Code taken from: http://www.thescarms.com/VBasic/alttab.aspx + + //Reject empty titles + if (string.IsNullOrEmpty(handle.Title)) + return true; + + //Accept windows that + // - are visible + // - do not have a parent + // - have no owner and are not Tool windows OR + // - have an owner and are App windows + if ((long)WindowManagerMethods.GetParent(handle.Handle) == 0) { + bool hasOwner = (long)WindowManagerMethods.GetWindow(handle.Handle, WindowManagerMethods.GetWindowMode.GW_OWNER) != 0; + WindowMethods.WindowExStyles exStyle = (WindowMethods.WindowExStyles)WindowMethods.GetWindowLong(handle.Handle, WindowMethods.WindowLong.ExStyle); + + if (((exStyle & WindowMethods.WindowExStyles.ToolWindow) == 0 && !hasOwner) || //unowned non-tool window + ((exStyle & WindowMethods.WindowExStyles.AppWindow) == WindowMethods.WindowExStyles.AppWindow && hasOwner)) { //owned application window + + _list.Add(handle); + } + } + + return true; + } + } +} diff --git a/OnTopReplica/WindowsFormsExtensions.cs b/OnTopReplica/WindowsFormsExtensions.cs new file mode 100644 index 0000000..d664dc1 --- /dev/null +++ b/OnTopReplica/WindowsFormsExtensions.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Windows.Forms; + +namespace OnTopReplica { + + /// + /// Extension methods for windows forms. + /// + static class WindowsFormsExtensions { + + /// + /// Internationalizes the text of a LinkLabel instance. + /// + /// Main text without link. Contains a '%' character which will be replaced by the link. + /// Linked text. + public static void Internationalize(this LinkLabel label, string text, string linkText) { + int linkIndex = text.IndexOf('%'); + if (linkIndex == -1) { + //Shouldn't happen, but try to fail with meaningful text + label.Text = text; + return; + } + + label.Text = text.Substring(0, linkIndex) + linkText + text.Substring(linkIndex + 1); + label.LinkArea = new LinkArea(linkIndex, linkText.Length); + } + + /// + /// Makes a safe GUI invoke on a form's GUI thread. + /// + /// The action to be executed on the GUI's thread. + /// + /// If the form is invalid or disposed, the action is not performed. + /// + public static void SafeInvoke(this Form form, Action action) { + if (form == null || form.IsDisposed) + return; + + if (form.InvokeRequired) { + form.Invoke(action); + } + else { + action(); + } + } + + } +} diff --git a/OnTopReplica/app.config b/OnTopReplica/app.config new file mode 100644 index 0000000..d5be21d --- /dev/null +++ b/OnTopReplica/app.config @@ -0,0 +1,60 @@ + + + + +
+ + + + + + 255 + + + (Default) + + + True + + + True + + + True + + + True + + + False + + + False + + + 0, 0 + + + 0, 0 + + + False + + + + + + + + + 0 + + + [CTRL]+[SHIFT]+C + + + [CTRL]+[SHIFT]+O + + + + diff --git a/OriginalAssets/Logo.png b/OriginalAssets/Logo.png new file mode 100644 index 0000000..fd56566 Binary files /dev/null and b/OriginalAssets/Logo.png differ diff --git a/OriginalAssets/icon.pdn b/OriginalAssets/icon.pdn new file mode 100644 index 0000000..b6e0be2 Binary files /dev/null and b/OriginalAssets/icon.pdn differ diff --git a/OriginalAssets/new-icon.png b/OriginalAssets/new-icon.png new file mode 100644 index 0000000..dfa49b4 Binary files /dev/null and b/OriginalAssets/new-icon.png differ