1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the demonstration applications of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "imageitem.h"

    43 #include "colors.h"

    44 

    45 ImageItem::ImageItem(const QImage &image, int maxWidth, int maxHeight, QGraphicsScene *scene,

    46         QGraphicsItem *parent, bool adjustSize, float scale) : DemoItem(scene, parent)

    47 {

    48     this->image = image;

    49     this->maxWidth = maxWidth;

    50     this->maxHeight = maxHeight;

    51     this->adjustSize = adjustSize;

    52     this->scale = scale;

    53 }

    54 

    55 QImage *ImageItem::createImage(const QMatrix &matrix) const

    56 {

    57     QImage *original = new QImage(image);

    58     if (original->isNull()){

    59         return original; // nothing we can do about it...

    60     }

    61 

    62     QPoint size = matrix.map(QPoint(this->maxWidth, this->maxHeight));

    63     float w = size.x(); // x, y is the used as width, height

    64     float h = size.y();

    65 

    66     // Optimization: if image is smaller than maximum allowed size, just return the loaded image

    67     if (original->size().height() <= h && original->size().width() <= w && !this->adjustSize && this->scale == 1)

    68         return original;

    69 

    70     // Calculate what the size of the final image will be:

    71     w = qMin(w, float(original->size().width()) * this->scale);

    72     h = qMin(h, float(original->size().height()) * this->scale);

    73 

    74     float adjustx = 1.0f;

    75     float adjusty = 1.0f;

    76     if (this->adjustSize){

    77         adjustx = qMin(matrix.m11(), matrix.m22());

    78         adjusty = matrix.m22() < adjustx ? adjustx : matrix.m22();

    79         w *= adjustx;

    80         h *= adjusty;

    81     }

    82 

    83     // Create a new image with correct size, and draw original on it

    84     QImage *image = new QImage(int(w+2), int(h+2), QImage::Format_ARGB32_Premultiplied);

    85     image->fill(QColor(0, 0, 0, 0).rgba());

    86     QPainter painter(image);

    87     painter.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);

    88     if (this->adjustSize)

    89         painter.scale(adjustx, adjusty);

    90     if (this->scale != 1)

    91        painter.scale(this->scale, this->scale);

    92     painter.drawImage(0, 0, *original);

    93 

    94     if (!this->adjustSize){

    95        // Blur out edges

    96        int blur = 30;

    97        if (h < original->height()){

    98            QLinearGradient brush1(0, h - blur, 0, h);

    99            brush1.setSpread(QGradient::PadSpread);

   100            brush1.setColorAt(0.0, QColor(0, 0, 0, 0));

   101            brush1.setColorAt(1.0, Colors::sceneBg1);

   102            painter.fillRect(0, int(h) - blur, original->width(), int(h), brush1);

   103        }

   104        if (w < original->width()){

   105            QLinearGradient brush2(w - blur, 0, w, 0);

   106            brush2.setSpread(QGradient::PadSpread);

   107            brush2.setColorAt(0.0, QColor(0, 0, 0, 0));

   108            brush2.setColorAt(1.0, Colors::sceneBg1);

   109            painter.fillRect(int(w) - blur, 0, int(w), original->height(), brush2);

   110        }

   111     }

   112     delete original;

   113     return image;

   114 }