Differential D15580 Diff 69380 ui/annotationactionhandler.cpp

Changeset View

Standalone View

View Options

ui/annotationactionhandler.cpp

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

no i18n?

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

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

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