Subversion Repositories Scribus

Rev

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

Rev Author Line No. Line
16546 jghali 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
 
9
#include "propertiespalette_image.h"
10
 
17539 jghali 11
#if defined(_MSC_VER) && !defined(_USE_MATH_DEFINES)
16546 jghali 12
#define _USE_MATH_DEFINES
13
#endif
14
#include <cmath>
21304 jghali 15
#include <QSignalBlocker>
16
 
16546 jghali 17
#include "commonstrings.h"
18
#include "pageitem.h"
19
#include "propertiespalette_utils.h"
21304 jghali 20
#include "sccolorengine.h"
16546 jghali 21
#include "sccombobox.h"
22
#include "scribuscore.h"
23
#include "scraction.h"
24
#include "scribusview.h"
25
#include "selection.h"
26
#include "units.h"
27
#include "undomanager.h"
28
#include "util.h"
29
#include "util_math.h"
30
 
31
PropertiesPalette_Image::PropertiesPalette_Image( QWidget* parent) : QWidget(parent)
32
{
33
        m_ScMW = 0;
34
        m_doc  = 0;
35
        m_haveDoc    = false;
36
        m_haveItem   = false;
20730 jghali 37
        m_item       = 0;
16546 jghali 38
        m_unitRatio  = 1.0;
20730 jghali 39
        m_unitIndex  = 0;
16546 jghali 40
 
41
        m_userActionOn    = false;
42
        userActionSniffer = new UserActionSniffer(this);
43
        connect(userActionSniffer, SIGNAL(actionStart()), this, SLOT(spinboxStartUserAction()));
44
        connect(userActionSniffer, SIGNAL(actionEnd()), this, SLOT(spinboxFinishUserAction()));
45
 
46
        setupUi(this);
17383 fschmid 47
        setSizePolicy( QSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum));
16546 jghali 48
 
49
        imagePageNumber->setMinimum(0);
19395 jghali 50
        imagePageNumber->setSpecialValueText( tr( "Auto" ));
17420 fschmid 51
        imagePageNumber->setDecimals(0);
17613 jghali 52
        imagePageNumber->setSuffix("");
16546 jghali 53
        imagePageNumberLabel->setBuddy(imagePageNumber);
17290 fschmid 54
        installSniffer(imagePageNumber);
16546 jghali 55
 
56
//      freeScale = new QRadioButton( "&Free Scaling", this );
57
//      freeScale->setChecked( true );
58
//      pageLayout_4->addWidget( freeScale );
59
 
60
        xposImgLabel->setBuddy(imageXOffsetSpinBox);
61
        yposImgLabel->setBuddy(imageYOffsetSpinBox);
62
 
63
        imageRotation->setWrapping( true );
17045 fschmid 64
        imageRotation->setNewUnit(6);
16546 jghali 65
        installSniffer(imageRotation);
66
        imageRotationLabel->setBuddy(imageRotation);
67
 
68
        freeScale->setChecked( true );
69
 
70
        installSniffer(imageXScaleSpinBox);
71
        xscaleLabel->setBuddy(imageXScaleSpinBox);
72
        installSniffer(imageYScaleSpinBox);
73
        yscaleLabel->setBuddy(imageYScaleSpinBox);
74
 
75
        keepImageWHRatioButton->setCheckable( true );
76
        keepImageWHRatioButton->setAutoRaise( true );
77
 
17613 jghali 78
        imgDpiX->setSuffix("");
16546 jghali 79
        installSniffer(imgDpiX);
80
        imgDPIXLabel->setBuddy(imgDpiX);
81
 
17613 jghali 82
        imgDpiY->setSuffix("");
16546 jghali 83
        installSniffer(imgDpiY);
84
        imgDPIYLabel->setBuddy(imgDpiY);
85
 
86
        keepImageDPIRatioButton->setCheckable( true );
87
        keepImageDPIRatioButton->setAutoRaise( true );
88
 
19395 jghali 89
        frameScale->setText( tr("&To Frame Size"));
16546 jghali 90
 
91
        cbProportional->setEnabled( false );
92
        cbProportional->setText( "P&roportional" );
93
        cbProportional->setChecked( true );
94
 
95
        languageChange();
96
 
17420 fschmid 97
        connect(imagePageNumber    , SIGNAL(valueChanged(double))   , this, SLOT(handleImagePageNumber()));
16546 jghali 98
        connect(imageXScaleSpinBox , SIGNAL(valueChanged(double)), this, SLOT(handleXScale()));
99
        connect(imageYScaleSpinBox , SIGNAL(valueChanged(double)), this, SLOT(handleYScale()));
100
        connect(imageXOffsetSpinBox, SIGNAL(valueChanged(double)), this, SLOT(handleLocalXY()));
101
        connect(imageYOffsetSpinBox, SIGNAL(valueChanged(double)), this, SLOT(handleLocalXY()));
102
        connect(imageRotation      , SIGNAL(valueChanged(double)), this, SLOT(handleLocalRotation()));
103
        connect(imgDpiX            , SIGNAL(valueChanged(double)), this, SLOT(handleDpiX()));
104
        connect(imgDpiY            , SIGNAL(valueChanged(double)), this, SLOT(handleDpiY()));
105
        connect(keepImageWHRatioButton , SIGNAL(clicked())       , this, SLOT(handleImageWHRatio()));
106
        connect(keepImageDPIRatioButton, SIGNAL(clicked())       , this, SLOT(handleImageDPIRatio()));
107
        connect(freeScale          , SIGNAL(clicked())           , this, SLOT(handleScaling()));
108
        connect(frameScale         , SIGNAL(clicked())           , this, SLOT(handleScaling()));
17747 craig 109
        connect(cbProportional     , SIGNAL(stateChanged(int))   , this, SLOT(handleScaling()));
16546 jghali 110
        connect(imgEffectsButton   , SIGNAL(clicked())           , this, SLOT(handleImageEffects()));
111
        connect(imgExtProperties   , SIGNAL(clicked())           , this, SLOT(handleExtImgProperties()));
112
        connect(inputProfiles      , SIGNAL(activated(const QString&)), this, SLOT(handleProfile(const QString&)));
113
        connect(renderIntent       , SIGNAL(activated(int))      , this, SLOT(handleIntent()));
114
        connect(compressionMethod  , SIGNAL(activated(int))      , this, SLOT(handleCompressionMethod()));
115
        connect(compressionQuality , SIGNAL(activated(int))      , this, SLOT(handleCompressionQuality()));
116
}
117
 
20506 jghali 118
void PropertiesPalette_Image::updateSpinBoxConstants()
119
{
120
        if (!m_haveDoc)
121
                return;
122
        if(m_doc->m_Selection->count()==0)
123
                return;
124
        imageXOffsetSpinBox->setConstants(&m_doc->constants());
125
        imageYOffsetSpinBox->setConstants(&m_doc->constants());
126
}
127
 
16546 jghali 128
void PropertiesPalette_Image::changeEvent(QEvent *e)
129
{
130
        if (e->type() == QEvent::LanguageChange)
131
        {
132
                languageChange();
133
                return;
134
        }
135
        QWidget::changeEvent(e);
136
}
137
 
138
void PropertiesPalette_Image::setMainWindow(ScribusMainWindow* mw)
139
{
140
        m_ScMW = mw;
141
 
142
        connect(m_ScMW, SIGNAL(UpdateRequest(int)), this  , SLOT(handleUpdateRequest(int)));
143
}
144
 
145
void PropertiesPalette_Image::setDoc(ScribusDoc *d)
146
{
147
        if((d == (ScribusDoc*) m_doc) || (m_ScMW && m_ScMW->scriptIsRunning()))
148
                return;
149
 
150
        if (m_doc)
151
        {
152
                disconnect(m_doc->m_Selection, SIGNAL(selectionChanged()), this, SLOT(handleSelectionChanged()));
153
                disconnect(m_doc             , SIGNAL(docChanged())      , this, SLOT(handleSelectionChanged()));
154
        }
155
 
156
        m_doc  = d;
157
        m_item = NULL;
158
        m_unitRatio   = m_doc->unitRatio();
159
        m_unitIndex   = m_doc->unitIndex();
160
        int precision = unitGetPrecisionFromIndex(m_unitIndex);
161
        double maxXYWHVal =  16777215 * m_unitRatio;
162
 
163
        m_haveDoc  = true;
164
        m_haveItem = false;
165
 
166
        imageXOffsetSpinBox->setValues( -16777215, maxXYWHVal, precision, 0);
167
        imageYOffsetSpinBox->setValues( -16777215, maxXYWHVal, precision, 0);
168
 
169
        imageRotation->setValues( 0, 359.99, 1, 0);
170
 
171
        imageXScaleSpinBox->setValues( 1, 30000, 2, 1);
172
        imageYScaleSpinBox->setValues( 1, 30000, 2, 1);
173
        imgDpiX->setValues( 1, 30000, 2, 1);
174
        imgDpiY->setValues( 1, 30000, 2, 1);
20506 jghali 175
        updateSpinBoxConstants();
16546 jghali 176
 
177
        connect(m_doc->m_Selection, SIGNAL(selectionChanged()), this, SLOT(handleSelectionChanged()));
178
        connect(m_doc             , SIGNAL(docChanged())      , this, SLOT(handleSelectionChanged()));
179
}
180
 
181
void PropertiesPalette_Image::unsetDoc()
182
{
183
        if (m_doc)
184
        {
185
                disconnect(m_doc->m_Selection, SIGNAL(selectionChanged()), this, SLOT(handleSelectionChanged()));
186
                disconnect(m_doc             , SIGNAL(docChanged())      , this, SLOT(handleSelectionChanged()));
187
        }
188
 
189
        m_haveDoc  = false;
190
        m_haveItem = false;
191
        m_doc   = NULL;
192
        m_item  = NULL;
193
 
194
        setEnabled(false);
195
}
196
 
197
void PropertiesPalette_Image::unsetItem()
198
{
199
        m_haveItem = false;
200
        m_item     = NULL;
201
        handleSelectionChanged();
202
}
203
 
204
PageItem* PropertiesPalette_Image::currentItemFromSelection()
205
{
206
        PageItem *currentItem = NULL;
207
 
208
        if (m_doc)
209
        {
210
                if (m_doc->m_Selection->count() > 1)
211
                {
212
                        currentItem = m_doc->m_Selection->itemAt(0);
213
                }
214
                else if (m_doc->m_Selection->count() == 1)
215
                {
216
                        currentItem = m_doc->m_Selection->itemAt(0);
217
                }
218
        }
219
 
220
        return currentItem;
221
}
222
 
223
void PropertiesPalette_Image::installSniffer(ScrSpinBox *spinBox)
224
{
225
        const QList<QObject*> list = spinBox->children();
226
        if (!list.isEmpty())
227
        {
228
                QListIterator<QObject*> it(list);
229
                QObject *obj;
230
                while (it.hasNext())
231
                {
232
                        obj = it.next();
233
                        obj->installEventFilter(userActionSniffer);
234
                }
235
        }
236
}
237
 
17290 fschmid 238
void PropertiesPalette_Image::installSniffer(QSpinBox *spinBox)
239
{
240
        const QList<QObject*> list = spinBox->children();
241
        if (!list.isEmpty())
242
        {
243
                QListIterator<QObject*> it(list);
244
                QObject *obj;
245
                while (it.hasNext())
246
                {
247
                        obj = it.next();
248
                        obj->installEventFilter(userActionSniffer);
249
                }
250
        }
251
}
252
 
16546 jghali 253
void PropertiesPalette_Image::updateProfileList()
254
{
255
        if (!m_ScMW || m_ScMW->scriptIsRunning())
256
                return;
257
        if (m_haveDoc)
258
        {
259
                if (ScCore->haveCMS() && m_doc->cmsSettings().CMSinUse)
260
                        colorMgmtGroup->show();
261
                else
262
                {
263
                        colorMgmtGroup->hide();
264
                        return;
265
                }
266
 
267
                inputProfiles->blockSignals(true);
268
                renderIntent->blockSignals(true);
269
 
270
                inputProfiles->clear();
271
                if (m_haveItem)
272
                {
273
                        if (m_item->pixm.imgInfo.colorspace == ColorSpaceCMYK)
274
                        {
275
                                ProfilesL::Iterator itP;
276
                                ProfilesL::Iterator itPend = ScCore->InputProfilesCMYK.end();
277
                                for (itP = ScCore->InputProfilesCMYK.begin(); itP != itPend; ++itP)
278
                                {
279
                                        inputProfiles->addItem(itP.key());
280
                                        if (itP.key() == m_item->IProfile)
281
                                                inputProfiles->setCurrentIndex(inputProfiles->count()-1);
282
                                }
283
                                if (!ScCore->InputProfilesCMYK.contains(m_item->IProfile))
284
                                {
285
                                        inputProfiles->addItem(m_item->IProfile);
286
                                        inputProfiles->setCurrentIndex(inputProfiles->count()-1);
287
                                }
288
                                else
289
                                {
290
                                        if (!m_item->EmProfile.isEmpty())
291
                                                inputProfiles->addItem(m_item->EmProfile);
292
                                }
293
                        }
294
                        else
295
                        {
296
                                ProfilesL::Iterator itP;
297
                                ProfilesL::Iterator itPend=ScCore->InputProfiles.end();
298
                                for (itP = ScCore->InputProfiles.begin(); itP != itPend; ++itP)
299
                                {
300
                                        inputProfiles->addItem(itP.key());
301
                                        if (itP.key() == m_item->IProfile)
302
                                                inputProfiles->setCurrentIndex(inputProfiles->count()-1);
303
                                }
304
                                if (!ScCore->InputProfiles.contains(m_item->IProfile))
305
                                {
306
                                        inputProfiles->addItem(m_item->IProfile);
307
                                        inputProfiles->setCurrentIndex(inputProfiles->count()-1);
308
                                }
309
                                else
310
                                {
311
                                        if (!m_item->EmProfile.isEmpty())
312
                                                inputProfiles->addItem(m_item->EmProfile);
313
                                }
314
                        }
315
                        renderIntent->setCurrentIndex(m_item->IRender);
316
                }
317
 
318
                inputProfiles->blockSignals(false);
319
                renderIntent->blockSignals(false);
320
        }
321
}
322
 
323
void PropertiesPalette_Image::showCMSOptions()
324
{
325
        if (!m_ScMW || m_ScMW->scriptIsRunning())
326
                return;
327
        if (m_haveItem)
328
                updateProfileList();
329
        else if (m_doc)
330
                colorMgmtGroup->setVisible(ScCore->haveCMS() && m_doc->cmsSettings().CMSinUse);
331
}
332
 
18795 jghali 333
void PropertiesPalette_Image::showImageRotation(double rot)
16546 jghali 334
{
335
        if (!m_ScMW || m_ScMW->scriptIsRunning())
336
                return;
337
        double rrR = rot;
338
        if (rot > 0)
339
                rrR = 360 - rrR;
340
        imageRotation->showValue(fabs(rrR));
341
}
342
 
18795 jghali 343
void PropertiesPalette_Image::showScaleAndOffset(double scx, double scy, double x, double y)
16546 jghali 344
{
345
        if (!m_ScMW || m_ScMW->scriptIsRunning())
346
                return;
20967 jghali 347
        bool whRatioBlocked = keepImageWHRatioButton->blockSignals(true);
348
        bool dpiRatioBlocked = keepImageDPIRatioButton->blockSignals(true);
16546 jghali 349
        if (fabs(scx - scy) > 0.0002)
350
        {
351
                keepImageWHRatioButton->setChecked(false);
352
                keepImageDPIRatioButton->setChecked(false);
353
        }
354
        if (m_haveItem)
355
        {
356
                imageXOffsetSpinBox->showValue(x * m_unitRatio * m_item->imageXScale());
357
                imageYOffsetSpinBox->showValue(y * m_unitRatio * m_item->imageYScale());
358
                imageXScaleSpinBox->showValue(scx * 100 / 72.0 * m_item->pixm.imgInfo.xres);
359
                imageYScaleSpinBox->showValue(scy * 100 / 72.0 * m_item->pixm.imgInfo.yres);
360
                imgDpiX->showValue(qRound(720.0 / m_item->imageXScale()) / 10.0);
361
                imgDpiY->showValue(qRound(720.0 / m_item->imageYScale()) / 10.0);
362
        }
363
        else
364
        {
365
                imageXOffsetSpinBox->showValue(x * m_unitRatio);
366
                imageYOffsetSpinBox->showValue(y * m_unitRatio);
367
                imageXScaleSpinBox->showValue(scx * 100);
368
                imageYScaleSpinBox->showValue(scy * 100);
369
                imgDpiX->showValue(72);
370
                imgDpiY->showValue(72);
371
        }
20967 jghali 372
        keepImageWHRatioButton->blockSignals(whRatioBlocked);
373
        keepImageDPIRatioButton->blockSignals(dpiRatioBlocked);
16546 jghali 374
}
375
 
376
void PropertiesPalette_Image::handleSelectionChanged()
377
{
378
        if (!m_haveDoc || !m_ScMW || m_ScMW->scriptIsRunning())
379
                return;
380
 
381
        PageItem* currItem = currentItemFromSelection();
382
        if (m_doc->m_Selection->count() > 1)
383
        {
384
                setEnabled(false);
385
        }
386
        else
387
        {
388
                int itemType = currItem ? (int) currItem->itemType() : -1;
389
                m_haveItem = (itemType != -1);
390
 
391
                switch (itemType)
392
                {
393
                case -1:
394
                        setEnabled(false);
395
                        break;
396
                case PageItem::ImageFrame:
397
                case PageItem::LatexFrame:
398
                case PageItem::OSGFrame:
399
                        setEnabled(currItem->asOSGFrame() == NULL);
400
                        break;
401
                case PageItem::TextFrame:
402
                        setEnabled(false);
403
                        break;
404
                case PageItem::Line:
405
                        setEnabled(false);
406
                        break;
407
                case PageItem::Arc:
408
                case PageItem::ItemType1:
409
                case PageItem::ItemType3:
410
                case PageItem::Polygon:
411
                case PageItem::RegularPolygon:
412
                        setEnabled(false);
413
                        break;
414
                case PageItem::PolyLine:
415
                        setEnabled(false);
416
                        break;
417
                case PageItem::PathText:
418
                        setEnabled(false);
419
                        break;
420
                case PageItem::Symbol:
421
                        setEnabled(false);
422
                        break;
423
                }
424
        }
425
        if (currItem)
426
        {
427
                setCurrentItem(currItem);
428
        }
429
        updateGeometry();
18480 jghali 430
        //repaint();
16546 jghali 431
}
432
 
433
void PropertiesPalette_Image::handleUpdateRequest(int updateFlags)
434
{
435
        if (updateFlags & reqCmsOptionsUpdate)
436
                showCMSOptions();
437
}
438
 
439
void PropertiesPalette_Image::setCurrentItem(PageItem *item)
440
{
441
        if (!m_ScMW || m_ScMW->scriptIsRunning())
442
                return;
21026 craig 443
        //CB We shouldn't really need to process this if our item is the same one
16546 jghali 444
        //maybe we do if the item has been changed by scripter.. but that should probably
445
        //set some status if so.
21026 craig 446
        //FIXME: This won't work until when a canvas deselect happens, m_item must be NULL.
16546 jghali 447
        //if (m_item == i)
448
        //      return;
449
 
450
        if (!m_doc)
451
                setDoc(item->doc());
452
 
453
        m_haveItem = false;
454
        m_item = item;
455
 
456
        if (m_item->asImageFrame())
457
        {
458
                imagePageNumber->blockSignals(true);
19834 craig 459
                if(m_item->imageIsAvailable)
17285 craig 460
                {
461
                        imagePageNumber->setMaximum(m_item->pixm.imgInfo.numberOfPages);
462
                        imagePageNumber->setEnabled(true);
463
                }
464
                else
465
                        imagePageNumber->setEnabled(false);
16546 jghali 466
                imagePageNumber->setValue(m_item->pixm.imgInfo.actualPageNumber);
17285 craig 467
 
16546 jghali 468
                compressionMethod->setCurrentIndex(m_item->OverrideCompressionMethod ? m_item->CompressionMethodIndex + 1 : 0);
469
                compressionQuality->setCurrentIndex(m_item->OverrideCompressionQuality ? m_item->CompressionQualityIndex + 1 : 0);
470
                imagePageNumber->blockSignals(false);
471
 
472
                imageXScaleSpinBox->blockSignals(true);
473
                imageYScaleSpinBox->blockSignals(true);
474
                imageXOffsetSpinBox->blockSignals(true);
475
                imageYOffsetSpinBox->blockSignals(true);
476
                imageRotation->blockSignals(true);
477
 
19834 craig 478
                imgEffectsButton->setVisible(m_item->imageIsAvailable && m_item->isRaster);
479
                imgExtProperties->setVisible(m_item->imageIsAvailable && m_item->pixm.imgInfo.valid);
16546 jghali 480
                bool setter = m_item->ScaleType;
481
                freeScale->setChecked(setter);
482
                frameScale->setChecked(!setter);
483
                if ((m_item->asLatexFrame()) || (m_item->asOSGFrame()))
484
                {
485
                        freeScale->setEnabled(false);
486
                        frameScale->setEnabled(false);
487
                        cbProportional->setEnabled(false);
488
                        imageXScaleSpinBox->setEnabled(false);
489
                        imageYScaleSpinBox->setEnabled(false);
490
                        imgDpiX->setEnabled(false);
491
                        imgDpiY->setEnabled(false);
492
                }
493
                else
494
                {
495
                        imageXScaleSpinBox->setEnabled(setter);
496
                        imageYScaleSpinBox->setEnabled(setter);
497
                        imgDpiX->setEnabled(setter);
498
                        imgDpiY->setEnabled(setter);
499
                        cbProportional->setEnabled(!setter);
500
                        cbProportional->setChecked(m_item->AspectRatio);
501
                        freeScale->setEnabled(true);
502
                        frameScale->setEnabled(true);
17709 craig 503
                        //Necessary for undo action
504
                        keepImageWHRatioButton->setEnabled(setter);
505
                        keepImageDPIRatioButton->setEnabled(setter);
17747 craig 506
                        keepImageWHRatioButton->setChecked(m_item->AspectRatio);
507
                        keepImageDPIRatioButton->setChecked(m_item->AspectRatio);
16546 jghali 508
                }
509
//CB Why do we need this? Setting it too much here
510
//              if (setter == true)
511
//              {
512
//                      keepImageWHRatioButton->setChecked(setter);
513
//                      keepImageDPIRatioButton->setChecked(setter);
514
//              }
515
                //imageXOffsetSpinBox->setEnabled(setter);
516
                //imageYOffsetSpinBox->setEnabled(setter);
517
                //imageRotation->setEnabled(setter);
518
 
519
                imageXScaleSpinBox->blockSignals(false);
520
                imageYScaleSpinBox->blockSignals(false);
521
                imageXOffsetSpinBox->blockSignals(false);
522
                imageYOffsetSpinBox->blockSignals(false);
523
                imageRotation->blockSignals(false);
524
        }
525
        m_haveItem = true;
526
 
18795 jghali 527
        showScaleAndOffset(m_item->imageXScale(), m_item->imageYScale(), m_item->imageXOffset(), m_item->imageYOffset());
16546 jghali 528
        double rrR = m_item->imageRotation();
529
        if (m_item->imageRotation() > 0)
530
                rrR = 360 - rrR;
531
        imageRotation->showValue(fabs(rrR));
532
 
533
        if (m_item->asImageFrame())
534
        {
535
                updateProfileList();
536
        }
537
        if (m_item->asOSGFrame())
538
        {
539
                setEnabled(false);
540
        }
541
        if (m_item->asSymbolFrame())
542
        {
543
                setEnabled(false);
544
        }
20506 jghali 545
        updateSpinBoxConstants();
16546 jghali 546
}
547
 
548
void PropertiesPalette_Image::handleLocalXY()
549
{
550
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
551
                return;
552
        m_doc->itemSelection_SetImageOffset(imageXOffsetSpinBox->value() / m_unitRatio / m_item->imageXScale(), imageYOffsetSpinBox->value() / m_unitRatio / m_item->imageYScale());
553
}
554
 
555
void PropertiesPalette_Image::handleLocalScale()
556
{
557
        if (!m_ScMW || m_ScMW->scriptIsRunning())
558
                return;
559
        if ((m_haveDoc) && (m_haveItem))
560
        {
21026 craig 561
                //CB Don't pass in the scale to the offset change as its taken from the new scale
16546 jghali 562
                m_doc->itemSelection_SetImageScaleAndOffset(imageXScaleSpinBox->value() / 100.0 / m_item->pixm.imgInfo.xres * 72.0, imageYScaleSpinBox->value() / 100.0 / m_item->pixm.imgInfo.yres * 72.0, imageXOffsetSpinBox->value() / m_unitRatio, imageYOffsetSpinBox->value() / m_unitRatio);
563
                imgDpiX->showValue(qRound(720.0 / m_item->imageXScale()) / 10.0);
564
                imgDpiY->showValue(qRound(720.0 / m_item->imageYScale()) / 10.0);
565
        }
566
}
567
 
568
void PropertiesPalette_Image::handleLocalDpi()
569
{
570
        if (!m_ScMW || m_ScMW->scriptIsRunning())
571
                return;
572
        if ((m_haveDoc) && (m_haveItem))
573
        {
21026 craig 574
                //CB Don't pass in the scale to the offset change as its taken from the new scale
16546 jghali 575
                m_doc->itemSelection_SetImageScaleAndOffset(72.0 / imgDpiX->value(), 72.0 / imgDpiY->value(), imageXOffsetSpinBox->value() / m_unitRatio, imageYOffsetSpinBox->value() / m_unitRatio);
576
 
577
                imageXScaleSpinBox->showValue(m_item->imageXScale() * 100 / 72.0 * m_item->pixm.imgInfo.xres);
578
                imageYScaleSpinBox->showValue(m_item->imageYScale() * 100 / 72.0 * m_item->pixm.imgInfo.yres);
579
        }
580
}
581
 
582
void PropertiesPalette_Image::handleLocalRotation()
583
{
584
        if (!m_ScMW || m_ScMW->scriptIsRunning())
585
                return;
586
        if ((m_haveDoc) && (m_haveItem))
17045 fschmid 587
        {
16546 jghali 588
                m_doc->itemSelection_SetImageRotation(360 - imageRotation->value());
17045 fschmid 589
                if (frameScale->isChecked())
590
                        m_item->AdjustPictScale();
591
        }
16546 jghali 592
}
593
 
594
void PropertiesPalette_Image::handleScaling()
595
{
596
        if (!m_ScMW || m_ScMW->scriptIsRunning())
597
                return;
598
 
599
        if (freeScale == sender())
600
        {
601
                frameScale->setChecked(false);
602
                freeScale->setChecked(true);
603
                cbProportional->setEnabled(false);
604
//              imageXOffsetSpinBox->setEnabled(true);
605
//              imageYOffsetSpinBox->setEnabled(true);
606
                imageXScaleSpinBox->setEnabled(true);
607
                imageYScaleSpinBox->setEnabled(true);
608
                imgDpiX->setEnabled(true);
609
                imgDpiY->setEnabled(true);
610
//              imageRotation->setEnabled(true);
611
                keepImageWHRatioButton->setEnabled(true);
612
                keepImageDPIRatioButton->setEnabled(true);
613
        }
614
        if (frameScale == sender())
615
        {
616
                frameScale->setChecked(true);
617
                freeScale->setChecked(false);
618
                cbProportional->setEnabled(true);
619
//              imageXOffsetSpinBox->setEnabled(false);
620
//              imageYOffsetSpinBox->setEnabled(false);
621
                imageXScaleSpinBox->setEnabled(false);
622
                imageYScaleSpinBox->setEnabled(false);
623
                imgDpiX->setEnabled(false);
624
                imgDpiY->setEnabled(false);
625
//              imageRotation->setEnabled(false);
626
                keepImageWHRatioButton->setEnabled(false);
627
                keepImageDPIRatioButton->setEnabled(false);
628
        }
629
 
630
        if ((m_haveDoc) && (m_haveItem))
631
        {
632
                m_item->setImageScalingMode(freeScale->isChecked(), cbProportional->isChecked());
17099 jghali 633
                m_doc->changed();
16546 jghali 634
                emit UpdtGui(PageItem::ImageFrame);
635
        }
636
}
637
 
638
void PropertiesPalette_Image::handleXScale()
639
{
20967 jghali 640
        bool xscaleBlocked = imageXScaleSpinBox->blockSignals(true);
641
        bool yscaleBlocked = imageYScaleSpinBox->blockSignals(true);
16546 jghali 642
        if (keepImageWHRatioButton->isChecked())
643
                imageYScaleSpinBox->setValue(imageXScaleSpinBox->value());
644
        handleLocalScale();
20967 jghali 645
        imageXScaleSpinBox->blockSignals(xscaleBlocked);
646
        imageYScaleSpinBox->blockSignals(yscaleBlocked);
16546 jghali 647
}
648
 
649
void PropertiesPalette_Image::handleYScale()
650
{
20967 jghali 651
        bool xscaleBlocked = imageXScaleSpinBox->blockSignals(true);
652
        bool yscaleBlocked = imageYScaleSpinBox->blockSignals(true);
16546 jghali 653
        if (keepImageWHRatioButton->isChecked())
654
                imageXScaleSpinBox->setValue(imageYScaleSpinBox->value());
655
        handleLocalScale();
20967 jghali 656
        imageXScaleSpinBox->blockSignals(xscaleBlocked);
657
        imageYScaleSpinBox->blockSignals(yscaleBlocked);
16546 jghali 658
}
659
 
660
void PropertiesPalette_Image::handleDpiX()
661
{
20967 jghali 662
        bool dpiXBlocked = imgDpiX->blockSignals(true);
663
        bool dpiYBlocked = imgDpiY->blockSignals(true);
16546 jghali 664
        if (keepImageDPIRatioButton->isChecked())
665
                imgDpiY->setValue(imgDpiX->value());
666
        handleLocalDpi();
20967 jghali 667
        imgDpiX->blockSignals(dpiXBlocked);
668
        imgDpiY->blockSignals(dpiYBlocked);
16546 jghali 669
}
670
 
671
void PropertiesPalette_Image::handleDpiY()
672
{
20967 jghali 673
        bool dpiXBlocked = imgDpiX->blockSignals(true);
674
        bool dpiYBlocked = imgDpiY->blockSignals(true);
16546 jghali 675
        if (keepImageDPIRatioButton->isChecked())
676
                imgDpiX->setValue(imgDpiY->value());
677
        handleLocalDpi();
20967 jghali 678
        imgDpiX->blockSignals(dpiXBlocked);
679
        imgDpiY->blockSignals(dpiYBlocked);
16546 jghali 680
}
681
 
682
void PropertiesPalette_Image::handleImageDPIRatio()
683
{
684
        if (!m_ScMW || m_ScMW->scriptIsRunning())
685
                return;
20967 jghali 686
        bool dpiXBlocked = imgDpiX->blockSignals(true);
687
        bool dpiYBlocked = imgDpiY->blockSignals(true);
16546 jghali 688
        if (keepImageDPIRatioButton->isChecked())
689
        {
20580 jghali 690
                double minXY = qMin(imgDpiX->value(), imgDpiY->value());
691
                imgDpiX->setValue(minXY);
692
                imgDpiY->setValue(minXY);
16546 jghali 693
                handleLocalDpi();
694
                keepImageWHRatioButton->setChecked(true);
17747 craig 695
                cbProportional->setChecked(true);
16546 jghali 696
        }
697
        else
17747 craig 698
        {
16546 jghali 699
                keepImageWHRatioButton->setChecked(false);
17747 craig 700
                cbProportional->setChecked(false);
701
        }
20967 jghali 702
        imgDpiX->blockSignals(dpiXBlocked);
703
        imgDpiY->blockSignals(dpiYBlocked);
16546 jghali 704
}
705
 
706
void PropertiesPalette_Image::handleImageWHRatio()
707
{
708
        if (!m_ScMW || m_ScMW->scriptIsRunning())
709
                return;
20967 jghali 710
        bool xscaleBlocked = imageXScaleSpinBox->blockSignals(true);
711
        bool yscaleBlocked = imageYScaleSpinBox->blockSignals(true);
16546 jghali 712
        if (keepImageWHRatioButton->isChecked())
713
        {
20580 jghali 714
                double maxXY = qMax(imageXScaleSpinBox->value(), imageYScaleSpinBox->value());
715
                imageXScaleSpinBox->setValue(maxXY);
716
                imageYScaleSpinBox->setValue(maxXY);
16546 jghali 717
                handleLocalScale();
718
                keepImageDPIRatioButton->setChecked(true);
17747 craig 719
                cbProportional->setChecked(true);
16546 jghali 720
        }
721
        else
17747 craig 722
        {
16546 jghali 723
                keepImageDPIRatioButton->setChecked(false);
17747 craig 724
                cbProportional->setChecked(false);
725
        }
20967 jghali 726
        imageXScaleSpinBox->blockSignals(xscaleBlocked);
727
        imageYScaleSpinBox->blockSignals(yscaleBlocked);
16546 jghali 728
}
729
 
730
void PropertiesPalette_Image::handleImageEffects()
731
{
732
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
733
                return;
734
        m_ScMW->ImageEffects();
735
}
736
 
737
void PropertiesPalette_Image::handleExtImgProperties()
738
{
739
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
740
                return;
741
        m_ScMW->view->editExtendedImageProperties();
17099 jghali 742
        m_doc->changed();
16546 jghali 743
}
744
 
745
void PropertiesPalette_Image::handleImagePageNumber()
746
{
747
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
748
                return;
749
        bool reallynew = (m_item->pixm.imgInfo.actualPageNumber != imagePageNumber->value());
17747 craig 750
        if(UndoManager::undoEnabled())
751
        {
752
                SimpleState *ss = new SimpleState(Um::PageNmbr.arg(static_cast<int>(imagePageNumber->value())),"",Um::IImageFrame);
20807 jghali 753
                ss->set("IMAGE_NBR");
754
                ss->set("OLD", m_item->pixm.imgInfo.actualPageNumber);
755
                ss->set("NEW", imagePageNumber->value());
17747 craig 756
                UndoManager::instance()->action(m_item,ss);
757
        }
17420 fschmid 758
        m_item->pixm.imgInfo.actualPageNumber = static_cast<int>(imagePageNumber->value());
16546 jghali 759
        if (reallynew)
760
                m_item->loadImage(m_item->externalFile(), true);
761
        m_item->update();
762
}
763
 
764
void PropertiesPalette_Image::handleProfile(const QString& prn)
765
{
766
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
767
                return;
768
        m_doc->itemSelection_SetColorProfile(inputProfiles->currentText());
769
}
770
 
771
void PropertiesPalette_Image::handleIntent()
772
{
773
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
774
                return;
775
        m_doc->itemSelection_SetRenderIntent(renderIntent->currentIndex());
776
}
777
 
778
void PropertiesPalette_Image::handleCompressionMethod()
779
{
780
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
781
                return;
782
        m_doc->itemSelection_SetCompressionMethod(compressionMethod->currentIndex() - 1);
783
}
784
 
785
void PropertiesPalette_Image::handleCompressionQuality()
786
{
787
        if (!m_haveDoc || !m_haveItem || !m_ScMW || m_ScMW->scriptIsRunning())
788
                return;
789
        m_doc->itemSelection_SetCompressionQuality(compressionQuality->currentIndex() - 1);
790
}
791
 
792
void PropertiesPalette_Image::languageChange()
793
{
21035 jghali 794
        retranslateUi(this);
795
 
20429 jghali 796
        imagePageNumber->setSpecialValueText( tr( "Auto" ));
797
 
21304 jghali 798
        QSignalBlocker renderIntentBlocker(renderIntent);
799
        int oldRenderI = renderIntent->currentIndex();
16546 jghali 800
        renderIntent->clear();
801
        renderIntent->addItem( tr("Perceptual"));
802
        renderIntent->addItem( tr("Relative Colorimetric"));
803
        renderIntent->addItem( tr("Saturation"));
804
        renderIntent->addItem( tr("Absolute Colorimetric"));
21304 jghali 805
        renderIntent->setCurrentIndex(oldRenderI);
16546 jghali 806
 
21304 jghali 807
        QSignalBlocker compressionMethodBlocker(compressionMethod);
808
        int oldCompressionMethod = compressionMethod->currentIndex();
16546 jghali 809
        compressionMethod->clear();
810
        compressionMethod->addItem( tr( "Global" ) );
811
        compressionMethod->addItem( tr( "Automatic" ) );
812
        compressionMethod->addItem( tr( "Lossy - JPEG" ) );
813
        compressionMethod->addItem( tr( "Lossless - Zip" ) );
814
        compressionMethod->addItem( tr( "None" ) );
815
        compressionMethod->setCurrentIndex(oldCompressionMethod);
816
 
21304 jghali 817
        QSignalBlocker compressionQualityBlocker(compressionQuality);
818
        int oldCompressionQuality = compressionQuality->currentIndex();
16546 jghali 819
        compressionQuality->clear();
820
        compressionQuality->addItem( tr( "Global" ) );
821
        compressionQuality->addItem( tr( "Maximum" ) );
822
        compressionQuality->addItem( tr( "High" ) );
823
        compressionQuality->addItem( tr( "Medium" ) );
824
        compressionQuality->addItem( tr( "Low" ) );
825
        compressionQuality->addItem( tr( "Minimum" ) );
826
        compressionQuality->setCurrentIndex(oldCompressionQuality);
827
 
828
        QString pctSuffix = tr(" %");
829
        imageXScaleSpinBox->setSuffix(pctSuffix);
830
        imageYScaleSpinBox->setSuffix(pctSuffix);
831
 
832
        QString ptSuffix = tr(" pt");
833
        QString suffix   = (m_haveDoc) ? unitGetSuffixFromIndex(m_doc->unitIndex()) : ptSuffix;
834
 
835
        imageXOffsetSpinBox->setSuffix(suffix);
836
        imageYOffsetSpinBox->setSuffix(suffix);
837
}
838
 
839
void PropertiesPalette_Image::unitChange()
840
{
841
        if (!m_doc)
842
                return;
843
 
844
        m_unitRatio = m_doc->unitRatio();
845
        m_unitIndex = m_doc->unitIndex();
846
 
847
        imageXOffsetSpinBox->blockSignals(true);
848
        imageXOffsetSpinBox->setNewUnit( m_unitIndex );
849
        imageXOffsetSpinBox->blockSignals(false);
850
 
851
        imageYOffsetSpinBox->blockSignals(true);
852
        imageYOffsetSpinBox->setNewUnit( m_unitIndex );
853
        imageYOffsetSpinBox->blockSignals(false);
854
}
855
 
856
bool PropertiesPalette_Image::userActionOn()
857
{
858
        return m_userActionOn;;
859
}
860
 
861
void PropertiesPalette_Image::spinboxStartUserAction()
862
{
863
        m_userActionOn = true;
864
}
865
 
866
void PropertiesPalette_Image::spinboxFinishUserAction()
867
{
868
        m_userActionOn = false;
869
 
870
        for (int i = 0; i < m_doc->m_Selection->count(); ++i)
871
                m_doc->m_Selection->itemAt(i)->checkChanges(true);
872
        if (m_ScMW->view->groupTransactionStarted())
873
        {
874
                m_ScMW->view->endGroupTransaction();
875
        }
876
}
877
 
878