Subversion Repositories Scribus

Rev

Rev 24467 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4430 cbradney 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
*/
3614 cbradney 7
/***************************************************************************
8
                          pageitem.cpp  -  description
9
                             -------------------
10
    begin                : Sat Apr 7 2001
11
    copyright            : (C) 2001 by Franz Schmid
12
    email                : Franz.Schmid@altmuehlnet.de
13
 ***************************************************************************/
14
 
15
/***************************************************************************
16
 *                                                                         *
17
 *   This program is free software; you can redistribute it and/or modify  *
18
 *   it under the terms of the GNU General Public License as published by  *
19
 *   the Free Software Foundation; either version 2 of the License, or     *
20
 *   (at your option) any later version.                                   *
21
 *                                                                         *
22
 ***************************************************************************/
23
 
11645 fschmid 24
// #include <QDebug>
16546 jghali 25
#include <QApplication>
21563 jghali 26
#include <QFontInfo>
10862 cbradney 27
#include <QGridLayout>
8501 cbradney 28
#include <QKeyEvent>
10220 cbradney 29
 
3614 cbradney 30
#include <cmath>
31
#include <cassert>
32
 
20478 jghali 33
#include "scconfig.h"
34
 
35
#include "appmodes.h"
36
#include "commonstrings.h"
16105 fschmid 37
#include "filewatcher.h"
3614 cbradney 38
#include "pageitem.h"
10862 cbradney 39
#include "pageitem_imageframe.h"
3614 cbradney 40
#include "prefsmanager.h"
10601 mrdocs 41
#include "scraction.h"
16736 jghali 42
#include "scpage.h"
3614 cbradney 43
#include "scpaths.h"
10601 mrdocs 44
#include "scpainter.h"
3614 cbradney 45
#include "scribusstructs.h"
16105 fschmid 46
#include "scribuscore.h"
3614 cbradney 47
#include "scribusdoc.h"
20478 jghali 48
#include "scribusview.h"
49
 
3614 cbradney 50
#include "undomanager.h"
51
#include "undostate.h"
22417 jghali 52
#include "undotransaction.h"
10601 mrdocs 53
#include "util_formats.h"
54
#include "util_color.h"
3614 cbradney 55
#include "util.h"
56
 
57
 
22598 craig 58
PageItem_ImageFrame::PageItem_ImageFrame(ScribusDoc *pa, double x, double y, double w, double h, double w2, const QString& fill, const QString& outline)
3614 cbradney 59
        : PageItem(pa, PageItem::ImageFrame, x, y, w, h, w2, fill, outline)
60
{
61
}
62
 
16105 fschmid 63
PageItem_ImageFrame::~PageItem_ImageFrame()
64
{
19834 craig 65
        if ((imageIsAvailable) && (!Pfile.isEmpty()))
16105 fschmid 66
        {
67
                ScCore->fileWatcher->removeFile(Pfile);
68
                QFileInfo fi(Pfile);
69
                ScCore->fileWatcher->removeDir(fi.absolutePath());
70
        }
71
}
72
 
24739 jghali 73
void PageItem_ImageFrame::DrawObj_Item(ScPainter *p, const QRectF& /*e*/)
3614 cbradney 74
{
17288 jghali 75
        if (m_Doc->RePos)
76
                return;
22832 craig 77
        if (m_Doc->layerOutline(m_layerID))
17288 jghali 78
                return;
79
 
80
        p->setFillRule(true);
81
        if ((fillColor() != CommonStrings::None) || (GrType != 0))
3614 cbradney 82
        {
17288 jghali 83
                p->setupPolygon(&PoLine);
84
                p->fillPath();
85
        }
86
        p->save();
87
        if (Pfile.isEmpty())
88
        {
18007 craig 89
                if ((drawFrame()) && (m_Doc->guidesPrefs().framesShown))
3614 cbradney 90
                {
17288 jghali 91
                        p->setPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
18095 craig 92
                        p->drawLine(FPoint(0, 0), FPoint(m_width, m_height));
93
                        p->drawLine(FPoint(0, m_height), FPoint(m_width, 0));
17288 jghali 94
                }
95
        }
24739 jghali 96
        else if ((!m_imageVisible) || (!imageIsAvailable))
17288 jghali 97
        {
98
                //If we are missing our image, draw a red cross in the frame
24739 jghali 99
                if ((drawFrame()) && (m_Doc->guidesPrefs().framesShown))
17288 jghali 100
                {
24739 jghali 101
                        p->setBrush(Qt::white);
102
                        QString htmlText = "";
103
                        QFileInfo fi(Pfile);
104
                        if (imageIsAvailable)
5572 fschmid 105
                        {
24739 jghali 106
                                p->setPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
107
                                if (isInlineImage)
108
                                        htmlText.append( tr("Embedded Image") + "\n");
109
                                else
110
                                        htmlText.append( tr("File:") + " " + fi.fileName() + "\n");
111
                                htmlText.append( tr("Original PPI:") + " " + QString::number(pixm.imgInfo.xres)+" x "+QString::number(pixm.imgInfo.yres) + "\n");
112
                                htmlText.append( tr("Actual PPI:") + " " + QString::number(qRound(72.0 / imageXScale()))+" x "+ QString::number(qRound(72.0 / imageYScale())) + "\n");
113
                                htmlText.append( tr("Size:") + " " + QString::number(OrigW) + " x " + QString::number(OrigH) + "\n");
114
                                htmlText.append( tr("Colorspace:") + " ");
115
                                QString ext = fi.suffix().toLower();
116
                                if ((extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext)) && (pixm.imgInfo.type != ImageType7))
117
                                        htmlText.append( tr("Unknown"));
118
                                else
119
                                        htmlText.append(colorSpaceText(pixm.imgInfo.colorspace));
120
                                if (pixm.imgInfo.numberOfPages > 1)
3614 cbradney 121
                                {
24739 jghali 122
                                        htmlText.append("\n");
123
                                        if (pixm.imgInfo.actualPageNumber > 0)
124
                                                htmlText.append( tr("Page:") + " " + QString::number(pixm.imgInfo.actualPageNumber) + "/" + QString::number(pixm.imgInfo.numberOfPages));
17288 jghali 125
                                        else
24739 jghali 126
                                                htmlText.append( tr("Pages:") + " " + QString::number(pixm.imgInfo.numberOfPages));
3614 cbradney 127
                                }
17288 jghali 128
                        }
24739 jghali 129
                        else
130
                        {
131
                                p->setPen(Qt::red, 1, Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin);
132
                                htmlText = fi.fileName();
133
                        }
134
                        p->drawLine(FPoint(0, 0), FPoint(m_width, m_height));
135
                        p->drawLine(FPoint(0, m_height), FPoint(m_width, 0));
136
                        const QFont &font = QApplication::font();
137
                        p->setFont(PrefsManager::instance().appPrefs.fontPrefs.AvailFonts.findFont(font.family(), QFontInfo(font).styleName()), font.pointSizeF());
138
                        p->drawText(QRectF(0.0, 0.0, m_width, m_height), htmlText);
17288 jghali 139
                }
24739 jghali 140
        }
141
        else
142
        {
143
                p->setupPolygon(&PoLine);
144
                p->setClipPath();
145
                if (imageFlippedH())
17288 jghali 146
                {
24739 jghali 147
                        p->translate(m_width, 0);
148
                        p->scale(-1, 1);
149
                }
150
                if (imageFlippedV())
151
                {
152
                        p->translate(0, m_height);
153
                        p->scale(1, -1);
154
                }
155
                if (!imageClip.empty())
156
                {
157
                        p->setupPolygon(&imageClip);
17288 jghali 158
                        p->setClipPath();
24739 jghali 159
                }
160
                p->translate(m_imageXOffset*m_imageXScale, m_imageYOffset*m_imageYScale);
161
                p->rotate(m_imageRotation);
162
                double mscalex = 1.0 / m_imageXScale;
163
                double mscaley = 1.0 / m_imageYScale;
164
                p->scale(m_imageXScale, m_imageYScale);
165
                if (pixm.imgInfo.lowResType != 0)
166
                {
167
                        p->scale(pixm.imgInfo.lowResScale, pixm.imgInfo.lowResScale);
168
                        mscalex *= 1.0 / pixm.imgInfo.lowResScale;
169
                        mscaley *= 1.0 / pixm.imgInfo.lowResScale;
170
                }
171
                if ((GrMask == GradMask_Linear) || (GrMask == GradMask_Radial) || (GrMask == GradMask_LinearLumAlpha) || (GrMask == GradMask_RadialLumAlpha))
172
                {
173
                        if ((GrMask == GradMask_Linear) || (GrMask == GradMask_Radial))
174
                                p->setMaskMode(1);
175
                        else
176
                                p->setMaskMode(3);
177
                        if ((!gradientMaskVal.isEmpty()) && (!m_Doc->docGradients.contains(gradientMaskVal)))
178
                                gradientMaskVal = "";
179
                        if (!(gradientMaskVal.isEmpty()) && (m_Doc->docGradients.contains(gradientMaskVal)))
180
                                mask_gradient = m_Doc->docGradients[gradientMaskVal];
181
                        p->mask_gradient = mask_gradient;
182
                        if ((GrMask == GradMask_Linear) || (GrMask == GradMask_LinearLumAlpha))
183
                                p->setGradientMask(VGradient::linear, FPoint(GrMaskStartX * mscalex, GrMaskStartY * mscaley), FPoint(GrMaskEndX * mscalex, GrMaskEndY * mscaley), FPoint(GrMaskStartX * mscalex, GrMaskStartY * mscaley), GrMaskScale, GrMaskSkew);
184
                        else
185
                                p->setGradientMask(VGradient::radial, FPoint(GrMaskStartX * mscalex, GrMaskStartY * mscaley), FPoint(GrMaskEndX * mscalex, GrMaskEndY * mscaley), FPoint(GrMaskFocalX * mscalex, GrMaskFocalY * mscaley), GrMaskScale, GrMaskSkew);
186
                }
187
                else if ((GrMask == GradMask_Pattern) || (GrMask == GradMask_PatternLumAlpha) || (GrMask == GradMask_PatternLumAlphaInverted) || (GrMask == GradMask_PatternInverted))
188
                {
189
                        if ((patternMaskVal.isEmpty()) || (!m_Doc->docPatterns.contains(patternMaskVal)))
190
                                p->setMaskMode(0);
191
                        else
17288 jghali 192
                        {
24739 jghali 193
                                p->setPatternMask(&m_Doc->docPatterns[patternMaskVal], patternMaskScaleX * mscalex, patternMaskScaleY * mscaley, patternMaskOffsetX, patternMaskOffsetY, patternMaskRotation, patternMaskSkewX, patternMaskSkewY, patternMaskMirrorX, patternMaskMirrorY);
194
                                if (GrMask == GradMask_Pattern)
195
                                        p->setMaskMode(2);
196
                                else if (GrMask == GradMask_PatternLumAlpha)
197
                                        p->setMaskMode(4);
198
                                else if (GrMask == GradMask_PatternLumAlphaInverted)
199
                                        p->setMaskMode(5);
17288 jghali 200
                                else
24739 jghali 201
                                        p->setMaskMode(6);
17288 jghali 202
                        }
3614 cbradney 203
                }
24739 jghali 204
                else
205
                        p->setMaskMode(0);
206
                p->drawImage(pixm.qImagePtr());
3614 cbradney 207
        }
17288 jghali 208
        p->restore();
3614 cbradney 209
}
3627 cbradney 210
 
211
void PageItem_ImageFrame::clearContents()
212
{
17224 craig 213
        if (UndoManager::undoEnabled())
214
        {
24739 jghali 215
                auto *is = new ScItemState<ScImageEffectList>(Um::ClearImage + "\n" + Pfile, "");
20806 jghali 216
                is->set("CLEAR_IMAGE");
17224 craig 217
                is->set("CI_PFILE", Pfile);
218
                is->set("CI_FLIPPH",imageFlippedH());
219
                is->set("CI_FLIPPV",imageFlippedV());
220
                is->set("CI_SCALING",ScaleType);
221
                is->set("CI_ASPECT",AspectRatio);
222
                is->set("CI_XOFF",imageXOffset());
223
                is->set("CI_XSCALE",imageXScale());
224
                is->set("CI_YOFF",imageYOffset());
225
                is->set("CI_YSCALE",imageYScale());
226
                is->set("CI_FILLT", fillTransparency());
227
                is->set("CI_LINET", lineTransparency());
228
                is->setItem(effectsInUse);
229
                undoManager->action(this, is);
230
        }
3955 fschmid 231
        effectsInUse.clear();
19834 craig 232
        imageIsAvailable = false;
23488 jghali 233
        Pfile.clear();
3627 cbradney 234
        pixm = ScImage();
4546 subik 235
 
18022 craig 236
        m_imageXScale = 1;
237
        m_imageYScale = 1;
3627 cbradney 238
        OrigW = 0;
239
        OrigH = 0;
18032 craig 240
        m_imageXOffset = 0;
241
        m_imageYOffset = 0;
3627 cbradney 242
        setImageFlippedH(false);
243
        setImageFlippedV(false);
23488 jghali 244
        EmbeddedProfile.clear();
245
        UseEmbedded = true; // Otherwise embedded profile will never be used when reloading image
24467 jghali 246
        ScaleType = m_Doc->prefsData().itemToolPrefs.imageScaleType;
19276 jghali 247
        AspectRatio = m_Doc->prefsData().itemToolPrefs.imageAspectRatio;
3627 cbradney 248
        setFillTransparency(0.0);
249
        setLineTransparency(0.0);
250
        imageClip.resize(0);
18203 fschmid 251
        if ((isTempFile) && (!Pfile.isEmpty()))
252
                QFile::remove(Pfile);
253
        isTempFile = false;
12795 fschmid 254
        isInlineImage = false;
4546 subik 255
        //                              emit UpdtObj(Doc->currentPage->pageNr(), ItemNr);
3627 cbradney 256
}
257
 
5226 cbradney 258
void PageItem_ImageFrame::handleModeEditKey(QKeyEvent *k, bool& keyRepeat)
259
{
260
        double moveBy=1.0;
10390 cbradney 261
        Qt::KeyboardModifiers buttonModifiers = k->modifiers();
10398 cbradney 262
        bool controlDown=(buttonModifiers & Qt::ControlModifier);
263
        bool altDown=(buttonModifiers & Qt::AltModifier);
264
        bool shiftDown=(buttonModifiers & Qt::ShiftModifier);
5727 cbradney 265
        bool resizingImage=false;
10390 cbradney 266
        if (shiftDown && !controlDown)
5226 cbradney 267
                moveBy=10.0;
10390 cbradney 268
        else if (shiftDown && controlDown && !altDown)
5226 cbradney 269
                moveBy=0.1;
10390 cbradney 270
        else if (shiftDown && controlDown && altDown)
5226 cbradney 271
                moveBy=0.01;
10390 cbradney 272
        else if (!shiftDown && altDown)
5727 cbradney 273
                resizingImage=true;
20478 jghali 274
 
5226 cbradney 275
        double dX=0.0,dY=0.0;
276
        int kk = k->key();
20478 jghali 277
        ScribusView* view = m_Doc->view();
278
 
279
        if (kk == Qt::Key_Delete || kk == Qt::Key_Backspace || (shiftDown && controlDown && kk == Qt::Key_Delete) )     // Delete in edit mode, to empty the frame
5226 cbradney 280
        {
20478 jghali 281
                clearContents();
282
                view->requestMode(modeNormal);
283
                update();
284
        }
285
        else if (!resizingImage)
286
        {
5727 cbradney 287
                moveBy/=m_Doc->unitRatio();//Lets allow movement by the current doc ratio, not only points
288
                switch (kk)
289
                {
8523 cbradney 290
                        case Qt::Key_Left:
5727 cbradney 291
                                dX=-moveBy;
292
                                break;
8523 cbradney 293
                        case Qt::Key_Right:
5727 cbradney 294
                                dX=moveBy;
295
                                break;
8523 cbradney 296
                        case Qt::Key_Up:
5727 cbradney 297
                                dY=-moveBy;
298
                                break;
8523 cbradney 299
                        case Qt::Key_Down:
5727 cbradney 300
                                dY=moveBy;
301
                                break;
302
                }
303
                if (dX!=0.0 || dY!=0.0)
304
                {
305
                        moveImageInFrame(dX, dY);
10532 avox 306
                        update();
5727 cbradney 307
                }
5226 cbradney 308
        }
5727 cbradney 309
        else
5226 cbradney 310
        {
5727 cbradney 311
                switch (kk)
312
                {
8523 cbradney 313
                        case Qt::Key_Left:
5727 cbradney 314
                                dX=-moveBy+100;
315
                                break;
8523 cbradney 316
                        case Qt::Key_Right:
5727 cbradney 317
                                dX=moveBy+100;
318
                                break;
8523 cbradney 319
                        case Qt::Key_Up:
5727 cbradney 320
                                dY=-moveBy+100;
321
                                break;
8523 cbradney 322
                        case Qt::Key_Down:
5727 cbradney 323
                                dY=moveBy+100;
324
                                break;
325
                        default:
326
                                return;
22417 jghali 327
                }
328
                UndoTransaction transaction;
329
                if (UndoManager::undoEnabled())
5727 cbradney 330
                {
22419 jghali 331
                        if ((fitImageToFrame() || !controlDown) && (dX != 0.0 || dY != 0.0))
22417 jghali 332
                                transaction = undoManager->beginTransaction(getUName(), getUPixmap(), Um::ImageScale, "", Um::IMove);
333
                }
334
                if (dX != 0.0)
335
                {
336
                        double newXScale = dX / 100.0 * m_imageXScale;
337
                        setImageScalingMode(true, AspectRatio);
5727 cbradney 338
                        setImageXScale(newXScale);
5976 cbradney 339
                        if (!controlDown)
5921 cbradney 340
                        {
22417 jghali 341
                                double newYScale = dX / 100.0 * m_imageYScale;
5921 cbradney 342
                                setImageYScale(newYScale);
343
                        }
5727 cbradney 344
                }
22417 jghali 345
                else if (dY != 0.0)
5727 cbradney 346
                {
22417 jghali 347
                        double newYScale = dY / 100.0 * m_imageYScale;
348
                        setImageScalingMode(true, AspectRatio);
5727 cbradney 349
                        setImageYScale(newYScale);
5976 cbradney 350
                        if (!controlDown)
5921 cbradney 351
                        {
22417 jghali 352
                                double newXScale = dY / 100.0 * m_imageYScale;
5921 cbradney 353
                                setImageXScale(newXScale);
354
                        }
5727 cbradney 355
                }
22417 jghali 356
                if (dX != 0.0 || dY != 0.0)
22638 craig 357
                        if (!imageClip.empty())
5727 cbradney 358
                        {
359
                                imageClip = pixm.imgInfo.PDSpathData[pixm.imgInfo.usedPath].copy();
13951 fschmid 360
                                QTransform cl;
5727 cbradney 361
                                cl.translate(imageXOffset()*imageXScale(), imageYOffset()*imageYScale());
14861 fschmid 362
                                cl.rotate(imageRotation());
5727 cbradney 363
                                cl.scale(imageXScale(), imageYScale());
364
                                imageClip.map(cl);
365
                        }
22417 jghali 366
                if (transaction)
367
                        transaction.commit();
10532 avox 368
                update();      
5226 cbradney 369
        }
5243 cbradney 370
}
10601 mrdocs 371
 
372
bool PageItem_ImageFrame::createInfoGroup(QFrame *infoGroup, QGridLayout *infoGroupLayout)
373
{
374
        QLabel *infoCT, *fileT, *fileCT, *oPpiT, *oPpiCT, *aPpiT, *aPpiCT, *colT, *colCT;
375
        infoCT = new QLabel(infoGroup);
376
        fileCT = new QLabel(infoGroup);
377
 
12961 fschmid 378
        infoCT->setText( tr("Image"));
10601 mrdocs 379
        infoGroupLayout->addWidget( infoCT, 0, 0, 1, 2, Qt::AlignHCenter );
380
 
19834 craig 381
        if (imageIsAvailable)
10601 mrdocs 382
        {
383
                fileT = new QLabel(infoGroup);
384
                oPpiT = new QLabel(infoGroup);
385
                oPpiCT = new QLabel(infoGroup);
386
                aPpiT = new QLabel(infoGroup);
387
                aPpiCT = new QLabel(infoGroup);
388
                colT = new QLabel(infoGroup);
389
                colCT = new QLabel(infoGroup);
24739 jghali 390
                QFileInfo fi(Pfile);
12961 fschmid 391
                fileCT->setText( tr("File:"));
10601 mrdocs 392
                infoGroupLayout->addWidget( fileCT, 1, 0, Qt::AlignRight );
12862 fschmid 393
                if (isInlineImage)
394
                        fileT->setText( tr("Embedded Image"));
395
                else
396
                        fileT->setText(fi.fileName());
10601 mrdocs 397
                infoGroupLayout->addWidget( fileT, 1, 1 );
398
 
12961 fschmid 399
                oPpiCT->setText( tr("Original PPI:"));
10601 mrdocs 400
                infoGroupLayout->addWidget( oPpiCT, 2, 0, Qt::AlignRight );
18194 fschmid 401
                oPpiT->setText(QString::number(pixm.imgInfo.xres)+" x "+QString::number(pixm.imgInfo.yres));
10601 mrdocs 402
                infoGroupLayout->addWidget( oPpiT, 2, 1 );
403
 
12961 fschmid 404
                aPpiCT->setText( tr("Actual PPI:"));
10601 mrdocs 405
                infoGroupLayout->addWidget( aPpiCT, 3, 0, Qt::AlignRight );
406
                aPpiT->setText(QString::number(qRound(72.0 / imageXScale()))+" x "+ QString::number(qRound(72.0 / imageYScale())));
407
                infoGroupLayout->addWidget( aPpiT, 3, 1 );
408
 
12961 fschmid 409
                colCT->setText( tr("Colorspace:"));
10601 mrdocs 410
                infoGroupLayout->addWidget( colCT, 4, 0, Qt::AlignRight );
411
                QString cSpace;
412
                QString ext = fi.suffix().toLower();
11331 jghali 413
                if ((extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext)) && (pixm.imgInfo.type != ImageType7))
12961 fschmid 414
                        cSpace = tr("Unknown");
10601 mrdocs 415
                else
416
                        cSpace=colorSpaceText(pixm.imgInfo.colorspace);
417
                colT->setText(cSpace);
418
                infoGroupLayout->addWidget( colT, 4, 1 );
419
        }
12957 fschmid 420
        else
421
        {
422
                if (!Pfile.isEmpty())
423
                {
24739 jghali 424
                        QFileInfo fi(Pfile);
12961 fschmid 425
                        fileCT->setText( tr("File:"));
12957 fschmid 426
                        infoGroupLayout->addWidget( fileCT, 1, 0, Qt::AlignRight );
427
                        fileT = new QLabel(infoGroup);
428
                        if (isInlineImage)
429
                                fileT->setText( tr("Embedded Image missing"));
17248 jghali 430
                        else if (extensionIndicatesPDF(fi.suffix().toLower()))
431
                                fileT->setText(fi.fileName() + " " + tr("missing or corrupt"));
12957 fschmid 432
                        else
433
                                fileT->setText(fi.fileName() + " " + tr("missing"));
434
                        infoGroupLayout->addWidget( fileT, 1, 1 );
435
                }
436
                else
437
                {
12961 fschmid 438
                        fileCT->setText( tr("No Image Loaded"));
12957 fschmid 439
                        infoGroupLayout->addWidget( fileCT, 1, 0, 1, 2, Qt::AlignHCenter );
440
                }
441
        }
10601 mrdocs 442
        return true;
443
}
444
 
10934 cbradney 445
void PageItem_ImageFrame::applicableActions(QStringList & actionList)
446
{
10940 cbradney 447
        actionList << "fileImportImage";
448
        actionList << "itemConvertToTextFrame";
449
        actionList << "itemImageIsVisible";
450
        actionList << "itemPreviewFull";
451
        actionList << "itemPreviewLow";
452
        actionList << "itemPreviewNormal";
453
 
19834 craig 454
        if (imageIsAvailable)
10940 cbradney 455
        {
17418 fschmid 456
                actionList << "itemAdjustFrameToImage";
12591 fschmid 457
                actionList << "itemAdjustImageToFrame";
10940 cbradney 458
                if (pixm.imgInfo.valid)
459
                        actionList << "itemExtendedImageProperties";
460
                if (pixm.imgInfo.exifDataValid)
461
                        actionList << "itemImageInfo";
462
                actionList << "itemUpdateImage";
463
                actionList << "editCopyContents";
14796 fschmid 464
                actionList << "itemToggleInlineImage";
10940 cbradney 465
                if (isRaster)
466
                {
467
                        actionList << "styleImageEffects";
468
                        actionList << "editEditWithImageEditor";
469
                }
470
        }
17735 craig 471
        if(!Pfile.isEmpty())
472
                actionList << "editClearContents";
17418 fschmid 473
        actionList << "itemConvertToPolygon";
10940 cbradney 474
        if (doc()->scMW()->contentsBuffer.sourceType==PageItem::ImageFrame)
475
        {
476
                actionList << "editPasteContents";
477
                actionList << "editPasteContentsAbs";
478
        }
10934 cbradney 479
}
10941 cbradney 480
 
22716 jghali 481
QString PageItem_ImageFrame::infoDescription() const
10941 cbradney 482
{
483
        QString htmlText;
12961 fschmid 484
        htmlText.append( tr("Image") + "<br/>");
10941 cbradney 485
 
19834 craig 486
        if (imageIsAvailable)
10941 cbradney 487
        {
24739 jghali 488
                QFileInfo fi(Pfile);
12957 fschmid 489
                if (isInlineImage)
490
                        htmlText.append( tr("Embedded Image") + "<br/>");
491
                else
12961 fschmid 492
                        htmlText.append( tr("File:") + " " + fi.fileName() + "<br/>");
18194 fschmid 493
                htmlText.append( tr("Original PPI:") + " " + QString::number(pixm.imgInfo.xres)+" x "+QString::number(pixm.imgInfo.yres) + "<br/>");
12961 fschmid 494
                htmlText.append( tr("Actual PPI:") + " " + QString::number(qRound(72.0 / imageXScale()))+" x "+ QString::number(qRound(72.0 / imageYScale())) + "<br/>");
495
                htmlText.append( tr("Colorspace:") + " ");
10941 cbradney 496
                QString ext = fi.suffix().toLower();
11331 jghali 497
                if ((extensionIndicatesPDF(ext) || extensionIndicatesEPSorPS(ext)) && (pixm.imgInfo.type != ImageType7))
12961 fschmid 498
                        htmlText.append( tr("Unknown"));
10941 cbradney 499
                else
500
                        htmlText.append(colorSpaceText(pixm.imgInfo.colorspace));
501
                htmlText.append("<br/>");
12080 avox 502
                if (pixm.imgInfo.numberOfPages > 1)
503
                {
504
                        if (pixm.imgInfo.actualPageNumber > 0)
12961 fschmid 505
                                htmlText.append( tr("Page:") + " " + QString::number(pixm.imgInfo.actualPageNumber) + "/" + QString::number(pixm.imgInfo.numberOfPages)+ "<br/>");
12080 avox 506
                        else
12961 fschmid 507
                                htmlText.append( tr("Pages:") + " " + QString::number(pixm.imgInfo.numberOfPages)+ "<br/>");
12080 avox 508
                }
10941 cbradney 509
        }
510
        else
511
        {
12957 fschmid 512
                if (!Pfile.isEmpty())
513
                {
24739 jghali 514
                        QFileInfo fi(Pfile);
12957 fschmid 515
                        if (isInlineImage)
516
                                htmlText.append( tr("Embedded Image missing") + "<br/>");
17248 jghali 517
                        else if (extensionIndicatesPDF(fi.suffix().toLower()))
518
                                htmlText.append( tr("File:") + " " + fi.fileName() + " " + tr("missing or corrupt") + "<br/>");
12957 fschmid 519
                        else
12961 fschmid 520
                                htmlText.append( tr("File:") + " " + fi.fileName() + " " + tr("missing") + "<br/>");
12957 fschmid 521
                }
522
                else
12961 fschmid 523
                        htmlText.append( tr("No Image Loaded") + "<br/>");
10941 cbradney 524
        }
525
        htmlText.append(PageItem::infoDescription());
526
        return htmlText;
527
}