Add Qt3 development HEAD version

1 files changed, 1081 insertions, 0 deletions

diff --git a/src/kernel/qmovie.cpp b/src/kernel/qmovie.cpp
new file mode 100644
index 0000000..3379fba
--- /dev/null
+++ b/src/kernel/qmovie.cpp
@@ -0,0 +1,1081 @@
+/****************************************************************************
+**
+** Implementation of movie classes
+**
+** Created : 970617
+**
+** Copyright (C) 1992-2008 Trolltech ASA.  All rights reserved.
+**
+** This file is part of the kernel module of the Qt GUI Toolkit.
+**
+** This file may be used under the terms of the GNU General
+** Public License versions 2.0 or 3.0 as published by the Free
+** Software Foundation and appearing in the files LICENSE.GPL2
+** and LICENSE.GPL3 included in the packaging of this file.
+** Alternatively you may (at your option) use any later version
+** of the GNU General Public License if such license has been
+** publicly approved by Trolltech ASA (or its successors, if any)
+** and the KDE Free Qt Foundation.
+**
+** Please review the following information to ensure GNU General
+** Public Licensing requirements will be met:
+** http://trolltech.com/products/qt/licenses/licensing/opensource/.
+** If you are unsure which license is appropriate for your use, please
+** review the following information:
+** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
+** or contact the sales department at [email protected].
+**
+** This file may be used under the terms of the Q Public License as
+** defined by Trolltech ASA and appearing in the file LICENSE.QPL
+** included in the packaging of this file.  Licensees holding valid Qt
+** Commercial licenses may use this file in accordance with the Qt
+** Commercial License Agreement provided with the Software.
+**
+** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
+** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
+** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted
+** herein.
+**
+**********************************************************************/
+
+// #define QT_SAVE_MOVIE_HACK
+
+#include "qtimer.h"
+#include "qpainter.h"
+#include "qptrlist.h"
+#include "qbitmap.h"
+#include "qmovie.h"
+#include "qfile.h"
+#include "qbuffer.h"
+#include "qobject.h"
+#include "qpixmapcache.h"
+
+#ifndef QT_NO_MOVIE
+
+#ifdef Q_WS_QWS
+#include "qgfx_qws.h"
+#endif
+
+#include "qasyncio.h"
+#include "qasyncimageio.h"
+
+#include <stdlib.h>
+
+/*!
+    \class QMovie qmovie.h
+    \brief The QMovie class provides incremental loading of animations or images, signalling as it progresses.
+
+    \ingroup images
+    \ingroup graphics
+    \ingroup multimedia
+    \mainclass
+
+    The simplest way to display a QMovie is to use a QLabel and
+    QLabel::setMovie().
+
+    A QMovie provides a QPixmap as the framePixmap(); connections can
+    be made via connectResize() and connectUpdate() to receive
+    notification of size and pixmap changes. All decoding is driven
+    by the normal event-processing mechanisms.
+
+    The movie begins playing as soon as the QMovie is created
+    (actually, once control returns to the event loop). When the last
+    frame in the movie has been played, it may loop back to the start
+    if such looping is defined in the input source.
+
+    QMovie objects are explicitly shared. This means that a QMovie
+    copied from another QMovie will be displaying the same frame at
+    all times. If one shared movie pauses, all pause. To make \e
+    independent movies, they must be constructed separately.
+
+    The set of data formats supported by QMovie is determined by the
+    decoder factories that have been installed; the format of the
+    input is determined as the input is decoded.
+
+    The supported formats are MNG (if Qt is configured with MNG
+    support enabled) and GIF (if Qt is configured with GIF support
+    enabled, see qgif.h).
+
+    If Qt is configured to support GIF reading, we are required to
+    state that "The Graphics Interchange Format(c) is the Copyright
+    property of CompuServe Incorporated. GIF(sm) is a Service Mark
+    property of CompuServe Incorporated.
+
+    \warning If you are in a country that recognizes software patents
+    and in which Unisys holds a patent on LZW compression and/or
+    decompression and you want to use GIF, Unisys may require you to
+    license that technology. Such countries include Canada, Japan,
+    the USA, France, Germany, Italy and the UK.
+
+    GIF support may be removed completely in a future version of Qt.
+    We recommend using the MNG or PNG format.
+
+    \img qmovie.png QMovie
+
+    \sa QLabel::setMovie()
+*/
+
+/*!
+    \enum QMovie::Status
+
+    \value SourceEmpty
+    \value UnrecognizedFormat
+    \value Paused
+    \value EndOfFrame
+    \value EndOfLoop
+    \value EndOfMovie
+    \value SpeedChanged
+*/
+
+class QMoviePrivate : public QObject, public QShared,
+		      private QDataSink, private QImageConsumer
+{
+    Q_OBJECT
+
+public: // for QMovie
+
+    // Creates a null Private
+    QMoviePrivate();
+
+    // NOTE:  The ownership of the QDataSource is transferred to the Private
+    QMoviePrivate(QDataSource* src, QMovie* movie, int bufsize);
+
+    virtual ~QMoviePrivate();
+
+    bool isNull() const;
+
+    // Initialize, possibly to the null state
+    void init(bool fully);
+    void flushBuffer();
+    void updatePixmapFromImage();
+    void updatePixmapFromImage(const QPoint& off, const QRect& area);
+    void showChanges();
+
+    // This as QImageConsumer
+    void changed(const QRect& rect);
+    void end();
+    void preFrameDone(); //util func
+    void frameDone();
+    void frameDone(const QPoint&, const QRect& rect);
+    void restartTimer();
+    void setLooping(int l);
+    void setFramePeriod(int milliseconds);
+    void setSize(int w, int h);
+
+    // This as QDataSink
+    int readyToReceive();
+    void receive(const uchar* b, int bytecount);
+    void eof();
+    void pause();
+
+signals:
+    void sizeChanged(const QSize&);
+    void areaChanged(const QRect&);
+    void dataStatus(int);
+
+public slots:
+    void refresh();
+
+public:
+    QMovie *that;
+    QWidget * display_widget;
+
+    QImageDecoder *decoder;
+
+    // Cyclic buffer
+    int buf_size;
+    uchar *buffer;
+    int buf_r, buf_w, buf_usage;
+
+    int framenumber;
+    int frameperiod;
+    int speed;
+    QTimer *frametimer;
+    int lasttimerinterval;
+    int loop;
+    bool movie_ended;
+    bool dirty_cache;
+    bool waitingForFrameTick;
+    int stepping;
+    QRect changed_area;
+    QRect valid_area;
+    QDataPump *pump;
+    QDataSource *source;
+    QPixmap mypixmap;
+    QBitmap mymask;
+    QColor bg;
+
+    int error;
+    bool empty;
+
+#ifdef QT_SAVE_MOVIE_HACK
+  bool save_image;
+  int image_number;
+#endif
+};
+
+
+QMoviePrivate::QMoviePrivate()
+{
+    dirty_cache = FALSE;
+    buffer = 0;
+    pump = 0;
+    source = 0;
+    decoder = 0;
+    display_widget=0;
+    buf_size = 0;
+    init(FALSE);
+}
+
+// NOTE:  The ownership of the QDataSource is transferred to the Private
+QMoviePrivate::QMoviePrivate(QDataSource* src, QMovie* movie, int bufsize) :
+    that(movie),
+    buf_size(bufsize)
+{
+    frametimer = new QTimer(this);
+    pump = src ? new QDataPump(src, this) : 0;
+    QObject::connect(frametimer, SIGNAL(timeout()), this, SLOT(refresh()));
+    dirty_cache = FALSE;
+    source = src;
+    buffer = 0;
+    decoder = 0;
+    speed = 100;
+    display_widget=0;
+    init(TRUE);
+}
+
+QMoviePrivate::~QMoviePrivate()
+{
+    if ( buffer )				// Avoid purify complaint
+	delete [] buffer;
+    delete pump;
+    delete decoder;
+    delete source;
+
+    // Too bad.. but better be safe than sorry
+    if ( dirty_cache )
+        QPixmapCache::clear();
+}
+
+bool QMoviePrivate::isNull() const
+{
+    return !buf_size;
+}
+
+// Initialize. Only actually allocate any space if \a fully is TRUE,
+// otherwise, just enough to be a valid null Private.
+void QMoviePrivate::init(bool fully)
+{
+#ifdef QT_SAVE_MOVIE_HACK
+    save_image = TRUE;
+    image_number = 0;
+#endif
+
+    buf_usage = buf_r = buf_w = 0;
+    if ( buffer )				// Avoid purify complaint
+	delete [] buffer;
+    buffer = fully ? new uchar[buf_size] : 0;
+    if ( buffer )
+	memset( buffer, 0, buf_size );
+
+    delete decoder;
+    decoder = fully ? new QImageDecoder(this) : 0;
+
+#ifdef AVOID_OPEN_FDS
+    if ( source && !source->isOpen() )
+	source->open(IO_ReadOnly);
+#endif
+
+    waitingForFrameTick = FALSE;
+    stepping = -1;
+    framenumber = 0;
+    frameperiod = -1;
+    if (fully) frametimer->stop();
+    lasttimerinterval = -1;
+    changed_area.setRect(0,0,-1,-1);
+    valid_area = changed_area;
+    loop = -1;
+    movie_ended = FALSE;
+    error = 0;
+    empty = TRUE;
+}
+
+void QMoviePrivate::flushBuffer()
+{
+    int used;
+    while (buf_usage && !waitingForFrameTick && stepping != 0 && !error) {
+	used = decoder->decode(buffer + buf_r, QMIN(buf_usage, buf_size - buf_r));
+	if (used <= 0) {
+	    if ( used < 0 ) {
+		error = 1;
+		emit dataStatus(QMovie::UnrecognizedFormat);
+	    }
+	    break;
+	}
+	buf_r = (buf_r + used) % buf_size;
+	buf_usage -= used;
+    }
+
+    // Some formats, like MNG, can make stuff happen without any extra data.
+    // Only do this if the movie hasn't ended, however or we'll never get the end of loop signal.
+    if (!movie_ended) {
+	used = decoder->decode(buffer + buf_r, 0);
+	if (used <= 0) {
+	    if ( used < 0 ) {
+		error = 1;
+		emit dataStatus(QMovie::UnrecognizedFormat);
+	    }
+	}
+    }
+
+    if (error)
+	frametimer->stop();
+    maybeReady();
+}
+
+void QMoviePrivate::updatePixmapFromImage()
+{
+    if (changed_area.isEmpty()) return;
+    updatePixmapFromImage(QPoint(0,0),changed_area);
+}
+
+void QMoviePrivate::updatePixmapFromImage(const QPoint& off,
+						const QRect& area)
+{
+    // Create temporary QImage to hold the part we want
+    const QImage& gimg = decoder->image();
+    QImage img = gimg.copy(area);
+
+#ifdef QT_SAVE_MOVIE_HACK
+    if ( save_image ) {
+	QString name;
+	name.sprintf("movie%i.ppm",image_number++);
+	gimg.save( name, "PPM" );
+    }
+#endif
+
+    // Resize to size of image
+    if (mypixmap.width() != gimg.width() || mypixmap.height() != gimg.height())
+	mypixmap.resize(gimg.width(), gimg.height());
+
+    // Convert to pixmap and paste that onto myself
+    QPixmap lines;
+
+#ifndef QT_NO_SPRINTF
+    if (!(frameperiod < 0 && loop == -1)) {
+        // its an animation, lets see if we converted
+        // this frame already.
+        QString key;
+        key.sprintf( "%08lx:%04d", ( long )this, framenumber );
+        if ( !QPixmapCache::find( key, lines ) ) {
+            lines.convertFromImage(img, Qt::ColorOnly);
+            QPixmapCache::insert( key, lines );
+            dirty_cache = TRUE;
+        }
+    } else
+#endif
+    {
+        lines.convertFromImage(img, Qt::ColorOnly);
+    }
+
+    if (bg.isValid()) {
+	QPainter p;
+	p.begin(&mypixmap);
+	p.fillRect(area, bg);
+	p.drawPixmap(area, lines);
+	p.end();
+    } else {
+	if (gimg.hasAlphaBuffer()) {
+	    // Resize to size of image
+	    if (mymask.isNull()) {
+		mymask.resize(gimg.width(), gimg.height());
+		mymask.fill( Qt::color1 );
+	    }
+	}
+	mypixmap.setMask(QBitmap()); // Remove reference to my mask
+	copyBlt( &mypixmap, area.left(), area.top(),
+		 &lines, off.x(), off.y(), area.width(), area.height() );
+    }
+
+#ifdef Q_WS_QWS
+    if(display_widget) {
+	QGfx * mygfx=display_widget->graphicsContext();
+	if(mygfx) {
+	    double xscale,yscale;
+	    xscale=display_widget->width();
+	    yscale=display_widget->height();
+	    xscale=xscale/((double)mypixmap.width());
+	    yscale=yscale/((double)mypixmap.height());
+	    double xh,yh;
+	    xh=xscale*((double)area.left());
+	    yh=yscale*((double)area.top());
+	    mygfx->setSource(&mypixmap);
+	    mygfx->setAlphaType(QGfx::IgnoreAlpha);
+	    mygfx->stretchBlt(0,0,display_widget->width(),
+			      display_widget->height(),mypixmap.width(),
+			      mypixmap.height());
+	    delete mygfx;
+	}
+    }
+#endif
+}
+
+void QMoviePrivate::showChanges()
+{
+    if (changed_area.isValid()) {
+	updatePixmapFromImage();
+
+	valid_area = valid_area.unite(changed_area);
+	emit areaChanged(changed_area);
+
+	changed_area.setWidth(-1); // make empty
+    }
+}
+
+// Private as QImageConsumer
+void QMoviePrivate::changed(const QRect& rect)
+{
+    if (!frametimer->isActive())
+	frametimer->start(0);
+    changed_area = changed_area.unite(rect);
+}
+
+void QMoviePrivate::end()
+{
+    movie_ended = TRUE;
+}
+
+void QMoviePrivate::preFrameDone()
+{
+    if (stepping > 0) {
+	stepping--;
+	if (!stepping) {
+	    frametimer->stop();
+	    emit dataStatus( QMovie::Paused );
+	}
+    } else {
+	waitingForFrameTick = TRUE;
+	restartTimer();
+    }
+}
+void QMoviePrivate::frameDone()
+{
+    preFrameDone();
+    showChanges();
+    emit dataStatus(QMovie::EndOfFrame);
+    framenumber++;
+}
+void QMoviePrivate::frameDone(const QPoint& p,
+				const QRect& rect)
+{
+    preFrameDone();
+    const QImage& gimg = decoder->image();
+    QPoint point = p - gimg.offset();
+    if (framenumber==0)
+	emit sizeChanged(gimg.size());
+    valid_area = valid_area.unite(QRect(point,rect.size()));
+    updatePixmapFromImage(point,rect);
+    emit areaChanged(QRect(point,rect.size()));
+    emit dataStatus(QMovie::EndOfFrame);
+    framenumber++;
+}
+
+void QMoviePrivate::restartTimer()
+{
+    if (speed > 0) {
+	int i = frameperiod >= 0 ? frameperiod * 100/speed : 0;
+	if ( i != lasttimerinterval || !frametimer->isActive() ) {
+	    lasttimerinterval = i;
+	    frametimer->start( i );
+	}
+    } else {
+	frametimer->stop();
+    }
+}
+
+void QMoviePrivate::setLooping(int nloops)
+{
+    if (loop == -1) { // Only if we don't already know how many loops!
+	if (source && source->rewindable()) {
+	    source->enableRewind(TRUE);
+	    loop = nloops;
+	} else {
+	    // Cannot loop from this source
+	    loop = -2;
+	}
+    }
+}
+
+void QMoviePrivate::setFramePeriod(int milliseconds)
+{
+    // Animation:  only show complete frame
+    frameperiod = milliseconds;
+    if (stepping<0 && frameperiod >= 0) restartTimer();
+}
+
+void QMoviePrivate::setSize(int w, int h)
+{
+    if (mypixmap.width() != w || mypixmap.height() != h) {
+	mypixmap.resize(w, h);
+	emit sizeChanged(QSize(w, h));
+    }
+}
+
+
+// Private as QDataSink
+
+int QMoviePrivate::readyToReceive()
+{
+    // Could pre-fill buffer, but more efficient to just leave the
+    // data back at the source.
+    return (waitingForFrameTick || !stepping || buf_usage || error)
+	? 0 : buf_size;
+}
+
+void QMoviePrivate::receive(const uchar* b, int bytecount)
+{
+    if ( bytecount ) empty = FALSE;
+
+    while (bytecount && !waitingForFrameTick && stepping != 0) {
+	int used = decoder->decode(b, bytecount);
+	if (used<=0) {
+	    if ( used < 0 ) {
+		error = 1;
+		emit dataStatus(QMovie::UnrecognizedFormat);
+	    }
+	    break;
+	}
+	b+=used;
+	bytecount-=used;
+    }
+
+    // Append unused to buffer
+    while (bytecount--) {
+	buffer[buf_w] = *b++;
+	buf_w = (buf_w+1)%buf_size;
+	buf_usage++;
+    }
+}
+
+void QMoviePrivate::eof()
+{
+    if ( !movie_ended )
+	return;
+
+    if ( empty )
+	emit dataStatus(QMovie::SourceEmpty);
+
+#ifdef QT_SAVE_MOVIE_HACK
+    save_image = FALSE;
+#endif
+
+    emit dataStatus(QMovie::EndOfLoop);
+
+    if (loop >= 0) {
+	if (loop) {
+	    loop--;
+	    if (!loop) return;
+	}
+	delete decoder;
+	decoder = new QImageDecoder(this);
+	source->rewind();
+	framenumber = 0;
+	movie_ended = FALSE;
+    } else {
+	delete decoder;
+	decoder = 0;
+	if ( buffer )				// Avoid purify complaint
+	    delete [] buffer;
+	buffer = 0;
+	emit dataStatus(QMovie::EndOfMovie);
+#ifdef AVOID_OPEN_FDS
+	if ( source )
+	    source->close();
+#endif
+    }
+}
+
+void QMoviePrivate::pause()
+{
+    if ( stepping ) {
+	stepping = 0;
+	frametimer->stop();
+	emit dataStatus( QMovie::Paused );
+    }
+}
+
+void QMoviePrivate::refresh()
+{
+    if (!decoder) {
+	frametimer->stop();
+	return;
+    }
+
+    if (frameperiod < 0 && loop == -1) {
+	// Only show changes if probably not an animation
+	showChanges();
+    }
+
+    if (!buf_usage) {
+	frametimer->stop();
+    }
+
+    waitingForFrameTick = FALSE;
+    flushBuffer();
+}
+
+///////////////// End of Private /////////////////
+
+
+
+
+
+/*!
+    Constructs a null QMovie. The only interesting thing to do with
+    such a movie is to assign another movie to it.
+
+    \sa isNull()
+*/
+QMovie::QMovie()
+{
+    d = new QMoviePrivate();
+}
+
+/*!
+    Constructs a QMovie with an external data source. You should later
+    call pushData() to send incoming animation data to the movie.
+
+    The \a bufsize argument sets the maximum amount of data the movie
+    will transfer from the data source per event loop. The lower this
+    value, the better interleaved the movie playback will be with
+    other event processing, but the slower the overall processing will
+    be.
+
+    \sa pushData()
+*/
+QMovie::QMovie(int bufsize)
+{
+    d = new QMoviePrivate(0, this, bufsize);
+}
+
+/*!
+    Returns the maximum amount of data that can currently be pushed
+    into the movie by a call to pushData(). This is affected by the
+    initial buffer size, but varies as the movie plays and data is
+    consumed.
+*/
+int QMovie::pushSpace() const
+{
+    return d->readyToReceive();
+}
+
+/*!
+    Pushes \a length bytes from \a data into the movie. \a length must
+    be no more than the amount returned by pushSpace() since the
+    previous call to pushData().
+*/
+void QMovie::pushData(const uchar* data, int length)
+{
+    d->receive(data,length);
+}
+
+#ifdef Q_WS_QWS // ##### Temporary performance experiment
+/*!
+    \internal
+*/
+void QMovie::setDisplayWidget(QWidget * w)
+{
+    d->display_widget=w;
+}
+#endif
+
+/*!
+    Constructs a QMovie that reads an image sequence from the given
+    data source, \a src. The source must be allocated dynamically,
+    because QMovie will take ownership of it and will destroy it when
+    the movie is destroyed. The movie starts playing as soon as event
+    processing continues.
+
+    The \a bufsize argument sets the maximum amount of data the movie
+    will transfer from the data source per event loop. The lower this
+    value, the better interleaved the movie playback will be with
+    other event processing, but the slower the overall processing will
+    be.
+*/
+QMovie::QMovie(QDataSource* src, int bufsize)
+{
+    d = new QMoviePrivate(src, this, bufsize);
+}
+
+/*!
+    Constructs a QMovie that reads an image sequence from the file, \a
+    fileName.
+
+    The \a bufsize argument sets the maximum amount of data the movie
+    will transfer from the data source per event loop. The lower this
+    value, the better interleaved the movie playback will be with
+    other event processing, but the slower the overall processing will
+    be.
+*/
+QMovie::QMovie(const QString &fileName, int bufsize)
+{
+    QFile* file = new QFile(fileName);
+    if ( !fileName.isEmpty() )
+ 	file->open(IO_ReadOnly);
+    d = new QMoviePrivate(new QIODeviceSource(file, bufsize), this, bufsize);
+}
+
+/*!
+    Constructs a QMovie that reads an image sequence from the byte
+    array, \a data.
+
+    The \a bufsize argument sets the maximum amount of data the movie
+    will transfer from the data source per event loop. The lower this
+    value, the better interleaved the movie playback will be with
+    other event processing, but the slower the overall processing will
+    be.
+*/
+QMovie::QMovie(QByteArray data, int bufsize)
+{
+    QBuffer* buffer = new QBuffer(data);
+    buffer->open(IO_ReadOnly);
+    d = new QMoviePrivate(new QIODeviceSource(buffer, bufsize), this, bufsize);
+}
+
+/*!
+    Constructs a movie that uses the same data as movie \a movie.
+    QMovies use explicit sharing, so operations on the copy will
+    affect both.
+*/
+QMovie::QMovie(const QMovie& movie)
+{
+    d = movie.d;
+    d->ref();
+}
+
+/*!
+    Destroys the QMovie. If this is the last reference to the data of
+    the movie, the data is deallocated.
+*/
+QMovie::~QMovie()
+{
+    if (d->deref()) delete d;
+}
+
+/*!
+    Returns TRUE if the movie is null; otherwise returns FALSE.
+*/
+bool QMovie::isNull() const
+{
+    return d->isNull();
+}
+
+/*!
+    Makes this movie use the same data as movie \a movie. QMovies use
+    explicit sharing.
+*/
+QMovie& QMovie::operator=(const QMovie& movie)
+{
+    movie.d->ref();
+    if (d->deref()) delete d;
+    d = movie.d;
+    return *this;
+}
+
+
+/*!
+    Sets the background color of the pixmap to \a c. If the background
+    color isValid(), the pixmap will never have a mask because the
+    background color will be used in transparent regions of the image.
+
+    \sa backgroundColor()
+*/
+void QMovie::setBackgroundColor(const QColor& c)
+{
+    d->bg = c;
+}
+
+/*!
+    Returns the background color of the movie set by
+    setBackgroundColor().
+*/
+const QColor& QMovie::backgroundColor() const
+{
+    return d->bg;
+}
+
+/*!
+    Returns the area of the pixmap for which pixels have been
+    generated.
+*/
+const QRect& QMovie::getValidRect() const
+{
+    return d->valid_area;
+}
+
+/*!
+    Returns the current frame of the movie, as a QPixmap. It is not
+    generally useful to keep a copy of this pixmap. It is better to
+    keep a copy of the QMovie and get the framePixmap() only when
+    needed for drawing.
+
+    \sa frameImage()
+*/
+const QPixmap& QMovie::framePixmap() const
+{
+    return d->mypixmap;
+}
+
+/*!
+    Returns the current frame of the movie, as a QImage. It is not
+    generally useful to keep a copy of this image. Also note that you
+    must not call this function if the movie is finished(), since by
+    then the image will not be available.
+
+    \sa framePixmap()
+*/
+const QImage& QMovie::frameImage() const
+{
+    return d->decoder->image();
+}
+
+/*!
+    Returns the number of steps remaining after a call to step(). If
+    the movie is paused, steps() returns 0. If it's running normally
+    or is finished, steps() returns a negative number.
+*/
+int QMovie::steps() const
+{
+    return d->stepping;
+}
+
+/*!
+    Returns the number of times EndOfFrame has been emitted since the
+    start of the current loop of the movie. Thus, before any
+    EndOfFrame has been emitted the value will be 0; within slots
+    processing the first signal, frameNumber() will be 1, and so on.
+*/
+int QMovie::frameNumber() const { return d->framenumber; }
+
+/*!
+    Returns TRUE if the image is paused; otherwise returns FALSE.
+*/
+bool QMovie::paused() const
+{
+    return d->stepping == 0;
+}
+
+/*!
+    Returns TRUE if the image is no longer playing: this happens when
+    all loops of all frames are complete; otherwise returns FALSE.
+*/
+bool QMovie::finished() const
+{
+    return !d->decoder;
+}
+
+/*!
+    Returns TRUE if the image is not single-stepping, not paused, and
+    not finished; otherwise returns FALSE.
+*/
+bool QMovie::running() const
+{
+    return d->stepping<0 && d->decoder;
+}
+
+/*!
+    Pauses the progress of the animation.
+
+    \sa unpause()
+*/
+void QMovie::pause()
+{
+    d->pause();
+}
+
+/*!
+    Unpauses the progress of the animation.
+
+    \sa pause()
+*/
+void QMovie::unpause()
+{
+    if ( d->stepping >= 0 )	{
+	if (d->isNull())
+	    return;
+	d->stepping = -1;
+	d->restartTimer();
+    }
+}
+
+/*!
+    \overload
+
+    Steps forward, showing \a steps frames, and then pauses.
+*/
+void QMovie::step(int steps)
+{
+    if (d->isNull())
+	return;
+    d->stepping = steps;
+    d->frametimer->start(0);
+    d->waitingForFrameTick = FALSE; // Full speed ahead!
+}
+
+/*!
+    Steps forward 1 frame and then pauses.
+*/
+void QMovie::step()
+{
+    step(1);
+}
+
+/*!
+    Rewinds the movie to the beginning. If the movie has not been
+    paused, it begins playing again.
+*/
+void QMovie::restart()
+{
+    if (d->isNull())
+	return;
+    if (d->source->rewindable()) {
+	d->source->enableRewind(TRUE);
+	d->source->rewind();
+	int s = d->stepping;
+	d->init(TRUE);
+	if ( s>0 )
+	    step(s);
+	else if ( s==0 )
+	    pause();
+    }
+}
+
+/*!
+    Returns the movie's play speed as a percentage. The default is 100
+    percent.
+
+    \sa setSpeed()
+*/
+int QMovie::speed() const
+{
+    return d->speed;
+}
+
+/*!
+    Sets the movie's play speed as a percentage, to \a percent. This
+    is a percentage of the speed dictated by the input data format.
+    The default is 100 percent.
+*/
+void QMovie::setSpeed(int percent)
+{
+    int oldspeed = d->speed;
+    if ( oldspeed != percent && percent >= 0 ) {
+	d->speed = percent;
+	// Restart timer only if really needed
+	if (d->stepping < 0) {
+	    if ( !percent || !oldspeed    // To or from zero
+		 || oldspeed*4 / percent > 4   // More than 20% slower
+		 || percent*4 / oldspeed > 4   // More than 20% faster
+		 )
+		d->restartTimer();
+	}
+    }
+}
+
+/*!
+    Connects the \a{receiver}'s \a member of type \c{void member(const
+    QSize&)} so that it is signalled when the movie changes size.
+
+    Note that due to the explicit sharing of QMovie objects, these
+    connections persist until they are explicitly disconnected with
+    disconnectResize() or until \e every shared copy of the movie is
+    deleted.
+*/
+void QMovie::connectResize(QObject* receiver, const char *member)
+{
+    QObject::connect(d, SIGNAL(sizeChanged(const QSize&)), receiver, member);
+}
+
+/*!
+    Disconnects the \a{receiver}'s \a member (or all members if \a
+    member is zero) that were previously connected by connectResize().
+*/
+void QMovie::disconnectResize(QObject* receiver, const char *member)
+{
+    QObject::disconnect(d, SIGNAL(sizeChanged(const QSize&)), receiver, member);
+}
+
+/*!
+    Connects the \a{receiver}'s \a member of type \c{void member(const
+    QRect&)} so that it is signalled when an area of the framePixmap()
+    has changed since the previous frame.
+
+    Note that due to the explicit sharing of QMovie objects, these
+    connections persist until they are explicitly disconnected with
+    disconnectUpdate() or until \e every shared copy of the movie is
+    deleted.
+*/
+void QMovie::connectUpdate(QObject* receiver, const char *member)
+{
+    QObject::connect(d, SIGNAL(areaChanged(const QRect&)), receiver, member);
+}
+
+/*!
+    Disconnects the \a{receiver}'s \a member (or all members if \q
+    member is zero) that were previously connected by connectUpdate().
+*/
+void QMovie::disconnectUpdate(QObject* receiver, const char *member)
+{
+    QObject::disconnect(d, SIGNAL(areaChanged(const QRect&)), receiver, member);
+}
+
+/*!
+    Connects the \a{receiver}'s \a member, of type \c{void
+    member(int)} so that it is signalled when the movie changes
+    status. The status codes are negative for errors and positive for
+    information.
+
+    \table
+    \header \i Status Code \i Meaning
+    \row \i QMovie::SourceEmpty
+	 \i signalled if the input cannot be read.
+    \row \i QMovie::UnrecognizedFormat
+	 \i signalled if the input data is unrecognized.
+    \row \i QMovie::Paused
+	  \i signalled when the movie is paused by a call to paused()
+	  or by after \link step() stepping \endlink pauses.
+    \row \i QMovie::EndOfFrame
+	 \i signalled at end-of-frame after any update and Paused signals.
+    \row \i QMovie::EndOfLoop
+	 \i signalled at end-of-loop, after any update signals,
+	 EndOfFrame - but before EndOfMovie.
+    \row \i QMovie::EndOfMovie
+	 \i signalled when the movie completes and is not about to loop.
+    \endtable
+
+    More status messages may be added in the future, so a general test
+    for errors would test for negative.
+
+    Note that due to the explicit sharing of QMovie objects, these
+    connections persist until they are explicitly disconnected with
+    disconnectStatus() or until \e every shared copy of the movie is
+    deleted.
+*/
+void QMovie::connectStatus(QObject* receiver, const char *member)
+{
+    QObject::connect(d, SIGNAL(dataStatus(int)), receiver, member);
+}
+
+/*!
+    Disconnects the \a{receiver}'s \a member (or all members if \a
+    member is zero) that were previously connected by connectStatus().
+*/
+void QMovie::disconnectStatus(QObject* receiver, const char *member)
+{
+    QObject::disconnect(d, SIGNAL(dataStatus(int)), receiver, member);
+}
+
+
+#include "qmovie.moc"
+
+#endif	// QT_NO_MOVIE