Long live Qt!

1 files changed, 350 insertions, 0 deletions

diff --git a/src/gui/widgets/qsplashscreen.cpp b/src/gui/widgets/qsplashscreen.cpp
new file mode 100644
index 0000000..4240096
--- /dev/null
+++ b/src/gui/widgets/qsplashscreen.cpp
@@ -0,0 +1,350 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.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 the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qsplashscreen.h"
+
+#ifndef QT_NO_SPLASHSCREEN
+
+#include "qapplication.h"
+#include "qdesktopwidget.h"
+#include "qpainter.h"
+#include "qpixmap.h"
+#include "qtextdocument.h"
+#include "qtextcursor.h"
+#include <QtCore/qdebug.h>
+#include <private/qwidget_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QSplashScreenPrivate : public QWidgetPrivate
+{
+    Q_DECLARE_PUBLIC(QSplashScreen)
+public:
+    QPixmap pixmap;
+    QString currStatus;
+    QColor currColor;
+    int currAlign;
+
+    inline QSplashScreenPrivate();
+    void drawContents();
+};
+
+/*!
+   \class QSplashScreen
+   \brief The QSplashScreen widget provides a splash screen that can
+   be shown during application startup.
+
+   \ingroup misc
+   \mainclass
+
+   A splash screen is a widget that is usually displayed when an
+   application is being started. Splash screens are often used for
+   applications that have long start up times (e.g. database or
+   networking applications that take time to establish connections) to
+   provide the user with feedback that the application is loading.
+
+   The splash screen appears in the center of the screen. It may be
+   useful to add the Qt::WindowStaysOnTopHint to the splash widget's
+   window flags if you want to keep it above all the other windows on
+   the desktop.
+
+   Some X11 window managers do not support the "stays on top" flag. A
+   solution is to set up a timer that periodically calls raise() on
+   the splash screen to simulate the "stays on top" effect.
+
+   The most common usage is to show a splash screen before the main
+   widget is displayed on the screen. This is illustrated in the
+   following code snippet in which a splash screen is displayed and
+   some initialization tasks are performed before the application's
+   main window is shown:
+
+   \snippet doc/src/snippets/qsplashscreen/main.cpp 0
+   \dots
+   \snippet doc/src/snippets/qsplashscreen/main.cpp 1
+
+   The user can hide the splash screen by clicking on it with the
+   mouse. Since the splash screen is typically displayed before the
+   event loop has started running, it is necessary to periodically
+   call QApplication::processEvents() to receive the mouse clicks.
+
+   It is sometimes useful to update the splash screen with messages,
+   for example, announcing connections established or modules loaded
+   as the application starts up:
+
+   \snippet doc/src/snippets/code/src_gui_widgets_qsplashscreen.cpp 0
+
+   QSplashScreen supports this with the showMessage() function. If you
+   wish to do your own drawing you can get a pointer to the pixmap
+   used in the splash screen with pixmap().  Alternatively, you can
+   subclass QSplashScreen and reimplement drawContents().
+*/
+
+/*!
+    Construct a splash screen that will display the \a pixmap.
+
+    There should be no need to set the widget flags, \a f, except
+    perhaps Qt::WindowStaysOnTopHint.
+*/
+QSplashScreen::QSplashScreen(const QPixmap &pixmap, Qt::WindowFlags f)
+    : QWidget(*(new QSplashScreenPrivate()), 0, Qt::SplashScreen | f)
+{
+    d_func()->pixmap = pixmap;
+    setPixmap(d_func()->pixmap);  // Does an implicit repaint
+}
+
+/*!
+    \overload
+
+    This function allows you to specify a parent for your splashscreen. The
+    typical use for this constructor is if you have a multiple screens and
+    prefer to have the splash screen on a different screen than your primary
+    one. In that case pass the proper desktop() as the \a parent.
+*/
+QSplashScreen::QSplashScreen(QWidget *parent, const QPixmap &pixmap, Qt::WindowFlags f)
+    : QWidget(*new QSplashScreenPrivate, parent, Qt::SplashScreen | f)
+{
+    d_func()->pixmap = pixmap;
+    setPixmap(d_func()->pixmap);  // Does an implicit repaint
+}
+
+/*!
+  Destructor.
+*/
+QSplashScreen::~QSplashScreen()
+{
+}
+
+/*!
+    \reimp
+*/
+void QSplashScreen::mousePressEvent(QMouseEvent *)
+{
+    hide();
+}
+
+/*!
+    This overrides QWidget::repaint(). It differs from the standard
+    repaint function in that it also calls QApplication::flush() to
+    ensure the updates are displayed, even when there is no event loop
+    present.
+*/
+void QSplashScreen::repaint()
+{
+    d_func()->drawContents();
+    QWidget::repaint();
+    QApplication::flush();
+}
+
+/*!
+    \fn QSplashScreen::messageChanged(const QString &message)
+
+    This signal is emitted when the message on the splash screen
+    changes. \a message is the new message and is a null-string
+    when the message has been removed.
+
+    \sa showMessage(), clearMessage()
+*/
+
+
+
+/*!
+    Draws the \a message text onto the splash screen with color \a
+    color and aligns the text according to the flags in \a alignment.
+
+    \sa Qt::Alignment, clearMessage()
+*/
+void QSplashScreen::showMessage(const QString &message, int alignment,
+                                const QColor &color)
+{
+    Q_D(QSplashScreen);
+    d->currStatus = message;
+    d->currAlign = alignment;
+    d->currColor = color;
+    emit messageChanged(d->currStatus);
+    repaint();
+}
+
+/*!
+    Removes the message being displayed on the splash screen
+
+    \sa showMessage()
+ */
+void QSplashScreen::clearMessage()
+{
+    d_func()->currStatus.clear();
+    emit messageChanged(d_func()->currStatus);
+    repaint();
+}
+
+/*!
+    Makes the splash screen wait until the widget \a mainWin is displayed
+    before calling close() on itself.
+*/
+void QSplashScreen::finish(QWidget *mainWin)
+{
+    if (mainWin) {
+#if defined(Q_WS_X11)
+        extern void qt_x11_wait_for_window_manager(QWidget *mainWin);
+        qt_x11_wait_for_window_manager(mainWin);
+#endif
+    }
+    close();
+}
+
+/*!
+    Sets the pixmap that will be used as the splash screen's image to
+    \a pixmap.
+*/
+void QSplashScreen::setPixmap(const QPixmap &pixmap)
+{
+    Q_D(QSplashScreen);
+
+    if (pixmap.hasAlpha()) {
+        QPixmap opaque(pixmap.size());
+        QPainter p(&opaque);
+        p.fillRect(0, 0, pixmap.width(), pixmap.height(), palette().background());
+        p.drawPixmap(0, 0, pixmap);
+        p.end();
+        d->pixmap = opaque;
+    } else {
+        d->pixmap = pixmap;
+    }
+
+    QRect r(0, 0, d->pixmap.size().width(), d->pixmap.size().height());
+    resize(d->pixmap.size());
+    move(QApplication::desktop()->screenGeometry().center() - r.center());
+    if (!isVisible())
+        d->drawContents();
+    else
+        repaint();
+}
+
+/*!
+    Returns the pixmap that is used in the splash screen. The image
+    does not have any of the text drawn by showMessage() calls.
+*/
+const QPixmap QSplashScreen::pixmap() const
+{
+    return d_func()->pixmap;
+}
+
+/*!
+  \internal
+*/
+void QSplashScreenPrivate::drawContents()
+{
+    Q_Q(QSplashScreen);
+    QPixmap textPix = pixmap;
+    if (!textPix.isNull()) {
+        QPainter painter(&textPix);
+        painter.initFrom(q);
+        q->drawContents(&painter);
+        QPalette p = q->palette();
+        p.setBrush(q->backgroundRole(), QBrush(textPix));
+        q->setPalette(p);
+    }
+}
+
+/*!
+    \internal
+*/
+inline QSplashScreenPrivate::QSplashScreenPrivate() : currAlign(Qt::AlignLeft)
+{
+}
+
+/*!
+    Draw the contents of the splash screen using painter \a painter.
+    The default implementation draws the message passed by showMessage().
+    Reimplement this function if you want to do your own drawing on
+    the splash screen.
+*/
+void QSplashScreen::drawContents(QPainter *painter)
+{
+    Q_D(QSplashScreen);
+    painter->setPen(d->currColor);
+    QRect r = rect();
+    r.setRect(r.x() + 5, r.y() + 5, r.width() - 10, r.height() - 10);
+    if (Qt::mightBeRichText(d->currStatus)) {
+        QTextDocument doc;
+#ifdef QT_NO_TEXTHTMLPARSER
+        doc.setPlainText(d->currStatus);
+#else
+        doc.setHtml(d->currStatus);
+#endif
+        doc.setTextWidth(r.width());
+        QTextCursor cursor(&doc);
+        cursor.select(QTextCursor::Document);
+        QTextBlockFormat fmt;
+        fmt.setAlignment(Qt::Alignment(d->currAlign));
+        cursor.mergeBlockFormat(fmt);
+        painter->save();
+        painter->translate(r.topLeft());
+        doc.drawContents(painter);
+        painter->restore();
+    } else {
+        painter->drawText(r, d->currAlign, d->currStatus);
+    }
+}
+
+/*!
+    \fn void QSplashScreen::message(const QString &message, int alignment,
+                                    const QColor &color)
+    \compat
+
+    Use showMessage() instead.
+*/
+
+/*!
+    \fn void QSplashScreen::clear()
+    \compat
+
+    Use clearMessage() instead.
+*/
+
+/*! \reimp */
+bool QSplashScreen::event(QEvent *e)
+{
+    return QWidget::event(e);
+}
+
+QT_END_NAMESPACE
+
+#endif //QT_NO_SPLASHSCREEN