diff options
Diffstat (limited to 'tqtinterface/qt4/src/kernel/tqmovie.cpp')
| -rw-r--r-- | tqtinterface/qt4/src/kernel/tqmovie.cpp | 1082 |
1 files changed, 1082 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/kernel/tqmovie.cpp b/tqtinterface/qt4/src/kernel/tqmovie.cpp new file mode 100644 index 0000000..4b77249 --- /dev/null +++ b/tqtinterface/qt4/src/kernel/tqmovie.cpp @@ -0,0 +1,1082 @@ +/**************************************************************************** +** +** Implementation of movie classes +** +** Created : 970617 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the kernel module of the TQt 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 TQt 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 sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** 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 TQT_SAVE_MOVIE_HACK + +#include "tqtimer.h" +#include "tqpainter.h" +#include "tqptrlist.h" +#include "tqbitmap.h" +#include "tqmovie.h" +#include "tqfile.h" +#include "tqbuffer.h" +#include "tqobject.h" +#include "tqpixmapcache.h" + +#ifndef TQT_NO_MOVIE + +#ifdef TQ_WS_TQWS +#include "tqgfx_qws.h" +#endif + +#include "tqasyncio.h" +#include "tqasyncimageio.h" + +#include <stdlib.h> + +/*! + \class TQMovie tqmovie.h + \brief The TQMovie 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 TQMovie is to use a TQLabel and + TQLabel::setMovie(). + + A TQMovie provides a TQPixmap 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 TQMovie 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. + + TQMovie objects are explicitly shared. This means that a TQMovie + copied from another TQMovie 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 TQMovie 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 TQt is configured with MNG + support enabled) and GIF (if TQt is configured with GIF support + enabled, see tqgif.h). + + If TQt 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 TQt. + We recommend using the MNG or PNG format. + + \img qmovie.png TQMovie + + \sa TQLabel::setMovie() +*/ + +/*! + \enum TQMovie::tqStatus + + \value SourceEmpty + \value UnrecognizedFormat + \value Paused + \value EndOfFrame + \value EndOfLoop + \value EndOfMovie + \value SpeedChanged +*/ + +class TQMoviePrivate : public TQObject, public TQShared, + private TQDataSink, private TQImageConsumer +{ + Q_OBJECT + TQ_OBJECT + +public: // for TQMovie + + // Creates a null Private + TQMoviePrivate(); + + // NOTE: The ownership of the TQDataSource is transferred to the Private + TQMoviePrivate(TQDataSource* src, TQMovie* movie, int bufsize); + + virtual ~TQMoviePrivate(); + + bool isNull() const; + + // Initialize, possibly to the null state + void init(bool fully); + void flushBuffer(); + void updatePixmapFromImage(); + void updatePixmapFromImage(const TQPoint& off, const TQRect& area); + void showChanges(); + + // This as TQImageConsumer + void changed(const TQRect& rect); + void end(); + void preFrameDone(); //util func + void frameDone(); + void frameDone(const TQPoint&, const TQRect& rect); + void restartTimer(); + void setLooping(int l); + void setFramePeriod(int milliseconds); + void setSize(int w, int h); + + // This as TQDataSink + int readyToReceive(); + void receive(const uchar* b, int bytecount); + void eof(); + void pause(); + +Q_SIGNALS: + void sizeChanged(const TQSize&); + void areaChanged(const TQRect&); + void datatqStatus(int); + +public Q_SLOTS: + void refresh(); + +public: + TQMovie *that; + TQWidget * display_widget; + + TQImageDecoder *decoder; + + // Cyclic buffer + int buf_size; + uchar *buffer; + int buf_r, buf_w, buf_usage; + + int framenumber; + int frameperiod; + int speed; + TQTimer *frametimer; + int lasttimerinterval; + int loop; + bool movie_ended; + bool dirty_cache; + bool waitingForFrameTick; + int stepping; + TQRect changed_area; + TQRect valid_area; + TQDataPump *pump; + TQDataSource *source; + TQPixmap mypixmap; + TQBitmap mytqmask; + TQColor bg; + + int error; + bool empty; + +#ifdef TQT_SAVE_MOVIE_HACK + bool save_image; + int image_number; +#endif +}; + + +TQMoviePrivate::TQMoviePrivate() +{ + dirty_cache = FALSE; + buffer = 0; + pump = 0; + source = 0; + decoder = 0; + display_widget=0; + buf_size = 0; + init(FALSE); +} + +// NOTE: The ownership of the TQDataSource is transferred to the Private +TQMoviePrivate::TQMoviePrivate(TQDataSource* src, TQMovie* movie, int bufsize) : + that(movie), + buf_size(bufsize) +{ + frametimer = new TQTimer(this); + pump = src ? new TQDataPump(src, this) : 0; + TQObject::connect(frametimer, TQT_SIGNAL(timeout()), this, TQT_SLOT(refresh())); + dirty_cache = FALSE; + source = src; + buffer = 0; + decoder = 0; + speed = 100; + display_widget=0; + init(TRUE); +} + +TQMoviePrivate::~TQMoviePrivate() +{ + if ( buffer ) // Avoid purify complaint + delete [] buffer; + delete pump; + delete decoder; + delete source; + + // Too bad.. but better be safe than sorry + if ( dirty_cache ) + TQPixmapCache::clear(); +} + +bool TQMoviePrivate::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 TQMoviePrivate::init(bool fully) +{ +#ifdef TQT_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 TQImageDecoder(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 TQMoviePrivate::flushBuffer() +{ + int used; + while (buf_usage && !waitingForFrameTick && stepping != 0 && !error) { + used = decoder->decode(buffer + buf_r, TQMIN(buf_usage, buf_size - buf_r)); + if (used <= 0) { + if ( used < 0 ) { + error = 1; + emit datatqStatus(TQMovie::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 datatqStatus(TQMovie::UnrecognizedFormat); + } + } + } + + if (error) + frametimer->stop(); + maybeReady(); +} + +void TQMoviePrivate::updatePixmapFromImage() +{ + if (changed_area.isEmpty()) return; + updatePixmapFromImage(TQPoint(0,0),changed_area); +} + +void TQMoviePrivate::updatePixmapFromImage(const TQPoint& off, + const TQRect& area) +{ + // Create temporary TQImage to hold the part we want + const TQImage& gimg = decoder->image(); + TQImage img = gimg.copy(area); + +#ifdef TQT_SAVE_MOVIE_HACK + if ( save_image ) { + TQString 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 + TQPixmap lines; + +#ifndef TQT_NO_SPRINTF + if (!(frameperiod < 0 && loop == -1)) { + // its an animation, lets see if we converted + // this frame already. + TQString key; + key.sprintf( "%08lx:%04d", ( long )this, framenumber ); + if ( !TQPixmapCache::tqfind( key, lines ) ) { + lines.convertFromImage(img, TQt::ColorOnly); + TQPixmapCache::insert( key, lines ); + dirty_cache = TRUE; + } + } else +#endif + { + lines.convertFromImage(img, TQt::ColorOnly); + } + + if (bg.isValid()) { + TQPainter p; + p.begin(&mypixmap); + p.fillRect(area, bg); + p.drawPixmap(area, lines); + p.end(); + } else { + if (gimg.hasAlphaBuffer()) { + // Resize to size of image + if (mytqmask.isNull()) { + mytqmask.resize(gimg.width(), gimg.height()); + mytqmask.fill( TQt::color1 ); + } + } + mypixmap.setMask(TQBitmap()); // Remove reference to my tqmask + copyBlt( &mypixmap, area.left(), area.top(), + &lines, off.x(), off.y(), area.width(), area.height() ); + } + +#ifdef TQ_WS_TQWS + if(display_widget) { + TQGfx * 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(TQGfx::IgnoreAlpha); + mygfx->stretchBlt(0,0,display_widget->width(), + display_widget->height(),mypixmap.width(), + mypixmap.height()); + delete mygfx; + } + } +#endif +} + +void TQMoviePrivate::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 TQImageConsumer +void TQMoviePrivate::changed(const TQRect& rect) +{ + if (!frametimer->isActive()) + frametimer->start(0); + changed_area = changed_area.unite(rect); +} + +void TQMoviePrivate::end() +{ + movie_ended = TRUE; +} + +void TQMoviePrivate::preFrameDone() +{ + if (stepping > 0) { + stepping--; + if (!stepping) { + frametimer->stop(); + emit datatqStatus( TQMovie::Paused ); + } + } else { + waitingForFrameTick = TRUE; + restartTimer(); + } +} +void TQMoviePrivate::frameDone() +{ + preFrameDone(); + showChanges(); + emit datatqStatus(TQMovie::EndOfFrame); + framenumber++; +} +void TQMoviePrivate::frameDone(const TQPoint& p, + const TQRect& rect) +{ + preFrameDone(); + const TQImage& gimg = decoder->image(); + TQPoint point = p - gimg.offset(); + if (framenumber==0) + emit sizeChanged(gimg.size()); + valid_area = valid_area.unite(TQRect(point,rect.size())); + updatePixmapFromImage(point,rect); + emit areaChanged(TQRect(point,rect.size())); + emit datatqStatus(TQMovie::EndOfFrame); + framenumber++; +} + +void TQMoviePrivate::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 TQMoviePrivate::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 TQMoviePrivate::setFramePeriod(int milliseconds) +{ + // Animation: only show complete frame + frameperiod = milliseconds; + if (stepping<0 && frameperiod >= 0) restartTimer(); +} + +void TQMoviePrivate::setSize(int w, int h) +{ + if (mypixmap.width() != w || mypixmap.height() != h) { + mypixmap.resize(w, h); + emit sizeChanged(TQSize(w, h)); + } +} + + +// Private as TQDataSink + +int TQMoviePrivate::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 TQMoviePrivate::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 datatqStatus(TQMovie::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 TQMoviePrivate::eof() +{ + if ( !movie_ended ) + return; + + if ( empty ) + emit datatqStatus(TQMovie::SourceEmpty); + +#ifdef TQT_SAVE_MOVIE_HACK + save_image = FALSE; +#endif + + emit datatqStatus(TQMovie::EndOfLoop); + + if (loop >= 0) { + if (loop) { + loop--; + if (!loop) return; + } + delete decoder; + decoder = new TQImageDecoder(this); + source->rewind(); + framenumber = 0; + movie_ended = FALSE; + } else { + delete decoder; + decoder = 0; + if ( buffer ) // Avoid purify complaint + delete [] buffer; + buffer = 0; + emit datatqStatus(TQMovie::EndOfMovie); +#ifdef AVOID_OPEN_FDS + if ( source ) + source->close(); +#endif + } +} + +void TQMoviePrivate::pause() +{ + if ( stepping ) { + stepping = 0; + frametimer->stop(); + emit datatqStatus( TQMovie::Paused ); + } +} + +void TQMoviePrivate::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 TQMovie. The only interesting thing to do with + such a movie is to assign another movie to it. + + \sa isNull() +*/ +TQMovie::TQMovie() +{ + d = new TQMoviePrivate(); +} + +/*! + Constructs a TQMovie 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() +*/ +TQMovie::TQMovie(int bufsize) +{ + d = new TQMoviePrivate(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 TQMovie::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 TQMovie::pushData(const uchar* data, int length) +{ + d->receive(data,length); +} + +#ifdef TQ_WS_TQWS // ##### Temporary performance experiment +/*! + \internal +*/ +void TQMovie::setDisplayWidget(TQWidget * w) +{ + d->display_widget=w; +} +#endif + +/*! + Constructs a TQMovie that reads an image sequence from the given + data source, \a src. The source must be allocated dynamically, + because TQMovie 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. +*/ +TQMovie::TQMovie(TQDataSource* src, int bufsize) +{ + d = new TQMoviePrivate(src, this, bufsize); +} + +/*! + Constructs a TQMovie 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. +*/ +TQMovie::TQMovie(const TQString &fileName, int bufsize) +{ + TQFile* file = new TQFile(fileName); + if ( !fileName.isEmpty() ) + file->open(IO_ReadOnly); + d = new TQMoviePrivate(new TQIODeviceSource(TQT_TQIODEVICE(file), bufsize), this, bufsize); +} + +/*! + Constructs a TQMovie 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. +*/ +TQMovie::TQMovie(TQByteArray data, int bufsize) +{ + TQBuffer* buffer = new TQBuffer(data); + buffer->open(IO_ReadOnly); + d = new TQMoviePrivate(new TQIODeviceSource(TQT_TQIODEVICE(buffer), bufsize), this, bufsize); +} + +/*! + Constructs a movie that uses the same data as movie \a movie. + TQMovies use explicit sharing, so operations on the copy will + affect both. +*/ +TQMovie::TQMovie(const TQMovie& movie) +{ + d = movie.d; + d->ref(); +} + +/*! + Destroys the TQMovie. If this is the last reference to the data of + the movie, the data is deallocated. +*/ +TQMovie::~TQMovie() +{ + if (d->deref()) delete d; +} + +/*! + Returns TRUE if the movie is null; otherwise returns FALSE. +*/ +bool TQMovie::isNull() const +{ + return d->isNull(); +} + +/*! + Makes this movie use the same data as movie \a movie. TQMovies use + explicit sharing. +*/ +TQMovie& TQMovie::operator=(const TQMovie& 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 tqmask because the + background color will be used in transtqparent regions of the image. + + \sa backgroundColor() +*/ +void TQMovie::setBackgroundColor(const TQColor& c) +{ + d->bg = c; +} + +/*! + Returns the background color of the movie set by + setBackgroundColor(). +*/ +const TQColor& TQMovie::backgroundColor() const +{ + return d->bg; +} + +/*! + Returns the area of the pixmap for which pixels have been + generated. +*/ +const TQRect& TQMovie::getValidRect() const +{ + return d->valid_area; +} + +/*! + Returns the current frame of the movie, as a TQPixmap. It is not + generally useful to keep a copy of this pixmap. It is better to + keep a copy of the TQMovie and get the framePixmap() only when + needed for drawing. + + \sa frameImage() +*/ +const TQPixmap& TQMovie::framePixmap() const +{ + return d->mypixmap; +} + +/*! + Returns the current frame of the movie, as a TQImage. 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 TQImage& TQMovie::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 TQMovie::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 Q_SLOTS + processing the first signal, frameNumber() will be 1, and so on. +*/ +int TQMovie::frameNumber() const { return d->framenumber; } + +/*! + Returns TRUE if the image is paused; otherwise returns FALSE. +*/ +bool TQMovie::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 TQMovie::finished() const +{ + return !d->decoder; +} + +/*! + Returns TRUE if the image is not single-stepping, not paused, and + not finished; otherwise returns FALSE. +*/ +bool TQMovie::running() const +{ + return d->stepping<0 && d->decoder; +} + +/*! + Pauses the progress of the animation. + + \sa unpause() +*/ +void TQMovie::pause() +{ + d->pause(); +} + +/*! + Unpauses the progress of the animation. + + \sa pause() +*/ +void TQMovie::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 TQMovie::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 TQMovie::step() +{ + step(1); +} + +/*! + Rewinds the movie to the beginning. If the movie has not been + paused, it begins playing again. +*/ +void TQMovie::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 TQMovie::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 TQMovie::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 + TQSize&)} so that it is signalled when the movie changes size. + + Note that due to the explicit sharing of TQMovie objects, these + connections persist until they are explicitly disconnected with + disconnectResize() or until \e every shared copy of the movie is + deleted. +*/ +void TQMovie::connectResize(TQT_BASE_OBJECT_NAME* receiver, const char *member) +{ + TQObject::connect(d, TQT_SIGNAL(sizeChanged(const TQSize&)), TQT_TQOBJECT(receiver), member); +} + +/*! + Disconnects the \a{receiver}'s \a member (or all members if \a + member is zero) that were previously connected by connectResize(). +*/ +void TQMovie::disconnectResize(TQT_BASE_OBJECT_NAME* receiver, const char *member) +{ + TQObject::disconnect(d, TQT_SIGNAL(sizeChanged(const TQSize&)), TQT_TQOBJECT(receiver), member); +} + +/*! + Connects the \a{receiver}'s \a member of type \c{void member(const + TQRect&)} 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 TQMovie objects, these + connections persist until they are explicitly disconnected with + disconnectUpdate() or until \e every shared copy of the movie is + deleted. +*/ +void TQMovie::connectUpdate(TQT_BASE_OBJECT_NAME* receiver, const char *member) +{ + TQObject::connect(d, TQT_SIGNAL(areaChanged(const TQRect&)), TQT_TQOBJECT(receiver), member); +} + +/*! + Disconnects the \a{receiver}'s \a member (or all members if \q + member is zero) that were previously connected by connectUpdate(). +*/ +void TQMovie::disconnectUpdate(TQT_BASE_OBJECT_NAME* receiver, const char *member) +{ + TQObject::disconnect(d, TQT_SIGNAL(areaChanged(const TQRect&)), TQT_TQOBJECT(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 tqStatus Code \i Meaning + \row \i TQMovie::SourceEmpty + \i signalled if the input cannot be read. + \row \i TQMovie::UnrecognizedFormat + \i signalled if the input data is unrecognized. + \row \i TQMovie::Paused + \i signalled when the movie is paused by a call to paused() + or by after \link step() stepping \endlink pauses. + \row \i TQMovie::EndOfFrame + \i signalled at end-of-frame after any update and Paused Q_SIGNALS. + \row \i TQMovie::EndOfLoop + \i signalled at end-of-loop, after any update Q_SIGNALS, + EndOfFrame - but before EndOfMovie. + \row \i TQMovie::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 TQMovie objects, these + connections persist until they are explicitly disconnected with + disconnectqStatus() or until \e every shared copy of the movie is + deleted. +*/ +void TQMovie::connectqStatus(TQObject* receiver, const char *member) +{ + TQObject::connect(d, TQT_SIGNAL(datatqStatus(int)), receiver, member); +} + +/*! + Disconnects the \a{receiver}'s \a member (or all members if \a + member is zero) that were previously connected by connectqStatus(). +*/ +void TQMovie::disconnectqStatus(TQObject* receiver, const char *member) +{ + TQObject::disconnect(d, TQT_SIGNAL(datatqStatus(int)), receiver, member); +} + + +#include "tqmovie.tqmoc" + +#endif // TQT_NO_MOVIE |