bool ComponentPeer::handleKeyUpOrDown (const bool isKeyDown)
{
updateCurrentModifiers();
bool keyWasUsed = false;
for (Component* target = getTargetForKeyPress(); target != nullptr; target = target->getParentComponent())
{
const WeakReference<Component> deletionChecker (target);
keyWasUsed = target->keyStateChanged (isKeyDown);
if (keyWasUsed || deletionChecker == nullptr)
break;
if (const Array <KeyListener*>* const keyListeners = target->keyListeners)
{
for (int i = keyListeners->size(); --i >= 0;)
{
keyWasUsed = keyListeners->getUnchecked(i)->keyStateChanged (isKeyDown, target);
if (keyWasUsed || deletionChecker == nullptr)
return keyWasUsed;
i = jmin (i, keyListeners->size());
}
}
}
return keyWasUsed;
}
void ComponentPeer::handleScreenSizeChange()
{
updateCurrentModifiers();
component->parentSizeChanged();
handleMovedOrResized();
}
//==============================================================================
void ComponentPeer::handleBroughtToFront()
{
updateCurrentModifiers();
if (component != nullptr)
component->internalBroughtToFront();
}
bool ComponentPeer::handleDragMove (const ComponentPeer::DragInfo& info)
{
updateCurrentModifiers();
Component* const compUnderMouse = component->getComponentAt (info.position);
Component* const lastTarget = dragAndDropTargetComponent.get();
Component* newTarget = nullptr;
if (compUnderMouse != lastDragAndDropCompUnderMouse)
{
lastDragAndDropCompUnderMouse = compUnderMouse;
newTarget = DragHelpers::findDragAndDropTarget (compUnderMouse, info, lastTarget);
if (newTarget != lastTarget)
{
if (lastTarget != nullptr)
{
if (DragHelpers::isFileDrag (info))
dynamic_cast <FileDragAndDropTarget*> (lastTarget)->fileDragExit (info.files);
else
dynamic_cast <TextDragAndDropTarget*> (lastTarget)->textDragExit (info.text);
}
dragAndDropTargetComponent = nullptr;
if (DragHelpers::isSuitableTarget (info, newTarget))
{
dragAndDropTargetComponent = newTarget;
const Point<int> pos (newTarget->getLocalPoint (component, info.position));
if (DragHelpers::isFileDrag (info))
dynamic_cast <FileDragAndDropTarget*> (newTarget)->fileDragEnter (info.files, pos.x, pos.y);
else
dynamic_cast <TextDragAndDropTarget*> (newTarget)->textDragEnter (info.text, pos.x, pos.y);
}
}
}
else
{
newTarget = lastTarget;
}
if (! DragHelpers::isSuitableTarget (info, newTarget))
return false;
const Point<int> pos (newTarget->getLocalPoint (component, info.position));
if (DragHelpers::isFileDrag (info))
dynamic_cast <FileDragAndDropTarget*> (newTarget)->fileDragMove (info.files, pos.x, pos.y);
else
dynamic_cast <TextDragAndDropTarget*> (newTarget)->textDragMove (info.text, pos.x, pos.y);
return true;
}
bool ComponentPeer::handleKeyPress (const int keyCode, const juce_wchar textCharacter)
{
updateCurrentModifiers();
bool keyWasUsed = false;
const KeyPress keyInfo (keyCode,
ModifierKeys::getCurrentModifiers().withoutMouseButtons(),
textCharacter);
for (Component* target = getTargetForKeyPress(); target != nullptr; target = target->getParentComponent())
{
const WeakReference<Component> deletionChecker (target);
if (const Array <KeyListener*>* const keyListeners = target->keyListeners)
{
for (int i = keyListeners->size(); --i >= 0;)
{
keyWasUsed = keyListeners->getUnchecked(i)->keyPressed (keyInfo, target);
if (keyWasUsed || deletionChecker == nullptr)
return keyWasUsed;
i = jmin (i, keyListeners->size());
}
}
keyWasUsed = target->keyPressed (keyInfo);
if (keyWasUsed || deletionChecker == nullptr)
break;
if (Component* const currentlyFocused = Component::getCurrentlyFocusedComponent())
{
const bool isTab = (keyInfo == KeyPress::tabKey);
const bool isShiftTab = (keyInfo == KeyPress (KeyPress::tabKey, ModifierKeys::shiftModifier, 0));
if (isTab || isShiftTab)
{
currentlyFocused->moveKeyboardFocusToSibling (isTab);
keyWasUsed = (currentlyFocused != Component::getCurrentlyFocusedComponent());
if (keyWasUsed || deletionChecker == nullptr)
break;
}
}
}
return keyWasUsed;
}
void ComponentPeer::handleModifierKeysChange()
{
updateCurrentModifiers();
Component* target = Desktop::getInstance().getMainMouseSource().getComponentUnderMouse();
if (target == nullptr)
target = Component::getCurrentlyFocusedComponent();
if (target == nullptr)
target = component;
if (target != nullptr)
target->internalModifierKeysChanged();
}
void ComponentPeer::handleFocusLoss()
{
updateCurrentModifiers();
if (component->hasKeyboardFocus (true))
{
lastFocusedComponent = Component::currentlyFocusedComponent;
if (lastFocusedComponent != nullptr)
{
Component::currentlyFocusedComponent = nullptr;
Desktop::getInstance().triggerFocusCallback();
lastFocusedComponent->internalFocusLoss (Component::focusChangedByMouseClick);
}
}
}
bool ComponentPeer::handleKeyUpOrDown (const bool isKeyDown)
{
updateCurrentModifiers();
Component* target = Component::getCurrentlyFocusedComponent() != nullptr
? Component::getCurrentlyFocusedComponent()
: component;
if (target->isCurrentlyBlockedByAnotherModalComponent())
{
Component* const currentModalComp = Component::getCurrentlyModalComponent();
if (currentModalComp != nullptr)
target = currentModalComp;
}
bool keyWasUsed = false;
while (target != nullptr)
{
const WeakReference<Component> deletionChecker (target);
keyWasUsed = target->keyStateChanged (isKeyDown);
if (keyWasUsed || deletionChecker == nullptr)
break;
const Array <KeyListener*>* const keyListeners = target->keyListeners;
if (keyListeners != nullptr)
{
for (int i = keyListeners->size(); --i >= 0;)
{
keyWasUsed = keyListeners->getUnchecked(i)->keyStateChanged (isKeyDown, target);
if (keyWasUsed || deletionChecker == nullptr)
return keyWasUsed;
i = jmin (i, keyListeners->size());
}
}
target = target->getParentComponent();
}
return keyWasUsed;
}
void ComponentPeer::handleFocusGain()
{
updateCurrentModifiers();
if (component->isParentOf (lastFocusedComponent))
{
Component::currentlyFocusedComponent = lastFocusedComponent;
Desktop::getInstance().triggerFocusCallback();
lastFocusedComponent->internalFocusGain (Component::focusChangedDirectly);
}
else
{
if (! component->isCurrentlyBlockedByAnotherModalComponent())
component->grabKeyboardFocus();
else
ModalComponentManager::getInstance()->bringModalComponentsToFront();
}
}
void ComponentPeer::handleMovedOrResized()
{
updateCurrentModifiers();
const bool nowMinimised = isMinimised();
if (component->flags.hasHeavyweightPeerFlag && ! nowMinimised)
{
const WeakReference<Component> deletionChecker (component);
const Rectangle<int> newBounds (getBounds());
const bool wasMoved = (component->getPosition() != newBounds.getPosition());
const bool wasResized = (component->getWidth() != newBounds.getWidth() || component->getHeight() != newBounds.getHeight());
if (wasMoved || wasResized)
{
component->bounds = newBounds;
if (wasResized)
component->repaint();
component->sendMovedResizedMessages (wasMoved, wasResized);
if (deletionChecker == nullptr)
return;
}
}
if (isWindowMinimised != nowMinimised)
{
isWindowMinimised = nowMinimised;
component->minimisationStateChanged (nowMinimised);
component->sendVisibilityChangeMessage();
}
if (! isFullScreen())
lastNonFullscreenBounds = component->getBounds();
}
//==============================================================================
void ComponentPeer::handleUserClosingWindow()
{
updateCurrentModifiers();
component->userTriedToCloseWindow();
}
bool ComponentPeer::handleKeyPress (const int keyCode,
const juce_wchar textCharacter)
{
updateCurrentModifiers();
Component* target = Component::getCurrentlyFocusedComponent() != nullptr
? Component::getCurrentlyFocusedComponent()
: component;
if (target->isCurrentlyBlockedByAnotherModalComponent())
{
Component* const currentModalComp = Component::getCurrentlyModalComponent();
if (currentModalComp != nullptr)
target = currentModalComp;
}
const KeyPress keyInfo (keyCode,
ModifierKeys::getCurrentModifiers().getRawFlags()
& ModifierKeys::allKeyboardModifiers,
textCharacter);
bool keyWasUsed = false;
while (target != nullptr)
{
const WeakReference<Component> deletionChecker (target);
const Array <KeyListener*>* const keyListeners = target->keyListeners;
if (keyListeners != nullptr)
{
for (int i = keyListeners->size(); --i >= 0;)
{
keyWasUsed = keyListeners->getUnchecked(i)->keyPressed (keyInfo, target);
if (keyWasUsed || deletionChecker == nullptr)
return keyWasUsed;
i = jmin (i, keyListeners->size());
}
}
keyWasUsed = target->keyPressed (keyInfo);
if (keyWasUsed || deletionChecker == nullptr)
break;
Component* const currentlyFocused = Component::getCurrentlyFocusedComponent();
if (currentlyFocused != nullptr)
{
const bool isTab = (keyInfo == KeyPress (KeyPress::tabKey, ModifierKeys::noModifiers, 0));
const bool isShiftTab = (keyInfo == KeyPress (KeyPress::tabKey, ModifierKeys::shiftModifier, 0));
if (isTab || isShiftTab)
{
currentlyFocused->moveKeyboardFocusToSibling (isTab);
keyWasUsed = (currentlyFocused != Component::getCurrentlyFocusedComponent());
break;
}
}
target = target->getParentComponent();
}
return keyWasUsed;
}
//==============================================================================
void ComponentPeer::handleBroughtToFront()
{
updateCurrentModifiers();
component.internalBroughtToFront();
}
