LMMS
Loading...
Searching...
No Matches
juce::RectangleList< ValueType > Class Template Referencefinal

#include <juce_RectangleList.h>

Public Types

using RectangleType = Rectangle<ValueType>

Public Member Functions

 RectangleList ()=default
 RectangleList (const RectangleList &other)
 RectangleList (RectangleType rect)
RectangleListoperator= (const RectangleList &other)
 RectangleList (RectangleList &&other) noexcept
RectangleListoperator= (RectangleList &&other) noexcept
bool isEmpty () const noexcept
int getNumRectangles () const noexcept
RectangleType getRectangle (int index) const noexcept
void clear ()
void add (RectangleType rect)
void add (ValueType x, ValueType y, ValueType width, ValueType height)
void addWithoutMerging (RectangleType rect)
void add (const RectangleList &other)
void subtract (RectangleType rect)
bool subtract (const RectangleList &otherList)
bool clipTo (RectangleType rect)
template<typename OtherValueType>
bool clipTo (const RectangleList< OtherValueType > &other)
bool getIntersectionWith (RectangleType rect, RectangleList &destRegion) const
void swapWith (RectangleList &otherList) noexcept
bool containsPoint (Point< ValueType > point) const noexcept
bool containsPoint (ValueType x, ValueType y) const noexcept
bool containsRectangle (RectangleType rectangleToCheck) const
bool intersectsRectangle (RectangleType rectangleToCheck) const noexcept
bool intersects (const RectangleList &other) const noexcept
RectangleType getBounds () const noexcept
void consolidate ()
void offsetAll (Point< ValueType > offset) noexcept
void offsetAll (ValueType dx, ValueType dy) noexcept
template<typename ScaleType>
void scaleAll (ScaleType scaleFactor) noexcept
void transformAll (const AffineTransform &transform) noexcept
Path toPath () const
const RectangleTypebegin () const noexcept
const RectangleTypeend () const noexcept
void ensureStorageAllocated (int minNumRectangles)

Private Attributes

Array< RectangleTyperects

Detailed Description

template<typename ValueType>
class juce::RectangleList< ValueType >

Maintains a set of rectangles as a complex region.

This class allows a set of rectangles to be treated as a solid shape, and can add and remove rectangular sections of it, and simplify overlapping or adjacent rectangles.

See also
Rectangle

@tags{Graphics}

Member Typedef Documentation

◆ RectangleType

template<typename ValueType>
using juce::RectangleList< ValueType >::RectangleType = Rectangle<ValueType>

Constructor & Destructor Documentation

◆ RectangleList() [1/4]

template<typename ValueType>
juce::RectangleList< ValueType >::RectangleList ( )
default

Creates an empty RectangleList

◆ RectangleList() [2/4]

template<typename ValueType>
juce::RectangleList< ValueType >::RectangleList ( const RectangleList< ValueType > & other)
inline

Creates a copy of another list

◆ RectangleList() [3/4]

template<typename ValueType>
juce::RectangleList< ValueType >::RectangleList ( RectangleType rect)
inline

Creates a list containing just one rectangle.

◆ RectangleList() [4/4]

template<typename ValueType>
juce::RectangleList< ValueType >::RectangleList ( RectangleList< ValueType > && other)
inlinenoexcept

Move constructor

Member Function Documentation

◆ add() [1/3]

template<typename ValueType>
void juce::RectangleList< ValueType >::add ( const RectangleList< ValueType > & other)
inline

Merges another rectangle list into this one.

Any overlaps between the two lists will be clipped, so that the result is the union of both lists.

◆ add() [2/3]

template<typename ValueType>
void juce::RectangleList< ValueType >::add ( RectangleType rect)
inline

Merges a new rectangle into the list.

The rectangle being added will first be clipped to remove any parts of it that overlap existing rectangles in the list, and adjacent rectangles will be merged into it.

The rectangle can have any size and may be empty, but if it's floating point then it's expected to not contain any INF values.

◆ add() [3/3]

template<typename ValueType>
void juce::RectangleList< ValueType >::add ( ValueType x,
ValueType y,
ValueType width,
ValueType height )
inline

Merges a new rectangle into the list.

The rectangle being added will first be clipped to remove any parts of it that overlap existing rectangles in the list.

◆ addWithoutMerging()

template<typename ValueType>
void juce::RectangleList< ValueType >::addWithoutMerging ( RectangleType rect)
inline

Dumbly adds a rectangle to the list without checking for overlaps.

This simply adds the rectangle to the end, it doesn't merge it or remove any overlapping bits.

The rectangle can have any size and may be empty, but if it's floating point then it's expected to not contain any INF values.

◆ begin()

template<typename ValueType>
const RectangleType * juce::RectangleList< ValueType >::begin ( ) const
inlinenoexcept

Standard method for iterating the rectangles in the list.

◆ clear()

template<typename ValueType>
void juce::RectangleList< ValueType >::clear ( )
inline

Removes all rectangles to leave an empty region.

◆ clipTo() [1/2]

template<typename ValueType>
template<typename OtherValueType>
bool juce::RectangleList< ValueType >::clipTo ( const RectangleList< OtherValueType > & other)
inline

Removes any areas of the region that lie outside a given rectangle list.

Any rectangles in this object which overlap the specified list will be clipped and subdivided if necessary.

Returns true if the resulting region is not empty, false if it is empty.

See also
getIntersectionWith

◆ clipTo() [2/2]

template<typename ValueType>
bool juce::RectangleList< ValueType >::clipTo ( RectangleType rect)
inline

Removes any areas of the region that lie outside a given rectangle.

Any rectangles in the list which overlap this will be clipped and subdivided if necessary.

Returns true if the resulting region is not empty, false if it is empty.

See also
getIntersectionWith

◆ consolidate()

template<typename ValueType>
void juce::RectangleList< ValueType >::consolidate ( )
inline

Optimises the list into a minimum number of constituent rectangles.

This will try to combine any adjacent rectangles into larger ones where possible, to simplify lists that might have been fragmented by repeated add/subtract calls.

◆ containsPoint() [1/2]

template<typename ValueType>
bool juce::RectangleList< ValueType >::containsPoint ( Point< ValueType > point) const
inlinenoexcept

Checks whether the region contains a given point.

Returns
true if the point lies within one of the rectangles in the list

◆ containsPoint() [2/2]

template<typename ValueType>
bool juce::RectangleList< ValueType >::containsPoint ( ValueType x,
ValueType y ) const
inlinenoexcept

Checks whether the region contains a given point.

Returns
true if the point lies within one of the rectangles in the list

◆ containsRectangle()

template<typename ValueType>
bool juce::RectangleList< ValueType >::containsRectangle ( RectangleType rectangleToCheck) const
inline

Checks whether the region contains the whole of a given rectangle.

Returns
true all parts of the rectangle passed in lie within the region defined by this object
See also
intersectsRectangle, containsPoint

◆ end()

template<typename ValueType>
const RectangleType * juce::RectangleList< ValueType >::end ( ) const
inlinenoexcept

Standard method for iterating the rectangles in the list.

◆ ensureStorageAllocated()

template<typename ValueType>
void juce::RectangleList< ValueType >::ensureStorageAllocated ( int minNumRectangles)
inline

Increases the internal storage to hold a minimum number of rectangles. Calling this before adding a large number of rectangles means that the array won't have to keep dynamically resizing itself as the elements are added, and it'll therefore be more efficient.

See also
Array::ensureStorageAllocated

◆ getBounds()

template<typename ValueType>
RectangleType juce::RectangleList< ValueType >::getBounds ( ) const
inlinenoexcept

Returns the smallest rectangle that can enclose the whole of this region.

◆ getIntersectionWith()

template<typename ValueType>
bool juce::RectangleList< ValueType >::getIntersectionWith ( RectangleType rect,
RectangleList< ValueType > & destRegion ) const
inline

Creates a region which is the result of clipping this one to a given rectangle.

Unlike the other clipTo method, this one doesn't affect this object - it puts the resulting region into the list whose reference is passed-in.

Returns true if the resulting region is not empty, false if it is empty.

See also
clipTo

◆ getNumRectangles()

template<typename ValueType>
int juce::RectangleList< ValueType >::getNumRectangles ( ) const
inlinenoexcept

Returns the number of rectangles in the list.

◆ getRectangle()

template<typename ValueType>
RectangleType juce::RectangleList< ValueType >::getRectangle ( int index) const
inlinenoexcept

Returns one of the rectangles at a particular index.

Returns
the rectangle at the index, or an empty rectangle if the index is out-of-range.

◆ intersects()

template<typename ValueType>
bool juce::RectangleList< ValueType >::intersects ( const RectangleList< ValueType > & other) const
inlinenoexcept

Checks whether this region intersects any part of another one.

See also
intersectsRectangle

◆ intersectsRectangle()

template<typename ValueType>
bool juce::RectangleList< ValueType >::intersectsRectangle ( RectangleType rectangleToCheck) const
inlinenoexcept

Checks whether the region contains any part of a given rectangle.

Returns
true if any part of the rectangle passed in lies within the region defined by this object
See also
containsRectangle

◆ isEmpty()

template<typename ValueType>
bool juce::RectangleList< ValueType >::isEmpty ( ) const
inlinenoexcept

Returns true if the region is empty.

◆ offsetAll() [1/2]

template<typename ValueType>
void juce::RectangleList< ValueType >::offsetAll ( Point< ValueType > offset)
inlinenoexcept

Adds an x and y value to all the coordinates.

◆ offsetAll() [2/2]

template<typename ValueType>
void juce::RectangleList< ValueType >::offsetAll ( ValueType dx,
ValueType dy )
inlinenoexcept

Adds an x and y value to all the coordinates.

◆ operator=() [1/2]

template<typename ValueType>
RectangleList & juce::RectangleList< ValueType >::operator= ( const RectangleList< ValueType > & other)
inline

Copies this list from another one.

◆ operator=() [2/2]

template<typename ValueType>
RectangleList & juce::RectangleList< ValueType >::operator= ( RectangleList< ValueType > && other)
inlinenoexcept

Move assignment operator

◆ scaleAll()

template<typename ValueType>
template<typename ScaleType>
void juce::RectangleList< ValueType >::scaleAll ( ScaleType scaleFactor)
inlinenoexcept

Scales all the coordinates.

◆ subtract() [1/2]

template<typename ValueType>
bool juce::RectangleList< ValueType >::subtract ( const RectangleList< ValueType > & otherList)
inline

Removes all areas in another RectangleList from this one.

Any rectangles in the list which overlap this will be clipped and subdivided if necessary.

Returns
true if the resulting list is non-empty.

◆ subtract() [2/2]

template<typename ValueType>
void juce::RectangleList< ValueType >::subtract ( RectangleType rect)
inline

Removes a rectangular region from the list.

Any rectangles in the list which overlap this will be clipped and subdivided if necessary.

◆ swapWith()

template<typename ValueType>
void juce::RectangleList< ValueType >::swapWith ( RectangleList< ValueType > & otherList)
inlinenoexcept

Swaps the contents of this and another list.

This swaps their internal pointers, so is hugely faster than using copy-by-value to swap them.

◆ toPath()

template<typename ValueType>
Path juce::RectangleList< ValueType >::toPath ( ) const
inline

Creates a Path object to represent this region.

◆ transformAll()

template<typename ValueType>
void juce::RectangleList< ValueType >::transformAll ( const AffineTransform & transform)
inlinenoexcept

Applies a transform to all the rectangles. Obviously this will create a mess if the transform involves any rotation or skewing.

Member Data Documentation

◆ rects

template<typename ValueType>
Array<RectangleType> juce::RectangleList< ValueType >::rects
private

The documentation for this class was generated from the following file: