src/msw/dcprint.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/dcprint.cpp
   3 // Purpose:     wxPrinterDC class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "dcprint.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/string.h"
  33     #include "wx/log.h"
  34     #include "wx/window.h"
  35     #include "wx/dcmemory.h"
  36 #endif
  37
  38 #include "wx/msw/private.h"
  39 #include "wx/dcprint.h"
  40 #include "math.h"
  41
  42 #if wxUSE_COMMON_DIALOGS || defined(__WXWINE__)
  43     #include <commdlg.h>
  44 #endif
  45
  46 #ifndef __WIN32__
  47     #include <print.h>
  48 #endif
  49
  50 // mingw32 defines GDI_ERROR incorrectly
  51 #ifdef __GNUWIN32__
  52     #undef GDI_ERROR
  53     #define GDI_ERROR ((int)-1)
  54 #endif
  55
  56 // ----------------------------------------------------------------------------
  57 // wxWin macros
  58 // ----------------------------------------------------------------------------
  59
  60 IMPLEMENT_CLASS(wxPrinterDC, wxDC)
  61
  62 // ============================================================================
  63 // implementation
  64 // ============================================================================
  65
  66 // ----------------------------------------------------------------------------
  67 // wxPrinterDC construction
  68 // ----------------------------------------------------------------------------
  69
  70 // This form is deprecated
  71 wxPrinterDC::wxPrinterDC(const wxString& driver_name, const wxString& device_name, const wxString& file, bool interactive, int orientation)
  72 {
  73     m_isInteractive = interactive;
  74
  75     if ( !!file )
  76         m_printData.SetFilename(file);
  77
  78 #if wxUSE_COMMON_DIALOGS
  79     if (interactive)
  80     {
  81         PRINTDLG pd;
  82
  83         pd.lStructSize = sizeof( PRINTDLG );
  84         pd.hwndOwner=(HWND) NULL;
  85         pd.hDevMode=(HANDLE)NULL;
  86         pd.hDevNames=(HANDLE)NULL;
  87         pd.Flags=PD_RETURNDC | PD_NOSELECTION | PD_NOPAGENUMS;
  88         pd.nFromPage=0;
  89         pd.nToPage=0;
  90         pd.nMinPage=0;
  91         pd.nMaxPage=0;
  92         pd.nCopies=1;
  93         pd.hInstance=(HINSTANCE)NULL;
  94
  95         if ( PrintDlg( &pd ) != 0 )
  96         {
  97             m_hDC = (WXHDC) pd.hDC;
  98             m_ok = TRUE;
  99         }
 100         else
 101         {
 102             m_ok = FALSE;
 103             return;
 104         }
 105
 106         //     m_dontDelete = TRUE;
 107     }
 108     else
 109 #endif // wxUSE_COMMON_DIALOGS
 110         if ((!driver_name.IsNull() && driver_name != wxT("")) &&
 111             (!device_name.IsNull() && device_name != wxT("")) &&
 112             (!file.IsNull() && file != wxT("")))
 113         {
 114             m_hDC = (WXHDC) CreateDC(WXSTRINGCAST driver_name, WXSTRINGCAST device_name, WXSTRINGCAST file, NULL);
 115             m_ok = m_hDC ? TRUE: FALSE;
 116         }
 117         else
 118         {
 119             wxPrintData printData;
 120             printData.SetOrientation(orientation);
 121             m_hDC = wxGetPrinterDC(printData);
 122             m_ok = m_hDC ? TRUE: FALSE;
 123         }
 124
 125         if (m_hDC)
 126         {
 127             //     int width = GetDeviceCaps(m_hDC, VERTRES);
 128             //     int height = GetDeviceCaps(m_hDC, HORZRES);
 129             SetMapMode(wxMM_TEXT);
 130         }
 131         SetBrush(*wxBLACK_BRUSH);
 132         SetPen(*wxBLACK_PEN);
 133 }
 134
 135 wxPrinterDC::wxPrinterDC(const wxPrintData& printData)
 136 {
 137     m_printData = printData;
 138
 139     m_isInteractive = FALSE;
 140
 141     m_hDC = wxGetPrinterDC(printData);
 142     m_ok = (m_hDC != 0);
 143
 144     if (m_hDC)
 145         SetMapMode(wxMM_TEXT);
 146
 147     SetBrush(*wxBLACK_BRUSH);
 148     SetPen(*wxBLACK_PEN);
 149 }
 150
 151
 152 wxPrinterDC::wxPrinterDC(WXHDC theDC)
 153 {
 154     m_isInteractive = FALSE;
 155
 156     m_hDC = theDC;
 157     m_ok = TRUE;
 158     if (m_hDC)
 159     {
 160         //     int width = GetDeviceCaps(m_hDC, VERTRES);
 161         //     int height = GetDeviceCaps(m_hDC, HORZRES);
 162         SetMapMode(wxMM_TEXT);
 163     }
 164     SetBrush(*wxBLACK_BRUSH);
 165     SetPen(*wxBLACK_PEN);
 166 }
 167
 168 wxPrinterDC::~wxPrinterDC()
 169 {
 170 }
 171
 172 // ----------------------------------------------------------------------------
 173 // wxPrinterDC {Start/End}{Page/Doc} methods
 174 // ----------------------------------------------------------------------------
 175
 176 bool wxPrinterDC::StartDoc(const wxString& message)
 177 {
 178     DOCINFO docinfo;
 179     docinfo.cbSize = sizeof(DOCINFO);
 180     docinfo.lpszDocName = (const wxChar*)message;
 181
 182     wxString filename(m_printData.GetFilename());
 183
 184     if (filename.IsEmpty())
 185         docinfo.lpszOutput = NULL;
 186     else
 187         docinfo.lpszOutput = (const wxChar *) filename;
 188
 189 #if defined(__WIN95__)
 190     docinfo.lpszDatatype = NULL;
 191     docinfo.fwType = 0;
 192 #endif
 193
 194     if (!m_hDC)
 195         return FALSE;
 196
 197     int ret = ::StartDoc(GetHdc(), &docinfo);
 198
 199 #ifndef __WIN16__
 200     if (ret <= 0)
 201     {
 202         DWORD lastError = GetLastError();
 203         wxLogDebug(wxT("wxDC::StartDoc failed with error: %d\n"), lastError);
 204     }
 205 #endif
 206
 207     return (ret > 0);
 208 }
 209
 210 void wxPrinterDC::EndDoc()
 211 {
 212     if (m_hDC) ::EndDoc((HDC) m_hDC);
 213 }
 214
 215 void wxPrinterDC::StartPage()
 216 {
 217     if (m_hDC)
 218         ::StartPage((HDC) m_hDC);
 219 }
 220
 221 void wxPrinterDC::EndPage()
 222 {
 223     if (m_hDC)
 224         ::EndPage((HDC) m_hDC);
 225 }
 226
 227 // Returns default device and port names
 228 static bool wxGetDefaultDeviceName(wxString& deviceName, wxString& portName)
 229 {
 230     deviceName = "";
 231
 232     LPDEVNAMES  lpDevNames;
 233     LPSTR       lpszDriverName;
 234     LPSTR       lpszDeviceName;
 235     LPSTR       lpszPortName;
 236
 237     PRINTDLG    pd;
 238
 239     // Cygwin has trouble believing PRINTDLG is 66 bytes - thinks it is 68
 240 #ifdef __GNUWIN32__
 241     pd.lStructSize    = 66; // sizeof(PRINTDLG);
 242 #else
 243     pd.lStructSize    = sizeof(PRINTDLG);
 244 #endif
 245
 246     pd.hwndOwner      = (HWND)NULL;
 247     pd.hDevMode       = NULL; // Will be created by PrintDlg
 248     pd.hDevNames      = NULL; // Ditto
 249     pd.Flags          = PD_RETURNDEFAULT;
 250     pd.nCopies        = 1;
 251
 252     if (!PrintDlg((LPPRINTDLG)&pd))
 253     {
 254         if ( pd.hDevMode )
 255             GlobalFree(pd.hDevMode);
 256         if (pd.hDevNames)
 257             GlobalFree(pd.hDevNames);
 258
 259         return FALSE;
 260     }
 261
 262     if (pd.hDevNames)
 263     {
 264         lpDevNames = (LPDEVNAMES)GlobalLock(pd.hDevNames);
 265         lpszDriverName = (LPSTR)lpDevNames + lpDevNames->wDriverOffset;
 266         lpszDeviceName = (LPSTR)lpDevNames + lpDevNames->wDeviceOffset;
 267         lpszPortName   = (LPSTR)lpDevNames + lpDevNames->wOutputOffset;
 268
 269         deviceName = lpszDeviceName;
 270         portName = lpszPortName;
 271
 272         GlobalUnlock(pd.hDevNames);
 273         GlobalFree(pd.hDevNames);
 274         pd.hDevNames=NULL;
 275     }
 276
 277     if (pd.hDevMode)
 278     {
 279         GlobalFree(pd.hDevMode);
 280         pd.hDevMode=NULL;
 281     }
 282     return ( deviceName != wxT("") );
 283 }
 284
 285 #if 0
 286 // This uses defaults, except for orientation, so we should eliminate this function
 287 // and use the 2nd form (passing wxPrintData) instead.
 288 WXHDC wxGetPrinterDC(int orientation)
 289 {
 290     HDC         hDC;
 291     LPDEVMODE   lpDevMode = NULL;
 292     LPDEVNAMES  lpDevNames;
 293     LPSTR       lpszDriverName;
 294     LPSTR       lpszDeviceName;
 295     LPSTR       lpszPortName;
 296
 297     PRINTDLG    pd;
 298     // __GNUWIN32__ has trouble believing PRINTDLG is 66 bytes - thinks it is 68
 299 #ifdef __GNUWIN32__
 300     pd.lStructSize    = 66; // sizeof(PRINTDLG);
 301 #else
 302     pd.lStructSize    = sizeof(PRINTDLG);
 303 #endif
 304     pd.hwndOwner      = (HWND)NULL;
 305     pd.hDevMode       = NULL; // Will be created by PrintDlg
 306     pd.hDevNames      = NULL; // Ditto
 307     pd.Flags          = PD_RETURNDEFAULT;
 308     pd.nCopies        = 1;
 309
 310     if (!PrintDlg((LPPRINTDLG)&pd))
 311     {
 312         if ( pd.hDevMode )
 313             GlobalFree(pd.hDevMode);
 314         if (pd.hDevNames)
 315             GlobalFree(pd.hDevNames);
 316
 317         return(0);
 318     }
 319
 320     if (!pd.hDevNames)
 321     {
 322         if ( pd.hDevMode )
 323             GlobalFree(pd.hDevMode);
 324     }
 325
 326     lpDevNames = (LPDEVNAMES)GlobalLock(pd.hDevNames);
 327     lpszDriverName = (LPSTR)lpDevNames + lpDevNames->wDriverOffset;
 328     lpszDeviceName = (LPSTR)lpDevNames + lpDevNames->wDeviceOffset;
 329     lpszPortName   = (LPSTR)lpDevNames + lpDevNames->wOutputOffset;
 330     GlobalUnlock(pd.hDevNames);
 331
 332     if ( pd.hDevMode )
 333     {
 334         lpDevMode = (DEVMODE*) GlobalLock(pd.hDevMode);
 335         lpDevMode->dmOrientation = orientation;
 336         lpDevMode->dmFields |= DM_ORIENTATION;
 337     }
 338
 339 #ifdef __WIN32__
 340     hDC = CreateDC(lpszDriverName, lpszDeviceName, lpszPortName, (DEVMODE *)lpDevMode);
 341 #else
 342     hDC = CreateDC(lpszDriverName, lpszDeviceName, lpszPortName, (LPSTR)lpDevMode);
 343 #endif
 344
 345     if (pd.hDevMode && lpDevMode)
 346         GlobalUnlock(pd.hDevMode);
 347
 348     if (pd.hDevNames)
 349     {
 350         GlobalFree(pd.hDevNames);
 351         pd.hDevNames=NULL;
 352     }
 353     if (pd.hDevMode)
 354     {
 355         GlobalFree(pd.hDevMode);
 356         pd.hDevMode=NULL;
 357     }
 358     return (WXHDC) hDC;
 359 }
 360 #endif
 361
 362 // Gets an HDC for the specified printer configuration
 363 WXHDC WXDLLEXPORT wxGetPrinterDC(const wxPrintData& printDataConst)
 364 {
 365     wxPrintData printData = printDataConst;
 366     printData.ConvertToNative();
 367
 368     wxChar* driverName = (wxChar*) NULL;
 369
 370     wxString devNameStr = printData.GetPrinterName();
 371     wxChar* portName = (wxChar*) NULL; // Obsolete in WIN32
 372
 373     const wxChar* deviceName;
 374     if ( !devNameStr )
 375         deviceName = (wxChar*) NULL;
 376     else
 377         deviceName = devNameStr.c_str();
 378
 379     LPDEVMODE lpDevMode = (LPDEVMODE) NULL;
 380
 381     HGLOBAL hDevMode = (HGLOBAL)(DWORD) printData.GetNativeData();
 382
 383     if ( hDevMode )
 384         lpDevMode = (DEVMODE*) GlobalLock(hDevMode);
 385
 386     if ( !devNameStr )
 387     {
 388         // Retrieve the default device name
 389         wxString portName;
 390 #ifdef  __WXDEBUG__
 391         bool ret =
 392 #else   // !Debug
 393         (void)
 394 #endif // Debug/Release
 395         wxGetDefaultDeviceName(devNameStr, portName);
 396
 397         wxASSERT_MSG( ret, wxT("Could not get default device name.") );
 398
 399         deviceName = devNameStr.c_str();
 400     }
 401
 402 #ifdef __WIN32__
 403     HDC hDC = CreateDC(driverName, deviceName, portName, (DEVMODE *) lpDevMode);
 404 #else
 405     HDC hDC = CreateDC(driverName, deviceName, portName, (LPSTR) lpDevMode);
 406 #endif
 407
 408     if (hDevMode && lpDevMode)
 409         GlobalUnlock(hDevMode);
 410
 411     return (WXHDC) hDC;
 412 }
 413
 414 // ----------------------------------------------------------------------------
 415 // wxPrinterDC bit blitting/bitmap drawing
 416 // ----------------------------------------------------------------------------
 417
 418 // Win16 doesn't define GDI_ERROR.
 419 #ifndef GDI_ERROR
 420 #define GDI_ERROR -1
 421 #endif
 422
 423 void wxPrinterDC::DoDrawBitmap(const wxBitmap &bmp,
 424                                wxCoord x, wxCoord y,
 425                                bool useMask)
 426 {
 427     wxCHECK_RET( bmp.Ok(), _T("invalid bitmap in wxPrinterDC::DrawBitmap") );
 428
 429     int width = bmp.GetWidth(),
 430         height = bmp.GetHeight();
 431
 432     if ( ::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHDIB )
 433     {
 434         BITMAPINFO *info = (BITMAPINFO *) malloc( sizeof( BITMAPINFOHEADER ) + 256 * sizeof(RGBQUAD ) );
 435         memset( info, 0, sizeof( BITMAPINFOHEADER ) );
 436
 437         int iBitsSize = ((width + 3 ) & ~3 ) * height;
 438
 439         void* bits = malloc( iBitsSize );
 440
 441         info->bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
 442         info->bmiHeader.biWidth = width;
 443         info->bmiHeader.biHeight = height;
 444         info->bmiHeader.biPlanes = 1;
 445         info->bmiHeader.biBitCount = 8;
 446         info->bmiHeader.biCompression = BI_RGB;
 447
 448         ScreenHDC display;
 449         if ( GetDIBits(display, GetHbitmapOf(bmp), 0,
 450                        bmp.GetHeight(), bits, info,
 451                        DIB_RGB_COLORS) )
 452         {
 453             if ( ::StretchDIBits(GetHdc(), x, y,
 454                                  width, height,
 455                                  0 , 0, width, height,
 456                                  bits, info,
 457                                  DIB_RGB_COLORS, SRCCOPY) == GDI_ERROR )
 458             {
 459                 wxLogLastError("StretchDIBits");
 460             }
 461         }
 462
 463         free(bits);
 464         free(info);
 465     }
 466     else // no support for StretchDIBits()
 467     {
 468         wxMemoryDC memDC;
 469         memDC.SelectObject(bmp);
 470
 471         Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
 472
 473         memDC.SelectObject(wxNullBitmap);
 474     }
 475 }
 476
 477 bool wxPrinterDC::DoBlit(wxCoord xdest, wxCoord ydest,
 478                          wxCoord width, wxCoord height,
 479                          wxDC *source,
 480                          wxCoord xsrc, wxCoord ysrc,
 481                          int rop, bool useMask)
 482 {
 483     bool success = TRUE;
 484
 485     if ( useMask )
 486     {
 487         // If we are printing source colours are screen colours
 488         // not printer colours and so we need copy the bitmap
 489         // pixel by pixel.
 490         RECT rect;
 491         HDC dc_src = GetHdcOf(*source);
 492         HDC dc_mask = ::CreateCompatibleDC(dc_src);
 493
 494         ::SelectObject(dc_mask, (HBITMAP) source->GetSelectedBitmap().GetMask()->GetMaskBitmap());
 495         for (int x = 0; x < width; x++)
 496         {
 497             for (int y = 0; y < height; y++)
 498             {
 499                 COLORREF cref = ::GetPixel(dc_mask, x, y);
 500                 if (cref)
 501                 {
 502                     HBRUSH brush = ::CreateSolidBrush(::GetPixel(dc_src, x, y));
 503                     rect.left = xdest + x;
 504                     rect.right = rect.left + 1;
 505                     rect.top = ydest + y;
 506                     rect.bottom = rect.top + 1;
 507                     ::FillRect(GetHdc(), &rect, brush);
 508                     ::DeleteObject(brush);
 509                 }
 510             }
 511         }
 512         ::SelectObject(dc_mask, 0);
 513         ::DeleteDC(dc_mask);
 514     }
 515     else // no mask
 516     {
 517         if ( ::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHDIB )
 518         {
 519             wxBitmap& bmp = source->GetSelectedBitmap();
 520             int width = bmp.GetWidth(),
 521                 height = bmp.GetHeight();
 522
 523             BITMAPINFO *info = (BITMAPINFO *) malloc( sizeof( BITMAPINFOHEADER ) + 256 * sizeof(RGBQUAD ) );
 524             int iBitsSize = ((width + 3 ) & ~3 ) * height;
 525
 526             void* bits = malloc( iBitsSize );
 527
 528             memset( info , 0 , sizeof( BITMAPINFOHEADER ) );
 529
 530             info->bmiHeader.biSize = sizeof( BITMAPINFOHEADER );
 531             info->bmiHeader.biWidth = width;
 532             info->bmiHeader.biHeight = height;
 533             info->bmiHeader.biPlanes = 1;
 534             info->bmiHeader.biBitCount = 8;
 535             info->bmiHeader.biCompression = BI_RGB;
 536
 537             ScreenHDC display;
 538             if ( !::GetDIBits(display, GetHbitmapOf(bmp), 0,
 539                               height, bits, info, DIB_RGB_COLORS) )
 540             {
 541                 wxLogLastError("GetDIBits");
 542
 543                 success = FALSE;
 544             }
 545
 546             if ( success )
 547             {
 548                 success = ::StretchDIBits(GetHdc(), xdest, ydest,
 549                                           width, height,
 550                                           xsrc, ysrc,
 551                                           width, height,
 552                                           bits, info ,
 553                                           DIB_RGB_COLORS,
 554                                           SRCCOPY) != GDI_ERROR;
 555                 if ( !success )
 556                 {
 557                     wxLogLastError("StretchDIBits");
 558                 }
 559             }
 560
 561             free(bits);
 562             free(info);
 563         }
 564         else // no support for StretchDIBits
 565         {
 566             // as we are printing, source colours are screen colours not printer
 567             // colours and so we need copy the bitmap pixel by pixel.
 568             HDC dc_src = GetHdcOf(*source);
 569             RECT rect;
 570             for (int y = 0; y < height; y++)
 571             {
 572                 // This is Stefan Csomor's optimisation, where identical adjacent
 573                 // pixels are drawn together.
 574                 for (int x = 0; x < width; x++)
 575                 {
 576                     COLORREF col = ::GetPixel(dc_src, x, y);
 577                     HBRUSH brush = ::CreateSolidBrush( col );
 578
 579                     rect.left = xdest + x;
 580                     rect.top = ydest + y;
 581                     while( (x + 1 < width) && (::GetPixel(dc_src, x + 1, y) == col ) )
 582                     {
 583                         ++x;
 584                     }
 585                     rect.right = xdest + x + 1;
 586                     rect.bottom = rect.top + 1;
 587                     ::FillRect((HDC) m_hDC, &rect, brush);
 588                     ::DeleteObject(brush);
 589                 }
 590             }
 591         }
 592     }
 593
 594     return success;
 595 }