void LMSImportChannelMapDialog::OnAddModelButtonClick(wxCommandEvent& event)
{
std::string name = ModelsChoice->GetStringSelection().ToStdString();
if (name == "") {
return;
}
ModelsChoice->Delete(ModelsChoice->GetSelection());
Element * model = nullptr;
for (size_t i=0;i<mSequenceElements->GetElementCount();i++) {
if (mSequenceElements->GetElement(i)->GetType() == "model"
&& name == mSequenceElements->GetElement(i)->GetName()) {
model = mSequenceElements->GetElement(i);
}
}
if (model == nullptr && allowAddModels) {
model = mSequenceElements->AddElement(name, "model", false, false, false, false);
model->AddEffectLayer();
}
if (model == nullptr) {
return;
}
modelNames.push_back(name);
Model *cls = xlights->GetModel(name);
AddModel(*cls);
Refresh();
_dirty = true;
}
void SequenceElements::AddMissingModelsToSequence(const std::string &models, bool visible)
{
if(models.length()> 0)
{
wxArrayString model=wxSplit(models,',');
for(size_t m=0;m<model.size();m++)
{
std::string modelName = model[m].ToStdString();
if(!ElementExists(modelName) && xframe->AllModels[modelName] != nullptr)
{
Element* elem = AddElement(modelName,"model",visible,false,false,false);
elem->AddEffectLayer();
}
}
}
}
void SequenceElements::AddMissingModelsToSequence(const std::string &models, bool visible)
{
if(models.length()> 0)
{
wxArrayString model=wxSplit(models,',');
for(int m=0;m<model.size();m++)
{
std::string modelName = model[m].ToStdString();
if(!ElementExists(modelName))
{
std::string elementType = "model";
Element* elem = AddElement(modelName,elementType,visible,false,false,false);
elem->AddEffectLayer();
}
}
}
}
void RowHeading::OnLayerPopup(wxCommandEvent& event)
{
Row_Information_Struct *ri = mSequenceElements->GetVisibleRowInformation(mSelectedRow);
Element* element = ri->element;
int layer_index = ri->layerIndex;
int id = event.GetId();
if(id == ID_ROW_MNU_INSERT_LAYER_ABOVE)
{
element->InsertEffectLayer(layer_index);
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
}
else if(id == ID_ROW_MNU_INSERT_LAYER_BELOW)
{
if( layer_index < element->GetEffectLayerCount()-1)
{
element->InsertEffectLayer(layer_index+1);
}
else
{
element->AddEffectLayer();
}
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
}
else if(id == ID_ROW_MNU_DELETE_LAYER)
{
int layerIndex = mSequenceElements->GetVisibleRowInformation(mSelectedRow)->layerIndex;
wxString prompt = wxString::Format("Delete 'Layer %d' of '%s'?",
layerIndex+1,element->GetName());
wxString caption = "Confirm Layer Deletion";
int answer = wxMessageBox(prompt,caption,wxYES_NO);
if(answer == wxYES)
{
element->RemoveEffectLayer(layerIndex);
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
}
}
else if(id == ID_ROW_MNU_ADD_TIMING_TRACK)
{
std::string name = wxGetTextFromUser("What is name of new timing track?", "Timing Track Name").ToStdString();
if( mSequenceElements->ElementExists(name) )
{
wxMessageBox("Timing name already exists in sequence as a model or another timing.", "ERROR");
}
else if(name.size()>0)
{
// Deactivate active timing mark so new one is selected;
mSequenceElements->DeactivateAllTimingElements();
int timingCount = mSequenceElements->GetNumberOfTimingElements();
Element* e = mSequenceElements->AddElement(timingCount,name,
"timing",true,false,true,false);
e->AddEffectLayer();
mSequenceElements->AddTimingToAllViews(name);
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
}
}
else if(id == ID_ROW_MNU_DELETE_TIMING_TRACK)
{
wxString prompt = wxString::Format("Delete 'Timing Track '%s'?",element->GetName());
wxString caption = "Confirm Timing Track Deletion";
int answer = wxMessageBox(prompt,caption,wxYES_NO);
if(answer == wxYES)
{
mSequenceElements->DeleteElement(element->GetName());
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
}
} else if(id == ID_ROW_MNU_IMPORT_TIMING_TRACK) {
wxCommandEvent playEvent(EVT_IMPORT_TIMING);
wxPostEvent(GetParent(), playEvent);
} else if(id == ID_ROW_MNU_IMPORT_LYRICS) {
mSequenceElements->ImportLyrics(element, GetParent());
} else if(id == ID_ROW_MNU_BREAKDOWN_TIMING_PHRASES) {
int result = wxMessageBox("Breakdown phrases? Any existing words and phonemes will be deleted.", "Confirm Action", wxOK | wxCANCEL | wxCENTER);
if (result == wxOK) {
BreakdownTimingPhrases(element);
}
} else if(id == ID_ROW_MNU_BREAKDOWN_TIMING_WORDS) {
int result = wxMessageBox("Breakdown words? Any existing phonemes will be deleted.", "Confirm Action", wxOK | wxCANCEL | wxCENTER);
if (result == wxOK) {
BreakdownTimingWords(element);
}
} else if (id == ID_ROW_MNU_EXPORT_MODEL) {
wxCommandEvent playEvent(EVT_EXPORT_MODEL);
playEvent.SetInt(0);
playEvent.SetString(element->GetName());
wxPostEvent(GetParent(), playEvent);
} else if (id == ID_ROW_MNU_EXPORT_RENDERED_MODEL) {
wxCommandEvent playEvent(EVT_EXPORT_MODEL);
playEvent.SetInt(1);
playEvent.SetString(element->GetName());
wxPostEvent(GetParent(), playEvent);
} else if (id == ID_ROW_MNU_PLAY_MODEL) {
wxCommandEvent playEvent(EVT_PLAY_MODEL);
playEvent.SetString(element->GetName());
wxPostEvent(GetParent(), playEvent);
} else if (id == ID_ROW_MNU_COPY_MODEL) {
wxCommandEvent copyModelEvent(EVT_COPY_MODEL_EFFECTS);
copyModelEvent.SetInt(mSelectedRow);
wxPostEvent(GetParent(), copyModelEvent);
mCanPaste = true;
} else if (id == ID_ROW_MNU_PASTE_MODEL) {
wxCommandEvent copyModelEvent(EVT_PASTE_MODEL_EFFECTS);
copyModelEvent.SetInt(mSelectedRow);
wxPostEvent(GetParent(), copyModelEvent);
} else if(id==ID_ROW_MNU_EDIT_DISPLAY_ELEMENTS) {
wxCommandEvent displayElementEvent(EVT_SHOW_DISPLAY_ELEMENTS);
wxPostEvent(GetParent(), displayElementEvent);
} else if (id == ID_ROW_MNU_TOGGLE_STRANDS) {
element->ShowStrands(!element->ShowStrands());
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
eventRowHeaderChanged.SetString(element->GetName());
wxPostEvent(GetParent(), eventRowHeaderChanged);
} else if (id == ID_ROW_MNU_TOGGLE_NODES) {
if (mSequenceElements->GetVisibleRowInformation(mSelectedRow)->strandIndex == -1) {
element->GetStrandLayer(0)->ShowNodes(true);
element->ShowStrands(!element->ShowStrands());
} else {
((StrandLayer*)mSequenceElements->GetVisibleEffectLayer(mSelectedRow))->ShowNodes(!((StrandLayer*)mSequenceElements->GetVisibleEffectLayer(mSelectedRow))->ShowNodes());
}
wxCommandEvent eventRowHeaderChanged(EVT_ROW_HEADINGS_CHANGED);
wxPostEvent(GetParent(), eventRowHeaderChanged);
} else if (id == ID_ROW_MNU_CONVERT_TO_EFFECTS) {
wxCommandEvent evt(EVT_CONVERT_DATA_TO_EFFECTS);
evt.SetClientData(element);
int i = ((ri->strandIndex << 16) & 0xFFFF0000) + ri->nodeIndex;
evt.SetInt(i);
wxPostEvent(GetParent(), evt);
} else if (id == ID_ROW_MNU_PROMOTE_EFFECTS) {
wxCommandEvent evt(EVT_PROMOTE_EFFECTS);
evt.SetClientData(element);
wxPostEvent(GetParent(), evt);
}
// Make sure message box is painted over by grid.
wxCommandEvent eventForceRefresh(EVT_FORCE_SEQUENCER_REFRESH);
wxPostEvent(GetParent(), eventForceRefresh);
}
bool SequenceElements::LoadSequencerFile(xLightsXmlFile& xml_file)
{
mFilename = xml_file;
wxXmlDocument& seqDocument = xml_file.GetXmlDocument();
wxXmlNode* root=seqDocument.GetRoot();
std::vector<std::string> effectStrings;
std::vector<std::string> colorPalettes;
Clear();
for(wxXmlNode* e=root->GetChildren(); e!=NULL; e=e->GetNext() )
{
if (e->GetName() == "DisplayElements")
{
for(wxXmlNode* element=e->GetChildren(); element!=NULL; element=element->GetNext() )
{
bool active=false;
bool selected=false;
bool collapsed=false;
std::string name = element->GetAttribute(STR_NAME).ToStdString();
std::string type = element->GetAttribute(STR_TYPE).ToStdString();
bool visible = element->GetAttribute("visible")=='1'?true:false;
if (type==STR_TIMING)
{
active = element->GetAttribute("active")=='1'?true:false;
}
else
{
collapsed = element->GetAttribute("collapsed")=='1'?true:false;
}
Element* elem = AddElement(name,type,visible,collapsed,active,selected);
if (type==STR_TIMING)
{
std::string views = element->GetAttribute("views", "").ToStdString();
elem->SetViews(views);
}
}
}
else if (e->GetName() == "EffectDB")
{
effectStrings.clear();
for(wxXmlNode* elementNode=e->GetChildren(); elementNode!=NULL; elementNode=elementNode->GetNext() )
{
if(elementNode->GetName()==STR_EFFECT)
{
effectStrings.push_back(elementNode->GetNodeContent().ToStdString());
}
}
}
else if (e->GetName() == "ColorPalettes")
{
colorPalettes.clear();
for(wxXmlNode* elementNode=e->GetChildren(); elementNode!=NULL; elementNode=elementNode->GetNext() )
{
if(elementNode->GetName() == STR_COLORPALETTE)
{
colorPalettes.push_back(elementNode->GetNodeContent().ToStdString());
}
}
}
else if (e->GetName() == "ElementEffects")
{
for(wxXmlNode* elementNode=e->GetChildren(); elementNode!=NULL; elementNode=elementNode->GetNext() )
{
if(elementNode->GetName()==STR_ELEMENT)
{
Element* element = GetElement(elementNode->GetAttribute(STR_NAME).ToStdString());
if (element !=NULL)
{
// check for fixed timing interval
int interval = 0;
if( elementNode->GetAttribute(STR_TYPE) == STR_TIMING )
{
interval = wxAtoi(elementNode->GetAttribute("fixed"));
}
if( interval > 0 )
{
element->SetFixedTiming(interval);
EffectLayer* effectLayer = element->AddEffectLayer();
int time = 0;
int end_time = xml_file.GetSequenceDurationMS();
int startTime, endTime, next_time;
while( time <= end_time )
{
next_time = (time + interval <= end_time) ? time + interval : end_time;
startTime = TimeLine::RoundToMultipleOfPeriod(time,mFrequency);
endTime = TimeLine::RoundToMultipleOfPeriod(next_time,mFrequency);
effectLayer->AddEffect(0,"","","",startTime,endTime,EFFECT_NOT_SELECTED,false);
time += interval;
}
}
else
{
for(wxXmlNode* effectLayerNode=elementNode->GetChildren(); effectLayerNode!=NULL; effectLayerNode=effectLayerNode->GetNext())
{
if (effectLayerNode->GetName() == STR_EFFECTLAYER || effectLayerNode->GetName() == STR_STRAND)
{
EffectLayer* effectLayer = NULL;
if (effectLayerNode->GetName() == STR_EFFECTLAYER) {
effectLayer = element->AddEffectLayer();
} else {
effectLayer = element->GetStrandLayer(wxAtoi(effectLayerNode->GetAttribute(STR_INDEX)), true);
if (effectLayerNode->GetAttribute(STR_NAME, STR_EMPTY) != STR_EMPTY) {
((StrandLayer*)effectLayer)->SetName(effectLayerNode->GetAttribute(STR_NAME).ToStdString());
}
}
LoadEffects(effectLayer, elementNode->GetAttribute(STR_TYPE).ToStdString(), effectLayerNode, effectStrings, colorPalettes);
}
}
}
}
}
}
}
}
// Select view and set current view models as visible
int last_view = xml_file.GetLastView();
for(wxXmlNode* view=mViewsNode->GetChildren(); view!=NULL; view=view->GetNext() )
{
std::string viewName = view->GetAttribute(STR_NAME).ToStdString();
std::string models = view->GetAttribute("models").ToStdString();
std::vector <Element*> new_view;
mAllViews.push_back(new_view);
int view_index = mAllViews.size()-1;
if( view_index == last_view )
{
AddMissingModelsToSequence(models);
PopulateView(models, view_index);
SetCurrentView(view_index);
}
}
if (mModelsNode != nullptr) {
PopulateRowInformation();
}
// Set to the first model/view
mFirstVisibleModelRow = 0;
return true;
}
void DisplayElementsPanel::OnButtonAddModelsClick(wxCommandEvent& event)
{
if (mSeqData->NumFrames() == 0) return;
ModelViewSelector dialog(this);
dialog.SetSequenceElementsModelsViews(mSequenceElements,mModels,mModelGroups,mViews, mSequenceElements->GetCurrentView());
std::string type = "model";
int current_view = mSequenceElements->GetCurrentView();
dialog.Initialize();
dialog.CenterOnParent();
int DlgResult = dialog.ShowModal();
if(DlgResult==wxID_OK)
{
if( current_view == MASTER_VIEW )
{
for(int i=0;i<dialog.ModelsToAdd.size();i++)
{
Element* e = mSequenceElements->AddElement(dialog.ModelsToAdd[i],type,true,false,false,false);
e->AddEffectLayer();
}
}
else
{
int view_index = 1;
for(wxXmlNode* view=mViews->GetChildren(); view!=NULL; view=view->GetNext() )
{
std::string viewName = view->GetAttribute("name").ToStdString();
if( view_index == current_view )
{
std::string models = view->GetAttribute("models").ToStdString();
for(int i=0;i<dialog.ModelsToAdd.size();i++)
{
if( models != "" )
{
models += ",";
}
models += dialog.ModelsToAdd[i];
}
mSequenceElements->AddMissingModelsToSequence(models);
for(int i=0;i<dialog.ModelsToAdd.size();i++)
{
Element* elem = mSequenceElements->GetElement(dialog.ModelsToAdd[i]);
if( elem != nullptr )
{
elem->SetVisible(true);
}
}
view->DeleteAttribute("models");
view->AddAttribute("models", models);
std::string modelsString = mSequenceElements->GetViewModels(viewName);
mSequenceElements->PopulateView(modelsString, current_view);
mSequenceElements->AddViewToTimings(dialog.TimingsToAdd, viewName);
mSequenceElements->SetTimingVisibility(viewName);
break;
}
view_index++;
}
}
MarkViewsChanged();
PopulateModels();
// Update Grid
wxCommandEvent eventForceRefresh(EVT_FORCE_SEQUENCER_REFRESH);
wxPostEvent(GetParent(), eventForceRefresh);
}
}
void LMSImportChannelMapDialog::LoadMapping(wxCommandEvent& event)
{
bool strandwarning = false;
bool modelwarning = false;
if (_dirty)
{
if (wxMessageBox("Are you sure you dont want to save your changes for future imports?", "Are you sure?", wxYES_NO | wxCENTER, this) == wxNO)
{
return;
}
}
wxFileDialog dlg(this);
if (dlg.ShowModal() == wxID_OK) {
for (size_t x = 0; x < modelNames.size(); x++) {
ModelsChoice->Append(modelNames[x]);
}
ChannelMapGrid->BeginBatch();
wxFileInputStream input(dlg.GetPath());
wxTextInputStream text(input, "\t");
MapByStrand->SetValue("true" == text.ReadLine());
int count = wxAtoi(text.ReadLine());
modelNames.clear();
for (int x = 0; x < count; x++) {
std::string mn = text.ReadLine().ToStdString();
int idx = ModelsChoice->FindString(mn);
if (idx == wxNOT_FOUND) {
//wxMessageBox("Model " + mn + " not part of sequence. Not mapping channels to this model.", "", wxICON_WARNING | wxOK , this);
if (!modelwarning)
{
if (wxMessageBox("Model " + mn + " not part of sequence. Not mapping channels to this model. Do you want to see future occurences of this error during this import?", "", wxICON_WARNING | wxYES_NO, this) == wxNO)
{
modelwarning = true;
}
}
} else {
ModelsChoice->Delete(idx);
modelNames.push_back(mn);
}
}
if (MapByStrand->GetValue()) {
SetupByStrand();
} else {
SetupByNode();
}
wxString line = text.ReadLine();
int r = 0;
while (line != "") {
wxString model = FindTab(line);
wxString strand = FindTab(line);
wxString node = FindTab(line);
wxString mapping = FindTab(line);
xlColor color(FindTab(line));
Element *modelEl = mSequenceElements->GetElement(model.ToStdString());
if (modelEl == nullptr && allowAddModels) {
modelEl = mSequenceElements->AddElement(model.ToStdString(), "model", false, false, false, false);
modelEl->AddEffectLayer();
}
if (modelEl != nullptr) {
while (model != ChannelMapGrid->GetCellValue(r, 0)
&& r < ChannelMapGrid->GetNumberRows()) {
r++;
}
if (model != ChannelMapGrid->GetCellValue(r, 0)
|| strand != ChannelMapGrid->GetCellValue(r, 1)
|| node != ChannelMapGrid->GetCellValue(r, 2)) {
if (!strandwarning)
{
if (wxMessageBox(model + "/" + strand + "/" + node + " not found. Has the models changed? Do you want to see future occurences of this error during this import?", "", wxICON_WARNING | wxYES_NO, this) == wxNO)
{
strandwarning = true;
}
}
} else {
ChannelMapGrid->SetCellValue(r, 3, mapping);
ChannelMapGrid->SetCellBackgroundColour(r, 4, color.asWxColor());
}
r++;
}
line = text.ReadLine();
}
ChannelMapGrid->EndBatch();
_dirty = false;
}
}
