CfgMgrBldr::CfgMgrBldr() : doc(nullptr), volatile_doc(nullptr), r(false)
{
ConfigManager::MigrateFolders();
TiXmlBase::SetCondenseWhiteSpace(false);
wxString personality(Manager::Get()->GetPersonalityManager()->GetPersonality());
if (personality.StartsWith(_T("http://")))
{
SwitchToR(personality);
return;
}
cfg = FindConfigFile(personality + _T(".conf"));
if (cfg.IsEmpty())
{
cfg = ConfigManager::GetConfigFolder() + wxFILE_SEP_PATH + personality + _T(".conf");
doc = new TiXmlDocument();
doc->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
doc->InsertEndChild(TiXmlElement("CodeBlocksConfig"));
doc->FirstChildElement("CodeBlocksConfig")->SetAttribute("version", CfgMgrConsts::version);
return;
}
SwitchTo(cfg);
}
CfgMgrBldr::CfgMgrBldr() : doc(nullptr), volatile_doc(nullptr), r(false)
{
TiXmlBase::SetCondenseWhiteSpace(false);
wxString personality(Manager::Get()->GetPersonalityManager()->GetPersonality());
if (personality.StartsWith(_T("http://")))
{
SwitchToR(personality);
return;
}
cfg = FindConfigFile(personality + _T(".conf"));
if (cfg.IsEmpty())
{
#ifdef __WINDOWS__
cfg = GetPortableConfigDir() + wxFILE_SEP_PATH + personality + _T(".conf");
#else
cfg = wxStandardPathsBase::Get().GetUserDataDir() + wxFILE_SEP_PATH + personality + _T(".conf");
#endif
doc = new TiXmlDocument();
doc->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
doc->InsertEndChild(TiXmlElement("CodeBlocksConfig"));
doc->FirstChildElement("CodeBlocksConfig")->SetAttribute("version", CfgMgrConsts::version);
return;
}
SwitchTo(cfg);
}
void Profile::read_from_configuration (Configuration* configuration)
{
TiXmlNode* node = 0;
// insert initial mandatory declaration if not present
TiXmlNode* decl = 0;
for (TiXmlNode* child = xmlProfileDoc->FirstChild();
child && !decl; child = child->NextSibling() ) {
decl = child->ToDeclaration ();
}
if (! decl) {
node = xmlProfileDoc->InsertEndChild( TiXmlDeclaration( "1.0", "UTF-8", "no" ) );
assert (node);
}
// for each configuration variable in configuration
for (std::map<std::string, Variable*>::const_iterator conf_it = configuration->begin();
conf_it != configuration->end();
conf_it ++) {
// start from root of DOM
node = xmlProfileDoc;
// get the variable name and break it up in its component vector
std::string variable_name = conf_it->second->get_name ();
std::vector<std::string> variable_name_vector = Variable::string_to_vector (variable_name);
// for each component in variable name vector
for (size_t i = 0; i < variable_name_vector.size(); i++) {
// check if component element exists
TiXmlElement* existing = node->FirstChildElement (variable_name_vector[i].c_str());
if (existing) {
// carry on with existing component
node = existing;
} else {
// create missing component element and carry on with new component
node = node->InsertEndChild (TiXmlElement (variable_name_vector[i].c_str()));
assert (node);
}
}
// check if a text node for element exists
TiXmlText* text = 0;
for(TiXmlNode* child = node->FirstChild(); child && !text; child = child->NextSibling() ) {
text = child->ToText ();
}
if (text) {
// text child already exists, so remove it to set new value
node->RemoveChild (text);
}
node = node->InsertEndChild (TiXmlText (conf_it->second->get_value ().c_str ()));
assert (node);
}
}
TiXmlElement* CXmlFile::CreateEmpty()
{
delete m_pDocument;
m_pDocument = new TiXmlDocument();
m_pDocument->SetCondenseWhiteSpace(false);
m_pDocument->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
return m_pDocument->InsertEndChild(TiXmlElement("FileZilla3"))->ToElement();
}
// Opens the specified XML file if it exists or creates a new one otherwise.
// Returns 0 on error.
TiXmlElement* GetXmlFile(wxFileName file)
{
if (wxFileExists(file.GetFullPath()) && file.GetSize() > 0)
{
// File does exist, open it
TiXmlDocument* pXmlDocument = new TiXmlDocument();
pXmlDocument->SetCondenseWhiteSpace(false);
if (!pXmlDocument->LoadFile(file.GetFullPath().mb_str()))
{
delete pXmlDocument;
return 0;
}
if (!pXmlDocument->FirstChildElement("FileZilla3"))
{
delete pXmlDocument;
return 0;
}
TiXmlElement* pElement = pXmlDocument->FirstChildElement("FileZilla3");
if (!pElement)
{
delete pXmlDocument;
return 0;
}
else
return pElement;
}
else
{
// File does not exist, create new XML document
TiXmlDocument* pXmlDocument = new TiXmlDocument();
pXmlDocument->SetCondenseWhiteSpace(false);
pXmlDocument->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
pXmlDocument->InsertEndChild(TiXmlElement("FileZilla3"));
if (!pXmlDocument->SaveFile(file.GetFullPath().mb_str()))
{
delete pXmlDocument;
return 0;
}
return pXmlDocument->FirstChildElement("FileZilla3");
}
}
bool WorkspaceLoader::Save(const wxString& title, const wxString& filename)
{
const char* ROOT_TAG = "CodeBlocks_workspace_file";
TiXmlDocument doc;
doc.SetCondenseWhiteSpace(false);
doc.InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
TiXmlElement* rootnode = static_cast<TiXmlElement*>(doc.InsertEndChild(TiXmlElement(ROOT_TAG)));
if (!rootnode)
return false;
TiXmlElement* wksp = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("Workspace")));
wksp->SetAttribute("title", cbU2C(title));
ProjectsArray* arr = Manager::Get()->GetProjectManager()->GetProjects();
for (unsigned int i = 0; i < arr->GetCount(); ++i)
{
cbProject* prj = arr->Item(i);
wxFileName wfname(filename);
wxFileName fname(prj->GetFilename());
fname.MakeRelativeTo(wfname.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR));
TiXmlElement* node = static_cast<TiXmlElement*>(wksp->InsertEndChild(TiXmlElement("Project")));
node->SetAttribute("filename", cbU2C( ExportFilename(fname) ) );
if (prj == Manager::Get()->GetProjectManager()->GetActiveProject())
node->SetAttribute("active", 1);
const ProjectsArray* deps = Manager::Get()->GetProjectManager()->GetDependenciesForProject(prj);
if (deps && deps->GetCount())
{
for (size_t i = 0; i < deps->GetCount(); ++i)
{
prj = deps->Item(i);
fname.Assign(prj->GetFilename());
fname.MakeRelativeTo(wfname.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR));
TiXmlElement* dnode = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Depends")));
dnode->SetAttribute("filename", cbU2C( ExportFilename(fname) ) );
}
}
}
return cbSaveTinyXMLDocument(&doc, filename);
}
bool CAddonMgr::LoadAddonDescriptionFromMemory(const TiXmlElement *root, AddonPtr &addon)
{
// create a context for these addons
cp_status_t status;
cp_context_t *context = m_cpluff->create_context(&status);
if (!root || !context)
return false;
// dump the XML back to text
std::string xml;
xml << TiXmlDeclaration("1.0", "UTF-8", "");
xml << *root;
cp_plugin_info_t *info = m_cpluff->load_plugin_descriptor_from_memory(context, xml.c_str(), xml.size(), &status);
if (info)
{
addon = GetAddonFromDescriptor(info);
m_cpluff->release_info(context, info);
}
m_cpluff->destroy_context(context);
return addon != NULL;
}
TiXmlNode* TiXmlNode::Identify( const char* p, TiXmlEncoding encoding )
{
TiXmlNode* returnNode = 0;
p = SkipWhiteSpace( p, encoding );
if( !p || !*p || *p != '<' )
{
return 0;
}
p = SkipWhiteSpace( p, encoding );
if ( !p || !*p )
{
return 0;
}
// What is this thing?
// - Elements start with a letter or underscore, but xml is reserved.
// - Comments: <!--
// - Decleration: <?xml
// - Everthing else is unknown to tinyxml.
//
const char* xmlHeader = { "<?xml" };
const char* commentHeader = { "<!--" };
const char* dtdHeader = { "<!" };
const char* cdataHeader = { "<![CDATA[" };
if ( StringEqual( p, xmlHeader, true, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Declaration\n" );
#endif
returnNode = NEW TiXmlDeclaration();
}
else if ( StringEqual( p, commentHeader, false, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Comment\n" );
#endif
returnNode = NEW TiXmlComment();
}
else if ( StringEqual( p, cdataHeader, false, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing CDATA\n" );
#endif
TiXmlText* text = NEW TiXmlText( "" );
text->SetCDATA( true );
returnNode = text;
}
else if ( StringEqual( p, dtdHeader, false, encoding ) )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Unknown(1)\n" );
#endif
returnNode = NEW TiXmlUnknown();
}
else if ( IsAlpha( *(p+1), encoding )
|| *(p+1) == '_' )
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Element\n" );
#endif
returnNode = NEW TiXmlElement( "" );
}
else
{
#ifdef DEBUG_PARSER
TIXML_LOG( "XML parsing Unknown(2)\n" );
#endif
returnNode = NEW TiXmlUnknown();
}
if ( returnNode )
{
// Set the parent, so it can report errors
returnNode->parent = this;
}
return returnNode;
}
bool ProjectLayoutLoader::Save(const wxString& filename)
{
const char* ROOT_TAG = "CodeBlocks_layout_file";
TiXmlDocument doc;
doc.SetCondenseWhiteSpace(false);
doc.InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
TiXmlElement* rootnode = static_cast<TiXmlElement*>(doc.InsertEndChild(TiXmlElement(ROOT_TAG)));
if (!rootnode)
return false;
rootnode->InsertEndChild(TiXmlElement("FileVersion"));
rootnode->FirstChildElement("FileVersion")->SetAttribute("major", PROJECT_LAYOUT_FILE_VERSION_MAJOR);
rootnode->FirstChildElement("FileVersion")->SetAttribute("minor", PROJECT_LAYOUT_FILE_VERSION_MINOR);
TiXmlElement* tgtidx = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("ActiveTarget")));
tgtidx->SetAttribute("name", cbU2C(m_pProject->GetActiveBuildTarget()));
ProjectFile* active = nullptr;
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if (ed)
active = ed->GetProjectFile();
for (FilesList::iterator it = m_pProject->GetFilesList().begin(); it != m_pProject->GetFilesList().end(); ++it)
{
ProjectFile* f = *it;
if (f->editorOpen || f->editorPos || f->editorPos_2 || f->editorTopLine || f->editorTopLine_2 || f->editorTabPos)
{
TiXmlElement* node = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("File")));
node->SetAttribute("name", cbU2C(f->relativeFilename));
node->SetAttribute("open", f->editorOpen);
node->SetAttribute("top", (f == active));
node->SetAttribute("tabpos", f->editorTabPos);
node->SetAttribute("split", f->editorSplit);
node->SetAttribute("active", f->editorSplitActive);
node->SetAttribute("splitpos", f->editorSplitPos);
node->SetAttribute("zoom_1", f->editorZoom);
node->SetAttribute("zoom_2", f->editorZoom_2);
TiXmlElement* cursor = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Cursor")));
TiXmlElement* cursor_1 = static_cast<TiXmlElement*>(cursor->InsertEndChild(TiXmlElement("Cursor1")));
cursor_1->SetAttribute("position", f->editorPos);
cursor_1->SetAttribute("topLine", f->editorTopLine);
if(f->editorSplit != cbEditor::stNoSplit)
{
TiXmlElement* cursor_2 = static_cast<TiXmlElement*>(cursor->InsertEndChild(TiXmlElement("Cursor2")));
cursor_2->SetAttribute("position", f->editorPos_2);
cursor_2->SetAttribute("topLine", f->editorTopLine_2);
}
if (f->editorFoldLinesArray.GetCount() > 0)
{
TiXmlElement* folding = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Folding")));
for (unsigned int i = 0; i < f->editorFoldLinesArray.GetCount(); i++)
{
TiXmlElement* line = static_cast<TiXmlElement*>(folding->InsertEndChild(TiXmlElement("Collapse")));
line->SetAttribute("line", f->editorFoldLinesArray[i]);
}
}
}
}
const wxArrayString& en = m_pProject->ExpandedNodes();
for (unsigned int i = 0; i < en.GetCount(); ++i)
{
if (!en[i].IsEmpty())
{
TiXmlElement* node = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("Expand")));
node->SetAttribute("folder", cbU2C(en[i]));
}
}
if (Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/enable_editor_layout"), false))
{
TiXmlElement *el =
static_cast<TiXmlElement*>(
rootnode->InsertEndChild( TiXmlElement("EditorTabsLayout") ) );
el->SetAttribute("layout", cbU2C( Manager::Get()->GetEditorManager()->GetNotebook()->SavePerspective(m_pProject->GetTitle()) ));
}
// else ?!
return cbSaveTinyXMLDocument(&doc, filename);
}
void CfgMgrBldr::SwitchTo(const wxString& fileName)
{
doc = new TiXmlDocument();
if (!TinyXML::LoadDocument(fileName, doc))
{
doc->InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
doc->InsertEndChild(TiXmlElement("CodeBlocksConfig"));
doc->FirstChildElement("CodeBlocksConfig")->SetAttribute("version", CfgMgrConsts::version);
}
if (doc->ErrorId())
cbThrow(wxString::Format(_T("TinyXML error: %s\nIn file: %s\nAt row %d, column: %d."), cbC2U(doc->ErrorDesc()).c_str(), fileName.c_str(), doc->ErrorRow(), doc->ErrorCol()));
TiXmlElement* docroot = doc->FirstChildElement("CodeBlocksConfig");
if (doc->ErrorId())
cbThrow(wxString::Format(_T("TinyXML error: %s\nIn file: %s\nAt row %d, column: %d."), cbC2U(doc->ErrorDesc()).c_str(), fileName.c_str(), doc->ErrorRow(), doc->ErrorCol()));
const char *vers = docroot->Attribute("version");
if (!vers || atoi(vers) != 1)
cbMessageBox(_("ConfigManager encountered an unknown config file version. Continuing happily."), _("Warning"), wxICON_WARNING);
doc->ClearError();
wxString info;
#ifndef __GNUC__
info.Printf(_T( " application info:\n"
"\t svn_revision:\t%u\n"
"\t build_date:\t%s, %s "), ConfigManager::GetRevisionNumber(), wxT(__DATE__), wxT(__TIME__));
#else
info.Printf(_T( " application info:\n"
"\t svn_revision:\t%u\n"
"\t build_date:\t%s, %s\n"
"\t gcc_version:\t%d.%d.%d "), ConfigManager::GetRevisionNumber(), wxT(__DATE__), wxT(__TIME__),
__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
#endif
if (platform::windows)
info.append(_T("\n\t Windows "));
if (platform::linux)
info.append(_T("\n\t Linux "));
if (platform::macosx)
info.append(_T("\n\t Mac OS X "));
if (platform::unix)
info.append(_T("\n\t Unix "));
info.append(platform::unicode ? _T("Unicode ") : _T("ANSI "));
TiXmlComment c;
c.SetValue((const char*) info.mb_str());
TiXmlNode *firstchild = docroot->FirstChild();
if (firstchild && firstchild->ToComment())
{
docroot->RemoveChild(firstchild);
firstchild = docroot->FirstChild();
}
if (firstchild)
docroot->InsertBeforeChild(firstchild, c);
else
docroot->InsertEndChild(c);
}
// ----------------------------------------------------------------------------
bool BrowseTrackerLayout::Save(const wxString& filename, FileBrowse_MarksHash& m_FileBrowse_MarksArchive, FileBrowse_MarksHash& m_EdBook_MarksArchive)
// ----------------------------------------------------------------------------
{
////DumpBrowse_Marks(wxT("BookMarks"), m_FileBrowse_MarksArchive, m_EdBook_MarksArchive);
const char* ROOT_TAG = "BrowseTracker_layout_file";
TiXmlDocument doc;
doc.SetCondenseWhiteSpace(false);
doc.InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
TiXmlElement* rootnode = static_cast<TiXmlElement*>(doc.InsertEndChild(TiXmlElement(ROOT_TAG)));
if (!rootnode)
return false;
TiXmlElement* tgtidx = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("ActiveTarget")));
tgtidx->SetAttribute("name", cbU2C(m_pProject->GetActiveBuildTarget()));
ProjectFile* active = 0L;
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if (ed)
active = ed->GetProjectFile();
int count = m_pProject->GetFilesCount();
for (int i = 0; i < count; ++i)
{
ProjectFile* f = m_pProject->GetFile(i);
if (f->editorOpen || f->editorPos || f->editorTopLine || f->editorTabPos)
{
TiXmlElement* node = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("File")));
node->SetAttribute("name", cbU2C(f->relativeFilename));
node->SetAttribute("open", f->editorOpen);
node->SetAttribute("top", (f == active));
node->SetAttribute("tabpos", f->editorTabPos);
TiXmlElement* cursor = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Cursor")));
cursor->SetAttribute("position", f->editorPos);
cursor->SetAttribute("topLine", f->editorTopLine);
EditorBase* eb = 0;
// write out a string of browse mark positions
#if defined(LOGGING)
////LOGIT( _T("ProjectFilename[%s]"),f->file.GetFullPath().c_str() );
#endif
eb = Manager::Get()->GetEditorManager()->GetEditor(f->file.GetFullPath());
#if defined(LOGGING)
////if (eb) LOGIT( _T("EditorBase Filename[%d][%s]"), i, eb->GetFilename().c_str() );
#endif
////if(eb) if (f->file.GetFullPath() != eb->GetFilename())
////{
//// #if defined(LOGGING)
//// LOGIT( _T("NAME MISSMATCH ProjectFile[%s]EditorBase[%s]"), f->file.GetFullPath().c_str(), eb->GetFilename().c_str() );
//// #endif
////}
//// #if defined(LOGGING)
//// if (m_FileBrowse_MarksArchive.find(eb) != m_FileBrowse_MarksArchive.end() )
//// LOGIT( _T("Found eb[%p][%s]"), eb, eb->GetShortName().c_str() );
//// else{
//// int i = 0;
//// for (EbBrowse_MarksHash::iterator it = m_FileBrowse_MarksArchive.begin();
//// it != m_FileBrowse_MarksArchive.end(); ++it)
//// {
//// #if defined(LOGGING)
//// LOGIT( _T("m_FileBrowse_MarksArchive[i][%d][%p]"), i, it->first );
//// #endif
//// ++i;
//// }
//// }
//// #endif
#if defined(LOGGING)
////LOGIT( _T("Layout processing for[%s]"),/*f->relativeFilename.c_str(),*/ f->file.GetFullPath().c_str() );
#endif
// Save the BrowseMarks
FileBrowse_MarksHash::iterator it = m_FileBrowse_MarksArchive.find(f->file.GetFullPath());
if (it != m_FileBrowse_MarksArchive.end() ) do
{
BrowseMarks* pBrowse_Marks = it->second;
if (not pBrowse_Marks) break;
wxString browseMarks = pBrowse_Marks->GetStringOfBrowse_Marks();
#if defined(LOGGING)
////LOGIT( _T("Layout writing BROWSEMarkString [%p]is[%s]"), pBrowse_Marks, browseMarks.c_str());
#endif
TiXmlElement* btMarks = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("BrowseMarks")));
btMarks->SetAttribute("positions", cbU2C(browseMarks));
}while(0);
////else{
//// #if defined(LOGGING)
//// LOGIT( _T("Browse_Marks failed find for[%s]"), f->file.GetFullPath().c_str() );
//// #endif
////}
// Save the Book_Marks
it = m_EdBook_MarksArchive.find(f->file.GetFullPath());
if (it != m_EdBook_MarksArchive.end() ) do
{
BrowseMarks* pBook_Marks = it->second;
if (not pBook_Marks) break;
wxString bookMarks = pBook_Marks->GetStringOfBrowse_Marks();
#if defined(LOGGING)
////LOGIT( _T("Layout writing BOOKMarkString [%p]is[%s]"), pBook_Marks, bookMarks.c_str());
#endif
TiXmlElement* btMarks = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Book_Marks")));
btMarks->SetAttribute("positions", cbU2C(bookMarks));
}while(0);
////else{
//// #if defined(LOGGING)
//// LOGIT( _T("Book_Marks failed find for[%s]"), f->file.GetFullPath().c_str() );
//// #endif
////}
}
}//for
const wxArrayString& en = m_pProject->ExpandedNodes();
for (unsigned int i = 0; i < en.GetCount(); ++i)
{
if (!en[i].IsEmpty())
{
TiXmlElement* node = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("Expand")));
node->SetAttribute("folder", cbU2C(en[i]));
}
}
return cbSaveTinyXMLDocument(&doc, filename);
}
/** Create new profile with default values.
*
*/
void ProfileManager::buildProfile(const std::string p)
{
TiXmlNode* root;
TiXmlNode* node;
TiXmlNode* module;
TiXmlNode* element;
// Create document
delete xmlProfileDoc;
xmlProfileDoc = new TiXmlDocument(p.c_str());
// Insert initial mandatory declaration
node = xmlProfileDoc->InsertEndChild( TiXmlDeclaration( "1.0", "UTF-8", "no" ) );
assert( node );
// Insert root element
root = xmlProfileDoc->InsertEndChild( TiXmlElement( "Presage" ) );
assert( root );
// PluginRegistry module
module = root->InsertEndChild( TiXmlElement( "PluginRegistry" ) );
assert( module );
if( module ) {
element = module->InsertEndChild(TiXmlElement("LOGGER"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_LOGGER_LEVEL;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "PLUGINS" ) );
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_PLUGINS;
node = element->InsertEndChild(TiXmlText( ss.str().c_str() ));
assert( node );
}
}
// ContextTracker module
module = root->InsertEndChild( TiXmlElement( "ContextTracker" ) );
assert( module );
if( module ) {
element = module->InsertEndChild(TiXmlElement("LOGGER"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_LOGGER_LEVEL;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "SLIDING_WINDOW_SIZE" ) );
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_SLIDING_WINDOW_SIZE;
node = element->InsertEndChild(TiXmlText( ss.str().c_str() ));
assert( node );
}
}
// Selector module
module = root->InsertEndChild( TiXmlElement( "Selector" ) );
assert( module );
if( module ) {
element = module->InsertEndChild(TiXmlElement("LOGGER"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_LOGGER_LEVEL;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild(TiXmlElement("SUGGESTIONS"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_SUGGESTIONS;
node = element->InsertEndChild(TiXmlText( ss.str().c_str() ));
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "REPEAT_SUGGESTIONS" ) );
assert( element );
if( element ) {
node = element->InsertEndChild( TiXmlText( "no" ) );
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "GREEDY_SUGGESTION_THRESHOLD" ) );
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_GREEDY_SUGGESTION_THRESHOLD;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
}
// PredictorActivator module
module = root->InsertEndChild( TiXmlElement( "PredictorActivator" ) );
assert( module );
if( module ) {
element = module->InsertEndChild(TiXmlElement("LOGGER"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_LOGGER_LEVEL;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild(TiXmlElement("PREDICT_TIME"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_PREDICT_TIME;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild(TiXmlElement("MAX_PARTIAL_PREDICTION_SIZE"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_MAX_PARTIAL_PREDICTION_SIZE;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "COMBINATION_POLICY" ) );
assert( element );
if( element ) {
std::stringstream ss;
ss << DEFAULT_COMBINATION_POLICY;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "PLUGINS" ) );
assert( element );
if( element ) {
std::stringstream ss;
ss << DEFAULT_PREDICTIVE_PLUGINS;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
}
// ProfileManager module
module = root->InsertEndChild( TiXmlElement( "ProfileManager" ) );
assert( module );
if( module ) {
element = module->InsertEndChild(TiXmlElement("LOGGER"));
assert( element );
if( element ) {
std::ostringstream ss;
ss << DEFAULT_LOGGER_LEVEL;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
}
//PLUMP
/*
// PluginManager module
module = root->InsertEndChild( TiXmlElement( "PluginManager" ) );
assert( module );
if( module ) {
element = module->InsertEndChild( TiXmlElement( "PLUGIN_PATH" ) );
assert( element );
if( element ) {
std::stringstream ss;
ss << DEFAULT_PLUGIN_PATH;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
element = module->InsertEndChild( TiXmlElement( "PLUGIN_SUFFIX" ) );
assert( element );
if( element ) {
std::stringstream ss;
ss << DEFAULT_PLUGIN_SUFFIX;
node = element->InsertEndChild( TiXmlText( ss.str().c_str() ) );
assert( node );
}
}
*/
// Plugin modules
module = root->InsertEndChild( TiXmlElement( "Plugins" ) );
assert( module );
if( module ) {
// handled by PluginManager object
//PLUMP pluginManager.createProfile( module );
}
// print out doc for debug purposes
// result.Print();
}
BOOL CheckValidXML(TiXmlDocument *pDoc)
{
if( pDoc->LoadFile(DEFAULT_BBS_WIFI_MANAGER_CONFIGXML_PATH_A) == FALSE )
{
pDoc->InsertEndChild( TiXmlDeclaration("1.0", "UTF-8", "") );
// 저장하려는 파일의 전체 경로중 없는 폴더가 있다면 폴더 자동생성
CreateFolderIfNotFoundDir(DEFAULT_BBS_WIFI_MANAGER_CONFIGXML_PATH_W);
// XML 파일형태로 저장.
if( pDoc->SaveFile(DEFAULT_BBS_WIFI_MANAGER_CONFIGXML_PATH_A) == FALSE )
{
return FALSE;
}
}
TiXmlNode *pNode = pDoc->FirstChild("BBS_WiFiConfig");
if(pNode == NULL)
{
TiXmlElement* pElem = new TiXmlElement("BBS_WiFiConfig");
pDoc->LinkEndChild( pElem );
pDoc->SaveFile();
}
pNode = pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting");
if(pNode == NULL)
{
TiXmlElement* pElem = new TiXmlElement("Setting");
pDoc->FirstChild("BBS_WiFiConfig")->LinkEndChild( pElem );
pDoc->SaveFile();
}
pNode = pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting")->FirstChild("Option");
if(pNode == NULL)
{
TiXmlElement* pElem = new TiXmlElement("Option");
pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting")->LinkEndChild( pElem );
pDoc->SaveFile();
}
pNode = pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting")->FirstChild("Option")->FirstChild("BkgPingCheck");
if(pNode == NULL)
{
TiXmlElement* pElem;
pElem = new TiXmlElement("BkgPingCheck");
pDoc->FirstChildElement("BBS_WiFiConfig")->FirstChild("Setting")->FirstChildElement("Option")->LinkEndChild( pElem );
pElem->SetAttribute("Operating", "");
pElem->SetAttribute("BreakInterval", "");
pElem->SetAttribute("PingInterval", "");
pElem->SetAttribute("MaxCheckCnt", "");
pElem->SetAttribute("CustomDestAddr", "");
pDoc->SaveFile();
}
pNode = pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting")->FirstChild("Option")->FirstChild("ScanOption");
if(pNode == NULL)
{
TiXmlElement* pElem;
pElem = new TiXmlElement("ScanOption");
pDoc->FirstChildElement("BBS_WiFiConfig")->FirstChild("Setting")->FirstChildElement("Option")->LinkEndChild( pElem );;
pElem->SetAttribute("TurnOnAvailNetNoti", "");
pElem->SetAttribute("ScanThreshold", "");
pElem->SetAttribute("LockSSID", "");
pElem->SetAttribute("NetToAccess", "");
pDoc->SaveFile();
}
pNode = pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting")->FirstChild("Option")->FirstChild("PowerOption");
if(pNode == NULL)
{
TiXmlElement* pElem;
pElem = new TiXmlElement("PowerOption");
pDoc->FirstChildElement("BBS_WiFiConfig")->FirstChild("Setting")->FirstChildElement("Option")->LinkEndChild( pElem );
pElem->SetAttribute("AllowSuspend", "");
pDoc->SaveFile();
}
pNode = pDoc->FirstChild("BBS_WiFiConfig")->FirstChild("Setting")->FirstChild("DefaultPreferNet");
if(pNode == NULL)
{
TiXmlElement* pElem;
pElem = new TiXmlElement("DefaultPreferNet");
pDoc->FirstChildElement("BBS_WiFiConfig")->FirstChild("Setting")->LinkEndChild( pElem );
pElem->SetAttribute("Enable", "");
pElem->SetAttribute("DHCP", "");
pElem->SetAttribute("Hidden", "");
pElem->SetAttribute("IP", "");
pElem->SetAttribute("Subnet", "");
pElem->SetAttribute("Gateway", "");
pElem->SetAttribute("DNS", "");
pElem->SetAttribute("SSID", "");
pElem->SetAttribute("Auth", "");
pElem->SetAttribute("Encr", "");
pElem->SetAttribute("Key", "");
pElem->SetAttribute("KeyIdx", "");
pElem->SetAttribute("Hex_16", "");
pDoc->SaveFile();
}
return TRUE;
}
// ----------------------------------------------------------------------------
bool BrowseTrackerLayout::Save(const wxString& filename, FileBrowse_MarksHash& m_FileBrowse_MarksArchive)
// ----------------------------------------------------------------------------
{
//DumpBrowse_Marks(wxT("BookMarks"), m_FileBrowse_MarksArchive, m_EdBook_MarksArchive);
const char* ROOT_TAG = "BrowseTracker_layout_file";
TiXmlDocument doc;
doc.SetCondenseWhiteSpace(false);
doc.InsertEndChild(TiXmlDeclaration("1.0", "UTF-8", "yes"));
TiXmlElement* rootnode = static_cast<TiXmlElement*>(doc.InsertEndChild(TiXmlElement(ROOT_TAG)));
if (!rootnode)
return false;
TiXmlElement* tgtidx = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("ActiveTarget")));
tgtidx->SetAttribute("name", cbU2C(m_pProject->GetActiveBuildTarget()));
ProjectFile* active = 0L;
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if (ed)
active = ed->GetProjectFile();
for (FilesList::iterator it = m_pProject->GetFilesList().begin(); it != m_pProject->GetFilesList().end(); ++it)
{
ProjectFile* f = *it;
if (f->editorOpen || f->editorPos || f->editorTopLine || f->editorTabPos)
{
TiXmlElement* node = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("File")));
node->SetAttribute("name", cbU2C(f->relativeFilename));
node->SetAttribute("open", f->editorOpen);
node->SetAttribute("top", (f == active));
node->SetAttribute("tabpos", f->editorTabPos);
TiXmlElement* cursor = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("Cursor")));
cursor->SetAttribute("position", f->editorPos);
cursor->SetAttribute("topLine", f->editorTopLine);
// Save the BrowseMarks
FileBrowse_MarksHash::iterator it2 = m_FileBrowse_MarksArchive.find(f->file.GetFullPath());
if (it2 != m_FileBrowse_MarksArchive.end() ) do
{
const BrowseMarks* pBrowse_Marks = it2->second;
if (not pBrowse_Marks) break;
wxString browseMarks = pBrowse_Marks->GetStringOfBrowse_Marks();
#if defined(LOGGING)
//LOGIT( _T("Layout writing BROWSEMarkString [%p]is[%s]"), pBrowse_Marks, browseMarks.c_str());
#endif
TiXmlElement* btMarks = static_cast<TiXmlElement*>(node->InsertEndChild(TiXmlElement("BrowseMarks")));
btMarks->SetAttribute("positions", cbU2C(browseMarks));
}while(0);
}
}//for
const wxArrayString& en = m_pProject->ExpandedNodes();
for (unsigned int i = 0; i < en.GetCount(); ++i)
{
if (!en[i].IsEmpty())
{
TiXmlElement* node = static_cast<TiXmlElement*>(rootnode->InsertEndChild(TiXmlElement("Expand")));
node->SetAttribute("folder", cbU2C(en[i]));
}
}
return cbSaveTinyXMLDocument(&doc, filename);
}
ResNickMan::ResNickMan() {
ReservedNicks = NULL;
TiXmlDocument doc;
#ifdef _WIN32
if(doc.LoadFile((PATH+"\\cfg\\ReservedNicks.xml").c_str()) == false) {
TiXmlDocument doc((PATH+"\\cfg\\ReservedNicks.xml").c_str());
#else
if(doc.LoadFile((PATH+"/cfg/ReservedNicks.xml").c_str()) == false) {
TiXmlDocument doc((PATH+"/cfg/ReservedNicks.xml").c_str());
#endif
doc.InsertEndChild(TiXmlDeclaration("1.0", "windows-1252", "yes"));
TiXmlElement reservednicks("ReservedNicks");
const char* Nicks[] = { "Hub-Security", "Admin", "Client", "PtokaX", "OpChat" };
for(uint8_t ui8i = 0; ui8i < 5; ui8i++) {
AddReservedNick(Nicks[ui8i]);
TiXmlElement reservednick("ReservedNick");
reservednick.InsertEndChild(TiXmlText(Nicks[ui8i]));
reservednicks.InsertEndChild(reservednick);
}
doc.InsertEndChild(reservednicks);
doc.SaveFile();
}
#ifdef _WIN32
if(doc.LoadFile((PATH+"\\cfg\\ReservedNicks.xml").c_str())) {
#else
if(doc.LoadFile((PATH+"/cfg/ReservedNicks.xml").c_str())) {
#endif
TiXmlHandle cfg(&doc);
TiXmlNode *reservednicks = cfg.FirstChild("ReservedNicks").Node();
if(reservednicks != NULL) {
TiXmlNode *child = NULL;
while((child = reservednicks->IterateChildren(child)) != NULL) {
TiXmlNode *reservednick = child->FirstChild();
if(reservednick == NULL) {
continue;
}
char *sNick = (char *)reservednick->Value();
AddReservedNick(sNick);
}
}
}
}
//---------------------------------------------------------------------------
ResNickMan::~ResNickMan() {
ReservedNick *next = ReservedNicks;
while(next != NULL) {
ReservedNick *cur = next;
next = cur->next;
delete cur;
}
}
//---------------------------------------------------------------------------
// Check for reserved nicks true = reserved
bool ResNickMan::CheckReserved(const char * sNick, const uint32_t &hash) const {
ReservedNick *next = ReservedNicks;
while(next != NULL) {
ReservedNick *cur = next;
next = cur->next;
if(cur->ui32Hash == hash && strcasecmp(cur->sNick, sNick) == 0) {
return true;
}
}
return false;
}