track-presenter.hpp

Go to the documentation of this file.

/*
  TRACK-PRESENTER.hpp  -  presentation control element for a track within the timeline

  Copyright (C)         Lumiera.org
    2016,               Hermann Vosseler <Ichthyostega@web.de>

  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_TIMELINE_TRACK_PRESENTER_H
#define STAGE_TIMELINE_TRACK_PRESENTER_H

#include "stage/gtk-base.hpp"
#include "include/ui-protocol.hpp"
#include "stage/model/view-hook.hpp"
#include "stage/model/controller.hpp"
#include "stage/timeline/display-evaluation.hpp"
#include "stage/timeline/marker-widget.hpp"
#include "stage/timeline/clip-presenter.hpp"
#include "stage/timeline/track-head-widget.hpp"
#include "stage/timeline/track-body.hpp"
#include "lib/time/timevalue.hpp"
#include "lib/iter-explorer.hpp"
#include "lib/util-coll.hpp"

#include "lib/nocopy.hpp"

#include <optional>
#include <utility>
#include <vector>



namespace stage  {
namespace timeline {
  
  using std::vector;
  using std::unique_ptr;
  using std::make_unique;
  
  using lib::time::TimeSpan;
  using lib::diff::TreeMutator;
  using lib::diff::collection;
  using lib::explore;
  using util::max;
  
  
  
  template<class WID>
  class RelativeCanvasHook
    : public model::CanvasHook<WID>
    {
      model::CanvasHook<WID>& refHook_;
      
      
      /* ==== Interface: ViewHook ===== */
      
      void
      hook (WID& widget, int xPos=0, int yPos=0) override
        {
          refHook_.hook (widget, hookAdjX (xPos), hookAdjY (yPos));
        }
      
      void
      move (WID& widget, int xPos, int yPos)  override
        {
          refHook_.move (widget, hookAdjX (xPos), hookAdjY (yPos));
        }

      void
      remove (WID& widget)  override
        {
          refHook_.remove (widget);
        }
      
      model::CanvasHook<WID>&
      getAnchorHook()  noexcept override
        {
          return this->refHook_;
        }
      
    protected: /* === extended Interface for relative canvas hook === */
      virtual int hookAdjX (int xPos)  =0;
      virtual int hookAdjY (int yPos)  =0;
      
      model::DisplayMetric&
      getMetric()  const override
        {
          return refHook_.getMetric();
        }
      
    public:
      RelativeCanvasHook(model::CanvasHook<WID>& baseHook)
        : refHook_{baseHook.getAnchorHook()}
        { }
    };
  
  
  
  using PFork  = unique_ptr<TrackPresenter>;
  using PClip  = unique_ptr<ClipPresenter>;
  using PMark  = unique_ptr<MarkerWidget>;
  using PRuler = unique_ptr<RulerTrack>;
  
  class DisplayFrame
    : util::NonCopyable
    , public DisplayViewHooks
    , public RelativeCanvasHook<Gtk::Widget>
    {
      model::ViewHooked<TrackHeadWidget> head_;
      model::ViewHooked<TrackBody>       body_;
      
      /* === extended Interface for relative view/canvas hook === */
      
      int hookAdjX (int xPos)  override { return xPos; };
      int hookAdjY (int yPos)  override { return yPos + body_.getContentOffsetY(); };
      
    public: /* ==== Interface: DisplayViewHooks===== */
      
      model::ViewHook<TrackHeadWidget>& getHeadHook()  override { return head_; };
      model::ViewHook<TrackBody>&       getBodyHook()  override { return body_; };
      model::CanvasHook<Gtk::Widget>&   getClipHook()  override { return *this; };
      
    public:
      DisplayFrame (DisplayViewHooks& displayAnchor)
        : RelativeCanvasHook{displayAnchor.getClipHook()}     
        , head_{displayAnchor.getHeadHook()}
        , body_{displayAnchor.getBodyHook()}
        { }
      
      void
      setTrackName (cuString& name)
        {
          head_.setTrackName (name);
          body_.setTrackName (name);  
        }
      
      vector<unique_ptr<RulerTrack>>&
      bindRulers()
        {
          return body_.bindRulers();
        }
      
      void establishExtension (vector<PClip>&, vector<PMark>&);
      void sync_and_balance (DisplayEvaluation&);
    };
  
  
  class TrackPresenter
    : public model::Controller
    , public LayoutElement
    {
      DisplayFrame display_;
      
      vector<PFork> subFork_;
      vector<PMark> markers_;
      vector<PClip> clips_;
      
      
    public:
      TrackPresenter (ID id, ctrl::BusTerm& nexus, DisplayViewHooks& displayAnchor)
        : Controller{id, nexus}
        , display_{displayAnchor}
        , subFork_{}
        , markers_{}
        , clips_{}
        {
          setTrackName (id.getSym());  // fallback initialise track-name from human-readable ID symbol
        }
      
      
      virtual void buildMutator (lib::diff::TreeMutator::Handle)  override;
      
      
    protected: /* ==== Interface: LayoutElement ===== */
      
      void establishLayout (DisplayEvaluation&)  override;
      void completeLayout (DisplayEvaluation&)   override;
      
    private:/* ===== Internals ===== */
      
      void
      setTrackName (string name)
        {
          display_.setTrackName (name);
        }
      
      void relinkContents ();
    };
  
  
  
  
  inline void
  TrackPresenter::buildMutator (TreeMutator::Handle buffer)
  {
    buffer.emplace(
      TreeMutator::build()
        .attach (collection(display_.bindRulers())
               .isApplicableIf ([&](GenNode const& spec) -> bool
                  {                                            // »Selector« : require object-like sub scope with type-field "Ruler"
                    return TYPE_Ruler == spec.data.recordType();
                  })
               .constructFrom ([&](GenNode const& spec) -> PRuler
                  {                                            // »Constructor« : how to attach a new ruler track
                    return make_unique<RulerTrack> (spec.idi, this->uiBus_, *this);               
                  }))
        .attach (collection(markers_)
               .isApplicableIf ([&](GenNode const& spec) -> bool
                  {                                            // »Selector« : require object-like sub scope with type-field "Marker"
                    return TYPE_Marker == spec.data.recordType();
                  })
               .constructFrom ([&](GenNode const& spec) -> PMark
                  {
                    return make_unique<MarkerWidget> (spec.idi, this->uiBus_);
                  }))
        .attach (collection(clips_)
               .isApplicableIf ([&](GenNode const& spec) -> bool
                  {                                            // »Selector« : require object-like sub scope with type-field "Clip"
                    return TYPE_Clip == spec.data.recordType();
                  })
               .constructFrom ([&](GenNode const& spec) -> PClip
                  {
                    std::optional<TimeSpan> timing = spec.retrieveAttribute<TimeSpan> (string{ATTR_timing});
                    return make_unique<ClipPresenter> (spec.idi, this->uiBus_, display_.getClipHook(), timing);
                  }))                                                                              
        .attach (collection(subFork_)
               .isApplicableIf ([&](GenNode const& spec) -> bool
                  {                                            // »Selector« : require object-like sub scope with type-field "Fork"
                    return TYPE_Fork == spec.data.recordType();
                  })
               .constructFrom ([&](GenNode const& spec) -> PFork
                  {
                    return make_unique<TrackPresenter> (spec.idi, uiBus_, this->display_);
                  }))
        .change(ATTR_name, [&](string val)
            {                                                  // »Attribute Setter« : receive a new value for the track name field
              this->setTrackName (val);
            }));
  }
  
  
  
  inline void
  TrackPresenter::establishLayout (DisplayEvaluation& displayEvaluation)
  {
    ASSERT (displayEvaluation.isCollectPhase());
    display_.establishExtension (clips_, markers_);
    for (auto& subTrack: subFork_)
      subTrack->establishLayout (displayEvaluation);
  }
  
  inline void
  TrackPresenter::completeLayout (DisplayEvaluation& displayEvaluation)
  {
    ASSERT (not displayEvaluation.isCollectPhase());
    // recursion first, so all sub-Tracks are already balanced
    for (auto& subTrack: subFork_)
      subTrack->completeLayout (displayEvaluation);
    this->relinkContents();
    // re-sync and match the header / body display
    display_.sync_and_balance (displayEvaluation);
  }

  inline void
  DisplayFrame::establishExtension (vector<PClip>& clips, vector<PMark>&)
  {
    uint maxVSize = max (explore (clips)
                          .transform([](PClip const& clip)
                                       {
                                         return clip->determineRequiredVerticalExtension();
                                       }));
    maxVSize = max (maxVSize, head_.getContentHeight());
    this->body_.accommodateContentHeight (maxVSize);
    this->head_.accommodateContentHeight (maxVSize);
  }
  
  inline void
  TrackPresenter::relinkContents ()
  {
    for (auto& clip: clips_)
      clip->relink();
    for (auto& mark: markers_)
      mark->relink();
  }
  
  
  inline void
  DisplayFrame::sync_and_balance (DisplayEvaluation&)
  {
    uint contentHeight = body_.calcContentHeight();
    uint overallHeight = contentHeight + body_.calcSubtrackHeight();
    head_.syncSubtrackStartHeight (contentHeight);
    head_.accommodateOverallHeight (overallHeight);
  }


  
  
  
}}// namespace stage::timeline
#endif /*STAGE_TIMELINE_TRACK_PRESENTER_H*/