contrib/src/animate/animate.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        animate.cpp
   3 // Purpose:     Implementation of wxAnimation classes
   4 // Author:      Julian Smart and Guillermo Rodriguez Garcia
   5 // Modified by:
   6 // Created:     13/8/99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Guillermo Rodriguez Garcia
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "animate.h"
  14 #endif
  15
  16 #include "wx/wxprec.h"
  17
  18 #ifdef    __BORLANDC__
  19   #pragma hdrstop
  20 #endif  //__BORLANDC__
  21
  22 #include "wx/wfstream.h"
  23 #include "wx/image.h"
  24 #include "wx/gifdecod.h"
  25 #include "wx/log.h"
  26 #include "wx/dcmemory.h"
  27 #include "wx/animate/animate.h"
  28 #include "wx/dc.h"
  29 #include "wx/dcclient.h"
  30
  31 /*
  32  * wxAnimationPlayer
  33  */
  34
  35 IMPLEMENT_CLASS(wxAnimationPlayer, wxObject)
  36
  37 wxAnimationPlayer::wxAnimationPlayer(wxAnimationBase *animation, bool destroyAnimation)
  38 {
  39     m_animation = animation;
  40     m_destroyAnimation = destroyAnimation;
  41     m_currentFrame = 0;
  42     m_window = (wxWindow*) NULL;
  43     m_position = wxPoint(0, 0);
  44     m_looped = TRUE;
  45     m_isPlaying = FALSE;
  46     m_useBackgroundColour = FALSE;
  47     m_customBackgroundColour = wxColour(0, 0, 0);
  48     m_useCustomBackgroundColour = FALSE;
  49     m_useParentBackground = FALSE;
  50     m_timer.SetPlayer(this);
  51 }
  52
  53 wxAnimationPlayer::~wxAnimationPlayer()
  54 {
  55     Stop();
  56     ClearCache();
  57
  58     if (m_destroyAnimation)
  59         delete m_animation;
  60 }
  61
  62 void wxAnimationPlayer::SetAnimation(wxAnimationBase* animation, bool destroyAnimation)
  63 {
  64     ClearCache();
  65     if (m_destroyAnimation)
  66         delete m_animation;
  67     m_animation = animation;
  68     m_destroyAnimation = destroyAnimation;
  69 }
  70
  71 // Play
  72 bool wxAnimationPlayer::Play(wxWindow& window, const wxPoint& pos, bool WXUNUSED(looped))
  73 {
  74     m_window = & window;
  75
  76     if (!m_animation || !m_animation->IsValid())
  77         return FALSE;
  78
  79     wxSize sz = GetLogicalScreenSize();
  80     wxRect rect(pos, sz);
  81     SaveBackground(rect);
  82
  83     if (m_frames.GetCount() == 0)
  84     {
  85         if (!Build())
  86         {
  87             wxLogWarning(_T("wxAnimationPlayer::Play: could not build the image cache."));
  88             return FALSE;
  89         }
  90     }
  91     m_currentFrame = 0;
  92
  93     // Create the backing store
  94     m_backingStore.Create(sz.x, sz.y);
  95
  96     PlayFrame();
  97
  98     return TRUE;
  99 }
 100
 101 // Build animation (list of wxImages). If not called before Play
 102 // is called, Play will call this automatically.
 103 bool wxAnimationPlayer::Build()
 104 {
 105     ClearCache();
 106     if (m_animation)
 107     {
 108         int n = GetFrameCount();
 109         int i;
 110         for (i = 0; i < n; i++)
 111         {
 112             wxImage* image = GetFrame(i);
 113             if (image)
 114             {
 115                 // If the frame has transparency,
 116                 // set the colour so converting to a bitmap
 117                 // will create a mask
 118                 wxColour transparentColour;
 119                 if (GetTransparentColour(transparentColour))
 120                     image->SetMaskColour(transparentColour.Red(), transparentColour.Green(), transparentColour.Blue());
 121
 122                 wxBitmap* bitmap = new wxBitmap(* image);
 123                 delete image;
 124                 if (bitmap)
 125                     m_frames.Append(bitmap);
 126                 else
 127                     return FALSE;
 128             }
 129             else
 130                 return FALSE;
 131         }
 132         return TRUE;
 133     }
 134     else
 135         return FALSE;
 136 }
 137
 138 // Stop the animation
 139 void wxAnimationPlayer::Stop()
 140 {
 141     m_timer.Stop();
 142     m_isPlaying = FALSE;
 143 }
 144
 145 // Draw the current view of the animation into this DC.
 146 // Call this from your OnPaint, for example.
 147 void wxAnimationPlayer::Draw(wxDC& dc)
 148 {
 149     dc.DrawBitmap(m_backingStore, m_position.x, m_position.y);
 150 }
 151
 152
 153 int wxAnimationPlayer::GetFrameCount() const
 154 {
 155     if (m_animation)
 156         return m_animation->GetFrameCount();
 157     else
 158         return 0;
 159 }
 160
 161 wxImage* wxAnimationPlayer::GetFrame(int i) const
 162 {
 163     if (m_animation)
 164         return m_animation->GetFrame(i);
 165     else
 166         return (wxImage*) NULL;
 167 }
 168
 169 wxAnimationDisposal wxAnimationPlayer::GetDisposalMethod(int i) const
 170 {
 171     if (m_animation)
 172         return m_animation->GetDisposalMethod(i);
 173     else
 174         return wxANIM_UNSPECIFIED;
 175 }
 176
 177 wxRect wxAnimationPlayer::GetFrameRect(int i) const
 178 {
 179     if (m_animation)
 180         return m_animation->GetFrameRect(i);
 181     else
 182         return wxRect(0, 0, 0, 0);
 183 }
 184
 185 int wxAnimationPlayer::GetDelay(int i) const
 186 {
 187     if (m_animation)
 188         return m_animation->GetDelay(i);
 189     else
 190         return 0;
 191 }
 192
 193 wxSize wxAnimationPlayer::GetLogicalScreenSize() const
 194 {
 195     if (m_animation)
 196         return m_animation->GetLogicalScreenSize();
 197     else
 198         return wxSize(0, 0);
 199 }
 200
 201 bool wxAnimationPlayer::GetBackgroundColour(wxColour& col) const
 202 {
 203     if (m_animation)
 204         return m_animation->GetBackgroundColour(col);
 205     else
 206         return FALSE;
 207 }
 208
 209 bool wxAnimationPlayer::GetTransparentColour(wxColour& col) const
 210 {
 211     if (m_animation)
 212         return m_animation->GetTransparentColour(col);
 213     else
 214         return FALSE;
 215 }
 216
 217 // Play the frame
 218 bool wxAnimationPlayer::PlayFrame(int frame, wxWindow& window, const wxPoint& WXUNUSED(pos))
 219 {
 220     wxMemoryDC dc;
 221     dc.SelectObject(m_backingStore);
 222
 223     // Draw the background: colour or area beneath animation
 224     wxColour col(255, 255, 255);
 225
 226     if (UsingBackgroundColour())
 227     {
 228         if (UsingCustomBackgroundColour())
 229             col = GetCustomBackgroundColour();
 230         else
 231         {
 232             GetBackgroundColour(col);
 233         }
 234
 235         // Draw the background colour loaded from the animation
 236         // (or set by the user)
 237         DrawBackground(dc, wxPoint(0, 0), col);
 238     }
 239     else
 240     {
 241         // Draw background we saved
 242         dc.DrawBitmap(m_savedBackground, 0, 0);
 243     }
 244
 245     // Draw all intermediate frames that haven't been removed from the
 246     // animation
 247     int i;
 248     for (i = 0; i < frame; i++)
 249     {
 250         if ((GetDisposalMethod(i) == wxANIM_DONOTREMOVE) || (GetDisposalMethod(i) == wxANIM_UNSPECIFIED))
 251         {
 252             DrawFrame(i, dc, wxPoint(0, 0));
 253         }
 254     }
 255     DrawFrame(frame, dc, wxPoint(0, 0));
 256
 257     dc.SelectObject(wxNullBitmap);
 258
 259     // Draw from backing bitmap onto window
 260     wxClientDC clientDC(& window);
 261     Draw(clientDC);
 262
 263     return TRUE;
 264 }
 265
 266 bool wxAnimationPlayer::PlayFrame()
 267 {
 268     m_isPlaying = TRUE;
 269
 270     PlayFrame(GetCurrentFrame(), * GetWindow(), GetPosition());
 271
 272     // Set the timer for the next frame
 273     m_timer.Start(GetDelay(GetCurrentFrame()));
 274
 275     m_currentFrame ++;
 276
 277     if (m_currentFrame == GetFrameCount())
 278     {
 279         // Should a non-looped animation display the last frame?
 280         if (!m_looped)
 281         {
 282             m_timer.Stop();
 283             m_isPlaying = FALSE;
 284         }
 285         else
 286             m_currentFrame = 0;
 287     }
 288
 289     return TRUE;
 290 }
 291
 292 // Clear the wxImage cache
 293 void wxAnimationPlayer::ClearCache()
 294 {
 295     wxList::compatibility_iterator node = m_frames.GetFirst();
 296     while (node)
 297     {
 298         wxList::compatibility_iterator next = node->GetNext();
 299         wxBitmap* bitmap = (wxBitmap*) node->GetData();
 300         delete bitmap;
 301         m_frames.Erase(node);
 302         node = next;
 303     }
 304 }
 305
 306 // Draw the background colour
 307 void wxAnimationPlayer::DrawBackground(wxDC& dc, const wxPoint& pos, const wxColour& colour)
 308 {
 309     wxASSERT_MSG( (m_animation != NULL), _T("Animation not present in wxAnimationPlayer"));
 310     wxASSERT_MSG( (m_frames.GetCount() != 0), _T("Animation cache not present in wxAnimationPlayer"));
 311
 312     // Optimization: if the first frame fills the whole area, and is non-transparent,
 313     // don't bother drawing the background
 314
 315     wxBitmap* firstBitmap = (wxBitmap*) m_frames.GetFirst()->GetData() ;
 316     wxSize screenSize = GetLogicalScreenSize();
 317     if (!firstBitmap->GetMask() && (firstBitmap->GetWidth() == screenSize.x) && (firstBitmap->GetHeight() == screenSize.y))
 318     {
 319         return;
 320     }
 321
 322     wxBrush brush(colour, wxSOLID);
 323     wxPen pen(colour, 1, wxSOLID);
 324     dc.SetBrush(brush);
 325     dc.SetPen(pen);
 326     dc.SetLogicalFunction(wxCOPY);
 327
 328     dc.DrawRectangle(pos.x, pos.y, screenSize.x, screenSize.y);
 329 }
 330
 331 // Save the pertinent area of the window so we can restore
 332 // it if drawing transparently
 333 void wxAnimationPlayer::SaveBackground(const wxRect& rect)
 334 {
 335     wxASSERT( GetWindow() );
 336
 337     if (!GetWindow())
 338         return;
 339
 340     m_savedBackground.Create(rect.width, rect.height);
 341
 342     wxMemoryDC memDC;
 343     memDC.SelectObject(m_savedBackground);
 344
 345     if (m_useParentBackground && GetWindow()->GetParent())
 346     {
 347         wxWindow* parent = GetWindow()->GetParent();
 348         wxClientDC dc(parent);
 349
 350         // Translate the point to coordinates in the
 351         // parent's client area, going via screen coordinates
 352         wxPoint pt(rect.x, rect.y);
 353         wxPoint screenPt = GetWindow()->ClientToScreen(pt);
 354         wxPoint parentPt = parent->ScreenToClient(screenPt);
 355
 356         memDC.Blit(0, 0, rect.width, rect.height, & dc, parentPt.x, parentPt.y);
 357     }
 358     else
 359     {
 360         wxClientDC dc(GetWindow());
 361
 362         memDC.Blit(0, 0, rect.width, rect.height, & dc, rect.x, rect.y);
 363     }
 364     memDC.SelectObject(wxNullBitmap);
 365 }
 366
 367 // Draw this frame
 368 void wxAnimationPlayer::DrawFrame(int frame, wxDC& dc, const wxPoint& pos)
 369 {
 370     wxASSERT_MSG( (m_animation != NULL), _T("Animation not present in wxAnimationPlayer"));
 371     wxASSERT_MSG( (m_frames.GetCount() != 0), _T("Animation cache not present in wxAnimationPlayer"));
 372     wxASSERT_MSG( !!m_frames.Item(frame), _T("Image not present in wxAnimationPlayer::DrawFrame"));
 373
 374     wxBitmap* bitmap = (wxBitmap*) m_frames.Item(frame)->GetData() ;
 375
 376     wxRect rect = GetFrameRect(frame);
 377
 378     dc.DrawBitmap(* bitmap, pos.x + rect.x, pos.y + rect.y, (bitmap->GetMask() != NULL));
 379 }
 380
 381 void wxAnimationTimer::Notify()
 382 {
 383     m_player->PlayFrame();
 384 }
 385
 386 /*
 387  * wxAnimationBase
 388  */
 389
 390 IMPLEMENT_ABSTRACT_CLASS(wxAnimationBase, wxObject)
 391
 392 /*
 393  * wxGIFAnimation
 394  */
 395
 396 IMPLEMENT_CLASS(wxGIFAnimation, wxAnimationBase)
 397
 398 wxGIFAnimation::wxGIFAnimation()
 399 {
 400     m_decoder = (wxGIFDecoder*) NULL;
 401 }
 402
 403 wxGIFAnimation::~wxGIFAnimation()
 404 {
 405     delete m_decoder;
 406 }
 407
 408 int wxGIFAnimation::GetFrameCount() const
 409 {
 410     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 411
 412     return m_decoder->GetNumberOfFrames();
 413 }
 414
 415 wxImage* wxGIFAnimation::GetFrame(int i) const
 416 {
 417     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 418
 419     m_decoder->GoFrame(i + 1);
 420
 421     wxImage* image = new wxImage;
 422     m_decoder->ConvertToImage(image);
 423     return image;
 424 }
 425
 426 wxAnimationDisposal wxGIFAnimation::GetDisposalMethod(int i) const
 427 {
 428     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 429
 430     m_decoder->GoFrame(i + 1);
 431
 432     int disposalMethod = m_decoder->GetDisposalMethod();
 433     return (wxAnimationDisposal) disposalMethod;
 434 }
 435
 436 wxRect wxGIFAnimation::GetFrameRect(int i) const
 437 {
 438     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 439
 440     m_decoder->GoFrame(i + 1);
 441
 442     wxRect rect(m_decoder->GetLeft(), m_decoder->GetTop(), m_decoder->GetWidth(), m_decoder->GetHeight());
 443     return rect;
 444 }
 445
 446 int wxGIFAnimation::GetDelay(int i) const
 447 {
 448     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 449
 450     m_decoder->GoFrame(i + 1);
 451     return m_decoder->GetDelay();
 452 }
 453
 454 wxSize wxGIFAnimation::GetLogicalScreenSize() const
 455 {
 456     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 457
 458     return wxSize(m_decoder->GetLogicalScreenWidth(), m_decoder->GetLogicalScreenHeight());
 459 }
 460
 461 bool wxGIFAnimation::GetBackgroundColour(wxColour& col) const
 462 {
 463     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 464
 465     int i = m_decoder->GetBackgroundColour();
 466     if (i == -1)
 467         return FALSE;
 468     else
 469     {
 470         unsigned char* pal = m_decoder->GetPalette();
 471
 472         if (pal)
 473         {
 474             col = wxColour(pal[3*i + 0], pal[3*i + 1], pal[3*i + 2]);
 475             return TRUE;
 476         }
 477         else
 478             return FALSE;
 479     }
 480 }
 481
 482 bool wxGIFAnimation::GetTransparentColour(wxColour& col) const
 483 {
 484     wxASSERT_MSG( (m_decoder != (wxGIFDecoder*) NULL), _T("m_decoder must be non-NULL"));
 485
 486     int i = m_decoder->GetTransparentColour();
 487     if (i == -1)
 488         return FALSE;
 489     else
 490     {
 491         unsigned char* pal = m_decoder->GetPalette();
 492
 493         if (pal)
 494         {
 495             col = wxColour(pal[3*i + 0], pal[3*i + 1], pal[3*i + 2]);
 496             return TRUE;
 497         }
 498         else
 499             return FALSE;
 500     }
 501 }
 502
 503 bool wxGIFAnimation::IsValid() const
 504 {
 505     return ((m_decoder != NULL) && (m_decoder->IsAnimation()));
 506 }
 507
 508 bool wxGIFAnimation::LoadFile(const wxString& filename)
 509 {
 510     if (m_decoder)
 511         delete m_decoder;
 512     m_decoder = NULL;
 513
 514     if (wxFileExists(filename))
 515     {
 516         wxFileInputStream stream(filename);
 517         m_decoder = new wxGIFDecoder(& stream, TRUE);
 518
 519         if (m_decoder->ReadGIF() != wxGIF_OK)
 520         {
 521             delete m_decoder;
 522             m_decoder = NULL;
 523             return FALSE;
 524         }
 525
 526         if (!m_decoder->IsAnimation())
 527         {
 528             delete m_decoder;
 529             m_decoder = NULL;
 530
 531             return FALSE;
 532         }
 533         else
 534             return TRUE;
 535     }
 536     else
 537         return FALSE;
 538 }
 539
 540 /*
 541  * wxAnimationCtrlBase
 542  * Abstract base class for format-specific animation controls.
 543  * This class implements most of the functionality; all a derived
 544  * class has to do is create the appropriate animation class on demand.
 545  */
 546
 547 IMPLEMENT_ABSTRACT_CLASS(wxAnimationCtrlBase, wxControl)
 548
 549 BEGIN_EVENT_TABLE(wxAnimationCtrlBase, wxControl)
 550     EVT_PAINT(wxAnimationCtrlBase::OnPaint)
 551 END_EVENT_TABLE()
 552
 553 bool wxAnimationCtrlBase::Create(wxWindow *parent, wxWindowID id,
 554             const wxString& filename, const wxPoint& pos,
 555             const wxSize& size, long style, const wxString& name)
 556 {
 557     m_animation = NULL;
 558     m_filename = filename;
 559
 560     if (!wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name))
 561         return FALSE;
 562
 563     SetBackgroundColour(parent->GetBackgroundColour());
 564
 565     m_animationPlayer.SetCustomBackgroundColour(GetBackgroundColour());
 566
 567     // Want to give the impression of transparency by painting
 568     // the parent background
 569 //    if (parent)
 570 //        m_animationPlayer.UseParentBackground(TRUE);
 571     m_animationPlayer.SetWindow(this);
 572     m_animationPlayer.SetPosition(wxPoint(0, 0));
 573     m_animationPlayer.SetDestroyAnimation(FALSE);
 574
 575     return TRUE;
 576 }
 577
 578 wxAnimationCtrlBase::~wxAnimationCtrlBase()
 579 {
 580     if (m_animationPlayer.IsPlaying())
 581         m_animationPlayer.Stop();
 582     m_animationPlayer.SetAnimation(NULL, FALSE);
 583     delete m_animation;
 584 }
 585
 586 bool wxAnimationCtrlBase::LoadFile(const wxString& filename)
 587 {
 588     if (m_animationPlayer.IsPlaying())
 589         m_animationPlayer.Stop();
 590
 591     wxString filename1(filename);
 592
 593     if (filename1.IsEmpty())
 594         filename1 = m_filename;
 595
 596     if (filename1.IsEmpty())
 597         return FALSE;
 598
 599     if (m_animation)
 600     {
 601         delete m_animation;
 602         m_animation = NULL;
 603     }
 604
 605     m_animation = DoCreateAnimation(filename1);
 606     if (!m_animation)
 607         return FALSE;
 608
 609     if (!m_animation->LoadFile(filename) || !m_animation->IsValid())
 610     {
 611         delete m_animation;
 612         m_animation = NULL;
 613         return FALSE;
 614     }
 615     m_animationPlayer.SetAnimation(m_animation, FALSE);
 616
 617     if (GetWindowStyle() & wxAN_FIT_ANIMATION)
 618         FitToAnimation();
 619
 620     return TRUE;
 621 }
 622
 623 bool wxAnimationCtrlBase::Play(bool looped)
 624 {
 625     return m_animationPlayer.Play(*this, wxPoint(0, 0), looped);
 626 }
 627
 628 wxSize wxAnimationCtrlBase::DoGetBestSize() const
 629 {
 630     if (m_animationPlayer.HasAnimation() && (GetWindowStyle() & wxAN_FIT_ANIMATION))
 631     {
 632         return m_animationPlayer.GetLogicalScreenSize();
 633     }
 634     else
 635     {
 636         return GetSize();
 637     }
 638 }
 639
 640 void wxAnimationCtrlBase::FitToAnimation()
 641 {
 642     if (!m_animationPlayer.HasAnimation())
 643         return;
 644
 645     wxSize sz = m_animationPlayer.GetLogicalScreenSize();
 646     SetClientSize(sz);
 647 }
 648
 649 void wxAnimationCtrlBase::OnPaint(wxPaintEvent& WXUNUSED(event))
 650 {
 651     wxPaintDC dc(this);
 652
 653     if (GetPlayer().IsPlaying())
 654     {
 655         GetPlayer().Draw(dc);
 656     }
 657 }
 658
 659 /*
 660  * wxGIFAnimationCtrl
 661  * Provides a GIF animation class when required.
 662  */
 663
 664 IMPLEMENT_ABSTRACT_CLASS(wxGIFAnimationCtrl, wxAnimationCtrlBase)
 665
 666 wxAnimationBase* wxGIFAnimationCtrl::DoCreateAnimation(const wxString& WXUNUSED(filename))
 667 {
 668     return new wxGIFAnimation;
 669 }