juce/source/src/gui/graphics/geometry/juce_RectangleList.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_RectangleList.h"
  31
  32
  33 //==============================================================================
  34 RectangleList::RectangleList() noexcept
  35 {
  36 }
  37
  38 RectangleList::RectangleList (const Rectangle<int>& rect)
  39 {
  40     if (! rect.isEmpty())
  41         rects.add (rect);
  42 }
  43
  44 RectangleList::RectangleList (const RectangleList& other)
  45     : rects (other.rects)
  46 {
  47 }
  48
  49 RectangleList& RectangleList::operator= (const RectangleList& other)
  50 {
  51     rects = other.rects;
  52     return *this;
  53 }
  54
  55 RectangleList::~RectangleList()
  56 {
  57 }
  58
  59 //==============================================================================
  60 void RectangleList::clear()
  61 {
  62     rects.clearQuick();
  63 }
  64
  65 Rectangle<int> RectangleList::getRectangle (const int index) const noexcept
  66 {
  67     if (isPositiveAndBelow (index, rects.size()))
  68         return rects.getReference (index);
  69
  70     return Rectangle<int>();
  71 }
  72
  73 bool RectangleList::isEmpty() const noexcept
  74 {
  75     return rects.size() == 0;
  76 }
  77
  78 //==============================================================================
  79 RectangleList::Iterator::Iterator (const RectangleList& list) noexcept
  80     : current (nullptr),
  81       owner (list),
  82       index (list.rects.size())
  83 {
  84 }
  85
  86 RectangleList::Iterator::~Iterator()
  87 {
  88 }
  89
  90 bool RectangleList::Iterator::next() noexcept
  91 {
  92     if (--index >= 0)
  93     {
  94         current = & (owner.rects.getReference (index));
  95         return true;
  96     }
  97
  98     return false;
  99 }
 100
 101
 102 //==============================================================================
 103 void RectangleList::add (const Rectangle<int>& rect)
 104 {
 105     if (! rect.isEmpty())
 106     {
 107         if (rects.size() == 0)
 108         {
 109             rects.add (rect);
 110         }
 111         else
 112         {
 113             bool anyOverlaps = false;
 114
 115             int i;
 116             for (i = rects.size(); --i >= 0;)
 117             {
 118                 Rectangle<int>& ourRect = rects.getReference (i);
 119
 120                 if (rect.intersects (ourRect))
 121                 {
 122                     if (rect.contains (ourRect))
 123                         rects.remove (i);
 124                     else if (! ourRect.reduceIfPartlyContainedIn (rect))
 125                         anyOverlaps = true;
 126                 }
 127             }
 128
 129             if (anyOverlaps && rects.size() > 0)
 130             {
 131                 RectangleList r (rect);
 132
 133                 for (i = rects.size(); --i >= 0;)
 134                 {
 135                     const Rectangle<int>& ourRect = rects.getReference (i);
 136
 137                     if (rect.intersects (ourRect))
 138                     {
 139                         r.subtract (ourRect);
 140
 141                         if (r.rects.size() == 0)
 142                             return;
 143                     }
 144                 }
 145
 146                 for (i = r.getNumRectangles(); --i >= 0;)
 147                     rects.add (r.rects.getReference (i));
 148             }
 149             else
 150             {
 151                 rects.add (rect);
 152             }
 153         }
 154     }
 155 }
 156
 157 void RectangleList::addWithoutMerging (const Rectangle<int>& rect)
 158 {
 159     if (! rect.isEmpty())
 160         rects.add (rect);
 161 }
 162
 163 void RectangleList::add (const int x, const int y, const int w, const int h)
 164 {
 165     if (rects.size() == 0)
 166     {
 167         if (w > 0 && h > 0)
 168             rects.add (Rectangle<int> (x, y, w, h));
 169     }
 170     else
 171     {
 172         add (Rectangle<int> (x, y, w, h));
 173     }
 174 }
 175
 176 void RectangleList::add (const RectangleList& other)
 177 {
 178     for (int i = 0; i < other.rects.size(); ++i)
 179         add (other.rects.getReference (i));
 180 }
 181
 182 void RectangleList::subtract (const Rectangle<int>& rect)
 183 {
 184     const int originalNumRects = rects.size();
 185
 186     if (originalNumRects > 0)
 187     {
 188         const int x1 = rect.x;
 189         const int y1 = rect.y;
 190         const int x2 = x1 + rect.w;
 191         const int y2 = y1 + rect.h;
 192
 193         for (int i = getNumRectangles(); --i >= 0;)
 194         {
 195             Rectangle<int>& r = rects.getReference (i);
 196
 197             const int rx1 = r.x;
 198             const int ry1 = r.y;
 199             const int rx2 = rx1 + r.w;
 200             const int ry2 = ry1 + r.h;
 201
 202             if (! (x2 <= rx1 || x1 >= rx2 || y2 <= ry1 || y1 >= ry2))
 203             {
 204                 if (x1 > rx1 && x1 < rx2)
 205                 {
 206                     if (y1 <= ry1 && y2 >= ry2 && x2 >= rx2)
 207                     {
 208                         r.w = x1 - rx1;
 209                     }
 210                     else
 211                     {
 212                         r.x = x1;
 213                         r.w = rx2 - x1;
 214
 215                         rects.insert (i + 1, Rectangle<int> (rx1, ry1, x1 - rx1,  ry2 - ry1));
 216                         i += 2;
 217                     }
 218                 }
 219                 else if (x2 > rx1 && x2 < rx2)
 220                 {
 221                     r.x = x2;
 222                     r.w = rx2 - x2;
 223
 224                     if (y1 > ry1 || y2 < ry2 || x1 > rx1)
 225                     {
 226                         rects.insert (i + 1, Rectangle<int> (rx1, ry1, x2 - rx1,  ry2 - ry1));
 227                         i += 2;
 228                     }
 229                 }
 230                 else if (y1 > ry1 && y1 < ry2)
 231                 {
 232                     if (x1 <= rx1 && x2 >= rx2 && y2 >= ry2)
 233                     {
 234                         r.h = y1 - ry1;
 235                     }
 236                     else
 237                     {
 238                         r.y = y1;
 239                         r.h = ry2 - y1;
 240
 241                         rects.insert (i + 1, Rectangle<int> (rx1, ry1, rx2 - rx1, y1 - ry1));
 242                         i += 2;
 243                     }
 244                 }
 245                 else if (y2 > ry1 && y2 < ry2)
 246                 {
 247                     r.y = y2;
 248                     r.h = ry2 - y2;
 249
 250                     if (x1 > rx1 || x2 < rx2 || y1 > ry1)
 251                     {
 252                         rects.insert (i + 1, Rectangle<int> (rx1, ry1, rx2 - rx1, y2 - ry1));
 253                         i += 2;
 254                     }
 255                 }
 256                 else
 257                 {
 258                     rects.remove (i);
 259                 }
 260             }
 261         }
 262     }
 263 }
 264
 265 bool RectangleList::subtract (const RectangleList& otherList)
 266 {
 267     for (int i = otherList.rects.size(); --i >= 0 && rects.size() > 0;)
 268         subtract (otherList.rects.getReference (i));
 269
 270     return rects.size() > 0;
 271 }
 272
 273 bool RectangleList::clipTo (const Rectangle<int>& rect)
 274 {
 275     bool notEmpty = false;
 276
 277     if (rect.isEmpty())
 278     {
 279         clear();
 280     }
 281     else
 282     {
 283         for (int i = rects.size(); --i >= 0;)
 284         {
 285             Rectangle<int>& r = rects.getReference (i);
 286
 287             if (! rect.intersectRectangle (r.x, r.y, r.w, r.h))
 288                 rects.remove (i);
 289             else
 290                 notEmpty = true;
 291         }
 292     }
 293
 294     return notEmpty;
 295 }
 296
 297 bool RectangleList::clipTo (const RectangleList& other)
 298 {
 299     if (rects.size() == 0)
 300         return false;
 301
 302     RectangleList result;
 303
 304     for (int j = 0; j < rects.size(); ++j)
 305     {
 306         const Rectangle<int>& rect = rects.getReference (j);
 307
 308         for (int i = other.rects.size(); --i >= 0;)
 309         {
 310             Rectangle<int> r (other.rects.getReference (i));
 311
 312             if (rect.intersectRectangle (r.x, r.y, r.w, r.h))
 313                 result.rects.add (r);
 314         }
 315     }
 316
 317     swapWith (result);
 318
 319     return ! isEmpty();
 320 }
 321
 322 bool RectangleList::getIntersectionWith (const Rectangle<int>& rect, RectangleList& destRegion) const
 323 {
 324     destRegion.clear();
 325
 326     if (! rect.isEmpty())
 327     {
 328         for (int i = rects.size(); --i >= 0;)
 329         {
 330             Rectangle<int> r (rects.getReference (i));
 331
 332             if (rect.intersectRectangle (r.x, r.y, r.w, r.h))
 333                 destRegion.rects.add (r);
 334         }
 335     }
 336
 337     return destRegion.rects.size() > 0;
 338 }
 339
 340 void RectangleList::swapWith (RectangleList& otherList) noexcept
 341 {
 342     rects.swapWithArray (otherList.rects);
 343 }
 344
 345
 346 //==============================================================================
 347 void RectangleList::consolidate()
 348 {
 349     int i;
 350     for (i = 0; i < getNumRectangles() - 1; ++i)
 351     {
 352         Rectangle<int>& r = rects.getReference (i);
 353         const int rx1 = r.x;
 354         const int ry1 = r.y;
 355         const int rx2 = rx1 + r.w;
 356         const int ry2 = ry1 + r.h;
 357
 358         for (int j = rects.size(); --j > i;)
 359         {
 360             Rectangle<int>& r2 = rects.getReference (j);
 361             const int jrx1 = r2.x;
 362             const int jry1 = r2.y;
 363             const int jrx2 = jrx1 + r2.w;
 364             const int jry2 = jry1 + r2.h;
 365
 366             // if the vertical edges of any blocks are touching and their horizontals don't
 367             // line up, split them horizontally..
 368             if (jrx1 == rx2 || jrx2 == rx1)
 369             {
 370                 if (jry1 > ry1 && jry1 < ry2)
 371                 {
 372                     r.h = jry1 - ry1;
 373                     rects.add (Rectangle<int> (rx1, jry1, rx2 - rx1, ry2 - jry1));
 374                     i = -1;
 375                     break;
 376                 }
 377
 378                 if (jry2 > ry1 && jry2 < ry2)
 379                 {
 380                     r.h = jry2 - ry1;
 381                     rects.add (Rectangle<int> (rx1, jry2, rx2 - rx1, ry2 - jry2));
 382                     i = -1;
 383                     break;
 384                 }
 385                 else if (ry1 > jry1 && ry1 < jry2)
 386                 {
 387                     r2.h = ry1 - jry1;
 388                     rects.add (Rectangle<int> (jrx1, ry1, jrx2 - jrx1, jry2 - ry1));
 389                     i = -1;
 390                     break;
 391                 }
 392                 else if (ry2 > jry1 && ry2 < jry2)
 393                 {
 394                     r2.h = ry2 - jry1;
 395                     rects.add (Rectangle<int> (jrx1, ry2, jrx2 - jrx1, jry2 - ry2));
 396                     i = -1;
 397                     break;
 398                 }
 399             }
 400         }
 401     }
 402
 403     for (i = 0; i < rects.size() - 1; ++i)
 404     {
 405         Rectangle<int>& r = rects.getReference (i);
 406
 407         for (int j = rects.size(); --j > i;)
 408         {
 409             if (r.enlargeIfAdjacent (rects.getReference (j)))
 410             {
 411                 rects.remove (j);
 412                 i = -1;
 413                 break;
 414             }
 415         }
 416     }
 417 }
 418
 419 //==============================================================================
 420 bool RectangleList::containsPoint (const int x, const int y) const noexcept
 421 {
 422     for (int i = getNumRectangles(); --i >= 0;)
 423         if (rects.getReference (i).contains (x, y))
 424             return true;
 425
 426     return false;
 427 }
 428
 429 bool RectangleList::containsRectangle (const Rectangle<int>& rectangleToCheck) const
 430 {
 431     if (rects.size() > 1)
 432     {
 433         RectangleList r (rectangleToCheck);
 434
 435         for (int i = rects.size(); --i >= 0;)
 436         {
 437             r.subtract (rects.getReference (i));
 438
 439             if (r.rects.size() == 0)
 440                 return true;
 441         }
 442     }
 443     else if (rects.size() > 0)
 444     {
 445         return rects.getReference (0).contains (rectangleToCheck);
 446     }
 447
 448     return false;
 449 }
 450
 451 bool RectangleList::intersectsRectangle (const Rectangle<int>& rectangleToCheck) const noexcept
 452 {
 453     for (int i = rects.size(); --i >= 0;)
 454         if (rects.getReference (i).intersects (rectangleToCheck))
 455             return true;
 456
 457     return false;
 458 }
 459
 460 bool RectangleList::intersects (const RectangleList& other) const noexcept
 461 {
 462     for (int i = rects.size(); --i >= 0;)
 463         if (other.intersectsRectangle (rects.getReference (i)))
 464             return true;
 465
 466     return false;
 467 }
 468
 469 Rectangle<int> RectangleList::getBounds() const noexcept
 470 {
 471     if (rects.size() <= 1)
 472     {
 473         if (rects.size() == 0)
 474             return Rectangle<int>();
 475         else
 476             return rects.getReference (0);
 477     }
 478     else
 479     {
 480         const Rectangle<int>& r = rects.getReference (0);
 481
 482         int minX = r.x;
 483         int minY = r.y;
 484         int maxX = minX + r.w;
 485         int maxY = minY + r.h;
 486
 487         for (int i = rects.size(); --i > 0;)
 488         {
 489             const Rectangle<int>& r2 = rects.getReference (i);
 490
 491             minX = jmin (minX, r2.x);
 492             minY = jmin (minY, r2.y);
 493             maxX = jmax (maxX, r2.getRight());
 494             maxY = jmax (maxY, r2.getBottom());
 495         }
 496
 497         return Rectangle<int> (minX, minY, maxX - minX, maxY - minY);
 498     }
 499 }
 500
 501 void RectangleList::offsetAll (const int dx, const int dy) noexcept
 502 {
 503     for (int i = rects.size(); --i >= 0;)
 504     {
 505         Rectangle<int>& r = rects.getReference (i);
 506
 507         r.x += dx;
 508         r.y += dy;
 509     }
 510 }
 511
 512 //==============================================================================
 513 Path RectangleList::toPath() const
 514 {
 515     Path p;
 516
 517     for (int i = rects.size(); --i >= 0;)
 518     {
 519         const Rectangle<int>& r = rects.getReference (i);
 520
 521         p.addRectangle ((float) r.x,
 522                         (float) r.y,
 523                         (float) r.w,
 524                         (float) r.h);
 525     }
 526
 527     return p;
 528 }
 529
 530
 531 END_JUCE_NAMESPACE