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

     2 **

     3 ** Copyright (C) 2009 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 "mainwindow.h"

    43 #include "menumanager.h"

    44 #include "colors.h"

    45 #include "dockitem.h"

    46 #include "demotextitem.h"

    47 #include "imageitem.h"

    48 #include "demoitem.h"

    49 #include "demoscene.h"

    50 

    51 #ifndef QT_NO_OPENGL

    52     #include <QGLWidget>

    53 #endif

    54 //#define QT_NO_OPENGL

    55 

    56 MainWindow::MainWindow(QWidget *parent) : QGraphicsView(parent), updateTimer(this)

    57 {

    58     this->currentFps = Colors::fps;

    59     this->loop = false;

    60     this->fpsMedian = -1;

    61     this->fpsLabel = 0;

    62     this->pausedLabel = 0;

    63     this->doneAdapt = false;

    64     this->useTimer = false;

    65     this->updateTimer.setSingleShot(true);

    66     this->companyLogo = 0;

    67     this->qtLogo = 0;

    68     this->setupWidget();

    69     this->setupScene();

    70     this->setupSceneItems();

    71     this->drawBackgroundToPixmap();

    72 }

    73 

    74 MainWindow::~MainWindow()

    75 {

    76     delete this->companyLogo;

    77     delete this->qtLogo;

    78 }

    79 

    80 void MainWindow::setupWidget()

    81 {

    82     QRect screenRect = QApplication::desktop()->screenGeometry(QApplication::desktop()->primaryScreen());

    83     QRect windowRect(0, 0, 800, 600);

    84     if (screenRect.width() < 800)

    85         windowRect.setWidth(screenRect.width());

    86     if (screenRect.height() < 600)

    87         windowRect.setHeight(screenRect.height());

    88     windowRect.moveCenter(screenRect.center());

    89     this->setGeometry(windowRect);

    90     this->setMinimumSize(80, 60);

    91     setWindowTitle(tr("Qt Examples and Demos"));

    92     setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    93     setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

    94     setFrameStyle(QFrame::NoFrame);

    95     this->setRenderingSystem();

    96     connect(&this->updateTimer, SIGNAL(timeout()), this, SLOT(tick()));

    97 }

    98 

    99 void MainWindow::setRenderingSystem()

   100 {

   101     QWidget *viewport = 0;

   102 

   103 #ifndef QT_NO_OPENGL

   104     if (Colors::openGlRendering) {

   105         QGLWidget *glw = new QGLWidget(QGLFormat(QGL::SampleBuffers));

   106         if (Colors::noScreenSync)

   107             glw->format().setSwapInterval(0);

   108         glw->setAutoFillBackground(false);

   109         viewport = glw;

   110         setCacheMode(QGraphicsView::CacheNone);

   111         if (Colors::verbose)

   112             qDebug() << "- using OpenGL";

   113     } else // software rendering

   114 #endif

   115     {

   116         // software rendering

   117         viewport = new QWidget;

   118         setCacheMode(QGraphicsView::CacheBackground);

   119         if (Colors::verbose)

   120             qDebug() << "- using software rendering";

   121     }

   122 

   123     setViewport(viewport);

   124 }

   125 

   126 void MainWindow::start()

   127 {

   128     this->switchTimerOnOff(true);

   129     this->demoStartTime.restart();

   130     MenuManager::instance()->itemSelected(MenuManager::ROOT, Colors::rootMenuName);

   131     if (Colors::verbose)

   132         qDebug("- starting demo");

   133 }

   134 

   135 void MainWindow::enableMask(bool enable)

   136 {

   137     if (!enable || Colors::noWindowMask)

   138         this->clearMask();

   139     else {

   140         QPolygon region;

   141         region.setPoints(9,

   142                                 // north side:

   143                                 0, 0,

   144                                 800, 0,

   145                                 // east side:

   146                                 // 800, 70,

   147                                 // 790, 90,

   148                                 // 790, 480,

   149                                 // 800, 500,

   150                                 800, 600,

   151                                 // south side:

   152                                 700, 600,

   153                                 670, 590,

   154                                 130, 590,

   155                                 100, 600,

   156                                 0, 600,

   157                                 // west side:

   158                                 // 0, 550,

   159                                 // 10, 530,

   160                                 // 10, 520,

   161                                 // 0, 520,

   162                                 0, 0);

   163         this->setMask(QRegion(region));

   164     }

   165 }

   166 

   167 void MainWindow::setupScene()

   168 {

   169     this->scene = new DemoScene(this);

   170     this->scene->setSceneRect(0, 0, 800, 600);

   171     setScene(this->scene);

   172     this->scene->setItemIndexMethod(QGraphicsScene::NoIndex);

   173 }

   174 

   175 void MainWindow::drawItems(QPainter *painter, int numItems, QGraphicsItem **items, const QStyleOptionGraphicsItem* options)

   176 {

   177     QGraphicsView::drawItems(painter, numItems, items, options);

   178 }

   179 

   180 void MainWindow::switchTimerOnOff(bool on)

   181 {

   182     bool ticker = MenuManager::instance()->ticker && MenuManager::instance()->ticker->scene();

   183     if (ticker)

   184         MenuManager::instance()->ticker->tickOnPaint = !on || Colors::noTimerUpdate;

   185 

   186     if (on && !Colors::noTimerUpdate){

   187         this->useTimer = true;

   188         this->setViewportUpdateMode(QGraphicsView::NoViewportUpdate);

   189         this->fpsTime = QTime::currentTime();

   190         this->updateTimer.start(int(1000 / Colors::fps));

   191     }

   192     else{

   193         this->useTimer = false;

   194         this->updateTimer.stop();

   195         if (Colors::softwareRendering)

   196             if (Colors::noTicker)

   197                 this->setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);

   198             else

   199                 this->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);

   200         else

   201             this->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);

   202     }

   203 }

   204 

   205 bool MainWindow::measureFps()

   206 {

   207     // Calculate time diff:

   208     float t = this->fpsTime.msecsTo(QTime::currentTime());

   209     if (t == 0)

   210         t = 0.01f;

   211     this->currentFps = (1000.0f / t);

   212     this->fpsHistory += this->currentFps;

   213     this->fpsTime = QTime::currentTime();

   214 

   215     // Calculate median:

   216     int size = this->fpsHistory.size();

   217     if (size == 10){

   218         qSort(this->fpsHistory.begin(), this->fpsHistory.end());

   219         this->fpsMedian = this->fpsHistory.at(int(size/2));

   220         if (this->fpsMedian == 0)

   221             this->fpsMedian = 0.01f;

   222         this->fpsHistory.clear();

   223         return true;

   224     }

   225     return false;

   226 }

   227 

   228 /**

   229     Used for adaption in case things are so slow

   230     that no median  yet has been calculated

   231 */

   232 void MainWindow::forceFpsMedianCalculation()

   233 {

   234     if (this->fpsMedian != -1)

   235         return;

   236 

   237     int size = this->fpsHistory.size();

   238     if (size == 0){

   239         this->fpsMedian = 0.01f;

   240         return;

   241     }

   242 

   243     qSort(this->fpsHistory.begin(), this->fpsHistory.end());

   244     this->fpsMedian = this->fpsHistory.at(int(size/2));

   245     if (this->fpsMedian == 0)

   246         this->fpsMedian = 0.01f;

   247 }

   248 

   249 void MainWindow::tick()

   250 {

   251     bool medianChanged = this->measureFps();

   252     this->checkAdapt();

   253 

   254     if (medianChanged && this->fpsLabel && Colors::showFps)

   255         this->fpsLabel->setText(QString("FPS: ") + QString::number(int(this->currentFps)));

   256 

   257     if (MenuManager::instance()->ticker)

   258         MenuManager::instance()->ticker->tick();

   259 

   260     this->viewport()->update();

   261     if (this->useTimer)

   262         this->updateTimer.start(int(1000 / Colors::fps));

   263 }

   264 

   265 void MainWindow::setupSceneItems()

   266 {

   267     if (Colors::showFps){

   268         this->fpsLabel = new DemoTextItem(QString("FPS: --"), Colors::buttonFont(), Qt::white, -1, this->scene, 0, DemoTextItem::DYNAMIC_TEXT);

   269         this->fpsLabel->setZValue(100);

   270         this->fpsLabel->setPos(Colors::stageStartX, 600 - QFontMetricsF(Colors::buttonFont()).height() - 5);

   271     }

   272 

   273     this->companyLogo = new ImageItem(QImage(":/images/trolltech-logo.png"), 1000, 1000, this->scene, 0, true, 0.5f);

   274     this->qtLogo = new ImageItem(QImage(":/images/qtlogo_small.png"), 1000, 1000, this->scene, 0, true, 0.5f);

   275     this->companyLogo->setZValue(100);

   276     this->qtLogo->setZValue(100);

   277     this->pausedLabel = new DemoTextItem(QString("PAUSED"), Colors::buttonFont(), Qt::white, -1, this->scene, 0);

   278     this->pausedLabel->setZValue(100);

   279     QFontMetricsF fm(Colors::buttonFont());

   280     this->pausedLabel->setPos(Colors::stageWidth - fm.width("PAUSED"), 590 - fm.height());

   281     this->pausedLabel->setRecursiveVisible(false);

   282 }

   283 

   284 void MainWindow::checkAdapt()

   285 {

   286     if (this->doneAdapt

   287         || Colors::noTimerUpdate

   288         || this->demoStartTime.elapsed() < 2000)

   289        return;

   290 

   291     this->doneAdapt = true;

   292     this->forceFpsMedianCalculation();

   293     Colors::benchmarkFps = this->fpsMedian;

   294     if (Colors::verbose)

   295         qDebug() << "- benchmark:" << QString::number(Colors::benchmarkFps) << "FPS";

   296 

   297     if (Colors::noAdapt)

   298         return;

   299 

   300     if (this->fpsMedian < 30){

   301         if (MenuManager::instance()->ticker && MenuManager::instance()->ticker->scene()){

   302             this->scene->removeItem(MenuManager::instance()->ticker);

   303             Colors::noTimerUpdate = true;

   304             this->switchTimerOnOff(false);

   305             if (this->fpsLabel)

   306                this->fpsLabel->setText(QString("FPS: (") + QString::number(this->fpsMedian) + QString(")"));

   307             if (Colors::verbose)

   308                qDebug() << "- benchmark adaption: removed ticker (fps < 30)";

   309         }

   310 

   311         if (this->fpsMedian < 20){

   312             Colors::noAnimations = true;

   313             if (Colors::verbose)

   314                qDebug() << "- benchmark adaption: animations switched off (fps < 20)";

   315         }

   316 

   317         Colors::adapted = true;

   318     }

   319 }

   320 

   321 int MainWindow::performBenchmark()

   322 {

   323 /*

   324     QTime time;

   325     time.restart();

   326     while (time.elapsed() < 2000)

   327         QCoreApplication::processEvents(QEventLoop::AllEvents, 50);

   328 */

   329     return 0;

   330 }

   331 

   332 void MainWindow::drawBackgroundToPixmap()

   333 {

   334     const QRectF r = this->scene->sceneRect();

   335     this->background = QPixmap(qRound(r.width()), qRound(r.height()));

   336     this->background.fill(Qt::black);

   337     QPainter painter(&this->background);

   338 

   339     if (false && Colors::useEightBitPalette){

   340         painter.fillRect(r, Colors::sceneBg1);

   341     } else {

   342         QImage bg(":/images/demobg.png");

   343         painter.drawImage(0, 0, bg);

   344     }

   345 }

   346 

   347 void MainWindow::drawBackground(QPainter *painter, const QRectF &rect)

   348 {

   349     Q_UNUSED(rect);

   350     painter->drawPixmap(QPoint(0, 0), this->background);

   351 }

   352 

   353 void MainWindow::showEvent(QShowEvent * event)

   354 {

   355     Q_UNUSED(event);

   356     QGraphicsView::showEvent(event);

   357 }

   358 

   359 void MainWindow::toggleFullscreen()

   360 {

   361     if (this->isFullScreen()){

   362         this->enableMask(true);

   363         this->showNormal();

   364         if (MenuManager::instance()->ticker)

   365             MenuManager::instance()->ticker->pause(false);

   366     }

   367     else {

   368         this->enableMask(false);

   369         this->showFullScreen();

   370     }

   371 }

   372 

   373 void MainWindow::keyPressEvent(QKeyEvent *event)

   374 {

   375     if (event->key() == Qt::Key_Escape){

   376         this->loop = false;

   377         QApplication::quit();

   378     }

   379     else if (event->key() == Qt::Key_1){

   380             QString s("");

   381             s += "Rendering system: ";

   382             if (Colors::openGlRendering)

   383                 s += "OpenGL";

   384             else

   385                 s += "software";

   386 

   387             s += "\nAdapt: ";

   388             s += Colors::noAdapt ? "off" : "on";

   389             s += "\nAdaption occured: ";

   390             s += Colors::adapted ? "yes" : "no";

   391             s += "\nOpenGL version: ";

   392             s += Colors::glVersion;

   393             QWidget w;

   394             s += "\nColor bit depth: ";

   395             s += QString::number(w.depth());

   396             s += "\nWanted FPS: ";

   397             s += QString::number(Colors::fps);

   398             s += "\nBenchmarked FPS: ";

   399             s += Colors::benchmarkFps != -1 ? QString::number(Colors::benchmarkFps) : "not calculated";

   400             s += "\nAnimations: ";

   401             s += Colors::noAnimations ? "off" : "on";

   402             s += "\nBlending: ";

   403             s += Colors::useEightBitPalette ? "off" : "on";

   404             s += "\nTicker: ";

   405             s += Colors::noTicker ? "off" : "on";

   406             s += "\nPixmaps: ";

   407             s += Colors::usePixmaps ? "on" : "off";

   408             s += "\nRescale images on resize: ";

   409             s += Colors::noRescale ? "off" : "on";

   410             s += "\nTimer based updates: ";

   411             s += Colors::noTimerUpdate ? "off" : "on";

   412             s += "\nSeparate loop: ";

   413             s += Colors::useLoop ? "yes" : "no";

   414             s += "\nScreen sync: ";

   415             s += Colors::noScreenSync ? "no" : "yes";

   416             QMessageBox::information(0, QString("Current configuration"), s);

   417     }

   418 }

   419 

   420 void MainWindow::focusInEvent(QFocusEvent *)

   421 {

   422     if (!Colors::pause)

   423         return;

   424 

   425     if (MenuManager::instance()->ticker)

   426         MenuManager::instance()->ticker->pause(false);

   427 

   428     int code = MenuManager::instance()->currentMenuCode;

   429     if (code == MenuManager::ROOT || code == MenuManager::MENU1)

   430         this->switchTimerOnOff(true);

   431 

   432     this->pausedLabel->setRecursiveVisible(false);

   433 }

   434 

   435 void MainWindow::focusOutEvent(QFocusEvent *)

   436 {

   437     if (!Colors::pause)

   438         return;

   439 

   440     if (MenuManager::instance()->ticker)

   441         MenuManager::instance()->ticker->pause(true);

   442 

   443     int code = MenuManager::instance()->currentMenuCode;

   444     if (code == MenuManager::ROOT || code == MenuManager::MENU1)

   445         this->switchTimerOnOff(false);

   446 

   447     this->pausedLabel->setRecursiveVisible(true);

   448 }

   449 

   450 void MainWindow::resizeEvent(QResizeEvent *event)

   451 {

   452     Q_UNUSED(event);

   453 

   454     this->resetMatrix();

   455     this->scale(event->size().width() / 800.0, event->size().height() / 600.0);

   456     QGraphicsView::resizeEvent(event);

   457     DemoItem::setMatrix(this->matrix());

   458 

   459     if (this->companyLogo){

   460         const QRectF r = this->scene->sceneRect();

   461         QRectF ttb = this->companyLogo->boundingRect();

   462         this->companyLogo->setPos(int((r.width() - ttb.width()) / 2), 595 - ttb.height());

   463         QRectF qtb = this->qtLogo->boundingRect();

   464         this->qtLogo->setPos(802 - qtb.width(), 0);

   465     }

   466 

   467     // Changing size will almost always

   468     // hurt FPS during the changing. So

   469     // ignore it.

   470     this->fpsHistory.clear();

   471 }

   472 

   473