track-head-widget.cpp

Go to the documentation of this file.

/*
  TrackHeadWidget  -  display of track heads 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.
 
* *****************************************************************/
 
 
#include "stage/gtk-base.hpp"
#include "stage/style-scheme.hpp"
#include "stage/timeline/track-head-widget.hpp"
 
#include "lib/util.hpp"
 
using util::max;
 
 
namespace stage {
namespace timeline {
  
  
  
  
  TrackHeadWidget::~TrackHeadWidget() { }
  HeadControlArea::~HeadControlArea() { }
  
  
  
  TrackHeadWidget::TrackHeadWidget()
    : Gtk::Grid{}
    , trackName_{widget::Kind::ITEM, widget::Type::LABEL}
    , structure_{}
    , padding_{}
    , headCtrl_{}
    , childCnt_{0}
    {
      get_style_context()->add_class (CLASS_fork_head);
      headCtrl_.set_valign(Gtk::Align::ALIGN_CENTER);
      headCtrl_.set_halign(Gtk::Align::ALIGN_FILL);
      this->attach (trackName_, 0,0, 2,1);
      this->attach (structure_, 0,1, 1,2);
      this->attach (headCtrl_, 1,1, 1,1); // corresponds to direct content
      this->attach (padding_,  1,2, 1,1);//  used to sync with sub-track display
      this->property_expand() = false;  //   do not expand to fill
      this->set_column_spacing(0);
      this->set_row_spacing(0);
      this->show_all();
    }
  
  
  HeadControlArea::HeadControlArea()
    : Gtk::Grid{}
    , ctrlTODO_{"\n 💡"}
    {
      get_style_context()->add_class (CLASS_fork_control);
      ctrlTODO_.set_xalign (0.3);
      ctrlTODO_.set_yalign (0.5);
      this->attach (ctrlTODO_, 0,0, 1,1);
      this->property_expand() = true;
      this->show_all();
    }
  
  
  void
  TrackHeadWidget::setTrackName (cuString& trackName)
  {
    trackName_.setName (trackName);
  }
  
  uint
  TrackHeadWidget::getHeightAt (int left, int top)  const
  {
    auto* cell = this->get_child_at(left,top);
    if (cell == nullptr) return 0;
    int actual = cell->get_height();
    int minimal=0, natural=0;
    cell->get_preferred_height(minimal, natural);
    return max (0, max (actual, natural));
  }
 
  uint
  TrackHeadWidget::getOverallHeight()  const
  {
    uint heightSum{0};
    for (uint line=1; line <= 2u + childCnt_; ++line)
      heightSum += getHeightAt (1,line);
    heightSum = max (heightSum, getExpansionHeight());
    return heightSum + getLabelHeight();
  }
  
  void
  TrackHeadWidget::enforceHeightAt(int left, int top, uint height)
  {
    auto* cell = this->get_child_at(left,top);
    REQUIRE (cell);
    cell->set_size_request (-1, height);
  }
  
  void
  TrackHeadWidget::accommodateContentHeight(uint contentHeight)
  {
    uint localHeight = getContentHeight();
    if (contentHeight > localHeight)
      enforceContentHeight (contentHeight);
  }
  
  void
  TrackHeadWidget::accommodateOverallHeight(uint overallHeight)
  {
    uint discrepancy{0};
    uint localHeight = getOverallHeight();
    if (overallHeight > localHeight)
      {
        enforceExpansionHeight (overallHeight - getLabelHeight());
        discrepancy = overallHeight-localHeight;
      }
    linkSubTrackPositions (discrepancy);
  }
 
  void
  TrackHeadWidget::syncSubtrackStartHeight (uint directHeight)
  {
    uint localHeight = getContentHeight() + getLabelHeight();
    if (directHeight > localHeight)
      enforceSyncPadHeight (directHeight - localHeight);
  }
  
  void
  TrackHeadWidget::linkSubTrackPositions(uint discrepancy)
  {
    structure_.clearConnectors();
    uint offset = getContentHeight()
                + getSyncPadHeight()
                + discrepancy
                + getLabelHeight()  // offset by the label in the children
                ;
    for (uint child=0; child < childCnt_; ++child)
      {
        structure_.addConnector (offset);
        offset += getHeightAt (1, child+3);
      }
  }
  
  
  void
  TrackHeadWidget::attachSubFork (TrackHeadWidget& subForkHead)
  {
    ++childCnt_;
    uint act = 2 + childCnt_;   //  left,top
    Gtk::Grid::attach (subForkHead, 1, act, 1,1);
    // expand the structure display column....
    Gtk::Grid::remove (structure_);   // width,height
    Gtk::Grid::attach (structure_,   0,1,    1, act);
  }
  
  void
  TrackHeadWidget::detachSubFork (TrackHeadWidget& subForkHead)
  {
    --childCnt_;
    uint act = 2 + childCnt_;
    Gtk::Grid::remove (subForkHead);
    // reduce the structure display column....
    Gtk::Grid::remove (structure_);
    Gtk::Grid::attach (structure_,   0,1, 1,act);
  }
  
  
  void
  TrackHeadWidget::clearFork()
  {
    if (not childCnt_) return;
    Gtk::Grid::remove (structure_);
    while (childCnt_ > 0)
      {
        Gtk::Grid::remove_row (childCnt_);
        --childCnt_;
      }
    Gtk::Grid::attach (structure_, 0,1, 1,2);
  }
 
  
  
  /* ==== Interface: ViewHook ===== */
  
  void
  TrackHeadWidget::hook (TrackHeadWidget& subHead)
  {
    attachSubFork (subHead);
  }
 
  void
  TrackHeadWidget::remove (TrackHeadWidget& subHead)
  {
    detachSubFork (subHead);
  }
  
  void
  TrackHeadWidget::rehook (TrackHeadWidget& hookedSubHead)  noexcept
  {
    detachSubFork (hookedSubHead);
    attachSubFork (hookedSubHead);
  }
  
  
  
}}// namespace stage::timeline