drag-relocate-controller.hpp

Go to the documentation of this file.

/*
  DRAG-RELOCATE-CONTROLLER.hpp  -  concrete gesture controller to relocate a widget by dragging
 
   Copyright (C)
     2021,            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.
 
*/
 
 
#ifndef STAGE_INTERACT_DRAG_RELOCATE_CONTROLLER_H
#define STAGE_INTERACT_DRAG_RELOCATE_CONTROLLER_H
 
 
#include "stage/gtk-base.hpp"
#include "stage/interact/interaction-state.hpp"
#include "stage/interact/cmd-context.hpp"
#include "lib/opaque-holder.hpp"
#include "lib/format-string.hpp"
#include "lib/format-cout.hpp"  
//#include "lib/idi/entry-id.hpp"
//#include "lib/symbol.hpp"
#include "lib/nocopy.hpp"
#include "lib/util.hpp"
 
//#include <string>
 
 
namespace stage {
namespace interact {
  
//  using lib::HashVal;
//  using util::isnil;
//  using std::string;
  using util::isnil;
  using util::_Fmt;
  
  namespace {
    const gdouble DISTANCE_THRESHOLD = 5.0;
    
    const size_t OBSERVER_BUFF_SIZ = sizeof(void*)
                                   + sizeof(Symbol)
                                   + 4 * sizeof(void*);
  }
 
  
  class DragRelocateController
    : public InteractionState
    {
      bool buttonPressed_ = false;
      Subject* subject_ = nullptr;
      bool isInFormation_ = false;
      gdouble anchorX_ = 0.0;
      gdouble anchorY_ = 0.0;
      
      using Observer = lib::InPlaceBuffer<GestureObserver, OBSERVER_BUFF_SIZ, InactiveObserver>;
      
      Observer observer_;
      
      void
      linkTrigger (Subject& subject, Symbol cmdID)  override
        {
          REQUIRE (not isnil (cmdID));
          auto& widget = subject.exposeWidget();
          widget.signal_button_press_event().connect(
              sigc::mem_fun (*this, &DragRelocateController::watchButton));
          widget.signal_button_release_event().connect(
              sigc::mem_fun (*this, &DragRelocateController::watchButton));
          widget.signal_motion_notify_event().connect(
              [&, cmdID](GdkEventMotion* motion) -> bool
                {
                  try{ return maybeActivate(cmdID, subject, motion); }
                  ON_EXCEPTION_RETURN (false, "activate dragging gesture")
                }
          );
        }
      
      bool
      watchButton (GdkEventButton* button_event)  noexcept
        {
          REQUIRE (button_event);
          if (GDK_BUTTON_PRESS == button_event->type)
            buttonPressed_ = true;
          else
          if (GDK_BUTTON_RELEASE == button_event->type)
            {
              buttonPressed_ = false;
              if (isActive())
                doCompleteGesture();
              resetState();
            }
          std::cerr << _Fmt{"BUTT %s flag=%d"} % buttonPressed_ % button_event->type << std::endl;
          return false;
        }
      
      bool
      maybeActivate (Symbol cmdID, Subject& subject, GdkEventMotion* motion_event)
        {
          if (not buttonPressed_)
              return false; // Event not handled by this controller
          REQUIRE (motion_event);
          std::cerr << _Fmt{"MOVE x=%3.1f y=%3.1f subject=%s"}
                       % motion_event->x_root
                       % motion_event->y_root
                       % subject
                    << std::endl;
          if (not isAnchored())
            anchor (cmdID, subject, motion_event);
          if (not isActive())
            {
              probeActivation (motion_event);
              if (isActive())
                initGestureTracking(cmdID, subject);
              return false;
            }
          else
            {
              doTrackGesture (motion_event);
              return true; // Event handled
            }
        }
      
      
      /* === gesture implementation === */
      bool
      isActive()
        {
          return subject_
             and isInFormation_;
        }
      
      bool
      isAnchored()
        {
          return bool(subject_);
        }
      
      void
      anchor (Symbol cmdID, Subject& subject, GdkEventMotion* motion_event)
        {
          REQUIRE (motion_event);
          this->subject_ = & subject;
          this->anchorX_ = motion_event->x_root;
          this->anchorY_ = motion_event->y_root;
          std::cerr << _Fmt{"ANCHOR at x=%3.1f y=%3.1f ('%s')"}
                           % anchorX_
                           % anchorY_
                           % cmdID
                    << std::endl;
        }
      
      void
      probeActivation (GdkEventMotion* motion_event)
        {
          isInFormation_ = DISTANCE_THRESHOLD < abs (motion_event->x_root - anchorX_)
                        or DISTANCE_THRESHOLD < abs (motion_event->y_root - anchorY_);
        }
      
      void
      initGestureTracking(Symbol cmdID, Subject& subject)
        {
          subject.buildGestureObserver (cmdID, Observer::Handle{observer_});
        }
      
      void
      doTrackGesture (GdkEventMotion* motion_event)
        {
          REQUIRE (motion_event);
          gdouble deltaX = motion_event->x_root - this->anchorX_;
          gdouble deltaY = motion_event->y_root - this->anchorY_;
          // notify Subject to feed current delta
          observer_->updateOffset (deltaX, deltaY);
        }
      
      void
      doCompleteGesture()
        {
          observer_->markGestureCompleted();
        }
      
      void
      resetState()
        {
          isInFormation_ = false;
          anchorX_ = anchorY_ = 0.0;
          subject_ = nullptr;
          observer_.reset();
        }
      
      
    public:
      DragRelocateController()
        : observer_{}
        { }
      
    private:
    };
  
  
  
}} // namespace stage::interact
#endif /*STAGE_INTERACT_DRAG_RELOCATE_CONTROLLER_H*/