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