project-kyoku/src/application/editorstate.cpp

#include "editorstate.h"
#include "widgets/button.h"
#include "widgets/group.h"
#include "widgets/menubar.h"
#include "widgets/window.h"
#include "widgets/editorwidget.h"
#include "widgets/bpmcalculatorwidget.h"
#include "tools/bpmcalculator.h"

#include "core/editor.h"

#include <iostream>

EditorState::EditorState(std::unique_ptr<Editor>&& editor, Callbacks&& callbacks, const FontHolder& font_holder) :
    _font(font_holder.get(Fonts::Id::GUI)),
    _callbacks(std::move(callbacks)),
    _editor(std::move(editor))
{}

EditorState::~EditorState()
{}

void EditorState::input(const sf::Event& event)
{
    _group->input(event);
}

void EditorState::update(const sf::Time& dt)
{
    _group->update(dt);
}

void EditorState::draw(sf::RenderTarget &target, sf::RenderStates states) const
{
    target.draw(*_group, states);
}

void EditorState::enter(sf::Vector2u &&render_size)
{
    _music.openFromFile("METEOR.flac");
    _music.setVolume(5);

    auto& group = _group;
    auto& music = _music;
    auto& editor = _editor;

    _bpm_calculator = std::make_shared<BPMCalculator>();
    auto& bpm_calculator = _bpm_calculator;
    std::shared_ptr<BPMCalculatorWidget> bpm_widget = std::make_shared<BPMCalculatorWidget>(_bpm_calculator, _font);

    auto button_start = std::make_shared<PushButton>("Start", _font);
    auto button_stop = std::make_shared<PushButton>("Stop", _font);
    auto button_apply = std::make_shared<PushButton>("Apply", _font);

    button_start->setCallback([bpm_calculator, button_start, button_stop, &music]()
    {
        music.play();
        bpm_calculator->start();
        button_start->setVisibility(false);
        button_stop->setVisibility(true);
    });

    button_stop->setCallback([bpm_calculator, button_start, button_stop, &music]()
    {
        music.stop();
        bpm_calculator->stop();
        button_start->setVisibility(true);
        button_stop->setVisibility(false);
    });

    button_apply->setCallback([&editor, bpm_calculator]()
    {
        BPMSection section;
        const auto& info = bpm_calculator->fetchApproximatedInfo();
        section.bpm = info.BPM;
        section.interval = info.interval;
        section.fraction = 2;
        section.offset_start = bpm_calculator->getStartingOffset();

        editor->insertBPMSection(std::move(section));
    });

    BPMCalculatorWidget::Init bpm_widget_init;
    bpm_widget_init.stop = button_stop;
    bpm_widget_init.apply = button_apply;
    bpm_widget_init.start = button_start;
    bpm_widget_init.current_time = [&music]() -> microsec { return music.fetchOffset(); };

    bpm_widget->init(std::move(bpm_widget_init));
    const auto bpm_widget_callback = [&group, bpm_widget=bpm_widget, &music]()
    {
        music.stop();
        bpm_widget->setVisibility(false);
        group->unblock();
    };

    const float window_width = render_size.x;

    auto menu_bar = std::make_shared<MenuBar>(_font);

    auto bpm_button = std::make_shared<PushButton>("Calculate BPM", _font);

    bpm_button->setCallback([&group, bpm_widget=bpm_widget]()
                            {
                                group->blockBy(bpm_widget);
                                bpm_widget->setVisibility(true);
                            });

    bpm_widget->setRect(sf::FloatRect(render_size.x / 3, render_size.y / 3,
                                      render_size.x / 3, render_size.y / 3));

    bpm_widget->addBarButton("X", bpm_widget_callback);
    bpm_widget->setVisibility(false);

    auto test_menu_2 = std::make_shared<MenuDrop>();
    test_menu_2->setRect(sf::FloatRect{0, 0, 200, 27 * 5});

    auto test_menu_3 = std::make_shared<MenuDrop>();
    test_menu_3->setRect(sf::FloatRect{0, 0, 200, 27 * 5});

    auto test_cascade_button = std::make_shared<CascadeMenuButton>("Show submenu", _font);

    auto test_cascade_button_2 = std::make_shared<CascadeMenuButton>("Show submenu 2", _font);

    auto quit_button = std::make_shared<PushButton>("Quit", _font);
    quit_button->setCallback(_callbacks.onLeaveEditorState);

    auto test_menu = std::make_shared<MenuDrop>();
    test_menu->setRect(sf::FloatRect{0, 0, 200, 27 * 3});

    menu_bar->setRect(sf::FloatRect(0, 0, window_width, 27));
    menu_bar->addRootSubMenu("test", test_menu);
    menu_bar->addDependentSubmenu(test_menu_2);
    menu_bar->addDependentSubmenu(test_menu_3);

    test_cascade_button->setSubmenu(test_menu_2);

    test_menu->addPushButton(bpm_button);
    test_menu->addCascadeButton(test_cascade_button);
    test_menu->addPushButton(quit_button);

    test_cascade_button->resetRect();

    test_cascade_button_2->setSubmenu(test_menu_3);
    test_menu_2->addCascadeButton(test_cascade_button_2);
    test_cascade_button_2->resetRect();

    menu_bar->setVisibility(true);

    EditorWidget::Callbacks callbacks;
    callbacks.onDraw = [&editor](sf::RenderTarget& target, sf::RenderStates states)
    {
        (void)target; (void)states; // fucking shit i am a retard damn fuck fuck
        editor->draw();
    };

    callbacks.onInput = [&editor, &music](const sf::Event& event)
    {
        if (event.key.code == sf::Keyboard::Space && event.type == sf::Event::KeyReleased)
            music.isPaused() ? music.play() : music.pause();
        else if (event.type == sf::Event::MouseWheelScrolled)
        {
            music.moveOffset(event.mouseWheelScroll.delta > 0 ? 500000 : -500000);
            editor->recalculate(music.fetchOffset());
        }
        else
            editor->input(PlayerInput{music.fetchOffset(), event});
    };

    callbacks.onUpdate = [&editor, &music](const sf::Time& dt)
    {
        editor->update(UpdateData{music.fetchOffset(), dt});
    };

    auto editor_widget = std::make_shared<EditorWidget>(std::move(callbacks));

    _group = std::make_shared<Group>();
    _group->addChild(editor_widget);
    _group->addChild(menu_bar);
    _group->addChild(bpm_widget);
}

void EditorState::leave()
{
    _group.reset();
    _bpm_calculator.reset();
}