--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/demos/qtdemo/mainwindow.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,473 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the demonstration applications 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 "mainwindow.h"
+#include "menumanager.h"
+#include "colors.h"
+#include "dockitem.h"
+#include "demotextitem.h"
+#include "imageitem.h"
+#include "demoitem.h"
+#include "demoscene.h"
+
+#ifndef QT_NO_OPENGL
+ #include <QGLWidget>
+#endif
+//#define QT_NO_OPENGL
+
+MainWindow::MainWindow(QWidget *parent) : QGraphicsView(parent), updateTimer(this)
+{
+ this->currentFps = Colors::fps;
+ this->loop = false;
+ this->fpsMedian = -1;
+ this->fpsLabel = 0;
+ this->pausedLabel = 0;
+ this->doneAdapt = false;
+ this->useTimer = false;
+ this->updateTimer.setSingleShot(true);
+ this->companyLogo = 0;
+ this->qtLogo = 0;
+ this->setupWidget();
+ this->setupScene();
+ this->setupSceneItems();
+ this->drawBackgroundToPixmap();
+}
+
+MainWindow::~MainWindow()
+{
+ delete this->companyLogo;
+ delete this->qtLogo;
+}
+
+void MainWindow::setupWidget()
+{
+ QRect screenRect = QApplication::desktop()->screenGeometry(QApplication::desktop()->primaryScreen());
+ QRect windowRect(0, 0, 800, 600);
+ if (screenRect.width() < 800)
+ windowRect.setWidth(screenRect.width());
+ if (screenRect.height() < 600)
+ windowRect.setHeight(screenRect.height());
+ windowRect.moveCenter(screenRect.center());
+ this->setGeometry(windowRect);
+ this->setMinimumSize(80, 60);
+ setWindowTitle(tr("Qt Examples and Demos"));
+ setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+ setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+ setFrameStyle(QFrame::NoFrame);
+ this->setRenderingSystem();
+ connect(&this->updateTimer, SIGNAL(timeout()), this, SLOT(tick()));
+}
+
+void MainWindow::setRenderingSystem()
+{
+ QWidget *viewport = 0;
+
+#ifndef QT_NO_OPENGL
+ if (Colors::openGlRendering) {
+ QGLWidget *glw = new QGLWidget(QGLFormat(QGL::SampleBuffers));
+ if (Colors::noScreenSync)
+ glw->format().setSwapInterval(0);
+ glw->setAutoFillBackground(false);
+ viewport = glw;
+ setCacheMode(QGraphicsView::CacheNone);
+ if (Colors::verbose)
+ qDebug() << "- using OpenGL";
+ } else // software rendering
+#endif
+ {
+ // software rendering
+ viewport = new QWidget;
+ setCacheMode(QGraphicsView::CacheBackground);
+ if (Colors::verbose)
+ qDebug() << "- using software rendering";
+ }
+
+ setViewport(viewport);
+}
+
+void MainWindow::start()
+{
+ this->switchTimerOnOff(true);
+ this->demoStartTime.restart();
+ MenuManager::instance()->itemSelected(MenuManager::ROOT, Colors::rootMenuName);
+ if (Colors::verbose)
+ qDebug("- starting demo");
+}
+
+void MainWindow::enableMask(bool enable)
+{
+ if (!enable || Colors::noWindowMask)
+ this->clearMask();
+ else {
+ QPolygon region;
+ region.setPoints(9,
+ // north side:
+ 0, 0,
+ 800, 0,
+ // east side:
+ // 800, 70,
+ // 790, 90,
+ // 790, 480,
+ // 800, 500,
+ 800, 600,
+ // south side:
+ 700, 600,
+ 670, 590,
+ 130, 590,
+ 100, 600,
+ 0, 600,
+ // west side:
+ // 0, 550,
+ // 10, 530,
+ // 10, 520,
+ // 0, 520,
+ 0, 0);
+ this->setMask(QRegion(region));
+ }
+}
+
+void MainWindow::setupScene()
+{
+ this->scene = new DemoScene(this);
+ this->scene->setSceneRect(0, 0, 800, 600);
+ setScene(this->scene);
+ this->scene->setItemIndexMethod(QGraphicsScene::NoIndex);
+}
+
+void MainWindow::drawItems(QPainter *painter, int numItems, QGraphicsItem **items, const QStyleOptionGraphicsItem* options)
+{
+ QGraphicsView::drawItems(painter, numItems, items, options);
+}
+
+void MainWindow::switchTimerOnOff(bool on)
+{
+ bool ticker = MenuManager::instance()->ticker && MenuManager::instance()->ticker->scene();
+ if (ticker)
+ MenuManager::instance()->ticker->tickOnPaint = !on || Colors::noTimerUpdate;
+
+ if (on && !Colors::noTimerUpdate){
+ this->useTimer = true;
+ this->setViewportUpdateMode(QGraphicsView::NoViewportUpdate);
+ this->fpsTime = QTime::currentTime();
+ this->updateTimer.start(int(1000 / Colors::fps));
+ }
+ else{
+ this->useTimer = false;
+ this->updateTimer.stop();
+ if (Colors::softwareRendering)
+ if (Colors::noTicker)
+ this->setViewportUpdateMode(QGraphicsView::MinimalViewportUpdate);
+ else
+ this->setViewportUpdateMode(QGraphicsView::SmartViewportUpdate);
+ else
+ this->setViewportUpdateMode(QGraphicsView::FullViewportUpdate);
+ }
+}
+
+bool MainWindow::measureFps()
+{
+ // Calculate time diff:
+ float t = this->fpsTime.msecsTo(QTime::currentTime());
+ if (t == 0)
+ t = 0.01f;
+ this->currentFps = (1000.0f / t);
+ this->fpsHistory += this->currentFps;
+ this->fpsTime = QTime::currentTime();
+
+ // Calculate median:
+ int size = this->fpsHistory.size();
+ if (size == 10){
+ qSort(this->fpsHistory.begin(), this->fpsHistory.end());
+ this->fpsMedian = this->fpsHistory.at(int(size/2));
+ if (this->fpsMedian == 0)
+ this->fpsMedian = 0.01f;
+ this->fpsHistory.clear();
+ return true;
+ }
+ return false;
+}
+
+/**
+ Used for adaption in case things are so slow
+ that no median yet has been calculated
+*/
+void MainWindow::forceFpsMedianCalculation()
+{
+ if (this->fpsMedian != -1)
+ return;
+
+ int size = this->fpsHistory.size();
+ if (size == 0){
+ this->fpsMedian = 0.01f;
+ return;
+ }
+
+ qSort(this->fpsHistory.begin(), this->fpsHistory.end());
+ this->fpsMedian = this->fpsHistory.at(int(size/2));
+ if (this->fpsMedian == 0)
+ this->fpsMedian = 0.01f;
+}
+
+void MainWindow::tick()
+{
+ bool medianChanged = this->measureFps();
+ this->checkAdapt();
+
+ if (medianChanged && this->fpsLabel && Colors::showFps)
+ this->fpsLabel->setText(QString("FPS: ") + QString::number(int(this->currentFps)));
+
+ if (MenuManager::instance()->ticker)
+ MenuManager::instance()->ticker->tick();
+
+ this->viewport()->update();
+ if (this->useTimer)
+ this->updateTimer.start(int(1000 / Colors::fps));
+}
+
+void MainWindow::setupSceneItems()
+{
+ if (Colors::showFps){
+ this->fpsLabel = new DemoTextItem(QString("FPS: --"), Colors::buttonFont(), Qt::white, -1, this->scene, 0, DemoTextItem::DYNAMIC_TEXT);
+ this->fpsLabel->setZValue(100);
+ this->fpsLabel->setPos(Colors::stageStartX, 600 - QFontMetricsF(Colors::buttonFont()).height() - 5);
+ }
+
+ this->companyLogo = new ImageItem(QImage(":/images/trolltech-logo.png"), 1000, 1000, this->scene, 0, true, 0.5f);
+ this->qtLogo = new ImageItem(QImage(":/images/qtlogo_small.png"), 1000, 1000, this->scene, 0, true, 0.5f);
+ this->companyLogo->setZValue(100);
+ this->qtLogo->setZValue(100);
+ this->pausedLabel = new DemoTextItem(QString("PAUSED"), Colors::buttonFont(), Qt::white, -1, this->scene, 0);
+ this->pausedLabel->setZValue(100);
+ QFontMetricsF fm(Colors::buttonFont());
+ this->pausedLabel->setPos(Colors::stageWidth - fm.width("PAUSED"), 590 - fm.height());
+ this->pausedLabel->setRecursiveVisible(false);
+}
+
+void MainWindow::checkAdapt()
+{
+ if (this->doneAdapt
+ || Colors::noTimerUpdate
+ || this->demoStartTime.elapsed() < 2000)
+ return;
+
+ this->doneAdapt = true;
+ this->forceFpsMedianCalculation();
+ Colors::benchmarkFps = this->fpsMedian;
+ if (Colors::verbose)
+ qDebug() << "- benchmark:" << QString::number(Colors::benchmarkFps) << "FPS";
+
+ if (Colors::noAdapt)
+ return;
+
+ if (this->fpsMedian < 30){
+ if (MenuManager::instance()->ticker && MenuManager::instance()->ticker->scene()){
+ this->scene->removeItem(MenuManager::instance()->ticker);
+ Colors::noTimerUpdate = true;
+ this->switchTimerOnOff(false);
+ if (this->fpsLabel)
+ this->fpsLabel->setText(QString("FPS: (") + QString::number(this->fpsMedian) + QString(")"));
+ if (Colors::verbose)
+ qDebug() << "- benchmark adaption: removed ticker (fps < 30)";
+ }
+
+ if (this->fpsMedian < 20){
+ Colors::noAnimations = true;
+ if (Colors::verbose)
+ qDebug() << "- benchmark adaption: animations switched off (fps < 20)";
+ }
+
+ Colors::adapted = true;
+ }
+}
+
+int MainWindow::performBenchmark()
+{
+/*
+ QTime time;
+ time.restart();
+ while (time.elapsed() < 2000)
+ QCoreApplication::processEvents(QEventLoop::AllEvents, 50);
+*/
+ return 0;
+}
+
+void MainWindow::drawBackgroundToPixmap()
+{
+ const QRectF r = this->scene->sceneRect();
+ this->background = QPixmap(qRound(r.width()), qRound(r.height()));
+ this->background.fill(Qt::black);
+ QPainter painter(&this->background);
+
+ if (false && Colors::useEightBitPalette){
+ painter.fillRect(r, Colors::sceneBg1);
+ } else {
+ QImage bg(":/images/demobg.png");
+ painter.drawImage(0, 0, bg);
+ }
+}
+
+void MainWindow::drawBackground(QPainter *painter, const QRectF &rect)
+{
+ Q_UNUSED(rect);
+ painter->drawPixmap(QPoint(0, 0), this->background);
+}
+
+void MainWindow::showEvent(QShowEvent * event)
+{
+ Q_UNUSED(event);
+ QGraphicsView::showEvent(event);
+}
+
+void MainWindow::toggleFullscreen()
+{
+ if (this->isFullScreen()){
+ this->enableMask(true);
+ this->showNormal();
+ if (MenuManager::instance()->ticker)
+ MenuManager::instance()->ticker->pause(false);
+ }
+ else {
+ this->enableMask(false);
+ this->showFullScreen();
+ }
+}
+
+void MainWindow::keyPressEvent(QKeyEvent *event)
+{
+ if (event->key() == Qt::Key_Escape){
+ this->loop = false;
+ QApplication::quit();
+ }
+ else if (event->key() == Qt::Key_1){
+ QString s("");
+ s += "Rendering system: ";
+ if (Colors::openGlRendering)
+ s += "OpenGL";
+ else
+ s += "software";
+
+ s += "\nAdapt: ";
+ s += Colors::noAdapt ? "off" : "on";
+ s += "\nAdaption occured: ";
+ s += Colors::adapted ? "yes" : "no";
+ s += "\nOpenGL version: ";
+ s += Colors::glVersion;
+ QWidget w;
+ s += "\nColor bit depth: ";
+ s += QString::number(w.depth());
+ s += "\nWanted FPS: ";
+ s += QString::number(Colors::fps);
+ s += "\nBenchmarked FPS: ";
+ s += Colors::benchmarkFps != -1 ? QString::number(Colors::benchmarkFps) : "not calculated";
+ s += "\nAnimations: ";
+ s += Colors::noAnimations ? "off" : "on";
+ s += "\nBlending: ";
+ s += Colors::useEightBitPalette ? "off" : "on";
+ s += "\nTicker: ";
+ s += Colors::noTicker ? "off" : "on";
+ s += "\nPixmaps: ";
+ s += Colors::usePixmaps ? "on" : "off";
+ s += "\nRescale images on resize: ";
+ s += Colors::noRescale ? "off" : "on";
+ s += "\nTimer based updates: ";
+ s += Colors::noTimerUpdate ? "off" : "on";
+ s += "\nSeparate loop: ";
+ s += Colors::useLoop ? "yes" : "no";
+ s += "\nScreen sync: ";
+ s += Colors::noScreenSync ? "no" : "yes";
+ QMessageBox::information(0, QString("Current configuration"), s);
+ }
+}
+
+void MainWindow::focusInEvent(QFocusEvent *)
+{
+ if (!Colors::pause)
+ return;
+
+ if (MenuManager::instance()->ticker)
+ MenuManager::instance()->ticker->pause(false);
+
+ int code = MenuManager::instance()->currentMenuCode;
+ if (code == MenuManager::ROOT || code == MenuManager::MENU1)
+ this->switchTimerOnOff(true);
+
+ this->pausedLabel->setRecursiveVisible(false);
+}
+
+void MainWindow::focusOutEvent(QFocusEvent *)
+{
+ if (!Colors::pause)
+ return;
+
+ if (MenuManager::instance()->ticker)
+ MenuManager::instance()->ticker->pause(true);
+
+ int code = MenuManager::instance()->currentMenuCode;
+ if (code == MenuManager::ROOT || code == MenuManager::MENU1)
+ this->switchTimerOnOff(false);
+
+ this->pausedLabel->setRecursiveVisible(true);
+}
+
+void MainWindow::resizeEvent(QResizeEvent *event)
+{
+ Q_UNUSED(event);
+
+ this->resetMatrix();
+ this->scale(event->size().width() / 800.0, event->size().height() / 600.0);
+ QGraphicsView::resizeEvent(event);
+ DemoItem::setMatrix(this->matrix());
+
+ if (this->companyLogo){
+ const QRectF r = this->scene->sceneRect();
+ QRectF ttb = this->companyLogo->boundingRect();
+ this->companyLogo->setPos(int((r.width() - ttb.width()) / 2), 595 - ttb.height());
+ QRectF qtb = this->qtLogo->boundingRect();
+ this->qtLogo->setPos(802 - qtb.width(), 0);
+ }
+
+ // Changing size will almost always
+ // hurt FPS during the changing. So
+ // ignore it.
+ this->fpsHistory.clear();
+}
+
+