File indexing completed on 2024-04-28 15:51:43

 /*
     SPDX-FileCopyrightText: 2015 Laurent Montel <montel@kde.org>
     SPDX-FileCopyrightText: 2015 Albert Astals Cid <aacid@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "drawingtoolactions.h"
 
 #include "gui/debug_ui.h"
 #include "settings.h"
 
 #include <KActionCollection>
 #include <KLocalizedString>
 
 #include <QAction>
 #include <QIconEngine>
 #include <QPainter>
 
 class ColorAction : public QAction
 {
     Q_OBJECT
 
 public:
     explicit ColorAction(KActionCollection *parent)
         : QAction(parent)
     {
     }
 
     void setColor(const QColor &color)
     {
         setIcon(QIcon(new ColorActionIconEngine(color)));
     }
 
 protected:
     class ColorActionIconEngine : public QIconEngine
     {
     public:
         explicit ColorActionIconEngine(const QColor &color)
             : m_color(color)
         {
         }
 
         ColorActionIconEngine(const ColorActionIconEngine &) = delete;
         ColorActionIconEngine &operator=(const ColorActionIconEngine &) = delete;
 
         // No one needs clone(), but it’s pure virtual
         QIconEngine *clone() const override
         {
             return nullptr;
         }
 
         QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state) override
         {
             QPixmap pixmap(size);
             pixmap.fill(Qt::transparent);
             Q_ASSERT(pixmap.hasAlphaChannel());
 
             QPainter painter(&pixmap);
             paint(&painter, QRect(QPoint(0, 0), size), mode, state);
             return pixmap;
         }
 
         void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state) override
         {
             Q_UNUSED(mode)
 
             // Assume that rect is square and at position (0, 0)
             int squareSize = rect.height() * 0.8;
             int squareOffset = (rect.height() - squareSize) / 2;
 
             painter->fillRect(squareOffset, squareOffset, squareSize, squareSize, m_color);
 
             if (state == QIcon::On) {
                 QFont checkmarkFont = painter->font();
                 checkmarkFont.setPixelSize(squareSize * 0.9);
                 painter->setFont(checkmarkFont);
 
                 const int lightness = ((m_color.red() * 299) + (m_color.green() * 587) + (m_color.blue() * 114)) / 1000;
                 painter->setPen(lightness < 128 ? Qt::white : Qt::black);
 
                 painter->drawText(QRect(squareOffset, squareOffset, squareSize, squareSize), Qt::AlignCenter, QStringLiteral("\u2713"));
             }
         }
 
     protected:
         QColor m_color;
     };
 };
 
 DrawingToolActions::DrawingToolActions(KActionCollection *parent)
     : QObject(parent)
 {
     loadTools();
 }
 
 DrawingToolActions::~DrawingToolActions()
 {
 }
 
 QList<QAction *> DrawingToolActions::actions() const
 {
     return m_actions;
 }
 
 void DrawingToolActions::reparseConfig()
 {
     qDeleteAll(m_actions);
     m_actions.clear();
     loadTools();
 }
 
 void DrawingToolActions::actionTriggered()
 {
     QAction *action = qobject_cast<QAction *>(sender());
 
     if (action) {
         if (action->isChecked()) {
             for (QAction *btn : std::as_const(m_actions)) {
                 if (action != btn) {
                     btn->setChecked(false);
                 }
             }
 
             Q_EMIT changeEngine(action->property("__document").value<QDomElement>());
         } else {
             Q_EMIT changeEngine(QDomElement());
         }
     }
 }
 
 void DrawingToolActions::loadTools()
 {
     const QStringList drawingTools = Okular::Settings::drawingTools();
 
     QDomDocument main;
     QDomElement drawingDefinition = main.createElement(QStringLiteral("drawingTools"));
     for (const QString &drawingXml : drawingTools) {
         QDomDocument entryParser;
         if (entryParser.setContent(drawingXml)) {
             drawingDefinition.appendChild(main.importNode(entryParser.documentElement(), true));
         } else {
             qCWarning(OkularUiDebug) << "Skipping malformed quick selection XML in QuickSelectionTools setting";
         }
     }
 
     // Create the AnnotationToolItems from the XML dom tree
     QDomNode drawingDescription = drawingDefinition.firstChild();
     while (drawingDescription.isElement()) {
         const QDomElement toolElement = drawingDescription.toElement();
         if (toolElement.tagName() == QLatin1String("tool")) {
             QString tooltip;
             QString width;
             QString colorStr;
             QString opacity;
 
             const QString name = toolElement.attribute(QStringLiteral("name"));
             if (toolElement.attribute(QStringLiteral("default"), QStringLiteral("false")) == QLatin1String("true")) {
                 tooltip = i18n(name.toLatin1().constData());
             } else {
                 tooltip = name;
             }
 
             const QDomNodeList engineNodeList = toolElement.elementsByTagName(QStringLiteral("engine"));
             if (engineNodeList.size() > 0) {
                 const QDomElement engineEl = engineNodeList.item(0).toElement();
                 if (engineEl.hasAttribute(QStringLiteral("color"))) {
                     colorStr = engineEl.attribute(QStringLiteral("color"));
                 }
 
                 const QDomNodeList annotationList = engineEl.elementsByTagName(QStringLiteral("annotation"));
                 if (annotationList.size() > 0) {
                     const QDomElement annotationEl = annotationList.item(0).toElement();
                     if (annotationEl.hasAttribute(QStringLiteral("width"))) {
                         width = annotationEl.attribute(QStringLiteral("width"));
                         opacity = annotationEl.attribute(QStringLiteral("opacity"), QStringLiteral("1.0"));
                     }
                 }
             }
 
             QDomDocument engine(QStringLiteral("engine"));
             QDomElement root = engine.createElement(QStringLiteral("engine"));
             root.setAttribute(QStringLiteral("color"), colorStr);
             engine.appendChild(root);
             QDomElement annElem = engine.createElement(QStringLiteral("annotation"));
             root.appendChild(annElem);
             annElem.setAttribute(QStringLiteral("type"), QStringLiteral("Ink"));
             annElem.setAttribute(QStringLiteral("color"), colorStr);
             annElem.setAttribute(QStringLiteral("width"), width);
             annElem.setAttribute(QStringLiteral("opacity"), opacity);
 
             const QString text = i18n("Drawing Tool: %1", tooltip);
             createToolAction(text, tooltip, colorStr, root);
         }
 
         drawingDescription = drawingDescription.nextSibling();
     }
 
     // add erasure action
     {
         QDomDocument engine(QStringLiteral("engine"));
         QDomElement root = engine.createElement(QStringLiteral("engine"));
         root.setAttribute(QStringLiteral("color"), QStringLiteral("transparent"));
         root.setAttribute(QStringLiteral("compositionMode"), QStringLiteral("clear"));
         engine.appendChild(root);
         QDomElement annElem = engine.createElement(QStringLiteral("annotation"));
         root.appendChild(annElem);
         annElem.setAttribute(QStringLiteral("type"), QStringLiteral("Ink"));
         annElem.setAttribute(QStringLiteral("color"), QStringLiteral("transparent"));
         annElem.setAttribute(QStringLiteral("width"), 20);
 
         KActionCollection *ac = static_cast<KActionCollection *>(parent());
         QAction *action = new QAction(ac);
         action->setText(i18n("Eraser"));
         action->setToolTip(i18n("Eraser"));
         action->setCheckable(true);
         action->setIcon(QIcon::fromTheme(QStringLiteral("draw-eraser")));
         action->setProperty("__document", QVariant::fromValue<QDomElement>(root));
 
         m_actions.append(action);
 
         ac->addAction(QStringLiteral("presentation_drawing_eraser"), action);
 
         connect(action, &QAction::triggered, this, &DrawingToolActions::actionTriggered);
     }
 }
 
 void DrawingToolActions::createToolAction(const QString &text, const QString &toolName, const QString &colorName, const QDomElement &root)
 {
     KActionCollection *ac = static_cast<KActionCollection *>(parent());
     ColorAction *action = new ColorAction(ac);
     action->setText(text);
     action->setToolTip(toolName);
     action->setCheckable(true);
     action->setColor(QColor(colorName));
     action->setEnabled(false);
 
     action->setProperty("__document", QVariant::fromValue<QDomElement>(root));
 
     m_actions.append(action);
 
     ac->addAction(QStringLiteral("presentation_drawing_%1").arg(toolName), action);
 
     connect(action, &QAction::triggered, this, &DrawingToolActions::actionTriggered);
 }
 
 #include "drawingtoolactions.moc"