API Reference

The full file path where screenshots are saved. This must include the folder path, the filename, and the file extension.

Supported file formats:

• .png: Best quality, supports transparency. Recommended for most uses.
• .jpg / .jpeg: Smaller file size, controlled by JpgQuality. Good for photos.
• .bmp: Uncompressed bitmap. Very large files, rarely needed.
• .tiff: High-quality format often used in print workflows.

If left empty, screenshots are silently discarded (not saved anywhere). No error is shown.

Examples:

; Save to the Pictures folder
SavePath=C:\Users\YourName\Pictures\shot.png

; Use a Rainmeter variable for the config folder
SavePath=#@#Screenshots\capture.jpg

; Use a date-stamped path (Rainmeter evaluates variables)
SavePath=#@#Screenshots\shot_#DATE#.png

Common mistakes to avoid:

• Forgetting the file extension (e.g. SavePath=C:\shots\photo): this will cause the save to fail.
• Using a folder that doesn't exist: make sure the directory is created beforehand.
• Using UNC paths (e.g. \\server\share): these are not supported.

Related settings: JpgQuality (for JPEG compression), ShowNotification (to see a preview after capture).

Controls whether the mouse cursor is visible in screenshots and GIF frames.

• 0: The mouse cursor is not captured. The screenshot shows only what is behind the cursor.
• 1: The mouse cursor is drawn onto the screenshot at its current screen position. This is useful when you need to show where you clicked or pointed.

Example:

ShowCursor=1

Why use this? If you are creating a tutorial or need to point to something on screen, set this to 1 so the cursor appears in the capture. For clean screenshots (e.g. wallpaper captures), leave it at 0.

Related settings: This applies to all screenshot modes and GIF recording.

Show a toast notification after a successful screenshot or GIF save. A toast notification is a small popup that appears briefly on your screen (typically in the corner) and then fades away.

• 0: No notification is shown after capture.
• 1: A themed notification popup appears with a small preview of the captured image. You can click the notification body to trigger NotificationClickAction if one is set.

Example:

ShowNotification=1
NotificationSound=1
NotificationClickAction=[!Log "User clicked the notification"]

What the notification looks like: It shows a small thumbnail of your screenshot, the file path, and the capture mode used. The notification theme follows the UITheme setting.

Related settings: NotificationSound, NotificationClickAction, UITheme.

Play a Windows notification sound when the toast notification appears (see ShowNotification).

• 0: No sound is played.
• 1: A notification sound plays (specifically the Windows Notify System Generic WAV file).

Technical note: This uses a specific Windows WAV file, which is independent of the Windows sound scheme's "Asterisk" event. The Asterisk event is often set to silent in Windows settings, so FinalShot uses its own sound file instead.

Example:

NotificationSound=1

Controls the window capture method used by the -ws (window capture) command.

• 0: Uses screen-based capture. The window is captured from what is visible on screen. Other windows that overlap on top will appear in the capture. This is the default and works on all windows.
• 1: Uses the PrintWindow API. This captures the window exclusively: overlapping windows are not included. The capture shows only the target window, even if other windows are in front of it.

When to use PrintWindow: Use UsePrintWindow=1 when you need a clean capture of a single window without other windows getting in the way. This is especially useful for capturing background windows or overlapping windows.

Limitations: Some applications may not render correctly with PrintWindow (e.g. certain hardware-accelerated apps). If the capture looks blank or wrong, try switching to 0.

Example:

UsePrintWindow=1

Related: -ws|windowtitle command, -wh (store window handle).

Controls the compression quality of JPEG screenshots. This setting only applies when the SavePath ends in .jpg or .jpeg. It has no effect on PNG, BMP, or TIFF files.

• 0: Lowest quality. Very small file size, but images look blocky and blurry.
• 50: Medium quality. A good balance between file size and visual quality.
• 70: Default. Good quality for most purposes.
• 100: Highest quality. Largest file size, but nearly lossless.

Example:

SavePath=C:\Screenshots\photo.jpg
JpgQuality=85

Why use this? If you need to email screenshots or keep file sizes small, lower the quality (e.g. 50). If quality matters more than file size (e.g. for printing or archiving), raise it (e.g. 95).

Tip: For screenshots with text or sharp edges, PNG (via .png extension) is often better than JPEG regardless of quality setting, because JPEG can introduce blurriness around text.

A Rainmeter bang command (or any valid Rainmeter bang) to execute automatically after a screenshot is saved. This is called a "callback": it lets you run code in response to an event. Does not run after GIF saves. Use GifFinishAction for that.

Leave empty for no action after capture.

Example:

; After saving, update a meter that shows the last screenshot path
ScreenshotFinishAction=[!UpdateMeter MeterLastShot][!Redraw]

; Or log a message
ScreenshotFinishAction=[!Log "Screenshot saved successfully"]

Important: This action runs after the file is written to disk. If the save fails (e.g. invalid path), the action is not executed.

Related: This applies to -fs, -ps, -cs, and -ws commands. GIF recording has its own separate actions (see GIF Recording Settings).

A Rainmeter bang to run when the user clicks the toast body (not the close button).

For opening the saved capture, use a path bang with GetLastScreenshotPath() (or GetSavePath() for GIFs). Rainmeter may resolve that path when the measure reloads; the plugin still opens the file shown on this toast.

Leave empty for no action when the notification is clicked.

Example:

; Open the last screenshot
NotificationClickAction=["[&Measure_FinalShot:GetLastScreenshotPath()]"]

; Open the last GIF
NotificationClickAction=["[&Measure_FinalShot:GetSavePath()]"]

; Open a fixed folder
NotificationClickAction=["C:\Users\YourName\Pictures"]

Note: This setting requires ShowNotification to be 1 for the notification to appear in the first place.

Controls the visual theme (color scheme) of all FinalShot popup windows, including the notification toast, GIF encoding progress window, and state dialogs.

• 0 or dark: Dark theme. Uses dark backgrounds with light text. Good for dark-mode desktops.
• 1 or light: Light theme. Uses light backgrounds with dark text. Good for light-mode desktops.
• 2 or system: System theme. Automatically follows the Windows "Apps use light theme" setting (found in Settings → Personalization → Colors).

Example:

UITheme=system

Why use this? Match FinalShot's popups to your desktop theme so they look consistent with the rest of your system.

The left edge of the predefined capture region, in screen pixels from the left edge of the virtual screen.

Example:

PredefX=200

This means the capture region starts 200 pixels from the left edge of the screen.

The top edge of the predefined capture region, in screen pixels from the top edge of the virtual screen.

Example:

PredefY=150

This means the capture region starts 150 pixels from the top of the screen.

The width of the predefined capture region, in pixels. This is how many pixels wide the captured area will be.

Example:

PredefWidth=1024

This captures a region that is 1024 pixels wide.

Note: A width of 0 means the region has no area: the -ps command will capture nothing useful.

The height of the predefined capture region, in pixels. This is how many pixels tall the captured area will be.

Example:

PredefHeight=768

This captures a region that is 768 pixels tall.

Enable or disable window detection in the -cs custom selection overlay.

• 1: Enabled. When you hover over a window in the overlay, it is highlighted with a border. Click to capture that window instantly. This also detects child controls (like toolbars, sidebars, panels, buttons) inside windows, if DetectControls is also enabled.
• 0: Disabled. No window detection occurs. You can only capture by dragging a rectangle (free selection). This is useful if the detection is distracting or if you only ever need free-form selections.

Example:

DetectWindows=1

Tip: If you find that window detection is highlighting the wrong things (e.g. transparent overlays), set this to 0 to use drag-only mode.

Related: -cs command, DetectControls.

Enable or disable child control detection inside windows. Child controls are the smaller UI elements inside a window, such as:

• Toolbars and ribbon bars
• Sidebar panels
• List views and tree views
• Individual buttons or input fields
• Panels and group boxes

• 1: Enabled. The overlay highlights both windows and their child controls. You can capture a specific panel inside a window, not just the whole window.
• 0: Disabled. Only top-level windows are detected. Child controls are ignored.

Important: This setting has no effect when DetectWindows=0. Child control detection is a refinement of window detection, so the parent feature must be on.

Example:

DetectWindows=1
DetectControls=1

Practical use case: You want to capture just the navigation pane of File Explorer, not the entire window. With both settings enabled, hover over the navigation pane until it highlights, then click to capture just that pane.

Remove the rounded corners from Windows 11 window captures. Windows 11 applies rounded corners to most application windows. When this setting is enabled, FinalShot masks (removes) those rounded corner areas so the captured image has sharp, square corners instead.

• 0: Disabled. Rounded corners are captured as-is (the default behavior).
• 1: Enabled. The rounded corner pixels are removed. In PNG files, these areas become transparent. In JPEG files, they become black.

Example:

RoundWindowCorners=1

Technical detail: This uses DWM (Desktop Window Manager) corner preference detection to identify which corners are rounded. It only applies to top-level window captures, not to free-form selections or full-screen captures.

Why use this? If you are preparing screenshots for documentation or design work where consistent square corners are preferred, this setting gives you clean window captures without rounded edges.

Limitations: Only works on Windows 11. On Windows 10, windows already have square corners, so this setting has no visible effect.

The full file path where the recorded GIF will be saved. Must include the folder path, filename, and the .gif extension.

What happens if empty? All GIF recording commands are silently aborted: nothing happens when you try to start a recording. No error is shown.

Example:

GifSavePath=C:\Users\YourName\Pictures\recording.gif

Tip: If you want to record multiple GIFs without overwriting, you can use Rainmeter variables like #DATE# or #TIME# in the path to generate unique filenames.

Common mistake: Forgetting the .gif extension. The path GifSavePath=C:\recordings\mygif will not work correctly.

The frames per second (FPS) for GIF recording. This controls how many screenshots are taken each second during recording. More frames = smoother animation, but larger file size and more CPU usage.

• 1: One frame per second. Very choppy, but smallest file size. Good for time-lapse style recordings.
• 5: Five frames per second. Acceptable for slow-moving content.
• 10: Default. A good balance between smoothness and file size.
• 15: Fifteen frames per second. Smoother, but larger files.
• 30: Maximum. Very smooth, but largest files and highest CPU usage.

Values outside the range 1–30 are automatically adjusted to the nearest valid value.

Example:

GifFPS=15

Rule of thumb: For most use cases, 10 is a good default. Use 15 or higher for capturing fast-moving content (e.g. animations, gameplay). Use 5 or lower for slow-changing content (e.g. clock updates, progress bars) to keep file sizes small.

Controls the color quality of the GIF. GIF files can only use up to 256 colors, so FinalShot must reduce (quantize) the colors in each frame. Higher quality values preserve more colors and use dithering (a technique that blends colors to create the illusion of more colors).

• 85–100: 256 colors. Best visual quality. Larger files.
• 65–84: 128 colors. Good quality. Moderate file size.
• 45–64: 64 colors. Noticeable color reduction. Smaller files.
• 25–44: 32 colors. Significant color reduction. Small files.
• 0–24: 16 colors. Very limited palette. Dithering is disabled below 15. Smallest files.

Example:

; High quality for presentations
GifQuality=95

; Smaller files for web sharing
GifQuality=60

Common mistake: Confusing GifQuality with GifCompression. GifQuality controls color fidelity (how many colors are used). GifCompression controls inter-frame optimization (how frames are compressed relative to each other).

Controls the inter-frame compression level. This is an advanced optimization that reduces file size by analyzing differences between consecutive frames and encoding only the parts that change.

• 0: Minimal compression. Only exact-frame duplicates are coalesced, and a single dirty rectangle is used for each frame. Largest files.
• 50: Default. Balanced compression. Good file sizes without sacrificing visual quality.
• 100: Most aggressive compression. Smallest files, but may introduce minor visual artifacts in some cases.

What does "inter-frame compression" mean? In an animated GIF, most of the screen stays the same between frames. Instead of storing the entire image for every frame, FinalShot can store only the pixels that changed. Higher compression values make FinalShot more aggressive about finding and merging these differences, resulting in smaller files.

Example:

; Maximum compression for sharing online
GifCompression=90

; Balanced
GifCompression=50

; No compression (largest files, but cleanest encoding)
GifCompression=0

Important: This setting does not change the resolution, frame rate, or color palette of the GIF. For those, use GifFPS and GifQuality.

Controls whether FinalShot drops successive captures that look identical (still screen / mouse not moving). Dropped time is merged into the next frame’s delay so playback length stays correct, but fewer frames are stored.

• 1 (default): Skip identical captures at record time and coalesces duplicates while encoding. Smaller files.
• 0: Keep every frame at GifFPS, even when nothing on screen changes. Larger files.

Example:

; Capture every FPS tick (still screen still writes frames)
GifSkipIdenticalFrames=0

; Default — coalesce motionless periods
GifSkipIdenticalFrames=1

The maximum recording duration in seconds. When this time is reached, the recording stops automatically and the GIF is saved.

• 0: No time limit. Recording continues until you explicitly send a -gif-stop command or use the overlay's Stop button.
• Any positive number: Recording stops automatically after that many seconds.

Example:

; Record for exactly 5 seconds, then stop
GifDuration=5

; Record until manually stopped
GifDuration=0

Why use this? A duration limit is useful for automated workflows where you don't want recordings to run indefinitely. It also prevents accidentally filling up disk space with very long recordings.

Note: Paused time is not counted toward the duration. If you pause for 3 seconds during a 10-second recording, the total recording time will be 10 seconds of active recording, not 7.

The X coordinate (left edge) of the predefined GIF capture region. This is separate from the screenshot predefined region, so you can define different regions for screenshots and GIFs.

Fallback behavior: If this setting is not specified or left empty, FinalShot uses the value of PredefX instead.

Example:

; Use different regions for screenshots vs GIFs
PredefX=0
PredefY=0
PredefWidth=1920
PredefHeight=1080

GifPredefX=100
GifPredefY=100
GifPredefWidth=800
GifPredefHeight=600

Related: GifPredefY, GifPredefWidth, GifPredefHeight, -gif-start-predefined.

The Y coordinate (top edge) of the predefined GIF capture region. Falls back to PredefY if not set.

The width of the predefined GIF capture region. Falls back to PredefWidth if not set.

The height of the predefined GIF capture region. Falls back to PredefHeight if not set.

Show the recording overlay during GIF recording. The overlay is a small floating toolbar that appears on screen while recording is active. It contains three buttons:

• Stop: Stops recording and saves the GIF.
• Pause: Pauses/resumes recording.
• Abort: Cancels recording and discards all captured frames.

• 1: Show the overlay during recording.
• 0: Hide the overlay. You must use bang commands (-gif-stop, -gif-pause, -gif-cancel) to control recording.

Example:

GifShowOverlay=1

Why hide it? If you are recording a tutorial or screencast, you may not want the overlay to appear in the recording. Set this to 0 and control recording with hotkeys instead.

Show a progress window while the GIF is being encoded and written to disk after recording stops.

• 1: A small window appears showing encoding progress (e.g. "Encoding frame 45 of 120...").
• 0: No progress window is shown. Encoding happens silently in the background.

Why this exists: Encoding a GIF (especially a long recording with many frames) can take several seconds. The progress window lets you know that FinalShot is still working and hasn't frozen.

Show a dialog box when the user issues a GIF command in an invalid state. For example:

• Trying to start a recording when one is already in progress.
• Trying to stop or cancel when no recording is active.
• Trying to toggle while the GIF is being encoded.

• 1: A dialog box is shown explaining the issue.
• 0: No dialog is shown. Invalid commands are silently ignored.

Example:

GifShowStateDialogs=0

Why hide it? If you are using GIF commands in an automated workflow, you don't want dialog boxes popping up and blocking execution. Set this to 0 for silent operation.

A Rainmeter bang command to execute when GIF recording starts. This runs at the moment recording begins, before any frames are captured.

Example:

GifStartAction=[!Log "GIF recording started"]

Practical use case: Update a UI element to show a "Recording" indicator, or switch a skin to a recording-themed layout.

A Rainmeter bang command to execute when GIF recording is cancelled. Cancellation discards all captured frames and no GIF file is saved.

Example:

GifCancelAction=[!Log "GIF recording cancelled"]

A Rainmeter bang command to execute when GIF recording is paused.

Example:

GifPauseAction=[!Log "GIF recording paused"]

A Rainmeter bang command to execute when GIF recording resumes from pause.

Example:

GifResumeAction=[!Log "GIF recording resumed"]

A Rainmeter bang command to execute when GIF recording stops and a save is requested. This fires at the moment you stop recording, before encoding begins.

When does it fire?

• You send -gif-stop.
• You use a toggle command (e.g. -gif-toggle) while recording.
• The recording duration limit (GifDuration) is reached.
• You click Stop on the recording overlay.

When does it NOT fire?

• You cancel recording with -gif-cancel (use GifCancelAction instead).
• Recording hasn't started yet.

Example:

GifStopAction=[!Log "GIF recording stopped"]

Practical use case: Update a UI element to show that encoding is in progress, or switch a skin to a different layout.

Related: GifEncodingAction (fires after this), GifFinishAction (fires after encoding completes).

A Rainmeter bang command to execute when GIF encoding begins. Encoding is the process of converting the captured frames into the GIF file format. This runs after GifStopAction fires but before the GIF file is fully written to disk.

Example:

GifEncodingAction=[!Log "Encoding GIF..."]

Practical use case: Show a "Processing..." indicator or disable a button while encoding is in progress.

Event timing: The full lifecycle order is: GifStartAction fires, frames are captured, GifStopAction fires, GifEncodingAction fires, encoding completes, GIF is saved, then GifFinishAction fires. Screenshots use ScreenshotFinishAction only, not these GIF actions.

A Rainmeter bang command to execute after a GIF is successfully saved to GifSavePath. This is the last action in the GIF recording lifecycle.

When does it fire?

• After encoding completes and the GIF file is written to disk.
• After the notification is shown (if GifShowOverlay is on).

When does it NOT fire?

• If recording was cancelled (-gif-cancel).
• If encoding fails (e.g. disk full, write error).

This action is independent of ScreenshotFinishAction. Screenshots use ScreenshotFinishAction, GIFs use this.

Example:

GifFinishAction=[!Log "GIF saved"][!UpdateMeterGroup StatusGroup][!Redraw]

Practical use case: Update meters to show the new GIF file path, refresh a file list, or play a completion sound.

Related: GetSavePath() (returns the path of the just-saved GIF), GetLastFileSize() (returns the file size).

The language for OCR text recognition. This uses Windows language tags (also called BCP 47 tags). The corresponding Windows OCR language pack must be installed on your system for the language to work.

Common language tags:

• en: English (any variant)
• en-US: English (United States)
• en-GB: English (United Kingdom)
• de: German
• fr: French
• ja: Japanese
• zh-CN: Chinese (Simplified)
• ko: Korean

If the value is empty or whitespace, it falls back to en.

How to install a language pack: Go to Windows Settings → Time & Language → Language & region → Add a language. The OCR feature will use whatever language packs are installed on your system.

Example:

OcrLanguage=en-US

Important: If you set a language that doesn't have its installed language pack, OCR will fail silently or produce poor results.

The upscale factor applied to the captured image before OCR processing. Before FinalShot sends the image to the OCR engine, it can enlarge (upscale) it to improve recognition accuracy, especially for small text.

• 1: No upscaling. The image is processed at its original size.
• 2: Default. The image is doubled in size. Good for most text sizes.
• 3: Tripled. Better for very small text.
• 4: Quadrupled. Maximum upscaling. Best for tiny text, but uses more memory and processing time.

Values outside the range 1–4 are automatically adjusted.

Example:

; For capturing small UI text
OcrScaleFactor=3

When to change this: If OCR results are inaccurate for small text (e.g. status bar text, tooltips), increase the scale factor. For large text (e.g. headings, titles), the default of 2 is usually sufficient.

Controls how multiple lines of OCR text are joined together.

• 0: Lines are separated by newlines (line breaks). This preserves the original line structure of the text.
• 1: Lines are joined with spaces instead of newlines. The result is a single continuous line of text.

Example:

; Result with OcrSingleLine=0:
; Hello
; World

; Result with OcrSingleLine=1:
; Hello World

When to use 1: If you are feeding the OCR result into another program that expects single-line input (e.g. a search box, a command-line tool), set this to 1.

Controls what happens after OCR text is recognized.

• 0: Silent mode. The recognized text is immediately copied to the clipboard. No window is shown. You can access the text via the GetLastOCRText() section variable.
• 1: Edit mode. A window appears showing the recognized text in an editable text box. You can review, edit, and correct the text before copying it to the clipboard. The text is also available via GetLastOCRText() (reflecting any edits you made).

Example:

ShowOCRWindow=1

Why use edit mode? OCR is not always perfect. If you need to correct mistakes before pasting the text, the edit window saves you from having to paste into a text editor first.

Related: -ocr command, OcrLanguage, OcrScaleFactor.

A Rainmeter bang command to execute after a successful OCR operation. This runs after the text has been recognized and (if applicable) after the user closes the edit window.

Important: This does not run if the user cancels the OCR selection or if the OCR fails.

Example:

; Update a meter that displays the OCR result
OCRFinishAction=[!UpdateMeter MeterOCR][!Redraw]

Practical use case: Display the OCR result in a Rainmeter meter, or trigger a search with the recognized text.

The master switch for all global hotkeys.

• 1: Hotkeys are active. FinalShot monitors the keyboard for the configured key combinations.
• 0: All hotkeys are disabled. No keyboard monitoring occurs, even if individual Hotkey* chords are set.

Example:

HotkeysEnabled=1
HotkeyCustom=Ctrl+Shift+PrintScreen

Note: Individual hotkey chords must still be set for their respective actions. Setting HotkeysEnabled=1 alone does nothing if no Hotkey* chords are configured.

The keyboard shortcut for full-screen capture (-fs). When this key combination is pressed, FinalShot captures the entire virtual screen (all monitors).

Example:

HotkeyFullscreen=Ctrl+Shift+F

What this does: Pressing Ctrl+Shift+F anywhere on your computer will trigger a full-screen screenshot, just as if you had sent the -fs command.

The keyboard shortcut for predefined region capture (-ps). Captures the rectangle defined by PredefX, PredefY, PredefWidth, PredefHeight.

Example:

HotkeyPredefined=Ctrl+Shift+P

The keyboard shortcut for custom selection / Smart Window Snap (-cs). Opens the overlay for drag-selection or click-to-snap window capture.

Example:

HotkeyCustom=Ctrl+Shift+PrintScreen

The keyboard shortcut for storing a window handle (-wh). Opens the snap overlay (window-only mode, no free-drag). Click a window to store its handle for later capture. No image is captured at this point.

Example:

HotkeyWindowHandle=Ctrl+Shift+H

How this works: Press the hotkey, click a window to "remember" it, then later press HotkeyStoredWindow to capture that window. This is useful when you want to capture the same window repeatedly without having to find it each time.

Related: HotkeyStoredWindow, -wh, -ws|.

The keyboard shortcut for capturing the stored window (-ws| with empty title). This captures the window that was previously stored by -wh. If the stored window no longer exists (was closed), the command aborts and clears the stored handle.

Example:

HotkeyStoredWindow=Ctrl+Shift+W

Workflow: Press Ctrl+Shift+H to store a window → work on other things → press Ctrl+Shift+W to capture that stored window at any time.

The keyboard shortcut for OCR text extraction (-ocr). Opens the snap overlay for region selection, then extracts text from the selected area using Windows OCR.

Example:

HotkeyOCR=Ctrl+Shift+O

The keyboard shortcut for toggling full-screen GIF recording (-gif-toggle). Press once to start recording, press again to stop and save.

Example:

HotkeyGifToggle=Ctrl+Shift+R

The keyboard shortcut for toggling snap GIF recording (-gif-toggle-snap). Press once to open the snap overlay and start recording the selected area. Press again to stop and save.

Example:

HotkeyGifToggleSnap=Ctrl+Shift+G

Enable debug logging. When enabled, FinalShot writes detailed log messages about its internal operations to a log file. This is useful for diagnosing problems.

• 0: Debug logging is off (default).
• 1: Debug logging is on. Log messages are written to the log file.

Example:

DebugLog=1

Tip: Enable this temporarily when something isn't working as expected. Check the log file for error messages or unexpected behavior. Disable it again when you're done troubleshooting, as logging can slow things down slightly.

A custom file path for the debug log file. By default, the log is written to FinalShotDebug.log in the Rainmeter profile directory. Use this setting to write the log to a different location.

Example:

DebugLog=1
DebugLogPath=C:\Logs\FinalShot.log

Note: This setting is only relevant when DebugLog is set to 1.

Captures the entire virtual screen (all monitors combined) and saves it to the path specified in SavePath.

What happens:

1. FinalShot captures a screenshot of all your monitors as one large image.
2. The image is saved to the file at SavePath.
3. If ShowNotification is enabled, a toast notification appears.
4. If ScreenshotFinishAction is set, it runs.

Example:

[!CommandMeasure MeasureFinalShot "-fs"]

Practical example: Add this to a meter's click action to create a screenshot button:

[MeterScreenshotButton]
Meter=String
Text=Take Screenshot
LeftMouseUpAction=[!CommandMeasure MeasureFinalShot "-fs"]

Captures a fixed rectangular area defined by PredefX, PredefY, PredefWidth, PredefHeight.

What happens: Same as -fs, but only captures the specified rectangle.

Example:

[!CommandMeasure MeasureFinalShot "-ps"]

When to use: Use this when you always want to capture the same area (e.g. a specific part of your desktop, a widget, or a game window at a known position).

Opens a full-screen overlay for interactive capture. This is the most flexible capture mode.

What happens:

1. The screen dims slightly and a full-screen overlay appears.
2. Hover mode: Move your mouse over windows or controls. FinalShot detects and highlights them with a border. Click to capture the highlighted area instantly.
3. Drag mode: Click and drag to draw a rectangle over any area. Release to capture that rectangle.
4. The captured image is saved to SavePath.
5. ScreenshotFinishAction runs (if set).

Example:

[!CommandMeasure MeasureFinalShot "-cs"]

When to use: Use this when you want to choose what to capture on the fly, without pre-defining coordinates.

Behavior depends on settings:

• If DetectWindows is 1, hovering highlights windows.
• If DetectControls is 1, hovering also highlights child controls inside windows.
• If both are 0, only drag-selection is available.

Press Escape to cancel without capturing anything.

Opens the Smart Window Snap overlay (window-only mode) to select and store a window for later capture. This does not capture any image. It only "remembers" which window you clicked.

What happens:

1. The snap overlay appears (same as -cs, but without drag-selection).
2. Click a window to store its handle (internal reference).
3. The window's title is stored and can be read via GetLastStoredWindow().

Example:

[!CommandMeasure MeasureFinalShot "-wh"]

Why use this? If you want to capture the same window repeatedly (e.g. every time you click a button), use -wh to store the window once, then use -ws| to capture it later. This is faster than manually finding the window each time.

Related: -ws|, GetLastStoredWindow().

Captures a specific window by its exact title. The pipe character | separates the command from the window title.

Syntax:

-ws|Window Title Here

What happens:

1. FinalShot searches for a window whose title matches the string after |.
2. If found, it captures that window.
3. If UsePrintWindow is 1, only the target window is captured (no overlapping content).

Example: capture a specific window:

[!CommandMeasure MeasureFinalShot "-ws|Calculator"]

Special case: capture the stored window:

; Use -ws| with nothing after the pipe to capture the stored window
[!CommandMeasure MeasureFinalShot "-ws|"]

When the title is empty (-ws|), FinalShot captures the window previously stored by -wh. If the stored window no longer exists, the command fails and the stored handle is cleared.

Important: The window title must be an exact match. Partial matches will not work. Use GetLastStoredWindow() to see the exact title of a stored window.

Common mistake: Forgetting the pipe character. -wsCalculator will not work. It must be -ws|Calculator.

Opens the last successfully saved screenshot in the default app. The path is read at click/command time (not when the measure reloads), so it always targets the newest file.

Example (recommended for toast clicks):

NotificationClickAction=[!CommandMeasure Measure_FinalShot "-open-last-screenshot"]

Related: NotificationClickAction, GetLastScreenshotPath().

Opens the last successfully saved GIF in the default app. Same click-time resolution as -open-last-screenshot.

Example:

NotificationClickAction=[!CommandMeasure Measure_FinalShot "-open-last-gif"]

Related: NotificationClickAction, GetSavePath().

Opens the snap overlay for region selection, then uses Windows OCR to extract text from the selected area.

What happens:

1. The snap overlay appears.
2. Select a region by hovering (click to snap) or dragging.
3. FinalShot captures the selected area as an image.
4. The image is sent to the Windows OCR engine, which reads the text.
5. The recognized text is copied to the clipboard.
6. If ShowOCRWindow is 1, an edit window appears so you can review and modify the text.
7. The text is also available via GetLastOCRText().
8. If OCRFinishAction is set, it runs.

Example:

[!CommandMeasure MeasureFinalShot "-ocr"]

Prerequisites:

• OcrLanguage must be set to a valid language tag.
• The corresponding Windows OCR language pack must be installed.

Related: OCR Settings, GetLastOCRText().

Starts recording a full-screen animated GIF. Every frame captures the entire virtual screen (all monitors).

What happens:

• If already recording: nothing happens (or a state dialog is shown if GifShowStateDialogs is 1).
• If idle: recording begins. The overlay appears (if GifShowOverlay is 1). GifStartAction fires.

Requirement: GifSavePath must be set.

Example:

[!CommandMeasure MeasureFinalShot "-gif-start"]

Opens the snap overlay for region selection, then starts recording a GIF of the selected area.

What happens:

1. The snap overlay appears.
2. Select a region by hovering (click to snap) or dragging.
3. Recording begins for the selected area only.

Example:

[!CommandMeasure MeasureFinalShot "-gif-start-snap"]

Starts recording a GIF of the predefined region defined by GifPredefX, GifPredefY, GifPredefWidth, GifPredefHeight.

Example:

[!CommandMeasure MeasureFinalShot "-gif-start-predefined"]

Starts recording a GIF of a specific window by its exact title. The pipe | separates the command from the window title.

Example:

[!CommandMeasure MeasureFinalShot "-gif-start-window|Calculator"]

Note: The recording will track the window even if it moves, but it will stop if the window is closed.

Stops the current GIF recording and encodes all captured frames into a GIF file, saving it to GifSavePath.

What happens:

• If not recording: nothing happens (or a state dialog is shown).
• If recording: recording stops. GifStopAction fires, then GifEncodingAction. The encoding progress window appears (if GifShowEncodingWindow is 1). The GIF file is written to disk. Then GifFinishAction fires (if set).

Example:

[!CommandMeasure MeasureFinalShot "-gif-stop"]

Cancels the current GIF recording. All captured frames are discarded and no GIF file is saved.

What happens:

• If not recording: nothing happens (or a state dialog is shown).
• If recording: recording stops immediately. GifCancelAction fires. No file is written.

Example:

[!CommandMeasure MeasureFinalShot "-gif-cancel"]

When to use: Use this if you started recording by mistake and don't want to save anything.

Toggles the pause state of the current GIF recording. This is a toggle: the first call pauses, the second resumes.

What happens:

• If not recording: nothing happens (or a state dialog is shown).
• If recording and not paused: recording pauses. GifPauseAction fires. No frames are captured while paused.
• If recording and paused: recording resumes. GifResumeAction fires.

Important: Paused time is excluded from the recording duration. If you pause for 3 seconds during a 10-second recording, the total active recording time will be 10 seconds.

Example:

[!CommandMeasure MeasureFinalShot "-gif-pause"]

Toggles full-screen GIF recording. This is a convenience command that combines start and stop into one action.

• If idle: starts full-screen recording (like -gif-start).
• If recording: stops and saves (like -gif-stop).
• If encoding: ignored (or a state dialog is shown).

Example:

[!CommandMeasure MeasureFinalShot "-gif-toggle"]

Why use toggle? It's perfect for a single button that starts and stops recording. You don't need two separate buttons.

Toggles snap-based GIF recording.

• If idle: opens the snap overlay for region selection, then starts recording.
• If recording: stops and saves.
• If encoding: ignored (or a state dialog is shown).

Example:

[!CommandMeasure MeasureFinalShot "-gif-toggle-snap"]

Toggles predefined region GIF recording.

• If idle: starts recording the predefined region.
• If recording: stops and saves.

Example:

[!CommandMeasure MeasureFinalShot "-gif-toggle-predefined"]

Toggles GIF recording of a specific window by title.

• If idle: starts recording the specified window.
• If recording: stops and saves.

Example:

[!CommandMeasure MeasureFinalShot "-gif-toggle-window|Calculator"]

Returns the current recording state as a numeric code:

• 1 = Idle: Not recording, not encoding.
• 2 = Recording: Actively capturing frames.
• 3 = Encoding: Recording is done, GIF is being encoded and saved.

Example:

[&MeasureFinalShot:GetStatus()]
; Returns: "1", "2", or "3"

Practical use: Use this to show a status indicator in your skin.

[MeterStatus]
Meter=String
Text=[&MeasureFinalShot:GetStatus()]
DynamicVariables=1

Returns whether GIF recording is currently active.

• 1: Yes, recording is in progress.
• -1: No, not recording.

Example:

[&MeasureFinalShot:IsRecording()]
; Returns: "1" if recording, "-1" otherwise

Practical use: Show or hide a "Recording" indicator based on the result.

[MeterRecordingDot]
Meter=String
Text=● REC
Hidden=([&MeasureFinalShot:IsRecording()] = -1 ? 1 : 0)
DynamicVariables=1

Returns whether the GIF is currently being encoded (after recording stops, before the file is saved).

• 1: Yes, encoding is in progress.
• -1: No, not encoding.

Example:

[&MeasureFinalShot:IsEncoding()]
; Returns: "1" if encoding, "-1" otherwise

Returns whether FinalShot is idle (not recording and not encoding).

• 1: Yes, idle.
• -1: No, busy (recording or encoding).

Example:

[&MeasureFinalShot:IsIdle()]
; Returns: "1" if idle, "-1" otherwise

Returns whether the recording is currently paused.

• 1: Yes, recording is paused.
• -1: No, not paused (or not recording at all).

Example:

[&MeasureFinalShot:IsPaused()]
; Returns: "1" if paused, "-1" otherwise

Returns the number of frames captured so far in the current recording.

• During recording: the count increases as frames are captured (e.g. "42").
• When not recording: returns "0".

Example:

[&MeasureFinalShot:GetFrameCount()]
; Returns: "0", "1", "15", "120", etc.

Practical use: Show a live frame counter in your skin while recording.

[MeterFrameCount]
Meter=String
Text=Frames: [&MeasureFinalShot:GetFrameCount()]
DynamicVariables=1

Returns the elapsed recording time as a formatted string in MM:SS format (minutes and seconds). Paused time is excluded.

• During recording: e.g. "00:15" (15 seconds), "01:30" (1 minute 30 seconds).
• When not recording: returns "00:00".

Example:

[&MeasureFinalShot:GetElapsedTime()]
; Returns: "00:15" after 15 seconds of recording

Practical use: Display a recording timer in your skin.

[MeterTimer]
Meter=String
Text=[&MeasureFinalShot:GetElapsedTime()]
FontSize=20
DynamicVariables=1

Returns the elapsed recording time in whole seconds (no formatting). Paused time is excluded.

• During recording: e.g. "15", "90".
• When not recording: returns "0".

Example:

[&MeasureFinalShot:GetElapsedSeconds()]
; Returns: "90" after 1 minute 30 seconds of recording

When to use this vs. GetElapsedTime(): Use GetElapsedSeconds() when you need a raw number for calculations (e.g. comparing against GifDuration). Use GetElapsedTime() for display purposes.

Returns the full file path of the last successfully saved GIF file.

• After a GIF is saved: returns the path, e.g. "C:\Users\You\Pictures\recording.gif".
• If no GIF has been saved yet this session: returns "" (empty string).

Example:

[&MeasureFinalShot:GetSavePath()]
; Returns: "C:\Users\You\Pictures\recording.gif"

Practical use: Open the saved GIF after recording stops.

; In GifEncodingAction or a separate meter
Text=Last saved: [&MeasureFinalShot:GetSavePath()]
DynamicVariables=1

Returns the full path of the last successfully saved screenshot this session, or "" if none. Use for meters/display, or in NotificationClickAction as ["[&Measure_FinalShot:GetLastScreenshotPath()]"].

Text=[&Measure_FinalShot:GetLastScreenshotPath()]
DynamicVariables=1

Returns the file size of the last saved GIF as a human-readable string.

• After a GIF is saved: e.g. "2.4 MB", "512.0 KB", "980 B", "1.2 GB".
• If no GIF has been saved yet: returns "" (empty string).

Size format: Values are automatically formatted with appropriate units: B (bytes), KB (kilobytes), MB (megabytes), or GB (gigabytes).

Example:

[&MeasureFinalShot:GetLastFileSize()]
; Returns: "2.4 MB"

Returns the last OCR result text.

• After a successful OCR operation: returns the recognized text.
• If ShowOCRWindow was 1: returns whatever text is in the edit window (including any edits the user made).
• If no OCR has been performed, or if the last OCR was cancelled or failed: returns "" (empty string).

Example:

[&MeasureFinalShot:GetLastOCRText()]
; Returns: "Hello, this is the recognized text."

Practical use: Display the OCR result in a meter, or use it in another skin.

[MeterOCRResult]
Meter=String
Text=[&MeasureFinalShot:GetLastOCRText()]
DynamicVariables=1

Returns the title of the window that was stored by the -wh command.

• After storing a window: returns the window title, e.g. "Calculator".
• If no window has been stored, or if the store was cleared (e.g. after an invalid -ws| attempt): returns "" (empty string).

Example:

[&MeasureFinalShot:GetLastStoredWindow()]
; Returns: "Calculator"

Practical use: Show which window is currently stored in your skin.

[MeterStoredWindow]
Meter=String
Text=Stored window: [&MeasureFinalShot:GetLastStoredWindow()]
DynamicVariables=1