Calculate the size of windows tiling

Calculating Window Tiling Dimensions for AutoIt

Learn how to precisely calculate the size and position of windows for effective tiling, especially useful for scripting with AutoIt.

Efficient window management often involves tiling windows to specific positions and sizes on the screen. Whether you're automating tasks, creating custom layouts, or developing utility scripts, understanding how to calculate these dimensions is crucial. This article will guide you through the mathematical principles and practical considerations for calculating window tiling, with a focus on applications like AutoIt scripting.

Understanding Screen Coordinates and Window Dimensions

Before diving into calculations, it's important to grasp the coordinate system used by most operating systems. The top-left corner of the primary monitor is typically (0,0). The X-axis increases to the right, and the Y-axis increases downwards. Window dimensions are usually defined by their top-left corner (X, Y) and their width and height. When tiling, you'll be manipulating these four values.

flowchart TD
    A["Get Screen Resolution (e.g., @DesktopWidth, @DesktopHeight)"] --> B["Determine Number of Tiles (Rows x Columns)"]
    B --> C["Calculate Tile Width = ScreenWidth / Columns"]
    B --> D["Calculate Tile Height = ScreenHeight / Rows"]
    C --> E["Calculate X Position = ColumnIndex * TileWidth"]
    D --> F["Calculate Y Position = RowIndex * TileHeight"]
    E & F --> G["Apply to Window (e.g., WinMove in AutoIt)"]

Basic workflow for calculating window tile dimensions

Calculating Dimensions for a Grid Layout

The most common tiling scenario involves arranging windows in a grid. To do this, you need to know the total screen resolution and the desired number of rows and columns. Let's assume you want to tile N windows in R rows and C columns. The basic formulas are straightforward:

ScreenWidth = @DesktopWidth
ScreenHeight = @DesktopHeight

DesiredColumns = 2
DesiredRows = 2

TileWidth = ScreenWidth / DesiredColumns
TileHeight = ScreenHeight / DesiredRows

For a window at (ColumnIndex, RowIndex):
WindowX = ColumnIndex * TileWidth
WindowY = RowIndex * TileHeight
WindowWidth = TileWidth
WindowHeight = TileHeight

General formulas for grid-based window tiling

Handling Taskbars and Multi-Monitor Setups

The calculations above assume the entire screen is available. However, the Windows taskbar often occupies space, and multi-monitor setups introduce additional complexity.

For single-monitor setups with a taskbar, you should use the work area dimensions instead of the full desktop dimensions. AutoIt provides @DesktopWorkWidth and @DesktopWorkHeight for this purpose. These variables exclude the taskbar and any docked toolbars.

For multi-monitor setups, each monitor has its own coordinate system relative to the primary monitor. AutoIt's SysGet(16) function can retrieve an array of monitor information, including their coordinates and dimensions. You'll need to iterate through these to determine the correct target monitor and its work area.

; Get screen work area dimensions (excludes taskbar)
Local $iWorkWidth = @DesktopWorkWidth
Local $iWorkHeight = @DesktopWorkHeight

; Example: Tile a window to the top-left quarter of the work area
Local $iDesiredColumns = 2
Local $iDesiredRows = 2

Local $iTileWidth = $iWorkWidth / $iDesiredColumns
Local $iTileHeight = $iWorkHeight / $iDesiredRows

Local $iColumnIndex = 0 ; First column
Local $iRowIndex = 0    ; First row

Local $iWindowX = $iColumnIndex * $iTileWidth
Local $iWindowY = $iRowIndex * $iTileHeight

; Replace 'Untitled' with the actual window title or handle
WinMove("Untitled", "", $iWindowX, $iWindowY, $iTileWidth, $iTileHeight)

MsgBox(0, "Window Tiled", "Window moved to X:" & $iWindowX & ", Y:" & $iWindowY & ", Width:" & $iTileWidth & ", Height:" & $iTileHeight)

AutoIt example for tiling a window to the top-left quarter of the work area

Advanced Tiling: Gaps and Offsets

Sometimes you might want to introduce small gaps between tiled windows or apply an overall offset from the screen edges. This requires minor adjustments to the basic formulas.

To add a gap, you'll need to subtract the total gap space from the available width/height before dividing, and then add half the gap to the position. For example, for a horizontal gap G between C columns:

EffectiveTileWidth = (ScreenWidth - (G * (C - 1))) / C WindowX = ColumnIndex * (EffectiveTileWidth + G)

Similar logic applies to vertical gaps. Offsets are simpler: just add the desired offset to the final WindowX and WindowY values, and subtract twice the offset from the WindowWidth and WindowHeight.

1. Determine Screen/Work Area Dimensions

Use @DesktopWidth, @DesktopHeight, @DesktopWorkWidth, or @DesktopWorkHeight in AutoIt to get the available screen real estate. For multi-monitor setups, use SysGet(16) to get individual monitor details.

2. Define Tiling Grid

Decide on the number of rows and columns you want for your tiled layout. This will dictate how the screen space is divided.

3. Calculate Base Tile Dimensions

Divide the available width by the number of columns and the available height by the number of rows to get the base TileWidth and TileHeight.

4. Apply Gaps and Offsets (Optional)

If desired, adjust TileWidth, TileHeight, and the WindowX/WindowY calculations to account for gaps between windows or offsets from screen edges.

5. Calculate Individual Window Positions and Sizes

For each window, determine its ColumnIndex and RowIndex. Then, calculate its WindowX, WindowY, WindowWidth, and WindowHeight using the adjusted formulas.

6. Move the Window

Use WinMove("Window Title", "", WindowX, WindowY, WindowWidth, WindowHeight) in AutoIt to position and resize the target window.