---------- NONSHIP\CTL3D\ctl3d.c (12-04-94@22:00) next ---------- 0a1,3648 > /*----------------------------------------------------------------------- > | > | CTL3D > | > | Copyright Microsoft Corporation 1992. All Rights Reserved. > | > | > | This module contains the functions to give windows controls a 3d effect > | > | This source is made public for your edification and debugging pleasure > | > | PLEASE do not make any changes or release private versions of this DLL > | send e-mail to me (wesc) if you have feature requests or bug fixes. > | > | Thanks -- Wes. > | > | > | History: > | 1-Jan-92 : Added OOM handling on GetDC (not really necessary but > | XL4 OOM failure testing made GetDC return NULL) > | > | 1-Jan-92 : Check wasn't getting redrawn when state changed in > | the default button proc. > | > | 29-Jan-92: If button has the focus and app is switched in, we weren't > | redrawing the entire button check & text. Force redraw > | of these on WM_SETFOCUS message. > | > | 3-Feb-92: Fixed switch in via task manager by erasing the buttons > | backgound on WM_SETFOCUS (detect this when wParam == NULL) > | > | 4-Apr-92: Make it work with OWNERDRAW buttons > | > | 22-Apr-92: Removed Excel specific code > | > | 19-May-92: Turn it into a DLL > | > | May-Jun92: Lots o' fixes & enhancements > | > | 23-Jun-92: Added support for hiding, sizing & moving > | > | 24-Jun-92: Make checks & radio button circles draw w/ window > | text color 'cause they are drawn on window bkgnd > | > | 30-Jun-92: (0.984) Fix bug where EnableWindow of StaticText doesn't > | redraw properly. Also disable ctl3d when verWindows > 3.1 > | > | 1-Jul-92: Added WIN32 support (davegi) (not in this source) > | > | 2-Jul-92: (0.984) Disable when verWindows >= 4.0 > | > | 20-Jul-92: (0.985) Draw focus rects of checks/radios properly on non > | default sized controls. > | > | 21-Jul-92: (0.990) Ctl3dAutoSubclass > | > | 21-Jul-92: (0.991) ported DaveGi's WIN32 support > | > | 22-Jul-92: (0.991) fixed Ctl3dCtlColor returning fFalse bug > | > | 4-Aug-92: (0.992) Graphic designers bug fixes...Now subclass > | regular buttons + disabled states for checks & radios > | > | 6-Aug-92: (0.993) Fix bug where activate via taskman & group > | box has focus, & not centering text in buttons > | > | 6-Aug-92: (0.993) Tweek drawing next to scroll bars. > | > | 13-Aug-92: (0.994) Fix button focus rect bug drawing due to > | Win 3.0 DrawText bug. > | > | 14-Aug-92: (1.0) Release of version 1.0 > | Don't draw default button border on BS_DEFPUSHBUTTON > | pushbuttons > | Fix bogus bug where Windows hangs when in a AUTORADIOBUTTON > | hold down space bar and hit arrow key. > | > | 23-Sep-92: (1.01) Made Ctl3dCtlColor call DefWindowProc so it works when > | called in a windproc. > | > | 28-Sep-92: (1.02) Added MyGetTextExtent so '&''s not considered in > | text extents. > | > | 08-Dec-92: (1.03) minor tweeks to the button text centering code > | for Publisher > | > | 11-Dec-92: (1.04) added 3d frames to dialogs > | > | 15-Dec-92: (1.05) fixed bug where group boxes redraw wrong when > | Window text is changed to something shorter > | > | ??-Dec-92: (1.06) added 3d borders > | > | 21-Dec-92: (1.07) added WM_DLGBORDER to disable borders > | > | 4-Jan-93: (1.08) fixed WM_SETTEXT bug w/ DLG frames & checks/checkboxes > | Also, WM_DLGSUBCLASS > | > | 22-Feb-93: (1.12) disabled it under Chicago > | > | 25-Feb-93: (1.13) re-add fix which allows dialog procs to > | handle WM_CTLCOLOR messages > | > | 26-April-93 (2.0) Changed to allow for second subclass. Now uses class instead of > | wndproc for subclass determination. > | store next wndproc in properties with global atoms > | > | 06-Jun-93 (2.0) Make a static linked library version. > | > | > -----------------------------------------------------------------------*/ > #include > > #ifdef _BORLAND > #include > #else > #include > #endif > > #include > #include "ctl3d.h" > > #include "stdio.h" > > /*----------------------------------------------------------------------- > |CTL3D Types > -----------------------------------------------------------------------*/ > #ifdef WIN32 > > #define Win32Only(e) e > #define Win16Only(e) > #define Win32Or16(e32, e16) e32 > #define Win16Or32(e16, e32) e32 > > #define _loadds > #define __export > > #define FValidLibHandle(hlib) ((hlib) != NULL) > > // > // No concept of far in Win32. > // > > #define MEMCMP memcmp > #define NPTSTR LPTSTR > > // > // Control IDs are LONG in Win32. > // > > typedef LONG CTLID; > #define GetControlId(hwnd) GetWindowLong(hwnd, GWL_ID) > > // > // Send a color button message. > // > > #define SEND_COLOR_BUTTON_MESSAGE( hwndParent, hwnd, hdc ) \ > ((HBRUSH) SendMessage(hwndParent, WM_CTLCOLORBTN, (WPARAM) hdc, (LPARAM) hwnd)) > > // > // Send a color static message. > // > > #define SEND_COLOR_STATIC_MESSAGE( hwndParent, hwnd, hdc ) \ > ((HBRUSH) SendMessage(hwndParent, WM_CTLCOLORSTATIC, (WPARAM) hdc, (LPARAM) hwnd)) > > #else > > #define CallWindowProcA CallWindowProc > #define DefWindowProcA DefWindowProc > > #define TEXT(a) a > #define TCHAR char > > #ifndef LPTSTR > #define LPTSTR LPSTR > #endif > #define LPCTSTR LPCSTR > #define NPTSTR NPSTR > > #define Win32Only(e) > #define Win16Only(e) e > #define Win32Or16(e32, e16) e16 > #define Win16Or32(e16, e32) e16 > > > #define FValidLibHandle(hlib) (( hlib ) > 32 ) > > #define MEMCMP _fmemcmp > > typedef WORD CTLID; > #define GetControlId(h) GetWindowWord(h, GWW_ID) > > #define SEND_COLOR_BUTTON_MESSAGE( hwndParent, hwnd, hdc ) \ > ((HBRUSH) SendMessage(hwndParent, WM_CTLCOLOR, (WORD) hdc, MAKELONG(hwnd, CTLCOLOR_BTN))) > > #define SEND_COLOR_STATIC_MESSAGE( hwndParent, hwnd, hdc ) \ > ((HBRUSH) SendMessage(hwndParent, WM_CTLCOLOR, (WORD) hdc, MAKELONG(hwnd, CTLCOLOR_STATIC))) > > > typedef struct > { > LPARAM lParam; > WPARAM wParam; > UINT message; > HWND hwnd; > } CWPSTRUCT; > > #endif // WIN32 > > // DBCS far east short cut key support > #define cchShortCutModeMax 10 > #define chShortCutSbcsPrefix '\036' > #define chShortCutDbcsPrefix '\037' > > #define cchClassMax 16 // max class is "combolbox"+NUL rounded up to 16 > > > #define Assert(f) > > #define PUBLIC > #define PRIVATE static > > #define fFalse 0 > #define fTrue 1 > > #define INCBTHOOK 1 > #define OUTCBTHOOK 0 > > #ifdef _BORLAND > #define CSCONST(type) type const > #define CodeLpszDecl(lpszVar, szLit) TCHAR *lpszVar = szLit > #define _alloca alloca > #define _memcmp memcmp > #else > #ifdef WIN32 > #define CSCONST(type) type const > #define CodeLpszDecl(lpszVar, szLit) TCHAR *lpszVar = szLit > #else > #define CSCONST(type) type _based(_segname("_CODE")) const > #define CodeLpszDecl(lpszVar, szLit) \ > static CSCONST(char) lpszVar##Code[] = szLit; \ > char far *lpszVar = (char far *)lpszVar##Code > #endif > #endif > > > // isomorphic to windows RECT > typedef struct > { > int xLeft; > int yTop; > int xRight; > int yBot; > } RC; > > > // Windows Versions (Byte order flipped from GetWindowsVersion) > #define ver30 0x0300 > #define ver31 0x030a > #define ver40 0x035F > > // Border widths > #define dxBorder 1 > #define dyBorder 1 > > > // Index Color Table > // WARNING: change mpicvSysColors if you change the icv order > typedef WORD ICV; > #define icvBtnHilite 0 > #define icvBtnFace 1 > #define icvBtnShadow 2 > > #define icvBrushMax 3 > > #define icvBtnText 3 > #define icvWindow 4 > #define icvWindowText 5 > #define icvGrayText 6 > #define icvWindowFrame 7 > #define icvMax 8 > > typedef COLORREF CV; > > // CoLoR Table > typedef struct > { > CV rgcv[icvMax]; > } CLRT; > > > // BRush Table > typedef struct > { > HBRUSH mpicvhbr[icvBrushMax]; > } BRT; > > > // DrawRec3d flags > #define dr3Left 0x0001 > #define dr3Top 0x0002 > #define dr3Right 0x0004 > #define dr3Bot 0x0008 > > #define dr3HackBotRight 0x1000 // code size is more important than aesthetics > #define dr3All 0x000f > typedef WORD DR3; > > > // Control Types > // Commdlg types are necessary because commdlg.dll subclasses certain > // controls before the app can call Ctl3dSubclassDlg. > #define ctButton 0 > #define ctList 1 > #define ctEdit 2 > #define ctCombo 3 > #define ctStatic 4 > #define ctComboLBox 5 > #define ctMax 6 > > // ConTroL > typedef struct > { > FARPROC lpfn; > WNDPROC lpfnDefProc; > TCHAR szClassName[cchClassMax]; > } CTL; > > // Control DEFinition > typedef struct > { > TCHAR sz[20]; > WNDPROC lpfnWndProc; > BOOL (* lpfnFCanSubclass)(HWND, LONG, WORD, WORD, HWND); > WORD msk; > } CDEF; > > // CLIent HooK > typedef struct > { > HANDLE hinstApp; > HANDLE htask; > HHOOK hhook; > int iCount; > DWORD dwFlags; > > } CLIHK; > > #ifdef WIN32 > #define iclihkMaxBig 1024 > #define iclihkMaxSmall 128 > #else > #define iclihkMaxBig 32 > #define iclihkMaxSmall 4 > #endif > > #ifdef DLL > #define iclihkMax iclihkMaxBig > #else > #ifdef SDLL > #define iclihkMax iclihkMaxBig > #else > #define iclihkMax iclihkMaxSmall > #define _loadds > #endif > #endif > > #ifdef SDLL > extern const HINSTANCE _hModule; > #endif > > // special styles > // #define bitFCoolButtons 0x0001 > > /*----------------------------------------------------------------------- > |CTL3D Function Prototypes > -----------------------------------------------------------------------*/ > PRIVATE VOID End3dDialogs(VOID); > PRIVATE BOOL FAR FInit3dDialogs(VOID); > PRIVATE BOOL DoSubclassCtl(HWND hwnd, WORD grbit, WORD wCallFlags, HWND hwndParent); > PRIVATE BOOL InternalCtl3dColorChange(BOOL fForce); > PRIVATE VOID DeleteObjectNull(HANDLE FAR *ph); > PRIVATE VOID DeleteObjects(VOID); > PRIVATE int IclihkFromHinst(HANDLE hinst); > > LRESULT __export _loadds WINAPI Ctl3dHook(int code, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI BtnWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI EditWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI ListWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI ComboWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI StaticWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI CDListWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > LRESULT __export _loadds WINAPI CDEditWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > WORD __export _loadds WINAPI Ctl3dSetStyle(HANDLE hinst, LPTSTR lpszName, WORD grbit); > > LRESULT __export _loadds WINAPI Ctl3dDlgProc(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam); > > BOOL FBtn(HWND, LONG, WORD, WORD, HWND); > BOOL FEdit(HWND, LONG, WORD, WORD, HWND); > BOOL FList(HWND, LONG, WORD, WORD, HWND); > BOOL FComboList(HWND, LONG, WORD, WORD, HWND); > BOOL FCombo(HWND, LONG, WORD, WORD, HWND); > BOOL FStatic(HWND, LONG, WORD, WORD, HWND); > > HBITMAP PASCAL LoadUIBitmap(HANDLE, LPCTSTR, COLORREF, COLORREF, COLORREF, COLORREF, COLORREF, COLORREF); > > #ifdef WIN32 > #ifdef DLL > BOOL CALLBACK LibMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved); > #else > #ifdef SDLL > FAR BOOL Ctl3dLibMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved); > #else > FAR BOOL LibMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved); > #endif > #endif > #else > #ifdef DLL > int WINAPI LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine); > #else > #ifdef SDLL > int FAR Ctl3dLibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine); > #else > #ifdef _BORLAND > int FAR PASCAL LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine); > #else > int FAR LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine); > #endif > #endif > #endif > #endif > > #ifndef _BORLAND > #ifndef WIN32 > #pragma alloc_text(INIT_TEXT, Ctl3dSetStyle) > #pragma alloc_text(INIT_TEXT, Ctl3dColorChange) > #pragma alloc_text(INIT_TEXT, Ctl3dGetVer) > #pragma alloc_text(INIT_TEXT, Ctl3dRegister) > #pragma alloc_text(INIT_TEXT, Ctl3dUnregister) > #pragma alloc_text(INIT_TEXT, Ctl3dAutoSubclass) > #pragma alloc_text(INIT_TEXT, Ctl3dEnabled) > #pragma alloc_text(INIT_TEXT, Ctl3dWinIniChange) > #pragma alloc_text(INIT_TEXT, DeleteObjects) > #pragma alloc_text(INIT_TEXT, DeleteObjectNull) > #pragma alloc_text(INIT_TEXT, InternalCtl3dColorChange) > #ifdef SDLL > #pragma alloc_text(INIT_TEXT, Ctl3dLibMain) > #else > #pragma alloc_text(INIT_TEXT, LibMain) > #endif > #pragma alloc_text(INIT_TEXT, FInit3dDialogs) > #pragma alloc_text(INIT_TEXT, End3dDialogs) > #pragma alloc_text(INIT_TEXT, LoadUIBitmap) > #pragma alloc_text(INIT_TEXT, IclihkFromHinst) > #endif > #endif > > #ifndef WIN32 > #ifdef DLL > int FAR PASCAL WEP(int); > #pragma alloc_text(WEP_TEXT, WEP) > #endif > #endif > > /*----------------------------------------------------------------------- > |CTL3D Globals > -----------------------------------------------------------------------*/ > //These static varables are only access when running 16 bit Windows or Win32s > //Since this is single threaded access they are OK to be statics and not protected. > // > static HHOOK hhookCallWndProcFilterProc; > static FARPROC lpfnSubclassByHook; > static HWND SubclasshWnd; > > #ifdef WIN32 > CRITICAL_SECTION g_CriticalSection; > #endif > > typedef struct _g3d > { > BOOL f3dDialogs; > int cInited; > ATOM aCtl3d; > ATOM aCtl3dHigh; > ATOM aCtl3dLow; > > ATOM aCtl3dDisable; > // module & windows stuff > HANDLE hinstLib; > HANDLE hmodLib; > WORD verWindows; > WORD verBase; > > // drawing globals > CLRT clrt; > BRT brt; > HBITMAP hbmpCheckboxes; > > // Hook cache > HANDLE htaskCache; > int iclihkCache; > int iclihkMac; > CLIHK rgclihk[iclihkMax]; > > // Control info > CTL mpctctl[ctMax]; > FARPROC lpfnDefDlgWndProc; > > // System Metrics > int dxFrame; > int dyFrame; > int dyCaption; > int dxSysMenu; > > // Windows functions > #ifndef WIN32 > #ifdef DLL > HHOOK (FAR PASCAL *lpfnSetWindowsHookEx)(int, HOOKPROC, HINSTANCE, HANDLE); > LRESULT (FAR PASCAL *lpfnCallNextHookEx)(HHOOK, int, WPARAM, LPARAM); > BOOL (FAR PASCAL *lpfnUnhookWindowsHookEx)(HHOOK); > #endif > #endif > > // DBCS stuff > char chShortCutPrefix; > char fDBCS; > > } G3D; > > G3D g3d; > > > CSCONST(CDEF) mpctcdef[ctMax] = > { > { TEXT("Button"), BtnWndProc3d, FBtn, CTL3D_BUTTONS }, > { TEXT("ListBox"), ListWndProc3d, FList, CTL3D_LISTBOXES }, > { TEXT("Edit"), EditWndProc3d, FEdit, CTL3D_EDITS }, > { TEXT("ComboBox"), ComboWndProc3d, FCombo, CTL3D_COMBOS}, > { TEXT("Static"), StaticWndProc3d, FStatic, CTL3D_STATICTEXTS|CTL3D_STATICFRAMES }, > { TEXT("ComboLBox"), ListWndProc3d, FComboList, CTL3D_LISTBOXES }, > }; > > > CSCONST (WORD) mpicvSysColor[] = > { > COLOR_BTNHIGHLIGHT, > COLOR_BTNFACE, > COLOR_BTNSHADOW, > COLOR_BTNTEXT, > COLOR_WINDOW, > COLOR_WINDOWTEXT, > COLOR_GRAYTEXT, > COLOR_WINDOWFRAME > }; > > > #define WM_CHECKSUBCLASS (WM_USER+5443) > > /*----------------------------------------------------------------------- > | CTL3D Utility routines > -----------------------------------------------------------------------*/ > > PRIVATE FARPROC LpfnGetDefWndProcNull(HWND hwnd) > { > if ( hwnd == NULL ) > return NULL; > > Win32Only(return (FARPROC) GetProp(hwnd, (LPCTSTR) g3d.aCtl3d)); > Win16Only(return (FARPROC) MAKELONG((UINT) GetProp(hwnd, (LPCSTR) g3d.aCtl3dLow), > GetProp(hwnd, (LPCSTR) g3d.aCtl3dHigh))); > } > > PRIVATE FARPROC LpfnGetDefWndProc(HWND hwnd, int ct) > { > FARPROC lpfnWndProc; > > lpfnWndProc = LpfnGetDefWndProcNull(hwnd); > if ( lpfnWndProc == NULL ) { > if ( ct == ctMax ) > { > lpfnWndProc = (FARPROC) g3d.lpfnDefDlgWndProc; > } > else > { > lpfnWndProc = (FARPROC) g3d.mpctctl[ct].lpfnDefProc; > } > > Win32Only(SetProp(hwnd, (LPCTSTR) g3d.aCtl3d, (HANDLE)(DWORD)lpfnWndProc)); > Win16Only(SetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow, LOWORD(lpfnWndProc))); > Win16Only(SetProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh, HIWORD(lpfnWndProc))); > } > return lpfnWndProc; > > } > > PRIVATE VOID SubclassWindow(HWND hwnd, FARPROC lpfnSubclassProc) > { > FARPROC lpfnWndProc; > > // Make sure we don't double subclass (16 | 32 bit subclass??) > if (GetProp(hwnd, (LPCTSTR) g3d.aCtl3d) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow)) > { > return; > } > > // Is this already subclassed by CTL3D? > if (LpfnGetDefWndProcNull(hwnd) == (FARPROC) NULL) > { > lpfnWndProc = (FARPROC)SetWindowLong((HWND) hwnd, GWL_WNDPROC, (LONG) lpfnSubclassProc); > Win32Only(SetProp(hwnd, (LPCTSTR) g3d.aCtl3d, (HANDLE)(DWORD)lpfnWndProc)); > Win16Only(SetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow, LOWORD(lpfnWndProc))); > Win16Only(SetProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh, HIWORD(lpfnWndProc))); > } > } > > LRESULT __export _loadds WINAPI CallWndProcFilterProc(int code, WPARAM wParam, LPARAM lParam) > { > CWPSTRUCT FAR *cwpStruct; > LONG l; > > cwpStruct = (CWPSTRUCT FAR *) lParam; > > l = CallNextHookEx(hhookCallWndProcFilterProc, code, wParam, lParam); > > if ( cwpStruct->hwnd == SubclasshWnd ) > { > UnhookWindowsHookEx(hhookCallWndProcFilterProc); > > SubclassWindow(cwpStruct->hwnd, lpfnSubclassByHook); > > hhookCallWndProcFilterProc = 0L; > lpfnSubclassByHook = NULL; > SubclasshWnd = NULL; > } > > return l; > } > > > PRIVATE VOID HookSubclassWindow(HWND hWnd, FARPROC lpfnSubclass) > { > // > // Windows 3.1 ( 16 bit ) and Win32s can't sublcass in > // WH_CBT hook. Must set up a MSG hook and subclasss at > // WM_GETMINMAXINFO ( for dialogs ) or WM_NCCREATE ( for controls ) > // Any other message and we are out of here. > // > // Notes from the inside: > // > // The only reason not to get the WM_GETMINMAXINFO/WM_NCCREATE message > // is if another CBT hook did not allow the window create. > // This code only runs/works on non multithreaded systems. Thus the global > // to hold the Hook Proc and subclass proc is OK. > // > > lpfnSubclassByHook = lpfnSubclass; > SubclasshWnd = hWnd; > > Win32Only(hhookCallWndProcFilterProc = SetWindowsHookEx(WH_CALLWNDPROC, (FARPROC)CallWndProcFilterProc, g3d.hmodLib, GetCurrentThreadId())); > Win16Only(hhookCallWndProcFilterProc = SetWindowsHookEx(WH_CALLWNDPROC, (FARPROC)CallWndProcFilterProc, g3d.hmodLib, GetCurrentTask())); > } > > PRIVATE LRESULT CleanupSubclass(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam, int ct) > { > FARPROC lpfnWinProc; > LRESULT lRet; > > lpfnWinProc = LpfnGetDefWndProc(hwnd, ct); > lRet = CallWindowProc(lpfnWinProc, hwnd, wm, wParam, lParam); > Win32Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3d)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dLow)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh)); > RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dDisable); > return lRet; > } > > > PRIVATE VOID DeleteObjectNull(HANDLE FAR *ph) > { > if (*ph != NULL) > { > DeleteObject(*ph); > *ph = NULL; > } > } > > PRIVATE VOID DeleteObjects(VOID) > { > int icv; > > for(icv = 0; icv < icvBrushMax; icv++) > DeleteObjectNull(&g3d.brt.mpicvhbr[icv]); > DeleteObjectNull(&g3d.hbmpCheckboxes); > } > > > PRIVATE VOID PatFill(HDC hdc, RC FAR *lprc) > { > PatBlt(hdc, lprc->xLeft, lprc->yTop, lprc->xRight-lprc->xLeft, lprc->yBot-lprc->yTop, PATCOPY); > } > > > /*----------------------------------------------------------------------- > | DrawRec3d > | > | > | Arguments: > | HDC hdc: > | RC FAR *lprc: > | LONG cvUL: > | LONG cvLR: > | WORD grbit; > | > | Returns: > | > -----------------------------------------------------------------------*/ > PRIVATE VOID DrawRec3d(HDC hdc, RC FAR *lprc, ICV icvUL, ICV icvLR, DR3 dr3) > { > COLORREF cvSav; > RC rc; > > cvSav = SetBkColor(hdc, g3d.clrt.rgcv[icvUL]); > > // top > rc = *lprc; > rc.yBot = rc.yTop+1; > if (dr3 & dr3Top) > ExtTextOut(hdc, 0, 0, ETO_OPAQUE, (LPRECT) &rc, > (LPCTSTR) NULL, 0, (int far *) NULL); > > // left > rc.yBot = lprc->yBot; > rc.xRight = rc.xLeft+1; > if (dr3 & dr3Left) > ExtTextOut(hdc, 0, 0, ETO_OPAQUE, (LPRECT) &rc, > (LPCTSTR) NULL, 0, (int far *) NULL); > > if (icvUL != icvLR) > SetBkColor(hdc, g3d.clrt.rgcv[icvLR]); > > // right > rc.xRight = lprc->xRight; > rc.xLeft = rc.xRight-1; > if (dr3 & dr3Right) > ExtTextOut(hdc, 0, 0, ETO_OPAQUE, (LPRECT) &rc, > (LPCTSTR) NULL, 0, (int far *) NULL); > > // bot > if (dr3 & dr3Bot) > { > rc.xLeft = lprc->xLeft; > rc.yTop = rc.yBot-1; > if (dr3 & dr3HackBotRight) > rc.xRight -=2; > ExtTextOut(hdc, 0, 0, ETO_OPAQUE, (LPRECT) &rc, > (LPCTSTR) NULL, 0, (int far *) NULL); > } > > SetBkColor(hdc, cvSav); > > } > > #ifdef CANTUSE > // Windows forces dialog fonts to be BOLD...URRRGH > PRIVATE VOID MyDrawText(HWND hwnd, HDC hdc, LPSTR lpch, int cch, RC FAR *lprc, int dt) > { > TEXTMETRIC tm; > BOOL fChisled; > > fChisled = fFalse; > if (!IsWindowEnabled(hwnd)) > { > GetTextMetrics(hdc, &tm); > if (tm.tmWeight > 400) > SetTextColor(hdc, g3d.clrt.rgcv[icvGrayText]); > else > { > fChisled = fTrue; > SetTextColor(hdc, g3d.clrt.rgcv[icvBtnHilite]); > OffsetRect((LPRECT) lprc, -1, -1); > } > } > DrawText(hdc, lpch, cch, (LPRECT) lprc, dt); > if (fChisled) > { > SetTextColor(hdc, g3d.clrt.rgcv[icvBtnHilite]); > OffsetRect((LPRECT) lprc, 1, 1); > DrawText(hdc, lpch, cch, (LPRECT) lprc, dt); > } > } > #endif > > > PRIVATE VOID DrawInsetRect3d(HDC hdc, RC FAR *prc, DR3 dr3) > { > RC rc; > > rc = *prc; > DrawRec3d(hdc, &rc, icvWindowFrame, icvBtnFace, (WORD)(dr3 & dr3All)); > rc.xLeft--; > rc.yTop--; > rc.xRight++; > rc.yBot++; > DrawRec3d(hdc, &rc, icvBtnShadow, icvBtnHilite, dr3); > } > > > PRIVATE VOID ClipCtlDc(HWND hwnd, HDC hdc) > { > RC rc; > > GetClientRect(hwnd, (LPRECT) &rc); > IntersectClipRect(hdc, rc.xLeft, rc.yTop, rc.xRight, rc.yBot); > } > > > PRIVATE int IclihkFromHinst(HANDLE hinst) > { > int iclihk; > > for (iclihk = 0; iclihk < g3d.iclihkMac; iclihk++) > if (g3d.rgclihk[iclihk].hinstApp == hinst) > return iclihk; > return -1; > } > > > PRIVATE VOID MyGetTextExtent(HDC hdc, LPTSTR lpsz, int FAR *lpdx, int FAR *lpdy) > { > LPTSTR lpch; > TCHAR szT[256]; > > lpch = szT; > while(*lpsz != '\000') > { > if (*lpsz == '&') > { > lpsz++; > if (*lpsz == '\000') > break; > } > //begin DBCS: far east short cut key support > else if (g3d.fDBCS) > { > if (*lpsz == g3d.chShortCutPrefix) > { // skip only prefix > lpsz++; > if (*lpsz == '\000') > break; > } > else if (*lpsz == chShortCutSbcsPrefix || *lpsz == chShortCutDbcsPrefix) > { // skip both prefix and short cut key > lpsz++; > if (*lpsz == '\000') > break; > lpsz = Win32Or16(CharNext(lpsz),AnsiNext(lpsz)); > continue; > } > } > //end DBCS > *lpch++ = *lpsz++; > } > *lpch = '\000'; > #ifdef WIN32 > { > SIZE pt; > > GetTextExtentPoint(hdc, szT, lstrlen(szT), &pt); > *lpdx = pt.cx; > *lpdy = pt.cy; > } > #else > { > long dwExt; > > dwExt = GetTextExtent(hdc, szT, lpch-(char far *)szT); > *lpdx = LOWORD(dwExt); > // Check for Hangeul Windows - JeeP 011194 > if ( (g3d.verWindows >= ver31 && GetSystemMetrics(SM_DBCSENABLED)) || > (IsDBCSLeadByte(0xa1) && !IsDBCSLeadByte(0xa0)) ) > *lpdy = HIWORD(dwExt)+1; > else > *lpdy = HIWORD(dwExt); > } > #endif > } > > > /*----------------------------------------------------------------------- > | CTL3D Publics > -----------------------------------------------------------------------*/ > > > PUBLIC BOOL WINAPI Ctl3dRegister(HANDLE hinstApp) > { > > #ifdef WIN32 > #ifndef DLL > InitializeCriticalSection(&g_CriticalSection); > #endif > EnterCriticalSection(&g_CriticalSection); > #endif > > g3d.cInited++; > > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > > if (g3d.cInited == 1) > { > #ifndef DLL > #ifdef SDLL > Win32Only(Ctl3dLibMain(hinstApp, DLL_PROCESS_ATTACH, (LPVOID) NULL)); > Win16Only(Ctl3dLibMain(hinstApp, 0, 0, (LPSTR) NULL)); > #else > Win32Only(LibMain(hinstApp, DLL_PROCESS_ATTACH, (LPVOID) NULL)); > Win16Only(LibMain(hinstApp, 0, 0, (LPSTR) NULL)); > #endif > #endif > FInit3dDialogs(); > } > > if (Ctl3dIsAutoSubclass()) > Ctl3dAutoSubclass(hinstApp); > > return g3d.f3dDialogs; > } > > > PUBLIC BOOL WINAPI Ctl3dUnregister(HANDLE hinstApp) > { > int iclihk; > HANDLE hTask; > > // > // Find the task's hook > // > Win32Only(hTask = (HANDLE)GetCurrentThreadId()); > Win16Only(hTask = GetCurrentTask()); > > Win32Only(EnterCriticalSection(&g_CriticalSection)); > > for (iclihk = 0; iclihk < g3d.iclihkMac; iclihk++) > { > if (g3d.rgclihk[iclihk].htask == hTask) > { > g3d.rgclihk[iclihk].iCount--; > if ( g3d.rgclihk[iclihk].iCount == 0 || hinstApp == g3d.rgclihk[iclihk].hinstApp) > { > Win32Only(UnhookWindowsHookEx(g3d.rgclihk[iclihk].hhook)); > #ifdef DLL > Win16Only((*g3d.lpfnUnhookWindowsHookEx)(g3d.rgclihk[iclihk].hhook)); > #else > Win16Only(UnhookWindowsHookEx(g3d.rgclihk[iclihk].hhook)); > #endif > g3d.iclihkMac--; > while(iclihk < g3d.iclihkMac) > { > g3d.rgclihk[iclihk] = g3d.rgclihk[iclihk+1]; > iclihk++; > } > } > } > } > > g3d.cInited--; > > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > > if (g3d.cInited == 0) > { > End3dDialogs(); > } > return fTrue; > } > > > > > /*----------------------------------------------------------------------- > | Ctl3dAutoSubclass > | > | Automatically subclasses all dialogs of the client app. > | > | Note: Due to bugs in Commdlg, an app should still call Ctl3dSubclassDlg > | for the Commdlg OpenFile and PageSetup dialogs. > | > | Arguments: > | HANDLE hinstApp: > | > | Returns: > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dAutoSubclass(HANDLE hinstApp) > { > return Ctl3dAutoSubclassEx(hinstApp, 0); > } > > PUBLIC BOOL WINAPI Ctl3dAutoSubclassEx(HANDLE hinstApp, DWORD dwFlags) > { > HHOOK hhook; > HANDLE htask; > int iclihk; > > if (g3d.verWindows < ver31) > return fFalse; > if (!g3d.f3dDialogs) > return fFalse; > > #ifdef WIN32 > // CTL3D_SUBCLASS_DYNCREATE is considered default in Win32, but > // not Win16 for backward compatibility reasons. > dwFlags |= CTL3D_SUBCLASS_DYNCREATE; > #endif > // CTL3D_NOSUBCLASS_DYNCREATE always overrides CTL3D_SUBCLASS_DYNCREATE > if (dwFlags & CTL3D_NOSUBCLASS_DYNCREATE) > dwFlags &= ~(CTL3D_NOSUBCLASS_DYNCREATE|CTL3D_SUBCLASS_DYNCREATE); > > Win32Only(EnterCriticalSection(&g_CriticalSection)); > > if (g3d.iclihkMac == iclihkMax) > goto Fail; > > Win32Only(htask = (HANDLE)GetCurrentThreadId()); > Win16Only(htask = GetCurrentTask()); > // > // Don't set the hook twice for the same task.... > // > for (iclihk = 0; iclihk < g3d.iclihkMac; iclihk++) > { > if (g3d.rgclihk[iclihk].htask == htask) > { > g3d.rgclihk[iclihk].iCount++; > goto Success; > } > } > > Win32Only(hhook = SetWindowsHookEx(WH_CBT, (HOOKPROC)Ctl3dHook, g3d.hmodLib, (DWORD)htask)); > #ifdef DLL > Win16Only(hhook = (*g3d.lpfnSetWindowsHookEx)(WH_CBT, (HOOKPROC) Ctl3dHook, g3d.hmodLib, hinstApp == NULL ? NULL : htask)); > #else > Win16Only(hhook = SetWindowsHookEx(WH_CBT, (HOOKPROC) Ctl3dHook, g3d.hmodLib, hinstApp == NULL ? NULL : htask)); > #endif > if (hhook != NULL) > { > g3d.rgclihk[g3d.iclihkMac].hinstApp = hinstApp; > g3d.rgclihk[g3d.iclihkMac].htask = htask; > g3d.rgclihk[g3d.iclihkMac].hhook = hhook; > g3d.rgclihk[g3d.iclihkMac].iCount = 1; > g3d.rgclihk[g3d.iclihkMac].dwFlags = dwFlags; > g3d.htaskCache = htask; > g3d.iclihkCache = g3d.iclihkMac; > g3d.iclihkMac++; > Success: > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > return fTrue; > } > Fail: > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > return fFalse; > } > > /*----------------------------------------------------------------------- > | Ctl3dIsAutoSubclass > | > | Returns: > | Whether this task has Automatic Subclassing Enabled > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dIsAutoSubclass() > { > int iclihk; > HANDLE hTask; > > Win32Only(hTask = (HANDLE)GetCurrentThreadId()); > Win16Only(hTask = GetCurrentTask()); > > for (iclihk = 0; iclihk < g3d.iclihkMac; iclihk++) > { > if (g3d.rgclihk[iclihk].htask == hTask) > { > return TRUE; > } > } > // didn't find task in hook table. > return FALSE; > } > > /*----------------------------------------------------------------------- > | Ctl3dUnAutoSubclass > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dUnAutoSubclass() > { > int iclihk; > HANDLE hTask; > > // Find the task's hook > // > // > Win32Only(hTask = (HANDLE)GetCurrentThreadId()); > Win16Only(hTask = GetCurrentTask()); > Win32Only(EnterCriticalSection(&g_CriticalSection)); > for (iclihk = 0; iclihk < g3d.iclihkMac; iclihk++) > { > if (g3d.rgclihk[iclihk].htask == hTask) > { > g3d.rgclihk[iclihk].iCount--; > if ( g3d.rgclihk[iclihk].iCount == 0 ) > { > Win32Only(UnhookWindowsHookEx(g3d.rgclihk[iclihk].hhook)); > #ifdef DLL > Win16Only((*g3d.lpfnUnhookWindowsHookEx)(g3d.rgclihk[iclihk].hhook)); > #else > Win16Only(UnhookWindowsHookEx(g3d.rgclihk[iclihk].hhook)); > #endif > g3d.iclihkMac--; > while(iclihk < g3d.iclihkMac) > { > g3d.rgclihk[iclihk] = g3d.rgclihk[iclihk+1]; > iclihk++; > } > } > } > } > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > return TRUE; > } > > WORD __export _loadds WINAPI Ctl3dSetStyle(HANDLE hinst, LPTSTR lpszName, WORD grbit) > { > #ifdef OLD > WORD grbitOld; > > if (!g3d.f3dDialogs) > return fFalse; > > grbitOld = grbitStyle; > if (grbit != 0) > grbitStyle = grbit; > > if (hinst != NULL && lpszName != NULL) > { > HBITMAP hbmpCheckboxesNew; > > hbmpCheckboxesNew = LoadUIBitmap(hinst, (LPCSTR) lpszName, > g3d.clrt.rgcv[icvWindowText], > g3d.clrt.rgcv[icvBtnFace], > g3d.clrt.rgcv[icvBtnShadow], > g3d.clrt.rgcv[icvBtnHilite], > g3d.clrt.rgcv[icvWindow], > g3d.clrt.rgcv[icvWindowFrame]); > if (hbmpCheckboxesNew != NULL) > { > DeleteObjectNull(&g3d.hbmpCheckboxes); > g3d.hbmpCheckboxes = hbmpCheckboxesNew; > } > } > > return grbitOld; > #endif > return 0; > } > > > /*----------------------------------------------------------------------- > | Ctl3dGetVer > | > | Returns version of CTL3D library > | > | Returns: > | Major version # in hibyte, minor version # in lobyte > | > -----------------------------------------------------------------------*/ > PUBLIC WORD WINAPI Ctl3dGetVer(void) > { > return 0x0226; > } > > > /*----------------------------------------------------------------------- > | Ctl3dEnabled > | > | Returns: > | Whether or not controls will be draw with 3d effects > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dEnabled(void) > { > return g3d.f3dDialogs; > } > > > > /*----------------------------------------------------------------------- > | Ctl3dSubclassCtl > | > | Subclasses an individual control > | > | Arguments: > | HWND hwnd: > | > | Returns: > | fTrue if control was successfully subclassed > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dSubclassCtl(HWND hwnd) > { > if (!g3d.f3dDialogs) > return fFalse; > return DoSubclassCtl(hwnd, CTL3D_ALL, OUTCBTHOOK, NULL); > } > > /*----------------------------------------------------------------------- > | Ctl3dUnsubclassCtl > | > | Un-Subclasses an individual control > | > | Arguments: > | HWND hwnd: > | > | Returns: > | fTrue if control was successfully subclassed > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dUnsubclassCtl(HWND hwnd) > { > FARPROC lpfnWinProc; > HWND hwndKids; > int ct; > > if (!g3d.f3dDialogs) > return fFalse; > > lpfnWinProc = (FARPROC) GetWindowLong(hwnd, GWL_WNDPROC); > > // Is it a control > for (ct = 0; ct < ctMax; ct++) > { > if ( lpfnWinProc == g3d.mpctctl[ct].lpfn ) > { > lpfnWinProc = LpfnGetDefWndProc(hwnd, ct); > Win32Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3d)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dLow)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh)); > SetWindowLong(hwnd, GWL_WNDPROC, (LONG) lpfnWinProc ); > lpfnWinProc = NULL; > ct = ctMax+10; > } > } > > // How about a dlg ? > if ( ct == ctMax ) > { > if ( lpfnWinProc == (FARPROC) Ctl3dDlgProc ) > { > lpfnWinProc = LpfnGetDefWndProc(hwnd, ct); > Win32Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3d)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dLow)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh)); > SetWindowLong(hwnd, GWL_WNDPROC, (LONG) lpfnWinProc ); > lpfnWinProc = NULL; > } > else > { > // None of the above, add disable property > SetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable, (HANDLE) 1); > } > } > > // > // Now unsubclass all the kids > // > for (hwndKids = GetWindow(hwnd, GW_CHILD); hwndKids != NULL; > hwndKids = GetWindow(hwndKids, GW_HWNDNEXT)) > { > Ctl3dUnsubclassCtl(hwndKids); > } > > return fTrue; > > } > > > /*----------------------------------------------------------------------- > | Ctl3dSubclassCtlEx > | > | Actually subclass the control > | > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dSubclassCtlEx(HWND hwnd, int ct) > { > LONG style; > BOOL fCan; > > if (!g3d.f3dDialogs) > return fFalse; > > if (ct < 0 || ct > ctMax) > return fFalse; > > // Is this already subclassed by CTL3D? > if (LpfnGetDefWndProcNull(hwnd) != (FARPROC) NULL) > return fFalse; > > // Only subclass it if it is something that we'd normally subclass > style = GetWindowLong(hwnd, GWL_STYLE); > fCan = mpctcdef[ct].lpfnFCanSubclass(hwnd, style, CTL3D_ALL, > OUTCBTHOOK, GetParent(hwnd)); > if (fCan == fTrue) > SubclassWindow(hwnd, g3d.mpctctl[ct].lpfn); > > return fTrue; > } > > /*----------------------------------------------------------------------- > | Ctl3dSubclassDlg > | > | Call this during WM_INITDIALOG processing. > | > | Arguments: > | hwndDlg: > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dSubclassDlg(HWND hwndDlg, WORD grbit) > { > HWND hwnd; > > if (!g3d.f3dDialogs) > return fFalse; > > for(hwnd = GetWindow(hwndDlg, GW_CHILD); hwnd != NULL; > hwnd = GetWindow(hwnd, GW_HWNDNEXT)) > { > DoSubclassCtl(hwnd, grbit, OUTCBTHOOK, NULL); > } > return fTrue; > } > > /*----------------------------------------------------------------------- > | Ctl3dCheckSubclassDlg > | > | Call this during WM_INITDIALOG processing. > | > | Arguments: > | hwndDlg: > | > -----------------------------------------------------------------------*/ > PRIVATE void CheckChildSubclass(HWND hwnd, WORD grbit, HWND hwndParent) > { > // Is this already subclassed by CTL3D? > // Is our property there ? > if (LpfnGetDefWndProcNull(hwnd) == (FARPROC) NULL) > { > // No, how did this slip by, try a subclass again. > DoSubclassCtl(hwnd, grbit, OUTCBTHOOK, hwndParent); > } > else > { > // Yes, we have subclassed this control. > // Is our subclass still on the chain ? > BOOL fSubclass; > > // Make sure subclassing isn't disabled... > if (GetProp(hwnd, (LPCTSTR)g3d.aCtl3dDisable)) > return; > > fSubclass = 666; > SendMessage((HWND) hwnd, WM_CHECKSUBCLASS, 0, (LPARAM)(int FAR *)&fSubclass); > > if ( fSubclass == 666 ) // Evil > { > // We have been un-subclassed by some bad app ( common dialogs in Win16 ) > // Remove the Prop, and subclass again, take that. > Win32Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3d)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dLow)); > Win16Only(RemoveProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh)); > DoSubclassCtl(hwnd, grbit, OUTCBTHOOK, hwndParent); > } > } > } > > PUBLIC BOOL WINAPI Ctl3dCheckSubclassDlg(HWND hwndDlg, WORD grbit) > { > HWND hwnd, hwnd2; > > if (!g3d.f3dDialogs) > return fFalse; > > for (hwnd = GetWindow(hwndDlg, GW_CHILD); hwnd != NULL; > hwnd = GetWindow(hwnd, GW_HWNDNEXT)) > { > CheckChildSubclass(hwnd, grbit, NULL); > for (hwnd2 = GetWindow(hwnd, GW_CHILD); hwnd2 != NULL; > hwnd2 = GetWindow(hwnd2, GW_HWNDNEXT)) > { > CheckChildSubclass(hwnd2, grbit, hwnd); > } > } > > return fTrue; > } > > /*----------------------------------------------------------------------- > | Ctl3dSubclassDlgEx > | > | Call this during WM_INITDIALOG processing. This is like > | Ctl3dSubclassDlg but it also subclasses the dialog window itself > | so the app doesn't need to. > | > | Arguments: > | hwndDlg: > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dSubclassDlgEx(HWND hwndDlg, DWORD grbit) > { > HWND hwnd; > > if (!g3d.f3dDialogs) > return fFalse; > > for(hwnd = GetWindow(hwndDlg, GW_CHILD); hwnd != NULL; > hwnd = GetWindow(hwnd, GW_HWNDNEXT)) > { > DoSubclassCtl(hwnd, LOWORD(grbit), OUTCBTHOOK, NULL); > } > > // > // Now Subclass the dialog window as well > // > SubclassWindow((HWND) hwndDlg, (FARPROC)Ctl3dDlgProc); > > return fTrue; > } > > > /*----------------------------------------------------------------------- > | Ctl3dCtlColor > | > | Common CTL_COLOR processor for 3d UITF dialogs & alerts. > | > | Arguments: > | hdc: > | lParam: > | > | Returns: > | appropriate brush if g3d.f3dDialogs. Returns fFalse otherwise > | > -----------------------------------------------------------------------*/ > PUBLIC HBRUSH WINAPI Ctl3dCtlColor(HDC hdc, LPARAM lParam) > { > #ifdef WIN32 > return (HBRUSH) fFalse; > #else > HWND hwndParent; > > Assert(CTLCOLOR_MSGBOX < CTLCOLOR_BTN); > Assert(CTLCOLOR_EDIT < CTLCOLOR_BTN); > Assert(CTLCOLOR_LISTBOX < CTLCOLOR_BTN); > if(g3d.f3dDialogs) > { > if (HIWORD(lParam) >= CTLCOLOR_LISTBOX) > { > if (HIWORD(lParam) == CTLCOLOR_LISTBOX && > (g3d.verWindows >= ver40 || > ((GetWindow(LOWORD(lParam), GW_CHILD) == NULL || > (GetWindowLong(LOWORD(lParam), GWL_STYLE) & 0x03) == CBS_DROPDOWNLIST)))) > { > // if it doesn't have a child then it must be a list box > // don't do brush stuff for drop down lists or else > // it draws funny grey inside the edit rect > goto DefWP; > } > SetTextColor(hdc, g3d.clrt.rgcv[icvBtnText]); > SetBkColor(hdc, g3d.clrt.rgcv[icvBtnFace]); > return g3d.brt.mpicvhbr[icvBtnFace]; > } > } > DefWP: > hwndParent = GetParent(LOWORD(lParam)); > if (hwndParent == NULL) > return fFalse; > return (HBRUSH) DefWindowProc(hwndParent, WM_CTLCOLOR, (WPARAM) hdc, (LONG) lParam); > #endif > } > > > > /*----------------------------------------------------------------------- > | Ctl3dCtlColorEx > | > | Common CTL_COLOR processor for 3d UITF dialogs & alerts. > | > | Arguments: > | > | Returns: > | appropriate brush if g3d.f3dDialogs. Returns fFalse otherwise > | > -----------------------------------------------------------------------*/ > PUBLIC HBRUSH WINAPI Ctl3dCtlColorEx(UINT wm, WPARAM wParam, LPARAM lParam) > { > #ifdef WIN32 > Assert(WM_CTLCOLORMSGBOX < WM_CTLCOLORBTN); > Assert(WM_CTLCOLOREDIT < WM_CTLCOLORBTN); > Assert(WM_CTLCOLORLISTBOX < WM_CTLCOLORBTN); > if(g3d.f3dDialogs) > { > if (wm >= WM_CTLCOLORLISTBOX && wm != WM_CTLCOLORSCROLLBAR) > { > if (wm == WM_CTLCOLORLISTBOX && > (g3d.verWindows >= ver40 || > ((GetWindow((HWND) lParam, GW_CHILD) == NULL || > (GetWindowLong((HWND) lParam, GWL_STYLE) & 0x03) == CBS_DROPDOWNLIST)))) > { > // if it doesn't have a child then it must be a list box > // don't do brush stuff for drop down lists or else > // it draws funny grey inside the edit rect > return (HBRUSH) fFalse; > } > SetTextColor((HDC) wParam, g3d.clrt.rgcv[icvBtnText]); > SetBkColor((HDC) wParam, g3d.clrt.rgcv[icvBtnFace]); > return g3d.brt.mpicvhbr[icvBtnFace]; > } > } > return (HBRUSH) fFalse; > #else > return Ctl3dCtlColor(wParam, lParam); > #endif > } > > > /*----------------------------------------------------------------------- > | Ctl3dColorChange > | > | App calls this when it gets a WM_SYSCOLORCHANGE message > | > | Returns: > | TRUE if successful. > | > -----------------------------------------------------------------------*/ > PUBLIC BOOL WINAPI Ctl3dColorChange(VOID) > { > BOOL bResult; > Win32Only(EnterCriticalSection(&g_CriticalSection)); > bResult = InternalCtl3dColorChange(fFalse); > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > return bResult; > } > > PRIVATE LONG WINAPI > Ctl3dDlgFramePaintI(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam, BOOL fDefWP); > > /*----------------------------------------------------------------------- > | Ctl3dDlgFramePaint > | > | App calls this when it gets a NC_PAINT message > | > | Returns: > | TRUE if successful. > | > -----------------------------------------------------------------------*/ > PUBLIC LONG WINAPI Ctl3dDlgFramePaint(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > return Ctl3dDlgFramePaintI(hwnd, wm, wParam, lParam, TRUE); > } > > // Ctl3dDlgFramePaintI used only internally by Ctl3d > PRIVATE LONG WINAPI > Ctl3dDlgFramePaintI(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam, BOOL fDefWP) > { > LONG lResult; > LONG lStyle; > BOOL fBorder; > > WNDPROC defProc = fDefWP ? NULL : (WNDPROC) LpfnGetDefWndProc(hwnd, ctMax); > > if (defProc != NULL) > lResult = CallWindowProc((FARPROC)defProc, hwnd, wm, wParam, lParam); > else > lResult = DefWindowProc(hwnd, wm, wParam, lParam); > > if (!g3d.f3dDialogs) > return lResult; > > if ( IsIconic(hwnd) ) > return lResult; > > fBorder = CTL3D_BORDER; > SendMessage(hwnd, WM_DLGBORDER, 0, (LPARAM)(int FAR *)&fBorder); > lStyle = GetWindowLong(hwnd, GWL_STYLE); > if (fBorder != CTL3D_NOBORDER && (lStyle & (WS_VISIBLE|WS_DLGFRAME|DS_MODALFRAME)) == (WS_VISIBLE|WS_DLGFRAME|DS_MODALFRAME)) > { > BOOL fCaption; > HBRUSH hbrSav; > HDC hdc; > RC rc; > RC rcFill; > int dyFrameTop; > > fCaption = (lStyle & WS_CAPTION) == WS_CAPTION; > dyFrameTop = g3d.dyFrame - (fCaption ? dyBorder : 0); > > hdc = GetWindowDC(hwnd); > GetWindowRect(hwnd, (LPRECT) &rc); > rc.xRight = rc.xRight-rc.xLeft; > rc.yBot = rc.yBot-rc.yTop; > rc.xLeft = rc.yTop = 0; > > DrawRec3d(hdc, &rc, icvBtnShadow, icvWindowFrame, dr3All); > InflateRect((LPRECT) &rc, -dxBorder, -dyBorder); > DrawRec3d(hdc, &rc, icvBtnHilite, icvBtnShadow, dr3All); > InflateRect((LPRECT) &rc, -dxBorder, -dyBorder); > > hbrSav = SelectObject(hdc, g3d.brt.mpicvhbr[icvBtnFace]); > rcFill = rc; > // Left > rcFill.xRight = rcFill.xLeft+g3d.dxFrame; > PatFill(hdc, &rcFill); > // Right > OffsetRect((LPRECT) &rcFill, rc.xRight-rc.xLeft-g3d.dxFrame, 0); > PatFill(hdc, &rcFill); > // Top > rcFill.xLeft = rc.xLeft + g3d.dxFrame; > rcFill.xRight = rc.xRight - g3d.dxFrame; > rcFill.yBot = rcFill.yTop+dyFrameTop; > PatFill(hdc, &rcFill); > if (fCaption) > { > RC rcT; > > rcT = rcFill; > rcT.yTop += dyFrameTop; > rcT.yBot = rcT.yTop + g3d.dyCaption; > DrawRec3d(hdc, &rcT, icvBtnShadow, icvBtnHilite, dr3All); > } > > // Bottom > rcFill.yTop += rc.yBot-rc.yTop-g3d.dxFrame; > rcFill.yBot = rcFill.yTop + g3d.dyFrame; > PatFill(hdc, &rcFill); > #ifdef CHISLEBORDER > if (fBorder == CTL3D_CHISLEBORDER) > { > // This code doesn't work because it draws in the client area > GetClientRect(hwnd, (LPRECT) &rc); > OffsetRect((LPRECT) &rc, g3d.dxFrame+2*dxBorder, fCaption ? g3d.dyFrame+g3d.dyCaption : g3d.dyFrame+dyBorder); > DrawRec3d(hdc, &rc, icvBtnShadow, icvBtnHilite, dr3Bot|dr3Left|dr3Right); > rc.xLeft++; > rc.xRight--; > rc.yBot--; > DrawRec3d(hdc, &rc, icvBtnHilite, icvBtnShadow, dr3Bot|dr3Left|dr3Right); > } > #endif > SelectObject(hdc, hbrSav); > ReleaseDC(hwnd, hdc); > } > return lResult; > } > > > //begin DBCS: far east short cut key support > /*----------------------------------------------------------------------- > | CTL3D Far East Support > -----------------------------------------------------------------------*/ > > /*----------------------------------------------------------------------- > | Ctl3dWinIniChange > | > | App calls this when it gets a WM_WININICHANGE message > | > | Returns: > | none > | > -----------------------------------------------------------------------*/ > PUBLIC VOID WINAPI Ctl3dWinIniChange(void) > { > TCHAR szShortCutMode[cchShortCutModeMax]; > CodeLpszDecl(szSectionWindows, TEXT("windows")); > CodeLpszDecl(szEntryShortCutKK, TEXT("kanjimenu")); > CodeLpszDecl(szEntryShortCutCH, TEXT("hangeulmenu")); > CodeLpszDecl(szShortCutSbcsKK, TEXT("roman")); > CodeLpszDecl(szShortCutSbcsCH, TEXT("english")); > CodeLpszDecl(szShortCutDbcsKK, TEXT("kanji")); > CodeLpszDecl(szShortCutDbcsCH, TEXT("hangeul")); > > if (!g3d.fDBCS) > return; > > Win32Only(EnterCriticalSection(&g_CriticalSection)); > > g3d.chShortCutPrefix = chShortCutSbcsPrefix; > GetProfileString(szSectionWindows, szEntryShortCutKK, szShortCutSbcsKK, szShortCutMode, cchShortCutModeMax - 1); > if (!lstrcmpi(szShortCutMode, szShortCutDbcsKK)) > g3d.chShortCutPrefix = chShortCutDbcsPrefix; > GetProfileString(szSectionWindows, szEntryShortCutCH, szShortCutSbcsCH, szShortCutMode, cchShortCutModeMax - 1); > if (!lstrcmpi(szShortCutMode, szShortCutDbcsCH)) > g3d.chShortCutPrefix = chShortCutDbcsPrefix; > > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > } > //end DBCS > > > > /*----------------------------------------------------------------------- > | CTL3D Internal Routines > -----------------------------------------------------------------------*/ > > > /*----------------------------------------------------------------------- > | FInit3dDialogs > | > | Initialized 3d stuff > | > -----------------------------------------------------------------------*/ > PRIVATE BOOL FAR FInit3dDialogs(VOID) > { > HDC hdc; > WNDCLASS wc; > > #ifdef DLL > #ifdef V2 > int nChars; > LPTSTR pCh; > static TCHAR MyDirectory[260]; > TCHAR OkDirectory[260]; > #endif > #endif > > //if (g3d.verWindows >= ver40) > // { > // g3d.f3dDialogs = fFalse; > // return fFalse; > // } > > Win32Only(EnterCriticalSection(&g_CriticalSection)); > > #ifdef DLL > #ifdef V2 > > #ifdef WIN32 > { > TCHAR szT[2]; > CodeLpszDecl(szSpecial, TEXT("Ctl3d_RunAlways")); > if (GetEnvironmentVariable(szSpecial, szT, 2) != 0 && szT[0] == '1') > { > goto AllowBadInstall; > } > } > #endif > > #ifdef WIN32 > #ifdef UNICODE > if (GetVersion() & 0x80000000) > { > Win16Or32( > CodeLpszDecl(lpszCtl3d, TEXT("CTL3DV2.DLL")), > CodeLpszDecl(lpszCtl3d, TEXT("CTL3D32.DLL"))); > CodeLpszDecl(lpszBadInstMsg, > TEXT("This application uses CTL3D32.DLL, which is not the correct version. ") > TEXT("This version of CTL3D32.DLL is designed only for Windows NT systems.")); > MessageBox(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK); > g3d.f3dDialogs = fFalse; > goto Return; > } > #else > if (!(GetVersion() & 0x80000000)) > { > Win16Or32( > CodeLpszDecl(lpszCtl3d, TEXT("CTL3DV2.DLL")), > CodeLpszDecl(lpszCtl3d, TEXT("CTL3D32.DLL"))); > CodeLpszDecl(lpszBadInstMsg, > TEXT("This application uses CTL3D32.DLL, which is not the correct version. ") > TEXT("This version of CTL3D32.DLL is designed only for Win32s or Windows 95 systems.")); > MessageBox(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK); > g3d.f3dDialogs = fFalse; > goto Return; > } > #endif > #endif > nChars = GetModuleFileName(g3d.hinstLib, MyDirectory, sizeof(MyDirectory)Win32Only(/sizeof(TCHAR))); > for (pCh = (LPTSTR)(MyDirectory+nChars-1); > pCh >= (LPTSTR)MyDirectory; > pCh = Win32Or16(CharPrev(MyDirectory, pCh),AnsiPrev(MyDirectory, pCh))) > { > if ( *pCh == '\\' ) > { > if ( *(pCh-1) != ':' ) > *pCh = 0; > else > *(pCh+1) = 0; > break; > } > } > > nChars = GetSystemDirectory(OkDirectory, sizeof(OkDirectory)Win32Only(/sizeof(TCHAR))); > if ( lstrcmpi(MyDirectory,OkDirectory ) ) > { > nChars = GetWindowsDirectory(OkDirectory, sizeof(OkDirectory)Win32Only(/sizeof(TCHAR))); > if ( lstrcmpi(MyDirectory,OkDirectory ) ) > { > Win16Or32( > CodeLpszDecl(lpszCtl3d, TEXT("CTL3DV2.DLL")), > CodeLpszDecl(lpszCtl3d, TEXT("CTL3D32.DLL"))); > Win16Or32( > CodeLpszDecl(lpszBadInstMsg, > TEXT("This application uses CTL3DV2.DLL, which has not been correctly installed. ") > TEXT("CTL3DV2.DLL must be installed in the Windows system directory.")), > CodeLpszDecl(lpszBadInstMsg, > TEXT("This application uses CTL3D32.DLL, which has not been correctly installed. ") > TEXT("CTL3D32.DLL must be installed in the Windows system directory."))); > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > MessageBox(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK ); > g3d.f3dDialogs = fFalse; > goto Return; > } > } > > Win32Only(AllowBadInstall:;) > #endif > #endif > > hdc = GetDC(NULL); > g3d.f3dDialogs = GetDeviceCaps(hdc,BITSPIXEL)*GetDeviceCaps(hdc,PLANES) >= 4; > // Win 3.1 EGA lies to us... > if(GetSystemMetrics(SM_CYSCREEN) == 350 && GetSystemMetrics(SM_CXSCREEN) == 640) > g3d.f3dDialogs = fFalse; > ReleaseDC(NULL, hdc); > if (g3d.f3dDialogs) > { > int ct; > CodeLpszDecl(lpszC3dD, TEXT("C3dD")); > > CodeLpszDecl(lpszC3d, TEXT("C3d")); > CodeLpszDecl(lpszC3dL, TEXT("C3dL")); > CodeLpszDecl(lpszC3dH, TEXT("C3dH")); > > g3d.aCtl3d = GlobalAddAtom(lpszC3d); > if (g3d.aCtl3d == 0) > { > g3d.f3dDialogs = fFalse; > goto Return; > } > > g3d.aCtl3dLow = GlobalAddAtom(lpszC3dL); > g3d.aCtl3dHigh = GlobalAddAtom(lpszC3dH); > if (g3d.aCtl3dLow == 0 || g3d.aCtl3dHigh == 0) > { > g3d.f3dDialogs = fFalse; > return fFalse; > } > > g3d.aCtl3dDisable = GlobalAddAtom(lpszC3dD); > if (g3d.aCtl3dDisable == 0) > { > g3d.f3dDialogs = fFalse; > goto Return; > } > > // DBCS > g3d.fDBCS = GetSystemMetrics(SM_DBCSENABLED); > Ctl3dWinIniChange(); > > if (InternalCtl3dColorChange(fTrue)) // load bitmap & brushes > { > for (ct = 0; ct < ctMax; ct++) > { > g3d.mpctctl[ct].lpfn = (FARPROC)mpctcdef[ct].lpfnWndProc; > Assert(g3d.mpctctl[ct].lpfn != NULL); > GetClassInfo(NULL, mpctcdef[ct].sz, (LPWNDCLASS) &wc); > g3d.mpctctl[ct].lpfnDefProc = wc.lpfnWndProc; > } > if (GetClassInfo(NULL, WC_DIALOG, &wc)) > g3d.lpfnDefDlgWndProc = (FARPROC) wc.lpfnWndProc; > else > g3d.lpfnDefDlgWndProc = (FARPROC) DefDlgProc; > } > else > { > g3d.f3dDialogs = fFalse; > } > } > Return: > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > return g3d.f3dDialogs; > } > > > > /*----------------------------------------------------------------------- > | End3dDialogs > | > | Called at DLL termination to free 3d dialog stuff > -----------------------------------------------------------------------*/ > PRIVATE VOID End3dDialogs(VOID) > { > int ct; > > Win32Only(EnterCriticalSection(&g_CriticalSection)); > > for (ct = 0; ct < ctMax; ct++) > { > if(g3d.mpctctl[ct].lpfn != NULL) > { > FreeProcInstance(g3d.mpctctl[ct].lpfn); > g3d.mpctctl[ct].lpfn = NULL; > } > } > DeleteObjects(); > Win32Only(g3d.aCtl3d ? GlobalDeleteAtom(g3d.aCtl3d) : 0); > Win16Only(g3d.aCtl3dLow ? GlobalDeleteAtom(g3d.aCtl3dLow) : 0); > Win16Only(g3d.aCtl3dHigh ? GlobalDeleteAtom(g3d.aCtl3dHigh) : 0); > g3d.aCtl3dDisable ? GlobalDeleteAtom(g3d.aCtl3dDisable) : 0; > > g3d.f3dDialogs = fFalse; > > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > > } > > > PRIVATE BOOL InternalCtl3dColorChange(BOOL fForce) > { > ICV icv; > CLRT clrtNew; > HBITMAP hbmpCheckboxesNew; > BRT brtNew; > > if (!g3d.f3dDialogs) > return fFalse; > > for (icv = 0; icv < icvMax; icv++) > clrtNew.rgcv[icv] = GetSysColor(mpicvSysColor[icv]); > > if (g3d.verWindows == ver30) > clrtNew.rgcv[icvBtnHilite] = RGB(0xff, 0xff, 0xff); > > if (clrtNew.rgcv[icvGrayText] == 0L || clrtNew.rgcv[icvGrayText] == clrtNew.rgcv[icvBtnFace]) > { > if (clrtNew.rgcv[icvBtnFace] == RGB(0x80, 0x80, 0x80)) > clrtNew.rgcv[icvGrayText] = RGB(0xc0, 0xc0, 0xc0); > else > clrtNew.rgcv[icvGrayText] = RGB(0x80, 0x80, 0x80); > } > > if (fForce || MEMCMP(&g3d.clrt, &clrtNew, sizeof(CLRT))) > { > hbmpCheckboxesNew = LoadUIBitmap(g3d.hinstLib, MAKEINTRESOURCE(CTL3D_3DCHECK), > clrtNew.rgcv[icvWindowText], > clrtNew.rgcv[icvBtnFace], > clrtNew.rgcv[icvBtnShadow], > clrtNew.rgcv[icvBtnHilite], > clrtNew.rgcv[icvWindow], > clrtNew.rgcv[icvWindowFrame]); > > for (icv = 0; icv < icvBrushMax; icv++) > brtNew.mpicvhbr[icv] = CreateSolidBrush(clrtNew.rgcv[icv]); > > for (icv = 0; icv < icvBrushMax; icv++) > if (brtNew.mpicvhbr[icv] == NULL) > goto OOM; > > if(hbmpCheckboxesNew != NULL) > { > DeleteObjects(); > g3d.brt = brtNew; > g3d.clrt = clrtNew; > g3d.hbmpCheckboxes = hbmpCheckboxesNew; > return fTrue; > } > else > { > OOM: > for (icv = 0; icv < icvBrushMax; icv++) > DeleteObjectNull(&brtNew.mpicvhbr[icv]); > DeleteObjectNull(&hbmpCheckboxesNew); > return fFalse; > } > } > return fTrue; > } > > > /*----------------------------------------------------------------------- > | Ctl3dDlgProc > | > | Subclass DlgProc for use w/ Ctl3dAutoSubclass > | > | > | Arguments: > | HWND hwnd: > | int wm: > | WORD wParam: > | LPARAM lParam: > | > | Returns: > | > -----------------------------------------------------------------------*/ > LRESULT __export _loadds WINAPI Ctl3dDlgProc(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > HBRUSH hbrush; > FARPROC lpfnDlgProc; > TCHAR szClass[cchClassMax]; > > if ( wm == WM_NCDESTROY ) > return CleanupSubclass(hwnd, wm, wParam, lParam, ctMax); > > if ( GetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable) ) > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, wm, wParam, lParam); > > switch (wm) > { > case WM_CHECKSUBCLASS: > *(int FAR *)lParam = fTrue; > return ctMax+1000; > > case WM_INITDIALOG: > { > long l; > BOOL fSubclass; > FARPROC lpfnWinProc; > > lpfnWinProc = LpfnGetDefWndProc(hwnd, ctMax); > > if (g3d.verWindows >= ver40 && (GetWindowLong(hwnd, GWL_STYLE) & 0x04)) > fSubclass = fFalse; > else > fSubclass = fTrue; > SendMessage(hwnd, WM_DLGSUBCLASS, 0, (LPARAM)(int FAR *)&fSubclass); > > if (!fSubclass) > { > Ctl3dUnsubclassCtl(hwnd); > return CallWindowProc(lpfnWinProc, hwnd, wm, wParam, lParam); > } > > l = CallWindowProc(lpfnWinProc, hwnd, wm, wParam, lParam); > > if (g3d.verWindows < ver40 || !(GetWindowLong(hwnd, GWL_STYLE) & 0x04)) > Ctl3dCheckSubclassDlg(hwnd, CTL3D_ALL); > > return l; > } > > case WM_NCPAINT: > case WM_NCACTIVATE: > case WM_SETTEXT: > if (g3d.verWindows >= ver40 || IsIconic(hwnd) ) > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, wm, wParam, lParam); > else > return Ctl3dDlgFramePaintI(hwnd, wm, wParam, lParam, FALSE); > > #ifdef WIN32 > case WM_CTLCOLORSCROLLBAR: > case WM_CTLCOLORBTN: > case WM_CTLCOLORDLG: > case WM_CTLCOLOREDIT: > case WM_CTLCOLORLISTBOX: > case WM_CTLCOLORMSGBOX: > case WM_CTLCOLORSTATIC: > #else > case WM_CTLCOLOR: > #endif > // Is this really a dialog > GetClassName(hwnd, szClass, sizeof(szClass)Win32Only(/sizeof(TCHAR))); > if (lstrcmp(TEXT("#32770"),szClass) != 0 ) > { > #ifdef WIN32 > hbrush = (HBRUSH) CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, > wm-WM_CTLCOLORMSGBOX+CTLMSGOFFSET, wParam, lParam); > #else > hbrush = (HBRUSH) CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, > CTL3D_CTLCOLOR, wParam, lParam); > #endif > if (hbrush == (HBRUSH) fFalse || hbrush == (HBRUSH)1) > hbrush = Ctl3dCtlColorEx(wm, wParam, lParam); > } > else > { > lpfnDlgProc = (FARPROC) GetWindowLong(hwnd, DWL_DLGPROC); > > if (lpfnDlgProc == NULL ) > { > hbrush = Ctl3dCtlColorEx(wm, wParam, lParam); > } > else > { > #ifdef WIN32 > if ( (LONG)lpfnDlgProc > 0xFFFF0000 && g3d.verWindows <= ver31) > { > // We have a Uni-code / non Unicode issue. > // If this is before Daytona, then I CAN NOT call because it may be NULL, but > // the returned value is not-null. NT Bug. > // So Just send our own message to the window proc instead > hbrush = (HBRUSH) CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, > wm-WM_CTLCOLORMSGBOX+CTLMSGOFFSET, wParam, lParam); > if (hbrush == (HBRUSH) fFalse || hbrush == (HBRUSH)1) > hbrush = Ctl3dCtlColorEx(wm, wParam, lParam); > } > else > { > #endif > hbrush = (HBRUSH) CallWindowProc(lpfnDlgProc, hwnd, wm, wParam, lParam); > if (hbrush == (HBRUSH) fFalse || hbrush == (HBRUSH)1) > { > #ifdef WIN32 > hbrush = (HBRUSH) CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, > wm-WM_CTLCOLORMSGBOX+CTLMSGOFFSET, wParam, lParam); > #else > hbrush = (HBRUSH) CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, > CTL3D_CTLCOLOR, wParam, lParam); > #endif > if (hbrush == (HBRUSH) fFalse || hbrush == (HBRUSH)1) > hbrush = Ctl3dCtlColorEx(wm, wParam, lParam); > } > } > #ifdef WIN32 > } > #endif > } > if (hbrush != (HBRUSH) fFalse) > return (LRESULT)hbrush; > break; > } > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctMax), hwnd, wm, wParam, lParam); > } > > PRIVATE BOOL NEAR DoesChildNeedSubclass(HWND hwnd) > { > if (!LpfnGetDefWndProcNull(hwnd)) > return fFalse; > if (g3d.verWindows >= ver40 && GetWindowLong(hwnd, GWL_STYLE) & 0x04) > return fFalse; > return fTrue; > } > > /*----------------------------------------------------------------------- > | Ctl3dHook > | > | CBT Hook to watch for window creation. Automatically subclasses all > | dialogs w/ Ctl3dDlgProc > | > | Arguments: > | int code: > | WORD wParam: > | LPARAM lParam: > | > | Returns: > | > -----------------------------------------------------------------------*/ > LRESULT __export _loadds WINAPI Ctl3dHook(int code, WPARAM wParam, LPARAM lParam) > { > int iclihk; > HANDLE htask; > > htask = Win32Or16((HANDLE)GetCurrentThreadId(), GetCurrentTask()); > Win32Only(EnterCriticalSection(&g_CriticalSection)); > if (htask != g3d.htaskCache) > { > for (iclihk = 0; iclihk < g3d.iclihkMac; iclihk++) > { > if (g3d.rgclihk[iclihk].htask == htask) > { > g3d.iclihkCache = iclihk; > g3d.htaskCache = htask; > break; > } > } > if ( iclihk == g3d.iclihkMac ) > { > // didn't find task in hook table. This could be bad, but > // returning 0L is about all we can doo. > // > // Actually not. The hhook isn't used anyway just set it to NULL. > // and call the next hook..... KGM > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > return CallNextHookEx((HHOOK)0L, code, wParam, lParam); > } > } > iclihk = g3d.iclihkCache; > Win32Only(LeaveCriticalSection(&g_CriticalSection)); > > if (code == HCBT_CREATEWND) > { > LPCREATESTRUCT lpcs; > lpcs = ((LPCBT_CREATEWND)lParam)->lpcs; > > if (lpcs->lpszClass == WC_DIALOG) > { > if (g3d.verBase == 32) > { > SubclassWindow((HWND)wParam, (FARPROC) Ctl3dDlgProc); > } > else > { > HookSubclassWindow((HWND)wParam, (FARPROC) Ctl3dDlgProc); > } > goto Zing; > } > if (!(g3d.rgclihk[iclihk].dwFlags & CTL3D_SUBCLASS_DYNCREATE)) > goto Zing; > > if (DoesChildNeedSubclass(lpcs->hwndParent) || > (lpcs->hwndParent && g3d.verBase != 24 && > DoesChildNeedSubclass(GetParent(lpcs->hwndParent)))) > { > DoSubclassCtl((HWND)wParam, CTL3D_ALL, INCBTHOOK, lpcs->hwndParent); > } > } > > Zing:; > Win32Only(return CallNextHookEx(g3d.rgclihk[iclihk].hhook, code, wParam, lParam)); > #ifdef DLL > Win16Only(return (*g3d.lpfnCallNextHookEx)(g3d.rgclihk[iclihk].hhook, code, wParam, lParam)); > #else > Win16Only(return (CallNextHookEx(g3d.rgclihk[iclihk].hhook, code, wParam, lParam))); > #endif > } > > > > > /*----------------------------------------------------------------------- > | CTL3D F* routines > | > | These routines determine whether or not the given control may be > | subclassed. They may recursively call DoSubclassCtl in the > | case of multi-control controls > | > | Returns: > | fTrue if can subclass the given control. > -----------------------------------------------------------------------*/ > > > PRIVATE BOOL FBtn(HWND hwnd, LONG style, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > if (g3d.verWindows >= ver40) > { > return fFalse; > } > style &= ~(BS_LEFTTEXT); > return ( LOWORD(style) >= BS_PUSHBUTTON && LOWORD(style) <= BS_AUTORADIOBUTTON); > } > > PRIVATE BOOL FEdit(HWND hwnd, LONG style, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > if (g3d.verWindows >= ver40 && hwndParent) > { > TCHAR szClass[cchClassMax]; > GetClassName(hwndParent, szClass, sizeof(szClass)Win32Only(/sizeof(TCHAR))); > if (lstrcmp(szClass, mpctcdef[ctCombo].sz) == 0 ) > return fFalse; > else > return fTrue; > } > else > return fTrue; > } > > PRIVATE BOOL FList(HWND hwnd, LONG style, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > if (g3d.verWindows >= ver40 && hwndParent) > { > TCHAR szClass[cchClassMax]; > GetClassName(hwndParent, szClass, sizeof(szClass)Win32Only(/sizeof(TCHAR))); > if (lstrcmp(szClass, mpctcdef[ctCombo].sz) == 0 ) > return fFalse; > else > return fTrue; > } > else > return fTrue; > } > > PRIVATE BOOL FComboList(HWND hwnd, LONG style, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > > if (g3d.verWindows >= ver40) > return fFalse; > > if ( wCallFlags == INCBTHOOK ) > { > LONG style; > style = GetWindowLong(hwndParent, GWL_STYLE); > if (!(((style & 0x0003) == CBS_DROPDOWN) || ((style & 0x0003) == CBS_DROPDOWNLIST))) > return fTrue; > else > return fFalse; > } > > return fTrue; > } > > PRIVATE BOOL FCombo(HWND hwnd, LONG style, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > HWND hwndEdit; > HWND hwndList; > > if (g3d.verWindows >= ver40) > return fFalse; > > if ((style & 0x0003) == CBS_DROPDOWN) > { > if ( wCallFlags == INCBTHOOK ) > { > return fFalse; > } > // Subclass edit so bottom border of the edit draws properly...This case > // is specially handled in ListEditPaint3d > hwndEdit = GetWindow(hwnd, GW_CHILD); > if (hwndEdit != NULL) > DoSubclassCtl(hwndEdit, CTL3D_EDITS, wCallFlags, hwnd); > return fTrue; > } > else if ((style & 0x0003) == CBS_DROPDOWNLIST ) > { > return fTrue; > } > else // assume simple // if ((style & 0x0003) == CBS_SIMPLE) > { > if ( wCallFlags == INCBTHOOK ) > { > return fTrue; > } > hwndList = GetWindow(hwnd, GW_CHILD); > if (hwndList != NULL) > { > // Subclass list & edit box so they draw properly. We also > // subclass the combo so we can hide/show/move it and the > // 3d effects outside the client area get erased > DoSubclassCtl(hwndList, CTL3D_LISTBOXES, wCallFlags, hwnd); > > hwndEdit = GetWindow(hwndList, GW_HWNDNEXT); > if (hwndEdit != NULL) > DoSubclassCtl(hwndEdit, CTL3D_EDITS, wCallFlags, hwnd); > return fTrue; > } > return fFalse; > } > } > > PRIVATE BOOL FStatic(HWND hwnd, LONG style, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > int wStyle; > > wStyle = LOWORD(style) & 0xf; > return (wStyle != SS_ICON && > ((grbit & CTL3D_STATICTEXTS) && > (wStyle <= SS_RIGHT || wStyle == SS_LEFTNOWORDWRAP) || > ((grbit & CTL3D_STATICFRAMES) && > (wStyle >= SS_BLACKRECT && wStyle <= SS_WHITEFRAME)))); > } > > > > /*----------------------------------------------------------------------- > | DoSubclassCtl > | > | Actually subclass the control > | > | > | Arguments: > | HWND hwnd: > | WORD grbit: > | WORD wCallFlags > | Returns: > | > -----------------------------------------------------------------------*/ > PRIVATE BOOL DoSubclassCtl(HWND hwnd, WORD grbit, WORD wCallFlags, HWND hwndParent) > { > LONG style; > int ct; > BOOL fCan; > TCHAR szClass[cchClassMax]; > > // Is this already subclassed by CTL3D? > if (LpfnGetDefWndProcNull(hwnd) != (FARPROC) NULL) > return fFalse; > > GetClassName(hwnd, szClass, sizeof(szClass)Win32Only(/sizeof(TCHAR))); > > for (ct = 0; ct < ctMax; ct++) > { > if ((mpctcdef[ct].msk & grbit) && > (lstrcmp(mpctcdef[ct].sz,szClass) == 0)) > { > style = GetWindowLong(hwnd, GWL_STYLE); > fCan = mpctcdef[ct].lpfnFCanSubclass(hwnd, style, grbit, wCallFlags, hwndParent); > if (fCan == fTrue) > { > if ( wCallFlags == INCBTHOOK && g3d.verBase == 16 ) > HookSubclassWindow(hwnd, g3d.mpctctl[ct].lpfn); > else > SubclassWindow(hwnd, g3d.mpctctl[ct].lpfn); > } > return fCan != fFalse; > } > } > > return fFalse; > } > > > > /*----------------------------------------------------------------------- > | Inval3dCtl > | > | Invalidate the controls rect in response to a WM_SHOWWINDOW or > | WM_WINDOWPOSCHANGING message. This is necessary because ctl3d draws > | the 3d effects of listboxes, combos & edits outside the controls client > | rect. > | > | Arguments: > | HWND hwnd: > | WINDOWPOS FAR *lpwp: > | > | Returns: > | > -----------------------------------------------------------------------*/ > PRIVATE VOID Inval3dCtl(HWND hwnd, WINDOWPOS FAR *lpwp) > { > RC rc; > HWND hwndParent; > LONG lStyle; > unsigned flags; > > GetWindowRect(hwnd, (LPRECT) &rc); > lStyle = GetWindowLong(hwnd, GWL_STYLE); > if (lStyle & WS_VISIBLE) > { > if (lpwp != NULL) > { > flags = lpwp->flags; > > // > // Is all this necessary ? Are we moving or sizing ? > // > if ( !((flags & SWP_HIDEWINDOW) || (flags & SWP_SHOWWINDOW)) && > (flags & SWP_NOMOVE) && (flags & SWP_NOSIZE) ) > // Nope > return; > > // handle integral height listboxes (or any other control which > // shrinks from the bottom) > if ((flags & (SWP_NOMOVE|SWP_NOSIZE)) == SWP_NOMOVE && > (lpwp->cx == (rc.xRight-rc.xLeft) && lpwp->cy <= (rc.yBot-rc.yTop))) > rc.yTop = rc.yTop+lpwp->cy+1; // +1 to offset InflateRect > } > InflateRect((LPRECT) &rc, 1, 1); > hwndParent = GetParent(hwnd); > ScreenToClient(hwndParent, (LPPOINT) &rc); > ScreenToClient(hwndParent, ((LPPOINT) &rc)+1); > if(lStyle & WS_VSCROLL) > rc.xRight ++; > InvalidateRect(hwndParent, (LPRECT) &rc, fFalse); > } > } > > /*----------------------------------------------------------------------- > | Val3dCtl > | > -----------------------------------------------------------------------*/ > PRIVATE VOID Val3dCtl(HWND hwnd) > { > RC rc; > HWND hwndParent; > LONG lStyle; > > lStyle = GetWindowLong(hwnd, GWL_STYLE); > GetWindowRect(hwnd, (LPRECT) &rc); > InflateRect((LPRECT) &rc, 1, 1); > hwndParent = GetParent(hwnd); > ScreenToClient(hwndParent, (LPPOINT) &rc); > ScreenToClient(hwndParent, ((LPPOINT) &rc)+1); > if(lStyle & WS_VSCROLL) > rc.xRight ++; > ValidateRect(hwndParent, (LPRECT) &rc); > } > > /*----------------------------------------------------------------------- > | CTL3D Subclass Wndprocs > -----------------------------------------------------------------------*/ > > /* These values are assumed for bit shifting operations */ > #define BFCHECK 0x0003 > #define BFSTATE 0x0004 > #define BFFOCUS 0x0008 > #define BFINCLICK 0x0010 /* Inside click code */ > #define BFCAPTURED 0x0020 /* We have mouse capture */ > #define BFMOUSE 0x0040 /* Mouse-initiated */ > #define BFDONTCLICK 0x0080 /* Don't check on get focus */ > > #define bpText 0x0002 > #define bpCheck 0x0004 > #define bpFocus 0x0008 // must be same as BFFOCUS > #define bpBkgnd 0x0010 > #define bpEraseGroupText 0x0020 > > PRIVATE VOID DrawPushButton(HWND hwnd, HDC hdc, RC FAR *lprc, LPTSTR lpch, int cch, WORD bs, BOOL fDown) > { > // int dxyBrdr; > int dxyShadow; > HBRUSH hbrSav; > RC rcInside; > rcInside = *lprc; > > // if (!(grbitStyle & bitFCoolButtons)) > { > DrawRec3d(hdc, lprc, icvWindowFrame, icvWindowFrame, dr3All); > InflateRect((LPRECT) &rcInside, -1, -1); > if (bs == LOWORD(BS_DEFPUSHBUTTON) && IsWindowEnabled(hwnd)) > { > // dxyBrdr = 2; > DrawRec3d(hdc, &rcInside, icvWindowFrame, icvWindowFrame, dr3All); > InflateRect((LPRECT) &rcInside, -1, -1); > } > // else > // dxyBrdr = 1; > > // Notch the corners > PatBlt(hdc, lprc->xLeft, lprc->yTop, dxBorder, dyBorder, PATCOPY); > /* Top xRight corner */ > PatBlt(hdc, lprc->xRight - dxBorder, lprc->yTop, dxBorder, dyBorder, PATCOPY); > /* yBot xLeft corner */ > PatBlt(hdc, lprc->xLeft, lprc->yBot - dyBorder, dxBorder, dyBorder, PATCOPY); > /* yBot xRight corner */ > PatBlt(hdc, lprc->xRight - dxBorder, lprc->yBot - dyBorder, dxBorder, dyBorder, PATCOPY); > dxyShadow = 1 + !fDown; > } > // else > // dxyShadow = 1; > > // draw upper left hilite/shadow > > if (fDown) > hbrSav = SelectObject(hdc, g3d.brt.mpicvhbr[icvBtnShadow]); > else > hbrSav = SelectObject(hdc, g3d.brt.mpicvhbr[icvBtnHilite]); > > PatBlt(hdc, rcInside.xLeft, rcInside.yTop, dxyShadow, > (rcInside.yBot - rcInside.yTop), PATCOPY); > PatBlt(hdc, rcInside.xLeft, rcInside.yTop, > (rcInside.xRight - rcInside.xLeft), dxyShadow, PATCOPY); > > // draw lower right shadow (only if not down) > if (!fDown) // || (grbitStyle & bitFCoolButtons)) > { > int i; > > if (fDown) > SelectObject(hdc, g3d.brt.mpicvhbr[icvBtnHilite]); > else > SelectObject(hdc, g3d.brt.mpicvhbr[icvBtnShadow]); > > rcInside.yBot--; > rcInside.xRight--; > > for (i = 0; i < dxyShadow; i++) > { > PatBlt(hdc, rcInside.xLeft, rcInside.yBot, > rcInside.xRight - rcInside.xLeft + dxBorder, dyBorder, > PATCOPY); > PatBlt(hdc, rcInside.xRight, rcInside.yTop, dxBorder, > rcInside.yBot - rcInside.yTop, PATCOPY); > if (i < dxyShadow-1) > InflateRect((LPRECT) &rcInside, -dxBorder, -dyBorder); > } > } > // draw the button face > > rcInside.xLeft++; > rcInside.yTop++; > > SelectObject(hdc, g3d.brt.mpicvhbr[icvBtnFace]); > PatBlt(hdc, rcInside.xLeft, rcInside.yTop, rcInside.xRight-rcInside.xLeft, > rcInside.yBot - rcInside.yTop, PATCOPY); > > // Draw the durned text > > if(!IsWindowEnabled(hwnd)) > SetTextColor(hdc, g3d.clrt.rgcv[icvGrayText]); > > { > int dy; > int dx; > > MyGetTextExtent(hdc, lpch, &dx, &dy); > rcInside.yTop += (rcInside.yBot-rcInside.yTop-dy)/2; > rcInside.xLeft += (rcInside.xRight-rcInside.xLeft-dx)/2; > rcInside.yBot = min(rcInside.yTop+dy, rcInside.yBot); > rcInside.xRight = min(rcInside.xLeft+dx, rcInside.xRight); > } > > if (fDown) > { > OffsetRect((LPRECT) &rcInside, 1, 1); > rcInside.xRight = min(rcInside.xRight, lprc->xRight-3); > rcInside.yBot = min(rcInside.yBot, lprc->yBot-3); > } > > DrawText(hdc, lpch, cch, (LPRECT) &rcInside, DT_LEFT|DT_SINGLELINE); > > if (hwnd == GetFocus()) > { > InflateRect((LPRECT) &rcInside, 1, 1); > IntersectRect((LPRECT) &rcInside, (LPRECT) &rcInside, (LPRECT) lprc); > DrawFocusRect(hdc, (LPRECT) &rcInside); > } > > if (hbrSav) > SelectObject(hdc, hbrSav); > } > > > /*----------------------------------------------------------------------- > | BtnPaint > | > | Paint a button > | > | Arguments: > | HWND hwnd: > | HDC hdc: > | int bp: > | > | Returns: > | > -----------------------------------------------------------------------*/ > PRIVATE VOID BtnPaint(HWND hwnd, HDC hdc, int bp) > { > RC rc; > RC rcClient; > HFONT hfont; > int bs; > int bf; > HBRUSH hbrBtn; > HWND hwndParent; > int xBtnBmp; > int yBtnBmp; > HBITMAP hbmpSav; > HDC hdcMem; > TCHAR szTitle[256]; > int cch; > BOOL fEnabled; > BOOL fLeftText; > > bs = (int) GetWindowLong(hwnd, GWL_STYLE); > fLeftText = (bs & Win32Or16(0x00000020, 0x0020)); > bs &= Win32Or16(0x0000001F, 0x001F); > hwndParent = GetParent(hwnd); > SetBkMode(hdc, OPAQUE); > GetClientRect(hwnd, (LPRECT)&rcClient); > rc = rcClient; > if((hfont = (HFONT)SendMessage(hwnd, WM_GETFONT, 0, 0L)) != NULL) > hfont = SelectObject(hdc, hfont); > > SetBkColor(hdc, GetSysColor(COLOR_BTNFACE)); > SetTextColor(hdc, GetSysColor(COLOR_BTNTEXT)); > hbrBtn = SEND_COLOR_BUTTON_MESSAGE(hwndParent, hwnd, hdc); > hbrBtn = SelectObject(hdc, hbrBtn); > IntersectClipRect(hdc, rc.xLeft, rc.yTop, rc.xRight, rc.yBot); > if(bp & bpBkgnd && (bs != BS_GROUPBOX)) > PatBlt(hdc, rc.xLeft, rc.yTop, rc.xRight-rc.xLeft, rc.yBot-rc.yTop, PATCOPY); > > fEnabled = IsWindowEnabled(hwnd); > bf = (int) SendMessage(hwnd, BM_GETSTATE, 0, 0L); > yBtnBmp = 0; > xBtnBmp = (((bf&BFCHECK) != 0) | ((bf&BFSTATE) >> 1)) * 14; > if (!fEnabled) > xBtnBmp += 14*(2+((bf&BFCHECK) != 0)); > if(bp & (bpText|bpFocus) || > bs == BS_PUSHBUTTON || bs == BS_DEFPUSHBUTTON) > cch = GetWindowText(hwnd, szTitle, sizeof(szTitle)Win32Only(/sizeof(TCHAR))); > switch(bs) > { > #ifdef DEBUG > default: > Assert(fFalse); > break; > #endif > case BS_PUSHBUTTON: > case BS_DEFPUSHBUTTON: > DrawPushButton(hwnd, hdc, &rcClient, szTitle, cch, LOWORD(bs), bf & BFSTATE); > break; > > case BS_RADIOBUTTON: > case BS_AUTORADIOBUTTON: > yBtnBmp = 13; > goto DrawBtn; > case BS_3STATE: > case BS_AUTO3STATE: > Assert((BFSTATE >> 1) == 2); > if((bf & BFCHECK) == 2) > yBtnBmp = 26; > // fall through > case BS_CHECKBOX: > case BS_AUTOCHECKBOX: > DrawBtn: > if(bp & bpCheck) > { > hdcMem = CreateCompatibleDC(hdc); > if(hdcMem != NULL) > { > hbmpSav = SelectObject(hdcMem, g3d.hbmpCheckboxes); > if(hbmpSav != NULL) > { > if (fLeftText) > BitBlt(hdc, rc.xRight - 14, rc.yTop+(rc.yBot-rc.yTop-13)/2, > 14, 13, hdcMem, xBtnBmp, yBtnBmp, SRCCOPY); > else > BitBlt(hdc, rc.xLeft, rc.yTop+(rc.yBot-rc.yTop-13)/2, > 14, 13, hdcMem, xBtnBmp, yBtnBmp, SRCCOPY); > SelectObject(hdcMem, hbmpSav); > } > DeleteDC(hdcMem); > } > } > if(bp & bpText) > { > // BUG! this assumes we have only 1 hbm3dCheck type > if (fLeftText) > rc.xRight = rcClient.xRight - (14+4); > else > rc.xLeft = rcClient.xLeft + 14+4; > if(!fEnabled) > SetTextColor(hdc, g3d.clrt.rgcv[icvGrayText]); > DrawText(hdc, szTitle, cch, (LPRECT) &rc, DT_VCENTER|DT_LEFT|DT_SINGLELINE); > } > if(bp & bpFocus) > { > int dx; > int dy; > > MyGetTextExtent(hdc, szTitle, &dx, &dy); > rc.yTop = (rc.yBot-rc.yTop-dy)/2; > rc.yBot = rc.yTop+dy; > rc.xLeft = rcClient.xLeft; > if (fLeftText) > { > rc.xLeft = rcClient.xLeft; > rcClient.xRight -= (14+4); > } > else > rc.xLeft = rcClient.xLeft + (14+4); > rc.xRight = rc.xLeft + dx; > InflateRect((LPRECT) &rc, 1, 1); > IntersectRect((LPRECT) &rc, (LPRECT) &rc, (LPRECT) &rcClient); > DrawFocusRect(hdc, (LPRECT) &rc); > } > break; > case BS_GROUPBOX: > if(bp & (bpText|bpCheck)) > { > int dy; > int dx; > > MyGetTextExtent(hdc, szTitle, &dx, &dy); > if (dy == 0) > { > int dxT; > MyGetTextExtent(hdc, TEXT("X"), &dxT, &dy); > } > > rc.xLeft += 4; > rc.xRight = rc.xLeft + dx + 4; > rc.yBot = rc.yTop + dy; > > if (bp & bpEraseGroupText) > { > RC rcT; > > rcT = rc; > rcT.xRight = rcClient.xRight; > // Hack! > ClientToScreen(hwnd, (LPPOINT) &rcT); > ClientToScreen(hwnd, ((LPPOINT) &rcT)+1); > ScreenToClient(hwndParent, (LPPOINT) &rcT); > ScreenToClient(hwndParent, ((LPPOINT) &rcT)+1); > InvalidateRect(hwndParent, (LPRECT) &rcT, fTrue); > return; > } > > rcClient.yTop += dy/2; > rcClient.xRight--; > rcClient.yBot--; > DrawRec3d(hdc, &rcClient, icvBtnShadow, icvBtnShadow, dr3All); > OffsetRect((LPRECT) &rcClient, 1, 1); > DrawRec3d(hdc, &rcClient, icvBtnHilite, icvBtnHilite, dr3All); > > if(!fEnabled) > SetTextColor(hdc, g3d.clrt.rgcv[icvGrayText]); > DrawText(hdc, szTitle, cch, (LPRECT) &rc, DT_LEFT|DT_SINGLELINE); > } > break; > } > > SelectObject(hdc, hbrBtn); > if(hfont != NULL) > SelectObject(hdc, hfont); > } > > LRESULT __export _loadds WINAPI BtnWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > LONG lRet; > LONG lStyle; > PAINTSTRUCT ps; > HDC hdc; > int bf; > int bfNew; > int bp; > > if ( wm == WM_NCDESTROY ) > return CleanupSubclass(hwnd, wm, wParam, lParam, ctButton); > > if ( GetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable) ) > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctButton), hwnd, wm, wParam, lParam); > > switch(wm) > { > case WM_CHECKSUBCLASS: > *(int FAR *)lParam = fTrue; > return ctButton+1000; > > case WM_SETTEXT: > lStyle = GetWindowLong(hwnd, GWL_STYLE); > if ((lStyle & WS_VISIBLE) && (LOWORD(lStyle) & 0x1f) == BS_GROUPBOX) > { > // total hack -- if group box text length shortens then > // we have to erase the old text. BtnPaint will Invalidate > // the rect of the text so everything will redraw. > bp = bpText | bpEraseGroupText; > } > else > { > bp = bpText|bpCheck|bpBkgnd; > } > goto DoIt; > > case BM_SETSTATE: > case BM_SETCHECK: > bp = bpCheck; > goto DoIt; > case WM_KILLFOCUS: > // HACK! Windows will go into an infinite loop trying to sync the > // states of the AUTO_RADIOBUTTON in this group. (we turn off the > // visible bit so it gets skipped in the enumeration) > // Disable this code by clearing the STATE bit > if ((LOWORD(GetWindowLong(hwnd, GWL_STYLE)) & 0x1F) == BS_AUTORADIOBUTTON) > SendMessage(hwnd, BM_SETSTATE, 0, 0L); > bp = 0; > goto DoIt; > case WM_ENABLE: > bp = bpCheck | bpText; > goto DoIt; > case WM_SETFOCUS: > // HACK! if wParam == NULL we may be activated via the task manager > // Erase background of control because a WM_ERASEBKGND messsage has not > // arrived yet for the dialog > // bp = wParam == (WPARAM)NULL ? (bpCheck | bpText | bpBkgnd) : (bpCheck | bpText); > bp = bpCheck | bpText | bpBkgnd; > DoIt: > bf = (int) SendMessage(hwnd, BM_GETSTATE, 0, 0L); > if((lStyle = GetWindowLong(hwnd, GWL_STYLE)) & WS_VISIBLE) > { > if ( wm != WM_SETFOCUS ) > SetWindowLong(hwnd, GWL_STYLE, lStyle & ~(WS_VISIBLE)); > lRet = CallWindowProc(LpfnGetDefWndProc(hwnd, ctButton), hwnd, wm, wParam, lParam); > > if ( wm != WM_SETFOCUS ) > SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE)|WS_VISIBLE); > bfNew = (int) SendMessage(hwnd, BM_GETSTATE, 0, 0L); > if((wm != BM_SETSTATE && wm != BM_SETCHECK) || > bf != bfNew) > { > hdc = GetDC(hwnd); > if (hdc != NULL) > { > Assert(BFFOCUS == bpFocus); > /* If the check state changed, redraw no matter what, > because it won't have during the above call to the def > wnd proc */ > if ((bf & BFCHECK) != (bfNew & BFCHECK)) > bp |= bpCheck; > ExcludeUpdateRgn(hdc, hwnd); > BtnPaint(hwnd, hdc, bp|((bf^bfNew)&BFFOCUS)); > ReleaseDC(hwnd, hdc); > } > } > return lRet; > } > break; > case WM_PAINT: > bf = (int) SendMessage(hwnd, BM_GETSTATE, 0, 0L); > if ((hdc = (HDC) wParam) == NULL) > hdc = BeginPaint(hwnd, &ps); > if(GetWindowLong(hwnd, GWL_STYLE) & WS_VISIBLE) > BtnPaint(hwnd, hdc, bpText|bpCheck|(bf&BFFOCUS)); > if (wParam == (WPARAM)NULL) > EndPaint(hwnd, &ps); > return 0L; > } > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctButton), hwnd, wm, wParam, lParam); > } > > > void ListEditPaint3d(HWND hwnd, BOOL fEdit, int ct) > { > CTLID id; > RC rc; > HDC hdc; > HWND hwndParent; > LONG lStyle; > DR3 dr3; > > if(!((lStyle = GetWindowLong(hwnd, GWL_STYLE)) & WS_VISIBLE)) > return; > > if ((ct == ctCombo && (lStyle & 0x003) == CBS_DROPDOWNLIST)) > { > if ( SendMessage(hwnd, CB_GETDROPPEDSTATE,0,0L) ) > return; > } > > if (fEdit) > HideCaret(hwnd); > > GetWindowRect(hwnd, (LPRECT) &rc); > > ScreenToClient(hwndParent = GetParent(hwnd), (LPPOINT) &rc); > ScreenToClient(hwndParent, ((LPPOINT) &rc)+1); > > hdc = GetDC(hwndParent); > > dr3 = dr3All; > > if(lStyle & WS_HSCROLL) > dr3 = dr3 & ~dr3Bot; > > if(lStyle & WS_VSCROLL) > dr3 = dr3 & ~dr3Right; > > // don't draw the top if it's a listbox of a simple combo > id = GetControlId(hwnd); > if (id == (CTLID) (1000 + fEdit)) > { > TCHAR szClass[cchClassMax]; > BOOL fSubclass = 666; > int ctParent; > > // could be superclassed! > fSubclass = 666; > ctParent = (int)SendMessage(hwndParent, WM_CHECKSUBCLASS, 0, (LPARAM)(int FAR *)&fSubclass); > > // could be subclassed! > GetClassName(hwndParent, szClass, sizeof(szClass)Win32Only(/sizeof(TCHAR))); > if (lstrcmp(szClass, mpctcdef[ctCombo].sz) == 0 || > (fSubclass == fTrue && ctParent == ctCombo+1000)) > { > HWND hwndComboParent; > > hwndComboParent = GetParent(hwndParent); > > Win16Only(GetWindowRect(hwnd, (LPRECT) &rc)); > Win16Only(ScreenToClient(hwndComboParent, (LPPOINT) &rc)); > Win16Only(ScreenToClient(hwndComboParent, ((LPPOINT) &rc)+1)); > > Win32Only(MapWindowPoints(hwndParent, hwndComboParent, (POINT*)&rc, 2)); > > ReleaseDC(hwndParent, hdc); > hdc = GetDC(hwndComboParent); > > if (fEdit) > { > RC rcList; > HWND hwndList; > long style; > > style = GetWindowLong(hwndParent, GWL_STYLE); > if (!(((style & 0x0003) == CBS_DROPDOWN) > || ((style & 0x0003) == CBS_DROPDOWNLIST))) > { > dr3 &= ~dr3Bot; > > hwndList = GetWindow(hwndParent, GW_CHILD); > GetWindowRect(hwndList, (LPRECT) &rcList); > > // Some ugly shit goin' on here! > rc.xRight -= rcList.xRight-rcList.xLeft; > DrawInsetRect3d(hdc, &rc, dr3Bot|dr3HackBotRight); > rc.xRight += rcList.xRight-rcList.xLeft; > } > else > { > // > // Is the drop down on the parent down ? if so don't paint. > // > if ( SendMessage(hwndParent, CB_GETDROPPEDSTATE,0,0L) ) > { > ReleaseDC(hwndComboParent, hdc); > ShowCaret(hwnd); > return; > } > } > } > else > { > rc.yTop++; > dr3 &= ~dr3Top; > } > > hwndParent = hwndComboParent; > > } > } > > DrawInsetRect3d(hdc, &rc, dr3); > > if ((ct == ctCombo && (lStyle & 0x003) == CBS_DROPDOWNLIST)) > { > rc.xLeft = rc.xRight - GetSystemMetrics(SM_CXVSCROLL); > DrawRec3d(hdc, &rc, icvWindowFrame, icvWindowFrame, dr3Right|dr3Bot); > Val3dCtl(hwnd); > } > else { > if (lStyle & WS_VSCROLL) > { > int SaveLeft; > > rc.xRight++; > DrawRec3d(hdc, &rc, icvBtnHilite, icvBtnHilite, dr3Right); > rc.xRight--; > SaveLeft = rc.xLeft; > rc.xLeft = rc.xRight - GetSystemMetrics(SM_CXVSCROLL); > DrawRec3d(hdc, &rc, icvWindowFrame, icvWindowFrame, dr3Bot); > rc.xLeft = SaveLeft; > } > if (lStyle & WS_HSCROLL) > { > rc.yBot++; > DrawRec3d(hdc, &rc, icvBtnHilite, icvBtnHilite, dr3Bot); > rc.yBot--; > rc.yTop = rc.yBot - GetSystemMetrics(SM_CXHSCROLL); > DrawRec3d(hdc, &rc, icvWindowFrame, icvWindowFrame, dr3Right); > } > } > > ReleaseDC(hwndParent, hdc); > if (fEdit) > ShowCaret(hwnd); > > } > > > LONG ShareEditComboWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam, int ct) > { > LONG l; > LONG style; > > if ( wm == WM_NCDESTROY ) > return CleanupSubclass(hwnd, wm, wParam, lParam, ct); > > if ( GetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable) ) > return CallWindowProc(LpfnGetDefWndProc(hwnd, ct), hwnd, wm, wParam, lParam); > > l = CallWindowProc(LpfnGetDefWndProc(hwnd,ct), hwnd, wm, wParam, lParam); > if (ct == ctCombo) > { > style = GetWindowLong(hwnd, GWL_STYLE); > if ((style & 0x0003) == CBS_DROPDOWN) > return l; > } > > switch(wm) > { > case WM_CHECKSUBCLASS: > *(int FAR *)lParam = fTrue; > return ctEdit+1000; > > case WM_SHOWWINDOW: > if (g3d.verWindows < ver31 && wParam == 0) > Inval3dCtl(hwnd, (WINDOWPOS FAR *) NULL); > break; > case WM_WINDOWPOSCHANGING: > if (g3d.verWindows >= ver31) > Inval3dCtl(hwnd, (WINDOWPOS FAR *) lParam); > break; > > case WM_PAINT: > { > if (ct != ctCombo || > (((style & 0x0003) == CBS_DROPDOWN) || ((style & 0x0003) == CBS_DROPDOWNLIST))) > ListEditPaint3d(hwnd, TRUE, ct); > } > break; > } > return l; > } > > > LRESULT __export _loadds WINAPI EditWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > return ShareEditComboWndProc3d(hwnd, wm, wParam, lParam, ctEdit); > } > > > LONG SharedListWndProc(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam, unsigned ct) > { > LONG l; > > if ( wm == WM_NCDESTROY ) > return CleanupSubclass(hwnd, wm, wParam, lParam, ct); > > if ( GetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable) ) > return CallWindowProc(LpfnGetDefWndProc(hwnd, ct), hwnd, wm, wParam, lParam); > > switch(wm) > { > case WM_CHECKSUBCLASS: > *(int FAR *)lParam = fTrue; > return ctList+1000; > > case WM_SHOWWINDOW: > if (g3d.verWindows < ver31 && wParam == 0) > Inval3dCtl(hwnd, (WINDOWPOS FAR *) NULL); > break; > case WM_WINDOWPOSCHANGING: > if (g3d.verWindows >= ver31) > Inval3dCtl(hwnd, (WINDOWPOS FAR *) lParam); > break; > case WM_PAINT: > l = CallWindowProc(LpfnGetDefWndProc(hwnd, ct), hwnd, wm, wParam, lParam); > ListEditPaint3d(hwnd, FALSE, ct); > return l; > case WM_NCCALCSIZE: > { > RC rc; > RC rcNew; > HWND hwndParent; > > // Inval3dCtl handles this case under Win 3.1 > if (g3d.verWindows >= ver31) > break; > > GetWindowRect(hwnd, (LPRECT) &rc); > #ifdef UNREACHABLE > if (g3d.verWindows >= ver31) > { > hwndParent = GetParent(hwnd); > ScreenToClient(hwndParent, (LPPOINT) &rc); > ScreenToClient(hwndParent, ((LPPOINT) &rc)+1); > } > #endif > > l = CallWindowProc(LpfnGetDefWndProc(hwnd, ct), hwnd, wm, wParam, lParam); > > rcNew = *(RC FAR *)lParam; > InflateRect((LPRECT) &rcNew, 2, 1); // +1 for border (Should use AdjustWindowRect) > if (rcNew.yBot < rc.yBot) > { > rcNew.yTop = rcNew.yBot+1; > rcNew.yBot = rc.yBot+1; > > #ifdef ALWAYS > if (g3d.verWindows < ver31) > #endif > { > hwndParent = GetParent(hwnd); > ScreenToClient(hwndParent, (LPPOINT) &rcNew); > ScreenToClient(hwndParent, ((LPPOINT) &rcNew)+1); > } > > InvalidateRect(hwndParent, (LPRECT) &rcNew, TRUE); > } > return l; > } > } > return CallWindowProc(LpfnGetDefWndProc(hwnd, ct), hwnd, wm, wParam, lParam); > } > > LRESULT __export _loadds WINAPI ListWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > return SharedListWndProc(hwnd, wm, wParam, lParam, ctList); > } > > > > LRESULT __export _loadds WINAPI ComboWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > switch(wm) > { > case WM_CHECKSUBCLASS: > *(int FAR *)lParam = fTrue; > return ctCombo+1000; > } > > return ShareEditComboWndProc3d(hwnd, wm, wParam, lParam, ctCombo); > } > > void StaticPrint(HWND hwnd, HDC hdc, RC FAR *lprc, LONG style) > { > WORD dt; > LONG cv; > Win16Or32(HANDLE , LPTSTR )hText; > int TextLen; > > PatBlt(hdc, lprc->xLeft, lprc->yTop, lprc->xRight-lprc->xLeft, lprc->yBot-lprc->yTop, PATCOPY); > > TextLen = GetWindowTextLength(hwnd); > > #ifndef WIN32 > hText = LocalAlloc(LPTR|LMEM_NODISCARD,(TextLen+5)*sizeof(TCHAR)); > #else > hText = _alloca((TextLen+5)*sizeof(TCHAR)); > #endif > if (hText == NULL) > return; > > if (GetWindowText(hwnd, (NPTSTR)hText, TextLen+2*sizeof(TCHAR)) == 0) > { > #ifndef WIN32 > LocalFree(hText); > #endif > return; > } > > if ((style & 0x000f) == SS_LEFTNOWORDWRAP) > dt = DT_NOCLIP | DT_EXPANDTABS; > else > { > dt = LOWORD(DT_NOCLIP | DT_EXPANDTABS | DT_WORDBREAK | ((style & 0x0000000f)-SS_LEFT)); > } > > if (style & SS_NOPREFIX) > dt |= DT_NOPREFIX; > > if (style & WS_DISABLED) > cv = SetTextColor(hdc, g3d.clrt.rgcv[icvGrayText]); > > DrawText(hdc, (NPTSTR)hText, -1, (LPRECT) lprc, dt); > > #ifndef WIN32 > LocalFree(hText); > #endif > > if (style & WS_DISABLED) > cv = SetTextColor(hdc, cv); > } > > void StaticPaint(HWND hwnd, HDC hdc) > { > LONG style; > RC rc; > > style = GetWindowLong(hwnd, GWL_STYLE); > if(!(style & WS_VISIBLE)) > return; > > GetClientRect(hwnd, (LPRECT) &rc); > switch(style & 0x0f) > { > case SS_BLACKRECT: > case SS_BLACKFRAME: // Inset rect > DrawRec3d(hdc, &rc, icvBtnShadow, icvBtnHilite, dr3All); > break; > case SS_GRAYRECT: > case SS_GRAYFRAME: > rc.xLeft++; > rc.yTop++; > DrawRec3d(hdc, &rc, icvBtnHilite, icvBtnHilite, dr3All); > OffsetRect((LPRECT) &rc, -1, -1); > DrawRec3d(hdc, &rc, icvBtnShadow, icvBtnShadow, dr3All); > break; > case SS_WHITERECT: // outset rect > case SS_WHITEFRAME: > DrawRec3d(hdc, &rc, icvBtnHilite, icvBtnShadow, dr3All); > break; > case SS_LEFT: > case SS_CENTER: > case SS_RIGHT: > case SS_LEFTNOWORDWRAP: > { > HANDLE hfont; > HBRUSH hbr; > > if((hfont = (HANDLE)SendMessage(hwnd, WM_GETFONT, 0, 0L)) != NULL) > hfont = SelectObject(hdc, hfont); > SetBkMode(hdc, OPAQUE); > > if(( hbr = SEND_COLOR_STATIC_MESSAGE(GetParent(hwnd), hwnd, hdc)) != NULL) > hbr = SelectObject(hdc, hbr); > > StaticPrint(hwnd, hdc, (RC FAR *)&rc, style); > > if (hfont != NULL) > SelectObject(hdc, hfont); > > if (hbr != NULL) > SelectObject(hdc, hbr); > } > break; > } > } > > > LRESULT __export _loadds WINAPI StaticWndProc3d(HWND hwnd, UINT wm, WPARAM wParam, LPARAM lParam) > { > HDC hdc; > PAINTSTRUCT ps; > > if ( wm == WM_NCDESTROY ) > return CleanupSubclass(hwnd, wm, wParam, lParam, ctStatic); > > if ( GetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable) ) > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctStatic), hwnd, wm, wParam, lParam); > > switch (wm) > { > case WM_CHECKSUBCLASS: > *(int FAR *)lParam = fTrue; > return ctStatic+1000; > > case WM_PAINT: > if ((hdc = (HDC) wParam) == NULL) > { > hdc = BeginPaint(hwnd, &ps); > ClipCtlDc(hwnd, hdc); > } > StaticPaint(hwnd, hdc); > if (wParam == (WPARAM)NULL) > EndPaint(hwnd, &ps); > return 0L; > > case WM_ENABLE: > hdc = GetDC(hwnd); > ClipCtlDc(hwnd, hdc); > StaticPaint(hwnd, hdc); > ReleaseDC(hwnd, hdc); > return 0L; > } > return CallWindowProc(LpfnGetDefWndProc(hwnd, ctStatic), hwnd, wm, wParam, lParam); > } > > > /*----------------------------------------------------------------------- > | LibMain > -----------------------------------------------------------------------*/ > #ifdef WIN32 > #ifdef DLL > BOOL CALLBACK LibMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved) > #else > #ifdef SDLL > BOOL FAR Ctl3dLibMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved) > #else > BOOL FAR LibMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved) > #endif > #endif > { > WORD wT; > DWORD dwVersion; > BOOL (WINAPI* pfnDisableThreadLibraryCalls)(HMODULE); > HMODULE hKernel; > > switch(dwReason) > { > case DLL_PROCESS_ATTACH: > // call DisableThreadLibraryCalls if available > hKernel = GetModuleHandleA("KERNEL32.DLL"); > *(FARPROC*)&pfnDisableThreadLibraryCalls = > GetProcAddress(hKernel, "DisableThreadLibraryCalls"); > if (pfnDisableThreadLibraryCalls != NULL) > (*pfnDisableThreadLibraryCalls)(hModule); > > #ifdef DLL > InitializeCriticalSection(&g_CriticalSection); > #endif > EnterCriticalSection(&g_CriticalSection); > #ifdef SDLL > g3d.hinstLib = g3d.hmodLib = _hModule; > #else > g3d.hinstLib = g3d.hmodLib = hModule; > #endif > > dwVersion = (DWORD)GetVersion(); > wT = LOWORD(dwVersion); > // get adjusted windows version > g3d.verWindows = (LOBYTE(wT) << 8) | HIBYTE(wT); > // Win32s or Win32 for real (Chicago reports Win32s) > g3d.verBase = > (dwVersion & 0x80000000) && g3d.verWindows < ver40 ? 16 : 32; > > g3d.dxFrame = GetSystemMetrics(SM_CXDLGFRAME)-dxBorder; > g3d.dyFrame = GetSystemMetrics(SM_CYDLGFRAME)-dyBorder; > g3d.dyCaption = GetSystemMetrics(SM_CYCAPTION); > g3d.dxSysMenu = GetSystemMetrics(SM_CXSIZE); > > LeaveCriticalSection(&g_CriticalSection); > } > return TRUE; > } > #else > #ifdef DLL > int WINAPI LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine) > #else > #ifdef SDLL > int FAR Ctl3dLibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine) > #else > #ifdef _BORLAND > BOOL FAR PASCAL LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine) > #else > BOOL FAR LibMain(HANDLE hModule, WORD wDataSeg, WORD cbHeapSize, LPSTR lpszCmdLine) > #endif > #endif > #endif > { > WORD wT; > #ifdef DLL > > #ifdef V2 > CodeLpszDecl(lpszCtl3d, "CTL3DV2"); > #else > CodeLpszDecl(lpszCtl3d, "CTL3D"); > #endif > > CodeLpszDecl(lpszUser, "user.exe"); > CodeLpszDecl(lpszSetWindowsHookEx, "SETWINDOWSHOOKEX"); > CodeLpszDecl(lpszUnhookWindowsHookEx, "UNHOOKWINDOWSHOOKEX"); > CodeLpszDecl(lpszCallNextHookEx, "CALLNEXTHOOKEX"); > #endif > > g3d.hinstLib = hModule; > #ifdef DLL > g3d.hmodLib = GetModuleHandle(lpszCtl3d); > #else > #ifdef SDLL > g3d.hinstLib = _hModule; > g3d.hmodLib = GetModuleHandle(MAKELP(0,_hModule)); > #else > g3d.hmodLib = hModule; > #endif > #endif > wT = LOWORD( GetVersion() ); > g3d.verWindows = (LOBYTE(wT) << 8) | HIBYTE(wT); > > if ( GetWinFlags() & 0x4000 ) > g3d.verBase = 24; // More then 16, not yet 32....WOW box on NT > else > g3d.verBase = 16; // Regular old 3.1 > > g3d.dxFrame = GetSystemMetrics(SM_CXDLGFRAME)-dxBorder; > g3d.dyFrame = GetSystemMetrics(SM_CYDLGFRAME)-dyBorder; > g3d.dyCaption = GetSystemMetrics(SM_CYCAPTION); > g3d.dxSysMenu = GetSystemMetrics(SM_CXSIZE); > > #ifdef DLL > if (g3d.verWindows >= ver31) > { > HANDLE hlib; > > hlib = LoadLibrary(lpszUser); > if (FValidLibHandle(hlib)) > { > (FARPROC) g3d.lpfnSetWindowsHookEx = GetProcAddress(hlib, lpszSetWindowsHookEx); > (FARPROC) g3d.lpfnUnhookWindowsHookEx = GetProcAddress(hlib, lpszUnhookWindowsHookEx); > (FARPROC) g3d.lpfnCallNextHookEx = GetProcAddress(hlib, lpszCallNextHookEx); > FreeLibrary(hlib); > } > } > #endif > return 1; > } > #endif // win32 > > // convert a RGB into a RGBQ > #define RGBQ(dw) RGB(GetBValue(dw),GetGValue(dw),GetRValue(dw)) > > // > // LoadUIBitmap() - load a bitmap resource > // > // load a bitmap resource from a resource file, converting all > // the standard UI colors to the current user specifed ones. > // > // this code is designed to load bitmaps used in "gray ui" or > // "toolbar" code. > // > // the bitmap must be a 4bpp windows 3.0 DIB, with the standard > // VGA 16 colors. > // > // the bitmap must be authored with the following colors > // > // Window Text Black (index 0) > // Button Shadow gray (index 7) > // Button Face lt gray (index 8) > // Button Highlight white (index 15) > // Window Color yellow (index 11) > // Window Frame green (index 10) > // > // Example: > // > // hbm = LoadUIBitmap(hInstance, "TestBmp", > // GetSysColor(COLOR_WINDOWTEXT), > // GetSysColor(COLOR_BTNFACE), > // GetSysColor(COLOR_BTNSHADOW), > // GetSysColor(COLOR_BTNHIGHLIGHT), > // GetSysColor(COLOR_WINDOW), > // GetSysColor(COLOR_WINDOWFRAME)); > // > // Author: JimBov, ToddLa > // > // > #ifdef WIN32 > > HBITMAP PASCAL LoadUIBitmap( > HANDLE hInstance, // EXE file to load resource from > LPCTSTR szName, // name of bitmap resource > COLORREF rgbText, // color to use for "Button Text" > COLORREF rgbFace, // color to use for "Button Face" > COLORREF rgbShadow, // color to use for "Button Shadow" > COLORREF rgbHighlight, // color to use for "Button Hilight" > COLORREF rgbWindow, // color to use for "Window Color" > COLORREF rgbFrame) // color to use for "Window Frame" > { > HBITMAP hbm; > LPBITMAPINFO lpbi; > HRSRC hrsrc; > HGLOBAL h; > HDC hdc; > DWORD size; > > // > // Load the bitmap resource and make a writable copy. > // > > hrsrc = FindResource(hInstance, szName, RT_BITMAP); > if (!hrsrc) > return(NULL); > size = SizeofResource( hInstance, hrsrc ); > h = LoadResource(hInstance,hrsrc); > if (!h) > return(NULL); > > lpbi = ( LPBITMAPINFO ) GlobalAlloc( GPTR, size ); > > if (!lpbi) > return(NULL); > > CopyMemory( lpbi, h, size ); > > *( LPCOLORREF ) &lpbi->bmiColors[0] = RGBQ(rgbText); // Black > *( LPCOLORREF ) &lpbi->bmiColors[7] = RGBQ(rgbShadow); // gray > *( LPCOLORREF ) &lpbi->bmiColors[8] = RGBQ(rgbFace); // lt gray > *( LPCOLORREF ) &lpbi->bmiColors[15] = RGBQ(rgbHighlight); // white > *( LPCOLORREF ) &lpbi->bmiColors[11] = RGBQ(rgbWindow); // yellow > *( LPCOLORREF ) &lpbi->bmiColors[10] = RGBQ(rgbFrame); // green > > hdc = GetDC(NULL); > > hbm = CreateDIBitmap(hdc, &lpbi->bmiHeader, CBM_INIT, (LPBYTE)(&lpbi->bmiColors[ 16 ]), > lpbi, DIB_RGB_COLORS); > > ReleaseDC(NULL, hdc); > GlobalFree( lpbi ); > > return(hbm); > } > > #else > > HBITMAP PASCAL LoadUIBitmap( > HANDLE hInstance, // EXE file to load resource from > LPCTSTR szName, // name of bitmap resource > COLORREF rgbText, // color to use for "Button Text" > COLORREF rgbFace, // color to use for "Button Face" > COLORREF rgbShadow, // color to use for "Button Shadow" > COLORREF rgbHighlight, // color to use for "Button Hilight" > COLORREF rgbWindow, // color to use for "Window Color" > COLORREF rgbFrame) // color to use for "Window Frame" > { > LPBYTE lpb; > HBITMAP hbm; > LPBITMAPINFOHEADER lpbi; > HANDLE h; > HDC hdc; > LPDWORD lprgb; > > h = LoadResource(hInstance,FindResource(hInstance, szName, RT_BITMAP)); > > lpbi = (LPBITMAPINFOHEADER)LockResource(h); > > if (!lpbi) > return(NULL); > > #ifdef NOTNEEDEDFORCTL3D > if (lpbi->biSize != sizeof(BITMAPINFOHEADER)) > return NULL; > > if (lpbi->biBitCount != 4) > return NULL; > #endif > > lprgb = (LPDWORD)((LPBYTE)lpbi + (int)lpbi->biSize); > lpb = (LPBYTE)(lprgb + 16); > > lprgb[0] = RGBQ(rgbText); // Black > > // lprgb[7] = RGBQ(rgbFace); // lt gray > // lprgb[8] = RGBQ(rgbShadow); // gray > > lprgb[7] = RGBQ(rgbShadow); // gray > lprgb[8] = RGBQ(rgbFace); // lt gray > > lprgb[15] = RGBQ(rgbHighlight); // white > lprgb[11] = RGBQ(rgbWindow); // yellow > lprgb[10] = RGBQ(rgbFrame); // green > > hdc = GetDC(NULL); > > hbm = CreateDIBitmap(hdc, lpbi, CBM_INIT, (LPVOID)lpb, > (LPBITMAPINFO)lpbi, DIB_RGB_COLORS); > > ReleaseDC(NULL, hdc); > UnlockResource(h); > FreeResource(h); > > return(hbm); > } > > > #endif // win32 > > > /*----------------------------------------------------------------------- > | > | DLL specific routines > | > ---------------------------------------------------------------WESC----*/ > > #ifndef WIN32 > #ifdef DLL > /*----------------------------------------------------------------------- > | WEP > -----------------------------------------------------------------------*/ > int FAR PASCAL WEP (int wSystemExit) > { > return 1; > } > #endif > #endif ---------- NONSHIP\CTL3D\ctl3d.c (02-06-95@00:43) next ---------- 111a112 > #define NO_STRICT 233a235 > #define CodeLpszDeclA(lpszVar, szLit) char *lpszVar = szLit 239a242 > #define CodeLpszDeclA(lpszVar, szLit) char *lpszVar = szLit 244a248,250 > #define CodeLpszDeclA(lpszVar, szLit) \ > static CSCONST(char) lpszVar##Code[] = szLit; \ > char far *lpszVar = (char far *)lpszVar##Code 1179c1185 < return 0x0226; --- > return 0x0227; 1759,1764c1765,1770 < CodeLpszDecl(lpszCtl3d, TEXT("CTL3DV2.DLL")), < CodeLpszDecl(lpszCtl3d, TEXT("CTL3D32.DLL"))); < CodeLpszDecl(lpszBadInstMsg, < TEXT("This application uses CTL3D32.DLL, which is not the correct version. ") < TEXT("This version of CTL3D32.DLL is designed only for Windows NT systems.")); < MessageBox(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK); --- > CodeLpszDeclA(lpszCtl3d, "CTL3DV2.DLL"), > CodeLpszDeclA(lpszCtl3d, "CTL3D32.DLL")); > CodeLpszDeclA(lpszBadInstMsg, > "This application uses CTL3D32.DLL, which is not the correct version. " > "This version of CTL3D32.DLL is designed only for Windows NT systems."); > MessageBoxA(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK); 1772,1777c1778,1783 < CodeLpszDecl(lpszCtl3d, TEXT("CTL3DV2.DLL")), < CodeLpszDecl(lpszCtl3d, TEXT("CTL3D32.DLL"))); < CodeLpszDecl(lpszBadInstMsg, < TEXT("This application uses CTL3D32.DLL, which is not the correct version. ") < TEXT("This version of CTL3D32.DLL is designed only for Win32s or Windows 95 systems.")); < MessageBox(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK); --- > CodeLpszDeclA(lpszCtl3d, "CTL3DV2.DLL"), > CodeLpszDeclA(lpszCtl3d, "CTL3D32.DLL")); > CodeLpszDeclA(lpszBadInstMsg, > "This application uses CTL3D32.DLL, which is not the correct version. " > "This version of CTL3D32.DLL is designed only for Win32s or Windows 95 systems."); > MessageBoxA(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK); 1805,1806c1811,1812 < CodeLpszDecl(lpszCtl3d, TEXT("CTL3DV2.DLL")), < CodeLpszDecl(lpszCtl3d, TEXT("CTL3D32.DLL"))); --- > CodeLpszDeclA(lpszCtl3d, "CTL3DV2.DLL"), > CodeLpszDeclA(lpszCtl3d, "CTL3D32.DLL")); 1808,1813c1814,1819 < CodeLpszDecl(lpszBadInstMsg, < TEXT("This application uses CTL3DV2.DLL, which has not been correctly installed. ") < TEXT("CTL3DV2.DLL must be installed in the Windows system directory.")), < CodeLpszDecl(lpszBadInstMsg, < TEXT("This application uses CTL3D32.DLL, which has not been correctly installed. ") < TEXT("CTL3D32.DLL must be installed in the Windows system directory."))); --- > CodeLpszDeclA(lpszBadInstMsg, > "This application uses CTL3DV2.DLL, which has not been correctly installed. " > "CTL3DV2.DLL must be installed in the Windows system directory."), > CodeLpszDeclA(lpszBadInstMsg, > "This application uses CTL3D32.DLL, which has not been correctly installed. " > "CTL3D32.DLL must be installed in the Windows system directory.")); 1815c1821 < MessageBox(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK ); --- > MessageBoxA(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK ); 3420c3426 < CodeLpszDecl(lpszCtl3d, "CTL3DV2"); --- > CodeLpszDeclA(lpszCtl3d, "CTL3DV2"); 3422c3428 < CodeLpszDecl(lpszCtl3d, "CTL3D"); --- > CodeLpszDeclA(lpszCtl3d, "CTL3D"); 3425,3428c3431,3434 < CodeLpszDecl(lpszUser, "user.exe"); < CodeLpszDecl(lpszSetWindowsHookEx, "SETWINDOWSHOOKEX"); < CodeLpszDecl(lpszUnhookWindowsHookEx, "UNHOOKWINDOWSHOOKEX"); < CodeLpszDecl(lpszCallNextHookEx, "CALLNEXTHOOKEX"); --- > CodeLpszDeclA(lpszUser, "user.exe"); > CodeLpszDeclA(lpszSetWindowsHookEx, "SETWINDOWSHOOKEX"); > CodeLpszDeclA(lpszUnhookWindowsHookEx, "UNHOOKWINDOWSHOOKEX"); > CodeLpszDeclA(lpszCallNextHookEx, "CALLNEXTHOOKEX"); ---------- NONSHIP\CTL3D\ctl3d.c (02-17-95@14:41) next ---------- 172a173 > #define MessageBoxA MessageBox 635a637 > BOOL fSubclass; 638c640,646 < SubclassWindow(cwpStruct->hwnd, lpfnSubclassByHook); --- > if (g3d.verWindows >= ver40 && (GetWindowLong(cwpStruct->hwnd, GWL_STYLE) & 0x04)) > fSubclass = fFalse; > else > fSubclass = fTrue; > SendMessage(cwpStruct->hwnd, WM_DLGSUBCLASS, 0, (LPARAM)(int FAR *)&fSubclass); > if (fSubclass) > SubclassWindow(cwpStruct->hwnd, lpfnSubclassByHook); 1185c1193 < return 0x0227; --- > return 0x0228; 1274c1282,1287 < SetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable, (HANDLE) 1); --- > if (GetProp(hwnd, (LPCTSTR) g3d.aCtl3d) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh)) > { > SetProp(hwnd,(LPCTSTR) g3d.aCtl3dDisable, (HANDLE) 1); > } 2200c2213,2220 < SubclassWindow((HWND)wParam, (FARPROC) Ctl3dDlgProc); --- > BOOL fSubclass; > if (g3d.verWindows >= ver40 && (GetWindowLong((HWND)wParam, GWL_STYLE) & 0x04)) > fSubclass = fFalse; > else > fSubclass = fTrue; > SendMessage((HWND)wParam, WM_DLGSUBCLASS, 0, (LPARAM)(int FAR *)&fSubclass); > if (fSubclass) > SubclassWindow((HWND)wParam, (FARPROC) Ctl3dDlgProc); ---------- NONSHIP\CTL3D\ctl3d.c (04-04-95@01:04) next ---------- 618a619,631 > #ifdef WIN32 > if (g3d.fDBCS && !IsWindowUnicode(hwnd)) > { > TCHAR szClass[cchClassMax]; > GetClassName(hwnd, szClass, cchClassMax); > if (lstrcmpi(szClass, TEXT("edit")) == 0) > { > lpfnWndProc = (FARPROC)SetWindowLongA(hwnd, GWL_WNDPROC,(LONG)lpfnSubclassProc); > goto SetProps; > } > } > #endif > 619a633 > SetProps: 1193c1207 < return 0x0228; --- > return 0x0229; ---------- NONSHIP\CTL3D\ctl3d.c (06-26-95@18:09) next ---------- 2388c2388 < wStyle = LOWORD(style) & 0xf; --- > wStyle = LOWORD(style) & 0x1f; 2393c2393,2394 < (wStyle >= SS_BLACKRECT && wStyle <= SS_WHITEFRAME)))); --- > ((wStyle >= SS_BLACKRECT && wStyle <= SS_WHITEFRAME) || > (g3d.verWindows < ver40 && wStyle >= 0x10 && wStyle <= 0x12))))); 3300c3301 < switch(style & 0x0f) --- > switch(style & 0x1f) 3307a3309,3311 > case 0x10: > case 0x11: > case 0x12: ---------- NONSHIP\CTL3D\ctl3d.c (07-13-95@20:24) next ---------- 491a492,494 > ATOM aCtl3dOld; > ATOM aCtl3dHighOld; > ATOM aCtl3dLowOld; 565,566c568,569 < < #define WM_CHECKSUBCLASS (WM_USER+5443) --- > #define WM_CHECKSUBCLASS_OLD (WM_USER+5443) > #define WM_CHECKSUBCLASS (WM_USER+5444) 610,611c613,618 < if (GetProp(hwnd, (LPCTSTR) g3d.aCtl3d) || < GetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow)) --- > if (GetProp(hwnd, (LPCTSTR) g3d.aCtl3dOld) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3d) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dLowOld) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh) || > GetProp(hwnd, (LPCTSTR) g3d.aCtl3dHighOld)) 1207c1214 < return 0x0229; --- > return 0x0231; 1404a1412,1413 > if ( fSubclass == 666 ) > SendMessage((HWND) hwnd, WM_CHECKSUBCLASS_OLD, 0, (LPARAM)(int FAR *)&fSubclass); 1869,1871c1878,1883 < CodeLpszDecl(lpszC3d, TEXT("C3d")); < CodeLpszDecl(lpszC3dL, TEXT("C3dL")); < CodeLpszDecl(lpszC3dH, TEXT("C3dH")); --- > CodeLpszDecl(lpszC3dOld, TEXT("C3d")); > CodeLpszDecl(lpszC3dLOld, TEXT("C3dL")); > CodeLpszDecl(lpszC3dHOld, TEXT("C3dH")); > CodeLpszDecl(lpszC3d, TEXT("C3dNew")); > CodeLpszDecl(lpszC3dL, TEXT("C3dLNew")); > CodeLpszDecl(lpszC3dH, TEXT("C3dHNew")); 1872a1885,1890 > g3d.aCtl3dOld = GlobalAddAtom(lpszC3dOld); > if (g3d.aCtl3dOld == 0) > { > g3d.f3dDialogs = fFalse; > goto Return; > } 1879a1898,1905 > g3d.aCtl3dLowOld = GlobalAddAtom(lpszC3dLOld); > g3d.aCtl3dHighOld = GlobalAddAtom(lpszC3dHOld); > if (g3d.aCtl3dLowOld == 0 || g3d.aCtl3dHighOld == 0) > { > g3d.f3dDialogs = fFalse; > return fFalse; > } > 1945,1947c1971,1976 < Win32Only(g3d.aCtl3d ? GlobalDeleteAtom(g3d.aCtl3d) : 0); < Win16Only(g3d.aCtl3dLow ? GlobalDeleteAtom(g3d.aCtl3dLow) : 0); < Win16Only(g3d.aCtl3dHigh ? GlobalDeleteAtom(g3d.aCtl3dHigh) : 0); --- > g3d.aCtl3dOld ? GlobalDeleteAtom(g3d.aCtl3dOld) : 0; > g3d.aCtl3d ? GlobalDeleteAtom(g3d.aCtl3d) : 0; > g3d.aCtl3dLowOld ? GlobalDeleteAtom(g3d.aCtl3dLowOld) : 0; > g3d.aCtl3dHighOld ? GlobalDeleteAtom(g3d.aCtl3dHighOld) : 0; > g3d.aCtl3dLow ? GlobalDeleteAtom(g3d.aCtl3dLow) : 0; > g3d.aCtl3dHigh ? GlobalDeleteAtom(g3d.aCtl3dHigh) : 0; 2047a2077 > case WM_CHECKSUBCLASS_OLD: 2861a2892 > case WM_CHECKSUBCLASS_OLD: 2994a3026,3028 > if (fSubclass == 666) > ctParent = (int)SendMessage(hwndParent, WM_CHECKSUBCLASS_OLD, 0, (LPARAM)(int FAR *)&fSubclass); > 3116a3151 > case WM_CHECKSUBCLASS_OLD: 3159a3195 > case WM_CHECKSUBCLASS_OLD: 3232a3269 > case WM_CHECKSUBCLASS_OLD: 3362a3400 > case WM_CHECKSUBCLASS_OLD: