doxy/notification-service_8cpp_source.html

 /*
   NotificationService  -  public service allowing to push information into the GUI

    Copyright (C)
      2008,            Hermann Vosseler <Ichthyostega@web.de>

   **Lumiera** 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. See the file COPYING for further details.

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

 #include "stage/ctrl/ui-manager.hpp"
 #include "stage/ctrl/ui-dispatcher.hpp"
 #include "stage/notification-service.hpp"
 #include "stage/interact/wizard.hpp"
 #include "include/ui-protocol.hpp"

 #include "lib/diff/mutation-message.hpp"
 #include "lib/diff/gen-node.hpp"
 #include "include/logging.h"
 #include "lib/format-string.hpp"
 #include "lib/depend.hpp"
 #include "lib/util.hpp"

 extern "C" {
 #include "common/interface-descriptor.h"
 }

 #include <utility>
 #include <string>


 using lib::diff::GenNode;
 using lib::diff::TreeMutator;
 using lib::diff::MutationMessage;
 using stage::ctrl::UiDispatcher;
 using stage::ctrl::BusTerm;
 using util::_Fmt;

 using std::string;
 using std::move;


 namespace stage {


   void
   NotificationService::dispatchMsg (ID uiElement, lib::diff::GenNode&& uiMessage)
   {
     dispatch_->event ([=]()
                       {
                         ctrl::BusTerm::mark (uiElement, uiMessage);
                       });
   }


   void
   NotificationService::displayInfo (NotifyLevel severity, string const& text)
   {
     ID errorLogID = interact::Wizard::getErrorLogID();
     switch (severity) {
       case NOTE_ERROR:
         markError (errorLogID, text);
         break;
       case NOTE_INFO:
         markNote (errorLogID, text);
         break;
       case NOTE_WARN:
         mark (errorLogID, GenNode{string{MARK_Warning}, text});
         break;
       default:
         throw lumiera::error::Logic (_Fmt{"UI Notification with invalid severity %d encountered. "
                                           "Given message text was '%s'"} % severity % text);
   }  }


   void
   NotificationService::markError (ID uiElement, string const& text)
   {
     dispatchMsg (uiElement, GenNode{string{MARK_Error}, text});
   }


   void
   NotificationService::markNote (ID uiElement, string const& text)
   {
     dispatchMsg (uiElement, GenNode{string{MARK_Message}, text});
   }


   void
   NotificationService::mark (ID uiElement, GenNode&& stateMarkMsg)
   {
     dispatchMsg (uiElement, move (stateMarkMsg));
   }


   void
   NotificationService::mutate (ID uiElement, MutationMessage&& diff)
   {
     dispatch_->event ([=]()
                       { // apply and consume diff message stored within closure
                         this->change (uiElement, move(unConst(diff)));
                       });
   }


   void
   NotificationService::triggerGuiShutdown (string const& cause)
   {
     NOTICE (stage, "@GUI: shutdown triggered with explanation '%s'....", cStr(cause));
     displayInfo (NOTE_ERROR, cause);
     dispatch_->event ([this]()
                       {
                         uiManager_.terminateUI();
                       });
   }


   namespace { // facade implementation details


     /* ================== define an lumieraorg_GuiNotification instance ======================= */

     LUMIERA_INTERFACE_INSTANCE (lumieraorg_interfacedescriptor, 0
                                ,lumieraorg_GuiNotificationFacade_descriptor
                                , NULL, NULL, NULL
                                , LUMIERA_INTERFACE_INLINE (name,
                                                            const char*, (LumieraInterface ifa),
                                                              { (void)ifa;  return "GuiNotification"; }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (brief,
                                                            const char*, (LumieraInterface ifa),
                                                              { (void)ifa;  return "Stage Interface: push state update and notification of events into the GUI"; }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (homepage,
                                                            const char*, (LumieraInterface ifa),
                                                              { (void)ifa;  return "http://www.lumiera.org/develompent.html" ;}
                                                           )
                                , LUMIERA_INTERFACE_INLINE (version,
                                                            const char*, (LumieraInterface ifa),
                                                              { (void)ifa;  return "0.1~pre"; }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (author,
                                                            const char*, (LumieraInterface ifa),
                                                              { (void)ifa;  return "Hermann Vosseler"; }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (email,
                                                            const char*, (LumieraInterface ifa),
                                                              { (void)ifa;  return "Ichthyostega@web.de"; }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (copyright,
                                                            const char*, (LumieraInterface ifa),
                                                              {
                                                                (void)ifa;
                                                                return
                                                                  "Copyright (C)\n"
                                                                  "  2008,            Hermann Vosseler <Ichthyostega@web.de>";
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (license,
                                                            const char*, (LumieraInterface ifa),
                                                              {
                                                                (void)ifa;
                                                                return
                                                                  "**Lumiera** is free software; you can redistribute it and/or modify it\n"
                                                                  "under the terms of the GNU General Public License as published by the\n"
                                                                  "Free Software Foundation; either version 2 of the License, or (at your\n"
                                                                  "option) any later version. See the file COPYING for further details."
                                                                  ;
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (state,
                                                            int, (LumieraInterface ifa),
                                                              {(void)ifa;  return LUMIERA_INTERFACE_EXPERIMENTAL; }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (versioncmp,
                                                            int, (const char* a, const char* b),
                                                              {(void)a;(void)b;  return 0;}
                                                           )
                                );


     using LERR_(LIFECYCLE);

     lib::Depend<NotificationService> _instance;


     LUMIERA_INTERFACE_INSTANCE (lumieraorg_GuiNotification, 0
                                ,lumieraorg_GuiNotificationService
                                , LUMIERA_INTERFACE_REF(lumieraorg_interfacedescriptor, 0, lumieraorg_GuiNotificationFacade_descriptor)
                                , NULL /* on  open  */
                                , NULL /* on  close */
                                , LUMIERA_INTERFACE_INLINE (displayInfo,
                                                            void, (uint severity, const char* text),
                                                              {
                                                                if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, text);
                                                                else
                                                                  _instance().displayInfo (NotifyLevel(severity), text);
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (markError,
                                                            void, (const void* element, const char* text),
                                                              {
                                                                if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, text);
                                                                else
                                                                  _instance().markError (*static_cast<lib::idi::BareEntryID const*> (element), text);
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (markNote,
                                                            void, (const void* element, const char* text),
                                                              {
                                                                if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, text);
                                                                else
                                                                  _instance().markNote (*static_cast<lib::idi::BareEntryID const*> (element), text);
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (mark,
                                                            void, (const void* element, void* stateMark),
                                                              {
                                                                if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, "passing state mark");
                                                                else
                                                                  _instance().mark   (*static_cast<lib::idi::BareEntryID const*> (element), move(*reinterpret_cast<GenNode*> (stateMark)));
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (mutate,
                                                            void, (const void* element, void* diff),
                                                              {
                                                                if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, "passing diff message");
                                                                else
                                                                  _instance().mutate (*static_cast<lib::idi::BareEntryID const*> (element), move(*reinterpret_cast<MutationMessage*> (diff)));
                                                              }
                                                           )
                                , LUMIERA_INTERFACE_INLINE (triggerGuiShutdown,
                                                            void, (const char* cause),
                                                              {
                                                                if (!_instance) lumiera_error_set (LUMIERA_ERROR_LIFECYCLE, cause);
                                                                else
                                                                  _instance().triggerGuiShutdown (cause);
                                                              }
                                                           )
                                );

   } //(END) facade implementation details


   NotificationService::NotificationService (ctrl::BusTerm& upLink, ctrl::UiManager& uiManager)
     : BusTerm{lib::idi::EntryID<NotificationService>{}, upLink}
     , dispatch_{new UiDispatcher{[this](string msg){ displayInfo (NOTE_ERROR, msg); }}}
     , uiManager_{uiManager}
     , serviceInstance_( LUMIERA_INTERFACE_REF (lumieraorg_GuiNotification, 0,lumieraorg_GuiNotificationService))
     {
       INFO (stage, "GuiNotification Facade opened.");
     }


   NotificationService::~NotificationService() { } // emit dtors of embedded objects here...


 } // namespace stage
mutation-message.hpp
Generic Message with an embedded diff, to describe changes to model elements.

stage::NotifyLevel
NotifyLevel
Definition: gui-notification-facade.h:56

wizard.hpp
Global help controller.

ui-protocol.hpp
Hard wired key constants and basic definitions for communication with the GUI.

stage::ctrl::BusTerm
connection point at the UI-Bus.
Definition: bus-term.hpp:96

cStr
CStr cStr(std::string const &rendered)
convenience shortcut: forced conversion to c-String via string.
Definition: symbol.hpp:59

stage::NotificationService::NotificationService
NotificationService(ctrl::BusTerm &upLink, ctrl::UiManager &uiManager)
When started, NotificationService connects to the UI-Bus via the provided connection.
Definition: notification-service.cpp:300

stage::NotificationService::dispatchMsg
void dispatchMsg(ID, lib::diff::GenNode &&)
Definition: notification-service.cpp:86

stage::ctrl::UiManager::terminateUI
void terminateUI()
Cause the main event loop to terminate, so the application as a whole unwinds.
Definition: ui-manager.cpp:147

format-string.hpp
Front-end for printf-style string template interpolation.

lib::idi::EntryID
typed symbolic and hash ID for asset-like position accounting.
Definition: entry-id.hpp:126

notification-service.hpp
A public service provided by the GUI, implementing the stage::GuiNotification facade interface...

stage::NotificationService::triggerGuiShutdown
void triggerGuiShutdown(string const &cause) override
causes the GUI to shut down unconditionally
Definition: notification-service.cpp:147

logging.h
This header is for including and configuring NoBug.

stage::ctrl::UiDispatcher
Helper to dispatch code blocks into the UI event thread for execution.
Definition: ui-dispatcher.hpp:102

stage::NOTE_WARN
something to be aware of, to be indicated unobtrusively
Definition: gui-notification-facade.h:58

lib::diff::MutationMessage
Opaque message to effect a structural change on a target, which is likewise only known in an abstract...
Definition: mutation-message.hpp:124

util::_Fmt
A front-end for using printf-style formatting.
Definition: format-string.hpp:148

lib::Depend
Access point to singletons and other kinds of dependencies designated by type.
Definition: depend.hpp:280

LUMIERA_INTERFACE_EXPERIMENTAL
Not finished development code.
Definition: interface-descriptor.h:44

LUMIERA_INTERFACE_INSTANCE
#define LUMIERA_INTERFACE_INSTANCE(iname, version, name, descriptor, acquire, release,...)
Define an interface instance.
Definition: interface.h:185

lumiera::error::LumieraError
Derived specific exceptions within Lumiera&#39;s exception hierarchy.
Definition: error.hpp:190

ui-manager.hpp
Manager for global user interface concerns, framework integration and global state.

stage::ctrl::BusTerm::mark
virtual bool mark(ID subject, GenNode const &mark)
route a state update or notification to the given subject.
Definition: ui-bus.cpp:168

LUMIERA_INTERFACE_REF
#define LUMIERA_INTERFACE_REF(iname, version, dname)
Return a reference (pointer) to an interface implementation.
Definition: interface.h:119

stage
Lumiera GTK UI implementation root.
Definition: guifacade.cpp:37

util.hpp
Tiny helper functions and shortcuts to be used everywhere Consider this header to be effectively incl...

stage::ctrl::BusTerm::change
virtual bool change(ID subject, MutationMessage &&diff)
alter and reshape the designated subject by applying the given diff message.
Definition: ui-bus.cpp:202

gen-node.hpp
Generic building block for tree shaped (meta)data structures.

ui-dispatcher.hpp
Allow dispatch of self-contained code blocks (lambdas) into the main UI event thread.

depend.hpp
Singleton services and Dependency Injection.

lumiera_error_set
lumiera_err lumiera_error_set(lumiera_err nerr, const char *extra)
Set error state for the current thread.
Definition: error-state.c:96

interface-descriptor.h
A data record to describe interface, interface instances and plug-in instances.

stage::ctrl::UiManager
The Lumiera UI framework and backbone object.
Definition: ui-manager.hpp:88

stage::NOTE_ERROR
severe condition to be indicated prominently
Definition: gui-notification-facade.h:59

stage::NOTE_INFO
possibly interesting info that can be safely ignored
Definition: gui-notification-facade.h:57

stage::NotificationService::displayInfo
void displayInfo(NotifyLevel, string const &text) override
push a user visible notification text
Definition: notification-service.cpp:96

stage::anonymous_namespace{notification-service.cpp}::_instance
lib::Depend< NotificationService > _instance
a backdoor for the C Language impl to access the actual SessionCommand implementation...
Definition: notification-service.cpp:228

stage::widget::name
ElementBoxWidget::Config::Qualifier name(string id)
define the name-ID displayed in the caption
Definition: element-box-widget.hpp:234

lib::diff::GenNode
generic data element node within a tree
Definition: gen-node.hpp:222

lib::diff::TreeMutator
Customisable intermediary to abstract mutating operations on arbitrary, hierarchical object-like data...
Definition: tree-mutator.hpp:136