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