element-box-widget.hpp

Go to the documentation of this file.

/*
  ELEMENT-BOX-WIDGET.hpp  -  fundamental UI building block to represent a placed element

  Copyright (C)         Lumiera.org
    2018,               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.

*/


#ifndef STAGE_WIDGET_ELEMENT_BOX_WIDGET_H
#define STAGE_WIDGET_ELEMENT_BOX_WIDGET_H

#include "stage/gtk-base.hpp"
#include "stage/model/expander-revealer.hpp"
#include "lib/builder-qualifier-support.hpp"

#include "lib/format-string.hpp" 
#include "lib/symbol.hpp"

#include <functional>
#include <utility>
#include <string> 
#include "lib/format-cout.hpp" 



namespace stage  {
namespace widget {
  
  using std::move;
  using lib::Literal;
  using std::string; 
  using util::_Fmt;  
  
  enum Kind { MARK     
            , SPAN     
            , ITEM     
            , CONTENT  
            };
  
  enum Type { VIDEO    
            , AUDIO    
            , TEXT     
            , AUTO     
            , EVENT    
            , EFFECT   
            , LABEL    
            , RULER    
            , GROUP    
            , META     
            };
  
  using SizeGetter = std::function<int()>;
  
  
  
  class IDLabel
    : public Gtk::Box
    {
      Gtk::Image  imgIcon_;
      Gtk::Image  imgMenu_;
      Gtk::Button icon_;
      Gtk::Button menu_;
      Gtk::Label  name_;
      
    public:
     ~IDLabel();
      IDLabel(Literal iconID, Literal menuSymb, Gtk::IconSize);
      
      cuString getCaption()  const;
      void setCaption(cuString&);
      
      void imposeSizeConstraint(int, int);
      
    private:
      Gtk::Requisition labelFullSize_{};
      void adaptSize (int, int);
    };
  
  
  
  /*************************************************************************/
  class ElementBoxWidget
    : public Gtk::EventBox
    {
      using _Base = Gtk::EventBox;
      struct Strategy
        {
          SizeGetter getWidth{};
          SizeGetter getHeight{};
          
          bool is_size_constrained()  const { return bool(getWidth); }
          bool shall_control_height() const { return bool(getHeight); }
        };
      
      Strategy strategy_;
      
      IDLabel label_;
      Gtk::Frame frame_;
      
    public:
      class Config;
      
      template<class... QS>
      ElementBoxWidget (Kind kind, Type type, QS ...qualifiers);
      
      ElementBoxWidget (Config);
     ~ElementBoxWidget();
      
      // default copy acceptable
      
      void setName(cuString&);
      cuString getName()  const;
      
      void set_label(cuString& s) { setName(s); }
      cuString get_label()  const { return getName(); }
      
    private:/* ===== Internals ===== */
      
      Gtk::SizeRequestMode get_request_mode_vfunc()              const final;
      void get_preferred_width_vfunc (int&, int&)                const override;
      void get_preferred_height_vfunc (int&, int&)               const override;
      void get_preferred_height_for_width_vfunc (int, int&,int&) const override;
      void on_size_allocate (Gtk::Allocation&)                         override;
      
      void imposeSizeConstraint(int, int);
    };
  
  
  class ElementBoxWidget::Config
    : lib::BuilderQualifierSupport<Config>
    {
      Type type_;
      uString nameID_{"∅"};
      SizeGetter widthConstraint_;
      SizeGetter heightConstraint_;
      string logTODO_{nameID_};    
      
      friend Qualifier kind(Kind);
      friend Qualifier name(string id);
      friend Qualifier expander(model::Expander&);
      friend Qualifier constrained(SizeGetter);
      friend Qualifier constrained(SizeGetter,SizeGetter);
      
      public:
        template<class... QS>
        Config(Type type, Qualifier qual, QS... qs)
          : type_{type}
        {
          qualify(*this, qual, qs...);
        }
        
        Strategy buildLayoutStrategy(ElementBoxWidget&);
        
        Literal getIconID()         const;
        Literal getMenuSymb()       const;
        Gtk::IconSize getIconSize() const;
        
        cuString
        getName()  const
          {
            return nameID_;
          }
    };
  
  
  inline ElementBoxWidget::Config::Qualifier
  kind(Kind kind)
  {
    return ElementBoxWidget::Config::Qualifier{
            [=](ElementBoxWidget::Config& config)
              {
                config.logTODO_ += util::_Fmt{"+kind(%s)"} % kind;
              }};
  }
  
  inline ElementBoxWidget::Config::Qualifier
  name(string id)
  {
    return ElementBoxWidget::Config::Qualifier{
            [=](ElementBoxWidget::Config& config)
              {
                config.nameID_ = id;
              }};
  }
  
  inline ElementBoxWidget::Config::Qualifier
  expander(model::Expander& expander)
  {
    return ElementBoxWidget::Config::Qualifier{
            [&](ElementBoxWidget::Config& config)
              {
                config.logTODO_ += util::_Fmt{"+expander(%s)"} % &expander;
              }};
  }
  
  inline ElementBoxWidget::Config::Qualifier
  constrained(SizeGetter widthConstraint)
  {
    return ElementBoxWidget::Config::Qualifier{
            [wC=move(widthConstraint)](ElementBoxWidget::Config& config) -> void
              {
                config.widthConstraint_ = move(wC);
              }};
  }
  
  inline ElementBoxWidget::Config::Qualifier
  constrained(SizeGetter widthConstraint, SizeGetter heightConstraint)
  {
    return ElementBoxWidget::Config::Qualifier{
            [wC=move(widthConstraint),hC=move(heightConstraint)]
            (ElementBoxWidget::Config& config) -> void
              {
                config.widthConstraint_ = move(wC);
                config.heightConstraint_ = move(hC);
              }};
  }
  
  
  
  template<class... QS>
  inline ElementBoxWidget::ElementBoxWidget (Kind widgetKind, Type type, QS ...qualifiers)
    : ElementBoxWidget{Config(type, kind(widgetKind), qualifiers...)}
  { }
  
  
}}// namespace stage::widget
#endif /*STAGE_WIDGET_ELEMENT_BOX_WIDGET_H*/