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