From bd0f3345a938b35ce6a12f6150373b0955b8dd12 Mon Sep 17 00:00:00 2001 From: Timothy Pearson Date: Sun, 10 Jul 2011 15:24:15 -0500 Subject: Add Qt3 development HEAD version --- doc/html/qpointarray.html | 285 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 285 insertions(+) create mode 100644 doc/html/qpointarray.html (limited to 'doc/html/qpointarray.html') diff --git a/doc/html/qpointarray.html b/doc/html/qpointarray.html new file mode 100644 index 0000000..1c4e19b --- /dev/null +++ b/doc/html/qpointarray.html @@ -0,0 +1,285 @@ + + + + + +QPointArray Class + + + + + + + +

QPointArray Class Reference

+ +

The QPointArray class provides an array of points. +More... +

#include <qpointarray.h> +

Inherits QMemArray<QPoint>. +

List of all member functions. +

Public Members

QPointArray ()
~QPointArray ()
QPointArray ( int size )
QPointArray ( const QPointArray & a )
QPointArray ( const QRect & r, bool closed = FALSE )
QPointArray & operator= ( const QPointArray & a )
QPointArray copy () const
void translate ( int dx, int dy )
QRect boundingRect () const
void point ( uint index, int * x, int * y ) const
QPoint point ( uint index ) const
void setPoint ( uint index, int x, int y )
void setPoint ( uint i, const QPoint & p )
bool putPoints ( int index, int nPoints, int firstx, int firsty, ... )
bool putPoints ( int index, int nPoints, const QPointArray & from, int fromIndex = 0 )
void makeArc ( int x, int y, int w, int h, int a1, int a2 )
void makeEllipse ( int x, int y, int w, int h )
void makeArc ( int x, int y, int w, int h, int a1, int a2, const QWMatrix & xf )
QPointArray cubicBezier () const

Related Functions

QDataStream & operator<< ( QDataStream & s, const QPointArray & a )
QDataStream & operator>> ( QDataStream & s, QPointArray & a )

Detailed Description

+ + +The QPointArray class provides an array of points. +

+ + +

A QPointArray is an array of QPoint objects. In addition to the +functions provided by QMemArray, QPointArray provides some +point-specific functions. +

For convenient reading and writing of the point data use +setPoints(), putPoints(), point(), and setPoint(). +

For geometry operations use boundingRect() and translate(). There +is also the QWMatrix::map() function for more general +transformations of QPointArrays. You can also create arcs and +ellipses with makeArc() and makeEllipse(). +

Among others, QPointArray is used by QPainter::drawLineSegments(), +QPainter::drawPolyline(), QPainter::drawPolygon() and +QPainter::drawCubicBezier(). +

Note that because this class is a QMemArray, copying an array and +modifying the copy modifies the original as well, i.e. a shallow copy. If you need a deep copy use copy() or detach(), for example: +

+        void drawGiraffe( const QPointArray & r, QPainter * p )
+        {
+            QPointArray tmp = r;
+            tmp.detach();
+            // some code that modifies tmp
+            p->drawPoints( tmp );
+        }
+

+ +

If you forget the tmp.detach(), the const array will be modified. +

Member Function Documentation

QPointArray::QPointArray () +

+ +

Constructs a null point array. +

QPointArray::QPointArray ( int size ) +

+ +

Constructs a point array with room for size points. Makes a +null array if size == 0. +

QPointArray::QPointArray ( const QPointArray & a ) +

+ +

Constructs a shallow copy of the point array a. +

QPointArray::QPointArray ( const QRect & r, bool closed = FALSE ) +

+Constructs a point array from the rectangle r. +

If closed is FALSE, then the point array just contains the +following four points in the listed order: r.topLeft(), +r.topRight(), r.bottomRight() and r.bottomLeft(). +

If closed is TRUE, then a fifth point is set to r.topLeft(). + +

QPointArray::~QPointArray () +

+ +

Destroys the point array. + +

QRect QPointArray::boundingRect () const +

+Returns the bounding rectangle of the points in the array, or +QRect(0,0,0,0) if the array is empty. + +

QPointArray QPointArray::copy () const +

+ +

Creates a deep copy of the array. +

QPointArray QPointArray::cubicBezier () const +

+Returns the Bezier points for the four control points in this +array. + +

void QPointArray::makeArc ( int x, int y, int w, int h, int a1, int a2 ) +

+Sets the points of the array to those describing an arc of an +ellipse with size, width w by height h, and position (x, +y), starting from angle a1 and spanning by angle a2. The +resulting array has sufficient resolution for pixel accuracy (see +the overloaded function which takes an additional QWMatrix +parameter). +

Angles are specified in 16ths of a degree, i.e. a full circle +equals 5760 (16*360). Positive values mean counter-clockwise, +whereas negative values mean the clockwise direction. Zero degrees +is at the 3 o'clock position. +

See the angle diagram. + +

void QPointArray::makeArc ( int x, int y, int w, int h, int a1, int a2, const QWMatrix & xf ) +

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

Sets the points of the array to those describing an arc of an +ellipse with width w and height h and position (x, y), +starting from angle a1, and spanning angle by a2, and +transformed by the matrix xf. The resulting array has +sufficient resolution for pixel accuracy. +

See the angle diagram. + +

void QPointArray::makeEllipse ( int x, int y, int w, int h ) +

+Sets the points of the array to those describing an ellipse with +size, width w by height h, and position (x, y). +

The returned array has sufficient resolution for use as pixels. + +

QPointArray & QPointArray::operator= ( const QPointArray & a ) +

+ +

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

Equivalent to assign(a). +

void QPointArray::point ( uint index, int * x, int * y ) const +

+Reads the coordinates of the point at position index within the +array and writes them into *x and *y. + +

QPoint QPointArray::point ( uint index ) const +

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

Returns the point at position index within the array. + +

bool QPointArray::putPoints ( int index, int nPoints, int firstx, int firsty, ... ) +

+Copies nPoints points from the variable argument list into this +point array from position index, and resizes the point array if +index+nPoints exceeds the size of the array. +

Returns TRUE if successful, or FALSE if the array could not be +resized (typically due to lack of memory). +

The example code creates an array with three points (4,5), (6,7) +and (8,9), by expanding the array from 1 to 3 points: +

+        QPointArray a( 1 );
+        a[0] = QPoint( 4, 5 );
+        a.putPoints( 1, 2, 6,7, 8,9 ); // index == 1, points == 2
+

+ +

This has the same result, but here putPoints overwrites rather +than extends: +

+        QPointArray a( 3 );
+        a.putPoints( 0, 3, 4,5, 0,0, 8,9 );
+        a.putPoints( 1, 1, 6,7 );
+

+ +

The points are given as a sequence of integers, starting with firstx then firsty, and so on. +

bool QPointArray::putPoints ( int index, int nPoints, const QPointArray & from, int fromIndex = 0 ) +

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

This version of the function copies nPoints from from into +this array, starting at index in this array and fromIndex in +from. fromIndex is 0 by default. +

+        QPointArray a;
+        a.putPoints( 0, 3, 1,2, 0,0, 5,6 );
+        // a is now the three-point array ( 1,2, 0,0, 5,6 );
+        QPointArray b;
+        b.putPoints( 0, 3, 4,4, 5,5, 6,6 );
+        // b is now ( 4,4, 5,5, 6,6 );
+        a.putPoints( 2, 3, b );
+        // a is now ( 1,2, 0,0, 4,4, 5,5, 6,6 );
+

+ + +