aw/valentina_old
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Resolved issue #611. Improve feature: Paths preferences.

Browse Source 
--HG--
branch : develop
This commit is contained in:
Roman Telezhynskyi 2017-02-17 20:37:49 +02:00
parent c00a1d6e94
commit 2f024db547
10 changed files with 373 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/app/tape/dialogs/configpages/tapepathpage.cpp
View File

@ -78,23 +78,24 @@ void TapePathPage::DefaultPath()
QTableWidgetItem *item = pathTable->item(row, 1);
SCASSERT(item != nullptr)
QString path;
switch (row)
{
case 0: // individual measurements
item->setText(QDir::homePath());
item->setToolTip(QDir::homePath());
path = VCommonSettings::GetDefPathIndividualMeasurements();
break;
case 1: // standard measurements
item->setText(qApp->TapeSettings()->StandardTablesPath());
item->setToolTip(qApp->TapeSettings()->StandardTablesPath());
path = VCommonSettings::GetDefPathStandardMeasurements();
break;
case 2: // templates
item->setText(qApp->TapeSettings()->TemplatesPath());
item->setToolTip(qApp->TapeSettings()->TemplatesPath());
path = VCommonSettings::GetDefPathTemplate();
break;
default:
break;
}
item->setText(path);
item->setToolTip(path);
}
//---------------------------------------------------------------------------------------------------------------------
@ -112,6 +113,7 @@ void TapePathPage::EditPath()
break;
case 1: // standard measurements
path = qApp->TapeSettings()->GetPathStandardMeasurements();
VCommonSettings::PrepareStandardTables(path);
break;
case 2: // templates
path = qApp->TapeSettings()->GetPathTemplate();
@ -119,10 +121,24 @@ void TapePathPage::EditPath()
default:
break;
}
bool usedNotExistedDir = false;
QDir directory(path);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
const QString dir = QFileDialog::getExistingDirectory(this, tr("Open Directory"), path,
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
if (dir.isEmpty())
{
if (usedNotExistedDir)
{
QDir directory(path);
directory.rmpath(".");
}
DefaultPath();
return;
}
@ -188,21 +204,21 @@ void TapePathPage::InitTable()
const VTapeSettings *settings = qApp->TapeSettings();
{
pathTable->setItem(0, 0, new QTableWidgetItem(tr("Individual measurements")));
pathTable->setItem(0, 0, new QTableWidgetItem(tr("My Individual Measurements")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathIndividualMeasurements());
item->setToolTip(settings->GetPathIndividualMeasurements());
pathTable->setItem(0, 1, item);
}
{
pathTable->setItem(1, 0, new QTableWidgetItem(tr("Standard measurements")));
pathTable->setItem(1, 0, new QTableWidgetItem(tr("My Multisize Measurements")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathStandardMeasurements());
item->setToolTip(settings->GetPathStandardMeasurements());
pathTable->setItem(1, 1, item);
}
{
pathTable->setItem(2, 0, new QTableWidgetItem(tr("Templates")));
pathTable->setItem(2, 0, new QTableWidgetItem(tr("My Templates")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathTemplate());
item->setToolTip(settings->GetPathTemplate());
pathTable->setItem(2, 1, item);
@ -233,7 +249,7 @@ void TapePathPage::RetranslateUi()
const QStringList tableHeader = QStringList() << tr("Type") << tr("Path");
pathTable->setHorizontalHeaderLabels(tableHeader);
pathTable->item(0, 0)->setText(tr("Individual measurements"));
pathTable->item(1, 0)->setText(tr("Standard measurements"));
pathTable->item(2, 0)->setText(tr("Templates"));
pathTable->item(0, 0)->setText(tr("My Individual Measurements"));
pathTable->item(1, 0)->setText(tr("My Multisize measurements"));
pathTable->item(2, 0)->setText(tr("My Templates"));
}

72
src/app/tape/tmainwindow.cpp
View File

@ -383,21 +383,35 @@ void TMainWindow::FileNew()
//---------------------------------------------------------------------------------------------------------------------
void TMainWindow::OpenIndividual()
{
const QString filter = tr("Individual measurements") + QLatin1String(" (*.vit);;") + tr("Standard measurements") +
const QString filter = tr("Individual measurements") + QLatin1String(" (*.vit);;") + tr("Multisize measurements") +
QLatin1String(" (*.vst);;") + tr("All files") + QLatin1String(" (*.*)");
//Use standard path to individual measurements
const QString pathTo = qApp->TapeSettings()->GetPathIndividualMeasurements();
bool usedNotExistedDir = false;
QDir directory(pathTo);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
Open(pathTo, filter);
if (usedNotExistedDir)
{
QDir directory(pathTo);
directory.rmpath(".");
}
}
//---------------------------------------------------------------------------------------------------------------------
void TMainWindow::OpenStandard()
{
const QString filter = tr("Standard measurements") + QLatin1String(" (*.vst);;") + tr("Individual measurements") +
const QString filter = tr("Multisize measurements") + QLatin1String(" (*.vst);;") + tr("Individual measurements") +
QLatin1String(" (*.vit);;") + tr("All files") + QLatin1String(" (*.*)");
//Use standard path to standard measurements
const QString pathTo = qApp->TapeSettings()->GetPathStandardMeasurements();
VCommonSettings::PrepareStandardTables(pathTo);
Open(pathTo, filter);
}
@ -409,7 +423,7 @@ void TMainWindow::OpenTemplate()
QLatin1String(" (*.*)");
//Use standard path to template files
const QString pathTo = qApp->TapeSettings()->GetPathTemplate();
VCommonSettings::PrepareStandardTemplates(pathTo);
Open(pathTo, filter);
if (m != nullptr)
@ -425,6 +439,14 @@ void TMainWindow::CreateFromExisting()
const QString filter = tr("Individual measurements") + QLatin1String(" (*.vit)");
//Use standard path to standard measurements
const QString pathTo = qApp->TapeSettings()->GetPathIndividualMeasurements();
bool usedNotExistedDir = false;
QDir directory(pathTo);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
const QString mPath = QFileDialog::getOpenFileName(this, tr("Select file"), pathTo, filter);
if (not mPath.isEmpty())
@ -438,6 +460,12 @@ void TMainWindow::CreateFromExisting()
qApp->NewMainWindow()->CreateFromExisting();
}
}
if (usedNotExistedDir)
{
QDir directory(pathTo);
directory.rmpath(".");
}
}
//---------------------------------------------------------------------------------------------------------------------
@ -482,7 +510,7 @@ void TMainWindow::changeEvent(QEvent *event)
if (mType == MeasurementsType::Standard)
{
ui->labelMType->setText(tr("Standard measurements"));
ui->labelMType->setText(tr("Multisize measurements"));
ui->labelBaseSizeValue->setText(QString().setNum(m->BaseSize()) + QLatin1String(" ") +
VDomDocument::UnitsToStr(m->MUnit(), true));
ui->labelBaseHeightValue->setText(QString().setNum(m->BaseHeight()) + QLatin1String(" ") +
@ -691,7 +719,7 @@ bool TMainWindow::FileSaveAs()
}
else
{
filters = tr("Standard measurements") + QLatin1String(" (*.vst)");
filters = tr("Multisize measurements") + QLatin1String(" (*.vst)");
suffix = QLatin1String("vst");
fName += QLatin1String(".") + suffix;
}
@ -701,23 +729,40 @@ bool TMainWindow::FileSaveAs()
{
if (mType == MeasurementsType::Individual)
{
dir = qApp->TapeSettings()->GetPathIndividualMeasurements() + QLatin1String("/") + fName;
dir = qApp->TapeSettings()->GetPathIndividualMeasurements();
}
else
{
dir = qApp->TapeSettings()->GetPathStandardMeasurements() + QLatin1String("/") + fName;
dir = qApp->TapeSettings()->GetPathStandardMeasurements();
VCommonSettings::PrepareStandardTables(dir);
}
}
else
{
dir = QFileInfo(curFile).absolutePath() + QLatin1String("/") + fName;
dir = QFileInfo(curFile).absolutePath();
}
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"), dir, filters);
bool usedNotExistedDir = false;
QDir directory(dir);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"), dir + QLatin1String("/") + fName, filters);
auto RemoveTempDir = [usedNotExistedDir, dir]()
{
if (usedNotExistedDir)
{
QDir directory(dir);
directory.rmpath(".");
}
};
if (fileName.isEmpty())
{
RemoveTempDir();
return false;
}
@ -735,6 +780,7 @@ bool TMainWindow::FileSaveAs()
{
qCCritical(tMainWindow, "%s",
qUtf8Printable(tr("Failed to lock. This file already opened in another window.")));
RemoveTempDir();
return false;
}
}
@ -760,6 +806,7 @@ bool TMainWindow::FileSaveAs()
// Restore previous state
m->SetReadOnly(readOnly);
mIsReadOnly = readOnly;
RemoveTempDir();
return false;
}
@ -771,8 +818,10 @@ bool TMainWindow::FileSaveAs()
{
qCCritical(tMainWindow, "%s", qUtf8Printable(tr("Failed to lock. This file already opened in another window. "
"Expect collissions when run 2 copies of the program.")));
RemoveTempDir();
return false;
}
RemoveTempDir();
return true;
}
@ -1283,6 +1332,7 @@ void TMainWindow::ImportFromPattern()
const QString filter(tr("Pattern files (*.val)"));
//Use standard path to individual measurements
const QString pathTo = qApp->TapeSettings()->GetPathTemplate();
VCommonSettings::PrepareStandardTemplates(pathTo);
const QString mPath = QFileDialog::getOpenFileName(this, tr("Import from a pattern"), pathTo, filter);
if (mPath.isEmpty())
@ -1913,7 +1963,7 @@ void TMainWindow::InitWindow()
if (mType == MeasurementsType::Standard)
{
ui->labelMType->setText(tr("Standard measurements"));
ui->labelMType->setText(tr("Multisize measurements"));
ui->labelBaseSizeValue->setText(QString().setNum(m->BaseSize()) + " " +
VDomDocument::UnitsToStr(m->MUnit(), true));
ui->labelBaseHeightValue->setText(QString().setNum(m->BaseHeight()) + " " +

64
src/app/valentina/dialogs/configpages/pathpage.cpp
View File

@ -77,25 +77,31 @@ void PathPage::DefaultPath()
QTableWidgetItem *item = pathTable->item(row, 1);
SCASSERT(item != nullptr)
QString path;
switch (row)
{
case 1: // standard measurements
item->setText(qApp->ValentinaSettings()->StandardTablesPath());
item->setToolTip(qApp->ValentinaSettings()->StandardTablesPath());
path = VCommonSettings::GetDefPathStandardMeasurements();
break;
case 2: // pattern path
path = VSettings::GetDefPathPattern();
break;
case 0: // individual measurements
case 2: // pattern path
path = VCommonSettings::GetDefPathIndividualMeasurements();
break;
case 3: // layout path
item->setText(QDir::homePath());
item->setToolTip(QDir::homePath());
path = VSettings::GetDefPathLayout();
break;
case 4: // templates
item->setText(qApp->ValentinaSettings()->TemplatesPath());
item->setToolTip(qApp->ValentinaSettings()->TemplatesPath());
path = VCommonSettings::GetDefPathTemplate();
break;
default:
break;
}
item->setText(path);
item->setToolTip(path);
}
//---------------------------------------------------------------------------------------------------------------------
@ -113,6 +119,7 @@ void PathPage::EditPath()
break;
case 1: // standard measurements
path = qApp->ValentinaSettings()->GetPathStandardMeasurements();
VCommonSettings::PrepareStandardTables(path);
break;
case 2: // pattern path
path = qApp->ValentinaSettings()->GetPathPattern();
@ -126,16 +133,35 @@ void PathPage::EditPath()
default:
break;
}
QString dir = QFileDialog::getExistingDirectory(this, tr("Open Directory"), path,
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
bool usedNotExistedDir = false;
QDir directory(path);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
const QString dir = QFileDialog::getExistingDirectory(this, tr("Open Directory"), path,
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
if (dir.isEmpty())
{
if (usedNotExistedDir)
{
QDir directory(path);
directory.rmpath(".");
}
DefaultPath();
return;
}
item->setText(dir);
item->setToolTip(dir);
if (usedNotExistedDir)
{
QDir directory(path);
directory.rmpath(".");
}
}
//---------------------------------------------------------------------------------------------------------------------
@ -194,35 +220,35 @@ void PathPage::InitTable()
const VSettings *settings = qApp->ValentinaSettings();
{
pathTable->setItem(0, 0, new QTableWidgetItem(tr("Individual measurements")));
pathTable->setItem(0, 0, new QTableWidgetItem(tr("My Individual Measurements")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathIndividualMeasurements());
item->setToolTip(settings->GetPathIndividualMeasurements());
pathTable->setItem(0, 1, item);
}
{
pathTable->setItem(1, 0, new QTableWidgetItem(tr("Standard measurements")));
pathTable->setItem(1, 0, new QTableWidgetItem(tr("My Multisize Measurements")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathStandardMeasurements());
item->setToolTip(settings->GetPathStandardMeasurements());
pathTable->setItem(1, 1, item);
}
{
pathTable->setItem(2, 0, new QTableWidgetItem(tr("Patterns")));
pathTable->setItem(2, 0, new QTableWidgetItem(tr("My Patterns")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathPattern());
item->setToolTip(settings->GetPathPattern());
pathTable->setItem(2, 1, item);
}
{
pathTable->setItem(3, 0, new QTableWidgetItem(tr("Layout")));
pathTable->setItem(3, 0, new QTableWidgetItem(tr("My Layouts")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathLayout());
item->setToolTip(settings->GetPathLayout());
pathTable->setItem(3, 1, item);
}
{
pathTable->setItem(4, 0, new QTableWidgetItem(tr("Templates")));
pathTable->setItem(4, 0, new QTableWidgetItem(tr("My Templates")));
QTableWidgetItem *item = new QTableWidgetItem(settings->GetPathTemplate());
item->setToolTip(settings->GetPathTemplate());
pathTable->setItem(4, 1, item);
@ -253,9 +279,9 @@ void PathPage::RetranslateUi()
const QStringList tableHeader = QStringList() << tr("Type") << tr("Path");
pathTable->setHorizontalHeaderLabels(tableHeader);
pathTable->item(0, 0)->setText(tr("Individual measurements"));
pathTable->item(1, 0)->setText(tr("Standard measurements"));
pathTable->item(2, 0)->setText(tr("Patterns"));
pathTable->item(3, 0)->setText(tr("Layout"));
pathTable->item(4, 0)->setText(tr("Templates"));
pathTable->item(0, 0)->setText(tr("My Individual Measurements"));
pathTable->item(1, 0)->setText(tr("My Multisize Measurements"));
pathTable->item(2, 0)->setText(tr("My Patterns"));
pathTable->item(3, 0)->setText(tr("My Layouts"));
pathTable->item(4, 0)->setText(tr("My Templates"));
}

17
src/app/valentina/dialogs/dialogsavelayout.cpp
View File

@ -102,13 +102,26 @@ DialogSaveLayout::DialogSaveLayout(int count, const QString &fileName, QWidget *
RECEIVER(this)ShowExample);
connect(ui->pushButtonBrowse, &QPushButton::clicked, RECEIVER(this)[this]()
{
const QString dir = QFileDialog::getExistingDirectory(this, tr("Select folder"),
qApp->ValentinaSettings()->GetPathLayout(),
const QString dirPath = qApp->ValentinaSettings()->GetPathLayout();
bool usedNotExistedDir = false;
QDir directory(dirPath);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
const QString dir = QFileDialog::getExistingDirectory(this, tr("Select folder"), dirPath,
QFileDialog::ShowDirsOnly | QFileDialog::DontResolveSymlinks);
if (not dir.isEmpty())
{// If paths equal the signal will not be called, we will do this manually
dir == ui->lineEditPath->text() ? PathChanged(dir) : ui->lineEditPath->setText(dir);
}
if (usedNotExistedDir)
{
QDir directory(dirPath);
directory.rmpath(".");
}
});
connect(ui->lineEditPath, &QLineEdit::textChanged, this, &DialogSaveLayout::PathChanged);

95
src/app/valentina/mainwindow.cpp
View File

@ -1375,9 +1375,18 @@ void MainWindow::PrepareSceneList()
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::LoadIndividual()
{
const QString filter = tr("Individual measurements (*.vit);;Standard measurements (*.vst)");
const QString filter = tr("Individual measurements") + QLatin1String(" (*.vit);;") + tr("Multisize measurements") +
QLatin1String(" (*.vst)");
//Use standard path to individual measurements
const QString path = qApp->ValentinaSettings()->GetPathIndividualMeasurements();
bool usedNotExistedDir = false;
QDir directory(path);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
const QString mPath = QFileDialog::getOpenFileName(this, tr("Open file"), path, filter);
if (not mPath.isEmpty())
@ -1399,14 +1408,22 @@ void MainWindow::LoadIndividual()
UpdateWindowTitle();
}
}
if (usedNotExistedDir)
{
QDir directory(path);
directory.rmpath(".");
}
}
//---------------------------------------------------------------------------------------------------------------------
void MainWindow::LoadStandard()
{
const QString filter = tr("Standard measurements (*.vst);;Individual measurements (*.vit)");
const QString filter = tr("Multisize measurements") + QLatin1String(" (*.vst);;") + tr("Individual measurements") +
QLatin1String("(*.vit)");
//Use standard path to standard measurements
const QString path = qApp->ValentinaSettings()->GetPathStandardMeasurements();
VCommonSettings::PrepareStandardTables(path);
const QString mPath = QFileDialog::getOpenFileName(this, tr("Open file"), path, filter);
if (not mPath.isEmpty())
@ -2362,29 +2379,43 @@ void MainWindow::ActionLayout(bool checked)
*/
bool MainWindow::SaveAs()
{
QString filters(tr("Pattern files (*.val)"));
QString filters(tr("Pattern files") + QLatin1String("(*.val)"));
QString dir;
if (curFile.isEmpty())
curFile.isEmpty() ? dir = qApp->ValentinaSettings()->GetPathPattern() : dir = QFileInfo(curFile).absolutePath();
bool usedNotExistedDir = false;
QDir directory(dir);
if (not directory.exists())
{
dir = qApp->ValentinaSettings()->GetPathPattern() + "/" + tr("pattern") + ".val";
usedNotExistedDir = directory.mkpath(".");
}
else
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"),
dir + QLatin1String("/") + tr("pattern") + QLatin1String(".val"),
filters);
auto RemoveTempDir = [usedNotExistedDir, dir]()
{
dir = QFileInfo(curFile).absolutePath() + "/" + tr("pattern") + ".val";
}
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"), dir, filters);
if (usedNotExistedDir)
{
QDir directory(dir);
directory.rmpath(".");
}
};
if (fileName.isEmpty())
{
RemoveTempDir();
return false;
}
QFileInfo f( fileName );
if (f.suffix().isEmpty() && f.suffix() != "val")
if (f.suffix().isEmpty() && f.suffix() != QLatin1String("val"))
{
fileName += ".val";
fileName += QLatin1String(".val");
}
if (QFileInfo(fileName).exists())
if (f.exists())
{
// Temporary try to lock the file before saving
// Also help to rewite current read-only pattern
@ -2393,6 +2424,7 @@ bool MainWindow::SaveAs()
{
qCCritical(vMainWindow, "%s",
qUtf8Printable(tr("Failed to lock. This file already opened in another window.")));
RemoveTempDir();
return false;
}
}
@ -2418,6 +2450,7 @@ bool MainWindow::SaveAs()
doc->SetReadOnly(readOnly);
doc->SetModified(wasModified);
RemoveTempDir();
return result;
}
@ -2439,6 +2472,7 @@ bool MainWindow::SaveAs()
"collissions when run 2 copies of the program.")));
}
RemoveTempDir();
return result;
}
@ -4307,24 +4341,55 @@ QString MainWindow::CheckPathToMeasurements(const QString &patternPath, const QS
QString mPath;
if (patternType == MeasurementsType::Standard)
{
const QString filter = tr("Standard measurements (*.vst)");
const QString filter = tr("Multisize measurements") + QLatin1String(" (*.vst)");
//Use standard path to standard measurements
const QString path = qApp->ValentinaSettings()->GetPathStandardMeasurements();
VCommonSettings::PrepareStandardTables(path);
mPath = QFileDialog::getOpenFileName(this, tr("Open file"), path, filter);
}
else if (patternType == MeasurementsType::Individual)
{
const QString filter = tr("Individual measurements (*.vit)");
const QString filter = tr("Individual measurements") + QLatin1String(" (*.vit)");
//Use standard path to individual measurements
const QString path = qApp->ValentinaSettings()->GetPathIndividualMeasurements();
bool usedNotExistedDir = false;
QDir directory(path);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
mPath = QFileDialog::getOpenFileName(this, tr("Open file"), path, filter);
if (usedNotExistedDir)
{
QDir directory(path);
directory.rmpath(".");
}
}
else
{
const QString filter = tr("Individual measurements (*.vit);;Standard measurements (*.vst)");
const QString filter = tr("Individual measurements") + QLatin1String(" (*.vit);;") +
tr("Multisize measurements") + QLatin1String(" (*.vst)");
//Use standard path to individual measurements
const QString path = qApp->ValentinaSettings()->GetPathIndividualMeasurements();
VCommonSettings::PrepareStandardTables(VCommonSettings::GetDefPathStandardMeasurements());
bool usedNotExistedDir = false;
QDir directory(path);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
mPath = QFileDialog::getOpenFileName(this, tr("Open file"), path, filter);
if (usedNotExistedDir)
{
QDir directory(path);
directory.rmpath(".");
}
}
if (mPath.isEmpty())

16
src/app/valentina/mainwindowsnogui.cpp
View File

@ -853,8 +853,16 @@ void MainWindowsNoGUI::SaveLayoutAs()
qWarning()<<tr("Pages will be cropped because they do not fit printer paper size.");
}
const QString dir = qApp->ValentinaSettings()->GetPathLayout();
bool usedNotExistedDir = false;
QDir directory(dir);
if (not directory.exists())
{
usedNotExistedDir = directory.mkpath(".");
}
QString fileName = QFileDialog::getSaveFileName(this, tr("Print to pdf"),
qApp->ValentinaSettings()->GetPathLayout()+"/"+FileName()+".pdf",
dir + QLatin1String("/") + FileName() + QLatin1String(".pdf"),
tr("PDF file (*.pdf)"));
if (not fileName.isEmpty())
{
@ -869,6 +877,12 @@ void MainWindowsNoGUI::SaveLayoutAs()
printer.setResolution(static_cast<int>(PrintDPI));
PrintPages( &printer );
}
if (usedNotExistedDir)
{
QDir directory(dir);
directory.rmpath(".");
}
}
//---------------------------------------------------------------------------------------------------------------------

113
src/libs/vmisc/vcommonsettings.cpp
View File

@ -75,9 +75,59 @@ const QString VCommonSettings::SettingUserDefinedMaterials = QStringLitera
static const QString commonIniFilename = QStringLiteral("common");
#if !defined(Q_OS_WIN)
const QString VCommonSettings::unixStandardSharePath = QStringLiteral("/usr/share/valentina");
#endif
namespace
{
//---------------------------------------------------------------------------------------------------------------------
bool SymlinkCopyDirRecursive(const QString &fromDir, const QString &toDir, bool replaceOnConflit)
{
QDir dir;
dir.setPath(fromDir);
foreach (QString copyFile, dir.entryList(QDir::Files))
{
const QString from = fromDir + QDir::separator() + copyFile;
const QString to = toDir + QDir::separator() + copyFile;
if (QFile::exists(to))
{
if (replaceOnConflit)
{
if (QFile::remove(to) == false)
{
return false;
}
}
else
{
continue;
}
}
if (QFile::link(from, to) == false)
{
return false;
}
}
foreach (QString copyDir, dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot))
{
const QString from = fromDir + QDir::separator() + copyDir;
const QString to = toDir + QDir::separator() + copyDir;
if (dir.mkpath(to) == false)
{
return false;
}
if (SymlinkCopyDirRecursive(from, to, replaceOnConflit) == false)
{
return false;
}
}
return true;
}
}
//---------------------------------------------------------------------------------------------------------------------
VCommonSettings::VCommonSettings(Format format, Scope scope, const QString &organization,
@ -136,16 +186,54 @@ QString VCommonSettings::StandardTablesPath()
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::TemplatesPath()
QString VCommonSettings::StandardTemplatesPath()
{
return SharePath(QStringLiteral("/tables/templates"));
}
//---------------------------------------------------------------------------------------------------------------------
void VCommonSettings::PrepareStandardTemplates(const QString & currentPath)
{
QDir standardPath(VCommonSettings::StandardTemplatesPath());
const QDir localdata (VCommonSettings::GetDefPathTemplate());
if (currentPath == VCommonSettings::GetDefPathTemplate() && standardPath.exists() && not localdata.exists())
{
if (localdata.mkpath("."))
{
SymlinkCopyDirRecursive(VCommonSettings::StandardTemplatesPath(), VCommonSettings::GetDefPathTemplate(),
false);
}
}
}
//---------------------------------------------------------------------------------------------------------------------
void VCommonSettings::PrepareStandardTables(const QString &currentPath)
{
QDir standardPath(VCommonSettings::StandardTablesPath());
const QDir localdata (VCommonSettings::GetDefPathStandardMeasurements());
if (currentPath == VCommonSettings::GetDefPathStandardMeasurements()
&& standardPath.exists()
&& not localdata.exists())
{
if (localdata.mkpath("."))
{
SymlinkCopyDirRecursive(VCommonSettings::StandardTablesPath(),
VCommonSettings::GetDefPathStandardMeasurements(), false);
}
}
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::GetDefPathIndividualMeasurements()
{
return QDir::homePath() + QLatin1String("/valentina/") + tr("measurements") + QLatin1String("/") + tr("individual");
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::GetPathIndividualMeasurements() const
{
QSettings settings(this->format(), this->scope(), this->organizationName(), commonIniFilename);
return settings.value(SettingPathsIndividualMeasurements, QDir::homePath()).toString();
return settings.value(SettingPathsIndividualMeasurements, GetDefPathIndividualMeasurements()).toString();
}
//---------------------------------------------------------------------------------------------------------------------
@ -156,11 +244,17 @@ void VCommonSettings::SetPathIndividualMeasurements(const QString &value)
settings.sync();
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::GetDefPathStandardMeasurements()
{
return QDir::homePath() + QLatin1String("/valentina/") + tr("measurements") + QLatin1String("/") + tr("multisize");
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::GetPathStandardMeasurements() const
{
QSettings settings(this->format(), this->scope(), this->organizationName(), commonIniFilename);
return settings.value(SettingPathsStandardMeasurements, StandardTablesPath()).toString();
return settings.value(SettingPathsStandardMeasurements, GetDefPathStandardMeasurements()).toString();
}
//---------------------------------------------------------------------------------------------------------------------
@ -171,12 +265,17 @@ void VCommonSettings::SetPathStandardMeasurements(const QString &value)
settings.sync();
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::GetDefPathTemplate()
{
return QDir::homePath() + QLatin1String("/valentina/") + tr("templates");
}
//---------------------------------------------------------------------------------------------------------------------
QString VCommonSettings::GetPathTemplate() const
{
QSettings settings(this->format(), this->scope(), this->organizationName(), commonIniFilename);
return settings.value(SettingPathsTemplates, TemplatesPath()).toString();
return settings.value(SettingPathsTemplates, GetDefPathTemplate()).toString();
}
//---------------------------------------------------------------------------------------------------------------------

12
src/libs/vmisc/vcommonsettings.h
View File

@ -51,14 +51,20 @@ public:
static QString SharePath(const QString &shareItem);
static QString StandardTablesPath();
static QString TemplatesPath();
static QString StandardTemplatesPath();
static void PrepareStandardTemplates(const QString &currentPath);
static void PrepareStandardTables(const QString &currentPath);
static QString GetDefPathIndividualMeasurements();
QString GetPathIndividualMeasurements() const;
void SetPathIndividualMeasurements(const QString &value);
static QString GetDefPathStandardMeasurements();
QString GetPathStandardMeasurements() const;
void SetPathStandardMeasurements(const QString &value);
static QString GetDefPathTemplate();
QString GetPathTemplate() const;
void SetPathTemplate(const QString &value);
@ -126,10 +132,6 @@ public:
bool GetForbidWorkpieceFlipping() const;
void SetForbidWorkpieceFlipping(bool value);
#if !defined(Q_OS_WIN)
static const QString unixStandardSharePath;
#endif
private:
Q_DISABLE_COPY(VCommonSettings)

16
src/libs/vmisc/vsettings.cpp
View File

@ -99,11 +99,17 @@ void VSettings::SetLabelLanguage(const QString &value)
setValue(SettingConfigurationLabelLanguage, value);
}
//---------------------------------------------------------------------------------------------------------------------
QString VSettings::GetDefPathPattern()
{
return QDir::homePath() + QLatin1String("/valentina/") + tr("patterns");
}
//---------------------------------------------------------------------------------------------------------------------
QString VSettings::GetPathPattern() const
{
QSettings settings(this->format(), this->scope(), this->organizationName(), this->applicationName());
return settings.value(SettingPathsPattern, QDir::homePath()).toString();
return settings.value(SettingPathsPattern, GetDefPathPattern()).toString();
}
//---------------------------------------------------------------------------------------------------------------------
@ -114,11 +120,17 @@ void VSettings::SetPathPattern(const QString &value)
settings.sync();
}
//---------------------------------------------------------------------------------------------------------------------
QString VSettings::GetDefPathLayout()
{
return QDir::homePath() + QLatin1String("/valentina/") + tr("layouts");
}
//---------------------------------------------------------------------------------------------------------------------
QString VSettings::GetPathLayout() const
{
QSettings settings(this->format(), this->scope(), this->organizationName(), this->applicationName());
return settings.value(SettingPathsLayout, QDir::homePath()).toString();
return settings.value(SettingPathsLayout, GetDefPathLayout()).toString();
}
//---------------------------------------------------------------------------------------------------------------------

2
src/libs/vmisc/vsettings.h
View File

@ -58,9 +58,11 @@ public:
QString GetLabelLanguage() const;
void SetLabelLanguage(const QString &value);
static QString GetDefPathPattern();
QString GetPathPattern() const;
void SetPathPattern(const QString &value);
static QString GetDefPathLayout();
QString GetPathLayout() const;
void SetPathLayout(const QString &value);