UnigineActions.h

// Copyright (C), UNIGINE. All rights reserved.
#pragma once


#include <editor/UnigineUndo.h>

#include <UnigineNode.h>
#include <UnigineVector.h>


// Forward decl.
namespace UnigineEditor
{
class Selector;
class SelectionActionPrivate;
class CreateNodesActionPrivate;
class RemoveNodesActionPrivate;
class SetNodeTransformActionPrivate;
class ReparentNodesActionPrivate;
class RenameNodeActionPrivate;
class EnableNodeActionPrivate;
}


namespace UnigineEditor
{

class UNIGINE_EDITOR_API SelectionAction : public Action
{
public:
    explicit SelectionAction(Selector *s);
    ~SelectionAction() override;

    void apply() override;
    void undo() override;
    void redo() override { apply(); }

    bool modifiesWorld() const override { return false; }
    bool validate() override;

    static void applySelection(Selector *selector);
    static void refreshSelection(bool expand = false);

public:
    ::UnigineEditor::SelectionActionPrivate *const d;
};

class UNIGINE_EDITOR_API CreateNodesAction : public Action
{
public:
    explicit CreateNodesAction(const Unigine::NodePtr &node);
    explicit CreateNodesAction(const Unigine::Vector<Unigine::NodePtr> &nodes);
    ~CreateNodesAction() override;

    void apply() override;
    void undo() override;
    void redo() override;

    Unigine::Vector<Unigine::NodePtr> getNodes() const;

private:
    ::UnigineEditor::CreateNodesActionPrivate *const d;
};

class UNIGINE_EDITOR_API RemoveNodesAction : public Action
{
public:
    explicit RemoveNodesAction(const Unigine::NodePtr &node);
    explicit RemoveNodesAction(const Unigine::Vector<Unigine::NodePtr> &nodes);
    ~RemoveNodesAction() override;

    void apply() override;
    void undo() override;
    void redo() override { apply(); }

    bool validate() override;

    Unigine::Vector<Unigine::NodePtr> getNodes() const;

private:
    ::UnigineEditor::RemoveNodesActionPrivate *const d;
};

class UNIGINE_EDITOR_API SetNodeTransformAction : public Action
{
public:
    explicit SetNodeTransformAction(const Unigine::NodePtr &node,
        const Unigine::Math::Mat4 &transform);
    ~SetNodeTransformAction() override;

    void apply() override;
    void undo() override;
    void redo() override;
    bool validate() override;

    Unigine::NodePtr getNode() const;

private:
    ::UnigineEditor::SetNodeTransformActionPrivate *const d;
};

class UNIGINE_EDITOR_API ReparentNodesAction final : public Action
{
public:
    explicit ReparentNodesAction(const Unigine::Vector<Unigine::NodePtr> &nodes,
        const Unigine::NodePtr &new_parent,
        int new_index = -1);
    ~ReparentNodesAction() override;

    void apply() override;
    void undo() override;
    void redo() override;

private:
    ::UnigineEditor::ReparentNodesActionPrivate *const d;
};

class UNIGINE_EDITOR_API RenameNodeAction : public Action
{
public:
    explicit RenameNodeAction(const Unigine::NodePtr &node, const char *new_name);
    ~RenameNodeAction() override;

    void apply() override;
    void undo() override;
    void redo() override;
    bool validate() override;

private:
    ::UnigineEditor::RenameNodeActionPrivate *const d;
};

class UNIGINE_EDITOR_API EnableNodeAction : public Action
{
public:
    explicit EnableNodeAction(const Unigine::NodePtr &node, bool enabled);
    EnableNodeAction(const Unigine::Vector<Unigine::NodePtr> &nodes, bool enabled);
    ~EnableNodeAction() override;

    void apply() override;
    void undo() override;
    void redo() override;
    bool validate() override;

private:
    ::UnigineEditor::EnableNodeActionPrivate *const d;
};

} // namespace UnigineEditor