diff -r 000000000000 -r a41df078684a kernel/eka/euser/us_graph.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kernel/eka/euser/us_graph.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,1392 @@ +// Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of the License "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// e32\euser\us_graph.cpp +// +// + +#include "us_std.h" + + + + +EXPORT_C TBool TPoint::operator==(const TPoint& aPoint) const +/** +Compares two points for equality. + +For two points to be equal, both their x and y co-ordinate values must be +equal. + +@param aPoint The point to be compared with this point. + +@return True, if the two points are equal; false, otherwise. +*/ + { + + return(iX==aPoint.iX && iY==aPoint.iY); + } + + + + +EXPORT_C TBool TPoint::operator!=(const TPoint& aPoint) const +/** +Compares two points for inequality. + +For two points to be unequal, either their x or their y co-ordinate values +must be different. + +@param aPoint The point to be compared with this point. + +@return True, if the two points are unequal; false, otherwise. +*/ + { + + return(iX!=aPoint.iX || iY!=aPoint.iY); + } + + + + +EXPORT_C TPoint& TPoint::operator-=(const TPoint& aPoint) +/** +TPoint subtraction assignment operator. + +The operator subtracts the specified point from this point, and assigns the +result back to this point. + +@param aPoint The point to be subtracted. + +@return A reference to this point object. +*/ + { + + iX-=aPoint.iX; + iY-=aPoint.iY; + return(*this); + } + + + + +EXPORT_C TPoint& TPoint::operator-=(const TSize& aSize) +/** +TSize subtraction assignment operator. + +The operator subtracts the specified TSize from this point, and assigns the +result back to this point. + +The operation proceeds by: + +1. subtracting the width value of the TSize from the x co-ordinate value + +2. subtracting the height value of the TSize from the y co-ordinate value + +@param aSize The TSize to be subtracted. + +@return A reference to this point object. +*/ + { + + iX-=aSize.iWidth; + iY-=aSize.iHeight; + return(*this); + } + + + + +EXPORT_C TPoint& TPoint::operator+=(const TPoint& aPoint) +/** +TPoint addition assignment operator. + +The operator adds the specified point to this point, and assigns the result +back to this point. + +@param aPoint The point to be added. + +@return A reference to this point object. +*/ + { + + iX+=aPoint.iX; + iY+=aPoint.iY; + return(*this); + } + + + + +EXPORT_C TPoint& TPoint::operator+=(const TSize& aSize) +/** +TSize addition assignment operator. + +The operator adds the specified TSize to this point, and assigns the result +back to this point. + +The operation proceeds by: + +1. adding the width value of the TSize to the x co-ordinate value + +2. adding the height value of the TSize to the y co-ordinate value + +@param aSize The TSize to be added to this point. + +@return A reference to this point object. +*/ + { + + iX+=aSize.iWidth; + iY+=aSize.iHeight; + return(*this); + } + + + + +EXPORT_C TPoint TPoint::operator-(const TPoint& aPoint) const +/** +TPoint subtraction operator. + +The operator subtracts the specified point from this point, and returns the +resulting value. + +@param aPoint The point to be subtracted from this point. + +@return The result of the operation. +*/ + { + + TPoint ret=* this; + ret-= aPoint; + return(ret); + } + + + + +EXPORT_C TPoint TPoint::operator-(const TSize& aSize) const +/** +TSize subtraction operator. + +The operator subtracts the specified TSize from this point, and returns the +resulting value. + +The operation proceeds by: + +1. subtracting the width value of the TSize from the x co-ordinate value + +2. subtracting the height value of the TSize from the y co-ordinate value. + +@param aSize The TSize to be subtracted. + +@return The result of the operation. +*/ + { + + TPoint ret=* this; + ret-= aSize; + return(ret); + } + + + + +EXPORT_C TPoint TPoint::operator+(const TPoint& aPoint) const +/** +The operator adds the specified point to this point, and returns the resulting +value. + +@param aPoint The point to be added to this point. + +@return The result of the operation. +*/ + { + + TPoint ret=* this; + ret+= aPoint; + return(ret); + } + + + + +EXPORT_C TPoint TPoint::operator+(const TSize& aSize) const +/** +TSize addition operator. + +The operator adds the specified TSize to this point, and returns the resulting +value. + +The operation proceeds by: + +1. adding the width value of the TSize to the x co-ordinate value + +2. adding the height value of the TSize to the y co-ordinate value. + +@param aSize The TSize to be added to this TPoint. + +@return The result of the operation. +*/ + { + + TPoint ret=* this; + ret+= aSize; + return(ret); + } + + + + +EXPORT_C TPoint TPoint::operator-() const +/** +Unary minus operator. + +The operator returns the negation of this point. + +@return The result of the operation. +*/ + { + + return TPoint(-iX,-iY); + } + + + + +EXPORT_C void TPoint::SetXY(TInt aX,TInt aY) +/** +Sets the x and y co-ordinates for this point. + +@param aX The value to assign to the x co-ordinate. +@param aY The value to assign to the y co-ordinate. +*/ + { + + iX=aX; + iY=aY; + } + + + + +EXPORT_C TSize TPoint::AsSize() const +/** +Gets the size of the rectangle whose top left hand corner is the origin of +the screen co-ordinates and whose bottom right hand corner is this point. + +@return The co-ordinates of this point converted to a size. +*/ + { + return(TSize(iX,iY)); + } + + + + + +EXPORT_C TBool TPoint3D::operator==(const TPoint3D& aPoint3D) const +/** +Compares two 3D points(TPoint3D) for equality. + +For two TPoint3D to be equal, their x , y and zco-ordinate values must be +equal. + +@param aPoint3D The point to be compared with this point. + +@return True, if the two points are equal; false, otherwise. +*/ + { + return(iX==aPoint3D.iX && iY==aPoint3D.iY && iZ==aPoint3D.iZ); + } + + + + +EXPORT_C TBool TPoint3D::operator!=(const TPoint3D& aPoint3D) const +/** +Compares two 3D points for inequality. + +For two points to be unequal, their x or y or z co-ordinate values +must be different. + +@param aPoint3D The point to be compared with this point. + +@return True, if the two points are unequal; false, otherwise. +*/ + { + return(iX!=aPoint3D.iX || iY!=aPoint3D.iY || iZ!=aPoint3D.iZ); + } + + + + + + +EXPORT_C TPoint3D& TPoint3D::operator-=(const TPoint3D& aPoint3D) +/** +TPoint3D subtraction assignment operator. + +The operator subtracts the specified point from this point, and assigns the +result back to this point. + +@param aPoint The point to be subtracted. + +@return A reference to this point object. +*/ + { + iX-=aPoint3D.iX; + iY-=aPoint3D.iY; + iZ-=aPoint3D.iZ; + return(*this); + } + + + +EXPORT_C TPoint3D& TPoint3D::operator-=(const TPoint& aPoint) + +/** +TPoint subtraction assignment operator. + +The operator subtracts the specified TPoint from this point(TPoint3D), and assigns the +result back to this point. + +The operation proceeds by +subtracting x and y cordinates of the TPoin to this point and no changes to the Z-coordinatete value + +@param aPoint The aPoint to be subtracted. + +@return A reference to this point object. +*/ + { + iX-=aPoint.iX; + iY-=aPoint.iY; + //No Changes to the z co-ordinate + return(*this); + } + + + +EXPORT_C TPoint3D& TPoint3D::operator+=(const TPoint3D& aPoint3D) +/** +TPoint3D addition assignment operator. + +The operator adds the specified point to this point, and assigns the result +back to this point. + +@param aPoint3D The point to be added. + +@return A reference to this point object. +*/ + { + iX+=aPoint3D.iX; + iY+=aPoint3D.iY; + iZ+=aPoint3D.iZ; + return(*this); + } + +EXPORT_C TPoint3D& TPoint3D::operator+=(const TPoint& aPoint) +/** +TPoint addition assignment operator. + +The operator adds the specified TPoint to this point, and assigns the result +back to this point. + +The operation proceeds by: +adding x and y cordinates of the TPoin to this point and no changes to the Z-coordinatete value + +@param aPoint The TPoint to be added to this point. + +@return A reference to this point object. +*/ + { + + iX+=aPoint.iX; + iY+=aPoint.iY; + //No Changes to the z co-ordinate + return(*this); + } +EXPORT_C TPoint3D TPoint3D::operator-(const TPoint3D& aPoint3D) const +/** +TPoint3D subtraction operator. + +The operator subtracts the specified point from this point, and returns the +resulting value. + +@param aPoint3D The point to be subtracted from this point. + +@return the point(TPoint3D) which is the result of the operation. +*/ + { + + TPoint3D ret=* this; + ret-= aPoint3D; + return(ret); + } + + + +EXPORT_C TPoint3D TPoint3D::operator-(const TPoint& aPoint) const +/** +TPoint subtraction operator. + +The operator subtracts the specified TPoint from this point, and returns the +resulting value. + +@param aPoint The TPoint to be subtracted. + +@return the point(TPoint3D) which is the result of the operation. +*/ + { + + TPoint3D ret=* this; + ret-= aPoint; + return(ret); + } + + +EXPORT_C TPoint3D TPoint3D::operator+(const TPoint3D& aPoint3D) const +/** +The operator adds the specified point to this point, and returns the resulting +value. + +@param aPoint3D The point to be added to this point. + +@return the point(TPoint3D) which is the result of the operation. +*/ + { + + TPoint3D ret=* this; + ret+= aPoint3D; + return(ret); + } + +EXPORT_C TPoint3D TPoint3D::operator+(const TPoint& aPoint) const +/** +TPoint addition operator. + +The operator adds the specified TPoint to this point, and returns the resulting +value. + +@param aSize The TSize to be added to this TPoint. + +@return the point(TPoint3D) which is the result of the operation. +*/ + { + + TPoint3D ret=* this; + ret+= aPoint; + return(ret); + } + + +EXPORT_C TPoint3D TPoint3D::operator-() const +/** +Unary minus operator. + +The operator returns the negation of this point. + +@return the point(TPoint3D) which is the result of Unary minus operation. +*/ + { + return TPoint3D(-iX,-iY,-iZ); + } + + + +EXPORT_C void TPoint3D::SetXYZ(TInt aX,TInt aY,TInt aZ) +/** +Sets the x , y and z co-ordinates for this point. + +@param aX The value to assign to the x co-ordinate. +@param aY The value to assign to the y co-ordinate. +@param aZ The value to assign to the z co-ordinate. +*/ + { + iX=aX; + iY=aY; + iZ=aZ; + } + +EXPORT_C void TPoint3D::SetPoint(const TPoint& aPoint) +/* +TPoint3D from TPoint, sets the Z co-ordinate to Zero +@param aPoint The TPoint to add to this point +*/ + { + iX=aPoint.iX; + iY=aPoint.iY; + iZ=0; + } + + +EXPORT_C TPoint TPoint3D::AsPoint() const +/** +Gets Tpoint from Tpoint3D +@return TPoint from X and Y cordinates of Tpoint3D +*/ + { + return(TPoint(iX,iY)); + } + + + + + + +EXPORT_C TBool TSize::operator==(const TSize& aSize) const +/** +Compares this TSize with the specified TSize for equality. + +For two TSizes to be equal, both their width and height values must be equal. + +@param aSize The TSize to be compared with this TSize. + +@return True, if the two TSize are equal; false, otherwise. +*/ + { + return(iWidth==aSize.iWidth && iHeight==aSize.iHeight); + } + + + + +EXPORT_C TBool TSize::operator!=(const TSize& aSize) const +/** +Compares two TSize for inequality. + +For two TSize to be unequal, either their width or height values must be different. + +@param aSize The TSize to be compared with this TSize. + +@return True, if the two TSize are unequal; false, otherwise. +*/ + { + return(iWidth!=aSize.iWidth || iHeight!=aSize.iHeight); + } + + + + +EXPORT_C TSize& TSize::operator-=(const TSize& aSize) +/** +TSize subtraction assignment operator. + +The operator subtracts the specified TSize from this TSize, and assigns the +result back to this TSize. + +@param aSize The TSize to be subtracted. + +@return A reference to this TSize object. +*/ + { + iWidth-=aSize.iWidth;iHeight-=aSize.iHeight;return(*this); + } + + + + +EXPORT_C TSize& TSize::operator-=(const TPoint& aPoint) +/** +TPoint subtraction assignment operator. + +The operator subtracts the specified point from this TSize, and assigns the +result back to this TSize. + +The operation proceeds by: + +1. subtracting the point's x co-ordinate value from the width + +2. subtracting the point's y co-ordinate value from the height. + +@param aPoint The point to be subtracted. + +@return A reference to this size object. +*/ + { + iWidth-=aPoint.iX;iHeight-=aPoint.iY;return(*this); + } + + + + +EXPORT_C TSize& TSize::operator+=(const TSize& aSize) +/** +TSize addition assignment operator. + +The operator adds the specified TSize to this TSize, and assigns the result +back to this TSize. + +@param aSize The TSize to be added. + +@return A reference to this size object. +*/ + { + iWidth+=aSize.iWidth;iHeight+=aSize.iHeight;return(*this); + } + + + + +EXPORT_C TSize& TSize::operator+=(const TPoint& aPoint) +/** +TPoint addition assignment operator. + +The operator adds the specified point to this TSize, and assigns the result +back to this TSize. + +The operation proceeds by: + +1. adding the point's x co-ordinate value to the width + +2. adding the point's y co-ordinate value to the height. + +@param aPoint The point to be added. + +@return A reference to this size object. +*/ + { + iWidth+=aPoint.iX;iHeight+=aPoint.iY;return(*this); + } + + + + +EXPORT_C TSize TSize::operator-(const TSize& aSize) const +/** +TSize subtraction operator. + +This operator subtracts the specified TSize from this TSize, and returns the +resulting value. + +@param aSize The TSize to be subtracted from this Tsize. + +@return The result of the operation. +*/ + { + TSize ret=* this; ret-= aSize ;return(ret); + } + + + + +EXPORT_C TSize TSize::operator-(const TPoint& aPoint) const +/** +TPoint subtraction operator. + +This operator subtracts the specified point from this TSize, and returns the +resulting value. + +The operation proceeds by: + +1. subtracting the x co-ordinate value from the width + +2. subtracting the y co-ordinate value from the height + +@param aPoint The point to be subtracted. + +@return The result of the operation. +*/ + { + TSize ret=* this; ret-= aPoint ;return(ret); + } + + + + +EXPORT_C TSize TSize::operator+(const TSize& aSize) const +/** +TSize addition operator. + +This operator adds the specified TSize to this TSize, and returns the resulting +value. + +@param aSize The TSize to be added to this Tsize. + +@return The result of the operation. +*/ + { + TSize ret=* this; ret+= aSize ;return(ret); + } + + + + +EXPORT_C TSize TSize::operator+(const TPoint& aPoint) const +/** +TPoint addition operator. + +This operator adds the specified point to this TSize, and returns the resulting +value. + +The operation proceeds by: + +1. adding the x co-ordinate value to the width + +2. adding the y co-ordinate value to the height + +@param aPoint The point to be added to this TSize. + +@return The result of the operation. +*/ + { + TSize ret=* this; ret+= aPoint ;return(ret); + } + + + + +EXPORT_C TSize TSize::operator-() const +/** +Unary minus operator. + +The operator returns the negation of this TSize. + +@return The result of the operation. +*/ + { + + return TSize(-iWidth,-iHeight); + } + + + + +EXPORT_C void TSize::SetSize(TInt aWidth,TInt aHeight) +/** +Sets the width and height. + +@param aWidth The width value. +@param aHeight The height value. +*/ + { + iWidth=aWidth;iHeight=aHeight; + } + + + + +EXPORT_C TPoint TSize::AsPoint() const +/** +Gets a TPoint object whose co-ordinates are the width and height of this TSize. + +@return The co-ordinates of this TSize converted to a point. +*/ + { + return(TPoint(iWidth,iHeight)); + } + + + + +EXPORT_C TRect::TRect() : iTl(0,0),iBr(0,0) +/** +Constructs a default rectangle. + +This initialises the co-ordinates of its top +left and bottom right corners to (0,0). +*/ + {} + + + + +EXPORT_C TRect::TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy) : iTl(aAx,aAy),iBr(aBx,aBy) +/** +Constructs the rectangle, initialising its top left and bottom right hand corners +with four TInt values. + +@param aAx The horizontal co-ordinate of the left hand side of the rectangle. +@param aAy The vertical co-ordinate of the top of the rectangle. +@param aBx The horizontal co-ordinate of the right hand side of the rectangle. +@param aBy The vertical co-ordinate of the bottom of the rectangle. +*/ + {} + + + + +EXPORT_C TRect::TRect(const TPoint& aPointA,const TPoint& aPointB) : iTl(aPointA),iBr(aPointB) +/** +Constructs the rectangle with two TPoints, corresponding to its top left and +bottom right hand corners. + +@param aPointA The co-ordinates of the rectangle's top left hand corner. +@param aPointB The co-ordinates of the rectangle's bottom right hand corner. +*/ + {} + + + + +EXPORT_C TRect::TRect(const TPoint& aPoint,const TSize& aSize) : iTl(aPoint),iBr(aPoint+aSize) +/** +Constructs the rectangle with a TPoint for its top left corner, and a TSize +for its width and height. + +@param aPoint The rectangle's top left hand corner. +@param aSize The rectangle's width and height. +*/ + {} + + + + +EXPORT_C TRect::TRect(const TSize& aSize) : iTl(0,0), iBr(aSize.iWidth, aSize.iHeight) +/** +Constructs the rectangle with a TSize. + +The co-ordinates of its top left hand corner are initialised to (0,0) and +its width and height are initialised to the values contained in the argument. + +@param aSize The width and height of the rectangle. +*/ + {} + + + + +EXPORT_C void TRect::SetRect(TInt aTlX,TInt aTlY,TInt aBrX,TInt aBrY) +/** +Sets the rectangle's position using four TInts. + +@param aTlX The horizontal co-ordinate of the left hand side of the rectangle. +@param aTlY The vertical co-ordinate of the top of the rectangle. +@param aBrX The horizontal co-ordinate of the right hand side of the rectangle. +@param aBrY The vertical co-ordinate of the bottom of the rectangle. +*/ + { + iTl.iX=aTlX;iTl.iY=aTlY;iBr.iX=aBrX;iBr.iY=aBrY; + } + + + + +EXPORT_C void TRect::SetRect(const TPoint& aPointTL,const TPoint& aPointBR) +/** +Sets the rectangle's position using two TPoints. + +@param aPointTL The co-ordinates of the rectangle's top left hand corner. +@param aPointBR The co-ordinates of the rectangle's bottom right hand corner. +*/ + { + iTl=aPointTL;iBr=aPointBR; + } + + + + +EXPORT_C void TRect::SetRect(const TPoint& aTL,const TSize& aSize) +/** +Sets the rectangle's position using a TPoint and a TSize. + +@param aTL The co-ordinates of the rectangle's top left hand corner. +@param aSize The rectangle's width and height. +*/ + { + iTl=aTL;iBr=aTL+aSize; + } + + + + +EXPORT_C void TRect::Shrink(TInt aDx,TInt aDy) +/** +Shrinks a rectangle using specified horizontal and vertical offsets. + +The offset values are added to the co-ordinates of its top left hand corner, +and the same values are subtracted from the co-ordinates of its bottom right +hand corner. The co-ordinates of the centre of the rectangle remain unchanged. +If either value is negative, the rectangle expands in the corresponding direction. + +@param aDx The number of pixels by which to move the left and right hand sides + of the rectangle. A positive value reduces the width, a negative + value increases it. +@param aDy The number of pixels by which to move the top and bottom of the + rectangle. A positive value reduces the height, a negative value + increases it. +*/ + { + Adjust(aDx,aDy); + } + + + + +EXPORT_C void TRect::Shrink(const TSize& aSize) +/** +Shrinks a rectangle using a specified TSize offset. + +The rectangle shrinks by twice the value of the height and width specified +in the TSize. The co-ordinates of the centre of the rectangle remain unchanged. +If either value is negative, the rectangle expands in the +corresponding direction. + +@param aSize The number of pixels by which to move the left and right hand + sides of the rectangle (by aSize.iWidth) and the top and bottom + (by aSize.iHeight). +*/ + { + Adjust(aSize.iWidth,aSize.iHeight); + } + + + + +EXPORT_C void TRect::Resize(const TSize& aSize) +/** +Resizes a rectangle by adding a TSize offset. + +The offset is added to the co-ordinates of its bottom right hand corner. If +either value in the TSize is negative, the rectangle shrinks in the +corresponding direction. The co-ordinates of the rectangle's top left hand +corner are unaffected. + +@param aSize The number of pixels by which to move the rectangle; the right + hand side by aSize.iWidth and the bottom by aSize.iHeight. +*/ + { + iBr+=aSize; + } + + + + +EXPORT_C void TRect::Resize(TInt aDx, TInt aDy) +/** +Resizes a rectangle by adding a horizontal and vertical offset. + +The offset is added to the co-ordinates of its bottom right hand corner. If +either value is negative, the rectangle shrinks in the corresponding direction. +The co-ordinates of the rectangle's top left hand corner are unaffected. + +@param aDx The number of pixels by which to move the right hand side of the + rectangle. +@param aDy The number of pixels by which to move the bottom of the rectangle. +*/ + { + iBr.iX+=aDx;iBr.iY+=aDy; + } + + + + +EXPORT_C TBool TRect::operator==(const TRect &aRect) const +/** +Compares two rectangles for equality. + +For two rectangles to be equal, the co-ordinates of both their top left and +bottom right hand corners must be equal. + +@param aRect The rectangle to compare with this rectangle. + +@return True, if the rectangles have the same co-ordinates; false, otherwise. +*/ + { + + return(iTl==aRect.iTl && iBr==aRect.iBr); + } + + + + +EXPORT_C TBool TRect::operator!=(const TRect &aRect) const +/** +Compares two rectangles for inequality. + +Two rectangles are unequal if any of their co-ordinates differ. + +@param aRect The rectangle to compare with this rectangle. +@return True, if the rectangles do not have the same co-ordinates; false, if + all co-ordinates are equal. +*/ + { + + return(iTl!=aRect.iTl || iBr!=aRect.iBr); + } + + + + +EXPORT_C void TRect::Move(const TPoint &aOffset) +/** +Moves the rectangle by adding a TPoint offset. + +The offset is added to the co-ordinates of both its top left and bottom right +hand corners. The size of the rectangle is unchanged. + +@param aOffset The number of pixels to move the rectangle; horizontally by + aOffset.iX and vertically by aOffset.iY. +*/ + { + + iTl+=aOffset; + iBr+=aOffset; + } + + + + +EXPORT_C void TRect::Move(TInt aDx,TInt aDy) +/** +Moves the rectangle by adding an x, y offset. + +The offset is added to the co-ordinates of both its top left and bottom right +hand corners. The size of the rectangle is unchanged. + +@param aDx The number of pixels to move the rectangle horizontally. If negative, + the rectangle moves leftwards. +@param aDy The number of pixels to move the rectangle vertically. If negative, + the rectangle moves upwards. +*/ + { + + iTl.iX+=aDx; + iTl.iY+=aDy; + iBr.iX+=aDx; + iBr.iY+=aDy; + } + + + + +// private function, hence not exported +void TRect::Adjust(TInt aDx,TInt aDy) +// +// Adjust by a delta. +// + { + + iTl.iX+=aDx; + iTl.iY+=aDy; + iBr.iX-=aDx; + iBr.iY-=aDy; + } + + + + +EXPORT_C void TRect::Grow(TInt aDx,TInt aDy) +// +// Grow by a delta. +// +/** +Grows the rectangle using the specified horizontal and vertical offsets. + +The offset values are subtracted from the co-ordinates of its top left hand +corner, and the same values are added to the co-ordinates of its bottom right +hand corner. The co-ordinates of the centre of the rectangle remain unchanged. +If either value is negative, the rectangle shrinks in the corresponding direction. + +@param aDx The number of pixels by which to move the left and right hand sides + of the rectangle. A positive value increases the width, a negative + value reduces it. +@param aDy The number of pixels by which to move the top and bottom of the + rectangle. A positive value increases the height, a negative + value reduces it. +*/ + { + + iTl.iX-=aDx; + iTl.iY-=aDy; + iBr.iX+=aDx; + iBr.iY+=aDy; + } + + + + +EXPORT_C void TRect::Grow(const TSize &aSize) +// +// Grow by a size. +// +/** +Grows a rectangle using the specified TSize offset. + +The rectangle grows by twice the value of the height and width specified in +the TSize. The co-ordinates of the centre of the rectangle remain unchanged. +If either value is negative, the rectangle shrinks in the +corresponding direction. + +@param aSize The number of pixels by which to move the left and right hand + sides of the rectangle (by aSize.iWidth) and the top and bottom + (by aSize.iHeight). +*/ + { + + iTl-=aSize; + iBr+=aSize; + } + + + + +EXPORT_C void TRect::BoundingRect(const TRect &aRect) +// +// Union of this and aRect, a union is defined as the minimum rectangle that encloses +// both source rectangles +// +/** +Gets the minimal rectangle which bounds both this rectangle and the specified +rectangle, and assigns it to this rectangle. + +@param aRect The rectangle to use with this rectangle to get the minimal bounding + rectangle. +*/ + { + + if (iTl.iX>aRect.iTl.iX) + iTl.iX=aRect.iTl.iX; + if (iTl.iY>aRect.iTl.iY) + iTl.iY=aRect.iTl.iY; + if (iBr.iX=iBr.iX || iTl.iY>=iBr.iY); + } + + + + +EXPORT_C void TRect::Intersection(const TRect &aRect) +// +// Intersect this with aRect. +// +/** +Gets the area of intersection between this rectangle and the specified +rectangle, and assigns it to this rectangle. + +It is usual to call TRect::Intersects() first to verify whether the two rectangles +intersect. If the two rectangles do not intersect, then, on return, this rectangle +is set to be empty. + +@param aRect The rectangle to be used with this rectangle to get the area + of intersection. + +@see TRect::Intersects +*/ + { + + if (iTl.iXaRect.iBr.iX) + iBr.iX=aRect.iBr.iX; + if (iBr.iY>aRect.iBr.iY) + iBr.iY=aRect.iBr.iY; + } + + + + +EXPORT_C TBool TRect::Intersects(const TRect &aRect) const +// +// If aRect Intersects with this return True. +// +/** +Tests whether this rectangle overlaps with the specified rectangle. + +Two rectangles overlap if any point is located within both rectangles. There +is no intersection if two adjacent sides touch without overlapping, or if +either rectangle is empty. + +@param aRect The rectangle to compare with this rectangle for an intersection. + +@return True, if the two rectangles overlap; false, if there is no overlap. +*/ + { + + return(!(IsEmpty() || aRect.IsEmpty() || iBr.iX<=aRect.iTl.iX || iBr.iY<=aRect.iTl.iY || iTl.iX>=aRect.iBr.iX || iTl.iY>=aRect.iBr.iY)); + } + + + + +EXPORT_C void TRect::Normalize() +// +// Make the conditions top left bottom right true. +// +/** +Ensures that the rectangle's width and height have positive values. + +For example, if the rectangle's co-ordinates are such that the top is below +the bottom, or the right hand side is to the left of the left hand side, normalisation +swaps the co-ordinates of the top and bottom or of the left and right. +*/ + { + + if (iTl.iX>iBr.iX) + { + TInt temp=iTl.iX; + iTl.iX=iBr.iX; + iBr.iX=temp; + } + if (iTl.iY>iBr.iY) + { + TInt temp=iTl.iY; + iTl.iY=iBr.iY; + iBr.iY=temp; + } + } + + + + +EXPORT_C TBool TRect::Contains(const TPoint &aPoint) const +/** +Tests whether a point is located within the rectangle. + +Note that a point located on the top or left hand side of the rectangle is +within the rectangle. A point located on the right hand side or bottom is +considered to be outside the rectangle. + +@param aPoint The point to be tested. + +@return True, if the point is within the rectangle; false, otherwise. +*/ + { + if (aPoint.iX=iBr.iX || aPoint.iY=iBr.iY) + return(EFalse); + return(ETrue); + } + + + + +EXPORT_C TSize TRect::Size() const +/** +Gets the size of the rectangle. + +@return The size of the rectangle. +*/ + { + return((iBr-iTl).AsSize()); + } + + + + +EXPORT_C TInt TRect::Width() const +/** +Gets the width of the rectangle. + +@return The width of the rectangle. +*/ + { + return(iBr.iX-iTl.iX); + } + + + + +EXPORT_C TInt TRect::Height() const +/** +Gets the height of the rectangle. + +@return The height of the rectangle. +*/ + { + return(iBr.iY-iTl.iY); + } + + + + +EXPORT_C TBool TRect::IsNormalized() const +/** +Tests whether the rectangle is normalised. + +A rectangle is normalised when its width and height are both zero or greater. + +@return True, if normalised; false, if not. +*/ + { + return((iBr.iX>=iTl.iX) && (iBr.iY>=iTl.iY)); + } + + + + +EXPORT_C TPoint TRect::Center() const +/** +Gets the point at the centre of the rectangle. + +@return The point at the centre of the rectangle. +*/ + { + return(TPoint((iTl.iX+iBr.iX)/2,(iTl.iY+iBr.iY)/2)); + } + + + + +EXPORT_C void TRect::SetSize(const TSize &aSize) +/** +Sets the size of the rectangle. + +Only the co-ordinates of the bottom right hand corner of the rectangle are +affected. + +@param aSize The new width is aSize.iWidth. The new height is aSize.iHeight. +*/ + { + iBr=iTl+aSize; + } + + + + +EXPORT_C void TRect::SetWidth(TInt aWidth) +/** +Sets the width of the rectangle. + +Only the position of the rectangle's right hand side is affected. + +@param aWidth The new width of the rectangle. +*/ + { + iBr.iX=iTl.iX+aWidth; + } + + + + +EXPORT_C void TRect::SetHeight(TInt aHeight) +/** +Sets the height of the rectangle. + +Only the position of the bottom of the rectangle is affected. + +@param aHeight The new height of the rectangle. +*/ + { + iBr.iY=iTl.iY+aHeight; + }