wxFBDataObject::wxFBDataObject( PObjectBase obj )
:
wxDataObject()
{
if ( obj )
{
// create xml representation of ObjectBase
ticpp::Element element;
obj->SerializeObject( &element );
// add version info to xml data, just in case it is pasted into a different version of wxFB
element.SetAttribute( "fbp_version_major", AppData()->m_fbpVerMajor );
element.SetAttribute( "fbp_version_minor", AppData()->m_fbpVerMinor );
ticpp::Document doc;
doc.LinkEndChild( &element );
TiXmlPrinter printer;
printer.SetIndent( "\t" );
#if defined( __WXMSW__ )
printer.SetLineBreak( "\r\n" );
#else
printer.SetLineBreak( "\n" );
#endif
doc.Accept( &printer );
m_data = printer.Str();
}
}
bool CSimpleXml::ModifyXmlAttri(list<XMLNODEINFO> &lstNode)
{
if(m_pDoc == NULL || m_pRoot == NULL)
{
return false;
}
list<XMLNODEINFO>::iterator itlst = lstNode.begin();
for(; itlst != lstNode.end(); ++itlst)
{
if(!ModifyOneAttri(*itlst))
{
return false;
}
}
TiXmlPrinter printer;
char szBuf[32];
memset(szBuf, 0, 32);
szBuf[0] = 0x9;
printer.SetIndent(szBuf);
szBuf[0] = 0x0a;
printer.SetLineBreak(szBuf);
if(m_pDoc->Accept(&printer))
{
m_strXml = printer.CStr();
}
else
{
return false;
}
return true;
}
void CXmlDocument::ToString(CDataBuffer& buffer)
{
TiXmlPrinter printer;
printer.SetLineBreak("\r\n");
printer.SetIndent("\t");
_doc->Accept(&printer);
buffer.Add(printer.CStr());
}
bool TreeVisitor::visitLeave(Solution& solution)
{
TiXmlPrinter printer;
printer.SetIndent(nullptr);
printer.SetLineBreak(nullptr);
m_document.Accept(&printer);
m_serialized = printer.CStr();
return true;
}
bool CSimpleXml::AddNodes(const string &strPath, list<XMLNODEINFO> &lstaddnode)
{
if(m_pDoc == NULL || m_pRoot == NULL)
{
return false;
}
TiXmlElement *pCurrNode = m_pRoot;
list<string> lstNode;
SeperateString(lstNode, strPath, "/");
list<string>::iterator itlstNode = lstNode.begin();
while (NULL != pCurrNode)
{
if (itlstNode != lstNode.end() && *itlstNode == pCurrNode->Value())
{
string strShow = pCurrNode->Value();
if (++itlstNode == lstNode.end())
{
AddOneNode(&pCurrNode, lstaddnode);
goto SIMXML;
}
pCurrNode = pCurrNode->FirstChildElement();
}
else
{
pCurrNode = pCurrNode->NextSiblingElement();
}
}
return false;
SIMXML:
TiXmlPrinter printer;
char szBuf[32];
memset(szBuf, 0, 32);
szBuf[0] = 0x9;
printer.SetIndent(szBuf);
szBuf[0] = 0x0a;
printer.SetLineBreak(szBuf);
if(m_pDoc->Accept(&printer))
{
m_strXml = printer.CStr();
}
else
{
return false;
}
return true;
}
std::string Partida::getXMLNivel() {
XMLDocument doc;
bool cargoArchivo = doc.LoadFile(idNiveles[contadorNiveles]);
if (cargoArchivo == false) {
std::cout << "\tError al abrir el archivo XML." << std::endl;
return std::string();
}
TiXmlPrinter printer;
printer.SetIndent("");
printer.SetLineBreak("");
doc.Accept(&printer);
return printer.CStr();
}
QString reportDataThread::encode(){
//if(DEBUG){qWarning() << "Encoding XML";}
TiXmlPrinter* printer = new TiXmlPrinter();
printer->SetIndent( "\t" );
printer->SetLineBreak( "\n" );
//printer->SetStreamPrinting();
doc->Accept(printer);
const char* temp = printer->CStr();
//qWarning() << "XML:" << temp;
QByteArray array = QByteArray(temp).toPercentEncoding();
//if(DEBUG){qWarning() << "XML encoded";}
return QString(array);
}
sqbind::stdString CSqXml::Encode( sqbind::CSqMulti *pData,
const sqbind::stdString &sLineBreak,
const sqbind::stdString &sTab, int bIndexed )
{_STT();
if ( !pData )
return oexT( "" );
// Encode the list into xml
TiXmlDocument xmlDoc;
// Do the encode
if ( !_Encode( &xmlDoc, pData, bIndexed ) )
return oexT( "" );
// Setup a printer
TiXmlPrinter printer;
printer.SetIndent( oexStrToMbPtr( sTab.c_str() ) );
printer.SetLineBreak( oexStrToMbPtr( sLineBreak.c_str() ) );
xmlDoc.Accept( &printer );
// Return the encoded xml
return oexMbToStrPtr( printer.CStr() );
}
void CAdvancedSettings::ParseSettingsFile(const CStdString &file)
{
TiXmlDocument advancedXML;
if (!CFile::Exists(file))
{
CLog::Log(LOGNOTICE, "No settings file to load (%s)", file.c_str());
return;
}
if (!advancedXML.LoadFile(file))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d\n%s", file.c_str(), advancedXML.ErrorRow(), advancedXML.ErrorDesc());
return;
}
TiXmlElement *pRootElement = advancedXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(),"advancedsettings") != 0)
{
CLog::Log(LOGERROR, "Error loading %s, no <advancedsettings> node", file.c_str());
return;
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded settings file from %s", file.c_str());
// Dump contents of AS.xml to debug log
TiXmlPrinter printer;
printer.SetLineBreak("\n");
printer.SetIndent(" ");
advancedXML.Accept(&printer);
CLog::Log(LOGNOTICE, "Contents of %s are...\n%s", file.c_str(), printer.CStr());
TiXmlElement *pElement = pRootElement->FirstChildElement("audio");
if (pElement)
{
XMLUtils::GetFloat(pElement, "ac3downmixgain", m_ac3Gain, -96.0f, 96.0f);
XMLUtils::GetInt(pElement, "headroom", m_audioHeadRoom, 0, 12);
XMLUtils::GetString(pElement, "defaultplayer", m_audioDefaultPlayer);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_audioPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_musicUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_musicTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_musicTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_musicTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_musicTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_musicPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_musicPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_musicPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_musicPercentSeekBackwardBig, -100, 0);
XMLUtils::GetInt(pElement, "resample", m_musicResample, 0, 192000);
TiXmlElement* pAudioExcludes = pElement->FirstChildElement("excludefromlisting");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromListingRegExps);
pAudioExcludes = pElement->FirstChildElement("excludefromscan");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromScanRegExps);
XMLUtils::GetString(pElement, "audiohost", m_audioHost);
XMLUtils::GetBoolean(pElement, "applydrc", m_audioApplyDrc);
XMLUtils::GetBoolean(pElement, "dvdplayerignoredtsinwav", m_dvdplayerIgnoreDTSinWAV);
XMLUtils::GetFloat(pElement, "limiterhold", m_limiterHold, 0.0f, 100.0f);
XMLUtils::GetFloat(pElement, "limiterrelease", m_limiterRelease, 0.001f, 100.0f);
}
pElement = pRootElement->FirstChildElement("karaoke");
if (pElement)
{
XMLUtils::GetFloat(pElement, "syncdelaycdg", m_karaokeSyncDelayCDG, -3.0f, 3.0f); // keep the old name for comp
XMLUtils::GetFloat(pElement, "syncdelaylrc", m_karaokeSyncDelayLRC, -3.0f, 3.0f);
XMLUtils::GetBoolean(pElement, "alwaysreplacegenre", m_karaokeChangeGenreForKaraokeSongs );
XMLUtils::GetBoolean(pElement, "storedelay", m_karaokeKeepDelay );
XMLUtils::GetInt(pElement, "autoassignstartfrom", m_karaokeStartIndex, 1, 2000000000);
XMLUtils::GetBoolean(pElement, "nocdgbackground", m_karaokeAlwaysEmptyOnCdgs );
XMLUtils::GetBoolean(pElement, "lookupsongbackground", m_karaokeUseSongSpecificBackground );
TiXmlElement* pKaraokeBackground = pElement->FirstChildElement("defaultbackground");
if (pKaraokeBackground)
{
const char* attr = pKaraokeBackground->Attribute("type");
if ( attr )
m_karaokeDefaultBackgroundType = attr;
attr = pKaraokeBackground->Attribute("path");
if ( attr )
m_karaokeDefaultBackgroundFilePath = attr;
}
}
pElement = pRootElement->FirstChildElement("video");
if (pElement)
{
XMLUtils::GetFloat(pElement, "subsdelayrange", m_videoSubsDelayRange, 10, 600);
XMLUtils::GetFloat(pElement, "audiodelayrange", m_videoAudioDelayRange, 10, 600);
XMLUtils::GetInt(pElement, "blackbarcolour", m_videoBlackBarColour, 0, 255);
XMLUtils::GetString(pElement, "defaultplayer", m_videoDefaultPlayer);
XMLUtils::GetString(pElement, "defaultdvdplayer", m_videoDefaultDVDPlayer);
XMLUtils::GetBoolean(pElement, "fullscreenonmoviestart", m_fullScreenOnMovieStart);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_videoPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetInt(pElement, "ignoresecondsatstart", m_videoIgnoreSecondsAtStart, 0, 900);
XMLUtils::GetFloat(pElement, "ignorepercentatend", m_videoIgnorePercentAtEnd, 0, 100.0f);
XMLUtils::GetInt(pElement, "smallstepbackseconds", m_videoSmallStepBackSeconds, 1, INT_MAX);
XMLUtils::GetInt(pElement, "smallstepbacktries", m_videoSmallStepBackTries, 1, 10);
XMLUtils::GetInt(pElement, "smallstepbackdelay", m_videoSmallStepBackDelay, 100, 5000); //MS
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_videoUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_videoTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_videoTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_videoTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_videoTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_videoPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_videoPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_videoPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_videoPercentSeekBackwardBig, -100, 0);
TiXmlElement* pVideoExcludes = pElement->FirstChildElement("excludefromlisting");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoExcludeFromListingRegExps);
pVideoExcludes = pElement->FirstChildElement("excludefromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_moviesExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("excludetvshowsfromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_tvshowExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("cleanstrings");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoCleanStringRegExps);
XMLUtils::GetString(pElement,"cleandatetime", m_videoCleanDateTimeRegExp);
XMLUtils::GetString(pElement,"ppffmpegdeinterlacing",m_videoPPFFmpegDeint);
XMLUtils::GetString(pElement,"ppffmpegpostprocessing",m_videoPPFFmpegPostProc);
XMLUtils::GetBoolean(pElement,"vdpauscaling",m_videoVDPAUScaling);
XMLUtils::GetFloat(pElement, "nonlinearstretchratio", m_videoNonLinStretchRatio, 0.01f, 1.0f);
XMLUtils::GetBoolean(pElement,"enablehighqualityhwscalers", m_videoEnableHighQualityHwScalers);
XMLUtils::GetFloat(pElement,"autoscalemaxfps",m_videoAutoScaleMaxFps, 0.0f, 1000.0f);
XMLUtils::GetBoolean(pElement,"allowmpeg4vdpau",m_videoAllowMpeg4VDPAU);
XMLUtils::GetBoolean(pElement,"allowmpeg4vaapi",m_videoAllowMpeg4VAAPI);
XMLUtils::GetBoolean(pElement, "disablebackgrounddeinterlace", m_videoDisableBackgroundDeinterlace);
XMLUtils::GetInt(pElement, "useocclusionquery", m_videoCaptureUseOcclusionQuery, -1, 1);
TiXmlElement* pAdjustRefreshrate = pElement->FirstChildElement("adjustrefreshrate");
if (pAdjustRefreshrate)
{
TiXmlElement* pRefreshOverride = pAdjustRefreshrate->FirstChildElement("override");
while (pRefreshOverride)
{
RefreshOverride override = {0};
float fps;
if (XMLUtils::GetFloat(pRefreshOverride, "fps", fps))
{
override.fpsmin = fps - 0.01f;
override.fpsmax = fps + 0.01f;
}
float fpsmin, fpsmax;
if (XMLUtils::GetFloat(pRefreshOverride, "fpsmin", fpsmin) &&
XMLUtils::GetFloat(pRefreshOverride, "fpsmax", fpsmax))
{
override.fpsmin = fpsmin;
override.fpsmax = fpsmax;
}
float refresh;
if (XMLUtils::GetFloat(pRefreshOverride, "refresh", refresh))
{
override.refreshmin = refresh - 0.01f;
override.refreshmax = refresh + 0.01f;
void LabelSetImageIO::Write()
{
ValidateOutputLocation();
const LabelSetImage* input = static_cast<const LabelSetImage*>(this->GetInput());
const std::string& locale = "C";
const std::string& currLocale = setlocale( LC_ALL, NULL );
if ( locale.compare(currLocale)!=0 )
{
try
{
setlocale(LC_ALL, locale.c_str());
}
catch(...)
{
mitkThrow() << "Could not set locale " << currLocale;
}
}
mitk::Image::Pointer inputVector = mitk::LabelSetImageConverter::ConvertLabelSetImageToImage(input);
// image write
if ( inputVector.IsNull() )
{
mitkThrow() << "Cannot write non-image data";
}
itk::NrrdImageIO::Pointer nrrdImageIo = itk::NrrdImageIO::New();
// Clone the image geometry, because we might have to change it
// for writing purposes
BaseGeometry::Pointer geometry = inputVector->GetGeometry()->Clone();
// Check if geometry information will be lost
if (inputVector->GetDimension() == 2 &&
!geometry->Is2DConvertable())
{
MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might consider using Convert2Dto3DImageFilter before saving.";
// set matrix to identity
mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
affTrans->SetIdentity();
mitk::Vector3D spacing = geometry->GetSpacing();
mitk::Point3D origin = geometry->GetOrigin();
geometry->SetIndexToWorldTransform(affTrans);
geometry->SetSpacing(spacing);
geometry->SetOrigin(origin);
}
LocalFile localFile(this);
const std::string path = localFile.GetFileName();
MITK_INFO << "Writing image: " << path << std::endl;
try
{
// Implementation of writer using itkImageIO directly. This skips the use
// of templated itkImageFileWriter, which saves the multiplexing on MITK side.
const unsigned int dimension = inputVector->GetDimension();
const unsigned int* const dimensions = inputVector->GetDimensions();
const mitk::PixelType pixelType = inputVector->GetPixelType();
const mitk::Vector3D mitkSpacing = geometry->GetSpacing();
const mitk::Point3D mitkOrigin = geometry->GetOrigin();
// Due to templating in itk, we are forced to save a 4D spacing and 4D Origin,
// though they are not supported in MITK
itk::Vector<double, 4u> spacing4D;
spacing4D[0] = mitkSpacing[0];
spacing4D[1] = mitkSpacing[1];
spacing4D[2] = mitkSpacing[2];
spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have a valid value here
itk::Vector<double, 4u> origin4D;
origin4D[0] = mitkOrigin[0];
origin4D[1] = mitkOrigin[1];
origin4D[2] = mitkOrigin[2];
origin4D[3] = 0; // There is no support for a 4D origin. However, we should have a valid value here
// Set the necessary information for imageIO
nrrdImageIo->SetNumberOfDimensions(dimension);
nrrdImageIo->SetPixelType(pixelType.GetPixelType());
nrrdImageIo->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
nrrdImageIo->SetNumberOfComponents(pixelType.GetNumberOfComponents());
itk::ImageIORegion ioRegion(dimension);
for (unsigned int i = 0; i < dimension; i++)
{
nrrdImageIo->SetDimensions(i, dimensions[i]);
nrrdImageIo->SetSpacing(i, spacing4D[i]);
nrrdImageIo->SetOrigin(i, origin4D[i]);
mitk::Vector3D mitkDirection;
mitkDirection.SetVnlVector(geometry->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
itk::Vector<double, 4u> direction4D;
direction4D[0] = mitkDirection[0];
direction4D[1] = mitkDirection[1];
direction4D[2] = mitkDirection[2];
// MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
// save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
if (i == 3)
{
direction4D[3] = 1; // homogenous component
}
else
{
direction4D[3] = 0;
}
vnl_vector<double> axisDirection(dimension);
for (unsigned int j = 0; j < dimension; j++)
{
axisDirection[j] = direction4D[j] / spacing4D[i];
}
nrrdImageIo->SetDirection(i, axisDirection);
ioRegion.SetSize(i, inputVector->GetLargestPossibleRegion().GetSize(i));
ioRegion.SetIndex(i, inputVector->GetLargestPossibleRegion().GetIndex(i));
}
//use compression if available
nrrdImageIo->UseCompressionOn();
nrrdImageIo->SetIORegion(ioRegion);
nrrdImageIo->SetFileName(path);
// label set specific meta data
char keybuffer[512];
char valbuffer[512];
sprintf(keybuffer, "modality");
sprintf(valbuffer, "org.mitk.image.multilabel");
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
sprintf(keybuffer, "layers");
sprintf(valbuffer, "%1d", input->GetNumberOfLayers());
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
for (unsigned int layerIdx = 0; layerIdx<input->GetNumberOfLayers(); layerIdx++)
{
sprintf(keybuffer, "layer_%03d", layerIdx); // layer idx
sprintf(valbuffer, "%1d", input->GetNumberOfLabels(layerIdx)); // number of labels for the layer
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), std::string(valbuffer));
mitk::LabelSet::LabelContainerConstIteratorType iter = input->GetLabelSet(layerIdx)->IteratorConstBegin();
unsigned int count(0);
while (iter != input->GetLabelSet(layerIdx)->IteratorConstEnd())
{
std::auto_ptr<TiXmlDocument> document;
document.reset(new TiXmlDocument());
TiXmlDeclaration* decl = new TiXmlDeclaration("1.0", "", ""); // TODO what to write here? encoding? etc....
document->LinkEndChild(decl);
TiXmlElement * labelElem = GetLabelAsTiXmlElement(iter->second);
document->LinkEndChild(labelElem);
TiXmlPrinter printer;
printer.SetIndent("");
printer.SetLineBreak("");
document->Accept(&printer);
sprintf(keybuffer, "org.mitk.label_%03u_%05u", layerIdx, count);
itk::EncapsulateMetaData<std::string>(nrrdImageIo->GetMetaDataDictionary(), std::string(keybuffer), printer.Str());
++iter;
++count;
}
}
// end label set specific meta data
ImageReadAccessor imageAccess(inputVector);
nrrdImageIo->Write(imageAccess.GetData());
}
catch (const std::exception& e)
{
mitkThrow() << e.what();
}
// end image write
try
{
setlocale(LC_ALL, currLocale.c_str());
}
catch(...)
{
mitkThrow() << "Could not reset locale " << currLocale;
}
}
bool CAdvancedSettings::Load()
{
// NOTE: This routine should NOT set the default of any of these parameters
// it should instead use the versions of GetString/Integer/Float that
// don't take defaults in. Defaults are set in the constructor above
CStdString advancedSettingsXML;
advancedSettingsXML = g_settings.GetUserDataItem("advancedsettings.xml");
TiXmlDocument advancedXML;
if (!CFile::Exists(advancedSettingsXML))
{ // tell the user it doesn't exist
CLog::Log(LOGNOTICE, "No advancedsettings.xml to load (%s)", advancedSettingsXML.c_str());
return false;
}
if (!advancedXML.LoadFile(advancedSettingsXML))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d\n%s", advancedSettingsXML.c_str(), advancedXML.ErrorRow(), advancedXML.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = advancedXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(),"advancedsettings") != 0)
{
CLog::Log(LOGERROR, "Error loading %s, no <advancedsettings> node", advancedSettingsXML.c_str());
return false;
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded advancedsettings.xml from %s", advancedSettingsXML.c_str());
// Dump contents of AS.xml to debug log
TiXmlPrinter printer;
printer.SetLineBreak("\n");
printer.SetIndent(" ");
advancedXML.Accept(&printer);
CLog::Log(LOGNOTICE, "Contents of %s are...\n%s", advancedSettingsXML.c_str(), printer.CStr());
TiXmlElement *pElement = pRootElement->FirstChildElement("audio");
if (pElement)
{
XMLUtils::GetFloat(pElement, "ac3downmixgain", m_ac3Gain, -96.0f, 96.0f);
XMLUtils::GetInt(pElement, "headroom", m_audioHeadRoom, 0, 12);
XMLUtils::GetFloat(pElement, "karaokesyncdelay", m_karaokeSyncDelay, -3.0f, 3.0f);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_audioPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_musicUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_musicTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_musicTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_musicTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_musicTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_musicPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_musicPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_musicPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_musicPercentSeekBackwardBig, -100, 0);
XMLUtils::GetInt(pElement, "resample", m_musicResample, 0, 48000);
TiXmlElement* pAudioExcludes = pElement->FirstChildElement("excludefromlisting");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromListingRegExps);
pAudioExcludes = pElement->FirstChildElement("excludefromscan");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromScanRegExps);
XMLUtils::GetBoolean(pElement, "applydrc", m_audioApplyDrc);
XMLUtils::GetBoolean(pElement, "dvdplayerignoredtsinwav", m_dvdplayerIgnoreDTSinWAV);
}
pElement = pRootElement->FirstChildElement("video");
if (pElement)
{
XMLUtils::GetFloat(pElement, "subsdelayrange", m_videoSubsDelayRange, 10, 600);
XMLUtils::GetFloat(pElement, "audiodelayrange", m_videoAudioDelayRange, 10, 600);
XMLUtils::GetInt(pElement, "blackbarcolour", m_videoBlackBarColour, 0, 255);
XMLUtils::GetBoolean(pElement, "fullscreenonmoviestart", m_fullScreenOnMovieStart);
// 101 on purpose - can be used to never automark as watched
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_videoPlayCountMinimumPercent, 0.0f, 101.0f);
XMLUtils::GetInt(pElement, "ignoresecondsatstart", m_videoIgnoreSecondsAtStart, 0, 900);
XMLUtils::GetFloat(pElement, "ignorepercentatend", m_videoIgnorePercentAtEnd, 0, 100.0f);
XMLUtils::GetInt(pElement, "smallstepbackseconds", m_videoSmallStepBackSeconds, 1, INT_MAX);
XMLUtils::GetInt(pElement, "smallstepbacktries", m_videoSmallStepBackTries, 1, 10);
XMLUtils::GetInt(pElement, "smallstepbackdelay", m_videoSmallStepBackDelay, 100, 5000); //MS
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_videoUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_videoTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_videoTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_videoTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_videoTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_videoPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_videoPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_videoPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_videoPercentSeekBackwardBig, -100, 0);
TiXmlElement* pVideoExcludes = pElement->FirstChildElement("excludefromlisting");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoExcludeFromListingRegExps);
pVideoExcludes = pElement->FirstChildElement("excludefromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_moviesExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("excludetvshowsfromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_tvshowExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("cleanstrings");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoCleanStringRegExps);
XMLUtils::GetString(pElement,"cleandatetime", m_videoCleanDateTimeRegExp);
XMLUtils::GetString(pElement,"ppffmpegdeinterlacing",m_videoPPFFmpegDeint);
XMLUtils::GetString(pElement,"ppffmpegpostprocessing",m_videoPPFFmpegPostProc);
}
pElement = pRootElement->FirstChildElement("musiclibrary");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "hideallitems", m_bMusicLibraryHideAllItems);
XMLUtils::GetInt(pElement, "recentlyaddeditems", m_iMusicLibraryRecentlyAddedItems, 1, INT_MAX);
XMLUtils::GetBoolean(pElement, "prioritiseapetags", m_prioritiseAPEv2tags);
XMLUtils::GetBoolean(pElement, "allitemsonbottom", m_bMusicLibraryAllItemsOnBottom);
XMLUtils::GetBoolean(pElement, "albumssortbyartistthenyear", m_bMusicLibraryAlbumsSortByArtistThenYear);
XMLUtils::GetString(pElement, "albumformat", m_strMusicLibraryAlbumFormat);
XMLUtils::GetString(pElement, "albumformatright", m_strMusicLibraryAlbumFormatRight);
XMLUtils::GetString(pElement, "itemseparator", m_musicItemSeparator);
}
pElement = pRootElement->FirstChildElement("videolibrary");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "hideallitems", m_bVideoLibraryHideAllItems);
XMLUtils::GetBoolean(pElement, "allitemsonbottom", m_bVideoLibraryAllItemsOnBottom);
XMLUtils::GetInt(pElement, "recentlyaddeditems", m_iVideoLibraryRecentlyAddedItems, 1, INT_MAX);
XMLUtils::GetBoolean(pElement, "hiderecentlyaddeditems", m_bVideoLibraryHideRecentlyAddedItems);
XMLUtils::GetBoolean(pElement, "hideemptyseries", m_bVideoLibraryHideEmptySeries);
XMLUtils::GetBoolean(pElement, "cleanonupdate", m_bVideoLibraryCleanOnUpdate);
XMLUtils::GetString(pElement, "itemseparator", m_videoItemSeparator);
XMLUtils::GetBoolean(pElement, "exportautothumbs", m_bVideoLibraryExportAutoThumbs);
XMLUtils::GetBoolean(pElement, "importwatchedstate", m_bVideoLibraryImportWatchedState);
TiXmlElement* pMyMovies = pElement->FirstChildElement("mymovies");
if (pMyMovies)
XMLUtils::GetBoolean(pMyMovies, "categoriestogenres", m_bVideoLibraryMyMoviesCategoriesToGenres);
}
pElement = pRootElement->FirstChildElement("videoscanner");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "ignoreerrors", m_bVideoScannerIgnoreErrors);
}
pElement = pRootElement->FirstChildElement("slideshow");
if (pElement)
{
XMLUtils::GetFloat(pElement, "panamount", m_slideshowPanAmount, 0.0f, 20.0f);
XMLUtils::GetFloat(pElement, "zoomamount", m_slideshowZoomAmount, 0.0f, 20.0f);
XMLUtils::GetFloat(pElement, "blackbarcompensation", m_slideshowBlackBarCompensation, 0.0f, 50.0f);
}
pElement = pRootElement->FirstChildElement("lcd");
if (pElement)
{
XMLUtils::GetInt(pElement, "rows", m_lcdRows, 1, 4);
XMLUtils::GetInt(pElement, "columns", m_lcdColumns, 1, 40);
XMLUtils::GetInt(pElement, "address1", m_lcdAddress1, 0, 0x100);
XMLUtils::GetInt(pElement, "address2", m_lcdAddress2, 0, 0x100);
XMLUtils::GetInt(pElement, "address3", m_lcdAddress3, 0, 0x100);
XMLUtils::GetInt(pElement, "address4", m_lcdAddress4, 0, 0x100);
}
pElement = pRootElement->FirstChildElement("network");
if (pElement)
{
XMLUtils::GetInt(pElement, "autodetectpingtime", m_autoDetectPingTime, 1, 240);
XMLUtils::GetInt(pElement, "curlclienttimeout", m_curlconnecttimeout, 1, 1000);
XMLUtils::GetInt(pElement, "curllowspeedtime", m_curllowspeedtime, 1, 1000);
XMLUtils::GetInt(pElement, "curlretries", m_curlretries, 0, 10);
XMLUtils::GetUInt(pElement, "cachemembuffersize", m_cacheMemBufferSize);
}
pElement = pRootElement->FirstChildElement("samba");
if (pElement)
{
XMLUtils::GetString(pElement, "doscodepage", m_sambadoscodepage);
XMLUtils::GetInt(pElement, "clienttimeout", m_sambaclienttimeout, 5, 100);
XMLUtils::GetBoolean(pElement, "statfiles", m_sambastatfiles);
}
pElement = pRootElement->FirstChildElement("httpdirectory");
if (pElement)
XMLUtils::GetBoolean(pElement, "statfilesize", m_bHTTPDirectoryStatFilesize);
pElement = pRootElement->FirstChildElement("ftp");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "remotethumbs", m_bFTPThumbs);
}
pElement = pRootElement->FirstChildElement("loglevel");
if (pElement)
{ // read the loglevel setting, so set the setting advanced to hide it in GUI
// as altering it will do nothing - we don't write to advancedsettings.xml
XMLUtils::GetInt(pRootElement, "loglevel", m_logLevelHint, LOG_LEVEL_NONE, LOG_LEVEL_MAX);
CSettingBool *setting = (CSettingBool *)g_guiSettings.GetSetting("debug.showloginfo");
if (setting)
{
const char* hide;
if (!((hide = pElement->Attribute("hide")) && strnicmp("false", hide, 4) == 0))
setting->SetAdvanced();
}
g_advancedSettings.m_logLevel = std::max(g_advancedSettings.m_logLevel, g_advancedSettings.m_logLevelHint);
CLog::SetLogLevel(g_advancedSettings.m_logLevel);
}
pElement = pRootElement->FirstChildElement("python");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "verbose", m_bPythonVerbose);
}
XMLUtils::GetString(pRootElement, "cddbaddress", m_cddbAddress);
XMLUtils::GetBoolean(pRootElement, "usepcdvdrom", m_usePCDVDROM);
XMLUtils::GetBoolean(pRootElement, "nodvdrom", m_noDVDROM);
XMLUtils::GetBoolean(pRootElement, "enableintro", m_enableintro);
XMLUtils::GetBoolean(pRootElement, "fasterscanning", m_fastscanning);
XMLUtils::GetBoolean(pRootElement, "slowscrolling", m_slowscrolling);
XMLUtils::GetBoolean(pRootElement, "splash", m_splashImage);
XMLUtils::GetBoolean(pRootElement, "disablemodchipdetection", m_DisableModChipDetection);
XMLUtils::GetBoolean(pRootElement, "powersave", m_bPowerSave);
XMLUtils::GetInt(pRootElement, "songinfoduration", m_songInfoDuration, 0, INT_MAX);
XMLUtils::GetInt(pRootElement, "busydialogdelay", m_busyDialogDelay, 0, 5000);
XMLUtils::GetInt(pRootElement, "playlistretries", m_playlistRetries, -1, 5000);
XMLUtils::GetInt(pRootElement, "playlisttimeout", m_playlistTimeout, 0, 5000);
XMLUtils::GetBoolean(pRootElement,"virtualshares", m_bVirtualShares);
XMLUtils::GetBoolean(pRootElement,"navigatevirtualkeyboard", m_bNavVKeyboard);
//Tuxbox
pElement = pRootElement->FirstChildElement("tuxbox");
if (pElement)
{
XMLUtils::GetInt(pElement, "streamtsport", m_iTuxBoxStreamtsPort, 0, 65535);
XMLUtils::GetBoolean(pElement, "audiochannelselection", m_bTuxBoxAudioChannelSelection);
XMLUtils::GetBoolean(pElement, "submenuselection", m_bTuxBoxSubMenuSelection);
XMLUtils::GetBoolean(pElement, "pictureicon", m_bTuxBoxPictureIcon);
XMLUtils::GetBoolean(pElement, "sendallaudiopids", m_bTuxBoxSendAllAPids);
XMLUtils::GetInt(pElement, "epgrequesttime", m_iTuxBoxEpgRequestTime, 0, 3600);
XMLUtils::GetInt(pElement, "defaultsubmenu", m_iTuxBoxDefaultSubMenu, 1, 4);
XMLUtils::GetInt(pElement, "defaultrootmenu", m_iTuxBoxDefaultRootMenu, 0, 4);
XMLUtils::GetInt(pElement, "zapwaittime", m_iTuxBoxZapWaitTime, 0, 120);
XMLUtils::GetBoolean(pElement, "zapstream", m_bTuxBoxZapstream);
XMLUtils::GetInt(pElement, "zapstreamport", m_iTuxBoxZapstreamPort, 0, 65535);
}
// Myth TV
pElement = pRootElement->FirstChildElement("myth");
if (pElement)
{
XMLUtils::GetInt(pElement, "movielength", m_iMythMovieLength);
}
// EDL commercial break handling
pElement = pRootElement->FirstChildElement("edl");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "mergeshortcommbreaks", m_bEdlMergeShortCommBreaks);
XMLUtils::GetInt(pElement, "maxcommbreaklength", m_iEdlMaxCommBreakLength, 0, 10 * 60); // Between 0 and 10 minutes
XMLUtils::GetInt(pElement, "mincommbreaklength", m_iEdlMinCommBreakLength, 0, 5 * 60); // Between 0 and 5 minutes
XMLUtils::GetInt(pElement, "maxcommbreakgap", m_iEdlMaxCommBreakGap, 0, 5 * 60); // Between 0 and 5 minutes.
XMLUtils::GetInt(pElement, "maxstartgap", m_iEdlMaxStartGap, 0, 10 * 60); // Between 0 and 10 minutes
XMLUtils::GetInt(pElement, "commbreakautowait", m_iEdlCommBreakAutowait, 0, 10); // Between 0 and 10 seconds
XMLUtils::GetInt(pElement, "commbreakautowind", m_iEdlCommBreakAutowind, 0, 10); // Between 0 and 10 seconds
}
// picture exclude regexps
TiXmlElement* pPictureExcludes = pRootElement->FirstChildElement("pictureexcludes");
if (pPictureExcludes)
GetCustomRegexps(pPictureExcludes, m_pictureExcludeFromListingRegExps);
// picture extensions
CStdString extraExtensions;
TiXmlElement* pExts = pRootElement->FirstChildElement("pictureextensions");
if (pExts)
GetCustomExtensions(pExts,g_settings.m_pictureExtensions);
// music extensions
pExts = pRootElement->FirstChildElement("musicextensions");
if (pExts)
GetCustomExtensions(pExts,g_settings.m_musicExtensions);
// video extensions
pExts = pRootElement->FirstChildElement("videoextensions");
if (pExts)
GetCustomExtensions(pExts,g_settings.m_videoExtensions);
m_vecTokens.clear();
CLangInfo::LoadTokens(pRootElement->FirstChild("sorttokens"),m_vecTokens);
XMLUtils::GetBoolean(pRootElement, "displayremotecodes", m_displayRemoteCodes);
// TODO: Should cache path be given in terms of our predefined paths??
// Are we even going to have predefined paths??
CSettings::GetPath(pRootElement, "cachepath", m_cachePath);
URIUtils::AddSlashAtEnd(m_cachePath);
XMLUtils::GetBoolean(pRootElement, "ftpshowcache", m_FTPShowCache);
g_LangCodeExpander.LoadUserCodes(pRootElement->FirstChildElement("languagecodes"));
// trailer matching regexps
TiXmlElement* pTrailerMatching = pRootElement->FirstChildElement("trailermatching");
if (pTrailerMatching)
GetCustomRegexps(pTrailerMatching, m_trailerMatchRegExps);
//everything thats a trailer is not a movie
m_moviesExcludeFromScanRegExps.insert(m_moviesExcludeFromScanRegExps.end(),
m_trailerMatchRegExps.begin(),
m_trailerMatchRegExps.end());
// stacking regexps
TiXmlElement* pVideoStacking = pRootElement->FirstChildElement("moviestacking");
if (pVideoStacking)
GetCustomRegexps(pVideoStacking, m_videoStackRegExps);
//tv stacking regexps
TiXmlElement* pTVStacking = pRootElement->FirstChildElement("tvshowmatching");
if (pTVStacking)
GetCustomTVRegexps(pTVStacking, m_tvshowStackRegExps);
// path substitutions
TiXmlElement* pPathSubstitution = pRootElement->FirstChildElement("pathsubstitution");
if (pPathSubstitution)
{
m_pathSubstitutions.clear();
CLog::Log(LOGDEBUG,"Configuring path substitutions");
TiXmlNode* pSubstitute = pPathSubstitution->FirstChildElement("substitute");
while (pSubstitute)
{
CStdString strFrom, strTo;
TiXmlNode* pFrom = pSubstitute->FirstChild("from");
if (pFrom)
strFrom = pFrom->FirstChild()->Value();
TiXmlNode* pTo = pSubstitute->FirstChild("to");
if (pTo)
strTo = pTo->FirstChild()->Value();
if (!strFrom.IsEmpty() && !strTo.IsEmpty())
{
CLog::Log(LOGDEBUG," Registering substition pair:");
CLog::Log(LOGDEBUG," From: [%s]", strFrom.c_str());
CLog::Log(LOGDEBUG," To: [%s]", strTo.c_str());
// keep literal commas since we use comma as a seperator
strFrom.Replace(",",",,");
strTo.Replace(",",",,");
m_pathSubstitutions.push_back(strFrom + " , " + strTo);
}
else
{
// error message about missing tag
if (strFrom.IsEmpty())
CLog::Log(LOGERROR," Missing <from> tag");
else
CLog::Log(LOGERROR," Missing <to> tag");
}
// get next one
pSubstitute = pSubstitute->NextSiblingElement("substitute");
}
}
XMLUtils::GetInt(pRootElement, "remoterepeat", m_remoteRepeat, 1, INT_MAX);
XMLUtils::GetFloat(pRootElement, "controllerdeadzone", m_controllerDeadzone, 0.0f, 1.0f);
XMLUtils::GetInt(pRootElement, "thumbsize", m_thumbSize, 0, 1024);
XMLUtils::GetInt(pRootElement, "fanartheight", m_fanartHeight, 0, 1080);
//dds support
XMLUtils::GetBoolean(pRootElement, "useddsfanart", m_useddsfanart);
XMLUtils::GetBoolean(pRootElement, "playlistasfolders", m_playlistAsFolders);
XMLUtils::GetBoolean(pRootElement, "detectasudf", m_detectAsUdf);
// music thumbs
CStdString extraThumbs;
TiXmlElement* pThumbs = pRootElement->FirstChildElement("musicthumbs");
if (pThumbs)
{
// remove before add so that the defaults can be restored after user defined ones
// (ie, the list can be:cover.jpg|cover.png|folder.jpg)
CSettings::GetString(pThumbs, "remove", extraThumbs, "");
if (extraThumbs != "")
{
CStdStringArray thumbs;
StringUtils::SplitString(extraThumbs, "|", thumbs);
for (unsigned int i = 0; i < thumbs.size(); ++i)
{
int iPos = m_musicThumbs.Find(thumbs[i]);
if (iPos == -1)
continue;
m_musicThumbs.erase(iPos, thumbs[i].size() + 1);
}
}
CSettings::GetString(pThumbs, "add", extraThumbs,"");
if (extraThumbs != "")
{
if (!m_musicThumbs.IsEmpty())
m_musicThumbs += "|";
m_musicThumbs += extraThumbs;
}
}
// dvd thumbs
pThumbs = pRootElement->FirstChildElement("dvdthumbs");
if (pThumbs)
{
// remove before add so that the defaults can be restored after user defined ones
// (ie, the list can be:cover.jpg|cover.png|folder.jpg)
CSettings::GetString(pThumbs, "remove", extraThumbs, "");
if (extraThumbs != "")
{
CStdStringArray thumbs;
StringUtils::SplitString(extraThumbs, "|", thumbs);
for (unsigned int i = 0; i < thumbs.size(); ++i)
{
int iPos = m_dvdThumbs.Find(thumbs[i]);
if (iPos == -1)
continue;
m_dvdThumbs.erase(iPos, thumbs[i].size() + 1);
}
}
CSettings::GetString(pThumbs, "add", extraThumbs,"");
if (extraThumbs != "")
{
if (!m_dvdThumbs.IsEmpty())
m_dvdThumbs += "|";
m_dvdThumbs += extraThumbs;
}
}
// movie fanarts
TiXmlElement* pFanart = pRootElement->FirstChildElement("fanart");
if (pFanart)
GetCustomExtensions(pFanart,m_fanartImages);
// music filename->tag filters
TiXmlElement* filters = pRootElement->FirstChildElement("musicfilenamefilters");
if (filters)
{
TiXmlNode* filter = filters->FirstChild("filter");
while (filter)
{
if (filter->FirstChild())
m_musicTagsFromFileFilters.push_back(filter->FirstChild()->ValueStr());
filter = filter->NextSibling("filter");
}
}
TiXmlElement* pHostEntries = pRootElement->FirstChildElement("hosts");
if (pHostEntries)
{
TiXmlElement* element = pHostEntries->FirstChildElement("entry");
while(element)
{
CStdString name = element->Attribute("name");
CStdString value;
if(element->GetText())
value = element->GetText();
if(name.length() > 0 && value.length() > 0)
CDNSNameCache::Add(name, value);
element = element->NextSiblingElement("entry");
}
}
XMLUtils::GetInt(pRootElement, "bginfoloadermaxthreads", m_bgInfoLoaderMaxThreads);
m_bgInfoLoaderMaxThreads = std::max(3, m_bgInfoLoaderMaxThreads);
// load in the GUISettings overrides:
g_guiSettings.LoadXML(pRootElement, true); // true to hide the settings we read in
return true;
}
bool CAdvancedSettings::Load()
{
// NOTE: This routine should NOT set the default of any of these parameters
// it should instead use the versions of GetString/Integer/Float that
// don't take defaults in. Defaults are set in the constructor above
CStdString advancedSettingsXML;
advancedSettingsXML = g_settings.GetUserDataItem("advancedsettings.xml");
TiXmlDocument advancedXML;
if (!CFile::Exists(advancedSettingsXML))
{ // tell the user it doesn't exist
CLog::Log(LOGNOTICE, "No advancedsettings.xml to load (%s)", advancedSettingsXML.c_str());
return false;
}
if (!advancedXML.LoadFile(advancedSettingsXML))
{
CLog::Log(LOGERROR, "Error loading %s, Line %d\n%s", advancedSettingsXML.c_str(), advancedXML.ErrorRow(), advancedXML.ErrorDesc());
return false;
}
TiXmlElement *pRootElement = advancedXML.RootElement();
if (!pRootElement || strcmpi(pRootElement->Value(),"advancedsettings") != 0)
{
CLog::Log(LOGERROR, "Error loading %s, no <advancedsettings> node", advancedSettingsXML.c_str());
return false;
}
// succeeded - tell the user it worked
CLog::Log(LOGNOTICE, "Loaded advancedsettings.xml from %s", advancedSettingsXML.c_str());
// Dump contents of AS.xml to debug log
TiXmlPrinter printer;
printer.SetLineBreak("\n");
printer.SetIndent(" ");
advancedXML.Accept(&printer);
CLog::Log(LOGDEBUG, "Contents of %s are...\n%s", advancedSettingsXML.c_str(), printer.CStr());
TiXmlElement *pElement = pRootElement->FirstChildElement("audio");
if (pElement)
{
XMLUtils::GetFloat(pElement, "ac3downmixgain", m_ac3Gain, -96.0f, 96.0f);
XMLUtils::GetInt(pElement, "headroom", m_audioHeadRoom, 0, 12);
XMLUtils::GetString(pElement, "defaultplayer", m_audioDefaultPlayer);
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_audioPlayCountMinimumPercent, 0.0f, 100.0f);
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_musicUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_musicTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_musicTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_musicTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_musicTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_musicPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_musicPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_musicPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_musicPercentSeekBackwardBig, -100, 0);
XMLUtils::GetInt(pElement, "resample", m_musicResample, 0, 192000);
TiXmlElement* pAudioExcludes = pElement->FirstChildElement("excludefromlisting");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromListingRegExps);
pAudioExcludes = pElement->FirstChildElement("excludefromscan");
if (pAudioExcludes)
GetCustomRegexps(pAudioExcludes, m_audioExcludeFromScanRegExps);
XMLUtils::GetString(pElement, "audiohost", m_audioHost);
XMLUtils::GetBoolean(pElement, "applydrc", m_audioApplyDrc);
TiXmlElement* pDDPlusCert = pElement->FirstChildElement("ddpluscert");
if( pDDPlusCert )
{
XMLUtils::GetBoolean(pDDPlusCert, "ltrtmode", m_ddplus.ltmode);
XMLUtils::GetBoolean(pDDPlusCert, "rfmode", m_ddplus.rfmode);
XMLUtils::GetBoolean(pDDPlusCert, "lfemode", m_ddplus.lfemode);
XMLUtils::GetBoolean(pDDPlusCert, "drc", m_ddplus.drc);
CStdString mono;
XMLUtils::GetString(pDDPlusCert, "monomode", mono);
if( mono == "stereo" ) m_ddplus.monomode = __ddplus::_stereo;
else if( mono == "left" ) m_ddplus.monomode = __ddplus::_left;
else if( mono == "right" ) m_ddplus.monomode = __ddplus::_right;
else if( mono == "mixed" ) m_ddplus.monomode = __ddplus::_mixed;
}
}
pElement = pRootElement->FirstChildElement("karaoke");
if (pElement)
{
XMLUtils::GetFloat(pElement, "syncdelaycdg", m_karaokeSyncDelayCDG, -3.0f, 3.0f); // keep the old name for comp
XMLUtils::GetFloat(pElement, "syncdelaylrc", m_karaokeSyncDelayLRC, -3.0f, 3.0f);
XMLUtils::GetBoolean(pElement, "alwaysreplacegenre", m_karaokeChangeGenreForKaraokeSongs );
XMLUtils::GetBoolean(pElement, "storedelay", m_karaokeKeepDelay );
XMLUtils::GetInt(pElement, "autoassignstartfrom", m_karaokeStartIndex, 1, 2000000000);
XMLUtils::GetBoolean(pElement, "nocdgbackground", m_karaokeAlwaysEmptyOnCdgs );
XMLUtils::GetBoolean(pElement, "lookupsongbackground", m_karaokeUseSongSpecificBackground );
TiXmlElement* pKaraokeBackground = pElement->FirstChildElement("defaultbackground");
if (pKaraokeBackground)
{
const char* attr = pKaraokeBackground->Attribute("type");
if ( attr )
m_karaokeDefaultBackgroundType = attr;
attr = pKaraokeBackground->Attribute("path");
if ( attr )
m_karaokeDefaultBackgroundFilePath = attr;
}
}
pElement = pRootElement->FirstChildElement("video");
if (pElement)
{
XMLUtils::GetFloat(pElement, "subsdelayrange", m_videoSubsDelayRange, 10, 600);
XMLUtils::GetFloat(pElement, "audiodelayrange", m_videoAudioDelayRange, 10, 600);
XMLUtils::GetInt(pElement, "blackbarcolour", m_videoBlackBarColour, 0, 255);
XMLUtils::GetString(pElement, "defaultplayer", m_videoDefaultPlayer);
XMLUtils::GetString(pElement, "defaultdvdplayer", m_videoDefaultDVDPlayer);
XMLUtils::GetBoolean(pElement, "fullscreenonmoviestart", m_fullScreenOnMovieStart);
XMLUtils::GetFloat(pElement, "playcountminimumpercent", m_videoPlayCountMinimumPercent, 0.0f, 100.0f);
XMLUtils::GetInt(pElement, "ignoreatstart", m_videoIgnoreAtStart, 0, 900);
XMLUtils::GetInt(pElement, "ignoreatend", m_videoIgnoreAtEnd, 0, 900);
XMLUtils::GetInt(pElement, "smallstepbackseconds", m_videoSmallStepBackSeconds, 1, INT_MAX);
XMLUtils::GetInt(pElement, "smallstepbacktries", m_videoSmallStepBackTries, 1, 10);
XMLUtils::GetInt(pElement, "smallstepbackdelay", m_videoSmallStepBackDelay, 100, 5000); //MS
XMLUtils::GetBoolean(pElement, "usetimeseeking", m_videoUseTimeSeeking);
XMLUtils::GetInt(pElement, "timeseekforward", m_videoTimeSeekForward, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackward", m_videoTimeSeekBackward, -6000, 0);
XMLUtils::GetInt(pElement, "timeseekforwardbig", m_videoTimeSeekForwardBig, 0, 6000);
XMLUtils::GetInt(pElement, "timeseekbackwardbig", m_videoTimeSeekBackwardBig, -6000, 0);
XMLUtils::GetInt(pElement, "percentseekforward", m_videoPercentSeekForward, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackward", m_videoPercentSeekBackward, -100, 0);
XMLUtils::GetInt(pElement, "percentseekforwardbig", m_videoPercentSeekForwardBig, 0, 100);
XMLUtils::GetInt(pElement, "percentseekbackwardbig", m_videoPercentSeekBackwardBig, -100, 0);
TiXmlElement* pVideoExcludes = pElement->FirstChildElement("excludefromlisting");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoExcludeFromListingRegExps);
pVideoExcludes = pElement->FirstChildElement("excludefromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_moviesExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("excludetvshowsfromscan");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_tvshowExcludeFromScanRegExps);
pVideoExcludes = pElement->FirstChildElement("cleanstrings");
if (pVideoExcludes)
GetCustomRegexps(pVideoExcludes, m_videoCleanStringRegExps);
XMLUtils::GetString(pElement,"cleandatetime", m_videoCleanDateTimeRegExp);
XMLUtils::GetString(pElement,"postprocessing",m_videoPPFFmpegType);
m_DXVACheckCompatibilityPresent = XMLUtils::GetBoolean(pElement,"checkdxvacompatibility", m_DXVACheckCompatibility);
}
pElement = pRootElement->FirstChildElement("musiclibrary");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "hideallitems", m_bMusicLibraryHideAllItems);
XMLUtils::GetInt(pElement, "recentlyaddeditems", m_iMusicLibraryRecentlyAddedItems, 1, INT_MAX);
XMLUtils::GetBoolean(pElement, "prioritiseapetags", m_prioritiseAPEv2tags);
XMLUtils::GetBoolean(pElement, "allitemsonbottom", m_bMusicLibraryAllItemsOnBottom);
XMLUtils::GetBoolean(pElement, "albumssortbyartistthenyear", m_bMusicLibraryAlbumsSortByArtistThenYear);
XMLUtils::GetString(pElement, "albumformat", m_strMusicLibraryAlbumFormat);
XMLUtils::GetString(pElement, "albumformatright", m_strMusicLibraryAlbumFormatRight);
XMLUtils::GetString(pElement, "itemseparator", m_musicItemSeparator);
}
pElement = pRootElement->FirstChildElement("videolibrary");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "hideallitems", m_bVideoLibraryHideAllItems);
XMLUtils::GetBoolean(pElement, "allitemsonbottom", m_bVideoLibraryAllItemsOnBottom);
XMLUtils::GetInt(pElement, "recentlyaddeditems", m_iVideoLibraryRecentlyAddedItems, 1, INT_MAX);
XMLUtils::GetBoolean(pElement, "hiderecentlyaddeditems", m_bVideoLibraryHideRecentlyAddedItems);
XMLUtils::GetBoolean(pElement, "hideemptyseries", m_bVideoLibraryHideEmptySeries);
XMLUtils::GetBoolean(pElement, "cleanonupdate", m_bVideoLibraryCleanOnUpdate);
XMLUtils::GetString(pElement, "itemseparator", m_videoItemSeparator);
XMLUtils::GetBoolean(pElement, "exportautothumbs", m_bVideoLibraryExportAutoThumbs);
TiXmlElement* pMyMovies = pElement->FirstChildElement("mymovies");
if (pMyMovies)
XMLUtils::GetBoolean(pMyMovies, "categoriestogenres", m_bVideoLibraryMyMoviesCategoriesToGenres);
}
// Backward-compatibility of ExternalPlayer config
pElement = pRootElement->FirstChildElement("externalplayer");
if (pElement)
{
CLog::Log(LOGWARNING, "External player configuration has been removed from advancedsettings.xml. It can now be configed in userdata/playercorefactory.xml");
}
pElement = pRootElement->FirstChildElement("slideshow");
if (pElement)
{
XMLUtils::GetFloat(pElement, "panamount", m_slideshowPanAmount, 0.0f, 20.0f);
XMLUtils::GetFloat(pElement, "zoomamount", m_slideshowZoomAmount, 0.0f, 20.0f);
XMLUtils::GetFloat(pElement, "blackbarcompensation", m_slideshowBlackBarCompensation, 0.0f, 50.0f);
}
pElement = pRootElement->FirstChildElement("lcd");
if (pElement)
{
XMLUtils::GetInt(pElement, "rows", m_lcdRows, 1, 4);
XMLUtils::GetInt(pElement, "columns", m_lcdColumns, 1, 40);
XMLUtils::GetInt(pElement, "address1", m_lcdAddress1, 0, 0x100);
XMLUtils::GetInt(pElement, "address2", m_lcdAddress2, 0, 0x100);
XMLUtils::GetInt(pElement, "address3", m_lcdAddress3, 0, 0x100);
XMLUtils::GetInt(pElement, "address4", m_lcdAddress4, 0, 0x100);
XMLUtils::GetBoolean(pElement, "heartbeat", m_lcdHeartbeat);
XMLUtils::GetInt(pElement, "scrolldelay", m_lcdScrolldelay, -8, 8);
}
pElement = pRootElement->FirstChildElement("network");
if (pElement)
{
XMLUtils::GetInt(pElement, "autodetectpingtime", m_autoDetectPingTime, 1, 240);
XMLUtils::GetInt(pElement, "curlclienttimeout", m_curlconnecttimeout, 1, 1000);
XMLUtils::GetInt(pElement, "curllowspeedtime", m_curllowspeedtime, 1, 1000);
XMLUtils::GetInt(pElement, "curlretries", m_curlretries, 0, 10);
}
pElement = pRootElement->FirstChildElement("samba");
if (pElement)
{
XMLUtils::GetString(pElement, "doscodepage", m_sambadoscodepage);
XMLUtils::GetInt(pElement, "clienttimeout", m_sambaclienttimeout, 5, 100);
XMLUtils::GetBoolean(pElement, "statfiles", m_sambastatfiles);
}
pElement = pRootElement->FirstChildElement("httpdirectory");
if (pElement)
XMLUtils::GetBoolean(pElement, "statfilesize", m_bHTTPDirectoryStatFilesize);
XMLUtils::GetString(pRootElement, "cddbaddress", m_cddbAddress);
#ifdef HAS_HAL
XMLUtils::GetBoolean(pRootElement, "usehalmount", m_useHalMount);
#endif
XMLUtils::GetBoolean(pRootElement, "nodvdrom", m_noDVDROM);
XMLUtils::GetBoolean(pRootElement, "usemultipaths", m_useMultipaths);
#ifdef HAS_SDL
XMLUtils::GetBoolean(pRootElement, "fullscreen", m_startFullScreen);
#endif
XMLUtils::GetInt(pRootElement, "songinfoduration", m_songInfoDuration, 0, INT_MAX);
XMLUtils::GetInt(pRootElement, "busydialogdelay", m_busyDialogDelay, 0, 5000);
XMLUtils::GetInt(pRootElement, "playlistretries", m_playlistRetries, -1, 5000);
XMLUtils::GetInt(pRootElement, "playlisttimeout", m_playlistTimeout, 0, 5000);
XMLUtils::GetBoolean(pRootElement,"rootovershoot",m_bUseEvilB);
XMLUtils::GetBoolean(pRootElement,"glrectanglehack", m_GLRectangleHack);
XMLUtils::GetInt(pRootElement,"skiploopfilter", m_iSkipLoopFilter, -16, 48);
XMLUtils::GetFloat(pRootElement, "forcedswaptime", m_ForcedSwapTime, 0.0, 100.0);
XMLUtils::GetBoolean(pRootElement,"osx_gl_fullscreen", m_osx_GLFullScreen);
XMLUtils::GetFloat(pRootElement,"sleepbeforeflip", m_sleepBeforeFlip, 0.0f, 1.0f);
XMLUtils::GetBoolean(pRootElement,"virtualshares", m_bVirtualShares);
//Tuxbox
pElement = pRootElement->FirstChildElement("tuxbox");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "audiochannelselection", m_bTuxBoxAudioChannelSelection);
XMLUtils::GetBoolean(pElement, "submenuselection", m_bTuxBoxSubMenuSelection);
XMLUtils::GetBoolean(pElement, "pictureicon", m_bTuxBoxPictureIcon);
XMLUtils::GetBoolean(pElement, "sendallaudiopids", m_bTuxBoxSendAllAPids);
XMLUtils::GetInt(pElement, "epgrequesttime", m_iTuxBoxEpgRequestTime, 0, 3600);
XMLUtils::GetInt(pElement, "defaultsubmenu", m_iTuxBoxDefaultSubMenu, 1, 4);
XMLUtils::GetInt(pElement, "defaultrootmenu", m_iTuxBoxDefaultRootMenu, 0, 4);
XMLUtils::GetInt(pElement, "zapwaittime", m_iTuxBoxZapWaitTime, 0, 120);
}
// Myth TV
pElement = pRootElement->FirstChildElement("myth");
if (pElement)
{
XMLUtils::GetInt(pElement, "movielength", m_iMythMovieLength);
}
// EDL commercial break handling
pElement = pRootElement->FirstChildElement("edl");
if (pElement)
{
XMLUtils::GetBoolean(pElement, "mergeshortcommbreaks", m_bEdlMergeShortCommBreaks);
XMLUtils::GetInt(pElement, "maxcommbreaklength", m_iEdlMaxCommBreakLength, 0, 10 * 60); // Between 0 and 10 minutes
XMLUtils::GetInt(pElement, "mincommbreaklength", m_iEdlMinCommBreakLength, 0, 5 * 60); // Between 0 and 5 minutes
XMLUtils::GetInt(pElement, "maxcommbreakgap", m_iEdlMaxCommBreakGap, 0, 5 * 60); // Between 0 and 5 minutes.
XMLUtils::GetInt(pElement, "maxstartgap", m_iEdlMaxStartGap, 0, 10 * 60); // Between 0 and 10 minutes
}
// picture exclude regexps
TiXmlElement* pPictureExcludes = pRootElement->FirstChildElement("pictureexcludes");
if (pPictureExcludes)
GetCustomRegexps(pPictureExcludes, m_pictureExcludeFromListingRegExps);
// picture extensions
CStdString extraExtensions;
TiXmlElement* pExts = pRootElement->FirstChildElement("pictureextensions");
if (pExts)
GetCustomExtensions(pExts,g_stSettings.m_pictureExtensions);
// music extensions
pExts = pRootElement->FirstChildElement("musicextensions");
if (pExts)
GetCustomExtensions(pExts,g_stSettings.m_musicExtensions);
// video extensions
pExts = pRootElement->FirstChildElement("videoextensions");
if (pExts)
GetCustomExtensions(pExts,g_stSettings.m_videoExtensions);
m_vecTokens.clear();
CLangInfo::LoadTokens(pRootElement->FirstChild("sorttokens"),m_vecTokens);
XMLUtils::GetBoolean(pRootElement, "displayremotecodes", m_displayRemoteCodes);
// TODO: Should cache path be given in terms of our predefined paths??
// Are we even going to have predefined paths??
CSettings::GetPath(pRootElement, "cachepath", m_cachePath);
CUtil::AddSlashAtEnd(m_cachePath);
g_LangCodeExpander.LoadUserCodes(pRootElement->FirstChildElement("languagecodes"));
// stacking regexps
TiXmlElement* pVideoStacking = pRootElement->FirstChildElement("moviestacking");
if (pVideoStacking)
GetCustomRegexps(pVideoStacking, m_videoStackRegExps);
//tv stacking regexps
TiXmlElement* pTVStacking = pRootElement->FirstChildElement("tvshowmatching");
if (pTVStacking)
GetCustomTVRegexps(pTVStacking, m_tvshowStackRegExps);
// path substitutions
TiXmlElement* pPathSubstitution = pRootElement->FirstChildElement("pathsubstitution");
if (pPathSubstitution)
{
m_pathSubstitutions.clear();
CLog::Log(LOGDEBUG,"Configuring path substitutions");
TiXmlNode* pSubstitute = pPathSubstitution->FirstChildElement("substitute");
while (pSubstitute)
{
CStdString strFrom, strTo;
TiXmlNode* pFrom = pSubstitute->FirstChild("from");
if (pFrom)
strFrom = pFrom->FirstChild()->Value();
TiXmlNode* pTo = pSubstitute->FirstChild("to");
if (pTo)
strTo = pTo->FirstChild()->Value();
if (!strFrom.IsEmpty() && !strTo.IsEmpty())
{
CLog::Log(LOGDEBUG," Registering substition pair:");
CLog::Log(LOGDEBUG," From: [%s]", strFrom.c_str());
CLog::Log(LOGDEBUG," To: [%s]", strTo.c_str());
// keep literal commas since we use comma as a seperator
strFrom.Replace(",",",,");
strTo.Replace(",",",,");
m_pathSubstitutions.push_back(strFrom + " , " + strTo);
}
else
{
// error message about missing tag
if (strFrom.IsEmpty())
CLog::Log(LOGERROR," Missing <from> tag");
else
CLog::Log(LOGERROR," Missing <to> tag");
}
// get next one
pSubstitute = pSubstitute->NextSiblingElement("substitute");
}
}
XMLUtils::GetInt(pRootElement, "remotedelay", m_remoteDelay, 1, 20);
XMLUtils::GetFloat(pRootElement, "controllerdeadzone", m_controllerDeadzone, 0.0f, 1.0f);
XMLUtils::GetInt(pRootElement, "thumbsize", m_thumbSize, 64, 1024);
XMLUtils::GetBoolean(pRootElement, "useddsfanart", m_useDDSFanart);
XMLUtils::GetBoolean(pRootElement, "playlistasfolders", m_playlistAsFolders);
XMLUtils::GetBoolean(pRootElement, "detectasudf", m_detectAsUdf);
// music thumbs
CStdString extraThumbs;
TiXmlElement* pThumbs = pRootElement->FirstChildElement("musicthumbs");
if (pThumbs)
GetCustomExtensions(pThumbs,m_musicThumbs);
// dvd thumbs
pThumbs = pRootElement->FirstChildElement("dvdthumbs");
if (pThumbs)
GetCustomExtensions(pThumbs,m_dvdThumbs);
// movie fanarts
TiXmlElement* pFanart = pRootElement->FirstChildElement("fanart");
if (pFanart)
GetCustomExtensions(pFanart,m_fanartImages);
// music filename->tag filters
TiXmlElement* filters = pRootElement->FirstChildElement("musicfilenamefilters");
if (filters)
{
TiXmlNode* filter = filters->FirstChild("filter");
while (filter)
{
if (filter->FirstChild())
m_musicTagsFromFileFilters.push_back(filter->FirstChild()->ValueStr());
filter = filter->NextSibling("filter");
}
}
TiXmlElement* pHostEntries = pRootElement->FirstChildElement("hosts");
if (pHostEntries)
{
TiXmlElement* element = pHostEntries->FirstChildElement("entry");
while(element)
{
CStdString name = element->Attribute("name");
CStdString value;
if(element->GetText())
value = element->GetText();
if(name.length() > 0 && value.length() > 0)
CDNSNameCache::Add(name, value);
element = element->NextSiblingElement("entry");
}
}
XMLUtils::GetString(pRootElement, "cputempcommand", m_cpuTempCmd);
XMLUtils::GetString(pRootElement, "gputempcommand", m_gpuTempCmd);
XMLUtils::GetBoolean(pRootElement, "alwaysontop", m_alwaysOnTop);
XMLUtils::GetInt(pRootElement, "bginfoloadermaxthreads", m_bgInfoLoaderMaxThreads);
m_bgInfoLoaderMaxThreads = std::max(1, m_bgInfoLoaderMaxThreads);
XMLUtils::GetBoolean(pRootElement, "measurerefreshrate", m_measureRefreshrate);
XMLUtils::GetBoolean(pRootElement,"wireframe",m_bWireFrameMode);
XMLUtils::GetBoolean(pRootElement,"countpixels",m_bCountPixels);
XMLUtils::GetInt(pRootElement, "logfilesize", m_logFileSize);
XMLUtils::GetBoolean(pRootElement, "forcevideohardwaredecoding", m_bForceVideoHardwareDecoding);
XMLUtils::GetBoolean(pRootElement, "forceaudiohardwarepassthrough", m_bForceAudioHardwarePassthrough);
XMLUtils::GetBoolean(pRootElement, "forcewmv3flushing", m_bForceWMV3Flushing);
XMLUtils::GetBoolean(pRootElement,"allowd3d9ex", m_AllowD3D9Ex);
XMLUtils::GetBoolean(pRootElement,"forced3d9ex", m_ForceD3D9Ex);
XMLUtils::GetBoolean(pRootElement,"allowdynamictextures", m_AllowDynamicTextures);
XMLUtils::GetUInt(pRootElement,"restrictcapsmask", m_RestrictCapsMask);
// Disk Quota settings
pElement = pRootElement->FirstChildElement("quota");
if (pElement)
{
uint32_t tmp_size = 0;
if (XMLUtils::GetUInt(pElement, "httpcachemaxsize", tmp_size))
{
m_httpCacheMaxSize = tmp_size * 1024;
}
if (XMLUtils::GetUInt(pElement, "appsmaxsize", tmp_size))
{
m_appsMaxSize = tmp_size * 1024;
}
if (XMLUtils::GetUInt(pElement, "thumbsmaxsize", tmp_size))
{
m_thumbsMaxSize = tmp_size * 1024;
}
}
// load in the GUISettings overrides:
g_guiSettings.LoadXML(pRootElement, true); // true to hide the settings we read in
return true;
}
bool XrcCodeGenerator::GenerateCode( PObjectBase project )
{
m_cw->Clear();
m_contextMenus.clear();
ticpp::Document doc;
ticpp::Declaration decl( "1.0", "UTF-8", "yes" );
doc.LinkEndChild( &decl );
ticpp::Element element( "resource" );
element.SetAttribute( "xmlns", "http://www.wxwindows.org/wxxrc" );
element.SetAttribute( "version", "2.3.0.1" );
// If project is not actually a "Project", generate it
if ( project->GetClassName() == wxT("Project") )
{
for( unsigned int i = 0; i < project->GetChildCount(); i++ )
{
ticpp::Element* child = GetElement( project->GetChild( i ) );
if ( child )
{
element.LinkEndChild( child );
delete child;
}
}
}
else
{
ticpp::Element* child = GetElement( project );
if ( child )
{
element.LinkEndChild( child );
delete child;
}
}
// generate context menus as top-level menus
for( std::vector<ticpp::Element*>::iterator it = m_contextMenus.begin(); it != m_contextMenus.end(); ++it )
{
element.LinkEndChild( *it );
delete *it;
}
doc.LinkEndChild( &element );
TiXmlPrinter printer;
printer.SetIndent( "\t" );
#if defined( __WXMSW__ )
printer.SetLineBreak( "\r\n" );
#elif defined( __WXMAC__ )
printer.SetLineBreak( "\r" );
#else
printer.SetLineBreak( "\n" );
#endif
doc.Accept( &printer );
const std::string& xrcFile = printer.Str();
m_cw->Write( _WXSTR( xrcFile ) );
return true;
}
