programs/wordpad/print.c

   1 /*
   2  * Wordpad implementation - Printing and print preview functions
   3  *
   4  * Copyright 2007-2008 by Alexander N. Sørnes <alex@thehandofagony.com>
   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 #include <windows.h>
  22 #include <richedit.h>
  23 #include <commctrl.h>
  24
  25 #include "wordpad.h"
  26
  27 typedef struct _previewinfo
  28 {
  29     int page;
  30     int pages;
  31     HDC hdc;
  32     HDC hdc2;
  33     HDC hdcSized;
  34     HDC hdcSized2;
  35     RECT window;
  36     LPWSTR wszFileName;
  37 } previewinfo, *ppreviewinfo;
  38
  39 static HGLOBAL devMode;
  40 static HGLOBAL devNames;
  41
  42 static RECT margins;
  43 static previewinfo preview;
  44
  45 static const WCHAR var_pagemargin[] = {'P','a','g','e','M','a','r','g','i','n',0};
  46
  47 static LPWSTR get_print_file_filter(HWND hMainWnd)
  48 {
  49     static WCHAR wszPrintFilter[MAX_STRING_LEN*2+6+4+1];
  50     const WCHAR files_prn[] = {'*','.','P','R','N',0};
  51     const WCHAR files_all[] = {'*','.','*','\0'};
  52     LPWSTR p;
  53     HINSTANCE hInstance = GetModuleHandleW(0);
  54
  55     p = wszPrintFilter;
  56     LoadStringW(hInstance, STRING_PRINTER_FILES_PRN, p, MAX_STRING_LEN);
  57     p += lstrlenW(p) + 1;
  58     lstrcpyW(p, files_prn);
  59     p += lstrlenW(p) + 1;
  60     LoadStringW(hInstance, STRING_ALL_FILES, p, MAX_STRING_LEN);
  61     p += lstrlenW(p) + 1;
  62     lstrcpyW(p, files_all);
  63     p += lstrlenW(p) + 1;
  64     *p = 0;
  65
  66     return wszPrintFilter;
  67 }
  68
  69 void registry_set_pagemargins(HKEY hKey)
  70 {
  71     RegSetValueExW(hKey, var_pagemargin, 0, REG_BINARY, (LPBYTE)&margins, sizeof(RECT));
  72 }
  73
  74 void registry_read_pagemargins(HKEY hKey)
  75 {
  76     DWORD size = sizeof(RECT);
  77
  78     if(!hKey || RegQueryValueExW(hKey, var_pagemargin, 0, NULL, (LPBYTE)&margins,
  79                      &size) != ERROR_SUCCESS || size != sizeof(RECT))
  80     {
  81         margins.top = 1417;
  82         margins.bottom = 1417;
  83         margins.left = 1757;
  84         margins.right = 1757;
  85     }
  86 }
  87
  88 static void AddTextButton(HWND hRebarWnd, UINT string, UINT command, UINT id)
  89 {
  90     REBARBANDINFOW rb;
  91     HINSTANCE hInstance = GetModuleHandleW(0);
  92     WCHAR text[MAX_STRING_LEN];
  93     HWND hButton;
  94
  95     LoadStringW(hInstance, string, text, MAX_STRING_LEN);
  96     hButton = CreateWindowW(WC_BUTTONW, text,
  97                             WS_VISIBLE | WS_CHILD, 5, 5, 100, 15,
  98                             hRebarWnd, ULongToHandle(command), hInstance, NULL);
  99
 100     rb.cbSize = REBARBANDINFOW_V6_SIZE;
 101     rb.fMask = RBBIM_SIZE | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBIM_CHILD | RBBIM_IDEALSIZE | RBBIM_ID;
 102     rb.fStyle = RBBS_NOGRIPPER | RBBS_VARIABLEHEIGHT;
 103     rb.hwndChild = hButton;
 104     rb.cyChild = rb.cyMinChild = 22;
 105     rb.cx = rb.cxMinChild = 90;
 106     rb.cxIdeal = 100;
 107     rb.wID = id;
 108
 109     SendMessageW(hRebarWnd, RB_INSERTBAND, -1, (LPARAM)&rb);
 110 }
 111
 112 static HDC make_dc(void)
 113 {
 114     if(devNames && devMode)
 115     {
 116         LPDEVNAMES dn = GlobalLock(devNames);
 117         LPDEVMODEW dm = GlobalLock(devMode);
 118         HDC ret;
 119
 120         ret = CreateDCW((LPWSTR)dn + dn->wDriverOffset,
 121                          (LPWSTR)dn + dn->wDeviceOffset, 0, dm);
 122
 123         GlobalUnlock(dn);
 124         GlobalUnlock(dm);
 125
 126         return ret;
 127     } else
 128     {
 129         return 0;
 130     }
 131 }
 132
 133 static LONG twips_to_centmm(int twips)
 134 {
 135     return MulDiv(twips, CENTMM_PER_INCH, TWIPS_PER_INCH);
 136 }
 137
 138 static LONG centmm_to_twips(int mm)
 139 {
 140     return MulDiv(mm, TWIPS_PER_INCH, CENTMM_PER_INCH);
 141 }
 142
 143 static LONG twips_to_pixels(int twips, int dpi)
 144 {
 145     return MulDiv(twips, dpi, TWIPS_PER_INCH);
 146 }
 147
 148 static LONG devunits_to_twips(int units, int dpi)
 149 {
 150     return MulDiv(units, TWIPS_PER_INCH, dpi);
 151 }
 152
 153
 154 static RECT get_print_rect(HDC hdc)
 155 {
 156     RECT rc;
 157     int width, height;
 158
 159     if(hdc)
 160     {
 161         int dpiY = GetDeviceCaps(hdc, LOGPIXELSY);
 162         int dpiX = GetDeviceCaps(hdc, LOGPIXELSX);
 163         width = devunits_to_twips(GetDeviceCaps(hdc, PHYSICALWIDTH), dpiX);
 164         height = devunits_to_twips(GetDeviceCaps(hdc, PHYSICALHEIGHT), dpiY);
 165     } else
 166     {
 167         width = centmm_to_twips(18500);
 168         height = centmm_to_twips(27000);
 169     }
 170
 171     rc.left = margins.left;
 172     rc.right = width - margins.right;
 173     rc.top = margins.top;
 174     rc.bottom = height - margins.bottom;
 175
 176     return rc;
 177 }
 178
 179 void target_device(HWND hMainWnd, DWORD wordWrap)
 180 {
 181     HWND hEditorWnd = GetDlgItem(hMainWnd, IDC_EDITOR);
 182
 183     if(wordWrap == ID_WORDWRAP_MARGIN)
 184     {
 185         int width = 0;
 186         LRESULT result;
 187         HDC hdc = make_dc();
 188         RECT rc = get_print_rect(hdc);
 189
 190         width = rc.right - rc.left;
 191         if(!hdc)
 192         {
 193             HDC hMaindc = GetDC(hMainWnd);
 194             hdc = CreateCompatibleDC(hMaindc);
 195             ReleaseDC(hMainWnd, hMaindc);
 196         }
 197         result = SendMessageW(hEditorWnd, EM_SETTARGETDEVICE, (WPARAM)hdc, width);
 198         DeleteDC(hdc);
 199         if (result)
 200             return;
 201         /* otherwise EM_SETTARGETDEVICE failed, so fall back on wrapping
 202          * to window using the NULL DC. */
 203     }
 204
 205     if (wordWrap != ID_WORDWRAP_NONE) {
 206         SendMessageW(hEditorWnd, EM_SETTARGETDEVICE, 0, 0);
 207     } else {
 208         SendMessageW(hEditorWnd, EM_SETTARGETDEVICE, 0, 1);
 209     }
 210
 211 }
 212
 213 static LPWSTR dialog_print_to_file(HWND hMainWnd)
 214 {
 215     OPENFILENAMEW ofn;
 216     static WCHAR file[MAX_PATH] = {'O','U','T','P','U','T','.','P','R','N',0};
 217     static const WCHAR defExt[] = {'P','R','N',0};
 218     static LPWSTR file_filter;
 219
 220     if(!file_filter)
 221         file_filter = get_print_file_filter(hMainWnd);
 222
 223     ZeroMemory(&ofn, sizeof(ofn));
 224
 225     ofn.lStructSize = sizeof(ofn);
 226     ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
 227     ofn.hwndOwner = hMainWnd;
 228     ofn.lpstrFilter = file_filter;
 229     ofn.lpstrFile = file;
 230     ofn.nMaxFile = MAX_PATH;
 231     ofn.lpstrDefExt = defExt;
 232
 233     if(GetSaveFileNameW(&ofn))
 234         return file;
 235     else
 236         return FALSE;
 237 }
 238
 239 static int get_num_pages(HWND hEditorWnd, FORMATRANGE fr)
 240 {
 241     int page = 0;
 242     fr.chrg.cpMin = 0;
 243
 244     do
 245     {
 246         int bottom = fr.rc.bottom;
 247         page++;
 248         fr.chrg.cpMin = SendMessageW(hEditorWnd, EM_FORMATRANGE, FALSE,
 249                                      (LPARAM)&fr);
 250         fr.rc.bottom = bottom;
 251     }
 252     while(fr.chrg.cpMin && fr.chrg.cpMin < fr.chrg.cpMax);
 253
 254     return page;
 255 }
 256
 257 static void char_from_pagenum(HWND hEditorWnd, FORMATRANGE *fr, int page)
 258 {
 259     int i;
 260
 261     fr->chrg.cpMin = 0;
 262
 263     for(i = 1; i < page; i++)
 264     {
 265         int bottom = fr->rc.bottom;
 266         fr->chrg.cpMin = SendMessageW(hEditorWnd, EM_FORMATRANGE, FALSE, (LPARAM)fr);
 267         fr->rc.bottom = bottom;
 268     }
 269 }
 270
 271 static HWND get_ruler_wnd(HWND hMainWnd)
 272 {
 273     return GetDlgItem(GetDlgItem(hMainWnd, IDC_REBAR), IDC_RULER);
 274 }
 275
 276 void redraw_ruler(HWND hRulerWnd)
 277 {
 278     RECT rc;
 279
 280     GetClientRect(hRulerWnd, &rc);
 281     InvalidateRect(hRulerWnd, &rc, TRUE);
 282 }
 283
 284 static void update_ruler(HWND hRulerWnd)
 285 {
 286      SendMessageW(hRulerWnd, WM_USER, 0, 0);
 287      redraw_ruler(hRulerWnd);
 288 }
 289
 290 static void print(LPPRINTDLGW pd, LPWSTR wszFileName)
 291 {
 292     FORMATRANGE fr;
 293     DOCINFOW di;
 294     HWND hEditorWnd = GetDlgItem(pd->hwndOwner, IDC_EDITOR);
 295     int printedPages = 0;
 296
 297     fr.hdc = pd->hDC;
 298     fr.hdcTarget = pd->hDC;
 299
 300     fr.rc = get_print_rect(fr.hdc);
 301     fr.rcPage.left = 0;
 302     fr.rcPage.right = fr.rc.right + margins.right;
 303     fr.rcPage.top = 0;
 304     fr.rcPage.bottom = fr.rc.bottom + margins.bottom;
 305
 306     ZeroMemory(&di, sizeof(di));
 307     di.cbSize = sizeof(di);
 308     di.lpszDocName = wszFileName;
 309
 310     if(pd->Flags & PD_PRINTTOFILE)
 311     {
 312         di.lpszOutput = dialog_print_to_file(pd->hwndOwner);
 313         if(!di.lpszOutput)
 314             return;
 315     }
 316
 317     if(pd->Flags & PD_SELECTION)
 318     {
 319         SendMessageW(hEditorWnd, EM_EXGETSEL, 0, (LPARAM)&fr.chrg);
 320     } else
 321     {
 322         GETTEXTLENGTHEX gt;
 323         gt.flags = GTL_DEFAULT;
 324         gt.codepage = 1200;
 325         fr.chrg.cpMin = 0;
 326         fr.chrg.cpMax = SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0);
 327
 328         if(pd->Flags & PD_PAGENUMS)
 329             char_from_pagenum(hEditorWnd, &fr, pd->nToPage);
 330     }
 331
 332     StartDocW(fr.hdc, &di);
 333     do
 334     {
 335         int bottom = fr.rc.bottom;
 336         if(StartPage(fr.hdc) <= 0)
 337             break;
 338
 339         fr.chrg.cpMin = SendMessageW(hEditorWnd, EM_FORMATRANGE, TRUE, (LPARAM)&fr);
 340
 341         if(EndPage(fr.hdc) <= 0)
 342             break;
 343         bottom = fr.rc.bottom;
 344
 345         printedPages++;
 346         if((pd->Flags & PD_PAGENUMS) && (printedPages > (pd->nToPage - pd->nFromPage)))
 347             break;
 348     }
 349     while(fr.chrg.cpMin && fr.chrg.cpMin < fr.chrg.cpMax);
 350
 351     EndDoc(fr.hdc);
 352     SendMessageW(hEditorWnd, EM_FORMATRANGE, FALSE, 0);
 353 }
 354
 355 void dialog_printsetup(HWND hMainWnd)
 356 {
 357     PAGESETUPDLGW ps;
 358
 359     ZeroMemory(&ps, sizeof(ps));
 360     ps.lStructSize = sizeof(ps);
 361     ps.hwndOwner = hMainWnd;
 362     ps.Flags = PSD_INHUNDREDTHSOFMILLIMETERS | PSD_MARGINS;
 363     ps.rtMargin.left = twips_to_centmm(margins.left);
 364     ps.rtMargin.right = twips_to_centmm(margins.right);
 365     ps.rtMargin.top = twips_to_centmm(margins.top);
 366     ps.rtMargin.bottom = twips_to_centmm(margins.bottom);
 367     ps.hDevMode = devMode;
 368     ps.hDevNames = devNames;
 369
 370     if(PageSetupDlgW(&ps))
 371     {
 372         margins.left = centmm_to_twips(ps.rtMargin.left);
 373         margins.right = centmm_to_twips(ps.rtMargin.right);
 374         margins.top = centmm_to_twips(ps.rtMargin.top);
 375         margins.bottom = centmm_to_twips(ps.rtMargin.bottom);
 376         devMode = ps.hDevMode;
 377         devNames = ps.hDevNames;
 378         update_ruler(get_ruler_wnd(hMainWnd));
 379     }
 380 }
 381
 382 void get_default_printer_opts(void)
 383 {
 384     PRINTDLGW pd;
 385     ZeroMemory(&pd, sizeof(pd));
 386
 387     ZeroMemory(&pd, sizeof(pd));
 388     pd.lStructSize = sizeof(pd);
 389     pd.Flags = PD_RETURNDC | PD_RETURNDEFAULT;
 390     pd.hDevMode = devMode;
 391
 392     PrintDlgW(&pd);
 393
 394     devMode = pd.hDevMode;
 395     devNames = pd.hDevNames;
 396 }
 397
 398 void print_quick(LPWSTR wszFileName)
 399 {
 400     PRINTDLGW pd;
 401
 402     ZeroMemory(&pd, sizeof(pd));
 403     pd.hDC = make_dc();
 404
 405     print(&pd, wszFileName);
 406 }
 407
 408 void dialog_print(HWND hMainWnd, LPWSTR wszFileName)
 409 {
 410     PRINTDLGW pd;
 411     HWND hEditorWnd = GetDlgItem(hMainWnd, IDC_EDITOR);
 412     int from = 0;
 413     int to = 0;
 414
 415     ZeroMemory(&pd, sizeof(pd));
 416     pd.lStructSize = sizeof(pd);
 417     pd.hwndOwner = hMainWnd;
 418     pd.Flags = PD_RETURNDC | PD_USEDEVMODECOPIESANDCOLLATE;
 419     pd.nMinPage = 1;
 420     pd.nMaxPage = -1;
 421     pd.hDevMode = devMode;
 422     pd.hDevNames = devNames;
 423
 424     SendMessageW(hEditorWnd, EM_GETSEL, (WPARAM)&from, (LPARAM)&to);
 425     if(from == to)
 426         pd.Flags |= PD_NOSELECTION;
 427
 428     if(PrintDlgW(&pd))
 429     {
 430         devMode = pd.hDevMode;
 431         devNames = pd.hDevNames;
 432         print(&pd, wszFileName);
 433         update_ruler(get_ruler_wnd(hMainWnd));
 434     }
 435 }
 436
 437 static void preview_bar_show(HWND hMainWnd, BOOL show)
 438 {
 439     HWND hReBar = GetDlgItem(hMainWnd, IDC_REBAR);
 440     int i;
 441
 442     if(show)
 443     {
 444         REBARBANDINFOW rb;
 445         HWND hStatic;
 446
 447         AddTextButton(hReBar, STRING_PREVIEW_PRINT, ID_PRINT, BANDID_PREVIEW_BTN1);
 448         AddTextButton(hReBar, STRING_PREVIEW_NEXTPAGE, ID_PREVIEW_NEXTPAGE, BANDID_PREVIEW_BTN2);
 449         AddTextButton(hReBar, STRING_PREVIEW_PREVPAGE, ID_PREVIEW_PREVPAGE, BANDID_PREVIEW_BTN3);
 450         AddTextButton(hReBar, STRING_PREVIEW_TWOPAGES, ID_PREVIEW_NUMPAGES, BANDID_PREVIEW_BTN4);
 451         AddTextButton(hReBar, STRING_PREVIEW_CLOSE, ID_FILE_EXIT, BANDID_PREVIEW_BTN5);
 452
 453         hStatic = CreateWindowW(WC_STATICW, NULL,
 454                                 WS_VISIBLE | WS_CHILD, 0, 0, 0, 0,
 455                                 hReBar, NULL, NULL, NULL);
 456
 457         rb.cbSize = REBARBANDINFOW_V6_SIZE;
 458         rb.fMask = RBBIM_SIZE | RBBIM_CHILDSIZE | RBBIM_STYLE | RBBIM_CHILD | RBBIM_IDEALSIZE | RBBIM_ID;
 459         rb.fStyle = RBBS_NOGRIPPER | RBBS_VARIABLEHEIGHT;
 460         rb.hwndChild = hStatic;
 461         rb.cyChild = rb.cyMinChild = 22;
 462         rb.cx = rb.cxMinChild = 90;
 463         rb.cxIdeal = 100;
 464         rb.wID = BANDID_PREVIEW_BUFFER;
 465
 466         SendMessageW(hReBar, RB_INSERTBAND, -1, (LPARAM)&rb);
 467     } else
 468     {
 469         for(i = 0; i <= PREVIEW_BUTTONS; i++)
 470             SendMessageW(hReBar, RB_DELETEBAND, SendMessageW(hReBar, RB_IDTOINDEX, BANDID_PREVIEW_BTN1+i, 0), 0);
 471     }
 472 }
 473
 474 void init_preview(HWND hMainWnd, LPWSTR wszFileName)
 475 {
 476     preview.page = 1;
 477     preview.hdc = 0;
 478     preview.hdc2 = 0;
 479     preview.wszFileName = wszFileName;
 480     preview_bar_show(hMainWnd, TRUE);
 481 }
 482
 483 void close_preview(HWND hMainWnd)
 484 {
 485     preview.window.right = 0;
 486     preview.window.bottom = 0;
 487     preview.page = 0;
 488     preview.pages = 0;
 489
 490     preview_bar_show(hMainWnd, FALSE);
 491 }
 492
 493 BOOL preview_isactive(void)
 494 {
 495     return preview.page != 0;
 496 }
 497
 498 static void add_ruler_units(HDC hdcRuler, RECT* drawRect, BOOL NewMetrics, LONG EditLeftmost)
 499 {
 500     static HDC hdc;
 501
 502     if(NewMetrics)
 503     {
 504         static HBITMAP hBitmap;
 505         int i, x, y, RulerTextEnd;
 506         int CmPixels;
 507         int QuarterCmPixels;
 508         HFONT hFont;
 509         WCHAR FontName[] = {'M','S',' ','S','a','n','s',' ','S','e','r','i','f',0};
 510
 511         if(hdc)
 512         {
 513             DeleteDC(hdc);
 514             DeleteObject(hBitmap);
 515         }
 516
 517         hdc = CreateCompatibleDC(0);
 518
 519         CmPixels = twips_to_pixels(centmm_to_twips(1000), GetDeviceCaps(hdc, LOGPIXELSX));
 520         QuarterCmPixels = (int)((float)CmPixels / 4.0);
 521
 522         hBitmap = CreateCompatibleBitmap(hdc, drawRect->right, drawRect->bottom);
 523         SelectObject(hdc, hBitmap);
 524         FillRect(hdc, drawRect, GetStockObject(WHITE_BRUSH));
 525
 526         hFont = CreateFontW(10, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, FontName);
 527
 528         SelectObject(hdc, hFont);
 529         SetBkMode(hdc, TRANSPARENT);
 530         SetTextAlign(hdc, TA_CENTER);
 531         y = (int)(((float)drawRect->bottom - (float)drawRect->top) / 2.0) + 1;
 532         RulerTextEnd = drawRect->right - EditLeftmost + 1;
 533         for(i = 1, x = EditLeftmost; x < (drawRect->right - EditLeftmost + 1); i ++)
 534         {
 535             WCHAR str[3];
 536             WCHAR format[] = {'%','d',0};
 537             int x2 = x;
 538
 539             x2 += QuarterCmPixels;
 540             if(x2 > RulerTextEnd)
 541                 break;
 542
 543             MoveToEx(hdc, x2, y, NULL);
 544             LineTo(hdc, x2, y+2);
 545
 546             x2 += QuarterCmPixels;
 547             if(x2 > RulerTextEnd)
 548                 break;
 549
 550             MoveToEx(hdc, x2, y - 3, NULL);
 551             LineTo(hdc, x2, y + 3);
 552
 553             x2 += QuarterCmPixels;
 554             if(x2 > RulerTextEnd)
 555                 break;
 556
 557             MoveToEx(hdc, x2, y, NULL);
 558             LineTo(hdc, x2, y+2);
 559
 560             x += CmPixels;
 561             if(x > RulerTextEnd)
 562                 break;
 563
 564             wsprintfW(str, format, i);
 565             TextOutW(hdc, x, 5, str, lstrlenW(str));
 566         }
 567         DeleteObject(hFont);
 568     }
 569
 570     BitBlt(hdcRuler, 0, 0, drawRect->right, drawRect->bottom, hdc, 0, 0, SRCAND);
 571 }
 572
 573 static void paint_ruler(HWND hWnd, LONG EditLeftmost, BOOL NewMetrics)
 574 {
 575     PAINTSTRUCT ps;
 576     HDC hdc = BeginPaint(hWnd, &ps);
 577     HDC hdcPrint = make_dc();
 578     RECT printRect = get_print_rect(hdcPrint);
 579     RECT drawRect;
 580     HBRUSH hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
 581
 582     GetClientRect(hWnd, &drawRect);
 583     FillRect(hdc, &drawRect, hBrush);
 584
 585     drawRect.top += 3;
 586     drawRect.bottom -= 3;
 587     drawRect.left = EditLeftmost;
 588     drawRect.right = twips_to_pixels(printRect.right - margins.left, GetDeviceCaps(hdc, LOGPIXELSX));
 589     FillRect(hdc, &drawRect, GetStockObject(WHITE_BRUSH));
 590
 591     drawRect.top--;
 592     drawRect.bottom++;
 593     DrawEdge(hdc, &drawRect, EDGE_SUNKEN, BF_RECT);
 594
 595     drawRect.left = drawRect.right - 1;
 596     drawRect.right = twips_to_pixels(printRect.right + margins.right - margins.left, GetDeviceCaps(hdc, LOGPIXELSX));
 597     DrawEdge(hdc, &drawRect, EDGE_ETCHED, BF_RECT);
 598
 599     drawRect.left = 0;
 600     drawRect.top = 0;
 601     add_ruler_units(hdc, &drawRect, NewMetrics, EditLeftmost);
 602
 603     SelectObject(hdc, GetStockObject(BLACK_BRUSH));
 604     DeleteObject(hBrush);
 605     DeleteDC(hdcPrint);
 606     EndPaint(hWnd, &ps);
 607 }
 608
 609 LRESULT CALLBACK ruler_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 610 {
 611     static WNDPROC pPrevRulerProc;
 612     static LONG EditLeftmost;
 613     static BOOL NewMetrics;
 614
 615     switch(msg)
 616     {
 617         case WM_USER:
 618             if(wParam)
 619             {
 620                 EditLeftmost = ((POINTL*)wParam)->x;
 621                 pPrevRulerProc = (WNDPROC)lParam;
 622             }
 623             NewMetrics = TRUE;
 624             break;
 625
 626         case WM_PAINT:
 627             paint_ruler(hWnd, EditLeftmost, NewMetrics);
 628             break;
 629
 630         default:
 631             return CallWindowProcW(pPrevRulerProc, hWnd, msg, wParam, lParam);
 632     }
 633
 634     return 0;
 635 }
 636
 637 static void draw_preview_page(HDC hdc, HDC* hdcSized, FORMATRANGE* lpFr, float ratio, int bmNewWidth, int bmNewHeight, int bmWidth, int bmHeight)
 638 {
 639     HBITMAP hBitmapScaled = CreateCompatibleBitmap(hdc, bmNewWidth, bmNewHeight);
 640     HPEN hPen;
 641     int TopMargin = (int)((float)twips_to_pixels(lpFr->rc.top, GetDeviceCaps(hdc, LOGPIXELSX)) * ratio);
 642     int BottomMargin = (int)((float)twips_to_pixels(lpFr->rc.bottom, GetDeviceCaps(hdc, LOGPIXELSX)) * ratio);
 643     int LeftMargin = (int)((float)twips_to_pixels(lpFr->rc.left, GetDeviceCaps(hdc, LOGPIXELSY)) * ratio);
 644     int RightMargin = (int)((float)twips_to_pixels(lpFr->rc.right, GetDeviceCaps(hdc, LOGPIXELSY)) * ratio);
 645
 646     if(*hdcSized)
 647         DeleteDC(*hdcSized);
 648     *hdcSized = CreateCompatibleDC(hdc);
 649     SelectObject(*hdcSized, hBitmapScaled);
 650
 651     StretchBlt(*hdcSized, 0, 0, bmNewWidth, bmNewHeight, hdc, 0, 0, bmWidth, bmHeight, SRCCOPY);
 652
 653     /* Draw margin lines */
 654     hPen = CreatePen(PS_DOT, 1, RGB(0,0,0));
 655     SelectObject(*hdcSized, hPen);
 656
 657     MoveToEx(*hdcSized, 0, TopMargin, NULL);
 658     LineTo(*hdcSized, bmNewWidth, TopMargin);
 659     MoveToEx(*hdcSized, 0, BottomMargin, NULL);
 660     LineTo(*hdcSized, bmNewWidth, BottomMargin);
 661
 662     MoveToEx(*hdcSized, LeftMargin, 0, NULL);
 663     LineTo(*hdcSized, LeftMargin, bmNewHeight);
 664     MoveToEx(*hdcSized, RightMargin, 0, NULL);
 665     LineTo(*hdcSized, RightMargin, bmNewHeight);
 666
 667 }
 668
 669 static void draw_preview(HWND hEditorWnd, FORMATRANGE* lpFr, int bmWidth, int bmHeight, RECT* paper, int page)
 670 {
 671     HBITMAP hBitmapCapture = CreateCompatibleBitmap(lpFr->hdc, bmWidth, bmHeight);
 672
 673     char_from_pagenum(hEditorWnd, lpFr, page);
 674     SelectObject(lpFr->hdc, hBitmapCapture);
 675     FillRect(lpFr->hdc, paper, GetStockObject(WHITE_BRUSH));
 676     SendMessageW(hEditorWnd, EM_FORMATRANGE, TRUE, (LPARAM)lpFr);
 677     /* EM_FORMATRANGE sets fr.rc to indicate the area printed in, but we want to
 678        keep the original for drawing margins */
 679     lpFr->rc = get_print_rect(lpFr->hdcTarget);
 680     SendMessageW(hEditorWnd, EM_FORMATRANGE, FALSE, 0);
 681 }
 682
 683 LRESULT print_preview(HWND hMainWnd)
 684 {
 685     FORMATRANGE fr;
 686     GETTEXTLENGTHEX gt;
 687     HDC hdc;
 688     RECT window, background;
 689     int bmWidth, bmHeight, bmNewWidth, bmNewHeight;
 690     float ratioWidth, ratioHeight, ratio;
 691     int xOffset, yOffset;
 692     int barheight;
 693     float spacing = 20.0;
 694     HWND hReBar = GetDlgItem(hMainWnd, IDC_REBAR);
 695     PAINTSTRUCT ps;
 696
 697     hdc = BeginPaint(hMainWnd, &ps);
 698     GetClientRect(hMainWnd, &window);
 699
 700     fr.hdcTarget = make_dc();
 701     fr.rc = get_print_rect(fr.hdcTarget);
 702     fr.rcPage.left = 0;
 703     fr.rcPage.top = 0;
 704     fr.rcPage.bottom = fr.rc.bottom + margins.bottom;
 705     fr.rcPage.right = fr.rc.right + margins.right;
 706
 707     bmWidth = twips_to_pixels(fr.rcPage.right, GetDeviceCaps(hdc, LOGPIXELSX));
 708     bmHeight = twips_to_pixels(fr.rcPage.bottom, GetDeviceCaps(hdc, LOGPIXELSY));
 709
 710     if(!preview.hdc)
 711     {
 712         RECT paper;
 713         HWND hEditorWnd = GetDlgItem(hMainWnd, IDC_EDITOR);
 714
 715         preview.hdc = CreateCompatibleDC(hdc);
 716
 717         if(preview.hdc2)
 718         {
 719             if(preview.hdc2 != (HDC)-1)
 720                 DeleteDC(preview.hdc2);
 721             preview.hdc2 = CreateCompatibleDC(hdc);
 722         }
 723
 724         fr.hdc = preview.hdc;
 725         gt.flags = GTL_DEFAULT;
 726         gt.codepage = 1200;
 727         fr.chrg.cpMin = 0;
 728         fr.chrg.cpMax = SendMessageW(hEditorWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gt, 0);
 729
 730         paper.left = 0;
 731         paper.right = bmWidth;
 732         paper.top = 0;
 733         paper.bottom = bmHeight;
 734
 735         if(!preview.pages)
 736             preview.pages = get_num_pages(hEditorWnd, fr);
 737
 738         fr.hdc = preview.hdc;
 739         draw_preview(hEditorWnd, &fr, bmWidth, bmHeight, &paper, preview.page);
 740
 741         if(preview.hdc2)
 742         {
 743             fr.hdc = preview.hdc2;
 744             draw_preview(hEditorWnd, &fr, bmWidth, bmHeight, &paper, preview.page + 1);
 745         }
 746
 747         EnableWindow(GetDlgItem(hReBar, ID_PREVIEW_PREVPAGE), preview.page > 1);
 748         EnableWindow(GetDlgItem(hReBar, ID_PREVIEW_NEXTPAGE), preview.hdc2 ?
 749                                                               (preview.page + 1) < preview.pages :
 750                                                               preview.page < preview.pages);
 751         EnableWindow(GetDlgItem(hReBar, ID_PREVIEW_NUMPAGES), preview.pages > 1);
 752     }
 753
 754     barheight = SendMessageW(hReBar, RB_GETBARHEIGHT, 0, 0);
 755     ratioHeight = ((float)window.bottom - spacing - (float)barheight) / (float)bmHeight;
 756
 757     if(preview.hdc2)
 758         ratioWidth = ((float)window.right / 2.0 - spacing * 2.0) / (float)bmWidth;
 759     else
 760         ratioWidth = ((float)window.right - spacing * 3.0) / (float)bmWidth;
 761
 762     if(ratioWidth > ratioHeight)
 763         ratio = ratioHeight;
 764     else
 765         ratio = ratioWidth;
 766
 767     bmNewWidth = (int)((float)bmWidth * ratio);
 768     bmNewHeight = (int)((float)bmHeight * ratio);
 769
 770     yOffset = ((window.bottom - bmNewHeight + barheight) / 2);
 771
 772     if(!preview.hdc2)
 773         xOffset = (window.right - bmNewWidth) / 2;
 774     else
 775         xOffset = (window.right - bmNewWidth * 2) / 2;
 776
 777     window.top = barheight;
 778     FillRect(hdc, &window, GetStockObject(GRAY_BRUSH));
 779
 780     background.left = xOffset - 2;
 781     background.right = xOffset + bmNewWidth + 2;
 782     background.top = yOffset - 2;
 783     background.bottom = yOffset + bmNewHeight + 2;
 784
 785     FillRect(hdc, &background, GetStockObject(BLACK_BRUSH));
 786
 787     if(window.right != preview.window.right || window.bottom != preview.window.bottom)
 788     {
 789         draw_preview_page(preview.hdc, &preview.hdcSized, &fr, ratio, bmNewWidth, bmNewHeight, bmWidth, bmHeight);
 790
 791         if(preview.hdc2)
 792         {
 793             background.left += bmNewWidth + spacing;
 794             background.right += bmNewWidth + spacing;
 795
 796             FillRect(hdc, &background, GetStockObject(BLACK_BRUSH));
 797
 798             draw_preview_page(preview.hdc2, &preview.hdcSized2, &fr, ratio, bmNewWidth, bmNewHeight, bmWidth, bmHeight);
 799         }
 800     }
 801
 802     BitBlt(hdc, xOffset, yOffset, bmNewWidth, bmNewHeight, preview.hdcSized, 0, 0, SRCCOPY);
 803
 804     if(preview.hdc2)
 805     {
 806         BitBlt(hdc, xOffset + bmNewWidth + spacing, yOffset, bmNewWidth, bmNewHeight, preview.hdcSized2, 0, 0, SRCCOPY);
 807     }
 808
 809     DeleteDC(fr.hdcTarget);
 810     preview.window = window;
 811
 812     EndPaint(hMainWnd, &ps);
 813
 814     return 0;
 815 }
 816
 817 static void update_preview(HWND hWnd)
 818 {
 819     RECT rc;
 820
 821     DeleteDC(preview.hdc);
 822     preview.hdc = 0;
 823
 824     preview.window.right = 0;
 825
 826     GetClientRect(hWnd, &rc);
 827     rc.top += SendMessageW(GetDlgItem(hWnd, IDC_REBAR), RB_GETBARHEIGHT, 0, 0);
 828     InvalidateRect(hWnd, &rc, TRUE);
 829 }
 830
 831 LRESULT preview_command(HWND hWnd, WPARAM wParam)
 832 {
 833     switch(LOWORD(wParam))
 834     {
 835         case ID_FILE_EXIT:
 836             PostMessageW(hWnd, WM_CLOSE, 0, 0);
 837             break;
 838
 839         case ID_PREVIEW_NEXTPAGE:
 840         case ID_PREVIEW_PREVPAGE:
 841         {
 842             if(LOWORD(wParam) == ID_PREVIEW_NEXTPAGE)
 843                 preview.page++;
 844             else
 845                 preview.page--;
 846
 847             update_preview(hWnd);
 848         }
 849         break;
 850
 851         case ID_PREVIEW_NUMPAGES:
 852         {
 853             HWND hReBar = GetDlgItem(hWnd, IDC_REBAR);
 854             WCHAR name[MAX_STRING_LEN];
 855             HINSTANCE hInst = GetModuleHandleW(0);
 856
 857             if(preview.hdc2)
 858             {
 859                 DeleteDC(preview.hdc2);
 860                 preview.hdc2 = 0;
 861             } else
 862             {
 863                 if(preview.page == preview.pages)
 864                     preview.page--;
 865                 preview.hdc2 = (HDC)-1;
 866             }
 867
 868             LoadStringW(hInst, preview.hdc2 ? STRING_PREVIEW_ONEPAGE : STRING_PREVIEW_TWOPAGES,
 869                         name, MAX_STRING_LEN);
 870
 871             SetWindowTextW(GetDlgItem(hReBar, ID_PREVIEW_NUMPAGES), name);
 872             update_preview(hWnd);
 873         }
 874         break;
 875
 876         case ID_PRINT:
 877             dialog_print(hWnd, preview.wszFileName);
 878             SendMessageW(hWnd, WM_CLOSE, 0, 0);
 879             break;
 880     }
 881
 882     return 0;
 883 }