git.oblomov.eu Git - wine/blob - programs/wordpad/wordpad.c

   1 /*
   2  * Wordpad implementation
   3  *
   4  * Copyright 2004 by Krzysztof Foltman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_LEAN_AND_MEAN
  22 #define _WIN32_IE 0x0400
  23
  24 #define MAX_STRING_LEN 255
  25
  26 #include <stdarg.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 <shlobj.h>
  36
  37 #include "resource.h"
  38
  39 /* use LoadString */
  40 static const WCHAR xszAppTitle[] = {'W','i','n','e',' ','W','o','r','d','p','a','d',0};
  41 static const WCHAR xszMainMenu[] = {'M','A','I','N','M','E','N','U',0};
  42
  43 static const WCHAR wszRichEditClass[] = {'R','I','C','H','E','D','I','T','2','0','W',0};
  44 static const WCHAR wszMainWndClass[] = {'W','O','R','D','P','A','D','T','O','P',0};
  45 static const WCHAR wszAppTitle[] = {'W','i','n','e',' ','W','o','r','d','p','a','d',0};
  46
  47 static const WCHAR key_recentfiles[] = {'R','e','c','e','n','t',' ','f','i','l','e',
  48                                         ' ','l','i','s','t',0};
  49
  50 static const WCHAR var_file[] = {'F','i','l','e','%','d',0};
  51
  52 static HWND hMainWnd;
  53 static HWND hEditorWnd;
  54 static HWND hFindWnd;
  55
  56 static UINT ID_FINDMSGSTRING;
  57
  58 static WCHAR wszFilter[MAX_STRING_LEN];
  59 static WCHAR wszDefaultFileName[MAX_STRING_LEN];
  60 static WCHAR wszSaveChanges[MAX_STRING_LEN];
  61
  62 static LRESULT OnSize( HWND hWnd, WPARAM wParam, LPARAM lParam );
  63
  64 /* Load string resources */
  65 static void DoLoadStrings(void)
  66 {
  67     LPWSTR p = wszFilter;
  68     static const WCHAR files_rtf[] = {'*','.','r','t','f','\0'};
  69     static const WCHAR files_txt[] = {'*','.','t','x','t','\0'};
  70     static const WCHAR files_all[] = {'*','.','*','\0'};
  71     HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtr(hMainWnd, GWLP_HINSTANCE);
  72
  73     LoadStringW(hInstance, STRING_RICHTEXT_FILES_RTF, p, MAX_STRING_LEN);
  74     p += lstrlenW(p) + 1;
  75     lstrcpyW(p, files_rtf);
  76     p += lstrlenW(p) + 1;
  77     LoadStringW(hInstance, STRING_TEXT_FILES_TXT, p, MAX_STRING_LEN);
  78     p += lstrlenW(p) + 1;
  79     lstrcpyW(p, files_txt);
  80     p += lstrlenW(p) + 1;
  81     LoadStringW(hInstance, STRING_ALL_FILES, p, MAX_STRING_LEN);
  82     p += lstrlenW(p) + 1;
  83     lstrcpyW(p, files_all);
  84     p += lstrlenW(p) + 1;
  85     *p = '\0';
  86
  87     p = wszDefaultFileName;
  88     LoadStringW(hInstance, STRING_DEFAULT_FILENAME, p, MAX_STRING_LEN);
  89
  90     p = wszSaveChanges;
  91     LoadStringW(hInstance, STRING_PROMPT_SAVE_CHANGES, p, MAX_STRING_LEN);
  92 }
  93
  94 static void AddButton(HWND hwndToolBar, int nImage, int nCommand)
  95 {
  96     TBBUTTON button;
  97
  98     ZeroMemory(&button, sizeof(button));
  99     button.iBitmap = nImage;
 100     button.idCommand = nCommand;
 101     button.fsState = TBSTATE_ENABLED;
 102     button.fsStyle = TBSTYLE_BUTTON;
 103     button.dwData = 0;
 104     button.iString = -1;
 105     SendMessageW(hwndToolBar, TB_ADDBUTTONSW, 1, (LPARAM)&button);
 106 }
 107
 108 static void AddSeparator(HWND hwndToolBar)
 109 {
 110     TBBUTTON button;
 111
 112     ZeroMemory(&button, sizeof(button));
 113     button.iBitmap = -1;
 114     button.idCommand = 0;
 115     button.fsState = 0;
 116     button.fsStyle = TBSTYLE_SEP;
 117     button.dwData = 0;
 118     button.iString = -1;
 119     SendMessageW(hwndToolBar, TB_ADDBUTTONSW, 1, (LPARAM)&button);
 120 }
 121
 122 static DWORD CALLBACK stream_in(DWORD_PTR cookie, LPBYTE buffer, LONG cb, LONG *pcb)
 123 {
 124     HANDLE hFile = (HANDLE)cookie;
 125     DWORD read;
 126
 127     if(!ReadFile(hFile, buffer, cb, &read, 0))
 128         return 1;
 129
 130     *pcb = read;
 131
 132     return 0;
 133 }
 134
 135 static DWORD CALLBACK stream_out(DWORD_PTR cookie, LPBYTE buffer, LONG cb, LONG *pcb)
 136 {
 137     DWORD written;
 138     int ret;
 139     HANDLE hFile = (HANDLE)cookie;
 140
 141     ret = WriteFile(hFile, buffer, cb, &written, 0);
 142
 143     if(!ret || (cb != written))
 144         return 1;
 145
 146     *pcb = cb;
 147
 148     return 0;
 149 }
 150
 151 static LPWSTR file_basename(LPWSTR path)
 152 {
 153     LPWSTR pos = path + lstrlenW(path);
 154
 155     while(pos > path)
 156     {
 157         if(*pos == '\\' || *pos == '/')
 158         {
 159             pos++;
 160             break;
 161         }
 162         pos--;
 163     }
 164     return pos;
 165 }
 166
 167 static WCHAR wszFileName[MAX_PATH];
 168
 169 static void set_caption(LPCWSTR wszNewFileName)
 170 {
 171     static const WCHAR wszSeparator[] = {' ','-',' '};
 172     WCHAR *wszCaption;
 173     SIZE_T length = 0;
 174
 175     if(!wszNewFileName)
 176         wszNewFileName = wszDefaultFileName;
 177
 178     wszCaption = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 179                 lstrlenW(wszNewFileName)*sizeof(WCHAR)+sizeof(wszSeparator)+sizeof(wszAppTitle));
 180
 181     if(!wszCaption)
 182         return;
 183
 184     memcpy(wszCaption, wszNewFileName, lstrlenW(wszNewFileName)*sizeof(WCHAR));
 185     length += lstrlenW(wszNewFileName);
 186     memcpy(wszCaption + length, wszSeparator, sizeof(wszSeparator));
 187     length += sizeof(wszSeparator) / sizeof(WCHAR);
 188     memcpy(wszCaption + length, wszAppTitle, sizeof(wszAppTitle));
 189
 190     SetWindowTextW(hMainWnd, wszCaption);
 191
 192     HeapFree(GetProcessHeap(), 0, wszCaption);
 193 }
 194
 195 static LRESULT registry_get_handle(HKEY *hKey, LPDWORD action, LPCWSTR subKey)
 196 {
 197     LONG ret;
 198     static const WCHAR wszProgramKey[] = {'S','o','f','t','w','a','r','e','\\',
 199         'M','i','c','r','o','s','o','f','t','\\',
 200         'W','i','n','d','o','w','s','\\',
 201         'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
 202         'A','p','p','l','e','t','s','\\',
 203         'W','o','r','d','p','a','d',0};
 204     LPWSTR key = (LPWSTR)wszProgramKey;
 205
 206     if(subKey)
 207     {
 208         WCHAR backslash[] = {'\\',0};
 209         key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 210                         (lstrlenW(wszProgramKey)+lstrlenW(subKey)+lstrlenW(backslash)+1)
 211                         *sizeof(WCHAR));
 212
 213         if(!key)
 214             return 1;
 215
 216         lstrcpyW(key, wszProgramKey);
 217         lstrcatW(key, backslash);
 218         lstrcatW(key, subKey);
 219     }
 220
 221     if(action)
 222     {
 223         ret = RegCreateKeyExW(HKEY_CURRENT_USER, key, 0, NULL, REG_OPTION_NON_VOLATILE,
 224                               KEY_READ | KEY_WRITE, NULL, hKey, action);
 225     } else
 226     {
 227         ret = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ | KEY_WRITE, hKey);
 228     }
 229
 230     if(subKey)
 231         HeapFree(GetProcessHeap(), 0, key);
 232
 233     return ret;
 234 }
 235
 236 static void truncate_path(LPWSTR file, LPWSTR out, LPWSTR pos1, LPWSTR pos2)
 237 {
 238     static const WCHAR dots[] = {'.','.','.',0};
 239
 240     *++pos1 = 0;
 241
 242     lstrcatW(out, file);
 243     lstrcatW(out, dots);
 244     lstrcatW(out, pos2);
 245 }
 246
 247 static void format_filelist_filename(LPWSTR file, LPWSTR out)
 248 {
 249     LPWSTR pos_basename;
 250     LPWSTR truncpos1, truncpos2;
 251     WCHAR myDocs[MAX_STRING_LEN];
 252
 253     SHGetFolderPathW(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, (LPWSTR)&myDocs);
 254     pos_basename = file_basename(file);
 255     truncpos1 = NULL;
 256     truncpos2 = NULL;
 257
 258     *(pos_basename-1) = 0;
 259     if(!lstrcmpiW(file, myDocs) || (lstrlenW(pos_basename) > FILELIST_ENTRY_LENGTH))
 260     {
 261         truncpos1 = pos_basename;
 262         *(pos_basename-1) = '\\';
 263     } else
 264     {
 265         LPWSTR pos;
 266         BOOL morespace = FALSE;
 267
 268         *(pos_basename-1) = '\\';
 269
 270         for(pos = file; pos < pos_basename; pos++)
 271         {
 272             if(*pos == '\\' || *pos == '/')
 273             {
 274                 if(truncpos1)
 275                 {
 276                     if((pos - file + lstrlenW(pos_basename)) > FILELIST_ENTRY_LENGTH)
 277                         break;
 278
 279                     truncpos1 = pos;
 280                     morespace = TRUE;
 281                     break;
 282                 }
 283
 284                 if((pos - file + lstrlenW(pos_basename)) > FILELIST_ENTRY_LENGTH)
 285                     break;
 286
 287                 truncpos1 = pos;
 288             }
 289         }
 290
 291         if(morespace)
 292         {
 293             for(pos = pos_basename; pos >= truncpos1; pos--)
 294             {
 295                 if(*pos == '\\' || *pos == '/')
 296                 {
 297                     if((truncpos1 - file + lstrlenW(pos_basename) + pos_basename - pos) > FILELIST_ENTRY_LENGTH)
 298                         break;
 299
 300                     truncpos2 = pos;
 301                 }
 302             }
 303         }
 304     }
 305
 306     if(truncpos1 == pos_basename)
 307         lstrcatW(out, pos_basename);
 308     else if(truncpos1 == truncpos2 || !truncpos2)
 309         lstrcatW(out, file);
 310     else
 311         truncate_path(file, out, truncpos1, truncpos2 ? truncpos2 : (pos_basename-1));
 312 }
 313
 314 static void registry_read_filelist(HWND hMainWnd)
 315 {
 316     HKEY hFileKey;
 317
 318     if(registry_get_handle(&hFileKey, 0, key_recentfiles) == ERROR_SUCCESS)
 319     {
 320         WCHAR itemText[MAX_PATH+3], buffer[MAX_PATH];
 321         /* The menu item name is not the same as the file name, so we need to store
 322            the file name here */
 323         static WCHAR file1[MAX_PATH], file2[MAX_PATH], file3[MAX_PATH], file4[MAX_PATH];
 324         WCHAR numFormat[] = {'&','%','d',' ',0};
 325         LPWSTR pFile[] = {file1, file2, file3, file4};
 326         DWORD pathSize = MAX_PATH*sizeof(WCHAR);
 327         int i;
 328         WCHAR key[6];
 329         MENUITEMINFOW mi;
 330         HMENU hMenu = GetMenu(hMainWnd);
 331
 332         mi.cbSize = sizeof(MENUITEMINFOW);
 333         mi.fMask = MIIM_ID | MIIM_DATA | MIIM_STRING | MIIM_FTYPE;
 334         mi.fType = MFT_STRING;
 335         mi.dwTypeData = itemText;
 336         mi.wID = ID_FILE_RECENT1;
 337
 338         RemoveMenu(hMenu, ID_FILE_RECENT_SEPARATOR, MF_BYCOMMAND);
 339         for(i = 0; i < FILELIST_ENTRIES; i++)
 340         {
 341             wsprintfW(key, var_file, i+1);
 342             RemoveMenu(hMenu, ID_FILE_RECENT1+i, MF_BYCOMMAND);
 343             if(RegQueryValueExW(hFileKey, (LPWSTR)key, 0, NULL, (LPBYTE)pFile[i], &pathSize)
 344                != ERROR_SUCCESS)
 345                 break;
 346
 347             mi.dwItemData = (DWORD)pFile[i];
 348             wsprintfW(itemText, numFormat, i+1);
 349
 350             lstrcpyW(buffer, pFile[i]);
 351
 352             format_filelist_filename(buffer, itemText);
 353
 354             InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
 355             mi.wID++;
 356             pathSize = MAX_PATH*sizeof(WCHAR);
 357         }
 358         mi.fType = MFT_SEPARATOR;
 359         mi.fMask = MIIM_FTYPE | MIIM_ID;
 360         InsertMenuItemW(hMenu, ID_FILE_EXIT, FALSE, &mi);
 361
 362         RegCloseKey(hFileKey);
 363     }
 364 }
 365
 366 static void registry_set_filelist(LPCWSTR newFile)
 367 {
 368     HKEY hKey;
 369     DWORD action;
 370
 371     if(registry_get_handle(&hKey, &action, key_recentfiles) == ERROR_SUCCESS)
 372     {
 373         LPCWSTR pFiles[FILELIST_ENTRIES];
 374         int i;
 375         HMENU hMenu = GetMenu(hMainWnd);
 376         MENUITEMINFOW mi;
 377         WCHAR buffer[6];
 378
 379         mi.cbSize = sizeof(MENUITEMINFOW);
 380         mi.fMask = MIIM_DATA;
 381
 382         for(i = 0; i < FILELIST_ENTRIES; i++)
 383             pFiles[i] = NULL;
 384
 385         for(i = 0; GetMenuItemInfoW(hMenu, ID_FILE_RECENT1+i, FALSE, &mi); i++)
 386             pFiles[i] = (LPWSTR)mi.dwItemData;
 387
 388         if(lstrcmpiW(newFile, pFiles[0]))
 389         {
 390             for(i = 0; pFiles[i] && i < FILELIST_ENTRIES; i++)
 391             {
 392                 if(!lstrcmpiW(pFiles[i], newFile))
 393                 {
 394                     int j;
 395                     for(j = 0; pFiles[j] && j < i; j++)
 396                     {
 397                         pFiles[i-j] = pFiles[i-j-1];
 398                     }
 399                     pFiles[0] = NULL;
 400                     break;
 401                 }
 402             }
 403
 404             if(!pFiles[0])
 405             {
 406                 pFiles[0] = newFile;
 407             } else
 408             {
 409                 for(i = 0; pFiles[i] && i < FILELIST_ENTRIES-1; i++)
 410                     pFiles[FILELIST_ENTRIES-1-i] = pFiles[FILELIST_ENTRIES-2-i];
 411
 412                 pFiles[0] = newFile;
 413             }
 414
 415             for(i = 0; pFiles[i] && i < FILELIST_ENTRIES; i++)
 416             {
 417                 wsprintfW(buffer, var_file, i+1);
 418                 RegSetValueExW(hKey, (LPWSTR)&buffer, 0, REG_SZ, (LPBYTE)pFiles[i],
 419                                (lstrlenW(pFiles[i])+1)*sizeof(WCHAR));
 420             }
 421         }
 422     }
 423     RegCloseKey(hKey);
 424     registry_read_filelist(hMainWnd);
 425 }
 426
 427 static void DoOpenFile(LPCWSTR szOpenFileName)
 428 {
 429     HANDLE hFile;
 430     EDITSTREAM es;
 431
 432     hFile = CreateFileW(szOpenFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
 433                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 434     if (hFile == INVALID_HANDLE_VALUE)
 435         return;
 436
 437     es.dwCookie = (DWORD_PTR)hFile;
 438     es.pfnCallback = stream_in;
 439
 440     /* FIXME: Handle different file formats */
 441     SendMessageW(hEditorWnd, EM_STREAMIN, SF_RTF, (LPARAM)&es);
 442
 443     CloseHandle(hFile);
 444
 445     SetFocus(hEditorWnd);
 446
 447     set_caption(szOpenFileName);
 448
 449     lstrcpyW(wszFileName, szOpenFileName);
 450     SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
 451     registry_set_filelist(szOpenFileName);
 452 }
 453
 454 static void DoSaveFile(LPCWSTR wszSaveFileName)
 455 {
 456     HANDLE hFile;
 457     EDITSTREAM stream;
 458     LRESULT ret;
 459
 460     hFile = CreateFileW(wszSaveFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 461         FILE_ATTRIBUTE_NORMAL, NULL);
 462
 463     if(hFile == INVALID_HANDLE_VALUE)
 464         return;
 465
 466     stream.dwCookie = (DWORD_PTR)hFile;
 467     stream.pfnCallback = stream_out;
 468
 469     /* FIXME: Handle different formats */
 470     ret = SendMessageW(hEditorWnd, EM_STREAMOUT, SF_RTF, (LPARAM)&stream);
 471
 472     CloseHandle(hFile);
 473
 474     SetFocus(hEditorWnd);
 475
 476     if(!ret)
 477     {
 478         GETTEXTLENGTHEX gt;
 479         gt.flags = GTL_DEFAULT;
 480         gt.codepage = 1200;
 481
 482         if(SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0))
 483             return;
 484     }
 485
 486     lstrcpyW(wszFileName, wszSaveFileName);
 487     set_caption(wszFileName);
 488     SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
 489 }
 490
 491 static void DialogSaveFile(void)
 492 {
 493     OPENFILENAMEW sfn;
 494
 495     WCHAR wszFile[MAX_PATH] = {'\0'};
 496     static const WCHAR wszDefExt[] = {'r','t','f','\0'};
 497
 498     ZeroMemory(&sfn, sizeof(sfn));
 499
 500     sfn.lStructSize = sizeof(sfn);
 501     sfn.Flags = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
 502     sfn.hwndOwner = hMainWnd;
 503     sfn.lpstrFilter = wszFilter;
 504     sfn.lpstrFile = wszFile;
 505     sfn.nMaxFile = MAX_PATH;
 506     sfn.lpstrDefExt = wszDefExt;
 507
 508     if(!GetSaveFileNameW(&sfn))
 509         return;
 510
 511     DoSaveFile(sfn.lpstrFile);
 512 }
 513
 514 static BOOL prompt_save_changes(void)
 515 {
 516     if(!wszFileName[0])
 517     {
 518         GETTEXTLENGTHEX gt;
 519         gt.flags = GTL_NUMCHARS;
 520         gt.codepage = 1200;
 521         if(!SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0))
 522             return TRUE;
 523     }
 524
 525     if(!SendMessageW(hEditorWnd, EM_GETMODIFY, 0, 0))
 526     {
 527         return TRUE;
 528     } else
 529     {
 530         LPWSTR displayFileName;
 531         WCHAR *text;
 532         int ret;
 533
 534         if(!wszFileName[0])
 535             displayFileName = wszDefaultFileName;
 536         else
 537             displayFileName = wszFileName;
 538
 539         text = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 540                          (lstrlenW(displayFileName)+lstrlenW(wszSaveChanges))*sizeof(WCHAR));
 541
 542         if(!text)
 543             return FALSE;
 544
 545         wsprintfW(text, wszSaveChanges, displayFileName);
 546
 547         ret = MessageBoxW(hMainWnd, text, wszAppTitle, MB_YESNOCANCEL | MB_ICONEXCLAMATION);
 548
 549         HeapFree(GetProcessHeap(), 0, text);
 550
 551         switch(ret)
 552         {
 553             case IDNO:
 554                 return TRUE;
 555
 556             case IDYES:
 557                 if(wszFileName[0])
 558                     DoSaveFile(wszFileName);
 559                 else
 560                     DialogSaveFile();
 561                 return TRUE;
 562
 563             default:
 564                 return FALSE;
 565         }
 566     }
 567 }
 568
 569 static void DialogOpenFile(void)
 570 {
 571     OPENFILENAMEW ofn;
 572
 573     WCHAR wszFile[MAX_PATH] = {'\0'};
 574     static const WCHAR wszDefExt[] = {'r','t','f','\0'};
 575
 576     ZeroMemory(&ofn, sizeof(ofn));
 577
 578     ofn.lStructSize = sizeof(ofn);
 579     ofn.Flags = OFN_HIDEREADONLY | OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
 580     ofn.hwndOwner = hMainWnd;
 581     ofn.lpstrFilter = wszFilter;
 582     ofn.lpstrFile = wszFile;
 583     ofn.nMaxFile = MAX_PATH;
 584     ofn.lpstrDefExt = wszDefExt;
 585
 586     if(GetOpenFileNameW(&ofn))
 587     {
 588         if(prompt_save_changes())
 589             DoOpenFile(ofn.lpstrFile);
 590     }
 591 }
 592
 593 static void HandleCommandLine(LPWSTR cmdline)
 594 {
 595     WCHAR delimiter;
 596     int opt_print = 0;
 597
 598     /* skip white space */
 599     while (*cmdline == ' ') cmdline++;
 600
 601     /* skip executable name */
 602     delimiter = (*cmdline == '"' ? '"' : ' ');
 603
 604     if (*cmdline == delimiter) cmdline++;
 605     while (*cmdline && *cmdline != delimiter) cmdline++;
 606     if (*cmdline == delimiter) cmdline++;
 607
 608     while (*cmdline == ' ' || *cmdline == '-' || *cmdline == '/')
 609     {
 610         WCHAR option;
 611
 612         if (*cmdline++ == ' ') continue;
 613
 614         option = *cmdline;
 615         if (option) cmdline++;
 616         while (*cmdline == ' ') cmdline++;
 617
 618         switch (option)
 619         {
 620             case 'p':
 621             case 'P':
 622                 opt_print = 1;
 623                 break;
 624         }
 625     }
 626
 627     if (*cmdline)
 628     {
 629         /* file name is passed on the command line */
 630         if (cmdline[0] == '"')
 631         {
 632             cmdline++;
 633             cmdline[lstrlenW(cmdline) - 1] = 0;
 634         }
 635         DoOpenFile(cmdline);
 636         InvalidateRect(hMainWnd, NULL, FALSE);
 637     }
 638
 639     if (opt_print)
 640         MessageBox(hMainWnd, "Printing not implemented", "WordPad", MB_OK);
 641 }
 642
 643 static LRESULT handle_findmsg(LPFINDREPLACEW pFr)
 644 {
 645     if(pFr->Flags & FR_DIALOGTERM)
 646     {
 647         hFindWnd = 0;
 648         pFr->Flags = FR_FINDNEXT;
 649         return 0;
 650     } else if(pFr->Flags & FR_FINDNEXT)
 651     {
 652         DWORD flags = FR_DOWN;
 653         FINDTEXTW ft;
 654         static CHARRANGE cr;
 655         LRESULT end, ret;
 656         GETTEXTLENGTHEX gt;
 657         LRESULT length;
 658         int startPos;
 659         HMENU hMenu = GetMenu(hMainWnd);
 660         MENUITEMINFOW mi;
 661
 662         mi.cbSize = sizeof(mi);
 663         mi.fMask = MIIM_DATA;
 664         mi.dwItemData = 1;
 665         SetMenuItemInfoW(hMenu, ID_FIND_NEXT, FALSE, &mi);
 666
 667         gt.flags = GTL_NUMCHARS;
 668         gt.codepage = 1200;
 669
 670         length = SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0);
 671
 672         if(pFr->lCustData == -1)
 673         {
 674             SendMessageW(hEditorWnd, EM_GETSEL, (WPARAM)&startPos, (LPARAM)&end);
 675             cr.cpMin = startPos;
 676             pFr->lCustData = startPos;
 677             cr.cpMax = length;
 678             if(cr.cpMin == length)
 679                 cr.cpMin = 0;
 680         } else
 681         {
 682             startPos = pFr->lCustData;
 683         }
 684
 685         if(cr.cpMax > length)
 686         {
 687             startPos = 0;
 688             cr.cpMin = 0;
 689             cr.cpMax = length;
 690         }
 691
 692         ft.chrg = cr;
 693         ft.lpstrText = pFr->lpstrFindWhat;
 694
 695         if(pFr->Flags & FR_MATCHCASE)
 696             flags |= FR_MATCHCASE;
 697         if(pFr->Flags & FR_WHOLEWORD)
 698             flags |= FR_WHOLEWORD;
 699
 700         ret = SendMessageW(hEditorWnd, EM_FINDTEXTW, (WPARAM)flags, (LPARAM)&ft);
 701
 702         if(ret == -1)
 703         {
 704             if(cr.cpMax == length && cr.cpMax != startPos)
 705             {
 706                 ft.chrg.cpMin = cr.cpMin = 0;
 707                 ft.chrg.cpMax = cr.cpMax = startPos;
 708
 709                 ret = SendMessageW(hEditorWnd, EM_FINDTEXTW, (WPARAM)flags, (LPARAM)&ft);
 710             }
 711         }
 712
 713         if(ret == -1)
 714         {
 715             pFr->lCustData = -1;
 716             MessageBoxW(hMainWnd, MAKEINTRESOURCEW(STRING_SEARCH_FINISHED), wszAppTitle,
 717                         MB_OK | MB_ICONASTERISK);
 718         } else
 719         {
 720             end = ret + lstrlenW(pFr->lpstrFindWhat);
 721             cr.cpMin = end;
 722             SendMessageW(hEditorWnd, EM_SETSEL, (WPARAM)ret, (LPARAM)end);
 723             SendMessageW(hEditorWnd, EM_SCROLLCARET, 0, 0);
 724         }
 725     }
 726
 727     return 0;
 728 }
 729
 730 static void dialog_find(LPFINDREPLACEW fr)
 731 {
 732     static WCHAR findBuffer[MAX_STRING_LEN];
 733
 734     ZeroMemory(fr, sizeof(FINDREPLACEW));
 735     fr->lStructSize = sizeof(FINDREPLACEW);
 736     fr->hwndOwner = hMainWnd;
 737     fr->Flags = FR_HIDEUPDOWN;
 738     fr->lpstrFindWhat = findBuffer;
 739     fr->lCustData = -1;
 740     fr->wFindWhatLen = MAX_STRING_LEN*sizeof(WCHAR);
 741
 742     hFindWnd = FindTextW(fr);
 743 }
 744
 745
 746 static void DoDefaultFont(void)
 747 {
 748     static const WCHAR szFaceName[] = {'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0};
 749     CHARFORMAT2W fmt;
 750
 751     ZeroMemory(&fmt, sizeof(fmt));
 752
 753     fmt.cbSize = sizeof(fmt);
 754     fmt.dwMask = CFM_FACE | CFM_BOLD | CFM_ITALIC | CFM_UNDERLINE;
 755     fmt.dwEffects = 0;
 756
 757     lstrcpyW(fmt.szFaceName, szFaceName);
 758
 759     SendMessageW(hEditorWnd, EM_SETCHARFORMAT,  SCF_DEFAULT, (LPARAM)&fmt);
 760 }
 761
 762 static void update_window(void)
 763 {
 764     RECT rect;
 765
 766     GetWindowRect(hMainWnd, &rect);
 767
 768     (void) OnSize(hMainWnd, SIZE_RESTORED, MAKELONG(rect.bottom, rect.right));
 769 }
 770
 771 static void toggle_toolbar(int bandId)
 772 {
 773     HWND hwndReBar = GetDlgItem(hMainWnd, IDC_REBAR);
 774     REBARBANDINFOW rbbinfo;
 775     BOOL hide = TRUE;
 776
 777     if(!hwndReBar)
 778         return;
 779
 780     rbbinfo.cbSize = sizeof(rbbinfo);
 781     rbbinfo.fMask = RBBIM_STYLE | RBBIM_SIZE;
 782
 783     SendMessageW(hwndReBar, RB_GETBANDINFO, bandId, (LPARAM)&rbbinfo);
 784
 785     if(rbbinfo.fStyle & RBBS_HIDDEN)
 786         hide = FALSE;
 787
 788     SendMessageW(hwndReBar, RB_SHOWBAND, bandId, hide ? 0 : 1);
 789
 790     if(bandId == BANDID_TOOLBAR)
 791     {
 792         rbbinfo.fMask ^= RBBIM_SIZE;
 793
 794         SendMessageW(hwndReBar, RB_GETBANDINFO, BANDID_FORMATBAR, (LPARAM)&rbbinfo);
 795
 796         if(hide)
 797             rbbinfo.fStyle ^= RBBS_BREAK;
 798         else
 799             rbbinfo.fStyle |= RBBS_BREAK;
 800
 801         SendMessageW(hwndReBar, RB_SETBANDINFO, BANDID_FORMATBAR, (LPARAM)&rbbinfo);
 802     }
 803 }
 804
 805 BOOL CALLBACK datetime_proc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 806 {
 807     switch(message)
 808     {
 809         case WM_INITDIALOG:
 810             {
 811                 WCHAR buffer[MAX_STRING_LEN];
 812                 SYSTEMTIME st;
 813                 HWND hListWnd = GetDlgItem(hWnd, IDC_DATETIME);
 814                 GetLocalTime(&st);
 815
 816                 GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, 0, (LPWSTR)&buffer,
 817                                MAX_STRING_LEN);
 818                 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
 819                 GetDateFormatW(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, 0, (LPWSTR)&buffer,
 820                                MAX_STRING_LEN);
 821                 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
 822                 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &st, 0, (LPWSTR)&buffer, MAX_STRING_LEN);
 823                 SendMessageW(hListWnd, LB_ADDSTRING, 0, (LPARAM)&buffer);
 824
 825                 SendMessageW(hListWnd, LB_SETSEL, TRUE, 0);
 826             }
 827             break;
 828
 829         case WM_COMMAND:
 830             switch(LOWORD(wParam))
 831             {
 832                 case IDOK:
 833                     {
 834                         LRESULT index;
 835                         HWND hListWnd = GetDlgItem(hWnd, IDC_DATETIME);
 836
 837                         index = SendMessageW(hListWnd, LB_GETCURSEL, 0, 0);
 838
 839                         if(index != LB_ERR)
 840                         {
 841                             WCHAR buffer[MAX_STRING_LEN];
 842                             SendMessageW(hListWnd, LB_GETTEXT, index, (LPARAM)&buffer);
 843                             SendMessageW(hEditorWnd, EM_REPLACESEL, TRUE, (LPARAM)&buffer);
 844                         }
 845                     }
 846                     /* Fall through */
 847
 848                 case IDCANCEL:
 849                     EndDialog(hWnd, wParam);
 850                     return TRUE;
 851             }
 852     }
 853     return FALSE;
 854 }
 855
 856 static LRESULT OnCreate( HWND hWnd, WPARAM wParam, LPARAM lParam)
 857 {
 858     HWND hToolBarWnd, hFormatBarWnd,  hReBarWnd;
 859     HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE);
 860     HANDLE hDLL;
 861     TBADDBITMAP ab;
 862     int nStdBitmaps = 0;
 863     REBARINFO rbi;
 864     REBARBANDINFOW rbb;
 865     static const WCHAR wszRichEditDll[] = {'R','I','C','H','E','D','2','0','.','D','L','L','\0'};
 866     static const WCHAR wszRichEditText[] = {'R','i','c','h','E','d','i','t',' ','t','e','x','t','\0'};
 867
 868     CreateStatusWindowW(CCS_NODIVIDER|WS_CHILD|WS_VISIBLE, wszRichEditText, hWnd, IDC_STATUSBAR);
 869
 870     hReBarWnd = CreateWindowExW(WS_EX_TOOLWINDOW, REBARCLASSNAMEW, NULL,
 871       CCS_NODIVIDER|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|RBS_VARHEIGHT|CCS_TOP,
 872       CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, hWnd, (HMENU)IDC_REBAR, hInstance, NULL);
 873
 874     rbi.cbSize = sizeof(rbi);
 875     rbi.fMask = 0;
 876     rbi.himl = NULL;
 877     if(!SendMessageW(hReBarWnd, RB_SETBARINFO, 0, (LPARAM)&rbi))
 878         return -1;
 879
 880     hToolBarWnd = CreateToolbarEx(hReBarWnd, CCS_NOPARENTALIGN|CCS_NOMOVEY|WS_VISIBLE|WS_CHILD|TBSTYLE_TOOLTIPS|TBSTYLE_BUTTON,
 881       IDC_TOOLBAR,
 882       1, hInstance, IDB_TOOLBAR,
 883       NULL, 0,
 884       24, 24, 16, 16, sizeof(TBBUTTON));
 885
 886     ab.hInst = HINST_COMMCTRL;
 887     ab.nID = IDB_STD_SMALL_COLOR;
 888     nStdBitmaps = SendMessageW(hToolBarWnd, TB_ADDBITMAP, 0, (LPARAM)&ab);
 889
 890     AddButton(hToolBarWnd, nStdBitmaps+STD_FILENEW, ID_FILE_NEW);
 891     AddButton(hToolBarWnd, nStdBitmaps+STD_FILEOPEN, ID_FILE_OPEN);
 892     AddButton(hToolBarWnd, nStdBitmaps+STD_FILESAVE, ID_FILE_SAVE);
 893     AddSeparator(hToolBarWnd);
 894     AddButton(hToolBarWnd, nStdBitmaps+STD_PRINT, ID_PRINT);
 895     AddButton(hToolBarWnd, nStdBitmaps+STD_PRINTPRE, ID_PREVIEW);
 896     AddSeparator(hToolBarWnd);
 897     AddButton(hToolBarWnd, nStdBitmaps+STD_FIND, ID_FIND);
 898     AddSeparator(hToolBarWnd);
 899     AddButton(hToolBarWnd, nStdBitmaps+STD_CUT, ID_EDIT_CUT);
 900     AddButton(hToolBarWnd, nStdBitmaps+STD_COPY, ID_EDIT_COPY);
 901     AddButton(hToolBarWnd, nStdBitmaps+STD_PASTE, ID_EDIT_PASTE);
 902     AddButton(hToolBarWnd, nStdBitmaps+STD_UNDO, ID_EDIT_UNDO);
 903     AddButton(hToolBarWnd, nStdBitmaps+STD_REDOW, ID_EDIT_REDO);
 904     AddSeparator(hToolBarWnd);
 905     AddButton(hToolBarWnd, 0, ID_DATETIME);
 906
 907     SendMessageW(hToolBarWnd, TB_AUTOSIZE, 0, 0);
 908
 909     rbb.cbSize = sizeof(rbb);
 910     rbb.fMask = RBBIM_SIZE | RBBIM_CHILDSIZE | RBBIM_CHILD | RBBIM_STYLE;
 911     rbb.fStyle = RBBS_CHILDEDGE | RBBS_BREAK | RBBS_NOGRIPPER;
 912     rbb.cx = 0;
 913     rbb.hwndChild = hToolBarWnd;
 914     rbb.cxMinChild = 0;
 915     rbb.cyChild = rbb.cyMinChild = HIWORD(SendMessageW(hToolBarWnd, TB_GETBUTTONSIZE, 0, 0));
 916
 917     SendMessageW(hReBarWnd, RB_INSERTBAND, BANDID_TOOLBAR, (LPARAM)&rbb);
 918
 919     hFormatBarWnd = CreateToolbarEx(hReBarWnd,
 920          CCS_NOPARENTALIGN | CCS_NOMOVEY | WS_VISIBLE | TBSTYLE_TOOLTIPS | TBSTYLE_BUTTON,
 921          IDC_FORMATBAR, 7, hInstance, IDB_FORMATBAR, NULL, 0, 16, 16, 16, 16, sizeof(TBBUTTON));
 922
 923     AddButton(hFormatBarWnd, 0, ID_FORMAT_BOLD);
 924     AddButton(hFormatBarWnd, 1, ID_FORMAT_ITALIC);
 925     AddButton(hFormatBarWnd, 2, ID_FORMAT_UNDERLINE);
 926     AddSeparator(hFormatBarWnd);
 927     AddButton(hFormatBarWnd, 3, ID_ALIGN_LEFT);
 928     AddButton(hFormatBarWnd, 4, ID_ALIGN_CENTER);
 929     AddButton(hFormatBarWnd, 5, ID_ALIGN_RIGHT);
 930     AddSeparator(hFormatBarWnd);
 931     AddButton(hFormatBarWnd, 6, ID_BULLET);
 932
 933     SendMessageW(hFormatBarWnd, TB_AUTOSIZE, 0, 0);
 934
 935     rbb.hwndChild = hFormatBarWnd;
 936
 937     SendMessageW(hReBarWnd, RB_INSERTBAND, BANDID_FORMATBAR, (LPARAM)&rbb);
 938
 939     hDLL = LoadLibraryW(wszRichEditDll);
 940     if(!hDLL)
 941     {
 942         MessageBoxW(hWnd, MAKEINTRESOURCEW(STRING_LOAD_RICHED_FAILED), wszAppTitle,
 943                     MB_OK | MB_ICONEXCLAMATION);
 944         PostQuitMessage(1);
 945     }
 946
 947     hEditorWnd = CreateWindowExW(WS_EX_CLIENTEDGE, wszRichEditClass, NULL,
 948       WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_AUTOVSCROLL|ES_WANTRETURN|WS_VSCROLL,
 949       0, 0, 1000, 100, hWnd, (HMENU)IDC_EDITOR, hInstance, NULL);
 950
 951     if (!hEditorWnd)
 952     {
 953         fprintf(stderr, "Error code %u\n", GetLastError());
 954         return -1;
 955     }
 956     assert(hEditorWnd);
 957
 958     SetFocus(hEditorWnd);
 959     SendMessageW(hEditorWnd, EM_SETEVENTMASK, 0, ENM_SELCHANGE);
 960
 961     DoDefaultFont();
 962
 963     DoLoadStrings();
 964     SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
 965
 966     ID_FINDMSGSTRING = RegisterWindowMessageW(FINDMSGSTRINGW);
 967
 968     registry_read_filelist(hWnd);
 969
 970     return 0;
 971 }
 972
 973 static LRESULT OnUser( HWND hWnd, WPARAM wParam, LPARAM lParam)
 974 {
 975     HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
 976     HWND hwndReBar = GetDlgItem(hWnd, IDC_REBAR);
 977     HWND hwndToolBar = GetDlgItem(hwndReBar, IDC_TOOLBAR);
 978     HWND hwndFormatBar = GetDlgItem(hwndReBar, IDC_FORMATBAR);
 979     int from, to;
 980     CHARFORMAT2W fmt;
 981     PARAFORMAT2 pf;
 982     GETTEXTLENGTHEX gt;
 983
 984     ZeroMemory(&fmt, sizeof(fmt));
 985     fmt.cbSize = sizeof(fmt);
 986
 987     ZeroMemory(&pf, sizeof(pf));
 988     pf.cbSize = sizeof(pf);
 989
 990     gt.flags = GTL_NUMCHARS;
 991     gt.codepage = 1200;
 992
 993     SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_FIND,
 994                  SendMessageW(hwndEditor, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0) ? 1 : 0);
 995
 996     SendMessageW(hwndEditor, EM_GETCHARFORMAT, TRUE, (LPARAM)&fmt);
 997
 998     SendMessageW(hwndEditor, EM_GETSEL, (WPARAM)&from, (LPARAM)&to);
 999     SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_UNDO,
1000       SendMessageW(hwndEditor, EM_CANUNDO, 0, 0));
1001     SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_REDO,
1002       SendMessageW(hwndEditor, EM_CANREDO, 0, 0));
1003     SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_CUT, from == to ? 0 : 1);
1004     SendMessageW(hwndToolBar, TB_ENABLEBUTTON, ID_EDIT_COPY, from == to ? 0 : 1);
1005
1006     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_FORMAT_BOLD, (fmt.dwMask & CFM_BOLD) &&
1007             (fmt.dwEffects & CFE_BOLD));
1008     SendMessageW(hwndFormatBar, TB_INDETERMINATE, ID_FORMAT_BOLD, !(fmt.dwMask & CFM_BOLD));
1009     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_FORMAT_ITALIC, (fmt.dwMask & CFM_ITALIC) &&
1010             (fmt.dwEffects & CFE_ITALIC));
1011     SendMessageW(hwndFormatBar, TB_INDETERMINATE, ID_FORMAT_ITALIC, !(fmt.dwMask & CFM_ITALIC));
1012     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_FORMAT_UNDERLINE, (fmt.dwMask & CFM_UNDERLINE) &&
1013             (fmt.dwEffects & CFE_UNDERLINE));
1014     SendMessageW(hwndFormatBar, TB_INDETERMINATE, ID_FORMAT_UNDERLINE, !(fmt.dwMask & CFM_UNDERLINE));
1015
1016     SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1017     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_ALIGN_LEFT, (pf.wAlignment == PFA_LEFT));
1018     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_ALIGN_CENTER, (pf.wAlignment == PFA_CENTER));
1019     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_ALIGN_RIGHT, (pf.wAlignment == PFA_RIGHT));
1020
1021     SendMessageW(hwndFormatBar, TB_CHECKBUTTON, ID_BULLET, (pf.wNumbering & PFN_BULLET));
1022     return 0;
1023 }
1024
1025 static LRESULT OnNotify( HWND hWnd, WPARAM wParam, LPARAM lParam)
1026 {
1027     HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
1028     NMHDR *pHdr = (NMHDR *)lParam;
1029
1030     if (pHdr->hwndFrom != hwndEditor)
1031         return 0;
1032
1033     if (pHdr->code == EN_SELCHANGE)
1034     {
1035         SELCHANGE *pSC = (SELCHANGE *)lParam;
1036         char buf[128];
1037
1038         sprintf( buf,"selection = %d..%d, line count=%ld",
1039                  pSC->chrg.cpMin, pSC->chrg.cpMax,
1040         SendMessage(hwndEditor, EM_GETLINECOUNT, 0, 0));
1041         SetWindowText(GetDlgItem(hWnd, IDC_STATUSBAR), buf);
1042         SendMessage(hWnd, WM_USER, 0, 0);
1043         return 1;
1044     }
1045     return 0;
1046 }
1047
1048 static LRESULT OnCommand( HWND hWnd, WPARAM wParam, LPARAM lParam)
1049 {
1050     HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
1051     HWND hwndStatus = GetDlgItem(hWnd, IDC_STATUSBAR);
1052     static FINDREPLACEW findreplace;
1053
1054     if ((HWND)lParam == hwndEditor)
1055         return 0;
1056
1057     switch(LOWORD(wParam))
1058     {
1059
1060     case ID_FILE_EXIT:
1061         PostMessageW(hWnd, WM_CLOSE, 0, 0);
1062         break;
1063
1064     case ID_FILE_NEW:
1065         if(prompt_save_changes())
1066         {
1067             set_caption(NULL);
1068             wszFileName[0] = '\0';
1069             SetWindowTextW(hwndEditor, wszFileName);
1070             SendMessageW(hEditorWnd, EM_SETMODIFY, FALSE, 0);
1071             /* FIXME: set default format too */
1072         }
1073         break;
1074
1075     case ID_FILE_OPEN:
1076         DialogOpenFile();
1077         break;
1078
1079     case ID_FILE_SAVE:
1080         if(wszFileName[0])
1081         {
1082             DoSaveFile(wszFileName);
1083             break;
1084         }
1085         /* Fall through */
1086
1087     case ID_FILE_SAVEAS:
1088         DialogSaveFile();
1089         break;
1090
1091     case ID_FILE_RECENT1:
1092     case ID_FILE_RECENT2:
1093     case ID_FILE_RECENT3:
1094     case ID_FILE_RECENT4:
1095         {
1096             HMENU hMenu = GetMenu(hWnd);
1097             MENUITEMINFOW mi;
1098
1099             mi.cbSize = sizeof(MENUITEMINFOW);
1100             mi.fMask = MIIM_DATA;
1101             if(GetMenuItemInfoW(hMenu, LOWORD(wParam), FALSE, &mi))
1102                 DoOpenFile((LPWSTR)mi.dwItemData);
1103         }
1104         break;
1105
1106     case ID_FIND:
1107         dialog_find(&findreplace);
1108         break;
1109
1110     case ID_FIND_NEXT:
1111         handle_findmsg(&findreplace);
1112         break;
1113
1114     case ID_PRINT:
1115     case ID_PREVIEW:
1116         {
1117             static const WCHAR wszNotImplemented[] = {'N','o','t',' ',
1118                                                       'i','m','p','l','e','m','e','n','t','e','d','\0'};
1119             MessageBoxW(hWnd, wszNotImplemented, wszAppTitle, MB_OK);
1120         }
1121         break;
1122
1123     case ID_FORMAT_BOLD:
1124     case ID_FORMAT_ITALIC:
1125     case ID_FORMAT_UNDERLINE:
1126         {
1127         CHARFORMAT2W fmt;
1128         int mask = CFM_BOLD;
1129         if (LOWORD(wParam) == ID_FORMAT_ITALIC) mask = CFM_ITALIC;
1130         if (LOWORD(wParam) == ID_FORMAT_UNDERLINE) mask = CFM_UNDERLINE;
1131
1132         ZeroMemory(&fmt, sizeof(fmt));
1133         fmt.cbSize = sizeof(fmt);
1134         SendMessageW(hwndEditor, EM_GETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
1135         if (!(fmt.dwMask&mask))
1136             fmt.dwEffects |= mask;
1137         else
1138             fmt.dwEffects ^= mask;
1139         fmt.dwMask = mask;
1140         SendMessageW(hwndEditor, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&fmt);
1141         break;
1142         }
1143
1144     case ID_EDIT_CUT:
1145         PostMessageW(hwndEditor, WM_CUT, 0, 0);
1146         break;
1147
1148     case ID_EDIT_COPY:
1149         PostMessageW(hwndEditor, WM_COPY, 0, 0);
1150         break;
1151
1152     case ID_EDIT_PASTE:
1153         PostMessageW(hwndEditor, WM_PASTE, 0, 0);
1154         break;
1155
1156     case ID_EDIT_CLEAR:
1157         PostMessageW(hwndEditor, WM_CLEAR, 0, 0);
1158         break;
1159
1160     case ID_EDIT_SELECTALL:
1161         {
1162         CHARRANGE range = {0, -1};
1163         SendMessageW(hwndEditor, EM_EXSETSEL, 0, (LPARAM)&range);
1164         /* SendMessage(hwndEditor, EM_SETSEL, 0, -1); */
1165         return 0;
1166         }
1167
1168     case ID_EDIT_GETTEXT:
1169         {
1170         int nLen = GetWindowTextLengthW(hwndEditor);
1171         LPWSTR data = HeapAlloc( GetProcessHeap(), 0, (nLen+1)*sizeof(WCHAR) );
1172         TEXTRANGEW tr;
1173
1174         GetWindowTextW(hwndEditor, data, nLen+1);
1175         MessageBoxW(NULL, data, xszAppTitle, MB_OK);
1176
1177         HeapFree( GetProcessHeap(), 0, data);
1178         data = HeapAlloc(GetProcessHeap(), 0, (nLen+1)*sizeof(WCHAR));
1179         tr.chrg.cpMin = 0;
1180         tr.chrg.cpMax = nLen;
1181         tr.lpstrText = data;
1182         SendMessage (hwndEditor, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
1183         MessageBoxW(NULL, data, xszAppTitle, MB_OK);
1184         HeapFree( GetProcessHeap(), 0, data );
1185
1186         /* SendMessage(hwndEditor, EM_SETSEL, 0, -1); */
1187         return 0;
1188         }
1189
1190     case ID_EDIT_CHARFORMAT:
1191     case ID_EDIT_DEFCHARFORMAT:
1192         {
1193         CHARFORMAT2W cf;
1194         LRESULT i;
1195         ZeroMemory(&cf, sizeof(cf));
1196         cf.cbSize = sizeof(cf);
1197         cf.dwMask = 0;
1198         i = SendMessageW(hwndEditor, EM_GETCHARFORMAT,
1199                         LOWORD(wParam) == ID_EDIT_CHARFORMAT, (LPARAM)&cf);
1200         return 0;
1201         }
1202
1203     case ID_EDIT_PARAFORMAT:
1204         {
1205         PARAFORMAT2 pf;
1206         ZeroMemory(&pf, sizeof(pf));
1207         pf.cbSize = sizeof(pf);
1208         SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1209         return 0;
1210         }
1211
1212     case ID_EDIT_SELECTIONINFO:
1213         {
1214         CHARRANGE range = {0, -1};
1215         char buf[128];
1216         WCHAR *data = NULL;
1217
1218         SendMessage(hwndEditor, EM_EXGETSEL, 0, (LPARAM)&range);
1219         data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data) * (range.cpMax-range.cpMin+1));
1220         SendMessage(hwndEditor, EM_GETSELTEXT, 0, (LPARAM)data);
1221         sprintf(buf, "Start = %d, End = %d", range.cpMin, range.cpMax);
1222         MessageBoxA(hWnd, buf, "Editor", MB_OK);
1223         MessageBoxW(hWnd, data, xszAppTitle, MB_OK);
1224         HeapFree( GetProcessHeap(), 0, data);
1225         /* SendMessage(hwndEditor, EM_SETSEL, 0, -1); */
1226         return 0;
1227         }
1228
1229     case ID_EDIT_READONLY:
1230         {
1231         long nStyle = GetWindowLong(hwndEditor, GWL_STYLE);
1232         if (nStyle & ES_READONLY)
1233             SendMessageW(hwndEditor, EM_SETREADONLY, 0, 0);
1234         else
1235             SendMessageW(hwndEditor, EM_SETREADONLY, 1, 0);
1236         return 0;
1237         }
1238
1239     case ID_EDIT_MODIFIED:
1240         if (SendMessageW(hwndEditor, EM_GETMODIFY, 0, 0))
1241             SendMessageW(hwndEditor, EM_SETMODIFY, 0, 0);
1242         else
1243             SendMessageW(hwndEditor, EM_SETMODIFY, 1, 0);
1244         return 0;
1245
1246     case ID_EDIT_UNDO:
1247         SendMessageW(hwndEditor, EM_UNDO, 0, 0);
1248         return 0;
1249
1250     case ID_EDIT_REDO:
1251         SendMessageW(hwndEditor, EM_REDO, 0, 0);
1252         return 0;
1253
1254     case ID_BULLET:
1255         {
1256             PARAFORMAT pf;
1257
1258             pf.cbSize = sizeof(pf);
1259             pf.dwMask = PFM_NUMBERING;
1260             SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1261
1262             pf.dwMask |=  PFM_OFFSET;
1263
1264             if(pf.wNumbering == PFN_BULLET)
1265             {
1266                 pf.wNumbering = 0;
1267                 pf.dxOffset = 0;
1268             } else
1269             {
1270                 pf.wNumbering = PFN_BULLET;
1271                 pf.dxOffset = 720;
1272             }
1273
1274             SendMessageW(hwndEditor, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
1275         }
1276         break;
1277
1278     case ID_ALIGN_LEFT:
1279     case ID_ALIGN_CENTER:
1280     case ID_ALIGN_RIGHT:
1281         {
1282         PARAFORMAT2 pf;
1283
1284         pf.cbSize = sizeof(pf);
1285         pf.dwMask = PFM_ALIGNMENT;
1286         switch(LOWORD(wParam)) {
1287         case ID_ALIGN_LEFT: pf.wAlignment = PFA_LEFT; break;
1288         case ID_ALIGN_CENTER: pf.wAlignment = PFA_CENTER; break;
1289         case ID_ALIGN_RIGHT: pf.wAlignment = PFA_RIGHT; break;
1290         }
1291         SendMessageW(hwndEditor, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
1292         break;
1293         }
1294
1295     case ID_BACK_1:
1296         SendMessageW(hwndEditor, EM_SETBKGNDCOLOR, 1, 0);
1297         break;
1298
1299     case ID_BACK_2:
1300         SendMessageW(hwndEditor, EM_SETBKGNDCOLOR, 0, RGB(255,255,192));
1301         break;
1302
1303     case ID_TOGGLE_TOOLBAR:
1304         toggle_toolbar(BANDID_TOOLBAR);
1305         update_window();
1306         break;
1307
1308     case ID_TOGGLE_FORMATBAR:
1309         toggle_toolbar(BANDID_FORMATBAR);
1310         update_window();
1311         break;
1312
1313     case ID_TOGGLE_STATUSBAR:
1314         ShowWindow(hwndStatus, IsWindowVisible(hwndStatus) ? SW_HIDE : SW_SHOW);
1315         update_window();
1316         break;
1317
1318     case ID_DATETIME:
1319         {
1320         HINSTANCE hInstance = (HINSTANCE)GetWindowLongPtr(hWnd, GWLP_HINSTANCE);
1321         DialogBoxW(hInstance, MAKEINTRESOURCEW(IDD_DATETIME), hWnd, (DLGPROC)datetime_proc);
1322         break;
1323         }
1324
1325     default:
1326         SendMessageW(hwndEditor, WM_COMMAND, wParam, lParam);
1327         break;
1328     }
1329     return 0;
1330 }
1331
1332 static LRESULT OnInitPopupMenu( HWND hWnd, WPARAM wParam, LPARAM lParam )
1333 {
1334     HMENU hMenu = (HMENU)wParam;
1335     HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
1336     HWND hwndReBar = GetDlgItem(hWnd, IDC_REBAR);
1337     HWND hwndStatus = GetDlgItem(hWnd, IDC_STATUSBAR);
1338     PARAFORMAT pf;
1339     int nAlignment = -1;
1340     REBARBANDINFOW rbbinfo;
1341     int selFrom, selTo;
1342     GETTEXTLENGTHEX gt;
1343     LRESULT textLength;
1344     MENUITEMINFOW mi;
1345
1346     SendMessageW(hEditorWnd, EM_GETSEL, (WPARAM)&selFrom, (LPARAM)&selTo);
1347     EnableMenuItem(hMenu, ID_EDIT_COPY, MF_BYCOMMAND|(selFrom == selTo) ? MF_GRAYED : MF_ENABLED);
1348     EnableMenuItem(hMenu, ID_EDIT_CUT, MF_BYCOMMAND|(selFrom == selTo) ? MF_GRAYED : MF_ENABLED);
1349
1350     pf.cbSize = sizeof(PARAFORMAT);
1351     SendMessageW(hwndEditor, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
1352     CheckMenuItem(hMenu, ID_EDIT_READONLY,
1353       MF_BYCOMMAND|(GetWindowLong(hwndEditor, GWL_STYLE)&ES_READONLY ? MF_CHECKED : MF_UNCHECKED));
1354     CheckMenuItem(hMenu, ID_EDIT_MODIFIED,
1355       MF_BYCOMMAND|(SendMessage(hwndEditor, EM_GETMODIFY, 0, 0) ? MF_CHECKED : MF_UNCHECKED));
1356     if (pf.dwMask & PFM_ALIGNMENT)
1357         nAlignment = pf.wAlignment;
1358     CheckMenuItem(hMenu, ID_ALIGN_LEFT, MF_BYCOMMAND|(nAlignment == PFA_LEFT) ?
1359             MF_CHECKED : MF_UNCHECKED);
1360     CheckMenuItem(hMenu, ID_ALIGN_CENTER, MF_BYCOMMAND|(nAlignment == PFA_CENTER) ?
1361             MF_CHECKED : MF_UNCHECKED);
1362     CheckMenuItem(hMenu, ID_ALIGN_RIGHT, MF_BYCOMMAND|(nAlignment == PFA_RIGHT) ?
1363             MF_CHECKED : MF_UNCHECKED);
1364     CheckMenuItem(hMenu, ID_BULLET, MF_BYCOMMAND | ((pf.wNumbering == PFN_BULLET) ?
1365             MF_CHECKED : MF_UNCHECKED));
1366     EnableMenuItem(hMenu, ID_EDIT_UNDO, MF_BYCOMMAND|(SendMessageW(hwndEditor, EM_CANUNDO, 0, 0)) ?
1367             MF_ENABLED : MF_GRAYED);
1368     EnableMenuItem(hMenu, ID_EDIT_REDO, MF_BYCOMMAND|(SendMessageW(hwndEditor, EM_CANREDO, 0, 0)) ?
1369             MF_ENABLED : MF_GRAYED);
1370
1371     rbbinfo.cbSize = sizeof(rbbinfo);
1372     rbbinfo.fMask = RBBIM_STYLE;
1373     SendMessageW(hwndReBar, RB_GETBANDINFO, BANDID_TOOLBAR, (LPARAM)&rbbinfo);
1374
1375     CheckMenuItem(hMenu, ID_TOGGLE_TOOLBAR, MF_BYCOMMAND|(rbbinfo.fStyle & RBBS_HIDDEN) ?
1376             MF_UNCHECKED : MF_CHECKED);
1377
1378     SendMessageW(hwndReBar, RB_GETBANDINFO, BANDID_FORMATBAR, (LPARAM)&rbbinfo);
1379
1380     CheckMenuItem(hMenu, ID_TOGGLE_FORMATBAR, MF_BYCOMMAND|(rbbinfo.fStyle & RBBS_HIDDEN) ?
1381             MF_UNCHECKED : MF_CHECKED);
1382
1383     CheckMenuItem(hMenu, ID_TOGGLE_STATUSBAR, MF_BYCOMMAND|IsWindowVisible(hwndStatus) ?
1384             MF_CHECKED : MF_UNCHECKED);
1385
1386     gt.flags = GTL_NUMCHARS;
1387     gt.codepage = 1200;
1388     textLength = SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0);
1389     EnableMenuItem(hMenu, ID_FIND, MF_BYCOMMAND|(textLength ? MF_ENABLED : MF_GRAYED));
1390
1391     mi.cbSize = sizeof(mi);
1392     mi.fMask = MIIM_DATA;
1393
1394     GetMenuItemInfoW(hMenu, ID_FIND_NEXT, FALSE, &mi);
1395
1396     EnableMenuItem(hMenu, ID_FIND_NEXT, MF_BYCOMMAND|((textLength && mi.dwItemData) ?
1397                    MF_ENABLED : MF_GRAYED));
1398     return 0;
1399 }
1400
1401 static LRESULT OnSize( HWND hWnd, WPARAM wParam, LPARAM lParam )
1402 {
1403     int nStatusSize = 0;
1404     RECT rc;
1405     HWND hwndEditor = GetDlgItem(hWnd, IDC_EDITOR);
1406     HWND hwndStatusBar = GetDlgItem(hWnd, IDC_STATUSBAR);
1407     HWND hwndReBar = GetDlgItem(hWnd, IDC_REBAR);
1408     int rebarHeight = 0;
1409     REBARBANDINFOW rbbinfo;
1410     int rebarRows = 2;
1411
1412     if (hwndStatusBar)
1413     {
1414         SendMessageW(hwndStatusBar, WM_SIZE, 0, 0);
1415         if (IsWindowVisible(hwndStatusBar))
1416         {
1417             GetClientRect(hwndStatusBar, &rc);
1418             nStatusSize = rc.bottom - rc.top;
1419         } else
1420         {
1421             nStatusSize = 0;
1422         }
1423     }
1424     if (hwndReBar)
1425     {
1426         rbbinfo.cbSize = sizeof(rbbinfo);
1427         rbbinfo.fMask = RBBIM_STYLE;
1428
1429         SendMessageW(hwndReBar, RB_GETBANDINFO, BANDID_TOOLBAR, (LPARAM)&rbbinfo);
1430         if(rbbinfo.fStyle & RBBS_HIDDEN)
1431             rebarRows--;
1432
1433         SendMessageW(hwndReBar, RB_GETBANDINFO, BANDID_FORMATBAR, (LPARAM)&rbbinfo);
1434         if(rbbinfo.fStyle & RBBS_HIDDEN)
1435             rebarRows--;
1436
1437         rebarHeight = rebarRows ? SendMessageW(hwndReBar, RB_GETBARHEIGHT, 0, 0) : 0;
1438
1439         rc.top = rc.left = 0;
1440         rc.bottom = rebarHeight;
1441         rc.right = LOWORD(lParam);
1442         SendMessageW(hwndReBar, RB_SIZETORECT, 0, (LPARAM)&rc);
1443     }
1444     if (hwndEditor)
1445     {
1446         GetClientRect(hWnd, &rc);
1447         MoveWindow(hwndEditor, 0, rebarHeight, rc.right, rc.bottom-nStatusSize-rebarHeight, TRUE);
1448     }
1449
1450     return DefWindowProcW(hWnd, WM_SIZE, wParam, lParam);
1451 }
1452
1453 static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1454 {
1455     if(msg == ID_FINDMSGSTRING)
1456         return handle_findmsg((LPFINDREPLACEW)lParam);
1457
1458     switch(msg)
1459     {
1460     case WM_CREATE:
1461         return OnCreate( hWnd, wParam, lParam );
1462
1463     case WM_USER:
1464         return OnUser( hWnd, wParam, lParam );
1465
1466     case WM_NOTIFY:
1467         return OnNotify( hWnd, wParam, lParam );
1468
1469     case WM_COMMAND:
1470         return OnCommand( hWnd, wParam, lParam );
1471
1472     case WM_DESTROY:
1473         PostQuitMessage(0);
1474         break;
1475
1476     case WM_CLOSE:
1477         if(prompt_save_changes())
1478             PostQuitMessage(0);
1479         break;
1480
1481     case WM_ACTIVATE:
1482         if (LOWORD(wParam))
1483             SetFocus(GetDlgItem(hWnd, IDC_EDITOR));
1484         return 0;
1485
1486     case WM_INITMENUPOPUP:
1487         return OnInitPopupMenu( hWnd, wParam, lParam );
1488
1489     case WM_SIZE:
1490         return OnSize( hWnd, wParam, lParam );
1491
1492     default:
1493         return DefWindowProcW(hWnd, msg, wParam, lParam);
1494     }
1495
1496     return 0;
1497 }
1498
1499 int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hOldInstance, LPSTR szCmdParagraph, int res)
1500 {
1501     INITCOMMONCONTROLSEX classes = {8, ICC_BAR_CLASSES|ICC_COOL_CLASSES};
1502     HACCEL hAccel;
1503     WNDCLASSW wc;
1504     MSG msg;
1505     static const WCHAR wszAccelTable[] = {'M','A','I','N','A','C','C','E','L',
1506                                           'T','A','B','L','E','\0'};
1507
1508     InitCommonControlsEx(&classes);
1509
1510     hAccel = LoadAcceleratorsW(hInstance, wszAccelTable);
1511
1512     wc.style = CS_HREDRAW | CS_VREDRAW;
1513     wc.lpfnWndProc = WndProc;
1514     wc.cbClsExtra = 0;
1515     wc.cbWndExtra = 4;
1516     wc.hInstance = hInstance;
1517     wc.hIcon = LoadIconW(hInstance, MAKEINTRESOURCEW(IDI_WORDPAD));
1518     wc.hCursor = LoadCursor(NULL, IDC_IBEAM);
1519     wc.hbrBackground = GetSysColorBrush(COLOR_WINDOW);
1520     wc.lpszMenuName = xszMainMenu;
1521     wc.lpszClassName = wszMainWndClass;
1522     RegisterClassW(&wc);
1523
1524     hMainWnd = CreateWindowExW(0, wszMainWndClass, wszAppTitle, WS_OVERLAPPEDWINDOW,
1525       CW_USEDEFAULT, CW_USEDEFAULT, 680, 260, NULL, NULL, hInstance, NULL);
1526     ShowWindow(hMainWnd, SW_SHOWDEFAULT);
1527
1528     set_caption(NULL);
1529
1530     HandleCommandLine(GetCommandLineW());
1531
1532     while(GetMessageW(&msg,0,0,0))
1533     {
1534         if (IsDialogMessage(hFindWnd, &msg))
1535             continue;
1536
1537         if (TranslateAcceleratorW(hMainWnd, hAccel, &msg))
1538             continue;
1539         TranslateMessage(&msg);
1540         DispatchMessageW(&msg);
1541         if (!PeekMessageW(&msg, 0, 0, 0, PM_NOREMOVE))
1542             SendMessageW(hMainWnd, WM_USER, 0, 0);
1543     }
1544
1545     return 0;
1546 }