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

no i18n?

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

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

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ d->m_favorites->addAction( annFav );
390​ connect( annFav, &QAction::triggered, [this, favToolID] () { slotFavoriteToolSelected( favToolID ); } );
391​ favToolElement = d->m_annotator->favoriteTool( ++favToolID );
392​ }
393​}
394​
395​AnnotationActionHandler::~AnnotationActionHandler()
396​{
397​ // delete the private data storage structure
398​ delete d;
399​}
400​
401​void AnnotationActionHandler::deselectAllAnnotationActions()
402​{
403​ QAction * checkedAction = d->m_annotationToolsGroup->checkedAction();
404​ if( checkedAction )
405​ checkedAction->trigger();
406​}
407​
408​void AnnotationActionHandler::setToolsEnabled( bool on )
409​{
410​ foreach( QAction * ann, d->m_annotationToolsGroup->actions() ) {
411​ ann->setEnabled( on );
412​ }
413​ d->m_favorites->setEnabled( on && d->m_favorites->actions().count() > 0 );
414​ d->m_continuousModeAction->setEnabled( on );
415​}
416​
417​void AnnotationActionHandler::setTextToolsEnabled( bool on )
418​{
419​ foreach( QAction * ann, *d->m_textAnnotationTools ) {
420​ ann->setEnabled( on );
421​ }
422​}
423​
424​void AnnotationActionHandler::reparseTools()
425​{
426​ d->parseTool( d->m_selectedTool );
427​ addFavoriteAnnotations();
428​}
429​
430​void AnnotationActionHandler::slotToolSelected( int toolID )
431​{
432​ d->m_selectedTool = toolID;
433​ d->parseTool( toolID );
434​ d->m_annotator->selectTool( toolID );
435​}
436​
437​void AnnotationActionHandler::slotFavoriteToolSelected( int favToolID )
438​{
439​ int toolID = d->m_annotator->setFavoriteTool( favToolID );
440​ d->m_annotationToolsGroup->actions()[ toolID - 1 ]->trigger();
441​}
442​
443​void AnnotationActionHandler::slotSelectColor()
444​{
445​ QColor selectedColor = QColorDialog::getColor(d->m_currentColor, nullptr, i18n("Select annotation color") );
446​ if (!selectedColor.isValid())
447​ return;
448​
449​ d->m_currentColor = selectedColor;
450​
451​ d->setColorActionIcon( d->m_currentColor );
452​
453​ if ( d->m_currentInnerColor.alpha() != selectedColor.alpha() && d->m_currentInnerColor.alpha() > 0 ) {
454​ d->m_currentInnerColor.setAlpha( selectedColor.alpha() );
455​ d->setInnerColorActionIcon( d->m_currentInnerColor );
456​ }
457​
458​ d->m_annotator->setAnnotationColor( d->m_currentColor );
459​}
460​
461​void AnnotationActionHandler::slotSelectInnerColor()
462​{
463​ QColor selectedColor = QColorDialog::getColor(d->m_currentInnerColor, nullptr, i18n("Select annotation inner color") );
464​ if (!selectedColor.isValid())
465​ return;
466​
467​ d->m_currentInnerColor = selectedColor;
468​
469​ d->setInnerColorActionIcon( d->m_currentInnerColor );
470​
471​ d->m_annotator->setAnnotationInnerColor( d->m_currentInnerColor );
472​
473​ if ( selectedColor.alpha() > 0 && d->m_currentColor.alpha() != selectedColor.alpha() ) {
474​ d->m_currentColor.setAlpha( selectedColor.alpha() );
475​ d->setColorActionIcon( d->m_currentColor );
476​ d->m_annotator->setAnnotationColor( d->m_currentColor );
477​ }
478​}
479​
480​void AnnotationActionHandler::slotSelectAnnotationFont()
481​{
482​ bool ok;
483​ QFont selectedFont = QFontDialog::getFont(&ok, d->m_currentFont);
484​ if (ok) {
485​ d->m_currentFont = selectedFont;
486​ d->m_annotator->setAnnotationFont( d->m_currentFont );
487​ }
488​}
489​
490​void AnnotationActionHandler::slotSelectAnnotationWidth( int widthNumber )
491​{
492​ d->m_annotator->setAnnotationWidth( widthNumber / 2.0 );
493​}
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​void AnnotationActionHandler::slotSelectAnnotationOpacity( int opacity )
496​{
497​ d->m_annotator->setAnnotationOpacity( opacity / 100.0 );
498​}
499​
500​#include "moc_annotationactionhandler.cpp"