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