Differential D15580 Diff 62320 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 <QFontDialog>
16​#include <QPainter>
17​#include <QPen>
18​
19​// kde includes
20​#include <KActionCollection>
21​#include <KLocalizedString>
22​#include <KSelectAction>
23​
24​// local includes
25​#include "pageviewannotator.h"
26​#include "toolaction.h"
27​
28​class AnnotationActionHandlerPrivate
29​{
30​public:
31​ AnnotationActionHandlerPrivate( AnnotationActionHandler * qq )
32​ : q( qq ), m_textAnnotationTools( nullptr ), m_favoriteTextAnnotationTools( nullptr ),
33​ m_selectedTool( -1 ), m_currentColor( QColor("yellow") ),
34​ m_currentInnerColor( QColor("#00000000") ), m_currentFont( QFont() ),
35​ m_textToolsEnabled( false ), m_annotator( nullptr )
36​ {
37​ }
38​
39​ void parseTool( int toolID );
40​
41​ QIcon colorizeIcon(QIcon &icon, const QColor &color);
42​ void setColorActionIcon( QColor color );
43​ void setInnerColorActionIcon( QColor color );
44​ void enableConfigActionsForAnnotation( QString annotType = "none" );
45​ void updateConfigActionsToolTips( QString annotType = "none" );
46​
47​ QIcon widthIcon( double width );
48​ QIcon opacityIcon( int opacity );
49​
50​ AnnotationActionHandler * q;
51​
52​ QList<QAction *> * m_textAnnotationTools;
53​ QList<QAction *> * m_favoriteTextAnnotationTools;
54​ QActionGroup * m_annotationToolsGroup;
55​
56​ KSelectAction * m_favorites;
57​ QAction * m_bookmark;
58​ QAction * m_colorAction;
59​ QAction * m_innerColorAction;
60​ KSelectAction * m_opacityAction;
61​ QAction * m_fontAction;
62​ KSelectAction * m_widthAction;
63​ QAction * m_annAdvancedSettings;
64​ KToggleAction * m_continuousModeAction;
65​
66​ int m_selectedTool;
67​
68​ QColor m_currentColor;
69​ QColor m_currentInnerColor;
70​ QFont m_currentFont;
71​ int m_currentWidth;
72​
73​ bool m_textToolsEnabled;
74​
75​ PageViewAnnotator * m_annotator;
76​};
77​
78​void AnnotationActionHandlerPrivate::parseTool( int toolID )
79​{
80​ if( toolID == -1 )
81​ {
82​ enableConfigActionsForAnnotation( "none" );
83​ updateConfigActionsToolTips( "none" );
84​ return;
85​ }
86​
87​ QDomElement toolElement = m_annotator->builtinTool( toolID );
88​ const QString annotType = toolElement.attribute( QStringLiteral("type") );
89​ QDomElement engineElement = toolElement.firstChildElement( QStringLiteral("engine") );
90​ QDomElement annElement = engineElement.firstChildElement( QStringLiteral("annotation") );
91​
92​ if( annElement.hasAttribute( QStringLiteral( "color" ) ) )
93​ {
94​ if (annotType == "note-inline" || annotType == "typewriter" )
95​ {
96​ m_currentInnerColor = QColor( annElement.attribute( QStringLiteral( "color" ) ) );
97​ setInnerColorActionIcon( m_currentInnerColor );
98​ }
99​ else
100​ {
101​ m_currentColor = QColor( annElement.attribute( QStringLiteral( "color" ) ) );
102​ setColorActionIcon( m_currentColor );
103​ }
104​ }
105​
106​ if( annElement.hasAttribute( QStringLiteral( "innerColor" ) ) )
107​ m_currentInnerColor = QColor( annElement.attribute( QStringLiteral( "innerColor" ) ) );
108​ else
109​ m_currentInnerColor = Qt::transparent;
110​ setInnerColorActionIcon( m_currentInnerColor );
111​
112​ if( annElement.hasAttribute( QStringLiteral( "textColor" ) ) )
113​ {
114​ m_currentColor = QColor( annElement.attribute( QStringLiteral( "textColor" ) ) );
115​ setColorActionIcon( m_currentColor );
116​ }
117​
118​ if( annElement.hasAttribute( QStringLiteral( "font" ) ) )
119​ m_currentFont.fromString( annElement.attribute( QStringLiteral( "font" ) ) );
120​
121​ if( annElement.hasAttribute( QStringLiteral( "width" ) ) )
122​ {
123​ double width = annElement.attribute( QStringLiteral( "width" ) ).toDouble();
124​ int widthNumber = int( 2*width );
125​ // FIXME: Add some checks here
126​ if ( widthNumber > 0 )
127​ m_widthAction->setCurrentItem( widthNumber - 1 );
128​ }
129​ if( annElement.hasAttribute( QStringLiteral( "opacity" ) ) )
130​ {
131​ double opacity = annElement.attribute( QStringLiteral( "opacity" ) ).toDouble();
132​ m_opacityAction->setCurrentItem( int( 10 * opacity) );
aacidUnsubmitted
Done

no i18n?

aacid: no i18n?
133​ }
134​ else
135​ m_opacityAction->setCurrentItem( 10 );
136​
137​ enableConfigActionsForAnnotation( annotType );
138​ updateConfigActionsToolTips( annotType );
139​}
140​
141​QIcon AnnotationActionHandlerPrivate::colorizeIcon(QIcon &icon, const QColor &color)
142​{
143​ //FIXME: Use GuiUtils::colorize if possible instead or write a decent version of this method
144​ QPixmap iconPixmap = icon.pixmap(32, 32);
145​ QBitmap mask = iconPixmap.createMaskFromColor(QColor(Qt::transparent), Qt::MaskInColor);
146​ iconPixmap.fill(color);
147​ iconPixmap.setMask(mask);
148​ return QIcon(iconPixmap);
149​}
150​
151​void AnnotationActionHandlerPrivate::setColorActionIcon( QColor color )
152​{
153​ // Cannot use the current icon of m_ColorAction to define the mask to avoid trubles
154​ // the alpha channel is zero
155​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
156​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
157​ m_colorAction->setIcon( colorizedColorPicker );
158​}
159​
160​void AnnotationActionHandlerPrivate::setInnerColorActionIcon( QColor color )
161​{
162​ // Cannot use the current icon of m_ColorAction to define the mask to avoid trubles
163​ // the alpha channel is zero
164​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
165​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
166​ m_innerColorAction->setIcon( colorizedColorPicker );
167​}
168​
169​void AnnotationActionHandlerPrivate::enableConfigActionsForAnnotation( QString annotType )
170​{
171​ if( annotType == QStringLiteral( "note-inline" ) || annotType == QStringLiteral( "typewriter" ) ) {
172​ m_fontAction->setEnabled( true );
173​ } else {
174​ m_fontAction->setEnabled( false );
175​ }
176​ if( annotType == QStringLiteral( "stamp" ) || annotType == QStringLiteral( "none" ) ) {
177​ setColorActionIcon( Qt::transparent);
178​ m_colorAction->setEnabled( false );
179​ m_opacityAction->setEnabled( false );
180​ } else {
181​ m_colorAction->setEnabled( true );
182​ m_opacityAction->setEnabled( true );
183​ }
184​ if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
185​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) ) {
186​ m_innerColorAction->setEnabled( true );
187​ } else {
188​ setInnerColorActionIcon( Qt::transparent);
189​ m_innerColorAction->setEnabled( false );
190​ }
191​ if( annotType == QStringLiteral( "ink" ) ||
192​ annotType == QStringLiteral( "straight-line" ) || annotType == QStringLiteral( "rectangle" )
193​ || annotType == QStringLiteral( "ellipse" ) || annotType == QStringLiteral( "polygon" ) )
194​ {
195​ m_widthAction->setEnabled( true );
196​ } else {
197​ m_widthAction->setEnabled( false );
198​ }
199​ if ( annotType == QStringLiteral( "none" ) ) {
200​ m_annAdvancedSettings->setEnabled( false );
201​ m_bookmark->setEnabled( false );
202​ } else {
203​ m_annAdvancedSettings->setEnabled( true );
204​ m_bookmark->setEnabled( true );
205​ }
206​
207​}
208​
209​void AnnotationActionHandlerPrivate::updateConfigActionsToolTips( QString annotType )
210​{
211​ if( annotType == QStringLiteral( "note-inline" ) )
212​ {
213​ m_colorAction->setToolTip( i18n("Annotation text and border color") );
214​ }
215​ else if ( annotType == QStringLiteral( "typewriter" ) )
216​ {
217​ m_colorAction->setToolTip( i18n("Annotation text color") );
218​ }
219​ else if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
220​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) )
221​ {
222​ m_colorAction->setToolTip( i18n("Annotation border color") );
223​ }
224​ else if( annotType == QStringLiteral( "none" ) )
225​ {
226​ m_colorAction->setToolTip( i18n("Annotation color (No annotation selected)") );
227​ }
228​ else
229​ {
230​ m_colorAction->setToolTip( i18n("Annotation color") );
231​ }
232​
233​ if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
234​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) )
235​ {
236​ m_innerColorAction->setToolTip( i18n("Annotation fill color") );
237​ }
238​ else if( annotType == QStringLiteral( "none" ) )
239​ {
240​ m_innerColorAction->setToolTip( i18n("Annotation fill color (No annotation selected)") );
241​ }
242​ else
243​ {
244​ m_innerColorAction->setToolTip( i18n("Annotation fill color (Current annotation has no fill color)") );
245​ }
246​
247​ if( annotType == QStringLiteral( "ink" ) ||
248​ annotType == QStringLiteral( "straight-line" ) || annotType == QStringLiteral( "rectangle" )
249​ || annotType == QStringLiteral( "ellipse" ) || annotType == QStringLiteral( "polygon" ) )
250​ {
251​ m_widthAction->setToolTip( i18n("Annotation line width") );
252​ }
253​ else if( annotType == QStringLiteral( "none" ) )
254​ {
255​ m_widthAction->setToolTip( i18n("Annotation line width (No annotation selected)") );
256​ }
257​ else
258​ {
259​ m_widthAction->setToolTip( i18n("Annotation line width (Current annotation has no line width)") );
260​ }
261​
262​ if( annotType == QStringLiteral( "stamp" ) )
263​ {
264​ m_opacityAction->setToolTip( i18n("Annotation opacity (Cannot change opacity of current annotation)") );
265​ }
266​ else if( annotType == QStringLiteral( "none" ) )
267​ {
268​ m_opacityAction->setToolTip( i18n("Annotation opacity (No annotation selected)") );
269​ }
270​ else
271​ {
272​ m_opacityAction->setToolTip( i18n("Annotation opacity") );
273​ }
274​
275​ if( annotType == QStringLiteral( "note-inline" ) || annotType == QStringLiteral( "typewriter" ) )
276​ {
277​ m_fontAction->setToolTip( i18n("Annotation font") );
278​ }
279​ else if( annotType == QStringLiteral( "none" ) )
280​ {
281​ m_fontAction->setToolTip( i18n("Annotation font (No annotation selected)") );
282​ }
283​ else
284​ {
285​ m_fontAction->setToolTip( i18n("Annotation font (Current annotation has no font)") );
286​ }
287​
288​ if( annotType == QStringLiteral( "none" ) )
289​ {
290​ m_bookmark->setToolTip( i18n("Add the current annotation to the favorites (No annotation selected)") );
291​ m_annAdvancedSettings->setToolTip( i18n("Advanced settings for the current annotation tool (No annotation selected)") );
292​ }
293​ else
294​ {
295​ m_bookmark->setToolTip( i18n("Add the current annotation to the favorites") );
296​ m_annAdvancedSettings->setToolTip( i18n("Advanced settings for the current annotation tool") );
297​ }
298​}
299​
300​QIcon AnnotationActionHandlerPrivate::widthIcon( double width )
301​{
302​ QPixmap pm(16, 16); //TODO: Is fixed size ok here?
303​ pm.fill( Qt::transparent );
304​ QPainter p(&pm);
305​ p.setRenderHint(QPainter::Antialiasing);
306​ p.setPen(QPen(Qt::black, width, Qt::SolidLine, Qt::RoundCap));
307​ p.drawLine(0, pm.height()/2, pm.width(), pm.height()/2);
308​ p.end();
309​
310​ return QIcon( pm );
311​}
312​
313​QIcon AnnotationActionHandlerPrivate::opacityIcon( int opacity )
314​{
315​ QPixmap pm( 32, 32 ); //TODO: Is fixed size ok here?
316​ pm.fill( Qt::transparent );
317​ QPainter p( &pm );
318​ p.setRenderHint( QPainter::Antialiasing );
319​ p.setPen( Qt::NoPen );
320​ QColor color( Qt::black );
321​ color.setAlpha( opacity*255.0/100.0 );
322​ p.setBrush( QBrush( color ) );
323​ p.drawRect( 4, 4, 24, 24 );
324​ p.end();
325​
326​ return QIcon( pm );
327​}
328​
329​AnnotationActionHandler::AnnotationActionHandler( PageViewAnnotator * parent, KActionCollection * ac )
330​ : QObject( parent ), d( new AnnotationActionHandlerPrivate( this ) )
331​{
332​ d->m_annotator = parent;
333​
334​ // Text markup
335​ KToggleAction * annHighlighter = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-eraser") ), i18n("Highlighter"), this);
336​ ac->addAction(QStringLiteral("annotation_highlighter"), annHighlighter );
337​
338​ KToggleAction * annUnderline = new KToggleAction(QIcon::fromTheme( QStringLiteral("format-text-underline") ), i18n("Underline"), this);
339​ ac->addAction(QStringLiteral("annotation_underline"), annUnderline );
340​
341​ KToggleAction * annSquiggle = new KToggleAction(QIcon::fromTheme( QStringLiteral("format-text-underline") ), i18n("Squiggle"), this);
342​ ac->addAction(QStringLiteral("annotation_squiggle"), annSquiggle );
343​
344​ KToggleAction * annStrikeout= new KToggleAction(QIcon::fromTheme( QStringLiteral("format-text-strikethrough") ), i18n("Strike out"), this);
345​ ac->addAction(QStringLiteral("annotation_strike_out"), annStrikeout );
346​
347​ // Notes
348​ KToggleAction * annTypewriter = new KToggleAction(QIcon::fromTheme( QStringLiteral("text-convert-to-regular") ), i18n("Typewriter"), this);
349​ ac->addAction(QStringLiteral("annotation_typewriter"), annTypewriter );
350​
351​ KToggleAction * annInlineNote = new KToggleAction(QIcon::fromTheme( QStringLiteral("note") ), i18n("Inline note"), this);
352​ ac->addAction(QStringLiteral("annotation_inline_note"), annInlineNote );
353​
354​ KToggleAction * annPopupNote = new KToggleAction(QIcon::fromTheme( QStringLiteral("edit-comment") ), i18n("Popup note"), this);
355​ ac->addAction(QStringLiteral("annotation_popup_note"), annPopupNote );
356​
357​ KToggleAction * annFreehandLine = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-freehand") ), i18n("Freehand line"), this);
358​ ac->addAction(QStringLiteral("annotation_freehand_line"), annFreehandLine );
359​
360​ // Geometrical shapes
361​ KToggleAction * annStraightLine = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-line") ), i18n("Straight line"), this);
362​ KToggleAction * annArrow = new KToggleAction(QIcon::fromTheme( QStringLiteral("circular-arrow-shape") ), i18n("Arrow"), this);
363​ KToggleAction * annRectangle = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-rectangle") ), i18n("Rectangle"), this);
364​ KToggleAction * annEllipse = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-ellipse") ), i18n("Ellipse"), this);
365​ KToggleAction * annPolygon = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-polyline") ), i18n("Polygon"), this);
366​ ToolAction *ta = new ToolAction( this );
367​ ta->setEnabled( true ); // Need to explicitly set this once, or refreshActions() in part.cpp will disable this action
368​ ac->addAction( QStringLiteral("annotation_geometrical_shape"), ta );
369​ ta->addAction( annStraightLine );
370​ ta->addAction( annArrow );
371​ ta->addAction( annRectangle );
372​ ta->addAction( annEllipse );
373​ ta->addAction( annPolygon );
374​
375​ // Favorite annotations
376​ d->m_favorites = new KSelectAction( QIcon::fromTheme( QStringLiteral("bookmarks") ), i18n("Favorites"), this );
377​ d->m_favorites->setToolTip( i18n("Annotation tools with user-defined settings") );
378​ d->m_favorites->setToolBarMode( KSelectAction::MenuMode );
379​ ac->addAction( QStringLiteral("annotation_favorites"), d->m_favorites );
380​ addFavoriteAnnotations();
381​
382​ d->m_bookmark = new QAction(QIcon::fromTheme( QStringLiteral("favorite") ), i18n("Add to favorites"), this);
383​ ac->addAction( QStringLiteral("annotation_bookmark"), d->m_bookmark );
384​
385​ // Settings
386​ d->m_widthAction = new KSelectAction( QIcon::fromTheme( QStringLiteral("format-line-spacing-double") ), i18n("Line width"), this );
387​ d->m_widthAction->setToolBarMode( KSelectAction::MenuMode );
388​ ac->addAction( QStringLiteral("annotation_settings_width"), d->m_widthAction );
yurchorUnsubmitted
Done

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

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ for( int i = 1; i <= 10; i++ ) {
390​ KToggleAction * ann = new KToggleAction( d->widthIcon( i ), i18n("Width %1").arg( i/2.0 ), this);
391​ d->m_widthAction->addAction( ann );
392​ connect( ann, &QAction::triggered, [this, i] () { slotSelectAnnotationWidth( i ); } );
393​ }
394​
395​ d->m_colorAction = new QAction( QIcon(), i18n("Color"), this);
396​ ac->addAction(QStringLiteral("annotation_settings_color"), d->m_colorAction );
397​
398​ d->m_innerColorAction = new QAction( QIcon(), i18n("Inner color"), this);
399​ ac->addAction(QStringLiteral("annotation_settings_inner_color"), d->m_innerColorAction );
400​
401​ d->m_fontAction = new QAction( QIcon::fromTheme( QStringLiteral("font-face") ), i18n("Font"), this );
402​ ac->addAction(QStringLiteral("annotation_settings_font"), d->m_fontAction );
403​
404​ d->m_opacityAction = new KSelectAction( QIcon::fromTheme( QStringLiteral("colors-luma") ), i18n("Opacity"), this );
405​ d->m_opacityAction->setToolBarMode( KSelectAction::MenuMode );
406​ ac->addAction( QStringLiteral("annotation_settings_opacity"), d->m_opacityAction );
407​ for( int opacity = 0; opacity <= 100; opacity += 10 ) {
408​ KToggleAction * ann = new KToggleAction( d->opacityIcon( opacity ), QString( "%1\%" ).arg( opacity ), this);
409​ d->m_opacityAction->addAction( ann );
410​ connect( ann, &QAction::triggered, [this, opacity] () { slotSelectAnnotationOpacity( opacity ); } );
411​ }
412​
413​ d->m_annAdvancedSettings = new QAction( QIcon::fromTheme( QStringLiteral("configure-shortcuts") ), i18n("Annotation settings"), this );
414​ ac->addAction(QStringLiteral("annotation_settings_advanced"), d->m_annAdvancedSettings );
415​
416​ d->m_continuousModeAction = new KToggleAction(QIcon::fromTheme( QStringLiteral("port") ), i18n("Pin"), this);
417​ d->m_continuousModeAction->setToolTip( i18n("Keep the annotation tool active after use") );
418​ d->m_continuousModeAction->setChecked( d->m_annotator->continuousMode() );
419​ ac->addAction(QStringLiteral("annotation_settings_pin"), d->m_continuousModeAction );
420​
421​ // The order in which the actions are added is relevant to connect
422​ // them to the correct tool id. See for loop below.
423​ d->m_annotationToolsGroup = new QActionGroup(this);
424​ d->m_annotationToolsGroup->addAction(annHighlighter);
425​ d->m_annotationToolsGroup->addAction(annUnderline);
426​ d->m_annotationToolsGroup->addAction(annSquiggle);
427​ d->m_annotationToolsGroup->addAction(annStrikeout);
428​ d->m_annotationToolsGroup->addAction(annTypewriter);
429​ d->m_annotationToolsGroup->addAction(annInlineNote);
430​ d->m_annotationToolsGroup->addAction(annPopupNote);
431​ d->m_annotationToolsGroup->addAction(annFreehandLine);
432​ d->m_annotationToolsGroup->addAction(annStraightLine);
433​ d->m_annotationToolsGroup->addAction(annArrow);
434​ d->m_annotationToolsGroup->addAction(annRectangle);
435​ d->m_annotationToolsGroup->addAction(annEllipse);
436​ d->m_annotationToolsGroup->addAction(annPolygon);
437​
438​ d->m_textAnnotationTools = new QList<QAction *>();
439​ d->m_textAnnotationTools->append(annHighlighter);
440​ d->m_textAnnotationTools->append(annUnderline);
441​ d->m_textAnnotationTools->append(annSquiggle);
442​ d->m_textAnnotationTools->append(annStrikeout);
443​
444​ d->enableConfigActionsForAnnotation();
445​ d->updateConfigActionsToolTips();
446​
447​ int i = 1;
448​ foreach( QAction * ann, d->m_annotationToolsGroup->actions() )
449​ {
450​ connect( ann, &QAction::toggled, [this, i] ( bool checked ) {
451​ if( checked )
452​ slotToolSelected( i );
453​ } );
454​ i++;
455​ }
456​
457​ connect( d->m_bookmark, &QAction::triggered, d->m_annotator, &PageViewAnnotator::bookmarkAnnotation );
458​
459​ connect( d->m_colorAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectColor );
460​ connect( d->m_innerColorAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectInnerColor );
461​ connect( d->m_fontAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectAnnotationFont );
462​ connect( d->m_annAdvancedSettings, &QAction::triggered, this, &AnnotationActionHandler::advancedSettingsTriggered );
463​ connect( d->m_continuousModeAction, &QAction::toggled , d->m_annotator, &PageViewAnnotator::setContinuousMode );
464​
465​ // Workaround to allow unchecking the currently selected annotation action in the QActionGroup
466​ connect( d->m_annotationToolsGroup, &QActionGroup::triggered, [this]( QAction* action ) {
467​ static QAction* lastAction = nullptr;
468​ if (action == lastAction) {
469​ lastAction = nullptr;
470​ d->m_annotationToolsGroup->checkedAction()->setChecked( false );
471​ d->enableConfigActionsForAnnotation();
472​ d->updateConfigActionsToolTips();
473​ d->m_selectedTool = -1;
474​ d->m_annotator->selectTool( -1 );
475​ } else {
476​ lastAction = action;
477​ }
478​ } );
479​}
480​
481​void AnnotationActionHandler::addFavoriteAnnotations()
482​{
483​ if( !d->m_favoriteTextAnnotationTools )
484​ d->m_favoriteTextAnnotationTools = new QList<QAction *>();
485​ d->m_favoriteTextAnnotationTools->clear();
486​
487​ d->m_favorites->removeAllActions();
488​ int favToolID = 1;
489​ QDomElement favToolElement = d->m_annotator->favoriteTool( favToolID );
490​ while( !favToolElement.isNull() ) {
491​ QString itemText = favToolElement.attribute( "name" );
492​ if ( itemText.isEmpty() )
493​ itemText = PageViewAnnotator::defaultToolName( favToolElement );
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​ QIcon toolIcon = QIcon( PageViewAnnotator::makeToolPixmap( favToolElement ) );
495​ QAction * annFav = new QAction( toolIcon, itemText, this);
496​ d->m_favorites->addAction( annFav );
497​ connect( annFav, &QAction::triggered, [this, favToolID] () { slotFavoriteToolSelected( favToolID ); } );
498​
499​ QDomElement engineElement = favToolElement.firstChildElement( QStringLiteral("engine") );
500​ if( engineElement.attribute( "type" ) == QStringLiteral("TextSelector") )
501​ {
502​ d->m_favoriteTextAnnotationTools->append( annFav );
503​ annFav->setEnabled( d->m_textToolsEnabled );
504​ }
505​
506​ favToolElement = d->m_annotator->favoriteTool( ++favToolID );
507​ }
508​}
509​
510​AnnotationActionHandler::~AnnotationActionHandler()
511​{
512​ // delete the private data storage structure
513​ delete d;
514​}
515​
516​void AnnotationActionHandler::deselectAllAnnotationActions()
517​{
518​ QAction * checkedAction = d->m_annotationToolsGroup->checkedAction();
519​ if( checkedAction )
520​ checkedAction->trigger();
521​}
522​
523​void AnnotationActionHandler::setToolsEnabled( bool on )
524​{
525​ foreach( QAction * ann, d->m_annotationToolsGroup->actions() ) {
526​ ann->setEnabled( on );
527​ }
528​ d->m_favorites->setEnabled( on && d->m_favorites->actions().count() > 0 );
529​ d->m_continuousModeAction->setEnabled( on );
530​}
531​
532​void AnnotationActionHandler::setTextToolsEnabled( bool on )
533​{
534​ d->m_textToolsEnabled = on;
535​ foreach( QAction * ann, *d->m_textAnnotationTools )
536​ {
537​ ann->setEnabled( on );
538​ }
539​ foreach( QAction * ann, *d->m_favoriteTextAnnotationTools )
540​ {
541​ ann->setEnabled( on );
542​ }
543​}
544​
545​void AnnotationActionHandler::reparseTools()
546​{
547​ d->parseTool( d->m_selectedTool );
548​ addFavoriteAnnotations();
549​}
550​
551​void AnnotationActionHandler::slotToolSelected( int toolID )
552​{
553​ d->m_selectedTool = toolID;
554​ d->parseTool( toolID );
555​ d->m_annotator->selectTool( toolID );
556​}
557​
558​void AnnotationActionHandler::slotFavoriteToolSelected( int favToolID )
559​{
560​ int toolID = d->m_annotator->setFavoriteTool( favToolID );
561​ QAction * favToolAction = d->m_annotationToolsGroup->actions()[ toolID - 1 ];
562​ if( !favToolAction->isChecked() )
563​ favToolAction->setChecked( true );
564​ slotToolSelected( toolID );
565​}
566​
567​void AnnotationActionHandler::slotSelectColor()
568​{
569​ QColor selectedColor = QColorDialog::getColor(d->m_currentColor, nullptr, i18n("Select annotation color") );
570​ if (!selectedColor.isValid())
571​ return;
572​
573​ d->m_currentColor = selectedColor;
574​
575​ d->setColorActionIcon( d->m_currentColor );
576​
577​ if ( d->m_currentInnerColor.alpha() != selectedColor.alpha() && d->m_currentInnerColor.alpha() > 0 ) {
578​ d->m_currentInnerColor.setAlpha( selectedColor.alpha() );
579​ d->setInnerColorActionIcon( d->m_currentInnerColor );
580​ }
581​
582​ d->m_annotator->setAnnotationColor( d->m_currentColor );
583​}
584​
585​void AnnotationActionHandler::slotSelectInnerColor()
586​{
587​ QColor selectedColor = QColorDialog::getColor(d->m_currentInnerColor, nullptr, i18n("Select annotation inner color") );
588​ if (!selectedColor.isValid())
589​ return;
590​
591​ d->m_currentInnerColor = selectedColor;
592​
593​ d->setInnerColorActionIcon( d->m_currentInnerColor );
594​
595​ d->m_annotator->setAnnotationInnerColor( d->m_currentInnerColor );
596​
597​ if ( selectedColor.alpha() > 0 && d->m_currentColor.alpha() != selectedColor.alpha() ) {
598​ d->m_currentColor.setAlpha( selectedColor.alpha() );
599​ d->setColorActionIcon( d->m_currentColor );
600​ d->m_annotator->setAnnotationColor( d->m_currentColor );
601​ }
602​}
603​
604​void AnnotationActionHandler::slotSelectAnnotationFont()
605​{
606​ bool ok;
607​ QFont selectedFont = QFontDialog::getFont(&ok, d->m_currentFont);
608​ if (ok) {
609​ d->m_currentFont = selectedFont;
610​ d->m_annotator->setAnnotationFont( d->m_currentFont );
611​ }
612​}
613​
614​void AnnotationActionHandler::slotSelectAnnotationWidth( int widthNumber )
615​{
616​ d->m_annotator->setAnnotationWidth( widthNumber / 2.0 );
617​}
618​
619​void AnnotationActionHandler::slotSelectAnnotationOpacity( int opacity )
620​{
621​ d->m_annotator->setAnnotationOpacity( opacity / 100.0 );
622​}
623​
624​#include "moc_annotationactionhandler.cpp"