Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
color2.c
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 28k
Category:

Windows Kernel

Development Platform:

Visual C++

color2.c：Code Content
  1. /*++
  3. Copyright (c) 1990-1998,  Microsoft Corporation  All rights reserved.
  5. Module Name:
  7.     color2.c
  9. Abstract:
  11.     This module implements the support for the Win32 color dialog.
  13. Revision History:
  15. --*/
  19. //
  20. //  Include Files.
  21. //
  23. #include "comdlg32.h"
  24. #include "color.h"
  26. // from pwin32.h
  27. #define MMoveTo(hdc, x, y)        MoveToEx(hdc, x, y, NULL)
  33. ////////////////////////////////////////////////////////////////////////////
  34. //
  35. //  ChangeColorSettings
  36. //
  37. //  Updates color shown.
  38. //
  39. ////////////////////////////////////////////////////////////////////////////
  41. VOID ChangeColorSettings(
  42.     register PCOLORINFO pCI)
  43. {
  44.     register HDC hDC;
  45.     HWND hDlg = pCI->hDialog;
  46.     DWORD dwRGBcolor = pCI->currentRGB;
  48.     RGBtoHLS(dwRGBcolor);
  49.     if (gLum != pCI->currentLum)
  50.     {
  51.         hDC = GetDC(hDlg);
  52.         EraseLumArrow(hDC, pCI);
  53.         pCI->currentLum = gLum;
  54.         HLStoHLSPos(COLOR_LUM, pCI);
  55.         LumArrowPaint(hDC, pCI->nLumPos, pCI);
  56.         ReleaseDC(hDlg, hDC);
  57.     }
  58.     if ((gHue != pCI->currentHue) || (gSat != pCI->currentSat))
  59.     {
  60.         pCI->currentHue = gHue;
  61.         pCI->currentSat = gSat;
  62.         InvalidateRect(hDlg, (LPRECT)&pCI->rLumPaint, FALSE);
  63.         hDC = GetDC(hDlg);
  64.         EraseCrossHair(hDC, pCI);
  65.         HLStoHLSPos(COLOR_HUE, pCI);
  66.         HLStoHLSPos(COLOR_SAT, pCI);
  67.         CrossHairPaint(hDC, pCI->nHuePos, pCI->nSatPos, pCI);
  68.         ReleaseDC(hDlg, hDC);
  69.     }
  70. }
  73. ////////////////////////////////////////////////////////////////////////////
  74. //
  75. //  LumArrowPaint
  76. //
  77. ////////////////////////////////////////////////////////////////////////////
  79. VOID LumArrowPaint(
  80.     HDC hDC,
  81.     SHORT y,
  82.     PCOLORINFO pCI)
  83. {
  84.     HBRUSH hBrush;
  85.     int x, h;
  87.     hBrush = SelectObject(hDC, GetSysColorBrush(COLOR_BTNTEXT));
  89.     for (x = pCI->rLumScroll.left + 2, h = 1;
  90.          x < pCI->rLumScroll.right - 2;
  91.          x++, h += 2)
  92.     {
  93.         PatBlt(hDC, x, y - h / 2, 1, h, PATCOPY);
  94.     }
  96.     SelectObject(hDC, hBrush);
  97. }
  100. ////////////////////////////////////////////////////////////////////////////
  101. //
  102. //  EraseLumArrow
  103. //
  104. ////////////////////////////////////////////////////////////////////////////
  106. VOID EraseLumArrow(
  107.     HDC hDC,
  108.     PCOLORINFO pCI)
  109. {
  110.     HBRUSH hBrush;
  111.     RECT Rect;
  113.     hBrush = (HBRUSH)SendMessage( pCI->hDialog,
  114.                                   WM_CTLCOLORDLG,
  115.                                   (WPARAM)hDC,
  116.                                   (LPARAM)pCI->hDialog );
  118.     Rect.left   = pCI->rLumScroll.left + 1;
  119.     Rect.right  = pCI->rLumScroll.right;
  120.     Rect.top    = pCI->nLumPos - (pCI->rLumScroll.right - pCI->rLumScroll.left);
  121.     Rect.bottom = pCI->nLumPos + (pCI->rLumScroll.right - pCI->rLumScroll.left) + 1;
  123.     FillRect(hDC, &Rect, hBrush);
  124. }
  127. ////////////////////////////////////////////////////////////////////////////
  128. //
  129. //  EraseCrossHair
  130. //
  131. ////////////////////////////////////////////////////////////////////////////
  133. VOID EraseCrossHair(
  134.     HDC hDC,
  135.     PCOLORINFO pCI)
  136. {
  137.     HBITMAP hOldBitmap;
  138.     WORD distancex, distancey;
  139.     WORD topy, bottomy, leftx, rightx;
  140.     RECT rRainbow;
  142.     CopyRect(&rRainbow, &pCI->rRainbow);
  144.     distancex = (WORD)(10 * cxBorder);
  145.     distancey = (WORD)(10 * cyBorder);
  146.     topy    = ((WORD)rRainbow.top > pCI->nSatPos - distancey)
  147.                   ? (WORD)rRainbow.top
  148.                   : pCI->nSatPos - distancey;
  149.     bottomy = ((WORD)rRainbow.bottom < pCI->nSatPos + distancey)
  150.                   ? (WORD)rRainbow.bottom
  151.                   : pCI->nSatPos + distancey;
  152.     leftx   = ((WORD)rRainbow.left > pCI->nHuePos - distancex)
  153.                   ? (WORD)rRainbow.left
  154.                   : pCI->nHuePos - distancex;
  155.     rightx  = ((WORD)rRainbow.right < pCI->nHuePos + distancex)
  156.                   ? (WORD)rRainbow.right
  157.                   : pCI->nHuePos + distancex;
  159.     hOldBitmap = SelectObject(hDCFastBlt, hRainbowBitmap);
  160.     BitBlt( hDC,
  161.             leftx,
  162.             topy,
  163.             rightx - leftx,
  164.             bottomy - topy,
  165.             hDCFastBlt,
  166.             leftx - (WORD)rRainbow.left,
  167.             topy - (WORD)rRainbow.top,
  168.             SRCCOPY );
  169.     SelectObject(hDCFastBlt, hOldBitmap);
  170. }
  173. ////////////////////////////////////////////////////////////////////////////
  174. //
  175. //  CrossHairPaint
  176. //
  177. ////////////////////////////////////////////////////////////////////////////
  179. VOID CrossHairPaint(
  180.     register HDC hDC,
  181.     SHORT x,
  182.     SHORT y,
  183.     PCOLORINFO pCI)
  184. {
  185.     SHORT distancex, distancey;
  186.     SHORT topy, bottomy, topy2, bottomy2;
  187.     SHORT leftx, rightx, leftx2, rightx2;
  188.     RECT rRainbow;
  190.     CopyRect(&rRainbow, &pCI->rRainbow);
  191.     distancex = (SHORT)(5 * cxBorder);
  192.     distancey = (SHORT)(5 * cyBorder);
  193.     topy     = (SHORT)((rRainbow.top > y - 2 * distancey)
  194.                          ? rRainbow.top
  195.                          : y - 2 * distancey);
  196.     bottomy  = (SHORT)((rRainbow.bottom < y + 2 * distancey)
  197.                          ? rRainbow.bottom
  198.                          : y + 2 * distancey);
  199.     leftx    = (SHORT)((rRainbow.left > x - 2 * distancex)
  200.                          ? rRainbow.left
  201.                          : x - 2 * distancex);
  202.     rightx   = (SHORT)((rRainbow.right < x + 2 * distancex)
  203.                          ? rRainbow.right
  204.                          : x + 2 * distancex);
  205.     topy2    = (SHORT)((rRainbow.top > y - distancey)
  206.                          ? rRainbow.top
  207.                          : y - distancey);
  208.     bottomy2 = (SHORT)((rRainbow.bottom < y + distancey)
  209.                          ? rRainbow.bottom
  210.                          : y + distancey);
  211.     leftx2 = (SHORT)((rRainbow.left > x - distancex)
  212.                          ? rRainbow.left
  213.                          : x - distancex);
  214.     rightx2 = (SHORT)((rRainbow.right < x + distancex)
  215.                          ? rRainbow.right
  216.                          : x + distancex);
  217.     if (rRainbow.top < topy2)
  218.     {
  219.         if ((x - 1) >= rRainbow.left)
  220.         {
  221.             MMoveTo(hDC, x - 1, topy2);
  222.             LineTo(hDC, x - 1, topy);
  223.         }
  224.         if ((int)x < rRainbow.right)
  225.         {
  226.             MMoveTo(hDC, x, topy2);
  227.             LineTo(hDC, x, topy);
  228.         }
  229.         if ((x + 1) < rRainbow.right)
  230.         {
  231.             MMoveTo(hDC, x + 1, topy2);
  232.             LineTo(hDC, x + 1, topy);
  233.         }
  234.     }
  235.     if (rRainbow.bottom > bottomy2)
  236.     {
  237.         if ((x - 1) >= rRainbow.left)
  238.         {
  239.             MMoveTo(hDC, x - 1, bottomy2);
  240.             LineTo(hDC, x - 1, bottomy);
  241.         }
  242.         if ((int)x < rRainbow.right)
  243.         {
  244.             MMoveTo(hDC, x, bottomy2);
  245.             LineTo(hDC, x, bottomy);
  246.         }
  247.         if ((x + 1) < rRainbow.right)
  248.         {
  249.             MMoveTo(hDC, x + 1, bottomy2);
  250.             LineTo(hDC, x + 1, bottomy);
  251.         }
  252.     }
  253.     if (rRainbow.left < leftx2)
  254.     {
  255.         if ((y - 1) >= rRainbow.top)
  256.         {
  257.             MMoveTo(hDC, leftx2, y - 1);
  258.             LineTo(hDC, leftx, y - 1);
  259.         }
  260.         if ((int)y < rRainbow.bottom)
  261.         {
  262.             MMoveTo(hDC, leftx2, y);
  263.             LineTo(hDC, leftx, y);
  264.         }
  265.         if ((y + 1) < rRainbow.bottom)
  266.         {
  267.             MMoveTo(hDC, leftx2, y + 1);
  268.             LineTo(hDC, leftx, y + 1);
  269.         }
  270.     }
  271.     if (rRainbow.right > rightx2)
  272.     {
  273.         if ((y - 1) >= rRainbow.top)
  274.         {
  275.             MMoveTo(hDC, rightx2, y - 1);
  276.             LineTo(hDC, rightx, y - 1);
  277.         }
  278.         if ((int)y < rRainbow.bottom)
  279.         {
  280.             MMoveTo(hDC, rightx2, y);
  281.             LineTo(hDC, rightx, y);
  282.         }
  283.         if ((y + 1) < rRainbow.bottom)
  284.         {
  285.             MMoveTo(hDC, rightx2, y + 1);
  286.             LineTo(hDC, rightx, y + 1);
  287.         }
  288.     }
  289. }
  292. ////////////////////////////////////////////////////////////////////////////
  293. //
  294. //  NearestSolid
  295. //
  296. ////////////////////////////////////////////////////////////////////////////
  298. VOID NearestSolid(
  299.     register PCOLORINFO pCI)
  300. {
  301.     register HDC hDC;
  302.     HWND hDlg = pCI->hDialog;
  304.     hDC = GetDC(hDlg);
  305.     EraseCrossHair(hDC, pCI);
  306.     EraseLumArrow(hDC, pCI);
  307.     RGBtoHLS(pCI->currentRGB = GetNearestColor(hDC, pCI->currentRGB));
  308.     pCI->currentHue = gHue;
  309.     pCI->currentLum = gLum;
  310.     pCI->currentSat = gSat;
  311.     HLStoHLSPos(0, pCI);
  312.     CrossHairPaint(hDC, pCI->nHuePos, pCI->nSatPos, pCI);
  313.     LumArrowPaint(hDC, pCI->nLumPos, pCI);
  314.     ReleaseDC(hDlg, hDC);
  315.     SetHLSEdit(0, pCI);
  316.     SetRGBEdit(0, pCI);
  317.     InvalidateRect(hDlg, (LPRECT)&pCI->rColorSamples, FALSE);
  318.     InvalidateRect(hDlg, (LPRECT)&pCI->rLumPaint, FALSE);
  319. }
  322. ////////////////////////////////////////////////////////////////////////////
  323. //
  324. //  HLSPostoHLS
  325. //
  326. ////////////////////////////////////////////////////////////////////////////
  328. VOID HLSPostoHLS(
  329.     SHORT nHLSEdit,
  330.     register PCOLORINFO pCI)
  331. {
  332.     switch (nHLSEdit)
  333.     {
  334.         case COLOR_HUE:
  335.         {
  336.             pCI->currentHue = (WORD)((pCI->nHuePos - pCI->rRainbow.left) *
  337.                                      (RANGE - 1) / (pCI->nHueWidth - 1));
  338.             break;
  339.         }
  340.         case COLOR_SAT:
  341.         {
  342.             pCI->currentSat = (WORD)(RANGE -
  343.                                      (pCI->nSatPos - pCI->rRainbow.top) *
  344.                                      RANGE / (pCI->nSatHeight - 1));
  345.             break;
  346.         }
  347.         case COLOR_LUM:
  348.         {
  349.             pCI->currentLum = (WORD)(RANGE -
  350.                                      (pCI->nLumPos - pCI->rLumPaint.top) *
  351.                                      RANGE / (pCI->nLumHeight - 1));
  352.             break;
  353.         }
  354.         default:
  355.         {
  356.             pCI->currentHue = (WORD)((pCI->nHuePos - pCI->rRainbow.left) *
  357.                                      (RANGE - 1) / pCI->nHueWidth);
  358.             pCI->currentSat = (WORD)(RANGE -
  359.                                      (pCI->nSatPos - pCI->rRainbow.top) *
  360.                                      RANGE / pCI->nSatHeight);
  361.             pCI->currentLum = (WORD)(RANGE -
  362.                                      (pCI->nLumPos - pCI->rLumPaint.top) *
  363.                                      RANGE / pCI->nLumHeight);
  364.             break;
  365.         }
  366.     }
  367. }
  370. ////////////////////////////////////////////////////////////////////////////
  371. //
  372. //  HLStoHLSPos
  373. //
  374. ////////////////////////////////////////////////////////////////////////////
  376. VOID HLStoHLSPos(
  377.     SHORT nHLSEdit,
  378.     register PCOLORINFO pCI)
  379. {
  380.     switch (nHLSEdit)
  381.     {
  382.         case ( COLOR_HUE ) :
  383.         {
  384.             pCI->nHuePos = (WORD)(pCI->rRainbow.left + pCI->currentHue *
  385.                                   pCI->nHueWidth / (RANGE - 1));
  386.             break;
  387.         }
  388.         case COLOR_SAT:
  389.         {
  390.             pCI->nSatPos = (WORD)(pCI->rRainbow.top +
  391.                                   (RANGE - pCI->currentSat) *
  392.                                   (pCI->nSatHeight - 1) / RANGE);
  393.             break;
  394.         }
  395.         case COLOR_LUM:
  396.         {
  397.             pCI->nLumPos = (WORD)(pCI->rLumPaint.top +
  398.                                   (RANGE - pCI->currentLum) *
  399.                                   (pCI->nLumHeight - 1) / RANGE);
  400.             break;
  401.         }
  402.         default:
  403.         {
  404.             pCI->nHuePos = (WORD)(pCI->rRainbow.left + pCI->currentHue *
  405.                                   pCI->nHueWidth / (RANGE - 1));
  406.             pCI->nSatPos = (WORD)(pCI->rRainbow.top +
  407.                                   (RANGE - pCI->currentSat) *
  408.                                   (pCI->nSatHeight - 1) / RANGE);
  409.             pCI->nLumPos = (WORD)(pCI->rLumPaint.top +
  410.                                   (RANGE - pCI->currentLum) *
  411.                                   (pCI->nLumHeight - 1) / RANGE);
  412.             break;
  413.         }
  414.     }
  415. }
  418. ////////////////////////////////////////////////////////////////////////////
  419. //
  420. //  SetHLSEdit
  421. //
  422. ////////////////////////////////////////////////////////////////////////////
  424. VOID SetHLSEdit(
  425.     SHORT nHLSEdit,
  426.     register PCOLORINFO pCI)
  427. {
  428.     register HWND hRainbowDlg = pCI->hDialog;
  430.     switch (nHLSEdit)
  431.     {
  432.         case ( COLOR_HUE ) :
  433.         {
  434.             SetDlgItemInt(hRainbowDlg, COLOR_HUE, pCI->currentHue, FALSE);
  435.             break;
  436.         }
  437.         case ( COLOR_SAT ) :
  438.         {
  439.             SetDlgItemInt(hRainbowDlg, COLOR_SAT, pCI->currentSat, FALSE);
  440.             break;
  441.         }
  442.         case ( COLOR_LUM ) :
  443.         {
  444.             SetDlgItemInt(hRainbowDlg, COLOR_LUM, pCI->currentLum, FALSE);
  445.             break;
  446.         }
  447.         default :
  448.         {
  449.             SetDlgItemInt(hRainbowDlg, COLOR_HUE, pCI->currentHue, FALSE);
  450.             SetDlgItemInt(hRainbowDlg, COLOR_SAT, pCI->currentSat, FALSE);
  451.             SetDlgItemInt(hRainbowDlg, COLOR_LUM, pCI->currentLum, FALSE);
  452.             break;
  453.         }
  454.     }
  455. }
  458. ////////////////////////////////////////////////////////////////////////////
  459. //
  460. //  SetRGBEdit
  461. //
  462. ////////////////////////////////////////////////////////////////////////////
  464. VOID SetRGBEdit(
  465.     SHORT nRGBEdit,
  466.     PCOLORINFO pCI)
  467. {
  468.     register HWND hRainbowDlg = pCI->hDialog;
  469.     DWORD rainbowRGB = pCI->currentRGB;
  471.     switch (nRGBEdit)
  472.     {
  473.         case ( COLOR_RED ) :
  474.         {
  475.             SetDlgItemInt(hRainbowDlg, COLOR_RED, GetRValue(rainbowRGB), FALSE);
  476.             break;
  477.         }
  478.         case ( COLOR_GREEN ) :
  479.         {
  480.             SetDlgItemInt(hRainbowDlg, COLOR_GREEN, GetGValue(rainbowRGB), FALSE);
  481.             break;
  482.         }
  483.         case ( COLOR_BLUE ) :
  484.         {
  485.             SetDlgItemInt(hRainbowDlg, COLOR_BLUE, GetBValue(rainbowRGB), FALSE);
  486.             break;
  487.         }
  488.         default :
  489.         {
  490.             SetDlgItemInt(hRainbowDlg, COLOR_RED, GetRValue(rainbowRGB), FALSE);
  491.             SetDlgItemInt(hRainbowDlg, COLOR_GREEN, GetGValue(rainbowRGB), FALSE);
  492.             SetDlgItemInt(hRainbowDlg, COLOR_BLUE, GetBValue(rainbowRGB), FALSE);
  493.             break;
  494.         }
  495.     }
  496. }
  499. ////////////////////////////////////////////////////////////////////////////
  500. //
  501. //  InitRainbow
  502. //
  503. //  Returns TRUE iff we make it.
  504. //
  505. ////////////////////////////////////////////////////////////////////////////
  507. BOOL InitRainbow(
  508.     register PCOLORINFO pCI)
  509. {
  510.     HDC hDC;
  511.     WORD Sat, Hue;
  512.     HBITMAP hOldBitmap;
  513.     RECT Rect;
  514.     HBRUSH hbrSwipe;
  515.     WORD nHueWidth, nSatHeight;
  516.     register HWND hRainbowDlg = pCI->hDialog;
  518.     RGBtoHLS(pCI->currentRGB);
  520.     SetupRainbowCapture(pCI);
  522.     nHueWidth = pCI->nHueWidth = (WORD)(pCI->rRainbow.right -
  523.                                         pCI->rRainbow.left);
  524.     nSatHeight = pCI->nSatHeight = (WORD)(pCI->rRainbow.bottom -
  525.                                           pCI->rRainbow.top);
  527.     pCI->currentHue = gHue;
  528.     pCI->currentSat = gSat;
  529.     pCI->currentLum = gLum;
  531.     HLStoHLSPos(0, pCI);
  532.     SetRGBEdit(0, pCI);
  533.     SetHLSEdit(0, pCI);
  535.     if (!hRainbowBitmap)
  536.     {
  537.         hDC = GetDC(hRainbowDlg);
  538.         hRainbowBitmap = CreateCompatibleBitmap(hDC, nHueWidth, nSatHeight);
  539.         if (!hRainbowBitmap)
  540.         {
  541.             return (FALSE);
  542.         }
  543.     }
  545.     hOldBitmap = SelectObject(hDCFastBlt, hRainbowBitmap);
  547.     //
  548.     //  NOTE: The final pass through this loop paints on and past the end
  549.     //        of the selected bitmap.  Windows is a good product, and doesn't
  550.     //        let such foolishness happen.
  551.     //
  552.     Rect.bottom = 0;
  553.     for (Sat = RANGE; Sat > 0; Sat -= SATINC)
  554.     {
  555.         Rect.top = Rect.bottom;
  556.         Rect.bottom = (nSatHeight * RANGE - (Sat - SATINC) * nSatHeight) / RANGE;
  557.         Rect.right = 0;
  559.         for (Hue = 0; Hue < (RANGE - 1); Hue += HUEINC)
  560.         {
  561.             Rect.left = Rect.right;
  562.             Rect.right = ((Hue + HUEINC) * nHueWidth) / RANGE;
  563.             hbrSwipe = CreateSolidBrush(HLStoRGB(Hue, RANGE / 2, Sat));
  564.             FillRect(hDCFastBlt, &Rect, hbrSwipe);
  565.             DeleteObject(hbrSwipe);
  566.         }
  567.     }
  569.     SelectObject(hDCFastBlt, hOldBitmap);
  570.     ReleaseDC(hRainbowDlg, hDC);
  572.     UpdateWindow(hRainbowDlg);
  574.     return (TRUE);
  575. }
  578. ////////////////////////////////////////////////////////////////////////////
  579. //
  580. //  PaintRainbow
  581. //
  582. ////////////////////////////////////////////////////////////////////////////
  584. VOID PaintRainbow(
  585.     HDC hDC,
  586.     LPRECT lpRect,
  587.     register PCOLORINFO pCI)
  588. {
  589.     HBITMAP hOldBitmap;
  591.     if (!hRainbowBitmap)
  592.     {
  593.         return;
  594.     }
  595.     hOldBitmap = SelectObject(hDCFastBlt, hRainbowBitmap);
  596.     BitBlt( hDC,
  597.             lpRect->left,
  598.             lpRect->top,
  599.             lpRect->right - lpRect->left,
  600.             lpRect->bottom - lpRect->top,
  601.             hDCFastBlt,
  602.             lpRect->left - pCI->rRainbow.left,
  603.             lpRect->top - pCI->rRainbow.top,
  604.             SRCCOPY );
  605.     SelectObject(hDCFastBlt, hOldBitmap);
  606.     CrossHairPaint(hDC, pCI->nHuePos, pCI->nSatPos, pCI);
  607.     UpdateWindow(pCI->hDialog);
  608. }
  611. ////////////////////////////////////////////////////////////////////////////
  612. //
  613. //  RainbowPaint
  614. //
  615. ////////////////////////////////////////////////////////////////////////////
  617. void RainbowPaint(
  618.     register PCOLORINFO pCI,
  619.     HDC hDC,
  620.     LPRECT lpPaintRect)
  621. {
  622.     WORD Lum;
  623.     RECT Rect;
  624.     HBRUSH hbrSwipe;
  626.     //
  627.     //  Paint the Current Color Sample.
  628.     //
  629.     if (IntersectRect((LPRECT)&Rect, lpPaintRect, (LPRECT)&(pCI->rCurrentColor)))
  630.     {
  631.         hbrSwipe = CreateSolidBrush(pCI->currentRGB);
  632.         FillRect(hDC, (LPRECT)&Rect, hbrSwipe);
  633.         DeleteObject(hbrSwipe);
  634.     }
  636.     //
  637.     //  Paint the Nearest Pure Color Sample.
  638.     //
  639.     if (IntersectRect((LPRECT)&Rect, lpPaintRect, (LPRECT)&(pCI->rNearestPure)))
  640.     {
  641.         hbrSwipe = CreateSolidBrush(GetNearestColor(hDC, pCI->currentRGB));
  642.         FillRect(hDC, (LPRECT)&Rect, hbrSwipe);
  643.         DeleteObject(hbrSwipe);
  644.     }
  646.     //
  647.     //  Paint the Luminosity Range.
  648.     //
  649.     if (IntersectRect((LPRECT)&Rect, lpPaintRect, (LPRECT)&(pCI->rLumPaint)))
  650.     {
  651.         Rect.left = pCI->rLumPaint.left;
  652.         Rect.right = pCI->rLumPaint.right;
  653.         Rect.top = pCI->rLumPaint.bottom - LUMINC / 2;
  654.         Rect.bottom = pCI->rLumPaint.bottom;
  655.         hbrSwipe = CreateSolidBrush(HLStoRGB( pCI->currentHue,
  656.                                               0,
  657.                                               pCI->currentSat ));
  658.         FillRect(hDC, (LPRECT)&Rect, hbrSwipe);
  659.         DeleteObject(hbrSwipe);
  660.         for (Lum = LUMINC; Lum < RANGE; Lum += LUMINC)
  661.         {
  662.             Rect.bottom = Rect.top;
  663.             Rect.top = (((pCI->rLumPaint.bottom + LUMINC / 2) * (DWORD)RANGE -
  664.                          (Lum + LUMINC) * pCI->nLumHeight) / RANGE);
  665.             hbrSwipe = CreateSolidBrush(HLStoRGB( pCI->currentHue,
  666.                                                   Lum,
  667.                                                   pCI->currentSat ));
  668.             FillRect(hDC, (LPRECT)&Rect, hbrSwipe);
  669.             DeleteObject(hbrSwipe);
  670.         }
  671.         Rect.bottom = Rect.top;
  672.         Rect.top = pCI->rLumPaint.top;
  673.         hbrSwipe = CreateSolidBrush(HLStoRGB( pCI->currentHue,
  674.                                               RANGE,
  675.                                               pCI->currentSat ));
  676.         FillRect(hDC, (LPRECT)&Rect, hbrSwipe);
  677.         DeleteObject(hbrSwipe);
  679.         //
  680.         //  Paint the bounding rectangle only when it might be necessary.
  681.         //
  682.         if (!EqualRect(lpPaintRect, (LPRECT)&pCI->rLumPaint))
  683.         {
  684.             hbrSwipe = SelectObject(hDC, GetStockObject(NULL_BRUSH));
  685.             Rectangle( hDC,
  686.                        pCI->rLumPaint.left - 1,
  687.                        pCI->rLumPaint.top - 1,
  688.                        pCI->rLumPaint.right + 1,
  689.                        pCI->rLumPaint.bottom + 1 );
  690.             SelectObject(hDC, hbrSwipe);
  691.         }
  692.     }
  694.     //
  695.     //  Paint the Luminosity Arrow.
  696.     //
  697.     if (IntersectRect((LPRECT)&Rect, lpPaintRect, (LPRECT)&pCI->rLumScroll))
  698.     {
  699.         LumArrowPaint(hDC, pCI->nLumPos, pCI);
  700.     }
  702.     if (IntersectRect((LPRECT)&Rect, lpPaintRect, (LPRECT)&pCI->rRainbow))
  703.     {
  704.         PaintRainbow(hDC, (LPRECT)&Rect, pCI);
  705.     }
  706. }
  709. ////////////////////////////////////////////////////////////////////////////
  710. //
  711. //  Color conversion routines --
  712. //
  713. //  RGBtoHLS() takes a DWORD RGB value, translates it to HLS, and stores the
  714. //  results in the global vars H, L, and S.  HLStoRGB takes the current values
  715. //  of H, L, and S and returns the equivalent value in an RGB DWORD.  The vars
  716. //  H, L and S are written to only by 1) RGBtoHLS (initialization) or 2) the
  717. //  scrollbar handlers.
  718. //
  719. //  A point of reference for the algorithms is Foley and Van Dam, pp. 618-19.
  720. //  Their algorithm is in floating point.
  721. //
  722. //  There are potential roundoff errors lurking throughout here.
  723. //     (0.5 + x/y) without floating point,
  724. //     (x / y) phrased ((x + (y / 2)) / y) yields very small roundoff error.
  725. //  This makes many of the following divisions look funny.
  726. //
  727. //
  728. //  H,L, and S vary over 0 - HLSMAX.
  729. //  R,G, and B vary over 0 - RGBMAX.
  730. //  HLSMAX BEST IF DIVISIBLE BY 6.
  731. //  RGBMAX, HLSMAX must each fit in a byte.
  732. //
  733. //  Hue is undefined if Saturation is 0 (grey-scale).
  734. //  This value determines where the Hue scrollbar is initially set for
  735. //  achromatic colors.
  736. //
  737. ////////////////////////////////////////////////////////////////////////////
  739. #define UNDEFINED (HLSMAX * 2 / 3)
  742. ////////////////////////////////////////////////////////////////////////////
  743. //
  744. //  RGBtoHLS
  745. //
  746. ////////////////////////////////////////////////////////////////////////////
  748. VOID RGBtoHLS(
  749.     DWORD lRGBColor)
  750. {
  751.     WORD R, G, B;                 // input RGB values
  752.     WORD cMax,cMin;               // max and min RGB values
  753.     WORD cSum,cDif;
  754.     SHORT Rdelta, Gdelta, Bdelta; // intermediate value: % of spread from max
  756.     //
  757.     //  get R, G, and B out of DWORD.
  758.     //
  759.     R = GetRValue(lRGBColor);
  760.     G = GetGValue(lRGBColor);
  761.     B = GetBValue(lRGBColor);
  763.     //
  764.     //  Calculate lightness.
  765.     //
  766.     cMax = max(max(R, G), B);
  767.     cMin = min(min(R, G), B);
  768.     cSum = cMax + cMin;
  769.     gLum = (WORD)(((cSum * (DWORD)HLSMAX) + RGBMAX) / (2 * RGBMAX));
  771.     cDif = cMax - cMin;
  772.     if (!cDif)
  773.     {
  774.         //
  775.         //  r = g = b --> Achromatic case.
  776.         //
  777.         gSat = 0;                         // saturation
  778.         gHue = UNDEFINED;                 // hue
  779.     }
  780.     else
  781.     {
  782.         //
  783.         //  Chromatic case.
  784.         //
  786.         //
  787.         //  Saturation.
  788.         //
  789.         //  Note: Division by cSum is not a problem, as cSum can only
  790.         //        be 0 if the RGB value is 0L, and that is achromatic.
  791.         //
  792.         if (gLum <= (HLSMAX / 2))
  793.         {
  794.             gSat = (WORD)(((cDif * (DWORD) HLSMAX) + (cSum / 2) ) / cSum);
  795.         }
  796.         else
  797.         {
  798.             gSat = (WORD)((DWORD)((cDif * (DWORD)HLSMAX) +
  799.                                (DWORD)((2 * RGBMAX - cSum) / 2)) /
  800.                        (2 * RGBMAX - cSum));
  801.         }
  803.         //
  804.         //  Hue.
  805.         //
  806.         Rdelta = (SHORT)((((cMax - R) * (DWORD)(HLSMAX / 6)) + (cDif / 2) ) / cDif);
  807.         Gdelta = (SHORT)((((cMax - G) * (DWORD)(HLSMAX / 6)) + (cDif / 2) ) / cDif);
  808.         Bdelta = (SHORT)((((cMax - B) * (DWORD)(HLSMAX / 6)) + (cDif / 2) ) / cDif);
  810.         if (R == cMax)
  811.         {
  812.             gHue = Bdelta - Gdelta;
  813.         }
  814.         else if (G == cMax)
  815.         {
  816.             gHue = (WORD)((HLSMAX / 3) + Rdelta - Bdelta);
  817.         }
  818.         else  // (B == cMax)
  819.         {
  820.             gHue = (WORD)(((2 * HLSMAX) / 3) + Gdelta - Rdelta);
  821.         }
  823.         if ((short)gHue < 0)
  824.         {
  825.             //
  826.             //  This can occur when R == cMax and G is > B.
  827.             //
  828.             gHue += HLSMAX;
  829.         }
  830.         if (gHue >= HLSMAX)
  831.         {
  832.             gHue -= HLSMAX;
  833.         }
  834.     }
  835. }
  838. ////////////////////////////////////////////////////////////////////////////
  839. //
  840. //  HueToRGB
  841. //
  842. //  Utility routine for HLStoRGB.
  843. //
  844. ////////////////////////////////////////////////////////////////////////////
  846. WORD HueToRGB(
  847.     WORD n1,
  848.     WORD n2,
  849.     WORD hue)
  850. {
  851.     if (hue >= HLSMAX)
  852.     {
  853.         hue -= HLSMAX;
  854.     }
  856.     //
  857.     //  Return r, g, or b value from this tridrant.
  858.     //
  859.     if (hue < (HLSMAX / 6))
  860.     {
  861.         return ((WORD)(n1 + (((n2 - n1) * hue + (HLSMAX / 12)) / (HLSMAX / 6))));
  862.     }
  863.     if (hue < (HLSMAX/2))
  864.     {
  865.         return (n2);
  866.     }
  867.     if (hue < ((HLSMAX*2)/3))
  868.     {
  869.         return ((WORD)(n1 + (((n2 - n1) * (((HLSMAX * 2) / 3) - hue) +
  870.                        (HLSMAX / 12)) / (HLSMAX / 6))));
  871.     }
  872.     else
  873.     {
  874.         return (n1);
  875.     }
  876. }
  879. ////////////////////////////////////////////////////////////////////////////
  880. //
  881. //  HLStoRGB
  882. //
  883. ////////////////////////////////////////////////////////////////////////////
  885. DWORD HLStoRGB(
  886.     WORD hue,
  887.     WORD lum,
  888.     WORD sat)
  889. {
  890.     WORD R, G, B;                      // RGB component values
  891.     WORD Magic1, Magic2;               // calculated magic numbers
  893.     if (sat == 0)
  894.     {
  895.         //
  896.         //  Achromatic case.
  897.         //
  898.         R = G = B = (WORD)((lum * RGBMAX) / HLSMAX);
  899.     }
  900.     else
  901.     {
  902.         //
  903.         //  Chromatic case
  904.         //
  906.         //
  907.         //  Set up magic numbers.
  908.         //
  909.         if (lum <= (HLSMAX / 2))
  910.         {
  911.             Magic2 = (WORD)((lum * ((DWORD)HLSMAX + sat) + (HLSMAX / 2)) / HLSMAX);
  912.         }
  913.         else
  914.         {
  915.             Magic2 = lum + sat -
  916.                      (WORD)(((lum * sat) + (DWORD)(HLSMAX / 2)) / HLSMAX);
  917.         }
  918.         Magic1 = (WORD)(2 * lum - Magic2);
  920.         //
  921.         //  Get RGB, change units from HLSMAX to RGBMAX.
  922.         //
  923.         R = (WORD)(((HueToRGB(Magic1, Magic2, (WORD)(hue + (HLSMAX / 3))) *
  924.                      (DWORD)RGBMAX + (HLSMAX / 2))) / HLSMAX);
  925.         G = (WORD)(((HueToRGB(Magic1, Magic2, hue) *
  926.                      (DWORD)RGBMAX + (HLSMAX / 2))) / HLSMAX);
  927.         B = (WORD)(((HueToRGB(Magic1, Magic2, (WORD)(hue - (HLSMAX / 3))) *
  928.                      (DWORD)RGBMAX + (HLSMAX / 2))) / HLSMAX);
  929.     }
  930.     return (RGB(R, G, B));
  931. }
  934. ////////////////////////////////////////////////////////////////////////////
  935. //
  936. //  RGBEditChange
  937. //
  938. //  Checks the edit box for a valid entry and updates the Hue, Sat, and Lum
  939. //  edit controls if appropriate.  Also updates Lum picture and current
  940. //  color sample.
  941. //
  942. //  nDlgID - Dialog ID of Red, Green or Blue edit control.
  943. //
  944. ////////////////////////////////////////////////////////////////////////////
  946. SHORT RGBEditChange(
  947.     SHORT nDlgID,
  948.     PCOLORINFO pCI)
  949. {
  950.     BOOL bOK;               // check that value in edit control is uint
  951.     BYTE *currentValue;     // pointer to byte in RGB to change (or reset)
  952.     SHORT nVal;
  953.     TCHAR cEdit[3];
  954.     register HWND hDlg = pCI->hDialog;
  956.     currentValue = (BYTE *)&pCI->currentRGB;
  957.     switch (nDlgID)
  958.     {
  959.         case ( COLOR_GREEN ) :
  960.         {
  961.             currentValue++;
  962.             break;
  963.         }
  964.         case ( COLOR_BLUE ) :
  965.         {
  966.             currentValue += 2;
  967.             break;
  968.         }
  969.     }
  970.     nVal = (SHORT)GetDlgItemInt(hDlg, nDlgID, (BOOL FAR *)&bOK, FALSE);
  971.     if (bOK)
  972.     {
  973.         if (nVal > RGBMAX)
  974.         {
  975.             nVal = RGBMAX;
  976.             SetDlgItemInt(hDlg, nDlgID, nVal, FALSE);
  977.         }
  978.         if (nVal != (SHORT) *currentValue)
  979.         {
  980.             *currentValue = LOBYTE(nVal);
  981.             ChangeColorSettings(pCI);
  982.             SetHLSEdit(nDlgID, pCI);
  983.         }
  984.     }
  985.     else if (GetDlgItemText(hDlg, nDlgID, (LPTSTR)cEdit, 2))
  986.     {
  987.         SetRGBEdit(nDlgID, pCI);
  988.         SendDlgItemMessage(hDlg, nDlgID, EM_SETSEL, (WPARAM)0, (LPARAM)-1);
  989.     }
  990.     return (SHORT)(bOK ? TRUE : FALSE);
  991. }