guifacade.cpp

Go to the documentation of this file.

/*
  GuiFacade  -  access point for communicating with the Lumiera GTK 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/guifacade.hpp"
#include "include/gui-notification-facade.h"
#include "lib/sync.hpp"
#include "lib/error.hpp"
#include "lib/depend.hpp"
#include "common/instancehandle.hpp"
#include "common/option.hpp"
 
#include <memory>
#include <string>
 
 
namespace stage {
  
  using std::string;
  using std::unique_ptr;
  using lumiera::Subsys;
  using lumiera::InstanceHandle;
  using lib::Sync;
  using lib::RecursiveLock_NoWait;
  
  
  
  struct GuiRunner
    : util::NonCopyable
    {
      typedef InstanceHandle<LUMIERA_INTERFACE_INAME(lumieraorg_Gui, 1)> GuiHandle;
      
      GuiHandle theGUI_;
      
      
      GuiRunner (Subsys::SigTerm terminationHandle)
        : theGUI_("lumieraorg_Gui", 1, 1, "lumieraorg_GuiStarterPlugin") // load GuiStarterPlugin
        {
          ASSERT (theGUI_);
          bool res = this->launchUI (terminationHandle);
          
          if (!res || lumiera_error_peek())
            throw lumiera::error::Fatal{"failed to bring up the GUI", lumiera_error()};
        }
      
      
      /*  ===== control interface for the GuiStarterPlugin ======= */
      
      bool launchUI (Subsys::SigTerm& terminationHandle)
        {
          return theGUI_->launchUI (reinterpret_cast<void*> (&terminationHandle));
        }
    };
  
  
  
  
  namespace { // implementation of GUI-"Subsystem" : start GUI through GuiStarterPlugin
    
    unique_ptr<GuiRunner> facade;
    
    
    class GuiSubsysDescriptor
      : public lumiera::Subsys,
        public Sync<RecursiveLock_NoWait>
      {
        operator string()  const { return "Lumiera GTK GUI"; }
        
        bool
        shouldStart (lumiera::Option& opts)  override
          {
            if (opts.isHeadless() or 0 < opts.getPort())
              {
                INFO (guifacade, "*not* starting the GUI...");
                return false;
              }
            else
              return true;
          }
        
        bool
        start (lumiera::Option&, Subsys::SigTerm termNotification)  override
          {
            Lock guard{this};
            if (facade)
              return false;    // already started
            
            facade.reset (   //  trigger loading of the GuiStarterPlugin...
              new GuiRunner (
                    [=,this] (string* problemMessage)
                        { //     will be invoked when the UI thread exits
                          closeGuiModule();
                          termNotification(problemMessage);
                        }));
            
            return true;
          }
        
        void
        triggerShutdown ()  noexcept override
          {
            try { GuiNotification::facade().triggerGuiShutdown ("Application shutdown"); }
            
            ERROR_LOG_AND_IGNORE (guifacade, "trigger shutdown of the GUI");
          }
        
        bool
        checkRunningState ()  noexcept override
          {
            return bool(facade);
          }
        
        
        void
        closeGuiModule ()
          {
            Lock guard{this};
            if (!facade)
              {
                WARN (guifacade, "Termination signal invoked, but GUI is currently closed. "
                                 "Probably this is due to some broken startup logic and should be fixed.");
              }
            else
              facade.reset (nullptr);
          }
        
        
        
      public:
        GuiSubsysDescriptor() { }
        
       ~GuiSubsysDescriptor()
          {
            if (facade)
              {
                WARN (guifacade, "GUI subsystem terminates, but GuiFacade isn't properly closed. "
                                 "Closing it forcedly; this indicates broken startup logic and should be fixed.");
                try { facade.reset (0); }
                ERROR_LOG_AND_IGNORE (guifacade, "forcibly closing the GUI");
                ENSURE (not lumiera_error_peek());
              }
          }
      };
    
    lib::Depend<GuiSubsysDescriptor> theDescriptor;
    
  } // (End) impl details
  
  
  
  
  
  
  lumiera::Subsys&
  GuiFacade::getDescriptor()
  {
    return theDescriptor();
  }
  
  
  bool
  GuiFacade::isUp ()
  {
    return bool(facade);
  }
  
  
} // namespace stage