mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1710 lines
55 KiB
1710 lines
55 KiB
/*
|
|
* _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<TMPDISPLAYATTR>
|
|
{
|
|
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
|