Several corrections to wxDocManager fields documentation.

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

diff --git a/src/msw/enhmeta.cpp b/src/msw/enhmeta.cpp
index 73c04b84dbb8952556b26213f9afc97357067b69..5249f46ff49816be0867961ae6fadbf9a65f2581 100644 (file)
--- a/src/msw/enhmeta.cpp
+++ b/src/msw/enhmeta.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        msw/enhmeta.cpp
+// Name:        src/msw/enhmeta.cpp

 // Purpose:     implementation of wxEnhMetaFileXXX classes
 // Author:      Vadim Zeitlin
 // Modified by:
 // Purpose:     implementation of wxEnhMetaFileXXX classes
 // Author:      Vadim Zeitlin
 // Modified by:


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "enhmeta.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"
 


@@ -33,8 +29,12 @@
 #ifndef WX_PRECOMP
     #include "wx/string.h"
     #include "wx/log.h"
 #ifndef WX_PRECOMP
     #include "wx/string.h"
     #include "wx/log.h"

+    #include "wx/intl.h"

 #endif //WX_PRECOMP
 
 #endif //WX_PRECOMP
 

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

 #include "wx/metafile.h"
 #include "wx/clipbrd.h"
 
 #include "wx/metafile.h"
 #include "wx/clipbrd.h"
 


@@ -45,7 +45,6 @@
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxEnhMetaFile, wxObject)
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxEnhMetaFile, wxObject)

-IMPLEMENT_ABSTRACT_CLASS(wxEnhMetaFileDC, wxDC)

 
 // ----------------------------------------------------------------------------
 // macros
 
 // ----------------------------------------------------------------------------
 // macros


@@ -60,7 +59,7 @@ IMPLEMENT_ABSTRACT_CLASS(wxEnhMetaFileDC, wxDC)
 
 // we must pass NULL if the string is empty to metafile functions
 static inline const wxChar *GetMetaFileName(const wxString& fn)
 
 // we must pass NULL if the string is empty to metafile functions
 static inline const wxChar *GetMetaFileName(const wxString& fn)

-    { return !fn ? (wxChar *)NULL : fn.c_str(); }
+    { return !fn ? (const wxChar *)NULL : (const wxChar*)fn.wx_str(); }

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


@@ -70,6 +69,38 @@ static inline const wxChar *GetMetaFileName(const wxString& fn)
 // wxEnhMetaFile
 // ----------------------------------------------------------------------------
 
 // wxEnhMetaFile
 // ----------------------------------------------------------------------------
 

+wxGDIRefData *wxEnhMetaFile::CreateGDIRefData() const
+{
+    wxFAIL_MSG( wxT("must be implemented if used") );
+
+    return NULL;
+}
+
+wxGDIRefData *
+wxEnhMetaFile::CloneGDIRefData(const wxGDIRefData *WXUNUSED(data)) const
+{
+    wxFAIL_MSG( wxT("must be implemented if used") );
+
+    return NULL;
+}
+
+void wxEnhMetaFile::Init()
+{
+    if ( m_filename.empty() )
+    {
+        m_hMF = 0;
+    }
+    else // have valid file name, load metafile from it
+    {
+        m_hMF = (WXHANDLE)::GetEnhMetaFile(m_filename.t_str());
+        if ( !m_hMF )
+        {
+            wxLogSysError(_("Failed to load metafile from file \"%s\"."),
+                          m_filename.c_str());
+        }
+    }
+}
+

 void wxEnhMetaFile::Assign(const wxEnhMetaFile& mf)
 {
     if ( &mf == this )
 void wxEnhMetaFile::Assign(const wxEnhMetaFile& mf)
 {
     if ( &mf == this )


@@ -81,7 +112,7 @@ void wxEnhMetaFile::Assign(const wxEnhMetaFile& mf)
                                             GetMetaFileName(m_filename));
         if ( !m_hMF )
         {
                                             GetMetaFileName(m_filename));
         if ( !m_hMF )
         {

-            wxLogLastError(_T("CopyEnhMetaFile"));
+            wxLogLastError(wxT("CopyEnhMetaFile"));

         }
     }
     else
         }
     }
     else


@@ -96,15 +127,15 @@ void wxEnhMetaFile::Free()
     {
         if ( !::DeleteEnhMetaFile(GetEMF()) )
         {
     {
         if ( !::DeleteEnhMetaFile(GetEMF()) )
         {

-            wxLogLastError(_T("DeleteEnhMetaFile"));
+            wxLogLastError(wxT("DeleteEnhMetaFile"));

         }
     }
 }
 
 bool wxEnhMetaFile::Play(wxDC *dc, wxRect *rectBound)
 {
         }
     }
 }
 
 bool wxEnhMetaFile::Play(wxDC *dc, wxRect *rectBound)
 {

-    wxCHECK_MSG( Ok(), FALSE, _T("can't play invalid enhanced metafile") );
-    wxCHECK_MSG( dc, FALSE, _T("invalid wxDC in wxEnhMetaFile::Play") );
+    wxCHECK_MSG( IsOk(), false, wxT("can't play invalid enhanced metafile") );
+    wxCHECK_MSG( dc, false, wxT("invalid wxDC in wxEnhMetaFile::Play") );

 
     RECT rect;
     if ( rectBound )
 
     RECT rect;
     if ( rectBound )


@@ -124,26 +155,31 @@ bool wxEnhMetaFile::Play(wxDC *dc, wxRect *rectBound)
         rect.bottom = size.y;
     }
 
         rect.bottom = size.y;
     }
 

-    if ( !::PlayEnhMetaFile(GetHdcOf(*dc), GetEMF(), &rect) )
+    wxDCImpl *impl = dc->GetImpl();
+    wxMSWDCImpl *msw_impl = wxDynamicCast( impl, wxMSWDCImpl );
+    if (!msw_impl)
+        return false;
+
+    if ( !::PlayEnhMetaFile(GetHdcOf(*msw_impl), GetEMF(), &rect) )

     {
     {

-        wxLogLastError(_T("PlayEnhMetaFile"));
+        wxLogLastError(wxT("PlayEnhMetaFile"));

 
 

-        return FALSE;
+        return false;

     }
 
     }
 

-    return TRUE;
+    return true;

 }
 
 wxSize wxEnhMetaFile::GetSize() const
 {
     wxSize size = wxDefaultSize;
 
 }
 
 wxSize wxEnhMetaFile::GetSize() const
 {
     wxSize size = wxDefaultSize;
 

-    if ( Ok() )
+    if ( IsOk() )

     {
         ENHMETAHEADER hdr;
         if ( !::GetEnhMetaFileHeader(GetEMF(), sizeof(hdr), &hdr) )
         {
     {
         ENHMETAHEADER hdr;
         if ( !::GetEnhMetaFileHeader(GetEMF(), sizeof(hdr), &hdr) )
         {

-            wxLogLastError(_T("GetEnhMetaFileHeader"));
+            wxLogLastError(wxT("GetEnhMetaFileHeader"));

         }
         else
         {
         }
         else
         {


@@ -164,27 +200,78 @@ wxSize wxEnhMetaFile::GetSize() const
 
 bool wxEnhMetaFile::SetClipboard(int WXUNUSED(width), int WXUNUSED(height))
 {
 
 bool wxEnhMetaFile::SetClipboard(int WXUNUSED(width), int WXUNUSED(height))
 {

-#if wxUSE_DRAG_AND_DROP
-    wxCHECK_MSG( m_hMF, FALSE, _T("can't copy invalid metafile to clipboard") );
+#if wxUSE_DRAG_AND_DROP && wxUSE_CLIPBOARD
+    wxCHECK_MSG( m_hMF, false, wxT("can't copy invalid metafile to clipboard") );

 
     return wxTheClipboard->AddData(new wxEnhMetaFileDataObject(*this));
 #else // !wxUSE_DRAG_AND_DROP
 
     return wxTheClipboard->AddData(new wxEnhMetaFileDataObject(*this));
 #else // !wxUSE_DRAG_AND_DROP

-    wxFAIL_MSG(_T("not implemented"));
-    return FALSE;
+    wxFAIL_MSG(wxT("not implemented"));
+    return false;

 #endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
 }
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
 }
 
 // ----------------------------------------------------------------------------

-// wxEnhMetaFileDC
+// wxEnhMetaFileDCImpl

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

-wxEnhMetaFileDC::wxEnhMetaFileDC(const wxString& filename,
+class wxEnhMetaFileDCImpl : public wxMSWDCImpl
+{
+public:
+    wxEnhMetaFileDCImpl( wxEnhMetaFileDC *owner,
+                         const wxString& filename, int width, int height,
+                         const wxString& description );
+    wxEnhMetaFileDCImpl( wxEnhMetaFileDC *owner,
+                         const wxDC& referenceDC,
+                         const wxString& filename, int width, int height,
+                         const wxString& description );
+    virtual ~wxEnhMetaFileDCImpl();
+
+    // obtain a pointer to the new metafile (caller should delete it)
+    wxEnhMetaFile *Close();
+
+protected:
+    virtual void DoGetSize(int *width, int *height) const;
+
+private:
+    void Create(HDC hdcRef,
+                const wxString& filename, int width, int height,
+                const wxString& description);
+
+    // size passed to ctor and returned by DoGetSize()
+    int m_width,
+        m_height;
+};
+
+
+wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,
+                                 const wxString& filename,
+                                 int width, int height,
+                                 const wxString& description )
+                   : wxMSWDCImpl( owner )
+{
+    Create(ScreenHDC(), filename, width, height, description);
+}
+
+wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,
+                                 const wxDC& referenceDC,
+                                 const wxString& filename,
+                                 int width, int height,
+                                 const wxString& description )
+                   : wxMSWDCImpl( owner )
+{
+    Create(GetHdcOf(referenceDC), filename, width, height, description);
+}
+
+void wxEnhMetaFileDCImpl::Create(HDC hdcRef,
+                                 const wxString& filename,

                                  int width, int height,
                                  const wxString& description)
 {
                                  int width, int height,
                                  const wxString& description)
 {

-    ScreenHDC hdcRef;
+    m_width = width;
+    m_height = height;
+

     RECT rect;
     RECT rect;

-       RECT *pRect;
+    RECT *pRect;

     if ( width && height )
     {
         rect.top =
     if ( width && height )
     {
         rect.top =


@@ -193,8 +280,8 @@ wxEnhMetaFileDC::wxEnhMetaFileDC(const wxString& filename,
         rect.bottom = height;
 
         // CreateEnhMetaFile() wants them in HIMETRIC
         rect.bottom = height;
 
         // CreateEnhMetaFile() wants them in HIMETRIC

-        PixelToHIMETRIC(&rect.right, &rect.bottom);
-        
+        PixelToHIMETRIC(&rect.right, &rect.bottom, hdcRef);
+

         pRect = ▭
     }
     else
         pRect = ▭
     }
     else


@@ -204,21 +291,29 @@ wxEnhMetaFileDC::wxEnhMetaFileDC(const wxString& filename,
     }
 
     m_hDC = (WXHDC)::CreateEnhMetaFile(hdcRef, GetMetaFileName(filename),
     }
 
     m_hDC = (WXHDC)::CreateEnhMetaFile(hdcRef, GetMetaFileName(filename),

-                                       pRect, description);
+                                       pRect, description.wx_str());

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

-        wxLogLastError(_T("CreateEnhMetaFile"));
+        wxLogLastError(wxT("CreateEnhMetaFile"));

     }
 }
 
     }
 }
 

-wxEnhMetaFile *wxEnhMetaFileDC::Close()
+void wxEnhMetaFileDCImpl::DoGetSize(int *width, int *height) const
+{
+    if ( width )
+        *width = m_width;
+    if ( height )
+        *height = m_height;
+}
+
+wxEnhMetaFile *wxEnhMetaFileDCImpl::Close()

 {
 {

-    wxCHECK_MSG( Ok(), NULL, _T("invalid wxEnhMetaFileDC") );
+    wxCHECK_MSG( IsOk(), NULL, wxT("invalid wxEnhMetaFileDC") );

 
     HENHMETAFILE hMF = ::CloseEnhMetaFile(GetHdc());
     if ( !hMF )
     {
 
     HENHMETAFILE hMF = ::CloseEnhMetaFile(GetHdc());
     if ( !hMF )
     {

-        wxLogLastError(_T("CloseEnhMetaFile"));
+        wxLogLastError(wxT("CloseEnhMetaFile"));

 
         return NULL;
     }
 
         return NULL;
     }


@@ -228,12 +323,49 @@ wxEnhMetaFile *wxEnhMetaFileDC::Close()
     return mf;
 }
 
     return mf;
 }
 

-wxEnhMetaFileDC::~wxEnhMetaFileDC()
+wxEnhMetaFileDCImpl::~wxEnhMetaFileDCImpl()

 {
     // avoid freeing it in the base class dtor
     m_hDC = 0;
 }
 
 {
     // avoid freeing it in the base class dtor
     m_hDC = 0;
 }
 

+// ----------------------------------------------------------------------------
+// wxEnhMetaFileDC
+// ----------------------------------------------------------------------------
+
+IMPLEMENT_ABSTRACT_CLASS(wxEnhMetaFileDC, wxDC)
+
+wxEnhMetaFileDC::wxEnhMetaFileDC(const wxString& filename,
+                                 int width, int height,
+                                 const wxString& description)
+               : wxDC(new wxEnhMetaFileDCImpl(this,
+                                              filename,
+                                              width, height,
+                                              description))
+{
+}
+
+wxEnhMetaFileDC::wxEnhMetaFileDC(const wxDC& referenceDC,
+                                 const wxString& filename,
+                                 int width, int height,
+                                 const wxString& description)
+               : wxDC(new wxEnhMetaFileDCImpl(this,
+                                              referenceDC,
+                                              filename,
+                                              width, height,
+                                              description))
+{
+}
+
+wxEnhMetaFile *wxEnhMetaFileDC::Close()
+{
+    wxEnhMetaFileDCImpl * const
+        impl = static_cast<wxEnhMetaFileDCImpl *>(GetImpl());
+    wxCHECK_MSG( impl, NULL, wxT("no wxEnhMetaFileDC implementation") );
+
+    return impl->Close();
+}
+

 #if wxUSE_DRAG_AND_DROP
 
 // ----------------------------------------------------------------------------
 #if wxUSE_DRAG_AND_DROP
 
 // ----------------------------------------------------------------------------


@@ -268,7 +400,7 @@ size_t wxEnhMetaFileDataObject::GetDataSize(const wxDataFormat& format) const
     }
     else
     {
     }
     else
     {

-        wxASSERT_MSG( format == wxDF_METAFILE, _T("unsupported format") );
+        wxASSERT_MSG( format == wxDF_METAFILE, wxT("unsupported format") );

 
         return sizeof(METAFILEPICT);
     }
 
         return sizeof(METAFILEPICT);
     }


@@ -276,7 +408,7 @@ size_t wxEnhMetaFileDataObject::GetDataSize(const wxDataFormat& format) const
 
 bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf) const
 {
 
 bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf) const
 {

-    wxCHECK_MSG( m_metafile.Ok(), FALSE, _T("copying invalid enh metafile") );
+    wxCHECK_MSG( m_metafile.IsOk(), false, wxT("copying invalid enh metafile") );

 
     HENHMETAFILE hEMF = (HENHMETAFILE)m_metafile.GetHENHMETAFILE();
 
 
     HENHMETAFILE hEMF = (HENHMETAFILE)m_metafile.GetHENHMETAFILE();
 


@@ -285,16 +417,16 @@ bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf)
         HENHMETAFILE hEMFCopy = ::CopyEnhMetaFile(hEMF, NULL);
         if ( !hEMFCopy )
         {
         HENHMETAFILE hEMFCopy = ::CopyEnhMetaFile(hEMF, NULL);
         if ( !hEMFCopy )
         {

-            wxLogLastError(_T("CopyEnhMetaFile"));
+            wxLogLastError(wxT("CopyEnhMetaFile"));

 
 

-            return FALSE;
+            return false;

         }
 
         *(HENHMETAFILE *)buf = hEMFCopy;
     }
     else
     {
         }
 
         *(HENHMETAFILE *)buf = hEMFCopy;
     }
     else
     {

-        wxASSERT_MSG( format == wxDF_METAFILE, _T("unsupported format") );
+        wxASSERT_MSG( format == wxDF_METAFILE, wxT("unsupported format") );

 
         // convert to WMF
 
 
         // convert to WMF
 


@@ -302,18 +434,18 @@ bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf)
 
         // first get the buffer size and alloc memory
         size_t size = ::GetWinMetaFileBits(hEMF, 0, NULL, MM_ANISOTROPIC, hdc);
 
         // first get the buffer size and alloc memory
         size_t size = ::GetWinMetaFileBits(hEMF, 0, NULL, MM_ANISOTROPIC, hdc);

-        wxCHECK_MSG( size, FALSE, _T("GetWinMetaFileBits() failed") );
+        wxCHECK_MSG( size, false, wxT("GetWinMetaFileBits() failed") );

 
         BYTE *bits = (BYTE *)malloc(size);
 
         // then get the enh metafile bits
         if ( !::GetWinMetaFileBits(hEMF, size, bits, MM_ANISOTROPIC, hdc) )
         {
 
         BYTE *bits = (BYTE *)malloc(size);
 
         // then get the enh metafile bits
         if ( !::GetWinMetaFileBits(hEMF, size, bits, MM_ANISOTROPIC, hdc) )
         {

-            wxLogLastError(_T("GetWinMetaFileBits"));
+            wxLogLastError(wxT("GetWinMetaFileBits"));

 
             free(bits);
 
 
             free(bits);
 

-            return FALSE;
+            return false;

         }
 
         // and finally convert them to the WMF
         }
 
         // and finally convert them to the WMF


@@ -321,9 +453,9 @@ bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf)
         free(bits);
         if ( !hMF )
         {
         free(bits);
         if ( !hMF )
         {

-            wxLogLastError(_T("SetMetaFileBitsEx"));
+            wxLogLastError(wxT("SetMetaFileBitsEx"));

 
 

-            return FALSE;
+            return false;

         }
 
         METAFILEPICT *mfpict = (METAFILEPICT *)buf;
         }
 
         METAFILEPICT *mfpict = (METAFILEPICT *)buf;


@@ -337,7 +469,7 @@ bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf)
         PixelToHIMETRIC(&mfpict->xExt, &mfpict->yExt);
     }
 
         PixelToHIMETRIC(&mfpict->xExt, &mfpict->yExt);
     }
 

-    return TRUE;
+    return true;

 }
 
 bool wxEnhMetaFileDataObject::SetData(const wxDataFormat& format,
 }
 
 bool wxEnhMetaFileDataObject::SetData(const wxDataFormat& format,


@@ -350,28 +482,28 @@ bool wxEnhMetaFileDataObject::SetData(const wxDataFormat& format,
     {
         hEMF = *(HENHMETAFILE *)buf;
 
     {
         hEMF = *(HENHMETAFILE *)buf;
 

-        wxCHECK_MSG( hEMF, FALSE, _T("pasting invalid enh metafile") );
+        wxCHECK_MSG( hEMF, false, wxT("pasting invalid enh metafile") );

     }
     else
     {
     }
     else
     {

-        wxASSERT_MSG( format == wxDF_METAFILE, _T("unsupported format") );
+        wxASSERT_MSG( format == wxDF_METAFILE, wxT("unsupported format") );

 
         // convert from WMF
         const METAFILEPICT *mfpict = (const METAFILEPICT *)buf;
 
         // first get the buffer size
         size_t size = ::GetMetaFileBitsEx(mfpict->hMF, 0, NULL);
 
         // convert from WMF
         const METAFILEPICT *mfpict = (const METAFILEPICT *)buf;
 
         // first get the buffer size
         size_t size = ::GetMetaFileBitsEx(mfpict->hMF, 0, NULL);

-        wxCHECK_MSG( size, FALSE, _T("GetMetaFileBitsEx() failed") );
+        wxCHECK_MSG( size, false, wxT("GetMetaFileBitsEx() failed") );

 
         // then get metafile bits
         BYTE *bits = (BYTE *)malloc(size);
         if ( !::GetMetaFileBitsEx(mfpict->hMF, size, bits) )
         {
 
         // then get metafile bits
         BYTE *bits = (BYTE *)malloc(size);
         if ( !::GetMetaFileBitsEx(mfpict->hMF, size, bits) )
         {

-            wxLogLastError(_T("GetMetaFileBitsEx"));
+            wxLogLastError(wxT("GetMetaFileBitsEx"));

 
             free(bits);
 
 
             free(bits);
 

-            return FALSE;
+            return false;

         }
 
         ScreenHDC hdcRef;
         }
 
         ScreenHDC hdcRef;


@@ -381,15 +513,15 @@ bool wxEnhMetaFileDataObject::SetData(const wxDataFormat& format,
         free(bits);
         if ( !hEMF )
         {
         free(bits);
         if ( !hEMF )
         {

-            wxLogLastError(_T("SetWinMetaFileBits"));
+            wxLogLastError(wxT("SetWinMetaFileBits"));

 
 

-            return FALSE;
+            return false;

         }
     }
 
     m_metafile.SetHENHMETAFILE((WXHANDLE)hEMF);
 
         }
     }
 
     m_metafile.SetHENHMETAFILE((WXHANDLE)hEMF);
 

-    return TRUE;
+    return true;

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


@@ -404,20 +536,20 @@ size_t wxEnhMetaFileSimpleDataObject::GetDataSize() const
 
 bool wxEnhMetaFileSimpleDataObject::GetDataHere(void *buf) const
 {
 
 bool wxEnhMetaFileSimpleDataObject::GetDataHere(void *buf) const
 {

-    wxCHECK_MSG( m_metafile.Ok(), FALSE, _T("copying invalid enh metafile") );
+    wxCHECK_MSG( m_metafile.IsOk(), false, wxT("copying invalid enh metafile") );

 
     HENHMETAFILE hEMF = (HENHMETAFILE)m_metafile.GetHENHMETAFILE();
 
     HENHMETAFILE hEMFCopy = ::CopyEnhMetaFile(hEMF, NULL);
     if ( !hEMFCopy )
     {
 
     HENHMETAFILE hEMF = (HENHMETAFILE)m_metafile.GetHENHMETAFILE();
 
     HENHMETAFILE hEMFCopy = ::CopyEnhMetaFile(hEMF, NULL);
     if ( !hEMFCopy )
     {

-        wxLogLastError(_T("CopyEnhMetaFile"));
+        wxLogLastError(wxT("CopyEnhMetaFile"));

 
 

-        return FALSE;
+        return false;

     }
 
     *(HENHMETAFILE *)buf = hEMFCopy;
     }
 
     *(HENHMETAFILE *)buf = hEMFCopy;

-    return TRUE;
+    return true;

 }
 
 bool wxEnhMetaFileSimpleDataObject::SetData(size_t WXUNUSED(len),
 }
 
 bool wxEnhMetaFileSimpleDataObject::SetData(size_t WXUNUSED(len),


@@ -425,10 +557,10 @@ bool wxEnhMetaFileSimpleDataObject::SetData(size_t WXUNUSED(len),
 {
     HENHMETAFILE hEMF = *(HENHMETAFILE *)buf;
 
 {
     HENHMETAFILE hEMF = *(HENHMETAFILE *)buf;
 

-    wxCHECK_MSG( hEMF, FALSE, _T("pasting invalid enh metafile") );
+    wxCHECK_MSG( hEMF, false, wxT("pasting invalid enh metafile") );

     m_metafile.SetHENHMETAFILE((WXHANDLE)hEMF);
 
     m_metafile.SetHENHMETAFILE((WXHANDLE)hEMF);
 

-    return TRUE;
+    return true;

 }
 
 
 }