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