Differential D15580 Diff 62678 ui/annotationactionhandler.cpp

Changeset View

Standalone View

View Options

ui/annotationactionhandler.cpp

  • This file was added.
1​/**************************************************************************
2​* Copyright (C) 2019 by Simone Gaiarin <simgunz@gmail.com> *
3​* *
4​* This program is free software; you can redistribute it and/or modify *
5​* it under the terms of the GNU General Public License as published by *
6​* the Free Software Foundation; either version 2 of the License, or *
7​* (at your option) any later version. *
8​**************************************************************************/
9​
10​#include "annotationactionhandler.h"
11​
12​// qt includes
13​#include <QBitmap>
14​#include <QColorDialog>
15​#include <QFileInfo>
16​#include <QFontDialog>
17​#include <QPainter>
18​#include <QPen>
19​
20​// kde includes
21​#include <KActionCollection>
22​#include <KLocalizedString>
23​#include <KSelectAction>
24​
25​// local includes
26​#include "annotationwidgets.h"
27​#include "guiutils.h"
28​#include "pageviewannotator.h"
29​#include "toggleactionmenu.h"
30​
31​
32​static const QList<double> lineWidthValues = { 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5 };
33​static const QList<double> opacityValues = { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
34​
35​
36​class AnnotationActionHandlerPrivate
37​{
38​public:
39​ AnnotationActionHandlerPrivate( AnnotationActionHandler * qq )
40​ : q( qq ), m_textAnnotationTools( nullptr ), m_favoriteTextAnnotationTools( nullptr ),
41​ m_annStamp( nullptr), m_selectedTool( -1 ), m_currentColor( QColor("yellow") ),
42​ m_currentInnerColor( QColor("#00000000") ), m_currentFont( QFont() ),
43​ m_textToolsEnabled( false ), m_annotator( nullptr ),
44​ m_customStamp(nullptr), m_customWidth( nullptr ), m_customOpacity( nullptr )
45​ {
46​ }
47​
48​ void parseTool( int toolID );
49​
50​ QIcon colorizeIcon(QIcon &icon, const QColor &color);
51​ void setColorActionIcon( QColor color );
52​ void setInnerColorActionIcon( QColor color );
53​ void enableConfigActionsForAnnotation( QString annotType = "none" );
54​ void updateConfigActionsToolTips( QString annotType = "none" );
55​
56​ QIcon stampIcon( QString stampIconName );
57​ QIcon widthIcon( double width );
58​ QIcon opacityIcon( double opacity );
59​
60​ AnnotationActionHandler * q;
61​
62​ QList<QAction *> * m_textAnnotationTools;
63​ QList<QAction *> * m_favoriteTextAnnotationTools;
64​ QActionGroup * m_annotationToolsGroup;
65​
66​ ToggleActionMenu * m_annStamp;
67​ KSelectAction * m_favorites;
68​ QAction * m_bookmark;
69​ QAction * m_colorAction;
70​ QAction * m_innerColorAction;
71​ KSelectAction * m_opacityAction;
72​ QAction * m_fontAction;
73​ KSelectAction * m_widthAction;
74​ QAction * m_annAdvancedSettings;
75​ KToggleAction * m_continuousModeAction;
76​
77​ int m_selectedTool;
78​
79​ QColor m_currentColor;
80​ QColor m_currentInnerColor;
81​ QFont m_currentFont;
82​ int m_currentWidth;
83​
84​ bool m_textToolsEnabled;
85​
86​ PageViewAnnotator * m_annotator;
87​
88​ QAction * m_customStamp;
89​ QAction * m_customWidth;
90​ QAction * m_customOpacity;
91​};
92​
93​void AnnotationActionHandlerPrivate::parseTool( int toolID )
94​{
95​ if( toolID == -1 )
96​ {
97​ enableConfigActionsForAnnotation( "none" );
98​ updateConfigActionsToolTips( "none" );
99​ return;
100​ }
101​
102​ QDomElement toolElement = m_annotator->builtinTool( toolID );
103​ const QString annotType = toolElement.attribute( QStringLiteral("type") );
104​ QDomElement engineElement = toolElement.firstChildElement( QStringLiteral("engine") );
105​ QDomElement annElement = engineElement.firstChildElement( QStringLiteral("annotation") );
106​
107​ if( annElement.hasAttribute( QStringLiteral( "color" ) ) )
108​ {
109​ if (annotType == "note-inline" || annotType == "typewriter" )
110​ {
111​ m_currentInnerColor = QColor( annElement.attribute( QStringLiteral( "color" ) ) );
112​ setInnerColorActionIcon( m_currentInnerColor );
113​ }
114​ else
115​ {
116​ m_currentColor = QColor( annElement.attribute( QStringLiteral( "color" ) ) );
117​ setColorActionIcon( m_currentColor );
118​ }
119​ }
120​
121​ if( annElement.hasAttribute( QStringLiteral( "innerColor" ) ) )
122​ m_currentInnerColor = QColor( annElement.attribute( QStringLiteral( "innerColor" ) ) );
123​ else
124​ m_currentInnerColor = Qt::transparent;
125​ setInnerColorActionIcon( m_currentInnerColor );
126​
127​ if( annElement.hasAttribute( QStringLiteral( "textColor" ) ) )
128​ {
129​ m_currentColor = QColor( annElement.attribute( QStringLiteral( "textColor" ) ) );
130​ setColorActionIcon( m_currentColor );
131​ }
132​
aacidUnsubmitted
Done

no i18n?

aacid: no i18n?
133​ if( annElement.hasAttribute( QStringLiteral( "font" ) ) )
134​ m_currentFont.fromString( annElement.attribute( QStringLiteral( "font" ) ) );
135​
136​ if( annElement.hasAttribute( QStringLiteral( "width" ) ) )
137​ {
138​ double width = annElement.attribute( QStringLiteral( "width" ) ).toDouble();
139​ if( m_customWidth ) {
140​ m_widthAction->removeAction( m_customWidth );
141​ m_customWidth = nullptr;
142​ }
143​ int idx = lineWidthValues.indexOf( width );
144​ if( idx >= 0 ) {
145​ m_widthAction->setCurrentItem( idx );
146​ }
147​ else
148​ {
149​ m_customWidth = new KToggleAction( widthIcon( width ), i18nc("@item:inlistbox", "Width %1", width), q);
150​ int i = std::lower_bound(lineWidthValues.begin(), lineWidthValues.end(), width) - lineWidthValues.begin();
151​ QAction * before = i < lineWidthValues.size() ? m_widthAction->actions()[ i ] : nullptr;
152​ m_widthAction->insertAction( before, m_customWidth );
153​ m_widthAction->setCurrentAction( m_customWidth );
154​ }
155​ }
156​ if( annElement.hasAttribute( QStringLiteral( "opacity" ) ) )
157​ {
158​ double opacity = 100 * annElement.attribute( QStringLiteral( "opacity" ) ).toDouble();
159​ if( m_customOpacity ) {
160​ m_opacityAction->removeAction( m_customOpacity );
161​ m_customOpacity = nullptr;
162​ }
163​ int idx = opacityValues.indexOf( opacity );
164​ if( idx >= 0 ) {
165​ m_opacityAction->setCurrentItem( idx );
166​ }
167​ else
168​ {
169​ m_customOpacity = new KToggleAction( opacityIcon( opacity ), i18nc("@item:inlistbox", "%1\%", opacity), q);
170​ int i = std::lower_bound(opacityValues.begin(), opacityValues.end(), opacity) - opacityValues.begin();
171​ QAction * before = i < opacityValues.size() ? m_opacityAction->actions()[ i ] : nullptr;
172​ m_opacityAction->insertAction( before, m_customOpacity );
173​ m_opacityAction->setCurrentAction( m_customOpacity );
174​ }
175​ }
176​ else
177​ m_opacityAction->setCurrentItem( opacityValues.size() - 1 );
178​
179​ if( annotType == QStringLiteral("stamp") )
180​ {
181​ QString stampIconName = annElement.attribute( QStringLiteral("icon") );
182​ QPair<QString, QString> pair;
183​ bool defaultStamp = false;
184​ foreach( pair, StampAnnotationWidget::defaultStamps() )
185​ {
186​ if( stampIconName == pair.second)
187​ {
188​ defaultStamp = true;
189​ break;
190​ }
191​ }
192​ if( m_customStamp )
193​ {
194​ m_annStamp->removeAction( m_customStamp );
195​ m_annotationToolsGroup->removeAction( m_customStamp );
196​ m_customStamp = nullptr;
197​ }
198​ if( !defaultStamp )
199​ {
200​ QFileInfo info( stampIconName );
201​ QString stampActionName = info.fileName();
202​ m_customStamp = new KToggleAction( stampIcon( stampIconName ), stampActionName, q);
203​ m_annStamp->addAction( m_customStamp );
204​ m_annStamp->setDefaultAction( m_customStamp );
205​ m_annotationToolsGroup->addAction( m_customStamp );
206​ QObject::connect( m_customStamp, &QAction::triggered, [this, stampIconName] () { q->slotStampSelected( stampIconName ); } );
207​ m_customStamp->setChecked( true );
208​ }
209​ }
210​
211​ enableConfigActionsForAnnotation( annotType );
212​ updateConfigActionsToolTips( annotType );
213​}
214​
215​QIcon AnnotationActionHandlerPrivate::colorizeIcon(QIcon &icon, const QColor &color)
216​{
217​ //FIXME: Use GuiUtils::colorize if possible instead or write a decent version of this method
218​ QPixmap iconPixmap = icon.pixmap(32, 32);
219​ QBitmap mask = iconPixmap.createMaskFromColor(QColor(Qt::transparent), Qt::MaskInColor);
220​ iconPixmap.fill(color);
221​ iconPixmap.setMask(mask);
222​ return QIcon(iconPixmap);
223​}
224​
225​void AnnotationActionHandlerPrivate::setColorActionIcon( QColor color )
226​{
227​ // Cannot use the current icon of m_ColorAction to define the mask to avoid trubles
228​ // the alpha channel is zero
229​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
230​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
231​ m_colorAction->setIcon( colorizedColorPicker );
232​}
233​
234​void AnnotationActionHandlerPrivate::setInnerColorActionIcon( QColor color )
235​{
236​ // Cannot use the current icon of m_ColorAction to define the mask to avoid trubles
237​ // the alpha channel is zero
238​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
239​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
240​ m_innerColorAction->setIcon( colorizedColorPicker );
241​}
242​
243​void AnnotationActionHandlerPrivate::enableConfigActionsForAnnotation( QString annotType )
244​{
245​ if( annotType == QStringLiteral( "note-inline" ) || annotType == QStringLiteral( "typewriter" ) ) {
246​ m_fontAction->setEnabled( true );
247​ } else {
248​ m_fontAction->setEnabled( false );
249​ }
250​ if( annotType == QStringLiteral( "stamp" ) || annotType == QStringLiteral( "none" ) ) {
251​ setColorActionIcon( Qt::transparent);
252​ m_colorAction->setEnabled( false );
253​ m_opacityAction->setEnabled( false );
254​ } else {
255​ m_colorAction->setEnabled( true );
256​ m_opacityAction->setEnabled( true );
257​ }
258​ if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
259​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) ) {
260​ m_innerColorAction->setEnabled( true );
261​ } else {
262​ setInnerColorActionIcon( Qt::transparent);
263​ m_innerColorAction->setEnabled( false );
264​ }
265​ if( annotType == QStringLiteral( "ink" ) ||
266​ annotType == QStringLiteral( "straight-line" ) || annotType == QStringLiteral( "rectangle" )
267​ || annotType == QStringLiteral( "ellipse" ) || annotType == QStringLiteral( "polygon" ) )
268​ {
269​ m_widthAction->setEnabled( true );
270​ } else {
271​ m_widthAction->setEnabled( false );
272​ }
273​ if ( annotType == QStringLiteral( "none" ) ) {
274​ m_annAdvancedSettings->setEnabled( false );
275​ m_bookmark->setEnabled( false );
276​ } else {
277​ m_annAdvancedSettings->setEnabled( true );
278​ m_bookmark->setEnabled( true );
279​ }
280​
281​}
282​
283​void AnnotationActionHandlerPrivate::updateConfigActionsToolTips( QString annotType )
284​{
285​ if( annotType == QStringLiteral( "note-inline" ) )
286​ {
287​ m_colorAction->setToolTip( i18nc( "@info:tooltip", "Annotation text and border color") );
288​ }
289​ else if ( annotType == QStringLiteral( "typewriter" ) )
290​ {
291​ m_colorAction->setToolTip( i18nc( "@info:tooltip", "Annotation text color") );
292​ }
293​ else if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
294​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) )
295​ {
296​ m_colorAction->setToolTip( i18nc( "@info:tooltip", "Annotation border color") );
297​ }
298​ else if( annotType == QStringLiteral( "none" ) )
299​ {
300​ m_colorAction->setToolTip( i18nc( "@info:tooltip", "Annotation color (No annotation selected)") );
301​ }
302​ else
303​ {
304​ m_colorAction->setToolTip( i18nc( "@info:tooltip", "Annotation color") );
305​ }
306​
307​ if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
308​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) )
309​ {
310​ m_innerColorAction->setToolTip( i18nc( "@info:tooltip", "Annotation fill color") );
311​ }
312​ else if( annotType == QStringLiteral( "none" ) )
313​ {
314​ m_innerColorAction->setToolTip( i18nc( "@info:tooltip", "Annotation fill color (No annotation selected)") );
315​ }
316​ else
317​ {
318​ m_innerColorAction->setToolTip( i18nc( "@info:tooltip", "Annotation fill color (Current annotation has no fill color)") );
319​ }
320​
321​ if( annotType == QStringLiteral( "ink" ) ||
322​ annotType == QStringLiteral( "straight-line" ) || annotType == QStringLiteral( "rectangle" )
323​ || annotType == QStringLiteral( "ellipse" ) || annotType == QStringLiteral( "polygon" ) )
324​ {
325​ m_widthAction->setToolTip( i18nc( "@info:tooltip", "Annotation line width") );
326​ }
327​ else if( annotType == QStringLiteral( "none" ) )
328​ {
329​ m_widthAction->setToolTip( i18nc( "@info:tooltip", "Annotation line width (No annotation selected)") );
330​ }
331​ else
332​ {
333​ m_widthAction->setToolTip( i18nc( "@info:tooltip", "Annotation line width (Current annotation has no line width)") );
334​ }
335​
336​ if( annotType == QStringLiteral( "stamp" ) )
337​ {
338​ m_opacityAction->setToolTip( i18nc( "@info:tooltip", "Annotation opacity (Cannot change opacity of current annotation)") );
339​ }
340​ else if( annotType == QStringLiteral( "none" ) )
341​ {
342​ m_opacityAction->setToolTip( i18nc( "@info:tooltip", "Annotation opacity (No annotation selected)") );
343​ }
344​ else
345​ {
346​ m_opacityAction->setToolTip( i18nc( "@info:tooltip", "Annotation opacity") );
347​ }
348​
349​ if( annotType == QStringLiteral( "note-inline" ) || annotType == QStringLiteral( "typewriter" ) )
350​ {
351​ m_fontAction->setToolTip( i18nc( "@info:tooltip", "Annotation font") );
352​ }
353​ else if( annotType == QStringLiteral( "none" ) )
354​ {
355​ m_fontAction->setToolTip( i18nc( "@info:tooltip", "Annotation font (No annotation selected)") );
356​ }
357​ else
358​ {
359​ m_fontAction->setToolTip( i18nc( "@info:tooltip", "Annotation font (Current annotation has no font)") );
360​ }
361​
362​ if( annotType == QStringLiteral( "none" ) )
363​ {
364​ m_bookmark->setToolTip( i18nc( "@info:tooltip", "Add the current annotation to the favorites (No annotation selected)") );
365​ m_annAdvancedSettings->setToolTip( i18nc( "@info:tooltip", "Advanced settings for the current annotation tool (No annotation selected)") );
366​ }
367​ else
368​ {
369​ m_bookmark->setToolTip( i18nc( "@info:tooltip", "Add the current annotation to the favorites") );
370​ m_annAdvancedSettings->setToolTip( i18nc( "@info:tooltip", "Advanced settings for the current annotation tool") );
371​ }
372​}
373​
374​QIcon AnnotationActionHandlerPrivate::stampIcon( QString stampIconName )
375​{
376​ QPixmap stampPix = GuiUtils::loadStamp( stampIconName, 64 );
377​ if( stampPix.width() == stampPix.height() )
378​ return QIcon( stampPix );
379​ else
380​ return QIcon::fromTheme( QStringLiteral("tag") );
381​}
382​
383​QIcon AnnotationActionHandlerPrivate::widthIcon( double width )
384​{
385​ QPixmap pm(16, 16); //TODO: Is fixed size ok here?
386​ pm.fill( Qt::transparent );
387​ QPainter p(&pm);
388​ p.setRenderHint(QPainter::Antialiasing);
yurchorUnsubmitted
Done

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

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ p.setPen(QPen(Qt::black, 2 * width, Qt::SolidLine, Qt::RoundCap));
390​ p.drawLine(0, pm.height()/2, pm.width(), pm.height()/2);
391​ p.end();
392​
393​ return QIcon( pm );
394​}
395​
396​QIcon AnnotationActionHandlerPrivate::opacityIcon( double opacity )
397​{
398​ QPixmap pm( 32, 32 ); //TODO: Is fixed size ok here?
399​ pm.fill( Qt::transparent );
400​ QPainter p( &pm );
401​ p.setRenderHint( QPainter::Antialiasing );
402​ p.setPen( Qt::NoPen );
403​ QColor color( Qt::black );
404​ color.setAlpha( opacity*255/100 );
405​ p.setBrush( QBrush( color ) );
406​ p.drawRect( 4, 4, 24, 24 );
407​ p.end();
408​
409​ return QIcon( pm );
410​}
411​
412​AnnotationActionHandler::AnnotationActionHandler( PageViewAnnotator * parent, KActionCollection * ac )
413​ : QObject( parent ), d( new AnnotationActionHandlerPrivate( this ) )
414​{
415​ d->m_annotator = parent;
416​
417​ // Text markup
418​ KToggleAction * annHighlighter = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-eraser") ),
419​ i18nc("@action:intoolbar Annotation tool", "Highlighter"), this);
420​ ac->addAction(QStringLiteral("annotation_highlighter"), annHighlighter );
421​ ac->setDefaultShortcut( annHighlighter, Qt::Key_1 );
422​
423​ KToggleAction * annUnderline = new KToggleAction(QIcon::fromTheme( QStringLiteral("format-text-underline") ),
424​ i18nc("@action:intoolbar Annotation tool", "Underline"), this);
425​ ac->addAction(QStringLiteral("annotation_underline"), annUnderline );
426​ ac->setDefaultShortcut( annUnderline, Qt::Key_2 );
427​
428​ KToggleAction * annSquiggle = new KToggleAction(QIcon::fromTheme( QStringLiteral("format-text-underline") ),
429​ i18nc("@action:intoolbar Annotation tool", "Squiggle"), this);
430​ ac->addAction(QStringLiteral("annotation_squiggle"), annSquiggle );
431​ ac->setDefaultShortcut( annSquiggle, Qt::Key_3 );
432​
433​ KToggleAction * annStrikeout= new KToggleAction(QIcon::fromTheme( QStringLiteral("format-text-strikethrough") ),
434​ i18nc("@action:intoolbar Annotation tool", "Strike Out"), this);
435​ ac->addAction(QStringLiteral("annotation_strike_out"), annStrikeout );
436​ ac->setDefaultShortcut( annStrikeout, Qt::Key_4 );
437​
438​ // Notes
439​ KToggleAction * annTypewriter = new KToggleAction(QIcon::fromTheme( QStringLiteral("text-convert-to-regular") ),
440​ i18nc("@action:intoolbar Annotation tool", "Typewriter"), this);
441​ ac->addAction(QStringLiteral("annotation_typewriter"), annTypewriter );
442​ ac->setDefaultShortcut( annTypewriter, Qt::Key_5 );
443​
444​ KToggleAction * annInlineNote = new KToggleAction(QIcon::fromTheme( QStringLiteral("note") ),
445​ i18nc("@action:intoolbar Annotation tool", "Inline Note"), this);
446​ ac->addAction(QStringLiteral("annotation_inline_note"), annInlineNote );
447​ ac->setDefaultShortcut( annInlineNote, Qt::Key_6 );
448​
449​ KToggleAction * annPopupNote = new KToggleAction(QIcon::fromTheme( QStringLiteral("edit-comment") ),
450​ i18nc("@action:intoolbar Annotation tool", "Popup Note"), this);
451​ ac->addAction(QStringLiteral("annotation_popup_note"), annPopupNote );
452​ ac->setDefaultShortcut( annPopupNote, Qt::Key_7 );
453​
454​ KToggleAction * annFreehandLine = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-freehand") ),
455​ i18nc("@action:intoolbar Annotation tool", "Freehand Line"), this);
456​ ac->addAction(QStringLiteral("annotation_freehand_line"), annFreehandLine );
457​ ac->setDefaultShortcut( annFreehandLine, Qt::Key_8 );
458​
459​ // Geometrical shapes
460​ KToggleAction * annStraightLine = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-line") ),
461​ i18nc("@action:intoolbar Annotation tool", "Straight line"), this);
462​ KToggleAction * annArrow = new KToggleAction(QIcon::fromTheme( QStringLiteral("circular-arrow-shape") ),
463​ i18nc("@action:intoolbar Annotation tool", "Arrow"), this);
464​ KToggleAction * annRectangle = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-rectangle") ),
465​ i18nc("@action:intoolbar Annotation tool", "Rectangle"), this);
466​ KToggleAction * annEllipse = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-ellipse") ),
467​ i18nc("@action:intoolbar Annotation tool", "Ellipse"), this);
468​ KToggleAction * annPolygon = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-polyline") ),
469​ i18nc("@action:intoolbar Annotation tool", "Polygon"), this);
470​
471​ ac->addAction( QStringLiteral("annotation_arrow"), annArrow );
472​ ac->setDefaultShortcut( annArrow, Qt::Key_9 );
473​ ac->addAction( QStringLiteral("annotation_straight_line"), annStraightLine );
474​ ac->addAction( QStringLiteral("annotation_rectangle"), annRectangle );
475​ ac->addAction( QStringLiteral("annotation_ellipse"), annEllipse );
476​ ac->addAction( QStringLiteral("annotation_polygon"), annPolygon );
477​
478​ ToggleActionMenu *ta = new ToggleActionMenu( QIcon(),QString(), this,
479​ QToolButton::MenuButtonPopup,
480​ ToggleActionMenu::ImplicitDefaultAction );
481​ connect(ta, &ToggleActionMenu::toggled, this, &AnnotationActionHandler::setTextToolsEnabled);
482​ ac->addAction( QStringLiteral("annotation_geometrical_shape"), ta );
483​ ta->setText( i18nc( "@action", "Geometrical shapes" ) );
484​ ta->setEnabled( true ); // Need to explicitly set this once, or refreshActions() in part.cpp will disable this action
485​ ta->addAction( annArrow );
486​ ta->addAction( annStraightLine );
487​ ta->addAction( annRectangle );
488​ ta->addAction( annEllipse );
489​ ta->addAction( annPolygon );
490​ ta->setDefaultAction( annArrow );
491​
492​ // The order in which the actions are added is relevant to connect
493​ // them to the correct tool id. See for loop below.
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​ d->m_annotationToolsGroup = new QActionGroup(this);
495​ d->m_annotationToolsGroup->addAction(annHighlighter);
496​ d->m_annotationToolsGroup->addAction(annUnderline);
497​ d->m_annotationToolsGroup->addAction(annSquiggle);
498​ d->m_annotationToolsGroup->addAction(annStrikeout);
499​ d->m_annotationToolsGroup->addAction(annTypewriter);
500​ d->m_annotationToolsGroup->addAction(annInlineNote);
501​ d->m_annotationToolsGroup->addAction(annPopupNote);
502​ d->m_annotationToolsGroup->addAction(annFreehandLine);
503​ d->m_annotationToolsGroup->addAction(annArrow);
504​ d->m_annotationToolsGroup->addAction(annStraightLine);
505​ d->m_annotationToolsGroup->addAction(annRectangle);
506​ d->m_annotationToolsGroup->addAction(annEllipse);
507​ d->m_annotationToolsGroup->addAction(annPolygon);
508​
509​ int i = 1;
510​ foreach( QAction * ann, d->m_annotationToolsGroup->actions() )
511​ {
512​ connect( ann, &QAction::toggled, [this, i] ( bool checked ) {
513​ if( checked )
514​ slotToolSelected( i );
515​ } );
516​ i++;
517​ }
518​
519​ d->m_annStamp = new ToggleActionMenu( QIcon::fromTheme( QStringLiteral("tag") ), QString(), this,
520​ QToolButton::MenuButtonPopup,
521​ ToggleActionMenu::ImplicitDefaultAction );
522​ ac->addAction(QStringLiteral("annotation_stamp"), d->m_annStamp );
523​ d->m_annStamp->setText( i18nc( "@action", "Stamp" ) );
524​
525​ QPair<QString, QString> stamp;
526​ foreach( stamp, StampAnnotationWidget::defaultStamps() ) {
527​
528​ KToggleAction * ann = new KToggleAction( d->stampIcon( stamp.second ), stamp.first, this);
529​ if( !d->m_annStamp->defaultAction() )
530​ d->m_annStamp->setDefaultAction( ann );
531​ d->m_annStamp->addAction( ann );
532​ d->m_annotationToolsGroup->addAction( ann );
533​ connect( ann, &QAction::triggered, [this, stamp] () { slotStampSelected( stamp.second ); } );
534​ }
535​
536​
537​ // Favorite annotations
538​ d->m_favorites = new KSelectAction( QIcon::fromTheme( QStringLiteral("bookmarks") ),
539​ i18nc("@action:intoolbar Show list of favorite annotation tools", "Favorites"), this );
540​ d->m_favorites->setToolTip( i18nc( "@info:tooltip", "Annotation tools with user-defined settings") );
541​ d->m_favorites->setToolBarMode( KSelectAction::MenuMode );
542​ ac->addAction( QStringLiteral("annotation_favorites"), d->m_favorites );
543​ addFavoriteAnnotations();
544​
545​ d->m_bookmark = new QAction(QIcon::fromTheme( QStringLiteral("favorite") ),
546​ i18nc("@action:intoolbar Add current annotation tool to favorite list", "Add to Favorites"), this);
547​ ac->addAction( QStringLiteral("annotation_bookmark"), d->m_bookmark );
548​ ac->setDefaultShortcut( d->m_bookmark, QKeySequence( Qt::CTRL + Qt::SHIFT + Qt::Key_B ) );
549​
550​ // Settings
551​ d->m_widthAction = new KSelectAction( QIcon::fromTheme( QStringLiteral("format-line-spacing-double") ),
552​ i18nc("@action:intoolbar Current annotation config option", "Line width"), this );
553​ d->m_widthAction->setToolBarMode( KSelectAction::MenuMode );
554​ ac->addAction( QStringLiteral("annotation_settings_width"), d->m_widthAction );
555​ for( int i = 0; i < lineWidthValues.size(); i++ ) {
556​ KToggleAction * ann = new KToggleAction( d->widthIcon( lineWidthValues[i] ), i18nc("@item:inlistbox", "Width %1", lineWidthValues[i]), this);
557​ d->m_widthAction->addAction( ann );
558​ connect( ann, &QAction::triggered, [this, i] () { slotSelectAnnotationWidth( lineWidthValues[i] ); } );
559​ }
560​
561​ d->m_colorAction = new QAction( QIcon(), i18nc("@action:intoolbar Current annotation config option", "Color"), this);
562​ ac->addAction(QStringLiteral("annotation_settings_color"), d->m_colorAction );
563​
564​ d->m_innerColorAction = new QAction( QIcon(), i18nc("@action:intoolbar Current annotation config option", "Inner Color"), this);
565​ ac->addAction(QStringLiteral("annotation_settings_inner_color"), d->m_innerColorAction );
566​
567​ d->m_fontAction = new QAction( QIcon::fromTheme( QStringLiteral("font-face") ),
568​ i18nc("@action:intoolbar Current annotation config option", "Font"), this );
569​ ac->addAction(QStringLiteral("annotation_settings_font"), d->m_fontAction );
570​
571​ d->m_opacityAction = new KSelectAction( QIcon::fromTheme( QStringLiteral("colors-luma") ),
572​ i18nc("@action:intoolbar Current annotation config option", "Opacity"), this );
573​ d->m_opacityAction->setToolBarMode( KSelectAction::MenuMode );
574​ ac->addAction( QStringLiteral("annotation_settings_opacity"), d->m_opacityAction );
575​ for( int i = 0; i < opacityValues.size(); i++ ) {
576​ KToggleAction * ann = new KToggleAction( d->opacityIcon( opacityValues[i] ), QString( "%1\%" ).arg( opacityValues[i] ), this);
577​ d->m_opacityAction->addAction( ann );
578​ connect( ann, &QAction::triggered, [this, i] () { slotSelectAnnotationOpacity( opacityValues[i] ); } );
579​ }
580​
581​ d->m_annAdvancedSettings = new QAction( QIcon::fromTheme( QStringLiteral("configure-shortcuts") ),
582​ i18nc("@action:intoolbar Current annotation advanced settings", "Annotation Settings"), this );
583​ ac->addAction(QStringLiteral("annotation_settings_advanced"), d->m_annAdvancedSettings );
584​
585​ d->m_continuousModeAction = new KToggleAction(QIcon::fromTheme( QStringLiteral("port") ),
586​ i18nc("@action:intoolbar When checked keep the current annotation tool active after use", "Pin"), this);
587​ d->m_continuousModeAction->setToolTip( i18nc( "@info:tooltip", "Keep the annotation tool active after use") );
588​ d->m_continuousModeAction->setChecked( d->m_annotator->continuousMode() );
589​ ac->addAction(QStringLiteral("annotation_settings_pin"), d->m_continuousModeAction );
590​
591​ d->m_textAnnotationTools = new QList<QAction *>();
592​ d->m_textAnnotationTools->append(annHighlighter);
593​ d->m_textAnnotationTools->append(annUnderline);
594​ d->m_textAnnotationTools->append(annSquiggle);
595​ d->m_textAnnotationTools->append(annStrikeout);
596​
597​ d->enableConfigActionsForAnnotation();
598​ d->updateConfigActionsToolTips();
599​
600​ connect( d->m_bookmark, &QAction::triggered, d->m_annotator, &PageViewAnnotator::bookmarkAnnotation );
601​
602​ connect( d->m_colorAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectColor );
603​ connect( d->m_innerColorAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectInnerColor );
604​ connect( d->m_fontAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectAnnotationFont );
605​ connect( d->m_annAdvancedSettings, &QAction::triggered, this, &AnnotationActionHandler::advancedSettingsTriggered );
606​ connect( d->m_continuousModeAction, &QAction::toggled , d->m_annotator, &PageViewAnnotator::setContinuousMode );
607​
608​ // Workaround to allow unchecking the currently selected annotation action in the QActionGroup
609​ connect( d->m_annotationToolsGroup, &QActionGroup::triggered, [this]( QAction* action ) {
610​ static QAction* lastAction = nullptr;
611​ if (action == lastAction) {
612​ lastAction = nullptr;
613​ d->m_annotationToolsGroup->checkedAction()->setChecked( false );
614​ d->enableConfigActionsForAnnotation();
615​ d->updateConfigActionsToolTips();
616​ d->m_selectedTool = -1;
617​ d->m_annotator->selectTool( -1 );
618​ } else {
619​ lastAction = action;
620​ }
621​ } );
622​}
623​
624​void AnnotationActionHandler::addFavoriteAnnotations()
625​{
626​ const QList<int> numberKeys = { Qt::Key_1, Qt::Key_2, Qt::Key_3, Qt::Key_4, Qt::Key_5,
627​ Qt::Key_6, Qt::Key_7,Qt::Key_8, Qt::Key_9, Qt::Key_0 };
628​
629​ if( !d->m_favoriteTextAnnotationTools )
630​ d->m_favoriteTextAnnotationTools = new QList<QAction *>();
631​ d->m_favoriteTextAnnotationTools->clear();
632​
633​ d->m_favorites->removeAllActions();
634​ int favToolID = 1;
635​ QList<int>::const_iterator shortcutNumber = numberKeys.begin();
636​ QDomElement favToolElement = d->m_annotator->favoriteTool( favToolID );
637​ while( !favToolElement.isNull() ) {
638​ QString itemText = favToolElement.attribute( "name" );
639​ if ( itemText.isEmpty() )
640​ itemText = PageViewAnnotator::defaultToolName( favToolElement );
641​ QIcon toolIcon = QIcon( PageViewAnnotator::makeToolPixmap( favToolElement ) );
642​ QAction * annFav = new QAction( toolIcon, itemText, this);
643​ d->m_favorites->addAction( annFav );
644​ if( shortcutNumber != numberKeys.end() )
645​ annFav->setShortcut( QKeySequence(Qt::ALT + *(shortcutNumber++) ) );
646​ connect( annFav, &QAction::triggered, [this, favToolID] () { slotFavoriteToolSelected( favToolID ); } );
647​
648​ QDomElement engineElement = favToolElement.firstChildElement( QStringLiteral("engine") );
649​ if( engineElement.attribute( "type" ) == QStringLiteral("TextSelector") )
650​ {
651​ d->m_favoriteTextAnnotationTools->append( annFav );
652​ annFav->setEnabled( d->m_textToolsEnabled );
653​ }
654​
655​ favToolElement = d->m_annotator->favoriteTool( ++favToolID );
656​ }
657​}
658​
659​AnnotationActionHandler::~AnnotationActionHandler()
660​{
661​ // delete the private data storage structure
662​ delete d;
663​}
664​
665​void AnnotationActionHandler::deselectAllAnnotationActions()
666​{
667​ QAction * checkedAction = d->m_annotationToolsGroup->checkedAction();
668​ if( checkedAction )
669​ checkedAction->trigger();
670​}
671​
672​void AnnotationActionHandler::setToolsEnabled( bool on )
673​{
674​ foreach( QAction * ann, d->m_annotationToolsGroup->actions() ) {
675​ ann->setEnabled( on );
676​ }
677​ d->m_favorites->setEnabled( on && d->m_favorites->actions().count() > 0 );
678​ d->m_continuousModeAction->setEnabled( on );
679​}
680​
681​void AnnotationActionHandler::setTextToolsEnabled( bool on )
682​{
683​ d->m_textToolsEnabled = on;
684​ foreach( QAction * ann, *d->m_textAnnotationTools )
685​ {
686​ ann->setEnabled( on );
687​ }
688​ foreach( QAction * ann, *d->m_favoriteTextAnnotationTools )
689​ {
690​ ann->setEnabled( on );
691​ }
692​}
693​
694​void AnnotationActionHandler::reparseTools()
695​{
696​ d->parseTool( d->m_selectedTool );
697​ addFavoriteAnnotations();
698​}
699​
700​void AnnotationActionHandler::slotToolSelected( int toolID )
701​{
702​ d->m_selectedTool = toolID;
703​ d->parseTool( toolID );
704​ d->m_annotator->selectTool( toolID );
705​}
706​
707​void AnnotationActionHandler::slotStampSelected( QString stamp )
708​{
709​ d->m_selectedTool = 14;
710​ d->m_annotator->setStampSymbol( stamp ); // Triggers a reparsing of the current tool
711​ d->m_annotator->selectTool( d->m_selectedTool );
712​}
713​
714​void AnnotationActionHandler::slotFavoriteToolSelected( int favToolID )
715​{
716​ int toolID = d->m_annotator->setFavoriteTool( favToolID );
717​ QAction * favToolAction = d->m_annotationToolsGroup->actions()[ toolID - 1 ];
718​ if( !favToolAction->isChecked() )
719​ favToolAction->setChecked( true );
720​ slotToolSelected( toolID );
721​}
722​
723​void AnnotationActionHandler::slotSelectColor()
724​{
725​ QColor selectedColor = QColorDialog::getColor(d->m_currentColor, nullptr,
726​ i18nc( "@title:window", "Select annotation color") );
727​ if (!selectedColor.isValid())
728​ return;
729​
730​ d->m_currentColor = selectedColor;
731​
732​ d->setColorActionIcon( d->m_currentColor );
733​
734​ if ( d->m_currentInnerColor.alpha() != selectedColor.alpha() && d->m_currentInnerColor.alpha() > 0 ) {
735​ d->m_currentInnerColor.setAlpha( selectedColor.alpha() );
736​ d->setInnerColorActionIcon( d->m_currentInnerColor );
737​ }
738​
739​ d->m_annotator->setAnnotationColor( d->m_currentColor );
740​}
741​
742​void AnnotationActionHandler::slotSelectInnerColor()
743​{
744​ QColor selectedColor = QColorDialog::getColor(d->m_currentInnerColor, nullptr,
745​ i18nc( "@title:window", "Select annotation inner color") );
746​ if (!selectedColor.isValid())
747​ return;
748​
749​ d->m_currentInnerColor = selectedColor;
750​
751​ d->setInnerColorActionIcon( d->m_currentInnerColor );
752​
753​ d->m_annotator->setAnnotationInnerColor( d->m_currentInnerColor );
754​
755​ if ( selectedColor.alpha() > 0 && d->m_currentColor.alpha() != selectedColor.alpha() ) {
756​ d->m_currentColor.setAlpha( selectedColor.alpha() );
757​ d->setColorActionIcon( d->m_currentColor );
758​ d->m_annotator->setAnnotationColor( d->m_currentColor );
759​ }
760​}
761​
762​void AnnotationActionHandler::slotSelectAnnotationFont()
763​{
764​ bool ok;
765​ QFont selectedFont = QFontDialog::getFont(&ok, d->m_currentFont);
766​ if (ok) {
767​ d->m_currentFont = selectedFont;
768​ d->m_annotator->setAnnotationFont( d->m_currentFont );
769​ }
770​}
771​
772​void AnnotationActionHandler::slotSelectAnnotationWidth( double width )
773​{
774​ d->m_annotator->setAnnotationWidth( width );
775​}
776​
777​void AnnotationActionHandler::slotSelectAnnotationOpacity( double opacity )
778​{
779​ d->m_annotator->setAnnotationOpacity( opacity / 100 );
780​}
781​
782​#include "moc_annotationactionhandler.cpp"