Update the registry keys of SPI_ICONHORIZONTALSPACING,
[wine] / dlls / commdlg / finddlg32.c
1 /*
2  *  Common Dialog Boxes interface (32 bit)
3  *  Find/Replace
4  *
5  * Copyright 1998,1999 Bertho A. Stultiens
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include <string.h>
23 #include "winbase.h"
24 #include "windef.h"
25 #include "winnls.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "commdlg.h"
29 #include "cderr.h"
30 #include "dlgs.h"
31 #include "wine/debug.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
34
35 #include "cdlg.h"
36
37
38 /*-----------------------------------------------------------------------*/
39
40 static UINT             FindReplaceMessage;
41 static UINT             HelpMessage;
42
43 #define FR_MASK (FR_DOWN | FR_MATCHCASE | FR_WHOLEWORD | FR_REPLACEALL | FR_REPLACE | FR_FINDNEXT | FR_DIALOGTERM)
44 /* CRITICAL_SECTION COMDLG32_CritSect; */
45
46 /* Notes:
47  * MS uses a critical section at a few locations. However, I fail to
48  * see the reason for this. Their comdlg32.dll has a few race conditions
49  * but _not_ at those places that are protected with the mutex (there are
50  * globals that seem to hold info for the wndproc).
51  *
52  * FindText[AW]/ReplaceText[AW]
53  * The find/replace calls are passed a structure that is _not_ used
54  * internally. There is a local copy that holds the running info to
55  * be able to combine xxxA and xxxW calls. The passed pointer is
56  * returned upon sendmessage. Apps wont break this way when they rely
57  * on the original pointer. This will work as long as the sizes of
58  * FINDREPLACEA == FINDREPLACEW. The local copy will also prevent
59  * the app to see the wine-specific extra flags to distinguish between
60  * A/W and Find/Replace.
61  */
62
63
64 /***********************************************************************
65  *      COMDLG32_FR_GetFlags                    [internal]
66  * Returns the button state that needs to be reported to the caller.
67  *      RETURNS
68  *              Current state of check and radio buttons
69  */
70 static DWORD COMDLG32_FR_GetFlags(HWND hDlgWnd)
71 {
72         DWORD flags = 0;
73         if(IsDlgButtonChecked(hDlgWnd, rad2) == BST_CHECKED)
74                 flags |= FR_DOWN;
75         if(IsDlgButtonChecked(hDlgWnd, chx1) == BST_CHECKED)
76                 flags |= FR_WHOLEWORD;
77         if(IsDlgButtonChecked(hDlgWnd, chx2) == BST_CHECKED)
78                 flags |= FR_MATCHCASE;
79         return flags;
80 }
81
82 /***********************************************************************
83  *      COMDLG32_FR_HandleWMCommand             [internal]
84  * Handle WM_COMMAND messages...
85  */
86 static void COMDLG32_FR_HandleWMCommand(HWND hDlgWnd, COMDLG32_FR_Data *pData, int Id, int NotifyCode)
87 {
88         DWORD flag;
89
90         pData->user_fr.fra->Flags &= ~FR_MASK;  /* Clear return flags */
91         if(pData->fr.Flags & FR_WINE_REPLACE)   /* Replace always goes down... */
92                 pData->user_fr.fra->Flags |= FR_DOWN;
93
94         if(NotifyCode == BN_CLICKED)
95         {
96                 switch(Id)
97                 {
98                 case IDOK: /* Find Next */
99                         if(GetDlgItemTextA(hDlgWnd, edt1, pData->fr.lpstrFindWhat, pData->fr.wFindWhatLen) > 0)
100                         {
101                                 pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd) | FR_FINDNEXT;
102                                 if(pData->fr.Flags & FR_WINE_UNICODE)
103                                 {
104                                     MultiByteToWideChar( CP_ACP, 0, pData->fr.lpstrFindWhat, -1,
105                                                          pData->user_fr.frw->lpstrFindWhat,
106                                                          0x7fffffff );
107                                 }
108                                 else
109                                 {
110                                         strcpy(pData->user_fr.fra->lpstrFindWhat, pData->fr.lpstrFindWhat);
111                                 }
112                                 SendMessageA(pData->fr.hwndOwner, FindReplaceMessage, 0, (LPARAM)pData->user_fr.fra);
113                         }
114                         break;
115
116                 case IDCANCEL:
117                         pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd) | FR_DIALOGTERM;
118                         SendMessageA(pData->fr.hwndOwner, FindReplaceMessage, 0, (LPARAM)pData->user_fr.fra);
119                         DestroyWindow(hDlgWnd);
120                         break;
121
122                 case psh2: /* Replace All */
123                         flag = FR_REPLACEALL;
124                         goto Replace;
125
126                 case psh1: /* Replace */
127                         flag = FR_REPLACE;
128 Replace:
129                         if((pData->fr.Flags & FR_WINE_REPLACE)
130                         && GetDlgItemTextA(hDlgWnd, edt1, pData->fr.lpstrFindWhat, pData->fr.wFindWhatLen) > 0)
131                         {
132                                 pData->fr.lpstrReplaceWith[0] = 0; /* In case the next GetDlgItemText Fails */
133                                 GetDlgItemTextA(hDlgWnd, edt2, pData->fr.lpstrReplaceWith, pData->fr.wReplaceWithLen);
134                                 pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd) | flag;
135                                 if(pData->fr.Flags & FR_WINE_UNICODE)
136                                 {
137                                     MultiByteToWideChar( CP_ACP, 0, pData->fr.lpstrFindWhat, -1,
138                                                          pData->user_fr.frw->lpstrFindWhat,
139                                                          0x7fffffff );
140                                     MultiByteToWideChar( CP_ACP, 0, pData->fr.lpstrReplaceWith, -1,
141                                                          pData->user_fr.frw->lpstrReplaceWith,
142                                                          0x7fffffff );
143                                 }
144                                 else
145                                 {
146                                         strcpy(pData->user_fr.fra->lpstrFindWhat, pData->fr.lpstrFindWhat);
147                                         strcpy(pData->user_fr.fra->lpstrReplaceWith, pData->fr.lpstrReplaceWith);
148                                 }
149                                 SendMessageA(pData->fr.hwndOwner, FindReplaceMessage, 0, (LPARAM)pData->user_fr.fra);
150                         }
151                         break;
152
153                 case pshHelp:
154                         pData->user_fr.fra->Flags |= COMDLG32_FR_GetFlags(hDlgWnd);
155                         SendMessageA(pData->fr.hwndOwner, HelpMessage, (WPARAM)hDlgWnd, (LPARAM)pData->user_fr.fra);
156                         break;
157                 }
158         }
159         else if(NotifyCode == EN_CHANGE && Id == edt1)
160         {
161                 BOOL enable = SendDlgItemMessageA(hDlgWnd, edt1, WM_GETTEXTLENGTH, 0, 0) > 0;
162                 EnableWindow(GetDlgItem(hDlgWnd, IDOK), enable);
163                 if(pData->fr.Flags & FR_WINE_REPLACE)
164                 {
165                         EnableWindow(GetDlgItem(hDlgWnd, psh1), enable);
166                         EnableWindow(GetDlgItem(hDlgWnd, psh2), enable);
167                 }
168         }
169 }
170
171 /***********************************************************************
172  *      COMDLG32_FindReplaceDlgProc             [internal]
173  * [Find/Replace]Text32[A/W] window procedure.
174  */
175 static INT_PTR CALLBACK COMDLG32_FindReplaceDlgProc(HWND hDlgWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
176 {
177         COMDLG32_FR_Data *pdata = (COMDLG32_FR_Data *)GetPropA(hDlgWnd, (LPSTR)COMDLG32_Atom);
178         INT_PTR retval = TRUE;
179
180         if(iMsg == WM_INITDIALOG)
181         {
182                 pdata = (COMDLG32_FR_Data *)lParam;
183                 if(!SetPropA(hDlgWnd, (LPSTR)COMDLG32_Atom, (HANDLE)pdata))
184                 {
185                         ERR("Could not Set prop; invent a gracefull exit?...\n");
186                         DestroyWindow(hDlgWnd);
187                         return FALSE;
188                 }
189                 SendDlgItemMessageA(hDlgWnd, edt1, EM_SETLIMITTEXT, (WPARAM)pdata->fr.wFindWhatLen, 0);
190                 SendDlgItemMessageA(hDlgWnd, edt1, WM_SETTEXT, 0, (LPARAM)pdata->fr.lpstrFindWhat);
191                 if(pdata->fr.Flags & FR_WINE_REPLACE)
192                 {
193                         SendDlgItemMessageA(hDlgWnd, edt2, EM_SETLIMITTEXT, (WPARAM)pdata->fr.wReplaceWithLen, 0);
194                         SendDlgItemMessageA(hDlgWnd, edt2, WM_SETTEXT, 0, (LPARAM)pdata->fr.lpstrReplaceWith);
195                 }
196
197                 if(!(pdata->fr.Flags & FR_SHOWHELP))
198                         ShowWindow(GetDlgItem(hDlgWnd, pshHelp), SW_HIDE);
199                 if(pdata->fr.Flags & FR_HIDEUPDOWN)
200                 {
201                         ShowWindow(GetDlgItem(hDlgWnd, rad1), SW_HIDE);
202                         ShowWindow(GetDlgItem(hDlgWnd, rad2), SW_HIDE);
203                         ShowWindow(GetDlgItem(hDlgWnd, grp1), SW_HIDE);
204                 }
205                 else if(pdata->fr.Flags & FR_NOUPDOWN)
206                 {
207                         EnableWindow(GetDlgItem(hDlgWnd, rad1), FALSE);
208                         EnableWindow(GetDlgItem(hDlgWnd, rad2), FALSE);
209                         EnableWindow(GetDlgItem(hDlgWnd, grp1), FALSE);
210                 }
211                 else
212                 {
213                         SendDlgItemMessageA(hDlgWnd, rad1, BM_SETCHECK, pdata->fr.Flags & FR_DOWN ? 0 : BST_CHECKED, 0);
214                         SendDlgItemMessageA(hDlgWnd, rad2, BM_SETCHECK, pdata->fr.Flags & FR_DOWN ? BST_CHECKED : 0, 0);
215                 }
216
217                 if(pdata->fr.Flags & FR_HIDEMATCHCASE)
218                         ShowWindow(GetDlgItem(hDlgWnd, chx2), SW_HIDE);
219                 else if(pdata->fr.Flags & FR_NOMATCHCASE)
220                         EnableWindow(GetDlgItem(hDlgWnd, chx2), FALSE);
221                 else
222                         SendDlgItemMessageA(hDlgWnd, chx2, BM_SETCHECK, pdata->fr.Flags & FR_MATCHCASE ? BST_CHECKED : 0, 0);
223
224                 if(pdata->fr.Flags & FR_HIDEWHOLEWORD)
225                         ShowWindow(GetDlgItem(hDlgWnd, chx1), SW_HIDE);
226                 else if(pdata->fr.Flags & FR_NOWHOLEWORD)
227                         EnableWindow(GetDlgItem(hDlgWnd, chx1), FALSE);
228                 else
229                         SendDlgItemMessageA(hDlgWnd, chx1, BM_SETCHECK, pdata->fr.Flags & FR_WHOLEWORD ? BST_CHECKED : 0, 0);
230
231                 /* We did the init here, now call the hook if requested */
232
233                 /* We do not do ShowWindow if hook exists and is FALSE  */
234                 /*   per MSDN Article Q96135                            */
235                 if((pdata->fr.Flags & FR_ENABLEHOOK)
236                      && ! pdata->fr.lpfnHook(hDlgWnd, iMsg, wParam, (LPARAM) &pdata->fr))
237                         return TRUE;
238                 ShowWindow(hDlgWnd, SW_SHOWNORMAL);
239                 UpdateWindow(hDlgWnd);
240                 return TRUE;
241         }
242
243         if(pdata && (pdata->fr.Flags & FR_ENABLEHOOK))
244         {
245                 retval = pdata->fr.lpfnHook(hDlgWnd, iMsg, wParam, lParam);
246         }
247         else
248                 retval = FALSE;
249
250         if(pdata && !retval)
251         {
252                 retval = TRUE;
253                 switch(iMsg)
254                 {
255                 case WM_COMMAND:
256                         COMDLG32_FR_HandleWMCommand(hDlgWnd, pdata, LOWORD(wParam), HIWORD(wParam));
257                         break;
258
259                 case WM_CLOSE:
260                         COMDLG32_FR_HandleWMCommand(hDlgWnd, pdata, IDCANCEL, BN_CLICKED);
261                         break;
262
263                 case WM_HELP:
264                         /* Heeeeelp! */
265                         FIXME("Got WM_HELP. Who is gonna supply it?\n");
266                         break;
267
268                 case WM_CONTEXTMENU:
269                         /* Heeeeelp! */
270                         FIXME("Got WM_CONTEXTMENU. Who is gonna supply it?\n");
271                         break;
272                 /* FIXME: Handle F1 help */
273
274                 default:
275                         retval = FALSE; /* We did not handle the message */
276                 }
277         }
278
279         /* WM_DESTROY is a special case.
280          * We need to ensure that the allocated memory is freed just before
281          * the dialog is killed. We also need to remove the added prop.
282          */
283         if(iMsg == WM_DESTROY)
284         {
285                 RemovePropA(hDlgWnd, (LPSTR)COMDLG32_Atom);
286                 HeapFree(GetProcessHeap(), 0, pdata);
287         }
288
289         return retval;
290 }
291
292 /***********************************************************************
293  *      COMDLG32_FR_CheckPartial                [internal]
294  * Check various fault conditions in the supplied parameters that
295  * cause an extended error to be reported.
296  *      RETURNS
297  *              TRUE: Success
298  *              FALSE: Failure
299  */
300 static BOOL COMDLG32_FR_CheckPartial(
301         LPFINDREPLACEA pfr,     /* [in] Find structure */
302         BOOL Replace            /* [in] True if called as replace */
303 ) {
304         if(!pfr)
305         {
306                 COMDLG32_SetCommDlgExtendedError(CDERR_GENERALCODES);
307                 return FALSE;
308         }
309
310         if(pfr->lStructSize != sizeof(FINDREPLACEA))
311         {
312                 COMDLG32_SetCommDlgExtendedError(CDERR_STRUCTSIZE);
313                 return FALSE;
314         }
315
316         if(!IsWindow(pfr->hwndOwner))
317         {
318                 COMDLG32_SetCommDlgExtendedError(CDERR_DIALOGFAILURE);
319                 return FALSE;
320         }
321
322         if((pfr->wFindWhatLen < 1 || !pfr->lpstrFindWhat)
323         ||(Replace && (pfr->wReplaceWithLen < 1 || !pfr->lpstrReplaceWith)))
324         {
325                 COMDLG32_SetCommDlgExtendedError(FRERR_BUFFERLENGTHZERO);
326                 return FALSE;
327         }
328
329         if((FindReplaceMessage = RegisterWindowMessageA(FINDMSGSTRINGA)) == 0)
330         {
331                 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
332                 return FALSE;
333         }
334         if((HelpMessage = RegisterWindowMessageA(HELPMSGSTRINGA)) == 0)
335         {
336                 COMDLG32_SetCommDlgExtendedError(CDERR_REGISTERMSGFAIL);
337                 return FALSE;
338         }
339
340         if((pfr->Flags & FR_ENABLEHOOK) && !pfr->lpfnHook)
341         {
342                 COMDLG32_SetCommDlgExtendedError(CDERR_NOHOOK);
343                 return FALSE;
344         }
345
346         if((pfr->Flags & (FR_ENABLETEMPLATE | FR_ENABLETEMPLATEHANDLE)) && !pfr->hInstance)
347         {
348                 COMDLG32_SetCommDlgExtendedError(CDERR_NOHINSTANCE);
349                 return FALSE;
350         }
351
352         if((pfr->Flags & FR_ENABLETEMPLATE) && !pfr->lpTemplateName)
353         {
354                 COMDLG32_SetCommDlgExtendedError(CDERR_NOTEMPLATE);
355                 return FALSE;
356         }
357
358         return TRUE;
359 }
360
361 /***********************************************************************
362  *      COMDLG32_FR_DoFindReplace               [internal]
363  * Actual load and creation of the Find/Replace dialog.
364  *      RETURNS
365  *              Window handle to created dialog:Success
366  *              NULL:Failure
367  */
368 static HWND COMDLG32_FR_DoFindReplace(
369         COMDLG32_FR_Data *pdata /* [in] Internal data structure */
370 ) {
371         HWND hdlgwnd = 0;
372         HGLOBAL loadrc;
373         DWORD error;
374         LPDLGTEMPLATEW rcs;
375
376         TRACE("hInst=%p, Flags=%08lx\n", pdata->fr.hInstance, pdata->fr.Flags);
377
378         if(!(pdata->fr.Flags & FR_ENABLETEMPLATEHANDLE))
379         {
380                 HMODULE hmod = COMDLG32_hInstance;
381                 HRSRC htemplate;
382                 if(pdata->fr.Flags & FR_ENABLETEMPLATE)
383                 {
384                         hmod = (HMODULE)pdata->fr.hInstance;
385                         if(pdata->fr.Flags & FR_WINE_UNICODE)
386                         {
387                                 htemplate = FindResourceW(hmod, (LPWSTR)pdata->fr.lpTemplateName, (LPWSTR)RT_DIALOGA);
388                         }
389                         else
390                         {
391                                 htemplate = FindResourceA(hmod, pdata->fr.lpTemplateName, (LPCSTR)RT_DIALOGA);
392                         }
393                 }
394                 else
395                 {
396                         int rcid = pdata->fr.Flags & FR_WINE_REPLACE ? REPLACEDLGORD
397                                                                      : FINDDLGORD;
398                         htemplate = FindResourceA(hmod, MAKEINTRESOURCEA(rcid), (LPCSTR)RT_DIALOGA);
399                 }
400                 if(!htemplate)
401                 {
402                         error = CDERR_FINDRESFAILURE;
403                         goto cleanup;
404                 }
405
406                 loadrc = LoadResource(hmod, htemplate);
407         }
408         else
409         {
410                 loadrc = (HGLOBAL)pdata->fr.hInstance;
411         }
412
413         if(!loadrc)
414         {
415                 error = CDERR_LOADRESFAILURE;
416                 goto cleanup;
417         }
418
419         if((rcs = (LPDLGTEMPLATEW)LockResource(loadrc)) == NULL)
420         {
421                 error = CDERR_LOCKRESFAILURE;
422                 goto cleanup;
423         }
424
425         hdlgwnd = CreateDialogIndirectParamA(COMDLG32_hInstance,
426                                              rcs,
427                                              pdata->fr.hwndOwner,
428                                              COMDLG32_FindReplaceDlgProc,
429                                              (LPARAM)pdata);
430         if(!hdlgwnd)
431         {
432                 error = CDERR_DIALOGFAILURE;
433 cleanup:
434                 COMDLG32_SetCommDlgExtendedError(error);
435                 HeapFree(GetProcessHeap(), 0, pdata);
436         }
437         return hdlgwnd;
438 }
439
440 /***********************************************************************
441  *      FindTextA                               [COMDLG32.@]
442  *      RETURNS
443  *              Window handle to created dialog: Success
444  *              NULL: Failure
445  */
446 HWND WINAPI FindTextA(
447         LPFINDREPLACEA pfr      /* [in] Find/replace structure*/
448 ) {
449         COMDLG32_FR_Data *pdata;
450
451         TRACE("LPFINDREPLACE=%p\n", pfr);
452
453         if(!COMDLG32_FR_CheckPartial(pfr, FALSE))
454                 return 0;
455
456         if((pdata = (COMDLG32_FR_Data *)COMDLG32_AllocMem(sizeof(COMDLG32_FR_Data))) == NULL)
457                 return 0; /* Error has been set */
458
459         pdata->user_fr.fra = pfr;
460         pdata->fr = *pfr;
461         return COMDLG32_FR_DoFindReplace(pdata);
462 }
463
464 /***********************************************************************
465  *      ReplaceTextA                            [COMDLG32.@]
466  *      RETURNS
467  *              Window handle to created dialog: Success
468  *              NULL: Failure
469  */
470 HWND WINAPI ReplaceTextA(
471         LPFINDREPLACEA pfr      /* [in] Find/replace structure*/
472 ) {
473         COMDLG32_FR_Data *pdata;
474
475         TRACE("LPFINDREPLACE=%p\n", pfr);
476
477         if(!COMDLG32_FR_CheckPartial(pfr, TRUE))
478                 return 0;
479
480         if((pdata = (COMDLG32_FR_Data *)COMDLG32_AllocMem(sizeof(COMDLG32_FR_Data))) == NULL)
481                 return 0; /* Error has been set */
482
483         pdata->user_fr.fra = pfr;
484         pdata->fr = *pfr;
485         pdata->fr.Flags |= FR_WINE_REPLACE;
486         return COMDLG32_FR_DoFindReplace(pdata);
487 }
488
489 /***********************************************************************
490  *      FindTextW                               [COMDLG32.@]
491  *      RETURNS
492  *              Window handle to created dialog: Success
493  *              NULL: Failure
494  */
495 HWND WINAPI FindTextW(
496         LPFINDREPLACEW pfr      /* [in] Find/replace structure*/
497 ) {
498         COMDLG32_FR_Data *pdata;
499         DWORD len;
500
501         TRACE("LPFINDREPLACE=%p\n", pfr);
502
503         if(!COMDLG32_FR_CheckPartial((LPFINDREPLACEA)pfr, FALSE))
504                 return 0;
505
506         len = WideCharToMultiByte( CP_ACP, 0, pfr->lpstrFindWhat, pfr->wFindWhatLen,
507                                    NULL, 0, NULL, NULL );
508         if((pdata = (COMDLG32_FR_Data *)COMDLG32_AllocMem(sizeof(COMDLG32_FR_Data) + len)) == NULL)
509             return 0; /* Error has been set */
510
511         pdata->user_fr.frw = pfr;
512         pdata->fr = *(LPFINDREPLACEA)pfr;       /* FINDREPLACEx have same size */
513         pdata->fr.Flags |= FR_WINE_UNICODE;
514         pdata->fr.lpstrFindWhat = (LPSTR)(pdata + 1);  /* Set string pointer */
515         WideCharToMultiByte( CP_ACP, 0, pfr->lpstrFindWhat, pfr->wFindWhatLen,
516                              pdata->fr.lpstrFindWhat, len, NULL, NULL );
517         return COMDLG32_FR_DoFindReplace(pdata);
518 }
519
520 /***********************************************************************
521  *      ReplaceTextW                            [COMDLG32.@]
522  *      RETURNS
523  *              Window handle to created dialog: Success
524  *              NULL: Failure
525  */
526 HWND WINAPI ReplaceTextW(
527         LPFINDREPLACEW pfr      /* [in] Find/replace structure*/
528 ) {
529         COMDLG32_FR_Data *pdata;
530         DWORD len1, len2;
531
532         TRACE("LPFINDREPLACE=%p\n", pfr);
533
534         if(!COMDLG32_FR_CheckPartial((LPFINDREPLACEA)pfr, FALSE))
535                 return 0;
536
537         len1 = WideCharToMultiByte( CP_ACP, 0, pfr->lpstrFindWhat, pfr->wFindWhatLen,
538                                     NULL, 0, NULL, NULL );
539         len2 = WideCharToMultiByte( CP_ACP, 0, pfr->lpstrReplaceWith, pfr->wReplaceWithLen,
540                                     NULL, 0, NULL, NULL );
541         if((pdata = (COMDLG32_FR_Data *)COMDLG32_AllocMem(sizeof(COMDLG32_FR_Data)
542                                                           + len1 + len2)) == NULL)
543             return 0; /* Error has been set */
544
545         pdata->user_fr.frw = pfr;
546         pdata->fr = *(LPFINDREPLACEA)pfr;       /* FINDREPLACEx have same size */
547         pdata->fr.Flags |= FR_WINE_REPLACE | FR_WINE_UNICODE;
548         pdata->fr.lpstrFindWhat = (LPSTR)(pdata + 1);  /* Set string pointer */
549         pdata->fr.lpstrReplaceWith = pdata->fr.lpstrFindWhat + len1;
550
551         WideCharToMultiByte( CP_ACP, 0, pfr->lpstrFindWhat, pfr->wFindWhatLen,
552                              pdata->fr.lpstrFindWhat, len1, NULL, NULL );
553         WideCharToMultiByte( CP_ACP, 0, pfr->lpstrReplaceWith, pfr->wReplaceWithLen,
554                              pdata->fr.lpstrReplaceWith, len2, NULL, NULL );
555         return COMDLG32_FR_DoFindReplace(pdata);
556 }