Differential D15580 Diff 69254 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 <KMessageBox>
25​#include <KSelectAction>
26​
27​// local includes
28​#include "annotationwidgets.h"
29​#include "guiutils.h"
30​#include "pageview.h"
31​#include "pageviewannotator.h"
32​#include "toggleactionmenu.h"
33​
34​
35​static const QList<double> widthStandardValues = { 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5 };
36​static const QList<double> opacityStandardValues = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
37​
38​
39​class AnnotationActionHandlerPrivate
40​{
41​ public:
42​ enum class AnnotationColor { Color, InnerColor };
43​ static const QList<QPair<QString, QColor>> defaultColors;
44​
45​ explicit AnnotationActionHandlerPrivate( AnnotationActionHandler * qq ) :
46​ q( qq ),
47​ annotator( nullptr ),
48​ textTools( nullptr ),
49​ textQuickTools( nullptr ),
50​ agTools( nullptr ),
51​ aQuickTools( nullptr),
52​ aGeomShapes( nullptr ),
53​ aStamp( nullptr),
54​ aAddToQuickTools( nullptr ),
55​ aContinuousMode( nullptr ),
56​ aWidth( nullptr ),
57​ aColor( nullptr ),
58​ aInnerColor( nullptr ),
59​ aOpacity( nullptr ),
60​ aFont( nullptr ),
61​ aAdvancedSettings( nullptr ),
62​ aCustomStamp(nullptr),
63​ aCustomWidth( nullptr ),
64​ aCustomOpacity( nullptr ),
65​ currentColor( QColor() ),
66​ currentInnerColor( QColor() ),
67​ currentFont( QFont() ),
68​ currentWidth( -1 ),
69​ selectedTool( -1 ),
70​ textToolsEnabled( false )
71​ {}
72​
73​ QAction * selectActionItem( KSelectAction * aList, QAction * aCustomCurrent, double value,
74​ const QList<double> &defaultValues, const QIcon &icon, const QString &label );
75​ void selectStampActionItem( const QString &stampIconName );
76​ void parseTool( int toolID );
77​
78​ void updateConfigActions( const QString &annotType = "" );
79​ void populateQuickAnnotations();
80​ KSelectAction * colorPickerAction( AnnotationColor colorType );
81​
82​ QIcon colorIcon( const QColor &color );
83​ QIcon widthIcon( double width );
84​ QIcon colorPickerIcon( const QString &iconName, const QColor &color );
85​ QIcon opacityIcon( double opacity );
86​ QIcon stampIcon( const QString &stampIconName );
87​
88​ void selectTool( int toolID );
89​ void slotStampToolSelected( QString stamp );
90​ void slotQuickToolSelected( int favToolID );
91​ void slotSetColor( const AnnotationColor &colorType, const QColor &color = QColor() );
92​ void slotSelectAnnotationFont();
93​
94​ AnnotationActionHandler * q;
95​
96​ PageViewAnnotator * annotator;
97​
98​ QList<QAction *> * textTools;
99​ QList<QAction *> * textQuickTools;
100​ QActionGroup * agTools;
101​
102​ KSelectAction * aQuickTools;
103​ ToggleActionMenu * aGeomShapes;
104​ ToggleActionMenu * aStamp;
105​ QAction * aAddToQuickTools;
106​ KToggleAction * aContinuousMode;
107​ KSelectAction * aWidth;
108​ KSelectAction * aColor;
109​ KSelectAction * aInnerColor;
110​ KSelectAction * aOpacity;
111​ QAction * aFont;
112​ QAction * aAdvancedSettings;
113​ QAction * aHideToolbar;
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​ QAction * aToggleAnnotator = qobject_cast<KParts::MainWindow *>(KParts::MainWindow::memberList()[0])
493​ ->actionCollection()->action( "mouse_toggle_annotate" );
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​ if ( !aToggleAnnotator->isChecked() ) {
495​ aToggleAnnotator->activate( QAction::Trigger );
496​ }
497​}
498​
499​void AnnotationActionHandlerPrivate::slotSetColor( const AnnotationColor &colorType, const QColor &color )
500​{
501​ QColor selectedColor( color );
502​ if ( !selectedColor.isValid() ) {
503​ selectedColor = QColorDialog::getColor( currentColor, nullptr,
504​ i18nc( "@title:window", "Select color" ) );
505​ if ( !selectedColor.isValid() ) {
506​ return;
507​ }
508​ }
509​ if ( colorType == AnnotationColor::Color ) {
510​ currentColor = selectedColor;
511​ annotator->setAnnotationColor( selectedColor );
512​ } else if ( colorType == AnnotationColor::InnerColor ) {
513​ currentInnerColor = selectedColor;
514​ annotator->setAnnotationInnerColor( selectedColor );
515​ }
516​}
517​
518​void AnnotationActionHandlerPrivate::slotSelectAnnotationFont()
519​{
520​ bool ok;
521​ QFont selectedFont = QFontDialog::getFont( &ok, currentFont );
522​ if ( ok ) {
523​ currentFont = selectedFont;
524​ annotator->setAnnotationFont( currentFont );
525​ }
526​}
527​
528​AnnotationActionHandler::AnnotationActionHandler( PageViewAnnotator * parent, KActionCollection * ac ) :
529​ QObject( parent ),
530​ d( new AnnotationActionHandlerPrivate( this ) )
531​{
532​ d->annotator = parent;
533​
534​ // Text markup actions
535​ KToggleAction * aHighlighter = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-highlight") ),
536​ i18nc("@action:intoolbar Annotation tool", "Highlighter"), this );
537​ KToggleAction * aUnderline = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-underline") ),
538​ i18nc("@action:intoolbar Annotation tool", "Underline"), this) ;
539​ KToggleAction * aSquiggle = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-underline-squiggle") ),
540​ i18nc("@action:intoolbar Annotation tool", "Squiggle"), this );
541​ KToggleAction * aStrikeout = new KToggleAction( QIcon::fromTheme( QStringLiteral("format-text-strikethrough") ),
542​ i18nc("@action:intoolbar Annotation tool", "Strike Out"), this );
543​ // Notes actions
544​ KToggleAction * aTypewriter = new KToggleAction( QIcon::fromTheme( QStringLiteral("tool-text") ),
545​ i18nc("@action:intoolbar Annotation tool", "Typewriter"), this );
546​ KToggleAction * aInlineNote = new KToggleAction( QIcon::fromTheme( QStringLiteral("note") ),
547​ i18nc("@action:intoolbar Annotation tool", "Inline Note"), this );
548​ KToggleAction * aPopupNote = new KToggleAction( QIcon::fromTheme( QStringLiteral("edit-comment") ),
549​ i18nc("@action:intoolbar Annotation tool", "Popup Note"), this );
550​ KToggleAction * aFreehandLine = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-freehand") ),
551​ i18nc("@action:intoolbar Annotation tool", "Freehand Line"), this );
552​ // Geometrical shapes actions
553​ KToggleAction * aStraightLine = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-line") ),
554​ i18nc("@action:intoolbar Annotation tool", "Straight line"), this );
555​ KToggleAction * aArrow = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-arrow") ),
556​ i18nc("@action:intoolbar Annotation tool", "Arrow"), this );
557​ KToggleAction * aRectangle = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-rectangle") ),
558​ i18nc("@action:intoolbar Annotation tool", "Rectangle"), this );
559​ KToggleAction * aEllipse = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-ellipse") ),
560​ i18nc("@action:intoolbar Annotation tool", "Ellipse"), this );
561​ KToggleAction * aPolygon = new KToggleAction( QIcon::fromTheme( QStringLiteral("draw-polyline") ),
562​ i18nc("@action:intoolbar Annotation tool", "Polygon"), this );
563​ d->aGeomShapes = new ToggleActionMenu( QIcon(),QString(), this,
564​ QToolButton::MenuButtonPopup,
565​ ToggleActionMenu::ImplicitDefaultAction );
566​ d->aGeomShapes->setText( i18nc( "@action", "Geometrical shapes" ) );
567​ d->aGeomShapes->setEnabled( true ); // Need to explicitly set this once, or refreshActions() in part.cpp will disable this action
568​ d->aGeomShapes->addAction( aArrow );
569​ d->aGeomShapes->addAction( aStraightLine );
570​ d->aGeomShapes->addAction( aRectangle );
571​ d->aGeomShapes->addAction( aEllipse );
572​ d->aGeomShapes->addAction( aPolygon );
573​ d->aGeomShapes->setDefaultAction( aArrow );
574​
575​ // The order in which the actions are added is relevant to connect
576​ // them to the correct toolId defined in tools.xml
577​ d->agTools = new QActionGroup( this );
578​ d->agTools->addAction( aHighlighter );
579​ d->agTools->addAction( aUnderline );
580​ d->agTools->addAction( aSquiggle );
581​ d->agTools->addAction( aStrikeout );
582​ d->agTools->addAction( aTypewriter );
583​ d->agTools->addAction( aInlineNote );
584​ d->agTools->addAction( aPopupNote );
585​ d->agTools->addAction( aFreehandLine );
586​ d->agTools->addAction( aArrow );
587​ d->agTools->addAction( aStraightLine );
588​ d->agTools->addAction( aRectangle );
589​ d->agTools->addAction( aEllipse );
590​ d->agTools->addAction( aPolygon );
591​
592​ d->textQuickTools = new QList<QAction *>();
593​ d->textTools = new QList<QAction *>();
594​ d->textTools->append( aHighlighter );
595​ d->textTools->append( aUnderline );
596​ d->textTools->append( aSquiggle );
597​ d->textTools->append( aStrikeout );
598​
599​ int toolId = 1;
600​ for( QAction * ann : d->agTools->actions() ) {
601​ // action group workaround: connecting to toggled instead of triggered
602​ connect( ann, &QAction::toggled, [this, toolId] ( bool checked ) {
603​ if( checked )
604​ d->selectTool( toolId );
605​ } );
606​ toolId++;
607​ }
608​
609​ // Stamp action
610​ d->aStamp = new ToggleActionMenu( QIcon::fromTheme( QStringLiteral("tag") ),
611​ QString(),
612​ this,
613​ QToolButton::MenuButtonPopup,
614​ ToggleActionMenu::ImplicitDefaultAction );
615​ d->aStamp->setText( i18nc( "@action", "Stamp" ) );
616​
617​ QPair<QString, QString> stamp;
618​ for( const auto& stamp : StampAnnotationWidget::defaultStamps ) {
619​
620​ KToggleAction * ann = new KToggleAction( d->stampIcon( stamp.second ), stamp.first, this);
621​ if( !d->aStamp->defaultAction() )
622​ d->aStamp->setDefaultAction( ann );
623​ d->aStamp->addAction( ann );
624​ d->agTools->addAction( ann );
625​ // action group workaround: connecting to toggled instead of triggered
626​ // (because deselectAllAnnotationActions has to call triggered)
627​ connect( ann, &QAction::toggled, [this, stamp] ( bool checked ) {
628​ if( checked )
629​ d->slotStampToolSelected( stamp.second );
630​ } );
631​ }
632​
633​ // Quick annotations action
634​ d->aQuickTools = new KSelectAction( QIcon::fromTheme( QStringLiteral("draw-freehand") ),
635​ i18nc("@action:intoolbar Show list of quick annotation tools", "Quick Annotations"), this );
636​ d->aQuickTools->setToolBarMode( KSelectAction::MenuMode );
637​ d->populateQuickAnnotations();
638​
639​ // Add to quick annotation action
640​ d->aAddToQuickTools = new QAction(QIcon::fromTheme( QStringLiteral("favorite") ),
641​ i18nc("@action:intoolbar Add current annotation tool to the quick annotations list", "Add to Quick Annotations"), this);
642​
643​ // Pin action
644​ d->aContinuousMode = new KToggleAction(QIcon::fromTheme( QStringLiteral("pin") ),
645​ i18nc("@action:intoolbar When checked keep the current annotation tool active after use", "Keep Active"), this);
646​ d->aContinuousMode->setToolTip( i18nc( "@info:tooltip", "Keep the annotation tool active after use") );
647​ d->aContinuousMode->setChecked( d->annotator->continuousMode() );
648​
649​ // Annotation settings actions
650​ d->aColor = d->colorPickerAction( AnnotationActionHandlerPrivate::AnnotationColor::Color );
651​ d->aInnerColor = d->colorPickerAction( AnnotationActionHandlerPrivate::AnnotationColor::InnerColor );
652​ d->aFont = new QAction( QIcon::fromTheme( QStringLiteral("font-face") ),
653​ i18nc("@action:intoolbar Current annotation config option", "Font"), this );
654​ d->aAdvancedSettings = new QAction( QIcon::fromTheme( QStringLiteral("settings-configure") ),
655​ i18nc("@action:intoolbar Current annotation advanced settings", "Annotation Settings"), this );
656​ d->aHideToolbar = new QAction( QIcon::fromTheme( QStringLiteral("dialog-close") ),
657​ i18nc("@action:intoolbar Hide the toolbar", "Hide"), this );
658​
659​ // Width list
660​ d->aWidth = new KSelectAction( QIcon::fromTheme( QStringLiteral("edit-line-width") ),
661​ i18nc("@action:intoolbar Current annotation config option", "Line width"), this );
662​ d->aWidth->setToolBarMode( KSelectAction::MenuMode );
663​ for( int i = 0; i < widthStandardValues.size(); i++ ) {
664​ KToggleAction * ann = new KToggleAction( d->widthIcon( widthStandardValues[i] ), i18nc("@item:inlistbox", "Width %1", widthStandardValues[i]), this);
665​ d->aWidth->addAction( ann );
666​ connect( ann, &QAction::triggered, [this, i] () { d->annotator->setAnnotationWidth( widthStandardValues[i] ); } );
667​ }
668​
669​ // Opacity list
670​ d->aOpacity = new KSelectAction( QIcon::fromTheme( QStringLiteral("edit-opacity") ),
671​ i18nc("@action:intoolbar Current annotation config option", "Opacity"), this );
672​ d->aOpacity->setToolBarMode( KSelectAction::MenuMode );
673​ for( int i = 0; i < opacityStandardValues.size(); i++ ) {
674​ KToggleAction * ann = new KToggleAction( d->opacityIcon( opacityStandardValues[i] ), QString( "%1\%" ).arg( opacityStandardValues[i] ), this);
675​ d->aOpacity->addAction( ann );
676​ connect( ann, &QAction::triggered, [this, i] () { d->annotator->setAnnotationOpacity( opacityStandardValues[i] / 100 ); } );
677​ }
678​
679​ connect( d->aAddToQuickTools, &QAction::triggered, d->annotator, &PageViewAnnotator::addToQuickAnnotations );
680​ connect( d->aContinuousMode, &QAction::toggled , d->annotator, &PageViewAnnotator::setContinuousMode );
681​ connect( d->aAdvancedSettings, &QAction::triggered, d->annotator, &PageViewAnnotator::slotAdvancedSettings );
682​ connect( d->aFont, &QAction::triggered, std::bind( &AnnotationActionHandlerPrivate::slotSelectAnnotationFont, d ) );
683​
684​ // action group workaround: allows unchecking the currently selected annotation action.
685​ // Other parts of code dependent to this workaround are marked with "action group workaround".
686​ connect( d->agTools, &QActionGroup::triggered, [this]( QAction* action ) {
687​ static QAction* lastAction = nullptr;
688​ if (action == lastAction) {
689​ lastAction = nullptr;
690​ d->agTools->checkedAction()->setChecked( false );
691​ d->selectTool( -1 );
692​ } else {
693​ lastAction = action;
694​ }
695​ } );
696​
697​ connect( d->aHideToolbar, &QAction::triggered, [] () {
698​ QAction * aToggleAnnotator = qobject_cast<KParts::MainWindow *>(KParts::MainWindow::memberList()[0])
699​ ->actionCollection()->action( "mouse_toggle_annotate" );
700​ if ( aToggleAnnotator->isChecked() ) {
701​ aToggleAnnotator->activate( QAction::Trigger );
702​ }
703​ } );
704​
705​ ac->addAction( QStringLiteral("annotation_highlighter"), aHighlighter );
706​ ac->addAction( QStringLiteral("annotation_underline"), aUnderline );
707​ ac->addAction( QStringLiteral("annotation_squiggle"), aSquiggle );
708​ ac->addAction( QStringLiteral("annotation_strike_out"), aStrikeout );
709​ ac->addAction( QStringLiteral("annotation_typewriter"), aTypewriter );
710​ ac->addAction( QStringLiteral("annotation_inline_note"), aInlineNote );
711​ ac->addAction( QStringLiteral("annotation_popup_note"), aPopupNote );
712​ ac->addAction( QStringLiteral("annotation_freehand_line"), aFreehandLine );
713​ ac->addAction( QStringLiteral("annotation_arrow"), aArrow );
714​ ac->addAction( QStringLiteral("annotation_straight_line"), aStraightLine );
715​ ac->addAction( QStringLiteral("annotation_rectangle"), aRectangle );
716​ ac->addAction( QStringLiteral("annotation_ellipse"), aEllipse );
717​ ac->addAction( QStringLiteral("annotation_polygon"), aPolygon );
718​ ac->addAction( QStringLiteral("annotation_geometrical_shape"), d->aGeomShapes );
719​ ac->addAction( QStringLiteral("annotation_stamp"), d->aStamp );
720​ ac->addAction( QStringLiteral("annotation_favorites"), d->aQuickTools );
721​ ac->addAction( QStringLiteral("annotation_bookmark"), d->aAddToQuickTools );
722​ ac->addAction(QStringLiteral("annotation_settings_pin"), d->aContinuousMode );
723​ ac->addAction( QStringLiteral("annotation_settings_width"), d->aWidth );
724​ ac->addAction(QStringLiteral("annotation_settings_color"), d->aColor );
725​ ac->addAction(QStringLiteral("annotation_settings_inner_color"), d->aInnerColor );
726​ ac->addAction( QStringLiteral("annotation_settings_opacity"), d->aOpacity );
727​ ac->addAction(QStringLiteral("annotation_settings_font"), d->aFont );
728​ ac->addAction(QStringLiteral("annotation_settings_advanced"), d->aAdvancedSettings );
729​ ac->addAction( QStringLiteral("hide_annotation_toolbar"), d->aHideToolbar );
730​
731​ ac->setDefaultShortcut( aHighlighter, Qt::Key_1 );
732​ ac->setDefaultShortcut( aUnderline, Qt::Key_2 );
733​ ac->setDefaultShortcut( aSquiggle, Qt::Key_3 );
734​ ac->setDefaultShortcut( aStrikeout, Qt::Key_4 );
735​ ac->setDefaultShortcut( aTypewriter, Qt::Key_5 );
736​ ac->setDefaultShortcut( aInlineNote, Qt::Key_6 );
737​ ac->setDefaultShortcut( aPopupNote, Qt::Key_7 );
738​ ac->setDefaultShortcut( aFreehandLine, Qt::Key_8 );
739​ ac->setDefaultShortcut( aArrow, Qt::Key_9 );
740​ ac->setDefaultShortcut( d->aAddToQuickTools, QKeySequence( Qt::CTRL + Qt::SHIFT + Qt::Key_B ) );
741​
742​ d->updateConfigActions();
743​}
744​
745​AnnotationActionHandler::~AnnotationActionHandler()
746​{
747​ // delete the private data storage structure
748​ delete d;
749​}
750​
751​void AnnotationActionHandler::reparseTools()
752​{
753​ d->parseTool( d->selectedTool );
754​ d->populateQuickAnnotations();
755​}
756​
757​void AnnotationActionHandler::setToolsEnabled( bool on )
758​{
759​ for( QAction * ann : d->agTools->actions() ) {
760​ ann->setEnabled( on );
761​ }
762​ d->aQuickTools->setEnabled( on );
763​ d->aGeomShapes->setEnabled( on );
764​ d->aStamp->setEnabled( on );
765​ d->aContinuousMode->setEnabled( on );
766​}
767​
768​void AnnotationActionHandler::setTextToolsEnabled( bool on )
769​{
770​ d->textToolsEnabled = on;
771​ for( QAction * ann : *d->textTools ) {
772​ ann->setEnabled( on );
773​ }
774​ for( QAction * ann : *d->textQuickTools ) {
775​ ann->setEnabled( on );
776​ }
777​}
778​
779​void AnnotationActionHandler::deselectAllAnnotationActions()
780​{
781​ QAction * checkedAction = d->agTools->checkedAction();
782​ if( checkedAction )
783​ checkedAction->trigger(); // action group workaround: using trigger instead of setChecked
784​}
785​
786​#include "moc_annotationactionhandler.cpp"