some fixes after global _T() => T() change

[wxWidgets.git] / src / gtk1 / dataobj.cpp

diff --git a/src/gtk1/dataobj.cpp b/src/gtk1/dataobj.cpp
index e6b756326a8ad02f6ec27e4388f5a075d49b0fa2..8b217e7bc476831877a977d178c7b139bc1633c2 100644 (file)
--- a/src/gtk1/dataobj.cpp
+++ b/src/gtk1/dataobj.cpp
@@ -4,73 +4,78 @@
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling

-// Licence:    wxWindows licence
+// Licence:     wxWindows licence

 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef __GNUG__

-#pragma implementation "dataobj.h"
+    #pragma implementation "dataobj.h"

 #endif
 
 #include "wx/dataobj.h"
 #include "wx/app.h"
 #include "wx/debug.h"
 #endif
 
 #include "wx/dataobj.h"
 #include "wx/app.h"
 #include "wx/debug.h"

+#include "wx/mstream.h"
+#include "wx/image.h"

 
 #include "gdk/gdk.h"
 
 
 #include "gdk/gdk.h"
 

+
+//-------------------------------------------------------------------------
+// global data
+//-------------------------------------------------------------------------
+
+GdkAtom  g_textAtom        = 0;
+GdkAtom  g_pngAtom         = 0;
+

 //-------------------------------------------------------------------------
 // wxDataFormat
 //-------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxDataFormat, wxObject)
 
 //-------------------------------------------------------------------------
 // wxDataFormat
 //-------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxDataFormat, wxObject)
 

-wxDataFormat::wxDataFormat( wxDataType type )
+wxDataFormat::wxDataFormat()

 {
 {

-    m_type = type;
-    
-    if (m_type == wxDF_TEXT)
-    {
-        m_id = "STRING";
-    } 
-    else
-    if (m_type == wxDF_BITMAP)
-    {
-        m_id = "BITMAP";
-    } 
-    else
-    if (m_type == wxDF_FILENAME)
-    {
-        m_id = "file:ALL";
-    }
-    else
-    {
-       wxFAIL_MSG( "invalid dataformat" );
-    }
-    
+    PrepareFormats();
+    m_type = wxDF_INVALID;

     m_hasAtom = FALSE;
     m_hasAtom = FALSE;

+    m_atom = (GdkAtom) 0;
+}
+
+wxDataFormat::wxDataFormat( wxDataFormatId type )
+{
+    PrepareFormats();
+    SetType( type );
+}
+
+wxDataFormat::wxDataFormat( const wxChar *id )
+{
+    PrepareFormats();
+    SetId( id );

 }
 
 wxDataFormat::wxDataFormat( const wxString &id )
 {
 }
 
 wxDataFormat::wxDataFormat( const wxString &id )
 {

-    m_type = wxDF_PRIVATE;
-    m_id = id;
-    m_hasAtom = FALSE;
+    PrepareFormats();
+    SetId( id );

 }
 
 }
 

-wxDataFormat::wxDataFormat( wxDataFormat &format )
+wxDataFormat::wxDataFormat( const wxDataFormat &format )

 {
 {

+    PrepareFormats();

     m_type = format.GetType();
     m_id = format.GetId();
     m_hasAtom = TRUE;
     m_type = format.GetType();
     m_id = format.GetId();
     m_hasAtom = TRUE;

-    m_atom = format.GetAtom();
+    m_atom = ((wxDataFormat &)format).GetAtom();    // const_cast

 }
 
 wxDataFormat::wxDataFormat( const GdkAtom atom )
 {
 }
 
 wxDataFormat::wxDataFormat( const GdkAtom atom )
 {

+    PrepareFormats();

     m_hasAtom = TRUE;
     m_hasAtom = TRUE;

-    
+

     m_atom = atom;
     m_atom = atom;

-    
-    if (m_atom == GDK_TARGET_STRING)
+
+    if (m_atom == g_textAtom)

     {
         m_type = wxDF_TEXT;
     } else
     {
         m_type = wxDF_TEXT;
     } else


@@ -81,15 +86,41 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
     {
         m_type = wxDF_PRIVATE;
        m_id = gdk_atom_name( m_atom );
     {
         m_type = wxDF_PRIVATE;
        m_id = gdk_atom_name( m_atom );

-       
-       if (m_id == "file:ALL")
+
+       if (m_id == T("file:ALL"))

        {
            m_type = wxDF_FILENAME;
        }
     }
 }
 
        {
            m_type = wxDF_FILENAME;
        }
     }
 }
 

-int wxDataFormat::GetType() const
+void wxDataFormat::SetType( wxDataFormatId type )
+{
+    m_type = type;
+
+    if (m_type == wxDF_TEXT)
+    {
+        m_id = T("STRING");
+    }
+    else
+    if (m_type == wxDF_BITMAP)
+    {
+        m_id = T("image/png");
+    }
+    else
+    if (m_type == wxDF_FILENAME)
+    {
+        m_id = T("file:ALL");
+    }
+    else
+    {
+       wxFAIL_MSG( T("invalid dataformat") );
+    }
+
+    m_hasAtom = FALSE;
+}
+
+wxDataFormatId wxDataFormat::GetType() const

 {
     return m_type;
 }
 {
     return m_type;
 }


@@ -99,7 +130,7 @@ wxString wxDataFormat::GetId() const
     return m_id;
 }
 
     return m_id;
 }
 

-void wxDataFormat::SetId( const wxString &id )
+void wxDataFormat::SetId( const wxChar *id )

 {
     m_type = wxDF_PRIVATE;
     m_id = id;
 {
     m_type = wxDF_PRIVATE;
     m_id = id;


@@ -111,129 +142,135 @@ GdkAtom wxDataFormat::GetAtom()
     if (!m_hasAtom)
     {
         m_hasAtom = TRUE;
     if (!m_hasAtom)
     {
         m_hasAtom = TRUE;

-       
+

        if (m_type == wxDF_TEXT)
        {
        if (m_type == wxDF_TEXT)
        {

-            m_atom = GDK_TARGET_STRING;
-        } 
+            m_atom = g_textAtom;
+        }

        else
         if (m_type == wxDF_BITMAP)
         {
             m_atom = GDK_TARGET_BITMAP;
        else
         if (m_type == wxDF_BITMAP)
         {
             m_atom = GDK_TARGET_BITMAP;

-        } 
+        }

        else
         if (m_type == wxDF_PRIVATE)
         {
        else
         if (m_type == wxDF_PRIVATE)
         {

-            m_atom = gdk_atom_intern( WXSTRINGCAST( m_id ), FALSE );
-        } 
+            m_atom = gdk_atom_intern( wxMBSTRINGCAST m_id.mbc_str(), FALSE );
+        }

        else
        if (m_type == wxDF_FILENAME)
        {
            m_atom = gdk_atom_intern( "file:ALL", FALSE );
        else
        if (m_type == wxDF_FILENAME)
        {
            m_atom = gdk_atom_intern( "file:ALL", FALSE );

-       } 
+       }

        else
        {
            m_hasAtom = FALSE;
            m_atom = (GdkAtom) 0;
        }
     }
        else
        {
            m_hasAtom = FALSE;
            m_atom = (GdkAtom) 0;
        }
     }

-    
+

     return m_atom;
 }
 
     return m_atom;
 }
 

+void wxDataFormat::PrepareFormats()
+{
+    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    if (!g_pngAtom) g_pngAtom = gdk_atom_intern( "image/png", FALSE );
+}
+

 //-------------------------------------------------------------------------
 // wxDataBroker
 //-------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxDataBroker,wxObject)
 
 //-------------------------------------------------------------------------
 // wxDataBroker
 //-------------------------------------------------------------------------
 
 IMPLEMENT_CLASS(wxDataBroker,wxObject)
 

-wxDataBroker::wxDataBroker() 
-{ 
+wxDataBroker::wxDataBroker()
+{

     m_dataObjects.DeleteContents(TRUE);
     m_preferred = 0;
 }
 
 void wxDataBroker::Add( wxDataObject *dataObject, bool preferred )
     m_dataObjects.DeleteContents(TRUE);
     m_preferred = 0;
 }
 
 void wxDataBroker::Add( wxDataObject *dataObject, bool preferred )

-{ 
+{

     if (preferred) m_preferred = m_dataObjects.GetCount();
     m_dataObjects.Append( dataObject );
     if (preferred) m_preferred = m_dataObjects.GetCount();
     m_dataObjects.Append( dataObject );

-}  
-  
+}
+

 size_t wxDataBroker::GetFormatCount() const
 size_t wxDataBroker::GetFormatCount() const

-{ 
-    return m_dataObjects.GetCount(); 
+{
+    return m_dataObjects.GetCount();

 }
 }

-    
-wxDataFormat &wxDataBroker::GetPreferredFormat() const
-{ 
+
+wxDataFormatId wxDataBroker::GetPreferredFormat() const
+{

     wxNode *node = m_dataObjects.Nth( m_preferred );
     wxNode *node = m_dataObjects.Nth( m_preferred );

-    
+

     wxASSERT( node );
     wxASSERT( node );

-    
+

     wxDataObject* data_obj = (wxDataObject*)node->Data();
     wxDataObject* data_obj = (wxDataObject*)node->Data();

-    
-    return data_obj->GetFormat();
+
+    return data_obj->GetFormat().GetType();

 }
 }

-    
+

 wxDataFormat &wxDataBroker::GetNthFormat( size_t nth ) const
 wxDataFormat &wxDataBroker::GetNthFormat( size_t nth ) const

-{ 
+{

     wxNode *node = m_dataObjects.Nth( nth );
 
     wxASSERT( node );
     wxNode *node = m_dataObjects.Nth( nth );
 
     wxASSERT( node );

-    
+

     wxDataObject* data_obj = (wxDataObject*)node->Data();
     wxDataObject* data_obj = (wxDataObject*)node->Data();

-    
+

     return data_obj->GetFormat();
 }
     return data_obj->GetFormat();
 }

-    
+

 bool wxDataBroker::IsSupportedFormat( wxDataFormat &format ) const
 bool wxDataBroker::IsSupportedFormat( wxDataFormat &format ) const

-{ 
+{

     wxNode *node = m_dataObjects.First();
     while (node)
     {
         wxDataObject *dobj = (wxDataObject*)node->Data();
     wxNode *node = m_dataObjects.First();
     while (node)
     {
         wxDataObject *dobj = (wxDataObject*)node->Data();

-       
+

        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {
            return TRUE;
        }
        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {
            return TRUE;
        }

-    
+

         node = node->Next();
     }
         node = node->Next();
     }

-    
+

     return FALSE;
 }
     return FALSE;
 }

-  
+

 size_t wxDataBroker::GetSize( wxDataFormat& format ) const
 {
     wxNode *node = m_dataObjects.First();
     while (node)
     {
         wxDataObject *dobj = (wxDataObject*)node->Data();
 size_t wxDataBroker::GetSize( wxDataFormat& format ) const
 {
     wxNode *node = m_dataObjects.First();
     while (node)
     {
         wxDataObject *dobj = (wxDataObject*)node->Data();

-       
+

        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {
            return dobj->GetSize();
        }
        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {
            return dobj->GetSize();
        }

-    
+

         node = node->Next();
     }
         node = node->Next();
     }

-    
+

     return 0;
 }
     return 0;
 }

-    
+

 void wxDataBroker::WriteData( wxDataFormat& format, void *dest ) const
 {
     wxNode *node = m_dataObjects.First();
     while (node)
     {
         wxDataObject *dobj = (wxDataObject*)node->Data();
 void wxDataBroker::WriteData( wxDataFormat& format, void *dest ) const
 {
     wxNode *node = m_dataObjects.First();
     while (node)
     {
         wxDataObject *dobj = (wxDataObject*)node->Data();

-       
+

        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {
        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {

-           return dobj->WriteData( dest );
+           dobj->WriteData( dest );

        }
        }

-    
+

         node = node->Next();
     }
 }
         node = node->Next();
     }
 }


@@ -246,19 +283,31 @@ IMPLEMENT_ABSTRACT_CLASS( wxDataObject, wxObject )
 
 wxDataObject::wxDataObject()
 {
 
 wxDataObject::wxDataObject()
 {

-    m_format = (wxDataFormat*) NULL;

 }
 }

-  
+

 wxDataObject::~wxDataObject()
 {
 wxDataObject::~wxDataObject()
 {

-    if (m_format) delete m_format;

 }
 
 }
 

-wxDataFormat &wxDataObject::GetFormat() const
+wxDataFormat &wxDataObject::GetFormat()

 {
 {

-    wxASSERT( m_format );
+    return m_format;
+}

 
 

-    return (*m_format);
+wxDataFormatId wxDataObject::GetFormatType() const
+{
+    return m_format.GetType();
+}
+
+wxString wxDataObject::GetFormatId() const
+{
+    return m_format.GetId();
+}
+
+GdkAtom wxDataObject::GetFormatAtom() const
+{
+    GdkAtom ret = ((wxDataObject*) this)->m_format.GetAtom();
+    return ret;

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


@@ -269,17 +318,17 @@ IMPLEMENT_DYNAMIC_CLASS( wxTextDataObject, wxDataObject )
 
 wxTextDataObject::wxTextDataObject()
 {
 
 wxTextDataObject::wxTextDataObject()
 {

-    m_format = new wxDataFormat( wxDF_TEXT );
+    m_format.SetType( wxDF_TEXT );

 }
 
 wxTextDataObject::wxTextDataObject( const wxString& data )
 {
 }
 
 wxTextDataObject::wxTextDataObject( const wxString& data )
 {

-    m_format = new wxDataFormat( wxDF_TEXT );
-    
+    m_format.SetType( wxDF_TEXT );
+

     m_data = data;
 }
 
     m_data = data;
 }
 

-void wxTextDataObject::SetText( const wxString& data ) 
+void wxTextDataObject::SetText( const wxString& data )

 {
     m_data = data;
 }
 {
     m_data = data;
 }


@@ -301,41 +350,41 @@ size_t wxTextDataObject::GetSize() const
 
 void wxTextDataObject::WriteString( const wxString &str, void *dest ) const
 {
 
 void wxTextDataObject::WriteString( const wxString &str, void *dest ) const
 {

-    memcpy( dest, m_data.c_str(), GetSize() );
+    memcpy( dest, str.mb_str(), str.Len()+1 );

 }
 }

-    
+

 // ----------------------------------------------------------------------------
 // wxFileDataObject
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS( wxFileDataObject, wxDataObject )
 
 // ----------------------------------------------------------------------------
 // wxFileDataObject
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS( wxFileDataObject, wxDataObject )
 

-wxFileDataObject::wxFileDataObject(void)
+wxFileDataObject::wxFileDataObject()

 {
 {

-    m_format = new wxDataFormat( wxDF_FILENAME );
+    m_format.SetType( wxDF_FILENAME );

 }
 
 void wxFileDataObject::AddFile( const wxString &file )
 }
 
 void wxFileDataObject::AddFile( const wxString &file )

-{ 
-    m_files += file; 
-    m_files += (char)0; 
+{
+    m_files += file;
+    m_files += (wxChar)0;

 }
 }

-    
+

 wxString wxFileDataObject::GetFiles() const
 wxString wxFileDataObject::GetFiles() const

-{ 
-    return m_files; 
+{
+    return m_files;

 }
 }

-    
+

 void wxFileDataObject::WriteData( void *dest ) const
 {
 void wxFileDataObject::WriteData( void *dest ) const
 {

-    memcpy( dest, m_files.c_str(), GetSize() );
+    memcpy( dest, m_files.mbc_str(), GetSize() );

 }
 }

- 
+

 size_t wxFileDataObject::GetSize() const
 {
     return m_files.Len() + 1;
 }
 size_t wxFileDataObject::GetSize() const
 {
     return m_files.Len() + 1;
 }

-  
+

 // ----------------------------------------------------------------------------
 // wxBitmapDataObject
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxBitmapDataObject
 // ----------------------------------------------------------------------------


@@ -344,19 +393,29 @@ IMPLEMENT_DYNAMIC_CLASS( wxBitmapDataObject, wxDataObject )
 
 wxBitmapDataObject::wxBitmapDataObject()
 {
 
 wxBitmapDataObject::wxBitmapDataObject()
 {

-    m_format = new wxDataFormat( wxDF_BITMAP );
+    m_format.SetType( wxDF_BITMAP );
+    m_pngData = (char*)NULL;
+    m_pngSize = 0;

 }
 
 wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
 {
 }
 
 wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
 {

-    m_format = new wxDataFormat( wxDF_BITMAP );
-    
+    m_format.SetType( wxDF_BITMAP );
+    m_pngData = (char*)NULL;
+    m_pngSize = 0;

     m_bitmap = bitmap;
     m_bitmap = bitmap;

+    DoConvertToPng();
+}
+
+wxBitmapDataObject::~wxBitmapDataObject()
+{
+    if (m_pngData) delete[] m_pngData;

 }
 
 void wxBitmapDataObject::SetBitmap( const wxBitmap &bitmap )
 {
     m_bitmap = bitmap;
 }
 
 void wxBitmapDataObject::SetBitmap( const wxBitmap &bitmap )
 {
     m_bitmap = bitmap;

+    DoConvertToPng();

 }
 
 wxBitmap wxBitmapDataObject::GetBitmap() const
 }
 
 wxBitmap wxBitmapDataObject::GetBitmap() const


@@ -371,61 +430,77 @@ void wxBitmapDataObject::WriteData( void *dest ) const
 
 size_t wxBitmapDataObject::GetSize() const
 {
 
 size_t wxBitmapDataObject::GetSize() const
 {

-    return 0;
+    return m_pngSize;
+}
+
+void wxBitmapDataObject::WriteBitmap( const wxBitmap &WXUNUSED(bitmap), void *dest ) const
+{
+//    if (m_bitmap == bitmap)
+        memcpy( dest, m_pngData, m_pngSize );

 }
 
 }
 

-void wxBitmapDataObject::WriteBitmap( const wxBitmap &bitmap, void *dest ) const
+void wxBitmapDataObject::SetPngData( const char *pngData, size_t pngSize )

 {
 {

-    memcpy( dest, m_bitmap.GetPixmap(), GetSize() );
+    if (m_pngData) delete[] m_pngData;
+    m_pngData = (char*) NULL;
+    m_pngSize = pngSize;
+    m_pngData = new char[m_pngSize];
+    memcpy( m_pngData, pngData, m_pngSize );
+    
+    wxMemoryInputStream mstream( pngData, pngSize );
+    wxImage image;
+    wxPNGHandler handler;
+    handler.LoadFile( &image, mstream );
+    m_bitmap = image.ConvertToBitmap();

 }
 }

+
+void wxBitmapDataObject::DoConvertToPng()
+{
+    if (m_pngData) delete[] m_pngData;
+    
+    wxImage image( m_bitmap );
+    wxPNGHandler handler;
+    
+    wxCountingOutputStream count;
+    handler.SaveFile( &image, count );
+    m_pngSize = count.GetSize() + 100; // sometimes the size seems to vary ???
+    m_pngData = new char[m_pngSize];

     
     

+    wxMemoryOutputStream mstream( m_pngData, m_pngSize );
+    handler.SaveFile( &image, mstream );
+}
+

 // ----------------------------------------------------------------------------
 // wxPrivateDataObject
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
 
 // ----------------------------------------------------------------------------
 // wxPrivateDataObject
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
 

-wxPrivateDataObject::wxPrivateDataObject() 
-{ 
-    m_id = "application/";
-    m_id += wxTheApp->GetAppName();
-    
-    m_format = new wxDataFormat( m_id );
-    
-    m_size = 0; 
-    m_data = (char*) NULL; 
-}
-    
-wxPrivateDataObject::~wxPrivateDataObject()
-{ 
-    if (m_data) delete[] m_data; 
-}
-  
-void wxPrivateDataObject::SetId( const wxString& id )
-{ 
-    m_id = id;
-    m_format->SetId( m_id );
-}
-    
-wxString wxPrivateDataObject::GetId() const
-{ 
-    return m_id; 
+void wxPrivateDataObject::Free()
+{
+    if ( m_data )
+        free(m_data);

 }
 
 }
 

-void wxPrivateDataObject::SetData( const char *data, size_t size )
+wxPrivateDataObject::wxPrivateDataObject()

 {
 {

-    m_size = size;
-    
-    if (m_data) delete[] m_data;
-    
-    m_data = new char[size];
+    wxString id = T("application/");
+    id += wxTheApp->GetAppName();
+
+    m_format.SetId( id );

 
 

-    memcpy( m_data, data, size );  
+    m_size = 0;
+    m_data = (void *)NULL;

 }
 
 }
 

-char* wxPrivateDataObject::GetData() const
+void wxPrivateDataObject::SetData( const void *data, size_t size )

 {
 {

-    return m_data;
+    Free();
+
+    m_size = size;
+    m_data = malloc(size);
+
+    memcpy( m_data, data, size );

 }
 
 void wxPrivateDataObject::WriteData( void *dest ) const
 }
 
 void wxPrivateDataObject::WriteData( void *dest ) const


@@ -435,10 +510,10 @@ void wxPrivateDataObject::WriteData( void *dest ) const
 
 size_t wxPrivateDataObject::GetSize() const
 {
 
 size_t wxPrivateDataObject::GetSize() const
 {

-   return m_size;
+    return m_size;

 }
 
 }
 

-void wxPrivateDataObject::WriteData( const char *data, void *dest ) const
+void wxPrivateDataObject::WriteData( const void *data, void *dest ) const

 {
     memcpy( dest, data, GetSize() );
 }
 {
     memcpy( dest, data, GetSize() );
 }