selection.hpp

Go to the documentation of this file.

#pragma once

 
#include <pulp/timeline/model.hpp>
 
#include <algorithm>
#include <optional>
#include <span>
#include <vector>
 
namespace pulp::timeline_editor {


class Selection {
  public:
    std::span<const timeline::ItemId> items() const noexcept {
        return items_;
    }

    std::optional<timeline::ItemId> anchor() const noexcept {
        return anchor_;
    }

    bool contains(timeline::ItemId item) const noexcept {
        return std::binary_search(items_.begin(), items_.end(), item);
    }

    bool empty() const noexcept {
        return items_.empty();
    }

    void clear() noexcept {
        items_.clear();
        anchor_.reset();
    }

    void replace(std::span<const timeline::ItemId> items) {
        anchor_.reset();
        items_.clear();
        items_.reserve(items.size());
        for (const auto item : items) {
            if (!item.valid())
                continue;
            if (!anchor_)
                anchor_ = item;
            items_.push_back(item);
        }
        canonicalize();
    }

    void add(timeline::ItemId item) {
        if (!item.valid() || contains(item))
            return;
        items_.insert(std::lower_bound(items_.begin(), items_.end(), item), item);
        if (!anchor_)
            anchor_ = item;
    }

    void toggle(timeline::ItemId item) {
        if (!item.valid())
            return;
        const auto found = std::lower_bound(items_.begin(), items_.end(), item);
        if (found == items_.end() || *found != item) {
            items_.insert(found, item);
            if (!anchor_)
                anchor_ = item;
            return;
        }
        items_.erase(found);
        if (anchor_ == item)
            anchor_ =
                items_.empty() ? std::nullopt : std::optional<timeline::ItemId>{items_.front()};
    }

    bool extend_from_anchor(timeline::ItemId item,
                            std::span<const timeline::ItemId> ordered_items) {
        if (!item.valid())
            return false;
        const auto target = std::find(ordered_items.begin(), ordered_items.end(), item);
        if (target == ordered_items.end())
            return false;
        if (!anchor_) {
            replace(std::span<const timeline::ItemId>(&*target, 1));
            return true;
        }
        const auto start = std::find(ordered_items.begin(), ordered_items.end(), *anchor_);
        if (start == ordered_items.end())
            return false;
 
        const auto first = std::min(start, target);
        const auto last = std::max(start, target);
        items_.assign(first, last + 1);
        canonicalize();
        return true;
    }

    void prune(const timeline::Project& project) {
        const auto dead = [&](timeline::ItemId item) {
            const auto location = project.locate(item);
            return !location || !location->active;
        };
        items_.erase(std::remove_if(items_.begin(), items_.end(), dead), items_.end());
        if (anchor_ && dead(*anchor_))
            anchor_.reset();
    }
 
  private:
    void canonicalize() {
        items_.erase(std::remove_if(items_.begin(), items_.end(),
                                    [](timeline::ItemId item) { return !item.valid(); }),
                     items_.end());
        std::sort(items_.begin(), items_.end());
        items_.erase(std::unique(items_.begin(), items_.end()), items_.end());
    }
 
    std::vector<timeline::ItemId> items_;
    std::optional<timeline::ItemId> anchor_;
};

 
} // namespace pulp::timeline_editor