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