src/mac/carbon/dataobj.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        mac/dataobj.cpp
   3 // Purpose:     implementation of wxDataObject class
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     10/21/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1999 Stefan Csomor
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21   #pragma implementation "dataobj.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifndef WX_PRECOMP
  28 #include "wx/intl.h"
  29 #endif
  30
  31 #include "wx/log.h"
  32 #include "wx/dataobj.h"
  33 #include "wx/mstream.h"
  34 #include "wx/image.h"
  35 #include "wx/metafile.h"
  36 #include "wx/mac/private.h"
  37 #include <Scrap.h>
  38
  39 // ----------------------------------------------------------------------------
  40 // functions
  41 // ----------------------------------------------------------------------------
  42
  43 // ----------------------------------------------------------------------------
  44 // wxDataFormat
  45 // ----------------------------------------------------------------------------
  46
  47 wxDataFormat::wxDataFormat()
  48 {
  49     m_type = wxDF_INVALID;
  50     m_format = 0;
  51 }
  52
  53 wxDataFormat::wxDataFormat(  wxDataFormatId   vType )
  54 {
  55     SetType(vType);
  56 }
  57
  58 wxDataFormat::wxDataFormat(  const wxChar*  zId)
  59 {
  60     SetId(zId);
  61 }
  62
  63 wxDataFormat::wxDataFormat(  const wxString&   rId)
  64 {
  65     SetId(rId);
  66 }
  67
  68 wxDataFormat::wxDataFormat( NativeFormat vFormat)
  69 {
  70     SetId(vFormat);
  71 }
  72
  73 void wxDataFormat::SetType(  wxDataFormatId  Type )
  74 {
  75     m_type = Type;
  76
  77     if (m_type == wxDF_TEXT )
  78         m_format = kScrapFlavorTypeText;
  79     else if (m_type == wxDF_UNICODETEXT )
  80         m_format = kScrapFlavorTypeUnicode ;
  81     else if (m_type == wxDF_BITMAP || m_type == wxDF_METAFILE )
  82         m_format = kScrapFlavorTypePicture;
  83     else if (m_type == wxDF_FILENAME)
  84         m_format = kDragFlavorTypeHFS ;
  85     else
  86     {
  87        wxFAIL_MSG( wxT("invalid dataformat") );
  88
  89        // this is '????' but it can't be used in the code because ??' is
  90        // parsed as a trigraph!
  91        m_format = 0x3f3f3f3f;
  92     }
  93 }
  94
  95 wxString wxDataFormat::GetId() const
  96 {
  97     // note that m_format is not a pointer to string, it *is* itself a 4
  98     // character string
  99     char text[5] ;
 100     strncpy( text , (char*) &m_format , 4 ) ;
 101     text[4] = 0 ;
 102
 103     return wxString::FromAscii( text ) ;
 104 }
 105
 106 void wxDataFormat::SetId(  NativeFormat  format )
 107 {
 108     m_format = format;
 109
 110     if (m_format == kScrapFlavorTypeText)
 111         m_type = wxDF_TEXT;
 112     else if (m_format == kScrapFlavorTypeUnicode )
 113         m_type = wxDF_UNICODETEXT;
 114     else if (m_format == kScrapFlavorTypePicture)
 115         m_type = wxDF_BITMAP;
 116     else if (m_format == kDragFlavorTypeHFS )
 117         m_type = wxDF_FILENAME;
 118     else
 119         m_type = wxDF_PRIVATE;
 120 }
 121
 122 void wxDataFormat::SetId( const wxChar* zId )
 123 {
 124     m_type = wxDF_PRIVATE;
 125     m_format = 0;// TODO: get the format gdk_atom_intern( wxMBSTRINGCAST tmp.mbc_str(), FALSE );
 126 }
 127
 128 //-------------------------------------------------------------------------
 129 // wxDataObject
 130 //-------------------------------------------------------------------------
 131
 132 wxDataObject::wxDataObject()
 133 {
 134 }
 135
 136 bool wxDataObject::IsSupportedFormat(
 137   const wxDataFormat&               rFormat
 138 , Direction                         vDir
 139 ) const
 140 {
 141     size_t                          nFormatCount = GetFormatCount(vDir);
 142
 143     if (nFormatCount == 1)
 144     {
 145         return rFormat == GetPreferredFormat();
 146     }
 147     else
 148     {
 149         wxDataFormat* pFormats = new wxDataFormat[nFormatCount];
 150         GetAllFormats( pFormats
 151                       ,vDir
 152                      );
 153
 154         size_t                      n;
 155
 156         for (n = 0; n < nFormatCount; n++)
 157         {
 158             if (pFormats[n] == rFormat)
 159                 break;
 160         }
 161
 162         delete [] pFormats;
 163
 164         // found?
 165         return n < nFormatCount;
 166     }
 167 }
 168
 169 // ----------------------------------------------------------------------------
 170 // wxTextDataObject
 171 // ----------------------------------------------------------------------------
 172
 173 #if wxUSE_UNICODE
 174 void wxTextDataObject::GetAllFormats(wxDataFormat *formats, wxDataObjectBase::Direction dir) const
 175 {
 176     *formats++ = wxDataFormat( wxDF_TEXT );
 177     *formats = wxDataFormat( wxDF_UNICODETEXT );
 178 }
 179
 180 #endif
 181
 182 // ----------------------------------------------------------------------------
 183 // wxFileDataObject
 184 // ----------------------------------------------------------------------------
 185
 186 bool wxFileDataObject::GetDataHere(
 187   void*                             pBuf
 188 ) const
 189 {
 190     wxString                        sFilenames;
 191
 192     for (size_t i = 0; i < m_filenames.GetCount(); i++)
 193     {
 194         sFilenames += m_filenames[i];
 195         sFilenames += (wxChar)0;
 196     }
 197
 198     memcpy(pBuf, sFilenames.mbc_str(), sFilenames.Len() + 1);
 199     return TRUE;
 200 }
 201
 202 size_t wxFileDataObject::GetDataSize() const
 203 {
 204     size_t nRes = 0;
 205
 206     for (size_t i = 0; i < m_filenames.GetCount(); i++)
 207     {
 208         nRes += m_filenames[i].Len();
 209         nRes += 1;
 210     }
 211
 212     return nRes + 1;
 213 }
 214
 215 bool wxFileDataObject::SetData(
 216   size_t                            WXUNUSED(nSize)
 217 , const void*                       pBuf
 218 )
 219 {
 220     m_filenames.Empty();
 221
 222     // only add if this is not an empty string
 223     // we can therefore clear the list by just setting an empty string
 224     if ( (*(char*)pBuf) != 0 )
 225         AddFile(wxString::FromAscii((char*)pBuf));
 226
 227     return TRUE;
 228 }
 229
 230 void wxFileDataObject::AddFile(
 231   const wxString&                   rFilename
 232 )
 233 {
 234     m_filenames.Add(rFilename);
 235 }
 236
 237 // ----------------------------------------------------------------------------
 238 // wxBitmapDataObject
 239 // ----------------------------------------------------------------------------
 240
 241 wxBitmapDataObject::wxBitmapDataObject()
 242 {
 243     Init();
 244 }
 245
 246 wxBitmapDataObject::wxBitmapDataObject(
 247   const wxBitmap& rBitmap
 248 )
 249 : wxBitmapDataObjectBase(rBitmap)
 250 {
 251     Init();
 252     if ( m_bitmap.Ok() )
 253     {
 254         m_pictHandle = wxMacCreatePicHandle( rBitmap ) ;
 255         m_pictCreated = true ;
 256     }
 257 }
 258
 259 wxBitmapDataObject::~wxBitmapDataObject()
 260 {
 261     Clear();
 262 }
 263
 264 void wxBitmapDataObject::SetBitmap(
 265   const wxBitmap&                   rBitmap
 266 )
 267 {
 268     Clear();
 269     wxBitmapDataObjectBase::SetBitmap(rBitmap);
 270     if ( m_bitmap.Ok() )
 271     {
 272         m_pictHandle = wxMacCreatePicHandle( rBitmap ) ;
 273         m_pictCreated = true ;
 274     }
 275 }
 276
 277 void wxBitmapDataObject::Init()
 278 {
 279     m_pictHandle = NULL ;
 280     m_pictCreated = false ;
 281 }
 282
 283 void wxBitmapDataObject::Clear()
 284 {
 285     if ( m_pictCreated && m_pictHandle )
 286     {
 287         KillPicture( (PicHandle) m_pictHandle ) ;
 288     }
 289     m_pictHandle = NULL ;
 290 }
 291
 292 bool wxBitmapDataObject::GetDataHere(
 293   void*                             pBuf
 294 ) const
 295 {
 296     if (!m_pictHandle)
 297     {
 298         wxFAIL_MSG(wxT("attempt to copy empty bitmap failed"));
 299         return FALSE;
 300     }
 301     memcpy(pBuf, *(Handle)m_pictHandle, GetHandleSize((Handle)m_pictHandle));
 302     return TRUE;
 303 }
 304
 305 size_t wxBitmapDataObject::GetDataSize() const
 306 {
 307     return GetHandleSize((Handle)m_pictHandle) ;
 308 }
 309
 310 bool wxBitmapDataObject::SetData(
 311   size_t                            nSize
 312 , const void*                       pBuf
 313 )
 314 {
 315     Clear();
 316     PicHandle picHandle = (PicHandle) NewHandle( nSize ) ;
 317     memcpy( *picHandle , pBuf , nSize ) ;
 318     m_pictHandle = picHandle ;
 319     // ownership is transferred to the bitmap
 320     m_pictCreated = false ;
 321     Rect frame = (**picHandle).picFrame ;
 322
 323     wxMetafile mf ;
 324     mf.SetHMETAFILE( (WXHMETAFILE) m_pictHandle ) ;
 325     wxMemoryDC mdc ;
 326     m_bitmap.Create( frame.right - frame.left ,frame.bottom - frame.top ) ;
 327     mdc.SelectObject(m_bitmap ) ;
 328     mf.Play( &mdc ) ;
 329     mdc.SelectObject( wxNullBitmap ) ;
 330
 331     return m_bitmap.Ok();
 332 }