clip-presenter.hpp

Go to the documentation of this file.

/*
  CLIP-PRESENTER.hpp  -  presentation control element for a clip within the timeline
 
   Copyright (C)
     2016,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
*/
 
 
#ifndef STAGE_TIMELINE_CLIP_PRESENTER_H
#define STAGE_TIMELINE_CLIP_PRESENTER_H
 
#include "stage/gtk-base.hpp"
#include "include/ui-protocol.hpp"
#include "stage/model/controller.hpp"
#include "stage/timeline/clip-widget.hpp"
#include "stage/timeline/marker-widget.hpp"
#include "stage/interact/cmd-context.hpp"
#include "lib/time/timevalue.hpp"
#include "steam/cmd.hpp"
#include "lib/format-cout.hpp" 
#include "lib/format-string.hpp"
 
//#include "lib/util.hpp"
 
//#include <memory>
#include <optional>
#include <vector>
 
 
 
namespace stage  {
namespace timeline {
  
  using std::vector;
  using std::optional;
  using std::unique_ptr;
  using std::make_unique;
  using lib::time::TimeSpan;
  using lib::diff::TreeMutator;
  using lib::diff::collection;
  using util::_Fmt;
  
  
  class ClipPresenter
    : public model::Controller
    , public interact::Subject
    {
      vector<unique_ptr<ClipPresenter>> channels_;
      vector<unique_ptr<ClipPresenter>> effects_;
      vector<unique_ptr<MarkerWidget>>  markers_;
      
      unique_ptr<ClipDelegate> widget_;
      
      static const ClipDelegate::Appearance defaultAppearance = ClipDelegate::COMPACT;
      
      
    public:
      ClipPresenter (ID identity, ctrl::BusTerm& nexus, WidgetHook& view, optional<TimeSpan> const& timing)
        : Controller{identity, nexus}
        , channels_{}
        , effects_{}
        , markers_{}
        , widget_{}
        {
          establishAppearance (&view, timing);
          ENSURE (widget_);
        }
      
     ~ClipPresenter() { };
      
      
      virtual void
      buildMutator (TreeMutator::Handle buffer)  override
        {
          using PChannel = unique_ptr<ClipPresenter>;
          using PEffect  = unique_ptr<ClipPresenter>;
          using PMarker  = unique_ptr<MarkerWidget>;
          
          buffer.emplace(
            TreeMutator::build()
              .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) -> PMarker
                        {
                          return make_unique<MarkerWidget> (spec.idi, this->uiBus_);
                        }))
              .attach (collection(effects_)
                     .isApplicableIf ([&](GenNode const& spec) -> bool
                        {                                            // »Selector« : require object-like sub scope with type-field "Effect"
                          return TYPE_Effect == spec.data.recordType();
                        })
                     .constructFrom ([&](GenNode const& spec) -> PEffect
                        {
                          std::optional<TimeSpan> timing = spec.retrieveAttribute<TimeSpan> (string{ATTR_timing});
                          return make_unique<ClipPresenter> (spec.idi, this->uiBus_
                                                            ,getClipContentCanvas()
                                                            ,timing);
                        }))
              .attach (collection(channels_)
                     .isApplicableIf ([&](GenNode const& spec) -> bool
                        {                                            // »Selector« : require object-like sub scope with type-field "Channel"
                          return TYPE_Channel == spec.data.recordType();
                        })
                     .constructFrom ([&](GenNode const& spec) -> PChannel
                        {
                          return make_unique<ClipPresenter> (spec.idi, this->uiBus_
                                                            ,getClipContentCanvas()
                                                            ,std::nullopt);     
                        }))
              .change(ATTR_name, [&](string val)
                  {                                                  // »Attribute Setter« : receive a new value for the clip name field
                    REQUIRE (widget_);
                    widget_->setClipName (val);
                  })
              .change(ATTR_timing, [&](TimeSpan val)
                  {
                    REQUIRE (widget_);
                    widget_->accessStartTime() = val.start();
                    widget_->accessDuration() = val.duration();
                  })
              //-Diff-Change-Listener----------------
              .onLocalChange ([this]()
                        {
                          this->establishAppearance();
                        }));
        }
      
      
      uint
      determineRequiredVerticalExtension()  const
        {
          REQUIRE (widget_);
          return widget_->calcRequiredHeight()
               + widget_->getVerticalOffset();
        }
      
      void
      relink()
        {
          REQUIRE (widget_);
          widget_->updatePosition();
        }
      
      
    private:/* ===== Subject-Interface ===== */
      
      class DragRelocateObserver
        : public interact::GestureObserver
        {
          ClipPresenter& subject_;
          model::DisplayMetric const& metric_;
          TimeVar&  newTime_;
          Time      oldTime_;
          
          void
          updateOffset (double deltaX, double deltaY)  override
            {
              newTime_ = metric_.applyScreenDelta(oldTime_, deltaX);
              subject_.widget_->updatePosition();
              std::cerr << _Fmt{"Gesture(%s) → Δ ≔ (%3.1f,%3.1f) ⟹ %s ↷ %s"}
                               % getCmdID()
                               % deltaX
                               % deltaY
                               % oldTime_
                               % subject_.widget_->accessStartTime()
                        << std::endl;
            }
          
          void
          markGestureCompleted()  override
            {
              std::cerr << _Fmt{"!!BANG!! Gesture-Cmd '%s' Time ↷ %s"}
                               % getCmdID()
                               % newTime_
                        << std::endl;
            }
          
        public:
          DragRelocateObserver(Symbol cmdID, ClipPresenter& clipPresenter)
            : interact::GestureObserver{cmdID}
            , subject_{clipPresenter}
            , metric_ {subject_.widget_->getCanvas().getMetric()}
            , newTime_{subject_.widget_->accessStartTime()}
            , oldTime_{newTime_}
          { }
        };
      
      void
      buildGestureObserver (Symbol cmdID, Buffer buffer)  override
        {
          buffer.create<DragRelocateObserver> (cmdID, *this);
        }
      
      Gtk::Widget&
      exposeWidget()  override
        {
          return ClipDelegate::expect_and_expose_Widget (widget_);
        }
      
      
      
    private:/* ===== Internals ===== */
      void
      establishAppearance(WidgetHook* newView =nullptr,
                          optional<TimeSpan> const& timing =nullopt)
        {
          void* prevDelegate = widget_.get();
          auto newAppearance = ClipDelegate::selectAppearance (this->widget_, defaultAppearance, newView, timing);
          
          if (prevDelegate != widget_.get()
              and newAppearance > ClipDelegate::DEGRADED)
            {// a new dedicated clip widget has been created...
              interact::CmdContext::of (steam::cmd::scope_moveRelocateClip, GESTURE_dragReolcate)
                                   .linkSubject (*this)
                                   .setupRelocateDrag();
            }
        }
      
      
      WidgetHook&
      getClipContentCanvas()
        {
          UNIMPLEMENTED ("how to create and wire an embedded canvas for the clip contents/effects");
        }
    };
  
  
}}// namespace stage::timeline
#endif /*STAGE_TIMELINE_CLIP_PRESENTER_H*/