arranger_object_all.h

// SPDX-FileCopyrightText: © 2024-2025 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
 
#pragma once
 
#include "structure/arrangement/audio_clip.h"
#include "structure/arrangement/audio_source_object.h"
#include "structure/arrangement/automation_clip.h"
#include "structure/arrangement/chord_clip.h"
#include "structure/arrangement/chord_object.h"
#include "structure/arrangement/marker.h"
#include "structure/arrangement/midi_clip.h"
#include "structure/arrangement/midi_control_event.h"
#include "structure/arrangement/midi_note.h"
#include "structure/arrangement/scale_object.h"
#include "structure/arrangement/tempo_object.h"
#include "structure/arrangement/time_signature_object.h"
 
namespace zrythm::structure::arrangement
{
 
template <FinalArrangerObjectSubclass ObjT>
bool
is_arranger_object_deletable (const ObjT &obj)
{
  if constexpr (std::is_same_v<ObjT, Marker>)
    {
      return obj.markerType () == Marker::MarkerType::Custom;
    }
  else
    {
      return true;
    }
}
 
// Currently unused
#if 0
template <ClipObject ObjectT>
[[gnu::nonnull]] std::pair<int64_t, bool>
get_frames_till_next_loop_or_end (
  const ObjectT &obj,
  int64_t timeline_frames)
{
  const auto   loop_size = obj.get_loop_length_in_frames ();
  assert (loop_size > 0);
  const auto           object_position_frames = obj.position ()->samples ();
  const int64_t loop_end_frames =
    obj.loopEndPosition ()->samples ();
  const int64_t clip_start_frames =
    obj.clipStartPosition ()->samples ();
 
  int64_t local_frames = timeline_frames - object_position_frames;
  local_frames += clip_start_frames;
  while (local_frames >= loop_end_frames)
    {
      local_frames -= loop_size;
    }
 
  const int64_t frames_till_next_loop = loop_end_frames - local_frames;
  const int64_t frames_till_end =
    obj.get_end_position_samples (true) - timeline_frames;
 
  return std::make_pair (
    std::min (frames_till_end, frames_till_next_loop),
    frames_till_next_loop < frames_till_end);
}
#endif

inline bool
is_clip (const ArrangerObject &obj)
{
  return qobject_cast<const Clip *> (&obj) != nullptr;
}

inline dsp::TimelineTick
timeline_ticks (const ArrangerObject &obj)
{
  const auto * parent = obj.parentObject ();
  if (parent != nullptr)
    {
      if (const auto * clip = qobject_cast<const Clip *> (parent))
        {
          return clip->contentWarp ()->contentToTimeline (
            qobject_cast<const dsp::ContentPosition *> (obj.position ())
              ->asTick ());
        }
    }
  return dsp::TimelineTick{ units::ticks (obj.position ()->ticks ()) };
}

inline dsp::TimelineTick
timeline_end_ticks (const ArrangerObject &obj)
{
  if (obj.length () == nullptr)
    return timeline_ticks (obj);
 
  const auto * parent = obj.parentObject ();
  if (parent != nullptr)
    {
      if (const auto * clip = qobject_cast<const Clip *> (parent))
        {
          const auto content_pos =
            qobject_cast<const dsp::ContentPosition *> (obj.position ())
              ->asTick ();
          return clip->contentWarp ()->contentToTimeline (
            content_pos + obj.length ()->asTick ());
        }
    }
 
  if (const auto * clip = qobject_cast<const Clip *> (&obj))
    {
      return clip->contentWarp ()->contentToTimeline (
        clip->length ()->asTick ());
    }
 
  // Standalone bounded object (no clip context): raw addition.
  return dsp::TimelineTick{
    units::ticks (obj.position ()->ticks () + obj.length ()->ticks ())
  };
}
 
inline auto
get_object_tick_range (const ArrangerObject * obj)
{
  return std::make_pair (
    timeline_ticks (*obj).asDouble (), timeline_end_ticks (*obj).asDouble ());
}

inline void
set_end_from_timeline_ticks (ArrangerObject &obj, dsp::TimelineTick timeline_end)
{
  if (obj.length () == nullptr)
    return;
 
  // Child object inside a clip — reverse-warp through parent
  const auto * parent = obj.parentObject ();
  if (parent != nullptr)
    {
      if (const auto * parent_clip = qobject_cast<const Clip *> (parent))
        {
          const auto content_end =
            parent_clip->contentWarp ()->timelineToContent (timeline_end);
          const auto content_pos =
            qobject_cast<const dsp::ContentPosition *> (obj.position ())
              ->asTick ();
          obj.length ()->setTicks ((content_end - content_pos).asDouble ());
          return;
        }
    }
 
  // Clip itself — reverse-warp through own warp
  if (auto * clip = qobject_cast<Clip *> (&obj))
    {
      const auto content_end =
        clip->contentWarp ()->timelineToContent (timeline_end);
      clip->length ()->setTicks (content_end.asDouble ());
      return;
    }
 
  // Standalone bounded object (no clip context) — raw subtraction
  obj.length ()->setTicks (
    (timeline_end - dsp::TimelineTick{ units::ticks (obj.position ()->ticks ()) })
      .asDouble ());
}
 
}