clip-widget.cpp

Go to the documentation of this file.

/*
  ClipWidget  -  display of a clip in timeline or media bin view
 
   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.
 
* *****************************************************************/
 
 
#include "stage/gtk-base.hpp"
#include "stage/timeline/clip-widget.hpp"
#include "stage/widget/element-box-widget.hpp"
 
#include "lib/format-string.hpp"
 
#include "lib/util.hpp"
 
#include <utility>
 
 
 
using util::_Fmt;
using lib::time::TimeVar;
using util::unConst;
using std::optional;
 
 
namespace stage {
namespace timeline {
  namespace error = lumiera::error;
  
  const int    ClipDelegate::defaultOffsetY{0};
  const string ClipDelegate::defaultName{_("clip")};
  
  
  ClipDelegate::ClipDelegate()  { }
  ClipDelegate::~ClipDelegate() { }
  
  
  namespace {// details of concrete clip appearance styles...
   
    using WidgetHook   = model::CanvasHook<Gtk::Widget>;
    using HookedWidget = model::CanvasHooked<widget::ElementBoxWidget, Gtk::Widget>;
    
    
    class ClipData
      : public ClipDelegate
      , util::MoveOnly
      {
        TimeVar start_;
        TimeVar dur_;
        
      public: /* === Partial implementation of ClipDelegate === */
        TimeVar&
        accessStartTime()  override
          {
            return start_;
          }
        
        TimeVar&
        accessDuration()  override
          {
            return this->dur_;
          }
        
        
      public:
        ClipData(TimeSpan const& timings =TimeSpan{Time::NEVER, Duration::NIL})
          : ClipDelegate{}
          , start_{timings.start()}
          , dur_{timings.duration()}
          { }
        
        ClipData (ClipData&&)   = default;
      };
    
    
    class DormantClip
      : public ClipData
      {
        WidgetHook& display_;
        uString clipName_;
        
        /* === Interface ClipDelegate === */
        
        Appearance
        currentAppearance()  const override
          {
            return Appearance::PENDING;
          }
        
        Appearance
        changeAppearance (Appearance)  override
          {
            return currentAppearance();
          }
        
        cuString
        getClipName()  const override
          {
            return clipName_;
          }
        
        void
        setClipName(cuString& newName)  override
          {
            clipName_ = newName;
          }
        
        
        uint
        calcRequiredHeight()  const override
          {
            return 0;
          }
        
        uint
        getVerticalOffset()  const override
          {
            return 0;
          }
        
        WidgetHook&
        getCanvas()  const override
          {
            return unConst(this)->display_;
          }
        
        void
        updatePosition()  override
          {
            /* NOOP */
          }
 
        
      public:
        DormantClip(WidgetHook& displayAnchor)
          : ClipData{}
          , display_{displayAnchor}
          , clipName_{}
          { }
        
        DormantClip(ClipData&& existing)
          : ClipData{std::move (existing)}
          , display_{existing.getCanvas()}
          , clipName_{existing.getClipName()}
          { }
      };
    
    
    class ClipWidget
      : public HookedWidget
      , public ClipData
      {
        
        /* === Interface ClipDelegate === */
        
        Appearance
        currentAppearance()  const override
          {
            return Appearance::COMPACT;
          }
        
        Appearance
        changeAppearance (Appearance desired)  override
          {
            return currentAppearance();
          }
        
        cuString
        getClipName()  const override
          {
            return widget::ElementBoxWidget::getName();
          }
        
        void
        setClipName(cuString& newName)  override
          {
            widget::ElementBoxWidget::setName (newName);
          }
        
        uint
        getVerticalOffset() const override
          {
            return defaultOffsetY;  
          }
 
        uint
        calcRequiredHeight()  const override
          {
            return this->get_height();   
          }
 
        WidgetHook&
        getCanvas()  const override
          {
            return HookedWidget::getCanvas();
          }
        
        void
        updatePosition()  override
          {
            WidgetHook::Pos nominalPos = establishHookPoint(nullptr);
            this->moveTo (nominalPos.x, nominalPos.y);                    
            establishHorizontalExtension();
          }
        
        /* ==== Size and Layout handling ==== */
        
        int
        establishHorizontalExtension()
          {
            int hsiz = getCanvas().getMetric().translateTimeToPixels (accessDuration());
            return hsiz;
          }
        
        
      public:
        ClipWidget(WidgetHook& displayAnchor, TimeSpan const& timings)
          : HookedWidget{displayAnchor.hookedAt(timings, defaultOffsetY), widget::Kind::CONTENT
                                                                        , widget::Type::VIDEO    
                                                                        , widget::name(defaultName)
                                                                        , widget::constrained(
                                                                            [this]() { return establishHorizontalExtension(); }
                                                                        )}
          , ClipData{timings}
          {
            show_all();
          }
        
        ClipWidget(ClipData&& existing, WidgetHook* newView =nullptr)
          : HookedWidget{existing.establishHookPoint(newView)           , widget::Kind::CONTENT
                                                                        , widget::Type::VIDEO    
                                                                        , widget::name(existing.getClipName())
                                                                        , widget::constrained(
                                                                            [this]() { return establishHorizontalExtension(); }
                                                                        )}
          , ClipData{std::move (existing)}
          {
            show_all();
          }
      };
    
    
    
    enum Mode { HIDDEN, SUMMARY, INDIVIDUAL };
    
    inline Mode
    classifyAppearance (ClipDelegate::Appearance appearance)
      {
        return appearance < ClipDelegate::SYMBOLIC? HIDDEN
             : appearance < ClipDelegate::ABRIDGED? SUMMARY
             :                                      INDIVIDUAL;
      }
    
    
    inline bool
    canShow (Time start)
    {
      return start != Time::NEVER;
    }
    
    inline bool
    canRepresentAsClip (PDelegate& existing, optional<TimeSpan> const& timing)
    {
      return (existing and canShow(existing->accessStartTime()))
          or (not existing and timing and canShow(timing->start())) ;
    }
    
    
    inline ClipDelegate*
    buildDelegateFor (Mode newMode, PDelegate& existingDelegate, WidgetHook* newView, optional<TimeSpan> const& timing)
    {
      if (existingDelegate)
        { // flip existing delegate to another instance for newMode...
          REQUIRE (INSTANCEOF (ClipData, existingDelegate.get()));
          ClipData& clipData = static_cast<ClipData&> (*existingDelegate);
          
          switch (newMode)
            {
              case HIDDEN:
                return new DormantClip (std::move (clipData));
              case INDIVIDUAL:
                return new ClipWidget (std::move (clipData), newView);
              case SUMMARY:
                UNIMPLEMENTED ("Summary/Overview presentation style");
            }
        }
      else
        { // First time: build new delegate from scratch
          REQUIRE (newMode==HIDDEN or (timing and canShow (timing->start())));
          REQUIRE (newView);
          
          switch (newMode)
            {
              case HIDDEN:
                return new DormantClip{*newView};
              case INDIVIDUAL:
                return new ClipWidget{*newView, *timing};
              case SUMMARY:
                UNIMPLEMENTED ("Summary/Overview presentation style");
            }
        }
      NOTREACHED("unsupported clip display mode.");
    }
  }//(End)clip appearance details.
  
  
  
  /* === Appearance Style state transitions === */
  
  ClipDelegate::Appearance
  ClipDelegate::selectAppearance (PDelegate& existing, Appearance desired, WidgetHook* newView, optional<TimeSpan> const& timing)
  {
    REQUIRE (existing or newView, "need either an existing delegate or also a new View/Canvas");
    
    Appearance current = existing? existing->currentAppearance()
                                 : Appearance::PENDING;
    if (not canRepresentAsClip (existing, timing))
      desired = Appearance::PENDING;
    // classify all possible appearances into three base presentation modes
    Mode curMode = classifyAppearance (current);
    Mode newMode = classifyAppearance (desired);
    
    if (newView or newMode != curMode)
      { // need to switch the clip delegate
        PDelegate newState (buildDelegateFor (newMode, existing, newView, timing));
        swap (existing, newState);
      }
    ENSURE (existing);
    return existing->changeAppearance (desired);
    // fine-tune appearance style within limits of the mode established
  }
  
  
  WidgetHook::Pos
  ClipDelegate::establishHookPoint (WidgetHook* newView)
  {
    if (not newView)
      newView = & getCanvas();
    return newView->hookedAt (Time{accessStartTime()}, defaultOffsetY);
  }
  
  
  Gtk::Widget&
  ClipDelegate::expect_and_expose_Widget (PDelegate& manager)
  {
    if (manager and manager->currentAppearance() >= ClipDelegate::ABRIDGED)
      return static_cast<ClipWidget&> (*manager);
    
    else
      throw error::State (_Fmt{"Attempt to access the Widget for clip('%s') in presentation state %d. "
                               "This implies an error in the signal wiring logic and state handling."}
                              % string{manager? manager->getClipName() : "<not initialised>"}
                              % int   {manager? manager->currentAppearance() : -1}
                         ,LERR_(UIWIRING)
                         );
  }
 
  
  
}}// namespace stage::timeline