check that the version of __sync_sub_and_fetch that returns a value is supported...

[wxWidgets.git] / src / msw / dcprint.cpp

diff --git a/src/msw/dcprint.cpp b/src/msw/dcprint.cpp
index 1d6fad9051afee00d2d09aee9ec8daf110b5c232..628e6e81b2217364fed0c46add04d756739c6603 100644 (file)
--- a/src/msw/dcprint.cpp
+++ b/src/msw/dcprint.cpp
@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "dcprint.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -28,27 +24,28 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

+#if wxUSE_PRINTING_ARCHITECTURE
+
+#include "wx/dcprint.h"
+#include "wx/msw/dcprint.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

+    #include "wx/msw/wrapcdlg.h"

     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/window.h"
     #include "wx/dcmemory.h"
     #include "wx/string.h"
     #include "wx/log.h"
     #include "wx/window.h"
     #include "wx/dcmemory.h"

+    #include "wx/math.h"

 #endif
 
 #endif
 

-#if wxUSE_PRINTING_ARCHITECTURE
-

 #include "wx/msw/private.h"
 
 #if wxUSE_WXDIB
 #include "wx/msw/private.h"
 
 #if wxUSE_WXDIB

-#include "wx/msw/dib.h"
+    #include "wx/msw/dib.h"

 #endif
 
 #endif
 

-#include "wx/dcprint.h"
-#include "math.h"
-
-#if wxUSE_COMMON_DIALOGS
-    #include <commdlg.h>
-#endif
+#include "wx/printdlg.h"
+#include "wx/msw/printdlg.h"

 
 #ifndef __WIN32__
     #include <print.h>
 
 #ifndef __WIN32__
     #include <print.h>


@@ -60,11 +57,17 @@
     #define GDI_ERROR ((int)-1)
 #endif
 
     #define GDI_ERROR ((int)-1)
 #endif
 

+#if defined(__WXUNIVERSAL__) && wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW
+    #define wxUSE_PS_PRINTING 1
+#else
+    #define wxUSE_PS_PRINTING 0
+#endif
+

 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_CLASS(wxPrinterDC, wxDC)
+IMPLEMENT_ABSTRACT_CLASS(wxPrinterDCImpl, wxMSWDCImpl)

 
 // ============================================================================
 // implementation
 
 // ============================================================================
 // implementation


@@ -74,6 +77,7 @@ IMPLEMENT_CLASS(wxPrinterDC, wxDC)
 // wxPrinterDC construction
 // ----------------------------------------------------------------------------
 
 // wxPrinterDC construction
 // ----------------------------------------------------------------------------
 

+#if 0

 // This form is deprecated
 wxPrinterDC::wxPrinterDC(const wxString& driver_name,
                          const wxString& device_name,
 // This form is deprecated
 wxPrinterDC::wxPrinterDC(const wxString& driver_name,
                          const wxString& device_name,


@@ -114,7 +118,10 @@ wxPrinterDC::wxPrinterDC(const wxString& driver_name,
     {
         if ( !driver_name.empty() && !device_name.empty() && !file.empty() )
         {
     {
         if ( !driver_name.empty() && !device_name.empty() && !file.empty() )
         {

-            m_hDC = (WXHDC) CreateDC(driver_name, device_name, file, NULL);
+            m_hDC = (WXHDC) CreateDC(driver_name.wx_str(),
+                                     device_name.wx_str(),
+                                     file.fn_str(),
+                                     NULL);

         }
         else // we don't have all parameters, ask the user
         {
         }
         else // we don't have all parameters, ask the user
         {


@@ -123,39 +130,42 @@ wxPrinterDC::wxPrinterDC(const wxString& driver_name,
             m_hDC = wxGetPrinterDC(printData);
         }
 
             m_hDC = wxGetPrinterDC(printData);
         }
 

-        m_ok = m_hDC ? TRUE: FALSE;
+        m_ok = m_hDC ? true: false;

 
         // as we created it, we must delete it as well
 
         // as we created it, we must delete it as well

-        m_bOwnsDC = TRUE;
+        m_bOwnsDC = true;

     }
 
     Init();
 }
     }
 
     Init();
 }

+#endif

 
 

-wxPrinterDC::wxPrinterDC(const wxPrintData& printData)
+wxPrinterDCImpl::wxPrinterDCImpl( wxPrinterDC *owner, const wxPrintData& printData ) :
+    wxMSWDCImpl( owner )

 {
     m_printData = printData;
 
 {
     m_printData = printData;
 

-    m_isInteractive = FALSE;
+    m_isInteractive = false;

 
     m_hDC = wxGetPrinterDC(printData);
     m_ok = m_hDC != 0;
 
     m_hDC = wxGetPrinterDC(printData);
     m_ok = m_hDC != 0;

-    m_bOwnsDC = TRUE;
+    m_bOwnsDC = true;

 
     Init();
 }
 
 
 
     Init();
 }
 
 

-wxPrinterDC::wxPrinterDC(WXHDC dc)
+wxPrinterDCImpl::wxPrinterDCImpl( wxPrinterDC *owner, WXHDC dc ) :
+    wxMSWDCImpl( owner )

 {
 {

-    m_isInteractive = FALSE;
+    m_isInteractive = false;

 
     m_hDC = dc;
 
     m_hDC = dc;

-    m_bOwnsDC = TRUE;
-    m_ok = TRUE;
+    m_bOwnsDC = true;
+    m_ok = true;

 }
 
 }
 

-void wxPrinterDC::Init()
+void wxPrinterDCImpl::Init()

 {
     if ( m_hDC )
     {
 {
     if ( m_hDC )
     {


@@ -169,67 +179,75 @@ void wxPrinterDC::Init()
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxPrinterDC {Start/End}{Page/Doc} methods
+// wxPrinterDCImpl {Start/End}{Page/Doc} methods

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-bool wxPrinterDC::StartDoc(const wxString& message)
+bool wxPrinterDCImpl::StartDoc(const wxString& message)

 {
     DOCINFO docinfo;
     docinfo.cbSize = sizeof(DOCINFO);
 {
     DOCINFO docinfo;
     docinfo.cbSize = sizeof(DOCINFO);

-    docinfo.lpszDocName = (const wxChar*)message;
+    docinfo.lpszDocName = message.wx_str();

 
     wxString filename(m_printData.GetFilename());
 
 
     wxString filename(m_printData.GetFilename());
 

-    if (filename.IsEmpty())
+    if (filename.empty())

         docinfo.lpszOutput = NULL;
     else
         docinfo.lpszOutput = NULL;
     else

-        docinfo.lpszOutput = (const wxChar *) filename;
+        docinfo.lpszOutput = filename.wx_str();

 
 

-#if defined(__WIN95__)

     docinfo.lpszDatatype = NULL;
     docinfo.fwType = 0;
     docinfo.lpszDatatype = NULL;
     docinfo.fwType = 0;

-#endif

 
     if (!m_hDC)
 
     if (!m_hDC)

-        return FALSE;
+        return false;

 
 

-    int ret = ::StartDoc(GetHdc(), &docinfo);
-
-#ifndef __WIN16__
-    if (ret <= 0)
+    if ( ::StartDoc(GetHdc(), &docinfo) <= 0 )

     {
     {

-        DWORD lastError = GetLastError();
-        wxLogDebug(wxT("wxDC::StartDoc failed with error: %ld\n"), lastError);
+        wxLogLastError(wxT("StartDoc"));
+        return false;

     }
     }

-#endif

 
 

-    return (ret > 0);
+    return true;

 }
 
 }
 

-void wxPrinterDC::EndDoc()
+void wxPrinterDCImpl::EndDoc()

 {
     if (m_hDC) ::EndDoc((HDC) m_hDC);
 }
 
 {
     if (m_hDC) ::EndDoc((HDC) m_hDC);
 }
 

-void wxPrinterDC::StartPage()
+void wxPrinterDCImpl::StartPage()

 {
     if (m_hDC)
         ::StartPage((HDC) m_hDC);
 }
 
 {
     if (m_hDC)
         ::StartPage((HDC) m_hDC);
 }
 

-void wxPrinterDC::EndPage()
+void wxPrinterDCImpl::EndPage()

 {
     if (m_hDC)
         ::EndPage((HDC) m_hDC);
 }
 
 {
     if (m_hDC)
         ::EndPage((HDC) m_hDC);
 }
 

+
+wxRect wxPrinterDCImpl::GetPaperRect()
+
+{
+    if (!IsOk()) return wxRect(0, 0, 0, 0);
+    int w = ::GetDeviceCaps((HDC) m_hDC, PHYSICALWIDTH);
+    int h = ::GetDeviceCaps((HDC) m_hDC, PHYSICALHEIGHT);
+    int x = -::GetDeviceCaps((HDC) m_hDC, PHYSICALOFFSETX);
+    int y = -::GetDeviceCaps((HDC) m_hDC, PHYSICALOFFSETY);
+    return wxRect(x, y, w, h);
+}
+
+
+#if !wxUSE_PS_PRINTING
+

 // Returns default device and port names
 static bool wxGetDefaultDeviceName(wxString& deviceName, wxString& portName)
 {
     deviceName.clear();
 
     LPDEVNAMES  lpDevNames;
 // Returns default device and port names
 static bool wxGetDefaultDeviceName(wxString& deviceName, wxString& portName)
 {
     deviceName.clear();
 
     LPDEVNAMES  lpDevNames;

-    LPTSTR      lpszDriverName;

     LPTSTR      lpszDeviceName;
     LPTSTR      lpszPortName;
 
     LPTSTR      lpszDeviceName;
     LPTSTR      lpszPortName;
 


@@ -257,13 +275,12 @@ static bool wxGetDefaultDeviceName(wxString& deviceName, wxString& portName)
         if (pd.hDevNames)
             GlobalFree(pd.hDevNames);
 
         if (pd.hDevNames)
             GlobalFree(pd.hDevNames);
 

-        return FALSE;
+        return false;

     }
 
     if (pd.hDevNames)
     {
         lpDevNames = (LPDEVNAMES)GlobalLock(pd.hDevNames);
     }
 
     if (pd.hDevNames)
     {
         lpDevNames = (LPDEVNAMES)GlobalLock(pd.hDevNames);

-        lpszDriverName = (LPTSTR)lpDevNames + lpDevNames->wDriverOffset;

         lpszDeviceName = (LPTSTR)lpDevNames + lpDevNames->wDeviceOffset;
         lpszPortName   = (LPTSTR)lpDevNames + lpDevNames->wOutputOffset;
 
         lpszDeviceName = (LPTSTR)lpDevNames + lpDevNames->wDeviceOffset;
         lpszPortName   = (LPTSTR)lpDevNames + lpDevNames->wOutputOffset;
 


@@ -280,63 +297,53 @@ static bool wxGetDefaultDeviceName(wxString& deviceName, wxString& portName)
         GlobalFree(pd.hDevMode);
         pd.hDevMode=NULL;
     }
         GlobalFree(pd.hDevMode);
         pd.hDevMode=NULL;
     }

-    return ( deviceName != wxEmptyString );
+    return ( !deviceName.empty() );

 }
 
 }
 

+#endif // !wxUSE_PS_PRINTING
+

 // Gets an HDC for the specified printer configuration
 WXHDC WXDLLEXPORT wxGetPrinterDC(const wxPrintData& printDataConst)
 {
 // Gets an HDC for the specified printer configuration
 WXHDC WXDLLEXPORT wxGetPrinterDC(const wxPrintData& printDataConst)
 {

-    wxPrintData printData = printDataConst;
-    printData.ConvertToNative();
-
-    wxChar* driverName = (wxChar*) NULL;
-
-    wxString devNameStr = printData.GetPrinterName();
-    wxChar* portName = (wxChar*) NULL; // Obsolete in WIN32
-
-    const wxChar* deviceName;
-    if ( !devNameStr )
-        deviceName = (wxChar*) NULL;
-    else
-        deviceName = devNameStr.c_str();
-
-    LPDEVMODE lpDevMode = (LPDEVMODE) NULL;
-
-    HGLOBAL hDevMode = (HGLOBAL)(DWORD) printData.GetNativeData();
-
-    if ( hDevMode )
-        lpDevMode = (DEVMODE*) GlobalLock(hDevMode);
-
-    if ( !devNameStr )
+#if wxUSE_PS_PRINTING
+    // TODO
+    wxUnusedVar(printDataConst);
+    return 0;
+#else // native Windows printing
+    wxWindowsPrintNativeData *data =
+        (wxWindowsPrintNativeData *) printDataConst.GetNativeData();
+
+    data->TransferFrom( printDataConst );
+
+    wxString deviceName = printDataConst.GetPrinterName();
+    if ( deviceName.empty() )

     {
         // Retrieve the default device name
         wxString portName;
     {
         // Retrieve the default device name
         wxString portName;

-#ifdef  __WXDEBUG__
-        bool ret =
-#else   // !Debug
-        (void)
-#endif // Debug/Release
-        wxGetDefaultDeviceName(devNameStr, portName);
+        if ( !wxGetDefaultDeviceName(deviceName, portName) )
+        {
+            return 0; // Could not get default device name
+        }
+    }

 
 

-        wxASSERT_MSG( ret, wxT("Could not get default device name.") );

 
 

-        deviceName = devNameStr.c_str();
-    }
+    HGLOBAL hDevMode = (HGLOBAL)(DWORD) data->GetDevMode();

 
 

-#ifdef __WIN32__
-    HDC hDC = CreateDC(driverName, deviceName, portName, (DEVMODE *) lpDevMode);
-#else
-    HDC hDC = CreateDC(driverName, deviceName, portName, (LPSTR) lpDevMode);
-#endif
+    DEVMODE *lpDevMode = hDevMode ? (DEVMODE *)::GlobalLock(hDevMode) : NULL;
+
+    HDC hDC = ::CreateDC(NULL, deviceName.wx_str(), NULL, lpDevMode);
+    if ( !hDC )
+        wxLogLastError(_T("CreateDC(printer)"));

 
 

-    if (hDevMode && lpDevMode)
-        GlobalUnlock(hDevMode);
+    if ( lpDevMode )
+        ::GlobalUnlock(hDevMode);

 
     return (WXHDC) hDC;
 
     return (WXHDC) hDC;

+#endif // PostScript/Windows printing

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// wxPrinterDC bit blitting/bitmap drawing
+// wxPrinterDCImpl bit blitting/bitmap drawing

 // ----------------------------------------------------------------------------
 
 // helper of DoDrawBitmap() and DoBlit()
 // ----------------------------------------------------------------------------
 
 // helper of DoDrawBitmap() and DoBlit()


@@ -347,15 +354,16 @@ bool DrawBitmapUsingStretchDIBits(HDC hdc,
 {
 #if wxUSE_WXDIB
     wxDIB dib(bmp);
 {
 #if wxUSE_WXDIB
     wxDIB dib(bmp);

-    if ( !dib.IsOk() )
-        return FALSE;
+    bool ok = dib.IsOk();
+    if ( !ok )
+        return false;

 
     DIBSECTION ds;
     if ( !::GetObject(dib.GetHandle(), sizeof(ds), &ds) )
     {
         wxLogLastError(_T("GetObject(DIBSECTION)"));
 
 
     DIBSECTION ds;
     if ( !::GetObject(dib.GetHandle(), sizeof(ds), &ds) )
     {
         wxLogLastError(_T("GetObject(DIBSECTION)"));
 

-        return FALSE;
+        return false;

     }
 
     // ok, we've got all data we need, do blit it
     }
 
     // ok, we've got all data we need, do blit it


@@ -374,16 +382,16 @@ bool DrawBitmapUsingStretchDIBits(HDC hdc,
     {
         wxLogLastError(wxT("StretchDIBits"));
 
     {
         wxLogLastError(wxT("StretchDIBits"));
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 #else
 #else

-    return FALSE;
+    return false;

 #endif
 }
 
 #endif
 }
 

-void wxPrinterDC::DoDrawBitmap(const wxBitmap& bmp,
+void wxPrinterDCImpl::DoDrawBitmap(const wxBitmap& bmp,

                                wxCoord x, wxCoord y,
                                bool useMask)
 {
                                wxCoord x, wxCoord y,
                                bool useMask)
 {


@@ -395,31 +403,37 @@ void wxPrinterDC::DoDrawBitmap(const wxBitmap& bmp,
     if ( !(::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHDIB) ||
             !DrawBitmapUsingStretchDIBits(GetHdc(), bmp, x, y) )
     {
     if ( !(::GetDeviceCaps(GetHdc(), RASTERCAPS) & RC_STRETCHDIB) ||
             !DrawBitmapUsingStretchDIBits(GetHdc(), bmp, x, y) )
     {

-        // no support for StretchDIBits() or an error occured if we got here
+        // no support for StretchDIBits() or an error occurred if we got here

         wxMemoryDC memDC;
         wxMemoryDC memDC;

-        memDC.SelectObject(bmp);

 
 

-        Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);
+        memDC.SelectObjectAsSource(bmp);
+
+        GetOwner()->Blit(x, y, width, height, &memDC, 0, 0, wxCOPY, useMask);

 
         memDC.SelectObject(wxNullBitmap);
     }
 }
 
 
         memDC.SelectObject(wxNullBitmap);
     }
 }
 

-bool wxPrinterDC::DoBlit(wxCoord xdest, wxCoord ydest,
+bool wxPrinterDCImpl::DoBlit(wxCoord xdest, wxCoord ydest,

                          wxCoord width, wxCoord height,
                          wxDC *source,
                          wxCoord WXUNUSED(xsrc), wxCoord WXUNUSED(ysrc),
                          int WXUNUSED(rop), bool useMask,
                          wxCoord WXUNUSED(xsrcMask), wxCoord WXUNUSED(ysrcMask))
 {
                          wxCoord width, wxCoord height,
                          wxDC *source,
                          wxCoord WXUNUSED(xsrc), wxCoord WXUNUSED(ysrc),
                          int WXUNUSED(rop), bool useMask,
                          wxCoord WXUNUSED(xsrcMask), wxCoord WXUNUSED(ysrcMask))
 {

-    wxBitmap& bmp = source->GetSelectedBitmap();
+    wxDCImpl *impl = source->GetImpl();
+    wxMSWDCImpl *msw_impl = wxDynamicCast(impl, wxMSWDCImpl);
+    if (!msw_impl)
+        return false;
+
+    wxBitmap& bmp = msw_impl->GetSelectedBitmap();

     wxMask *mask = useMask ? bmp.GetMask() : NULL;
     if ( mask )
     {
         // If we are printing source colours are screen colours not printer
         // colours and so we need copy the bitmap pixel by pixel.
         RECT rect;
     wxMask *mask = useMask ? bmp.GetMask() : NULL;
     if ( mask )
     {
         // If we are printing source colours are screen colours not printer
         // colours and so we need copy the bitmap pixel by pixel.
         RECT rect;

-        HDC dcSrc = GetHdcOf(*source);
+        HDC dcSrc = GetHdcOf(*msw_impl);

         MemoryHDC dcMask(dcSrc);
         SelectInHDC selectMask(dcMask, (HBITMAP)mask->GetMaskBitmap());
 
         MemoryHDC dcMask(dcSrc);
         SelectInHDC selectMask(dcMask, (HBITMAP)mask->GetMaskBitmap());
 


@@ -450,7 +464,7 @@ bool wxPrinterDC::DoBlit(wxCoord xdest, wxCoord ydest,
 
             // as we are printing, source colours are screen colours not
             // printer colours and so we need copy the bitmap pixel by pixel.
 
             // as we are printing, source colours are screen colours not
             // printer colours and so we need copy the bitmap pixel by pixel.

-            HDC dcSrc = GetHdcOf(*source);
+            HDC dcSrc = GetHdcOf(*msw_impl);

             RECT rect;
             for (int y = 0; y < height; y++)
             {
             RECT rect;
             for (int y = 0; y < height; y++)
             {


@@ -476,7 +490,7 @@ bool wxPrinterDC::DoBlit(wxCoord xdest, wxCoord ydest,
         }
     }
 
         }
     }
 

-    return TRUE;
+    return true;

 }
 
 #endif
 }
 
 #endif