git.oblomov.eu Git - wine/blob - misc/commdlg.c

   1 /*
   2  * COMMDLG functions
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Albrecht Kleine
   6  */
   7
   8 #include <ctype.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include "win.h"
  12 #include "heap.h"
  13 #include "message.h"
  14 #include "commdlg.h"
  15 #include "dialog.h"
  16 #include "dlgs.h"
  17 #include "module.h"
  18 #include "resource.h"
  19 #include "drive.h"
  20 #include "debug.h"
  21 #include "font.h"
  22 #include "winproc.h"
  23
  24 static  DWORD           CommDlgLastError = 0;
  25
  26 static HBITMAP16 hFolder = 0;
  27 static HBITMAP16 hFolder2 = 0;
  28 static HBITMAP16 hFloppy = 0;
  29 static HBITMAP16 hHDisk = 0;
  30 static HBITMAP16 hCDRom = 0;
  31 static HBITMAP16 hBitmapTT = 0;
  32 static const char defaultfilter[]=" \0\0";
  33
  34 /***********************************************************************
  35  *                              FileDlg_Init                    [internal]
  36  */
  37 static BOOL32 FileDlg_Init(void)
  38 {
  39     static BOOL32 initialized = 0;
  40
  41     if (!initialized) {
  42         if (!hFolder) hFolder = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_FOLDER));
  43         if (!hFolder2) hFolder2 = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_FOLDER2));
  44         if (!hFloppy) hFloppy = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_FLOPPY));
  45         if (!hHDisk) hHDisk = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_HDISK));
  46         if (!hCDRom) hCDRom = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_CDROM));
  47         if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
  48             hHDisk == 0 || hCDRom == 0)
  49         {
  50             WARN(commdlg, "Error loading bitmaps !\nprin");
  51             return FALSE;
  52         }
  53         initialized = TRUE;
  54     }
  55     return TRUE;
  56 }
  57
  58 /***********************************************************************
  59  *           GetOpenFileName   (COMMDLG.1)
  60  */
  61 BOOL16 WINAPI GetOpenFileName16( SEGPTR ofn )
  62 {
  63     HINSTANCE32 hInst;
  64     HANDLE32 hDlgTmpl = 0, hResInfo;
  65     BOOL32 bRet = FALSE, win32Format = FALSE;
  66     HWND32 hwndDialog;
  67     LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(ofn);
  68     LPCVOID template;
  69     char defaultopen[]="Open File";
  70     char *str=0,*str1=0;
  71
  72     if (!lpofn || !FileDlg_Init()) return FALSE;
  73
  74     if (lpofn->Flags & OFN_WINE32) {
  75             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
  76             {
  77                 if (!(template = LockResource32( MapHModuleSL(lpofn->hInstance ))))
  78                 {
  79                     CommDlgLastError = CDERR_LOADRESFAILURE;
  80                     return FALSE;
  81                 }
  82             }
  83             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
  84             {
  85                 if (!(hResInfo = FindResource32A(MapHModuleSL(lpofn->hInstance),
  86                                                 PTR_SEG_TO_LIN(lpofn->lpTemplateName), RT_DIALOG32A)))
  87                 {
  88                     CommDlgLastError = CDERR_FINDRESFAILURE;
  89                     return FALSE;
  90                 }
  91                 if (!(hDlgTmpl = LoadResource32( MapHModuleSL(lpofn->hInstance),
  92                                                  hResInfo )) ||
  93                     !(template = LockResource32( hDlgTmpl )))
  94                 {
  95                     CommDlgLastError = CDERR_LOADRESFAILURE;
  96                     return FALSE;
  97                 }
  98             } else {
  99                 template = SYSRES_GetResPtr( SYSRES_DIALOG_OPEN_FILE );
 100             }
 101             win32Format = TRUE;
 102     } else {
 103             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 104             {
 105                 if (!(template = LockResource16( lpofn->hInstance )))
 106                 {
 107                     CommDlgLastError = CDERR_LOADRESFAILURE;
 108                     return FALSE;
 109                 }
 110             }
 111             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 112             {
 113                 if (!(hResInfo = FindResource16(lpofn->hInstance,
 114                                                 lpofn->lpTemplateName,
 115                                                 RT_DIALOG16)))
 116                 {
 117                     CommDlgLastError = CDERR_FINDRESFAILURE;
 118                     return FALSE;
 119                 }
 120                 if (!(hDlgTmpl = LoadResource16( lpofn->hInstance, hResInfo )) ||
 121                     !(template = LockResource16( hDlgTmpl )))
 122                 {
 123                     CommDlgLastError = CDERR_LOADRESFAILURE;
 124                     return FALSE;
 125                 }
 126             } else {
 127                 template = SYSRES_GetResPtr( SYSRES_DIALOG_OPEN_FILE );
 128                 win32Format = TRUE;
 129             }
 130     }
 131
 132     hInst = WIN_GetWindowInstance( lpofn->hwndOwner );
 133
 134     if (!(lpofn->lpstrFilter))
 135       {
 136        str = SEGPTR_ALLOC(sizeof(defaultfilter));
 137        TRACE(commdlg,"Alloc %p default for Filetype in GetOpenFileName\n",str);
 138        memcpy(str,defaultfilter,sizeof(defaultfilter));
 139        lpofn->lpstrFilter=SEGPTR_GET(str);
 140       }
 141
 142     if (!(lpofn->lpstrTitle))
 143       {
 144        str1 = SEGPTR_ALLOC(strlen(defaultopen)+1);
 145        TRACE(commdlg,"Alloc %p default for Title in GetOpenFileName\n",str1);
 146        strcpy(str1,defaultopen);
 147        lpofn->lpstrTitle=SEGPTR_GET(str1);
 148       }
 149
 150     /* FIXME: doesn't handle win32 format correctly yet */
 151     hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
 152                                         lpofn->hwndOwner,
 153                                         (DLGPROC16)MODULE_GetWndProcEntry16("FileOpenDlgProc"),
 154                                         ofn, WIN_PROC_16 );
 155     if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpofn->hwndOwner );
 156
 157     if (str1)
 158       {
 159        TRACE(commdlg,"Freeing %p default for Title in GetOpenFileName\n",str1);
 160         SEGPTR_FREE(str1);
 161        lpofn->lpstrTitle=0;
 162       }
 163
 164     if (str)
 165       {
 166        TRACE(commdlg,"Freeing %p default for Filetype in GetOpenFileName\n",str);
 167         SEGPTR_FREE(str);
 168        lpofn->lpstrFilter=0;
 169       }
 170
 171     if (hDlgTmpl) {
 172             if (lpofn->Flags & OFN_WINE32)
 173                     FreeResource32( hDlgTmpl );
 174             else
 175                     FreeResource16( hDlgTmpl );
 176     }
 177
 178     TRACE(commdlg,"return lpstrFile='%s' !\n",
 179            (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile));
 180     return bRet;
 181 }
 182
 183
 184 /***********************************************************************
 185  *           GetSaveFileName   (COMMDLG.2)
 186  */
 187 BOOL16 WINAPI GetSaveFileName16( SEGPTR ofn)
 188 {
 189     HINSTANCE32 hInst;
 190     HANDLE32 hDlgTmpl = 0;
 191     BOOL32 bRet = FALSE, win32Format = FALSE;
 192     LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(ofn);
 193     LPCVOID template;
 194     HWND32 hwndDialog;
 195     char defaultsave[]="Save as";
 196     char *str =0,*str1=0;
 197
 198     if (!lpofn || !FileDlg_Init()) return FALSE;
 199
 200     if (lpofn->Flags & OFN_WINE32) {
 201             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 202             {
 203                 if (!(template = LockResource32( MapHModuleSL(lpofn->hInstance ))))
 204                 {
 205                     CommDlgLastError = CDERR_LOADRESFAILURE;
 206                     return FALSE;
 207                 }
 208             }
 209             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 210             {
 211                 HANDLE32 hResInfo;
 212                 if (!(hResInfo = FindResource32A(MapHModuleSL(lpofn->hInstance),
 213                                                  PTR_SEG_TO_LIN(lpofn->lpTemplateName),
 214                                                  RT_DIALOG32A)))
 215                 {
 216                     CommDlgLastError = CDERR_FINDRESFAILURE;
 217                     return FALSE;
 218                 }
 219                 if (!(hDlgTmpl = LoadResource32(MapHModuleSL(lpofn->hInstance),
 220                                                 hResInfo)) ||
 221                     !(template = LockResource32(hDlgTmpl)))
 222                 {
 223                     CommDlgLastError = CDERR_LOADRESFAILURE;
 224                     return FALSE;
 225                 }
 226                 win32Format= TRUE;
 227             } else {
 228                 template = SYSRES_GetResPtr( SYSRES_DIALOG_SAVE_FILE );
 229                 win32Format = TRUE;
 230             }
 231     } else {
 232             if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
 233             {
 234                 if (!(template = LockResource16( lpofn->hInstance )))
 235                 {
 236                     CommDlgLastError = CDERR_LOADRESFAILURE;
 237                     return FALSE;
 238                 }
 239             }
 240             else if (lpofn->Flags & OFN_ENABLETEMPLATE)
 241             {
 242                 HANDLE16 hResInfo;
 243                 if (!(hResInfo = FindResource16(lpofn->hInstance,
 244                                                 lpofn->lpTemplateName,
 245                                                 RT_DIALOG16)))
 246                 {
 247                     CommDlgLastError = CDERR_FINDRESFAILURE;
 248                     return FALSE;
 249                 }
 250                 if (!(hDlgTmpl = LoadResource16( lpofn->hInstance, hResInfo )) ||
 251                     !(template = LockResource16( hDlgTmpl )))
 252                 {
 253                     CommDlgLastError = CDERR_LOADRESFAILURE;
 254                     return FALSE;
 255                 }
 256         } else {
 257                 template = SYSRES_GetResPtr( SYSRES_DIALOG_SAVE_FILE );
 258                 win32Format = TRUE;
 259         }
 260     }
 261
 262     hInst = WIN_GetWindowInstance( lpofn->hwndOwner );
 263
 264     if (!(lpofn->lpstrFilter))
 265       {
 266        str = SEGPTR_ALLOC(sizeof(defaultfilter));
 267        TRACE(commdlg,"Alloc default for Filetype in GetSaveFileName\n");
 268        memcpy(str,defaultfilter,sizeof(defaultfilter));
 269        lpofn->lpstrFilter=SEGPTR_GET(str);
 270       }
 271
 272     if (!(lpofn->lpstrTitle))
 273       {
 274        str1 = SEGPTR_ALLOC(sizeof(defaultsave)+1);
 275        TRACE(commdlg,"Alloc default for Title in GetSaveFileName\n");
 276        strcpy(str1,defaultsave);
 277        lpofn->lpstrTitle=SEGPTR_GET(str1);
 278       }
 279
 280     hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
 281                                         lpofn->hwndOwner,
 282                                         (DLGPROC16)MODULE_GetWndProcEntry16("FileSaveDlgProc"),
 283                                         ofn, WIN_PROC_16 );
 284     if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpofn->hwndOwner );
 285
 286     if (str1)
 287       {
 288        TRACE(commdlg,"Freeing %p default for Title in GetSaveFileName\n",str1);
 289         SEGPTR_FREE(str1);
 290        lpofn->lpstrTitle=0;
 291       }
 292
 293     if (str)
 294       {
 295        TRACE(commdlg,"Freeing %p default for Filetype in GetSaveFileName\n",str);
 296         SEGPTR_FREE(str);
 297        lpofn->lpstrFilter=0;
 298       }
 299
 300     if (hDlgTmpl) {
 301             if (lpofn->Flags & OFN_WINE32)
 302                     FreeResource32( hDlgTmpl );
 303             else
 304                     FreeResource16( hDlgTmpl );
 305     }
 306
 307     TRACE(commdlg, "return lpstrFile='%s' !\n",
 308             (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile));
 309     return bRet;
 310 }
 311
 312 /***********************************************************************
 313  *                              FILEDLG_StripEditControl        [internal]
 314  * Strip pathnames off the contents of the edit control.
 315  */
 316 static void FILEDLG_StripEditControl(HWND16 hwnd)
 317 {
 318     char temp[512], *cp;
 319
 320     GetDlgItemText32A( hwnd, edt1, temp, sizeof(temp) );
 321     cp = strrchr(temp, '\\');
 322     if (cp != NULL) {
 323         strcpy(temp, cp+1);
 324     }
 325     cp = strrchr(temp, ':');
 326     if (cp != NULL) {
 327         strcpy(temp, cp+1);
 328     }
 329     /* FIXME: shouldn't we do something with the result here? ;-) */
 330 }
 331
 332 /***********************************************************************
 333  *                              FILEDLG_ScanDir                 [internal]
 334  */
 335 static BOOL32 FILEDLG_ScanDir(HWND16 hWnd, LPSTR newPath)
 336 {
 337     char                buffer[512];
 338          char*                  str = buffer;
 339     int                         drive;
 340     HWND32              hlb;
 341
 342     lstrcpyn32A(buffer, newPath, sizeof(buffer));
 343
 344     if (str[0] && (str[1] == ':')) {
 345         drive = toupper(str[0]) - 'A';
 346         str += 2;
 347         if (!DRIVE_SetCurrentDrive(drive))
 348                           return FALSE;
 349     } else {
 350                  drive = DRIVE_GetCurrentDrive();
 351          }
 352
 353     if (str[0] && !DRIVE_Chdir(drive, str)) {
 354                  return FALSE;
 355     }
 356
 357     GetDlgItemText32A(hWnd, edt1, buffer, sizeof(buffer));
 358     if ((hlb = GetDlgItem32(hWnd, lst1)) != 0) {
 359                  char*  scptr; /* ptr on semi-colon */
 360                  char*  filter = buffer;
 361
 362                  TRACE(commdlg, "Using filter %s\n", filter);
 363                  SendMessage32A(hlb, LB_RESETCONTENT32, 0, 0);
 364                  while (filter) {
 365                          scptr = strchr(filter, ';');
 366                          if (scptr)     *scptr = 0;
 367                          TRACE(commdlg, "Using file spec %s\n", filter);
 368                          if (SendMessage32A(hlb, LB_DIR32, 0, (LPARAM)filter) == LB_ERR)
 369                                  return FALSE;
 370                          if (scptr) *scptr = ';';
 371                          filter = (scptr) ? (scptr + 1) : 0;
 372                  }
 373          }
 374
 375     strcpy(buffer, "*.*");
 376     return DlgDirList32A(hWnd, buffer, lst2, stc1, 0x8010);
 377 }
 378
 379 /***********************************************************************
 380  *                              FILEDLG_GetFileType             [internal]
 381  */
 382
 383 static LPSTR FILEDLG_GetFileType(LPSTR cfptr, LPSTR fptr, WORD index)
 384 {
 385   int n, i;
 386   i = 0;
 387   if (cfptr)
 388     for ( ;(n = strlen(cfptr)) != 0; i++)
 389       {
 390         cfptr += n + 1;
 391         if (i == index)
 392           return cfptr;
 393         cfptr += strlen(cfptr) + 1;
 394       }
 395   if (fptr)
 396     for ( ;(n = strlen(fptr)) != 0; i++)
 397       {
 398         fptr += n + 1;
 399         if (i == index)
 400           return fptr;
 401         fptr += strlen(fptr) + 1;
 402     }
 403   return "*.*"; /* FIXME */
 404 }
 405
 406 /***********************************************************************
 407  *                              FILEDLG_WMDrawItem              [internal]
 408  */
 409 static LONG FILEDLG_WMDrawItem(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam,int savedlg)
 410 {
 411     LPDRAWITEMSTRUCT16 lpdis = (LPDRAWITEMSTRUCT16)PTR_SEG_TO_LIN(lParam);
 412     char *str;
 413     HBRUSH32 hBrush;
 414     HBITMAP16 hBitmap, hPrevBitmap;
 415     BITMAP16 bm;
 416     HDC32 hMemDC;
 417
 418     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
 419     {
 420         if (!(str = SEGPTR_ALLOC(512))) return FALSE;
 421         hBrush = SelectObject32(lpdis->hDC, GetStockObject32(LTGRAY_BRUSH));
 422         SelectObject32(lpdis->hDC, hBrush);
 423         FillRect16(lpdis->hDC, &lpdis->rcItem, hBrush);
 424         SendMessage16(lpdis->hwndItem, LB_GETTEXT16, lpdis->itemID,
 425                       (LPARAM)SEGPTR_GET(str));
 426
 427         if (savedlg)       /* use _gray_ text in FileSaveDlg */
 428         {
 429           if (!lpdis->itemState)
 430             SetTextColor32(lpdis->hDC,GetSysColor32(COLOR_GRAYTEXT) );
 431           else
 432             SetTextColor32(lpdis->hDC,GetSysColor32(COLOR_WINDOWTEXT) );
 433             /* inversion of gray would be bad readable */
 434         }
 435
 436         TextOut16(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
 437                   str, strlen(str));
 438         if (lpdis->itemState != 0) {
 439             InvertRect16(lpdis->hDC, &lpdis->rcItem);
 440         }
 441         SEGPTR_FREE(str);
 442         return TRUE;
 443     }
 444
 445     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
 446     {
 447         if (!(str = SEGPTR_ALLOC(512))) return FALSE;
 448         hBrush = SelectObject32(lpdis->hDC, GetStockObject32(LTGRAY_BRUSH));
 449         SelectObject32(lpdis->hDC, hBrush);
 450         FillRect16(lpdis->hDC, &lpdis->rcItem, hBrush);
 451         SendMessage16(lpdis->hwndItem, LB_GETTEXT16, lpdis->itemID,
 452                       (LPARAM)SEGPTR_GET(str));
 453
 454         hBitmap = hFolder;
 455         GetObject16( hBitmap, sizeof(bm), &bm );
 456         TextOut16(lpdis->hDC, lpdis->rcItem.left + bm.bmWidth,
 457                   lpdis->rcItem.top, str, strlen(str));
 458         hMemDC = CreateCompatibleDC32(lpdis->hDC);
 459         hPrevBitmap = SelectObject32(hMemDC, hBitmap);
 460         BitBlt32(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
 461                  bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
 462         SelectObject32(hMemDC, hPrevBitmap);
 463         DeleteDC32(hMemDC);
 464         if (lpdis->itemState != 0) InvertRect16(lpdis->hDC, &lpdis->rcItem);
 465         SEGPTR_FREE(str);
 466         return TRUE;
 467     }
 468     if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
 469     {
 470         if (!(str = SEGPTR_ALLOC(512))) return FALSE;
 471         hBrush = SelectObject32(lpdis->hDC, GetStockObject32(LTGRAY_BRUSH));
 472         SelectObject32(lpdis->hDC, hBrush);
 473         FillRect16(lpdis->hDC, &lpdis->rcItem, hBrush);
 474         SendMessage16(lpdis->hwndItem, CB_GETLBTEXT16, lpdis->itemID,
 475                       (LPARAM)SEGPTR_GET(str));
 476         switch(DRIVE_GetType( str[2] - 'a' ))
 477         {
 478         case TYPE_FLOPPY:  hBitmap = hFloppy; break;
 479         case TYPE_CDROM:   hBitmap = hCDRom; break;
 480         case TYPE_HD:
 481         case TYPE_NETWORK:
 482         default:           hBitmap = hHDisk; break;
 483         }
 484         GetObject16( hBitmap, sizeof(bm), &bm );
 485         TextOut16(lpdis->hDC, lpdis->rcItem.left + bm.bmWidth,
 486                   lpdis->rcItem.top, str, strlen(str));
 487         hMemDC = CreateCompatibleDC32(lpdis->hDC);
 488         hPrevBitmap = SelectObject32(hMemDC, hBitmap);
 489         BitBlt32( lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top,
 490                   bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY );
 491         SelectObject32(hMemDC, hPrevBitmap);
 492         DeleteDC32(hMemDC);
 493         if (lpdis->itemState != 0) InvertRect16(lpdis->hDC, &lpdis->rcItem);
 494         SEGPTR_FREE(str);
 495         return TRUE;
 496     }
 497     return FALSE;
 498 }
 499
 500 /***********************************************************************
 501  *                              FILEDLG_WMMeasureItem           [internal]
 502  */
 503 static LONG FILEDLG_WMMeasureItem(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
 504 {
 505     BITMAP16 bm;
 506     LPMEASUREITEMSTRUCT16 lpmeasure;
 507
 508     GetObject16( hFolder2, sizeof(bm), &bm );
 509     lpmeasure = (LPMEASUREITEMSTRUCT16)PTR_SEG_TO_LIN(lParam);
 510     lpmeasure->itemHeight = bm.bmHeight;
 511     return TRUE;
 512 }
 513
 514 /***********************************************************************
 515  *                              FILEDLG_HookCallChk             [internal]
 516  */
 517 static int FILEDLG_HookCallChk(LPOPENFILENAME16 lpofn)
 518 {
 519  if (lpofn)
 520   if (lpofn->Flags & OFN_ENABLEHOOK)
 521    if (lpofn->lpfnHook)
 522     return 1;
 523  return 0;
 524 }
 525
 526 /***********************************************************************
 527  *                              FILEDLG_CallWindowProc             [internal]
 528  *
 529  * Adapt the structures back for win32 calls so the callee can read lpCustData
 530  */
 531 static BOOL32 FILEDLG_CallWindowProc(LPOPENFILENAME16 lpofn,HWND32 hwnd,
 532         UINT32 wMsg,WPARAM32 wParam,LPARAM lParam
 533
 534 ) {
 535         BOOL32  needstruct;
 536
 537         needstruct = (PTR_SEG_TO_LIN(lParam) == lpofn);
 538
 539         if (!(lpofn->Flags & OFN_WINE32))
 540                 return (BOOL32)CallWindowProc16(
 541                         lpofn->lpfnHook,hwnd,(UINT16)wMsg,(WPARAM16)wParam,lParam
 542                 );
 543         /* |OFN_WINE32 */
 544         if (lpofn->Flags & OFN_UNICODE) {
 545                 if (needstruct) {
 546                     OPENFILENAME32W ofnw;
 547
 548                     /* FIXME: probably needs more converted */
 549                     ofnw.lCustData = lpofn->lCustData;
 550                     return (BOOL32)CallWindowProc32W(
 551                             (WNDPROC32)lpofn->lpfnHook,hwnd,wMsg,wParam,(LPARAM)&ofnw
 552                     );
 553                 } else
 554                     return (BOOL32)CallWindowProc32W(
 555                             (WNDPROC32)lpofn->lpfnHook,hwnd,wMsg,wParam,lParam
 556                     );
 557         }
 558         /* ! |OFN_UNICODE */
 559         if (needstruct) {
 560                 OPENFILENAME32A ofna;
 561
 562                 /* FIXME: probably needs more converted */
 563                 ofna.lCustData = lpofn->lCustData;
 564                 return (BOOL32)CallWindowProc32A(
 565                         (WNDPROC32)lpofn->lpfnHook,hwnd,wMsg,wParam,(LPARAM)&ofna
 566                 );
 567         } else
 568                 return (BOOL32)CallWindowProc32A(
 569                         (WNDPROC32)lpofn->lpfnHook,hwnd,wMsg,wParam,lParam
 570                 );
 571
 572 }
 573
 574 /***********************************************************************
 575  *                              FILEDLG_WMInitDialog            [internal]
 576  */
 577
 578 static LONG FILEDLG_WMInitDialog(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
 579 {
 580   int i, n;
 581   LPOPENFILENAME16 lpofn;
 582   char tmpstr[512];
 583   LPSTR pstr, old_pstr;
 584   SetWindowLong32A(hWnd, DWL_USER, lParam);
 585   lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(lParam);
 586   if (lpofn->lpstrTitle) SetWindowText16( hWnd, lpofn->lpstrTitle );
 587   /* read custom filter information */
 588   if (lpofn->lpstrCustomFilter)
 589     {
 590       pstr = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter);
 591       n = 0;
 592       TRACE(commdlg,"lpstrCustomFilter = %p\n", pstr);
 593       while(*pstr)
 594         {
 595           old_pstr = pstr;
 596           i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
 597                                    (LPARAM)lpofn->lpstrCustomFilter + n );
 598           n += strlen(pstr) + 1;
 599           pstr += strlen(pstr) + 1;
 600           TRACE(commdlg,"add str='%s' "
 601                           "associated to '%s'\n", old_pstr, pstr);
 602           SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
 603           n += strlen(pstr) + 1;
 604           pstr += strlen(pstr) + 1;
 605         }
 606     }
 607   /* read filter information */
 608   if (lpofn->lpstrFilter) {
 609         pstr = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFilter);
 610         n = 0;
 611         while(*pstr) {
 612           old_pstr = pstr;
 613           i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
 614                                        (LPARAM)lpofn->lpstrFilter + n );
 615           n += strlen(pstr) + 1;
 616           pstr += strlen(pstr) + 1;
 617           TRACE(commdlg,"add str='%s' "
 618                           "associated to '%s'\n", old_pstr, pstr);
 619           SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
 620           n += strlen(pstr) + 1;
 621           pstr += strlen(pstr) + 1;
 622         }
 623   }
 624   /* set default filter */
 625   if (lpofn->nFilterIndex == 0 && lpofn->lpstrCustomFilter == (SEGPTR)NULL)
 626         lpofn->nFilterIndex = 1;
 627   SendDlgItemMessage16(hWnd, cmb1, CB_SETCURSEL16, lpofn->nFilterIndex - 1, 0);
 628   strncpy(tmpstr, FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
 629              PTR_SEG_TO_LIN(lpofn->lpstrFilter), lpofn->nFilterIndex - 1),511);
 630   tmpstr[511]=0;
 631   TRACE(commdlg,"nFilterIndex = %ld, SetText of edt1 to '%s'\n",
 632                         lpofn->nFilterIndex, tmpstr);
 633   SetDlgItemText32A( hWnd, edt1, tmpstr );
 634   /* get drive list */
 635   *tmpstr = 0;
 636   DlgDirListComboBox32A(hWnd, tmpstr, cmb2, 0, 0xC000);
 637   /* read initial directory */
 638   if (PTR_SEG_TO_LIN(lpofn->lpstrInitialDir) != NULL)
 639     {
 640       strncpy(tmpstr, PTR_SEG_TO_LIN(lpofn->lpstrInitialDir), 510);
 641       tmpstr[510]=0;
 642       if (strlen(tmpstr) > 0 && tmpstr[strlen(tmpstr)-1] != '\\'
 643           && tmpstr[strlen(tmpstr)-1] != ':')
 644         strcat(tmpstr,"\\");
 645     }
 646   else
 647     *tmpstr = 0;
 648   if (!FILEDLG_ScanDir(hWnd, tmpstr)) {
 649     *tmpstr = 0;
 650     if (!FILEDLG_ScanDir(hWnd, tmpstr))
 651       WARN(commdlg, "Couldn't read initial directory %s!\n",tmpstr);
 652   }
 653   /* select current drive in combo 2, omit missing drives */
 654   for(i=0, n=-1; i<=DRIVE_GetCurrentDrive(); i++)
 655     if (DRIVE_IsValid(i))                  n++;
 656   SendDlgItemMessage16(hWnd, cmb2, CB_SETCURSEL16, n, 0);
 657   if (!(lpofn->Flags & OFN_SHOWHELP))
 658     ShowWindow32(GetDlgItem32(hWnd, pshHelp), SW_HIDE);
 659   if (lpofn->Flags & OFN_HIDEREADONLY)
 660     ShowWindow32(GetDlgItem32(hWnd, chx1), SW_HIDE);
 661   if (FILEDLG_HookCallChk(lpofn))
 662      return (BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,WM_INITDIALOG,wParam,lParam );
 663   else
 664      return TRUE;
 665 }
 666
 667 /***********************************************************************
 668  *                              FILEDLG_WMCommand               [internal]
 669  */
 670 BOOL32 in_update=FALSE;
 671
 672 static LRESULT FILEDLG_WMCommand(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
 673 {
 674   LONG lRet;
 675   LPOPENFILENAME16 lpofn;
 676   OPENFILENAME16 ofn2;
 677   char tmpstr[512], tmpstr2[512];
 678   LPSTR pstr, pstr2;
 679   UINT16 control,notification;
 680
 681   /* Notifications are packaged differently in Win32 */
 682   control = wParam;
 683   notification = HIWORD(lParam);
 684
 685   lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(GetWindowLong32A(hWnd, DWL_USER));
 686   switch (control)
 687     {
 688     case lst1: /* file list */
 689       FILEDLG_StripEditControl(hWnd);
 690       if (notification == LBN_DBLCLK)
 691         goto almost_ok;
 692       lRet = SendDlgItemMessage16(hWnd, lst1, LB_GETCURSEL16, 0, 0);
 693       if (lRet == LB_ERR) return TRUE;
 694       if ((pstr = SEGPTR_ALLOC(512)))
 695       {
 696           SendDlgItemMessage16(hWnd, lst1, LB_GETTEXT16, lRet,
 697                                (LPARAM)SEGPTR_GET(pstr));
 698           SetDlgItemText32A( hWnd, edt1, pstr );
 699           SEGPTR_FREE(pstr);
 700       }
 701       if (FILEDLG_HookCallChk(lpofn))
 702        FILEDLG_CallWindowProc(lpofn,hWnd,
 703                   RegisterWindowMessage32A( LBSELCHSTRING ),
 704                   control, MAKELONG(lRet,CD_LBSELCHANGE));
 705       /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD, CD_LBSELNOITEMS */
 706       return TRUE;
 707     case lst2: /* directory list */
 708       FILEDLG_StripEditControl(hWnd);
 709       if (notification == LBN_DBLCLK)
 710         {
 711           lRet = SendDlgItemMessage16(hWnd, lst2, LB_GETCURSEL16, 0, 0);
 712           if (lRet == LB_ERR) return TRUE;
 713           pstr = SEGPTR_ALLOC(512);
 714           SendDlgItemMessage16(hWnd, lst2, LB_GETTEXT16, lRet,
 715                              (LPARAM)SEGPTR_GET(pstr));
 716           strcpy( tmpstr, pstr );
 717           SEGPTR_FREE(pstr);
 718           if (tmpstr[0] == '[')
 719             {
 720               tmpstr[strlen(tmpstr) - 1] = 0;
 721               strcpy(tmpstr,tmpstr+1);
 722             }
 723           strcat(tmpstr, "\\");
 724           goto reset_scan;
 725         }
 726       return TRUE;
 727     case cmb1: /* file type drop list */
 728       if (notification == CBN_SELCHANGE)
 729         {
 730           *tmpstr = 0;
 731           goto reset_scan;
 732         }
 733       return TRUE;
 734     case chx1:
 735       return TRUE;
 736     case pshHelp:
 737       return TRUE;
 738     case cmb2: /* disk drop list */
 739       FILEDLG_StripEditControl(hWnd);
 740       lRet = SendDlgItemMessage16(hWnd, cmb2, CB_GETCURSEL16, 0, 0L);
 741       if (lRet == LB_ERR) return 0;
 742       pstr = SEGPTR_ALLOC(512);
 743       SendDlgItemMessage16(hWnd, cmb2, CB_GETLBTEXT16, lRet,
 744                            (LPARAM)SEGPTR_GET(pstr));
 745       sprintf(tmpstr, "%c:", pstr[2]);
 746       SEGPTR_FREE(pstr);
 747     reset_scan:
 748       lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
 749       if (lRet == LB_ERR)
 750         return TRUE;
 751       pstr = (LPSTR)SendDlgItemMessage16(hWnd, cmb1, CB_GETITEMDATA16, lRet, 0);
 752       TRACE(commdlg,"Selected filter : %s\n", pstr);
 753       SetDlgItemText32A( hWnd, edt1, pstr );
 754       FILEDLG_ScanDir(hWnd, tmpstr);
 755       in_update=TRUE;
 756     case IDOK:
 757     almost_ok:
 758       ofn2=*lpofn; /* for later restoring */
 759       GetDlgItemText32A( hWnd, edt1, tmpstr, sizeof(tmpstr) );
 760       pstr = strrchr(tmpstr, '\\');
 761       if (pstr == NULL)
 762         pstr = strrchr(tmpstr, ':');
 763       if (strchr(tmpstr,'*') != NULL || strchr(tmpstr,'?') != NULL)
 764         {
 765           /* edit control contains wildcards */
 766           if (pstr != NULL)
 767             {
 768               strncpy(tmpstr2, pstr+1, 511); tmpstr2[511]=0;
 769               *(pstr+1) = 0;
 770             }
 771           else
 772             {
 773               strcpy(tmpstr2, tmpstr);
 774               *tmpstr=0;
 775             }
 776           TRACE(commdlg,"tmpstr=%s, tmpstr2=%s\n", tmpstr, tmpstr2);
 777           SetDlgItemText32A( hWnd, edt1, tmpstr2 );
 778           FILEDLG_ScanDir(hWnd, tmpstr);
 779           return TRUE;
 780         }
 781       /* no wildcards, we might have a directory or a filename */
 782       /* try appending a wildcard and reading the directory */
 783       pstr2 = tmpstr + strlen(tmpstr);
 784       if (pstr == NULL || *(pstr+1) != 0)
 785         strcat(tmpstr, "\\");
 786       lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
 787       if (lRet == LB_ERR) return TRUE;
 788       lpofn->nFilterIndex = lRet + 1;
 789       TRACE(commdlg,"lpofn->nFilterIndex=%ld\n", lpofn->nFilterIndex);
 790       lstrcpyn32A(tmpstr2,
 791              FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
 792                                  PTR_SEG_TO_LIN(lpofn->lpstrFilter),
 793                                  lRet), sizeof(tmpstr2));
 794       SetDlgItemText32A( hWnd, edt1, tmpstr2 );
 795       if (!in_update)
 796       /* if ScanDir succeeds, we have changed the directory */
 797       if (FILEDLG_ScanDir(hWnd, tmpstr)) return TRUE;
 798       /* if not, this must be a filename */
 799       *pstr2 = 0;
 800       if (pstr != NULL)
 801         {
 802           /* strip off the pathname */
 803           *pstr = 0;
 804           SetDlgItemText32A( hWnd, edt1, pstr + 1 );
 805           lstrcpyn32A(tmpstr2, pstr+1, sizeof(tmpstr2) );
 806           /* Should we MessageBox() if this fails? */
 807           if (!FILEDLG_ScanDir(hWnd, tmpstr)) return TRUE;
 808           strcpy(tmpstr, tmpstr2);
 809         }
 810       else SetDlgItemText32A( hWnd, edt1, tmpstr );
 811 #if 0
 812       ShowWindow16(hWnd, SW_HIDE);   /* this should not be necessary ?! (%%%) */
 813 #endif
 814       {
 815         int drive = DRIVE_GetCurrentDrive();
 816         tmpstr2[0] = 'A'+ drive;
 817         tmpstr2[1] = ':';
 818         tmpstr2[2] = '\\';
 819         strncpy(tmpstr2 + 3, DRIVE_GetDosCwd(drive), 507); tmpstr2[510]=0;
 820         if (strlen(tmpstr2) > 3)
 821            strcat(tmpstr2, "\\");
 822         strncat(tmpstr2, tmpstr, 511-strlen(tmpstr2)); tmpstr2[511]=0;
 823         if (lpofn->lpstrFile)
 824           lstrcpyn32A(PTR_SEG_TO_LIN(lpofn->lpstrFile), tmpstr2,lpofn->nMaxFile);
 825       }
 826       lpofn->nFileOffset = strrchr(tmpstr2,'\\') - tmpstr2 +1;
 827       lpofn->nFileExtension = 0;
 828       while(tmpstr2[lpofn->nFileExtension] != '.' && tmpstr2[lpofn->nFileExtension] != '\0')
 829         lpofn->nFileExtension++;
 830       if (tmpstr2[lpofn->nFileExtension] == '\0')
 831         lpofn->nFileExtension = 0;
 832       else
 833         lpofn->nFileExtension++;
 834
 835       if(in_update)
 836        {
 837          if (FILEDLG_HookCallChk(lpofn))
 838            FILEDLG_CallWindowProc(lpofn,hWnd,
 839                                   RegisterWindowMessage32A( LBSELCHSTRING ),
 840                                   control, MAKELONG(lRet,CD_LBSELCHANGE));
 841
 842          in_update = FALSE;
 843          return TRUE;
 844        }
 845       if (PTR_SEG_TO_LIN(lpofn->lpstrFileTitle) != NULL)
 846         {
 847           lRet = SendDlgItemMessage16(hWnd, lst1, LB_GETCURSEL16, 0, 0);
 848           SendDlgItemMessage16(hWnd, lst1, LB_GETTEXT16, lRet,
 849                                lpofn->lpstrFileTitle );
 850         }
 851       if (FILEDLG_HookCallChk(lpofn))
 852       {
 853        lRet= (BOOL16)FILEDLG_CallWindowProc(lpofn,
 854                hWnd, RegisterWindowMessage32A( FILEOKSTRING ), 0, lParam );
 855        if (lRet)
 856        {
 857          *lpofn=ofn2; /* restore old state */
 858 #if 0
 859          ShowWindow16(hWnd, SW_SHOW);               /* only if above (%%%) SW_HIDE used */
 860 #endif
 861          break;
 862        }
 863       }
 864       EndDialog32(hWnd, TRUE);
 865       return TRUE;
 866     case IDCANCEL:
 867       EndDialog32(hWnd, FALSE);
 868       return TRUE;
 869     }
 870   return FALSE;
 871 }
 872
 873
 874 /***********************************************************************
 875  *           FileOpenDlgProc   (COMMDLG.6)
 876  */
 877 LRESULT WINAPI FileOpenDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
 878                                LPARAM lParam)
 879 {
 880  LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(GetWindowLong32A(hWnd, DWL_USER));
 881
 882  if (wMsg!=WM_INITDIALOG)
 883   if (FILEDLG_HookCallChk(lpofn))
 884   {
 885    LRESULT  lRet=(BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,wMsg,wParam,lParam);
 886    if (lRet)
 887     return lRet;         /* else continue message processing */
 888   }
 889   switch (wMsg)
 890     {
 891     case WM_INITDIALOG:
 892       return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
 893     case WM_MEASUREITEM:
 894       return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
 895     case WM_DRAWITEM:
 896       return FILEDLG_WMDrawItem(hWnd, wParam, lParam, FALSE);
 897     case WM_COMMAND:
 898       return FILEDLG_WMCommand(hWnd, wParam, lParam);
 899 #if 0
 900     case WM_CTLCOLOR:
 901       SetBkColor((HDC16)wParam, 0x00C0C0C0);
 902       switch (HIWORD(lParam))
 903         {
 904         case CTLCOLOR_BTN:
 905           SetTextColor((HDC16)wParam, 0x00000000);
 906           return hGRAYBrush;
 907         case CTLCOLOR_STATIC:
 908           SetTextColor((HDC16)wParam, 0x00000000);
 909           return hGRAYBrush;
 910         }
 911       break;
 912 #endif
 913     }
 914   return FALSE;
 915 }
 916
 917
 918 /***********************************************************************
 919  *           FileSaveDlgProc   (COMMDLG.7)
 920  */
 921 LRESULT WINAPI FileSaveDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
 922                                LPARAM lParam)
 923 {
 924  LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(GetWindowLong32A(hWnd, DWL_USER));
 925
 926  if (wMsg!=WM_INITDIALOG)
 927   if (FILEDLG_HookCallChk(lpofn))
 928   {
 929    LRESULT  lRet=(BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,wMsg,wParam,lParam);
 930    if (lRet)
 931     return lRet;         /* else continue message processing */
 932   }
 933   switch (wMsg) {
 934    case WM_INITDIALOG:
 935       return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
 936
 937    case WM_MEASUREITEM:
 938       return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
 939
 940    case WM_DRAWITEM:
 941       return FILEDLG_WMDrawItem(hWnd, wParam, lParam, TRUE);
 942
 943    case WM_COMMAND:
 944       return FILEDLG_WMCommand(hWnd, wParam, lParam);
 945   }
 946
 947   /*
 948   case WM_CTLCOLOR:
 949    SetBkColor((HDC16)wParam, 0x00C0C0C0);
 950    switch (HIWORD(lParam))
 951    {
 952     case CTLCOLOR_BTN:
 953      SetTextColor((HDC16)wParam, 0x00000000);
 954      return hGRAYBrush;
 955     case CTLCOLOR_STATIC:
 956      SetTextColor((HDC16)wParam, 0x00000000);
 957      return hGRAYBrush;
 958    }
 959    return FALSE;
 960
 961    */
 962   return FALSE;
 963 }
 964
 965
 966 /***********************************************************************
 967  *           FindText16   (COMMDLG.11)
 968  */
 969 HWND16 WINAPI FindText16( SEGPTR find )
 970 {
 971     HANDLE16 hInst;
 972     LPCVOID ptr;
 973     LPFINDREPLACE16 lpFind = (LPFINDREPLACE16)PTR_SEG_TO_LIN(find);
 974
 975     /*
 976      * FIXME : Should respond to FR_ENABLETEMPLATE and FR_ENABLEHOOK here
 977      * For now, only the standard dialog works.
 978      */
 979     if (lpFind->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE |
 980         FR_ENABLEHOOK)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
 981     ptr = SYSRES_GetResPtr( SYSRES_DIALOG_FIND_TEXT );
 982     hInst = WIN_GetWindowInstance( lpFind->hwndOwner );
 983     return DIALOG_CreateIndirect( hInst, ptr, TRUE, lpFind->hwndOwner,
 984                         (DLGPROC16)MODULE_GetWndProcEntry16("FindTextDlgProc"),
 985                                   find, WIN_PROC_16 );
 986 }
 987
 988 /***********************************************************************
 989  *           FindText32A   (COMMDLG.6)
 990  */
 991 HWND32 WINAPI FindText32A( LPFINDREPLACE32A lpFind )
 992 {
 993     HANDLE16 hInst;
 994     LPCVOID ptr;
 995
 996     /*
 997      * FIXME : Should respond to FR_ENABLETEMPLATE and FR_ENABLEHOOK here
 998      * For now, only the standard dialog works.
 999      */
1000     if (lpFind->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE |
1001         FR_ENABLEHOOK)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
1002     ptr = SYSRES_GetResPtr( SYSRES_DIALOG_FIND_TEXT );
1003     hInst = WIN_GetWindowInstance( lpFind->hwndOwner );
1004     return DIALOG_CreateIndirect( hInst, ptr, TRUE, lpFind->hwndOwner,
1005                 (DLGPROC16)FindTextDlgProc32A, (LPARAM)lpFind, WIN_PROC_32A );
1006 }
1007
1008 /***********************************************************************
1009  *           FindText32W   (COMMDLG.7)
1010  */
1011 HWND32 WINAPI FindText32W( LPFINDREPLACE32W lpFind )
1012 {
1013     HANDLE16 hInst;
1014     LPCVOID ptr;
1015
1016     /*
1017      * FIXME : Should respond to FR_ENABLETEMPLATE and FR_ENABLEHOOK here
1018      * For now, only the standard dialog works.
1019      */
1020     if (lpFind->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE |
1021         FR_ENABLEHOOK)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
1022     ptr = SYSRES_GetResPtr( SYSRES_DIALOG_FIND_TEXT );
1023     hInst = WIN_GetWindowInstance( lpFind->hwndOwner );
1024     return DIALOG_CreateIndirect( hInst, ptr, TRUE, lpFind->hwndOwner,
1025                 (DLGPROC16)FindTextDlgProc32W, (LPARAM)lpFind, WIN_PROC_32W );
1026 }
1027
1028 /***********************************************************************
1029  *           ReplaceText16   (COMMDLG.12)
1030  */
1031 HWND16 WINAPI ReplaceText16( SEGPTR find )
1032 {
1033     HANDLE16 hInst;
1034     LPCVOID ptr;
1035     LPFINDREPLACE16 lpFind = (LPFINDREPLACE16)PTR_SEG_TO_LIN(find);
1036
1037     /*
1038      * FIXME : We should do error checking on the lpFind structure here
1039      * and make CommDlgExtendedError() return the error condition.
1040      */
1041     if (lpFind->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE |
1042         FR_ENABLEHOOK)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
1043     ptr = SYSRES_GetResPtr( SYSRES_DIALOG_REPLACE_TEXT );
1044     hInst = WIN_GetWindowInstance( lpFind->hwndOwner );
1045     return DIALOG_CreateIndirect( hInst, ptr, TRUE, lpFind->hwndOwner,
1046                      (DLGPROC16)MODULE_GetWndProcEntry16("ReplaceTextDlgProc"),
1047                                   find, WIN_PROC_16 );
1048 }
1049
1050 /***********************************************************************
1051  *           ReplaceText32A   (COMDLG32.19)
1052  */
1053 HWND32 WINAPI ReplaceText32A( LPFINDREPLACE32A lpFind )
1054 {
1055     HANDLE16 hInst;
1056     LPCVOID ptr;
1057
1058     /*
1059      * FIXME : Should respond to FR_ENABLETEMPLATE and FR_ENABLEHOOK here
1060      * For now, only the standard dialog works.
1061      */
1062     if (lpFind->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE |
1063         FR_ENABLEHOOK)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
1064     ptr = SYSRES_GetResPtr( SYSRES_DIALOG_REPLACE_TEXT );
1065     hInst = WIN_GetWindowInstance( lpFind->hwndOwner );
1066     return DIALOG_CreateIndirect( hInst, ptr, TRUE, lpFind->hwndOwner,
1067                 (DLGPROC16)ReplaceTextDlgProc32A, (LPARAM)lpFind, WIN_PROC_32A );
1068 }
1069
1070 /***********************************************************************
1071  *           ReplaceText32W   (COMDLG32.20)
1072  */
1073 HWND32 WINAPI ReplaceText32W( LPFINDREPLACE32W lpFind )
1074 {
1075     HANDLE16 hInst;
1076     LPCVOID ptr;
1077
1078     /*
1079      * FIXME : We should do error checking on the lpFind structure here
1080      * and make CommDlgExtendedError() return the error condition.
1081      */
1082     if (lpFind->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE |
1083         FR_ENABLEHOOK)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
1084     ptr = SYSRES_GetResPtr( SYSRES_DIALOG_REPLACE_TEXT );
1085     hInst = WIN_GetWindowInstance( lpFind->hwndOwner );
1086     return DIALOG_CreateIndirect( hInst, ptr, TRUE, lpFind->hwndOwner,
1087                 (DLGPROC16)ReplaceTextDlgProc32W, (LPARAM)lpFind, WIN_PROC_32W );
1088 }
1089
1090
1091 /***********************************************************************
1092  *                              FINDDLG_WMInitDialog            [internal]
1093  */
1094 static LRESULT FINDDLG_WMInitDialog(HWND32 hWnd, LPARAM lParam, LPDWORD lpFlags,
1095                                     LPSTR lpstrFindWhat, BOOL32 fUnicode)
1096 {
1097     SetWindowLong32A(hWnd, DWL_USER, lParam);
1098     *lpFlags &= ~(FR_FINDNEXT | FR_REPLACE | FR_REPLACEALL | FR_DIALOGTERM);
1099     /*
1100      * FIXME : If the initial FindWhat string is empty, we should disable the
1101      * FindNext (IDOK) button.  Only after typing some text, the button should be
1102      * enabled.
1103      */
1104     if (fUnicode) SetDlgItemText32W(hWnd, edt1, (LPWSTR)lpstrFindWhat);
1105         else SetDlgItemText32A(hWnd, edt1, lpstrFindWhat);
1106     CheckRadioButton32(hWnd, rad1, rad2, (*lpFlags & FR_DOWN) ? rad2 : rad1);
1107     if (*lpFlags & (FR_HIDEUPDOWN | FR_NOUPDOWN)) {
1108         EnableWindow32(GetDlgItem32(hWnd, rad1), FALSE);
1109         EnableWindow32(GetDlgItem32(hWnd, rad2), FALSE);
1110     }
1111     if (*lpFlags & FR_HIDEUPDOWN) {
1112         ShowWindow32(GetDlgItem32(hWnd, rad1), SW_HIDE);
1113         ShowWindow32(GetDlgItem32(hWnd, rad2), SW_HIDE);
1114         ShowWindow32(GetDlgItem32(hWnd, grp1), SW_HIDE);
1115     }
1116     CheckDlgButton32(hWnd, chx1, (*lpFlags & FR_WHOLEWORD) ? 1 : 0);
1117     if (*lpFlags & (FR_HIDEWHOLEWORD | FR_NOWHOLEWORD))
1118         EnableWindow32(GetDlgItem32(hWnd, chx1), FALSE);
1119     if (*lpFlags & FR_HIDEWHOLEWORD)
1120         ShowWindow32(GetDlgItem32(hWnd, chx1), SW_HIDE);
1121     CheckDlgButton32(hWnd, chx2, (*lpFlags & FR_MATCHCASE) ? 1 : 0);
1122     if (*lpFlags & (FR_HIDEMATCHCASE | FR_NOMATCHCASE))
1123         EnableWindow32(GetDlgItem32(hWnd, chx2), FALSE);
1124     if (*lpFlags & FR_HIDEMATCHCASE)
1125         ShowWindow32(GetDlgItem32(hWnd, chx2), SW_HIDE);
1126     if (!(*lpFlags & FR_SHOWHELP)) {
1127         EnableWindow32(GetDlgItem32(hWnd, pshHelp), FALSE);
1128         ShowWindow32(GetDlgItem32(hWnd, pshHelp), SW_HIDE);
1129     }
1130     ShowWindow32(hWnd, SW_SHOWNORMAL);
1131     return TRUE;
1132 }
1133
1134
1135 /***********************************************************************
1136  *                              FINDDLG_WMCommand               [internal]
1137  */
1138 static LRESULT FINDDLG_WMCommand(HWND32 hWnd, WPARAM32 wParam,
1139                         HWND32 hwndOwner, LPDWORD lpFlags,
1140                         LPSTR lpstrFindWhat, WORD wFindWhatLen,
1141                         BOOL32 fUnicode)
1142 {
1143     int uFindReplaceMessage = RegisterWindowMessage32A( FINDMSGSTRING );
1144     int uHelpMessage = RegisterWindowMessage32A( HELPMSGSTRING );
1145
1146     switch (wParam) {
1147         case IDOK:
1148             if (fUnicode)
1149               GetDlgItemText32W(hWnd, edt1, (LPWSTR)lpstrFindWhat, wFindWhatLen/2);
1150               else GetDlgItemText32A(hWnd, edt1, lpstrFindWhat, wFindWhatLen);
1151             if (IsDlgButtonChecked32(hWnd, rad2))
1152                 *lpFlags |= FR_DOWN;
1153                 else *lpFlags &= ~FR_DOWN;
1154             if (IsDlgButtonChecked32(hWnd, chx1))
1155                 *lpFlags |= FR_WHOLEWORD;
1156                 else *lpFlags &= ~FR_WHOLEWORD;
1157             if (IsDlgButtonChecked32(hWnd, chx2))
1158                 *lpFlags |= FR_MATCHCASE;
1159                 else *lpFlags &= ~FR_MATCHCASE;
1160             *lpFlags &= ~(FR_REPLACE | FR_REPLACEALL | FR_DIALOGTERM);
1161             *lpFlags |= FR_FINDNEXT;
1162             SendMessage32A(hwndOwner, uFindReplaceMessage, 0,
1163                           GetWindowLong32A(hWnd, DWL_USER) );
1164             return TRUE;
1165         case IDCANCEL:
1166             *lpFlags &= ~(FR_FINDNEXT | FR_REPLACE | FR_REPLACEALL);
1167             *lpFlags |= FR_DIALOGTERM;
1168             SendMessage32A(hwndOwner, uFindReplaceMessage, 0,
1169                           GetWindowLong32A(hWnd, DWL_USER) );
1170             DestroyWindow32(hWnd);
1171             return TRUE;
1172         case pshHelp:
1173             /* FIXME : should lpfr structure be passed as an argument ??? */
1174             SendMessage32A(hwndOwner, uHelpMessage, 0, 0);
1175             return TRUE;
1176     }
1177     return FALSE;
1178 }
1179
1180
1181 /***********************************************************************
1182  *           FindTextDlgProc16   (COMMDLG.13)
1183  */
1184 LRESULT WINAPI FindTextDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1185                                  LPARAM lParam)
1186 {
1187     LPFINDREPLACE16 lpfr;
1188     switch (wMsg) {
1189         case WM_INITDIALOG:
1190             lpfr=(LPFINDREPLACE16)PTR_SEG_TO_LIN(lParam);
1191             return FINDDLG_WMInitDialog(hWnd, lParam, &(lpfr->Flags),
1192                 PTR_SEG_TO_LIN(lpfr->lpstrFindWhat), FALSE);
1193         case WM_COMMAND:
1194             lpfr=(LPFINDREPLACE16)PTR_SEG_TO_LIN(GetWindowLong32A(hWnd, DWL_USER));
1195             return FINDDLG_WMCommand(hWnd, wParam, lpfr->hwndOwner,
1196                 &lpfr->Flags, PTR_SEG_TO_LIN(lpfr->lpstrFindWhat),
1197                 lpfr->wFindWhatLen, FALSE);
1198     }
1199     return FALSE;
1200 }
1201
1202 /***********************************************************************
1203  *           FindTextDlgProc32A
1204  */
1205 LRESULT WINAPI FindTextDlgProc32A(HWND32 hWnd, UINT32 wMsg, WPARAM32 wParam,
1206                                  LPARAM lParam)
1207 {
1208     LPFINDREPLACE32A lpfr;
1209     switch (wMsg) {
1210         case WM_INITDIALOG:
1211             lpfr=(LPFINDREPLACE32A)lParam;
1212             return FINDDLG_WMInitDialog(hWnd, lParam, &(lpfr->Flags),
1213               lpfr->lpstrFindWhat, FALSE);
1214         case WM_COMMAND:
1215             lpfr=(LPFINDREPLACE32A)GetWindowLong32A(hWnd, DWL_USER);
1216             return FINDDLG_WMCommand(hWnd, wParam, lpfr->hwndOwner,
1217                 &lpfr->Flags, lpfr->lpstrFindWhat, lpfr->wFindWhatLen,
1218                 FALSE);
1219     }
1220     return FALSE;
1221 }
1222
1223 /***********************************************************************
1224  *           FindTextDlgProc32W
1225  */
1226 LRESULT WINAPI FindTextDlgProc32W(HWND32 hWnd, UINT32 wMsg, WPARAM32 wParam,
1227                                  LPARAM lParam)
1228 {
1229     LPFINDREPLACE32W lpfr;
1230     switch (wMsg) {
1231         case WM_INITDIALOG:
1232             lpfr=(LPFINDREPLACE32W)lParam;
1233             return FINDDLG_WMInitDialog(hWnd, lParam, &(lpfr->Flags),
1234               (LPSTR)lpfr->lpstrFindWhat, TRUE);
1235         case WM_COMMAND:
1236             lpfr=(LPFINDREPLACE32W)GetWindowLong32A(hWnd, DWL_USER);
1237             return FINDDLG_WMCommand(hWnd, wParam, lpfr->hwndOwner,
1238                 &lpfr->Flags, (LPSTR)lpfr->lpstrFindWhat, lpfr->wFindWhatLen,
1239                 TRUE);
1240     }
1241     return FALSE;
1242 }
1243
1244
1245 /***********************************************************************
1246  *                              REPLACEDLG_WMInitDialog         [internal]
1247  */
1248 static LRESULT REPLACEDLG_WMInitDialog(HWND32 hWnd, LPARAM lParam,
1249                     LPDWORD lpFlags, LPSTR lpstrFindWhat,
1250                     LPSTR lpstrReplaceWith, BOOL32 fUnicode)
1251 {
1252     SetWindowLong32A(hWnd, DWL_USER, lParam);
1253     *lpFlags &= ~(FR_FINDNEXT | FR_REPLACE | FR_REPLACEALL | FR_DIALOGTERM);
1254     /*
1255      * FIXME : If the initial FindWhat string is empty, we should disable the FinNext /
1256      * Replace / ReplaceAll buttons.  Only after typing some text, the buttons should be
1257      * enabled.
1258      */
1259     if (fUnicode)
1260     {
1261         SetDlgItemText32W(hWnd, edt1, (LPWSTR)lpstrFindWhat);
1262         SetDlgItemText32W(hWnd, edt2, (LPWSTR)lpstrReplaceWith);
1263     } else
1264     {
1265         SetDlgItemText32A(hWnd, edt1, lpstrFindWhat);
1266         SetDlgItemText32A(hWnd, edt2, lpstrReplaceWith);
1267     }
1268     CheckDlgButton32(hWnd, chx1, (*lpFlags & FR_WHOLEWORD) ? 1 : 0);
1269     if (*lpFlags & (FR_HIDEWHOLEWORD | FR_NOWHOLEWORD))
1270         EnableWindow32(GetDlgItem32(hWnd, chx1), FALSE);
1271     if (*lpFlags & FR_HIDEWHOLEWORD)
1272         ShowWindow32(GetDlgItem32(hWnd, chx1), SW_HIDE);
1273     CheckDlgButton32(hWnd, chx2, (*lpFlags & FR_MATCHCASE) ? 1 : 0);
1274     if (*lpFlags & (FR_HIDEMATCHCASE | FR_NOMATCHCASE))
1275         EnableWindow32(GetDlgItem32(hWnd, chx2), FALSE);
1276     if (*lpFlags & FR_HIDEMATCHCASE)
1277         ShowWindow32(GetDlgItem32(hWnd, chx2), SW_HIDE);
1278     if (!(*lpFlags & FR_SHOWHELP)) {
1279         EnableWindow32(GetDlgItem32(hWnd, pshHelp), FALSE);
1280         ShowWindow32(GetDlgItem32(hWnd, pshHelp), SW_HIDE);
1281     }
1282     ShowWindow32(hWnd, SW_SHOWNORMAL);
1283     return TRUE;
1284 }
1285
1286
1287 /***********************************************************************
1288  *                              REPLACEDLG_WMCommand            [internal]
1289  */
1290 static LRESULT REPLACEDLG_WMCommand(HWND32 hWnd, WPARAM16 wParam,
1291                     HWND32 hwndOwner, LPDWORD lpFlags,
1292                     LPSTR lpstrFindWhat, WORD wFindWhatLen,
1293                     LPSTR lpstrReplaceWith, WORD wReplaceWithLen,
1294                     BOOL32 fUnicode)
1295 {
1296     int uFindReplaceMessage = RegisterWindowMessage32A( FINDMSGSTRING );
1297     int uHelpMessage = RegisterWindowMessage32A( HELPMSGSTRING );
1298
1299     switch (wParam) {
1300         case IDOK:
1301             if (fUnicode)
1302             {
1303                 GetDlgItemText32W(hWnd, edt1, (LPWSTR)lpstrFindWhat, wFindWhatLen/2);
1304                 GetDlgItemText32W(hWnd, edt2, (LPWSTR)lpstrReplaceWith, wReplaceWithLen/2);
1305             }  else
1306             {
1307                 GetDlgItemText32A(hWnd, edt1, lpstrFindWhat, wFindWhatLen);
1308                 GetDlgItemText32A(hWnd, edt2, lpstrReplaceWith, wReplaceWithLen);
1309             }
1310             if (IsDlgButtonChecked32(hWnd, chx1))
1311                 *lpFlags |= FR_WHOLEWORD;
1312                 else *lpFlags &= ~FR_WHOLEWORD;
1313             if (IsDlgButtonChecked32(hWnd, chx2))
1314                 *lpFlags |= FR_MATCHCASE;
1315                 else *lpFlags &= ~FR_MATCHCASE;
1316             *lpFlags &= ~(FR_REPLACE | FR_REPLACEALL | FR_DIALOGTERM);
1317             *lpFlags |= FR_FINDNEXT;
1318             SendMessage32A(hwndOwner, uFindReplaceMessage, 0,
1319                           GetWindowLong32A(hWnd, DWL_USER) );
1320             return TRUE;
1321         case IDCANCEL:
1322             *lpFlags &= ~(FR_FINDNEXT | FR_REPLACE | FR_REPLACEALL);
1323             *lpFlags |= FR_DIALOGTERM;
1324             SendMessage32A(hwndOwner, uFindReplaceMessage, 0,
1325                           GetWindowLong32A(hWnd, DWL_USER) );
1326             DestroyWindow32(hWnd);
1327             return TRUE;
1328         case psh1:
1329             if (fUnicode)
1330             {
1331                 GetDlgItemText32W(hWnd, edt1, (LPWSTR)lpstrFindWhat, wFindWhatLen/2);
1332                 GetDlgItemText32W(hWnd, edt2, (LPWSTR)lpstrReplaceWith, wReplaceWithLen/2);
1333             }  else
1334             {
1335                 GetDlgItemText32A(hWnd, edt1, lpstrFindWhat, wFindWhatLen);
1336                 GetDlgItemText32A(hWnd, edt2, lpstrReplaceWith, wReplaceWithLen);
1337             }
1338             if (IsDlgButtonChecked32(hWnd, chx1))
1339                 *lpFlags |= FR_WHOLEWORD;
1340                 else *lpFlags &= ~FR_WHOLEWORD;
1341             if (IsDlgButtonChecked32(hWnd, chx2))
1342                 *lpFlags |= FR_MATCHCASE;
1343                 else *lpFlags &= ~FR_MATCHCASE;
1344             *lpFlags &= ~(FR_FINDNEXT | FR_REPLACEALL | FR_DIALOGTERM);
1345             *lpFlags |= FR_REPLACE;
1346             SendMessage32A(hwndOwner, uFindReplaceMessage, 0,
1347                           GetWindowLong32A(hWnd, DWL_USER) );
1348             return TRUE;
1349         case psh2:
1350             if (fUnicode)
1351             {
1352                 GetDlgItemText32W(hWnd, edt1, (LPWSTR)lpstrFindWhat, wFindWhatLen/2);
1353                 GetDlgItemText32W(hWnd, edt2, (LPWSTR)lpstrReplaceWith, wReplaceWithLen/2);
1354             }  else
1355             {
1356                 GetDlgItemText32A(hWnd, edt1, lpstrFindWhat, wFindWhatLen);
1357                 GetDlgItemText32A(hWnd, edt2, lpstrReplaceWith, wReplaceWithLen);
1358             }
1359             if (IsDlgButtonChecked32(hWnd, chx1))
1360                 *lpFlags |= FR_WHOLEWORD;
1361                 else *lpFlags &= ~FR_WHOLEWORD;
1362             if (IsDlgButtonChecked32(hWnd, chx2))
1363                 *lpFlags |= FR_MATCHCASE;
1364                 else *lpFlags &= ~FR_MATCHCASE;
1365             *lpFlags &= ~(FR_FINDNEXT | FR_REPLACE | FR_DIALOGTERM);
1366             *lpFlags |= FR_REPLACEALL;
1367             SendMessage32A(hwndOwner, uFindReplaceMessage, 0,
1368                           GetWindowLong32A(hWnd, DWL_USER) );
1369             return TRUE;
1370         case pshHelp:
1371             /* FIXME : should lpfr structure be passed as an argument ??? */
1372             SendMessage32A(hwndOwner, uHelpMessage, 0, 0);
1373             return TRUE;
1374     }
1375     return FALSE;
1376 }
1377
1378
1379 /***********************************************************************
1380  *           ReplaceTextDlgProc16   (COMMDLG.14)
1381  */
1382 LRESULT WINAPI ReplaceTextDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1383                                     LPARAM lParam)
1384 {
1385     LPFINDREPLACE16 lpfr;
1386     switch (wMsg) {
1387         case WM_INITDIALOG:
1388             lpfr=(LPFINDREPLACE16)PTR_SEG_TO_LIN(lParam);
1389             return REPLACEDLG_WMInitDialog(hWnd, lParam, &lpfr->Flags,
1390                     PTR_SEG_TO_LIN(lpfr->lpstrFindWhat),
1391                     PTR_SEG_TO_LIN(lpfr->lpstrReplaceWith), FALSE);
1392         case WM_COMMAND:
1393             lpfr=(LPFINDREPLACE16)PTR_SEG_TO_LIN(GetWindowLong32A(hWnd, DWL_USER));
1394             return REPLACEDLG_WMCommand(hWnd, wParam, lpfr->hwndOwner,
1395                     &lpfr->Flags, PTR_SEG_TO_LIN(lpfr->lpstrFindWhat),
1396                     lpfr->wFindWhatLen, PTR_SEG_TO_LIN(lpfr->lpstrReplaceWith),
1397                     lpfr->wReplaceWithLen, FALSE);
1398     }
1399     return FALSE;
1400 }
1401
1402 /***********************************************************************
1403  *           ReplaceTextDlgProc32A
1404  */
1405 LRESULT WINAPI ReplaceTextDlgProc32A(HWND32 hWnd, UINT32 wMsg, WPARAM32 wParam,
1406                                     LPARAM lParam)
1407 {
1408     LPFINDREPLACE32A lpfr;
1409     switch (wMsg) {
1410         case WM_INITDIALOG:
1411             lpfr=(LPFINDREPLACE32A)lParam;
1412             return REPLACEDLG_WMInitDialog(hWnd, lParam, &lpfr->Flags,
1413                     lpfr->lpstrFindWhat, lpfr->lpstrReplaceWith, FALSE);
1414         case WM_COMMAND:
1415             lpfr=(LPFINDREPLACE32A)GetWindowLong32A(hWnd, DWL_USER);
1416             return REPLACEDLG_WMCommand(hWnd, wParam, lpfr->hwndOwner,
1417                     &lpfr->Flags, lpfr->lpstrFindWhat, lpfr->wFindWhatLen,
1418                     lpfr->lpstrReplaceWith, lpfr->wReplaceWithLen, FALSE);
1419     }
1420     return FALSE;
1421 }
1422
1423 /***********************************************************************
1424  *           ReplaceTextDlgProc32W
1425  */
1426 LRESULT WINAPI ReplaceTextDlgProc32W(HWND32 hWnd, UINT32 wMsg, WPARAM32 wParam,
1427                                     LPARAM lParam)
1428 {
1429     LPFINDREPLACE32W lpfr;
1430     switch (wMsg) {
1431         case WM_INITDIALOG:
1432             lpfr=(LPFINDREPLACE32W)lParam;
1433             return REPLACEDLG_WMInitDialog(hWnd, lParam, &lpfr->Flags,
1434                     (LPSTR)lpfr->lpstrFindWhat, (LPSTR)lpfr->lpstrReplaceWith,
1435                     TRUE);
1436         case WM_COMMAND:
1437             lpfr=(LPFINDREPLACE32W)GetWindowLong32A(hWnd, DWL_USER);
1438             return REPLACEDLG_WMCommand(hWnd, wParam, lpfr->hwndOwner,
1439                     &lpfr->Flags, (LPSTR)lpfr->lpstrFindWhat, lpfr->wFindWhatLen,
1440                     (LPSTR)lpfr->lpstrReplaceWith, lpfr->wReplaceWithLen, TRUE);
1441     }
1442     return FALSE;
1443 }
1444
1445
1446 /***********************************************************************
1447  *           PrintDlg16   (COMMDLG.20)
1448  */
1449 BOOL16 WINAPI PrintDlg16( SEGPTR printdlg )
1450 {
1451     HANDLE16 hInst;
1452     BOOL16 bRet = FALSE;
1453     LPCVOID template;
1454     HWND32 hwndDialog;
1455     LPPRINTDLG16 lpPrint = (LPPRINTDLG16)PTR_SEG_TO_LIN(printdlg);
1456
1457     TRACE(commdlg,"(%p) -- Flags=%08lX\n", lpPrint, lpPrint->Flags );
1458
1459     if (lpPrint->Flags & PD_RETURNDEFAULT)
1460         /* FIXME: should fill lpPrint->hDevMode and lpPrint->hDevNames here */
1461         return TRUE;
1462
1463     if (lpPrint->Flags & PD_PRINTSETUP)
1464         template = SYSRES_GetResPtr( SYSRES_DIALOG_PRINT_SETUP );
1465     else
1466         template = SYSRES_GetResPtr( SYSRES_DIALOG_PRINT );
1467
1468     hInst = WIN_GetWindowInstance( lpPrint->hwndOwner );
1469     hwndDialog = DIALOG_CreateIndirect( hInst, template, TRUE,
1470                                         lpPrint->hwndOwner,
1471                                (DLGPROC16)((lpPrint->Flags & PD_PRINTSETUP) ?
1472                                 MODULE_GetWndProcEntry16("PrintSetupDlgProc") :
1473                                 MODULE_GetWndProcEntry16("PrintDlgProc")),
1474                                 printdlg, WIN_PROC_16 );
1475     if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpPrint->hwndOwner);
1476     return bRet;
1477 }
1478
1479
1480 /***********************************************************************
1481  *           PrintDlg32A   (COMDLG32.17)
1482  */
1483 BOOL32 WINAPI PrintDlg32A( LPPRINTDLG32A printdlg )
1484 {
1485     FIXME(commdlg, "(%p): stub\n",printdlg);
1486     /* Altough returning FALSE is theoricaly the right thing
1487      * most programs check for a printer at startup, and if
1488      * none is found popup PrintDlg32A(), if it fails the program
1489      * terminates; by returning TRUE the programs can still run
1490      * as long as no printer related stuff is used
1491      */
1492     return TRUE;
1493 }
1494
1495
1496 /***********************************************************************
1497  *           PrintDlg32W   (COMDLG32.18)
1498  */
1499 BOOL32 WINAPI PrintDlg32W( LPPRINTDLG32W printdlg )
1500 {
1501     FIXME(commdlg, "empty stub\n" );
1502     return FALSE;
1503 }
1504
1505
1506 /***********************************************************************
1507  *           PrintDlgProc   (COMMDLG.21)
1508  */
1509 LRESULT WINAPI PrintDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1510                             LPARAM lParam)
1511 {
1512   switch (wMsg)
1513     {
1514     case WM_INITDIALOG:
1515       TRACE(commdlg,"WM_INITDIALOG lParam=%08lX\n", lParam);
1516       ShowWindow16(hWnd, SW_SHOWNORMAL);
1517       return (TRUE);
1518     case WM_COMMAND:
1519       switch (wParam)
1520         {
1521         case IDOK:
1522           EndDialog32(hWnd, TRUE);
1523           return(TRUE);
1524         case IDCANCEL:
1525           EndDialog32(hWnd, FALSE);
1526           return(TRUE);
1527         }
1528       return(FALSE);
1529     }
1530   return FALSE;
1531 }
1532
1533
1534 /***********************************************************************
1535  *           PrintSetupDlgProc   (COMMDLG.22)
1536  */
1537 LRESULT WINAPI PrintSetupDlgProc(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1538                                  LPARAM lParam)
1539 {
1540   switch (wMsg)
1541     {
1542     case WM_INITDIALOG:
1543       TRACE(commdlg,"WM_INITDIALOG lParam=%08lX\n", lParam);
1544       ShowWindow16(hWnd, SW_SHOWNORMAL);
1545       return (TRUE);
1546     case WM_COMMAND:
1547       switch (wParam) {
1548       case IDOK:
1549         EndDialog32(hWnd, TRUE);
1550         return(TRUE);
1551       case IDCANCEL:
1552         EndDialog32(hWnd, FALSE);
1553         return(TRUE);
1554       }
1555       return(FALSE);
1556     }
1557   return FALSE;
1558 }
1559
1560
1561 /***********************************************************************
1562  *           CommDlgExtendedError   (COMMDLG.26)
1563  */
1564 DWORD WINAPI CommDlgExtendedError(void)
1565 {
1566   return CommDlgLastError;
1567 }
1568
1569 /***********************************************************************
1570  *           GetFileTitleA   (COMDLG32.8)
1571  */
1572 short WINAPI GetFileTitle32A(LPCSTR lpFile, LPSTR lpTitle, UINT32 cbBuf)
1573 {
1574     int i, len;
1575     TRACE(commdlg,"(%p %p %d); \n", lpFile, lpTitle, cbBuf);
1576     if (lpFile == NULL || lpTitle == NULL)
1577         return -1;
1578     len = strlen(lpFile);
1579     if (len == 0)
1580         return -1;
1581     if (strpbrk(lpFile, "*[]"))
1582         return -1;
1583     len--;
1584     if (lpFile[len] == '/' || lpFile[len] == '\\' || lpFile[len] == ':')
1585         return -1;
1586     for (i = len; i >= 0; i--)
1587         if (lpFile[i] == '/' ||  lpFile[i] == '\\' ||  lpFile[i] == ':')
1588     {
1589         i++;
1590         break;
1591     }
1592     if (i == -1)
1593       i++;
1594     TRACE(commdlg,"---> '%s' \n", &lpFile[i]);
1595
1596     len = strlen(lpFile+i)+1;
1597     if (cbBuf < len)
1598         return len;
1599
1600     strncpy(lpTitle, &lpFile[i], len);
1601     return 0;
1602 }
1603
1604
1605 /***********************************************************************
1606  *           GetFileTitleA   (COMDLG32.8)
1607  */
1608 short WINAPI GetFileTitle32W(LPCWSTR lpFile, LPWSTR lpTitle, UINT32 cbBuf)
1609 {
1610         LPSTR file = HEAP_strdupWtoA(GetProcessHeap(),0,lpFile);
1611         LPSTR title = HeapAlloc(GetProcessHeap(),0,cbBuf);
1612         short   ret;
1613
1614         ret = GetFileTitle32A(file,title,cbBuf);
1615
1616         lstrcpynAtoW(lpTitle,title,cbBuf);
1617         HeapFree(GetProcessHeap(),0,file);
1618         HeapFree(GetProcessHeap(),0,title);
1619         return ret;
1620 }
1621 /***********************************************************************
1622  *           GetFileTitle   (COMMDLG.27)
1623  */
1624 short WINAPI GetFileTitle16(LPCSTR lpFile, LPSTR lpTitle, UINT16 cbBuf)
1625 {
1626     return GetFileTitle32A(lpFile,lpTitle,cbBuf);
1627 }
1628
1629
1630 /* ------------------------ Choose Color Dialog --------------------------- */
1631
1632 /***********************************************************************
1633  *           ChooseColor   (COMMDLG.5)
1634  */
1635 BOOL16 WINAPI ChooseColor16(LPCHOOSECOLOR16 lpChCol)
1636 {
1637     HINSTANCE16 hInst;
1638     HANDLE16 hDlgTmpl = 0;
1639     BOOL16 bRet = FALSE, win32Format = FALSE;
1640     LPCVOID template;
1641     HWND32 hwndDialog;
1642
1643     TRACE(commdlg,"ChooseColor\n");
1644     if (!lpChCol) return FALSE;
1645
1646     if (lpChCol->Flags & CC_ENABLETEMPLATEHANDLE)
1647     {
1648         if (!(template = LockResource16( lpChCol->hInstance )))
1649         {
1650             CommDlgLastError = CDERR_LOADRESFAILURE;
1651             return FALSE;
1652         }
1653     }
1654     else if (lpChCol->Flags & CC_ENABLETEMPLATE)
1655     {
1656         HANDLE16 hResInfo;
1657         if (!(hResInfo = FindResource16(lpChCol->hInstance,
1658                                         lpChCol->lpTemplateName,
1659                                         RT_DIALOG16)))
1660         {
1661             CommDlgLastError = CDERR_FINDRESFAILURE;
1662             return FALSE;
1663         }
1664         if (!(hDlgTmpl = LoadResource16( lpChCol->hInstance, hResInfo )) ||
1665             !(template = LockResource16( hDlgTmpl )))
1666         {
1667             CommDlgLastError = CDERR_LOADRESFAILURE;
1668             return FALSE;
1669         }
1670     }
1671     else
1672     {
1673         template = SYSRES_GetResPtr( SYSRES_DIALOG_CHOOSE_COLOR );
1674         win32Format = TRUE;
1675     }
1676
1677     hInst = WIN_GetWindowInstance( lpChCol->hwndOwner );
1678     hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
1679                                         lpChCol->hwndOwner,
1680                            (DLGPROC16)MODULE_GetWndProcEntry16("ColorDlgProc"),
1681                                         (DWORD)lpChCol, WIN_PROC_16 );
1682     if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpChCol->hwndOwner);
1683     if (hDlgTmpl) FreeResource16( hDlgTmpl );
1684     return bRet;
1685 }
1686
1687
1688 static const COLORREF predefcolors[6][8]=
1689 {
1690  { 0x008080FFL, 0x0080FFFFL, 0x0080FF80L, 0x0080FF00L,
1691    0x00FFFF80L, 0x00FF8000L, 0x00C080FFL, 0x00FF80FFL },
1692  { 0x000000FFL, 0x0000FFFFL, 0x0000FF80L, 0x0040FF00L,
1693    0x00FFFF00L, 0x00C08000L, 0x00C08080L, 0x00FF00FFL },
1694
1695  { 0x00404080L, 0x004080FFL, 0x0000FF00L, 0x00808000L,
1696    0x00804000L, 0x00FF8080L, 0x00400080L, 0x008000FFL },
1697  { 0x00000080L, 0x000080FFL, 0x00008000L, 0x00408000L,
1698    0x00FF0000L, 0x00A00000L, 0x00800080L, 0x00FF0080L },
1699
1700  { 0x00000040L, 0x00004080L, 0x00004000L, 0x00404000L,
1701    0x00800000L, 0x00400000L, 0x00400040L, 0x00800040L },
1702  { 0x00000000L, 0x00008080L, 0x00408080L, 0x00808080L,
1703    0x00808040L, 0x00C0C0C0L, 0x00400040L, 0x00FFFFFFL },
1704 };
1705
1706 struct CCPRIVATE
1707 {
1708  LPCHOOSECOLOR16 lpcc;  /* points to public known data structure */
1709  int nextuserdef;     /* next free place in user defined color array */
1710  HDC16 hdcMem;        /* color graph used for BitBlt() */
1711  HBITMAP16 hbmMem;    /* color graph bitmap */
1712  RECT16 fullsize;     /* original dialog window size */
1713  UINT16 msetrgb;        /* # of SETRGBSTRING message (today not used)  */
1714  RECT16 old3angle;    /* last position of l-marker */
1715  RECT16 oldcross;     /* last position of color/satuation marker */
1716  BOOL32 updating;     /* to prevent recursive WM_COMMAND/EN_UPDATE procesing */
1717  int h;
1718  int s;
1719  int l;               /* for temporary storing of hue,sat,lum */
1720 };
1721
1722 /***********************************************************************
1723  *                             CC_HSLtoRGB                    [internal]
1724  */
1725 static int CC_HSLtoRGB(char c,int hue,int sat,int lum)
1726 {
1727  int res=0,maxrgb;
1728
1729  /* hue */
1730  switch(c)
1731  {
1732   case 'R':if (hue>80)  hue-=80;  else hue+=160; break;
1733   case 'G':if (hue>160) hue-=160; else hue+=80;  break;
1734   case 'B':break;
1735  }
1736
1737  /* l below 120 */
1738  maxrgb=(256*MIN(120,lum))/120;  /* 0 .. 256 */
1739  if (hue< 80)
1740   res=0;
1741  else
1742   if (hue< 120)
1743   {
1744    res=(hue-80)* maxrgb;           /* 0...10240 */
1745    res/=40;                        /* 0...256 */
1746   }
1747   else
1748    if (hue< 200)
1749     res=maxrgb;
1750    else
1751     {
1752      res=(240-hue)* maxrgb;
1753      res/=40;
1754     }
1755  res=res-maxrgb/2;                 /* -128...128 */
1756
1757  /* saturation */
1758  res=maxrgb/2 + (sat*res) /240;    /* 0..256 */
1759
1760  /* lum above 120 */
1761  if (lum>120 && res<256)
1762   res+=((lum-120) * (256-res))/120;
1763
1764  return MIN(res,255);
1765 }
1766
1767 /***********************************************************************
1768  *                             CC_RGBtoHSL                    [internal]
1769  */
1770 static int CC_RGBtoHSL(char c,int r,int g,int b)
1771 {
1772  WORD maxi,mini,mmsum,mmdif,result=0;
1773  int iresult=0;
1774
1775  maxi=MAX(r,b);
1776  maxi=MAX(maxi,g);
1777  mini=MIN(r,b);
1778  mini=MIN(mini,g);
1779
1780  mmsum=maxi+mini;
1781  mmdif=maxi-mini;
1782
1783  switch(c)
1784  {
1785   /* lum */
1786   case 'L':mmsum*=120;              /* 0...61200=(255+255)*120 */
1787            result=mmsum/255;        /* 0...240 */
1788            break;
1789   /* saturation */
1790   case 'S':if (!mmsum)
1791             result=0;
1792            else
1793             if (!mini || maxi==255)
1794              result=240;
1795            else
1796            {
1797             result=mmdif*240;       /* 0...61200=255*240 */
1798             result/= (mmsum>255 ? mmsum=510-mmsum : mmsum); /* 0..255 */
1799            }
1800            break;
1801   /* hue */
1802   case 'H':if (!mmdif)
1803             result=160;
1804            else
1805            {
1806             if (maxi==r)
1807             {
1808              iresult=40*(g-b);       /* -10200 ... 10200 */
1809              iresult/=(int)mmdif;    /* -40 .. 40 */
1810              if (iresult<0)
1811               iresult+=240;          /* 0..40 and 200..240 */
1812             }
1813             else
1814              if (maxi==g)
1815              {
1816               iresult=40*(b-r);
1817               iresult/=(int)mmdif;
1818               iresult+=80;           /* 40 .. 120 */
1819              }
1820              else
1821               if (maxi==b)
1822               {
1823                iresult=40*(r-g);
1824                iresult/=(int)mmdif;
1825                iresult+=160;         /* 120 .. 200 */
1826               }
1827             result=iresult;
1828            }
1829            break;
1830  }
1831  return result;    /* is this integer arithmetic precise enough ? */
1832 }
1833
1834 #define DISTANCE 4
1835
1836 /***********************************************************************
1837  *                CC_MouseCheckPredefColorArray               [internal]
1838  */
1839 static int CC_MouseCheckPredefColorArray(HWND16 hDlg,int dlgitem,int rows,int cols,
1840             LPARAM lParam,COLORREF *cr)
1841 {
1842  HWND16 hwnd;
1843  POINT16 point = MAKEPOINT16(lParam);
1844  RECT16 rect;
1845  int dx,dy,x,y;
1846
1847  ClientToScreen16(hDlg,&point);
1848  hwnd=GetDlgItem32(hDlg,dlgitem);
1849  GetWindowRect16(hwnd,&rect);
1850  if (PtInRect16(&rect,point))
1851  {
1852   dx=(rect.right-rect.left)/cols;
1853   dy=(rect.bottom-rect.top)/rows;
1854   ScreenToClient16(hwnd,&point);
1855
1856   if (point.x % dx < (dx-DISTANCE) && point.y % dy < (dy-DISTANCE))
1857   {
1858    x=point.x/dx;
1859    y=point.y/dy;
1860    *cr=predefcolors[y][x];
1861    /* FIXME: Draw_a_Focus_Rect() */
1862    return 1;
1863   }
1864  }
1865  return 0;
1866 }
1867
1868 /***********************************************************************
1869  *                  CC_MouseCheckUserColorArray               [internal]
1870  */
1871 static int CC_MouseCheckUserColorArray(HWND16 hDlg,int dlgitem,int rows,int cols,
1872             LPARAM lParam,COLORREF *cr,COLORREF*crarr)
1873 {
1874  HWND16 hwnd;
1875  POINT16 point = MAKEPOINT16(lParam);
1876  RECT16 rect;
1877  int dx,dy,x,y;
1878
1879  ClientToScreen16(hDlg,&point);
1880  hwnd=GetDlgItem32(hDlg,dlgitem);
1881  GetWindowRect16(hwnd,&rect);
1882  if (PtInRect16(&rect,point))
1883  {
1884   dx=(rect.right-rect.left)/cols;
1885   dy=(rect.bottom-rect.top)/rows;
1886   ScreenToClient16(hwnd,&point);
1887
1888   if (point.x % dx < (dx-DISTANCE) && point.y % dy < (dy-DISTANCE))
1889   {
1890    x=point.x/dx;
1891    y=point.y/dy;
1892    *cr=crarr[x+cols*y];
1893    /* FIXME: Draw_a_Focus_Rect() */
1894    return 1;
1895   }
1896  }
1897  return 0;
1898 }
1899
1900 #define MAXVERT  240
1901 #define MAXHORI  239
1902
1903 /*  240  ^......        ^^ 240
1904          |     .        ||
1905     SAT  |     .        || LUM
1906          |     .        ||
1907          +-----> 239   ----
1908            HUE
1909 */
1910 /***********************************************************************
1911  *                  CC_MouseCheckColorGraph                   [internal]
1912  */
1913 static int CC_MouseCheckColorGraph(HWND16 hDlg,int dlgitem,int *hori,int *vert,LPARAM lParam)
1914 {
1915  HWND32 hwnd;
1916  POINT16 point = MAKEPOINT16(lParam);
1917  RECT16 rect;
1918  long x,y;
1919
1920  ClientToScreen16(hDlg,&point);
1921  hwnd=GetDlgItem32(hDlg,dlgitem);
1922  GetWindowRect16(hwnd,&rect);
1923  if (PtInRect16(&rect,point))
1924  {
1925   GetClientRect16(hwnd,&rect);
1926   ScreenToClient16(hwnd,&point);
1927
1928   x=(long)point.x*MAXHORI;
1929   x/=rect.right;
1930   y=(long)(rect.bottom-point.y)*MAXVERT;
1931   y/=rect.bottom;
1932
1933   if (hori)
1934    *hori=x;
1935   if (vert)
1936    *vert=y;
1937   return 1;
1938  }
1939  else
1940   return 0;
1941 }
1942 /***********************************************************************
1943  *                  CC_MouseCheckResultWindow                 [internal]
1944  */
1945 static int CC_MouseCheckResultWindow(HWND16 hDlg,LPARAM lParam)
1946 {
1947  HWND16 hwnd;
1948  POINT16 point = MAKEPOINT16(lParam);
1949  RECT16 rect;
1950
1951  ClientToScreen16(hDlg,&point);
1952  hwnd=GetDlgItem32(hDlg,0x2c5);
1953  GetWindowRect16(hwnd,&rect);
1954  if (PtInRect16(&rect,point))
1955  {
1956   PostMessage16(hDlg,WM_COMMAND,0x2c9,0);
1957   return 1;
1958  }
1959  return 0;
1960 }
1961
1962 /***********************************************************************
1963  *                       CC_CheckDigitsInEdit                 [internal]
1964  */
1965 static int CC_CheckDigitsInEdit(HWND16 hwnd,int maxval)
1966 {
1967  int i,k,m,result,value;
1968  long editpos;
1969  char buffer[30];
1970  GetWindowText32A(hwnd,buffer,sizeof(buffer));
1971  m=strlen(buffer);
1972  result=0;
1973
1974  for (i=0;i<m;i++)
1975   if (buffer[i]<'0' || buffer[i]>'9')
1976   {
1977    for (k=i+1;k<=m;k++)   /* delete bad character */
1978    {
1979     buffer[i]=buffer[k];
1980     m--;
1981    }
1982    buffer[m]=0;
1983    result=1;
1984   }
1985
1986  value=atoi(buffer);
1987  if (value>maxval)       /* build a new string */
1988  {
1989   sprintf(buffer,"%d",maxval);
1990   result=2;
1991  }
1992  if (result)
1993  {
1994   editpos=SendMessage16(hwnd,EM_GETSEL16,0,0);
1995   SetWindowText32A(hwnd,buffer);
1996   SendMessage16(hwnd,EM_SETSEL16,0,editpos);
1997  }
1998  return value;
1999 }
2000
2001
2002
2003 /***********************************************************************
2004  *                    CC_PaintSelectedColor                   [internal]
2005  */
2006 static void CC_PaintSelectedColor(HWND16 hDlg,COLORREF cr)
2007 {
2008  RECT16 rect;
2009  HDC32  hdc;
2010  HBRUSH32 hBrush;
2011  HWND32 hwnd=GetDlgItem32(hDlg,0x2c5);
2012  if (IsWindowVisible32(GetDlgItem32(hDlg,0x2c6)))   /* if full size */
2013  {
2014   hdc=GetDC32(hwnd);
2015   GetClientRect16 (hwnd, &rect) ;
2016   hBrush = CreateSolidBrush32(cr);
2017   if (hBrush)
2018   {
2019    hBrush = SelectObject32 (hdc, hBrush) ;
2020    Rectangle32(hdc, rect.left,rect.top,rect.right/2,rect.bottom);
2021    DeleteObject32 (SelectObject32 (hdc,hBrush)) ;
2022    hBrush=CreateSolidBrush32(GetNearestColor32(hdc,cr));
2023    if (hBrush)
2024    {
2025     hBrush= SelectObject32 (hdc, hBrush) ;
2026     Rectangle32( hdc, rect.right/2-1,rect.top,rect.right,rect.bottom);
2027     DeleteObject32( SelectObject32 (hdc, hBrush)) ;
2028    }
2029   }
2030   ReleaseDC32(hwnd,hdc);
2031  }
2032 }
2033
2034 /***********************************************************************
2035  *                    CC_PaintTriangle                        [internal]
2036  */
2037 static void CC_PaintTriangle(HWND16 hDlg,int y)
2038 {
2039  HDC32 hDC;
2040  long temp;
2041  int w=GetDialogBaseUnits();
2042  POINT16 points[3];
2043  int height;
2044  int oben;
2045  RECT16 rect;
2046  HWND16 hwnd=GetDlgItem32(hDlg,0x2be);
2047  struct CCPRIVATE *lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2048
2049  if (IsWindowVisible32(GetDlgItem32(hDlg,0x2c6)))   /* if full size */
2050  {
2051    GetClientRect16(hwnd,&rect);
2052    height=rect.bottom;
2053    hDC=GetDC32(hDlg);
2054
2055    points[0].y=rect.top;
2056    points[0].x=rect.right;           /*  |  /|  */
2057    ClientToScreen16(hwnd,points);    /*  | / |  */
2058    ScreenToClient16(hDlg,points);    /*  |<  |  */
2059    oben=points[0].y;                 /*  | \ |  */
2060                                      /*  |  \|  */
2061    temp=(long)height*(long)y;
2062    points[0].y=oben+height -temp/(long)MAXVERT;
2063    points[1].y=points[0].y+w;
2064    points[2].y=points[0].y-w;
2065    points[2].x=points[1].x=points[0].x + w;
2066
2067    if (lpp->old3angle.left)
2068     FillRect16(hDC,&lpp->old3angle,GetStockObject32(WHITE_BRUSH));
2069    lpp->old3angle.left  =points[0].x;
2070    lpp->old3angle.right =points[1].x+1;
2071    lpp->old3angle.top   =points[2].y-1;
2072    lpp->old3angle.bottom=points[1].y+1;
2073    Polygon16(hDC,points,3);
2074    ReleaseDC32(hDlg,hDC);
2075  }
2076 }
2077
2078
2079 /***********************************************************************
2080  *                    CC_PaintCross                           [internal]
2081  */
2082 static void CC_PaintCross(HWND16 hDlg,int x,int y)
2083 {
2084  HDC32 hDC;
2085  int w=GetDialogBaseUnits();
2086  HWND16 hwnd=GetDlgItem32(hDlg,0x2c6);
2087  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2088  RECT16 rect;
2089  POINT16 point;
2090  HPEN32 hPen;
2091
2092  if (IsWindowVisible32(GetDlgItem32(hDlg,0x2c6)))   /* if full size */
2093  {
2094    GetClientRect16(hwnd,&rect);
2095    hDC=GetDC32(hwnd);
2096    SelectClipRgn32(hDC,CreateRectRgnIndirect16(&rect));
2097    hPen=CreatePen32(PS_SOLID,2,0);
2098    hPen=SelectObject32(hDC,hPen);
2099    point.x=((long)rect.right*(long)x)/(long)MAXHORI;
2100    point.y=rect.bottom-((long)rect.bottom*(long)y)/(long)MAXVERT;
2101    if (lpp->oldcross.left!=lpp->oldcross.right)
2102      BitBlt32(hDC,lpp->oldcross.left,lpp->oldcross.top,
2103               lpp->oldcross.right-lpp->oldcross.left,
2104               lpp->oldcross.bottom-lpp->oldcross.top,
2105               lpp->hdcMem,lpp->oldcross.left,lpp->oldcross.top,SRCCOPY);
2106    lpp->oldcross.left  =point.x-w-1;
2107    lpp->oldcross.right =point.x+w+1;
2108    lpp->oldcross.top   =point.y-w-1;
2109    lpp->oldcross.bottom=point.y+w+1;
2110
2111    MoveTo(hDC,point.x-w,point.y);
2112    LineTo32(hDC,point.x+w,point.y);
2113    MoveTo(hDC,point.x,point.y-w);
2114    LineTo32(hDC,point.x,point.y+w);
2115    DeleteObject32(SelectObject32(hDC,hPen));
2116    ReleaseDC32(hwnd,hDC);
2117  }
2118 }
2119
2120
2121 #define XSTEPS 48
2122 #define YSTEPS 24
2123
2124
2125 /***********************************************************************
2126  *                    CC_PrepareColorGraph                    [internal]
2127  */
2128 static void CC_PrepareColorGraph(HWND16 hDlg)
2129 {
2130  int sdif,hdif,xdif,ydif,r,g,b,hue,sat;
2131  HWND32 hwnd=GetDlgItem32(hDlg,0x2c6);
2132  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2133  HBRUSH32 hbrush;
2134  HDC32 hdc ;
2135  RECT16 rect,client;
2136  HCURSOR16 hcursor=SetCursor16(LoadCursor16(0,IDC_WAIT16));
2137
2138  GetClientRect16(hwnd,&client);
2139  hdc=GetDC32(hwnd);
2140  lpp->hdcMem = CreateCompatibleDC32(hdc);
2141  lpp->hbmMem = CreateCompatibleBitmap32(hdc,client.right,client.bottom);
2142  SelectObject32(lpp->hdcMem,lpp->hbmMem);
2143
2144  xdif=client.right /XSTEPS;
2145  ydif=client.bottom/YSTEPS+1;
2146  hdif=239/XSTEPS;
2147  sdif=240/YSTEPS;
2148  for(rect.left=hue=0;hue<239+hdif;hue+=hdif)
2149  {
2150   rect.right=rect.left+xdif;
2151   rect.bottom=client.bottom;
2152   for(sat=0;sat<240+sdif;sat+=sdif)
2153   {
2154    rect.top=rect.bottom-ydif;
2155    r=CC_HSLtoRGB('R',hue,sat,120);
2156    g=CC_HSLtoRGB('G',hue,sat,120);
2157    b=CC_HSLtoRGB('B',hue,sat,120);
2158    hbrush=CreateSolidBrush32(RGB(r,g,b));
2159    FillRect16(lpp->hdcMem,&rect,hbrush);
2160    DeleteObject32(hbrush);
2161    rect.bottom=rect.top;
2162   }
2163   rect.left=rect.right;
2164  }
2165  ReleaseDC32(hwnd,hdc);
2166  SetCursor16(hcursor);
2167 }
2168
2169 /***********************************************************************
2170  *                          CC_PaintColorGraph                [internal]
2171  */
2172 static void CC_PaintColorGraph(HWND16 hDlg)
2173 {
2174  HWND32 hwnd=GetDlgItem32(hDlg,0x2c6);
2175  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2176  HDC32  hDC;
2177  RECT16 rect;
2178  if (IsWindowVisible32(hwnd))   /* if full size */
2179  {
2180   if (!lpp->hdcMem)
2181    CC_PrepareColorGraph(hDlg);   /* should not be necessary */
2182
2183   hDC=GetDC32(hwnd);
2184   GetClientRect16(hwnd,&rect);
2185   if (lpp->hdcMem)
2186       BitBlt32(hDC,0,0,rect.right,rect.bottom,lpp->hdcMem,0,0,SRCCOPY);
2187   else
2188     WARN(commdlg,"choose color: hdcMem is not defined\n");
2189   ReleaseDC32(hwnd,hDC);
2190  }
2191 }
2192 /***********************************************************************
2193  *                           CC_PaintLumBar                   [internal]
2194  */
2195 static void CC_PaintLumBar(HWND16 hDlg,int hue,int sat)
2196 {
2197  HWND32 hwnd=GetDlgItem32(hDlg,0x2be);
2198  RECT16 rect,client;
2199  int lum,ldif,ydif,r,g,b;
2200  HBRUSH32 hbrush;
2201  HDC32 hDC;
2202
2203  if (IsWindowVisible32(hwnd))
2204  {
2205   hDC=GetDC32(hwnd);
2206   GetClientRect16(hwnd,&client);
2207   rect=client;
2208
2209   ldif=240/YSTEPS;
2210   ydif=client.bottom/YSTEPS+1;
2211   for(lum=0;lum<240+ldif;lum+=ldif)
2212   {
2213    rect.top=MAX(0,rect.bottom-ydif);
2214    r=CC_HSLtoRGB('R',hue,sat,lum);
2215    g=CC_HSLtoRGB('G',hue,sat,lum);
2216    b=CC_HSLtoRGB('B',hue,sat,lum);
2217    hbrush=CreateSolidBrush32(RGB(r,g,b));
2218    FillRect16(hDC,&rect,hbrush);
2219    DeleteObject32(hbrush);
2220    rect.bottom=rect.top;
2221   }
2222   GetClientRect16(hwnd,&rect);
2223   FrameRect16(hDC,&rect,GetStockObject32(BLACK_BRUSH));
2224   ReleaseDC32(hwnd,hDC);
2225  }
2226 }
2227
2228 /***********************************************************************
2229  *                             CC_EditSetRGB                  [internal]
2230  */
2231 static void CC_EditSetRGB(HWND16 hDlg,COLORREF cr)
2232 {
2233  char buffer[10];
2234  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2235  int r=GetRValue(cr);
2236  int g=GetGValue(cr);
2237  int b=GetBValue(cr);
2238  if (IsWindowVisible32(GetDlgItem32(hDlg,0x2c6)))   /* if full size */
2239  {
2240    lpp->updating=TRUE;
2241    sprintf(buffer,"%d",r);
2242    SetWindowText32A(GetDlgItem32(hDlg,0x2c2),buffer);
2243    sprintf(buffer,"%d",g);
2244    SetWindowText32A(GetDlgItem32(hDlg,0x2c3),buffer);
2245    sprintf(buffer,"%d",b);
2246    SetWindowText32A(GetDlgItem32(hDlg,0x2c4),buffer);
2247    lpp->updating=FALSE;
2248  }
2249 }
2250
2251 /***********************************************************************
2252  *                             CC_EditSetHSL                  [internal]
2253  */
2254 static void CC_EditSetHSL(HWND16 hDlg,int h,int s,int l)
2255 {
2256  char buffer[10];
2257  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2258  lpp->updating=TRUE;
2259  if (IsWindowVisible32(GetDlgItem32(hDlg,0x2c6)))   /* if full size */
2260  {
2261    lpp->updating=TRUE;
2262    sprintf(buffer,"%d",h);
2263    SetWindowText32A(GetDlgItem32(hDlg,0x2bf),buffer);
2264    sprintf(buffer,"%d",s);
2265    SetWindowText32A(GetDlgItem32(hDlg,0x2c0),buffer);
2266    sprintf(buffer,"%d",l);
2267    SetWindowText32A(GetDlgItem32(hDlg,0x2c1),buffer);
2268    lpp->updating=FALSE;
2269  }
2270  CC_PaintLumBar(hDlg,h,s);
2271 }
2272
2273 /***********************************************************************
2274  *                       CC_SwitchToFullSize                  [internal]
2275  */
2276 static void CC_SwitchToFullSize(HWND16 hDlg,COLORREF result,LPRECT16 lprect)
2277 {
2278  int i;
2279  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2280
2281  EnableWindow32(GetDlgItem32(hDlg,0x2cf),FALSE);
2282  CC_PrepareColorGraph(hDlg);
2283  for (i=0x2bf;i<0x2c5;i++)
2284    EnableWindow32(GetDlgItem32(hDlg,i),TRUE);
2285  for (i=0x2d3;i<0x2d9;i++)
2286    EnableWindow32(GetDlgItem32(hDlg,i),TRUE);
2287  EnableWindow32(GetDlgItem32(hDlg,0x2c9),TRUE);
2288  EnableWindow32(GetDlgItem32(hDlg,0x2c8),TRUE);
2289
2290  if (lprect)
2291   SetWindowPos32(hDlg,0,0,0,lprect->right-lprect->left,
2292    lprect->bottom-lprect->top, SWP_NOMOVE|SWP_NOZORDER);
2293
2294  ShowWindow32(GetDlgItem32(hDlg,0x2c6),SW_SHOW);
2295  ShowWindow32(GetDlgItem32(hDlg,0x2be),SW_SHOW);
2296  ShowWindow32(GetDlgItem32(hDlg,0x2c5),SW_SHOW);
2297
2298  CC_EditSetRGB(hDlg,result);
2299  CC_EditSetHSL(hDlg,lpp->h,lpp->s,lpp->l);
2300 }
2301
2302 /***********************************************************************
2303  *                           CC_PaintPredefColorArray         [internal]
2304  */
2305 static void CC_PaintPredefColorArray(HWND16 hDlg,int rows,int cols)
2306 {
2307  HWND32 hwnd=GetDlgItem32(hDlg,0x2d0);
2308  RECT16 rect;
2309  HDC32  hdc;
2310  HBRUSH32 hBrush;
2311  int dx,dy,i,j,k;
2312
2313  GetClientRect16(hwnd,&rect);
2314  dx=rect.right/cols;
2315  dy=rect.bottom/rows;
2316  k=rect.left;
2317
2318  hdc=GetDC32(hwnd);
2319  GetClientRect16 (hwnd, &rect) ;
2320
2321  for (j=0;j<rows;j++)
2322  {
2323   for (i=0;i<cols;i++)
2324   {
2325    hBrush = CreateSolidBrush32(predefcolors[j][i]);
2326    if (hBrush)
2327    {
2328     hBrush = SelectObject32 (hdc, hBrush) ;
2329     Rectangle32(hdc, rect.left, rect.top,
2330                 rect.left+dx-DISTANCE, rect.top+dy-DISTANCE);
2331     rect.left=rect.left+dx;
2332     DeleteObject32( SelectObject32 (hdc, hBrush)) ;
2333    }
2334   }
2335   rect.top=rect.top+dy;
2336   rect.left=k;
2337  }
2338  ReleaseDC32(hwnd,hdc);
2339  /* FIXME: draw_a_focus_rect */
2340 }
2341 /***********************************************************************
2342  *                             CC_PaintUserColorArray         [internal]
2343  */
2344 static void CC_PaintUserColorArray(HWND16 hDlg,int rows,int cols,COLORREF* lpcr)
2345 {
2346  HWND32 hwnd=GetDlgItem32(hDlg,0x2d1);
2347  RECT16 rect;
2348  HDC32  hdc;
2349  HBRUSH32 hBrush;
2350  int dx,dy,i,j,k;
2351
2352  GetClientRect16(hwnd,&rect);
2353
2354  dx=rect.right/cols;
2355  dy=rect.bottom/rows;
2356  k=rect.left;
2357
2358  hdc=GetDC32(hwnd);
2359  if (hdc)
2360  {
2361   for (j=0;j<rows;j++)
2362   {
2363    for (i=0;i<cols;i++)
2364    {
2365     hBrush = CreateSolidBrush32(lpcr[i+j*cols]);
2366     if (hBrush)
2367     {
2368      hBrush = SelectObject32 (hdc, hBrush) ;
2369      Rectangle32( hdc, rect.left, rect.top,
2370                   rect.left+dx-DISTANCE, rect.top+dy-DISTANCE);
2371      rect.left=rect.left+dx;
2372      DeleteObject32( SelectObject32 (hdc, hBrush)) ;
2373     }
2374    }
2375    rect.top=rect.top+dy;
2376    rect.left=k;
2377   }
2378   ReleaseDC32(hwnd,hdc);
2379  }
2380  /* FIXME: draw_a_focus_rect */
2381 }
2382
2383
2384
2385 /***********************************************************************
2386  *                             CC_HookCallChk                 [internal]
2387  */
2388 static BOOL32 CC_HookCallChk(LPCHOOSECOLOR16 lpcc)
2389 {
2390  if (lpcc)
2391   if(lpcc->Flags & CC_ENABLEHOOK)
2392    if (lpcc->lpfnHook)
2393     return TRUE;
2394  return FALSE;
2395 }
2396
2397 /***********************************************************************
2398  *                            CC_WMInitDialog                 [internal]
2399  */
2400 static LONG CC_WMInitDialog(HWND16 hDlg, WPARAM16 wParam, LPARAM lParam)
2401 {
2402    int i,res;
2403    HWND16 hwnd;
2404    RECT16 rect;
2405    POINT16 point;
2406    struct CCPRIVATE * lpp;
2407
2408    TRACE(commdlg,"WM_INITDIALOG lParam=%08lX\n", lParam);
2409    lpp=calloc(1,sizeof(struct CCPRIVATE));
2410    lpp->lpcc=(LPCHOOSECOLOR16)lParam;
2411    if (lpp->lpcc->lStructSize != sizeof(CHOOSECOLOR16))
2412    {
2413       EndDialog32 (hDlg, 0) ;
2414       return FALSE;
2415    }
2416    SetWindowLong32A(hDlg, DWL_USER, (LONG)lpp);
2417
2418    if (!(lpp->lpcc->Flags & CC_SHOWHELP))
2419       ShowWindow32(GetDlgItem32(hDlg,0x40e),SW_HIDE);
2420    lpp->msetrgb=RegisterWindowMessage32A( SETRGBSTRING );
2421 #if 0
2422    cpos=MAKELONG(5,7); /* init */
2423    if (lpp->lpcc->Flags & CC_RGBINIT)
2424    {
2425      for (i=0;i<6;i++)
2426        for (j=0;j<8;j++)
2427         if (predefcolors[i][j]==lpp->lpcc->rgbResult)
2428         {
2429           cpos=MAKELONG(i,j);
2430           goto found;
2431         }
2432    }
2433    found:
2434    /* FIXME: Draw_a_focus_rect & set_init_values */
2435 #endif
2436    GetWindowRect16(hDlg,&lpp->fullsize);
2437    if (lpp->lpcc->Flags & CC_FULLOPEN || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
2438    {
2439       hwnd=GetDlgItem32(hDlg,0x2cf);
2440       EnableWindow32(hwnd,FALSE);
2441    }
2442    if (!(lpp->lpcc->Flags & CC_FULLOPEN) || lpp->lpcc->Flags & CC_PREVENTFULLOPEN)
2443    {
2444       rect=lpp->fullsize;
2445       res=rect.bottom-rect.top;
2446       hwnd=GetDlgItem32(hDlg,0x2c6); /* cut at left border */
2447       point.x=point.y=0;
2448       ClientToScreen16(hwnd,&point);
2449       ScreenToClient16(hDlg,&point);
2450       GetClientRect16(hDlg,&rect);
2451       point.x+=GetSystemMetrics32(SM_CXDLGFRAME);
2452       SetWindowPos32(hDlg,0,0,0,point.x,res,SWP_NOMOVE|SWP_NOZORDER);
2453
2454       ShowWindow32(GetDlgItem32(hDlg,0x2c6),SW_HIDE);
2455       ShowWindow32(GetDlgItem32(hDlg,0x2c5),SW_HIDE);
2456    }
2457    else
2458       CC_SwitchToFullSize(hDlg,lpp->lpcc->rgbResult,NULL);
2459    res=TRUE;
2460    for (i=0x2bf;i<0x2c5;i++)
2461      SendMessage16(GetDlgItem32(hDlg,i),EM_LIMITTEXT16,3,0);      /* max 3 digits:  xyz  */
2462    if (CC_HookCallChk(lpp->lpcc))
2463       res=CallWindowProc16(lpp->lpcc->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
2464    return res;
2465 }
2466
2467 /***********************************************************************
2468  *                              CC_WMCommand                  [internal]
2469  */
2470 static LRESULT CC_WMCommand(HWND16 hDlg, WPARAM16 wParam, LPARAM lParam)
2471 {
2472     int r,g,b,i,xx;
2473     UINT16 cokmsg;
2474     HDC32 hdc;
2475     COLORREF *cr;
2476     struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2477     TRACE(commdlg,"CC_WMCommand wParam=%x lParam=%lx\n",wParam,lParam);
2478     switch (wParam)
2479     {
2480           case 0x2c2:  /* edit notify RGB */
2481           case 0x2c3:
2482           case 0x2c4:
2483                if (HIWORD(lParam)==EN_UPDATE && !lpp->updating)
2484                          {
2485                            i=CC_CheckDigitsInEdit(LOWORD(lParam),255);
2486                            r=GetRValue(lpp->lpcc->rgbResult);
2487                            g=GetGValue(lpp->lpcc->rgbResult);
2488                            b=GetBValue(lpp->lpcc->rgbResult);
2489                            xx=0;
2490                            switch (wParam)
2491                            {
2492                             case 0x2c2:if ((xx=(i!=r))) r=i;break;
2493                             case 0x2c3:if ((xx=(i!=g))) g=i;break;
2494                             case 0x2c4:if ((xx=(i!=b))) b=i;break;
2495                            }
2496                            if (xx) /* something has changed */
2497                            {
2498                             lpp->lpcc->rgbResult=RGB(r,g,b);
2499                             CC_PaintSelectedColor(hDlg,lpp->lpcc->rgbResult);
2500                             lpp->h=CC_RGBtoHSL('H',r,g,b);
2501                             lpp->s=CC_RGBtoHSL('S',r,g,b);
2502                             lpp->l=CC_RGBtoHSL('L',r,g,b);
2503                             CC_EditSetHSL(hDlg,lpp->h,lpp->s,lpp->l);
2504                             CC_PaintCross(hDlg,lpp->h,lpp->s);
2505                             CC_PaintTriangle(hDlg,lpp->l);
2506                            }
2507                          }
2508                  break;
2509
2510           case 0x2bf:  /* edit notify HSL */
2511           case 0x2c0:
2512           case 0x2c1:
2513                if (HIWORD(lParam)==EN_UPDATE && !lpp->updating)
2514                          {
2515                            i=CC_CheckDigitsInEdit(LOWORD(lParam),wParam==0x2bf?239:240);
2516                            xx=0;
2517                            switch (wParam)
2518                            {
2519                             case 0x2bf:if ((xx=(i!=lpp->h))) lpp->h=i;break;
2520                             case 0x2c0:if ((xx=(i!=lpp->s))) lpp->s=i;break;
2521                             case 0x2c1:if ((xx=(i!=lpp->l))) lpp->l=i;break;
2522                            }
2523                            if (xx) /* something has changed */
2524                            {
2525                             r=CC_HSLtoRGB('R',lpp->h,lpp->s,lpp->l);
2526                             g=CC_HSLtoRGB('G',lpp->h,lpp->s,lpp->l);
2527                             b=CC_HSLtoRGB('B',lpp->h,lpp->s,lpp->l);
2528                             lpp->lpcc->rgbResult=RGB(r,g,b);
2529                             CC_PaintSelectedColor(hDlg,lpp->lpcc->rgbResult);
2530                             CC_EditSetRGB(hDlg,lpp->lpcc->rgbResult);
2531                             CC_PaintCross(hDlg,lpp->h,lpp->s);
2532                             CC_PaintTriangle(hDlg,lpp->l);
2533                            }
2534                          }
2535                break;
2536
2537           case 0x2cf:
2538                CC_SwitchToFullSize(hDlg,lpp->lpcc->rgbResult,&lpp->fullsize);
2539                InvalidateRect32( hDlg, NULL, TRUE );
2540                SetFocus32(GetDlgItem32(hDlg,0x2bf));
2541                break;
2542
2543           case 0x2c8:    /* add colors ... column by column */
2544                cr=PTR_SEG_TO_LIN(lpp->lpcc->lpCustColors);
2545                cr[(lpp->nextuserdef%2)*8 + lpp->nextuserdef/2]=lpp->lpcc->rgbResult;
2546                if (++lpp->nextuserdef==16)
2547                    lpp->nextuserdef=0;
2548                CC_PaintUserColorArray(hDlg,2,8,PTR_SEG_TO_LIN(lpp->lpcc->lpCustColors));
2549                break;
2550
2551           case 0x2c9:              /* resulting color */
2552                hdc=GetDC32(hDlg);
2553                lpp->lpcc->rgbResult=GetNearestColor32(hdc,lpp->lpcc->rgbResult);
2554                ReleaseDC32(hDlg,hdc);
2555                CC_EditSetRGB(hDlg,lpp->lpcc->rgbResult);
2556                CC_PaintSelectedColor(hDlg,lpp->lpcc->rgbResult);
2557                r=GetRValue(lpp->lpcc->rgbResult);
2558                g=GetGValue(lpp->lpcc->rgbResult);
2559                b=GetBValue(lpp->lpcc->rgbResult);
2560                lpp->h=CC_RGBtoHSL('H',r,g,b);
2561                lpp->s=CC_RGBtoHSL('S',r,g,b);
2562                lpp->l=CC_RGBtoHSL('L',r,g,b);
2563                CC_EditSetHSL(hDlg,lpp->h,lpp->s,lpp->l);
2564                CC_PaintCross(hDlg,lpp->h,lpp->s);
2565                CC_PaintTriangle(hDlg,lpp->l);
2566                break;
2567
2568           case 0x40e:           /* Help! */ /* The Beatles, 1965  ;-) */
2569                i=RegisterWindowMessage32A( HELPMSGSTRING );
2570                if (lpp->lpcc->hwndOwner)
2571                    SendMessage16(lpp->lpcc->hwndOwner,i,0,(LPARAM)lpp->lpcc);
2572                if (CC_HookCallChk(lpp->lpcc))
2573                    CallWindowProc16(lpp->lpcc->lpfnHook,hDlg,
2574                       WM_COMMAND,psh15,(LPARAM)lpp->lpcc);
2575                break;
2576
2577           case IDOK :
2578                 cokmsg=RegisterWindowMessage32A( COLOROKSTRING );
2579                 if (lpp->lpcc->hwndOwner)
2580                         if (SendMessage16(lpp->lpcc->hwndOwner,cokmsg,0,(LPARAM)lpp->lpcc))
2581                            break;    /* do NOT close */
2582
2583                 EndDialog32 (hDlg, 1) ;
2584                 return TRUE ;
2585
2586           case IDCANCEL :
2587                 EndDialog32 (hDlg, 0) ;
2588                 return TRUE ;
2589
2590        }
2591        return FALSE;
2592 }
2593
2594 /***********************************************************************
2595  *                              CC_WMPaint                    [internal]
2596  */
2597 static LRESULT CC_WMPaint(HWND16 hDlg, WPARAM16 wParam, LPARAM lParam)
2598 {
2599     struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2600     /* we have to paint dialog children except text and buttons */
2601
2602     CC_PaintPredefColorArray(hDlg,6,8);
2603     CC_PaintUserColorArray(hDlg,2,8,PTR_SEG_TO_LIN(lpp->lpcc->lpCustColors));
2604     CC_PaintColorGraph(hDlg);
2605     CC_PaintLumBar(hDlg,lpp->h,lpp->s);
2606     CC_PaintCross(hDlg,lpp->h,lpp->s);
2607     CC_PaintTriangle(hDlg,lpp->l);
2608     CC_PaintSelectedColor(hDlg,lpp->lpcc->rgbResult);
2609
2610     /* special necessary for Wine */
2611     ValidateRect32(GetDlgItem32(hDlg,0x2d0),NULL);
2612     ValidateRect32(GetDlgItem32(hDlg,0x2d1),NULL);
2613     ValidateRect32(GetDlgItem32(hDlg,0x2c6),NULL);
2614     ValidateRect32(GetDlgItem32(hDlg,0x2be),NULL);
2615     ValidateRect32(GetDlgItem32(hDlg,0x2c5),NULL);
2616     /* hope we can remove it later -->FIXME */
2617  return 0;
2618 }
2619
2620
2621 /***********************************************************************
2622  *                              CC_WMLButtonDown              [internal]
2623  */
2624 static LRESULT CC_WMLButtonDown(HWND16 hDlg, WPARAM16 wParam, LPARAM lParam)
2625 {
2626    struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2627    int r,g,b,i;
2628    i=0;
2629    if (CC_MouseCheckPredefColorArray(hDlg,0x2d0,6,8,lParam,&lpp->lpcc->rgbResult))
2630       i=1;
2631    else
2632       if (CC_MouseCheckUserColorArray(hDlg,0x2d1,2,8,lParam,&lpp->lpcc->rgbResult,
2633               PTR_SEG_TO_LIN(lpp->lpcc->lpCustColors)))
2634          i=1;
2635       else
2636          if (CC_MouseCheckColorGraph(hDlg,0x2c6,&lpp->h,&lpp->s,lParam))
2637             i=2;
2638          else
2639             if (CC_MouseCheckColorGraph(hDlg,0x2be,NULL,&lpp->l,lParam))
2640                i=2;
2641    if (i==2)
2642    {
2643       r=CC_HSLtoRGB('R',lpp->h,lpp->s,lpp->l);
2644       g=CC_HSLtoRGB('G',lpp->h,lpp->s,lpp->l);
2645       b=CC_HSLtoRGB('B',lpp->h,lpp->s,lpp->l);
2646       lpp->lpcc->rgbResult=RGB(r,g,b);
2647    }
2648    if (i==1)
2649    {
2650       r=GetRValue(lpp->lpcc->rgbResult);
2651       g=GetGValue(lpp->lpcc->rgbResult);
2652       b=GetBValue(lpp->lpcc->rgbResult);
2653       lpp->h=CC_RGBtoHSL('H',r,g,b);
2654       lpp->s=CC_RGBtoHSL('S',r,g,b);
2655       lpp->l=CC_RGBtoHSL('L',r,g,b);
2656    }
2657    if (i)
2658    {
2659       CC_EditSetRGB(hDlg,lpp->lpcc->rgbResult);
2660       CC_EditSetHSL(hDlg,lpp->h,lpp->s,lpp->l);
2661       CC_PaintCross(hDlg,lpp->h,lpp->s);
2662       CC_PaintTriangle(hDlg,lpp->l);
2663       CC_PaintSelectedColor(hDlg,lpp->lpcc->rgbResult);
2664       return TRUE;
2665    }
2666    return FALSE;
2667 }
2668
2669 /***********************************************************************
2670  *           ColorDlgProc   (COMMDLG.8)
2671  */
2672 LRESULT WINAPI ColorDlgProc(HWND16 hDlg, UINT16 message,
2673                             WPARAM16 wParam, LONG lParam)
2674 {
2675  int res;
2676  struct CCPRIVATE * lpp=(struct CCPRIVATE *)GetWindowLong32A(hDlg, DWL_USER);
2677  if (message!=WM_INITDIALOG)
2678  {
2679   if (!lpp)
2680      return FALSE;
2681   res=0;
2682   if (CC_HookCallChk(lpp->lpcc))
2683      res=CallWindowProc16(lpp->lpcc->lpfnHook,hDlg,message,wParam,lParam);
2684   if (res)
2685      return res;
2686  }
2687
2688  /* FIXME: SetRGB message
2689  if (message && message==msetrgb)
2690     return HandleSetRGB(hDlg,lParam);
2691  */
2692
2693  switch (message)
2694         {
2695           case WM_INITDIALOG:
2696                         return CC_WMInitDialog(hDlg,wParam,lParam);
2697           case WM_NCDESTROY:
2698                         DeleteDC32(lpp->hdcMem);
2699                         DeleteObject32(lpp->hbmMem);
2700                         free(lpp);
2701                         SetWindowLong32A(hDlg, DWL_USER, 0L); /* we don't need it anymore */
2702                         break;
2703           case WM_COMMAND:
2704                         if (CC_WMCommand(hDlg, wParam, lParam))
2705                            return TRUE;
2706                         break;
2707           case WM_PAINT:
2708                         CC_WMPaint(hDlg, wParam, lParam);
2709                         break;
2710           case WM_LBUTTONDBLCLK:
2711                         if (CC_MouseCheckResultWindow(hDlg,lParam))
2712                           return TRUE;
2713                         break;
2714           case WM_MOUSEMOVE:  /* FIXME: calculate new hue,sat,lum (if in color graph) */
2715                         break;
2716           case WM_LBUTTONUP:  /* FIXME: ClipCursor off (if in color graph)*/
2717                         break;
2718           case WM_LBUTTONDOWN:/* FIXME: ClipCursor on  (if in color graph)*/
2719                         if (CC_WMLButtonDown(hDlg, wParam, lParam))
2720                            return TRUE;
2721                         break;
2722         }
2723      return FALSE ;
2724 }
2725
2726 static void CFn_CHOOSEFONT16to32A(LPCHOOSEFONT16 chf16, LPCHOOSEFONT32A chf32a)
2727 {
2728   chf32a->lStructSize=sizeof(CHOOSEFONT32A);
2729   chf32a->hwndOwner=chf16->hwndOwner;
2730   chf32a->hDC=chf16->hDC;
2731   chf32a->iPointSize=chf16->iPointSize;
2732   chf32a->Flags=chf16->Flags;
2733   chf32a->rgbColors=chf16->rgbColors;
2734   chf32a->lCustData=chf16->lCustData;
2735   chf32a->lpfnHook=NULL;
2736   chf32a->lpTemplateName=PTR_SEG_TO_LIN(chf16->lpTemplateName);
2737   chf32a->hInstance=chf16->hInstance;
2738   chf32a->lpszStyle=PTR_SEG_TO_LIN(chf16->lpszStyle);
2739   chf32a->nFontType=chf16->nFontType;
2740   chf32a->nSizeMax=chf16->nSizeMax;
2741   chf32a->nSizeMin=chf16->nSizeMin;
2742   FONT_LogFont16To32A(PTR_SEG_TO_LIN(chf16->lpLogFont), chf32a->lpLogFont);
2743 }
2744
2745
2746 /***********************************************************************
2747  *                        ChooseFont16   (COMMDLG.15)
2748  */
2749 BOOL16 WINAPI ChooseFont16(LPCHOOSEFONT16 lpChFont)
2750 {
2751     HINSTANCE16 hInst;
2752     HANDLE16 hDlgTmpl = 0;
2753     BOOL16 bRet = FALSE, win32Format = FALSE;
2754     LPCVOID template;
2755     HWND32 hwndDialog;
2756     CHOOSEFONT32A cf32a;
2757     LOGFONT32A lf32a;
2758     SEGPTR lpTemplateName;
2759
2760     cf32a.lpLogFont=&lf32a;
2761     CFn_CHOOSEFONT16to32A(lpChFont, &cf32a);
2762
2763     TRACE(commdlg,"ChooseFont\n");
2764     if (!lpChFont) return FALSE;
2765
2766     if (lpChFont->Flags & CF_ENABLETEMPLATEHANDLE)
2767     {
2768         if (!(template = LockResource16( lpChFont->hInstance )))
2769         {
2770             CommDlgLastError = CDERR_LOADRESFAILURE;
2771             return FALSE;
2772         }
2773     }
2774     else if (lpChFont->Flags & CF_ENABLETEMPLATE)
2775     {
2776         HANDLE16 hResInfo;
2777         if (!(hResInfo = FindResource16( lpChFont->hInstance,
2778                                          lpChFont->lpTemplateName,
2779                                          RT_DIALOG16)))
2780         {
2781             CommDlgLastError = CDERR_FINDRESFAILURE;
2782             return FALSE;
2783         }
2784         if (!(hDlgTmpl = LoadResource16( lpChFont->hInstance, hResInfo )) ||
2785             !(template = LockResource16( hDlgTmpl )))
2786         {
2787             CommDlgLastError = CDERR_LOADRESFAILURE;
2788             return FALSE;
2789         }
2790     }
2791     else
2792     {
2793         template = SYSRES_GetResPtr( SYSRES_DIALOG_CHOOSE_FONT );
2794         win32Format = TRUE;
2795     }
2796
2797     hInst = WIN_GetWindowInstance( lpChFont->hwndOwner );
2798
2799     /* lpTemplateName is not used in the dialog */
2800     lpTemplateName=lpChFont->lpTemplateName;
2801     lpChFont->lpTemplateName=(SEGPTR)&cf32a;
2802
2803     hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
2804                                         lpChFont->hwndOwner,
2805                       (DLGPROC16)MODULE_GetWndProcEntry16("FormatCharDlgProc"),
2806                                         (DWORD)lpChFont, WIN_PROC_16 );
2807     if (hwndDialog) bRet = DIALOG_DoDialogBox(hwndDialog, lpChFont->hwndOwner);
2808     if (hDlgTmpl) FreeResource16( hDlgTmpl );
2809     lpChFont->lpTemplateName=lpTemplateName;
2810     FONT_LogFont32ATo16(cf32a.lpLogFont,
2811         (LPLOGFONT16)(PTR_SEG_TO_LIN(lpChFont->lpLogFont)));
2812     return bRet;
2813 }
2814
2815
2816 /***********************************************************************
2817  *           ChooseFont32A   (COMDLG32.3)
2818  */
2819 BOOL32 WINAPI ChooseFont32A(LPCHOOSEFONT32A lpChFont)
2820 {
2821   BOOL32 bRet=FALSE;
2822   HWND32 hwndDialog;
2823   HINSTANCE32 hInst=WIN_GetWindowInstance( lpChFont->hwndOwner );
2824   LPCVOID template = SYSRES_GetResPtr( SYSRES_DIALOG_CHOOSE_FONT );
2825   if (lpChFont->Flags & (CF_SELECTSCRIPT | CF_NOVERTFONTS | CF_ENABLETEMPLATE |
2826     CF_ENABLETEMPLATEHANDLE)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
2827   hwndDialog = DIALOG_CreateIndirect(hInst, template, TRUE, lpChFont->hwndOwner,
2828             (DLGPROC16)FormatCharDlgProc32A, (LPARAM)lpChFont, WIN_PROC_32A );
2829   if (hwndDialog) bRet = DIALOG_DoDialogBox(hwndDialog, lpChFont->hwndOwner);
2830   return bRet;
2831 }
2832
2833 /***********************************************************************
2834  *           ChooseFont32W   (COMDLG32.4)
2835  */
2836 BOOL32 WINAPI ChooseFont32W(LPCHOOSEFONT32W lpChFont)
2837 {
2838   BOOL32 bRet=FALSE;
2839   HWND32 hwndDialog;
2840   HINSTANCE32 hInst=WIN_GetWindowInstance( lpChFont->hwndOwner );
2841   CHOOSEFONT32A cf32a;
2842   LOGFONT32A lf32a;
2843   LPCVOID template = SYSRES_GetResPtr( SYSRES_DIALOG_CHOOSE_FONT );
2844   if (lpChFont->Flags & (CF_SELECTSCRIPT | CF_NOVERTFONTS | CF_ENABLETEMPLATE |
2845     CF_ENABLETEMPLATEHANDLE)) FIXME(commdlg, ": unimplemented flag (ignored)\n");
2846   memcpy(&cf32a, lpChFont, sizeof(cf32a));
2847   memcpy(&lf32a, lpChFont->lpLogFont, sizeof(LOGFONT32A));
2848   lstrcpynWtoA(lf32a.lfFaceName, lpChFont->lpLogFont->lfFaceName, LF_FACESIZE);
2849   cf32a.lpLogFont=&lf32a;
2850   cf32a.lpszStyle=HEAP_strdupWtoA(GetProcessHeap(), 0, lpChFont->lpszStyle);
2851   lpChFont->lpTemplateName=(LPWSTR)&cf32a;
2852   hwndDialog=DIALOG_CreateIndirect(hInst, template, TRUE, lpChFont->hwndOwner,
2853             (DLGPROC16)FormatCharDlgProc32W, (LPARAM)lpChFont, WIN_PROC_32W );
2854   if (hwndDialog)bRet=DIALOG_DoDialogBox(hwndDialog, lpChFont->hwndOwner);
2855   HeapFree(GetProcessHeap(), 0, cf32a.lpszStyle);
2856   lpChFont->lpTemplateName=(LPWSTR)cf32a.lpTemplateName;
2857   memcpy(lpChFont->lpLogFont, &lf32a, sizeof(CHOOSEFONT32A));
2858   lstrcpynAtoW(lpChFont->lpLogFont->lfFaceName, lf32a.lfFaceName, LF_FACESIZE);
2859   return bRet;
2860 }
2861
2862
2863 #define TEXT_EXTRAS 4
2864 #define TEXT_COLORS 16
2865
2866 static const COLORREF textcolors[TEXT_COLORS]=
2867 {
2868  0x00000000L,0x00000080L,0x00008000L,0x00008080L,
2869  0x00800000L,0x00800080L,0x00808000L,0x00808080L,
2870  0x00c0c0c0L,0x000000ffL,0x0000ff00L,0x0000ffffL,
2871  0x00ff0000L,0x00ff00ffL,0x00ffff00L,0x00FFFFFFL
2872 };
2873
2874 /***********************************************************************
2875  *                          CFn_HookCallChk                 [internal]
2876  */
2877 static BOOL32 CFn_HookCallChk(LPCHOOSEFONT16 lpcf)
2878 {
2879  if (lpcf)
2880   if(lpcf->Flags & CF_ENABLEHOOK)
2881    if (lpcf->lpfnHook)
2882     return TRUE;
2883  return FALSE;
2884 }
2885
2886 /***********************************************************************
2887  *                          CFn_HookCallChk32                 [internal]
2888  */
2889 static BOOL32 CFn_HookCallChk32(LPCHOOSEFONT32A lpcf)
2890 {
2891  if (lpcf)
2892   if(lpcf->Flags & CF_ENABLEHOOK)
2893    if (lpcf->lpfnHook)
2894     return TRUE;
2895  return FALSE;
2896 }
2897
2898
2899 /*************************************************************************
2900  *              AddFontFamily                               [internal]
2901  */
2902 static INT32 AddFontFamily(LPLOGFONT32A lplf, UINT32 nFontType,
2903                            LPCHOOSEFONT32A lpcf, HWND32 hwnd)
2904 {
2905   int i;
2906   WORD w;
2907
2908   TRACE(commdlg,"font=%s (nFontType=%d)\n", lplf->lfFaceName,nFontType);
2909
2910   if (lpcf->Flags & CF_FIXEDPITCHONLY)
2911    if (!(lplf->lfPitchAndFamily & FIXED_PITCH))
2912      return 1;
2913   if (lpcf->Flags & CF_ANSIONLY)
2914    if (lplf->lfCharSet != ANSI_CHARSET)
2915      return 1;
2916   if (lpcf->Flags & CF_TTONLY)
2917    if (!(nFontType & TRUETYPE_FONTTYPE))
2918      return 1;
2919
2920   i=SendMessage32A(hwnd, CB_ADDSTRING32, 0, (LPARAM)lplf->lfFaceName);
2921   if (i!=CB_ERR)
2922   {
2923     w=(lplf->lfCharSet << 8) | lplf->lfPitchAndFamily;
2924     SendMessage32A(hwnd, CB_SETITEMDATA32, i, MAKELONG(nFontType,w));
2925     return 1 ;        /* store some important font information */
2926   }
2927   else
2928     return 0;
2929 }
2930
2931 typedef struct
2932 {
2933   HWND32 hWnd1;
2934   HWND32 hWnd2;
2935   LPCHOOSEFONT32A lpcf32a;
2936 } CFn_ENUMSTRUCT, *LPCFn_ENUMSTRUCT;
2937
2938 /*************************************************************************
2939  *              FontFamilyEnumProc32                           [internal]
2940  */
2941 INT32 WINAPI FontFamilyEnumProc32(LPENUMLOGFONT32A lpEnumLogFont,
2942           LPNEWTEXTMETRIC32A metrics, UINT32 nFontType, LPARAM lParam)
2943 {
2944   LPCFn_ENUMSTRUCT e;
2945   e=(LPCFn_ENUMSTRUCT)lParam;
2946   return AddFontFamily(&lpEnumLogFont->elfLogFont, nFontType, e->lpcf32a, e->hWnd1);
2947 }
2948
2949 /***********************************************************************
2950  *                FontFamilyEnumProc16                     (COMMDLG.19)
2951  */
2952 INT16 WINAPI FontFamilyEnumProc16( SEGPTR logfont, SEGPTR metrics,
2953                                    UINT16 nFontType, LPARAM lParam )
2954 {
2955   HWND16 hwnd=LOWORD(lParam);
2956   HWND16 hDlg=GetParent16(hwnd);
2957   LPCHOOSEFONT16 lpcf=(LPCHOOSEFONT16)GetWindowLong32A(hDlg, DWL_USER);
2958   LOGFONT16 *lplf = (LOGFONT16 *)PTR_SEG_TO_LIN( logfont );
2959   LOGFONT32A lf32a;
2960   FONT_LogFont16To32A(lplf, &lf32a);
2961   return AddFontFamily(&lf32a, nFontType, (LPCHOOSEFONT32A)lpcf->lpTemplateName,
2962                        hwnd);
2963 }
2964
2965 /*************************************************************************
2966  *              SetFontStylesToCombo2                           [internal]
2967  *
2968  * Fill font style information into combobox  (without using font.c directly)
2969  */
2970 static int SetFontStylesToCombo2(HWND32 hwnd, HDC32 hdc, LPLOGFONT32A lplf)
2971 {
2972    #define FSTYLES 4
2973    struct FONTSTYLE
2974           { int italic;
2975             int weight;
2976             char stname[20]; };
2977    static struct FONTSTYLE fontstyles[FSTYLES]={
2978           { 0,FW_NORMAL,"Regular"},{0,FW_BOLD,"Bold"},
2979           { 1,FW_NORMAL,"Italic"}, {1,FW_BOLD,"Bold Italic"}};
2980    HFONT16 hf;
2981    TEXTMETRIC16 tm;
2982    int i,j;
2983
2984    for (i=0;i<FSTYLES;i++)
2985    {
2986      lplf->lfItalic=fontstyles[i].italic;
2987      lplf->lfWeight=fontstyles[i].weight;
2988      hf=CreateFontIndirect32A(lplf);
2989      hf=SelectObject32(hdc,hf);
2990      GetTextMetrics16(hdc,&tm);
2991      hf=SelectObject32(hdc,hf);
2992      DeleteObject32(hf);
2993
2994      if (tm.tmWeight==fontstyles[i].weight &&
2995          tm.tmItalic==fontstyles[i].italic)    /* font successful created ? */
2996      {
2997        char *str = SEGPTR_STRDUP(fontstyles[i].stname);
2998        j=SendMessage16(hwnd,CB_ADDSTRING16,0,(LPARAM)SEGPTR_GET(str) );
2999        SEGPTR_FREE(str);
3000        if (j==CB_ERR) return 1;
3001        j=SendMessage16(hwnd, CB_SETITEMDATA16, j,
3002                                  MAKELONG(fontstyles[i].weight,fontstyles[i].italic));
3003        if (j==CB_ERR) return 1;
3004      }
3005    }
3006   return 0;
3007 }
3008
3009 /*************************************************************************
3010  *              AddFontSizeToCombo3                           [internal]
3011  */
3012 static int AddFontSizeToCombo3(HWND32 hwnd, UINT32 h, LPCHOOSEFONT32A lpcf)
3013 {
3014     int j;
3015     char buffer[20];
3016
3017     if (  (!(lpcf->Flags & CF_LIMITSIZE))  ||
3018         ((lpcf->Flags & CF_LIMITSIZE) && (h >= lpcf->nSizeMin) && (h <= lpcf->nSizeMax)))
3019     {
3020         sprintf(buffer, "%2d", h);
3021         j=SendMessage32A(hwnd, CB_FINDSTRINGEXACT32, -1, (LPARAM)buffer);
3022         if (j==CB_ERR)
3023         {
3024             j=SendMessage32A(hwnd, CB_ADDSTRING32, 0, (LPARAM)buffer);
3025             if (j!=CB_ERR) j = SendMessage32A(hwnd, CB_SETITEMDATA32, j, h);
3026             if (j==CB_ERR) return 1;
3027         }
3028     }
3029     return 0;
3030 }
3031
3032 /*************************************************************************
3033  *              SetFontSizesToCombo3                           [internal]
3034  */
3035 static int SetFontSizesToCombo3(HWND32 hwnd, LPCHOOSEFONT32A lpcf)
3036 {
3037   static const int sizes[]={8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72,0};
3038   int i;
3039
3040   for (i=0; sizes[i]; i++)
3041     if (AddFontSizeToCombo3(hwnd, sizes[i], lpcf)) return 1;
3042   return 0;
3043 }
3044
3045 /***********************************************************************
3046  *                 AddFontStyle                          [internal]
3047  */
3048 INT32 AddFontStyle(LPLOGFONT32A lplf, UINT32 nFontType,
3049     LPCHOOSEFONT32A lpcf, HWND32 hcmb2, HWND32 hcmb3, HWND32 hDlg)
3050 {
3051   int i;
3052
3053   TRACE(commdlg,"(nFontType=%d)\n",nFontType);
3054   TRACE(commdlg,"  %s h=%d w=%d e=%d o=%d wg=%d i=%d u=%d s=%d"
3055                " ch=%d op=%d cp=%d q=%d pf=%xh\n",
3056                lplf->lfFaceName,lplf->lfHeight,lplf->lfWidth,
3057                lplf->lfEscapement,lplf->lfOrientation,
3058                lplf->lfWeight,lplf->lfItalic,lplf->lfUnderline,
3059                lplf->lfStrikeOut,lplf->lfCharSet, lplf->lfOutPrecision,
3060                lplf->lfClipPrecision,lplf->lfQuality, lplf->lfPitchAndFamily);
3061   if (nFontType & RASTER_FONTTYPE)
3062   {
3063     if (AddFontSizeToCombo3(hcmb3, lplf->lfHeight, lpcf)) return 0;
3064   } else if (SetFontSizesToCombo3(hcmb3, lpcf)) return 0;
3065
3066   if (!SendMessage32A(hcmb2, CB_GETCOUNT32, 0, 0))
3067   {
3068        HDC32 hdc= (lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC) ? lpcf->hDC : GetDC32(hDlg);
3069        i=SetFontStylesToCombo2(hcmb2,hdc,lplf);
3070        if (!(lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC))
3071          ReleaseDC32(hDlg,hdc);
3072        if (i)
3073         return 0;
3074   }
3075   return 1 ;
3076
3077 }
3078
3079 /***********************************************************************
3080  *                 FontStyleEnumProc16                     (COMMDLG.18)
3081  */
3082 INT16 WINAPI FontStyleEnumProc16( SEGPTR logfont, SEGPTR metrics,
3083                                   UINT16 nFontType, LPARAM lParam )
3084 {
3085   HWND16 hcmb2=LOWORD(lParam);
3086   HWND16 hcmb3=HIWORD(lParam);
3087   HWND16 hDlg=GetParent16(hcmb3);
3088   LPCHOOSEFONT16 lpcf=(LPCHOOSEFONT16)GetWindowLong32A(hDlg, DWL_USER);
3089   LOGFONT16 *lplf = (LOGFONT16 *)PTR_SEG_TO_LIN(logfont);
3090   LOGFONT32A lf32a;
3091   FONT_LogFont16To32A(lplf, &lf32a);
3092   return AddFontStyle(&lf32a, nFontType, (LPCHOOSEFONT32A)lpcf->lpTemplateName,
3093                       hcmb2, hcmb3, hDlg);
3094 }
3095
3096 /***********************************************************************
3097  *                 FontStyleEnumProc32                     [internal]
3098  */
3099 INT32 WINAPI FontStyleEnumProc32( LPENUMLOGFONT32A lpFont,
3100           LPNEWTEXTMETRIC32A metrics, UINT32 nFontType, LPARAM lParam )
3101 {
3102   LPCFn_ENUMSTRUCT s=(LPCFn_ENUMSTRUCT)lParam;
3103   HWND32 hcmb2=s->hWnd1;
3104   HWND32 hcmb3=s->hWnd2;
3105   HWND32 hDlg=GetParent32(hcmb3);
3106   return AddFontStyle(&lpFont->elfLogFont, nFontType, s->lpcf32a, hcmb2,
3107                       hcmb3, hDlg);
3108 }
3109
3110 /***********************************************************************
3111  *           CFn_WMInitDialog                            [internal]
3112  */
3113 LRESULT CFn_WMInitDialog(HWND32 hDlg, WPARAM32 wParam, LPARAM lParam,
3114                          LPCHOOSEFONT32A lpcf)
3115 {
3116   HDC32 hdc;
3117   int i,j,res,init=0;
3118   long l;
3119   LPLOGFONT32A lpxx;
3120   HCURSOR32 hcursor=SetCursor32(LoadCursor32A(0,IDC_WAIT32A));
3121
3122   SetWindowLong32A(hDlg, DWL_USER, lParam);
3123   lpxx=lpcf->lpLogFont;
3124   TRACE(commdlg,"WM_INITDIALOG lParam=%08lX\n", lParam);
3125
3126   if (lpcf->lStructSize != sizeof(CHOOSEFONT32A))
3127   {
3128     ERR(commdlg,"structure size failure !!!\n");
3129     EndDialog32 (hDlg, 0);
3130     return FALSE;
3131   }
3132   if (!hBitmapTT)
3133     hBitmapTT = LoadBitmap32A(0, MAKEINTRESOURCE32A(OBM_TRTYPE));
3134
3135   /* This font will be deleted by WM_COMMAND */
3136   SendDlgItemMessage32A(hDlg,stc6,WM_SETFONT,
3137      CreateFont32A(0, 0, 1, 1, 400, 0, 0, 0, 0, 0, 0, 0, 0, NULL),FALSE);
3138
3139   if (!(lpcf->Flags & CF_SHOWHELP) || !IsWindow32(lpcf->hwndOwner))
3140     ShowWindow32(GetDlgItem32(hDlg,pshHelp),SW_HIDE);
3141   if (!(lpcf->Flags & CF_APPLY))
3142     ShowWindow32(GetDlgItem32(hDlg,psh3),SW_HIDE);
3143   if (lpcf->Flags & CF_EFFECTS)
3144   {
3145     for (res=1,i=0;res && i<TEXT_COLORS;i++)
3146     {
3147       /* FIXME: load color name from resource:  res=LoadString(...,i+....,buffer,.....); */
3148       char name[20];
3149       strcpy( name, "[color name]" );
3150       j=SendDlgItemMessage32A(hDlg, cmb4, CB_ADDSTRING32, 0, (LPARAM)name);
3151       SendDlgItemMessage32A(hDlg, cmb4, CB_SETITEMDATA16, j, textcolors[j]);
3152       /* look for a fitting value in color combobox */
3153       if (textcolors[j]==lpcf->rgbColors)
3154         SendDlgItemMessage32A(hDlg,cmb4, CB_SETCURSEL32,j,0);
3155     }
3156   }
3157   else
3158   {
3159     ShowWindow32(GetDlgItem32(hDlg,cmb4),SW_HIDE);
3160     ShowWindow32(GetDlgItem32(hDlg,chx1),SW_HIDE);
3161     ShowWindow32(GetDlgItem32(hDlg,chx2),SW_HIDE);
3162     ShowWindow32(GetDlgItem32(hDlg,grp1),SW_HIDE);
3163     ShowWindow32(GetDlgItem32(hDlg,stc4),SW_HIDE);
3164   }
3165   hdc= (lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC) ? lpcf->hDC : GetDC32(hDlg);
3166   if (hdc)
3167   {
3168     CFn_ENUMSTRUCT s;
3169     s.hWnd1=GetDlgItem32(hDlg,cmb1);
3170     s.lpcf32a=lpcf;
3171     if (!EnumFontFamilies32A(hdc, NULL, FontFamilyEnumProc32, (LPARAM)&s))
3172       TRACE(commdlg,"EnumFontFamilies returns 0\n");
3173     if (lpcf->Flags & CF_INITTOLOGFONTSTRUCT)
3174     {
3175       /* look for fitting font name in combobox1 */
3176       j=SendDlgItemMessage32A(hDlg,cmb1,CB_FINDSTRING32,-1,(LONG)lpxx->lfFaceName);
3177       if (j!=CB_ERR)
3178       {
3179         SendDlgItemMessage32A(hDlg, cmb1, CB_SETCURSEL32, j, 0);
3180         SendMessage32A(hDlg, WM_COMMAND, MAKEWPARAM(cmb1, CBN_SELCHANGE),
3181                        GetDlgItem32(hDlg,cmb1));
3182         init=1;
3183         /* look for fitting font style in combobox2 */
3184         l=MAKELONG(lpxx->lfWeight > FW_MEDIUM ? FW_BOLD:FW_NORMAL,lpxx->lfItalic !=0);
3185         for (i=0;i<TEXT_EXTRAS;i++)
3186         {
3187           if (l==SendDlgItemMessage32A(hDlg, cmb2, CB_GETITEMDATA32, i, 0))
3188             SendDlgItemMessage32A(hDlg, cmb2, CB_SETCURSEL32, i, 0);
3189         }
3190
3191         /* look for fitting font size in combobox3 */
3192         j=SendDlgItemMessage32A(hDlg, cmb3, CB_GETCOUNT32, 0, 0);
3193         for (i=0;i<j;i++)
3194         {
3195           if (lpxx->lfHeight==(int)SendDlgItemMessage32A(hDlg,cmb3, CB_GETITEMDATA32,i,0))
3196             SendDlgItemMessage32A(hDlg,cmb3,CB_SETCURSEL32,i,0);
3197         }
3198       }
3199     }
3200     if (!init)
3201     {
3202       SendDlgItemMessage32A(hDlg,cmb1,CB_SETCURSEL32,0,0);
3203       SendMessage32A(hDlg, WM_COMMAND, MAKEWPARAM(cmb1, CBN_SELCHANGE),
3204                        GetDlgItem32(hDlg,cmb1));
3205     }
3206     if (lpcf->Flags & CF_USESTYLE && lpcf->lpszStyle)
3207     {
3208       j=SendDlgItemMessage32A(hDlg,cmb2,CB_FINDSTRING32,-1,(LONG)lpcf->lpszStyle);
3209       if (j!=CB_ERR)
3210       {
3211         j=SendDlgItemMessage32A(hDlg,cmb2,CB_SETCURSEL32,j,0);
3212         SendMessage32A(hDlg,WM_COMMAND,cmb2,
3213                        MAKELONG(GetDlgItem32(hDlg,cmb2),CBN_SELCHANGE));
3214       }
3215     }
3216   }
3217   else
3218   {
3219     WARN(commdlg,"HDC failure !!!\n");
3220     EndDialog32 (hDlg, 0);
3221     return FALSE;
3222   }
3223
3224   if (!(lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC))
3225     ReleaseDC32(hDlg,hdc);
3226   SetCursor32(hcursor);
3227   return TRUE;
3228 }
3229
3230
3231 /***********************************************************************
3232  *           CFn_WMMeasureItem                           [internal]
3233  */
3234 LRESULT CFn_WMMeasureItem(HWND32 hDlg, WPARAM32 wParam, LPARAM lParam)
3235 {
3236   BITMAP32 bm;
3237   LPMEASUREITEMSTRUCT32 lpmi=(LPMEASUREITEMSTRUCT32)lParam;
3238   if (!hBitmapTT)
3239     hBitmapTT = LoadBitmap32A(0, MAKEINTRESOURCE32A(OBM_TRTYPE));
3240   GetObject32A( hBitmapTT, sizeof(bm), &bm );
3241   lpmi->itemHeight=bm.bmHeight;
3242   /* FIXME: use MAX of bm.bmHeight and tm.tmHeight .*/
3243   return 0;
3244 }
3245
3246
3247 /***********************************************************************
3248  *           CFn_WMDrawItem                              [internal]
3249  */
3250 LRESULT CFn_WMDrawItem(HWND32 hDlg, WPARAM32 wParam, LPARAM lParam)
3251 {
3252   HBRUSH32 hBrush;
3253   char buffer[40];
3254   BITMAP32 bm;
3255   COLORREF cr, oldText=0, oldBk=0;
3256   RECT32 rect;
3257 #if 0
3258   HDC32 hMemDC;
3259   int nFontType;
3260   HBITMAP32 hBitmap; /* for later TT usage */
3261 #endif
3262   LPDRAWITEMSTRUCT32 lpdi = (LPDRAWITEMSTRUCT32)lParam;
3263
3264   if (lpdi->itemID == 0xFFFF)                   /* got no items */
3265     DrawFocusRect32(lpdi->hDC, &lpdi->rcItem);
3266   else
3267   {
3268    if (lpdi->CtlType == ODT_COMBOBOX)
3269    {
3270      if (lpdi->itemState ==ODS_SELECTED)
3271      {
3272        hBrush=GetSysColorBrush32(COLOR_HIGHLIGHT);
3273        oldText=SetTextColor32(lpdi->hDC, GetSysColor32(COLOR_HIGHLIGHTTEXT));
3274        oldBk=SetBkColor32(lpdi->hDC, GetSysColor32(COLOR_HIGHLIGHT));
3275      }  else
3276      {
3277        hBrush = SelectObject32(lpdi->hDC, GetStockObject32(LTGRAY_BRUSH));
3278        SelectObject32(lpdi->hDC, hBrush);
3279      }
3280      FillRect32(lpdi->hDC, &lpdi->rcItem, hBrush);
3281    }
3282    else
3283      return TRUE;       /* this should never happen */
3284
3285    rect=lpdi->rcItem;
3286    switch (lpdi->CtlID)
3287    {
3288     case cmb1:  /* TRACE(commdlg,"WM_Drawitem cmb1\n"); */
3289                 SendMessage32A(lpdi->hwndItem, CB_GETLBTEXT32, lpdi->itemID,
3290                                (LPARAM)buffer);
3291                 GetObject32A( hBitmapTT, sizeof(bm), &bm );
3292                 TextOut32A(lpdi->hDC, lpdi->rcItem.left + bm.bmWidth + 10,
3293                            lpdi->rcItem.top, buffer, lstrlen32A(buffer));
3294 #if 0
3295                 nFontType = SendMessage32A(lpdi->hwndItem, CB_GETITEMDATA32, lpdi->itemID,0L);
3296                   /* FIXME: draw bitmap if truetype usage */
3297                 if (nFontType&TRUETYPE_FONTTYPE)
3298                 {
3299                   hMemDC = CreateCompatibleDC32(lpdi->hDC);
3300                   hBitmap = SelectObject32(hMemDC, hBitmapTT);
3301                   BitBlt32(lpdi->hDC, lpdi->rcItem.left, lpdi->rcItem.top,
3302                            bm.bmWidth, bm.bmHeight, hMemDC, 0, 0, SRCCOPY);
3303                   SelectObject32(hMemDC, hBitmap);
3304                   DeleteDC32(hMemDC);
3305                 }
3306 #endif
3307                 break;
3308     case cmb2:
3309     case cmb3:  /* TRACE(commdlg,"WM_DRAWITEN cmb2,cmb3\n"); */
3310                 SendMessage32A(lpdi->hwndItem, CB_GETLBTEXT32, lpdi->itemID,
3311                                (LPARAM)buffer);
3312                 TextOut32A(lpdi->hDC, lpdi->rcItem.left,
3313                            lpdi->rcItem.top, buffer, lstrlen32A(buffer));
3314                 break;
3315
3316     case cmb4:  /* TRACE(commdlg,"WM_DRAWITEM cmb4 (=COLOR)\n"); */
3317                 SendMessage32A(lpdi->hwndItem, CB_GETLBTEXT32, lpdi->itemID,
3318                                (LPARAM)buffer);
3319                 TextOut32A(lpdi->hDC, lpdi->rcItem.left +  25+5,
3320                            lpdi->rcItem.top, buffer, lstrlen32A(buffer));
3321                 cr = SendMessage32A(lpdi->hwndItem, CB_GETITEMDATA32, lpdi->itemID,0L);
3322                 hBrush = CreateSolidBrush32(cr);
3323                 if (hBrush)
3324                 {
3325                   hBrush = SelectObject32 (lpdi->hDC, hBrush) ;
3326                   rect.right=rect.left+25;
3327                   rect.top++;
3328                   rect.left+=5;
3329                   rect.bottom--;
3330                   Rectangle32( lpdi->hDC, rect.left, rect.top,
3331                                rect.right, rect.bottom );
3332                   DeleteObject32( SelectObject32 (lpdi->hDC, hBrush)) ;
3333                 }
3334                 rect=lpdi->rcItem;
3335                 rect.left+=25+5;
3336                 break;
3337
3338     default:    return TRUE;    /* this should never happen */
3339    }
3340    if (lpdi->itemState == ODS_SELECTED)
3341    {
3342      SetTextColor32(lpdi->hDC, oldText);
3343      SetBkColor32(lpdi->hDC, oldBk);
3344    }
3345  }
3346  return TRUE;
3347 }
3348
3349 /***********************************************************************
3350  *           CFn_WMCtlColor                              [internal]
3351  */
3352 LRESULT CFn_WMCtlColorStatic(HWND32 hDlg, WPARAM32 wParam, LPARAM lParam,
3353                              LPCHOOSEFONT32A lpcf)
3354 {
3355   if (lpcf->Flags & CF_EFFECTS)
3356    if (GetDlgCtrlID32(lParam)==stc6)
3357    {
3358      SetTextColor32((HDC32)wParam, lpcf->rgbColors);
3359      return GetStockObject32(WHITE_BRUSH);
3360    }
3361   return 0;
3362 }
3363
3364 /***********************************************************************
3365  *           CFn_WMCommand                               [internal]
3366  */
3367 LRESULT CFn_WMCommand(HWND32 hDlg, WPARAM32 wParam, LPARAM lParam,
3368                       LPCHOOSEFONT32A lpcf)
3369 {
3370   HFONT32 hFont;
3371   int i,j;
3372   long l;
3373   HDC32 hdc;
3374   LPLOGFONT32A lpxx=lpcf->lpLogFont;
3375
3376   TRACE(commdlg,"WM_COMMAND wParam=%08lX lParam=%08lX\n", (LONG)wParam, lParam);
3377   switch (LOWORD(wParam))
3378   {
3379         case cmb1:if (HIWORD(wParam)==CBN_SELCHANGE)
3380                   {
3381                     hdc=(lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC) ? lpcf->hDC : GetDC32(hDlg);
3382                     if (hdc)
3383                     {
3384                       SendDlgItemMessage32A(hDlg, cmb2, CB_RESETCONTENT16, 0, 0);
3385                       SendDlgItemMessage32A(hDlg, cmb3, CB_RESETCONTENT16, 0, 0);
3386                       i=SendDlgItemMessage32A(hDlg, cmb1, CB_GETCURSEL16, 0, 0);
3387                       if (i!=CB_ERR)
3388                       {
3389                         HCURSOR32 hcursor=SetCursor32(LoadCursor32A(0,IDC_WAIT32A));
3390                         CFn_ENUMSTRUCT s;
3391                         char str[256];
3392                         SendDlgItemMessage32A(hDlg, cmb1, CB_GETLBTEXT32, i,
3393                                               (LPARAM)str);
3394                         TRACE(commdlg,"WM_COMMAND/cmb1 =>%s\n",str);
3395                         s.hWnd1=GetDlgItem32(hDlg, cmb2);
3396                         s.hWnd2=GetDlgItem32(hDlg, cmb3);
3397                         s.lpcf32a=lpcf;
3398                         EnumFontFamilies32A(hdc, str, FontStyleEnumProc32, (LPARAM)&s);
3399                         SetCursor32(hcursor);
3400                       }
3401                       if (!(lpcf->Flags & CF_PRINTERFONTS && lpcf->hDC))
3402                         ReleaseDC32(hDlg,hdc);
3403                     }
3404                     else
3405                     {
3406                       WARN(commdlg,"HDC failure !!!\n");
3407                       EndDialog32 (hDlg, 0);
3408                       return TRUE;
3409                     }
3410                   }
3411         case chx1:
3412         case chx2:
3413         case cmb2:
3414         case cmb3:if (HIWORD(wParam)==CBN_SELCHANGE || HIWORD(wParam)== BN_CLICKED )
3415                   {
3416                     char str[256];
3417                     TRACE(commdlg,"WM_COMMAND/cmb2,3 =%08lX\n", lParam);
3418                     i=SendDlgItemMessage32A(hDlg,cmb1,CB_GETCURSEL32,0,0);
3419                     if (i==CB_ERR)
3420                       i=GetDlgItemText32A( hDlg, cmb1, str, 256 );
3421                     else
3422                     {
3423                       SendDlgItemMessage32A(hDlg,cmb1,CB_GETLBTEXT32,i,
3424                                             (LPARAM)str);
3425                       l=SendDlgItemMessage32A(hDlg,cmb1,CB_GETITEMDATA32,i,0);
3426                       j=HIWORD(l);
3427                       lpcf->nFontType = LOWORD(l);
3428                       /* FIXME:   lpcf->nFontType |= ....  SIMULATED_FONTTYPE and so */
3429                       /* same value reported to the EnumFonts
3430                        call back with the extra FONTTYPE_...  bits added */
3431                       lpxx->lfPitchAndFamily=j&0xff;
3432                       lpxx->lfCharSet=j>>8;
3433                     }
3434                     strcpy(lpxx->lfFaceName,str);
3435                     i=SendDlgItemMessage32A(hDlg, cmb2, CB_GETCURSEL32, 0, 0);
3436                     if (i!=CB_ERR)
3437                     {
3438                       l=SendDlgItemMessage32A(hDlg, cmb2, CB_GETITEMDATA32, i, 0);
3439                       if (0!=(lpxx->lfItalic=HIWORD(l)))
3440                         lpcf->nFontType |= ITALIC_FONTTYPE;
3441                       if ((lpxx->lfWeight=LOWORD(l)) > FW_MEDIUM)
3442                         lpcf->nFontType |= BOLD_FONTTYPE;
3443                     }
3444                     i=SendDlgItemMessage32A(hDlg, cmb3, CB_GETCURSEL32, 0, 0);
3445                     if (i!=CB_ERR)
3446                       lpxx->lfHeight=-LOWORD(SendDlgItemMessage32A(hDlg, cmb3, CB_GETITEMDATA32, i, 0));
3447                     else
3448                       lpxx->lfHeight=0;
3449                     lpxx->lfStrikeOut=IsDlgButtonChecked32(hDlg,chx1);
3450                     lpxx->lfUnderline=IsDlgButtonChecked32(hDlg,chx2);
3451                     lpxx->lfWidth=lpxx->lfOrientation=lpxx->lfEscapement=0;
3452                     lpxx->lfOutPrecision=OUT_DEFAULT_PRECIS;
3453                     lpxx->lfClipPrecision=CLIP_DEFAULT_PRECIS;
3454                     lpxx->lfQuality=DEFAULT_QUALITY;
3455                     lpcf->iPointSize= -10*lpxx->lfHeight;
3456
3457                     hFont=CreateFontIndirect32A(lpxx);
3458                     if (hFont)
3459                     {
3460                       HFONT32 oldFont=SendDlgItemMessage32A(hDlg, stc6,
3461                           WM_GETFONT, 0, 0);
3462                       SendDlgItemMessage32A(hDlg,stc6,WM_SETFONT,hFont,TRUE);
3463                       DeleteObject32(oldFont);
3464                     }
3465                   }
3466                   break;
3467
3468         case cmb4:i=SendDlgItemMessage32A(hDlg, cmb4, CB_GETCURSEL32, 0, 0);
3469                   if (i!=CB_ERR)
3470                   {
3471                    lpcf->rgbColors=textcolors[i];
3472                    InvalidateRect32( GetDlgItem32(hDlg,stc6), NULL, 0 );
3473                   }
3474                   break;
3475
3476         case psh15:i=RegisterWindowMessage32A( HELPMSGSTRING );
3477                   if (lpcf->hwndOwner)
3478                     SendMessage32A(lpcf->hwndOwner, i, 0, (LPARAM)GetWindowLong32A(hDlg, DWL_USER));
3479 /*                if (CFn_HookCallChk(lpcf))
3480                     CallWindowProc16(lpcf->lpfnHook,hDlg,WM_COMMAND,psh15,(LPARAM)lpcf);*/
3481                   break;
3482
3483         case IDOK:if (  (!(lpcf->Flags & CF_LIMITSIZE))  ||
3484                      ( (lpcf->Flags & CF_LIMITSIZE) &&
3485                       (-lpxx->lfHeight >= lpcf->nSizeMin) &&
3486                       (-lpxx->lfHeight <= lpcf->nSizeMax)))
3487                      EndDialog32(hDlg, TRUE);
3488                   else
3489                   {
3490                    char buffer[80];
3491                    sprintf(buffer,"Select a font size between %d and %d points.",
3492                            lpcf->nSizeMin,lpcf->nSizeMax);
3493                    MessageBox32A(hDlg, buffer, NULL, MB_OK);
3494                   }
3495                   return(TRUE);
3496         case IDCANCEL:EndDialog32(hDlg, FALSE);
3497                   return(TRUE);
3498         }
3499       return(FALSE);
3500 }
3501
3502 static LRESULT CFn_WMDestroy(HWND32 hwnd, WPARAM32 wParam, LPARAM lParam)
3503 {
3504   DeleteObject32(SendDlgItemMessage32A(hwnd, stc6, WM_GETFONT, 0, 0));
3505   return TRUE;
3506 }
3507
3508
3509 /***********************************************************************
3510  *           FormatCharDlgProc16   (COMMDLG.16)
3511              FIXME: 1. some strings are "hardcoded", but it's better load from sysres
3512                     2. some CF_.. flags are not supported
3513                     3. some TType extensions
3514  */
3515 LRESULT WINAPI FormatCharDlgProc16(HWND16 hDlg, UINT16 message, WPARAM16 wParam,
3516                                    LPARAM lParam)
3517 {
3518   LPCHOOSEFONT16 lpcf;
3519   LPCHOOSEFONT32A lpcf32a;
3520   UINT32 uMsg32;
3521   WPARAM32 wParam32;
3522   LRESULT res=0;
3523   if (message!=WM_INITDIALOG)
3524   {
3525    lpcf=(LPCHOOSEFONT16)GetWindowLong32A(hDlg, DWL_USER);
3526    if (!lpcf)
3527       return FALSE;
3528    if (CFn_HookCallChk(lpcf))
3529      res=CallWindowProc16(lpcf->lpfnHook,hDlg,message,wParam,lParam);
3530    if (res)
3531     return res;
3532   }
3533   else
3534   {
3535     lpcf=(LPCHOOSEFONT16)lParam;
3536     lpcf32a=(LPCHOOSEFONT32A)lpcf->lpTemplateName;
3537     if (!CFn_WMInitDialog(hDlg, wParam, lParam, lpcf32a))
3538     {
3539       TRACE(commdlg, "CFn_WMInitDialog returned FALSE\n");
3540       return FALSE;
3541     }
3542     if (CFn_HookCallChk(lpcf))
3543       return CallWindowProc16(lpcf->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
3544   }
3545   WINPROC_MapMsg16To32A(message, wParam, &uMsg32, &wParam32, &lParam);
3546   lpcf32a=(LPCHOOSEFONT32A)lpcf->lpTemplateName;
3547   switch (uMsg32)
3548     {
3549       case WM_MEASUREITEM:
3550                         res=CFn_WMMeasureItem(hDlg, wParam32, lParam);
3551                         break;
3552       case WM_DRAWITEM:
3553                         res=CFn_WMDrawItem(hDlg, wParam32, lParam);
3554                         break;
3555       case WM_CTLCOLORSTATIC:
3556                         res=CFn_WMCtlColorStatic(hDlg, wParam32, lParam, lpcf32a);
3557                         break;
3558       case WM_COMMAND:
3559                         res=CFn_WMCommand(hDlg, wParam32, lParam, lpcf32a);
3560                         break;
3561       case WM_DESTROY:
3562                         res=CFn_WMDestroy(hDlg, wParam32, lParam);
3563                         break;
3564       case WM_CHOOSEFONT_GETLOGFONT:
3565                          TRACE(commdlg,"WM_CHOOSEFONT_GETLOGFONT lParam=%08lX\n",
3566                                       lParam);
3567                          FIXME(commdlg, "current logfont back to caller\n");
3568                         break;
3569     }
3570   WINPROC_UnmapMsg16To32A(hDlg,uMsg32, wParam32, lParam, res);
3571   return res;
3572 }
3573
3574 /***********************************************************************
3575  *           FormatCharDlgProc32A   [internal]
3576  */
3577 LRESULT WINAPI FormatCharDlgProc32A(HWND32 hDlg, UINT32 uMsg, WPARAM32 wParam,
3578                                     LPARAM lParam)
3579 {
3580   LPCHOOSEFONT32A lpcf;
3581   LRESULT res=FALSE;
3582   if (uMsg!=WM_INITDIALOG)
3583   {
3584    lpcf=(LPCHOOSEFONT32A)GetWindowLong32A(hDlg, DWL_USER);
3585    if (!lpcf)
3586      return FALSE;
3587    if (CFn_HookCallChk32(lpcf))
3588      res=CallWindowProc32A(lpcf->lpfnHook, hDlg, uMsg, wParam, lParam);
3589    if (res)
3590      return res;
3591   }
3592   else
3593   {
3594     lpcf=(LPCHOOSEFONT32A)lParam;
3595     if (!CFn_WMInitDialog(hDlg, wParam, lParam, lpcf))
3596     {
3597       TRACE(commdlg, "CFn_WMInitDialog returned FALSE\n");
3598       return FALSE;
3599     }
3600     if (CFn_HookCallChk32(lpcf))
3601       return CallWindowProc32A(lpcf->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
3602   }
3603   switch (uMsg)
3604     {
3605       case WM_MEASUREITEM:
3606                         return CFn_WMMeasureItem(hDlg, wParam, lParam);
3607       case WM_DRAWITEM:
3608                         return CFn_WMDrawItem(hDlg, wParam, lParam);
3609       case WM_CTLCOLORSTATIC:
3610                         return CFn_WMCtlColorStatic(hDlg, wParam, lParam, lpcf);
3611       case WM_COMMAND:
3612                         return CFn_WMCommand(hDlg, wParam, lParam, lpcf);
3613       case WM_DESTROY:
3614                         return CFn_WMDestroy(hDlg, wParam, lParam);
3615       case WM_CHOOSEFONT_GETLOGFONT:
3616                          TRACE(commdlg,"WM_CHOOSEFONT_GETLOGFONT lParam=%08lX\n",
3617                                       lParam);
3618                          FIXME(commdlg, "current logfont back to caller\n");
3619                         break;
3620     }
3621   return res;
3622 }
3623
3624 /***********************************************************************
3625  *           FormatCharDlgProc32W   [internal]
3626  */
3627 LRESULT WINAPI FormatCharDlgProc32W(HWND32 hDlg, UINT32 uMsg, WPARAM32 wParam,
3628                                     LPARAM lParam)
3629 {
3630   LPCHOOSEFONT32W lpcf32w;
3631   LPCHOOSEFONT32A lpcf32a;
3632   LRESULT res=FALSE;
3633   if (uMsg!=WM_INITDIALOG)
3634   {
3635    lpcf32w=(LPCHOOSEFONT32W)GetWindowLong32A(hDlg, DWL_USER);
3636    if (!lpcf32w)
3637      return FALSE;
3638    if (CFn_HookCallChk32((LPCHOOSEFONT32A)lpcf32w))
3639      res=CallWindowProc32W(lpcf32w->lpfnHook, hDlg, uMsg, wParam, lParam);
3640    if (res)
3641      return res;
3642   }
3643   else
3644   {
3645     lpcf32w=(LPCHOOSEFONT32W)lParam;
3646     lpcf32a=(LPCHOOSEFONT32A)lpcf32w->lpTemplateName;
3647     if (!CFn_WMInitDialog(hDlg, wParam, lParam, lpcf32a))
3648     {
3649       TRACE(commdlg, "CFn_WMInitDialog returned FALSE\n");
3650       return FALSE;
3651     }
3652     if (CFn_HookCallChk32((LPCHOOSEFONT32A)lpcf32w))
3653       return CallWindowProc32W(lpcf32w->lpfnHook,hDlg,WM_INITDIALOG,wParam,lParam);
3654   }
3655   lpcf32a=(LPCHOOSEFONT32A)lpcf32w->lpTemplateName;
3656   switch (uMsg)
3657     {
3658       case WM_MEASUREITEM:
3659                         return CFn_WMMeasureItem(hDlg, wParam, lParam);
3660       case WM_DRAWITEM:
3661                         return CFn_WMDrawItem(hDlg, wParam, lParam);
3662       case WM_CTLCOLORSTATIC:
3663                         return CFn_WMCtlColorStatic(hDlg, wParam, lParam, lpcf32a);
3664       case WM_COMMAND:
3665                         return CFn_WMCommand(hDlg, wParam, lParam, lpcf32a);
3666       case WM_DESTROY:
3667                         return CFn_WMDestroy(hDlg, wParam, lParam);
3668       case WM_CHOOSEFONT_GETLOGFONT:
3669                          TRACE(commdlg,"WM_CHOOSEFONT_GETLOGFONT lParam=%08lX\n",
3670                                       lParam);
3671                          FIXME(commdlg, "current logfont back to caller\n");
3672                         break;
3673     }
3674   return res;
3675 }
3676
3677
3678 static BOOL32 Commdlg_GetFileName32A( BOOL16 (CALLBACK *dofunction)(SEGPTR x),
3679                                       LPOPENFILENAME32A ofn )
3680 {
3681         BOOL16 ret;
3682         LPOPENFILENAME16 ofn16 = SEGPTR_ALLOC(sizeof(OPENFILENAME16));
3683
3684         memset(ofn16,'\0',sizeof(*ofn16));
3685         ofn16->lStructSize = sizeof(*ofn16);
3686         ofn16->hwndOwner = ofn->hwndOwner;
3687         ofn16->hInstance = MapHModuleLS(ofn->hInstance);
3688         if (ofn->lpstrFilter) {
3689                 LPSTR   s,x;
3690
3691                 /* filter is a list...  title\0ext\0......\0\0 */
3692                 s = (LPSTR)ofn->lpstrFilter;
3693                 while (*s)
3694                         s = s+strlen(s)+1;
3695                 s++;
3696                 x = (LPSTR)SEGPTR_ALLOC(s-ofn->lpstrFilter);
3697                 memcpy(x,ofn->lpstrFilter,s-ofn->lpstrFilter);
3698                 ofn16->lpstrFilter = SEGPTR_GET(x);
3699         }
3700         if (ofn->lpstrCustomFilter) {
3701                 LPSTR   s,x;
3702
3703                 /* filter is a list...  title\0ext\0......\0\0 */
3704                 s = (LPSTR)ofn->lpstrCustomFilter;
3705                 while (*s)
3706                         s = s+strlen(s)+1;
3707                 s++;
3708                 x = SEGPTR_ALLOC(s-ofn->lpstrCustomFilter);
3709                 memcpy(x,ofn->lpstrCustomFilter,s-ofn->lpstrCustomFilter);
3710                 ofn16->lpstrCustomFilter = SEGPTR_GET(x);
3711         }
3712         ofn16->nMaxCustFilter = ofn->nMaxCustFilter;
3713         ofn16->nFilterIndex = ofn->nFilterIndex;
3714         if (ofn->nMaxFile)
3715             ofn16->lpstrFile = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFile));
3716         ofn16->nMaxFile = ofn->nMaxFile;
3717         ofn16->nMaxFileTitle = ofn->nMaxFileTitle;
3718         if (ofn16->nMaxFileTitle)
3719             ofn16->lpstrFileTitle = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFileTitle));
3720         if (ofn->lpstrInitialDir)
3721             ofn16->lpstrInitialDir = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrInitialDir));
3722         if (ofn->lpstrTitle)
3723             ofn16->lpstrTitle = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrTitle));
3724         ofn16->Flags = ofn->Flags|OFN_WINE32;
3725         ofn16->nFileOffset = ofn->nFileOffset;
3726         ofn16->nFileExtension = ofn->nFileExtension;
3727         if (ofn->lpstrDefExt)
3728             ofn16->lpstrDefExt = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrDefExt));
3729         ofn16->lCustData = ofn->lCustData;
3730         ofn16->lpfnHook = (WNDPROC16)ofn->lpfnHook;
3731
3732         if (ofn->lpTemplateName)
3733             ofn16->lpTemplateName = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpTemplateName));
3734
3735         ret = dofunction(SEGPTR_GET(ofn16));
3736
3737         ofn->nFileOffset = ofn16->nFileOffset;
3738         ofn->nFileExtension = ofn16->nFileExtension;
3739         if (ofn16->lpstrFilter)
3740             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFilter));
3741         if (ofn16->lpTemplateName)
3742             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpTemplateName));
3743         if (ofn16->lpstrDefExt)
3744             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrDefExt));
3745         if (ofn16->lpstrTitle)
3746             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrTitle));
3747         if (ofn16->lpstrInitialDir)
3748             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrInitialDir));
3749         if (ofn16->lpstrCustomFilter)
3750             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrCustomFilter));
3751
3752         if (ofn16->lpstrFile)
3753           {
3754             strcpy(ofn->lpstrFile,PTR_SEG_TO_LIN(ofn16->lpstrFile));
3755             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFile));
3756           }
3757
3758         if (ofn16->lpstrFileTitle)
3759           {
3760             strcpy(ofn->lpstrFileTitle,PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
3761             SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
3762           }
3763         SEGPTR_FREE(ofn16);
3764         return ret;
3765 }
3766
3767 static BOOL32 Commdlg_GetFileName32W( BOOL16 (CALLBACK *dofunction)(SEGPTR x),
3768                                       LPOPENFILENAME32W ofn )
3769 {
3770         BOOL16 ret;
3771         LPOPENFILENAME16 ofn16 = SEGPTR_ALLOC(sizeof(OPENFILENAME16));
3772
3773         memset(ofn16,'\0',sizeof(*ofn16));
3774         ofn16->lStructSize = sizeof(*ofn16);
3775         ofn16->hwndOwner = ofn->hwndOwner;
3776         ofn16->hInstance = MapHModuleLS(ofn->hInstance);
3777         if (ofn->lpstrFilter) {
3778                 LPWSTR  s;
3779                 LPSTR   x,y;
3780                 int     n;
3781
3782                 /* filter is a list...  title\0ext\0......\0\0 */
3783                 s = (LPWSTR)ofn->lpstrFilter;
3784                 while (*s)
3785                         s = s+lstrlen32W(s)+1;
3786                 s++;
3787                 n = s - ofn->lpstrFilter; /* already divides by 2. ptr magic */
3788                 x = y = (LPSTR)SEGPTR_ALLOC(n);
3789                 s = (LPWSTR)ofn->lpstrFilter;
3790                 while (*s) {
3791                         lstrcpyWtoA(x,s);
3792                         x+=lstrlen32A(x)+1;
3793                         s+=lstrlen32W(s)+1;
3794                 }
3795                 *x=0;
3796                 ofn16->lpstrFilter = SEGPTR_GET(y);
3797 }
3798         if (ofn->lpstrCustomFilter) {
3799                 LPWSTR  s;
3800                 LPSTR   x,y;
3801                 int     n;
3802
3803                 /* filter is a list...  title\0ext\0......\0\0 */
3804                 s = (LPWSTR)ofn->lpstrCustomFilter;
3805                 while (*s)
3806                         s = s+lstrlen32W(s)+1;
3807                 s++;
3808                 n = s - ofn->lpstrCustomFilter;
3809                 x = y = (LPSTR)SEGPTR_ALLOC(n);
3810                 s = (LPWSTR)ofn->lpstrCustomFilter;
3811                 while (*s) {
3812                         lstrcpyWtoA(x,s);
3813                         x+=lstrlen32A(x)+1;
3814                         s+=lstrlen32W(s)+1;
3815                 }
3816                 *x=0;
3817                 ofn16->lpstrCustomFilter = SEGPTR_GET(y);
3818         }
3819         ofn16->nMaxCustFilter = ofn->nMaxCustFilter;
3820         ofn16->nFilterIndex = ofn->nFilterIndex;
3821         if (ofn->nMaxFile)
3822            ofn16->lpstrFile = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFile));
3823         ofn16->nMaxFile = ofn->nMaxFile;
3824         ofn16->nMaxFileTitle = ofn->nMaxFileTitle;
3825         if (ofn->nMaxFileTitle)
3826                 ofn16->lpstrFileTitle = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFileTitle));
3827         if (ofn->lpstrInitialDir)
3828                 ofn16->lpstrInitialDir = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrInitialDir));
3829         if (ofn->lpstrTitle)
3830                 ofn16->lpstrTitle = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrTitle));
3831         ofn16->Flags = ofn->Flags|OFN_WINE32|OFN_UNICODE;
3832         ofn16->nFileOffset = ofn->nFileOffset;
3833         ofn16->nFileExtension = ofn->nFileExtension;
3834         if (ofn->lpstrDefExt)
3835                 ofn16->lpstrDefExt = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrDefExt));
3836         ofn16->lCustData = ofn->lCustData;
3837         ofn16->lpfnHook = (WNDPROC16)ofn->lpfnHook;
3838         if (ofn->lpTemplateName)
3839                 ofn16->lpTemplateName = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpTemplateName));
3840         ret = dofunction(SEGPTR_GET(ofn16));
3841
3842         ofn->nFileOffset = ofn16->nFileOffset;
3843         ofn->nFileExtension = ofn16->nFileExtension;
3844         if (ofn16->lpstrFilter)
3845                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFilter));
3846         if (ofn16->lpTemplateName)
3847                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpTemplateName));
3848         if (ofn16->lpstrDefExt)
3849                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrDefExt));
3850         if (ofn16->lpstrTitle)
3851                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrTitle));
3852         if (ofn16->lpstrInitialDir)
3853                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrInitialDir));
3854         if (ofn16->lpstrCustomFilter)
3855                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrCustomFilter));
3856
3857         if (ofn16->lpstrFile) {
3858         lstrcpyAtoW(ofn->lpstrFile,PTR_SEG_TO_LIN(ofn16->lpstrFile));
3859         SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFile));
3860         }
3861
3862         if (ofn16->lpstrFileTitle) {
3863                 lstrcpyAtoW(ofn->lpstrFileTitle,PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
3864                 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
3865         }
3866         SEGPTR_FREE(ofn16);
3867         return ret;
3868 }
3869
3870 /***********************************************************************
3871  *            GetOpenFileName32A  (COMDLG32.10)
3872  */
3873 BOOL32 WINAPI GetOpenFileName32A( LPOPENFILENAME32A ofn )
3874 {
3875    BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetOpenFileName16;
3876    return Commdlg_GetFileName32A(dofunction,ofn);
3877 }
3878
3879 /***********************************************************************
3880  *            GetOpenFileName32W (COMDLG32.11)
3881  */
3882 BOOL32 WINAPI GetOpenFileName32W( LPOPENFILENAME32W ofn )
3883 {
3884    BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetOpenFileName16;
3885    return Commdlg_GetFileName32W(dofunction,ofn);
3886 }
3887
3888 /***********************************************************************
3889  *            GetSaveFileName32A  (COMDLG32.12)
3890  */
3891 BOOL32 WINAPI GetSaveFileName32A( LPOPENFILENAME32A ofn )
3892 {
3893    BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetSaveFileName16;
3894    return Commdlg_GetFileName32A(dofunction,ofn);
3895 }
3896
3897 /***********************************************************************
3898  *            GetSaveFileName32W  (COMDLG32.13)
3899  */
3900 BOOL32 WINAPI GetSaveFileName32W( LPOPENFILENAME32W ofn )
3901 {
3902    BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetSaveFileName16;
3903    return Commdlg_GetFileName32W(dofunction,ofn);
3904 }
3905
3906 /***********************************************************************
3907  *            ChooseColorA  (COMDLG32.1)
3908  */
3909 BOOL32 WINAPI ChooseColor32A(LPCHOOSECOLOR32A lpChCol )
3910
3911 {
3912   BOOL16 ret;
3913   char *str = NULL;
3914   COLORREF* ccref=SEGPTR_ALLOC(64);
3915   LPCHOOSECOLOR16 lpcc16=SEGPTR_ALLOC(sizeof(CHOOSECOLOR16));
3916
3917   memset(lpcc16,'\0',sizeof(*lpcc16));
3918   lpcc16->lStructSize=sizeof(*lpcc16);
3919   lpcc16->hwndOwner=lpChCol->hwndOwner;
3920   lpcc16->hInstance=MapHModuleLS(lpChCol->hInstance);
3921   lpcc16->rgbResult=lpChCol->rgbResult;
3922   memcpy(ccref,lpChCol->lpCustColors,64);
3923   lpcc16->lpCustColors=(COLORREF*)SEGPTR_GET(ccref);
3924   lpcc16->Flags=lpChCol->Flags;
3925   lpcc16->lCustData=lpChCol->lCustData;
3926   lpcc16->lpfnHook=(WNDPROC16)lpChCol->lpfnHook;
3927   if (lpChCol->lpTemplateName)
3928     str = SEGPTR_STRDUP(lpChCol->lpTemplateName );
3929   lpcc16->lpTemplateName=SEGPTR_GET(str);
3930
3931   ret = ChooseColor16(lpcc16);
3932   if(str)
3933     SEGPTR_FREE(str);
3934   memcpy(lpChCol->lpCustColors,ccref,64);
3935   SEGPTR_FREE(ccref);
3936   SEGPTR_FREE(lpcc16);
3937   return (BOOL32)ret;
3938 }
3939
3940 /***********************************************************************
3941  *            ChooseColorW  (COMDLG32.2)
3942  */
3943 BOOL32 WINAPI ChooseColor32W(LPCHOOSECOLOR32W lpChCol )
3944
3945 {
3946   BOOL16 ret;
3947   char *str = NULL;
3948   COLORREF* ccref=SEGPTR_ALLOC(64);
3949   LPCHOOSECOLOR16 lpcc16=SEGPTR_ALLOC(sizeof(CHOOSECOLOR16));
3950
3951   memset(lpcc16,'\0',sizeof(*lpcc16));
3952   lpcc16->lStructSize=sizeof(*lpcc16);
3953   lpcc16->hwndOwner=lpChCol->hwndOwner;
3954   lpcc16->hInstance=MapHModuleLS(lpChCol->hInstance);
3955   lpcc16->rgbResult=lpChCol->rgbResult;
3956   memcpy(ccref,lpChCol->lpCustColors,64);
3957   lpcc16->lpCustColors=(COLORREF*)SEGPTR_GET(ccref);
3958   lpcc16->Flags=lpChCol->Flags;
3959   lpcc16->lCustData=lpChCol->lCustData;
3960   lpcc16->lpfnHook=(WNDPROC16)lpChCol->lpfnHook;
3961   if (lpChCol->lpTemplateName)
3962     str = SEGPTR_STRDUP_WtoA(lpChCol->lpTemplateName );
3963   lpcc16->lpTemplateName=SEGPTR_GET(str);
3964
3965   ret = ChooseColor16(lpcc16);
3966   if(str)
3967     SEGPTR_FREE(str);
3968   memcpy(lpChCol->lpCustColors,ccref,64);
3969   SEGPTR_FREE(ccref);
3970   SEGPTR_FREE(lpcc16);
3971   return (BOOL32)ret;
3972 }
3973
3974 /***********************************************************************
3975  *            PageSetupDlgA  (COMDLG32.15)
3976  */
3977 BOOL32 WINAPI PageSetupDlg32A(LPPAGESETUPDLG32A setupdlg) {
3978         FIXME(commdlg,"(%p), stub!\n",setupdlg);
3979         return FALSE;
3980 }