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

no i18n?

aacid: no i18n?
133​}
134​
135​void AnnotationActionHandlerPrivate::setBorderColorActionIcon( QColor color )
136​{
137​ // Cannot use the current icon of m_borderColorAction to define the mask to avoid trubles
138​ // the alpha channel is zero
139​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
140​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
141​ m_borderColorAction->setIcon( colorizedColorPicker );
142​}
143​
144​void AnnotationActionHandlerPrivate::setInnerColorActionIcon( QColor color )
145​{
146​ // Cannot use the current icon of m_borderColorAction to define the mask to avoid trubles
147​ // the alpha channel is zero
148​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
149​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
150​ m_innerColorAction->setIcon( colorizedColorPicker );
151​}
152​
153​void AnnotationActionHandlerPrivate::enableConfigActionsForAnnotation( QString annotType = "none" )
154​{
155​ if( annotType == QStringLiteral( "note-inline" ) || annotType == QStringLiteral( "typewriter" ) ) {
156​ m_fontAction->setEnabled( true );
157​ } else {
158​ m_fontAction->setEnabled( false );
159​ }
160​ if( annotType == QStringLiteral( "stamp" ) || annotType == QStringLiteral( "none" ) ) {
161​ m_borderColorAction->setEnabled( false );
162​ m_opacityAction->setEnabled( false );
163​ } else {
164​ m_borderColorAction->setEnabled( true );
165​ m_opacityAction->setEnabled( true );
166​ }
167​ if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
168​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) ) {
169​ m_innerColorAction->setEnabled( true );
170​ } else {
171​ m_innerColorAction->setEnabled( false );
172​ }
173​ if( annotType == QStringLiteral( "ink" ) ||
174​ annotType == QStringLiteral( "straight-line" ) || annotType == QStringLiteral( "rectangle" )
175​ || annotType == QStringLiteral( "ellipse" ) || annotType == QStringLiteral( "polygon" ) )
176​ {
177​ m_widthAction->setEnabled( true );
178​ } else {
179​ m_widthAction->setEnabled( false );
180​ }
181​ if ( annotType == QStringLiteral( "none" ) ) {
182​ m_annAdvancedSettings->setEnabled( false );
183​ m_bookmark->setEnabled( false );
184​ } else {
185​ m_annAdvancedSettings->setEnabled( true );
186​ m_bookmark->setEnabled( true );
187​ }
188​
189​}
190​
191​QIcon AnnotationActionHandlerPrivate::widthIcon( double width )
192​{
193​ QPixmap pm(16, 16); //TODO: Is fixed size ok here?
194​ pm.fill( Qt::transparent );
195​ QPainter p(&pm);
196​ p.setRenderHint(QPainter::Antialiasing);
197​ p.setPen(QPen(Qt::black, width, Qt::SolidLine, Qt::RoundCap));
198​ p.drawLine(0, pm.height()/2, pm.width(), pm.height()/2);
199​ p.end();
200​
201​ return QIcon( pm );
202​}
203​
204​QIcon AnnotationActionHandlerPrivate::opacityIcon( int opacity )
205​{
206​ QPixmap pm( 32, 32 ); //TODO: Is fixed size ok here?
207​ pm.fill( Qt::transparent );
208​ QPainter p( &pm );
209​ p.setRenderHint( QPainter::Antialiasing );
210​ p.setPen( Qt::NoPen );
211​ QColor color( Qt::black );
212​ color.setAlpha( opacity*255.0/100.0 );
213​ p.setBrush( QBrush( color ) );
214​ p.drawRect( 4, 4, 24, 24 );
215​ p.end();
216​
217​ return QIcon( pm );
218​}
219​
220​AnnotationActionHandler::AnnotationActionHandler( PageViewAnnotator * parent, KActionCollection * ac )
221​ : QObject( parent ), d( new AnnotationActionHandlerPrivate( this ) )
222​{
223​ d->m_annotator = parent;
224​
225​ // Text markup
226​ QAction * annHighlighter = new QAction(QIcon::fromTheme( QStringLiteral("draw-eraser") ), "Highlighter", this);
227​ annHighlighter->setCheckable( true );
228​ ac->addAction(QStringLiteral("annotation_highlighter"), annHighlighter );
229​
230​ QAction * annUnderline = new QAction(QIcon::fromTheme( QStringLiteral("format-text-underline") ), "Underline", this);
231​ annUnderline->setCheckable( true );
232​ ac->addAction(QStringLiteral("annotation_underline"), annUnderline );
233​
234​ QAction * annSquiggle = new QAction(QIcon::fromTheme( QStringLiteral("format-text-underline") ), "Squiggle", this);
235​ annSquiggle->setCheckable( true );
236​ ac->addAction(QStringLiteral("annotation_squiggle"), annSquiggle );
237​
238​ QAction * annStrikeout= new QAction(QIcon::fromTheme( QStringLiteral("format-text-strikethrough") ), "Strike out", this);
239​ annStrikeout->setCheckable( true );
240​ ac->addAction(QStringLiteral("annotation_strike_out"), annStrikeout );
241​
242​ // Notes
243​ QAction * annTypewriter = new QAction(QIcon::fromTheme( QStringLiteral("text-convert-to-regular") ), "Typewriter", this);
244​ annTypewriter->setCheckable( true );
245​ ac->addAction(QStringLiteral("annotation_typewriter"), annTypewriter );
246​
247​ QAction * annInlineNote = new QAction(QIcon::fromTheme( QStringLiteral("note") ), "Inline note", this);
248​ annInlineNote->setCheckable( true );
249​ ac->addAction(QStringLiteral("annotation_inline_note"), annInlineNote );
250​
251​ QAction * annPopupNote = new QAction(QIcon::fromTheme( QStringLiteral("edit-comment") ), "Popup note", this);
252​ annPopupNote->setCheckable( true );
253​ ac->addAction(QStringLiteral("annotation_popup_note"), annPopupNote );
254​
255​ QAction * annFreehandLine = new QAction(QIcon::fromTheme( QStringLiteral("draw-freehand") ), "Freehand line", this);
256​ annFreehandLine->setCheckable( true );
257​ ac->addAction(QStringLiteral("annotation_freehand_line"), annFreehandLine );
258​
259​ // Geometrical shapes
260​ KToggleAction * annStraightLine = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-line") ), i18n("Straight line"), this);
261​
262​ KToggleAction * annArrow = new KToggleAction(QIcon::fromTheme( QStringLiteral("circular-arrow-shape") ), i18n("Arrow"), this);
263​
264​ KToggleAction * annRectangle = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-rectangle") ), i18n("Rectangle"), this);
265​
266​ KToggleAction * annEllipse = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-ellipse") ), i18n("Ellipse"), this);
267​
268​ KToggleAction * annPolygon = new KToggleAction(QIcon::fromTheme( QStringLiteral("draw-polyline") ), i18n("Polygon"), this);
269​
270​ ToolAction *ta = new ToolAction( this );
271​ ac->addAction( QStringLiteral("annotation_geometrical_shape"), ta );
272​ ta->addAction( annStraightLine );
273​ ta->addAction( annArrow );
274​ ta->addAction( annRectangle );
275​ ta->addAction( annEllipse );
276​ ta->addAction( annPolygon );
277​
278​ // Favorite annotations
279​ d->m_favorites = new KSelectAction( QIcon::fromTheme( QStringLiteral("bookmarks") ), "Favorites", this );
280​ d->m_favorites->setToolBarMode( KSelectAction::MenuMode );
281​ ac->addAction( QStringLiteral("annotation_favorites"), d->m_favorites );
282​ addFavoriteAnnotations();
283​
284​ d->m_bookmark = new QAction(QIcon::fromTheme( QStringLiteral("favorite") ), "Add to favorites", this);
285​ ac->addAction( QStringLiteral("annotation_bookmark"), d->m_bookmark );
286​
287​ // Settings
288​ d->m_widthAction = new KSelectAction( QIcon::fromTheme( QStringLiteral("format-line-spacing-double") ), i18n("Line width"), this );
289​ d->m_widthAction->setToolBarMode( KSelectAction::MenuMode );
290​ ac->addAction( QStringLiteral("annotation_size"), d->m_widthAction );
291​ QSignalMapper * widthSelectorSignalMapper = new QSignalMapper(this);
292​ for( int i = 1; i <= 10; i++ )
293​ {
294​ QAction * ann = new QAction( d->widthIcon( i ), QString( "Width %1" ).arg( i/2.0 ), this);
295​ ann->setCheckable( true );
296​ d->m_widthAction->addAction( ann );
297​ connect(ann, SIGNAL(triggered()), widthSelectorSignalMapper, SLOT(map()));
298​ widthSelectorSignalMapper->setMapping(ann, i);
299​ }
300​
301​ d->m_borderColorAction = new QAction( QIcon(), "Color", this);
302​ d->setBorderColorActionIcon( QColor( "black" ) );
303​ ac->addAction(QStringLiteral("annotation_settings_color"), d->m_borderColorAction );
304​
305​ d->m_innerColorAction = new QAction( QIcon(), "Inner color", this);
306​ d->setInnerColorActionIcon( QColor( "black" ) );
307​ ac->addAction(QStringLiteral("annotation_settings_inner_color"), d->m_innerColorAction );
308​
309​ d->m_fontAction = new QAction( QIcon::fromTheme( QStringLiteral("font-face") ), "Font", this );
310​ ac->addAction(QStringLiteral("annotation_settings_font"), d->m_fontAction );
311​
312​ d->m_opacityAction = new KSelectAction( QIcon::fromTheme( QStringLiteral("colors-luma") ), "Opacity", this );
313​ d->m_opacityAction->setToolBarMode( KSelectAction::MenuMode );
314​ d->m_opacityAction->setEditable( true );
315​ ac->addAction( QStringLiteral("annotation_settings_opacity"), d->m_opacityAction );
316​ QSignalMapper * opacitySelectorSignalMapper = new QSignalMapper(this);
317​ for( int opacity = 0; opacity <= 100; opacity += 10 )
318​ {
319​ QAction * ann = new QAction( d->opacityIcon( opacity ), QString( "%1\%" ).arg( opacity ), this);
320​ ann->setCheckable( true );
321​ d->m_opacityAction->addAction( ann );
322​ connect( ann, SIGNAL( triggered() ), opacitySelectorSignalMapper, SLOT( map() ) );
323​ opacitySelectorSignalMapper->setMapping( ann, opacity );
324​ }
325​
326​
327​ d->m_annAdvancedSettings = new QAction( QIcon::fromTheme( QStringLiteral("configure-shortcuts") ), "Annotation settings", this );
328​ ac->addAction(QStringLiteral("annotation_settings_advanced"), d->m_annAdvancedSettings );
329​
330​ QAction * pinAnnotationTool = new QAction(QIcon::fromTheme( QStringLiteral("port") ), "Pin annotation", this);
331​ pinAnnotationTool->setCheckable( true );
332​ pinAnnotationTool->setChecked( true );
333​ ac->addAction(QStringLiteral("annotation_settings_pin"), pinAnnotationTool );
334​
335​ // The order in which the actions are added is relevant to connect
336​ // them to the correct tool id. See for loop below.
337​ d->m_annotationToolsGroup = new QActionGroup(this);
338​ d->m_annotationToolsGroup->addAction(annHighlighter);
339​ d->m_annotationToolsGroup->addAction(annUnderline);
340​ d->m_annotationToolsGroup->addAction(annSquiggle);
341​ d->m_annotationToolsGroup->addAction(annStrikeout);
342​ d->m_annotationToolsGroup->addAction(annTypewriter);
343​ d->m_annotationToolsGroup->addAction(annInlineNote);
344​ d->m_annotationToolsGroup->addAction(annPopupNote);
345​ d->m_annotationToolsGroup->addAction(annFreehandLine);
346​ d->m_annotationToolsGroup->addAction(annStraightLine);
347​ d->m_annotationToolsGroup->addAction(annArrow);
348​ d->m_annotationToolsGroup->addAction(annRectangle);
349​ d->m_annotationToolsGroup->addAction(annEllipse);
350​ d->m_annotationToolsGroup->addAction(annPolygon);
351​
352​ d->m_annotationTools = new QList<QAction *>(d->m_annotationToolsGroup->actions());
353​ d->m_annotationTools->append(pinAnnotationTool);
354​ d->m_annotationTools->append( d->m_favorites );
355​
356​ d->m_textAnnotationTools = new QList<QAction *>();
357​ d->m_textAnnotationTools->append(annHighlighter);
358​ d->m_textAnnotationTools->append(annUnderline);
359​ d->m_textAnnotationTools->append(annSquiggle);
360​ d->m_textAnnotationTools->append(annStrikeout);
361​
362​ d->enableConfigActionsForAnnotation();
363​
364​ QSignalMapper * annSignalMapper = new QSignalMapper(this);
365​ int i = 1;
366​ foreach( QAction * ann, d->m_annotationToolsGroup->actions() )
367​ {
368​ connect(ann, SIGNAL(triggered()), annSignalMapper, SLOT(map()));
369​ annSignalMapper->setMapping(ann, i++);
370​ }
371​ connect(annSignalMapper, SIGNAL( mapped(int) ), this, SLOT( slotToolSelected(int) ) );
372​
373​ connect( d->m_bookmark, &QAction::triggered, d->m_annotator, &PageViewAnnotator::bookmarkAnnotation );
374​
375​ connect( widthSelectorSignalMapper, SIGNAL( mapped(int) ), this, SLOT( slotSelectAnnotationWidth(int) ) );
376​ connect( opacitySelectorSignalMapper, SIGNAL( mapped(int) ), this, SLOT( slotSelectAnnotationOpacity(int) ) );
377​ connect( d->m_borderColorAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectBorderColor );
378​ connect( d->m_innerColorAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectInnerColor );
379​ connect( d->m_fontAction, &QAction::triggered, this, &AnnotationActionHandler::slotSelectAnnotationFont );
380​ connect( d->m_annAdvancedSettings, &QAction::triggered, this, &AnnotationActionHandler::advancedSettingsTriggered );
381​ connect( pinAnnotationTool, &QAction::toggled , d->m_annotator, &PageViewAnnotator::setContinuousMode );
382​}
383​
384​void AnnotationActionHandler::addFavoriteAnnotations()
385​{
386​ d->m_favorites->removeAllActions();
387​ int favToolID = 1;
388​ QDomElement favToolElement = d->m_annotator->favoriteTool( favToolID );
yurchorUnsubmitted
Done

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

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ while( !favToolElement.isNull() ) {
390​ QString itemText = favToolElement.attribute( "name" );
391​ if ( itemText.isEmpty() )
392​ itemText = PageViewAnnotator::defaultToolName( favToolElement );
393​ QIcon toolIcon = QIcon( PageViewAnnotator::makeToolPixmap( favToolElement ) );
394​ QAction * annFav = new QAction( toolIcon, itemText, this);
395​ d->m_favorites->addAction( annFav );
396​ connect( annFav, &QAction::triggered, [this, favToolID] () { slotFavoriteToolSelected( favToolID ); } );
397​ favToolElement = d->m_annotator->favoriteTool( ++favToolID );
398​ }
399​}
400​
401​AnnotationActionHandler::~AnnotationActionHandler()
402​{
403​ // delete the private data storage structure
404​ delete d;
405​}
406​
407​void AnnotationActionHandler::deselectAllAnnotationActions()
408​{
409​ QAction * currentAction = d->m_annotationToolsGroup->checkedAction();
410​ currentAction->setChecked( false );
411​
412​ d->enableConfigActionsForAnnotation();
413​
414​ d->m_selectedTool = -1;
415​ d->m_annotator->selectTool( -1 );
416​}
417​
418​void AnnotationActionHandler::setToolsEnabled( bool on )
419​{
420​ foreach( QAction * ann, *d->m_annotationTools )
421​ {
422​ ann->setEnabled( on );
423​ }
424​}
425​
426​void AnnotationActionHandler::setTextToolsEnabled( bool on )
427​{
428​ foreach( QAction * ann, *d->m_textAnnotationTools )
429​ {
430​ ann->setEnabled( on );
431​ }
432​}
433​
434​void AnnotationActionHandler::reparseTools()
435​{
436​ d->parseTool( d->m_selectedTool );
437​ addFavoriteAnnotations();
438​}
439​
440​void AnnotationActionHandler::slotToolSelected( int toolID )
441​{
442​ QAction * toolAction = d->m_annotationToolsGroup->actions()[ toolID - 1 ];
443​ if( !toolAction->isChecked() )
444​ toolAction->setChecked( true );
445​ d->m_selectedTool = toolID;
446​ d->parseTool( toolID );
447​ d->m_annotator->selectTool( toolID );
448​}
449​
450​void AnnotationActionHandler::slotFavoriteToolSelected( int favToolID )
451​{
452​ int toolID = d->m_annotator->setFavoriteTool( favToolID );
453​ slotToolSelected( toolID );
454​}
455​
456​void AnnotationActionHandler::slotSelectBorderColor()
457​{
458​ QColor selectedColor = QColorDialog::getColor(d->m_currentBorderColor, nullptr, i18n("Select annotation color") );
459​ if (!selectedColor.isValid())
460​ return;
461​
462​ d->m_currentBorderColor = selectedColor;
463​
464​ d->setBorderColorActionIcon( d->m_currentBorderColor );
465​
466​ if ( d->m_currentInnerColor.alpha() != selectedColor.alpha() && d->m_currentInnerColor.alpha() > 0 ) {
467​ d->m_currentInnerColor.setAlpha( selectedColor.alpha() );
468​ d->setInnerColorActionIcon( d->m_currentInnerColor );
469​ }
470​
471​ d->m_annotator->setAnnotationColor( d->m_currentBorderColor );
472​}
473​
474​void AnnotationActionHandler::slotSelectInnerColor()
475​{
476​ QColor selectedColor = QColorDialog::getColor(d->m_currentInnerColor, nullptr, i18n("Select annotation inner color") );
477​ if (!selectedColor.isValid())
478​ return;
479​
480​ d->m_currentInnerColor = selectedColor;
481​
482​ d->setInnerColorActionIcon( d->m_currentInnerColor );
483​
484​ d->m_annotator->setAnnotationInnerColor( d->m_currentInnerColor );
485​
486​ if ( selectedColor.alpha() > 0 && d->m_currentBorderColor.alpha() != selectedColor.alpha() ) {
487​ d->m_currentBorderColor.setAlpha( selectedColor.alpha() );
488​ d->setBorderColorActionIcon( d->m_currentBorderColor );
489​ d->m_annotator->setAnnotationColor( d->m_currentBorderColor );
490​ }
491​}
492​
493​void AnnotationActionHandler::slotSelectAnnotationFont()
simgunzAuthorUnsubmitted
Done

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

simgunz: This implementation is buggy. How to detect in which main window are we? (Even if we move…
494​{
495​ bool ok;
496​ QFont selectedFont = QFontDialog::getFont(&ok, d->m_currentFont);
497​ if (ok) {
498​ d->m_currentFont = selectedFont;
499​ d->m_annotator->setAnnotationFont( d->m_currentFont );
500​ }
501​}
502​
503​void AnnotationActionHandler::slotSelectAnnotationWidth( int widthNumber )
504​{
505​ d->m_annotator->setAnnotationWidth( widthNumber / 2.0 );
506​}
507​
508​void AnnotationActionHandler::slotSelectAnnotationOpacity( int opacity )
509​{
510​ d->m_annotator->setAnnotationOpacity( opacity / 100.0 );
511​}
512​
513​#include "moc_annotationactionhandler.cpp"