Differential D15580 Diff 69406 ui/annotationactionhandler.cpp

Changeset View

Standalone View

View Options

ui/annotationactionhandler.cpp

  • This file was added.
1​/**************************************************************************
2​* Copyright (C) 2019 by Simone Gaiarin <simgunz@gmail.com> *
3​* *
4​* This program is free software; you can redistribute it and/or modify *
5​* it under the terms of the GNU General Public License as published by *
6​* the Free Software Foundation; either version 2 of the License, or *
7​* (at your option) any later version. *
8​**************************************************************************/
9​
10​#include "annotationactionhandler.h"
11​
12​// qt includes
13​#include <QBitmap>
14​#include <QColorDialog>
15​#include <QFileInfo>
16​#include <QFontDialog>
17​#include <QPainter>
18​#include <QPen>
19​
20​// kde includes
21​#include <KActionCollection>
22​#include <KLocalizedString>
23​#include <KMessageBox>
24​#include <KSelectAction>
25​
26​// local includes
27​#include "annotationwidgets.h"
28​#include "guiutils.h"
29​#include "pageview.h"
30​#include "pageviewannotator.h"
31​#include "toggleactionmenu.h"
32​
33​
34​static const QList<double> widthStandardValues = { 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5 };
35​static const QList<double> opacityStandardValues = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
36​
37​
38​class AnnotationActionHandlerPrivate
39​{
40​ public:
41​ enum class AnnotationColor { Color, InnerColor };
42​ static const QList<QPair<QString, QColor>> defaultColors;
43​
44​ explicit AnnotationActionHandlerPrivate( AnnotationActionHandler * qq ) :
45​ q( qq ),
46​ annotator( nullptr ),
47​ textTools( nullptr ),
48​ textQuickTools( nullptr ),
49​ agTools( nullptr ),
50​ aQuickTools( nullptr),
51​ aGeomShapes( nullptr ),
52​ aStamp( nullptr),
53​ aAddToQuickTools( nullptr ),
54​ aContinuousMode( nullptr ),
55​ aWidth( nullptr ),
56​ aColor( nullptr ),
57​ aInnerColor( nullptr ),
58​ aOpacity( nullptr ),
59​ aFont( nullptr ),
60​ aAdvancedSettings( nullptr ),
61​ aCustomStamp(nullptr),
62​ aCustomWidth( nullptr ),
63​ aCustomOpacity( nullptr ),
64​ currentColor( QColor() ),
65​ currentInnerColor( QColor() ),
66​ currentFont( QFont() ),
67​ currentWidth( -1 ),
68​ selectedTool( -1 ),
69​ textToolsEnabled( false )
70​ {}
71​
72​ QAction * selectActionItem( KSelectAction * aList, QAction * aCustomCurrent, double value,
73​ const QList<double> &defaultValues, const QIcon &icon, const QString &label );
74​ void selectStampActionItem( const QString &stampIconName );
75​ void parseTool( int toolID );
76​
77​ void updateConfigActions( const QString &annotType = "" );
78​ void populateQuickAnnotations();
79​ KSelectAction * colorPickerAction( AnnotationColor colorType );
80​
81​ QIcon colorIcon( const QColor &color );
82​ QIcon widthIcon( double width );
83​ QIcon colorPickerIcon( const QString &iconName, const QColor &color );
84​ QIcon opacityIcon( double opacity );
85​ QIcon stampIcon( const QString &stampIconName );
86​
87​ void selectTool( int toolID );
88​ void slotStampToolSelected( QString stamp );
89​ void slotQuickToolSelected( int favToolID );
90​ void slotSetColor( const AnnotationColor &colorType, const QColor &color = QColor() );
91​ void slotSelectAnnotationFont();
92​
93​ AnnotationActionHandler * q;
94​
95​ PageViewAnnotator * annotator;
96​
97​ QList<QAction *> * textTools;
98​ QList<QAction *> * textQuickTools;
99​ QActionGroup * agTools;
100​
101​ KSelectAction * aQuickTools;
102​ ToggleActionMenu * aGeomShapes;
103​ ToggleActionMenu * aStamp;
104​ QAction * aAddToQuickTools;
105​ KToggleAction * aContinuousMode;
106​ KSelectAction * aWidth;
107​ KSelectAction * aColor;
108​ KSelectAction * aInnerColor;
109​ KSelectAction * aOpacity;
110​ QAction * aFont;
111​ QAction * aAdvancedSettings;
112​ QAction * aHideToolbar;
113​ QAction * aShowToolBar;
114​
115​ QAction * aCustomStamp;
116​ QAction * aCustomWidth;
117​ QAction * aCustomOpacity;
118​
119​ QColor currentColor;
120​ QColor currentInnerColor;
121​ QFont currentFont;
122​ int currentWidth;
123​
124​ int selectedTool;
125​ bool textToolsEnabled;
126​};
127​
128​const QList<QPair<QString, QColor>> AnnotationActionHandlerPrivate::defaultColors = {
129​ { i18n( "Red" ), Qt::red },
130​ { i18n( "Orange" ), "#ff5500" },
131​ { i18n( "Yellow" ), Qt::yellow },
132​ { i18n( "Green" ), Qt::green },
aacidUnsubmitted
Done

no i18n?

aacid: no i18n?
133​ { i18n( "Cyan" ), Qt::cyan },
134​ { i18n( "Blue" ), Qt::blue },
135​ { i18n( "Magenta" ), Qt::magenta },
136​ { i18n( "White" ), Qt::white },
137​ { i18n( "Gray" ), Qt::gray },
138​ { i18n( "Black" ), Qt::black }
139​
140​};
141​
142​QAction * AnnotationActionHandlerPrivate::selectActionItem( KSelectAction * aList, QAction * aCustomCurrent,
143​ double value, const QList<double> &defaultValues,
144​ const QIcon &icon, const QString &label )
145​{
146​ QAction * aCustom = nullptr;
147​ if ( aCustomCurrent ) {
148​ aList->removeAction( aCustomCurrent );
149​ }
150​ int idx = defaultValues.indexOf( value );
151​ if ( idx >= 0 ) {
152​ aList->setCurrentItem( idx );
153​ } else {
154​ aCustom = new KToggleAction( icon, label, q );
155​ int i = std::lower_bound(defaultValues.begin(), defaultValues.end(), value) - defaultValues.begin();
156​ QAction * before = i < defaultValues.size() ? aList->actions()[ i ] : nullptr;
157​ aList->insertAction( before, aCustom );
158​ aList->setCurrentAction( aCustom );
159​ }
160​ return aCustom;
161​}
162​
163​void AnnotationActionHandlerPrivate::selectStampActionItem( const QString &stampIconName )
164​{
165​ QPair<QString, QString> pair;
166​ bool defaultStamp = false;
167​ for ( const auto& pair : StampAnnotationWidget::defaultStamps ) {
168​ if ( stampIconName == pair.second) {
169​ defaultStamp = true;
170​ break;
171​ }
172​ }
173​ if ( aCustomStamp ) {
174​ aStamp->removeAction( aCustomStamp );
175​ agTools->removeAction( aCustomStamp );
176​ aCustomStamp = nullptr;
177​ }
178​ if ( !defaultStamp ) {
179​ QFileInfo info( stampIconName );
180​ QString stampActionName = info.fileName();
181​ aCustomStamp = new KToggleAction( stampIcon( stampIconName ), stampActionName, q);
182​ aStamp->addAction( aCustomStamp );
183​ aStamp->setDefaultAction( aCustomStamp );
184​ agTools->addAction( aCustomStamp );
185​ aCustomStamp->setChecked( true );
186​ QObject::connect( aCustomStamp, &QAction::triggered, [this, stampIconName] () {
187​ slotStampToolSelected( stampIconName );
188​ } );
189​ }
190​}
191​
192​void AnnotationActionHandlerPrivate::parseTool( int toolID )
193​{
194​ if ( toolID == -1 ) {
195​ updateConfigActions();
196​ return;
197​ }
198​
199​ QDomElement toolElement = annotator->builtinTool( toolID );
200​ const QString annotType = toolElement.attribute( QStringLiteral("type") );
201​ QDomElement engineElement = toolElement.firstChildElement( QStringLiteral("engine") );
202​ QDomElement annElement = engineElement.firstChildElement( QStringLiteral("annotation") );
203​
204​ QColor color, innerColor, textColor;
205​ if ( annElement.hasAttribute( QStringLiteral( "color" ) ) ) {
206​ color = QColor( annElement.attribute( QStringLiteral( "color" ) ) );
207​ }
208​ if ( annElement.hasAttribute( QStringLiteral( "innerColor" ) ) ) {
209​ innerColor = QColor( annElement.attribute( QStringLiteral( "innerColor" ) ) );
210​ }
211​ if ( annElement.hasAttribute( QStringLiteral( "textColor" ) ) ) {
212​ textColor = QColor( annElement.attribute( QStringLiteral( "textColor" ) ) );
213​ }
214​ if ( textColor.isValid() ) {
215​ currentColor = textColor;
216​ currentInnerColor = color;
217​ } else {
218​ currentColor = color;
219​ currentInnerColor = innerColor;
220​ }
221​
222​ if ( annElement.hasAttribute( QStringLiteral( "font" ) ) ) {
223​ currentFont.fromString( annElement.attribute( QStringLiteral( "font" ) ) );
224​ }
225​
226​ // if the width value is not a default one, insert a new action in the width list
227​ if ( annElement.hasAttribute( QStringLiteral( "width" ) ) ) {
228​ double width = annElement.attribute( QStringLiteral( "width" ) ).toDouble();
229​ aCustomWidth = selectActionItem( aWidth, aCustomWidth, width, widthStandardValues,
230​ widthIcon( width ), i18nc("@item:inlistbox", "Width %1", width ) );
231​ }
232​
233​ // if the opacity value is not a default one, insert a new action in the opacity list
234​ if ( annElement.hasAttribute( QStringLiteral( "opacity" ) ) ) {
235​ double opacity = 100 * annElement.attribute( QStringLiteral( "opacity" ) ).toDouble();
236​ aCustomOpacity = selectActionItem( aOpacity, aCustomOpacity, opacity, opacityStandardValues,
237​ opacityIcon( opacity ), i18nc("@item:inlistbox", "%1\%", opacity) );
238​ } else {
239​ aOpacity->setCurrentItem( opacityStandardValues.size() - 1 ); // 100 %
240​ }
241​
242​ // if the tool is a custom stamp, insert a new action in the stamp list
243​ if ( annotType == QStringLiteral( "stamp" ) ) {
244​ QString stampIconName = annElement.attribute( QStringLiteral("icon") );
245​ selectStampActionItem( stampIconName );
246​ }
247​
248​ updateConfigActions( annotType );
249​}
250​
251​void AnnotationActionHandlerPrivate::updateConfigActions( const QString &annotType )
252​{
253​ const bool annotationSelected = !annotType.isEmpty();
254​ const bool isTypewriter = annotType == QStringLiteral( "typewriter" );
255​ const bool isInlineNote = annotType == QStringLiteral( "note-inline" );
256​ const bool isText = isInlineNote || isTypewriter;
257​ const bool isShape = annotType == QStringLiteral( "rectangle" )
258​ || annotType == QStringLiteral( "ellipse" )
259​ || annotType == QStringLiteral( "polygon" );
260​ const bool isLine = annotType == QStringLiteral( "ink" )
261​ || annotType == QStringLiteral( "straight-line" );
262​ const bool isStamp = annotType == QStringLiteral( "stamp" );
263​
264​ if ( isTypewriter ) {
265​ aColor->setIcon( colorPickerIcon( QStringLiteral( "format-text-color" ), currentColor ) );
266​ } else {
267​ aColor->setIcon( colorPickerIcon( QStringLiteral( "format-stroke-color" ), currentColor ) );
268​ }
269​ aInnerColor->setIcon( colorPickerIcon( QStringLiteral( "format-fill-color" ), currentInnerColor ) );
270​
271​ aAddToQuickTools->setEnabled( annotationSelected );
272​ aWidth->setEnabled( isLine || isShape );
273​ aColor->setEnabled( annotationSelected && !isStamp );
274​ aInnerColor->setEnabled( isShape );
275​ aOpacity->setEnabled( annotationSelected && !isStamp );
276​ aFont->setEnabled( isText );
277​ aAdvancedSettings->setEnabled( annotationSelected );
278​
279​ // set tooltips
280​ if ( !annotationSelected ) {
281​ aWidth->setToolTip( i18nc( "@info:tooltip", "Annotation line width (No annotation selected)") );
282​ aColor->setToolTip( i18nc( "@info:tooltip", "Annotation color (No annotation selected)") );
283​ aInnerColor->setToolTip( i18nc( "@info:tooltip", "Annotation fill color (No annotation selected)") );
284​ aOpacity->setToolTip( i18nc( "@info:tooltip", "Annotation opacity (No annotation selected)") );
285​ aFont->setToolTip( i18nc( "@info:tooltip", "Annotation font (No annotation selected)") );
286​ aAddToQuickTools->setToolTip( i18nc( "@info:tooltip", "Add the current annotation to the quick annotations menu (No annotation selected)") );
287​ aAdvancedSettings->setToolTip( i18nc( "@info:tooltip", "Advanced settings for the current annotation tool (No annotation selected)") );
288​ return;
289​ }
290​
291​ if ( isLine || isShape ) {
292​ aWidth->setToolTip( i18nc( "@info:tooltip", "Annotation line width") );
293​ } else {
294​ aWidth->setToolTip( i18nc( "@info:tooltip", "Annotation line width (Current annotation has no line width)") );
295​ }
296​
297​ if ( isTypewriter ) {
298​ aColor->setToolTip( i18nc( "@info:tooltip", "Annotation text color") );
299​ } else if ( isShape ) {
300​ aColor->setToolTip( i18nc( "@info:tooltip", "Annotation border color") );
301​ } else {
302​ aColor->setToolTip( i18nc( "@info:tooltip", "Annotation color") );
303​ }
304​
305​ if ( isShape ) {
306​ aInnerColor->setToolTip( i18nc( "@info:tooltip", "Annotation fill color") );
307​ } else {
308​ aInnerColor->setToolTip( i18nc( "@info:tooltip", "Annotation fill color (Current annotation has no fill color)") );
309​ }
310​
311​ if ( isStamp ) {
312​ aOpacity->setToolTip( i18nc( "@info:tooltip", "Annotation opacity (Cannot change opacity of current annotation)") );
313​ } else {
314​ aOpacity->setToolTip( i18nc( "@info:tooltip", "Annotation opacity") );
315​ }
316​
317​ if ( isText ) {
318​ aFont->setToolTip( i18nc( "@info:tooltip", "Annotation font") );
319​ } else {
320​ aFont->setToolTip( i18nc( "@info:tooltip", "Annotation font (Current annotation has no font)") );
321​ }
322​
323​ aAddToQuickTools->setToolTip( i18nc( "@info:tooltip", "Add the current annotation to the quick annotations menu") );
324​ aAdvancedSettings->setToolTip( i18nc( "@info:tooltip", "Advanced settings for the current annotation tool") );
325​}
326​
327​void AnnotationActionHandlerPrivate::populateQuickAnnotations()
328​{
329​ const QList<int> numberKeys = { Qt::Key_1, Qt::Key_2, Qt::Key_3, Qt::Key_4, Qt::Key_5,
330​ Qt::Key_6, Qt::Key_7, Qt::Key_8, Qt::Key_9, Qt::Key_0
331​ };
332​
333​ textQuickTools->clear();
334​ aQuickTools->removeAllActions();
335​
336​ int favToolId = 1;
337​ QList<int>::const_iterator shortcutNumber = numberKeys.begin();
338​ QDomElement favToolElement = annotator->quickTool( favToolId );
339​ while ( !favToolElement.isNull() ) {
340​ QString itemText = favToolElement.attribute( "name" );
341​ if ( itemText.isEmpty() ) {
342​ itemText = PageViewAnnotator::defaultToolName( favToolElement );
343​ }
344​ QIcon toolIcon = QIcon( PageViewAnnotator::makeToolPixmap( favToolElement ) );
345​ QAction * annFav = new QAction( toolIcon, itemText, q);
346​ aQuickTools->addAction( annFav );
347​ if ( shortcutNumber != numberKeys.end() )
348​ annFav->setShortcut( QKeySequence(Qt::ALT + * (shortcutNumber++) ) );
349​ QObject::connect( annFav, &QAction::triggered, [this, favToolId] () {
350​ slotQuickToolSelected( favToolId );
351​ } );
352​
353​ QDomElement engineElement = favToolElement.firstChildElement( QStringLiteral("engine") );
354​ if ( engineElement.attribute( "type" ) == QStringLiteral("TextSelector") ) {
355​ textQuickTools->append( annFav );
356​ annFav->setEnabled( textToolsEnabled );
357​ }
358​
359​ favToolElement = annotator->quickTool( ++favToolId );
360​ }
361​ QAction * separator = new QAction();
362​ separator->setSeparator( true );
363​ aQuickTools->addAction( separator );
364​ // add action to open "Configure Annotation" settings dialog
365​ KActionCollection * ac = qobject_cast<PageView *>( q->parent()->parent() )->actionCollection();
366​ QAction * aConfigAnnotation = ac->action( QStringLiteral("options_configure_annotations") );
367​ if ( aConfigAnnotation ) {
368​ aQuickTools->addAction( aConfigAnnotation );
369​ }
370​}
371​
372​KSelectAction * AnnotationActionHandlerPrivate::colorPickerAction( AnnotationColor colorType )
373​{
374​ auto colorList = defaultColors;
375​ QString aText( i18nc( "@action:intoolbar Current annotation config option", "Color" ) );
376​ if ( colorType == AnnotationColor::InnerColor ) {
377​ aText = i18nc( "@action:intoolbar Current annotation config option", "Fill Color" );
378​ colorList.append( QPair<QString, Qt::GlobalColor>( QStringLiteral( "Transparent" ), Qt::transparent ) );
379​ }
380​ KSelectAction * aColorPicker = new KSelectAction( QIcon(), aText, q);
381​ aColorPicker->setToolBarMode( KSelectAction::MenuMode );
382​ for ( const auto& colorNameValue : colorList ) {
383​ QColor color( colorNameValue.second );
384​ QAction * aColor = new QAction( colorIcon( color ), i18nc("@item:inlistbox Color name", "%1", colorNameValue.first ), q);
385​ aColorPicker->addAction( aColor );
386​ QObject::connect( aColor, &QAction::triggered, [this, colorType, color] () {
387​ slotSetColor( colorType, color );
388​ } );
yurchorUnsubmitted
Done

May it be a complete ellipsis, for consistency (.. -> ...)?

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ }
390​ QAction * aCustomColor = new QAction( QIcon::fromTheme( QStringLiteral("color-picker") ),
391​ i18nc("@item:inlistbox", "Custom Color..."), q );
392​ aColorPicker->addAction( aCustomColor );
393​ QObject::connect( aCustomColor, &QAction::triggered, [this, colorType] () {
394​ slotSetColor( colorType );
395​ } );
396​ return aColorPicker;
397​}
398​
399​QIcon AnnotationActionHandlerPrivate::widthIcon( double width )
400​{
401​ QPixmap pm( 32, 32 );
402​ pm.fill( Qt::transparent );
403​ QPainter p( &pm );
404​ p.setRenderHint( QPainter::Antialiasing );
405​ p.setPen( QPen( Qt::black, 2 * width, Qt::SolidLine, Qt::RoundCap ) );
406​ p.drawLine( 0, pm.height() / 2, pm.width(), pm.height() / 2 );
407​ p.end();
408​ return QIcon( pm );
409​}
410​
411​QIcon AnnotationActionHandlerPrivate::colorPickerIcon( const QString &iconName, const QColor &color )
412​{
413​ QIcon icon = QIcon::fromTheme( iconName );
414​ if ( !color.isValid() ) {
415​ return icon;
416​ }
417​ QSize iconSize = QSize( 32, 32 );
418​ QPixmap pm = icon.pixmap( iconSize );
419​ QPainter p( &pm );
420​ p.fillRect( 0, iconSize.height() - 8, iconSize.width(), 8, color );
421​ p.end();
422​ return QIcon( pm );
423​}
424​
425​QIcon AnnotationActionHandlerPrivate::colorIcon( const QColor &color )
426​{
427​ QSize iconSize = QSize( 32, 32 );
428​ QPixmap pm( iconSize );
429​ QPainter p( &pm );
430​ if ( color == Qt::transparent ) {
431​ p.fillRect( 0, 0, iconSize.width(), iconSize.height(), Qt::white );
432​ p.setPen( QPen( Qt::red, 2 ) );
433​ p.drawLine( iconSize.width() - 1, 0, 0, iconSize.height() - 1 );
434​ } else {
435​ p.fillRect( 0, 0, iconSize.width(), iconSize.height(), color );
436​ }
437​ p.setPen( Qt::black );
438​ p.drawRect( 0, 0, iconSize.width() - 1, iconSize.height() - 1 );
439​ p.end();
440​ return QIcon( pm );
441​}
442​
443​QIcon AnnotationActionHandlerPrivate::opacityIcon( double opacity )
444​{
445​ QPixmap pm( 32, 32 );
446​ pm.fill( Qt::transparent );
447​ QPainter p( &pm );
448​ p.setRenderHint( QPainter::Antialiasing );
449​ p.setPen( Qt::NoPen );
450​ QColor color( Qt::black );
451​ color.setAlpha( opacity * 255 / 100 );
452​ p.setBrush( QBrush( color ) );
453​ p.drawRect( 4, 4, 24, 24 );
454​ p.end();
455​ return QIcon( pm );
456​}
457​
458​QIcon AnnotationActionHandlerPrivate::stampIcon( const QString &stampIconName )
459​{
460​ QPixmap stampPix = GuiUtils::loadStamp( stampIconName, 32 );
461​ if ( stampPix.width() == stampPix.height() )
462​ return QIcon( stampPix );
463​ else
464​ return QIcon::fromTheme( QStringLiteral("tag") );
465​}
466​
467​void AnnotationActionHandlerPrivate::selectTool( int toolID )
468​{
469​ selectedTool = toolID;
470​ annotator->selectTool( toolID );
471​ parseTool( toolID );
472​}
473​
474​void AnnotationActionHandlerPrivate::slotStampToolSelected( QString stamp )
475​{
476​ KMessageBox::information( nullptr,
477​ i18nc( "@info", "Stamps inserted in PDF documents are not visible in PDF readers other than Okular" ),
478​ i18nc( "@title:window", "Experimental feature" ),
479​ QStringLiteral( "stampAnnotationWarning" )
480​ );
481​ selectedTool = PageViewAnnotator::STAMP_TOOL_ID;
482​ annotator->selectStampTool( stamp ); // triggers a reparsing thus calling parseTool
483​}
484​
485​void AnnotationActionHandlerPrivate::slotQuickToolSelected( int favToolID )
486​{
487​ int toolID = annotator->setQuickTool( favToolID ); // always triggers an unuseful reparsing
488​ QAction * favToolAction = agTools->actions()[ toolID - 1 ];
489​ if ( !favToolAction->isChecked() ) {
490​ // action group workaround: activates the action slot calling selectTool
491​ // when new tool if different from the selected one
492​ favToolAction->setChecked( true );
493​ } else {
simgunzAuthorUnsubmitted
Done

This implementation is buggy. How to detect in which main window are we? (Even if we move aToggleAnnotator to part.rc I think we still need to figure out in which part are we, so should not give any benefit)

simgunz: This implementation is buggy. How to detect in which main window are we? (Even if we move…
494​ selectTool( toolID );
495​ }
496​ aShowToolBar->setChecked( true );
497​}
498​
499​void AnnotationActionHandlerPrivate::slotSetColor( const AnnotationColor &colorType, const QColor &color )
500​{
501​ QColor selectedColor( color );
502​ if ( !selectedColor.isValid() ) {
503​ selectedColor = QColorDialog::getColor( currentColor, nullptr,
504​ i18nc( "@title:window", "Select color" ) );
505​ if ( !selectedColor.isValid() ) {
506​ return;
507​ }
508​ }
509​ if ( colorType == AnnotationColor::Color ) {
510​ currentColor = selectedColor;
511​ annotator->setAnnotationColor( selectedColor );
512​ } else if ( colorType == AnnotationColor::InnerColor ) {
513​ currentInnerColor = selectedColor;
514​ annotator->setAnnotationInnerColor( selectedColor );
515​ }
516​}
517​
518​void AnnotationActionHandlerPrivate::slotSelectAnnotationFont()
519​{
520​ bool ok;
521​ QFont selectedFont = QFontDialog::getFont( &ok, currentFont );
522​ if ( ok ) {
523​ currentFont = selectedFont;
524​ annotator->setAnnotationFont( currentFont );
525​ }
526​}
527​
528​AnnotationActionHandler::AnnotationActionHandler( PageViewAnnotator * parent, KActionCollection * ac ) :
529​ QObject( parent ),
530​ d( new AnnotationActionHandlerPrivate( this ) )
531​{
532​ d->annotator = parent;
533​
534​ // Text markup actions
535​ KToggleAction * aHighlighter = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-highlight") ),
536​ i18nc("@action:intoolbar Annotation tool", "Highlighter"), this );
537​ KToggleAction * aUnderline = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-underline") ),
538​ i18nc("@action:intoolbar Annotation tool", "Underline"), this) ;
539​ KToggleAction * aSquiggle = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-underline-squiggle") ),
540​ i18nc("@action:intoolbar Annotation tool", "Squiggle"), this );
541​ KToggleAction * aStrikeout = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-strikethrough") ),
542​ i18nc("@action:intoolbar Annotation tool", "Strike Out"), this );
543​ // Notes actions
544​ KToggleAction * aTypewriter = new KToggleAction( QIcon::fromTheme( QStringLiteral("tool-text") ),
545​ i18nc("@action:intoolbar Annotation tool", "Typewriter"), this );
546​ KToggleAction * aInlineNote = new KToggleAction( QIcon::fromTheme( QStringLiteral("note") ),
547​ i18nc("@action:intoolbar Annotation tool", "Inline Note"), this );
548​ KToggleAction * aPopupNote = new KToggleAction( QIcon::fromTheme( QStringLiteral("edit-comment") ),
549​ i18nc("@action:intoolbar Annotation tool", "Popup Note"), this );
550​ KToggleAction * aFreehandLine = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-freehand") ),
551​ i18nc("@action:intoolbar Annotation tool", "Freehand Line"), this );
552​ // Geometrical shapes actions
553​ KToggleAction * aStraightLine = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-line") ),
554​ i18nc("@action:intoolbar Annotation tool", "Straight line"), this );
555​ KToggleAction * aArrow = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-arrow") ),
556​ i18nc("@action:intoolbar Annotation tool", "Arrow"), this );
557​ KToggleAction * aRectangle = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-rectangle") ),
558​ i18nc("@action:intoolbar Annotation tool", "Rectangle"), this );
559​ KToggleAction * aEllipse = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-ellipse") ),
560​ i18nc("@action:intoolbar Annotation tool", "Ellipse"), this );
561​ KToggleAction * aPolygon = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-polyline") ),
562​ i18nc("@action:intoolbar Annotation tool", "Polygon"), this );
563​ d->aGeomShapes = new ToggleActionMenu( QIcon(), QString(), this,
564​ QToolButton::MenuButtonPopup,
565​ ToggleActionMenu::ImplicitDefaultAction );
566​ d->aGeomShapes->setText( i18nc( "@action", "Geometrical shapes" ) );
567​ d->aGeomShapes->setEnabled( true ); // Need to explicitly set this once, or refreshActions() in part.cpp will disable this action
568​ d->aGeomShapes->addAction( aArrow );
569​ d->aGeomShapes->addAction( aStraightLine );
570​ d->aGeomShapes->addAction( aRectangle );
571​ d->aGeomShapes->addAction( aEllipse );
572​ d->aGeomShapes->addAction( aPolygon );
573​ d->aGeomShapes->setDefaultAction( aArrow );
574​
575​ // The order in which the actions are added is relevant to connect
576​ // them to the correct toolId defined in tools.xml
577​ d->agTools = new QActionGroup( this );
578​ d->agTools->addAction( aHighlighter );
579​ d->agTools->addAction( aUnderline );
580​ d->agTools->addAction( aSquiggle );
581​ d->agTools->addAction( aStrikeout );
582​ d->agTools->addAction( aTypewriter );
583​ d->agTools->addAction( aInlineNote );
584​ d->agTools->addAction( aPopupNote );
585​ d->agTools->addAction( aFreehandLine );
586​ d->agTools->addAction( aArrow );
587​ d->agTools->addAction( aStraightLine );
588​ d->agTools->addAction( aRectangle );
589​ d->agTools->addAction( aEllipse );
590​ d->agTools->addAction( aPolygon );
591​
592​ d->textQuickTools = new QList<QAction *>();
593​ d->textTools = new QList<QAction *>();
594​ d->textTools->append( aHighlighter );
595​ d->textTools->append( aUnderline );
596​ d->textTools->append( aSquiggle );
597​ d->textTools->append( aStrikeout );
598​
599​ int toolId = 1;
600​ for ( QAction * ann : d->agTools->actions() ) {
601​ // action group workaround: connecting to toggled instead of triggered
602​ connect( ann, &QAction::toggled, [this, toolId] ( bool checked ) {
603​ if ( checked )
604​ d->selectTool( toolId );
605​ } );
606​ toolId++;
607​ }
608​
609​ // Stamp action
610​ d->aStamp = new ToggleActionMenu( QIcon::fromTheme( QStringLiteral("tag") ),
611​ QString(),
612​ this,
613​ QToolButton::MenuButtonPopup,
614​ ToggleActionMenu::ImplicitDefaultAction );
615​ d->aStamp->setText( i18nc( "@action", "Stamp" ) );
616​
617​ QPair<QString, QString> stamp;
618​ for ( const auto& stamp : StampAnnotationWidget::defaultStamps ) {
619​
620​ KToggleAction * ann = new KToggleAction( d->stampIcon( stamp.second ), stamp.first, this);
621​ if ( !d->aStamp->defaultAction() )
622​ d->aStamp->setDefaultAction( ann );
623​ d->aStamp->addAction( ann );
624​ d->agTools->addAction( ann );
625​ // action group workaround: connecting to toggled instead of triggered
626​ // (because deselectAllAnnotationActions has to call triggered)
627​ connect( ann, &QAction::toggled, [this, stamp] ( bool checked ) {
628​ if ( checked )
629​ d->slotStampToolSelected( stamp.second );
630​ } );
631​ }
632​
633​ // Quick annotations action
634​ d->aQuickTools = new KSelectAction( QIcon::fromTheme( QStringLiteral("draw-freehand") ),
635​ i18nc("@action:intoolbar Show list of quick annotation tools", "Quick Annotations"), this );
636​ d->aQuickTools->setToolBarMode( KSelectAction::MenuMode );
637​ d->populateQuickAnnotations();
638​
639​ // Add to quick annotation action
640​ d->aAddToQuickTools = new QAction(QIcon::fromTheme( QStringLiteral("favorite") ),
641​ i18nc("@action:intoolbar Add current annotation tool to the quick annotations list", "Add to Quick Annotations"), this);
642​
643​ // Pin action
644​ d->aContinuousMode = new KToggleAction(QIcon::fromTheme( QStringLiteral("pin") ),
645​ i18nc("@action:intoolbar When checked keep the current annotation tool active after use", "Keep Active"), this);
646​ d->aContinuousMode->setToolTip( i18nc( "@info:tooltip", "Keep the annotation tool active after use") );
647​ d->aContinuousMode->setChecked( d->annotator->continuousMode() );
648​
649​ // Annotation settings actions
650​ d->aColor = d->colorPickerAction( AnnotationActionHandlerPrivate::AnnotationColor::Color );
651​ d->aInnerColor = d->colorPickerAction( AnnotationActionHandlerPrivate::AnnotationColor::InnerColor );
652​ d->aFont = new QAction( QIcon::fromTheme( QStringLiteral("font-face") ),
653​ i18nc("@action:intoolbar Current annotation config option", "Font"), this );
654​ d->aAdvancedSettings = new QAction( QIcon::fromTheme( QStringLiteral("settings-configure") ),
655​ i18nc("@action:intoolbar Current annotation advanced settings", "Annotation Settings"), this );
656​ d->aHideToolbar = new QAction( QIcon::fromTheme( QStringLiteral("dialog-close") ),
657​ i18nc("@action:intoolbar Hide the toolbar", "Hide"), this );
658​
659​ // Width list
660​ d->aWidth = new KSelectAction( QIcon::fromTheme( QStringLiteral("edit-line-width") ),
661​ i18nc("@action:intoolbar Current annotation config option", "Line width"), this );
662​ d->aWidth->setToolBarMode( KSelectAction::MenuMode );
663​ for ( int i = 0; i < widthStandardValues.size(); i++ ) {
664​ KToggleAction * ann = new KToggleAction( d->widthIcon( widthStandardValues[i] ), i18nc("@item:inlistbox", "Width %1", widthStandardValues[i]), this);
665​ d->aWidth->addAction( ann );
666​ connect( ann, &QAction::triggered, [this, i] () {
667​ d->annotator->setAnnotationWidth( widthStandardValues[i] );
668​ } );
669​ }
670​
671​ // Opacity list
672​ d->aOpacity = new KSelectAction( QIcon::fromTheme( QStringLiteral("edit-opacity") ),
673​ i18nc("@action:intoolbar Current annotation config option", "Opacity"), this );
674​ d->aOpacity->setToolBarMode( KSelectAction::MenuMode );
675​ for ( int i = 0; i < opacityStandardValues.size(); i++ ) {
676​ KToggleAction * ann = new KToggleAction( d->opacityIcon( opacityStandardValues[i] ), QString( "%1\%" ).arg( opacityStandardValues[i] ), this);
677​ d->aOpacity->addAction( ann );
678​ connect( ann, &QAction::triggered, [this, i] () {
679​ d->annotator->setAnnotationOpacity( opacityStandardValues[i] / 100 );
680​ } );
681​ }
682​
683​ connect( d->aAddToQuickTools, &QAction::triggered, d->annotator, &PageViewAnnotator::addToQuickAnnotations );
684​ connect( d->aContinuousMode, &QAction::toggled, d->annotator, &PageViewAnnotator::setContinuousMode );
685​ connect( d->aAdvancedSettings, &QAction::triggered, d->annotator, &PageViewAnnotator::slotAdvancedSettings );
686​ connect( d->aFont, &QAction::triggered, std::bind( &AnnotationActionHandlerPrivate::slotSelectAnnotationFont, d ) );
687​
688​ // action group workaround: allows unchecking the currently selected annotation action.
689​ // Other parts of code dependent to this workaround are marked with "action group workaround".
690​ connect( d->agTools, &QActionGroup::triggered, [this]( QAction * action ) {
691​ static QAction* lastAction = nullptr;
692​ if (action == lastAction) {
693​ lastAction = nullptr;
694​ d->agTools->checkedAction()->setChecked( false );
695​ d->selectTool( -1 );
696​ } else {
697​ lastAction = action;
698​ }
699​ } );
700​
701​ d->aShowToolBar = ac->action( "mouse_toggle_annotate" );
702​ connect( d->aHideToolbar, &QAction::triggered, [this] () {
703​ d->aShowToolBar->setChecked( false );
704​ } );
705​
706​ ac->addAction( QStringLiteral("annotation_highlighter"), aHighlighter );
707​ ac->addAction( QStringLiteral("annotation_underline"), aUnderline );
708​ ac->addAction( QStringLiteral("annotation_squiggle"), aSquiggle );
709​ ac->addAction( QStringLiteral("annotation_strike_out"), aStrikeout );
710​ ac->addAction( QStringLiteral("annotation_typewriter"), aTypewriter );
711​ ac->addAction( QStringLiteral("annotation_inline_note"), aInlineNote );
712​ ac->addAction( QStringLiteral("annotation_popup_note"), aPopupNote );
713​ ac->addAction( QStringLiteral("annotation_freehand_line"), aFreehandLine );
714​ ac->addAction( QStringLiteral("annotation_arrow"), aArrow );
715​ ac->addAction( QStringLiteral("annotation_straight_line"), aStraightLine );
716​ ac->addAction( QStringLiteral("annotation_rectangle"), aRectangle );
717​ ac->addAction( QStringLiteral("annotation_ellipse"), aEllipse );
718​ ac->addAction( QStringLiteral("annotation_polygon"), aPolygon );
719​ ac->addAction( QStringLiteral("annotation_geometrical_shape"), d->aGeomShapes );
720​ ac->addAction( QStringLiteral("annotation_stamp"), d->aStamp );
721​ ac->addAction( QStringLiteral("annotation_favorites"), d->aQuickTools );
722​ ac->addAction( QStringLiteral("annotation_bookmark"), d->aAddToQuickTools );
723​ ac->addAction(QStringLiteral("annotation_settings_pin"), d->aContinuousMode );
724​ ac->addAction( QStringLiteral("annotation_settings_width"), d->aWidth );
725​ ac->addAction(QStringLiteral("annotation_settings_color"), d->aColor );
726​ ac->addAction(QStringLiteral("annotation_settings_inner_color"), d->aInnerColor );
727​ ac->addAction( QStringLiteral("annotation_settings_opacity"), d->aOpacity );
728​ ac->addAction(QStringLiteral("annotation_settings_font"), d->aFont );
729​ ac->addAction(QStringLiteral("annotation_settings_advanced"), d->aAdvancedSettings );
730​ ac->addAction( QStringLiteral("hide_annotation_toolbar"), d->aHideToolbar );
731​
732​ ac->setDefaultShortcut( aHighlighter, Qt::Key_1 );
733​ ac->setDefaultShortcut( aUnderline, Qt::Key_2 );
734​ ac->setDefaultShortcut( aSquiggle, Qt::Key_3 );
735​ ac->setDefaultShortcut( aStrikeout, Qt::Key_4 );
736​ ac->setDefaultShortcut( aTypewriter, Qt::Key_5 );
737​ ac->setDefaultShortcut( aInlineNote, Qt::Key_6 );
738​ ac->setDefaultShortcut( aPopupNote, Qt::Key_7 );
739​ ac->setDefaultShortcut( aFreehandLine, Qt::Key_8 );
740​ ac->setDefaultShortcut( aArrow, Qt::Key_9 );
741​ ac->setDefaultShortcut( d->aAddToQuickTools, QKeySequence( Qt::CTRL + Qt::SHIFT + Qt::Key_B ) );
742​
743​ d->updateConfigActions();
744​}
745​
746​AnnotationActionHandler::~AnnotationActionHandler()
747​{
748​ // delete the private data storage structure
749​ delete d;
750​}
751​
752​void AnnotationActionHandler::reparseTools()
753​{
754​ d->parseTool( d->selectedTool );
755​ d->populateQuickAnnotations();
756​}
757​
758​void AnnotationActionHandler::setToolsEnabled( bool on )
759​{
760​ for ( QAction * ann : d->agTools->actions() ) {
761​ ann->setEnabled( on );
762​ }
763​ d->aQuickTools->setEnabled( on );
764​ d->aGeomShapes->setEnabled( on );
765​ d->aStamp->setEnabled( on );
766​ d->aContinuousMode->setEnabled( on );
767​}
768​
769​void AnnotationActionHandler::setTextToolsEnabled( bool on )
770​{
771​ d->textToolsEnabled = on;
772​ for ( QAction * ann : *d->textTools ) {
773​ ann->setEnabled( on );
774​ }
775​ for ( QAction * ann : *d->textQuickTools ) {
776​ ann->setEnabled( on );
777​ }
778​}
779​
780​void AnnotationActionHandler::deselectAllAnnotationActions()
781​{
782​ QAction * checkedAction = d->agTools->checkedAction();
783​ if ( checkedAction )
784​ checkedAction->trigger(); // action group workaround: using trigger instead of setChecked
785​}
786​
787​#include "moc_annotationactionhandler.cpp"