warning fixed

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

diff --git a/src/gtk/dataobj.cpp b/src/gtk/dataobj.cpp
index 246e603722921806ec760265806a6c5a9a72481c..d1668eb212137f57b74919e59e366fd0db5aa687 100644 (file)
--- a/src/gtk/dataobj.cpp
+++ b/src/gtk/dataobj.cpp
@@ -4,16 +4,18 @@
 // 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"
 


@@ -23,6 +25,7 @@
 //-------------------------------------------------------------------------
 
 GdkAtom  g_textAtom        = 0;
 //-------------------------------------------------------------------------
 
 GdkAtom  g_textAtom        = 0;

+GdkAtom  g_pngAtom         = 0;

 
 //-------------------------------------------------------------------------
 // wxDataFormat
 
 //-------------------------------------------------------------------------
 // wxDataFormat


@@ -32,46 +35,46 @@ IMPLEMENT_CLASS(wxDataFormat, wxObject)
 
 wxDataFormat::wxDataFormat()
 {
 
 wxDataFormat::wxDataFormat()
 {

-    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    PrepareFormats();

     m_type = wxDF_INVALID;
     m_hasAtom = FALSE;
     m_atom = (GdkAtom) 0;
 }
 
     m_type = wxDF_INVALID;
     m_hasAtom = FALSE;
     m_atom = (GdkAtom) 0;
 }
 

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

 {
 {

-    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    PrepareFormats();

     SetType( type );
 }
 
 wxDataFormat::wxDataFormat( const wxChar *id )
 {
     SetType( type );
 }
 
 wxDataFormat::wxDataFormat( const wxChar *id )
 {

-    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    PrepareFormats();

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

-    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    PrepareFormats();

     SetId( id );
 }
 
     SetId( id );
 }
 

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

 {
 {

-    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    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 )
 {

-    if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    PrepareFormats();

     m_hasAtom = TRUE;
     m_hasAtom = TRUE;

-    
+

     m_atom = atom;
     m_atom = atom;

-    
+

     if (m_atom == g_textAtom)
     {
         m_type = wxDF_TEXT;
     if (m_atom == g_textAtom)
     {
         m_type = wxDF_TEXT;


@@ -83,41 +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 == _T("file:ALL"))
+
+       if (m_id == wxT("file:ALL"))

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

-void wxDataFormat::SetType( wxDataType type )
+void wxDataFormat::SetType( wxDataFormatId type )

 {
     m_type = type;
 {
     m_type = type;

-    
+

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

-        m_id = _T("STRING");
-    } 
+        m_id = wxT("STRING");
+    }

     else
     if (m_type == wxDF_BITMAP)
     {
     else
     if (m_type == wxDF_BITMAP)
     {

-        m_id = _T("BITMAP");
-    } 
+        m_id = wxT("image/png");
+    }

     else
     if (m_type == wxDF_FILENAME)
     {
     else
     if (m_type == wxDF_FILENAME)
     {

-        m_id = _T("file:ALL");
+        m_id = wxT("file:ALL");

     }
     else
     {
     }
     else
     {

-       wxFAIL_MSG( _T("invalid dataformat") );
+       wxFAIL_MSG( wxT("invalid dataformat") );

     }
     }

-    
+

     m_hasAtom = FALSE;
 }
     m_hasAtom = FALSE;
 }

-  
-wxDataType wxDataFormat::GetType() const
+
+wxDataFormatId wxDataFormat::GetType() const

 {
     return m_type;
 }
 {
     return m_type;
 }


@@ -139,7 +142,7 @@ GdkAtom wxDataFormat::GetAtom()
     if (!m_hasAtom)
     {
         m_hasAtom = TRUE;
     if (!m_hasAtom)
     {
         m_hasAtom = TRUE;

-       
+

        if (m_type == wxDF_TEXT)
        {
             m_atom = g_textAtom;
        if (m_type == wxDF_TEXT)
        {
             m_atom = g_textAtom;


@@ -148,120 +151,126 @@ GdkAtom wxDataFormat::GetAtom()
         if (m_type == wxDF_BITMAP)
         {
             m_atom = GDK_TARGET_BITMAP;
         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( MBSTRINGCAST m_id.mbc_str(), 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())
        {
            dobj->WriteData( dest );
        }
        if (dobj->GetFormat().GetAtom() == format.GetAtom())
        {
            dobj->WriteData( dest );
        }

-    
+

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


@@ -275,7 +284,7 @@ IMPLEMENT_ABSTRACT_CLASS( wxDataObject, wxObject )
 wxDataObject::wxDataObject()
 {
 }
 wxDataObject::wxDataObject()
 {
 }

-  
+

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


@@ -285,7 +294,7 @@ wxDataFormat &wxDataObject::GetFormat()
     return m_format;
 }
 
     return m_format;
 }
 

-wxDataType wxDataObject::GetFormatType() const
+wxDataFormatId wxDataObject::GetFormatType() const

 {
     return m_format.GetType();
 }
 {
     return m_format.GetType();
 }


@@ -299,7 +308,7 @@ GdkAtom wxDataObject::GetFormatAtom() const
 {
     GdkAtom ret = ((wxDataObject*) this)->m_format.GetAtom();
     return ret;
 {
     GdkAtom ret = ((wxDataObject*) this)->m_format.GetAtom();
     return ret;

-}  
+}

 
 // ----------------------------------------------------------------------------
 // wxTextDataObject
 
 // ----------------------------------------------------------------------------
 // wxTextDataObject


@@ -315,11 +324,11 @@ wxTextDataObject::wxTextDataObject()
 wxTextDataObject::wxTextDataObject( const wxString& data )
 {
     m_format.SetType( wxDF_TEXT );
 wxTextDataObject::wxTextDataObject( const wxString& data )
 {
     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;
 }


@@ -341,9 +350,9 @@ 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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxFileDataObject
 // ----------------------------------------------------------------------------


@@ -356,26 +365,26 @@ wxFileDataObject::wxFileDataObject()
 }
 
 void wxFileDataObject::AddFile( const wxString &file )
 }
 
 void wxFileDataObject::AddFile( const wxString &file )

-{ 
-    m_files += file; 
-    m_files += (wxChar)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
 // ----------------------------------------------------------------------------


@@ -385,18 +394,28 @@ IMPLEMENT_DYNAMIC_CLASS( wxBitmapDataObject, wxDataObject )
 wxBitmapDataObject::wxBitmapDataObject()
 {
     m_format.SetType( wxDF_BITMAP );
 wxBitmapDataObject::wxBitmapDataObject()
 {
     m_format.SetType( wxDF_BITMAP );

+    m_pngData = (char*)NULL;
+    m_pngSize = 0;

 }
 
 wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
 {
     m_format.SetType( wxDF_BITMAP );
 }
 
 wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& 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


@@ -411,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 &bitmap, void *dest ) const
+void wxBitmapDataObject::WriteBitmap( const wxBitmap &WXUNUSED(bitmap), void *dest ) const

 {
 {

-    memcpy( dest, m_bitmap.GetPixmap(), GetSize() );
+//    if (m_bitmap == bitmap)
+        memcpy( dest, m_pngData, m_pngSize );

 }
 }

+
+void wxBitmapDataObject::SetPngData( const char *pngData, size_t pngSize )
+{
+    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 = _T("application/");
-    m_id += wxTheApp->GetAppName();
-    
-    m_format.SetId( 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 = wxT("application/");
+    id += wxTheApp->GetAppName();

 
 

-    memcpy( m_data, data, size );  
+    m_format.SetId( id );
+
+    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


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