juce/source/src/gui/components/mouse/juce_MouseInputSource.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_MouseInputSource.h"
  31 #include "juce_MouseEvent.h"
  32 #include "../juce_Component.h"
  33 #include "../../../events/juce_AsyncUpdater.h"
  34 #include "../../../events/juce_MessageManager.h"
  35 #include "../lookandfeel/juce_LookAndFeel.h"
  36 #include "../windows/juce_ComponentPeer.h"
  37
  38
  39 //==============================================================================
  40 class MouseInputSourceInternal   : public AsyncUpdater
  41 {
  42 public:
  43     //==============================================================================
  44     MouseInputSourceInternal (MouseInputSource& source_, const int index_, const bool isMouseDevice_)
  45         : index (index_), isMouseDevice (isMouseDevice_), source (source_), lastPeer (nullptr),
  46           isUnboundedMouseModeOn (false), isCursorVisibleUntilOffscreen (false), currentCursorHandle (nullptr),
  47           mouseEventCounter (0)
  48     {
  49     }
  50
  51     //==============================================================================
  52     bool isDragging() const noexcept
  53     {
  54         return buttonState.isAnyMouseButtonDown();
  55     }
  56
  57     Component* getComponentUnderMouse() const
  58     {
  59         return static_cast <Component*> (componentUnderMouse);
  60     }
  61
  62     const ModifierKeys getCurrentModifiers() const
  63     {
  64         return ModifierKeys::getCurrentModifiers().withoutMouseButtons().withFlags (buttonState.getRawFlags());
  65     }
  66
  67     ComponentPeer* getPeer()
  68     {
  69         if (! ComponentPeer::isValidPeer (lastPeer))
  70             lastPeer = nullptr;
  71
  72         return lastPeer;
  73     }
  74
  75     Component* findComponentAt (const Point<int>& screenPos)
  76     {
  77         ComponentPeer* const peer = getPeer();
  78
  79         if (peer != nullptr)
  80         {
  81             Component* const comp = peer->getComponent();
  82             const Point<int> relativePos (comp->getLocalPoint (nullptr, screenPos));
  83
  84             // (the contains() call is needed to test for overlapping desktop windows)
  85             if (comp->contains (relativePos))
  86                 return comp->getComponentAt (relativePos);
  87         }
  88
  89         return nullptr;
  90     }
  91
  92     const Point<int> getScreenPosition() const
  93     {
  94         // This needs to return the live position if possible, but it mustn't update the lastScreenPos
  95         // value, because that can cause continuity problems.
  96         return unboundedMouseOffset + (isMouseDevice ? MouseInputSource::getCurrentMousePosition()
  97                                                      : lastScreenPos);
  98     }
  99
 100     //==============================================================================
 101     void sendMouseEnter (Component* const comp, const Point<int>& screenPos, const Time& time)
 102     {
 103         //DBG ("Mouse " + String (source.getIndex()) + " enter: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 104         comp->internalMouseEnter (source, comp->getLocalPoint (nullptr, screenPos), time);
 105     }
 106
 107     void sendMouseExit (Component* const comp, const Point<int>& screenPos, const Time& time)
 108     {
 109         //DBG ("Mouse " + String (source.getIndex()) + " exit: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 110         comp->internalMouseExit (source, comp->getLocalPoint (nullptr, screenPos), time);
 111     }
 112
 113     void sendMouseMove (Component* const comp, const Point<int>& screenPos, const Time& time)
 114     {
 115         //DBG ("Mouse " + String (source.getIndex()) + " move: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 116         comp->internalMouseMove (source, comp->getLocalPoint (nullptr, screenPos), time);
 117     }
 118
 119     void sendMouseDown (Component* const comp, const Point<int>& screenPos, const Time& time)
 120     {
 121         //DBG ("Mouse " + String (source.getIndex()) + " down: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 122         comp->internalMouseDown (source, comp->getLocalPoint (nullptr, screenPos), time);
 123     }
 124
 125     void sendMouseDrag (Component* const comp, const Point<int>& screenPos, const Time& time)
 126     {
 127         //DBG ("Mouse " + String (source.getIndex()) + " drag: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 128         comp->internalMouseDrag (source, comp->getLocalPoint (nullptr, screenPos), time);
 129     }
 130
 131     void sendMouseUp (Component* const comp, const Point<int>& screenPos, const Time& time)
 132     {
 133         //DBG ("Mouse " + String (source.getIndex()) + " up: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 134         comp->internalMouseUp (source, comp->getLocalPoint (nullptr, screenPos), time, getCurrentModifiers());
 135     }
 136
 137     void sendMouseWheel (Component* const comp, const Point<int>& screenPos, const Time& time, float x, float y)
 138     {
 139         //DBG ("Mouse " + String (source.getIndex()) + " wheel: " + comp->getLocalPoint (nullptr, screenPos).toString() + " - Comp: " + String::toHexString ((int) comp));
 140         comp->internalMouseWheel (source, comp->getLocalPoint (nullptr, screenPos), time, x, y);
 141     }
 142
 143     //==============================================================================
 144     // (returns true if the button change caused a modal event loop)
 145     bool setButtons (const Point<int>& screenPos, const Time& time, const ModifierKeys& newButtonState)
 146     {
 147         if (buttonState == newButtonState)
 148             return false;
 149
 150         setScreenPos (screenPos, time, false);
 151
 152         // (ignore secondary clicks when there's already a button down)
 153         if (buttonState.isAnyMouseButtonDown() == newButtonState.isAnyMouseButtonDown())
 154         {
 155             buttonState = newButtonState;
 156             return false;
 157         }
 158
 159         const int lastCounter = mouseEventCounter;
 160
 161         if (buttonState.isAnyMouseButtonDown())
 162         {
 163             Component* const current = getComponentUnderMouse();
 164
 165             if (current != nullptr)
 166                 sendMouseUp (current, screenPos + unboundedMouseOffset, time);
 167
 168             enableUnboundedMouseMovement (false, false);
 169         }
 170
 171         buttonState = newButtonState;
 172
 173         if (buttonState.isAnyMouseButtonDown())
 174         {
 175             Desktop::getInstance().incrementMouseClickCounter();
 176
 177             Component* const current = getComponentUnderMouse();
 178
 179             if (current != nullptr)
 180             {
 181                 registerMouseDown (screenPos, time, current, buttonState);
 182                 sendMouseDown (current, screenPos, time);
 183             }
 184         }
 185
 186         return lastCounter != mouseEventCounter;
 187     }
 188
 189     void setComponentUnderMouse (Component* const newComponent, const Point<int>& screenPos, const Time& time)
 190     {
 191         Component* current = getComponentUnderMouse();
 192
 193         if (newComponent != current)
 194         {
 195             WeakReference<Component> safeNewComp (newComponent);
 196             const ModifierKeys originalButtonState (buttonState);
 197
 198             if (current != nullptr)
 199             {
 200                 setButtons (screenPos, time, ModifierKeys());
 201                 sendMouseExit (current, screenPos, time);
 202                 buttonState = originalButtonState;
 203             }
 204
 205             componentUnderMouse = safeNewComp;
 206             current = getComponentUnderMouse();
 207
 208             if (current != nullptr)
 209                 sendMouseEnter (current, screenPos, time);
 210
 211             revealCursor (false);
 212             setButtons (screenPos, time, originalButtonState);
 213         }
 214     }
 215
 216     void setPeer (ComponentPeer* const newPeer, const Point<int>& screenPos, const Time& time)
 217     {
 218         ModifierKeys::updateCurrentModifiers();
 219
 220         if (newPeer != lastPeer)
 221         {
 222             setComponentUnderMouse (nullptr, screenPos, time);
 223             lastPeer = newPeer;
 224             setComponentUnderMouse (findComponentAt (screenPos), screenPos, time);
 225         }
 226     }
 227
 228     void setScreenPos (const Point<int>& newScreenPos, const Time& time, const bool forceUpdate)
 229     {
 230         if (! isDragging())
 231             setComponentUnderMouse (findComponentAt (newScreenPos), newScreenPos, time);
 232
 233         if (newScreenPos != lastScreenPos || forceUpdate)
 234         {
 235             cancelPendingUpdate();
 236
 237             lastScreenPos = newScreenPos;
 238             Component* const current = getComponentUnderMouse();
 239
 240             if (current != nullptr)
 241             {
 242                 if (isDragging())
 243                 {
 244                     registerMouseDrag (newScreenPos);
 245                     sendMouseDrag (current, newScreenPos + unboundedMouseOffset, time);
 246
 247                     if (isUnboundedMouseModeOn)
 248                         handleUnboundedDrag (current);
 249                 }
 250                 else
 251                 {
 252                     sendMouseMove (current, newScreenPos, time);
 253                 }
 254             }
 255
 256             revealCursor (false);
 257         }
 258     }
 259
 260     //==============================================================================
 261     void handleEvent (ComponentPeer* const newPeer, const Point<int>& positionWithinPeer, const Time& time, const ModifierKeys& newMods)
 262     {
 263         jassert (newPeer != nullptr);
 264         lastTime = time;
 265         ++mouseEventCounter;
 266         const Point<int> screenPos (newPeer->localToGlobal (positionWithinPeer));
 267
 268         if (isDragging() && newMods.isAnyMouseButtonDown())
 269         {
 270             setScreenPos (screenPos, time, false);
 271         }
 272         else
 273         {
 274             setPeer (newPeer, screenPos, time);
 275
 276             ComponentPeer* peer = getPeer();
 277             if (peer != nullptr)
 278             {
 279                 if (setButtons (screenPos, time, newMods))
 280                     return; // some modal events have been dispatched, so the current event is now out-of-date
 281
 282                 peer = getPeer();
 283                 if (peer != nullptr)
 284                     setScreenPos (screenPos, time, false);
 285             }
 286         }
 287     }
 288
 289     void handleWheel (ComponentPeer* const peer, const Point<int>& positionWithinPeer, const Time& time, float x, float y)
 290     {
 291         jassert (peer != nullptr);
 292         lastTime = time;
 293         ++mouseEventCounter;
 294         const Point<int> screenPos (peer->localToGlobal (positionWithinPeer));
 295
 296         setPeer (peer, screenPos, time);
 297         setScreenPos (screenPos, time, false);
 298         triggerFakeMove();
 299
 300         if (! isDragging())
 301         {
 302             Component* current = getComponentUnderMouse();
 303             if (current != nullptr)
 304                 sendMouseWheel (current, screenPos, time, x, y);
 305         }
 306     }
 307
 308     //==============================================================================
 309     Time getLastMouseDownTime() const noexcept
 310     {
 311         return Time (mouseDowns[0].time);
 312     }
 313
 314     Point<int> getLastMouseDownPosition() const noexcept
 315     {
 316         return mouseDowns[0].position;
 317     }
 318
 319     int getNumberOfMultipleClicks() const noexcept
 320     {
 321         int numClicks = 0;
 322
 323         if (mouseDowns[0].time != Time())
 324         {
 325             if (! mouseMovedSignificantlySincePressed)
 326                 ++numClicks;
 327
 328             for (int i = 1; i < numElementsInArray (mouseDowns); ++i)
 329             {
 330                 if (mouseDowns[0].canBePartOfMultipleClickWith (mouseDowns[i], (int) (MouseEvent::getDoubleClickTimeout() * (1.0 + 0.25 * (i - 1)))))
 331                     ++numClicks;
 332                 else
 333                     break;
 334             }
 335         }
 336
 337         return numClicks;
 338     }
 339
 340     bool hasMouseMovedSignificantlySincePressed() const noexcept
 341     {
 342         return mouseMovedSignificantlySincePressed
 343                 || lastTime > mouseDowns[0].time + RelativeTime::milliseconds (300);
 344     }
 345
 346     //==============================================================================
 347     void triggerFakeMove()
 348     {
 349         triggerAsyncUpdate();
 350     }
 351
 352     void handleAsyncUpdate()
 353     {
 354         setScreenPos (lastScreenPos, jmax (lastTime, Time::getCurrentTime()), true);
 355     }
 356
 357     //==============================================================================
 358     void enableUnboundedMouseMovement (bool enable, bool keepCursorVisibleUntilOffscreen)
 359     {
 360         enable = enable && isDragging();
 361         isCursorVisibleUntilOffscreen = keepCursorVisibleUntilOffscreen;
 362
 363         if (enable != isUnboundedMouseModeOn)
 364         {
 365             if ((! enable) && ((! isCursorVisibleUntilOffscreen) || ! unboundedMouseOffset.isOrigin()))
 366             {
 367                 // when released, return the mouse to within the component's bounds
 368                 Component* current = getComponentUnderMouse();
 369                 if (current != nullptr)
 370                     Desktop::setMousePosition (current->getScreenBounds()
 371                                                  .getConstrainedPoint (lastScreenPos));
 372             }
 373
 374             isUnboundedMouseModeOn = enable;
 375             unboundedMouseOffset = Point<int>();
 376
 377             revealCursor (true);
 378         }
 379     }
 380
 381     void handleUnboundedDrag (Component* current)
 382     {
 383         const Rectangle<int> screenArea (current->getParentMonitorArea().expanded (-2, -2));
 384
 385         if (! screenArea.contains (lastScreenPos))
 386         {
 387             const Point<int> componentCentre (current->getScreenBounds().getCentre());
 388             unboundedMouseOffset += (lastScreenPos - componentCentre);
 389             Desktop::setMousePosition (componentCentre);
 390         }
 391         else if (isCursorVisibleUntilOffscreen
 392                   && (! unboundedMouseOffset.isOrigin())
 393                   && screenArea.contains (lastScreenPos + unboundedMouseOffset))
 394         {
 395             Desktop::setMousePosition (lastScreenPos + unboundedMouseOffset);
 396             unboundedMouseOffset = Point<int>();
 397         }
 398     }
 399
 400     //==============================================================================
 401     void showMouseCursor (MouseCursor cursor, bool forcedUpdate)
 402     {
 403         if (isUnboundedMouseModeOn && ((! unboundedMouseOffset.isOrigin()) || ! isCursorVisibleUntilOffscreen))
 404         {
 405             cursor = MouseCursor::NoCursor;
 406             forcedUpdate = true;
 407         }
 408
 409         if (forcedUpdate || cursor.getHandle() != currentCursorHandle)
 410         {
 411             currentCursorHandle = cursor.getHandle();
 412             cursor.showInWindow (getPeer());
 413         }
 414     }
 415
 416     void hideCursor()
 417     {
 418         showMouseCursor (MouseCursor::NoCursor, true);
 419     }
 420
 421     void revealCursor (bool forcedUpdate)
 422     {
 423         MouseCursor mc (MouseCursor::NormalCursor);
 424
 425         Component* current = getComponentUnderMouse();
 426         if (current != nullptr)
 427             mc = current->getLookAndFeel().getMouseCursorFor (*current);
 428
 429         showMouseCursor (mc, forcedUpdate);
 430     }
 431
 432     //==============================================================================
 433     const int index;
 434     const bool isMouseDevice;
 435     Point<int> lastScreenPos;
 436     ModifierKeys buttonState;
 437
 438 private:
 439     MouseInputSource& source;
 440     WeakReference<Component> componentUnderMouse;
 441     ComponentPeer* lastPeer;
 442
 443     Point<int> unboundedMouseOffset;
 444     bool isUnboundedMouseModeOn, isCursorVisibleUntilOffscreen;
 445     void* currentCursorHandle;
 446     int mouseEventCounter;
 447
 448     struct RecentMouseDown
 449     {
 450         RecentMouseDown()  : component (nullptr)
 451         {
 452         }
 453
 454         Point<int> position;
 455         Time time;
 456         Component* component;
 457         ModifierKeys buttons;
 458
 459         bool canBePartOfMultipleClickWith (const RecentMouseDown& other, const int maxTimeBetweenMs) const
 460         {
 461             return time - other.time < RelativeTime::milliseconds (maxTimeBetweenMs)
 462                     && abs (position.getX() - other.position.getX()) < 8
 463                     && abs (position.getY() - other.position.getY()) < 8
 464                     && buttons == other.buttons;;
 465         }
 466     };
 467
 468     RecentMouseDown mouseDowns[4];
 469     bool mouseMovedSignificantlySincePressed;
 470     Time lastTime;
 471
 472     void registerMouseDown (const Point<int>& screenPos, const Time& time,
 473                             Component* const component, const ModifierKeys& modifiers) noexcept
 474     {
 475         for (int i = numElementsInArray (mouseDowns); --i > 0;)
 476             mouseDowns[i] = mouseDowns[i - 1];
 477
 478         mouseDowns[0].position = screenPos;
 479         mouseDowns[0].time = time;
 480         mouseDowns[0].component = component;
 481         mouseDowns[0].buttons = modifiers.withOnlyMouseButtons();
 482         mouseMovedSignificantlySincePressed = false;
 483     }
 484
 485     void registerMouseDrag (const Point<int>& screenPos) noexcept
 486     {
 487         mouseMovedSignificantlySincePressed = mouseMovedSignificantlySincePressed
 488                || mouseDowns[0].position.getDistanceFrom (screenPos) >= 4;
 489     }
 490
 491     JUCE_DECLARE_NON_COPYABLE (MouseInputSourceInternal);
 492 };
 493
 494 //==============================================================================
 495 MouseInputSource::MouseInputSource (const int index, const bool isMouseDevice)
 496 {
 497     pimpl = new MouseInputSourceInternal (*this, index, isMouseDevice);
 498 }
 499
 500 MouseInputSource::~MouseInputSource()
 501 {
 502 }
 503
 504 bool MouseInputSource::isMouse() const                                  { return pimpl->isMouseDevice; }
 505 bool MouseInputSource::isTouch() const                                  { return ! isMouse(); }
 506 bool MouseInputSource::canHover() const                                 { return isMouse(); }
 507 bool MouseInputSource::hasMouseWheel() const                            { return isMouse(); }
 508 int MouseInputSource::getIndex() const                                  { return pimpl->index; }
 509 bool MouseInputSource::isDragging() const                               { return pimpl->isDragging(); }
 510 const Point<int> MouseInputSource::getScreenPosition() const            { return pimpl->getScreenPosition(); }
 511 const ModifierKeys MouseInputSource::getCurrentModifiers() const        { return pimpl->getCurrentModifiers(); }
 512 Component* MouseInputSource::getComponentUnderMouse() const             { return pimpl->getComponentUnderMouse(); }
 513 void MouseInputSource::triggerFakeMove() const                          { pimpl->triggerFakeMove(); }
 514 int MouseInputSource::getNumberOfMultipleClicks() const noexcept        { return pimpl->getNumberOfMultipleClicks(); }
 515 Time MouseInputSource::getLastMouseDownTime() const noexcept            { return pimpl->getLastMouseDownTime(); }
 516 Point<int> MouseInputSource::getLastMouseDownPosition() const noexcept  { return pimpl->getLastMouseDownPosition(); }
 517 bool MouseInputSource::hasMouseMovedSignificantlySincePressed() const noexcept  { return pimpl->hasMouseMovedSignificantlySincePressed(); }
 518 bool MouseInputSource::canDoUnboundedMovement() const noexcept          { return isMouse(); }
 519 void MouseInputSource::enableUnboundedMouseMovement (bool isEnabled, bool keepCursorVisibleUntilOffscreen)    { pimpl->enableUnboundedMouseMovement (isEnabled, keepCursorVisibleUntilOffscreen); }
 520 bool MouseInputSource::hasMouseCursor() const noexcept                  { return isMouse(); }
 521 void MouseInputSource::showMouseCursor (const MouseCursor& cursor)      { pimpl->showMouseCursor (cursor, false); }
 522 void MouseInputSource::hideCursor()                                     { pimpl->hideCursor(); }
 523 void MouseInputSource::revealCursor()                                   { pimpl->revealCursor (false); }
 524 void MouseInputSource::forceMouseCursorUpdate()                         { pimpl->revealCursor (true); }
 525
 526 void MouseInputSource::handleEvent (ComponentPeer* peer, const Point<int>& positionWithinPeer, const int64 time, const ModifierKeys& mods)
 527 {
 528     pimpl->handleEvent (peer, positionWithinPeer, Time (time), mods.withOnlyMouseButtons());
 529 }
 530
 531 void MouseInputSource::handleWheel (ComponentPeer* const peer, const Point<int>& positionWithinPeer, const int64 time, const float x, const float y)
 532 {
 533     pimpl->handleWheel (peer, positionWithinPeer, Time (time), x, y);
 534 }
 535
 536
 537 END_JUCE_NAMESPACE