clip-presenter.hpp

Go to the documentation of this file.

/*
  CLIP-PRESENTER.hpp  -  presentation control element for a clip 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_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*/