alex
/
moonfall
1
Fork 0
Code Releases Activity
moonfall/FrameMapEditor.cpp

592 lines
23 KiB
C++
Raw Permalink Blame History

/*
Moonfall Copyright (C) 2008 Alex Yatskov
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "Pch.h"
#include "FrameMapEditor.h"
#include "Surface.h"
#include "Actor.h"
#include "ActorPropertyScript.h"
BEGIN_EVENT_TABLE(FrameMapEditor, wxFrame)
EVT_CLOSE( FrameMapEditor::OnClose)
EVT_SHOW( FrameMapEditor::OnShow)
EVT_MENU(ID_MENU_FILE_NEW, FrameMapEditor::OnMenuSelectedFileNew)
EVT_MENU(ID_MENU_FILE_OPEN, FrameMapEditor::OnMenuSelectedFileOpen)
EVT_MENU(ID_MENU_FILE_SAVE, FrameMapEditor::OnMenuSelectedFileSave)
EVT_MENU(ID_MENU_FILE_SAVE_AS, FrameMapEditor::OnMenuSelectedFileSaveAs)
EVT_MENU(ID_MENU_FILE_EXIT, FrameMapEditor::OnMenuSelectedFileExit)
EVT_MENU(ID_MENU_VIEW_GRID_DOUBLE, FrameMapEditor::OnMenuSelectedViewGridDouble)
EVT_MENU(ID_MENU_VIEW_GRID_HALVE, FrameMapEditor::OnMenuSelectedViewGridHalve)
EVT_MENU(ID_MENU_VIEW_GRID_CUSTOM, FrameMapEditor::OnMenuSelectedViewGridCustom)
EVT_TEXT_ENTER(ID_WORLD_SCRIPT, FrameMapEditor::OnModifiedUiWorld)
EVT_BUTTON(ID_WORLD_SCRIPT_BROWSE, FrameMapEditor::OnButtonClickedWorldScriptBrowse)
EVT_TEXT_ENTER(ID_WORLD_BACKDROP, FrameMapEditor::OnModifiedUiWorld)
EVT_BUTTON(ID_WORLD_BACKDROP_BROWSE, FrameMapEditor::OnButtonClickedWorldBackdropBrowse)
EVT_TEXT_ENTER(ID_SELECTION_NAME, FrameMapEditor::OnModifiedUiSelection)
EVT_TEXT_ENTER(ID_SELECTION_POSITION_X, FrameMapEditor::OnModifiedUiSelection)
EVT_TEXT_ENTER(ID_SELECTION_POSITION_Y, FrameMapEditor::OnModifiedUiSelection)
EVT_BUTTON(ID_SELECTION_PREVIEW, FrameMapEditor::OnButtonClickedSelectionPreview)
EVT_TEXT_ENTER(ID_SELECTION_PARAMS, FrameMapEditor::OnTextChangeScriptParams)
EVT_TEXT_ENTER(ID_PALETTE_FILTER, FrameMapEditor::OnModifiedUiPalette)
END_EVENT_TABLE()
FrameMapEditor::FrameMapEditor(wxWindow* parent) :
wxFrame(parent, wxID_ANY, wxT("Map Editor"), wxDefaultPosition, wxSize(500, 800), wxDEFAULT_FRAME_STYLE),
m_worldGridSize(32),
m_textWorldScript(NULL),
m_textWorldBackdrop(NULL),
m_listPalette(NULL),
m_textPaletteFilter(NULL),
m_notebookSelection(NULL),
m_panelSelectionGeneral(NULL),
m_scrollWinSelectionScript(NULL),
m_textSelectionName(NULL),
m_textSelectionPositionX(NULL),
m_textSelectionPositionY(NULL),
m_buttonSelectionPreview(NULL)
{
wxBoxSizer* sizerMain = new wxBoxSizer(wxVERTICAL);
sizerMain->Add(InitializeUiWorld(), 0, wxALL | wxEXPAND, 5);
sizerMain->Add(InitializeUiPalette(), 1, wxALL | wxEXPAND, 5);
sizerMain->Add(InitializeUiSelection(), 0, wxALL | wxEXPAND, 5);
SetSizer(sizerMain);
InitializeUiMenuBar();
}
void FrameMapEditor::InitializeUiMenuBar()
{
wxMenu* menuFile = new wxMenu();
menuFile->Append(ID_MENU_FILE_NEW, wxT("&New\tCtrl+N"));
menuFile->Append(ID_MENU_FILE_OPEN, wxT("&Open\tCtrl+O"));
menuFile->Append(ID_MENU_FILE_SAVE, wxT("&Save\tCtrl+S"));
menuFile->Append(ID_MENU_FILE_SAVE_AS, wxT("Save &As...\tCtrl+Shift+S"));
menuFile->AppendSeparator();
menuFile->Append(ID_MENU_FILE_EXIT, wxT("E&xit\tCtrl+Q"));
wxMenu* menuViewGrid = new wxMenu();
menuViewGrid->Append(ID_MENU_VIEW_GRID_HALVE, wxT("&Halve\tCtrl+H"));
menuViewGrid->Append(ID_MENU_VIEW_GRID_DOUBLE, wxT("&Double\tCtrl+D"));
menuViewGrid->AppendSeparator();
menuViewGrid->Append(ID_MENU_VIEW_GRID_CUSTOM, wxT("&Custom...\tCtrl+G"));
wxMenu* menuView = new wxMenu();
menuView->Append(-1, wxT("&Grid"), menuViewGrid);
wxMenuBar* menuBar = new wxMenuBar();
menuBar->Append(menuFile, wxT("&File"));
menuBar->Append(menuView, wxT("&View"));
SetMenuBar(menuBar);
}
wxSizer* FrameMapEditor::InitializeUiWorld()
{
wxBoxSizer* sizerWorldScript = new wxBoxSizer(wxHORIZONTAL);
sizerWorldScript->Add(new wxStaticText(this, wxID_ANY, wxT("Script")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerWorldScript->Add(m_textWorldScript = new wxTextCtrl(this, ID_WORLD_SCRIPT, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), 1, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerWorldScript->Add(new wxButton(this, ID_WORLD_SCRIPT_BROWSE, wxT("&Browse...")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxBoxSizer* sizerWorldBackdrop = new wxBoxSizer(wxHORIZONTAL);
sizerWorldBackdrop->Add(new wxStaticText(this, wxID_ANY, wxT("Backdrop")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerWorldBackdrop->Add(m_textWorldBackdrop = new wxTextCtrl(this, ID_WORLD_BACKDROP, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), 1, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerWorldBackdrop->Add(new wxButton(this, ID_WORLD_BACKDROP_BROWSE, wxT("&Browse...")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxStaticBoxSizer* sizerWorld = new wxStaticBoxSizer(new wxStaticBox(this, wxID_ANY, wxT("World")), wxVERTICAL);
sizerWorld->Add(sizerWorldScript, 0, wxEXPAND, 5);
sizerWorld->Add(sizerWorldBackdrop, 0, wxEXPAND, 5);
return sizerWorld;
}
wxSizer* FrameMapEditor::InitializeUiPalette()
{
wxBoxSizer* sizerPaletteSettings = new wxBoxSizer(wxHORIZONTAL);
sizerPaletteSettings->Add(new wxStaticText(this, wxID_ANY, wxT("Alias filter")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerPaletteSettings->Add(m_textPaletteFilter = new wxTextCtrl(this, ID_PALETTE_FILTER, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), 1, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxStaticBoxSizer* sizerPalette = new wxStaticBoxSizer(new wxStaticBox(this, wxID_ANY, wxT("Palette")), wxVERTICAL);
m_listPalette = new wxListCtrl(this, ID_PALETTE_LIST, wxDefaultPosition, wxDefaultSize, wxLC_ICON | wxLC_SINGLE_SEL);
m_listPalette->SetForegroundColour(wxColour(0xff, 0xff, 0xff));
m_listPalette->SetBackgroundColour(wxColour(0x00, 0x00, 0x00));
sizerPalette->Add(m_listPalette, 1, wxALL | wxEXPAND, 5);
sizerPalette->Add(sizerPaletteSettings, 0, wxEXPAND, 5);
return sizerPalette;
}
wxSizer* FrameMapEditor::InitializeUiSelection()
{
m_notebookSelection = new wxNotebook( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxNB_BOTTOM);
m_panelSelectionGeneral = new wxPanel(m_notebookSelection, wxID_ANY);
wxBoxSizer* sizerSelectionSettingsName = new wxBoxSizer(wxHORIZONTAL);
sizerSelectionSettingsName->Add(new wxStaticText(m_panelSelectionGeneral, wxID_ANY, wxT("Name")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerSelectionSettingsName->Add(m_textSelectionName = new wxTextCtrl(m_panelSelectionGeneral, ID_SELECTION_NAME, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), 1, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxStaticBoxSizer* sizerSelectionSettingsPosition = new wxStaticBoxSizer(new wxStaticBox( m_panelSelectionGeneral, wxID_ANY, wxT("Position")), wxHORIZONTAL);
sizerSelectionSettingsPosition->Add(new wxStaticText(m_panelSelectionGeneral, wxID_ANY, wxT("x")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerSelectionSettingsPosition->Add(m_textSelectionPositionX = new wxTextCtrl(m_panelSelectionGeneral, ID_SELECTION_POSITION_X, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), 1, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerSelectionSettingsPosition->Add(new wxStaticText(m_panelSelectionGeneral, wxID_ANY, wxT("y")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
sizerSelectionSettingsPosition->Add(m_textSelectionPositionY = new wxTextCtrl(m_panelSelectionGeneral, ID_SELECTION_POSITION_Y, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER), 1, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxBoxSizer* sizerSelectionSettings = new wxBoxSizer(wxVERTICAL);
sizerSelectionSettings->Add(sizerSelectionSettingsName, 0, wxEXPAND, 5);
sizerSelectionSettings->Add(sizerSelectionSettingsPosition, 0, wxALL | wxEXPAND, 5);
wxBoxSizer* sizerSelectionSettingsPreview = new wxBoxSizer(wxHORIZONTAL);
sizerSelectionSettingsPreview->Add(sizerSelectionSettings, 1, wxEXPAND, 5);
sizerSelectionSettingsPreview->Add(m_buttonSelectionPreview = new wxBitmapButton(m_panelSelectionGeneral, ID_SELECTION_PREVIEW, wxNullBitmap, wxDefaultPosition, wxSize(96, 96)), 0, wxALL, 5);
m_scrollWinSelectionScript = new wxScrolledWindow(m_notebookSelection);
m_scrollWinSelectionScript->SetScrollRate(5, 5);
m_panelSelectionGeneral->SetSizer(sizerSelectionSettingsPreview);
m_notebookSelection->AddPage(m_panelSelectionGeneral, wxT("General"), true);
m_notebookSelection->AddPage(m_scrollWinSelectionScript, wxT("Script"), false);
wxStaticBoxSizer* sizerSelection = new wxStaticBoxSizer(new wxStaticBox(this, wxID_ANY, wxT("Selection")), wxVERTICAL);
sizerSelection->Add(m_notebookSelection, 1, wxEXPAND | wxALL, 5);
return sizerSelection;
}
void FrameMapEditor::UpdateUiWorld()
{
m_textWorldBackdrop->SetValue(wxString::FromAscii(System::QueryWorldContext()->GetBackdropSpriteAlias()));
m_textWorldScript->SetValue(wxString::FromAscii(System::QueryWorldContext()->GetScriptAlias()));
}
void FrameMapEditor::UpdateUiPalette()
{
wxImage bitmapMissing = wxArtProvider::GetBitmap(wxART_MISSING_IMAGE).ConvertToImage();
Vector2i targetSize(bitmapMissing.GetWidth(), bitmapMissing.GetHeight());
for (std::vector<ActorSummary>::iterator iter = m_actorSummary.begin(); iter != m_actorSummary.end(); ++iter)
{
if (iter->thumbnail)
{
targetSize.x = MAX(targetSize.x, iter->thumbnail->GetSize().x);
targetSize.y = MAX(targetSize.y, iter->thumbnail->GetSize().y);
}
}
std::vector<ActorSummary> actorSummaryFiltered;
wxImageList* actorThumbnails = new wxImageList(targetSize.x, targetSize.y, true, m_actorSummary.size());
const wxString actorAliasFilter = m_textPaletteFilter->GetValue();
for (std::vector<ActorSummary>::iterator iter = m_actorSummary.begin(); iter != m_actorSummary.end(); ++iter)
{
const wxString actorAlias(wxString::FromAscii(iter->alias.c_str()));
if (actorAliasFilter.IsEmpty() || actorAlias.Lower().Contains(actorAliasFilter.Lower()))
{
wxBitmap actorThumbnail = wxNullBitmap;
if (iter->thumbnail)
{
iter->thumbnail->Lock();
byte* const data = static_cast<byte*>(iter->thumbnail->GetData());
wxImage image(iter->thumbnail->GetSize().x, iter->thumbnail->GetSize().y, data, true);
image.Resize(wxSize(targetSize.x, targetSize.y), wxPoint());
actorThumbnail = wxBitmap(image);
iter->thumbnail->Unlock();
}
actorThumbnails->Add(actorThumbnail.IsOk() ? actorThumbnail : bitmapMissing);
actorSummaryFiltered.push_back(*iter);
}
}
m_listPalette->ClearAll();
m_listPalette->AssignImageList(actorThumbnails, wxIMAGE_LIST_NORMAL);
for (size_t i = 0; i < actorSummaryFiltered.size(); ++i)
{
m_listPalette->InsertItem(actorSummaryFiltered.size(), wxString::FromAscii(actorSummaryFiltered[i].alias.c_str()), i);
}
}
void FrameMapEditor::UpdateUiSelection()
{
boost::shared_ptr<Actor> actorSelection = m_actorSelection.lock();
m_notebookSelection->Enable(actorSelection);
m_scrollWinSelectionScript->DestroyChildren();
if (!actorSelection)
{
return;
}
m_textSelectionName->SetValue(wxString::FromAscii(actorSelection->GetName()));
m_textSelectionPositionX->SetValue(wxString::Format(wxT("%d"), actorSelection->GetPosition().x));
m_textSelectionPositionY->SetValue(wxString::Format(wxT("%d"), actorSelection->GetPosition().y));
boost::shared_ptr<ActorPropertyScript> propertyScript = actorSelection->GetProperty<ActorPropertyScript>().lock();
if (propertyScript)
{
std::vector<std::string> scriptParameters;
propertyScript->EnumerateParameters(&scriptParameters);
wxBoxSizer* sizerScript = new wxBoxSizer(wxVERTICAL);
for (size_t i = 0; i < scriptParameters.size(); ++i)
{
wxBoxSizer* sizerParameter = new wxBoxSizer(wxHORIZONTAL);
const char* name = scriptParameters[i].c_str();
wxStaticText* textLabel = new wxStaticText(m_scrollWinSelectionScript, wxID_ANY, wxString::FromAscii(name), wxDefaultPosition, wxSize(75,-1));
sizerParameter->Add(textLabel, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);
ScriptParameter parameter;
if (propertyScript->GetParameter(name, &parameter))
{
wxTextCtrl* textCtrlValue = new wxTextCtrl(
m_scrollWinSelectionScript,
ID_SELECTION_PARAMS,
wxString::FromAscii(parameter.value.c_str()),
wxDefaultPosition,
wxDefaultSize,
wxTE_PROCESS_ENTER,
wxDefaultValidator,
wxString::FromAscii(name)
);
sizerParameter->Add(textCtrlValue, 1, wxALIGN_CENTER_VERTICAL, 5);
}
sizerScript->Add(sizerParameter, 0, wxEXPAND, 5);
}
m_scrollWinSelectionScript->SetSizer(sizerScript);
m_scrollWinSelectionScript->Layout();
}
wxBitmap actorThumbnail = wxNullBitmap;
for (std::vector<ActorSummary>::iterator iter = m_actorSummary.begin(); iter != m_actorSummary.end(); ++iter)
{
if (iter->thumbnail && strcmp(actorSelection->GetAlias(), iter->alias.c_str()) == 0)
{
iter->thumbnail->Lock();
actorThumbnail = wxBitmap(wxImage(iter->thumbnail->GetSize().x, iter->thumbnail->GetSize().y, static_cast<byte*>(iter->thumbnail->GetData()), true));
iter->thumbnail->Unlock();
}
}
m_buttonSelectionPreview->SetBitmapLabel(actorThumbnail);
}
void FrameMapEditor::OnModifiedUiWorld(wxCommandEvent& event)
{
System::QueryWorldContext()->SetBackdropSpriteAlias(m_textWorldBackdrop->GetValue().ToAscii());
System::QueryWorldContext()->SetScriptAlias(m_textWorldScript->GetValue().ToAscii());
}
void FrameMapEditor::OnModifiedUiPalette(wxCommandEvent& event)
{
UpdateUiPalette();
}
void FrameMapEditor::OnModifiedUiSelection(wxCommandEvent& event)
{
boost::shared_ptr<Actor> actorSelection = m_actorSelection.lock();
if (!actorSelection)
{
return;
}
long actorPositionX = actorSelection->GetPosition().x;
m_textSelectionPositionX->GetValue().ToLong(&actorPositionX);
long actorPositionY = actorSelection->GetPosition().y;
m_textSelectionPositionY->GetValue().ToLong(&actorPositionY);
actorSelection->SetName(m_textSelectionName->GetValue().ToAscii());
actorSelection->SetPosition(Vector2i(actorPositionX, actorPositionY));
UpdateUiSelection();
}
void FrameMapEditor::OnWorldMouseMove(const InputMouse& args)
{
boost::shared_ptr<Actor> actorSelection = m_actorSelection.lock();
if (actorSelection && args.buttonState == SDL_BUTTON_LMASK)
{
actorSelection->SetPosition(SnapPointToGrid(args.position));
UpdateUiSelection();
}
if (args.buttonState == SDL_BUTTON_RMASK)
{
const Vector2i cameraPosition = System::QueryWorldContext()->GetCameraTarget();
System::QueryWorldContext()->SetCameraTarget(Vector2i(cameraPosition.x - args.delta.x, cameraPosition.y - args.delta.y));
}
}
void FrameMapEditor::OnWorldMouseButtonDown(const InputMouse& args)
{
boost::shared_ptr<Actor> actorSelection = System::QueryWorldContext()->PickActor(args.position).lock();
if (args.button == SDL_BUTTON_LEFT)
{
const int index = m_listPalette->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (args.modifier == KMOD_SHIFT && index != -1)
{
const std::string actorAlias(m_listPalette->GetItemText(index).ToAscii());
ActorSummary summary;
if (!actorSelection || (System::SummarizeActor(actorAlias.c_str(), &summary) && actorSelection->GetLayer() < summary.layer))
{
actorSelection = System::QueryWorldContext()->AddActor(actorAlias.c_str(), SnapPointToGrid(args.position)).lock();
}
}
if (args.modifier == KMOD_CTRL && actorSelection)
{
System::QueryWorldContext()->RemoveActor(actorSelection->GetId());
actorSelection.reset();
}
m_actorSelection = actorSelection;
UpdateUiSelection();
}
else if (args.button == SDL_BUTTON_RIGHT && actorSelection)
{
SelectPaletteAlias(actorSelection->GetAlias());
}
}
void FrameMapEditor::OnClose(wxCloseEvent&)
{
Hide();
}
void FrameMapEditor::OnShow(wxShowEvent& event)
{
if (event.GetShow())
{
if (m_actorSummary.size() == 0)
{
System::SummarizeActors(&m_actorSummary);
}
if (m_worldSummary.size() == 0)
{
System::SummarizeWorlds(&m_worldSummary);
}
System::QueryWorldContext()->AddListener(this);
UpdateUiWorld();
UpdateUiPalette();
UpdateUiSelection();
}
else if (System::QueryWorldContext() != NULL)
{
System::QueryWorldContext()->RemoveListener(this);
}
}
void FrameMapEditor::SelectPaletteAlias(const char* alias)
{
const int index = m_listPalette->FindItem(-1, wxString::FromAscii(alias));
if (index != -1)
{
const int listFlags = wxLIST_STATE_SELECTED;
m_listPalette->SetItemState(index, listFlags, listFlags);
m_listPalette->EnsureVisible(index);
}
else if (m_listPalette->GetItemCount() != static_cast<int>(m_actorSummary.size()))
{
m_textPaletteFilter->Clear();
UpdateUiPalette();
SelectPaletteAlias(alias);
}
}
Vector2i FrameMapEditor::SnapPointToGrid(const Vector2i& position) const
{
Vector2i gridPosition(position.x / m_worldGridSize, position.y / m_worldGridSize);
if (position.x < 0)
{
--gridPosition.x;
}
if (position.y < 0)
{
--gridPosition.y;
}
return Vector2i(gridPosition.x * m_worldGridSize, gridPosition.y * m_worldGridSize);
}
void FrameMapEditor::BuildWorldAliasList(wxArrayString* aliasList) const
{
for (std::vector<WorldSummary>::const_iterator iter = m_worldSummary.begin(); iter != m_worldSummary.end(); ++iter)
{
aliasList->Add(wxString::FromAscii(iter->alias.c_str()));
}
}
void FrameMapEditor::OnMenuSelectedFileNew(wxCommandEvent& event)
{
System::QueryWorldContext()->ClearActors();
}
void FrameMapEditor::OnMenuSelectedFileOpen(wxCommandEvent& event)
{
wxArrayString worldNames;
BuildWorldAliasList(&worldNames);
wxSingleChoiceDialog dialog(this, wxT("Select a world to load"), wxT("Load world"), worldNames);
if (dialog.ShowModal() == wxID_OK)
{
System::QueryWorldContext()->LoadWorld(dialog.GetStringSelection().ToAscii());
UpdateUiWorld();
UpdateUiSelection();
}
}
void FrameMapEditor::OnMenuSelectedFileSave(wxCommandEvent& event)
{
const char* worldAlias = System::QueryWorldContext()->GetWorldAlias();
if (worldAlias == NULL)
{
OnMenuSelectedFileSaveAs(event);
}
else
{
System::QueryWorldContext()->SaveWorld(worldAlias);
}
}
void FrameMapEditor::OnMenuSelectedFileSaveAs(wxCommandEvent& event)
{
wxArrayString worldNames;
BuildWorldAliasList(&worldNames);
wxSingleChoiceDialog dialog(this, wxT("Select a world to save"), wxT("Save world"), worldNames);
if (dialog.ShowModal() == wxID_OK)
{
System::QueryWorldContext()->SaveWorld(dialog.GetStringSelection().ToAscii());
}
}
void FrameMapEditor::OnMenuSelectedFileExit(wxCommandEvent& event)
{
Hide();
}
void FrameMapEditor::OnMenuSelectedViewGridHalve(wxCommandEvent& event)
{
if (m_worldGridSize >= 2)
{
m_worldGridSize >>= 1;
}
}
void FrameMapEditor::OnMenuSelectedViewGridDouble(wxCommandEvent& event)
{
if (m_worldGridSize <= 1024)
{
m_worldGridSize <<= 1;
}
}
void FrameMapEditor::OnMenuSelectedViewGridCustom(wxCommandEvent& event)
{
wxTextEntryDialog dialog(this, wxT("Specify a world grid size"), wxT("World grid size"), wxString::Format(wxT("%d"), m_worldGridSize));
if (dialog.ShowModal() != wxID_OK)
{
return;
}
long worldGridSize = m_worldGridSize;
if (dialog.GetValue().ToLong(&worldGridSize) && worldGridSize >= 1 && worldGridSize <= 1024)
{
m_worldGridSize = worldGridSize;
}
}
void FrameMapEditor::OnButtonClickedSelectionPreview(wxCommandEvent& event)
{
const boost::shared_ptr<Actor> actorSelection = m_actorSelection.lock();
if (actorSelection)
{
SelectPaletteAlias(actorSelection->GetAlias());
}
}
void FrameMapEditor::OnTextChangeScriptParams(wxCommandEvent& event)
{
boost::shared_ptr<Actor> actorSelection = m_actorSelection.lock();
if (!actorSelection)
{
return;
}
boost::shared_ptr<ActorPropertyScript> propertyScript = actorSelection->GetProperty<ActorPropertyScript>().lock();
if (!propertyScript)
{
return;
}
wxTextCtrl* selectedTextCtrl = static_cast<wxTextCtrl*>(m_scrollWinSelectionScript->FindFocus());
const std::string name(selectedTextCtrl->GetName().ToAscii());
const std::string value(selectedTextCtrl->GetValue().ToAscii());
ScriptParameter parameter;
if (!propertyScript->GetParameter(name.c_str(), &parameter))
{
return;
}
propertyScript->SetParameter(name.c_str(), ScriptParameter(value.c_str(), parameter.type));
propertyScript->ResetScriptState();
}
void FrameMapEditor::OnButtonClickedWorldScriptBrowse(wxCommandEvent& event)
{
std::vector<ScriptSummary> summary;
System::SummarizeScripts(&summary);
wxArrayString scriptNames;
for (std::vector<ScriptSummary>::iterator iter = summary.begin(); iter != summary.end(); ++iter)
{
scriptNames.Add(wxString::FromAscii(iter->alias.c_str()));
}
wxSingleChoiceDialog dialog(this, wxT("Select a script"), wxT("Load script"), scriptNames);
if (dialog.ShowModal() == wxID_OK)
{
System::QueryWorldContext()->SetScriptAlias(dialog.GetStringSelection().ToAscii());
UpdateUiWorld();
}
}
void FrameMapEditor::OnButtonClickedWorldBackdropBrowse(wxCommandEvent& event)
{
std::vector<SpriteSummary> summary;
System::SummarizeSprites(&summary);
wxArrayString spriteNames;
for (std::vector<SpriteSummary>::iterator iter = summary.begin(); iter != summary.end(); ++iter)
{
spriteNames.Add(wxString::FromAscii(iter->alias.c_str()));
}
wxSingleChoiceDialog dialog(this, wxT("Select a sprite"), wxT("Load sprite"), spriteNames);
if (dialog.ShowModal() == wxID_OK)
{
System::QueryWorldContext()->SetBackdropSpriteAlias(dialog.GetStringSelection().ToAscii());
UpdateUiWorld();
}
}
View Git Blame Copy Permalink