Wrapping Windows Functions using ctypes

in

Alright ! Let’s talk about wrapping Windows functions using ctypes in Python. This can be super fun if you want to interact with your favorite operating system from within Python! To begin with: find the function(s) you want to wrap by checking out Microsoft’s documentation website. For example, let’s say we want to get the window coordinates of our beloved Notepad application (because who doesn’t love writing in a text editor that hasn’t been updated since 1985?). We can head over to their docs and search for “GetWindowRect” function. Once you find it, copy its prototype:

// This script demonstrates how to use the "GetWindowRect" function to retrieve the coordinates of a window.

// First, we need to include the necessary header files.
#include <windows.h> // This header file contains the definition of the "HWND" data type and the "GetWindowRect" function.
#include <stdio.h> // This header file is needed for the "printf" function.

// Next, we need to declare the main function.
int main() {

    // We need to declare a variable of type "HWND" to store the handle of the window we want to retrieve the coordinates of.
    HWND notepadHandle;

    // We can use the "FindWindow" function to retrieve the handle of the Notepad window.
    notepadHandle = FindWindow(NULL, "Notepad");

    // We need to declare a variable of type "RECT" to store the coordinates of the window.
    RECT windowRect;

    // Now, we can call the "GetWindowRect" function and pass in the handle of the Notepad window and the address of the "RECT" variable.
    GetWindowRect(notepadHandle, &windowRect);

    // Finally, we can print out the coordinates of the window using the "printf" function.
    printf("The coordinates of the Notepad window are: (%d, %d, %d, %d)", windowRect.left, windowRect.top, windowRect.right, windowRect.bottom);

    // The "GetWindowRect" function returns a boolean value indicating whether the operation was successful or not.
    // In this case, we can simply return 0 to indicate that the program executed successfully.
    return 0;
}

// Note: This script assumes that the Notepad window is already open and running. If the window is not found, the "FindWindow" function will return a NULL handle and the program will not be able to retrieve the coordinates.

Now let’s convert that into Python using ctypes. Here’s what we get:

# Import necessary libraries
from ctypes import POINTER, WINFUNCTYPE, windll, WinError
from ctypes.wintypes import BOOL, HWND, RECT

# Define the prototype for the GetWindowRect function
# WINFUNCTYPE is used to create a function prototype with specified return type and argument types
# BOOL is the return type, HWND and POINTER(RECT) are the argument types
prototype = WINFUNCTYPE(BOOL, HWND, POINTER(RECT))

# Define the parameter flags for the GetWindowRect function
# The first parameter is a flag indicating the type of the parameter, in this case 1 for HWND
# The second parameter is the name of the parameter, in this case "hwnd"
# The third parameter is a flag indicating the type of the parameter, in this case 2 for POINTER(RECT)
# The fourth parameter is the name of the parameter, in this case "lprect"
paramflags = (1, "hwnd"), (2, "lprect")

# Use the prototype and parameter flags to create the GetWindowRect function
# "GetWindowRect" is the name of the function, windll.user32 is the library where the function is located
GetWindowRect = prototype("GetWindowRect", windll.user32)

Let’s break it down:
– We import `ctypes`, `wintypes`, and the `windll` module from ctypes to access Windows functions.
– We define a function called `prototype` that takes two arguments (a window handle and a pointer to a rectangle structure) and returns a boolean value. This is done using the `WINFUNCTYPE` class, which allows us to specify the return type and argument types of our wrapped function.
– The `paramflags` tuple specifies how each parameter should be passed in when calling the function. In this case, we’re passing the window handle as a plain integer (index 1) and the pointer to the rectangle structure as an object reference (index 2).
– Finally, we assign our wrapped function to `GetWindowRect` using the `prototype` function and specifying that it should be called from the `user32.dll` library.

And there you have it! Now you can call this function in your Python script like so:

# Import necessary libraries
import ctypes # Import ctypes library for working with C data types
from ctypes import wintypes, windll # Import specific modules from ctypes library
from ctypes.wintypes import BOOL, HWND, RECT # Import specific data types from wintypes module
from ctypes.util import find_library # Import find_library function from util module

# Load user32.dll library
user32 = windll.LoadLibrary(find_library("user32"))

# Define GetWindowRect function using WINFUNCTYPE
# Specify return type, function name, and library to call from
GetWindowRect = ctypes.WINFUNCTYPE(BOOL, wintypes.HWND, ctypes.POINTER(RECT))(
    "GetWindowRect", user32)

# Define parameter flags for GetWindowRect function
paramflags = (1, "hwnd"), (2, "lprect")

# Define get_window_rect function
def get_window_rect(hWnd):
    # Create RECT object
    rect = RECT()
    # Call GetWindowRect function and pass in hWnd and a pointer to the rect object
    GetWindowRect(hWnd, ctypes.byref(rect))
    # Return the rect object
    return rect

# Now you can call the get_window_rect function in your Python script
# Example: get_window_rect(hWnd)

And that’s it! You can now call `get_window_rect` with a window handle and get back the coordinates of its top-left corner.

SICORPS