winaccessibility/source/UAccCOM/AccEditableText.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 /**
  21  * AccEditableText.cpp : Implementation of CUAccCOMApp and DLL registration.
  22  */
  23 #include "stdafx.h"
  24 #include  <UAccCOM.h>
  25 #include "AccEditableText.h"
  26
  27 #include <vcl/svapp.hxx>
  28 #include <o3tl/char16_t2wchar_t.hxx>
  29
  30 #include <com/sun/star/accessibility/XAccessible.hpp>
  31 #include <com/sun/star/accessibility/XAccessibleContext.hpp>
  32 #include <com/sun/star/accessibility/XAccessibleText.hpp>
  33 #include <com/sun/star/awt/FontSlant.hpp>
  34 #include <com/sun/star/beans/PropertyValue.hpp>
  35 #include <com/sun/star/style/LineSpacing.hpp>
  36 #include <com/sun/star/style/TabStop.hpp>
  37 #include <vector>
  38
  39 using namespace com::sun::star::accessibility;
  40 using namespace com::sun::star::uno;
  41 using namespace com::sun::star::awt;
  42 using namespace com::sun::star::beans;
  43
  44 /**
  45  * Copy a range of text to the clipboard.
  46  *
  47  * @param    startOffset    the start offset of copying.
  48  * @param    endOffset      the end offset of copying.
  49  * @param    success        the boolean result to be returned.
  50  */
  51 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::copyText(long startOffset, long endOffset)
  52 {
  53     SolarMutexGuard g;
  54
  55     try {
  56
  57     if(!pRXEdtTxt.is())
  58     {
  59         return E_FAIL;
  60     }
  61
  62     if ( GetXInterface()->copyText( startOffset, endOffset ) )
  63         return S_OK;
  64
  65     return E_FAIL;
  66
  67     } catch(...) { return E_FAIL; }
  68 }
  69
  70 /**
  71  * Deletes a range of text.
  72  *
  73  * @param    startOffset    the start offset of deleting.
  74  * @param    endOffset      the end offset of deleting.
  75  * @param    success        the boolean result to be returned.
  76  */
  77 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::deleteText(long startOffset, long endOffset)
  78 {
  79     SolarMutexGuard g;
  80
  81     try {
  82
  83     if( !pRXEdtTxt.is() )
  84         return E_FAIL;
  85
  86     if( GetXInterface()->deleteText( startOffset, endOffset ) )
  87         return S_OK;
  88
  89     return E_FAIL;
  90
  91     } catch(...) { return E_FAIL; }
  92 }
  93
  94 /**
  95  * Inserts text at a specified offset.
  96  *
  97  * @param    offset    the offset of inserting.
  98  * @param    text      the text to be inserted.
  99  * @param    success   the boolean result to be returned.
 100  */
 101 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::insertText(long offset, BSTR * text)
 102 {
 103     SolarMutexGuard g;
 104
 105     try {
 106
 107     if (text == nullptr)
 108         return E_INVALIDARG;
 109
 110     if( !pRXEdtTxt.is() )
 111         return E_FAIL;
 112
 113     OUString ouStr(o3tl::toU(*text));
 114
 115     if( GetXInterface()->insertText( ouStr, offset ) )
 116         return S_OK;
 117
 118     return E_FAIL;
 119
 120     } catch(...) { return E_FAIL; }
 121 }
 122
 123 /**
 124  * Cuts a range of text to the clipboard.
 125  *
 126  * @param    startOffset    the start offset of cutting.
 127  * @param    endOffset      the end offset of cutting.
 128  * @param    success        the boolean result to be returned.
 129  */
 130 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::cutText(long startOffset, long endOffset)
 131 {
 132     SolarMutexGuard g;
 133
 134     try {
 135
 136     if( !pRXEdtTxt.is() )
 137         return E_FAIL;
 138
 139     if( GetXInterface()->cutText( startOffset, endOffset ) )
 140         return S_OK;
 141
 142     return E_FAIL;
 143
 144     } catch(...) { return E_FAIL; }
 145 }
 146
 147 /**
 148  * Pastes text from clipboard at specified offset.
 149  *
 150  * @param    offset    the offset of pasting.
 151  * @param    success   the boolean result to be returned.
 152  */
 153 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::pasteText(long offset)
 154 {
 155     SolarMutexGuard g;
 156
 157     try {
 158
 159     if( !pRXEdtTxt.is() )
 160         return E_FAIL;
 161
 162     if( GetXInterface()->pasteText( offset ) )
 163         return S_OK;
 164
 165     return E_FAIL;
 166
 167     } catch(...) { return E_FAIL; }
 168 }
 169
 170 /**
 171  * Replaces range of text with new text.
 172  *
 173  * @param    startOffset    the start offset of replacing.
 174  * @param    endOffset      the end offset of replacing.
 175  * @param    text           the replacing text.
 176  * @param    success        the boolean result to be returned.
 177  */
 178 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::replaceText(long startOffset, long endOffset, BSTR * text)
 179 {
 180     SolarMutexGuard g;
 181
 182     try {
 183
 184     if (text == nullptr)
 185         return E_INVALIDARG;
 186     if( !pRXEdtTxt.is() )
 187         return E_FAIL;
 188
 189     OUString ouStr(o3tl::toU(*text));
 190
 191     if( GetXInterface()->replaceText( startOffset,endOffset, ouStr) )
 192         return S_OK;
 193     return E_FAIL;
 194
 195     } catch(...) { return E_FAIL; }
 196 }
 197
 198 /**
 199  * Sets attributes of range of text.
 200  *
 201  * @param    startOffset    the start offset.
 202  * @param    endOffset      the end offset.
 203  * @param    attributes     the attribute text.
 204  * @param    success        the boolean result to be returned.
 205  */
 206 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::setAttributes(long startOffset, long endOffset, BSTR * attributes)
 207 {
 208     SolarMutexGuard g;
 209
 210     try {
 211
 212     if (attributes == nullptr)
 213         return E_INVALIDARG;
 214     if( !pRXEdtTxt.is() )
 215         return E_FAIL;
 216
 217     OUString ouStr(o3tl::toU(*attributes));
 218
 219     std::vector< OUString > vecAttr;
 220     for (sal_Int32 nIndex {0}; nIndex >= 0; )
 221         vecAttr.push_back(ouStr.getToken(0, ';', nIndex));
 222
 223     Sequence< PropertyValue > beanSeq(vecAttr.size());
 224     auto beanSeqRange = asNonConstRange(beanSeq);
 225     for(std::vector<OUString>::size_type i = 0; i < vecAttr.size(); i ++)
 226     {
 227         OUString attr = vecAttr[i];
 228         sal_Int32 nPos = attr.indexOf(':');
 229         if(nPos > -1)
 230         {
 231             OUString attrName = attr.copy(0, nPos);
 232             OUString attrValue = attr.copy(nPos + 1);
 233             beanSeqRange[i].Name = attrName;
 234             get_AnyFromOLECHAR(attrName, attrValue, beanSeqRange[i].Value);
 235         }
 236     }
 237
 238     if( GetXInterface()->setAttributes( startOffset,endOffset, beanSeq) )
 239         return S_OK;
 240
 241     return E_FAIL;
 242
 243     } catch(...) { return E_FAIL; }
 244 }
 245
 246 /**
 247  * Convert attributes string to Any type.
 248  *
 249  * @param   ouName      the string of attribute name.
 250  * @param   ouValue     the string of attribute value.
 251  * @param   rAny        the Any object to be returned.
 252  */
 253 void CAccEditableText::get_AnyFromOLECHAR(std::u16string_view ouName, const OUString &ouValue, Any &rAny)
 254 {
 255     if(ouName == u"CharBackColor" ||
 256             ouName == u"CharColor" ||
 257             ouName == u"ParaAdjust" ||
 258             ouName == u"ParaFirstLineIndent" ||
 259             ouName == u"ParaLeftMargin" ||
 260             ouName == u"ParaRightMargin" ||
 261             ouName == u"ParaTopMargin" ||
 262             ouName == u"ParaBottomMargin" ||
 263             ouName == u"CharFontPitch" )
 264     {
 265         // Convert to int.
 266         // NOTE: CharFontPitch is not implemented in java file.
 267         sal_Int32 nValue = ouValue.toInt32();
 268         rAny.setValue(&nValue, cppu::UnoType<sal_Int32>::get());
 269     }
 270     else if(ouName == u"CharShadowed" ||
 271             ouName == u"CharContoured" )
 272     {
 273         // Convert to boolean.
 274         rAny <<= ouValue.toBoolean();
 275     }
 276     else if(ouName == u"CharEscapement" ||
 277             ouName == u"CharStrikeout"  ||
 278             ouName == u"CharUnderline" ||
 279             ouName == u"CharFontPitch" )
 280     {
 281         // Convert to short.
 282         short nValue = static_cast<short>(ouValue.toInt32());
 283         rAny.setValue(&nValue, cppu::UnoType<short>::get());
 284     }
 285     else if(ouName == u"CharHeight" ||
 286             ouName == u"CharWeight" )
 287     {
 288         // Convert to float.
 289         float fValue = ouValue.toFloat();
 290         rAny.setValue(&fValue, cppu::UnoType<float>::get());
 291     }
 292     else if(ouName == u"CharFontName" )
 293     {
 294         // Convert to string.
 295         rAny.setValue(&ouValue, cppu::UnoType<OUString>::get());
 296     }
 297     else if(ouName == u"CharPosture" )
 298     {
 299         // Convert to FontSlant.
 300         css::awt::FontSlant fontSlant = static_cast<css::awt::FontSlant>(ouValue.toInt32());
 301         rAny.setValue(&fontSlant, cppu::UnoType<css::awt::FontSlant>::get());
 302     }
 303     else if(ouName == u"ParaTabStops" )
 304     {
 305
 306         // Convert to the Sequence with TabStop element.
 307         std::vector< css::style::TabStop > vecTabStop;
 308         css::style::TabStop tabStop;
 309         OUString ouSubValue;
 310         sal_Int32 pos = 0, posComma = 0;
 311
 312         do
 313         {
 314             // Position.
 315             pos = ouValue.indexOf("Position=", pos);
 316             if(pos != -1)
 317             {
 318                 posComma = ouValue.indexOf(',', pos + 9); // 9 = length of "Position=".
 319                 if(posComma != -1)
 320                 {
 321                     ouSubValue = ouValue.copy(pos + 9, posComma - pos - 9);
 322                     tabStop.Position = ouSubValue.toInt32();
 323                     pos = posComma + 1;
 324
 325                     // TabAlign.
 326                     pos = ouValue.indexOf("TabAlign=", pos);
 327                     if(pos != -1)
 328                     {
 329                         posComma = ouValue.indexOf(',', pos + 9); // 9 = length of "TabAlign=".
 330                         if(posComma != -1)
 331                         {
 332                             ouSubValue = ouValue.copy(pos + 9, posComma - pos - 9);
 333                             tabStop.Alignment = static_cast<css::style::TabAlign>(ouSubValue.toInt32());
 334                             pos = posComma + 1;
 335
 336                             // DecimalChar.
 337                             pos = ouValue.indexOf("DecimalChar=", pos);
 338                             if(pos != -1)
 339                             {
 340                                 posComma = ouValue.indexOf(',', pos + 11); // 11 = length of "TabAlign=".
 341                                 if(posComma != -1)
 342                                 {
 343                                     ouSubValue = ouValue.copy(pos + 11, posComma - pos - 11);
 344                                     tabStop.DecimalChar = ouSubValue.toChar();
 345                                     pos = posComma + 1;
 346
 347                                     // FillChar.
 348                                     pos = ouValue.indexOf("FillChar=", pos);
 349                                     if(pos != -1)
 350                                     {
 351                                         posComma = ouValue.indexOf(',', pos + 9); // 9 = length of "TabAlign=".
 352                                         if(posComma != -1)
 353                                         {
 354                                             ouSubValue = ouValue.copy(pos + 9, posComma - pos - 9);
 355                                             tabStop.DecimalChar = ouSubValue.toChar();
 356                                             pos = posComma + 1;
 357
 358                                             // Complete TabStop element.
 359                                             vecTabStop.push_back(tabStop);
 360                                         }
 361                                         else
 362                                             break;  // No match comma.
 363                                     }
 364                                     else
 365                                         break;  // No match FillChar.
 366                                 }
 367                                 else
 368                                     break;  // No match comma.
 369                             }
 370                             else
 371                                 break;  // No match DecimalChar.
 372                         }
 373                         else
 374                             break;  // No match comma.
 375                     }
 376                     else
 377                         break;  // No match TabAlign.
 378                 }
 379                 else
 380                     break;  // No match comma.
 381             }
 382             else
 383                 break;  // No match Position.
 384         }
 385         while(pos < ouValue.getLength());
 386
 387
 388         // Dump into Sequence.
 389         int iSeqLen = vecTabStop.empty() ? 1 : vecTabStop.size();
 390         Sequence< css::style::TabStop > seqTabStop(iSeqLen);
 391         auto pseqTabStop = seqTabStop.getArray();
 392
 393         if (!vecTabStop.empty())
 394         {
 395             // Dump every element.
 396             for(int i = 0; i < iSeqLen; i ++)
 397             {
 398                 pseqTabStop[i] = vecTabStop[i];
 399             }
 400         }
 401         else
 402         {
 403             // Create default value.
 404             pseqTabStop[0].Position = 0;
 405             pseqTabStop[0].Alignment = css::style::TabAlign_DEFAULT;
 406             pseqTabStop[0].DecimalChar = '.';
 407             pseqTabStop[0].FillChar = ' ';
 408         }
 409
 410         // Assign to Any object.
 411         rAny.setValue(&seqTabStop, cppu::UnoType<Sequence< css::style::TabStop >>::get());
 412     }
 413     else if(ouName == u"ParaLineSpacing" )
 414     {
 415         // Parse value string.
 416         css::style::LineSpacing lineSpacing;
 417         OUString ouSubValue;
 418         sal_Int32 pos = 0, posComma = 0;
 419
 420         pos = ouValue.indexOf("Mode=", pos);
 421         if(pos != -1)
 422         {
 423             posComma = ouValue.indexOf(',', pos + 5); // 5 = length of "Mode=".
 424             if(posComma != -1)
 425             {
 426                 ouSubValue = ouValue.copy(pos + 5, posComma - pos - 5);
 427                 lineSpacing.Mode = static_cast<sal_Int16>(ouSubValue.toInt32());
 428                 pos = posComma + 1;
 429
 430                 pos = ouValue.indexOf("Height=", pos);
 431                 if(pos != -1)
 432                 {
 433                     ouSubValue = ouValue.copy(pos + 7);
 434                     lineSpacing.Height = static_cast<sal_Int16>(ouSubValue.toInt32());
 435                 }
 436                 else
 437                 {
 438                     lineSpacing.Height = sal_Int16(100);    // Default height.
 439                 }
 440             }
 441             else
 442             {
 443                 lineSpacing.Height = sal_Int16(100);    // Default height.
 444             }
 445         }
 446         else
 447         {
 448             // Default Mode and Height.
 449             lineSpacing.Mode = sal_Int16(0);
 450             lineSpacing.Height = sal_Int16(100);    // Default height.
 451         }
 452
 453         // Convert to Any object.
 454         rAny.setValue(&lineSpacing, cppu::UnoType<css::style::LineSpacing>::get());
 455     }
 456     else
 457     {
 458         // Do nothing.
 459         sal_Int32 nDefault = 0;
 460         rAny.setValue(&nDefault, cppu::UnoType<sal_Int32>::get());
 461     }
 462 }
 463
 464 /**
 465  * Override of IUNOXWrapper.
 466  *
 467  * @param    pXInterface    the pointer of UNO interface.
 468  */
 469 COM_DECLSPEC_NOTHROW STDMETHODIMP CAccEditableText::put_XInterface(hyper pXInterface)
 470 {
 471     // internal IUNOXWrapper - no mutex meeded
 472
 473     try {
 474
 475     CUNOXWrapper::put_XInterface(pXInterface);
 476     //special query.
 477     if(pUNOInterface == nullptr)
 478         return E_FAIL;
 479     Reference<XAccessibleContext> pRContext = pUNOInterface->getAccessibleContext();
 480     if( !pRContext.is() )
 481     {
 482         return E_FAIL;
 483     }
 484     Reference<XAccessibleEditableText> pRXI(pRContext,UNO_QUERY);
 485     if( !pRXI.is() )
 486         pRXEdtTxt = nullptr;
 487     else
 488         pRXEdtTxt = pRXI.get();
 489     return S_OK;
 490
 491     } catch(...) { return E_FAIL; }
 492 }
 493
 494 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */