Wt

#include "ParticleEffectUI.h"

#include "BasicParticleEditor.h"

#include "CurveEdit.h"

#include "ParticleEmitterModelEdit.h"

#include "DirectionEdit.h"

#include "EmitterListEdit.h"

#include "Slider.h"

#include "FloatSliderEdit.h"

#include "ParticleEffectsWriter.h"

#include "ExplosionUpdateMsg.h"

#include "BaseSFXEditor.h"

#include "Communication/SFXComSlot.h"

// core

#include "../../SDK/PlatformIndependent/Core/ProductInformation.h"

#include "../../SDK/PlatformIndependent/Core/ServiceManager.h"

#include "../../SDK/PlatformIndependent/Core/Label.h"

#include "../../SDK/PlatformIndependent/Core/XMLParser.h"

#include "../../SDK/PlatformIndependent/Core/XMLElement.h"

#include "../../SDK/SDKRuntime.h"

#include "../../SDK/PlatformIndependent/Core/Thread.h"

#include "../../SDK/PlatformIndependent/Core/Timer.h"

#include "../../SDK/PlatformIndependent/SceneManagement/SceneManager.h"

// simulation facade

#include "../../SimulationFacade/ExplosionConfig.h"

#include "../../SimulationFacade/GenericObject.h"

#include <Wt/WPanel>

#include <Wt/WBreak>

#include <Wt/WContainerWidget>

#include <Wt/WLineEdit>

#include <Wt/WPushButton>

#include <Wt/WText>

#include <Wt/WSlider>

#include <Wt/WTable>

#include <Wt/WTree>

#include <Wt/WTreeNode>

#include <Wt/WIconPair>

#include <Wt/WGridLayout>

#include <Wt/WHBoxLayout>

#include <Wt/WVBoxLayout>

#include <Wt/WDoubleValidator>

#include <Wt/WRegExpValidator>

#include <Wt/WSignalMapper>

#include <Wt/WTimer>

#include <Wt/WLogger>

#include <Wt/WStandardItemModel>

#include <Wt/Chart/WCartesianChart>

#include <Wt/WPointF>

#include <Wt/WPainterPath>

#include <Wt/WPainter>

#include <Wt/WScrollArea>

#include <Wt/WGroupBox>

#include <Wt/WPopupMenu>

#include <Wt/WMessageBox>

#include <Wt/WDialog>

#include <Wt/WStackedWidget>

#include <Wt/Ext/Button>

#include <Wt/Ext/LineEdit>

#include <Wt/Ext/ComboBox>

#include <Wt/Ext/CheckBox>

#include <Wt/Ext/RadioButton>

#include <Wt/Ext/Calendar>

#include <Wt/Ext/DateField>

#include <Wt/Ext/Menu>

#include <Wt/Ext/ToolBar>

#include <Wt/Ext/NumberField>

using namespace Wt;

using namespace Wt::Chart;

using namespace TVNG;

//-------------------------------------------------------------------------

ParticleEffectUI::ParticleEffectUI(const char* panelName, SFXComData::PAGE_CODE pageCode, unsigned int emitterFuncCode,

                                                                   unsigned int parameterFuncCode)

:

pageCode_ (pageCode),

emitterFuncCode_ (emitterFuncCode),

parameterFuncCode_ (parameterFuncCode),

editor_ (NULL),

messageBox_(NULL),

currentSelectedNode_(NULL),

com_ (BaseSFXEditor::sfxEditorInstance_->GetComSlot ())

{

        WVBoxLayout* layout = new WVBoxLayout();

        layout->setContentsMargins(0, 0, 0, 0);

        setLayout(layout);

        // toolbar

        Ext::ToolBar *toolBar = new Ext::ToolBar();

        Ext::Button *button = toolBar->addButton("Save");

        button->clicked().connect(this, &ParticleEffectUI::SaveClicked);

        layout->addWidget(toolBar);

        WContainerWidget* container = new WContainerWidget();

    WHBoxLayout *boxLayout = new WHBoxLayout(container);

        boxLayout->setContentsMargins(0, 0, 0, 0);

        layout->addWidget(container, 1);

        dynamicView_ = new WStackedWidget();

        // panel

        WPanel* panel = new WPanel();

        panel->setTitle(panelName);

        modelTree_ = new WTree();

        modelTree_->setSelectionMode(SingleSelection);

        WTreeNode* rootnode = new WTreeNode("");

        modelsRoot_ = rootnode;

        rootnode->setNodeVisible(false);

        rootnode->setSelectable(false);

        modelTree_->setTreeRoot(rootnode);

        boxLayout->addWidget(panel);

        boxLayout->setResizable(0, true);

        boxLayout->addWidget(dynamicView_, 1);

        WScrollArea* scrollArea = new WScrollArea();

        scrollArea->setScrollBarPolicy(WScrollArea::ScrollBarAsNeeded);

        scrollArea->setWidget(modelTree_);

        panel->setCentralWidget(scrollArea);

        boxLayout->setResizable(0, true);

        pemEdit_ = new ParticleEmitterModelEdit();

        pemEdit_->MinMaxParamChanged().connect(this, &ParticleEffectUI::MinMaxParamChanged);

        pemEdit_->FloatParamChanged().connect(this, &ParticleEffectUI::FloatParamChanged);

        pemEdit_->Vector3ParamChanged().connect(this, &ParticleEffectUI::Vector3ParamChanged);

        pemEdit_->IntParamChanged().connect(this, &ParticleEffectUI::IntParamChanged);

        dynamicView_->addWidget(new WContainerWidget());

        dynamicView_->addWidget(pemEdit_);

        mouseUpMapper_ = new WSignalMapper< WTreeNode*, WMouseEvent >(this);

        mouseUpMapper_->mapped().connect(this, &ParticleEffectUI::MouseUpBasicEmitter);

        popupActionMapper_ = new Wt::WSignalMapper< int >(this);

        popupActionMapper_->mapped().connect(this, &ParticleEffectUI::PopupAction);

        popup_ = new WPopupMenu();

        WPopupMenuItem* item = popup_->addItem("Copy");

        popupActionMapper_->mapConnect(item->triggered(), POPUP_COPY);

        item = popup_->addItem("Paste");

        popupActionMapper_->mapConnect(item->triggered(), POPUP_PASTE);

        item = popup_->addItem("Clone");

        popupActionMapper_->mapConnect(item->triggered(), POPUP_CLONE);

        popup_->addSeparator();

        item = popup_->addItem("Rename");

        popupActionMapper_->mapConnect(item->triggered(), POPUP_RENAME);

        item = popup_->addItem("Delete");

        item->setChecked(true);

        popupActionMapper_->mapConnect(item->triggered(), POPUP_DELETE);

        renameDialog_ = new WDialog();

        renameDialog_->setWindowTitle("Change Name");

        WContainerWidget* content = renameDialog_->contents();

        WVBoxLayout* dialogLayout = new WVBoxLayout(content);

        {

                WHBoxLayout* layout = new WHBoxLayout();

                dialogLayout->addLayout(layout);

                WText* text = new WText("Name :");

                text->setWordWrap(false);

                layout->addWidget(text, 0, AlignMiddle);

                renameEdit_ = new WLineEdit();

                renameEdit_->setTextSize(30);

                layout->addWidget(renameEdit_, 1, AlignMiddle);

        }

        {

                WHBoxLayout* layout = new WHBoxLayout();

                dialogLayout->addLayout(layout);

                WPushButton* ok = new WPushButton("OK");

                WPushButton* cancel = new WPushButton("Cancel");

                ok->clicked().connect(this, &ParticleEffectUI::RenameOK);

                cancel->clicked().connect(this, &ParticleEffectUI::RenameCancel);

                layout->addStretch(1);

                layout->addWidget(ok, 0, AlignMiddle);

                layout->addWidget(cancel, 0, AlignMiddle);

        }        

}

//-------------------------------------------------------------------------

ParticleEffectUI::~ParticleEffectUI()

{

        delete popup_;

        delete renameDialog_;

        if (editor_ != NULL)

                delete editor_;

}

//-------------------------------------------------------------------------

void ParticleEffectUI::NodeSelectionChanged(bool selected)

{

        if (!selected) 

                currentSelectedNode_ = NULL;

        else

        {

                const WTree::WTreeNodeSet& selectedNodes = modelTree_->selectedNodes();

                currentSelectedNode_ = *selectedNodes.begin();

                WTreeNode* modelNode = GetModelNode(currentSelectedNode_);

                UpdateSelectModel (emitterFuncCode_, modelNode->label()->text().toUTF8().c_str(), currentSelectedNode_->label()->text().toUTF8().c_str());

                dynamicView_->setCurrentWidget(pemEdit_);

                pemEdit_->UpdateUI(editor_->GetCurrentParticleEmitterModel ());

        }

}

//-------------------------------------------------------------------------

void ParticleEffectUI::RenameOK()

{

        WTreeNode* node = currentSelectedNode_;

        renameDialog_->setHidden(true);

        std::string name( renameEdit_->text().toUTF8() );

        if (name.empty()) return;

        if (node->label()->text().toUTF8() == name) return;

        if (RenameEmitterModel(name.c_str()) == false) return;

        node->label()->setText(name.c_str());

        // keep nodes sorted by name

        WTreeNode* parent = node->parentNode();

        parent->removeChildNode(node);

        const std::vector< WTreeNode * > &childNodes = parent->childNodes();

        for (int index(0); index<childNodes.size(); index++)

        {

                WTreeNode* child = childNodes.at(index);

                if (child->label()->text().toUTF8() > name)

                        break;

        }

        parent->insertChildNode(index, node);

        modelTree_->select(node);

}

//-------------------------------------------------------------------------

void ParticleEffectUI::RenameCancel()

{

        renameDialog_->setHidden(true);

}

//-------------------------------------------------------------------------

void ParticleEffectUI::MouseUpBasicEmitter(WTreeNode* node, const WMouseEvent& evt)

{

        if (evt.button() == WMouseEvent::RightButton)

        {

                if (currentSelectedNode_ != node)

                {

                        modelTree_->select(node);

                }

                if (popup_->isHidden())

                        popup_->popup(evt);

                else

                        popup_->hide();

        }        

        else

                popup_->hide();

}

//-------------------------------------------------------------------------

WTreeNode* ParticleEffectUI::GetModelNode(WTreeNode* emitterModelNode) const

{

        WTreeNode* node = emitterModelNode;

        do

        {

                node = node->parentNode();

        } 

        while (node->parentNode() != modelsRoot_);

        return node;

}

//-------------------------------------------------------------------------

void ParticleEffectUI::UpdateSelectModel(unsigned int funcCode, const char* modelName, const char* emitterModelName)

{

        ModelNamesData data (pageCode_, funcCode, modelName, emitterModelName);

        com_->Write (data);

        if (editor_ != NULL)

        {

                editor_->SetCurrentModel (modelName, emitterModelName);

        }

}

//-------------------------------------------------------------------------

void ParticleEffectUI::MinMaxParamChanged(unsigned int paramId, float minValue, float maxValue, const TVNG::FloatAnimationCurve* curve)

{

        ParameterData data (pageCode_, parameterFuncCode_, paramId, minValue, maxValue, curve);

        com_->Write (data);

        editor_->SetParam(paramId, minValue, maxValue, curve);

}

//-------------------------------------------------------------------------

void ParticleEffectUI::Vector3ParamChanged(unsigned int paramId, const Vector3f& value)

{

        Vector3fParameterData data (pageCode_, parameterFuncCode_, paramId, value);

        com_->Write (data);

        editor_->SetParam(paramId, value);

}

//-------------------------------------------------------------------------

void ParticleEffectUI::FloatParamChanged(unsigned int paramId, float value)

{

        FloatParameterData data (pageCode_, parameterFuncCode_, paramId, value);

        com_->Write (data);

        editor_->SetParam(paramId, value);

}

//-------------------------------------------------------------------------

void ParticleEffectUI::IntParamChanged(unsigned int paramId, int value)

{

        IntParameterData data (pageCode_, parameterFuncCode_, paramId, value);

        com_->Write (data);

        editor_->SetParam(paramId, value);

}

//-------------------------------------------------------------------------

void ParticleEffectUI::SaveClicked()

{

        messageBox_ = new WMessageBox("Save", "Do you want to overwrite the configuration file ?", Wt::NoIcon, Wt::Ok | Wt::Cancel);

        messageBox_->textWidget()->setWordWrap(false);

        messageBox_->buttonClicked().connect(this, &ParticleEffectUI::SaveConfirmationDone);

        messageBox_->show();

}

//-------------------------------------------------------------------------

void ParticleEffectUI::SaveConfirmationDone(StandardButton result)

{

        if (result == Ok)

                editor_->Save();

        delete messageBox_;

        messageBox_ = 0;

}

//-------------------------------------------------------------------------

WTreeNode* ParticleEffectUI::AddTreeNode (const char* nodeName)

{

        WIconPair *modelIcon = new WIconPair("resources/icons/b-2-icon.png", "resources/icons/b-2-icon.png", false);

        WTreeNode* modelNode = new WTreeNode(nodeName, modelIcon);

        modelNode->setSelectable(false);

        modelTree_->treeRoot()->addChildNode(modelNode);

        return modelNode;

}

//-------------------------------------------------------------------------

WTreeNode* ParticleEffectUI::AddTreeNode (WTreeNode* father, const char* nodeName, bool isSelectable /*=false*/)

{

        WTreeNode* node = new WTreeNode(nodeName);

        node->setSelectable(isSelectable);

        father->addChildNode(node);

        return node;

}

//-------------------------------------------------------------------------

WTreeNode* ParticleEffectUI::CreateTreeNode(WTreeNode* father, const ParticleEmitterModelPtr& emitterModel )

{

        WTreeNode* node = new WTreeNode( emitterModel->GetName() );

        node->selected().connect(this, &ParticleEffectUI::NodeSelectionChanged);

        mouseUpMapper_->mapConnect1(node->label()->mouseWentUp(), node);

        node->label()->setAttributeValue("oncontextmenu", "event.cancelBubble = true; event.returnValue = false; return false;");

        unsigned int count = emitterModel->GetChildrenCount();

        for (unsigned int i(0); i<count; i++)

        {

                CreateTreeNode( node, emitterModel->GetChild(i) );

        }

        father->addChildNode( node );

        return node;

}

//-------------------------------------------------------------------------

void ParticleEffectUI::ExpandTree ()

{

        modelTree_->treeRoot()->expand();

}

//-------------------------------------------------------------------------

void ParticleEffectUI::PopupAction(int item) 

{

        popup_->hide();

        if (popup_->result() == NULL) return;

        switch (item)

        {

        case POPUP_RENAME:

                {

                        renameEdit_->setText(currentSelectedNode_->label()->text().toUTF8());

                        renameDialog_->show();

                }

                break;

        case POPUP_DELETE:

                {

                        std::string message = "Delete " + currentSelectedNode_->label()->text().toUTF8() + " ?";

                        messageBox_ = new WMessageBox("Delete Confirmation", message.c_str(), Wt::NoIcon, Wt::Ok | Wt::Cancel);

                        messageBox_->textWidget()->setWordWrap(false);

                        messageBox_->buttonClicked().connect(this, &ParticleEffectUI::DeleteConfirmationDone);

                        messageBox_->show();

                }

                break;

        }

}

//-------------------------------------------------------------------------

void ParticleEffectUI::DeleteConfirmationDone(StandardButton result) 

{

        if (result == Ok)

        {

                bool deleted = DeleteEmitterModel(currentSelectedNode_->label()->text().toUTF8().c_str());

                if (deleted)

                {

                        WTreeNode* parentNode = currentSelectedNode_->parentNode();

                        parentNode->removeChildNode(currentSelectedNode_);

                        dynamicView_->setCurrentIndex(0);

                }

        }

        delete messageBox_;

        messageBox_ = 0;

}