Implement wxStaticBitmap.

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

diff --git a/src/generic/animateg.cpp b/src/generic/animateg.cpp
index 1bda5864672ae4de05eeac00772664cdf65140d1..d860f2d487f03f290a2a6bcab89285488bbe7eed 100644 (file)
--- a/src/generic/animateg.cpp
+++ b/src/generic/animateg.cpp
@@ -51,14 +51,14 @@ wxSize wxAnimation::GetSize() const
     return M_ANIMDATA->GetAnimationSize();
 }
 
     return M_ANIMDATA->GetAnimationSize();
 }
 

-size_t wxAnimation::GetFrameCount() const
+unsigned int wxAnimation::GetFrameCount() const

 {
     wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
 
     return M_ANIMDATA->GetFrameCount();
 }
 
 {
     wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
 
     return M_ANIMDATA->GetFrameCount();
 }
 

-wxImage wxAnimation::GetFrame(size_t i) const
+wxImage wxAnimation::GetFrame(unsigned int i) const

 {
     wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid animation") );
 
 {
     wxCHECK_MSG( IsOk(), wxNullImage, wxT("invalid animation") );
 


@@ -68,35 +68,35 @@ wxImage wxAnimation::GetFrame(size_t i) const
     return ret;
 }
 
     return ret;
 }
 

-int wxAnimation::GetDelay(size_t i) const
+int wxAnimation::GetDelay(unsigned int i) const

 {
     wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
 
     return M_ANIMDATA->GetDelay(i);
 }
 
 {
     wxCHECK_MSG( IsOk(), 0, wxT("invalid animation") );
 
     return M_ANIMDATA->GetDelay(i);
 }
 

-wxPoint wxAnimation::GetFramePosition(size_t frame) const
+wxPoint wxAnimation::GetFramePosition(unsigned int frame) const

 {
     wxCHECK_MSG( IsOk(), wxDefaultPosition, wxT("invalid animation") );
 
     return M_ANIMDATA->GetFramePosition(frame);
 }
 
 {
     wxCHECK_MSG( IsOk(), wxDefaultPosition, wxT("invalid animation") );
 
     return M_ANIMDATA->GetFramePosition(frame);
 }
 

-wxSize wxAnimation::GetFrameSize(size_t frame) const
+wxSize wxAnimation::GetFrameSize(unsigned int frame) const

 {
     wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid animation") );
 
     return M_ANIMDATA->GetFrameSize(frame);
 }
 
 {
     wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid animation") );
 
     return M_ANIMDATA->GetFrameSize(frame);
 }
 

-wxAnimationDisposal wxAnimation::GetDisposalMethod(size_t frame) const
+wxAnimationDisposal wxAnimation::GetDisposalMethod(unsigned int frame) const

 {
     wxCHECK_MSG( IsOk(), wxANIM_UNSPECIFIED, wxT("invalid animation") );
 
     return M_ANIMDATA->GetDisposalMethod(frame);
 }
 
 {
     wxCHECK_MSG( IsOk(), wxANIM_UNSPECIFIED, wxT("invalid animation") );
 
     return M_ANIMDATA->GetDisposalMethod(frame);
 }
 

-wxColour wxAnimation::GetTransparentColour(size_t frame) const
+wxColour wxAnimation::GetTransparentColour(unsigned int frame) const

 {
     wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") );
 
 {
     wxCHECK_MSG( IsOk(), wxNullColour, wxT("invalid animation") );
 


@@ -147,10 +147,6 @@ bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
 
     handler = FindHandler(type);
 
 
     handler = FindHandler(type);
 

-    // do a copy of the handler from the static list which we will own
-    // as our reference data
-    m_refData = handler->Clone();
-

     if (handler == NULL)
     {
         wxLogWarning( _("No animation handler for type %ld defined."), type );
     if (handler == NULL)
     {
         wxLogWarning( _("No animation handler for type %ld defined."), type );


@@ -158,6 +154,11 @@ bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
         return false;
     }
 
         return false;
     }
 

+
+    // do a copy of the handler from the static list which we will own
+    // as our reference data
+    m_refData = handler->Clone();
+

     if (stream.IsSeekable() && !M_ANIMDATA->CanRead(stream))
     {
         wxLogError(_("Animation file is not of type %ld."), type);
     if (stream.IsSeekable() && !M_ANIMDATA->CanRead(stream))
     {
         wxLogError(_("Animation file is not of type %ld."), type);


@@ -185,7 +186,6 @@ void wxAnimation::AddHandler( wxAnimationDecoder *handler )
         // for preventing duplicate additions.  If someone ever has
         // a good reason to add and remove duplicate handlers (and they
         // may) we should probably refcount the duplicates.
         // for preventing duplicate additions.  If someone ever has
         // a good reason to add and remove duplicate handlers (and they
         // may) we should probably refcount the duplicates.

-        //   also an issue in InsertHandler below.

 
         wxLogDebug( _T("Adding duplicate animation handler for '%d' type"),
                     handler->GetType() );
 
         wxLogDebug( _T("Adding duplicate animation handler for '%d' type"),
                     handler->GetType() );


@@ -255,8 +255,8 @@ class wxAnimationModule: public wxModule
 DECLARE_DYNAMIC_CLASS(wxAnimationModule)
 public:
     wxAnimationModule() {}
 DECLARE_DYNAMIC_CLASS(wxAnimationModule)
 public:
     wxAnimationModule() {}

-    bool OnInit() { wxAnimation::InitStandardHandlers(); return true; };
-    void OnExit() { wxAnimation::CleanUpHandlers(); };
+    bool OnInit() { wxAnimation::InitStandardHandlers(); return true; }
+    void OnExit() { wxAnimation::CleanUpHandlers(); }

 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxAnimationModule, wxModule)
 };
 
 IMPLEMENT_DYNAMIC_CLASS(wxAnimationModule, wxModule)


@@ -288,7 +288,6 @@ bool wxAnimationCtrl::Create(wxWindow *parent, wxWindowID id,
             const wxAnimation& animation, const wxPoint& pos,
             const wxSize& size, long style, const wxString& name)
 {
             const wxAnimation& animation, const wxPoint& pos,
             const wxSize& size, long style, const wxString& name)
 {

-    m_animation = animation;

     m_timer.SetOwner(this);
 
     if (!base_type::Create(parent, id, pos, size, style, wxDefaultValidator, name))
     m_timer.SetOwner(this);
 
     if (!base_type::Create(parent, id, pos, size, style, wxDefaultValidator, name))


@@ -296,6 +295,9 @@ bool wxAnimationCtrl::Create(wxWindow *parent, wxWindowID id,
 
     // by default we get the same background colour of our parent
     SetBackgroundColour(parent->GetBackgroundColour());
 
     // by default we get the same background colour of our parent
     SetBackgroundColour(parent->GetBackgroundColour());

+
+    SetAnimation(animation);
+

     return true;
 }
 
     return true;
 }
 


@@ -328,34 +330,33 @@ void wxAnimationCtrl::SetAnimation(const wxAnimation& animation)
     if (IsPlaying())
         Stop();
 
     if (IsPlaying())
         Stop();
 

+    // set new animation even if it's wxNullAnimation

     m_animation = animation;
     m_animation = animation;

+    if (!m_animation.IsOk())
+    {
+        DisplayStaticImage();
+        return;
+    }

 
     if (m_animation.GetBackgroundColour() == wxNullColour)
         SetUseWindowBackgroundColour();
     if (!this->HasFlag(wxAC_NO_AUTORESIZE))
         FitToAnimation();
 
 
     if (m_animation.GetBackgroundColour() == wxNullColour)
         SetUseWindowBackgroundColour();
     if (!this->HasFlag(wxAC_NO_AUTORESIZE))
         FitToAnimation();
 

-    // display first frame
-    m_currentFrame = 0;
-    if (m_animation.IsOk())
-    {
-        if (!RebuildBackingStoreUpToFrame(0))
-        {
-            m_animation = wxNullAnimation;
-            return;
-        }
-    }
-    else
-    {
-        // clear to
-        wxMemoryDC dc;
-        dc.SelectObject(m_backingStore);
+    DisplayStaticImage();
+}

 
 

-        // Draw the background
-        DisposeToBackground(dc);
-    }
+void wxAnimationCtrl::SetInactiveBitmap(const wxBitmap &bmp)
+{
+    // if the bitmap has an associated mask, we need to set our background to
+    // the colour of our parent otherwise when calling DrawCurrentFrame()
+    // (which uses the bitmap's mask), our background colour would be used for
+    // transparent areas - and that's not what we want (at least for
+    // consistency with the GTK version)
+    if ( bmp.GetMask() != NULL && GetParent() != NULL )
+        SetBackgroundColour(GetParent()->GetBackgroundColour());

 
 

-    Refresh();
+    wxAnimationCtrlBase::SetInactiveBitmap(bmp);

 }
 
 void wxAnimationCtrl::FitToAnimation()
 }
 
 void wxAnimationCtrl::FitToAnimation()


@@ -363,6 +364,19 @@ void wxAnimationCtrl::FitToAnimation()
     SetSize(m_animation.GetSize());
 }
 
     SetSize(m_animation.GetSize());
 }
 

+bool wxAnimationCtrl::SetBackgroundColour(const wxColour& colour)
+{
+    if ( !wxWindow::SetBackgroundColour(colour) )
+        return false;
+
+    // if not playing, then this change must be seen immediately (unless
+    // there's an inactive bitmap set which has higher priority than bg colour)
+    if ( !IsPlaying() )
+        DisplayStaticImage();
+
+    return true;
+}
+

 
 // ----------------------------------------------------------------------------
 // wxAnimationCtrl - stop/play methods
 
 // ----------------------------------------------------------------------------
 // wxAnimationCtrl - stop/play methods


@@ -370,9 +384,13 @@ void wxAnimationCtrl::FitToAnimation()
 
 void wxAnimationCtrl::Stop()
 {
 
 void wxAnimationCtrl::Stop()
 {

-    // leave current frame displayed until Play() is called again

     m_timer.Stop();
     m_isPlaying = false;
     m_timer.Stop();
     m_isPlaying = false;

+
+    // reset frame counter
+    m_currentFrame = 0;
+
+    DisplayStaticImage();

 }
 
 bool wxAnimationCtrl::Play(bool looped)
 }
 
 bool wxAnimationCtrl::Play(bool looped)


@@ -380,18 +398,18 @@ bool wxAnimationCtrl::Play(bool looped)
     if (!m_animation.IsOk())
         return false;
 
     if (!m_animation.IsOk())
         return false;
 

-    int oldframe = m_currentFrame;

     m_looped = looped;
     m_currentFrame = 0;
 
     m_looped = looped;
     m_currentFrame = 0;
 

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

 
     m_isPlaying = true;
 
 
     m_isPlaying = true;
 

+    // do a ClearBackground() to avoid that e.g. the custom static bitmap which
+    // was eventually shown previously remains partially drawn
+    ClearBackground();
+

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


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

-bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
+bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(unsigned int 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


@@ -434,7 +452,7 @@ bool wxAnimationCtrl::RebuildBackingStoreUpToFrame(size_t frame)
     DisposeToBackground(dc);
 
     // Draw all intermediate frames that haven't been removed from the animation
     DisposeToBackground(dc);
 
     // Draw all intermediate frames that haven't been removed from the animation

-    for (size_t i = 0; i < frame; i++)
+    for (unsigned int i = 0; i < frame; i++)

     {
         if (m_animation.GetDisposalMethod(i) == wxANIM_DONOTREMOVE ||
             m_animation.GetDisposalMethod(i) == wxANIM_UNSPECIFIED)
     {
         if (m_animation.GetDisposalMethod(i) == wxANIM_DONOTREMOVE ||
             m_animation.GetDisposalMethod(i) == wxANIM_UNSPECIFIED)


@@ -505,7 +523,42 @@ void wxAnimationCtrl::IncrementalUpdateBackingStore()
     dc.SelectObject(wxNullBitmap);
 }
 
     dc.SelectObject(wxNullBitmap);
 }
 

-void wxAnimationCtrl::DrawFrame(wxDC &dc, size_t frame)
+void wxAnimationCtrl::DisplayStaticImage()
+{
+    wxASSERT(!IsPlaying());
+
+    // m_bmpStaticReal will be updated only if necessary...
+    UpdateStaticImage();
+
+    if (m_bmpStaticReal.IsOk())
+    {
+        // copy the inactive bitmap in the backing store
+        // eventually using the mask if the static bitmap has one
+        if ( m_bmpStaticReal.GetMask() )
+        {
+            wxMemoryDC temp;
+            temp.SelectObject(m_backingStore);
+            DisposeToBackground(temp);
+            temp.DrawBitmap(m_bmpStaticReal, 0, 0, true /* use mask */);
+        }
+        else
+            m_backingStore = m_bmpStaticReal;
+    }
+    else
+    {
+        // put in the backing store the first frame of the animation
+        if (!m_animation.IsOk() ||
+            !RebuildBackingStoreUpToFrame(0))
+        {
+            m_animation = wxNullAnimation;
+            DisposeToBackground();
+        }
+    }
+
+    Refresh();
+}
+
+void wxAnimationCtrl::DrawFrame(wxDC &dc, unsigned int frame)

 {
     // PERFORMANCE NOTE:
     // this draw stuff is not as fast as possible: the wxAnimationDecoder
 {
     // PERFORMANCE NOTE:
     // this draw stuff is not as fast as possible: the wxAnimationDecoder


@@ -523,7 +576,16 @@ void wxAnimationCtrl::DrawCurrentFrame(wxDC& dc)
     wxASSERT( m_backingStore.IsOk() );
 
     // m_backingStore always contains the current frame
     wxASSERT( m_backingStore.IsOk() );
 
     // m_backingStore always contains the current frame

-    dc.DrawBitmap(m_backingStore, 0, 0);
+    dc.DrawBitmap(m_backingStore, 0, 0, true /* use mask in case it's present */);
+}
+
+void wxAnimationCtrl::DisposeToBackground()
+{
+    // clear the backing store
+    wxMemoryDC dc;
+    dc.SelectObject(m_backingStore);
+    if ( dc.IsOk() )
+        DisposeToBackground(dc);

 }
 
 void wxAnimationCtrl::DisposeToBackground(wxDC& dc)
 }
 
 void wxAnimationCtrl::DisposeToBackground(wxDC& dc)


@@ -531,6 +593,7 @@ void wxAnimationCtrl::DisposeToBackground(wxDC& dc)
     wxColour col = IsUsingWindowBackgroundColour()
                     ? GetBackgroundColour()
                     : m_animation.GetBackgroundColour();
     wxColour col = IsUsingWindowBackgroundColour()
                     ? GetBackgroundColour()
                     : m_animation.GetBackgroundColour();

+

     wxBrush brush(col);
     dc.SetBackground(brush);
     dc.Clear();
     wxBrush brush(col);
     dc.SetBackground(brush);
     dc.Clear();


@@ -556,10 +619,19 @@ void wxAnimationCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
     // VERY IMPORTANT: the wxPaintDC *must* be created in any case
     wxPaintDC dc(this);
 
     // VERY IMPORTANT: the wxPaintDC *must* be created in any case
     wxPaintDC dc(this);
 

-    // both if we are playing or not, we need to refresh the current frame

     if ( m_backingStore.IsOk() )
     if ( m_backingStore.IsOk() )

-        DrawCurrentFrame(dc);
-    //else: m_animation is not valid and thus we don't have a valid backing store...
+    {
+        // NOTE: we draw the bitmap explicitely ignoring the mask (if any);
+        //       i.e. we don't want to combine the backing store with the 
+        //       possibly wrong preexisting contents of the window!
+        dc.DrawBitmap(m_backingStore, 0, 0, false /* no mask */);
+    }
+    else
+    {
+        // m_animation is not valid and thus we don't have a valid backing store...
+        // clear then our area to the background colour
+        DisposeToBackground(dc);
+    }

 }
 
 void wxAnimationCtrl::OnTimer(wxTimerEvent &WXUNUSED(event))
 }
 
 void wxAnimationCtrl::OnTimer(wxTimerEvent &WXUNUSED(event))


@@ -570,8 +642,7 @@ void wxAnimationCtrl::OnTimer(wxTimerEvent &WXUNUSED(event))
         // Should a non-looped animation display the last frame?
         if (!m_looped)
         {
         // Should a non-looped animation display the last frame?
         if (!m_looped)
         {

-            m_timer.Stop();
-            m_isPlaying = false;
+            Stop();

             return;
         }
         else
             return;
         }
         else


@@ -599,10 +670,21 @@ void wxAnimationCtrl::OnSize(wxSizeEvent &WXUNUSED(event))
 {
     // NB: resizing an animation control may take a lot of time
     //     for big animations as the backing store must be
 {
     // NB: resizing an animation control may take a lot of time
     //     for big animations as the backing store must be

-    //     extended and rebuilt. Try to avoid it!!
+    //     extended and rebuilt. Try to avoid it e.g. using
+    //     a null proportion value for your wxAnimationCtrls
+    //     when using them inside sizers.

     if (m_animation.IsOk())
     if (m_animation.IsOk())

-        if (!RebuildBackingStoreUpToFrame(m_currentFrame))
-            Stop();     // in case we are playing
+    {
+        // be careful to change the backing store *only* if we are 
+        // playing the animation as otherwise we may be displaying 
+        // the inactive bitmap and overwriting the backing store 
+        // with the last played frame is wrong in this case
+        if (IsPlaying())
+        {
+            if (!RebuildBackingStoreUpToFrame(m_currentFrame))
+                Stop();     // in case we are playing
+        }
+    }

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