← Back to branch summary

~ubuntu-branches/ubuntu/saucy/digikam/saucy

« back to all changes in this revision

Viewing changes to utilities/imageeditor/editor/imageiface.cpp

  • Committer: Package Import Robot
  • Author(s): Felix Geyer, Rohan Garg, Philip Muškovac, Felix Geyer
  • Date: 2011-09-23 18:18:55 UTC
  • mfrom: (1.2.36 upstream)
  • Revision ID: package-import@ubuntu.com-20110923181855-ifs67wxkugshev9k
Tags: 2:2.1.1-0ubuntu1
https://launchpad.net/bugs/834190
https://launchpad.net/bugs/804894
[ Rohan Garg ]
* New upstream release (LP: #834190)
  - debian/control
    + Build with libqtwebkit-dev
 - debian/kipi-plugins-common
    + Install libkvkontakte required by kipi-plugins
 - debian/digikam
    + Install panoramagui

[ Philip Muškovac ]
* New upstream release
  - debian/control:
    + Add libcv-dev, libcvaux-dev, libhighgui-dev, libboost-graph1.46-dev,
      libksane-dev, libxml2-dev, libxslt-dev, libqt4-opengl-dev, libqjson-dev,
      libgpod-dev and libqca2-dev to build-deps
    + Add packages for kipi-plugins, libmediawiki, libkface, libkgeomap and
      libkvkontakte
  - debian/rules:
    + Don't build with gphoto2 since it doesn't build with it.
  - Add kubuntu_fix_test_linking.diff to fix linking of the dngconverter test
  - update install files
  - update kubuntu_01_mysqld_executable_name.diff for new cmake layout
    and rename to kubuntu_mysqld_executable_name.diff
* Fix typo in digikam-data description (LP: #804894)
* Fix Vcs links

[ Felix Geyer ]
* Move library data files to the new packages libkface-data, libkgeomap-data
  and libkvkontakte-data.
* Override version of the embedded library packages to 1.0~digikam<version>.
* Exclude the library packages from digikam-dbg to prevent file conflicts in
  the future.
* Call dh_install with --list-missing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
utilities/imageeditor/editor/imageiface.cpp
1
 
/* ============================================================
2
 
 *
3
 
 * This file is a part of digiKam project
4
 
 * http://www.digikam.org
5
 
 *
6
 
 * Date        : 2004-02-14
7
 
 * Description : image data interface for image plugins
8
 
 *
9
 
 * Copyright (C) 2004-2005 by Renchi Raju <renchi@pooh.tam.uiuc.edu>
10
 
 * Copyright (C) 2004-2010 by Gilles Caulier <caulier dot gilles at gmail dot com>
11
 
 *
12
 
 * This program is free software; you can redistribute it
13
 
 * and/or modify it under the terms of the GNU General
14
 
 * Public License as published by the Free Software Foundation;
15
 
 * either version 2, or (at your option)
16
 
 * any later version.
17
 
 *
18
 
 * This program is distributed in the hope that it will be useful,
19
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
 
 * GNU General Public License for more details.
22
 
 *
23
 
 * ============================================================ */
24
 
 
25
 
#include "imageiface.h"
26
 
 
27
 
// Qt includes
28
 
 
29
 
#include <QWidget>
30
 
#include <QSize>
31
 
#include <QPixmap>
32
 
#include <QBitmap>
33
 
#include <QPainter>
34
 
 
35
 
// KDE includes
36
 
 
37
 
#include <kdebug.h>
38
 
 
39
 
// Local includes
40
 
 
41
 
#include "exposurecontainer.h"
42
 
#include "iccmanager.h"
43
 
#include "iccsettingscontainer.h"
44
 
#include "icctransform.h"
45
 
#include "dimginterface.h"
46
 
#include "dmetadata.h"
47
 
 
48
 
namespace Digikam
49
 
{
50
 
 
51
 
class ImageIface::ImageIfacePriv
52
 
{
53
 
public:
54
 
 
55
 
    ImageIfacePriv() :
56
 
        usePreviewSelection(false),
57
 
        originalWidth(0),
58
 
        originalHeight(0),
59
 
        originalBytesDepth(0),
60
 
        constrainWidth(0),
61
 
        constrainHeight(0),
62
 
        previewWidth(0),
63
 
        previewHeight(0)
64
 
    {
65
 
    }
66
 
 
67
 
    bool    usePreviewSelection;
68
 
 
69
 
    int     originalWidth;
70
 
    int     originalHeight;
71
 
    int     originalBytesDepth;
72
 
 
73
 
    int     constrainWidth;
74
 
    int     constrainHeight;
75
 
 
76
 
    int     previewWidth;
77
 
    int     previewHeight;
78
 
 
79
 
    QPixmap qcheck;
80
 
 
81
 
    DImg    previewImage;
82
 
    DImg    targetPreviewImage;
83
 
};
84
 
 
85
 
ImageIface::ImageIface(int w, int h)
86
 
    : d(new ImageIfacePriv)
87
 
{
88
 
    d->constrainWidth     = w;
89
 
    d->constrainHeight    = h;
90
 
    d->originalWidth      = DImgInterface::defaultInterface()->origWidth();
91
 
    d->originalHeight     = DImgInterface::defaultInterface()->origHeight();
92
 
    d->originalBytesDepth = DImgInterface::defaultInterface()->bytesDepth();
93
 
 
94
 
    d->qcheck = QPixmap(8, 8);
95
 
 
96
 
    QPainter p;
97
 
    p.begin(&d->qcheck);
98
 
    p.fillRect(0, 0, 4, 4, QColor(144,144,144));
99
 
    p.fillRect(4, 4, 4, 4, QColor(144,144,144));
100
 
    p.fillRect(0, 4, 4, 4, QColor(100,100,100));
101
 
    p.fillRect(4, 0, 4, 4, QColor(100,100,100));
102
 
    p.end();
103
 
}
104
 
 
105
 
ImageIface::~ImageIface()
106
 
{
107
 
    delete d;
108
 
}
109
 
 
110
 
void ImageIface::setPreviewType(bool useSelect)
111
 
{
112
 
    d->usePreviewSelection = useSelect;
113
 
}
114
 
 
115
 
bool ImageIface::previewType()
116
 
{
117
 
    return d->usePreviewSelection;
118
 
}
119
 
 
120
 
DColor ImageIface::getColorInfoFromOriginalImage(const QPoint& point)
121
 
{
122
 
    if ( !DImgInterface::defaultInterface()->getImage() || point.x() > originalWidth() || point.y() > originalHeight() )
123
 
    {
124
 
        kWarning() << "Coordinate out of range or no image data available!";
125
 
        return DColor();
126
 
    }
127
 
 
128
 
    return DImgInterface::defaultInterface()->getImg()->getPixelColor(point.x(), point.y());
129
 
}
130
 
 
131
 
DColor ImageIface::getColorInfoFromPreviewImage(const QPoint& point)
132
 
{
133
 
    if ( d->previewImage.isNull() || point.x() > previewWidth() || point.y() > previewHeight() )
134
 
    {
135
 
        kWarning() << "Coordinate out of range or no image data available!";
136
 
        return DColor();
137
 
    }
138
 
 
139
 
    return d->previewImage.getPixelColor(point.x(), point.y());
140
 
}
141
 
 
142
 
DColor ImageIface::getColorInfoFromTargetPreviewImage(const QPoint& point)
143
 
{
144
 
    if ( d->targetPreviewImage.isNull() || point.x() > previewWidth() || point.y() > previewHeight() )
145
 
    {
146
 
        kWarning() << "Coordinate out of range or no image data available!";
147
 
        return DColor();
148
 
    }
149
 
 
150
 
    return d->targetPreviewImage.getPixelColor(point.x(), point.y());
151
 
}
152
 
 
153
 
uchar* ImageIface::setPreviewImageSize(int w, int h) const
154
 
{
155
 
    d->previewImage.reset();
156
 
    d->targetPreviewImage.reset();
157
 
 
158
 
    d->constrainWidth  = w;
159
 
    d->constrainHeight = h;
160
 
 
161
 
    return (getPreviewImage());
162
 
}
163
 
 
164
 
uchar* ImageIface::getPreviewImage() const
165
 
{
166
 
    if (d->previewImage.isNull())
167
 
    {
168
 
        DImg* im = 0;
169
 
 
170
 
        if (!d->usePreviewSelection)
171
 
        {
172
 
            im = DImgInterface::defaultInterface()->getImg();
173
 
 
174
 
            if (!im || im->isNull())
175
 
            {
176
 
                return 0;
177
 
            }
178
 
        }
179
 
        else
180
 
        {
181
 
            int    x, y, w, h;
182
 
            bool   s    = DImgInterface::defaultInterface()->sixteenBit();
183
 
            bool   a    = DImgInterface::defaultInterface()->hasAlpha();
184
 
            uchar* data = DImgInterface::defaultInterface()->getImageSelection();
185
 
            DImgInterface::defaultInterface()->getSelectedArea(x, y, w, h);
186
 
            im          = new DImg(w, h, s, a, data, true);
187
 
            delete [] data;
188
 
 
189
 
            if (!im)
190
 
            {
191
 
                return 0;
192
 
            }
193
 
 
194
 
            if (im->isNull())
195
 
            {
196
 
                delete im;
197
 
                return 0;
198
 
            }
199
 
 
200
 
            im->setIccProfile(DImgInterface::defaultInterface()->getEmbeddedICC());
201
 
        }
202
 
 
203
 
        QSize sz(im->width(), im->height());
204
 
        sz.scale(d->constrainWidth, d->constrainHeight, Qt::KeepAspectRatio);
205
 
 
206
 
        d->previewImage  = im->smoothScale(sz.width(), sz.height());
207
 
        d->previewWidth  = d->previewImage.width();
208
 
        d->previewHeight = d->previewImage.height();
209
 
 
210
 
        // only create another copy if needed, in putPreviewImage
211
 
        d->targetPreviewImage = d->previewImage;
212
 
 
213
 
        if (d->usePreviewSelection)
214
 
        {
215
 
            delete im;
216
 
        }
217
 
    }
218
 
 
219
 
    DImg previewData = d->previewImage.copyImageData();
220
 
    return previewData.stripImageData();
221
 
}
222
 
 
223
 
DImg ImageIface::getPreviewImg()
224
 
{
225
 
    DImg preview(previewWidth(), previewHeight(), previewSixteenBit(), previewHasAlpha(), getPreviewImage());
226
 
    return preview;
227
 
}
228
 
 
229
 
uchar* ImageIface::getOriginalImage() const
230
 
{
231
 
    DImg* im = DImgInterface::defaultInterface()->getImg();
232
 
 
233
 
    if (!im || im->isNull())
234
 
    {
235
 
        return 0;
236
 
    }
237
 
 
238
 
    DImg origData = im->copyImageData();
239
 
    return origData.stripImageData();
240
 
}
241
 
 
242
 
DImg* ImageIface::getOriginalImg() const
243
 
{
244
 
    return DImgInterface::defaultInterface()->getImg();
245
 
}
246
 
 
247
 
uchar* ImageIface::getImageSelection() const
248
 
{
249
 
    return DImgInterface::defaultInterface()->getImageSelection();
250
 
}
251
 
 
252
 
void ImageIface::putPreviewImage(uchar* data)
253
 
{
254
 
    if (!data)
255
 
    {
256
 
        return;
257
 
    }
258
 
 
259
 
    d->targetPreviewImage.detach();
260
 
    d->targetPreviewImage.putImageData(data);
261
 
}
262
 
 
263
 
void ImageIface::putPreviewIccProfile(const IccProfile& profile)
264
 
{
265
 
    d->targetPreviewImage.detach();
266
 
    d->targetPreviewImage.setIccProfile(profile);
267
 
}
268
 
 
269
 
void ImageIface::putOriginalImage(const QString& caller, uchar* data, int w, int h)
270
 
{
271
 
    if (!data)
272
 
    {
273
 
        return;
274
 
    }
275
 
 
276
 
    DImgInterface::defaultInterface()->putImage(caller, data, w, h);
277
 
}
278
 
 
279
 
void ImageIface::putOriginalIccProfile(const IccProfile& profile)
280
 
{
281
 
    DImgInterface::defaultInterface()->putIccProfile( profile );
282
 
}
283
 
 
284
 
void ImageIface::putImageSelection(const QString& caller, uchar* data)
285
 
{
286
 
    if (!data)
287
 
    {
288
 
        return;
289
 
    }
290
 
 
291
 
    DImgInterface::defaultInterface()->putImageSelection(caller, data);
292
 
}
293
 
 
294
 
int ImageIface::previewWidth()
295
 
{
296
 
    return d->previewWidth;
297
 
}
298
 
 
299
 
int ImageIface::previewHeight()
300
 
{
301
 
    return d->previewHeight;
302
 
}
303
 
 
304
 
bool ImageIface::previewSixteenBit()
305
 
{
306
 
    return originalSixteenBit();
307
 
}
308
 
 
309
 
bool ImageIface::previewHasAlpha()
310
 
{
311
 
    return originalHasAlpha();
312
 
}
313
 
 
314
 
int ImageIface::originalWidth()
315
 
{
316
 
    return DImgInterface::defaultInterface()->origWidth();
317
 
}
318
 
 
319
 
int ImageIface::originalHeight()
320
 
{
321
 
    return DImgInterface::defaultInterface()->origHeight();
322
 
}
323
 
 
324
 
bool ImageIface::originalSixteenBit()
325
 
{
326
 
    return DImgInterface::defaultInterface()->sixteenBit();
327
 
}
328
 
 
329
 
bool ImageIface::originalHasAlpha()
330
 
{
331
 
    return DImgInterface::defaultInterface()->hasAlpha();
332
 
}
333
 
 
334
 
int ImageIface::selectedWidth()
335
 
{
336
 
    int x, y, w, h;
337
 
    DImgInterface::defaultInterface()->getSelectedArea(x, y, w, h);
338
 
    return w;
339
 
}
340
 
 
341
 
int ImageIface::selectedHeight()
342
 
{
343
 
    int x, y, w, h;
344
 
    DImgInterface::defaultInterface()->getSelectedArea(x, y, w, h);
345
 
    return h;
346
 
}
347
 
 
348
 
int ImageIface::selectedXOrg()
349
 
{
350
 
    int x, y, w, h;
351
 
    DImgInterface::defaultInterface()->getSelectedArea(x, y, w, h);
352
 
    return x;
353
 
}
354
 
 
355
 
int ImageIface::selectedYOrg()
356
 
{
357
 
    int x, y, w, h;
358
 
    DImgInterface::defaultInterface()->getSelectedArea(x, y, w, h);
359
 
    return y;
360
 
}
361
 
 
362
 
void ImageIface::convertOriginalColorDepth(int depth)
363
 
{
364
 
    DImgInterface::defaultInterface()->convertDepth(depth);
365
 
}
366
 
 
367
 
QPixmap ImageIface::convertToPixmap(DImg& img)
368
 
{
369
 
    return DImgInterface::defaultInterface()->convertToPixmap(img);
370
 
}
371
 
 
372
 
IccProfile ImageIface::getOriginalIccProfile()
373
 
{
374
 
    return DImgInterface::defaultInterface()->getEmbeddedICC();
375
 
}
376
 
 
377
 
KExiv2Data ImageIface::getOriginalMetadata()
378
 
{
379
 
    return DImgInterface::defaultInterface()->getImg()->getMetadata();
380
 
}
381
 
 
382
 
void ImageIface::setOriginalMetadata(const KExiv2Data& meta)
383
 
{
384
 
    DImgInterface::defaultInterface()->getImg()->setMetadata(meta);
385
 
}
386
 
 
387
 
PhotoInfoContainer ImageIface::getPhotographInformation() const
388
 
{
389
 
    DMetadata meta(DImgInterface::defaultInterface()->getImg()->getMetadata());
390
 
    return meta.getPhotographInformation();
391
 
}
392
 
 
393
 
void ImageIface::paint(QPaintDevice* device, int x, int y, int w, int h, QPainter* painter)
394
 
{
395
 
    QPainter localPainter;
396
 
    QPainter* p=0;
397
 
 
398
 
    if (painter)
399
 
    {
400
 
        p = painter;
401
 
    }
402
 
    else
403
 
    {
404
 
        p = &localPainter;
405
 
        p->begin(device);
406
 
    }
407
 
 
408
 
    int width  = w > 0 ? qMin(d->previewWidth, w)  : d->previewWidth;
409
 
    int height = h > 0 ? qMin(d->previewHeight, h) : d->previewHeight;
410
 
 
411
 
    if ( !d->targetPreviewImage.isNull() )
412
 
    {
413
 
        if (d->targetPreviewImage.hasAlpha())
414
 
        {
415
 
            p->drawTiledPixmap(x, y, width, height, d->qcheck);
416
 
        }
417
 
 
418
 
        QPixmap pixImage;
419
 
        ICCSettingsContainer* iccSettings = DImgInterface::defaultInterface()->getICCSettings();
420
 
 
421
 
        if (iccSettings && iccSettings->enableCM && iccSettings->useManagedView)
422
 
        {
423
 
            IccManager manager(d->targetPreviewImage);
424
 
            IccTransform monitorICCtrans = manager.displayTransform();
425
 
            pixImage = d->targetPreviewImage.convertToPixmap(monitorICCtrans);
426
 
        }
427
 
        else
428
 
        {
429
 
            pixImage = d->targetPreviewImage.convertToPixmap();
430
 
        }
431
 
 
432
 
        p->drawPixmap(x, y, pixImage, 0, 0, width, height);
433
 
 
434
 
        // Show the Over/Under exposure pixels indicators
435
 
 
436
 
        ExposureSettingsContainer* expoSettings = DImgInterface::defaultInterface()->getExposureSettings();
437
 
 
438
 
        if (expoSettings->underExposureIndicator || expoSettings->overExposureIndicator)
439
 
        {
440
 
            ExposureSettingsContainer* expoSettings = DImgInterface::defaultInterface()->getExposureSettings();
441
 
            QImage pureColorMask                    = d->targetPreviewImage.pureColorMask(expoSettings);
442
 
            QPixmap pixMask                         = QPixmap::fromImage(pureColorMask);
443
 
            p->drawPixmap(x, y, pixMask, 0, 0, width, height);
444
 
        }
445
 
    }
446
 
 
447
 
    if (!painter)
448
 
    {
449
 
        p->end();
450
 
    }
451
 
}
452
 
 
453
 
}   // namespace Digikam