You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1230 lines
30 KiB
1230 lines
30 KiB
/****************************************************************************
|
|
**
|
|
** Implementation of TQPicture class
|
|
**
|
|
** Created : 940802
|
|
**
|
|
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
|
|
**
|
|
** 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.
|
|
**
|
|
**********************************************************************/
|
|
|
|
#include "ntqpicture.h"
|
|
|
|
#ifndef TQT_NO_PICTURE
|
|
|
|
#include "ntqpainter.h"
|
|
#include "ntqpixmap.h"
|
|
#include "ntqimage.h"
|
|
#include "ntqfile.h"
|
|
#include "ntqdatastream.h"
|
|
#include "ntqpaintdevicemetrics.h"
|
|
|
|
#ifndef TQT_NO_SVG
|
|
#include "private/qsvgdevice_p.h"
|
|
#endif
|
|
|
|
/*!
|
|
\class TQPicture ntqpicture.h
|
|
\brief The TQPicture class is a paint device that records and
|
|
replays TQPainter commands.
|
|
|
|
\ingroup graphics
|
|
\ingroup images
|
|
\ingroup shared
|
|
|
|
A picture serializes painter commands to an IO device in a
|
|
platform-independent format. For example, a picture created under
|
|
Windows can be read on a Sun SPARC.
|
|
|
|
Pictures are called meta-files on some platforms.
|
|
|
|
TQt pictures use a proprietary binary format. Unlike native picture
|
|
(meta-file) formats on many window systems, TQt pictures have no
|
|
limitations regarding their contents. Everything that can be
|
|
painted can also be stored in a picture, e.g. fonts, pixmaps,
|
|
regions, transformed graphics, etc.
|
|
|
|
TQPicture is an \link shclass.html implicitly shared\endlink class.
|
|
|
|
Example of how to record a picture:
|
|
\code
|
|
TQPicture pic;
|
|
TQPainter p;
|
|
p.begin( &pic ); // paint in picture
|
|
p.drawEllipse( 10,20, 80,70 ); // draw an ellipse
|
|
p.end(); // painting done
|
|
pic.save( "drawing.pic" ); // save picture
|
|
\endcode
|
|
|
|
Example of how to replay a picture:
|
|
\code
|
|
TQPicture pic;
|
|
pic.load( "drawing.pic" ); // load picture
|
|
TQPainter p;
|
|
p.begin( &myWidget ); // paint in myWidget
|
|
p.drawPicture( pic ); // draw the picture
|
|
p.end(); // painting done
|
|
\endcode
|
|
|
|
Pictures can also be drawn using play(). Some basic data about a
|
|
picture is available, for example, size(), isNull() and
|
|
boundingRect().
|
|
|
|
*/
|
|
|
|
|
|
static const char *mfhdr_tag = "TQPIC"; // header tag
|
|
static const TQ_UINT16 mfhdr_maj = 5; // major version #
|
|
static const TQ_UINT16 mfhdr_min = 0; // minor version #
|
|
|
|
|
|
/*!
|
|
Constructs an empty picture.
|
|
|
|
The \a formatVersion parameter may be used to \e create a TQPicture
|
|
that can be read by applications that are compiled with earlier
|
|
versions of TQt.
|
|
\list
|
|
\i \a formatVersion == 1 is binary compatible with TQt 1.x and later.
|
|
\i \a formatVersion == 2 is binary compatible with TQt 2.0.x and later.
|
|
\i \a formatVersion == 3 is binary compatible with TQt 2.1.x and later.
|
|
\i \a formatVersion == 4 is binary compatible with TQt 3.0.x and later.
|
|
\i \a formatVersion == 5 is binary compatible with TQt 3.1.
|
|
\endlist
|
|
|
|
Note that the default formatVersion is -1 which signifies the
|
|
current release, i.e. for TQt 3.1 a formatVersion of 5 is the same
|
|
as the default formatVersion of -1.
|
|
|
|
Reading pictures generated by earlier versions of TQt is supported
|
|
and needs no special coding; the format is automatically detected.
|
|
*/
|
|
|
|
TQPicture::TQPicture( int formatVersion )
|
|
: TQPaintDevice( TQInternal::Picture | TQInternal::ExternalDevice )
|
|
// set device type
|
|
{
|
|
d = new TQPicturePrivate;
|
|
|
|
#if defined(QT_CHECK_RANGE)
|
|
if ( formatVersion == 0 )
|
|
tqWarning( "TQPicture: invalid format version 0" );
|
|
#endif
|
|
|
|
// still accept the 0 default from before TQt 3.0.
|
|
if ( formatVersion > 0 && formatVersion != (int)mfhdr_maj ) {
|
|
d->formatMajor = formatVersion;
|
|
d->formatMinor = 0;
|
|
d->formatOk = FALSE;
|
|
}
|
|
else {
|
|
d->resetFormat();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
Constructs a \link shclass.html shallow copy\endlink of \a pic.
|
|
*/
|
|
|
|
TQPicture::TQPicture( const TQPicture &pic )
|
|
: TQPaintDevice( TQInternal::Picture | TQInternal::ExternalDevice )
|
|
{
|
|
d = pic.d;
|
|
d->ref();
|
|
}
|
|
|
|
/*!
|
|
Destroys the picture.
|
|
*/
|
|
TQPicture::~TQPicture()
|
|
{
|
|
if ( d->deref() )
|
|
delete d;
|
|
}
|
|
|
|
|
|
/*!
|
|
\fn bool TQPicture::isNull() const
|
|
|
|
Returns TRUE if the picture contains no data; otherwise returns
|
|
FALSE.
|
|
*/
|
|
|
|
/*!
|
|
\fn uint TQPicture::size() const
|
|
|
|
Returns the size of the picture data.
|
|
|
|
\sa data()
|
|
*/
|
|
|
|
/*!
|
|
\fn const char* TQPicture::data() const
|
|
|
|
Returns a pointer to the picture data. The pointer is only valid
|
|
until the next non-const function is called on this picture. The
|
|
returned pointer is 0 if the picture contains no data.
|
|
|
|
\sa size(), isNull()
|
|
*/
|
|
|
|
/*!
|
|
Sets the picture data directly from \a data and \a size. This
|
|
function copies the input data.
|
|
|
|
\sa data(), size()
|
|
*/
|
|
|
|
void TQPicture::setData( const char* data, uint size )
|
|
{
|
|
detach();
|
|
TQByteArray a( size );
|
|
memcpy( a.data(), data, size );
|
|
d->pictb.setBuffer( a ); // set byte array in buffer
|
|
d->resetFormat(); // we'll have to check
|
|
}
|
|
|
|
|
|
/*!
|
|
Loads a picture from the file specified by \a fileName and returns
|
|
TRUE if successful; otherwise returns FALSE.
|
|
|
|
By default, the file will be interpreted as being in the native
|
|
TQPicture format. Specifying the \a format string is optional and
|
|
is only needed for importing picture data stored in a different
|
|
format.
|
|
|
|
Currently, the only external format supported is the \link
|
|
http://www.w3.org/Graphics/SVG/ W3C SVG \endlink format which
|
|
requires the \link xml.html TQt XML module \endlink. The
|
|
corresponding \a format string is "svg".
|
|
|
|
\sa save()
|
|
*/
|
|
|
|
bool TQPicture::load( const TQString &fileName, const char *format )
|
|
{
|
|
TQFile f( fileName );
|
|
if ( !f.open(IO_ReadOnly) )
|
|
return FALSE;
|
|
return load( &f, format );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a dev is the device to use for loading.
|
|
*/
|
|
|
|
bool TQPicture::load( TQIODevice *dev, const char *format )
|
|
{
|
|
#ifndef TQT_NO_SVG
|
|
if ( qstrcmp( format, "svg" ) == 0 ) {
|
|
TQSvgDevice svg;
|
|
if ( !svg.load( dev ) )
|
|
return FALSE;
|
|
TQPainter p( this );
|
|
bool b = svg.play( &p );
|
|
d->brect = svg.boundingRect();
|
|
return b;
|
|
}
|
|
#endif
|
|
if ( format ) {
|
|
tqWarning( "TQPicture::load: No such picture format: %s", format );
|
|
return FALSE;
|
|
}
|
|
|
|
detach();
|
|
TQByteArray a = dev->readAll();
|
|
d->pictb.setBuffer( a ); // set byte array in buffer
|
|
return d->checkFormat();
|
|
}
|
|
|
|
/*!
|
|
Saves a picture to the file specified by \a fileName and returns
|
|
TRUE if successful; otherwise returns FALSE.
|
|
|
|
Specifying the file \a format string is optional. It's not
|
|
recommended unless you intend to export the picture data for
|
|
use by a third party reader. By default the data will be saved in
|
|
the native TQPicture file format.
|
|
|
|
Currently, the only external format supported is the \link
|
|
http://www.w3.org/Graphics/SVG/ W3C SVG \endlink format which
|
|
requires the \link xml.html TQt XML module \endlink. The
|
|
corresponding \a format string is "svg".
|
|
|
|
\sa load()
|
|
*/
|
|
|
|
bool TQPicture::save( const TQString &fileName, const char *format )
|
|
{
|
|
if ( paintingActive() ) {
|
|
#if defined(QT_CHECK_STATE)
|
|
tqWarning( "TQPicture::save: still being painted on. "
|
|
"Call TQPainter::end() first" );
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
|
|
#ifndef TQT_NO_SVG
|
|
// identical to TQIODevice* code below but the file name
|
|
// makes a difference when it comes to saving pixmaps
|
|
if ( tqstricmp( format, "svg" ) == 0 ) {
|
|
TQSvgDevice svg;
|
|
TQPainter p( &svg );
|
|
if ( !play( &p ) )
|
|
return FALSE;
|
|
svg.setBoundingRect( boundingRect() );
|
|
return svg.save( fileName );
|
|
}
|
|
#endif
|
|
|
|
TQFile f( fileName );
|
|
if ( !f.open(IO_WriteOnly) )
|
|
return FALSE;
|
|
return save( &f, format );
|
|
}
|
|
|
|
/*!
|
|
\overload
|
|
|
|
\a dev is the device to use for saving.
|
|
*/
|
|
|
|
bool TQPicture::save( TQIODevice *dev, const char *format )
|
|
{
|
|
if ( paintingActive() ) {
|
|
#if defined(QT_CHECK_STATE)
|
|
tqWarning( "TQPicture::save: still being painted on. "
|
|
"Call TQPainter::end() first" );
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
|
|
#ifndef TQT_NO_SVG
|
|
if ( tqstricmp( format, "svg" ) == 0 ) {
|
|
TQSvgDevice svg;
|
|
TQPainter p( &svg );
|
|
if ( !play( &p ) )
|
|
return FALSE;
|
|
svg.setBoundingRect( boundingRect() );
|
|
return svg.save( dev );
|
|
}
|
|
#endif
|
|
if ( format ) {
|
|
tqWarning( "TQPicture::save: No such picture format: %s", format );
|
|
return FALSE;
|
|
}
|
|
|
|
dev->writeBlock( d->pictb.buffer().data(), d->pictb.buffer().size() );
|
|
return TRUE;
|
|
}
|
|
|
|
/*!
|
|
Returns the picture's bounding rectangle or an invalid rectangle
|
|
if the picture contains no data.
|
|
*/
|
|
|
|
TQRect TQPicture::boundingRect() const
|
|
{
|
|
if ( !d->formatOk )
|
|
d->checkFormat();
|
|
return d->brect;
|
|
}
|
|
|
|
/*!
|
|
Sets the picture's bounding rectangle to \a r. The automatically
|
|
calculated value is overriden.
|
|
*/
|
|
|
|
void TQPicture::setBoundingRect( const TQRect &r )
|
|
{
|
|
if ( !d->formatOk )
|
|
d->checkFormat();
|
|
d->brect = r;
|
|
}
|
|
|
|
/*!
|
|
Replays the picture using \a painter, and returns TRUE if
|
|
successful; otherwise returns FALSE.
|
|
|
|
This function does exactly the same as TQPainter::drawPicture()
|
|
with (x, y) = (0, 0).
|
|
*/
|
|
|
|
bool TQPicture::play( TQPainter *painter )
|
|
{
|
|
if ( d->pictb.size() == 0 ) // nothing recorded
|
|
return TRUE;
|
|
|
|
if ( !d->formatOk && !d->checkFormat() )
|
|
return FALSE;
|
|
|
|
d->pictb.open( IO_ReadOnly ); // open buffer device
|
|
TQDataStream s;
|
|
s.setDevice( &d->pictb ); // attach data stream to buffer
|
|
s.device()->at( 10 ); // go directly to the data
|
|
s.setVersion( d->formatMajor == 4 ? 3 : d->formatMajor );
|
|
|
|
TQ_UINT8 c, clen;
|
|
TQ_UINT32 nrecords;
|
|
s >> c >> clen;
|
|
Q_ASSERT( c == PdcBegin );
|
|
// bounding rect was introduced in ver 4. Read in checkFormat().
|
|
if ( d->formatMajor >= 4 ) {
|
|
TQ_INT32 dummy;
|
|
s >> dummy >> dummy >> dummy >> dummy;
|
|
}
|
|
s >> nrecords;
|
|
if ( !exec( painter, s, nrecords ) ) {
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQPicture::play: Format error" );
|
|
#endif
|
|
d->pictb.close();
|
|
return FALSE;
|
|
}
|
|
d->pictb.close();
|
|
return TRUE; // no end-command
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
Iterates over the internal picture data and draws the picture using
|
|
\a painter.
|
|
*/
|
|
|
|
bool TQPicture::exec( TQPainter *painter, TQDataStream &s, int nrecords )
|
|
{
|
|
#if defined(QT_DEBUG)
|
|
int strm_pos;
|
|
#endif
|
|
TQ_UINT8 c; // command id
|
|
TQ_UINT8 tiny_len; // 8-bit length descriptor
|
|
TQ_INT32 len; // 32-bit length descriptor
|
|
TQ_INT16 i_16, i1_16, i2_16; // parameters...
|
|
TQ_INT8 i_8;
|
|
TQ_UINT32 ul;
|
|
TQCString str1;
|
|
TQString str;
|
|
TQPoint p, p1, p2;
|
|
TQRect r;
|
|
TQPointArray a;
|
|
TQColor color;
|
|
TQFont font;
|
|
TQPen pen;
|
|
TQBrush brush;
|
|
TQRegion rgn;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
TQWMatrix matrix;
|
|
#endif
|
|
|
|
while ( nrecords-- && !s.eof() ) {
|
|
s >> c; // read cmd
|
|
s >> tiny_len; // read param length
|
|
if ( tiny_len == 255 ) // longer than 254 bytes
|
|
s >> len;
|
|
else
|
|
len = tiny_len;
|
|
#if defined(QT_DEBUG)
|
|
strm_pos = s.device()->at();
|
|
#endif
|
|
switch ( c ) { // exec cmd
|
|
case PdcNOP:
|
|
break;
|
|
case PdcDrawPoint:
|
|
s >> p;
|
|
painter->drawPoint( p );
|
|
break;
|
|
case PdcMoveTo:
|
|
s >> p;
|
|
painter->moveTo( p );
|
|
break;
|
|
case PdcLineTo:
|
|
s >> p;
|
|
painter->lineTo( p );
|
|
break;
|
|
case PdcDrawLine:
|
|
s >> p1 >> p2;
|
|
painter->drawLine( p1, p2 );
|
|
break;
|
|
case PdcDrawRect:
|
|
s >> r;
|
|
painter->drawRect( r );
|
|
break;
|
|
case PdcDrawRoundRect:
|
|
s >> r >> i1_16 >> i2_16;
|
|
painter->drawRoundRect( r, i1_16, i2_16 );
|
|
break;
|
|
case PdcDrawEllipse:
|
|
s >> r;
|
|
painter->drawEllipse( r );
|
|
break;
|
|
case PdcDrawArc:
|
|
s >> r >> i1_16 >> i2_16;
|
|
painter->drawArc( r, i1_16, i2_16 );
|
|
break;
|
|
case PdcDrawPie:
|
|
s >> r >> i1_16 >> i2_16;
|
|
painter->drawPie( r, i1_16, i2_16 );
|
|
break;
|
|
case PdcDrawChord:
|
|
s >> r >> i1_16 >> i2_16;
|
|
painter->drawChord( r, i1_16, i2_16 );
|
|
break;
|
|
case PdcDrawLineSegments:
|
|
s >> a;
|
|
painter->drawLineSegments( a );
|
|
break;
|
|
case PdcDrawPolyline:
|
|
s >> a;
|
|
painter->drawPolyline( a );
|
|
break;
|
|
case PdcDrawPolygon:
|
|
s >> a >> i_8;
|
|
painter->drawPolygon( a, i_8 );
|
|
break;
|
|
case PdcDrawCubicBezier:
|
|
s >> a;
|
|
#ifndef TQT_NO_BEZIER
|
|
painter->drawCubicBezier( a );
|
|
#endif
|
|
break;
|
|
case PdcDrawText:
|
|
s >> p >> str1;
|
|
painter->drawText( p, str1 );
|
|
break;
|
|
case PdcDrawTextFormatted:
|
|
s >> r >> i_16 >> str1;
|
|
painter->drawText( r, i_16, str1 );
|
|
break;
|
|
case PdcDrawText2:
|
|
s >> p >> str;
|
|
painter->drawText( p, str );
|
|
break;
|
|
case PdcDrawText2Formatted:
|
|
s >> r >> i_16 >> str;
|
|
painter->drawText( r, i_16, str );
|
|
break;
|
|
case PdcDrawPixmap: {
|
|
TQPixmap pixmap;
|
|
if ( d->formatMajor < 4 ) {
|
|
s >> p >> pixmap;
|
|
painter->drawPixmap( p, pixmap );
|
|
} else {
|
|
s >> r >> pixmap;
|
|
painter->drawPixmap( r, pixmap );
|
|
}
|
|
}
|
|
break;
|
|
case PdcDrawImage: {
|
|
TQImage image;
|
|
if ( d->formatMajor < 4 ) {
|
|
s >> p >> image;
|
|
painter->drawImage( p, image );
|
|
} else {
|
|
s >> r >> image;
|
|
painter->drawImage( r, image );
|
|
}
|
|
}
|
|
break;
|
|
case PdcBegin:
|
|
s >> ul; // number of records
|
|
if ( !exec( painter, s, ul ) )
|
|
return FALSE;
|
|
break;
|
|
case PdcEnd:
|
|
if ( nrecords == 0 )
|
|
return TRUE;
|
|
break;
|
|
case PdcSave:
|
|
painter->save();
|
|
break;
|
|
case PdcRestore:
|
|
painter->restore();
|
|
break;
|
|
case PdcSetBkColor:
|
|
s >> color;
|
|
painter->setBackgroundColor( color );
|
|
break;
|
|
case PdcSetBkMode:
|
|
s >> i_8;
|
|
painter->setBackgroundMode( (TQt::BGMode)i_8 );
|
|
break;
|
|
case PdcSetROP:
|
|
s >> i_8;
|
|
painter->setRasterOp( (TQt::RasterOp)i_8 );
|
|
break;
|
|
case PdcSetBrushOrigin:
|
|
s >> p;
|
|
painter->setBrushOrigin( p );
|
|
break;
|
|
case PdcSetFont:
|
|
s >> font;
|
|
painter->setFont( font );
|
|
break;
|
|
case PdcSetPen:
|
|
s >> pen;
|
|
painter->setPen( pen );
|
|
break;
|
|
case PdcSetBrush:
|
|
s >> brush;
|
|
painter->setBrush( brush );
|
|
break;
|
|
case PdcSetTabStops:
|
|
s >> i_16;
|
|
painter->setTabStops( i_16 );
|
|
break;
|
|
case PdcSetTabArray:
|
|
s >> i_16;
|
|
if ( i_16 == 0 ) {
|
|
painter->setTabArray( 0 );
|
|
} else {
|
|
int *ta = new int[i_16];
|
|
TQ_CHECK_PTR( ta );
|
|
for ( int i=0; i<i_16; i++ ) {
|
|
s >> i1_16;
|
|
ta[i] = i1_16;
|
|
}
|
|
painter->setTabArray( ta );
|
|
delete [] ta;
|
|
}
|
|
break;
|
|
case PdcSetVXform:
|
|
s >> i_8;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
painter->setViewXForm( i_8 );
|
|
#endif
|
|
break;
|
|
case PdcSetWindow:
|
|
s >> r;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
painter->setWindow( r );
|
|
#endif
|
|
break;
|
|
case PdcSetViewport:
|
|
s >> r;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
painter->setViewport( r );
|
|
#endif
|
|
break;
|
|
case PdcSetWXform:
|
|
s >> i_8;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
painter->setWorldXForm( i_8 );
|
|
#endif
|
|
break;
|
|
case PdcSetWMatrix:
|
|
#ifndef TQT_NO_TRANSFORMATIONS // #### fix me!
|
|
s >> matrix >> i_8;
|
|
painter->setWorldMatrix( matrix, i_8 );
|
|
#endif
|
|
break;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
case PdcSaveWMatrix:
|
|
painter->saveWorldMatrix();
|
|
break;
|
|
case PdcRestoreWMatrix:
|
|
painter->restoreWorldMatrix();
|
|
break;
|
|
#endif
|
|
case PdcSetClip:
|
|
s >> i_8;
|
|
painter->setClipping( i_8 );
|
|
break;
|
|
case PdcSetClipRegion:
|
|
s >> rgn >> i_8;
|
|
painter->setClipRegion( rgn, (TQPainter::CoordinateMode)i_8 );
|
|
break;
|
|
default:
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQPicture::play: Invalid command %d", c );
|
|
#endif
|
|
if ( len ) // skip unknown command
|
|
s.device()->at( s.device()->at()+len );
|
|
}
|
|
#if defined(QT_DEBUG)
|
|
//tqDebug( "device->at(): %i, strm_pos: %i len: %i", s.device()->at(), strm_pos, len );
|
|
Q_ASSERT( TQ_INT32(s.device()->at() - strm_pos) == len );
|
|
#endif
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
Records painter commands and stores them in the pictb buffer.
|
|
*/
|
|
|
|
bool TQPicture::cmd( int c, TQPainter *pt, TQPDevCmdParam *p )
|
|
{
|
|
detach();
|
|
return d->cmd( c, pt, p );
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
Implementation of the function forwarded above to the internal data struct.
|
|
*/
|
|
|
|
bool TQPicture::TQPicturePrivate::cmd( int c, TQPainter *pt, TQPDevCmdParam *p )
|
|
{
|
|
TQDataStream s;
|
|
s.setDevice( &pictb );
|
|
// when moving up to 4 the TQDataStream version remained at 3
|
|
s.setVersion( formatMajor != 4 ? formatMajor : 3 );
|
|
if ( c == PdcBegin ) { // begin; write header
|
|
TQByteArray empty( 0 );
|
|
pictb.setBuffer( empty ); // reset byte array in buffer
|
|
pictb.open( IO_WriteOnly );
|
|
s.writeRawBytes( mfhdr_tag, 4 );
|
|
s << (TQ_UINT16)0 << (TQ_UINT16)formatMajor << (TQ_UINT16)formatMinor;
|
|
s << (TQ_UINT8)c << (TQ_UINT8)sizeof(TQ_INT32);
|
|
brect = TQRect();
|
|
if ( formatMajor >= 4 ) {
|
|
s << (TQ_INT32)brect.left() << (TQ_INT32)brect.top()
|
|
<< (TQ_INT32)brect.width() << (TQ_INT32)brect.height();
|
|
}
|
|
trecs = 0;
|
|
s << (TQ_UINT32)trecs; // total number of records
|
|
formatOk = FALSE;
|
|
return TRUE;
|
|
} else if ( c == PdcEnd ) { // end; calc checksum and close
|
|
trecs++;
|
|
s << (TQ_UINT8)c << (TQ_UINT8)0;
|
|
TQByteArray buf = pictb.buffer();
|
|
int cs_start = sizeof(TQ_UINT32); // pos of checksum word
|
|
int data_start = cs_start + sizeof(TQ_UINT16);
|
|
int brect_start = data_start + 2*sizeof(TQ_INT16) + 2*sizeof(TQ_UINT8);
|
|
int pos = pictb.at();
|
|
pictb.at( brect_start );
|
|
if ( formatMajor >= 4 ) { // bounding rectangle
|
|
s << (TQ_INT32)brect.left() << (TQ_INT32)brect.top()
|
|
<< (TQ_INT32)brect.width() << (TQ_INT32)brect.height();
|
|
}
|
|
s << (TQ_UINT32)trecs; // write number of records
|
|
pictb.at( cs_start );
|
|
TQ_UINT16 cs = (TQ_UINT16)tqChecksum( buf.data()+data_start, pos-data_start );
|
|
s << cs; // write checksum
|
|
pictb.close();
|
|
return TRUE;
|
|
}
|
|
trecs++;
|
|
s << (TQ_UINT8)c; // write cmd to stream
|
|
s << (TQ_UINT8)0; // write dummy length info
|
|
int pos = (int)pictb.at(); // save position
|
|
TQRect br; // bounding rect addition
|
|
bool corr = FALSE; // correction for pen width
|
|
|
|
switch ( c ) {
|
|
case PdcDrawPoint:
|
|
case PdcMoveTo:
|
|
case PdcLineTo:
|
|
case PdcSetBrushOrigin:
|
|
s << *p[0].point;
|
|
br = TQRect( *p[0].point, TQSize( 1, 1 ) );
|
|
corr = TRUE;
|
|
break;
|
|
case PdcDrawLine:
|
|
s << *p[0].point << *p[1].point;
|
|
br = TQRect( *p[0].point, *p[1].point ).normalize();
|
|
corr = TRUE;
|
|
break;
|
|
case PdcDrawRect:
|
|
case PdcDrawEllipse:
|
|
s << *p[0].rect;
|
|
br = *p[0].rect;
|
|
corr = TRUE;
|
|
break;
|
|
case PdcDrawRoundRect:
|
|
case PdcDrawArc:
|
|
case PdcDrawPie:
|
|
case PdcDrawChord:
|
|
s << *p[0].rect << (TQ_INT16)p[1].ival << (TQ_INT16)p[2].ival;
|
|
br = *p[0].rect;
|
|
corr = TRUE;
|
|
break;
|
|
case PdcDrawLineSegments:
|
|
case PdcDrawPolyline:
|
|
s << *p[0].ptarr;
|
|
br = p[0].ptarr->boundingRect();
|
|
corr = TRUE;
|
|
break;
|
|
#ifndef TQT_NO_BEZIER
|
|
case PdcDrawCubicBezier:
|
|
s << *p[0].ptarr;
|
|
br = p[0].ptarr->cubicBezier().boundingRect();
|
|
corr = TRUE;
|
|
break;
|
|
#endif
|
|
case PdcDrawPolygon:
|
|
s << *p[0].ptarr << (TQ_INT8)p[1].ival;
|
|
br = p[0].ptarr->boundingRect();
|
|
corr = TRUE;
|
|
break;
|
|
case PdcDrawText2:
|
|
if ( formatMajor == 1 ) {
|
|
pictb.at( pos - 2 );
|
|
s << (TQ_UINT8)PdcDrawText << (TQ_UINT8)0;
|
|
TQCString str1( (*p[1].str).latin1() );
|
|
s << *p[0].point << str1;
|
|
}
|
|
else {
|
|
s << *p[0].point << *p[1].str;
|
|
}
|
|
br = pt->fontMetrics().boundingRect( *p[1].str );
|
|
br.moveBy( p[0].point->x(), p[0].point->y() );
|
|
break;
|
|
case PdcDrawText2Formatted:
|
|
if ( formatMajor == 1 ) {
|
|
pictb.at( pos - 2 );
|
|
s << (TQ_UINT8)PdcDrawTextFormatted << (TQ_UINT8)0;
|
|
TQCString str1( (*p[2].str).latin1() );
|
|
s << *p[0].rect << (TQ_INT16)p[1].ival << str1;
|
|
}
|
|
else {
|
|
s << *p[0].rect << (TQ_INT16)p[1].ival << *p[2].str;
|
|
}
|
|
br = *p[0].rect;
|
|
break;
|
|
case PdcDrawPixmap:
|
|
if ( formatMajor < 4 ) {
|
|
s << *p[0].point;
|
|
s << *p[1].pixmap;
|
|
br = TQRect( *p[0].point, p[1].pixmap->size() );
|
|
} else {
|
|
s << *p[0].rect;
|
|
s << *p[1].pixmap;
|
|
br = *p[0].rect;
|
|
}
|
|
break;
|
|
case PdcDrawImage:
|
|
if ( formatMajor < 4 ) {
|
|
TQPoint pt( p[0].point->x(), p[0].point->y() );
|
|
s << pt;
|
|
s << *p[1].image;
|
|
br = TQRect( *p[0].point, p[1].image->size() );
|
|
} else {
|
|
s << *p[0].rect;
|
|
s << *p[1].image;
|
|
br = *p[0].rect;
|
|
}
|
|
break;
|
|
case PdcSave:
|
|
case PdcRestore:
|
|
break;
|
|
case PdcSetBkColor:
|
|
s << *p[0].color;
|
|
break;
|
|
case PdcSetBkMode:
|
|
case PdcSetROP:
|
|
s << (TQ_INT8)p[0].ival;
|
|
break;
|
|
case PdcSetFont: {
|
|
TQFont fnt = *p[0].font;
|
|
if (fnt.pointSize() > 0)
|
|
// we have to store pixels to get correct replay.
|
|
// the resolution is 72 dpi, so points == pixels
|
|
fnt.setPixelSize(TQFontInfo(fnt).pixelSize());
|
|
s << fnt;
|
|
}
|
|
break;
|
|
case PdcSetPen:
|
|
s << *p[0].pen;
|
|
break;
|
|
case PdcSetBrush:
|
|
s << *p[0].brush;
|
|
break;
|
|
case PdcSetTabStops:
|
|
s << (TQ_INT16)p[0].ival;
|
|
break;
|
|
case PdcSetTabArray:
|
|
s << (TQ_INT16)p[0].ival;
|
|
if ( p[0].ival ) {
|
|
int *ta = p[1].ivec;
|
|
for ( int i=0; i<p[0].ival; i++ )
|
|
s << (TQ_INT16)ta[i];
|
|
}
|
|
break;
|
|
case PdcSetUnit:
|
|
case PdcSetVXform:
|
|
case PdcSetWXform:
|
|
case PdcSetClip:
|
|
s << (TQ_INT8)p[0].ival;
|
|
break;
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
case PdcSetWindow:
|
|
case PdcSetViewport:
|
|
s << *p[0].rect;
|
|
break;
|
|
case PdcSetWMatrix:
|
|
s << *p[0].matrix << (TQ_INT8)p[1].ival;
|
|
break;
|
|
#endif
|
|
case PdcSetClipRegion:
|
|
s << *p[0].rgn;
|
|
s << (TQ_INT8)p[1].ival;
|
|
break;
|
|
#if defined(QT_CHECK_RANGE)
|
|
default:
|
|
tqWarning( "TQPicture::cmd: Command %d not recognized", c );
|
|
#endif
|
|
}
|
|
int newpos = (int)pictb.at(); // new position
|
|
int length = newpos - pos;
|
|
if ( length < 255 ) { // write 8-bit length
|
|
pictb.at(pos - 1); // position to right index
|
|
s << (TQ_UINT8)length;
|
|
} else { // write 32-bit length
|
|
s << (TQ_UINT32)0; // extend the buffer
|
|
pictb.at(pos - 1); // position to right index
|
|
s << (TQ_UINT8)255; // indicate 32-bit length
|
|
char *p = pictb.buffer().data();
|
|
memmove( p+pos+4, p+pos, length ); // make room for 4 byte
|
|
s << (TQ_UINT32)length;
|
|
newpos += 4;
|
|
}
|
|
pictb.at( newpos ); // set to new position
|
|
|
|
if ( br.isValid() ) {
|
|
if ( corr ) { // widen bounding rect
|
|
int w2 = pt->pen().width() / 2;
|
|
br.setCoords( br.left() - w2, br.top() - w2,
|
|
br.right() + w2, br.bottom() + w2 );
|
|
}
|
|
#ifndef TQT_NO_TRANSFORMATIONS
|
|
br = pt->worldMatrix().map( br );
|
|
#endif
|
|
if ( pt->hasClipping() ) {
|
|
TQRect cr = pt->clipRegion().boundingRect();
|
|
br &= cr;
|
|
}
|
|
if ( br.isValid() )
|
|
brect |= br; // merge with existing rect
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*!
|
|
Internal implementation of the virtual TQPaintDevice::metric()
|
|
function.
|
|
|
|
Use the TQPaintDeviceMetrics class instead.
|
|
|
|
A picture has the following hard-coded values: dpi=72,
|
|
numcolors=16777216 and depth=24.
|
|
|
|
\a m is the metric to get.
|
|
*/
|
|
|
|
int TQPicture::metric( int m ) const
|
|
{
|
|
int val;
|
|
switch ( m ) {
|
|
// ### hard coded dpi and color depth values !
|
|
case TQPaintDeviceMetrics::PdmWidth:
|
|
val = d->brect.width();
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmHeight:
|
|
val = d->brect.height();
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmWidthMM:
|
|
val = int(25.4/72.0*d->brect.width());
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmHeightMM:
|
|
val = int(25.4/72.0*d->brect.height());
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmDpiX:
|
|
case TQPaintDeviceMetrics::PdmPhysicalDpiX:
|
|
val = 72;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmDpiY:
|
|
case TQPaintDeviceMetrics::PdmPhysicalDpiY:
|
|
val = 72;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmNumColors:
|
|
val = 16777216;
|
|
break;
|
|
case TQPaintDeviceMetrics::PdmDepth:
|
|
val = 24;
|
|
break;
|
|
default:
|
|
val = 0;
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQPicture::metric: Invalid metric command" );
|
|
#endif
|
|
}
|
|
return val;
|
|
}
|
|
|
|
/*!
|
|
Detaches from shared picture data and makes sure that this picture
|
|
is the only one referring to the data.
|
|
|
|
If multiple pictures share common data, this picture makes a copy
|
|
of the data and detaches itself from the sharing mechanism.
|
|
Nothing is done if there is just a single reference.
|
|
*/
|
|
|
|
void TQPicture::detach()
|
|
{
|
|
if ( d->count != 1 )
|
|
*this = copy();
|
|
}
|
|
|
|
/*!
|
|
Returns a \link shclass.html deep copy\endlink of the picture.
|
|
*/
|
|
|
|
TQPicture TQPicture::copy() const
|
|
{
|
|
TQPicture p;
|
|
TQByteArray a( size() );
|
|
memcpy( a.data(), data(), size() );
|
|
p.d->pictb.setBuffer( a ); // set byte array in buffer
|
|
if ( d->pictb.isOpen() ) { // copy buffer state
|
|
p.d->pictb.open( d->pictb.mode() );
|
|
p.d->pictb.at( d->pictb.at() );
|
|
}
|
|
p.d->trecs = d->trecs;
|
|
p.d->formatOk = d->formatOk;
|
|
p.d->formatMinor = d->formatMajor;
|
|
p.d->brect = boundingRect();
|
|
return p;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
TQPainter member functions
|
|
*****************************************************************************/
|
|
|
|
/*!
|
|
Replays the picture \a pic translated by (\a x, \a y).
|
|
|
|
This function does exactly the same as TQPicture::play() when
|
|
called with (\a x, \a y) = (0, 0).
|
|
*/
|
|
|
|
void TQPainter::drawPicture( int x, int y, const TQPicture &pic )
|
|
{
|
|
save();
|
|
translate( x, y );
|
|
((TQPicture*)&pic)->play( (TQPainter*)this );
|
|
restore();
|
|
}
|
|
|
|
/*!
|
|
\overload void TQPainter::drawPicture( const TQPoint &p, const TQPicture &pic )
|
|
|
|
Draws picture \a pic at point \a p.
|
|
*/
|
|
|
|
void TQPainter::drawPicture( const TQPoint &p, const TQPicture &pic )
|
|
{
|
|
drawPicture( p.x(), p.y(), pic );
|
|
}
|
|
|
|
/*!
|
|
\obsolete
|
|
|
|
Use one of the other TQPainter::drawPicture() functions with a (0, 0)
|
|
offset instead.
|
|
*/
|
|
|
|
void TQPainter::drawPicture( const TQPicture &pic )
|
|
{
|
|
drawPicture( 0, 0, pic );
|
|
}
|
|
|
|
/*!
|
|
Assigns a \link shclass.html shallow copy\endlink of \a p to this
|
|
picture and returns a reference to this picture.
|
|
*/
|
|
|
|
TQPicture& TQPicture::operator= (const TQPicture& p)
|
|
{
|
|
p.d->ref(); // avoid 'x = x'
|
|
if ( d->deref() )
|
|
delete d;
|
|
d = p.d;
|
|
return *this;
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Sets formatOk to FALSE and resets the format version numbers to default
|
|
*/
|
|
|
|
void TQPicture::TQPicturePrivate::resetFormat()
|
|
{
|
|
formatOk = FALSE;
|
|
formatMajor = mfhdr_maj;
|
|
formatMinor = mfhdr_min;
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Checks data integrity and format version number. Set formatOk to TRUE
|
|
on success, to FALSE otherwise. Returns the resulting formatOk value.
|
|
*/
|
|
|
|
bool TQPicture::TQPicturePrivate::checkFormat()
|
|
{
|
|
resetFormat();
|
|
|
|
// can't check anything in an empty buffer
|
|
if ( pictb.size() == 0 )
|
|
return FALSE;
|
|
|
|
pictb.open( IO_ReadOnly ); // open buffer device
|
|
TQDataStream s;
|
|
s.setDevice( &pictb ); // attach data stream to buffer
|
|
|
|
char mf_id[4]; // picture header tag
|
|
s.readRawBytes( mf_id, 4 ); // read actual tag
|
|
if ( memcmp(mf_id, mfhdr_tag, 4) != 0 ) { // wrong header id
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQPicture::checkFormat: Incorrect header" );
|
|
#endif
|
|
pictb.close();
|
|
return FALSE;
|
|
}
|
|
|
|
int cs_start = sizeof(TQ_UINT32); // pos of checksum word
|
|
int data_start = cs_start + sizeof(TQ_UINT16);
|
|
TQ_UINT16 cs,ccs;
|
|
TQByteArray buf = pictb.buffer(); // pointer to data
|
|
s >> cs; // read checksum
|
|
ccs = tqChecksum( buf.data() + data_start, buf.size() - data_start );
|
|
if ( ccs != cs ) {
|
|
#if defined(QT_CHECK_STATE)
|
|
tqWarning( "TQPicture::checkFormat: Invalid checksum %x, %x expected",
|
|
ccs, cs );
|
|
#endif
|
|
pictb.close();
|
|
return FALSE;
|
|
}
|
|
|
|
TQ_UINT16 major, minor;
|
|
s >> major >> minor; // read version number
|
|
if ( major > mfhdr_maj ) { // new, incompatible version
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQPicture::checkFormat: Incompatible version %d.%d",
|
|
major, minor);
|
|
#endif
|
|
pictb.close();
|
|
return FALSE;
|
|
}
|
|
s.setVersion( major != 4 ? major : 3 );
|
|
|
|
TQ_UINT8 c, clen;
|
|
s >> c >> clen;
|
|
if ( c == PdcBegin ) {
|
|
if ( !( major >= 1 && major <= 3 )) {
|
|
TQ_INT32 l, t, w, h;
|
|
s >> l >> t >> w >> h;
|
|
brect = TQRect( l, t, w, h );
|
|
}
|
|
} else {
|
|
#if defined(QT_CHECK_RANGE)
|
|
tqWarning( "TQPicture::checkFormat: Format error" );
|
|
#endif
|
|
pictb.close();
|
|
return FALSE;
|
|
}
|
|
pictb.close();
|
|
|
|
formatOk = TRUE; // picture seems to be ok
|
|
formatMajor = major;
|
|
formatMinor = minor;
|
|
return TRUE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
TQPicture stream functions
|
|
*****************************************************************************/
|
|
|
|
/*!
|
|
\relates TQPicture
|
|
|
|
Writes picture \a r to the stream \a s and returns a reference to
|
|
the stream.
|
|
*/
|
|
|
|
TQDataStream &operator<<( TQDataStream &s, const TQPicture &r )
|
|
{
|
|
TQ_UINT32 size = r.d->pictb.buffer().size();
|
|
s << size;
|
|
// null picture ?
|
|
if ( size == 0 )
|
|
return s;
|
|
// just write the whole buffer to the stream
|
|
return s.writeRawBytes ( r.d->pictb.buffer().data(),
|
|
r.d->pictb.buffer().size() );
|
|
}
|
|
|
|
/*!
|
|
\relates TQPicture
|
|
|
|
Reads a picture from the stream \a s into picture \a r and returns
|
|
a reference to the stream.
|
|
*/
|
|
|
|
TQDataStream &operator>>( TQDataStream &s, TQPicture &r )
|
|
{
|
|
TQDataStream sr;
|
|
|
|
// "init"; this code is similar to the beginning of TQPicture::cmd()
|
|
sr.setDevice( &r.d->pictb );
|
|
sr.setVersion( r.d->formatMajor );
|
|
TQ_UINT32 len;
|
|
s >> len;
|
|
TQByteArray data( len );
|
|
if ( len > 0 )
|
|
s.readRawBytes( data.data(), len );
|
|
|
|
r.d->pictb.setBuffer( data );
|
|
r.d->resetFormat();
|
|
|
|
return s;
|
|
}
|
|
|
|
#endif // TQT_NO_PICTURE
|
|
|