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/ntqimage.html | 1117 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1117 insertions(+) create mode 100644 doc/html/ntqimage.html (limited to 'doc/html/ntqimage.html') diff --git a/doc/html/ntqimage.html b/doc/html/ntqimage.html new file mode 100644 index 000000000..0fa297597 --- /dev/null +++ b/doc/html/ntqimage.html @@ -0,0 +1,1117 @@ + + + + + +TQImage Class + + + + + + + +
+ +Home + | +All Classes + | +Main Classes + | +Annotated + | +Grouped Classes + | +Functions +

TQImage Class Reference

+ +

The TQImage class provides a hardware-independent pixmap +representation with direct access to the pixel data. +More... +

#include <ntqimage.h> +

List of all member functions. +

Public Members

+ +

Static Public Members

+ +

Related Functions

+ +

Detailed Description

+ + +The TQImage class provides a hardware-independent pixmap +representation with direct access to the pixel data. +

+ + + +

It is one of the two classes TQt provides for dealing with images, +the other being TQPixmap. TQImage is designed and optimized for I/O +and for direct pixel access/manipulation. TQPixmap is designed and +optimized for drawing. There are (slow) functions to convert +between TQImage and TQPixmap: TQPixmap::convertToImage() and +TQPixmap::convertFromImage(). +

An image has the parameters width, height and depth (bits per +pixel, bpp), a color table and the actual pixels. TQImage supports 1-bpp, 8-bpp and 32-bpp image +data. 1-bpp and 8-bpp images use a color lookup table; the pixel +value is a color table index. +

32-bpp images encode an RGB value in 24 bits and ignore the color +table. The most significant byte is used for the alpha buffer. +

An entry in the color table is an RGB triplet encoded as a uint. Use the qRed(), qGreen() and qBlue() functions (ntqcolor.h) to access the components, and qRgb to make an RGB triplet (see the TQColor class +documentation). +

1-bpp (monochrome) images have a color table with a most two +colors. There are two different formats: big endian (MSB first) or +little endian (LSB first) bit order. To access a single bit you +will must do some bit shifts: +

+    TQImage image;
+    // sets bit at (x,y) to 1
+    if ( image.bitOrder() == TQImage::LittleEndian )
+        *(image.scanLine(y) + (x >> 3)) |= 1 << (x & 7);
+    else
+        *(image.scanLine(y) + (x >> 3)) |= 1 << (7 - (x & 7));
+
+ +

If this looks complicated, it might be a good idea to convert the +1-bpp image to an 8-bpp image using convertDepth(). +

8-bpp images are much easier to work with than 1-bpp images +because they have a single byte per pixel: +

+    TQImage image;
+    // set entry 19 in the color table to yellow
+    image.setColor( 19, qRgb(255,255,0) );
+    // set 8 bit pixel at (x,y) to value yellow (in color table)
+    *(image.scanLine(y) + x) = 19;
+
+ +

32-bpp images ignore the color table; instead, each pixel contains +the RGB triplet. 24 bits contain the RGB value; the most +significant byte is reserved for the alpha buffer. +

+    TQImage image;
+    // sets 32 bit pixel at (x,y) to yellow.
+    uint *p = (uint *)image.scanLine(y) + x;
+    *p = qRgb(255,255,0);
+
+ +

On TQt/Embedded, scanlines are aligned to the pixel depth and may +be padded to any degree, while on all other platforms, the +scanlines are 32-bit aligned for all depths. The constructor +taking a uchar* argument always expects 32-bit aligned data. +On TQt/Embedded, an additional constructor allows the number of +bytes-per-line to be specified. +

TQImage supports a variety of methods for getting information about +the image, for example, colorTable(), allGray(), isGrayscale(), +bitOrder(), bytesPerLine(), depth(), dotsPerMeterX() and +dotsPerMeterY(), hasAlphaBuffer(), numBytes(), numColors(), and +width() and height(). +

Pixel colors are retrieved with pixel() and set with setPixel(). +

TQImage also supports a number of functions for creating a new +image that is a transformed version of the original. For example, +copy(), convertBitOrder(), convertDepth(), createAlphaMask(), +createHeuristicMask(), mirror(), scale(), smoothScale(), swapRGB() +and xForm(). There are also functions for changing attributes of +an image in-place, for example, setAlphaBuffer(), setColor(), +setDotsPerMeterX() and setDotsPerMeterY() and setNumColors(). +

Images can be loaded and saved in the supported formats. Images +are saved to a file with save(). Images are loaded from a file +with load() (or in the constructor) or from an array of data with +loadFromData(). The lists of supported formats are available from +inputFormatList() and outputFormatList(). +

Strings of text may be added to images using setText(). +

The TQImage class uses explicit sharing, +similar to that used by TQMemArray. +

New image formats can be added as plugins. +

See also TQImageIO, TQPixmap, Shared Classes, Graphics Classes, Image Processing Classes, and Implicitly and Explicitly Shared Classes. + +

Member Type Documentation

+

TQImage::Endian

+ +

This enum type is used to describe the endianness of the CPU and +graphics hardware. +

+

TQImage::ScaleMode

+ +

The functions scale() and smoothScale() use different modes for +scaling the image. The purpose of these modes is to retain the +ratio of the image if this is required. +

+ +

Member Function Documentation

+

TQImage::TQImage () +

+Constructs a null image. +

See also isNull(). + +

TQImage::TQImage ( int w, int h, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) +

+Constructs an image with w width, h height, depth bits +per pixel, numColors colors and bit order bitOrder. +

Using this constructor is the same as first constructing a null +image and then calling the create() function. +

See also create(). + +

TQImage::TQImage ( const TQSize & size, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) +

+Constructs an image with size size pixels, depth depth bits, +numColors and bitOrder endianness. +

Using this constructor is the same as first constructing a null +image and then calling the create() function. +

See also create(). + +

TQImage::TQImage ( const TQString & fileName, const char * format = 0 ) +

+Constructs an image and tries to load the image from the file fileName. +

If format is specified, the loader attempts to read the image +using the specified format. If format is not specified (which +is the default), the loader reads a few bytes from the header to +guess the file format. +

If the loading of the image failed, this object is a null image. +

The TQImageIO documentation lists the supported image formats and +explains how to add extra formats. +

See also load(), isNull(), and TQImageIO. + +

TQImage::TQImage ( const char * const xpm[] ) +

+Constructs an image from xpm, which must be a valid XPM image. +

Errors are silently ignored. +

Note that it's possible to squeeze the XPM variable a little bit +by using an unusual declaration: +

+        static const char * const start_xpm[]={
+            "16 15 8 1",
+            "a c #cec6bd",
+        ....
+
+ +

The extra const makes the entire definition read-only, which is +slightly more efficient (e.g. when the code is in a shared +library) and ROMable when the application is to be stored in ROM. + +

TQImage::TQImage ( const TQByteArray & array ) +

+Constructs an image from the binary data array. It tries to +guess the file format. +

If the loading of the image failed, this object is a null image. +

See also loadFromData(), isNull(), and imageFormat(). + +

TQImage::TQImage ( uchar * yourdata, int w, int h, int depth, TQRgb * colortable, int numColors, Endian bitOrder ) +

+Constructs an image w pixels wide, h pixels high with a +color depth of depth, that uses an existing memory buffer, yourdata. The buffer must remain valid throughout the life of the +TQImage. The image does not delete the buffer at destruction. +

If colortable is 0, a color table sufficient for numColors +will be allocated (and destructed later). +

Note that yourdata must be 32-bit aligned. +

The endianness is given in bitOrder. + +

TQImage::TQImage ( uchar * yourdata, int w, int h, int depth, int bpl, TQRgb * colortable, int numColors, Endian bitOrder ) +

+Constructs an image that uses an existing memory buffer. The +buffer must remain valid for the life of the TQImage. The image +does not delete the buffer at destruction. The buffer is passed as +yourdata. The image's width is w and its height is h. The +color depth is depth. bpl specifies the number of bytes per +line. +

If colortable is 0, a color table sufficient for numColors +will be allocated (and destructed later). +

The endianness is specified by bitOrder. +

Warning: This constructor is only available on TQt/Embedded. + +

TQImage::TQImage ( const TQImage & image ) +

+Constructs a shallow copy of image. + +

TQImage::~TQImage () +

+Destroys the image and cleans up. + +

bool TQImage::allGray () const +

+Returns TRUE if all the colors in the image are shades of gray +(i.e. their red, green and blue components are equal); otherwise +returns FALSE. +

This function is slow for large 16-bit (TQt/Embedded only) and 32-bit images. +

See also isGrayscale(). + +

Endian TQImage::bitOrder () const +

+ +

Returns the bit order for the image. +

If it is a 1-bpp image, this function returns either +TQImage::BigEndian or TQImage::LittleEndian. +

If it is not a 1-bpp image, this function returns +TQImage::IgnoreEndian. +

See also depth(). + +

uchar * TQImage::bits () const +

+ +

Returns a pointer to the first pixel data. This is equivalent to +scanLine(0). +

See also numBytes(), scanLine(), and jumpTable(). + +

Example: opengl/texture/gltexobj.cpp. +

int TQImage::bytesPerLine () const +

+ +

Returns the number of bytes per image scanline. This is equivalent +to numBytes()/height(). +

See also numBytes() and scanLine(). + +

TQRgb TQImage::color ( int i ) const +

+ +

Returns the color in the color table at index i. The first +color is at index 0. +

A color value is an RGB triplet. Use the qRed(), qGreen() and qBlue() functions (defined in ntqcolor.h) to +get the color value components. +

See also setColor(), numColors(), and TQColor. + +

Example: themes/wood.cpp. +

TQRgb * TQImage::colorTable () const +

+ +

Returns a pointer to the color table. +

See also numColors(). + +

TQImage TQImage::convertBitOrder ( Endian bitOrder ) const +

+Converts the bit order of the image to bitOrder and returns the +converted image. The original image is not changed. +

Returns *this if the bitOrder is equal to the image bit +order, or a null image if this image cannot +be converted. +

See also bitOrder(), systemBitOrder(), and isNull(). + +

TQImage TQImage::convertDepth ( int depth, int conversion_flags ) const +

+Converts the depth (bpp) of the image to depth and returns the +converted image. The original image is not changed. +

The depth argument must be 1, 8, 16 (TQt/Embedded only) or 32. +

Returns *this if depth is equal to the image depth, or a +null image if this image cannot be +converted. +

If the image needs to be modified to fit in a lower-resolution +result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. +

See also TQt::ImageConversionFlags, depth(), and isNull(). + +

TQImage TQImage::convertDepth ( int depth ) const +

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

+

TQImage TQImage::convertDepthWithPalette ( int d, TQRgb * palette, int palette_count, int conversion_flags = 0 ) const +

+Returns an image with depth d, using the palette_count +colors pointed to by palette. If d is 1 or 8, the returned +image will have its color table ordered the same as palette. +

If the image needs to be modified to fit in a lower-resolution +result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. +

Note: currently no closest-color search is made. If colors are +found that are not in the palette, the palette may not be used at +all. This result should not be considered valid because it may +change in future implementations. +

Currently inefficient for non-32-bit images. +

See also TQt::ImageConversionFlags. + +

TQImage TQImage::copy () const +

+Returns a deep copy of the image. +

See also detach(). + +

TQImage TQImage::copy ( int x, int y, int w, int h, int conversion_flags = 0 ) const +

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

Returns a deep copy of a sub-area of +the image. +

The returned image is always w by h pixels in size, and is +copied from position x, y in this image. In areas beyond +this image pixels are filled with pixel 0. +

If the image needs to be modified to fit in a lower-resolution +result (e.g. converting from 32-bit to 8-bit), use the conversion_flags to specify how you'd prefer this to happen. +

See also bitBlt() and TQt::ImageConversionFlags. + +

TQImage TQImage::copy ( const TQRect & r ) const +

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

Returns a deep copy of a sub-area of +the image. +

The returned image always has the size of the rectangle r. In +areas beyond this image pixels are filled with pixel 0. + +

bool TQImage::create ( int width, int height, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) +

+Sets the image width, height, depth, its number of colors +(in numColors), and bit order. Returns TRUE if successful, or +FALSE if the parameters are incorrect or if memory cannot be +allocated. +

The width and height is limited to 32767. depth must be +1, 8, or 32. If depth is 1, bitOrder must be set to +either TQImage::LittleEndian or TQImage::BigEndian. For other depths +bitOrder must be TQImage::IgnoreEndian. +

This function allocates a color table and a buffer for the image +data. The image data is not initialized. +

The image buffer is allocated as a single block that consists of a +table of scanline pointers (jumpTable()) +and the image data (bits()). +

See also fill(), width(), height(), depth(), numColors(), bitOrder(), jumpTable(), scanLine(), bits(), bytesPerLine(), and numBytes(). + +

bool TQImage::create ( const TQSize &, int depth, int numColors = 0, Endian bitOrder = IgnoreEndian ) +

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

+

TQImage TQImage::createAlphaMask ( int conversion_flags = 0 ) const +

+Builds and returns a 1-bpp mask from the alpha buffer in this +image. Returns a null image if alpha buffer mode is disabled. +

See TQPixmap::convertFromImage() for a description of the conversion_flags argument. +

The returned image has little-endian bit order, which you can +convert to big-endianness using convertBitOrder(). +

See also createHeuristicMask(), hasAlphaBuffer(), and setAlphaBuffer(). + +

TQImage TQImage::createHeuristicMask ( bool clipTight = TRUE ) const +

+Creates and returns a 1-bpp heuristic mask for this image. It +works by selecting a color from one of the corners, then chipping +away pixels of that color starting at all the edges. +

The four corners vote for which color is to be masked away. In +case of a draw (this generally means that this function is not +applicable to the image), the result is arbitrary. +

The returned image has little-endian bit order, which you can +convert to big-endianness using convertBitOrder(). +

If clipTight is TRUE the mask is just large enough to cover the +pixels; otherwise, the mask is larger than the data pixels. +

This function disregards the alpha buffer. +

See also createAlphaMask(). + +

int TQImage::depth () const +

+ +

Returns the depth of the image. +

The image depth is the number of bits used to encode a single +pixel, also called bits per pixel (bpp) or bit planes of an image. +

The supported depths are 1, 8, 16 (TQt/Embedded only) and 32. +

See also convertDepth(). + +

void TQImage::detach () +

+Detaches from shared image data and makes sure that this image is +the only one referring to the data. +

If multiple images share common data, this image makes a copy of +the data and detaches itself from the sharing mechanism. +Nothing is done if there is just a single reference. +

See also copy(). + +

Example: themes/wood.cpp. +

int TQImage::dotsPerMeterX () const +

+ +

Returns the number of pixels that fit horizontally in a physical +meter. This and dotsPerMeterY() define the intended scale and +aspect ratio of the image. +

See also setDotsPerMeterX(). + +

int TQImage::dotsPerMeterY () const +

+ +

Returns the number of pixels that fit vertically in a physical +meter. This and dotsPerMeterX() define the intended scale and +aspect ratio of the image. +

See also setDotsPerMeterY(). + +

void TQImage::fill ( uint pixel ) +

+Fills the entire image with the pixel value pixel. +

If the depth of this image is 1, only the +lowest bit is used. If you say fill(0), fill(2), etc., the image +is filled with 0s. If you say fill(1), fill(3), etc., the image is +filled with 1s. If the depth is 8, the lowest 8 bits are used. +

If the depth is 32 and the image has no alpha buffer, the pixel +value is written to each pixel in the image. If the image has an +alpha buffer, only the 24 RGB bits are set and the upper 8 bits +(alpha value) are left unchanged. +

Note: TQImage::pixel() returns the color of the pixel at the given +coordinates; TQColor::pixel() returns the pixel value of the +underlying window system (essentially an index value), so normally +you will want to use TQImage::pixel() to use a color from an +existing image or TQColor::rgb() to use a specific color. +

See also invertPixels(), depth(), hasAlphaBuffer(), and create(). + +

TQImage TQImage::fromMimeSource ( const TQString & abs_name ) [static] +

Convenience function. Gets the data associated with the absolute +name abs_name from the default mime source factory and decodes it +to an image. +

See also TQMimeSourceFactory, TQImage::fromMimeSource(), and TQImageDrag::decode(). + +

bool TQImage::hasAlphaBuffer () const +

+ +

Returns TRUE if alpha buffer mode is enabled; otherwise returns +FALSE. +

See also setAlphaBuffer(). + +

int TQImage::height () const +

+ +

Returns the height of the image. +

See also width(), size(), and rect(). + +

Examples: canvas/canvas.cpp and opengl/texture/gltexobj.cpp. +

const char * TQImage::imageFormat ( const TQString & fileName ) [static] +

+Returns a string that specifies the image format of the file fileName, or 0 if the file cannot be read or if the format is not +recognized. +

The TQImageIO documentation lists the guaranteed supported image +formats, or use TQImage::inputFormats() and TQImage::outputFormats() +to get lists that include the installed formats. +

See also load() and save(). + +

TQStringList TQImage::inputFormatList () [static] +

+Returns a list of image formats that are supported for image +input. +

Note that if you want to iterate over the list, you should iterate +over a copy, e.g. +

+    TQStringList list = myImage.inputFormatList();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+        myProcessing( *it );
+        ++it;
+    }
+
+ +

See also outputFormatList(), inputFormats(), and TQImageIO. + +

Example: showimg/showimg.cpp. +

TQStrList TQImage::inputFormats () [static] +

+Returns a list of image formats that are supported for image +input. +

See also outputFormats(), inputFormatList(), and TQImageIO. + +

void TQImage::invertPixels ( bool invertAlpha = TRUE ) +

+Inverts all pixel values in the image. +

If the depth is 32: if invertAlpha is TRUE, the alpha bits are +also inverted, otherwise they are left unchanged. +

If the depth is not 32, the argument invertAlpha has no +meaning. +

Note that inverting an 8-bit image means to replace all pixels +using color index i with a pixel using color index 255 minus i. Similarly for a 1-bit image. The color table is not changed. +

See also fill(), depth(), and hasAlphaBuffer(). + +

bool TQImage::isGrayscale () const +

+For 16-bit (TQt/Embedded only) and 32-bit images, this function is +equivalent to allGray(). +

For 8-bpp images, this function returns TRUE if color(i) is +TQRgb(i,i,i) for all indices of the color table; otherwise returns +FALSE. +

See also allGray() and depth(). + +

bool TQImage::isNull () const +

+ +

Returns TRUE if it is a null image; otherwise returns FALSE. +

A null image has all parameters set to zero and no allocated data. + +

Example: showimg/showimg.cpp. +

uchar ** TQImage::jumpTable () const +

+ +

Returns a pointer to the scanline pointer table. +

This is the beginning of the data block for the image. +

See also bits() and scanLine(). + +

bool TQImage::load ( const TQString & fileName, const char * format = 0 ) +

+Loads an image from the file fileName. Returns TRUE if the +image was successfully loaded; otherwise returns FALSE. +

If format is specified, the loader attempts to read the image +using the specified format. If format is not specified (which +is the default), the loader reads a few bytes from the header to +guess the file format. +

The TQImageIO documentation lists the supported image formats and +explains how to add extra formats. +

See also loadFromData(), save(), imageFormat(), TQPixmap::load(), and TQImageIO. + +

bool TQImage::loadFromData ( const uchar * buf, uint len, const char * format = 0 ) +

+Loads an image from the first len bytes of binary data in buf. Returns TRUE if the image was successfully loaded; otherwise +returns FALSE. +

If format is specified, the loader attempts to read the image +using the specified format. If format is not specified (which +is the default), the loader reads a few bytes from the header to +guess the file format. +

The TQImageIO documentation lists the supported image formats and +explains how to add extra formats. +

See also load(), save(), imageFormat(), TQPixmap::loadFromData(), and TQImageIO. + +

bool TQImage::loadFromData ( TQByteArray buf, const char * format = 0 ) +

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

Loads an image from the TQByteArray buf. + +

TQImage TQImage::mirror () const +

+Returns a TQImage which is a vertically mirrored copy of this +image. The original TQImage is not changed. + +

TQImage TQImage::mirror ( bool horizontal, bool vertical ) const +

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

Returns a mirror of the image, mirrored in the horizontal and/or +the vertical direction depending on whether horizontal and vertical are set to TRUE or FALSE. The original image is not +changed. +

See also smoothScale(). + +

int TQImage::numBytes () const +

+ +

Returns the number of bytes occupied by the image data. +

See also bytesPerLine() and bits(). + +

int TQImage::numColors () const +

+ +

Returns the size of the color table for the image. +

Notice that numColors() returns 0 for 16-bpp (TQt/Embedded only) +and 32-bpp images because these images do not use color tables, +but instead encode pixel values as RGB triplets. +

See also setNumColors() and colorTable(). + +

Example: themes/wood.cpp. +

TQPoint TQImage::offset () const +

+ +

Returns the number of pixels by which the image is intended to be +offset by when positioning relative to other images. + +

bool TQImage::operator!= ( const TQImage & i ) const +

+Returns TRUE if this image and image i have different contents; +otherwise returns FALSE. The comparison can be slow, unless there +is some obvious difference, such as different widths, in which +case the function will return tquickly. +

See also operator=(). + +

TQImage & TQImage::operator= ( const TQImage & image ) +

+Assigns a shallow copy of image to +this image and returns a reference to this image. +

See also copy(). + +

TQImage & TQImage::operator= ( const TQPixmap & pixmap ) +

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

Sets the image bits to the pixmap contents and returns a +reference to the image. +

If the image shares data with other images, it will first +dereference the shared data. +

Makes a call to TQPixmap::convertToImage(). + +

bool TQImage::operator== ( const TQImage & i ) const +

+Returns TRUE if this image and image i have the same contents; +otherwise returns FALSE. The comparison can be slow, unless there +is some obvious difference, such as different widths, in which +case the function will return tquickly. +

See also operator=(). + +

TQStringList TQImage::outputFormatList () [static] +

+Returns a list of image formats that are supported for image +output. +

Note that if you want to iterate over the list, you should iterate +over a copy, e.g. +

+    TQStringList list = myImage.outputFormatList();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+        myProcessing( *it );
+        ++it;
+    }
+
+ +

See also inputFormatList(), outputFormats(), and TQImageIO. + +

TQStrList TQImage::outputFormats () [static] +

+Returns a list of image formats that are supported for image +output. +

See also inputFormats(), outputFormatList(), and TQImageIO. + +

Example: showimg/showimg.cpp. +

TQRgb TQImage::pixel ( int x, int y ) const +

+Returns the color of the pixel at the coordinates (x, y). +

If (x, y) is not on the image, the +results are undefined. +

See also setPixel(), qRed(), qGreen(), qBlue(), and valid(). + +

Examples: canvas/canvas.cpp and qmag/qmag.cpp. +

int TQImage::pixelIndex ( int x, int y ) const +

+Returns the pixel index at the given coordinates. +

If (x, y) is not valid, or if the +image is not a paletted image (depth() > 8), the results are +undefined. +

See also valid() and depth(). + +

TQRect TQImage::rect () const +

+ +

Returns the enclosing rectangle (0, 0, width(), height()) of the +image. +

See also width(), height(), and size(). + +

void TQImage::reset () +

+Resets all image parameters and deallocates the image data. + +

bool TQImage::save ( const TQString & fileName, const char * format, int quality = -1 ) const +

+Saves the image to the file fileName, using the image file +format format and a quality factor of quality. quality +must be in the range 0..100 or -1. Specify 0 to obtain small +compressed files, 100 for large uncompressed files, and -1 (the +default) to use the default settings. +

Returns TRUE if the image was successfully saved; otherwise +returns FALSE. +

See also load(), loadFromData(), imageFormat(), TQPixmap::save(), and TQImageIO. + +

bool TQImage::save ( TQIODevice * device, const char * format, int quality = -1 ) const +

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

This function writes a TQImage to the TQIODevice, device. This +can be used, for example, to save an image directly into a +TQByteArray: +

+    TQImage image;
+    TQByteArray ba;
+    TQBuffer buffer( ba );
+    buffer.open( IO_WriteOnly );
+    image.save( &buffer, "PNG" ); // writes image into ba in PNG format
+
+ + +

TQImage TQImage::scale ( int w, int h, ScaleMode mode = ScaleFree ) const +

+Returns a copy of the image scaled to a rectangle of width w +and height h according to the ScaleMode mode. +

+

If either the width w or the height h is 0 or negative, this +function returns a null image. +

This function uses a simple, fast algorithm. If you need better +quality, use smoothScale() instead. +

See also scaleWidth(), scaleHeight(), smoothScale(), and xForm(). + +

TQImage TQImage::scale ( const TQSize & s, ScaleMode mode = ScaleFree ) const +

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

The requested size of the image is s. + +

TQImage TQImage::scaleHeight ( int h ) const +

+Returns a scaled copy of the image. The returned image has a +height of h pixels. This function automatically calculates the +width of the image so that the ratio of the image is preserved. +

If h is 0 or negative a null image is +returned. +

See also scale(), scaleWidth(), smoothScale(), and xForm(). + +

Example: table/small-table-demo/main.cpp. +

TQImage TQImage::scaleWidth ( int w ) const +

+Returns a scaled copy of the image. The returned image has a width +of w pixels. This function automatically calculates the height +of the image so that the ratio of the image is preserved. +

If w is 0 or negative a null image is +returned. +

See also scale(), scaleHeight(), smoothScale(), and xForm(). + +

uchar * TQImage::scanLine ( int i ) const +

+ +

Returns a pointer to the pixel data at the scanline with index i. The first scanline is at index 0. +

The scanline data is aligned on a 32-bit boundary. +

Warning: If you are accessing 32-bpp image data, cast the returned +pointer to TQRgb* (TQRgb has a 32-bit size) and use it to +read/write the pixel value. You cannot use the uchar* pointer +directly, because the pixel format depends on the byte order on +the underlying platform. Hint: use qRed(), +qGreen() and qBlue(), etc. (ntqcolor.h) to access the pixels. +

Warning: If you are accessing 16-bpp image data, you must handle +endianness yourself. (TQt/Embedded only) +

See also bytesPerLine(), bits(), and jumpTable(). + +

Example: desktop/desktop.cpp. +

void TQImage::setAlphaBuffer ( bool enable ) +

+Enables alpha buffer mode if enable is TRUE, otherwise disables +it. The default setting is disabled. +

An 8-bpp image has 8-bit pixels. A pixel is an index into the +color table, which contains 32-bit color +values. In a 32-bpp image, the 32-bit pixels are the color values. +

This 32-bit value is encoded as follows: The lower 24 bits are +used for the red, green, and blue components. The upper 8 bits +contain the alpha component. +

The alpha component specifies the transparency of a pixel. 0 means +completely transparent and 255 means opaque. The alpha component +is ignored if you do not enable alpha buffer mode. +

The alpha buffer is used to set a mask when a TQImage is translated +to a TQPixmap. +

See also hasAlphaBuffer() and createAlphaMask(). + +

void TQImage::setColor ( int i, TQRgb c ) +

+ +

Sets a color in the color table at index i to c. +

A color value is an RGB triplet. Use the qRgb() function (defined in ntqcolor.h) to make RGB +triplets. +

See also color(), setNumColors(), and numColors(). + +

Examples: desktop/desktop.cpp and themes/wood.cpp. +

void TQImage::setDotsPerMeterX ( int x ) +

+Sets the value returned by dotsPerMeterX() to x. + +

void TQImage::setDotsPerMeterY ( int y ) +

+Sets the value returned by dotsPerMeterY() to y. + +

void TQImage::setNumColors ( int numColors ) +

+Resizes the color table to numColors colors. +

If the color table is expanded all the extra colors will be set to +black (RGB 0,0,0). +

See also numColors(), color(), setColor(), and colorTable(). + +

void TQImage::setOffset ( const TQPoint & p ) +

+Sets the value returned by offset() to p. + +

void TQImage::setPixel ( int x, int y, uint index_or_rgb ) +

+Sets the pixel index or color at the coordinates (x, y) to +index_or_rgb. +

If (x, y) is not valid, the result is +undefined. +

If the image is a paletted image (depth() <= 8) and index_or_rgb >= numColors(), the result is undefined. +

See also pixelIndex(), pixel(), qRgb(), qRgba(), and valid(). + +

void TQImage::setText ( const char * key, const char * lang, const TQString & s ) +

+Records string s for the keyword key. The key should be a +portable keyword recognizable by other software - some suggested +values can be found in the PNG specification. s can be any text. lang +should specify the language code (see +RFC 1766) or 0. + +

TQSize TQImage::size () const +

+ +

Returns the size of the image, i.e. its width and height. +

See also width(), height(), and rect(). + +

TQImage TQImage::smoothScale ( int w, int h, ScaleMode mode = ScaleFree ) const +

+Returns a smoothly scaled copy of the image. The returned image +has a size of width w by height h pixels if mode is ScaleFree. The modes ScaleMin and ScaleMax may be used to +preserve the ratio of the image: if mode is ScaleMin, the +returned image is guaranteed to fit into the rectangle specified +by w and h (it is as large as possible within the +constraints); if mode is ScaleMax, the returned image fits +at least into the specified rectangle (it is a small as possible +within the constraints). +

For 32-bpp images and 1-bpp/8-bpp color images the result will be +32-bpp, whereas all-gray images +(including black-and-white 1-bpp) will produce 8-bit grayscale images with the palette spanning +256 grays from black to white. +

This function uses code based on pnmscale.c by Jef Poskanzer. +

pnmscale.c - read a portable anymap and scale it +

+

Copyright (C) 1989, 1991 by Jef Poskanzer. +

Permission to use, copy, modify, and distribute this software and +its documentation for any purpose and without fee is hereby +granted, provided that the above copyright notice appear in all +copies and that both that copyright notice and this permission +notice appear in supporting documentation. This software is +provided "as is" without express or implied warranty. +

See also scale() and mirror(). + +

TQImage TQImage::smoothScale ( const TQSize & s, ScaleMode mode = ScaleFree ) const +

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

The requested size of the image is s. + +

TQImage TQImage::swapRGB () const +

+Returns a TQImage in which the values of the red and blue +components of all pixels have been swapped, effectively converting +an RGB image to a BGR image. The original TQImage is not changed. + +

Endian TQImage::systemBitOrder () [static] +

+Determines the bit order of the display hardware. Returns +TQImage::LittleEndian (LSB first) or TQImage::BigEndian (MSB first). +

See also systemByteOrder(). + +

Endian TQImage::systemByteOrder () [static] +

+Determines the host computer byte order. Returns +TQImage::LittleEndian (LSB first) or TQImage::BigEndian (MSB first). +

See also systemBitOrder(). + +

TQString TQImage::text ( const char * key, const char * lang = 0 ) const +

+Returns the string recorded for the keyword key in language lang, or in a default language if lang is 0. + +

TQString TQImage::text ( const TQImageTextKeyLang & kl ) const +

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

Returns the string recorded for the keyword and language kl. + +

TQStringList TQImage::textKeys () const +

+Returns the keywords for which some texts are recorded. +

Note that if you want to iterate over the list, you should iterate +over a copy, e.g. +

+    TQStringList list = myImage.textKeys();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+        myProcessing( *it );
+        ++it;
+    }
+
+ +

See also textList(), text(), setText(), and textLanguages(). + +

TQStringList TQImage::textLanguages () const +

+Returns the language identifiers for which some texts are +recorded. +

Note that if you want to iterate over the list, you should iterate +over a copy, e.g. +

+    TQStringList list = myImage.textLanguages();
+    TQStringList::Iterator it = list.begin();
+    while( it != list.end() ) {
+        myProcessing( *it );
+        ++it;
+    }
+
+ +

See also textList(), text(), setText(), and textKeys(). + +

TQValueList<TQImageTextKeyLang> TQImage::textList () const +

+Returns a list of TQImageTextKeyLang objects that enumerate all the +texts key/language pairs set by setText() for this image. +

Note that if you want to iterate over the list, you should iterate +over a copy, e.g. +

+    TQValueList<TQImageTextKeyLang> list = myImage.textList();
+    TQValueList<TQImageTextKeyLang>::Iterator it = list.begin();
+    while( it != list.end() ) {
+        myProcessing( *it );
+        ++it;
+    }
+
+ + +

bool TQImage::valid ( int x, int y ) const +

+Returns TRUE if ( x, y ) is a valid coordinate in the image; +otherwise returns FALSE. +

See also width(), height(), and pixelIndex(). + +

Examples: canvas/canvas.cpp and qmag/qmag.cpp. +

int TQImage::width () const +

+ +

Returns the width of the image. +

See also height(), size(), and rect(). + +

Examples: canvas/canvas.cpp and opengl/texture/gltexobj.cpp. +

TQImage TQImage::xForm ( const TQWMatrix & matrix ) const +

+Returns a copy of the image that is transformed using the +transformation matrix, matrix. +

The transformation matrix is internally adjusted to compensate +for unwanted translation, i.e. xForm() returns the smallest image +that contains all the transformed points of the original image. +

See also scale(), TQPixmap::xForm(), TQPixmap::trueMatrix(), and TQWMatrix. + +

Related Functions

+

void bitBlt ( TQImage * dst, int dx, int dy, const TQImage * src, int sx, int sy, int sw, int sh, int conversion_flags ) +

+ +

Copies a block of pixels from src to dst. The pixels +copied from source (src) are converted according to +conversion_flags if it is incompatible with the destination +(dst). +

sx, sy is the top-left pixel in src, dx, dy +is the top-left position in dst and sw, \sh is the +size of the copied block. +

The copying is clipped if areas outside src or dst are +specified. +

If sw is -1, it is adjusted to src->width(). Similarly, if sh is -1, it is adjusted to src->height(). +

Currently inefficient for non 32-bit images. + +

TQDataStream & operator<< ( TQDataStream & s, const TQImage & image ) +

+ +

Writes the image image to the stream s as a PNG image, or as a +BMP image if the stream's version is 1. +

Note that writing the stream to a file will not produce a valid image file. +

See also TQImage::save() and Format of the TQDataStream operators. + +

TQDataStream & operator>> ( TQDataStream & s, TQImage & image ) +

+ +

Reads an image from the stream s and stores it in image. +

See also TQImage::load() and Format of the TQDataStream operators. + + +

+This file is part of the TQt toolkit. +Copyright © 1995-2007 +Trolltech. All Rights Reserved.

+ +
Copyright © 2007 +TrolltechTrademarks +
TQt 3.3.8
+
+ -- cgit v1.2.1