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

# displaywidget.cpp Example File
tools/qtdemo/displaywidget.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 <QtGui>

        #include "displayshape.h"
        #include "displaywidget.h"

        DisplayWidget::DisplayWidget(QWidget *parent)
            : QWidget(parent)
        {
            empty = true;
            emptying = false;

            enableUpdates();

            setBackgroundRole(QPalette::Base);
            setMouseTracking(true);
        }

        void DisplayWidget::appendShape(DisplayShape *shape)
        {
            shapes.append(shape);
            empty = false;
            enableUpdates();
        }

        void DisplayWidget::insertShape(int position, DisplayShape *shape)
        {
            shapes.insert(position, shape);
            empty = false;
            enableUpdates();
        }

        QSize DisplayWidget::minimumSizeHint() const
        {
            return QSize(800, 600);
        }

        void DisplayWidget::mouseMoveEvent(QMouseEvent *event)
        {
            if (emptying)
                return;

            bool updated = false;

            foreach (DisplayShape *shape, shapes) {
                if (shape->rect().contains(event->pos())) {
                    if (shape->isInteractive() && !shape->contains("fade")
                        && !shape->contains("highlight")) {
                        shape->setMetaData("highlight", true);
                        updated = true;
                    }
                } else if (shape->isInteractive() && shape->contains("highlight")
                           && shape->metaData("highlight").toBool()) {
                    shape->setMetaData("highlight", false);
                    updated = true;
                }
            }

            if (updated)
                enableUpdates();
        }

        void DisplayWidget::mousePressEvent(QMouseEvent *event)
        {
            if (event->button() != Qt::LeftButton)
                return;

            if (emptying)
                return;

            foreach (DisplayShape *shape, shapes) {
                if (shape->rect().contains(event->pos()) && !shape->contains("fade")) {
                    if (shape->contains("action"))
                        emit actionRequested(shape->metaData("action").toString());
                    else if (shape->contains("category"))
                        emit categoryRequested(shape->metaData("category").toString());
                    else if (shape->contains("example"))
                        emit exampleRequested(shape->metaData("example").toString());
                    else if (shape->contains("documentation")) {
                        emit documentationRequested(
                            shape->metaData("documentation").toString());
                        shape->setMetaData("highlight", false);
                        enableUpdates();
                    } else if (shape->contains("launch")) {
                        emit launchRequested(shape->metaData("launch").toString());
                        shape->setMetaData("fade", -5);
                        enableUpdates();
                    }
                }
            }
        }

        void DisplayWidget::paintEvent(QPaintEvent *event)
        {
            QPainter painter;
            painter.begin(this);
            painter.fillRect(event->rect(), Qt::white);
            foreach (DisplayShape *shape, shapes)
                shape->paint(&painter);
            painter.end();
        }

        void DisplayWidget::reset()
        {
            if (emptying)
                return;

            if (shapes.size() == 0) {
                empty = true;
                timer.stop();
                emit displayEmpty();    // Note: synchronous signal
            } else {
                enableUpdates();
                emptying = true;
                empty = false;
                foreach (DisplayShape *shape, shapes) {
                    shape->setMetaData("fade", -15);
                    shape->setMetaData("fade minimum", 0);
                }
            }
        }

        DisplayShape *DisplayWidget::shape(int index) const
        {
            return shapes.value(index);
        }

        int DisplayWidget::shapesCount() const
        {
            return shapes.size();
        }

        void DisplayWidget::enableUpdates()
        {
            if (!timer.isActive())
                timer.start(50, this);
        }

        void DisplayWidget::timerEvent(QTimerEvent *event)
        {
            if (event->timerId() == timer.timerId()) {
                QVector<DisplayShape*> discard;

                int updated = 0;

                foreach (DisplayShape *shape, shapes) {
                    QRect oldRect = shape->rect().toRect().adjusted(-1,-1,1,1);
                    if (shape->animate()) {

                        update(oldRect);
                        QRect newRect = shape->rect().toRect().adjusted(-1,-1,1,1);
                        ++updated;

                        if (shape->contains("destroy")) {
                            discard.append(shape);
                        } else {
                            update(newRect);
                        }
                    }
                }

                if (updated == 0)
                    timer.stop();

                foreach (DisplayShape *shape, discard) {
                    shapes.removeAll(shape);
                    delete shape;
                }

                if (shapes.size() == 0 && !empty) {
                    empty = true;
                    emptying = false;
                    timer.stop();
                    emit displayEmpty();    // Note: synchronous signal
                }
            } else {
                QWidget::timerEvent(event);
            }
        }