Highlighter::Highlighter(QTextDocument *parent,QString SpellDic,bool spellCheckState) :
QSyntaxHighlighter(parent) {
HighlightingRule rule;
spellCheckFormat.setUnderlineColor(QColor(Qt::red));
spellCheckFormat.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
//Settings for online spellchecking
if(SpellDic!=""){
//mWords.clear();
spell_dic=SpellDic.left(SpellDic.length()-4);
pChecker =new Hunspell(spell_dic.toLatin1()+".aff",spell_dic.toLatin1()+".dic");
spell_encoding=QString(pChecker->get_dic_encoding());
codec = QTextCodec::codecForName(spell_encoding.toLatin1());
QFileInfo fi(SpellDic);
if (fi.exists() && fi.isReadable()) spellCheckActive=true;
else spellCheckActive=false;
// get user config dictionary
QSettings setting;
QString filePath=QFileInfo(setting.fileName()).absoluteFilePath();
filePath=filePath+"/User_"+QFileInfo(spell_dic.toLatin1()+".dic").fileName();
/* std::cout << qPrintable(filePath) << std::endl;*/
fi=QFileInfo(filePath);
if (fi.exists() && fi.isReadable()){
pChecker->add_dic(filePath.toLatin1());
}
else filePath="";
}
else spellCheckActive=false;
spellerError=!spellCheckActive;
spellCheckActive=spellCheckActive && spellCheckState;
}
void init(QSettings &set)
{
Q_ASSERT(qApp != NULL);
qDebug() << "Initiating Q(Core)Application";
qApp->setApplicationName(APP_NAME);
qApp->setOrganizationDomain(ORG_DOMAIN);
qApp->setOrganizationName(ORG_DOMAIN);
#ifndef CONSOLE
qApp->setWindowIcon(QIcon(QStringLiteral(":/icon/svg")));
#endif
if (qApp->arguments().contains(QStringLiteral("--killall"))) {
killall(set);
exit(EXIT_SUCCESS);
}
if (qApp->arguments().contains(QStringLiteral("--reset"))) {
qDebug() << "<- Reset invoked";
killall(set);
set.clear();
set.sync();
qDebug() << "-> Cleared settings";
}
qDebug() << "Settings:" << set.fileName();
}
QString Notepadqq::extensionsPath()
{
QSettings settings;
QFileInfo f = QFileInfo(settings.fileName());
return f.absoluteDir().absoluteFilePath("extensions");
}
void SetupDialog::commitSettings(bool skipped)
{
QSettings settings;
DEBUG << "Settings location is " << settings.fileName();
settings.setValue("app/wizard_done", true);
if(!skipped)
{
if(_ui->storeIniFormatCheckBox->isChecked())
{
settings.setValue("app/ini_format", true);
settings.setValue("app/app_data", _appDataDir);
settings.sync();
settings.setPath(QSettings::IniFormat, QSettings::UserScope,
_appDataDir);
settings.setDefaultFormat(QSettings::IniFormat);
}
QSettings settings;
settings.setValue("app/app_data", _appDataDir);
settings.setValue("tarsnap/path", _tarsnapDir);
settings.setValue("tarsnap/version", _tarsnapVersion);
settings.setValue("tarsnap/cache", _tarsnapCacheDir);
settings.setValue("tarsnap/key", _tarsnapKeyFile);
settings.setValue("tarsnap/user", _ui->tarsnapUserLineEdit->text());
settings.setValue("tarsnap/machine", _ui->machineNameLineEdit->text());
}
settings.sync();
accept();
}
void parseArgs(QStringList args)
{
QSettings settings;
QString sDefaultHostName = QHostInfo::localHostName();
QString sHostName = settings.value("hostname", QVariant(sDefaultHostName)).toString();
settings.setValue("hostname", QVariant(sHostName));
LOG_IN(QString("SETTINGS host name: %1").arg(sHostName));
QString sDefaultPort = "54340";
QString sPort = settings.value("port", QVariant(sDefaultPort)).toString();
settings.setValue("port", QVariant(sPort));
LOG_IN(QString("SETTINGS host port: %1").arg(sPort));
QString sDefaultRootPath = QString("%1/.Hobbyist_Software/VLC_Streamer/Root").arg(QDir::homePath());
QString sRootPath = settings.value("root", QVariant(sDefaultRootPath)).toString();
settings.setValue("root", QVariant(sRootPath));
LOG_IN(QString("SETTINGS root: %1").arg(sRootPath));
LOG_IN(QString("SETTINGS settings file %1").arg(settings.fileName()));
if (!settings.isWritable())
{
LOG_ER(QString("SETTINGS could not write file"));
}
settings.sync();
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
app.setOrganizationDomain("github/gdpurjyfs");
app.setOrganizationName("gdpurjyfs");
app.setApplicationName("TestSettings");
app.setApplicationDisplayName("TestSettings");
app.setApplicationVersion("0.0.1");
QSettings extraSettings;
extraSettings.beginGroup("CPP");
extraSettings.setValue("cppSettings", "this is cpp settings");
extraSettings.endGroup();
QQmlApplicationEngine engine;
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
// try to get settings that create in qml
QSettings applicationWindowOption;
// QVariant(int, 517)
qDebug() << applicationWindowOption.value("ApplicationWindow/applicationWindowWidth");
// "\\HKEY_CURRENT_USER\\Software\\gdpurjyfs\\TestSettings"
qDebug() << applicationWindowOption.fileName();
return app.exec();
}
void ColorThemeEngine::FillQML (QSettings& settings)
{
QMLColors_.clear ();
for (const auto& group : settings.childGroups ())
{
settings.beginGroup (group);
auto& hash = QMLColors_ [group];
for (const auto& key : settings.childKeys ())
hash [key] = ParseColor (settings.value (key));
settings.endGroup ();
}
auto fixup = [this, &settings] (const QString& section,
const QString& name, const QString& fallback) -> void
{
auto& sec = QMLColors_ [section];
if (sec.contains (name))
return;
qWarning () << Q_FUNC_INFO
<< settings.fileName ()
<< "lacks"
<< (section + "_" + name)
<< "; falling back to"
<< fallback;
sec [name] = sec [fallback];
};
fixup ("ToolButton", "HoveredTopColor", "SelectedTopColor");
fixup ("ToolButton", "HoveredBottomColor", "SelectedBottomColor");
}
Properties::Properties(const QString& filename) : filename(filename)
{
if (filename.isEmpty()) {
QSettings settings;
this->filename = settings.fileName();
}
qDebug("Properties constructor called");
}
void Helpers::initConfig(void)
{
if (!containsRememberLogin())
setRememberLogin();
// Ensure permissions
QSettings s;
QFile::setPermissions(s.fileName(), QFileDevice::ReadOwner | QFileDevice::WriteOwner);
}
void DBThread::Initialize()
{
QSettings settings;//(QSettings::UserScope, "osmscout.fransschreuder", "osmscout");
std::cout<<"Settings.status: "<<settings.status()<<std::endl;
int selectedMap = settings.value("selectedmap", 0).toInt();
settings.setValue("selectedmap", selectedMap);
std::cout<<"Settings filename "<<settings.fileName().toLocal8Bit().data()<<std::endl;
QStringList mapDirs = findValidMapDirs();
if(mapDirs.size()<=0)
{
std::cout<<"Could not find valid map dir"<<std::endl;
return;
}
if(selectedMap>=mapDirs.size())
{
selectedMap = 0;
}
QString databaseDirectory = mapDirs[selectedMap];
QString stylesheetFilename=databaseDirectory+"/standard.oss";
if (database->Open(databaseDirectory.toLocal8Bit().data())) {
osmscout::TypeConfigRef typeConfig=database->GetTypeConfig();
if (typeConfig) {
styleConfig=new osmscout::StyleConfig(typeConfig);
delete painter;
painter=NULL;
if (styleConfig->Load(stylesheetFilename.toLocal8Bit().data())) {
painter=new osmscout::MapPainterQt(styleConfig);
}
else {
//qDebug() << "Cannot load style sheet!";
styleConfig=NULL;
}
}
else {
//qDebug() << "TypeConfig invalid!";
styleConfig=NULL;
}
}
else {
//qDebug() << "Cannot open database!";
return;
}
DatabaseLoadedResponse response;
if (!database->GetBoundingBox(response.boundingBox)) {
//qDebug() << "Cannot read initial bounding box";
return;
}
emit InitialisationFinished(response);
}
Settings::Settings(const QSettings &settingsSource)
: m_Settings(settingsSource.fileName(), settingsSource.format())
{
if (s_Instance != nullptr) {
throw std::runtime_error("second instance of \"Settings\" created");
} else {
s_Instance = this;
}
}
/*!
* Saves the settings to a file. The settings are first
* saved to a temporary file, and then that file is copied
* over the original settings. This avoids clearing settings
* when there's no disk space.
* \param originalSettings Settings to save.
*/
static bool doSync(QSettings &originalSettings, QScopedPointer<QFileSystemWatcher>& watcher)
{
bool returnValue = false;
QString tempFileName = createTempFile(originalSettings.fileName());
if (!tempFileName.isEmpty()) {
QSettings copiedSettings(tempFileName, QSettings::IniFormat);
if (copySettings(originalSettings, copiedSettings)) {
copiedSettings.sync();
if (copiedSettings.status() == QSettings::NoError) {
renameSettingFile(tempFileName, originalSettings.fileName());
originalSettings.sync();
returnValue = true;
}
}
}
addPathsToWatcher(originalSettings.fileName(), watcher);
return returnValue;
}
void PreferencesDialog::_loadSettings()
{
QSettings settings;
qDebug() << "Load settings from" << settings.fileName();
this->_ui->defaultHosterComboBox->setCurrentText(settings.value("app/default_hoster", "").toString());
this->_ui->traktClientIdEdit->setText(settings.value("trakt/client_id", "").toString());
this->_ui->traktUsernameEdit->setText(settings.value("trakt/username", "").toString());
this->_ui->themoviedbKeyEdit->setText(settings.value("themoviedb/key", "").toString());
}
void PreferencesDialog::_saveSettings()
{
QSettings settings;
qDebug() << "Save settings in" << settings.fileName();
settings.setValue("app/default_hoster", this->_ui->defaultHosterComboBox->currentText());
settings.setValue("trakt/client_id", this->_ui->traktClientIdEdit->text().trimmed());
settings.setValue("trakt/username", this->_ui->traktUsernameEdit->text().trimmed());
settings.setValue("themoviedb/key", this->_ui->themoviedbKeyEdit->text().trimmed());
}
QString CuteChessCoreApplication::configPath()
{
// QDesktopServices requires QtGui
QSettings settings;
QFileInfo fi(settings.fileName());
QDir dir(fi.absolutePath());
if (!dir.exists())
dir.mkpath(fi.absolutePath());
return fi.absolutePath();
}
bool SessionStoreFile::deleteSessionData(Context *c, const QString &sid, const QString &key)
{
Q_D(const SessionStoreFile);
QSettings *settings = d->checkSessionFileStorage(c, sid);
settings->remove(key);
if (settings->allKeys().isEmpty()) {
QFile::remove(settings->fileName());
delete settings;
c->setProperty(SESSION_STORE_FILE, QVariant());
}
return true;
}
static void
initDescfile(QSettings& s, QSize size, int FPS)
{
s.beginGroup("qarv_raw_video_description");
s.remove("");
s.setValue("description_version", "0.1");
QFileInfo finfo(s.fileName());
QString fname(finfo.completeBaseName());
s.setValue("file_name", fname);
s.setValue("frame_size", size);
s.setValue("nominal_fps", FPS);
}
int main(int argc, char *argv[])
{
Q_INIT_RESOURCE(lxqtconfigrandr);
QApplication::setApplicationName("lxqt-config-randr");
#ifdef STR_VERSION
QApplication::setApplicationVersion(QString("%1").arg(STR_VERSION));
#endif
QApplication::setOrganizationDomain("lxqt");
QSettings::setDefaultFormat(QSettings::NativeFormat);
QApplication a(argc, argv);
bool startup;
parse_args(argc, argv, startup);
if(startup)
{
QSettings config;
QFile fileconfig(config.fileName());
if(fileconfig.exists())
{
LoaderConfigLogin loader;
loader.execute();
}
else
{
qDebug() << "File config not exist: " << config.fileName();
qDebug() << "Not load config. Exit without change";
}
exit(0);
}
else
{
LXQtRandrConfig *w = new LXQtRandrConfig;
w->show();
}
return a.exec();
}
QString CuteChessApplication::configPath()
{
// We want to have the exact same config path in "gui" and
// "cli" applications so that they can share resources
QSettings settings;
QFileInfo fi(settings.fileName());
QDir dir(fi.absolutePath());
if (!dir.exists())
dir.mkpath(fi.absolutePath());
return fi.absolutePath();
}
void FilenamePin::saveSettings( QSettings &pSettings ) const
{
QString FileName = ( mPin->direction() == PIN_INPUT ? mPin->value().toString() : mValues.first() );
if( !FileName.isEmpty() )
{
QFileInfo FileInfo( pSettings.fileName() );
QDir FileDir( FileInfo.absolutePath() );
FileName = FileDir.relativeFilePath( FileName );
pSettings.setValue( "filename", FileName );
}
}
void VorbitalDlg::LoadSettings()
{
QSettings* configData = new QSettings("Zeta Centauri", "Vorbital Player");
qDebug() << "LoadSettings loading file " << configData->fileName() << ".";
// Randomizer setting.
_randomize = configData->value( "randomize" ).toInt();
if( _randomize )
{
_btnRandomize->setIcon(QPixmap(random_xpm));
}
else
{
_btnRandomize->setIcon(QPixmap(normal_xpm));
}
// Volume setting.
_volumeSlider->setValue((configData->value( "volume" )).toInt());
int volume = _volumeSlider->value();
float actualVol = (float)volume / 100.0f;
if( _musicStream != NULL )
{
_musicStream->SetVolume( actualVol );
}
// Window size.
int sizex = (configData->value( "sizex" )).toInt();
int sizey = (configData->value( "sizey" )).toInt();
if( sizex > 0 && sizey > 0 )
{
setFixedSize(sizex, sizey);
setFixedSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX);
}
// Previous playlist.
QString songs = configData->value("playlist").toString();
QStringList songList = songs.split(";");
for( int i = 0; i < songList.count(); i++ )
{
if( songList[i].length() < 2 )
{
continue;
}
QFileInfo info(songList[i]);
QListWidgetItem* item = new QListWidgetItem(info.baseName());
item->setData(Qt::UserRole, QVariant(info.absoluteFilePath()));
qDebug() << "Adding to playlist: " << songList[i];
_lstPlaylist->addItem(item);
}
qDebug() << "Loaded Settings: Randomize =" << _randomize << ", Volume =" << volume << ", Width =" << sizex <<
", Height =" << sizey << ", Playlist =" << songList.count() << " items.";
delete configData;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow),
venueModel(NULL),
divModel(NULL),
teamModel(NULL)
{
ui->setupUi(this);
QSettings settings;
qDebug()<<"Files stored here: "<<settings.fileName();
QString defaultFilename = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation)+"/defaultLeague.ldb";
QString filename = settings.value("DefaultFilename",defaultFilename).toString();
restoreGeometry(settings.value("geometry").toByteArray());
restoreState(settings.value("windowState").toByteArray());
open(filename);
}
PerspectiveControl::PerspectiveControl(MasterWindow *master, MainWindow *slave, QObject *parent) :
QObject(parent), mMaster(master), mSlave(slave), mActionGroup(this), mElementMenu(0)
{
if(mSlave == mMaster){
mSlave = 0;
}
mToolBar = new QToolBar(tr("Perspectives"));
mToolBar->setIconSize(QSize(cButtonWidth, 26));
mToolBar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
mToolBar->setObjectName("perspectiveToolbar");
mToolBar->setStyleSheet("QToolBar { border: 0px }");
QAction* a = mToolBar->addAction(QIcon(":/img/newPerspective.png"), tr("New\nperspective"), this, SLOT(createPerspective()));
a->setToolTip(tr("Create new perspective based on the current one"));
mResetAction = mToolBar->addAction(QIcon(":/img/resetPerspective.png"), tr("Reset\nperspective"), this, SLOT(resetPerspectives()));
mResetAction->setToolTip(tr("Reset the current perspective"));
mResetAction->setEnabled(false);
mDeleteAction = mToolBar->addAction(QIcon(":/img/close.png"), tr("Delete\nperspective"), this, SLOT(deletePerspective()));
mDeleteAction->setToolTip(tr("Delete the current perspective"));
mDeleteAction->setEnabled(false);
mToolBar->addSeparator();
QSettings settings;
QString s = settings.fileName();
settings.remove("perspectives");
settings.remove("lastPerspective");
settings.beginGroup("perspectiveSettings");
QStringList names = settings.childGroups();
foreach(QString name, names)
{
settings.beginGroup(name);
Perspective& p = mPerspectives[name];
p.masterObjects = settings.value("master/docks").toStringList();
p.masterState = QByteArray::fromBase64(settings.value("master/state").toByteArray());
p.slaveObjects = settings.value("slave/docks").toStringList();
p.slaveState = QByteArray::fromBase64(settings.value("slave/state").toByteArray());
settings.endGroup();
}
bool WebSettings::initSettings(const QVariantMap &settingsMap, const QString &settingsFile)
{
if (localSettingsLoaded)
return false;
QString applicationName = QCoreApplication::applicationName();
if (applicationName.isEmpty()) {
applicationName = QLatin1String("WebSettings");
QCoreApplication::setApplicationName(applicationName);
}
QString organizationName = QCoreApplication::organizationName();
if (organizationName.isEmpty()) {
organizationName = QLatin1String("webos");
QCoreApplication::setOrganizationName(organizationName);
}
QSettings settings;
if (QFile::exists(settings.fileName()))
QFile::remove(settings.fileName());
qDebug("webOS::WebSettings::initSettings");
// add all values from settingsMap
QVariantMap::const_iterator it;
for (it = settingsMap.constBegin(); it != settingsMap.constEnd(); ++it)
settings.setValue(it.key(), it.value());
if (!settingsFile.isEmpty()) {
qDebug("webOS::WebSettings::loading settings from: %s", qPrintable(settingsFile));
QSettings systemSettings(settingsFile, QSettings::NativeFormat);
// override settingsMap values with system conf values
QStringList keyList = systemSettings.allKeys();
foreach (QString key, keyList)
settings.setValue(key, systemSettings.value(key));
}
localSettingsLoaded = true;
return true;
}
void SetupDialog::commitSettings(bool skipped)
{
QSettings settings;
DEBUG << "Settings location is " << settings.fileName();
settings.setValue("application/wizardDone", true);
if(!skipped)
{
settings.setValue("app/appdata", _appDataDir);
settings.setValue("tarsnap/path", _tarsnapCLIDir);
settings.setValue("tarsnap/cache", _tarsnapCacheDir);
settings.setValue("tarsnap/key", _tarsnapKeyFile);
settings.setValue("tarsnap/user", _ui->tarsnapUserLineEdit->text());
settings.setValue("tarsnap/machine", _ui->machineNameLineEdit->text());
}
settings.sync();
accept();
}
CoverManager::CoverManager() :
SceneCover(this), m_fileSystemWatcher(new QFileSystemWatcher(this)){
//Create a new Container based off LastPushSceneCover.qml
QmlDocument *qml =
QmlDocument::create("asset:///LastPushSceneCover.qml").parent(this);
m_pushMessageCover = qml->createRootObject<Container>();
//This call sets the Container to be the displayable for the SceneCover
setContent (m_pushMessageCover);
// Set up a watcher on our QSettings file so we can react and update the UI whenever
// a new push arrives or all data is cleared out.
QSettings settings;
settings.sync();
m_fileSystemWatcher->addPath(settings.fileName());
connect(m_fileSystemWatcher, SIGNAL(fileChanged(const QString &)), SLOT(pushListUpdated()));
pushListUpdated();
}
LoggingConfig::LoggingConfig(const QString& logConfiguration, const QString& logDirectory,
const QString& logFilePrefix)
: logConfig(logConfiguration), logDir(logDirectory), logPrefix(logFilePrefix)
{
QSettings *settings = nullptr;
if(!logConfig.isEmpty())
{
QFileInfo logFile(logConfig);
QString logFileInConfig = atools::settings::Settings::getPath() + QDir::separator() + logFile.fileName();
if(QFile::exists(logFileInConfig))
// Try in the configuration directory
settings = new QSettings(logFileInConfig, QSettings::IniFormat);
else if(QFile::exists(logConfig))
// Try resource or full path
settings = new QSettings(logConfig, QSettings::IniFormat);
}
else
// Use default configuration file
settings = atools::settings::Settings::getQSettings();
if(settings->status() != QSettings::NoError)
qWarning() << "Error reading log configuration file" << settings->fileName() << ":" << settings->status();
// Read general parameters
readConfigurationSection(settings);
QHash<QString, QTextStream *> channelMap;
// Create all file streams and add them to the channelMap
readChannels(settings, channelMap);
// Assign log levels to channels
readLevels(settings, channelMap);
delete settings;
}
/**
*
* read/write saves the column width and order
* set a default column width
* if we have saved state, use it
* otherwise if we have 'columns' set the sizes from that, provided there are as many entries as
* there are columns
*
* The passed QSettings is cloned, so the calling routine can do what it wants
*
* @param settings a QSettings pointing at the correct group
*/
void ColumnarTableWidget::readConfiguration(QSettings & settings) {
m_settings = new QSettings(settings.fileName(),settings.format());
m_settings->setIniCodec(settings.iniCodec());
m_settings->beginGroup(settings.group());
if (m_defaultWidth == -1) {
m_defaultWidth = 200;
}
m_defaultWidth = settings.value(m_defaultWidthKey,m_defaultWidth).toInt();
this->horizontalHeader()->setDefaultSectionSize(m_defaultWidth);
QByteArray b = settings.value(m_stateKey,QByteArray()).toByteArray();
if (b.size() > 0) {
this->horizontalHeader()->restoreState(b);
}
else {
bool ok;
int w;
QList<int> sections;
QStringList v = settings.value(m_columnWidthsKey).toStringList();
for(int i=0;i < v.size();i++) {
w = v[i].toInt(&ok);
if (ok) {
if (w == -1) {
w = m_defaultWidth;
}
sections << w;
}
}
if (sections.size() == m_columnHeadings.size()) {
for(int i=0;i < sections.size();i++) {
this->setColumnWidth(i,sections[i]);
}
}
}
if (m_markColumn != -1) {
this->resizeColumnToContents(m_markColumn);
}
}
bool Highlighter::setDict(const QString SpellDic)
{
bool spell;
if(SpellDic!=""){
//mWords.clear();
spell_dic=SpellDic.left(SpellDic.length()-4);
delete pChecker;
pChecker = new Hunspell(spell_dic.toLatin1()+".aff",spell_dic.toLatin1()+".dic");
spell_encoding=QString(pChecker->get_dic_encoding());
codec = QTextCodec::codecForName(spell_encoding.toLatin1());
QFileInfo fi(SpellDic);
if (fi.exists() && fi.isReadable()) spell=true;
else spell=false;
// get user config dictionary
QSettings setting;
QString filePath=QFileInfo(setting.fileName()).absoluteFilePath();
filePath=filePath+"/User_"+QFileInfo(spell_dic.toLatin1()+".dic").fileName();
/*std::cout << qPrintable(filePath) << std::endl;*/
fi=QFileInfo(filePath);
if (fi.exists() && fi.isReadable()){
pChecker->add_dic(filePath.toLatin1());
}
else filePath="";
spellCheckFormat.setForeground(Qt::red);//faster Cursoroperation ...
//spellCheckFormat.setUnderlineColor(QColor(Qt::red));
//spellCheckFormat.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
}
else spell=false;
spellerError=!spell;
spellCheckActive=spellCheckActive && spell;
rehighlight();
return spell;
}
void FilenamePin::loadSettings( QSettings &pSettings )
{
QString FileName = ( mPin->direction() == PIN_INPUT ? mPin->value().toString() : mValues.first() );
FileName = pSettings.value( "filename", FileName ).toString();
if( !FileName.isEmpty() )
{
QFileInfo FileInfo( pSettings.fileName() );
QDir FileDir( FileInfo.absolutePath() );
QFileInfo DestInfo( FileDir.absoluteFilePath( FileName ) );
FileName = DestInfo.exists() ? DestInfo.canonicalFilePath() : FileName;
if( mPin->direction() == PIN_INPUT )
{
mPin->setValue( FileName );
}
else
{
mValues[ 0 ] = FileName;
}
}
}
