From ea318d1431c89e647598c510c4245c6571aa5f46 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Thu, 26 Jan 2012 23:32:43 -0600 Subject: Update to latest tqt3 automated conversion --- doc/html/ntqmovie.html | 388 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 388 insertions(+) create mode 100644 doc/html/ntqmovie.html (limited to 'doc/html/ntqmovie.html') diff --git a/doc/html/ntqmovie.html b/doc/html/ntqmovie.html new file mode 100644 index 000000000..9a02f4cb9 --- /dev/null +++ b/doc/html/ntqmovie.html @@ -0,0 +1,388 @@ + + + + + +TQMovie Class + + + + + + + +

TQMovie Class Reference

+ +

The TQMovie class provides incremental loading of animations or images, signalling as it progresses. +More... +

#include <ntqmovie.h> +

List of all member functions. +

Public Members

TQMovie ()
TQMovie ( int bufsize )
TQMovie ( TQDataSource * src, int bufsize = 1024 )
TQMovie ( const TQString & fileName, int bufsize = 1024 )
TQMovie ( TQByteArray data, int bufsize = 1024 )
TQMovie ( const TQMovie & movie )
~TQMovie ()
TQMovie & operator= ( const TQMovie & movie )
int pushSpace () const
void pushData ( const uchar * data, int length )
const TQColor & backgroundColor () const
void setBackgroundColor ( const TQColor & c )
const TQRect & getValidRect () const
const TQPixmap & framePixmap () const
const TQImage & frameImage () const
bool isNull () const
int frameNumber () const
int steps () const
bool paused () const
bool finished () const
bool running () const
void unpause ()
void pause ()
void step ()
void step ( int steps )
void restart ()
int speed () const
void setSpeed ( int percent )
void connectResize ( TQObject * receiver, const char * member )
void disconnectResize ( TQObject * receiver, const char * member = 0 )
void connectUpdate ( TQObject * receiver, const char * member )
void disconnectUpdate ( TQObject * receiver, const char * member = 0 )
enum Status { SourceEmpty = -2, UnrecognizedFormat = -1, Paused = 1, EndOfFrame = 2, EndOfLoop = 3, EndOfMovie = 4, SpeedChanged = 5 }
void connectStatus ( TQObject * receiver, const char * member )
void disconnectStatus ( TQObject * receiver, const char * member = 0 )

Detailed Description

+ + +The TQMovie class provides incremental loading of animations or images, signalling as it progresses. +

+ + + +

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 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 ntqgif.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. +

Member Type Documentation

TQMovie::Status

+ +

TQMovie::SourceEmpty +
TQMovie::UnrecognizedFormat +
TQMovie::Paused +
TQMovie::EndOfFrame +
TQMovie::EndOfLoop +
TQMovie::EndOfMovie +
TQMovie::SpeedChanged +

Member Function Documentation

TQMovie::TQMovie () +

+Constructs a null TQMovie. The only interesting thing to do with +such a movie is to assign another movie to it. +

TQMovie::TQMovie ( int bufsize ) +

+Constructs a TQMovie with an external data source. You should later +call pushData() to send incoming animation data to the movie. +

The 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 = 1024 ) +

+Constructs a TQMovie that reads an image sequence from the given +data source, 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. +

TQMovie::TQMovie ( const TQString & fileName, int bufsize = 1024 ) +

+Constructs a TQMovie that reads an image sequence from the file, fileName. +

TQMovie::TQMovie ( TQByteArray data, int bufsize = 1024 ) +

+Constructs a TQMovie that reads an image sequence from the byte +array, data. +

TQMovie::TQMovie ( const TQMovie & movie ) +

+Constructs a movie that uses the same data as movie movie. +TQMovies use explicit sharing, so operations on the copy will +affect both. + +

TQMovie::~TQMovie () +

+Destroys the TQMovie. If this is the last reference to the data of +the movie, the data is deallocated. + +

const TQColor & TQMovie::backgroundColor () const +

+Returns the background color of the movie set by +setBackgroundColor(). + +

void TQMovie::connectResize ( TQObject * receiver, const char * member ) +

+Connects the receiver's member of type 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 every shared copy of the movie is +deleted. + +

Example: movies/main.cpp. +

void TQMovie::connectStatus ( TQObject * receiver, const char * member ) +

+Connects the receiver's member, of type void member(int) so that it is signalled when the movie changes +status. The status codes are negative for errors and positive for +information. +

Status Code	Meaning +
TQMovie::SourceEmpty +	signalled if the input cannot be read. +
TQMovie::UnrecognizedFormat +	signalled if the input data is unrecognized. +
TQMovie::Paused +	signalled when the movie is paused by a call to paused() +or by after stepping pauses. +
TQMovie::EndOfFrame +	signalled at end-of-frame after any update and Paused signals. +
TQMovie::EndOfLoop +	signalled at end-of-loop, after any update signals, +EndOfFrame - but before EndOfMovie. +
TQMovie::EndOfMovie +	signalled when the movie completes and is not about to loop. +

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 +disconnectStatus() or until every shared copy of the movie is +deleted. + +

Example: movies/main.cpp. +

void TQMovie::connectUpdate ( TQObject * receiver, const char * member ) +

+Connects the receiver's member of type 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 every shared copy of the movie is +deleted. + +

Example: movies/main.cpp. +

void TQMovie::disconnectResize ( TQObject * receiver, const char * member = 0 ) +

+Disconnects the receiver's member (or all members if member is zero) that were previously connected by connectResize(). + +

void TQMovie::disconnectStatus ( TQObject * receiver, const char * member = 0 ) +

+Disconnects the receiver's member (or all members if member is zero) that were previously connected by connectStatus(). + +

void TQMovie::disconnectUpdate ( TQObject * receiver, const char * member = 0 ) +

+Disconnects the receiver's member (or all members if \q +member is zero) that were previously connected by connectUpdate(). + +

bool TQMovie::finished () const +

+Returns TRUE if the image is no longer playing: this happens when +all loops of all frames are complete; otherwise returns FALSE. + +

Example: movies/main.cpp. +

const TQImage & TQMovie::frameImage () const +

+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. +

int TQMovie::frameNumber () const +

+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. + +

const TQPixmap & TQMovie::framePixmap () const +

+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. +

const TQRect & TQMovie::getValidRect () const +

+Returns the area of the pixmap for which pixels have been +generated. + +

bool TQMovie::isNull () const +

+Returns TRUE if the movie is null; otherwise returns FALSE. + +

TQMovie & TQMovie::operator= ( const TQMovie & movie ) +

+Makes this movie use the same data as movie movie. TQMovies use +explicit sharing. + +

void TQMovie::pause () +

+Pauses the progress of the animation. +

bool TQMovie::paused () const +

+Returns TRUE if the image is paused; otherwise returns FALSE. + +

Example: movies/main.cpp. +

void TQMovie::pushData ( const uchar * data, int length ) +

+Pushes length bytes from data into the movie. length must +be no more than the amount returned by pushSpace() since the +previous call to pushData(). + +

int TQMovie::pushSpace () const +

+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. + +

void TQMovie::restart () +

+Rewinds the movie to the beginning. If the movie has not been +paused, it begins playing again. + +

Example: movies/main.cpp. +

bool TQMovie::running () const +

+Returns TRUE if the image is not single-stepping, not paused, and +not finished; otherwise returns FALSE. + +

void TQMovie::setBackgroundColor ( const TQColor & c ) +

+Sets the background color of the pixmap to 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. +

void TQMovie::setSpeed ( int percent ) +

+Sets the movie's play speed as a percentage, to percent. This +is a percentage of the speed dictated by the input data format. +The default is 100 percent. + +

int TQMovie::speed () const +

+Returns the movie's play speed as a percentage. The default is 100 +percent. +

void TQMovie::step () +

+Steps forward 1 frame and then pauses. + +

Example: movies/main.cpp. +

void TQMovie::step ( int steps ) +

+This is an overloaded member function, provided for convenience. It behaves essentially like the above function. +

Steps forward, showing steps frames, and then pauses. + +

int TQMovie::steps () const +

+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. + +

Example: movies/main.cpp. +

void TQMovie::unpause () +

+Unpauses the progress of the animation. +