programs/notepad/dialog.c

   1 /*
   2  *  Notepad (dialog.c)
   3  *
   4  *  Copyright 1998,99 Marcel Baur <mbaur@g26.ethz.ch>
   5  *  Copyright 2002 Sylvain Petreolle <spetreolle@yahoo.fr>
   6  *  Copyright 2002 Andriy Palamarchuk
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #define UNICODE
  24
  25 #include <assert.h>
  26 #include <stdio.h>
  27 #include <windows.h>
  28 #include <commdlg.h>
  29
  30 #include "main.h"
  31 #include "license.h"
  32 #include "dialog.h"
  33
  34 static const WCHAR helpfileW[] = { 'n','o','t','e','p','a','d','.','h','l','p',0 };
  35
  36 static INT_PTR WINAPI DIALOG_PAGESETUP_DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam);
  37
  38 VOID ShowLastError(void)
  39 {
  40     DWORD error = GetLastError();
  41     if (error != NO_ERROR)
  42     {
  43         LPWSTR lpMsgBuf;
  44         WCHAR szTitle[MAX_STRING_LEN];
  45
  46         LoadString(Globals.hInstance, STRING_ERROR, szTitle, SIZEOF(szTitle));
  47         FormatMessage(
  48             FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  49             NULL, error, 0,
  50             (LPTSTR) &lpMsgBuf, 0, NULL);
  51         MessageBox(NULL, lpMsgBuf, szTitle, MB_OK | MB_ICONERROR);
  52         LocalFree(lpMsgBuf);
  53     }
  54 }
  55
  56 /**
  57  * Sets the caption of the main window according to Globals.szFileTitle:
  58  *    Notepad - (untitled)      if no file is open
  59  *    Notepad - [filename]      if a file is given
  60  */
  61 static void UpdateWindowCaption(void)
  62 {
  63   WCHAR szCaption[MAX_STRING_LEN];
  64   WCHAR szUntitled[MAX_STRING_LEN];
  65
  66   LoadString(Globals.hInstance, STRING_NOTEPAD, szCaption, SIZEOF(szCaption));
  67
  68   if (Globals.szFileTitle[0] != '\0') {
  69       static const WCHAR bracket_lW[] = { ' ','-',' ','[',0 };
  70       static const WCHAR bracket_rW[] = { ']',0 };
  71       lstrcat(szCaption, bracket_lW);
  72       lstrcat(szCaption, Globals.szFileTitle);
  73       lstrcat(szCaption, bracket_rW);
  74   }
  75   else
  76   {
  77       static const WCHAR hyphenW[] = { ' ','-',' ',0 };
  78       LoadString(Globals.hInstance, STRING_UNTITLED, szUntitled, SIZEOF(szUntitled));
  79       lstrcat(szCaption, hyphenW);
  80       lstrcat(szCaption, szUntitled);
  81   }
  82
  83   SetWindowText(Globals.hMainWnd, szCaption);
  84 }
  85
  86 static void AlertFileNotFound(LPCWSTR szFileName)
  87 {
  88    WCHAR szMessage[MAX_STRING_LEN];
  89    WCHAR szResource[MAX_STRING_LEN];
  90
  91    /* Load and format szMessage */
  92    LoadString(Globals.hInstance, STRING_NOTFOUND, szResource, SIZEOF(szResource));
  93    wsprintf(szMessage, szResource, szFileName);
  94
  95    /* Load szCaption */
  96    LoadString(Globals.hInstance, STRING_ERROR,  szResource, SIZEOF(szResource));
  97
  98    /* Display Modal Dialog */
  99    MessageBox(Globals.hMainWnd, szMessage, szResource, MB_ICONEXCLAMATION);
 100 }
 101
 102 static int AlertFileNotSaved(LPCWSTR szFileName)
 103 {
 104    WCHAR szMessage[MAX_STRING_LEN];
 105    WCHAR szResource[MAX_STRING_LEN];
 106    WCHAR szUntitled[MAX_STRING_LEN];
 107
 108    LoadString(Globals.hInstance, STRING_UNTITLED, szUntitled, SIZEOF(szUntitled));
 109
 110    /* Load and format Message */
 111    LoadString(Globals.hInstance, STRING_NOTSAVED, szResource, SIZEOF(szResource));
 112    wsprintf(szMessage, szResource, szFileName[0] ? szFileName : szUntitled);
 113
 114    /* Load Caption */
 115    LoadString(Globals.hInstance, STRING_ERROR, szResource, SIZEOF(szResource));
 116
 117    /* Display modal */
 118    return MessageBox(Globals.hMainWnd, szMessage, szResource, MB_ICONEXCLAMATION|MB_YESNOCANCEL);
 119 }
 120
 121 /**
 122  * Returns:
 123  *   TRUE  - if file exists
 124  *   FALSE - if file does not exist
 125  */
 126 BOOL FileExists(LPCWSTR szFilename)
 127 {
 128    WIN32_FIND_DATA entry;
 129    HANDLE hFile;
 130
 131    hFile = FindFirstFile(szFilename, &entry);
 132    FindClose(hFile);
 133
 134    return (hFile != INVALID_HANDLE_VALUE);
 135 }
 136
 137
 138 static VOID DoSaveFile(VOID)
 139 {
 140     HANDLE hFile;
 141     DWORD dwNumWrite;
 142     LPSTR pTemp;
 143     DWORD size;
 144
 145     hFile = CreateFile(Globals.szFileName, GENERIC_WRITE, FILE_SHARE_WRITE,
 146                        NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 147     if(hFile == INVALID_HANDLE_VALUE)
 148     {
 149         ShowLastError();
 150         return;
 151     }
 152
 153     size = GetWindowTextLengthA(Globals.hEdit) + 1;
 154     pTemp = HeapAlloc(GetProcessHeap(), 0, size);
 155     if (!pTemp)
 156     {
 157         CloseHandle(hFile);
 158         ShowLastError();
 159         return;
 160     }
 161     size = GetWindowTextA(Globals.hEdit, pTemp, size);
 162
 163     if (!WriteFile(hFile, pTemp, size, &dwNumWrite, NULL))
 164         ShowLastError();
 165     else
 166         SendMessage(Globals.hEdit, EM_SETMODIFY, FALSE, 0);
 167
 168     CloseHandle(hFile);
 169     HeapFree(GetProcessHeap(), 0, pTemp);
 170 }
 171
 172 /**
 173  * Returns:
 174  *   TRUE  - User agreed to close (both save/don't save)
 175  *   FALSE - User cancelled close by selecting "Cancel"
 176  */
 177 BOOL DoCloseFile(void)
 178 {
 179     int nResult;
 180     static const WCHAR empty_strW[] = { 0 };
 181
 182     if (SendMessage(Globals.hEdit, EM_GETMODIFY, 0, 0))
 183     {
 184         /* prompt user to save changes */
 185         nResult = AlertFileNotSaved(Globals.szFileName);
 186         switch (nResult) {
 187             case IDYES:     DIALOG_FileSave();
 188                             break;
 189
 190             case IDNO:      break;
 191
 192             case IDCANCEL:  return(FALSE);
 193                             break;
 194
 195             default:        return(FALSE);
 196                             break;
 197         } /* switch */
 198     } /* if */
 199
 200     SetFileName(empty_strW);
 201
 202     UpdateWindowCaption();
 203     return(TRUE);
 204 }
 205
 206
 207 void DoOpenFile(LPCWSTR szFileName)
 208 {
 209     static const WCHAR dotlog[] = { '.','L','O','G',0 };
 210     HANDLE hFile;
 211     LPSTR pTemp;
 212     DWORD size;
 213     DWORD dwNumRead;
 214     WCHAR log[5];
 215
 216     /* Close any files and prompt to save changes */
 217     if (!DoCloseFile())
 218         return;
 219
 220     hFile = CreateFile(szFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
 221         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 222     if(hFile == INVALID_HANDLE_VALUE)
 223     {
 224         ShowLastError();
 225         return;
 226     }
 227
 228     size = GetFileSize(hFile, NULL);
 229     if (size == INVALID_FILE_SIZE)
 230     {
 231         CloseHandle(hFile);
 232         ShowLastError();
 233         return;
 234     }
 235     size++;
 236
 237     pTemp = HeapAlloc(GetProcessHeap(), 0, size);
 238     if (!pTemp)
 239     {
 240         CloseHandle(hFile);
 241         ShowLastError();
 242         return;
 243     }
 244
 245     if (!ReadFile(hFile, pTemp, size, &dwNumRead, NULL))
 246     {
 247         CloseHandle(hFile);
 248         HeapFree(GetProcessHeap(), 0, pTemp);
 249         ShowLastError();
 250         return;
 251     }
 252
 253     CloseHandle(hFile);
 254     pTemp[dwNumRead] = 0;
 255
 256     if (IsTextUnicode(pTemp, dwNumRead, NULL))
 257     {
 258         LPWSTR p = (LPWSTR)pTemp;
 259         /* We need to strip BOM Unicode character, SetWindowTextW won't do it for us. */
 260         if (*p == 0xFEFF || *p == 0xFFFE) p++;
 261         SetWindowTextW(Globals.hEdit, p);
 262     }
 263     else
 264         SetWindowTextA(Globals.hEdit, pTemp);
 265
 266     HeapFree(GetProcessHeap(), 0, pTemp);
 267
 268     SendMessage(Globals.hEdit, EM_SETMODIFY, FALSE, 0);
 269     SendMessage(Globals.hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
 270     SetFocus(Globals.hEdit);
 271
 272     /*  If the file starts with .LOG, add a time/date at the end and set cursor after
 273      *  See http://support.microsoft.com/?kbid=260563
 274      */
 275     if (GetWindowTextW(Globals.hEdit, log, sizeof(log)/sizeof(log[0])) && !lstrcmp(log, dotlog))
 276     {
 277         static const WCHAR lfW[] = { '\r','\n',0 };
 278         SendMessage(Globals.hEdit, EM_SETSEL, GetWindowTextLength(Globals.hEdit), -1);
 279         SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)lfW);
 280         DIALOG_EditTimeDate();
 281         SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)lfW);
 282     }
 283
 284     SetFileName(szFileName);
 285     UpdateWindowCaption();
 286 }
 287
 288 VOID DIALOG_FileNew(VOID)
 289 {
 290     static const WCHAR empty_strW[] = { 0 };
 291
 292     /* Close any files and promt to save changes */
 293     if (DoCloseFile()) {
 294         SetWindowText(Globals.hEdit, empty_strW);
 295         SendMessage(Globals.hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
 296         SetFocus(Globals.hEdit);
 297     }
 298 }
 299
 300 VOID DIALOG_FileOpen(VOID)
 301 {
 302     OPENFILENAME openfilename;
 303     WCHAR szPath[MAX_PATH];
 304     WCHAR szDir[MAX_PATH];
 305     static const WCHAR szDefaultExt[] = { 't','x','t',0 };
 306     static const WCHAR txt_files[] = { '*','.','t','x','t',0 };
 307
 308     ZeroMemory(&openfilename, sizeof(openfilename));
 309
 310     GetCurrentDirectory(SIZEOF(szDir), szDir);
 311     lstrcpy(szPath, txt_files);
 312
 313     openfilename.lStructSize       = sizeof(openfilename);
 314     openfilename.hwndOwner         = Globals.hMainWnd;
 315     openfilename.hInstance         = Globals.hInstance;
 316     openfilename.lpstrFilter       = Globals.szFilter;
 317     openfilename.lpstrFile         = szPath;
 318     openfilename.nMaxFile          = SIZEOF(szPath);
 319     openfilename.lpstrInitialDir   = szDir;
 320     openfilename.Flags             = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST |
 321         OFN_HIDEREADONLY;
 322     openfilename.lpstrDefExt       = szDefaultExt;
 323
 324
 325     if (GetOpenFileName(&openfilename)) {
 326         if (FileExists(openfilename.lpstrFile))
 327             DoOpenFile(openfilename.lpstrFile);
 328         else
 329             AlertFileNotFound(openfilename.lpstrFile);
 330     }
 331 }
 332
 333
 334 VOID DIALOG_FileSave(VOID)
 335 {
 336     if (Globals.szFileName[0] == '\0')
 337         DIALOG_FileSaveAs();
 338     else
 339         DoSaveFile();
 340 }
 341
 342 VOID DIALOG_FileSaveAs(VOID)
 343 {
 344     OPENFILENAME saveas;
 345     WCHAR szPath[MAX_PATH];
 346     WCHAR szDir[MAX_PATH];
 347     static const WCHAR szDefaultExt[] = { 't','x','t',0 };
 348     static const WCHAR txt_files[] = { '*','.','t','x','t',0 };
 349
 350     ZeroMemory(&saveas, sizeof(saveas));
 351
 352     GetCurrentDirectory(SIZEOF(szDir), szDir);
 353     lstrcpy(szPath, txt_files);
 354
 355     saveas.lStructSize       = sizeof(OPENFILENAME);
 356     saveas.hwndOwner         = Globals.hMainWnd;
 357     saveas.hInstance         = Globals.hInstance;
 358     saveas.lpstrFilter       = Globals.szFilter;
 359     saveas.lpstrFile         = szPath;
 360     saveas.nMaxFile          = SIZEOF(szPath);
 361     saveas.lpstrInitialDir   = szDir;
 362     saveas.Flags             = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT |
 363         OFN_HIDEREADONLY;
 364     saveas.lpstrDefExt       = szDefaultExt;
 365
 366     if (GetSaveFileName(&saveas)) {
 367         SetFileName(szPath);
 368         UpdateWindowCaption();
 369         DoSaveFile();
 370     }
 371 }
 372
 373 VOID DIALOG_FilePrint(VOID)
 374 {
 375     DOCINFO di;
 376     PRINTDLG printer;
 377     SIZE szMetric;
 378     int cWidthPels, cHeightPels, border;
 379     int xLeft, yTop, pagecount, dopage, copycount;
 380     unsigned int i;
 381     LOGFONT hdrFont;
 382     HFONT font, old_font=0;
 383     DWORD size;
 384     LPWSTR pTemp;
 385     static const WCHAR times_new_romanW[] = { 'T','i','m','e','s',' ','N','e','w',' ','R','o','m','a','n',0 };
 386
 387     /* Get a small font and print some header info on each page */
 388     hdrFont.lfHeight = 100;
 389     hdrFont.lfWidth = 0;
 390     hdrFont.lfEscapement = 0;
 391     hdrFont.lfOrientation = 0;
 392     hdrFont.lfWeight = FW_BOLD;
 393     hdrFont.lfItalic = 0;
 394     hdrFont.lfUnderline = 0;
 395     hdrFont.lfStrikeOut = 0;
 396     hdrFont.lfCharSet = ANSI_CHARSET;
 397     hdrFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
 398     hdrFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
 399     hdrFont.lfQuality = PROOF_QUALITY;
 400     hdrFont.lfPitchAndFamily = VARIABLE_PITCH | FF_ROMAN;
 401     lstrcpy(hdrFont.lfFaceName, times_new_romanW);
 402
 403     font = CreateFontIndirect(&hdrFont);
 404
 405     /* Get Current Settings */
 406     ZeroMemory(&printer, sizeof(printer));
 407     printer.lStructSize           = sizeof(printer);
 408     printer.hwndOwner             = Globals.hMainWnd;
 409     printer.hInstance             = Globals.hInstance;
 410
 411     /* Set some default flags */
 412     printer.Flags                 = PD_RETURNDC;
 413     printer.nFromPage             = 0;
 414     printer.nMinPage              = 1;
 415     /* we really need to calculate number of pages to set nMaxPage and nToPage */
 416     printer.nToPage               = 0;
 417     printer.nMaxPage              = -1;
 418
 419     /* Let commdlg manage copy settings */
 420     printer.nCopies               = (WORD)PD_USEDEVMODECOPIES;
 421
 422     if (!PrintDlg(&printer)) return;
 423
 424     assert(printer.hDC != 0);
 425
 426     /* initialize DOCINFO */
 427     di.cbSize = sizeof(DOCINFO);
 428     di.lpszDocName = Globals.szFileTitle;
 429     di.lpszOutput = NULL;
 430     di.lpszDatatype = NULL;
 431     di.fwType = 0;
 432
 433     if (StartDoc(printer.hDC, &di) <= 0) return;
 434
 435     /* Get the page dimensions in pixels. */
 436     cWidthPels = GetDeviceCaps(printer.hDC, HORZRES);
 437     cHeightPels = GetDeviceCaps(printer.hDC, VERTRES);
 438
 439     /* Get the file text */
 440     size = GetWindowTextLength(Globals.hEdit) + 1;
 441     pTemp = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 442     if (!pTemp)
 443     {
 444         ShowLastError();
 445         return;
 446     }
 447     size = GetWindowText(Globals.hEdit, pTemp, size);
 448
 449     border = 150;
 450     for (copycount=1; copycount <= printer.nCopies; copycount++) {
 451         i = 0;
 452         pagecount = 1;
 453         do {
 454             static const WCHAR letterM[] = { 'M',0 };
 455
 456             if (pagecount >= printer.nFromPage &&
 457     /*          ((printer.Flags & PD_PAGENUMS) == 0 ||  pagecount <= printer.nToPage))*/
 458             pagecount <= printer.nToPage)
 459                 dopage = 1;
 460             else
 461                 dopage = 0;
 462
 463             old_font = SelectObject(printer.hDC, font);
 464             GetTextExtentPoint32(printer.hDC, letterM, 1, &szMetric);
 465
 466             if (dopage) {
 467                 if (StartPage(printer.hDC) <= 0) {
 468                     static const WCHAR failedW[] = { 'S','t','a','r','t','P','a','g','e',' ','f','a','i','l','e','d',0 };
 469                     static const WCHAR errorW[] = { 'P','r','i','n','t',' ','E','r','r','o','r',0 };
 470                     MessageBox(Globals.hMainWnd, failedW, errorW, MB_ICONEXCLAMATION);
 471                     return;
 472                 }
 473                 /* Write a rectangle and header at the top of each page */
 474                 Rectangle(printer.hDC, border, border, cWidthPels-border, border+szMetric.cy*2);
 475                 /* I don't know what's up with this TextOut command. This comes out
 476                 kind of mangled.
 477                 */
 478                 TextOut(printer.hDC, border*2, border+szMetric.cy/2, Globals.szFileTitle, lstrlen(Globals.szFileTitle));
 479             }
 480
 481             /* The starting point for the main text */
 482             xLeft = border*2;
 483             yTop = border+szMetric.cy*4;
 484
 485             SelectObject(printer.hDC, old_font);
 486             GetTextExtentPoint32(printer.hDC, letterM, 1, &szMetric);
 487
 488             /* Since outputting strings is giving me problems, output the main
 489             text one character at a time.
 490             */
 491             do {
 492                 if (pTemp[i] == '\n') {
 493                     xLeft = border*2;
 494                     yTop += szMetric.cy;
 495                 }
 496                 else if (pTemp[i] != '\r') {
 497                     if (dopage)
 498                         TextOut(printer.hDC, xLeft, yTop, &pTemp[i], 1);
 499                     xLeft += szMetric.cx;
 500                 }
 501             } while (i++<size && yTop<(cHeightPels-border*2));
 502
 503             if (dopage)
 504                 EndPage(printer.hDC);
 505             pagecount++;
 506         } while (i<size);
 507     }
 508
 509     EndDoc(printer.hDC);
 510     DeleteDC(printer.hDC);
 511     HeapFree(GetProcessHeap(), 0, pTemp);
 512 }
 513
 514 VOID DIALOG_FilePrinterSetup(VOID)
 515 {
 516     PRINTDLG printer;
 517
 518     ZeroMemory(&printer, sizeof(printer));
 519     printer.lStructSize         = sizeof(printer);
 520     printer.hwndOwner           = Globals.hMainWnd;
 521     printer.hInstance           = Globals.hInstance;
 522     printer.Flags               = PD_PRINTSETUP;
 523     printer.nCopies             = 1;
 524
 525     PrintDlg(&printer);
 526 }
 527
 528 VOID DIALOG_FileExit(VOID)
 529 {
 530     PostMessage(Globals.hMainWnd, WM_CLOSE, 0, 0l);
 531 }
 532
 533 VOID DIALOG_EditUndo(VOID)
 534 {
 535     SendMessage(Globals.hEdit, EM_UNDO, 0, 0);
 536 }
 537
 538 VOID DIALOG_EditCut(VOID)
 539 {
 540     SendMessage(Globals.hEdit, WM_CUT, 0, 0);
 541 }
 542
 543 VOID DIALOG_EditCopy(VOID)
 544 {
 545     SendMessage(Globals.hEdit, WM_COPY, 0, 0);
 546 }
 547
 548 VOID DIALOG_EditPaste(VOID)
 549 {
 550     SendMessage(Globals.hEdit, WM_PASTE, 0, 0);
 551 }
 552
 553 VOID DIALOG_EditDelete(VOID)
 554 {
 555     SendMessage(Globals.hEdit, WM_CLEAR, 0, 0);
 556 }
 557
 558 VOID DIALOG_EditSelectAll(VOID)
 559 {
 560     SendMessage(Globals.hEdit, EM_SETSEL, 0, (LPARAM)-1);
 561 }
 562
 563 VOID DIALOG_EditTimeDate(VOID)
 564 {
 565     SYSTEMTIME   st;
 566     WCHAR        szDate[MAX_STRING_LEN];
 567     static const WCHAR spaceW[] = { ' ',0 };
 568
 569     GetLocalTime(&st);
 570
 571     GetTimeFormat(LOCALE_USER_DEFAULT, 0, &st, NULL, szDate, MAX_STRING_LEN);
 572     SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)szDate);
 573
 574     SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)spaceW);
 575
 576     GetDateFormat(LOCALE_USER_DEFAULT, DATE_LONGDATE, &st, NULL, szDate, MAX_STRING_LEN);
 577     SendMessage(Globals.hEdit, EM_REPLACESEL, TRUE, (LPARAM)szDate);
 578 }
 579
 580 VOID DIALOG_EditWrap(VOID)
 581 {
 582     static const WCHAR editW[] = { 'e','d','i','t',0 };
 583     DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL |
 584                     ES_AUTOVSCROLL | ES_MULTILINE;
 585     RECT rc;
 586     DWORD size;
 587     LPWSTR pTemp;
 588
 589     size = GetWindowTextLength(Globals.hEdit) + 1;
 590     pTemp = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 591     if (!pTemp)
 592     {
 593         ShowLastError();
 594         return;
 595     }
 596     GetWindowText(Globals.hEdit, pTemp, size);
 597     DestroyWindow(Globals.hEdit);
 598     GetClientRect(Globals.hMainWnd, &rc);
 599     if( Globals.bWrapLongLines ) dwStyle |= WS_HSCROLL | ES_AUTOHSCROLL;
 600     Globals.hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, editW, NULL, dwStyle,
 601                          0, 0, rc.right, rc.bottom, Globals.hMainWnd,
 602                          NULL, Globals.hInstance, NULL);
 603     SendMessage(Globals.hEdit, WM_SETFONT, (WPARAM)Globals.hFont, (LPARAM)FALSE);
 604     SetWindowTextW(Globals.hEdit, pTemp);
 605     SetFocus(Globals.hEdit);
 606     HeapFree(GetProcessHeap(), 0, pTemp);
 607
 608     Globals.bWrapLongLines = !Globals.bWrapLongLines;
 609     CheckMenuItem(GetMenu(Globals.hMainWnd), CMD_WRAP,
 610         MF_BYCOMMAND | (Globals.bWrapLongLines ? MF_CHECKED : MF_UNCHECKED));
 611 }
 612
 613 VOID DIALOG_SelectFont(VOID)
 614 {
 615     CHOOSEFONT cf;
 616     LOGFONT lf=Globals.lfFont;
 617
 618     ZeroMemory( &cf, sizeof(cf) );
 619     cf.lStructSize=sizeof(cf);
 620     cf.hwndOwner=Globals.hMainWnd;
 621     cf.lpLogFont=&lf;
 622     cf.Flags=CF_SCREENFONTS;
 623
 624     if( ChooseFont(&cf) )
 625     {
 626         HFONT currfont=Globals.hFont;
 627
 628         Globals.hFont=CreateFontIndirect( &lf );
 629         Globals.lfFont=lf;
 630         SendMessage( Globals.hEdit, WM_SETFONT, (WPARAM)Globals.hFont, (LPARAM)TRUE );
 631         if( currfont!=NULL )
 632             DeleteObject( currfont );
 633     }
 634 }
 635
 636 VOID DIALOG_Search(VOID)
 637 {
 638         ZeroMemory(&Globals.find, sizeof(Globals.find));
 639         Globals.find.lStructSize      = sizeof(Globals.find);
 640         Globals.find.hwndOwner        = Globals.hMainWnd;
 641         Globals.find.hInstance        = Globals.hInstance;
 642         Globals.find.lpstrFindWhat    = Globals.szFindText;
 643         Globals.find.wFindWhatLen     = SIZEOF(Globals.szFindText);
 644         Globals.find.Flags            = FR_DOWN;
 645
 646         /* We only need to create the modal FindReplace dialog which will */
 647         /* notify us of incoming events using hMainWnd Window Messages    */
 648
 649         Globals.hFindReplaceDlg = FindText(&Globals.find);
 650         assert(Globals.hFindReplaceDlg !=0);
 651 }
 652
 653 VOID DIALOG_SearchNext(VOID)
 654 {
 655     /* FIXME: Search Next */
 656     DIALOG_Search();
 657 }
 658
 659 VOID DIALOG_HelpContents(VOID)
 660 {
 661     WinHelp(Globals.hMainWnd, helpfileW, HELP_INDEX, 0);
 662 }
 663
 664 VOID DIALOG_HelpSearch(VOID)
 665 {
 666         /* Search Help */
 667 }
 668
 669 VOID DIALOG_HelpHelp(VOID)
 670 {
 671     WinHelp(Globals.hMainWnd, helpfileW, HELP_HELPONHELP, 0);
 672 }
 673
 674 VOID DIALOG_HelpLicense(VOID)
 675 {
 676         WineLicense(Globals.hMainWnd);
 677 }
 678
 679 VOID DIALOG_HelpNoWarranty(VOID)
 680 {
 681         WineWarranty(Globals.hMainWnd);
 682 }
 683
 684 VOID DIALOG_HelpAboutWine(VOID)
 685 {
 686     static const WCHAR notepadW[] = { 'N','o','t','e','p','a','d','\n',0 };
 687     WCHAR szNotepad[MAX_STRING_LEN];
 688
 689     LoadString(Globals.hInstance, STRING_NOTEPAD, szNotepad, SIZEOF(szNotepad));
 690     ShellAbout(Globals.hMainWnd, szNotepad, notepadW, 0);
 691 }
 692
 693
 694 /***********************************************************************
 695  *
 696  *           DIALOG_FilePageSetup
 697  */
 698 VOID DIALOG_FilePageSetup(void)
 699 {
 700   DialogBox(Globals.hInstance, MAKEINTRESOURCE(DIALOG_PAGESETUP),
 701             Globals.hMainWnd, DIALOG_PAGESETUP_DlgProc);
 702 }
 703
 704
 705 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 706  *
 707  *           DIALOG_PAGESETUP_DlgProc
 708  */
 709
 710 static INT_PTR WINAPI DIALOG_PAGESETUP_DlgProc(HWND hDlg, UINT msg, WPARAM wParam, LPARAM lParam)
 711 {
 712
 713    switch (msg)
 714     {
 715     case WM_COMMAND:
 716       switch (wParam)
 717         {
 718         case IDOK:
 719           /* save user input and close dialog */
 720           GetDlgItemText(hDlg, 0x141, Globals.szHeader, SIZEOF(Globals.szHeader));
 721           GetDlgItemText(hDlg, 0x143, Globals.szFooter, SIZEOF(Globals.szFooter));
 722           GetDlgItemText(hDlg, 0x14A, Globals.szMarginTop, SIZEOF(Globals.szMarginTop));
 723           GetDlgItemText(hDlg, 0x150, Globals.szMarginBottom, SIZEOF(Globals.szMarginBottom));
 724           GetDlgItemText(hDlg, 0x147, Globals.szMarginLeft, SIZEOF(Globals.szMarginLeft));
 725           GetDlgItemText(hDlg, 0x14D, Globals.szMarginRight, SIZEOF(Globals.szMarginRight));
 726           EndDialog(hDlg, IDOK);
 727           return TRUE;
 728
 729         case IDCANCEL:
 730           /* discard user input and close dialog */
 731           EndDialog(hDlg, IDCANCEL);
 732           return TRUE;
 733
 734         case IDHELP:
 735         {
 736           /* FIXME: Bring this to work */
 737           static const WCHAR sorryW[] = { 'S','o','r','r','y',',',' ','n','o',' ','h','e','l','p',' ','a','v','a','i','l','a','b','l','e',0 };
 738           static const WCHAR helpW[] = { 'H','e','l','p',0 };
 739           MessageBox(Globals.hMainWnd, sorryW, helpW, MB_ICONEXCLAMATION);
 740           return TRUE;
 741         }
 742
 743         default:
 744             break;
 745         }
 746       break;
 747
 748     case WM_INITDIALOG:
 749        /* fetch last user input prior to display dialog */
 750        SetDlgItemText(hDlg, 0x141, Globals.szHeader);
 751        SetDlgItemText(hDlg, 0x143, Globals.szFooter);
 752        SetDlgItemText(hDlg, 0x14A, Globals.szMarginTop);
 753        SetDlgItemText(hDlg, 0x150, Globals.szMarginBottom);
 754        SetDlgItemText(hDlg, 0x147, Globals.szMarginLeft);
 755        SetDlgItemText(hDlg, 0x14D, Globals.szMarginRight);
 756        break;
 757     }
 758
 759   return FALSE;
 760 }