timeline-state.hpp

Go to the documentation of this file.

/*
  TIMELINE-STATE.hpp  -  timeline presentation state holder

  Copyright (C)         Lumiera.org
    2008,               Joel Holdsworth <joel@airwebreathe.org.uk>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef STAGE_WIDGET_TIMELINE_STATE_H
#define STAGE_WIDGET_TIMELINE_STATE_H

#include "stage/gtk-base.hpp"
//#include "stage/widget/timeline/timeline-view-window.hpp"////////////////////////////TODO : obsolete and removed 3/23

#include "lib/time/timevalue.hpp"
#include "lib/time/mutation.hpp"
#include "lib/time/control.hpp"

#include <memory>


namespace stage {
  namespace model {
    class Sequence;
  }  
  namespace widget { 
  namespace timeline {
  
  using lib::time::Time;
  using lib::time::Offset;
  using lib::time::TimeVar;
  using lib::time::TimeSpan;
  using lib::time::TimeValue;
  using lib::time::Mutation;
  using lib::time::Control;
  
  using std::shared_ptr;
  
  typedef Control<TimeSpan> SelectionControl;

  class TimelineViewWindow
    {
    public:
      TimelineViewWindow (Offset offset, int64_t scale)
        {
          NOTREACHED ("3/23: this code is dead and left in-tree for later reference only");
        }
    };
  
  
  template<class TI>
  class SelectionListener
    : util::NonCopyable
    {
      sigc::signal<void, TI> valueChangedSignal_;
      
    public:
      SelectionListener() { }
      
      void
      operator() (TI const& changeValue)  const
        {
          valueChangedSignal_.emit (changeValue);
        }
      
      
      void connect (const sigc::slot<void, TI> &connection)
        {
          valueChangedSignal_.connect (connection);
        }
    };
  
  
  
  class TimelineState
    {
    public:
      
      TimelineState (shared_ptr<model::Sequence> sourceSequence);
      
      
    public:
      shared_ptr<model::Sequence> getSequence()  const;
      
      timeline::TimelineViewWindow& getViewWindow();
      
      
      SelectionListener<TimeSpan>&
      getSelectionListener()              { return selectionListener_; }
      
      Time getSelectionStart()      const { return selection_.start();}
      Time getSelectionEnd()        const { return selection_.end();  }
      Time getPlaybackPeriodStart() const { return selection_.start();}
      Time getPlaybackPeriodEnd()   const { return selection_.end();  }
      
      Time getPlaybackPoint()       const { return playbackPoint_; }
      
      
      bool isPlaying() const { return isPlayback_; }
      
      void setSelectionControl (SelectionControl &control);
      
      void setSelection(Mutation const& change,
                        bool resetPlaybackPeriod = true);
      
      void setPlaybackPeriod(Mutation const& change);
      
      void setPlaybackPoint(Time newPos);
      
      sigc::signal<void> selectionChangedSignal()  const;
      
      sigc::signal<void> playbackChangedSignal()  const;
      
      
      
    private: /* ========= Event Handlers ========== */
      void on_selection_changed (TimeSpan selection);
      
      
    private:
      shared_ptr<model::Sequence> sequence_;
      
      
      
      /* == View State == */
      
      timeline::TimelineViewWindow viewWindow_;
      
      
      /* == Selection State == */
      
      TimeSpan selection_;
      
      SelectionListener<TimeSpan> selectionListener_;
      
      TimeSpan playbackPeriod_;
      
      TimeVar playbackPoint_;
      
      bool isPlayback_;
      
      
      /* == Signals == */
      
      sigc::signal<void> selectionChangedSignal_;
      
      sigc::signal<void> playbackChangedSignal_;
    };
  
  
}}}// namespace stage::widget::timeline
#endif /*STAGE_WIDGET_TIMELINE_STATE_H*/