CanvasView.hpp

Go to the documentation of this file.

#ifndef CANVASVIEW_HPP
#define CANVASVIEW_HPP
/*
This file is part of AlgAudio.

AlgAudio, Copyright (C) 2015 CeTA - Audiovisual Technology Center

AlgAudio is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.

AlgAudio 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with AlgAudio.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <queue>
#include "UI/UIContainer.hpp"
#include "ModuleUI/ModuleGUI.hpp"
#include "Canvas.hpp"
#include "Alertable.hpp"

namespace AlgAudio{

class CanvasView : public UIContainerMultiple{
public:
  static std::shared_ptr<CanvasView> CreateEmpty(std::shared_ptr<Window> parent);
  
  virtual void CustomDraw(DrawContext& c);
  virtual bool CustomMousePress(bool,MouseButton,Point2D);
  virtual void CustomMouseEnter(Point2D);
  virtual void CustomMouseLeave(Point2D);
  virtual void OnKeyboard(KeyData);

  virtual void Clear() override {}
  virtual Point2D GetChildPos(std::shared_ptr<UIWidget>) const override;
  
  virtual void CustomMouseMotion(Point2D from_abs,Point2D to_abs) override;
  void MouseMotionOverCanvasPlane(Point2D from_rel, Point2D to_rel);
  
  LateReturn<> AddModule(std::string id, Point2D position);

  void RemoveSelected();
  
  void CenterView();
  

  void IncreaseZoom();
  void DecreaseZoom();
  void SetZoom(float level);

  void SwitchTopLevelCanvas(std::shared_ptr<Canvas> canvas, std::string name);
  
  std::shared_ptr<Canvas> GetCurrentCanvas() { if(canvas_stack.size() == 0) return nullptr; else return canvas_stack.back().first; }
  std::shared_ptr<Canvas> GetTopCanvas() { if(canvas_stack.size() == 0) return nullptr; else return canvas_stack.front().first; }
  
  void EnterCanvas(std::shared_ptr<Canvas> canvas, std::string name="");
  void ExitCanvas();
  std::vector<std::string> GetCanvasStackPath();
  Signal<> on_canvas_stack_path_changed;

private:
  CanvasView(std::shared_ptr<Window> parent);
  
  std::deque<std::pair<std::shared_ptr<Canvas>, std::string>> canvas_stack;
  
  std::vector<std::shared_ptr<ModuleGUI>> module_guis;
  
  void CreateModuleGUIs();
  void ResetUI();
  
  // Used to determine which module was clicked knowing the click position.
  int InWhich(Point2D relative_pos);
  int CurveStrengthFuncA(Point2D a, Point2D b);
  int CurveStrengthFuncB(Point2D a, Point2D b);
  // These flags are set according to the mouse buttons state.
  bool lmb_down = false;
  bool mmb_down = false;
  
  enum MouseDownMode{
    ModeNone, 
    ModeModuleBody, 
    ModeCaptured, 
    ModeInlet, 
    ModeOutlet, 
    ModeSlider, 
    ModeSliderInlet, 
    ModeSliderRelativeOutlet, 
    ModeSliderAbsoluteOutlet, 
  };
  MouseDownMode mouse_down_mode;
  UIWidget::ID mouse_down_elem_widgetid;
  std::string mouse_down_elem_paramid;
  Point2D mouse_down_position, drag_position;
  int mouse_down_id = -1;

  std::list<std::pair<std::shared_ptr<ModuleGUI>, Point2D>> selection;
  void ClearSelection();
  void SelectSingle(std::shared_ptr<ModuleGUI>);
  void AddToSelection(std::shared_ptr<ModuleGUI>);

  inline Point2D_<float> PositionRelToAbs(Point2D_<float> rel){ return (rel - view_position)*view_zoom + current_size/2; }
  inline Point2D_<float> PositionAbsToRel(Point2D_<float> abs){ return view_position + (abs - current_size/2)/view_zoom; }

  bool drag_in_progress = false;
  bool view_move_in_progress = false;
  enum DragMode{
    DragModeMove, 
    DragModeConnectAudioFromInlet, 
    DragModeConnectAudioFromOutlet, 
    DragModeConnectDataFromInlet, 
    DragModeConnectDataFromRelativeOutlet, 
    DragModeConnectDataFromAbsoluteOutlet, 
    DragModeSlider, 
    DragModeBBSelect, 
  };
  DragMode drag_mode;
  void FinalizeAudioConnectingDrag(int inlet_module_id, UIWidget::ID inlet_id, int outlet_module_id, UIWidget::ID outlet_id);
  void FinalizeDataConnectingDrag(int inlet_module_id, UIWidget::ID inlet_slider_id, int outlet_module_id, UIWidget::ID outlet_slider_id, Canvas::DataConnectionMode);

  Point2D mmb_down_pos_abs;
  Point2D view_move_start_view_position;

  void StopDrag();

  enum class PotentialWireMode{
    None,
    New,
    Remove,
  };
  enum class PotentialWireType{
    Audio,
    DataRelative,
    DataAbsolute,
  };
  PotentialWireMode potential_wire = PotentialWireMode::None;
  PotentialWireType potential_wire_type;
  std::pair<std::pair<int,std::string>, std::pair<int,std::string>> potential_wire_connection;
  // Animated fadeout of potential wire.
  Subscription fadeout_anim;
  PotentialWireMode fadeout_wire = PotentialWireMode::None;
  PotentialWireType fadeout_wire_type;
  std::pair<std::pair<std::weak_ptr<ModuleGUI>,std::string>, std::pair<std::weak_ptr<ModuleGUI>,std::string>> fadeout_wire_connection;
  void FadeoutWireStart(PotentialWireMode m);
  void FadeoutWireStep(float delta);
  float fadeout_phase;

  // Flags remebering held keys.
  bool shift_held = false, ctrl_held = false, alt_held = false;
  
  Point2D view_position = Point2D(0,0);
  float view_zoom = 1.0;
};

} // namespace AlgAudio

#endif //CANVASVIEW_HPP