|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

# displayshape.cpp Example File
tools/qtdemo/displayshape.cpp

        /****************************************************************************
        **
        ** Copyright (C) 2005-2005 Trolltech AS. All rights reserved.
        **
        ** This file is part of the documentation of the Qt Toolkit.
        **
        ** This file may be used under the terms of the GNU General Public
        ** License version 2.0 as published by the Free Software Foundation
        ** and appearing in the file LICENSE.GPL included in the packaging of
        ** this file.  Please review the following information to ensure GNU
        ** General Public Licensing requirements will be met:
        ** http://www.trolltech.com/products/qt/opensource.html
        **
        ** If you are unsure which license is appropriate for your use, please
        ** review the following information:
        ** http://www.trolltech.com/products/qt/licensing.html or contact the
        ** sales department at sales@trolltech.com.
        **
        ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
        ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
        **
        ****************************************************************************/

        #include <math.h>
        #include <QtGui>

        #include "displayshape.h"

        DisplayShape::DisplayShape(const QPointF &position, const QSizeF &maxSize)
            : pos(position), maxSize(maxSize), interactive(false)
        {
        }

        bool DisplayShape::animate()
        {
            if (!targetPos.isNull()) {
                QLineF displacement(pos, targetPos);
                QPointF newPosition = displacement.pointAt(0.25);
                if (displacement.length() <= 1.0) {
                    pos = targetPos;
                    targetPos = QPointF();
                } else {
                    pos = newPosition;
                }
                return true;
            }

            return false;
        }

        bool DisplayShape::contains(const QString &key) const
        {
            return meta.contains(key);
        }

        bool DisplayShape::isInteractive() const
        {
            return interactive;
        }

        QVariant DisplayShape::metaData(const QString &key) const
        {
            return meta.value(key);
        }

        void DisplayShape::paint(QPainter *painter) const
        {
            painter->save();
            painter->drawImage(pos, image);
            painter->restore();
        }

        QPointF DisplayShape::position() const
        {
            return pos;
        }

        QRectF DisplayShape::rect() const
        {
            return QRectF(pos, image.size());
        }

        void DisplayShape::removeMetaData(const QString &key)
        {
            meta.remove(key);
        }

        void DisplayShape::setInteractive(bool enable)
        {
            interactive = enable;
        }

        void DisplayShape::setMetaData(const QString &key, const QVariant &value)
        {
            meta[key] = value;
        }

        void DisplayShape::setPosition(const QPointF &position)
        {
            pos = position;
        }

        void DisplayShape::setSize(const QSizeF &size)
        {
            maxSize = size;
        }

        void DisplayShape::setTarget(const QPointF &position)
        {
            targetPos = position;
        }

        QSizeF DisplayShape::size() const
        {
            return maxSize;
        }

        QPointF DisplayShape::target() const
        {
            return targetPos;
        }

        PanelShape::PanelShape(const QPainterPath &path, const QBrush &normal,
                               const QBrush &highlighted, const QPen &pen,
                               const QPointF &position, const QSizeF &maxSize)
            : DisplayShape(position, maxSize), highlightedBrush(highlighted),
              normalBrush(normal), path(path), pen(pen)
        {
            brush = normalBrush;
        }

        bool PanelShape::animate()
        {
            bool updated = false;

            if (!meta.contains("destroy")) {
                if (meta.contains("fade")) {
                    QColor penColor = pen.color();
                    QColor brushColor = brush.color();
                    int penAlpha = penColor.alpha();
                    int brushAlpha = brushColor.alpha();
                    int fadeMinimum = meta.value("fade minimum").toInt();

                    if (penAlpha != fadeMinimum || brushAlpha != fadeMinimum
                        || meta.value("fade").toInt() > 0) {

                        penAlpha = qBound(fadeMinimum,
                                          penAlpha + meta.value("fade").toInt(), 255);
                        brushAlpha = qBound(fadeMinimum,
                                          brushAlpha + meta.value("fade").toInt(), 255);

                        penColor.setAlpha(penAlpha);
                        brushColor.setAlpha(brushAlpha);
                        pen.setColor(penColor);
                        brush.setColor(brushColor);

                        if (penAlpha == 0 && brushAlpha == 0) {
                            meta["destroy"] = true;
                            meta.remove("fade");
                        } else if (penAlpha == 255 && brushAlpha == 255)
                            meta.remove("fade");

                        updated = true;
                    }
                } else if (meta.contains("highlight")) {
                    qreal scale = meta.value("highlight scale").toDouble();
                    QColor color = brush.color();

                    if (meta.value("highlight").toBool())
                        scale = qBound(0.0, scale + 0.5, 1.0);
                    else
                        scale = qBound(0.0, scale - 0.2, 1.0);

                    if (scale == 0.0) {
                        brush = normalBrush;
                        meta.remove("highlight");
                        meta.remove("highlight scale");
                        updated = true;
                    } else if (scale != meta["highlight scale"]) {
                        meta["highlight scale"] = scale;

                        if (scale == 1.0)
                            brush = highlightedBrush;
                        else {
                            QColor normal = normalBrush.color();
                            QColor highlighted = highlightedBrush.color();

                            color.setRedF((1.0-scale) * normal.redF()
                                          + scale*highlighted.redF());
                            color.setGreenF((1.0-scale) * normal.greenF()
                                            + scale*highlighted.greenF());
                            color.setBlueF((1.0-scale) * normal.blueF()
                                           + scale*highlighted.blueF());
                            brush.setColor(color);
                        }
                        updated = true;
                    }
                }
            }

            return DisplayShape::animate() || updated;
        }

        void PanelShape::paint(QPainter *painter) const
        {
            painter->save();
            painter->setRenderHint(QPainter::Antialiasing);
            painter->setBrush(brush);
            painter->setPen(pen);
            painter->translate(pos);
            painter->drawPath(path);
            painter->restore();
        }

        QRectF PanelShape::rect() const
        {
            return QRectF(pos + path.boundingRect().topLeft(),
                          path.boundingRect().size());
        }

        TitleShape::TitleShape(const QString &text, const QFont &f,
                               const QPen &pen, const QPointF &position,
                               const QSizeF &maxSize, Qt::Alignment alignment)
            : DisplayShape(position, maxSize), font(f), text(text), pen(pen),
              alignment(alignment)
        {
            QFontMetricsF fm(font);
            textRect = fm.boundingRect(QRectF(QPointF(0, 0), maxSize), alignment, text);

            qreal textWidth = qMax(fm.width(text), textRect.width());
            qreal textHeight = qMax(fm.height(), textRect.height());

            qreal scale = qMin(maxSize.width()/textWidth,
                               maxSize.height()/textHeight);

            font.setPointSizeF(font.pointSizeF() * scale);
            fm = QFontMetricsF(font);
            textRect = fm.boundingRect(QRectF(QPointF(0, 0), maxSize), alignment, text);
            baselineStart = QPointF(textRect.left(), textRect.bottom() - fm.descent());
        }

        bool TitleShape::animate()
        {
            bool updated = false;

            if (!meta.contains("destroy")) {
                if (meta.contains("fade")) {
                    QColor penColor = pen.color();
                    int penAlpha = penColor.alpha();

                    penAlpha = qBound(meta.value("fade minimum").toInt(),
                                      penAlpha + meta.value("fade").toInt(), 255);

                    penColor.setAlpha(penAlpha);
                    pen.setColor(penColor);

                    if (penAlpha == 0) {
                        meta["destroy"] = true;
                        meta.remove("fade");
                    } else if (penAlpha == 255)
                        meta.remove("fade");

                    updated = true;
                }
            }

            return DisplayShape::animate() || updated;
        }

        void TitleShape::paint(QPainter *painter) const
        {
            QRectF rect(textRect);
            rect.translate(pos);
            painter->save();
            painter->setRenderHint(QPainter::TextAntialiasing);
            painter->setPen(pen);
            painter->setFont(font);
            painter->drawText(pos + baselineStart, text);
            painter->restore();
        }

        QRectF TitleShape::rect() const
        {
            QRectF rect(textRect);
            return rect.translated(pos);
        }

        ImageShape::ImageShape(const QImage &original, const QPointF &position,
                               const QSizeF &maxSize, int alpha,
                               Qt::Alignment alignment)
            : DisplayShape(position, maxSize), alpha(alpha), alignment(alignment)
        {
            source = original.convertToFormat(QImage::Format_ARGB32_Premultiplied);
            qreal scale = qMin(qMin(maxSize.width()/source.width(),
                                    maxSize.height()/source.height()), qreal(1.0));

            source = source.scaled(int(ceil(source.width() * scale)),
                                   int(ceil(source.height() * scale)),
                                   Qt::KeepAspectRatio,
                                   Qt::SmoothTransformation);

            image = QImage(source.size(), QImage::Format_ARGB32_Premultiplied);

            offset = QPointF(0.0, 0.0);

            if (alignment & Qt::AlignHCenter)
                offset.setX((maxSize.width() - image.width())/2);
            else if (alignment & Qt::AlignRight)
                offset.setX(maxSize.width() - image.width());

            if (alignment & Qt::AlignVCenter)
                offset.setY((maxSize.height() - image.height())/2);
            else if (alignment & Qt::AlignBottom)
                offset.setY(maxSize.height() - image.height());

            redraw();
        }

        void ImageShape::redraw()
        {
            image.fill(qRgba(alpha, alpha, alpha, alpha));

            QPainter painter;
            painter.begin(&image);
            painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
            painter.drawImage(0, 0, source);
            painter.end();
        }

        void ImageShape::paint(QPainter *painter) const
        {
            painter->drawImage(pos + offset, image);
        }

        QRectF ImageShape::rect() const
        {
            return QRectF(pos, maxSize);
        }

        bool ImageShape::animate()
        {
            bool updated = false;

            if (!meta.contains("destroy")) {
                if (meta.contains("fade")) {
                    alpha = qBound(meta.value("fade minimum").toInt(),
                                   alpha + meta.value("fade").toInt(), 255);
                    redraw();

                    if (alpha == 0) {
                        meta["destroy"] = true;
                        meta.remove("fade");
                    } else if (alpha == 255)
                        meta.remove("fade");

                    updated = true;
                }
            }

            return DisplayShape::animate() || updated;
        }

        DocumentShape::DocumentShape(const QString &text, const QFont &font,
                                     const QPointF &position, const QSizeF &maxSize,
                                     int alpha)
            : DisplayShape(position, maxSize), alpha(alpha)
        {
            textDocument.setHtml(text);
            textDocument.setDefaultFont(font);
            textDocument.setPageSize(maxSize);
            QSizeF documentSize = textDocument.documentLayout()->documentSize();
            setSize(QSizeF(maxSize.width(),
                              qMin(maxSize.height(), documentSize.height())));

            source = QImage(int(ceil(documentSize.width())),
                            int(ceil(documentSize.height())),
                            QImage::Format_ARGB32_Premultiplied);
            source.fill(qRgba(255, 255, 255, 255));

            QAbstractTextDocumentLayout::PaintContext context;
            textDocument.documentLayout()->setPaintDevice(&source);

            QPainter painter;
            painter.begin(&source);
            painter.setRenderHint(QPainter::TextAntialiasing);
            painter.setRenderHint(QPainter::Antialiasing);
            textDocument.documentLayout()->draw(&painter, context);
            painter.end();

            source = source.scaled(int(ceil(maxSize.width())),
                                   int(ceil(maxSize.height())),
                                   Qt::KeepAspectRatio,
                                   Qt::SmoothTransformation);

            image = QImage(source.size(), source.format());
            redraw();
        }

        DocumentShape::~DocumentShape()
        {
        }

        bool DocumentShape::animate()
        {
            bool updated = false;

            if (!meta.contains("destroy")) {
                if (meta.contains("fade")) {
                    alpha = qBound(meta.value("fade minimum").toInt(),
                                   alpha + meta.value("fade").toInt(), 255);
                    redraw();

                    if (alpha == 0) {
                        meta["destroy"] = true;
                        meta.remove("fade");
                    } else if (alpha == 255)
                        meta.remove("fade");

                    updated = true;
                }
            }

            return DisplayShape::animate() || updated;
        }

        void DocumentShape::redraw()
        {
            image.fill(qRgba(alpha, alpha, alpha, alpha));

            QPainter painter;
            painter.begin(&image);
            painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
            painter.drawImage(0, 0, source);
            painter.end();
        }

        void DocumentShape::paint(QPainter *painter) const
        {
            painter->drawImage(pos, image);
        }

        QRectF DocumentShape::rect() const
        {
            return QRectF(pos, maxSize);
        }