source/modules/juce_gui_basics/buttons/juce_Button.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library.
   5    Copyright (c) 2022 - Raw Material Software Limited
   6
   7    JUCE is an open source library subject to commercial or open-source
   8    licensing.
   9
  10    By using JUCE, you agree to the terms of both the JUCE 7 End-User License
  11    Agreement and JUCE Privacy Policy.
  12
  13    End User License Agreement: www.juce.com/juce-7-licence
  14    Privacy Policy: www.juce.com/juce-privacy-policy
  15
  16    Or: You may also use this code under the terms of the GPL v3 (see
  17    www.gnu.org/licenses).
  18
  19    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
  20    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
  21    DISCLAIMED.
  22
  23   ==============================================================================
  24 */
  25
  26 namespace juce
  27 {
  28
  29 struct Button::CallbackHelper  : public Timer,
  30                                  public ApplicationCommandManagerListener,
  31                                  public Value::Listener,
  32                                  public KeyListener
  33 {
  34     CallbackHelper (Button& b) : button (b)   {}
  35
  36     void timerCallback() override
  37     {
  38         button.repeatTimerCallback();
  39     }
  40
  41     bool keyStateChanged (bool, Component*) override
  42     {
  43         return button.keyStateChangedCallback();
  44     }
  45
  46     void valueChanged (Value& value) override
  47     {
  48         if (value.refersToSameSourceAs (button.isOn))
  49             button.setToggleState (button.isOn.getValue(), dontSendNotification, sendNotification);
  50     }
  51
  52     bool keyPressed (const KeyPress&, Component*) override
  53     {
  54         // returning true will avoid forwarding events for keys that we're using as shortcuts
  55         return button.isShortcutPressed();
  56     }
  57
  58     void applicationCommandInvoked (const ApplicationCommandTarget::InvocationInfo& info) override
  59     {
  60         if (info.commandID == button.commandID
  61              && (info.commandFlags & ApplicationCommandInfo::dontTriggerVisualFeedback) == 0)
  62             button.flashButtonState();
  63     }
  64
  65     void applicationCommandListChanged() override
  66     {
  67         button.applicationCommandListChangeCallback();
  68     }
  69
  70     Button& button;
  71
  72     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (CallbackHelper)
  73 };
  74
  75 //==============================================================================
  76 Button::Button (const String& name)  : Component (name), text (name)
  77 {
  78     callbackHelper.reset (new CallbackHelper (*this));
  79
  80     setWantsKeyboardFocus (true);
  81     isOn.addListener (callbackHelper.get());
  82 }
  83
  84 Button::~Button()
  85 {
  86     clearShortcuts();
  87
  88     if (commandManagerToUse != nullptr)
  89         commandManagerToUse->removeListener (callbackHelper.get());
  90
  91     isOn.removeListener (callbackHelper.get());
  92     callbackHelper.reset();
  93 }
  94
  95 //==============================================================================
  96 void Button::setButtonText (const String& newText)
  97 {
  98     if (text != newText)
  99     {
 100         text = newText;
 101         repaint();
 102     }
 103 }
 104
 105 void Button::setTooltip (const String& newTooltip)
 106 {
 107     SettableTooltipClient::setTooltip (newTooltip);
 108     generateTooltip = false;
 109 }
 110
 111 void Button::updateAutomaticTooltip (const ApplicationCommandInfo& info)
 112 {
 113     if (generateTooltip && commandManagerToUse != nullptr)
 114     {
 115         auto tt = info.description.isNotEmpty() ? info.description
 116                                                 : info.shortName;
 117
 118         for (auto& kp : commandManagerToUse->getKeyMappings()->getKeyPressesAssignedToCommand (commandID))
 119         {
 120             auto key = kp.getTextDescription();
 121
 122             tt << " [";
 123
 124             if (key.length() == 1)
 125                 tt << TRANS("shortcut") << ": '" << key << "']";
 126             else
 127                 tt << key << ']';
 128         }
 129
 130         SettableTooltipClient::setTooltip (tt);
 131     }
 132 }
 133
 134 void Button::setConnectedEdges (int newFlags)
 135 {
 136     if (connectedEdgeFlags != newFlags)
 137     {
 138         connectedEdgeFlags = newFlags;
 139         repaint();
 140     }
 141 }
 142
 143 //==============================================================================
 144 void Button::checkToggleableState (bool wasToggleable)
 145 {
 146     if (isToggleable() != wasToggleable)
 147         invalidateAccessibilityHandler();
 148 }
 149
 150 void Button::setToggleable (bool isNowToggleable)
 151 {
 152     const auto wasToggleable = isToggleable();
 153
 154     canBeToggled = isNowToggleable;
 155     checkToggleableState (wasToggleable);
 156 }
 157
 158 void Button::setToggleState (bool shouldBeOn, NotificationType notification)
 159 {
 160     setToggleState (shouldBeOn, notification, notification);
 161 }
 162
 163 void Button::setToggleState (bool shouldBeOn, NotificationType clickNotification, NotificationType stateNotification)
 164 {
 165     if (shouldBeOn != lastToggleState)
 166     {
 167         WeakReference<Component> deletionWatcher (this);
 168
 169         if (shouldBeOn)
 170         {
 171             turnOffOtherButtonsInGroup (clickNotification, stateNotification);
 172
 173             if (deletionWatcher == nullptr)
 174                 return;
 175         }
 176
 177         // This test is done so that if the value is void rather than explicitly set to
 178         // false, the value won't be changed unless the required value is true.
 179         if (getToggleState() != shouldBeOn)
 180         {
 181             isOn = shouldBeOn;
 182
 183             if (deletionWatcher == nullptr)
 184                 return;
 185         }
 186
 187         lastToggleState = shouldBeOn;
 188         repaint();
 189
 190         if (clickNotification != dontSendNotification)
 191         {
 192             // async callbacks aren't possible here
 193             jassert (clickNotification != sendNotificationAsync);
 194
 195             sendClickMessage (ModifierKeys::currentModifiers);
 196
 197             if (deletionWatcher == nullptr)
 198                 return;
 199         }
 200
 201         if (stateNotification != dontSendNotification)
 202             sendStateMessage();
 203         else
 204             buttonStateChanged();
 205
 206         if (auto* handler = getAccessibilityHandler())
 207             handler->notifyAccessibilityEvent (AccessibilityEvent::valueChanged);
 208     }
 209 }
 210
 211 void Button::setToggleState (bool shouldBeOn, bool sendChange)
 212 {
 213     setToggleState (shouldBeOn, sendChange ? sendNotification : dontSendNotification);
 214 }
 215
 216 void Button::setClickingTogglesState (bool shouldToggle) noexcept
 217 {
 218     const auto wasToggleable = isToggleable();
 219
 220     clickTogglesState = shouldToggle;
 221     checkToggleableState (wasToggleable);
 222
 223     // if you've got clickTogglesState turned on, you shouldn't also connect the button
 224     // up to be a command invoker. Instead, your command handler must flip the state of whatever
 225     // it is that this button represents, and the button will update its state to reflect this
 226     // in the applicationCommandListChanged() method.
 227     jassert (commandManagerToUse == nullptr || ! clickTogglesState);
 228 }
 229
 230 void Button::setRadioGroupId (int newGroupId, NotificationType notification)
 231 {
 232     if (radioGroupId != newGroupId)
 233     {
 234         radioGroupId = newGroupId;
 235
 236         if (lastToggleState)
 237             turnOffOtherButtonsInGroup (notification, notification);
 238
 239         setToggleable (true);
 240         invalidateAccessibilityHandler();
 241     }
 242 }
 243
 244 void Button::turnOffOtherButtonsInGroup (NotificationType clickNotification, NotificationType stateNotification)
 245 {
 246     if (auto* p = getParentComponent())
 247     {
 248         if (radioGroupId != 0)
 249         {
 250             WeakReference<Component> deletionWatcher (this);
 251
 252             for (auto* c : p->getChildren())
 253             {
 254                 if (c != this)
 255                 {
 256                     if (auto b = dynamic_cast<Button*> (c))
 257                     {
 258                         if (b->getRadioGroupId() == radioGroupId)
 259                         {
 260                             b->setToggleState (false, clickNotification, stateNotification);
 261
 262                             if (deletionWatcher == nullptr)
 263                                 return;
 264                         }
 265                     }
 266                 }
 267             }
 268         }
 269     }
 270 }
 271
 272 //==============================================================================
 273 void Button::enablementChanged()
 274 {
 275     updateState();
 276     repaint();
 277 }
 278
 279 Button::ButtonState Button::updateState()
 280 {
 281     return updateState (isMouseOver (true), isMouseButtonDown());
 282 }
 283
 284 Button::ButtonState Button::updateState (bool over, bool down)
 285 {
 286     ButtonState newState = buttonNormal;
 287
 288     if (isEnabled() && isVisible() && ! isCurrentlyBlockedByAnotherModalComponent())
 289     {
 290         if ((down && (over || (triggerOnMouseDown && buttonState == buttonDown))) || isKeyDown)
 291             newState = buttonDown;
 292         else if (over)
 293             newState = buttonOver;
 294     }
 295
 296     setState (newState);
 297     return newState;
 298 }
 299
 300 void Button::setState (ButtonState newState)
 301 {
 302     if (buttonState != newState)
 303     {
 304         buttonState = newState;
 305         repaint();
 306
 307         if (buttonState == buttonDown)
 308         {
 309             buttonPressTime = Time::getApproximateMillisecondCounter();
 310             lastRepeatTime = 0;
 311         }
 312
 313         sendStateMessage();
 314     }
 315 }
 316
 317 bool Button::isDown() const noexcept    { return buttonState == buttonDown; }
 318 bool Button::isOver() const noexcept    { return buttonState != buttonNormal; }
 319
 320 void Button::buttonStateChanged() {}
 321
 322 uint32 Button::getMillisecondsSinceButtonDown() const noexcept
 323 {
 324     auto now = Time::getApproximateMillisecondCounter();
 325     return now > buttonPressTime ? now - buttonPressTime : 0;
 326 }
 327
 328 void Button::setTriggeredOnMouseDown (bool isTriggeredOnMouseDown) noexcept
 329 {
 330     triggerOnMouseDown = isTriggeredOnMouseDown;
 331 }
 332
 333 bool Button::getTriggeredOnMouseDown() const noexcept
 334 {
 335     return triggerOnMouseDown;
 336 }
 337
 338 //==============================================================================
 339 void Button::clicked()
 340 {
 341 }
 342
 343 void Button::clicked (const ModifierKeys&)
 344 {
 345     clicked();
 346 }
 347
 348 enum { clickMessageId = 0x2f3f4f99 };
 349
 350 void Button::triggerClick()
 351 {
 352     postCommandMessage (clickMessageId);
 353 }
 354
 355 void Button::internalClickCallback (const ModifierKeys& modifiers)
 356 {
 357     if (clickTogglesState)
 358     {
 359         const bool shouldBeOn = (radioGroupId != 0 || ! lastToggleState);
 360
 361         if (shouldBeOn != getToggleState())
 362         {
 363             setToggleState (shouldBeOn, sendNotification);
 364             return;
 365         }
 366     }
 367
 368     sendClickMessage (modifiers);
 369 }
 370
 371 void Button::flashButtonState()
 372 {
 373     if (isEnabled())
 374     {
 375         needsToRelease = true;
 376         setState (buttonDown);
 377         callbackHelper->startTimer (100);
 378     }
 379 }
 380
 381 void Button::handleCommandMessage (int commandId)
 382 {
 383     if (commandId == clickMessageId)
 384     {
 385         if (isEnabled())
 386         {
 387             flashButtonState();
 388             internalClickCallback (ModifierKeys::currentModifiers);
 389         }
 390     }
 391     else
 392     {
 393         Component::handleCommandMessage (commandId);
 394     }
 395 }
 396
 397 //==============================================================================
 398 void Button::addListener (Listener* l)      { buttonListeners.add (l); }
 399 void Button::removeListener (Listener* l)   { buttonListeners.remove (l); }
 400
 401 void Button::sendClickMessage (const ModifierKeys& modifiers)
 402 {
 403     Component::BailOutChecker checker (this);
 404
 405     if (commandManagerToUse != nullptr && commandID != 0)
 406     {
 407         ApplicationCommandTarget::InvocationInfo info (commandID);
 408         info.invocationMethod = ApplicationCommandTarget::InvocationInfo::fromButton;
 409         info.originatingComponent = this;
 410
 411         commandManagerToUse->invoke (info, true);
 412     }
 413
 414     clicked (modifiers);
 415
 416     if (checker.shouldBailOut())
 417         return;
 418
 419     buttonListeners.callChecked (checker, [this] (Listener& l) { l.buttonClicked (this); });
 420
 421     if (checker.shouldBailOut())
 422         return;
 423
 424     if (onClick != nullptr)
 425         onClick();
 426 }
 427
 428 void Button::sendStateMessage()
 429 {
 430     Component::BailOutChecker checker (this);
 431
 432     buttonStateChanged();
 433
 434     if (checker.shouldBailOut())
 435         return;
 436
 437     buttonListeners.callChecked (checker, [this] (Listener& l) { l.buttonStateChanged (this); });
 438
 439     if (checker.shouldBailOut())
 440         return;
 441
 442     if (onStateChange != nullptr)
 443         onStateChange();
 444 }
 445
 446 //==============================================================================
 447 void Button::paint (Graphics& g)
 448 {
 449     if (needsToRelease && isEnabled())
 450     {
 451         needsToRelease = false;
 452         needsRepainting = true;
 453     }
 454
 455     paintButton (g, isOver(), isDown());
 456     lastStatePainted = buttonState;
 457 }
 458
 459 //==============================================================================
 460 void Button::mouseEnter (const MouseEvent&)     { updateState (true,  false); }
 461 void Button::mouseExit (const MouseEvent&)      { updateState (false, false); }
 462
 463 void Button::mouseDown (const MouseEvent& e)
 464 {
 465     updateState (true, true);
 466
 467     if (isDown())
 468     {
 469         if (autoRepeatDelay >= 0)
 470             callbackHelper->startTimer (autoRepeatDelay);
 471
 472         if (triggerOnMouseDown)
 473             internalClickCallback (e.mods);
 474     }
 475 }
 476
 477 void Button::mouseUp (const MouseEvent& e)
 478 {
 479     const auto wasDown = isDown();
 480     const auto wasOver = isOver();
 481     updateState (isMouseSourceOver (e), false);
 482
 483     if (wasDown && wasOver && ! triggerOnMouseDown)
 484     {
 485         if (lastStatePainted != buttonDown)
 486             flashButtonState();
 487
 488         WeakReference<Component> deletionWatcher (this);
 489
 490         internalClickCallback (e.mods);
 491
 492         if (deletionWatcher != nullptr)
 493             updateState (isMouseSourceOver (e), false);
 494     }
 495 }
 496
 497 void Button::mouseDrag (const MouseEvent& e)
 498 {
 499     auto oldState = buttonState;
 500     updateState (isMouseSourceOver (e), true);
 501
 502     if (autoRepeatDelay >= 0 && buttonState != oldState && isDown())
 503         callbackHelper->startTimer (autoRepeatSpeed);
 504 }
 505
 506 bool Button::isMouseSourceOver (const MouseEvent& e)
 507 {
 508     if (e.source.isTouch() || e.source.isPen())
 509         return getLocalBounds().toFloat().contains (e.position);
 510
 511     return isMouseOver();
 512 }
 513
 514 void Button::focusGained (FocusChangeType)
 515 {
 516     updateState();
 517     repaint();
 518 }
 519
 520 void Button::focusLost (FocusChangeType)
 521 {
 522     updateState();
 523     repaint();
 524 }
 525
 526 void Button::visibilityChanged()
 527 {
 528     needsToRelease = false;
 529     updateState();
 530 }
 531
 532 void Button::parentHierarchyChanged()
 533 {
 534     auto* newKeySource = shortcuts.isEmpty() ? nullptr : getTopLevelComponent();
 535
 536     if (newKeySource != keySource.get())
 537     {
 538         if (keySource != nullptr)
 539             keySource->removeKeyListener (callbackHelper.get());
 540
 541         keySource = newKeySource;
 542
 543         if (keySource != nullptr)
 544             keySource->addKeyListener (callbackHelper.get());
 545     }
 546 }
 547
 548 //==============================================================================
 549 void Button::setCommandToTrigger (ApplicationCommandManager* newCommandManager,
 550                                   CommandID newCommandID, bool generateTip)
 551 {
 552     commandID = newCommandID;
 553     generateTooltip = generateTip;
 554
 555     if (commandManagerToUse != newCommandManager)
 556     {
 557         if (commandManagerToUse != nullptr)
 558             commandManagerToUse->removeListener (callbackHelper.get());
 559
 560         commandManagerToUse = newCommandManager;
 561
 562         if (commandManagerToUse != nullptr)
 563             commandManagerToUse->addListener (callbackHelper.get());
 564
 565         // if you've got clickTogglesState turned on, you shouldn't also connect the button
 566         // up to be a command invoker. Instead, your command handler must flip the state of whatever
 567         // it is that this button represents, and the button will update its state to reflect this
 568         // in the applicationCommandListChanged() method.
 569         jassert (commandManagerToUse == nullptr || ! clickTogglesState);
 570     }
 571
 572     if (commandManagerToUse != nullptr)
 573         applicationCommandListChangeCallback();
 574     else
 575         setEnabled (true);
 576 }
 577
 578 void Button::applicationCommandListChangeCallback()
 579 {
 580     if (commandManagerToUse != nullptr)
 581     {
 582         ApplicationCommandInfo info (0);
 583
 584         if (commandManagerToUse->getTargetForCommand (commandID, info) != nullptr)
 585         {
 586             updateAutomaticTooltip (info);
 587             setEnabled ((info.flags & ApplicationCommandInfo::isDisabled) == 0);
 588             setToggleState ((info.flags & ApplicationCommandInfo::isTicked) != 0, dontSendNotification);
 589         }
 590         else
 591         {
 592             setEnabled (false);
 593         }
 594     }
 595 }
 596
 597 //==============================================================================
 598 void Button::addShortcut (const KeyPress& key)
 599 {
 600     if (key.isValid())
 601     {
 602         jassert (! isRegisteredForShortcut (key));  // already registered!
 603
 604         shortcuts.add (key);
 605         parentHierarchyChanged();
 606     }
 607 }
 608
 609 void Button::clearShortcuts()
 610 {
 611     shortcuts.clear();
 612     parentHierarchyChanged();
 613 }
 614
 615 bool Button::isShortcutPressed() const
 616 {
 617     if (isShowing() && ! isCurrentlyBlockedByAnotherModalComponent())
 618         for (auto& s : shortcuts)
 619             if (s.isCurrentlyDown())
 620                 return true;
 621
 622     return false;
 623 }
 624
 625 bool Button::isRegisteredForShortcut (const KeyPress& key) const
 626 {
 627     for (auto& s : shortcuts)
 628         if (key == s)
 629             return true;
 630
 631     return false;
 632 }
 633
 634 bool Button::keyStateChangedCallback()
 635 {
 636     if (! isEnabled())
 637         return false;
 638
 639     const bool wasDown = isKeyDown;
 640     isKeyDown = isShortcutPressed();
 641
 642     if (autoRepeatDelay >= 0 && (isKeyDown && ! wasDown))
 643         callbackHelper->startTimer (autoRepeatDelay);
 644
 645     updateState();
 646
 647     if (isEnabled() && wasDown && ! isKeyDown)
 648     {
 649         internalClickCallback (ModifierKeys::currentModifiers);
 650
 651         // (return immediately - this button may now have been deleted)
 652         return true;
 653     }
 654
 655     return wasDown || isKeyDown;
 656 }
 657
 658 bool Button::keyPressed (const KeyPress& key)
 659 {
 660     if (isEnabled() && key.isKeyCode (KeyPress::returnKey))
 661     {
 662         triggerClick();
 663         return true;
 664     }
 665
 666     return false;
 667 }
 668
 669 //==============================================================================
 670 void Button::setRepeatSpeed (int initialDelayMillisecs,
 671                              int repeatMillisecs,
 672                              int minimumDelayInMillisecs) noexcept
 673 {
 674     autoRepeatDelay = initialDelayMillisecs;
 675     autoRepeatSpeed = repeatMillisecs;
 676     autoRepeatMinimumDelay = jmin (autoRepeatSpeed, minimumDelayInMillisecs);
 677 }
 678
 679 void Button::repeatTimerCallback()
 680 {
 681     if (needsRepainting)
 682     {
 683         callbackHelper->stopTimer();
 684         updateState();
 685         needsRepainting = false;
 686     }
 687     else if (autoRepeatSpeed > 0 && (isKeyDown || (updateState() == buttonDown)))
 688     {
 689         auto repeatSpeed = autoRepeatSpeed;
 690
 691         if (autoRepeatMinimumDelay >= 0)
 692         {
 693             auto timeHeldDown = jmin (1.0, getMillisecondsSinceButtonDown() / 4000.0);
 694             timeHeldDown *= timeHeldDown;
 695
 696             repeatSpeed = repeatSpeed + (int) (timeHeldDown * (autoRepeatMinimumDelay - repeatSpeed));
 697         }
 698
 699         repeatSpeed = jmax (1, repeatSpeed);
 700
 701         auto now = Time::getMillisecondCounter();
 702
 703         // if we've been blocked from repeating often enough, speed up the repeat timer to compensate..
 704         if (lastRepeatTime != 0 && (int) (now - lastRepeatTime) > repeatSpeed * 2)
 705             repeatSpeed = jmax (1, repeatSpeed / 2);
 706
 707         lastRepeatTime = now;
 708         callbackHelper->startTimer (repeatSpeed);
 709
 710         internalClickCallback (ModifierKeys::currentModifiers);
 711     }
 712     else if (! needsToRelease)
 713     {
 714         callbackHelper->stopTimer();
 715     }
 716 }
 717
 718 //==============================================================================
 719 class ButtonAccessibilityHandler  : public AccessibilityHandler
 720 {
 721 public:
 722     explicit ButtonAccessibilityHandler (Button& buttonToWrap, AccessibilityRole roleIn)
 723         : AccessibilityHandler (buttonToWrap,
 724                                 isRadioButton (buttonToWrap) ? AccessibilityRole::radioButton : roleIn,
 725                                 getAccessibilityActions (buttonToWrap),
 726                                 getAccessibilityInterfaces (buttonToWrap)),
 727           button (buttonToWrap)
 728     {
 729     }
 730
 731     AccessibleState getCurrentState() const override
 732     {
 733         auto state = AccessibilityHandler::getCurrentState();
 734
 735         if (button.isToggleable())
 736         {
 737             state = state.withCheckable();
 738
 739             if (button.getToggleState())
 740                 state = state.withChecked();
 741         }
 742
 743         return state;
 744     }
 745
 746     String getTitle() const override
 747     {
 748         auto title = AccessibilityHandler::getTitle();
 749
 750         if (title.isEmpty())
 751             return button.getButtonText();
 752
 753         return title;
 754     }
 755
 756     String getHelp() const override  { return button.getTooltip(); }
 757
 758 private:
 759     class ButtonValueInterface  : public AccessibilityTextValueInterface
 760     {
 761     public:
 762         explicit ButtonValueInterface (Button& buttonToWrap)
 763             : button (buttonToWrap)
 764         {
 765         }
 766
 767         bool isReadOnly() const override                 { return true; }
 768         String getCurrentValueAsString() const override  { return button.getToggleState() ? "On" : "Off"; }
 769         void setValueAsString (const String&) override   {}
 770
 771     private:
 772         Button& button;
 773
 774         //==============================================================================
 775         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ButtonValueInterface)
 776     };
 777
 778     static bool isRadioButton (const Button& button) noexcept
 779     {
 780         return button.getRadioGroupId() != 0;
 781     }
 782
 783     static AccessibilityActions getAccessibilityActions (Button& button)
 784     {
 785         auto actions = AccessibilityActions().addAction (AccessibilityActionType::press,
 786                                                          [&button] { button.triggerClick(); });
 787
 788         if (button.isToggleable())
 789             actions = actions.addAction (AccessibilityActionType::toggle,
 790                                          [&button] { button.setToggleState (! button.getToggleState(), sendNotification); });
 791
 792         return actions;
 793     }
 794
 795     static Interfaces getAccessibilityInterfaces (Button& button)
 796     {
 797         if (button.isToggleable())
 798             return { std::make_unique<ButtonValueInterface> (button) };
 799
 800         return {};
 801     }
 802
 803     Button& button;
 804
 805     //==============================================================================
 806     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ButtonAccessibilityHandler)
 807 };
 808
 809 std::unique_ptr<AccessibilityHandler> Button::createAccessibilityHandler()
 810 {
 811     return std::make_unique<ButtonAccessibilityHandler> (*this, AccessibilityRole::button);
 812 }
 813
 814 } // namespace juce