body-canvas-widget.cpp

Go to the documentation of this file.

/*
  BodyCanvasWidget  -  custom drawing canvas to display the timeline body

   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/body-canvas-widget.hpp"
#include "stage/timeline/display-manager.hpp"
#include "stage/timeline/track-profile.hpp"
#include "stage/timeline/track-body.hpp"
#include "stage/style-scheme.hpp"

#include "common/advice.hpp"
#include "lib/util.hpp"

#include <utility>


using lib::time::Time;
using util::max;
using util::isnil;
using Gdk::Rectangle;
using std::string;
using std::move;



namespace stage {
namespace timeline {
  
  using CairoC = PCairoContext const&;
  using StyleC = PStyleContext const&;
  
  namespace { // details of track background painting
    
    const int INITIAL_TIMERULER_HEIGHT_px = 30;
    const int INITIAL_CONTENT_HEIGHT_px = 100;
    const int MINIMAL_CONTENT_WIDTH_px = 100;
    
    lumiera::advice::Request<PStyleContext> trackBodyStyle{"style(trackBody)"};
    lumiera::advice::Request<PStyleContext> trackRulerStyle{"style(trackRuler)"};
    
    cuString
    slopeClassName(int depth)
    {
      switch (depth)
        {
          case 1: return CLASS_slope_deep1;
          case 2: return CLASS_slope_deep2;
          case 3: return CLASS_slope_deep3;
          case 4: return CLASS_slope_deep4;
          default:return CLASS_slope_verydeep;
        }
    }
    const uint SLOPE_CAP_DEPTH = 5;
    
    
    void
    setupAdditionalTrackPadding_fromCSS()
    {
      static bool styleSetupDone{false};
      if (styleSetupDone) return;
      
      StyleC styleRuler{trackRulerStyle.getAdvice()};
      StyleC styleBody {trackBodyStyle.getAdvice()};
      
      TrackBody::decoration.ruler = styleRuler->get_margin().get_top()
                                  + styleRuler->get_margin().get_bottom()
                                  + styleRuler->get_border().get_top()
                                  + styleRuler->get_border().get_bottom()
                                  + styleRuler->get_padding().get_top()
                                  + styleRuler->get_padding().get_bottom()
                                  ;
      TrackBody::decoration.content = styleBody->get_margin().get_top()
                                    + styleBody->get_margin().get_bottom()
                                    + styleBody->get_padding().get_top()
                                    + styleBody->get_padding().get_bottom()
                                    ;
      TrackBody::decoration.trackPad = styleBody->get_margin().get_top()
                                     + styleBody->get_padding().get_top()
                                     ;
      TrackBody::decoration.topMar = styleBody->get_margin().get_top();
      TrackBody::decoration.botMar = styleBody->get_margin().get_bottom();
      
      for (uint depth=SLOPE_CAP_DEPTH; depth>0; --depth)
        {
//        styleBody->context_save();                // <<<---does not work. Asked on SO: https://stackoverflow.com/q/57342478
          styleBody->add_class (slopeClassName(depth));
          
          TrackBody::decoration.borders[depth] = styleBody->get_border().get_bottom();
          TrackBody::decoration.borders[0]     = styleBody->get_border().get_top();   // Note: we use a common size for all opening borders
          
          styleBody->remove_class (slopeClassName(depth));
//        styleBody->context_restore();             // <<<---does not work...
        }
      styleSetupDone = true;
    }
    
    
    class AbstractTrackRenderer
      : public ProfileInterpreter
      {
      protected:
        CairoC cox_;
        StyleC style_;             // CSS style for the main track body
        StyleC styleR_;            // CSS style for the an overview ruler
        PixSpan visible_;          // vertical extension of the timeline
        
        int line_ = 0;
        
        void
        fillBackground (StyleC style, int height)
          {
            style->render_background (cox_
                                     ,visible_.b       // left start of the rectangle
                                     ,line_            // top of the rectangle
                                     ,visible_.delta() // width of the area
                                     ,height           // height to fill
                                     );
          }
        
      public:
        AbstractTrackRenderer (CairoC currentDrawContext, DisplayManager& layout)
          : cox_{currentDrawContext}
          , style_{trackBodyStyle.getAdvice()}
          , styleR_{trackRulerStyle.getAdvice()}
          , visible_{layout.getPixSpan()}
          { }
       /*
        * Note: we store a const& to the advice in the member fields.
        * This is potentially dangerous, but seems adequate here, since
        * the renderer instance does not outlive the BodyCanvasWidget,
        * and the style context accessed through the advice is created
        * once, at application startup. Please take into account that
        * this drawing code is invoked very frequently from GUI thread.
        */
      };
    
    
    class TrackGroundingRenderer
      : public AbstractTrackRenderer
      {
        
        void
        prelude()  override
          {
            int topMargin = style_->get_margin().get_top();
            line_ += topMargin;
          }
        
        void
        coda (uint pad)  override
          {
            int bottomPad = pad + style_->get_margin().get_bottom();
            line_ += bottomPad;
          }
        
        void
        ruler (uint contentHeight)  override
          {
            int marTop = styleR_->get_margin().get_top();
            int marBot = styleR_->get_margin().get_bottom();
            int padTop = styleR_->get_padding().get_top();
            int padBot = styleR_->get_padding().get_bottom();
            int frameT = styleR_->get_border().get_top();
            int frameB = styleR_->get_border().get_bottom();
            
            int heightWithFrame = contentHeight + padTop+padBot + frameT+frameB;
            
            line_ += marTop;
            fillBackground(styleR_, heightWithFrame);
            styleR_->render_frame (cox_
                                  ,visible_.b
                                  ,line_
                                  ,visible_.delta()
                                  ,heightWithFrame
                                  );
            line_ += heightWithFrame;
            line_ += marBot;
          }
        
        void
        gap (uint h)  override
          {
            line_ += h;
          }
        
        void
        content (uint contentHeight)  override
          {
            int marTop = style_->get_margin().get_top();
            int marBot = style_->get_margin().get_bottom();
            int padTop = style_->get_padding().get_top();
            int padBot = style_->get_padding().get_bottom();
            int heightWithPadding = contentHeight + padTop+padBot;
            
            line_ += marTop;
            fillBackground (style_, heightWithPadding);
            line_ += heightWithPadding;
            line_ += marBot;
          }
        
        void
        open()  override
          {
//          style_->context_save();                // <<<---does not work. Asked on SO: https://stackoverflow.com/q/57342478
            style_->add_class (slopeClassName (1));
            int slopeWidth = style_->get_border().get_top();
            style_->render_frame_gap(cox_
                                 ,visible_.b       - slopeWidth
                                 ,line_
                                 ,visible_.delta() + 2*slopeWidth
                                 ,2*slopeWidth
                                 //_______________________________we only need the top side of the frame
                                 ,Gtk::PositionType::POS_BOTTOM
                                 ,visible_.b
                                 ,visible_.e       + 2*slopeWidth
                                 );
//          style_->context_restore();             // <<<---does not work...
            style_->remove_class (slopeClassName(1));
            line_ += slopeWidth;
          }
        
        void
        close (uint n)  override
          {
//          style_->context_save();                // <<<---does not work. Asked on SO: https://stackoverflow.com/q/57342478
            style_->add_class (slopeClassName(n));
            int slopeWidth = style_->get_border().get_bottom();
            line_ -= slopeWidth;  // set back to create room for the (invisible) top side of the frame
            style_->render_frame_gap(cox_
                                 ,visible_.b       - slopeWidth
                                 ,line_
                                 ,visible_.delta() + 2*slopeWidth
                                 ,2*slopeWidth
                                 //_______________________________we only need the bottom side of the frame
                                 ,Gtk::PositionType::POS_TOP
                                 ,visible_.b
                                 ,visible_.e       + 2*slopeWidth
                                 );
//          style_->context_restore();             // <<<---does not work...
            style_->remove_class (slopeClassName(n));
            line_ += 2*slopeWidth;
          }
        
      public:
        using AbstractTrackRenderer::AbstractTrackRenderer;
      };
    
    
    
    class TrackOverlayRenderer
      : public AbstractTrackRenderer
      {
        
        void
        prelude()  override
          {
            /* nothing to paint */
            line_ += style_->get_margin().get_top();
          }
        
        void
        coda (uint pad)  override
          {
            /* nothing to paint */
            line_ += pad + style_->get_margin().get_bottom();
          }
        
        void
        ruler (uint contentHeight)  override
          {
            int marTop = styleR_->get_margin().get_top();
            int marBot = styleR_->get_margin().get_bottom();
            int padTop = styleR_->get_padding().get_top();
            int padBot = styleR_->get_padding().get_bottom();
            int frameT = styleR_->get_border().get_top();
            int frameB = styleR_->get_border().get_bottom();
            
            int heightWithFrame = contentHeight + padTop+padBot + frameT+frameB;
            
            /* nothing to paint */
            line_ += marTop
                   + heightWithFrame
                   + marBot;
          }
        
        void
        gap (uint h)  override
          {
            /* nothing to paint */
            line_ += h;
          }
        
        void
        content (uint contentHeight)  override
          {
            int marTop = style_->get_margin().get_top();
            int marBot = style_->get_margin().get_bottom();
            int padTop = style_->get_padding().get_top();
            int padBot = style_->get_padding().get_bottom();
            int heightWithPadding = contentHeight + padTop+padBot;
            
            /* nothing to paint */
            line_ += marTop
                   + heightWithPadding
                   + marBot;
          }
        
        void
        open()  override
          {
//          style_->context_save();                // <<<---does not work. Asked on SO: https://stackoverflow.com/q/57342478
            style_->add_class (slopeClassName (1));
            int slopeWidth = style_->get_border().get_top();
//          style_->context_restore();             // <<<---does not work...
            style_->remove_class (slopeClassName(1));
            line_ += slopeWidth;
          }
        
        void
        close (uint n)  override
          {
//          style_->context_save();                // <<<---does not work. Asked on SO: https://stackoverflow.com/q/57342478
            style_->add_class (slopeClassName(n));
            int slopeWidth = style_->get_border().get_bottom();
//          style_->context_restore();             // <<<---does not work...
            style_->remove_class (slopeClassName(n));
            line_ += slopeWidth;
          }
        
      public:
        using AbstractTrackRenderer::AbstractTrackRenderer;
      };
    
    
    template<class PINT, bool isRuler>
    auto
    makeRenderer (DisplayManager& layout, BodyCanvasWidget::ProfileGetter& getProfile)
      {
        return [&](CairoC cox)
                {
                  PINT concreteRenderScheme{cox, layout};
                  getProfile().performWith (concreteRenderScheme, isRuler);
                };
      }
    
    // abbreviations for readability
    using Grounding = TrackGroundingRenderer;
    using Overlay   = TrackOverlayRenderer;
    const bool RULER = true;
    const bool BODY  = false;
  }
  
  
  
  
  
  BodyCanvasWidget::~BodyCanvasWidget() { }
  
  
  BodyCanvasWidget::BodyCanvasWidget (DisplayManager& displayManager)
    : Glib::ObjectBase("body")    // enables use of custom CSS properties (on 'gtkmm__CustomObject_body')
    , Gtk::Box{Gtk::ORIENTATION_VERTICAL}
    , layout_{displayManager}
    , profile_{}
    , rootBody_{nullptr}
    , contentArea_{}
    , rulerArea_{contentArea_.get_hadjustment(), Gtk::Adjustment::create (0,0,0,0,0,0)}
    , rulerCanvas_{makeRenderer<Grounding,RULER>(layout_,getProfile), makeRenderer<Overlay,RULER>(layout_,getProfile)}
    , mainCanvas_ {makeRenderer<Grounding,BODY> (layout_,getProfile), makeRenderer<Overlay,BODY> (layout_,getProfile)}
    {
      get_style_context()->add_class(CLASS_timeline);
      get_style_context()->add_class(CLASS_timeline_body);
      
      // respond to any structure changes of the timeline by recomputing the TrackProfile
      layout_.signalStructureChange_.connect (sigc::mem_fun (*this, &BodyCanvasWidget::slotStructureChange));
      
      // on demand access and possible (re)establish the current "profile" of the tracks for drawing...
      getProfile = [this]() -> TrackProfile&
                        {
                          maybeRebuildLayout();
                          return profile_;
                        };
      
      // initially set up some dummy space. Will be updated to match on first draw() call...
      adjustCanvasSize(MINIMAL_CONTENT_WIDTH_px, INITIAL_CONTENT_HEIGHT_px, INITIAL_TIMERULER_HEIGHT_px);
      
      this->set_border_width (0);
      this->property_expand() = true;   // dynamically grab any available additional space
      this->pack_start (rulerArea_,   Gtk::PACK_SHRINK);
      this->pack_start (contentArea_, Gtk::PACK_EXPAND_WIDGET);
      
      rulerArea_.set_shadow_type (Gtk::SHADOW_NONE);
      rulerArea_.set_policy (Gtk::POLICY_NEVER, Gtk::POLICY_NEVER);
      rulerArea_.property_expand() = false;
      rulerArea_.add (rulerCanvas_);
      contentArea_.set_shadow_type (Gtk::SHADOW_NONE);
      contentArea_.set_policy (Gtk::POLICY_ALWAYS, Gtk::POLICY_ALWAYS);  // always use both scrollbars ////////////////TICKET #1208 : 2/2002 Gtk::POLICY_AUTOMATIC hides scrollbar after focus loss 
      contentArea_.property_expand() = true;                            //  dynamically grab additional space
      contentArea_.add (mainCanvas_);
      
      // realise all initially configured elements....
      this->show_all();
    }
  
  
  
  void
  BodyCanvasWidget::installForkRoot (TrackBody& rootTrackBody)
  {
    rootBody_ = &rootTrackBody;
  }
  
  void
  BodyCanvasWidget::disable()
  {
    profile_.clear();
    rootBody_ = nullptr;
  }
  
  
  void
  BodyCanvasWidget::slotStructureChange()  noexcept
  {
    profile_.clear();
  }
  
  
  void
  BodyCanvasWidget::maybeRebuildLayout()
  {
    while (rootBody_ and isnil (profile_))
      {
        setupAdditionalTrackPadding_fromCSS();
        layout_.triggerDisplayEvaluation();
      }
    ENSURE (not isnil (profile_), "DisplayEvaluation logic broken");
  }
  
  
  
  void
  BodyCanvasWidget::adjustCanvasSize(int canvasWidth, int contentHeight, int rulerHeight)
  {
    auto adjust = [](Gtk::Layout& canvas, guint newWidth, guint newHeight) -> void
                    {
                      guint currWidth{0}, currHeight{0};
                      canvas.get_size(currWidth, currHeight);
                      if (currWidth != newWidth or currHeight != newHeight)
                        {
                          canvas.set_size(newWidth, newHeight);
                            // Note: must force GTK at least to claim the necessary height,
                           //        otherwise the enclosing Box won't reflow and adapt;
                          //         implicitly this defines minimum timeline window width
                          canvas.set_size_request(MINIMAL_CONTENT_WIDTH_px, newHeight);
                        }
                    };
    
    adjust (rulerCanvas_, canvasWidth, rulerHeight);
    adjust (mainCanvas_, canvasWidth, contentHeight);
  }
  

  void
  BodyCanvasWidget::forceRedraw()
  {
    rulerCanvas_.queue_draw();
    mainCanvas_.queue_draw();
  }
  
  TimelineCanvas&
  BodyCanvasWidget::getCanvas (int yPos)
  {
    return mainCanvas_; 
  }
  
  
  /* ==== Interface: CanvasHook ===== */
  
  void
  BodyCanvasWidget::hook (Gtk::Widget& widget, int xPos, int yPos)
  {
    getCanvas(yPos).put (widget, xPos, yPos);
  }
  
  void
  BodyCanvasWidget::remove (Gtk::Widget& widget)
  {
    getCanvas(0).remove (widget);
  }
  
  void
  BodyCanvasWidget::move (Gtk::Widget& widget, int xPos, int yPos)
  {
    getCanvas(yPos).move (widget, xPos, yPos);
  }
  
  model::DisplayMetric&
  BodyCanvasWidget::getMetric()  const
  {
    return layout_;
  }
  
  void
  BodyCanvasWidget::establishLayout (DisplayEvaluation&)
  {
    // Traverse TrackBody structure and populate the (track)profile
    uint contentHeight = rootBody_->establishTrackSpace (profile_);
    uint rulerHeight = rootBody_->calcRulerHeight();
    adjustCanvasSize(layout_.getPixSpan().delta(), contentHeight, rulerHeight);
    
  }
  
  void
  BodyCanvasWidget::completeLayout (DisplayEvaluation&)
  { /* nothing to do */ }
  
  
  
  
  
  
  TimelineCanvas::TimelineCanvas (_Renderer groundingFun, _Renderer overlayFun)
    : Gtk::Layout{}
    , renderGrounding_{groundingFun}
    , renderOverlay_{overlayFun}
    { }
  
  
  bool
  TimelineCanvas::on_draw (CairoC cox)
  {
    // draw track structure behind all widgets
    openCanvas (cox);
    drawGrounding (cox);
    closeCanvas (cox);
    
    // cause child widgets to be redrawn
    bool event_is_handled = Gtk::Layout::on_draw(cox);
    
    // draw dynamic markers and locators on top
    openCanvas (cox);
    drawOverlays (cox);
    closeCanvas (cox);
    
    return event_is_handled;
  }
  
  
  void
  TimelineCanvas::openCanvas (CairoC cox)
  {
    auto adjH = get_hadjustment();
    auto adjV = get_vadjustment();
    double offH = adjH->get_value();
    double offV = adjV->get_value();
    
    cox->save();
    cox->translate(-offH, -offV);
  }
  
  
  void
  TimelineCanvas::closeCanvas (CairoC cox)
  {
    cox->restore();
  }
  
  
  void
  TimelineCanvas::drawGrounding (CairoC cox)
  {
    renderGrounding_(cox);
  }
  
  
  void
  TimelineCanvas::drawOverlays (CairoC cox)
  {
    renderOverlay_(cox);
  }
  
  
  
}}// namespace stage::timeline