/* * _w32sys.h * * Purpose: * Isolate various Win 32 system dependencies. * * Copyright (c) 1995-2000, Microsoft Corporation. All rights reserved. */ #ifndef _W32SYS_H #define _W32SYS_H #ifndef NOFEPROCESSING #define OBSOLETE // need this to get old IMEShare defines #include "imeshare.h" #else // Some class declarations to keep the compiler happy struct IMESTYLE; struct IMECOLORSTY; struct CIMEShare; #endif #include "_array.h" #ifndef THICKCARET #define duCaret 1 #else #define duCaret 2 #endif #ifdef LIMITEDMEMORY #define FONTCACHESIZE 8 #define CCSHASHSEARCHSIZE 15 #define DEFAULT_UNDO_SIZE 20 #else #define FONTCACHESIZE 24 #define CCSHASHSEARCHSIZE 31 #define DEFAULT_UNDO_SIZE 100 #endif #ifdef SLOWCPU #define NUMPASTECHARSWAITCURSOR 1024 #else #define NUMPASTECHARSWAITCURSOR (1024*32) #endif #ifndef NOMEMORYH #include "memory.h" // for memmove #endif #define RSHIFT 1 #define LSHIFT 2 #define RCTRL 0x10 #define LCTRL 0x20 #define RALT 0x40 #define LALT 0x80 #define SHIFT (RSHIFT + LSHIFT) #define ALT (RALT + LALT) #define CTRL (RCTRL + LCTRL) #define HOTEURO 0x1000 #define ALT0 0x2000 #define ALTNUMPAD 0x4000 #define LETAFTERSHIFT 0x8000 // special virtual keys copied from Japan MSVC ime.h #define VK_KANA 0x15 #define VK_KANJI 0x19 // Initialization flags that can be used in system.ini for testing purposes #define SYSINI_USELS 0x1 #define SYSINI_BIDI 0x2 #define SYSINI_USEAIMM 0x4 #define SYSINI_DEBUGFONT 0x8 #define SYSINI_DEBUGGCF125X 0x10 #define SYSINI_USECTF 0x20 /* * GetCaretDelta () * * @func Get size of caret to add to current caret position to get the * maximum extent needed to display caret. * * @rdesc Size of caret over 1 pixel * * @devnote This exists solely to abstract this calculation * to handle a variable size caret. */ inline int GetCaretDelta() { return duCaret - 1; } // Used in rtfread.cpp to keep track of lossy rtf. #ifdef PWORD_CONVERTER_V2 #define REPORT_LOSSAGE #endif //Windows CE defines which need to be before their function declarations #ifdef UNDER_CE typedef struct tagKERNINGPAIR { WORD wFirst; WORD wSecond; int iKernAmount; } KERNINGPAIR, *LPKERNINGPAIR; #endif // Defines for some Codepages #define CP_JAPAN 932 #define CP_KOREAN 949 #define CP_CHINESE_TRAD 950 #define CP_CHINESE_SIM 936 #define CP_HEBREW 1255 #define CP_ARABIC 1256 #define CP_THAI 874 #define CP_VIETNAMESE 1258 #define CP_ULE 1200 // Unicode #define CP_UBE 1201 #define IsUnicodeCP(cp) (((cp) & ~1) == CP_ULE) // Newly introduced Indic language ID #if(WINVER < 0x500) #define LANG_HINDI 0x39 #define LANG_KONKANI 0x57 #define LANG_NEPALI 0x61 #define LANG_BENGALI 0x45 #define LANG_PUNJABI 0x46 #define LANG_GUJARATHI 0x47 #define LANG_ORIYA 0x48 #define LANG_TAMIL 0x49 #define LANG_TELUGU 0x4a #define LANG_KANNADA 0x4b #define LANG_MALAYALAM 0x4c #define LANG_ASSAMESE 0x4d #define LANG_MARATHI 0x4e #define LANG_SANSKRIT 0x4f #endif // Other possibly missing defines #ifndef LANG_THAI #define LANG_THAI 0x1e #endif #define ANSI_INDEX 0 // Keep these indices in sync #define EASTEUROPE_INDEX 1 // with rgCodePage[] and #define RUSSIAN_INDEX 2 // rgCharSet[] if entries #define GREEK_INDEX 3 // exist in these arrays. #define TURKISH_INDEX 4 #define HEBREW_INDEX 5 #define ARABIC_INDEX 6 #define BALTIC_INDEX 7 #define VIET_INDEX 8 #define DEFAULT_INDEX 9 #define SYMBOL_INDEX 10 #define THAI_INDEX 11 #define SHIFTJIS_INDEX 12 #define GB2312_INDEX 13 #define HANGUL_INDEX 14 #define BIG5_INDEX 15 #define PC437_INDEX 16 #define OEM_INDEX 17 #define MAC_INDEX 18 #define NCHARSETS 19 // Size of charset-oriented tables #define ARMENIAN_INDEX 19 // Start of Unicode-only repertoires #define SYRIAC_INDEX 20 #define THAANA_INDEX 21 #define DEVANAGARI_INDEX 22 #define BENGALI_INDEX 23 #define GURMUKHI_INDEX 24 #define GUJARATI_INDEX 25 #define ORIYA_INDEX 26 #define TAMIL_INDEX 27 #define TELUGU_INDEX 28 #define KANNADA_INDEX 29 #define MALAYALAM_INDEX 30 #define SINHALA_INDEX 31 #define LAO_INDEX 32 #define TIBETAN_INDEX 33 #define MYANMAR_INDEX 34 #define GEORGIAN_INDEX 35 #define JAMO_INDEX 36 #define ETHIOPIC_INDEX 37 #define CHEROKEE_INDEX 38 #define ABORIGINAL_INDEX 39 #define OGHAM_INDEX 40 #define RUNIC_INDEX 41 #define KHMER_INDEX 42 #define MONGOLIAN_INDEX 43 #define BRAILLE_INDEX 44 #define YI_INDEX 45 // Keep next four in same order as #define JPN2_INDEX 46 // SHIFTJIS_INDEX to BIG5_INDEX #define CHS2_INDEX 47 #define KOR2_INDEX 48 #define CHT2_INDEX 49 #define NCHARREPERTOIRES 50 // Size of keyboard and font-binding tables #define INDIC_FIRSTINDEX DEVANAGARI_INDEX #define INDIC_LASTINDEX SINHALA_INDEX #define PC437_CHARSET 254 // Flags which can be passed down to REExtTextOut // The low 2 bits are reserved for passing down the TFLOW of the text const DWORD fETOFEFontOnNonFEWin9x = 0x04; const DWORD fETOCustomTextOut = 0x08; #define IsSymbolOrOEMCharRep(x) (x == SYMBOL_INDEX || x == OEM_INDEX) enum CC { CC_ARABIC, CC_HEBREW, CC_RTL, CC_LTR, CC_EOP, CC_ASCIIDIGIT, CC_NEUTRAL }; #define IsRTL(cc) (cc <= CC_RTL) const SHORT sLanguageEnglishUS = 0x0409; const SHORT sLanguageMask = 0x03ff; const SHORT sLanguageArabic = 0x0401; const SHORT sLanguageHebrew = 0x040d; // FUTURE: currently this const == sLanguageEnglishUS // for no reason except that it was this way // in RE1.0 BiDi. Consider changing, or sticking // the real language in, and changing the logic // of handling wLang a bit. const SHORT sLanguageNonBiDi = 0x0409; // Logical unit definition const int LX_PER_INCH = 1440; const int LY_PER_INCH = 1440; // HIMETRIC units per inch (used for conversion) const int HIMETRIC_PER_INCH = 2540; #if defined(DEBUG) void* __cdecl operator new(size_t nSize, char *szFile, int nLine); #define NEW_DEBUG new(__FILE__, __LINE__) #define new NEW_DEBUG void UpdateMst(void); struct MST { char *szFile; int cbAlloc; }; //Memory Statistics; extern MST vrgmst[]; #endif //DEBUG #ifdef CopyMemory #undef CopyMemory #endif #ifdef MoveMemory #undef MoveMemory #endif #ifdef FillMemory #undef FillMemory #endif #ifdef ZeroMemory #undef ZeroMemory #endif #ifdef CompareMemory #undef CompareMemory #endif #ifndef KF_ALTDOWN #define KF_ALTDOWN 0x2000 #endif // Use for our version of ExtTextOut enum CONVERTMODE { CVT_NONE, // Use Unicode (W) CharWidth/TextOut APIs CVT_WCTMB, // Convert to MBCS using WCTMB and _wCodePage CVT_LOWBYTE // Use low byte of 16-bit chars (for SYMBOL_CHARSET }; // and when code page isn't installed) // Opaque Type class CTxtSelection; class CTxtEdit; class CCharFormat; class CCcs; enum UN_FLAGS { UN_NOOBJECTS = 1, UN_CONVERT_WCH_EMBEDDING = 2 }; #undef GetStringTypeEx #undef CharLower #undef CharLowerBuff #undef CharUpperBuff #undef CreateIC #undef CreateFile #undef CreateFontIndirect #undef CompareString #undef DefWindowProc #undef GetKeyboardLayout #undef GetProfileSection #undef GetKerningPairs #undef GetTextMetrics #undef GetTextFace #undef GetWindowLong #undef GetWindowLongPtr #undef GetClassLong #undef LoadBitmap #undef LoadCursor #undef LoadLibrary #undef SendMessage #undef SetWindowLong #undef SetWindowLongPtr #undef PostMessage #undef lstrcmp #undef lstrcmpi #undef PeekMessage #undef GetModuleFileName #undef GlobalAlloc #undef GlobalFree #undef GlobalFlags #undef GlobalReAlloc #undef GlobalLock #undef GlobalHandle #undef GlobalUnlock #undef GlobalSize // Bits used in _fFEFontInfo: #define JPN_FONT_AVAILABLE 0x0001 // True if Jpn font is available #define KOR_FONT_AVAILABLE 0x0002 // True if Kor font is available #define BIG5_FONT_AVAILABLE 0x0004 // True if Trad. Chinese font is available #define GB_FONT_AVAILABLE 0x0008 // True if Simplified Chinese font is available #define FEUSER_LCID 0x0010 // True if User LCID is FE LCID #define FEUSER_CODEPAGE 0x0060 // indicate which User FE codepage its #define FEUSER_CP_JPN 0x0000 // =00 for JPN #define FEUSER_CP_KOR 0x0020 // =20 for KOR #define FEUSER_CP_BIG5 0x0040 // =40 for BIG5 #define FEUSER_CP_GB 0x0060 // =60 for GB #define FEDATA_NOT_INIT 0xFFFF // No data yet class CConvertStrW { public: operator WCHAR *(); protected: CConvertStrW(); ~CConvertStrW(); void Free(); LPWSTR _pwstr; WCHAR _awch[MAX_PATH * 2]; }; inline CConvertStrW::CConvertStrW() { _pwstr = NULL; } inline CConvertStrW::~CConvertStrW() { Free(); } inline CConvertStrW::operator WCHAR *() { return _pwstr; } class CStrInW : public CConvertStrW { public: CStrInW(LPCSTR pstr); CStrInW(LPCSTR pstr, UINT uiCodePage); CStrInW(LPCSTR pstr, int cch, UINT uiCodePage); int strlen(); protected: CStrInW(); void Init(LPCSTR pstr, int cch, UINT uiCodePage); int _cwchLen; UINT _uiCodePage; }; inline CStrInW::CStrInW() { } inline int CStrInW::strlen() { return _cwchLen; } // Mask bit for temp display Attributes #define APPLY_TMP_FORECOLOR 0x0001 // Apply temp. text color #define APPLY_TMP_BACKCOLOR 0x0002 // Apply temp. background color // Actions for GetTmpColor #define GET_TEMP_TEXT_COLOR 1 #define GET_TEMP_BACK_COLOR 2 #define GET_TEMP_UL_COLOR 3 typedef struct _tmpDispAttrib { WORD wMask; // Mask for temp display Attributes BYTE bUnderlineType; // Temp Underline type COLORREF crTextColor; // Temp Foreground color COLORREF crBackColor; // Temp Background color COLORREF crUnderlineColor; // Temp Underline color } TMPDISPLAYATTR; class CTmpDisplayAttrArray : public CArray { public: CTmpDisplayAttrArray() {}; ~CTmpDisplayAttrArray() {}; }; typedef DWORD (WINAPI* PFN_GETLAYOUT)(HDC); typedef DWORD (WINAPI* PFN_SETLAYOUT)(HDC, DWORD); #ifdef wcsicmp #undef wcsicmp #endif class CW32System { private : static DWORD _dwPlatformId; // platform GetVersionEx(); static LCID _syslcid; public : static CIMEShare *_pIMEShare; static UINT _fRegisteredXBox; // flag indicating if listbox and combobox were registered static DWORD _dwMajorVersion; // major version from GetVersionEx() static DWORD _dwMinorVersion; // minor version from GetVersionEx() static INT _icr3DDarkShadow; // value to use for COLOR_3DDKSHADOW static UINT _MSIMEMouseMsg; // mouse operation static UINT _MSIMEReconvertMsg; // reconversion static UINT _MSIMEReconvertRequestMsg; // reconversion request static UINT _MSIMEDocFeedMsg; // document feed static UINT _MSIMEQueryPositionMsg; // query position static UINT _MSIMEServiceMsg; // checking MSIME98 or later static UINT _MSMouseRoller; // mouse scrolling // Misc flags used for more precise character classification static WORD _fFEFontInfo; static BYTE _fLRMorRLM; // Misc flags used for FE static BYTE _fHaveIMMProcs; static BYTE _fHaveAIMM; static BYTE _fHaveIMMEShare; static BYTE _fLoadAIMM10; static CTmpDisplayAttrArray *_arTmpDisplayAttrib; CW32System(); ~CW32System(); static DWORD AddRef(); static DWORD Release(); // Platform testing static bool OnWinNTFE() { return _dwPlatformId == VER_PLATFORM_WIN32_NT && IsFELCID(_syslcid ); } static bool OnWinNTNonFE() { return _dwPlatformId == VER_PLATFORM_WIN32_NT && !IsFELCID(_syslcid ); } static bool OnWinNT5() { return _dwPlatformId == VER_PLATFORM_WIN32_NT && 5 == _dwMajorVersion; } static bool OnWinNT4() { return _dwPlatformId == VER_PLATFORM_WIN32_NT && 4 == _dwMajorVersion; } static bool OnWin9xFE() { return _dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && IsFELCID(_syslcid ); } static bool OnWin9x() { return _dwPlatformId == VER_PLATFORM_WIN32_WINDOWS; } static bool OnWin95() { return OnWin9x() && (4 == _dwMajorVersion) && (0 == _dwMinorVersion); } static bool OnWin95FE() { return OnWin95() && IsFELCID(_syslcid ); } static bool OnWin9xThai() { return _dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && PRIMARYLANGID(_syslcid) == LANG_THAI; } static bool OnWin9xBiDi() { return _dwPlatformId == VER_PLATFORM_WIN32_WINDOWS && IsBiDiLcid(_syslcid); } static bool OnBiDiOS() { return IsBiDiLcid(_syslcid) != 0; } struct WM_CHAR_INFO { bool _fAccumulate; bool _fLeadByte; bool _fTrailByte; bool _fIMEChar; }; static UINT GetACP() {return _ACP;} static LCID GetSysLCID() {return _syslcid;} #ifndef NOANSIWINDOWS static LRESULT ANSIWndProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam, BOOL fIs10Mode ); static void AnsiFilter( UINT &msg, WPARAM &wparam, LPARAM lparam, void *pvoid, BOOL fIs10Mode = FALSE ); #endif static HGLOBAL WINAPI GlobalAlloc( UINT uFlags, DWORD dwBytes ); static HGLOBAL WINAPI GlobalFree( HGLOBAL hMem ); static UINT WINAPI GlobalFlags( HGLOBAL hMem ); static HGLOBAL WINAPI GlobalReAlloc( HGLOBAL hMem, DWORD dwBytes, UINT uFlags ); static DWORD WINAPI GlobalSize( HGLOBAL hMem ); static PVOID WINAPI GlobalLock( HGLOBAL hMem ); static HGLOBAL WINAPI GlobalHandle( LPCVOID pMem ); static BOOL WINAPI GlobalUnlock( HGLOBAL hMem ); static void WINAPI REGetCharWidth( HDC hdc, WCHAR ch, INT *pdxp, UINT uiCodePage, BOOL fCustomTextOut); static DWORD WINAPI GetKerningPairs(HDC hdc, DWORD ckp, KERNINGPAIR *pkp); static void EraseTextOut(HDC hdc, const RECT *prc); static void WINAPI REExtTextOut( CONVERTMODE cm, UINT uiCodePage, HDC hdc, int x, int y, UINT fuOptions, CONST RECT *lprc, const WCHAR *lpString, UINT cch, CONST INT *lpDx, DWORD dwETOFlags); static CONVERTMODE WINAPI DetermineConvertMode( HDC hdc, BYTE tmCharSet ); static void WINAPI CalcUnderlineInfo(HDC hdc, CCcs *pccs, TEXTMETRIC *ptm ); static BOOL WINAPI EnableScrollBar( HWND hWnd, UINT wSBflags, UINT wArrows ); static BOOL WINAPI ShowScrollBar( HWND hWnd, int wBar, BOOL bShow, LONG nMax ); static BOOL WINAPI IsEnhancedMetafileDC( HDC hdc ); static HPALETTE WINAPI ManagePalette( HDC hdc, CONST LOGPALETTE *plogpal, HPALETTE &hpalOld, HPALETTE &hpalNew ); static UINT WINAPI SetTextAlign( HDC hdc, UINT fMode ); static BOOL WINAPI InvertRect( HDC hdc, CONST RECT *lprc ); static BOOL PtInRect(const RECT *prc, POINT pt) { return ::PtInRect(prc, pt); } static BOOL PtInRect(const RECTUV *prc, POINTUV pt) { POINT ptxy = {pt.u, pt.v}; return ::PtInRect((RECT*) prc, ptxy); } static void InflateRect(RECT *prc, int dxp, int dyp) { ::InflateRect(prc, dxp, dyp); } static void InflateRect(RECTUV *prc, int dup, int dvp) { ::InflateRect((RECT*) prc, dup, dvp); } static BOOL IntersectRect(RECT *prcDest, CONST RECT *prc1, CONST RECT *prc2) { return ::IntersectRect(prcDest, prc1, prc2); } static BOOL IntersectRect(RECTUV *prcDest, CONST RECTUV *prc1, CONST RECTUV *prc2) { return ::IntersectRect((RECT*) prcDest, (RECT*) prc1, (RECT*) prc2); } static void GetFacePriCharSet(HDC hdc, LOGFONT* plf); static BOOL WINAPI WinLPtoDP(HDC hdc, LPPOINT lppoints, int nCount); static BOOL WINAPI WinDPtoLP(HDC hdc, LPPOINT lppoints, int nCount); static long WINAPI WvsprintfA(LONG cb, LPSTR szBuf, LPCSTR szFmt, va_list arglist); static int WINAPI MulDivFunc(int nNumber, int nNumerator, int nDenominator); static inline LONG HimetricToDevice(LONG z, LONG dzpInch) { return MulDivFunc(z, dzpInch, HIMETRIC_PER_INCH); } static inline LONG DeviceToHimetric(LONG z, LONG dzpInch) { return MulDivFunc(z, HIMETRIC_PER_INCH, dzpInch); } // // Case insensitive ASCII compare // static BOOL ASCIICompareI( const BYTE *pstr1, const BYTE *pstr2, int iCount ) { int i; for (i = 0; i < iCount && !((pstr1[i] ^ pstr2[i]) & ~0x20); i++) ; return i == iCount; } // // Allocate and convert a MultiByte string to a wide character string // Allocated strings must be freed with delete // static WCHAR *ConvertToWideChar( const char *pstr ) { int istrlen = 0; if(pstr) for (istrlen; pstr[istrlen]; istrlen++); WCHAR *pnew = new WCHAR[istrlen + 1]; if(pnew && (!pstr || 0 != ::MultiByteToWideChar( CP_ACP, 0, pstr, -1, pnew, istrlen + 1))) { return pnew; } return NULL; } // // functions for memory and string management // #ifdef DEBUG static void PvSet(void *pv, char *szFile, int line); static PVOID PvAllocDebug(ULONG cbBuf, UINT uiMemFlags, char *szFile, int line); static PVOID PvReAllocDebug(PVOID pvBuf, DWORD cbBuf, char *szFile, int line); static void FreePvDebug(PVOID pvBuf); #endif static PVOID PvAlloc(ULONG cbBuf, UINT uiMemFlags); static PVOID PvReAlloc(PVOID pvBuf, DWORD cbBuf); static void FreePv(PVOID pvBuf); static inline void *MoveMemory(void *dst, const void *src, size_t cb) { Assert(cb >= 0); return memmove(dst, src, cb); } static inline void *CopyMemory(void *dst, const void *src, size_t cb) { // Will work for overlapping regions Assert(cb >= 0); return MoveMemory(dst, src, cb); } static inline void *FillMemory(void *dst, int fill, size_t cb) { return memset(dst, fill, cb); } static inline void *ZeroMemory(void *dst, size_t cb) { Assert(cb >= 0); return memset(dst, 0, cb); } static inline int CompareMemory(const void *s1, const void *s2, size_t cb) { return memcmp(s1, s2, cb); } static size_t wcslen(const wchar_t *wcs); static wchar_t * wcscpy(wchar_t * dst, const wchar_t * src); static int wcscmp(const wchar_t * src, const wchar_t * dst); static int wcsicmp(const wchar_t * src, const wchar_t * dst); static wchar_t * wcsncpy (wchar_t * dest, const wchar_t * source, size_t count); static int wcsnicmp(const wchar_t *first, const wchar_t *last, size_t count); static unsigned long strtoul(const char *); #ifndef NOFEPROCESSING // ---------------------------------- // IME Support // ---------------------------------- static BOOL ImmInitialize( void ); static void ImmTerminate( void ); static LONG ImmGetCompositionStringA ( HIMC, DWORD, PVOID, DWORD, BOOL ); static LONG ImmGetCompositionStringW ( HIMC, DWORD, PVOID, DWORD, BOOL ); static HIMC ImmGetContext ( HWND, BOOL ); static BOOL ImmSetCompositionFontA ( HIMC, LPLOGFONTA, BOOL ); static BOOL ImmSetCompositionWindow ( HIMC, LPCOMPOSITIONFORM, BOOL ); static BOOL ImmReleaseContext ( HWND, HIMC, BOOL ); static DWORD ImmGetProperty ( HKL, DWORD, BOOL ); static BOOL ImmGetCandidateWindow ( HIMC, DWORD, LPCANDIDATEFORM, BOOL ); static BOOL ImmSetCandidateWindow ( HIMC, LPCANDIDATEFORM, BOOL ); static BOOL ImmNotifyIME ( HIMC, DWORD, DWORD, DWORD, BOOL ); static HIMC ImmAssociateContext ( HWND, HIMC, BOOL ); static UINT ImmGetVirtualKey ( HWND, BOOL ); static HIMC ImmEscape ( HKL, HIMC, UINT, PVOID, BOOL ); static BOOL ImmGetOpenStatus ( HIMC, BOOL ); static BOOL ImmSetOpenStatus ( HIMC, BOOL, BOOL ); static BOOL ImmGetConversionStatus ( HIMC, LPDWORD, LPDWORD, BOOL ); static BOOL ImmSetConversionStatus ( HIMC, DWORD, DWORD, BOOL ); static HWND ImmGetDefaultIMEWnd ( HWND , BOOL); static BOOL ImmSetCompositionStringW (HIMC, DWORD, PVOID, DWORD, PVOID, DWORD, BOOL); static BOOL ImmIsIME ( HKL, BOOL ); static BOOL FSupportSty ( UINT, UINT ); static const IMESTYLE * PIMEStyleFromAttr ( const UINT ); static const IMECOLORSTY * PColorStyleTextFromIMEStyle ( const IMESTYLE * ); static const IMECOLORSTY * PColorStyleBackFromIMEStyle ( const IMESTYLE * ); static BOOL FBoldIMEStyle ( const IMESTYLE * ); static BOOL FItalicIMEStyle ( const IMESTYLE * ); static BOOL FUlIMEStyle ( const IMESTYLE * ); static UINT IdUlIMEStyle ( const IMESTYLE * ); static COLORREF RGBFromIMEColorStyle ( const IMECOLORSTY * ); #endif // NOFEPROCESSING // ---------------------------------- // National Language Keyboard support // ---------------------------------- static HKL CheckChangeKeyboardLayout (BYTE iCharRep); static HKL ActivateKeyboard (LONG iCharRep); static QWORD GetCharFlags125x(WCHAR ch); static BOOL GetKeyboardFlag (WORD dwKeyMask, WORD wKey); static WORD GetKeyboardFlags () {return _wKeyboardFlags;} static HKL GetKeyboardLayout (DWORD dwThreadID); static DWORD GetKeyPadNumber () {return _dwNumKeyPad;} static WORD GetDeadKey () {return _wDeadKey;} static void InitKeyboardFlags (); static void RefreshKeyboardLayout (); static void ResetKeyboardFlag (WORD wFlag) {_wKeyboardFlags &= ~wFlag;} static void SetDeadKey (WORD wDeadKey) {_wDeadKey = wDeadKey;} static void SetKeyboardFlag (WORD wFlag) {_wKeyboardFlags |= wFlag;} static void SetKeyPadNumber (DWORD dwNum) {_dwNumKeyPad = dwNum;} static bool UsingHebrewKeyboard () {return PRIMARYLANGID(_hklCurrent) == LANG_HEBREW;} static void InitPreferredFontInfo(); static bool SetPreferredFontInfo( int iCharRep, bool fUIFont, SHORT iFont, BYTE yHeight, BYTE bPitchAndFamily ); static bool GetPreferredFontInfo( int iCharRep, bool fUIFont, SHORT& iFont, BYTE& yHeight, BYTE& bPitchAndFamily ); static bool IsExternalFontCheckActive() {return false;} static bool GetExternalPreferredFontInfo( const WCHAR *pch, LONG cch, BYTE & iCharRep, SHORT & iFont, BYTE & bPitchAndFamily, bool fUIFont ) { return false;} static int GetTextCharsetInfo( HDC hdc, // handle to device context LPFONTSIGNATURE lpSig, // pointer to structure to receive data DWORD dwFlags // reserved; must be zero ); static SHORT GetPreferredFontHeight( bool fUIFont, BYTE iCharRepOrg, BYTE iCharRepNew, SHORT yOrgHeight ); static void CheckInstalledFEFonts(); static void CheckInstalledKeyboards(); static bool IsFontAvail( HDC hDC, int iCharRep, bool fUIFont = false, short *piFontIndex = NULL, WCHAR *pFontName = NULL); static bool IsDefaultFontDefined(LONG iCharRep, bool fUIFont, SHORT &iFont); #ifndef NOFEPROCESSING static bool IsFEFontInSystem( int cpg ); static UINT GetFEFontInfo( void ); static int IsFESystem() { return IsFELCID( _syslcid ); } #else static bool IsFEFontInSystem( int ) { return FALSE; } static UINT GetFEFontInfo( void ) { return 0; }; static int IsFESystem() { return FALSE; } #endif // Helper routines to get data from temp display attributes array static short GetTmpDisplayAttrIdx(TMPDISPLAYATTR &tmpDisplayAttr); static short GetTmpUnderline(SHORT idx); static bool GetTmpColor(SHORT idx, COLORREF &crTmpColor, INT iAction); #ifndef NOACCESSIBILITY // ---------------------------------- // Accessability Support // ---------------------------------- static HRESULT VariantCopy(VARIANTARG FAR* pvargDest, VARIANTARG FAR* pvargSrc); static LRESULT LResultFromObject(REFIID riid, WPARAM wParam, LPUNKNOWN punk); static HRESULT CreateStdAccessibleProxyW(HWND hwnd, LPCWSTR pClassName, LONG idObject, REFIID riid, void** ppvObject); static HRESULT AccessibleObjectFromWindow(HWND hWnd, DWORD dwID, REFIID riidInterface, void ** ppvObject); static BOOL BlockInput(BOOL fBlock); static UINT SendInput(UINT nInputs, LPINPUT pInputs, int cbSize); static VOID NotifyWinEvent(DWORD dwEvent, HWND hWnd, LONG lObjectType, LONG lObjectId); #endif // ---------------------------------- // OLE Support // ---------------------------------- static HRESULT LoadRegTypeLib ( REFGUID, WORD, WORD, LCID, ITypeLib ** ); static HRESULT LoadTypeLib ( const OLECHAR *, ITypeLib ** ); static HRESULT LoadTypeLibEx( LPCOLESTR szFile, REGKIND regkind, ITypeLib ** pptlib ); static BSTR SysAllocString ( const OLECHAR * ); static BSTR SysAllocStringLen ( const OLECHAR *, UINT ); static void SysFreeString ( BSTR ); static UINT SysStringLen ( BSTR ); static void VariantInit ( VARIANTARG * ); static void VariantClear ( VARIANTARG * ); static HRESULT OleCreateFromData ( LPDATAOBJECT, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, void ** ); static void CoTaskMemFree ( PVOID ); static HRESULT CreateBindCtx ( DWORD, LPBC * ); static HANDLE OleDuplicateData ( HANDLE, CLIPFORMAT, UINT ); static HRESULT CoTreatAsClass ( REFCLSID, REFCLSID ); static HRESULT ProgIDFromCLSID ( REFCLSID, LPOLESTR * ); static HRESULT OleConvertIStorageToOLESTREAM ( LPSTORAGE, LPOLESTREAM ); static HRESULT OleConvertIStorageToOLESTREAMEx ( LPSTORAGE, CLIPFORMAT, LONG, LONG, DWORD, LPSTGMEDIUM, LPOLESTREAM ); static HRESULT OleSave ( LPPERSISTSTORAGE, LPSTORAGE, BOOL ); static HRESULT StgCreateDocfileOnILockBytes ( ILockBytes *, DWORD, DWORD, IStorage ** ); static HRESULT CreateILockBytesOnHGlobal ( HGLOBAL, BOOL, ILockBytes ** ); static HRESULT OleCreateLinkToFile ( LPCOLESTR, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, void ** ); static PVOID CoTaskMemAlloc ( ULONG ); static PVOID CoTaskMemRealloc ( PVOID, ULONG ); static HRESULT OleInitialize ( PVOID ); static void OleUninitialize ( ); static HRESULT OleSetClipboard ( IDataObject * ); static HRESULT OleFlushClipboard ( ); static HRESULT OleIsCurrentClipboard ( IDataObject * ); static HRESULT DoDragDrop ( IDataObject *, IDropSource *, DWORD, DWORD * ); static HRESULT OleGetClipboard ( IDataObject ** ); static HRESULT RegisterDragDrop ( HWND, IDropTarget * ); static HRESULT OleCreateLinkFromData ( IDataObject *, REFIID, DWORD, LPFORMATETC, IOleClientSite *, IStorage *, void ** ); static HRESULT OleCreateStaticFromData ( IDataObject *, REFIID, DWORD, LPFORMATETC, IOleClientSite *, IStorage *, void ** ); static HRESULT OleDraw ( IUnknown *, DWORD, HDC, LPCRECT ); static HRESULT OleSetContainedObject ( IUnknown *, BOOL ); static HRESULT CoDisconnectObject ( IUnknown *, DWORD ); static HRESULT WriteFmtUserTypeStg ( IStorage *, CLIPFORMAT, LPOLESTR ); static HRESULT WriteClassStg ( IStorage *, REFCLSID ); static HRESULT SetConvertStg ( IStorage *, BOOL ); static HRESULT ReadFmtUserTypeStg ( IStorage *, CLIPFORMAT *, LPOLESTR * ); static HRESULT ReadClassStg ( IStorage *pstg, CLSID * ); static HRESULT OleRun ( IUnknown * ); static HRESULT RevokeDragDrop ( HWND ); static HRESULT CreateStreamOnHGlobal ( HGLOBAL, BOOL, IStream ** ); static HRESULT GetHGlobalFromStream ( IStream *pstm, HGLOBAL * ); static HRESULT OleCreateDefaultHandler ( REFCLSID, IUnknown *, REFIID, void ** ); static HRESULT CLSIDFromProgID ( LPCOLESTR, LPCLSID ); static HRESULT OleConvertOLESTREAMToIStorage ( LPOLESTREAM, IStorage *, const DVTARGETDEVICE * ); static HRESULT OleLoad ( IStorage *, REFIID, IOleClientSite *, void ** ); static HRESULT ReleaseStgMedium ( LPSTGMEDIUM ); static HRESULT CoCreateInstance (REFCLSID rclsid, LPUNKNOWN pUnknown, DWORD dwClsContext, REFIID riid, PVOID *ppv); static HRESULT OleCreateFromFile (REFCLSID, LPCOLESTR, REFIID, DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, LPVOID *); static void FreeOle(); #ifndef NOFEPROCESSING static void FreeIME(); static BOOL HaveIMEShare(); static BOOL getIMEShareObject(CIMEShare **ppIMEShare); static BOOL IsAIMMLoaded() { return _fHaveAIMM; } static BOOL GetAimmObject(IUnknown **ppAimm); static BOOL LoadAIMM(BOOL fUseAimm12); static HRESULT AIMMDefWndProc(HWND hWnd, UINT msg, WPARAM wparam, LPARAM lparam, LRESULT *plres); static HRESULT AIMMGetCodePage (HKL hKL, UINT *uCodePage); static HRESULT AIMMActivate (BOOL fRestoreLayout); static HRESULT AIMMDeactivate (void); static HRESULT AIMMFilterClientWindows(ATOM *aaClassList, UINT uSize, HWND hWnd); static HRESULT AIMMUnfilterClientWindows(HWND hWnd); static UINT GetDisplayGUID (HIMC hIMC, UINT uAttribute); #endif // NOFEPROCESSING int __cdecl sprintf(char * buff, char *fmt, ...); #ifdef DEBUG int __cdecl strcmp(const char *, const char *); char * __cdecl strrchr(const char *, int); char * __cdecl strcat(char *, const char *); #endif // ---------------------------------- // Useful ANSI<-->Unicode conversion // and language id routines // ---------------------------------- static int MbcsFromUnicode(LPSTR pstr, int cch, LPCWSTR pwstr, int cwch = -1, UINT codepage = CP_ACP, UN_FLAGS flags = UN_CONVERT_WCH_EMBEDDING); static int UnicodeFromMbcs(LPWSTR pwstr, int cwch, LPCSTR pstr, int cch = -1, UINT uiCodePage = CP_ACP); static int MBTWC(INT CodePage, DWORD dwFlags, LPCSTR pstrMB, int cchMB, LPWSTR pstrWC, int cchWC, LPBOOL pfNoCodePage); static int WCTMB(INT CodePage, DWORD dwFlags, LPCWSTR pstrWC, int cchWC, LPSTR pstrMB, int cchMB, LPCSTR pchDefault, LPBOOL pfUsedDef, LPBOOL pfNoCodePage, BOOL fTestCodePage = FALSE); static int VerifyFEString(INT cpg, LPCWSTR pstrWC, int cchWC, BOOL fTestInputCpg); static HGLOBAL TextHGlobalAtoW( HGLOBAL hglobal ); static HGLOBAL TextHGlobalWtoA( HGLOBAL hglobal ); static LONG CharRepFontSig(QWORD qwFontSig, BOOL fFirstAvailable); static UINT CharRepFromLID(WORD lid, BOOL fPlane2 = FALSE); static LONG CharRepFromCharSet(BYTE bCharSet); static INT CharRepFromCodePage(LONG CodePage); static LONG CharRepFromFontSig(QWORD qwFontSig) {return CharRepFontSig(qwFontSig, FALSE);} static BYTE CharSetFromCharRep(LONG iCharRep); static INT CodePageFromCharRep(LONG iCharRep); static QWORD FontSigFromCharRep(LONG iCharRep); #ifndef NOCOMPLEXSCRIPTS static HKL FindDirectionalKeyboard(BOOL fRTL); #else static HKL FindDirectionalKeyboard(BOOL fRTL) {return NULL;} #endif static BYTE GetCharSet(INT cpg, int *piCharRep = NULL); static BYTE MatchFECharRep(QWORD qwCharFlags, QWORD qwFontSig); static BYTE GetFirstAvailCharRep(QWORD qwFontSig) {return CharRepFontSig(qwFontSig, TRUE);} static UINT GetKeyboardCharRep(DWORD dwMakeAPICall = 0); static UINT GetKeyboardCodePage(DWORD dwMakeAPICall = 0) {return CodePageFromCharRep(GetKeyboardCharRep(dwMakeAPICall));} static LCID GetKeyboardLCID(DWORD dwMakeAPICall = 0); static UINT GetLocaleCharRep(); static HKL GetPreferredKbd(LONG iCharRep) {return _hkl[iCharRep];} static void SetPreferredKbd(LONG iCharRep, HKL hkl) {_hkl[iCharRep] = hkl;} static UINT GetSystemDefaultCodePage() {return CodePageFromCharRep(CharRepFromLID(GetSystemDefaultLangID()));} static int GetTrailBytesCount(BYTE ach, UINT cpg); static BOOL Is8BitCodePage(unsigned CodePage); static BOOL Is8BitCharRep(unsigned iCharRep) {return IN_RANGE(ANSI_INDEX, iCharRep, THAI_INDEX);} static BOOL IsAlef(WCHAR ch); static BOOL IsBiDiCharSet(unsigned CharSet) {return IN_RANGE(HEBREW_CHARSET, CharSet, ARABIC_CHARSET);} static BOOL IsBiDiCharRep(unsigned iCharRep) {return IN_RANGE(HEBREW_INDEX, iCharRep, ARABIC_INDEX) || IN_RANGE(SYRIAC_INDEX, iCharRep, THAANA_INDEX);} static BOOL IsIndicCharRep(unsigned iCharRep) {return IN_RANGE(INDIC_FIRSTINDEX, iCharRep, INDIC_LASTINDEX);} static bool IsBiDiCodePage(int cpg) {return IN_RANGE(CP_HEBREW, cpg, CP_ARABIC);} static bool IsBiDiKbdInstalled() {return _hkl[HEBREW_INDEX] || _hkl[ARABIC_INDEX];} static bool IsThaiKbdInstalled() {return _hkl[THAI_INDEX] != 0;} static bool IsIndicKbdInstalled(); static bool IsComplexKbdInstalled() {return IsBiDiKbdInstalled() || IsThaiKbdInstalled() || IsIndicKbdInstalled();} static bool IsVietnameseCodePage(int cpg) {return cpg == CP_VIETNAMESE;} static BOOL IsDiacritic(WCHAR ch); static BOOL IsBiDiDiacritic(WCHAR ch); static BOOL IsBiDiKashida(WCHAR ch) {return ch == 0x0640;} static BOOL IsBiDiLcid(LCID lcid); static BOOL IsIndicLcid(LCID lcid); static BOOL IsComplexScriptLcid(LCID lcid); #ifndef NOCOMPLEXSCRIPTS static BOOL IsDiacriticOrKashida(WCHAR ch, WORD wC3Type); #else static BOOL IsDiacriticOrKashida(WCHAR, WORD) { return FALSE; } #endif static bool IsFELCID(LCID lcid); static BOOL IsFECharSet (BYTE bCharSet); static BOOL IsFECharRep (BYTE iCharRep) {return IN_RANGE(SHIFTJIS_INDEX, iCharRep, BIG5_INDEX);} static bool IsFECodePage(int cpg) {return IN_RANGE(CP_JAPAN, cpg, CP_CHINESE_TRAD);} static BOOL IsFECodePageFont (DWORD dwFontSig); static BOOL IsRTLCharRep(BYTE iCharRep) {return IN_RANGE(HEBREW_INDEX, iCharRep, ARABIC_INDEX);} static BOOL IsRTLCharSet(BYTE bCharSet); BOOL IsStrongDirectional(CC cc) {return cc <= CC_LTR;} static BOOL IsVietCdmSequenceValid(WCHAR ch1, WCHAR ch2); static BOOL IsUTF8BOM(BYTE *pstr); static WPARAM ValidateStreamWparam(WPARAM wparam); static CC MECharClass(WCHAR ch); static HDC GetScreenDC(); // ---------------------------------- // Unicode Wrapped Functions // ---------------------------------- // We could use inline and a function pointer table to improve efficiency and code size. static ATOM WINAPI RegisterREClass( const WNDCLASSW *lpWndClass ); static BOOL GetVersion( DWORD *pdwPlatformId, DWORD *pdwMajorVersion, DWORD *pdwMinorVersion ); static BOOL GetStringTypes( LCID lcid, LPCTSTR lpSrcStr, int cchSrc, LPWORD lpCharType1, LPWORD lpCharType3 ); static BOOL WINAPI GetStringTypeEx( LCID Locale, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType ); static LPWSTR WINAPI CharLower(LPWSTR pwstr); static DWORD WINAPI CharLowerBuff(LPWSTR pwstr, DWORD cchLength); static DWORD WINAPI CharUpperBuff(LPWSTR pwstr, DWORD cchLength); static HDC WINAPI CreateIC( LPCWSTR lpszDriver, LPCWSTR lpszDevice, LPCWSTR lpszOutput, CONST DEVMODEW * lpInitData ); static HANDLE WINAPI CreateFile( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ); static HFONT WINAPI CreateFontIndirect(CONST LOGFONTW * plfw); static int WINAPI CompareString ( LCID Locale, // locale identifier DWORD dwCmpFlags, // comparison-style options LPCWSTR lpString1, // pointer to first string int cch1, // size, in bytes or characters, of first string LPCWSTR lpString2, // pointer to second string int cch2 // size, in bytes or characters, of second string ); static LRESULT WINAPI DefWindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); static int WINAPI GetObject(HGDIOBJ hgdiObj, int cbBuffer, PVOID lpvObj); static DWORD APIENTRY GetProfileSection( LPCWSTR lpAppName, LPWSTR lpReturnedString, DWORD nSize ); static int WINAPI GetTextFace( HDC hdc, int cch, LPWSTR lpFaceName ); static BOOL WINAPI GetTextMetrics(HDC hdc, LPTEXTMETRICW lptm); static BOOL WINAPI GetTextMetrics(HDC hdc, LOGFONTW &lf, TEXTMETRICW &tm); static LONG WINAPI GetWindowLong(HWND hWnd, int nIndex); static LONG_PTR WINAPI GetWindowLongPtr(HWND hWnd, int nIndex); static DWORD WINAPI GetClassLong(HWND hWnd, int nIndex); static HBITMAP WINAPI LoadBitmap(HINSTANCE hInstance, LPCWSTR lpBitmapName); static HBITMAP WINAPI GetPictureBitmap(IStream *pstm); static HCURSOR WINAPI LoadCursor(HINSTANCE hInstance, LPCWSTR lpCursorName); static HINSTANCE WINAPI LoadLibrary(LPCWSTR lpLibFileName); static LRESULT WINAPI SendMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ); static LONG WINAPI SetWindowLong(HWND hWnd, int nIndex, LONG dwNewLong); static LONG WINAPI SetWindowLongPtr(HWND hWnd, int nIndex, LONG_PTR dwNew); static BOOL WINAPI PostMessage( HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam ); static BOOL WINAPI UnregisterClass(LPCWSTR lpClassName, HINSTANCE hInstance); static int WINAPI lstrcmpi(LPCWSTR lpString1, LPCWSTR lpString2); static BOOL WINAPI PeekMessage( LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax, UINT wRemoveMsg ); static DWORD WINAPI GetModuleFileName( HMODULE hModule, LPWSTR lpFilename, DWORD nSize ); static DWORD GetCurrentThreadId(void); static BOOL TrackMouseLeave(HWND hWnd); static COLORREF GetCtlBorderColor(BOOL fMousedown, BOOL fMouseover); static COLORREF GetCtlBkgColor(BOOL fMousedown, BOOL fMouseover); static COLORREF GetCtlTxtColor(BOOL fMousedown, BOOL fMouseover, BOOL fDisabled); static void DrawBorderedRectangle( HDC hdc, RECT *prc, COLORREF crBorder, COLORREF crBackground ); static void DrawArrow( HDC hdc, RECT *prc, COLORREF crArrow ); private: // System Parameters static BOOL _fSysParamsOk; // System Parameters have been Initialized static INT _dupSystemFont; // average char width of system font static INT _dvpSystemFont; // height of system font static INT _ySysFontLeading; // System font internal leading static BOOL _fUsePalette; static LONG _xPerInchScreenDC; // Pixels per inch used for conversions ... static LONG _yPerInchScreenDC; // ... and determining whether screen or ... static INT _cxBorder; // GetSystemMetricx(SM_CXBORDER)... static INT _cyBorder; // GetSystemMetricx(SM_CYBORDER)... static INT _cxVScroll; // Width/height of scrlbar arw bitmap static INT _cyHScroll; // Width of scrlbar arw bitmap static LONG _dxSelBar; static INT _sysiniflags; // Start using line services from the start static UINT _ACP; // Current Ansi code page identifier static HDC _hdcScreen; // Double click distances static INT _cxDoubleClk; static INT _cyDoubleClk; // Double Click Time in milliseconds static INT _DCT; //Width of hot zone (in pixels) for auto-scrolling static WORD _nScrollInset; //Delay (in ms) before scrolling static WORD _nScrollDelay; //Interval (in ms) at which we scroll static WORD _nScrollInterval; //Amount of horizontal scroll at each interval (pixels) static WORD _nScrollHAmount; //Amount of vertical scroll at each interval (pixels) static WORD _nScrollVAmount; //Amount of time to wait for determining start of drag operation static WORD _nDragDelay; //Minimun distance that must be traversed within drag delay time interval static WORD _nDragMinDist; //Keyboard deadkey static WORD _wDeadKey; //Keyboard shift/ctrl/alt/lock status static WORD _wKeyboardFlags; //North/South sizing cursor (double arrow) static HCURSOR _hcurSizeNS; //West/East sizing cursor (double arrow) static HCURSOR _hcurSizeWE; //Northwest/Southeast sizing cursor (double arrow) static HCURSOR _hcurSizeNWSE; //Northeast/Southwest sizing cursor (double arrow) static HCURSOR _hcurSizeNESW; //Number of Lines to scroll with a mouse roller wheel, -1 for pages static LONG _cLineScroll; //System Font Handle. This one need only be done once. static HFONT _hSystemFont; //Default Font Handle. This one need only be done once. static HFONT _hDefaultFont; //System Keyboard Layout static HKL _hklCurrent; static HKL _hkl[NCHARREPERTOIRES]; // Ref Count static DWORD _cRefs; //AltNumericKeyboard number static DWORD _dwNumKeyPad; //Digit substitution mode (context, none, national) static BYTE _bDigitSubstMode; //SYSTEM_FONT charset static BYTE _bCharSetSys; public: static INT GetDupSystemFont() {return _dupSystemFont; } static INT GetDvpSystemFont() {return _dvpSystemFont; } static INT GetSysFontLeading() {return _ySysFontLeading; } static LONG GetXPerInchScreenDC(){return _xPerInchScreenDC; } static LONG GetYPerInchScreenDC(){return _yPerInchScreenDC; } static INT GetCxBorder() {return _cxBorder; } static INT GetCyBorder() {return _cyBorder; } static INT GetCyHScroll() {return _cyHScroll; } static INT GetCxVScroll() {return _cxVScroll; } static LONG GetDxSelBar() {return _dxSelBar; } static WORD GetScrollInset() {return _nScrollInset; } static WORD GetScrollDelay() {return _nScrollDelay; } static WORD GetScrollInterval() {return _nScrollInterval; } static WORD GetScrollHAmount() {return _nScrollHAmount; } static WORD GetScrollVAmount() {return _nScrollVAmount; } static INT GetCxDoubleClk() {return _cxDoubleClk; } static INT GetCyDoubleClk() {return _cyDoubleClk; } static INT GetDCT() {return _DCT; } static WORD GetDragDelay() {return _nDragDelay; } static WORD GetDragMinDist() {return _nDragMinDist; } static LONG GetRollerLineScrollCount(); static HCURSOR GetSizeCursor(LPTSTR idcur); static HFONT GetSystemFont() {return _hSystemFont; } static BYTE ReadRegDigitSubstitutionMode(); static BYTE GetDigitSubstitutionMode() {return _bDigitSubstMode;} static bool fUseAimm() {return (_sysiniflags & SYSINI_USEAIMM) != 0;} static bool fUseCTF() {return (_sysiniflags & SYSINI_USECTF) != 0;} static bool fUseBiDi() {return (_sysiniflags & SYSINI_BIDI) != 0;} static bool fUseLs() {return (_sysiniflags & SYSINI_USELS) != 0;} static bool fDebugFont() {return (_sysiniflags & SYSINI_DEBUGFONT) != 0;} static int DebugDefaultCpg() {return HIWORD(_sysiniflags);} static BOOL FUsePalette() {return _fUsePalette; } static void InitSysParams(BOOL fUpdate = FALSE); static DWORD GetRefs() {return _cRefs;} static BYTE GetSysCharSet() {return _bCharSetSys;} static BOOL IsForegroundFrame(HWND); // Should also be wrapped but aren't. Used for debugging. // MessageBox // OutputDebugString // lstrcmpiA should also be wrapped for Win CE's sake but the code // that uses it is ifdeffed out for WINCE. // Mirroring API entry points static PFN_GETLAYOUT _pfnGetLayout; static PFN_SETLAYOUT _pfnSetLayout; #ifndef NODRAFTMODE public: static bool GetDraftModeFontInfo( SHORT &iFont, SHORT &yHeight, QWORD &qwFontSig, COLORREF &crColor ); private: struct DraftModeFontInfo { SHORT _iFont; SHORT _yHeight; QWORD _qwFontSig; COLORREF _crTextColor; }; static struct DraftModeFontInfo _draftModeFontInfo; #endif }; extern CW32System *W32; HKL g_hkl[]; // This fixes a problem with MulDiv reference in _font.h #define W32MulDiv W32->MulDivFunc #if !defined(W32SYS_CPP) #define OnWinNTFE W32->OnWinNTFE #define OnWin95FE W32->OnWin95FE #if defined(DEBUG) #define PvAlloc(cbBuf, uiMemFlags) W32->PvAllocDebug(cbBuf, uiMemFlags, __FILE__, __LINE__) #define PvReAlloc(pv, cbBuf) W32->PvReAllocDebug(pv, cbBuf, __FILE__, __LINE__) #define PvSet(pv) W32->PvSet(pv, __FILE__, __LINE__) #define FreePv W32->FreePvDebug #else #define PvAlloc W32->PvAlloc #define PvReAlloc W32->PvReAlloc #define FreePv W32->FreePv #define PvSet(pv) #endif #define CopyMemory W32->CopyMemory #define MoveMemory W32->MoveMemory #define FillMemory W32->FillMemory #define ZeroMemory W32->ZeroMemory #define CompareMemory W32->CompareMemory #define GlobalAlloc W32->GlobalAlloc #define GlobalFree W32->GlobalFree #define GlobalFlags W32->GlobalFlags #define GlobalReAlloc W32->GlobalReAlloc #define GlobalSize W32->GlobalSize #define GlobalLock W32->GlobalLock #define GlobalHandle W32->GlobalHandle #define GlobalUnlock W32->GlobalUnlock #define ImmInitialize W32->ImmInitialize #define ImmTerminate W32->ImmTerminate #define ImmGetCompositionStringA W32->ImmGetCompositionStringA #define ImmGetCompositionStringW W32->ImmGetCompositionStringW #define ImmGetContext W32->ImmGetContext #define ImmSetCompositionFontA W32->ImmSetCompositionFontA #define ImmSetCompositionWindow W32->ImmSetCompositionWindow #define ImmReleaseContext W32->ImmReleaseContext #define ImmGetProperty W32->ImmGetProperty #define ImmGetCandidateWindow W32->ImmGetCandidateWindow #define ImmSetCandidateWindow W32->ImmSetCandidateWindow #define ImmNotifyIME W32->ImmNotifyIME #define ImmAssociateContext W32->ImmAssociateContext #define ImmGetVirtualKey W32->ImmGetVirtualKey #define ImmEscape W32->ImmEscape #define ImmGetOpenStatus W32->ImmGetOpenStatus #define ImmSetOpenStatus W32->ImmSetOpenStatus #define ImmGetConversionStatus W32->ImmGetConversionStatus #define ImmSetConversionStatus W32->ImmSetConversionStatus #define ImmGetDefaultIMEWnd W32->ImmGetDefaultIMEWnd #define ImmSetCompositionStringW W32->ImmSetCompositionStringW #define ImmIsIME W32->ImmIsIME #define LoadRegTypeLib W32->LoadRegTypeLib #define LoadTypeLib W32->LoadTypeLib #define SysAllocString W32->SysAllocString #define SysAllocStringLen W32->SysAllocStringLen #define SysFreeString W32->SysFreeString #define SysStringLen W32->SysStringLen #define VariantInit W32->VariantInit #define VariantClear W32->VariantClear #define OleCreateFromData W32->OleCreateFromData #define CoTaskMemFree W32->CoTaskMemFree #define CreateBindCtx W32->CreateBindCtx #define OleDuplicateData W32->OleDuplicateData #define CoTreatAsClass W32->CoTreatAsClass #define ProgIDFromCLSID W32->ProgIDFromCLSID #define OleConvertIStorageToOLESTREAM W32->OleConvertIStorageToOLESTREAM #define OleConvertIStorageToOLESTREAMEx W32->OleConvertIStorageToOLESTREAMEx #define OleSave W32->OleSave #define StgCreateDocfileOnILockBytes W32->StgCreateDocfileOnILockBytes #define CreateILockBytesOnHGlobal W32->CreateILockBytesOnHGlobal #define OleCreateLinkToFile W32->OleCreateLinkToFile #define CoTaskMemAlloc W32->CoTaskMemAlloc #define CoTaskMemRealloc W32->CoTaskMemRealloc #define OleInitialize W32->OleInitialize #define OleUninitialize W32->OleUninitialize #define OleSetClipboard W32->OleSetClipboard #define OleFlushClipboard W32->OleFlushClipboard #define OleIsCurrentClipboard W32->OleIsCurrentClipboard #define DoDragDrop W32->DoDragDrop #define OleGetClipboard W32->OleGetClipboard #define RegisterDragDrop W32->RegisterDragDrop #define OleCreateLinkFromData W32->OleCreateLinkFromData #define OleCreateStaticFromData W32->OleCreateStaticFromData #define OleDraw W32->OleDraw #define OleSetContainedObject W32->OleSetContainedObject #define CoDisconnectObject W32->CoDisconnectObject #define WriteFmtUserTypeStg W32->WriteFmtUserTypeStg #define WriteClassStg W32->WriteClassStg #define SetConvertStg W32->SetConvertStg #define ReadFmtUserTypeStg W32->ReadFmtUserTypeStg #define ReadClassStg W32->ReadClassStg #define OleRun W32->OleRun #define RevokeDragDrop W32->RevokeDragDrop #define CreateStreamOnHGlobal W32->CreateStreamOnHGlobal #define GetHGlobalFromStream W32->GetHGlobalFromStream #define OleCreateDefaultHandler W32->OleCreateDefaultHandler #define CLSIDFromProgID W32->CLSIDFromProgID #define OleConvertOLESTREAMToIStorage W32->OleConvertOLESTREAMToIStorage #define OleLoad W32->OleLoad #define ReleaseStgMedium W32->ReleaseStgMedium #define CoCreateInstance W32->CoCreateInstance #ifndef NOFEPROCESSING #define FSupportSty W32->FSupportSty #define PIMEStyleFromAttr W32->PIMEStyleFromAttr #define PColorStyleTextFromIMEStyle W32->PColorStyleTextFromIMEStyle #define PColorStyleBackFromIMEStyle W32->PColorStyleBackFromIMEStyle #define FBoldIMEStyle W32->FBoldIMEStyle #define FItalicIMEStyle W32->FItalicIMEStyle #define FUlIMEStyle W32->FUlIMEStyle #define IdUlIMEStyle W32->IdUlIMEStyle #define RGBFromIMEColorStyle W32->RGBFromIMEColorStyle #endif // NOFEPROCESSING #define fHaveIMMProcs W32->_fHaveIMMProcs #define fHaveAIMM W32->_fHaveAIMM #define fLoadAIMM10 W32->_fLoadAIMM10 #define dwPlatformId W32->_dwPlatformId #define icr3DDarkShadow W32->_icr3DDarkShadow #define MSIMEMouseMsg W32->_MSIMEMouseMsg #define MSIMEReconvertMsg W32->_MSIMEReconvertMsg #define MSIMEReconvertRequestMsg W32->_MSIMEReconvertRequestMsg #define MSIMEDocFeedMsg W32->_MSIMEDocFeedMsg #define MSIMEQueryPositionMsg W32->_MSIMEQueryPositionMsg #define MSIMEServiceMsg W32->_MSIMEServiceMsg #define CharRepFromCharSet W32->CharRepFromCharSet #define CharRepFromCodePage W32->CharRepFromCodePage #define CharSetFromCharRep W32->CharSetFromCharRep #define CodePageFromCharRep W32->CodePageFromCharRep #define MECharClass W32->MECharClass #define MbcsFromUnicode W32->MbcsFromUnicode #define UnicodeFromMbcs W32->UnicodeFromMbcs #define TextHGlobalAtoW W32->TextHGlobalAtoW #define TextHGlobalWtoA W32->TextHGlobalWtoA #define CharRepFromLID W32->CharRepFromLID #define In125x W32->In125x #define Is8BitCharRep W32->Is8BitCharRep #define Is8BitCodePage W32->Is8BitCodePage #define IsAlef W32->IsAlef #define IsAmbiguous W32->IsAmbiguous #define IsBiDiCharRep W32->IsBiDiCharRep #define IsBiDiCharSet W32->IsBiDiCharSet #define IsBiDiDiacritic W32->IsBiDiDiacritic #define IsBiDiKashida W32->IsBiDiKashida #define IsBiDiKbdInstalled W32->IsBiDiKbdInstalled #define IsDiacritic W32->IsDiacritic #define IsDiacriticOrKashida W32->IsDiacriticOrKashida #define IsFECharRep W32->IsFECharRep #define IsFECharSet W32->IsFECharSet #define IsFELCID W32->IsFELCID #define IsRTLCharRep W32->IsRTLCharRep #define IsRTLCharSet W32->IsRTLCharSet #define IsStrongDirectional W32->IsStrongDirectional #define IsThaiKbdInstalled W32->IsThaiKbdInstalled #define IsIndicKbdInstalled W32->IsIndicKbdInstalled #define IsComplexKbdInstalled W32->IsComplexKbdInstalled #define IsTrailByte W32->IsTrailByte #define IsVietCdmSequenceValid W32->IsVietCdmSequenceValid #define GetCharSet W32->GetCharSet #define FontSigFromCharRep W32->FontSigFromCharRep #define GetFirstAvailCharRep W32->GetFirstAvailCharRep #define MatchFECharRep W32->MatchFECharRep #define GetKeyboardCharRep W32->GetKeyboardCharRep #define GetKeyboardCodePage W32->GetKeyboardCodePage #define GetKeyboardLCID W32->GetKeyboardLCID #define GetLocaleCharRep W32->GetLocaleCharRep #define GetSystemDefaultCodePage W32->GetSystemDefaultCodePage #define GetTrailBytesCount W32->GetTrailBytesCount #define MBTWC W32->MBTWC #define WCTMB W32->WCTMB #define VerifyFEString W32->VerifyFEString #define GetKerningPairs W32->GetKerningPairs #define CharLower W32->CharLower #define CharLowerBuff W32->CharLowerBuff #define CharUpperBuff W32->CharUpperBuff #define CreateIC W32->CreateIC #define CreateFile W32->CreateFile #define CreateFontIndirect W32->CreateFontIndirect #define CompareString W32->CompareString #define DefWindowProc W32->DefWindowProc #define GetDeadKey W32->GetDeadKey #define GetKeyboardFlag W32->GetKeyboardFlag #define GetKeyboardFlags W32->GetKeyboardFlags #define GetKeyboardLayout W32->GetKeyboardLayout #define GetKeyPadNumber W32->GetKeyPadNumber #define GetProfileSection W32->GetProfileSection #define GetTextMetrics W32->GetTextMetrics #define GetTextFace W32->GetTextFace #define GetWindowLong W32->GetWindowLong #define GetWindowLongPtr W32->GetWindowLongPtr #define GetClassLong W32->GetClassLong #define InitKeyboardFlags W32->InitKeyboardFlags #define IsEnhancedMetafileDC W32->IsEnhancedMetafileDC #define LoadBitmap W32->LoadBitmap #define LoadCursor W32->LoadCursor #define LoadLibrary W32->LoadLibrary #define ResetKeyboardFlag W32->ResetKeyboardFlag #define SendMessage W32->SendMessage #define SetDeadKey W32->SetDeadKey #define SetKeyboardFlag W32->SetKeyboardFlag #define SetKeyPadNumber W32->SetKeyPadNumber #define SetWindowLong W32->SetWindowLong #define SetWindowLongPtr W32->SetWindowLongPtr #define PostMessage W32->PostMessage #define lstrcmpi W32->lstrcmpi #define PeekMessage W32->PeekMessage #define WinLPtoDP W32->WinLPtoDP #define WinDPtoLP W32->WinDPtoLP #define MulDiv W32->MulDivFunc #define InflateRect W32->InflateRect #define PtInRect W32->PtInRect #define IntersectRect W32->IntersectRect #define InflateRect W32->InflateRect #define PtInRect W32->PtInRect #define IntersectRect W32->IntersectRect // AIMM wrapper #define IsAIMMLoaded W32->IsAIMMLoaded #define LoadAIMM W32->LoadAIMM #define CallAIMMDefaultWndProc W32->AIMMDefWndProc #define GetAIMMKeyboardCP W32->AIMMGetCodePage #define ActivateAIMM W32->AIMMActivate #define DeactivateAIMM W32->AIMMDeactivate #define FilterClientWindowsAIMM W32->AIMMFilterClientWindows #define UnfilterClientWindowsAIMM W32->AIMMUnfilterClientWindows #define sprintf W32->sprintf #ifdef DEBUG #define strrchr W32->strrchr #define strcmp W32->strcmp #define strcat W32->strcat #endif #define wcslen W32->wcslen #define wcscpy W32->wcscpy #define wcscmp W32->wcscmp #define wcsicmp W32->wcsicmp #define wcsncpy W32->wcsncpy #define W32GetLayout (*W32->_pfnGetLayout) #define W32SetLayout (*W32->_pfnSetLayout) #define GetTmpTextColor(a, b) W32->GetTmpColor(a, b, GET_TEMP_TEXT_COLOR) #define GetTmpBackColor(a, b) W32->GetTmpColor(a, b, GET_TEMP_BACK_COLOR) #define GetTmpUnderlineColor(a, b) W32->GetTmpColor(a, b, GET_TEMP_UL_COLOR) #define GetTmpDisplayAttrIdx W32->GetTmpDisplayAttrIdx #define GetTmpUnderline W32->GetTmpUnderline #define GetACP W32->GetACP #define GetSysLCID W32->GetSysLCID #define SetTextAlign W32->SetTextAlign #define InvertRect W32->InvertRect #endif // !defined(W32SYS_CPP) #ifndef offsetof #define offsetof(s,m) ((size_t)&(((s*)0)->m)) #endif #ifdef UNDER_CE // The follwing definitions do not exist in the Windows CE environment but we emulate them. // The values have been copied from the appropriate win32 header files. // These definitions should be removed if Ce adds them // Scroll Bars #ifndef ESB_ENABLE_BOTH #define ESB_ENABLE_BOTH 0x0000 #define ESB_DISABLE_BOTH 0x0003 #endif // Text alignment values #ifndef TA_TOP #define TA_TOP 0 #define TA_BOTTOM 8 #define TA_BASELINE 24 #define TA_CENTER 6 #define TA_LEFT 0 #define TA_RIGHT 2 #endif // Device Technology. This one is mostly used for exclusion #ifndef DT_METAFILE #define DT_METAFILE 5 // Metafile, VDM #endif // FInd/Replace options #ifndef FR_DOWN #define FR_DOWN 0x00000001 #define FR_WHOLEWORD 0x00000002 #define FR_MATCHCASE 0x00000004 #endif // Window messages #ifndef WM_NCMOUSEMOVE #define WM_NCMOUSEMOVE 0x00A0 #endif #ifndef WM_NCMBUTTONDBLCLK #define WM_NCMBUTTONDBLCLK 0x00A9 #endif #ifndef WM_DROPFILES #define WM_DROPFILES 0x0233 #endif // Clipboard formats #ifndef CF_METAFILEPICT #define CF_METAFILEPICT 3 #endif /* Pen Styles : Windows CE only supports PS_DASH */ #ifndef PS_DOT #define PS_DOT PS_DASH #endif #ifndef PS_DASHDOT #define PS_DASHDOT PS_DASH #endif #ifndef PS_DASHDOTDOT #define PS_DASHDOTDOT PS_DASH #endif // Missing APIs #define GetMessageTime() 0 #define IsIconic(hwnd) 0 #define SetWindowOrgEx(hdc, xOrg, yOrg, pt) #define SetViewportExtEx(hdc, nX, nY, lpSize) #define SetWindowExtEx(hdc, x, y, lpSize) // Unsupported messages. // FUTURE : Perhaps we should ifdef the code the messages control #ifndef WS_EX_TRANSPARENT #define WS_EX_TRANSPARENT 0x00000020L #endif #ifndef WM_MOUSEACTIVATE #define WM_MOUSEACTIVATE 0x0021 #endif #ifndef WM_SYSCOLORCHANGE #define WM_SYSCOLORCHANGE 0x0015 #endif #ifndef WM_STYLECHANGING #define WM_STYLECHANGING 0x007C #endif #ifndef WM_WINDOWPOSCHANGING #define WM_WINDOWPOSCHANGING 0x0046 #endif #ifndef WM_SETCURSOR #define WM_SETCURSOR 0x0020 #endif #ifndef WM_NCPAINT #define WM_NCPAINT 0x0085 #endif #ifndef SM_SWAPBUTTON #define SM_SWAPBUTTON 23 #endif #ifndef TPM_RIGHTBUTTON #define TPM_RIGHTBUTTON 0x0002L #endif #define RegisterClipboardFormatA(s) RegisterClipboardFormatW(TEXT(s)) /* * EDITWORDBREAKPROC */ typedef int (CALLBACK* EDITWORDBREAKPROC)(LPWSTR lpch, int ichCurrent, int cch, int code); #ifndef WB_LEFT #define WB_LEFT 0 #define WB_RIGHT 1 #define WB_ISDELIMITER 2 #endif #ifndef OUT_TT_ONLY_PRECIS #define OUT_TT_ONLY_PRECIS 7 #endif // Mapping Modes : Win CE only supports MM_TEXT #ifndef MM_TEXT #define MM_TEXT 1 #define SetMapMode(hdc, mapmode) WINGDIAPI inline int WINAPI GetMapMode(HDC) { return MM_TEXT; } #endif #ifndef HANGUL_CHARSET #define HANGUL_CHARSET HANGEUL_CHARSET #endif #endif // UNDER_CE #endif // _W32SYS_H