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