tangible.cpp

Go to the documentation of this file.

/*
  Tangible  -  common implementation base of all relevant interface elements

  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.

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


#include "stage/model/tangible.hpp"
#include "stage/model/widget.hpp"
#include "stage/model/controller.hpp"
#include "include/ui-protocol.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/meta/util.hpp"


namespace stage {
namespace model {
  
  
  
  Tangible::~Tangible() { }  // Emit VTables here...
  
  
  
  Tangible::operator string() const
  {
    return lib::meta::typeStr (this)
         + "("
         + string{this->getID()}
         + ")";
  }
  
  
  void
  Tangible::reset()
  {
    if (this->doReset())
      uiBus_.note (GenNode{string{MARK_reset}, true});
  }
  
  
  void
  Tangible::clearErr()
  {
    if (this->doClearErr())
      uiBus_.note (GenNode{string{MARK_clearErr}, true});
  }
  
  
  void
  Tangible::clearMsg()
  {
    if (this->doClearMsg())
      uiBus_.note (GenNode{string{MARK_clearMsg}, true});
  }
  
  
  void
  Tangible::markFlash()
  {
    this->doFlash();
  }
  
  
  void
  Tangible::markMsg (string message)
  {
    if (this->doMsg (message))
      uiBus_.note (GenNode{string{MARK_Message}, message});
  }
  
  
  void
  Tangible::markErr (string error)
  {
    if (this->doErr (error))
      uiBus_.note (GenNode{string{MARK_Error}, error});
  }
  
  
  void
  Tangible::slotExpand()
  {
    if (this->doExpand (true))
      uiBus_.note (GenNode{string{MARK_expand}, true});
  }
  
  
  void
  Tangible::slotCollapse()
  {
    if (this->doExpand (false))
      uiBus_.note (GenNode{string{MARK_expand}, false});
  }
  
  
  bool
  Tangible::doExpand (bool yes)
  {
    if (not expand_.canExpand())
      return false;
    bool oldState = expand_(yes);
    return oldState != yes; // actually changed
  }
  
  
  void
  Tangible::slotReveal()
  {
    this->doReveal();
  }
  
  
  void
  Tangible::doReveal()
  {
    if (reveal_.canReveal())
      reveal_();
  }
  
  
  
  void
  Tangible::invoke (Symbol cmdID, Rec&& arguments)
  {
    uiBus_.act (GenNode{string{cmdID}, std::forward<Rec>(arguments)});
  }
  
  
  
  void
  Tangible::mark (GenNode const& stateMark)
  {
    if (stateMark.idi.getSym() == MARK_Flash)
      this->doFlash();
    else
    if (stateMark.idi.getSym() == MARK_Error)
      this->markErr (stateMark.data.get<string>());
    else
    if (stateMark.idi.getSym() == MARK_Message)
      this->markMsg (stateMark.data.get<string>());
    else
      this->doMark(stateMark);
  }
  
  
  void
  Tangible::doMark (GenNode const& stateMark)
  {
    if (stateMark.idi.getSym() == MARK_expand)
      {
        if (this->doExpand (stateMark.data.get<bool>()))
          uiBus_.note (GenNode(string{MARK_expand}, true));    // possibly reentrant (yet harmless)
      }
    else
    if (stateMark.idi.getSym() == MARK_reset)
      this->reset();
    else
    if (stateMark.idi.getSym() == MARK_clearMsg)
      this->clearMsg();
    else
    if (stateMark.idi.getSym() == MARK_clearErr)
      this->clearErr();
    else
    if (stateMark.idi.getSym() == MARK_reveal)
      this->doReveal();
  }
  
  
  
}} // namespace stage::model