src/pwclib/shapes.cxx

   1 /*
   2  * shapes.cxx
   3  *
   4  * Geometric shapes.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 1993-1998 Equivalence Pty. Ltd.
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23  *
  24  * Portions are Copyright (C) 1993 Free Software Foundation, Inc.
  25  * All Rights Reserved.
  26  *
  27  * Contributor(s): ______________________________________.
  28  *
  29  * $Log$
  30  * Revision 1.12  1999/08/17 03:46:41  robertj
  31  * Fixed usage of inlines in optimised version.
  32  *
  33  * Revision 1.11  1998/12/20 09:14:44  robertj
  34  * Added pragma implementation for GNU compiler.
  35  *
  36  * Revision 1.10  1998/11/30 04:52:17  robertj
  37  * New directory structure
  38  *
  39  * Revision 1.9  1998/09/23 06:29:55  robertj
  40  * Added open source copyright license.
  41  *
  42  * Revision 1.8  1997/04/27 05:50:24  robertj
  43  * DLL support.
  44  *
  45  * Revision 1.7  1996/08/08 10:08:50  robertj
  46  * Directory structure changes for common files.
  47  *
  48  * Revision 1.6  1996/01/28 02:52:08  robertj
  49  * Added assert into all Compare functions to assure comparison between compatible objects.
  50  *
  51  * Revision 1.5  1995/01/21 05:22:36  robertj
  52  * Documentation.
  53  *
  54  * Revision 1.4  1994/10/23  03:38:06  robertj
  55  * Changed PPixels to pointer to get polymorphism.
  56  *
  57  * Revision 1.3  1994/08/01  03:41:24  robertj
  58  * Use of PNEW instead of new for heap debugging. Need undef for Unix end.
  59  *
  60  * Revision 1.2  1994/07/27  05:58:07  robertj
  61  * Synchronisation.
  62  *
  63  * Revision 1.1  1994/04/20  12:17:44  robertj
  64  * Initial revision
  65  *
  66  */
  67
  68 #ifdef __GNUC__
  69 #pragma implementation "shapes.h"
  70 #endif
  71
  72 #include <pwlib.h>
  73 #include <pwclib/shapes.h>
  74
  75 #if !P_USE_INLINES
  76 #include <pwclib/shapes.inl>
  77 #endif
  78
  79 #define new PNEW
  80
  81
  82 //////////////////////////////////////////////////////////////////////////////
  83 // PShape
  84
  85 void PShape::_SetPosition(const PPoint & pt)
  86 {
  87   position = pt;
  88 }
  89
  90
  91 void PShape::_SetDimensions(const PDim &)
  92 {
  93   // Do nothing
  94 }
  95
  96
  97 BOOL PShape::InShape(const PPoint & pt) const
  98 {
  99   return GetBounds().ContainsPoint(pt);
 100 }
 101
 102
 103 BOOL PShape::IsComposite() const
 104 {
 105   return FALSE;
 106 }
 107
 108
 109 //////////////////////////////////////////////////////////////////////////////
 110 // PLine
 111
 112 PObject::Comparison PLine::Compare(const PObject & obj) const
 113 {
 114   PAssert(obj.IsDescendant(PLine::Class()), PInvalidCast);
 115   const PLine & other = (const PLine &)obj;
 116   return position != other.position || otherEnd != other.otherEnd
 117                                                       ? GreaterThan : EqualTo;
 118 }
 119
 120
 121 PDim PLine::GetDimensions() const
 122 {
 123   PPoint d = position - otherEnd;
 124   return PDim(PABS(d.X()), PABS(d.Y()));
 125 }
 126
 127
 128 BOOL PLine::InShape(const PPoint &) const
 129 {
 130   return FALSE;
 131 }
 132
 133
 134 void PLine::Draw(PCanvas & canvas) const
 135 {
 136   canvas = *this;
 137   canvas.DrawLine(position, otherEnd);
 138 }
 139
 140
 141 //////////////////////////////////////////////////////////////////////////////
 142 // POrthoShape
 143
 144 POrthoShape::POrthoShape(const PPoint & topLeft, const PPoint & botRight)
 145   : PShape(PMIN(topLeft.X(), botRight.X()), PMIN(topLeft.Y(), botRight.Y())),
 146     dimensions(PABS(topLeft.X()-botRight.X()), PABS(topLeft.Y()-botRight.Y()))
 147 {
 148 }
 149
 150
 151 PObject::Comparison POrthoShape::Compare(const PObject & obj) const
 152 {
 153   PAssert(obj.IsDescendant(POrthoShape::Class()), PInvalidCast);
 154   const POrthoShape & other = (const POrthoShape &)obj;
 155   if (dimensions != other.dimensions)
 156     return GreaterThan;
 157   return position != other.position ? LessThan : EqualTo;
 158 }
 159
 160
 161 PDim POrthoShape::GetDimensions() const
 162 {
 163   return dimensions;
 164 }
 165
 166
 167 void POrthoShape::_SetDimensions(const PDim & dim)
 168 {
 169   dimensions = dim;
 170 }
 171
 172
 173 //////////////////////////////////////////////////////////////////////////////
 174 // PRectangle
 175
 176 void PRectangle::Draw(PCanvas & canvas) const
 177 {
 178   canvas = *this;
 179   canvas.DrawRect(position, dimensions);
 180 }
 181
 182
 183 //////////////////////////////////////////////////////////////////////////////
 184 // PRoundedRectangle
 185
 186 PObject::Comparison PRoundedRectangle::Compare(const PObject & obj) const
 187 {
 188   PAssert(obj.IsDescendant(PRoundedRectangle::Class()), PInvalidCast);
 189   const PRoundedRectangle & other = (const PRoundedRectangle &)obj;
 190   return position != other.position || dimensions != other.dimensions ||
 191                                corner != other.corner ? GreaterThan : EqualTo;
 192 }
 193
 194
 195 void PRoundedRectangle::Draw(PCanvas & canvas) const
 196 {
 197   canvas = *this;
 198   canvas.DrawRoundRect(PRect(position, dimensions),
 199                                             corner.Width(), corner.Height());
 200 }
 201
 202
 203 //////////////////////////////////////////////////////////////////////////////
 204 // PEllipse
 205
 206 void PEllipse::Draw(PCanvas & canvas) const
 207 {
 208   canvas = *this;
 209   canvas.DrawEllipse(PRect(position, dimensions));
 210 }
 211
 212
 213 //////////////////////////////////////////////////////////////////////////////
 214 // PArc
 215
 216 PObject::Comparison PArc::Compare(const PObject & obj) const
 217 {
 218   PAssert(obj.IsDescendant(PArc::Class()), PInvalidCast);
 219   const PArc & other = (const PArc &)obj;
 220   return position != other.position || dimensions != other.dimensions ||
 221          startAngle != other.startAngle || endAngle != other.endAngle
 222                                                       ? GreaterThan : EqualTo;
 223 }
 224
 225
 226 void PArc::Draw(PCanvas & canvas) const
 227 {
 228   canvas = *this;
 229   canvas.DrawArc(PRect(position, dimensions), startAngle, endAngle);
 230 }
 231
 232
 233 //////////////////////////////////////////////////////////////////////////////
 234 // PPie
 235
 236 void PPie::Draw(PCanvas & canvas) const
 237 {
 238   canvas = *this;
 239   canvas.DrawPie(PRect(position, dimensions), startAngle, endAngle);
 240 }
 241
 242
 243 //////////////////////////////////////////////////////////////////////////////
 244 // PChord
 245
 246 void PChord::Draw(PCanvas & canvas) const
 247 {
 248   canvas = *this;
 249   canvas.DrawChord(PRect(position, dimensions), startAngle, endAngle);
 250 }
 251
 252
 253 //////////////////////////////////////////////////////////////////////////////
 254 // PPixShape
 255
 256 PPixShape::PPixShape(PORDINATE x, PORDINATE y, const PPixelImage & pix)
 257   : POrthoShape(x, y, pix->Width(), pix->Height())
 258 {
 259   pixels = pix;
 260 }
 261
 262
 263 PPixShape::PPixShape(const PPoint & pt, const PPixelImage & pix)
 264   : POrthoShape(pt, pix->GetDimensions())
 265 {
 266   pixels = pix;
 267 }
 268
 269
 270 void PPixShape::Draw(PCanvas & canvas) const
 271 {
 272   canvas = *this;
 273   canvas.DrawPixels(PRect(position, dimensions), pixels);
 274 }
 275
 276
 277 //////////////////////////////////////////////////////////////////////////////
 278 // PPicShape
 279
 280 PPicShape::PPicShape(PORDINATE x, PORDINATE y, const PPictImage & pic)
 281   : POrthoShape(x, y, pic->Width(), pic->Height())
 282 {
 283   picture = pic;
 284 }
 285
 286
 287 PPicShape::PPicShape(const PPoint & pt, const PPictImage & pic)
 288   : POrthoShape(pt, pic->GetDimensions())
 289 {
 290   picture = pic;
 291 }
 292
 293
 294 void PPicShape::Draw(PCanvas & canvas) const
 295 {
 296   canvas = *this;
 297   canvas.DrawPict(PRect(position, dimensions), picture);
 298 }
 299
 300
 301 //////////////////////////////////////////////////////////////////////////////
 302 // PTextLines
 303
 304 PObject::Comparison PTextLines::Compare(const PObject & obj) const
 305 {
 306   PAssert(obj.IsDescendant(PTextLines::Class()), PInvalidCast);
 307   const PTextLines & other = (const PTextLines &)obj;
 308   return position != other.position || text != other.text
 309                                                       ? GreaterThan : EqualTo;
 310 }
 311
 312
 313 PDim PTextLines::GetDimensions() const
 314 {
 315   PAssert(dimensions.Width() != 0 && dimensions.Height() != 0, PInvalidParameter);
 316   return dimensions;
 317 }
 318
 319
 320 void PTextLines::Draw(PCanvas & canvas) const
 321 {
 322   canvas = *this;
 323   ((PTextLines*)this)->dimensions = canvas.MeasureString(text);
 324   canvas.DrawString(position, text);
 325 }
 326
 327
 328 void PTextLines::SetText(const PString & str)
 329 {
 330   text = str;
 331   dimensions.SetHeight(0); // Needs to be recalculated
 332 }
 333
 334
 335 PDim PTextLines::GetDimensions(PCanvas & canvas)
 336 {
 337   canvas = *this;
 338   dimensions = canvas.MeasureString(text);
 339   return GetDimensions();
 340 }
 341
 342
 343 //////////////////////////////////////////////////////////////////////////////
 344 // PTextBlock
 345
 346 PObject::Comparison PTextBlock::Compare(const PObject & obj) const
 347 {
 348   PAssert(obj.IsDescendant(PTextBlock::Class()), PInvalidCast);
 349   const PTextBlock & other = (const PTextBlock &)obj;
 350   return position != other.position || text != other.text ||
 351        dimensions.Width() != other.dimensions.Width() ? GreaterThan : EqualTo;
 352 }
 353
 354
 355 void PTextBlock::_SetDimensions(const PDim & dim)
 356 {
 357   PAssert(dim.Width() > 0, PInvalidParameter);
 358   if (dim.Width() != dimensions.Width()) {
 359     dimensions.SetWidth(dim.Width());
 360     dimensions.SetHeight(0);
 361   }
 362 }
 363
 364
 365 void PTextBlock::Draw(PCanvas & canvas) const
 366 {
 367   canvas = *this;
 368   ((PTextBlock*)this)->dimensions.SetHeight(
 369                               canvas.MeasureString(text, dimensions.Width()));
 370   canvas.DrawString(position, text, dimensions.Width());
 371 }
 372
 373
 374 PDim PTextBlock::GetDimensions(PCanvas & canvas)
 375 {
 376   canvas = *this;
 377   dimensions.SetHeight(canvas.MeasureString(text, dimensions.Width()));
 378   return dimensions;
 379 }
 380
 381
 382 //////////////////////////////////////////////////////////////////////////////
 383 // PPolyShape
 384
 385 PPolyShape::PPolyShape(const PPoint * ptArray, PINDEX numPts)
 386   : PShape(*ptArray)
 387 {
 388   for (PINDEX i = 0; i < numPts; i++)
 389     points.Append(new PPoint(ptArray[i]));
 390 }
 391
 392
 393 void PPolyShape::_SetPosition(const PPoint & pt)
 394 {
 395   PPoint diff = pt - position;
 396   for (PINDEX i = 0; i < points.GetSize(); i++)
 397     points[i] += diff;
 398 }
 399
 400
 401 PDim PPolyShape::GetDimensions() const
 402 {
 403   PPoint min, max;
 404   for (PINDEX i = 0; i < points.GetSize(); i++) {
 405     if (min.X() > points[i].X())
 406       min.SetX(points[i].X());
 407     if (max.X() < points[i].X())
 408       max.SetX(points[i].X());
 409     if (min.Y() > points[i].Y())
 410       min.SetY(points[i].Y());
 411     if (max.Y() < points[i].Y())
 412       max.SetY(points[i].Y());
 413   }
 414   max -= min;
 415   return PDim(max.X(), max.Y());
 416 }
 417
 418
 419 //////////////////////////////////////////////////////////////////////////////
 420 // PPolyLine
 421
 422 void PPolyLine::Draw(PCanvas & canvas) const
 423 {
 424   canvas = *this;
 425   canvas.DrawPolyLine(points);
 426 }
 427
 428
 429 //////////////////////////////////////////////////////////////////////////////
 430 // PPolygon
 431
 432 void PPolygon::Draw(PCanvas & canvas) const
 433 {
 434   canvas = *this;
 435   canvas.DrawPolygon(points);
 436 }
 437
 438 //////////////////////////////////////////////////////////////////////////////
 439 // PCurve
 440
 441
 442 //////////////////////////////////////////////////////////////////////////////
 443 // PBezier
 444
 445 void PBezier::Draw(PCanvas & canvas) const
 446 {
 447   canvas = *this;
 448 }
 449
 450
 451 //////////////////////////////////////////////////////////////////////////////
 452 // PBSpline
 453
 454 void PBSpline::Draw(PCanvas & canvas) const
 455 {
 456   canvas = *this;
 457 }
 458
 459
 460 //////////////////////////////////////////////////////////////////////////////
 461 // PCompositeShape
 462
 463 PCompositeShape::PCompositeShape(PShape & shape)
 464   : PShape(shape.GetPosition()), dimensions(shape.GetDimensions())
 465 {
 466   shapes.DisallowDeleteObjects();
 467   shapes.Append(&shape);
 468 }
 469
 470
 471 void PCompositeShape::_SetPosition(const PPoint & pt)
 472 {
 473   PPoint delta = position - pt;
 474   for (PINDEX i = 0; i < shapes.GetSize(); i++)
 475     shapes[i].Offset(delta);
 476   position = pt;
 477 }
 478
 479
 480 void PCompositeShape::Draw(PCanvas & canvas) const
 481 {
 482   for (PINDEX i = 0; i < shapes.GetSize(); i++)
 483     shapes[i].Draw(canvas);
 484 }
 485
 486
 487 void PCompositeShape::Add(PShape & shape)
 488 {
 489   shapes.Append(&shape);
 490   CalculateBounds();
 491 }
 492
 493
 494 void PCompositeShape::Remove(PShape & shape)
 495 {
 496   shapes.Remove(&shape);
 497   PAssert(shapes.GetSize() != 0, PInvalidParameter);
 498   CalculateBounds();
 499 }
 500
 501
 502 void PCompositeShape::Remove(PINDEX idx)
 503 {
 504   shapes.RemoveAt(idx);
 505   PAssert(shapes.GetSize() != 0, PInvalidParameter);
 506   CalculateBounds();
 507 }
 508
 509
 510 PShape * PCompositeShape::Find(const PPoint & pt)
 511 {
 512   for (PINDEX i = 0; i < shapes.GetSize(); i++) {
 513     if (shapes[i].InShape(pt))
 514       return &shapes[i];
 515   }
 516
 517   return NULL;
 518 }
 519
 520
 521 PShape * PCompositeShape::FindPrimitive(const PPoint & pt)
 522 {
 523   for (PINDEX i = 0; i < shapes.GetSize(); i++) {
 524     if (shapes[i].InShape(pt)) {
 525       if (shapes[i].IsComposite())
 526         return ((PCompositeShape&)shapes[i]).FindPrimitive(pt);
 527       else
 528         return &shapes[i];
 529     }
 530   }
 531
 532   return NULL;
 533 }
 534
 535
 536 void PCompositeShape::CalculateBounds()
 537 {
 538   position = shapes[0].GetPosition();
 539   PPoint otherCorner = position + shapes[0].GetDimensions();
 540   for (PINDEX i = 1; i < shapes.GetSize(); i++) {
 541     PPoint p = shapes[i].GetPosition();
 542     if (position.X() > p.X())
 543       position.SetX(p.X());
 544     if (position.Y() > p.Y())
 545       position.SetY(p.Y());
 546
 547     p += shapes[i].GetDimensions();
 548     if (otherCorner.X() > p.X())
 549       otherCorner.SetX(p.X());
 550     if (otherCorner.Y() > p.Y())
 551       otherCorner.SetY(p.Y());
 552   }
 553   otherCorner -= position;
 554   PAssert(otherCorner.X() > 0 && otherCorner.Y() > 0, PInvalidParameter);
 555   dimensions = PDim(otherCorner.X(), otherCorner.Y());
 556 }
 557
 558
 559 #undef new
 560
 561
 562 // End Of File ///////////////////////////////////////////////////////////////