![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bttncur.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / bttncur|
Return to bttncur.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / bttncur |
1.1 ! root 1: /* ! 2: * BTTNCUR.C ! 3: * Buttons & Cursors Version 1.1, March 1993 ! 4: * ! 5: * Public functions to generate different states of toolbar buttons from ! 6: * a single bitmap. States are normal, pressed, checked, and disabled. ! 7: * ! 8: * Copyright (c)1992-1993 Microsoft Corporation, All Rights Reserved, ! 9: * as applied to redistribution of this source code in source form ! 10: * License is granted to use of compiled code in shipped binaries. ! 11: */ ! 12: ! 13: #ifdef WIN32 ! 14: #define _INC_OLE ! 15: #define __RPC_H__ ! 16: #endif ! 17: ! 18: ! 19: #define STRICT ! 20: #include <windows.h> ! 21: #include <memory.h> ! 22: #include "bttncur.h" ! 23: #include "bttncuri.h" ! 24: ! 25: ! 26: ! 27: //Display sensitive information ! 28: TOOLDISPLAYDATA tdd; ! 29: ! 30: //Library instance ! 31: HINSTANCE ghInst; ! 32: ! 33: ! 34: //Cache GDI objects to speed drawing. ! 35: HDC hDCGlyphs = NULL; ! 36: HDC hDCMono = NULL; ! 37: HBRUSH hBrushDither = NULL; ! 38: ! 39: //Standard images to use in case caller doesn't provide them ! 40: HBITMAP rghBmpStandardImages[3]; ! 41: ! 42: //Standard button colors. ! 43: const COLORREF crStandard[4]={ RGB(0, 0, 0) //STDCOLOR_BLACK ! 44: , RGB(128, 128, 128) //STDCOLOR_DKGRAY ! 45: , RGB(192, 192, 192) //STDCOLOR_LTGRAY ! 46: , RGB(255, 255, 255)}; //STDCOLOR_WHITE ! 47: ! 48: ! 49: /* ! 50: * Mapping from image identifier to button type (command/attribute). ! 51: * Version 1.00 of this DLL has no attribute images defined, so ! 52: * the code will only support three states for each command ! 53: * button. Any state is, however, valid for an application ! 54: * defined image. ! 55: */ ! 56: ! 57: UINT mpButtonType[TOOLIMAGE_MAX-TOOLIMAGE_MIN+1]= ! 58: { ! 59: BUTTONTYPE_COMMAND, BUTTONTYPE_COMMAND, BUTTONTYPE_COMMAND, ! 60: BUTTONTYPE_COMMAND, BUTTONTYPE_COMMAND, BUTTONTYPE_COMMAND, ! 61: BUTTONTYPE_COMMAND, BUTTONTYPE_COMMAND, BUTTONTYPE_COMMAND ! 62: }; ! 63: ! 64: ! 65: ! 66: ! 67: /* ! 68: * LibMain ! 69: * ! 70: * Purpose: ! 71: * DLL-specific entry point called from LibEntry. Initializes ! 72: * global variables and loads standard image bitmaps. ! 73: * ! 74: * Parameters: ! 75: * hInstance HANDLE instance of the DLL. ! 76: * wDataSeg WORD segment selector of the DLL's data segment. ! 77: * wHeapSize WORD byte count of the heap. ! 78: * lpCmdLine LPSTR to command line used to start the module. ! 79: * ! 80: * Return Value: ! 81: * HANDLE Instance handle of the DLL. ! 82: */ ! 83: ! 84: BOOL xxxLibMain(HINSTANCE hInstance) ! 85: { ! 86: int i; ! 87: ! 88: ghInst=hInstance; ! 89: ! 90: tdd.uDPI =96; ! 91: tdd.cyBar =CYBUTTONBAR96; ! 92: tdd.cxButton =TOOLBUTTON_STD96WIDTH; ! 93: tdd.cyButton =TOOLBUTTON_STD96HEIGHT; ! 94: tdd.cxImage =TOOLBUTTON_STD96IMAGEWIDTH; ! 95: tdd.cyImage =TOOLBUTTON_STD96IMAGEHEIGHT; ! 96: tdd.uIDImages=IDB_STANDARDIMAGES96; ! 97: ! 98: for (i=0; i < 3; i++) ! 99: { ! 100: rghBmpStandardImages[i]=LoadBitmap(hInstance ! 101: , MAKEINTRESOURCE(IDB_STANDARDIMAGESMIN+i)); ! 102: ! 103: if (NULL==rghBmpStandardImages[i]) ! 104: return FALSE; ! 105: } ! 106: ! 107: ! 108: //Perform global initialization. ! 109: if (ToolButtonInit()) ! 110: { ! 111: CursorsCache(hInstance); ! 112: ! 113: ! 114: return TRUE; ! 115: } ! 116: ! 117: return FALSE; ! 118: ! 119: } ! 120: ! 121: #ifdef WIN32 ! 122: ! 123: extern BOOL WINAPI _CRT_INIT(HINSTANCE hInst, DWORD dwReason, LPVOID lpReserved); ! 124: extern _cexit(void); ! 125: void FAR PASCAL WEP(int); ! 126: ! 127: extern BOOL __stdcall LibMain ! 128: ( ! 129: HINSTANCE hInstance, ! 130: ULONG Reason, ! 131: PCONTEXT Context ! 132: ) ! 133: { ! 134: OutputDebugString("bttncur LibMain: bttncur.dll loaded\r\n"); ! 135: ! 136: UNREFERENCED_PARAMETER(Context); ! 137: ! 138: if (Reason == DLL_PROCESS_DETACH) { ! 139: ! 140: _CRT_INIT(hInstance,Reason,NULL); ! 141: WEP(0); ! 142: return TRUE; ! 143: } ! 144: else if (Reason != DLL_PROCESS_ATTACH) ! 145: return TRUE; ! 146: ! 147: if (!_CRT_INIT(hInstance,Reason,NULL)) ! 148: return FALSE; ! 149: ! 150: return xxxLibMain(hInstance); ! 151: ! 152: } ! 153: ! 154: #else ! 155: ! 156: HANDLE FAR PASCAL LibMain(HANDLE hInstance, WORD wDataSeg ! 157: , WORD cbHeapSize, LPSTR lpCmdLine) ! 158: { ! 159: ! 160: //Perform global initialization. ! 161: if (xxxLibMain(hInstance)) ! 162: if (0!=cbHeapSize) ! 163: UnlockData(0); ! 164: ! 165: return hInstance; ! 166: ! 167: } ! 168: ! 169: #endif ! 170: ! 171: ! 172: /* ! 173: * WEP ! 174: * ! 175: * Purpose: ! 176: * Required DLL Exit function. Does nothing. ! 177: * ! 178: * Parameters: ! 179: * bSystemExit BOOL indicating if the system is being shut ! 180: * down or the DLL has just been unloaded. ! 181: * ! 182: * Return Value: ! 183: * void ! 184: * ! 185: */ ! 186: ! 187: void FAR PASCAL WEP(int bSystemExit) ! 188: { ! 189: /* ! 190: * **Developers: Note that WEP is called AFTER Windows does any ! 191: * automatic task cleanup. You may see warnings for ! 192: * that two DCs, a bitmap, and a brush, were not ! 193: * deleted before task termination. THIS IS NOT A ! 194: * PROBLEM WITH THIS CODE AND IT IS NOT A BUG. This ! 195: * WEP function is properly called and performs the ! 196: * cleanup as appropriate. The fact that Windows is ! 197: * calling WEP after checking task cleanup is not ! 198: * something we can control. Just to prove it, the ! 199: * OutputDebugStrings in this and ToolButtonFree ! 200: * show that the code is exercised. ! 201: */ ! 202: ! 203: #ifdef DEBUG ! 204: OutputDebugString("WEP Entry\r\n"); ! 205: #endif ! 206: ! 207: CursorsFree(); ! 208: ToolButtonFree(); ! 209: ! 210: #ifdef DEBUG ! 211: OutputDebugString("WEP Exit\r\n"); ! 212: #endif ! 213: return; ! 214: } ! 215: ! 216: ! 217: ! 218: ! 219: ! 220: /* ! 221: * UIToolConfigureForDisplay ! 222: * Public API ! 223: * ! 224: * Purpose: ! 225: * Initializes the library to scale button images for the display type. ! 226: * Without calling this function the library defaults to 96 DPI (VGA). ! 227: * By calling this function an application acknowledges that it must ! 228: * use the data returned from this function to configure itself for ! 229: * the display. ! 230: * ! 231: * Parameters: ! 232: * lpDD LPTOOLDISPLAYDATA to fill with the display-sensitive ! 233: * size values. ! 234: * ! 235: * Return Value: ! 236: * BOOL TRUE if the sizes were obtained, FALSE otherwise. ! 237: */ ! 238: ! 239: BOOL WINAPI UIToolConfigureForDisplay(LPTOOLDISPLAYDATA lpDD) ! 240: { ! 241: int cy; ! 242: HDC hDC; ! 243: ! 244: ! 245: if (NULL==lpDD || IsBadWritePtr(lpDD, sizeof(TOOLDISPLAYDATA))) ! 246: return FALSE; ! 247: ! 248: /* ! 249: * Determine the aspect ratio of the display we're currently ! 250: * running on and calculate the necessary information. ! 251: * ! 252: * By retrieving the logical Y extent of the display driver, you ! 253: * only have limited possibilities: ! 254: * LOGPIXELSY Display ! 255: * ---------------------------------------- ! 256: * 48 CGA (unsupported) ! 257: * 72 EGA ! 258: * 96 VGA ! 259: * 120 8514/a (i.e. HiRes VGA) ! 260: */ ! 261: ! 262: hDC=GetDC(NULL); ! 263: ! 264: if (NULL==hDC) ! 265: return FALSE; ! 266: ! 267: cy=GetDeviceCaps(hDC, LOGPIXELSY); ! 268: ReleaseDC(NULL, hDC); ! 269: ! 270: /* ! 271: * Instead of single comparisons, check ranges instead, so in case ! 272: * we get something funky, we'll act reasonable. ! 273: */ ! 274: if (72 >=cy) ! 275: { ! 276: lpDD->uDPI =72; ! 277: lpDD->cyBar =CYBUTTONBAR72; ! 278: lpDD->cxButton =TOOLBUTTON_STD72WIDTH; ! 279: lpDD->cyButton =TOOLBUTTON_STD72HEIGHT; ! 280: lpDD->cxImage =TOOLBUTTON_STD72IMAGEWIDTH; ! 281: lpDD->cyImage =TOOLBUTTON_STD72IMAGEHEIGHT; ! 282: lpDD->uIDImages=IDB_STANDARDIMAGES72; ! 283: } ! 284: else ! 285: { ! 286: if (72 < cy && 120 > cy) ! 287: { ! 288: lpDD->uDPI =96; ! 289: lpDD->cyBar =CYBUTTONBAR96; ! 290: lpDD->cxButton =TOOLBUTTON_STD96WIDTH; ! 291: lpDD->cyButton =TOOLBUTTON_STD96HEIGHT; ! 292: lpDD->cxImage =TOOLBUTTON_STD96IMAGEWIDTH; ! 293: lpDD->cyImage =TOOLBUTTON_STD96IMAGEHEIGHT; ! 294: lpDD->uIDImages=IDB_STANDARDIMAGES96; ! 295: } ! 296: else ! 297: { ! 298: lpDD->uDPI =120; ! 299: lpDD->cyBar =CYBUTTONBAR120; ! 300: lpDD->cxButton =TOOLBUTTON_STD120WIDTH; ! 301: lpDD->cyButton =TOOLBUTTON_STD120HEIGHT; ! 302: lpDD->cxImage =TOOLBUTTON_STD120IMAGEWIDTH; ! 303: lpDD->cyImage =TOOLBUTTON_STD120IMAGEHEIGHT; ! 304: lpDD->uIDImages=IDB_STANDARDIMAGES120; ! 305: } ! 306: } ! 307: ! 308: return TRUE; ! 309: } ! 310: ! 311: ! 312: ! 313: ! 314: ! 315: ! 316: ! 317: ! 318: /* ! 319: * ToolButtonInit ! 320: * Internal ! 321: * ! 322: * Purpose: ! 323: * Initializes GDI objects for drawing images through UIToolButtonDraw. ! 324: * If the function fails, the function has already performed proper ! 325: * cleanup. ! 326: * ! 327: * Parameters: ! 328: * None ! 329: * ! 330: * Return Value: ! 331: * BOOL TRUE if initialization succeeded. FALSE otherwise. ! 332: */ ! 333: ! 334: static BOOL ToolButtonInit(void) ! 335: { ! 336: COLORREF rgbHi; ! 337: ! 338: //DC for BitBltting the image (the glyph) ! 339: hDCGlyphs=CreateCompatibleDC(NULL); ! 340: ! 341: //Create a monochrome DC and a brush for doing pattern dithering. ! 342: hDCMono=CreateCompatibleDC(NULL); ! 343: ! 344: //Windows 3.0 doesn't support COLOR_BTNHIGHLIGHT, so leave it white. ! 345: if (0x0300 < (UINT)GetVersion()) ! 346: rgbHi=GetSysColor(COLOR_BTNHIGHLIGHT); ! 347: else ! 348: rgbHi=crStandard[STDCOLOR_WHITE]; ! 349: ! 350: hBrushDither=HBrushDitherCreate(GetSysColor(COLOR_BTNFACE), rgbHi); ! 351: ! 352: if (NULL==hDCGlyphs || NULL==hDCMono || NULL==hBrushDither) ! 353: { ! 354: //On failure, cleanup whatever might have been allocated. ! 355: ToolButtonFree(); ! 356: return FALSE; ! 357: } ! 358: ! 359: return TRUE; ! 360: } ! 361: ! 362: ! 363: ! 364: ! 365: ! 366: /* ! 367: * ToolButtonFree ! 368: * Internal ! 369: * ! 370: * Purpose: ! 371: * Free all GDI allocations made during initialization. Note that the ! 372: * DEBUG output included here shows that WEP is called and cleanup actually ! 373: * occurs. However, if you watch debug output in DBWIN or on a terminal, ! 374: * the debugging version of Windows does automatic app cleanup before WEP ! 375: * is called, leading some to believe that this code is buggy. The ! 376: * debug output below shows that we do perform all necessary cleanup. ! 377: * ! 378: * Parameters: ! 379: * None ! 380: * ! 381: * Return Value: ! 382: * None ! 383: */ ! 384: ! 385: static void ToolButtonFree(void) ! 386: { ! 387: UINT i; ! 388: ! 389: if (NULL!=hDCMono) ! 390: DeleteDC(hDCMono); ! 391: hDCMono=NULL; ! 392: ! 393: ! 394: if (NULL!=hDCGlyphs) ! 395: DeleteDC(hDCGlyphs); ! 396: hDCGlyphs=NULL; ! 397: ! 398: if (NULL!=hBrushDither) ! 399: DeleteObject(hBrushDither); ! 400: hBrushDither=NULL; ! 401: ! 402: for (i=0; i < 3; i++) ! 403: { ! 404: if (NULL!=rghBmpStandardImages[i]) ! 405: DeleteObject(rghBmpStandardImages[i]); ! 406: rghBmpStandardImages[i]=NULL; ! 407: } ! 408: ! 409: return; ! 410: } ! 411: ! 412: ! 413: ! 414: ! 415: ! 416: /* ! 417: * HBrushDitherCreate ! 418: * Internal ! 419: * ! 420: * Purpose: ! 421: * Creates and returns a handle to a pattern brush created from ! 422: * an 8*8 monochrome pattern bitmap. We use the button face and ! 423: * highlight colors to indicate the resulting colors of a PatBlt ! 424: * using this brush. ! 425: * ! 426: * Parameters: ! 427: * rgbFace COLORREF of the button face color. ! 428: * rgbHilight COLORREF of the button highlight color. ! 429: * ! 430: * Return Value: ! 431: * HBITMAP Handle to the dither bitmap. ! 432: */ ! 433: ! 434: static HBRUSH HBrushDitherCreate(COLORREF rgbFace, COLORREF rgbHilight) ! 435: { ! 436: struct //BITMAPINFO with 16 colors ! 437: { ! 438: BITMAPINFOHEADER bmiHeader; ! 439: RGBQUAD bmiColors[16]; ! 440: } bmi; ! 441: ! 442: HBRUSH hBrush=NULL; ! 443: DWORD patGray[8]; ! 444: HDC hDC; ! 445: HBITMAP hBmp; ! 446: static COLORREF rgbFaceOld =0xFFFFFFFF; //Initially an impossible color ! 447: static COLORREF rgbHilightOld=0xFFFFFFFF; //so at first we always create ! 448: ! 449: /* ! 450: * If the colors haven't changed from last time, just return the ! 451: * existing brush. ! 452: */ ! 453: if (rgbFace==rgbFaceOld && rgbHilight==rgbHilightOld) ! 454: return hBrushDither; ! 455: ! 456: rgbFaceOld=rgbFace; ! 457: rgbHilightOld=rgbHilight; ! 458: ! 459: /* ! 460: * We're going to create an 8*8 brush for PatBlt using the ! 461: * button face color and button highlight color. We use this ! 462: * brush to affect the pressed state and the disabled state. ! 463: */ ! 464: bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER); ! 465: bmi.bmiHeader.biWidth = 8; ! 466: bmi.bmiHeader.biHeight = 8; ! 467: bmi.bmiHeader.biPlanes = 1; ! 468: bmi.bmiHeader.biBitCount = 1; ! 469: bmi.bmiHeader.biCompression = BI_RGB; ! 470: bmi.bmiHeader.biSizeImage = 0; ! 471: bmi.bmiHeader.biXPelsPerMeter= 0; ! 472: bmi.bmiHeader.biYPelsPerMeter= 0; ! 473: bmi.bmiHeader.biClrUsed = 0; ! 474: bmi.bmiHeader.biClrImportant = 0; ! 475: ! 476: bmi.bmiColors[0].rgbBlue = GetBValue(rgbFace); ! 477: bmi.bmiColors[0].rgbGreen = GetGValue(rgbFace); ! 478: bmi.bmiColors[0].rgbRed = GetRValue(rgbFace); ! 479: bmi.bmiColors[0].rgbReserved = 0; ! 480: ! 481: bmi.bmiColors[1].rgbBlue = GetBValue(rgbHilight); ! 482: bmi.bmiColors[1].rgbGreen = GetGValue(rgbHilight); ! 483: bmi.bmiColors[1].rgbRed = GetRValue(rgbHilight); ! 484: bmi.bmiColors[1].rgbReserved = 0; ! 485: ! 486: //Create the byte array for CreateDIBitmap. ! 487: patGray[6]=patGray[4]=patGray[2]=patGray[0]=0x5555AAAAL; ! 488: patGray[7]=patGray[5]=patGray[3]=patGray[1]=0xAAAA5555L; ! 489: ! 490: //Create the bitmap ! 491: hDC=GetDC(NULL); ! 492: hBmp=CreateDIBitmap(hDC, &bmi.bmiHeader, CBM_INIT, patGray ! 493: , (LPBITMAPINFO)&bmi, DIB_RGB_COLORS); ! 494: ReleaseDC(NULL, hDC); ! 495: ! 496: //Create the brush from the bitmap ! 497: if (NULL!=hBmp) ! 498: { ! 499: hBrush=CreatePatternBrush(hBmp); ! 500: DeleteObject(hBmp); ! 501: } ! 502: ! 503: /* ! 504: * If we could recreate a brush, clean up and make it the current ! 505: * pattern. Otherwise the best we can do it return the old one, ! 506: * which will be colored wrong, but at least it works. ! 507: */ ! 508: if (NULL!=hBrush) ! 509: { ! 510: if (NULL!=hBrushDither) ! 511: DeleteObject(hBrushDither); ! 512: ! 513: hBrushDither=hBrush; ! 514: } ! 515: ! 516: return hBrushDither; ! 517: } ! 518: ! 519: ! 520: ! 521: ! 522: ! 523: /* ! 524: * UIToolButtonDraw ! 525: * Public API ! 526: * ! 527: * Purpose: ! 528: * Draws the complete image of a toolbar-style button with a given ! 529: * image in the center and in a specific state. The button is drawn ! 530: * on a specified hDC at a given location, so this function is useful ! 531: * on standard owner-draw buttons as well as on toolbar controls that ! 532: * have only one window but show images of multiple buttons. ! 533: * ! 534: * Parameters: ! 535: * hDC HDC on which to draw. ! 536: * x, y int coordinates at which to draw. ! 537: * dx, dy int dimensions of the *button*, not necessarily the image. ! 538: * hBmp HBITMAP from which to draw the image. ! 539: * bmx, bmy int dimensions of each bitmap in hBmp. If hBmp is NULL ! 540: * then these are forced to the standard sizes. ! 541: * iImage int index to the image to draw in the button ! 542: * uStateIn UINT containing the state index for the button and the ! 543: * color control bits. ! 544: * ! 545: * Return Value: ! 546: * BOOL TRUE if drawing succeeded, FALSE otherwise meaning that ! 547: * hDC is NULL or hBmp is NULL and iImage is not a valid ! 548: * index for a standard image. ! 549: */ ! 550: ! 551: BOOL WINAPI UIToolButtonDraw(HDC hDC, int x, int y, int dx, int dy ! 552: , HBITMAP hBmp, int bmx, int bmy, int iImage, UINT uStateIn) ! 553: { ! 554: return UIToolButtonDrawTDD(hDC, x, y, dx, dy, hBmp, bmx, bmy, iImage ! 555: , uStateIn, &tdd); ! 556: } ! 557: ! 558: ! 559: ! 560: ! 561: ! 562: ! 563: /* ! 564: * UIToolButtonDrawTDD ! 565: * Public API ! 566: * ! 567: * Purpose: ! 568: * Draws the complete image of a toolbar-style button with a given ! 569: * image in the center and in a specific state. The button is drawn ! 570: * on a specified hDC at a given location, so this function is useful ! 571: * on standard owner-draw buttons as well as on toolbar controls that ! 572: * have only one window but show images of multiple buttons. ! 573: * ! 574: * This is the same as UIToolButtonDraw but adds the pTDD configuration ! 575: * structure. UIToolButtonDraw calls us with that pointing to the ! 576: * default 96dpi structure. ! 577: * ! 578: * Parameters: ! 579: * hDC HDC on which to draw. ! 580: * x, y int coordinates at which to draw. ! 581: * dx, dy int dimensions of the *button*, not necessarily the image. ! 582: * hBmp HBITMAP from which to draw the image. ! 583: * bmx, bmy int dimensions of each bitmap in hBmp. If hBmp is NULL ! 584: * then these are forced to the standard sizes. ! 585: * iImage int index to the image to draw in the button ! 586: * uStateIn UINT containing the state index for the button and the ! 587: * color control bits. ! 588: * pTDD LPTOOLDISPLAYDATA containing display configuration. ! 589: * Can be NULL if hBmp is non-NULL. ! 590: * ! 591: * Return Value: ! 592: * BOOL TRUE if drawing succeeded, FALSE otherwise meaning that ! 593: * hDC is NULL or hBmp is NULL and iImage is not a valid ! 594: * index for a standard image. ! 595: */ ! 596: ! 597: BOOL WINAPI UIToolButtonDrawTDD(HDC hDC, int x, int y, int dx, int dy ! 598: , HBITMAP hBmp, int bmx, int bmy, int iImage, UINT uStateIn ! 599: , LPTOOLDISPLAYDATA pTDD) ! 600: { ! 601: static COLORREF crSys[5]; //Avoid stack arrays in DLLs: use static ! 602: UINT uState=(UINT)LOBYTE((WORD)uStateIn); ! 603: UINT uColors=(UINT)HIBYTE((WORD)uStateIn & PRESERVE_ALL); ! 604: int xOffsetGlyph, yOffsetGlyph; ! 605: int i, iSaveDC; ! 606: HDC hMemDC; ! 607: HGDIOBJ hObj; ! 608: HBRUSH hBR; ! 609: HBITMAP hBmpT; ! 610: HBITMAP hBmpMono; ! 611: HBITMAP hBmpMonoOrg; ! 612: HBITMAP hBmpSave=NULL; ! 613: ! 614: if (NULL==hDC) ! 615: return FALSE; ! 616: ! 617: /* ! 618: * If we're given no image bitmap, then use the standard and validate the ! 619: * image index. We also enforce the standard bitmap size and the size of ! 620: * the button (as requested by User Interface designers). ! 621: */ ! 622: if (NULL==hBmp && !(uState & BUTTONGROUP_BLANK)) ! 623: { ! 624: hBmp=rghBmpStandardImages[pTDD->uIDImages-IDB_STANDARDIMAGESMIN]; ! 625: ! 626: bmx=pTDD->cxImage; //Force bitmap dimensions ! 627: bmy=pTDD->cyImage; ! 628: ! 629: dx=pTDD->cxButton; //Force button dimensions ! 630: dy=pTDD->cyButton; ! 631: ! 632: if (iImage > TOOLIMAGE_MAX) ! 633: return FALSE; ! 634: ! 635: /* ! 636: * If we are using a standard command button, verify that the state ! 637: * does not contain the LIGHTFACE group which only applies to ! 638: * attribute buttons. ! 639: */ ! 640: if (BUTTONTYPE_COMMAND==mpButtonType[iImage] ! 641: && (uState & BUTTONGROUP_LIGHTFACE)) ! 642: return FALSE; ! 643: } ! 644: ! 645: //Create a dithered bitmap. ! 646: hBmpMono=CreateBitmap(dx-2, dy-2, 1, 1, NULL); ! 647: ! 648: if (NULL==hBmpMono) ! 649: return FALSE; ! 650: ! 651: hBmpMonoOrg=(HBITMAP)SelectObject(hDCMono, hBmpMono); ! 652: ! 653: ! 654: //Save the DC state before we munge on it. ! 655: iSaveDC=SaveDC(hDC); ! 656: ! 657: /* ! 658: * Draw a button sans image. This also fills crSys with the system ! 659: * colors for us which has space for five colors. We don't use the ! 660: * fifth, the frame color, in this function. ! 661: */ ! 662: DrawBlankButton(hDC, x, y, dx, dy, (BOOL)(uState & BUTTONGROUP_DOWN), crSys); ! 663: ! 664: //Shift coordinates to account for the button's border ! 665: x++; ! 666: y++; ! 667: dx-=2; ! 668: dy-=2; ! 669: ! 670: /* ! 671: * Determine the offset necessary to center the image but also reflect ! 672: * the pushed-in state, which means just adding 1 to the up state. ! 673: */ ! 674: i=(uState & BUTTONGROUP_DOWN) ? 1 : 0; ! 675: xOffsetGlyph=((dx-bmx) >> 1)+i; ! 676: yOffsetGlyph=((dy-bmy) >> 1)+i; ! 677: ! 678: ! 679: //Select the given image bitmap into the glyph DC before calling MaskCreate ! 680: if (NULL!=hBmp) ! 681: hBmpSave=(HBITMAP)SelectObject(hDCGlyphs, hBmp); ! 682: ! 683: ! 684: /* ! 685: * Draw the face on the button. If we have an up or [mouse]down ! 686: * button then we can just draw it as-is. For indeterminate, ! 687: * disabled, or down disabled we have to gray the image and possibly ! 688: * add a white shadow to it (disabled/down disabled). ! 689: * ! 690: * Also note that for the intermediate state we first draw the normal ! 691: * up state, then proceed to add disabling looking highlights. ! 692: */ ! 693: ! 694: //Up, mouse down, down, indeterminate ! 695: if ((uState & BUTTONGROUP_ACTIVE) && !(uState & BUTTONGROUP_BLANK)) ! 696: { ! 697: BOOL fColorsSame=TRUE; ! 698: ! 699: /* ! 700: * In here we pay close attention to the system colors. Where ! 701: * the source image is black, we paint COLOR_BTNTEXT. Where ! 702: * light gray, we paint COLOR_BTNFACE. Where dark gray we paint ! 703: * COLOR_BTNSHADOW, and where white we paint COLOR_BTNHILIGHT. ! 704: * ! 705: * The uColors variable contains flags to prevent color ! 706: * conversion. To do a little optimization, we just do a ! 707: * single BitBlt if we're preserving all colors or if no colors ! 708: * are different than the standards, which is by far the most ! 709: * common case. Otherwise, cycle through the four colors we can ! 710: * convert and do a BitBlt that converts it to the system color. ! 711: */ ! 712: ! 713: //See what colors are different. ! 714: for (i=STDCOLOR_BLACK; i<=STDCOLOR_WHITE; i++) ! 715: fColorsSame &= (crSys[i]==crStandard[i]); ! 716: ! 717: if (PRESERVE_ALL==uColors || fColorsSame) ! 718: { ! 719: BitBlt(hDC, x+xOffsetGlyph, y+yOffsetGlyph, bmx, bmy ! 720: , hDCGlyphs, iImage*bmx, 0, SRCCOPY); ! 721: } ! 722: else ! 723: { ! 724: /* ! 725: * Cycle through hard-coded colors and create a mask that has all ! 726: * regions of that color in white and all other regions black. ! 727: * Then we select a pattern brush of the color to convert to: ! 728: * if we aren't converting the color then we use a brush of ! 729: * the standard hard-coded color, otherwise we use the actual ! 730: * system color. The ROP_DSPDxax means that anything that's ! 731: * 1's in the mask get the pattern, anything that's 0 is unchanged ! 732: * in the destination. ! 733: * ! 734: * To prevent too many Blts to the screen, we use an intermediate ! 735: * bitmap and DC. ! 736: */ ! 737: ! 738: hMemDC=CreateCompatibleDC(hDC); ! 739: ! 740: //Make sure conversion of monochrome to color stays B&W ! 741: SetTextColor(hMemDC, 0L); //0's in mono -> 0 ! 742: SetBkColor(hMemDC, (COLORREF)0x00FFFFFF); //1's in mono -> 1 ! 743: ! 744: hBmpT=CreateCompatibleBitmap(hDC, bmx, bmy); ! 745: SelectObject(hMemDC, hBmpT); ! 746: ! 747: //Copy the unmodified bitmap to the temporary bitmap ! 748: BitBlt(hMemDC, 0, 0, bmx, bmy, hDCGlyphs, iImage*bmx, 0, SRCCOPY); ! 749: ! 750: for (i=STDCOLOR_BLACK; i<=STDCOLOR_WHITE; i++) ! 751: { ! 752: //Convert pixels of the color to convert to 1's in the mask ! 753: SetBkColor(hDCGlyphs, crStandard[i]); ! 754: BitBlt(hDCMono, 0, 0, bmx, bmy, hDCGlyphs, iImage*bmx, 0, SRCCOPY); ! 755: ! 756: //Preserve or modify the color depending on the flag. ! 757: hBR=CreateSolidBrush((uColors & (1 << i)) ! 758: ? crStandard[i] : crSys[i]); ! 759: ! 760: if (NULL!=hBR) ! 761: { ! 762: hObj=SelectObject(hMemDC, hBR); ! 763: ! 764: if (NULL!=hObj) ! 765: { ! 766: BitBlt(hMemDC, 0, 0, dx-1, dy-1, hDCMono, 0, 0, ROP_DSPDxax); ! 767: SelectObject(hMemDC, hObj); ! 768: } ! 769: ! 770: DeleteObject(hBR); ! 771: } ! 772: } ! 773: ! 774: //Now put the final version on the display and clean up ! 775: BitBlt(hDC, x+xOffsetGlyph, y+yOffsetGlyph, dx-1, dy-1 ! 776: , hMemDC, 0, 0, SRCCOPY); ! 777: ! 778: DeleteDC(hMemDC); ! 779: DeleteObject(hBmpT); ! 780: ! 781: } ! 782: } ! 783: ! 784: ! 785: //Disabled and indeterminate states (unless we're blank) ! 786: if ((uState & BUTTONGROUP_DISABLED || ATTRIBUTEBUTTON_INDETERMINATE==uState) ! 787: && !(uState & BUTTONGROUP_BLANK)) ! 788: { ! 789: //Grayed state (up or down, no difference) ! 790: MaskCreate(iImage, dx, dy, bmx, bmy, xOffsetGlyph, yOffsetGlyph, 0); ! 791: ! 792: //Make sure conversion of monochrome to color stays B&W ! 793: SetTextColor(hDC, 0L); //0's in mono -> 0 ! 794: SetBkColor(hDC, (COLORREF)0x00FFFFFF); //1's in mono -> 1 ! 795: ! 796: //If we're disabled, up or down, draw the highlighted shadow. ! 797: if (uState & BUTTONGROUP_DISABLED) ! 798: { ! 799: hBR=CreateSolidBrush(crSys[SYSCOLOR_HILIGHT]); ! 800: ! 801: if (NULL!=hBR) ! 802: { ! 803: hObj=SelectObject(hDC, hBR); ! 804: ! 805: if (NULL!=hObj) ! 806: { ! 807: //Draw hilight color where we have 0's in the mask ! 808: BitBlt(hDC, x+1, y+1, dx-2, dy-2, hDCMono, 0, 0, ROP_PSDPxax); ! 809: SelectObject(hDC, hObj); ! 810: } ! 811: DeleteObject(hBR); ! 812: } ! 813: } ! 814: ! 815: //Draw the gray image. ! 816: hBR=CreateSolidBrush(crSys[SYSCOLOR_SHADOW]); ! 817: ! 818: if (NULL!=hBR) ! 819: { ! 820: hObj=SelectObject(hDC, hBR); ! 821: ! 822: if (NULL!=hObj) ! 823: { ! 824: //Draw the shadow color where we have 0's in the mask ! 825: BitBlt(hDC, x, y, dx-2, dy-2, hDCMono, 0, 0, ROP_PSDPxax); ! 826: SelectObject(hDC, hObj); ! 827: } ! 828: ! 829: DeleteObject(hBR); ! 830: } ! 831: } ! 832: ! 833: //If the button is selected do the dither brush avoiding the glyph ! 834: if (uState & BUTTONGROUP_LIGHTFACE) ! 835: { ! 836: HBRUSH hBRDither; ! 837: ! 838: /* ! 839: * Get the dither brush. This function will recreate it if ! 840: * necessary or return the global one if the colors already match. ! 841: */ ! 842: hBRDither=HBrushDitherCreate(crSys[SYSCOLOR_FACE], crSys[SYSCOLOR_HILIGHT]); ! 843: hObj=SelectObject(hDC, hBRDither); ! 844: ! 845: if (NULL!=hObj) ! 846: { ! 847: /* ! 848: * The mask we create now determines where the dithering ! 849: * ends up. In the down disabled state, we have to preserve ! 850: * the highlighted shadow, so the mask we create must have ! 851: * two masks of the original glyph, one of them offset by ! 852: * one pixel in both x & y. For the indeterminate state, ! 853: * we have to mask all highlighted areas. The state passed ! 854: * to MaskCreate matters here (we've used zero before). ! 855: */ ! 856: MaskCreate(iImage, dx, dy, bmx, bmy ! 857: , xOffsetGlyph-1, yOffsetGlyph-1, uState); ! 858: ! 859: //Convert monochrome masks to B&W color bitmap in the BitBlt. ! 860: SetTextColor(hDC, 0L); ! 861: SetBkColor(hDC, (COLORREF)0x00FFFFFF); ! 862: ! 863: /* ! 864: * Only draw the dither brush where the mask is 1's. For ! 865: * the indeterminate state we have to not overdraw the ! 866: * shadow highlight so we use dx-3, dy-3 instead of dx-1 ! 867: * and dy-1. We do this whether or not we're blank. ! 868: */ ! 869: i=(ATTRIBUTEBUTTON_INDETERMINATE==uState ! 870: || BLANKBUTTON_INDETERMINATE==uState) ? 3 : 1; ! 871: ! 872: BitBlt(hDC, x+1, y+1, dx-i, dy-i, hDCMono, 0, 0, ROP_DSPDxax); ! 873: SelectObject(hDC, hObj); ! 874: } ! 875: ! 876: //DO NOT delete hBRDither! It's a reference to a shared global. ! 877: } ! 878: ! 879: //Cleanup hDCGlyphs: Must do AFTER calling MaskCreate ! 880: if (NULL!=hBmpSave) ! 881: SelectObject(hDCGlyphs, hBmpSave); ! 882: ! 883: SelectObject(hDCMono, hBmpMonoOrg); ! 884: DeleteObject(hBmpMono); ! 885: ! 886: //Restore everything in the DC. ! 887: RestoreDC(hDC, iSaveDC); ! 888: return TRUE; ! 889: } ! 890: ! 891: ! 892: ! 893: ! 894: ! 895: ! 896: /* ! 897: * DrawBlankButton ! 898: * ! 899: * Purpose: ! 900: * Draws a button with no face using the current system colors in either ! 901: * an up or down state. ! 902: * ! 903: * Parameters: ! 904: * hDC HDC on which to draw ! 905: * x, y int coordinates where we start drawing ! 906: * dx,dy int size of the button ! 907: * fDown BOOL indicating the up or down state of the button ! 908: * pcr COLORREF FAR * to five colors in which we store text, ! 909: * shadow, face, highlight, and frame colors. This is ! 910: * a matter of convenience for the caller, since we have ! 911: * to load these colors anyway we might as well send them ! 912: * back. ! 913: * ! 914: * Return Value: ! 915: * None ! 916: */ ! 917: ! 918: static void DrawBlankButton(HDC hDC, int x, int y, int dx, int dy ! 919: , BOOL fDown, COLORREF FAR *pcr) ! 920: { ! 921: //Get the current system colors for buttons. ! 922: pcr[0]=GetSysColor(COLOR_BTNTEXT); ! 923: pcr[1]=GetSysColor(COLOR_BTNSHADOW); ! 924: pcr[2]=GetSysColor(COLOR_BTNFACE); ! 925: ! 926: //Windows 3.0 doesn't support COLOR_BTNHIGHLIGHT, so leave it white. ! 927: if (0x0300 < (UINT)GetVersion()) ! 928: pcr[3]=GetSysColor(COLOR_BTNHIGHLIGHT); ! 929: else ! 930: pcr[3]=crStandard[STDCOLOR_WHITE]; ! 931: ! 932: pcr[4]=GetSysColor(COLOR_WINDOWFRAME); ! 933: ! 934: //Draw the border around the button. ! 935: PatB(hDC, x+1, y, dx-2, 1, pcr[4]); ! 936: PatB(hDC, x+1, y+dy-1, dx-2, 1, pcr[4]); ! 937: PatB(hDC, x, y+1, 1, dy-2, pcr[4]); ! 938: PatB(hDC, x+dx-1, y+1, 1, dy-2, pcr[4]); ! 939: ! 940: //Shift coordinates to account for the border we just drew ! 941: x++; ! 942: y++; ! 943: dx-=2; ! 944: dy-=2; ! 945: ! 946: //Paint the interior grey as a default. ! 947: PatB(hDC, x, y, dx, dy, pcr[2]); ! 948: ! 949: /* ! 950: * Draw shadows and highlights. The DOWN grouping that contains ! 951: * down, mouse down, and down disabled are drawn depressed. Up, ! 952: * indeterminate, and disabled are drawn up. ! 953: */ ! 954: ! 955: if (fDown) ! 956: { ! 957: PatB(hDC, x, y, 1, dy, pcr[1]); ! 958: PatB(hDC, x, y, dx, 1, pcr[1]); ! 959: } ! 960: else ! 961: { ! 962: //Normal button look. ! 963: PatB(hDC, x, y, 1, dy-1, pcr[3]); ! 964: PatB(hDC, x, y, dx-1, 1, pcr[3]); ! 965: ! 966: PatB(hDC, x+dx-1, y, 1, dy, pcr[1]); ! 967: PatB(hDC, x, y+dy-1, dx, 1, pcr[1]); ! 968: ! 969: PatB(hDC, x+1+dx-3, y+1, 1, dy-2, pcr[1]); ! 970: PatB(hDC, x+1, y+dy-2, dx-2, 1, pcr[1]); ! 971: } ! 972: ! 973: return; ! 974: } ! 975: ! 976: ! 977: ! 978: ! 979: ! 980: ! 981: /* ! 982: * PatB ! 983: * Internal ! 984: * ! 985: * Purpose: ! 986: * A more convenient PatBlt operation for drawing button borders and ! 987: * highlights. ! 988: * ! 989: * Parameters: ! 990: * hDC HDC on which to paint. ! 991: * x, y int coordinates at which to paint. ! 992: * dx, dy int dimensions of rectangle to paint. ! 993: * rgb COLORREF to use as the background color. ! 994: * ! 995: * Return Value: ! 996: * None ! 997: */ ! 998: ! 999: static void PatB(HDC hDC, int x, int y, int dx, int dy, COLORREF rgb) ! 1000: { ! 1001: RECT rc; ! 1002: ! 1003: SetBkColor(hDC, rgb); ! 1004: SetRect(&rc, x, y, x+dx, y+dy); ! 1005: ExtTextOut(hDC, 0, 0, ETO_OPAQUE, &rc, NULL, 0, NULL); ! 1006: } ! 1007: ! 1008: ! 1009: ! 1010: ! 1011: /* ! 1012: * MaskCreate ! 1013: * Internal ! 1014: * ! 1015: * Purpose: ! 1016: * Creates a monochrome mask bitmap of the given image at the given offset ! 1017: * in the global hDCMono. Anywhere in the image that you have the light ! 1018: * gray (STDCOLOR_LTGRAY) or the white highlight (STDCOLOR_WHITE) you get ! 1019: * get 1's. All other pixels are 0's ! 1020: * ! 1021: * Parameters: ! 1022: * iImage UINT index of the image for which to create a mask. ! 1023: * dx, dy int dimensions of the button. ! 1024: * bmx, bmy int dimensions of the bitmap to use. ! 1025: * xOffset int offset for x inside hDCMono where we paint. ! 1026: * yOffset int offset for y inside hDCMono where we paint. ! 1027: * uState UINT state of the image. Special cases are made ! 1028: * for ATTRIBUTEBUTTON_DOWNDISABLED and ! 1029: * ATTRIBUTEBUTTON_INDETERMINATE. In any case where you ! 1030: * do not want a special case, pass zero here, regardless ! 1031: * of the true button state. ! 1032: * ! 1033: * Return Value: ! 1034: * None ! 1035: */ ! 1036: ! 1037: static void MaskCreate(UINT iImage, int dx, int dy, int bmx, int bmy ! 1038: ,int xOffset, int yOffset, UINT uState) ! 1039: { ! 1040: //Initalize whole area with zeros ! 1041: PatBlt(hDCMono, 0, 0, dx, dy, WHITENESS); ! 1042: ! 1043: if (uState & BUTTONGROUP_BLANK) ! 1044: return; ! 1045: ! 1046: //Convert face colored pixels to 1's. all others to black. ! 1047: SetBkColor(hDCGlyphs, crStandard[STDCOLOR_LTGRAY]); ! 1048: BitBlt(hDCMono, xOffset, yOffset, bmx, bmy, hDCGlyphs, iImage*bmx, 0, SRCCOPY); ! 1049: ! 1050: //In the indeterminate state, don't turn highlight's to 1's. Leave black. ! 1051: if (ATTRIBUTEBUTTON_INDETERMINATE!=uState) ! 1052: { ! 1053: //Convert highlight colored pixels to 1's and OR them with the previous. ! 1054: SetBkColor(hDCGlyphs, crStandard[STDCOLOR_WHITE]); ! 1055: BitBlt(hDCMono, xOffset, yOffset, bmx, bmy, hDCGlyphs, iImage*bmx, 0, SRCPAINT); ! 1056: } ! 1057: ! 1058: /* ! 1059: * For the down disabled state, AND this same mask with itself at an ! 1060: * offset of 1, which accounts for the highlight shadow. ! 1061: */ ! 1062: if (ATTRIBUTEBUTTON_DOWNDISABLED==uState) ! 1063: BitBlt(hDCMono, 1, 1, dx-1, dy-1, hDCMono, 0, 0, SRCAND); ! 1064: ! 1065: return; ! 1066: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.