projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Sync with trunk head (part 1 or 2)
[reactos.git] / base / applications / wordpad / wordpad.c
1 /*
2 * Wordpad implementation
3 *
4 * Copyright 2004 by Krzysztof Foltman
5 * Copyright 2007-2008 by Alexander N. Sørnes <alex@thehandofagony.com>
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define WIN32_LEAN_AND_MEAN
23 #define _WIN32_IE 0x0400
24
25 #include <stdarg.h>
26 #include <stdlib.h>
27 #include <ctype.h>
28 #include <stdio.h>
29 #include <assert.h>
30
31 #include <windows.h>
32 #include <richedit.h>
33 #include <commctrl.h>
34 #include <commdlg.h>
35 #include <shellapi.h>
36 #include <math.h>
37 #include <errno.h>
38
39 #include "wine/unicode.h"
40 #include "wordpad.h"
41
42 #ifdef NONAMELESSUNION
43 # define U(x) (x).u
44 # define U2(x) (x).u2
45 # define U3(x) (x).u3
46 #else
47 # define U(x) (x)
48 # define U2(x) (x)
49 # define U3(x) (x)
50 #endif
51
52 /* use LoadString */
53 static const WCHAR wszAppTitle[] = {'W','i','n','e',' ','W','o','r','d','p','a','d',0};
54
55 static const WCHAR wszMainWndClass[] = {'W','O','R','D','P','A','D','T','O','P',0};
56
57 static const WCHAR stringFormat[] = {'%','2','d','\0'};
58
59 const WCHAR wszPreviewWndClass[] = {'P','r','t','P','r','e','v','i','e','w',0};
60 LRESULT CALLBACK preview_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
61
62 static HWND hMainWnd;
63 static HWND hEditorWnd;
64 static HWND hFindWnd;
65 static HMENU hPopupMenu;
66 static HMENU hColorPopupMenu;
67
68 static UINT ID_FINDMSGSTRING;
69
70 static DWORD wordWrap[2];
71 static DWORD barState[2];
72 static WPARAM fileFormat = SF_RTF;
73
74 static WCHAR wszFileName[MAX_PATH];
75 static WCHAR wszFilter[MAX_STRING_LEN*4+6*3+5];
76 static WCHAR wszDefaultFileName[MAX_STRING_LEN];
77 static WCHAR wszSaveChanges[MAX_STRING_LEN];
78 static WCHAR units_cmW[MAX_STRING_LEN];
79
80 static char units_cmA[MAX_STRING_LEN];
81
82 static LRESULT OnSize( HWND hWnd, WPARAM wParam, LPARAM lParam );
83
84 /* Load string resources */
85 static void DoLoadStrings(void)
86 {
87 LPWSTR p = wszFilter;
88 static const WCHAR files_rtf[] = {'*','.','r','t','f','\0'};
89 static const WCHAR files_txt[] = {'*','.','t','x','t','\0'};
90 static const WCHAR files_all[] = {'*','.','*','\0'};
91
92 HINSTANCE hInstance = GetModuleHandleW(0);
93
94 LoadStringW(hInstance, STRING_RICHTEXT_FILES_RTF, p, MAX_STRING_LEN);
95 p += lstrlenW(p) + 1;
96 lstrcpyW(p, files_rtf);
97 p += lstrlenW(p) + 1;
98 LoadStringW(hInstance, STRING_TEXT_FILES_TXT, p, MAX_STRING_LEN);
99 p += lstrlenW(p) + 1;
100 lstrcpyW(p, files_txt);
101 p += lstrlenW(p) + 1;
102 LoadStringW(hInstance, STRING_TEXT_FILES_UNICODE_TXT, p, MAX_STRING_LEN);
103 p += lstrlenW(p) + 1;
104 lstrcpyW(p, files_txt);
105 p += lstrlenW(p) + 1;
106 LoadStringW(hInstance, STRING_ALL_FILES, p, MAX_STRING_LEN);
107 p += lstrlenW(p) + 1;
108 lstrcpyW(p, files_all);
109 p += lstrlenW(p) + 1;
110 *p = '\0';
111
112 p = wszDefaultFileName;
113 LoadStringW(hInstance, STRING_DEFAULT_FILENAME, p, MAX_STRING_LEN);
114
115 p = wszSaveChanges;
116 LoadStringW(hInstance, STRING_PROMPT_SAVE_CHANGES, p, MAX_STRING_LEN);
117
118 LoadStringA(hInstance, STRING_UNITS_CM, units_cmA, MAX_STRING_LEN);
119 LoadStringW(hInstance, STRING_UNITS_CM, units_cmW, MAX_STRING_LEN);
120 }
121
122 /* Show a message box with resource strings */
123 static int MessageBoxWithResStringW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType)
124 {
125 MSGBOXPARAMSW params;
126
127 params.cbSize = sizeof(params);
128 params.hwndOwner = hWnd;
129 params.hInstance = GetModuleHandleW(0);
130 params.lpszText = lpText;
131 params.lpszCaption = lpCaption;
132 params.dwStyle = uType;
133 params.lpszIcon = NULL;
134 params.dwContextHelpId = 0;
135 params.lpfnMsgBoxCallback = NULL;
136 params.dwLanguageId = 0;
137 return MessageBoxIndirectW(&params);
138 }
139
140
141 static void AddButton(HWND hwndToolBar, int nImage, int nCommand)
142 {
143 TBBUTTON button;
144
145 ZeroMemory(&button, sizeof(button));
146 button.iBitmap = nImage;
147 button.idCommand = nCommand;
148 button.fsState = TBSTATE_ENABLED;
149 button.fsStyle = TBSTYLE_BUTTON;
150 button.dwData = 0;
151 button.iString = -1;
152 SendMessageW(hwndToolBar, TB_ADDBUTTONSW, 1, (LPARAM)&button);
153 }
154
155 static void AddSeparator(HWND hwndToolBar)
156 {
157 TBBUTTON button;
158
159 ZeroMemory(&button, sizeof(button));
160 button.iBitmap = -1;
161 button.idCommand = 0;
162 button.fsState = 0;
163 button.fsStyle = TBSTYLE_SEP;
164 button.dwData = 0;
165 button.iString = -1;
166 SendMessageW(hwndToolBar, TB_ADDBUTTONSW, 1, (LPARAM)&button);
167 }
168
169 static DWORD CALLBACK stream_in(DWORD_PTR cookie, LPBYTE buffer, LONG cb, LONG *pcb)
170 {
171 HANDLE hFile = (HANDLE)cookie;
172 DWORD read;
173
174 if(!ReadFile(hFile, buffer, cb, &read, 0))
175 return 1;
176
177 *pcb = read;
178
179 return 0;
180 }
181
182 static DWORD CALLBACK stream_out(DWORD_PTR cookie, LPBYTE buffer, LONG cb, LONG *pcb)
183 {
184 DWORD written;
185 int ret;
186 HANDLE hFile = (HANDLE)cookie;
187
188 ret = WriteFile(hFile, buffer, cb, &written, 0);
189
190 if(!ret || (cb != written))
191 return 1;
192
193 *pcb = cb;
194
195 return 0;
196 }
197
198 LPWSTR file_basename(LPWSTR path)
199 {
200 LPWSTR pos = path + lstrlenW(path);
201
202 while(pos > path)
203 {
204 if(*pos == '\\' || *pos == '/')
205 {
206 pos++;
207 break;
208 }
209 pos--;
210 }
211 return pos;
212 }
213
214 static void set_caption(LPCWSTR wszNewFileName)
215 {
216 static const WCHAR wszSeparator[] = {' ','-',' '};
217 WCHAR *wszCaption;
218 SIZE_T length = 0;
219
220 if(!wszNewFileName)
221 wszNewFileName = wszDefaultFileName;
222 else
223 wszNewFileName = file_basename((LPWSTR)wszNewFileName);
224
225 wszCaption = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
226 lstrlenW(wszNewFileName)*sizeof(WCHAR)+sizeof(wszSeparator)+sizeof(wszAppTitle));
227
228 if(!wszCaption)
229 return;
230
231 memcpy(wszCaption, wszNewFileName, lstrlenW(wszNewFileName)*sizeof(WCHAR));
232 length += lstrlenW(wszNewFileName);
233 memcpy(wszCaption + length, wszSeparator, sizeof(wszSeparator));
234 length += sizeof(wszSeparator) / sizeof(WCHAR);
235 memcpy(wszCaption + length, wszAppTitle, sizeof(wszAppTitle));
236
237 SetWindowTextW(hMainWnd, wszCaption);
238
239 HeapFree(GetProcessHeap(), 0, wszCaption);
240 }
241
242 static BOOL validate_endptr(LPCSTR endptr, BOOL units)
243 {
244 if(!endptr)
245 return FALSE;
246 if(!*endptr)
247 return TRUE;
248
249 while(*endptr == ' ')
250 endptr++;
251
252 if(!units)
253 return *endptr == '\0';
254
255 /* FIXME: Allow other units and convert between them */
256 if(!lstrcmpA(endptr, units_cmA))
257 endptr += 2;
258
259 return *endptr == '\0';
260 }
261
262 static BOOL number_from_string(LPCWSTR string, float *num, BOOL units)
263 {
264 double ret;
265 char buffer[MAX_STRING_LEN];
266 char *endptr = buffer;
267
268 WideCharToMultiByte(CP_ACP, 0, string, -1, buffer, MAX_STRING_LEN, NULL, NULL);
269 *num = 0;
270 errno = 0;
271 ret = strtod(buffer, &endptr);
272
273 if((ret == 0 && errno != 0) || endptr == buffer || !validate_endptr(endptr, units))
274 {
275 return FALSE;
276 } else
277 {
278 *num = (float)ret;
279 return TRUE;
280 }
281 }
282
283 static void set_size(float size)
284 {
285 CHARFORMAT2W fmt;
286
287 ZeroMemory(&fmt, sizeof(fmt));
288 fmt.cbSize = sizeof(fmt);
289 fmt.dwMask = CFM_SIZE;
290 fmt.yHeight = (int)(size * 20.0);
291 SendMessageW(hEditorWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
292 }
293
294 static void on_sizelist_modified(HWND hwndSizeList, LPWSTR wszNewFontSize)
295 {
296 WCHAR sizeBuffer[MAX_STRING_LEN];
297 CHARFORMAT2W format;
298
299 ZeroMemory(&format, sizeof(format));
300 format.cbSize = sizeof(format);
301 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
302
303 wsprintfW(sizeBuffer, stringFormat, format.yHeight / 20);
304 if(lstrcmpW(sizeBuffer, wszNewFontSize))
305 {
306 float size = 0;
307 if(number_from_string(wszNewFontSize, &size, FALSE)
308 && size > 0)
309 {
310 set_size(size);
311 } else
312 {
313 SetWindowTextW(hwndSizeList, sizeBuffer);
314 MessageBoxWithResStringW(hMainWnd, MAKEINTRESOURCEW(STRING_INVALID_NUMBER),
315 wszAppTitle, MB_OK | MB_ICONINFORMATION);
316 }
317 }
318 }
319
320 static void add_size(HWND hSizeListWnd, unsigned size)
321 {
322 WCHAR buffer[3];
323 COMBOBOXEXITEMW cbItem;
324 cbItem.mask = CBEIF_TEXT;
325 cbItem.iItem = -1;
326
327 wsprintfW(buffer, stringFormat, size);
328 cbItem.pszText = buffer;
329 SendMessageW(hSizeListWnd, CBEM_INSERTITEMW, 0, (LPARAM)&cbItem);
330 }
331
332 static void populate_size_list(HWND hSizeListWnd)
333 {
334 HWND hReBarWnd = GetDlgItem(hMainWnd, IDC_REBAR);
335 HWND hFontListWnd = GetDlgItem(hReBarWnd, IDC_FONTLIST);
336 COMBOBOXEXITEMW cbFontItem;
337 CHARFORMAT2W fmt;
338 HWND hListEditWnd = (HWND)SendMessageW(hSizeListWnd, CBEM_GETEDITCONTROL, 0, 0);
339 HDC hdc = GetDC(hMainWnd);
340 static const unsigned choices[] = {8,9,10,11,12,14,16,18,20,22,24,26,28,36,48,72};
341 WCHAR buffer[3];
342 size_t i;
343 DWORD fontStyle;
344
345 ZeroMemory(&fmt, sizeof(fmt));
346 fmt.cbSize = sizeof(fmt);
347 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
348
349 cbFontItem.mask = CBEIF_LPARAM;
350 cbFontItem.iItem = SendMessageW(hFontListWnd, CB_FINDSTRINGEXACT, -1, (LPARAM)fmt.szFaceName);
351 SendMessageW(hFontListWnd, CBEM_GETITEMW, 0, (LPARAM)&cbFontItem);
352
353 fontStyle = (DWORD)LOWORD(cbFontItem.lParam);
354
355 SendMessageW(hSizeListWnd, CB_RESETCONTENT, 0, 0);
356
357 if((fontStyle & RASTER_FONTTYPE) && cbFontItem.iItem)
358 {
359 add_size(hSizeListWnd, (BYTE)MulDiv(HIWORD(cbFontItem.lParam), 72,
360 GetDeviceCaps(hdc, LOGPIXELSY)));
361 } else
362 {
363 for(i = 0; i < sizeof(choices)/sizeof(choices[0]); i++)
364 add_size(hSizeListWnd, choices[i]);
365 }
366
367 wsprintfW(buffer, stringFormat, fmt.yHeight / 20);
368 SendMessageW(hListEditWnd, WM_SETTEXT, 0, (LPARAM)buffer);
369 }
370
371 static void update_size_list(void)
372 {
373 HWND hReBar = GetDlgItem(hMainWnd, IDC_REBAR);
374 HWND hwndSizeList = GetDlgItem(hReBar, IDC_SIZELIST);
375 HWND hwndSizeListEdit = (HWND)SendMessageW(hwndSizeList, CBEM_GETEDITCONTROL, 0, 0);
376 WCHAR fontSize[MAX_STRING_LEN], sizeBuffer[MAX_STRING_LEN];
377 CHARFORMAT2W fmt;
378
379 ZeroMemory(&fmt, sizeof(fmt));
380 fmt.cbSize = sizeof(fmt);
381
382 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
383
384 SendMessageW(hwndSizeListEdit, WM_GETTEXT, MAX_PATH, (LPARAM)fontSize);
385 wsprintfW(sizeBuffer, stringFormat, fmt.yHeight / 20);
386
387 if(lstrcmpW(fontSize, sizeBuffer))
388 SendMessageW(hwndSizeListEdit, WM_SETTEXT, 0, (LPARAM)sizeBuffer);
389 }
390
391 static void update_font_list(void)
392 {
393 HWND hReBar = GetDlgItem(hMainWnd, IDC_REBAR);
394 HWND hFontList = GetDlgItem(hReBar, IDC_FONTLIST);
395 HWND hFontListEdit = (HWND)SendMessageW(hFontList, CBEM_GETEDITCONTROL, 0, 0);
396 WCHAR fontName[MAX_STRING_LEN];
397 CHARFORMAT2W fmt;
398
399 ZeroMemory(&fmt, sizeof(fmt));
400 fmt.cbSize = sizeof(fmt);
401
402 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
403 if (!SendMessageW(hFontListEdit, WM_GETTEXT, MAX_PATH, (LPARAM)fontName)) return;
404
405 if(lstrcmpW(fontName, fmt.szFaceName))
406 {
407 SendMessageW(hFontListEdit, WM_SETTEXT, 0, (LPARAM)fmt.szFaceName);
408 populate_size_list(GetDlgItem(hReBar, IDC_SIZELIST));
409 } else
410 {
411 update_size_list();
412 }
413 }
414
415 static void clear_formatting(void)
416 {
417 PARAFORMAT2 pf;
418
419 pf.cbSize = sizeof(pf);
420 pf.dwMask = PFM_ALIGNMENT;
421 pf.wAlignment = PFA_LEFT;
422 SendMessageW(hEditorWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
423 }
424
425 static int fileformat_number(WPARAM format)
426 {
427 int number = 0;
428
429 if(format == SF_TEXT)
430 {
431 number = 1;
432 } else if (format == (SF_TEXT | SF_UNICODE))
433 {
434 number = 2;
435 }
436 return number;
437 }
438
439 static WPARAM fileformat_flags(int format)
440 {
441 WPARAM flags[] = { SF_RTF , SF_TEXT , SF_TEXT | SF_UNICODE };
442
443 return flags[format];
444 }
445
446 static void set_font(LPCWSTR wszFaceName)
447 {
448 HWND hReBarWnd = GetDlgItem(hMainWnd, IDC_REBAR);
449 HWND hSizeListWnd = GetDlgItem(hReBarWnd, IDC_SIZELIST);
450 HWND hFontListWnd = GetDlgItem(hReBarWnd, IDC_FONTLIST);
451 HWND hFontListEditWnd = (HWND)SendMessageW(hFontListWnd, CBEM_GETEDITCONTROL, 0, 0);
452 CHARFORMAT2W fmt;
453
454 ZeroMemory(&fmt, sizeof(fmt));
455
456 fmt.cbSize = sizeof(fmt);
457 fmt.dwMask = CFM_FACE;
458
459 lstrcpyW(fmt.szFaceName, wszFaceName);
460
461 SendMessageW(hEditorWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
462
463 populate_size_list(hSizeListWnd);
464
465 SendMessageW(hFontListEditWnd, WM_SETTEXT, 0, (LPARAM)wszFaceName);
466 }
467
468 static void set_default_font(void)
469 {
470 static const WCHAR richTextFont[] = {'T','i','m','e','s',' ','N','e','w',' ',
471 'R','o','m','a','n',0};
472 static const WCHAR plainTextFont[] = {'C','o','u','r','i','e','r',' ','N','e','w',0};
473 CHARFORMAT2W fmt;
474 LPCWSTR font;
475
476 ZeroMemory(&fmt, sizeof(fmt));
477
478 fmt.cbSize = sizeof(fmt);
479 fmt.dwMask = CFM_FACE | CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE;
480 fmt.dwEffects = 0;
481
482 if(fileFormat & SF_RTF)
483 font = richTextFont;
484 else
485 font = plainTextFont;
486
487 lstrcpyW(fmt.szFaceName, font);
488
489 SendMessageW(hEditorWnd, EM_SETCHARFORMAT, SCF_DEFAULT, (LPARAM)&fmt);
490 }
491
492 static void on_fontlist_modified(LPWSTR wszNewFaceName)
493 {
494 CHARFORMAT2W format;
495 ZeroMemory(&format, sizeof(format));
496 format.cbSize = sizeof(format);
497 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&format);
498
499 if(lstrcmpW(format.szFaceName, wszNewFaceName))
500 set_font(wszNewFaceName);
501 }
502
503 static void add_font(LPCWSTR fontName, DWORD fontType, HWND hListWnd, const NEWTEXTMETRICEXW *ntmc)
504 {
505 COMBOBOXEXITEMW cbItem;
506 WCHAR buffer[MAX_PATH];
507 int fontHeight = 0;
508
509 cbItem.mask = CBEIF_TEXT;
510 cbItem.pszText = buffer;
511 cbItem.cchTextMax = MAX_STRING_LEN;
512 cbItem.iItem = 0;
513
514 while(SendMessageW(hListWnd, CBEM_GETITEMW, 0, (LPARAM)&cbItem))
515 {
516 if(lstrcmpiW(cbItem.pszText, fontName) <= 0)
517 cbItem.iItem++;
518 else
519 break;
520 }
521 cbItem.pszText = HeapAlloc( GetProcessHeap(), 0, (lstrlenW(fontName) + 1)*sizeof(WCHAR) );
522 lstrcpyW( cbItem.pszText, fontName );
523
524 cbItem.mask |= CBEIF_LPARAM;
525 if(fontType & RASTER_FONTTYPE)
526 fontHeight = ntmc->ntmTm.tmHeight - ntmc->ntmTm.tmInternalLeading;
527
528 cbItem.lParam = MAKELONG(fontType,fontHeight);
529 SendMessageW(hListWnd, CBEM_INSERTITEMW, 0, (LPARAM)&cbItem);
530 HeapFree( GetProcessHeap(), 0, cbItem.pszText );
531 }
532
533 static void dialog_choose_font(void)
534 {
535 CHOOSEFONTW cf;
536 LOGFONTW lf;
537 CHARFORMAT2W fmt;
538 HDC hDC = GetDC(hMainWnd);
539
540 ZeroMemory(&cf, sizeof(cf));
541 cf.lStructSize = sizeof(cf);
542 cf.hwndOwner = hMainWnd;
543 cf.lpLogFont = &lf;
544 cf.Flags = CF_SCREENFONTS | CF_NOSCRIPTSEL | CF_INITTOLOGFONTSTRUCT | CF_EFFECTS;
545
546 ZeroMemory(&fmt, sizeof(fmt));
547 fmt.cbSize = sizeof(fmt);
548
549 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
550 lstrcpyW(cf.lpLogFont->lfFaceName, fmt.szFaceName);
551 cf.lpLogFont->lfItalic = (fmt.dwEffects & CFE_ITALIC) ? TRUE : FALSE;
552 cf.lpLogFont->lfWeight = (fmt.dwEffects & CFE_BOLD) ? FW_BOLD : FW_NORMAL;
553 cf.lpLogFont->lfUnderline = (fmt.dwEffects & CFE_UNDERLINE) ? TRUE : FALSE;
554 cf.lpLogFont->lfStrikeOut = (fmt.dwEffects & CFE_STRIKEOUT) ? TRUE : FALSE;
555 cf.lpLogFont->lfHeight = -MulDiv(fmt.yHeight / 20, GetDeviceCaps(hDC, LOGPIXELSY), 72);
556 cf.rgbColors = fmt.crTextColor;
557
558 if(ChooseFontW(&cf))
559 {
560 ZeroMemory(&fmt, sizeof(fmt));
561 fmt.cbSize = sizeof(fmt);
562 fmt.dwMask = CFM_BOLD | CFM_ITALIC | CFM_SIZE | CFM_UNDERLINE | CFM_STRIKEOUT | CFM_COLOR;
563 fmt.yHeight = cf.iPointSize * 2;
564
565 if(cf.nFontType & BOLD_FONTTYPE)
566 fmt.dwEffects |= CFE_BOLD;
567 if(cf.nFontType & ITALIC_FONTTYPE)
568 fmt.dwEffects |= CFE_ITALIC;
569 if(cf.lpLogFont->lfUnderline == TRUE)
570 fmt.dwEffects |= CFE_UNDERLINE;
571 if(cf.lpLogFont->lfStrikeOut == TRUE)
572 fmt.dwEffects |= CFE_STRIKEOUT;
573
574 fmt.crTextColor = cf.rgbColors;
575
576 SendMessageW(hEditorWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
577 set_font(cf.lpLogFont->lfFaceName);
578 }
579 }
580
581
582 static int CALLBACK enum_font_proc(const LOGFONTW *lpelfe, const TEXTMETRICW *lpntme,
583 DWORD FontType, LPARAM lParam)
584 {
585 HWND hListWnd = (HWND) lParam;
586
587 if(SendMessageW(hListWnd, CB_FINDSTRINGEXACT, -1, (LPARAM)lpelfe->lfFaceName) == CB_ERR)
588 {
589
590 add_font(lpelfe->lfFaceName, FontType, hListWnd, (const NEWTEXTMETRICEXW*)lpntme);
591 }
592
593 return 1;
594 }
595
596 static void populate_font_list(HWND hListWnd)
597 {
598 HDC hdc = GetDC(hMainWnd);
599 LOGFONTW fontinfo;
600 HWND hListEditWnd = (HWND)SendMessageW(hListWnd, CBEM_GETEDITCONTROL, 0, 0);
601 CHARFORMAT2W fmt;
602
603 fontinfo.lfCharSet = DEFAULT_CHARSET;
604 *fontinfo.lfFaceName = '\0';
605 fontinfo.lfPitchAndFamily = 0;
606
607 EnumFontFamiliesExW(hdc, &fontinfo, enum_font_proc,
608 (LPARAM)hListWnd, 0);
609
610 ZeroMemory(&fmt, sizeof(fmt));
611 fmt.cbSize = sizeof(fmt);
612 SendMessageW(hEditorWnd, EM_GETCHARFORMAT, SCF_DEFAULT, (LPARAM)&fmt);
613 SendMessageW(hListEditWnd, WM_SETTEXT, 0, (LPARAM)fmt.szFaceName);
614 }
615
616 static void update_window(void)
617 {
618 RECT rect;
619
620 GetClientRect(hMainWnd, &rect);
621
622 OnSize(hMainWnd, SIZE_RESTORED, MAKELPARAM(rect.right, rect.bottom));
623 }
624
625 static BOOL is_bar_visible(int bandId)
626 {
627 return barState[reg_formatindex(fileFormat)] & (1 << bandId);
628 }
629
630 static void store_bar_state(int bandId, BOOL show)
631 {
632 int formatIndex = reg_formatindex(fileFormat);
633
634 if(show)
635 barState[formatIndex] |= (1 << bandId);
636 else
637 barState[formatIndex] &= ~(1 << bandId);
638 }
639
640 static void set_toolbar_state(int bandId, BOOL show)
641 {
642 HWND hwndReBar = GetDlgItem(hMainWnd, IDC_REBAR);
643
644 SendMessageW(hwndReBar, RB_SHOWBAND, SendMessageW(hwndReBar, RB_IDTOINDEX, bandId, 0), show);
645
646 if(bandId == BANDID_TOOLBAR)
647 {
648 REBARBANDINFOW rbbinfo;
649 int index = SendMessageW(hwndReBar, RB_IDTOINDEX, BANDID_FONTLIST, 0);
650
651 rbbinfo.cbSize = REBARBANDINFOW_V6_SIZE;
652 rbbinfo.fMask = RBBIM_STYLE;
653
654 SendMessageW(hwndReBar, RB_GETBANDINFO, index, (LPARAM)&rbbinfo);
655
656 if(!show)
657 rbbinfo.fStyle &= ~RBBS_BREAK;
658 else
659 rbbinfo.fStyle |= RBBS_BREAK;
660
661 SendMessageW(hwndReBar, RB_SETBANDINFO, index, (LPARAM)&rbbinfo);
662 }
663
664 if(bandId == BANDID_TOOLBAR || bandId == BANDID_FORMATBAR || bandId == BANDID_RULER)
665 store_bar_state(bandId, show);
666 }
667
668 static void set_statusbar_state(BOOL show)
669 {
670 HWND hStatusWnd = GetDlgItem(hMainWnd, IDC_STATUSBAR);
671
672 ShowWindow(hStatusWnd, show ? SW_SHOW : SW_HIDE);
673 store_bar_state(BANDID_STATUSBAR, show);
674 }
675
676 static void set_bar_states(void)
677 {
678 set_toolbar_state(BANDID_TOOLBAR, is_bar_visible(BANDID_TOOLBAR));
679 set_toolbar_state(BANDID_FONTLIST, is_bar_visible(BANDID_FORMATBAR));
680 set_toolbar_state(BANDID_SIZELIST, is_bar_visible(BANDID_FORMATBAR));
681 set_toolbar_state(BANDID_FORMATBAR, is_bar_visible(BANDID_FORMATBAR));
682 set_toolbar_state(BANDID_RULER, is_bar_visible(BANDID_RULER));
683 set_statusbar_state(is_bar_visible(BANDID_STATUSBAR));
684
685 update_window();
686 }
687
688 static void preview_exit(HWND hMainWnd)
689 {
690 HMENU hMenu = LoadMenuW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDM_MAINMENU));
691 HWND hEditorWnd = GetDlgItem(hMainWnd, IDC_EDITOR);
692
693 set_bar_states();
694 ShowWindow(hEditorWnd, TRUE);
695
696 close_preview(hMainWnd);
697
698 SetMenu(hMainWnd, hMenu);
699 registry_read_filelist(hMainWnd);
700
701 update_window();
702 }
703
704 static void set_fileformat(WPARAM format)
705 {
706 HICON hIcon;
707 HINSTANCE hInstance = GetModuleHandleW(0);
708 fileFormat = format;
709
710 if(format & SF_TEXT)
711 hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_TXT));
712 else
713 hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_RTF));
714
715 SendMessageW(hMainWnd, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
716
717 set_bar_states();
718 set_default_font();
719 target_device(hMainWnd, wordWrap[reg_formatindex(fileFormat)]);
720 }
721
722 static void ShowOpenError(DWORD Code)
723 {
724 LPWSTR Message;
725
726 switch(Code)
727 {
728 case ERROR_ACCESS_DENIED:
729 Message = MAKEINTRESOURCEW(STRING_OPEN_ACCESS_DENIED);
730 break;
731
732 default:
733 Message = MAKEINTRESOURCEW(STRING_OPEN_FAILED);
734 }
735 MessageBoxW(hMainWnd, Message, wszAppTitle, MB_ICONEXCLAMATION | MB_OK);
736 }
737
738 static void DoOpenFile(LPCWSTR szOpenFileName)
739 {
740 HANDLE hFile;
741 EDITSTREAM es;
742 char fileStart[5];
743 DWORD readOut;
744 WPARAM format = SF_TEXT;
745
746 hFile = CreateFileW(szOpenFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
747 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
748 if (hFile == INVALID_HANDLE_VALUE)
749 {
750 ShowOpenError(GetLastError());
751 return;
752 }
753
754 ReadFile(hFile, fileStart, 5, &readOut, NULL);
755 SetFilePointer(hFile, 0, NULL, FILE_BEGIN);
756
757 if(readOut >= 2 && (BYTE)fileStart[0] == 0xff && (BYTE)fileStart[1] == 0xfe)
758 {
759 format = SF_TEXT | SF_UNICODE;
760 SetFilePointer(hFile, 2, NULL, FILE_BEGIN);
761 } else if(readOut >= 5)
762 {
763 static const char header[] = "{\\rtf";
764 static const BYTE STG_magic[] = { 0xd0,0xcf,0x11,0xe0 };
765
766 if(!memcmp(header, fileStart, 5))
767 format = SF_RTF;
768 else if (!memcmp(STG_magic, fileStart, sizeof(STG_magic)))
769 {
770 CloseHandle(hFile);
771 MessageBoxWithResStringW(hMainWnd, MAKEINTRESOURCEW(STRING_OLE_STORAGE_NOT_SUPPORTED),
772 wszAppTitle, MB_OK | MB_ICONEXCLAMATION);
773 return;
774 }
775 }
776
777 es.dwCookie = (DWORD_PTR)hFile;
778 es.pfnCallback = stream_in;
779
780 clear_formatting();
781 set_fileformat(format);
782 SendMessageW(hEditorWnd, EM_STREAMIN, format, (LPARAM)&es);
783
784 CloseHandle(hFile);
785
786 SetFocus(hEditorWnd);
787
788 set_caption(szOpenFileName);
789
790 lstrcpyW(wszFileName, szOpenFileName);
791 SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
792 registry_set_filelist(szOpenFileName, hMainWnd);
793 update_font_list();
794 }
795
796 static void ShowWriteError(DWORD Code)
797 {
798 LPWSTR Message;
799
800 switch(Code)
801 {
802 case ERROR_ACCESS_DENIED:
803 Message = MAKEINTRESOURCEW(STRING_WRITE_ACCESS_DENIED);
804 break;
805
806 default:
807 Message = MAKEINTRESOURCEW(STRING_WRITE_FAILED);
808 }
809 MessageBoxW(hMainWnd, Message, wszAppTitle, MB_ICONEXCLAMATION | MB_OK);
810 }
811
812 static void DoSaveFile(LPCWSTR wszSaveFileName, WPARAM format)
813 {
814 HANDLE hFile;
815 EDITSTREAM stream;
816 LRESULT ret;
817
818 hFile = CreateFileW(wszSaveFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
819 FILE_ATTRIBUTE_NORMAL, NULL);
820
821 if(hFile == INVALID_HANDLE_VALUE)
822 {
823 ShowWriteError(GetLastError());
824 return;
825 }
826
827 if(format == (SF_TEXT | SF_UNICODE))
828 {
829 static const BYTE unicode[] = {0xff,0xfe};
830 DWORD writeOut;
831 WriteFile(hFile, &unicode, sizeof(unicode), &writeOut, 0);
832
833 if(writeOut != sizeof(unicode))
834 {
835 CloseHandle(hFile);
836 return;
837 }
838 }
839
840 stream.dwCookie = (DWORD_PTR)hFile;
841 stream.pfnCallback = stream_out;
842
843 ret = SendMessageW(hEditorWnd, EM_STREAMOUT, format, (LPARAM)&stream);
844
845 CloseHandle(hFile);
846
847 SetFocus(hEditorWnd);
848
849 if(!ret)
850 {
851 GETTEXTLENGTHEX gt;
852 gt.flags = GTL_DEFAULT;
853 gt.codepage = 1200;
854
855 if(SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0))
856 return;
857 }
858
859 lstrcpyW(wszFileName, wszSaveFileName);
860 set_caption(wszFileName);
861 SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
862 set_fileformat(format);
863 }
864
865 static void DialogSaveFile(void)
866 {
867 OPENFILENAMEW sfn;
868
869 WCHAR wszFile[MAX_PATH] = {'\0'};
870 static const WCHAR wszDefExt[] = {'r','t','f','\0'};
871
872 ZeroMemory(&sfn, sizeof(sfn));
873
874 sfn.lStructSize = sizeof(sfn);
875 sfn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_ENABLESIZING;
876 sfn.hwndOwner = hMainWnd;
877 sfn.lpstrFilter = wszFilter;
878 sfn.lpstrFile = wszFile;
879 sfn.nMaxFile = MAX_PATH;
880 sfn.lpstrDefExt = wszDefExt;
881 sfn.nFilterIndex = fileformat_number(fileFormat)+1;
882
883 while(GetSaveFileNameW(&sfn))
884 {
885 if(fileformat_flags(sfn.nFilterIndex-1) != SF_RTF)
886 {
887 if(MessageBoxWithResStringW(hMainWnd, MAKEINTRESOURCEW(STRING_SAVE_LOSEFORMATTING),
888 wszAppTitle, MB_YESNO | MB_ICONEXCLAMATION) != IDYES)
889 {
890 continue;
891 } else
892 {
893 DoSaveFile(sfn.lpstrFile, fileformat_flags(sfn.nFilterIndex-1));
894 break;
895 }
896 } else
897 {
898 DoSaveFile(sfn.lpstrFile, fileformat_flags(sfn.nFilterIndex-1));
899 break;
900 }
901 }
902 }
903
904 static BOOL prompt_save_changes(void)
905 {
906 if(!wszFileName[0])
907 {
908 GETTEXTLENGTHEX gt;
909 gt.flags = GTL_NUMCHARS;
910 gt.codepage = 1200;
911 if(!SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0))
912 return TRUE;
913 }
914
915 if(!SendMessageW(hEditorWnd, EM_GETMODIFY, 0, 0))
916 {
917 return TRUE;
918 } else
919 {
920 LPWSTR displayFileName;
921 WCHAR *text;
922 int ret;
923
924 if(!wszFileName[0])
925 displayFileName = wszDefaultFileName;
926 else
927 displayFileName = file_basename(wszFileName);
928
929 text = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
930 (lstrlenW(displayFileName)+lstrlenW(wszSaveChanges))*sizeof(WCHAR));
931
932 if(!text)
933 return FALSE;
934
935 wsprintfW(text, wszSaveChanges, displayFileName);
936
937 ret = MessageBoxW(hMainWnd, text, wszAppTitle, MB_YESNOCANCEL | MB_ICONEXCLAMATION);
938
939 HeapFree(GetProcessHeap(), 0, text);
940
941 switch(ret)
942 {
943 case IDNO:
944 return TRUE;
945
946 case IDYES:
947 if(wszFileName[0])
948 DoSaveFile(wszFileName, fileFormat);
949 else
950 DialogSaveFile();
951 return TRUE;
952
953 default:
954 return FALSE;
955 }
956 }
957 }
958
959 static void DialogOpenFile(void)
960 {
961 OPENFILENAMEW ofn;
962
963 WCHAR wszFile[MAX_PATH] = {'\0'};
964 static const WCHAR wszDefExt[] = {'r','t','f','\0'};
965
966 ZeroMemory(&ofn, sizeof(ofn));
967
968 ofn.lStructSize = sizeof(ofn);
969 ofn.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_ENABLESIZING;
970 ofn.hwndOwner = hMainWnd;
971 ofn.lpstrFilter = wszFilter;
972 ofn.lpstrFile = wszFile;
973 ofn.nMaxFile = MAX_PATH;
974 ofn.lpstrDefExt = wszDefExt;
975 ofn.nFilterIndex = fileformat_number(fileFormat)+1;
976
977 if(GetOpenFileNameW(&ofn))
978 {
979 if(prompt_save_changes())
980 DoOpenFile(ofn.lpstrFile);
981 }
982 }
983
984 static void dialog_about(void)
985 {
986 HICON icon = LoadImageW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDI_WORDPAD), IMAGE_ICON, 48, 48, LR_SHARED);
987 ShellAboutW(hMainWnd, wszAppTitle, 0, icon);
988 }
989
990 static INT_PTR CALLBACK formatopts_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
991 {
992 switch(message)
993 {
994 case WM_INITDIALOG:
995 {
996 LPPROPSHEETPAGEW ps = (LPPROPSHEETPAGEW)lParam;
997 int wrap = -1;
998 char id[4];
999 HWND hIdWnd = GetDlgItem(hWnd, IDC_PAGEFMT_ID);
1000
1001 sprintf(id, "%d\n", (int)ps->lParam);
1002 SetWindowTextA(hIdWnd, id);
1003 if(wordWrap[ps->lParam] == ID_WORDWRAP_NONE)
1004 wrap = IDC_PAGEFMT_WN;
1005 else if(wordWrap[ps->lParam] == ID_WORDWRAP_WINDOW)
1006 wrap = IDC_PAGEFMT_WW;
1007 else if(wordWrap[ps->lParam] == ID_WORDWRAP_MARGIN)
1008 wrap = IDC_PAGEFMT_WM;
1009
1010 if(wrap != -1)
1011 CheckRadioButton(hWnd, IDC_PAGEFMT_WN,
1012 IDC_PAGEFMT_WM, wrap);
1013
1014 if(barState[ps->lParam] & (1 << BANDID_TOOLBAR))
1015 CheckDlgButton(hWnd, IDC_PAGEFMT_TB, TRUE);
1016 if(barState[ps->lParam] & (1 << BANDID_FORMATBAR))
1017 CheckDlgButton(hWnd, IDC_PAGEFMT_FB, TRUE);
1018 if(barState[ps->lParam] & (1 << BANDID_RULER))
1019 CheckDlgButton(hWnd, IDC_PAGEFMT_RU, TRUE);
1020 if(barState[ps->lParam] & (1 << BANDID_STATUSBAR))
1021 CheckDlgButton(hWnd, IDC_PAGEFMT_SB, TRUE);
1022 }
1023 break;
1024
1025 case WM_COMMAND:
1026 switch(LOWORD(wParam))
1027 {
1028 case IDC_PAGEFMT_WN:
1029 case IDC_PAGEFMT_WW:
1030 case IDC_PAGEFMT_WM:
1031 CheckRadioButton(hWnd, IDC_PAGEFMT_WN, IDC_PAGEFMT_WM,
1032 LOWORD(wParam));
1033 break;
1034
1035 case IDC_PAGEFMT_TB:
1036 case IDC_PAGEFMT_FB:
1037 case IDC_PAGEFMT_RU:
1038 case IDC_PAGEFMT_SB:
1039 CheckDlgButton(hWnd, LOWORD(wParam),
1040 !IsDlgButtonChecked(hWnd, LOWORD(wParam)));
1041 break;
1042 }
1043 break;
1044 case WM_NOTIFY:
1045 {
1046 LPNMHDR header = (LPNMHDR)lParam;
1047 if(header->code == PSN_APPLY)
1048 {
1049 HWND hIdWnd = GetDlgItem(hWnd, IDC_PAGEFMT_ID);
1050 char sid[4];
1051 int id;
1052
1053 GetWindowTextA(hIdWnd, sid, 4);
1054 id = atoi(sid);
1055 if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_WN))
1056 wordWrap[id] = ID_WORDWRAP_NONE;
1057 else if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_WW))
1058 wordWrap[id] = ID_WORDWRAP_WINDOW;
1059 else if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_WM))
1060 wordWrap[id] = ID_WORDWRAP_MARGIN;
1061
1062 if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_TB))
1063 barState[id] |= (1 << BANDID_TOOLBAR);
1064 else
1065 barState[id] &= ~(1 << BANDID_TOOLBAR);
1066
1067 if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_FB))
1068 barState[id] |= (1 << BANDID_FORMATBAR);
1069 else
1070 barState[id] &= ~(1 << BANDID_FORMATBAR);
1071
1072 if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_RU))
1073 barState[id] |= (1 << BANDID_RULER);
1074 else
1075 barState[id] &= ~(1 << BANDID_RULER);
1076
1077 if(IsDlgButtonChecked(hWnd, IDC_PAGEFMT_SB))
1078 barState[id] |= (1 << BANDID_STATUSBAR);
1079 else
1080 barState[id] &= ~(1 << BANDID_STATUSBAR);
1081 }
1082 }
1083 break;
1084 }
1085 return FALSE;
1086 }
1087
1088 static void dialog_viewproperties(void)
1089 {
1090 PROPSHEETPAGEW psp[2];
1091 PROPSHEETHEADERW psh;
1092 size_t i;
1093 HINSTANCE hInstance = GetModuleHandleW(0);
1094 LPCPROPSHEETPAGEW ppsp = (LPCPROPSHEETPAGEW)&psp;
1095
1096 psp[0].dwSize = sizeof(PROPSHEETPAGEW);
1097 psp[0].dwFlags = PSP_USETITLE;
1098 U(psp[0]).pszTemplate = MAKEINTRESOURCEW(IDD_FORMATOPTS);
1099 psp[0].pfnDlgProc = formatopts_proc;
1100 psp[0].hInstance = hInstance;
1101 psp[0].lParam = reg_formatindex(SF_TEXT);
1102 psp[0].pfnCallback = NULL;
1103 psp[0].pszTitle = MAKEINTRESOURCEW(STRING_VIEWPROPS_TEXT);
1104 for(i = 1; i < sizeof(psp)/sizeof(psp[0]); i++)
1105 {
1106 psp[i].dwSize = psp[0].dwSize;
1107 psp[i].dwFlags = psp[0].dwFlags;
1108 U(psp[i]).pszTemplate = U(psp[0]).pszTemplate;
1109 psp[i].pfnDlgProc = psp[0].pfnDlgProc;
1110 psp[i].hInstance = psp[0].hInstance;
1111 psp[i].lParam = reg_formatindex(SF_RTF);
1112 psp[i].pfnCallback = psp[0].pfnCallback;
1113 psp[i].pszTitle = MAKEINTRESOURCEW(STRING_VIEWPROPS_RICHTEXT);
1114 }
1115
1116 psh.dwSize = sizeof(psh);
1117 psh.dwFlags = PSH_USEICONID | PSH_PROPSHEETPAGE | PSH_NOAPPLYNOW;
1118 psh.hwndParent = hMainWnd;
1119 psh.hInstance = hInstance;
1120 psh.pszCaption = MAKEINTRESOURCEW(STRING_VIEWPROPS_TITLE);
1121 psh.nPages = sizeof(psp)/sizeof(psp[0]);
1122 U3(psh).ppsp = ppsp;
1123 U(psh).pszIcon = MAKEINTRESOURCEW(IDI_WORDPAD);
1124
1125 if(fileFormat & SF_RTF)
1126 U2(psh).nStartPage = 1;
1127 else
1128 U2(psh).nStartPage = 0;
1129 PropertySheetW(&psh);
1130 set_bar_states();
1131 target_device(hMainWnd, wordWrap[reg_formatindex(fileFormat)]);
1132 }
1133
1134 static void HandleCommandLine(LPWSTR cmdline)
1135 {
1136 WCHAR delimiter;
1137 int opt_print = 0;
1138
1139 /* skip white space */
1140 while (*cmdline == ' ') cmdline++;
1141
1142 /* skip executable name */
1143 delimiter = (*cmdline == '"' ? '"' : ' ');
1144
1145 if (*cmdline == delimiter) cmdline++;
1146 while (*cmdline && *cmdline != delimiter) cmdline++;
1147 if (*cmdline == delimiter) cmdline++;
1148
1149 while (*cmdline)
1150 {
1151 while (isspace(*cmdline)) cmdline++;
1152
1153 if (*cmdline == '-' || *cmdline == '/')
1154 {
1155 if (!cmdline[2] || isspace(cmdline[2]))
1156 {
1157 switch (cmdline[1])
1158 {
1159 case 'P':
1160 case 'p':
1161 opt_print = 1;
1162 cmdline += 2;
1163 continue;
1164 }
1165 }
1166 /* a filename starting by / */
1167 }
1168 break;
1169 }
1170
1171 if (*cmdline)
1172 {
1173 /* file name is passed on the command line */
1174 if (cmdline[0] == '"')
1175 {
1176 cmdline++;
1177 cmdline[lstrlenW(cmdline) - 1] = 0;
1178 }
1179 DoOpenFile(cmdline);
1180 InvalidateRect(hMainWnd, NULL, FALSE);
1181 }
1182
1183 if (opt_print)
1184 MessageBoxWithResStringW(hMainWnd, MAKEINTRESOURCEW(STRING_PRINTING_NOT_IMPLEMENTED), wszAppTitle, MB_OK);
1185 }
1186
1187 static LRESULT handle_findmsg(LPFINDREPLACEW pFr)
1188 {
1189 if(pFr->Flags & FR_DIALOGTERM)
1190 {
1191 hFindWnd = 0;
1192 pFr->Flags = FR_FINDNEXT;
1193 return 0;
1194 }
1195
1196 if(pFr->Flags & FR_FINDNEXT || pFr->Flags & FR_REPLACE || pFr->Flags & FR_REPLACEALL)
1197 {
1198 DWORD flags = FR_DOWN;
1199 FINDTEXTW ft;
1200 static CHARRANGE cr;
1201 LRESULT end, ret;
1202 GETTEXTLENGTHEX gt;
1203 LRESULT length;
1204 int startPos;
1205 HMENU hMenu = GetMenu(hMainWnd);
1206 MENUITEMINFOW mi;
1207
1208 mi.cbSize = sizeof(mi);
1209 mi.fMask = MIIM_DATA;
1210 mi.dwItemData = 1;
1211 SetMenuItemInfoW(hMenu, ID_FIND_NEXT, FALSE, &mi);
1212
1213 gt.flags = GTL_NUMCHARS;
1214 gt.codepage = 1200;
1215
1216 length = SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0);
1217
1218 if(pFr->lCustData == -1)
1219 {
1220 SendMessageW(hEditorWnd, EM_GETSEL, (WPARAM)&startPos, (LPARAM)&end);
1221 cr.cpMin = startPos;
1222 pFr->lCustData = startPos;
1223 cr.cpMax = length;
1224 if(cr.cpMin == length)
1225 cr.cpMin = 0;
1226 } else
1227 {
1228 startPos = pFr->lCustData;
1229 }
1230
1231 if(cr.cpMax > length)
1232 {
1233 startPos = 0;
1234 cr.cpMin = 0;
1235 cr.cpMax = length;
1236 }
1237
1238 ft.chrg = cr;
1239 ft.lpstrText = pFr->lpstrFindWhat;
1240
1241 if(pFr->Flags & FR_MATCHCASE)
1242 flags |= FR_MATCHCASE;
1243 if(pFr->Flags & FR_WHOLEWORD)
1244 flags |= FR_WHOLEWORD;
1245
1246 ret = SendMessageW(hEditorWnd, EM_FINDTEXTW, flags, (LPARAM)&ft);
1247
1248 if(ret == -1)
1249 {
1250 if(cr.cpMax == length && cr.cpMax != startPos)
1251 {
1252 ft.chrg.cpMin = cr.cpMin = 0;
1253 ft.chrg.cpMax = cr.cpMax = startPos;
1254
1255 ret = SendMessageW(hEditorWnd, EM_FINDTEXTW, flags, (LPARAM)&ft);
1256 }
1257 }
1258
1259 if(ret == -1)
1260 {
1261 pFr->lCustData = -1;
1262 MessageBoxWithResStringW(hMainWnd, MAKEINTRESOURCEW(STRING_SEARCH_FINISHED), wszAppTitle,
1263 MB_OK | MB_ICONASTERISK);
1264 } else
1265 {
1266 end = ret + lstrlenW(pFr->lpstrFindWhat);
1267 cr.cpMin = end;
1268 SendMessageW(hEditorWnd, EM_SETSEL, ret, end);
1269 SendMessageW(hEditorWnd, EM_SCROLLCARET, 0, 0);
1270
1271 if(pFr->Flags & FR_REPLACE || pFr->Flags & FR_REPLACEALL)
1272 SendMessageW(hEditorWnd, EM_REPLACESEL, TRUE, (LPARAM)pFr->lpstrReplaceWith);
1273
1274 if(pFr->Flags & FR_REPLACEALL)
1275 handle_findmsg(pFr);
1276 }
1277 }
1278
1279 return 0;
1280 }
1281
1282 static void dialog_find(LPFINDREPLACEW fr, BOOL replace)
1283 {
1284 static WCHAR findBuffer[MAX_STRING_LEN];
1285
1286 /* Allow only one search/replace dialog to open */
1287 if(hFindWnd != NULL)
1288 {
1289 SetActiveWindow(hFindWnd);
1290 return;
1291 }
1292
1293 ZeroMemory(fr, sizeof(FINDREPLACEW));
1294 fr->lStructSize = sizeof(FINDREPLACEW);
1295 fr->hwndOwner = hMainWnd;
1296 fr->Flags = FR_HIDEUPDOWN;
1297 fr->lpstrFindWhat = findBuffer;
1298 fr->lCustData = -1;
1299 fr->wFindWhatLen = MAX_STRING_LEN*sizeof(WCHAR);
1300
1301 if(replace)
1302 hFindWnd = ReplaceTextW(fr);
1303 else
1304 hFindWnd = FindTextW(fr);
1305 }
1306
1307 static int current_units_to_twips(float number)
1308 {
1309 int twips = (int)(number * 1000.0 / (float)CENTMM_PER_INCH * (float)TWIPS_PER_INCH);
1310 return twips;
1311 }
1312
1313 static void append_current_units(LPWSTR buffer)
1314 {
1315 static const WCHAR space[] = {' ', 0};
1316 lstrcatW(buffer, space);
1317 lstrcatW(buffer, units_cmW);
1318 }
1319
1320 static void number_with_units(LPWSTR buffer, int number)
1321 {
1322 static const WCHAR fmt[] = {'%','.','2','f',' ','%','s','\0'};
1323 float converted = (float)number / (float)TWIPS_PER_INCH *(float)CENTMM_PER_INCH / 1000.0;
1324
1325 sprintfW(buffer, fmt, converted, units_cmW);
1326 }
1327
1328 static BOOL get_comboexlist_selection(HWND hComboEx, LPWSTR wszBuffer, UINT bufferLength)
1329 {
1330 COMBOBOXEXITEMW cbItem;
1331 COMBOBOXINFO cbInfo;
1332 HWND hCombo, hList;
1333 int idx, result;
1334
1335 hCombo = (HWND)SendMessage(hComboEx, CBEM_GETCOMBOCONTROL, 0, 0);
1336 if (!hCombo)
1337 return FALSE;
1338 cbInfo.cbSize = sizeof(COMBOBOXINFO);
1339 result = SendMessage(hCombo, CB_GETCOMBOBOXINFO, 0, (LPARAM)&cbInfo);
1340 if (!result)
1341 return FALSE;
1342 hList = cbInfo.hwndList;
1343 idx = SendMessage(hList, LB_GETCURSEL, 0, 0);
1344 if (idx < 0)
1345 return FALSE;
1346
1347 ZeroMemory(&cbItem, sizeof(cbItem));
1348 cbItem.mask = CBEIF_TEXT;
1349 cbItem.iItem = idx;
1350 cbItem.pszText = wszBuffer;
1351 cbItem.cchTextMax = bufferLength-1;
1352 result = SendMessageW(hComboEx, CBEM_GETITEMW, 0, (LPARAM)&cbItem);
1353
1354 return result != 0;
1355 }
1356
1357 static INT_PTR CALLBACK datetime_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1358 {
1359 switch(message)
1360 {
1361 case WM_INITDIALOG:
1362 {
1363 WCHAR buffer[MAX_STRING_LEN];
1364 SYSTEMTIME st;
1365 HWND hListWnd = GetDlgItem(hWnd, IDC_DATETIME);
1366 GetLocalTime(&st);
1367
1368 GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, 0, (LPWSTR)&buffer,
1369 MAX_STRING_LEN);
1370 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
1371 GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, 0, (LPWSTR)&buffer,
1372 MAX_STRING_LEN);
1373 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
1374 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, 0, (LPWSTR)&buffer, MAX_STRING_LEN);
1375 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
1376
1377 SendMessageW(hListWnd, LB_SETSEL, TRUE, 0);
1378 }
1379 break;
1380
1381 case WM_COMMAND:
1382 switch(LOWORD(wParam))
1383 {
1384 case IDC_DATETIME:
1385 if (HIWORD(wParam) != LBN_DBLCLK)
1386 break;
1387 /* Fall through */
1388
1389 case IDOK:
1390 {
1391 LRESULT index;
1392 HWND hListWnd = GetDlgItem(hWnd, IDC_DATETIME);
1393
1394 index = SendMessageW(hListWnd, LB_GETCURSEL, 0, 0);
1395
1396 if(index != LB_ERR)
1397 {
1398 WCHAR buffer[MAX_STRING_LEN];
1399 SendMessageW(hListWnd, LB_GETTEXT, index, (LPARAM)&buffer);
1400 SendMessageW(hEditorWnd, EM_REPLACESEL, TRUE, (LPARAM)&buffer);
1401 }
1402 }
1403 /* Fall through */
1404
1405 case IDCANCEL:
1406 EndDialog(hWnd, wParam);
1407 return TRUE;
1408 }
1409 }
1410 return FALSE;
1411 }
1412
1413 static INT_PTR CALLBACK newfile_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1414 {
1415 switch(message)
1416 {
1417 case WM_INITDIALOG:
1418 {
1419 HINSTANCE hInstance = GetModuleHandleW(0);
1420 WCHAR buffer[MAX_STRING_LEN];
1421 HWND hListWnd = GetDlgItem(hWnd, IDC_NEWFILE);
1422
1423 LoadStringW(hInstance, STRING_NEWFILE_RICHTEXT, buffer, MAX_STRING_LEN);
1424 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
1425 LoadStringW(hInstance, STRING_NEWFILE_TXT, buffer, MAX_STRING_LEN);
1426 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
1427 LoadStringW(hInstance, STRING_NEWFILE_TXT_UNICODE, buffer, MAX_STRING_LEN);
1428 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
1429
1430 SendMessageW(hListWnd, LB_SETSEL, TRUE, 0);
1431 }
1432 break;
1433
1434 case WM_COMMAND:
1435 switch(LOWORD(wParam))
1436 {
1437 case IDOK:
1438 {
1439 LRESULT index;
1440 HWND hListWnd = GetDlgItem(hWnd, IDC_NEWFILE);
1441 index = SendMessageW(hListWnd, LB_GETCURSEL, 0, 0);
1442
1443 if(index != LB_ERR)
1444 EndDialog(hWnd, MAKELONG(fileformat_flags(index),0));
1445 }
1446 return TRUE;
1447
1448 case IDCANCEL:
1449 EndDialog(hWnd, MAKELONG(ID_NEWFILE_ABORT,0));
1450 return TRUE;
1451 }
1452 }
1453 return FALSE;
1454 }
1455
1456 static INT_PTR CALLBACK paraformat_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1457 {
1458 static const WORD ALIGNMENT_VALUES[] = {PFA_LEFT, PFA_RIGHT, PFA_CENTER};
1459
1460 switch(message)
1461 {
1462 case WM_INITDIALOG:
1463 {
1464 HINSTANCE hInstance = GetModuleHandleW(0);
1465 WCHAR buffer[MAX_STRING_LEN];
1466 HWND hListWnd = GetDlgItem(hWnd, IDC_PARA_ALIGN);
1467 HWND hLeftWnd = GetDlgItem(hWnd, IDC_PARA_LEFT);
1468 HWND hRightWnd = GetDlgItem(hWnd, IDC_PARA_RIGHT);
1469 HWND hFirstWnd = GetDlgItem(hWnd, IDC_PARA_FIRST);
1470 PARAFORMAT2 pf;
1471 int index = 0;
1472
1473 LoadStringW(hInstance, STRING_ALIGN_LEFT, buffer,
1474 MAX_STRING_LEN);
1475 SendMessageW(hListWnd, CB_ADDSTRING, 0, (LPARAM)buffer);
1476 LoadStringW(hInstance, STRING_ALIGN_RIGHT, buffer,
1477 MAX_STRING_LEN);
1478 SendMessageW(hListWnd, CB_ADDSTRING, 0, (LPARAM)buffer);
1479 LoadStringW(hInstance, STRING_ALIGN_CENTER, buffer,
1480 MAX_STRING_LEN);
1481 SendMessageW(hListWnd, CB_ADDSTRING, 0, (LPARAM)buffer);
1482
1483 pf.cbSize = sizeof(pf);
1484 pf.dwMask = PFM_ALIGNMENT | PFM_OFFSET | PFM_RIGHTINDENT |
1485 PFM_STARTINDENT;
1486 SendMessageW(hEditorWnd, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1487
1488 if(pf.wAlignment == PFA_RIGHT)
1489 index ++;
1490 else if(pf.wAlignment == PFA_CENTER)
1491 index += 2;
1492
1493 SendMessageW(hListWnd, CB_SETCURSEL, index, 0);
1494
1495 number_with_units(buffer, pf.dxStartIndent + pf.dxOffset);
1496 SetWindowTextW(hLeftWnd, buffer);
1497 number_with_units(buffer, pf.dxRightIndent);
1498 SetWindowTextW(hRightWnd, buffer);
1499 number_with_units(buffer, -pf.dxOffset);
1500 SetWindowTextW(hFirstWnd, buffer);
1501 }
1502 break;
1503
1504 case WM_COMMAND:
1505 switch(LOWORD(wParam))
1506 {
1507 case IDOK:
1508 {
1509 HWND hListWnd = GetDlgItem(hWnd, IDC_PARA_ALIGN);
1510 HWND hLeftWnd = GetDlgItem(hWnd, IDC_PARA_LEFT);
1511 HWND hRightWnd = GetDlgItem(hWnd, IDC_PARA_RIGHT);
1512 HWND hFirstWnd = GetDlgItem(hWnd, IDC_PARA_FIRST);
1513 WCHAR buffer[MAX_STRING_LEN];
1514 int index;
1515 float num;
1516 int ret = 0;
1517 PARAFORMAT pf;
1518
1519 index = SendMessageW(hListWnd, CB_GETCURSEL, 0, 0);
1520 pf.wAlignment = ALIGNMENT_VALUES[index];
1521
1522 GetWindowTextW(hLeftWnd, buffer, MAX_STRING_LEN);
1523 if(number_from_string(buffer, &num, TRUE))
1524 ret++;
1525 pf.dxOffset = current_units_to_twips(num);
1526 GetWindowTextW(hRightWnd, buffer, MAX_STRING_LEN);
1527 if(number_from_string(buffer, &num, TRUE))
1528 ret++;
1529 pf.dxRightIndent = current_units_to_twips(num);
1530 GetWindowTextW(hFirstWnd, buffer, MAX_STRING_LEN);
1531 if(number_from_string(buffer, &num, TRUE))
1532 ret++;
1533 pf.dxStartIndent = current_units_to_twips(num);
1534
1535 if(ret != 3)
1536 {
1537 MessageBoxWithResStringW(hMainWnd, MAKEINTRESOURCEW(STRING_INVALID_NUMBER),
1538 wszAppTitle, MB_OK | MB_ICONASTERISK);
1539 return FALSE;
1540 } else
1541 {
1542 if (pf.dxOffset + pf.dxStartIndent < 0
1543 && pf.dxStartIndent < 0)
1544 {
1545 /* The first line is before the left edge, so
1546 * make sure it is at the left edge. */
1547 pf.dxOffset = -pf.dxStartIndent;
1548 } else if (pf.dxOffset < 0) {
1549 /* The second and following lines are before
1550 * the left edge, so set it to be at the left
1551 * edge, and adjust the first line since it
1552 * is relative to it. */
1553 pf.dxStartIndent = max(pf.dxStartIndent + pf.dxOffset, 0);
1554 pf.dxOffset = 0;
1555 }
1556 /* Internally the dxStartIndent is the absolute
1557 * offset for the first line and dxOffset is
1558 * to it value as opposed how it is displayed with
1559 * the first line being the relative value.
1560 * These two lines make the adjustments. */
1561 pf.dxStartIndent = pf.dxStartIndent + pf.dxOffset;
1562 pf.dxOffset = pf.dxOffset - pf.dxStartIndent;
1563
1564 pf.cbSize = sizeof(pf);
1565 pf.dwMask = PFM_ALIGNMENT | PFM_OFFSET | PFM_RIGHTINDENT |
1566 PFM_STARTINDENT;
1567 SendMessageW(hEditorWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
1568 }
1569 }
1570 /* Fall through */
1571
1572 case IDCANCEL:
1573 EndDialog(hWnd, wParam);
1574 return TRUE;
1575 }
1576 }
1577 return FALSE;
1578 }
1579
1580 static INT_PTR CALLBACK tabstops_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
1581 {
1582 switch(message)
1583 {
1584 case WM_INITDIALOG:
1585 {
1586 HWND hTabWnd = GetDlgItem(hWnd, IDC_TABSTOPS);
1587 PARAFORMAT pf;
1588 WCHAR buffer[MAX_STRING_LEN];
1589 int i;
1590
1591 pf.cbSize = sizeof(pf);
1592 pf.dwMask = PFM_TABSTOPS;
1593 SendMessageW(hEditorWnd, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1594 SendMessageW(hTabWnd, CB_LIMITTEXT, MAX_STRING_LEN-1, 0);
1595
1596 for(i = 0; i < pf.cTabCount; i++)
1597 {
1598 number_with_units(buffer, pf.rgxTabs[i]);
1599 SendMessageW(hTabWnd, CB_ADDSTRING, 0, (LPARAM)&buffer);
1600 }
1601 SetFocus(hTabWnd);
1602 }
1603 break;
1604
1605 case WM_COMMAND:
1606 switch(LOWORD(wParam))
1607 {
1608 case IDC_TABSTOPS:
1609 {
1610 HWND hTabWnd = (HWND)lParam;
1611 HWND hAddWnd = GetDlgItem(hWnd, ID_TAB_ADD);
1612 HWND hDelWnd = GetDlgItem(hWnd, ID_TAB_DEL);
1613 HWND hEmptyWnd = GetDlgItem(hWnd, ID_TAB_EMPTY);
1614
1615 if(GetWindowTextLengthW(hTabWnd))
1616 EnableWindow(hAddWnd, TRUE);
1617 else
1618 EnableWindow(hAddWnd, FALSE);
1619
1620 if(SendMessageW(hTabWnd, CB_GETCOUNT, 0, 0))
1621 {
1622 EnableWindow(hEmptyWnd, TRUE);
1623
1624 if(SendMessageW(hTabWnd, CB_GETCURSEL, 0, 0) == CB_ERR)
1625 EnableWindow(hDelWnd, FALSE);
1626 else
1627 EnableWindow(hDelWnd, TRUE);
1628 } else
1629 {
1630 EnableWindow(hEmptyWnd, FALSE);
1631 }
1632 }
1633 break;
1634
1635 case ID_TAB_ADD:
1636 {
1637 HWND hTabWnd = GetDlgItem(hWnd, IDC_TABSTOPS);
1638 WCHAR buffer[MAX_STRING_LEN];
1639
1640 GetWindowTextW(hTabWnd, buffer, MAX_STRING_LEN);
1641 append_current_units(buffer);
1642
1643 if(SendMessageW(hTabWnd, CB_FINDSTRINGEXACT, -1, (LPARAM)&buffer) == CB_ERR)
1644 {
1645 float number = 0;
1646 int item_count = SendMessage(hTabWnd, CB_GETCOUNT, 0, 0);
1647
1648 if(!number_from_string(buffer, &number, TRUE))
1649 {
1650 MessageBoxWithResStringW(hWnd, MAKEINTRESOURCEW(STRING_INVALID_NUMBER),
1651 wszAppTitle, MB_OK | MB_ICONINFORMATION);
1652 } else if (item_count >= MAX_TAB_STOPS) {
1653 MessageBoxWithResStringW(hWnd, MAKEINTRESOURCEW(STRING_MAX_TAB_STOPS),
1654 wszAppTitle, MB_OK | MB_ICONINFORMATION);
1655 } else {
1656 int i;
1657 float next_number = -1;
1658 int next_number_in_twips = -1;
1659 int insert_number = current_units_to_twips(number);
1660
1661 /* linear search for position to insert the string */
1662 for(i = 0; i < item_count; i++)
1663 {
1664 SendMessageW(hTabWnd, CB_GETLBTEXT, i, (LPARAM)&buffer);
1665 number_from_string(buffer, &next_number, TRUE);
1666 next_number_in_twips = current_units_to_twips(next_number);
1667 if (insert_number <= next_number_in_twips)
1668 break;
1669 }
1670 if (insert_number != next_number_in_twips)
1671 {
1672 number_with_units(buffer, insert_number);
1673 SendMessageW(hTabWnd, CB_INSERTSTRING, i, (LPARAM)&buffer);
1674 SetWindowTextW(hTabWnd, 0);
1675 }
1676 }
1677 }
1678 SetFocus(hTabWnd);
1679 }
1680 break;
1681
1682 case ID_TAB_DEL:
1683 {
1684 HWND hTabWnd = GetDlgItem(hWnd, IDC_TABSTOPS);
1685 LRESULT ret;
1686 ret = SendMessageW(hTabWnd, CB_GETCURSEL, 0, 0);
1687 if(ret != CB_ERR)
1688 SendMessageW(hTabWnd, CB_DELETESTRING, ret, 0);
1689 }
1690 break;
1691
1692 case ID_TAB_EMPTY:
1693 {
1694 HWND hTabWnd = GetDlgItem(hWnd, IDC_TABSTOPS);
1695 SendMessageW(hTabWnd, CB_RESETCONTENT, 0, 0);
1696 SetFocus(hTabWnd);
1697 }
1698 break;
1699
1700 case IDOK:
1701 {
1702 HWND hTabWnd = GetDlgItem(hWnd, IDC_TABSTOPS);
1703 int i;
1704 WCHAR buffer[MAX_STRING_LEN];
1705 PARAFORMAT pf;
1706 float number;
1707
1708 pf.cbSize = sizeof(pf);
1709 pf.dwMask = PFM_TABSTOPS;
1710
1711 for(i = 0; SendMessageW(hTabWnd, CB_GETLBTEXT, i,
1712 (LPARAM)&buffer) != CB_ERR &&
1713 i < MAX_TAB_STOPS; i++)
1714 {
1715 number_from_string(buffer, &number, TRUE);
1716 pf.rgxTabs[i] = current_units_to_twips(number);
1717 }
1718 pf.cTabCount = i;
1719 SendMessageW(hEditorWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
1720 }
1721 /* Fall through */
1722 case IDCANCEL:
1723 EndDialog(hWnd, wParam);
1724 return TRUE;
1725 }
1726 }
1727 return FALSE;
1728 }
1729
1730 static int context_menu(LPARAM lParam)
1731 {
1732 int x = (int)(short)LOWORD(lParam);
1733 int y = (int)(short)HIWORD(lParam);
1734 HMENU hPop = GetSubMenu(hPopupMenu, 0);
1735
1736 if(x == -1)
1737 {
1738 int from = 0, to = 0;
1739 POINTL pt;
1740 SendMessageW(hEditorWnd, EM_GETSEL, (WPARAM)&from, (LPARAM)&to);
1741 SendMessageW(hEditorWnd, EM_POSFROMCHAR, (WPARAM)&pt, to);
1742 ClientToScreen(hEditorWnd, (POINT*)&pt);
1743 x = pt.x;
1744 y = pt.y;
1745 }
1746
1747 TrackPopupMenu(hPop, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON,
1748 x, y, 0, hMainWnd, 0);
1749
1750 return 0;
1751 }
1752
1753 static LRESULT OnCreate( HWND hWnd )
1754 {
1755 HWND hToolBarWnd, hFormatBarWnd, hReBarWnd, hFontListWnd, hSizeListWnd, hRulerWnd;
1756 HINSTANCE hInstance = GetModuleHandleW(0);
1757 HANDLE hDLL;
1758 TBADDBITMAP ab;
1759 int nStdBitmaps = 0;
1760 REBARINFO rbi;
1761 REBARBANDINFOW rbb;
1762 static const WCHAR wszRichEditDll[] = {'R','I','C','H','E','D','2','0','.','D','L','L','\0'};
1763 static const WCHAR wszRichEditText[] = {'R','i','c','h','E','d','i','t',' ','t','e','x','t','\0'};
1764
1765 CreateStatusWindowW(CCS_NODIVIDER|WS_CHILD|WS_VISIBLE, wszRichEditText, hWnd, IDC_STATUSBAR);
1766
1767 hReBarWnd = CreateWindowExW(WS_EX_TOOLWINDOW, REBARCLASSNAMEW, NULL,
1768 CCS_NODIVIDER|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|RBS_VARHEIGHT|CCS_TOP,
1769 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, hWnd, (HMENU)IDC_REBAR, hInstance, NULL);
1770
1771 rbi.cbSize = sizeof(rbi);
1772 rbi.fMask = 0;
1773 rbi.himl = NULL;
1774 if(!SendMessageW(hReBarWnd, RB_SETBARINFO, 0, (LPARAM)&rbi))
1775 return -1;
1776
1777 hToolBarWnd = CreateToolbarEx(hReBarWnd, CCS_NOPARENTALIGN|CCS_NOMOVEY|WS_VISIBLE|WS_CHILD|TBSTYLE_TOOLTIPS|TBSTYLE_BUTTON,
1778 IDC_TOOLBAR,
1779 1, hInstance, IDB_TOOLBAR,
1780 NULL, 0,
1781 24, 24, 16, 16, sizeof(TBBUTTON));
1782
1783 ab.hInst = HINST_COMMCTRL;
1784 ab.nID = IDB_STD_SMALL_COLOR;
1785 nStdBitmaps = SendMessageW(hToolBarWnd, TB_ADDBITMAP, 0, (LPARAM)&ab);
1786
1787 AddButton(hToolBarWnd, nStdBitmaps+STD_FILENEW, ID_FILE_NEW);
1788 AddButton(hToolBarWnd, nStdBitmaps+STD_FILEOPEN, ID_FILE_OPEN);
1789 AddButton(hToolBarWnd, nStdBitmaps+STD_FILESAVE, ID_FILE_SAVE);
1790 AddSeparator(hToolBarWnd);
1791 AddButton(hToolBarWnd, nStdBitmaps+STD_PRINT, ID_PRINT_QUICK);
1792 AddButton(hToolBarWnd, nStdBitmaps+STD_PRINTPRE, ID_PREVIEW);
1793 AddSeparator(hToolBarWnd);
1794 AddButton(hToolBarWnd, nStdBitmaps+STD_FIND, ID_FIND);
1795 AddSeparator(hToolBarWnd);
1796 AddButton(hToolBarWnd, nStdBitmaps+STD_CUT, ID_EDIT_CUT);
1797 AddButton(hToolBarWnd, nStdBitmaps+STD_COPY, ID_EDIT_COPY);
1798 AddButton(hToolBarWnd, nStdBitmaps+STD_PASTE, ID_EDIT_PASTE);
1799 AddButton(hToolBarWnd, nStdBitmaps+STD_UNDO, ID_EDIT_UNDO);
1800 AddButton(hToolBarWnd, nStdBitmaps+STD_REDOW, ID_EDIT_REDO);
1801 AddSeparator(hToolBarWnd);
1802 AddButton(hToolBarWnd, 0, ID_DATETIME);
1803
1804 SendMessageW(hToolBarWnd, TB_AUTOSIZE, 0, 0);
1805
1806 rbb.cbSize = REBARBANDINFOW_V6_SIZE;
1807 rbb.fMask = RBBIM_SIZE | RBBIM_CHILDSIZE | RBBIM_CHILD | RBBIM_STYLE | RBBIM_ID;
1808 rbb.fStyle = RBBS_CHILDEDGE | RBBS_BREAK | RBBS_NOGRIPPER;
1809 rbb.cx = 0;
1810 rbb.hwndChild = hToolBarWnd;
1811 rbb.cxMinChild = 0;
1812 rbb.cyChild = rbb.cyMinChild = HIWORD(SendMessageW(hToolBarWnd, TB_GETBUTTONSIZE, 0, 0));
1813 rbb.wID = BANDID_TOOLBAR;
1814
1815 SendMessageW(hReBarWnd, RB_INSERTBAND, -1, (LPARAM)&rbb);
1816
1817 hFontListWnd = CreateWindowExW(0, WC_COMBOBOXEXW, NULL,
1818 WS_BORDER | WS_VISIBLE | WS_CHILD | CBS_DROPDOWN | CBS_SORT,
1819 0, 0, 200, 150, hReBarWnd, (HMENU)IDC_FONTLIST, hInstance, NULL);
1820
1821 rbb.hwndChild = hFontListWnd;
1822 rbb.cx = 200;
1823 rbb.wID = BANDID_FONTLIST;
1824
1825 SendMessageW(hReBarWnd, RB_INSERTBAND, -1, (LPARAM)&rbb);
1826
1827 hSizeListWnd = CreateWindowExW(0, WC_COMBOBOXEXW, NULL,
1828 WS_BORDER | WS_VISIBLE | WS_CHILD | CBS_DROPDOWN,
1829 0, 0, 50, 150, hReBarWnd, (HMENU)IDC_SIZELIST, hInstance, NULL);
1830
1831 rbb.hwndChild = hSizeListWnd;
1832 rbb.cx = 50;
1833 rbb.fStyle ^= RBBS_BREAK;
1834 rbb.wID = BANDID_SIZELIST;
1835
1836 SendMessageW(hReBarWnd, RB_INSERTBAND, -1, (LPARAM)&rbb);
1837
1838 hFormatBarWnd = CreateToolbarEx(hReBarWnd,
1839 CCS_NOPARENTALIGN | CCS_NOMOVEY | WS_VISIBLE | TBSTYLE_TOOLTIPS | TBSTYLE_BUTTON,
1840 IDC_FORMATBAR, 8, hInstance, IDB_FORMATBAR, NULL, 0, 16, 16, 16, 16, sizeof(TBBUTTON));
1841
1842 AddButton(hFormatBarWnd, 0, ID_FORMAT_BOLD);
1843 AddButton(hFormatBarWnd, 1, ID_FORMAT_ITALIC);
1844 AddButton(hFormatBarWnd, 2, ID_FORMAT_UNDERLINE);
1845 AddButton(hFormatBarWnd, 3, ID_FORMAT_COLOR);
1846 AddSeparator(hFormatBarWnd);
1847 AddButton(hFormatBarWnd, 4, ID_ALIGN_LEFT);
1848 AddButton(hFormatBarWnd, 5, ID_ALIGN_CENTER);
1849 AddButton(hFormatBarWnd, 6, ID_ALIGN_RIGHT);
1850 AddSeparator(hFormatBarWnd);
1851 AddButton(hFormatBarWnd, 7, ID_BULLET);
1852
1853 SendMessageW(hFormatBarWnd, TB_AUTOSIZE, 0, 0);
1854
1855 rbb.hwndChild = hFormatBarWnd;
1856 rbb.wID = BANDID_FORMATBAR;
1857
1858 SendMessageW(hReBarWnd, RB_INSERTBAND, -1, (LPARAM)&rbb);
1859
1860 hRulerWnd = CreateWindowExW(0, WC_STATICW, NULL, WS_VISIBLE | WS_CHILD,
1861 0, 0, 200, 10, hReBarWnd, (HMENU)IDC_RULER, hInstance, NULL);
1862
1863
1864 rbb.hwndChild = hRulerWnd;
1865 rbb.wID = BANDID_RULER;
1866 rbb.fStyle |= RBBS_BREAK;
1867
1868 SendMessageW(hReBarWnd, RB_INSERTBAND, -1, (LPARAM)&rbb);
1869
1870 hDLL = LoadLibraryW(wszRichEditDll);
1871 if(!hDLL)
1872 {
1873 MessageBoxWithResStringW(hWnd, MAKEINTRESOURCEW(STRING_LOAD_RICHED_FAILED), wszAppTitle,
1874 MB_OK | MB_ICONEXCLAMATION);
1875 PostQuitMessage(1);
1876 }
1877
1878 hEditorWnd = CreateWindowExW(WS_EX_CLIENTEDGE, RICHEDIT_CLASS20W, NULL,
1879 WS_CHILD|WS_VISIBLE|ES_SELECTIONBAR|ES_MULTILINE|ES_AUTOVSCROLL
1880 |ES_WANTRETURN|WS_VSCROLL|ES_NOHIDESEL|WS_HSCROLL,
1881 0, 0, 1000, 100, hWnd, (HMENU)IDC_EDITOR, hInstance, NULL);
1882
1883 if (!hEditorWnd)
1884 {
1885 fprintf(stderr, "Error code %u\n", GetLastError());
1886 return -1;
1887 }
1888 assert(hEditorWnd);
1889
1890 SetFocus(hEditorWnd);
1891 SendMessageW(hEditorWnd, EM_SETEVENTMASK, 0, ENM_SELCHANGE);
1892
1893 set_default_font();
1894
1895 populate_font_list(hFontListWnd);
1896 populate_size_list(hSizeListWnd);
1897 DoLoadStrings();
1898 SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
1899
1900 ID_FINDMSGSTRING = RegisterWindowMessageW(FINDMSGSTRINGW);
1901
1902 registry_read_filelist(hWnd);
1903 registry_read_formatopts_all(barState, wordWrap);
1904 registry_read_options();
1905 DragAcceptFiles(hWnd, TRUE);
1906
1907 return 0;
1908 }
1909
1910 static LRESULT OnUser( HWND hWnd )
1911 {
1912 HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
1913 HWND hwndReBar = GetDlgItem(hWnd, IDC_REBAR);
1914 HWND hwndToolBar = GetDlgItem(hwndReBar, IDC_TOOLBAR);
1915 HWND hwndFormatBar = GetDlgItem(hwndReBar, IDC_FORMATBAR);
1916 int from, to;
1917 CHARFORMAT2W fmt;
1918 PARAFORMAT2 pf;
1919 GETTEXTLENGTHEX gt;
1920
1921 ZeroMemory(&fmt, sizeof(fmt));
1922 fmt.cbSize = sizeof(fmt);
1923
1924 ZeroMemory(&pf, sizeof(pf));
1925 pf.cbSize = sizeof(pf);
1926
1927 gt.flags = GTL_NUMCHARS;
1928 gt.codepage = 1200;
1929
1930 SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_FIND,
1931 SendMessageW(hwndEditor, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0) ? 1 : 0);
1932
1933 SendMessageW(hwndEditor, EM_GETCHARFORMAT, TRUE, (LPARAM)&fmt);
1934
1935 SendMessageW(hwndEditor, EM_GETSEL, (WPARAM)&from, (LPARAM)&to);
1936 SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_UNDO,
1937 SendMessageW(hwndEditor, EM_CANUNDO, 0, 0));
1938 SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_REDO,
1939 SendMessageW(hwndEditor, EM_CANREDO, 0, 0));
1940 SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_CUT, from == to ? 0 : 1);
1941 SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_COPY, from == to ? 0 : 1);
1942
1943 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_FORMAT_BOLD, (fmt.dwMask & CFM_BOLD) &&
1944 (fmt.dwEffects & CFE_BOLD));
1945 SendMessageW(hwndFormatBar, TB_INDETERMINATE, ID_FORMAT_BOLD, !(fmt.dwMask & CFM_BOLD));
1946 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_FORMAT_ITALIC, (fmt.dwMask & CFM_ITALIC) &&
1947 (fmt.dwEffects & CFE_ITALIC));
1948 SendMessageW(hwndFormatBar, TB_INDETERMINATE, ID_FORMAT_ITALIC, !(fmt.dwMask & CFM_ITALIC));
1949 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_FORMAT_UNDERLINE, (fmt.dwMask & CFM_UNDERLINE) &&
1950 (fmt.dwEffects & CFE_UNDERLINE));
1951 SendMessageW(hwndFormatBar, TB_INDETERMINATE, ID_FORMAT_UNDERLINE, !(fmt.dwMask & CFM_UNDERLINE));
1952
1953 SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1954 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_ALIGN_LEFT, (pf.wAlignment == PFA_LEFT));
1955 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_ALIGN_CENTER, (pf.wAlignment == PFA_CENTER));
1956 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_ALIGN_RIGHT, (pf.wAlignment == PFA_RIGHT));
1957
1958 SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_BULLET, (pf.wNumbering & PFN_BULLET));
1959 return 0;
1960 }
1961
1962 static LRESULT OnNotify( HWND hWnd, LPARAM lParam)
1963 {
1964 HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
1965 HWND hwndReBar = GetDlgItem(hWnd, IDC_REBAR);
1966 NMHDR *pHdr = (NMHDR *)lParam;
1967 HWND hwndFontList = GetDlgItem(hwndReBar, IDC_FONTLIST);
1968 HWND hwndSizeList = GetDlgItem(hwndReBar, IDC_SIZELIST);
1969
1970 if (pHdr->hwndFrom == hwndFontList || pHdr->hwndFrom == hwndSizeList)
1971 {
1972 if (pHdr->code == CBEN_ENDEDITW)
1973 {
1974 NMCBEENDEDIT *endEdit = (NMCBEENDEDIT *)lParam;
1975 if(pHdr->hwndFrom == hwndFontList)
1976 {
1977 on_fontlist_modified((LPWSTR)endEdit->szText);
1978 } else if (pHdr->hwndFrom == hwndSizeList)
1979 {
1980 on_sizelist_modified(hwndFontList,(LPWSTR)endEdit->szText);
1981 }
1982 }
1983 return 0;
1984 }
1985
1986 if (pHdr->hwndFrom != hwndEditor)
1987 return 0;
1988
1989 if (pHdr->code == EN_SELCHANGE)
1990 {
1991 SELCHANGE *pSC = (SELCHANGE *)lParam;
1992 char buf[128];
1993
1994 update_font_list();
1995
1996 sprintf( buf,"selection = %d..%d, line count=%ld",
1997 pSC->chrg.cpMin, pSC->chrg.cpMax,
1998 SendMessage(hwndEditor, EM_GETLINECOUNT, 0, 0));
1999 SetWindowTextA(GetDlgItem(hWnd, IDC_STATUSBAR), buf);
2000 SendMessage(hWnd, WM_USER, 0, 0);
2001 return 1;
2002 }
2003 return 0;
2004 }
2005
2006 /* Copied from dlls/comdlg32/fontdlg.c */
2007 static const COLORREF textcolors[]=
2008 {
2009 0x00000000L,0x00000080L,0x00008000L,0x00008080L,
2010 0x00800000L,0x00800080L,0x00808000L,0x00808080L,
2011 0x00c0c0c0L,0x000000ffL,0x0000ff00L,0x0000ffffL,
2012 0x00ff0000L,0x00ff00ffL,0x00ffff00L,0x00FFFFFFL
2013 };
2014
2015 static LRESULT OnCommand( HWND hWnd, WPARAM wParam, LPARAM lParam)
2016 {
2017 HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
2018 static FINDREPLACEW findreplace;
2019
2020 if ((HWND)lParam == hwndEditor)
2021 return 0;
2022
2023 switch(LOWORD(wParam))
2024 {
2025
2026 case ID_FILE_EXIT:
2027 PostMessageW(hWnd, WM_CLOSE, 0, 0);
2028 break;
2029
2030 case ID_FILE_NEW:
2031 {
2032 HINSTANCE hInstance = GetModuleHandleW(0);
2033 int ret = DialogBox(hInstance, MAKEINTRESOURCE(IDD_NEWFILE), hWnd,
2034 newfile_proc);
2035
2036 if(ret != ID_NEWFILE_ABORT)
2037 {
2038 if(prompt_save_changes())
2039 {
2040 SETTEXTEX st;
2041
2042 set_caption(NULL);
2043 wszFileName[0] = '\0';
2044
2045 clear_formatting();
2046
2047 st.flags = ST_DEFAULT;
2048 st.codepage = 1200;
2049 SendMessageW(hEditorWnd, EM_SETTEXTEX, (WPARAM)&st, 0);
2050
2051 SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
2052 set_fileformat(ret);
2053 update_font_list();
2054 }
2055 }
2056 }
2057 break;
2058
2059 case ID_FILE_OPEN:
2060 DialogOpenFile();
2061 break;
2062
2063 case ID_FILE_SAVE:
2064 if(wszFileName[0])
2065 {
2066 DoSaveFile(wszFileName, fileFormat);
2067 break;
2068 }
2069 /* Fall through */
2070
2071 case ID_FILE_SAVEAS:
2072 DialogSaveFile();
2073 break;
2074
2075 case ID_FILE_RECENT1:
2076 case ID_FILE_RECENT2:
2077 case ID_FILE_RECENT3:
2078 case ID_FILE_RECENT4:
2079 {
2080 HMENU hMenu = GetMenu(hWnd);
2081 MENUITEMINFOW mi;
2082
2083 mi.cbSize = sizeof(MENUITEMINFOW);
2084 mi.fMask = MIIM_DATA;
2085 if(GetMenuItemInfoW(hMenu, LOWORD(wParam), FALSE, &mi))
2086 DoOpenFile((LPWSTR)mi.dwItemData);
2087 }
2088 break;
2089
2090 case ID_FIND:
2091 dialog_find(&findreplace, FALSE);
2092 break;
2093
2094 case ID_FIND_NEXT:
2095 handle_findmsg(&findreplace);
2096 break;
2097
2098 case ID_REPLACE:
2099 dialog_find(&findreplace, TRUE);
2100 break;
2101
2102 case ID_FONTSETTINGS:
2103 dialog_choose_font();
2104 break;
2105
2106 case ID_PRINT:
2107 dialog_print(hWnd, wszFileName);
2108 target_device(hMainWnd, wordWrap[reg_formatindex(fileFormat)]);
2109 break;
2110
2111 case ID_PRINT_QUICK:
2112 print_quick(hMainWnd, wszFileName);
2113 target_device(hMainWnd, wordWrap[reg_formatindex(fileFormat)]);
2114 break;
2115
2116 case ID_PREVIEW:
2117 {
2118 int index = reg_formatindex(fileFormat);
2119 DWORD tmp = barState[index];
2120 barState[index] = 1 << BANDID_STATUSBAR;
2121 set_bar_states();
2122 barState[index] = tmp;
2123 ShowWindow(hEditorWnd, FALSE);
2124
2125 init_preview(hWnd, wszFileName);
2126
2127 SetMenu(hWnd, NULL);
2128 InvalidateRect(0, 0, TRUE);
2129 }
2130 break;
2131
2132 case ID_PRINTSETUP:
2133 dialog_printsetup(hWnd);
2134 target_device(hMainWnd, wordWrap[reg_formatindex(fileFormat)]);
2135 break;
2136
2137 case ID_FORMAT_BOLD:
2138 case ID_FORMAT_ITALIC:
2139 case ID_FORMAT_UNDERLINE:
2140 {
2141 CHARFORMAT2W fmt;
2142 int effects = CFE_BOLD;
2143
2144 ZeroMemory(&fmt, sizeof(fmt));
2145 fmt.cbSize = sizeof(fmt);
2146 SendMessageW(hwndEditor, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
2147
2148 fmt.dwMask = CFM_BOLD;
2149
2150 if (LOWORD(wParam) == ID_FORMAT_ITALIC)
2151 {
2152 effects = CFE_ITALIC;
2153 fmt.dwMask = CFM_ITALIC;
2154 } else if (LOWORD(wParam) == ID_FORMAT_UNDERLINE)
2155 {
2156 effects = CFE_UNDERLINE;
2157 fmt.dwMask = CFM_UNDERLINE;
2158 }
2159
2160 fmt.dwEffects ^= effects;
2161
2162 SendMessageW(hwndEditor, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
2163 break;
2164 }
2165
2166 case ID_FORMAT_COLOR:
2167 {
2168 HWND hReBarWnd = GetDlgItem(hWnd, IDC_REBAR);
2169 HWND hFormatBarWnd = GetDlgItem(hReBarWnd, IDC_FORMATBAR);
2170 HMENU hPop;
2171 RECT itemrc;
2172 POINT pt;
2173 int mid;
2174 int itemidx = SendMessage(hFormatBarWnd, TB_COMMANDTOINDEX, ID_FORMAT_COLOR, 0);
2175
2176 SendMessage(hFormatBarWnd, TB_GETITEMRECT, itemidx, (LPARAM)&itemrc);
2177 pt.x = itemrc.left;
2178 pt.y = itemrc.bottom;
2179 ClientToScreen(hFormatBarWnd, &pt);
2180 hPop = GetSubMenu(hColorPopupMenu, 0);
2181 mid = TrackPopupMenu(hPop, TPM_LEFTALIGN | TPM_TOPALIGN | TPM_LEFTBUTTON |
2182 TPM_RETURNCMD | TPM_NONOTIFY,
2183 pt.x, pt.y, 0, hWnd, 0);
2184 if (mid >= ID_COLOR_FIRST && mid <= ID_COLOR_AUTOMATIC)
2185 {
2186 CHARFORMAT2W fmt;
2187
2188 ZeroMemory(&fmt, sizeof(fmt));
2189 fmt.cbSize = sizeof(fmt);
2190 SendMessageW(hwndEditor, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
2191
2192 fmt.dwMask = CFM_COLOR;
2193
2194 if (mid < ID_COLOR_AUTOMATIC) {
2195 fmt.crTextColor = textcolors[mid - ID_COLOR_FIRST];
2196 fmt.dwEffects &= ~CFE_AUTOCOLOR;
2197 } else {
2198 fmt.dwEffects |= CFE_AUTOCOLOR;
2199 }
2200
2201 SendMessageW(hwndEditor, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
2202 }
2203 break;
2204 }
2205
2206 case ID_EDIT_CUT:
2207 PostMessageW(hwndEditor, WM_CUT, 0, 0);
2208 break;
2209
2210 case ID_EDIT_COPY:
2211 PostMessageW(hwndEditor, WM_COPY, 0, 0);
2212 break;
2213
2214 case ID_EDIT_PASTE:
2215 PostMessageW(hwndEditor, WM_PASTE, 0, 0);
2216 break;
2217
2218 case ID_EDIT_CLEAR:
2219 PostMessageW(hwndEditor, WM_CLEAR, 0, 0);
2220 break;
2221
2222 case ID_EDIT_SELECTALL:
2223 {
2224 CHARRANGE range = {0, -1};
2225 SendMessageW(hwndEditor, EM_EXSETSEL, 0, (LPARAM)&range);
2226 /* SendMessage(hwndEditor, EM_SETSEL, 0, -1); */
2227 return 0;
2228 }
2229
2230 case ID_EDIT_GETTEXT:
2231 {
2232 int nLen = GetWindowTextLengthW(hwndEditor);
2233 LPWSTR data = HeapAlloc( GetProcessHeap(), 0, (nLen+1)*sizeof(WCHAR) );
2234 TEXTRANGEW tr;
2235
2236 GetWindowTextW(hwndEditor, data, nLen+1);
2237 MessageBoxW(NULL, data, wszAppTitle, MB_OK);
2238
2239 HeapFree( GetProcessHeap(), 0, data);
2240 data = HeapAlloc(GetProcessHeap(), 0, (nLen+1)*sizeof(WCHAR));
2241 tr.chrg.cpMin = 0;
2242 tr.chrg.cpMax = nLen;
2243 tr.lpstrText = data;
2244 SendMessage (hwndEditor, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
2245 MessageBoxW(NULL, data, wszAppTitle, MB_OK);
2246 HeapFree( GetProcessHeap(), 0, data );
2247
2248 /* SendMessage(hwndEditor, EM_SETSEL, 0, -1); */
2249 return 0;
2250 }
2251
2252 case ID_EDIT_CHARFORMAT:
2253 case ID_EDIT_DEFCHARFORMAT:
2254 {
2255 CHARFORMAT2W cf;
2256 LRESULT i;
2257 ZeroMemory(&cf, sizeof(cf));
2258 cf.cbSize = sizeof(cf);
2259 cf.dwMask = 0;
2260 i = SendMessageW(hwndEditor, EM_GETCHARFORMAT,
2261 LOWORD(wParam) == ID_EDIT_CHARFORMAT, (LPARAM)&cf);
2262 return 0;
2263 }
2264
2265 case ID_EDIT_PARAFORMAT:
2266 {
2267 PARAFORMAT2 pf;
2268 ZeroMemory(&pf, sizeof(pf));
2269 pf.cbSize = sizeof(pf);
2270 SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
2271 return 0;
2272 }
2273
2274 case ID_EDIT_SELECTIONINFO:
2275 {
2276 CHARRANGE range = {0, -1};
2277 char buf[128];
2278 WCHAR *data = NULL;
2279
2280 SendMessage(hwndEditor, EM_EXGETSEL, 0, (LPARAM)&range);
2281 data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data) * (range.cpMax-range.cpMin+1));
2282 SendMessage(hwndEditor, EM_GETSELTEXT, 0, (LPARAM)data);
2283 sprintf(buf, "Start = %d, End = %d", range.cpMin, range.cpMax);
2284 MessageBoxA(hWnd, buf, "Editor", MB_OK);
2285 MessageBoxW(hWnd, data, wszAppTitle, MB_OK);
2286 HeapFree( GetProcessHeap(), 0, data);
2287 /* SendMessage(hwndEditor, EM_SETSEL, 0, -1); */
2288 return 0;
2289 }
2290
2291 case ID_EDIT_READONLY:
2292 {
2293 LONG nStyle = GetWindowLong(hwndEditor, GWL_STYLE);
2294 if (nStyle & ES_READONLY)
2295 SendMessageW(hwndEditor, EM_SETREADONLY, 0, 0);
2296 else
2297 SendMessageW(hwndEditor, EM_SETREADONLY, 1, 0);
2298 return 0;
2299 }
2300
2301 case ID_EDIT_MODIFIED:
2302 if (SendMessageW(hwndEditor, EM_GETMODIFY, 0, 0))
2303 SendMessageW(hwndEditor, EM_SETMODIFY, 0, 0);
2304 else
2305 SendMessageW(hwndEditor, EM_SETMODIFY, 1, 0);
2306 return 0;
2307
2308 case ID_EDIT_UNDO:
2309 SendMessageW(hwndEditor, EM_UNDO, 0, 0);
2310 return 0;
2311
2312 case ID_EDIT_REDO:
2313 SendMessageW(hwndEditor, EM_REDO, 0, 0);
2314 return 0;
2315
2316 case ID_BULLET:
2317 {
2318 PARAFORMAT pf;
2319
2320 pf.cbSize = sizeof(pf);
2321 pf.dwMask = PFM_NUMBERING;
2322 SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
2323
2324 pf.dwMask |= PFM_OFFSET;
2325
2326 if(pf.wNumbering == PFN_BULLET)
2327 {
2328 pf.wNumbering = 0;
2329 pf.dxOffset = 0;
2330 } else
2331 {
2332 pf.wNumbering = PFN_BULLET;
2333 pf.dxOffset = 720;
2334 }
2335
2336 SendMessageW(hwndEditor, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
2337 }
2338 break;
2339
2340 case ID_ALIGN_LEFT:
2341 case ID_ALIGN_CENTER:
2342 case ID_ALIGN_RIGHT:
2343 {
2344 PARAFORMAT2 pf;
2345
2346 pf.cbSize = sizeof(pf);
2347 pf.dwMask = PFM_ALIGNMENT;
2348 switch(LOWORD(wParam)) {
2349 case ID_ALIGN_LEFT: pf.wAlignment = PFA_LEFT; break;
2350 case ID_ALIGN_CENTER: pf.wAlignment = PFA_CENTER; break;
2351 case ID_ALIGN_RIGHT: pf.wAlignment = PFA_RIGHT; break;
2352 }
2353 SendMessageW(hwndEditor, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
2354 break;
2355 }
2356
2357 case ID_BACK_1:
2358 SendMessageW(hwndEditor, EM_SETBKGNDCOLOR, 1, 0);
2359 break;
2360
2361 case ID_BACK_2:
2362 SendMessageW(hwndEditor, EM_SETBKGNDCOLOR, 0, RGB(255,255,192));
2363 break;
2364
2365 case ID_TOGGLE_TOOLBAR:
2366 set_toolbar_state(BANDID_TOOLBAR, !is_bar_visible(BANDID_TOOLBAR));
2367 update_window();
2368 break;
2369
2370 case ID_TOGGLE_FORMATBAR:
2371 set_toolbar_state(BANDID_FONTLIST, !is_bar_visible(BANDID_FORMATBAR));
2372 set_toolbar_state(BANDID_SIZELIST, !is_bar_visible(BANDID_FORMATBAR));
2373 set_toolbar_state(BANDID_FORMATBAR, !is_bar_visible(BANDID_FORMATBAR));
2374 update_window();
2375 break;
2376
2377 case ID_TOGGLE_STATUSBAR:
2378 set_statusbar_state(!is_bar_visible(BANDID_STATUSBAR));
2379 update_window();
2380 break;
2381
2382 case ID_TOGGLE_RULER:
2383 set_toolbar_state(BANDID_RULER, !is_bar_visible(BANDID_RULER));
2384 update_window();
2385 break;
2386
2387 case ID_DATETIME:
2388 DialogBoxW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDD_DATETIME), hWnd, datetime_proc);
2389 break;
2390
2391 case ID_PARAFORMAT:
2392 DialogBoxW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDD_PARAFORMAT), hWnd, paraformat_proc);
2393 break;
2394
2395 case ID_TABSTOPS:
2396 DialogBoxW(GetModuleHandleW(0), MAKEINTRESOURCEW(IDD_PARAFORMAT), hWnd, tabstops_proc);
2397 break;
2398
2399 case ID_ABOUT:
2400 dialog_about();
2401 break;
2402
2403 case ID_VIEWPROPERTIES:
2404 dialog_viewproperties();
2405 break;
2406
2407 case IDC_FONTLIST:
2408 if (HIWORD(wParam) == CBN_SELENDOK)
2409 {
2410 WCHAR buffer[LF_FACESIZE];
2411 HWND hwndFontList = (HWND)lParam;
2412 get_comboexlist_selection(hwndFontList, buffer, LF_FACESIZE);
2413 on_fontlist_modified(buffer);
2414 }
2415 break;
2416
2417 case IDC_SIZELIST:
2418 if (HIWORD(wParam) == CBN_SELENDOK)
2419 {
2420 WCHAR buffer[MAX_STRING_LEN+1];
2421 HWND hwndSizeList = (HWND)lParam;
2422 get_comboexlist_selection(hwndSizeList, buffer, MAX_STRING_LEN+1);
2423 on_sizelist_modified(hwndSizeList, buffer);
2424 }
2425 break;
2426
2427 default:
2428 SendMessageW(hwndEditor, WM_COMMAND, wParam, lParam);
2429 break;
2430 }
2431 return 0;
2432 }
2433
2434 static LRESULT OnInitPopupMenu( HWND hWnd, WPARAM wParam )
2435 {
2436 HMENU hMenu = (HMENU)wParam;
2437 HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
2438 HWND hwndStatus = GetDlgItem(hWnd, IDC_STATUSBAR);
2439 PARAFORMAT pf;
2440 int nAlignment = -1;
2441 int selFrom, selTo;
2442 GETTEXTLENGTHEX gt;
2443 LRESULT textLength;
2444 MENUITEMINFOW mi;
2445
2446 SendMessageW(hEditorWnd, EM_GETSEL, (WPARAM)&selFrom, (LPARAM)&selTo);
2447 EnableMenuItem(hMenu, ID_EDIT_COPY, MF_BYCOMMAND|(selFrom == selTo) ? MF_GRAYED : MF_ENABLED);
2448 EnableMenuItem(hMenu, ID_EDIT_CUT, MF_BYCOMMAND|(selFrom == selTo) ? MF_GRAYED : MF_ENABLED);
2449
2450 pf.cbSize = sizeof(PARAFORMAT);
2451 SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
2452 CheckMenuItem(hMenu, ID_EDIT_READONLY,
2453 MF_BYCOMMAND|(GetWindowLong(hwndEditor, GWL_STYLE)&ES_READONLY ? MF_CHECKED : MF_UNCHECKED));
2454 CheckMenuItem(hMenu, ID_EDIT_MODIFIED,
2455 MF_BYCOMMAND|(SendMessage(hwndEditor, EM_GETMODIFY, 0, 0) ? MF_CHECKED : MF_UNCHECKED));
2456 if (pf.dwMask & PFM_ALIGNMENT)
2457 nAlignment = pf.wAlignment;
2458 CheckMenuItem(hMenu, ID_ALIGN_LEFT, MF_BYCOMMAND|(nAlignment == PFA_LEFT) ?
2459 MF_CHECKED : MF_UNCHECKED);
2460 CheckMenuItem(hMenu, ID_ALIGN_CENTER, MF_BYCOMMAND|(nAlignment == PFA_CENTER) ?
2461 MF_CHECKED : MF_UNCHECKED);
2462 CheckMenuItem(hMenu, ID_ALIGN_RIGHT, MF_BYCOMMAND|(nAlignment == PFA_RIGHT) ?
2463 MF_CHECKED : MF_UNCHECKED);
2464 CheckMenuItem(hMenu, ID_BULLET, MF_BYCOMMAND | ((pf.wNumbering == PFN_BULLET) ?
2465 MF_CHECKED : MF_UNCHECKED));
2466 EnableMenuItem(hMenu, ID_EDIT_UNDO, MF_BYCOMMAND|(SendMessageW(hwndEditor, EM_CANUNDO, 0, 0)) ?
2467 MF_ENABLED : MF_GRAYED);
2468 EnableMenuItem(hMenu, ID_EDIT_REDO, MF_BYCOMMAND|(SendMessageW(hwndEditor, EM_CANREDO, 0, 0)) ?
2469 MF_ENABLED : MF_GRAYED);
2470
2471 CheckMenuItem(hMenu, ID_TOGGLE_TOOLBAR, MF_BYCOMMAND|(is_bar_visible(BANDID_TOOLBAR)) ?
2472 MF_CHECKED : MF_UNCHECKED);
2473
2474 CheckMenuItem(hMenu, ID_TOGGLE_FORMATBAR, MF_BYCOMMAND|(is_bar_visible(BANDID_FORMATBAR)) ?
2475 MF_CHECKED : MF_UNCHECKED);
2476
2477 CheckMenuItem(hMenu, ID_TOGGLE_STATUSBAR, MF_BYCOMMAND|IsWindowVisible(hwndStatus) ?
2478 MF_CHECKED : MF_UNCHECKED);
2479
2480 CheckMenuItem(hMenu, ID_TOGGLE_RULER, MF_BYCOMMAND|(is_bar_visible(BANDID_RULER)) ? MF_CHECKED : MF_UNCHECKED);
2481
2482 gt.flags = GTL_NUMCHARS;
2483 gt.codepage = 1200;
2484 textLength = SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0);
2485 EnableMenuItem(hMenu, ID_FIND, MF_BYCOMMAND|(textLength ? MF_ENABLED : MF_GRAYED));
2486
2487 mi.cbSize = sizeof(mi);
2488 mi.fMask = MIIM_DATA;
2489
2490 GetMenuItemInfoW(hMenu, ID_FIND_NEXT, FALSE, &mi);
2491
2492 EnableMenuItem(hMenu, ID_FIND_NEXT, MF_BYCOMMAND|((textLength && mi.dwItemData) ?
2493 MF_ENABLED : MF_GRAYED));
2494
2495 EnableMenuItem(hMenu, ID_REPLACE, MF_BYCOMMAND|(textLength ? MF_ENABLED : MF_GRAYED));
2496
2497 return 0;
2498 }
2499
2500 static LRESULT OnSize( HWND hWnd, WPARAM wParam, LPARAM lParam )
2501 {
2502 int nStatusSize = 0;
2503 RECT rc;
2504 HWND hwndEditor = preview_isactive() ? GetDlgItem(hWnd, IDC_PREVIEW) : GetDlgItem(hWnd, IDC_EDITOR);
2505 HWND hwndStatusBar = GetDlgItem(hWnd, IDC_STATUSBAR);
2506 HWND hwndReBar = GetDlgItem(hWnd, IDC_REBAR);
2507 HWND hRulerWnd = GetDlgItem(hWnd, IDC_RULER);
2508 int rebarHeight = 0;
2509
2510 if (hwndStatusBar)
2511 {
2512 SendMessageW(hwndStatusBar, WM_SIZE, 0, 0);
2513 if (IsWindowVisible(hwndStatusBar))
2514 {
2515 GetClientRect(hwndStatusBar, &rc);
2516 nStatusSize = rc.bottom - rc.top;
2517 } else
2518 {
2519 nStatusSize = 0;
2520 }
2521 }
2522 if (hwndReBar)
2523 {
2524 rebarHeight = SendMessageW(hwndReBar, RB_GETBARHEIGHT, 0, 0);
2525
2526 MoveWindow(hwndReBar, 0, 0, LOWORD(lParam), rebarHeight, TRUE);
2527 }
2528 if (hwndEditor)
2529 {
2530 GetClientRect(hWnd, &rc);
2531 MoveWindow(hwndEditor, 0, rebarHeight, rc.right, rc.bottom-nStatusSize-rebarHeight, TRUE);
2532 }
2533
2534 redraw_ruler(hRulerWnd);
2535
2536 return DefWindowProcW(hWnd, WM_SIZE, wParam, lParam);
2537 }
2538
2539 static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
2540 {
2541 if(msg == ID_FINDMSGSTRING)
2542 return handle_findmsg((LPFINDREPLACEW)lParam);
2543
2544 switch(msg)
2545 {
2546 case WM_CREATE:
2547 return OnCreate( hWnd );
2548
2549 case WM_USER:
2550 return OnUser( hWnd );
2551
2552 case WM_NOTIFY:
2553 return OnNotify( hWnd, lParam );
2554
2555 case WM_COMMAND:
2556 if(preview_isactive())
2557 {
2558 return preview_command( hWnd, wParam );
2559 }
2560
2561 return OnCommand( hWnd, wParam, lParam );
2562
2563 case WM_DESTROY:
2564 PostQuitMessage(0);
2565 break;
2566
2567 case WM_CLOSE:
2568 if(preview_isactive())
2569 {
2570 preview_exit(hWnd);
2571 } else if(prompt_save_changes())
2572 {
2573 registry_set_options(hMainWnd);
2574 registry_set_formatopts_all(barState);
2575 PostQuitMessage(0);
2576 }
2577 break;
2578
2579 case WM_ACTIVATE:
2580 if (LOWORD(wParam))
2581 SetFocus(GetDlgItem(hWnd, IDC_EDITOR));
2582 return 0;
2583
2584 case WM_INITMENUPOPUP:
2585 return OnInitPopupMenu( hWnd, wParam );
2586
2587 case WM_SIZE:
2588 return OnSize( hWnd, wParam, lParam );
2589
2590 case WM_CONTEXTMENU:
2591 if((HWND)wParam == hEditorWnd)
2592 return context_menu(lParam);
2593 else
2594 return DefWindowProcW(hWnd, msg, wParam, lParam);
2595
2596 case WM_DROPFILES:
2597 {
2598 WCHAR file[MAX_PATH];
2599 DragQueryFileW((HDROP)wParam, 0, file, MAX_PATH);
2600 DragFinish((HDROP)wParam);
2601
2602 if(prompt_save_changes())
2603 DoOpenFile(file);
2604 }
2605 break;
2606 case WM_PAINT:
2607 if(!preview_isactive())
2608 return DefWindowProcW(hWnd, msg, wParam, lParam);
2609
2610 default:
2611 return DefWindowProcW(hWnd, msg, wParam, lParam);
2612 }
2613
2614 return 0;
2615 }
2616
2617 int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hOldInstance, LPSTR szCmdParagraph, int nCmdShow)
2618 {
2619 INITCOMMONCONTROLSEX classes = {8, ICC_BAR_CLASSES|ICC_COOL_CLASSES|ICC_USEREX_CLASSES};
2620 HACCEL hAccel;
2621 WNDCLASSW wc;
2622 MSG msg;
2623 RECT rc;
2624 UINT_PTR hPrevRulerProc;
2625 HWND hRulerWnd;
2626 POINTL EditPoint;
2627 DWORD bMaximized;
2628 static const WCHAR wszAccelTable[] = {'M','A','I','N','A','C','C','E','L',
2629 'T','A','B','L','E','\0'};
2630
2631 InitCommonControlsEx(&classes);
2632
2633 hAccel = LoadAcceleratorsW(hInstance, wszAccelTable);
2634
2635 wc.style = CS_HREDRAW | CS_VREDRAW;
2636 wc.lpfnWndProc = WndProc;
2637 wc.cbClsExtra = 0;
2638 wc.cbWndExtra = 4;
2639 wc.hInstance = hInstance;
2640 wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_WORDPAD));
2641 wc.hCursor = LoadCursor(NULL, IDC_IBEAM);
2642 wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
2643 wc.lpszMenuName = MAKEINTRESOURCEW(IDM_MAINMENU);
2644 wc.lpszClassName = wszMainWndClass;
2645 RegisterClassW(&wc);
2646
2647 wc.style = CS_HREDRAW | CS_VREDRAW;
2648 wc.lpfnWndProc = preview_proc;
2649 wc.cbClsExtra = 0;
2650 wc.cbWndExtra = 0;
2651 wc.hInstance = hInstance;
2652 wc.hIcon = NULL;
2653 wc.hCursor = LoadCursor(NULL, IDC_IBEAM);
2654 wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
2655 wc.lpszMenuName = NULL;
2656 wc.lpszClassName = wszPreviewWndClass;
2657 RegisterClassW(&wc);
2658
2659 registry_read_winrect(&rc);
2660 hMainWnd = CreateWindowExW(0, wszMainWndClass, wszAppTitle, WS_CLIPCHILDREN|WS_OVERLAPPEDWINDOW,
2661 rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, NULL, NULL, hInstance, NULL);
2662 registry_read_maximized(&bMaximized);
2663 if ((nCmdShow == SW_SHOWNORMAL || nCmdShow == SW_SHOWDEFAULT)
2664 && bMaximized)
2665 nCmdShow = SW_SHOWMAXIMIZED;
2666 ShowWindow(hMainWnd, nCmdShow);
2667
2668 set_caption(NULL);
2669 set_bar_states();
2670 set_fileformat(SF_RTF);
2671 hPopupMenu = LoadMenuW(hInstance, MAKEINTRESOURCEW(IDM_POPUP));
2672 hColorPopupMenu = LoadMenuW(hInstance, MAKEINTRESOURCEW(IDM_COLOR_POPUP));
2673 get_default_printer_opts();
2674 target_device(hMainWnd, wordWrap[reg_formatindex(fileFormat)]);
2675
2676 hRulerWnd = GetDlgItem(GetDlgItem(hMainWnd, IDC_REBAR), IDC_RULER);
2677 SendMessageW(GetDlgItem(hMainWnd, IDC_EDITOR), EM_POSFROMCHAR, (WPARAM)&EditPoint, 0);
2678 hPrevRulerProc = SetWindowLongPtrW(hRulerWnd, GWLP_WNDPROC, (UINT_PTR)ruler_proc);
2679 SendMessageW(hRulerWnd, WM_USER, (WPARAM)&EditPoint, hPrevRulerProc);
2680
2681 HandleCommandLine(GetCommandLineW());
2682
2683 while(GetMessageW(&msg,0,0,0))
2684 {
2685 if (IsDialogMessage(hFindWnd, &msg))
2686 continue;
2687
2688 if (TranslateAcceleratorW(hMainWnd, hAccel, &msg))
2689 continue;
2690 TranslateMessage(&msg);
2691 DispatchMessageW(&msg);
2692 if (!PeekMessageW(&msg, 0, 0, 0, PM_NOREMOVE))
2693 SendMessageW(hMainWnd, WM_USER, 0, 0);
2694 }
2695
2696 return 0;
2697 }
A free Windows-compatible Operating System