/** @brief UnRegisterElement
*
* @todo: document this function
*/
bool HashManager::UnRegisterElement(const HashType& Hash) {
if (ElementExists(Hash))
{
ElementsByString.erase(GetString(Hash));
ElementsByHash.erase(Hash);
return true;
}
return false;
}
/** @brief UnRegisterElement
*
* @todo: document this function
*/
bool HashManager::UnRegisterElement(const std::string& Name) {
if (ElementExists(Name))
{
ElementsByHash.erase(GetHash(Name));
ElementsByString.erase(Name);
return true;
}
return false;
}
Element* SequenceElements::AddElement(const std::string &name, const std::string &type,
bool visible,bool collapsed,bool active, bool selected)
{
if(!ElementExists(name))
{
mAllViews[MASTER_VIEW].push_back(new Element(this, name,type,visible,collapsed,active,selected));
Element *el = mAllViews[MASTER_VIEW][mAllViews[MASTER_VIEW].size()-1];
IncrementChangeCount(el);
return el;
}
return NULL;
}
Element* SequenceElements::AddElement(int index, const std::string &name,
const std::string &type,
bool visible,bool collapsed,bool active, bool selected)
{
if(!ElementExists(name) && index <= mAllViews[MASTER_VIEW].size())
{
mAllViews[MASTER_VIEW].insert(mAllViews[MASTER_VIEW].begin()+index,new Element(this, name,type,visible,collapsed,active,selected));
Element *el = mAllViews[MASTER_VIEW][index];
IncrementChangeCount(el);
return el;
}
return NULL;
}
SetHeadPtr Intersections(SetHeadPtr firstHead, SetHeadPtr secondHead)
{
SetHeadPtr newSetHead = CreateEmptySet();
for(ElementPtr current = firstHead->next; !IsOutOfRange(current); SetToNext(¤t))
{
if(ElementExists(secondHead, current))
{
AddElementToSet(newSetHead, CloneElement_withoutNext(current));
}
}
return newSetHead;
}
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 AddElementToSet(SetHeadPtr head, ElementPtr element)
{
if(!ElementExists(head, element))
{
ElementPtr current = head->next;
if (!IsOutOfRange(current) && IsLargerPowerThan(current, element))
{
for (; !IsLastElement(current) && IsLargerPowerThan(current->next, element); SetToNext(¤t));
element ->next = current->next;
current ->next = element;
}
else
{
element ->next = head->next;
head ->next = element;
}
}
}
/** @brief RegisterElement
*
* @todo: document this function
*/
bool HashManager::RegisterElement(const std::string& Name) {
if (!ElementExists(Name))
{
std::shared_ptr<HashedString> HS(new HashedString(Name.c_str()));
if (HS->getHashValue() == 0)
{
Engine::out(Engine::ERROR) << "HashManager: Element '" << Name << "' gives 0 (zero) as Hash, which is reserved!" << std::endl;
return false;
}
ElementsByString[Name] = HS;
ElementsByHash[HS->getHashValue()] = HS;
return true;
}
else
{
Engine::out(Engine::ERROR) << "HashManager: Element '" << Name << "' already exists" << std::endl;
return false;
}
}
bool SequenceElements::LoadSequencerFile(xLightsXmlFile& xml_file, const wxString &ShowDir)
{
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;
}
if (ElementExists(name))
{
log4cpp::Category &logger_base = log4cpp::Category::getInstance(std::string("log_base"));
logger_base.warn("Duplicate "+type+": '" + name + "'. Second instance ignored.");
wxMessageBox("Duplicate "+type+": '" + name + "'. Second instance ignored.", _("ERROR"));
}
else
{
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)
{
if (elementNode->GetNodeContent().Find("E_FILEPICKER_Pictures_Filename") >= 0)
{
elementNode->SetContent(xml_file.FixEffectFileParameter("E_FILEPICKER_Pictures_Filename", elementNode->GetNodeContent(), ShowDir));
}
else if (elementNode->GetNodeContent().Find("E_TEXTCTRL_Glediator_Filename") >= 0)
{
elementNode->SetContent(xml_file.FixEffectFileParameter("E_TEXTCTRL_Glediator_Filename", elementNode->GetNodeContent(), ShowDir));
}
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);
}
}
}
}
}
}
}
}
for (size_t x = 0; x < GetElementCount(); x++) {
Element *el = GetElement(x);
if (el->GetEffectLayerCount() == 0) {
el->AddEffectLayer();
}
}
// 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;
}
