![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dibmp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / mandel|
Return to dibmp.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / mandel |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: dibmp.c ! 3: * ! 4: * Contains functions that manipulate the DIB color ! 5: * ! 6: * Created: 30-Jan-1992 21:21:05 ! 7: * Author: Petrus Wong ! 8: * ! 9: * Copyright (c) 1990 Microsoft Corporation ! 10: * ! 11: * These functions will be called from the ChildWndProc() as it processes ! 12: * the corresponding WM_COMMAND message for changing the color of the bitmap. ! 13: * ! 14: * iCreatePenFrPal() is called by InitializeApp() for creating pens based on ! 15: * either system or custom palette. ! 16: * ! 17: * Dependencies: ! 18: * none ! 19: * ! 20: \**************************************************************************/ ! 21: #include <windows.h> ! 22: #include <stdio.h> ! 23: #include "jtypes.h" ! 24: #include "dibmp.h" ! 25: ! 26: //#define CYCLETHRD ! 27: ! 28: //#define DEBUG ! 29: ! 30: #ifndef DEBUG ! 31: #undef OutputDebugString ! 32: #define OutputDebugString(LPCSTR) ! 33: #endif ! 34: ! 35: ! 36: extern HWND ghwndMain; ! 37: extern HWND ghwndClient; ! 38: extern HANDLE hQuitEvent; ! 39: extern char gtext[256]; ! 40: extern HANDLE ghAccel; ! 41: BOOL bValidMode(INT); ! 42: BOOL bColor2BW(PBITMAPINFO); ! 43: BOOL bChangeDIBColor(HDC, PINFO, INT); ! 44: BOOL bColorShift(PBITMAPINFO); ! 45: BOOL bColorReplace(PBITMAPINFO); ! 46: BOOL bColorCycle(HDC, RECT, PBYTE, PBITMAPINFO, PINFO); ! 47: BOOL bCycle(HWND); ! 48: BOOL bColor2Mono(HDC, PINFO, PBITMAPINFO); ! 49: INT iCreatePenFrPal(HDC, PVOID *); ! 50: extern PINFO pGetInfoData(HWND); ! 51: extern BOOL bReleaseInfoData(HWND); ! 52: ! 53: ! 54: /******************************Public*Routine******************************\ ! 55: * ! 56: * bChangeDIBColor ! 57: * ! 58: * Effects: Main entry point for the color changing operations. It ! 59: * 1. validates the operation ! 60: * 2. retrieves the bitmap info from the graphics engine ! 61: * 3. dispatches the call to the right function ! 62: * 4. saves the resulting bitmap ! 63: * 5. updates the screen ! 64: * ! 65: * Warnings: ! 66: * ! 67: * History: ! 68: * 30-Jan-1992 -by- Petrus Wong ! 69: * Wrote it. ! 70: \**************************************************************************/ ! 71: BOOL bChangeDIBColor(HDC hDC, PINFO pInfo, INT iMode) ! 72: { ! 73: BOOL bSuccess; ! 74: HBITMAP hTmpBmp, hBmpOld; ! 75: PBITMAPINFO pbmi; ! 76: PBYTE pBits; ! 77: BITMAPINFO bmi; ! 78: PBYTE pjTmp, pjTmpBmi; ! 79: ULONG sizBMI; ! 80: RECT rc; ! 81: BOOL bCycle; ! 82: ! 83: ! 84: bSuccess = TRUE; ! 85: if (!pInfo->hBmpSaved) { ! 86: MessageBox(ghwndMain, "There's no Bitmap to change!", "Error", MB_OK); ! 87: return FALSE; ! 88: } ! 89: ! 90: if (!bValidMode(iMode)) { ! 91: MessageBox(ghwndMain, "bChangeDIBColor: invalid mode!", "Error", MB_OK); ! 92: return FALSE; ! 93: } ! 94: ! 95: // ! 96: // Let the graphics engine to retrieve the dimension of the bitmap for us ! 97: // GetDIBits uses the size to determine if it's BITMAPCOREINFO or BITMAPINFO ! 98: // if BitCount != 0, color table will be retrieved ! 99: // ! 100: bmi.bmiHeader.biSize = 0x28; // GDI need this to work ! 101: bmi.bmiHeader.biBitCount = 0; // don't get the color table ! 102: if ((GetDIBits(hDC, pInfo->hBmpSaved, 0, 0, (LPSTR)NULL, &bmi, DIB_RGB_COLORS)) == 0) { ! 103: MessageBox(ghwndMain, "GetDIBits failed!", "Error", MB_OK); ! 104: return FALSE; ! 105: } ! 106: ! 107: // ! 108: // Now that we know the size of the image, alloc enough memory to retrieve ! 109: // the actual bits ! 110: // ! 111: if ((pBits = (PBYTE)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, ! 112: bmi.bmiHeader.biSizeImage)) == NULL) { ! 113: MessageBox(ghwndMain, "Failed in Memory Allocation for pBits!", "Error", MB_OK); ! 114: return FALSE; ! 115: } ! 116: ! 117: // ! 118: // Note: 24 bits per pixel has no color table. So, we don't have to ! 119: // allocate memory for retrieving that. Otherwise, we do. ! 120: // ! 121: pbmi = &bmi; // assume no color table ! 122: if (bmi.bmiHeader.biBitCount != 24) { // has color table ! 123: sizBMI = sizeof(BITMAPINFO)+sizeof(RGBQUAD)*(1<<bmi.bmiHeader.biBitCount); ! 124: // ! 125: // I need more memory for the color table ! 126: // ! 127: if ((pbmi = (PBITMAPINFO)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizBMI )) == NULL) { ! 128: MessageBox(ghwndMain, "Failed in Memory Allocation for pbmi!", "Error", MB_OK); ! 129: bSuccess = FALSE; ! 130: goto ErrExit1; ! 131: } ! 132: ! 133: // ! 134: // Now that we've a bigger chunk of memory, let's copy the Bitmap ! 135: // info header data over ! 136: // ! 137: pjTmp = (PBYTE)pbmi; ! 138: pjTmpBmi = (PBYTE)&bmi; ! 139: sizBMI = sizeof(BITMAPINFOHEADER); ! 140: ! 141: while(sizBMI--) ! 142: { ! 143: *(((PBYTE)pjTmp)++) = *((pjTmpBmi)++); ! 144: } ! 145: ! 146: } ! 147: ! 148: // ! 149: // Bitmap can't be selected into a DC when calling GetDIBits ! 150: // Assume that the hDC is the DC where the bitmap would have been selected ! 151: // if indeed it has been selected ! 152: // ! 153: if (hTmpBmp = CreateCompatibleBitmap(hDC, pbmi->bmiHeader.biWidth, pbmi->bmiHeader.biHeight)) { ! 154: hBmpOld = SelectObject(hDC, hTmpBmp); ! 155: if ((GetDIBits(hDC, pInfo->hBmpSaved, 0, pbmi->bmiHeader.biHeight, (LPSTR)pBits, pbmi, DIB_RGB_COLORS))==0){ ! 156: MessageBox(ghwndMain, "Failed in GetDIBits!", "Error", MB_OK); ! 157: bSuccess = FALSE; ! 158: goto ErrExit4; ! 159: } ! 160: } else { ! 161: MessageBox(ghwndMain, "Failed in creating bitmap!", "Error", MB_OK); ! 162: bSuccess = FALSE; ! 163: goto ErrExit3; ! 164: } ! 165: ! 166: bCycle = FALSE; ! 167: switch (iMode) { ! 168: case MM_BW: ! 169: if ((!bColor2Mono(hDC, pInfo, pbmi)) || ! 170: (pInfo->hBmpMono == NULL)) { ! 171: MessageBox(ghwndMain, "Failed in Color2Mono!", "Error", MB_OK); ! 172: bSuccess = FALSE; ! 173: goto ErrExit4; ! 174: } ! 175: pInfo->bUseMono = TRUE; ! 176: break; ! 177: case MM_SHIFT: ! 178: if (!bColorShift(pbmi)) { ! 179: MessageBox(ghwndMain, "Failed in ColorShift!", "Error", MB_OK); ! 180: bSuccess = FALSE; ! 181: goto ErrExit4; ! 182: } ! 183: break; ! 184: case MM_CUSTOM: ! 185: bColorReplace(pbmi); ! 186: break; ! 187: ! 188: case MM_CYCLE: ! 189: bCycle = TRUE; ! 190: break; ! 191: ! 192: default: ! 193: bSuccess = FALSE; ! 194: break; ! 195: } ! 196: ! 197: if (SetDIBits(hDC, pInfo->hBmpSaved, 0, pbmi->bmiHeader.biHeight, (LPSTR)pBits, ! 198: pbmi, DIB_RGB_COLORS) == 0) { ! 199: MessageBox(ghwndMain, "Failed in SetDIBits!", "Error", MB_OK); ! 200: bSuccess = FALSE; ! 201: goto ErrExit4; ! 202: } ! 203: ! 204: if (bCycle) ! 205: pInfo->bSetDIBsToDevice = TRUE; ! 206: ! 207: if (pInfo->bSetDIBsToDevice && !pInfo->bUseMono) { ! 208: //GetWindowRect(pInfo->hwnd, &rc); ! 209: GetClientRect(pInfo->hwnd, &rc); ! 210: //SetMapMode(hDC, MM_TEXT); ! 211: ! 212: if (SetDIBitsToDevice(hDC, 0, 0, rc.right-rc.left, rc.bottom-rc.top, ! 213: 0, 0, 0, pbmi->bmiHeader.biHeight, (LPSTR)pBits, pbmi, DIB_RGB_COLORS) == 0) { ! 214: MessageBox(ghwndMain, "Failed in SetDIBitsToDevice!", "Error", MB_OK); ! 215: bSuccess = FALSE; ! 216: goto ErrExit4; ! 217: } ! 218: } else { ! 219: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 220: ! 221: } ! 222: ! 223: if (bCycle) { ! 224: //SetSystemPaletteUse(hDC, SYSPAL_NOSTATIC); ! 225: bColorCycle(hDC, rc, pBits, pbmi, pInfo); ! 226: //SetSystemPaletteUse(hDC, SYSPAL_STATIC); ! 227: } ! 228: ! 229: ErrExit4: ! 230: SelectObject(hDC, hBmpOld); ! 231: DeleteObject(hTmpBmp); ! 232: ErrExit3: ! 233: GlobalFree(pbmi); ! 234: ErrExit1: ! 235: GlobalFree(pBits); ! 236: return bSuccess; ! 237: } ! 238: ! 239: ! 240: /******************************Public*Routine******************************\ ! 241: * ! 242: * bValidMode ! 243: * ! 244: * Effects: validates the change mode for ChangeDIBColor function ! 245: * returns TRUE if mode is valid. Otherwise, FALSE ! 246: * ! 247: * Warnings: ! 248: * ! 249: * History: ! 250: * 30-Jan-1992 -by- Petrus Wong ! 251: * Wrote it. ! 252: \**************************************************************************/ ! 253: BOOL bValidMode(INT iMode) ! 254: { ! 255: if ((iMode == MM_BW) || (iMode == MM_SHIFT) || ! 256: (iMode == MM_CUSTOM) || (iMode == MM_CYCLE)) ! 257: return TRUE; ! 258: else ! 259: return FALSE; ! 260: } ! 261: ! 262: /******************************Public*Routine******************************\ ! 263: * ! 264: * bColor2BW ! 265: * ! 266: * Effects: changes the color table in the bitmapinfo to black and white ! 267: * ! 268: * Warnings: doesn't check if pbmi is valid or not ! 269: * ! 270: * History: ! 271: * 30-Jan-1992 -by- Petrus Wong ! 272: * Wrote it. ! 273: \**************************************************************************/ ! 274: BOOL bColor2BW(PBITMAPINFO pbmi) ! 275: { ! 276: INT iEntry; ! 277: ! 278: // ! 279: // CR! What's the right behavior? Maybe I should convert this to a ! 280: // monochrome bitmap. This will be very useful in MaskBlt(). ! 281: // ! 282: iEntry = 1<<pbmi->bmiHeader.biBitCount; ! 283: while (--iEntry >= 0) { ! 284: if (iEntry <= iEntry / 2) { ! 285: pbmi->bmiColors[iEntry].rgbBlue = 0x00; ! 286: pbmi->bmiColors[iEntry].rgbGreen = 0x00; ! 287: pbmi->bmiColors[iEntry].rgbRed = 0x00; ! 288: pbmi->bmiColors[iEntry].rgbReserved = 0x00; ! 289: } else { ! 290: pbmi->bmiColors[iEntry].rgbBlue = 0xFF; ! 291: pbmi->bmiColors[iEntry].rgbGreen = 0xFF; ! 292: pbmi->bmiColors[iEntry].rgbRed = 0xFF; ! 293: pbmi->bmiColors[iEntry].rgbReserved = 0x00; ! 294: } ! 295: } ! 296: return TRUE; ! 297: } ! 298: ! 299: ! 300: /******************************Public*Routine******************************\ ! 301: * ! 302: * bColorShift ! 303: * ! 304: * Effects: Shifting entries of the color table ! 305: * ! 306: * Warnings: ! 307: * ! 308: * History: ! 309: * 30-Jan-1992 -by- Petrus Wong ! 310: * Wrote it. ! 311: \**************************************************************************/ ! 312: ! 313: BOOL bColorShift(PBITMAPINFO pbmi) ! 314: { ! 315: INT iEntry; ! 316: RGBQUAD Tmp; ! 317: ! 318: iEntry = 1<<pbmi->bmiHeader.biBitCount; ! 319: ! 320: Tmp.rgbBlue = pbmi->bmiColors[iEntry-1].rgbBlue; ! 321: Tmp.rgbGreen = pbmi->bmiColors[iEntry-1].rgbGreen; ! 322: Tmp.rgbRed = pbmi->bmiColors[iEntry-1].rgbRed; ! 323: Tmp.rgbReserved = pbmi->bmiColors[iEntry-1].rgbReserved; ! 324: ! 325: while (--iEntry > 0) { ! 326: pbmi->bmiColors[iEntry].rgbBlue = ! 327: pbmi->bmiColors[iEntry-1].rgbBlue; ! 328: pbmi->bmiColors[iEntry].rgbGreen = ! 329: pbmi->bmiColors[iEntry-1].rgbGreen; ! 330: pbmi->bmiColors[iEntry].rgbRed = ! 331: pbmi->bmiColors[iEntry-1].rgbRed; ! 332: pbmi->bmiColors[iEntry].rgbReserved = ! 333: pbmi->bmiColors[iEntry-1].rgbReserved; ! 334: } ! 335: pbmi->bmiColors[0].rgbBlue = Tmp.rgbBlue; ! 336: pbmi->bmiColors[0].rgbGreen = Tmp.rgbGreen; ! 337: pbmi->bmiColors[0].rgbRed = Tmp.rgbRed; ! 338: pbmi->bmiColors[0].rgbReserved = Tmp.rgbReserved; ! 339: return TRUE; ! 340: ! 341: } ! 342: ! 343: BOOL bColorReplace(PBITMAPINFO pbmi) ! 344: { ! 345: return FALSE; ! 346: UNREFERENCED_PARAMETER(pbmi); ! 347: } ! 348: ! 349: /******************************Public*Routine******************************\ ! 350: * ! 351: * bColorCycle ! 352: * ! 353: * Effects: Create a logical palette with a good spread of color ! 354: * Animate the palette, shift the palette entries and animate ! 355: * again for 256 times altogether. ! 356: * This creates the color cycling effect. ! 357: * ! 358: * Warnings: Only works in device that support palette. ! 359: * ! 360: * History: ! 361: * 31-May-1992 Petrus Wong Check if drawing window is gone or not ! 362: * 24-Apr-1992 -by- Petrus Wong ! 363: * Wrote it. ! 364: \**************************************************************************/ ! 365: ! 366: BOOL bColorCycle(HDC hDC, RECT rc, PBYTE pBits, PBITMAPINFO pbmi, PINFO pInfo) ! 367: { ! 368: INT iEntry, i; ! 369: PLOGPALETTE plogPat; ! 370: ULONG ulSize; ! 371: BOOL bSuccess; ! 372: HPALETTE hPal, hPalOld; ! 373: PALETTEENTRY peTemp; ! 374: BYTE red, green, blue; ! 375: #ifdef CYCLETHRD ! 376: DWORD dwWait; ! 377: #endif ! 378: MSG msg; ! 379: BOOL bQuit; ! 380: ! 381: UINT uRC; ! 382: ! 383: bSuccess = TRUE; ! 384: iEntry = 1<<pbmi->bmiHeader.biBitCount; ! 385: ulSize = sizeof(LOGPALETTE)+sizeof(PALETTEENTRY)*256; ! 386: ! 387: if ((plogPat = (PLOGPALETTE) GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, ulSize)) == NULL) { ! 388: MessageBox(ghwndMain, "Failed in Memory Allocation for plogPat!", "Error", MB_OK); ! 389: bSuccess = FALSE; ! 390: goto ErrExit1; ! 391: } ! 392: ! 393: plogPat->palVersion = 0x300; ! 394: plogPat->palNumEntries = (WORD) 256; ! 395: #if 0 ! 396: for (i = 0; i < iEntry; i++) { ! 397: plogPat->palPalEntry[i].peBlue = pbmi->bmiColors[i].rgbBlue; ! 398: plogPat->palPalEntry[i].peGreen = pbmi->bmiColors[i].rgbGreen; ! 399: plogPat->palPalEntry[i].peRed = pbmi->bmiColors[i].rgbRed; ! 400: plogPat->palPalEntry[i].peFlags = PC_RESERVED; ! 401: } ! 402: #endif ! 403: for (i = 0; i < 256; i++) { ! 404: plogPat->palPalEntry[i].peBlue = blue; ! 405: plogPat->palPalEntry[i].peGreen = green; ! 406: plogPat->palPalEntry[i].peRed = red; ! 407: plogPat->palPalEntry[i].peFlags = PC_RESERVED; ! 408: ! 409: if (!(red += 32)) ! 410: if (!(green += 32)) ! 411: blue += 64; ! 412: } ! 413: ! 414: if ((hPal = CreatePalette(plogPat)) == (HPALETTE) NULL) { ! 415: MessageBox(ghwndMain, "Failed in creating palette!", "Error", MB_OK); ! 416: bSuccess = FALSE; ! 417: goto ErrExit2; ! 418: } ! 419: ! 420: hPalOld = SelectPalette(hDC, hPal, FALSE); ! 421: RealizePalette(hDC); ! 422: ! 423: #ifndef CYCLETHRD ! 424: ! 425: bQuit = FALSE; ! 426: while (TRUE && !bQuit) { ! 427: ! 428: if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { ! 429: //sprintf( gtext,"msg = %lx\n", msg.message); ! 430: //OutputDebugString( gtext ); ! 431: ! 432: if ((msg.message == WM_QUIT) || (msg.message == WM_CLOSE) || ! 433: ((msg.message == WM_SYSCOMMAND) && (msg.wParam == SC_CLOSE))) { ! 434: sprintf( gtext,"msg = %lx, wPram = %lx\n", msg.message, msg.wParam); ! 435: OutputDebugString( gtext ); ! 436: bQuit = TRUE; ! 437: PostMessage(msg.hwnd, msg.message, msg.wParam, msg.lParam); ! 438: } else { ! 439: if (!TranslateAccelerator( ghwndMain, ghAccel, &msg) && ! 440: !TranslateMDISysAccel( ghwndClient, &msg) ) { ! 441: TranslateMessage(&msg); ! 442: DispatchMessage(&msg); ! 443: } ! 444: } ! 445: } ! 446: ! 447: #else ! 448: bQuit = FALSE; ! 449: while (TRUE) { ! 450: // ! 451: // If parent gets a WM_CLOSE, we will return ! 452: // ! 453: dwWait = WaitForSingleObject(pInfo->hQuitEvent, 0); ! 454: if (dwWait == WAIT_TIMEOUT) { ! 455: MessageBox(ghwndMain, "Cycle Thread Quitting!", "CYCLE Thread", MB_OK); ! 456: break; ! 457: } ! 458: #endif ! 459: if (!pInfo->bClrCycle) { ! 460: sprintf( gtext,"NOT to animate palette\n"); ! 461: OutputDebugString( gtext ); ! 462: bQuit = TRUE; ! 463: } ! 464: ! 465: if (!bQuit) { ! 466: sprintf( gtext,"About to animate palette\n"); ! 467: OutputDebugString( gtext ); ! 468: ! 469: ! 470: peTemp = plogPat->palPalEntry[0]; ! 471: for (i = 0; i < 255; i++) { ! 472: plogPat->palPalEntry[i] = plogPat->palPalEntry[i+1]; ! 473: } ! 474: plogPat->palPalEntry[i] = peTemp; ! 475: ! 476: if (!AnimatePalette(hPal, 0, 256, plogPat->palPalEntry)) { ! 477: sprintf( gtext,"Anmiate palette failed\n"); ! 478: OutputDebugString( gtext ); ! 479: } ! 480: ! 481: if ((uRC = RealizePalette(hDC)) == -1) { ! 482: sprintf( gtext,"Realize palette failed\n"); ! 483: OutputDebugString( gtext ); ! 484: } ! 485: sprintf( gtext,"Realize palette = %d\n", uRC); ! 486: OutputDebugString( gtext ); ! 487: ! 488: if (!UpdateColors(hDC)) { ! 489: sprintf( gtext,"Update Colors failed\n"); ! 490: OutputDebugString( gtext ); ! 491: } ! 492: ! 493: if (SetDIBitsToDevice(hDC, 0, 0, rc.right-rc.left, rc.bottom-rc.top, ! 494: 0, 0, 0, pbmi->bmiHeader.biHeight, (LPSTR)pBits, pbmi, DIB_PAL_COLORS) == 0) { ! 495: MessageBox(ghwndMain, "Failed in SetDIBitsToDevice!", "Error", MB_OK); ! 496: } ! 497: } ! 498: ! 499: } ! 500: ! 501: SelectPalette(hDC, hPalOld, 0); ! 502: DeleteObject(hPal); ! 503: ErrExit2: ! 504: GlobalFree(plogPat); ! 505: ErrExit1: ! 506: return bSuccess; ! 507: ! 508: } ! 509: ! 510: ! 511: /******************************Public*Routine******************************\ ! 512: * ! 513: * bCycle ! 514: * ! 515: * Effects: Wrapper for doing color cycling in a separate thread ! 516: * Called from MM_CYCLE ! 517: * ! 518: * Warnings: presents problem when the MDI child is closed if this thread ! 519: * is not done yet. We will have to wait until DeleteDC is ! 520: * fully functional. ! 521: * ! 522: * History: ! 523: * 28-May-1992 -by- Petrus Wong ! 524: * Wrote it. ! 525: \**************************************************************************/ ! 526: BOOL bCycle(HWND hwnd) ! 527: { ! 528: HDC hDC; ! 529: PINFO pInfo; ! 530: ! 531: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 532: return 0L; ! 533: } ! 534: ! 535: hDC = GetDC(pInfo->hwnd); ! 536: bChangeDIBColor(hDC, pInfo, MM_CYCLE); ! 537: ReleaseDC(pInfo->hwnd, hDC); ! 538: ! 539: bReleaseInfoData(hwnd); ! 540: ! 541: ExitThread(0); ! 542: return TRUE; ! 543: } ! 544: ! 545: ! 546: /******************************Public*Routine******************************\ ! 547: * ! 548: * bColor2Mono ! 549: * ! 550: * Effects: Create a monochrome bitmap out of the colored one ! 551: * Using a different a source background clr every time it is called ! 552: * Saving the Monochrome bitmap in pInfo ! 553: * ! 554: * Warnings: It's more straight forward to use GetDIBits than this but ! 555: * that means some big changes to the bChangeDIBColor. ! 556: * ! 557: * History: ! 558: * 31-May-1992 -by- Petrus Wong ! 559: * Wrote it. ! 560: \**************************************************************************/ ! 561: ! 562: BOOL bColor2Mono(HDC hDC, PINFO pInfo, PBITMAPINFO pbmi) { ! 563: HDC hDCMemDest, hDCMemSrc; ! 564: HBITMAP hOldBmpDest, hOldBmpSrc; ! 565: INT iWidth, iHeight, iEntry; ! 566: static INT iCount=0; ! 567: ! 568: ! 569: iWidth = pbmi->bmiHeader.biWidth; ! 570: iHeight = pbmi->bmiHeader.biHeight; ! 571: ! 572: if (pInfo->hBmpMono) ! 573: DeleteObject(pInfo->hBmpMono); ! 574: ! 575: pInfo->hBmpMono = CreateBitmap(iWidth, iHeight, pbmi->bmiHeader.biPlanes, 1, NULL); ! 576: if (pInfo->hBmpMono == NULL) { ! 577: return(FALSE); ! 578: } ! 579: ! 580: hDCMemDest = CreateCompatibleDC(hDC); ! 581: hDCMemSrc = CreateCompatibleDC(hDC); ! 582: iEntry = 1<<pbmi->bmiHeader.biBitCount; ! 583: SetBkColor(hDCMemSrc, RGB( pbmi->bmiColors[iCount].rgbRed, ! 584: pbmi->bmiColors[iCount].rgbGreen, ! 585: pbmi->bmiColors[iCount].rgbBlue) ); ! 586: //SetBkColor(hDCMemDest, RGB( 0, 0, 0)); ! 587: //SetTextColor(hDCMemDest, RGB( 255, 255, 255)); ! 588: ! 589: iCount++; ! 590: if (iCount >= iEntry) ! 591: iCount = 0; ! 592: ! 593: hOldBmpDest = SelectObject(hDCMemDest, pInfo->hBmpMono); ! 594: hOldBmpSrc = SelectObject(hDCMemSrc, pInfo->hBmpSaved); ! 595: BitBlt(hDCMemDest, 0, 0, iWidth, iHeight, hDCMemSrc, 0, 0, SRCCOPY); ! 596: ! 597: SelectObject(hDCMemDest, hOldBmpDest); ! 598: SelectObject(hDCMemSrc, hOldBmpSrc); ! 599: ! 600: DeleteDC(hDCMemDest); ! 601: DeleteDC(hDCMemSrc); ! 602: ! 603: return(TRUE); ! 604: ! 605: } ! 606: ! 607: ! 608: /******************************Public*Routine******************************\ ! 609: * ! 610: * iCreatePenFrPal ! 611: * ! 612: * Effects: Create an array of pens from palette. ! 613: * If device supports palette, then first creates a logical palette ! 614: * with a good spread of color. Then select the logical palette into ! 615: * the DC. Create pen that corresponds to each palette entry. ! 616: * If system does not support palette, then use the system palette. ! 617: * ! 618: * prghPen pointer to an array of hPen ! 619: * If this is NULL, the required size of the array is ! 620: * returned. If this is not NULL, the array will be filled ! 621: * with hPens. ! 622: * ! 623: * returns the number of hPens created. ! 624: * ! 625: * Warnings: ! 626: * ! 627: * History: ! 628: * 13-Jun-1992 -by- Petrus Wong ! 629: * Wrote it. ! 630: \**************************************************************************/ ! 631: ! 632: INT iCreatePenFrPal(HDC hDC, PVOID *prghPen) ! 633: { ! 634: INT iNumClr, iResult, i; ! 635: PLOGPALETTE plogPat; ! 636: ULONG ulSize; ! 637: HPALETTE hPal, hPalOld; ! 638: BYTE red, green, blue; ! 639: ! 640: iResult = 0; ! 641: ! 642: if (!((GetDeviceCaps(hDC, RASTERCAPS)) & RC_PALETTE)) { ! 643: ! 644: iNumClr = GetSystemPaletteEntries(hDC, 0, 0, NULL); ! 645: if (prghPen == NULL) { ! 646: return (iNumClr); ! 647: } ! 648: ! 649: for (i = 0; i < iNumClr; i++) { ! 650: prghPen[i] = (PVOID) CreatePen(PS_SOLID, 0, PALETTEINDEX(i)); ! 651: iResult = i; ! 652: } ! 653: ! 654: return iResult; ! 655: } ! 656: ! 657: iNumClr = GetDeviceCaps(hDC, NUMCOLORS); ! 658: ! 659: if (prghPen == NULL) ! 660: return iNumClr; ! 661: ! 662: ulSize = sizeof(LOGPALETTE)+sizeof(PALETTEENTRY)*iNumClr; ! 663: ! 664: if ((plogPat = (PLOGPALETTE) GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, ulSize)) == NULL) { ! 665: MessageBox(ghwndMain, "Failed in Memory Allocation for plogPat!", "Error", MB_OK); ! 666: goto ErrExit1; ! 667: } ! 668: ! 669: plogPat->palVersion = 0x300; ! 670: plogPat->palNumEntries = (WORD) iNumClr; ! 671: for (i = 0; i < iNumClr; i++) { ! 672: plogPat->palPalEntry[i].peBlue = blue; ! 673: plogPat->palPalEntry[i].peGreen = green; ! 674: plogPat->palPalEntry[i].peRed = red; ! 675: plogPat->palPalEntry[i].peFlags = PC_RESERVED; ! 676: ! 677: if (!(red += 32)) ! 678: if (!(green += 32)) ! 679: blue += 64; ! 680: } ! 681: ! 682: if ((hPal = CreatePalette(plogPat)) == (HPALETTE) NULL) { ! 683: MessageBox(ghwndMain, "Failed in creating palette!", "Error", MB_OK); ! 684: goto ErrExit2; ! 685: } ! 686: ! 687: hPalOld = SelectPalette(hDC, hPal, FALSE); ! 688: RealizePalette(hDC); ! 689: ! 690: for (i = 0; i < iNumClr; i++) { ! 691: prghPen[i] = (PVOID) CreatePen(PS_SOLID, 0, PALETTEINDEX(i)); ! 692: iResult = i; ! 693: } ! 694: ! 695: SelectPalette(hDC, hPalOld, 0); ! 696: DeleteObject(hPal); ! 697: ErrExit2: ! 698: GlobalFree(plogPat); ! 699: ErrExit1: ! 700: return iResult; ! 701: ! 702: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.