Twinkle Tray

https://github.com/xanderfrangos/twinkle-tray
Admin
Twinkle Tray enables brightness control on external displays in Windows 10 & 11, providing instant...
Tokens:12,753
Snippets:118
Trust Score:9.1
License:MIT
Update:7 months ago
Show doc for...
Tokens:
Raw
### Get Active Window Information (C++ Example)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Demonstrates how to get information about the currently active window, including its title, application, executable path, PID, and icon. This example requires linking against specific frameworks and using C++17.

```c++
#include <iostream>
#include "ActiveWindow.h"

using namespace std;
using namespace PaymoActiveWindow;

int main() {
	ActiveWindow* activeWindow = new ActiveWindow();

	WindowInfo* windowInfo = activeWindow->getActiveWindow();

	if (windowInfo == NULL) {
		cout<<"Could not get active window\n";
	}
	else {
		cout<<"Title: "<<windowInfo->title<<"\n";
		cout<<"Application: "<<windowInfo->application<<"\n";
		cout<<"Executable path: "<<windowInfo->path<<"\n";
		cout<<"PID: "<<windowInfo->pid<<"\n";
		cout<<"Icon: "<<windowInfo->icon<<"\n";
	}

	delete windowInfo;
	delete activeWindow;

	return 0;
}
```

--------------------------------

### ActiveWindow Class Integration Example

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

A complete implementation example demonstrating how to instantiate the ActiveWindow class, retrieve window information, and handle memory cleanup.

```C++
#include <iostream>
#include "ActiveWindow.h"

using namespace std;
using namespace PaymoActiveWindow;

int main() {
	ActiveWindow* activeWindow = new ActiveWindow(10);

	WindowInfo* windowInfo = activeWindow->getActiveWindow();

	if (windowInfo == NULL) {
		cout<<"Could not get active window\n";
	}
	else {
		cout<<"Title: "<<windowInfo->title<<"\n";
		cout<<"Application: "<<windowInfo->application<<"\n";
		cout<<"Executable path: "<<windowInfo->path<<"\n";
		cout<<"PID: "<<windowInfo->pid<<"\n";
		cout<<"Icon: "<<windowInfo->icon<<"\n";
	}

	delete windowInfo;
	delete activeWindow;

	return 0;
}
```

--------------------------------

### Usage Example: Control Monitor Brightness

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-ddcci/README.md

Demonstrates how to use the node-ddcci package to get a list of connected monitors, retrieve their current brightness, and set a new brightness level. It iterates through all monitors and sets their brightness to 25.

```javascript
const ddcci = require("@hensm/ddcci");

for (const monitor of ddcci.getMonitorList()) {
    console.log(`${monitor} current brightness: ${ddcci.getBrightness(monitor)}`);
    ddcci.setBrightness(monitor, 25);
}
```

--------------------------------

### Get Active Window Information with TypeScript

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Example demonstrating how to initialize the ActiveWindow library, request necessary permissions, and retrieve details of the currently active window using TypeScript. It logs the window title, application name, path, PID, and icon.

```typescript
import ActiveWindow from '@paymoapp/active-window';

ActiveWindow.initialize();

if (!ActiveWindow.requestPermissions()) {
	console.log('Error: You need to grant screen recording permission in System Preferences > Security & Privacy > Privacy > Screen Recording');
	process.exit(0);
}

const activeWin = ActiveWindow.getActiveWindow();

console.log('Window title:', activeWin.title);
console.log('Application:', activeWin.application);
console.log('Application path:', activeWin.path);
console.log('Application PID:', activeWin.pid);
console.log('Application icon:', activeWin.icon);
```

--------------------------------

### Environment Setup for Windows Build

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Configures the build environment using the Visual Studio vcvarsall.bat script to enable access to compiler and linker tools.

```batch
"C:\Program Files (x86)\Microsoft Visual Studio\2019\BuildTools\VC\Auxiliary\Build\vcvarsall.bat" x64
```

--------------------------------

### Time of Day Brightness Adjustments Configuration - JSON

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Example JSON configuration for setting automatic brightness adjustments based on time of day, including options for individual displays, animation, and sun-based calculations.

```json
{
  "adjustmentTimes": [
    {
      "time": "07:00",
      "brightness": 80,
      "monitors": {
        "\\?\DISPLAY#DELA0EC#serial123": 80,
        "\\?\DISPLAY#GSM7707#serial456": 70
      },
      "useSunCalc": false
    },
    {
      "time": "22:00",
      "brightness": 30,
      "monitors": {},
      "useSunCalc": false
    },
    {
      "useSunCalc": true,
      "sunCalc": "sunset",
      "brightness": 40,
      "monitors": {}
    }
  ],
  "adjustmentTimeIndividualDisplays": true,
  "adjustmentTimeSpeed": "normal",
  "adjustmentTimeAnimate": false,
  "adjustmentTimeLatitude": 40.7128,
  "adjustmentTimeLongitude": -74.0060
}
```

--------------------------------

### Custom DDC/CI VCP Codes Configuration - JSON

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Example JSON configuration to override default DDC/CI VCP codes for specific monitors, such as brightness.

```json
{
  "userDDCBrightnessVCPs": {
    "GSM7707": "0x13",
    "DELA0EC": 16
  }
}
```

--------------------------------

### Install @paymoapp/active-window NPM Package

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Install the @paymoapp/active-window package using npm. This package provides the core functionality for accessing active window information.

```bash
npm install --save @paymoapp/active-window
```

--------------------------------

### Install node-ddcci Package

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-ddcci/README.md

Installs the node-ddcci package using npm. This package is specifically for Windows operating systems.

```bash
npm install @hensm/ddcci
```

--------------------------------

### Request Screen Capture Access (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Requests permission to capture the screen. This function is non-blocking and returns the current status. A system popup guides the user to grant permission on the first call. Relaunching the application is required after granting permission.

```c++
bool requestScreenCaptureAccess();
```

--------------------------------

### GET getActiveWindow

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Retrieves the metadata of the currently active foreground window synchronously.

```APIDOC
## GET getActiveWindow

### Description
Requests the current foreground window in a synchronous way. Returns a WindowInfo object containing details about the active application.

### Method
Synchronous Function Call

### Parameters
None

### Response
#### Success Response (Object)
- **title** (string) - The title of the current window
- **application** (string) - The name of the application
- **path** (string) - The path to the application's executable
- **pid** (number) - Process identifier of the application
- **icon** (string) - Base64 encoded string representing the application icon
- **windows** (object) - Platform specific info (Windows only)

### Response Example
{
	"title": "Visual Studio Code",
	"application": "Code.exe",
	"path": "C:\\Program Files\\Microsoft VS Code\\Code.exe",
	"pid": 1234,
	"icon": "data:image/png;base64,iVBORw0KGgoAAA...",
	"windows": {
		"isUWPApp": false,
		"uwpPackage": ""
	}
}
```

--------------------------------

### Manage Window Monitoring

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Functions to register and unregister callbacks for tracking active window changes. The watchActiveWindow function starts a background thread, requiring thread-safe implementations for callbacks.

```C++
watch_t watchActiveWindow(watch_callback cb);
void unwatchActiveWindow(watch_t watch);
```

--------------------------------

### Configure UDP Server Settings

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

The UDP server is configured via the settings.json file. This enables remote control functionality and requires a secret key for authentication.

```json
{
  "udpEnabled": true,
  "udpRemote": false,
  "udpPortStart": 14715,
  "udpKey": "your-secret-key-here"
}
```

--------------------------------

### Manage Monitors via CLI

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

The Twinkle Tray CLI allows for listing, setting, and adjusting monitor brightness and VCP features. Commands support targeting specific monitors by index or hardware ID, as well as applying global changes.

```bash
# List all connected displays
"Twinkle Tray.exe" --List

# Set monitor 1 to 80% brightness
"Twinkle Tray.exe" --MonitorNum=1 --Set=80

# Decrease brightness by 20% on monitor 1
"Twinkle Tray.exe" --MonitorNum=1 --Offset=-20

# Set brightness on monitor with ID containing "DELA0EC"
"Twinkle Tray.exe" --MonitorID="DELA0EC" --Set=60

# Set power state (0xD6) to standby (value 5)
"Twinkle Tray.exe" --MonitorNum=1 --VCP="0xD6:5"
```

--------------------------------

### Enable Advanced DDC/CI Monitor Features

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Configures custom DDC/CI feature codes for specific monitors. Allows mapping of VCP codes to UI elements and defining operational ranges.

```json
{
  "monitorFeatures": {
    "DELA0EC": { "0x12": true, "0x62": true }
  }
}
```

--------------------------------

### Initialize Application Cache

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Scans system directories for .desktop files to resolve application icons. This must be called to enable icon resolution functionality.

```C++
void buildAppCache();
```

--------------------------------

### Query Low-Level Display Device Info with Node.js

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

Demonstrates how to query low-level display device configuration using the `win32-displayconfig` module. It retrieves `pathArray`, `modeArray`, and `nameArray` which contain raw Win32 API structs and parsed information about display devices. This is useful for detailed inspection but `extractDisplayConfig` is recommended for general use.

```javascript
const w32disp = require("win32-displayconfig");
const util = require("util");

w32disp.queryDisplayConfig().then((config) => {
  // The outputs of `pathArray` and `modeArray` refer to
  // both parsed values and raw buffer values. The raw buffers
  // are the exact structs returned by the Win32 API, and are
  // used to save and restore display positioning configuration.
  const pathArray = config.pathArray.map((pa) => pa.value);
  const modeArray = config.modeArray.map((ma) => ma.value);
  console.log(
    util.inspect(
      // However, the `nameArray` only refers to parsed values.
      { pathArray, modeArray, nameArray: config.nameArray },
      { depth: 10 }
    )
  );
});

```

--------------------------------

### Configure Hotkeys for Brightness Control

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Defines custom keyboard shortcuts to adjust brightness levels or cycle through presets. The configuration uses an array of objects specifying the accelerator key and the corresponding action type.

```json
{
  "hotkeys": [
    {
      "id": "uuid-string-here",
      "accelerator": "CommandOrControl+Alt+Up",
      "actions": [
        { "type": "offset", "target": "brightness", "value": 10, "allMonitors": true, "monitors": {} }
      ]
    }
  ]
}
```

--------------------------------

### Control Brightness via PowerShell UDP

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Sends commands to the Twinkle Tray UDP server to adjust monitor brightness or power states. Requires a secret key for authentication.

```powershell
$udpClient = New-Object System.Net.Sockets.UdpClient
$udpClient.Connect("localhost", 14715)
$command = @{ type = "set"; key = "your-secret-key-here"; monitor = "all"; vcp = "brightness"; value = 75 } | ConvertTo-Json
$bytes = [System.Text.Encoding]::ASCII.GetBytes($command)
$udpClient.Send($bytes, $bytes.Length)
$udpClient.Close()
```

--------------------------------

### Configure Idle Detection and Dimming

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Settings for automatic display dimming based on system idle time. Includes options to ignore fullscreen applications or media playback.

```json
{
  "detectIdleTimeEnabled": true,
  "detectIdleTimeMinutes": 5,
  "detectIdleCheckFullscreen": true,
  "idleRestoreSeconds": 4
}
```

--------------------------------

### Interact with Monitors via UDP API

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Use Node.js dgram to send JSON-formatted commands to the Twinkle Tray UDP server. This allows for listing monitors and querying specific properties like brightness or contrast.

```javascript
const dgram = require('dgram');
const client = dgram.createSocket('udp4');

// Request list of monitors
const listCommand = JSON.stringify({ type: "list", key: "your-secret-key-here" });
client.send(listCommand, 14715, "localhost");

// Get brightness of a specific monitor
const getCommand = JSON.stringify({
  type: "get",
  key: "your-secret-key-here",
  monitor: "DELA0EC",
  property: "brightness"
});
client.send(getCommand, 14715, "localhost");
```

--------------------------------

### Saving and Restoring Display Layouts

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

This section describes how to save the current display device layout to a profile and restore a previously saved layout. This can be used to implement display configuration profiles.

```APIDOC
## POST /displayconfig/save

### Description
Saves the current display device layout to a JSON-serializable object.

### Method
POST

### Endpoint
`/displayconfig/save`

### Parameters
None

### Request Example
```
POST /displayconfig/save
```

### Response
#### Success Response (200)
- **configuration** (object) - A JSON-safe object representing the current display configuration.

#### Response Example
```json
{
  "configuration": {
    "version": 1,
    "primary": {"id": "\\\\?\\DISPLAY\\DOML\\0000", "width": 1920, "height": 1080, "frequency": 60},
    "secondary": [
      {"id": "\\\\?\\DISPLAY\\DOML\\0001", "width": 1920, "height": 1080, "frequency": 60, "top": 0, "left": 1920}
    ]
  }
}
```
```

```APIDOC
## POST /displayconfig/restore

### Description
Restores a previously saved display device layout. If `persistent` is true, the configuration is saved as the default Windows display configuration.

### Method
POST

### Endpoint
`/displayconfig/restore`

### Parameters
#### Request Body
- **serializedConfiguration** (string) - Required - A JSON string representing the display configuration to restore.
- **persistent** (boolean) - Optional - If true, the restored configuration will be set as the default Windows display configuration.

### Request Example
```json
{
  "serializedConfiguration": "{\"version\": 1, \"primary\": {\"id\": \\\\.\\\\DISPLAY\\DOML\\0000\", \"width\": 1920, \"height\": 1080, \"frequency\": 60}, \"secondary\": []}",
  "persistent": false
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating the configuration was restored.

#### Response Example
```json
{
  "message": "Display configuration restored successfully."
}
```

### Notes
- The function attempts to enable all present and enabled displays from the configuration and disable others. If displays in the configuration are not present, it makes a best effort to apply the configuration to available displays.
```

--------------------------------

### Saving and Restoring Display Layout Profiles

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

Provides functions to capture the current display configuration into a JSON-serializable format and restore it later. The restoration process supports persistent application of settings to the Windows display configuration.

```javascript
const w32disp = require("win32-displayconfig");

async function saveDisplayConfig() {
  const conf = await w32disp.displayConfigForRestoration();
  return JSON.stringify(conf);
}

async function restoreDisplayConfig(serialized, persistent) {
  persistent = !!persistent;
  const conf = JSON.parse(serialized);
  await w32disp.restoreDisplayConfig(conf);
}
```

--------------------------------

### Define Application-Specific Brightness Profiles

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Sets automatic brightness levels triggered when specific applications are active. Profiles map executable names to monitor-specific brightness values.

```json
{
  "profiles": [
    {
      "name": "Gaming Profile",
      "path": "game.exe,steam.exe",
      "setBrightness": true,
      "monitors": { "\\?\\DISPLAY#DELA0EC#serial123": 100 }
    }
  ]
}
```

--------------------------------

### Set Brightness via Named Pipe - JavaScript

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Control monitor brightness through the named pipe without needing a UDP key. Requires the 'net' module.

```javascript
const net = require('net');
const client = net.connect('\\.\pipe\twinkle-tray\cmds');

// Set brightness on specific monitor
const command = JSON.stringify({
  type: "set",
  monitor: "DELA0EC",
  vcp: "brightness",
  value: 75
});

client.write(command);

client.on('data', (data) => {
  console.log('Response:', data.toString());
  client.end();
});
```

--------------------------------

### Connect to Named Pipe - JavaScript

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Establish a connection to the Twinkle Tray named pipe for local inter-process communication without authentication. Requires the 'net' module.

```javascript
const net = require('net');

const client = net.connect('\\.\pipe\twinkle-tray\cmds');

// List all monitors
client.write(JSON.stringify({ type: "list" }));

client.on('data', (data) => {
  const monitors = JSON.parse(data.toString());
  console.log(monitors);
  client.end();
});

client.on('error', (err) => {
  console.error('Connection error:', err);
});
```

--------------------------------

### Initialize Active Window Library (TypeScript)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Initializes the library, which is necessary on platforms like Linux. It can optionally configure the OS X run loop for subscriptions in GUI-less applications.

```typescript
interface IActiveWindow {
	initialize(opts?: { osxRunLoop: boolean }): void;
	// ...
}
```

--------------------------------

### Request Screen Recording Permissions (TypeScript)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Requests screen recording permissions on macOS, which is required to fetch window titles. Returns a boolean indicating permission status and prompts the user if necessary. Relaunch is required after granting permissions.

```typescript
interface IActiveWindow {
	requestPermissions(): boolean;
	// ...
}
```

--------------------------------

### Send VCP Commands via UDP - JavaScript

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Control various DDC/CI features like contrast, volume, and power state using UDP commands. Supports setting specific VCP codes or raw decimal values. Requires the 'dgram' module.

```javascript
const dgram = require('dgram');
const client = dgram.createSocket('udp4');

// Set contrast to 70
const contrastCommand = JSON.stringify({
  type: "setvcp",
  key: "your-secret-key-here",
  monitor: "DELA0EC",
  vcp: "contrast",
  value: 70
});

// Set volume to 30
const volumeCommand = JSON.stringify({
  type: "setvcp",
  key: "your-secret-key-here",
  monitor: "DELA0EC",
  vcp: "volume",
  value: 30
});

// Set power state (5 = standby, 4 = suspend, 1 = on)
const powerCommand = JSON.stringify({
  type: "setvcp",
  key: "your-secret-key-here",
  monitor: "DELA0EC",
  vcp: "power",
  value: 5
});

// Send raw VCP code (decimal)
const rawVcpCommand = JSON.stringify({
  type: "setvcp",
  key: "your-secret-key-here",
  monitor: "DELA0EC",
  vcp: 16,  // 0x10 = luminance
  value: 50
});

client.send(contrastCommand, 14715, "localhost");
```

--------------------------------

### Monitor Display Configuration Changes

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

Demonstrates how to register and remove event listeners to track changes in display geometry. The addDisplayChangeListener function triggers a callback whenever the display configuration is updated.

```javascript
const w32disp = require("win32-displayconfig");
const listener1 = (err, conf) => {
  if (err !== null) {
    console.error(err);
  } else {
    // Handle configuration change
  }
};
w32disp.addDisplayChangeListener(listener1);

// Removing listeners to allow clean process exit
w32disp.removeDisplayChangeListener(listener1);
```

--------------------------------

### ActiveWindow Constructor (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Constructor for the ActiveWindow class. Optionally initializes an LRU cache for icons to reduce CPU usage. The cache size impacts memory consumption and CPU utilization.

```c++
ActiveWindow(unsigned int iconCacheSize = 0);

```

--------------------------------

### Trigger Refresh and Time Adjustments via UDP - JavaScript

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Force a monitor refresh or trigger time-based brightness settings using UDP commands. Requires the 'dgram' module.

```javascript
const dgram = require('dgram');
const client = dgram.createSocket('udp4');

// Force refresh all monitors
const refreshCommand = JSON.stringify({
  type: "refresh",
  key: "your-secret-key-here"
});

// Apply time of day adjustments
const timeCommand = JSON.stringify({
  type: "checktime",
  key: "your-secret-key-here"
});

client.send(refreshCommand, 14715, "localhost");
```

--------------------------------

### Set Brightness via UDP - JavaScript

Source: https://context7.com/xanderfrangos/twinkle-tray/llms.txt

Control monitor brightness using UDP commands. Supports setting absolute brightness or applying an offset to all monitors. Requires the 'dgram' module.

```javascript
const dgram = require('dgram');
const client = dgram.createSocket('udp4');

// Set absolute brightness
const setCommand = JSON.stringify({
  type: "set",
  key: "your-secret-key-here",
  monitor: "DELA0EC",
  vcp: "brightness",
  value: 80
});

// Set brightness on all monitors with offset
const offsetCommand = JSON.stringify({
  type: "set",
  key: "your-secret-key-here",
  monitor: "all",
  vcp: "brightness",
  value: -10,
  mode: "offset"
});

client.send(setCommand, 14715, "localhost");
```

--------------------------------

### Watch Active Window Changes (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Sets up a callback to be triggered when the active window changes. The callback receives the current active window information. Requires a running NSRunLoop on the main thread and should not perform blocking operations in the callback. The returned watch ID is used for unsubscribing.

```c++
watch_t watchActiveWindow(watch_callback cb);
```

--------------------------------

### Querying Vertical Refresh Rate

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

This section details how to query the vertical refresh rate of displays at a specific point. It's useful for operations that require synchronization with the GPU's frame rate.

```APIDOC
## GET /displayconfig/refresh-rate

### Description
Retrieves the minimum vertical refresh rate (in Hz) for displays servicing a given display point. If multiple displays service the point, the minimum rate is returned. Returns undefined if the point is not within any display bounds.

### Method
GET

### Endpoint
`/displayconfig/refresh-rate`

### Parameters
#### Query Parameters
- **x** (number) - Required - The horizontal offset of the display point (relative to the primary display's upper-left corner).
- **y** (number) - Required - The vertical offset of the display point (relative to the primary display's upper-left corner).

### Request Example
```
GET /displayconfig/refresh-rate?x=100&y=200
```

### Response
#### Success Response (200)
- **refreshRate** (number | undefined) - The vertical refresh rate in Hz, or undefined if the point is not found.

#### Response Example
```json
{
  "refreshRate": 60
}
```

### Notes
- The `VerticalRefreshRateContext` class should be disposed of using `ctx.close()` when no longer needed to prevent memory leaks and ensure graceful shutdown.
```

--------------------------------

### Retrieve Active Window Metadata

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Retrieves the current window's information, including title, PID, and application path. The caller is responsible for deallocating the returned WindowInfo object.

```c++
#include <iostream>
#include "ActiveWindow.h"

using namespace std;
using namespace PaymoActiveWindow;

int main() {
	ActiveWindow* activeWindow = new ActiveWindow(10);
	WindowInfo* windowInfo = activeWindow->getActiveWindow();

	if (windowInfo != NULL) {
		wcout << L"Title: " << windowInfo->title << "\n";
		delete windowInfo;
	}
	delete activeWindow;
	return 0;
}
```

--------------------------------

### WindowInfo Data Structure

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Defines the structure containing metadata for an active window, including UTF8 strings for titles and paths, the process ID, and a base64 encoded icon.

```c++
struct WindowInfo {
	std::string title;
	std::string application;
	std::string path;
	int pid;
	std::string icon;
};
```

--------------------------------

### getActiveWindow Function Signature

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Illustrates the signature of the 'getActiveWindow' function, which synchronously retrieves information about the current foreground window. It returns a 'WindowInfo' object and may throw an error if the window cannot be fetched.

```typescript
interface IActiveWindow {
	getActiveWindow(): WindowInfo
	// ...
}
```

--------------------------------

### Run Main Thread RunLoop (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

A helper function to run the main thread's RunLoop for a short duration or until the first event is handled. This is useful for console applications or when a RunLoop is not otherwise active. It should only be called on the main thread.

```c++
void runLoop();
```

--------------------------------

### WindowInfo Data Structure (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Defines the structure for holding window information, including title, application name, path, PID, and icon. This structure is used across different platforms.

```c++
struct WindowInfo {
	std::string title; // UTF8 encoded string of window title. Empty string if couldn't fetch
	std::string application; // UTF8 encoded string of application name. Empty string if couldn't fetch
	std::string path; // UTF8 encoded string of application path. Empty string if couldn't fetch
	int pid; // PID of process. -1 if couldn't fetch
	std::string icon; // base64 encoded PNG icon. Empty string if couldn't fetch
}
```

--------------------------------

### Querying Vertical Refresh Rate for Display Points

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

Uses the VerticalRefreshRateContext class to determine the refresh rate at specific screen coordinates. It handles multiple displays by returning the minimum refresh rate and requires manual disposal to prevent memory leaks.

```javascript
const { VerticalRefreshRateContext } = require("win32-displayconfig");
const ctx = new VerticalRefreshRateContext();

async function refreshRateForPoint(x, y) {
  return await ctx.findVerticalRefreshRateForDisplayPoint(x, y);
}

ctx.close();
```

--------------------------------

### Windows WindowInfo Data Structure

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Defines the structure containing metadata for windows on Windows platforms, including UWP-specific fields and base64 encoded icons.

```C++
struct WindowInfo {
	std::wstring title = L"";
	std::wstring application = L"";
	std::wstring path = L"";
	unsigned int pid = 0;
	bool isUWPApp = false;
	std::wstring uwpPackage = L"";
	std::string icon = "";
};
```

--------------------------------

### WindowInfo Data Structure Definition

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Defines the 'WindowInfo' interface, which represents the structure of data returned when querying for the active window. It includes properties for title, application, path, PID, icon, and platform-specific details for Windows.

```typescript
interface WindowInfo {
	title: string;
	application: string;
	path: string;
	pid: number;
	icon: string;
	windows?: {
		isUWPApp: boolean;
		uwpPackage: string;
	};
}
```

--------------------------------

### Retrieve Active Window Information

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Fetches a pointer to a WindowInfo object containing details about the currently active window. The caller is responsible for deallocating the returned pointer using delete.

```C++
WindowInfo* getActiveWindow();
```

--------------------------------

### Override Console Logging for IPC Communication

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/html/settings.html

This snippet overrides the global console.log and console.error methods. It captures log arguments and sends them to the main process using the window.ipc bridge while maintaining original console functionality.

```javascript
const consoleLog = console.log;
const consoleError = console.error;

const sendLog = (logArr, func) => {
  window.ipc.send('log', `[SETTINGS_WIN] ${logArr.join(" | ")}`);
  func.apply(console, logArr);
};

console.log = (...e) => sendLog(e, consoleLog);
console.error = (...e) => sendLog(e, consoleError);
```

--------------------------------

### Override Taskbar Gap

Source: https://github.com/xanderfrangos/twinkle-tray/wiki/Advanced-settings-parameters

Defines a manual pixel offset for the taskbar height to ensure the flyout renders correctly. Accepts an integer value representing the gap in pixels.

```json
"overrideTaskbarGap": 100
```

--------------------------------

### Configure DDC Brightness VCP Codes

Source: https://github.com/xanderfrangos/twinkle-tray/wiki/Advanced-settings-parameters

Overrides the default DDC/CI VCP code for specific monitors. The input is an object mapping the internal display name to a decimal or hexadecimal VCP code string.

```json
"userDDCBrightnessVCPs": {
	"GSM7707": "0x13"
}
```

--------------------------------

### Subscribe to Active Window Changes (TypeScript)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Allows subscribing to events when the active window changes. A callback function is executed with window information or null if no window is focused. Returns a watch ID for unsubscribing.

```typescript
interface IActiveWindow {
	subscribe(callback: (windowInfo: WindowInfo | null) => void): number;
	// ...
}
```

--------------------------------

### Extract and Inspect Display Configuration

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/win32-displayconfig/README.md

Uses the extractDisplayConfig function to retrieve a structured object containing display names, paths, and mode information. This function aggregates data from multiple low-level buffers into a single, readable format.

```javascript
const w32disp = require("win32-displayconfig");
const util = require("util");

w32disp.extractDisplayConfig().then((output) => {
  console.log(util.inspect(output, { depth: 10 }));
});
```

--------------------------------

### Override Taskbar Position

Source: https://github.com/xanderfrangos/twinkle-tray/wiki/Advanced-settings-parameters

Forces the application to recognize a specific taskbar position when automatic detection fails. Supported values are TOP, BOTTOM, LEFT, or RIGHT.

```json
"overrideTaskbarPosition": "LEFT"
```

--------------------------------

### Watch Callback Function Type (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Defines the type for the callback function used when a window change is detected. It accepts a pointer to a WindowInfo structure.

```c++
typedef std::function<void(WindowInfo*)> watch_callback;

```

--------------------------------

### Watch Identifier Type (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Defines the type for watch identifiers, used to manage event listeners for window changes.

```c++
typedef unsigned int watch_t;

```

--------------------------------

### Unwatch Active Window (C++)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Removes an active window watcher using its unique watch ID.

```c++
void unwatchActiveWindow(watch_t watch);
```

--------------------------------

### Unsubscribe from Active Window Changes (TypeScript)

Source: https://github.com/xanderfrangos/twinkle-tray/blob/master/src/modules/node-active-window/README.md

Removes an event listener for active window changes using the provided watch ID. This function is essential for managing event subscriptions and preventing memory leaks.

```typescript
interface IActiveWindow {
	unsubscribe(watchId: number): void;
	// ...
}
```
Tokens:
Raw