tangible.hpp

Go to the documentation of this file.

/*
  TANGIBLE.hpp  -  a tangible element of the user interface

  Copyright (C)         Lumiera.org
    2015,               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_MODEL_TANGIBLE_H
#define STAGE_MODEL_TANGIBLE_H


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "stage/ctrl/bus-term.hpp"
#include "stage/model/expander-revealer.hpp"
#include "lib/diff/diff-mutable.hpp"
#include "lib/idi/entry-id.hpp"
#include "lib/symbol.hpp"

#include <sigc++/trackable.h>
#include <utility>
#include <string>


namespace stage {
namespace model {
  
  using std::string;
  using lib::Symbol;
  
  
  class Tangible
    : public sigc::trackable
    , public lib::diff::DiffMutable
    , util::NonCopyable
    {
    public:
      using ID = ctrl::BusTerm::ID;
      using LuidH = lib::hash::LuidH;
    protected:
      using Rec     = lib::diff::Rec;
      using GenNode = lib::diff::GenNode;
      
      ctrl::BusTerm uiBus_;
      
      Expander expand_;
      Revealer reveal_;
      
      
      Tangible(ID identity, ctrl::BusTerm& nexus)
        : uiBus_{nexus.attach(identity, *this)}
        , expand_{}
        , reveal_{}
        { }
      
    public:
      virtual ~Tangible();  
      
      operator string() const;
      operator LuidH()  const { return uiBus_.getID().getHash(); }
      
      ID getID()        const { return uiBus_.getID();}
      
      void reset();
      void clearMsg();
      void clearErr();
      
      template<typename...ARGS>
      void invoke (Symbol cmdID, ARGS&&...);
      void invoke (Symbol cmdID, Rec&& arguments);
      
      void slotExpand();
      void slotCollapse();
      void slotReveal();
      
      void markFlash();
      void markMsg (string message);
      void markErr (string error);
      void mark(GenNode const&);
      
      void installExpander (Expander::ProbeFun, Expander::ChangeFun);
      void installRevealer (Revealer::RevealeItFun);
      
    protected:
      virtual bool doReset()           =0;
      virtual bool doClearMsg()        =0;
      virtual bool doClearErr()        =0;
      virtual bool doExpand (bool yes);
      virtual void doReveal ();
      
      virtual bool doMsg (string)          =0;
      virtual bool doErr (string)          =0;
      virtual void doFlash()               =0;
      virtual void doMark(GenNode const&)  =0;
      
    public:
      virtual void buildMutator (lib::diff::TreeMutator::Handle)  =0;
      
      
      friend constexpr size_t
      treeMutatorSize (const Tangible*)
      {
        return 512;
      }
    };
  
  
  
  template<typename...ARGS>
  inline lib::diff::GenNode
  commandMessage (Symbol cmdID, ARGS&&... args)
  {
    using lib::diff::Rec;
    using lib::diff::GenNode;
    using GenNodeIL = std::initializer_list<GenNode>;
    
    
    return GenNode (string{cmdID},
                    Rec(Rec::TYPE_NIL_SYM
                       ,GenNodeIL{}
                       ,GenNodeIL {std::forward<ARGS> (args)...}));
  }                  // not typed, no attributes, all arguments as children
  
  
  template<typename...ARGS>
  inline void
  Tangible::invoke (Symbol cmdID, ARGS&&... args)
  {
    uiBus_.act (commandMessage (cmdID, std::forward<ARGS> (args)...));
  }
  
  
  inline void
  Tangible::installExpander (Expander::ProbeFun detectCurrExpansionState,
                             Expander::ChangeFun howto_expand_collapse)
  {
    expand_ = Expander{move (detectCurrExpansionState), move (howto_expand_collapse)};
  }
  
  
  inline void
  Tangible::installRevealer (Revealer::RevealeItFun how_to_uncover_the_element)
  {
    reveal_ = Revealer{move (how_to_uncover_the_element)};
  }

  
  
  
}} // namespace stage::model
#endif /*STAGE_MODEL_TANGIBLE_H*/