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