Differential D15580 Diff 68649 ui/annotationactionhandler.cpp

Changeset View

Standalone View

View Options

ui/annotationactionhandler.cpp

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

no i18n?

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

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

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

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

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