#include <juce_ComponentBoundsConstrainer.h>
|
| ComponentBoundsConstrainer () noexcept |
|
virtual | ~ComponentBoundsConstrainer () |
|
void | setMinimumWidth (int minimumWidth) noexcept |
|
int | getMinimumWidth () const noexcept |
|
void | setMaximumWidth (int maximumWidth) noexcept |
|
int | getMaximumWidth () const noexcept |
|
void | setMinimumHeight (int minimumHeight) noexcept |
|
int | getMinimumHeight () const noexcept |
|
void | setMaximumHeight (int maximumHeight) noexcept |
|
int | getMaximumHeight () const noexcept |
|
void | setMinimumSize (int minimumWidth, int minimumHeight) noexcept |
|
void | setMaximumSize (int maximumWidth, int maximumHeight) noexcept |
|
void | setSizeLimits (int minimumWidth, int minimumHeight, int maximumWidth, int maximumHeight) noexcept |
|
void | setMinimumOnscreenAmounts (int minimumWhenOffTheTop, int minimumWhenOffTheLeft, int minimumWhenOffTheBottom, int minimumWhenOffTheRight) noexcept |
|
int | getMinimumWhenOffTheTop () const noexcept |
|
int | getMinimumWhenOffTheLeft () const noexcept |
|
int | getMinimumWhenOffTheBottom () const noexcept |
|
int | getMinimumWhenOffTheRight () const noexcept |
|
void | setFixedAspectRatio (double widthOverHeight) noexcept |
|
double | getFixedAspectRatio () const noexcept |
|
virtual void | checkBounds (Rectangle< int > &bounds, const Rectangle< int > &previousBounds, const Rectangle< int > &limits, bool isStretchingTop, bool isStretchingLeft, bool isStretchingBottom, bool isStretchingRight) |
|
virtual void | resizeStart () |
|
virtual void | resizeEnd () |
|
void | setBoundsForComponent (Component *component, const Rectangle< int > &bounds, bool isStretchingTop, bool isStretchingLeft, bool isStretchingBottom, bool isStretchingRight) |
|
void | checkComponentBounds (Component *component) |
|
virtual void | applyBoundsToComponent (Component *component, const Rectangle< int > &bounds) |
|
A class that imposes restrictions on a Component's size or position.
This is used by classes such as ResizableCornerComponent, ResizableBorderComponent and ResizableWindow.
The base class can impose some basic size and position limits, but you can also subclass this for custom uses.
- See also
- ResizableCornerComponent, ResizableBorderComponent, ResizableWindow
◆ ComponentBoundsConstrainer()
ComponentBoundsConstrainer::ComponentBoundsConstrainer |
( |
| ) |
|
|
noexcept |
When first created, the object will not impose any restrictions on the components.
◆ ~ComponentBoundsConstrainer()
ComponentBoundsConstrainer::~ComponentBoundsConstrainer |
( |
| ) |
|
|
virtual |
◆ applyBoundsToComponent()
Called by setBoundsForComponent() to apply a new constrained size to a component.
By default this just calls setBounds(), but is virtual in case it's needed for extremely cunning purposes.
◆ checkBounds()
void ComponentBoundsConstrainer::checkBounds |
( |
Rectangle< int > & |
bounds, |
|
|
const Rectangle< int > & |
previousBounds, |
|
|
const Rectangle< int > & |
limits, |
|
|
bool |
isStretchingTop, |
|
|
bool |
isStretchingLeft, |
|
|
bool |
isStretchingBottom, |
|
|
bool |
isStretchingRight |
|
) |
| |
|
virtual |
This callback changes the given coordinates to impose whatever the current constraints are set to be.
- Parameters
-
bounds | the target position that should be examined and adjusted |
previousBounds | the component's current size |
limits | the region in which the component can be positioned |
isStretchingTop | whether the top edge of the component is being resized |
isStretchingLeft | whether the left edge of the component is being resized |
isStretchingBottom | whether the bottom edge of the component is being resized |
isStretchingRight | whether the right edge of the component is being resized |
◆ checkComponentBounds()
void ComponentBoundsConstrainer::checkComponentBounds |
( |
Component * |
component | ) |
|
Performs a check on the current size of a component, and moves or resizes it if it fails the constraints.
◆ getFixedAspectRatio()
double ComponentBoundsConstrainer::getFixedAspectRatio |
( |
| ) |
const |
|
noexcept |
Returns the aspect ratio that was set with setFixedAspectRatio().
If no aspect ratio is being enforced, this will return 0.
◆ getMaximumHeight()
int ComponentBoundsConstrainer::getMaximumHeight |
( |
| ) |
const |
|
inlinenoexcept |
Returns the current maximum height.
◆ getMaximumWidth()
int ComponentBoundsConstrainer::getMaximumWidth |
( |
| ) |
const |
|
inlinenoexcept |
Returns the current maximum width.
◆ getMinimumHeight()
int ComponentBoundsConstrainer::getMinimumHeight |
( |
| ) |
const |
|
inlinenoexcept |
Returns the current minimum height.
◆ getMinimumWhenOffTheBottom()
int ComponentBoundsConstrainer::getMinimumWhenOffTheBottom |
( |
| ) |
const |
|
inlinenoexcept |
◆ getMinimumWhenOffTheLeft()
int ComponentBoundsConstrainer::getMinimumWhenOffTheLeft |
( |
| ) |
const |
|
inlinenoexcept |
◆ getMinimumWhenOffTheRight()
int ComponentBoundsConstrainer::getMinimumWhenOffTheRight |
( |
| ) |
const |
|
inlinenoexcept |
◆ getMinimumWhenOffTheTop()
int ComponentBoundsConstrainer::getMinimumWhenOffTheTop |
( |
| ) |
const |
|
inlinenoexcept |
◆ getMinimumWidth()
int ComponentBoundsConstrainer::getMinimumWidth |
( |
| ) |
const |
|
inlinenoexcept |
Returns the current minimum width.
◆ resizeEnd()
void ComponentBoundsConstrainer::resizeEnd |
( |
| ) |
|
|
virtual |
This callback happens when the resizer has finished dragging.
◆ resizeStart()
void ComponentBoundsConstrainer::resizeStart |
( |
| ) |
|
|
virtual |
This callback happens when the resizer is about to start dragging.
◆ setBoundsForComponent()
void ComponentBoundsConstrainer::setBoundsForComponent |
( |
Component * |
component, |
|
|
const Rectangle< int > & |
bounds, |
|
|
bool |
isStretchingTop, |
|
|
bool |
isStretchingLeft, |
|
|
bool |
isStretchingBottom, |
|
|
bool |
isStretchingRight |
|
) |
| |
Checks the given bounds, and then sets the component to the corrected size.
◆ setFixedAspectRatio()
void ComponentBoundsConstrainer::setFixedAspectRatio |
( |
double |
widthOverHeight | ) |
|
|
noexcept |
Specifies a width-to-height ratio that the resizer should always maintain.
If the value is 0, no aspect ratio is enforced. If it's non-zero, the width will always be maintained as this multiple of the height.
- See also
- setResizeLimits
◆ setMaximumHeight()
void ComponentBoundsConstrainer::setMaximumHeight |
( |
int |
maximumHeight | ) |
|
|
noexcept |
Imposes a maximum height limit.
◆ setMaximumSize()
void ComponentBoundsConstrainer::setMaximumSize |
( |
int |
maximumWidth, |
|
|
int |
maximumHeight |
|
) |
| |
|
noexcept |
Imposes a maximum width and height limit.
◆ setMaximumWidth()
void ComponentBoundsConstrainer::setMaximumWidth |
( |
int |
maximumWidth | ) |
|
|
noexcept |
Imposes a maximum width limit.
◆ setMinimumHeight()
void ComponentBoundsConstrainer::setMinimumHeight |
( |
int |
minimumHeight | ) |
|
|
noexcept |
Imposes a minimum height limit.
◆ setMinimumOnscreenAmounts()
void ComponentBoundsConstrainer::setMinimumOnscreenAmounts |
( |
int |
minimumWhenOffTheTop, |
|
|
int |
minimumWhenOffTheLeft, |
|
|
int |
minimumWhenOffTheBottom, |
|
|
int |
minimumWhenOffTheRight |
|
) |
| |
|
noexcept |
Sets the amount by which the component is allowed to go off-screen.
The values indicate how many pixels must remain on-screen when dragged off one of its parent's edges, so e.g. if minimumWhenOffTheTop is set to 10, then when the component goes off the top of the screen, its y-position will be clipped so that there are always at least 10 pixels on-screen. In other words, the lowest y-position it can take would be (10 - the component's height).
If you pass 0 or less for one of these amounts, the component is allowed to move beyond that edge completely, with no restrictions at all.
If you pass a very large number (i.e. larger that the dimensions of the component itself), then the component won't be allowed to overlap that edge at all. So e.g. setting minimumWhenOffTheLeft to 0xffffff will mean that the component will bump into the left side of the screen and go no further.
◆ setMinimumSize()
void ComponentBoundsConstrainer::setMinimumSize |
( |
int |
minimumWidth, |
|
|
int |
minimumHeight |
|
) |
| |
|
noexcept |
Imposes a minimum width and height limit.
◆ setMinimumWidth()
void ComponentBoundsConstrainer::setMinimumWidth |
( |
int |
minimumWidth | ) |
|
|
noexcept |
Imposes a minimum width limit.
◆ setSizeLimits()
void ComponentBoundsConstrainer::setSizeLimits |
( |
int |
minimumWidth, |
|
|
int |
minimumHeight, |
|
|
int |
maximumWidth, |
|
|
int |
maximumHeight |
|
) |
| |
|
noexcept |
Set all the maximum and minimum dimensions.
The documentation for this class was generated from the following files: