arranger.h

// SPDX-FileCopyrightText: © 2018-2022, 2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __GUI_WIDGETS_ARRANGER_H__
#define __GUI_WIDGETS_ARRANGER_H__
 
#include "common/dsp/position.h"
#include "common/dsp/transport.h"
#include "common/utils/ui.h"
#include "gui/backend/backend/editor_settings.h"
#include "gui/backend/gtk_widgets/gtk_wrapper.h"
#include "gui/backend/gtk_widgets/main_window.h"
 
#define ARRANGER_WIDGET_TYPE (arranger_widget_get_type ())
G_DECLARE_FINAL_TYPE (ArrangerWidget, arranger_widget, Z, ARRANGER_WIDGET, GtkWidget)
 
TYPEDEF_STRUCT_UNDERSCORED (ArrangerBgWidget);
TYPEDEF_STRUCT_UNDERSCORED (GtkEventControllerMotion);
TYPEDEF_STRUCT_UNDERSCORED (RulerWidget);

 
#define ARRANGER_WIDGET_GET_ACTION(arr, actn) (arr->action == ##actn)
 
enum class ArrangerCursor
{
  None,
  Select,
  SelectStretch,
  Edit,
  Autofill,
  ARRANGER_CURSOR_CUT,
  Eraser,
  Audition,
  Ramp,
  Grab,
  Grabbing,
  ResizingL,
  ResizingLFade,
  ARRANGER_CURSOR_STRETCHING_L,
  ARRANGER_CURSOR_RESIZING_L_LOOP,
  ResizingR,
  ARRANGER_CURSOR_RESIZING_R_FADE,
  ARRANGER_CURSOR_STRETCHING_R,
  ARRANGER_CURSOR_RESIZING_R_LOOP,
  ResizingUp,
  ResizingUpFadeIn,
  ResizingUpFadeOut,
  GrabbingCopy,
  GrabbingLink,
  Range,
  FadeIn,
  FadeOut,
  Rename,
  Panning,
};

enum class ArrangerWidgetType
{
  Timeline,
  Midi,
  MidiModifier,
  Audio,
  Chord,
  Automation,
};
 
#if 0
typedef enum ArrangerWidgetHoverType
{
  ARRANGER_WIDGET_HOVER_TYPE_NONE,
  ARRANGER_WIDGET_HOVER_TYPE_TRACK,
  ARRANGER_WIDGET_HOVER_TYPE_TRACK_LANE,
  ARRANGER_WIDGET_HOVER_TYPE_AUTOMATION_TRACK,
} ArrangerWidgetHoverType;
#endif

using ArrangerWidget = struct _ArrangerWidget
{
  GtkWidget parent_instance;

  ArrangerWidgetType type;
 
  GtkGestureDrag *           drag;
  GtkGestureClick *          click;
  GtkGestureClick *          right_click;
  GtkEventControllerMotion * motion_controller;

  double last_offset_x;
  double last_offset_y;

  double offset_x_from_scroll;
  double offset_y_from_scroll;
 
  UiOverlayAction action;

  double start_x;

  double start_y;

  double start_pos_px;

  bool drag_update_started;

  std::unique_ptr<Position> earliest_obj_start_pos;

  Position fade_pos_at_start;

  std::unique_ptr<ArrangerObject> start_object;

  std::weak_ptr<ArrangerObject> prj_start_object;

  std::weak_ptr<ArrangerObject> hovered_object;

  bool start_object_was_selected;

  std::unique_ptr<ArrangerSelections> sel_at_start;
 
#if 0
  std::vector<ArrangerObject *> live_selections;
#endif

  std::unique_ptr<Region> region_at_start;

  std::unique_ptr<ArrangerSelections> sel_to_delete;

  Position start_pos;

  bool was_paused;

  Position playhead_pos_at_start;

  double curr_ticks_diff_from_start;

  double adj_ticks_diff;

  double last_adj_ticks_diff;

  Position curr_pos;
 
  Position end_pos; 
  gboolean key_is_pressed;

  double hover_x;
  double hover_y;
 
  bool hovered;

  int n_press;

  std::shared_ptr<SnapGrid> snap_grid;

  int shift_held;

  int ctrl_held;

  int alt_held;
 
  gint64 last_frame_time;
 
  /* ----- TIMELINE ------ */

  int visible_track_diff;

  int lane_diff;

  int visible_at_diff;

  int is_pinned;

  int resizing_range;

  int resizing_range_start;
 
  AutomationTrack * hovered_at;
  TrackLane *       hovered_lane;
  Track *           hovered_track;
 
  /* textures used as region icons */
  GdkTexture * symbolic_link_texture;
  GdkTexture * music_note_16th_texture;
  GdkTexture * fork_awesome_snowflake_texture;
  GdkTexture * media_playlist_repeat_texture;

  int region_icon_texture_size;

  GskRenderNode * loop_line_node;
  GskRenderNode * clip_start_line_node;
  GskRenderNode * cut_line_node;
 
  /* ----- END TIMELINE ----- */
 
  /* ------ MIDI (PIANO ROLL) ---- */

  int hovered_note;
 
  /* ------ END MIDI (PIANO ROLL) ---- */
 
  /* ------ MIDI MODIFIER ---- */

  int start_vel_val;

  int vel_diff;
 
  /* ------ END MIDI MODIFIER ---- */
 
  /* ------- CHORD ------- */

  int hovered_chord_index;
 
  /* ------- END CHORD ------- */
 
  /* --- AUDIO --- */

  float fval_at_start;
 
  double dval_at_start;
 
  /* --- END AUDIO --- */

  int last_playhead_px;

  bool redraw;
 
  // cairo_t *      cached_cr;
 
  // cairo_surface_t * cached_surface;

  graphene_rect_t last_rect;

  bool can_link;

  bool is_highlighted;

  GdkRectangle highlight_rect;
  // GdkRectangle   prev_highlight_rect;
  //

  GdkRectangle last_selection_rect;

  guint drag_start_btn;

  bool first_draw;

  double new_hadj_val;

  Transport::Display ruler_display;

  PangoLayoutUniquePtr vel_layout;

  PangoLayoutUniquePtr ap_layout;

  PangoLayoutUniquePtr audio_layout;

  PangoLayoutUniquePtr debug_layout;

  int queued_playhead_px;

  GtkPopoverMenu * popover_menu;
 
  guint unlisten_notes_timeout_id;
};
 
const char *
arranger_widget_get_type_str (ArrangerWidgetType type);

bool
arranger_widget_can_scroll_vertically (ArrangerWidget * self);

void
arranger_widget_setup (
  ArrangerWidget *                 self,
  ArrangerWidgetType               type,
  const std::shared_ptr<SnapGrid> &snap_grid);

void
arranger_widget_set_cursor (ArrangerWidget * self, ArrangerCursor cursor);

int
arranger_widget_pos_to_px (
  ArrangerWidget * self,
  const Position   pos,
  bool             use_padding);

ArrangerCursor
arranger_widget_get_cursor (ArrangerWidget * self);

void
arranger_widget_refresh_cursor (ArrangerWidget * self);

void
arranger_widget_get_all_objects (
  ArrangerWidget *               self,
  std::vector<ArrangerObject *> &objs_arr);

Position
arranger_widget_px_to_pos (ArrangerWidget * self, double px, bool has_padding);

void
arranger_widget_get_visible_rect (ArrangerWidget * self, GdkRectangle * rect);

void
arranger_widget_get_hit_objects_at_point (
  ArrangerWidget *               self,
  ArrangerObject::Type           type,
  double                         x,
  double                         y,
  std::vector<ArrangerObject *> &arr);

void
arranger_widget_get_hit_objects_in_rect (
  ArrangerWidget *               self,
  ArrangerObject::Type           type,
  GdkRectangle *                 rect,
  std::vector<ArrangerObject *> &arr);

ArrangerObject *
arranger_widget_get_hit_arranger_object (
  ArrangerWidget *     self,
  ArrangerObject::Type type,
  const double         x,
  const double         y);
 
void
arranger_widget_select_all (ArrangerWidget * self, bool select, bool fire_events);
 
template <typename T = ArrangerObject>
  requires std::derived_from<T, ArrangerObject>
void
arranger_widget_set_start_object (ArrangerWidget * self, std::shared_ptr<T> obj)
{
  self->start_object = obj->clone_unique ();
  self->prj_start_object = obj;
}

ATTR_NONNULL bool
arranger_widget_is_in_moving_operation (ArrangerWidget * self);

template <typename T = ArrangerSelections>
  requires std::derived_from<T, ArrangerSelections>
T *
arranger_widget_get_selections (ArrangerWidget * self) ATTR_RETURNS_NONNULL;

void
arranger_widget_redraw_playhead (ArrangerWidget * self);
 
SnapGrid *
arranger_widget_get_snap_grid (ArrangerWidget * self);

gboolean
arranger_widget_on_key_press (
  GtkEventControllerKey * key_controller,
  guint                   keyval,
  guint                   keycode,
  GdkModifierType         state,
  ArrangerWidget *        self);
 
void
arranger_widget_on_key_release (
  GtkEventControllerKey * key_controller,
  guint                   keyval,
  guint                   keycode,
  GdkModifierType         state,
  ArrangerWidget *        self);

void
arranger_widget_handle_erase_action (ArrangerWidget * self);

ATTR_NONNULL void
arranger_widget_scroll_until_obj (
  ArrangerWidget * self,
  ArrangerObject * obj,
  bool             horizontal,
  bool             up,
  bool             left,
  int              padding);

void
arranger_widget_toggle_selections_muted (
  ArrangerWidget * self,
  ArrangerObject * clicked_object);

void
arranger_widget_get_min_possible_position (ArrangerWidget * self, Position * pos);

void
arranger_widget_set_highlight_rect (ArrangerWidget * self, GdkRectangle * rect);

EditorSettingsPtrVariant
arranger_widget_get_editor_settings (ArrangerWidget * self);

std::unique_ptr<EditorSettings>
arranger_widget_get_editor_setting_values (ArrangerWidget * self);
 
bool
arranger_widget_is_playhead_visible (ArrangerWidget * self);
 
ATTR_NONNULL void
arranger_widget_handle_playhead_auto_scroll (ArrangerWidget * self, bool force);
 
typedef void (*ArrangerWidgetForeachFunc) (ArrangerWidget * arranger);

ATTR_NONNULL void
arranger_widget_foreach (ArrangerWidgetForeachFunc func);
 
ATTR_NONNULL RulerWidget *
arranger_widget_get_ruler (ArrangerWidget * self);

bool
arranger_widget_any_doing_action (void);

int
arranger_widget_get_playhead_px (ArrangerWidget * self);
 
#define arranger_widget_print_action(self) z_debug ("action: {}", self->action)

bool
arranger_widget_get_drum_mode_enabled (ArrangerWidget * self);

ATTR_NONNULL void
arranger_widget_create_item (
  ArrangerWidget * self,
  double           start_x,
  double           start_y,
  bool             autofilling);

ATTR_NONNULL bool
arranger_widget_finish_creating_item_from_action (
  ArrangerWidget * self,
  double           x,
  double           y);

int
arranger_widget_get_total_height (ArrangerWidget * self);

bool
arranger_widget_is_cursor_in_top_half (ArrangerWidget * self, double y);

std::pair<ArrangerObject::ResizeType, bool>
arranger_widget_get_resize_type_and_direction_from_action (
  UiOverlayAction action);
 
extern template MidiSelections *
arranger_widget_get_selections (ArrangerWidget * self);
extern template TimelineSelections *
arranger_widget_get_selections (ArrangerWidget * self);
extern template ChordSelections *
arranger_widget_get_selections (ArrangerWidget * self);
extern template AutomationSelections *
arranger_widget_get_selections (ArrangerWidget * self);

 
#endif