1 // Copyright (c) 1994-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32\euser\us_graph.cpp

    15 // 

    16 //

    17 

    18 #include "us_std.h"

    19 

    20 

    21 

    22 

    23 EXPORT_C TBool TPoint::operator==(const TPoint& aPoint) const

    24 /**

    25 Compares two points for equality.

    26 

    27 For two points to be equal, both their x and y co-ordinate values must be 

    28 equal.

    29 

    30 @param aPoint The point to be compared with this point.

    31 

    32 @return True, if the two points are equal; false, otherwise.

    33 */

    34 	{

    35 

    36 	return(iX==aPoint.iX && iY==aPoint.iY);

    37 	}

    38 

    39 

    40 

    41 

    42 EXPORT_C TBool TPoint::operator!=(const TPoint& aPoint) const

    43 /**

    44 Compares two points for inequality.

    45 

    46 For two points to be unequal, either their x or their y co-ordinate values 

    47 must be different.

    48 

    49 @param aPoint The point to be compared with this point.

    50 

    51 @return True, if the two points are unequal; false, otherwise.

    52 */

    53 	{

    54 

    55 	return(iX!=aPoint.iX || iY!=aPoint.iY);

    56 	}

    57 

    58 

    59 

    60 

    61 EXPORT_C TPoint& TPoint::operator-=(const TPoint& aPoint)

    62 /**

    63 TPoint subtraction assignment operator.

    64 

    65 The operator subtracts the specified point from this point, and assigns the 

    66 result back to this point.

    67 

    68 @param aPoint The point to be subtracted.

    69 

    70 @return A reference to this point object.

    71 */

    72 	{

    73 

    74 	iX-=aPoint.iX;

    75 	iY-=aPoint.iY;

    76 	return(*this);

    77 	}

    78 

    79 

    80 

    81 

    82 EXPORT_C TPoint& TPoint::operator-=(const TSize& aSize)

    83 /**

    84 TSize subtraction assignment operator.

    85 

    86 The operator subtracts the specified TSize from this point, and assigns the 

    87 result back to this point.

    88 

    89 The operation proceeds by:

    90 

    91 1. subtracting the width value of the TSize from the x co-ordinate value

    92 

    93 2. subtracting the height value of the TSize from the y co-ordinate value

    94 

    95 @param aSize The TSize to be subtracted.

    96 

    97 @return A reference to this point object.

    98 */

    99 	{

   100 

   101 	iX-=aSize.iWidth;

   102 	iY-=aSize.iHeight;

   103 	return(*this);

   104 	}

   105 

   106 

   107 

   108 

   109 EXPORT_C TPoint& TPoint::operator+=(const TPoint& aPoint)

   110 /**

   111 TPoint addition assignment operator. 

   112 

   113 The operator adds the specified point to this point, and assigns the result 

   114 back to this point.

   115 

   116 @param aPoint The point to be added.

   117 

   118 @return A reference to this point object.

   119 */

   120 	{

   121 

   122 	iX+=aPoint.iX;

   123 	iY+=aPoint.iY;

   124 	return(*this);

   125 	}

   126 

   127 

   128 

   129 

   130 EXPORT_C TPoint& TPoint::operator+=(const TSize& aSize)

   131 /**

   132 TSize addition assignment operator. 

   133 

   134 The operator adds the specified TSize to this point, and assigns the result 

   135 back to this point.

   136 

   137 The operation proceeds by:

   138 

   139 1. adding the width value of the TSize to the x co-ordinate value

   140 

   141 2. adding the height value of the TSize to the y co-ordinate value

   142 

   143 @param aSize The TSize to be added to this point. 

   144 

   145 @return A reference to this point object.

   146 */

   147 	{

   148 

   149 	iX+=aSize.iWidth;

   150 	iY+=aSize.iHeight;

   151 	return(*this);

   152 	}

   153 

   154 

   155 

   156 

   157 EXPORT_C TPoint TPoint::operator-(const TPoint& aPoint) const

   158 /**

   159 TPoint subtraction operator.

   160 

   161 The operator subtracts the specified point from this point, and returns the 

   162 resulting value.

   163 

   164 @param aPoint The point to be subtracted from this point. 

   165 

   166 @return The result of the operation.

   167 */

   168 	{

   169 

   170 	TPoint ret=* this;

   171 	ret-= aPoint;

   172 	return(ret);

   173 	}

   174 

   175 

   176 

   177 

   178 EXPORT_C TPoint TPoint::operator-(const TSize& aSize) const

   179 /**

   180 TSize subtraction operator. 

   181 

   182 The operator subtracts the specified TSize from this point, and returns the 

   183 resulting value.

   184 

   185 The operation proceeds by:

   186 

   187 1. subtracting the width value of the TSize from the x co-ordinate value

   188 

   189 2. subtracting the height value of the TSize from the y co-ordinate value.

   190 

   191 @param aSize The TSize to be subtracted.

   192 

   193 @return The result of the operation.

   194 */

   195 	{

   196 

   197 	TPoint ret=* this;

   198 	ret-= aSize;

   199 	return(ret);

   200 	}

   201 

   202 

   203 

   204 

   205 EXPORT_C TPoint TPoint::operator+(const TPoint& aPoint) const

   206 /**

   207 The operator adds the specified point to this point, and returns the resulting 

   208 value.

   209 

   210 @param aPoint The point to be added to this point.

   211 

   212 @return The result of the operation.

   213 */

   214 	{

   215 

   216 	TPoint ret=* this;

   217 	ret+= aPoint;

   218 	return(ret);

   219 	}

   220 

   221 

   222 

   223 

   224 EXPORT_C TPoint TPoint::operator+(const TSize& aSize) const

   225 /**

   226 TSize addition operator. 

   227 

   228 The operator adds the specified TSize to this point, and returns the resulting 

   229 value.

   230 

   231 The operation proceeds by:

   232 

   233 1. adding the width value of the TSize to the x co-ordinate value

   234 

   235 2. adding the height value of the TSize to the y co-ordinate value.

   236 

   237 @param aSize The TSize to be added to this TPoint. 

   238 

   239 @return The result of the operation.

   240 */

   241 	{

   242 

   243 	TPoint ret=* this;

   244 	ret+= aSize;

   245 	return(ret);

   246 	}

   247 

   248 

   249 

   250 

   251 EXPORT_C TPoint TPoint::operator-() const

   252 /**

   253 Unary minus operator.

   254 

   255 The operator returns the negation of this point.

   256 

   257 @return The result of the operation.

   258 */

   259 	{

   260 

   261 	return TPoint(-iX,-iY);

   262 	}

   263 

   264 

   265 

   266 

   267 EXPORT_C void TPoint::SetXY(TInt aX,TInt aY)

   268 /**

   269 Sets the x and y co-ordinates for this point.

   270 

   271 @param aX The value to assign to the x co-ordinate. 

   272 @param aY The value to assign to the y co-ordinate.

   273 */

   274 	{

   275 

   276 	iX=aX;

   277 	iY=aY;

   278 	}

   279 

   280 

   281 

   282 

   283 EXPORT_C TSize TPoint::AsSize() const

   284 /**

   285 Gets the size of the rectangle whose top left hand corner is the origin of 

   286 the screen co-ordinates and whose bottom right hand corner is this point.

   287 

   288 @return The co-ordinates of this point converted to a size.

   289 */

   290 	{

   291 	return(TSize(iX,iY));

   292 	}

   293 

   294 

   295 

   296 

   297 

   298 EXPORT_C TBool TPoint3D::operator==(const TPoint3D& aPoint3D) const

   299 /**

   300 Compares two 3D points(TPoint3D) for equality.

   301 

   302 For two TPoint3D to be equal, their x , y and zco-ordinate values must be 

   303 equal.

   304 

   305 @param aPoint3D The point to be compared with this point.

   306 

   307 @return True, if the two points are equal; false, otherwise.

   308 */

   309 	{

   310 	return(iX==aPoint3D.iX && iY==aPoint3D.iY && iZ==aPoint3D.iZ);

   311 	}

   312 

   313 

   314 

   315 

   316 EXPORT_C TBool TPoint3D::operator!=(const TPoint3D& aPoint3D) const

   317 /**

   318 Compares two 3D points for inequality.

   319 

   320 For two points to be unequal, their x  or y or z co-ordinate values 

   321 must be different.

   322 

   323 @param aPoint3D The point to be compared with this point.

   324 

   325 @return True, if the two points are unequal; false, otherwise.

   326 */

   327 	{

   328 	return(iX!=aPoint3D.iX || iY!=aPoint3D.iY || iZ!=aPoint3D.iZ);

   329 	}

   330 

   331 

   332 

   333 

   334 

   335 

   336 EXPORT_C TPoint3D& TPoint3D::operator-=(const TPoint3D& aPoint3D)

   337 /**

   338 TPoint3D subtraction assignment operator.

   339 

   340 The operator subtracts the specified point from this point, and assigns the 

   341 result back to this point.

   342 

   343 @param aPoint The point to be subtracted.

   344 

   345 @return A reference to this point object.

   346 */

   347 	{

   348 	iX-=aPoint3D.iX;

   349 	iY-=aPoint3D.iY;

   350 	iZ-=aPoint3D.iZ;

   351 	return(*this);

   352 	}

   353 

   354 

   355 

   356 EXPORT_C TPoint3D& TPoint3D::operator-=(const TPoint& aPoint)

   357 

   358 /**

   359 TPoint subtraction assignment operator.

   360 

   361 The operator subtracts the specified TPoint from this point(TPoint3D), and assigns the 

   362 result back to this point.

   363 

   364 The operation proceeds by

   365 subtracting x and y cordinates of the TPoin to this point and no changes  to the Z-coordinatete value

   366 

   367 @param aPoint The aPoint to be subtracted.

   368 

   369 @return A reference to this point object.

   370 */

   371 	{

   372 	iX-=aPoint.iX;

   373 	iY-=aPoint.iY;

   374 	//No Changes to the z co-ordinate

   375 	return(*this);

   376 	}

   377 

   378 

   379 

   380 EXPORT_C TPoint3D& TPoint3D::operator+=(const TPoint3D& aPoint3D)

   381 /**

   382 TPoint3D addition assignment operator. 

   383 

   384 The operator adds the specified point to this point, and assigns the result 

   385 back to this point.

   386 

   387 @param aPoint3D The point to be added.

   388 

   389 @return A reference to this point object.

   390 */

   391 	{

   392 	iX+=aPoint3D.iX;

   393 	iY+=aPoint3D.iY;

   394 	iZ+=aPoint3D.iZ;

   395 	return(*this);

   396 	}

   397 

   398 EXPORT_C TPoint3D& TPoint3D::operator+=(const TPoint& aPoint)

   399 /**

   400 TPoint addition assignment operator. 

   401 

   402 The operator adds the specified TPoint to this point, and assigns the result 

   403 back to this point.

   404 

   405 The operation proceeds by:

   406 adding  x and y cordinates of the TPoin to this point and no changes  to the Z-coordinatete value

   407 

   408 @param aPoint The TPoint to be added to this point. 

   409 

   410 @return A reference to this point object.

   411 */

   412 	{

   413 

   414 	iX+=aPoint.iX;

   415 	iY+=aPoint.iY;

   416 	//No Changes to the z co-ordinate

   417 	return(*this);

   418 	}

   419 EXPORT_C TPoint3D TPoint3D::operator-(const TPoint3D& aPoint3D) const

   420 /**

   421 TPoint3D subtraction operator.

   422 

   423 The operator subtracts the specified point from this point, and returns the 

   424 resulting value.

   425 

   426 @param aPoint3D The point to be subtracted from this point. 

   427 

   428 @return the point(TPoint3D) which is the  result of the operation.

   429 */

   430 	{

   431 

   432 	TPoint3D ret=* this;

   433 	ret-= aPoint3D;

   434 	return(ret);

   435 	}

   436 

   437 

   438 

   439 EXPORT_C TPoint3D TPoint3D::operator-(const TPoint& aPoint) const

   440 /**

   441 TPoint subtraction operator. 

   442 

   443 The operator subtracts the specified TPoint from this point, and returns the 

   444 resulting value.

   445 

   446 @param aPoint The TPoint to be subtracted.

   447 

   448 @return the point(TPoint3D) which is the  result of the operation.

   449 */

   450 	{

   451 

   452 	TPoint3D ret=* this;

   453 	ret-= aPoint;

   454 	return(ret);

   455 	}

   456 

   457 

   458 EXPORT_C TPoint3D TPoint3D::operator+(const TPoint3D& aPoint3D) const

   459 /**

   460 The operator adds the specified point to this point, and returns the resulting 

   461 value.

   462 

   463 @param aPoint3D The point to be added to this point.

   464 

   465 @return the point(TPoint3D) which is the  result of the operation.

   466 */

   467 	{

   468 

   469 	TPoint3D ret=* this;

   470 	ret+= aPoint3D;

   471 	return(ret);

   472 	}

   473 

   474 EXPORT_C TPoint3D TPoint3D::operator+(const TPoint& aPoint) const

   475 /**

   476 TPoint addition operator. 

   477 

   478 The operator adds the specified TPoint to this point, and returns the resulting 

   479 value.

   480 

   481 @param aSize The TSize to be added to this TPoint. 

   482 

   483 @return the point(TPoint3D) which is the  result of the operation.

   484 */

   485 	{

   486 

   487 	TPoint3D ret=* this;

   488 	ret+= aPoint;

   489 	return(ret);

   490 	}

   491 

   492 

   493 EXPORT_C TPoint3D TPoint3D::operator-() const

   494 /**

   495 Unary minus operator.

   496 

   497 The operator returns the negation of this point.

   498 

   499 @return the point(TPoint3D) which is the  result of Unary minus operation.

   500 */

   501 	{

   502 	return TPoint3D(-iX,-iY,-iZ);

   503 	}

   504 

   505 

   506 

   507 EXPORT_C void TPoint3D::SetXYZ(TInt aX,TInt aY,TInt aZ)

   508 /**

   509 Sets the x , y and z co-ordinates for this point.

   510 

   511 @param aX The value to assign to the x co-ordinate. 

   512 @param aY The value to assign to the y co-ordinate.

   513 @param aZ The value to assign to the z co-ordinate.

   514 */

   515 	{

   516 	iX=aX;

   517 	iY=aY;

   518 	iZ=aZ;

   519 	}

   520 

   521 EXPORT_C void TPoint3D::SetPoint(const TPoint& aPoint)

   522 /*

   523 TPoint3D from TPoint, sets the Z co-ordinate to  Zero

   524 @param aPoint The TPoint to add to this point 

   525 */

   526 	{

   527 	iX=aPoint.iX;

   528 	iY=aPoint.iY;

   529 	iZ=0;

   530 	}

   531 	

   532 

   533 EXPORT_C TPoint TPoint3D::AsPoint() const

   534 /**

   535 Gets Tpoint from Tpoint3D

   536 @return TPoint from X and Y cordinates of Tpoint3D

   537 */

   538 	{

   539 	return(TPoint(iX,iY));

   540 	}

   541 

   542 

   543 

   544 

   545 

   546 

   547 EXPORT_C TBool TSize::operator==(const TSize& aSize) const

   548 /**

   549 Compares this TSize with the specified TSize for equality. 

   550 

   551 For two TSizes to be equal, both their width and height values must be equal.

   552 

   553 @param aSize The TSize to be compared with this TSize.

   554 

   555 @return True, if the two TSize are equal; false, otherwise.

   556 */

   557 	{

   558 	return(iWidth==aSize.iWidth && iHeight==aSize.iHeight);

   559 	}

   560 

   561 

   562 

   563 

   564 EXPORT_C TBool TSize::operator!=(const TSize& aSize) const

   565 /**

   566 Compares two TSize for inequality.

   567 

   568 For two TSize to be unequal, either their width or height values must be different.

   569 

   570 @param aSize The TSize to be compared with this TSize. 

   571 

   572 @return True, if the two TSize are unequal; false, otherwise.

   573 */

   574 	{

   575 	return(iWidth!=aSize.iWidth || iHeight!=aSize.iHeight);

   576 	}

   577 

   578 

   579 

   580 

   581 EXPORT_C TSize& TSize::operator-=(const TSize& aSize)

   582 /**

   583 TSize subtraction assignment operator.

   584 

   585 The operator subtracts the specified TSize from this TSize, and assigns the 

   586 result back to this TSize.

   587 

   588 @param aSize The TSize to be subtracted. 

   589 

   590 @return A reference to this TSize object.

   591 */

   592 	{

   593 	iWidth-=aSize.iWidth;iHeight-=aSize.iHeight;return(*this);

   594 	}

   595 

   596 

   597 

   598 

   599 EXPORT_C TSize& TSize::operator-=(const TPoint& aPoint)

   600 /**

   601 TPoint subtraction assignment operator.

   602 

   603 The operator subtracts the specified point from this TSize, and assigns the 

   604 result back to this TSize.

   605 

   606 The operation proceeds by:

   607 

   608 1. subtracting the point's x co-ordinate value from the width

   609 

   610 2. subtracting the point's y co-ordinate value from the height.

   611 

   612 @param aPoint The point to be subtracted.

   613 

   614 @return A reference to this size object.

   615 */

   616 	{

   617 	iWidth-=aPoint.iX;iHeight-=aPoint.iY;return(*this);

   618 	}

   619 

   620 

   621 

   622 

   623 EXPORT_C TSize& TSize::operator+=(const TSize& aSize)

   624 /**

   625 TSize addition assignment operator.

   626 

   627 The operator adds the specified TSize to this TSize, and assigns the result 

   628 back to this TSize.

   629 

   630 @param aSize The TSize to be added.

   631 

   632 @return A reference to this size object.

   633 */

   634 	{

   635 	iWidth+=aSize.iWidth;iHeight+=aSize.iHeight;return(*this);

   636 	}

   637 

   638 

   639 

   640 

   641 EXPORT_C TSize& TSize::operator+=(const TPoint& aPoint)

   642 /**

   643 TPoint addition assignment operator.

   644 

   645 The operator adds the specified point to this TSize, and assigns the result 

   646 back to this TSize.

   647 

   648 The operation proceeds by:

   649 

   650 1. adding the point's x co-ordinate value to the width

   651 

   652 2. adding the point's y co-ordinate value to the height.

   653 

   654 @param aPoint The point to be added.

   655 

   656 @return A reference to this size object.

   657 */

   658 	{

   659 	iWidth+=aPoint.iX;iHeight+=aPoint.iY;return(*this);

   660 	}

   661 

   662 

   663 

   664 

   665 EXPORT_C TSize TSize::operator-(const TSize& aSize) const

   666 /**

   667 TSize subtraction operator.

   668 

   669 This operator subtracts the specified TSize from this TSize, and returns the 

   670 resulting value.

   671 

   672 @param aSize The TSize to be subtracted from this Tsize.

   673 

   674 @return The result of the operation.

   675 */

   676 	{

   677 	TSize ret=* this; ret-= aSize ;return(ret);

   678 	}

   679 

   680 

   681 

   682 

   683 EXPORT_C TSize TSize::operator-(const TPoint& aPoint) const

   684 /**

   685 TPoint subtraction operator.

   686 

   687 This operator subtracts the specified point from this TSize, and returns the 

   688 resulting value.

   689 

   690 The operation proceeds by:

   691 

   692 1. subtracting the x co-ordinate value from the width

   693 

   694 2. subtracting the y co-ordinate value from the height

   695 

   696 @param aPoint The point to be subtracted.

   697 

   698 @return The result of the operation.

   699 */

   700 	{

   701 	TSize ret=* this; ret-= aPoint ;return(ret);

   702 	}

   703 

   704 

   705 

   706 

   707 EXPORT_C TSize TSize::operator+(const TSize& aSize) const

   708 /**

   709 TSize addition operator.

   710 

   711 This operator adds the specified TSize to this TSize, and returns the resulting 

   712 value.

   713 

   714 @param aSize The TSize to be added to this Tsize. 

   715 

   716 @return The result of the operation.

   717 */

   718 	{

   719 	TSize ret=* this; ret+= aSize ;return(ret);

   720 	}

   721 

   722 

   723 

   724 

   725 EXPORT_C TSize TSize::operator+(const TPoint& aPoint) const

   726 /**

   727 TPoint addition operator.

   728 

   729 This operator adds the specified point to this TSize, and returns the resulting 

   730 value.

   731 

   732 The operation proceeds by:

   733 

   734 1. adding the x co-ordinate value to the width

   735 

   736 2. adding the y co-ordinate value to the height

   737 

   738 @param aPoint The point to be added to this TSize. 

   739 

   740 @return The result of the operation.

   741 */

   742 	{

   743 	TSize ret=* this; ret+= aPoint ;return(ret);

   744 	}

   745 

   746 

   747 

   748 

   749 EXPORT_C TSize TSize::operator-() const

   750 /**

   751 Unary minus operator.

   752 

   753 The operator returns the negation of this TSize.

   754 

   755 @return The result of the operation.

   756 */

   757 	{

   758 

   759 	return TSize(-iWidth,-iHeight);

   760 	}

   761 

   762 

   763 

   764 

   765 EXPORT_C void TSize::SetSize(TInt aWidth,TInt aHeight)

   766 /**

   767 Sets the width and height.

   768 

   769 @param aWidth The width value. 

   770 @param aHeight The height value.

   771 */

   772 	{

   773 	iWidth=aWidth;iHeight=aHeight;

   774 	}

   775 

   776 

   777 

   778 

   779 EXPORT_C TPoint TSize::AsPoint() const

   780 /**

   781 Gets a TPoint object whose co-ordinates are the width and height of this TSize.

   782 

   783 @return The co-ordinates of this TSize converted to a point.

   784 */

   785 	{

   786 	return(TPoint(iWidth,iHeight));

   787 	}

   788 

   789 

   790 

   791 

   792 EXPORT_C TRect::TRect()	: iTl(0,0),iBr(0,0)

   793 /**

   794 Constructs a default rectangle.

   795 

   796 This initialises the co-ordinates of its top 

   797 left and bottom right corners to (0,0).

   798 */

   799 	{}

   800 	

   801 	

   802 	

   803 	

   804 EXPORT_C TRect::TRect(TInt aAx,TInt aAy,TInt aBx,TInt aBy) : iTl(aAx,aAy),iBr(aBx,aBy)

   805 /**

   806 Constructs the rectangle, initialising its top left and bottom right hand corners 

   807 with four TInt values.

   808 

   809 @param aAx The horizontal co-ordinate of the left hand side of the rectangle. 

   810 @param aAy The vertical co-ordinate of the top of the rectangle. 

   811 @param aBx The horizontal co-ordinate of the right hand side of the rectangle. 

   812 @param aBy The vertical co-ordinate of the bottom of the rectangle.

   813 */

   814 	{}

   815 	

   816 	

   817 	

   818 	

   819 EXPORT_C TRect::TRect(const TPoint& aPointA,const TPoint& aPointB) : iTl(aPointA),iBr(aPointB)

   820 /**

   821 Constructs the rectangle with two TPoints, corresponding to its top left and 

   822 bottom right hand corners.

   823 

   824 @param aPointA The co-ordinates of the rectangle's top left hand corner. 

   825 @param aPointB The co-ordinates of the rectangle's bottom right hand corner.

   826 */

   827 	{}

   828 	

   829 	

   830 	

   831 	

   832 EXPORT_C TRect::TRect(const TPoint& aPoint,const TSize& aSize) : iTl(aPoint),iBr(aPoint+aSize)

   833 /**

   834 Constructs the rectangle with a TPoint for its top left corner, and a TSize 

   835 for its width and height.

   836 

   837 @param aPoint The rectangle's top left hand corner. 

   838 @param aSize  The rectangle's width and height.

   839 */

   840 	{}

   841 	

   842 	

   843 	

   844 	

   845 EXPORT_C TRect::TRect(const TSize& aSize) : iTl(0,0), iBr(aSize.iWidth, aSize.iHeight)

   846 /**

   847 Constructs the rectangle with a TSize.

   848 

   849 The co-ordinates of its top left hand corner are initialised to (0,0) and

   850 its width and height are initialised to the values contained in the argument.

   851 

   852 @param aSize The width and height of the rectangle.

   853 */

   854 	{}

   855 	

   856 	

   857 	

   858 

   859 EXPORT_C void TRect::SetRect(TInt aTlX,TInt aTlY,TInt aBrX,TInt aBrY)

   860 /**

   861 Sets the rectangle's position using four TInts.

   862 	

   863 @param aTlX The horizontal co-ordinate of the left hand side of the rectangle. 

   864 @param aTlY The vertical co-ordinate of the top of the rectangle. 

   865 @param aBrX The horizontal co-ordinate of the right hand side of the rectangle. 

   866 @param aBrY The vertical co-ordinate of the bottom of the rectangle.

   867 */

   868 	{

   869 	iTl.iX=aTlX;iTl.iY=aTlY;iBr.iX=aBrX;iBr.iY=aBrY;

   870 	}

   871 	

   872 	

   873 	

   874 

   875 EXPORT_C void TRect::SetRect(const TPoint& aPointTL,const TPoint& aPointBR)

   876 /**

   877 Sets the rectangle's position using two TPoints.

   878 

   879 @param aPointTL The co-ordinates of the rectangle's top left hand corner. 

   880 @param aPointBR The co-ordinates of the rectangle's bottom right hand corner.

   881 */

   882 	{

   883 	iTl=aPointTL;iBr=aPointBR;

   884 	}

   885 

   886 

   887 

   888 

   889 EXPORT_C void TRect::SetRect(const TPoint& aTL,const TSize& aSize)

   890 /**

   891 Sets the rectangle's position using a TPoint and a TSize.

   892 	

   893 @param aTL    The co-ordinates of the rectangle's top left hand corner. 

   894 @param aSize  The rectangle's width and height.

   895 */

   896 	{

   897 	iTl=aTL;iBr=aTL+aSize;

   898 	}

   899 

   900 

   901 

   902 

   903 EXPORT_C void TRect::Shrink(TInt aDx,TInt aDy)

   904 /**

   905 Shrinks a rectangle using specified horizontal and vertical offsets. 

   906 

   907 The offset values are added to the co-ordinates of its top left hand corner, 

   908 and the same values are subtracted from the co-ordinates of its bottom right 

   909 hand corner. The co-ordinates of the centre of the rectangle remain unchanged. 

   910 If either value is negative, the rectangle expands in the corresponding direction.

   911 

   912 @param aDx The number of pixels by which to move the left and right hand sides 

   913            of the rectangle. A positive value reduces the width, a negative

   914            value increases it. 

   915 @param aDy The number of pixels by which to move the top and bottom of the 

   916            rectangle. A positive value reduces the height, a negative value

   917            increases it.

   918 */

   919 	{

   920 	Adjust(aDx,aDy);

   921 	}

   922 

   923 

   924 

   925 

   926 EXPORT_C void TRect::Shrink(const TSize& aSize)

   927 /**

   928 Shrinks a rectangle using a specified TSize offset.

   929 

   930 The rectangle shrinks by twice the value of the height and width specified 

   931 in the TSize. The co-ordinates of the centre of the rectangle remain unchanged. 

   932 If either value is negative, the rectangle expands in the

   933 corresponding direction.

   934 

   935 @param aSize The number of pixels by which to move the left and right hand 

   936              sides of the rectangle (by aSize.iWidth) and the top and bottom

   937              (by aSize.iHeight).

   938 */

   939 	{

   940 	Adjust(aSize.iWidth,aSize.iHeight);

   941 	}

   942 

   943 

   944 

   945 

   946 EXPORT_C void TRect::Resize(const TSize& aSize)

   947 /**

   948 Resizes a rectangle by adding a TSize offset.

   949 

   950 The offset is added to the co-ordinates of its bottom right hand corner. If 

   951 either value in the TSize is negative, the rectangle shrinks in the

   952 corresponding direction. The co-ordinates of the rectangle's top left hand

   953 corner are unaffected.

   954 

   955 @param aSize The number of pixels by which to move the rectangle; the right 

   956              hand side by aSize.iWidth and the bottom by aSize.iHeight.

   957 */

   958 	{

   959 	iBr+=aSize;

   960 	}

   961 

   962 

   963 

   964 

   965 EXPORT_C void TRect::Resize(TInt aDx, TInt aDy)

   966 /**

   967 Resizes a rectangle by adding a horizontal and vertical offset.

   968 

   969 The offset is added to the co-ordinates of its bottom right hand corner. If 

   970 either value is negative, the rectangle shrinks in the corresponding direction.

   971 The co-ordinates of the rectangle's top left hand corner are unaffected.

   972 

   973 @param aDx The number of pixels by which to move the right hand side of the 

   974            rectangle. 

   975 @param aDy The number of pixels by which to move the bottom of the rectangle.

   976 */

   977 	{

   978 	iBr.iX+=aDx;iBr.iY+=aDy;

   979 	}

   980 

   981 

   982 

   983 

   984 EXPORT_C TBool TRect::operator==(const TRect &aRect) const

   985 /**

   986 Compares two rectangles for equality.

   987 

   988 For two rectangles to be equal, the co-ordinates of both their top left and 

   989 bottom right hand corners must be equal.

   990 

   991 @param aRect The rectangle to compare with this rectangle.

   992 

   993 @return True, if the rectangles have the same co-ordinates; false, otherwise.

   994 */

   995 	{

   996 

   997 	return(iTl==aRect.iTl && iBr==aRect.iBr);

   998 	}

   999 

  1000 

  1001 

  1002 

  1003 EXPORT_C TBool TRect::operator!=(const TRect &aRect) const

  1004 /**

  1005 Compares two rectangles for inequality.

  1006 

  1007 Two rectangles are unequal if any of their co-ordinates differ.

  1008 

  1009 @param aRect The rectangle to compare with this rectangle.

  1010 @return True, if the rectangles do not have the same co-ordinates; false, if 

  1011         all co-ordinates are equal.

  1012 */

  1013 	{

  1014 

  1015 	return(iTl!=aRect.iTl || iBr!=aRect.iBr);

  1016 	}

  1017 

  1018 

  1019 

  1020 

  1021 EXPORT_C void TRect::Move(const TPoint &aOffset)

  1022 /**

  1023 Moves the rectangle by adding a TPoint offset.

  1024 

  1025 The offset is added to the co-ordinates of both its top left and bottom right 

  1026 hand corners. The size of the rectangle is unchanged.

  1027 

  1028 @param aOffset The number of pixels to move the rectangle; horizontally by 

  1029                aOffset.iX and vertically by aOffset.iY.

  1030 */

  1031 	{

  1032 

  1033 	iTl+=aOffset;

  1034 	iBr+=aOffset;

  1035 	}

  1036 

  1037 

  1038 

  1039 

  1040 EXPORT_C void TRect::Move(TInt aDx,TInt aDy)

  1041 /**

  1042 Moves the rectangle by adding an x, y offset.

  1043 

  1044 The offset is added to the co-ordinates of both its top left and bottom right 

  1045 hand corners. The size of the rectangle is unchanged.

  1046 

  1047 @param aDx The number of pixels to move the rectangle horizontally. If negative, 

  1048            the rectangle moves leftwards. 

  1049 @param aDy The number of pixels to move the rectangle vertically. If negative, 

  1050            the rectangle moves upwards.

  1051 */

  1052 	{

  1053 

  1054 	iTl.iX+=aDx;

  1055 	iTl.iY+=aDy;

  1056 	iBr.iX+=aDx;

  1057 	iBr.iY+=aDy;

  1058 	}

  1059 

  1060 

  1061 

  1062 

  1063 // private function, hence not exported

  1064 void TRect::Adjust(TInt aDx,TInt aDy)

  1065 //

  1066 // Adjust by a delta.

  1067 //

  1068 	{

  1069 

  1070 	iTl.iX+=aDx;

  1071 	iTl.iY+=aDy;

  1072 	iBr.iX-=aDx;

  1073 	iBr.iY-=aDy;

  1074 	}

  1075 

  1076 

  1077 

  1078 

  1079 EXPORT_C void TRect::Grow(TInt aDx,TInt aDy)

  1080 //

  1081 // Grow by a delta.

  1082 //

  1083 /**

  1084 Grows the rectangle using the specified horizontal and vertical offsets.

  1085 

  1086 The offset values are subtracted from the co-ordinates of its top left hand 

  1087 corner, and the same values are added to the co-ordinates of its bottom right 

  1088 hand corner. The co-ordinates of the centre of the rectangle remain unchanged. 

  1089 If either value is negative, the rectangle shrinks in the corresponding direction.

  1090 

  1091 @param aDx The number of pixels by which to move the left and right hand sides 

  1092            of the rectangle. A positive value increases the width, a negative

  1093            value reduces it. 

  1094 @param aDy The number of pixels by which to move the top and bottom of the 

  1095            rectangle. A positive value increases the height, a negative

  1096            value reduces it.

  1097 */

  1098 	{

  1099 

  1100 	iTl.iX-=aDx;

  1101 	iTl.iY-=aDy;

  1102 	iBr.iX+=aDx;

  1103 	iBr.iY+=aDy;

  1104 	}

  1105 

  1106 

  1107 

  1108 

  1109 EXPORT_C void TRect::Grow(const TSize &aSize)

  1110 //

  1111 // Grow by a size.

  1112 //

  1113 /**

  1114 Grows a rectangle using the specified TSize offset.

  1115 

  1116 The rectangle grows by twice the value of the height and width specified in 

  1117 the TSize. The co-ordinates of the centre of the rectangle remain unchanged. 

  1118 If either value is negative, the rectangle shrinks in the

  1119 corresponding direction.

  1120 

  1121 @param aSize The number of pixels by which to move the left and right hand 

  1122              sides of the rectangle (by aSize.iWidth) and the top and bottom

  1123              (by aSize.iHeight).

  1124 */

  1125 	{

  1126 

  1127 	iTl-=aSize;

  1128 	iBr+=aSize;

  1129 	}

  1130 

  1131 

  1132 

  1133 

  1134 EXPORT_C void TRect::BoundingRect(const TRect &aRect)