arranger_object.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: © 2019-2022 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#ifndef __GUI_BACKEND_ARRANGER_OBJECT_H__
#define __GUI_BACKEND_ARRANGER_OBJECT_H__
 
#include <stdbool.h>
 
#include "dsp/curve.h"
#include "dsp/position.h"
#include "dsp/region_identifier.h"
#include "utils/yaml.h"
 
#include <glib/gi18n.h>
 
typedef struct ArrangerObject                 ArrangerObject;
typedef struct ArrangerSelections             ArrangerSelections;
typedef struct _ArrangerWidget                ArrangerWidget;
typedef struct _ArrangerObjectWidget          ArrangerObjectWidget;
typedef struct UndoableAction                 UndoableAction;
typedef enum ArrangerSelectionsActionEditType ArrangerSelectionsActionEditType;
 
#define ARRANGER_OBJECT_MAGIC 347616554
#define IS_ARRANGER_OBJECT(tr) \
  (((ArrangerObject *) tr)->magic == ARRANGER_OBJECT_MAGIC \
   && ((ArrangerObject *) tr)->type >= ARRANGER_OBJECT_TYPE_REGION \
   && ((ArrangerObject *) tr)->type <= ARRANGER_OBJECT_TYPE_VELOCITY)
#define IS_ARRANGER_OBJECT_AND_NONNULL(x) (x && IS_ARRANGER_OBJECT (x))
 
typedef enum ArrangerObjectResizeType
{
  ARRANGER_OBJECT_RESIZE_NORMAL,
  ARRANGER_OBJECT_RESIZE_LOOP,
  ARRANGER_OBJECT_RESIZE_FADE,
  ARRANGER_OBJECT_RESIZE_STRETCH,
 
  ARRANGER_OBJECT_RESIZE_STRETCH_BPM_CHANGE,
} ArrangerObjectResizeType;
 
typedef enum ArrangerObjectType
{
  /* These two are not actual object types. */
  ARRANGER_OBJECT_TYPE_NONE,
  ARRANGER_OBJECT_TYPE_ALL,
 
  ARRANGER_OBJECT_TYPE_REGION,
  ARRANGER_OBJECT_TYPE_MIDI_NOTE,
  ARRANGER_OBJECT_TYPE_CHORD_OBJECT,
  ARRANGER_OBJECT_TYPE_SCALE_OBJECT,
  ARRANGER_OBJECT_TYPE_MARKER,
  ARRANGER_OBJECT_TYPE_AUTOMATION_POINT,
  ARRANGER_OBJECT_TYPE_VELOCITY,
} ArrangerObjectType;
 
static const char * arranger_object_type_strings[] = {
  N_ ("None"),         N_ ("All"),
  N_ ("Region"),       N_ ("Midi Note"),
  N_ ("Chord Object"), N_ ("Scale Object"),
  N_ ("Marker"),       N_ ("Automation Point"),
  N_ ("Velocity"),
};
 
typedef enum ArrangerObjectFlags
{
  ARRANGER_OBJECT_FLAG_NON_PROJECT = 1 << 0,
 
} ArrangerObjectFlags;
 
typedef enum ArrangerObjectPositionType
{
  ARRANGER_OBJECT_POSITION_TYPE_START,
  ARRANGER_OBJECT_POSITION_TYPE_END,
  ARRANGER_OBJECT_POSITION_TYPE_CLIP_START,
  ARRANGER_OBJECT_POSITION_TYPE_LOOP_START,
  ARRANGER_OBJECT_POSITION_TYPE_LOOP_END,
  ARRANGER_OBJECT_POSITION_TYPE_FADE_IN,
  ARRANGER_OBJECT_POSITION_TYPE_FADE_OUT,
} ArrangerObjectPositionType;
 
typedef struct ArrangerObject
{
  ArrangerObjectType type;
 
  ArrangerObjectFlags flags;
 
  Position pos;
 
  Position end_pos;
 
  Position clip_start_pos;
 
  Position loop_start_pos;
 
  Position loop_end_pos;
 
  Position fade_in_pos;
 
  Position fade_out_pos;
 
  CurveOptions fade_in_opts;
 
  CurveOptions fade_out_opts;
 
  GdkRectangle full_rect;
 
  // GdkRectangle       draw_rect;
 
  int textw;
  int texth;
 
  ArrangerObject * transient;
 
  ArrangerObject * main;
 
  bool muted;
 
  int magic;
 
  RegionIdentifier region_id;
 
  int index_in_prev_lane;
 
  bool deleted_temporarily;
 
  /* --- The following should only be used for objects that really need caching,
   * such as audio regions --- */
 
  bool use_cache;
 
  cairo_t * cached_cr[2];
 
  cairo_surface_t * cached_surface[2];
 
  GdkRectangle last_name_rect;
 
  bool is_auditioner;
} ArrangerObject;
 
#define arranger_object_type_has_length(type) \
  (type == ARRANGER_OBJECT_TYPE_REGION \
   || type == ARRANGER_OBJECT_TYPE_MIDI_NOTE)
 
#define arranger_object_type_has_global_pos(type) \
  (type == ARRANGER_OBJECT_TYPE_REGION \
   || type == ARRANGER_OBJECT_TYPE_SCALE_OBJECT \
   || type == ARRANGER_OBJECT_TYPE_MARKER)
 
#define arranger_object_type_has_name(type) \
  (type == ARRANGER_OBJECT_TYPE_REGION || type == ARRANGER_OBJECT_TYPE_MARKER)
 
#define arranger_object_can_have_lanes(_obj) \
  ((_obj)->type == ARRANGER_OBJECT_TYPE_REGION \
   && region_type_has_lane (((ZRegion *) _obj)->id.type))
 
#define arranger_object_type_can_loop(type) \
  (type == ARRANGER_OBJECT_TYPE_REGION)
 
#define arranger_object_can_fade(_obj) \
  ((_obj)->type == ARRANGER_OBJECT_TYPE_REGION \
   && region_type_can_fade (((ZRegion *) _obj)->id.type))
 
#define arranger_object_can_mute(_obj) \
  ((_obj)->type == ARRANGER_OBJECT_TYPE_REGION \
   || (_obj)->type == ARRANGER_OBJECT_TYPE_MIDI_NOTE)
 
#define arranger_object_owned_by_region(_obj) \
  ((_obj)->type == ARRANGER_OBJECT_TYPE_VELOCITY \
   || (_obj)->type == ARRANGER_OBJECT_TYPE_MIDI_NOTE \
   || (_obj)->type == ARRANGER_OBJECT_TYPE_CHORD_OBJECT \
   || (_obj)->type == ARRANGER_OBJECT_TYPE_AUTOMATION_POINT)
 
#define arranger_object_can_cache_drawing(_obj) (false)
 
#if 0
  ((_obj)->type == ARRANGER_OBJECT_TYPE_REGION && \
    region_type_can_fade ( \
      ((ZRegion *) _obj)->id.type))
#endif
 
ArrangerWidget *
arranger_object_get_arranger (const ArrangerObject * self);
 
void
arranger_object_set_magic (ArrangerObject * self);
 
HOT ZRegion *
arranger_object_get_region (const ArrangerObject * const self);
 
const char *
arranger_object_get_name (const ArrangerObject * self);
 
char *
arranger_object_gen_human_readable_name (const ArrangerObject * self);
 
void
arranger_object_gen_escaped_name (const ArrangerObject * self);
 
void
arranger_object_set_to_object (ArrangerObject * dest, ArrangerObject * src);
 
ArrangerObject *
arranger_object_get_object (ArrangerObject * self);
 
void
arranger_object_init (ArrangerObject * self);
 
void
arranger_object_init_loaded (ArrangerObject * self);
 
ArrangerSelections *
arranger_object_get_selections_for_type (ArrangerObjectType type);
 
void
arranger_object_select (
  ArrangerObject * self,
  const bool       select,
  const bool       append,
  bool             fire_events);
 
NONNULL_ARGS (1)
PURE WARN_UNUSED_RESULT bool arranger_object_is_hit (
  const ArrangerObject * self,
  const Position *       start,
  const Position *       end);
 
int
arranger_object_get_num_loops (ArrangerObject * self, const int count_incomplete);
 
bool
arranger_object_is_selected (ArrangerObject * self);
 
NONNULL void
arranger_object_print (const ArrangerObject * self);
 
NONNULL bool
arranger_object_get_muted (ArrangerObject * self, bool check_parent);
 
void
arranger_object_set_muted (ArrangerObject * self, bool muted, bool fire_events);
 
void
arranger_object_get_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_end_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_clip_start_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_loop_start_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_loop_end_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_fade_in_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_fade_out_pos (const ArrangerObject * self, Position * pos);
 
void
arranger_object_get_position_from_type (
  const ArrangerObject *     self,
  Position *                 pos,
  ArrangerObjectPositionType type);
 
void
arranger_object_edit_begin (const ArrangerObject * self);
 
void
arranger_object_edit_finish (
  const ArrangerObject *           self,
  ArrangerSelectionsActionEditType type);
 
void
arranger_object_edit_position_finish (const ArrangerObject * self);
 
void
arranger_object_pos_setter (ArrangerObject * self, const Position * pos);
 
void
arranger_object_end_pos_setter (ArrangerObject * self, const Position * pos);
 
void
arranger_object_clip_start_pos_setter (
  ArrangerObject * self,
  const Position * pos);
 
void
arranger_object_loop_start_pos_setter (
  ArrangerObject * self,
  const Position * pos);
 
void
arranger_object_loop_end_pos_setter (ArrangerObject * self, const Position * pos);
 
HOT NONNULL WARN_UNUSED_RESULT bool
arranger_object_is_position_valid (
  const ArrangerObject * const self,
  const Position *             pos,
  ArrangerObjectPositionType   pos_type);
 
#define arranger_object_validate_pos arranger_object_is_position_valid
 
bool
arranger_object_set_position (
  ArrangerObject *           self,
  const Position *           pos,
  ArrangerObjectPositionType pos_type,
  const bool                 validate);
 
void
arranger_object_copy_identifier (ArrangerObject * dest, ArrangerObject * src);
 
void
arranger_object_add_linked_region (ArrangerObject * self, ZRegion * region);
 
void
arranger_object_remove_linked_region (ArrangerObject * self, ZRegion * region);
 
void
arranger_object_move (ArrangerObject * self, const double ticks);
 
NONNULL WARN_UNUSED_RESULT static inline double
arranger_object_get_length_in_ticks (const ArrangerObject * const self)
{
  g_return_val_if_fail (arranger_object_type_has_length (self->type), 0);
 
  return self->end_pos.ticks - self->pos.ticks;
}
 
NONNULL WARN_UNUSED_RESULT static inline signed_frame_t
arranger_object_get_length_in_frames (const ArrangerObject * const self)
{
  g_return_val_if_fail (arranger_object_type_has_length (self->type), 0);
 
  return self->end_pos.frames - self->pos.frames;
}
 
NONNULL static inline double
arranger_object_get_loop_length_in_ticks (const ArrangerObject * const self)
{
  g_return_val_if_fail (arranger_object_type_has_length (self->type), 0);
 
  return self->loop_end_pos.ticks - self->loop_start_pos.ticks;
}
 
NONNULL HOT static inline signed_frame_t
arranger_object_get_loop_length_in_frames (const ArrangerObject * const self)
{
  g_return_val_if_fail (arranger_object_type_has_length (self->type), 0);
 
  return self->loop_end_pos.frames - self->loop_start_pos.frames;
}
 
void
arranger_object_update_positions (
  ArrangerObject * self,
  bool             from_ticks,
  bool             bpm_change,
  UndoableAction * action);
 
void
arranger_object_free (ArrangerObject * self);
 
WARN_UNUSED_RESULT bool
arranger_object_resize (
  ArrangerObject *         self,
  const bool               left,
  ArrangerObjectResizeType type,
  const double             ticks,
  bool                     during_ui_action,
  GError **                error);
 
void
arranger_object_append_children (ArrangerObject * self, GPtrArray * children);
 
void
arranger_object_add_ticks_to_children (ArrangerObject * self, const double ticks);
 
#define _ARRANGER_OBJECT_FREE_AND_SET_STRING(_obj, _val_name, _val_value) \
  g_free_and_null (_obj->_val_name); \
  _obj->_val_name = g_strdup (_val_value)
 
#define arranger_object_set_string(cc, obj, val_name, val_value) \
  { \
    cc * _obj = (cc *) obj; \
    _ARRANGER_OBJECT_FREE_AND_SET_STRING (_obj, val_name, val_value); \
  }
 
HOT NONNULL Track *
arranger_object_get_track (const ArrangerObject * const self);
 
static inline const char *
arranger_object_get_type_as_string (ArrangerObjectType type)
{
  return arranger_object_type_strings[type];
}
 
void
arranger_object_post_deserialize (ArrangerObject * self);
 
bool
arranger_object_validate (const ArrangerObject * const self);
 
bool
arranger_object_validate_name (ArrangerObject * self, const char * name);
 
ArrangerObject *
arranger_object_find (ArrangerObject * obj);
 
ArrangerObject *
arranger_object_clone (const ArrangerObject * self);
 
WARN_UNUSED_RESULT bool
arranger_object_split (
  ArrangerObject *  self,
  const Position *  pos,
  const bool        pos_is_local,
  ArrangerObject ** r1,
  ArrangerObject ** r2,
  bool              is_project,
  GError **         error);
 
WARN_UNUSED_RESULT NONNULL_ARGS (1, 2) bool arranger_object_unsplit (
  ArrangerObject *  r1,
  ArrangerObject *  r2,
  ArrangerObject ** obj,
  bool              fire_events,
  GError **         error);
 
void
arranger_object_set_name (
  ArrangerObject * self,
  const char *     name,
  int              fire_events);
 
void
arranger_object_set_name_with_action (ArrangerObject * self, const char * name);
 
void
arranger_object_set_start_pos_full_size (ArrangerObject * obj, Position * pos);
 
void
arranger_object_set_end_pos_full_size (ArrangerObject * obj, Position * pos);
 
WARN_UNUSED_RESULT NONNULL_ARGS (1) bool arranger_object_add_to_project (
  ArrangerObject * obj,
  bool             fire_events,
  GError **        error);
 
WARN_UNUSED_RESULT bool
arranger_object_insert_to_project (ArrangerObject * obj, GError ** error);
 
void
arranger_object_remove_from_project (ArrangerObject * obj);
 
bool
arranger_object_is_frozen (ArrangerObject * obj);
 
bool
arranger_object_is_deletable (const ArrangerObject * obj);
 
bool
arranger_object_is_renamable (const ArrangerObject * obj);
 
void
arranger_object_remove_child (ArrangerObject * self, ArrangerObject * child);
 
#endif