sortingbox.cpp Example File
widgets/tooltips/sortingbox.cpp

 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the examples of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** No Commercial Usage
 ** This file contains pre-release code and may not be distributed.
 ** You may use this file in accordance with the terms and conditions
 ** contained in the Technology Preview License Agreement accompanying
 ** this package.
 **
 ** GNU Lesser General Public License Usage
 ** Alternatively, this file may be used under the terms of the GNU Lesser
 ** General Public License version 2.1 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.LGPL included in the
 ** packaging of this file.  Please review the following information to
 ** ensure the GNU Lesser General Public License version 2.1 requirements
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
 ** In addition, as a special exception, Nokia gives you certain additional
 ** rights.  These rights are described in the Nokia Qt LGPL Exception
 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at qt-info@nokia.com.
 **
 **
 **
 **
 **
 **
 **
 **
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/

 #include <QtGui>

 #include <stdlib.h>

 #include "sortingbox.h"

 SortingBox::SortingBox()
 {
     setMouseTracking(true);
     setBackgroundRole(QPalette::Base);

     itemInMotion = 0;

     newCircleButton = createToolButton(tr("New Circle"),
                                        QIcon(":/images/circle.png"),
                                        SLOT(createNewCircle()));

     newSquareButton = createToolButton(tr("New Square"),
                                        QIcon(":/images/square.png"),
                                        SLOT(createNewSquare()));

     newTriangleButton = createToolButton(tr("New Triangle"),
                                          QIcon(":/images/triangle.png"),
                                          SLOT(createNewTriangle()));

     circlePath.addEllipse(QRect(0, 0, 100, 100));
     squarePath.addRect(QRect(0, 0, 100, 100));

     qreal x = trianglePath.currentPosition().x();
     qreal y = trianglePath.currentPosition().y();
     trianglePath.moveTo(x + 120 / 2, y);
     trianglePath.lineTo(0, 100);
     trianglePath.lineTo(120, 100);
     trianglePath.lineTo(x + 120 / 2, y);

     setWindowTitle(tr("Tool Tips"));
     resize(500, 300);

     createShapeItem(circlePath, tr("Circle"), initialItemPosition(circlePath),
                     initialItemColor());
     createShapeItem(squarePath, tr("Square"), initialItemPosition(squarePath),
                     initialItemColor());
     createShapeItem(trianglePath, tr("Triangle"),
                     initialItemPosition(trianglePath), initialItemColor());
 }

 bool SortingBox::event(QEvent *event)
 {
     if (event->type() == QEvent::ToolTip) {
         QHelpEvent *helpEvent = static_cast<QHelpEvent *>(event);
         int index = itemAt(helpEvent->pos());
         if (index != -1) {
             QToolTip::showText(helpEvent->globalPos(), shapeItems[index].toolTip());
         } else {
             QToolTip::hideText();
             event->ignore();
         }

         return true;
     }
     return QWidget::event(event);
 }

 void SortingBox::resizeEvent(QResizeEvent * /* event */)
 {
     int margin = style()->pixelMetric(QStyle::PM_DefaultTopLevelMargin);
     int x = width() - margin;
     int y = height() - margin;

     y = updateButtonGeometry(newCircleButton, x, y);
     y = updateButtonGeometry(newSquareButton, x, y);
     updateButtonGeometry(newTriangleButton, x, y);
 }

 void SortingBox::paintEvent(QPaintEvent * /* event */)
 {
     QPainter painter(this);
     painter.setRenderHint(QPainter::Antialiasing);
     foreach (ShapeItem shapeItem, shapeItems) {
         painter.translate(shapeItem.position());
         painter.setBrush(shapeItem.color());
         painter.drawPath(shapeItem.path());
         painter.translate(-shapeItem.position());
     }
 }

 void SortingBox::mousePressEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::LeftButton) {
         int index = itemAt(event->pos());
         if (index != -1) {
             itemInMotion = &shapeItems[index];
             previousPosition = event->pos();
             shapeItems.move(index, shapeItems.size() - 1);
             update();
         }
     }
 }

 void SortingBox::mouseMoveEvent(QMouseEvent *event)
 {
     if ((event->buttons() & Qt::LeftButton) && itemInMotion)
         moveItemTo(event->pos());
 }

 void SortingBox::mouseReleaseEvent(QMouseEvent *event)
 {
     if (event->button() == Qt::LeftButton && itemInMotion) {
         moveItemTo(event->pos());
         itemInMotion = 0;
     }
 }

 void SortingBox::createNewCircle()
 {
     static int count = 1;
     createShapeItem(circlePath, tr("Circle <%1>").arg(++count),
                     randomItemPosition(), randomItemColor());
 }

 void SortingBox::createNewSquare()
 {
     static int count = 1;
     createShapeItem(squarePath, tr("Square <%1>").arg(++count),
                     randomItemPosition(), randomItemColor());
 }

 void SortingBox::createNewTriangle()
 {
     static int count = 1;
     createShapeItem(trianglePath, tr("Triangle <%1>").arg(++count),
                     randomItemPosition(), randomItemColor());
 }

 int SortingBox::itemAt(const QPoint &pos)
 {
     for (int i = shapeItems.size() - 1; i >= 0; --i) {
         const ShapeItem &item = shapeItems[i];
         if (item.path().contains(pos - item.position()))
             return i;
     }
     return -1;
 }

 void SortingBox::moveItemTo(const QPoint &pos)
 {
     QPoint offset = pos - previousPosition;
     itemInMotion->setPosition(itemInMotion->position() + offset);
     previousPosition = pos;
     update();
 }

 int SortingBox::updateButtonGeometry(QToolButton *button, int x, int y)
 {
     QSize size = button->sizeHint();
     button->setGeometry(x - size.rwidth(), y - size.rheight(),
                         size.rwidth(), size.rheight());

     return y - size.rheight()
            - style()->pixelMetric(QStyle::PM_DefaultLayoutSpacing);
 }

 void SortingBox::createShapeItem(const QPainterPath &path,
                                  const QString &toolTip, const QPoint &pos,
                                  const QColor &color)
 {
     ShapeItem shapeItem;
     shapeItem.setPath(path);
     shapeItem.setToolTip(toolTip);
     shapeItem.setPosition(pos);
     shapeItem.setColor(color);
     shapeItems.append(shapeItem);
     update();
 }

 QToolButton *SortingBox::createToolButton(const QString &toolTip,
                                           const QIcon &icon, const char *member)
 {
     QToolButton *button = new QToolButton(this);
     button->setToolTip(toolTip);
     button->setIcon(icon);
     button->setIconSize(QSize(32, 32));
     connect(button, SIGNAL(clicked()), this, member);

     return button;
 }

 QPoint SortingBox::initialItemPosition(const QPainterPath &path)
 {
     int x;
     int y = (height() - (int)path.controlPointRect().height()) / 2;
     if (shapeItems.size() == 0)
         x = ((3 * width()) / 2 - (int)path.controlPointRect().width()) / 2;
     else
         x = (width() / shapeItems.size()
              - (int)path.controlPointRect().width()) / 2;

     return QPoint(x, y);
 }

 QPoint SortingBox::randomItemPosition()
 {
     return QPoint(qrand() % (width() - 120), qrand() % (height() - 120));
 }

 QColor SortingBox::initialItemColor()
 {
     return QColor::fromHsv(((shapeItems.size() + 1) * 85) % 256, 255, 190);
 }

 QColor SortingBox::randomItemColor()
 {
     return QColor::fromHsv(qrand() % 256, 255, 190);
 }