element-box-widget.cpp

Go to the documentation of this file.

/*
  ElementBoxWidget  -  fundamental UI building block to represent a placed element

  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.

* *****************************************************/


#include "stage/gtk-base.hpp"
#include "stage/widget/element-box-widget.hpp"
#include "stage/style-scheme.hpp"

#include "lib/util.hpp"



namespace stage {
namespace widget {
  
  
  namespace {//Implementation helpers...
    inline void
    queryNaturalSize (Gtk::Widget const& widget, Gtk::Requisition& natSize)
    {
      Gtk::Requisition minDummy;
      widget.get_preferred_size (minDummy, natSize);
    }
    
    inline int
    queryNaturalHeight (Gtk::Widget const& widget)
    {
      int minDummy{0}, natHeight{0};
      widget.get_preferred_height(minDummy, natHeight);
      return natHeight;
    }
    
    inline int
    queryNaturalWidth (Gtk::Widget const& widget)
    {
      int minDummy{0}, natWidth{0};
      widget.get_preferred_width(minDummy, natWidth);
      return natWidth;
    }

    Gtk::Requisition ICON_SIZ{};
    
    const double HYSTERESIS = 1.6;
    
    inline void
    initIconSizeHeuristic (Gtk::Widget const& icon)
    {
      if (ICON_SIZ.width > 0) return;
      queryNaturalSize (icon, ICON_SIZ);
    }
    
  }//(End)helpers
  
  
  
  
  IDLabel::~IDLabel()                    { }
  ElementBoxWidget::~ElementBoxWidget()  { }
  
  
  Literal
  ElementBoxWidget::Config::getIconID()  const
  {
    return ICON_placement;
  }
  
  Literal
  ElementBoxWidget::Config::getMenuSymb()  const
  {
    return ICON_arrow_hand_menu;
  }
  
  Gtk::IconSize
  ElementBoxWidget::Config::getIconSize()  const
  {
    return Gtk::ICON_SIZE_MENU;
  }

  
  ElementBoxWidget::Strategy
  ElementBoxWidget::Config::buildLayoutStrategy(ElementBoxWidget&)
  {
    Strategy strategy;
    if (widthConstraint_)
      strategy.getWidth = move(widthConstraint_);
    if (heightConstraint_)
      strategy.getHeight = move(heightConstraint_);
    return strategy;
  }
  
  
  IDLabel::IDLabel (Literal iconID, Literal menuSymb, Gtk::IconSize siz)
    : Gtk::Box{Gtk::ORIENTATION_HORIZONTAL}
    , imgIcon_{Gtk::StockID{iconID},   siz}    
    , imgMenu_{Gtk::StockID{menuSymb}, siz}   
    {
      icon_.set_image(imgIcon_);
      menu_.set_image(imgMenu_);
      this->add(icon_);
      this->add(menu_);
      this->add(name_);
      this->set_name(ID_idlabel);
      this->get_style_context()->add_class(CLASS_background);
      this->get_style_context()->add_class(CLASS_idlabel);
      icon_.get_style_context()->add_class(CLASS_idlabel_icon);
      menu_.get_style_context()->add_class(CLASS_idlabel_menu);
      name_.get_style_context()->add_class(CLASS_idlabel_name);
      name_.set_hexpand(true);
      
      this->show_all();
      initIconSizeHeuristic (icon_);
    }
  
  
  void
  IDLabel::setCaption(cuString& idCaption)
  {
    name_.set_text(idCaption);
    // can not retrieve size information from hidden widgets...
    this->show_all();     // Note: size constraint handling will trigger again
    // cache required full display size (for size constrained layout)
    queryNaturalSize (*this, labelFullSize_);
  }
  
  cuString
  IDLabel::getCaption()  const
  {
    return name_.get_text();
  }
  
  
  
  ElementBoxWidget::ElementBoxWidget (Config config)
    : EventBox{}
    , strategy_{config.buildLayoutStrategy(*this)}
    , label_{config.getIconID()
            ,config.getMenuSymb()
            ,config.getIconSize()}
    , frame_{}
    {
      set_name (ID_element);
      get_style_context()->add_class (CLASS_background);     // Style to ensure an opaque backdrop
      get_style_context()->add_class (CLASS_elementbox);
      label_.get_style_context()->add_class (CLASS_elementbox_idlabel);
      
      frame_.set_label_align (0.0, 0.0);
      frame_.set_label_widget(label_);
      this->add (frame_);
      
      this->show_all();
      label_.setCaption (config.getName());
    }
  
  
  void
  ElementBoxWidget::setName (cuString& nameID)
  {
    label_.setCaption (nameID);
  }
  
  cuString
  ElementBoxWidget::getName()  const
  {
    return label_.getCaption();
  }
  
  Gtk::SizeRequestMode
  ElementBoxWidget::get_request_mode_vfunc()  const
  {
    return Gtk::SizeRequestMode::SIZE_REQUEST_HEIGHT_FOR_WIDTH;
  }
  
  void
  ElementBoxWidget::get_preferred_width_vfunc (int& minimum_width, int& natural_width)  const
  {
    if (strategy_.is_size_constrained())
      minimum_width = natural_width = strategy_.getWidth();
    else
      _Base::get_preferred_width_vfunc (minimum_width,natural_width);
  }
  
  void
  ElementBoxWidget::get_preferred_height_vfunc (int& minimum_height, int& natural_height)  const
  {
    if (strategy_.shall_control_height())
      minimum_height = natural_height = strategy_.getHeight();
    else
      _Base::get_preferred_height_vfunc (minimum_height,natural_height);
  }
  
  void
  ElementBoxWidget::get_preferred_height_for_width_vfunc (int width, int& minimum_height, int& natural_height)  const
  {
    if (strategy_.is_size_constrained() and strategy_.shall_control_height())
      minimum_height = natural_height = strategy_.getHeight();
    else
      _Base::get_preferred_height_for_width_vfunc (width, minimum_height,natural_height);
  }
  
  void
  ElementBoxWidget::on_size_allocate (Gtk::Allocation& availableSize)
  {
    if (strategy_.is_size_constrained())
      imposeSizeConstraint (availableSize.get_width(), availableSize.get_height());
    _Base::on_size_allocate(availableSize);
  }
  
  
  void
  ElementBoxWidget::imposeSizeConstraint (int widthC, int heightC)
  {
    label_.imposeSizeConstraint (widthC, heightC);
  }
  
  void
  IDLabel::imposeSizeConstraint (int widthC, int heightC)
  {
    // short circuit: need to perform precise checks?
    if (  labelFullSize_.width >  widthC
       or labelFullSize_.height > heightC
       )
      this->adaptSize(widthC, heightC);
  }
  
  
  namespace {//IDLabel layout management internals....
    
    inline int
    reduce(Gtk::Button& icon)
    {
      int widthReduction{0};
      if (icon.get_visible())
        {
          widthReduction = queryNaturalWidth (icon);
          icon.hide();
        }
      return widthReduction;
    }

    inline int
    reduce(Gtk::Label& label, int goal)
    {
      ASSERT (goal >=0);
      int reduction{0};
      if (label.get_visible())
        {
          int width = queryNaturalWidth (label);
          if (reduction < goal)
            {//shortening alone does not suffice
              label.hide();
              reduction = width;
            }
        }
      return reduction;
    }
    
    template<class FUN>
    inline bool
    maybeShow(Gtk::Button& icon, int w, int h, FUN& reCheck)
    {
      if (icon.is_visible()) return true; // nothing can be done here
      bool success{false};
      if (w >= ICON_SIZ.width * HYSTERESIS and h >= ICON_SIZ.height)
        {
          icon.show();
          if (not (success=reCheck()))
            icon.hide();
        }
      return success;
    }
    
    template<class FUN>
    inline bool
    maybeShow(Gtk::Label& label, int w, int h, FUN& reCheck)
    {
      bool success{false};
      // use icon dimensions as as heuristics to determine
      // if attempting to show the label is worth trying...
      if (w >= ICON_SIZ.width * HYSTERESIS and h >= ICON_SIZ.height)
        {
          label.show();
          int width = queryNaturalWidth (label);
          int goal = width - w;
          if (goal > 0) // too large, yet might fit if shortened
            reduce (label, goal);
          if (not (success=reCheck()))
            label.hide();
        }
      return success;
    }
    

  }//(End)Layout helpers
  

  void
  IDLabel::adaptSize (int widthC, int heightC)
  {
    // first determine if vertical extension is problematic
    int currH = queryNaturalHeight (*this);
    if (currH > heightC)
      {//hide all child widgets,
      // not much options left...
        name_.hide();
        menu_.hide();
        icon_.hide();
        return;
      }
    
    // now test if we need to reduce or can expand
    int currW = queryNaturalWidth (*this);
    if  (currW > widthC)
      {//reduce to comply
        int goal = currW - widthC;
        ASSERT (goal > 0);
        if ((goal -= reduce(name_, goal)) <= 0) return;
        if ((goal -= reduce(menu_)      ) <= 0) return;
        if ((goal -= reduce(icon_)      ) <= 0) return;
        currW = queryNaturalWidth(*this);
        goal = currW - widthC;
        ENSURE (goal <= 0, "IDLabel layout management floundered. "
                           "Removed all content, yet remaining width %d > %d"
                         ,                                         currW, widthC);
      }
    else
      {//maybe some headroom left to show more?
        int headroom = widthC - currW;
        auto reCheck = [&]() -> bool
                          {// WARNING: side effect assignment
                            currW = queryNaturalWidth (*this);
                            currH = queryNaturalHeight(*this);
                            headroom = widthC - currW;
                            return currH <= heightC
                               and currW <= widthC;
                          };
        
        if (not maybeShow (icon_, headroom, heightC, reCheck)) return;
        if (not maybeShow (menu_, headroom, heightC, reCheck)) return;
        if (not maybeShow (name_, headroom, heightC, reCheck)) return;
      }
  }
  
  
  
}}// namespace stage::widget