PDF4QT/Pdf4QtViewer/pdfprogramcontroller.cpp

2244 lines
92 KiB
C++

// Copyright (C) 2020-2022 Jakub Melka
//
// This file is part of PDF4QT.
//
// PDF4QT is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// with the written consent of the copyright owner, any later version.
//
// PDF4QT 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with PDF4QT. If not, see <https://www.gnu.org/licenses/>.
#include "pdfprogramcontroller.h"
#include "pdfdrawwidget.h"
#include "pdfannotation.h"
#include "pdfform.h"
#include "pdfdocumentwriter.h"
#include "pdfadvancedtools.h"
#include "pdfdrawspacecontroller.h"
#include "pdfwidgetutils.h"
#include "pdfconstants.h"
#include "pdfdocumentbuilder.h"
#include "pdfdbgheap.h"
#include "pdfcertificatemanagerdialog.h"
#include "pdfviewersettings.h"
#include "pdfundoredomanager.h"
#include "pdfrendertoimagesdialog.h"
#include "pdfoptimizedocumentdialog.h"
#include "pdfviewersettingsdialog.h"
#include "pdfaboutdialog.h"
#include "pdfrenderingerrorswidget.h"
#include "pdfsendmail.h"
#include "pdfrecentfilemanager.h"
#include "pdftexttospeech.h"
#include "pdfencryptionsettingsdialog.h"
#include <QMenu>
#include <QPrinter>
#include <QPrintDialog>
#include <QMessageBox>
#include <QDesktopServices>
#include <QApplication>
#include <QFileDialog>
#include <QtConcurrent/QtConcurrent>
#include <QInputDialog>
#include <QMainWindow>
#include <QToolBar>
#include <QXmlStreamWriter>
#if defined(PDF4QT_USE_PRAGMA_LIB)
#pragma comment(lib, "Shell32")
#endif
namespace pdfviewer
{
PDFActionManager::PDFActionManager(QObject* parent) :
BaseClass(parent),
m_actions(),
m_actionGroups()
{
}
QToolButton* PDFActionManager::createToolButtonForActionGroup(ActionGroup group, QWidget* parent) const
{
QActionGroup* actionGroup = getActionGroup(group);
if (!actionGroup)
{
return nullptr;
}
QToolButton* toolButton = new QToolButton(parent);
toolButton->setPopupMode(QToolButton::MenuButtonPopup);
toolButton->setMenu(new QMenu(toolButton));
QList<QAction*> actions = actionGroup->actions();
auto onInsertStickyNotesActionTriggered = [toolButton](QAction* action)
{
if (action)
{
toolButton->setDefaultAction(action);
}
};
connect(actionGroup, &QActionGroup::triggered, toolButton, onInsertStickyNotesActionTriggered);
for (QAction* action : actions)
{
toolButton->menu()->addAction(action);
}
toolButton->setDefaultAction(actions.front());
return toolButton;
}
void PDFActionManager::setShortcut(Action type, QKeySequence sequence)
{
if (QAction* action = getAction(type))
{
action->setShortcut(sequence);
}
}
void PDFActionManager::setUserData(Action type, QVariant userData)
{
if (QAction* action = getAction(type))
{
action->setData(userData);
}
}
void PDFActionManager::setEnabled(Action type, bool enabled)
{
if (QAction* action = getAction(type))
{
action->setEnabled(enabled);
}
}
void PDFActionManager::setChecked(PDFActionManager::Action type, bool checked)
{
if (QAction* action = getAction(type))
{
action->setChecked(checked);
}
}
std::vector<QAction*> PDFActionManager::getRenderingOptionActions() const
{
return getActionList({
RenderOptionAntialiasing,
RenderOptionTextAntialiasing,
RenderOptionSmoothPictures,
RenderOptionIgnoreOptionalContentSettings,
RenderOptionDisplayAnnotations,
RenderOptionInvertColors,
RenderOptionShowTextBlocks,
RenderOptionShowTextLines
});
}
std::vector<QAction*> PDFActionManager::getActions() const
{
std::vector<QAction*> result;
result.reserve(LastAction + m_additionalActions.size());
for (int i = 0; i < LastAction; ++i)
{
if (QAction* action = getAction(Action(i)))
{
result.push_back(action);
}
}
result.insert(result.cend(), m_additionalActions.cbegin(), m_additionalActions.cend());
return result;
}
void PDFActionManager::addAdditionalAction(QAction* action)
{
m_additionalActions.push_back(action);
}
void PDFActionManager::initActions(QSize iconSize, bool initializeStampActions)
{
setShortcut(Open, QKeySequence::Open);
setShortcut(Close, QKeySequence::Close);
setShortcut(Quit, QKeySequence::Quit);
setShortcut(ZoomIn, QKeySequence::ZoomIn);
setShortcut(ZoomOut, QKeySequence::ZoomOut);
setShortcut(Find, QKeySequence::Find);
setShortcut(FindPrevious, QKeySequence::FindPrevious);
setShortcut(FindNext, QKeySequence::FindNext);
setShortcut(SelectTextAll, QKeySequence::SelectAll);
setShortcut(DeselectText, QKeySequence::Deselect);
setShortcut(CopyText, QKeySequence::Copy);
setShortcut(RotateRight, QKeySequence("Ctrl+Shift++"));
setShortcut(RotateLeft, QKeySequence("Ctrl+Shift+-"));
setShortcut(Print, QKeySequence::Print);
setShortcut(Undo, QKeySequence::Undo);
setShortcut(Redo, QKeySequence::Redo);
setShortcut(Save, QKeySequence::Save);
setShortcut(SaveAs, QKeySequence::SaveAs);
setShortcut(GoToDocumentStart, QKeySequence::MoveToStartOfDocument);
setShortcut(GoToDocumentEnd, QKeySequence::MoveToEndOfDocument);
setShortcut(GoToNextPage, QKeySequence::MoveToNextPage);
setShortcut(GoToPreviousPage, QKeySequence::MoveToPreviousPage);
setShortcut(GoToNextLine, QKeySequence::MoveToNextLine);
setShortcut(GoToPreviousLine, QKeySequence::MoveToPreviousLine);
if (hasActions({ CreateStickyNoteComment, CreateStickyNoteHelp, CreateStickyNoteInsert, CreateStickyNoteKey, CreateStickyNoteNewParagraph, CreateStickyNoteNote, CreateStickyNoteParagraph }))
{
m_actionGroups[CreateStickyNoteGroup] = new QActionGroup(this);
m_actionGroups[CreateStickyNoteGroup]->setExclusionPolicy(QActionGroup::ExclusionPolicy::ExclusiveOptional);
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteComment));
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteHelp));
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteInsert));
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteKey));
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteNewParagraph));
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteNote));
m_actionGroups[CreateStickyNoteGroup]->addAction(getAction(CreateStickyNoteParagraph));
getAction(CreateStickyNoteComment)->setData(int(pdf::TextAnnotationIcon::Comment));
getAction(CreateStickyNoteHelp)->setData(int(pdf::TextAnnotationIcon::Help));
getAction(CreateStickyNoteInsert)->setData(int(pdf::TextAnnotationIcon::Insert));
getAction(CreateStickyNoteKey)->setData(int(pdf::TextAnnotationIcon::Key));
getAction(CreateStickyNoteNewParagraph)->setData(int(pdf::TextAnnotationIcon::NewParagraph));
getAction(CreateStickyNoteNote)->setData(int(pdf::TextAnnotationIcon::Note));
getAction(CreateStickyNoteParagraph)->setData(int(pdf::TextAnnotationIcon::Paragraph));
getAction(CreateStickyNoteComment)->setIcon(pdf::PDFTextAnnotation::createIcon("Comment", iconSize));
getAction(CreateStickyNoteHelp)->setIcon(pdf::PDFTextAnnotation::createIcon("Help", iconSize));
getAction(CreateStickyNoteInsert)->setIcon(pdf::PDFTextAnnotation::createIcon("Insert", iconSize));
getAction(CreateStickyNoteKey)->setIcon(pdf::PDFTextAnnotation::createIcon("Key", iconSize));
getAction(CreateStickyNoteNewParagraph)->setIcon(pdf::PDFTextAnnotation::createIcon("NewParagraph", iconSize));
getAction(CreateStickyNoteNote)->setIcon(pdf::PDFTextAnnotation::createIcon("Note", iconSize));
getAction(CreateStickyNoteParagraph)->setIcon(pdf::PDFTextAnnotation::createIcon("Paragraph", iconSize));
}
if (hasActions({ CreateTextHighlight, CreateTextUnderline, CreateTextStrikeout, CreateTextSquiggly }))
{
m_actionGroups[CreateTextHighlightGroup] = new QActionGroup(this);
m_actionGroups[CreateTextHighlightGroup]->setExclusionPolicy(QActionGroup::ExclusionPolicy::ExclusiveOptional);
m_actionGroups[CreateTextHighlightGroup]->addAction(getAction(CreateTextHighlight));
m_actionGroups[CreateTextHighlightGroup]->addAction(getAction(CreateTextUnderline));
m_actionGroups[CreateTextHighlightGroup]->addAction(getAction(CreateTextStrikeout));
m_actionGroups[CreateTextHighlightGroup]->addAction(getAction(CreateTextSquiggly));
getAction(CreateTextHighlight)->setData(int(pdf::AnnotationType::Highlight));
getAction(CreateTextUnderline)->setData(int(pdf::AnnotationType::Underline));
getAction(CreateTextStrikeout)->setData(int(pdf::AnnotationType::StrikeOut));
getAction(CreateTextSquiggly)->setData(int(pdf::AnnotationType::Squiggly));
}
setUserData(RenderOptionAntialiasing, pdf::PDFRenderer::Antialiasing);
setUserData(RenderOptionTextAntialiasing, pdf::PDFRenderer::TextAntialiasing);
setUserData(RenderOptionSmoothPictures, pdf::PDFRenderer::SmoothImages);
setUserData(RenderOptionIgnoreOptionalContentSettings, pdf::PDFRenderer::IgnoreOptionalContent);
setUserData(RenderOptionDisplayAnnotations, pdf::PDFRenderer::DisplayAnnotations);
setUserData(RenderOptionInvertColors, pdf::PDFRenderer::InvertColors);
setUserData(RenderOptionShowTextBlocks, pdf::PDFRenderer::DebugTextBlocks);
setUserData(RenderOptionShowTextLines, pdf::PDFRenderer::DebugTextLines);
if (initializeStampActions)
{
m_actionGroups[CreateStampGroup] = new QActionGroup(this);
m_actionGroups[CreateStampGroup]->setExclusionPolicy(QActionGroup::ExclusionPolicy::ExclusiveOptional);
auto createCreateStampAction = [this](Action actionType, pdf::Stamp stamp)
{
QString text = pdf::PDFStampAnnotation::getText(stamp);
QAction* action = new QAction(text, this);
action->setObjectName(QString("actionCreateStamp_%1").arg(int(stamp)));
action->setData(int(stamp));
action->setCheckable(true);
m_actions[actionType] = action;
m_actionGroups[CreateStampGroup]->addAction(action);
};
createCreateStampAction(CreateStampApproved, pdf::Stamp::Approved);
createCreateStampAction(CreateStampAsIs, pdf::Stamp::AsIs);
createCreateStampAction(CreateStampConfidential, pdf::Stamp::Confidential);
createCreateStampAction(CreateStampDepartmental, pdf::Stamp::Departmental);
createCreateStampAction(CreateStampDraft, pdf::Stamp::Draft);
createCreateStampAction(CreateStampExperimental, pdf::Stamp::Experimental);
createCreateStampAction(CreateStampExpired, pdf::Stamp::Expired);
createCreateStampAction(CreateStampFinal, pdf::Stamp::Final);
createCreateStampAction(CreateStampForComment, pdf::Stamp::ForComment);
createCreateStampAction(CreateStampForPublicRelease, pdf::Stamp::ForPublicRelease);
createCreateStampAction(CreateStampNotApproved, pdf::Stamp::NotApproved);
createCreateStampAction(CreateStampNotForPublicRelease, pdf::Stamp::NotForPublicRelease);
createCreateStampAction(CreateStampSold, pdf::Stamp::Sold);
createCreateStampAction(CreateStampTopSecret, pdf::Stamp::TopSecret);
}
}
bool PDFActionManager::hasActions(const std::initializer_list<Action>& actionTypes) const
{
for (Action actionType : actionTypes)
{
if (!getAction(actionType))
{
return false;
}
}
return true;
}
std::vector<QAction*> PDFActionManager::getActionList(const std::initializer_list<PDFActionManager::Action>& actionTypes) const
{
std::vector<QAction*> result;
result.reserve(actionTypes.size());
for (const Action actionType : actionTypes)
{
if (QAction* action = getAction(actionType))
{
result.push_back(action);
}
}
return result;
}
PDFProgramController::PDFProgramController(QObject* parent) :
BaseClass(parent),
m_actionManager(nullptr),
m_mainWindow(nullptr),
m_mainWindowInterface(nullptr),
m_pdfWidget(nullptr),
m_settings(new PDFViewerSettings(this)),
m_undoRedoManager(nullptr),
m_recentFileManager(new PDFRecentFileManager(this)),
m_optionalContentActivity(nullptr),
m_textToSpeech(nullptr),
m_futureWatcher(nullptr),
m_CMSManager(new pdf::PDFCMSManager(this)),
m_toolManager(nullptr),
m_annotationManager(nullptr),
m_formManager(nullptr),
m_isBusy(false),
m_progress(nullptr)
{
}
PDFProgramController::~PDFProgramController()
{
delete m_formManager;
m_formManager = nullptr;
delete m_annotationManager;
m_annotationManager = nullptr;
}
void PDFProgramController::initializeAnnotationManager()
{
m_annotationManager = new pdf::PDFWidgetAnnotationManager(m_pdfWidget->getDrawWidgetProxy(), this);
connect(m_annotationManager, &pdf::PDFWidgetAnnotationManager::actionTriggered, this, &PDFProgramController::onActionTriggered);
connect(m_annotationManager, &pdf::PDFWidgetAnnotationManager::documentModified, this, &PDFProgramController::onDocumentModified);
m_pdfWidget->setAnnotationManager(m_annotationManager);
}
void PDFProgramController::initializeFormManager()
{
m_formManager = new pdf::PDFFormManager(m_pdfWidget->getDrawWidgetProxy(), this);
m_formManager->setAnnotationManager(m_annotationManager);
m_formManager->setAppearanceFlags(m_settings->getSettings().m_formAppearanceFlags);
m_annotationManager->setFormManager(m_formManager);
m_pdfWidget->setFormManager(m_formManager);
connect(m_formManager, &pdf::PDFFormManager::actionTriggered, this, &PDFProgramController::onActionTriggered);
connect(m_formManager, &pdf::PDFFormManager::documentModified, this, &PDFProgramController::onDocumentModified);
}
void PDFProgramController::initialize(Features features,
QMainWindow* mainWindow,
IMainWindow* mainWindowInterface,
PDFActionManager* actionManager,
pdf::PDFProgress* progress)
{
Q_ASSERT(!m_actionManager);
m_actionManager = actionManager;
m_progress = progress;
m_mainWindow = mainWindow;
m_mainWindowInterface = mainWindowInterface;
if (QAction* action = m_actionManager->getAction(PDFActionManager::GoToDocumentStart))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGoToDocumentStartTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::GoToDocumentEnd))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGoToDocumentEndTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::GoToNextPage))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGoToNextPageTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::GoToPreviousPage))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGoToPreviousPageTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::GoToNextLine))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGoToNextLineTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::GoToPreviousLine))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGoToPreviousLineTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::ZoomIn))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionZoomIn);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::ZoomOut))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionZoomOut);
}
for (QAction* action : m_actionManager->getRenderingOptionActions())
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionRenderingOptionTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Print))
{
connect(action, &QAction::triggered, this, &PDFProgramController::performPrint);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Save))
{
connect(action, &QAction::triggered, this, &PDFProgramController::performSave);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::SaveAs))
{
connect(action, &QAction::triggered, this, &PDFProgramController::performSaveAs);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::RotateLeft))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionRotateLeftTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::RotateRight))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionRotateRightTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Properties))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionPropertiesTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::About))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionAboutTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::SendByMail))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionSendByEMailTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::RenderToImages))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionRenderToImagesTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Optimize))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionOptimizeTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Encryption))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionEncryptionTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::FitPage))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionFitPageTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::FitWidth))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionFitWidthTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::FitHeight))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionFitHeightTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::ShowRenderingErrors))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionRenderingErrorsTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::PageLayoutSinglePage))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionPageLayoutSinglePageTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::PageLayoutContinuous))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionPageLayoutContinuousTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::PageLayoutTwoPages))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionPageLayoutTwoPagesTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::PageLayoutTwoColumns))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionPageLayoutTwoColumnsTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::PageLayoutFirstPageOnRightSide))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionFirstPageOnRightSideTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Find))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionFindTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Options))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionOptionsTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::CertificateManager))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionCertificateManagerTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Open))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionOpenTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::Close))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionCloseTriggered);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::DeveloperCreateInstaller))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionDeveloperCreateInstaller);
}
if (QAction* action = m_actionManager->getAction(PDFActionManager::GetSource))
{
connect(action, &QAction::triggered, this, &PDFProgramController::onActionGetSource);
}
if (m_recentFileManager)
{
connect(m_recentFileManager, &PDFRecentFileManager::fileOpenRequest, this, &PDFProgramController::openDocument);
for (QAction* action : m_recentFileManager->getActions())
{
m_actionManager->addAdditionalAction(action);
}
}
readSettings(Settings(WindowSettings | GeneralSettings | PluginsSettings | RecentFileSettings | CertificateSettings));
m_pdfWidget = new pdf::PDFWidget(m_CMSManager, m_settings->getRendererEngine(), m_settings->isMultisampleAntialiasingEnabled() ? m_settings->getRendererSamples() : -1, m_mainWindow);
m_pdfWidget->updateCacheLimits(m_settings->getCompiledPageCacheLimit() * 1024, m_settings->getThumbnailsCacheLimit(), m_settings->getFontCacheLimit(), m_settings->getInstancedFontCacheLimit());
m_pdfWidget->getDrawWidgetProxy()->setProgress(m_progress);
connect(this, &PDFProgramController::queryPasswordRequest, this, &PDFProgramController::onQueryPasswordRequest, Qt::BlockingQueuedConnection);
connect(m_pdfWidget->getDrawWidgetProxy(), &pdf::PDFDrawWidgetProxy::drawSpaceChanged, this, &PDFProgramController::onDrawSpaceChanged);
connect(m_pdfWidget->getDrawWidgetProxy(), &pdf::PDFDrawWidgetProxy::pageLayoutChanged, this, &PDFProgramController::onPageLayoutChanged);
connect(m_pdfWidget, &pdf::PDFWidget::pageRenderingErrorsChanged, this, &PDFProgramController::onPageRenderingErrorsChanged, Qt::QueuedConnection);
connect(m_settings, &PDFViewerSettings::settingsChanged, this, &PDFProgramController::onViewerSettingsChanged);
connect(m_CMSManager, &pdf::PDFCMSManager::colorManagementSystemChanged, this, &PDFProgramController::onColorManagementSystemChanged);
if (features.testFlag(TextToSpeech))
{
m_textToSpeech = new PDFTextToSpeech(this);
m_textToSpeech->setProxy(m_pdfWidget->getDrawWidgetProxy());
m_textToSpeech->setSettings(m_settings);
}
initializeAnnotationManager();
if (features.testFlag(Forms))
{
initializeFormManager();
}
if (features.testFlag(Tools))
{
initializeToolManager();
}
if (features.testFlag(UndoRedo))
{
// Connect undo/redo manager
m_undoRedoManager = new PDFUndoRedoManager(this);
connect(m_undoRedoManager, &PDFUndoRedoManager::undoRedoStateChanged, this, &PDFProgramController::updateUndoRedoActions);
connect(m_undoRedoManager, &PDFUndoRedoManager::documentChangeRequest, this, &PDFProgramController::onDocumentUndoRedo);
connect(m_actionManager->getAction(PDFActionManager::Undo), &QAction::triggered, m_undoRedoManager, &PDFUndoRedoManager::doUndo);
connect(m_actionManager->getAction(PDFActionManager::Redo), &QAction::triggered, m_undoRedoManager, &PDFUndoRedoManager::doRedo);
updateUndoRedoSettings();
}
if (features.testFlag(Plugins))
{
loadPlugins();
}
}
void PDFProgramController::finishInitialization()
{
readSettings(ActionSettings);
if (m_textToSpeech)
{
m_textToSpeech->setSettings(m_settings);
}
updatePageLayoutActions();
m_mainWindowInterface->updateUI(true);
onViewerSettingsChanged();
updateActionsAvailability();
}
void PDFProgramController::performPrint()
{
// Are we allowed to print in high resolution? If yes, then print in high resolution,
// otherwise print in low resolution. If this action is triggered, then print operation
// should be allowed (at least print in low resolution).
const pdf::PDFObjectStorage& storage = m_pdfDocument->getStorage();
const pdf::PDFSecurityHandler* securityHandler = storage.getSecurityHandler();
QPrinter::PrinterMode printerMode = QPrinter::HighResolution;
if (!securityHandler->isAllowed(pdf::PDFSecurityHandler::Permission::PrintHighResolution))
{
printerMode = QPrinter::ScreenResolution;
}
// Run print dialog
QPrinter printer(printerMode);
QPrintDialog printDialog(&printer, m_mainWindow);
printDialog.setOptions(QPrintDialog::PrintPageRange | QPrintDialog::PrintShowPageSize | QPrintDialog::PrintCollateCopies | QPrintDialog::PrintSelection);
printDialog.setOption(QPrintDialog::PrintCurrentPage, m_pdfWidget->getDrawWidget()->getCurrentPages().size() == 1);
printDialog.setMinMax(1, int(m_pdfDocument->getCatalog()->getPageCount()));
if (printDialog.exec() == QPrintDialog::Accepted)
{
std::vector<pdf::PDFInteger> pageIndices;
switch (printDialog.printRange())
{
case QAbstractPrintDialog::AllPages:
{
pageIndices.resize(m_pdfDocument->getCatalog()->getPageCount(), 0);
std::iota(pageIndices.begin(), pageIndices.end(), 0);
break;
}
case QAbstractPrintDialog::Selection:
case QAbstractPrintDialog::CurrentPage:
{
pageIndices = m_pdfWidget->getDrawWidget()->getCurrentPages();
break;
}
case QAbstractPrintDialog::PageRange:
{
const pdf::PDFInteger fromPage = printDialog.fromPage();
const pdf::PDFInteger toPage = printDialog.toPage();
const pdf::PDFInteger pageCount = toPage - fromPage + 1;
if (pageCount > 0)
{
pageIndices.resize(pageCount, 0);
std::iota(pageIndices.begin(), pageIndices.end(), fromPage - 1);
}
break;
}
default:
Q_ASSERT(false);
break;
}
if (pageIndices.empty())
{
// Nothing to be printed
return;
}
pdf::ProgressStartupInfo info;
info.showDialog = true;
info.text = tr("Printing document");
m_progress->start(pageIndices.size(), qMove(info));
printer.setFullPage(true);
QPainter painter(&printer);
const pdf::PDFCatalog* catalog = m_pdfDocument->getCatalog();
pdf::PDFDrawWidgetProxy* proxy = m_pdfWidget->getDrawWidgetProxy();
pdf::PDFOptionalContentActivity optionalContentActivity(m_pdfDocument.data(), pdf::OCUsage::Print, nullptr);
pdf::PDFCMSPointer cms = proxy->getCMSManager()->getCurrentCMS();
pdf::PDFRenderer renderer(m_pdfDocument.get(), proxy->getFontCache(), cms.data(), &optionalContentActivity, proxy->getFeatures(), proxy->getMeshQualitySettings());
const pdf::PDFInteger lastPage = pageIndices.back();
for (const pdf::PDFInteger pageIndex : pageIndices)
{
const pdf::PDFPage* page = catalog->getPage(pageIndex);
Q_ASSERT(page);
QRectF mediaBox = page->getRotatedMediaBox();
QRectF paperRect = printer.pageLayout().fullRectPixels(printer.resolution());
QSizeF scaledSize = mediaBox.size().scaled(paperRect.size(), Qt::KeepAspectRatio);
mediaBox.setSize(scaledSize);
mediaBox.moveCenter(paperRect.center());
renderer.render(&painter, mediaBox, pageIndex);
m_progress->step();
if (pageIndex != lastPage)
{
if (!printer.newPage())
{
break;
}
}
}
painter.end();
m_progress->finish();
}
}
void PDFProgramController::onActionTriggered(const pdf::PDFAction* action)
{
Q_ASSERT(action);
for (const pdf::PDFAction* currentAction : action->getActionList())
{
switch (action->getType())
{
case pdf::ActionType::GoTo:
{
const pdf::PDFActionGoTo* typedAction = dynamic_cast<const pdf::PDFActionGoTo*>(currentAction);
pdf::PDFDestination destination = typedAction->getDestination();
if (destination.getDestinationType() == pdf::DestinationType::Named)
{
if (const pdf::PDFDestination* targetDestination = m_pdfDocument->getCatalog()->getNamedDestination(destination.getName()))
{
destination = *targetDestination;
}
else
{
destination = pdf::PDFDestination();
QMessageBox::critical(m_mainWindow, tr("Go to action"), tr("Failed to go to destination '%1'. Destination wasn't found.").arg(pdf::PDFEncoding::convertTextString(destination.getName())));
}
}
if (destination.getDestinationType() != pdf::DestinationType::Invalid &&
destination.getPageReference() != pdf::PDFObjectReference())
{
const size_t pageIndex = m_pdfDocument->getCatalog()->getPageIndexFromPageReference(destination.getPageReference());
if (pageIndex != pdf::PDFCatalog::INVALID_PAGE_INDEX)
{
m_pdfWidget->getDrawWidgetProxy()->goToPage(pageIndex);
switch (destination.getDestinationType())
{
case pdf::DestinationType::Fit:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomFit);
break;
case pdf::DestinationType::FitH:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomFitWidth);
break;
case pdf::DestinationType::FitV:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomFitHeight);
break;
default:
break;
}
}
}
break;
}
case pdf::ActionType::Launch:
{
if (!m_settings->getSettings().m_allowLaunchApplications)
{
// Launching of applications is disabled -> continue to next action
continue;
}
const pdf::PDFActionLaunch* typedAction = dynamic_cast<const pdf::PDFActionLaunch*>(currentAction);
#ifdef Q_OS_WIN
const pdf::PDFActionLaunch::Win& winSpecification = typedAction->getWinSpecification();
if (!winSpecification.file.isEmpty())
{
QString message = tr("Would you like to launch application '%1' in working directory '%2' with parameters '%3'?").arg(QString::fromLatin1(winSpecification.file), QString::fromLatin1(winSpecification.directory), QString::fromLatin1(winSpecification.parameters));
if (QMessageBox::question(m_mainWindow, tr("Launch application"), message) == QMessageBox::Yes)
{
auto getStringOrNULL = [](const QByteArray& array) -> LPCSTR
{
if (!array.isEmpty())
{
return array.data();
}
return NULL;
};
const HINSTANCE result = ::ShellExecuteA(NULL, getStringOrNULL(winSpecification.operation), getStringOrNULL(winSpecification.file), getStringOrNULL(winSpecification.parameters), getStringOrNULL(winSpecification.directory), SW_SHOWNORMAL);
if (result <= HINSTANCE(32))
{
// Error occured
QMessageBox::warning(m_mainWindow, tr("Launch application"), tr("Executing application failed. Error code is %1.").arg(reinterpret_cast<intptr_t>(result)));
}
}
// Continue next action
continue;
}
const pdf::PDFFileSpecification& fileSpecification = typedAction->getFileSpecification();
QString plaftormFileName = fileSpecification.getPlatformFileName();
if (!plaftormFileName.isEmpty())
{
QString message = tr("Would you like to launch application '%1'?").arg(plaftormFileName);
if (QMessageBox::question(m_mainWindow, tr("Launch application"), message) == QMessageBox::Yes)
{
const HINSTANCE result = ::ShellExecuteW(NULL, NULL, plaftormFileName.toStdWString().c_str(), NULL, NULL, SW_SHOWNORMAL);
if (result <= HINSTANCE(32))
{
// Error occured
QMessageBox::warning(m_mainWindow, tr("Launch application"), tr("Executing application failed. Error code is %1.").arg(reinterpret_cast<intptr_t>(result)));
}
}
// Continue next action
continue;
}
#endif
break;
}
case pdf::ActionType::URI:
{
if (!m_settings->getSettings().m_allowLaunchURI)
{
// Launching of URI is disabled -> continue to next action
continue;
}
const pdf::PDFActionURI* typedAction = dynamic_cast<const pdf::PDFActionURI*>(currentAction);
QByteArray URI = m_pdfDocument->getCatalog()->getBaseURI() + typedAction->getURI();
QString urlString = QString::fromUtf8(URI);
QString message = tr("Would you like to open URL '%1'?").arg(urlString);
if (QMessageBox::question(m_mainWindow, tr("Open URL"), message) == QMessageBox::Yes)
{
if (!QDesktopServices::openUrl(QUrl(urlString)))
{
// Error occured
QMessageBox::warning(m_mainWindow, tr("Open URL"), tr("Opening url '%1' failed.").arg(urlString));
}
}
break;
}
case pdf::ActionType::Named:
{
const pdf::PDFActionNamed* typedAction = dynamic_cast<const pdf::PDFActionNamed*>(currentAction);
switch (typedAction->getNamedActionType())
{
case pdf::PDFActionNamed::NamedActionType::NextPage:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateNextPage);
break;
case pdf::PDFActionNamed::NamedActionType::PrevPage:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigatePreviousPage);
break;
case pdf::PDFActionNamed::NamedActionType::FirstPage:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateDocumentStart);
break;
case pdf::PDFActionNamed::NamedActionType::LastPage:
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateDocumentEnd);
break;
default:
break;
}
break;
}
case pdf::ActionType::SetOCGState:
{
const pdf::PDFActionSetOCGState* typedAction = dynamic_cast<const pdf::PDFActionSetOCGState*>(currentAction);
const pdf::PDFActionSetOCGState::StateChangeItems& stateChanges = typedAction->getStateChangeItems();
const bool isRadioButtonsPreserved = typedAction->isRadioButtonsPreserved();
if (m_optionalContentActivity)
{
for (const pdf::PDFActionSetOCGState::StateChangeItem& stateChange : stateChanges)
{
pdf::OCState newState = pdf::OCState::Unknown;
switch (stateChange.first)
{
case pdf::PDFActionSetOCGState::SwitchType::ON:
newState = pdf::OCState::ON;
break;
case pdf::PDFActionSetOCGState::SwitchType::OFF:
newState = pdf::OCState::OFF;
break;
case pdf::PDFActionSetOCGState::SwitchType::Toggle:
{
pdf::OCState oldState = m_optionalContentActivity->getState(stateChange.second);
switch (oldState)
{
case pdf::OCState::ON:
newState = pdf::OCState::OFF;
break;
case pdf::OCState::OFF:
newState = pdf::OCState::ON;
break;
case pdf::OCState::Unknown:
break;
default:
Q_ASSERT(false);
break;
}
break;
}
default:
Q_ASSERT(false);
}
if (newState != pdf::OCState::Unknown)
{
m_optionalContentActivity->setState(stateChange.second, newState, isRadioButtonsPreserved);
}
}
}
break;
}
case pdf::ActionType::ResetForm:
{
m_formManager->performResetAction(dynamic_cast<const pdf::PDFActionResetForm*>(action));
break;
}
default:
break;
}
}
}
void PDFProgramController::initializeToolManager()
{
// Initialize tools
pdf::PDFToolManager::Actions actions;
actions.findPrevAction = m_actionManager->getAction(PDFActionManager::FindPrevious);
actions.findNextAction = m_actionManager->getAction(PDFActionManager::FindNext);
actions.selectTextToolAction = m_actionManager->getAction(PDFActionManager::ToolSelectText);
actions.selectTableToolAction = m_actionManager->getAction(PDFActionManager::ToolSelectTable);
actions.selectAllAction = m_actionManager->getAction(PDFActionManager::SelectTextAll);
actions.deselectAction = m_actionManager->getAction(PDFActionManager::DeselectText);
actions.copyTextAction = m_actionManager->getAction(PDFActionManager::CopyText);
actions.magnifierAction = m_actionManager->getAction(PDFActionManager::ToolMagnifier);
actions.screenshotToolAction = m_actionManager->getAction(PDFActionManager::ToolScreenshot);
actions.extractImageAction = m_actionManager->getAction(PDFActionManager::ToolExtractImage);
m_toolManager = new pdf::PDFToolManager(m_pdfWidget->getDrawWidgetProxy(), actions, this, m_mainWindow);
m_pdfWidget->setToolManager(m_toolManager);
updateMagnifierToolSettings();
connect(m_toolManager, &pdf::PDFToolManager::documentModified, this, &PDFProgramController::onDocumentModified);
// Add special tools
pdf::PDFCreateStickyNoteTool* createStickyNoteTool = new pdf::PDFCreateStickyNoteTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getActionGroup(PDFActionManager::CreateStickyNoteGroup), this);
m_toolManager->addTool(createStickyNoteTool);
pdf::PDFCreateHyperlinkTool* createHyperlinkTool = new pdf::PDFCreateHyperlinkTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getAction(PDFActionManager::CreateHyperlink), this);
m_toolManager->addTool(createHyperlinkTool);
pdf::PDFCreateFreeTextTool* createFreeTextTool = new pdf::PDFCreateFreeTextTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getAction(PDFActionManager::CreateInlineText), this);
m_toolManager->addTool(createFreeTextTool);
pdf::PDFCreateLineTypeTool* createStraightLineTool = new pdf::PDFCreateLineTypeTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, pdf::PDFCreateLineTypeTool::Type::Line, m_actionManager->getAction(PDFActionManager::CreateStraightLine), this);
m_toolManager->addTool(createStraightLineTool);
pdf::PDFCreateLineTypeTool* createPolylineTool = new pdf::PDFCreateLineTypeTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, pdf::PDFCreateLineTypeTool::Type::PolyLine, m_actionManager->getAction(PDFActionManager::CreatePolyline), this);
m_toolManager->addTool(createPolylineTool);
pdf::PDFCreateLineTypeTool* createPolygonTool = new pdf::PDFCreateLineTypeTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, pdf::PDFCreateLineTypeTool::Type::Polygon, m_actionManager->getAction(PDFActionManager::CreatePolygon), this);
m_toolManager->addTool(createPolygonTool);
pdf::PDFCreateEllipseTool* createEllipseTool = new pdf::PDFCreateEllipseTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getAction(PDFActionManager::CreateEllipse), this);
m_toolManager->addTool(createEllipseTool);
pdf::PDFCreateFreehandCurveTool* createFreehandCurveTool = new pdf::PDFCreateFreehandCurveTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getAction(PDFActionManager::CreateFreehandCurve), this);
m_toolManager->addTool(createFreehandCurveTool);
pdf::PDFCreateStampTool* createStampTool = new pdf::PDFCreateStampTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getActionGroup(PDFActionManager::CreateStampGroup), this);
m_toolManager->addTool(createStampTool);
pdf::PDFCreateHighlightTextTool* createHighlightTextTool = new pdf::PDFCreateHighlightTextTool(m_pdfWidget->getDrawWidgetProxy(), m_toolManager, m_actionManager->getActionGroup(PDFActionManager::CreateTextHighlightGroup), this);
m_toolManager->addTool(createHighlightTextTool);
}
void PDFProgramController::onActionGoToDocumentStartTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateDocumentStart);
}
void PDFProgramController::onActionGoToDocumentEndTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateDocumentEnd);
}
void PDFProgramController::onActionGoToNextPageTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateNextPage);
}
void PDFProgramController::onActionGoToPreviousPageTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigatePreviousPage);
}
void PDFProgramController::onActionGoToNextLineTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigateNextStep);
}
void PDFProgramController::onActionGoToPreviousLineTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::NavigatePreviousStep);
}
void PDFProgramController::onActionZoomIn()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomIn);
}
void PDFProgramController::onActionZoomOut()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomOut);
}
void PDFProgramController::onActionRenderingOptionTriggered(bool checked)
{
QAction* action = qobject_cast<QAction*>(sender());
Q_ASSERT(action);
pdf::PDFRenderer::Features features = m_settings->getFeatures();
features.setFlag(static_cast<pdf::PDFRenderer::Feature>(action->data().toInt()), checked);
m_settings->setFeatures(features);
}
void PDFProgramController::performSaveAs()
{
QFileInfo fileInfo(m_fileInfo.originalFileName);
QString saveFileName = QFileDialog::getSaveFileName(m_mainWindow, tr("Save As"), fileInfo.dir().absoluteFilePath(m_fileInfo.originalFileName), tr("Portable Document (*.pdf);;All files (*.*)"));
if (!saveFileName.isEmpty())
{
saveDocument(saveFileName);
}
}
void PDFProgramController::performSave()
{
saveDocument(m_fileInfo.originalFileName);
}
void PDFProgramController::saveDocument(const QString& fileName)
{
pdf::PDFDocumentWriter writer(nullptr);
pdf::PDFOperationResult result = writer.write(fileName, m_pdfDocument.data(), true);
if (result)
{
updateFileInfo(fileName);
updateTitle();
if (m_recentFileManager)
{
m_recentFileManager->addRecentFile(fileName);
}
}
else
{
QMessageBox::critical(m_mainWindow, tr("Error"), result.getErrorMessage());
}
}
bool PDFProgramController::getIsBusy() const
{
return m_isBusy;
}
void PDFProgramController::setIsBusy(bool isBusy)
{
m_isBusy = isBusy;
}
bool PDFProgramController::canClose() const
{
return !(m_futureWatcher && m_futureWatcher->isRunning()) || !m_isBusy;
}
QString PDFProgramController::getOriginalFileName() const
{
return m_fileInfo.originalFileName;
}
pdf::PDFTextSelection PDFProgramController::getSelectedText() const
{
return m_mainWindowInterface->getSelectedText();
}
QMainWindow* PDFProgramController::getMainWindow() const
{
return m_mainWindow;
}
pdf::IPluginDataExchange::VoiceSettings PDFProgramController::getVoiceSettings() const
{
VoiceSettings voiceSettings;
const PDFViewerSettings::Settings& settings = m_settings->getSettings();
voiceSettings.directory = m_settings->getDirectory();
voiceSettings.voiceName = settings.m_speechVoice;
voiceSettings.pitch = settings.m_speechPitch;
voiceSettings.rate = settings.m_speechRate;
voiceSettings.volume = settings.m_speechVolume;
return voiceSettings;
}
void PDFProgramController::onActionRotateRightTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::RotateRight);
}
void PDFProgramController::onActionRotateLeftTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::RotateLeft);
}
void PDFProgramController::onActionPropertiesTriggered()
{
Q_ASSERT(m_pdfDocument);
PDFDocumentPropertiesDialog documentPropertiesDialog(m_pdfDocument.data(), &m_fileInfo, m_mainWindow);
documentPropertiesDialog.exec();
}
void PDFProgramController::onActionAboutTriggered()
{
PDFAboutDialog dialog(m_mainWindow);
dialog.exec();
}
void PDFProgramController::onActionSendByEMailTriggered()
{
Q_ASSERT(m_pdfDocument);
QString subject = m_pdfDocument->getInfo()->title;
if (subject.isEmpty())
{
subject = m_fileInfo.fileName;
}
if (!PDFSendMail::sendMail(m_mainWindow, subject, m_fileInfo.originalFileName))
{
QMessageBox::critical(m_mainWindow, tr("Error"), tr("Error while starting email client occured!"));
}
}
void PDFProgramController::onActionRenderToImagesTriggered()
{
PDFRenderToImagesDialog dialog(m_pdfDocument.data(), m_pdfWidget->getDrawWidgetProxy(), m_progress, m_mainWindow);
dialog.exec();
}
void PDFProgramController::onActionOptimizeTriggered()
{
PDFOptimizeDocumentDialog dialog(m_pdfDocument.data(), m_mainWindow);
if (dialog.exec() == QDialog::Accepted)
{
pdf::PDFDocumentPointer pointer(new pdf::PDFDocument(dialog.takeOptimizedDocument()));
pdf::PDFModifiedDocument document(qMove(pointer), m_optionalContentActivity, pdf::PDFModifiedDocument::Reset);
onDocumentModified(qMove(document));
}
}
void PDFProgramController::onActionEncryptionTriggered()
{
auto queryPassword = [this](bool* ok)
{
QString result;
*ok = false;
onQueryPasswordRequest(&result, ok);
return result;
};
// Check that we have owner access to the document
const pdf::PDFSecurityHandler* securityHandler = m_pdfDocument->getStorage().getSecurityHandler();
pdf::PDFSecurityHandler::AuthorizationResult authorizationResult = securityHandler->getAuthorizationResult();
if (authorizationResult != pdf::PDFSecurityHandler::AuthorizationResult::OwnerAuthorized &&
authorizationResult != pdf::PDFSecurityHandler::AuthorizationResult::NoAuthorizationRequired)
{
// Jakub Melka: we must authorize as owner, otherwise we can't continue,
// because we don't have sufficient permissions.
pdf::PDFSecurityHandlerPointer clonedSecurityHandler(securityHandler->clone());
authorizationResult = clonedSecurityHandler->authenticate(queryPassword, true);
if (authorizationResult != pdf::PDFSecurityHandler::AuthorizationResult::OwnerAuthorized)
{
QMessageBox::critical(m_mainWindow, QApplication::applicationDisplayName(), tr("Permission to change document security is denied."));
return;
}
pdf::PDFObjectStorage storage = m_pdfDocument->getStorage();
storage.setSecurityHandler(qMove(clonedSecurityHandler));
pdf::PDFDocumentPointer pointer(new pdf::PDFDocument(qMove(storage), m_pdfDocument->getInfo()->version));
pdf::PDFModifiedDocument document(qMove(pointer), m_optionalContentActivity, pdf::PDFModifiedDocument::Authorization);
onDocumentModified(qMove(document));
}
PDFEncryptionSettingsDialog dialog(m_pdfDocument->getIdPart(0), m_mainWindow);
if (dialog.exec() == QDialog::Accepted)
{
pdf::PDFSecurityHandlerPointer updatedSecurityHandler = dialog.getUpdatedSecurityHandler();
if (!updatedSecurityHandler)
{
QMessageBox::critical(m_mainWindow, QApplication::applicationDisplayName(), tr("Failed to create security handler."));
return;
}
// Jakub Melka: If we changed encryption (password), recheck, that user doesn't
// forgot (or accidentally entered wrong) password. So, we require owner authentization
// to continue.
switch (updatedSecurityHandler->getMode())
{
case pdf::EncryptionMode::Standard:
{
if (updatedSecurityHandler->authenticate(queryPassword, true) != pdf::PDFSecurityHandler::AuthorizationResult::OwnerAuthorized)
{
QMessageBox::critical(m_mainWindow, QApplication::applicationDisplayName(), tr("Reauthorization is required to change document encryption."));
return;
}
break;
}
case pdf::EncryptionMode::PublicKey:
{
if (updatedSecurityHandler->authenticate(queryPassword, false) != pdf::PDFSecurityHandler::AuthorizationResult::UserAuthorized)
{
QMessageBox::critical(m_mainWindow, QApplication::applicationDisplayName(), tr("Reauthorization is required to change document encryption."));
return;
}
break;
}
case pdf::EncryptionMode::None:
break;
default:
Q_ASSERT(false);
break;
}
pdf::PDFDocumentBuilder builder(m_pdfDocument.data());
builder.setSecurityHandler(qMove(updatedSecurityHandler));
pdf::PDFDocumentPointer pointer(new pdf::PDFDocument(builder.build()));
pdf::PDFModifiedDocument document(qMove(pointer), m_optionalContentActivity, pdf::PDFModifiedDocument::Reset);
onDocumentModified(qMove(document));
}
}
void PDFProgramController::onActionFitPageTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomFit);
}
void PDFProgramController::onActionFitWidthTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomFitWidth);
}
void PDFProgramController::onActionFitHeightTriggered()
{
m_pdfWidget->getDrawWidgetProxy()->performOperation(pdf::PDFDrawWidgetProxy::ZoomFitHeight);
}
void PDFProgramController::onActionRenderingErrorsTriggered()
{
pdf::PDFRenderingErrorsWidget renderingErrorsDialog(m_mainWindow, m_pdfWidget);
renderingErrorsDialog.exec();
}
void PDFProgramController::updateMagnifierToolSettings()
{
if (m_toolManager)
{
pdf::PDFMagnifierTool* magnifierTool = m_toolManager->getMagnifierTool();
magnifierTool->setMagnifierSize(pdf::PDFWidgetUtils::scaleDPI_x(m_mainWindow, m_settings->getSettings().m_magnifierSize));
magnifierTool->setMagnifierZoom(m_settings->getSettings().m_magnifierZoom);
}
}
void PDFProgramController::updateUndoRedoSettings()
{
if (m_undoRedoManager)
{
const PDFViewerSettings::Settings& settings = m_settings->getSettings();
m_undoRedoManager->setMaximumSteps(settings.m_maximumUndoSteps, settings.m_maximumRedoSteps);
}
}
void PDFProgramController::updateUndoRedoActions()
{
if (m_undoRedoManager)
{
const bool isBusy = (m_futureWatcher && m_futureWatcher->isRunning()) || m_isBusy;
const bool canUndo = !isBusy && m_undoRedoManager->canUndo();
const bool canRedo = !isBusy && m_undoRedoManager->canRedo();
m_actionManager->setEnabled(PDFActionManager::Undo, canUndo);
m_actionManager->setEnabled(PDFActionManager::Redo, canRedo);
}
else
{
m_actionManager->setEnabled(PDFActionManager::Undo, false);
m_actionManager->setEnabled(PDFActionManager::Redo, false);
}
}
void PDFProgramController::onQueryPasswordRequest(QString* password, bool* ok)
{
*password = QInputDialog::getText(m_mainWindow, tr("Encrypted document"), tr("Enter password to access document content"), QLineEdit::Password, QString(), ok);
}
void PDFProgramController::onActionPageLayoutSinglePageTriggered()
{
setPageLayout(pdf::PageLayout::SinglePage);
}
void PDFProgramController::onActionPageLayoutContinuousTriggered()
{
setPageLayout(pdf::PageLayout::OneColumn);
}
void PDFProgramController::onActionPageLayoutTwoPagesTriggered()
{
setPageLayout(m_actionManager->getAction(PDFActionManager::PageLayoutFirstPageOnRightSide)->isChecked() ? pdf::PageLayout::TwoPagesRight : pdf::PageLayout::TwoPagesLeft);
}
void PDFProgramController::onActionPageLayoutTwoColumnsTriggered()
{
setPageLayout(m_actionManager->getAction(PDFActionManager::PageLayoutFirstPageOnRightSide)->isChecked() ? pdf::PageLayout::TwoColumnRight : pdf::PageLayout::TwoColumnLeft);
}
void PDFProgramController::onActionFirstPageOnRightSideTriggered()
{
switch (m_pdfWidget->getDrawWidgetProxy()->getPageLayout())
{
case pdf::PageLayout::SinglePage:
case pdf::PageLayout::OneColumn:
break;
case pdf::PageLayout::TwoColumnLeft:
case pdf::PageLayout::TwoColumnRight:
onActionPageLayoutTwoColumnsTriggered();
break;
case pdf::PageLayout::TwoPagesLeft:
case pdf::PageLayout::TwoPagesRight:
onActionPageLayoutTwoPagesTriggered();
break;
default:
Q_ASSERT(false);
}
}
void PDFProgramController::onActionFindTriggered()
{
if (m_toolManager)
{
m_toolManager->setActiveTool(m_toolManager->getFindTextTool());
}
}
void PDFProgramController::readSettings(Settings settingsFlags)
{
QSettings settings(QSettings::IniFormat, QSettings::UserScope, QCoreApplication::organizationName(), QCoreApplication::applicationName());
if (settingsFlags.testFlag(WindowSettings))
{
QByteArray geometry = settings.value("geometry", QByteArray()).toByteArray();
if (geometry.isEmpty())
{
QRect availableGeometry = QApplication::primaryScreen()->availableGeometry();
QRect windowRect(0, 0, availableGeometry.width() / 2, availableGeometry.height() / 2);
windowRect = windowRect.translated(availableGeometry.center() - windowRect.center());
m_mainWindow->setGeometry(windowRect);
}
else
{
m_mainWindow->restoreGeometry(geometry);
}
QByteArray state = settings.value("windowState", QByteArray()).toByteArray();
if (!state.isEmpty())
{
m_mainWindow->restoreState(state);
}
}
if (settingsFlags.testFlag(GeneralSettings))
{
m_settings->readSettings(settings, m_CMSManager->getDefaultSettings());
m_CMSManager->setSettings(m_settings->getColorManagementSystemSettings());
if (m_textToSpeech)
{
m_textToSpeech->setSettings(m_settings);
}
if (m_formManager)
{
m_formManager->setAppearanceFlags(m_settings->getSettings().m_formAppearanceFlags);
}
}
if (settingsFlags.testFlag(PluginsSettings))
{
// Load allowed plugins
settings.beginGroup("Plugins");
m_enabledPlugins = settings.value("EnabledPlugins").toStringList();
settings.endGroup();
}
// Load action shortcuts
if (settingsFlags.testFlag(ActionSettings))
{
settings.beginGroup("Actions");
for (QAction* action : m_actionManager->getActions())
{
QString name = action->objectName();
if (!name.isEmpty() && settings.contains(name))
{
QKeySequence sequence = QKeySequence::fromString(settings.value(name, action->shortcut().toString(QKeySequence::PortableText)).toString(), QKeySequence::PortableText);
action->setShortcut(sequence);
}
}
settings.endGroup();
}
if (settingsFlags.testFlag(RecentFileSettings) && m_recentFileManager)
{
// Load recent files
settings.beginGroup("RecentFiles");
m_recentFileManager->setRecentFilesLimit(settings.value("MaximumRecentFilesCount", PDFRecentFileManager::getDefaultRecentFiles()).toInt());
m_recentFileManager->setRecentFiles(settings.value("RecentFileList", QStringList()).toStringList());
settings.endGroup();
}
if (settingsFlags.testFlag(CertificateSettings))
{
// Load trusted certificates
m_certificateStore.loadDefaultUserCertificates();
}
}
void PDFProgramController::setPageLayout(pdf::PageLayout pageLayout)
{
m_pdfWidget->getDrawWidgetProxy()->setPageLayout(pageLayout);
}
void PDFProgramController::updateActionsAvailability()
{
const bool isBusy = (m_futureWatcher && m_futureWatcher->isRunning()) || m_isBusy;
const bool hasDocument = m_pdfDocument != nullptr;
const bool hasValidDocument = !isBusy && hasDocument;
bool canPrint = false;
if (m_pdfDocument)
{
const pdf::PDFObjectStorage& storage = m_pdfDocument->getStorage();
const pdf::PDFSecurityHandler* securityHandler = storage.getSecurityHandler();
canPrint = securityHandler->isAllowed(pdf::PDFSecurityHandler::Permission::PrintLowResolution) ||
securityHandler->isAllowed(pdf::PDFSecurityHandler::Permission::PrintHighResolution);
}
m_actionManager->setEnabled(PDFActionManager::Open, !isBusy);
m_actionManager->setEnabled(PDFActionManager::Close, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::Quit, !isBusy);
m_actionManager->setEnabled(PDFActionManager::Options, !isBusy);
m_actionManager->setEnabled(PDFActionManager::About, !isBusy);
m_actionManager->setEnabled(PDFActionManager::FitPage, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::FitWidth, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::FitHeight, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::ShowRenderingErrors, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::Find, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::Print, hasValidDocument && canPrint);
m_actionManager->setEnabled(PDFActionManager::RenderToImages, hasValidDocument && canPrint);
m_actionManager->setEnabled(PDFActionManager::Optimize, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::Encryption, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::Save, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::SaveAs, hasValidDocument);
m_actionManager->setEnabled(PDFActionManager::Properties, hasDocument);
m_actionManager->setEnabled(PDFActionManager::SendByMail, hasDocument);
m_mainWindow->setEnabled(!isBusy);
updateUndoRedoActions();
}
void PDFProgramController::onViewerSettingsChanged()
{
m_pdfWidget->updateRenderer(m_settings->getRendererEngine(), m_settings->isMultisampleAntialiasingEnabled() ? m_settings->getRendererSamples() : -1);
m_pdfWidget->updateCacheLimits(m_settings->getCompiledPageCacheLimit() * 1024, m_settings->getThumbnailsCacheLimit(), m_settings->getFontCacheLimit(), m_settings->getInstancedFontCacheLimit());
m_pdfWidget->getDrawWidgetProxy()->setFeatures(m_settings->getFeatures());
m_pdfWidget->getDrawWidgetProxy()->setPreferredMeshResolutionRatio(m_settings->getPreferredMeshResolutionRatio());
m_pdfWidget->getDrawWidgetProxy()->setMinimalMeshResolutionRatio(m_settings->getMinimalMeshResolutionRatio());
m_pdfWidget->getDrawWidgetProxy()->setColorTolerance(m_settings->getColorTolerance());
m_annotationManager->setFeatures(m_settings->getFeatures());
m_annotationManager->setMeshQualitySettings(m_pdfWidget->getDrawWidgetProxy()->getMeshQualitySettings());
pdf::PDFExecutionPolicy::setStrategy(m_settings->getMultithreadingStrategy());
updateRenderingOptionActions();
}
void PDFProgramController::onColorManagementSystemChanged()
{
m_settings->setColorManagementSystemSettings(m_CMSManager->getSettings());
}
void PDFProgramController::updateFileInfo(const QString& fileName)
{
QFileInfo fileInfo(fileName);
m_fileInfo.originalFileName = fileName;
m_fileInfo.fileName = fileInfo.fileName();
m_fileInfo.path = fileInfo.path();
m_fileInfo.fileSize = fileInfo.size();
m_fileInfo.writable = fileInfo.isWritable();
m_fileInfo.creationTime = fileInfo.birthTime();
m_fileInfo.lastModifiedTime = fileInfo.lastModified();
m_fileInfo.lastReadTime = fileInfo.lastRead();
}
void PDFProgramController::openDocument(const QString& fileName)
{
// First close old document
closeDocument();
updateFileInfo(fileName);
QApplication::setOverrideCursor(Qt::WaitCursor);
auto readDocument = [this, fileName]() -> AsyncReadingResult
{
AsyncReadingResult result;
auto queryPassword = [this](bool* ok)
{
QString result;
*ok = false;
Q_EMIT queryPasswordRequest(&result, ok);
return result;
};
// Try to open a new document
pdf::PDFDocumentReader reader(m_progress, qMove(queryPassword), true, false);
pdf::PDFDocument document = reader.readFromFile(fileName);
result.errorMessage = reader.getErrorMessage();
result.result = reader.getReadingResult();
if (result.result == pdf::PDFDocumentReader::Result::OK)
{
// Verify signatures
pdf::PDFSignatureHandler::Parameters parameters;
parameters.store = &m_certificateStore;
parameters.dss = &document.getCatalog()->getDocumentSecurityStore();
parameters.enableVerification = m_settings->getSettings().m_signatureVerificationEnabled;
parameters.ignoreExpirationDate = m_settings->getSettings().m_signatureIgnoreCertificateValidityTime;
parameters.useSystemCertificateStore = m_settings->getSettings().m_signatureUseSystemStore;
pdf::PDFForm form = pdf::PDFForm::parse(&document, document.getCatalog()->getFormObject());
result.signatures = pdf::PDFSignatureHandler::verifySignatures(form, reader.getSource(), parameters);
result.document.reset(new pdf::PDFDocument(qMove(document)));
}
return result;
};
m_future = QtConcurrent::run(readDocument);
m_futureWatcher = new QFutureWatcher<AsyncReadingResult>();
connect(m_futureWatcher, &QFutureWatcher<AsyncReadingResult>::finished, this, &PDFProgramController::onDocumentReadingFinished);
m_futureWatcher->setFuture(m_future);
updateActionsAvailability();
}
void PDFProgramController::onDocumentReadingFinished()
{
QApplication::restoreOverrideCursor();
AsyncReadingResult result = m_future.result();
m_future = QFuture<AsyncReadingResult>();
m_futureWatcher->deleteLater();
m_futureWatcher = nullptr;
switch (result.result)
{
case pdf::PDFDocumentReader::Result::OK:
{
// Mark current directory as this
QFileInfo fileInfo(m_fileInfo.originalFileName);
m_settings->setDirectory(fileInfo.dir().absolutePath());
// We add file to recent files only, if we have successfully read the document
m_recentFileManager->addRecentFile(m_fileInfo.originalFileName);
m_pdfDocument = qMove(result.document);
m_signatures = qMove(result.signatures);
pdf::PDFModifiedDocument document(m_pdfDocument.data(), m_optionalContentActivity);
setDocument(document);
if (m_formManager)
{
m_formManager->performPaging();
}
pdf::PDFDocumentRequirements requirements = pdf::PDFDocumentRequirements::parse(&m_pdfDocument->getStorage(), m_pdfDocument->getCatalog()->getRequirements());
constexpr pdf::PDFDocumentRequirements::Requirements requirementFlags = pdf::PDFDocumentRequirements::Requirements(pdf::PDFDocumentRequirements::OCInteract |
pdf::PDFDocumentRequirements::OCAutoStates |
pdf::PDFDocumentRequirements::Navigation |
pdf::PDFDocumentRequirements::Attachment |
pdf::PDFDocumentRequirements::DigSigValidation |
pdf::PDFDocumentRequirements::Encryption);
pdf::PDFDocumentRequirements::ValidationResult requirementResult = requirements.validate(requirementFlags);
if (requirementResult.isError())
{
QMessageBox::critical(m_mainWindow, QApplication::applicationDisplayName(), requirementResult.message);
}
else if (requirementResult.isWarning())
{
QMessageBox::warning(m_mainWindow, QApplication::applicationDisplayName(), requirementResult.message);
}
m_mainWindowInterface->setStatusBarMessage(tr("Document '%1' was successfully loaded!").arg(m_fileInfo.fileName), 4000);
break;
}
case pdf::PDFDocumentReader::Result::Failed:
{
QMessageBox::critical(m_mainWindow, QApplication::applicationDisplayName(), tr("Document read error: %1").arg(result.errorMessage));
break;
}
case pdf::PDFDocumentReader::Result::Cancelled:
break; // Do nothing, user cancelled the document reading
}
updateActionsAvailability();
}
void PDFProgramController::onDocumentModified(pdf::PDFModifiedDocument document)
{
// We will create undo/redo step from old document, with flags from the new,
// because new document is modification of old document with flags.
Q_ASSERT(m_pdfDocument);
if (m_undoRedoManager)
{
m_undoRedoManager->createUndo(document, m_pdfDocument);
}
m_pdfDocument = document;
document.setOptionalContentActivity(m_optionalContentActivity);
setDocument(document);
}
void PDFProgramController::onDocumentUndoRedo(pdf::PDFModifiedDocument document)
{
m_pdfDocument = document;
document.setOptionalContentActivity(m_optionalContentActivity);
setDocument(document);
}
void PDFProgramController::setDocument(pdf::PDFModifiedDocument document)
{
if (document.hasReset())
{
if (m_optionalContentActivity)
{
// We use deleteLater, because we want to avoid consistency problem with model
// (we set document to the model before activity).
m_optionalContentActivity->deleteLater();
m_optionalContentActivity = nullptr;
}
if (document)
{
m_optionalContentActivity = new pdf::PDFOptionalContentActivity(document, pdf::OCUsage::View, this);
}
if (m_undoRedoManager)
{
m_undoRedoManager->clear();
}
}
else if (m_optionalContentActivity)
{
Q_ASSERT(document);
m_optionalContentActivity->setDocument(document);
}
document.setOptionalContentActivity(m_optionalContentActivity);
if (m_annotationManager)
{
m_annotationManager->setDocument(document);
}
if (m_formManager)
{
m_formManager->setDocument(document);
}
if (m_toolManager)
{
m_toolManager->setDocument(document);
}
if (m_textToSpeech)
{
m_textToSpeech->setDocument(document);
}
m_pdfWidget->setDocument(document);
m_mainWindowInterface->setDocument(document);
m_CMSManager->setDocument(document);
updateTitle();
m_mainWindowInterface->updateUI(true);
for (const auto& plugin : m_loadedPlugins)
{
plugin.second->setDocument(document);
}
if (m_pdfDocument && document.hasReset())
{
const pdf::PDFCatalog* catalog = m_pdfDocument->getCatalog();
setPageLayout(catalog->getPageLayout());
updatePageLayoutActions();
if (const pdf::PDFAction* action = catalog->getOpenAction())
{
onActionTriggered(action);
}
}
updateActionsAvailability();
}
void PDFProgramController::closeDocument()
{
m_signatures.clear();
setDocument(pdf::PDFModifiedDocument());
m_pdfDocument.reset();
updateActionsAvailability();
updateTitle();
}
void PDFProgramController::updateRenderingOptionActions()
{
const pdf::PDFRenderer::Features features = m_settings->getFeatures();
for (QAction* action : m_actionManager->getRenderingOptionActions())
{
action->setChecked(features.testFlag(static_cast<pdf::PDFRenderer::Feature>(action->data().toInt())));
}
}
void PDFProgramController::updateTitle()
{
if (m_pdfDocument)
{
QString title = m_pdfDocument->getInfo()->title;
if (title.isEmpty())
{
title = m_fileInfo.fileName;
}
m_mainWindow->setWindowTitle(tr("%1 - %2").arg(title, QApplication::applicationDisplayName()));
}
else
{
m_mainWindow->setWindowTitle(QApplication::applicationDisplayName());
}
}
void PDFProgramController::updatePageLayoutActions()
{
for (PDFActionManager::Action action : { PDFActionManager::PageLayoutSinglePage, PDFActionManager::PageLayoutContinuous,
PDFActionManager::PageLayoutTwoPages, PDFActionManager::PageLayoutTwoColumns })
{
m_actionManager->setChecked(action, false);
}
const pdf::PageLayout pageLayout = m_pdfWidget->getDrawWidgetProxy()->getPageLayout();
switch (pageLayout)
{
case pdf::PageLayout::SinglePage:
m_actionManager->setChecked(PDFActionManager::PageLayoutSinglePage, true);
break;
case pdf::PageLayout::OneColumn:
m_actionManager->setChecked(PDFActionManager::PageLayoutContinuous, true);
break;
case pdf::PageLayout::TwoColumnLeft:
case pdf::PageLayout::TwoColumnRight:
m_actionManager->setChecked(PDFActionManager::PageLayoutTwoColumns, true);
m_actionManager->setChecked(PDFActionManager::PageLayoutFirstPageOnRightSide, pageLayout == pdf::PageLayout::TwoPagesRight);
break;
case pdf::PageLayout::TwoPagesLeft:
case pdf::PageLayout::TwoPagesRight:
m_actionManager->setChecked(PDFActionManager::PageLayoutTwoPages, true);
m_actionManager->setChecked(PDFActionManager::PageLayoutFirstPageOnRightSide, pageLayout == pdf::PageLayout::TwoPagesRight);
break;
default:
Q_ASSERT(false);
}
}
void PDFProgramController::loadPlugins()
{
#if defined(Q_OS_WIN)
QDir directory(QApplication::applicationDirPath() + "/pdfplugins");
QStringList availablePlugins = directory.entryList(QStringList("*.dll"));
#elif defined(Q_OS_UNIX)
QDir directory(QApplication::applicationDirPath() + "/../pdfplugins");
QStringList availablePlugins = directory.entryList(QStringList("*.so"));
#else
static_assert(false, "Implement this for another OS!");
#endif
for (const QString& availablePlugin : availablePlugins)
{
QString pluginFileName = directory.absoluteFilePath(availablePlugin);
QPluginLoader loader(pluginFileName);
if (loader.load())
{
QJsonObject metaData = loader.metaData();
m_plugins.emplace_back(pdf::PDFPluginInfo::loadFromJson(&metaData));
m_plugins.back().pluginFile = availablePlugin;
m_plugins.back().pluginFileWithPath = pluginFileName;
if (!m_enabledPlugins.contains(m_plugins.back().name))
{
loader.unload();
continue;
}
pdf::PDFPlugin* plugin = qobject_cast<pdf::PDFPlugin*>(loader.instance());
if (plugin)
{
m_loadedPlugins.push_back(std::make_pair(m_plugins.back(), plugin));
}
}
}
auto comparator = [](const std::pair<pdf::PDFPluginInfo, pdf::PDFPlugin*>& l, const std::pair<pdf::PDFPluginInfo, pdf::PDFPlugin*>& r)
{
return l.first.name < r.first.name;
};
std::sort(m_loadedPlugins.begin(), m_loadedPlugins.end(), comparator);
for (const auto& plugin : m_loadedPlugins)
{
plugin.second->setDataExchangeInterface(this);
plugin.second->setWidget(m_pdfWidget);
plugin.second->setCMSManager(m_CMSManager);
std::vector<QAction*> actions = plugin.second->getActions();
if (!actions.empty())
{
QToolBar* toolBar = m_mainWindow->addToolBar(plugin.first.name);
toolBar->setObjectName(QString("Plugin_Toolbar_%1").arg(plugin.first.name));
m_mainWindowInterface->adjustToolbar(toolBar);
QMenu* menu = m_mainWindowInterface->addToolMenu(plugin.first.name);
for (QAction* action : actions)
{
if (!action)
{
menu->addSeparator();
toolBar->addSeparator();
continue;
}
m_actionManager->addAdditionalAction(action);
menu->addAction(action);
toolBar->addAction(action);
}
}
}
}
void PDFProgramController::writeSettings()
{
QSettings settings(QSettings::IniFormat, QSettings::UserScope, QCoreApplication::organizationName(), QCoreApplication::applicationName());
settings.setValue("geometry", m_mainWindow->saveGeometry());
settings.setValue("windowState", m_mainWindow->saveState());
m_settings->writeSettings(settings);
// Save action shortcuts
settings.beginGroup("Actions");
for (QAction* action : m_actionManager->getActions())
{
QString name = action->objectName();
if (!name.isEmpty())
{
QString accelerator = action->shortcut().toString(QKeySequence::PortableText);
settings.setValue(name, accelerator);
}
}
settings.endGroup();
// Save recent files
settings.beginGroup("RecentFiles");
settings.setValue("MaximumRecentFilesCount", m_recentFileManager->getRecentFilesLimit());
settings.setValue("RecentFileList", m_recentFileManager->getRecentFiles());
settings.endGroup();
// Save allowed plugins
settings.beginGroup("Plugins");
settings.setValue("EnabledPlugins", m_enabledPlugins);
settings.endGroup();
// Save trusted certificates
m_certificateStore.saveDefaultUserCertificates();
}
void PDFProgramController::onActionOptionsTriggered()
{
PDFViewerSettingsDialog::OtherSettings otherSettings;
otherSettings.maximumRecentFileCount = m_recentFileManager->getRecentFilesLimit();
PDFViewerSettingsDialog dialog(m_settings->getSettings(), m_settings->getColorManagementSystemSettings(),
otherSettings, m_certificateStore, m_actionManager->getActions(), m_CMSManager,
m_enabledPlugins, m_plugins, m_mainWindow);
if (dialog.exec() == QDialog::Accepted)
{
const bool pluginsChanged = m_enabledPlugins != dialog.getEnabledPlugins();
m_settings->setSettings(dialog.getSettings());
m_settings->setColorManagementSystemSettings(dialog.getCMSSettings());
m_CMSManager->setSettings(m_settings->getColorManagementSystemSettings());
if (m_recentFileManager)
{
m_recentFileManager->setRecentFilesLimit(dialog.getOtherSettings().maximumRecentFileCount);
}
if (m_textToSpeech)
{
m_textToSpeech->setSettings(m_settings);
}
if (m_formManager)
{
m_formManager->setAppearanceFlags(m_settings->getSettings().m_formAppearanceFlags);
}
m_certificateStore = dialog.getCertificateStore();
m_enabledPlugins = dialog.getEnabledPlugins();
updateMagnifierToolSettings();
updateUndoRedoSettings();
if (pluginsChanged)
{
QMessageBox::information(m_mainWindow, tr("Plugins"), tr("Plugin on/off state has been changed. Please restart application to apply settings."));
}
}
}
void PDFProgramController::onActionCertificateManagerTriggered()
{
pdf::PDFCertificateManagerDialog dialog(getMainWindow());
dialog.exec();
}
void PDFProgramController::onDrawSpaceChanged()
{
m_mainWindowInterface->updateUI(false);
}
void PDFProgramController::onPageLayoutChanged()
{
m_mainWindowInterface->updateUI(false);
updatePageLayoutActions();
}
void PDFProgramController::onActionOpenTriggered()
{
QString fileName = QFileDialog::getOpenFileName(m_mainWindow, tr("Select PDF document"), m_settings->getDirectory(), tr("PDF document (*.pdf)"));
if (!fileName.isEmpty())
{
openDocument(fileName);
}
}
void PDFProgramController::onActionCloseTriggered()
{
closeDocument();
}
void PDFProgramController::onActionDeveloperCreateInstaller()
{
QString directory = QFileDialog::getExistingDirectory(m_mainWindow, tr("Select Directory for Installer"));
if (directory.isEmpty())
{
return;
}
// Config.xml
{
QDir().mkpath(directory + "/config");
QFile configFile(directory + "/config/config.xml");
if (configFile.open(QFile::WriteOnly | QFile::Truncate))
{
QXmlStreamWriter configWriter(&configFile);
configWriter.setAutoFormatting(true);
configWriter.setAutoFormattingIndent(2);
configWriter.writeStartDocument();
configWriter.writeStartElement("Installer");
configWriter.writeTextElement("Name", tr("PDF4QT"));
configWriter.writeTextElement("Title", tr("PDF4QT Suite (library, viewer, editor, command line tool)"));
configWriter.writeTextElement("Version", pdf::PDF_LIBRARY_VERSION);
configWriter.writeTextElement("Publisher", tr("Jakub Melka"));
configWriter.writeTextElement("StartMenuDir", "PDF4QT");
configWriter.writeTextElement("TargetDir", "@ApplicationsDir@/PDF4QT");
configWriter.writeTextElement("CreateLocalRepository", "true");
configWriter.writeTextElement("InstallActionColumnVisible", "true");
configWriter.writeEndElement();
configWriter.writeEndDocument();
configFile.close();
}
}
// Installer project file
{
QString qtInstallDirectory = QT_INSTALL_DIRECTORY;
int indexofQtRoot = qtInstallDirectory.lastIndexOf("/Qt/");
QString binaryCreatorDirectory;
if (indexofQtRoot != -1)
{
indexofQtRoot += 4;
QString qtRootDirectory = qtInstallDirectory.left(indexofQtRoot);
QString qtInstallerFrameworkRoot = qtRootDirectory + "Tools/QtInstallerFramework/";
QDir qtInstallerFrameworkRootDir(qtInstallerFrameworkRoot);
QStringList entries = qtInstallerFrameworkRootDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
if (!entries.isEmpty())
{
binaryCreatorDirectory = QString("%1/%2/bin").arg(qtInstallerFrameworkRoot, entries.back());
binaryCreatorDirectory = QDir(binaryCreatorDirectory).absolutePath();
}
}
QFile configFile(directory + "/installer.pro");
if (configFile.open(QFile::WriteOnly | QFile::Truncate))
{
QTextStream stream(&configFile);
stream << "TEMPLATE = aux" << Qt::endl << Qt::endl;
stream << "INSTALLER_NAME = $$PWD/instpdf4qt" << Qt::endl;
stream << "INPUT = $$PWD/config/config.xml $$PWD/packages" << Qt::endl;
stream << "pdfforqtinstaller.input = INPUT" << Qt::endl;
stream << "pdfforqtinstaller.output = $$INSTALLER_NAME" << Qt::endl;
stream << QString("pdfforqtinstaller.commands = %1/binarycreator -c $$PWD/config/config.xml -p $$PWD/packages ${QMAKE_FILE_OUT}").arg(binaryCreatorDirectory) << Qt::endl;
stream << "pdfforqtinstaller.CONFIG += target_predeps no_link combine" << Qt::endl << Qt::endl;
stream << "QMAKE_EXTRA_COMPILERS += pdfforqtinstaller";
configFile.close();
}
}
// Packages
QDir().mkpath(directory + "/packages");
auto addComponentMeta = [&](QString componentName, QString displayName, QString description, QString version, QString internalName, bool forcedInstallation, bool defaultInstall, bool addDefaultLicense, QString dependencies = QString())
{
QString componentMetaDirectory = directory + QString("/packages/%1/meta").arg(componentName);
QDir().mkpath(componentMetaDirectory);
QString metaFileName = QString("%1/package.xml").arg(componentMetaDirectory);
QFile metaFile(metaFileName);
if (metaFile.open(QFile::WriteOnly | QFile::Truncate))
{
QXmlStreamWriter metaFileWriter(&metaFile);
metaFileWriter.setAutoFormatting(true);
metaFileWriter.setAutoFormattingIndent(2);
metaFileWriter.writeStartDocument();
metaFileWriter.writeStartElement("Package");
metaFileWriter.writeTextElement("DisplayName", displayName);
metaFileWriter.writeTextElement("Description", description);
metaFileWriter.writeTextElement("Version", version);
metaFileWriter.writeTextElement("ReleaseDate", QDateTime::currentDateTime().toString("yyyy-MM-dd"));
metaFileWriter.writeTextElement("Name", internalName);
metaFileWriter.writeTextElement("ExpandedByDefault", "true");
metaFileWriter.writeTextElement("ForcedInstallation", forcedInstallation ? "true" : "false");
metaFileWriter.writeTextElement("Default", defaultInstall ? "true" : "false");
if (!dependencies.isEmpty())
{
metaFileWriter.writeTextElement("Dependencies", dependencies);
}
if (addDefaultLicense)
{
QFile::copy(":/LICENSE.txt", QString("%1/LICENSE.txt").arg(componentMetaDirectory));
metaFileWriter.writeStartElement("Licenses");
metaFileWriter.writeStartElement("License");
metaFileWriter.writeAttribute("name", tr("License Agreement"));
metaFileWriter.writeAttribute("file", tr("LICENSE.txt"));
metaFileWriter.writeEndElement();
metaFileWriter.writeEndElement();
}
QString scriptFile = QString("%1/inst.qs").arg(componentMetaDirectory);
if (QFile::exists(scriptFile))
{
metaFileWriter.writeTextElement("Script", "inst.qs");
}
metaFileWriter.writeEndElement();
metaFileWriter.writeEndDocument();
metaFile.close();
}
};
auto addDirectoryContent = [&](QString componentName, QString applicationDirectory)
{
QString componentDataDirectory = directory + QString("/packages/%1/data/%2").arg(componentName, applicationDirectory);
QDir().mkpath(componentDataDirectory);
QString applicationDataDirectory = QString("%1/%2").arg(QApplication::applicationDirPath(), applicationDirectory);
QStringList fileNames = QDir(applicationDataDirectory).entryList(QDir::Files | QDir::NoDotAndDotDot);
for (QString fileName : fileNames)
{
QFile::copy(QString("%1/%2").arg(applicationDataDirectory, fileName), QString("%1/%2").arg(componentDataDirectory, fileName));
}
};
auto addFileContent = [&](QString componentName, QString filter)
{
QString componentDataDirectory = directory + QString("/packages/%1/data").arg(componentName);
QDir().mkpath(componentDataDirectory);
QString applicationDataDirectory = QApplication::applicationDirPath();
QStringList fileNames = QDir(applicationDataDirectory).entryList(QStringList() << filter, QDir::Files | QDir::NoDotAndDotDot);
for (QString fileName : fileNames)
{
QFile::copy(QString("%1/%2").arg(applicationDataDirectory, fileName), QString("%1/%2").arg(componentDataDirectory, fileName));
}
};
auto addStartMenuShortcut = [&](QString componentName, QString exeFileNameWithoutSuffix, QString description)
{
QString componentMetaDirectory = directory + QString("/packages/%1/meta").arg(componentName);
QDir().mkpath(componentMetaDirectory);
QString script =
"function Component() \n"
"{\n"
"\n"
"}\n"
"Component.prototype.createOperations = function() \n"
"{ \n"
" component.createOperations(); \n"
" if (systemInfo.productType === \"windows\") { \n"
" component.addOperation(\"CreateShortcut\", \"@TargetDir@/%1.exe\", \"@StartMenuDir@/%2.lnk\", \n"
" \"workingDirectory=@TargetDir@\", \"iconPath=@TargetDir@/%1.exe\", \n"
" \"iconId=0\", \"description=%2\"); \n"
" } \n"
"} ";
script = script.arg(exeFileNameWithoutSuffix, description);
QFile installScriptFile(QString("%1/inst.qs").arg(componentMetaDirectory));
if (installScriptFile.open(QFile::WriteOnly | QFile::Truncate))
{
QTextStream stream(&installScriptFile);
stream << script;
installScriptFile.close();
}
};
// CoreLib package
addStartMenuShortcut("pdf4qt_framework", "maintenancetool", tr("PDF4QT Maintenance Tool"));
addComponentMeta("pdf4qt_framework", tr("Framework (Core libraries)"), tr("Framework libraries and other data files required to run all other programs."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_framework", true, true, true);
addDirectoryContent("pdf4qt_framework", "iconengines");
addDirectoryContent("pdf4qt_framework", "imageformats");
addDirectoryContent("pdf4qt_framework", "platforms");
addDirectoryContent("pdf4qt_framework", "printsupport");
addDirectoryContent("pdf4qt_framework", "styles");
addDirectoryContent("pdf4qt_framework", "texttospeech");
addFileContent("pdf4qt_framework", "*.dll");
addStartMenuShortcut("pdf4qt_v_lite", "Pdf4QtViewerLite", tr("PDF4QT Viewer Lite"));
addComponentMeta("pdf4qt_v_lite", tr("Viewer (Lite)"), tr("Simple PDF viewer with basic functions."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_v_lite", false, true, false);
addFileContent("pdf4qt_v_lite", "Pdf4QtViewerLite.exe");
addStartMenuShortcut("pdf4qt_v_profi", "Pdf4QtViewerProfi", tr("PDF4QT Viewer Profi"));
addComponentMeta("pdf4qt_v_profi", tr("Viewer (Profi)"), tr("Advanced PDF viewer with many functions, such as annotation editing, form filling, signature verification, and many optional plugins."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_v_profi", false, true, false);
addFileContent("pdf4qt_v_profi", "Pdf4QtViewerProfi.exe");
addStartMenuShortcut("pdf4qt_dpo", "Pdf4QtDocPageOrganizer", tr("PDF4QT DocPage Organizer"));
addComponentMeta("pdf4qt_dpo", tr("DocPage Organizer"), tr("Document page organizer (split/merge documents, insert/remove/move/clone pages, insert blank pages and images to create a new document)."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_dpo", false, true, false);
addFileContent("pdf4qt_dpo", "Pdf4QtDocPageOrganizer.exe");
addStartMenuShortcut("pdf4qt_diff", "Pdf4QtDocDiff", tr("PDF4QT DocDiff"));
addComponentMeta("pdf4qt_diff", tr("DocDiff"), tr("Compare content of two documents."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_diff", false, true, false);
addFileContent("pdf4qt_diff", "Pdf4QtDocDiff.exe");
addStartMenuShortcut("pdf4qt_tool", "PdfTool", tr("PDF4QT Command Line Tool"));
addComponentMeta("pdf4qt_tool", tr("PdfTool"), tr("Command line tool for manipulation of PDF files with many functions."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_tool", false, false, false);
addFileContent("pdf4qt_tool", "PdfTool.exe");
addComponentMeta("pdf4qt_v_profi_plugins", tr("Viewer (Profi) | Plugins"), tr("Plugins for profi viewer providing additional functionality."), pdf::PDF_LIBRARY_VERSION, "pdf4qt_v_profi_plugins", false, false, false, "pdf4qt_v_profi");
for (const pdf::PDFPluginInfo& info : m_plugins)
{
QString pluginName = info.pluginFile;
pluginName.remove(".dll");
QString componentName = QString("pdf4qt_v_profi_plugins.%1").arg(pluginName);
addComponentMeta(componentName, info.name, info.description, info.version, componentName, false, false, false, "pdf4qt_v_profi");
QString componentDataDirectory = directory + QString("/packages/%1/data/pdfplugins").arg(componentName);
QDir().mkpath(componentDataDirectory);
QFile::copy(info.pluginFileWithPath, QString("%1/%2").arg(componentDataDirectory, info.pluginFile));
}
}
void PDFProgramController::onActionGetSource()
{
QDesktopServices::openUrl(QUrl("https://github.com/JakubMelka/PDF4QT"));
}
void PDFProgramController::onPageRenderingErrorsChanged(pdf::PDFInteger pageIndex, int errorsCount)
{
if (errorsCount > 0)
{
m_mainWindowInterface->setStatusBarMessage(tr("Rendering of page %1: %2 errors occured.").arg(pageIndex + 1).arg(errorsCount), 4000);
}
}
} // namespace pdfviewer