DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
Browse Source

Deleted some old deprecated methods from Component, and tidied a few things up

tags/2021-05-28
jules 7 years ago
parent
510fa0c22b
commit
78791be3c5
3 changed files with 81 additions and 115 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +8
    -8
      modules/juce_core/memory/juce_WeakReference.h
  2. +67
    -95
      modules/juce_gui_basics/components/juce_Component.cpp
  3. +6
    -12
      modules/juce_gui_basics/components/juce_Component.h

+ 8
- 8
modules/juce_core/memory/juce_WeakReference.h View File

@@ -81,7 +81,7 @@ public:
inline WeakReference() noexcept {}
/** Creates a WeakReference that points at the given object. */
WeakReference (ObjectType* const object) : holder (getRef (object)) {}
WeakReference (ObjectType* object) : holder (getRef (object)) {}
/** Creates a copy of another WeakReference. */
WeakReference (const WeakReference& other) noexcept : holder (other.holder) {}
@@ -93,7 +93,7 @@ public:
WeakReference& operator= (const WeakReference& other) { holder = other.holder; return *this; }
/** Copies another pointer to this one. */
WeakReference& operator= (ObjectType* const newObject) { holder = getRef (newObject); return *this; }
WeakReference& operator= (ObjectType* newObject) { holder = getRef (newObject); return *this; }
/** Move assignment operator */
WeakReference& operator= (WeakReference&& other) noexcept { holder = static_cast<SharedRef&&> (other.holder); return *this; }
@@ -119,8 +119,8 @@ public:
*/
bool wasObjectDeleted() const noexcept { return holder != nullptr && holder->get() == nullptr; }
bool operator== (ObjectType* const object) const noexcept { return get() == object; }
bool operator!= (ObjectType* const object) const noexcept { return get() != object; }
bool operator== (ObjectType* object) const noexcept { return get() == object; }
bool operator!= (ObjectType* object) const noexcept { return get() != object; }
//==============================================================================
/** This class is used internally by the WeakReference class - don't use it directly
@@ -130,13 +130,13 @@ public:
class SharedPointer : public ReferenceCountingType
{
public:
explicit SharedPointer (ObjectType* const obj) noexcept : owner (obj) {}
explicit SharedPointer (ObjectType* obj) noexcept : owner (obj) {}
inline ObjectType* get() const noexcept { return owner; }
void clearPointer() noexcept { owner = nullptr; }
private:
ObjectType* volatile owner;
ObjectType* owner;
JUCE_DECLARE_NON_COPYABLE (SharedPointer)
};
@@ -164,7 +164,7 @@ public:
/** The first call to this method will create an internal object that is shared by all weak
references to the object.
*/
SharedPointer* getSharedPointer (ObjectType* const object)
SharedPointer* getSharedPointer (ObjectType* object)
{
if (sharedPointer == nullptr)
{
@@ -204,7 +204,7 @@ public:
private:
SharedRef holder;
static inline SharedPointer* getRef (ObjectType* const o)
static inline SharedPointer* getRef (ObjectType* o)
{
return (o != nullptr) ? o->masterReference.getSharedPointer (o) : nullptr;
}


+ 67
- 95
modules/juce_gui_basics/components/juce_Component.cpp View File

@@ -404,7 +404,8 @@ struct Component::ComponentHelpers
return convertFromDistantParentSpace (topLevelComp, *target, p);
}
static bool clipObscuredRegions (const Component& comp, Graphics& g, const Rectangle<int> clipRect, Point<int> delta)
static bool clipObscuredRegions (const Component& comp, Graphics& g,
const Rectangle<int> clipRect, Point<int> delta)
{
bool wasClipped = false;
@@ -747,7 +748,7 @@ void Component::minimisationStateChanged (bool) {}
float Component::getDesktopScaleFactor() const { return Desktop::getInstance().getGlobalScaleFactor(); }
//==============================================================================
void Component::setOpaque (const bool shouldBeOpaque)
void Component::setOpaque (bool shouldBeOpaque)
{
if (shouldBeOpaque != flags.opaqueFlag)
{
@@ -838,7 +839,7 @@ void Component::setCachedComponentImage (CachedComponentImage* newCachedImage)
}
}
void Component::setBufferedToImage (const bool shouldBeBuffered)
void Component::setBufferedToImage (bool shouldBeBuffered)
{
// This assertion means that this component is already using a custom CachedComponentImage,
// so by calling setBufferedToImage, you'll be deleting the custom one - this is almost certainly
@@ -858,7 +859,7 @@ void Component::setBufferedToImage (const bool shouldBeBuffered)
}
//==============================================================================
void Component::reorderChildInternal (const int sourceIndex, const int destIndex)
void Component::reorderChildInternal (int sourceIndex, int destIndex)
{
if (sourceIndex != destIndex)
{
@@ -873,7 +874,7 @@ void Component::reorderChildInternal (const int sourceIndex, const int destIndex
}
}
void Component::toFront (const bool setAsForeground)
void Component::toFront (bool setAsForeground)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -923,7 +924,7 @@ void Component::toFront (const bool setAsForeground)
}
}
void Component::toBehind (Component* const other)
void Component::toBehind (Component* other)
{
if (other != nullptr && other != this)
{
@@ -993,7 +994,7 @@ void Component::toBack()
}
}
void Component::setAlwaysOnTop (const bool shouldStayOnTop)
void Component::setAlwaysOnTop (bool shouldStayOnTop)
{
if (shouldStayOnTop != flags.alwaysOnTopFlag)
{
@@ -1030,8 +1031,8 @@ bool Component::isAlwaysOnTop() const noexcept
}
//==============================================================================
int Component::proportionOfWidth (const float proportion) const noexcept { return roundToInt (proportion * boundsRelativeToParent.getWidth()); }
int Component::proportionOfHeight (const float proportion) const noexcept { return roundToInt (proportion * boundsRelativeToParent.getHeight()); }
int Component::proportionOfWidth (float proportion) const noexcept { return roundToInt (proportion * boundsRelativeToParent.getWidth()); }
int Component::proportionOfHeight (float proportion) const noexcept { return roundToInt (proportion * boundsRelativeToParent.getHeight()); }
int Component::getParentWidth() const noexcept
{
@@ -1086,26 +1087,8 @@ Rectangle<int> Component::localAreaToGlobal (Rectangle<int> area) const
return ComponentHelpers::convertCoordinate (nullptr, this, area);
}
// Deprecated methods...
Point<int> Component::relativePositionToGlobal (Point<int> relativePosition) const
{
return localPointToGlobal (relativePosition);
}
Point<int> Component::globalPositionToRelative (Point<int> screenPosition) const
{
return getLocalPoint (nullptr, screenPosition);
}
Point<int> Component::relativePositionToOtherComponent (const Component* const targetComponent, Point<int> positionRelativeToThis) const
{
return targetComponent == nullptr ? localPointToGlobal (positionRelativeToThis)
: targetComponent->getLocalPoint (this, positionRelativeToThis);
}
//==============================================================================
void Component::setBounds (const int x, const int y, int w, int h)
void Component::setBounds (int x, int y, int w, int h)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -1125,6 +1108,7 @@ void Component::setBounds (const int x, const int y, int w, int h)
if (wasMoved || wasResized)
{
const bool showing = isShowing();
if (showing)
{
// send a fake mouse move to trigger enter/exit messages if needed..
@@ -1173,7 +1157,7 @@ void Component::sendMovedResizedMessagesIfPending()
}
}
void Component::sendMovedResizedMessages (const bool wasMoved, const bool wasResized)
void Component::sendMovedResizedMessages (bool wasMoved, bool wasResized)
{
BailOutChecker checker (this);
@@ -1225,7 +1209,7 @@ void Component::setTopLeftPosition (Point<int> pos)
setBounds (pos.x, pos.y, getWidth(), getHeight());
}
void Component::setTopRightPosition (const int x, const int y)
void Component::setTopRightPosition (int x, int y)
{
setTopLeftPosition (x - getWidth(), y);
}
@@ -1235,18 +1219,7 @@ void Component::setBounds (Rectangle<int> r)
setBounds (r.getX(), r.getY(), r.getWidth(), r.getHeight());
}
void Component::setBounds (const RelativeRectangle& newBounds)
{
newBounds.applyToComponent (*this);
}
void Component::setBounds (const String& newBoundsExpression)
{
RelativeRectangle (newBoundsExpression).applyToComponent (*this);
}
void Component::setBoundsRelative (const float x, const float y,
const float w, const float h)
void Component::setBoundsRelative (float x, float y, float w, float h)
{
auto pw = getParentWidth();
auto ph = getParentHeight();
@@ -1266,7 +1239,7 @@ void Component::setCentreRelative (float x, float y)
roundToInt (getParentHeight() * y));
}
void Component::centreWithSize (const int width, const int height)
void Component::centreWithSize (int width, int height)
{
auto parentArea = ComponentHelpers::getParentOrMainMonitorBounds (*this)
.transformedBy (getTransform().inverted());
@@ -1282,8 +1255,7 @@ void Component::setBoundsInset (BorderSize<int> borders)
}
void Component::setBoundsToFit (int x, int y, int width, int height,
Justification justification,
const bool onlyReduceInSize)
Justification justification, bool onlyReduceInSize)
{
// it's no good calling this method unless both the component and
// target rectangle have a finite size.
@@ -1387,8 +1359,8 @@ bool Component::hitTest (int x, int y)
return false;
}
void Component::setInterceptsMouseClicks (const bool allowClicks,
const bool allowClicksOnChildComponents) noexcept
void Component::setInterceptsMouseClicks (bool allowClicks,
bool allowClicksOnChildComponents) noexcept
{
flags.ignoresMouseClicksFlag = ! allowClicks;
flags.allowChildMouseClicksFlag = allowClicksOnChildComponents;
@@ -1416,7 +1388,7 @@ bool Component::contains (Point<int> point)
return false;
}
bool Component::reallyContains (Point<int> point, const bool returnTrueIfWithinAChild)
bool Component::reallyContains (Point<int> point, bool returnTrueIfWithinAChild)
{
if (! contains (point))
return false;
@@ -1498,19 +1470,19 @@ void Component::addAndMakeVisible (Component& child, int zOrder)
addChildComponent (child, zOrder);
}
void Component::addChildComponent (Component* const child, int zOrder)
void Component::addChildComponent (Component* child, int zOrder)
{
if (child != nullptr)
addChildComponent (*child, zOrder);
}
void Component::addAndMakeVisible (Component* const child, int zOrder)
void Component::addAndMakeVisible (Component* child, int zOrder)
{
if (child != nullptr)
addAndMakeVisible (*child, zOrder);
}
void Component::addChildAndSetID (Component* const child, const String& childID)
void Component::addChildAndSetID (Component* child, const String& childID)
{
if (child != nullptr)
{
@@ -1519,17 +1491,17 @@ void Component::addChildAndSetID (Component* const child, const String& childID)
}
}
void Component::removeChildComponent (Component* const child)
void Component::removeChildComponent (Component* child)
{
removeChildComponent (childComponentList.indexOf (child), true, true);
}
Component* Component::removeChildComponent (const int index)
Component* Component::removeChildComponent (int index)
{
return removeChildComponent (index, true, true);
}
Component* Component::removeChildComponent (const int index, bool sendParentEvents, const bool sendChildEvents)
Component* Component::removeChildComponent (int index, bool sendParentEvents, bool sendChildEvents)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -1602,12 +1574,12 @@ int Component::getNumChildComponents() const noexcept
return childComponentList.size();
}
Component* Component::getChildComponent (const int index) const noexcept
Component* Component::getChildComponent (int index) const noexcept
{
return childComponentList[index];
}
int Component::getIndexOfChildComponent (const Component* const child) const noexcept
int Component::getIndexOfChildComponent (const Component* child) const noexcept
{
return childComponentList.indexOf (const_cast<Component*> (child));
}
@@ -1714,9 +1686,9 @@ int Component::runModalLoop()
#endif
//==============================================================================
void Component::enterModalState (const bool shouldTakeKeyboardFocus,
void Component::enterModalState (bool shouldTakeKeyboardFocus,
ModalComponentManager::Callback* callback,
const bool deleteWhenDismissed)
bool deleteWhenDismissed)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -1740,7 +1712,7 @@ void Component::enterModalState (const bool shouldTakeKeyboardFocus,
}
}
void Component::exitModalState (const int returnValue)
void Component::exitModalState (int returnValue)
{
if (isCurrentlyModal (false))
{
@@ -1798,7 +1770,7 @@ Component* JUCE_CALLTYPE Component::getCurrentlyModalComponent (int index) noexc
}
//==============================================================================
void Component::setBroughtToFrontOnMouseClick (const bool shouldBeBroughtToFront) noexcept
void Component::setBroughtToFrontOnMouseClick (bool shouldBeBroughtToFront) noexcept
{
flags.bringToFrontOnClickFlag = shouldBeBroughtToFront;
}
@@ -1831,7 +1803,7 @@ void Component::updateMouseCursor() const
}
//==============================================================================
void Component::setRepaintsOnMouseActivity (const bool shouldRepaint) noexcept
void Component::setRepaintsOnMouseActivity (bool shouldRepaint) noexcept
{
flags.repaintOnMouseActivityFlag = shouldRepaint;
}
@@ -2024,7 +1996,7 @@ void Component::paintComponentAndChildren (Graphics& g)
g.restoreState();
}
void Component::paintEntireComponent (Graphics& g, const bool ignoreAlphaLevel)
void Component::paintEntireComponent (Graphics& g, bool ignoreAlphaLevel)
{
// If sizing a top-level-window and the OS paint message is delivered synchronously
// before resized() is called, then we'll invoke the callback here, to make sure
@@ -2077,7 +2049,7 @@ void Component::paintEntireComponent (Graphics& g, const bool ignoreAlphaLevel)
#endif
}
void Component::setPaintingIsUnclipped (const bool shouldPaintWithoutClipping) noexcept
void Component::setPaintingIsUnclipped (bool shouldPaintWithoutClipping) noexcept
{
flags.dontClipGraphicsFlag = shouldPaintWithoutClipping;
}
@@ -2099,8 +2071,8 @@ Image Component::createComponentSnapshot (Rectangle<int> areaToGrab,
if (r.isEmpty())
return Image();
const int w = roundToInt (scaleFactor * r.getWidth());
const int h = roundToInt (scaleFactor * r.getHeight());
auto w = roundToInt (scaleFactor * r.getWidth());
auto h = roundToInt (scaleFactor * r.getHeight());
Image image (flags.opaqueFlag ? Image::RGB : Image::ARGB, w, h, true);
@@ -2116,7 +2088,7 @@ Image Component::createComponentSnapshot (Rectangle<int> areaToGrab,
return image;
}
void Component::setComponentEffect (ImageEffectFilter* const newEffect)
void Component::setComponentEffect (ImageEffectFilter* newEffect)
{
if (effect != newEffect)
{
@@ -2135,7 +2107,7 @@ LookAndFeel& Component::getLookAndFeel() const noexcept
return LookAndFeel::getDefaultLookAndFeel();
}
void Component::setLookAndFeel (LookAndFeel* const newLookAndFeel)
void Component::setLookAndFeel (LookAndFeel* newLookAndFeel)
{
if (lookAndFeel != newLookAndFeel)
{
@@ -2172,7 +2144,7 @@ void Component::sendLookAndFeelChange()
}
}
Colour Component::findColour (const int colourId, const bool inheritFromParent) const
Colour Component::findColour (int colourId, bool inheritFromParent) const
{
if (auto* v = properties.getVarPointer (ComponentHelpers::getColourPropertyId (colourId)))
return Colour ((uint32) static_cast<int> (*v));
@@ -2184,18 +2156,18 @@ Colour Component::findColour (const int colourId, const bool inheritFromParent)
return getLookAndFeel().findColour (colourId);
}
bool Component::isColourSpecified (const int colourId) const
bool Component::isColourSpecified (int colourId) const
{
return properties.contains (ComponentHelpers::getColourPropertyId (colourId));
}
void Component::removeColour (const int colourId)
void Component::removeColour (int colourId)
{
if (properties.remove (ComponentHelpers::getColourPropertyId (colourId)))
colourChanged();
}
void Component::setColour (const int colourId, Colour colour)
void Component::setColour (int colourId, Colour colour)
{
if (properties.set (ComponentHelpers::getColourPropertyId (colourId), (int) colour.getARGB()))
colourChanged();
@@ -2283,7 +2255,7 @@ void Component::moved() {}
void Component::childBoundsChanged (Component*) {}
void Component::parentSizeChanged() {}
void Component::addComponentListener (ComponentListener* const newListener)
void Component::addComponentListener (ComponentListener* newListener)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -2295,7 +2267,7 @@ void Component::addComponentListener (ComponentListener* const newListener)
componentListeners.add (newListener);
}
void Component::removeComponentListener (ComponentListener* const listenerToRemove)
void Component::removeComponentListener (ComponentListener* listenerToRemove)
{
componentListeners.remove (listenerToRemove);
}
@@ -2319,7 +2291,7 @@ void Component::internalModalInputAttempt()
}
//==============================================================================
void Component::postCommandMessage (const int commandID)
void Component::postCommandMessage (int commandID)
{
WeakReference<Component> target (this);
@@ -2336,8 +2308,8 @@ void Component::handleCommandMessage (int)
}
//==============================================================================
void Component::addMouseListener (MouseListener* const newListener,
const bool wantsEventsForAllNestedChildComponents)
void Component::addMouseListener (MouseListener* newListener,
bool wantsEventsForAllNestedChildComponents)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -2353,7 +2325,7 @@ void Component::addMouseListener (MouseListener* const newListener,
mouseListeners->addListener (newListener, wantsEventsForAllNestedChildComponents);
}
void Component::removeMouseListener (MouseListener* const listenerToRemove)
void Component::removeMouseListener (MouseListener* listenerToRemove)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -2633,7 +2605,7 @@ void Component::sendFakeMouseMove() const
mainMouse.triggerFakeMove();
}
void JUCE_CALLTYPE Component::beginDragAutoRepeat (const int interval)
void JUCE_CALLTYPE Component::beginDragAutoRepeat (int interval)
{
Desktop::getInstance().beginDragAutoRepeat (interval);
}
@@ -2673,12 +2645,12 @@ void Component::focusGained (FocusChangeType) {}
void Component::focusLost (FocusChangeType) {}
void Component::focusOfChildComponentChanged (FocusChangeType) {}
void Component::internalFocusGain (const FocusChangeType cause)
void Component::internalFocusGain (FocusChangeType cause)
{
internalFocusGain (cause, WeakReference<Component> (this));
}
void Component::internalFocusGain (const FocusChangeType cause, const WeakReference<Component>& safePointer)
void Component::internalFocusGain (FocusChangeType cause, const WeakReference<Component>& safePointer)
{
focusGained (cause);
@@ -2686,7 +2658,7 @@ void Component::internalFocusGain (const FocusChangeType cause, const WeakRefere
internalChildFocusChange (cause, safePointer);
}
void Component::internalFocusLoss (const FocusChangeType cause)
void Component::internalFocusLoss (FocusChangeType cause)
{
const WeakReference<Component> safePointer (this);
@@ -2714,12 +2686,12 @@ void Component::internalChildFocusChange (FocusChangeType cause, const WeakRefer
parentComponent->internalChildFocusChange (cause, WeakReference<Component> (parentComponent));
}
void Component::setWantsKeyboardFocus (const bool wantsFocus) noexcept
void Component::setWantsKeyboardFocus (bool wantsFocus) noexcept
{
flags.wantsFocusFlag = wantsFocus;
}
void Component::setMouseClickGrabsKeyboardFocus (const bool shouldGrabFocus)
void Component::setMouseClickGrabsKeyboardFocus (bool shouldGrabFocus)
{
flags.dontFocusOnMouseClickFlag = ! shouldGrabFocus;
}
@@ -2734,7 +2706,7 @@ bool Component::getWantsKeyboardFocus() const noexcept
return flags.wantsFocusFlag && ! flags.isDisabledFlag;
}
void Component::setFocusContainer (const bool shouldBeFocusContainer) noexcept
void Component::setFocusContainer (bool shouldBeFocusContainer) noexcept
{
flags.isFocusContainerFlag = shouldBeFocusContainer;
}
@@ -2751,7 +2723,7 @@ int Component::getExplicitFocusOrder() const
return properties [juce_explicitFocusOrderId];
}
void Component::setExplicitFocusOrder (const int newFocusOrderIndex)
void Component::setExplicitFocusOrder (int newFocusOrderIndex)
{
properties.set (juce_explicitFocusOrderId, newFocusOrderIndex);
}
@@ -2764,7 +2736,7 @@ KeyboardFocusTraverser* Component::createFocusTraverser()
return parentComponent->createFocusTraverser();
}
void Component::takeKeyboardFocus (const FocusChangeType cause)
void Component::takeKeyboardFocus (FocusChangeType cause)
{
// give the focus to this component
if (currentlyFocusedComponent != this)
@@ -2794,7 +2766,7 @@ void Component::takeKeyboardFocus (const FocusChangeType cause)
}
}
void Component::grabFocusInternal (const FocusChangeType cause, const bool canTryParent)
void Component::grabFocusInternal (FocusChangeType cause, bool canTryParent)
{
if (isShowing())
{
@@ -2852,7 +2824,7 @@ void Component::grabKeyboardFocus()
jassert (isShowing() || isOnDesktop());
}
void Component::moveKeyboardFocusToSibling (const bool moveToNext)
void Component::moveKeyboardFocusToSibling (bool moveToNext)
{
// if component methods are being called from threads other than the message
// thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
@@ -2886,7 +2858,7 @@ void Component::moveKeyboardFocusToSibling (const bool moveToNext)
}
}
bool Component::hasKeyboardFocus (const bool trueIfChildIsFocused) const
bool Component::hasKeyboardFocus (bool trueIfChildIsFocused) const
{
return (currentlyFocusedComponent == this)
|| (trueIfChildIsFocused && isParentOf (currentlyFocusedComponent));
@@ -2921,7 +2893,7 @@ bool Component::isEnabled() const noexcept
&& (parentComponent == nullptr || parentComponent->isEnabled());
}
void Component::setEnabled (const bool shouldBeEnabled)
void Component::setEnabled (bool shouldBeEnabled)
{
if (flags.isDisabledFlag == shouldBeEnabled)
{
@@ -2961,7 +2933,7 @@ void Component::sendEnablementChangeMessage()
}
//==============================================================================
bool Component::isMouseOver (const bool includeChildren) const
bool Component::isMouseOver (bool includeChildren) const
{
for (auto& ms : Desktop::getInstance().getMouseSources())
{
@@ -2985,7 +2957,7 @@ bool Component::isMouseButtonDown() const
return false;
}
bool Component::isMouseOverOrDragging (const bool includeChildren) const
bool Component::isMouseOverOrDragging (bool includeChildren) const
{
for (auto& ms : Desktop::getInstance().getMouseSources())
{
@@ -3010,7 +2982,7 @@ Point<int> Component::getMouseXYRelative() const
}
//==============================================================================
void Component::addKeyListener (KeyListener* const newListener)
void Component::addKeyListener (KeyListener* newListener)
{
if (keyListeners == nullptr)
keyListeners = new Array<KeyListener*>();
@@ -3018,7 +2990,7 @@ void Component::addKeyListener (KeyListener* const newListener)
keyListeners->addIfNotAlreadyThere (newListener);
}
void Component::removeKeyListener (KeyListener* const listenerToRemove)
void Component::removeKeyListener (KeyListener* listenerToRemove)
{
if (keyListeners != nullptr)
keyListeners->removeFirstMatchingValue (listenerToRemove);
@@ -3040,7 +3012,7 @@ void Component::internalModifierKeysChanged()
}
//==============================================================================
Component::BailOutChecker::BailOutChecker (Component* const component)
Component::BailOutChecker::BailOutChecker (Component* component)
: safePointer (component)
{
jassert (component != nullptr);


+ 6
- 12
modules/juce_gui_basics/components/juce_Component.h View File

@@ -1749,6 +1749,10 @@ public:
for which this method will return true is the one that was originally
clicked on.
Also note that on a touch-screen device, this will only return true when a finger
is actually down - as soon as all touch is released, isMouseOver will always
return false.
If includeChildren is true, then this will also return true if the mouse is over
any of the component's children (recursively) as well as the component itself.
@@ -2240,16 +2244,6 @@ public:
*/
bool getViewportIgnoreDragFlag() const noexcept { return flags.viewportIgnoreDragFlag; }
//==============================================================================
// These methods are deprecated - use localPointToGlobal, getLocalPoint, getLocalPoint, etc instead.
JUCE_DEPRECATED (Point<int> relativePositionToGlobal (Point<int>) const);
JUCE_DEPRECATED (Point<int> globalPositionToRelative (Point<int>) const);
JUCE_DEPRECATED (Point<int> relativePositionToOtherComponent (const Component*, Point<int>) const);
// RelativeCoordinates are eventually going to be deprecated
JUCE_DEPRECATED (void setBounds (const RelativeRectangle&));
JUCE_DEPRECATED (void setBounds (const String&));
private:
//==============================================================================
friend class ComponentPeer;
@@ -2344,8 +2338,8 @@ private:
void sendMovedResizedMessagesIfPending();
void repaintParent();
void sendFakeMouseMove() const;
void takeKeyboardFocus (const FocusChangeType);
void grabFocusInternal (const FocusChangeType, bool canTryParent);
void takeKeyboardFocus (FocusChangeType);
void grabFocusInternal (FocusChangeType, bool canTryParent);
static void giveAwayFocus (bool sendFocusLossEvent);
void sendEnablementChangeMessage();
void sendVisibilityChangeMessage();


Write Preview
Loading…
Cancel
Save