wxChoice* PreferencesWindow::AddPaletteStyleChoice(wxWindow* parent, wxSizer* sizer, const wxString& short_description, const wxString& description, const std::string& setting)
{
wxStaticText* text;
sizer->Add(text = newd wxStaticText(parent, wxID_ANY, short_description), 0);
wxChoice* choice = newd wxChoice(parent, wxID_ANY);
sizer->Add(choice, 0);
choice->Append("Large Icons");
choice->Append("Small Icons");
choice->Append("Listbox with Icons");
text->SetToolTip(description);
choice->SetToolTip(description);
if(setting == "large icons") {
choice->SetSelection(0);
} else if(setting == "small icons") {
choice->SetSelection(1);
} else if(setting == "listbox") {
choice->SetSelection(2);
}
return choice;
}
//---------------------------------------------------------------------------------------
void WizardDevicesPage::CreateControls()
{
wxBoxSizer* itemBoxSizer3 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
SetSizer(itemBoxSizer3);
wxBoxSizer* itemBoxSizer4 = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
itemBoxSizer3->Add(itemBoxSizer4, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxStaticText* itemStaticText5 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Midi devices to use"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticText5->SetFont(wxFont(14, wxSWISS, wxNORMAL, wxBOLD, false, "Arial"));
itemBoxSizer4->Add(itemStaticText5, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);
wxBoxSizer* itemBoxSizer6 = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
itemBoxSizer3->Add(itemBoxSizer6, 1, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer7 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer6->Add(itemBoxSizer7, 1, wxGROW|wxALL, 5);
wxStaticText* itemStaticText8 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("To generate sounds the program needs a MIDI synthesizer device. Normally, one of these devices is included in the sound board of the PC, but your PC might have more than one."), wxDefaultPosition, wxSize(250, -1), 0 );
itemBoxSizer7->Add(itemStaticText8, 1, wxGROW|wxALL|wxADJUST_MINSIZE, 5);
wxStaticText* itemStaticText9 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("If your PC has more than one device, choose one of them. You can test all of them and choose the one whose sound you prefer."), wxDefaultPosition, wxSize(250, -1), 0 );
itemBoxSizer7->Add(itemStaticText9, 1, wxGROW|wxALL|wxADJUST_MINSIZE, 5);
wxStaticLine* itemStaticLine10 = LENMUS_NEW wxStaticLine( this, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
itemBoxSizer6->Add(itemStaticLine10, 0, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer11 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer6->Add(itemBoxSizer11, 1, wxGROW|wxALL, 5);
wxStaticText* itemStaticText12 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Output device:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer11->Add(itemStaticText12, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pOutComboStrings = NULL;
m_pOutCombo = LENMUS_NEW wxComboBox( this, ID_COMBO_OUT_DEVICES, "", wxDefaultPosition, wxSize(250, -1), 0, m_pOutComboStrings, wxCB_READONLY );
itemBoxSizer11->Add(m_pOutCombo, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
//TODO: Un-comment when ready to use MIDI input
//wxStaticText* itemStaticText14 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Input device:"), wxDefaultPosition, wxDefaultSize, 0 );
//itemBoxSizer11->Add(itemStaticText14, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
//TODO: Un-comment when ready to use MIDI input
//wxString* m_pInComboStrings = NULL;
//m_pInCombo = LENMUS_NEW wxComboBox( this, ID_COMBO_IN_DEVICES, "", wxDefaultPosition, wxSize(250, -1), 0, m_pInComboStrings, wxCB_READONLY );
//itemBoxSizer11->Add(m_pInCombo, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
}
//---------------------------------------------------------------------------------------
void LangOptionsPanel::create_controls()
{
//content generated with wxFormBuilder
this->SetExtraStyle( wxWS_EX_BLOCK_EVENTS );
wxBoxSizer* pMainSizer;
pMainSizer = LENMUS_NEW wxBoxSizer( wxVERTICAL );
m_pTitlePannel = LENMUS_NEW wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxRAISED_BORDER|wxTAB_TRAVERSAL );
wxBoxSizer* pTitleSizer;
pTitleSizer = LENMUS_NEW wxBoxSizer( wxHORIZONTAL );
m_pTitle = LENMUS_NEW wxStaticText( m_pTitlePannel, wxID_ANY, _("Language preferences"), wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
m_pTitle->Wrap( -1 );
m_pTitle->SetFont( wxFont( 8, 74, 90, 92, false, "Tahoma" ) );
pTitleSizer->Add( m_pTitle, 0, wxALIGN_TOP|wxALL|wxADJUST_MINSIZE, 5 );
pTitleSizer->Add( 5, 5, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
m_pTitleIcon = LENMUS_NEW wxStaticBitmap( m_pTitlePannel, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );
pTitleSizer->Add( m_pTitleIcon, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
m_pTitlePannel->SetSizer( pTitleSizer );
m_pTitlePannel->Layout();
pTitleSizer->Fit( m_pTitlePannel );
pMainSizer->Add( m_pTitlePannel, 0, wxEXPAND|wxBOTTOM, 5 );
wxBoxSizer* pLangSizer;
pLangSizer = LENMUS_NEW wxBoxSizer( wxHORIZONTAL );
m_pLang = LENMUS_NEW wxStaticText( this, wxID_ANY, _("Choose language to use:"), wxDefaultPosition, wxDefaultSize, 0 );
m_pLang->Wrap( -1 );
pLangSizer->Add( m_pLang, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5 );
wxArrayString m_pChoiceChoices;
m_pChoice = LENMUS_NEW wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, m_pChoiceChoices, 0 );
m_pChoice->SetSelection( 0 );
pLangSizer->Add( m_pChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
pMainSizer->Add( pLangSizer, 0, wxEXPAND|wxALL, 5 );
this->SetSizer( pMainSizer );
this->Layout();
}
wxNotebookPage* PreferencesWindow::CreateGeneralPage() {
wxNotebookPage* general_page = newd wxPanel(book, wxID_ANY);
wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
wxStaticText* tmptext;
sizer->Add(always_make_backup_chkbox = newd wxCheckBox(general_page, wxID_ANY, wxT("Always make map backup")));
always_make_backup_chkbox->SetValue(settings.getInteger(Config::ALWAYS_MAKE_BACKUP) == 1);
sizer->Add(create_on_startup_chkbox = newd wxCheckBox(general_page, wxID_ANY, wxT("Create map on startup")));
create_on_startup_chkbox->SetValue(settings.getInteger(Config::CREATE_MAP_ON_STARTUP) == 1);
sizer->Add(update_check_on_startup_chkbox = newd wxCheckBox(general_page, wxID_ANY, wxT("Check for updates on startup")));
update_check_on_startup_chkbox->SetValue(settings.getInteger(Config::USE_UPDATER) == 1);
sizer->Add(only_one_instance_chkbox = newd wxCheckBox(general_page, wxID_ANY, wxT("Open all maps in the same instance")));
only_one_instance_chkbox->SetValue(settings.getInteger(Config::ONLY_ONE_INSTANCE) == 1);
only_one_instance_chkbox->SetToolTip(wxT("When checked, maps opened using the shell will all be opened in the same instance."));
wxFlexGridSizer* grid_sizer = newd wxFlexGridSizer(2, 10, 10);
grid_sizer->AddGrowableCol(1);
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, wxT("Undo queue size: ")), 0);
undo_size_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(settings.getInteger(Config::UNDO_SIZE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 0x10000000);
grid_sizer->Add(undo_size_spin, 0);
SetWindowToolTip(tmptext, undo_size_spin, wxT("How many action you can undo, be aware that a high value will increase memory usage."));
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, wxT("Undo maximum memory size (MB): ")), 0);
undo_mem_size_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(settings.getInteger(Config::UNDO_MEM_SIZE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 4096);
grid_sizer->Add(undo_mem_size_spin, 0);
SetWindowToolTip(tmptext, undo_mem_size_spin, wxT("The approximite limit for the memory usage of the undo queue."));
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, wxT("Worker Threads: ")), 0);
worker_threads_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(settings.getInteger(Config::WORKER_THREADS)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 1, 64);
grid_sizer->Add(worker_threads_spin, 0);
SetWindowToolTip(tmptext, worker_threads_spin, wxT("How many threads the editor will use for intensive operations. This should be equivalent to the amount of logical processors in your system."));
sizer->Add(20,10);
sizer->Add(grid_sizer);
general_page->SetSizerAndFit(sizer);
return general_page;
}
BrowseTileWindow::BrowseTileWindow(wxWindow* parent, const Map* map, Tile* tile, wxPoint position /* = wxDefaultPosition */) :
wxDialog(parent, wxID_ANY, "Browse Field", position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER)
{
wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
item_list = newd BrowseTileListBox(this, wxID_ANY, tile);
sizer->Add(item_list, wxSizerFlags(1).Expand());
wxString pos;
pos << wxT("x=") << tile->getX() << wxT(", y=") << tile->getY() << wxT(", z=") << tile->getZ();
wxSizer* infoSizer = newd wxBoxSizer(wxVERTICAL);
infoSizer->Add(newd wxButton(this, wxID_REMOVE, wxT("Delete")), wxSizerFlags(0).Left());
infoSizer->AddSpacer(5);
infoSizer->Add(newd wxStaticText(this, wxID_ANY, wxT("Position: ") + pos), wxSizerFlags(0).Left());
infoSizer->Add(item_count_txt = newd wxStaticText(this, wxID_ANY, wxT("Item count: ") + i2ws(item_list->GetItemCount())), wxSizerFlags(0).Left());
infoSizer->Add(newd wxStaticText(this, wxID_ANY, wxT("Protection zone: ") + b2yn(tile->isPZ())), wxSizerFlags(0).Left());
infoSizer->Add(newd wxStaticText(this, wxID_ANY, wxT("No PvP: ") + b2yn(tile->getMapFlags() & TILESTATE_NOPVP)), wxSizerFlags(0).Left());
infoSizer->Add(newd wxStaticText(this, wxID_ANY, wxT("No logout: ") + b2yn(tile->getMapFlags() & TILESTATE_NOLOGOUT)), wxSizerFlags(0).Left());
infoSizer->Add(newd wxStaticText(this, wxID_ANY, wxT("PvP zone: ") + b2yn(tile->getMapFlags() & TILESTATE_PVPZONE)), wxSizerFlags(0).Left());
infoSizer->Add(newd wxStaticText(this, wxID_ANY, wxT("House: ") + b2yn(tile->isHouseTile())), wxSizerFlags(0).Left());
sizer->Add(infoSizer, wxSizerFlags(0).Left().DoubleBorder());
// OK/Cancel buttons
wxSizer* btnSizer = newd wxBoxSizer(wxHORIZONTAL);
btnSizer->Add(newd wxButton(this, wxID_OK, wxT("OK")), wxSizerFlags(0).Center());
btnSizer->Add(newd wxButton(this, wxID_CANCEL, wxT("Cancel")), wxSizerFlags(0).Center());
sizer->Add(btnSizer, wxSizerFlags(0).Center().DoubleBorder());
SetSizerAndFit(sizer);
}
wxWindow* PropertiesWindow::createGeneralPanel(wxWindow* parent)
{
wxPanel* panel = newd wxPanel(parent, ITEM_PROPERTIES_GENERAL_TAB);
wxFlexGridSizer* gridsizer = newd wxFlexGridSizer(2, 10, 10);
gridsizer->AddGrowableCol(1);
gridsizer->Add(newd wxStaticText(panel, wxID_ANY, "ID " + i2ws(edit_item->getID())));
gridsizer->Add(newd wxStaticText(panel, wxID_ANY, "\"" + wxstr(edit_item->getName()) + "\""));
gridsizer->Add(newd wxStaticText(panel, wxID_ANY, "Action ID"));
wxSpinCtrl* action_id_field = newd wxSpinCtrl(panel, wxID_ANY, i2ws(edit_item->getActionID()), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 0xFFFF, edit_item->getActionID());
gridsizer->Add(action_id_field, wxSizerFlags(1).Expand());
gridsizer->Add(newd wxStaticText(panel, wxID_ANY, "Unique ID"));
wxSpinCtrl* unique_id_field = newd wxSpinCtrl(panel, wxID_ANY, i2ws(edit_item->getUniqueID()), wxDefaultPosition, wxSize(-1, 20), wxSP_ARROW_KEYS, 0, 0xFFFF, edit_item->getUniqueID());
gridsizer->Add(unique_id_field, wxSizerFlags(1).Expand());
panel->SetSizerAndFit(gridsizer);
return panel;
}
//---------------------------------------------------------------------------------------
void WizardMetronomePage::CreateControls()
{
wxBoxSizer* itemBoxSizer35 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
SetSizer(itemBoxSizer35);
wxBoxSizer* itemBoxSizer36 = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
itemBoxSizer35->Add(itemBoxSizer36, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxStaticText* itemStaticText37 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Metronome channel and sounds"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticText37->SetFont(wxFont(14, wxSWISS, wxNORMAL, wxBOLD, false, "Arial"));
itemBoxSizer36->Add(itemStaticText37, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);
wxBoxSizer* itemBoxSizer38 = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
itemBoxSizer35->Add(itemBoxSizer38, 1, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer39 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer38->Add(itemBoxSizer39, 1, wxGROW|wxALL, 5);
wxStaticText* itemStaticText40 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Channels 10 and 16 are specialized in percussion sounds. So it is recommended to choose one of these (it doesn't matter wich one)."), wxDefaultPosition, wxSize(250, -1), 0 );
itemBoxSizer39->Add(itemStaticText40, 1, wxGROW|wxALL|wxADJUST_MINSIZE, 5);
wxStaticText* itemStaticText41 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("To better identify the first beat of each measure it is possible to assign a different sound to it. But you can also choose the same sound for both, the first beat and the others."), wxDefaultPosition, wxSize(250, -1), 0 );
itemBoxSizer39->Add(itemStaticText41, 1, wxGROW|wxALL|wxADJUST_MINSIZE, 5);
wxStaticLine* itemStaticLine42 = LENMUS_NEW wxStaticLine( this, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
itemBoxSizer38->Add(itemStaticLine42, 0, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer43 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer38->Add(itemBoxSizer43, 1, wxGROW|wxALL, 5);
wxStaticText* itemStaticText44 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Channel:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer43->Add(itemStaticText44, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pMtrChannelComboStrings = NULL;
m_pMtrChannelCombo = LENMUS_NEW wxComboBox( this, ID_COMBO_MTR_CHANNEL, "", wxDefaultPosition, wxSize(70, -1), 0, m_pMtrChannelComboStrings, wxCB_READONLY );
itemBoxSizer43->Add(m_pMtrChannelCombo, 0, wxALIGN_LEFT|wxALL, 5);
wxBoxSizer* itemBoxSizer46 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer43->Add(itemBoxSizer46, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxStaticText* itemStaticText47 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Sound for first beat of each measure:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer43->Add(itemStaticText47, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pMtrInstr1ComboStrings = NULL;
m_pMtrInstr1Combo = LENMUS_NEW wxComboBox( this, ID_COMBO_MTR_INSTR1, "", wxDefaultPosition, wxSize(250, -1), 0, m_pMtrInstr1ComboStrings, wxCB_READONLY );
itemBoxSizer43->Add(m_pMtrInstr1Combo, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
wxStaticText* itemStaticText49 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Sound for other beats of each measure:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer43->Add(itemStaticText49, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pMtrInstr2ComboStrings = NULL;
m_pMtrInstr2Combo = LENMUS_NEW wxComboBox( this, ID_COMBO_MTR_INSTR2, "", wxDefaultPosition, wxSize(250, -1), 0, m_pMtrInstr2ComboStrings, wxCB_READONLY );
itemBoxSizer43->Add(m_pMtrInstr2Combo, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
wxButton* itemButton51 = LENMUS_NEW wxButton( this, ID_BUTTON, _("Test sound"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer43->Add(itemButton51, 0, wxALIGN_LEFT|wxALL, 5);
}
//---------------------------------------------------------------------------------------
ColorsOptPanel::ColorsOptPanel(wxWindow* parent, ApplicationScope& appScope)
: OptionsPanel(parent, appScope)
{
//TODO GetLanguages(m_cLangCodes, m_cLangNames);
wxString* m_cLangCodes = LENMUS_NEW wxString[2];
wxString* m_cLangNames = LENMUS_NEW wxString[2];
m_cLangCodes[0] = "en"; m_cLangNames[0] = "Green";
m_cLangCodes[1] = "sp"; m_cLangNames[1] = "Blue";
int nNumLangs = 2; //TODO m_cLangNames.GetCount();
wxString sysLang = "en"; //TODO GetSystemLanguageCode();
wxBoxSizer *mainSizer = LENMUS_NEW wxBoxSizer(wxVERTICAL);
wxBoxSizer *hSizer;
hSizer = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
hSizer->Add(LENMUS_NEW wxStaticText(this, -1,
_("Choose colors to use:")),
0, wxALIGN_CENTRE | wxALIGN_CENTER_VERTICAL | wxALL, 8);
wxString *langArray = LENMUS_NEW wxString[nNumLangs];
int i;
for(i=0; i < nNumLangs; i++)
langArray[i] = m_cLangNames[i];
m_pChoice = LENMUS_NEW wxChoice(this, -1, wxDefaultPosition, wxDefaultSize,
nNumLangs, langArray);
m_pChoice->SetSelection(0); // in case nothing else matches
delete[] langArray;
for(i=0; i < nNumLangs; i++) {
if (m_cLangCodes[i] == sysLang)
m_pChoice->SetSelection(i);
}
hSizer->Add(m_pChoice,
0, wxALIGN_CENTRE | wxALIGN_CENTER_VERTICAL | wxALL, 8);
mainSizer->Add(hSizer,
0, wxALL, 8);
SetAutoLayout(true);
SetSizer(mainSizer);
mainSizer->Fit(this);
mainSizer->SetSizeHints(this);
//TODO Delete this debug code
delete [] m_cLangNames;
delete [] m_cLangCodes;
}
//---------------------------------------------------------------------------------------
void WizardInstrumentsPage::CreateControls()
{
wxBoxSizer* itemBoxSizer17 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
SetSizer(itemBoxSizer17);
wxBoxSizer* itemBoxSizer18 = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
itemBoxSizer17->Add(itemBoxSizer18, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxStaticText* itemStaticText19 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Voice channel and instrument"), wxDefaultPosition, wxDefaultSize, 0 );
itemStaticText19->SetFont(wxFont(14, wxSWISS, wxNORMAL, wxBOLD, false, "Arial"));
itemBoxSizer18->Add(itemStaticText19, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);
wxBoxSizer* itemBoxSizer20 = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
itemBoxSizer17->Add(itemBoxSizer20, 1, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer21 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer20->Add(itemBoxSizer21, 1, wxGROW|wxALL, 5);
wxStaticText* itemStaticText22 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Channels 10 and 16 are specialized in percussion sounds. So it is recommended to choose any other channel (it doesn't matter wich one)."), wxDefaultPosition, wxSize(250, -1), 0 );
itemBoxSizer21->Add(itemStaticText22, 1, wxGROW|wxALL|wxADJUST_MINSIZE, 5);
wxStaticText* itemStaticText23 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("To facilitate access to the instruments they are grouped into sections. First choose a section and then choose the desired instrument."), wxDefaultPosition, wxSize(250, -1), 0 );
itemBoxSizer21->Add(itemStaticText23, 1, wxGROW|wxALL|wxADJUST_MINSIZE, 5);
wxStaticLine* itemStaticLine24 = LENMUS_NEW wxStaticLine( this, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
itemBoxSizer20->Add(itemStaticLine24, 0, wxGROW|wxALL, 5);
wxBoxSizer* itemBoxSizer25 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer20->Add(itemBoxSizer25, 1, wxGROW|wxALL, 5);
wxStaticText* itemStaticText26 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Channel:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer25->Add(itemStaticText26, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pVoiceChannelComboStrings = NULL;
m_pVoiceChannelCombo = LENMUS_NEW wxComboBox( this, ID_COMBO_CHANNEL, "", wxDefaultPosition, wxSize(70, -1), 0, m_pVoiceChannelComboStrings, wxCB_READONLY );
itemBoxSizer25->Add(m_pVoiceChannelCombo, 0, wxALIGN_LEFT|wxALL, 5);
wxBoxSizer* itemBoxSizer28 = LENMUS_NEW wxBoxSizer(wxVERTICAL);
itemBoxSizer25->Add(itemBoxSizer28, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);
wxStaticText* itemStaticText29 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Section:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer25->Add(itemStaticText29, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pSectComboStrings = NULL;
m_pSectCombo = LENMUS_NEW wxComboBox( this, ID_COMBO_SECTION, "", wxDefaultPosition, wxSize(250, -1), 0, m_pSectComboStrings, wxCB_READONLY );
itemBoxSizer25->Add(m_pSectCombo, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
wxStaticText* itemStaticText31 = LENMUS_NEW wxStaticText( this, wxID_STATIC, _("Instrument:"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer25->Add(itemStaticText31, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxTOP|wxADJUST_MINSIZE, 5);
wxString* m_pInstrComboStrings = NULL;
m_pInstrCombo = LENMUS_NEW wxComboBox( this, ID_COMBO_INSTRUMENT, "", wxDefaultPosition, wxSize(250, -1), 0, m_pInstrComboStrings, wxCB_READONLY );
itemBoxSizer25->Add(m_pInstrCombo, 0, wxALIGN_LEFT|wxLEFT|wxRIGHT|wxBOTTOM, 5);
wxButton* itemButton33 = LENMUS_NEW wxButton( this, ID_BUTTON_TEST_SOUND, _("Test sound"), wxDefaultPosition, wxDefaultSize, 0 );
itemBoxSizer25->Add(itemButton33, 0, wxALIGN_LEFT|wxALL, 5);
}
//---------------------------------------------------------------------------------------
DlgChooseLanguage::DlgChooseLanguage(wxWindow* parent, wxWindowID id,
const wxString& title)
: wxDialog(parent, id, title)
{
GetLanguages(m_cLangCodes, m_cLangNames);
m_nNumLangs = m_cLangNames.GetCount();
wxString sysLang = GetSystemLanguageCode();
wxBoxSizer *mainSizer = LENMUS_NEW wxBoxSizer(wxVERTICAL);
wxBoxSizer *hSizer;
hSizer = LENMUS_NEW wxBoxSizer(wxHORIZONTAL);
hSizer->Add(LENMUS_NEW wxStaticText(this, -1,
_("Choose language to use:")),
0, wxALIGN_CENTRE | wxALIGN_CENTER_VERTICAL | wxALL, 8);
wxString *langArray = LENMUS_NEW wxString[m_nNumLangs];
for(int i=0; i < m_nNumLangs; i++)
langArray[i] = m_cLangNames[i];
m_pChoice = LENMUS_NEW wxChoice(this, -1, wxDefaultPosition, wxDefaultSize,
m_nNumLangs, langArray);
m_pChoice->SetSelection(0); // in case nothing else matches
delete[] langArray;
for(int i=0; i < m_nNumLangs; i++)
{
if (m_cLangCodes[i] == sysLang)
m_pChoice->SetSelection(i);
}
hSizer->Add(m_pChoice,
0, wxALIGN_CENTRE | wxALIGN_CENTER_VERTICAL | wxALL, 8);
mainSizer->Add(hSizer,
0, wxALL, 8);
wxButton *ok = LENMUS_NEW wxButton(this, wxID_OK, _("OK"));
ok->SetDefault();
mainSizer->Add(ok, 0, wxALIGN_CENTRE | wxALL, 8);
SetAutoLayout(true);
SetSizer(mainSizer);
mainSizer->Fit(this);
mainSizer->SetSizeHints(this);
// set default language, just in case user closes the dialog by clicking on
// the dialog title [X] button
m_sLang = m_cLangCodes[m_pChoice->GetSelection()];
}
void EffectRack::Add(Effect *effect, bool active, bool favorite)
{
if (mEffects.Index(effect) != wxNOT_FOUND)
{
return;
}
wxBitmapButton *bb;
wxASSERT(mPanel); // To justify safenew
bb = safenew wxBitmapButton(mPanel, ID_POWER + mNumEffects, mPowerRaised);
bb->SetBitmapSelected(mPowerRaised);
bb->SetName(_("Active State"));
bb->SetToolTip(_("Set effect active state"));
mPowerState.Add(active);
if (active)
{
bb->SetBitmapLabel(mPowerPushed);
bb->SetBitmapSelected(mPowerPushed);
}
else
{
bb->SetBitmapLabel(mPowerRaised);
bb->SetBitmapSelected(mPowerRaised);
}
mMainSizer->Add(bb, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
bb = safenew wxBitmapButton(mPanel, ID_EDITOR + mNumEffects, mSettingsRaised);
bb->SetBitmapSelected(mSettingsPushed);
bb->SetName(_("Show/Hide Editor"));
bb->SetToolTip(_("Open/close effect editor"));
mMainSizer->Add(bb, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
bb = safenew wxBitmapButton(mPanel, ID_UP + mNumEffects, mUpRaised);
bb->SetBitmapSelected(mUpPushed);
bb->SetBitmapDisabled(mUpDisabled);
bb->SetName(_("Move Up"));
bb->SetToolTip(_("Move effect up in the rack"));
mMainSizer->Add(bb, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
bb = safenew wxBitmapButton(mPanel, ID_DOWN + mNumEffects, mDownRaised);
bb->SetBitmapSelected(mDownPushed);
bb->SetBitmapDisabled(mDownDisabled);
bb->SetName(_("Move Down"));
bb->SetToolTip(_("Move effect down in the rack"));
mMainSizer->Add(bb, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
bb = safenew wxBitmapButton(mPanel, ID_FAV + mNumEffects, mFavRaised);
bb->SetBitmapSelected(mFavPushed);
bb->SetName(_("Favorite"));
bb->SetToolTip(_("Mark effect as a favorite"));
mFavState.Add(favorite);
if (favorite)
{
bb->SetBitmapLabel(mFavPushed);
bb->SetBitmapSelected(mFavPushed);
}
else
{
bb->SetBitmapLabel(mFavRaised);
bb->SetBitmapSelected(mFavRaised);
}
mMainSizer->Add(bb, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
bb = safenew wxBitmapButton(mPanel, ID_REMOVE + mNumEffects, mRemoveRaised);
bb->SetBitmapSelected(mRemovePushed);
bb->SetName(_("Remove"));
bb->SetToolTip(_("Remove effect from the rack"));
mMainSizer->Add(bb, 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
wxStaticText *text = safenew wxStaticText(mPanel, ID_NAME + mNumEffects, effect->GetName());
text->SetToolTip(_("Name of the effect"));
mMainSizer->Add(text, 0, wxEXPAND | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxALL, 5);
mMainSizer->Layout();
SetSize(GetMinSize());
Fit();
Update();
mEffects.Add(effect);
mNumEffects++;
if (!mTimer.IsRunning())
{
mTimer.Start(1000);
}
if (active)
{
UpdateActive();
}
}
EffectRack::EffectRack()
: wxFrame(GetActiveProject(),
wxID_ANY,
_("Effects Rack"),
wxDefaultPosition,
wxDefaultSize,
wxSYSTEM_MENU |
wxCLOSE_BOX |
wxCAPTION |
wxFRAME_NO_TASKBAR |
wxFRAME_FLOAT_ON_PARENT)
{
mBypassing = false;
mNumEffects = 0;
mLastLatency = 0;
mTimer.SetOwner(this);
mPowerPushed = CreateBitmap(power_on_16x16_xpm, false, false);
mPowerRaised = CreateBitmap(power_off_16x16_xpm, true, false);
mSettingsPushed = CreateBitmap(settings_up_16x16_xpm, false, true);
mSettingsRaised = CreateBitmap(settings_down_16x16_xpm, true, true);
mUpDisabled = CreateBitmap(up_9x16_xpm, true, true);
mUpPushed = CreateBitmap(up_9x16_xpm, false, true);
mUpRaised = CreateBitmap(up_9x16_xpm, true, true);
mDownDisabled = CreateBitmap(down_9x16_xpm, true, true);
mDownPushed = CreateBitmap(down_9x16_xpm, false, true);
mDownRaised = CreateBitmap(down_9x16_xpm, true, true);
mFavPushed = CreateBitmap(fav_down_16x16_xpm, false, false);
mFavRaised = CreateBitmap(fav_up_16x16_xpm, true, false);
mRemovePushed = CreateBitmap(remove_16x16_xpm, false, true);
mRemoveRaised = CreateBitmap(remove_16x16_xpm, true, true);
{
auto bs = std::make_unique<wxBoxSizer>(wxVERTICAL);
mPanel = safenew wxPanel(this, wxID_ANY);
bs->Add(mPanel, 1, wxEXPAND);
SetSizer(bs.release());
}
{
auto bs = std::make_unique<wxBoxSizer>(wxVERTICAL);
{
auto hs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
wxASSERT(mPanel); // To justify safenew
hs->Add(safenew wxButton(mPanel, wxID_APPLY, _("&Apply")), 0, wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL);
hs->AddStretchSpacer();
mLatency = safenew wxStaticText(mPanel, wxID_ANY, _("Latency: 0"));
hs->Add(mLatency, 0, wxALIGN_CENTER);
hs->AddStretchSpacer();
hs->Add(safenew wxToggleButton(mPanel, wxID_CLEAR, _("&Bypass")), 0, wxALIGN_RIGHT | wxALIGN_CENTER_VERTICAL);
bs->Add(hs.release(), 0, wxEXPAND);
}
bs->Add(safenew wxStaticLine(mPanel, wxID_ANY), 0, wxEXPAND);
{
auto uMainSizer = std::make_unique<wxFlexGridSizer>(7);
uMainSizer->AddGrowableCol(6);
uMainSizer->SetHGap(0);
uMainSizer->SetVGap(0);
bs->Add((mMainSizer = uMainSizer.release()), 1, wxEXPAND);
}
mPanel->SetSizer(bs.release());
}
wxString oldPath = gPrefs->GetPath();
gPrefs->SetPath(wxT("/EffectsRack"));
size_t cnt = gPrefs->GetNumberOfEntries();
gPrefs->SetPath(oldPath);
EffectManager & em = EffectManager::Get();
for (size_t i = 0; i < cnt; i++)
{
wxString slot;
gPrefs->Read(wxString::Format(wxT("/EffectsRack/Slot%02d"), i), &slot);
Effect *effect = em.GetEffect(slot.AfterFirst(wxT(',')).c_str());
if (effect)
{
Add(effect, slot.BeforeFirst(wxT(',')) == wxT("1"), true);
}
}
Fit();
}
wxNotebookPage* PreferencesWindow::CreateGeneralPage()
{
wxNotebookPage* general_page = newd wxPanel(book, wxID_ANY);
wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
wxStaticText* tmptext;
always_make_backup_chkbox = newd wxCheckBox(general_page, wxID_ANY, "Always make map backup");
always_make_backup_chkbox->SetValue(g_settings.getInteger(Config::ALWAYS_MAKE_BACKUP) == 1);
sizer->Add(always_make_backup_chkbox, 0, wxLEFT | wxTOP, 5);
create_on_startup_chkbox = newd wxCheckBox(general_page, wxID_ANY, "Create map on startup");
create_on_startup_chkbox->SetValue(g_settings.getInteger(Config::CREATE_MAP_ON_STARTUP) == 1);
sizer->Add(create_on_startup_chkbox, 0, wxLEFT | wxTOP, 5);
update_check_on_startup_chkbox = newd wxCheckBox(general_page, wxID_ANY, "Check for updates on startup");
update_check_on_startup_chkbox->SetValue(g_settings.getInteger(Config::USE_UPDATER) == 1);
sizer->Add(update_check_on_startup_chkbox, 0, wxLEFT | wxTOP, 5);
only_one_instance_chkbox = newd wxCheckBox(general_page, wxID_ANY, "Open all maps in the same instance");
only_one_instance_chkbox->SetValue(g_settings.getInteger(Config::ONLY_ONE_INSTANCE) == 1);
only_one_instance_chkbox->SetToolTip("When checked, maps opened using the shell will all be opened in the same instance.");
sizer->Add(only_one_instance_chkbox, 0, wxLEFT | wxTOP, 5);
sizer->AddSpacer(10);
wxFlexGridSizer* grid_sizer = newd wxFlexGridSizer(2, 10, 10);
grid_sizer->AddGrowableCol(1);
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, "Undo queue size: "), 0);
undo_size_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(g_settings.getInteger(Config::UNDO_SIZE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 0x10000000);
grid_sizer->Add(undo_size_spin, 0);
SetWindowToolTip(tmptext, undo_size_spin, "How many action you can undo, be aware that a high value will increase memory usage.");
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, "Undo maximum memory size (MB): "), 0);
undo_mem_size_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(g_settings.getInteger(Config::UNDO_MEM_SIZE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 4096);
grid_sizer->Add(undo_mem_size_spin, 0);
SetWindowToolTip(tmptext, undo_mem_size_spin, "The approximite limit for the memory usage of the undo queue.");
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, "Worker Threads: "), 0);
worker_threads_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(g_settings.getInteger(Config::WORKER_THREADS)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 1, 64);
grid_sizer->Add(worker_threads_spin, 0);
SetWindowToolTip(tmptext, worker_threads_spin, "How many threads the editor will use for intensive operations. This should be equivalent to the amount of logical processors in your system.");
grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, "Replace count: "), 0);
replace_size_spin = newd wxSpinCtrl(general_page, wxID_ANY, i2ws(g_settings.getInteger(Config::REPLACE_SIZE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 100000);
grid_sizer->Add(replace_size_spin, 0);
SetWindowToolTip(tmptext, replace_size_spin, "How many items you can replace on the map using the Replace Item tool.");
sizer->Add(grid_sizer, 0, wxALL, 5);
sizer->AddSpacer(10);
wxString position_choices[] = { " {x = 0, y = 0, z = 0}",
" {\"x\":0,\"y\":0,\"z\":0}",
" x, y, z",
" (x, y, z)",
" Position(x, y, z)" };
int radio_choices = sizeof(position_choices) / sizeof(wxString);
position_format = newd wxRadioBox(general_page, wxID_ANY, "Copy Position Format", wxDefaultPosition, wxDefaultSize, radio_choices, position_choices, 1, wxRA_SPECIFY_COLS);
position_format->SetSelection(g_settings.getInteger(Config::COPY_POSITION_FORMAT));
sizer->Add(position_format, 0, wxALL | wxEXPAND, 5);
SetWindowToolTip(tmptext, position_format, "The position format when copying from the map.");
general_page->SetSizerAndFit(sizer);
return general_page;
}
wxNotebookPage* PreferencesWindow::CreateClientPage()
{
wxNotebookPage* client_page = newd wxPanel(book, wxID_ANY);
// Refresh g_settings
ClientVersion::saveVersions();
ClientVersionList versions = ClientVersion::getAllVisible();
wxSizer* topsizer = newd wxBoxSizer(wxVERTICAL);
wxFlexGridSizer* options_sizer = newd wxFlexGridSizer(2, 10, 10);
options_sizer->AddGrowableCol(1);
// Default client version choice control
default_version_choice = newd wxChoice(client_page, wxID_ANY);
wxStaticText* default_client_tooltip = newd wxStaticText(client_page, wxID_ANY, "Default client version:");
options_sizer->Add(default_client_tooltip, 0, wxLEFT | wxTOP, 5);
options_sizer->Add(default_version_choice, 0, wxTOP, 5);
SetWindowToolTip(default_client_tooltip, default_version_choice, "This will decide what client version will be used when new maps are created.");
// Check file sigs checkbox
check_sigs_chkbox = newd wxCheckBox(client_page, wxID_ANY, "Check file signatures");
check_sigs_chkbox->SetValue(g_settings.getBoolean(Config::CHECK_SIGNATURES));
check_sigs_chkbox->SetToolTip("When this option is not checked, the editor will load any OTB/DAT/SPR combination without complaints. This may cause graphics bugs.");
options_sizer->Add(check_sigs_chkbox, 0, wxLEFT | wxRIGHT | wxTOP, 5);
// Add the grid sizer
topsizer->Add(options_sizer, wxSizerFlags(0).Expand());
topsizer->AddSpacer(10);
wxScrolledWindow *client_list_window = newd wxScrolledWindow(client_page, wxID_ANY, wxDefaultPosition, wxSize(400, 350), wxSUNKEN_BORDER);
wxFlexGridSizer* client_list_sizer = newd wxFlexGridSizer(2, 10, 10);
client_list_sizer->AddGrowableCol(1);
client_list_window->SetVirtualSize( 500, 1000 );
int version_counter = 0;
for(ClientVersionList::iterator version_iter = versions.begin(); version_iter != versions.end(); ++version_iter) {
const ClientVersion* version = *version_iter;
if(!version->isVisible())
continue;
default_version_choice->Append(wxstr(version->getName()));
wxString searchtip;
searchtip << "Version " << wxstr(version->getName()) << " search path";
wxStaticText *tmp_text = newd wxStaticText(client_list_window, wxID_ANY, searchtip);
client_list_sizer->Add(tmp_text, 0);
wxDirPickerCtrl* dir_picker = newd wxDirPickerCtrl(client_list_window, wxID_ANY, version->getClientPath().GetFullPath());
version_dir_pickers.push_back(dir_picker);
client_list_sizer->Add(dir_picker, 0);
wxString tooltip;
tooltip << "The editor will look for " << wxstr(version->getName()) << " DAT & SPR here.";
tmp_text->SetToolTip(tooltip);
dir_picker->SetToolTip(tooltip);
if(version->getID() == g_settings.getInteger(Config::DEFAULT_CLIENT_VERSION))
default_version_choice->SetSelection(version_counter);
version_counter++;
}
// Set the sizers
client_list_window->SetSizer(client_list_sizer);
client_list_window->FitInside();
client_list_window->SetScrollRate(5, 5);
topsizer->Add(client_list_window, 0, wxALL, 5);
client_page->SetSizerAndFit(topsizer);
return client_page;
}
wxNotebookPage* PreferencesWindow::CreateUIPage()
{
wxNotebookPage* ui_page = newd wxPanel(book, wxID_ANY);
wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
wxFlexGridSizer* subsizer = newd wxFlexGridSizer(2, 10, 10);
subsizer->AddGrowableCol(1);
terrain_palette_style_choice = AddPaletteStyleChoice(
ui_page, subsizer,
"Terrain Palette Style:",
"Configures the look of the terrain palette.",
g_settings.getString(Config::PALETTE_TERRAIN_STYLE));
doodad_palette_style_choice = AddPaletteStyleChoice(
ui_page, subsizer,
"Doodad Palette Style:",
"Configures the look of the doodad palette.",
g_settings.getString(Config::PALETTE_DOODAD_STYLE));
item_palette_style_choice = AddPaletteStyleChoice(
ui_page, subsizer,
"Item Palette Style:",
"Configures the look of the item palette.",
g_settings.getString(Config::PALETTE_ITEM_STYLE));
raw_palette_style_choice = AddPaletteStyleChoice(
ui_page, subsizer,
"RAW Palette Style:",
"Configures the look of the raw palette.",
g_settings.getString(Config::PALETTE_RAW_STYLE));
sizer->Add(subsizer, 0, wxALL, 5);
sizer->AddSpacer(10);
large_terrain_tools_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large terrain palette tool & size icons");
large_terrain_tools_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_TERRAIN_TOOLBAR));
sizer->Add(large_terrain_tools_chkbox, 0, wxLEFT | wxTOP, 5);
large_doodad_sizebar_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large doodad size palette icons");
large_doodad_sizebar_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_DOODAD_SIZEBAR));
sizer->Add(large_doodad_sizebar_chkbox, 0, wxLEFT | wxTOP, 5);
large_item_sizebar_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large item size palette icons");
large_item_sizebar_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_ITEM_SIZEBAR));
sizer->Add(large_item_sizebar_chkbox, 0, wxLEFT | wxTOP, 5);
large_house_sizebar_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large house palette size icons");
large_house_sizebar_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_HOUSE_SIZEBAR));
sizer->Add(large_house_sizebar_chkbox, 0, wxLEFT | wxTOP, 5);
large_raw_sizebar_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large raw palette size icons");
large_raw_sizebar_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_RAW_SIZEBAR));
sizer->Add(large_raw_sizebar_chkbox, 0, wxLEFT | wxTOP, 5);
large_container_icons_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large container view icons");
large_container_icons_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_CONTAINER_ICONS));
sizer->Add(large_container_icons_chkbox, 0, wxLEFT | wxTOP, 5);
large_pick_item_icons_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use large item picker icons");
large_pick_item_icons_chkbox->SetValue(g_settings.getBoolean(Config::USE_LARGE_CHOOSE_ITEM_ICONS));
sizer->Add(large_pick_item_icons_chkbox, 0, wxLEFT | wxTOP, 5);
sizer->AddSpacer(10);
switch_mousebtn_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Switch mousebuttons");
switch_mousebtn_chkbox->SetValue(g_settings.getBoolean(Config::SWITCH_MOUSEBUTTONS));
switch_mousebtn_chkbox->SetToolTip("Switches the right and center mouse button.");
sizer->Add(switch_mousebtn_chkbox, 0, wxLEFT | wxTOP, 5);
doubleclick_properties_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Double click for properties");
doubleclick_properties_chkbox->SetValue(g_settings.getBoolean(Config::DOUBLECLICK_PROPERTIES));
doubleclick_properties_chkbox->SetToolTip("Double clicking on a tile will bring up the properties menu for the top item.");
sizer->Add(doubleclick_properties_chkbox, 0, wxLEFT | wxTOP, 5);
inversed_scroll_chkbox = newd wxCheckBox(ui_page, wxID_ANY, "Use inversed scroll");
inversed_scroll_chkbox->SetValue(g_settings.getFloat(Config::SCROLL_SPEED) < 0);
inversed_scroll_chkbox->SetToolTip("When this checkbox is checked, dragging the map using the center mouse button will be inversed (default RTS behaviour).");
sizer->Add(inversed_scroll_chkbox, 0, wxLEFT | wxTOP, 5);
sizer->AddSpacer(10);
sizer->Add(newd wxStaticText(ui_page, wxID_ANY, "Scroll speed: "), 0, wxLEFT | wxTOP, 5);
int true_scrollspeed = int(std::abs(g_settings.getFloat(Config::SCROLL_SPEED)) * 10);
scroll_speed_slider = newd wxSlider(ui_page, wxID_ANY, true_scrollspeed, 1, max(true_scrollspeed, 100));
scroll_speed_slider->SetToolTip("This controls how fast the map will scroll when you hold down the center mouse button and move it around.");
sizer->Add(scroll_speed_slider, 0, wxEXPAND, 5);
sizer->Add(newd wxStaticText(ui_page, wxID_ANY, "Zoom speed: "), 0, wxLEFT | wxTOP, 5);
int true_zoomspeed = int(g_settings.getFloat(Config::ZOOM_SPEED) * 10);
zoom_speed_slider = newd wxSlider(ui_page, wxID_ANY, true_zoomspeed, 1, max(true_zoomspeed, 100));
zoom_speed_slider->SetToolTip("This controls how fast you will zoom when you scroll the center mouse button.");
sizer->Add(zoom_speed_slider, 0, wxEXPAND, 5);
ui_page->SetSizerAndFit(sizer);
return ui_page;
}
void SelectionBar::Populate()
{
mLeftTime = mRightTime = mAudioTime = nullptr;
// This will be inherited by all children:
SetFont(wxFont(
#ifdef __WXMAC__
12
#else
9
#endif
,
wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
wxFlexGridSizer *mainSizer;
/* we don't actually need a control yet, but we want to use it's methods
* to do some look-ups, so we'll have to create one. We can't make the
* look-ups static because they depend on translations which are done at
* runtime */
wxString formatName = mListener ? mListener->AS_GetSelectionFormat() : wxString(wxEmptyString);
Add((mainSizer = safenew wxFlexGridSizer(7, 1, 1)), 0, wxALIGN_CENTER_VERTICAL);
//
// Top row (mostly labels)
//
mainSizer->Add(safenew wxStaticText(this, -1, _("Project Rate (Hz):"),
// LLL: On my Ubuntu 7.04 install, the label wraps to two lines
// and I could not figure out why. Thus...hackage.
#if defined(__WXGTK__)
wxDefaultPosition, wxSize(110, -1)),
#else
wxDefaultPosition, wxDefaultSize),
#endif
0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
mainSizer->Add(5, 1);
mainSizer->Add(safenew wxStaticText(this, -1, _("Snap To:")),
0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
mainSizer->Add(safenew wxStaticText(this, -1, _("Selection Start:")),
0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
bool showSelectionLength = false;
gPrefs->Read(wxT("/ShowSelectionLength"), &showSelectionLength);
{
auto hSizer = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
mRightEndButton = safenew wxRadioButton(this, OnEndRadioID, _("End"),
wxDefaultPosition, wxDefaultSize,
wxRB_GROUP);
mRightEndButton->SetName(_("End"));
mRightEndButton->SetValue(!showSelectionLength);
hSizer->Add(mRightEndButton,
0, wxRIGHT | wxALIGN_CENTER_VERTICAL, 5);
mRightLengthButton = safenew wxRadioButton(this, OnLengthRadioID, _("Length"));
mRightLengthButton->SetName(_("Length"));
mRightLengthButton->SetValue(showSelectionLength);
hSizer->Add(mRightLengthButton,
0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
#if defined(__WXMSW__)
// Refer to Microsoft KB article 261192 for an explanation as
// to why this is needed. We've only experienced it under Win2k
// so it's probably been fixed. But, it doesn't hurt to have this
// in for all versions.
wxRadioButton* dummyButton =
safenew wxRadioButton(this, wxID_ANY, _("hidden"),
wxDefaultPosition, wxDefaultSize,
wxRB_GROUP);
dummyButton->Disable();
dummyButton->Hide();
#endif
mainSizer->Add(hSizer.release(), 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 0);
}
mainSizer->Add(5, 1);
mainSizer->Add(safenew wxStaticText(this, -1, _("Audio Position:")),
0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 0);
//
// Middle row (mostly time controls)
//
mRateBox = safenew wxComboBox(this, OnRateID,
wxT(""),
wxDefaultPosition, wxSize(80, -1));
mRateBox->SetName(_("Project Rate (Hz):"));
wxTextValidator vld(wxFILTER_INCLUDE_CHAR_LIST);
vld.SetIncludes(wxArrayString(10, numbers));
mRateBox->SetValidator(vld);
mRateBox->SetValue(wxString::Format(wxT("%d"), (int)mRate));
UpdateRates(); // Must be done _after_ setting value on mRateBox!
// We need to capture the SetFocus and KillFocus events to set up
// for keyboard capture. On Windows and GTK it's easy since the
// combobox is presented as one control to hook into.
mRateText = mRateBox;
#if defined(__WXMAC__)
// The Mac uses a standard wxTextCtrl for the edit portion and that's
// the control that gets the focus events. So we have to find the
// textctrl.
wxWindowList kids = mRateBox->GetChildren();
for (unsigned int i = 0; i < kids.GetCount(); i++) {
wxClassInfo *ci = kids[i]->GetClassInfo();
if (ci->IsKindOf(CLASSINFO(wxTextCtrl))) {
mRateText = kids[i];
break;
}
}
#endif
mRateText->Connect(wxEVT_SET_FOCUS,
wxFocusEventHandler(SelectionBar::OnFocus),
NULL,
this);
mRateText->Connect(wxEVT_KILL_FOCUS,
wxFocusEventHandler(SelectionBar::OnFocus),
NULL,
this);
mainSizer->Add(mRateBox, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
mainSizer->Add(safenew wxStaticLine(this, -1, wxDefaultPosition,
wxSize(1, toolbarSingle),
wxLI_VERTICAL),
0, wxRIGHT, 5);
mSnapTo = safenew wxChoice(this, OnSnapToID,
wxDefaultPosition, wxDefaultSize,
SnapManager::GetSnapLabels());
mainSizer->Add(mSnapTo,
0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
mSnapTo->SetName(_("Snap To"));
mSnapTo->SetSelection(mListener ? mListener->AS_GetSnapTo() : SNAP_OFF);
mSnapTo->Connect(wxEVT_SET_FOCUS,
wxFocusEventHandler(SelectionBar::OnFocus),
NULL,
this);
mSnapTo->Connect(wxEVT_KILL_FOCUS,
wxFocusEventHandler(SelectionBar::OnFocus),
NULL,
this);
mLeftTime = safenew NumericTextCtrl(
NumericConverter::TIME, this, OnLeftTimeID, formatName, 0.0, mRate);
mLeftTime->SetName(_("Selection Start:"));
mLeftTime->EnableMenu();
mainSizer->Add(mLeftTime, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
mRightTime = safenew NumericTextCtrl(
NumericConverter::TIME, this, OnRightTimeID, formatName, 0.0, mRate);
mRightTime->SetName(wxString(_("Selection ")) + (showSelectionLength ?
_("Length") :
_("End")));
mRightTime->EnableMenu();
mainSizer->Add(mRightTime, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 5);
mainSizer->Add(safenew wxStaticLine(this, -1, wxDefaultPosition,
wxSize(1, toolbarSingle),
wxLI_VERTICAL),
0, wxRIGHT, 5);
mAudioTime = safenew NumericTextCtrl(
NumericConverter::TIME, this, wxID_ANY, formatName, 0.0, mRate);
mAudioTime->SetName(_("Audio Position:"));
mAudioTime->EnableMenu();
mainSizer->Add(mAudioTime, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 0);
mainSizer->Layout();
RegenerateTooltips();
Layout();
SetMinSize( GetSizer()->GetMinSize() );
}
wxNotebookPage* PreferencesWindow::CreateGraphicsPage()
{
wxWindow* tmp;
wxNotebookPage* graphics_page = newd wxPanel(book, wxID_ANY);
wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
hide_items_when_zoomed_chkbox = newd wxCheckBox(graphics_page, wxID_ANY, "Hide items when zoomed out");
hide_items_when_zoomed_chkbox->SetValue(g_settings.getBoolean(Config::HIDE_ITEMS_WHEN_ZOOMED));
sizer->Add(hide_items_when_zoomed_chkbox, 0, wxLEFT | wxTOP, 5);
SetWindowToolTip(hide_items_when_zoomed_chkbox, "When this option is checked, \"loose\" items will be hidden when you zoom very far out.");
icon_selection_shadow_chkbox = newd wxCheckBox(graphics_page, wxID_ANY, "Use icon selection shadow");
icon_selection_shadow_chkbox->SetValue(g_settings.getBoolean(Config::USE_GUI_SELECTION_SHADOW));
sizer->Add(icon_selection_shadow_chkbox, 0, wxLEFT | wxTOP, 5);
SetWindowToolTip(icon_selection_shadow_chkbox, "When this option is checked, selected items in the palette menu will be shaded.");
use_memcached_chkbox = newd wxCheckBox(graphics_page, wxID_ANY, "Use memcached sprites");
use_memcached_chkbox->SetValue(g_settings.getBoolean(Config::USE_MEMCACHED_SPRITES));
sizer->Add(use_memcached_chkbox, 0, wxLEFT | wxTOP, 5);
SetWindowToolTip(use_memcached_chkbox, "When this is checked, sprites will be loaded into memory at startup and unpacked at runtime. This is faster but consumes more memory.\nIf it is not checked, the editor will use less memory but there will be a performance decrease due to reading sprites from the disk.");
sizer->AddSpacer(10);
wxFlexGridSizer* subsizer = newd wxFlexGridSizer(2, 10, 10);
subsizer->AddGrowableCol(1);
// Icon background color
icon_background_choice = newd wxChoice(graphics_page, wxID_ANY);
icon_background_choice->Append("Black background");
icon_background_choice->Append("Gray background");
icon_background_choice->Append("White background");
if(g_settings.getInteger(Config::ICON_BACKGROUND) == 255) {
icon_background_choice->SetSelection(2);
} else if(g_settings.getInteger(Config::ICON_BACKGROUND) == 88) {
icon_background_choice->SetSelection(1);
} else {
icon_background_choice->SetSelection(0);
}
subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Icon background color: "), 0);
subsizer->Add(icon_background_choice, 0);
SetWindowToolTip(icon_background_choice, tmp, "This will change the background color on icons in all windows.");
// Cursor colors
subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Cursor color: "), 0);
subsizer->Add(cursor_color_pick = newd wxColourPickerCtrl(graphics_page, wxID_ANY, wxColor(
g_settings.getInteger(Config::CURSOR_RED),
g_settings.getInteger(Config::CURSOR_GREEN),
g_settings.getInteger(Config::CURSOR_BLUE),
g_settings.getInteger(Config::CURSOR_ALPHA)
)), 0);
SetWindowToolTip(icon_background_choice, tmp, "The color of the main cursor on the map (while in drawing mode).");
// Alternate cursor color
subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Secondary cursor color: "), 0);
subsizer->Add(cursor_alt_color_pick = newd wxColourPickerCtrl(graphics_page, wxID_ANY, wxColor(
g_settings.getInteger(Config::CURSOR_ALT_RED),
g_settings.getInteger(Config::CURSOR_ALT_GREEN),
g_settings.getInteger(Config::CURSOR_ALT_BLUE),
g_settings.getInteger(Config::CURSOR_ALT_ALPHA)
)), 0);
SetWindowToolTip(icon_background_choice, tmp, "The color of the secondary cursor on the map (for houses and flags).");
// Screenshot dir
subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Screenshot directory: "), 0);
screenshot_directory_picker = newd wxDirPickerCtrl(graphics_page, wxID_ANY);
subsizer->Add(screenshot_directory_picker);
wxString ss = wxstr(g_settings.getString(Config::SCREENSHOT_DIRECTORY));
screenshot_directory_picker->SetPath(ss);
SetWindowToolTip(screenshot_directory_picker, "Screenshot taken in the editor will be saved to this directory.");
// Screenshot format
screenshot_format_choice = newd wxChoice(graphics_page, wxID_ANY);
screenshot_format_choice->Append("PNG");
screenshot_format_choice->Append("JPG");
screenshot_format_choice->Append("TGA");
screenshot_format_choice->Append("BMP");
if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "png") {
screenshot_format_choice->SetSelection(0);
} else if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "jpg") {
screenshot_format_choice->SetSelection(1);
} else if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "tga") {
screenshot_format_choice->SetSelection(2);
} else if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "bmp") {
screenshot_format_choice->SetSelection(3);
} else {
screenshot_format_choice->SetSelection(0);
}
subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Screenshot format: "), 0);
subsizer->Add(screenshot_format_choice, 0);
SetWindowToolTip(screenshot_format_choice, tmp, "This will affect the screenshot format used by the editor.\nTo take a screenshot, press F11.");
sizer->Add(subsizer, 1, wxEXPAND | wxALL, 5);
// Advanced g_settings
/*
wxCollapsiblePane* pane = newd wxCollapsiblePane(graphics_page, PANE_ADVANCED_GRAPHICS, "Advanced g_settings");
{
wxSizer* pane_sizer = newd wxBoxSizer(wxVERTICAL);
pane_sizer->Add(texture_managment_chkbox = newd wxCheckBox(pane->GetPane(), wxID_ANY, "Use texture managment"));
if(g_settings.getInteger(Config::TEXTURE_MANAGEMENT)) {
texture_managment_chkbox->SetValue(true);
}
pane_sizer->AddSpacer(8);
wxFlexGridSizer* pane_grid_sizer = newd wxFlexGridSizer(2, 10, 10);
pane_grid_sizer->AddGrowableCol(1);
pane_grid_sizer->Add(tmp = newd wxStaticText(pane->GetPane(), wxID_ANY, "Texture clean interval: "), 0);
clean_interval_spin = newd wxSpinCtrl(pane->GetPane(), wxID_ANY, i2ws(g_settings.getInteger(Config::TEXTURE_CLEAN_PULSE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 0x1000000);
pane_grid_sizer->Add(clean_interval_spin, 0);
SetWindowToolTip(clean_interval_spin, tmp, "This controls how often the editor tries to free hardware texture resources.");
pane_grid_sizer->Add(tmp = newd wxStaticText(pane->GetPane(), wxID_ANY, "Texture longevity: "), 0);
texture_longevity_spin = newd wxSpinCtrl(pane->GetPane(), wxID_ANY, i2ws(g_settings.getInteger(Config::TEXTURE_LONGEVITY)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 0, 0x1000000);
pane_grid_sizer->Add(texture_longevity_spin, 0);
SetWindowToolTip(texture_longevity_spin, tmp, "This controls for how long (in seconds) that the editor will keep textures in memory before it cleans them up.");
pane_grid_sizer->Add(tmp = newd wxStaticText(pane->GetPane(), wxID_ANY, "Texture clean threshold: "), 0);
texture_threshold_spin = newd wxSpinCtrl(pane->GetPane(), wxID_ANY, i2ws(g_settings.getInteger(Config::TEXTURE_CLEAN_THRESHOLD)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 100, 0x1000000);
pane_grid_sizer->Add(texture_threshold_spin, 0);
SetWindowToolTip(texture_threshold_spin, tmp, "This controls how many textures the editor will hold in memory before it attempts to clean up old textures. However, an infinite amount MIGHT be loaded.");
pane_grid_sizer->Add(tmp = newd wxStaticText(pane->GetPane(), wxID_ANY, "Software clean threshold: "), 0);
software_threshold_spin = newd wxSpinCtrl(pane->GetPane(), wxID_ANY, i2ws(g_settings.getInteger(Config::SOFTWARE_CLEAN_THRESHOLD)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 100, 0x1000000);
pane_grid_sizer->Add(software_threshold_spin, 0);
SetWindowToolTip(software_threshold_spin, tmp, "This controls how many GUI sprites (icons) the editor will hold in memory at the same time.");
pane_grid_sizer->Add(tmp = newd wxStaticText(pane->GetPane(), wxID_ANY, "Software clean amount: "), 0);
software_clean_amount_spin = newd wxSpinCtrl(pane->GetPane(), wxID_ANY, i2ws(g_settings.getInteger(Config::SOFTWARE_CLEAN_SIZE)), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 1, 0x1000000);
pane_grid_sizer->Add(software_clean_amount_spin, 0);
SetWindowToolTip(software_clean_amount_spin, tmp, "How many sprites the editor will free at once when the limit is exceeded.");
pane_sizer->Add(pane_grid_sizer, 0, wxEXPAND);
pane->GetPane()->SetSizerAndFit(pane_sizer);
pane->Collapse();
}
sizer->Add(pane, 0);
*/
graphics_page->SetSizerAndFit(sizer);
return graphics_page;
}
void TreeGeneratorFrame::createWxCtrls()
{
// menu
SetIcon(wxIcon(L"./Assets/Icons/Zee.xpm", wxBITMAP_TYPE_XPM));
wxMenu* menuFile = New wxMenu;
menuFile->Append(ID_MENU_OPEN, L"&Open");
menuFile->Append(ID_MENU_SAVE, L"&Save");
wxMenuBar* menuBar = New wxMenuBar;
menuBar->Append(menuFile, L"&File");
SetMenuBar(menuBar);
// wnd
wxBoxSizer* boxSizer1 = New wxBoxSizer(wxHORIZONTAL);
// left
mCtrlsPanel = New wxScrolledWindow(this, -1, wxDefaultPosition, wxDefaultSize, wxVSCROLL);
mCtrlsPanel->SetScrollRate(0, 5);
wxBoxSizer* boxSizer2 = New wxBoxSizer(wxVERTICAL);
// -- generalParams
mPanelGeneralParams = New wxCollapsiblePane(mCtrlsPanel, ID_GENERAL_PARAMS, L"General Params");
wxWindow* generalParamsWnd = mPanelGeneralParams->GetPane();
wxFlexGridSizer* fgSizer1 = New wxFlexGridSizer(2, 2, 0, 0);
fgSizer1->SetFlexibleDirection(wxBOTH);
fgSizer1->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
wxStaticText* textLevels = New wxStaticText(generalParamsWnd, -1, L"Levels");
mSpinLevels = New wxSpinCtrl(generalParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 5, 1);
wxStaticText* textScale = New wxStaticText(generalParamsWnd, -1, L"Scale");
mTextScale = New wxTextCtrl(generalParamsWnd, -1, L"10.0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textScaleV = New wxStaticText(generalParamsWnd, -1, L"ScaleV");
mTextScaleV = New wxTextCtrl(generalParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textBaseSize = New wxStaticText(generalParamsWnd, -1, L"BaseSize");
mTextBaseSize = New wxTextCtrl(generalParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textRadiusRatio = New wxStaticText(generalParamsWnd, -1, L"RadiusRatio");
mTextRadiusRatio = New wxTextCtrl(generalParamsWnd, -1, L"0.02", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textRatioPower = New wxStaticText(generalParamsWnd, -1, L"RatioPower");
mTextRatioPower = New wxTextCtrl(generalParamsWnd, -1, L"1", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textShape = New wxStaticText(generalParamsWnd, -1, L"Shape");
mSpinShape = New wxSpinCtrl(generalParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 10, 0);
wxStaticText* textBaseSplits = New wxStaticText(generalParamsWnd, -1, L"BaseSplits");
mSpinBaseSplits = New wxSpinCtrl(generalParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 10, 0);
fgSizer1->Add(textLevels, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mSpinLevels, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textScale, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mTextScale, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textScaleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mTextScaleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textBaseSize, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mTextBaseSize, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textRadiusRatio, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mTextRadiusRatio, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textRatioPower, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mTextRatioPower, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textShape, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mSpinShape, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(textBaseSplits, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer1->Add(mSpinBaseSplits, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
generalParamsWnd->SetSizer(fgSizer1);
generalParamsWnd->Layout();
generalParamsWnd->Fit();
// -- LevelParams
mPanelLevelParmas0 = New wxCollapsiblePane(mCtrlsPanel, ID_GENERAL_PARAMS, L"Level Params");
wxWindow* levelParamsWnd = mPanelLevelParmas0->GetPane();
wxFlexGridSizer* fgSizer2 = New wxFlexGridSizer(2, 2, 0, 0);
fgSizer2->SetFlexibleDirection(wxBOTH);
fgSizer2->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
wxStaticText* textLevel = New wxStaticText(levelParamsWnd, -1, L"Level");
//mSpinLevel = new wxSpinCtrl(levelParamsWnd0, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
// wxSP_ARROW_KEYS, 0, 10, 0);
wxArrayString choices;
choices.Add(wxT("0"));
mChoiceLevel = New wxChoice(levelParamsWnd, -1, wxDefaultPosition, wxDefaultSize, choices);
mChoiceLevel->SetSelection(0);
mSelectedLevel = 0;
wxStaticText* textSegSegsW = New wxStaticText(levelParamsWnd, -1, L"SegSegsW");
mSpinSegSegsW = New wxSpinCtrl(levelParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 100, 8);
wxStaticText* textSegSegsH = New wxStaticText(levelParamsWnd, -1, L"SegSegsH");
mSpinSegSegsH = New wxSpinCtrl(levelParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 100, 4);
wxStaticText* textLength = New wxStaticText(levelParamsWnd, -1, L"Length");
mTextLength = New wxTextCtrl(levelParamsWnd, -1, L"1.0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textLengthV = New wxStaticText(levelParamsWnd, -1, L"LengthV");
mTextLengthV = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textTaper = New wxStaticText(levelParamsWnd, -1, L"Taper");
mTextTaper = New wxTextCtrl(levelParamsWnd, -1, L"1", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textCurveRes = New wxStaticText(levelParamsWnd, -1, L"CurveRes");
mSpinCurveRes = New wxSpinCtrl(levelParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 100, 3);
wxStaticText* textCurve = New wxStaticText(levelParamsWnd, -1, L"Curve");
mTextCurve = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textCurveV = New wxStaticText(levelParamsWnd, -1, L"CurveV");
mTextCurveV = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textCurveBack = New wxStaticText(levelParamsWnd, -1, L"CurveBack");
mTextCurveBack = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textSegSplits = New wxStaticText(levelParamsWnd, -1, L"SegSplits");
mTextSegSplits = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textSplitAngle = New wxStaticText(levelParamsWnd, -1, L"SplitAngle");
mTextSplitAngle = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textSplitAngleV = New wxStaticText(levelParamsWnd, -1, L"SplitAngleV");
mTextSplitAngleV = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textBranches = New wxStaticText(levelParamsWnd, -1, L"Branches");
mSpinBranches = New wxSpinCtrl(levelParamsWnd, -1, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxSP_ARROW_KEYS, 0, 100, 0);
wxStaticText* textDownAngle = New wxStaticText(levelParamsWnd, -1, L"DownAngle");
mTextDownAngle = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textDownAngleV = New wxStaticText(levelParamsWnd, -1, L"DownAngleV");
mTextDownAngleV = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textRotateAngle = New wxStaticText(levelParamsWnd, -1, L"RotateAngle");
mTextRotateAngle = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
wxStaticText* textRotateAngleV = New wxStaticText(levelParamsWnd, -1, L"RotateAngleV");
mTextRotateAngleV = New wxTextCtrl(levelParamsWnd, -1, L"0", wxDefaultPosition, wxDefaultSize, 0,
wxTextValidator(wxFILTER_NUMERIC));
fgSizer2->Add(textLevel, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mChoiceLevel, 0, wxALL | wxALIGN_CENTER_VERTICAL | wxEXPAND, 5);
fgSizer2->Add(textSegSegsW, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mSpinSegSegsW, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textSegSegsH, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mSpinSegSegsH, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textLength, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextLength, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textLengthV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextLengthV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textTaper, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextTaper, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textCurveRes, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mSpinCurveRes, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textCurve, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextCurve, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textCurveV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextCurveV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textCurveBack, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextCurveBack, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textSegSplits, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextSegSplits, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textSplitAngle, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextSplitAngle, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textSplitAngleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextSplitAngleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textBranches, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mSpinBranches, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textDownAngle, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextDownAngle, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textDownAngleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextDownAngleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textRotateAngle, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextRotateAngle, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(textRotateAngleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
fgSizer2->Add(mTextRotateAngleV, 0, wxALL | wxALIGN_CENTER_VERTICAL, 5);
levelParamsWnd->SetSizer(fgSizer2);
levelParamsWnd->Layout();
levelParamsWnd->Fit();
// button
mButtonGenerate = New wxButton(mCtrlsPanel, ID_BUTTON_GENERATE, L"Generate");
boxSizer2->Add(mPanelGeneralParams, 0, wxALL, 5);
boxSizer2->Add(mPanelLevelParmas0, 0, wxALL, 5);
boxSizer2->Add(mButtonGenerate, 0, wxALL, 5);
mCtrlsPanel->SetSizer(boxSizer2);
mCtrlsPanel->SetMinSize(wxSize(240, 600));
mCtrlsPanel->FitInside();
mCtrlsPanel->Layout();
// right
mCanvasPanel = New wxPanel(this, -1);
mCanvasPanel->SetMinSize(wxSize(480, 600));
boxSizer1->Add(mCtrlsPanel, 0, wxALL, 5);
boxSizer1->Add(mCanvasPanel, 0, wxALL, 5);
this->SetSizer(boxSizer1);
this->Layout();
this->Fit();
mSpinLevels->Connect(wxEVT_COMMAND_SPINCTRL_UPDATED, wxSpinEventHandler(TreeGeneratorFrame::OnSpinLevels), NULL, this);
mChoiceLevel->Connect(wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler(TreeGeneratorFrame::OnChoiceLevel), NULL, this);
}
LabelDialog::LabelDialog(wxWindow *parent,
TrackFactory &factory,
TrackList *tracks,
ViewInfo &viewinfo,
double rate,
const wxString & format)
: wxDialog(parent,
wxID_ANY,
_("Edit Labels"),
wxDefaultPosition,
wxSize(800, 600),
wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER),
mFactory(factory),
mTracks(tracks),
mViewInfo(&viewinfo),
mRate(rate),
mFormat(format)
{
SetName(GetTitle());
{
// Create the main sizer
auto vs = std::make_unique<wxBoxSizer>(wxVERTICAL);
// A little instruction
wxStaticText *instruct =
safenew wxStaticText(this,
wxID_ANY,
_("Press F2 or double click to edit cell contents."));
instruct->SetName(instruct->GetLabel()); // fix for bug 577 (NVDA/Narrator screen readers do not read static text in dialogs)
vs->Add(instruct,
0,
wxALIGN_LEFT | wxALL,
5);
// Create the main sizer
mGrid = safenew Grid(this, wxID_ANY);
vs->Add(mGrid, 1, wxEXPAND | wxALL, 5);
// Create the action buttons
{
auto hs = std::make_unique<wxBoxSizer>(wxHORIZONTAL);
hs->Add(safenew wxButton(this, ID_INSERTA, _("Insert &After")), 1, wxCENTER | wxALL, 5);
hs->Add(safenew wxButton(this, ID_INSERTB, _("Insert &Before")), 1, wxCENTER | wxALL, 5);
hs->Add(safenew wxButton(this, ID_REMOVE, _("&Remove")), 1, wxCENTER | wxALL, 5);
hs->Add(safenew wxButton(this, ID_IMPORT, _("&Import...")), 1, wxCENTER | wxALL, 5);
hs->Add(safenew wxButton(this, ID_EXPORT, _("&Export...")), 1, wxCENTER | wxALL, 5);
vs->Add(hs.release(), 0, wxEXPAND | wxCENTER | wxALL, 5);
}
// Create the exit buttons
vs->Add(CreateStdButtonSizer(this, eCancelButton | eOkButton).release(), 0, wxEXPAND);
// Make it so
SetSizer(vs.release());
}
// Build the initial (empty) grid
mGrid->CreateGrid(0, Col_Max);
mGrid->SetDefaultCellAlignment(wxALIGN_LEFT, wxALIGN_CENTER);
/* i18n-hint: (noun). A track contains waves, audio etc.*/
mGrid->SetColLabelValue(0,_("Track"));
/* i18n-hint: (noun)*/
mGrid->SetColLabelValue(1,_("Label"));
/* i18n-hint: (noun) of a label*/
mGrid->SetColLabelValue(2,_("Start Time"));
/* i18n-hint: (noun) of a label*/
mGrid->SetColLabelValue(3,_("End Time"));
// Create and remember editors. No need to DELETE these as the wxGrid will
// do it for us. (The DecRef() that is needed after GetDefaultEditorForType
// becomes the duty of the wxGridCellAttr objects after we set them in the grid.)
mChoiceEditor = (ChoiceEditor *) mGrid->GetDefaultEditorForType(GRID_VALUE_CHOICE);
mTimeEditor = (TimeEditor *) mGrid->GetDefaultEditorForType(GRID_VALUE_TIME);
// Initialize and set the track name column attributes
wxGridCellAttr *attr;
mGrid->SetColAttr(Col_Track, (attr = safenew wxGridCellAttr));
attr->SetEditor(mChoiceEditor);
mTrackNames.Add(_("New..."));
// Initialize and set the time column attributes
mGrid->SetColAttr(Col_Stime, (attr = safenew wxGridCellAttr));
// Don't need DecRef() after this GetDefaultRendererForType.
attr->SetRenderer(mGrid->GetDefaultRendererForType(GRID_VALUE_TIME));
attr->SetEditor(mTimeEditor);
attr->SetAlignment(wxALIGN_CENTER, wxALIGN_CENTER);
mGrid->SetColAttr(Col_Etime, attr->Clone());
// Seems there's a bug in wxGrid. Adding only 1 row does not
// allow SetCellSize() to work properly and you will not get
// the expected 1 row by 4 column cell.
//
// So, we set the minimum row height to 0 and basically hide
// the extra row by setting its height to 0. And not allowing the
// rows to be manually resized prevents the user from ever seeing
// the extra row.
mGrid->SetRowMinimalAcceptableHeight(0);
mGrid->EnableDragRowSize(false);
// Locate all labels in current track list
FindAllLabels();
// Populate the grid
TransferDataToWindow();
// Resize the label name column and ensure it doesn't go below an
// arbitrary width.
//
// This should not be in TransferDataToWindow() since a user might
// resize the column and we'd resize it back to the minimum.
mGrid->AutoSizeColumn(Col_Label, false );
mGrid->SetColSize(Col_Label, wxMax(150, mGrid->GetColSize(Col_Label)));
mGrid->SetColMinimalWidth(Col_Label, mGrid->GetColSize(Col_Label));
// Layout the works
Layout();
// Resize width based on width of columns and the vertical scrollbar
wxRect r = mGrid->GetGridColLabelWindow()->GetRect();
wxScrollBar sb(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSB_VERTICAL);
r.width += sb.GetSize().GetWidth() + 6;
SetClientSize(r.width, 300);
// Make sure it doesn't go below this size
r = GetRect();
SetSizeHints(r.GetWidth(), r.GetHeight());
// Center on display
Center();
}