palo
/
valentina
mirror of https://gitlab.com/smart-pattern/valentina.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
valentina/src/app/valentina/watermarkwindow.cpp

742 lines
25 KiB
C++
Raw Blame History

/************************************************************************
**
** @file watermarkwindow.cpp
** @author Roman Telezhynskyi <dismine(at)gmail.com>
** @date 24 12, 2019
**
** @brief
** @copyright
** This source code is part of the Valentina project, a pattern making
** program, whose allow create and modeling patterns of clothing.
** Copyright (C) 2019 Valentina project
** <https://gitlab.com/smart-pattern/valentina> All Rights Reserved.
**
** Valentina is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** Valentina is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with Valentina. If not, see <http://www.gnu.org/licenses/>.
**
*************************************************************************/
#include "watermarkwindow.h"
#include "ui_watermarkwindow.h"
#include <QCloseEvent>
#include <QFileDialog>
#include <QFileInfo>
#include <QFontDialog>
#include <QFuture>
#include <QMessageBox>
#include <QtConcurrent>
#include "../vmisc/def.h"
#include "core/vapplication.h"
#include "../vpropertyexplorer/checkablemessagebox.h"
#include "../ifc/exception/vexception.h"
#include "../ifc/xml/vwatermarkconverter.h"
//---------------------------------------------------------------------------------------------------------------------
WatermarkWindow::WatermarkWindow(const QString &patternPath, QWidget *parent) :
QMainWindow(parent),
ui(new Ui::WatermarkWindow),
m_patternPath(patternPath),
m_okPathColor()
{
ui->setupUi(this);
m_okPathColor = ui->lineEditPath->palette().color(ui->lineEditPath->foregroundRole());
qApp->Settings()->GetOsSeparator() ? setLocale(QLocale()) : setLocale(QLocale::c());
UpdateWindowTitle();
m_curFileFormatVersion = VWatermarkConverter::WatermarkMaxVer;
m_curFileFormatVersionStr = VWatermarkConverter::WatermarkMaxVerStr;
ToolBarStyle(ui->toolBar);
connect(ui->spinBoxOpacity, QOverload<int>::of(&QSpinBox::valueChanged),this,
[this](){WatermarkChangesWereSaved(false);});
connect(ui->lineEditText, &QLineEdit::textChanged, this, [this]()
{
WatermarkChangesWereSaved(false);
});
connect(ui->spinBoxTextRotation, QOverload<int>::of(&QSpinBox::valueChanged), this,
[this](){WatermarkChangesWereSaved(false);});
connect(ui->toolButtonFont, &QToolButton::clicked, this, [this]()
{
bool ok;
QFont font = QFontDialog::getFont(&ok, m_data.font, this);
if (ok)
{
WatermarkChangesWereSaved(false);
m_data.font = font;
ui->lineEditFontSample->setFont(font);
}
});
connect(ui->lineEditPath, &QLineEdit::textChanged, this, [this]()
{
WatermarkChangesWereSaved(false);
ValidatePath();
});
connect(ui->pushButtonBrowse, &QPushButton::clicked, this, [this]()
{
const QString filter = tr("Images") + QLatin1String(" (*.png *.jpg *.jpeg *.bmp)");
const QString fileName = QFileDialog::getOpenFileName(this, tr("Watermark image"), QString(), filter,
nullptr);
if (not fileName.isEmpty())
{
ui->lineEditPath->setText(fileName);
}
});
connect(ui->spinBoxImageRotation, QOverload<int>::of(&QSpinBox::valueChanged),this,
[this](){WatermarkChangesWereSaved(false);});
connect(ui->checkBoxGrayColor, &QCheckBox::stateChanged, this, [this](){WatermarkChangesWereSaved(false);});
connect(ui->groupBoxWatermarkText, &QGroupBox::toggled, this, [this](){WatermarkChangesWereSaved(false);});
connect(ui->groupBoxWatermarkImage, &QGroupBox::toggled, this, [this](){WatermarkChangesWereSaved(false);});
}
//---------------------------------------------------------------------------------------------------------------------
WatermarkWindow::~WatermarkWindow()
{
delete ui;
}
//---------------------------------------------------------------------------------------------------------------------
QString WatermarkWindow::CurrentFile() const
{
return m_curFile;
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::Open(QString path)
{
qDebug("Loading new watermark file %s.", qUtf8Printable(path));
if (path.isEmpty())
{
qDebug("Path is empty");
Clear();
return false;
}
// Convert to absolute path if need
path = AbsoluteMPath(m_patternPath, path);
QFuture<VWatermarkConverter *> futureConverter = QtConcurrent::run([path]()
{
QScopedPointer<VWatermarkConverter> converter(new VWatermarkConverter(path));
return converter.take();
});
//We have unsaved changes or load more then one file per time
if (OpenNewEditor(path))
{
return false;
}
qDebug("Loking watermark file");
VlpCreateLock(lock, path);
if (lock->IsLocked())
{
qDebug("Watermark file %s was locked.", qUtf8Printable(path));
}
else
{
if (not IgnoreLocking(lock->GetLockError(), path))
{
return false;
}
}
VWatermark doc;
try
{
QScopedPointer<VWatermarkConverter> converter(futureConverter.result());
m_curFileFormatVersion = converter->GetCurrentFormatVersion();
m_curFileFormatVersionStr = converter->GetFormatVersionStr();
doc.setXMLContent(converter->Convert());
}
catch (VException &e)
{
qCritical("%s\n\n%s\n\n%s", qUtf8Printable(tr("File error.")),
qUtf8Printable(e.ErrorMessage()), qUtf8Printable(e.DetailedInformation()));
Clear();
return false;
}
m_curFile = path;
UpdateWindowTitle();
m_data = doc.GetWatermark();
ShowWatermark();
return true;
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::closeEvent(QCloseEvent *event)
{
#if defined(Q_OS_MAC) && QT_VERSION < QT_VERSION_CHECK(5, 11, 1)
// Workaround for Qt bug https://bugreports.qt.io/browse/QTBUG-43344
static int numCalled = 0;
if (numCalled++ >= 1)
{
return;
}
#endif
if (MaybeSave())
{
event->accept();
deleteLater();
}
else
{
event->ignore();
}
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::changeEvent(QEvent *event)
{
if (event->type() == QEvent::LanguageChange)
{
// retranslate designer form (single inheritance approach)
ui->retranslateUi(this);
UpdateWindowTitle();
}
// remember to call base class implementation
QMainWindow::changeEvent(event);
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::showEvent(QShowEvent *event)
{
QMainWindow::showEvent( event );
if ( event->spontaneous() )
{
return;
}
if (m_isInitialized)
{
return;
}
// do your init stuff here
QSize sz = qApp->ValentinaSettings()->GetWatermarkEditorSize();
if (sz.isEmpty() == false)
{
resize(sz);
}
m_isInitialized = true;//first show windows are held
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::resizeEvent(QResizeEvent *event)
{
// remember the size for the next time this window is opened, but only
// if the window was already initialized, which rules out the resize at
// window creating, which would
if (m_isInitialized)
{
qApp->ValentinaSettings()->SetWatermarkEditorSize(size());
}
QMainWindow::resizeEvent(event);
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::on_actionNew_triggered()
{
emit New();
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::on_actionSaveAs_triggered()
{
QString filters(tr("Watermark files") + QLatin1String("(*.vwm)"));
QString dir;
if (m_curFile.isEmpty())
{
dir = QDir::homePath();
}
else
{
dir = QFileInfo(m_curFile).absolutePath();
}
QString fileName = QFileDialog::getSaveFileName(this, tr("Save as"),
dir + QLatin1String("/") + tr("watermark") + QLatin1String(".vwm"),
filters, nullptr);
if (fileName.isEmpty())
{
return false;
}
QFileInfo f( fileName );
if (f.suffix().isEmpty() && f.suffix() != QLatin1String("vwm"))
{
fileName += QLatin1String(".vwm");
}
if (f.exists() && m_curFile != fileName)
{
// Temporary try to lock the file before saving
VLockGuard<char> tmp(fileName);
if (not tmp.IsLocked())
{
qCritical("%s", qUtf8Printable(tr("Failed to lock. This file already opened in another window.")));
return false;
}
}
QString error;
const bool result = SaveWatermark(fileName, error);
if (not result)
{
QMessageBox messageBox(this);
messageBox.setIcon(QMessageBox::Warning);
messageBox.setInformativeText(tr("Could not save file"));
messageBox.setDefaultButton(QMessageBox::Ok);
messageBox.setDetailedText(error);
messageBox.setStandardButtons(QMessageBox::Ok);
messageBox.exec();
return result;
}
if (m_curFile == fileName && not lock.isNull())
{
lock->Unlock();
}
VlpCreateLock(lock, fileName);
if (lock->IsLocked())
{
qDebug("Watermark file %s was locked.", qUtf8Printable(fileName));
}
else
{
qDebug("Failed to lock %s", qUtf8Printable(fileName));
qDebug("Error type: %d", lock->GetLockError());
qCritical("%s", qUtf8Printable(tr("Failed to lock. This file already opened in another window. Expect "
"collissions when run 2 copies of the program.")));
}
return result;
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::on_actionSave_triggered()
{
if (m_curFile.isEmpty())
{
return on_actionSaveAs_triggered();
}
else
{
if (m_curFileFormatVersion < VWatermarkConverter::WatermarkMaxVer
&& not ContinueFormatRewrite(m_curFileFormatVersionStr, VWatermarkConverter::WatermarkMaxVerStr))
{
return false;
}
#ifdef Q_OS_WIN32
qt_ntfs_permission_lookup++; // turn checking on
#endif /*Q_OS_WIN32*/
const bool isFileWritable = QFileInfo(m_curFile).isWritable();
#ifdef Q_OS_WIN32
qt_ntfs_permission_lookup--; // turn it off again
#endif /*Q_OS_WIN32*/
if (not isFileWritable)
{
QMessageBox messageBox(this);
messageBox.setIcon(QMessageBox::Question);
messageBox.setText(tr("The document has no write permissions."));
messageBox.setInformativeText("Do you want to change the premissions?");
messageBox.setStandardButtons(QMessageBox::Yes | QMessageBox::Cancel);
messageBox.setDefaultButton(QMessageBox::Yes);
if (messageBox.exec() == QMessageBox::Yes)
{
#ifdef Q_OS_WIN32
qt_ntfs_permission_lookup++; // turn checking on
#endif /*Q_OS_WIN32*/
bool changed = QFile::setPermissions(m_curFile,
QFileInfo(m_curFile).permissions() | QFileDevice::WriteUser);
#ifdef Q_OS_WIN32
qt_ntfs_permission_lookup--; // turn it off again
#endif /*Q_OS_WIN32*/
if (not changed)
{
QMessageBox messageBoxWarning(this);
messageBoxWarning.setIcon(QMessageBox::Warning);
messageBoxWarning.setText(tr("Cannot set permissions for %1 to writable.").arg(m_curFile));
messageBoxWarning.setInformativeText(tr("Could not save the file."));
messageBoxWarning.setDefaultButton(QMessageBox::Ok);
messageBoxWarning.setStandardButtons(QMessageBox::Ok);
messageBoxWarning.exec();
return false;
}
}
else
{
return false;
}
}
QString error;
bool result = SaveWatermark(m_curFile, error);
if (result)
{
m_curFileFormatVersion = VWatermarkConverter::WatermarkMaxVer;
m_curFileFormatVersionStr = VWatermarkConverter::WatermarkMaxVerStr;
}
else
{
QMessageBox messageBox(this);
messageBox.setIcon(QMessageBox::Warning);
messageBox.setText(tr("Could not save the file"));
messageBox.setDefaultButton(QMessageBox::Ok);
messageBox.setDetailedText(error);
messageBox.setStandardButtons(QMessageBox::Ok);
messageBox.exec();
}
return result;
}
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::on_actionOpen_triggered()
{
qDebug("Openning new watermark file.");
const QString filter(tr("Watermark files") + QLatin1String(" (*.vwm)"));
QString dir = QDir::homePath();
qDebug("Run QFileDialog::getOpenFileName: dir = %s.", qUtf8Printable(dir));
const QString filePath = QFileDialog::getOpenFileName(this, tr("Open file"), dir, filter, nullptr);
if (filePath.isEmpty())
{
return;
}
Open(filePath);
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::on_actionExit_triggered()
{
close();
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::WatermarkChangesWereSaved(bool saved)
{
const bool state = /*doc->IsModified() ||*/ !saved;
setWindowModified(state);
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::MaybeSave()
{
if (this->isWindowModified())
{
QScopedPointer<QMessageBox> messageBox(new QMessageBox(tr("Unsaved changes"),
tr("The watermark has been modified.\n"
"Do you want to save your changes?"),
QMessageBox::Warning, QMessageBox::Yes, QMessageBox::No,
QMessageBox::Cancel, this, Qt::Sheet));
messageBox->setDefaultButton(QMessageBox::Yes);
messageBox->setEscapeButton(QMessageBox::Cancel);
messageBox->setButtonText(QMessageBox::Yes, m_curFile.isEmpty() ? tr("Save") : tr("Save as"));
messageBox->setButtonText(QMessageBox::No, tr("Don't Save"));
messageBox->setWindowModality(Qt::ApplicationModal);
const auto ret = static_cast<QMessageBox::StandardButton>(messageBox->exec());
switch (ret)
{
case QMessageBox::Yes:
return m_curFile.isEmpty() ? on_actionSaveAs_triggered() : on_actionSave_triggered();
case QMessageBox::No:
return true;
case QMessageBox::Cancel:
return false;
default:
break;
}
}
return true;
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::UpdateWindowTitle()
{
bool isFileWritable = true;
if (not m_curFile.isEmpty())
{
#ifdef Q_OS_WIN32
qt_ntfs_permission_lookup++; // turn checking on
#endif /*Q_OS_WIN32*/
isFileWritable = QFileInfo(m_curFile).isWritable();
#ifdef Q_OS_WIN32
qt_ntfs_permission_lookup--; // turn it off again
#endif /*Q_OS_WIN32*/
}
if (isFileWritable)
{
setWindowTitle(GetWatermarkFileName());
}
else
{
setWindowTitle(GetWatermarkFileName() + QLatin1String(" (") + tr("read only") + QLatin1String(")"));
}
setWindowFilePath(m_curFile);
#if defined(Q_OS_MAC)
static QIcon fileIcon = QIcon(QCoreApplication::applicationDirPath() +
QLatin1String("/../Resources/Valentina.icns"));
QIcon icon;
if (not m_curFile.isEmpty())
{
if (not isWindowModified())
{
icon = fileIcon;
}
else
{
static QIcon darkIcon;
if (darkIcon.isNull())
{
darkIcon = QIcon(darkenPixmap(fileIcon.pixmap(16, 16)));
}
icon = darkIcon;
}
}
setWindowIcon(icon);
#endif //defined(Q_OS_MAC)
}
//---------------------------------------------------------------------------------------------------------------------
QString WatermarkWindow::GetWatermarkFileName()
{
QString shownName = tr("untitled.vwm");
if(not m_curFile.isEmpty())
{
shownName = StrippedName(m_curFile);
}
shownName += QLatin1String("[*]");
return shownName;
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::ContinueFormatRewrite(const QString &currentFormatVersion, const QString &maxFormatVersion)
{
if (qApp->Settings()->GetConfirmFormatRewriting())
{
Utils::CheckableMessageBox msgBox(this);
msgBox.setWindowTitle(tr("Confirm format rewriting"));
msgBox.setText(tr("This file is using previous format version v%1. The current is v%2. "
"Saving the file with this app version will update the format version for this "
"file. This may prevent you from be able to open the file with older app versions. "
"Do you really want to continue?").arg(currentFormatVersion, maxFormatVersion));
msgBox.setStandardButtons(QDialogButtonBox::Yes | QDialogButtonBox::No);
msgBox.setDefaultButton(QDialogButtonBox::No);
msgBox.setIconPixmap(QApplication::style()->standardIcon(QStyle::SP_MessageBoxQuestion).pixmap(32, 32));
int dialogResult = msgBox.exec();
if (dialogResult == QDialog::Accepted)
{
qApp->Settings()->SetConfirmFormatRewriting(not msgBox.isChecked());
return true;
}
else
{
return false;
}
}
return true;
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::SaveWatermark(const QString &fileName, QString &error)
{
m_data.opacity = ui->spinBoxOpacity->value();
m_data.showText = ui->groupBoxWatermarkText->isChecked();
m_data.text = ui->lineEditText->text();
m_data.textRotation = ui->spinBoxTextRotation->value();
m_data.showImage = ui->groupBoxWatermarkImage->isChecked();
m_data.path = RelativeMPath(fileName, ui->lineEditPath->text());
m_data.imageRotation = ui->spinBoxImageRotation->value();
m_data.grayscale = ui->checkBoxGrayColor->isChecked();
VWatermark doc;
doc.CreateEmptyWatermark();
doc.SetWatermark(m_data);
const bool result = doc.SaveDocument(fileName, error);
if (result)
{
SetCurrentFile(fileName);
statusBar()->showMessage(tr("File saved"), 5000);
WatermarkChangesWereSaved(result);
}
return result;
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::SetCurrentFile(const QString &fileName)
{
m_curFile = fileName;
UpdateWindowTitle();
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::OpenNewEditor(const QString &fileName) const
{
if (this->isWindowModified() || not m_curFile.isEmpty())
{
emit OpenAnother(fileName);
return true;
}
return false;
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::Clear()
{
m_curFile.clear();
UpdateWindowTitle();
setWindowModified(false);
m_data = VWatermarkData();
ShowWatermark();
}
//---------------------------------------------------------------------------------------------------------------------
bool WatermarkWindow::IgnoreLocking(int error, const QString &path)
{
QMessageBox::StandardButton answer = QMessageBox::Abort;
switch(error)
{
case QLockFile::LockFailedError:
answer = QMessageBox::warning(this, tr("Locking file"),
tr("This file already opened in another window. Ignore if you want "
"to continue (not recommended, can cause a data corruption)."),
QMessageBox::Abort|QMessageBox::Ignore, QMessageBox::Abort);
break;
case QLockFile::PermissionError:
answer = QMessageBox::question(this, tr("Locking file"),
tr("The lock file could not be created, for lack of permissions. "
"Ignore if you want to continue (not recommended, can cause "
"a data corruption)."),
QMessageBox::Abort|QMessageBox::Ignore, QMessageBox::Abort);
break;
case QLockFile::UnknownError:
answer = QMessageBox::question(this, tr("Locking file"),
tr("Unknown error happened, for instance a full partition prevented "
"writing out the lock file. Ignore if you want to continue (not "
"recommended, can cause a data corruption)."),
QMessageBox::Abort|QMessageBox::Ignore, QMessageBox::Abort);
break;
default:
answer = QMessageBox::Abort;
break;
}
if (answer == QMessageBox::Abort)
{
qDebug("Failed to lock %s", qUtf8Printable(path));
qDebug("Error type: %d", error);
Clear();
return false;
}
return true;
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::ShowWatermark()
{
ui->spinBoxOpacity->blockSignals(true);
ui->spinBoxOpacity->setValue(m_data.opacity);
ui->spinBoxOpacity->blockSignals(false);
ui->groupBoxWatermarkText->blockSignals(true);
ui->groupBoxWatermarkText->setChecked(m_data.showText);
ui->groupBoxWatermarkText->blockSignals(false);
ui->lineEditText->blockSignals(true);
ui->lineEditText->setText(m_data.text);
ui->lineEditText->blockSignals(false);
ui->spinBoxTextRotation->blockSignals(true);
ui->spinBoxTextRotation->setValue(m_data.textRotation);
ui->spinBoxTextRotation->blockSignals(false);
ui->lineEditFontSample->blockSignals(true);
ui->lineEditFontSample->setFont(m_data.font);
ui->lineEditFontSample->blockSignals(false);
ui->groupBoxWatermarkImage->blockSignals(true);
ui->groupBoxWatermarkImage->setChecked(m_data.showImage);
ui->groupBoxWatermarkImage->blockSignals(false);
ui->lineEditPath->blockSignals(true);
ui->lineEditPath->setText(AbsoluteMPath(m_curFile, m_data.path));
ValidatePath();
ui->lineEditPath->blockSignals(false);
ui->spinBoxImageRotation->blockSignals(true);
ui->spinBoxImageRotation->setValue(m_data.imageRotation);
ui->spinBoxImageRotation->blockSignals(false);
ui->checkBoxGrayColor->blockSignals(true);
ui->checkBoxGrayColor->setChecked(m_data.grayscale);
ui->checkBoxGrayColor->blockSignals(false);
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::ValidatePath()
{
QPalette palette = ui->lineEditPath->palette();
const QString path = ui->lineEditPath->text();
palette.setColor(ui->lineEditPath->foregroundRole(),
path.isEmpty() || QFileInfo::exists(path) ? m_okPathColor : Qt::red);
ui->lineEditPath->setPalette(palette);
}
//---------------------------------------------------------------------------------------------------------------------
void WatermarkWindow::ToolBarStyle(QToolBar *bar)
{
SCASSERT(bar != nullptr)
if (qApp->Settings()->GetToolBarStyle())
{
bar->setToolButtonStyle(Qt::ToolButtonTextUnderIcon);
}
else
{
bar->setToolButtonStyle(Qt::ToolButtonIconOnly);
}
}
Reference in New Issue View Git Blame Copy Permalink