Differential D15580 Diff 68372 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 = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
35​
36​
37​class AnnotationActionHandlerPrivate
38​{
39​ public:
40​ enum class AnnotationColor { Color, InnerColor };
41​ static const QList<QPair<QString, QColor>> defaultColors;
42​
43​ explicit AnnotationActionHandlerPrivate( AnnotationActionHandler * qq ) :
44​ q( qq ),
45​ annotator( nullptr ),
46​ textTools( nullptr ),
47​ textQuickTools( nullptr ),
48​ agTools( nullptr ),
49​ aQuickTools( nullptr),
50​ aGeomShapes( nullptr ),
51​ aStamp( nullptr),
52​ aAddToQuickTools( nullptr ),
53​ aContinuousMode( nullptr ),
54​ aWidth( nullptr ),
55​ aColor( nullptr ),
56​ aInnerColor( nullptr ),
57​ aOpacity( nullptr ),
58​ aFont( nullptr ),
59​ aAdvancedSettings( nullptr ),
60​ aCustomStamp(nullptr),
61​ aCustomWidth( nullptr ),
62​ aCustomOpacity( nullptr ),
63​ currentColor( QColor() ),
64​ currentInnerColor( QColor() ),
65​ currentFont( QFont() ),
66​ currentWidth( -1 ),
67​ selectedTool( -1 ),
68​ textToolsEnabled( false )
69​ {}
70​
71​ QAction * selectActionItem( KSelectAction * aList, QAction * aCustomCurrent, double value,
72​ const QList<double> &defaultValues, const QIcon &icon, const QString &label );
73​ void selectStampActionItem( const QString &stampIconName );
74​ void parseTool( int toolID );
75​
76​ void updateConfigActions( const QString &annotType = "" );
77​ void populateQuickAnnotations();
78​ KSelectAction * colorPickerAction( AnnotationColor colorType );
79​
80​ QIcon colorIcon( const QColor &color );
81​ QIcon widthIcon( double width );
82​ QIcon colorPickerIcon( const QString &iconName, const QColor &color );
83​ QIcon opacityIcon( double opacity );
84​ QIcon stampIcon( const QString &stampIconName );
85​
86​ void selectTool( int toolID );
87​ void slotStampToolSelected( QString stamp );
88​ void slotQuickToolSelected( int favToolID );
89​ void slotSetColor( const AnnotationColor &colorType, const QColor &color = QColor() );
90​ void slotSelectAnnotationFont();
91​
92​ AnnotationActionHandler * q;
93​
94​ PageViewAnnotator * annotator;
95​
96​ QList<QAction *> * textTools;
97​ QList<QAction *> * textQuickTools;
98​ QActionGroup * agTools;
99​
100​ KSelectAction * aQuickTools;
101​ ToggleActionMenu * aGeomShapes;
102​ ToggleActionMenu * aStamp;
103​ QAction * aAddToQuickTools;
104​ KToggleAction * aContinuousMode;
105​ KSelectAction * aWidth;
106​ KSelectAction * aColor;
107​ KSelectAction * aInnerColor;
108​ KSelectAction * aOpacity;
109​ QAction * aFont;
110​ QAction * aAdvancedSettings;
111​
112​ QAction * aCustomStamp;
113​ QAction * aCustomWidth;
114​ QAction * aCustomOpacity;
115​
116​ QColor currentColor;
117​ QColor currentInnerColor;
118​ QFont currentFont;
119​ int currentWidth;
120​
121​ int selectedTool;
122​ bool textToolsEnabled;
123​};
124​
125​const QList<QPair<QString, QColor>> AnnotationActionHandlerPrivate::defaultColors = {
126​ { i18n( "Red" ), Qt::red },
127​ { i18n( "Orange" ), "#ff5500" },
128​ { i18n( "Yellow" ), Qt::yellow },
129​ { i18n( "Green" ), Qt::green },
130​ { i18n( "Cyan" ), Qt::cyan },
131​ { i18n( "Blue" ), Qt::blue },
132​ { i18n( "Magenta" ), Qt::magenta },
aacidUnsubmitted
Done

no i18n?

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

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

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