/*----------------------------------------------------------------------- | | 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. | | -----------------------------------------------------------------------*/ #define NO_STRICT #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 MessageBoxA MessageBox #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 CodeLpszDeclA(lpszVar, szLit) char *lpszVar = szLit #define _alloca alloca #define _memcmp memcmp #else #ifdef WIN32 #define CSCONST(type) type const #define CodeLpszDecl(lpszVar, szLit) TCHAR *lpszVar = szLit #define CodeLpszDeclA(lpszVar, szLit) char *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 #define CodeLpszDeclA(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 aCtl3dOld; ATOM aCtl3dHighOld; ATOM aCtl3dLowOld; 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_OLD (WM_USER+5443) #define WM_CHECKSUBCLASS (WM_USER+5444) /*----------------------------------------------------------------------- | 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.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)) { return; } // Is this already subclassed by CTL3D? if (LpfnGetDefWndProcNull(hwnd) == (FARPROC) NULL) { #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 lpfnWndProc = (FARPROC)SetWindowLong((HWND) hwnd, GWL_WNDPROC, (LONG) lpfnSubclassProc); SetProps: 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 ) { BOOL fSubclass; UnhookWindowsHookEx(hhookCallWndProcFilterProc); 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); 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 0x0231; } /*----------------------------------------------------------------------- | 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 if (GetProp(hwnd, (LPCTSTR) g3d.aCtl3d) || GetProp(hwnd, (LPCTSTR) g3d.aCtl3dLow) || GetProp(hwnd, (LPCTSTR) g3d.aCtl3dHigh)) { 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 ) SendMessage((HWND) hwnd, WM_CHECKSUBCLASS_OLD, 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( 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); g3d.f3dDialogs = fFalse; goto Return; } #else if (!(GetVersion() & 0x80000000)) { Win16Or32( 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); g3d.f3dDialogs = fFalse; goto Return; } #endif #endif #ifndef SPECIAL_WOW_VERSION 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( CodeLpszDeclA(lpszCtl3d, "CTL3DV2.DLL"), CodeLpszDeclA(lpszCtl3d, "CTL3D32.DLL")); Win16Or32( 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.")); Win32Only(LeaveCriticalSection(&g_CriticalSection)); MessageBoxA(NULL, lpszBadInstMsg, lpszCtl3d, MB_ICONSTOP | MB_OK ); g3d.f3dDialogs = fFalse; goto Return; } } #endif //!SPECIAL_WOW_VERSION 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(lpszC3dOld, TEXT("C3d")); CodeLpszDecl(lpszC3dLOld, TEXT("C3dL")); CodeLpszDecl(lpszC3dHOld, TEXT("C3dH")); CodeLpszDecl(lpszC3d, TEXT("C3dNew")); CodeLpszDecl(lpszC3dL, TEXT("C3dLNew")); CodeLpszDecl(lpszC3dH, TEXT("C3dHNew")); g3d.aCtl3dOld = GlobalAddAtom(lpszC3dOld); if (g3d.aCtl3dOld == 0) { g3d.f3dDialogs = fFalse; goto Return; } g3d.aCtl3d = GlobalAddAtom(lpszC3d); if (g3d.aCtl3d == 0) { g3d.f3dDialogs = fFalse; goto Return; } g3d.aCtl3dLowOld = GlobalAddAtom(lpszC3dLOld); g3d.aCtl3dHighOld = GlobalAddAtom(lpszC3dHOld); if (g3d.aCtl3dLowOld == 0 || g3d.aCtl3dHighOld == 0) { g3d.f3dDialogs = fFalse; return fFalse; } 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(); 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; 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_OLD: 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) { 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); } 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) & 0x1f; return (wStyle != SS_ICON && ((grbit & CTL3D_STATICTEXTS) && (wStyle <= SS_RIGHT || wStyle == SS_LEFTNOWORDWRAP) || ((grbit & CTL3D_STATICFRAMES) && ((wStyle >= SS_BLACKRECT && wStyle <= SS_WHITEFRAME) || (g3d.verWindows < ver40 && wStyle >= 0x10 && wStyle <= 0x12))))); } /*----------------------------------------------------------------------- | 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_OLD: 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); if (fSubclass == 666) ctParent = (int)SendMessage(hwndParent, WM_CHECKSUBCLASS_OLD, 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); 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_OLD: 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_OLD: 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_OLD: 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 & 0x1f) { case SS_BLACKRECT: case SS_BLACKFRAME: // Inset rect DrawRec3d(hdc, &rc, icvBtnShadow, icvBtnHilite, dr3All); break; case SS_GRAYRECT: case SS_GRAYFRAME: case 0x10: case 0x11: case 0x12: 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_OLD: 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 CodeLpszDeclA(lpszCtl3d, "CTL3DV2"); #else CodeLpszDeclA(lpszCtl3d, "CTL3D"); #endif CodeLpszDeclA(lpszUser, "user.exe"); CodeLpszDeclA(lpszSetWindowsHookEx, "SETWINDOWSHOOKEX"); CodeLpszDeclA(lpszUnhookWindowsHookEx, "UNHOOKWINDOWSHOOKEX"); CodeLpszDeclA(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