|
|
---------- 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 <windows.h>> > #ifdef _BORLAND> #include <mem.h>> #else> #include <memory.h>> #endif> > #include <malloc.h>> #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_STRICT233a235> #define CodeLpszDeclA(lpszVar, szLit) char *lpszVar = szLit239a242> #define CodeLpszDeclA(lpszVar, szLit) char *lpszVar = szLit244a248,250> #define CodeLpszDeclA(lpszVar, szLit) \> static CSCONST(char) lpszVar##Code[] = szLit; \> char far *lpszVar = (char far *)lpszVar##Code1179c1185< 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 MessageBox635a637> 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:
|
