DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13169 Commits
9 Branches
776MB
Tree: b51e835baf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b51e835baf'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_win32_UIATextProvider.h

618 lines
24KB
Raw Blame History 

  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. //==============================================================================

  30. class UIATextProvider  : public UIAProviderBase,

  31.                          public ComBaseClassHelper<ComTypes::ITextProvider2>

  32. {

  33. public:

  34.     using UIAProviderBase::UIAProviderBase;

  35. 

  36.     //==============================================================================

  37.     JUCE_COMRESULT QueryInterface (REFIID iid, void** result) override

  38.     {

  39.         JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wlanguage-extension-token")

  40. 

  41.         if (iid == __uuidof (IUnknown) || iid == __uuidof (ComTypes::ITextProvider))

  42.             return castToType<ComTypes::ITextProvider> (result);

  43. 

  44.         if (iid == __uuidof (ComTypes::ITextProvider2))

  45.             return castToType<ComTypes::ITextProvider2> (result);

  46. 

  47.         *result = nullptr;

  48.         return E_NOINTERFACE;

  49. 

  50.         JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  51.     }

  52. 

  53.     //=============================================================================

  54.     JUCE_COMRESULT get_DocumentRange (ComTypes::ITextRangeProvider** pRetVal) override

  55.     {

  56.         return withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  57.         {

  58.             *pRetVal = new UIATextRangeProvider (*this, { 0, textInterface.getTotalNumCharacters() });

  59.             return S_OK;

  60.         });

  61.     }

  62. 

  63.     JUCE_COMRESULT get_SupportedTextSelection (ComTypes::SupportedTextSelection* pRetVal) override

  64.     {

  65.         return withCheckedComArgs (pRetVal, *this, [&]

  66.         {

  67.             *pRetVal = ComTypes::SupportedTextSelection_Single;

  68.             return S_OK;

  69.         });

  70.     }

  71. 

  72.     JUCE_COMRESULT GetSelection (SAFEARRAY** pRetVal) override

  73.     {

  74.         return withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  75.         {

  76.             *pRetVal = SafeArrayCreateVector (VT_UNKNOWN, 0, 1);

  77. 

  78.             if (pRetVal != nullptr)

  79.             {

  80.                 auto selection = textInterface.getSelection();

  81.                 auto hasSelection = ! selection.isEmpty();

  82.                 auto cursorPos = textInterface.getTextInsertionOffset();

  83. 

  84.                 auto* rangeProvider = new UIATextRangeProvider (*this,

  85.                                                                 { hasSelection ? selection.getStart() : cursorPos,

  86.                                                                   hasSelection ? selection.getEnd()   : cursorPos });

  87. 

  88.                 LONG pos = 0;

  89.                 auto hr = SafeArrayPutElement (*pRetVal, &pos, static_cast<IUnknown*> (rangeProvider));

  90. 

  91.                 if (FAILED (hr))

  92.                     return E_FAIL;

  93. 

  94.                 rangeProvider->Release();

  95.             }

  96. 

  97.             return S_OK;

  98.         });

  99.     }

  100. 

  101.     JUCE_COMRESULT GetVisibleRanges (SAFEARRAY** pRetVal) override

  102.     {

  103.         return withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  104.         {

  105.             *pRetVal = SafeArrayCreateVector (VT_UNKNOWN, 0, 1);

  106. 

  107.             if (pRetVal != nullptr)

  108.             {

  109.                 auto* rangeProvider = new UIATextRangeProvider (*this, { 0, textInterface.getTotalNumCharacters() });

  110. 

  111.                 LONG pos = 0;

  112.                 auto hr = SafeArrayPutElement (*pRetVal, &pos, static_cast<IUnknown*> (rangeProvider));

  113. 

  114.                 if (FAILED (hr))

  115.                     return E_FAIL;

  116. 

  117.                 rangeProvider->Release();

  118.             }

  119. 

  120.             return S_OK;

  121.         });

  122.     }

  123. 

  124.     JUCE_COMRESULT RangeFromChild (IRawElementProviderSimple*, ComTypes::ITextRangeProvider** pRetVal) override

  125.     {

  126.         return withCheckedComArgs (pRetVal, *this, []

  127.         {

  128.             return S_OK;

  129.         });

  130.     }

  131. 

  132.     JUCE_COMRESULT RangeFromPoint (ComTypes::UiaPoint point, ComTypes::ITextRangeProvider** pRetVal) override

  133.     {

  134.         return withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  135.         {

  136.             auto offset = textInterface.getOffsetAtPoint ({ roundToInt (point.x), roundToInt (point.y) });

  137. 

  138.             if (offset > 0)

  139.                 *pRetVal = new UIATextRangeProvider (*this, { offset, offset });

  140. 

  141.             return S_OK;

  142.         });

  143.     }

  144. 

  145.     //==============================================================================

  146.     JUCE_COMRESULT GetCaretRange (BOOL* isActive, ComTypes::ITextRangeProvider** pRetVal) override

  147.     {

  148.         return withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  149.         {

  150.             *isActive = getHandler().hasFocus (false);

  151. 

  152.             auto cursorPos = textInterface.getTextInsertionOffset();

  153.             *pRetVal = new UIATextRangeProvider (*this, { cursorPos, cursorPos });

  154. 

  155.             return S_OK;

  156.         });

  157.     }

  158. 

  159.     JUCE_COMRESULT RangeFromAnnotation (IRawElementProviderSimple*, ComTypes::ITextRangeProvider** pRetVal) override

  160.     {

  161.         return withCheckedComArgs (pRetVal, *this, []

  162.         {

  163.             return S_OK;

  164.         });

  165.     }

  166. 

  167. private:

  168.     //==============================================================================

  169.     template <typename Value, typename Callback>

  170.     JUCE_COMRESULT withTextInterface (Value* pRetVal, Callback&& callback) const

  171.     {

  172.         return withCheckedComArgs (pRetVal, *this, [&]() -> HRESULT

  173.         {

  174.             if (auto* textInterface = getHandler().getTextInterface())

  175.                 return callback (*textInterface);

  176. 

  177.             return (HRESULT) UIA_E_NOTSUPPORTED;

  178.         });

  179.     }

  180. 

  181.     //==============================================================================

  182.     class UIATextRangeProvider  : public UIAProviderBase,

  183.                                   public ComBaseClassHelper<ComTypes::ITextRangeProvider>

  184.     {

  185.     public:

  186.         UIATextRangeProvider (UIATextProvider& textProvider, Range<int> range)

  187.             : UIAProviderBase (textProvider.getHandler().getNativeImplementation()),

  188.               owner (&textProvider),

  189.               selectionRange (range)

  190.         {

  191.         }

  192. 

  193.         //==============================================================================

  194.         Range<int> getSelectionRange() const noexcept  { return selectionRange; }

  195. 

  196.         //==============================================================================

  197.         JUCE_COMRESULT AddToSelection() override

  198.         {

  199.             return Select();

  200.         }

  201. 

  202.         JUCE_COMRESULT Clone (ComTypes::ITextRangeProvider** pRetVal) override

  203.         {

  204.             return withCheckedComArgs (pRetVal, *this, [&]

  205.             {

  206.                 *pRetVal = new UIATextRangeProvider (*owner, selectionRange);

  207.                 return S_OK;

  208.             });

  209.         }

  210. 

  211.         JUCE_COMRESULT Compare (ComTypes::ITextRangeProvider* range, BOOL* pRetVal) override

  212.         {

  213.             return withCheckedComArgs (pRetVal, *this, [&]

  214.             {

  215.                 *pRetVal = (selectionRange == static_cast<UIATextRangeProvider*> (range)->getSelectionRange());

  216.                 return S_OK;

  217.             });

  218.         }

  219. 

  220.         JUCE_COMRESULT CompareEndpoints (ComTypes::TextPatternRangeEndpoint endpoint,

  221.                                          ComTypes::ITextRangeProvider* targetRange,

  222.                                          ComTypes::TextPatternRangeEndpoint targetEndpoint,

  223.                                          int* pRetVal) override

  224.         {

  225.             if (targetRange == nullptr)

  226.                 return E_INVALIDARG;

  227. 

  228.             return withCheckedComArgs (pRetVal, *this, [&]

  229.             {

  230.                 auto offset = (endpoint == ComTypes::TextPatternRangeEndpoint_Start ? selectionRange.getStart()

  231.                                                                                     : selectionRange.getEnd());

  232. 

  233.                 auto otherRange = static_cast<UIATextRangeProvider*> (targetRange)->getSelectionRange();

  234.                 auto otherOffset = (targetEndpoint == ComTypes::TextPatternRangeEndpoint_Start ? otherRange.getStart()

  235.                                                                                                : otherRange.getEnd());

  236. 

  237.                 *pRetVal = offset - otherOffset;

  238.                 return S_OK;

  239.             });

  240.         }

  241. 

  242.         JUCE_COMRESULT ExpandToEnclosingUnit (ComTypes::TextUnit unit) override

  243.         {

  244.             if (! isElementValid())

  245.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  246. 

  247.             if (auto* textInterface = owner->getHandler().getTextInterface())

  248.             {

  249.                 using ATH = AccessibilityTextHelpers;

  250. 

  251.                 const auto boundaryType = getBoundaryType (unit);

  252.                 const auto start = ATH::findTextBoundary (*textInterface,

  253.                                                           selectionRange.getStart(),

  254.                                                           boundaryType,

  255.                                                           ATH::Direction::backwards,

  256.                                                           ATH::IncludeThisBoundary::yes,

  257.                                                           ATH::IncludeWhitespaceAfterWords::no);

  258. 

  259.                 const auto end = ATH::findTextBoundary (*textInterface,

  260.                                                         start,

  261.                                                         boundaryType,

  262.                                                         ATH::Direction::forwards,

  263.                                                         ATH::IncludeThisBoundary::no,

  264.                                                         ATH::IncludeWhitespaceAfterWords::yes);

  265. 

  266.                 selectionRange = Range<int> (start, end);

  267. 

  268.                 return S_OK;

  269.             }

  270. 

  271.             return (HRESULT) UIA_E_NOTSUPPORTED;

  272.         }

  273. 

  274.         JUCE_COMRESULT FindAttribute (TEXTATTRIBUTEID, VARIANT, BOOL, ComTypes::ITextRangeProvider** pRetVal) override

  275.         {

  276.             return withCheckedComArgs (pRetVal, *this, []

  277.             {

  278.                 return S_OK;

  279.             });

  280.         }

  281. 

  282.         JUCE_COMRESULT FindText (BSTR text, BOOL backward, BOOL ignoreCase,

  283.                                  ComTypes::ITextRangeProvider** pRetVal) override

  284.         {

  285.             return owner->withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  286.             {

  287.                 auto selectionText = textInterface.getText (selectionRange);

  288.                 String textToSearchFor (text);

  289. 

  290.                 auto offset = (backward ? (ignoreCase ? selectionText.lastIndexOfIgnoreCase (textToSearchFor) : selectionText.lastIndexOf (textToSearchFor))

  291.                                         : (ignoreCase ? selectionText.indexOfIgnoreCase (textToSearchFor)     : selectionText.indexOf (textToSearchFor)));

  292. 

  293.                 if (offset != -1)

  294.                     *pRetVal = new UIATextRangeProvider (*owner, { offset, offset + textToSearchFor.length() });

  295. 

  296.                 return S_OK;

  297.             });

  298.         }

  299. 

  300.         JUCE_COMRESULT GetAttributeValue (TEXTATTRIBUTEID attributeId, VARIANT* pRetVal) override

  301.         {

  302.             return owner->withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  303.             {

  304.                 VariantHelpers::clear (pRetVal);

  305. 

  306.                 switch (attributeId)

  307.                 {

  308.                     case ComTypes::UIA_IsReadOnlyAttributeId:

  309.                     {

  310.                         VariantHelpers::setBool (textInterface.isReadOnly(), pRetVal);

  311.                         break;

  312.                     }

  313. 

  314.                     case ComTypes::UIA_CaretPositionAttributeId:

  315.                     {

  316.                         auto cursorPos = textInterface.getTextInsertionOffset();

  317. 

  318.                         auto caretPos = [&]

  319.                         {

  320.                             if (cursorPos == 0)

  321.                                 return ComTypes::CaretPosition_BeginningOfLine;

  322. 

  323.                             if (cursorPos == textInterface.getTotalNumCharacters())

  324.                                 return ComTypes::CaretPosition_EndOfLine;

  325. 

  326.                             return ComTypes::CaretPosition_Unknown;

  327.                         }();

  328. 

  329.                         VariantHelpers::setInt (caretPos, pRetVal);

  330.                         break;

  331.                     }

  332.                 }

  333. 

  334.                 return S_OK;

  335.             });

  336.         }

  337. 

  338.         JUCE_COMRESULT GetBoundingRectangles (SAFEARRAY** pRetVal) override

  339.         {

  340.             return owner->withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  341.             {

  342.                 auto rectangleList = textInterface.getTextBounds (selectionRange);

  343.                 auto numRectangles = rectangleList.getNumRectangles();

  344. 

  345.                 *pRetVal = SafeArrayCreateVector (VT_R8, 0, 4 * (ULONG) numRectangles);

  346. 

  347.                 if (*pRetVal == nullptr)

  348.                     return E_FAIL;

  349. 

  350.                 if (numRectangles > 0)

  351.                 {

  352.                     double* doubleArr = nullptr;

  353. 

  354.                     if (FAILED (SafeArrayAccessData (*pRetVal, reinterpret_cast<void**> (&doubleArr))))

  355.                     {

  356.                         SafeArrayDestroy (*pRetVal);

  357.                         return E_FAIL;

  358.                     }

  359. 

  360.                     for (int i = 0; i < numRectangles; ++i)

  361.                     {

  362.                         auto r = Desktop::getInstance().getDisplays().logicalToPhysical (rectangleList.getRectangle (i));

  363. 

  364.                         doubleArr[i * 4]     = r.getX();

  365.                         doubleArr[i * 4 + 1] = r.getY();

  366.                         doubleArr[i * 4 + 2] = r.getWidth();

  367.                         doubleArr[i * 4 + 3] = r.getHeight();

  368.                     }

  369. 

  370.                     if (FAILED (SafeArrayUnaccessData (*pRetVal)))

  371.                     {

  372.                         SafeArrayDestroy (*pRetVal);

  373.                         return E_FAIL;

  374.                     }

  375.                 }

  376. 

  377.                 return S_OK;

  378.             });

  379.         }

  380. 

  381.         JUCE_COMRESULT GetChildren (SAFEARRAY** pRetVal) override

  382.         {

  383.             return withCheckedComArgs (pRetVal, *this, [&]

  384.             {

  385.                 *pRetVal = SafeArrayCreateVector (VT_UNKNOWN, 0, 0);

  386.                 return S_OK;

  387.             });

  388.         }

  389. 

  390.         JUCE_COMRESULT GetEnclosingElement (IRawElementProviderSimple** pRetVal) override

  391.         {

  392.             JUCE_BEGIN_IGNORE_WARNINGS_GCC_LIKE ("-Wlanguage-extension-token")

  393. 

  394.             return withCheckedComArgs (pRetVal, *this, [&]

  395.             {

  396.                 getHandler().getNativeImplementation()->QueryInterface (IID_PPV_ARGS (pRetVal));

  397.                 return S_OK;

  398.             });

  399. 

  400.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  401.         }

  402. 

  403.         JUCE_COMRESULT GetText (int maxLength, BSTR* pRetVal) override

  404.         {

  405.             return owner->withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  406.             {

  407.                 auto text = textInterface.getText (selectionRange);

  408. 

  409.                 if (maxLength >= 0 && text.length() > maxLength)

  410.                     text = text.substring (0, maxLength);

  411. 

  412.                 *pRetVal = SysAllocString ((const OLECHAR*) text.toWideCharPointer());

  413.                 return S_OK;

  414.             });

  415.         }

  416. 

  417.         JUCE_COMRESULT Move (ComTypes::TextUnit unit, int count, int* pRetVal) override

  418.         {

  419.             return owner->withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  420.             {

  421.                 using ATH = AccessibilityTextHelpers;

  422. 

  423.                 const auto boundaryType = getBoundaryType (unit);

  424.                 const auto previousUnitBoundary = ATH::findTextBoundary (textInterface,

  425.                                                                          selectionRange.getStart(),

  426.                                                                          boundaryType,

  427.                                                                          ATH::Direction::backwards,

  428.                                                                          ATH::IncludeThisBoundary::yes,

  429.                                                                          ATH::IncludeWhitespaceAfterWords::no);

  430. 

  431.                 auto numMoved = 0;

  432.                 auto movedEndpoint = previousUnitBoundary;

  433. 

  434.                 for (; numMoved < std::abs (count); ++numMoved)

  435.                 {

  436.                     const auto nextEndpoint = ATH::findTextBoundary (textInterface,

  437.                                                                      movedEndpoint,

  438.                                                                      boundaryType,

  439.                                                                      count > 0 ? ATH::Direction::forwards : ATH::Direction::backwards,

  440.                                                                      ATH::IncludeThisBoundary::no,

  441.                                                                      count > 0 ? ATH::IncludeWhitespaceAfterWords::yes : ATH::IncludeWhitespaceAfterWords::no);

  442. 

  443.                     if (nextEndpoint == movedEndpoint)

  444.                         break;

  445. 

  446.                     movedEndpoint = nextEndpoint;

  447.                 }

  448. 

  449.                 *pRetVal = numMoved;

  450. 

  451.                 ExpandToEnclosingUnit (unit);

  452.                 return S_OK;

  453.             });

  454.         }

  455. 

  456.         JUCE_COMRESULT MoveEndpointByRange (ComTypes::TextPatternRangeEndpoint endpoint,

  457.                                             ComTypes::ITextRangeProvider* targetRange,

  458.                                             ComTypes::TextPatternRangeEndpoint targetEndpoint) override

  459.         {

  460.             if (targetRange == nullptr)

  461.                 return E_INVALIDARG;

  462. 

  463.             if (! isElementValid())

  464.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  465. 

  466.             if (owner->getHandler().getTextInterface() != nullptr)

  467.             {

  468.                 auto otherRange = static_cast<UIATextRangeProvider*> (targetRange)->getSelectionRange();

  469.                 auto targetPoint = (targetEndpoint == ComTypes::TextPatternRangeEndpoint_Start ? otherRange.getStart()

  470.                                                                                                : otherRange.getEnd());

  471. 

  472.                 setEndpointChecked (endpoint, targetPoint);

  473.                 return S_OK;

  474.             }

  475. 

  476.             return (HRESULT) UIA_E_NOTSUPPORTED;

  477.         }

  478. 

  479.         JUCE_COMRESULT MoveEndpointByUnit (ComTypes::TextPatternRangeEndpoint endpoint,

  480.                                            ComTypes::TextUnit unit,

  481.                                            int count,

  482.                                            int* pRetVal) override

  483.         {

  484.             return owner->withTextInterface (pRetVal, [&] (const AccessibilityTextInterface& textInterface)

  485.             {

  486.                 if (count == 0 || textInterface.getTotalNumCharacters() == 0)

  487.                     return S_OK;

  488. 

  489.                 const auto endpointToMove = (endpoint == ComTypes::TextPatternRangeEndpoint_Start ? selectionRange.getStart()

  490.                                                                                                   : selectionRange.getEnd());

  491. 

  492.                 using ATH = AccessibilityTextHelpers;

  493. 

  494.                 const auto direction = (count > 0 ? ATH::Direction::forwards

  495.                                                   : ATH::Direction::backwards);

  496. 

  497.                 const auto boundaryType = getBoundaryType (unit);

  498.                 auto movedEndpoint = endpointToMove;

  499. 

  500.                 int numMoved = 0;

  501.                 for (; numMoved < std::abs (count); ++numMoved)

  502.                 {

  503.                     auto nextEndpoint = ATH::findTextBoundary (textInterface,

  504.                                                                movedEndpoint,

  505.                                                                boundaryType,

  506.                                                                direction,

  507.                                                                ATH::IncludeThisBoundary::no,

  508.                                                                direction == ATH::Direction::forwards ? ATH::IncludeWhitespaceAfterWords::yes

  509.                                                                                                      : ATH::IncludeWhitespaceAfterWords::no);

  510. 

  511.                     if (nextEndpoint == movedEndpoint)

  512.                         break;

  513. 

  514.                     movedEndpoint = nextEndpoint;

  515.                 }

  516. 

  517.                 *pRetVal = numMoved;

  518. 

  519.                 setEndpointChecked (endpoint, movedEndpoint);

  520. 

  521.                 return S_OK;

  522.             });

  523.         }

  524. 

  525.         JUCE_COMRESULT RemoveFromSelection() override

  526.         {

  527.             if (! isElementValid())

  528.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  529. 

  530.             if (auto* textInterface = owner->getHandler().getTextInterface())

  531.             {

  532.                 textInterface->setSelection ({});

  533.                 return S_OK;

  534.             }

  535. 

  536.             return (HRESULT) UIA_E_NOTSUPPORTED;

  537.         }

  538. 

  539.         JUCE_COMRESULT ScrollIntoView (BOOL) override

  540.         {

  541.             if (! isElementValid())

  542.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  543. 

  544.             return (HRESULT) UIA_E_NOTSUPPORTED;

  545.         }

  546. 

  547.         JUCE_COMRESULT Select() override

  548.         {

  549.             if (! isElementValid())

  550.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  551. 

  552.             if (auto* textInterface = owner->getHandler().getTextInterface())

  553.             {

  554.                 textInterface->setSelection ({});

  555.                 textInterface->setSelection (selectionRange);

  556. 

  557.                 return S_OK;

  558.             }

  559. 

  560.             return (HRESULT) UIA_E_NOTSUPPORTED;

  561.         }

  562. 

  563.     private:

  564.         static AccessibilityTextHelpers::BoundaryType getBoundaryType (ComTypes::TextUnit unit)

  565.         {

  566.             switch (unit)

  567.             {

  568.                 case ComTypes::TextUnit_Character:

  569.                     return AccessibilityTextHelpers::BoundaryType::character;

  570. 

  571.                 case ComTypes::TextUnit_Format:

  572.                 case ComTypes::TextUnit_Word:

  573.                     return AccessibilityTextHelpers::BoundaryType::word;

  574. 

  575.                 case ComTypes::TextUnit_Line:

  576.                     return AccessibilityTextHelpers::BoundaryType::line;

  577. 

  578.                 case ComTypes::TextUnit_Paragraph:

  579.                 case ComTypes::TextUnit_Page:

  580.                 case ComTypes::TextUnit_Document:

  581.                     return AccessibilityTextHelpers::BoundaryType::document;

  582.             };

  583. 

  584.             jassertfalse;

  585.             return AccessibilityTextHelpers::BoundaryType::character;

  586.         }

  587. 

  588.         void setEndpointChecked (ComTypes::TextPatternRangeEndpoint endpoint, int newEndpoint)

  589.         {

  590.             if (endpoint == ComTypes::TextPatternRangeEndpoint_Start)

  591.             {

  592.                 if (selectionRange.getEnd() < newEndpoint)

  593.                     selectionRange.setEnd (newEndpoint);

  594. 

  595.                 selectionRange.setStart (newEndpoint);

  596.             }

  597.             else

  598.             {

  599.                 if (selectionRange.getStart() > newEndpoint)

  600.                     selectionRange.setStart (newEndpoint);

  601. 

  602.                 selectionRange.setEnd (newEndpoint);

  603.             }

  604.         }

  605. 

  606.         ComSmartPtr<UIATextProvider> owner;

  607.         Range<int> selectionRange;

  608. 

  609.         //==============================================================================

  610.         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (UIATextRangeProvider)

  611.     };

  612. 

  613.     //==============================================================================

  614.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (UIATextProvider)

  615. };

  616. 

  617. } // namespace juce