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
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_PRINTING_ARCHITECTURE
  28
  29 #include "wx/dcprint.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/msw/wrapcdlg.h"
  33     #include "wx/string.h"
  34     #include "wx/log.h"
  35     #include "wx/window.h"
  36     #include "wx/dcmemory.h"
  37     #include "wx/math.h"
  38 #endif
  39
  40 #include "wx/msw/private.h"
  41
  42 #if wxUSE_WXDIB
  43     #include "wx/msw/dib.h"
  44 #endif
  45
  46 #include "wx/printdlg.h"
  47 #include "wx/msw/printdlg.h"
  48
  49 #ifndef __WIN32__
  50     #include <print.h>
  51 #endif
  52
  53 // mingw32 defines GDI_ERROR incorrectly
  54 #if defined(__GNUWIN32__) || !defined(GDI_ERROR)
  55     #undef GDI_ERROR
  56     #define GDI_ERROR ((int)-1)
  57 #endif
  58
  59 #if defined(__WXUNIVERSAL__) || wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW
  60     #define wxUSE_PS_PRINTING 1
  61 #else
  62     #define wxUSE_PS_PRINTING 0
  63 #endif
  64
  65 // ----------------------------------------------------------------------------
  66 // wxWin macros
  67 // ----------------------------------------------------------------------------
  68
  69 IMPLEMENT_CLASS(wxPrinterDC, wxDC)
  70
  71 // ============================================================================
  72 // implementation
  73 // ============================================================================
  74
  75 // ----------------------------------------------------------------------------
  76 // wxPrinterDC construction
  77 // ----------------------------------------------------------------------------
  78
  79 // This form is deprecated
  80 wxPrinterDC::wxPrinterDC(const wxString& driver_name,
  81                          const wxString& device_name,
  82                          const wxString& file,
  83                          bool interactive,
  84                          int orientation)
  85 {
  86     m_isInteractive = interactive;
  87
  88     if ( !file.empty() )
  89         m_printData.SetFilename(file);
  90
  91 #if wxUSE_COMMON_DIALOGS
  92     if ( interactive )
  93     {
  94         PRINTDLG pd;
  95
  96         pd.lStructSize = sizeof( PRINTDLG );
  97         pd.hwndOwner = (HWND) NULL;
  98         pd.hDevMode = (HANDLE)NULL;
  99         pd.hDevNames = (HANDLE)NULL;
 100         pd.Flags = PD_RETURNDC | PD_NOSELECTION | PD_NOPAGENUMS;
 101         pd.nFromPage = 0;
 102         pd.nToPage = 0;
 103         pd.nMinPage = 0;
 104         pd.nMaxPage = 0;
 105         pd.nCopies = 1;
 106         pd.hInstance = (HINSTANCE)NULL;
 107
 108         m_ok = PrintDlg( &pd ) != 0;
 109         if ( m_ok )
 110         {
 111             m_hDC = (WXHDC) pd.hDC;
 112         }
 113     }
 114     else
 115 #endif // wxUSE_COMMON_DIALOGS
 116     {
 117         if ( !driver_name.empty() && !device_name.empty() && !file.empty() )
 118         {
 119             m_hDC = (WXHDC) CreateDC(driver_name, device_name, file, NULL);
 120         }
 121         else // we don't have all parameters, ask the user
 122         {
 123             wxPrintData printData;
 124             printData.SetOrientation(orientation);
 125             m_hDC = wxGetPrinterDC(printData);
 126         }
 127
 128         m_ok = m_hDC ? true: false;
 129
 130         // as we created it, we must delete it as well
 131         m_bOwnsDC = true;
 132     }
 133
 134     Init();
 135 }
 136
 137 wxPrinterDC::wxPrinterDC(const wxPrintData& printData)
 138 {
 139     m_printData = printData;
 140
 141     m_isInteractive = false;
 142
 143     m_hDC = wxGetPrinterDC(printData);
 144     m_ok = m_hDC != 0;
 145     m_bOwnsDC = true;
 146
 147     Init();
 148 }
 149
 150
 151 wxPrinterDC::wxPrinterDC(WXHDC dc)
 152 {
 153     m_isInteractive = false;
 154
 155     m_hDC = dc;
 156     m_bOwnsDC = true;
 157     m_ok = true;
 158 }
 159
 160 void wxPrinterDC::Init()
 161 {
 162     if ( m_hDC )
 163     {
 164         //     int width = GetDeviceCaps(m_hDC, VERTRES);
 165         //     int height = GetDeviceCaps(m_hDC, HORZRES);
 166         SetMapMode(wxMM_TEXT);
 167
 168         SetBrush(*wxBLACK_BRUSH);
 169         SetPen(*wxBLACK_PEN);
 170     }
 171 }
 172
 173 // ----------------------------------------------------------------------------
 174 // wxPrinterDC {Start/End}{Page/Doc} methods
 175 // ----------------------------------------------------------------------------
 176
 177 bool wxPrinterDC::StartDoc(const wxString& message)
 178 {
 179     DOCINFO docinfo;
 180     docinfo.cbSize = sizeof(DOCINFO);
 181     docinfo.lpszDocName = (const wxChar*)message;
 182
 183     wxString filename(m_printData.GetFilename());
 184
 185     if (filename.empty())
 186         docinfo.lpszOutput = NULL;
 187     else
 188         docinfo.lpszOutput = (const wxChar *) filename;
 189
 190     docinfo.lpszDatatype = NULL;
 191     docinfo.fwType = 0;
 192
 193     if (!m_hDC)
 194         return false;
 195
 196     int ret = ::StartDoc(GetHdc(), &docinfo);
 197
 198     if (ret <= 0)
 199     {
 200         DWORD lastError = GetLastError();
 201         wxLogDebug(wxT("wxDC::StartDoc failed with error: %ld\n"), lastError);
 202     }
 203
 204     return (ret > 0);
 205 }
 206
 207 void wxPrinterDC::EndDoc()
 208 {
 209     if (m_hDC) ::EndDoc((HDC) m_hDC);
 210 }
 211
 212 void wxPrinterDC::StartPage()
 213 {
 214     if (m_hDC)
 215         ::StartPage((HDC) m_hDC);
 216 }
 217
 218 void wxPrinterDC::EndPage()
 219 {
 220     if (m_hDC)
 221         ::EndPage((HDC) m_hDC);
 222 }
 223
 224 #if !wxUSE_PS_PRINTING
 225
 226 // Returns default device and port names
 227 static bool wxGetDefaultDeviceName(wxString& deviceName, wxString& portName)
 228 {
 229     deviceName.clear();
 230
 231     LPDEVNAMES  lpDevNames;
 232     LPTSTR      lpszDeviceName;
 233     LPTSTR      lpszPortName;
 234
 235     PRINTDLG    pd;
 236
 237     // Cygwin has trouble believing PRINTDLG is 66 bytes - thinks it is 68
 238 #ifdef __GNUWIN32__
 239     memset(&pd, 0, 66);
 240     pd.lStructSize    = 66; // sizeof(PRINTDLG);
 241 #else
 242     memset(&pd, 0, sizeof(PRINTDLG));
 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         lpszDeviceName = (LPTSTR)lpDevNames + lpDevNames->wDeviceOffset;
 266         lpszPortName   = (LPTSTR)lpDevNames + lpDevNames->wOutputOffset;
 267
 268         deviceName = lpszDeviceName;
 269         portName = lpszPortName;
 270
 271         GlobalUnlock(pd.hDevNames);
 272         GlobalFree(pd.hDevNames);
 273         pd.hDevNames=NULL;
 274     }
 275
 276     if (pd.hDevMode)
 277     {
 278         GlobalFree(pd.hDevMode);
 279         pd.hDevMode=NULL;
 280     }
 281     return ( !deviceName.empty() );
 282 }
 283
 284 #endif // !wxUSE_PS_PRINTING
 285
 286 // Gets an HDC for the specified printer configuration
 287 WXHDC WXDLLEXPORT wxGetPrinterDC(const wxPrintData& printDataConst)
 288 {
 289 #if wxUSE_PS_PRINTING
 290     // TODO
 291     wxUnusedVar(printDataConst);
 292     return 0;
 293 #else // native Windows printing
 294     wxWindowsPrintNativeData *data =
 295         (wxWindowsPrintNativeData *) printDataConst.GetNativeData();
 296
 297     data->TransferFrom( printDataConst );
 298
 299     wxString deviceName = printDataConst.GetPrinterName();
 300     if ( deviceName.empty() )
 301     {
 302         // Retrieve the default device name
 303         wxString portName;
 304         if ( !wxGetDefaultDeviceName(deviceName, portName) )
 305         {
 306             return 0; // Could not get default device name
 307         }
 308     }
 309
 310
 311     HGLOBAL hDevMode = (HGLOBAL)(DWORD) data->GetDevMode();
 312
 313     DEVMODE *lpDevMode = hDevMode ? (DEVMODE *)::GlobalLock(hDevMode) : NULL;
 314
 315     HDC hDC = ::CreateDC(NULL, deviceName, NULL, lpDevMode);
 316     if ( !hDC )
 317         wxLogLastError(_T("CreateDC(printer)"));
 318
 319     if ( lpDevMode )
 320         ::GlobalUnlock(hDevMode);
 321
 322     return (WXHDC) hDC;
 323 #endif // PostScript/Windows printing
 324 }
 325
 326 // ----------------------------------------------------------------------------
 327 // wxPrinterDC bit blitting/bitmap drawing
 328 // ----------------------------------------------------------------------------
 329
 330 // helper of DoDrawBitmap() and DoBlit()
 331 static
 332 bool DrawBitmapUsingStretchDIBits(HDC hdc,
 333                                   const wxBitmap& bmp,
 334                                   wxCoord x, wxCoord y)
 335 {
 336 #if wxUSE_WXDIB
 337     wxDIB dib(bmp);
 338     bool ok = dib.IsOk();
 339     if ( !ok )
 340         return false;
 341
 342     DIBSECTION ds;
 343     if ( !::GetObject(dib.GetHandle(), sizeof(ds), &ds) )
 344     {
 345         wxLogLastError(_T("GetObject(DIBSECTION)"));
 346
 347         return false;
 348     }
 349
 350     // ok, we've got all data we need, do blit it
 351     if ( ::StretchDIBits
 352             (
 353                 hdc,
 354                 x, y,
 355                 ds.dsBmih.biWidth, ds.dsBmih.biHeight,
 356                 0, 0,
 357                 ds.dsBmih.biWidth, ds.dsBmih.biHeight,
 358                 ds.dsBm.bmBits,
 359                 (LPBITMAPINFO)&ds.dsBmih,
 360                 DIB_RGB_COLORS,
 361                 SRCCOPY
 362             ) == GDI_ERROR )
 363     {
 364         wxLogLastError(wxT("StretchDIBits"));
 365
 366         return false;
 367     }
 368
 369     return true;
 370 #else
 371     return false;
 372 #endif
 373 }
 374
 375 void wxPrinterDC::DoDrawBitmap(const wxBitmap& bmp,
 376                                wxCoord x, wxCoord y,
 377                                bool useMask)
 378 {
 379     wxCHECK_RET( bmp.Ok(), _T("invalid bitmap in wxPrinterDC::DrawBitmap") );
 380
 381     int width = bmp.GetWidth(),
 382         height = bmp.GetHeight();
 383
 384     if ( !(::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHDIB) ||
 385             !DrawBitmapUsingStretchDIBits(GetHdc(), bmp, x, y) )
 386     {
 387         // no support for StretchDIBits() or an error occurred if we got here
 388         wxMemoryDC memDC;
 389         memDC.SelectObject(bmp);
 390
 391         Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
 392
 393         memDC.SelectObject(wxNullBitmap);
 394     }
 395 }
 396
 397 bool wxPrinterDC::DoBlit(wxCoord xdest, wxCoord ydest,
 398                          wxCoord width, wxCoord height,
 399                          wxDC *source,
 400                          wxCoord WXUNUSED(xsrc), wxCoord WXUNUSED(ysrc),
 401                          int WXUNUSED(rop), bool useMask,
 402                          wxCoord WXUNUSED(xsrcMask), wxCoord WXUNUSED(ysrcMask))
 403 {
 404     wxBitmap& bmp = source->GetSelectedBitmap();
 405     wxMask *mask = useMask ? bmp.GetMask() : NULL;
 406     if ( mask )
 407     {
 408         // If we are printing source colours are screen colours not printer
 409         // colours and so we need copy the bitmap pixel by pixel.
 410         RECT rect;
 411         HDC dcSrc = GetHdcOf(*source);
 412         MemoryHDC dcMask(dcSrc);
 413         SelectInHDC selectMask(dcMask, (HBITMAP)mask->GetMaskBitmap());
 414
 415         for (int x = 0; x < width; x++)
 416         {
 417             for (int y = 0; y < height; y++)
 418             {
 419                 COLORREF cref = ::GetPixel(dcMask, x, y);
 420                 if (cref)
 421                 {
 422                     HBRUSH brush = ::CreateSolidBrush(::GetPixel(dcSrc, x, y));
 423                     rect.left = xdest + x;
 424                     rect.right = rect.left + 1;
 425                     rect.top = ydest + y;
 426                     rect.bottom = rect.top + 1;
 427                     ::FillRect(GetHdc(), &rect, brush);
 428                     ::DeleteObject(brush);
 429                 }
 430             }
 431         }
 432     }
 433     else // no mask
 434     {
 435         if ( !(::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHDIB) ||
 436                 !DrawBitmapUsingStretchDIBits(GetHdc(), bmp, xdest, ydest) )
 437         {
 438             // no support for StretchDIBits
 439
 440             // as we are printing, source colours are screen colours not
 441             // printer colours and so we need copy the bitmap pixel by pixel.
 442             HDC dcSrc = GetHdcOf(*source);
 443             RECT rect;
 444             for (int y = 0; y < height; y++)
 445             {
 446                 // optimization: draw identical adjacent pixels together.
 447                 for (int x = 0; x < width; x++)
 448                 {
 449                     COLORREF col = ::GetPixel(dcSrc, x, y);
 450                     HBRUSH brush = ::CreateSolidBrush( col );
 451
 452                     rect.left = xdest + x;
 453                     rect.top = ydest + y;
 454                     while( (x + 1 < width) &&
 455                                 (::GetPixel(dcSrc, x + 1, y) == col ) )
 456                     {
 457                         ++x;
 458                     }
 459                     rect.right = xdest + x + 1;
 460                     rect.bottom = rect.top + 1;
 461                     ::FillRect((HDC) m_hDC, &rect, brush);
 462                     ::DeleteObject(brush);
 463                 }
 464             }
 465         }
 466     }
 467
 468     return true;
 469 }
 470
 471 #endif
 472     // wxUSE_PRINTING_ARCHITECTURE