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.
13479 Commits
9 Branches
356MB
Tree: 55a8b2ac12
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '55a8b2ac12'
${ noResults }
JUCE/modules/juce_gui_basics/native/accessibility/juce_win32_UIATextProvider.h

620 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.                 using namespace ComTypes::Constants;

  307. 

  308.                 switch (attributeId)

  309.                 {

  310.                     case UIA_IsReadOnlyAttributeId:

  311.                     {

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

  313.                         break;

  314.                     }

  315. 

  316.                     case UIA_CaretPositionAttributeId:

  317.                     {

  318.                         auto cursorPos = textInterface.getTextInsertionOffset();

  319. 

  320.                         auto caretPos = [&]

  321.                         {

  322.                             if (cursorPos == 0)

  323.                                 return ComTypes::CaretPosition_BeginningOfLine;

  324. 

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

  326.                                 return ComTypes::CaretPosition_EndOfLine;

  327. 

  328.                             return ComTypes::CaretPosition_Unknown;

  329.                         }();

  330. 

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

  332.                         break;

  333.                     }

  334.                 }

  335. 

  336.                 return S_OK;

  337.             });

  338.         }

  339. 

  340.         JUCE_COMRESULT GetBoundingRectangles (SAFEARRAY** pRetVal) override

  341.         {

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

  343.             {

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

  345.                 auto numRectangles = rectangleList.getNumRectangles();

  346. 

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

  348. 

  349.                 if (*pRetVal == nullptr)

  350.                     return E_FAIL;

  351. 

  352.                 if (numRectangles > 0)

  353.                 {

  354.                     double* doubleArr = nullptr;

  355. 

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

  357.                     {

  358.                         SafeArrayDestroy (*pRetVal);

  359.                         return E_FAIL;

  360.                     }

  361. 

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

  363.                     {

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

  365. 

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

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

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

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

  370.                     }

  371. 

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

  373.                     {

  374.                         SafeArrayDestroy (*pRetVal);

  375.                         return E_FAIL;

  376.                     }

  377.                 }

  378. 

  379.                 return S_OK;

  380.             });

  381.         }

  382. 

  383.         JUCE_COMRESULT GetChildren (SAFEARRAY** pRetVal) override

  384.         {

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

  386.             {

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

  388.                 return S_OK;

  389.             });

  390.         }

  391. 

  392.         JUCE_COMRESULT GetEnclosingElement (IRawElementProviderSimple** pRetVal) override

  393.         {

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

  395. 

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

  397.             {

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

  399.                 return S_OK;

  400.             });

  401. 

  402.             JUCE_END_IGNORE_WARNINGS_GCC_LIKE

  403.         }

  404. 

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

  406.         {

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

  408.             {

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

  410. 

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

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

  413. 

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

  415.                 return S_OK;

  416.             });

  417.         }

  418. 

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

  420.         {

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

  422.             {

  423.                 using ATH = AccessibilityTextHelpers;

  424. 

  425.                 const auto boundaryType = getBoundaryType (unit);

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

  427.                                                                          selectionRange.getStart(),

  428.                                                                          boundaryType,

  429.                                                                          ATH::Direction::backwards,

  430.                                                                          ATH::IncludeThisBoundary::yes,

  431.                                                                          ATH::IncludeWhitespaceAfterWords::no);

  432. 

  433.                 auto numMoved = 0;

  434.                 auto movedEndpoint = previousUnitBoundary;

  435. 

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

  437.                 {

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

  439.                                                                      movedEndpoint,

  440.                                                                      boundaryType,

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

  442.                                                                      ATH::IncludeThisBoundary::no,

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

  444. 

  445.                     if (nextEndpoint == movedEndpoint)

  446.                         break;

  447. 

  448.                     movedEndpoint = nextEndpoint;

  449.                 }

  450. 

  451.                 *pRetVal = numMoved;

  452. 

  453.                 ExpandToEnclosingUnit (unit);

  454.                 return S_OK;

  455.             });

  456.         }

  457. 

  458.         JUCE_COMRESULT MoveEndpointByRange (ComTypes::TextPatternRangeEndpoint endpoint,

  459.                                             ComTypes::ITextRangeProvider* targetRange,

  460.                                             ComTypes::TextPatternRangeEndpoint targetEndpoint) override

  461.         {

  462.             if (targetRange == nullptr)

  463.                 return E_INVALIDARG;

  464. 

  465.             if (! isElementValid())

  466.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  467. 

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

  469.             {

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

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

  472.                                                                                                : otherRange.getEnd());

  473. 

  474.                 setEndpointChecked (endpoint, targetPoint);

  475.                 return S_OK;

  476.             }

  477. 

  478.             return (HRESULT) UIA_E_NOTSUPPORTED;

  479.         }

  480. 

  481.         JUCE_COMRESULT MoveEndpointByUnit (ComTypes::TextPatternRangeEndpoint endpoint,

  482.                                            ComTypes::TextUnit unit,

  483.                                            int count,

  484.                                            int* pRetVal) override

  485.         {

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

  487.             {

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

  489.                     return S_OK;

  490. 

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

  492.                                                                                                   : selectionRange.getEnd());

  493. 

  494.                 using ATH = AccessibilityTextHelpers;

  495. 

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

  497.                                                   : ATH::Direction::backwards);

  498. 

  499.                 const auto boundaryType = getBoundaryType (unit);

  500.                 auto movedEndpoint = endpointToMove;

  501. 

  502.                 int numMoved = 0;

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

  504.                 {

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

  506.                                                                movedEndpoint,

  507.                                                                boundaryType,

  508.                                                                direction,

  509.                                                                ATH::IncludeThisBoundary::no,

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

  511.                                                                                                      : ATH::IncludeWhitespaceAfterWords::no);

  512. 

  513.                     if (nextEndpoint == movedEndpoint)

  514.                         break;

  515. 

  516.                     movedEndpoint = nextEndpoint;

  517.                 }

  518. 

  519.                 *pRetVal = numMoved;

  520. 

  521.                 setEndpointChecked (endpoint, movedEndpoint);

  522. 

  523.                 return S_OK;

  524.             });

  525.         }

  526. 

  527.         JUCE_COMRESULT RemoveFromSelection() override

  528.         {

  529.             if (! isElementValid())

  530.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  531. 

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

  533.             {

  534.                 textInterface->setSelection ({});

  535.                 return S_OK;

  536.             }

  537. 

  538.             return (HRESULT) UIA_E_NOTSUPPORTED;

  539.         }

  540. 

  541.         JUCE_COMRESULT ScrollIntoView (BOOL) override

  542.         {

  543.             if (! isElementValid())

  544.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  545. 

  546.             return (HRESULT) UIA_E_NOTSUPPORTED;

  547.         }

  548. 

  549.         JUCE_COMRESULT Select() override

  550.         {

  551.             if (! isElementValid())

  552.                 return (HRESULT) UIA_E_ELEMENTNOTAVAILABLE;

  553. 

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

  555.             {

  556.                 textInterface->setSelection ({});

  557.                 textInterface->setSelection (selectionRange);

  558. 

  559.                 return S_OK;

  560.             }

  561. 

  562.             return (HRESULT) UIA_E_NOTSUPPORTED;

  563.         }

  564. 

  565.     private:

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

  567.         {

  568.             switch (unit)

  569.             {

  570.                 case ComTypes::TextUnit_Character:

  571.                     return AccessibilityTextHelpers::BoundaryType::character;

  572. 

  573.                 case ComTypes::TextUnit_Format:

  574.                 case ComTypes::TextUnit_Word:

  575.                     return AccessibilityTextHelpers::BoundaryType::word;

  576. 

  577.                 case ComTypes::TextUnit_Line:

  578.                     return AccessibilityTextHelpers::BoundaryType::line;

  579. 

  580.                 case ComTypes::TextUnit_Paragraph:

  581.                 case ComTypes::TextUnit_Page:

  582.                 case ComTypes::TextUnit_Document:

  583.                     return AccessibilityTextHelpers::BoundaryType::document;

  584.             };

  585. 

  586.             jassertfalse;

  587.             return AccessibilityTextHelpers::BoundaryType::character;

  588.         }

  589. 

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

  591.         {

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

  593.             {

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

  595.                     selectionRange.setEnd (newEndpoint);

  596. 

  597.                 selectionRange.setStart (newEndpoint);

  598.             }

  599.             else

  600.             {

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

  602.                     selectionRange.setStart (newEndpoint);

  603. 

  604.                 selectionRange.setEnd (newEndpoint);

  605.             }

  606.         }

  607. 

  608.         ComSmartPtr<UIATextProvider> owner;

  609.         Range<int> selectionRange;

  610. 

  611.         //==============================================================================

  612.         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (UIATextRangeProvider)

  613.     };

  614. 

  615.     //==============================================================================

  616.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (UIATextProvider)

  617. };

  618. 

  619. } // namespace juce