track_header_projection.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <optional>
#include <span>
#include <utility>
#include <vector>
 
#include <pulp/runtime/result.hpp>
#include <pulp/timeline/item_id.hpp>
 
namespace pulp::timeline_editor {

enum class TrackHeaderProjectionError : std::uint8_t {
    EmptyTrackOrder,
    InvalidTrackId,
    DuplicateTrackId,
    NonFiniteGeometry,
    NonPositiveRowHeight,
    NonFiniteCoordinate,
    MissingMovingTrack,
};

class TrackHeaderProjection {
  public:
    using DropTarget = std::optional<timeline::ItemId>;

    static runtime::Result<TrackHeaderProjection, TrackHeaderProjectionError>
    create(std::span<const timeline::ItemId> track_order, float origin_y, float row_height) {
        if (!std::isfinite(origin_y) || !std::isfinite(row_height)) {
            return runtime::Err(TrackHeaderProjectionError::NonFiniteGeometry);
        }
        if (row_height <= 0.0f) {
            return runtime::Err(TrackHeaderProjectionError::NonPositiveRowHeight);
        }
        if (track_order.empty()) {
            return runtime::Err(TrackHeaderProjectionError::EmptyTrackOrder);
        }
 
        std::vector<timeline::ItemId> order(track_order.begin(), track_order.end());
        for (const auto id : order) {
            if (!id.valid()) {
                return runtime::Err(TrackHeaderProjectionError::InvalidTrackId);
            }
        }
        auto sorted = order;
        std::sort(sorted.begin(), sorted.end());
        if (std::adjacent_find(sorted.begin(), sorted.end()) != sorted.end()) {
            return runtime::Err(TrackHeaderProjectionError::DuplicateTrackId);
        }
 
        const auto bottom = origin_y + row_height * static_cast<float>(order.size());
        if (!std::isfinite(bottom)) {
            return runtime::Err(TrackHeaderProjectionError::NonFiniteGeometry);
        }
        return runtime::Ok(TrackHeaderProjection(std::move(order), origin_y, row_height));
    }

    [[nodiscard]] std::optional<timeline::ItemId> track_at(float y) const noexcept {
        if (!std::isfinite(y) || y < origin_y_ || y >= bottom_y()) {
            return std::nullopt;
        }
        const auto index =
            std::min(static_cast<std::size_t>((y - origin_y_) / row_height_), order_.size() - 1);
        return order_[index];
    }

    [[nodiscard]] runtime::Result<DropTarget, TrackHeaderProjectionError>
    before_track_for_drop(float y, timeline::ItemId moving_track) const {
        if (!std::isfinite(y)) {
            return runtime::Err(TrackHeaderProjectionError::NonFiniteCoordinate);
        }
        if (std::find(order_.begin(), order_.end(), moving_track) == order_.end()) {
            return runtime::Err(TrackHeaderProjectionError::MissingMovingTrack);
        }
 
        std::size_t candidate_index = 0;
        for (const auto candidate : order_) {
            if (candidate == moving_track) {
                continue;
            }
            const auto center =
                origin_y_ + (static_cast<float>(candidate_index) + 0.5f) * row_height_;
            if (y < center) {
                return runtime::Ok(DropTarget{candidate});
            }
            ++candidate_index;
        }
        return runtime::Ok(DropTarget{});
    }

    [[nodiscard]] constexpr float origin_y() const noexcept {
        return origin_y_;
    }

    [[nodiscard]] constexpr float row_height() const noexcept {
        return row_height_;
    }

    [[nodiscard]] float bottom_y() const noexcept {
        return origin_y_ + row_height_ * static_cast<float>(order_.size());
    }

    [[nodiscard]] std::span<const timeline::ItemId> track_order() const noexcept {
        return order_;
    }
 
  private:
    TrackHeaderProjection(std::vector<timeline::ItemId> order, float origin_y, float row_height)
        : order_(std::move(order)), origin_y_(origin_y), row_height_(row_height) {}
 
    std::vector<timeline::ItemId> order_;
    float origin_y_ = 0.0f;
    float row_height_ = 0.0f;
};
 
} // namespace pulp::timeline_editor