user.odl

来自「The code for this article was written fo」· ODL 代码 · 共 2,094 行 · 第 1/5 页

    entry("CallWindowProcA"),
    #else
    entry("CallWindowProc"),
    #endif
    helpstring("Passes message information to a specified window procedure"),
    ]
    LRESULT WINAPI CallWindowProc([in] WNDPROC lpPrevWndFunc,
                                  [in] HWND hwnd, [in] UINT Msg,
                                  [in] WPARAM wParam, [in] LPARAM lParam);

    // ****** Main window support ***

    /*
    void    WINAPI AdjustWindowRect(RECT FAR*, DWORD, BOOL);
    void    WINAPI AdjustWindowRectEx(RECT FAR*, DWORD, BOOL, DWORD);

    void    WINAPI ShowOwnedPopups([in] HWND hwnd, BOOL);

    // Obsolete functions
    BOOL    WINAPI OpenIcon([in] HWND hwnd);
    void    WINAPI CloseWindow([in] HWND hwnd);
    BOOL    WINAPI AnyPopup(void);
    */

    [
    usesgetlasterror,
    entry("FlashWindow"),
    helpstring("Flashes or unflashes a given window depending on fInvert")
    ]
    BOOL    WINAPI FlashWindow([in] HWND hwnd, [in] BOOL fInvert);

    [
    usesgetlasterror,
    entry("IsIconic"),
    helpstring("Tells whether a window is minimized")
    ]
    BOOL    WINAPI IsIconic([in] HWND hwnd);

    [
    usesgetlasterror,
    entry("IsZoomed"),
    helpstring("Tells whether a window is maximized"),
	helpcontext(357)
    ]
    BOOL    WINAPI IsZoomed([in] HWND hwnd);

    // ****** Window coordinate mapping and hit-testing **************************

    /*
    void    WINAPI ClientToScreen([in] HWND hwnd, POINT FAR*);
    void    WINAPI ScreenToClient([in] HWND hwnd, POINT FAR*);

    void    WINAPI MapWindowPoints([in] HWND hwnd hwndFrom, [in] HWND hwnd hwndTo, POINT FAR* lppt, UINT cpt);

    HWND    WINAPI WindowFromPoint(POINT);
    HWND    WINAPI ChildWindowFromPoint([in] HWND hwnd, POINT);
    */

    // ****** Window query and enumeration ******

    [
    usesgetlasterror,
    entry("GetDesktopWindow"),
    helpstring("Returns handle of desktop window"),
    ]
    HWND    WINAPI GetDesktopWindow();

    [
    #ifdef WIN32
    usesgetlasterror,
    entry("FindWindowA"),
    #else
    entry("FindWindow"),
    #endif
    helpstring("Finds a window by its class name and title"),
    ]
    HWND    WINAPI FindWindow([in] LPCSTR lpszClassName,
                              [in] LPCSTR lpszWindow);

    /* Omit
    typedef BOOL (CALLBACK* WNDENUMPROC)(HWND, LPARAM);

    BOOL    WINAPI EnumWindows(WNDENUMPROC, LPARAM);
    BOOL    WINAPI EnumChildWindows(HWND, WNDENUMPROC, LPARAM);
    BOOL    WINAPI EnumTaskWindows(HTASK, WNDENUMPROC, LPARAM);
    */

    [
    usesgetlasterror,
    entry("GetTopWindow"),
    helpstring("Gets handle of window at the top of the Z-order of a specified child window"),
    ]
    HWND    WINAPI GetTopWindow([in] HWND hwnd);

    [
    usesgetlasterror,
    entry("GetWindow"),
    helpstring("Gets handle of window with specified relationship (GW_HWNDFIRST, GW_HWNDLAST, GW_HWNDNEXT, GW_HWNDPREV, GW_OWNER, GW_CHILD)"),
    ]
    HWND    WINAPI GetWindow([in] HWND hwnd, [in] UINT uCmd);

    [
    usesgetlasterror,
    entry("GetNextWindow"),
    helpstring("Gets handle of next (GW_HWNDNEXT) or previous (GW_HWNDPREV) window in the Z-order"),
    ]
    HWND    WINAPI GetNextWindow([in] HWND hwnd, [in] UINT fuDirection);

    // ****** Omit Window property support *******

    /*
    BOOL    WINAPI SetProp(HWND, LPCSTR, HANDLE);
    HANDLE  WINAPI GetProp(HWND, LPCSTR);
    HANDLE  WINAPI RemoveProp(HWND, LPCSTR);

    typedef BOOL (CALLBACK* PROPENUMPROC)(HWND, LPCSTR, HANDLE);

    int     WINAPI EnumProps(HWND, PROPENUMPROC);
    */

    // ****** Window drawing support ********

    [
    usesgetlasterror,
    entry("GetDC"),
    helpstring("Gets client area DC of given window"),
    ]
    HDC     WINAPI GetDC([in] HWND hwnd);

    [
    usesgetlasterror,
    entry("ReleaseDC"),
    helpstring("Releases a DC obtained with GetDC or GetWindowDC"),
    ]
    int     WINAPI ReleaseDC([in] HWND hwnd, [in] HDC hdc);

    [
    usesgetlasterror,
    entry("GetWindowDC"),
    helpstring("Gets entire DC of given window"),
    ]
    HDC     WINAPI GetWindowDC([in] HWND hwnd);

    /*
    HDC     WINAPI GetDCEx(register HWND hwnd, HRGN hrgnClip, DWORD flags);
    */


    // ****** Window repainting ****


    /* Omit
    // BeginPaint() return structure
    typedef struct tagPAINTSTRUCT
    {
        HDC     hdc;
        BOOL    fErase;
        RECT    rcPaint;
        BOOL    fRestore;
        BOOL    fIncUpdate;
        BYTE    rgbReserved[16];
    } PAINTSTRUCT;
    typedef PAINTSTRUCT* PPAINTSTRUCT;
    typedef PAINTSTRUCT NEAR* NPPAINTSTRUCT;
    typedef PAINTSTRUCT FAR* LPPAINTSTRUCT;

    HDC     WINAPI BeginPaint([in] HWND hwnd, PAINTSTRUCT FAR*);
    void    WINAPI EndPaint([in] HWND hwnd, const PAINTSTRUCT FAR*);
    */

    /*
    void    WINAPI UpdateWindow([in] HWND hwnd);

    int     WINAPI ExcludeUpdateRgn([in] HDC hdc, [in] HWND hwnd);
    */

    [
    usesgetlasterror,
    entry("LockWindowUpdate"),
    helpstring("Disables drawing in the given window, or enables drawing in the locked window if NULL is passed"),
    ]
    BOOL    WINAPI LockWindowUpdate([in] HWND hwndLock);

    /*
    BOOL    WINAPI GetUpdateRect([in] HWND hwnd, RECT FAR*, BOOL);
    int     WINAPI GetUpdateRgn([in] HWND hwnd, HRGN, BOOL);

    void    WINAPI InvalidateRect([in] HWND hwnd, const RECT FAR*, BOOL);
    void    WINAPI ValidateRect([in] HWND hwnd, const RECT FAR*);

    void    WINAPI InvalidateRgn([in] HWND hwnd, HRGN, BOOL);
    void    WINAPI ValidateRgn([in] HWND hwnd, HRGN);

    BOOL    WINAPI RedrawWindow([in] HWND hwnd, const RECT FAR* lprcUpdate, HRGN hrgnUpdate, UINT flags);
    */

    // ****** Window scrolling *****

    /*
    void     WINAPI ScrollWindow([in] HWND hwnd, int, int, const RECT FAR*, const RECT FAR*);
    BOOL    WINAPI ScrollDC([in] HDC hdc, int, int, const RECT FAR*, const RECT FAR*, HRGN, RECT FAR*);

    int     WINAPI ScrollWindowEx([in] HWND hwnd hwnd, int dx, int dy,
                    const RECT FAR* prcScroll, const RECT FAR* prcClip,
                    HRGN hrgnUpdate, RECT FAR* prcUpdate, UINT flags);
    */

    // ****** Window activation ****

    [
    usesgetlasterror,
    entry("SetActiveWindow"),
    #ifdef WIN32
    helpstring("Makes the specified top level window the active window"),
    #else
    helpstring("Makes the specified top level window associated with the calling thread the active window"),
    #endif
    ]
    HWND    WINAPI SetActiveWindow([in] HWND hwnd);

    [
    usesgetlasterror,
    entry("GetActiveWindow"),
    helpstring("Gets the handle of the active window"),
    ]
    HWND    WINAPI GetActiveWindow(void);

    #ifdef WIN32
    [
    usesgetlasterror,
    entry("SetForegroundWindow"),
    helpstring("Activates the thread and the window of the specified window handle"),
    ]
    BOOL    WINAPI SetForegroundWindow([in] HWND hWnd);

    [
    usesgetlasterror,
    entry("GetForegroundWindow"),
    helpstring("Gets the handle of the foreground window"),
    ]
    HWND    WINAPI GetForegroundWindow(VOID);
    #endif


    /*
    HWND    WINAPI GetLastActivePopup([in] HWND hwnd);
    */

    // ****** Keyboard input support ********

    [
    usesgetlasterror,
    entry("SetFocus"),
    helpstring("Sets keyboard input focus to given window, returning previous focus window if successful"),
    ]
    HWND    WINAPI SetFocus([in] HWND hwnd);

    [
    usesgetlasterror,
    entry("GetFocus"),
    helpstring("Returns handle of window with keyboard input focus"),
    ]
    HWND    WINAPI GetFocus(void);

    [
    usesgetlasterror,
    entry("GetKeyState"),
    helpstring("Gets state of a Windows virtual keys"),
    ]
    short WINAPI GetKeyState([in] int nKeyState);

    [
    usesgetlasterror,
    entry("GetAsyncKeyState"),
    helpstring("Gets asynchronouse state of a Windows virtual keys"),
    ]
    short WINAPI GetAsyncKeyState([in] int nKeyState);

    [
    usesgetlasterror,
    entry("GetKeyboardState"),
    helpstring("Gets an array of 256 bytes representing the state of Windows virtual keys"),
    ]
    void    WINAPI GetKeyboardState([in] BYTE FAR* lpbKeyState);

    [
    usesgetlasterror,
    entry("SetKeyboardState"),
    helpstring("Sets an array of 256 bytes representing the state of Windows virtual keys"),
    ]
    void    WINAPI SetKeyboardState([out] BYTE FAR* lpbKeyState);

    // ****** Mouse input support **

    [
    usesgetlasterror,
    entry("SetCapture"),
    helpstring("Sets capture of all mouse events regardless of cursor position to the given window"),
    ]
    HWND    WINAPI SetCapture([in] HWND hwnd);

    [
    usesgetlasterror,
    entry("SetCapture"),
    helpstring("Releases mouse capture and restores normal mouse input processing"),
    ]
    void    WINAPI ReleaseCapture(void);

    [
    usesgetlasterror,
    entry("GetCapture"),
    helpstring("Gets the window handle (if any) that owns mouse capture"),
    ]
    HWND    WINAPI GetCapture(void);

    /*
    BOOL    WINAPI SwapMouseButton(BOOL);

    typedef struct tagMOUSEHOOKSTRUCT
    {
        POINT   pt;
        HWND    hwnd;
        UINT    wHitTestCode;
        DWORD   dwExtraInfo;
    } MOUSEHOOKSTRUCT;
    typedef MOUSEHOOKSTRUCT  FAR* LPMOUSEHOOKSTRUCT;
    */

    // ****** System modal window support *******

    /*
    HWND    WINAPI GetSysModalWindow(void);
    HWND    WINAPI SetSysModalWindow([in] HWND hwnd);
    */

    // ****** Omit Timer support ********

    /*
    typedef void (CALLBACK* TIMERPROC)(HWND, UINT, UINT, DWORD);

    UINT    WINAPI SetTimer(HWND, UINT, UINT, TIMERPROC);

    BOOL    WINAPI KillTimer(HWND, UINT);
    */

    // ****** Omit Accelerator support ******

    /*
    DECLARE_HANDLE(HACCEL);

    HACCEL  WINAPI LoadAccelerators([in] HINSTANCE hInst, LPCSTR);

    int     WINAPI TranslateAccelerator(HWND, HACCEL, MSG FAR*);
    */

    // ****** Menu support *********

    /*
    // Menu template header
    typedef struct
    {
        UINT    versionNumber;
        UINT    offset;
    } MENUITEMTEMPLATEHEADER;

    // Menu template item struct
    typedef struct
    {
        UINT    mtOption;
        UINT    mtID;
        char    mtString[1];
    } MENUITEMTEMPLATE;
    */

    [
    usesgetlasterror,
    entry("IsMenu"),
    helpstring("Tells whether a handle is a menu handle")
    ]
    BOOL    WINAPI IsMenu([in] HMENU hmenu);

    [
    usesgetlasterror,
    entry("CreateMenu"),
    helpstring("Creates an empty menu and returns its handle")
    ]
    HMENU   WINAPI CreateMenu(VOID);

    [
    usesgetlasterror,
    entry("CreatePopupMenu"),
    helpstring("Creates an empty pop-up menu and returns its handle")
    ]
    HMENU   WINAPI CreatePopupMenu(VOID);

    [
    #if WIN32
    usesgetlasterror,
    entry("LoadMenuA"),
    #else
    entry("LoadMenu"),
    #endif
    helpstring("Loads menu resource lpszMenuName into an instance"),
    ]
    HMENU   WINAPI LoadMenu([in] HINSTANCE hInst,
                            [in] LPCSTR lpszMenuName);

    [
    #if WIN32
    usesgetlasterror,
    entry("LoadMenuA"),
    #else
    entry("LoadMenu"),
    #endif
    helpstring("Loads menu resource idMenuName into an instance"),
    ]
    HMENU   WINAPI LoadMenuAsId([in] HINSTANCE hInst,
                                [in] LONG idMenuName);