dlls/comdlg32/colordlg.c

   1 /*
   2  * COMMDLG - Color Dialog
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Albrecht Kleine
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 /* BUGS : still seems to not refresh correctly
  23    sometimes, especially when 2 instances of the
  24    dialog are loaded at the same time */
  25
  26 #include <ctype.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "wingdi.h"
  34 #include "winuser.h"
  35 #include "commdlg.h"
  36 #include "dlgs.h"
  37 #include "wine/debug.h"
  38 #include "cderr.h"
  39 #include "cdlg.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
  42
  43 static INT_PTR CALLBACK ColorDlgProc( HWND hWnd, UINT wMsg, WPARAM wParam, LPARAM lParam );
  44
  45 #define CONV_LPARAMTOPOINT(lp,p) do { (p)->x = (short)LOWORD(lp); (p)->y = (short)HIWORD(lp); } while(0)
  46
  47 static const COLORREF predefcolors[6][8]=
  48 {
  49  { 0x008080FFL, 0x0080FFFFL, 0x0080FF80L, 0x0080FF00L,
  50    0x00FFFF80L, 0x00FF8000L, 0x00C080FFL, 0x00FF80FFL },
  51  { 0x000000FFL, 0x0000FFFFL, 0x0000FF80L, 0x0040FF00L,
  52    0x00FFFF00L, 0x00C08000L, 0x00C08080L, 0x00FF00FFL },
  53
  54  { 0x00404080L, 0x004080FFL, 0x0000FF00L, 0x00808000L,
  55    0x00804000L, 0x00FF8080L, 0x00400080L, 0x008000FFL },
  56  { 0x00000080L, 0x000080FFL, 0x00008000L, 0x00408000L,
  57    0x00FF0000L, 0x00A00000L, 0x00800080L, 0x00FF0080L },
  58
  59  { 0x00000040L, 0x00004080L, 0x00004000L, 0x00404000L,
  60    0x00800000L, 0x00400000L, 0x00400040L, 0x00800040L },
  61  { 0x00000000L, 0x00008080L, 0x00408080L, 0x00808080L,
  62    0x00808040L, 0x00C0C0C0L, 0x00400040L, 0x00FFFFFFL },
  63 };
  64
  65 static const WCHAR szColourDialogProp[] = {
  66     'c','o','l','o','u','r','d','i','a','l','o','g','p','r','o','p',0 };
  67
  68 /* Chose Color PRIVATE Structure:
  69  *
  70  * This structure is duplicated in the 16 bit code with
  71  * an extra member
  72  */
  73
  74 typedef struct CCPRIVATE
  75 {
  76     LPCHOOSECOLORW lpcc; /* points to public known data structure */
  77     int nextuserdef;     /* next free place in user defined color array */
  78     HDC hdcMem;          /* color graph used for BitBlt() */
  79     HBITMAP hbmMem;      /* color graph bitmap */
  80     RECT fullsize;       /* original dialog window size */
  81     UINT msetrgb;        /* # of SETRGBSTRING message (today not used)  */
  82     RECT old3angle;      /* last position of l-marker */
  83     RECT oldcross;       /* last position of color/saturation marker */
  84     BOOL updating;       /* to prevent recursive WM_COMMAND/EN_UPDATE processing */
  85     int h;
  86     int s;
  87     int l;               /* for temporary storing of hue,sat,lum */
  88     int capturedGraph;   /* control mouse captured */
  89     RECT focusRect;      /* rectangle last focused item */
  90     HWND hwndFocus;      /* handle last focused item */
  91 } CCPRIV, *LPCCPRIV;
  92
  93 /***********************************************************************
  94  *                             CC_HSLtoRGB                    [internal]
  95  */
  96 int CC_HSLtoRGB(char c, int hue, int sat, int lum)
  97 {
  98  int res = 0, maxrgb;
  99
 100  /* hue */
 101  switch(c)
 102  {
 103   case 'R': if (hue > 80)  hue -= 80; else hue += 160; break;
 104   case 'G': if (hue > 160) hue -= 160; else hue += 80; break;
 105   case 'B': break;
 106  }
 107
 108  /* l below 120 */
 109  maxrgb = (256 * min(120,lum)) / 120;  /* 0 .. 256 */
 110  if (hue < 80)
 111   res = 0;
 112  else
 113   if (hue < 120)
 114   {
 115    res = (hue - 80) * maxrgb;           /* 0...10240 */
 116    res /= 40;                        /* 0...256 */
 117   }
 118   else
 119    if (hue < 200)
 120     res = maxrgb;
 121    else
 122     {
 123      res= (240 - hue) * maxrgb;
 124      res /= 40;
 125     }
 126  res = res - maxrgb / 2;                 /* -128...128 */
 127
 128  /* saturation */
 129  res = maxrgb / 2 + (sat * res) / 240;    /* 0..256 */
 130
 131  /* lum above 120 */
 132  if (lum > 120 && res < 256)
 133   res += ((lum - 120) * (256 - res)) / 120;
 134
 135  return min(res, 255);
 136 }
 137
 138 /***********************************************************************
 139  *                             CC_RGBtoHSL                    [internal]
 140  */
 141 int CC_RGBtoHSL(char c, int r, int g, int b)
 142 {
 143  WORD maxi, mini, mmsum, mmdif, result = 0;
 144  int iresult = 0;
 145
 146  maxi = max(r, b);
 147  maxi = max(maxi, g);
 148  mini = min(r, b);
 149  mini = min(mini, g);
 150
 151  mmsum = maxi + mini;
 152  mmdif = maxi - mini;
 153
 154  switch(c)
 155  {
 156   /* lum */
 157   case 'L': mmsum *= 120;              /* 0...61200=(255+255)*120 */
 158            result = mmsum / 255;        /* 0...240 */
 159            break;
 160   /* saturation */
 161   case 'S': if (!mmsum)
 162             result = 0;
 163            else
 164             if (!mini || maxi == 255)
 165              result = 240;
 166            else
 167            {
 168             result = mmdif * 240;       /* 0...61200=255*240 */
 169             result /= (mmsum > 255 ? mmsum = 510 - mmsum : mmsum); /* 0..255 */
 170            }
 171            break;
 172   /* hue */
 173   case 'H': if (!mmdif)
 174             result = 160;
 175            else
 176            {
 177             if (maxi == r)
 178             {
 179              iresult = 40 * (g - b);       /* -10200 ... 10200 */
 180              iresult /= (int) mmdif;    /* -40 .. 40 */
 181              if (iresult < 0)
 182               iresult += 240;          /* 0..40 and 200..240 */
 183             }
 184             else
 185              if (maxi == g)
 186              {
 187               iresult = 40 * (b - r);
 188               iresult /= (int) mmdif;
 189               iresult += 80;           /* 40 .. 120 */
 190              }
 191              else
 192               if (maxi == b)
 193               {
 194                iresult = 40 * (r - g);
 195                iresult /= (int) mmdif;
 196                iresult += 160;         /* 120 .. 200 */
 197               }
 198             result = iresult;
 199            }
 200            break;
 201  }
 202  return result;    /* is this integer arithmetic precise enough ? */
 203 }
 204
 205
 206 /***********************************************************************
 207  *                  CC_DrawCurrentFocusRect                       [internal]
 208  */
 209 static void CC_DrawCurrentFocusRect( const CCPRIV *lpp )
 210 {
 211   if (lpp->hwndFocus)
 212   {
 213     HDC hdc = GetDC(lpp->hwndFocus);
 214     DrawFocusRect(hdc, &lpp->focusRect);
 215     ReleaseDC(lpp->hwndFocus, hdc);
 216   }
 217 }
 218
 219 /***********************************************************************
 220  *                  CC_DrawFocusRect                       [internal]
 221  */
 222 static void CC_DrawFocusRect( LPCCPRIV lpp, HWND hwnd, int x, int y, int rows, int cols)
 223 {
 224   RECT rect;
 225   int dx, dy;
 226   HDC hdc;
 227
 228   CC_DrawCurrentFocusRect(lpp); /* remove current focus rect */
 229   /* calculate new rect */
 230   GetClientRect(hwnd, &rect);
 231   dx = (rect.right - rect.left) / cols;
 232   dy = (rect.bottom - rect.top) / rows;
 233   rect.left += (x * dx) - 2;
 234   rect.top += (y * dy) - 2;
 235   rect.right = rect.left + dx;
 236   rect.bottom = rect.top + dy;
 237   /* draw it */
 238   hdc = GetDC(hwnd);
 239   DrawFocusRect(hdc, &rect);
 240   CopyRect(&lpp->focusRect, &rect);
 241   lpp->hwndFocus = hwnd;
 242   ReleaseDC(hwnd, hdc);
 243 }
 244
 245 #define DISTANCE 4
 246
 247 /***********************************************************************
 248  *                CC_MouseCheckPredefColorArray               [internal]
 249  *                returns 1 if one of the predefined colors is clicked
 250  */
 251 static int CC_MouseCheckPredefColorArray( LPCCPRIV lpp, HWND hDlg, int dlgitem, int rows, int cols,
 252             LPARAM lParam )
 253 {
 254  HWND hwnd;
 255  POINT point;
 256  RECT rect;
 257  int dx, dy, x, y;
 258
 259  CONV_LPARAMTOPOINT(lParam, &point);
 260  ClientToScreen(hDlg, &point);
 261  hwnd = GetDlgItem(hDlg, dlgitem);
 262  GetWindowRect(hwnd, &rect);
 263  if (PtInRect(&rect, point))
 264  {
 265   dx = (rect.right - rect.left) / cols;
 266   dy = (rect.bottom - rect.top) / rows;
 267   ScreenToClient(hwnd, &point);
 268
 269   if (point.x % dx < ( dx - DISTANCE) && point.y % dy < ( dy - DISTANCE))
 270   {
 271    x = point.x / dx;
 272    y = point.y / dy;
 273    lpp->lpcc->rgbResult = predefcolors[y][x];
 274    CC_DrawFocusRect(lpp, hwnd, x, y, rows, cols);
 275    return 1;
 276   }
 277  }
 278  return 0;
 279 }
 280
 281 /***********************************************************************
 282  *                  CC_MouseCheckUserColorArray               [internal]
 283  *                  return 1 if the user clicked a color
 284  */
 285 static int CC_MouseCheckUserColorArray( LPCCPRIV lpp, HWND hDlg, int dlgitem, int rows, int cols,
 286             LPARAM lParam )
 287 {
 288  HWND hwnd;
 289  POINT point;
 290  RECT rect;
 291  int dx, dy, x, y;
 292  COLORREF *crarr = lpp->lpcc->lpCustColors;
 293
 294  CONV_LPARAMTOPOINT(lParam, &point);
 295  ClientToScreen(hDlg, &point);
 296  hwnd = GetDlgItem(hDlg, dlgitem);
 297  GetWindowRect(hwnd, &rect);
 298  if (PtInRect(&rect, point))
 299  {
 300   dx = (rect.right - rect.left) / cols;
 301   dy = (rect.bottom - rect.top) / rows;
 302   ScreenToClient(hwnd, &point);
 303
 304   if (point.x % dx < (dx - DISTANCE) && point.y % dy < (dy - DISTANCE))
 305   {
 306    x = point.x / dx;
 307    y = point.y / dy;
 308    lpp->lpcc->rgbResult = crarr[x + (cols * y) ];
 309    CC_DrawFocusRect(lpp, hwnd, x, y, rows, cols);
 310    return 1;
 311   }
 312  }
 313  return 0;
 314 }
 315
 316 #define MAXVERT  240
 317 #define MAXHORI  239
 318
 319 /*  240  ^......        ^^ 240
 320          |     .        ||
 321     SAT  |     .        || LUM
 322          |     .        ||
 323          +-----> 239   ----
 324            HUE
 325 */
 326 /***********************************************************************
 327  *                  CC_MouseCheckColorGraph                   [internal]
 328  */
 329 static int CC_MouseCheckColorGraph( HWND hDlg, int dlgitem, int *hori, int *vert, LPARAM lParam )
 330 {
 331  HWND hwnd;
 332  POINT point;
 333  RECT rect;
 334  long x,y;
 335
 336  CONV_LPARAMTOPOINT(lParam, &point);
 337  ClientToScreen(hDlg, &point);
 338  hwnd = GetDlgItem( hDlg, dlgitem );
 339  GetWindowRect(hwnd, &rect);
 340
 341  if (!PtInRect(&rect, point))
 342   return 0;
 343
 344  GetClientRect(hwnd, &rect);
 345  ScreenToClient(hwnd, &point);
 346
 347  x = (long) point.x * MAXHORI;
 348  x /= rect.right;
 349  y = (long) (rect.bottom - point.y) * MAXVERT;
 350  y /= rect.bottom;
 351
 352  if (x < 0) x = 0;
 353  if (y < 0) y = 0;
 354  if (x > MAXHORI) x = MAXHORI;
 355  if (y > MAXVERT) y = MAXVERT;
 356
 357  if (hori)
 358   *hori = x;
 359  if (vert)
 360   *vert = y;
 361
 362  return 1;
 363 }
 364 /***********************************************************************
 365  *                  CC_MouseCheckResultWindow                 [internal]
 366  *                  test if double click one of the result colors
 367  */
 368 int CC_MouseCheckResultWindow( HWND hDlg, LPARAM lParam )
 369 {
 370  HWND hwnd;
 371  POINT point;
 372  RECT rect;
 373
 374  CONV_LPARAMTOPOINT(lParam, &point);
 375  ClientToScreen(hDlg, &point);
 376  hwnd = GetDlgItem(hDlg, 0x2c5);
 377  GetWindowRect(hwnd, &rect);
 378  if (PtInRect(&rect, point))
 379  {
 380   PostMessageA(hDlg, WM_COMMAND, 0x2c9, 0);
 381   return 1;
 382  }
 383  return 0;
 384 }
 385
 386 /***********************************************************************
 387  *                       CC_CheckDigitsInEdit                 [internal]
 388  */
 389 int CC_CheckDigitsInEdit( HWND hwnd, int maxval )
 390 {
 391  int i, k, m, result, value;
 392  long editpos;
 393  char buffer[30];
 394
 395  GetWindowTextA(hwnd, buffer, sizeof(buffer));
 396  m = strlen(buffer);
 397  result = 0;
 398
 399  for (i = 0 ; i < m ; i++)
 400   if (buffer[i] < '0' || buffer[i] > '9')
 401   {
 402    for (k = i + 1; k <= m; k++)  /* delete bad character */
 403    {
 404     buffer[i] = buffer[k];
 405     m--;
 406    }
 407    buffer[m] = 0;
 408    result = 1;
 409   }
 410
 411  value = atoi(buffer);
 412  if (value > maxval)       /* build a new string */
 413  {
 414   sprintf(buffer, "%d", maxval);
 415   result = 2;
 416  }
 417  if (result)
 418  {
 419   editpos = SendMessageA(hwnd, EM_GETSEL, 0, 0);
 420   SetWindowTextA(hwnd, buffer );
 421   SendMessageA(hwnd, EM_SETSEL, 0, editpos);
 422  }
 423  return value;
 424 }
 425
 426
 427
 428 /***********************************************************************
 429  *                    CC_PaintSelectedColor                   [internal]
 430  */
 431 void CC_PaintSelectedColor( HWND hDlg, COLORREF cr )
 432 {
 433  RECT rect;
 434  HDC  hdc;
 435  HBRUSH hBrush;
 436  HWND hwnd = GetDlgItem(hDlg, 0x2c5);
 437  if (IsWindowVisible( GetDlgItem(hDlg, 0x2c6) ))   /* if full size */
 438  {
 439   hdc = GetDC(hwnd);
 440   GetClientRect(hwnd, &rect) ;
 441   hBrush = CreateSolidBrush(cr);
 442   if (hBrush)
 443   {
 444    FillRect(hdc, &rect, hBrush);
 445    DrawEdge(hdc, &rect, BDR_SUNKENOUTER, BF_RECT);
 446   }
 447   ReleaseDC(hwnd, hdc);
 448  }
 449 }
 450
 451 /***********************************************************************
 452  *                    CC_PaintTriangle                        [internal]
 453  */
 454 void CC_PaintTriangle( HWND hDlg, int y)
 455 {
 456  HDC hDC;
 457  long temp;
 458  int w = LOWORD(GetDialogBaseUnits()) / 2;
 459  POINT points[3];
 460  int height;
 461  int oben;
 462  RECT rect;
 463  HBRUSH hbr;
 464  HWND hwnd = GetDlgItem(hDlg, 0x2be);
 465  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 466
 467  if (IsWindowVisible( GetDlgItem(hDlg, 0x2c6)))   /* if full size */
 468  {
 469    GetClientRect(hwnd, &rect);
 470    height = rect.bottom;
 471    hDC = GetDC(hDlg);
 472    points[0].y = rect.top;
 473    points[0].x = rect.right;     /*  |  /|  */
 474    ClientToScreen(hwnd, points); /*  | / |  */
 475    ScreenToClient(hDlg, points); /*  |<  |  */
 476    oben = points[0].y;           /*  | \ |  */
 477                                  /*  |  \|  */
 478    temp = (long)height * (long)y;
 479    points[0].x += 1;
 480    points[0].y = oben + height - temp / (long)MAXVERT;
 481    points[1].y = points[0].y + w;
 482    points[2].y = points[0].y - w;
 483    points[2].x = points[1].x = points[0].x + w;
 484
 485    hbr = (HBRUSH)GetClassLongPtrW( hwnd, GCLP_HBRBACKGROUND);
 486    if (!hbr) hbr = GetSysColorBrush(COLOR_BTNFACE);
 487    FillRect(hDC, &lpp->old3angle, hbr);
 488    lpp->old3angle.left  = points[0].x;
 489    lpp->old3angle.right = points[1].x + 1;
 490    lpp->old3angle.top   = points[2].y - 1;
 491    lpp->old3angle.bottom= points[1].y + 1;
 492
 493    hbr = SelectObject(hDC, GetStockObject(BLACK_BRUSH));
 494    Polygon(hDC, points, 3);
 495    SelectObject(hDC, hbr);
 496
 497    ReleaseDC(hDlg, hDC);
 498  }
 499 }
 500
 501
 502 /***********************************************************************
 503  *                    CC_PaintCross                           [internal]
 504  */
 505 void CC_PaintCross( HWND hDlg, int x, int y)
 506 {
 507  HDC hDC;
 508  int w = GetDialogBaseUnits() - 1;
 509  int wc = GetDialogBaseUnits() * 3 / 4;
 510  HWND hwnd = GetDlgItem(hDlg, 0x2c6);
 511  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 512  RECT rect;
 513  POINT point, p;
 514  HPEN hPen;
 515
 516  if (IsWindowVisible( GetDlgItem(hDlg, 0x2c6) ))   /* if full size */
 517  {
 518    GetClientRect(hwnd, &rect);
 519    hDC = GetDC(hwnd);
 520    SelectClipRgn( hDC, CreateRectRgnIndirect(&rect));
 521
 522    point.x = ((long)rect.right * (long)x) / (long)MAXHORI;
 523    point.y = rect.bottom - ((long)rect.bottom * (long)y) / (long)MAXVERT;
 524    if ( lpp->oldcross.left != lpp->oldcross.right )
 525      BitBlt(hDC, lpp->oldcross.left, lpp->oldcross.top,
 526               lpp->oldcross.right - lpp->oldcross.left,
 527               lpp->oldcross.bottom - lpp->oldcross.top,
 528               lpp->hdcMem, lpp->oldcross.left, lpp->oldcross.top, SRCCOPY);
 529    lpp->oldcross.left   = point.x - w - 1;
 530    lpp->oldcross.right  = point.x + w + 1;
 531    lpp->oldcross.top    = point.y - w - 1;
 532    lpp->oldcross.bottom = point.y + w + 1;
 533
 534    hPen = CreatePen(PS_SOLID, 3, 0x000000); /* -black- color */
 535    hPen = SelectObject(hDC, hPen);
 536    MoveToEx(hDC, point.x - w, point.y, &p);
 537    LineTo(hDC, point.x - wc, point.y);
 538    MoveToEx(hDC, point.x + wc, point.y, &p);
 539    LineTo(hDC, point.x + w, point.y);
 540    MoveToEx(hDC, point.x, point.y - w, &p);
 541    LineTo(hDC, point.x, point.y - wc);
 542    MoveToEx(hDC, point.x, point.y + wc, &p);
 543    LineTo(hDC, point.x, point.y + w);
 544    DeleteObject( SelectObject(hDC, hPen));
 545
 546    ReleaseDC(hwnd, hDC);
 547  }
 548 }
 549
 550
 551 #define XSTEPS 48
 552 #define YSTEPS 24
 553
 554
 555 /***********************************************************************
 556  *                    CC_PrepareColorGraph                    [internal]
 557  */
 558 static void CC_PrepareColorGraph( HWND hDlg )
 559 {
 560  int sdif, hdif, xdif, ydif, r, g, b, hue, sat;
 561  HWND hwnd = GetDlgItem(hDlg, 0x2c6);
 562  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 563  HBRUSH hbrush;
 564  HDC hdc ;
 565  RECT rect, client;
 566  HCURSOR hcursor = SetCursor( LoadCursorW(0, (LPCWSTR)IDC_WAIT) );
 567
 568  GetClientRect(hwnd, &client);
 569  hdc = GetDC(hwnd);
 570  lpp->hdcMem = CreateCompatibleDC(hdc);
 571  lpp->hbmMem = CreateCompatibleBitmap(hdc, client.right, client.bottom);
 572  SelectObject(lpp->hdcMem, lpp->hbmMem);
 573
 574  xdif = client.right / XSTEPS;
 575  ydif = client.bottom / YSTEPS+1;
 576  hdif = 239 / XSTEPS;
 577  sdif = 240 / YSTEPS;
 578  for (rect.left = hue = 0; hue < 239 + hdif; hue += hdif)
 579  {
 580   rect.right = rect.left + xdif;
 581   rect.bottom = client.bottom;
 582   for(sat = 0; sat < 240 + sdif; sat += sdif)
 583   {
 584    rect.top = rect.bottom - ydif;
 585    r = CC_HSLtoRGB('R', hue, sat, 120);
 586    g = CC_HSLtoRGB('G', hue, sat, 120);
 587    b = CC_HSLtoRGB('B', hue, sat, 120);
 588    hbrush = CreateSolidBrush( RGB(r, g, b));
 589    FillRect(lpp->hdcMem, &rect, hbrush);
 590    DeleteObject(hbrush);
 591    rect.bottom = rect.top;
 592   }
 593   rect.left = rect.right;
 594  }
 595  ReleaseDC(hwnd, hdc);
 596  SetCursor(hcursor);
 597 }
 598
 599 /***********************************************************************
 600  *                          CC_PaintColorGraph                [internal]
 601  */
 602 static void CC_PaintColorGraph( HWND hDlg )
 603 {
 604  HWND hwnd = GetDlgItem( hDlg, 0x2c6 );
 605  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 606  HDC  hDC;
 607  RECT rect;
 608  if (IsWindowVisible(hwnd))   /* if full size */
 609  {
 610   if (!lpp->hdcMem)
 611    CC_PrepareColorGraph(hDlg);   /* should not be necessary */
 612
 613   hDC = GetDC(hwnd);
 614   GetClientRect(hwnd, &rect);
 615   if (lpp->hdcMem)
 616       BitBlt(hDC, 0, 0, rect.right, rect.bottom, lpp->hdcMem, 0, 0, SRCCOPY);
 617   else
 618       WARN("choose color: hdcMem is not defined\n");
 619   ReleaseDC(hwnd, hDC);
 620  }
 621 }
 622
 623 /***********************************************************************
 624  *                           CC_PaintLumBar                   [internal]
 625  */
 626 static void CC_PaintLumBar( HWND hDlg, int hue, int sat )
 627 {
 628  HWND hwnd = GetDlgItem(hDlg, 0x2be);
 629  RECT rect, client;
 630  int lum, ldif, ydif, r, g, b;
 631  HBRUSH hbrush;
 632  HDC hDC;
 633
 634  if (IsWindowVisible(hwnd))
 635  {
 636   hDC = GetDC(hwnd);
 637   GetClientRect(hwnd, &client);
 638   rect = client;
 639
 640   ldif = 240 / YSTEPS;
 641   ydif = client.bottom / YSTEPS+1;
 642   for (lum = 0; lum < 240 + ldif; lum += ldif)
 643   {
 644    rect.top = max(0, rect.bottom - ydif);
 645    r = CC_HSLtoRGB('R', hue, sat, lum);
 646    g = CC_HSLtoRGB('G', hue, sat, lum);
 647    b = CC_HSLtoRGB('B', hue, sat, lum);
 648    hbrush = CreateSolidBrush( RGB(r, g, b) );
 649    FillRect(hDC, &rect, hbrush);
 650    DeleteObject(hbrush);
 651    rect.bottom = rect.top;
 652   }
 653   GetClientRect(hwnd, &rect);
 654   DrawEdge(hDC, &rect, BDR_SUNKENOUTER, BF_RECT);
 655   ReleaseDC(hwnd, hDC);
 656  }
 657 }
 658
 659 /***********************************************************************
 660  *                             CC_EditSetRGB                  [internal]
 661  */
 662 void CC_EditSetRGB( HWND hDlg, COLORREF cr )
 663 {
 664  char buffer[10];
 665  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 666  int r = GetRValue(cr);
 667  int g = GetGValue(cr);
 668  int b = GetBValue(cr);
 669  if (IsWindowVisible( GetDlgItem(hDlg, 0x2c6) ))   /* if full size */
 670  {
 671    lpp->updating = TRUE;
 672    sprintf(buffer, "%d", r);
 673    SetWindowTextA( GetDlgItem(hDlg, 0x2c2), buffer);
 674    sprintf(buffer, "%d", g);
 675    SetWindowTextA( GetDlgItem(hDlg, 0x2c3), buffer);
 676    sprintf( buffer, "%d", b );
 677    SetWindowTextA( GetDlgItem(hDlg, 0x2c4),buffer);
 678    lpp->updating = FALSE;
 679  }
 680 }
 681
 682 /***********************************************************************
 683  *                             CC_EditSetHSL                  [internal]
 684  */
 685 void CC_EditSetHSL( HWND hDlg, int h, int s, int l )
 686 {
 687  char buffer[10];
 688  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 689
 690  if (IsWindowVisible( GetDlgItem(hDlg, 0x2c6) ))   /* if full size */
 691  {
 692    lpp->updating = TRUE;
 693    sprintf(buffer, "%d", h);
 694    SetWindowTextA( GetDlgItem(hDlg, 0x2bf), buffer);
 695    sprintf(buffer, "%d", s);
 696    SetWindowTextA( GetDlgItem(hDlg, 0x2c0), buffer);
 697    sprintf(buffer, "%d", l);
 698    SetWindowTextA( GetDlgItem(hDlg, 0x2c1), buffer);
 699    lpp->updating = FALSE;
 700  }
 701  CC_PaintLumBar(hDlg, h, s);
 702 }
 703
 704 /***********************************************************************
 705  *                       CC_SwitchToFullSize                  [internal]
 706  */
 707 void CC_SwitchToFullSize( HWND hDlg, COLORREF result, LPCRECT lprect )
 708 {
 709  int i;
 710  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 711
 712  EnableWindow( GetDlgItem(hDlg, 0x2cf), FALSE);
 713  CC_PrepareColorGraph(hDlg);
 714  for (i = 0x2bf; i < 0x2c5; i++)
 715    ShowWindow( GetDlgItem(hDlg, i), SW_SHOW);
 716  for (i = 0x2d3; i < 0x2d9; i++)
 717    ShowWindow( GetDlgItem(hDlg, i), SW_SHOW);
 718  ShowWindow( GetDlgItem(hDlg, 0x2c9), SW_SHOW);
 719  ShowWindow( GetDlgItem(hDlg, 0x2c8), SW_SHOW);
 720  ShowWindow( GetDlgItem(hDlg, 1090), SW_SHOW);
 721
 722  if (lprect)
 723   SetWindowPos(hDlg, 0, 0, 0, lprect->right-lprect->left,
 724    lprect->bottom-lprect->top, SWP_NOMOVE|SWP_NOZORDER);
 725
 726  ShowWindow( GetDlgItem(hDlg, 0x2be), SW_SHOW);
 727  ShowWindow( GetDlgItem(hDlg, 0x2c5), SW_SHOW);
 728
 729  CC_EditSetRGB(hDlg, result);
 730  CC_EditSetHSL(hDlg, lpp->h, lpp->s, lpp->l);
 731  ShowWindow( GetDlgItem( hDlg, 0x2c6), SW_SHOW);
 732  UpdateWindow( GetDlgItem(hDlg, 0x2c6) );
 733 }
 734
 735 /***********************************************************************
 736  *                           CC_PaintPredefColorArray         [internal]
 737  *                Paints the default standard 48 colors
 738  */
 739 static void CC_PaintPredefColorArray( HWND hDlg, int rows, int cols)
 740 {
 741  HWND hwnd = GetDlgItem(hDlg, 0x2d0);
 742  RECT rect, blockrect;
 743  HDC  hdc;
 744  HBRUSH hBrush;
 745  int dx, dy, i, j, k;
 746  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 747
 748  GetClientRect(hwnd, &rect);
 749  dx = rect.right / cols;
 750  dy = rect.bottom / rows;
 751  k = rect.left;
 752
 753  hdc = GetDC(hwnd);
 754  GetClientRect(hwnd, &rect);
 755  hBrush = (HBRUSH)GetClassLongPtrW( hwnd, GCLP_HBRBACKGROUND);
 756  if (!hBrush) hBrush = GetSysColorBrush(COLOR_BTNFACE);
 757  FillRect(hdc, &rect, hBrush);
 758  for ( j = 0; j < rows; j++ )
 759  {
 760   for ( i = 0; i < cols; i++ )
 761   {
 762    hBrush = CreateSolidBrush(predefcolors[j][i]);
 763    if (hBrush)
 764    {
 765     blockrect.left = rect.left;
 766     blockrect.top = rect.top;
 767     blockrect.right = rect.left + dx - DISTANCE;
 768     blockrect.bottom = rect.top + dy - DISTANCE;
 769     FillRect(hdc, &blockrect, hBrush);
 770     DrawEdge(hdc, &blockrect, BDR_SUNKEN, BF_RECT);
 771     DeleteObject(hBrush);
 772    }
 773    rect.left += dx;
 774   }
 775   rect.top += dy;
 776   rect.left = k;
 777  }
 778  ReleaseDC(hwnd, hdc);
 779  if (lpp->hwndFocus == hwnd)
 780    CC_DrawCurrentFocusRect(lpp);
 781 }
 782 /***********************************************************************
 783  *                             CC_PaintUserColorArray         [internal]
 784  *               Paint the 16 user-selected colors
 785  */
 786 void CC_PaintUserColorArray( HWND hDlg, int rows, int cols, const COLORREF *lpcr )
 787 {
 788  HWND hwnd = GetDlgItem(hDlg, 0x2d1);
 789  RECT rect, blockrect;
 790  HDC  hdc;
 791  HBRUSH hBrush;
 792  int dx, dy, i, j, k;
 793  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 794
 795  GetClientRect(hwnd, &rect);
 796
 797  dx = rect.right / cols;
 798  dy = rect.bottom / rows;
 799  k = rect.left;
 800
 801  hdc = GetDC(hwnd);
 802  if (hdc)
 803  {
 804   hBrush = (HBRUSH)GetClassLongPtrW( hwnd, GCLP_HBRBACKGROUND);
 805   if (!hBrush) hBrush = GetSysColorBrush(COLOR_BTNFACE);
 806   FillRect( hdc, &rect, hBrush );
 807   for (j = 0; j < rows; j++)
 808   {
 809    for (i = 0; i < cols; i++)
 810    {
 811     hBrush = CreateSolidBrush(lpcr[i+j*cols]);
 812     if (hBrush)
 813     {
 814      blockrect.left = rect.left;
 815      blockrect.top = rect.top;
 816      blockrect.right = rect.left + dx - DISTANCE;
 817      blockrect.bottom = rect.top + dy - DISTANCE;
 818      FillRect(hdc, &blockrect, hBrush);
 819      DrawEdge(hdc, &blockrect, BDR_SUNKEN, BF_RECT);
 820      DeleteObject(hBrush);
 821     }
 822     rect.left += dx;
 823    }
 824    rect.top += dy;
 825    rect.left = k;
 826   }
 827   ReleaseDC(hwnd, hdc);
 828  }
 829  if (lpp->hwndFocus == hwnd)
 830    CC_DrawCurrentFocusRect(lpp);
 831 }
 832
 833
 834 /***********************************************************************
 835  *                             CC_HookCallChk                 [internal]
 836  */
 837 BOOL CC_HookCallChk( const CHOOSECOLORW *lpcc )
 838 {
 839  if (lpcc)
 840   if(lpcc->Flags & CC_ENABLEHOOK)
 841    if (lpcc->lpfnHook)
 842     return TRUE;
 843  return FALSE;
 844 }
 845
 846 /***********************************************************************
 847  *                              CC_WMInitDialog                  [internal]
 848  */
 849 static LONG CC_WMInitDialog( HWND hDlg, WPARAM wParam, LPARAM lParam )
 850 {
 851    int i, res;
 852    int r, g, b;
 853    HWND hwnd;
 854    RECT rect;
 855    POINT point;
 856    LPCCPRIV lpp;
 857
 858    TRACE("WM_INITDIALOG lParam=%08lX\n", lParam);
 859    lpp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct CCPRIVATE) );
 860
 861    lpp->lpcc = (LPCHOOSECOLORW) lParam;
 862    if (lpp->lpcc->lStructSize != sizeof(CHOOSECOLORW) )
 863    {
 864        HeapFree(GetProcessHeap(), 0, lpp);
 865        EndDialog (hDlg, 0) ;
 866        return FALSE;
 867    }
 868
 869    SetPropW( hDlg, szColourDialogProp, lpp );
 870
 871    if (!(lpp->lpcc->Flags & CC_SHOWHELP))
 872       ShowWindow( GetDlgItem(hDlg,0x40e), SW_HIDE);
 873    lpp->msetrgb = RegisterWindowMessageA(SETRGBSTRINGA);
 874
 875 #if 0
 876    cpos = MAKELONG(5,7); /* init */
 877    if (lpp->lpcc->Flags & CC_RGBINIT)
 878    {
 879      for (i = 0; i < 6; i++)
 880        for (j = 0; j < 8; j++)
 881         if (predefcolors[i][j] == lpp->lpcc->rgbResult)
 882         {
 883           cpos = MAKELONG(i,j);
 884           goto found;
 885         }
 886    }
 887    found:
 888    /* FIXME: Draw_a_focus_rect & set_init_values */
 889 #endif
 890
 891    GetWindowRect(hDlg, &lpp->fullsize);
 892    if (lpp->lpcc->Flags & CC_FULLOPEN || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
 893    {
 894       hwnd = GetDlgItem(hDlg, 0x2cf);
 895       EnableWindow(hwnd, FALSE);
 896    }
 897    if (!(lpp->lpcc->Flags & CC_FULLOPEN ) || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
 898    {
 899       rect = lpp->fullsize;
 900       res = rect.bottom - rect.top;
 901       hwnd = GetDlgItem(hDlg, 0x2c6); /* cut at left border */
 902       point.x = point.y = 0;
 903       ClientToScreen(hwnd, &point);
 904       ScreenToClient(hDlg,&point);
 905       GetClientRect(hDlg, &rect);
 906       point.x += GetSystemMetrics(SM_CXDLGFRAME);
 907       SetWindowPos(hDlg, 0, 0, 0, point.x, res, SWP_NOMOVE|SWP_NOZORDER);
 908
 909       for (i = 0x2bf; i < 0x2c5; i++)
 910          ShowWindow( GetDlgItem(hDlg, i), SW_HIDE);
 911       for (i = 0x2d3; i < 0x2d9; i++)
 912          ShowWindow( GetDlgItem(hDlg, i), SW_HIDE);
 913       ShowWindow( GetDlgItem(hDlg, 0x2c9), SW_HIDE);
 914       ShowWindow( GetDlgItem(hDlg, 0x2c8), SW_HIDE);
 915       ShowWindow( GetDlgItem(hDlg, 0x2c6), SW_HIDE);
 916       ShowWindow( GetDlgItem(hDlg, 0x2c5), SW_HIDE);
 917       ShowWindow( GetDlgItem(hDlg, 1090 ), SW_HIDE);
 918    }
 919    else
 920       CC_SwitchToFullSize(hDlg, lpp->lpcc->rgbResult, NULL);
 921    res = TRUE;
 922    for (i = 0x2bf; i < 0x2c5; i++)
 923      SendMessageA( GetDlgItem(hDlg, i), EM_LIMITTEXT, 3, 0);  /* max 3 digits:  xyz  */
 924    if (CC_HookCallChk(lpp->lpcc))
 925    {
 926           res = CallWindowProcA( (WNDPROC)lpp->lpcc->lpfnHook, hDlg, WM_INITDIALOG, wParam, lParam);
 927    }
 928
 929    /* Set the initial values of the color chooser dialog */
 930    r = GetRValue(lpp->lpcc->rgbResult);
 931    g = GetGValue(lpp->lpcc->rgbResult);
 932    b = GetBValue(lpp->lpcc->rgbResult);
 933
 934    CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
 935    lpp->h = CC_RGBtoHSL('H', r, g, b);
 936    lpp->s = CC_RGBtoHSL('S', r, g, b);
 937    lpp->l = CC_RGBtoHSL('L', r, g, b);
 938
 939    /* Doing it the long way because CC_EditSetRGB/HSL doesn't seem to work */
 940    SetDlgItemInt(hDlg, 703, lpp->h, TRUE);
 941    SetDlgItemInt(hDlg, 704, lpp->s, TRUE);
 942    SetDlgItemInt(hDlg, 705, lpp->l, TRUE);
 943    SetDlgItemInt(hDlg, 706, r, TRUE);
 944    SetDlgItemInt(hDlg, 707, g, TRUE);
 945    SetDlgItemInt(hDlg, 708, b, TRUE);
 946
 947    CC_PaintCross(hDlg, lpp->h, lpp->s);
 948    CC_PaintTriangle(hDlg, lpp->l);
 949
 950    return res;
 951 }
 952
 953
 954 /***********************************************************************
 955  *                              CC_WMCommand                  [internal]
 956  */
 957 LRESULT CC_WMCommand( HWND hDlg, WPARAM wParam, LPARAM lParam, WORD notifyCode, HWND hwndCtl )
 958 {
 959     int  r, g, b, i, xx;
 960     UINT cokmsg;
 961     HDC hdc;
 962     COLORREF *cr;
 963     LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
 964     TRACE("CC_WMCommand wParam=%lx lParam=%lx\n", wParam, lParam);
 965     switch (LOWORD(wParam))
 966     {
 967           case 0x2c2:  /* edit notify RGB */
 968           case 0x2c3:
 969           case 0x2c4:
 970                if (notifyCode == EN_UPDATE && !lpp->updating)
 971                          {
 972                            i = CC_CheckDigitsInEdit(hwndCtl, 255);
 973                            r = GetRValue(lpp->lpcc->rgbResult);
 974                            g = GetGValue(lpp->lpcc->rgbResult);
 975                            b= GetBValue(lpp->lpcc->rgbResult);
 976                            xx = 0;
 977                            switch (LOWORD(wParam))
 978                            {
 979                             case 0x2c2: if ((xx = (i != r))) r = i; break;
 980                             case 0x2c3: if ((xx = (i != g))) g = i; break;
 981                             case 0x2c4: if ((xx = (i != b))) b = i; break;
 982                            }
 983                            if (xx) /* something has changed */
 984                            {
 985                             lpp->lpcc->rgbResult = RGB(r, g, b);
 986                             CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
 987                             lpp->h = CC_RGBtoHSL('H', r, g, b);
 988                             lpp->s = CC_RGBtoHSL('S', r, g, b);
 989                             lpp->l = CC_RGBtoHSL('L', r, g, b);
 990                             CC_EditSetHSL(hDlg, lpp->h, lpp->s, lpp->l);
 991                             CC_PaintCross(hDlg, lpp->h, lpp->s);
 992                             CC_PaintTriangle(hDlg, lpp->l);
 993                            }
 994                          }
 995                  break;
 996
 997           case 0x2bf:  /* edit notify HSL */
 998           case 0x2c0:
 999           case 0x2c1:
1000                if (notifyCode == EN_UPDATE && !lpp->updating)
1001                          {
1002                            i = CC_CheckDigitsInEdit(hwndCtl , LOWORD(wParam) == 0x2bf ? 239:240);
1003                            xx = 0;
1004                            switch (LOWORD(wParam))
1005                            {
1006                             case 0x2bf: if ((xx = ( i != lpp->h))) lpp->h = i; break;
1007                             case 0x2c0: if ((xx = ( i != lpp->s))) lpp->s = i; break;
1008                             case 0x2c1: if ((xx = ( i != lpp->l))) lpp->l = i; break;
1009                            }
1010                            if (xx) /* something has changed */
1011                            {
1012                             r = CC_HSLtoRGB('R', lpp->h, lpp->s, lpp->l);
1013                             g = CC_HSLtoRGB('G', lpp->h, lpp->s, lpp->l);
1014                             b = CC_HSLtoRGB('B', lpp->h, lpp->s, lpp->l);
1015                             lpp->lpcc->rgbResult = RGB(r, g, b);
1016                             CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
1017                             CC_EditSetRGB(hDlg, lpp->lpcc->rgbResult);
1018                             CC_PaintCross(hDlg, lpp->h, lpp->s);
1019                             CC_PaintTriangle(hDlg, lpp->l);
1020                            }
1021                          }
1022                break;
1023
1024           case 0x2cf:
1025                CC_SwitchToFullSize(hDlg, lpp->lpcc->rgbResult, &lpp->fullsize);
1026                SetFocus( GetDlgItem(hDlg, 0x2bf));
1027                break;
1028
1029           case 0x2c8:    /* add colors ... column by column */
1030                cr = lpp->lpcc->lpCustColors;
1031                cr[(lpp->nextuserdef % 2) * 8 + lpp->nextuserdef / 2] = lpp->lpcc->rgbResult;
1032                if (++lpp->nextuserdef == 16)
1033                    lpp->nextuserdef = 0;
1034                CC_PaintUserColorArray(hDlg, 2, 8, lpp->lpcc->lpCustColors);
1035                break;
1036
1037           case 0x2c9:              /* resulting color */
1038                hdc = GetDC(hDlg);
1039                lpp->lpcc->rgbResult = GetNearestColor(hdc, lpp->lpcc->rgbResult);
1040                ReleaseDC(hDlg, hdc);
1041                CC_EditSetRGB(hDlg, lpp->lpcc->rgbResult);
1042                CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
1043                r = GetRValue(lpp->lpcc->rgbResult);
1044                g = GetGValue(lpp->lpcc->rgbResult);
1045                b = GetBValue(lpp->lpcc->rgbResult);
1046                lpp->h = CC_RGBtoHSL('H', r, g, b);
1047                lpp->s = CC_RGBtoHSL('S', r, g, b);
1048                lpp->l = CC_RGBtoHSL('L', r, g, b);
1049                CC_EditSetHSL(hDlg, lpp->h, lpp->s, lpp->l);
1050                CC_PaintCross(hDlg, lpp->h, lpp->s);
1051                CC_PaintTriangle(hDlg, lpp->l);
1052                break;
1053
1054           case 0x40e:           /* Help! */ /* The Beatles, 1965  ;-) */
1055                i = RegisterWindowMessageA(HELPMSGSTRINGA);
1056                    if (lpp->lpcc->hwndOwner)
1057                        SendMessageA(lpp->lpcc->hwndOwner, i, 0, (LPARAM)lpp->lpcc);
1058                    if ( CC_HookCallChk(lpp->lpcc))
1059                        CallWindowProcA( (WNDPROC) lpp->lpcc->lpfnHook, hDlg,
1060                           WM_COMMAND, psh15, (LPARAM)lpp->lpcc);
1061                break;
1062
1063           case IDOK :
1064                 cokmsg = RegisterWindowMessageA(COLOROKSTRINGA);
1065                     if (lpp->lpcc->hwndOwner)
1066                         if (SendMessageA(lpp->lpcc->hwndOwner, cokmsg, 0, (LPARAM)lpp->lpcc))
1067                         break;    /* do NOT close */
1068                 EndDialog(hDlg, 1) ;
1069                 return TRUE ;
1070
1071           case IDCANCEL :
1072                 EndDialog(hDlg, 0) ;
1073                 return TRUE ;
1074
1075        }
1076        return FALSE;
1077 }
1078
1079 /***********************************************************************
1080  *                              CC_WMPaint                    [internal]
1081  */
1082 LRESULT CC_WMPaint( HWND hDlg, WPARAM wParam, LPARAM lParam )
1083 {
1084     PAINTSTRUCT ps;
1085     LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
1086
1087     BeginPaint(hDlg, &ps);
1088     /* we have to paint dialog children except text and buttons */
1089     CC_PaintPredefColorArray(hDlg, 6, 8);
1090     CC_PaintUserColorArray(hDlg, 2, 8, lpp->lpcc->lpCustColors);
1091     CC_PaintLumBar(hDlg, lpp->h, lpp->s);
1092     CC_PaintTriangle(hDlg, lpp->l);
1093     CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
1094     CC_PaintColorGraph(hDlg);
1095     CC_PaintCross(hDlg, lpp->h, lpp->s);
1096     EndPaint(hDlg, &ps);
1097
1098     return TRUE;
1099 }
1100
1101 /***********************************************************************
1102  *                              CC_WMLButtonUp              [internal]
1103  */
1104 LRESULT CC_WMLButtonUp( HWND hDlg, WPARAM wParam, LPARAM lParam )
1105 {
1106    LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
1107    if (lpp->capturedGraph)
1108    {
1109        lpp->capturedGraph = 0;
1110        ReleaseCapture();
1111        CC_PaintCross(hDlg, lpp->h, lpp->s);
1112        return 1;
1113    }
1114    return 0;
1115 }
1116
1117 /***********************************************************************
1118  *                              CC_WMMouseMove              [internal]
1119  */
1120 LRESULT CC_WMMouseMove( HWND hDlg, LPARAM lParam )
1121 {
1122    LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
1123    int r, g, b;
1124
1125    if (lpp->capturedGraph)
1126    {
1127       int *ptrh = NULL, *ptrs = &lpp->l;
1128       if (lpp->capturedGraph == 0x2c6)
1129       {
1130           ptrh = &lpp->h;
1131           ptrs = &lpp->s;
1132       }
1133       if (CC_MouseCheckColorGraph( hDlg, lpp->capturedGraph, ptrh, ptrs, lParam))
1134       {
1135           r = CC_HSLtoRGB('R', lpp->h, lpp->s, lpp->l);
1136           g = CC_HSLtoRGB('G', lpp->h, lpp->s, lpp->l);
1137           b = CC_HSLtoRGB('B', lpp->h, lpp->s, lpp->l);
1138           lpp->lpcc->rgbResult = RGB(r, g, b);
1139           CC_EditSetRGB(hDlg, lpp->lpcc->rgbResult);
1140           CC_EditSetHSL(hDlg,lpp->h, lpp->s, lpp->l);
1141           CC_PaintCross(hDlg, lpp->h, lpp->s);
1142           CC_PaintTriangle(hDlg, lpp->l);
1143           CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
1144       }
1145       else
1146       {
1147           ReleaseCapture();
1148           lpp->capturedGraph = 0;
1149       }
1150       return 1;
1151    }
1152    return 0;
1153 }
1154
1155 /***********************************************************************
1156  *                              CC_WMLButtonDown              [internal]
1157  */
1158 LRESULT CC_WMLButtonDown( HWND hDlg, WPARAM wParam, LPARAM lParam )
1159 {
1160    LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
1161    int r, g, b, i;
1162    i = 0;
1163
1164    if (CC_MouseCheckPredefColorArray(lpp, hDlg, 0x2d0, 6, 8, lParam))
1165       i = 1;
1166    else
1167       if (CC_MouseCheckUserColorArray(lpp, hDlg, 0x2d1, 2, 8, lParam))
1168          i = 1;
1169       else
1170          if (CC_MouseCheckColorGraph(hDlg, 0x2c6, &lpp->h, &lpp->s, lParam))
1171          {
1172             i = 2;
1173             lpp->capturedGraph = 0x2c6;
1174          }
1175          else
1176             if (CC_MouseCheckColorGraph(hDlg, 0x2be, NULL, &lpp->l, lParam))
1177             {
1178                i = 2;
1179                lpp->capturedGraph = 0x2be;
1180             }
1181    if ( i == 2 )
1182    {
1183       SetCapture(hDlg);
1184       r = CC_HSLtoRGB('R', lpp->h, lpp->s, lpp->l);
1185       g = CC_HSLtoRGB('G', lpp->h, lpp->s, lpp->l);
1186       b = CC_HSLtoRGB('B', lpp->h, lpp->s, lpp->l);
1187       lpp->lpcc->rgbResult = RGB(r, g, b);
1188    }
1189    if ( i == 1 )
1190    {
1191       r = GetRValue(lpp->lpcc->rgbResult);
1192       g = GetGValue(lpp->lpcc->rgbResult);
1193       b = GetBValue(lpp->lpcc->rgbResult);
1194       lpp->h = CC_RGBtoHSL('H', r, g, b);
1195       lpp->s = CC_RGBtoHSL('S', r, g, b);
1196       lpp->l = CC_RGBtoHSL('L', r, g, b);
1197    }
1198    if (i)
1199    {
1200       CC_EditSetRGB(hDlg, lpp->lpcc->rgbResult);
1201       CC_EditSetHSL(hDlg,lpp->h, lpp->s, lpp->l);
1202       CC_PaintCross(hDlg, lpp->h, lpp->s);
1203       CC_PaintTriangle(hDlg, lpp->l);
1204       CC_PaintSelectedColor(hDlg, lpp->lpcc->rgbResult);
1205       return TRUE;
1206    }
1207    return FALSE;
1208 }
1209
1210 /***********************************************************************
1211  *           ColorDlgProc32 [internal]
1212  *
1213  */
1214 static INT_PTR CALLBACK ColorDlgProc( HWND hDlg, UINT message,
1215                                    WPARAM wParam, LPARAM lParam )
1216 {
1217
1218  int res;
1219  LPCCPRIV lpp = (LPCCPRIV) GetPropW( hDlg, szColourDialogProp );
1220  if (message != WM_INITDIALOG)
1221  {
1222   if (!lpp)
1223      return FALSE;
1224   res = 0;
1225   if (CC_HookCallChk(lpp->lpcc))
1226      res = CallWindowProcA( (WNDPROC)lpp->lpcc->lpfnHook, hDlg, message, wParam, lParam);
1227   if ( res )
1228      return res;
1229  }
1230
1231  /* FIXME: SetRGB message
1232  if (message && message == msetrgb)
1233     return HandleSetRGB(hDlg, lParam);
1234  */
1235
1236  switch (message)
1237         {
1238           case WM_INITDIALOG:
1239                         return CC_WMInitDialog(hDlg, wParam, lParam);
1240           case WM_NCDESTROY:
1241                         DeleteDC(lpp->hdcMem);
1242                         DeleteObject(lpp->hbmMem);
1243                         HeapFree(GetProcessHeap(), 0, lpp);
1244                         RemovePropW( hDlg, szColourDialogProp );
1245                         break;
1246           case WM_COMMAND:
1247                         if (CC_WMCommand( hDlg, wParam, lParam, HIWORD(wParam), (HWND) lParam))
1248                            return TRUE;
1249                         break;
1250           case WM_PAINT:
1251                         if ( CC_WMPaint(hDlg, wParam, lParam))
1252                            return TRUE;
1253                         break;
1254           case WM_LBUTTONDBLCLK:
1255                         if (CC_MouseCheckResultWindow(hDlg, lParam))
1256                           return TRUE;
1257                         break;
1258           case WM_MOUSEMOVE:
1259                         if (CC_WMMouseMove(hDlg, lParam))
1260                           return TRUE;
1261                         break;
1262           case WM_LBUTTONUP:  /* FIXME: ClipCursor off (if in color graph)*/
1263                         if (CC_WMLButtonUp(hDlg, wParam, lParam))
1264                            return TRUE;
1265                         break;
1266           case WM_LBUTTONDOWN:/* FIXME: ClipCursor on  (if in color graph)*/
1267                         if (CC_WMLButtonDown(hDlg, wParam, lParam))
1268                            return TRUE;
1269                         break;
1270         }
1271      return FALSE ;
1272 }
1273
1274 /***********************************************************************
1275  *            ChooseColorW  (COMDLG32.@)
1276  *
1277  * Create a color dialog box.
1278  *
1279  * PARAMS
1280  *  lpChCol [I/O] in:  information to initialize the dialog box.
1281  *                out: User's color selection
1282  *
1283  * RETURNS
1284  *  TRUE:  Ok button clicked.
1285  *  FALSE: Cancel button clicked, or error.
1286  */
1287 BOOL WINAPI ChooseColorW( LPCHOOSECOLORW lpChCol )
1288 {
1289     HANDLE hDlgTmpl = 0;
1290     BOOL bRet = FALSE;
1291     LPCVOID template;
1292
1293     TRACE("ChooseColor\n");
1294     if (!lpChCol) return FALSE;
1295
1296     if (lpChCol->Flags & CC_ENABLETEMPLATEHANDLE)
1297     {
1298         if (!(template = LockResource(lpChCol->hInstance)))
1299         {
1300             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
1301             return FALSE;
1302         }
1303     }
1304     else if (lpChCol->Flags & CC_ENABLETEMPLATE)
1305     {
1306         HRSRC hResInfo;
1307         if (!(hResInfo = FindResourceW((HINSTANCE)lpChCol->hInstance,
1308                                         lpChCol->lpTemplateName,
1309                                         (LPWSTR)RT_DIALOG)))
1310         {
1311             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
1312             return FALSE;
1313         }
1314         if (!(hDlgTmpl = LoadResource((HINSTANCE)lpChCol->hInstance, hResInfo)) ||
1315             !(template = LockResource(hDlgTmpl)))
1316         {
1317             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
1318             return FALSE;
1319         }
1320     }
1321     else
1322     {
1323         HRSRC hResInfo;
1324         HGLOBAL hDlgTmpl;
1325         static const WCHAR wszCHOOSE_COLOR[] = {'C','H','O','O','S','E','_','C','O','L','O','R',0};
1326         if (!(hResInfo = FindResourceW(COMDLG32_hInstance, wszCHOOSE_COLOR, (LPWSTR)RT_DIALOG)))
1327         {
1328             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
1329             return FALSE;
1330         }
1331         if (!(hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo )) ||
1332             !(template = LockResource(hDlgTmpl)))
1333         {
1334             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
1335             return FALSE;
1336         }
1337     }
1338
1339     bRet = DialogBoxIndirectParamW(COMDLG32_hInstance, template, lpChCol->hwndOwner,
1340                      ColorDlgProc, (LPARAM)lpChCol);
1341     return bRet;
1342 }
1343
1344 /***********************************************************************
1345  *            ChooseColorA  (COMDLG32.@)
1346  *
1347  * See ChooseColorW.
1348  */
1349 BOOL WINAPI ChooseColorA( LPCHOOSECOLORA lpChCol )
1350
1351 {
1352   LPWSTR template_name = NULL;
1353   BOOL ret;
1354
1355   LPCHOOSECOLORW lpcc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CHOOSECOLORW));
1356   lpcc->lStructSize = sizeof(*lpcc);
1357   lpcc->hwndOwner = lpChCol->hwndOwner;
1358   lpcc->hInstance = lpChCol->hInstance;
1359   lpcc->rgbResult = lpChCol->rgbResult;
1360   lpcc->lpCustColors = lpChCol->lpCustColors;
1361   lpcc->Flags = lpChCol->Flags;
1362   lpcc->lCustData = lpChCol->lCustData;
1363   lpcc->lpfnHook = lpChCol->lpfnHook;
1364   if ((lpcc->Flags & CC_ENABLETEMPLATE) && (lpChCol->lpTemplateName)) {
1365       if (HIWORD(lpChCol->lpTemplateName)) {
1366           INT len = MultiByteToWideChar( CP_ACP, 0, lpChCol->lpTemplateName, -1, NULL, 0);
1367           template_name = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
1368           MultiByteToWideChar( CP_ACP, 0, lpChCol->lpTemplateName, -1, template_name, len );
1369           lpcc->lpTemplateName = template_name;
1370       } else {
1371           lpcc->lpTemplateName = (LPCWSTR)lpChCol->lpTemplateName;
1372       }
1373   }
1374
1375   ret = ChooseColorW(lpcc);
1376
1377   if (ret)
1378       lpChCol->rgbResult = lpcc->rgbResult;
1379   HeapFree(GetProcessHeap(), 0, template_name);
1380   HeapFree(GetProcessHeap(), 0, lpcc);
1381   return ret;
1382 }