Qt 4.6: panel.cpp Example File (graphicsview/padnavigator/panel.cpp)

|  | Home · All Classes · Overviews |

# panel.cpp Example File
graphicsview/padnavigator/panel.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
     ** 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 "panel.h"
     #include "roundrectitem.h"
     #include "splashitem.h"
     #include "ui_backside.h"

     #ifndef QT_NO_OPENGL
     #include <QtOpenGL/QtOpenGL>
     #else
     #endif
     #include <QtGui/QtGui>

     #include <math.h>

     Panel::Panel(int width, int height)
         : selectedX(0),
           selectedY(0),
           width(width),
           height(height),
           flipped(false),
           flipLeft(true)
     {
         setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         setCacheMode(CacheBackground);
         setViewportUpdateMode(FullViewportUpdate);
         setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform
                        | QPainter::TextAntialiasing);
         setBackgroundBrush(QPixmap(":/images/blue_angle_swirl.jpg"));
     #ifndef QT_NO_OPENGL
         setViewport(new QGLWidget(QGLFormat(QGL::SampleBuffers)));
     #endif
         setMinimumSize(50, 50);

         selectionTimeLine = new QTimeLine(150, this);
         flipTimeLine = new QTimeLine(500, this);

         QRectF bounds((-width / 2.0) * 150, (-height / 2.0) * 150, width * 150, height * 150);

         scene = new QGraphicsScene(bounds, this);
         scene->setItemIndexMethod(QGraphicsScene::NoIndex);
         setScene(scene);

         baseItem = new RoundRectItem(bounds, QColor(226, 255, 92, 64));
         scene->addItem(baseItem);

         QWidget *embed = new QWidget;
         ui = new Ui_BackSide;
         ui->setupUi(embed);
         ui->hostName->setFocus();

         backItem = new RoundRectItem(bounds, embed->palette().window(), embed);
         backItem->setTransform(QTransform().rotate(180, Qt::YAxis));
         backItem->setParentItem(baseItem);

         selectionItem = new RoundRectItem(QRectF(-60, -60, 120, 120), Qt::gray);
         selectionItem->setParentItem(baseItem);
         selectionItem->setZValue(-1);
         selectionItem->setPos(posForLocation(0, 0));
         startPos = selectionItem->pos();

         grid = new QGraphicsItem **[height];

         for (int y = 0; y < height; ++y) {
             grid[y] = new QGraphicsItem *[width];

             for (int x = 0; x < width; ++x) {
                 RoundRectItem *item = new RoundRectItem(QRectF(-54, -54, 108, 108),
                                                         QColor(214, 240, 110, 128));
                 item->setPos(posForLocation(x, y));

                 item->setParentItem(baseItem);
                 item->setFlag(QGraphicsItem::ItemIsFocusable);
                 grid[y][x] = item;

                 switch (qrand() % 9) {
                 case 0: item->setPixmap(QPixmap(":/images/kontact_contacts.png")); break;
                 case 1: item->setPixmap(QPixmap(":/images/kontact_journal.png")); break;
                 case 2: item->setPixmap(QPixmap(":/images/kontact_notes.png")); break;
                 case 3: item->setPixmap(QPixmap(":/images/kopeteavailable.png")); break;
                 case 4: item->setPixmap(QPixmap(":/images/metacontact_online.png")); break;
                 case 5: item->setPixmap(QPixmap(":/images/minitools.png")); break;
                 case 6: item->setPixmap(QPixmap(":/images/kontact_journal.png")); break;
                 case 7: item->setPixmap(QPixmap(":/images/kontact_contacts.png")); break;
                 case 8: item->setPixmap(QPixmap(":/images/kopeteavailable.png")); break;
                 default:
                     break;
                 }

                 connect(item, SIGNAL(activated()), this, SLOT(flip()));
             }
         }

         grid[0][0]->setFocus();

         connect(backItem, SIGNAL(activated()),
                 this, SLOT(flip()));
         connect(selectionTimeLine, SIGNAL(valueChanged(qreal)),
                 this, SLOT(updateSelectionStep(qreal)));
         connect(flipTimeLine, SIGNAL(valueChanged(qreal)),
                 this, SLOT(updateFlipStep(qreal)));

         splash = new SplashItem;
         splash->setZValue(5);
         splash->setPos(-splash->rect().width() / 2, scene->sceneRect().top());
         scene->addItem(splash);

         splash->grabKeyboard();

         updateSelectionStep(0);

         setWindowTitle(tr("Pad Navigator Example"));
     }

     Panel::~Panel()
     {
         for (int y = 0; y < height; ++y)
             delete [] grid[y];
         delete [] grid;
     }

     void Panel::keyPressEvent(QKeyEvent *event)
     {
         if (splash->isVisible() || event->key() == Qt::Key_Return || flipped) {
             QGraphicsView::keyPressEvent(event);
             return;
         }

         selectedX = (selectedX + width + (event->key() == Qt::Key_Right) - (event->key() == Qt::Key_Left)) % width;
         selectedY = (selectedY + height + (event->key() == Qt::Key_Down) - (event->key() == Qt::Key_Up)) % height;
         grid[selectedY][selectedX]->setFocus();

         selectionTimeLine->stop();
         startPos = selectionItem->pos();
         endPos = posForLocation(selectedX, selectedY);
         selectionTimeLine->start();
     }

     void Panel::resizeEvent(QResizeEvent *event)
     {
         QGraphicsView::resizeEvent(event);
         fitInView(scene->sceneRect(), Qt::KeepAspectRatio);
     }

     void Panel::updateSelectionStep(qreal val)
     {
         QPointF newPos(startPos.x() + (endPos - startPos).x() * val,
                        startPos.y() + (endPos - startPos).y() * val);
         selectionItem->setPos(newPos);

         QTransform transform;
         yrot = newPos.x() / 6.0;
         xrot = newPos.y() / 6.0;
         transform.rotate(newPos.x() / 6.0, Qt::YAxis);
         transform.rotate(newPos.y() / 6.0, Qt::XAxis);
         baseItem->setTransform(transform);
     }

     void Panel::updateFlipStep(qreal val)
     {
         qreal finalxrot = xrot - xrot * val;
         qreal finalyrot;
         if (flipLeft)
             finalyrot = yrot - yrot * val - 180 * val;
         else
             finalyrot = yrot - yrot * val + 180 * val;
         QTransform transform;
         transform.rotate(finalyrot, Qt::YAxis);
         transform.rotate(finalxrot, Qt::XAxis);
         qreal scale = 1 - sin(3.14 * val) * 0.3;
         transform.scale(scale, scale);
         baseItem->setTransform(transform);
         if (val == 0)
             grid[selectedY][selectedX]->setFocus();
     }

     void Panel::flip()
     {
         if (flipTimeLine->state() == QTimeLine::Running)
             return;

         if (flipTimeLine->currentValue() == 0) {
             flipTimeLine->setDirection(QTimeLine::Forward);
             flipTimeLine->start();
             flipped = true;
             flipLeft = selectionItem->pos().x() < 0;
         } else {
             flipTimeLine->setDirection(QTimeLine::Backward);
             flipTimeLine->start();
             flipped = false;
         }
     }

     QPointF Panel::posForLocation(int x, int y) const
     {
         return QPointF(x * 150, y * 150)
             - QPointF((width - 1) * 75, (height - 1) * 75);
     }