window.h

/**
 * \file window.h
 * \author Wei Yongming <vincent@minigui.org>
 * \date 2002/01/26
 * 
 * \brief This file includes windowing interfaces of MiniGUI.
 *
 \verbatim

    This file is part of MiniGUI, a mature cross-platform windowing 
    and Graphics User Interface (GUI) support system for embedded systems
    and smart IoT devices.

    Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd.
    Copyright (C) 1998~2002, WEI Yongming

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Or,

    As this program is a library, any link to this program must follow
    GNU General Public License version 3 (GPLv3). If you cannot accept
    GPLv3, you need to be licensed from FMSoft.

    If you have got a commercial license of this program, please use it
    under the terms and conditions of the commercial license.

    For more information about the commercial license, please refer to
    <http://www.minigui.com/en/about/licensing-policy/>.

 \endverbatim
 */

/* 
 * $Id: window.h 13674 2010-12-06 06:45:01Z wanzheng $
 *
 *      MiniGUI for Linux/uClinux, eCos, uC/OS-II, VxWorks, 
 *      pSOS, ThreadX, NuCleus, OSE, and Win32.
 */

#ifndef _MGUI_WINDOW_H
#define _MGUI_WINDOW_H

#ifdef __cplusplus
extern "C" {
#endif  /* __cplusplus */

    /**
     * \defgroup msgs Messages
     * @{
     */

/* Definitions of common messages. */
#define MSG_NULLMSG         0x0000
#define MSG_SYNCMSG         0x0000

    /**
     * \defgroup mouse_msgs Mouse event messages
     * @{
     */

/* Group 1 from 0x0001 to 0x000F, the mouse messages. */
#define MSG_FIRSTMOUSEMSG   0x0001

/**
 * \def MSG_LBUTTONDOWN
 * \brief Left mouse button down message.
 *
 * This message is posted to the window when the user presses down
 * the left button of the mouse in the client area of the window.
 *
 * \code
 * MSG_LBUTTONDOWN
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_LBUTTONUP, key_defs
 *
 * Example:
 * \include buttondown.c
 */
#define MSG_LBUTTONDOWN     0x0001

/**
 * \def MSG_LBUTTONUP
 * \brief Left mouse button up message.
 *
 * This message is posted to the window when the user releases up
 * the left button of the mouse in the client area of the window.
 *
 * \code
 * MSG_LBUTTONUP
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_LBUTTONDOWN, key_defs
 */
#define MSG_LBUTTONUP       0x0002

/**
 * \def MSG_LBUTTONDBLCLK
 * \brief Left mouse button double clicked message.
 *
 * This message is posted to the window when the user double clicks
 * the left button of the mouse in the client area of the window.
 *
 * \code
 * MSG_LBUTTONDBLCLK
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_RBUTTONDBLCLK, key_defs
 */
#define MSG_LBUTTONDBLCLK   0x0003

/**
 * \def MSG_MOUSEMOVE
 * \brief The mouse moved message.
 *
 * This message is posted to the window when the user moves the mouse
 * in the client area of the window.
 *
 * \code
 * MSG_MOUSEMOVE
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa key_defs
 */
#define MSG_MOUSEMOVE       0x0004

/**
 * \def MSG_RBUTTONDOWN
 * \brief Right mouse button down message.
 *
 * This message is posted to the window when the user presses down
 * the right button of the mouse in the client area of the window.
 *
 * \code
 * MSG_RBUTTONDOWN
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_RBUTTONUP, key_defs
 *
 * Example:
 * \include buttondown.c
 */
#define MSG_RBUTTONDOWN     0x0005

/**
 * \def MSG_RBUTTONUP
 * \brief Right mouse button up message.
 *
 * This message is posted to the window when the user releases up
 * the right button of the mouse in the client area of the window.
 *
 * \code
 * MSG_RBUTTONUP
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_RBUTTONDOWN, key_defs
 */
#define MSG_RBUTTONUP       0x0006

/**
 * \def MSG_RBUTTONDBLCLK
 * \brief Right mouse button double clicked message.
 *
 * This message is posted to the window when the user double clicks
 * the right button of the mouse in the client area of the window.
 *
 * \code
 * MSG_RBUTTONDBLCLK
 * DWORD key_flags = (DWORD)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param key_flags The shift key status when this message occurred.
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_LBUTTONDBLCLK, key_defs
 */
#define MSG_RBUTTONDBLCLK   0x0007

#define MSG_NCMOUSEOFF      0x0007

/**
 * \def MSG_NCLBUTTONDOWN
 * \brief Left mouse button down message in the non-client area.
 *
 * This message is posted to the window when the user presses down
 * the left button of the mouse in the non-client area of the window.
 *
 * \code
 * MSG_NCLBUTTONDOWN
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCLBUTTONUP, MSG_NCHITTEST
 */
#define MSG_NCLBUTTONDOWN   0x0008

/**
 * \def MSG_NCLBUTTONUP
 * \brief Left mouse button up message in the non-client area.
 *
 * This message is posted to the window when the user releases up
 * the left button of the mouse in the non-client area of the window.
 *
 * \code
 * MSG_NCLBUTTONUP
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCLBUTTONDOWN, MSG_NCHITTEST
 */
#define MSG_NCLBUTTONUP     0x0009

/**
 * \def MSG_NCLBUTTONDBLCLK
 * \brief Left mouse button double clicked in the non-client area.
 *
 * This message is posted to the window when the user double clicks
 * the left button of the mouse in the non-client area of the window.
 *
 * \code
 * MSG_NCLBUTTONDBLCLK
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCRBUTTONDBLCLK, MSG_NCHITTEST
 */
#define MSG_NCLBUTTONDBLCLK 0x000A

/**
 * \def MSG_NCMOUSEMOVE
 * \brief Mouse moves in the non-client area.
 *
 * This message is posted to the window when the user moves the mouse
 * in the non-client area of the window.
 *
 * \code
 * MSG_NCMOUSEMOVE
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCHITTEST
 */
#define MSG_NCMOUSEMOVE     0x000B

/**
 * \def MSG_NCRBUTTONDOWN
 * \brief Right mouse button down message in the non-client area.
 *
 * This message is posted to the window when the user presses down
 * the right button of the mouse in the non-client area of the window.
 *
 * \code
 * MSG_NCRBUTTONDOWN
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCRBUTTONUP, MSG_NCHITTEST
 */
#define MSG_NCRBUTTONDOWN   0x000C

/**
 * \def MSG_NCRBUTTONUP
 * \brief Right mouse button up message in the non-client area.
 *
 * This message is posted to the window when the user releases up
 * the right button of the mouse in the non-client area of the window.
 *
 * \code
 * MSG_NCRBUTTONUP
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCRBUTTONDOWN, MSG_NCHITTEST
 */
#define MSG_NCRBUTTONUP     0x000D

/**
 * \def MSG_NCRBUTTONDBLCLK
 * \brief Right mouse button double clicked in the non-client area.
 *
 * This message is posted to the window when the user double clicks
 * the right button of the mouse in the non-client area of the window.
 *
 * \code
 * MSG_NCRBUTTONDBLCLK
 * int hit_code = (int)wParam;
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param hit_code The hit test code which tells the area of the mouse.
 * \param x_pos,y_pos The position of the mouse in window coordinates.
 *
 * \sa MSG_NCLBUTTONDBLCLK, MSG_NCHITTEST
 */
#define MSG_NCRBUTTONDBLCLK 0x000E

#define MSG_LASTMOUSEMSG    0x000F

    /** @} end of mouse_msgs */

    /**
     * \defgroup key_msgs Key event messages
     * @{
     */

/* Group 2 from 0x0010 to 0x001F, the key messages. */
#define MSG_FIRSTKEYMSG     0x0010

/**
 * \def MSG_KEYDOWN
 * \brief User presses a key down.
 *
 * This message is posted to the current active window when the user 
 * presses a key down.
 *
 * \code
 * MSG_KEYDOWN
 * int scancode = (int)wParam;
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param scancode The scan code of the pressed key.
 * \param key_flags The shift key status when this message occurred.
 *
 * \sa MSG_KEYUP, key_defs
 *
 * Example:
 *
 * \include keydown.c
 */
#define MSG_KEYDOWN         0x0010

/**
 * \def MSG_CHAR
 * \brief A character translated from MSG_KEYDOWN message.
 *
 * This message is translated from a MSG_KEYDOWN message by \a TranslateMessage 
 * and sent to the current active window.
 *
 * \code
 * MSG_CHAR
 * unsigned char ch_buff [4];
 * unsigned char ch_buff [0] = FIRSTBYTE(wParam);
 * unsigned char ch_buff [1] = SECONDBYTE(wParam);
 * unsigned char ch_buff [2] = THIRDBYTE(wParam);
 * unsigned char ch_buff [3] = FOURTHBYTE(wParam);
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param ch_buff The buffer to store the bytes of the character.
 * \param key_flags The shift key status when this message occurred.
 *
 * \note Please use \a FIRSTBYTE ~ \a FOURTHBYTE to get the bytes
 *       if the character is a multi-byte character. Use MSG_UTF8CHAR
 *       to handle the characters encoded in UTF-8.
 *
 * \sa MSG_SYSCHAR, TranslateMessage, key_defs
 */
#define MSG_CHAR            0x0011

/**
 * \def MSG_KEYUP
 * \brief User releases up a key.
 *
 * This message is posted to the current active window when the user 
 * releases up a key.
 *
 * \code
 * MSG_KEYUP
 * int scancode = (int)wParam;
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param scancode The scan code of the released key.
 * \param key_flags The shift key status when this message occurred.
 *
 * \sa MSG_KEYDOWN, key_defs
 */
#define MSG_KEYUP           0x0012

/**
 * \def MSG_SYSKEYDOWN
 * \brief User presses down a key when \<Alt\> key is down.
 *
 * This message is posted to the current active window when the user 
 * presses down a key as \<Alt\> key is down.
 *
 * \code
 * MSG_SYSKEYDOWN
 * int scancode = (int)wParam;
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param scancode The scan code of the pressed key.
 * \param key_flags The shift key status when this message occurred.
 *
 * \sa MSG_SYSKEYUP, MSG_SYSCHAR, key_defs
 */
#define MSG_SYSKEYDOWN      0x0013

/**
 * \def MSG_SYSCHAR
 * \brief A system character translated from MSG_SYSKEYDOWN message.
 *
 * This message is translated from a MSG_SYSKEYDOWN message by 
 * \a TranslateMessage and sent to the current active window.
 *
 * \code
 * MSG_SYSCHAR
 * int ch = (int)wParam;
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param ch The ASCII code of the pressed key.
 * \param key_flags The shift key status when this message occurred.
 *
 * \sa MSG_CHAR, TranslateMessage, key_defs
 */
#define MSG_SYSCHAR         0x0014

/**
 * \def MSG_SYSKEYUP
 * \brief User releases up a key when \<Alt\> key is down.
 *
 * This message is posted to the current active window when the user 
 * releases up a key as \<Alt\> key is down.
 *
 * \code
 * MSG_SYSKEYUP
 * int scancode = (int)wParam;
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param scancode The scan code of the released key.
 * \param key_flags The shift key status when this message occurred.
 *
 * \sa MSG_SYSKEYDOWN, key_defs
 */
#define MSG_SYSKEYUP        0x0015


/* keyboard longpress supported */

/**
 * \def MSG_KEYLONGPRESS
 * \brief A key is long pressed.
 *
 * This message is sent when a key is pressed exceed user-defined long 
 * time value.
 */
#define MSG_KEYLONGPRESS    0x0016

/**
 * \def MSG_KEYALWAYSPRESS
 * \brief A key is always pressed.
 *
 * This message is sent when a key is pressed to exceed user-defined
 * always time value.
 */
#define MSG_KEYALWAYSPRESS  0x0017

/**
 * \def MSG_KEYSYM
 * \brief A key symbol translated from MSG_KEYDOWN messages.
 *
 * This message is translated from a MSG_KEYDOWN message by 
 * \a TranslateMessage and sent to the current active window.
 *
 * Note that one translation may generate a key symbol made by more than one 
 * character, e.g., when using default keymap, DEL key will generate the 
 * key symbol "^[[3~".
 *
 * \code
 * MSG_KEYSYM
 * int index = HIBYTE (wParam);
 * int keysym = LOBYTE (wParam);
 * DWORD key_flags = (DWORD)lParam;
 * \endcode
 *
 * \param index The index of the key symbol in one translation, 
 *        zero for a new translation, and the \a keysym is the first symbol.
 * \param keysym The code of the key symbol.
 * \param key_flags The shift key status when this message occurred.
 *
 * \sa MSG_SYSCHAR, TranslateMessage, key_defs
 */
#define MSG_KEYSYM          0x0018

/**
 * \def MSG_UTF8CHAR
 * \brief A character translated from MSG_KEYDOWN message.
 *
 * This message generally sent by a IME window to the current active window.
 * The chararcter will be encoded in UTF-8.
 *
 * \code
 * MSG_UTF8CHAR
 * unsigned char ch_utf8 [6];
 * unsigned char ch_utf8 [0] = FIRSTBYTE(wParam);
 * unsigned char ch_utf8 [1] = SECONDBYTE(wParam);
 * unsigned char ch_utf8 [2] = THIRDBYTE(wParam);
 * unsigned char ch_utf8 [3] = FOURTHBYTE(wParam);
 * unsigned char ch_utf8 [4] = FIRSTBYTE(lParam);
 * unsigned char ch_utf8 [5] = SECONDBYTE(lParam);
 * \endcode
 *
 * \param ch_utf8 The buffer to save the character in UTF-8.
 *
 * \sa MSG_CHAR, key_defs
 */
#define MSG_UTF8CHAR        0x0019

#define MSG_KEYUP_LONG    0x001A

#define MSG_MAINWIN_KEYDOWN         0x001B
#define MSG_MAINWIN_KEYUP           0x001C
#define MSG_MAINWIN_KEYLONGPRESS    0x001D
#define MSG_MAINWIN_KEYALWAYSPRESS  0x001E
#define MSG_MAINWIN_KEYUP_LONG      0x001F

/**
 * \def DEF_LPRESS_TIME
 * \brief Default long pressed time of a key.
 *
 * \sa MSG_KEYLONGPRESS
 */
#define DEF_LPRESS_TIME     500

/**
 * \def DEF_APRESS_TIME
 * \brief Default always pressed time of a key.
 *
 * \sa MSG_KEYALWAYSPRESS
 */
#define DEF_APRESS_TIME     1000
/**
 * \def DEF_INTERVAL_TIME
 * \brief Default send MSG_KEYLONGPRESS in interval value. 
 *
 */
#define DEF_INTERVAL_TIME   200

extern DWORD __mg_key_longpress_time;
extern DWORD __mg_key_alwayspress_time;
extern DWORD __mg_interval_time;

/**
 * \def SetKeyLongPressTime(time)
 * \brief User set default long pressed time of a key.
 */
#define SetKeyLongPressTime(time)       \
    do {                                \
        __mg_key_longpress_time = time; \
    } while (0)

/**
 * \def SetKeyAlwaysPressTime(time)
 * \brief User set default always pressed time of a key.
 */
#define SetKeyAlwaysPressTime(time)     \
    do {                                \
        __mg_key_alwayspress_time = time; \
    } while (0)

/**
 * \def SetIntervalTime(time)
 * \brief User set default interval time that MSG_KEYLONGPRESS is sent.
 */
#define SetIntervalTime(time)           \
    do {                                \
        __mg_interval_time = time;      \
    } while (0)

#define MSG_LASTKEYMSG      0x001F

    /** @} end of key_msgs */

    /**
     * \defgroup post_event_msgs User-machine Interaction messages
     * @{
     */

/* Group 3 from 0x0020 to 0x005F, User-machine Interaction messages. */
#define MSG_FIRSTPOSTMSG    0x0020

/**
 * \def MSG_SETCURSOR
 * \brief Sets cursor shape in the client area.
 *
 * This message is posted to the window under the cursor when the user moves
 * the mouse in order to give the chance to change the cursor shape.
 * The default handler set the cursor shape to the default cursor of the window.
 * If you set a new cursor shape, your message handler should return 
 * immediately.
 *
 * \code
 * MSG_SETCURSOR
 * int cx = LOSWORD (lParam);
 * int cy = HISWORD (lParam);
 * \endcode
 *
 * \param cx,cy The client coordinates of the cursor.
 *
 * Example:
 *
 * \include setcursor.c
 *
 * \sa MSG_NCSETCURSOR
 */
#define MSG_SETCURSOR       0x0020
    
    #define HT_MASK             0xFF

    #define HT_UNKNOWN          0x00
    #define HT_OUT              0x01
    #define HT_MENUBAR          0x02
    #define HT_TRANSPARENT      0x03
    
    #define HT_BORDER           0x04
    #define HT_CLIENT           0x0C
    
    #define HT_NEEDCAPTURE      0x10
    #define HT_ICON             0x14
    #define HT_CLOSEBUTTON      0x15
    #define HT_MAXBUTTON        0x16
    #define HT_MINBUTTON        0x17
    #define HT_HSCROLL          0x18
    #define HT_VSCROLL          0x19
    
    #define HT_DRAGGABLE        0x20
    #define HT_CAPTION          0x20
    
    /*indicate cursor at border */
    #define HT_BORDER_MASK      0x28
    #define HT_BORDER_TOP       0x28
    #define HT_BORDER_BOTTOM    0x29
    #define HT_BORDER_LEFT      0x2A
    #define HT_BORDER_RIGHT     0x2B
    
    /*indicate cursor at border corner*/
    #define HT_CORNER_MASK      0x2C
    #define HT_CORNER_TL        0x2C
    #define HT_CORNER_TR        0x2D
    #define HT_CORNER_BL        0x2E
    #define HT_CORNER_BR        0x2F
    
    /*new scrollbar hittest value
     * can be AND'ed with HT_NEEDCAPTURE*/
    #define HT_SB_MASK          0x50

    #define HT_SB_LEFTARROW     0x50
    #define HT_SB_RIGHTARROW    0x51
    #define HT_SB_LEFTSPACE     0x52
    #define HT_SB_RIGHTSPACE    0x53
    #define HT_SB_HTHUMB        0x54
    
    #define HT_SB_VMASK         0x58

    #define HT_SB_UPARROW       0x58
    #define HT_SB_DOWNARROW     0x59
    #define HT_SB_UPSPACE       0x5a
    #define HT_SB_DOWNSPACE     0x5b
    #define HT_SB_VTHUMB        0x5c
    
    #define HT_SB_UNKNOWN       0x5f
    
/*user defined hittest code are 0x80 ~ 0x8F*/
#define HT_USER_MASK            0x80


/**
 * \def MSG_NCHITTEST
 * \brief Hit test in non-client area. 
 * This is an async message.
 */
#define MSG_NCHITTEST       0x0021      

/**
 * \def MSG_HITTEST
 * \brief Hit test in non-client area. 
 *
 * \sa MSG_NCHITTEST
 */
#define MSG_HITTEST         MSG_NCHITTEST

/**
 * \def MSG_CHANGESIZE
 * \brief Change window size.
 */
#define MSG_CHANGESIZE      0x0022

/* reserved */
#define MSG_QUERYNCRECT     0x0023

/**
 * \def MSG_QUERYCLIENTAREA
 * \brief Query client area. 
 */
#define MSG_QUERYCLIENTAREA 0x0024

/**
 * \def MSG_SIZECHANGING
 * \brief Indicates the size of the window is being changed.
 *
 * This message is sent to the window when the size is being changed.
 * If you want to control the actual position and size of the window when 
 * the size is being changed (this may be caused by \a MoveWindow or 
 * other functions), you should handle this message, and return the actual
 * position and size of the window through the second parameter.
 *
 * \code
 * MSG_SIZECHANGING
 * const RECT* rcExpect = (const RECT*)wParam;
 * RECT* rcResult = (RECT*)lParam;
 * \endcode
 *
 * \param rcExpect The expected size of the window after changing.
 * \param rcResult The actual size of the window after changing.
 *
 * Example:
 *
 * \include msg_sizechanging.c
 */
#define MSG_SIZECHANGING    0x0025

/**
 * \def MSG_SIZECHANGED
 * \brief Indicates the size of the window has been changed.
 *
 * This message is sent to the window when the size has been changed.
 * If you want adjust the size of the client area of the window, 
 * you should handle this message, change the values of the client area,
 * and return non-zero value to indicate that the client area has been 
 * modified.
 *
 * \code
 * MSG_SIZECHANGED
 * RECT* rcClient = (RECT*)lParam;
 * \endcode
 *
 * \param rcClient The pointer to a RECT structure which contains 
 *        the new client area.
 * 
 * Example:
 *
 * \include msg_sizechanged.c
 */
#define MSG_SIZECHANGED     0x0026

/**
 * \def MSG_CSIZECHANGED
 * \brief Indicates the size of the client area of the window has been changed.
 *
 * This message is sent as a notification to the window when the size of 
 * the client area has been changed.  
 *
 * \code
 * MSG_CSIZECHANGED
 * int client_width = (int)wParam;
 * int client_height = (int)lParam;
 * \endcode
 * 
 * \param client_width The width of the client area.
 * \param client_height The height of the client area.
 */
#define MSG_CSIZECHANGED     0x0027

/**
 * \def MSG_SETFOCUS
 * \brief Indicates that the window has gained the input focus.
 *
 * \param lparam The parameter passed into used for pass setfocus 
 *        msg to child control if lparam > 0.
 *
 * This message is sent to the window procedure 
 * after the window gains the input focus.
 */
#define MSG_SETFOCUS        0x0030

/**
 * \def MSG_KILLFOCUS
 * \brief Indicates that the window has lost the input focus.
 *
 * \param lparam The parameter passed into used for pass killfocus 
 *        msg to child control if lparam > 0.
 *
 * This message is sent to the window procedure 
 * after the window losts the input focus.
 */
#define MSG_KILLFOCUS       0x0031

/**
 * \def MSG_MOUSEACTIVE
 * \brief Indicates that the window has gained the input focus because
 * the user clicked the window.
 *
 * This message is sent to the window procedure 
 * after the user clicked the window and it has gained the input focus.
 */
#define MSG_MOUSEACTIVE     0x0032

/**
 * \def MSG_ACTIVE
 * \brief Indicates that the window has gained the input focus because
 * the user clicked the window.
 *
 * This message is sent to the window procedure 
 * after the user clicked the window and it has gained the input focus.
 */
#define MSG_ACTIVE          0x0033

/**
 * \def MSG_CHILDHIDDEN
 * \brief Hide child window.
 */
#define MSG_CHILDHIDDEN     0x0034
    #define RCTM_CLICK          1
    #define RCTM_KEY            2
    #define RCTM_MESSAGE        3
    #define RCTM_SHOWCTRL       4

/**
 * \def MSG_ACTIVEMENU
 * \brief Indicates that the user activates the menu bar and tracks it.
 *
 * This message is sent to the window procedure when the user
 * activates the menu bar and tracks it.
 *
 * If you want to change the states of menu items in the submenu 
 * before displaying it, you can handle this message.
 *
 * \code
 * MSG_ACTIVEMENU
 * int pos = (int)wParam;
 * HMENU submenu = (HMENU)lParam;
 * \endcode
 * 
 * \param pos The position of the activated submenu. The position value of the 
 *        first submenu is 0.
 * \param submenu The handle to the activated submenu.
 *
 * Example:
 *
 * \include activemenu.c
 */
#define MSG_ACTIVEMENU      0x0040

/**
 * \def MSG_DEACTIVEMENU
 * \brief Indicates the end of the tracking of a menu bar or a popup menu.
 *
 * This message is sent to the window procedure when the user has
 * closed the tracking menu bar or popup menu.
 *
 * \code
 * MSG_DEACTIVEMENU
 * HMENU menubar = (HMENU)wParam;
 * HMENU submenu = (HMENU)lParam;
 * \endcode
 *
 * \param menubar The handle to the menu bar. It will be zero when the 
 *        deactivated menu is a popup menu.
 * \param submenu The handle to the submenu.
 */
#define MSG_DEACTIVEMENU    0x0041

/* Scroll bar notifying code */
    /**
     * \defgroup ctrl_scrollbar_ncs Notification codes of srollbar control
     * @{
     */

/**
 * \def SB_LINEUP
 * \brief The SB_LINEUP notification message is sent when the user clicked 
 * the up arrow on the bar.
 */
#define SB_LINEUP           0x01a

/**
 * \def SB_LINEDOWN
 * \brief The SB_LINEDOWN notification message is sent when the user clicked 
 * the down arrow on the bar.
 */
#define SB_LINEDOWN         0x02

/**
 * \def SB_LINELEFT
 * \brief The SB_LINELEFT notification message is sent when the user clicked 
 * the left arrow on the bar.
 */
#define SB_LINELEFT         0x03

/**
 * \def SB_LINERIGHT
 * \brief The SB_LINERIGHT notification message is sent when the user clicked 
 * the right arrow on the bar.
 */
#define SB_LINERIGHT        0x04

/**
 * \def SB_PAGEUP
 * \brief The SB_PAGEUP notification message is sent when the user clicked 
 * the page up area on the bar.
 */
#define SB_PAGEUP           0x05

/**
 * \def SB_PAGEDOWN
 * \brief The SB_PAGEDOWN notification message is sent when the user clicked 
 * the page down area on the bar.
 */
#define SB_PAGEDOWN         0x06

/**
 * \def SB_PAGELEFT
 * \brief The SB_PAGELEFT notification message is sent when the user clicked 
 * the page left area on the bar.
 */
#define SB_PAGELEFT         0x07

/**
 * \def SB_PAGERIGHT
 * \brief The SB_PAGERIGHT notification message is sent when the user clicked 
 * the page right area on the bar.
 */
#define SB_PAGERIGHT        0x08

/**
 * \def SB_THUMBPOSITION
 * \brief The SB_THUMBPOSITION notification message is sent when the user set 
 * a new thumb position.
 */
#define SB_THUMBPOSITION    0x09

/**
 * \def SB_THUMBTRACK
 * \brief The SB_THUMBTRACK notification message is sent when the user is 
 * draging and tracking the thumb.
 */
#define SB_THUMBTRACK       0x0A

/**
 * \def SB_TOP
 * \brief The SB_TOP notification message is sent when the user move thumb 
 * to minimum position 
 */
#define SB_TOP              0x0B

/**
 * \def SB_BOTTOM
 * \brief The SB_BOTTOM notification message is sent when the user move 
 * thumb to maximum position 
 */
#define SB_BOTTOM           0x0C

/**
 * \def SB_ENDSCROLL
 * \brief The SB_ENDSCROLL notification message is sent when the thumb at 
 * the end of bar 
 */
#define SB_ENDSCROLL        0x0D

     /** @} end of ctrl_scrollbar_ncs */
    
/**
 * \def MSG_HSCROLL
 * \brief Indicates that the user has clicked the horizontal scroll bar.
 *
 * This message is sent to the window procedure when the user has clicked
 * the horizontal scroll bar and changed the position of the thumb.
 *
 * \code
 * MSG_HSCROLL
 * int hs_nc = (int)wParam;
 * \endcode
 *
 * \param hs_nc The scrolling code, can be one of the following values:
 *      - SB_LINELEFT\n
 *        The user clicked the left arrow on the bar.
 *      - SB_LINERIGHT\n
 *        The user clicked the right arrow on the bar.
 *      - SB_PAGELEFT\n
 *        The user clicked the left page area on the bar.
 *      - SB_PAGERIGHT\n
 *        The user clicked the right page area on the bar.
 *      - SB_THUMBPOSITION\n
 *        The user set a new thumb position.
 *      - SB_THUMBTRACK\n
 *        The user is draging and tracking the thumb.
 *      - SB_ENDSCROLL\n
 *        The end of scrolling.
 */
#define MSG_HSCROLL         0x0042

/**
 * \def MSG_VSCROLL
 * \brief Indicates that the user has clicked the vertical scroll bar.
 *
 * This message is sent to the window procedure when the user has clicked
 * the vertical scroll bar and changed the position of the thumb.
 *
 * \code
 * MSG_HSCROLL
 * int vs_nc = (int)wParam;
 * \endcode
 *
 * \param vs_nc The scrolling code, can be one of the following values:
 *      - SB_LINEUP\n
 *        The user clicked the up arrow on the bar.
 *      - SB_LINEDOWN\n
 *        The user clicked the down arrow on the bar.
 *      - SB_PAGEUP\n
 *        The user clicked the up page area on the bar.
 *      - SB_PAGEDOWN\n
 *        The user clicked the down page area on the bar.
 *      - SB_THUMBPOSITION\n
 *        The user set a new thumb position.
 *      - SB_THUMBTRACK\n
 *        The user is draging and tracking the thumb.
 *      - SB_ENDSCROLL\n
 *        The end of scrolling.
 */
#define MSG_VSCROLL         0x0043

/**
 * \def MSG_NCSETCURSOR
 * \brief Sets cursor shape in the non-client area.
 *
 * This message is posted to the window under the cursor when the user moves
 * the mouse in order to give the chance to change the cursor shape.
 * The default handler set the cursor shape to the default cursor of the window.
 * If you set a new cursor shape, your message handler should return 
 * immediately.
 *
 * \sa MSG_SETCURSOR
 */
#define MSG_NCSETCURSOR     0x0044

/**
 * \def MSG_MOUSEMOVEIN
 * \brief Indicates the mouse is moved in/out the area of the window.
 *
 * This message is posted to the window when the user moves the mouse
 * in/out the area of the window.
 *
 * \code
 * MSG_MOUSEMOVEIN
 * BOOL in_out = (BOOL)wParam;
 * \endcode
 *
 * \param in_out Indicates whether the mouse has been moved in the window
 *      or out the window.
 */
#define MSG_MOUSEMOVEIN     0x0050

/** 
 * \def MSG_WINDOWDROPPED
 * \brief Indicates that user dropped window.
 * server to client; (wParam, lParam): result rectangle. 
 */
#define MSG_WINDOWDROPPED   0x0051

#define MSG_LASTPOSTMSG     0x005F

    /** @} end of post_event_msgs */

    /**
     * \defgroup creation_msgs Window creation messages
     * @{
     */

    /* Group 4 from 0x0060 to 0x009F, the creation messages. */
#define MSG_FIRSTCREATEMSG  0x0060

/**
 * \def MSG_CREATE
 * \brief Indicates the window has been created, and gives you a chance to initialize your private objects.
 *
 * This messages is sent to the window after the window has been created 
 * and registered to the system. You can initialize your own objects when 
 * you receive this message, and return zero to the system in order to 
 * indicates the success of your initialization. If you return non-zero to 
 * the system after handled this message, the created window will be 
 * destroyed immediately.
 *
 * \code
 * MSG_CREATE for main windows:
 * PMAINWINCREATE create_info = (PMAINWINCREATE)lParam;
 *
 * MSG_CREATE for controls:
 * HWND parent = (HWND)wParam;
 * DWORD add_data = (DWORD)lParam;
 * \endcode
 *
 * \param create_info The pointer to the MAINWINCREATE structure which is 
 *        passed to CreateMainWindow function.
 * \param parent The handle to the parent window of the control.
 * \param add_data The first additional data passed to CreateWindowEx function.
 *
 * \sa CreateMainWindow, CreateWindowEx, MAINWINCREATE
 */
#define MSG_CREATE          0x0060

/**
 * \def MSG_NCCREATE
 * \brief Indicates the window has been created, but has not registered to 
 *        the system.
 *
 * This message is sent to the window after the window has been created, 
 * but not registered the system. Like MSG_CREATE message, you can 
 * initialize your own objects when you receive this message, but can not 
 * create child windows of the window, and can not get a device context 
 * to paint.
 *
 * If you return non-zero to the system after handled this message, 
 * the created window will be destroyed immediately.
 *
 * \code
 * MSG_NCCREATE for main windows:
 * PMAINWINCREATE create_info = (PMAINWINCREATE)lParam;
 *
 * MSG_NCCREATE for controls:
 * DWORD add_data = (DWORD)lParam;
 * \endcode
 *
 * \param create_info The pointer to the MAINWINCREATE structure which is 
 *        passed to CreateMainWindow function.
 * \param add_data The first additional data passed to CreateWindowEx function.
 *
 * \sa CreateMainWindow, CreateWindowEx, MAINWINCREATE
 */
#define MSG_NCCREATE        0x0061

/*Not use*/
#define MSG_INITPANES       0x0062
#define MSG_DESTROYPANES    0x0063

/**
 * \def MSG_DESTROY
 * \brief Indicates the window will be destroyed.
 *
 * This message is sent to the window when \a DestroyMainWindow 
 * or \a DestroyWindow is calling. You can destroy your private objects
 * when receiving this message.
 *
 * If you return non-zero to the system after handle this message, the process 
 * of \a DestroyMainWindow and \a DestroyWindow will return immediately.
 *
 * \sa DestroyMainWindow, DestroyWindow
 */
#define MSG_DESTROY         0x0064

/* Not use */
#define MSG_NCDESTROY       0x0065

/**
 * \def MSG_CLOSE
 * \brief Indicates the user has clicked the closing box on the caption.
 *
 * This message is sent to the window when the user has clicked the closing box
 * on the caption of the window.
 */
#define MSG_CLOSE           0x0066

/* Not use */
#define MSG_NCCALCSIZE      0x0067

/* 
 * Not implemented, this message is reserved for future use.
 *
 * \def MSG_MAXIMIZE
 * \brief Indicates the user has clicked the maximizing box on the caption.
 *
 * This message is sent to the window when the user has clicked the maximizing
 * box on the caption of the window.
 */
#define MSG_MAXIMIZE        0x0068

/*
 * Not implemented, this message is reserved for future use.
 *
 * \def MSG_MINIMIZE
 * \brief Indicates the user has clicked the minimizing box on the caption.
 *
 * This message is sent to the window when the user has clicked the 
 * minimizing box on the caption of the window.
 */
#define MSG_MINIMIZE        0x0069

/*
 * Not implemented, this message is reserved for future use.
 *
 * \def MSG_HELP
 * \brief Indicates the user has clicked the help box on the caption.
 *
 * This message is sent to the window when the user has clicked the 
 * help box on the caption of the window.
 */
#define MSG_HELP            0x006A

#define MSG_LASTCREATEMSG   0x009F

    /** @} end of creation_msgs */

    /**
     * \defgroup paint_msgs Window painting messages
     * @{
     */

/* Group 5 from 0x00A0 to 0x00CF, the paint messages. */
#define MSG_FIRSTPAINTMSG   0x00A0

/**
 * \def MSG_SHOWWINDOW
 * \brief Indicates that the window has been shown or hidden.
 *
 * This message is sent to the window when the window has been shown
 * or hidden (due to the calling of the function ShowWindow).
 *
 * \code
 * MSG_SHOWWINDOW
 * int show_cmd = (int)wParam;
 * \endcode
 *
 * \param show_cmd The command to show or hide, can be one of 
 * the following values:
 *      - SW_SHOW\n
 *        Shows the window.
 *      - SW_HIDE\n
 *        Hides the window.
 *      - SW_SHOWNORMAL\n
 *        Shows the window, and if the window is a main window 
 *        sets it to be the topmost main window.
 *
 * \sa ShowWindow
 */
#define MSG_SHOWWINDOW      0x00A0 

/**
 * \def MSG_ERASEBKGND
 * \brief Sent to the window to erase the background.
 *
 * This message is sent to the window if the whole or a part of the background
 * should be erased.
 *
 * \code
 * MSG_ERASEBKGND
 * HDC hdc = (HDC)wParam;
 * const RECT* inv_rect = (const RECT*)lParam;
 * \endcode
 *
 * \param hdc The device context.
 * \param inv_rect The pointer to a RECT structure contains the rectangle
 *        should be erase. The rectangle is in client coordinates system. 
 *        If it is NULL, the whole client area should be erased.
 */
#define MSG_ERASEBKGND   	0x00B0      /* this is an async message */ 

/**
 * \def MSG_PAINT
 * \brief Sent to the window if the window contains an invalid region.
 *
 * This message is sent to the window if the window contains an invalid region.
 *
 * \code
 * MSG_PAINT
 * const CLIPRGN* inv_rgn = (const CLIPRGN*) lParam;
 * \endcode
 *
 * \param inv_rgn The pointer to the invalid region of the window.
 */
#define MSG_PAINT           0x00B1

/**
 * \def MSG_NCPAINT
 * \brief Indicates that paints non-client area. 
 *
 * \code
 * MSG_NCPAINT
 * HDC hdc = (HDC)wParam;
 * const RECT* inv_rect = (const RECT*)lParam;
 * \endcode
 *
 * \param hdc The device context.
 * \param inv_rect The pointer to a RECT structure contains the rectangle
 *        should be paint. The rectangle is in client coordinates system. 
 *        If it is NULL, the whole nc client area should be paint.
 */
#define MSG_NCPAINT         0x00B2

/**
 * \def MSG_NCACTIVATE
 * \brief Indicates that active non-client area of main window. 
 */
#define MSG_NCACTIVATE      0x00B3

/**
 * \def MSG_SYNCPAINT
 * \brief Indicates that actives and paints main window synchronously. 
 */
#define MSG_SYNCPAINT       0x00B4

#define MSG_LASTPAINTMSG    0x00CF

    /** @} end of paint_msgs */

    /**
     * \defgroup desktop_msgs Internal desktop messages
     * @{
     */

/* Group 6 from 0x00D0 to 0x00EF, the internal desktop messages. */
#define MSG_FIRSTSESSIONMSG 0x00D0

#define MSG_STARTSESSION    0x00D0
#define MSG_QUERYENDSESSION 0x00D1
#define MSG_ENDSESSION      0x00D2
#define MSG_REINITSESSION   0x00D3

#define MSG_ERASEDESKTOP    0x00DE
#define MSG_PAINTDESKTOP    0x00DF

#define MSG_DT_MOUSEOFF     0x00E0

/**
 * \def MSG_DT_LBUTTONDOWN
 * \brief Left mouse button down message on the desktop.
 *
 * This message is posted to the desktop window when the user presses down
 * the left button of the mouse in the area of the desktop window.
 *
 * \code
 * MSG_DT_LBUTTONDOWN
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in desktop coordinates.
 *
 * \sa MSG_DT_LBUTTONUP, MSG_LBUTTONDOWN
 */
#define MSG_DT_LBUTTONDOWN  0x00E1

/**
 * \def MSG_DT_LBUTTONUP
 * \brief Left mouse button up message on the desktop.
 *
 * This message is posted to the desktop window when the user releases up
 * the left button of the mouse in the area of the desktop window.
 *
 * \code
 * MSG_DT_LBUTTONUP
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in desktop coordinates.
 *
 * \sa MSG_DT_LBUTTONDOWN, MSG_LBUTTONUP 
 */
#define MSG_DT_LBUTTONUP    0x00E2

/**
 * \def MSG_DT_LBUTTONDBLCLK
 * \brief Left mouse button double clicked message on the desktop.
 *
 * This message is posted to the desktop window when the user double clicks
 * the left button of the mouse in the area of the desktop window.
 *
 * \code
 * MSG_DT_LBUTTONDBLCLK
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in client coordinates.
 *
 * \sa MSG_RBUTTONDBLCLK
 */
#define MSG_DT_LBUTTONDBLCLK    0x00E3

/**
 * \def MSG_DT_MOUSEMOVE
 * \brief The mouse moved message on the desktop.
 *
 * This message is posted to the desktop window when the user moves the mouse
 * in the area of the desktop window.
 *
 * \code
 * MSG_DT_MOUSEMOVE
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in desktop coordinates.
 *
 * \sa MSG_MOUSEMOVE
 */
#define MSG_DT_MOUSEMOVE    0x00E4

/**
 * \def MSG_DT_RBUTTONDOWN
 * \brief Right mouse button down message on the desktop.
 *
 * This message is posted to the desktop window when the user presses down
 * the right button of the mouse in the area of the desktop window.
 *
 * \code
 * MSG_DT_RBUTTONDOWN
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in desktop coordinates.
 *
 * \sa MSG_DT_RBUTTONUP, MSG_RBUTTONDOWN
 *
 */
#define MSG_DT_RBUTTONDOWN  0x00E5

/**
 * \def MSG_DT_RBUTTONUP
 * \brief Right mouse button up message on the desktop.
 *
 * This message is posted to the desktop window when the user releases up
 * the right button of the mouse in the area of the desktop window.
 *
 * \code
 * MSG_DT_RBUTTONUP
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in desktop coordinates.
 *
 * \sa MSG_DT_RBUTTONDOWN, MSG_RBUTTONUP
 */
#define MSG_DT_RBUTTONUP    0x00E6

/**
 * \def MSG_DT_RBUTTONDBLCLK
 * \brief Right mouse button double clicked message on the desktop.
 *
 * This message is posted to the desktop window when the user double clicks
 * the right button of the mouse in the area of the desktop window.
 *
 * \code
 * MSG_DT_RBUTTONDBLCLK
 * int x_pos = LOSWORD (lParam);
 * int y_pos = HISWORD (lParam);
 * \endcode
 *
 * \param x_pos,y_pos The position of the mouse in desktop coordinates.
 *
 * \sa MSG_LBUTTONDBLCLK
 */
#define MSG_DT_RBUTTONDBLCLK    0x00E7

#define MSG_DT_KEYOFF       0x00D8 

/**
 * \def MSG_DT_KEYDOWN
 * \brief User presses a key down on the desktop.
 *
 * This message is posted to the desktop window when the user 
 * presses a key down.
 *
 * \code
 * MSG_DT_KEYDOWN
 * int scancode = (int)wParam;
 * \endcode
 *
 * \param scancode The scan code of the pressed key.
 *
 * \sa MSG_DT_KEYUP
 *
 */
#define MSG_DT_KEYDOWN      0x00E8

/**
 * \def MSG_DT_KEYUP
 * \brief User releases up a key on the desktop.
 *
 * This message is posted to the desktop window when the user 
 * releases up a key.
 *
 * \code
 * MSG_DT_KEYUP
 * int scancode = (int)wParam;
 * \endcode
 *
 * \param scancode The scan code of the released key.
 *
 * \sa MSG_DT_KEYDOWN
 */
#define MSG_DT_KEYUP        0x00EA

#define MSG_DT_SYSKEYDOWN   0x00EB
#define MSG_DT_SYSKEYUP     0x00ED

#define MSG_DT_SYSCHAR      0x00EC
#define MSG_DT_CHAR         0x00E9

#define MSG_DT_KEYLONGPRESS     0x00EE
#define MSG_DT_KEYALWAYSPRESS   0x00EF

#define MSG_LASTSESSIONMSG  0x00EF

    /** @} end of desktop_msgs */

    /**
     * \defgroup window_msgs Internal window management messages
     * @{
     */

/* Group 7 from 0x00F0 to 0x010F, Internal window management messages. */
#define MSG_FIRSTWINDOWMSG  0x00F0

#define MSG_ADDNEWMAINWIN   0x00F0
#define MSG_REMOVEMAINWIN   0x00F1
#define MSG_MOVETOTOPMOST   0x00F2 
#define MSG_SETACTIVEMAIN   0x00F3
#define MSG_GETACTIVEMAIN   0x00F4
#define MSG_SHOWMAINWIN     0x00F5
#define MSG_HIDEMAINWIN     0x00F6
#define MSG_MOVEMAINWIN     0x00F7
#define MSG_SETCAPTURE      0x00F8
#define MSG_GETCAPTURE      0x00F9

#define MSG_ENDTRACKMENU    0x00FA
#define MSG_TRACKPOPUPMENU  0x00FB
#define MSG_CLOSEMENU       0x00FC
#define MSG_SCROLLMAINWIN   0x00FD
#define MSG_CARET_CREATE    0x00FE
#define MSG_CARET_DESTROY   0x00FF

#define MSG_ENABLEMAINWIN   0x0100
#define MSG_ISENABLED       0x0101

#define MSG_SETWINCURSOR    0x0102

#define MSG_GETNEXTMAINWIN  0x0103

#define MSG_SHOWGLOBALCTRL  0x010A
#define MSG_HIDEGLOBALCTRL  0x010B

typedef struct _DRAGINFO {
    int     location;
    int     init_x, init_y;
} DRAGINFO;

/* client to server; wParam: hwnd, lParam: DRAGINFO. */
#define MSG_STARTDRAGWIN    0x010C
/* client to server; wParam: hwnd, lParam: 0L. */
#define MSG_CANCELDRAGWIN   0x010D

#define MSG_CHANGECAPTION   0x010E

#define MSG_LASTWINDOWMSG   0x010F

    /** @} end of window_msgs */

    /**
     * \defgroup ctrl_msgs Dialog and control messages
     * @{
     */

/* Group 8 from 0x0120 to 0x013F, the dialog and control messages. */
#define MSG_FIRSTCONTROLMSG 0x0120

/**
 * \def MSG_COMMAND
 * \brief The command message, indicates a notification message from child 
 *        window, or the user has selected a menu item.
 *
 * This message sent to the window when the user has selected a menu item, or
 * a child window has sent a notification message to the parent.
 *
 * \code
 * MSG_COMMAND
 * int id = LOWORD(wParam);
 * int code = HIWORD(wParam);
 * HWND hwnd = (HWND)lParam;
 * \endcode
 *
 * \param id The identifier of the menu item or the child window.
 * \param code The notification code.
 * \param hwnd The handle to the control.
 *
 * \note If you use `MSG_COMMAND` message to handle the notification 
 *       sent from children controls, you should make sure the identifier
 *       value is small enough on 64-bit platform. If you use a pointer
 *       as the the identifier of a control, the code above will not work.
 *
 *       Instead, we recommend strongly that you use a NOTIFYPOROC 
 *       callback to handle the notification generated by controls. 
 *
 * \sa NotifyParentEx
 */
#define MSG_COMMAND         0x0120

/**
 * \def MSG_SYSCOMMAND
 * \brief The system command message.
 */
#define MSG_SYSCOMMAND      0x0121

/**
 * \def MSG_GETDLGCODE
 * \brief Get dialog code.
 */
#define MSG_GETDLGCODE      0x0122

/**
 * \def MSG_INITDIALOG
 * \brief Ready to initialize the controls in a dialog box.
 *
 * This message is sent to the dialog in order that you can initialize the 
 * controls in the dialog box.
 *
 * \code
 * MSG_INITDIALOG
 * HWND focus_hwnd = (HWND)wParam;
 * LPARAM lparam = (LPARAM)lParam;
 * \endcode
 *
 * \param focus_hwnd The handle to the control which will gain the input focus.
 * \param lparam The parameter passed into the dialog box 
 *        through \a DialogBoxIndirectParam function.
 *
 * \return Returns non-zero value to set the input focus to \a focus_hwnd, 
 *         else do not set focus.
 *
 * \sa DialogBoxIndirectParam
 *
 * Example:
 *
 * \include msg_initdialog.c
 */
#define MSG_INITDIALOG      0x0123

/*Reserved*/
#define MSG_NEXTDLGCTRL     0x0124
#define MSG_ENTERIDLE       0x0125

/**
 * \def MSG_DLG_GETDEFID
 * \brief Get default push button ID first.
 */
#define MSG_DLG_GETDEFID    0x0126

/**
 * \def MSG_DLG_SETDEFID
 * \brief Set default push button ID first.
 */
#define MSG_DLG_SETDEFID    0x0127

/* #define MSG_DLG_REPOSITION  0x0128 */

/**
 * \def MSG_ISDIALOG
 * \brief Sends to a window to query whether the window is a dialog window.
 *
 * \note This is a asynchronical message.
 */
#define MSG_ISDIALOG        0x0128

/**
 * \def MSG_INITPAGE
 * \brief Ready to initialize the controls in a property page.
 *
 * This message is sent to the page in order that you can initialize the 
 * controls in the page.
 *
 * \code
 * MSG_INITPAGE
 * DWORD add_data = (DWORD)lParam;
 * \endcode
 *
 * \param add_data The additional data in DLGTEMPLATE structure passed 
 *        through PSM_ADDPAGE message.
 *
 * \sa ctrl_propsheet
 */
#define MSG_INITPAGE        0x0129

/**
 * \def MSG_SHOWPAGE
 * \brief Indicates the page will be shown or hidden.
 *
 * This message is sent to the page when the page will be shown or hidden.
 *
 * \code
 * MSG_SHOWPAGE
 * HWND focus_hwnd = (HWND)wParam;
 * int show_cmd = (int)lParam;
 * \endcode
 *
 * \param focus_hwnd The handle to the child which will gain the input focus 
 *        if showing the page.
 * \param show_cmd The show command, can be one of the following values:
 *      - SW_SHOW\n The page will be shown.
 *      - SW_HIDE\n The page will be hidden.
 *
 * \sa ctrl_propsheet
 */
#define MSG_SHOWPAGE        0x012A

/**
 * \def MSG_SHEETCMD
 * \brief Indicates that a PSM_SHEETCMD message had been sent to the 
 * PropertySheet control.
 *
 * This message is sent to the property page when the property sheet contains 
 * the page received the PSM_SHEETCMD message.
 *
 * \code
 * MSG_SHEETCMD
 * WPARAM param1 = wParam;
 * LPARAM param2 = lParam;
 * \endcode
 *
 * \param param1 The wParam of PSM_SHEETCMD message.
 * \param param2 The lParam of PSM_SHEETCMD message.
 *
 * \sa ctrl_propsheet, PSM_SHEETCMD
 */
#define MSG_SHEETCMD        0x012B

/**
 * \def MSG_INITCONTAINER
 * \brief This message will be sent to the container window procedure after
 * the container window is created.
 *
 * This message is sent to the container in order that you can initialize the 
 * controls in the container.
 *
 * \code
 * MSG_INITCONTAINER
 * DWORD add_data = (DWORD)lParam;
 * \endcode
 *
 * \param add_data The additional data in \a CONTAINERINFO structure passed 
 *        through the argument of \a dwAddData when creating the ScrollView 
 *        control by calling CreateWindowEx.
 *
 * \sa ctrl_scrollview, CONTAINERINFO
 */
#define MSG_INITCONTAINER   0x012C

/**
 * \def MSG_SVCONTCMD
 * \brief This message will be sent to the parent of the ScrollView control 
 *        when the container of the ScrollView control reveived a MSG_COMMAND
 *        message.
 *
 * This message will be sent to the parent of the ScrollView when
 * the container of the ScrollView control reveived a MSG_COMMAND message.
 * Generally, the notification of the child control in the container will be
 * sent via MSG_COMMAND to the container. If you have not defined your own
 * window procedure for the container, this message gives a chance for the 
 * parent of the ScrollView control to handle the notifications come from 
 * the controls in the container.
 *
 * Note that you can also define your window procedure for the container, and
 * handle the notification from the child control in this procedure.
 *
 * \code
 * MSG_SVCONTCMD
 * WPARAM param1 = wParam;
 * WPARAM param2 = lParam;
 * \endcode
 *
 * \param param1 The wParam of MSG_COMMAND message.
 * \param param2 The lParam of MSG_COMMAND message.
 *
 * \sa ctrl_scrollview, MSG_COMMAND
 */
#define MSG_SVCONTCMD       0x012D

/**
 * \def MSG_FREEZECTRL
 * \brief You can send this message to freeze or thaw the paint action of 
 * the control.
 *
 * \code
 * MSG_FREEZECTRL
 * BOOL bFrozen;
 *
 * wParam = bFrozen
 * lParam = 0;
 *
 * \endcode
 *
 * \note Note that implemented only in scrollview and listview.
 *
 * \param bFrozen to freeze or to thaw.
 */
#define MSG_FREEZECTRL      0x012E

/**
 * \def MSG_FONTCHANGING
 * \brief Indicates the user is trying to change the font of the window.
 *
 * This message is sent to the window when the user is trying to change
 * the font of the window by calling \a SetWindowFont.
 * If you return non-zero after handling this message, \a SetWindowFont
 * will return immediately, i.e., the default window font will not change.
 *
 * \code
 * MSG_FONTCHANGING
 * PLOGFONT log_font = (PLOGFONT)lParam;
 * \endcode
 *
 * \param log_font The pointer to the new window logical font.
 *
 * \sa SetWindowFont
 */
#define MSG_FONTCHANGING    0x0130


/**
 * \def MSG_FONTCHANGED
 * \brief Indicates the window font has been changed.
 *
 * This message is sent to the window after the window font has changed.
 * Some window should be repainted to reflect the new window font.
 */
#define MSG_FONTCHANGED     0x0131

/**
 * \def MSG_GETTEXTLENGTH
 * \brief Sent to the control to get the length of the text.
 *
 * This message is sent to the control when you calling \a GetWindowTextLength
 * function to get the lenght of the text.
 *
 * \code
 * MSG_GETTEXTLENGTH
 * wParam = 0;
 * lParam = 0;
 * \endcode
 *
 * \return The length of the text.
 *
 * \sa GetWindowTextLength
 */
#define MSG_GETTEXTLENGTH   0x0132

/**
 * \def MSG_GETTEXT
 * \brief Sent to the control to get the text.
 *
 * This message is sent to the control when you calling \a GetWindowText
 * function to get the text.
 *
 * \code
 * MSG_GETTEXT
 * int max_len;
 * char* text_buf;
 *
 * wParam = (WPARAM)max_len;
 * lParam = (LPARAM)text_buf;
 * \endcode
 *
 * \param max_len The maximal number of characters can be copied to the buffer.
 * \param text_buf The pointer to a buffer receives the text.
 * \return The length of the window text string.
 *
 * \sa GetWindowText
 */
#define MSG_GETTEXT         0x0133

/**
 * \def MSG_SETTEXT
 * \brief Sent to the control to set the text.
 *
 * This message is sent to the control when you calling \a SetWindowText
 * function to set the text.
 *
 * \code
 * MSG_GETTEXT
 * char* text_buf;
 *
 * wParam = 0;
 * lParam = (LPARAM)text_buf;
 * \endcode
 *
 * \param text_buf The pointer to a buffer contains the text.
 * \return The return value is equal to zero if the text is set. 
 *
 * \sa SetWindowText
 */
#define MSG_SETTEXT         0x0134

/**
 * \def MSG_ENABLE
 * \brief Indicates the window is disabled/enabled.
 *
 * This message is sent to the window if the window has been disabled or enabled.
 *
 * \code
 * MSG_ENABLE
 * BOOL enabled = (BOOL)wParam;
 * \endcode
 *
 * \param enabled Indicates whether the window was disabled or enabled.
 */
#define MSG_ENABLE          0x0135

#define MSG_LASTCONTROLMSG  0x013F

    /** @} end of ctrl_msgs */

    /**
     * \defgroup system_msgs System messages
     * @{
     */

/* Group 9 from 0x0140 to 0x016F, the system messages. */
#define MSG_FIRSTSYSTEMMSG  0x0140

#define MSG_QUIT            0x0140

/**
 * \def MSG_IDLE
 * \brief Indicates the system enters idle loop.
 *
 * This message is sent to the all main windows when the system
 * enters idle loop.
 */
#define MSG_IDLE            0x0142

#define MSG_TIMEOUT         0x0143

/**
 * \def MSG_TIMER
 * \brief Indicates a timer has expired.
 *
 * This message is sent to the window when a timer expired.
 *
 * \code
 * MSG_TIMER
 * int timer_id = (int)wParam;
 * DWORD tick_count = (DWORD)lParam;
 * \endcode
 *
 * \param timer_id The identifier of the timer has expired.
 * \param tick_count The tick count when the timer had expired.
 */
#define MSG_TIMER           0x0144

#define MSG_CARETBLINK      0x0145

#ifndef _MGRM_THREADS

/**
 * \def MSG_FDEVENT
 * \brief Indicates an event of registered file descriptor occurred.
 *
 * You can use \a RegisterListenFD to register a file desciptor to 
 * MiniGUI-Processes for listening.
 *
 * When there is a read/write/except event on the fd, MiniGUI
 * will post a MSG_FDEVENT message with \a wParam being equal to
 * MAKELONG (fd, type), and the \a lParam being set to be the context
 * to the target window.
 *
 * \code
 * MSG_FDEVENT
 * int fd = LOWORD(wParam);
 * int type = HIWORD(wParam);
 * void* context = (void*)lParam;
 * \endcode
 *
 * \param fd The listened file descriptor.
 * \param type The event type.
 * \param context A context value.
 *
 * \note Only available on MiniGUI-Processes.
 *
 * \sa RegisterListenFD
 */
#define MSG_FDEVENT         0x0146

/**
 * \def MSG_SRVNOTIFY
 * \brief Indicates a notification from the server of MiniGUI-Processes.
 *
 * This message will be broadcasted to all of the main windows
 * in a client process when the client receives a MSG_SRVNOTIFY message
 * from the server.
 *
 * The server, i.e. 'mginit' defines the meaning of two parameters of 
 * this message.
 *
 * \note Only available on MiniGUI-Processes.
 */
#define MSG_SRVNOTIFY       0x0147

#ifdef _MGRM_PROCESSES
    #define MSG_UPDATECLIWIN    0x0148
#endif

#endif /* !_MGRM_THREADS */

/**
 * \def MSG_DOESNEEDIME
 * \brief Sends to a window to query whether the window needs to open 
 *        IME window.
 *
 * The system will send this message when the window gain the input focus
 * to determine whether the window needs to open IME window.
 *
 * The application should handle this message and return TRUE when
 * the window need IME window.  Default window procedure returns FALSE.
 *
 * \note This is an asynchronical message.
 */
#define MSG_DOESNEEDIME     0x0150

/* flag code. */
#define IME_STATUS_REGISTERED   0x0000
#define IME_STATUS_ENABLED      0x0001
#define IME_STATUS_AUTOTRACK    0x0002
#define IME_STATUS_LANGUAGE     0x0003
    #define IME_LANGUAGE_UNKNOWN    0x0000
    #define IME_LANGUAGE_LATIN      0x0001
    #define IME_LANGUAGE_ZHCN       0x0002
    #define IME_LANGUAGE_ZHTW       0x0003
#define IME_STATUS_ENCODING     0x0004
    #define IME_ENCODING_LOCAL      0x0000
    #define IME_ENCODING_UTF8       0x0001
#define IME_STATUS_VERSION          0x0005
#define IME_STATUS_USER_MIN         0x0006
#define IME_STATUS_USER_MAX         0x0020

/* IME edit type */
#define IME_WINDOW_TYPE_NOT_EDITABLE    0x0000
#define IME_WINDOW_TYPE_EDITABLE        0x0001
#define IME_WINDOW_TYPE_READONLY        0x0002
#define IME_WINDOW_TYPE_PASSWORD        0x0003

/*Internal use*/
#define MSG_IME_REGISTER    0x0151
#define MSG_IME_UNREGISTER  0x0152
#define MSG_IME_OPEN        0x0153
#define MSG_IME_CLOSE       0x0154
#define MSG_IME_SETSTATUS   0x0156
#define MSG_IME_GETSTATUS   0x0157
#define MSG_IME_SETTARGET   0x0158
#define MSG_IME_GETTARGET   0x0159
#define MSG_IME_SETPOS      0x015A
#define MSG_IME_GETPOS      0x015B

/*  new ime msg. */
#define MSG_IME_SET_TARGET_INFO   0x015C
#define MSG_IME_GET_TARGET_INFO   0x015D

#define MSG_SHOWMENU        0x0160
#define MSG_HIDEMENU        0x0161

#define MSG_ADDTIMER        0x0162
#define MSG_REMOVETIMER     0x0163
#define MSG_RESETTIMER      0x0164

#define MSG_WINDOWCHANGED   0x0165

#define MSG_BROADCASTMSG    0x0166

#define MSG_REGISTERWNDCLASS    0x0167
#define MSG_UNREGISTERWNDCLASS  0x0168
#define MSG_NEWCTRLINSTANCE     0x0169
#define MSG_REMOVECTRLINSTANCE  0x016A
#define MSG_GETCTRLCLASSINFO    0x016B
#define MSG_CTRLCLASSDATAOP     0x016C
    #define CCDOP_GETCCI        0x01
    #define CCDOP_SETCCI        0x02

#define MSG_REGISTERKEYHOOK     0x016D
#define MSG_REGISTERMOUSEHOOK   0x016E

#define MSG_LASTSYSTEMMSG   0x016F

    /** @} end of system_msgs */

    /**
     * \defgroup menu_msgs Internal menu messages
     * @{
     */

/* Group 10 from 0x0170 to 0x018F, the menu messages */
#define MSG_FIRSTMENUMSG    0x0170

/*Internal use*/
#define MSG_INITMENU        0x0170
#define MSG_INITMENUPOPUP   0x0171
#define MSG_MENUSELECT      0x0172
#define MSG_MENUCHAR        0x0173
#define MSG_ENTERMENULOOP   0x0174
#define MSG_EXITMENULOOP    0x0175
#define MSG_CONTEXTMENU     0x0176
#define MSG_NEXTMENU        0x0177

#define MSG_MAINWIN_REGISTER    0x0178
#define MSG_MAINWIN_UNREGISTER  0x0179

#define MSG_LASTMENUMSG     0x018F

    /** @} end of menu_msgs */

    /**
     * \defgroup user_msgs User-defined messages
     * @{
     */
#define MSG_DISPLAY_CHANGED 0x0200

#define MSG_FIRSTUSERMSG    0x0800


/**
 * \def MSG_USER
 * \brief The first user-defined message.
 *
 * MiniGUI reserved the range from 0x0800 to 0xEFFF for user-defined messages.
 * MSG_USER is the first user-defined message you can use it by your own.
 */
#define MSG_USER            0x0800

#define MSG_LASTUSERMSG     0xEFFF

    /** @} end of user_msgs */

    /** @} end of msgs */

    /**
     * \addtogroup fns Functions
     * @{
     */

    /**
     * \defgroup msg_fns Message functions
     * @{
     */

    /**
     * \defgroup msg_pass_fns Message passing functions
     * @{
     */

/**
 * The message structure.
 * \sa GetMessage, PostMessage, msgs
 */
typedef struct _MSG
{
    /** The handle to the window which receives this message. */
    HWND            hwnd;
    /** The message identifier. */
    UINT            message;
    /** The first parameter of the message (a unsigned integer with pointer precision). */
    WPARAM          wParam;
    /** The second parameter of the message (a unsigned integer with pointer precision). */
    LPARAM          lParam;
    /** Time */
    DWORD           time;
#ifdef _MGRM_THREADS
    /** Addtional data*/
    void*            pAdd;
#endif
} MSG;
typedef MSG* PMSG;

#define QS_NOTIFYMSG        0x10000000
#ifdef _MGRM_THREADS
  #define QS_SYNCMSG        0x20000000
#else
  #define QS_DESKTIMER      0x20000000
#endif
#define QS_POSTMSG          0x40000000
#define QS_QUIT             0x80000000
#define QS_INPUT            0x01000000
#define QS_PAINT            0x02000000
#define QS_TIMER            0x0000FFFF
#define QS_EMPTY            0x00000000

/**
 * \def PM_NOREMOVE
 *
 * \sa PeekMessage PeekMessageEx
 */
#define PM_NOREMOVE     0x0000

/**
 * \def PM_REMOVE
 *
 * \sa PeekMessage PeekMessageEx PeekPostMessage
 */
#define PM_REMOVE       0x0001

/**
 * \def PM_NOYIELD
 *
 * \sa PeekMessage PeekMessageEx PeekPostMessage
 */
#define PM_NOYIELD      0x0002

/**
 * \fn BOOL PeekMessageEx (PMSG pMsg, HWND hWnd, \
 *               UINT nMsgFilterMin, UINT nMsgFilterMax, \
 *               BOOL bWait, UINT uRemoveMsg)
 * \brief Peeks a message from the message queue of a main window.
 *
 * This functions peek a message from the message queue of the window \a hWnd;
 * if \a bWait is TRUE, it will wait for the message, else return immediatly.
 *
 * \param pMsg Pointer to the result message.
 * \param hWnd The handle to the window.
 * \param nMsgFilterMin The min identifier of the message that should be peeked.
 * \param nMsgFilterMax The max identifier of the message that should be peeked.
 * \param bWait Whether to wait for a message.
 * \param uRemoveMsg Whether remove the message from the message queue.
 *      Should be the following values:
 *      - PM_NOREMOVE\n
 *        Leave it in the message queue.
 *      - PM_REMOVE
 *        Remove it from the message queue.
 *      - PM_NOYIELD
 *        Nouse now.
 *        
 * \return TRUE if there is a message peeked, or FALSE.
 *
 * \sa GetMessage, PeekPostMessage, HavePendingMessage, PostMessage
 */               
MG_EXPORT BOOL GUIAPI PeekMessageEx (PMSG pMsg, HWND hWnd, 
                UINT nMsgFilterMin, UINT nMsgFilterMax, 
                BOOL bWait, UINT uRemoveMsg);

/**
 * \fn BOOL GetMessage (PMSG pMsg, HWND hMainWnd)
 * \brief Gets a message from the message queue of a main window.
 *
 * This function gets a message from the message queue of the main window 
 * \a hMainWnd, and returns until there is a message in the message queue.
 *
 * \param pMsg Pointer to the result message.
 * \param hMainWnd Handle to the window.
 *
 * \return FALSE on MSG_QUIT have been found or on error, else gets a message.
 *
 * \sa HavePendingMessage, PostQuitMessage, MSG
 *
 * Example:
 *
 * \include getmessage.c
 */
static inline BOOL GUIAPI GetMessage (PMSG pMsg, HWND hWnd)
{
    return PeekMessageEx (pMsg, hWnd, 0, 0, TRUE, PM_REMOVE);
}

/**
 * \fn BOOL WaitMessage (PMSG pMsg, HWND hMainWnd)
 * \brief Waits for a message from the message queue of a main window.
 *
 * This function waits for a message from the message queue of the main 
 * window \a hMainWnd, and returns until there is a message in the message 
 * queue. Unlike \a GetMessage, this function does not remove the message 
 * from the message queue.
 *
 * \param pMsg Pointer to the result message.
 * \param hMainWnd Handle to the window.
 *
 * \return 0 on MSG_QUIT have been found, else gets a message.
 *
 * \sa HavePendingMessage, PostQuitMessage, MSG
 */
MG_EXPORT BOOL GUIAPI WaitMessage (PMSG pMsg, HWND hMainWnd);

/**
 * \fn BOOL HavePendingMessage (HWND hMainWnd)
 * \brief Checks if there is any pending message in the message queue of 
 * a main window.
 *
 * This function checks whether there is any pending message in the
 * message queue of the main window \a hMainWnd.
 *
 * \param hMainWnd The handle to the main window.
 *
 * \return TRUE for pending message, FALSE for empty message queue.
 *
 * \sa GetMessage, MSG
 */
MG_EXPORT BOOL GUIAPI HavePendingMessage (HWND hMainWnd);

/**
 * \fn BOOL PeekMessage (PMSG pMsg, HWND hWnd, \
 *               UINT nMsgFilterMin, UINT nMsgFilterMax, UINT uRemoveMsg)
 * \brief Peeks a message from the message queue of a main window
 *
 * This functions peek a message from the message queue of the window \a hWnd 
 * and returns immediatly. Unlike \a GetMessage, this function does not wait 
 * for a message.
 *
 * \param pMsg Pointer to the result message.
 * \param hWnd The handle to the window.
 * \param nMsgFilterMin The min identifier of the message that should be peeked.
 * \param nMsgFilterMax The max identifier of the message that should be peeked.
 * \param uRemoveMsg Whether remove the message from the message queue.
 *      Should be the following values:
 *      - PM_NOREMOVE\n
 *        Leave it in the message queue.
 *      - PM_REMOVE
 *        Remove it from the message queue.
 *      - PM_NOYIELD
 *        Nouse now.
 *        
 * \return TRUE if there is a message peeked, or FALSE.
 *
 * \sa GetMessage, PeekPostMessage, HavePendingMessage, PostMessage
 */               
static inline BOOL GUIAPI PeekMessage (PMSG pMsg, HWND hWnd, UINT nMsgFilterMin, 
                         UINT nMsgFilterMax, UINT uRemoveMsg)
{
    return PeekMessageEx (pMsg, hWnd, nMsgFilterMin, nMsgFilterMax, 
                           FALSE, uRemoveMsg);
}

/**
 * \fn BOOL PeekPostMessage (PMSG pMsg, HWND hWnd, \
                UINT nMsgFilterMin, UINT nMsgFilterMax, UINT uRemoveMsg)
 * \brief Peeks a post message from the message queue of a main window
 *
 * This functions peek a message from the message queue of the window \a hWnd 
 * and returns immediatly. Unlike \a PeekMessage, this function only peek a 
 * post message.
 *
 * \param pMsg Pointer to the result message.
 * \param hWnd The handle to the window.
 * \param nMsgFilterMin The min identifier of the message that should be peeked.
 * \param nMsgFilterMax The max identifier of the message that should be peeked.
 * \param uRemoveMsg Whether remove the message from the message queue.
 *      Should be the following values:
 *      - PM_NOREMOVE\n
 *        Leave it in the message queue.
 *      - PM_REMOVE
 *        Remove it from the message queue.
 *      - PM_NOYIELD
 *        Nouse now.
 *        
 * \return TRUE if there is a message peeked, or FALSE.
 *
 * \sa GetMessage, PeekMessage, HavePendingMessage, PostMessage
 */               
MG_EXPORT BOOL GUIAPI PeekPostMessage (PMSG pMsg, HWND hWnd, UINT nMsgFilterMin, 
                UINT nMsgFilterMax, UINT uRemoveMsg);

/**
 * \fn int PostMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Posts a message into the message queue of a window and returns 
 * immediatly.
 *
 * This functions posts a message into the message queue of the window \a hWnd 
 * and returns immediately.
 *
 * \param hWnd The handle to the window.
 * \param nMsg The identifier of the message.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 * \return ERR_OK on success, < 0 on errors.
 *
 * \retval ERR_OK Post message successfully.
 * \retval ERR_QUEUE_FULL The message queue is full.
 * \retval ERR_INV_HWND Invalid window handle.
 *
 * \sa SendMessage
 */               
MG_EXPORT int GUIAPI PostMessage (HWND hWnd, UINT nMsg, 
                WPARAM wParam, LPARAM lParam);

/**
 * \fn LRESULT SendMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Sends a message to a window.
 *
 * This function sends a message to the window \a hWnd, and will return 
 * until the message-handling process returns.
 *
 * \param hWnd The handle to the window.
 * \param nMsg The identifier of the message.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 * \return The return value of the message handler.
 *
 * \sa PostMessage
 */
MG_EXPORT LRESULT GUIAPI SendMessage (HWND hWnd, UINT nMsg, 
                WPARAM wParam, LPARAM lParam);

/**
 * \fn void GUIAPI SetAutoRepeatMessage (HWND hwnd, UINT msg, \
            WPARAM wParam, LPARAM lParam)
 * \brief Sets the auto-repeat message.
 *
 * This function sets the auto-repeat message. When the default message
 * procedure receives an MSG_IDLE message, the default handler will send
 * the auto-repeat message to the target window as a notification message.
 *
 * \param hwnd The handle to the target window. Set it to zero
 *        to disable the auto-repeat message.
 * \param msg The identifier of the auto-repeat message.
 * \param wParam The first parameter of the auto-repeat message.
 * \param lParam The second parameter of the auto-repeat message.
 */
MG_EXPORT void GUIAPI SetAutoRepeatMessage (HWND hwnd, UINT msg, 
                WPARAM wParam, LPARAM lParam);

#ifndef _MGRM_THREADS

/**
 * \def SendAsyncMessage
 * \brief Is an alias of \a SendMessage for MiniGUI-Processes 
 *        and MiniGUI-Standalone.
 * \sa SendMessage
 */ 
#define SendAsyncMessage SendMessage

#ifdef _MGRM_PROCESSES

#define CLIENTS_TOPMOST          -1
#define CLIENTS_ALL              -2
#define CLIENTS_EXCEPT_TOPMOST   -3
#define CLIENT_ACTIVE            -4

/**
 * \fn int Send2Client (const MSG* msg, int cli)
 * \brief Sends a message to a client.
 *
 * This function sends a message to the specified client \a cli.
 *
 * \param msg The pointer to the message.
 * \param cli Either be the identifier of the targe client or one of the 
 *        following values:
 *      - CLIENT_ACTIVE\n
 *        The current active client on the topmost layer.
 *      - CLIENTS_TOPMOST\n
 *        All clients in the topmost layer.
 *      - CLIENTS_EXCEPT_TOPMOST\n
 *        All clients except clients in the topmost layer.
 *      - CLIENTS_ALL\n
 *        All clients.
 *
 * \return The number of bytes sent, < 0 on error.
 *
 * \retval SOCKERR_OK       Read data successfully.
 * \retval SOCKERR_IO       There are some I/O errors occurred.
 * \retval SOCKERR_CLOSED   The socket has been closed by the peer.
 * \retval SOCKERR_INVARG   You passed invalid arguments.
 *
 * \note This function is only defined for MiniGUI-Processes, and
 *       can be called only by the server, i.e. \a mginit.
 *
 * \sa Send2TopMostClients, Send2ActiveWindow
 */
int GUIAPI Send2Client (const MSG* msg, int cli);

/**
 * \fn BOOL Send2TopMostClients (UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Sends a message to all clients in the topmost layer.
 *
 * This function sends the message specified by (\a nMsg, \a wParam, \a lParam) 
 * to all clients in the topmost layer.
 *
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 * \return TRUE on success, FALSE on error.
 *
 * \note This function is only defined for MiniGUI-Processes, and
 *       can be called only by the server, i.e. \a mginit.
 *
 * \note The message will be sent to the virtual desktop of the target client.
 *
 * \sa Send2Client, Send2ActiveWindow
 */
BOOL GUIAPI Send2TopMostClients (UINT nMsg, WPARAM wParam, LPARAM lParam);

/**
 * \fn BOOL Send2ActiveWindow (const MG_Layer* layer, \
                 UINT nMsg, WPARAM wParam, LPARAM lParam);
 * \brief Sends a message to the active window in layer.
 *
 * This function sends the message specified by (\a nMsg, \a wParam, \a lParam) 
 * to the current active window in the specific layer (\a layer).
 *
 * \param layer The pointer to the layer.
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \note This function is only defined for MiniGUI-Processes, and
 *       can be called only by the server, i.e. \a mginit.
 *
 * \sa Send2Client
 */
BOOL GUIAPI Send2ActiveWindow (const MG_Layer* layer, 
                 UINT nMsg, WPARAM wParam, LPARAM lParam);

#endif /* _MGRM_PROCESSES */

#else /* !_MGRM_THREADS */

/**
 * \fn LRESULT PostSyncMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Posts a synchronical message to a window which is in different thread.
 *
 * This function posts the synchronical message specified by 
 * (\a nMsg, \a wParam, \a lParam) to the window \a hWnd which 
 * is in different thread. This function will return until 
 * the message is handled by the window procedure.
 *
 * \note The destination window must belong to other thread.
 *
 * \param hWnd The handle to the window.
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 * \return The return value of the message handler.
 *
 * \sa SendMessage
 */
MG_EXPORT LRESULT GUIAPI PostSyncMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam);

/**
 * \fn LRESULT SendAsyncMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Sends an asynchronical message to a window.
 *
 * This function sends the asynchronical message specified by 
 * (\a nMsg, \a wParam, \a lParam) to the window \a hWnd 
 * which is in different thread. This function calls 
 * the window procedure immediately, so it is very dangerous.
 *
 * \param hWnd The handle to the window.
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 * \return The return value of the message handler.
 *
 * \note This function may corrupt your data.
 *
 * \sa PostSyncMessage
 */
MG_EXPORT LRESULT GUIAPI SendAsyncMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam);
#endif

/**
 * \fn int SendNotifyMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Sends a notification message to a window.
 *
 * This function sends the notification message specified by 
 * (\a nMsg, \a wParam, \a lParam) to the window \a hWnd. This function 
 * puts the notication message in the message queue and then returns 
 * immediately.
 *
 * \param hWnd The handle to the window.
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 * \return 0 if all OK, < 0 on error.
 *
 * \sa SendMessage, PostMessage
 */
MG_EXPORT int GUIAPI SendNotifyMessage (HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam);

/**
 * \fn int BroadcastMessage (UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Broadcasts a message to all main window on the desktop.
 *
 * This function posts the message specified by (\a nMsg, \a wParam, \a lParam)
 * to all the main windows on the desktop.
 *
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 * \return 0 if all OK, < 0 on error.
 *
 * \sa PostMessage
 */
MG_EXPORT int GUIAPI BroadcastMessage (UINT nMsg, WPARAM wParam, LPARAM lParam);

/**
 * \fn int PostQuitMessage (HWND hWnd)
 * \brief Puts a MSG_QUIT message into the message queue of a main window.
 *
 * This function puts a MSG_QUIT message into the message queue of the
 * main window \a hWnd. The next call to \a GetMessage will return 0.
 *
 * \param hWnd The handle to the main window.
 * \return 0 if all OK, < 0 on error.
 *
 * \sa GetMessage
 */
MG_EXPORT int GUIAPI PostQuitMessage (HWND hWnd);

#define KBD_LAYOUT_DEFAULT  "default"
#define KBD_LAYOUT_FRPC     "frpc"
#define KBD_LAYOUT_FR       "fr"
#define KBD_LAYOUT_DE       "de"
#define KBD_LAYOUT_DELATIN1 "delatin1"
#define KBD_LAYOUT_IT       "it"
#define KBD_LAYOUT_ES       "es"
#define KBD_LAYOUT_ESCP850  "escp850"
#define KBD_LAYOUT_HEBREW   "hebrew"
#define KBD_LAYOUT_ARABIC   "arabic"

/**
 * \fn BOOL SetKeyboardLayout (const char* kbd_layout)
 * \brief Sets a new keyboard layout.
 *
 * This function sets the keymaps to translate key scancodes to MSG_CHAR
 * or MSG_KEYSYM messages. The default keymaps is for US PC keyboard 
 * layout, you can call this function to set a different keyboard layout.
 * The argument of \a kbd_layout specifies the name of the keyboard layout.
 *
 * \param kbd_layout The keyboard layout name. It can be 
 *        one of the following values:
 *
 *      - KBD_LAYOUT_DEFAULT\n
 *        The default keyboard layout, i.e., US PC.
 *      - KBD_LAYOUT_FRPC\n
 *        The France PC keyboard layout.
 *      - KBD_LAYOUT_FR\n
 *        The France keyboard layout.
 *      - KBD_LAYOUT_DE\n
 *        The German keyboard layout.
 *      - KBD_LAYOUT_DELATIN1\n
 *        The German Latin1 keyboard layout.
 *      - KBD_LAYOUT_IT\n
 *        The Italian keyboard layout.
 *      - KBD_LAYOUT_ES\n
 *        The Spanish keyboard layout.
 *      - KBD_LAYOUT_ESCP850\n
 *        The Spanish CP850 keyboard layout.
 *      - KBD_LAYOUT_HEBREW\n
 *        The hebrew keyboard layout.
 *      - KBD_LAYOUT_ARABIC\n
 *        The arabic keyboard layout.
 *
 * \return TRUE for success, otherwise FALSE.
 *
 * \sa TranslateMessage, MSG_CHAR, MSG_KEYSYM
 */
MG_EXPORT BOOL GUIAPI SetKeyboardLayout (const char* kbd_layout);

#ifdef _MGCHARSET_UNICODE

#include <stddef.h>
#include <stdlib.h>

MG_EXPORT int GUIAPI ToUnicode (UINT keycode, const BYTE* kbd_state, 
        wchar_t* wcs, int wcs_len, const char* kbd_layout);

MG_EXPORT int GUIAPI ToAscii (UINT keycode, const BYTE* kbd_state, 
        WORD* ch, const char* kbd_layout);

#endif /* _MGCHARSET_UNICODE */

/**
 * \fn BOOL TranslateMessage (PMSG pMsg)
 * \brief Translates key down and key up messages to MSG_CHAR 
 *        message and post it into the message queue.
 *
 * This function translates key down and key up message to an MSG_CHAR 
 * message or some MSG_KEYSYM messages, and send the message(s) to 
 * the window procedure as a notification message. If the message is 
 * not a key message, this function does nothing.
 *
 * The behavior of this function is inflected by the current
 * keyboard layout. The default keyboard layout is US PC keyboard, but
 * you can call \a SetKeyboardLayout function to set a different keyboard
 * layout.
 *
 * \param pMsg The pointer of message.
 * \return A boolean indicates whether the message is a key message.
 *
 * \sa SetKeyboardLayout, MSG_CHAR, MSG_KEYSYM
 */
MG_EXPORT BOOL GUIAPI TranslateMessage (PMSG pMsg);

/**
 * \fn BOOL GUIAPI TranslateKeyMsgToChar (int message, \
                WPARAM wParam, LPARAM lParam, WORD *ch)
 * \brief Translates a key down and key up message to a corresponding character.
 *
 * This function translates a key down and key up message to a character.
 * If the message is not a key message, this function does nothing.
 *
 * The behavior of this function is inflected by the current
 * keyboard layout. The default keyboard layout is US PC keyboard, but
 * you can call \a SetKeyboardLayout function to set a different keyboard
 * layout.
 *
 * \param message The type of message.
 * \param wParam Message parameter.
 * \param lParam Message parameter.
 * \param ch A string buffer for storing translated characters.
 *
 * \return A boolean indicates whether the message is a key message.
 *
 * \sa TranslateMessage
 */
MG_EXPORT BOOL GUIAPI TranslateKeyMsgToChar (int message, 
                WPARAM wParam, LPARAM lParam, WORD *ch);

/**
 * \fn LRESULT DispatchMessage (PMSG pMsg)
 * \brief Dispatches a message to the window's callback procedure.
 *
 * This function dispatches the message pointed to by \a pMsg to the
 * target window's callback procedure.
 *
 * \param pMsg The pointer to the message.
 * \return The return value of the message handler.
 *
 * \sa GetMessage
 *
 * Example:
 *
 * \include getmessage.c
 */
MG_EXPORT LRESULT GUIAPI DispatchMessage (PMSG pMsg);

/**
 * \fn int ThrowAwayMessages (HWND pMainWnd)
 * \brief Removes all messages in the message queue associated with a window.
 *
 * This function removes all messages which are associated with 
 * the specified window \a pMainWnd.
 *
 * \param pMainWnd The handle to the window.
 * \return The number of thrown messages.
 *
 * \sa EmptyMessageQueue
 */
MG_EXPORT int GUIAPI ThrowAwayMessages (HWND pMainWnd);

#ifndef _MGRM_THREADS

/**
 * \fn BOOL EmptyMessageQueue (HWND hWnd)
 * \brief Empties a message queue.
 *
 * This function empties the message queue of the main window \a hWnd.
 *
 * \param hWnd The handle to the main window.
 *
 * \return TRUE on all success, FALSE on error.
 *
 * \note Only defined for MiniGUI-Processes.
 *
 * \sa ThrowAwayMessages
 */
MG_EXPORT BOOL GUIAPI EmptyMessageQueue (HWND hWnd);

#endif

#ifdef _MGHAVE_MSG_STRING

/**
 * \fn const char* GUIAPI Message2Str (UINT message)
 * \brief Translates a message identifier to the message string.
 *
 * This function returns the message string of the message identifier \a message.
 * E.g. this function will return the string of "MSG_CHAR" for MSG_CHAR message.
 * 
 * \param message The message identifier.
 * \return The message string.
 *
 * \note Only available if defined _MGHAVE_MSG_STRING.
 *
 * \sa PrintMessage
 */
MG_EXPORT const char* GUIAPI Message2Str (UINT message);

/**
 * \fn void GUIAPI PrintMessage (FILE* fp, HWND hWnd, \
                UINT nMsg, WPARAM wParam, LPARAM lParam)
 * \brief Prints a message in readable string form to a stdio stream.
 *
 * This function prints the message specified by (\a nMsg, \a wParam, \a lParam)
 * in readable string form to the stdio stream \a fp.
 *
 * \param fp The pointer to the FILE object.
 * \param hWnd The target window of the message.
 * \param nMsg The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 * \sa Message2Str
 */
MG_EXPORT void GUIAPI PrintMessage (FILE* fp, HWND hWnd, 
                UINT nMsg, WPARAM wParam, LPARAM lParam);

#endif

    /** @} end of msg_pass_fns */

    /**
     * \defgroup msg_hook_fns Message or event hook functions
     * @{
     */

/**
 * \def HOOK_GOON
 * \sa SRVEVTHOOK  RegisterKeyHookWindow RegisterMouseHookWindow
 */
#define HOOK_GOON       0

/**
 * \def HOOK_STOP
 * \sa SRVEVTHOOK  RegisterKeyHookWindow RegisterMouseHookWindow
 */
#define HOOK_STOP       1

#ifndef _MGRM_PROCESSES

/**
 * \var typedef int (* MSGHOOK)(void* context, HWND dst_wnd, \
 *                UINT msg, WPARAM wparam, LPARAM lparam)
 *
 * \brief Type of message hook function.
 */
typedef int (* MSGHOOK)(void* context, HWND dst_wnd, 
                UINT msg, WPARAM wparam, LPARAM lparam);

/**
 * Structure defines a message hook.
 */
typedef struct _HOOKINFO
{
    /** the context which will be passed to the hook function. */
    void* context;
    /** the pointer to the hook function. */
    MSGHOOK hook;
} HOOKINFO;

/**
 * \fn MSGHOOK GUIAPI RegisterKeyMsgHook (void* context, MSGHOOK hook)
 * \brief Registers a key message hook.
 *
 * This function registers a key message hook pointed to by \a hook.
 *
 * When the desktop receives a key message, it will send it to the hook first,
 * and passes the \a context value to the hook as the first argument.
 *
 * \param context The context value will be passed to the hook.
 * \param hook The hook. This function will unregister the old hook if 
 *        \a hook is NULL.
 * \return The old hook.
 *
 * \sa UnregisterHook, KEYMSGHOOK
 */
MG_EXPORT MSGHOOK GUIAPI RegisterKeyMsgHook (void* context, MSGHOOK hook);

/**
 * \fn MSGHOOK GUIAPI RegisterMouseMsgHook (void* context, MSGHOOK hook)
 * \brief Registers a mouse message hook.
 *
 * This function registers a mouse message hook pointed to by \a hook.
 *
 * When the desktop receives a mouse message, it will send it to the hook 
 * first, and passes the \a context value to the hook as the first argument.
 *
 * \param context The context value will be passed to the hook.
 * \param hook The hook. This function will unregister the old hook if 
 *        \a hook is NULL.
 * \return The old hook.
 *
 * \sa UnregisterHook, KEYMSGHOOK
 */
MG_EXPORT MSGHOOK GUIAPI RegisterMouseMsgHook (void* context, MSGHOOK hook);

#endif /* !_MGRM_PROCESSES */

#ifndef _MGRM_THREADS

/**
 * \var typedef int (* SRVEVTHOOK) (PMSG pMsg)
 * \brief The type of the event hook.
 *
 * You can call \a SetServerEventHook to set an event hook
 * in the server of the MiniGUI-Processes.
 *
 * If the event hook returns HOOK_GOON, \a mginit will continue to
 * handle the event, and send it to the active client.
 * If the hook returns HOOK_STOP, \a mginit will cancel normal handling.
 *
 * \sa SetServerEventHook
 */
typedef int (* SRVEVTHOOK) (PMSG pMsg);

/**
 * \fn void GUIAPI SetServerEventHook (SRVEVTHOOK SrvEvtHook)
 * \brief Sets an event hook in the server of MiniGUI-Processes.
 *
 * This function sets the event hook as \a SrvEvtHook in the server, 
 * i.e. mginit, of MiniGUI-Processes.
 *
 * \param SrvEvtHook The pointer to the hook, NULL to cancel the hook.
 *
 * \note Only defined for MiniGUI-Processes, and only can be used by the server.
 *
 * \sa SRVEVTHOOK
 */
MG_EXPORT SRVEVTHOOK GUIAPI SetServerEventHook (SRVEVTHOOK SrvEvtHook);

#ifdef _MGRM_PROCESSES

/**
 * \fn HWND GUIAPI RegisterKeyHookWindow (HWND hwnd, DWORD flag)
 * \brief Registers a key message hook window.
 *
 * This function registers a key message hook pointed to by \a hook.
 *
 * When the desktop receives a key message, it will send it to the hook first,
 * and passes the \a context value to the hook as the first argument.
 *
 * \param hwnd The hook hwnd. This function will unregister the old hook if 
 *        \a hwnd is HWND_NULL.
 * \param flag Indicates whether stop or continue handling the hooked messages.
 *        HOOK_GOON to continue, HOOK_STOP to stop.
 *
 * \return The handle of old hook window.
 *
 * \note This function be be called by a client of MiniGUI-Processes.
 *       For the server, you can use SetServerEventHook.
 *
 * \sa RegisterMouseHookWindow, SetServerEventHook 
 */
MG_EXPORT HWND GUIAPI RegisterKeyHookWindow (HWND hwnd, DWORD flag);

/**
 * \fn HWND GUIAPI RegisterMouseHookWindow (HWND hwnd, DWORD flag)
 * \brief Registers a mouse message hook window.
 *
 * This function registers a mouse message hook pointed to by \a hook.
 *
 * When the desktop receives a mouse message, it will send it to the hook 
 * first, and passes the \a context value to the hook as the first argument.
 *
 * \param hwnd The hook hwnd. This function will unregister the old hook if 
 *        \a hook is HWND_NULL.
 * \param flag Indicates whether stop or continue handling the hooked messages.
 *        HOOK_GOON to continue, HOOK_STOP to stop.
 *
 * \return The handle of old hook window.
 *
 * \note This function be be called by a client of MiniGUI-Processes.
 *       For the server, you can use SetServerEventHook.
 *
 * \sa RegisterKeyHookWindow, SetServerEventHook 
 */
MG_EXPORT HWND GUIAPI RegisterMouseHookWindow (HWND hwnd, DWORD flag);

#endif /* _MGRM_PROCESSES */
#endif /* !_MGRM_THREADS */


    /** @} end of msg_hook_fns */

    /** @} end of msg_fns */

    /** @} end of fns */

    /**
     * \defgroup styles Window styles
     * @{
     */

#define WS_CTRLMASK         0x0000FFFFL

/**
 * \def WS_NONE
 * \brief None style.
 */
#define WS_NONE             0x00000000L

/**
 * \def WS_CHILD
 * \brief Indicates the window is a child.
 */
#define WS_CHILD            0x40000000L

/**
 * \def WS_CAPTION
 * \brief Creates a main window with caption.
 */
#define WS_CAPTION          0x20000000L

/**
 * \def WS_SYSMENU
 * \brief Creates a main window with system menu.
 */
#define WS_SYSMENU          0x10000000L

/**
 * \def WS_VISIBLE
 * \brief Creates a window initially visible.
 */
#define WS_VISIBLE          0x08000000L

/**
 * \def WS_DISABLED
 * \brief Creates a window initially disabled.
 */
#define WS_DISABLED         0x04000000L

/* Main window states -- reserved for future use. */
#define WS_MINIMIZE         0x02000000L
#define WS_MAXIMIZE         0x01000000L

/**
 * \def WS_DLGFRAME
 * \brief The window has a fixed frame, i.e. user can not 
 *        drag the border of the window.
 */
#define WS_DLGFRAME         0x00800000L

/**
 * \def WS_BORDER
 * \brief Creates a window with border.
 */
#define WS_BORDER           0x00400000L

/**
 * \def WS_THICKFRAME
 * \brief Creates a window with thick frame.
 */
#define WS_THICKFRAME       0x00200000L

/**
 * \def WS_THINFRAME
 * \brief Creates a window with thin frame.
 */
#define WS_THINFRAME        0x00100000L

/**
 * \def WS_VSCROLL
 * \brief Creates a window with vertical scroll bar.
 */
#define WS_VSCROLL          0x00080000L

/**
 * \def WS_HSCROLL
 * \brief Creates a window with horizontal scroll bar.
 */
#define WS_HSCROLL          0x00040000L

/**
 * \def WS_GROUP
 * \brief Indicates the control is the leader of a group.
 * \note This style is valid only for controls.
 */
#define WS_GROUP            0x00020000L

/**
 * \def WS_TABSTOP
 * \brief Indicates the user can set the input focus to the control by 
 *        using Tab key.
 * \note This style is valid only for controls.
 */
#define WS_TABSTOP          0x00010000L

/*
 * Not implemented, reserved for future use.
 *
 * \def WS_MINIMIZEBOX
 * \brief Creates a window with minimizing box on caption.
 * \note This style is valid only for main window.
 */
#define WS_MINIMIZEBOX      0x00020000L

/*
 * Not implemented, reserved for future use.
 *
 * \def WS_MAXIMIZEBOX
 * \brief Creates a window with maximizing box on caption.
 * \note This style is valid only for main window.
 */
#define WS_MAXIMIZEBOX      0x00010000L

/* Obsolete styles, back-compatibility definitions. */
#define WS_OVERLAPPED       0x00000000L
#define WS_ABSSCRPOS        0x00000000L

/**
 * \def WS_EX_CONTROL_MASK
 * \brief The extended style mask for control usage.
 */
#define WS_EX_CONTROL_MASK      0x0000000FL

/**
 * \def WS_EX_INTERNAL_MASK
 * \brief The extended style mask for internal usage.
 */
#define WS_EX_INTERNAL_MASK     0xF0000000L

/**
 * \def WS_EX_NONE
 * \brief No any extended window style.
 */
#define WS_EX_NONE              0x00000000L

/**
 * \def WS_EX_TROUNDCNS
 * \brief The window have round corners in top.
 */
#define WS_EX_TROUNDCNS         0x00000010L

/**
 * \def WS_EX_BROUNDCNS
 * \brief The window have round corners at bottom.
 */
#define WS_EX_BROUNDCNS         0x00000020L

/**
 * \def WS_EX_USEPRIVATECDC
 * \brief The window has its own private client device context.
 *
 * \sa CreatePrivateClientDC
 */
#define WS_EX_USEPRIVATECDC     0x00000040L

/**
 * \def WS_EX_NOTDRAGGABLE
 * \brief A style controlling whether a main window can be dragged by using mouse.
 */
#define WS_EX_NOTDRAGGABLE      0x00000080L
#define WS_EX_DRAGGABLE         0x00000000L

/**
 * \def WS_EX_USEPARENTFONT
 * \brief The window uses the font of its parent as the default font.
 */
#define WS_EX_USEPARENTFONT     0x00000100L

/**
 * \def WS_EX_USEPARENTCURSOR
 * \brief The window uses the cursor of its parent as the default cursor.
 */
#define WS_EX_USEPARENTCURSOR   0x00000200L

/**
 * \def WS_EX_USEPARENTRDR
 * \brief The window use the same window renderer as parent.
 */
#define WS_EX_USEPARENTRDR      0x00000400L

/**
 * \def WS_EX_NOPARENTNOTIFY
 * \brief The window will not send any notification to the parent.
 *
 * \sa NotifyParentEx
 */
#define WS_EX_NOPARENTNOTIFY    0x00000800L

/**
 * \def WS_EX_AUTOSECONDARYDC
 * \brief The window creates its own secondary device context automatically.
 *
 * \sa CreateSecondaryDC
 */
#define WS_EX_AUTOSECONDARYDC   0x00001000L

/**
 * \def WS_EX_TRANSPARENT
 * \brief The window is transparent.
 * \note This style is only implemented for controls.
 */
#define WS_EX_TRANSPARENT       0x00002000L

/**
 * \def WS_EX_TOPMOST
 * \brief The main window is a topmost (always on top) window.
 */
#define WS_EX_TOPMOST           0x00004000L

/**
 * \def WS_EX_TOOLWINDOW
 * \brief The main window is a tool window, which can not gain the input focus.
 */
#define WS_EX_TOOLWINDOW        0x00008000L

/* The group reserved for BIDI support */
#define WS_EX_RIGHT             0x00010000L
#define WS_EX_LEFT              0x00000000L
#define WS_EX_RTLREADING        0x00020000L
#define WS_EX_LTRREADING        0x00000000L

/**
 * \def WS_EX_LEFTSCROLLBAR
 * \brief The horizontal scroll bar of the window is located at left.
 */
#define WS_EX_LEFTSCROLLBAR     0x00040000L

/**
 * \def WS_EX_RIGHTSCROLLBAR
 * \brief The horizontal scroll bar of the window is located at right (default).
 */
#define WS_EX_RIGHTSCROLLBAR    0x00000000L

/**
 * \def WS_EX_DLGHIDE
 * \brief The dialog won't show immediately after it is created.
 */
#define WS_EX_DLGHIDE           0x00100000L

/**
 * \def WS_EX_NOCLOSEBOX
 * \brief The main window has no closing box on its caption.
 */
#define WS_EX_NOCLOSEBOX        0x00400000L

/**
 * \def WS_EX_CLIPCHILDREN
 * \brief When paint the window, the children areas will be clipped.
 */
#define WS_EX_CLIPCHILDREN      0x00800000L

/**
 * \def WS_EX_LFRDR_MASK
 * \brief The style mask for LF renderer internal usage.
 */
#define WS_EX_LFRDR_MASK        0x0F000000L

/**
 * \def WS_EX_LFRDR_CUSTOM1
 * \brief The user-defined extended style. It's often used to process 
 *        user-defined hotspot area. 
 */
#define WS_EX_LFRDR_CUSTOM1     0x01000000L

/**
 * \def WS_EX_LFRDR_CUSTOM2
 * \brief The user-defined extended style. 
 * 
 * \sa WS_EX_LFRDR_CUSTOM1
 */
#define WS_EX_LFRDR_CUSTOM2     0x02000000L

/**
 * \def WS_EX_LFRDR_CUSTOM3
 * \brief The user-defined extended style.
 * 
 * \sa WS_EX_LFRDR_CUSTOM1
 */
#define WS_EX_LFRDR_CUSTOM3     0x04000000L

/**
 * \def WS_EX_LFRDR_CUSTOM4
 * \brief The user-defined extended style.
 * 
 * \sa WS_EX_LFRDR_CUSTOM1
 */
#define WS_EX_LFRDR_CUSTOM4     0x08000000L

/* Obsolete style, back-compatibility definitions. */
#define WS_EX_IMECOMPOSE        0x00000000L

    /** @} end of styles */

    /**
     * \addtogroup fns Functions
     * @{
     */

    /**
     * \defgroup lf_fns Look and Feel Renderer management functions 
     * @{
     */

/**
 * \def WE_FONTS_NUMBER
 * \brief The number of window element font attributes.
 */
#define WE_FONTS_NUMBER             4 

/**
 * \def WE_METRICS_NUMBER
 * \brief The number of window element metric attributes.
 */
#define WE_METRICS_NUMBER           6

/**
 * \def WE_COLORS_NUMBER
 * \brief The number of window element color attributes.
 */
#define WE_COLORS_NUMBER            14

/* Window type mask */
#define WE_ATTR_TYPE_MASK           0xF000
#define WE_ATTR_TYPE_COLOR_MASK     0x0F00
#define WE_ATTR_INDEX_MASK          0x00FF

#define WE_ATTR_TYPE_FONT           0x1000
#define WE_ATTR_TYPE_METRICS        0x2000

#define WE_ATTR_TYPE_COLOR          0x3000  
#define WE_ATTR_TYPE_FGC            0x3000
#define WE_ATTR_TYPE_BGCA           0x3100
#define WE_ATTR_TYPE_BGCB           0x3200

/* window element id */
#define WE_CAPTION                  0  
#define WE_MENU                     1
#define WE_MESSAGEBOX               2
#define WE_TOOLTIP                  3
#define WE_WND_BORDER               4
#define WE_SCROLLBAR                5
#define WE_INACTIVE_CAPTION         6
#define WE_WINDOW                   7
#define WE_THREED_BODY              8
#define WE_SELECTED_ITEM            9
#define WE_DISABLED_ITEM            10
#define WE_HIGHLIGHT_ITEM           11
#define WE_SIGNIFICANT_ITEM         12
#define WE_DESKTOP                  13

/* window element attr id */

/* Window caption */
#define WE_FONT_CAPTION             (WE_CAPTION | WE_ATTR_TYPE_FONT)
#define WE_METRICS_CAPTION          (WE_CAPTION | WE_ATTR_TYPE_METRICS)
#define WE_FGC_ACTIVE_CAPTION       (WE_CAPTION | WE_ATTR_TYPE_FGC)
#define WE_BGCA_ACTIVE_CAPTION      (WE_CAPTION | WE_ATTR_TYPE_BGCA)
#define WE_BGCB_ACTIVE_CAPTION      (WE_CAPTION | WE_ATTR_TYPE_BGCB)

/* Menu */
#define WE_FONT_MENU                (WE_MENU | WE_ATTR_TYPE_FONT)
#define WE_METRICS_MENU             (WE_MENU | WE_ATTR_TYPE_METRICS)
#define WE_FGC_MENU                 (WE_MENU | WE_ATTR_TYPE_FGC)
#define WE_BGC_MENU                 (WE_MENU | WE_ATTR_TYPE_BGCA)

/* Message box */
#define WE_FONT_MESSAGEBOX          (WE_MESSAGEBOX | WE_ATTR_TYPE_FONT)
#define WE_FGC_MESSAGEBOX           (WE_MESSAGEBOX | WE_ATTR_TYPE_FGC)

/* Tool tips */
#define WE_FONT_TOOLTIP             (WE_TOOLTIP | WE_ATTR_TYPE_FONT)
#define WE_FGC_TOOLTIP              (WE_TOOLTIP | WE_ATTR_TYPE_FGC)
#define WE_BGC_TOOLTIP              (WE_TOOLTIP | WE_ATTR_TYPE_BGCA)

/* Window border */
#define WE_METRICS_WND_BORDER       (WE_WND_BORDER | WE_ATTR_TYPE_METRICS)
#define WE_FGC_ACTIVE_WND_BORDER    (WE_WND_BORDER | WE_ATTR_TYPE_FGC)
#define WE_FGC_INACTIVE_WND_BORDER  (WE_WND_BORDER | WE_ATTR_TYPE_BGCA)

/* Scroll bar */
#define WE_METRICS_SCROLLBAR        (WE_SCROLLBAR | WE_ATTR_TYPE_METRICS)

/* Inactive caption */
#define WE_FGC_INACTIVE_CAPTION     (WE_INACTIVE_CAPTION | WE_ATTR_TYPE_FGC)
#define WE_BGCA_INACTIVE_CAPTION    (WE_INACTIVE_CAPTION | WE_ATTR_TYPE_BGCA)
#define WE_BGCB_INACTIVE_CAPTION    (WE_INACTIVE_CAPTION | WE_ATTR_TYPE_BGCB)

/* Window */
#define WE_FGC_WINDOW               (WE_WINDOW | WE_ATTR_TYPE_FGC)
#define WE_BGC_WINDOW               (WE_WINDOW | WE_ATTR_TYPE_BGCA)

/* 3d body */
#define WE_FGC_THREED_BODY          (WE_THREED_BODY | WE_ATTR_TYPE_FGC)
#define WE_MAINC_THREED_BODY        (WE_THREED_BODY | WE_ATTR_TYPE_BGCA)

/* Selected items */
#define WE_FGC_SELECTED_ITEM        (WE_SELECTED_ITEM | WE_ATTR_TYPE_FGC)
#define WE_BGC_SELECTED_ITEM        (WE_SELECTED_ITEM | WE_ATTR_TYPE_BGCA)
#define WE_BGC_SELECTED_LOSTFOCUS   (WE_SELECTED_ITEM | WE_ATTR_TYPE_BGCB)

/* Invalidate items */
#define WE_FGC_DISABLED_ITEM        (WE_DISABLED_ITEM | WE_ATTR_TYPE_FGC)
#define WE_BGC_DISABLED_ITEM        (WE_DISABLED_ITEM | WE_ATTR_TYPE_BGCA)

/* Highlight items */
#define WE_FGC_HIGHLIGHT_ITEM       (WE_HIGHLIGHT_ITEM | WE_ATTR_TYPE_FGC)
#define WE_BGC_HIGHLIGHT_ITEM       (WE_HIGHLIGHT_ITEM | WE_ATTR_TYPE_BGCA)

/* Significant items */
#define WE_FGC_SIGNIFICANT_ITEM     (WE_SIGNIFICANT_ITEM | WE_ATTR_TYPE_FGC)
#define WE_BGC_SIGNIFICANT_ITEM     (WE_SIGNIFICANT_ITEM | WE_ATTR_TYPE_BGCA)

/* Desktop */
#define WE_BGC_DESKTOP              (WE_DESKTOP | WE_ATTR_TYPE_BGCA)

#define WE_ATTR_TYPE_ICON           0x4000  
#define WE_ATTR_TYPE_ICON_MASK      0x0F00
#define WE_ATTR_TYPE_SMALLICON      0x4000
#define WE_ATTR_TYPE_LARGEICON      0x4100

#define WE_LARGEICON_APPLICATION    (WE_ATTR_TYPE_LARGEICON | 0x00)
#define WE_LARGEICON_HAND           (WE_ATTR_TYPE_LARGEICON | 0x01)
#define WE_LARGEICON_QUESTION       (WE_ATTR_TYPE_LARGEICON | 0x02)
#define WE_LARGEICON_EXCLAMATION    (WE_ATTR_TYPE_LARGEICON | 0x03)
#define WE_LARGEICON_ASTERISK       (WE_ATTR_TYPE_LARGEICON | 0x04)
#define WE_LARGEICON_STOP           WE_LARGEICON_HAND
#define WE_LARGEICON_INFORMATION    WE_LARGEICON_ASTERISK

#define WE_SMALLICON_APPLICATION    (WE_ATTR_TYPE_SMALLICON | 0x00)
#define WE_SMALLICON_HAND           (WE_ATTR_TYPE_SMALLICON | 0x01)
#define WE_SMALLICON_QUESTION       (WE_ATTR_TYPE_SMALLICON | 0x02)
#define WE_SMALLICON_EXCLAMATION    (WE_ATTR_TYPE_SMALLICON | 0x03)
#define WE_SMALLICON_ASTERISK       (WE_ATTR_TYPE_SMALLICON | 0x04)
#define WE_SMALLICON_STOP           WE_SMALLICON_HAND
#define WE_SMALLICON_INFORMATION    WE_SMALLICON_ASTERISK

/**
 * \def WE_ATTR_TYPE_RDR
 * \brief The specific type for LF renderer.
 */
#define WE_ATTR_TYPE_RDR                0x5000 

#define WE_LFFLAT_NUMBER                1
#ifdef _MGLF_RDR_FLAT

#define WE_LFFLAT_TAB_NRMLCLR           (WE_ATTR_TYPE_RDR | 0)
#endif

#define WE_LFSKIN_NUMBER                28
#ifdef _MGLF_RDR_SKIN
#define WE_LFSKIN_WND_BKGND             (WE_ATTR_TYPE_RDR | 0)

#define WE_LFSKIN_CAPTION               (WE_ATTR_TYPE_RDR | 1)
#define WE_LFSKIN_CAPTION_BTN           (WE_ATTR_TYPE_RDR | 2)

#define WE_LFSKIN_SCROLLBAR_VSHAFT      (WE_ATTR_TYPE_RDR | 3)
#define WE_LFSKIN_SCROLLBAR_VTHUMB      (WE_ATTR_TYPE_RDR | 4)
#define WE_LFSKIN_SCROLLBAR_HSHAFT      (WE_ATTR_TYPE_RDR | 5)
#define WE_LFSKIN_SCROLLBAR_HTHUMB      (WE_ATTR_TYPE_RDR | 6)
#define WE_LFSKIN_SCROLLBAR_ARROWS      (WE_ATTR_TYPE_RDR | 7)

#define WE_LFSKIN_BORDER_TOP            (WE_ATTR_TYPE_RDR | 8)
#define WE_LFSKIN_BORDER_BOTTOM         (WE_ATTR_TYPE_RDR | 9)
#define WE_LFSKIN_BORDER_LEFT           (WE_ATTR_TYPE_RDR | 10)
#define WE_LFSKIN_BORDER_RIGHT          (WE_ATTR_TYPE_RDR | 11)

#define WE_LFSKIN_ARROWS                (WE_ATTR_TYPE_RDR | 12)
#define WE_LFSKIN_ARROWS_SHELL          (WE_ATTR_TYPE_RDR | 13)

#define WE_LFSKIN_RADIOBUTTON           (WE_ATTR_TYPE_RDR | 14)
#define WE_LFSKIN_CHECKBUTTON           (WE_ATTR_TYPE_RDR | 15)
#define WE_LFSKIN_PUSHBUTTON            (WE_ATTR_TYPE_RDR | 16)

#define WE_LFSKIN_TREE                  (WE_ATTR_TYPE_RDR | 17)

#define WE_LFSKIN_HEADER                (WE_ATTR_TYPE_RDR | 18)
#define WE_LFSKIN_TAB                   (WE_ATTR_TYPE_RDR | 19)

#define WE_LFSKIN_PROGRESS_HCHUNK       (WE_ATTR_TYPE_RDR | 20)
#define WE_LFSKIN_PROGRESS_VCHUNK       (WE_ATTR_TYPE_RDR | 21)
#define WE_LFSKIN_PROGRESS_HTRACKBAR    (WE_ATTR_TYPE_RDR | 22)
#define WE_LFSKIN_PROGRESS_VTRACKBAR    (WE_ATTR_TYPE_RDR | 23)

#define WE_LFSKIN_TBSLIDER_H            (WE_ATTR_TYPE_RDR | 24)
#define WE_LFSKIN_TRACKBAR_VERT         (WE_ATTR_TYPE_RDR | 25)
#define WE_LFSKIN_TRACKBAR_HORZ         (WE_ATTR_TYPE_RDR | 26)
#define WE_LFSKIN_TBSLIDER_V            (WE_ATTR_TYPE_RDR | 27)
#endif

/** The window element attributes structure. */
typedef struct _WINDOW_ELEMENT_ATTR {
    /** The attribute identifier. */
    int we_attr_id;
    /** The attribute value. */
    DWORD we_attr;
} WINDOW_ELEMENT_ATTR;

struct _WINDOW_ELEMENT_RENDERER;
typedef struct _WINDOW_ELEMENT_RENDERER* PWERENDERER;

#define SBS_NORMAL                  0x00
#define SBS_DISABLED                0x01
#define SBS_HIDE                    0x02

/**
 * The scrollbar information structure in look and feel.
 */
typedef struct _LFSCROLLBARINFO {
    /** The minimum value of scrollbar range. */
    int  minPos;       
    /** The max value of scrollbar range. */
    int  maxPos; 
    /** The current scrollbar pos. */      
    int  curPos;       
    /** The step per page.  */  
    int  pageStep;      
    /** The length of arrow. */  
    int  arrowLen;      
    /** The start pixel of thumb. */  
    int  barStart;     
    /** The length of thumb. */  
    int  barLen;     
    /** The status of scrollbar. */   
    int status;        
} LFSCROLLBARINFO;

typedef LFSCROLLBARINFO* PLFSCROLLBARINFO;

/**
 * The scrollbar data construction for scrollbar control.
 */
typedef struct _SCROLLBARDATA {
    /** The minimum value of scrollbar range. */
    int  minPos;
    /** The max value of scrollbar range. */
    int  maxPos;
    /** The current scrollbar pos. */      
    int  curPos;
    /** The step per page.  */  
    int  pageStep;
    /** The length of arrow. */  
    int  arrowLen;
    /** The start pixel of thumb. */  
    int  barStart;
    /** The length of thumb. */  
    int  barLen;       
    /* mouse position before tracking thumb.
     * it represents the distance from x mouse postion to barStart 
     * for horizontal scrollbar.
     * it represents the distance from y mouse postion to barStart 
     * for vertical  scrollbar.
     */
    int  track_pos;
    /** The status of scrollbar. */   
    int status;
} SCROLLBARDATA;

typedef SCROLLBARDATA* PSCROLLBARDATA;

/** left or up arrow is in disabled state */
#define SBS_DISABLED_LTUP       0x0100

/** right or bottom arrow is in disabled  state */
#define SBS_DISABLED_BTDN       0x0200

/** left or up arrow is in hilited state */
#define SBS_HILITE_LTUP         0x0400

/** right or bottom arrow is in hilited state */
#define SBS_HILITE_BTDN         0x0800

/** thumb is in hilite state as cursor is in the area of thumb */
#define SBS_HILITE_THUMB        0x0010

/** left or up arrow is in pressed state */
#define SBS_PRESSED_LTUP        0x0020

/** right or bottom arrow is in pressed state */
#define SBS_PRESSED_BTDN        0x0040

/** thumb is in pressed state as left button presses it */
#define SBS_PRESSED_THUMB       0x0080


#define LFRDR_WINTYPE_UNKNOWN           0
#define LFRDR_WINTYPE_DIALOG            1
#define LFRDR_WINTYPE_MAINWIN           2
#define LFRDR_WINTYPE_CONTROL           3

/** The window style information structure. Used by 
 *  \a calc_we_metrics renderer function.  
 */ 
typedef struct _LFRDR_WINSTYLEINFO
{
    /** The styles of window.*/
    int         dwStyle; 

    /** The window type, can be one of the values:
     *      - LFRDR_WINTYPE_DIALOG\n
     *        For dialog. 
     *      - LFRDR_WINTYPE_MAINWIN\n
     *        For main window. 
     *      - LFRDR_WINTYPE_CONTROL\n
     *        For control. 
     */
    int         winType; 
} LFRDR_WINSTYLEINFO;

/**
 * The scrollbar information structure. Used by
 * \a draw_scrollbar and \a get_scrollbar_rect 
 * renderer function.
 */
typedef struct _LFRDR_TRACKBARINFO
{   
    int nMin;                  
    int nMax;                  
    int nPos;
    int nTickFreq;                                
}LFRDR_TRACKBARINFO;

#define LFRDR_METRICS_MASK              0xFF00
#define LFRDR_METRICS_BORDER            0x0100
#define LFRDR_METRICS_CAPTION_H         0x0200
#define LFRDR_METRICS_ICON_H            0x0300
#define LFRDR_METRICS_ICON_W            0x0400
#define LFRDR_METRICS_MENU_H            0x0500
#define LFRDR_METRICS_VSCROLL_W         0x0600
#define LFRDR_METRICS_HSCROLL_H         0x0700
#define LFRDR_METRICS_MINWIN_WIDTH      0x0800
#define LFRDR_METRICS_MINWIN_HEIGHT     0x0900

#define LFRDR_SB_MINBARLEN        10

/**
 * \def LEN_RENDERER_NAME
 * \brief The maximum length of a renderer name.
 */
#define LEN_RENDERER_NAME           15

/* button status used by button and 3dbox.  */
#define LFRDR_BTN_STATUS_MASK       0x03
#define LFRDR_BTN_STATUS_NORMAL     0x00
#define LFRDR_BTN_STATUS_HILITE     0x01
#define LFRDR_BTN_STATUS_PRESSED    0x02
#define LFRDR_BTN_STATUS_DISABLED   0x03
 
/* a flag used by radio button and check button. */
#define LFRDR_BTN_STATUS_SELECTED   0x04

/* a flag used by button on capton bar. */
#define LFRDR_BTN_STATUS_INACTIVE   0x08
 
/* thick or thin frame used by 3dbox. */
#define LFRDR_3DBOX_THICKFRAME      0x20
 
/* filled 3dbox */
#define LFRDR_3DBOX_FILLED          0x40
 
/*select status used by checkmark or radio.*/
#define LFRDR_MARK_SELECTED_MASK    0x05
#define LFRDR_MARK_ALL_SELECTED     0x01
#define LFRDR_MARK_HALF_SELECTED    0x04
 
/* a flag whether a checkmark or radio has a shell or not.*/
#define LFRDR_MARK_HAVESHELL        0x02
 
/*the direction of arrow.*/
#define LFRDR_ARROW_DIRECT_MASK     0x0F00
#define LFRDR_ARROW_LEFT            0x0000
#define LFRDR_ARROW_RIGHT           0x0100
#define LFRDR_ARROW_UP              0x0200
#define LFRDR_ARROW_DOWN            0x0300

/* hollow arrow or filled */
#define LFRDR_ARROW_NOFILL          0x1000
#define LFRDR_ARROW_HAVESHELL       0x2000

/* minimum of menu margin */
#define LFRDR_MENUITEMOFFY_MIN      4

#define LFRDR_3DBOX_COLOR_LIGHTEST  0x01
#define LFRDR_3DBOX_COLOR_DARKEST   0x02
#define LFRDR_3DBOX_COLOR_LIGHTER   0x03
#define LFRDR_3DBOX_COLOR_DARKER    0x04

/* flag of propsheet tab */
#define LFRDR_TAB_BOTTOM            0x0001
#define LFRDR_TAB_ACTIVE            0x0010
#define LFRDR_TAB_ICON              0x0100

/* for fold icon*/
#define LFRDR_TREE_WITHICON         0x08
#define LFRDR_TREE_FOLD             0x01

/* for connecting line*/
#define LFRDR_TREE_CHILD            0x02
#define LFRDR_TREE_NEXT             0x04

#define SYSICO_ITEM_NUMBER          5

/** The window element renderer structure. */
typedef struct _WINDOW_ELEMENT_RENDERER {
    /** The renderer name. */
    const char name[LEN_RENDERER_NAME+1];

    /** The pointer to initialize function. It is used to initialize basic 
     *  renderer information (metrics, color, font, icon, etc) and private
     *  information.
     */
    int (*init) (PWERENDERER renderer);

    /** The pointer to release function. It is used to release renderer
     *  resource.
     *  \sa init
     */
    int (*deinit) (PWERENDERER renderer);

    /** The function pointer to calculate lighter, lightest, darker 
     * and darkest color according to main color.
     *
     *  \param color The main color.
     *  \param flag The color type, can be one of the values:
     *      - LFRDR_3DBOX_COLOR_DARKER \n
     *        darker color. 
     *      - LFRDR_3DBOX_COLOR_DARKEST \n
     *        darkest color. 
     *      - LFRDR_3DBOX_COLOR_LIGHTER \n
     *        lighter color. 
     *      - LFRDR_3DBOX_COLOR_LIGHTEST \n
     *        lightest color. 
     */
    DWORD (*calc_3dbox_color) (DWORD color, int flag);

    /** The pointer to draw 3dbox function.
     *  
     * \param flag, can be OR'ed by the following values:
     *  - LFRDR_BTN_STATUS_NORMAL\n
     *    Normal status.
     *  - LFRDR_BTN_STATUS_HILITE\n
     *    Highlight status.
     *  - LFRDR_BTN_STATUS_PRESSED\n
     *    Pushed status.
     *  - LFRDR_BTN_STATUS_DISABLED\n
     *    Disabled status.
     *  - LFRDR_BTN_STATUS_SELECTED\n
     *    Selected status.
     *
     *  - LFRDR_3DBOX_THICKFRAME\n
     *    Use thick/thin frame.
     *  - LFRDR_3DBOX_FILLED\n
     *    Filled rectangle.
     */
    void (*draw_3dbox) (HDC hdc, const RECT* pRect, DWORD color, DWORD flag);


    /** The pointer to draw radio function. 
     *
     * \param status, can be OR'ed by the following values:
     *  - LFRDR_MARK_ALL_SELECTED\n
     *    All selected status.
     *  - LFRDR_MARK_HALF_SELECTED\n
     *    Half selected status.
     *  - LFRDR_MARK_HAVESHELL\n
     *    Have shell for mark.
     */
    void (*draw_radio) (HDC hdc, const RECT* pRect, DWORD color, int status);

    /** The pointer to draw checkbox function. 
     *  \sa draw_radio
     */
    void (*draw_checkbox) (HDC hdc, const RECT* pRect, DWORD color, 
            int status);

    /** The pointer to draw checkmark function.
     *  \sa draw_radio
     */
    void (*draw_checkmark) (HDC hdc, const RECT* pRect, DWORD color, 
            int status);

    /** The pointer to draw arrow function.
     *
     * \param status, can be OR'ed by the following values:
     *  - LFRDR_ARROW_LEFT\n
     *    Left arrow.
     *  - LFRDR_ARROW_RIGHT\n
     *    Right arrow.
     *  - LFRDR_ARROW_UP\n
     *    Up arrow.
     *  - LFRDR_ARROW_DOWN\n
     *    Down arrow.
     *  - LFRDR_ARROW_NOFILL\n
     *    No filled arrow area.
     *  - LFRDR_ARROW_HAVESHELL\n
     *    Have shell for arrow.
     */
    void (*draw_arrow) (HWND hWnd, HDC hdc, const RECT* pRect, DWORD color, int status);

    /** The pointer to draw fold function, this function used 
     *  by listview and treeview.
     *
     * \param status, can be OR'ed by the following values:
     *  - LFRDR_TREE_FOLD\n
     *    Draw opening/closing folder.
     *  - LFRDR_TREE_CHILD\n
     *    Draw connecting status between parent and child node.
     *  - LFRDR_TREE_NEXT\n
     *    Draw connecting status between current and next node.
     *
     *  \param next The number of child node.
     */
    void (*draw_fold) (HWND hWnd, HDC hdc, const RECT* pRect, DWORD color, 
            int status, int next);

    /** The pointer to draw focus frame function.*/
    void (*draw_focus_frame) (HDC hdc, const RECT *pRect, DWORD color);

    /** The pointer to draw normal item function, this function used by listbox.*/
    void (*draw_normal_item) (HWND hWnd, HDC hdc, const RECT* pRect, 
            DWORD color);
    
    /** The pointer to draw highlight item function, this function used by listbox.*/
    void (*draw_hilite_item) (HWND hWnd, HDC hdc, const RECT* pRect, 
            DWORD color);
    
    /** The pointer to draw disabled item function, this function used by listbox. */
    void (*draw_disabled_item) (HWND hWnd, HDC hdc, const RECT* pRect, 
            DWORD color);
    
    /** The pointer to draw significant item function, this function used by listbox.*/
    void (*draw_significant_item) (HWND hWnd, HDC hdc, const RECT* pRect, 
            DWORD color);

    /** The pointer to draw push button function, this function used 
     *  by button. 
     *
     * \param status, can be OR'ed by the following values:
     *  - BST_NORMAL\n
     *  - BST_HILITE\n
     *  - BST_PUSHED\n
     *  - BST_DISABLE\n
     *  - BST_UNCHECKED\n
     *  - BST_CHECKED\n
     *  - BST_INDETERMINATE\n
     *  - BST_FOCUS\n
     */
    void (*draw_push_button) (HWND hWnd, HDC hdc, const RECT* pRect,
            DWORD color1, DWORD color2, int status);

    /** The pointer to draw radio button function, the function ued
     *  by button. 
     *
     * \param status, can be OR'ed by the following values:
     *  - LFRDR_BTN_STATUS_NORMAL\n
     *    Normal status.
     *  - LFRDR_BTN_STATUS_HILITE\n
     *    Highlight status.
     *  - LFRDR_BTN_STATUS_PRESSED\n
     *    Pushed status.
     *  - LFRDR_BTN_STATUS_DISABLED\n
     *    Disabled status.
     *
     *  - LFRDR_BTN_STATUS_SELECTED\n
     *    Selected status.
     */
    void (*draw_radio_button) (HWND hWnd, HDC hdc, const RECT* pRect, int status);

    /** The pointer to draw check button function, this function used
     *  by button.
     *
     * \param status, can be OR'ed by the following values:
     *  - LFRDR_BTN_STATUS_NORMAL\n
     *    Normal status.
     *  - LFRDR_BTN_STATUS_HILITE\n
     *    Highlight status.
     *  - LFRDR_BTN_STATUS_PRESSED\n
     *    Pushed status.
     *  - LFRDR_BTN_STATUS_DISABLED\n
     *    Disabled status.
     *
     *  - LFRDR_BTN_STATUS_SELECTED\n
     *    Selected status.
     */
    void (*draw_check_button) (HWND hWnd, HDC hdc, const RECT* pRect, int status);

    /** The pointer to draw window border function.*/
    void (*draw_border) (HWND hWnd, HDC hdc, BOOL is_active);

    /** The pointer to draw window text and icon function.*/
    void (*draw_caption) (HWND hWnd, HDC hdc, BOOL is_active);

    /** The pointer to draw caption button function.
     *
     * \param ht_code The hittest code. If 0, it should draw all buttons.
     *  \param state The button state, can be one of the values:
     *  - LFRDR_BTN_STATUS_NORMAL\n
     *    Normal status.
     *  - LFRDR_BTN_STATUS_HILITE\n
     *    Highlight status.
     *  - LFRDR_BTN_STATUS_PRESSED\n
     *    Pushed status.
     *  - LFRDR_BTN_STATUS_DISABLED\n
     *    Disabled status.
     */
    void (*draw_caption_button) (HWND hwnd, HDC hdc, int ht_code, int state);

    /** The pointer to draw scrollbar function. 
     * 
     * \param sb_pos The position need to be paint. 
     *   If 0, it should draw all the scrollbar.
     * \param status, which is one of the value:
     *  - LFRDR_BTN_STATUS_NORMAL\n
     *    Normal status.
     *  - LFRDR_BTN_STATUS_HILITE\n
     *    Highlight status.
     *  - LFRDR_BTN_STATUS_PRESSED\n
     *    Pushed status.
     *  - LFRDR_BTN_STATUS_DISABLED\n
     *    Disabled status.
     */
    void (*draw_scrollbar) (HWND hWnd, HDC hdc, int sb_pos);

    /** The pointer to get trackbar rect function. */
    void (*calc_trackbar_rect) (HWND hWnd, LFRDR_TRACKBARINFO *info, 
            DWORD dwStyle, const RECT* rcClient, RECT* rcRuler, 
            RECT* rcBar, RECT* rcBorder);

    /** The pointer to draw trackbar function. */
    void (*draw_trackbar) (HWND hWnd, HDC hdc, LFRDR_TRACKBARINFO *info);

    /** The pointer to calculate window element area function.
     *
     * \param which The hit test code of the part to be calculated.
     * \param we_area The reactangle for calculating result.
     *
     * */
    int (*calc_we_area) (HWND hWnd, int which, RECT* we_area);

    /** The pointer to calculate window element metrics function.
     *
     * \param which, can be one of the following values:
     *  - LFRDR_METRICS_BORDER\n
     *    The metrics of window border.
     *  - LFRDR_METRICS_CAPTION_H\n
     *    The height of window caption.
     *  - LFRDR_METRICS_MENU_H\n
     *    The height of window menu.
     *  - LFRDR_METRICS_VSCROLL_W\n
     *    The width of vertical scrollbar.
     *  - LFRDR_METRICS_HSCROLL_H\n
     *    The height of horizontal scrollbar.
     *  - LFRDR_METRICS_ICON_H\n
     *    The height of window icon.
     *  - LFRDR_METRICS_ICON_W\n
     *    The width of window icon.
     *  - LFRDR_METRICS_MINWIN_WIDTH\n
     *    The minimize width of window.
     *  - LFRDR_METRICS_MINWIN_HEIGHT\n
     *    The minimize height of window.
     */
    int (*calc_we_metrics) (HWND hWnd, 
            LFRDR_WINSTYLEINFO* style_info, int which);

    /** The pointer to hittest function. 
     *
     * \param x, y The position of the mouse in screen coordinates.
     * \return HT_XXX or HT_USER_XXX, hittest value.
     */
    int (*hit_test) (HWND hWnd, int x, int y);

    /** The pointer to user-defined hotspot function.*/
    int (*on_click_hotspot) (HWND hWnd, int which);

    /** The pointer to draw user-defined hotspot function.
     *
     * \param ht_code The hittest code. If 0, it should draw all 
     *        user-defined hotspot.
     * \param state The button state, can be one of the values:
     *  - LFRDR_BTN_STATUS_NORMAL\n
     *  - LFRDR_BTN_STATUS_HILITE\n
     *  - LFRDR_BTN_STATUS_PRESSED\n
     */
    void (*draw_custom_hotspot) (HWND hWnd, HDC hdc, int ht_code, int state);

    /** The pointer to calculate scrollbar's thumb area function.
     *    
     * \param vertical Vertical scrollbar or Horizontal scrollbar.
     * \param sb_info The scrollbar information for calculating result.
     *
     */
    void (*calc_thumb_area) (HWND hWnd, BOOL vertical, 
            LFSCROLLBARINFO* sb_info);

    /** The pointer to output disabled text function.*/
    void (*disabled_text_out) (HWND hWnd, HDC hdc, const char* spText,
                    PRECT rc, DWORD dt_fmt);

    /** The pointer to draw propsheet's tab function.
     *
     * \param flag, can be OR'ed by the following values:
     *  - LFRDR_TAB_BOTTOM\n
     *    Use bottom tab.
     *  - LFRDR_TAB_ACTIVE\n
     *    Active tab.
     *  - LFRDR_TAB_ICON\n
     *    With icon.
     */
    void (*draw_tab) (HWND hWnd, HDC hdc, RECT *rect, char *title, 
                DWORD color, int flag, HICON icon);

    /** The pointer to draw progressbar's chunk/bar function.*/
    void (*draw_progress) (HWND hWnd, HDC hdc, 
            int nMax, int nMin, int nPos, BOOL fVertical);
    
    /** The pointer to draw table header function. 
     *  this function used by listview and gridview.
     */
    void (*draw_header) (HWND hWnd, HDC hdc, const RECT* pRect, DWORD color);

    /** The pointer to get renderer private data function. 
     *
     * \param we_attr_id The id pointed renderer private data. 
     */
    DWORD (*on_get_rdr_attr) (struct _WINDOW_ELEMENT_RENDERER*, int we_attr_id);

    /** The pointer to set renderer private data function. 
     * 
     * \param we_attr_id The id pointed renderer private data. 
     * \param we_attr The new renderer private data. 
     *
     */
    DWORD (*on_set_rdr_attr) (struct _WINDOW_ELEMENT_RENDERER*, int we_attr_id, DWORD we_attr, BOOL change);

    /** The pointer to erase background function.*/
    void (*erase_background) (HWND hWnd, HDC hdc, const RECT *rect);

    /** The pointer to draw menu normal item function. */
    void (*draw_normal_menu_item) (HWND hWnd, HDC hdc, const RECT* pRect,
                        DWORD color);

    /** The pointer to draw menu highlight item function. */
    void (*draw_hilite_menu_item) (HWND hWnd, HDC hdc, const RECT* pRect,
                        DWORD color);

    /** The pointer to draw menu disabled item function. */
    void (*draw_disabled_menu_item) (HWND hWnd, HDC hdc, const RECT* pRect,
                        DWORD color);

    /** The window element metrics information. */
    int we_metrics [WE_METRICS_NUMBER];

    /** The window element color information. */
    DWORD we_colors [WE_COLORS_NUMBER][3];

    /** The window element font information. */
    PLOGFONT we_fonts [WE_FONTS_NUMBER];

    /** The renderer icon information. */
    HICON  we_icon [2][SYSICO_ITEM_NUMBER];

    /** The reference count. */
    unsigned int refcount;

    /** The private information. */
    const void* private_info;
} WINDOW_ELEMENT_RENDERER;

/**
 * The window information structure.
 */
typedef struct _WINDOWINFO
{
    /** The position and size of window.*/
    int left, top; 
    int right, bottom;

    /** The position and size of client area.*/
    int cl, ct;
    int cr, cb;

    /** The styles of window.*/
    DWORD dwStyle;
    /** The extended styles of window.*/
    DWORD dwExStyle;

    /** The foreground color (not used).*/
    gal_pixel iFgColor; 
    /** The background color.*/
    gal_pixel iBkColor; 
    /** The handle of menu.*/
    HMENU hMenu; 
    /** The handle of accelerator table.*/
    HACCEL hAccel;
    /** The handle of cursor.*/
    HCURSOR hCursor;
    /** The handle of icon.*/
    HICON hIcon; 
    /** The handle of system menu.*/
    HMENU hSysMenu; 
    /** The pointer to logical font.*/
    PLOGFONT pLogFont;

    /** The caption of window.*/
    char* spCaption; 
    /** The identifier of window.
      * \note The type changed from int to LINT since v3.2.
      */
    LINT   id;

    /** The vertical scrollbar information.*/
    LFSCROLLBARINFO vscroll;
    /** The horizital scrollbar information.*/
    LFSCROLLBARINFO hscroll;

    /** The window renderer. */
    WINDOW_ELEMENT_RENDERER* we_rdr;
} WINDOWINFO;

/**
 * \fn const WINDOWINFO* GUIAPI GetWindowInfo (HWND hWnd)
 * \brief Get the handle of window information.
 *
 * This function gets the handle to the window information \
 * from the specified window handle \a hWnd.
 *
 * \param hWnd The handle to the window. 
 *
 * \return The handle to the window information.
 */
static inline const WINDOWINFO* GUIAPI GetWindowInfo (HWND hWnd)
{
    return (WINDOWINFO*)hWnd;
}

/** 
 * \fn BOOL GUIAPI InitWindowElementAttrs (PWERENDERER rdr)
 *
 * This function initializes window element attributes of the 
 * specified renderer \a rdr according to the appropriate section
 * in configuration file.
 *
 * \param rdr The pointer to the specified renderer.
 *
 * \return If succeed, return TRUE; otherwise return FALSE. 
 */
MG_EXPORT BOOL GUIAPI InitWindowElementAttrs (PWERENDERER rdr);

/**
 * \fn DWORD GUIAPI GetWindowElementAttr (HWND hwnd, int we_attr_id)
 * \brief Get a window element data.
 *
 * This function gets a window element data which is identified by 
 * \a we_attr_id.
 *
 * \param hwnd The handle to the window. 
 * \param we_attr_id The window element id number, can be one of the 
 *        following values:
 *
 *      - WE_FONT_CAPTION\n
 *        The caption font.
 *      - WE_FONT_MENU\n
 *        The menu font. Used by menu and listbox.
 *      - WE_FONT_MESSAGEBOX\n
 *        The messagebox font. Resevered.
 *      - WE_FONT_TOOLTIP\n
 *        The tooltip font. Used by tooltip window.
 *
 *      - WE_METRICS_CAPTION\n
 *        The caption size.
 *      - WE_METRICS_CAPTION_BUTTON\n
 *        The caption button size.
 *      - WE_METRICS_MENU\n
 *        The menu size.
 *      - WE_METRICS_WND_BORDER\n
 *        The border size.
 *      - WE_METRICS_SCROLLBAR\n
 *        The scrollbar size.
 *
 *      - WE_FGC_ACTIVE_CAPTION\n
 *        The active caption foreground color.
 *      - WE_BGCA_ACTIVE_CAPTION\n
 *        The active caption background color A.
 *      - WE_BGCB_ACTIVE_CAPTION\n
 *        The active caption background color B.
 *      - WE_FGC_MENU\n
 *        The menu foreground color.
 *      - WE_BGC_MENU\n
 *        The menu background color.
 *      - WE_FGC_MESSAGEBOX\n
 *        The messagebox foreground color. Reserved.
 *      - WE_FGC_TOOLTIP\n
 *        The tooltip foreground color. Only used by tooltip window.
 *      - WE_BGC_TOOLTIP\n
 *        The tooltip background color. Only used by tooltip window.
 *      - WE_FGC_ACTIVE_WND_BORDER\n
 *        The active border foreground color.
 *      - WE_FGC_INACTIVE_WND_BORDER\n
 *        The inactive border foreground color.
 *      - WE_FGC_INACTIVE_CAPTION\n
 *        The inactive caption foreground color.
 *      - WE_BGCA_INACTIVE_CAPTION\n
 *        The inactive caption background color A.
 *      - WE_BGCB_INACTIVE_CAPTION\n
 *        The inactive caption background color B.
 *      - WE_FGC_WINDOW\n
 *        The window foreground color. Used by window and control.
 *      - WE_BGC_WINDOW\n
 *        The window background color. Used by window and control.
 *      - WE_FGC_THREED_BODY\n
 *        The 3dbox foreground color. Mainly used by drawing 3dbox 
 *        object, such as dialog and button, etc.
 *      - WE_MAINC_THREED_BODY\n
 *        The 3dbox background color. Mainly used by drawing menubar, 
 *        dialog, header and button, etc.
 *      - WE_FGC_SELECTED_ITEM\n
 *        The selected item foreground color. Used by menu and control.
 *      - WE_BGC_SELECTED_ITEM\n
 *        The selected item background color. Used by menu and control.
 *      - WE_BGC_SELECTED_LOSTFOCUS\n
 *        The lostfocus selected item background color. Only Used by mledit.
 *      - WE_FGC_DISABLED_ITEM\n
 *        The disabled item foreground color. Used by menu and control.
 *      - WE_BGC_DISABLED_ITEM\n
 *        The disabled item background color. Used by menu and control.
 *      - WE_FGC_HIGHLIGHT_ITEM\n
 *        The highlight item foreground color. Used by menu and control.
 *      - WE_BGC_HIGHLIGHT_ITEM\n
 *        The highlight item background color. Used by menu and control.
 *      - WE_FGC_SIGNIFICANT_ITEM\n
 *        The significant item foreground color. Used by listbox.
 *      - WE_BGC_SIGNIFICANT_ITEM\n
 *        The significant item background color. Used by listbox.
 *      - WE_BGC_DESKTOP\n
 *        The desktop background color. Only used by desktop.
 *
 * \return If succeed, return the window element data; otherwise return -1.
 *
 * \sa SetWindowElementAttr
 */
MG_EXPORT DWORD GUIAPI GetWindowElementAttr (HWND hwnd, int we_attr_id);

/**
 * \fn DWORD GUIAPI SetWindowElementAttr (HWND hwnd, int we_attr_id, \
                        DWORD we_attr)
 * \brief Set a new window element data specified by \a we_attr_id.
 *
 * This function sets a new window element data \a we_attr to MiniGUI,
 * which is identified by \a we_attr_id.
 *
 * \param hwnd The handle to the window. 
 * \param we_attr_id The window element id. 
 * \param we_attr The new window element data. 
 *
 * \return If succeed, return the old window element data; otherwise return -1.
 *
 * \sa GetWindowElementAttr
 */
MG_EXPORT DWORD GUIAPI SetWindowElementAttr (HWND hwnd, int we_attr_id, 
        DWORD we_attr);

/**
 * \fn gal_pixel GUIAPI GetWindowElementPixelEx (HWND hwnd, \
                                        HDC hdc, int we_attr_id)
 * \brief Get a window element gal_pixel color.
 *
 * This function gets a window element gal_pixel color which is identified 
 * by \a we_attr_id and \a hdc.
 *
 * \param hwnd The handle to the window. 
 * \param hdc The device context. If -1, it will return pixel value according 
 *            to window handle \a hwnd; otherwise return pixel value according
 *            to pixel format in \a hdc. 
 * \param we_attr_id The window element id number. 
 *
 * \return If succeed, return the window element pixel color data; otherwise 
 *         return -1.
 *
 * \sa GetWindowElementAttr
 */
MG_EXPORT gal_pixel GUIAPI GetWindowElementPixelEx (HWND hwnd, 
        HDC hdc, int we_attr_id);

/**
 * \fn WINDOW_ELEMENT_RENDERER* GUIAPI GetWindowRendererFromName (const char* name)
 * \brief Get window renderer from name.
 * 
 * \param name The renderer name.
 *
 * This function gets window renderer from the specified name \a name, 
 * which is case-insensitive.
 *
 * \return The pointer to the window renderer for success, NULL for failure.
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one returns
 *      a const value.
 */
MG_EXPORT WINDOW_ELEMENT_RENDERER* 
    GUIAPI GetWindowRendererFromName (const char* name);

/**
 * \fn BOOL GUIAPI AddWindowElementRenderer (const char* name, \
                        const WINDOW_ELEMENT_RENDERER* we_rdr)
 * \brief Add a window element renderer to the system.
 * 
 * This function adds a new window renderer to MiniGUI system.
 * 
 * \param name The renderer name.
 * \param we_rdr The pointer to a new renderer.
 *
 * \return TRUE for success, FALSE for failure.
 */
MG_EXPORT BOOL GUIAPI AddWindowElementRenderer (const char* name, 
        const WINDOW_ELEMENT_RENDERER* we_rdr);

/**
 * \fn BOOL BOOL GUIAPI RemoveWindowElementRenderer (const char* name)
 * \brief Remove a window renderer from MiniGUI.
 * 
 * This function only removes a window renderer named by \a name.
 * 
 * \param name The renderer name.
 *
 * \return TRUE for success, FALSE for failure.
 */
MG_EXPORT BOOL GUIAPI RemoveWindowElementRenderer (const char* name);

/**
 * \fn WINDOW_ELEMENT_RENDERER* GUIAPI GetDefaultWindowElementRenderer (void)
 * \brief Get the default window renderer. 
 * 
 * This function gets the default window renderer in MiniGUI. 
 *
 * \return the pointer to the default renderer.
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one returns
 *      a const value.
 */
MG_EXPORT WINDOW_ELEMENT_RENDERER* 
        GUIAPI GetDefaultWindowElementRenderer (void);

/**
 * \fn const char* GUIAPI SetDefaultWindowElementRenderer (const char* name)
 * \brief Set a window element renderer as the default system renderer. 
 * 
 * This function sets a window element renderer as the default system
 * renderer. 
 * 
 * \param name The renderer name.
 *
 * \return the old renderer's name for success, NULL for failure.
 */
MG_EXPORT const char* GUIAPI SetDefaultWindowElementRenderer (const char* name);

/**
 * \fn BOOL GUIAPI SetWindowElementRenderer (HWND hwnd, \
                            const char* werdr_name, \
                            const WINDOW_ELEMENT_ATTR* we_attrs)
 *
 * \brief Set a window element renderer and window element attributes 
 *        for window specified by \a hwnd.
 * 
 * This function sets the window handled by \a hWnd to use a different 
 * window element renderer OR'ed window element attributes and updates 
 * window in time.
 * 
 * \param hwnd The handle to the window. 
 * \param werdr_name The renderer name.
 * \param we_attrs The pointer to new window element attributes.
 *
 * \return TRUE for success, FALSE for failure.
 */
MG_EXPORT BOOL GUIAPI SetWindowElementRenderer (HWND hWnd, 
        const char* werdr_name, const WINDOW_ELEMENT_ATTR* we_attrs);

/**
 * \fn BOOL GUIAPI InitRendererSystemIcon (const char* rdr_name, \
                            HICON *large_icon, HICON *small_icon);
 * \brief Initialize large and small system icons in the specified renderer
 *        \a rdr_name.
 *
 * \param rdr_name The renderer name.
 * \param large_icon The pointer to large system icons.
 * \param small_icon The pointer to small system icons.
 *
 * \return TRUE for success, FALSE for failure.
 */
MG_EXPORT BOOL InitRendererSystemIcon (const char* rdr_name, 
        HICON *small_icon, HICON *large_icon);

/**
 * \fn void GUIAPI TermRendererSystemIcon (HICON *large_icon, \
        HICON *small_icon);
 * \brief Release large and small system icon resources.
 *
 * \param large_icon The pointer to large system icons.
 * \param small_icon The pointer to small system icons.
 *
 * \sa InitRendererSystemIcon
 */
MG_EXPORT void TermRendererSystemIcon (HICON *small_icon, 
        HICON *large_icon);

    /** @} end of lf_fns */

    /**
     * \defgroup res_manage Resource managment functions
     * @{
     */
/**                                               
 * \fn BOOL GUIAPI RegisterResFromFile (HDC hdc, const char* file);
 * \brief Register a device-dependent bitmap from a file.
 *                                                
 * This function load a device-dependent bitmap from a file and register it to 
 * bitmap cache.                 
 *                                                
 * \param hdc The device context.
 * \param file The name of image file. The suffix indicates image type such as 
 *  bmp, png, jpg etc.
 * 
 * \return TRUE on success, FALSE on error.
 *
 */
MG_EXPORT BOOL GUIAPI RegisterResFromFile (HDC hdc, const char* file);


/**                                               
 * \fn BOOL GUIAPI RegisterResFromMem (HDC hdc, const char* file, \
 *              const unsigned char* data, size_t data_size);
 *
 * \brief Register a device-dependent bitmap to bitmap cache from memory.
 *                                                
 * This function load a device-dependent bitmap from memory and register it to 
 * bitmap cache.                 
 *                                                
 * \param hdc The device context.
 * \param file The name of image file. The suffix indicates image type such as 
 *  bmp, png, jpg etc.
 * \param data The pointer to image data.
 * \param data_size The size of image data.
 * 
 * \return TRUE on success, FALSE on error.
 *
 */
MG_EXPORT BOOL GUIAPI RegisterResFromMem (HDC hdc, const char* file, 
        const unsigned char* data, size_t data_size);

/**                                               
 * \fn BOOL GUIAPI RegisterResFromBitmap (const char* file, const BITMAP* bmp);
 * \brief Register a device-dependent bitmap to bitmap cache.
 *                                                
 * This function register a device-dependent bitmap to bitmap cache.            
 *                                                
 * \param file The name of image file. The suffix indicates image type such as 
 *  bmp, png, jpg etc.
 * \param bmp The pointer to a BITMAP object.
 * 
 * \return TRUE on success, FALSE on error.
 *
 */
MG_EXPORT BOOL GUIAPI RegisterResFromBitmap (const char* file, const BITMAP* bmp);

/**
 * \fn MG_EXPORT const BITMAP* RetrieveRes (const char *file)
 * \brief Get a BITMAP object from cache according to the specified resource 
 * file name.
 * 
 * This function gets a BITMAP object from cache according to the specified 
 * resource file name \a file.
 * 
 * \param file The specified file name.
 *
 * \return a BITMAP object for success, NULL for error.
 */
MG_EXPORT const BITMAP* GUIAPI RetrieveRes (const char *file);

/**
 * \fn void UnregisterRes (const char *file)
 * \brief Unregister the BITMAP object from cache according to the specified 
 * resource file name.
 * 
 * This function unregister the BITMAP object from cache according to the 
 * specified resource file name \a file and the BITMAP \a bmp.
 * 
 * \param file The specified file name.
 *
 * \return None.
 *
 */
MG_EXPORT void GUIAPI UnregisterRes (const char *file);

/**                                               
 * \fn BOOL GUIAPI RegisterSystemBitmap (HDC hdc, const char* rdr_name, \
 *                const char* id);
 * \brief Register a device-dependent bitmap from id to BITMAP cache.
 *                                                
 * This function load a device-dependent bitmap from id and register it to 
 * BITMAP cache. 
 *
 * \param hdc The device context.
 * \param rdr_name The name of window element renderer. NULL for default 
 *        renderer.
 * \param id The id of system image.
 * 
 * \return TRUE on success, FALSE on error.
 *
 */
MG_EXPORT BOOL GUIAPI RegisterSystemBitmap (HDC hdc, const char* rdr_name, 
        const char* id);

/**                                               
 * \fn void GUIAPI UnregisterSystemBitmap (HDC hdc, const char* rdr_name, \
 *                const char* id);
 * \brief Unregister a BITMAP object from BITMAP cache.
 *                                                
 * This function unregister a BITMAP object from BITMAP cache. 
 *
 * \param hdc The device context.
 * \param rdr_name The name of window element renderer. NULL for default 
 *        renderer.
 * \param id The id of system image.
 * 
 *
 */
MG_EXPORT void GUIAPI UnregisterSystemBitmap (HDC hdc, const char* rdr_name, 
        const char* id);

/* define the key of resource */
typedef unsigned long RES_KEY;
#define RES_KEY_INVALID 0

/* define the incore res type */
typedef struct _INNER_RES {
    RES_KEY key;
    Uint8* data;
    int data_len;

    /* special param recognized by the TYPE_OPS
     * normal is null. 
     * is the data is a mem of raw png, jpeg, bmp
     * and so on, it should be the extention name
     * of the filename. eg. 
     * INNER_RES res[]= { ... { ..., ... ,.., "png" } .. };
     * */
    void* additional;
} INNER_RES;

/* the type of resource */
enum emResType{
    RES_TYPE_INVALID = 0xFF,

    /* All kinds of image supported by MiniGUI
     * such as png, jpeg, bmp and so on
     * This type will make LoadResource return a
     * PBITMAP pointer
     */
    RES_TYPE_IMAGE = 0,

    /* All kinds of image supported by MiniGUI
     * This Type will make LoadResource return a MYBITMAP* pointer
     */
    RES_TYPE_MYBITMAP,

    /* the icon file and mem
     * it only make LoadResource load or get the FIRST
     * icon, and return HICON
     */
    RES_TYPE_ICON,

#ifdef _MGHAVE_CURSOR
    /* the cursor file or data
     * Make LoadResource return HCURSOR
     */
    RES_TYPE_CURSOR,
#endif

    /* the config file or data support by minigui
     * make LoadResource return GHANDLE
     * it should be accessed by GetValueFromEtc and GetIntValueFromEtc
     */
    RES_TYPE_ETC,

    /* NOT IMPLEMENT */
    RES_TYPE_TEXT,
    /* NOT IMPLEMENT */
    RES_TYPE_MENU,
    /* NOT IMPLEMENT */

    RES_TYPE_WINDOW,
    /* Make the LoadResource return the 
     * raw data of INNER_RES, it's a pointer
     * of MEM_RES
     * only support incore Resource,
     * if the resource is stored in disk, LoadResource will return NULL
     */
    RES_TYPE_MEM_RES, 

    RES_TYPE_FONT, 

    /* the beginning of user defined type
     */
    RES_TYPE_USER,

    /* the max valid value of type
     * used defined type must less this value
     */
    RES_TYPE_USER_MAX = 0x7F
};

/* the return value of LoadResource with type RES_TYPE_MEM_RES */
typedef struct _MEM_RES {
    Uint8 *data;
    int data_len;
} MEM_RES;

typedef struct _FONT_RES {
    LOGFONT logfont;
    RES_KEY key;
} FONT_RES;

/* the original source of resource 
 * depend on the values, the res manager
 * would select corrent loader to
 * load resource form disk or mem
 */

#define REF_SRC_NOTYPE 0x00

/* indicate that the resource is stored in disk */
#define REF_SRC_FILE 0x01

/* indicate that the resource is stored in memory*/
#define REF_SRC_INNER 0x02

/* indicate that the resource is stored in shared memory*/
#define REF_SRC_SHARED 0x03

/* indicate that the resource is stored in outside( NOT SUPPORTED) */
#define REF_SRC_OUTSIDE 0x04

/* indicate that the resource is stored in a stream object (NOT SUPPORTED) */
#define REF_SRC_STREAM 0x05

/* indicate that the resource is create by MiniGUI */
#define REF_SRC_LOGIC 0x06

/* the RESOUCE type for loadding */
typedef struct _RESOURCE {
    void* data; // store the pointer of cached resource
    union {
        void* src;
        INNER_RES* inner;
        char* file;
    } source; // indicate the stored format of resource
} RESOURCE;

/* The operations of one type of resource */
typedef struct _RES_TYPE_OPS {
    /* To get a resource
     * return the buffered resource pointer
     * param res the in and out param of resource.
     * param src_type, one of REF_SRC_XXX
     * param usr_param
     * */
    void* (*get_res_data)(RESOURCE* res, int src_type, DWORD usr_param);
    /* To unload a buffered resource
     */
    void (*unload)(RESOURCE* res, int src_type);
} RES_TYPE_OPS;

/* Return value and error code of resource manager */
enum emResReturn {
    RES_RET_OK = 0,
    RES_RET_INVALID_PARAM,
    RES_RET_NOT_EXIST_KEY, //RES_KEY is not exist
    RES_RET_LOAD_FILE_FAILED, 
    RES_RET_LOAD_MEM_FAILED,
    RES_RET_UNKNOWN_TYPE,
    RES_RET_NOT_IMPLEMENTED,
    RES_RET_INUSED //the res or object is in used, cannot be unloaded
};

/**
 * \fn const char* GetResPath (void)
 * \brief Get the currrent user's resource path.
 *
 * \param path The path which store the resources. It can be an absolute path or relative path.
 *
 * \return the user's resource path; NULL if have not been set.
 *
 * \sa SetResPath
 *
 **/
MG_EXPORT const char* GetResPath (void);

/**
 * \fn int SetResPath (const char* path);
 * \brief Set user's resource path into the search paths of resource manager.
 *
 * If you set this value, resource mamanger will try to find a resource in the path.
 *
 * \param path The path which store the resources. It can be an absolute path or relative path.
 *
 * \return RES_RET_OK for success or error code.
 *
 * \sa GetResPath
 *
 **/
MG_EXPORT int SetResPath (const char* path);

/**
 * \fn int AddInnerRes (INNER_RES* inner_res, int count, BOOL copy)
 * \brief Add some incore resource into the resource manager in order to 
 * call LoadResource to get those resource.
 *
 * \param inner_res The pointer to the incore resource.
 * \param count The bytes count of inner_res.
 * \param copy TRUE indicate that resource manager will copy the value of 
 *        inner_res array, otherwise, resource manager just save the 
 *        pointer to inner_res.
 *
 * \return RES_RET_OK for success or error code.
 */
MG_EXPORT int AddInnerRes (INNER_RES* inner_res, int count, BOOL copy);

/*
 *  NOT IMPLEMENT
 */
MG_EXPORT int AddSharedRes (const char* shared_name);

/**
 * \fn int RegisterResType (int type, RES_TYPE_OPS* ops)
 * \brief Register a new user-defined type into resource manager, 
 * so that the LoadResource can load the special resource automatically.
 *
 * \param type The user-defined type. It must >=RES_TYPE_USER and <RES_TYPE_USER_MAX
 * \param ops the operations of the resource.
 *
 * \return RES_RET_OK for success or error code
 *
 * \sa RES_TYPE_OPS, enum emResType, UnregisterResType
 */
MG_EXPORT int RegisterResType (int type, RES_TYPE_OPS* ops);

/**
 * \fn int UnregisterResType (int type)
 * \brief Unregister a user-defined resource type
 *
 * \param type The user-defined type registered by calling RegisterResType.
 *
 * \return RES_RET_OK or error code
 *
 * \sa RegisterResType
 */
MG_EXPORT int UnregisterResType (int type);

/**
 * \fn void* LoadResource (const char* res_name, int type, DWORD usr_param)
 * \brief Load a resource from disk or memory. 
 *
 * This function loads a resource from disk or memory. If the resource is loaded, 
 * it will return the buffered one and increase the reference count. This 
 * function will try to find a loader for the resource first according to 
 * \a type.
 *
 * \param res_name The resource name. If res_name is an absolute path 
 *        (the leading character is '/'), it will load resource from disk directly,
 *        else it will:
 *         - step 1) try to find the resource in loaded buffer.
 *         - step 2) if step 1 failed, try to load from incore memory.
 *         - step 3) if step 2 failed, try to find the file in the path set by SetResPath and load it.
 *         - step 4) if step 3 failed, try to find the file in the path where MiniGUI.cfg locates.
 *         - step 5) return NULL if all steps faild
 *     
 * \param type The resource type what you want to load. It must be one of the following values:
 *         - RES_TYPE_IMAGE: A BITMAP object (BITMAP*).
 *         - RES_TYPE_MYBITMAP: A MYBITMAP object (MYBITMAP*).
 *         - RES_TYPE_ICON: An icon (HICON).
 *         - RES_TYPE_CURSOR: A cursor (HCURSOR).
 *         - RES_TYPE_ETC: A configuration (GHANDLE).
 *         - RES_TYPE_TEXT: NOT implemented.
 *         - RES_TYPE_MENU: NOT implemented.
 *         - RES_TYPE_WINDOW: NOT implemented.
 *         - RES_TYPE_MEM_RES: A in-memory resource (MEM_RES*).
 *         - RES_TYPE_USER ~ RES_TYPE_USER_MAX: A user-defined resource type (void*).
 *
 * \param usr_param The param pass to RES_TYPE_OPS.get_res_data. For resource type 
 *        RES_TYPE_IMAGE and RES_TYPE_ICON, it must be a handle to DC.
 *
 * \return The pointer of resource, see the parameter type.
 *
 * \sa enum emResType, MEM_RES, SetResPath, AddInnerRes, RegisterResType, GetResource
 */
MG_EXPORT void* LoadResource (const char* res_name, int type, DWORD usr_param);

/**
 * \fn void* GetResource (RES_KEY key);
 * \brief Retrive and return a buffered resource by the key.
 *
 *  You should call LoadResource firstly, and then call GetResource when you need it.
 *  Note that GetResource will not increase the reference count automatically.
 *
 * \param key The key of the resource (use Str2Key(res_name) to get the key).
 *
 * \return the pointer to the resource; NULL if the resource does not exist.
 *
 * \sa LoadResource, Str2Key
 */
MG_EXPORT void* GetResource (RES_KEY key);

/**
 * \fn int AddResRef(RES_KEY key);
 *
 * \brief Increase the reference count of a buffered resource.
 *
 *  When you get a resource, you should call this function to ensure that
 *  the resource can not be unloaded when you still use it. 
 *  This function must be called after LoadResource.
 *
 *  \param key The key of resource (use Str2Key(res_name) to get the key).
 *
 *  \return The reference count; -1 if the resource does not exist.
 *
 * \sa LoadResource, GetResource, ReleaseRes, Str2Key
 */
MG_EXPORT int AddResRef (RES_KEY key);

/**
 * \fn int ReleaseRes (RES_KEY key);
 * \brief Release the buffered resource. It will decrease the reference count of 
 * the resource. If the reference count is less then 0, the resource will be released.
 *
 * \param key The key of the resource (use Str2Key(res_name) to get the key).
 *
 * \return The reference count; -1 if the resource does not exist.
 *
 * \sa LoadResource, GetResource, AddResRef, Str2Key
 */
MG_EXPORT int ReleaseRes (RES_KEY key);

#define LoadBitmapFromRes(hdc, res_name) \
    (PBITMAP)LoadResource(res_name, RES_TYPE_IMAGE, (DWORD)hdc)

#define GetBitmapFromRes(key) (BITMAP*)GetResource(key)

#define GetIconFromRes(key) (HICON)GetResource(key)

#ifndef _MGHAVE_CURSOR
#define GetCursorFromRes(key) (HCURSOR)GetResource(key)
#endif

#define GetEtcFromRes(key) (GHANDLE)GetResource(key)

#define LoadLogicFontFromRes(font_name)  (PLOGFONT)LoadResource(font_name, RES_TYPE_FONT, 0)
#define GetLogicFontFromRes(font_name)   (PLOGFONT)GetResource(Str2Key(font_name))
#define ReleaseLogicFont(font)  ReleaseRes(((FONT_RES*)(font))->key)
#define ReleaseLogicFontByName(font_name)  ReleaseRes(Str2Key(font_name))

/**
 * \fn RES_KEY Str2Key (const char* str);
 * \brief Translate a string to an unsigned long (RES_KEY), which is used to 
 * find a resource in the resource manager.
 *
 * \param str The name of resource. Normaly, it's a path and filename of the resource.
 *
 * \return The key. 
 *
 * \sa GetResource, AddResRef, ReleaseRes
 */
MG_EXPORT RES_KEY Str2Key (const char* str);


#ifdef __TARGET_MSTUDIO__
/**
 * \fn int GUIAPI GetWindowZOrder(HWND hWnd);
 * \brief Get The Control ZOrder in the parent window
 *
 * \param hWnd Handler of a control
 * 
 * \return return index of ZOrder or 0 if hWnd is a MainWindow or -1 if error
 *
 */
MG_EXPORT int GUIAPI GetWindowZOrder(HWND hWnd);

/**
 * \fn int GUIAPI SetWindowZOrder(HWND hWnd, int zorder);
 * \brief Set The Control ZOrder in the parent window
 *
 * \param hWnd handler of a control
 * \param zorder the index of ZOrder
 *
 * \return return the new index of ZOrder or 0 if hWnd is a MainWindow
 */
MG_EXPORT int GUIAPI SetWindowZOrder(HWND hWnd, int zorder);

#endif

    /** @} end of res_manage */

    /**
     * \defgroup window_fns Windowing functions
     * @{
     */

    /**
     * \defgroup window_create_fns Window creating/destroying
     * @{
     */

/**
 * \var typedef int (* WNDPROC)(HWND, int, WPARAM, LPARAM)
 * \brief Type of the window callback procedure.
 */
typedef LRESULT (* WNDPROC)(HWND, UINT, WPARAM, LPARAM);

extern MG_EXPORT HWND __mg_hwnd_desktop;

/**
 * \def HWND_DESKTOP
 * \brief Desktop window handle.
 */
#define HWND_DESKTOP        __mg_hwnd_desktop

/**
 * \def HWND_NULL
 * \brief Null window handle.
 */
#define HWND_NULL           ((HWND)0)

/**
 * \def HWND_INVALID
 * \brief Invalid window handle.
 */
#define HWND_INVALID        ((HWND)-1)

#define HWND_OTHERPROC      ((HWND)-1)

/**
 * Structure defines a main window.
 */
typedef struct _MAINWINCREATE
{
    /** The style of the main window */
    DWORD dwStyle;

    /** The extended style of the main window */
    DWORD dwExStyle;

    /** The caption of the main window */
    const char* spCaption;

    /** The handle to the menu of the main window */
    HMENU hMenu;

    /** The handle to the cursor of the main window */
    HCURSOR hCursor;

    /** The handle to the icon of the main window */
    HICON hIcon;

    /** The hosting main window */
    HWND  hHosting;

    /** The window callback procedure */
    LRESULT (*MainWindowProc)(HWND, UINT, WPARAM, LPARAM);

    /** The position of the main window in the screen coordinates */
    int lx, ty, rx, by;

    /** The pixel value of background color of the main window */
    gal_pixel iBkColor;

    /** The first private data associated with the main window */
    DWORD dwAddData;

    /** Reserved, do not use */
    DWORD dwReserved;
}MAINWINCREATE;
typedef MAINWINCREATE* PMAINWINCREATE;

#ifdef _MGRM_THREADS

/**
 * \fn int GUIAPI CreateThreadForMainWindow(pthread_t* thread, \
 *                                    pthread_attr_t* attr, \
 *                                    void * (*start_routine)(void *), \
 *                                    void * arg);
 *
 * \brief Create a thread for main window. 
 *
 * \sa pthread_create
 */
MG_EXPORT int GUIAPI CreateThreadForMainWindow(pthread_t* thread, 
                                     pthread_attr_t* attr, 
                                     void * (*start_routine)(void *), 
                                     void * arg);

/**
 * \fn pthread_t GUIAPI GetMainWinThread(HWND hMainWnd)
 * \brief Get the thread id which main window belongs to. 
 *
 * \return Thread id.
 */
MG_EXPORT pthread_t GUIAPI GetMainWinThread(HWND hMainWnd);

/**
 * \fn int GUIAPI WaitMainWindowClose(HWND hWnd, void** returnval)
 * \brief Suspends execution of the calling thread which main window belongs
 * to until the target thread terminates, unless the target thread has already 
 * terminated. 
 *
 * \return non-NULL value on success.
 */

MG_EXPORT int GUIAPI WaitMainWindowClose(HWND hWnd, void** returnval);
#endif

/**
 * \fn void GUIAPI MainWindowThreadCleanup(HWND hMainWnd)
 * \brief Cleans up system resource associated with a main window.
 *
 * This function cleans up the system resource such as message queue associated
 * with the main window \a hMainWnd. \a DestroyMainWindow does not
 * destroy all resource used by a main window, therefore, you should call
 * this function after calling \a DestroyMainWindow and skipping out from
 * the message loop. After calling this function, the main window object
 * will destroyed actually.
 *
 * \param hMainWnd The handle to the main window.
 *
 * \sa DestroyMainWindow
 */
MG_EXPORT void GUIAPI MainWindowThreadCleanup(HWND hMainWnd);

/**
 * \def MainWindowCleanup(hwnd)
 * \brief Is an alias of \a MainWindowThreadCleanup
 *
 * \sa MainWindowThreadCleanup
 */
#define MainWindowCleanup(hwnd)      MainWindowThreadCleanup(hwnd)

/**                                               
 * \fn HWND GUIAPI CreateMainWindowEx (PMAINWINCREATE pCreateInfo, \
 *                const char* werdr_name, const WINDOW_ELEMENT_ATTR* we_attrs, \
 *                const char* window_name, const char* layer_name);
 * \brief Creates a main window.
 *                                                
 * This function creates a main window by using some information, and returns 
 * the handle to the main window.                 
 *                                                
 * \param pCreateInfo The pointer to a MAINWINCREATE structure.
 * \param werdr_name The name of window element renderer. NULL for default 
 *                   renderer.
 * \param we_attrs The pointer to window element attribute table. NULL for 
 *                   default window attribute table.
 * \param window_name The window name; reserved for future use.
 * \param layer_name The layer name; reserved for future use.
 * 
 * \return The handle to the new main window; HWND_INVALID indicates an error.
 *                                                
 * \sa CreateMainWindow, MAINWINCREATE, styles                                         
 *
 * Example:
 *
 * \include createmainwindow.c
 */
MG_EXPORT HWND GUIAPI CreateMainWindowEx (PMAINWINCREATE pCreateInfo, 
                        const char* werdr_name, const WINDOW_ELEMENT_ATTR* we_attrs,
                        const char* window_name, const char* layer_name);

/**
 * \fn HWND GUIAPI CreateMainWindow (PMAINWINCREATE pCreateInfo)
 * \brief A simplified version of CreateMainWindowEx.
 *
 * This function creates a main window by calling CreateMainWindow function
 * and passing NULL for werdr_name, we_attrs, window_name, and layer_name 
 * parameters.
 *
 * \sa CreateMainWindowEx
 */
static inline HWND GUIAPI CreateMainWindow (PMAINWINCREATE pCreateInfo)
{
    return CreateMainWindowEx (pCreateInfo, NULL, NULL, NULL, NULL);
}

/**
 * \fn BOOL GUIAPI DestroyMainWindow (HWND hWnd)
 * \brief Destroys a main window.
 *
 * This function destroys the main window specified by \a hWnd.
 * It does not release all system resource used by the main window.
 * You should call \a MainWindowThreadCleanup to destroy the main window
 * actually.
 *
 * \param hWnd The handle to the main window.
 * \return TRUE on success, FALSE on error.
 *
 * \sa MainWindowThreadCleanup
 *
 * Example:
 *
 * \include destroymainwindow.c
 */
MG_EXPORT BOOL GUIAPI DestroyMainWindow (HWND hWnd);

/**
 * \fn BOOL GUIAPI SetWindowMask (HWND hWnd,  \
 *          const MYBITMAP* mask)
 * 
 * \brief Set window (a main window, or a child window which is 
 * also known as "control")'s Mask Rect with MYBITMAP data.
 * 
 * \param hWnd The handle to the window.
 * \param mask The mask of the window which indicate the transparency of
 * each pixel on this window.
 * 
 * \return return TRUE on success, otherwise FALSE.
 * 
 * \sa SetWindowRegion
 */
MG_EXPORT BOOL GUIAPI SetWindowMask (HWND hWnd, const MYBITMAP* mask);

/**
 * \fn BOOL GUIAPI SetWindowMaskEx (HWND hWnd, HDC hdc,  \
 *          const BITMAP* mask)
 * 
 * \brief Set window (a main window, or a child window which is 
 * also known as "control")'s Mask Rect with BITMAP data, 
 * 
 * \param hWnd The handle to the window.
 * \param hdc The reference dc which indicate the colorformat of the \a mask.
 * \param mask The mask of the window which indicate the transparency of
 * each pixel on this window.
 * 
 * \return return TRUE on success, otherwise FALSE.
 * 
 * \sa SetWindowRegion
 */
MG_EXPORT BOOL GUIAPI SetWindowMaskEx (HWND hWnd, HDC hdc, const BITMAP* mask);

/**
 * \fn BOOL GUIAPI SetWindowRegion (HWND hWnd, const CLIPRGN* region)
 * \brief Set window's Mask Rect with CLIPRGN data.
 *
 * \param hWnd The handle to the window.
 * \param region The region to indicate which part of the window is visible.
 * 
 * \return return TRUE on success, otherwise FALSE.
 */
BOOL GUIAPI SetWindowRegion (HWND hWnd, const CLIPRGN* region);

/**
 * \fn BOOL GUIAPI GetWindowRegion (HWND hWnd, CLIPRGN* region)
 * \brief The function obtains a copy of the window region of a window.
 *
 * This function obtains a copy of the window region of a window. 
 * The window region of a window is set by calling the SetWindowRegion 
 * or SetWindowMaskEx function. 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.
 *
 * \param hWnd Handle to the window whose window region is to be obtained.
 * \param region Pointer to the region which will be modified to 
 *        represent the window region.
 * 
 * \return return TRUE on success, otherwise FALSE.
 *
 * \sa SetWindowRegion, SetWindowMaskEx
 */
BOOL GUIAPI GetWindowRegion (HWND hWnd, CLIPRGN* region);

LRESULT GUIAPI PreDefMainWinProc (HWND hWnd, UINT message, 
                WPARAM wParam, LPARAM lParam);

LRESULT GUIAPI PreDefDialogProc (HWND hWnd, 
                UINT message, WPARAM wParam, LPARAM lParam);

LRESULT GUIAPI PreDefControlProc (HWND hWnd, UINT message, 
                WPARAM wParam, LPARAM lParam);

/**
 * \fn LRESULT DefaultWindowProc (HWND hWnd, UINT message, \
                WPARAM wParam, LPARAM lParam)
 * \brief The default window callback procedure.
 *
 * This window procedure can be used for main windows, dialog boxes,
 * and child windows.
 *
 * This function is the default window callback procedure.
 * You should call this function for all messages you do not want to handle
 * in your window procedure.
 *
 * \param hWnd The handle to the window.
 * \param message The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 */
MG_EXPORT LRESULT GUIAPI DefaultWindowProc (HWND hWnd, UINT message, 
                WPARAM wParam, LPARAM lParam);

/**
 * \var WNDPROC __mg_def_proc[3]
 * \brief The default window callback procedure array
 *
*/
extern MG_EXPORT WNDPROC __mg_def_proc[3];

/**
 * \def DefaultMainWinProc
 * \brief Is the default main window callback procedure.
 *
 * This function is the default main window callback procedure.
 * You should call this function for all messages, you do not want to handle
 * in your main window procedure.
 *
 * \param hWnd The handle to the window.
 * \param message The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 *
 */
#define DefaultMainWinProc (__mg_def_proc[0])

/**
 * \def DefaultDialogProc
 * \brief The default dialog box procedure.
 *
 * This function is the default dialog box procedure. 
 * You should call this function in your dialog box procedure 
 * to process the unhandled messages.
 *
 * \param hWnd The handle to the window.
 * \param message The message identifier.
 * \param wParam The first message parameter.
 * \param lParam The second message parameter.
 *
 * \return The return value of the message handler.
 *
 */
#define DefaultDialogProc  (__mg_def_proc[1])

/**
 * \def DefaultControlProc
 * \brief The default control callback procedure.
 *
 * This function is the default control callback procedure.
 * You should call this function for all messages, you do not want to handle
 * in your own control procedure.
 *
 * \param hWnd The handle to the window.
 * \param message The message identifier.
 * \param wParam The first parameter of the message.
 * \param lParam The second parameter of the message.
 */
#define DefaultControlProc (__mg_def_proc[2])

#ifdef _DEBUG
MG_EXPORT void GUIAPI DumpWindow (FILE* fp, HWND hWnd);
#endif /* _DEBUG */

    /** @} end of window_create_fns */

    /**
     * \defgroup window_general_fns General window operations
     * @{
     */

#define SW_HIDE              0x0000
#define SW_SHOW              0x0010
#define SW_SHOWNORMAL        0x0100

/**
 * \fn void GUIAPI UpdateWindow (HWND hWnd, BOOL bErase)
 * \brief Updates a window.
 *
 * This function updates the window specified by \a hWnd.
 * It will redraw the caption, the frame, and the menu bar of the window.
 * It will invalidate the client area of the window as well, and 
 * if \b bErase is TRUE, the client area will be erased by using 
 * background color.
 *
 * \param hWnd The handle to the window.
 * \param bErase Indicates whether to erase the client area of the window.
 *
 * \sa InvalidateRect
 */
MG_EXPORT void GUIAPI UpdateWindow (HWND hWnd, BOOL bErase);

/**
 * \fn BOOL GUIAPI ShowWindow (HWND hWnd, int iCmdShow)
 * \brief Shows or hides a window.
 *
 * This function shows or hides the window specified by \a hWnd.
 * 
 * \param hWnd The handle to the window.
 * \param iCmdShow The command to show or hide, can be one of 
 * the following values:
 *      - SW_SHOW\n
 *        Shows the window.
 *      - SW_HIDE\n
 *        Hides the window.
 *      - SW_SHOWNORMAL\n
 *        Shows the window, and if the window is a main window 
 *        sets it to be the top most main window.
 * \return TRUE on sucess, otherwise FALSE.
 */
MG_EXPORT BOOL GUIAPI ShowWindow (HWND hWnd, int iCmdShow);

/**
 * \fn BOOL GUIAPI EnableWindow (HWND hWnd, BOOL fEnable)
 * \brief Enables of disables a window.
 *
 * This function enables or disables mouse and keyboard input 
 * to the specified window \a hWnd. When input is disabled, the window 
 * does not receive input such as mouse clicks and key presses. 
 * When input is enabled, the window receives all input.
 *
 * \param hWnd The handle to the window.
 * \param fEnable Indicates whether to enable or disable the window, 
 *        TRUE for enable.
 * \return The old enable state of the window.
 *
 * \sa IsWindowEnabled
 */
MG_EXPORT BOOL GUIAPI EnableWindow (HWND hWnd, BOOL fEnable);

/**
 * \fn BOOL GUIAPI IsWindowEnabled (HWND hWnd)
 * \brief Determines whether the specified window is enabled for mouse 
 *        and keyboard input.
 *
 * This function returns the enable/disable state of the window specified by 
 * \a hWnd.
 *
 * \param hWnd The handle to the window.
 *
 * \return The enable/disable state of the window, TRUE for enabled.
 * 
 * \sa EnableWindow
 */
MG_EXPORT BOOL GUIAPI IsWindowEnabled (HWND hWnd);

/**
 * \fn BOOL GUIAPI GetClientRect(HWND hWnd, PRECT prc)
 * \brief Retrives the client rectangle of a window.
 *
 * This function retrives the coordinates of the client area of 
 * the window specified by \a hWnd. 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 always (0,0).
 *
 * \param hWnd The handle to the window.
 * \param prc The pointer to a RECT structure receives the client rectangle.
 *
 * \return TRUE on sucess, otherwise FALSE.
 *
 * \note Note that the coordinates of the upper-left corner are always zero.
 *
 * \sa MoveWindow
 */
MG_EXPORT BOOL GUIAPI GetClientRect(HWND hWnd, PRECT prc);

/**
 * \fn gal_pixel GUIAPI GetWindowBkColor (HWND hWnd)
 * \brief Returns the current background color of a window.
 *
 * This function returns the pixel value of the current background color of 
 * the window specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 *
 * \return The pixel value of the background color.
 *
 * \note The type of return value changed from int to gal_pixel since v3.2.
 *
 * \sa SetWindowBkColor
 */
MG_EXPORT gal_pixel GUIAPI GetWindowBkColor (HWND hWnd);

/**
 * \fn gal_pixel GUIAPI SetWindowBkColor (HWND hWnd, gal_pixel new_bkcolor)
 * \brief Sets the background color of a window.
 *
 * This function sets the background color of the specified window \a hWnd
 * to be new pixel value \a new_backcolor. You should call \a UpdateWindow
 * or \a InvalidateRect in order that the new background color runs into
 * affect.
 *
 * \param hWnd The handle to the window.
 * \param new_bkcolor The pixel value of the new background color.
 * \return The pixel value of the old background color.
 *
 * \note The type of return value and \a new_bkcolor changed from int to 
 *       gal_pixel since v3.2.
 *
 * \sa GetWindowBkColor
 */
MG_EXPORT gal_pixel GUIAPI SetWindowBkColor (HWND hWnd, gal_pixel new_bkcolor);

/**
 * \fn PLOGFONT GUIAPI GetWindowFont (HWND hWnd)
 * \brief Retrives the default font of a window.
 *
 * This function retrives the default font of the specified 
 * window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The default logical font of the window.
 *
 * \sa SetWindowFont
 */
MG_EXPORT PLOGFONT GUIAPI GetWindowFont (HWND hWnd);

/**
 * \fn PLOGFONT GUIAPI SetWindowFont (HWND hWnd, PLOGFONT pLogFont)
 * \brief Sets the default font of a window.
 *
 * This function sets the default font of the specified window \a hWnd
 * to be the logical font \a pLogFont. This function will send an
 * MSG_FONTCHANGING message to the window. If the handler of the message
 * returns non-zero value, this function will return immediately with the 
 * unchanged default font. Or, after the new default font set, this function 
 * will send an MSG_FONTCHANGED message to the window as a notification.
 *
 * \param hWnd The handle to the window.
 * \param pLogFont The new default logical font. If it is NULL, this function
 * will set the default font to be the system wchar font.
 *
 * \return The old default logical font of the window, NULL on error.
 *
 * \sa GetWindowFont, GetSystemFont
 */
MG_EXPORT PLOGFONT GUIAPI SetWindowFont (HWND hWnd, PLOGFONT pLogFont);

/**
 * \fn HCURSOR GUIAPI GetWindowCursor (HWND hWnd)
 * \brief Retrives the current cursor of a window.
 *
 * This function retrives the current cursor of the specified
 * window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The handle to the cursor.
 *
 * \sa SetWindowCursor
 */
MG_EXPORT HCURSOR GUIAPI GetWindowCursor (HWND hWnd);

/**
 * \fn HCURSOR GUIAPI SetWindowCursor (HWND hWnd, HCURSOR hNewCursor)
 * \brief Sets the current cursor of a window.
 *
 * This function sets the current cursor of the specified window \a hWnd with
 * argument \a hNewCursor.
 *
 * \param hWnd The handle to the window.
 * \param hNewCursor The handle to the new cursor.
 * \return The handle to the old cursor.
 *
 * \sa GetWindowCursor
 */
MG_EXPORT HCURSOR GUIAPI SetWindowCursor (HWND hWnd, HCURSOR hNewCursor);

/**
 * \fn HICON GUIAPI GetWindowIcon (HWND hWnd)
 * \brief Retrives the current icon of a window.
 *
 * This function retrives the current icon of the specified
 * window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The handle to the icon.
 *
 * \sa SetWindowIcon
 */
MG_EXPORT HICON GUIAPI GetWindowIcon (HWND hWnd);

/**
 * \fn HICON GUIAPI SetWindowIcon (HWND hWnd, HICON hIcon, BOOL bRedraw)
 * \brief Sets the current icon of a window.
 *
 * This function sets the current icon of the specified window \a hWnd with
 * argument \a hIcon.
 *
 * \param hWnd The handle to the window.
 * \param hIcon The handle to the new icon.
 * \param bRedraw Indicates whether to update the whole window.
 *
 * \return The handle to the old icon.
 *
 * \note Note that MiniGUI only provides icon support for main window so far.
 *
 * \sa GetWindowIcon
 */
MG_EXPORT HICON GUIAPI SetWindowIcon (HWND hWnd, HICON hIcon, BOOL bRedraw);

/**
 * \fn DWORD GUIAPI GetWindowStyle (HWND hWnd)
 * \brief Retrives the style of a window.
 *
 * This function retrives the style of the window specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The style of the window.
 *
 * \sa GetWindowExStyle
 */
MG_EXPORT DWORD GUIAPI GetWindowStyle (HWND hWnd);

/**
 * \fn DWORD GUIAPI GetWindowExStyle (HWND hWnd)
 * \brief Retrives the extended style of a window.
 *
 * This function retrives the extended style of the window specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The extended style of the window.
 *
 * \sa GetWindowStyle
 */
MG_EXPORT DWORD GUIAPI GetWindowExStyle (HWND hWnd);

/**
 * \fn BOOL GUIAPI ExcludeWindowStyle (HWND hWnd, DWORD dwStyle)
 * \brief Removes the specific style of a window.
 *
 * This function removes the specific style of the window 
 * specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param dwStyle The specific style which will be removed.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa ExcludeWindowStyle
 */
MG_EXPORT BOOL GUIAPI ExcludeWindowStyle (HWND hWnd, DWORD dwStyle);

/**
 * \fn BOOL GUIAPI IncludeWindowStyle (HWND hWnd, DWORD dwStyle)
 * \brief Includes the specific style of a window.
 *
 * This function includes the specific style of the window 
 * specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param dwStyle The specific style which will be included.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa IncludeWindowStyle
 */
MG_EXPORT BOOL GUIAPI IncludeWindowStyle (HWND hWnd, DWORD dwStyle);

/**
 * \fn BOOL GUIAPI ExcludeWindowExStyle (HWND hWnd, DWORD dwStyle)
 * \brief Removes the specific extended style of a window.
 *
 * This function removes the specific extended style of the window 
 * specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param dwStyle The specific extended style which will be removed.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa ExcludeWindowStyle
 */
MG_EXPORT BOOL GUIAPI ExcludeWindowExStyle (HWND hWnd, DWORD dwStyle);

/**
 * \fn BOOL GUIAPI IncludeWindowExStyle (HWND hWnd, DWORD dwStyle)
 * \brief Includes the specific extended style of a window.
 *
 * This function includes the specific extended style of the window 
 * specified by \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param dwStyle The specific extended style which will be included.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa IncludeWindowStyle
 */
MG_EXPORT BOOL GUIAPI IncludeWindowExStyle (HWND hWnd, DWORD dwStyle);

/**
 * \fn WNDPROC GUIAPI GetWindowCallbackProc (HWND hWnd)
 * \brief Retrives the callback procedure of a window.
 *
 * This function retrives the window callback procedure of the specified window
 * \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The callback procedure of the window.
 *
 * \sa SetWindowCallbackProc
 */
MG_EXPORT WNDPROC GUIAPI GetWindowCallbackProc (HWND hWnd);

/**
 * \fn WNDPROC GUIAPI SetWindowCallbackProc (HWND hWnd, WNDPROC newProc)
 * \brief Sets the callback procedure of a window.
 *
 * This function sets the window callback procedure of the specified window
 * \a hWnd to be the procedure \a newProc.
 *
 * \param hWnd The handle to the window.
 * \param newProc The new callback procedure of the window.
 * \return The old callback procedure of the window.
 *
 * \sa GetWindowCallbackProc
 *
 * Example:
 *
 * \include subclass.c
 */
MG_EXPORT WNDPROC GUIAPI SetWindowCallbackProc (HWND hWnd, WNDPROC newProc);

/**
 * \fn DWORD GUIAPI GetWindowAdditionalData (HWND hWnd)
 * \brief Retrives the first additional data of a window.
 *
 * This function retrives the first additional data of the specified window
 * \a hWnd.
 * 
 * \param hWnd The handle to the window.
 * \return The first additional data of the window.
 *
 * \sa SetWindowAdditionalData
 */
MG_EXPORT DWORD GUIAPI GetWindowAdditionalData (HWND hWnd);

/**
 * \fn DWORD GUIAPI SetWindowAdditionalData (HWND hWnd, DWORD newData)
 * \brief Sets the first additional data of a window.
 *
 * This function sets the first additional data of the specified window
 * \a hWnd.
 * 
 * \param hWnd The handle to the window.
 * \param newData The new first additional data of the window.
 * \return The old first additional data of the window.
 *
 * \note For a dialog box created by \a DialogBoxIndirectParam, 
 *       its second additional data used internally by the system to save 
 *       the return value of the box. So you should avoid setting the 
 *       second additional data of a dialog box.
 *
 * \sa GetWindowAdditionalData
 */
MG_EXPORT DWORD GUIAPI SetWindowAdditionalData (HWND hWnd, DWORD newData);

/**
 * \fn DWORD GUIAPI GetWindowAdditionalData2 (HWND hWnd)
 * \brief Retrives the second additional data of a window.
 *
 * This function retrives the second additional data of the specified window
 * \a hWnd.
 * 
 * \param hWnd The handle to the window.
 * \return The second additional data of the window.
 *
 * \sa SetWindowAdditionalData2
 */
MG_EXPORT DWORD GUIAPI GetWindowAdditionalData2 (HWND hWnd);

/**
 * \fn DWORD GUIAPI SetWindowAdditionalData2 (HWND hWnd, DWORD newData)
 * \brief Sets the second additional data of a window.
 *
 * This function sets the second additional data of the specified window
 * \a hWnd.
 * 
 * \param hWnd The handle to the window.
 * \param newData The new second additional data of the window.
 * \return The old second additional data of the window.
 *
 * \note For a control created by \a CreateWindowEx, its second additional
 *       data is reserved for internal use. So you should avoid setting 
 *       the second additional data of a control.
 *
 * \sa GetWindowAdditionalData2
 */
MG_EXPORT DWORD GUIAPI SetWindowAdditionalData2 (HWND hWnd, DWORD newData);

/**
 * \fn DWORD GUIAPI GetWindowClassAdditionalData (HWND hWnd)
 * \brief Retrives the additional data of a control class.
 *
 * This function retrives the additional data of the control class to which
 * the specified control \a hWnd belongs.
 *
 * \param hWnd The handle to the control.
 *
 * \return The additional data of the control class to which the control 
 *         belongs.
 *
 * \note Note that this function always returns zero for the main window.
 *
 * \sa SetWindowClassAdditionalData
 */
MG_EXPORT DWORD GUIAPI GetWindowClassAdditionalData (HWND hWnd);

/**
 * \fn DWORD GUIAPI SetWindowClassAdditionalData (HWND hWnd, DWORD newData)
 * \brief Sets the additional data of a control class.
 *
 * This function sets the additional data of the control class to which
 * the specified control \a hWnd belongs.
 *
 * \param hWnd The handle to the control.
 * \param newData The new additional data of the control class.
 * \return The old additional data of the control class.
 *
 * \note This function always does nothing and returns zero for the main window.
 *
 * \sa SetWindowClassAdditionalData
 */
MG_EXPORT DWORD GUIAPI SetWindowClassAdditionalData (HWND hWnd, DWORD newData);

/**
 * \fn const char* GUIAPI GetWindowCaption (HWND hWnd)
 * \brief Retrives the caption of a window.
 *
 * This function retrives the caption of the specified window \a hWnd.
 *
 * \param hWnd The handle to the window.
 *
 * \return The pointer to the caption string of the window.
 *
 * \sa SetWindowCaption
 */
MG_EXPORT const char* GUIAPI GetWindowCaption (HWND hWnd);

/**
 * \fn BOOL GUIAPI SetWindowCaption (HWND hWnd, const char* spCaption)
 * \brief Sets the caption of a window.
 *
 * This function sets the caption of the specified window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param spCaption The pointer to the new caption of the window.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa GetWindowCaption, SetWindowText
 */
MG_EXPORT BOOL GUIAPI SetWindowCaption (HWND hWnd, const char* spCaption);

/**
 * \fn BOOL GUIAPI InvalidateRect (HWND hWnd, const RECT* prc, BOOL bEraseBkgnd)
 * \brief Makes a rectangle region in the client area of a window invalid.
 *
 * This function adds a rectangle pointed to by \a prc to the specified 
 * window's update region. The update region represents the portion of 
 * the window's client area that must be redrawn, and erase background 
 * if argument \a bReaseBkgnd is set.
 *
 * \param hWnd The handle to the window.
 * \param prc The pointer to a RECT structure which defines the 
 *        invalid rectangle.
 * \param bEraseBkgnd Indicates whether the background should be erased.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa MSG_PAINT
 */
MG_EXPORT BOOL GUIAPI InvalidateRect (HWND hWnd, 
                const RECT* prc, BOOL bEraseBkgnd);

/**
 * \fn BOOL GUIAPI InvalidateRegion (HWND hWnd, const CLIPRGN* pRgn, BOOL bErase)
 * \brief Invalidates the client area within the specified region.
 *
 * This function invalidates the client area within the specified region 
 * by adding it to the current update region of a window. The invalidated 
 * region, along with all other areas in the update region, is marked for 
 * painting when the next MSG_PAINT message occurs.
 *
 * \param hWnd Handle to the window with an update region that is to be 
 *        modified.
 * \param pRgn Pointer to the region to be added to the update region. 
 *        The region is assumed to have client coordinates. If this 
 *        parameter is NULL, the entire client area is added to the 
 *        update region.
 * \param bErase Specifies whether the background within the 
 *        update region should be erased when the update region is processed. 
 *        If this parameter is TRUE, the background is erased. If the 
 *        parameter is FALSE, the background remains unchanged.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \note Invalidated areas accumulate in the update region until the 
 *       next MSG_PAINT message is processed or until the region is 
 *       validated by using the ValidateRect or ValidateRegion function.
 *       MiniGUI sends a MSG_PAINT message to a window whenever its 
 *       update region is not empty and there are no other messages 
 *       in the application queue for that window.
 *       The specified region must have been created by using one of 
 *       the region functions.
 *       If the bErase parameter is TRUE for any part of the update region, 
 *       the background in the entire region is erased, not just in 
 *       the specified part.
 *
 * \sa MSG_PAINT, InvalidateRect, ValidateRegion
 */
MG_EXPORT BOOL GUIAPI InvalidateRegion (HWND hWnd, const CLIPRGN* pRgn, BOOL bErase);

/**
 * \fn BOOL GUIAPI ValidateRect (HWND hWnd, const RECT* rect)
 * \brief Validates the client area within a rectangle by removing 
 *        the rectangle from the update region of the specified window.
 *
 * This function validates the client area within a rectangle by 
 * removing the rectangle from the update region of the specified window.
 *
 * \param hWnd Handle to the window whose update region is to be modified.
 * \param rect Pointer to a RECT structure that contains the client 
 *        coordinates of the rectangle to be removed from the update region. 
 *        If this parameter is NULL, the entire client area is removed.
 *
 * \return If the function succeeds, the return value is nonzero. 
 *         If the function fails, the return value is zero.
 *
 * \note The BeginPaint function automatically validates the entire 
 *       client area. Neither the ValidateRect nor ValidateRegion function 
 *       should be called if a portion of the update region must be 
 *       validated before the next MSG_PAINT message is generated.
 *       The system continues to generate MSG_PAINT messages until 
 *       the current update region is validated.
 *
 * \sa MSG_PAINT, BeginPaint, ValidateRegion, InvalidateRect
 */
MG_EXPORT BOOL GUIAPI ValidateRect (HWND hWnd, const RECT* rect);

/**
 * \fn BOOL GUIAPI ValidateRegion (HWND hWnd, const CLIPRGN* pRgn)
 * \brief Validates the client area within a region by removing the 
 *        region from the current update region of the specified window.
 *
 * This function validates the client area within a region by removing 
 * the region \a pRgn from the current update region of the specified 
 * window \a hWnd.
 *
 * \param hWnd Handle to the window whose update region is to be modified.
 * \param pRgn A region that defines the area to be removed from the 
 *        update region. If this parameter is NULL, the entire client area 
 *        is removed.
 *
 * \return If the function succeeds, the return value is nonzero. 
 *         If the function fails, the return value is zero.
 *
 * \note The specified region must have been created by a region function. 
 *       The region coordinates are assumed to be client coordinates.
 *       The BeginPaint function automatically validates the entire client area. 
 *       Neither the ValidateRect nor ValidateRegion function should be called 
 *       if a portion of the update region must be validated before the 
 *       next MSG_PAINT message is generated.
 *
 * \sa MSG_PAINT, BeginPaint, ValidateRect, InvalidateRegion
 */
MG_EXPORT BOOL GUIAPI ValidateRegion (HWND hWnd, const CLIPRGN* pRgn);

/**
 * \fn HDC GUIAPI BeginPaint(HWND hWnd)
 * \brief Prepares a window for painting.
 *
 * This function prepares the specified window \a hWnd for painting.
 * This function is called in the handler of MSG_PAINT message normally.
 * It returns a device context including the update region of the window.
 * When you are done with the device context, you should call \a EndPaint
 * to finish the painting of the window.
 *
 * \param hWnd The handle to the window.
 * \return The device context.
 *
 * \sa EndPaint
 */
MG_EXPORT HDC GUIAPI BeginPaint(HWND hWnd);

/**
 * \fn void GUIAPI EndPaint(HWND hWnd, HDC hdc)
 * \brief Marks the end of painting in a window.
 *
 * This function marks the end of painting in the specified window. 
 * This function is required for each call to the \a BeginPaint function, 
 * but only after painting is complete.
 *
 * \param hWnd The handle to the window.
 * \param hdc The device context returned by BeginPaint.
 *
 * \sa BeginPaint
 */
MG_EXPORT void GUIAPI EndPaint(HWND hWnd, HDC hdc);

/**
 * \fn BOOL GUIAPI GetUpdateRect (HWND hWnd, RECT* update_rect)
 * \brief Retrives the bounding box of the update region of a window.
 *
 * This function retrives the bounding box of the update region of
 * the specified window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param update_rect The pointer to a RECT structure which will contains 
 *        the bounding box of the update region.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa InvalidateRect
 */
MG_EXPORT BOOL GUIAPI GetUpdateRect (HWND hWnd, RECT* update_rect);

/**
 * \fn int GUIAPI GetUpdateRegion (HWND hWnd, PCLIPRGN pRgn)
 * \brief Copy the update region of a window to a region.
 *
 * This function copies the update region of the specified window \a hWnd
 * into the region \a pRgn.
 *
 * \param hWnd The handle to the window.
 * \param pRgn The pointer to a region which receives the update region 
 *        of the window.
 *
 * \return The region type.
 * \retval NULLREGION     Region is empty.
 * \retval SIMPLEREGION   Region is a single rectangle.
 * \retval COMPLEXREGION  Region is more than one rectangle.
 * \retval -1             An error occurred.
 *
 * \sa GetUpdateRect
 */
MG_EXPORT int GUIAPI GetUpdateRegion (HWND hWnd, PCLIPRGN pRgn);

/**
 * \fn int GUIAPI ClientWidthToWindowWidthEx (DWORD dwStyle, \
                     int win_type, int cw)
 * \brief Calculates main window width from the width of the client area.
 *
 * This function calculates the window width from the width of the 
 * client area.
 *
 * \param dwStyle The style of window.
 * \param win_type The type of window.
 * \param cw The width of the client area.
 *
 * \return The width of the main window.
 *
 * \sa ClientHeightToWindowHeightEx
 */
MG_EXPORT int GUIAPI ClientWidthToWindowWidthEx (DWORD dwStyle, 
        int win_type, int cw);

/**
 * \fn int GUIAPI ClientHeightToWindowHeightEx (DWORD dwStyle, int win_type, \
                int ch, BOOL hasMenu)
 * \brief Calculates window height from the height of the client area.
 *
 * This function calculates the main window height from the height of
 * the client area.
 *
 * \param dwStyle The style of window.
 * \param win_type The type of window.
 * \param ch The height of the client area.
 * \param hasMenu Indicates whether the main window has menu.
 * \return The height of the main window.
 *
 * \sa ClientWidthToWindowWidthEx
 */
MG_EXPORT int GUIAPI ClientHeightToWindowHeightEx (DWORD dwStyle, 
        int win_type, int ch, BOOL hasMenu);

#define ClientWidthToWindowWidth(dwStyle, cw) \
    ClientWidthToWindowWidthEx (dwStyle, LFRDR_WINTYPE_MAINWIN, cw)

#define ClientHeightToWindowHeight(dwStyle, ch, hasMenu) \
    ClientHeightToWindowHeightEx (dwStyle, LFRDR_WINTYPE_MAINWIN, ch, hasMenu)

/**
 * \fn BOOL AdjustWindowRectEx (RECT* pRect, DWORD dwStyle, BOOL bMenu, 
                DWORD dwExStyle)
 * \brief Calculates the required size of the window rectangle 
 *        based on the desired size of the client rectangle.
 *
 * This function calculates the required size of the window rectangle, 
 * based on the desired size of the client rectangle. The window rectangle 
 * can then be passed to the CreateMainWindow or CreateWindow 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 takes the WS_VSCROLL or WS_HSCROLL 
 * styles into account.
 *
 * \param pRect 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. 
 * \param dwStyle Specifies the window style of the window whose required 
 *        size is to be calculated.
 * \param bMenu Specifies whether the window has a menu. 
 * \param dwExStyle Specifies the extended window style of the window whose 
 *        required size is to be calculated. 
 *
 * \return If the function succeeds, the return value is nonzero. 
 *         If the function fails, the return value is zero.
 *
 * \sa ClientWidthToWindowWidth, ClientHeightToWindowHeight
 */
MG_EXPORT BOOL GUIAPI AdjustWindowRectEx (RECT* pRect, DWORD dwStyle, 
                BOOL bMenu, DWORD dwExStyle);

/**
 * \fn void GUIAPI ClientToScreen (HWND hWnd, int* x, int* y)
 * \brief Converts the client coordinates of a point to screen coordinates.
 *
 * This function converts the client coordinates of the specified point 
 * \a (*x,*y) in the specified window \a hWnd to screen coordinates.
 *
 * \param hWnd The handle to the window.
 * \param x The pointer to the x coordinate.
 * \param y The pointer to the y coordinate.
 * 
 * \sa ScreenToClient
 */
MG_EXPORT void GUIAPI ClientToScreen (HWND hWnd, int* x, int* y);

/**
 * \fn void GUIAPI ScreenToClient (HWND hWnd, int* x, int* y)
 * \brief Converts the screen coordinates of a point to client coordinates.
 *
 * This function converts the screen coordinates of the specified point 
 * \a (*x,*y) to client coordinates of the specified window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param x The pointer to the x coordinate.
 * \param y The pointer to the y coordinate.
 * 
 * \sa ClientToScreen
 */
MG_EXPORT void GUIAPI ScreenToClient (HWND hWnd, int* x, int* y);

/**
 * \fn void GUIAPI ClientToWindow  (HWND hWnd, int* x, int* y)
 * \brief Converts the client coordinates to the window coordinates.
 *
 * This function converts the client coordinates of the specified point 
 * \a (*x,*y) in the specified window \a hWnd to the window coordinates.
 *
 * \param hWnd The handle to the window.
 * \param x The pointer to the x coordinate.
 * \param y The pointer to the y coordinate.
 * 
 * \sa WindowToClient
 */
MG_EXPORT void GUIAPI ClientToWindow(HWND hWnd, int* x, int* y);

/**
 * \fn void GUIAPI WindowToClient (HWND hWnd, int* x, int* y)
 * \brief Converts the window coordinates to client coordinates.
 *
 * This function converts the window coordinates of the specified point 
 * \a (*x,*y) in the specified window \a hWnd to the client coordinates.
 *
 * \param hWnd The handle to the window.
 * \param x The pointer to the x coordinate.
 * \param y The pointer to the y coordinate.
 * 
 * \sa WindowToScreen
 */
MG_EXPORT void GUIAPI WindowToClient(HWND hWnd, int* x, int* y);


/**
 * \fn void GUIAPI WindowToScreen (HWND hWnd, int* x, int* y)
 * \brief Converts the window coordinates of a point to screen coordinates.
 *
 * This function converts the window coordinates of the specified point 
 * \a (*x,*y) in the specified window \a hWnd to the screen coordinates.
 *
 * \param hWnd The handle to the window.
 * \param x The pointer to the x coordinate.
 * \param y The pointer to the y coordinate.
 * 
 * \sa ScreenToWindow
 */
MG_EXPORT void GUIAPI WindowToScreen (HWND hWnd, int* x, int* y);

/**
 * \fn void GUIAPI ScreenToWindow (HWND hWnd, int* x, int* y)
 * \brief Converts the screen coordinates of a point to window coordinates.
 *
 * This function converts the screen coordinates of the specified point 
 * \a (*x,*y) to the window coordinates of the specfied window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \param x The pointer to the x coordinate.
 * \param y The pointer to the y coordinate.
 * 
 * \sa WindowToScreen
 */
MG_EXPORT void GUIAPI ScreenToWindow (HWND hWnd, int* x, int* y);

/**
 * \fn BOOL GUIAPI IsMainWindow (HWND hWnd)
 * \brief Determines whether a window is a main window.
 *
 * This function determines whether the specified window \a hWnd is 
 * a main window or not.
 *
 * \param hWnd The handle to the window.
 *
 * \return TRUE for main window, otherwise FALSE.
 *
 * \sa IsControl, IsWindow
 */
MG_EXPORT BOOL GUIAPI IsMainWindow (HWND hWnd);

/**
 * \fn BOOL GUIAPI IsControl (HWND hWnd)
 * \brief Determines whether a window is a control.
 *
 * This function determines whether the specified window \a hWnd is a control.
 *
 * \param hWnd The handle to the window.
 *
 * \return TRUE for control, otherwise FALSE.
 *
 * \sa IsMainWindow, IsWindow
 */
MG_EXPORT BOOL GUIAPI IsControl (HWND hWnd);

/**
 * \fn BOOL GUIAPI IsWindow (HWND hWnd)
 * \brief Determines whether a window handle identifies an existing window.
 *
 * This function determines whether the specified window handle \a hWnd 
 * identifies an existing window.
 *
 * \param hWnd The window handle.
 *
 * \return TRUE for window, otherwise FALSE.
 *
 * \sa IsMainWindow, IsControl
 */
MG_EXPORT BOOL GUIAPI IsWindow (HWND hWnd);

/**
 * \fn BOOL GUIAPI IsDialog (HWND hWnd)
 * \brief Determines whether a window handle identifies a dialog window.
 *
 * This function determines whether the specified window handle \a hWnd 
 * identifies a dialog window.
 *
 * \param hWnd The window handle.
 *
 * \return TRUE for dialog window, otherwise FALSE.
 *
 * \sa IsMainWindow, IsControl
 */
MG_EXPORT BOOL GUIAPI IsDialog (HWND hWnd);

/**
 * \fn HWND GUIAPI GetParent (HWND hWnd)
 * \brief Retrieves the handle to a child window's parent window.
 *
 * This function retrieves the handle to the specified child window's 
 * parent window.
 *
 * \param hWnd The handle to the child window.
 *
 * \return The handle to the parent, HWND_INVALID indicates an error.
 *
 * \note For a main window, this function always returns 0. 
 *       For HWND_DESKTOP or an invalid window handle, 
 *       HWND_INVALID will be returned.
 *
 * \sa GetMainWindowHandle
 */
MG_EXPORT HWND GUIAPI GetParent (HWND hWnd);

/**
 * \fn HWND GUIAPI GetMainWindowHandle (HWND hWnd)
 * \brief Retrives the handle to the main window contains a window.
 *
 * This function retrives the handle to the main window which contains the
 * specified window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The handle to the main window, HWND_INVALID indicates an error.
 *
 * \note For a main window, this function always returns the handle to itself.
 *       For HWND_DESKTOP, HWND_DESKTOP is returned.
 *
 * \sa GetParent
 */
MG_EXPORT HWND GUIAPI GetMainWindowHandle (HWND hWnd);

/**
 * \fn BOOL GUIAPI IsWindowVisible (HWND hWnd)
 * \brief Retrieves the visibility state of the specified window.
 *
 * This function retrives the visibility state of the specified window \a hWnd.
 *
 * \param hWnd Handle to the window to test.
 *
 * \return If the specified window, its parent window, its parent's parent 
 *         window, and so forth, all have the WS_VISIBLE style, the return 
 *         value is nonzero. Otherwise the return value is zero.
 *
 * \sa ShowWindow
 */
MG_EXPORT BOOL GUIAPI IsWindowVisible (HWND hWnd);

/**
 * \fn BOOL GUIAPI GetWindowRect (HWND hWnd, PRECT prc)
 * \brief Retrives the dimensions of the bounding rectangle of a window. 
 *
 * This function retrives the dimension of the bounding rectangle of
 * the specified window \a hWnd. The dimensions are given in parent's
 * client coordinates (screen coordinates for main window) that are 
 * relative to the upper-left corner of the parent's client area (screen).
 *
 * \param hWnd The handle to the window.
 * \param prc The pointer to a RECT structure which will contains the 
 *        window rectangle.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa GetClientRect
 */
MG_EXPORT BOOL GUIAPI GetWindowRect (HWND hWnd, PRECT prc);

/**
 * \fn HWND GUIAPI GetNextChild (HWND hWnd, HWND hChild)
 * \brief Retrives the next control in a window.
 *
 * This function retrives the next child of the specified 
 * window \a hWnd. If you pass HWND_NULL for the argument
 * of \a hChild, the function will return the first child of the window.
 *
 * \param hWnd The handle to the window.
 * \param hChild The handle to a child of the window.
 * \return The handle of the next child. If you pass HWND_NULL for
 *         the argument of \a hChild, it will return the first child of the 
 *         window. When the child you passed is the last one, this function 
 *         will return HWND_NULL. If hWnd is not the parent of hChild, 
 *         this function will return HWND_INVALID.
 *
 * \sa GetNextMainWindow
 *
 * \note Do not use HWND_DESKTOP for \a hWnd or \a hChild.
 *
 * Example:
 *
 * \include nextcontrol.c
 */
MG_EXPORT HWND GUIAPI GetNextChild (HWND hWnd, HWND hChild);

/**
 * \fn HWND GUIAPI GetNextMainWindow (HWND hMainWnd)
 * \brief Retrives the next main window in the system according to the zorder.
 *
 * This function retrives the next main window of the specified 
 * main window \a hMainWnd.
 *
 * \param hMainWnd The handle to the main window.
 *
 * \return The handle of the next main window. If you pass HWND_NULL 
 *         for the argument of \a hMainWnd, it will return the topmost main 
 *         window. When the main window you passed is the bottommost one, 
 *         this function will return HWND_NULL. If hMainWnd is not a main 
 *         window, the function will return HWND_INVALID.
 *
 * \sa GetNextChild
 */
MG_EXPORT HWND GUIAPI GetNextMainWindow (HWND hMainWnd);

/**
 * \fn HWND GUIAPI GetHosting (HWND hMainWnd)
 * \brief Retrives the hosting main window of a main window.
 *
 * This function retrives the hosting main window of the specified 
 * main window \a hWnd. The hosting main window creates the message queue,
 * which shared with all hosted main window of it.
 * The hosting window of a top-level main window is HWND_DESKTOP.
 *
 * HWND_DESKTOP has no hosting window, do not use this function for it.
 *
 * \param hMainWnd The handle to the main window.
 *
 * \return The handle to the hosting main window. A valid window must have a 
 *         hosting window.  If error occurs, such as a invalid handle or 
 *         HWND_DESKTOP is passed as \a hMainWnd, HWND_INVALID is returned.
 *
 * \sa GetFirstHosted, GetNextHosted
 */
MG_EXPORT HWND GUIAPI GetHosting (HWND hMainWnd);

/**
 * \fn HWND GUIAPI GetFirstHosted (HWND hHosting)
 * \brief Retrives the first hosted main window of a main window.
 *
 * This function retrives the first hosted main window of 
 * the specified main window \a hMainWnd.
 *
 * For MiniGUI-Threads, HWND_DESKTOP has no any "hosted" window, 
 * so do not use this function for it.
 *
 * \param hHosting The handle to the hosting main window.
 *
 * \return The handle to the first hosted main window. If an invalid window
 *         handle is passed for \a hHosting, HWND_INVALID will be returned. 
 *         If tihs main window do not have a hosted window, HWND_NULL 
 *         will be returned.
 *
 * \sa GetHosting, GetNextHosted
 */
MG_EXPORT HWND GUIAPI GetFirstHosted (HWND hHosting);

/**
 * \fn HWND GUIAPI GetNextHosted (HWND hHosting, HWND hHosted)
 * \brief Retrives the next hosted main window of a main window.
 *
 * This function retrives the next hosted main window of the specified
 * main window \a hHosting.
 *
 * For MiniGUI-Threads, HWND_DESKTOP has no any "hosted" window, 
 * so do not use this function for it.
 *
 * \param hHosting The handle to the hosting main window.
 * \param hHosted The handle to a known hosted main window. This function
 *        will return the next hosted main window.
 *
 * \return Handle to the next hosted main window. 
 *         Returns 0 when \a hHosted is the last hosted main window; 
 *         HWND_INVALID when error occurs. If \a hHosted is 0, this call
 *         equals GetFirstHosted(hHosting).
 *         If an invalid window handle is passed as \a hHosting
 *         or \a hHosted, HWND_INVALID will be returned; If \a hHosted is 
 *         not the hosted window of \a hHosting, HWND_INVALID will be returned.
 *
 * \sa GetFirstHosted
 */
MG_EXPORT HWND GUIAPI GetNextHosted (HWND hHosting, HWND hHosted);

/**
 * \fn int GUIAPI GetWindowTextLength (HWND hWnd)
 * \brief Retrieves the length of a window's text.
 *
 * This function retrieves the length, in characters, of the specified 
 * window's text. The function retrieves the length of the text by sending 
 * an MSG_GETTEXTLENGTH message to the window.
 *
 * \param hWnd The handle to the window.
 *
 * \return The length of the window's text.
 *
 * \sa GetWindowText
 */
MG_EXPORT int GUIAPI GetWindowTextLength (HWND hWnd);

/**
 * \fn int GUIAPI GetWindowText (HWND hWnd, char* spString, int nMaxLen)
 * \brief Copies the text of a window's into a buffer.
 *
 * This function copies the text of the specified window \a hWnd into the buffer
 * pointed to by \a spString. The function gets the window text by sending
 * an MSG_GETTEXT message to the window.
 *
 * \param hWnd The handle to the window.
 * \param spString The pointer to a buffer receives the text.
 * \param nMaxLen The maximal number of characters can be copied to the buffer.
 *
 * \return The length of the window text string.
 *
 * \sa GetWindowCaption, SetWindowText
 */
MG_EXPORT int GUIAPI GetWindowText (HWND hWnd, char* spString, int nMaxLen);

/**
 * \fn BOOL GUIAPI SetWindowText (HWND hWnd, const char* spString)
 * \brief Sets the text of a window.
 *
 * This function copies the string in the buffer pointed to by \a spString
 * to be the text of the specified window \a hWnd. The function sets
 * the window text by sending an MSG_SETTEXT message to the window.
 *
 * \param hWnd The handle to the window.
 * \param spString The pointer to the buffer.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa SetWindowCaption, GetWindowText
 */
MG_EXPORT BOOL GUIAPI SetWindowText (HWND hWnd, const char* spString);

/**
 * \fn HWND GUIAPI GetFocusChild (HWND hParent)
 * \brief Retrieves the handle to the window's active child that has 
 *        the keyboard focus.
 *
 * This function retrives the handle to the window's active child that has
 * the keyboard focus.
 *
 * \param hParent The handle to the parent window.
 *
 * \return The handle to the active child.
 *
 * \sa SetFocusChild, SetNullFoucs
 */
MG_EXPORT HWND GUIAPI GetFocusChild (HWND hParent);

/**
 * \fn HWND GUIAPI SetNullFocus (HWND hParent)
 * \brief Cancels the current active child and set the focus child to be null.
 *
 * This function cancels the current active child and set the focus child
 * of the window \a hParent to be null.
 *
 * \param hParent The handle to the parent window.
 *
 * \return The handle to the old active child.
 *
 * \sa GetFocusChild, SetFocusChild
 */
MG_EXPORT HWND GUIAPI SetNullFocus (HWND hParent);

/**
 * \fn HWND GUIAPI SetFocusChild (HWND hWnd)
 * \brief Sets the active child of a window.
 *
 * This function sets the specified window \a hWnd as the active child of 
 * its parent.
 *
 * \param hWnd The handle to the window.
 *
 * \return The handle to the old active child of its parent.
 *
 * \sa GetFocusChild, SetNullFocus
 */
MG_EXPORT HWND GUIAPI SetFocusChild (HWND hWnd);

/**
 * \def SetFocus
 * \sa SetFocusChild
 */
#define SetFocus SetFocusChild

/**
 * \def GetFocus
 * \sa GetFocusChild
 */
#define GetFocus GetFocusChild

/**
 * \fn HWND GUIAPI GetActiveWindow (void)
 * \brief Retrieves the main window handle to the active main window.
 *
 * This function retrives the main window handle to the active main window 
 * which receives the input.
 *
 * \return The handle to the active main window.
 *
 * \sa SetActiveWindow, GetFocusChild
 */
MG_EXPORT HWND GUIAPI GetActiveWindow (void);

/**
 * \fn HWND GUIAPI SetActiveWindow (HWND hMainWnd)
 * \brief Sets a main window to be the active main window.
 *
 * This function sets the specified main window \a hMainWnd to be the 
 * active main window which receives the input.
 *
 * \param hMainWnd The handle to the new active main window.
 *
 * \return The handle to the old active main window.
 *
 * \sa GetActiveWindow, SetFocusChild
 */
MG_EXPORT HWND GUIAPI SetActiveWindow (HWND hMainWnd);

/**
 * \def GetForegroundWindow
 * \sa GetActiveWindow
 */
#define GetForegroundWindow GetActiveWindow

/**
 * \def SetForegroundWindow
 * \sa SetActiveWindow
 */
#define SetForegroundWindow SetActiveWindow

/**
 * \fn HWND GUIAPI GetCapture(void)
 * \brief Retrives the handle to the window (if any) that has captured 
 * the mouse.
 *
 * This function retrieves the handle to the window (if any) that has captured 
 * the mouse.  Only one window at a time can capture the mouse; this window 
 * receives mouse input whether or not the cursor is within its borders.
 *
 * \return The handle to the window that has captured the mouse, 0 for
 *         no window captures the mouse.
 *
 * \sa SetCapture
 */
MG_EXPORT HWND GUIAPI GetCapture(void);

/**
 * \fn HWND GUIAPI SetCapture(HWND hWnd)
 * \brief Sets the mouse capture to the specified window.
 *
 * This function sets the mouse capture to the specified window \a hWnd. 
 * Once a window has captured the mouse, all mouse input is directed to 
 * that window, regardless of whether the cursor is within the borders 
 * of that window. Only one window at a time can capture the mouse. 
 *
 * \param hWnd The handle to the window.
 *
 * \return The old capture window.
 *
 * \sa GetCapture
 */
MG_EXPORT HWND GUIAPI SetCapture(HWND hWnd);

/**
 * \fn void GUIAPI ReleaseCapture(void)
 * \brief Releases the mouse capture from a window and restores normal mouse 
 *        input processing.
 *
 * This function releases the mouse capture from a window and restores normal 
 * mouse input processing. A window that has captured the mouse receives 
 * all mouse input, regardless of the position of the cursor.
 *
 * \sa GetCapture, SetCapture
 */
MG_EXPORT void GUIAPI ReleaseCapture(void);

/**
 * \fn HWND GUIAPI GetWindowUnderCursor(void)
 * \brief Retrives the handle to the window (if any) which is just 
 *        beneath the mouse cursor.
 *
 * This function retrieves the handle to the window (if any) that is under 
 * the mouse cursor. If a parent window and a child window are all under 
 * the mouse cursor, the handle to the child window will be returned.
 *
 * \return The handle to the window under the mouse cursor, 
 *         HWND_NULL for no window is under the mouse cursor.
 */
MG_EXPORT HWND GUIAPI GetWindowUnderCursor (void);

/**
 * \fn HWND GUIAPI WindowFromPointEx (POINT pt, BOOL bRecursion)
 * \brief Retrieves a handle to the window that contains the specified point.
 *
 * This function retrieves a handle to the main window that contains the 
 * specified point \a pt.
 *
 * \param pt Specifies a POINT structure that defines the point to be checked. 
 * \param bRecursion Try find the child window of the mMainWindow
 *
 * \return The return value is a handle to the main window that contains 
 *         the point. If no main window exists at the given point, 
 *         the return value is HWND_NULL. 
 */
MG_EXPORT HWND GUIAPI WindowFromPointEx (POINT pt, BOOL bRecursion);

#define WindowFromPoint(pt)  WindowFromPointEx(pt, TRUE)

#define CWP_ALL             0x0000
#define CWP_SKIPINVISIBLE   0x0001
#define CWP_SKIPDISABLED    0x0002
#define CWP_SKIPTRANSPARENT 0x0004

/**
 * \fn HWND GUIAPI ChildWindowFromPointEx (HWND hParent, POINT pt, 
                    UINT uFlags)
 * \brief Retrives a handle to the child window that contains the
 *        speicified point and meets the certain criteria.
 *
 * This function determines which, if any, of the child windows 
 * belonging to a parent window contains the specified point. 
 * The function can ignore invisible, disabled, and transparent 
 * child windows. The search is restricted to immediate child windows. 
 * Grandchildren, and deeper descendant windows are not searched.
 *
 * \param hParent Handle to the parent window.
 * \param pt Specifies a POINT structure that defines the client 
 *        coordinates (relative to hParent) of the point to be checked. 
 * \param uFlags Specifies which child windows to skip. This parameter can be 
 *        one or more of the following values.
 *          - CWP_ALL\n
 *            Does not skip any child windows
 *          - CWP_SKIPINVISIBLE\n 
 *            Skips invisible child windows
 *          - CWP_SKIPDISABLED\n
 *            Skips disabled child windows
 *          - CWP_SKIPTRANSPARENT\n
 *            Skips transparent child windows
 *
 * \return The return value is a handle to the first child window 
 *         that contains the point and meets the criteria specified 
 *         by uFlags. If the point is within the parent window but 
 *         not within any child window that meets the criteria, 
 *         the return value is a handle to the parent window. 
 *         If the point lies outside the parent window or if the 
 *         function fails, the return value is HWND_NULL.
 *
 * \sa ChildWindowFromPoint
 */
MG_EXPORT HWND GUIAPI ChildWindowFromPointEx (HWND hParent, POINT pt,
                UINT uFlags);

/**
 * \fn HWND GUIAPI ChildWindowFromPoint (HWND hParent, POINT pt)
 * \brief Retrives a handle to the child window that contains the
 *        speicified point.
 *
 * This function determines which, if any, of the child windows 
 * belonging to a parent window contains the specified point by calling
 * ChildWindowFromPointEx and passing CWP_ALL to uFlags parameter.
 *
 * \sa ChildWindowFromPointEx
 */
static inline HWND GUIAPI ChildWindowFromPoint (HWND hParent, POINT pt)
{
    return ChildWindowFromPointEx (hParent, pt, CWP_ALL);
}

/**
 * \fn BOOL GUIAPI MoveWindow (HWND hWnd, int x, int y, int w, int h, \
 *               BOOL fPaint)
 * \brief Changes the position and dimensions of a window.
 *
 * This function changes the position and dimensions of the specified window 
 * \a hWnd.  For a main window, the position and dimensions are relative to 
 * the upper-left corner of the screen. For a control, they are relative to 
 * the upper-left corner of the parent window's client area.
 *
 * \param hWnd The handle to the window.
 * \param x The new x coordinate of the upper-left corner of the window.
 * \param y The new y coordinate of the upper-left corner of the window.
 * \param w The new width of the window.
 * \param h The new height of the window.
 * \param fPaint Indicates whether the window should be repainted.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa ScrollWindow
 */
MG_EXPORT BOOL GUIAPI MoveWindow (HWND hWnd, int x, int y, int w, int h, 
                BOOL fPaint);

#define SW_INVALIDATE       0x01
#define SW_ERASE            0x02
#define SW_SCROLLCHILDREN   0x04

/**
 * \fn int GUIAPI ScrollWindowEx (HWND hWnd, int dx, int dy,
                const RECT *prcScroll, const RECT *prcClip,
                PCLIPRGN pRgnUpdate, PRECT prcUpdate, UINT flags)
 * \brief Scrolls the content of a window's client area.
 *
 * This function scrolls the content of a window's client area.
 *
 * If the SW_INVALIDATE and SW_ERASE flags are not specified, 
 * ScrollWindowEx does not invalidate the area that is scrolled from. 
 * If either of these flags is set, ScrollWindowEx invalidates this area. 
 * The area is not updated until the application calls the UpdateWindow 
 * function or retrieves the MSG_PAINT message from the application queue.
 *
 * If the window has the WS_CLIPCHILDREN style, the returned areas 
 * specified by pRgnUpdate and prcUpdate represent the total area of 
 * the scrolled window that must be updated, including any areas in 
 * child windows that need updating.
 *
 * If the SW_SCROLLCHILDREN flag is specified, the system does not 
 * properly update the screen if part of a child window is scrolled. 
 * The part of the scrolled child window that lies outside the source 
 * rectangle is not erased and is not properly redrawn in its new 
 * destination. To move child windows that do not lie completely 
 * within the rectangle specified by prcScroll, use the DeferWindowPos 
 * function. The cursor is repositioned if the SW_SCROLLCHILDREN flag is set 
 * and the caret rectangle intersects the scroll rectangle.
 *
 * All input and output coordinates (for prcScroll, prcClip, prcUpdate, 
 * and pRgnUpdate) are determined as client coordinates.
 *
 * \param hWnd Handle to the window where the client area is to be scrolled.
 * \param dx Specifies the amount, in device units, of horizontal scrolling. 
 *        This parameter must be a negative value to scroll to the left. 
 * \param dy Specifies the amount, in device units, of vertical scrolling. 
 *        This parameter must be a negative value to scroll up. 
 * \param prcScroll Pointer to a RECT structure that specifies the 
 *        portion of the client area to be scrolled. If this parameter 
 *        is NULL, the entire client area is scrolled. 
 * \param prcClip Pointer to a RECT structure that contains the coordinates 
 *        of the clipping rectangle. Only device bits within the clipping 
 *        rectangle are affected. Bits scrolled from the outside of the 
 *        rectangle to the inside are painted; bits scrolled from the inside 
 *        of the rectangle to the outside are not painted. This parameter 
 *        may be NULL. 
 * \param pRgnUpdate Pointer to the region that is modified to hold the 
 *        region invalidated by scrolling. This parameter may be NULL. 
 * \param prcUpdate Pointer to a RECT structure that receives the 
 *        boundaries of the rectangle invalidated by scrolling. This 
 *        parameter may be NULL. 
 * \param flags Specifies flags that control scrolling. This parameter 
 *        can be one of the following values:
 *        - SW_ERASE\n
 *          Erases the newly invalidated region by sending a MSG_ERASEBKGND 
 *          message to the window when specified with the SW_INVALIDATE flag.
 *        - SW_INVALIDATE\n
 *          Invalidates the region identified by the pRgnUpdate parameter 
 *          after scrolling.
 *        - SW_SCROLLCHILDREN\n
 *          Scrolls all child windows that intersect the rectangle pointed 
 *          to by the prcScroll parameter. The child windows are scrolled 
 *          by the number of pixels specified by the dx and dy parameters. 
 *          MiniGUI calls MoveWindow to all child windows that 
 *          intersect the prcScroll rectangle, even if they do not move.
 *
 * \return If the function succeeds, the return value is SIMPLEREGION 
 *         (rectangular invalidated region), COMPLEXREGION (nonrectangular 
 *         invalidated region; overlapping rectangles), or NULLREGION 
 *         (no invalidated region).
 *         If the function fails, the return value is -1. 
 */
MG_EXPORT int GUIAPI ScrollWindowEx (HWND hWnd, int dx, int dy,
                const RECT *prcScroll, const RECT *prcClip,
                PCLIPRGN pRgnUpdate, PRECT prcUpdate, UINT flags);

/**
 * \fn void GUIAPI ScrollWindow (HWND hWnd, int dx, int dy, \
                const RECT* prcScroll, const RECT* prcClip)
 * \brief Scrolls the content of a window's client area.
 *
 * This function scrolls the content of the specified window's client area.
 *
 * \param hWnd The handle to the window.
 * \param dx The new x coordinate of the origin in the client coordinates 
 *        system after scrolling.
 * \param dy The new y coordinate of the origin in the client coordinates 
 *        system after scrolling.
 * \param prcScroll The rectangle of the area which will be scrolled actually. 
 *        NULL for whole client area.
 * \param prcClip A rectangle, all children covered totally by this rectangle 
 *        will be moved after scrolling. All of the children will be 
 *        moved if \a prcClip is NULL.
 *
 * \sa MoveWindow
 */
static inline void GUIAPI ScrollWindow (HWND hWnd, int dx, int dy, 
               const RECT* prcScroll, const RECT* prcClip)
{
    ScrollWindowEx (hWnd, dx, dy, prcScroll, prcClip,
                NULL, NULL, SW_ERASE | SW_INVALIDATE | SW_SCROLLCHILDREN);
}

/**
 * \def GetWindowElementColor
 * \brief Get window element color.
 */
#define GetWindowElementColor(iItem)   \
        GetWindowElementPixelEx(HWND_NULL, (HDC)-1, iItem)

#define GetWindowElementColorEx(hWnd, iItem)   \
        GetWindowElementPixelEx(hWnd, (HDC)-1, iItem)

#define GetWindowElementPixel(hWnd, iItem)   \
        GetWindowElementPixelEx(hWnd, (HDC)-1, iItem)

    /** @} end of window_general_fns */

    /**
     * \defgroup sys_bmps System bitmap/icon operations
     * @{
     */
#define SYSBMP_RADIOBUTTON          "radiobutton" 
#define SYSBMP_CHECKBUTTON          "checkbutton" 
#define SYSBMP_BGPICTURE            "bgpicture"
#define SYSBMP_BGPICPOS             "bgpicpos"

/* Obsolete definitions; back-compatibility definitions. */
#define SYSBMP_IMECTRLBTN          "IMEctrlbtn"
#define SYSBMP_LOGO                "logo"

/**
 * \fn MG_EXPORT const BITMAP* GUIAPI GetSystemBitmapEx (const char* rdr_name, const char* id)
 * \brief Retrives the system bitmap object by identifier.
 *
 * This function returns the system bitmap object by its identifier.
 *
 * \param rdr_name The renderer name.
 * \param id The identifier of the system bitmap object, can be
 *           one of the following values:
 *
 *      - SYSBMP_RADIOBUTTON\n 
 *      - SYSBMP_CHECKBUTTON\n
 *      - SYSBMP_BGPICTURE\n
 *
 * \return The pointer to the system bitmap object.
 *
 * \sa GetLargeSystemIcon, GetSmallSystemIcon
 */
MG_EXPORT const BITMAP* GUIAPI GetSystemBitmapEx (const char* rdr_name, 
        const char* id);

/**
 * \fn PBITMAP GUIAPI GetSystemBitmapByHwnd (HWND hWnd, const char* id)
 * \brief Retrives the system bitmap object by identifier.
 *
 * This function returns the system bitmap object by its identifier.
 *
 * \param hWnd The handle to the window.
 * \param id The identifier of the system bitmap object, can be
 * one of the following values:
 *
 *      - SYSBMP_RADIOBUTTON\n 
 *      - SYSBMP_CHECKBUTTON\n
 *      - SYSBMP_BGPICTURE\n
 *
 * \return The pointer to the system bitmap object.
 *
 * \sa GetLargeSystemIcon, GetSmallSystemIcon
 */
MG_EXPORT const BITMAP* GUIAPI GetSystemBitmapByHwnd (HWND hWnd, const char* id);

/**
 * \fn PBITMAP GUIAPI GetSystemBitmap (HWND hWnd, const char* id)
 * \brief Retrives the system bitmap object by identifier.
 *
 * This function returns the system bitmap object by its identifier.
 *
 * \param hWnd The handle to the window.
 * \param id The identifier of the system bitmap object, can be
 * one of the following values:
 *
 *      - SYSBMP_RADIOBUTTON\n 
 *      - SYSBMP_CHECKBUTTON\n
 *      - SYSBMP_BGPICTURE\n
 *
 * \return The pointer to the system bitmap object.
 *
 * \sa GetLargeSystemIcon, GetSmallSystemIcon
 */
MG_EXPORT const BITMAP* GUIAPI GetSystemBitmap (HWND hWnd, const char* id);

/**
 * \fn void GUIAPI TermSystemBitmapEx (const char* id, \
                     const char* rdr_name, PBITMAP bmp)
 * \brief Release the system bitmap object by identifier.
 *
 * \param id The identifier of the system bitmap object, can be
 * one of the following values:
 *
 *      - SYSBMP_RADIOBUTTON\n 
 *      - SYSBMP_CHECKBUTTON\n
 *      - SYSBMP_BGPICTURE\n
 *
 * \param rdr_name The renderer name.
 * \param bmp The pointer to the system bitmap object.
 *
 * \return none.
 *
 * \sa GetSystemBitmap
 */
MG_EXPORT void GUIAPI TermSystemBitmapEx (const char* id, 
        const char* rdr_name, PBITMAP bmp);

/**
 * \fn void GUIAPI TermSystemBitmap (HWND hWnd, const char* id, PBITMAP bmp)
 * \brief Release the system bitmap object by identifier.
 *
 * \param hWnd The handle to the window.
 * \param id The identifier of the system bitmap object, can be
 * one of the following values:
 *
 *      - SYSBMP_RADIOBUTTON\n 
 *      - SYSBMP_CHECKBUTTON\n
 *      - SYSBMP_BGPICTURE\n
 *
 * \param bmp The pointer to the system bitmap object.
 *
 * \return none.
 *
 * \sa GetSystemBitmap
 */
MG_EXPORT void GUIAPI TermSystemBitmap (HWND hWnd, const char* id, PBITMAP bmp);

/*for backward compatibility */
#define IDI_APPLICATION         0
#define IDI_HAND                1
#define IDI_STOP                IDI_HAND
#define IDI_QUESTION            2
#define IDI_EXCLAMATION         3
#define IDI_ASTERISK            4
#define IDI_INFORMATION         IDI_ASTERISK

#define SYSICON_FT_DIR          "dir"
#define SYSICON_FT_FILE         "file"

#define SYSICON_TREEFOLD        "treefold" 
#define SYSICON_TREEUNFOLD      "treeunfold" 

/**
 * \fn HICON GUIAPI LoadSystemIconEx (HDC hdc, \
         const char* rdr_name, const char* szItemName, int which)
 * \brief Loads an icon from information defined in MiniGUI.cfg.
 *
 * This function loads an icon from information defined in MiniGUI.cfg.
 *
 * \param hdc The device context.
 * \param rdr_name The renderer name.
 * \param szItemName The key name in the section of renderer name in MiniGUI.cfg.
 * \param which Tell the function to load which icon. 0 for the small icon, 
 *        and 1 for large icon. 
 *
 * \return The handle to the loaded icon.
 *
 * \sa LoadSystemBitmap, LoadIconFromFile, DestroyIcon
 */
MG_EXPORT HICON GUIAPI LoadSystemIconEx (HDC hdc, 
        const char* rdr_name, const char* szItemName, int which);

/**
 * \fn HICON GUIAPI LoadSystemIcon (const char* szItemName, int which)
 * \brief Uses default renderer and HDC_SCREEN to load an icon from 
 * information defined in MiniGUI.cfg.
 *
 * This function loads an icon from information defined in MiniGUI.cfg.
 *
 * \param szItemName The key name in the section of renderer name in MiniGUI.cfg.
 * \param which Tell the function to load which icon.
 *
 * \return The handle to the loaded icon.
 *
 * \sa LoadSystemBitmap, LoadIconFromFile, DestroyIcon
 */
MG_EXPORT HICON GUIAPI LoadSystemIcon (const char* szItemName, int which);

/**
 * \fn HICON GUIAPI GetLargeSystemIconEx (HWND hWnd, int iItem)
 * \brief Retrives a large system icon by its identifier in default renderer.
 *
 * This function retrives the handle to a large (32x32) system icon 
 * by its identifier \a id.
 *
 * \param hWnd The handle to the window.
 * \param iItem The identifier of the icon. It can be one of the 
 *        following values:
 *      - IDI_APPLICATION\n The application icon.
 *      - IDI_STOP\n        The stop icon.
 *      - IDI_QUESTION\n    The question mark icon.
 *      - IDI_EXCLAMATION\n The exclamation mark icon.
 *      - IDI_INFORMATION\n The information mark icon.
 *
 * \return The handle to the icon.
 *
 * \sa GetSystemBitmap
 */
MG_EXPORT HICON GUIAPI GetLargeSystemIconEx (HWND hWnd, int iItem);

/**
 * \fn HICON GUIAPI GetSmallSystemIconEx (HWND hWnd, int iItem)
 * \brief Retrives a small system icon by its identifier.
 *
 * This function retrives the handle to a small (16x16) system icon by 
 * its identifier \a id.
 *
 * \param hWnd The handle to the window.
 * \param iItem The identifier of the icon. It can be one of the 
 *        following values:
 *      - IDI_APPLICATION\n The application icon.
 *      - IDI_STOP\n        The stop icon.
 *      - IDI_QUESTION\n    The question mark icon.
 *      - IDI_EXCLAMATION\n The exclamation mark icon.
 *      - IDI_INFORMATION\n The information mark icon.
 *
 * \return The handle to the icon.
 *
 * \sa GetSystemBitmap
 */
MG_EXPORT HICON GUIAPI GetSmallSystemIconEx (HWND hWnd, int iItem);

/**
 * \def GetLargeSystemIcon
 * \brief Retrives a large (32x32) system icon by its identifier 
 *        in default renderer.
 * \sa GetSmallSystemIconEx
 */
#define GetLargeSystemIcon(iItem) GetLargeSystemIconEx(HWND_NULL, iItem)

/**
 * \def GetSmallSystemIcon
 * \brief Retrives a small (16x16) system icon by its identifier 
 *        in default renderer.
 * \sa GetSmallSystemIconEx
 */
#define GetSmallSystemIcon(iItem) GetSmallSystemIconEx(HWND_NULL, iItem)

    /** @} end of sys_bmps */

    /**
     * \defgroup scrollbar_fns Scroll bar operations
     * @{
     */

#define SB_HORZ     1
#define SB_VERT     2

/**
 * \fn BOOL GUIAPI EnableScrollBar (HWND hWnd, int iSBar, BOOL bEnable)
 * \brief Enables or disables one scroll bar arrows.
 *
 * This function enables or disables one scroll bar arrows.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param bEnable Indicates whether to enable or disable the scroll bar.
 * \return TRUE on success, FALSE on error.
 *
 * \sa ShowScrollBar
 */
MG_EXPORT BOOL GUIAPI EnableScrollBar (HWND hWnd, int iSBar, BOOL bEnable);

/**
 * \fn BOOL GUIAPI GetScrollPos (HWND hWnd, int iSBar, int* pPos)
 * \brief Retrieves the current position of the scroll box (thumb) in the 
 *        specified scroll bar.
 *
 * This function retrieves the current position of the scroll box (thumb) in 
 * the specified scroll bar. The current position is a relative value that 
 * depends on the current scrolling range.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param pPos The pointer to a integer which receives the position value.
 * \return TRUE on success, FALSE on error.
 *
 * \sa SetScrollPos
 */
MG_EXPORT BOOL GUIAPI GetScrollPos (HWND hWnd, int iSBar, int* pPos);

/**
 * \fn BOOL GUIAPI GetScrollRange (HWND hWnd, int iSBar, int* pMinPos, int* pMaxPos)
 * \brief Retrives the minimum and maximum position values for the specified 
 * scroll bar.
 *
 * This function retrives the minimum and maximum position values for 
 * the specified scroll bar.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param pMinPos The pointer to a integer which receives the minimum 
 *        position value.
 * \param pMaxPos The pointer to a integer which receives the maximum 
 *        position value.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa SetScrollRange
 */
MG_EXPORT BOOL GUIAPI GetScrollRange (HWND hWnd, int iSBar, 
                int* pMinPos, int* pMaxPos);

/**
 * \fn BOOL GUIAPI SetScrollPos (HWND hWnd, int iSBar, int iNewPos)
 * \brief Sets the position of the scroll box (thumb) of the specified 
 * scroll bar.
 *
 * This function sets the position of the scroll box (thumb) of the specified 
 * scroll bar, and if needed, redraws the scroll bar to reflect the new 
 * position of the scroll box.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param iNewPos The new position value.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa GetScrollPos
 */
MG_EXPORT BOOL GUIAPI SetScrollPos (HWND hWnd, int iSBar, int iNewPos);

/**
 * \fn BOOL GUIAPI SetScrollRange (HWND hWnd, int iSBar, \
 *               int iMinPos, int iMaxPos)
 * \brief Sets the minimum and maximum position values for the specified 
 * scroll bar.
 *
 * This function sets the minimum and maximum position values for the 
 * specified scroll bar, and if needed, redraws the scroll bar to reflect 
 * the new position values of the scroll box.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param iMinPos The new minimum position value.
 * \param iMaxPos The new maximum position value.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa GetScrollRange
 */
MG_EXPORT BOOL GUIAPI SetScrollRange (HWND hWnd, int iSBar, 
                int iMinPos, int iMaxPos);

/**
 * \fn BOOL GUIAPI ShowScrollBar (HWND hWnd, int iSBar, BOOL bShow)
 * \brief Shows or hides the specified scroll bar.
 *
 * This function shows or hides the specified scroll bar.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param bShow Indicates whether show or hide the scrollbar.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa EnableScrollBar
 */
MG_EXPORT BOOL GUIAPI ShowScrollBar (HWND hWnd, int iSBar, BOOL bShow);

#define SIF_RANGE           0x0001
#define SIF_PAGE            0x0002
#define SIF_POS             0x0004
#define SIF_DISABLENOSCROLL 0x0008
#define SIF_TRACKPOS        0x0010
#define SIF_ALL             (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)

/** left or up arrow */
#define SB_ARROW_LTUP   0x0001

/** right or bottom arrow */
#define SB_ARROW_BTDN   0x0002

/** left,up, right or bottom arrow */
#define SB_ARROW_BOTH  (SB_ARROW_LTUP | SB_ARROW_BTDN)

/**
 * Scroll bar information structure.
 */
typedef struct _SCROLLINFO
{
    /** Size of the structrue in bytes */
    UINT    cbSize;
    /**
     * A flag indicates which fields contain valid values, 
     * can be OR'ed value of the following values:
     *      - SIF_RANGE\n
     *        Retrives or sets the range of the scroll bar.
     *      - SIF_PAGE\n
     *        Retrives or sets the page size of the scroll bar.
     *      - SIF_POS\n
     *        Retrives or sets the position of the scroll bar.
     *      - SIF_DISABLENOSCROLL\n
     *        Hides the scroll when disabled, not implemented so far.
     */
    UINT    fMask;
    /** The minimum position value of the scroll bar */
    int     nMin;
    /** The maximum position value of the scroll bar */
    int     nMax;
    /** The page size of the scroll bar */
    UINT    nPage;
    /** The position value of the scroll bar */
    int     nPos;
#if 0
    int     nTrackPos;
#endif
} SCROLLINFO, *PSCROLLINFO;

/**
 * \fn BOOL GUIAPI SetScrollInfo (HWND hWnd, int iSBar, \
 *                const SCROLLINFO* lpsi, BOOL fRedraw)
 * \brief Sets the parameters of a scroll bar.
 *
 * This function sets the parameters of a scroll bar, including the 
 * minimum and maximum scrolling positions, the page size, and the position 
 * of the scroll box (thumb). The function also redraws the scroll bar, 
 * if requested.
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param lpsi The pointer to the structure of scroll bar information.
 * \param fRedraw A boolean indicates whether to redraw the scroll bar.
 * \return TRUE on success, FALSE on error.
 *
 * \sa GetScrollInfo, SCROLLINFO
 */
MG_EXPORT BOOL GUIAPI SetScrollInfo (HWND hWnd, int iSBar, 
                const SCROLLINFO* lpsi, BOOL fRedraw);

/**
 * \fn BOOL GUIAPI GetScrollInfo (HWND hWnd, int iSBar, PSCROLLINFO lpsi)
 * \brief Retrieves the parameters of a scroll bar.
 *
 * This function retrieves the parameters of a scroll bar, including the 
 * minimum and maximum scrolling positions, the page size, and the position 
 * of the scroll box (thumb).
 *
 * \param hWnd The handle to the window.
 * \param iSBar Indicates to enable or disable which scroll bar, can be one of 
 *        the following values:
 *      - SB_HORZ\n
 *        The horizontal scroll bar.
 *      - SB_VERT\n
 *        The vertical scroll bar.
 * \param lpsi The pointer to a structure of SCROLLINFO which receives the 
 *        parameters.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa SetScrollInfo, SCROLLINFO
 */
MG_EXPORT BOOL GUIAPI GetScrollInfo (HWND hWnd, int iSBar, PSCROLLINFO lpsi);

    /** @} end of scrollbar_fns */

    /**
     * \defgroup class_fns Window class operations
     * @{
     */

/* Class styles -- not supported so far */
#define CS_VREDRAW          0x0001
#define CS_HREDRAW          0x0002
#define CS_KEYCVTWINDOW     0x0004
#define CS_DBLCLKS          0x0008

#define CS_OWNDC            0x0020
#define CS_CLASSDC          0x0040
#define CS_PARENTDC         0x0080

#define CS_NOKEYCVT         0x0100
#define CS_NOCLOSE          0x0200
#define CS_SAVEBITS         0x0800

#define CS_BYTEALIGNCLIENT  0x1000
#define CS_BYTEALIGNWINDOW  0x2000
#define CS_GLOBALCLASS      0x4000
#define CS_IME              0x8000

#define COP_STYLE           0x0001
#define COP_HCURSOR         0x0002
#define COP_BKCOLOR         0x0004
#define COP_WINPROC         0x0008
#define COP_ADDDATA         0x0010

/**
 * Structure defines a window class
 */
typedef struct _WNDCLASS
{
    /** The class name */
    const char* spClassName;

    /** The mask of class information, can be OR'd with the following values:
      * - COP_STYLE\n
      *   Retrive the style of the window class.
      * - COP_HCURSOR\n
      *   Retrive the cursor of the window class.
      * - COP_BKCOLOR\n
      *   Retrive the background pixel value of the window class.
      * - COP_WINPROC
      *   Retrive the window procedure of the window class.
      * - COP_ADDDATA\n
      *   Retrive the additional data of the window class.
      */
    DWORD   opMask;

    /** Window style for all instances of this window class */
    DWORD   dwStyle;

    /** Extended window style for all instances of this window class */
    DWORD   dwExStyle;

    /** Cursor handle to all instances of this window class */
    HCURSOR hCursor;

    /** Background color pixel value of all instances of this window class */
    gal_pixel iBkColor;

    /** Window callback procedure of all instances of this window class */
    LRESULT (*WinProc) (HWND, UINT, WPARAM, LPARAM);

    /** The private additional data associated with this window class */
    DWORD dwAddData;
} WNDCLASS;
typedef WNDCLASS* PWNDCLASS;

#define MAINWINCLASSNAME    ("MAINWINDOW")
#define ROOTWINCLASSNAME    ("ROOTWINDOW")

/**
 * \fn BOOL GUIAPI RegisterWindowClass (PWNDCLASS pWndClass)
 * \brief Registers a window class. 
 *
 * This function registers a window class. 
 * Later on, you can create a window of the registered class.
 *
 * \param pWndClass The pointer to a WNDCLASS structure which specifies 
 *        the information of the window class.
 *
 * \return TRUE on success, FALSE on error.
 * 
 * \sa UnregisterWindowClass, WNDCLASS
 *
 * Example:
 *
 * \include registerwindowclass.c
 */
MG_EXPORT BOOL GUIAPI RegisterWindowClass (PWNDCLASS pWndClass);

/**
 * \fn BOOL GUIAPI UnregisterWindowClass (const char* szClassName)
 * \brief Undoes the effect of \a RegisterWindowClass.
 *
 * This function unregisters a registered window class specified by 
 * \a szClassName.
 * 
 * \param szClassName The name of the class to be unregistered.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa RegisterWindowClass
 */
MG_EXPORT BOOL GUIAPI UnregisterWindowClass (const char* szClassName);

/**
 * \fn const char* GUIAPI GetClassName (HWND hWnd)
 * \brief Retrieves the name of the class to which the specified window belongs.
 *
 * This function retrieves the name of the class to which 
 * the specified window \a hWnd belongs.
 *
 * \param hWnd The handle to the window.
 *
 * \return The pointer to a const class name string, NULL on error.
 *
 * \sa RegisterWindowClass
 */
MG_EXPORT const char* GUIAPI GetClassName (HWND hWnd);

/**
 * \fn BOOL GUIAPI GetWindowClassInfo (PWNDCLASS pWndClass)
 * \brief Retrieves the information of the specified window class.
 *
 * This function retrives the information of a window class.
 * The window class to be retrived is specified by \a pWndClass->spClassName.
 *
 * \param pWndClass The pointer to a WNDCLASS structure, which specifies the
 *        window class to be retrived via \a spClassName field, and
 *        returns the information through other fields.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa SetWindowClassInfo
 */
MG_EXPORT BOOL GUIAPI GetWindowClassInfo (PWNDCLASS pWndClass);

/**
 * \fn BOOL GUIAPI SetWindowClassInfo (const WNDCLASS* pWndClass)
 * \brief Sets the information of the specified window class.
 *
 * This function sets the information of a window class.
 * The window class to be operated is specified by \a pWndClass->spClassName.
 *
 * \param pWndClass The pointer to a WNDCLASS structure, which specifies
 *        the new information of the window class.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa GetWindowClassInfo
 */
MG_EXPORT BOOL GUIAPI SetWindowClassInfo (const WNDCLASS* pWndClass);

    /** @} end of class_fns */

    /**
     * \defgroup control_fns Control creating/destroying
     * @{
     */

/**
 * \fn HWND GUIAPI CreateWindowEx2 (const char* spClassName, \
 *               const char* spCaption, DWORD dwStyle, DWORD dwExStyle, \
 *               LINT id, int x, int y, int w, int h, HWND hParentWnd, \
 *               const char* werdr_name, const WINDOW_ELEMENT_ATTR* we_attrs, \
 *               DWORD dwAddData)
 * \brief Creates a child window with extended style, renderer and 
 * attributes table.
 *
 * This function creates a child window (also known as "control") with 
 * extended style, renderer and attributes table. It specifies the window  
 * class, the window title, the window style, the window extended style,
 *  the initial position, and the size of the window, etc.  The function also 
 * specifies the window's parent or owner.
 *
 * \param spClassName The class name of the control.
 * \param spCaption The caption of the control.
 * \param dwStyle The control style.
 * \param dwExStyle The extended control style.
 * \param id The identifier of the control.
 * \param x x,y: The initial position of the control in the parent window.
 * \param y x,y: The initial position of the control in the parent window.
 * \param w The initial width of the control.
 * \param h The initial height of the control.
 * \param hParentWnd The handle to the parent window.
 * \param werdr_name The window renderer name. NULL for default renderer.
 * \param we_attrs The pointer to window element attribute table. 
 *                 NULL for default attribute table.
 * \param dwAddData The first private additional data of the control.
 *        Note that some control classes use this value to initialize 
 *        some properties of the new control instance. For these control 
 *        classes, you should pass a valid value to it.
 *
 * \return The handle to the new control, HWND_INVALID on error.
 *
 * \sa CreateWindowEx, CreateMainWindow, CTRLDATA
 */
MG_EXPORT HWND GUIAPI CreateWindowEx2 (const char* spClassName, 
        const char* spCaption, DWORD dwStyle, DWORD dwExStyle, 
        LINT id, int x, int y, int w, int h, HWND hParentWnd, 
        const char* werdr_name, const WINDOW_ELEMENT_ATTR* we_attrs, 
        DWORD dwAddData);

/**
 * \fn HWND GUIAPI CreateWindowEx (const char* spClassName, 
                 const char* spCaption, DWORD dwStyle, DWORD dwExStyle,
                 LINT id, int x, int y, int w, int h, HWND hParentWnd,
                 DWORD dwAddData)
 * \brief A shortcut version of CreateWindowEx2.
 *
 * This function creates a child window by calling CreateWindowEx2 function
 * and passing NULL for both werdr_name and we_attrs parameters.
 *
 * \sa CreateWindowEx2
 */
static inline HWND GUIAPI CreateWindowEx (const char* spClassName, 
                const char* spCaption, DWORD dwStyle, DWORD dwExStyle, 
                LINT id, int x, int y, int w, int h, HWND hParentWnd, 
                DWORD dwAddData)
{
    return CreateWindowEx2 (spClassName, spCaption, dwStyle, dwExStyle, 
                id, x, y, w, h, hParentWnd, NULL, NULL, dwAddData);
}

/**
 * \fn BOOL GUIAPI DestroyWindow (HWND hWnd)
 * \brief Destroys a specified control.
 *
 * This function destroys the specified control \a hWnd, which is created
 * by \a CreateWindowEx or CreateWindowEx2.
 *
 * \param hWnd The handle to the control.
 * \return TRUE on success, FALSE on error.
 *
 * \sa CreateWindowEx
 */
MG_EXPORT BOOL GUIAPI DestroyWindow (HWND hWnd);

/**
 * \var typedef void (* NOTIFPROC)(HWND hwnd, LINT id, int nc, DWORD add_data)
 * \brief Type of the notification callback procedure.
 *
 * This is the function type of Notification Callback Procedure.
 * If you set the Notification Callback Procedure for a control,
 * when a notification occurred the control will call this callback
 * procedure.
 *
 * \note The type of \a id changed from int to LINT since v3.2.
 *
 * \sa SetNotificationCallback
 */
typedef void (* NOTIFPROC) (HWND hwnd, LINT id, int nc, DWORD add_data);

/**
 * \fn NOTIFPROC GUIAPI SetNotificationCallback (HWND hwnd, \
 *                NOTIFPROC notif_proc)
 * \brief Sets a new notification callback procedure for a control.
 *
 * This function sets the new notification callback procedure (\a notif_proc) 
 * for the control of \a hwnd.
 *
 * By default, the notification from a control will be sent to its parent
 * window within a MSG_COMMAND messsage.
 *
 * Since version 1.2.6, MiniGUI defines the Notification Callback Procedure 
 * for control. You can specify a callback function for a control by calling
 * \a SetNotificationCallback to receive and handle the notifications from 
 * the control.
 *
 * If you did not set the notification callback function for a control,
 * the notification will be sent to its parent as same as the earlier 
 * version of MiniGUI.
 *
 * \param hwnd The handle to the control.
 * \param notif_proc The new notification callback procedure, can be NULL.
 * \return The old notification callback procedure.
 *
 * \sa NOTIFPROC, GetNotificationCallback
 */
MG_EXPORT NOTIFPROC GUIAPI SetNotificationCallback (HWND hwnd, 
                NOTIFPROC notif_proc);

/**
 * \fn NOTIFPROC GUIAPI GetNotificationCallback (HWND hwnd)
 * \brief Gets the notification callback procedure of a control.
 *
 * This function gets the new notification callback procedure of 
 * the control of \a hwnd.
 *
 * \param hwnd The handle to the control.
 *
 * \return The notification callback procedure.
 *
 * \sa NOTIFPROC, SetNotificationCallback
 */
MG_EXPORT NOTIFPROC GUIAPI GetNotificationCallback (HWND hwnd);

/**
 * \def CreateWindow(class_name, caption, style, id, x, y, w, h, parent, add_data)
 * \brief A simplified version of \a CreateWindowEx.
 *
 * \sa CreateWindowEx
 */
#define CreateWindow(class_name, caption, style,        \
                id, x, y, w, h, parent, add_data)       \
        CreateWindowEx(class_name, caption, style, 0,   \
                        id, x, y, w, h, parent, add_data)

    /** @} end of control_fns */

/******************************** Timer Support ******************************/
    /**
     * \defgroup timer_fns Timer operations
     * @{
     */

/**
 * \var typedef BOOL (* TIMERPROC)(HWND, LINT, DWORD)
 * \brief Type of the timer callback procedure.
 *
 * This is the prototype of the callback procedure of a timer created by SetTimerEx.
 * MiniGUI will call the timer procedure instead of sending MSG_TIMER message.
 *
 * If the return value of a timer procedure is FALSE, the timer will be killed
 * by MiniGUI automatically. This can be used to implement a one-shot timer.
 *
 * \sa SetTimerEx
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one:
 *      BOOL (* TIMERPROC)(HWND, int, unsigned int)
 */
typedef BOOL (* TIMERPROC)(HWND, LINT, DWORD);

/**
 * \fn BOOL GUIAPI SetTimerEx (HWND hWnd, LINT id, DWORD speed, \
 *              TIMERPROC timer_proc)
 * \brief Creates a timer with the specified timeout value.
 *
 * This function creates a timer with the specified timeout value \a speed.
 * Note that the timeout value is in unit of 10 ms.
 * When the timer expires, an MSG_TIMER message will be send to the 
 * window \a hWnd if \a timer_proc is NULL, otherwise MiniGUI will call
 * \a timer_proc by passing \a hWnd, \a id, and the tick count when this
 * timer had expired to this callback procedure.
 *
 * \param hWnd The window receives the MSG_TIMER message. If \a timer_proc
 *        is not NULL, MiniGUI will call \a timer_proc instead sending
 *        MSG_TIMER message to this window. If you use timer callback 
 *        procedure, \a hWnd can be any value you can pass.
 * \param id The identifier of the timer, will be passed to the window
 *        with MSG_TIMER message as the first parameter of the message.
 * \param speed The timeout value of the timer. Note that the timeout value 
 *        is in unit of 10 ms.
 * \param timer_proc The timer callback procedure. If this argument is NULL,
 *        MiniGUI will send MSG_TIMER to the window procedure of \a hWnd.
 * \return TRUE on success, FALSE on error.
 * 
 * \sa SetTimer, ResetTimerEx, KillTimer, MSG_TIMER
 *
 * \note You should set, reset, and kill a timer in the same thread if your
 *       MiniGUI is configured as MiniGUI-Threads.
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one:
 *      BOOL GUIAPI SetTimerEx (HWND hWnd, int id, unsigned int speed, TIMERPROC timer_proc);
 *
 * Example:
 *
 * \include settimer.c
 */
MG_EXPORT BOOL GUIAPI SetTimerEx (HWND hWnd, LINT id, DWORD speed, 
                TIMERPROC timer_proc);

/**
 * \def SetTimer(hwnd, id, speed)
 * \brief The backward compatibility version of SetTimerEx.
 *
 * \sa SetTimerEx
 */
#define SetTimer(hwnd, id, speed) \
                SetTimerEx(hwnd, id, speed, NULL)

/**
 * \fn int GUIAPI KillTimer (HWND hWnd, LINT id)
 * \brief Destroys a timer.
 *
 * This function destroys the specified timer \a id.
 *
 * \param hWnd The window owns the timer.
 * \param id The identifier of the timer. If \a id equals 0, 
 *        this function will kill all timers in the system.
 *
 * \return The number of actually killed timer.
 *
 * \sa SetTimer
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one:
 *      int GUIAPI KillTimer (HWND hWnd, int id)
 */
MG_EXPORT int GUIAPI KillTimer (HWND hWnd, LINT id);

/**
 * \fn BOOL GUIAPI ResetTimerEx (HWND hWnd, LINT id, DWORD speed, \
 *              TIMERPROC timer_proc)
 * \brief Adjusts a timer with a different timeout value or different
 *        timer callback procedure.
 *
 * This function resets a timer with the specified timeout \a speed value.
 *
 * \param hWnd The window owns the timer.
 * \param id The identifier of the timer.
 * \param speed The new timeout value.
 * \param timer_proc The new timer callback procedure. If \a timer_proc
 *        is INV_PTR, the setting of timer callback procedure will
 *        not change.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa SetTimerEx
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one:
 *      BOOL GUIAPI ResetTimerEx (HWND hWnd, int id, unsigned int speed, TIMERPROC timer_proc)
 */
MG_EXPORT BOOL GUIAPI ResetTimerEx (HWND hWnd, LINT id, DWORD speed,
                TIMERPROC timer_proc);

/**
 * \def ResetTimer(hwnd, id, speed)
 * \brief The backward compatibility version of ResetTimerEx.
 *
 * \sa ResetTimerEx
 */
#define ResetTimer(hwnd, id, speed) \
                ResetTimerEx(hwnd, id, speed, (TIMERPROC)INV_PTR)

/**
 * \fn DWORD GUIAPI GetTickCount (void)
 * \brief Retrieves the tick counts that have elapsed since MiniGUI was started.
 *
 * This function retrieves the tick counts that have elapsed since MiniGUI 
 * was started. It is limited to the resolution of the system timer, i.e. 
 * for a general Linux box, the returned tick count value is in unit of 10ms.
 *
 * \return The tick counts value that have elapsed since MiniGUI was started.
 *
 * \note The prototype had changed since MiniGUI v3.2; The old one:
 *      unsinged int GUIAPI GetTickCount (void);
 */
MG_EXPORT DWORD GUIAPI GetTickCount (void);

/**
 * \fn BOOL GUIAPI IsTimerInstalled (HWND hWnd, LINT id)
 * \brief Determines whether a timer is installed.
 *
 * This function determines whether a timer with identifier \a id of 
 * a window \a hwnd has been installed.
 *
 * \param hWnd The window owns the timer.
 * \param id The identifier of the timer.
 *
 * \return TRUE for installed, otherwise FALSE. 
 *
 * \sa SetTimer, HaveFreeTimer
 *
 * \note The prototype had changed since MiniGUI v3.2; the old one:
 *      BOOL GUIAPI IsTimerInstalled (HWND hWnd, int id)
 */
MG_EXPORT BOOL GUIAPI IsTimerInstalled (HWND hWnd, LINT id);

/**
 * \fn BOOL GUIAPI HaveFreeTimer (void)
 * \brief Determines whether there is any free timer slot in the system.
 *
 * This function determines whether there is any free timer slot in the
 * system.
 *
 * \return TRUE for yes, otherwise FALSE. 
 *
 * \sa IsTimerInstalled
 */
MG_EXPORT BOOL GUIAPI HaveFreeTimer (void);

    /** @} end of timer_fns */

    /**
     * \defgroup ime_fns IME Window functions
     * @{
     */

/**
 *  \ struct defines a ime target info
 * */
typedef struct _IME_TARGET_INFO
{
   /** The type of the edit box:
     * - IME_WINDOW_TYPE_READONLY\n
     *   The edit box is readonly.
     *
     * - IME_WINDOW_TYPE_PASSWORD\n
     *   The edit box is readonly.
     *
     * - IME_WINDOW_TYPE_NOT_EDITABLE\n
     *   The edit box is not editable.
     *
     */
    int     iEditBoxType;
    
    /* The position of the caret */
    POINT   ptCaret;
    
    /* The rect of the edit box */
    RECT    rcEditBox;
} IME_TARGET_INFO;

/**
 * \fn int GUIAPI RegisterIMEWindow (HWND hWnd)
 * \brief Registers an IME window.
 *
 * This function registers the specified window \a hWnd as the IME window of 
 * the MiniGUI. After that, the keyboard input will be sent to IME window 
 * first. Note that only one IME window can be registered.
 *
 * \param hWnd The handle to your IME window.
 *
 * \return ERR_OK on success, otherwise less than zero.
 *
 * \retval ERR_OK Success.
 * \retval ERR_IME_TOOMUCHIMEWND Already have an IME window registered.
 * \retval ERR_INV_HWND Invalid main window handle.
 *
 * \sa UnregisterIMEWindow
 */
MG_EXPORT int GUIAPI RegisterIMEWindow (HWND hWnd);

/**
 * \fn int GUIAPI UnregisterIMEWindow (HWND hWnd)
 * \brief Unregisters an IME window.
 *
 * This function undoes the effect of \a RegisterIMEWindow.
 *
 * \param hWnd The handle to the current IME window.
 * \return ERR_OK on success, otherwise less than zero.
 *
 * \retval ERR_OK Success.
 * \retval ERR_IME_NOSUCHIMEWND The window is not the current IME window.
 *
 * \sa RegisterIMEWindow
 */
MG_EXPORT int GUIAPI UnregisterIMEWindow (HWND hWnd);

MG_EXPORT int GUIAPI RegisterMainWindow (HWND hWnd);

MG_EXPORT int GUIAPI UnregisterMainWindow (HWND hWnd);

MG_EXPORT void GUIAPI EnableKeyMessage(void);

MG_EXPORT void GUIAPI DisableKeyMessage(void);

/**
 * \fn int GUIAPI GetIMEStatus (int StatusCode)
 * \brief Retrives status of the current IME window.
 *
 * This function retrives status of the current IME window.
 *
 * \param StatusCode The item to be retrived, can be one of the following
 * values:
 *      - IME_STATUS_REGISTERED\n
 *        Is there any registered IME window?
 *      - IME_STATUS_ENABLED\n
 *        Is the IME window enabled?
 *      - IME_STATUS_AUTOTRACK\n
 *        Does the IME window autotrack the input focus?
 *      - IME_STATUS_LANGUAGE\n
 *        Retrieve the selected input method. The return value can be
 *        one of the following values:
 *          - IME_LANGUAGE_UNKNOWN\n
 *            Unknown
 *          - IME_LANGUAGE_LATIN\n
 *            Latin
 *          - IME_LANGUAGE_ZHCN\n
 *            Chinese simplified
 *          - IME_LANGUAGE_ZHTW\n
 *            Chinese traditional
 *      - IME_STATUS_ENCODING\n
 *        Retrieve the output encoding. The return value can be one of
 *        the following values:
 *          - IME_ENCODING_LOCAL\n
 *            The local encoding
 *          - IME_ENCODING_UTF8\n
 *            UTF-8
 *      - IME_STATUS_VERSION\n
 *        Retrieve the version of the IME
 *      - IME_STATUS_USER_MIN, IME_STATUS_USER_MAX
 *        Reserved for user. The return value and its meaning is determined
 *        by the specific IME implementation.
 *
 * \return The status of the item specified by \a StatusCode, 
 *        ERR_IME_NOIMEWND if error occurred.
 *
 * \sa SetIMEStatus
 */
MG_EXPORT int GUIAPI GetIMEStatus (int StatusCode);

/**
 * \fn int GUIAPI SetIMEStatus (int StatusCode, int Value)
 * \brief Sets the status of the current IME window.
 *
 * This function sets the status of the current IME window.
 *
 * \param StatusCode The item to be set. Please see GetIMEStatus for more
 * information.
 * \param Value The status value of the item.
 *
 * \retval ERR_OK Success.
 * \retval ERR_IME_NOIMEWND There is no any IME window registered.
 *
 * \sa GetIMEStatus
 */
MG_EXPORT int GUIAPI SetIMEStatus (int StatusCode, int Value);

/**
 * \fn int GUIAPI GetIMETargetInfo (IME_TARGET_INFO* info)
 * \brief Retrives the target info of the current IME window.
 *
 * This function retrives the target info of the current IME window.
 *
 * \param info The item to be retrived. The target info is 
 *        return by the current IME Window.
 *
 * \return ERR_OK on success, otherwise less than zero.
 *
 * \sa GetIMETargetInfo
 */
MG_EXPORT int GUIAPI GetIMETargetInfo (IME_TARGET_INFO *info);

/**
 * \fn int GUIAPI SetIMETargetInfo (const IME_TARGET_INFO *info)
 * \brief Sets the target info of the current IME window.
 *
 * This function sets the target info of the current IME window.
 *
 * \param info The set target info.
 *
 * \return ERR_OK on success, otherwise less than zero.
 *
 * \retval ERR_OK Success.
 * \retval ERR_IME_NOIMEWND There is no any IME window registered.
 *
 * \sa SetIMETargetInfo
 */
MG_EXPORT int GUIAPI SetIMETargetInfo (const IME_TARGET_INFO *info);

/**
 * \fn int GUIAPI GetIMEPos (POINT* pt)
 * \brief Retrives the position of the current IME window.
 *
 * NOTE that this function is deprecated.
 * 
 * This function retrives the position of the current IME window.
 *
 * \param pt The item to be retrived. The positon is 
 *        return by the current IME Window.
 *
 * \return The current IME window positon.
 *        ERR_IME_NOIMEWND if error occurred.
 *
 * \sa GetIMEPos
 */
MG_EXPORT int GUIAPI GetIMEPos (POINT* pt);

/**
 * \fn int GUIAPI SetIMEPos (POINT* pt)
 * \brief Sets the position of the current IME window.
 *
 * NOTE that this function is deprecated.
 * 
 * This function sets the position of the current IME window.
 *
 * \param pt The set position value.
 *
 * \return ERR_OK on success, otherwise less than zero.
 *
 * \retval ERR_OK Success.
 * \retval ERR_IME_NOIMEWND There is no any IME window registered.
 *
 * \sa SetIMEPos
 */
MG_EXPORT int GUIAPI SetIMEPos (const POINT* pt);

    /** @} end of ime_fns */

    /**
     * \defgroup accel_fns Accelerator operations
     * @{
     */

/**
 * \fn HACCEL GUIAPI CopyAcceleratorTable (HACCEL hacc)
 * \brief Copies the specified accelerator table.
 *
 * This function copies the specified accelerator table. 
 * The function is used to obtain the accelerator table data that 
 * corresponds to an accelerator table handle.
 *
 * \param hacc The handle to the accelerator table.
 * \return The handle to the copied new accelerator table.
 */
MG_EXPORT HACCEL GUIAPI CopyAcceleratorTable (HACCEL hacc);

/**
 * \fn int GUIAPI DeleteAccelerators (HACCEL hacc, int key, DWORD keymask)
 * \brief Deletes an accelerator from the accelerator table.
 *
 * This function deletes an accelerator from the accelerator table.
 *
 * \param hacc The handle to the accelerator table.
 * \param key The key value of the accelerator.
 * \param keymask The shift key state.
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \sa AddAccelerators, DestroyAcceleratorTable
 */
MG_EXPORT int GUIAPI DeleteAccelerators (HACCEL hacc, int key, DWORD keymask);

#define ACCEL_SHIFT     KS_SHIFT
#define ACCEL_ALT       KS_ALT
#define ACCEL_CTRL      KS_CTRL

/**
 * \fn int GUIAPI AddAccelerators (HACCEL hacc, int key, \
 *               DWORD keymask, WPARAM wParam, LPARAM lParam)
 * \brief Adds an accelerator to the accelerator table.
 *
 * This function adds an accelerator to the accelerator table. 
 * It's called after you call \a CreateAcceleratorTable function.
 *
 * \param hacc The handle to the accelerator table.
 * \param key The key value of the accelerator. Note that you can define the 
 *        key value by either scancode or ASCII code. If you define the key 
 *        with scancode, the key value should be equal to (scancode + 256).
 * \param keymask The shift key state, can be OR'ed value of the following 
 *        values:
 *      - KS_SHIFT\n
 *        Shift key should be pressed.
 *      - KS_ALT\n
 *        Alt key should be pressed.
 *      - KS_CTRL\n
 *        Ctrl key should be pressed.
 * \param wParam The first parameter of the MSG_COMMAND when receiving such 
 *        a accelerator key.
 * \param lParam The second parameter of the MSG_COMMAND when receiving such 
 *        a accelerator key.
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \sa CreateAcceleratorTable, DeleteAccelerators
 */
MG_EXPORT int GUIAPI AddAccelerators (HACCEL hacc, int key, 
                DWORD keymask, WPARAM wParam, LPARAM lParam);

/**
 * \fn int GUIAPI DestroyAcceleratorTable (HACCEL hacc)
 * \brief Destroys an accelerator table.
 *
 * This function destroys the specified accelerator table \a hacc. 
 * Before closing a window, you must call this function to destroy 
 * each accelerator table that is created by using \a CreateAcceleratorTable 
 * function.
 *
 * \param hacc The handle to the accelerator table.
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \sa CreateAcceleratorTable
 */
MG_EXPORT int GUIAPI DestroyAcceleratorTable (HACCEL hacc);

/**
 * \fn HACCEL GUIAPI CreateAcceleratorTable (HWND hWnd)
 * \brief Creates an empty accelerator table.
 *
 * This function creates an empty accelerator table.
 *
 * \param hWnd The handle to the main window.
 * \return The handle to the new accelerator table, zero when error.
 *
 * \sa AddAccelerators, DestroyAcceleratorTable
 */
MG_EXPORT HACCEL GUIAPI CreateAcceleratorTable (HWND hWnd);

/**
 * \fn int GUIAPI TranslateAccelerator (HACCEL hAccel, PMSG pMsg)
 * \brief Translates an accelerator key message to MSG_COMMAND messge 
 * and sends it to the window procedure.
 *
 * \param hAccel The handle to the accelerator table.
 * \param pMsg The pointer to the MSG structure to be translated.
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \sa TranslateMessage
 */
MG_EXPORT int GUIAPI TranslateAccelerator (HACCEL hAccel, PMSG pMsg);

    /** @} end of accel_fns */

    /**
     * \defgroup caret_fns Caret operations
     * @{
     */

/**
 * \fn BOOL GUIAPI CreateCaret (HWND hWnd, PBITMAP pBitmap, \
 *               int nWidth, int nHeight)
 * \brief Creates a new shape for the system caret and assigns ownership of 
 * the caret to the specified window. 
 *
 * This function creates a new shape for the system caret and assigns 
 * ownership of the caret to the specified window \a hWnd. The caret shape 
 * can be a line, a block, or a bitmap.
 *
 * \param hWnd The owner of the caret.
 * \param pBitmap The bitmap shape of the caret. It can be NULL.
 * \param nWidth The width of the caret.
 * \param nHeight The height of the caret.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa ActiveCaret, ChangeCaretSize
 */
MG_EXPORT BOOL GUIAPI CreateCaret (HWND hWnd, PBITMAP pBitmap, 
                int nWidth, int nHeight);

/**
 * \fn BOOL GUIAPI ChangeCaretSize (HWND hWnd, int newWidth, int newHeight)
 * \brief Changes the size of the caret.
 *
 * This function change the size of the caret owned by the specified window
 * \a hWnd. Note that the new size of the caret should be smaller than
 * the original size which is specified when you call \a CreateCaret.
 *
 * \param hWnd The owner of the caret.
 * \param newWidth The new width of the caret.
 * \param newHeight The new height of the caret.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa CreateCaret
 */
MG_EXPORT BOOL GUIAPI ChangeCaretSize (HWND hWnd, int newWidth, int newHeight);

/**
 * \fn BOOL GUIAPI ActiveCaret (HWND hWnd)
 * \brief Activates the caret owned by a window.
 *
 * This function activates the caret owned by the specified window \a hWnd.
 * After activating the caret, the caret will begin flashing automatically.
 *
 * \param hWnd The owner of the caret.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa HideCaret, ShowCaret
 */
MG_EXPORT BOOL GUIAPI ActiveCaret (HWND hWnd);

/**
 * \fn UINT GUIAPI GetCaretBlinkTime (HWND hWnd)
 * \brief Returns the elapsed time, in milliseconds, required to invert the 
 *        caret's pixels.
 *
 * This function returns the elapsed time, in milliseconds, required to 
 * invert the caret's pixels. The default blink time of a caret is 500 
 * milliseconds.
 *
 * \param hWnd The owner of the caret.
 *
 * \return The elapsed time in milliseconds. Returns zero on error.
 *
 * \sa SetCaretBlinkTime
 */
MG_EXPORT UINT GUIAPI GetCaretBlinkTime (HWND hWnd);

/**
 * \fn BOOL GUIAPI SetCaretBlinkTime (HWND hWnd, UINT uTime)
 * \brief Sets the caret blink time to the specified number of milliseconds.
 *
 * This function sets the caret blink time to the specified number of 
 * milliseconds. The blink time is the elapsed time, in milliseconds, 
 * required to invert the caret's pixels. The default blink time of a caret 
 * is 500 milliseconds.
 *
 * \param hWnd The owner of the caret.
 * \param uTime New blink time in milliseconds.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa GetCaretBlinkTime
 */
MG_EXPORT BOOL GUIAPI SetCaretBlinkTime (HWND hWnd, UINT uTime);

/**
 * \fn BOOL GUIAPI DestroyCaret (HWND hWnd)
 * \brief Destroys a caret.
 *
 * This function destroys the caret's current shape, 
 * frees the caret from the window, and removes the caret from the screen.
 *
 * \param hWnd The owner of the caret.
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa CreateCaret
 */
MG_EXPORT BOOL GUIAPI DestroyCaret (HWND hWnd);

/**
 * \fn BOOL GUIAPI HideCaretEx (HWND hWnd, BOOl ime)
 * \brief Hides a caret.
 *
 * This function removes the caret from the screen. 
 * Hiding a caret does not destroy its current shape or invalidate the 
 * insertion point.
 *
 * \param hWnd The owner of the caret.
 *
 * \param ime TRUE if you want to close the IME window (if there is any)
 * at the same time.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa ShowCaretEx
 */
MG_EXPORT BOOL GUIAPI HideCaretEx (HWND hWnd, BOOL ime);

/**
 * \fn BOOL GUIAPI HideCaret (HWND hWnd)
 * \brief Hides a caret.
 *
 * This function removes the caret from the screen and close the IME window. 
 * Hiding a caret does not destroy its current shape or invalidate the 
 * insertion point.
 *
 * \param hWnd The owner of the caret.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa ShowCaret
 */
static inline BOOL GUIAPI HideCaret (HWND hWnd)
{
    return HideCaretEx (hWnd, TRUE);
}

/**
 * \fn BOOL GUIAPI ShowCaretEx (HWND hWnd, BOOL ime)
 * \brief Shows a caret.
 *
 * This function makes the caret visible on the screen at the caret's 
 * current position. When the caret becomes visible, it begins flashing 
 * automatically.
 *
 * \param hWnd The owner of the caret.
 *
 * \param ime TRUE if you want to let the hidden IME window (if there is any)
 * show up at the same time.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa HideCaretEx
 */
MG_EXPORT BOOL GUIAPI ShowCaretEx (HWND hWnd, BOOL ime);

/**
 * \fn BOOL GUIAPI ShowCaret (HWND hWnd)
 * \brief Shows a caret.
 *
 * This function makes the caret visible on the screen at the caret's 
 * current position. When the caret becomes visible, it begins flashing 
 * automatically.
 *
 * \param hWnd The owner of the caret.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa HideCaret
 */
static inline BOOL GUIAPI ShowCaret (HWND hWnd)
{
    return ShowCaretEx (hWnd, TRUE);
}

/**
 * \fn BOOL GUIAPI SetCaretPos (HWND hWnd, int x, int y)
 * \brief Moves the caret to a new position.
 *
 * This function moves the caret to the specified coordinates \a (x,y).
 *
 * \param hWnd The owner of the caret.
 * \param x x,y: The position of the caret in client coordiantes of 
 *        the owner window.
 * \param y x,y: The position of the caret in client coordiantes of
 *        the owner window.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa GetCaretPos
 */
MG_EXPORT BOOL GUIAPI SetCaretPos (HWND hWnd, int x, int y);

/**
 * \fn BOOL GUIAPI GetCaretPos (HWND hWnd, PPOINT pPt)
 * \brief Gets the caret position.
 *
 * This function copies the caret's position, in client coordinates, 
 * to the specified POINT structure \a pPt.
 *
 * \param hWnd The owner of the caret.
 * \param pPt The pointer to the buffer saves the caret's position.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa SetCaretPos
 */
MG_EXPORT BOOL GUIAPI GetCaretPos (HWND hWnd, PPOINT pPt);

    /** @} end of caret_fns */

    /**
     * \defgroup menu_fns Menu operations
     * @{
     */

/* Menu flags */
#define MF_INSERT           0x00000000L
#define MF_CHANGE           0x00000080L
#define MF_APPEND           0x00000100L
#define MF_DELETE           0x00000200L
#define MF_REMOVE           0x00001000L

#define MF_BYCOMMAND        0x00000000L
#define MF_BYPOSITION       0x00000400L

#define MF_SEPARATOR        0x00000800L

#define MF_ENABLED          0x00000000L
#define MF_GRAYED           0x00000001L
#define MF_DISABLED         0x00000002L

#define MF_UNCHECKED        0x00000000L
#define MF_CHECKED          0x00000008L
#define MF_USECHECKBITMAPS  0x00000200L

#define MF_STRING           0x00000000L
#define MF_BITMAP           0x00000004L
#define MF_OWNERDRAW        0x00000100L

#define MF_POPUP            0x00000010L
#define MF_MENUBARBREAK     0x00000020L
#define MF_MENUBREAK        0x00000040L

#define MF_UNHILITE         0x00000000L
#define MF_HILITE           0x00000080L

#define MF_DEFAULT          0x00001000L
#define MF_SYSMENU          0x00002000L
#define MF_HELP             0x00004000L
#define MF_RIGHTJUSTIFY     0x00004000L

#define MF_MOUSESELECT      0x00008000L
#define MF_END              0x00000080L

#define MFT_STRING          MF_STRING /* 0x00000000L */
#define MFT_BITMAP          MF_BITMAP /* 0x00000004L */
#define MFT_BMPSTRING       0x00010000L
#define MFT_MENUBARBREAK    MF_MENUBARBREAK /* 0x00000020L */
#define MFT_MENUBREAK       MF_MENUBREAK /* 0x00000040L */
#define MFT_OWNERDRAW       MF_OWNERDRAW /* 0x00000100L */
#define MFT_RADIOCHECK      0x00000200L
#define MFT_MARKCHECK       0x00000400L
#define MFT_SEPARATOR       MF_SEPARATOR /* 0x00000800L */

#define MFT_RIGHTORDER      0x00002000L
#define MFT_RIGHTJUSTIFY    MF_RIGHTJUSTIFY

#define MFS_GRAYED          0x00000003L
#define MFS_DISABLED        MFS_GRAYED
#define MFS_CHECKED         MF_CHECKED
#define MFS_HILITE          MF_HILITE
#define MFS_ENABLED         MF_ENABLED
#define MFS_UNCHECKED       MF_UNCHECKED
#define MFS_UNHILITE        MF_UNHILITE
#define MFS_DEFAULT         MF_DEFAULT

/* System Menu Command Values */
  #define SC_SIZE         0xF000
  #define SC_MOVE         0xF010
  #define SC_MINIMIZE     0xF020
  #define SC_MAXIMIZE     0xF030
  #define SC_NEXTWINDOW   0xF040
  #define SC_PREVWINDOW   0xF050
  #define SC_CLOSE        0xF060
  #define SC_VSCROLL      0xF070
  #define SC_HSCROLL      0xF080
  #define SC_MOUSEMENU    0xF090
  #define SC_KEYMENU      0xF100
  #define SC_ARRANGE      0xF110
  #define SC_RESTORE      0xF120
  #define SC_TASKLIST     0xF130
  #define SC_SCREENSAVE   0xF140
  #define SC_HOTKEY       0xF150

  #define SC_DEFAULT      0xF160
  #define SC_MONITORPOWER 0xF170
  #define SC_CONTEXTHELP  0xF180
  #define SC_SEPARATOR    0xF00F

/* MENUITEMINFO flags */
  #define MIIM_STATE       0x00000001
  #define MIIM_ID          0x00000002
  #define MIIM_SUBMENU     0x00000004
  #define MIIM_CHECKMARKS  0x00000008
  #define MIIM_TYPE        0x00000010
  #define MIIM_DATA        0x00000020
  #define MIIM_STRING      0x00000040
  #define MIIM_BITMAP      0x00000080
  #define MIIM_FTYPE       0x00000100


/* Flags for TrackPopupMenu */
  #define TPM_LEFTBUTTON  0x0000L
  #define TPM_RIGHTBUTTON 0x0002L
  #define TPM_LEFTALIGN   0x0000L
  #define TPM_CENTERALIGN 0x0004L
  #define TPM_RIGHTALIGN  0x0008L
  #define TPM_TOPALIGN        0x0000L
  #define TPM_VCENTERALIGN    0x0010L
  #define TPM_BOTTOMALIGN     0x0020L

  #define TPM_HORIZONTAL      0x0000L     /* Horz alignment matters more */
  #define TPM_VERTICAL        0x0040L     /* Vert alignment matters more */
  #define TPM_NONOTIFY        0x0080L     /* Don't send any notification msgs */
  #define TPM_RETURNCMD       0x0100L

  #define TPM_DESTROY         0x1000L       /* Destroy menu after tracking */
  #define TPM_SYSCMD          0x2000L       /* Send system command */
  #define TPM_DEFAULT         0x0000L       /* Default tracking flag */

/* return codes for MSG_MENUCHAR */
#define MNC_IGNORE  0
#define MNC_CLOSE   1
#define MNC_EXECUTE 2
#define MNC_SELECT  3

/**
 * Structure defines a menu item
 */
typedef struct _MENUITEMINFO {

    /**
     * Used by \a GetMenuItemInfo and \a SetMenuItemInfo functions, 
     * can be OR'ed with the following values:
     *      - MIIM_STATE\n
     *        Get/set the state of the menu item.
     *      - MIIM_ID\n
     *        Get/set the identifier of the menu item.
     *      - MIIM_SUBMENU\n
     *        Get/set the sub-menu of the menu item.
     *      - MIIM_CHECKMARKS\n
     *        Get/set the check/uncheck bitmap.
     *      - MIIM_TYPE\n
     *        Get/set the type and the type data of the menu item.
     *      - MIIM_DATA\n
     *        Get/set the item data of the menu item.
     */
    UINT                mask;

    /**
     * Type of menu item, can be one of the following values:
     *      - MFT_STRING\n
     *        A normal string menu item.
     *
     *      - MFT_BITMAP\n
     *        A bitmap menu item. When the menu item is this type, 
     *        the member \a typedata will be the pointer to the normal BITMAP object,
     *        the member \a uncheckedbmp will be the pointer to the hilighted BITMAP object,
     *        the member \a checkedbmp will be the pointer to the checked BITMAP object.
     *
     *      - MFT_BMPSTRING\n
     *        A bitmap menu item followed by a string. When the menu item is this type,
     *        the member \a typedata will be the pointer to the text string,
     *        the member \a uncheckedbmp will be the pointer to the normal BITMAP object,
     *        and the member \a checkedbmp will be the pointer to the checked BITMAP object.
     *
     *      - MFT_SEPARATOR\n
     *        A separator in menu.
     *
     *      - MFT_RADIOCHECK\n
     *        A normal string with a radio check mark.
     *
     *      - MFT_MARKCHECK\n
     *        A normal string with a check box mark.
     */
    UINT                type;

    /**
     * State of the menu item, can be one of the following values:
     *      - MFS_GRAYED\n
     *        The menu item is disabled.
     *      - MFS_DISABLED\n
     *        The menu item is disabled.
     *      - MFS_CHECKED\n
     *        The menu item is checked.
     *      - MFS_ENABLED\n
     *        The menu item is enabled.
     *      - MFS_UNCHECKED\n
     *        The menu item is unchecked.
     */
    UINT                state;

    /** The identifier of the menu item.
      * \note The type changed from int to LINT since v3.2.
      */
    LINT                 id;

    /** The handle to the sub-menu if this menu contains a sub menu */
    HMENU               hsubmenu;

    /** The pointer to a BITMAP object used for unchecked/highlited bitmap menu item */
    PBITMAP             uncheckedbmp;

    /** The pointer to a BITMAP object used for checked bitmap menu item */
    PBITMAP             checkedbmp;

    /** The private data attached to the menu item */
    DWORD               itemdata; 

    /** The data of this menu item, used to pass the string or the pointer to the BITMAP object of the menu item */
    DWORD               typedata;

    /** 
     * Used by \a GetMenuItemInfo function to indicate the maximal length 
     * of the string
     */
    UINT                cch;
} MENUITEMINFO;
typedef MENUITEMINFO* PMENUITEMINFO;

/**
 * \fn HMENU GUIAPI CreateMenu (void)
 * \brief Creates an empty menu.
 *
 * This function creates a menu. The menu is initially empty, but it can be 
 * filled with menu items by using the \a InsertMenuItem functions.
 *
 * \return The handle to the menu, zero when error.
 *
 * \sa InsertMenuItem
 */
MG_EXPORT HMENU GUIAPI CreateMenu (void);

/**
 * \fn HMENU GUIAPI CreatePopupMenu ( PMENUITEMINFO pmii)
 * \brief Creates a drop-down menu or submenu.
 *
 * This function creates a drop-down menu or submenu. The menu is initially 
 * empty. You can insert or append menu items by using the \a InsertMenuItem 
 * function.
 *
 * \param pmii Menu item information used to create the popup menu.
 *
 * \return The handle to the popup menu.
 *
 * \sa InsertMenuItem, MENUITEMINFO
 */
MG_EXPORT HMENU GUIAPI CreatePopupMenu ( PMENUITEMINFO pmii);

/**
 * \fn HMENU GUIAPI CreateSystemMenu (HWND hwnd, DWORD dwStyle)
 * \brief Creates a system menu.
 *
 * This function creates a system menu for the main window specified by 
 * \a hwnd.
 *
 * \param hwnd The handle to the main window.
 * \param dwStyle The style of the main window.
 *
 * \return The handle to the system menu.
 *
 * \sa CreateMenu, CreatePopupMenu
 */
MG_EXPORT HMENU GUIAPI CreateSystemMenu (HWND hwnd, DWORD dwStyle);

/**
 * \fn int GUIAPI InsertMenuItem (HMENU hmnu, LINT item, \
 *                UINT flag, PMENUITEMINFO pmii)
 * \brief Inserts a new menu item at the specified position in a menu.
 *
 * This function inserts a new menu item specified by \a pmmi at the
 * specified position (determined by \a item and \a flag) in the menu \a hmnu.
 *
 * \param hmnu The handle to the menu.
 * \param item The insertion position.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *        The new menu item will insert bellow the item whose id is \a item.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 * \param pmii Menu item information used to create the popup menu.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \retval ERR_INVALID_HANDLE \a hmnu is not a handle to menu.
 * \retval ERR_RES_ALLOCATION Can not allocate new menu item.
 * \retval ERR_INVALID_HMENU \a hmnu is an invalid menu.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa RemoveMenu, MENUITEMINFO
 */
MG_EXPORT int GUIAPI InsertMenuItem (HMENU hmnu, LINT item, 
                            UINT flag, PMENUITEMINFO pmii);

/**
 * \fn int GUIAPI RemoveMenu (HMENU hmnu, LINT item, UINT flag)
 * \brief Deletes a menu item or detaches a submenu from the specified menu.
 *
 * This function deletes a menu item or detaches a submenu from the specified 
 * menu \a hmnu. If the item is a normal menu item, the function will delete 
 * the item. If the item is a submenu, the function will detache the submenu 
 * for the menu, but not delete the submenu.
 *
 * \param hmnu The handle to the menu.
 * \param item The position of the menu item or submenu.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \retval ERR_INVALID_HANDLE \a hmnu is not a handle to menu.
 * \retval ERR_INVALID_HMENU \a hmnu is an invalid menu.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa InsertMenuItem, DeleteMenu
 */
MG_EXPORT int GUIAPI RemoveMenu (HMENU hmnu, LINT item, UINT flag);

/**
 * \fn int GUIAPI DeleteMenu (HMENU hmnu, LINT item, UINT flag)
 * \brief Deletes an item from the specified menu.
 *
 * This function deletes an item from the specified menu \a hmnu.
 * Either the item is a normal menu item or a submenu, this function
 * will delete the item.
 *
 * \param hmnu The handle to the menu.
 * \param item The position of the menu item or submenu.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \retval ERR_INVALID_HANDLE \a hmnu is not a handle to menu.
 * \retval ERR_INVALID_HMENU \a hmnu is an invalid menu.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa InsertMenuItem, RemoveMenu
 */
MG_EXPORT int GUIAPI DeleteMenu (HMENU hmnu, LINT item, UINT flag);

/**
 * \fn int GUIAPI DestroyMenu (HMENU hmnu)
 * \brief Destroys the specified menu and frees any memory that the menu 
 * occupies.
 *
 * This function destroys the specified menu \a hmnu and frees any memory 
 * that the menu occupies.
 *
 * \param hmnu The handle to the menu.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \retval ERR_INVALID_HANDLE \a hmnu is not a handle to menu.
 *
 * \sa RemoveMenu, DeleteMenu
 */
MG_EXPORT int GUIAPI DestroyMenu (HMENU hmnu);

/**
 * \fn int GUIAPI IsMenu (HMENU hmnu)
 * \brief Determines whether a handle is a menu handle.
 *
 * This function determines whether the handle specified by \a hmnu is a 
 * menu handle.
 *
 * \param hmnu The handle to a menu.
 *
 * \return The function returns 0 for none menu handle, 
 *         otherwise the type of the menu.
 *
 * \sa CreateMenu
 */
MG_EXPORT int GUIAPI IsMenu (HMENU hmnu);

/**
 * \fn HMENU GUIAPI SetMenu (HWND hwnd, HMENU hmnu)
 * \brief Assigns a new menu to the specified main window.
 *
 * This functionn assigns the specified menu \a hmnu to 
 * the main window specified by \a hwnd.
 *
 * \param hwnd The handle to the main window.
 * \param hmnu The handle to the new menu.
 *
 * \return The handle to the old menu of the window.
 * 
 * \sa GetMenu
 */
MG_EXPORT HMENU GUIAPI SetMenu (HWND hwnd, HMENU hmnu);

/**
 * \fn HMENU GUIAPI GetMenu (HWND hwnd)
 * \brief Retrieves the handle to the menu assigned to the given main window.
 *
 * This function retrives the handle to the menu assigned to 
 * the given main window \a hwnd.
 *
 * \param hwnd The handle to the main window.
 * \return The handle to the menu of the window.
 *
 * \sa SetMenu
 */
MG_EXPORT HMENU GUIAPI GetMenu (HWND hwnd);

/**
 * \fn void GUIAPI DrawMenuBar (HWND hwnd)
 * \brief Redraws the menu bar of the specified main window.
 *
 * This function redraws the menu bar of the specified main window. 
 * If the menu bar changes after the system has created the window, 
 * this function must be called to draw the changed menu bar.
 *
 * \param hwnd The handle to the main window.
 *
 * \sa TrackMenuBar
 */
MG_EXPORT void GUIAPI DrawMenuBar (HWND hwnd);

/**
 * \fn int GUIAPI TrackMenuBar (HWND hwnd, int pos)
 * \brief Displays the specified submenu.
 *
 * This function displays the specified submenu in the menu bar of 
 * the specified main window \a hwnd.
 *
 * \param hwnd The handle to the main window.
 * \param pos The position of the submenu. The position value of the 
 *      first submenu is 0.
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \sa TrackPopupMenu, CreateMenu
 */
MG_EXPORT int GUIAPI TrackMenuBar (HWND hwnd, int pos);

/**
 * \fn int GUIAPI TrackPopupMenu (HMENU hmnu, UINT uFlags, \
 *               int x, int y, HWND hwnd)
 * \brief Displays and tracks a popup menu.
 *
 * This function displays a shortcut menu at the specified location 
 * and tracks the selection of items on the menu. The shortcut menu 
 * can appear anywhere on the screen.
 *
 * \param hmnu The handle to the popup menu.
 * \param uFlags The tracking flags, can be OR'ed value of the following values:
 *      - TPM_LEFTALIGN\n
 *        Horz alignement is left.
 *      - TPM_CENTERALIGN\n
 *        Horz alignement is center.
 *      - TPM_RIGHTALIGN\n
 *        Horz alignement is right.
 *      - TPM_TOPALIGN\n
 *        Vert alignement is top.
 *      - TPM_VCENTERALIGN\n
 *        Vert alignement is center.
 *      - TPM_BOTTOMALIGN\n
 *        Vert alignement is bottom.
 *      - TPM_DESTROY\n
 *        Destroys the popup menu after finishing tracking.
 *      - TPM_SYSCMD\n
 *        Sends an MSG_SYSCOMMAND message to the window when the use select a 
 *        menu item.
 * \param x The x coordinate of the position of the popup menu.
 * \param y The y coordinate of the position of the popup menu.
 * \param hwnd The handle to the window which will receive 
 *        the MSG_COMMAND or MSG_SYSCOMMAND message.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \sa TrackMenuBar, CreatePopupMenu
 */
MG_EXPORT int GUIAPI TrackPopupMenu (HMENU hmnu, UINT uFlags, 
                int x, int y, HWND hwnd);

/**
 * \fn HMENU GUIAPI GetMenuBarItemRect (HWND hwnd, int pos, RECT* prc)
 * \brief Retrieves the rect of a menu bar item.
 *
 * This function retrieves the rect of the menu bar item specified 
 * by the parameter \a pos.
 *
 * \param hwnd The handle to the main window.
 * \param pos The position of the item. The position value of the 
 *        first item is 0.
 * \param prc The pointer to a RECT object, which will receive the rectangle.
 *
 * \return The function returns the handle to the menu bar if success,
 *      otherwise returns 0.
 *
 * \sa TrackMenuBar
 */
MG_EXPORT HMENU GUIAPI GetMenuBarItemRect (HWND hwnd, int pos, RECT* prc);

#define LFRDR_MENU_STATE_HILITE       0x01
#define LFRDR_MENU_STATE_NORMAL       0x02
#define LFRDR_MENU_STATE_DISABLED     0x04

/**
 * \fn BOOL GUIAPI HiliteMenuBarItem (HWND hwnd, int pos, UINT flag)
 * \brief Draws the specified menubar item with 3D effect.
 *
 * This function draws the specified menubar item with 3D effect.
 *
 * \param hwnd The handle to the main window.
 * \param pos The position of the item. The position value of the 
 *        first item is 0.
 * \param flag The drawing flag, can be one of the following values:
 *      - LFRDR_MENU_STATE_HILITE\n
 *        hilite item.
 *      - LFRDR_MENU_STATE_NORMAL\n
 *        normal item.
 *      - LFRDR_MENU_STATE_DISABLED\n
 *        disabled item.
 *
 * \return TRUE on success, otherwise FALSE.
 *
 * \sa TrackMenuBar
 */
MG_EXPORT BOOL GUIAPI HiliteMenuBarItem (HWND hwnd, int pos, UINT flag);

/**
 * \fn int GUIAPI GetMenuItemCount (HMENU hmnu)
 * \brief Determines the number of items in a menu.
 *
 * This function determines the number of items in the specified menu \a hmnu.
 *
 * \param hmnu The handle to the menu.
 *
 * \return The number of the items in the menu.
 *
 * \sa GetMenuItemInfo
 */
MG_EXPORT int GUIAPI GetMenuItemCount (HMENU hmnu);

/**
 * \fn LINT GUIAPI GetMenuItemID (HMENU hmnu, int pos)
 * \brief Retrieves the menu item identifier of a menu item at specified 
 *        position in a menu.
 *
 * This function retrieves the menu item identifier of a menu item at 
 * the specified position \a pos in the specified menu \a hmnu.
 *
 * \param hmnu The handle to the menu.
 * \param pos The position of the menu item. The position value of the 
 *        first item is 0.
 *
 * \return The identifier of the items in the menu.
 * \note The type of return value changed from int to LINT since v3.2.
 *
 * \sa GetMenuItemInfo
 */
MG_EXPORT LINT GUIAPI GetMenuItemID (HMENU hmnu, int pos); 

/**
 * \fn int GUIAPI GetMenuItemInfo (HMENU hmnu, LINT item, \
 *               UINT flag, PMENUITEMINFO pmii)
 * \brief Retrieves information about a menu item.
 *
 * This function retrieves information about a menu item, and returns the
 * information via \a pmii.
 *
 * \param hmnu [in] Handle to the menu that contains the menu item.
 * \param item The position of the menu item or submenu.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 * \param pmii [in, out] Pointer to a \a MENUITEMINFO structure that specifies 
 * the information to retrieve and receive information about the menu item.
 * 
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa SetMenuItemInfo, MENUITEMINFO
 */
MG_EXPORT int GUIAPI GetMenuItemInfo (HMENU hmnu, LINT item, 
                            UINT flag, PMENUITEMINFO pmii);

/*Reserved*/
int GUIAPI GetMenuItemRect (HWND hwnd, HMENU hmnu, 
                LINT item, PRECT prc);

/**
 * \fn HMENU GUIAPI GetPopupSubMenu (HMENU hpppmnu)
 * \brief Retrieves the submenu of the specified popup menu.
 *
 * This function retrieves the submenu of the specified popup menu.
 *
 * \param hpppmnu The handle to the popup menu.
 *
 * \return The handle to the submenu of the popup menu.
 *
 * \sa CreatePopupMenu
 */
MG_EXPORT HMENU GUIAPI GetPopupSubMenu (HMENU hpppmnu);

/**
 * \fn HMENU GUIAPI StripPopupHead (HMENU hpppmnu)
 * \brief Strips the title of the popup menu.
 *
 * This function strips the title of the popup menu \a hpppmnu.
 *
 * \param hpppmnu The handle to the popup menu.
 *
 * \return The handle to the submenu whose title has been stripped.
 *
 * \sa GetPopupSubMenu
 */
MG_EXPORT HMENU GUIAPI StripPopupHead (HMENU hpppmnu);

/**
 * \fn HMENU GUIAPI GetSubMenu (HMENU hmnu, int pos)
 * \brief Retrieves the handle to the submenu activated by the specified menu 
 *        item.
 *
 * This function retrieves the handle to the drop-down menu or submenu 
 * activated by the specified menu item.
 *
 * \param hmnu The handle to the menu.
 * \param pos The position of the menu item. The position value of the 
 *        first item is 0.
 *
 * \return The handle to the submenu; 0 if the menu item can not activate 
 *         a submenu.
 *
 * \sa GetPopupSubMenu
 */
MG_EXPORT HMENU GUIAPI GetSubMenu (HMENU hmnu, int pos);

/**
 * \fn HMENU GUIAPI GetSystemMenu (HWND hwnd, BOOL flag)
 * \brief Allows the application to access the window menu (also known as 
 *        the system menu) for copying and modifying.
 *
 * This function returns the handle to the system menu of the main window.
 * This allows the application to access the window menu (also known as
 * the system menu) for copying and modifying.
 *
 * \param hwnd The handle to the main window.
 * \param flag Ignored currently; reserved for future use.
 *
 * \return The handle to the system menu; 0 if the main window has not 
 *         a system menu.
 * 
 * \sa GetMenu, SetMenu
 */
MG_EXPORT HMENU GUIAPI GetSystemMenu (HWND hwnd, BOOL flag);

/**
 * \fn UINT GUIAPI EnableMenuItem (HMENU hmnu, LINT item, UINT flag)
 * \brief Enables, disables, or grays the specified menu item.
 *
 * This function enables, disables, or grays the specified menu item.
 *
 * \param hmnu [in] Handle to the menu.
 * \param item [in] Specifies the menu item or submenu to be enabled, disabled,
 * or grayed, as determined by the \a flag parameter. This parameter specifies
 * an item in a menu bar, menu or submenu.
 * \param flag [in] Controls the interpretation of the \a item parameter and 
 * indicates whether the menu item is enabled, disabled, or grayed. This 
 * parameter must be a combination of either MF_BYPOSITION or MF_BYCOMMAND.
 *
 * \return The return value specifies the previous state of the menu item.
 * If the menu item does not exist, the return value is -1.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa GetMenuItemInfo
 */
MG_EXPORT UINT GUIAPI EnableMenuItem (HMENU hmnu, LINT item, UINT flag);

/**
 * \fn LINT GUIAPI CheckMenuRadioItem (HMENU hmnu, LINT first, LINT last, \
 *               LINT checkitem, UINT flag)
 * \brief Checks a specified menu item and makes it a radio item.
 *
 * This function checks a specified menu item and makes it a radio item. 
 * At the same time, the function unchecks all other menu items in the 
 * associated group and clears the radio-item type flag for those items.
 *
 * \param hmnu The handle to the menu.
 * \param first The position of the first item in the group.
 * \param last The position of the last item in the group.
 * \param checkitem The position of the menu item to check.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \note The type of \a first, \a last, \a checkitem changed from 
 *       int to LINT since v3.2.
 *
 * \sa SetMenuItemInfo, MENUITEMINFO
 */
MG_EXPORT int GUIAPI CheckMenuRadioItem (HMENU hmnu, LINT first, LINT last, 
                            LINT checkitem, UINT flag);

/**
 * \fn int GUIAPI SetMenuItemBitmaps (HMENU hmnu, LINT item, \
 *                UINT flag, PBITMAP hBmpUnchecked, PBITMAP hBmpChecked)
 * \brief Associates the specified bitmap with a menu item.
 *
 * This function associates the specified bitmap with a menu item. 
 * Whether the menu item is checked or unchecked, the system displays the 
 * appropriate bitmap next to the menu item.
 *
 * \param hmnu The handle to the menu.
 * \param item The position of the menu item.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 * \param hBmpUnchecked The pointer to the unchecked BITMAP object.
 * \param hBmpChecked The pointer to the checked BITMAP object.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa SetMenuItemInfo, MENUITEMINFO
 */
MG_EXPORT int GUIAPI SetMenuItemBitmaps (HMENU hmnu, LINT item, UINT flag, 
                            PBITMAP hBmpUnchecked, PBITMAP hBmpChecked);

/**
 * \fn int GUIAPI SetMenuItemInfo (HMENU hmnu, LINT item, \
 *               UINT flag, PMENUITEMINFO pmii)
 * \brief Changes information about a menu item.
 *
 * This function changes information about the specified menu item.
 *
 * \param hmnu [in] Handle to the menu that contains the menu item.
 * \param item [in] Specifies the identifier or position of the menu item 
 * to change. The meaning of this parameter depends on the value of \a flag.
 * \param flag Indicates the position base, can be one of the following values:
 *      - MF_BYCOMMAND\n
 *        The position value \a item is based on the command identifier.
 *      - MF_BYPOSITION\n
 *        The position value \a item is based on the position in the menu.
 * \param pmii The pointer to a MENUITEMINFO structure contains the information.
 *
 * \return The function returns 0 for success, non-zero for failure.
 *
 * \note The type of \a item changed from int to LINT since v3.2.
 *
 * \sa GetMenuItemInfo, MENUITEMINFO
 */
MG_EXPORT int GUIAPI SetMenuItemInfo (HMENU hmnu, LINT item, 
                            UINT flag, PMENUITEMINFO pmii);

    /** @} end of menu_fns */

    /**
     * \defgroup dialog_fns Dialog operations
     * @{
     */

/* Dialog codes */
/**
 * \def DLGC_WANTARROWS
 * \brief Control wants arrow keys.
 */
#define DLGC_WANTARROWS     0x0001     
/**
 * \def DLGC_WANTTAB
 * \brief Control wants tab keys
 */
#define DLGC_WANTTAB        0x0002    
/**
 * \def DLGC_WANTALLKEYS
 * \brief Control wants all keys.
 */
#define DLGC_WANTALLKEYS    0x0004   
/**
 * \def DLGC_WANTCHARS
 * \brief Want MSG_CHAR messages.
 */
#define DLGC_WANTCHARS      0x0008  

/**
 * \def DLGC_WANTENTER
 * \brief Control wants enter keys.
 */
#define DLGC_WANTENTER      0x0010 
/**
 * \def DLGC_HASSETSEL
 * \brief Understands EM_SETSEL message.
 */
#define DLGC_HASSETSEL      0x0080    

/**
 * \def DLGC_DEFPUSHBUTTON
 * \brief Default pushbutton.
 */
#define DLGC_DEFPUSHBUTTON  0x0100   
/**
 * \def DLGC_PUSHBUTTON
 * \brief Non-default pushbutton.
 */
#define DLGC_PUSHBUTTON     0x0200  
/**
 * \def DLGC_RADIOBUTTON
 * \brief Radio button.
 */
#define DLGC_RADIOBUTTON    0x0400 
/**
 * \def DLGC_3STATE
 * \brief 3 States button item.
 */
#define DLGC_3STATE         0x0800
/**
 * \def DLGC_STATIC
 * \brief Static item: don't include.
 */
#define DLGC_STATIC         0x1000 
/**
 * \def DLGC_BUTTON
 * \brief Button item: can be checked.
 */
#define DLGC_BUTTON         0x2000    

/**
 * Structure which defines a control.
 */
typedef struct _CTRLDATA
{
    /** Class name of the control */
    const char* class_name;             
    /** Control style */
    DWORD       dwStyle;                
    /** Control position in dialog */
    int         x, y, w, h;             
    /** Control identifier
      * \note The type changed from int to LINT since v3.2.
      */
    LINT         id;                     
    /** Control caption */
    const char* caption;                
    /** Additional data */
    DWORD       dwAddData;              
    /** Control extended style */
    DWORD       dwExStyle;              

    /** window element renderer name */
    const char* werdr_name;

    /** table of we_attrs */
    const WINDOW_ELEMENT_ATTR* we_attrs;
} CTRLDATA;
typedef CTRLDATA* PCTRLDATA;

/**
 * Structure which defines a dialogbox.
 *
 * Example:
 * 
 * \include dlgtemplate.c
 */
typedef struct _DLGTEMPLATE
{
    /** Dialog box style */
    DWORD       dwStyle;                
    /** Dialog box extended style */
    DWORD       dwExStyle;              
    /** Dialog box position */
    int         x, y, w, h;             
    /** Dialog box caption */
    const char* caption;                
    /** Dialog box icon */
    HICON       hIcon;                  
    /** Dialog box menu */
    HMENU       hMenu;                  
    /** Number of controls */
    int         controlnr;              
    /** Poiter to control array */
    PCTRLDATA   controls;               
    /** Addtional data, must be zero */
    DWORD       dwAddData;              
} DLGTEMPLATE;
typedef DLGTEMPLATE* PDLGTEMPLATE;

/**
 * \fn HWND GUIAPI CreateMainWindowIndirectParamEx (PDLGTEMPLATE pDlgTemplate, \
 *               HWND hOwner, WNDPROC WndProc, LPARAM lParam, \
 *               const char* werdr_name, WINDOW_ELEMENT_ATTR* we_attrs, \
 *               const char* window_name, const char* layer_name);
 * \brief Uses a dialog template and other information to create a modeless 
 *        main window and controls in it, and pass a parameter to the window 
 *        procedure.
 *
 * This function uses a dialog template pointed to by \a pDlgTemplate and 
 * other information to create a modeless main window and controls in it. 
 * The parameter specified by \a lParam will be passed to the window procedure 
 * as the second paramter of MSG_INITDIALOG message.
 *
 * \param pDlgTemplate The pointer to a DLGTEMPLATE structure.
 * \param hOwner The handle to the hosting main window.
 * \param WndProc The window procedure of the new main window.
 * \param lParam The parameter will be passed to the window procedure.
 * \param werdr_name The name of window element renderer. NULL for default 
 *                 renderer.
 * \param we_attrs The pointer to window element attribute table. NULL for 
 *                 default window attribute table.
 * \param window_name The window name; reserved for future use.
 * \param layer_name The layer name; reserved for future use.
 *
 * \return Handle to the new main window, HWND_INVALID on error.
 *
 * \sa CreateMainWindowIndirectParam, DestroyMainWindowIndirect, 
 *     DialogBoxIndirectParam, DLGTEMPLATE
 */

MG_EXPORT HWND GUIAPI CreateMainWindowIndirectParamEx (PDLGTEMPLATE pDlgTemplate,
        HWND hOwner, WNDPROC WndProc, LPARAM lParam,
        const char* werdr_name, WINDOW_ELEMENT_ATTR* we_attrs,
        const char* window_name, const char* layer_name);

/**
 * \fn HWND GUIAPI CreateMainWindowIndirectParam (
                   PDLGTEMPLATE pDlgTemplate, HWND hOwner, 
                   WNDPROC WndProc, LPARAM lParam)
 * \brief A simplified version of CreateMainWindowIndirectParamEx.
 *
 * This function creates a main window by calling 
 * CreateMainWindowIndirectParamEx function and passing NULL for 
 * werdr_name, we_attrs, window_name, and layer_name parameters.
 *
 * \sa CreateMainWindowIndirectParamEx
 */
static inline HWND GUIAPI CreateMainWindowIndirectParam (
                PDLGTEMPLATE pDlgTemplate, HWND hOwner, 
                WNDPROC WndProc, LPARAM lParam)
{
    return CreateMainWindowIndirectParamEx (pDlgTemplate, hOwner, 
            WndProc, lParam, NULL, NULL, NULL, NULL);
}

/**
 * \fn HWND GUIAPI CreateMainWindowIndirect (
                    PDLGTEMPLATE pDlgTemplate, HWND hOwner, 
                    WNDPROC WndProc)
 * \brief A simplified version of CreateMainWindowIndirectParam.
 *
 * This function creates a main window by calling CreateMainWindowIndirectParam
 * function and passing 0 for lParam parameter.
 *
 * \sa CreateMainWindowIndirectParam
 */
static inline HWND GUIAPI CreateMainWindowIndirect (
                PDLGTEMPLATE pDlgTemplate, HWND hOwner, WNDPROC WndProc)
{
    return CreateMainWindowIndirectParam (pDlgTemplate, hOwner, WndProc, 0);
}

/**
 * \fn BOOL GUIAPI DestroyMainWindowIndirect (HWND hMainWin)
 * \brief Destroys a main window created by \a CreateMainWindowIndirectParam.
 *
 * This function destroys the main window which was created by 
 * \a CreateMainWindowIndirectParam function.
 *
 * \param hMainWin The handle to the main window.
 *
 * \sa CreateMainWindowIndirectParam
 */
MG_EXPORT BOOL GUIAPI DestroyMainWindowIndirect (HWND hMainWin);

/**
 * \fn int GUIAPI DialogBoxIndirectParamEx (PDLGTEMPLATE pDlgTemplate, \
 *               HWND hOwner, WNDPROC DlgProc, LPARAM lParam, \
 *               const char* werdr_name, WINDOW_ELEMENT_ATTR* we_attrs, \
 *               const char* window_name, const char* layer_name);
 * \brief Creates a modal dialog box from a dialog box template 
 *        in memory and other information.
 *
 * This function creates a modal dialog box from a dialog box template 
 * in memory and other information. Before displaying the dialog box, 
 * the function passes an application-defined value to the dialog box 
 * procedure as the second parameter of the MSG_INITDIALOG message. 
 * An application can use this value to initialize the controls in the 
 * dialog box.
 *
 * \param pDlgTemplate The pointer to a DLGTEMPLATE structure.
 * \param hOwner The handle to the hosting main window.
 * \param DlgProc The window procedure of the new dialog box.
 * \param lParam The parameter will be passed to the window procedure.
 * \param werdr_name The name of window element renderer. NULL for 
 *                   default renderer.
 * \param we_attrs The pointer to window element attribute table. 
 *                 NULL for default window attribute table.
 * \param window_name The window name; reserved for future use.
 * \param layer_name The layer name; reserved for future use.
 *
 * \return Return value of the dialog box, i.e., the second argument
 *         passed to EndDialog function which closes the dialog box.
 *
 * \sa EndDialog, DialogBoxIndirectParam, CreateMainWindowIndirectParam, 
 *     DLGTEMPLATE
 */

MG_EXPORT int GUIAPI DialogBoxIndirectParamEx (PDLGTEMPLATE pDlgTemplate,
        HWND hOwner, WNDPROC DlgProc, LPARAM lParam,
        const char* werdr_name, WINDOW_ELEMENT_ATTR* we_attrs,
        const char* window_name, const char* layer_name);

/**
 * \fn int GUIAPI DialogBoxIndirectParam (PDLGTEMPLATE pDlgTemplate,
                HWND hOwner, WNDPROC DlgProc, LPARAM lParam)
 * \brief A simplified version of DialogBoxIndirectParamEx.
 *
 * This function creates a dialog box by calling 
 * DialogBoxIndirectParamEx function and passing NULL for 
 * werdr_name, we_attrs, window_name, and layer_name parameters.
 *
 * \sa DialogBoxIndirectParamEx
 */
static inline int GUIAPI DialogBoxIndirectParam (PDLGTEMPLATE pDlgTemplate,
                HWND hOwner, WNDPROC DlgProc, LPARAM lParam)
{
    return DialogBoxIndirectParamEx (pDlgTemplate, hOwner, DlgProc, lParam,
                NULL, NULL, NULL, NULL);
}

/**
 * \fn BOOL GUIAPI EndDialog (HWND hDlg, int endCode)
 * \brief Destroys a modal dialog box, causing MiniGUI to end any processing 
 *        for the dialog box.
 *
 * This function destroys the modal dialog box \a hDlg created by 
 * \a DialogBoxIndirectParam and ends any processing for the dialog box. 
 * The argument \a endCode will be returned by \a DialogBoxIndirectParam 
 * as the return value.
 *
 * \param hDlg The handle to the dialog box.
 * \param endCode The value will be returned by \a DialogBoxIndirectParam.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \sa DialogBoxIndirectParam
 */
MG_EXPORT BOOL GUIAPI EndDialog (HWND hDlg, int endCode);

/**
 * \fn void GUIAPI DestroyAllControls (HWND hWnd)
 * \brief Destroys all controls in a window.
 *
 * This function destroys all controls (child windows) in a window.
 *
 * \param hWnd The handle to the window.
 *
 * \sa DestroyWindow
 */
MG_EXPORT void GUIAPI DestroyAllControls (HWND hWnd);

/**
 * \fn HWND GUIAPI GetDlgDefPushButton (HWND hWnd)
 * \brief Gets the default push button control in a window.
 *
 * This function gets the handle to the default push button 
 * (with BS_DEFPUSHBUTTON style) in the specified window \a hWnd.
 *
 * \param hWnd The handle to the window.
 * \return The handle to the default push button, 
 *         zero for non default push button in the window.
 */
MG_EXPORT HWND GUIAPI GetDlgDefPushButton (HWND hWnd);

/**
 * \fn LINT GUIAPI GetDlgCtrlID (HWND hwndCtl)
 * \brief Gets the integer identifier of a control.
 *
 * This function gets the integer identifier of the control \a hwndCtl.
 *
 * \param hwndCtl The handle to the control.
 *
 * \return The identifier of the control, -1 for error.
 *
 * \note The type of return value changed from int to LINT since v3.2.
 *
 * \sa GetDlgItem
 */
MG_EXPORT LINT GUIAPI GetDlgCtrlID (HWND hwndCtl);

/**
 * \fn HWND GUIAPI GetDlgItem (HWND hDlg, LINT nIDDlgItem)
 * \brief Retrives the handle to a control in a dialog box.
 *
 * This function retrives the handle to a control, whose identifier is 
 * \a nIDDlgItem, in the specified dialog box \a hDlg.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \return The handle to the control, zero for not found.
 */
MG_EXPORT HWND GUIAPI GetDlgItem (HWND hDlg, LINT nIDDlgItem);

/**
 * \fn UINT GUIAPI GetDlgItemInt (HWND hDlg, LINT nIDDlgItem, \
 *               BOOL *lpTranslated, BOOL bSigned)
 * \brief Translates the text of a control in a dialog box into an integer 
 *        value.
 *
 * This function translates the text of the control, whose identifier is 
 * \a nIDDlgItem in the dialog box \a hDlg into an integer value.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 * \param lpTranslated The pointer to a boolean value, which indicates whether
 *        translated successfully.
 * \param bSigned Indicates whether handle the text as a signed integer.
 *
 * \return The translated 32-bit integer.
 *
 * \note MiniGUI uses \a strtol or \a strtoul to convert the string value 
 * to a 32-bit integer, and pass the base as 0. Thus, the valid string value 
 * should be in the following forms:
 *
 *  - [+|-]0x[0-9|A-F]*\n
 *    Will be read in base 16.
 *  - [+|-]0[0-7]*\n
 *    Will be read in base 8.
 *  - [+|-][1-9][0-9]*\n
 *    Will be read in base 10.
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \sa GetDlgItemText, SetDlgItemInt
 */
MG_EXPORT UINT GUIAPI GetDlgItemInt (HWND hDlg, LINT nIDDlgItem, 
                BOOL *lpTranslated, BOOL bSigned);

/**
 * \fn int GUIAPI GetDlgItemText (HWND hDlg, LINT nIDDlgItem, \
 *               char* lpString, int nMaxCount)
 * \brief Retrieves the title or text associated with a control in a dialog box.
 *
 * This function retrives the title or text associated with a control, whose
 * identifier is \a nIDDlgItem in the dialog box \a hDlg.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 * \param lpString The pointer to a buffer which receives the text.
 * \param nMaxCount The maximal length of the string, not including 
 *        the null character.
 *
 * \return The length of the null-terminated text.
 *
 * \note The buffer should at least have size of (\a nMaxCount + 1).
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \sa GetDlgItemInt, GetDlgItemText2
 */
MG_EXPORT int GUIAPI GetDlgItemText (HWND hDlg, LINT nIDDlgItem, 
                char* lpString, int nMaxCount);

/**
 * \fn char* GUIAPI GetDlgItemText2 (HWND hDlg, LINT id, int* lenPtr)
 * \brief Retrieves the title or text associated with a control in a dialog box.
 *
 * This function is similiar as \a GetDlgItemText function,
 * but it allocates memory for the text and returns the pointer 
 * to the allocated buffer. You should free the buffer when done by using
 * \a free function.
 *
 * \param hDlg The handle to the dialog box.
 * \param id The identifier of the control.
 * \param lenPtr The pointer to an integer which receives the length of the text
 *        if it is not NULL.
 *
 * \return The pointer to the allocated buffer.
 *
 * \note The type of \a id changed from int to LINT since v3.2.
 *
 * \sa GetDlgItemText
 */
MG_EXPORT char* GUIAPI GetDlgItemText2 (HWND hDlg, LINT id, int* lenPtr);

/**
 * \fn HWND GUIAPI GetNextDlgGroupItem (HWND hDlg, \
 *               HWND hCtl, BOOL bPrevious)
 * \brief Retrieves the handle to the first control in a group of controls 
 *        that precedes (or follows) the specified control in a dialog box.
 *
 * This function retrieves the handle to the first control in a group of 
 * controls that precedes (or follows) the specified control \a hCtl in 
 * the dialog box \a hDlg.
 *
 * \param hDlg The handle to the dialog box.
 * \param hCtl The handle to the control.
 * \param bPrevious A boolean value indicates to retrive the preceding or 
 *        following control. TRUE for preceding control.
 *
 * \return The handle to the preceding or following control.
 *
 * \sa GetNextDlgTabItem
 */
MG_EXPORT HWND GUIAPI GetNextDlgGroupItem (HWND hDlg, 
                HWND hCtl, BOOL bPrevious);

/**
 * \fn HWND GUIAPI GetNextDlgTabItem (HWND hDlg, HWND hCtl, BOOL bPrevious)
 * \brief Retrieves the handle to the first control that has the WS_TABSTOP 
 *        style that precedes (or follows) the specified control.
 *
 * This function retrieves the handle to the first control that has the 
 * WS_TABSTOP style that precedes (or follows) the specified control \a hCtl
 * in the dialog box \a hDlg.
 *
 * \param hDlg The handle to the dialog box.
 * \param hCtl The handle to the control.
 * \param bPrevious A boolean value indicates to retrive the preceding or 
 *        following control. TRUE for preceding control.
 *
 * \return The handle to the preceding or following control.
 *
 * \sa GetNextDlgGroupItem
 */
MG_EXPORT HWND GUIAPI GetNextDlgTabItem (HWND hDlg, HWND hCtl, BOOL bPrevious);

/**
 * \fn LRESULT GUIAPI SendDlgItemMessage (HWND hDlg, LINT nIDDlgItem, \
 *               UINT message, WPARAM wParam, LPARAM lParam)
 * \brief Sends a message to the specified control in a dialog box.
 *
 * This function sends a message specified by (\a message, \a wParam, \a lParam)
 * to the specified control whose identifier is \a nIDDlgItem in the dialog 
 * box \a hDlg.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 * \param message The message identifier.
 * \param wParam The first message parameter.
 * \param lParam The second message parameter.
 *
 * \return The return value of the message handler.
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \sa SendMessage, GetDlgItem
 */
MG_EXPORT LRESULT GUIAPI SendDlgItemMessage (HWND hDlg, LINT nIDDlgItem, 
                UINT message, WPARAM wParam, LPARAM lParam);

/**
 * \fn BOOL GUIAPI SetDlgItemInt (HWND hDlg, LINT nIDDlgItem, \
 *               UINT uValue, BOOL bSigned)
 * \brief Sets the text of a control in a dialog box to the string 
 *        representation of a specified integer value.
 *
 * This function sets the text of the control whose identifier is \a nIDDlgItem 
 * in the dialog box \a hDlg to the string representation of 
 * the specified integer value \a nValue.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 * \param uValue The 32-bit integer value.
 * \param bSigned A boolean value indicates whether the integer value is a 
 *        signed integer.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \sa GetDlgItemInt, SetDlgItemText
 */
MG_EXPORT BOOL GUIAPI SetDlgItemInt (HWND hDlg, LINT nIDDlgItem, 
                UINT uValue, BOOL bSigned);

/**
 * \fn BOOL GUIAPI SetDlgItemText (HWND hDlg, int nIDDlgItem, \
 *               const char* lpString)
 * \brief Sets the title or text of a control in a dialog box.
 *
 * This function sets the title or text of the control whose identifier 
 * is \a nIDDlgItem in the dialog box \a hDlg to the string pointed to 
 * by \a lpString.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 * \param lpString The pointer to the string.
 *
 * \return TRUE on success, FALSE on error.
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \sa GetDlgItemText, SetDlgItemInt
 */
MG_EXPORT BOOL GUIAPI SetDlgItemText (HWND hDlg, LINT nIDDlgItem, 
                const char* lpString);

#ifdef _MGCTRL_BUTTON

/**
 * \fn void GUIAPI CheckDlgButton (HWND hDlg, LINT nIDDlgItem, int nCheck)
 * \brief Changes the check status of a button control.
 *
 * This function changes the check status of the button control whose 
 * identifier is \a nIDDlgItem in the dialog box \a hDlg.
 *
 * \param hDlg The handle to the dialog box.
 * \param nIDDlgItem The identifier of the control.
 * \param nCheck The state of the button. If the button is a normal button,
 *        the value being zero means the button is checked, otherwise unchecked.
 *        If the button is a special button with three states, the value 
 *        can be one of the following values:
 *          - BST_UNCHECKED\n
 *            The button is unchecked.
 *          - BST_CHECKED\n
 *            The button is checked.
 *          - BST_INDETERMINATE\n
 *            The button is in indeterminate state.
 *
 * \note The type of \a nIDDlgItem changed from int to LINT since v3.2.
 *
 * \sa CheckRadioButton, IsDlgButtonChecked
 */
MG_EXPORT void GUIAPI CheckDlgButton (HWND hDlg, LINT nIDDlgItem, int nCheck);

/**
 * \fn void GUIAPI CheckRadioButton (HWND hDlg, \
 *               LINT idFirstButton, LINT idLastButton, LINT idCheckButton)
 * \brief Adds a check mark to (checks) a specified radio button in a group 
 *        and removes a check mark from (clears) all other radio buttons in 
 *        the group.
 *
 * This function adds a check mark to (checks) the specified radio button 
 * \a idCheckButton in a group between \a idFirstButton and \a idLastButton, 
 * and removes a check mark from (clears) all other radio buttons in the group.
 *
 * \param hDlg The handle to the dialog box.
 * \param idFirstButton The identifier of the first control in the group.
 * \param idLastButton The identifier of the last control in the group.
 * \param idCheckButton The identifier of the control to be checked.
 *
 * \note The type of \a idFirstButton, \a idLastButton, and \a idCheckButton
 *       changed from int to LINT since v3.2.
 *
 * \sa CheckDlgButton
 */
MG_EXPORT void GUIAPI CheckRadioButton (HWND hDlg, 
                LINT idFirstButton, LINT idLastButton, LINT idCheckButton);

/**
 * \fn int GUIAPI IsDlgButtonChecked (HWND hDlg, LINT idButton)
 * \brief Determines whether a button control has a check mark next to it or 
 *        whether a three-state button control is grayed, checked, or neither.
 *
 * This function determines whether the button control whose identifier is 
 * \a idButton has a check mark next to it or whether a three-state button 
 * control is grayed, checked, or neither.
 *
 * \param hDlg The handle to the dialog box.
 * \param idButton The identifier of the button.
 *
 * \return The check state of the button. If the button is a normal button,
 *        the value being zero means the button is checked, otherwise unchecked.
 *        If the button is a special button with three states, the value 
 *        can be one of the following values:
 *          - BST_UNCHECKED\n
 *            The button is unchecked.
 *          - BST_CHECKED\n
 *            The button is checked.
 *          - BST_INDETERMINATE\n
 *            The button is in indeterminate state.
 *
 * \note The type of \a idButton tem changed from int to LINT since v3.2.
 *
 * \sa CheckDlgButton
 */
MG_EXPORT int  GUIAPI IsDlgButtonChecked (HWND hDlg, LINT idButton); 
#endif

     /** @} end of dialog_fns */

     /**
      * \defgroup msgbox_fns Message box operations
      * @{
      */

#if defined(_MGCTRL_STATIC) && defined (_MGCTRL_BUTTON)

/* Standard control IDs */
#define IDC_STATIC    0
#define IDOK          1
#define IDCANCEL      2
#define IDABORT       3
#define IDRETRY       4
#define IDIGNORE      5
#define IDYES         6
#define IDNO          7

#define MINID_RESERVED      0xF001
#define MAXID_RESERVED      0xFFFF

#define MB_OK                   0x00000000
#define MB_OKCANCEL             0x00000001
#define MB_YESNO                0x00000002
#define MB_RETRYCANCEL          0x00000003
#define MB_ABORTRETRYIGNORE     0x00000004
#define MB_YESNOCANCEL          0x00000005
#define MB_CANCELASBACK         0x00000008  /* customized style */
#define MB_TYPEMASK             0x00000007

#define MB_ICONHAND             0x00000010
#define MB_ICONQUESTION         0x00000020
#define MB_ICONEXCLAMATION      0x00000030
#define MB_ICONASTERISK         0x00000040
#define MB_ICONMASK             0x000000F0

#define MB_ICONINFORMATION      MB_ICONASTERISK
#define MB_ICONSTOP             MB_ICONHAND

#define MB_DEFBUTTON1           0x00000000
#define MB_DEFBUTTON2           0x00000100
#define MB_DEFBUTTON3           0x00000200
#define MB_DEFMASK              0x00000F00

/* #define MB_APPLMODAL            0x00000000 */
/* #define MB_SYSTEMMODAL          0x00001000 */
/* #define MB_TASKMODAL            0x00002000 */

#define MB_NOFOCUS              0x00008000

#define MB_ALIGNCENTER          0x00000000
#define MB_ALIGNTOPLEFT         0x00010000
#define MB_ALIGNBTMLEFT         0x00020000
#define MB_ALIGNTOPRIGHT        0x00030000
#define MB_ALIGNBTMRIGHT        0x00040000
#define MB_ALIGNMASK            0x00070000

#define MB_BASEDONPARENT        0x00080000  /* default is desktop. */

/**
 * \fn int GUIAPI MessageBox (HWND hParentWnd, const char* pszText, \
 *               const char* pszCaption, DWORD dwStyle)
 * \brief Displays a message box within one, two, or three push buttons.
 *
 * This function displays a message box within one, two, or three buttons, 
 * and returns the identifier of the button clicked by the user. You can 
 * pass \a dwStyle argument with different values to control the number of 
 * buttons, the button titles, and so on.
 *
 * \param hParentWnd The handle to the hosting main window.
 * \param pszText The message text will be displayed in the message box.
 * \param pszCaption The caption of the message box.
 * \param dwStyle Specifies the contents and behavior of the dialog box. 
 * This parameter can be a combination of flags from the following groups 
 * of flags.
 *
 *          To indicate the buttons displayed in the message box, specify 
 *          one of the following values.
 *          - MB_OK\n
 *            Create a message box within only one button whose title is "OK".
 *          - MB_OKCANCEL\n
 *            Create a message box within two buttons whose title are "OK" 
 *            and "Cancel" respectively.
 *          - MB_YESNO\n
 *            Create a message box within two buttons whose title are "Yes" 
 *            and "No" respectively.
 *          - MB_RETRYCANCEL\n
 *            Create a message box within two buttons whose title are "Retry" 
 *            and "Cancel" respectively.
 *          - MB_ABORTRETRYIGNORE\n
 *            Create a message box within three buttons whose title are 
 *            "Abort", "Retry" and "Ignore" respectively.
 *          - MB_YESNOCANCEL\n
 *            Create a message box within three buttons whose title are 
 *            "Yes", "No" and "Cancel" respectively.
 *          - MB_CANCELASBACK\n
 *            Title "Cancel" replaced with title "Previous".
 *
 *          To display an icon in the message box, specify one of the following
 *          values.
 *          - MB_ICONHAND\n
 *            Display a hand/stop icon in the message box.
 *          - MB_ICONQUESTION\n
 *            Display a question mark icon in the message box.
 *          - MB_ICONEXCLAMATION\n
 *            Display a exclamation mark icon in the message box.
 *          - MB_ICONASTERISK\n
 *            Display an information icon in the message box.
 *          - MB_ICONINFORMATION\n
 *            Display an information icon in the message box.
 *          - MB_ICONSTOP\n
 *            Display a hand/stop icon in the message box.
 *
 *          To indicate the default button, specify one of the following values.
 *          - MB_DEFBUTTON1\n
 *            The first button is the default button. 
 *          - MB_DEFBUTTON2\n
 *            The second button is the default button. 
 *          - MB_DEFBUTTON3\n
 *            The third button is the default button. 
 *
 *          To indicate the default text alignment, specify one of the following
 *          values.
 *          - MB_ALIGNCENTER\n
 *            The message box is center aligned.
 *          - MB_ALIGNTOPLEFT\n
 *            The message box is upper-left aligned.
 *          - MB_ALIGNBTMLEFT\n
 *            The message box is lower-left aligned.
 *          - MB_ALIGNTOPRIGHT\n
 *            The message box is upper-right aligned.
 *          - MB_ALIGNBTMRIGHT\n
 *            The message box is lower-right aligned.
 *
 *          To indicate the default align based on hosting window, specify the following value.
 *          - MB_BASEDONPARENT\n
 *            A flag indicates that the alignments above are based on the 
 *            hosting window, not the desktop. 
 *
 * \return The identifier of the button clicked by user, can be one of the 
 *         following values:
 *          - IDOK\n
 *            The "OK" button clicked.
 *          - IDCANCEL\n
 *            The "Cancel" or "Previous" button clicked.
 *          - IDABORT\n
 *            The "Abort" button clicked.
 *          - IDRETRY\n
 *            The "Retry" button clicked.
 *          - IDIGNORE\n
 *            The "Ignore" button clicked.
 *          - IDYES\n
 *            The "Yes" button clicked.
 *          - IDNO\n
 *            The "No" button clicked.
 *
 * \note This function will call \a GetSysText to translate the button 
 *       titles to localized text.
 *
 * \sa GetSysText, DialogBoxIndirectParam
 */
MG_EXPORT int GUIAPI MessageBox (HWND hParentWnd, const char* pszText, 
                      const char* pszCaption, DWORD dwStyle);

#endif /* _MGCTRL_STATIC && _MGCTRL_BUTTON */

/**
 * \fn void GUIAPI MessageBeep (DWORD dwBeep)
 * \brief Makes a sound of beep.
 *
 * This function makes a sound of beep. We ignore \a dwBeep argument so far.
 *
 * \param dwBeep The beep type, ignored so far.
 *
 * \sa Beep, Ping, Tone
 */
MG_EXPORT void GUIAPI MessageBeep (DWORD dwBeep);

    /** @} end of msgbox_fns */
    /** @} end of window_fns */
    /** @} end of fns */

MG_EXPORT void GUIAPI Shadow_cw_ccw_switch(int iscw);
#ifdef __cplusplus
}
#endif  /* __cplusplus */

#endif /* _MGUI_WINDOW_H */