avoiding nesting dcs on the same window concurrently

[wxWidgets.git] / src / generic / animateg.cpp

diff --git a/src/generic/animateg.cpp b/src/generic/animateg.cpp
index 90cb3cae6a0416ed63b1124319505ca426bdf88b..1bda5864672ae4de05eeac00772664cdf65140d1 100644 (file)
--- a/src/generic/animateg.cpp
+++ b/src/generic/animateg.cpp
@@ -15,28 +15,28 @@
   #pragma hdrstop
 #endif  //__BORLANDC__
 
   #pragma hdrstop
 #endif  //__BORLANDC__
 

+#if wxUSE_ANIMATIONCTRL && (!defined(__WXGTK20__) || defined(__WXUNIVERSAL__))

 
 

-#if wxUSE_ANIMATIONCTRL
+#include "wx/animate.h"
+
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/image.h"
+    #include "wx/dcmemory.h"
+    #include "wx/dcclient.h"
+    #include "wx/module.h"
+#endif

 
 

-#include "wx/log.h"

 #include "wx/wfstream.h"
 #include "wx/wfstream.h"

-#include "wx/image.h"

 #include "wx/gifdecod.h"
 #include "wx/anidecod.h"
 #include "wx/gifdecod.h"
 #include "wx/anidecod.h"

-#include "wx/dcmemory.h"
-#include "wx/dc.h"
-#include "wx/dcclient.h"
-#include "wx/animate.h"
-#include "wx/animdecod.h"

 
 

-
-#include <wx/listimpl.cpp>
-WX_DEFINE_LIST(wxAnimationDecoderList);
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxAnimationDecoderList)

 
 wxAnimationDecoderList wxAnimation::sm_handlers;
 
 
 
 wxAnimationDecoderList wxAnimation::sm_handlers;
 
 

-

 // ----------------------------------------------------------------------------
 // wxAnimation
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxAnimation
 // ----------------------------------------------------------------------------


@@ -82,6 +82,13 @@ wxPoint wxAnimation::GetFramePosition(size_t frame) const
     return M_ANIMDATA->GetFramePosition(frame);
 }
 
     return M_ANIMDATA->GetFramePosition(frame);
 }
 

+wxSize wxAnimation::GetFrameSize(size_t frame) const
+{
+    wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid animation") );
+
+    return M_ANIMDATA->GetFrameSize(frame);
+}
+

 wxAnimationDisposal wxAnimation::GetDisposalMethod(size_t frame) const
 {
     wxCHECK_MSG( IsOk(), wxANIM_UNSPECIFIED, wxT("invalid animation") );
 wxAnimationDisposal wxAnimation::GetDisposalMethod(size_t frame) const
 {
     wxCHECK_MSG( IsOk(), wxANIM_UNSPECIFIED, wxT("invalid animation") );


@@ -89,6 +96,13 @@ wxAnimationDisposal wxAnimation::GetDisposalMethod(size_t frame) const
     return M_ANIMDATA->GetDisposalMethod(frame);
 }
 
     return M_ANIMDATA->GetDisposalMethod(frame);
 }
 

+wxColour wxAnimation::GetTransparentColour(size_t frame) const
+{
+    wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") );
+
+    return M_ANIMDATA->GetTransparentColour(frame);
+}
+

 wxColour wxAnimation::GetBackgroundColour() const
 {
     wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") );
 wxColour wxAnimation::GetBackgroundColour() const
 {
     wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") );


@@ -99,7 +113,7 @@ wxColour wxAnimation::GetBackgroundColour() const
 bool wxAnimation::LoadFile(const wxString& filename, wxAnimationType type)
 {
     wxFileInputStream stream(filename);
 bool wxAnimation::LoadFile(const wxString& filename, wxAnimationType type)
 {
     wxFileInputStream stream(filename);

-    if (!stream.Ok())
+    if ( !stream.IsOk() )

         return false;
 
     return Load(stream, type);
         return false;
 
     return Load(stream, type);


@@ -112,7 +126,7 @@ bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
     const wxAnimationDecoder *handler;
     if ( type == wxANIMATION_TYPE_ANY )
     {
     const wxAnimationDecoder *handler;
     if ( type == wxANIMATION_TYPE_ANY )
     {

-        for ( wxAnimationDecoderList::compatibility_iterator node = sm_handlers.GetFirst(); 
+        for ( wxAnimationDecoderList::compatibility_iterator node = sm_handlers.GetFirst();

               node; node = node->GetNext() )
         {
             handler=(const wxAnimationDecoder*)node->GetData();
               node; node = node->GetNext() )
         {
             handler=(const wxAnimationDecoder*)node->GetData();


@@ -209,8 +223,12 @@ const wxAnimationDecoder *wxAnimation::FindHandler( wxAnimationType animType )
 
 void wxAnimation::InitStandardHandlers()
 {
 
 void wxAnimation::InitStandardHandlers()
 {

+#if wxUSE_GIF

     AddHandler(new wxGIFDecoder);
     AddHandler(new wxGIFDecoder);

+#endif // wxUSE_GIF
+#if wxUSE_ICO_CUR

     AddHandler(new wxANIDecoder);
     AddHandler(new wxANIDecoder);

+#endif // wxUSE_ICO_CUR

 }
 
 void wxAnimation::CleanUpHandlers()
 }
 
 void wxAnimation::CleanUpHandlers()


@@ -244,8 +262,6 @@ public:
 IMPLEMENT_DYNAMIC_CLASS(wxAnimationModule, wxModule)
 
 
 IMPLEMENT_DYNAMIC_CLASS(wxAnimationModule, wxModule)
 
 

-
-

 // ----------------------------------------------------------------------------
 // wxAnimationCtrl
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxAnimationCtrl
 // ----------------------------------------------------------------------------


@@ -257,18 +273,25 @@ BEGIN_EVENT_TABLE(wxAnimationCtrl, wxAnimationCtrlBase)
     EVT_TIMER(wxID_ANY, wxAnimationCtrl::OnTimer)
 END_EVENT_TABLE()
 
     EVT_TIMER(wxID_ANY, wxAnimationCtrl::OnTimer)
 END_EVENT_TABLE()
 

+void wxAnimationCtrl::Init()
+{
+    m_currentFrame = 0;
+    m_looped = false;
+    m_isPlaying = false;
+
+    // use the window background colour by default to be consistent
+    // with the GTK+ native version
+    m_useWinBackgroundColour = true;
+}
+

 bool wxAnimationCtrl::Create(wxWindow *parent, wxWindowID id,
             const wxAnimation& animation, const wxPoint& pos,
             const wxSize& size, long style, const wxString& name)
 {
     m_animation = animation;
 bool wxAnimationCtrl::Create(wxWindow *parent, wxWindowID id,
             const wxAnimation& animation, const wxPoint& pos,
             const wxSize& size, long style, const wxString& name)
 {
     m_animation = animation;

-    m_currentFrame = 0;
-    m_looped = true;
-    m_isPlaying = false;
-    m_useWinBackgroundColour = false;

     m_timer.SetOwner(this);
 
     m_timer.SetOwner(this);
 

-    if (!wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name))
+    if (!base_type::Create(parent, id, pos, size, style, wxDefaultValidator, name))

         return false;
 
     // by default we get the same background colour of our parent
         return false;
 
     // by default we get the same background colour of our parent


@@ -284,7 +307,7 @@ wxAnimationCtrl::~wxAnimationCtrl()
 bool wxAnimationCtrl::LoadFile(const wxString& filename, wxAnimationType type)
 {
     wxAnimation anim;
 bool wxAnimationCtrl::LoadFile(const wxString& filename, wxAnimationType type)
 {
     wxAnimation anim;

-    if (!anim.LoadFile(filename, type) || 
+    if (!anim.LoadFile(filename, type) ||

         !anim.IsOk())
         return false;
 
         !anim.IsOk())
         return false;
 


@@ -315,10 +338,16 @@ void wxAnimationCtrl::SetAnimation(const wxAnimation& animation)
     // display first frame
     m_currentFrame = 0;
     if (m_animation.IsOk())
     // display first frame
     m_currentFrame = 0;
     if (m_animation.IsOk())

-        RebuildBackingStoreUpToFrame(0);
+    {
+        if (!RebuildBackingStoreUpToFrame(0))
+        {
+            m_animation = wxNullAnimation;
+            return;
+        }
+    }

     else
     {
     else
     {

-        // clear to 
+        // clear to

         wxMemoryDC dc;
         dc.SelectObject(m_backingStore);
 
         wxMemoryDC dc;
         dc.SelectObject(m_backingStore);
 


@@ -354,12 +383,14 @@ bool wxAnimationCtrl::Play(bool looped)
     int oldframe = m_currentFrame;
     m_looped = looped;
     m_currentFrame = 0;
     int oldframe = m_currentFrame;
     m_looped = looped;
     m_currentFrame = 0;

-    m_isPlaying = true;

 
     // small optimization: if the back store was already updated to the
     // first frame, don't rebuild it
     if (oldframe != 0)
 
     // small optimization: if the back store was already updated to the
     // first frame, don't rebuild it
     if (oldframe != 0)

-        RebuildBackingStoreUpToFrame(0);
+        if (!RebuildBackingStoreUpToFrame(0))
+            return false;
+
+    m_isPlaying = true;

 
     // DrawCurrentFrame() will use our updated backing store
     wxClientDC clientDC(this);
 
     // DrawCurrentFrame() will use our updated backing store
     wxClientDC clientDC(this);


@@ -380,7 +411,7 @@ bool wxAnimationCtrl::Play(bool looped)
 // wxAnimationCtrl - rendering methods
 // ----------------------------------------------------------------------------
 
 // wxAnimationCtrl - rendering methods
 // ----------------------------------------------------------------------------
 

-void wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
+bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)

 {
     // if we've not created the backing store yet or it's too
     // small, then recreate it
 {
     // if we've not created the backing store yet or it's too
     // small, then recreate it


@@ -389,10 +420,11 @@ void wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
     int w = wxMin(sz.GetWidth(), winsz.GetWidth());
     int h = wxMin(sz.GetHeight(), winsz.GetHeight());
 
     int w = wxMin(sz.GetWidth(), winsz.GetWidth());
     int h = wxMin(sz.GetHeight(), winsz.GetHeight());
 

-    if ( !m_backingStore.Ok() ||
+    if ( !m_backingStore.IsOk() ||

             m_backingStore.GetWidth() < w || m_backingStore.GetHeight() < h )
     {
             m_backingStore.GetWidth() < w || m_backingStore.GetHeight() < h )
     {

-        m_backingStore.Create(w, h);
+        if (!m_backingStore.Create(w, h))
+            return false;

     }
 
     wxMemoryDC dc;
     }
 
     wxMemoryDC dc;


@@ -409,11 +441,16 @@ void wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
         {
             DrawFrame(dc, i);
         }
         {
             DrawFrame(dc, i);
         }

+        else if (m_animation.GetDisposalMethod(i) == wxANIM_TOBACKGROUND)
+            DisposeToBackground(dc, m_animation.GetFramePosition(i),
+                                    m_animation.GetFrameSize(i));

     }
 
     // finally draw this frame
     DrawFrame(dc, frame);
     dc.SelectObject(wxNullBitmap);
     }
 
     // finally draw this frame
     DrawFrame(dc, frame);
     dc.SelectObject(wxNullBitmap);

+
+    return true;

 }
 
 void wxAnimationCtrl::IncrementalUpdateBackingStore()
 }
 
 void wxAnimationCtrl::IncrementalUpdateBackingStore()


@@ -437,14 +474,15 @@ void wxAnimationCtrl::IncrementalUpdateBackingStore()
         switch (m_animation.GetDisposalMethod(m_currentFrame-1))
         {
         case wxANIM_TOBACKGROUND:
         switch (m_animation.GetDisposalMethod(m_currentFrame-1))
         {
         case wxANIM_TOBACKGROUND:

-            DisposeToBackground(dc);
+            DisposeToBackground(dc, m_animation.GetFramePosition(m_currentFrame-1),
+                                    m_animation.GetFrameSize(m_currentFrame-1));

             break;
 
         case wxANIM_TOPREVIOUS:
             // this disposal should never be used too often.
             // E.g. GIF specification explicitely say to keep the usage of this
             break;
 
         case wxANIM_TOPREVIOUS:
             // this disposal should never be used too often.
             // E.g. GIF specification explicitely say to keep the usage of this

-            //      disposal limited to the minimum. 
-            // In fact it may require a lot of time to restore 
+            //      disposal limited to the minimum.
+            // In fact it may require a lot of time to restore

             if (m_currentFrame == 1)
             {
                 // if 0-th frame disposal is to restore to previous frame,
             if (m_currentFrame == 1)
             {
                 // if 0-th frame disposal is to restore to previous frame,


@@ -452,7 +490,8 @@ void wxAnimationCtrl::IncrementalUpdateBackingStore()
                 DisposeToBackground(dc);
             }
             else
                 DisposeToBackground(dc);
             }
             else

-                RebuildBackingStoreUpToFrame(m_currentFrame-2);
+                if (!RebuildBackingStoreUpToFrame(m_currentFrame-2))
+                    Stop();

             break;
 
         case wxANIM_DONOTREMOVE:
             break;
 
         case wxANIM_DONOTREMOVE:


@@ -481,20 +520,33 @@ void wxAnimationCtrl::DrawFrame(wxDC &dc, size_t frame)
 
 void wxAnimationCtrl::DrawCurrentFrame(wxDC& dc)
 {
 
 void wxAnimationCtrl::DrawCurrentFrame(wxDC& dc)
 {

-    wxASSERT(m_backingStore.Ok());
+    wxASSERT( m_backingStore.IsOk() );

 
     // m_backingStore always contains the current frame
     dc.DrawBitmap(m_backingStore, 0, 0);
 }
 
 void wxAnimationCtrl::DisposeToBackground(wxDC& dc)
 
     // m_backingStore always contains the current frame
     dc.DrawBitmap(m_backingStore, 0, 0);
 }
 
 void wxAnimationCtrl::DisposeToBackground(wxDC& dc)

-{
-    wxBrush brush(IsUsingWindowBackgroundColour() ? 
-                  this->GetBackgroundColour() : m_animation.GetBackgroundColour(), wxSOLID);
+{ 
+    wxColour col = IsUsingWindowBackgroundColour()
+                    ? GetBackgroundColour()
+                    : m_animation.GetBackgroundColour();
+    wxBrush brush(col);

     dc.SetBackground(brush);
     dc.Clear();
 }
 
     dc.SetBackground(brush);
     dc.Clear();
 }
 

+void wxAnimationCtrl::DisposeToBackground(wxDC& dc, const wxPoint &pos, const wxSize &sz)
+{
+    wxColour col = IsUsingWindowBackgroundColour()
+                    ? GetBackgroundColour()
+                    : m_animation.GetBackgroundColour();
+    wxBrush brush(col);
+    dc.SetBrush(brush);         // SetBrush and not SetBackground !!
+    dc.SetPen(*wxTRANSPARENT_PEN);
+    dc.DrawRectangle(pos, sz);
+}
+

 // ----------------------------------------------------------------------------
 // wxAnimationCtrl - event handlers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxAnimationCtrl - event handlers
 // ----------------------------------------------------------------------------


@@ -505,7 +557,7 @@ void wxAnimationCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
     wxPaintDC dc(this);
 
     // both if we are playing or not, we need to refresh the current frame
     wxPaintDC dc(this);
 
     // both if we are playing or not, we need to refresh the current frame

-    if (m_backingStore.Ok())
+    if ( m_backingStore.IsOk() )

         DrawCurrentFrame(dc);
     //else: m_animation is not valid and thus we don't have a valid backing store...
 }
         DrawCurrentFrame(dc);
     //else: m_animation is not valid and thus we don't have a valid backing store...
 }


@@ -531,6 +583,11 @@ void wxAnimationCtrl::OnTimer(wxTimerEvent &WXUNUSED(event))
     wxClientDC dc(this);
     DrawCurrentFrame(dc);
 
     wxClientDC dc(this);
     DrawCurrentFrame(dc);
 

+#ifdef __WXMAC__
+    // without this, the animation currently doesn't redraw under Mac
+    Refresh();
+#endif // __WXMAC__
+

     // Set the timer for the next frame
     int delay = m_animation.GetDelay(m_currentFrame);
     if (delay == 0)
     // Set the timer for the next frame
     int delay = m_animation.GetDelay(m_currentFrame);
     if (delay == 0)


@@ -544,7 +601,8 @@ void wxAnimationCtrl::OnSize(wxSizeEvent &WXUNUSED(event))
     //     for big animations as the backing store must be
     //     extended and rebuilt. Try to avoid it!!
     if (m_animation.IsOk())
     //     for big animations as the backing store must be
     //     extended and rebuilt. Try to avoid it!!
     if (m_animation.IsOk())

-        RebuildBackingStoreUpToFrame(m_currentFrame);
+        if (!RebuildBackingStoreUpToFrame(m_currentFrame))
+            Stop();     // in case we are playing

 }
 
 #endif      // wxUSE_ANIMATIONCTRL
 }
 
 #endif      // wxUSE_ANIMATIONCTRL