editeng/source/uno/unotext2.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <vcl/svapp.hxx>
  30 #include <osl/mutex.hxx>
  31 #include <rtl/instance.hxx>
  32
  33 #include <editeng/eeitem.hxx>
  34 #include <editeng/flditem.hxx>
  35 #include <editeng/unofield.hxx>
  36 #include <editeng/unotext.hxx>
  37 #include <comphelper/serviceinfohelper.hxx>
  38 #include <comphelper/servicehelper.hxx>
  39
  40 using namespace ::rtl;
  41 using namespace ::cppu;
  42 using namespace ::com::sun::star;
  43
  44 // ====================================================================
  45 // SvxUnoTextContentEnumeration
  46 // ====================================================================
  47
  48 SvxUnoTextContentEnumeration::SvxUnoTextContentEnumeration( const SvxUnoTextBase& _rText ) throw()
  49 : mrText( _rText )
  50 {
  51     mxParentText = const_cast<SvxUnoTextBase*>(&_rText);
  52     if( mrText.GetEditSource() )
  53         mpEditSource = mrText.GetEditSource()->Clone();
  54     else
  55         mpEditSource = NULL;
  56     mnNextParagraph = 0;
  57 }
  58
  59 SvxUnoTextContentEnumeration::~SvxUnoTextContentEnumeration() throw()
  60 {
  61     delete mpEditSource;
  62 }
  63
  64 // container::XEnumeration
  65 sal_Bool SAL_CALL SvxUnoTextContentEnumeration::hasMoreElements(void)
  66     throw( uno::RuntimeException )
  67 {
  68     SolarMutexGuard aGuard;
  69     if( mpEditSource && mpEditSource->GetTextForwarder() )
  70         return mnNextParagraph < mpEditSource->GetTextForwarder()->GetParagraphCount();
  71     else
  72         return sal_False;
  73 }
  74
  75 uno::Any SvxUnoTextContentEnumeration::nextElement(void) throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
  76 {
  77     SolarMutexGuard aGuard;
  78
  79     if(!hasMoreElements())
  80         throw container::NoSuchElementException();
  81
  82     SvxUnoTextContent* pContent = 0;
  83
  84     const SvxUnoTextRangeBaseList& rRanges( mpEditSource->getRanges() );
  85     SvxUnoTextRangeBaseList::const_iterator aIter;
  86     for( aIter = rRanges.begin(); (aIter != rRanges.end()) && (pContent == 0); ++aIter )
  87     {
  88         SvxUnoTextContent* pIterContent = dynamic_cast< SvxUnoTextContent* >( (*aIter ) );
  89         if( pIterContent && (pIterContent->mnParagraph == mnNextParagraph) )
  90             pContent = pIterContent;
  91     }
  92
  93     if( pContent == 0 )
  94      pContent = new SvxUnoTextContent( mrText, mnNextParagraph );
  95
  96     mnNextParagraph++;
  97
  98     uno::Reference< text::XTextContent > xRef( pContent );
  99     return uno::makeAny( xRef );
 100 }
 101
 102 // ====================================================================
 103 // class SvxUnoTextContent
 104 // ====================================================================
 105
 106 SvxUnoTextContent::SvxUnoTextContent( const SvxUnoTextBase& rText, sal_uInt16 nPara ) throw()
 107 :       SvxUnoTextContent_Base(rText)
 108 ,   mnParagraph(nPara)
 109 ,   mrParentText(rText)
 110 ,   maDisposeListeners(maDisposeContainerMutex)
 111 ,   mbDisposing( false )
 112 {
 113     mxParentText = const_cast<SvxUnoTextBase*>(&rText);
 114     if( GetEditSource() && GetEditSource()->GetTextForwarder() )
 115         SetSelection( ESelection( mnParagraph,0, mnParagraph, GetEditSource()->GetTextForwarder()->GetTextLen( mnParagraph ) ) );
 116 }
 117
 118 SvxUnoTextContent::SvxUnoTextContent( const SvxUnoTextContent& rContent ) throw()
 119 :       SvxUnoTextContent_Base(rContent)
 120 ,   mrParentText(rContent.mrParentText)
 121 ,   maDisposeListeners(maDisposeContainerMutex)
 122 ,   mbDisposing( false )
 123 {
 124     mxParentText = rContent.mxParentText;
 125     mnParagraph  = rContent.mnParagraph;
 126     SetSelection( rContent.GetSelection() );
 127 }
 128
 129 SvxUnoTextContent::~SvxUnoTextContent() throw()
 130 {
 131 }
 132
 133 // text::XTextRange
 134
 135 uno::Reference< text::XText > SAL_CALL SvxUnoTextContent::getText()
 136     throw(uno::RuntimeException)
 137 {
 138     return mxParentText;
 139 }
 140
 141 // text::XTextContent
 142 void SAL_CALL SvxUnoTextContent::attach( const uno::Reference< text::XTextRange >& )
 143     throw(lang::IllegalArgumentException, uno::RuntimeException)
 144 {
 145 }
 146
 147 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextContent::getAnchor() throw( uno::RuntimeException )
 148 {
 149     return uno::Reference< text::XTextRange >::query( mxParentText );
 150 }
 151
 152 // XComponent
 153
 154 void SAL_CALL SvxUnoTextContent::dispose()
 155     throw(uno::RuntimeException)
 156 {
 157     SolarMutexGuard aGuard;
 158
 159     if( mbDisposing )
 160         return; // catched a recursion
 161
 162     mbDisposing = true;
 163
 164     lang::EventObject aEvt;
 165     aEvt.Source = *(OWeakAggObject*) this;
 166     maDisposeListeners.disposeAndClear(aEvt);
 167
 168     if( mxParentText.is() )
 169         mxParentText->removeTextContent( this );
 170 }
 171
 172 void SAL_CALL SvxUnoTextContent::addEventListener( const uno::Reference< lang::XEventListener >& xListener )
 173     throw(uno::RuntimeException)
 174 {
 175     maDisposeListeners.addInterface(xListener);
 176 }
 177
 178 void SAL_CALL SvxUnoTextContent::removeEventListener( const uno::Reference< lang::XEventListener >& aListener )
 179     throw(uno::RuntimeException)
 180 {
 181    maDisposeListeners.removeInterface(aListener);
 182 }
 183
 184 // XEnumerationAccess
 185
 186 uno::Reference< container::XEnumeration > SAL_CALL SvxUnoTextContent::createEnumeration(  )
 187     throw(uno::RuntimeException)
 188 {
 189     SolarMutexGuard aGuard;
 190
 191     return new SvxUnoTextRangeEnumeration( mrParentText, mnParagraph );
 192 }
 193
 194 // XElementAccess ( container::XEnumerationAccess )
 195
 196 uno::Type SAL_CALL SvxUnoTextContent::getElementType()
 197     throw(uno::RuntimeException)
 198 {
 199     return ::getCppuType((const uno::Reference< text::XTextRange >*)0);
 200 }
 201
 202 sal_Bool SAL_CALL SvxUnoTextContent::hasElements()
 203     throw(uno::RuntimeException)
 204 {
 205     SolarMutexGuard aGuard;
 206
 207     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : NULL;
 208     if( pForwarder )
 209     {
 210         std::vector<sal_uInt16> aPortions;
 211         pForwarder->GetPortions( mnParagraph, aPortions );
 212         return !aPortions.empty();
 213     }
 214     else
 215     {
 216         return 0;
 217     }
 218 }
 219
 220 // XPropertySet
 221
 222 void SAL_CALL SvxUnoTextContent::setPropertyValue( const OUString& aPropertyName, const uno::Any& aValue )
 223     throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 224 {
 225     _setPropertyValue( aPropertyName, aValue, mnParagraph );
 226 }
 227
 228 uno::Any SAL_CALL SvxUnoTextContent::getPropertyValue( const OUString& PropertyName )
 229     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
 230 {
 231     return _getPropertyValue( PropertyName, mnParagraph );
 232 }
 233
 234 // XMultiPropertySet
 235 void SAL_CALL SvxUnoTextContent::setPropertyValues( const uno::Sequence< ::rtl::OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues ) throw (beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 236 {
 237     _setPropertyValues( aPropertyNames, aValues, mnParagraph );
 238 }
 239
 240 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextContent::getPropertyValues( const uno::Sequence< ::rtl::OUString >& aPropertyNames ) throw (uno::RuntimeException)
 241 {
 242     return _getPropertyValues( aPropertyNames, mnParagraph );
 243 }
 244
 245 /*// XTolerantMultiPropertySet
 246 uno::Sequence< beans::SetPropertyTolerantFailed > SAL_CALL SvxUnoTextContent::setPropertyValuesTolerant( const uno::Sequence< ::rtl::OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues ) throw (lang::IllegalArgumentException, uno::RuntimeException)
 247 {
 248     return _setPropertyValuesTolerant(aPropertyNames, aValues, mnParagraph);
 249 }
 250
 251 uno::Sequence< beans::GetPropertyTolerantResult > SAL_CALL SvxUnoTextContent::getPropertyValuesTolerant( const uno::Sequence< ::rtl::OUString >& aPropertyNames ) throw (uno::RuntimeException)
 252 {
 253     return _getPropertyValuesTolerant(aPropertyNames, mnParagraph);
 254 }
 255
 256 uno::Sequence< beans::GetDirectPropertyTolerantResult > SAL_CALL SvxUnoTextContent::getDirectPropertyValuesTolerant( const uno::Sequence< ::rtl::OUString >& aPropertyNames )
 257     throw (uno::RuntimeException)
 258 {
 259     return _getDirectPropertyValuesTolerant(aPropertyNames, mnParagraph);
 260 }*/
 261
 262 // beans::XPropertyState
 263 beans::PropertyState SAL_CALL SvxUnoTextContent::getPropertyState( const OUString& PropertyName )
 264     throw(beans::UnknownPropertyException, uno::RuntimeException)
 265 {
 266     return _getPropertyState( PropertyName, mnParagraph );
 267 }
 268
 269 uno::Sequence< beans::PropertyState > SAL_CALL SvxUnoTextContent::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
 270     throw(beans::UnknownPropertyException, uno::RuntimeException)
 271 {
 272     return _getPropertyStates( aPropertyName, mnParagraph );
 273 }
 274
 275 void SAL_CALL SvxUnoTextContent::setPropertyToDefault( const OUString& PropertyName )
 276     throw(beans::UnknownPropertyException, uno::RuntimeException)
 277 {
 278     _setPropertyToDefault( PropertyName, mnParagraph );
 279 }
 280
 281 // lang::XServiceInfo
 282
 283 OUString SAL_CALL SvxUnoTextContent::getImplementationName()
 284     throw(uno::RuntimeException)
 285 {
 286     return OUString( RTL_CONSTASCII_USTRINGPARAM("SvxUnoTextContent") );
 287 }
 288
 289 uno::Sequence< OUString > SAL_CALL SvxUnoTextContent::getSupportedServiceNames()
 290     throw(uno::RuntimeException)
 291 {
 292     uno::Sequence< OUString > aSeq( SvxUnoTextRangeBase::getSupportedServiceNames() );
 293     comphelper::ServiceInfoHelper::addToSequence( aSeq, 5, "com.sun.star.style.ParagraphProperties",
 294                                                   "com.sun.star.style.ParagraphPropertiesComplex",
 295                                                   "com.sun.star.style.ParagraphPropertiesAsian",
 296                                                   "com.sun.star.text.TextContent",
 297                                                   "com.sun.star.text.Paragraph");
 298     return aSeq;
 299 }
 300
 301 // ====================================================================
 302 //  class SvxUnoTextRangeEnumeration
 303 // ====================================================================
 304
 305 SvxUnoTextRangeEnumeration::SvxUnoTextRangeEnumeration( const SvxUnoTextBase& rText, sal_uInt16 nPara ) throw()
 306 :   mxParentText(  const_cast<SvxUnoTextBase*>(&rText) ),
 307     mrParentText( rText ),
 308     mnParagraph( nPara ),
 309     mnNextPortion( 0 )
 310 {
 311     mpEditSource = rText.GetEditSource() ? rText.GetEditSource()->Clone() : NULL;
 312
 313     if( mpEditSource && mpEditSource->GetTextForwarder() )
 314     {
 315         mpPortions = new std::vector<sal_uInt16>;
 316         mpEditSource->GetTextForwarder()->GetPortions( nPara, *mpPortions );
 317     }
 318     else
 319     {
 320         mpPortions = NULL;
 321     }
 322 }
 323
 324 SvxUnoTextRangeEnumeration::~SvxUnoTextRangeEnumeration() throw()
 325 {
 326     delete mpEditSource;
 327     delete mpPortions;
 328 }
 329
 330 // container::XEnumeration
 331
 332 sal_Bool SAL_CALL SvxUnoTextRangeEnumeration::hasMoreElements()
 333     throw(uno::RuntimeException)
 334 {
 335     SolarMutexGuard aGuard;
 336
 337     return mpPortions && mnNextPortion < mpPortions->size();
 338 }
 339
 340 uno::Any SAL_CALL SvxUnoTextRangeEnumeration::nextElement()
 341     throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
 342 {
 343     SolarMutexGuard aGuard;
 344
 345     if( mpPortions == NULL || mnNextPortion >= mpPortions->size() )
 346         throw container::NoSuchElementException();
 347
 348     sal_uInt16 nStartPos = 0;
 349     if (mnNextPortion > 0)
 350         nStartPos = mpPortions->at(mnNextPortion-1);
 351     sal_uInt16 nEndPos = mpPortions->at(mnNextPortion);
 352     ESelection aSel( mnParagraph, nStartPos, mnParagraph, nEndPos );
 353
 354     uno::Reference< text::XTextRange > xRange;
 355
 356     const SvxUnoTextRangeBaseList& rRanges( mpEditSource->getRanges() );
 357
 358     SvxUnoTextRange* pRange = 0;
 359
 360     SvxUnoTextRangeBaseList::const_iterator aIter;
 361     for( aIter = rRanges.begin(); (aIter != rRanges.end()) && (pRange == 0); ++aIter )
 362     {
 363         SvxUnoTextRange* pIterRange = dynamic_cast< SvxUnoTextRange* >( (*aIter ) );
 364         if( pIterRange && pIterRange->mbPortion && (aSel.IsEqual( pIterRange->maSelection ) ) )
 365             pRange = pIterRange;
 366     }
 367
 368     if( pRange == 0 )
 369     {
 370         pRange = new SvxUnoTextRange( mrParentText, sal_True );
 371         pRange->SetSelection(aSel);
 372     }
 373
 374     xRange = pRange;
 375
 376     mnNextPortion++;
 377
 378     return uno::makeAny( xRange );
 379 }
 380
 381 // ====================================================================
 382 // class SvxUnoTextCursor
 383 // ====================================================================
 384
 385 SvxUnoTextCursor_Base::SvxUnoTextCursor_Base(SvxUnoTextCursor_Base const & base)
 386     throw ():
 387     SvxUnoTextCursor_Base0(base)
 388 {}
 389
 390 SvxUnoTextCursor_Base::SvxUnoTextCursor_Base(SvxUnoTextRangeBase const & base)
 391     throw ():
 392     SvxUnoTextCursor_Base0(base)
 393 {}
 394
 395 SvxUnoTextCursor_Base::~SvxUnoTextCursor_Base() throw () {}
 396
 397 uno::Reference< uno::XInterface > SvxUnoTextCursor_NewInstance()
 398 {
 399     SvxUnoText aText;
 400     uno::Reference< text::XText > xText( (text::XText*)new SvxUnoTextCursor( aText ) );
 401     uno::Reference< uno::XInterface > xInt( xText, uno::UNO_QUERY );
 402     return xInt;
 403 }
 404
 405 SvxUnoTextCursor::SvxUnoTextCursor( const SvxUnoTextBase& rText ) throw()
 406 :       SvxUnoTextCursor_Base(rText),
 407     mxParentText( const_cast<SvxUnoTextBase*>(&rText) )
 408 {
 409 }
 410
 411 SvxUnoTextCursor::SvxUnoTextCursor( const SvxUnoTextCursor& rCursor ) throw()
 412 :       SvxUnoTextCursor_Base(rCursor)
 413 ,   mxParentText(rCursor.mxParentText)
 414 {
 415 }
 416
 417 SvxUnoTextCursor::~SvxUnoTextCursor() throw()
 418 {
 419 }
 420
 421 // text::XTextCursor
 422 void SAL_CALL SvxUnoTextCursor::collapseToStart()
 423     throw(uno::RuntimeException)
 424 {
 425     SolarMutexGuard aGuard;
 426     CollapseToStart();
 427 }
 428
 429 void SAL_CALL SvxUnoTextCursor::collapseToEnd()
 430     throw(uno::RuntimeException)
 431 {
 432     SolarMutexGuard aGuard;
 433     CollapseToEnd();
 434 }
 435
 436 sal_Bool SAL_CALL SvxUnoTextCursor::isCollapsed()
 437     throw(uno::RuntimeException)
 438 {
 439     SolarMutexGuard aGuard;
 440     return IsCollapsed();
 441 }
 442
 443 sal_Bool SAL_CALL SvxUnoTextCursor::goLeft( sal_Int16 nCount, sal_Bool bExpand )
 444     throw(uno::RuntimeException)
 445 {
 446     SolarMutexGuard aGuard;
 447     return GoLeft( nCount, bExpand );
 448 }
 449
 450 sal_Bool SAL_CALL SvxUnoTextCursor::goRight( sal_Int16 nCount, sal_Bool bExpand )
 451     throw(uno::RuntimeException)
 452 {
 453     SolarMutexGuard aGuard;
 454     return GoRight( nCount, bExpand );
 455 }
 456
 457 void SAL_CALL SvxUnoTextCursor::gotoStart( sal_Bool bExpand )
 458     throw(uno::RuntimeException)
 459 {
 460     SolarMutexGuard aGuard;
 461     GotoStart( bExpand );
 462 }
 463
 464 void SAL_CALL SvxUnoTextCursor::gotoEnd( sal_Bool bExpand )
 465     throw(uno::RuntimeException)
 466 {
 467     SolarMutexGuard aGuard;
 468     GotoEnd( bExpand );
 469 }
 470
 471 void SAL_CALL SvxUnoTextCursor::gotoRange( const uno::Reference< text::XTextRange >& xRange, sal_Bool bExpand )
 472     throw(uno::RuntimeException)
 473 {
 474     if( !xRange.is() )
 475         return;
 476
 477     SvxUnoTextRangeBase* pRange = SvxUnoTextRangeBase::getImplementation( xRange );
 478
 479     if( pRange )
 480     {
 481         ESelection aNewSel = pRange->GetSelection();
 482
 483         if( bExpand )
 484         {
 485             const ESelection& rOldSel = GetSelection();
 486             aNewSel.nStartPara = rOldSel.nStartPara;
 487             aNewSel.nStartPos  = rOldSel.nStartPos;
 488         }
 489
 490         SetSelection( aNewSel );
 491     }
 492 }
 493
 494 // text::XTextRange (rest in SvxTextRange)
 495 uno::Reference< text::XText > SAL_CALL SvxUnoTextCursor::getText(void) throw( uno::RuntimeException )
 496 {
 497     return mxParentText;
 498 }
 499
 500 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextCursor::getStart()
 501     throw(uno::RuntimeException)
 502 {
 503     return SvxUnoTextRangeBase::getStart();
 504 }
 505
 506 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextCursor::getEnd()
 507     throw(uno::RuntimeException)
 508 {
 509     return SvxUnoTextRangeBase::getEnd();
 510 }
 511
 512 OUString SAL_CALL SvxUnoTextCursor::getString() throw( uno::RuntimeException )
 513 {
 514     return SvxUnoTextRangeBase::getString();
 515 }
 516
 517 void SAL_CALL SvxUnoTextCursor::setString( const OUString& aString ) throw(uno::RuntimeException)
 518 {
 519     SvxUnoTextRangeBase::setString(aString);
 520 }
 521 // lang::XServiceInfo
 522 OUString SAL_CALL SvxUnoTextCursor::getImplementationName() throw(uno::RuntimeException)
 523 {
 524     return OUString(RTL_CONSTASCII_USTRINGPARAM("SvxUnoTextCursor"));
 525 }
 526
 527 sal_Bool SAL_CALL SvxUnoTextCursor::supportsService( const OUString& ServiceName ) throw(uno::RuntimeException)
 528 {
 529     return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
 530 }
 531
 532 uno::Sequence< OUString > SAL_CALL SvxUnoTextCursor::getSupportedServiceNames() throw(uno::RuntimeException)
 533 {
 534     uno::Sequence< OUString > aSeq( SvxUnoTextRangeBase::getSupportedServiceNames() );
 535     comphelper::ServiceInfoHelper::addToSequence( aSeq, 4,"com.sun.star.style.ParagraphProperties",
 536                                                   "com.sun.star.style.ParagraphPropertiesComplex",
 537                                                   "com.sun.star.style.ParagraphPropertiesAsian",
 538                                                  "com.sun.star.text.TextCursor");
 539     return aSeq;
 540 }
 541
 542
 543 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */