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