]> git.saurik.com Git - wxWidgets.git/blobdiff - src/mac/carbon/dataobj.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
create stock GDI objects on demand; use const with GDI objects appropriately (patch...
[wxWidgets.git] / src / mac / carbon / dataobj.cpp
diff --git a/src/mac/carbon/dataobj.cpp b/src/mac/carbon/dataobj.cpp
index e6e4af8767191f5b937da5ee9899487ce75e5961..f617d26f1c4df387e5ac49968784b8a95836a7e1 100644 (file)
--- a/src/mac/carbon/dataobj.cpp
+++ b/src/mac/carbon/dataobj.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        mac/dataobj.cpp
+// Name:        src/mac/carbon/dataobj.cpp
 // Purpose:     implementation of wxDataObject class
 // Author:      Stefan Csomor
 // Modified by:
 // Purpose:     implementation of wxDataObject class
 // Author:      Stefan Csomor
 // Modified by:
@@ -9,14 +9,6 @@
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
-// ============================================================================
-// declarations
-// ============================================================================
-
-// ----------------------------------------------------------------------------
-// headers
-// ----------------------------------------------------------------------------
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
@@ -32,14 +24,14 @@
 #include "wx/mstream.h"
 #include "wx/image.h"
 #include "wx/metafile.h"
 #include "wx/mstream.h"
 #include "wx/image.h"
 #include "wx/metafile.h"
+#include "wx/tokenzr.h"
+
 #include "wx/mac/private.h"
 #include "wx/mac/private.h"
+
 #ifndef __DARWIN__
 #include <Scrap.h>
 #endif
 
 #ifndef __DARWIN__
 #include <Scrap.h>
 #endif
 
-// ----------------------------------------------------------------------------
-// functions
-// ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxDataFormat
 
 // ----------------------------------------------------------------------------
 // wxDataFormat
@@ -51,95 +43,112 @@ wxDataFormat::wxDataFormat()
     m_format = 0;
 }
 
     m_format = 0;
 }
 
-wxDataFormat::wxDataFormat(  wxDataFormatId   vType )
+wxDataFormat::wxDataFormat( wxDataFormatId vType )
 {
 {
-    SetType(vType);
+    SetType( vType );
 }
 
 }
 
-wxDataFormat::wxDataFormat(  const wxChar*  zId)
+wxDataFormat::wxDataFormat( const wxChar *zId )
 {
 {
-    SetId(zId);
+    SetId( zId );
 }
 
 }
 
-wxDataFormat::wxDataFormat(  const wxString&   rId)
+wxDataFormat::wxDataFormat( const wxString& rId )
 {
 {
-    SetId(rId);
+    SetId( rId );
 }
 
 }
 
-wxDataFormat::wxDataFormat( NativeFormat vFormat)
+wxDataFormat::wxDataFormat( NativeFormat vFormat )
 {
 {
-    SetId(vFormat);
+    SetId( vFormat );
 }
 
 }
 
-void wxDataFormat::SetType(  wxDataFormatId  Type )
+void wxDataFormat::SetType( wxDataFormatId dataType )
 {
 {
-    m_type = Type;
+    m_type = dataType;
 
 
-    if (m_type == wxDF_TEXT )
+    switch (m_type)
+    {
+    case wxDF_TEXT:
         m_format = kScrapFlavorTypeText;
         m_format = kScrapFlavorTypeText;
-    else if (m_type == wxDF_UNICODETEXT )
-        m_format = kScrapFlavorTypeUnicode ;
-    else if (m_type == wxDF_BITMAP || m_type == wxDF_METAFILE )
+        break;
+
+    case wxDF_UNICODETEXT:
+        m_format = kScrapFlavorTypeUnicode;
+        break;
+
+    case wxDF_BITMAP:
+    case wxDF_METAFILE:
         m_format = kScrapFlavorTypePicture;
         m_format = kScrapFlavorTypePicture;
-    else if (m_type == wxDF_FILENAME)
-        m_format = kDragFlavorTypeHFS ;
-    else
-    {
-       wxFAIL_MSG( wxT("invalid dataformat") );
+        break;
+
+    case wxDF_FILENAME:
+        m_format = kDragFlavorTypeHFS;
+        break;
 
 
-       // this is '????' but it can't be used in the code because ??' is
-       // parsed as a trigraph!
+    default:
+       wxFAIL_MSG( wxT("invalid data format") );
+
+       // NB: this translates to '????' ASCII but it can't be used in the code
+       // because '??' will get parsed as a trigraph!
        m_format = 0x3f3f3f3f;
        m_format = 0x3f3f3f3f;
+       break;
     }
 }
 
 wxString wxDataFormat::GetId() const
 {
     }
 }
 
 wxString wxDataFormat::GetId() const
 {
-    wxCHECK_MSG( !IsStandard(), wxEmptyString ,
+    wxCHECK_MSG( !IsStandard(), wxEmptyString,
                  wxT("name of predefined format cannot be retrieved") );
 
                  wxT("name of predefined format cannot be retrieved") );
 
-    return m_id ;
+    return m_id;
 }
 
 }
 
-void wxDataFormat::SetId(  NativeFormat  format )
+void wxDataFormat::SetId( NativeFormat format )
 {
     m_format = format;
 
 {
     m_format = format;
 
-    if (m_format == kScrapFlavorTypeText)
+    switch (m_format)
+    {
+    case kScrapFlavorTypeText:
         m_type = wxDF_TEXT;
         m_type = wxDF_TEXT;
-    else if (m_format == kScrapFlavorTypeUnicode )
+        break;
+
+    case kScrapFlavorTypeUnicode:
         m_type = wxDF_UNICODETEXT;
         m_type = wxDF_UNICODETEXT;
-    else if (m_format == kScrapFlavorTypePicture)
+        break;
+
+    case kScrapFlavorTypePicture:
         m_type = wxDF_BITMAP;
         m_type = wxDF_BITMAP;
-    else if (m_format == kDragFlavorTypeHFS )
+        break;
+
+    case kDragFlavorTypeHFS:
         m_type = wxDF_FILENAME;
         m_type = wxDF_FILENAME;
-    else
-    {
+        break;
+
+    default:
         m_type = wxDF_PRIVATE;
         m_type = wxDF_PRIVATE;
-        char text[5] ;
-        strncpy( text , (char*) &format , 4 ) ;
-        text[4] = 0 ;
-        m_id = wxString::FromAscii( text ) ;
+        char text[5];
+        memcpy( text, (const char*)&format, 4 );
+        text[4] = 0;
+        m_id = wxString::FromAscii( text );
+        break;
     }
 }
 
 void wxDataFormat::SetId( const wxChar* zId )
 {
     m_type = wxDF_PRIVATE;
     }
 }
 
 void wxDataFormat::SetId( const wxChar* zId )
 {
     m_type = wxDF_PRIVATE;
-    m_id = zId ;
-    m_format = 'WXPR' ;
+    m_id = zId;
+    m_format = 'WXPR';
 }
 
 }
 
-bool wxDataFormat::operator==(const wxDataFormat& format) const 
+bool wxDataFormat::operator==(const wxDataFormat& format) const
 {
 {
-    if ( IsStandard() || format.IsStandard() )
-    {
-        return ( format.m_type == m_type ) ;
-    }
+    if (IsStandard() || format.IsStandard())
+        return (format.m_type == m_type);
     else
     else
-    {
-        return ( m_id == format.m_id ) ;
-    }
+        return (m_id == format.m_id);
 }
 
 //-------------------------------------------------------------------------
 }
 
 //-------------------------------------------------------------------------
@@ -150,37 +159,33 @@ wxDataObject::wxDataObject()
 {
 }
 
 {
 }
 
-bool wxDataObject::IsSupportedFormat(
-  const wxDataFormat&               rFormat
-, Direction                         vDir
-) const
+bool wxDataObject::IsSupportedFormat( const wxDataFormat& rFormat, Direction vDir ) const
 {
 {
-    size_t                          nFormatCount = GetFormatCount(vDir);
+    size_t nFormatCount = GetFormatCount( vDir );
+    bool found = false;
 
     if (nFormatCount == 1)
     {
 
     if (nFormatCount == 1)
     {
-        return rFormat == GetPreferredFormat();
+        found = (rFormat == GetPreferredFormat());
     }
     else
     {
     }
     else
     {
-        wxDataFormat* pFormats = new wxDataFormat[nFormatCount];
-        GetAllFormats( pFormats
-                      ,vDir
-                     );
-
-        size_t                      n;
+        wxDataFormat *pFormats = new wxDataFormat[nFormatCount];
+        GetAllFormats( pFormats, vDir );
 
 
-        for (n = 0; n < nFormatCount; n++)
+        for (size_t n = 0; n < nFormatCount; n++)
         {
             if (pFormats[n] == rFormat)
         {
             if (pFormats[n] == rFormat)
+            {
+                found = true;
                 break;
                 break;
+            }
         }
 
         delete [] pFormats;
         }
 
         delete [] pFormats;
-
-        // found?
-        return n < nFormatCount;
     }
     }
+
+    return found;
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -188,67 +193,74 @@ bool wxDataObject::IsSupportedFormat(
 // ----------------------------------------------------------------------------
 
 #if wxUSE_UNICODE
 // ----------------------------------------------------------------------------
 
 #if wxUSE_UNICODE
-void wxTextDataObject::GetAllFormats(wxDataFormat *formats, wxDataObjectBase::Direction dir) const
+void wxTextDataObject::GetAllFormats( wxDataFormat *formats, wxDataObjectBase::Direction dir ) const
 {
     *formats++ = wxDataFormat( wxDF_TEXT );
     *formats = wxDataFormat( wxDF_UNICODETEXT );
 }
 {
     *formats++ = wxDataFormat( wxDF_TEXT );
     *formats = wxDataFormat( wxDF_UNICODETEXT );
 }
-
 #endif
 
 // ----------------------------------------------------------------------------
 // wxFileDataObject
 // ----------------------------------------------------------------------------
 
 #endif
 
 // ----------------------------------------------------------------------------
 // wxFileDataObject
 // ----------------------------------------------------------------------------
 
-bool wxFileDataObject::GetDataHere(
-  void*                             pBuf
-) const
+void wxFileDataObject::GetFileNames( wxCharBuffer &buf ) const
 {
 {
-    wxString                        sFilenames;
+    wxString filenames;
 
     for (size_t i = 0; i < m_filenames.GetCount(); i++)
     {
 
     for (size_t i = 0; i < m_filenames.GetCount(); i++)
     {
-        sFilenames += m_filenames[i];
-        sFilenames += (wxChar)0;
+        filenames += m_filenames[i];
+        filenames += wxT('\n');
     }
 
     }
 
-    memcpy(pBuf, sFilenames.mbc_str(), sFilenames.Len() + 1);
-    return TRUE;
+    buf = filenames.fn_str();
+}
+
+bool wxFileDataObject::GetDataHere( void *pBuf ) const
+{
+    if (pBuf == NULL)
+        return false;
+
+    wxCharBuffer buf;
+    size_t buffLength;
+
+    GetFileNames( buf );
+    buffLength = strlen( buf );
+    memcpy( pBuf, (const char*)buf, buffLength + 1 );
+
+    return true;
 }
 
 size_t wxFileDataObject::GetDataSize() const
 {
 }
 
 size_t wxFileDataObject::GetDataSize() const
 {
-    size_t nRes = 0;
+    wxCharBuffer buf;
+    size_t buffLength;
 
 
-    for (size_t i = 0; i < m_filenames.GetCount(); i++)
-    {
-        nRes += m_filenames[i].Len();
-        nRes += 1;
-    }
+    GetFileNames( buf );
+    buffLength = strlen( buf );
 
 
-    return nRes + 1;
+    return buffLength + 1;
 }
 
 }
 
-bool wxFileDataObject::SetData(
-  size_t                            WXUNUSED(nSize)
-, const void*                       pBuf
-)
+bool wxFileDataObject::SetData( size_t nSize, const void *pBuf )
 {
 {
-    m_filenames.Empty();
+    wxString filenames;
+
+#if wxUSE_UNICODE
+    filenames = wxString( (const char*)pBuf, *wxConvFileName );
+#else
+    filenames = wxString( wxConvFileName->cMB2WX( (const char*)pBuf ), wxConvLocal );
+#endif
 
 
-    // only add if this is not an empty string
-    // we can therefore clear the list by just setting an empty string
-    if ( (*(char*)pBuf) != 0 )
-        AddFile(wxString::FromAscii((char*)pBuf));
+    m_filenames = wxStringTokenize( filenames, wxT("\n"), wxTOKEN_STRTOK );
 
 
-    return TRUE;
+    return true;
 }
 
 }
 
-void wxFileDataObject::AddFile(
-  const wxString&                   rFilename
-)
+void wxFileDataObject::AddFile( const wxString& rFilename )
 {
 {
-    m_filenames.Add(rFilename);
+    m_filenames.Add( rFilename );
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------
@@ -260,16 +272,15 @@ wxBitmapDataObject::wxBitmapDataObject()
     Init();
 }
 
     Init();
 }
 
-wxBitmapDataObject::wxBitmapDataObject(
-  const wxBitmap& rBitmap
-)
-: wxBitmapDataObjectBase(rBitmap)
+wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& rBitmap )
+: wxBitmapDataObjectBase( rBitmap )
 {
     Init();
 {
     Init();
-    if ( m_bitmap.Ok() )
+
+    if (m_bitmap.Ok())
     {
     {
-        m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle() ;
-        m_pictCreated = false ;
+        m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle();
+        m_pictCreated = false;
     }
 }
 
     }
 }
 
@@ -278,74 +289,84 @@ wxBitmapDataObject::~wxBitmapDataObject()
     Clear();
 }
 
     Clear();
 }
 
-void wxBitmapDataObject::SetBitmap(
-  const wxBitmap&                   rBitmap
-)
+void wxBitmapDataObject::SetBitmap( const wxBitmap& rBitmap )
 {
     Clear();
 {
     Clear();
-    wxBitmapDataObjectBase::SetBitmap(rBitmap);
-    if ( m_bitmap.Ok() )
+    wxBitmapDataObjectBase::SetBitmap( rBitmap );
+    if (m_bitmap.Ok())
     {
     {
-        m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle() ;
-        m_pictCreated = false ;
+        m_pictHandle = m_bitmap.GetBitmapData()->GetPictHandle();
+        m_pictCreated = false;
     }
 }
 
     }
 }
 
-void wxBitmapDataObject::Init() 
-{ 
-    m_pictHandle = NULL ;
-    m_pictCreated = false ;
-} 
+void wxBitmapDataObject::Init()
+{
+    m_pictHandle = NULL;
+    m_pictCreated = false;
+}
 
 
-void wxBitmapDataObject::Clear() 
+void wxBitmapDataObject::Clear()
 {
 {
-    if ( m_pictCreated && m_pictHandle )
+    if (m_pictHandle != NULL)
     {
     {
-        KillPicture( (PicHandle) m_pictHandle ) ;
+        if (m_pictCreated)
+            KillPicture( (PicHandle)m_pictHandle );
+        m_pictHandle = NULL;
     }
     }
-    m_pictHandle = NULL ;
+
+    m_pictCreated = false;
 }
 
 }
 
-bool wxBitmapDataObject::GetDataHere(
-  void*                             pBuf
-) const
+bool wxBitmapDataObject::GetDataHere( void *pBuf ) const
 {
 {
-    if (!m_pictHandle)
+    if (m_pictHandle == NULL)
     {
     {
-        wxFAIL_MSG(wxT("attempt to copy empty bitmap failed"));
-        return FALSE;
+        wxFAIL_MSG( wxT("attempt to copy empty bitmap failed") );
+        return false;
     }
     }
-    memcpy(pBuf, *(Handle)m_pictHandle, GetHandleSize((Handle)m_pictHandle));
-    return TRUE;
+
+    if (pBuf == NULL)
+        return false;
+
+    memcpy( pBuf, *(Handle)m_pictHandle, GetHandleSize( (Handle)m_pictHandle ) );
+
+    return true;
 }
 
 size_t wxBitmapDataObject::GetDataSize() const
 {
 }
 
 size_t wxBitmapDataObject::GetDataSize() const
 {
-    return GetHandleSize((Handle)m_pictHandle) ;
+    if (m_pictHandle != NULL)
+        return GetHandleSize( (Handle)m_pictHandle );
+    else
+        return 0;
 }
 
 }
 
-bool wxBitmapDataObject::SetData(
-  size_t                            nSize
-, const void*                       pBuf
-)
+bool wxBitmapDataObject::SetData( size_t nSize, const void *pBuf )
 {
     Clear();
 {
     Clear();
-    PicHandle picHandle = (PicHandle) NewHandle( nSize ) ;
-    memcpy( *picHandle , pBuf , nSize ) ;
-    m_pictHandle = picHandle ;
+
+    if ((pBuf == NULL) || (nSize == 0))
+        return false;
+
+    PicHandle picHandle = (PicHandle)NewHandle( nSize );
+    memcpy( *picHandle, pBuf, nSize );
+    m_pictHandle = picHandle;
+
     // ownership is transferred to the bitmap
     // ownership is transferred to the bitmap
-    m_pictCreated = false ;
-    Rect frame = (**picHandle).picFrame ;
-    
-    wxMetafile mf ;
-    mf.SetHMETAFILE( (WXHMETAFILE) m_pictHandle ) ;
-    wxMemoryDC mdc ;
-    m_bitmap.Create( frame.right - frame.left ,frame.bottom - frame.top ) ;
-    mdc.SelectObject(m_bitmap ) ;
-    mf.Play( &mdc ) ;
-    mdc.SelectObject( wxNullBitmap ) ;
-    
+    m_pictCreated = false;
+    Rect frame;
+    wxMacGetPictureBounds( picHandle, &frame );
+
+    wxMetafile mf;
+    mf.SetHMETAFILE( (WXHMETAFILE)m_pictHandle );
+    wxMemoryDC mdc;
+    m_bitmap.Create( frame.right - frame.left, frame.bottom - frame.top );
+    mdc.SelectObject( m_bitmap );
+    mf.Play( &mdc );
+    mdc.SelectObject( wxNullBitmap );
+
     return m_bitmap.Ok();
 }
 
     return m_bitmap.Ok();
 }
 
-#endif
\ No newline at end of file
+#endif
wxWidgets (Impactor)