Subversion Repositories Scribus

Rev

Rev 16311 | Rev 18194 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
10928 fschmid 1
/*
2
For general Scribus (>=1.3.2) copyright and licensing information please refer
3
to the COPYING file provided with the program. Following this notice may exist
4
a copyright and/or license notice that predates the release of Scribus 1.3.2
5
for which a new license (GPL+exception) is in place.
6
*/
7
/**************************************************************************
8
*   Copyright (C) 2007 by Franz Schmid                                    *
9
*   franz.schmid@altmuehlnet.de                                           *
10
*                                                                         *
11
*   This program is free software; you can redistribute it and/or modify  *
12
*   it under the terms of the GNU General Public License as published by  *
13
*   the Free Software Foundation; either version 2 of the License, or     *
14
*   (at your option) any later version.                                   *
15
*                                                                         *
16
*   This program is distributed in the hope that it will be useful,       *
17
*   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
18
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
19
*   GNU General Public License for more details.                          *
20
*                                                                         *
21
*   You should have received a copy of the GNU General Public License     *
22
*   along with this program; if not, write to the                         *
23
*   Free Software Foundation, Inc.,                                       *
18122 mrdocs 24
*   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.             *
10928 fschmid 25
***************************************************************************/
26
 
27
#include "lensdialog.h"
14170 jghali 28
#include <cmath>
10928 fschmid 29
#include <QRadialGradient>
30
#include "util_icon.h"
31
#include "selection.h"
32
#include "sccolorengine.h"
10936 fschmid 33
#include "scpattern.h"
10928 fschmid 34
#include "commonstrings.h"
16311 fschmid 35
#include "pageitem_group.h"
10928 fschmid 36
 
10966 fschmid 37
LensItem::LensItem(QRectF geom, LensDialog *parent) : QGraphicsRectItem(geom)
10928 fschmid 38
{
39
        dialog = parent;
10966 fschmid 40
        strength = -100.0;
41
        scaling = 1.0,
42
        handle = -1;
10928 fschmid 43
        setPen(QPen(Qt::black));
44
        QRadialGradient radialGrad(QPointF(0.5, 0.5), 1.0);
45
        radialGrad.setColorAt(0.0, QColor(255, 0, 0, 127));
46
        radialGrad.setColorAt(0.1, QColor(255, 0, 0, 127));
47
        radialGrad.setColorAt(1.0, QColor(255, 255, 255, 0));
48
#if QT_VERSION  >= 0x040301
49
        radialGrad.setCoordinateMode(QGradient::ObjectBoundingMode);
50
#endif
51
        setBrush(radialGrad);
52
        setFlags(QGraphicsItem::ItemIsMovable | QGraphicsItem::ItemIsSelectable);
10966 fschmid 53
        setAcceptsHoverEvents(true);
10928 fschmid 54
}
55
 
10966 fschmid 56
void LensItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
57
{
58
        Q_UNUSED(widget);
59
        painter->setPen(QPen(Qt::black, 1.0 / option->levelOfDetail));
60
        QRadialGradient radialGrad(QPointF(0.5, 0.5), 1.0);
61
        radialGrad.setColorAt(0.0, QColor(255, 0, 0, 127));
62
        radialGrad.setColorAt(0.1, QColor(255, 0, 0, 127));
63
        radialGrad.setColorAt(1.0, QColor(255, 255, 255, 0));
64
#if QT_VERSION  >= 0x040301
65
        radialGrad.setCoordinateMode(QGradient::ObjectBoundingMode);
66
#endif
67
        painter->setBrush(radialGrad);
68
        painter->drawEllipse(rect().toRect());
69
        if (option->state & QStyle::State_Selected)
70
        {
71
                scaling = option->levelOfDetail;
72
                double siz = 6.0 / option->levelOfDetail;
73
                QRectF br = boundingRect();
74
                painter->setBrush(Qt::NoBrush);
75
                painter->setPen(QPen(Qt::red, 1.0 / option->levelOfDetail, Qt::DotLine));
76
                painter->drawRect(br);
77
                painter->setBrush(Qt::red);
78
                painter->setPen(Qt::NoPen);
79
                painter->drawRect(QRectF(br.x() + br.width(), br.y() + br.height(), -siz, -siz));
80
                painter->drawRect(QRectF(br.x() + br.width(), br.y(), -siz, siz));
81
                painter->drawRect(QRectF(br.x(), br.y() + br.height(), siz, -siz));
82
                painter->drawRect(QRectF(br.x(), br.y(), siz, siz));
83
        }
84
}
85
 
86
void LensItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
87
{
88
        mousePoint = event->screenPos();
89
        QRectF br = boundingRect();
90
        double siz = 6.0 / scaling;
91
        if (QRectF(br.x(), br.y(), siz, siz).contains(event->pos()))
92
                handle = 0;
93
        else if (QRectF(br.x() + br.width(), br.y(), -siz, siz).contains(event->pos()))
94
                handle = 1;
95
        else if (QRectF(br.x() + br.width(), br.y() + br.height(), -siz, -siz).contains(event->pos()))
96
                handle = 2;
97
        else if (QRectF(br.x(), br.y() + br.height(), siz, -siz).contains(event->pos()))
98
                handle = 3;
99
        else
100
                handle = -1;
101
        QGraphicsItem::mousePressEvent(event);
102
}
103
 
104
void LensItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
105
{
106
        QRectF r = rect();
107
        double dx = (mousePoint.x() - event->screenPos().x()) / scaling;
108
        if (handle == 0)
109
        {
110
                QPointF tl = r.topLeft();
111
                tl = tl - QPointF(dx, dx);
112
                r.setTopLeft(tl);
113
                setRect(r.normalized());
114
        }
115
        else if (handle == 1)
116
        {
117
                QPointF tl = r.topRight();
118
                tl = tl - QPointF(dx, -dx);
119
                r.setTopRight(tl);
120
                setRect(r.normalized());
121
        }
122
        else if (handle == 2)
123
        {
124
                QPointF tl = r.bottomRight();
125
                tl = tl - QPointF(dx, dx);
126
                r.setBottomRight(tl);
127
                setRect(r.normalized());
128
        }
129
        else if (handle == 3)
130
        {
131
                QPointF tl = r.bottomLeft();
132
                tl = tl - QPointF(dx, -dx);
133
                r.setBottomLeft(tl);
134
                setRect(r.normalized());
135
        }
136
        else
137
                QGraphicsItem::mouseMoveEvent(event);
138
        mousePoint = event->screenPos();
139
        dialog->lensSelected(this);
140
}
141
 
142
void LensItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
143
{
144
        handle = -1;
145
        updateEffect();
146
        QGraphicsItem::mouseReleaseEvent(event);
147
}
148
 
149
void LensItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
150
{
151
        QPainterPath p;
152
        p.addEllipse(rect());
153
        if ((p.contains(event->pos())) && (isSelected()))
154
                qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
155
        else
156
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
157
}
158
 
159
void LensItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
160
{
161
        QPainterPath p;
162
        p.addEllipse(rect());
163
        if (isSelected())
164
        {
165
                if (p.contains(event->pos()))
166
                        qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
167
                else
168
                {
169
                        QRectF br = boundingRect();
170
                        double siz = 6.0 / scaling;
171
                        if (QRectF(br.x(), br.y(), siz, siz).contains(event->pos()))
172
                                qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
173
                        else if (QRectF(br.x() + br.width(), br.y(), -siz, siz).contains(event->pos()))
174
                                qApp->changeOverrideCursor(QCursor(Qt::SizeBDiagCursor));
175
                        else if (QRectF(br.x() + br.width(), br.y() + br.height(), -siz, -siz).contains(event->pos()))
176
                                qApp->changeOverrideCursor(QCursor(Qt::SizeFDiagCursor));
177
                        else if (QRectF(br.x(), br.y() + br.height(), siz, -siz).contains(event->pos()))
178
                                qApp->changeOverrideCursor(QCursor(Qt::SizeBDiagCursor));
179
                        else
180
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
181
                }
182
        }
183
        else
184
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
185
}
186
 
187
void LensItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *)
188
{
189
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
190
}
191
 
10928 fschmid 192
void LensItem::setStrength(double s)
193
{
194
        strength = s;
195
}
196
 
197
QVariant LensItem::itemChange(GraphicsItemChange change, const QVariant &value)
198
{
199
        switch (change)
200
        {
201
                case ItemSelectedChange:
202
                        dialog->lensSelected(this);
203
                        break;
204
                case ItemPositionHasChanged:
205
                        dialog->setLensPositionValues(mapToScene(rect().center()));
206
                        updateEffect();
207
                        break;
208
                default:
209
                        break;
210
        }
211
        return QGraphicsItem::itemChange(change, value);
212
}
213
 
214
void LensItem::updateEffect()
215
{
216
        LensItem *item;
217
        for (int a = 0; a < dialog->origPathItem.count(); a++)
218
        {
219
                QGraphicsPathItem* pItem = dialog->origPathItem[a];
220
                QPainterPath path = dialog->origPath[a];
10936 fschmid 221
                path = pItem->mapToScene(path);
10928 fschmid 222
                for (int b = 0; b < dialog->lensList.count(); b++)
223
                {
224
                        item = dialog->lensList[b];
225
                        path = lensDeform(path, item->mapToScene(item->rect().center()), item->rect().width() / 2.0, item->strength / 100.0);
226
                }
10936 fschmid 227
                path = pItem->mapFromScene(path);
10928 fschmid 228
                pItem->setPath(path);
229
        }
230
}
231
 
232
QPainterPath LensItem::lensDeform(const QPainterPath &source, const QPointF &offset, double m_radius, double s)
233
{
234
        QPainterPath path;
235
        path.addPath(source);
236
        for (int i = 0; i < path.elementCount(); ++i)
237
        {
238
                const QPainterPath::Element &e = path.elementAt(i);
239
                double dx = e.x - offset.x();
240
                double dy = e.y - offset.y();
241
                double len = m_radius - sqrt(dx * dx + dy * dy);
242
                if (len > 0)
243
                        path.setElementPositionAt(i, e.x - s * dx * len / m_radius, e.y - s * dy * len / m_radius);
244
        }
245
        return path;
246
}
247
 
248
LensDialog::LensDialog(QWidget* parent, ScribusDoc *doc) : QDialog(parent)
249
{
250
        setupUi(this);
251
        buttonRemove->setEnabled(false);
252
        setModal(true);
253
        buttonZoomOut->setIcon(QIcon(loadIcon("16/zoom-out.png")));
254
        buttonZoomI->setIcon(QIcon(loadIcon("16/zoom-in.png")));
16115 fschmid 255
        addItemsToScene(doc->m_Selection, doc, 0, 0);
256
        previewWidget->setRenderHint(QPainter::Antialiasing);
257
        previewWidget->setScene(&scene);
258
        isFirst = true;
259
        addLens();
260
        connect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
261
        connect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
262
        connect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
263
        connect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
264
        connect(buttonAdd, SIGNAL(clicked()), this, SLOT(addLens()));
265
        connect(buttonRemove, SIGNAL(clicked()), this, SLOT(removeLens()));
266
        connect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
267
        connect(buttonZoomI, SIGNAL(clicked()), this, SLOT(doZoomIn()));
268
        connect(buttonZoomOut, SIGNAL(clicked()), this, SLOT(doZoomOut()));
269
        connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
270
        connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
271
        connect(&scene, SIGNAL(selectionChanged()), this, SLOT(selectionHasChanged()));
272
}
10928 fschmid 273
 
16115 fschmid 274
void LensDialog::addItemsToScene(Selection* itemSelection, ScribusDoc *doc, QGraphicsPathItem* parentItem, PageItem* parent)
275
{
10928 fschmid 276
        PageItem *currItem;
277
        double gx, gy, gh, gw;
16115 fschmid 278
        itemSelection->setGroupRect();
279
        itemSelection->getGroupRect(&gx, &gy, &gw, &gh);
280
        uint selectedItemCount = itemSelection->count();
10928 fschmid 281
        for (uint i = 0; i < selectedItemCount; ++i)
282
        {
16115 fschmid 283
                currItem = itemSelection->itemAt(i);
16311 fschmid 284
                if (currItem->isGroup())
285
                        currItem->asGroupFrame()->adjustXYPosition();
10928 fschmid 286
                FPointArray path = currItem->PoLine;
10931 fschmid 287
                QPainterPath pp;
288
                if (currItem->itemType() == PageItem::PolyLine)
289
                        pp = path.toQPainterPath(false);
290
                else
291
                        pp = path.toQPainterPath(true);
10928 fschmid 292
                origPath.append(pp);
16115 fschmid 293
                QGraphicsPathItem* pItem = new QGraphicsPathItem(pp, parentItem);
294
                if (parentItem == 0)
10931 fschmid 295
                {
296
                        scene.addItem(pItem);
297
                        pItem->setPos(currItem->xPos() - gx, currItem->yPos() - gy);
10936 fschmid 298
                        pItem->rotate(currItem->rotation());
10931 fschmid 299
                }
300
                else
301
                {
13951 fschmid 302
                        QTransform mm;
10936 fschmid 303
                        mm.rotate(-parent->rotation());
304
                        mm.translate(-parent->xPos(), -parent->yPos());
305
                        pItem->setPos(mm.map(QPointF(currItem->xPos(), currItem->yPos())));
10931 fschmid 306
                }
307
                pItem->setZValue(i);
10928 fschmid 308
                origPathItem.append(pItem);
16115 fschmid 309
                origPageItem.append(currItem);
310
                if (((currItem->fillColor() == CommonStrings::None) && (currItem->GrType == 0)) || (currItem->isGroup()))
10928 fschmid 311
                        pItem->setBrush(Qt::NoBrush);
312
                else
10936 fschmid 313
                {
314
                        if (currItem->GrType != 0)
315
                        {
316
                                if (currItem->GrType != 8)
317
                                {
318
                                        QGradient pat;
319
                                        double x1 = currItem->GrStartX;
320
                                        double y1 = currItem->GrStartY;
321
                                        double x2 = currItem->GrEndX;
322
                                        double y2 = currItem->GrEndY;
323
                                        switch (currItem->GrType)
324
                                        {
325
                                                case 1:
326
                                                case 2:
327
                                                case 3:
328
                                                case 4:
329
                                                case 6:
330
                                                        pat = QLinearGradient(x1, y1,  x2, y2);
331
                                                        break;
332
                                                case 5:
333
                                                case 7:
334
                                                        pat = QRadialGradient(x1, y1, sqrt(pow(x2 - x1, 2) + pow(y2 - y1,2)), x1, y1);
335
                                                        break;
336
                                        }
337
                                        QList<VColorStop*> colorStops = currItem->fill_gradient.colorStops();
338
                                        QColor qStopColor;
339
                                        for( int offset = 0 ; offset < colorStops.count() ; offset++ )
340
                                        {
341
                                                qStopColor = colorStops[ offset ]->color;
342
                                                int h, s, v, sneu, vneu;
343
                                                int shad = colorStops[offset]->shade;
344
                                                qStopColor.getHsv(&h, &s, &v);
345
                                                sneu = s * shad / 100;
346
                                                vneu = 255 - ((255 - v) * shad / 100);
347
                                                qStopColor.setHsv(h, sneu, vneu);
348
                                                qStopColor.setAlphaF(colorStops[offset]->opacity);
349
                                                pat.setColorAt(colorStops[ offset ]->rampPoint, qStopColor);
350
                                        }
351
                                        pItem->setBrush(pat);
352
                                }
353
                                else if ((currItem->GrType == 8) && (!currItem->pattern().isEmpty()) && (doc->docPatterns.contains(currItem->pattern())))
354
                                {
14260 fschmid 355
                                        double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation, patternSkewX, patternSkewY;
356
                                        currItem->patternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation, patternSkewX, patternSkewY);
13951 fschmid 357
                                        QTransform qmatrix;
10936 fschmid 358
                                        qmatrix.translate(patternOffsetX, patternOffsetY);
359
                                        qmatrix.rotate(patternRotation);
14260 fschmid 360
                                        qmatrix.shear(patternSkewX, patternSkewY);
10936 fschmid 361
                                        qmatrix.scale(patternScaleX / 100.0, patternScaleY / 100.0);
14276 fschmid 362
                                        bool mirrorX, mirrorY;
363
                                        currItem->patternFlip(mirrorX, mirrorY);
364
                                        if (mirrorX)
365
                                                qmatrix.scale(-1, 1);
366
                                        if (mirrorY)
367
                                                qmatrix.scale(1, -1);
10936 fschmid 368
                                        QImage pat = *doc->docPatterns[currItem->pattern()].getPattern();
369
                                        QBrush brush = QBrush(pat);
13951 fschmid 370
                                        brush.setTransform(qmatrix);
10936 fschmid 371
                                        pItem->setBrush(brush);
372
                                }
373
                        }
374
                        else
375
                        {
376
                                QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->fillColor()], doc, currItem->fillShade());
377
                                paint.setAlphaF(1.0 - currItem->fillTransparency());
378
                                pItem->setBrush(paint);
379
                        }
380
                }
16115 fschmid 381
                if (currItem->isGroup())
10928 fschmid 382
                        pItem->setPen(Qt::NoPen);
14223 fschmid 383
                else if (currItem->NamedLStyle.isEmpty())
384
                {
385
                        if ((!currItem->strokePattern().isEmpty()) && (doc->docPatterns.contains(currItem->strokePattern())))
386
                        {
14398 fschmid 387
                                double patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation, patternSkewX, patternSkewY, patternSpace;
388
                                currItem->strokePatternTransform(patternScaleX, patternScaleY, patternOffsetX, patternOffsetY, patternRotation, patternSkewX, patternSkewY, patternSpace);
14223 fschmid 389
                                QTransform qmatrix;
390
                                qmatrix.translate(-currItem->lineWidth() / 2.0, -currItem->lineWidth() / 2.0);
391
                                qmatrix.translate(patternOffsetX, patternOffsetY);
392
                                qmatrix.rotate(patternRotation);
14260 fschmid 393
                                qmatrix.shear(patternSkewX, patternSkewY);
14223 fschmid 394
                                qmatrix.scale(patternScaleX / 100.0, patternScaleY / 100.0);
14276 fschmid 395
                                bool mirrorX, mirrorY;
396
                                currItem->strokePatternFlip(mirrorX, mirrorY);
397
                                if (mirrorX)
398
                                        qmatrix.scale(-1, 1);
399
                                if (mirrorY)
400
                                        qmatrix.scale(1, -1);
14223 fschmid 401
                                QImage pat = *doc->docPatterns[currItem->strokePattern()].getPattern();
402
                                QBrush brush = QBrush(pat);
403
                                brush.setTransform(qmatrix);
404
                                pItem->setPen(QPen(brush, currItem->lineWidth(), currItem->lineStyle(), currItem->lineEnd(), currItem->lineJoin()));
405
                        }
406
                        else if (currItem->GrTypeStroke > 0)
407
                        {
408
                                QGradient pat;
409
                                double x1 = currItem->GrStrokeStartX;
410
                                double y1 = currItem->GrStrokeStartY;
411
                                double x2 = currItem->GrStrokeEndX;
412
                                double y2 = currItem->GrStrokeEndY;
413
                                if (currItem->GrTypeStroke == 6)
414
                                        pat = QLinearGradient(x1, y1,  x2, y2);
415
                                else
416
                                        pat = QRadialGradient(x1, y1, sqrt(pow(x2 - x1, 2) + pow(y2 - y1,2)), x1, y1);
417
                                QList<VColorStop*> colorStops = currItem->stroke_gradient.colorStops();
418
                                QColor qStopColor;
419
                                for( int offset = 0 ; offset < colorStops.count() ; offset++ )
420
                                {
421
                                        qStopColor = colorStops[ offset ]->color;
422
                                        int h, s, v, sneu, vneu;
423
                                        int shad = colorStops[offset]->shade;
424
                                        qStopColor.getHsv(&h, &s, &v);
425
                                        sneu = s * shad / 100;
426
                                        vneu = 255 - ((255 - v) * shad / 100);
427
                                        qStopColor.setHsv(h, sneu, vneu);
428
                                        qStopColor.setAlphaF(colorStops[offset]->opacity);
429
                                        pat.setColorAt(colorStops[ offset ]->rampPoint, qStopColor);
430
                                }
431
                                pItem->setPen(QPen(pat, currItem->lineWidth(), currItem->lineStyle(), currItem->lineEnd(), currItem->lineJoin()));
432
                        }
433
                        else if (currItem->lineColor() != CommonStrings::None)
434
                        {
435
                                QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->lineColor()], doc, currItem->lineShade());
436
                                paint.setAlphaF(1.0 - currItem->lineTransparency());
437
                                pItem->setPen(QPen(paint, currItem->lineWidth(), currItem->lineStyle(), currItem->lineEnd(), currItem->lineJoin()));
438
                        }
439
                }
10928 fschmid 440
                else
10936 fschmid 441
                {
14223 fschmid 442
                        if (currItem->lineColor() != CommonStrings::None)
443
                        {
444
                                QColor paint = ScColorEngine::getShadeColorProof(doc->PageColors[currItem->lineColor()], doc, currItem->lineShade());
445
                                paint.setAlphaF(1.0 - currItem->lineTransparency());
446
                                pItem->setPen(QPen(paint, currItem->lineWidth(), currItem->lineStyle(), currItem->lineEnd(), currItem->lineJoin()));
447
                        }
10936 fschmid 448
                }
16115 fschmid 449
                if (currItem->isGroup())
10931 fschmid 450
                {
451
                        pItem->setFlags(QGraphicsItem::ItemClipsChildrenToShape);
16115 fschmid 452
                        Selection tmpSelection(this, false);
453
                        for (int a = 0; a < currItem->groupItemList.count(); a++)
454
                        {
455
                                tmpSelection.addItem(currItem->groupItemList.at(a));
456
                        }
457
                        addItemsToScene(&tmpSelection, doc, pItem, currItem);
10931 fschmid 458
                }
10928 fschmid 459
        }
460
 
461
}
462
 
10932 fschmid 463
void LensDialog::showEvent(QShowEvent *e)
464
{
465
        QDialog::showEvent(e);
466
        if (isFirst)
467
                previewWidget->fitInView(scene.itemsBoundingRect(), Qt::KeepAspectRatio);
468
        isFirst = false;
469
}
470
 
10928 fschmid 471
void LensDialog::doZoomIn()
472
{
473
        previewWidget->scale(2.0, 2.0);
474
}
475
 
476
void LensDialog::doZoomOut()
477
{
478
        previewWidget->scale(0.5, 0.5);
479
}
480
 
481
void LensDialog::addLens()
482
{
483
        disconnect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
484
        disconnect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
485
        disconnect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
486
        disconnect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
10966 fschmid 487
        disconnect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
488
        if (lensList.count() > 0)
489
        {
490
                lensList[currentLens]->setSelected(false);
491
                lensList[currentLens]->update();
492
        }
10928 fschmid 493
        QRectF bBox = scene.itemsBoundingRect();
494
        double r = qMin(bBox.width(), bBox.height());
495
        double x = (bBox.width() - r) / 2.0;
496
        double y = (bBox.height() - r) / 2.0;
497
        LensItem *item = new LensItem(QRectF(x, y, r, r), this);
498
        scene.addItem(item);
499
        lensList.append(item);
500
        currentLens = lensList.count() - 1;
10931 fschmid 501
        item->setZValue(currentLens+999999);
10928 fschmid 502
        spinXPos->setValue(x + r / 2.0);
503
        spinYPos->setValue(y + r / 2.0);
504
        spinRadius->setValue(r / 2.0);
505
        spinStrength->setValue(100.0);
10966 fschmid 506
        buttonMagnify->setChecked(true);
10928 fschmid 507
        lensList[currentLens]->updateEffect();
508
        if (lensList.count() > 1)
509
                buttonRemove->setEnabled(true);
10966 fschmid 510
        lensList[currentLens]->setSelected(true);
10928 fschmid 511
        connect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
512
        connect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
513
        connect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
514
        connect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
10966 fschmid 515
        connect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
10928 fschmid 516
}
517
 
518
void LensDialog::removeLens()
519
{
520
        LensItem *item = lensList.takeAt(currentLens);
521
        scene.removeItem(item);
522
        delete item;
523
        if (lensList.count() > 1)
524
                buttonRemove->setEnabled(true);
525
        else
526
                buttonRemove->setEnabled(false);
527
        currentLens = lensList.count() - 1;
528
        lensList[currentLens]->setSelected(true);
529
        lensList[currentLens]->updateEffect();
10966 fschmid 530
        lensSelected(lensList[currentLens]);
10928 fschmid 531
}
532
 
10966 fschmid 533
void LensDialog::changeLens()
534
{
535
        double s = qAbs(lensList[currentLens]->strength);
536
        if (buttonMagnify->isChecked())
537
                lensList[currentLens]->setStrength(s * -1.0);
538
        else
539
                lensList[currentLens]->setStrength(s);
540
        lensList[currentLens]->updateEffect();
541
}
542
 
543
void LensDialog::selectionHasChanged()
544
{
545
        bool setter = true;
546
        if (scene.selectedItems().count() == 0)
547
                setter = false;
548
        spinXPos->setEnabled(setter);
549
        spinYPos->setEnabled(setter);
550
        spinRadius->setEnabled(setter);
551
        spinStrength->setEnabled(setter);
552
        buttonMagnify->setEnabled(setter);
553
        buttonFishEye->setEnabled(setter);
554
        if (lensList.count() == 1)
555
                buttonRemove->setEnabled(false);
556
        else
557
                buttonRemove->setEnabled(setter);
558
}
559
 
10928 fschmid 560
void LensDialog::lensSelected(LensItem *item)
561
{
562
        disconnect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
563
        disconnect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
564
        disconnect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
565
        disconnect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
10966 fschmid 566
        disconnect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
10928 fschmid 567
        QPointF p = item->mapToScene(item->rect().center());
568
        spinXPos->setValue(p.x());
569
        spinYPos->setValue(p.y());
570
        spinRadius->setValue(item->rect().width() / 2.0);
10966 fschmid 571
        if (item->strength < 0.0)
572
                buttonMagnify->setChecked(true);
573
        else
574
                buttonFishEye->setChecked(true);
575
        spinStrength->setValue(qAbs(item->strength));
10928 fschmid 576
        currentLens = lensList.indexOf(item);
577
        if (currentLens < 0)
578
                currentLens = 0;
579
        connect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
580
        connect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
581
        connect(spinRadius, SIGNAL(valueChanged(double)), this, SLOT(setNewLensRadius(double)));
582
        connect(spinStrength, SIGNAL(valueChanged(double)), this, SLOT(setNewLensStrength(double)));
10966 fschmid 583
        connect(buttonMagnify, SIGNAL(toggled(bool)), this, SLOT(changeLens()));
10928 fschmid 584
}
585
 
586
void LensDialog::setLensPositionValues(QPointF p)
587
{
588
        disconnect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
589
        disconnect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
590
        spinXPos->setValue(p.x());
591
        spinYPos->setValue(p.y());
592
        connect(spinXPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensX(double)));
593
        connect(spinYPos, SIGNAL(valueChanged(double)), this, SLOT(setNewLensY(double)));
594
}
595
 
596
void LensDialog::setNewLensX(double x)
597
{
598
        QRectF r = lensList[currentLens]->rect();
599
        r.moveCenter(QPointF(x, r.center().y()));
600
        lensList[currentLens]->setRect(r);
601
        lensList[currentLens]->updateEffect();
602
}
603
 
604
void LensDialog::setNewLensY(double y)
605
{
606
        QRectF r = lensList[currentLens]->rect();
607
        r.moveCenter(QPointF(r.center().x(), y));
608
        lensList[currentLens]->setRect(r);
609
        lensList[currentLens]->updateEffect();
610
}
611
 
612
void LensDialog::setNewLensRadius(double radius)
613
{
614
        QRectF r = lensList[currentLens]->rect();
615
        QPointF center = r.center();
616
        r.setWidth(radius * 2.0);
617
        r.setHeight(radius * 2.0);
618
        QPointF centerN = r.center();
619
        r.translate(center.x() - centerN.x(), center.y() - centerN.y());
620
        setLensPositionValues(lensList[currentLens]->mapToScene(r.center()));
621
        lensList[currentLens]->setRect(r);
622
        lensList[currentLens]->updateEffect();
623
}
624
 
625
void LensDialog::setNewLensStrength(double s)
626
{
10966 fschmid 627
        if (buttonMagnify->isChecked())
628
                lensList[currentLens]->setStrength(s * -1.0);
629
        else
630
                lensList[currentLens]->setStrength(s);
10928 fschmid 631
        lensList[currentLens]->updateEffect();
632
}