Differential D15580 Diff 67589 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 <KSelectAction>
24​
25​// local includes
26​#include "annotationwidgets.h"
27​#include "guiutils.h"
28​#include "pageview.h"
29​#include "pageviewannotator.h"
30​#include "toggleactionmenu.h"
31​
32​
33​static const QList<double> widthStandardValues = { 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5 };
34​static const QList<double> opacityStandardValues = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
35​
36​
37​class AnnotationActionHandlerPrivate
38​{
39​ public:
40​ explicit AnnotationActionHandlerPrivate( AnnotationActionHandler * qq ) :
41​ q( qq ),
42​ annotator( nullptr ),
43​ textTools( nullptr ),
44​ textQuickTools( nullptr ),
45​ agTools( nullptr ),
46​ aQuickTools( nullptr),
47​ aGeomShapes( nullptr ),
48​ aStamp( nullptr),
49​ aAddToQuickTools( nullptr ),
50​ aContinuousMode( nullptr ),
51​ aWidth( nullptr ),
52​ aColor( nullptr ),
53​ aInnerColor( nullptr ),
54​ aOpacity( nullptr ),
55​ aFont( nullptr ),
56​ aAdvancedSettings( nullptr ),
57​ aCustomStamp(nullptr),
58​ aCustomWidth( nullptr ),
59​ aCustomOpacity( nullptr ),
60​ currentColor( QColor() ),
61​ currentInnerColor( QColor() ),
62​ currentFont( QFont() ),
63​ currentWidth( -1 ),
64​ selectedTool( -1 ),
65​ textToolsEnabled( false )
66​ {}
67​
68​ QAction * selectActionItem( KSelectAction * aList, QAction * aCustomCurrent, double value,
69​ const QList<double> &defaultValues, const QIcon &icon, const QString &label );
70​ void selectStampActionItem( const QString &stampIconName );
71​ void parseTool( int toolID );
72​
73​ void updateConfigActions( const QString &annotType = "" );
74​ void populateQuickAnnotations();
75​
76​ QIcon widthIcon( double width );
77​ QIcon colorPickerIcon( const QString &iconName, const QColor &color );
78​ QIcon opacityIcon( double opacity );
79​ QIcon stampIcon( const QString &stampIconName );
80​
81​ void selectTool( int toolID );
82​ void slotStampToolSelected( QString stamp );
83​ void slotQuickToolSelected( int favToolID );
84​ void slotSelectColor();
85​ void slotSelectInnerColor();
86​ void slotSelectAnnotationFont();
87​
88​ AnnotationActionHandler * q;
89​
90​ PageViewAnnotator * annotator;
91​
92​ QList<QAction *> * textTools;
93​ QList<QAction *> * textQuickTools;
94​ QActionGroup * agTools;
95​
96​ KSelectAction * aQuickTools;
97​ ToggleActionMenu * aGeomShapes;
98​ ToggleActionMenu * aStamp;
99​ QAction * aAddToQuickTools;
100​ KToggleAction * aContinuousMode;
101​ KSelectAction * aWidth;
102​ QAction * aColor;
103​ QAction * aInnerColor;
104​ KSelectAction * aOpacity;
105​ QAction * aFont;
106​ QAction * aAdvancedSettings;
107​
108​ QAction * aCustomStamp;
109​ QAction * aCustomWidth;
110​ QAction * aCustomOpacity;
111​
112​ QColor currentColor;
113​ QColor currentInnerColor;
114​ QFont currentFont;
115​ int currentWidth;
116​
117​ int selectedTool;
118​ bool textToolsEnabled;
119​};
120​
121​QAction * AnnotationActionHandlerPrivate::selectActionItem( KSelectAction * aList, QAction * aCustomCurrent,
122​ double value, const QList<double> &defaultValues,
123​ const QIcon &icon, const QString &label )
124​{
125​ QAction * aCustom = nullptr;
126​ if( aCustomCurrent ) {
127​ aList->removeAction( aCustomCurrent );
128​ }
129​ int idx = defaultValues.indexOf( value );
130​ if( idx >= 0 ) {
131​ aList->setCurrentItem( idx );
132​ } else {
aacidUnsubmitted
Done

no i18n?

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

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

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