notification-hub.hpp

Go to the documentation of this file.

/*
  NOTIFICATION-HUB.hpp  -  receive and reroute notification messages

  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_CTRL_NOTIFICATION_HUB_H
#define STAGE_CTRL_NOTIFICATION_HUB_H

#include "stage/widget/error-log-display.hpp"
#include "lib/diff/tree-mutator.hpp"
#include "stage/model/controller.hpp"
#include "stage/model/w-link.hpp"

#include <functional>


namespace stage {
namespace ctrl {
  
  using lib::diff::TreeMutator;
  using model::WLink;
  
  
  
  
  class NotificationHub
    : public model::Controller
    {
      
      
      void
      buildMutator (lib::diff::TreeMutator::Handle buffer)  override
        {
          buffer.emplace(
            TreeMutator::build()
          );
          UNIMPLEMENTED ("define and implement what need to be reflected from asset::ErrorLog");
        }
    
      
      /* ==== Tangible interface ==== */
      
      virtual bool
      doReset()  override
        {
          if (not widget_) return false;
          
          widget_->clearAll();
          widget_->expand (false);
          return true;
        }
      
      virtual bool
      doMsg (string text)  override
        {
          getWidget().addInfo (text);
          return false; // logging is no persistent state
        }
      
      virtual bool
      doClearMsg ()  override
        {
          if (widget_)
            widget_->clearInfoMsg();
          return false; // not persistent (sticky)
        }
      
      virtual bool
      doErr (string text)  override
        {
          getWidget().addError (text);
          return false;
        }
      
      virtual bool
      doClearErr ()  override
        {
          if (widget_)
            widget_->turnError_into_InfoMsg();
          return false; // not persistent (sticky)
        }
      
      virtual void
      doMark (GenNode const& stateMark)  override
        {
          if (stateMark.idi.getSym() == MARK_Warning)
            getWidget().addWarn (stateMark.data.get<string>());
          else
            // forward to default handler
            Controller::doMark (stateMark);
        }
      
      virtual void
      doFlash()  override
        {
          if (not widget_) return;
          widget_->reveal();
          widget_->triggerFlash();
        }
      
      
    public:
      using WidgetAllocator = std::function<widget::ErrorLogDisplay&(void)>;
      
      
      NotificationHub (ID identity, ctrl::BusTerm& nexus, WidgetAllocator wa)
        : model::Controller{identity, nexus}
        , allocateWidget_{wa}
        , widget_{}
        {
          installExpander([&](){ return widget_ and widget_->expand; }
                         ,[&](bool yes)
                               {
                                 if (widget_ or yes)
                                   getWidget().expand (yes);
                               }
                         );
          installRevealer([&](){ getWidget().reveal(); }); // implementation implies also expand
        }
      
     ~NotificationHub() { };
      
      
    private:
      WidgetAllocator allocateWidget_;
      
      WLink<widget::ErrorLogDisplay> widget_;
      
      
      widget::ErrorLogDisplay&
      getWidget()
        {
          if (not widget_)
            widget_.connect (allocateWidget_());
          return *widget_;
        }
    };
  
  
  
}}// namespace stage::ctrl
#endif /*STAGE_CTRL_NOTIFICATION_HUB_H*/