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