Differential D15580 Diff 68650 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 <kparts/mainwindow.h>
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​
113​ QAction * aCustomStamp;
114​ QAction * aCustomWidth;
115​ QAction * aCustomOpacity;
116​
117​ QColor currentColor;
118​ QColor currentInnerColor;
119​ QFont currentFont;
120​ int currentWidth;
121​
122​ int selectedTool;
123​ bool textToolsEnabled;
124​};
125​
126​const QList<QPair<QString, QColor>> AnnotationActionHandlerPrivate::defaultColors = {
127​ { i18n( "Red" ), Qt::red },
128​ { i18n( "Orange" ), "#ff5500" },
129​ { i18n( "Yellow" ), Qt::yellow },
130​ { i18n( "Green" ), Qt::green },
131​ { i18n( "Cyan" ), Qt::cyan },
132​ { i18n( "Blue" ), Qt::blue },
aacidUnsubmitted
Done

no i18n?

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

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

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ } );
390​ return aColorPicker;
391​}
392​
393​QIcon AnnotationActionHandlerPrivate::widthIcon( double width )
394​{
395​ QPixmap pm( 32, 32 );
396​ pm.fill( Qt::transparent );
397​ QPainter p( &pm );
398​ p.setRenderHint( QPainter::Antialiasing );
399​ p.setPen( QPen( Qt::black, 2 * width, Qt::SolidLine, Qt::RoundCap ) );
400​ p.drawLine( 0, pm.height()/2, pm.width(), pm.height()/2 );
401​ p.end();
402​ return QIcon( pm );
403​}
404​
405​QIcon AnnotationActionHandlerPrivate::colorPickerIcon( const QString &iconName, const QColor &color )
406​{
407​ QIcon icon = QIcon::fromTheme( iconName );
408​ if ( !color.isValid() ) {
409​ return icon;
410​ }
411​ QSize iconSize = QSize( 32, 32 );
412​ QPixmap pm = icon.pixmap( iconSize );
413​ QPainter p( &pm );
414​ p.fillRect( 0, iconSize.height() - 8, iconSize.width(), 8, color );
415​ p.end();
416​ return QIcon( pm );
417​}
418​
419​QIcon AnnotationActionHandlerPrivate::colorIcon( const QColor &color )
420​{
421​ QSize iconSize = QSize( 32, 32 );
422​ QPixmap pm( iconSize );
423​ QPainter p( &pm );
424​ if( color == Qt::transparent ) {
425​ p.fillRect( 0, 0, iconSize.width(), iconSize.height(), Qt::white );
426​ p.setPen( QPen( Qt::red, 2 ) );
427​ p.drawLine( iconSize.width() - 1, 0, 0, iconSize.height() - 1 );
428​ } else {
429​ p.fillRect( 0, 0, iconSize.width(), iconSize.height(), color );
430​ }
431​ p.setPen( Qt::black );
432​ p.drawRect( 0, 0, iconSize.width() - 1, iconSize.height() - 1 );
433​ p.end();
434​ return QIcon( pm );
435​}
436​
437​QIcon AnnotationActionHandlerPrivate::opacityIcon( double opacity )
438​{
439​ QPixmap pm( 32, 32 );
440​ pm.fill( Qt::transparent );
441​ QPainter p( &pm );
442​ p.setRenderHint( QPainter::Antialiasing );
443​ p.setPen( Qt::NoPen );
444​ QColor color( Qt::black );
445​ color.setAlpha( opacity*255/100 );
446​ p.setBrush( QBrush( color ) );
447​ p.drawRect( 4, 4, 24, 24 );
448​ p.end();
449​ return QIcon( pm );
450​}
451​
452​QIcon AnnotationActionHandlerPrivate::stampIcon( const QString &stampIconName )
453​{
454​ QPixmap stampPix = GuiUtils::loadStamp( stampIconName, 32 );
455​ if( stampPix.width() == stampPix.height() )
456​ return QIcon( stampPix );
457​ else
458​ return QIcon::fromTheme( QStringLiteral("tag") );
459​}
460​
461​void AnnotationActionHandlerPrivate::selectTool( int toolID )
462​{
463​ selectedTool = toolID;
464​ annotator->selectTool( toolID );
465​ parseTool( toolID );
466​}
467​
468​void AnnotationActionHandlerPrivate::slotStampToolSelected( QString stamp )
469​{
470​ selectedTool = PageViewAnnotator::STAMP_TOOL_ID;
471​ annotator->selectStampTool( stamp ); // triggers a reparsing thus calling parseTool
472​}
473​
474​void AnnotationActionHandlerPrivate::slotQuickToolSelected( int favToolID )
475​{
476​ int toolID = annotator->setQuickTool( favToolID ); // always triggers an unuseful reparsing
477​ QAction * favToolAction = agTools->actions()[ toolID - 1 ];
478​ if ( !favToolAction->isChecked() ) {
479​ // action group workaround: activates the action slot calling selectTool
480​ // when new tool if different from the selected one
481​ favToolAction->setChecked( true );
482​ } else {
483​ selectTool( toolID );
484​ }
485​ QAction * aToggleAnnotator = qobject_cast<KParts::MainWindow *>(KParts::MainWindow::memberList()[0])
486​ ->actionCollection()->action( "mouse_toggle_annotate" );
487​ if ( !aToggleAnnotator->isChecked() ) {
488​ aToggleAnnotator->activate( QAction::Trigger );
489​ }
490​}
491​
492​void AnnotationActionHandlerPrivate::slotSetColor( const AnnotationColor &colorType, const QColor &color )
493​{
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​ QColor selectedColor( color );
495​ if ( !selectedColor.isValid() ) {
496​ selectedColor = QColorDialog::getColor( currentColor, nullptr,
497​ i18nc( "@title:window", "Select color" ) );
498​ if ( !selectedColor.isValid() ) {
499​ return;
500​ }
501​ }
502​ if ( colorType == AnnotationColor::Color ) {
503​ currentColor = selectedColor;
504​ annotator->setAnnotationColor( selectedColor );
505​ } else if ( colorType == AnnotationColor::InnerColor ) {
506​ currentInnerColor = selectedColor;
507​ annotator->setAnnotationInnerColor( selectedColor );
508​ }
509​}
510​
511​void AnnotationActionHandlerPrivate::slotSelectAnnotationFont()
512​{
513​ bool ok;
514​ QFont selectedFont = QFontDialog::getFont( &ok, currentFont );
515​ if ( ok ) {
516​ currentFont = selectedFont;
517​ annotator->setAnnotationFont( currentFont );
518​ }
519​}
520​
521​AnnotationActionHandler::AnnotationActionHandler( PageViewAnnotator * parent, KActionCollection * ac ) :
522​ QObject( parent ),
523​ d( new AnnotationActionHandlerPrivate( this ) )
524​{
525​ d->annotator = parent;
526​
527​ // Text markup actions
528​ KToggleAction * aHighlighter = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-highlight") ),
529​ i18nc("@action:intoolbar Annotation tool", "Highlighter"), this );
530​ KToggleAction * aUnderline = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-underline") ),
531​ i18nc("@action:intoolbar Annotation tool", "Underline"), this) ;
532​ KToggleAction * aSquiggle = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-underline-squiggle") ),
533​ i18nc("@action:intoolbar Annotation tool", "Squiggle"), this );
534​ KToggleAction * aStrikeout = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-strikethrough") ),
535​ i18nc("@action:intoolbar Annotation tool", "Strike Out"), this );
536​ // Notes actions
537​ KToggleAction * aTypewriter = new KToggleAction( QIcon::fromTheme( QStringLiteral("tool-text") ),
538​ i18nc("@action:intoolbar Annotation tool", "Typewriter"), this );
539​ KToggleAction * aInlineNote = new KToggleAction( QIcon::fromTheme( QStringLiteral("note") ),
540​ i18nc("@action:intoolbar Annotation tool", "Inline Note"), this );
541​ KToggleAction * aPopupNote = new KToggleAction( QIcon::fromTheme( QStringLiteral("edit-comment") ),
542​ i18nc("@action:intoolbar Annotation tool", "Popup Note"), this );
543​ KToggleAction * aFreehandLine = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-freehand") ),
544​ i18nc("@action:intoolbar Annotation tool", "Freehand Line"), this );
545​ // Geometrical shapes actions
546​ KToggleAction * aStraightLine = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-line") ),
547​ i18nc("@action:intoolbar Annotation tool", "Straight line"), this );
548​ KToggleAction * aArrow = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-arrow") ),
549​ i18nc("@action:intoolbar Annotation tool", "Arrow"), this );
550​ KToggleAction * aRectangle = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-rectangle") ),
551​ i18nc("@action:intoolbar Annotation tool", "Rectangle"), this );
552​ KToggleAction * aEllipse = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-ellipse") ),
553​ i18nc("@action:intoolbar Annotation tool", "Ellipse"), this );
554​ KToggleAction * aPolygon = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-polyline") ),
555​ i18nc("@action:intoolbar Annotation tool", "Polygon"), this );
556​ d->aGeomShapes = new ToggleActionMenu( QIcon(),QString(), this,
557​ QToolButton::MenuButtonPopup,
558​ ToggleActionMenu::ImplicitDefaultAction );
559​ d->aGeomShapes->setText( i18nc( "@action", "Geometrical shapes" ) );
560​ d->aGeomShapes->setEnabled( true ); // Need to explicitly set this once, or refreshActions() in part.cpp will disable this action
561​ d->aGeomShapes->addAction( aArrow );
562​ d->aGeomShapes->addAction( aStraightLine );
563​ d->aGeomShapes->addAction( aRectangle );
564​ d->aGeomShapes->addAction( aEllipse );
565​ d->aGeomShapes->addAction( aPolygon );
566​ d->aGeomShapes->setDefaultAction( aArrow );
567​
568​ // The order in which the actions are added is relevant to connect
569​ // them to the correct toolId defined in tools.xml
570​ d->agTools = new QActionGroup( this );
571​ d->agTools->addAction( aHighlighter );
572​ d->agTools->addAction( aUnderline );
573​ d->agTools->addAction( aSquiggle );
574​ d->agTools->addAction( aStrikeout );
575​ d->agTools->addAction( aTypewriter );
576​ d->agTools->addAction( aInlineNote );
577​ d->agTools->addAction( aPopupNote );
578​ d->agTools->addAction( aFreehandLine );
579​ d->agTools->addAction( aArrow );
580​ d->agTools->addAction( aStraightLine );
581​ d->agTools->addAction( aRectangle );
582​ d->agTools->addAction( aEllipse );
583​ d->agTools->addAction( aPolygon );
584​
585​ d->textQuickTools = new QList<QAction *>();
586​ d->textTools = new QList<QAction *>();
587​ d->textTools->append( aHighlighter );
588​ d->textTools->append( aUnderline );
589​ d->textTools->append( aSquiggle );
590​ d->textTools->append( aStrikeout );
591​
592​ int toolId = 1;
593​ for( QAction * ann : d->agTools->actions() ) {
594​ // action group workaround: connecting to toggled instead of triggered
595​ connect( ann, &QAction::toggled, [this, toolId] ( bool checked ) {
596​ if( checked )
597​ d->selectTool( toolId );
598​ } );
599​ toolId++;
600​ }
601​
602​ // Stamp action
603​ d->aStamp = new ToggleActionMenu( QIcon::fromTheme( QStringLiteral("tag") ),
604​ QString(),
605​ this,
606​ QToolButton::MenuButtonPopup,
607​ ToggleActionMenu::ImplicitDefaultAction );
608​ d->aStamp->setText( i18nc( "@action", "Stamp" ) );
609​
610​ QPair<QString, QString> stamp;
611​ for( const auto& stamp : StampAnnotationWidget::defaultStamps ) {
612​
613​ KToggleAction * ann = new KToggleAction( d->stampIcon( stamp.second ), stamp.first, this);
614​ if( !d->aStamp->defaultAction() )
615​ d->aStamp->setDefaultAction( ann );
616​ d->aStamp->addAction( ann );
617​ d->agTools->addAction( ann );
618​ // action group workaround: connecting to toggled instead of triggered
619​ // (because deselectAllAnnotationActions has to call triggered)
620​ connect( ann, &QAction::toggled, [this, stamp] ( bool checked ) {
621​ if( checked )
622​ d->slotStampToolSelected( stamp.second );
623​ } );
624​ }
625​
626​ // Quick annotations action
627​ d->aQuickTools = new KSelectAction( QIcon::fromTheme( QStringLiteral("draw-freehand") ),
628​ i18nc("@action:intoolbar Show list of quick annotation tools", "Quick Annotations"), this );
629​ d->aQuickTools->setToolBarMode( KSelectAction::MenuMode );
630​ d->populateQuickAnnotations();
631​
632​ // Add to quick annotation action
633​ d->aAddToQuickTools = new QAction(QIcon::fromTheme( QStringLiteral("favorite") ),
634​ i18nc("@action:intoolbar Add current annotation tool to the quick annotations list", "Add to Quick Annotations"), this);
635​
636​ // Pin action
637​ d->aContinuousMode = new KToggleAction(QIcon::fromTheme( QStringLiteral("pin") ),
638​ i18nc("@action:intoolbar When checked keep the current annotation tool active after use", "Keep Active"), this);
639​ d->aContinuousMode->setToolTip( i18nc( "@info:tooltip", "Keep the annotation tool active after use") );
640​ d->aContinuousMode->setChecked( d->annotator->continuousMode() );
641​
642​ // Annotation settings actions
643​ d->aColor = d->colorPickerAction( AnnotationActionHandlerPrivate::AnnotationColor::Color );
644​ d->aInnerColor = d->colorPickerAction( AnnotationActionHandlerPrivate::AnnotationColor::InnerColor );
645​ d->aFont = new QAction( QIcon::fromTheme( QStringLiteral("font-face") ),
646​ i18nc("@action:intoolbar Current annotation config option", "Font"), this );
647​ d->aAdvancedSettings = new QAction( QIcon::fromTheme( QStringLiteral("settings-configure") ),
648​ i18nc("@action:intoolbar Current annotation advanced settings", "Annotation Settings"), this );
649​
650​ // Width list
651​ d->aWidth = new KSelectAction( QIcon::fromTheme( QStringLiteral("edit-line-width") ),
652​ i18nc("@action:intoolbar Current annotation config option", "Line width"), this );
653​ d->aWidth->setToolBarMode( KSelectAction::MenuMode );
654​ for( int i = 0; i < widthStandardValues.size(); i++ ) {
655​ KToggleAction * ann = new KToggleAction( d->widthIcon( widthStandardValues[i] ), i18nc("@item:inlistbox", "Width %1", widthStandardValues[i]), this);
656​ d->aWidth->addAction( ann );
657​ connect( ann, &QAction::triggered, [this, i] () { d->annotator->setAnnotationWidth( widthStandardValues[i] ); } );
658​ }
659​
660​ // Opacity list
661​ d->aOpacity = new KSelectAction( QIcon::fromTheme( QStringLiteral("edit-opacity") ),
662​ i18nc("@action:intoolbar Current annotation config option", "Opacity"), this );
663​ d->aOpacity->setToolBarMode( KSelectAction::MenuMode );
664​ for( int i = 0; i < opacityStandardValues.size(); i++ ) {
665​ KToggleAction * ann = new KToggleAction( d->opacityIcon( opacityStandardValues[i] ), QString( "%1\%" ).arg( opacityStandardValues[i] ), this);
666​ d->aOpacity->addAction( ann );
667​ connect( ann, &QAction::triggered, [this, i] () { d->annotator->setAnnotationOpacity( opacityStandardValues[i] / 100 ); } );
668​ }
669​
670​ connect( d->aAddToQuickTools, &QAction::triggered, d->annotator, &PageViewAnnotator::addToQuickAnnotations );
671​ connect( d->aContinuousMode, &QAction::toggled , d->annotator, &PageViewAnnotator::setContinuousMode );
672​ connect( d->aAdvancedSettings, &QAction::triggered, d->annotator, &PageViewAnnotator::slotAdvancedSettings );
673​ connect( d->aFont, &QAction::triggered, std::bind( &AnnotationActionHandlerPrivate::slotSelectAnnotationFont, d ) );
674​
675​ // action group workaround: allows unchecking the currently selected annotation action.
676​ // Other parts of code dependent to this workaround are marked with "action group workaround".
677​ connect( d->agTools, &QActionGroup::triggered, [this]( QAction* action ) {
678​ static QAction* lastAction = nullptr;
679​ if (action == lastAction) {
680​ lastAction = nullptr;
681​ d->agTools->checkedAction()->setChecked( false );
682​ d->selectTool( -1 );
683​ } else {
684​ lastAction = action;
685​ }
686​ } );
687​
688​ ac->addAction( QStringLiteral("annotation_highlighter"), aHighlighter );
689​ ac->addAction( QStringLiteral("annotation_underline"), aUnderline );
690​ ac->addAction( QStringLiteral("annotation_squiggle"), aSquiggle );
691​ ac->addAction( QStringLiteral("annotation_strike_out"), aStrikeout );
692​ ac->addAction( QStringLiteral("annotation_typewriter"), aTypewriter );
693​ ac->addAction( QStringLiteral("annotation_inline_note"), aInlineNote );
694​ ac->addAction( QStringLiteral("annotation_popup_note"), aPopupNote );
695​ ac->addAction( QStringLiteral("annotation_freehand_line"), aFreehandLine );
696​ ac->addAction( QStringLiteral("annotation_arrow"), aArrow );
697​ ac->addAction( QStringLiteral("annotation_straight_line"), aStraightLine );
698​ ac->addAction( QStringLiteral("annotation_rectangle"), aRectangle );
699​ ac->addAction( QStringLiteral("annotation_ellipse"), aEllipse );
700​ ac->addAction( QStringLiteral("annotation_polygon"), aPolygon );
701​ ac->addAction( QStringLiteral("annotation_geometrical_shape"), d->aGeomShapes );
702​ ac->addAction( QStringLiteral("annotation_stamp"), d->aStamp );
703​ ac->addAction( QStringLiteral("annotation_favorites"), d->aQuickTools );
704​ ac->addAction( QStringLiteral("annotation_bookmark"), d->aAddToQuickTools );
705​ ac->addAction(QStringLiteral("annotation_settings_pin"), d->aContinuousMode );
706​ ac->addAction( QStringLiteral("annotation_settings_width"), d->aWidth );
707​ ac->addAction(QStringLiteral("annotation_settings_color"), d->aColor );
708​ ac->addAction(QStringLiteral("annotation_settings_inner_color"), d->aInnerColor );
709​ ac->addAction( QStringLiteral("annotation_settings_opacity"), d->aOpacity );
710​ ac->addAction(QStringLiteral("annotation_settings_font"), d->aFont );
711​ ac->addAction(QStringLiteral("annotation_settings_advanced"), d->aAdvancedSettings );
712​
713​ ac->setDefaultShortcut( aHighlighter, Qt::Key_1 );
714​ ac->setDefaultShortcut( aUnderline, Qt::Key_2 );
715​ ac->setDefaultShortcut( aSquiggle, Qt::Key_3 );
716​ ac->setDefaultShortcut( aStrikeout, Qt::Key_4 );
717​ ac->setDefaultShortcut( aTypewriter, Qt::Key_5 );
718​ ac->setDefaultShortcut( aInlineNote, Qt::Key_6 );
719​ ac->setDefaultShortcut( aPopupNote, Qt::Key_7 );
720​ ac->setDefaultShortcut( aFreehandLine, Qt::Key_8 );
721​ ac->setDefaultShortcut( aArrow, Qt::Key_9 );
722​ ac->setDefaultShortcut( d->aAddToQuickTools, QKeySequence( Qt::CTRL + Qt::SHIFT + Qt::Key_B ) );
723​
724​ d->updateConfigActions();
725​}
726​
727​AnnotationActionHandler::~AnnotationActionHandler()
728​{
729​ // delete the private data storage structure
730​ delete d;
731​}
732​
733​void AnnotationActionHandler::reparseTools()
734​{
735​ d->parseTool( d->selectedTool );
736​ d->populateQuickAnnotations();
737​}
738​
739​void AnnotationActionHandler::setToolsEnabled( bool on )
740​{
741​ for( QAction * ann : d->agTools->actions() ) {
742​ ann->setEnabled( on );
743​ }
744​ d->aQuickTools->setEnabled( on );
745​ d->aGeomShapes->setEnabled( on );
746​ d->aStamp->setEnabled( on );
747​ d->aContinuousMode->setEnabled( on );
748​}
749​
750​void AnnotationActionHandler::setTextToolsEnabled( bool on )
751​{
752​ d->textToolsEnabled = on;
753​ for( QAction * ann : *d->textTools ) {
754​ ann->setEnabled( on );
755​ }
756​ for( QAction * ann : *d->textQuickTools ) {
757​ ann->setEnabled( on );
758​ }
759​}
760​
761​void AnnotationActionHandler::deselectAllAnnotationActions()
762​{
763​ QAction * checkedAction = d->agTools->checkedAction();
764​ if( checkedAction )
765​ checkedAction->trigger(); // action group workaround: using trigger instead of setChecked
766​}
767​
768​#include "moc_annotationactionhandler.cpp"