windows-server-2003/windows/core/ntuser/client/usercli.h

/****************************** Module Header ******************************\
* Module Name: usercli.h
*
* Copyright (c) 1985 - 1999, Microsoft Corporation
*
* Typedefs, defines, and prototypes that are used exclusively by the User
* client-side DLL.
*
* History:
* 04-27-91 DarrinM      Created from PROTO.H, MACRO.H and STRTABLE.H
\***************************************************************************/

#ifndef _USERCLI_
#define _USERCLI_

#define OEMRESOURCE 1

#include <windows.h>
#include <winnls32.h>

#include <w32gdip.h>
#include <w32err.h>
#include <ddeml.h>
#include "ddemlp.h"
#include "winuserp.h"
#include "w32wow64.h"
#include "winuserk.h"
#include <dde.h>
#include <ddetrack.h>
#include "kbd.h"
#include <wowuserp.h>
#include "immstruc.h"
#include "immuser.h"
#include <winbasep.h>

#include "user.h"
#include "callproc.h"


#if DBG
/*
 * This structure allows apps to set RIP flags locally to their process.
 * This is mostly intended for naughty/penetration apps.
 *
 * dwTouchedMask is used to determine which fields have been locally set.
 * For those that have not been, we'll return the global/kernel values.
 */
#define USERDBG_TAGSTOUCHED     0x1
#define USERDBG_PIDTOUCHED      0x2
#define USERDBG_FLAGSTOUCHED    0x4
typedef struct _USERDBGGLOBALS {
    DWORD adwDBGTAGFlags[DBGTAG_Max + 1];
    DWORD dwRIPPID;
    DWORD dwRIPFlags;
    DWORD dwTouchedMask;
} USERDBGGLOBALS, *PUSERDBGGLOBALS;
#endif

/*
 * This prototype is needed in client\globals.h which is included unintentionally
 * from usersrv.h
 */
typedef LRESULT (APIENTRY *CFNSCSENDMESSAGE)(HWND, UINT, WPARAM, LPARAM,
        ULONG_PTR, DWORD, BOOL);

/***************************************************************************\
* Typedefs and Macros
*
* Here are defined all types and macros that are shared across the User's
* client-side code modules.  Types and macros that are unique to a single
* module should be defined at the head of that module, not in this file.
*
\***************************************************************************/

#define MIRRORED_HDC(hdc)     (GetLayout(hdc) & LAYOUT_RTL)
#define MIRRORED_HWND(hwnd)   (GetWindowLong(hwnd, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)

#ifdef LAZY_CLASS_INIT
BOOL UserRegisterControls(
    VOID);
BOOL UserRegisterDDEML(
    VOID);
extern BOOL gbClassesRegistered;

__inline VOID LazyInitClasses(
    VOID)
{
    if (!gbClassesRegistered) {
        gbClassesRegistered = TRUE;
        UserRegisterControls();
        UserRegisterDDEML();
    }
}
#endif

#if DBG

__inline void DebugUserGlobalUnlock(HANDLE h)
{
    UserAssert(
            "GlobalUnlock on bad handle" &&
            !(GlobalFlags(h) == GMEM_INVALID_HANDLE));

    GlobalUnlock((HANDLE) h);
}

/*
 * Bug 262144 - joejo
 *
 * Changed function to accept a pointer to the handle so we
 * can trash the handle and return it as trashed.
 *
 * Added a local handle variable to accept the return from GlobalFree
 * so we can return it as expected.
 *
 * Trash incoming handle freed so we can track any invalid access on
 * it after it's been free'd.
 */
__inline HANDLE DebugUserGlobalFree(HANDLE* ph)
{
    HANDLE th;

    UserAssert(
            "GlobalFree on bad handle" &&
            !(GlobalFlags(*ph) == GMEM_INVALID_HANDLE));

    th = GlobalFree(*ph);
#if defined(_WIN64)
    *ph = (HANDLE)(PVOID)0xBAADF00DBAADF00D;
#else
    *ph = (HANDLE)(PVOID)0xBAADF00D;
#endif
    return th;
}

__inline HANDLE DebugUserGlobalAlloc(UINT uFlags, SIZE_T dwBytes)
{
    HANDLE h = GlobalAlloc(uFlags, dwBytes);

    /*
     * Assert that FreeDDElParam and _ClientFreeDDEHandle assumption is correct.
     */
    if (h != NULL) {
        UserAssert(h > (HANDLE)0xFFFF);
    }

    return h;
}

#define USERGLOBALUNLOCK(h)             DebugUserGlobalUnlock((HANDLE)(h))
#define UserGlobalFree(h)               DebugUserGlobalFree((HANDLE*)(&h))
#define UserGlobalAlloc(flags, size)    DebugUserGlobalAlloc(flags, size)

#else

#define USERGLOBALUNLOCK(h)             GlobalUnlock((HANDLE)(h))
#define UserGlobalFree(h)               GlobalFree((HANDLE)(h))
#define UserGlobalAlloc(flags, size)    GlobalAlloc(flags, size)
#endif

#define USERGLOBALLOCK(h, p)   p = GlobalLock((HANDLE)(h))
#define UserGlobalReAlloc(pmem, cnt, flags) GlobalReAlloc(pmem,cnt,flags)
#define UserGlobalSize(pmem)                GlobalSize(pmem)
#define WOWGLOBALFREE(pmem)                 GlobalFree(pmem)

#define RESERVED_MSG_BITS   (0xFFFE0000)



/*
 * A macro for testing bits in the message bit-arrays.  Messages in the
 * the bit arrays must be processed
 */
#define FDEFWINDOWMSG(msg, procname) \
    ((msg <= (gSharedInfo.procname.maxMsgs)) && \
            ((gSharedInfo.procname.abMsgs)[msg / 8] & (1 << (msg & 7))))
#define FWINDOWMSG(msg, fnid) \
    ((msg <= (gSharedInfo.awmControl[fnid - FNID_START].maxMsgs)) && \
            ((gSharedInfo.awmControl[fnid - FNID_START].abMsgs)[msg / 8] & (1 << (msg & 7))))

#define CsSendMessage(hwnd, msg, wParam, lParam, xParam, pfn, bAnsi) \
        (((msg) >= WM_USER) ? \
            NtUserMessageCall(hwnd, msg, wParam, lParam, xParam, pfn, bAnsi) : \
            gapfnScSendMessage[MessageTable[msg].iFunction](hwnd, msg, wParam, lParam, xParam, pfn, bAnsi))

#define GetWindowProcess(hwnd) NtUserQueryWindow(hwnd, WindowProcess)
#define GETPROCESSID() (NtCurrentTeb()->ClientId.UniqueProcess)
#define GETTHREADID()  (NtCurrentTeb()->ClientId.UniqueThread)

/*
 * Macro to mask off uniqueness bits for WOW handles
 */
#define SAMEWOWHANDLE(h1, h2)  ((BOOL)!(((ULONG_PTR)(h1) ^ (ULONG_PTR)(h2)) & 0xffff))
#define DIFFWOWHANDLE(h1, h2)  (!SAMEWOWHANDLE(h1, h2))

/*
 * For callbacks to the client - for msg and hook thunks, callback addresses
 * are passed as addresses, not function indexes as they are from client to
 * server.
 */
typedef INT_PTR (WINAPI *GENERICPROC)();

#define CALLPROC(p) ((GENERICPROC)p)
#define PACTCTXT(pwnd) (pwnd ? pwnd->pActCtx : NULL)

extern PFNWOWDLGPROCEX      pfnWowDlgProcEx;
extern PFNWOWWNDPROCEX      pfnWowWndProcEx;

BOOL UserCallDlgProcCheckWow(PACTIVATION_CONTEXT pActCtx, DLGPROC pfn,
        HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, PVOID pww, INT_PTR * pret);
LRESULT UserCallWinProcCheckWow(PACTIVATION_CONTEXT pActCtx, WNDPROC pfn,
        HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, PVOID pww, BOOL fEnableLiteHooks);


/***************************************************************************\
* IsMsgOverride
*
* Returns if a message should be sent to USERAPIHOOK OverrideWndProc()
* hooks.  The message should only be sent if its "index" is within the range
* specified by the hook and its "bit" is on.  It is very important to
* actually check guah.cbMsgMask instead of sizeof(gbLiteHookMsg) because the
* hook may have a smaller MsgMask in which case anything past the end fails.
*
* History:
* 27-Apr-2000  jstall     Created
\***************************************************************************/

__inline BOOL IsMsgOverride(UINT msg, MSGMASK * pmm)
{
    UINT idxMajor = msg / 8;
    if ((pmm->rgb != NULL) && (idxMajor < pmm->cb)) {
        return (pmm->rgb[idxMajor] & (1 << (msg & 7)));
    }

    return FALSE;
}



#define RevalidateHwnd(hwnd)    ((PWND)HMValidateHandleNoSecure(hwnd, TYPE_WINDOW))

#define VALIDATEHMENU(hmenu)        ((PMENU)HMValidateHandle(hmenu, TYPE_MENU))
#define VALIDATEHMONITOR(hmonitor)  ((PMONITOR)HMValidateSharedHandle(hmonitor, TYPE_MONITOR))


/*
 * REBASE macros take kernel desktop addresses and convert them into
 * user addresses.
 *
 * REBASEALWAYS converts a kernel address contained in an object
 * REBASEPWND casts REBASEALWAYS to a PWND
 * REBASE only converts if the address is in kernel space.  Also works for NULL
 * REBASEPTR converts a random kernel address
 */

#define REBASEALWAYS(p, elem) ((PVOID)((KERNEL_ULONG_PTR)(p) + ((KERNEL_ULONG_PTR)(p)->elem - (KERNEL_ULONG_PTR)(p)->head.pSelf)))
#define REBASEPTR(obj, p) ((PVOID)((KERNEL_ULONG_PTR)(p) - ((KERNEL_ULONG_PTR)(obj)->head.pSelf - (KERNEL_ULONG_PTR)(obj))))

#define REBASE(p, elem) ((KERNEL_ULONG_PTR)((p)->elem) <= (KERNEL_ULONG_PTR)gHighestUserAddress ? \
        ((PVOID)(KERNEL_ULONG_PTR)(p)->elem) : REBASEALWAYS(p, elem))
#define REBASEPWND(p, elem) ((PWND)REBASE(p, elem))

#ifndef USEREXTS

PTHREADINFO PtiCurrent(VOID);

/*
 * Window Proc Window Validation macro. This macro assumes
 * that pwnd and hwnd are existing variables pointing to the window.
 * Checking the BUTTON is for Mavis Beacon.
 */

#define VALIDATECLASSANDSIZE(pwnd, inFNID)                                      \
    switch ((pwnd)->fnid) {                                                     \
    case inFNID:                                                                \
        break;                                                                  \
                                                                                \
    case 0:                                                                     \
        if ((pwnd->cbwndExtra + sizeof(WND)) < (DWORD)(CBFNID(inFNID))) {       \
            RIPMSG3(RIP_ERROR,                                                  \
                   "(%#p %lX) needs at least (%ld) window words for this proc", \
                    pwnd, pwnd->cbwndExtra,                                     \
                    (DWORD)(CBFNID(inFNID)) - sizeof(WND));                     \
            return 0;                                                           \
        }                                                                       \
                                                                                \
        if (inFNID == FNID_BUTTON && *((KPULONG_PTR)(pwnd + 1))) {              \
                                                                                \
            RIPMSG3(RIP_WARNING, "Window (%#p) fnid = %lX overrides "           \
                "the extra pointer with %#p\n",                                 \
                pwnd, inFNID, *((KPULONG_PTR)(pwnd + 1)));                      \
                                                                                \
            NtUserSetWindowLongPtr(hwnd, 0, 0, FALSE);                          \
        }                                                                       \
                                                                                \
        NtUserSetWindowFNID(hwnd, inFNID);                                      \
        break;                                                                  \
                                                                                \
    case (inFNID | FNID_CLEANEDUP_BIT):                                         \
    case (inFNID | FNID_DELETED_BIT):                                           \
    case (inFNID | FNID_STATUS_BITS):                                           \
        return 0;                                                               \
                                                                                \
    default:                                                                    \
        RIPMSG3(RIP_WARNING,                                                    \
              "Window (%#p) not of correct class; fnid = %lX not %lX",          \
              (pwnd), (DWORD)((pwnd)->fnid), (DWORD)(inFNID));                  \
        return 0;                                                               \
    }

/*
 * This macro initializes the lookaside entry for a control.  It assumes
 * that pwnd and hwnd are existing variables pointing to the control's
 * windows and that fInit exists as a BOOL initialization flag.
 */
#define INITCONTROLLOOKASIDE(plaType, type, pwnditem, count)                \
    if (!*((KPULONG_PTR)(pwnd + 1))) {                                      \
        P ## type pType;                                                    \
        if (fInit) {                                                        \
            if (!NT_SUCCESS(InitLookaside(plaType, sizeof(type), count))) { \
                NtUserSetWindowFNID(hwnd, FNID_CLEANEDUP_BIT);              \
                NtUserDestroyWindow(hwnd);                                  \
                return FALSE;                                               \
            }                                                               \
            fInit = FALSE;                                                  \
        }                                                                   \
        if ((pType = (P ## type)AllocLookasideEntry(plaType))) {            \
            NtUserSetWindowLongPtr(hwnd, 0, (LONG_PTR)pType, FALSE);        \
            Lock(&(pType->pwnditem), pwnd);                                 \
        } else {                                                            \
            NtUserSetWindowFNID(hwnd, FNID_CLEANEDUP_BIT);                  \
            NtUserDestroyWindow(hwnd);                                      \
            return FALSE;                                                   \
        }                                                                   \
    }

#endif

#define ISREMOTESESSION()   (NtCurrentPeb()->SessionId != USER_SHARED_DATA->ActiveConsoleId)


/*
 * Bitmap related macroes.
 */
#define SetBestStretchMode(hdc, planes, bpp) \
    SetStretchBltMode(hdc, (((planes) * (bpp)) == 1 ? BLACKONWHITE : COLORONCOLOR))

#define BitmapSize(cx, cy, planes, bits) \
        (BitmapWidth(cx, bits) * (cy) * (planes))

#define BitmapWidth(cx, bpp)  (((((cx)*(bpp)) + 31) & ~31) >> 3)

#define RGBX(rgb)  RGB(GetBValue(rgb), GetGValue(rgb), GetRValue(rgb))

/*
 * Typedefs used for capturing string arguments to be passed
 * to the kernel.
 */
typedef struct _IN_STRING {
    UNICODE_STRING strCapture;
    PUNICODE_STRING pstr;
    BOOL fAllocated;
} IN_STRING, *PIN_STRING;

typedef struct _LARGE_IN_STRING {
    LARGE_UNICODE_STRING strCapture;
    PLARGE_UNICODE_STRING pstr;
    BOOL fAllocated;
} LARGE_IN_STRING, *PLARGE_IN_STRING;


/*
 * Lookaside definitions
 */
typedef struct _LOOKASIDE {
    PVOID LookasideBase;
    PVOID LookasideBounds;
    ZONE_HEADER LookasideZone;
    DWORD EntrySize;
#if DBG
    ULONG AllocHiWater;
    ULONG AllocCalls;
    ULONG AllocSlowCalls;
    ULONG DelCalls;
    ULONG DelSlowCalls;
#endif
} LOOKASIDE, *PLOOKASIDE;

NTSTATUS InitLookaside(PLOOKASIDE pla, DWORD cbEntry, DWORD cEntries);
PVOID AllocLookasideEntry(PLOOKASIDE pla);
VOID FreeLookasideEntry(PLOOKASIDE pla, PVOID pEntry);

/***************************************************************************\
*
* Thread and structure locking routines - we'll just define these to do
* nothing for now until we figure out what needs to be done
*
\***************************************************************************/

#undef ThreadLock
#undef ThreadLockAlways
#undef ThreadLockWithPti
#undef ThreadLockAlwaysWithPti
#undef ThreadUnlock
#undef Lock
#undef Unlock
#define CheckLock(pobj)
#define ThreadLock(pobj, ptl) DBG_UNREFERENCED_LOCAL_VARIABLE(*ptl)
#define ThreadLockAlways(pobj, ptl) DBG_UNREFERENCED_LOCAL_VARIABLE(*ptl)
#define ThreadLockWithPti(pti, pobj, ptl) DBG_UNREFERENCED_LOCAL_VARIABLE(*ptl)
#define ThreadLockAlwaysWithPti(pti, pobj, ptl) DBG_UNREFERENCED_LOCAL_VARIABLE(*ptl)
#define ThreadUnlock(ptl) (ptl)
#define Lock(ppobj, pobj) (*ppobj = pobj)
#define Unlock(ppobj) (*ppobj = NULL)

#if !defined(_USERRTL_) && !defined(USEREXTS)
typedef struct _TL {
    int iBogus;
} TL;
#endif

/***************************************************************************\
*
* Button Controls
*
\***************************************************************************/

/*
 *  Note: The button data structures are now found in user.h because the
 *        kernel needs to handle a special case of SetWindowWord on index
 *        0L to change the state of the button.
 */

#define BUTTONSTATE(pbutn)   (pbutn->buttonState)

#define BST_CHECKMASK       0x0003
#define BST_INCLICK         0x0010
#define BST_CAPTURED        0x0020
#define BST_MOUSE           0x0040
#define BST_DONTCLICK       0x0080
#define BST_INBMCLICK       0x0100

#define PBF_PUSHABLE     0x0001
#define PBF_DEFAULT      0x0002

/*
 * BNDrawText codes
 */
#define DBT_TEXT    0x0001
#define DBT_FOCUS   0x0002


/***************************************************************************\
*
* ComboBox
*
\***************************************************************************/

/*
 * ID numbers (hMenu) for the child controls in the combo box
 */
#define CBLISTBOXID 1000
#define CBEDITID    1001
#define CBBUTTONID  1002

/*
 * For CBOX.c. BoxType field, we define the following combo box styles. These
 * numbers are the same as the CBS_ style codes as defined in windows.h.
 */
#define SDROPPABLE      CBS_DROPDOWN
#define SEDITABLE       CBS_SIMPLE


#define SSIMPLE         SEDITABLE
#define SDROPDOWNLIST   SDROPPABLE
#define SDROPDOWN       (SDROPPABLE | SEDITABLE)


/*
 * CBOX.OwnerDraw & LBIV.OwnerDraw types
 */
#define OWNERDRAWFIXED 1
#define OWNERDRAWVAR   2

#define UPPERCASE   1
#define LOWERCASE   2

#define CaretCreate(plb)    ((plb)->fCaret = TRUE)

/*
 * This macro is used to isolate the combo box style bits.  Ie if it the combo
 * box is simple, atomic, dropdown, or a dropdown listbox.
 */
#define COMBOBOXSTYLE(style)   ((LOBYTE(style)) & 3)

#define IsComboVisible(pcbox) (!pcbox->fNoRedraw && IsVisible(pcbox->spwnd))

/*
 * Note that I depend on the fact that these CBN_ defines are the same as
 * their listbox counterparts.  These defines are found in windows.h.
 * #define CBN_ERRSPACE  (-1)
 * #define CBN_SELCHANGE 1
 * #define CBN_DBLCLK    2
 */


/***************************************************************************\
*
* Edit Control Types/Macros
*
\***************************************************************************/

/* Window extra bytes - we need at least this much space for compatibility */
#define CBEDITEXTRA 6

/*
 * NOTE: Text handle is sized as multiple of this constant
 *       (should be power of 2).
 */
#define CCHALLOCEXTRA   0x20

/* Maximum width in pixels for a line/rectangle */

#define MAXPIXELWIDTH   30000

#define MAXCLIPENDPOS   32764

/* Limit multiline edit controls to at most 1024 characters on a single line.
 * We will force a wrap if the user exceeds this limit.
 */

#define MAXLINELENGTH   1024

/*
 * Allow an initial maximum of 30000 characters in all edit controls since
 * some apps will run into unsigned problems otherwise.  If apps know about
 * the 64K limit, they can set the limit themselves.
 */
#define MAXTEXT         30000

/*
 * Key modifiers which have been pressed.  Code in KeyDownHandler and
 * CharHandler depend on these exact values.
 */
#define NONEDOWN   0 /* Neither shift nor control down */
#define CTRLDOWN   1 /* Control key only down */
#define SHFTDOWN   2 /* Shift key only down */
#define SHCTDOWN   3 /* Shift and control keys down = CTRLDOWN + SHFTDOWN */
#define NOMODIFY   4 /* Neither shift nor control down */


#define CALLWORDBREAKPROC(proc, pText, iStart, cch, iAction)                \
    (IsWOWProc(proc) ?                                                      \
        (* pfnWowEditNextWord)(pText, iStart, cch, iAction, PtrToUlong(proc)) :  \
        (* proc)(pText, iStart, cch, iAction))

/*
 * Types of undo supported in this ped
 */
#define UNDO_NONE   0  /* We can't undo the last operation. */
#define UNDO_INSERT 1  /* We can undo the user's insertion of characters */
#define UNDO_DELETE 2  /* We can undo the user's deletion of characters */

typedef struct tagUNDO {
    UINT    undoType;          /* Current type of undo we support */
    PBYTE   hDeletedText;      /* Pointer to text which has been deleted (for
                                  undo) -- note, the memory is allocated as fixed
                                */
    ICH     ichDeleted;        /* Starting index from which text was deleted */
    ICH     cchDeleted;        /* Count of deleted characters in buffer */
    ICH     ichInsStart;       /* Starting index from which text was
                                  inserted */
    ICH     ichInsEnd;         /* Ending index of inserted text */
} UNDO, *PUNDO;

#define Pundo(ped)             ((PUNDO)&(ped)->undoType)

/*
 * Length of the buffer for ASCII character width caching: for characters
 * 0x00 to 0xff (field charWidthBuffer in PED structure below).
 * As the upper half of the cache was not used by almost anyone and fixing
 * it's usage required a lot of conversion, we decided to get rid of it
 * MCostea #174031
 */
#define CHAR_WIDTH_BUFFER_LENGTH 128

typedef struct tagED {
    HANDLE  hText;                      /* Block of text we are editing */
    ICH     cchAlloc;                   /* Number of chars we have allocated for hText*/
    ICH     cchTextMax;                 /* Max number bytes allowed in edit control*/
    ICH     cch;                        /* Current number of bytes of actual text*/
    ICH     cLines;                     /* Number of lines of text */

    ICH     ichMinSel;                  /* Selection extent.  MinSel is first selected
                                         * char
                                         */
    ICH     ichMaxSel;                  /* MaxSel is first unselected character */
    ICH     ichCaret;                   /* Caret location. Caret is on left side of
                                         * char
                                         */
    ICH     iCaretLine;                 /* The line the caret is on. So that if word
                                         * wrapping, we can tell if the caret is at end
                                         * of a line of at beginning of next line...
                                         */
    ICH     ichScreenStart;             /* Index of left most character displayed on
                                         * screen for sl ec and index of top most line
                                         * for multiline edit controls
                                         */
    ICH     ichLinesOnScreen;           /* Number of lines we can display on screen */
    UINT    xOffset;                    /* x (horizontal) scroll position in pixels
                                         * (for multiline text horizontal scroll bar)
                                         */
    UINT    charPasswordChar;           /* If non null, display this character instead
                                         * of the real text. So that we can implement
                                         * hidden text fields.
                                         */
    int     cPasswordCharWidth;         /* Width of password char */

    HWND    hwnd;                       /* Window for this edit control */
    PWND    pwnd;                       /* Pointer to window */
    RECT    rcFmt;                      /* Client rectangle */
    HWND    hwndParent;                 /* Parent of this edit control window */

                                        /* These vars allow us to automatically scroll
                                         * when the user holds the mouse at the bottom
                                         * of the multiline edit control window.
                                         */
    POINT   ptPrevMouse;                /* Previous point for the mouse for system
                                         * timer.
                                         */
    UINT    prevKeys;                   /* Previous key state for the mouse */


    UINT     fSingle       : 1;         /* Single line edit control? (or multiline) */
    UINT     fNoRedraw     : 1;         /* Redraw in response to a change? */
    UINT     fMouseDown    : 1;         /* Is mouse button down? when moving mouse */
    UINT     fFocus        : 1;         /* Does ec have the focus ? */
    UINT     fDirty        : 1;         /* Modify flag for the edit control */
    UINT     fDisabled     : 1;         /* Window disabled? */
    UINT     fNonPropFont  : 1;         /* Fixed width font? */
    UINT     fNonPropDBCS  : 1;         /* Non-Propotional DBCS font */
    UINT     fBorder       : 1;         /* Draw a border? */
    UINT     fAutoVScroll  : 1;         /* Automatically scroll vertically */
    UINT     fAutoHScroll  : 1;         /* Automatically scroll horizontally */
    UINT     fNoHideSel    : 1;         /* Hide sel when we lose focus? */
    UINT     fDBCS         : 1;         /* Are we using DBCS font set for editing? */
    UINT     fFmtLines     : 1;         /* For multiline only. Do we insert CR CR LF at
                                         * word wrap breaks?
                                         */
    UINT     fWrap         : 1;         /* Do int  wrapping? */
    UINT     fCalcLines    : 1;         /* Recalc ped->chLines array? (recalc line
                                         * breaks?)
                                         */
    UINT     fEatNextChar  : 1;         /* Hack for ALT-NUMPAD stuff with combo boxes.
                                         * If numlock is up, we want to eat the next
                                         * character generated by the keyboard driver
                                         * if user enter num pad ascii value...
                                         */
    UINT     fStripCRCRLF  : 1;         /* CRCRLFs have been added to text. Strip them
                                         * before doing any internal edit control
                                         * stuff
                                         */
    UINT     fInDialogBox  : 1;         /* True if the ml edit control is in a dialog
                                         * box and we have to specially treat TABS and
                                         * ENTER
                                         */
    UINT     fReadOnly     : 1;         /* Is this a read only edit control? Only
                                         * allow scrolling, selecting and copying.
                                         */
    UINT     fCaretHidden  : 1;         /* This indicates whether the caret is
                                         * currently hidden because the width or height
                                         * of the edit control is too small to show it.
                                         */
    UINT     fTrueType     : 1;         /* Is the current font TrueType? */
    UINT     fAnsi         : 1;         /* is the edit control Ansi or unicode */
    UINT     fWin31Compat  : 1;         /* TRUE if created by Windows 3.1 app */
    UINT     f40Compat     : 1;         /* TRUE if created by Windows 4.0 app */
    UINT     fFlatBorder   : 1;         /* Do we have to draw this baby ourself? */
    UINT     fSawRButtonDown : 1;
    UINT     fInitialized  : 1;         /* If any more bits are needed, then   */
    UINT     fSwapRoOnUp   : 1;         /* Swap reading order on next keyup    */
    UINT     fAllowRTL     : 1;         /* Allow RTL processing                */
    UINT     fDisplayCtrl  : 1;         /* Display unicode control characters  */
    UINT     fRtoLReading  : 1;         /* Right to left reading order         */

    BOOL    fInsertCompChr  :1;         /* means WM_IME_COMPOSITION:CS_INSERTCHAR will come */
    BOOL    fReplaceCompChr :1;         /* means need to replace current composition str. */
    BOOL    fNoMoveCaret    :1;         /* means stick to current caret pos. */
    BOOL    fResultProcess  :1;         /* means now processing result. */
    BOOL    fKorea          :1;         /* for Korea */
    BOOL    fInReconversion :1;         /* In reconversion mode */
    BOOL    fLShift         :1;         /* L-Shift pressed with Ctrl */

    WORD    wImeStatus;                 /* current IME status */

    WORD    cbChar;                     /* count of bytes in the char size (1 or 2 if unicode) */
    LPICH   chLines;                    /* index of the start of each line */

    UINT    format;                     /* Left, center, or right justify multiline
                                         * text.
                                         */
    EDITWORDBREAKPROCA lpfnNextWord;    /* use CALLWORDBREAKPROC macro to call */

                                        /* Next word function */
    int     maxPixelWidth;              /* WASICH Width (in pixels) of longest line */

    UNDO;                               /* Undo buffer */

    HANDLE  hFont;                      /* Handle to the font for this edit control.
                                         * Null if system font.
                                         */
    int     aveCharWidth;               /* Ave width of a character in the hFont */
    int     lineHeight;                 /* Height of a line in the hFont */
    int     charOverhang;               /* Overhang associated with the hFont */
    int     cxSysCharWidth;             /* System font ave width */
    int     cySysCharHeight;            /* System font height */
    HWND    listboxHwnd;                /* ListBox hwnd. Non null if we are a combo box */
    LPINT   pTabStops;                  /* Points to an array of tab stops; First
                                         * element contains the number of elements in
                                         * the array
                                         */
    LPINT   charWidthBuffer;
    BYTE    charSet;                    /* Character set for currently selected font
                                         * needed for all versions
                                         */
    UINT    wMaxNegA;                   /* The biggest negative A width, */
    UINT    wMaxNegAcharPos;            /* and how many characters it can span accross */
    UINT    wMaxNegC;                   /* The biggest negative C width, */
    UINT    wMaxNegCcharPos;            /* and how many characters it can span accross */
    UINT    wLeftMargin;                /* Left margin width in pixels. */
    UINT    wRightMargin;               /* Right margin width in pixels. */

    ICH     ichStartMinSel;
    ICH     ichStartMaxSel;

    PLPKEDITCALLOUT pLpkEditCallout;
    HBITMAP hCaretBitmap;               /* Current caret bitmap handle */
    INT     iCaretOffset;               /* Offset in pixels (for LPK use) */

    HANDLE  hInstance;                  /* for WOW */
    UCHAR   seed;                       /* used to encode and decode password text */
    BOOLEAN fEncoded;                   /* is the text currently encoded */
    int     iLockLevel;                 /* number of times the text has been locked */

    BYTE    DBCSVector[MAX_LEADBYTES];  /* DBCS vector table */
    HIMC    hImcPrev;                   /* place to save hImc if we disable IME */
    POINT   ptScreenBounding;           /* top left corner of edit window in screen */
} ED, *PED, **PPED;

typedef struct tagEDITWND {
    WND wnd;
    PED ped;
} EDITWND, * KPTR_MODIFIER PEDITWND;

#ifdef FAREAST_CHARSET_BITS
#error FAREAST_CHARSET_BITS should not be defined
#endif
#define FAREAST_CHARSET_BITS   (FS_JISJAPAN | FS_CHINESESIMP | FS_WANSUNG | FS_CHINESETRAD)


// Language pack specific context menu IDs

#define ID_CNTX_RTL         0x00008000L
#define ID_CNTX_DISPLAYCTRL 0x00008001L
#define ID_CNTX_INSERTCTRL  0x00008013L
#define ID_CNTX_ZWJ         0x00008002L
#define ID_CNTX_ZWNJ        0x00008003L
#define ID_CNTX_LRM         0x00008004L
#define ID_CNTX_RLM         0x00008005L
#define ID_CNTX_LRE         0x00008006L
#define ID_CNTX_RLE         0x00008007L
#define ID_CNTX_LRO         0x00008008L
#define ID_CNTX_RLO         0x00008009L
#define ID_CNTX_PDF         0x0000800AL
#define ID_CNTX_NADS        0x0000800BL
#define ID_CNTX_NODS        0x0000800CL
#define ID_CNTX_ASS         0x0000800DL
#define ID_CNTX_ISS         0x0000800EL
#define ID_CNTX_AAFS        0x0000800FL
#define ID_CNTX_IAFS        0x00008010L
#define ID_CNTX_RS          0x00008011L
#define ID_CNTX_US          0x00008012L

/*
 * The following structure is used to store a selection block; In Multiline
 * edit controls, "StPos" and "EndPos" fields contain the Starting and Ending
 * lines of the block. In Single line edit controls, "StPos" and "EndPos"
 * contain the Starting and Ending character positions of the block;
 */
typedef struct tagBLOCK {
    ICH StPos;
    ICH EndPos;
}  BLOCK, *LPBLOCK;

/*  The following structure is used to store complete information about a
 *  a strip of text.
 */
typedef  struct {
    LPSTR   lpString;
    ICH     ichString;
    ICH     nCount;
    int     XStartPos;
}  STRIPINFO;
typedef  STRIPINFO FAR *LPSTRIPINFO;


/***************************************************************************\
*
* ListBox
*
\***************************************************************************/

#define IsLBoxVisible(plb)  (plb->fRedraw && IsVisible(plb->spwnd))

/*
 * Number of list box items we allocated whenever we grow the list box
 * structures.
 */
#define CITEMSALLOC     32

/* Return Values */
#define EQ        0
#define PREFIX    1
#define LT        2
#define GT        3

#define         SINGLESEL       0
#define         MULTIPLESEL     1
#define         EXTENDEDSEL     2

#define LBI_ADD     0x0004

/*
 *  The various bits of wFileDetails field are used as mentioned below:
 *      0x0001    Should the file name be in upper case.
 *      0x0002    Should the file size be shown.
 *      0x0004    Date stamp of the file to be shown ?
 *      0x0008    Time stamp of the file to be shown ?
 *      0x0010    The dos attributes of the file ?
 *      0x0020    In DlgDirSelectEx(), along with file name
 *                all other details also will be returned
 *
 */

#define LBUP_RELEASECAPTURE 0x0001
#define LBUP_RESETSELECTION 0x0002
#define LBUP_NOTIFY         0x0004
#define LBUP_SUCCESS        0x0008
#define LBUP_SELCHANGE      0x0010

/*
 * rgpch is set up as follows:  First there are cMac 2 byte pointers to the
 * start of the strings in hStrings or if ownerdraw, it is 4 bytes of data
 * supplied by the app and hStrings is not used.  Then if multiselection
 * listboxes, there are cMac 1 byte selection state bytes (one for each item
 * in the list box).  If variable height owner draw, there will be cMac 1 byte
 * height bytes (once again, one for each item in the list box.).
 *
 * CHANGES DONE BY SANKAR:
 *      The selection byte in rgpch is divided into two nibbles. The lower
 * nibble is the selection state (1 => Selected; 0 => de-selected)
 * and higher nibble is the display state(1 => Hilited and 0 => de-hilited).
 * You must be wondering why on earth we should store this selection state and
 * the display state seperately.Well! The reason is as follows:
 *      While Ctrl+Dragging or Shift+Ctrl+Dragging, the user can adjust the
 * selection before the mouse button is up. If the user enlarges a range and
 * and before the button is up if he shrinks the range, then the old selection
 * state has to be preserved for the individual items that do not fall in the
 * range finally.
 *      Please note that the display state and the selection state for an item
 * will be the same except when the user is dragging his mouse. When the mouse
 * is dragged, only the display state is updated so that the range is hilited
 * or de-hilited) but the selection state is preserved. Only when the button
 * goes up, for all the individual items in the range, the selection state is
 * made the same as the display state.
 */

typedef struct tagLBItem {
    LONG offsz;
    ULONG_PTR itemData;
} LBItem, *lpLBItem;

typedef struct tagLBODItem {
    ULONG_PTR itemData;
} LBODItem, *lpLBODItem;

void LBEvent(PLBIV, UINT, int);

/***************************************************************************\
*
* Static Controls
*
\***************************************************************************/

typedef struct tagSTAT {
    PWND spwnd;
    union {
        HANDLE hFont;
        BOOL   fDeleteIt;
    };
    HANDLE hImage;
    UINT cicur;
    UINT iicur;
    UINT fPaintKbdCuesOnly : 1;
} STAT, *PSTAT;

typedef struct tagSTATWND {
    WND wnd;
    PSTAT pstat;
} STATWND, * KPTR_MODIFIER PSTATWND;


typedef struct tagCURSORRESOURCE {
    WORD xHotspot;
    WORD yHotspot;
    BITMAPINFOHEADER bih;
} CURSORRESOURCE, *PCURSORRESOURCE;


#define NextWordBoundary(p)     ((PBYTE)(p) + ((ULONG_PTR)(p) & 1))
#define NextDWordBoundary(p)    ((PBYTE)(p) + ((ULONG_PTR)(-(LONG_PTR)(p)) & 3))

// DDEML stub prototypes

DWORD  Event(PEVENT_PACKET pep);
PVOID CsValidateInstance(HANDLE hInst);

/***************************************************************************\
* WOW Prototypes, Typedefs and Defines
*
* WOW registers resource callback functions so it can load 16 bit resources
* transparently for Win32.  At resource load time, these WOW functions are
* called.
*
\***************************************************************************/

BOOL  APIENTRY _FreeResource(HANDLE hResData, HINSTANCE hModule);
LPSTR APIENTRY _LockResource(HANDLE hResData, HINSTANCE hModule);
BOOL  APIENTRY _UnlockResource(HANDLE hResData, HINSTANCE hModule);

#define FINDRESOURCEA(hModule,lpName,lpType)         ((*(pfnFindResourceExA))(hModule, lpType, lpName, 0))
#define FINDRESOURCEW(hModule,lpName,lpType)         ((*(pfnFindResourceExW))(hModule, lpType, lpName, 0))
#define FINDRESOURCEEXA(hModule,lpName,lpType,wLang) ((*(pfnFindResourceExA))(hModule, lpType, lpName, wLang))
#define FINDRESOURCEEXW(hModule,lpName,lpType,wLang) ((*(pfnFindResourceExW))(hModule, lpType, lpName, wLang))
#define LOADRESOURCE(hModule,hResInfo)               ((*(pfnLoadResource))(hModule, hResInfo))
#define LOCKRESOURCE(hResData, hModule)              ((*(pfnLockResource))(hResData, hModule))
#define UNLOCKRESOURCE(hResData, hModule)            ((*(pfnUnlockResource))(hResData, hModule))
#define FREERESOURCE(hResData, hModule)              ((*(pfnFreeResource))(hResData, hModule))
#define SIZEOFRESOURCE(hModule,hResInfo)             ((*(pfnSizeofResource))(hModule, hResInfo))
#define GETEXPWINVER(hModule)                        ((*(pfnGetExpWinVer))((hModule)?(hModule):GetModuleHandle(NULL)))

/*
 * Pointers to unaligned-bits.  These are necessary for handling
 * bitmap-info's loaded from file.
 */
typedef BITMAPINFO       UNALIGNED *UPBITMAPINFO;
typedef BITMAPINFOHEADER UNALIGNED *UPBITMAPINFOHEADER;
typedef BITMAPCOREHEADER UNALIGNED *UPBITMAPCOREHEADER;

#define CCHFILEMAX      MAX_PATH

HLOCAL WINAPI DispatchLocalAlloc(
    UINT uFlags,
    UINT uBytes,
    HANDLE hInstance);

HLOCAL WINAPI DispatchLocalReAlloc(
    HLOCAL hMem,
    UINT uBytes,
    UINT uFlags,
    HANDLE hInstance,
    PVOID* ppv);

LPVOID WINAPI DispatchLocalLock(
    HLOCAL hMem,
    HANDLE hInstance);

BOOL WINAPI DispatchLocalUnlock(
    HLOCAL hMem,
    HANDLE hInstance);

UINT WINAPI DispatchLocalSize(
    HLOCAL hMem,
    HANDLE hInstance);

HLOCAL WINAPI DispatchLocalFree(
    HLOCAL hMem,
    HANDLE hInstance);

#define UserLocalAlloc(uFlag,uBytes) RtlAllocateHeap(pUserHeap, uFlag, uBytes)
#define UserLocalReAlloc(p, uBytes, uFlags) RtlReAllocateHeap(pUserHeap, uFlags, p, uBytes)
#define UserLocalFree(p)    RtlFreeHeap(pUserHeap, 0, (LPSTR)(p))
#define UserLocalSize(p)    RtlSizeHeap(pUserHeap, 0, (LPSTR)(p))

LONG TabTextOut(HDC hdc, int x, int y, LPCWSTR lpstring, int nCount,
        int nTabPositions, CONST INT *lpTabPositions, int iTabOrigin,
        BOOL fDrawTheText, int iCharset);
LONG UserLpkTabbedTextOut(HDC hdc, int x, int y, LPCWSTR lpstring,
        int nCount, int nTabPositions, CONST INT *lpTabPositions,
        int iTabOrigin, BOOL fDrawTheText, int cxCharWidth,
        int cyCharHeight, int iCharset);
void UserLpkPSMTextOut(HDC hdc, int xLeft, int yTop,
        LPWSTR lpsz, int cch, DWORD dwFlags);
void PSMTextOut(HDC hdc, int xLeft, int yTop, LPWSTR lpsz, int cch, DWORD dwFlags);
void ECUpdateFormat(PED ped, DWORD dwStyle, DWORD dwExStyle);

int  LoadStringOrError(HANDLE, UINT, LPTSTR, int, WORD);
int  RtlGetIdFromDirectory(PBYTE, BOOL, int, int, DWORD, PDWORD);
BOOL RtlCaptureAnsiString(PIN_STRING, LPCSTR, BOOL);
BOOL RtlCaptureLargeAnsiString(PLARGE_IN_STRING, LPCSTR, BOOL);
LONG BroadcastSystemMessageWorker(
    DWORD dwFlags,
    LPDWORD lpdwRecipients,
    UINT uiMessage,
    WPARAM wParam,
    LPARAM lParam,
    PBSMINFO pBSMInfo,
    BOOL fAnsi);

PWND FASTCALL ValidateHwnd(HWND hwnd);
PWND FASTCALL ValidateHwndNoRip(HWND hwnd);

PSTR ECLock(PED ped);
void ECUnlock(PED ped);
BOOL ECNcCreate(PED, PWND, LPCREATESTRUCT);
void ECInvalidateClient(PED ped, BOOL fErase);
BOOL ECCreate(PED ped, LONG windowStyle);
void ECWord(PED, ICH, BOOL, ICH*, ICH*);
ICH  ECFindTab(LPSTR, ICH);
void ECNcDestroyHandler(PWND, PED);
BOOL ECSetText(PED, LPSTR);
void ECSetPasswordChar(PED, UINT);
ICH  ECCchInWidth(PED, HDC, LPSTR, ICH, int, BOOL);
void ECEmptyUndo(PUNDO);
void ECSaveUndo(PUNDO pundoFrom, PUNDO pundoTo, BOOL fClear);
BOOL ECInsertText(PED, LPSTR, ICH*);
ICH  ECDeleteText(PED);
void ECResetTextInfo(PED ped);
void ECNotifyParent(PED, int);
void ECSetEditClip(PED, HDC, BOOL);
HDC  ECGetEditDC(PED, BOOL);
void ECReleaseEditDC(PED, HDC, BOOL);
ICH  ECGetText(PED, ICH, LPSTR, BOOL);
void ECSetFont(PED, HFONT, BOOL);
void ECSetMargin(PED, UINT, long, BOOL);
ICH  ECCopy(PED);
BOOL ECCalcChangeSelection(PED, ICH, ICH, LPBLOCK, LPBLOCK);
void ECFindXORblks(LPBLOCK, LPBLOCK, LPBLOCK, LPBLOCK);
BOOL ECIsCharNumeric(PED ped, DWORD keyPress);

/*
 * Combine two DBCS WM_CHAR messages to
 * a single WORD value.
 */
WORD DbcsCombine(HWND, WORD);
#define CrackCombinedDbcsLB(c)  ((BYTE)(c))
#define CrackCombinedDbcsTB(c)  ((c) >> 8)

ICH  ECAdjustIch(PED, LPSTR, ICH);
ICH  ECAdjustIchNext(PED, LPSTR, ICH);
int  ECGetDBCSVector(PED, HDC, BYTE);
BOOL ECIsDBCSLeadByte(PED, BYTE);
LPSTR ECAnsiNext(PED, LPSTR);
LPSTR ECAnsiPrev(PED, LPSTR, LPSTR);
ICH  ECPrevIch(PED, LPSTR, ICH);
ICH  ECNextIch(PED, LPSTR, ICH);

void ECEnableDisableIME( PED ped );
void ECImmSetCompositionFont( PED ped );
void ECImmSetCompositionWindow( PED ped, LONG, LONG );
void  ECSetCaretHandler(PED ped);
void  ECInitInsert(PED ped, HKL hkl);
LRESULT ECImeComposition(PED ped, WPARAM wParam, LPARAM lParam);
LRESULT EcImeRequestHandler(PED, WPARAM, LPARAM);  // NT 5.0
BOOL HanjaKeyHandler(PED ped);  // Korean Support

void ECInOutReconversionMode(PED ped, BOOL fIn);


// ECTabTheTextOut draw codes
#define ECT_CALC        0
#define ECT_NORMAL      1
#define ECT_SELECTED    2

#define ECGetCaretWidth() (gpsi->uCaretWidth)

UINT ECTabTheTextOut(HDC, int, int, int, int,
                     LPSTR, int, ICH, PED, int, BOOL, LPSTRIPINFO);
HBRUSH ECGetControlBrush(PED, HDC, LONG);
HBRUSH ECGetBrush(PED ped, HDC hdc);
int  ECGetModKeys(int);
VOID ECSize(PED, LPRECT, BOOL);

ICH  MLInsertText(PED, LPSTR, ICH, BOOL);
ICH  MLDeleteText(PED);
BOOL MLEnsureCaretVisible(PED);
VOID MLDrawText(PED, HDC, ICH, ICH, BOOL);
VOID MLBuildchLines(PED, ICH, int, BOOL, PLONG, PLONG);
VOID MLShiftchLines(PED, ICH, int);
VOID MLSetCaretPosition(PED,HDC);
VOID MLIchToXYPos(PED, HDC, ICH, BOOL, LPPOINT);
int  MLIchToLine(PED, ICH);
VOID MLMouseMotion(PED, UINT, UINT, LPPOINT);
ICH  MLLine(PED, ICH);
VOID MLStripCrCrLf(PED);
BOOL MLUndo(PED);
LRESULT MLEditWndProc(HWND, PED, UINT, WPARAM, LPARAM);
VOID MLChar(PED, DWORD, int);
VOID MLSetSelection(PED, BOOL, ICH, ICH);
LONG MLCreate(PED, LPCREATESTRUCT);
BOOL MLInsertCrCrLf(PED);
VOID MLSetHandle(PED, HANDLE);
LONG MLGetLine(PED, ICH, ICH, LPSTR);
ICH  MLLineIndex(PED, ICH);
VOID MLSize(PED, BOOL);
VOID MLChangeSelection(PED, HDC, ICH, ICH);
BOOL MLSetTabStops(PED, int, LPINT);
LONG MLScroll(PED, BOOL, int, int, BOOL);
VOID MLUpdateiCaretLine(PED ped);
ICH  MLLineLength(PED, ICH);
VOID MLReplaceSel(PED, LPSTR);

VOID SLReplaceSel(PED, LPSTR);
BOOL SLUndo(PED);
VOID SLSetCaretPosition(PED, HDC);
int  SLIchToLeftXPos(PED, HDC, ICH);
VOID SLChangeSelection(PED, HDC, ICH, ICH);
VOID SLDrawLine(PED, HDC, int, int, ICH, int, BOOL);
VOID SLDrawText(PED, HDC, ICH);
BOOL SLScrollText(PED, HDC);
VOID SLSetSelection(PED,ICH, ICH);
ICH  SLInsertText(PED, LPSTR, ICH);
VOID SLChar(PED, DWORD);
LONG SLCreate(PED, LPCREATESTRUCT);
LRESULT SLEditWndProc(HWND, PED, UINT, WPARAM, LPARAM);
LRESULT EditWndProc(PWND, UINT, WPARAM, LPARAM);

#define GETAPPVER() GetClientInfo()->dwExpWinVer
#define THREAD_HKL()      (KHKL_TO_HKL(GetClientInfo()->hKL))
#define GETCLIENTTHREADINFO()   (CLIENTTHREADINFO *)KPVOID_TO_PVOID(GetClientInfo()->pClientThreadInfo)
#define CLIENTTHREADINFO(pci)   (CLIENTTHREADINFO *)KPVOID_TO_PVOID((pci)->pClientThreadInfo)


#define ISDELIMETERA(ch) ((ch == ' ') || (ch == '\t'))
#define ISDELIMETERW(ch) ((ch == L' ') || (ch == L'\t'))

#define AWCOMPARECHAR(ped,pbyte,awchar) (ped->fAnsi ? (*(PUCHAR)(pbyte) == (UCHAR)(awchar)) : (*(LPWSTR)(pbyte) == (WCHAR)(awchar)))

/* Menu that comes up when you press the right mouse button on an edit
 * control
 */
#define ID_EC_PROPERTY_MENU      1

#define IDD_MDI_ACTIVATE         9

#ifndef _USERK_
/*
 * String IDs
 */
#define STR_ERROR                        0x00000002L
#define STR_MOREWINDOWS                  0x0000000DL
#define STR_NOMEMBITMAP                  0x0000000EL

/*
 * IME specific context menu string
 */
#define STR_IMEOPEN                 700
#define STR_IMECLOSE                701
#define STR_SOFTKBDOPEN             702
#define STR_SOFTKBDCLOSE            703
#define STR_RECONVERTSTRING         705

/*
 * Shutdown logging strings.
 */
#define STR_SHUTDOWN_SHUTDOWN       706
#define STR_SHUTDOWN_POWEROFF       707
#define STR_SHUTDOWN_REBOOT         708

/*
 * Misc. strings.
 */
#define STR_UNKNOWN                 709

/*
 * ExitWindowsEx warning dlg strings
 */
#define IDS_EXITWINDOWS_TITLE           710
#define IDS_SHUTDOWN_REMOTE             711
#define IDS_SHUTDOWN_REMOTE_OTHERUSERS  712
#define IDS_SHUTDOWN_OTHERUSERS         713
#define IDS_RESTART_OTHERUSERS          714

#endif  // !_USERK_


BOOL InitClientDrawing();

/***************************************************************************\
* Function Prototypes
*
* NOTE: Only prototypes for GLOBAL (across module) functions should be put
* here.  Prototypes for functions that are global to a single module should
* be put at the head of that module.
*
\***************************************************************************/

int InternalScrollWindowEx(HWND hwnd, int dx, int dy, CONST RECT *prcScroll,
        CONST RECT *prcClip, HRGN hrgnUpdate, LPRECT prcUpdate,
        UINT dwFlags, DWORD dwTime);

BOOL IsMetaFile(HDC hdc);

BOOL DrawDiagonal(HDC hdc, LPRECT lprc, HBRUSH hbrTL, HBRUSH hbrBR, UINT flags);
BOOL FillTriangle(HDC hdc, LPRECT lprc, HBRUSH hbr, UINT flags);

BOOL   _ClientFreeLibrary(HANDLE hmod);
DWORD  _ClientGetListboxString(PWND pwnd, UINT msg, WPARAM wParam, LPSTR lParam,
        ULONG_PTR xParam, PROC xpfn);
LPHLP  HFill(LPCSTR lpszHelp, DWORD ulCommand, ULONG_PTR ulData);
BOOL SetVideoTimeout(DWORD dwVideoTimeout);

DWORD _GetWindowLong(PWND pwnd, int index, BOOL bAnsi);
#ifdef _WIN64
ULONG_PTR _GetWindowLongPtr(PWND pwnd, int index, BOOL bAnsi);
#else
#define _GetWindowLongPtr   _GetWindowLong
#endif
WORD  _GetWindowWord(PWND pwnd, int index);

HWND InternalFindWindowExA(HWND hwndParent, HWND hwndChild, LPCSTR pClassName,
                          LPCSTR pWindowName, DWORD   dwFlag);
HWND InternalFindWindowExW(HWND hwndParent, HWND hwndChild, LPCTSTR pClassName,
                          LPCTSTR pWindowName, DWORD   dwFlag);


/*
 * Message thunks.
 */
#define fnCOPYDATA                      NtUserMessageCall
#define fnDDEINIT                       NtUserMessageCall
#define fnDWORD                         NtUserMessageCall
#define fnNCDESTROY                     NtUserMessageCall
#define fnDWORDOPTINLPMSG               NtUserMessageCall
#define fnGETTEXTLENGTHS                NtUserMessageCall
#define fnGETDBCSTEXTLENGTHS            NtUserMessageCall
#define fnINLPCREATESTRUCT              NtUserMessageCall
#define fnINLPCOMPAREITEMSTRUCT         NtUserMessageCall
#define fnINLPDELETEITEMSTRUCT          NtUserMessageCall
#define fnINLPDRAWITEMSTRUCT            NtUserMessageCall
#define fnINLPHELPINFOSTRUCT            NtUserMessageCall
#define fnINLPHLPSTRUCT                 NtUserMessageCall
#define fnINLPWINDOWPOS                 NtUserMessageCall
#define fnINOUTDRAG                     NtUserMessageCall
#define fnINOUTLPMEASUREITEMSTRUCT      NtUserMessageCall
#define fnINOUTLPPOINT5                 NtUserMessageCall
#define fnINOUTLPRECT                   NtUserMessageCall
#define fnINOUTLPSCROLLINFO             NtUserMessageCall
#define fnINOUTLPWINDOWPOS              NtUserMessageCall
#define fnINOUTNCCALCSIZE               NtUserMessageCall
#define fnINOUTNEXTMENU                 NtUserMessageCall
#define fnINOUTSTYLECHANGE              NtUserMessageCall
#define fnOPTOUTLPDWORDOPTOUTLPDWORD    NtUserMessageCall
#define fnOUTLPRECT                     NtUserMessageCall
#define fnPOPTINLPUINT                  NtUserMessageCall
#define fnPOUTLPINT                     NtUserMessageCall
#define fnSENTDDEMSG                    NtUserMessageCall
#define fnOUTDWORDINDWORD               NtUserMessageCall
#define fnINOUTMENUGETOBJECT            NtUserMessageCall
#define fnINCBOXSTRING                  NtUserMessageCall
#define fnINCNTOUTSTRING                NtUserMessageCall
#define fnINCNTOUTSTRINGNULL            NtUserMessageCall
#define fnINLBOXSTRING                  NtUserMessageCall
#define fnINLPMDICREATESTRUCT           NtUserMessageCall
#define fnINSTRING                      NtUserMessageCall
#define fnINSTRINGNULL                  NtUserMessageCall
#define fnINWPARAMCHAR                  NtUserMessageCall
#define fnOUTCBOXSTRING                 NtUserMessageCall
#define fnOUTLBOXSTRING                 NtUserMessageCall
#define fnOUTSTRING                     NtUserMessageCall
#define fnKERNELONLY                    NtUserMessageCall
#define fnOUTLPCOMBOBOXINFO             NtUserMessageCall
#define fnOUTLPSCROLLBARINFO            NtUserMessageCall


#define MESSAGEPROTO(func) \
LRESULT CALLBACK fn ## func(                               \
        HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam, \
        ULONG_PTR xParam, DWORD xpfnWndProc, BOOL bAnsi)

MESSAGEPROTO(COPYGLOBALDATA);
MESSAGEPROTO(INDEVICECHANGE);
MESSAGEPROTO(INPAINTCLIPBRD);
MESSAGEPROTO(INSIZECLIPBRD);
MESSAGEPROTO(IMECONTROL);
MESSAGEPROTO(IMEREQUEST);
MESSAGEPROTO(INWPARAMDBCSCHAR);
MESSAGEPROTO(EMGETSEL);
MESSAGEPROTO(EMSETSEL);
MESSAGEPROTO(CBGETEDITSEL);


/*
 * clhook.c
 */
#define IsHooked(pci, fsHook) \
    ((fsHook & (pci->fsHooks | pci->pDeskInfo->fsHooks)) != 0)

LRESULT fnHkINLPCWPSTRUCTW(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, ULONG_PTR xParam);
LRESULT fnHkINLPCWPSTRUCTA(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, ULONG_PTR xParam);
LRESULT fnHkINLPCWPRETSTRUCTW(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, ULONG_PTR xParam);
LRESULT fnHkINLPCWPRETSTRUCTA(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, ULONG_PTR xParam);
LRESULT DispatchHookW(int dw, WPARAM wParam, LPARAM lParam, HOOKPROC pfn);
LRESULT DispatchHookA(int dw, WPARAM wParam, LPARAM lParam, HOOKPROC pfn);

/*
 * client.c
 */
LRESULT APIENTRY ButtonWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ButtonWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY MenuWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY MenuWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY DesktopWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY DesktopWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ScrollBarWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ScrollBarWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ListBoxWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ListBoxWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY StaticWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY StaticWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ComboBoxWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ComboBoxWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ComboListBoxWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ComboListBoxWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY MDIClientWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY MDIClientWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
INT_PTR APIENTRY MB_DlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
INT_PTR APIENTRY MDIActivateDlgProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
INT_PTR APIENTRY MDIActivateDlgProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY EditWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY EditWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ImeWndProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY ImeWndProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
#ifdef MESSAGE_PUMP_HOOK
DWORD APIENTRY RealGetQueueStatus(UINT flags);
DWORD WINAPI RealMsgWaitForMultipleObjectsEx(DWORD nCount, CONST HANDLE *pHandles,
        DWORD dwMilliseconds, DWORD dwWakeMask, DWORD dwFlags);
#endif
LRESULT APIENTRY RealDefWindowProcA(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY RealDefWindowProcW(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT APIENTRY DispatchDefWindowProcA(PWND pwnd, UINT msg, WPARAM wParam, LPARAM lParam, ULONG_PTR pfn);
LRESULT APIENTRY DispatchDefWindowProcW(PWND pwnd, UINT msg, WPARAM wParam, LPARAM lParam, ULONG_PTR pfn);
BOOL    InitUserApiHook(HMODULE hmod, ULONG_PTR offPfnInitUserApiHook);
BOOL    ClearUserApiHook(HMODULE hmod);
BOOL    CALLBACK DefaultOWP(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, LRESULT * pr, void ** pvCookie);
void    ResetUserApiHook(USERAPIHOOK * puah);
LRESULT SendMessageWorker(PWND pwnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL fAnsi);
LRESULT SendMessageTimeoutWorker(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam,
            UINT fuFlags, UINT uTimeout, PULONG_PTR lpdwResult, BOOL fAnsi);

void ClientEmptyClipboard(void);
VOID GetActiveKeyboardName(LPWSTR lpszName);
HANDLE OpenKeyboardLayoutFile(LPWSTR lpszKLName, LANGID langid,
                              PUINT puFlags, PUINT poffTable, PUINT pKbdInputLocale,
                              OUT OPTIONAL PKBDTABLE_MULTI_INTERNAL pKbdTableMulti);
VOID LoadPreloadKeyboardLayouts(void);
void SetWindowState(PWND pwnd, UINT flags);
void ClearWindowState(PWND pwnd, UINT flags);

HKL LoadKeyboardLayoutWorker(HKL hkl, LPCWSTR lpszKLName, LANGID langid, UINT uFlags, BOOL fFailSafe);
BOOL GetRemoteKeyboardLayout(PWCHAR pwszKLName, LANGID* pLangId);


/*
 * Worker routines called from both the window procs and
 * the callback thunks.
 */
LRESULT DispatchClientMessage(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, ULONG_PTR pfn);
LRESULT DefWindowProcWorker(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT RealDefWindowProcWorker(PWND pwnd, UINT message, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT ButtonWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT ListBoxWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT StaticWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT ComboBoxWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT ComboListBoxWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT MDIClientWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT EditWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT DefDlgProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);
LRESULT ImeWndProcWorker(PWND pwnd, UINT msg, WPARAM wParam,
        LPARAM lParam, DWORD fAnsi);

/*
 * Server Stubs - ntstubs.c
 */

LONG _SetWindowLong(
    HWND hWnd,
    int nIndex,
    LONG dwNewLong,
    BOOL bAnsi);

#ifdef _WIN64
LONG_PTR _SetWindowLongPtr(
    HWND hWnd,
    int nIndex,
    LONG_PTR dwNewLong,
    BOOL bAnsi);
#else
#define _SetWindowLongPtr   _SetWindowLong
#endif

BOOL _PeekMessage(
    LPMSG pmsg,
    HWND hwnd,
    UINT wMsgFilterMin,
    UINT wMsgFilterMax,
    UINT wRemoveMsg,
    BOOL bAnsi);

BOOL _DefSetText(
    HWND hwnd,
    LPCWSTR pstr,
    BOOL bAnsi);

HCURSOR _GetCursorFrameInfo(
    HCURSOR hcur,
    LPWSTR id,
    int iFrame,
    LPDWORD pjifRate,
    LPINT pccur);

HWND _CreateWindowEx(
    DWORD dwExStyle,
    LPCTSTR pClassName,
    LPCTSTR pWindowName,
    DWORD dwStyle,
    int x,
    int y,
    int nWidth,
    int nHeight,
    HWND hwndParent,
    HMENU hmenu,
    HANDLE hModule,
    LPVOID pParam,
    DWORD dwFlags);

HWND VerNtUserCreateWindowEx(
    IN DWORD dwExStyle,
    IN PLARGE_STRING pstrClassName,
    IN PLARGE_STRING pstrWindowName OPTIONAL,
    IN DWORD dwStyle,
    IN int x,
    IN int y,
    IN int nWidth,
    IN int nHeight,
    IN HWND hwndParent,
    IN HMENU hmenu,
    IN HANDLE hModule,
    IN LPVOID pParam,
    IN DWORD dwFlags);

HKL _LoadKeyboardLayoutEx(
    HANDLE hFile,
    UINT offTable,
    PKBDTABLE_MULTI_INTERNAL pKbdTableMulti,
    HKL hkl,
    LPCWSTR pwszKL,
    UINT KbdInputLocale,
    UINT Flags);

BOOL _SetCursorIconData(
    HCURSOR hCursor,
    PCURSORDATA pcur);

HCURSOR FindExistingCursorIcon(
    LPWSTR      pszModName,
    LPCWSTR     pszResName,
    PCURSORFIND pcfSearch);

HANDLE CreateLocalMemHandle(
    HANDLE hMem);

HANDLE ConvertMemHandle(
    HANDLE hMem,
    UINT cbNULL);

HHOOK _SetWindowsHookEx(
    HANDLE hmod,
    LPTSTR pszLib,
    DWORD idThread,
    int nFilterType,
    PROC pfnFilterProc,
    DWORD dwFlags);

#if 0
DWORD WINAPI ImmGetReconvertTotalSize(
    DWORD dwSize,
    REQ_CALLER eCaller,
    BOOL bAnsiTarget);

DWORD WINAPI ImmReconversionWorker(
    LPRECONVERTSTRING lpRecTo,
    LPRECONVERTSTRING lpRecFrom,
    BOOL bToAnsi,
    DWORD dwCodePage);
#endif

/*
 * classc.c
 */
ULONG_PTR _GetClassData(
    PCLS pcls,
    PWND pwnd,
    int index,
    BOOL bAnsi);

DWORD _GetClassLong(
    PWND pwnd,
    int index,
    BOOL bAnsi);

#ifdef _WIN64
ULONG_PTR _GetClassLongPtr(
    PWND pwnd,
    int index,
    BOOL bAnsi);
#else
#define _GetClassLongPtr    _GetClassLong
#endif

/*
 * mngrayc.c
 */
BOOL BitBltSysBmp(
    HDC hdc,
    int x,
    int y,
    UINT i);


/*
 * clenum.c
 */
DWORD BuildHwndList(
    HDESK hdesk,
    HWND hwndNext,
    BOOL fEnumChildren,
    DWORD idThread,
    HWND **phwndFirst);

/*
 * cltxt.h
 */
ATOM RegisterClassExWOWA(
    PWNDCLASSEXA lpWndClass,
    LPDWORD pdwWOWstuff,
    WORD fnid,
    DWORD dwFlags);

ATOM RegisterClassExWOWW(
    PWNDCLASSEXW lpWndClass,
    LPDWORD pdwWOWstuff,
    WORD fnid,
    DWORD dwFlags);

void CopyLogFontAtoW(
    PLOGFONTW pdest,
    PLOGFONTA psrc);

void CopyLogFontWtoA(
    PLOGFONTA pdest,
    PLOGFONTW psrc);

/*
 * dlgmgrc.c
 */
PWND _NextControl(
    PWND pwndDlg,
    PWND pwnd,
    UINT uFlags);

PWND _PrevControl(
    PWND pwndDlg,
    PWND pwnd,
    UINT uFlags);

PWND _GetNextDlgGroupItem(
    PWND pwndDlg,
    PWND pwnd,
    BOOL fPrev);

PWND _GetNextDlgTabItem(
    PWND pwndDlg,
    PWND pwnd,
    BOOL fPrev);

PWND _GetChildControl(
    PWND pwndDlg,
    PWND pwndLevel);

/*
 * winmgrc.c
 */
BOOL FChildVisible(
    HWND hwnd);

/*
 * draw.c
 */
BOOL PaintRect(
    HWND hwndBrush,
    HWND hwndPaint,
    HDC hdc,
    HBRUSH hbr,
    LPRECT lprc);

#define NtUserReleaseDC(hwnd,hdc)  NtUserCallOneParam((ULONG_PTR)(hdc), SFI__RELEASEDC)
#define NtUserArrangeIconicWindows(hwnd)  (UINT)NtUserCallHwndLock((hwnd), SFI_XXXARRANGEICONICWINDOWS)
#define NtUserBeginDeferWindowPos(nNumWindows) (HANDLE)NtUserCallOneParam((nNumWindows),SFI__BEGINDEFERWINDOWPOS)
#define NtUserCreateMenu()   (HMENU)NtUserCallNoParam(SFI__CREATEMENU)
#define NtUserDestroyCaret() (BOOL)NtUserCallNoParam(SFI_ZZZDESTROYCARET)
#define NtUserEnableWindow(hwnd, bEnable) (BOOL)NtUserCallHwndParamLock((hwnd), (bEnable),SFI_XXXENABLEWINDOW)
#define NtUserGetMessagePos() (DWORD)NtUserCallNoParam(SFI__GETMESSAGEPOS)
#define NtUserKillSystemTimer(hwnd,nIDEvent)  (BOOL)NtUserCallHwndParam((hwnd), (nIDEvent), SFI__KILLSYSTEMTIMER)
#define NtUserMessageBeep(wType)  (BOOL)NtUserCallOneParam((wType), SFI_XXXMESSAGEBEEP)
#define NtUserSetWindowContextHelpId(hwnd,id) (BOOL)NtUserCallHwndParam((hwnd), (id), SFI__SETWINDOWCONTEXTHELPID)
#define NtUserGetWindowContextHelpId(hwnd)   (BOOL)NtUserCallHwnd((hwnd), SFI__GETWINDOWCONTEXTHELPID)
#define NtUserRedrawFrame(hwnd)   NtUserCallHwndLock((hwnd), SFI_XXXREDRAWFRAME)
#define NtUserRedrawFrameAndHook(hwnd)  NtUserCallHwndLock((hwnd), SFI_XXXREDRAWFRAMEANDHOOK)
#define NtUserRedrawTitle(hwnd, wFlags)  NtUserCallHwndParamLock((hwnd), (wFlags), SFI_XXXREDRAWTITLE)
#define NtUserReleaseCapture()  (BOOL)NtUserCallNoParam(SFI_XXXRELEASECAPTURE)
#define NtUserSetCaretPos(X,Y)  (BOOL)NtUserCallTwoParam((DWORD)(X), (DWORD)(Y), SFI_ZZZSETCARETPOS)
#define NtUserSetCursorPos(X, Y)  (BOOL)NtUserCallTwoParam((X), (Y), SFI_ZZZSETCURSORPOS)
#define NtUserSetForegroundWindow(hwnd)  (BOOL)NtUserCallHwndLock((hwnd), SFI_XXXSTUBSETFOREGROUNDWINDOW)
#define NtUserSetSysMenu(hwnd)  NtUserCallHwndLock((hwnd), SFI_XXXSETSYSMENU)
#define NtUserSetVisible(hwnd,fSet)  NtUserCallHwndParam((hwnd), (fSet), SFI_SETVISIBLE)
#define NtUserShowCursor(bShow)   (int)NtUserCallOneParam((bShow), SFI_ZZZSHOWCURSOR)
#define NtUserUpdateClientRect(hwnd) NtUserCallHwndLock((hwnd), SFI_XXXUPDATECLIENTRECT)

#define CreateCaret         NtUserCreateCaret
#define FillWindow          NtUserFillWindow
#define GetControlBrush     NtUserGetControlBrush
#define GetControlColor     NtUserGetControlColor
#define GetDCEx             NtUserGetDCEx
#define GetWindowPlacement  NtUserGetWindowPlacement
#define RedrawWindow        NtUserRedrawWindow


/*
 * dmmnem.c
 */
int FindMnemChar(
    LPWSTR lpstr,
    WCHAR ch,
    BOOL fFirst,
    BOOL fPrefix);

/*
 * clres.c
 */
BOOL WowGetModuleFileName(
    HMODULE hModule,
    LPWSTR pwsz,
    DWORD  cchMax);

HICON WowServerLoadCreateCursorIcon(
    HANDLE hmod,
    LPTSTR lpModName,
    DWORD dwExpWinVer,
    LPCTSTR lpName,
    DWORD cb,
    PVOID pcr,
    LPTSTR lpType,
    BOOL fClient);

HANDLE InternalCopyImage(
    HANDLE hImage,
    UINT IMAGE_flag,
    int cxNew,
    int cyNew,
    UINT LR_flags);

HMENU CreateMenuFromResource(
    LPBYTE);

/*
 * acons.c
 */
#define BFT_ICON    0x4349  //  'IC'
#define BFT_BITMAP  0x4D42  //  'BM'
#define BFT_CURSOR  0x5450  //  'PT'

typedef struct _FILEINFO {
    LPBYTE  pFileMap;
    LPBYTE  pFilePtr;
    LPBYTE  pFileEnd;
    LPCWSTR pszName;
} FILEINFO, *PFILEINFO;

HANDLE LoadCursorIconFromFileMap(
    IN PFILEINFO   pfi,
    IN OUT LPWSTR *prt,
    IN DWORD       cxDesired,
    IN DWORD       cyDesired,
    IN DWORD       LR_flags,
    OUT LPBOOL     pfAni);

DWORD GetIcoCurWidth(
    DWORD cxOrg,
    BOOL  fIcon,
    UINT  LR_flags,
    DWORD cxDesired);

DWORD GetIcoCurHeight(
    DWORD cyOrg,
    BOOL  fIcon,
    UINT  LR_flags,
    DWORD cyDesired);

DWORD GetIcoCurBpp(
    UINT LR_flags);

HICON LoadIcoCur(
    HINSTANCE hmod,
    LPCWSTR   lpName,
    LPWSTR    type,
    DWORD     cxDesired,
    DWORD     cyDesired,
    UINT      LR_flags);

HANDLE ObjectFromDIBResource(
    HINSTANCE hmod,
    LPCWSTR   lpName,
    LPWSTR    type,
    DWORD     cxDesired,
    DWORD     cyDesired,
    UINT      LR_flags);

HANDLE RtlLoadObjectFromDIBFile(
    LPCWSTR lpszName,
    LPWSTR  type,
    DWORD   cxDesired,
    DWORD   cyDesired,
    UINT    LR_flags);

HCURSOR LoadCursorOrIconFromFile(
    LPCWSTR pszFilename,
    BOOL    fIcon);

HBITMAP ConvertDIBBitmap(
    UPBITMAPINFOHEADER lpbih,
    DWORD              cxDesired,
    DWORD              cyDesired,
    UINT               flags,
    LPBITMAPINFOHEADER *lplpbih,
    LPSTR              *lplpBits);

HICON ConvertDIBIcon(
    LPBITMAPINFOHEADER lpbih,
    HINSTANCE          hmod,
    LPCWSTR            lpName,
    BOOL               fIcon,
    DWORD              cxNew,
    DWORD              cyNew,
    UINT               LR_flags);

int SmartStretchDIBits(
    HDC          hdc,
    int          xD,
    int          yD,
    int          dxD,
    int          dyD,
    int          xS,
    int          yS,
    int          dxS,
    int          dyS,
    LPVOID       lpBits,
    LPBITMAPINFO lpbi,
    UINT         wUsage,
    DWORD        rop);


/*
 * OFFSET for different DPI resources.
 * This allows us to take a resource number and "map" to an actual resource
 * based on what DPI the user selected
 */

#define OFFSET_SCALE_DPI 000
#define OFFSET_96_DPI    100
#define OFFSET_120_DPI   200
#define OFFSET_160_DPI   300

/*
 * defines the highest resource number so we can do math on the resource
 * number.
 */

#define MAX_RESOURCE_INDEX 32768


/*
 * Parameter for xxxAlterHilite()
 */
#define HILITEONLY      0x0001
#define SELONLY         0x0002
#define HILITEANDSEL    (HILITEONLY + SELONLY)

#define HILITE     1

// LATER IanJa: these vary by country!  For US they are VK_OEM_2 VK_OEM_5.
//       Change lboxctl2.c MapVirtualKey to character - and fix the spelling?
#define VERKEY_SLASH     0xBF   /* Virtual key for '/' character */
#define VERKEY_BACKSLASH 0xDC   /* Virtual key for '\' character */

/*
 * Procedures for combo boxes.
 */
LONG  xxxCBCommandHandler(PCBOX, DWORD, HWND);
LRESULT xxxCBMessageItemHandler(PCBOX, UINT, LPVOID);
int   xxxCBDir(PCBOX, UINT, LPWSTR);
VOID  xxxCBPaint(PCBOX, HDC);
VOID  xxxCBCompleteEditWindow(PCBOX pcbox);
BOOL  xxxCBHideListBoxWindow(PCBOX pcbox, BOOL fNotifyParent, BOOL fSelEndOK);
VOID  xxxCBShowListBoxWindow(PCBOX pcbox, BOOL fTrack);
void xxxCBPosition(PCBOX pcbox);

/*
 * combo.h
 */

/* Initialization code */
long  CBNcCreateHandler(PCBOX, PWND);
LRESULT xxxCBCreateHandler(PCBOX, PWND);
void xxxCBCalcControlRects(PCBOX pcbox, LPRECT lprcList);

/* Destruction code */
VOID  xxxCBNcDestroyHandler(PWND, PCBOX);

/* Generic often used routines */
VOID  xxxCBNotifyParent(PCBOX, SHORT);
VOID  xxxCBUpdateListBoxWindow(PCBOX, BOOL);


/* Helpers' */
VOID  xxxCBInternalUpdateEditWindow(PCBOX, HDC);
VOID  xxxCBGetFocusHelper(PCBOX);
VOID  xxxCBKillFocusHelper(PCBOX);
VOID  xxxCBInvertStaticWindow(PCBOX,BOOL,HDC);
VOID  xxxCBSetFontHandler(PCBOX, HANDLE, BOOL);
VOID  xxxCBSizeHandler(PCBOX);
LONG  xxxCBSetEditItemHeight(PCBOX pcbox, int editHeight);


/*
 * String
 */

INT xxxFindString(PLBIV, LPWSTR, INT, INT, BOOL);

VOID  InitHStrings(PLBIV);

int   xxxLBInsertItem(PLBIV, LPWSTR, int, UINT);

/*
 * Selection
 */
BOOL  ISelFromPt(PLBIV, POINT, LPDWORD);
BOOL  IsSelected(PLBIV, INT, UINT);
VOID LBSetCItemFullMax(PLBIV plb);

VOID  xxxLBSelRange(PLBIV, INT, INT, BOOL);

INT xxxLBSetCurSel(PLBIV, INT);

INT LBoxGetSelItems(PLBIV, BOOL, INT, LPINT);

LONG  xxxLBSetSel(PLBIV, BOOL, INT);

VOID  xxxSetISelBase(PLBIV, INT);

VOID  SetSelected(PLBIV, INT, BOOL, UINT);


/*
 * Caret
 */
void xxxLBSetCaret(PLBIV plb, BOOL fSetCaret);
VOID  xxxCaretDestroy(PLBIV);

/*
 * LBox
 */
LONG  xxxLBCreate(PLBIV, PWND, LPCREATESTRUCT);
VOID  xxxDestroyLBox(PLBIV, PWND);
VOID  xxxLBoxDeleteItem(PLBIV, INT);

VOID  xxxLBoxDoDeleteItems(PLBIV);
VOID  xxxLBoxDrawItem(PLBIV, INT, UINT, UINT, LPRECT);


/*
 * Scroll
 */
INT   LBCalcVarITopScrollAmt(PLBIV, INT, INT);

VOID  xxxLBoxCtlHScroll(PLBIV, INT, INT);

VOID  xxxLBoxCtlHScrollMultiColumn(PLBIV, INT, INT);

VOID  xxxLBoxCtlScroll(PLBIV, INT, INT);

VOID  xxxLBShowHideScrollBars(PLBIV);

/*
 * LBoxCtl
 */
INT xxxLBoxCtlDelete(PLBIV, INT);

VOID  xxxLBoxCtlCharInput(PLBIV, UINT, BOOL);
VOID  xxxLBoxCtlKeyInput(PLBIV, UINT, UINT);
VOID  xxxLBPaint(PLBIV, HDC, LPRECT);

BOOL xxxLBInvalidateRect(PLBIV plb, LPRECT lprc, BOOL fErase);
/*
 * Miscellaneous
 */
VOID  xxxAlterHilite(PLBIV, INT, INT, BOOL, INT, BOOL);

INT CItemInWindow(PLBIV, BOOL);

VOID  xxxCheckRedraw(PLBIV, BOOL, INT);

LPWSTR GetLpszItem(PLBIV, INT);

VOID  xxxInsureVisible(PLBIV, INT, BOOL);

VOID  xxxInvertLBItem(PLBIV, INT, BOOL);

VOID  xxxLBBlockHilite(PLBIV, INT, BOOL);

int   LBGetSetItemHeightHandler(PLBIV plb, UINT message, int item, UINT height);
VOID  LBDropObjectHandler(PLBIV, PDROPSTRUCT);
LONG_PTR LBGetItemData(PLBIV, INT);

INT LBGetText(PLBIV, BOOL, BOOL, INT, LPWSTR);

VOID  xxxLBSetFont(PLBIV, HANDLE, BOOL);
int LBSetItemData(PLBIV, INT, LONG_PTR);

BOOL  LBSetTabStops(PLBIV, INT, LPINT);

VOID  xxxLBSize(PLBIV, INT, INT);
INT LastFullVisible(PLBIV);

INT xxxLbDir(PLBIV, UINT, LPWSTR);

INT xxxLbInsertFile(PLBIV, LPWSTR);

VOID  xxxNewITop(PLBIV, INT);
VOID  xxxNewITopEx(PLBIV, INT, DWORD);

VOID  xxxNotifyOwner(PLBIV, INT);

VOID  xxxResetWorld(PLBIV, INT, INT, BOOL);

VOID  xxxTrackMouse(PLBIV, UINT, POINT);
BOOL  xxxDlgDirListHelper(PWND, LPWSTR, LPBYTE, int, int, UINT, BOOL);
BOOL  DlgDirSelectHelper(LPWSTR pFileName, int cbFileName, HWND hwndListBox);
BOOL xxxLBResetContent(PLBIV plb);
VOID xxxLBSetRedraw(PLBIV plb, BOOL fRedraw);
int xxxSetLBScrollParms(PLBIV plb, int nCtl);
void xxxLBButtonUp(PLBIV plb, UINT uFlags);

/*
 * Variable Height OwnerDraw Support Routines
 */
INT CItemInWindowVarOwnerDraw(PLBIV, BOOL);

INT LBPage(PLBIV, INT, BOOL);


/*
 * Multicolumn listbox
 */
VOID  LBCalcItemRowsAndColumns(PLBIV);

/*
 * Both multicol and var height
 */
BOOL  LBGetItemRect(PLBIV, INT, LPRECT);

VOID  LBSetVariableHeightItemHeight(PLBIV, INT, INT);

INT   LBGetVariableHeightItemHeight(PLBIV, INT);

/*
 * No-data (lazy evaluation) listbox
 */
INT  xxxLBSetCount(PLBIV, INT);

UINT LBCalcAllocNeeded(PLBIV, INT);

/*
 * Storage pre-allocation support for LB_INITSTORAGE
 */
LONG xxxLBInitStorage(PLBIV plb, BOOL fAnsi, INT cItems, INT cb);

/***************************************************************************\
*
* Dialog Boxes
*
\***************************************************************************/

HWND        InternalCreateDialog(HANDLE hmod,
             LPDLGTEMPLATE lpDlgTemplate, DWORD cb,
             HWND hwndOwner , DLGPROC pfnWndProc, LPARAM dwInitParam,
             UINT fFlags);

INT_PTR     InternalDialogBox(HANDLE hmod,
             LPDLGTEMPLATE lpDlgTemplate,
             HWND hwndOwner , DLGPROC pfnWndProc, LPARAM dwInitParam,
             UINT fFlags);

PWND        _FindDlgItem(PWND pwndParent, DWORD id);
PWND        _GetDlgItem(PWND, int);
long        _GetDialogBaseUnits(VOID);
PWND        GetParentDialog(PWND pwndDialog);
VOID        xxxRemoveDefaultButton(PWND pwndDlg, PWND pwndStart);
VOID        xxxCheckDefPushButton(PWND pwndDlg, HWND hwndOldFocus, HWND hwndNewFocus);
PWND        xxxGotoNextMnem(PWND pwndDlg, PWND pwndStart, WCHAR ch);
VOID        DlgSetFocus(HWND hwnd);
void        RepositionRect(PMONITOR pMonitor, LPRECT lprc, DWORD dwStyle, DWORD dwExStyle);
BOOL        ValidateDialogPwnd(PWND pwnd);
PMONITOR    GetDialogMonitor(HWND hwndOwner, DWORD dwFlags);

HANDLE      GetEditDS(VOID);
VOID        ReleaseEditDS(HANDLE h);
VOID        TellWOWThehDlg(HWND hDlg);

UINT        GetACPCharSet();

/***************************************************************************\
*
* Menus
*
\***************************************************************************/
// cltxt.h
BOOL GetMenuItemInfoInternalW(HMENU hMenu, UINT uID, BOOL fByPosition, LPMENUITEMINFOW lpmii);

#define MENUAPI_INSERT  0
#define MENUAPI_GET     1
#define MENUAPI_SET     2

// clmenu.c
BOOL InternalInsertMenuItem(HMENU hMenu, UINT uID, BOOL fByPosition, LPCMENUITEMINFO lpmii);
BOOL ValidateMENUITEMINFO(LPMENUITEMINFOW lpmiiIn, LPMENUITEMINFOW lpmii, DWORD dwAPICode);
BOOL ValidateMENUINFO(LPCMENUINFO lpmi, DWORD dwAPICode);


// ntstubs.c
BOOL ThunkedMenuItemInfo(HMENU hMenu, UINT  nPosition, BOOL fByPosition,
                            BOOL fInsert, LPMENUITEMINFOW lpmii, BOOL fAnsi);

// menuc.c
void SetMenuItemInfoStruct(HMENU hMenu, UINT wFlags, UINT_PTR wIDNew, LPWSTR pwszNew,
                              LPMENUITEMINFOW pmii);

/***************************************************************************\
*
* Message Boxes
*
\***************************************************************************/

/* Unicode Right-To-Left mark unicode code point. Look in msgbox.c for more info */
#define UNICODE_RLM             0x200f

/***************************************************************************\
*
* MDI Windows
*
\***************************************************************************/

/* maximum number of MDI children windows listed in "Window" menu */
#define MAXITEMS         10

/*
 * MDI typedefs
 */
typedef struct tagSHORTCREATE {
    int         cy;
    int         cx;
    int         y;
    int         x;
    LONG        style;
    HMENU       hMenu;
} SHORTCREATE, *PSHORTCREATE;

typedef struct tagMDIACTIVATEPOS {
    int     cx;
    int     cy;
    int     cxMin;
    int     cyMin;
} MDIACTIVATEPOS, *PMDIACTIVATEPOS;

BOOL CreateMDIChild(PSHORTCREATE pcs, LPMDICREATESTRUCT pmcs, DWORD dwExpWinVerAndFlags, HMENU *phSysMenu, PWND pwndParent);
BOOL MDICompleteChildCreation(HWND hwndChild, HMENU hSysMenu, BOOL fVisible, BOOL fDisabled);

/*
 * MDI defines
 */
#define WS_MDISTYLE     (WS_CHILD | WS_CLIPSIBLINGS | WS_SYSMENU|WS_CAPTION|WS_THICKFRAME|WS_MAXIMIZEBOX|WS_MINIMIZEBOX)
#define WS_MDICOMMANDS  (WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX)
#define WS_MDIALLOWED   (WS_MINIMIZE | WS_MAXIMIZE | WS_CLIPCHILDREN | WS_DISABLED | WS_HSCROLL | WS_VSCROLL | 0x0000FFFFL)

#define HAS_SBVERT      0x0100
#define HAS_SBHORZ      0x0200
#define OTHERMAXING     0x0400
#define CALCSCROLL      0x0800

#define SCROLLSUPPRESS  0x0003
#define SCROLLCOUNT     0x00FF

#define CKIDS(pmdi)     (pmdi->cKids)
#define MAXED(pmdi)     (pmdi->hwndMaxedChild)
#define ACTIVE(pmdi)    (pmdi->hwndActiveChild)
#define WINDOW(pmdi)    (pmdi->hmenuWindow)
#define FIRST(pmdi)     (pmdi->idFirstChild)
#define SCROLL(pmdi)    (pmdi->wScroll)
#define ITILELEVEL(pmdi)    (pmdi->iChildTileLevel)
#define HTITLE(pmdi)    (pmdi->pTitle)

#define PROP_MDICLIENT  MAKEINTRESOURCE(0x8CAC)
#define MDIACTIVATE_PROP_NAME   L"MDIA"

PWND  FindPwndChild(PWND pwndMDI, UINT wChildID);
int   MakeMenuItem(LPWSTR lpOut, PWND pwnd);
VOID  ModifyMenuItem(PWND pwnd);
BOOL  MDIAddSysMenu(HMENU hmenuFrame, HWND hwndChild);
BOOL  MDIRemoveSysMenu(HMENU hMenuFrame, HWND hwndChild);
VOID  ShiftMenuIDs(PWND pwnd, PWND pwndVictim);
HMENU MDISetMenu(PWND,BOOL,HMENU,HMENU);
void  MDIRedrawFrame(HWND hwndChild, BOOL fAdd);

/*
 * Drag and Drop menus.
 */
#define COM_NO_WINDOWS_H
#define RPC_NO_WINDOWS_H
#include <ole2.h>

/*
 * Prototypes to cast function pointers
 */
typedef HRESULT (* OLEINITIALIZEPROC)(LPVOID);
typedef HRESULT (* OLEUNINITIALIZEPROC)(VOID);
typedef HRESULT (* REGISTERDDPROC)(HWND, LPDROPTARGET);
typedef HRESULT (* REVOKEDDPROC)(HWND);
typedef HRESULT (* DODDPROC)(LPDATAOBJECT, LPDROPSOURCE, DWORD, LPDWORD);

/*
 * Internal IDropTarget interface info
 */
typedef struct tagMNIDROPTARGET
{
   IDropTarget idt;                 /* Interal IDropTarget */
   DWORD dwRefCount;                /* Ref count */
   IDataObject * pido;              /* IDataObject received at DragEnter */
   IDropTarget * pidt;              /* Application IDropTarget, if any */
} MNIDROPTARGET, * PMNIDROPTARGET;

/*
 * OLE procs info (used by LoadOLEOnce GetProcAddress calls)
 */
typedef struct tagGETPROCINFO
{
    FARPROC * ppfn;
    LPCSTR lpsz;
} GETPROCINFO;

/*
 * Special value used by __ClientLoadOLE.
 */
#define OLEWONTLOAD (HINSTANCE)IntToPtr(0xFFFFFFFF)

/*
 * Accelerator table resources list.
 */
typedef struct tagACCELCACHE
{
    struct tagACCELCACHE *pacNext;
    UINT dwLockCount;
    HACCEL hAccel;
    PVOID pRes;
} ACCELCACHE, *PACCELCACHE;


/*
 * x86 callback return function prototype
 */
#if defined(_X86_) && !defined(BUILD_WOW6432)
NTSTATUS
FASTCALL
XyCallbackReturn(
    IN PVOID Buffer,
    IN ULONG Length,
    IN NTSTATUS Status
    );

#define UserCallbackReturn XyCallbackReturn
#else
#define UserCallbackReturn NtCallbackReturn
#endif

/*
 * Reader mode support
 */
typedef LONG (CALLBACK* READERMODEPROC)(LPARAM lParam, int nCode, int dx, int dy);

typedef struct tagREADERMODE {  // rdrm
    UINT cbSize;
    DWORD dwFlags;
    READERMODEPROC pfnReaderModeProc;
    LPARAM lParam;
} READERMODE, *PREADERMODE, *LPREADERMODE;

#define RDRMODE_VERT    0x00000001
#define RDRMODE_HORZ    0x00000002
#define RDRMODE_DIAG    0x00000004

#define RDRCODE_START   1
#define RDRCODE_SCROLL  2
#define RDRCODE_END     3

typedef struct tagREADERINFO {
    READERMODE;
    int dx;
    int dy;
    UINT uCursor;
    HBITMAP hbm;
    UINT dxBmp;
    UINT dyBmp;
} READERINFO, *PREADERINFO;

typedef struct tagREADERWND {
    WND wnd;
    PREADERINFO prdr;
} READERWND, * KPTR_MODIFIER PREADERWND;

BOOL EnterReaderModeHelper(HWND hwnd);

#include "ddemlcli.h"
#include "globals.h"
#include "cscall.h"
#include "ntuser.h"

/***************************************************************************\
*
* DBCS MESSAGING
*
\***************************************************************************/
/*
 * Message keeper for ...
 *
 * Client to Client.
 */
#define GetDispatchDbcsInfo()          (&(GetClientInfo()->achDbcsCF[0]))
/*
 * Client to Server.
 */
#define GetForwardDbcsInfo()           (&(GetClientInfo()->achDbcsCF[1]))
/*
 * Server to Client.
 */
#define GetCallBackDbcsInfo()          (&(GetClientInfo()->msgDbcsCB))

/*
 * Macros for DBCS Messaging for Recieve side.
 */
#define GET_DBCS_MESSAGE_IF_EXIST(_apiName,_pmsg,_wMsgFilterMin,_wMsgFilterMax,bRemoveMsg)  \
                                                                                            \
        if (GetCallBackDbcsInfo()->wParam) {                                                \
            /*                                                                              \
             * Check message filter... only WM_CHAR message will be pushed                  \
             * into CLIENTINFO. Then if WM_CHAR is filtered out, we should                  \
             * get message from queue...                                                    \
             */                                                                             \
            if ((!(_wMsgFilterMin) && !(_wMsgFilterMax)) ||                                 \
                ((_wMsgFilterMin) <= WM_CHAR && (_wMsgFilterMax) >= WM_CHAR)) {             \
                PKERNEL_MSG pmsgDbcs = GetCallBackDbcsInfo();                               \
                /*                                                                          \
                 * Get pushed message.                                                      \
                 *                                                                          \
                 * Backup current message. this backupped message will be used              \
                 * when Apps peek (or get) message from thier WndProc.                      \
                 * (see GetMessageA(), PeekMessageA()...)                                   \
                 *                                                                          \
                 * pmsg->hwnd    = pmsgDbcs->hwnd;                                          \
                 * pmsg->message = pmsgDbcs->message;                                       \
                 * pmsg->wParam  = pmsgDbcs->wParam;                                        \
                 * pmsg->lParam  = pmsgDbcs->lParam;                                        \
                 * pmsg->time    = pmsgDbcs->time;                                          \
                 * pmsg->pt      = pmsgDbcs->pt;                                            \
                 */                                                                         \
                COPY_KERNELMSG_TO_MSG((_pmsg),pmsgDbcs);                                   \
                /*                                                                          \
                 * if we don't want to clear the cached data, just leave it there.          \
                 */                                                                         \
                if (bRemoveMsg) {                                                           \
                    /*                                                                      \
                     * Invalidate pushed message in CLIENTINFO.                             \
                     */                                                                     \
                    pmsgDbcs->wParam = 0;                                                   \
                }                                                                           \
                /*                                                                          \
                 * Set return value to TRUE.                                                \
                 */                                                                         \
                retval = TRUE;                                                              \
                /*                                                                          \
                 * Exit function..                                                          \
                 */                                                                         \
                goto Exit ## _apiName;                                                      \
            }                                                                               \
        }

/*
 * Macros for DBCS Messaging for Send side.
 */
#define BUILD_DBCS_MESSAGE_TO_SERVER_FROM_CLIENTA(_msg,_wParam,_RetVal)                     \
                                                                                            \
        if (IS_DBCS_ENABLED() && (((_msg) == WM_CHAR) || ((_msg) == EM_SETPASSWORDCHAR))) { \
            /*                                                                              \
             * Chech wParam is DBCS character or not.                                       \
             */                                                                             \
            if (IS_DBCS_MESSAGE((_wParam))) {                                               \
                if ((_wParam) & WMCR_IR_DBCSCHAR) {                                         \
                    /*                                                                      \
                     * This message sent with IR_DBCSCHAR, already aligned for conversion   \
                     */                                                                     \
                } else {                                                                    \
                    /*                                                                      \
                     * Make IR_DBCSCHAR compatible DBCS packed message                      \
                     */                                                                     \
                    (_wParam) = MAKEWPARAM(MAKE_IR_DBCSCHAR(LOWORD((_wParam))),0);          \
                }                                                                           \
            } else {                                                                        \
                PBYTE pchDbcsCF = GetForwardDbcsInfo();                                     \
                /*                                                                          \
                 * If we have cached Dbcs LeadingByte character, build A Dbcs character     \
                 * with the TrailingByte in wParam...                                       \
                 */                                                                         \
                if (*pchDbcsCF) {                                                           \
                    WORD DbcsLeadChar = (WORD)(*pchDbcsCF);                                 \
                    /*                                                                      \
                     * HIBYTE(LOWORD(wParam)) = Dbcs LeadingByte.                           \
                     * LOBYTE(LOWORD(wParam)) = Dbcs TrailingByte.                          \
                     */                                                                     \
                    (_wParam) |= (DbcsLeadChar << 8);                                       \
                    /*                                                                      \
                     * Invalidate cached data..                                             \
                     */                                                                     \
                    *pchDbcsCF = 0;                                                         \
                } else if (IsDBCSLeadByteEx(THREAD_CODEPAGE(),LOBYTE(LOWORD(_wParam)))) { \
                    /*                                                                      \
                     * if this is Dbcs LeadByte character, we should wait Dbcs TrailingByte \
                     * to convert this to Unicode. then we cached it here...                \
                     */                                                                     \
                    *pchDbcsCF = LOBYTE(LOWORD((_wParam)));                                 \
                    /*                                                                      \
                     * Right now, we have nothing to do for this, just return with TRUE.    \
                     */                                                                     \
                    return((_RetVal));                                                      \
                }                                                                           \
            }                                                                               \
        }

#define BUILD_DBCS_MESSAGE_TO_CLIENTW_FROM_CLIENTA(_msg,_wParam,_RetVal)                    \
                                                                                            \
        if (IS_DBCS_ENABLED() && (((_msg) == WM_CHAR) || ((_msg) == EM_SETPASSWORDCHAR))) { \
            /*                                                                              \
             * Check wParam is DBCS character or not.                                       \
             */                                                                             \
            if (IS_DBCS_MESSAGE((_wParam))) {                                               \
                if ((_wParam) & WMCR_IR_DBCSCHAR) {                                         \
                    /*                                                                      \
                     * This message sent with IR_DBCSCHAR, already aligned for conversion   \
                     */                                                                     \
                } else {                                                                    \
                    /*                                                                      \
                     * Make IR_DBCSCHAR compatible DBCS packed message                      \
                     */                                                                     \
                    (_wParam) = MAKEWPARAM(MAKE_IR_DBCSCHAR(LOWORD((_wParam))),0);          \
                }                                                                           \
            } else {                                                                        \
                PBYTE pchDbcsCF = GetDispatchDbcsInfo();                                    \
                /*                                                                          \
                 * If we have cached Dbcs LeadingByte character, build A Dbcs character     \
                 * with the TrailingByte in wParam...                                       \
                 */                                                                         \
                if (*pchDbcsCF) {                                                           \
                    WORD DbcsLeadChar = (WORD)(*pchDbcsCF);                                 \
                    /*                                                                      \
                     * HIBYTE(LOWORD(wParam)) = Dbcs LeadingByte.                           \
                     * LOBYTE(LOWORD(wParam)) = Dbcs TrailingByte.                          \
                     */                                                                     \
                    (_wParam) |= (DbcsLeadChar << 8);                                       \
                    /*                                                                      \
                     * Invalidate cached data..                                             \
                     */                                                                     \
                    *pchDbcsCF = 0;                                                         \
                } else if (IsDBCSLeadByteEx(THREAD_CODEPAGE(),LOBYTE(LOWORD(_wParam)))) { \
                    /*                                                                      \
                     * if this is Dbcs LeadByte character, we should wait Dbcs TrailingByte \
                     * to convert this to Unicode. then we cached it here...                \
                     */                                                                     \
                    *pchDbcsCF = LOBYTE(LOWORD((_wParam)));                                 \
                    /*                                                                      \
                     * Right now, we have nothing to do for this, just return with TRUE.    \
                     */                                                                     \
                    return((_RetVal));                                                      \
                }                                                                           \
            }                                                                               \
        }

#define BUILD_DBCS_MESSAGE_TO_CLIENTA_FROM_SERVER(_pmsg,_dwAnsi,_bIrDbcsFormat,bSaveMsg)    \
        /*                                                                                  \
         * _bIrDbcsFormat parameter is only effective WM_CHAR/EM_SETPASSWORDCHAR message    \
         *                                                                                  \
         * (_bIrDbcsFormat == FALSE) dwAnsi has ....                                        \
         *                                                                                  \
         * HIBYTE(LOWORD(_dwAnsi)) = DBCS TrailingByte character.                           \
         * LOBYTE(LOWORD(_dwAnsi)) = DBCS LeadingByte character                             \
         *                           or SBCS character.                                     \
         *                                                                                  \
         * (_bIrDbcsFormat == TRUE) dwAnsi has ....                                         \
         *                                                                                  \
         * HIBYTE(LOWORD(_dwAnsi)) = DBCS LeadingByte character.                            \
         * LOBYTE(LOWORD(_dwAnsi)) = DBCS TrailingByte character                            \
         *                           or SBCS character.                                     \
         */                                                                                 \
    if (IS_DBCS_ENABLED())                                                 \
        switch ((_pmsg)->message) {                                                         \
        case WM_CHAR:                                                                       \
        case EM_SETPASSWORDCHAR:                                                            \
            if (IS_DBCS_MESSAGE((_dwAnsi))) {                                               \
                /*                                                                          \
                 * This is DBCS character..                                                 \
                 */                                                                         \
                if ((_pmsg)->wParam & WMCR_IR_DBCSCHAR) {                                   \
                    /*                                                                      \
                     * Build IR_DBCSCHAR format message.                                    \
                     */                                                                     \
                    if ((_bIrDbcsFormat)) {                                                 \
                        (_pmsg)->wParam = (WPARAM)(LOWORD((_dwAnsi)));                      \
                    } else {                                                                \
                        (_pmsg)->wParam = MAKE_IR_DBCSCHAR(LOWORD((_dwAnsi)));              \
                    }                                                                       \
                } else {                                                                    \
                    PKERNEL_MSG pDbcsMsg = GetCallBackDbcsInfo();                           \
                    if ((_bIrDbcsFormat)) {                                                 \
                        /*                                                                  \
                         * if the format is IR_DBCSCHAR format, adjust it to regular        \
                         * WPARAM format...                                                 \
                         */                                                                 \
                        (_dwAnsi) = MAKE_WPARAM_DBCSCHAR((_dwAnsi));                        \
                    }                                                                       \
                    if ((bSaveMsg)) {                                                       \
                        /*                                                                  \
                         * Copy this message to CLIENTINFO for next GetMessage              \
                         * or PeekMesssage() call.                                          \
                         */                                                                 \
                        COPY_MSG_TO_KERNELMSG(pDbcsMsg,(_pmsg));                            \
                        /*                                                                  \
                         * Only Dbcs Trailingbyte is nessesary for pushed message. we'll    \
                         * pass this message when GetMessage/PeekMessage is called at next. \
                         */                                                                 \
                        pDbcsMsg->wParam = (WPARAM)(((_dwAnsi) & 0x0000FF00) >> 8);         \
                    }                                                                       \
                    /*                                                                      \
                     * Return DbcsLeading byte to Apps.                                     \
                     */                                                                     \
                    (_pmsg)->wParam =  (WPARAM)((_dwAnsi) & 0x000000FF);                    \
                }                                                                           \
            } else {                                                                        \
                /*                                                                          \
                 * This is single byte character... set it to wParam.                       \
                 */                                                                         \
                (_pmsg)->wParam = (WPARAM)((_dwAnsi) & 0x000000FF);                         \
            }                                                                               \
            break;                                                                          \
        case WM_IME_CHAR:                                                                   \
        case WM_IME_COMPOSITION:                                                            \
            /*                                                                              \
             * if the message is not adjusted to IR_DBCSCHAR format yet,                    \
             * Build WM_IME_xxx format message.                                             \
             */                                                                             \
            if (!(_bIrDbcsFormat)) {                                                        \
                (_pmsg)->wParam = MAKE_IR_DBCSCHAR(LOWORD((_dwAnsi)));                      \
            }                                                                               \
            break;                                                                          \
        default:                                                                            \
            (_pmsg)->wParam = (WPARAM)(_dwAnsi);                                            \
            break;                                                                          \
        } /* switch */                                                                      \
    else                                                                                    \

#define BUILD_DBCS_MESSAGE_TO_CLIENTW_FROM_SERVER(_msg,_wParam)                             \
                                                                                            \
        if (((_msg) == WM_CHAR) || ((_msg) == EM_SETPASSWORDCHAR)) {                        \
            /*                                                                              \
             * Only LOWORD of WPARAM is valid for WM_CHAR....                               \
             * (Mask off DBCS messaging information.)                                       \
             */                                                                             \
            (_wParam) &= 0x0000FFFF;                                                        \
        }

#define BUILD_DBCS_MESSAGE_TO_CLIENTA_FROM_CLIENTW(_hwnd,_msg,_wParam,_lParam,_time,_pt,_bDbcs) \
                                                                                                \
        if (IS_DBCS_ENABLED() && (((_msg) == WM_CHAR) || ((_msg) == EM_SETPASSWORDCHAR))) {     \
            /*                                                                                  \
             * Check this message is DBCS Message or not..                                      \
             */                                                                                 \
            if (IS_DBCS_MESSAGE((_wParam))) {                                                   \
                PKERNEL_MSG pmsgDbcsCB = GetCallBackDbcsInfo();                                 \
                /*                                                                              \
                 * Mark this is DBCS character.                                                 \
                 */                                                                             \
                (_bDbcs) = TRUE;                                                                \
                /*                                                                              \
                 * Backup current message. this backupped message will be used                  \
                 * when Apps peek (or get) message from thier WndProc.                          \
                 * (see GetMessageA(), PeekMessageA()...)                                       \
                 */                                                                             \
                pmsgDbcsCB->hwnd    = (_hwnd);                                                  \
                pmsgDbcsCB->message = (_msg);                                                   \
                pmsgDbcsCB->lParam  = (_lParam);                                                \
                pmsgDbcsCB->time    = (_time);                                                  \
                pmsgDbcsCB->pt      = (_pt);                                                    \
                /*                                                                              \
                 * DbcsLeadByte will be sent below soon, we just need DbcsTrailByte             \
                 * for further usage..                                                          \
                 */                                                                             \
                pmsgDbcsCB->wParam = ((_wParam) & 0x000000FF);                                  \
                /*                                                                              \
                 * Pass the LeadingByte of the DBCS character to an ANSI WndProc.               \
                 */                                                                             \
                (_wParam) = ((_wParam) & 0x0000FF00) >> 8;                                      \
            } else {                                                                            \
                /*                                                                              \
                 * Validate only BYTE for WM_CHAR.                                              \
                 */                                                                             \
                (_wParam) &= 0x000000FF;                                                        \
            }                                                                                   \
        }

#define DISPATCH_DBCS_MESSAGE_IF_EXIST(_msg,_wParam,_bDbcs,_apiName)                            \
        /*                                                                                      \
         * Check we need to send trailing byte or not, if the wParam has Dbcs character         \
         */                                                                                     \
        if (IS_DBCS_ENABLED() && (_bDbcs) && (GetCallBackDbcsInfo()->wParam)) {                 \
            PKERNEL_MSG pmsgDbcsCB = GetCallBackDbcsInfo();                                            \
            /*                                                                                  \
             * If an app didn't peek (or get) the trailing byte from within                     \
             * WndProc, and then pass the DBCS TrailingByte to the ANSI WndProc here            \
             * pmsgDbcsCB->wParam has DBCS TrailingByte here.. see above..                      \
             */                                                                                 \
            (_wParam) = KERNEL_WPARAM_TO_WPARAM(pmsgDbcsCB->wParam);                            \
            /*                                                                                  \
             * Invalidate cached message.                                                       \
             */                                                                                 \
            pmsgDbcsCB->wParam = 0;                                                             \
            /*                                                                                  \
             * Send it....                                                                      \
             */                                                                                 \
            goto _apiName ## Again;                                                             \
        }

#define CalcAnsiStringLengthW(_unicodestring,_unicodeLength,_ansiLength)                        \
        /*                                                                                      \
         * Get AnsiStringLength from UnicodeString,UnicodeLength                                \
         */                                                                                     \
        {                                                                                       \
            RtlUnicodeToMultiByteSize((ULONG *)(_ansiLength),                                   \
                                      (LPWSTR)(_unicodestring),                                 \
                                      (ULONG)((_unicodeLength)*sizeof(WCHAR)));                 \
        }

#define CalcAnsiStringLengthA(_ansistring,_unicodeLength,_ansiLength)                           \
        /*                                                                                      \
         * Get AnsiStringLength from AnsiString,UnicodeLength                                   \
         */                                                                                     \
        {                                                                                       \
            LPSTR _string = (_ansistring);                                                      \
            LONG  _length = (LONG)(_unicodeLength);                                             \
            (*(_ansiLength)) = 0;                                                               \
            while(*_string && _length) {                                                        \
                if (IsDBCSLeadByte(*_string)) {                                                 \
                    (*(_ansiLength)) += 2; _string++;                                           \
                } else {                                                                        \
                    (*(_ansiLength))++;                                                         \
                }                                                                               \
                _string++; _length--;                                                           \
            }                                                                                   \
        }

#define CalcUnicodeStringLengthA(_ansistring,_ansiLength,_unicodeLength)                        \
        /*                                                                                      \
         * Get UnicodeLength from AnsiString,AnsiLength                                         \
         */                                                                                     \
        {                                                                                       \
            RtlMultiByteToUnicodeSize((ULONG *)(_unicodeLength),                                \
                                      (LPSTR)(_ansistring),                                     \
                                      (ULONG)(_ansiLength));                                    \
            (*(_unicodeLength)) /= sizeof(WCHAR);                                               \
        }

#define CalcUnicodeStringLengthW(_unicodestring,_ansiLength,_unicodeLength)                     \
        /*                                                                                      \
         * Get UnicodeLength from UnicodeString,AnsiLength                                      \
         */                                                                                     \
        {                                                                                       \
            LPWSTR _string = (_unicodestring);                                                  \
            LONG   _length = (LONG)(_ansiLength);                                               \
            LONG   _charlength;                                                                 \
            (*(_unicodeLength)) = 0;                                                            \
            while(*_string && (_length > 0)) {                                                  \
                CalcAnsiStringLengthW(_string,1,&_charlength);                                  \
                _length -= _charlength;                                                         \
                if (_length >= 0) {                                                             \
                    (*(_unicodeLength))++;                                                      \
                }                                                                               \
                _string++;                                                                      \
            }                                                                                   \
        }


/*
 * DBCS function defined in userrtl.lib (see ..\rtl\userrtl.h)
 */
DWORD UserGetCodePage(HDC hdc);
BOOL  UserIsFullWidth(DWORD dwCodePage,WCHAR wChar);
BOOL  UserIsFELineBreak(DWORD dwCodePage,WCHAR wChar);


// FE_IME   // fareast.c
typedef struct {
    BOOL (WINAPI* ImmWINNLSEnableIME)(HWND, BOOL);
    BOOL (WINAPI* ImmWINNLSGetEnableStatus)(HWND);
    LRESULT (WINAPI* ImmSendIMEMessageExW)(HWND, LPARAM);
    LRESULT (WINAPI* ImmSendIMEMessageExA)(HWND, LPARAM);
    BOOL (WINAPI* ImmIMPGetIMEW)(HWND, LPIMEPROW);
    BOOL (WINAPI* ImmIMPGetIMEA)(HWND, LPIMEPROA);
    BOOL (WINAPI* ImmIMPQueryIMEW)(LPIMEPROW);
    BOOL (WINAPI* ImmIMPQueryIMEA)(LPIMEPROA);
    BOOL (WINAPI* ImmIMPSetIMEW)(HWND, LPIMEPROW);
    BOOL (WINAPI* ImmIMPSetIMEA)(HWND, LPIMEPROA);

    HIMC (WINAPI* ImmAssociateContext)(HWND, HIMC);
    LRESULT (WINAPI* ImmEscapeA)(HKL, HIMC, UINT, LPVOID);
    LRESULT (WINAPI* ImmEscapeW)(HKL, HIMC, UINT, LPVOID);
    LONG (WINAPI* ImmGetCompositionStringA)(HIMC, DWORD, LPVOID, DWORD);
    LONG (WINAPI* ImmGetCompositionStringW)(HIMC, DWORD, LPVOID, DWORD);
    BOOL (WINAPI* ImmGetCompositionWindow)(HIMC, LPCOMPOSITIONFORM);
    HIMC (WINAPI* ImmGetContext)(HWND);
    HWND (WINAPI* ImmGetDefaultIMEWnd)(HWND);
    BOOL (WINAPI* ImmIsIME)(HKL);
    BOOL (WINAPI* ImmReleaseContext)(HWND, HIMC);
    BOOL (*ImmRegisterClient)(PSHAREDINFO, HINSTANCE);

    BOOL (WINAPI* ImmGetCompositionFontW)(HIMC, LPLOGFONTW);
    BOOL (WINAPI* ImmGetCompositionFontA)(HIMC, LPLOGFONTA);
    BOOL (WINAPI* ImmSetCompositionFontW)(HIMC, LPLOGFONTW);
    BOOL (WINAPI* ImmSetCompositionFontA)(HIMC, LPLOGFONTA);

    BOOL (WINAPI* ImmSetCompositionWindow)(HIMC, LPCOMPOSITIONFORM);
    BOOL (WINAPI* ImmNotifyIME)(HIMC, DWORD, DWORD, DWORD);
    PINPUTCONTEXT (WINAPI* ImmLockIMC)(HIMC);
    BOOL (WINAPI* ImmUnlockIMC)(HIMC);
    BOOL (WINAPI* ImmLoadIME)(HKL);
    BOOL (WINAPI* ImmSetOpenStatus)(HIMC, BOOL);
    BOOL (WINAPI* ImmFreeLayout)(DWORD);
    BOOL (WINAPI* ImmActivateLayout)(HKL);
    BOOL (WINAPI* ImmGetCandidateWindow)(HIMC, DWORD, LPCANDIDATEFORM);
    BOOL (WINAPI* ImmSetCandidateWindow)(HIMC, LPCANDIDATEFORM);
    BOOL (WINAPI* ImmConfigureIMEW)(HKL, HWND, DWORD, LPVOID);
    BOOL (WINAPI* ImmGetConversionStatus)(HIMC, LPDWORD, LPDWORD);
    BOOL (WINAPI* ImmSetConversionStatus)(HIMC, DWORD, DWORD);
    BOOL (WINAPI* ImmSetStatusWindowPos)(HIMC, LPPOINT);
    BOOL (WINAPI* ImmGetImeInfoEx)(PIMEINFOEX, IMEINFOEXCLASS, PVOID);
    PIMEDPI (WINAPI* ImmLockImeDpi)(HKL);
    VOID (WINAPI* ImmUnlockImeDpi)(PIMEDPI);
    BOOL (WINAPI* ImmGetOpenStatus)(HIMC);
    BOOL (*ImmSetActiveContext)(HWND, HIMC, BOOL);
    BOOL (*ImmTranslateMessage)(HWND, UINT, WPARAM, LPARAM);
    BOOL (*ImmLoadLayout)(HKL, PIMEINFOEX);
    DWORD (WINAPI* ImmProcessKey)(HWND, HKL, UINT, LPARAM, DWORD);
    LRESULT (*ImmPutImeMenuItemsIntoMappedFile)(HIMC);
    DWORD (WINAPI* ImmGetProperty)(HKL hKL, DWORD dwIndex);
    BOOL (WINAPI* ImmSetCompositionStringA)(
        HIMC hImc, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen, LPCVOID lpRead, DWORD dwReadLen);
    BOOL (WINAPI* ImmSetCompositionStringW)(
        HIMC hImc, DWORD dwIndex, LPCVOID lpComp, DWORD dwCompLen, LPCVOID lpRead, DWORD dwReadLen);
    BOOL (WINAPI* ImmEnumInputContext)(
        DWORD idThread, IMCENUMPROC lpfn, LPARAM lParam);
    LRESULT (WINAPI* ImmSystemHandler)(HIMC, WPARAM, LPARAM);

#ifdef CUAS_ENABLE
    // Cicero
    HRESULT (WINAPI* CtfImmTIMActivate)(HKL hKL);
    void (WINAPI* CtfImmRestoreToolbarWnd)(DWORD dwPrevSts);
    DWORD (WINAPI* CtfImmHideToolbarWnd)(void);
    LRESULT (WINAPI* CtfImmDispatchDefImeMessage)(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
#endif // CUAS_ENABLE
} ImmApiEntries;

extern ImmApiEntries gImmApiEntries;
extern HMODULE ghImm32;
VOID InitializeImmEntryTable(VOID);
VOID GetImmFileName(PWSTR);
VOID CliImmInitializeHotKeys(DWORD dwAction, HKL hkl);

#define fpImmAssociateContext       gImmApiEntries.ImmAssociateContext
#define fpImmEscapeA                gImmApiEntries.ImmEscapeA
#define fpImmEscapeW                gImmApiEntries.ImmEscapeW
#define fpImmGetContext             gImmApiEntries.ImmGetContext
#define fpImmGetCompositionStringA  gImmApiEntries.ImmGetCompositionStringA
#define fpImmGetCompositionStringW  gImmApiEntries.ImmGetCompositionStringW
#define fpImmGetCompositionWindow   gImmApiEntries.ImmGetCompositionWindow
#define fpImmGetDefaultIMEWnd       gImmApiEntries.ImmGetDefaultIMEWnd
#define fpImmIsIME                  gImmApiEntries.ImmIsIME
#define fpImmLockIMC                gImmApiEntries.ImmLockIMC
#define fpImmReleaseContext         gImmApiEntries.ImmReleaseContext
#define fpImmRegisterClient         gImmApiEntries.ImmRegisterClient
#define fpImmGetCompositionFontW    gImmApiEntries.ImmGetCompositionFontW
#define fpImmGetCompositionFontA    gImmApiEntries.ImmGetCompositionFontA
#define fpImmSetCompositionFontW    gImmApiEntries.ImmSetCompositionFontW
#define fpImmSetCompositionFontA    gImmApiEntries.ImmSetCompositionFontA
#define fpImmSetCompositionFont     gImmApiEntries.ImmSetCompositionFont
#define fpImmSetCompositionWindow   gImmApiEntries.ImmSetCompositionWindow
#define fpImmNotifyIME              gImmApiEntries.ImmNotifyIME
#define fpImmUnlockIMC              gImmApiEntries.ImmUnlockIMC
#define fpImmLoadIME                gImmApiEntries.ImmLoadIME
#define fpImmSetOpenStatus          gImmApiEntries.ImmSetOpenStatus
#define fpImmFreeLayout             gImmApiEntries.ImmFreeLayout
#define fpImmActivateLayout         gImmApiEntries.ImmActivateLayout
#define fpImmGetCandidateWindow     gImmApiEntries.ImmGetCandidateWindow
#define fpImmSetCandidateWindow     gImmApiEntries.ImmSetCandidateWindow
#define fpImmConfigureIMEW          gImmApiEntries.ImmConfigureIMEW
#define fpImmGetConversionStatus    gImmApiEntries.ImmGetConversionStatus
#define fpImmSetConversionStatus    gImmApiEntries.ImmSetConversionStatus
#define fpImmSetStatusWindowPos     gImmApiEntries.ImmSetStatusWindowPos
#define fpImmGetImeInfoEx           gImmApiEntries.ImmGetImeInfoEx
#define fpImmLockImeDpi             gImmApiEntries.ImmLockImeDpi
#define fpImmUnlockImeDpi           gImmApiEntries.ImmUnlockImeDpi
#define fpImmGetOpenStatus          gImmApiEntries.ImmGetOpenStatus
#define fpImmSetActiveContext       gImmApiEntries.ImmSetActiveContext
#define fpImmTranslateMessage       gImmApiEntries.ImmTranslateMessage
#define fpImmLoadLayout             gImmApiEntries.ImmLoadLayout
#define fpImmProcessKey             gImmApiEntries.ImmProcessKey
#define fpImmPutImeMenuItemsIntoMappedFile gImmApiEntries.ImmPutImeMenuItemsIntoMappedFile
#define fpImmGetProperty            gImmApiEntries.ImmGetProperty
#define fpImmSetCompositionStringA  gImmApiEntries.ImmSetCompositionStringA
#define fpImmSetCompositionStringW  gImmApiEntries.ImmSetCompositionStringW
#define fpImmEnumInputContext       gImmApiEntries.ImmEnumInputContext
#define fpImmSystemHandler          gImmApiEntries.ImmSystemHandler

BOOL SyncSoftKbdState(HIMC hImc, LPARAM lParam); // imectl.c

#ifdef CUAS_ENABLE
// Cicero
#define fpCtfImmTIMActivate            gImmApiEntries.CtfImmTIMActivate
#define fpCtfImmRestoreToolbarWnd      gImmApiEntries.CtfImmRestoreToolbarWnd
#define fpCtfImmHideToolbarWnd         gImmApiEntries.CtfImmHideToolbarWnd
#define fpCtfImmDispatchDefImeMessage  gImmApiEntries.CtfImmDispatchDefImeMessage

#endif


// end FE_IME

/*
 * Rebasing functions for shared memory. Need to located after
 * inclusion of globals.h.
 */
__inline PVOID
REBASESHAREDPTRALWAYS(KERNEL_PVOID p)
{
    return (PVOID)(((KERNEL_UINT_PTR)p) - gSharedInfo.ulSharedDelta);
}

__inline PVOID
REBASESHAREDPTR(KERNEL_PVOID p)
{
    return (p) ? REBASESHAREDPTRALWAYS(p) : NULL;
}

/*
 * Multimonitor macros used in RTL. There are similar definitions
 * in kernel\userk.h
 */
__inline PDISPLAYINFO
GetDispInfo(VOID)
{
    return gSharedInfo.pDispInfo;
}

__inline PMONITOR
GetPrimaryMonitor(VOID)
{
    return REBASESHAREDPTR(GetDispInfo()->pMonitorPrimary);
}


/*
 * UserApiHook functions
 */

__inline BOOL IsInsideUserApiHook(
    VOID)
{
    return (ghmodUserApiHook != NULL) && gfUserApiHook;
}

__inline BOOL _BeginIfHookedUserApiHook()
{
    UserAssert(gcCallUserApiHook < MAXLONG);

    InterlockedIncrement(&gcCallUserApiHook);
    if (!IsInsideUserApiHook()) {
        InterlockedDecrement(&gcCallUserApiHook);
        return FALSE;
    } else {
        UserAssertMsg0(ghmodUserApiHook != NULL, "Should not reach 0 while outstanding call");
        return TRUE;
    }
}

VOID _EndUserApiHook(VOID);

#define BEGIN_USERAPIHOOK()                                                 \
    {                                                                       \
        BOOL fInsideHook = IsInsideUserApiHook();                           \
                                                                            \
        if (!gfServerProcess && !fInsideHook && TEST_SRVIF(SRVIF_HOOKED)) { \
            if (!RtlIsThreadWithinLoaderCallout()) {                        \
                NtUserCallNoParam(SFI_XXXLOADUSERAPIHOOK);                  \
            }                                                               \
        }                                                                   \
                                                                            \
        fInsideHook = _BeginIfHookedUserApiHook();                          \
        try {                                                               \


#define END_USERAPIHOOK()               \
        } finally {                     \
            if (fInsideHook) {          \
                _EndUserApiHook();      \
            }                           \
        }                               \
    }                                   \


#ifdef MESSAGE_PUMP_HOOK

__inline BOOL IsInsideMessagePumpHook()
{
    PCLIENTTHREADINFO pcti = GetClientInfo()->pClientThreadInfo;
    return gfMessagePumpHook && (pcti != NULL) && (pcti->cMessagePumpHooks > 0);
}

#define BEGIN_MESSAGEPUMPHOOK()                         \
    {                                                   \
        BOOL fInsideHook = IsInsideMessagePumpHook();   \


#define END_MESSAGEPUMPHOOK()           \
    }                                   \

#endif


int RealSetScrollInfo(HWND hwnd, int fnBar, LPCSCROLLINFO lpsi, BOOL fRedraw);
BOOL RealGetScrollInfo(HWND hwnd, int code, LPSCROLLINFO lpsi);
BOOL RealEnableScrollBar(HWND hWnd, UINT wSBflags, UINT wArrows);
BOOL RealAdjustWindowRectEx(LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle);
BOOL RealSetWindowRgn(HWND hwnd, HRGN hrgn, BOOL bRedraw);
int RealGetSystemMetrics(int index);
BOOL RealSystemParametersInfoA(UINT wFlag, UINT wParam, PVOID lParam, UINT flags);
BOOL RealSystemParametersInfoW(UINT wFlag, UINT wParam, PVOID lParam, UINT flags);
BOOL ForceResetUserApiHook(HMODULE hmod);
BOOL RealDrawFrameControl(HDC hdc, LPRECT lprc, UINT wType, UINT wState);
BOOL RealDrawCaption(HWND hwnd, HDC hdc, CONST RECT *lprc, UINT flags);
void RealMDIRedrawFrame(HWND hwndChild, BOOL fAdd);


/*
 * Event logging stuff
 */
BOOL GetCurrentProcessName(WCHAR *pszProcessName, int cch);
BOOL GetUserSid(PTOKEN_USER *ppTokenUser);

#ifdef _JANUS_
BOOL InitInstrument(LPDWORD lpEMIControl);
#endif

#define MAX_ATOM_LEN    256

#define FREE_LIBRARY_SAVE_ERROR(hModule)                                    \
{                                                                           \
    DWORD SaveLastError = NtCurrentTeb()->LastErrorValue;                   \
    FreeLibrary(hModule);                                                   \
    NtCurrentTeb()->LastErrorValue = SaveLastError;                         \
}

BOOL VersionRegisterClass(LPWSTR lpzClassName, LPWSTR lpzDllName, PACTIVATION_CONTEXT lpActivationContext, HMODULE *phModule);
LPWSTR ClassNameToVersion (LPCWSTR lpClassName, LPWSTR pClassVerName, LPWSTR* lpDllName, PACTIVATION_CONTEXT* lppActivationContext, BOOL bIsANSI);

#define ARRAYSIZE(a)    (sizeof(a) / sizeof(a[0]))

#define TEST_DUSER_WMH 0

#if TEST_DUSER_WMH

DECLARE_HANDLE(HDCONTEXT);

typedef struct tagINITGADGET
{
    DWORD       cbSize;         // Size of structure
    UINT        nThreadMode;    // Threading model
    UINT        nMsgMode;       // DirectUser/Core messaging subsystem mode
    HDCONTEXT   hctxShare;      // Existing context to share with
} INITGADGET;

typedef HDCONTEXT (WINAPI * InitGadgetsProc)(INITGADGET * pInit);
extern HDCONTEXT g_hctx;        // DirectUser Context

#define IGTM_SEPARATE           (2)     // | MT with single thread per context

#define IGMM_STANDARD           (3)     // | Standard mode on Whistler

#endif

#ifdef LAME_BUTTON
#define LAMEBUTTON_PROP_NAME L"LAME"
#endif

#endif