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