Differential D15580 Diff 59781 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_currentBorderColor( QColor("yellow") ),
36​ m_currentInnerColor( QColor("#00000000") ), m_currentFont( QFont() ),
37​ m_annotator( nullptr )
38​ {
39​ }
40​
41​ QIcon colorizeIcon(QIcon &icon, const QColor &color);
42​ void setBorderColorActionIcon( QColor color );
43​ void setInnerColorActionIcon( QColor color );
44​ void enableConfigActionsForAnnotation( QString annotType );
45​
46​ QIcon widthIcon( double width );
47​ QIcon opacityIcon( int opacity );
48​
49​ AnnotationActionHandler * q;
50​
51​ QList<QAction *> * m_annotationTools;
52​ QList<QAction *> * m_textAnnotationTools;
53​ QActionGroup * m_annotationToolsGroup;
54​
55​ QAction * m_borderColorAction;
56​ QAction * m_innerColorAction;
57​ KSelectAction * m_opacityAction;
58​ QAction * m_fontAction;
59​ KSelectAction * m_widthAction;
60​ QAction * m_annAdvancedSettings;
61​
62​ QColor m_currentBorderColor;
63​ QColor m_currentInnerColor;
64​ QFont m_currentFont;
65​ int m_currentWidth;
66​
67​ PageViewAnnotator * m_annotator;
68​};
69​
70​QIcon AnnotationActionHandlerPrivate::colorizeIcon(QIcon &icon, const QColor &color)
71​{
72​ //FIXME: Use GuiUtils::colorize if possible instead or write a decent version of this method
73​ QPixmap iconPixmap = icon.pixmap(32, 32);
74​ QBitmap mask = iconPixmap.createMaskFromColor(QColor(Qt::transparent), Qt::MaskInColor);
75​ iconPixmap.fill(color);
76​ iconPixmap.setMask(mask);
77​ return QIcon(iconPixmap);
78​}
79​
80​void AnnotationActionHandlerPrivate::setBorderColorActionIcon( QColor color )
81​{
82​ // Cannot use the current icon of m_borderColorAction to define the mask to avoid trubles
83​ // the alpha channel is zero
84​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
85​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
86​ m_borderColorAction->setIcon( colorizedColorPicker );
87​}
88​
89​void AnnotationActionHandlerPrivate::setInnerColorActionIcon( QColor color )
90​{
91​ // Cannot use the current icon of m_borderColorAction to define the mask to avoid trubles
92​ // the alpha channel is zero
93​ QIcon icon = QIcon::fromTheme( QStringLiteral("color-picker") );
94​ QIcon colorizedColorPicker = colorizeIcon( icon, color );
95​ m_innerColorAction->setIcon( colorizedColorPicker );
96​}
97​
98​void AnnotationActionHandlerPrivate::enableConfigActionsForAnnotation( QString annotType = "none" )
99​{
100​ if( annotType == QStringLiteral( "note-inline" ) || annotType == QStringLiteral( "typewriter" ) ) {
101​ m_fontAction->setEnabled( true );
102​ } else {
103​ m_fontAction->setEnabled( false );
104​ }
105​ if( annotType == QStringLiteral( "stamp" ) || annotType == QStringLiteral( "none" ) ) {
106​ m_borderColorAction->setEnabled( false );
107​ } else {
108​ m_borderColorAction->setEnabled( true );
109​ }
110​ if( annotType == QStringLiteral( "rectangle" ) || annotType == QStringLiteral( "ellipse" )
111​ || annotType == QStringLiteral( "polygon" ) || annotType == QStringLiteral( "note-inline" ) ) {
112​ m_innerColorAction->setEnabled( true );
113​ } else {
114​ m_innerColorAction->setEnabled( false );
115​ }
116​ if( annotType == QStringLiteral( "ink" ) ||
117​ annotType == QStringLiteral( "straight-line" ) || annotType == QStringLiteral( "rectangle" )
118​ || annotType == QStringLiteral( "ellipse" ) || annotType == QStringLiteral( "polygon" ) )
119​ {
120​ m_widthAction->setEnabled( true );
121​ } else {
122​ m_widthAction->setEnabled( false );
123​ }
124​ if ( annotType == QStringLiteral( "none" ) ) {
125​ m_annAdvancedSettings->setEnabled( false );
126​ } else {
127​ m_annAdvancedSettings->setEnabled( true );
128​ }
129​}
130​
131​QIcon AnnotationActionHandlerPrivate::widthIcon( double width )
132​{
aacidUnsubmitted
Done

no i18n?

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

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

yurchor: May it be a complete ellipsis, for consistency (.. -> ...)?
389​ if( annElement.hasAttribute( QStringLiteral( "opacity" ) ) ) {
390​ int opacity = annElement.attribute( QStringLiteral( "opacity" ) ).toDouble();
391​ d->m_opacityAction->setCurrentItem( int( 100 * opacity) );
392​ }
393​
394​ d->enableConfigActionsForAnnotation( annotType );
395​}
396​
397​void AnnotationActionHandler::slotToolSelected( int toolID )
398​{
399​ parseTool( toolID );
400​ d->m_annotator->selectTool( toolID );
401​}
402​
403​void AnnotationActionHandler::slotSelectBorderColor()
404​{
405​ QColor selectedColor = QColorDialog::getColor(d->m_currentBorderColor, nullptr, i18n("Select annotation color") );
406​ if (!selectedColor.isValid())
407​ return;
408​
409​ d->m_currentBorderColor = selectedColor;
410​
411​ d->setBorderColorActionIcon( d->m_currentBorderColor );
412​
413​ if ( d->m_currentInnerColor.alpha() != selectedColor.alpha() && d->m_currentInnerColor.alpha() > 0 ) {
414​ d->m_currentInnerColor.setAlpha( selectedColor.alpha() );
415​ d->setInnerColorActionIcon( d->m_currentInnerColor );
416​ }
417​
418​ d->m_annotator->setAnnotationColor( d->m_currentBorderColor );
419​}
420​
421​void AnnotationActionHandler::slotSelectInnerColor()
422​{
423​ QColor selectedColor = QColorDialog::getColor(d->m_currentInnerColor, nullptr, i18n("Select annotation inner color") );
424​ if (!selectedColor.isValid())
425​ return;
426​
427​ d->m_currentInnerColor = selectedColor;
428​
429​ d->setInnerColorActionIcon( d->m_currentInnerColor );
430​
431​ d->m_annotator->setAnnotationInnerColor( d->m_currentInnerColor );
432​
433​ if ( selectedColor.alpha() > 0 && d->m_currentBorderColor.alpha() != selectedColor.alpha() ) {
434​ d->m_currentBorderColor.setAlpha( selectedColor.alpha() );
435​ d->setBorderColorActionIcon( d->m_currentBorderColor );
436​ d->m_annotator->setAnnotationColor( d->m_currentBorderColor );
437​ }
438​}
439​
440​void AnnotationActionHandler::slotSelectAnnotationFont()
441​{
442​ bool ok;
443​ QFont selectedFont = QFontDialog::getFont(&ok, d->m_currentFont);
444​ if (ok) {
445​ d->m_currentFont = selectedFont;
446​ d->m_annotator->setAnnotationFont( d->m_currentFont );
447​ }
448​}
449​
450​void AnnotationActionHandler::slotSelectAnnotationWidth( int widthNumber )
451​{
452​ d->m_annotator->setAnnotationWidth( widthNumber / 2.0 );
453​}
454​
455​void AnnotationActionHandler::slotSelectAnnotationOpacity( int opacity )
456​{
457​ d->m_annotator->setAnnotationOpacity( opacity / 100.0 );
458​}
459​
460​#include "moc_annotationactionhandler.cpp"
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…