| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| ////////////////////////////////////////////////////////////////////// | |
| // AccTextBase.cpp: implementation of the CAccTextBase class. | |
| ////////////////////////////////////////////////////////////////////// | |
| #include "stdafx.h" | |
| #include <string> | |
| #define WNT | |
| #include <com/sun/star/accessibility/AccessibleTextType.hpp> | |
| #include "AccTextBase.h" | |
| #include <com/sun/star/accessibility/XAccessible.hpp> | |
| #include <com/sun/star/accessibility/XAccessibleContext.hpp> | |
| #include <com/sun/star/accessibility/XAccessibleComponent.hpp> | |
| #include <com/sun/star/accessibility/XAccessibleTextSelection.hpp> | |
| #include "MAccessible.h" | |
| using namespace com::sun::star::accessibility; | |
| using namespace com::sun::star::uno; | |
| using namespace rtl; | |
| ////////////////////////////////////////////////////////////////////// | |
| // Construction/Destruction | |
| ////////////////////////////////////////////////////////////////////// | |
| OUString ReplaceFourChar(OUString oldOUString); | |
| CAccTextBase::CAccTextBase() | |
| {} | |
| CAccTextBase::~CAccTextBase() | |
| {} | |
| /** | |
| * Get special selection. | |
| * @param startOffset Start selection offset. | |
| * @param endOffset End selection offset. | |
| * @param success Variant to accept the result of if the method call is successful. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_addSelection(long startOffset, long endOffset) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| // #CHECK XInterface# | |
| if(pUNOInterface == NULL) | |
| return E_FAIL; | |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); | |
| Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); | |
| if( pRExtension.is() ) | |
| { | |
| pRExtension->addSelection(0, startOffset, endOffset); | |
| return S_OK; | |
| } | |
| else | |
| { | |
| GetXInterface()->setSelection(startOffset, endOffset); | |
| return S_OK; | |
| } | |
| return E_FAIL; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get special attributes. | |
| * @param offset Offset. | |
| * @param startOffset Variant to accept start offset. | |
| * @param endOffset Variant to accept end offset. | |
| * @param textAttributes Variant to accept attributes. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_attributes(long offset, long * startOffset, long * endOffset, BSTR * textAttributes) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (startOffset == NULL || endOffset == NULL || textAttributes == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| { | |
| return E_FAIL; | |
| } | |
| if( offset < 0 || offset > GetXInterface()->getCharacterCount() ) | |
| return E_FAIL; | |
| std::wstring strAttrs; | |
| strAttrs += L"Version:1;"; | |
| Sequence< ::com::sun::star::beans::PropertyValue > pValues = GetXInterface()->getCharacterAttributes(offset, Sequence< rtl::OUString >()); | |
| int nCount = pValues.getLength(); | |
| short numberingLevel = 0; | |
| OUString numberingPrefix; | |
| Any anyNumRule; | |
| bool bHaveNumberingPrefixAttr = false; | |
| bool bHaveNumberingLevel = false; | |
| bool bHaveNumberingRules = false; | |
| for(int i =0; i<nCount; i++) | |
| { | |
| ::com::sun::star::beans::PropertyValue &pValue = pValues[i]; | |
| if(pValue.Name.compareTo(OUString::createFromAscii("NumberingLevel"))==0) | |
| { | |
| if (pValue.Value != Any()) | |
| pValue.Value >>= numberingLevel; | |
| else | |
| numberingLevel = -1; | |
| bHaveNumberingLevel = true; | |
| continue; | |
| } | |
| if(pValue.Name.compareTo(OUString::createFromAscii("NumberingPrefix"))==0) | |
| { | |
| pValue.Value >>=numberingPrefix; | |
| bHaveNumberingPrefixAttr = true; | |
| continue; | |
| } | |
| if(pValue.Name.compareTo(OUString::createFromAscii("NumberingRules"))==0) | |
| { | |
| bHaveNumberingRules = true; | |
| anyNumRule = pValue.Value; | |
| continue; | |
| } | |
| if (bHaveNumberingLevel && bHaveNumberingRules && bHaveNumberingPrefixAttr) | |
| { | |
| OLECHAR numProps[512] = {0}; | |
| strAttrs+=L";"; | |
| numberingPrefix = ReplaceFourChar(numberingPrefix); | |
| CMAccessible::get_OLECHAR4Numbering(anyNumRule,numberingLevel,numberingPrefix,numProps); | |
| strAttrs += numProps; | |
| bHaveNumberingLevel = 0; | |
| bHaveNumberingRules = 0; | |
| } | |
| if( (bHaveNumberingPrefixAttr && i > 1 ) || | |
| (!bHaveNumberingPrefixAttr && i > 0 ) ) //element 0 is NumberingPrefix, not write alone | |
| { | |
| strAttrs+=L";"; | |
| } | |
| strAttrs += pValue.Name.getStr(); | |
| strAttrs += L":"; | |
| OLECHAR pTemp[2048] = {0}; | |
| if (pValue.Name.compareTo(OUString::createFromAscii("CharBackColor"))==0 || | |
| pValue.Name.compareTo(OUString::createFromAscii("CharColor"))==0 || | |
| pValue.Name.compareTo(OUString::createFromAscii("CharUnderlineColor"))==0 ) | |
| { | |
| unsigned long nColor; | |
| pValue.Value >>= nColor; | |
| OLECHAR pBuf[64]; | |
| swprintf( pBuf, L"%08X", nColor ); | |
| pTemp[0]=L'#'; | |
| wcscat( pTemp, pBuf ); | |
| } | |
| else | |
| { | |
| CMAccessible::get_OLECHARFromAny(pValue.Value,pTemp); | |
| } | |
| strAttrs +=pTemp; | |
| } | |
| strAttrs +=L";"; | |
| // #CHECK# | |
| if(*textAttributes) | |
| SysFreeString(*textAttributes); | |
| *textAttributes = SysAllocString(strAttrs.c_str()); | |
| if( offset < GetXInterface()->getCharacterCount() ) | |
| { | |
| TextSegment textSeg = GetXInterface()->getTextAtIndex(offset, AccessibleTextType::ATTRIBUTE_RUN); | |
| *startOffset = textSeg.SegmentStart; | |
| *endOffset = textSeg.SegmentEnd; | |
| } | |
| else | |
| { | |
| *startOffset = offset; | |
| *endOffset = offset; | |
| } | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get caret position. | |
| * @param offset Variant to accept caret offset. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_caretOffset(long * offset) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (offset == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| { | |
| *offset = 0; | |
| return S_OK; | |
| } | |
| *offset = GetXInterface()->getCaretPosition(); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get character count. | |
| * @param nCharacters Variant to accept character count. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_characterCount(long * nCharacters) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (nCharacters == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| { | |
| *nCharacters = 0; | |
| return S_OK; | |
| } | |
| *nCharacters = GetXInterface()->getCharacterCount(); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get character extents. | |
| * @param offset Offset. | |
| * @param x Variant to accept x position. | |
| * @param y Variant to accept y position. | |
| * @param width Variant to accept width. | |
| * @param Height Variant to accept height. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_characterExtents(long offset, IA2CoordinateType coordType, long * x, long * y, long * width, long * height) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (x == NULL || height == NULL || y == NULL || width == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| if(offset < 0 || offset > GetXInterface()->getCharacterCount() ) | |
| return E_FAIL; | |
| com::sun::star::awt::Rectangle rectangle; | |
| rectangle = GetXInterface()->getCharacterBounds(offset); | |
| //IA2Point aPoint; | |
| com::sun::star::awt::Point aPoint; | |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); | |
| if( !pRContext.is() ) | |
| { | |
| return E_FAIL; | |
| } | |
| Reference<XAccessibleComponent> pRComp(pRContext,UNO_QUERY); | |
| if( pRComp.is() ) | |
| { | |
| if(coordType == IA2_COORDTYPE_SCREEN_RELATIVE) | |
| { | |
| ::com::sun::star::awt::Point pt = pRComp->getLocationOnScreen(); | |
| aPoint.X = pt.X; | |
| aPoint.Y = pt.Y; | |
| } | |
| else if(coordType == IA2_COORDTYPE_PARENT_RELATIVE) | |
| { | |
| ::com::sun::star::awt::Point pt = pRComp->getLocation(); | |
| aPoint.X = pt.X; | |
| aPoint.Y = pt.Y; | |
| } | |
| } | |
| rectangle.X = rectangle.X + aPoint.X; | |
| rectangle.Y = rectangle.Y + aPoint.Y; | |
| *x = rectangle.X; | |
| *y = rectangle.Y; | |
| // GetXInterface()->getCharacterBounds() have different implement in different acc component | |
| // But we need return the width/height == 1 for every component when offset == text length. | |
| // So we ignore the return result of GetXInterface()->getCharacterBounds() when offset == text length. | |
| if( offset == GetXInterface()->getCharacterCount() ) | |
| { | |
| *width = 1; | |
| *height = 1; | |
| } | |
| else | |
| { | |
| *width = rectangle.Width; | |
| *height = rectangle.Height; | |
| } | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get selections count. | |
| * @param nSelections Variant to accept selections count. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_nSelections(long * nSelections) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (nSelections == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(pUNOInterface == NULL) | |
| { | |
| *nSelections = 0; | |
| return S_OK; | |
| } | |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); | |
| Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); | |
| if( pRExtension.is() ) | |
| { | |
| *nSelections = pRExtension->getSelectedPortionCount(); | |
| return S_OK; | |
| } | |
| long iLength = GetXInterface()->getSelectedText().getLength(); | |
| if( iLength> 0) | |
| { | |
| *nSelections = 1; | |
| return S_OK; | |
| } | |
| *nSelections = 0; | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get offset of some special point. | |
| * @param x X position of one point. | |
| * @param x Y position of one point. | |
| * @param coordType Type. | |
| * @param offset Variant to accept offset. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_offsetAtPoint(long x, long y, IA2CoordinateType, long * offset) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (offset == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| com::sun::star::awt::Point point; | |
| point.X = x; | |
| point.Y = y; | |
| *offset = GetXInterface()->getIndexAtPoint(point); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get selection range. | |
| * @param selection selection count. | |
| * @param startOffset Variant to accept the start offset of special selection. | |
| * @param endOffset Variant to accept the end offset of special selection. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_selection(long selectionIndex, long * startOffset, long * endOffset) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (startOffset == NULL || endOffset == NULL ) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(pUNOInterface == NULL ) | |
| return E_FAIL; | |
| long nSelection = 0; | |
| get_nSelections(&nSelection); | |
| if(selectionIndex >= nSelection || selectionIndex < 0 ) | |
| return E_FAIL; | |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); | |
| Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); | |
| if( pRExtension.is() ) | |
| { | |
| *startOffset = pRExtension->getSeletedPositionStart(selectionIndex); | |
| *endOffset = pRExtension->getSeletedPositionEnd(selectionIndex); | |
| return S_OK; | |
| } | |
| else if(GetXInterface()->getSelectionEnd() > -1) | |
| { | |
| *startOffset = GetXInterface()->getSelectionStart(); | |
| *endOffset = GetXInterface()->getSelectionEnd(); | |
| return S_OK; | |
| } | |
| *startOffset = 0; | |
| *endOffset = 0; | |
| return E_FAIL; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get special text. | |
| * @param startOffset Start position of special range. | |
| * @param endOffset End position of special range. | |
| * @param text Variant to accept the text of special range. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_text(long startOffset, long endOffset, BSTR * text) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (text == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| if (endOffset < -1 || endOffset < startOffset ) | |
| { | |
| return E_FAIL; | |
| } | |
| ::rtl::OUString ouStr; | |
| if (endOffset == -1 ) | |
| { | |
| long nLen=0; | |
| if(SUCCEEDED(get_characterCount(&nLen))) | |
| { | |
| ouStr = GetXInterface()->getTextRange( 0, nLen ); | |
| } | |
| } | |
| else | |
| { | |
| ouStr = GetXInterface()->getTextRange( startOffset, endOffset ); | |
| } | |
| SysFreeString(*text); | |
| *text = SysAllocString((OLECHAR*)ouStr.getStr()); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get special text before some position. | |
| * @param offset Special position. | |
| * @param boundaryType Boundary type. | |
| * @param startOffset Variant to accept the start offset. | |
| * @param endOffset Variant to accept the end offset. | |
| * @param text Variant to accept the special text. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_textBeforeOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| // #CHECK# | |
| if (startOffset == NULL || endOffset == NULL || text == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| // In New UNO IAccessibleText.idl these constant values are defined as follows: | |
| // | |
| // const long TEXT_BOUNDARY_CHAR = -1; | |
| // const long TEXT_BOUNDARY_TO_CURSOR_POS = -2; | |
| // const long TEXT_BOUNDARY_START_OF_WORD = -3; | |
| // const long TEXT_BOUNDARY_END_OF_WORD = -4; | |
| // const long TEXT_BOUNDARY_START_OF_SENTENCE = -5; | |
| // const long TEXT_BOUNDARY_END_OF_SENTENCE = -6; | |
| // const long TEXT_BOUNDARY_START_OF_LINE = -7; | |
| // const long TEXT_BOUNDARY_END_OF_LINE = -8; | |
| // | |
| // In UNO, the corresponding values are as follows: | |
| // | |
| // const short CHARACTER = 1; | |
| // const short WORD = 2; | |
| // const short SENTENCE = 3; | |
| // const short PARAGRAPH = 4; | |
| // const short LINE = 5; | |
| // const short GLYPH = 6; | |
| // const short ATTRIBUTE_RUN = 7; | |
| // | |
| long lUnoBoundaryType; | |
| switch(boundaryType) | |
| { | |
| case IA2_TEXT_BOUNDARY_CHAR: | |
| lUnoBoundaryType = 1; // CHARACTER; | |
| break; | |
| case IA2_TEXT_BOUNDARY_WORD: | |
| lUnoBoundaryType = 2; // WORD; | |
| break; | |
| case IA2_TEXT_BOUNDARY_SENTENCE: | |
| lUnoBoundaryType = 3; // SENTENCE; | |
| break; | |
| case IA2_TEXT_BOUNDARY_LINE: | |
| lUnoBoundaryType = 5; // LINE; | |
| break; | |
| case IA2_TEXT_BOUNDARY_PARAGRAPH: | |
| lUnoBoundaryType = 4; | |
| break; | |
| case IA2_TEXT_BOUNDARY_ALL: | |
| { | |
| long nChar; | |
| get_nCharacters( &nChar ); | |
| *startOffset = 0; | |
| *endOffset = nChar; | |
| return get_text(0, nChar, text); | |
| } | |
| break; | |
| default: | |
| return E_FAIL; | |
| } | |
| TextSegment segment = GetXInterface()->getTextBeforeIndex( offset, sal_Int16(lUnoBoundaryType)); | |
| ::rtl::OUString ouStr = segment.SegmentText; | |
| SysFreeString(*text); | |
| *text = SysAllocString((OLECHAR*)ouStr.getStr()); | |
| *startOffset = segment.SegmentStart; | |
| *endOffset = segment.SegmentEnd; | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get special text after some position. | |
| * @param offset Special position. | |
| * @param boundaryType Boundary type. | |
| * @param startOffset Variant to accept the start offset. | |
| * @param endOffset Variant to accept the end offset. | |
| * @param text Variant to accept the special text. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_textAfterOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (startOffset == NULL || endOffset == NULL || text == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| // In New UNO IAccessibleText.idl these constant values are defined as follows: | |
| // | |
| // const long TEXT_BOUNDARY_CHAR = -1; | |
| // const long TEXT_BOUNDARY_TO_CURSOR_POS = -2; | |
| // const long TEXT_BOUNDARY_START_OF_WORD = -3; | |
| // const long TEXT_BOUNDARY_END_OF_WORD = -4; | |
| // const long TEXT_BOUNDARY_START_OF_SENTENCE = -5; | |
| // const long TEXT_BOUNDARY_END_OF_SENTENCE = -6; | |
| // const long TEXT_BOUNDARY_START_OF_LINE = -7; | |
| // const long TEXT_BOUNDARY_END_OF_LINE = -8; | |
| // | |
| // In UNO, the corresponding values are as follows: | |
| // | |
| // const short CHARACTER = 1; | |
| // const short WORD = 2; | |
| // const short SENTENCE = 3; | |
| // const short PARAGRAPH = 4; | |
| // const short LINE = 5; | |
| // const short GLYPH = 6; | |
| // const short ATTRIBUTE_RUN = 7; | |
| // | |
| long lUnoBoundaryType; | |
| switch(boundaryType) | |
| { | |
| case IA2_TEXT_BOUNDARY_CHAR: | |
| lUnoBoundaryType = 1; // CHARACTER; | |
| break; | |
| case IA2_TEXT_BOUNDARY_WORD: | |
| lUnoBoundaryType = 2; // WORD; | |
| break; | |
| case IA2_TEXT_BOUNDARY_SENTENCE: | |
| lUnoBoundaryType = 3; // SENTENCE; | |
| break; | |
| case IA2_TEXT_BOUNDARY_LINE: | |
| lUnoBoundaryType = 5; // LINE; | |
| break; | |
| case IA2_TEXT_BOUNDARY_PARAGRAPH: | |
| lUnoBoundaryType = 4; | |
| break; | |
| case IA2_TEXT_BOUNDARY_ALL: | |
| { | |
| long nChar; | |
| get_nCharacters( &nChar ); | |
| *startOffset = 0; | |
| *endOffset = nChar; | |
| return get_text(0, nChar, text); | |
| } | |
| break; | |
| default: | |
| return E_FAIL; | |
| } | |
| TextSegment segment = GetXInterface()->getTextBehindIndex( offset, sal_Int16(lUnoBoundaryType)); | |
| ::rtl::OUString ouStr = segment.SegmentText; | |
| SysFreeString(*text); | |
| *text = SysAllocString((OLECHAR*)ouStr.getStr()); | |
| *startOffset = segment.SegmentStart; | |
| *endOffset = segment.SegmentEnd; | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get special text at some position. | |
| * @param offset Special position. | |
| * @param boundaryType Boundary type. | |
| * @param startOffset Variant to accept the start offset. | |
| * @param endOffset Variant to accept the end offset. | |
| * @param text Variant to accept the special text. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_textAtOffset(long offset, IA2TextBoundaryType boundaryType, long * startOffset, long * endOffset, BSTR * text) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (startOffset == NULL || text == NULL ||endOffset == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| // In New UNO IAccessibleText.idl these constant values are defined as follows: | |
| // | |
| // const long TEXT_BOUNDARY_CHAR = -1; | |
| // const long TEXT_BOUNDARY_TO_CURSOR_POS = -2; | |
| // const long TEXT_BOUNDARY_START_OF_WORD = -3; | |
| // const long TEXT_BOUNDARY_END_OF_WORD = -4; | |
| // const long TEXT_BOUNDARY_START_OF_SENTENCE = -5; | |
| // const long TEXT_BOUNDARY_END_OF_SENTENCE = -6; | |
| // const long TEXT_BOUNDARY_START_OF_LINE = -7; | |
| // const long TEXT_BOUNDARY_END_OF_LINE = -8; | |
| // | |
| // In UNO, the corresponding values are as follows: | |
| // | |
| // const short CHARACTER = 1; | |
| // const short WORD = 2; | |
| // const short SENTENCE = 3; | |
| // const short PARAGRAPH = 4; | |
| // const short LINE = 5; | |
| // const short GLYPH = 6; | |
| // const short ATTRIBUTE_RUN = 7; | |
| // | |
| long lUnoBoundaryType; | |
| switch(boundaryType) | |
| { | |
| case IA2_TEXT_BOUNDARY_CHAR: | |
| lUnoBoundaryType = 1; // CHARACTER; | |
| break; | |
| case IA2_TEXT_BOUNDARY_WORD: | |
| lUnoBoundaryType = 2; // WORD; | |
| break; | |
| case IA2_TEXT_BOUNDARY_SENTENCE: | |
| lUnoBoundaryType = 3; // SENTENCE; | |
| break; | |
| case IA2_TEXT_BOUNDARY_LINE: | |
| lUnoBoundaryType = 5; // LINE; | |
| break; | |
| case IA2_TEXT_BOUNDARY_PARAGRAPH: | |
| lUnoBoundaryType = 4; | |
| break; | |
| case IA2_TEXT_BOUNDARY_ALL: | |
| { | |
| long nChar; | |
| get_nCharacters( &nChar ); | |
| *startOffset = 0; | |
| *endOffset = nChar; | |
| return get_text(0, nChar, text); | |
| } | |
| break; | |
| default: | |
| return E_FAIL; | |
| } | |
| TextSegment segment = GetXInterface()->getTextAtIndex( offset, sal_Int16(lUnoBoundaryType)); | |
| ::rtl::OUString ouStr = segment.SegmentText; | |
| SysFreeString(*text); | |
| *text = SysAllocString((OLECHAR*)ouStr.getStr()); | |
| *startOffset = segment.SegmentStart; | |
| *endOffset = segment.SegmentEnd; | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Remove selection. | |
| * @param selectionIndex Special selection index | |
| * @param success Variant to accept the memthod called result. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::removeSelection(long selectionIndex) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| // #CHECK XInterface# | |
| if(pUNOInterface == NULL) | |
| { | |
| return E_FAIL; | |
| } | |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); | |
| Reference< XAccessibleTextSelection > pRExtension(pRContext,UNO_QUERY); | |
| if( pRExtension.is() ) | |
| { | |
| pRExtension->removeSelection(selectionIndex); | |
| return S_OK; | |
| } | |
| else | |
| { | |
| GetXInterface()->setSelection(0, 0); | |
| return S_OK; | |
| } | |
| return E_FAIL; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Set caret position. | |
| * @param offset Special position. | |
| * @param success Variant to accept the memthod called result. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::setCaretOffset(long offset) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| return E_FAIL; | |
| GetXInterface()->setCaretPosition( offset); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Set special selection. | |
| * @param selectionIndex Special selection index. | |
| * @param startOffset start position. | |
| * @param endOffset end position. | |
| * @param success Variant to accept the memthod called result. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::setSelection(long, long startOffset, long endOffset) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| { | |
| return E_FAIL; | |
| } | |
| GetXInterface()->setSelection( startOffset, endOffset ); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Get characters count. | |
| * @param nCharacters Variant to accept the characters count. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::get_nCharacters(long * nCharacters) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| if (nCharacters == NULL) | |
| return E_INVALIDARG; | |
| // #CHECK XInterface# | |
| if(!pRXText.is()) | |
| { | |
| *nCharacters = 0; | |
| return S_OK; | |
| } | |
| *nCharacters = GetXInterface()->getCharacterCount(); | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| // added by qiuhd, 2006/07/03, for direver 07/11 | |
| STDMETHODIMP CAccTextBase::get_newText( IA2TextSegment *) | |
| { | |
| return E_NOTIMPL; | |
| } | |
| STDMETHODIMP CAccTextBase::get_oldText( IA2TextSegment *) | |
| { | |
| return E_NOTIMPL; | |
| } | |
| /** | |
| * Scroll to special sub-string . | |
| * @param startIndex Start index of sub string. | |
| * @param endIndex End index of sub string. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::scrollSubstringToPoint(long, long, IA2CoordinateType, long, long ) | |
| { | |
| ENTER_PROTECTED_BLOCK | |
| return E_NOTIMPL; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| STDMETHODIMP CAccTextBase::scrollSubstringTo(long, long, IA2ScrollType) | |
| { | |
| ENTER_PROTECTED_BLOCK | |
| return E_NOTIMPL; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| /** | |
| * Put UNO interface. | |
| * @param pXInterface UNO interface. | |
| * @return Result. | |
| */ | |
| STDMETHODIMP CAccTextBase::put_XInterface(LONG_PTR pXInterface) | |
| { | |
| CHECK_ENABLE_INF | |
| ENTER_PROTECTED_BLOCK | |
| CUNOXWrapper::put_XInterface(pXInterface); | |
| //special query. | |
| if(pUNOInterface == NULL) | |
| return E_FAIL; | |
| Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext(); | |
| if( !pRContext.is() ) | |
| { | |
| return E_FAIL; | |
| } | |
| Reference<XAccessibleText> pRXI(pRContext,UNO_QUERY); | |
| if( !pRXI.is() ) | |
| pRXText = NULL; | |
| else | |
| pRXText = pRXI; | |
| return S_OK; | |
| LEAVE_PROTECTED_BLOCK | |
| } | |
| OUString ReplaceOneChar(OUString oldOUString, OUString replacedChar, OUString replaceStr) | |
| { | |
| int iReplace = -1; | |
| iReplace = oldOUString.lastIndexOf(replacedChar); | |
| if (iReplace > -1) | |
| { | |
| for(;iReplace>-1;) | |
| { | |
| oldOUString = oldOUString.replaceAt(iReplace,1, replaceStr); | |
| iReplace=oldOUString.lastIndexOf(replacedChar,iReplace); | |
| } | |
| } | |
| return oldOUString; | |
| } | |
| OUString ReplaceFourChar(OUString oldOUString) | |
| { | |
| oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii("\\"),OUString::createFromAscii("\\\\")); | |
| oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii(";"),OUString::createFromAscii("\\;")); | |
| oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii("="),OUString::createFromAscii("\\=")); | |
| oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii(","),OUString::createFromAscii("\\,")); | |
| oldOUString = ReplaceOneChar(oldOUString,OUString::createFromAscii(":"),OUString::createFromAscii("\\:")); | |
| return oldOUString; | |
| } |