Generate wxEVT_KEY_DOWN events for navigation keys in wxMSW wxTreeCtrl.

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

diff --git a/src/msw/enhmeta.cpp b/src/msw/enhmeta.cpp
index 818d796a81b51a983d475f2588aa6edd7ee34139..a59f622acc2cdb4f3fcb5b96434d96b1f407e932 100644 (file)
--- a/src/msw/enhmeta.cpp
+++ b/src/msw/enhmeta.cpp
@@ -69,6 +69,21 @@ 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() )
 void wxEnhMetaFile::Init()
 {
     if ( m_filename.empty() )


@@ -79,8 +94,10 @@ void wxEnhMetaFile::Init()
     {
         m_hMF = (WXHANDLE)::GetEnhMetaFile(m_filename.fn_str());
         if ( !m_hMF )
     {
         m_hMF = (WXHANDLE)::GetEnhMetaFile(m_filename.fn_str());
         if ( !m_hMF )

+        {

             wxLogSysError(_("Failed to load metafile from file \"%s\"."),
                           m_filename.c_str());
             wxLogSysError(_("Failed to load metafile from file \"%s\"."),
                           m_filename.c_str());

+        }

     }
 }
 
     }
 }
 


@@ -95,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


@@ -110,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( Ok(), 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 )


@@ -142,10 +159,10 @@ bool wxEnhMetaFile::Play(wxDC *dc, wxRect *rectBound)
     wxMSWDCImpl *msw_impl = wxDynamicCast( impl, wxMSWDCImpl );
     if (!msw_impl)
         return false;
     wxMSWDCImpl *msw_impl = wxDynamicCast( impl, wxMSWDCImpl );
     if (!msw_impl)
         return false;

-        
+

     if ( !::PlayEnhMetaFile(GetHdcOf(*msw_impl), GetEMF(), &rect) )
     {
     if ( !::PlayEnhMetaFile(GetHdcOf(*msw_impl), GetEMF(), &rect) )
     {

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

 
         return false;
     }
 
         return false;
     }


@@ -162,7 +179,7 @@ wxSize wxEnhMetaFile::GetSize() const
         ENHMETAHEADER hdr;
         if ( !::GetEnhMetaFileHeader(GetEMF(), sizeof(hdr), &hdr) )
         {
         ENHMETAHEADER hdr;
         if ( !::GetEnhMetaFileHeader(GetEMF(), sizeof(hdr), &hdr) )
         {

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

         }
         else
         {
         }
         else
         {


@@ -184,23 +201,27 @@ wxSize wxEnhMetaFile::GetSize() const
 bool wxEnhMetaFile::SetClipboard(int WXUNUSED(width), int WXUNUSED(height))
 {
 #if wxUSE_DRAG_AND_DROP && wxUSE_CLIPBOARD
 bool wxEnhMetaFile::SetClipboard(int WXUNUSED(width), int WXUNUSED(height))
 {
 #if wxUSE_DRAG_AND_DROP && wxUSE_CLIPBOARD

-    wxCHECK_MSG( m_hMF, false, _T("can't copy invalid metafile to 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"));
+    wxFAIL_MSG(wxT("not implemented"));

     return false;
 #endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
 }
 
 // ----------------------------------------------------------------------------
     return false;
 #endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
 }
 
 // ----------------------------------------------------------------------------

-// wxEnhMetaFileDC
+// wxEnhMetaFileDCImpl

 // ----------------------------------------------------------------------------
 
 class wxEnhMetaFileDCImpl : public wxMSWDCImpl
 {
 public:
 // ----------------------------------------------------------------------------
 
 class wxEnhMetaFileDCImpl : public wxMSWDCImpl
 {
 public:

-    wxEnhMetaFileDCImpl( wxEnhMetaFileDC *owner, 
+    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();
                          const wxString& filename, int width, int height,
                          const wxString& description );
     virtual ~wxEnhMetaFileDCImpl();


@@ -212,27 +233,39 @@ protected:
     virtual void DoGetSize(int *width, int *height) const;
 
 private:
     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;
 };
 
 
     // size passed to ctor and returned by DoGetSize()
     int m_width,
         m_height;
 };
 
 

-IMPLEMENT_ABSTRACT_CLASS(wxEnhMetaFileDC, wxDC)
-
-wxEnhMetaFileDC::wxEnhMetaFileDC(const wxString& filename,
+wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,
+                                 const wxString& filename,

                                  int width, int height,
                                  int width, int height,

-                                 const wxString& description)
+                                 const wxString& description )
+                   : wxMSWDCImpl( owner )

 {
 {

-    m_pimpl = new wxEnhMetaFileDCImpl( this, filename, width, height, description );
+    Create(ScreenHDC(), filename, width, height, description);

 }
 
 }
 

-

 wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,
 wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,

+                                 const wxDC& referenceDC,

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

-   : wxMSWDCImpl( owner )
+                   : wxMSWDCImpl( owner )
+{
+    Create(GetHdcOf(referenceDC), filename, width, height, description);
+}
+
+void wxEnhMetaFileDCImpl::Create(HDC hdcRef,
+                                 const wxString& filename,
+                                 int width, int height,
+                                 const wxString& description)

 {
     m_width = width;
     m_height = height;
 {
     m_width = width;
     m_height = height;


@@ -247,7 +280,7 @@ wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,
         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 = ▭
     }
 
         pRect = ▭
     }


@@ -257,12 +290,11 @@ wxEnhMetaFileDCImpl::wxEnhMetaFileDCImpl( wxEnhMetaFileDC* owner,
         pRect = (LPRECT)NULL;
     }
 
         pRect = (LPRECT)NULL;
     }
 

-    ScreenHDC hdcRef;

     m_hDC = (WXHDC)::CreateEnhMetaFile(hdcRef, GetMetaFileName(filename),
                                        pRect, description.wx_str());
     if ( !m_hDC )
     {
     m_hDC = (WXHDC)::CreateEnhMetaFile(hdcRef, GetMetaFileName(filename),
                                        pRect, description.wx_str());
     if ( !m_hDC )
     {

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

     }
 }
 
     }
 }
 


@@ -276,12 +308,12 @@ void wxEnhMetaFileDCImpl::DoGetSize(int *width, int *height) const
 
 wxEnhMetaFile *wxEnhMetaFileDCImpl::Close()
 {
 
 wxEnhMetaFile *wxEnhMetaFileDCImpl::Close()
 {

-    wxCHECK_MSG( IsOk(), 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;
     }


@@ -297,6 +329,43 @@ wxEnhMetaFileDCImpl::~wxEnhMetaFileDCImpl()
     m_hDC = 0;
 }
 
     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
 
 // ----------------------------------------------------------------------------


@@ -331,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);
     }


@@ -339,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.Ok(), false, wxT("copying invalid enh metafile") );

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


@@ -348,7 +417,7 @@ 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;
         }


@@ -357,7 +426,7 @@ bool wxEnhMetaFileDataObject::GetDataHere(const wxDataFormat& format, void *buf)
     }
     else
     {
     }
     else
     {

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

 
         // convert to WMF
 
 
         // convert to WMF
 


@@ -365,14 +434,14 @@ 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);
 


@@ -384,7 +453,7 @@ 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;
         }


@@ -413,24 +482,24 @@ 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);
 


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

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

 
             return false;
         }
 
             return false;
         }


@@ -467,14 +536,14 @@ 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.Ok(), 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;
     }


@@ -488,7 +557,7 @@ 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);
 
     return true;
     m_metafile.SetHENHMETAFILE((WXHANDLE)hEMF);
 
     return true;