Set modifiers properly for the key events with AltGr in wxGTK.

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

diff --git a/src/generic/animateg.cpp b/src/generic/animateg.cpp
index c7e55f4f92e862dbd0d582e85f10f229dcf6fca7..d6e44ba9a225bce5993c7f61afbe0e1379e3f22e 100644 (file)
--- a/src/generic/animateg.cpp
+++ b/src/generic/animateg.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        animateg.cpp
+// Name:        src/generic/animateg.cpp

 // Purpose:     wxAnimation and wxAnimationCtrl
 // Author:      Julian Smart and Guillermo Rodriguez Garcia
 // Modified by: Francesco Montorsi
 // Purpose:     wxAnimation and wxAnimationCtrl
 // Author:      Julian Smart and Guillermo Rodriguez Garcia
 // Modified by: Francesco Montorsi


@@ -15,7 +15,7 @@
   #pragma hdrstop
 #endif  //__BORLANDC__
 
   #pragma hdrstop
 #endif  //__BORLANDC__
 

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

 
 #include "wx/animate.h"
 
 
 #include "wx/animate.h"
 


@@ -42,7 +42,7 @@ wxAnimationDecoderList wxAnimation::sm_handlers;
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxAnimation, wxAnimationBase)
 // ----------------------------------------------------------------------------
 
 IMPLEMENT_DYNAMIC_CLASS(wxAnimation, wxAnimationBase)

-#define M_ANIMDATA      wx_static_cast(wxAnimationDecoder*, m_refData)
+#define M_ANIMDATA      static_cast<wxAnimationDecoder*>(m_refData)

 
 wxSize wxAnimation::GetSize() const
 {
 
 wxSize wxAnimation::GetSize() const
 {


@@ -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") );
 


@@ -138,7 +138,6 @@ bool wxAnimation::Load(wxInputStream &stream, wxAnimationType type)
                 m_refData = handler->Clone();
                 return M_ANIMDATA->Load(stream);
             }
                 m_refData = handler->Clone();
                 return M_ANIMDATA->Load(stream);
             }

-

         }
 
         wxLogWarning( _("No handler found for animation type.") );
         }
 
         wxLogWarning( _("No handler found for animation type.") );


@@ -147,10 +146,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 +153,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,9 +185,8 @@ 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"),
+        wxLogDebug( wxT("Adding duplicate animation handler for '%d' type"),

                     handler->GetType() );
         delete handler;
     }
                     handler->GetType() );
         delete handler;
     }


@@ -203,7 +202,7 @@ void wxAnimation::InsertHandler( wxAnimationDecoder *handler )
     else
     {
         // see AddHandler for additional comments.
     else
     {
         // see AddHandler for additional comments.

-        wxLogDebug( _T("Inserting duplicate animation handler for '%d' type"),
+        wxLogDebug( wxT("Inserting duplicate animation handler for '%d' type"),

                     handler->GetType() );
         delete handler;
     }
                     handler->GetType() );
         delete handler;
     }


@@ -255,8 +254,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)


@@ -307,10 +306,17 @@ wxAnimationCtrl::~wxAnimationCtrl()
 }
 
 bool wxAnimationCtrl::LoadFile(const wxString& filename, wxAnimationType type)
 }
 
 bool wxAnimationCtrl::LoadFile(const wxString& filename, wxAnimationType type)

+{
+    wxFileInputStream fis(filename);
+    if (!fis.IsOk())
+        return false;
+    return Load(fis, type);
+}
+
+bool wxAnimationCtrl::Load(wxInputStream& stream, wxAnimationType type)

 {
     wxAnimation anim;
 {
     wxAnimation anim;

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

         return false;
 
     SetAnimation(anim);
         return false;
 
     SetAnimation(anim);


@@ -330,26 +336,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();
 

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

 }
 
 void wxAnimationCtrl::SetInactiveBitmap(const wxBitmap &bmp)
 {
 }
 
 void wxAnimationCtrl::SetInactiveBitmap(const wxBitmap &bmp)
 {

-    m_bmpStatic = 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());

 
 

-    // if not playing, update the backing store now
-    if (!IsPlaying())
-        UpdateBackingStoreWithStaticImage();
+    wxAnimationCtrlBase::SetInactiveBitmap(bmp);

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


@@ -357,6 +370,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


@@ -367,7 +393,10 @@ void wxAnimationCtrl::Stop()
     m_timer.Stop();
     m_isPlaying = false;
 
     m_timer.Stop();
     m_isPlaying = false;
 

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

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


@@ -395,7 +424,7 @@ bool wxAnimationCtrl::Play(bool looped)
     int delay = m_animation.GetDelay(0);
     if (delay == 0)
         delay = 1;      // 0 is invalid timeout for wxTimer.
     int delay = m_animation.GetDelay(0);
     if (delay == 0)
         delay = 1;      // 0 is invalid timeout for wxTimer.

-    m_timer.Start(delay);
+    m_timer.Start(delay, true);

 
     return true;
 }
 
     return true;
 }


@@ -406,7 +435,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


@@ -429,7 +458,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)


@@ -475,7 +504,7 @@ void wxAnimationCtrl::IncrementalUpdateBackingStore()
 
         case wxANIM_TOPREVIOUS:
             // this disposal should never be used too often.
 
         case wxANIM_TOPREVIOUS:
             // this disposal should never be used too often.

-            // E.g. GIF specification explicitely say to keep the usage of this
+            // E.g. GIF specification explicitly say to keep the usage of this

             //      disposal limited to the minimum.
             // In fact it may require a lot of time to restore
             if (m_currentFrame == 1)
             //      disposal limited to the minimum.
             // In fact it may require a lot of time to restore
             if (m_currentFrame == 1)


@@ -500,14 +529,26 @@ void wxAnimationCtrl::IncrementalUpdateBackingStore()
     dc.SelectObject(wxNullBitmap);
 }
 
     dc.SelectObject(wxNullBitmap);
 }
 

-void wxAnimationCtrl::UpdateBackingStoreWithStaticImage()
+void wxAnimationCtrl::DisplayStaticImage()

 {
     wxASSERT(!IsPlaying());
 
 {
     wxASSERT(!IsPlaying());
 

-    if (m_bmpStatic.IsOk())
+    // m_bmpStaticReal will be updated only if necessary...
+    UpdateStaticImage();
+
+    if (m_bmpStaticReal.IsOk())

     {
         // copy the inactive bitmap in the backing store
     {
         // copy the inactive bitmap in the backing store

-        m_backingStore = m_bmpStatic;
+        // 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
     {
     }
     else
     {


@@ -523,7 +564,7 @@ void wxAnimationCtrl::UpdateBackingStoreWithStaticImage()
     Refresh();
 }
 
     Refresh();
 }
 

-void wxAnimationCtrl::DrawFrame(wxDC &dc, size_t frame)
+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


@@ -549,14 +590,16 @@ void wxAnimationCtrl::DisposeToBackground()
     // clear the backing store
     wxMemoryDC dc;
     dc.SelectObject(m_backingStore);
     // clear the backing store
     wxMemoryDC dc;
     dc.SelectObject(m_backingStore);

-    DisposeToBackground(dc);
+    if ( dc.IsOk() )
+        DisposeToBackground(dc);

 }
 
 void wxAnimationCtrl::DisposeToBackground(wxDC& dc)
 }
 
 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();


@@ -583,7 +626,12 @@ void wxAnimationCtrl::OnPaint(wxPaintEvent& WXUNUSED(event))
     wxPaintDC dc(this);
 
     if ( m_backingStore.IsOk() )
     wxPaintDC dc(this);
 
     if ( m_backingStore.IsOk() )

-        DrawCurrentFrame(dc);
+    {
+        // NOTE: we draw the bitmap explicitly 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...
     else
     {
         // m_animation is not valid and thus we don't have a valid backing store...


@@ -621,7 +669,7 @@ void wxAnimationCtrl::OnTimer(wxTimerEvent &WXUNUSED(event))
     int delay = m_animation.GetDelay(m_currentFrame);
     if (delay == 0)
         delay = 1;      // 0 is invalid timeout for wxTimer.
     int delay = m_animation.GetDelay(m_currentFrame);
     if (delay == 0)
         delay = 1;      // 0 is invalid timeout for wxTimer.

-    m_timer.Start(delay);
+    m_timer.Start(delay, true);

 }
 
 void wxAnimationCtrl::OnSize(wxSizeEvent &WXUNUSED(event))
 }
 
 void wxAnimationCtrl::OnSize(wxSizeEvent &WXUNUSED(event))


@@ -633,17 +681,17 @@ void wxAnimationCtrl::OnSize(wxSizeEvent &WXUNUSED(event))
     //     when using them inside sizers.
     if (m_animation.IsOk())
     {
     //     when using them inside sizers.
     if (m_animation.IsOk())
     {

-        // 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 
+        // 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())
         {
         // with the last played frame is wrong in this case
         if (IsPlaying())
         {

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

         }
     }
 }
 
         }
     }
 }
 

-#endif      // wxUSE_ANIMATIONCTRL
+#endif // wxUSE_ANIMATIONCTRL