canvas-hook.hpp

Go to the documentation of this file.

/*
  CANVAS-HOOK.hpp  -  abstracted attachment to a canvas with free positioning

   Copyright (C)
     2020,            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_MODEL_CANVAS_HOOK_H
#define STAGE_MODEL_CANVAS_HOOK_H

#include "lib/time/timevalue.hpp"
#include "lib/nocopy.hpp"
#include "lib/util.hpp"

#include <utility>


namespace stage {
namespace model {
  
  using lib::time::Time;
  using lib::time::Offset;
  using lib::time::TimeValue;
  using lib::time::TimeSpan;
  
  
  
  class DisplayMetric
    {
    public:
      virtual ~DisplayMetric() { }    
      
      virtual TimeSpan coveredTime()  const                =0;
      
      virtual int translateTimeToPixels (TimeValue)  const =0;
      
      virtual int translateScreenDelta (Offset)  const     =0;
      
      virtual TimeValue applyScreenDelta(Time anchor, double deltaPx)  const =0;
    };
  
  
  
  template<class WID>
  class CanvasHook
    {
    public:
      virtual ~CanvasHook() { }    
      
      virtual void hook   (WID& widget, int xPos, int yPos)  =0;
      virtual void move   (WID& widget, int xPos, int yPos)  =0;
      virtual void remove (WID& widget)                      =0;

      virtual DisplayMetric& getMetric()  const              =0;
      
      virtual CanvasHook<WID>&
      getAnchorHook()  noexcept
        {
          return *this;
        }
      
      struct Pos
        {
          CanvasHook* view;
          int x,y;
        };
      
      Pos
      hookedAt (int x, int y)
        {
          return Pos{this, x,y};
        }
      
      Pos
      hookedAt (Time start, int downshift=0)
        {
          return hookedAt (getMetric().translateTimeToPixels (start), downshift);
        }
    };
  
  
  
  template<class WID, class BASE =WID>
  class CanvasHooked
    : public WID
    , util::NonCopyable
    {
      using Canvas = CanvasHook<BASE>;
      Canvas* view_;
      
    protected:
      Canvas& getCanvas()  const { return *view_; }
      
    public:
      template<typename...ARGS>
      CanvasHooked (typename Canvas::Pos attachmentPos, ARGS&& ...args)
        : WID{std::forward<ARGS>(args)...}
        , view_{attachmentPos.view}
        {
          getCanvas().hook (*this, attachmentPos.x, attachmentPos.y);
        }
      
     ~CanvasHooked()  noexcept
        {
          try {
              if (view_)
                view_->remove (*this);
            }
          ERROR_LOG_AND_IGNORE (progress, "Detaching of CanvasHooked widgets from the presentation")
        }
      
      void
      moveTo (int xPos, int yPos)
        {
          getCanvas().move (*this, xPos,yPos);
        }
    };
  
  
  
}}// namespace stage::model
#endif /*STAGE_MODEL_CANVAS_HOOK_H*/