interaction-director.cpp

Go to the documentation of this file.

/*
  interactionDirector  -  Global UI Manager

  Copyright (C)         Lumiera.org
    2017,               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/gtk-base.hpp"
#include "stage/ui-bus.hpp"
#include "stage/ctrl/bus-term.hpp"
#include "stage/ctrl/global-ctx.hpp"
#include "stage/interact/interaction-director.hpp"
#include "stage/interact/view-locator.hpp"
#include "stage/interact/spot-locator.hpp"
#include "stage/interact/navigator.hpp"
#include "stage/interact/focus-tracker.hpp"
#include "stage/interact/ui-coord-resolver.hpp"
#include "stage/interact/gesture-state.hpp"
#include "stage/dialog/preferences-dialog.hpp"
#include "stage/dialog/render.hpp"
#include "stage/workspace/workspace-window.hpp"
#include "stage/ctrl/ui-state.hpp"
#include "stage/setting/asset-controller.hpp"
#include "stage/panel/timeline-panel.hpp"
//#include "stage/timeline/timeline-widget.hpp"
//#include "stage/timeline/timeline-controller.hpp"   /////////////////TODO still required?
#include "include/ui-protocol.hpp"
#include "steam/mobject/session/root.hpp"
#include "steam/asset/sequence.hpp"                
#include "steam/mobject/session/fork.hpp"          
#include "steam/cmd.hpp"
#include "vault/real-clock.hpp"
#include "lib/diff/tree-mutator.hpp"
#include "lib/format-string.hpp"
#include "lib/format-obj.hpp"
//#include "stage/ui-bus.hpp"
//#include "lib/util.hpp"

//#include <memory>
//#include <list>

//using util::isnil;
using util::_Fmt;
//using std::list;
//using std::shared_ptr;
using lib::idi::EntryID;
using lib::hash::LuidH;
using lib::diff::Rec;
using lib::diff::TreeMutator;
using lib::diff::collection;
using LERR_(DIFF_STRUCTURE);
using std::make_unique;
using util::toString;


namespace stage {
namespace interact {
  
  namespace session = steam::mobject::session;
  namespace cmd = steam::cmd;
  
  using ctrl::GlobalCtx;
  using ctrl::UiState;
  using setting::AssetController;
  using timeline::TimelineController;
  
  
  // emit dtors of children here...
  InteractionDirector::~InteractionDirector()
    { }
  
  
  InteractionDirector::InteractionDirector (GlobalCtx& globals)
    : model::Controller(session::Root::getID(), globals.uiBus_.getAccessPoint())
    , globalCtx_(globals)
    , gestureState_{}
    , viewLocator_{new ViewLocator}
    , spotLocator_{new SpotLocator}
    , navigator_{*spotLocator_, *viewLocator_}    // Service exposed as Depend<LocationQuery>
    , tracker_{new FocusTracker{*navigator_}}
    , uiState_{new UiState{globals.uiBus_.getStateManager(), *tracker_}}
    , assets_{new AssetController{session::Root::getAssetID(), this->uiBus_}}
    , timelines_{}
    {
      Glib::signal_timeout()
        .connect_once (sigc::mem_fun(*this, &InteractionDirector::populateContent_afterStart)
                      ,DELAY_AFTER_GUI_START_in_ms
                      ,Glib::PRIORITY_LOW);     // after all initial drawing tasks
    }
  
  
  void
  InteractionDirector::populateContent_afterStart()
    {
      invoke (cmd::test_meta_activateContentDiff);               
    }
  
  
  namespace { // Temporary Junk
    inline void
    unimplemented (const char* todo)
    {
      WARN (stage, "%s is not yet implemented. So sorry.", todo);
    }
  }
  
  
  
  void
  InteractionDirector::buildMutator (TreeMutator::Handle buffer)
  {
    buffer.emplace(
      TreeMutator::build()
        .attach (collection(timelines_)
               .isApplicableIf ([&](GenNode const& spec) -> bool
                  {                                            // »Selector« : require object-like sub scope
                    return spec.data.isNested();
                  })
               .constructFrom ([&](GenNode const& spec) -> TimelineGui
                  {                                            // »Constructor« : what to do when the diff mentions a new entity
                    return injectTimeline (spec);
                  }))
        .mutateAttrib(ATTR_fork, [&](TreeMutator::Handle buff)
            {                                                  // »Attribute Mutator« : how enter an object field as nested scope
              REQUIRE (assets_);
              assets_->buildMutator(buff);
            }));
  }
  
  
  void
  InteractionDirector::newProject()
  {
    unimplemented ("launch project setup UI");
  }
  
  
  void
  InteractionDirector::saveSnapshot()
  {
    string snapshotID{"snap-" + toString(vault::RealClock::now())};
    invoke (cmd::session_saveSnapshot, snapshotID);
  }
  
  
  void
  InteractionDirector::forkProject()
  {
    unimplemented ("launch project setup UI to create a fork of the project under new name");
  }
  
  
  void
  InteractionDirector::editSetup()
  {
    dialog::PreferencesDialog dialog(getWorkspaceWindow());
    dialog.run();
    
    unimplemented ("edit global configuration");
  }
  
  
  void
  InteractionDirector::openFile()
  {
    unimplemented ("open file");
  }
  
  
  void
  InteractionDirector::render()
  {
    dialog::Render dialog{getWorkspaceWindow()};                                   
    dialog.run();
    
    unimplemented ("start render");
  }
  
  
  void
  InteractionDirector::newSequence()
  {
    LuidH anchor{*this};                    
    LuidH newSeqID{EntryID<steam::asset::Sequence>().getHash()};  
    invoke (cmd::session_newSequence, anchor, newSeqID);
  }
  
  
  void
  InteractionDirector::newTrack()
  {
    LuidH anchor{*this};                    
    LuidH newTrackID{EntryID<steam::mobject::session::Fork>().getHash()};  
    invoke (cmd::sequence_newTrack, anchor, newTrackID);
  }
  
  
  workspace::WorkspaceWindow&
  InteractionDirector::getWorkspaceWindow()
  {
    return globalCtx_.windowLoc_.findActiveWindow();
  }
  
  
  namespace {
    ID
    verifyDiffStructure_and_extract_RootTrack (GenNode const& spec)
    {
      if (not (spec.data.isNested()
               and spec.data.get<Rec>().hasAttribute(string{ATTR_fork})
               and TYPE_Fork == spec.data.get<Rec>().get(string{ATTR_fork}).data.recordType()
         )    )
        throw error::State (_Fmt{"When populating a new Timeline, a root track must be given immediately"
                                 "nested into INS message. We got the following initialisation payload: %s"}
                                % spec                      
                           , LERR_(DIFF_STRUCTURE));
      
      return spec.data.get<Rec>().get(string{ATTR_fork}).idi;
    }
  }
  
  TimelineGui
  InteractionDirector::injectTimeline (GenNode const& spec)
  {
    ID rootTrack = verifyDiffStructure_and_extract_RootTrack (spec);
    TimelineGui anchorProxy{spec.idi, rootTrack};
    
    globalCtx_.windowLoc_
              .locatePanel()
              .find_or_create<panel::TimelinePanel>()
              .addTimeline (
                  anchorProxy.buildTimelineWidget (this->uiBus_));
    
    globalCtx_.uiManager_.configureStyle (*anchorProxy);
    return anchorProxy;
  }


  
  
}}// namespace stage::interact