Package com.sun.jna.platform.win32

Interface User32

    • Field Detail

      • INSTANCE

        static final User32 INSTANCE
        The instance.

      • HWND_MESSAGE

        static final WinDef.HWND HWND_MESSAGE
        Handle for message-only window.

      • DEVICE_NOTIFY_WINDOW_HANDLE

        static final int DEVICE_NOTIFY_WINDOW_HANDLE
        The hRecipient parameter is a window handle.
        See Also:
        Constant Field Values

      • DEVICE_NOTIFY_SERVICE_HANDLE

        static final int DEVICE_NOTIFY_SERVICE_HANDLE
        The hRecipient parameter is a service status handle.
        See Also:
        Constant Field Values

      • DEVICE_NOTIFY_ALL_INTERFACE_CLASSES

        static final int DEVICE_NOTIFY_ALL_INTERFACE_CLASSES
        The device notify all interface classes.
        See Also:
        Constant Field Values

      • SW_SHOWDEFAULT

        static final int SW_SHOWDEFAULT

        Sets the show state based on the SW_ value specified in the STARTUPINFO structure passed to the CreateProcess function by the program that started the application.

        See Also:
        Constant Field Values

    • Method Detail

      • GetDC

        WinDef.HDC GetDC​(WinDef.HWND hWnd)
        This function retrieves a handle to a display device context (DC) for the client area of the specified window. The display device context can be used in subsequent graphics display interface (GDI) functions to draw in the client area of the window.
        Parameters:
        hWnd - Handle to the window whose device context is to be retrieved. If this value is NULL, GetDC retrieves the device context for the entire screen.
        Returns:
        The handle the device context for the specified window's client area indicates success. NULL indicates failure. To get extended error information, call GetLastError.

      • ReleaseDC

        int ReleaseDC​(WinDef.HWND hWnd,
              WinDef.HDC hDC)
        This function releases a device context (DC), freeing it for use by other applications. The effect of ReleaseDC depends on the type of device context.
        Parameters:
        hWnd - Handle to the window whose device context is to be released.
        hDC - Handle to the device context to be released.
        Returns:
        The return value specifies whether the device context is released. 1 indicates that the device context is released. Zero indicates that the device context is not released.

      • FindWindow

        WinDef.HWND FindWindow​(String lpClassName,
                       String lpWindowName)
        This function retrieves the handle to the top-level window whose class name and window name match the specified strings. This function does not search child windows.
        Parameters:
        lpClassName - Long pointer to a null-terminated string that specifies the class name or is an atom that identifies the class-name string. If this parameter is an atom, it must be a global atom created by a previous call to the GlobalAddAtom function. The atom, a 16-bit value, must be placed in the low-order word of lpClassName; the high-order word must be zero.
        lpWindowName - Long pointer to a null-terminated string that specifies the window name (the window's title). If this parameter is NULL, all window names match.
        Returns:
        A handle to the window that has the specified class name and window name indicates success. NULL indicates failure. To get extended error information, call GetLastError.

      • GetClassName

        int GetClassName​(WinDef.HWND hWnd,
                 char[] lpClassName,
                 int nMaxCount)
        This function retrieves the name of the class to which the specified window belongs.
        Parameters:
        hWnd - Handle to the window and, indirectly, the class to which the window belongs.
        lpClassName - Long pointer to the buffer that is to receive the class name string.
        nMaxCount - Specifies the length, in characters, of the buffer pointed to by the lpClassName parameter. The class name string is truncated if it is longer than the buffer.
        Returns:
        The number of characters copied to the specified buffer indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • GetGUIThreadInfo

        boolean GetGUIThreadInfo​(int idThread,
                         WinUser.GUITHREADINFO lpgui)
        Retrieves information about the active window or a specified graphical user interface (GUI) thread.
        Parameters:
        idThread - Identifies the thread for which information is to be retrieved. To retrieve this value, use the GetWindowThreadProcessId function. If this parameter is NULL, the function returns information for the foreground thread.
        lpgui - Pointer to a GUITHREADINFO structure that receives information describing the thread. Note that you must set GUITHREADINFO.cbSize to sizeof(GUITHREADINFO) before calling this function.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetWindowInfo

        boolean GetWindowInfo​(WinDef.HWND hWnd,
                      WinUser.WINDOWINFO pwi)
        The GetWindowInfo function retrieves information about the specified window.
        Parameters:
        hWnd - Handle to the window whose information is to be retrieved.
        pwi - Pointer to a WINDOWINFO structure to receive the information. Note that you must set WINDOWINFO.cbSize to sizeof(WINDOWINFO) before calling this function.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • GetWindowRect

        boolean GetWindowRect​(WinDef.HWND hWnd,
                      WinDef.RECT rect)
        This function retrieves the dimensions of the bounding rectangle of the specified window. The dimensions are given in screen coordinates that are relative to the upper-left corner of the screen.
        Parameters:
        hWnd - Handle to the window.
        rect - Long pointer to a RECT structure that receives the screen coordinates of the upper-left and lower-right corners of the window.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • GetClientRect

        boolean GetClientRect​(WinDef.HWND hWnd,
                      WinDef.RECT rect)
        This function retrieves the coordinates of a window's client area. The client coordinates specify the upper-left and lower-right corners of the client area. Because client coordinates are relative to the upper-left corner of a window's client area, the coordinates of the upper-left corner are (0,0).
        Parameters:
        hWnd - Handle to the window.
        rect - Long pointer to a RECT structure that structure that receives the client coordinates. The left and top members are zero. The right and bottom members contain the width and height of the window.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • GetWindowText

        int GetWindowText​(WinDef.HWND hWnd,
                  char[] lpString,
                  int nMaxCount)
        This function copies the text of the specified window's title bar - if it has one - into a buffer. If the specified window is a control, the text of the control is copied.
        Parameters:
        hWnd - Handle to the window or control containing the text.
        lpString - Long pointer to the buffer that will receive the text.
        nMaxCount - Specifies the maximum number of characters to copy to the buffer, including the NULL character. If the text exceeds this limit, it is truncated.
        Returns:
        The length, in characters, of the copied string, not including the terminating null character, indicates success. Zero indicates that the window has no title bar or text, if the title bar is empty, or if the window or control handle is invalid. To get extended error information, call GetLastError. This function cannot retrieve the text of an edit control in another application.

      • GetWindowTextLength

        int GetWindowTextLength​(WinDef.HWND hWnd)
        This function retrieves the length, in characters, of the specified window's title bar text - if the window has a title bar. If the specified window is a control, the function retrieves the length of the text within the control.
        Parameters:
        hWnd - Handle to the window or control.
        Returns:
        The length, in characters, of the text indicates success. Under certain conditions, this value may actually be greater than the length of the text. Zero indicates that the window has no text. To get extended error information, call GetLastError.

      • GetWindowModuleFileName

        int GetWindowModuleFileName​(WinDef.HWND hWnd,
                            char[] lpszFileName,
                            int cchFileNameMax)
        The GetWindowModuleFileName function retrieves the full path and file name of the module associated with the specified window handle.
        Parameters:
        hWnd - Handle to the window whose module file name will be retrieved.
        lpszFileName - Pointer to a buffer that receives the path and file name.
        cchFileNameMax - Specifies the maximum number of TCHARs that can be copied into the lpszFileName buffer.
        Returns:
        The return value is the total number of TCHARs copied into the buffer.

      • GetWindowThreadProcessId

        int GetWindowThreadProcessId​(WinDef.HWND hWnd,
                             IntByReference lpdwProcessId)
        This function retrieves the identifier of the thread that created the specified window and, optionally, the identifier of the process that created the window.
        Parameters:
        hWnd - Handle to the window.
        lpdwProcessId - Pointer to a 32-bit value that receives the process identifier. If this parameter is not NULL, GetWindowThreadProcessId copies the identifier of the process to the 32-bit value; otherwise, it does not.
        Returns:
        The return value is the identifier of the thread that created the window.

      • EnumWindows

        boolean EnumWindows​(WinUser.WNDENUMPROC lpEnumFunc,
                    Pointer data)
        This function enumerates all top-level windows on the screen by passing the handle to each window, in turn, to an application-defined callback function. EnumWindows continues until the last top-level window is enumerated or the callback function returns FALSE.
        Parameters:
        lpEnumFunc - Long pointer to an application-defined callback function.
        data - Specifies an application-defined value to be passed to the callback function.
        Returns:
        Nonzero indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • EnumChildWindows

        boolean EnumChildWindows​(WinDef.HWND hWnd,
                         WinUser.WNDENUMPROC lpEnumFunc,
                         Pointer data)
        The EnumChildWindows function enumerates the child windows that belong to the specified parent window by passing the handle to each child window, in turn, to an application-defined callback function. EnumChildWindows continues until the last child window is enumerated or the callback function returns FALSE.
        Parameters:
        hWnd - Handle to the parent window whose child windows are to be enumerated. If this parameter is NULL, this function is equivalent to EnumWindows.
        lpEnumFunc - Pointer to an application-defined callback function.
        data - Specifies an application-defined value to be passed to the callback function.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError. If EnumChildProc returns zero, the return value is also zero. In this case, the callback function should call SetLastError to obtain a meaningful error code to be returned to the caller of EnumChildWindows.

      • EnumThreadWindows

        boolean EnumThreadWindows​(int dwThreadId,
                          WinUser.WNDENUMPROC lpEnumFunc,
                          Pointer data)
        The EnumThreadWindows function enumerates all nonchild windows associated with a thread by passing the handle to each window, in turn, to an application-defined callback function. EnumThreadWindows continues until the last window is enumerated or the callback function returns FALSE. To enumerate child windows of a particular window, use the EnumChildWindows function.
        Parameters:
        dwThreadId - Identifies the thread whose windows are to be enumerated.
        lpEnumFunc - Pointer to an application-defined callback function.
        data - Specifies an application-defined value to be passed to the callback function.
        Returns:
        If the callback function returns TRUE for all windows in the thread specified by dwThreadId, the return value is TRUE. If the callback function returns FALSE on any enumerated window, or if there are no windows found in the thread specified by dwThreadId, the return value is FALSE.

      • FlashWindowEx

        boolean FlashWindowEx​(WinUser.FLASHWINFO pfwi)
        The FlashWindowEx function flashes the specified window. It does not change the active state of the window.
        Parameters:
        pfwi - Pointer to the FLASHWINFO structure.
        Returns:
        The return value specifies the window's state before the call to the FlashWindowEx function. If the window caption was drawn as active before the call, the return value is nonzero. Otherwise, the return value is zero.

      • LoadIcon

        WinDef.HICON LoadIcon​(WinDef.HINSTANCE hInstance,
                      String iconName)
        This function loads the specified icon resource from the executable (.exe) file associated with an application instance.
        Parameters:
        hInstance - Handle to an instance of the module whose executable file contains the icon to be loaded. This parameter must be NULL when a standard icon is being loaded.
        iconName - Long pointer to a null-terminated string that contains the name of the icon resource to be loaded. Alternatively, this parameter can contain the resource identifier in the low-order word and zero in the high-order word. Use the MAKEINTRESOURCE macro to create this value.

        To use one of the predefined icons, set the hInstance parameter to NULL and the lpIconName parameter to one of the following values: WinUser.IDC_APPSTARTING etc.

        Returns:
        A handle to the newly loaded icon indicates success. NULL indicates failure. To get extended error information, call GetLastError.

      • LoadImage

        WinNT.HANDLE LoadImage​(WinDef.HINSTANCE hinst,
                       String name,
                       int type,
                       int xDesired,
                       int yDesired,
                       int load)
        This function loads an icon, cursor, or bitmap.
        Parameters:
        hinst - Handle to an instance of the module that contains the image to be loaded.
        name - Pointer to a null-terminated string that contains the name of the image resource in the hinst module that identifies the image to load.
        type - Specifies the type of image to be loaded.
        xDesired - Specifies the width, in pixels, of the icon or cursor. If this parameter is zero, the function uses the SM_CXICON or SM_CXCURSOR system metric value to set the width. If uType is IMAGE_BITMAP, this parameter must be zero.
        yDesired - Specifies the height, in pixels, of the icon or cursor. If this parameter is zero, the function uses the SM_CYICON or SM_CYCURSOR system metric value to set the height. If uType is IMAGE_BITMAP, this parameter must be zero.
        load - Set to zero.
        Returns:
        The handle of the newly loaded image indicates success. NULL indicates failure. To get extended error information, call GetLastError.

      • DestroyIcon

        boolean DestroyIcon​(WinDef.HICON hicon)
        This function destroys an icon and frees any memory the icon occupied.
        Parameters:
        hicon - Handle to the icon to be destroyed. The icon must not be in use.
        Returns:
        Nonzero indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • GetWindowLong

        int GetWindowLong​(WinDef.HWND hWnd,
                  int nIndex)
        This function retrieves information about the specified window. GetWindowLong also retrieves the 32-bit (long) value at the specified offset into the extra window memory of a window.
        Parameters:
        hWnd - Handle to the window and, indirectly, the class to which the window belongs.
        nIndex - Specifies the zero-based offset to the value to be retrieved.
        Returns:
        The requested 32-bit value indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • SetWindowLong

        int SetWindowLong​(WinDef.HWND hWnd,
                  int nIndex,
                  int dwNewLong)
        This function changes an attribute of the specified window. SetWindowLong also sets a 32-bit (LONG) value at the specified offset into the extra window memory of a window.
        Parameters:
        hWnd - Handle to the window and, indirectly, the class to which the window belongs.
        nIndex - Specifies the zero-based offset to the value to be set.
        dwNewLong - Specifies the replacement value.
        Returns:
        The previous value of the specified 32-bit integer indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • GetWindowLongPtr

        BaseTSD.LONG_PTR GetWindowLongPtr​(WinDef.HWND hWnd,
                                  int nIndex)
        The GetWindowLongPtr function retrieves information about the specified window. The function also retrieves the value at a specified offset into the extra window memory.
        Parameters:
        hWnd - Handle to the window and, indirectly, the class to which the window belongs.
        nIndex - Specifies the zero-based offset to the value to be retrieved.
        Returns:
        If the function succeeds, the return value is the requested value. If the function fails, the return value is zero. To get extended error information, call GetLastError. If SetWindowLong or SetWindowLongPtr has not been called previously, GetWindowLongPtr returns zero for values in the extra window or class memory.

      • SetWindowLongPtr

        Pointer SetWindowLongPtr​(WinDef.HWND hWnd,
                         int nIndex,
                         Pointer dwNewLongPtr)
        The SetWindowLongPtr function changes an attribute of the specified window. The function also sets a value at the specified offset in the extra window memory.
        Parameters:
        hWnd - Handle to the window and, indirectly, the class to which the window belongs.
        nIndex - Specifies the zero-based offset to the value to be set.
        dwNewLongPtr - Specifies the replacement value.
        Returns:
        If the function succeeds, the return value is the previous value of the specified offset. If the function fails, the return value is zero. To get extended error information, call GetLastError. If the previous value is zero and the function succeeds, the return value is zero, but the function does not clear the last error information. To determine success or failure, clear the last error information by calling SetLastError(0), then call SetWindowLongPtr. Function failure will be indicated by a return value of zero and a GetLastError result that is nonzero.

      • SetLayeredWindowAttributes

        boolean SetLayeredWindowAttributes​(WinDef.HWND hwnd,
                                   int crKey,
                                   byte bAlpha,
                                   int dwFlags)
        The SetLayeredWindowAttributes function sets the opacity and transparency color key of a layered window.
        Parameters:
        hwnd - Handle to the layered window.
        crKey - COLORREF structure that specifies the transparency color key to be used when composing the layered window.
        bAlpha - Alpha value used to describe the opacity of the layered window.
        dwFlags - Specifies an action to take.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetLayeredWindowAttributes

        boolean GetLayeredWindowAttributes​(WinDef.HWND hwnd,
                                   IntByReference pcrKey,
                                   ByteByReference pbAlpha,
                                   IntByReference pdwFlags)
        The GetLayeredWindowAttributes function retrieves the opacity and transparency color key of a layered window.
        Parameters:
        hwnd - Handle to the layered window. A layered window is created by specifying WS_EX_LAYERED when creating the window with the CreateWindowEx function or by setting WS_EX_LAYERED via SetWindowLong after the window has been created.
        pcrKey - Pointer to a COLORREF value that receives the transparency color key to be used when composing the layered window. All pixels painted by the window in this color will be transparent. This can be NULL if the argument is not needed.
        pbAlpha - Pointer to a BYTE that receives the Alpha value used to describe the opacity of the layered window. Similar to the SourceConstantAlpha member of the BLENDFUNCTION structure. When the variable referred to by pbAlpha is 0, the window is completely transparent. When the variable referred to by pbAlpha is 255, the window is opaque. This can be NULL if the argument is not needed.
        pdwFlags - Pointer to a DWORD that receives a layering flag. This can be NULL if the argument is not needed.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • UpdateLayeredWindow

        boolean UpdateLayeredWindow​(WinDef.HWND hwnd,
                            WinDef.HDC hdcDst,
                            WinDef.POINT pptDst,
                            WinUser.SIZE psize,
                            WinDef.HDC hdcSrc,
                            WinDef.POINT pptSrc,
                            int crKey,
                            WinUser.BLENDFUNCTION pblend,
                            int dwFlags)
        The UpdateLayeredWindow function updates the position, size, shape, content, and translucency of a layered window.
        Parameters:
        hwnd - Handle to a layered window. A layered window is created by specifying WS_EX_LAYERED when creating the window with the CreateWindowEx function.
        hdcDst - Handle to a device context (DC) for the screen. This handle is obtained by specifying NULL when calling the function. It is used for palette color matching when the window contents are updated. If hdcDst isNULL, the default palette will be used. If hdcSrc is NULL, hdcDst must be NULL.
        pptDst - Pointer to a POINT structure that specifies the new screen position of the layered window. If the current position is not changing, pptDst can be NULL.
        psize - Pointer to a SIZE structure that specifies the new size of the layered window. If the size of the window is not changing, psize can be NULL. If hdcSrc is NULL, psize must be NULL.
        hdcSrc - Handle to a DC for the surface that defines the layered window. This handle can be obtained by calling the CreateCompatibleDC function. If the shape and visual context of the window are not changing, hdcSrc can be NULL.
        pptSrc - Pointer to a POINT structure that specifies the location of the layer in the device context. If hdcSrc is NULL, pptSrc should be NULL.
        crKey - Pointer to a COLORREF value that specifies the color key to be used when composing the layered window. To generate a COLORREF, use the RGB macro.
        pblend - Pointer to a BLENDFUNCTION structure that specifies the transparency value to be used when composing the layered window.
        dwFlags - ULW_* flags.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • SetWindowRgn

        int SetWindowRgn​(WinDef.HWND hWnd,
                 WinDef.HRGN hRgn,
                 boolean bRedraw)
        This function sets the window region of a window. The window region determines the area within the window where the system permits drawing. The system does not display any portion of a window that lies outside of the window region.
        Parameters:
        hWnd - Handle to the window whose window region is to be set.
        hRgn - Handle to a region. The function sets the window region of the window to this region. If hRgn is NULL, the function sets the window region to NULL.
        bRedraw - Specifies whether the system redraws the window after setting the window region. If bRedraw is TRUE, the system does so; otherwise, it does not. Typically, you set bRedraw to TRUE if the window is visible.
        Returns:
        Nonzero indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • GetKeyboardState

        boolean GetKeyboardState​(byte[] lpKeyState)
        The GetKeyboardState function copies the status of the 256 virtual keys to the specified buffer.
        Parameters:
        lpKeyState - Pointer to the 256-byte array that receives the status data for each virtual key.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetAsyncKeyState

        short GetAsyncKeyState​(int vKey)
        This function determines whether a key is up or down at the time the function is called, and whether the key was pressed after a previous call to GetAsyncKeyState.
        Parameters:
        vKey - Specifies one of 256 possible virtual-key codes.
        Returns:
        If the function succeeds, the return value specifies whether the key was pressed since the last call to GetAsyncKeyState, and whether the key is currently up or down. If the most significant bit is set, the key is down.

      • SetWindowsHookEx

        WinUser.HHOOK SetWindowsHookEx​(int idHook,
                               WinUser.HOOKPROC lpfn,
                               WinDef.HINSTANCE hMod,
                               int dwThreadId)
        The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain. You would install a hook procedure to monitor the system for certain types of events. These events are associated either with a specific thread or with all threads in the same desktop as the calling thread.
        Parameters:
        idHook - Specifies the type of hook procedure to be installed.
        lpfn - Pointer to the hook procedure.
        hMod - Handle to the DLL containing the hook procedure pointed to by the lpfn parameter.
        dwThreadId - Specifies the identifier of the thread with which the hook procedure is to be associated.
        Returns:
        If the function succeeds, the return value is the handle to the hook procedure. If the function fails, the return value is NULL. To get extended error information, call GetLastError.

      • CallNextHookEx

        WinDef.LRESULT CallNextHookEx​(WinUser.HHOOK hhk,
                              int nCode,
                              WinDef.WPARAM wParam,
                              WinDef.LPARAM lParam)
        The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain. A hook procedure can call this function either before or after processing the hook information.
        Parameters:
        hhk - Ignored.
        nCode - Specifies the hook code passed to the current hook procedure. The next hook procedure uses this code to determine how to process the hook information.
        wParam - Specifies the wParam value passed to the current hook procedure. The meaning of this parameter depends on the type of hook associated with the current hook chain.
        lParam - Specifies the lParam value passed to the current hook procedure. The meaning of this parameter depends on the type of hook associated with the current hook chain.
        Returns:
        This value is returned by the next hook procedure in the chain. The current hook procedure must also return this value. The meaning of the return value depends on the hook type.

      • UnhookWindowsHookEx

        boolean UnhookWindowsHookEx​(WinUser.HHOOK hhk)
        The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function.
        Parameters:
        hhk - Handle to the hook to be removed. This parameter is a hook handle obtained by a previous call to SetWindowsHookEx.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetMessage

        int GetMessage​(WinUser.MSG lpMsg,
               WinDef.HWND hWnd,
               int wMsgFilterMin,
               int wMsgFilterMax)
        This function retrieves a message from the calling thread's message queue and places it in the specified structure.
        Parameters:
        lpMsg - Pointer to an MSG structure that receives message information from the thread's message queue.
        hWnd - Handle to the window whose messages are to be retrieved. One value has a special meaning.
        wMsgFilterMin - Specifies the integer value of the lowest message value to be retrieved.
        wMsgFilterMax - Specifies the integer value of the highest message value to be retrieved.
        Returns:
        If the function retrieves a message other than WM_QUIT, the return value is nonzero.

        If the function retrieves the WM_QUIT message, the return value is zero.

        If there is an error, the return value is -1. For example, the function fails if hWnd is an invalid window handle or lpMsg is an invalid pointer. To get extended error information, call GetLastError.

      • PeekMessage

        boolean PeekMessage​(WinUser.MSG lpMsg,
                    WinDef.HWND hWnd,
                    int wMsgFilterMin,
                    int wMsgFilterMax,
                    int wRemoveMsg)
        This function checks a thread message queue for a message and places the message (if any) in the specified structure.
        Parameters:
        lpMsg - Pointer to an MSG structure that receives message information.
        hWnd - Handle to the window whose messages are to be examined.
        wMsgFilterMin - Specifies the value of the first message in the range of messages to be examined.
        wMsgFilterMax - Specifies the value of the last message in the range of messages to be examined.
        wRemoveMsg - Specifies how messages are handled. This parameter can be one of the following values.
        Returns:
        Nonzero indicates success. Zero indicates failure.

      • TranslateMessage

        boolean TranslateMessage​(WinUser.MSG lpMsg)
        This function translates virtual-key messages into character messages. The character messages are posted to the calling thread's message queue, to be read the next time the thread calls the GetMessage or PeekMessage function.
        Parameters:
        lpMsg - Pointer to an MSG structure that contains message information retrieved from the calling thread's message queue by using the GetMessage or PeekMessage function.
        Returns:
        Nonzero indicates that the message is translated, that is, a character message is posted to the thread's message queue. If the message is WM_KEYDOWN or WM_SYSKEYDOWN, the return value is nonzero, regardless of the translation. Zero indicates that the message is not translated, that is, a character message is not posted to the thread's message queue.

      • DispatchMessage

        WinDef.LRESULT DispatchMessage​(WinUser.MSG lpMsg)
        This function dispatches a message to a window procedure. It is typically used to dispatch a message retrieved by the GetMessage function.
        Parameters:
        lpMsg - Pointer to an MSG structure that contains the message.
        Returns:
        The return value specifies the value returned by the window procedure. Although its meaning depends on the message being dispatched, the return value generally is ignored.

      • PostMessage

        void PostMessage​(WinDef.HWND hWnd,
                 int msg,
                 WinDef.WPARAM wParam,
                 WinDef.LPARAM lParam)
        This function places a message in the message queue associated with the thread that created the specified window and then returns without waiting for the thread to process the message. Messages in a message queue are retrieved by calls to the GetMessage or PeekMessage function.
        Parameters:
        hWnd - Handle to the window whose window procedure is to receive the message.
        msg - Specifies the message to be posted.
        wParam - Specifies additional message-specific information.
        lParam - Specifies additional message-specific information.

      • PostThreadMessage

        int PostThreadMessage​(int idThread,
                      int Msg,
                      WinDef.WPARAM wParam,
                      WinDef.LPARAM lParam)
        Posts a message to the message queue of the specified thread. It returns without waiting for the thread to process the message.
        Parameters:
        idThread - The identifier of the thread to which the message is to be posted.

        The function fails if the specified thread does not have a message queue. The system creates a thread's message queue when the thread makes its first call to one of the User or GDI functions.

        Message posting is subject to UIPI. The thread of a process can post messages only to posted-message queues of threads in processes of lesser or equal integrity level.

        This thread must have the SE_TCB_NAME privilege to post a message to a thread that belongs to a process with the same locally unique identifier (LUID) but is in a different desktop. Otherwise, the function fails and returns ERROR_INVALID_THREAD_ID.

        This thread must either belong to the same desktop as the calling thread or to a process with the same LUID. Otherwise, the function fails and returns ERROR_INVALID_THREAD_ID.

        Msg - The type of message to be posted.
        wParam - Additional message-specific information.
        lParam - Additional message-specific information.
        Returns:
        If the function succeeds, the return value is nonzero.

        If the function fails, the return value is zero. To get extended error information, call GetLastError.

        GetLastError returns ERROR_INVALID_THREAD_ID if idThread is not a valid thread identifier, or if the thread specified by idThread does not have a message queue.

        GetLastError returns ERROR_NOT_ENOUGH_QUOTA when the message limit is hit.

      • PostQuitMessage

        void PostQuitMessage​(int nExitCode)
        This function indicates to Windows that a thread has made a request to terminate (quit). It is typically used in response to a WM_DESTROY message.
        Parameters:
        nExitCode - Specifies an application exit code. This value is used as the wParam parameter of the WM_QUIT message.

      • GetSystemMetrics

        int GetSystemMetrics​(int nIndex)
        The GetSystemMetrics function retrieves various system metrics (widths and heights of display elements) and system configuration settings. All dimensions retrieved by GetSystemMetrics are in pixels.
        Parameters:
        nIndex - System metric or configuration setting to retrieve. This parameter can be one of the following values. Note that all SM_CX* values are widths and all SM_CY* values are heights. Also note that all settings designed to return Boolean data represent TRUE as any nonzero value, and FALSE as a zero value.
        Returns:
        If the function succeeds, the return value is the requested system metric or configuration setting. If the function fails, the return value is zero. GetLastError does not provide extended error information.

      • SetParent

        WinDef.HWND SetParent​(WinDef.HWND hWndChild,
                      WinDef.HWND hWndNewParent)
        Changes the parent window of the specified child window.
        Parameters:
        hWndChild - A handle to the child window.
        hWndNewParent - A handle to the new parent window. If this parameter is NULL, the desktop window becomes the new parent window. If this parameter is HWND_MESSAGE, the child window becomes a message-only window.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • IsWindowVisible

        boolean IsWindowVisible​(WinDef.HWND hWnd)
        Determines the visibility state of the specified window.
        Parameters:
        hWnd - A handle to the window to be tested.
        Returns:
        If the specified window, its parent window, its parent's parent window, and so forth, have the WS_VISIBLE style, the return value is nonzero. Otherwise, the return value is zero. Because the return value specifies whether the window has the WS_VISIBLE style, it may be nonzero even if the window is totally obscured by other windows.

      • MoveWindow

        boolean MoveWindow​(WinDef.HWND hWnd,
                   int X,
                   int Y,
                   int nWidth,
                   int nHeight,
                   boolean bRepaint)
        Changes the position and dimensions of the specified window. For a top-level window, the position and dimensions are relative to the upper-left corner of the screen. For a child window, they are relative to the upper-left corner of the parent window's client area.
        Parameters:
        hWnd - A handle to the window.
        X - The new position of the left side of the window.
        Y - The new position of the top of the window.
        nWidth - The new width of the window.
        nHeight - The new height of the window.
        bRepaint - Indicates whether the window is to be repainted. If this parameter is TRUE, the window receives a message. If the parameter is FALSE, no repainting of any kind occurs. This applies to the client area, the nonclient area (including the title bar and scroll bars), and any part of the parent window uncovered as a result of moving a child window.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • SetWindowPos

        boolean SetWindowPos​(WinDef.HWND hWnd,
                     WinDef.HWND hWndInsertAfter,
                     int X,
                     int Y,
                     int cx,
                     int cy,
                     int uFlags)
        Changes the size, position, and Z order of a child, pop-up, or top-level window. These windows are ordered according to their appearance on the screen. The topmost window receives the highest rank and is the first window in the Z order.
        Parameters:
        hWnd - A handle to the window.
        hWndInsertAfter - A handle to the window to precede the positioned window in the Z order.
        X - The new position of the left side of the window, in client coordinates.
        Y - The new position of the top of the window, in client coordinates.
        cx - The new width of the window, in pixels.
        cy - The new height of the window, in pixels.
        uFlags - The window sizing and positioning flags.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • AttachThreadInput

        boolean AttachThreadInput​(WinDef.DWORD idAttach,
                          WinDef.DWORD idAttachTo,
                          boolean fAttach)
        Attaches or detaches the input processing mechanism of one thread to that of another thread.
        Parameters:
        idAttach - The identifier of the thread to be attached to another thread. The thread to be attached cannot be a system thread.
        idAttachTo - The identifier of the thread to which idAttach will be attached. This thread cannot be a system thread. A thread cannot attach to itself. Therefore, idAttachTo cannot equal idAttach.
        fAttach - If this parameter is TRUE, the two threads are attached. If the parameter is FALSE, the threads are detached.
        Returns:
        If the function succeeds, the return value is nonzero.

      • SetForegroundWindow

        boolean SetForegroundWindow​(WinDef.HWND hWnd)
        Brings the thread that created the specified window into the foreground and activates the window. Keyboard input is directed to the window, and various visual cues are changed for the user. The system assigns a slightly higher priority to the thread that created the foreground window than it does to other threads.
        Parameters:
        hWnd - A handle to the window that should be activated and brought to the foreground.
        Returns:
        If the window was brought to the foreground, the return value is nonzero.

      • GetForegroundWindow

        WinDef.HWND GetForegroundWindow()
        Retrieves a handle to the foreground window (the window with which the user is currently working). The system assigns a slightly higher priority to the thread that creates the foreground window than it does to other threads.
        Returns:
        The return value is a handle to the foreground window. The foreground window can be NULL in certain circumstances, such as when a window is losing activation.

      • SetFocus

        WinDef.HWND SetFocus​(WinDef.HWND hWnd)
        Sets the keyboard focus to the specified window. The window must be attached to the calling thread's message queue.
        Parameters:
        hWnd - A handle to the window that will receive the keyboard input. If this parameter is NULL, keystrokes are ignored.
        Returns:
        If the function succeeds, the return value is the handle to the window that previously had the keyboard focus. If the hWnd parameter is invalid or the window is not attached to the calling thread's message queue, the return value is NULL. To get extended error information, call GetLastError.

      • SendInput

        WinDef.DWORD SendInput​(WinDef.DWORD nInputs,
                       WinUser.INPUT[] pInputs,
                       int cbSize)
        Synthesizes keystrokes, mouse motions, and button clicks.
        Parameters:
        nInputs - The number of structures in the pInputs array.
        pInputs - An array of INPUT structures. Each structure represents an event to be inserted into the keyboard or mouse input stream.
        cbSize - The size, in bytes, of an INPUT structure. If cbSize is not the size of an INPUT structure, the function fails.
        Returns:
        The function returns the number of events that it successfully inserted into the keyboard or mouse input stream. If the function returns zero, the input was already blocked by another thread. To get extended error information, call GetLastError. This function fails when it is blocked by UIPI. Note that neither GetLastError nor the return value will indicate the failure was caused by UIPI blocking.

      • WaitForInputIdle

        WinDef.DWORD WaitForInputIdle​(WinNT.HANDLE hProcess,
                              WinDef.DWORD dwMilliseconds)
        Waits until the specified process has finished processing its initial input and is waiting for user input with no input pending, or until the time-out interval has elapsed.
        Parameters:
        hProcess - A handle to the process. If this process is a console application or does not have a message queue, WaitForInputIdle returns immediately.
        dwMilliseconds - The time-out interval, in milliseconds. If dwMilliseconds is INFINITE, the function does not return until the process is idle.
        Returns:
        The following table shows the possible return values for this function.
        Possible return values
        Return code/value Description
        0 The wait was satisfied successfully.
        WAIT_TIMEOUT The wait was terminated because the time-out interval elapsed.
        WAIT_FAILED An error occurred.

      • InvalidateRect

        boolean InvalidateRect​(WinDef.HWND hWnd,
                       WinDef.RECT lpRect,
                       boolean bErase)
        The InvalidateRect function adds a rectangle to the specified window's update region. The update region represents the portion of the window's client area that must be redrawn.
        Parameters:
        hWnd - A handle to the window whose update region has changed. If this parameter is NULL, the system invalidates and redraws all windows, not just the windows for this application, and sends the WM_ERASEBKGND and WM_NCPAINT messages before the function returns. Setting this parameter to NULL is not recommended.
        lpRect - A pointer to a RECT structure that contains the client coordinates of the rectangle to be added to the update region. If this parameter is NULL, the entire client area is added to the update region.
        bErase - Specifies whether the background within the update region is to be erased when the update region is processed. If this parameter is TRUE, the background is erased when the BeginPaint function is called. If this parameter is FALSE, the background remains unchanged.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • RedrawWindow

        boolean RedrawWindow​(WinDef.HWND hWnd,
                     WinDef.RECT lprcUpdate,
                     WinDef.HRGN hrgnUpdate,
                     WinDef.DWORD flags)
        The RedrawWindow function updates the specified rectangle or region in a window's client area.
        Parameters:
        hWnd - A handle to the window to be redrawn. If this parameter is NULL, the desktop window is updated.
        lprcUpdate - A pointer to a RECT structure containing the coordinates, in device units, of the update rectangle. This parameter is ignored if the hrgnUpdate parameter identifies a region.
        hrgnUpdate - A handle to the update region. If both the hrgnUpdate and lprcUpdate parameters are NULL, the entire client area is added to the update region.
        flags - One or more redraw flags. This parameter can be used to invalidate or validate a window, control repainting, and control which windows are affected by RedrawWindow.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • GetWindow

        WinDef.HWND GetWindow​(WinDef.HWND hWnd,
                      WinDef.DWORD uCmd)
        Retrieves a handle to a window that has the specified relationship (Z-Order or owner) to the specified window.
        Parameters:
        hWnd - A handle to a window. The window handle retrieved is relative to this window, based on the value of the uCmd parameter.
        uCmd - The relationship between the specified window and the window whose handle is to be retrieved.
        Returns:
        If the function succeeds, the return value is a window handle. If no window exists with the specified relationship to the specified window, the return value is NULL. To get extended error information, call GetLastError.

      • UpdateWindow

        boolean UpdateWindow​(WinDef.HWND hWnd)
        The UpdateWindow function updates the client area of the specified window by sending a WM_PAINT message to the window if the window's update region is not empty. The function sends a WM_PAINT message directly to the window procedure of the specified window, bypassing the application queue. If the update region is empty, no message is sent.
        Parameters:
        hWnd - Handle to the window to be updated.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • ShowWindow

        boolean ShowWindow​(WinDef.HWND hWnd,
                   int nCmdShow)
        Sets the specified window's show state.
        Parameters:
        hWnd - A handle to the window.
        nCmdShow - Controls how the window is to be shown. This parameter is ignored the first time an application calls ShowWindow, if the program that launched the application provides a STARTUPINFO structure. Otherwise, the first time ShowWindow is called, the value should be the value obtained by the WinMain function in its nCmdShow parameter.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • CloseWindow

        boolean CloseWindow​(WinDef.HWND hWnd)
        Minimizes (but does not destroy) the specified window.
        Parameters:
        hWnd - A handle to the window to be minimized.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • RegisterHotKey

        boolean RegisterHotKey​(WinDef.HWND hWnd,
                       int id,
                       int fsModifiers,
                       int vk)
        Defines a system-wide hot key.
        Parameters:
        hWnd - A handle to the window that will receive
        id - The identifier of the hot key
        fsModifiers - The keys that must be pressed in combination with the key specified by the uVirtKey parameter in order to generate the
        vk - The virtual-key code of the hot key
        Returns:
        If the function succeeds, the return value is nonzero.

        If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError(). WinUser.WM_HOTKEY messages generated by the hot key WinUser.WM_HOTKEY message.

        A combination of the following values
        • WinUser.MOD_ALT Either ALT key must be held down.
        • WinUser.MOD_CONTROL Either CTRL key must be held down.
        • WinUser.MOD_NOREPEAT Changes the hotkey behavior so that the keyboard auto-repeat does not yield multiple hotkey notifications.

          Windows Vista and Windows XP/2000: This flag is not supported.

        • WinUser.MOD_SHIFT Either SHIFT key must be held down.
        • WinUser.MOD_WIN Either WINDOWS key was held down. These keys are labeled with the Windows logo.

      • UnregisterHotKey

        boolean UnregisterHotKey​(Pointer hWnd,
                         int id)
        Frees a hot key previously registered by the calling thread.
        Parameters:
        hWnd - A handle to the window associated with the hot key to be freed. This parameter should be NULL if the hot key is not associated with a window.
        id - The identifier of the hot key to be freed.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • GetLastInputInfo

        boolean GetLastInputInfo​(WinUser.LASTINPUTINFO plii)
        Retrieves the time of the last input event.
        Parameters:
        plii - structure that receives the time of the last input event
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • RegisterClassEx

        WinDef.ATOM RegisterClassEx​(WinUser.WNDCLASSEX lpwcx)
        Registers a window class for subsequent use in calls to the CreateWindow or CreateWindowEx function.
        Parameters:
        lpwcx - Type: const WNDCLASSEX* A pointer to a WNDCLASSEX structure. You must fill the structure with the appropriate class attributes before passing it to the function.
        Returns:
        If the function succeeds, the return value is a class atom that uniquely identifies the class being registered. This atom can only be used by the CreateWindow, CreateWindowEx, GetClassInfo, GetClassInfoEx, FindWindow, FindWindowEx, and UnregisterClass functions and the IActiveIMMap::FilterClientWindows method. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • UnregisterClass

        boolean UnregisterClass​(String lpClassName,
                        WinDef.HINSTANCE hInstance)
        Unregisters a window class, freeing the memory required for the class.
        Parameters:
        lpClassName - [in] Type: LPCTSTR A null-terminated string or a class atom. If lpClassName is a string, it specifies the window class name. This class name must have been registered by a previous call to the RegisterClass or RegisterClassEx function. System classes, such as dialog box controls, cannot be unregistered. If this parameter is an atom, it must be a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be in the low-order word of lpClassName; the high-order word must be zero.
        hInstance - [in,optional] Type: HINSTANCE A handle to the instance of the module that created the class. *
        Returns:
        Type: BOOL If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • CreateWindowEx

        WinDef.HWND CreateWindowEx​(int dwExStyle,
                           String lpClassName,
                           String lpWindowName,
                           int dwStyle,
                           int x,
                           int y,
                           int nWidth,
                           int nHeight,
                           WinDef.HWND hWndParent,
                           WinDef.HMENU hMenu,
                           WinDef.HINSTANCE hInstance,
                           WinDef.LPVOID lpParam)
        Creates an overlapped, pop-up, or child window with an extended window style; otherwise, this function is identical to the CreateWindow function. For more information about creating a window and for full descriptions of the other parameters of CreateWindowEx, see CreateWindow.
        Parameters:
        dwExStyle - [in] Type: DWORD The extended window style of the window being created. For a list of possible values,see Extended Window Styles.
        lpClassName - [in, optional] Type: LPCTSTR A null-terminated string or a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be in the low-order word of lpClassName; the high-order word must be zero. If lpClassName is a string, it specifies the window class name. The class name can be any name registered with RegisterClass or RegisterClassEx, provided that the module that registers the class is also the module that creates the window. The class name can also be any of the predefined system class names.
        lpWindowName - [in, optional] Type: LPCTSTR The window name. If the window style specifies a title bar, the window title pointed to by lpWindowName is displayed in the title bar. When using CreateWindow to create controls, such as buttons, check boxes, and static controls, use lpWindowName to specify the text of the control. When creating a static control with the SS_ICON style, use lpWindowName to specify the icon name or identifier. To specify an identifier, use the syntax "#num".
        dwStyle - [in] Type: DWORD The style of the window being created. This parameter can be a combination of the window style values, plus the control styles indicated in the Remarks section.
        x - [in] Type: int The initial horizontal position of the window. For an overlapped or pop-up window, the x parameter is the initial x-coordinate of the window's upper-left corner, in screen coordinates. For a child window, x is the x-coordinate of the upper-left corner of the window relative to the upper-left corner of the parent window's client area. If x is set to CW_USEDEFAULT, the system selects the default position for the window's upper-left corner and ignores the y parameter. CW_USEDEFAULT is valid only for overlapped windows; if it is specified for a pop-up or child window, the x and y parameters are set to zero.
        y - [in] Type: int The initial vertical position of the window. For an overlapped or pop-up window, the y parameter is the initial y-coordinate of the window's upper-left corner, in screen coordinates. For a child window, y is the initial y-coordinate of the upper-left corner of the child window relative to the upper-left corner of the parent window's client area. For a list box y is the initial y-coordinate of the upper-left corner of the list box's client area relative to the upper-left corner of the parent window's client area. If an overlapped window is created with the WS_VISIBLE style bit set and the x parameter is set to CW_USEDEFAULT, then the y parameter determines how the window is shown. If the y parameter is CW_USEDEFAULT, then the window manager calls ShowWindow with the SW_SHOW flag after the window has been created. If the y parameter is some other value, then the window manager calls ShowWindow with that value as the nCmdShow parameter.
        nWidth - [in] Type: int The width, in device units, of the window. For overlapped windows, nWidth is the window's width, in screen coordinates, or CW_USEDEFAULT. If nWidth is CW_USEDEFAULT, the system selects a default width and height for the window; the default width extends from the initial x-coordinates to the right edge of the screen; the default height extends from the initial y-coordinate to the top of the icon area. CW_USEDEFAULT is valid only for overlapped windows; if CW_USEDEFAULT is specified for a pop-up or child window, the nWidth and nHeight parameter are set to zero.
        nHeight - [in] Type: int The height, in device units, of the window. For overlapped windows, nHeight is the window's height, in screen coordinates. If the nWidth parameter is set to CW_USEDEFAULT, the system ignores nHeight.
        hWndParent - [in, optional] Type: HWND A handle to the parent or owner window of the window being created. To create a child window or an owned window, supply a valid window handle. This parameter is optional for pop-up windows. To create a message-only window, supply HWND_MESSAGE or a handle to an existing message-only window.
        hMenu - [in, optional] Type: HMENU A handle to a menu, or specifies a child-window identifier, depending on the window style. For an overlapped or pop-up window, hMenu identifies the menu to be used with the window; it can be NULL if the class menu is to be used. For a child window, hMenu specifies the child-window identifier, an integer value used by a dialog box control to notify its parent about events. The application determines the child-window identifier; it must be unique for all child windows with the same parent window.
        hInstance - [in, optional] Type: HINSTANCE A handle to the instance of the module to be associated with the window.
        lpParam - [in, optional] Type: LPVOID Pointer to a value to be passed to the window through the CREATESTRUCT structure (lpCreateParams member) pointed to by the lParam param of the WM_CREATE message. This message is sent to the created window by this function before it returns. If an application calls CreateWindow to create a MDI client window, lpParam should point to a CLIENTCREATESTRUCT structure. If an MDI client window calls CreateWindow to create an MDI child window, lpParam should point to a MDICREATESTRUCT structure. lpParam may be NULL if no additional data is needed.
        Returns:
        Type: HWND If the function succeeds, the return value is a handle to the new window. If the function fails, the return value is NULL. To get extended error information, call GetLastError.

        This function typically fails for one of the following reasons:

        • an invalid parameter value
        • the system class was registered by a different module
        • The WH_CBT hook is installed and returns a failure code
        • if one of the controls in the dialog template is not registered, or its window window procedure fails WM_CREATE or WM_NCCREATE

      • DestroyWindow

        boolean DestroyWindow​(WinDef.HWND hWnd)
        Destroys the specified window. The function sends WM_DESTROY and WM_NCDESTROY messages to the window to deactivate it and remove the keyboard focus from it. The function also destroys the window's menu, flushes the thread message queue, destroys timers, removes clipboard ownership, and breaks the clipboard viewer chain (if the window is at the top of the viewer chain). If the specified window is a parent or owner window, DestroyWindow automatically destroys the associated child or owned windows when it destroys the parent or owner window. The function first destroys child or owned windows, and then it destroys the parent or owner window. DestroyWindow also destroys modeless dialog boxes created by the CreateDialog function.
        Parameters:
        hWnd - [in] Type: HWND A handle to the window to be destroyed.
        Returns:
        Type: BOOL If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • GetClassInfoEx

        boolean GetClassInfoEx​(WinDef.HINSTANCE hinst,
                       String lpszClass,
                       WinUser.WNDCLASSEX lpwcx)
        Retrieves information about a window class, including a handle to the small icon associated with the window class. The GetClassInfo function does not retrieve a handle to the small icon.
        Parameters:
        hinst - [in, optional] Type: HINSTANCE A handle to the instance of the application that created the class. To retrieve information about classes defined by the system (such as buttons or list boxes), set this parameter to NULL.
        lpszClass - [in] Type: LPCTSTR The class name. The name must be that of a preregistered class or a class registered by a previous call to the RegisterClass or RegisterClassEx function. Alternatively, this parameter can be a class atom created by a previous call to RegisterClass or RegisterClassEx. The atom must be in the low-order word of lpszClass; the high-order word must be zero.
        lpwcx - [out] Type: LPWNDCLASSEX A pointer to a WNDCLASSEX structure that receives the information about the class.
        Returns:
        Type: BOOL If the function finds a matching class and successfully copies the data, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError() .

      • DefWindowProc

        WinDef.LRESULT DefWindowProc​(WinDef.HWND hWnd,
                             int Msg,
                             WinDef.WPARAM wParam,
                             WinDef.LPARAM lParam)
        Calls the default window procedure to provide default processing for any window messages that an application does not process. This function ensures that every message is processed. DefWindowProc is called with the same parameters received by the window procedure.
        Parameters:
        hWnd - [in] Type: HWND A handle to the window procedure that received the message.
        Msg - [in] Type: UINT The message.
        wParam - [in] Type: WPARAM Additional message information. The content of this parameter depends on the value of the Msg parameter.
        lParam - [in] Type: LPARAM Additional message information. The content of this parameter depends on the value of the Msg parameter.
        Returns:
        Type: LRESULT The return value is the result of the message processing and depends on the message. If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • RegisterDeviceNotification

        WinUser.HDEVNOTIFY RegisterDeviceNotification​(WinNT.HANDLE hRecipient,
                                              Structure notificationFilter,
                                              int Flags)
        Registers the device or type of device for which a window will receive notifications.
        Parameters:
        hRecipient - [in] A handle to the window or service that will receive device events for the devices specified in the NotificationFilter parameter. The same window handle can be used in multiple calls to RegisterDeviceNotification. Services can specify either a window handle or service status handle.
        notificationFilter - [in] A pointer to a block of data that specifies the type of device for which notifications should be sent. This block always begins with the DEV_BROADCAST_HDR structure. The data following this header is dependent on the value of the dbch_devicetype member, which can be DBT_DEVTYP_DEVICEINTERFACE or DBT_DEVTYP_HANDLE. For more information, see Remarks.
        Flags - [in] This parameter can be one of the following values. DEVICE_NOTIFY_WINDOW_HANDLE0x00000000 The hRecipient parameter is a window handle. DEVICE_NOTIFY_SERVICE_HANDLE0x00000001 The hRecipient parameter is a service status handle. In addition, you can specify the following value. DEVICE_NOTIFY_ALL_INTERFACE_CLASSES0x00000004 Notifies the recipient of device interface events for all device interface classes. (The dbcc_classguid member is ignored.) This value can be used only if the dbch_devicetype member is DBT_DEVTYP_DEVICEINTERFACE.
        Returns:
        value If the function succeeds, the return value is a device notification handle. If the function fails, the return value is NULL. To get extended error information, call GetLastError.

      • UnregisterDeviceNotification

        boolean UnregisterDeviceNotification​(WinUser.HDEVNOTIFY Handle)
        Closes the specified device notification handle.
        Parameters:
        Handle - [in] Device notification handle returned by the RegisterDeviceNotification function.
        Returns:
        Return value If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • RegisterWindowMessage

        int RegisterWindowMessage​(String string)
        Defines a new window message that is guaranteed to be unique throughout the system. The message value can be used when sending or posting messages.
        Parameters:
        string - The message to be registered.
        Returns:
        If the message is successfully registered, the return value is a message identifier in the range 0xC000 through 0xFFFF.

        If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • MonitorFromPoint

        WinUser.HMONITOR MonitorFromPoint​(WinDef.POINT.ByValue pt,
                                  int dwFlags)
        Retrieves a handle to the display monitor that contains a specified point.
        Parameters:
        pt - A POINT structure that specifies the point of interest in virtual-screen coordinates.
        dwFlags - Determines the function's return value if the window does not intersect any display monitor. This parameter can be one of the following values.
        • MONITOR_DEFAULTTONEAREST
        • MONITOR_DEFAULTTONULL
        • MONITOR_DEFAULTTOPRIMARY
        Returns:
        If the point is contained by a display monitor, the return value is an HMONITOR handle to that display monitor. If the point is not contained by a display monitor, the return value depends on the value of dwFlags.

      • MonitorFromRect

        WinUser.HMONITOR MonitorFromRect​(WinDef.RECT lprc,
                                 int dwFlags)
        Retrieves a handle to the display monitor that has the largest area of intersection with a specified rectangle.
        Parameters:
        lprc - A pointer to a RECT structure that specifies the rectangle of interest in virtual-screen coordinates.
        dwFlags - Determines the function's return value if the window does not intersect any display monitor. This parameter can be one of the following values.
        • MONITOR_DEFAULTTONEAREST
        • MONITOR_DEFAULTTONULL
        • MONITOR_DEFAULTTOPRIMARY
        Returns:
        If the rectangle intersects one or more display monitor rectangles, the return value is an HMONITOR handle to the display monitor that has the largest area of intersection with the rectangle. If the rectangle does not intersect a display monitor, the return value depends on the value of dwFlags.

      • MonitorFromWindow

        WinUser.HMONITOR MonitorFromWindow​(WinDef.HWND hwnd,
                                   int dwFlags)
        Retrieves a handle to the display monitor that has the largest area of intersection with the bounding rectangle of a specified window.

        If the window is currently minimized, MonitorFromWindow uses the rectangle of the window before it was minimized.

        Parameters:
        hwnd - A handle to the window of interest.
        dwFlags - Determines the function's return value if the window does not intersect any display monitor. This parameter can be one of the following values.
        • MONITOR_DEFAULTTONEAREST
        • MONITOR_DEFAULTTONULL
        • MONITOR_DEFAULTTOPRIMARY
        Returns:
        If the window intersects one or more display monitor rectangles, the return value is an HMONITOR handle to the display monitor that has the largest area of intersection with the window. If the window does not intersect a display monitor, the return value depends on the value of dwFlags.

      • GetMonitorInfo

        WinDef.BOOL GetMonitorInfo​(WinUser.HMONITOR hMonitor,
                           WinUser.MONITORINFO lpmi)
        Retrieves information about a display monitor.
        Parameters:
        hMonitor - A handle to the display monitor of interest.
        lpmi - A pointer to a WinUser.MONITORINFO structure that receives information about the specified display monitor.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • GetMonitorInfo

        WinDef.BOOL GetMonitorInfo​(WinUser.HMONITOR hMonitor,
                           WinUser.MONITORINFOEX lpmi)
        Retrieves information about a display monitor.
        Parameters:
        hMonitor - A handle to the display monitor of interest.
        lpmi - A pointer to a WinUser.MONITORINFOEX structure that receives information about the specified display monitor.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • EnumDisplayMonitors

        WinDef.BOOL EnumDisplayMonitors​(WinDef.HDC hdc,
                                WinDef.RECT lprcClip,
                                WinUser.MONITORENUMPROC lpfnEnum,
                                WinDef.LPARAM dwData)
        Enumerates display monitors (including invisible pseudo-monitors associated with the mirroring drivers) that intersect a region formed by the intersection of a specified clipping rectangle and the visible region of a device context. EnumDisplayMonitors calls an application-defined MonitorEnumProc callback function once for each monitor that is enumerated. Note that GetSystemMetrics (SM_CMONITORS) counts only the display monitors.
        Parameters:
        hdc - A handle to a display device context that defines the visible region of interest. If this parameter is NULL, the hdcMonitor parameter passed to the callback function will be NULL, and the visible region of interest is the virtual screen that encompasses all the displays on the desktop.
        lprcClip - A pointer to a RECT structure that specifies a clipping rectangle. The region of interest is the intersection of the clipping rectangle with the visible region specified by hdc. If hdc is non-NULL, the coordinates of the clipping rectangle are relative to the origin of the hdc. If hdc is NULL, the coordinates are virtual-screen coordinates. This parameter can be NULL if you don't want to clip the region specified by hdc.
        lpfnEnum - A pointer to an application-defined callback function.
        dwData - Application-defined data that EnumDisplayMonitors passes directly to the lpfnEnum function.
        Returns:
        If the function succeeds, the return value is nonzero. If the function fails, the return value is zero.

      • GetWindowPlacement

        WinDef.BOOL GetWindowPlacement​(WinDef.HWND hwnd,
                               WinUser.WINDOWPLACEMENT lpwndpl)
        Retrieves the show state and the restored, minimized, and maximized positions of the specified window.
        Parameters:
        hwnd - A handle to the window.
        lpwndpl - A pointer to the WINDOWPLACEMENT structure that receives the show state and position information.
        Returns:
        The number of characters copied to the specified buffer indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • SetWindowPlacement

        WinDef.BOOL SetWindowPlacement​(WinDef.HWND hwnd,
                               WinUser.WINDOWPLACEMENT lpwndpl)
        Sets the show state and the restored, minimized, and maximized positions of the specified window.
        Parameters:
        hwnd - A handle to the window.
        lpwndpl - A pointer to a WINDOWPLACEMENT structure that specifies the new show state and window positions.
        Returns:
        The number of characters copied to the specified buffer indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • AdjustWindowRect

        WinDef.BOOL AdjustWindowRect​(WinDef.RECT lpRect,
                             WinDef.DWORD dwStyle,
                             WinDef.BOOL bMenu)
        Calculates the required size of the window rectangle, based on the desired client-rectangle size. The window rectangle can then be passed to the CreateWindow function to create a window whose client area is the desired size. To specify an extended window style, use the AdjustWindowRectEx function. A client rectangle is the smallest rectangle that completely encloses a client area. A window rectangle is the smallest rectangle that completely encloses the window, which includes the client area and the nonclient area. The AdjustWindowRect function does not add extra space when a menu bar wraps to two or more rows. The AdjustWindowRect function does not take the WS_VSCROLL or WS_HSCROLL styles into account. To account for the scroll bars, call the GetSystemMetrics function with SM_CXVSCROLL or SM_CYHSCROLL.
        Parameters:
        lpRect - A pointer to a RECT structure that contains the coordinates of the top-left and bottom-right corners of the desired client area. When the function returns, the structure contains the coordinates of the top-left and bottom-right corners of the window to accommodate the desired client area.
        dwStyle - The window style of the window whose required size is to be calculated. Note that you cannot specify the WS_OVERLAPPED style.
        bMenu - Indicates whether the window has a menu.
        Returns:
        The number of characters copied to the specified buffer indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • AdjustWindowRectEx

        WinDef.BOOL AdjustWindowRectEx​(WinDef.RECT lpRect,
                               WinDef.DWORD dwStyle,
                               WinDef.BOOL bMenu,
                               WinDef.DWORD dwExStyle)
        Calculates the required size of the window rectangle, based on the desired client-rectangle size. The window rectangle can then be passed to the CreateWindowEx function to create a window whose client area is the desired size. A client rectangle is the smallest rectangle that completely encloses a client area. A window rectangle is the smallest rectangle that completely encloses the window, which includes the client area and the nonclient area. The AdjustWindowRectEx function does not add extra space when a menu bar wraps to two or more rows. The AdjustWindowRectEx function does not take the WS_VSCROLL or WS_HSCROLL styles into account. To account for the scroll bars, call the GetSystemMetrics function with SM_CXVSCROLL or SM_CYHSCROLL.
        Parameters:
        lpRect - A pointer to a RECT structure that contains the coordinates of the top-left and bottom-right corners of the desired client area. When the function returns, the structure contains the coordinates of the top-left and bottom-right corners of the window to accommodate the desired client area.
        dwStyle - The window style of the window whose required size is to be calculated. Note that you cannot specify the WS_OVERLAPPED style.
        bMenu - Indicates whether the window has a menu.
        dwExStyle - The extended window style of the window whose required size is to be calculated.
        Returns:
        The number of characters copied to the specified buffer indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • ExitWindowsEx

        WinDef.BOOL ExitWindowsEx​(WinDef.UINT uFlags,
                          WinDef.DWORD dReason)
        Logs off the interactive user, shuts down the system, or shuts down and restarts the system. It sends the WM_QUERYENDSESSION message to all applications to determine if they can be terminated. When this function is called, the caller must specify whether or not applications with unsaved changes should be forcibly closed. If the caller chooses not to force these applications to close and an application with unsaved changes is running on the console session, the shutdown will remain in progress until the user logged into the console session aborts the shutdown, saves changes, closes the application, or forces the application to close. During this period, the shutdown may not be aborted except by the console user, and another shutdown may not be initiated. Calling this function with the value of the uFlags parameter set to EWX_FORCE avoids this situation. Remember that doing this may result in loss of data. To set a shutdown priority for an application relative to other applications in the system, use the SetProcessShutdownParameters function. During a shutdown or log-off operation, running applications are allowed a specific amount of time to respond to the shutdown request. If this time expires before all applications have stopped, the system displays a user interface that allows the user to forcibly shut down the system or to cancel the shutdown request. If the EWX_FORCE value is specified, the system forces running applications to stop when the time expires. If the EWX_FORCEIFHUNG value is specified, the system forces hung applications to close and does not display the dialog box. Console processes receive a separate notification message, CTRL_SHUTDOWN_EVENT or CTRL_LOGOFF_EVENT, as the situation warrants. A console process routes these messages to its HandlerRoutine function. ExitWindowsEx sends these notification messages asynchronously; thus, an application cannot assume that the console notification messages have been handled when a call to ExitWindowsEx returns. To shut down or restart the system, the calling process must use the Advapi32.AdjustTokenPrivileges(com.sun.jna.platform.win32.WinNT.HANDLE, boolean, com.sun.jna.platform.win32.WinNT.TOKEN_PRIVILEGES, int, com.sun.jna.platform.win32.WinNT.TOKEN_PRIVILEGES, com.sun.jna.ptr.IntByReference) function to enable the SE_SHUTDOWN_NAME privilege. For more information, see Running with Special Privileges.
        Parameters:
        uFlags - The shutdown type. This parameter must include one of EWX_HYBRID_SHUTDOWN, EWX_LOGOFF, EWX_POWEROFF, EWX_REBOOT, EWX_RESTARTAPPS, or EWX_SHUTDOWN. This parameter can optionally include one of EWX_FORCE or EWX_FORCEIFHUNG.
        dReason - The reason for initiating the shutdown. This parameter must be one of the system shutdown reason codes. If this parameter is zero, the SHTDN_REASON_FLAG_PLANNED reason code will not be set and therefore the default action is an undefined shutdown that is logged as "No title for this reason could be found". By default, it is also an unplanned shutdown. Depending on how the system is configured, an unplanned shutdown triggers the creation of a file that contains the system state information, which can delay shutdown. Therefore, do not use zero for this parameter.
        Returns:
        If the function succeeds, the return value is nonzero. Because the function executes asynchronously, a nonzero return value indicates that the shutdown has been initiated. It does not indicate whether the shutdown will succeed. It is possible that the system, the user, or another application will abort the shutdown. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • LockWorkStation

        WinDef.BOOL LockWorkStation()
        Locks the workstation's display. Locking a workstation protects it from unauthorized use. The LockWorkStation function is callable only by processes running on the interactive desktop. In addition, the user must be logged on, and the workstation cannot already be locked.
        Returns:
        If the function succeeds, the return value is nonzero. Because the function executes asynchronously, a nonzero return value indicates that the operation has been initiated. It does not indicate whether the workstation has been successfully locked. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetIconInfo

        boolean GetIconInfo​(WinDef.HICON hIcon,
                    WinGDI.ICONINFO piconinfo)
        Retrieves information about the specified icon or cursor.
        Parameters:
        hIcon - A handle to the icon or cursor.

        To retrieve information about a standard icon or cursor, specify one of the following values and use the MAKEINTRESOURCE macro to create this value: WinUser.IDC_APPSTARTING etc.

        piconinfo - A pointer to an ICONINFO structure. The function fills in the structure's members.
        Returns:
        If the function succeeds, the return value is true and the function fills in the members of the specified ICONINFO structure.

        If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • SendMessageTimeout

        WinDef.LRESULT SendMessageTimeout​(WinDef.HWND hWnd,
                                  int msg,
                                  WinDef.WPARAM wParam,
                                  WinDef.LPARAM lParam,
                                  int fuFlags,
                                  int uTimeout,
                                  WinDef.DWORDByReference lpdwResult)
        Sends the specified message to one or more windows.
        Parameters:
        hWnd - A handle to the window whose window procedure will receive the message.

        If this parameter is HWND_BROADCAST ((HWND)0xffff), the message is sent to all top-level windows in the system, including disabled or invisible unowned windows. The function does not return until each window has timed out. Therefore, the total wait time can be up to the value of uTimeout multiplied by the number of top-level windows.

        msg - The message to be sent.
        wParam - Any additional message-specific information.
        lParam - Any additional message-specific information.
        fuFlags - The behavior of this function. This parameter can be one or more of the following values: WinUser.SMTO_ABORTIFHUNG etc.
        uTimeout - The duration of the time-out period, in milliseconds. If the message is a broadcast message, each window can use the full time-out period. For example, if you specify a five second time-out period and there are three top-level windows that fail to process the message, you could have up to a 15 second delay.
        lpdwResult - The result of the message processing. The value of this parameter depends on the message that is specified.
        Returns:
        If the function succeeds, the return value is nonzero. SendMessageTimeout does not provide information about individual windows timing out if HWND_BROADCAST is used.

        If the function fails or times out, the return value is 0. To get extended error information, call GetLastError. If GetLastError returns ERROR_TIMEOUT, then the function timed out.

        Windows 2000: If Kernel32.GetLastError() returns 0, then the function timed out.

      • GetClassLongPtr

        BaseTSD.ULONG_PTR GetClassLongPtr​(WinDef.HWND hWnd,
                                  int nIndex)
        Retrieves the specified value from the WNDCLASSEX structure associated with the specified window.
        Parameters:
        hWnd - A handle to the window and, indirectly, the class to which the window belongs.
        nIndex - The value to be retrieved. To retrieve a value from the extra class memory, specify the positive, zero-based byte offset of the value to be retrieved. Valid values are in the range zero through the number of bytes of extra class memory, minus eight; for example, if you specified 24 or more bytes of extra class memory, a value of 16 would be an index to the third integer.To retrieve any other value from the WNDCLASSEX structure, specify one of the following values: WinUser.GCW_ATOM etc.
        Returns:
        If the function succeeds, the return value is the requested value.

        If the function fails, the return value is zero. To get extended error information, call Kernel32.GetLastError().

      • GetRawInputDeviceList

        int GetRawInputDeviceList​(WinUser.RAWINPUTDEVICELIST[] pRawInputDeviceList,
                          IntByReference puiNumDevices,
                          int cbSize)
        Parameters:
        pRawInputDeviceList - An array of WinUser.RAWINPUTDEVICELIST structures for the devices attached to the system. If (@code null}, the number of devices is returned in puiNumDevices
        puiNumDevices - If pRawInputDeviceList is null, the function populates this variable with the number of devices attached to the system; otherwise, this variable specifies the number of WinUser.RAWINPUTDEVICELIST structures that can be contained in the buffer to which pRawInputDeviceList points. If this value is less than the number of devices attached to the system, the function returns the actual number of devices in this variable and fails with ERROR_INSUFFICIENT_BUFFER.
        cbSize - The size of a WinUser.RAWINPUTDEVICELIST structure, in bytes.
        Returns:
        If the function is successful, the return value is the number of devices stored in the buffer pointed to by pRawInputDeviceList. On any other error, the function returns -1 and GetLastError returns the error indication.
        See Also:
        WinUser.RAWINPUTDEVICELIST.sizeof(), GetRawInputDeviceList

      • GetDesktopWindow

        WinDef.HWND GetDesktopWindow()
        Retrieves a handle to the desktop window. The desktop window covers the entire screen. The desktop window is the area on top of which other windows are painted.
        Returns:
        Type: HWND The return value is a handle to the desktop window.

      • PrintWindow

        boolean PrintWindow​(WinDef.HWND hWnd,
                    WinDef.HDC dest,
                    int flags)
        The PrintWindow function copies a visual window into the specified device context (DC), typically a printer DC.
        Parameters:
        hWnd - A handle to the window that will be copied.
        dest - A handle to the destination device context.
        flags - The drawing options. It can be one of the following values:
        PW_CLIENTONLY:
        Only the client area of the window is copied to hdcBlt. By default, the entire window is copied.
        Returns:
        If the function succeeds, it returns true (MSDN: a nonzero value). If the function fails, it returns false (MSDN: zero).

      • IsWindowEnabled

        boolean IsWindowEnabled​(WinDef.HWND hWnd)
        Determines whether the specified window is enabled for mouse and keyboard input.
        Parameters:
        hWnd - A handle to the window to be tested.
        Returns:
        If the window is enabled, the return value is true (nonzero).
        If the window is not enabled, the return value is false (zero).

      • IsWindow

        boolean IsWindow​(WinDef.HWND hWnd)
        Determines whether the specified window handle identifies an existing window.
        A thread should not use IsWindow for a window that it did not create because the window could be destroyed after this function was called.
        Further, because window handles are recycled the handle could even point to a different window.
        Parameters:
        hWnd - A handle to the window to be tested.
        Returns:
        If the window handle identifies an existing window, the return value is true (nonzero).
        If the window handle does not identify an existing window, the return value is false (zero).

      • FindWindowEx

        WinDef.HWND FindWindowEx​(WinDef.HWND parent,
                         WinDef.HWND child,
                         String className,
                         String window)
        Parameters:
        parent - Type: HWND
        A handle to the parent window whose child windows are to be searched.
        If hwndParent is NULL, the function uses the desktop window as the parent window. The function searches among windows that are child windows of the desktop.
        If hwndParent is HWND_MESSAGE, the function searches all message-only windows.
        child - Type: HWND
        A handle to a child window. The search begins with the next child window in the Z order. The child window must be a direct child window of hwndParent, not just a descendant window.
        If hwndChildAfter is NULL, the search begins with the first child window of hwndParent.
        Note that if both hwndParent and hwndChildAfter are NULL, the function searches all top-level and message-only windows.
        className - Type: LPCTSTR
        The class name or a class atom created by a previous call to the RegisterClass or RegisterClassEx function. The atom must be placed in the low-order word of lpszClass; the high-order word must be zero.
        If lpszClass is a string, it specifies the window class name. The class name can be any name registered with RegisterClass or RegisterClassEx , or any of the predefined control-class names, or it can be MAKEINTATOM(0x8000). In this latter case, 0x8000 is the atom for a menu class. For more information, see the Remarks section of this topic.
        window - Type: LPCTSTR
        The window name (the window's title). If this parameter is NULL, all window names match.
        Returns:
        If the function succeeds, the return value is a handle to the window that has the specified class and window names.
        If the function fails, the return value is NULL. To get extended error information, call GetLastError.

      • GetAncestor

        WinDef.HWND GetAncestor​(WinDef.HWND hwnd,
                        int gaFlags)
        Retrieves the handle to the ancestor of the specified window.
        Parameters:
        hwnd - A handle to the window whose ancestor is to be retrieved. If this parameter is the desktop window, the function returns NULL.
        gaFlags - The ancestor to be retrieved. This parameter can be one of the following values:
        • GA_PARENT (1) -- Retrieves the parent window. This does not include the owner, as it does with the GetParent function.
        • GA_ROOT (2) -- Retrieves the root window by walking the chain of parent windows..
        • GA_ROOTOWNER (3) -- Retrieves the owned root window by walking the chain of parent and owner windows returned by GetParent..
        Returns:
        The return value is the handle to the ancestor window.

      • GetCursorPos

        boolean GetCursorPos​(WinDef.POINT p)
        Retrieves the position of the mouse cursor, in screen coordinates.
        Parameters:
        p - lpPoint [out]
        Type: LPPOINT
        A pointer to a POINT structure that receives the screen coordinates of the cursor.
        Returns:
        Type: BOOL.
        Returns nonzero if successful or zero otherwise. To get extended error information, call GetLastError.

      • SetCursorPos

        boolean SetCursorPos​(long x,
                     long y)
        Moves the cursor to the specified screen coordinates.
        If the new coordinates are not within the screen rectangle set by the most recent ClipCursor function call, the system automatically adjusts the coordinates so that the cursor stays within the rectangle.
        Parameters:
        x - The new x-coordinate of the cursor, in screen coordinates.
        y - The new y-coordinate of the cursor, in screen coordinates.
        Returns:
        Type: BOOL.
        Returns nonzero if successful or zero otherwise. To get extended error information, call GetLastError.

      • SetWinEventHook

        WinNT.HANDLE SetWinEventHook​(int eventMin,
                             int eventMax,
                             WinDef.HMODULE hmodWinEventProc,
                             WinUser.WinEventProc winEventProc,
                             int processID,
                             int threadID,
                             int flags)
        Parameters:
        eventMin - Type: UINT
        Specifies the event constant for the lowest event value in the range of events that are handled by the hook function.
        This parameter can be set to EVENT_MIN to indicate the lowest possible event value.
        eventMax - Type: UINT
        Specifies the event constant for the highest event value in the range of events that are handled by the hook function.
        This parameter can be set to EVENT_MAX to indicate the highest possible event value.
        hmodWinEventProc - Type: HMODULE
        Handle to the DLL that contains the hook function at lpfnWinEventProc, if the WINEVENT_INCONTEXT flag is specified in the dwFlags parameter.
        If the hook function is not located in a DLL, or if the WINEVENT_OUTOFCONTEXT flag is specified, this parameter is NULL.
        winEventProc - Type: WINEVENTPROC
        Pointer to the event hook function. For more information about this function, see WinEventProc.
        processID - Type: DWORD
        Specifies the ID of the process from which the hook function receives events.
        Specify zero (0) to receive events from all processes on the current desktop.
        threadID - Type: DWORD
        Specifies the ID of the thread from which the hook function receives events.
        If this parameter is zero, the hook function is associated with all existing threads on the current desktop.
        flags - Type: UINT
        Flag values that specify the location of the hook function and of the events to be skipped.
        The following flags are valid:
        • WINEVENT_INCONTEXT: The DLL that contains the callback function is mapped into the address space of the process that generates the event.
          With this flag, the system sends event notifications to the callback function as they occur.
          The hook function must be in a DLL when this flag is specified.
          This flag has no effect when both the calling process and the generating process are not 32-bit or 64-bit processes, or when the generating process is a console application.
          For more information, see In-Context Hook Functions.
        • WINEVENT_OUTOFCONTEXT: The callback function is not mapped into the address space of the process that generates the event.
          Because the hook function is called across process boundaries, the system must queue events.
          Although this method is asynchronous, events are guaranteed to be in sequential order.
          For more information, see Out-of-Context Hook Functions.
        • WINEVENT_SKIPOWNPROCESS:
          Prevents this instance of the hook from receiving the events that are generated by threads in this process.
          This flag does not prevent threads from generating events.
        • WINEVENT_SKIPOWNTHREAD:
          Prevents this instance of the hook from receiving the events that are generated by the thread that is registering this hook.
        Returns:
        Type: HWINEVENTHOOK
        If successful, returns an HWINEVENTHOOK value that identifies this event hook instance. Applications save this return value to use it with the UnhookWinEvent function.
        If unsuccessful, returns zero.

      • UnhookWinEvent

        boolean UnhookWinEvent​(WinNT.HANDLE hook)
        Removes an event hook function created by a previous call to SetWinEventHook.
        Parameters:
        hook - Type: HWINEVENTHOOK
        Handle to the event hook returned in the previous call to SetWinEventHook.
        Returns:
        Type: BOOL If successful, returns TRUE; otherwise, returns FALSE.
        Three common errors cause this function to fail:
        The hWinEventHook parameter is NULL or not valid.
        The event hook specified by hWinEventHook was already removed.
        UnhookWinEvent is called from a thread that is different from the original call to SetWinEventHook.

      • CopyIcon

        WinDef.HICON CopyIcon​(WinDef.HICON hIcon)
        Copies the specified icon from another module to the current module.
        Parameters:
        hIcon - A handle to the icon to be copied.
        Returns:
        If the function succeeds, the return value is a handle to the duplicate icon.
        If the function fails, the return value is NULL. To get extended error information, call GetLastError.
        See Also:
        MSDN

      • GetClassLong

        int GetClassLong​(WinDef.HWND hWnd,
                 int nIndex)
        Retrieves the specified 32-bit (DWORD) value from the WNDCLASSEX structure associated with the specified window. Note If you are retrieving a pointer or a handle, this function has been superseded by the GetClassLongPtr function.
        (Pointers and handles are 32 bits on 32-bit Windows and 64 bits on 64-bit Windows.)
        Parameters:
        hWnd - A handle to the window and, indirectly, the class to which the window belongs.
        nIndex - The value to be retrieved. To retrieve a value from the extra class memory, specify the positive, zero-based byte offset of the value to be retrieved. Valid values are in the range zero through the number of bytes of extra class memory, minus four; for example, if you specified 12 or more bytes of extra class memory, a value of 8 would be an index to the third integer. To retrieve any other value from the WNDCLASSEX structure, specify one of the following values.
        GCW_ATOM: -32
        Retrieves an ATOM value that uniquely identifies the window class. This is the same atom that the RegisterClassEx function returns.
        GCL_CBCLSEXTRA: -20
        Retrieves the size, in bytes, of the extra memory associated with the class.
        GCL_CBWNDEXTRA: -18
        Retrieves the size, in bytes, of the extra window memory associated with each window in the class. For information on how to access this memory, see GetWindowLong.
        GCL_HBRBACKGROUND: -10
        Retrieves a handle to the background brush associated with the class.
        GCL_HCURSOR: -12
        Retrieves a handle to the cursor associated with the class.
        GCL_HICON: -14
        Retrieves a handle to the icon associated with the class.
        GCL_HICONSM: -34
        Retrieves a handle to the small icon associated with the class.
        GCL_HMODULE: -16
        Retrieves a handle to the module that registered the class.
        GCL_MENUNAME: -8
        Retrieves the address of the menu name string. The string identifies the menu resource associated with the class.
        GCL_STYLE: -26
        Retrieves the window-class style bits.
        GCL_WNDPROC: -24
        Retrieves the address of the window procedure, or a handle representing the address of the window procedure. You must use the CallWindowProc function to call the window procedure.
        Returns:
        Type: DWORD If the function succeeds, the return value is the requested value.
        If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • RegisterClipboardFormat

        int RegisterClipboardFormat​(String formatName)
        Registers a new clipboard format. This format can then be used as a valid clipboard format.
        Parameters:
        formatName - The name of the new format.
        Returns:
        If the function succeeds, the return value identifies the registered clipboard format.

        If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetActiveWindow

        WinDef.HWND GetActiveWindow()
        Retrieves the window handle to the active window attached to the calling thread's message queue.
        Returns:
        Type: HWND The return value is the handle to the active window attached to the calling thread's message queue. Otherwise, the return value is NULL.

      • SendMessage

        WinDef.LRESULT SendMessage​(WinDef.HWND hWnd,
                           int msg,
                           WinDef.WPARAM wParam,
                           WinDef.LPARAM lParam)
        Sends the specified message to a window or windows. The SendMessage function calls the window procedure for the specified window and does not return until the window procedure has processed the message. To send a message and return immediately, use the SendMessageCallback or SendNotifyMessage function. To post a message to a thread's message queue and return immediately, use the PostMessage or PostThreadMessage function.
        Parameters:
        hWnd - A handle to the window whose window procedure will receive the message. If this parameter is HWND_BROADCAST ((HWND)0xffff), the message is sent to all top-level windows in the system, including disabled or invisible unowned windows, overlapped windows, and pop-up windows; but the message is not sent to child windows. Message sending is subject to UIPI. The thread of a process can send messages only to message queues of threads in processes of lesser or equal integrity level.
        msg - The message to be sent. For lists of the system-provided messages, see System-Defined Messages.
        wParam - Additional message-specific information.
        lParam - Additional message-specific information.
        Returns:
        The return value specifies the result of the message processing; it depends on the message sent. Two classic usage : - with a WM_USER+x msg value : wParam and lParam are numeric values - with a WM_COPYDATA msg value : wParam is the length of the structure and lParam a pointer to a COPYDATASTRUCT

      • GetKeyboardLayoutList

        int GetKeyboardLayoutList​(int nBuff,
                          WinDef.HKL[] lpList)
        Retrieves the input locale identifiers (formerly called keyboard layout handles) corresponding to the current set of input locales in the system. The function copies the identifiers to the specified buffer.
        Parameters:
        nBuff - The maximum number of handles that the buffer can hold.
        lpList - A pointer to the buffer that receives the array of input locale identifiers.
        Returns:
        If the function succeeds, the return value is the number of input locale identifiers copied to the buffer or, if nBuff is zero, the return value is the size, in array elements, of the buffer needed to receive all current input locale identifiers. If the function fails, the return value is zero. To get extended error information, call GetLastError.

      • GetKeyboardLayout

        WinDef.HKL GetKeyboardLayout​(int idThread)
        Retrieves the active input locale identifier (formerly called the keyboard layout).
        Parameters:
        idThread - The identifier of the thread to query, or 0 for the current thread.
        Returns:
        The return value is the input locale identifier for the thread. The low word contains a Language Identifier for the input language and the high word contains a device handle to the physical layout of the keyboard.

      • GetKeyboardLayoutName

        boolean GetKeyboardLayoutName​(char[] pwszKLID)
        This function retrieves the name of the active keyboard layout.
        Parameters:
        pwszKLID - [in] Pointer to the buffer of at least WinUser.KL_NAMELENGTH characters that is to receive the name of the keyboard layout, including the terminating null character.
        Returns:
        Nonzero indicates success. Zero indicates failure. To get extended error information, call GetLastError.

      • VkKeyScanExA

        short VkKeyScanExA​(byte ch,
                   WinDef.HKL dwhkl)
        Translates a character to the corresponding virtual-key code and shift state. The function translates the character using the input language and physical keyboard layout identified by the input locale identifier.
        Parameters:
        ch - The character to be translated into a virtual-key code.
        dwhkl - Input locale identifier to use for translating the specified code. This parameter can be any input locale identifier previously returned by the #LoadKeyboardLayout() function.
        Returns:
        If the function succeeds, the low-order byte of the return value contains the virtual-key code and the high-order byte contains the shift state, which can be a combination of the following flag bits.
        1
        Either SHIFT key is pressed. Use WinUser.MODIFIER_SHIFT_MASK.
        2
        Either CTRL key is pressed. Use WinUser.MODIFIER_CTRL_MASK.
        4
        Either ALT key is pressed. Use WinUser.MODIFIER_ALT_MASK.
        8
        The Hankaku key is pressed. Use WinUser.MODIFIER_HANKAKU_MASK.
        16
        Reserved (defined by the keyboard layout driver). Use WinUser.MODIFIER_RESERVED1_MASK.
        32
        Reserved (defined by the keyboard layout driver). Use WinUser.MODIFIER_RESERVED2_MASK.
        If the function finds no key that translates to the passed character code, both the low-order and high-order bytes contain -1.

      • VkKeyScanExW

        short VkKeyScanExW​(char ch,
                   WinDef.HKL dwhkl)
        Translates a character to the corresponding virtual-key code and shift state. The function translates the character using the input language and physical keyboard layout identified by the input locale identifier.
        Parameters:
        ch - The character to be translated into a virtual-key code.
        dwhkl - Input locale identifier to use for translating the specified code. This parameter can be any input locale identifier previously returned by the #LoadKeyboardLayout() function.
        Returns:
        If the function succeeds, the low-order byte of the return value contains the virtual-key code and the high-order byte contains the shift state, which can be a combination of the following flag bits.
        1
        Either SHIFT key is pressed. Use WinUser.MODIFIER_SHIFT_MASK.
        2
        Either CTRL key is pressed. Use WinUser.MODIFIER_CTRL_MASK.
        4
        Either ALT key is pressed. Use WinUser.MODIFIER_ALT_MASK.
        8
        The Hankaku key is pressed. Use WinUser.MODIFIER_HANKAKU_MASK.
        16
        Reserved (defined by the keyboard layout driver). Use WinUser.MODIFIER_RESERVED1_MASK.
        32
        Reserved (defined by the keyboard layout driver). Use WinUser.MODIFIER_RESERVED2_MASK.
        If the function finds no key that translates to the passed character code, both the low-order and high-order bytes contain -1.

      • MapVirtualKeyEx

        int MapVirtualKeyEx​(int uCode,
                    int uMapType,
                    WinDef.HKL dwhkl)
        Translates (maps) a virtual-key code into a scan code or character value, or translates a scan code into a virtual-key code. The function translates the codes using the input language and an input locale identifier.
        Parameters:
        uCode - The virtual-key code or scan code for a key. How this value is interpreted depends on the value of the uMapType parameter. Starting with Windows Vista, the high byte of the uCode value can contain either 0xe0 or 0xe1 to specify the extended scan code.
        uMapType - The translation to perform. The value of this parameter depends on the value of the uCode parameter. One of WinUser.MAPVK_VK_TO_CHAR, WinUser.MAPVK_VK_TO_VSC, WinUser.MAPVK_VK_TO_VSC_EX, WinUser.MAPVK_VSC_TO_VK, WinUser.MAPVK_VSC_TO_VK_EX
        dwhkl - Input locale identifier to use for translating the specified code. This parameter can be any input locale identifier previously returned by the #LoadKeyboardLayout() function.
        Returns:
        The return value is either a scan code, a virtual-key code, or a character value, depending on the value of uCode and uMapType. If there is no translation, the return value is zero.

      • ToUnicodeEx

        int ToUnicodeEx​(int wVirtKey,
                int wScanCode,
                byte[] lpKeyState,
                char[] pwszBuff,
                int cchBuff,
                int wFlags,
                WinDef.HKL dwhkl)
        Translates the specified virtual-key code and keyboard state to the corresponding Unicode character or characters.
        Parameters:
        wVirtKey - The virtual-key code to be translated.
        wScanCode - The hardware scan code of the key to be translated. The high-order bit of this value is set if the key is up.
        lpKeyState - A pointer to a 256-byte array that contains the current keyboard state. Each element (byte) in the array contains the state of one key. If the high-order bit of a byte is set, the key is down.
        pwszBuff - The buffer that receives the translated Unicode character or characters. However, this buffer may be returned without being null-terminated even though the variable name suggests that it is null-terminated.
        cchBuff - The size, in characters, of the buffer pointed to by the pwszBuff parameter.
        wFlags - The behavior of the function. If bit 0 is set, a menu is active. If bit 2 is set, keyboard state is not changed (Windows 10, version 1607 and newer) All other bits (through 31) are reserved.
        dwhkl - Input locale identifier to use for translating the specified code. This parameter can be any input locale identifier previously returned by the #LoadKeyboardLayout() function.
        Returns:
        The function returns one of the following values.
        -1
        The specified virtual key is a dead-key character (accent or diacritic). This value is returned regardless of the keyboard layout, even if several characters have been typed and are stored in the keyboard state. If possible, even with Unicode keyboard layouts, the function has written a spacing version of the dead-key character to the buffer specified by pwszBuff. For example, the function writes the character SPACING ACUTE (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
        0
        The specified virtual key has no translation for the current state of the keyboard. Nothing was written to the buffer specified by pwszBuff.
        1
        One character was written to the buffer specified by pwszBuff.
        2≤value
        Two or more characters were written to the buffer specified by pwszBuff. The most common cause for this is that a dead-key character (accent or diacritic) stored in the keyboard layout could not be combined with the specified virtual key to form a single character. However, the buffer may contain more characters than the return value specifies. When this happens, any extra characters are invalid and should be ignored.

      • LoadString

        int LoadString​(WinDef.HINSTANCE hInstance,
               int uID,
               Pointer lpBuffer,
               int cchBufferMax)
        Loads a string resource from the executable file associated with a specified module, copies the string into a buffer, and appends a terminating null character.
        Parameters:
        hInstance - A handle to an instance of the module whose executable file contains the string resource. To get the handle to the application itself, call the GetModuleHandle function with NULL.
        uID - The identifier of the string to be loaded.
        lpBuffer - The buffer is to receive the string. Must be of sufficient length to hold a pointer (8 bytes).
        cchBufferMax - The size of the buffer, in characters. The string is truncated and null-terminated if it is longer than the number of characters specified. If this parameter is 0, then lpBuffer receives a read-only pointer to the resource itself.
        Returns:
        If the function succeeds, the return value is the number of characters copied into the buffer, not including the terminating null character, or zero if the string resource does not exist. To get extended error information, call GetLastError.