svx/source/unoedit/unotext.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: unotext.cxx,v $
  10  * $Revision: 1.66 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33 #include <vcl/svapp.hxx>
  34 #include <com/sun/star/style/LineSpacing.hpp>
  35 #include <com/sun/star/text/ControlCharacter.hpp>
  36 #include <com/sun/star/text/ControlCharacter.hpp>
  37 #ifndef _COM_SUN_STAR_TEXT_XTEXTFIELD_HDL_
  38 #include <com/sun/star/text/XTextField.hdl>
  39 #endif
  40 #include <vos/mutex.hxx>
  41 #include <svtools/itemset.hxx>
  42
  43 #include <svx/eeitem.hxx>
  44 #include <svtools/itempool.hxx>
  45 #include <fontitem.hxx>
  46 #include <svx/tstpitem.hxx>
  47 #include <svx/svdobj.hxx>
  48 #include <svtools/intitem.hxx>
  49
  50 #include <svtools/eitem.hxx>
  51
  52 #include <rtl/uuid.h>
  53 #include <rtl/memory.h>
  54
  55 #include <svx/unoshtxt.hxx>
  56 #include <svx/unoprnms.hxx>
  57 #include <svx/unotext.hxx>
  58 #include <svx/unoedsrc.hxx>
  59 #include <svx/unomid.hxx>
  60 #include "unonrule.hxx"
  61 #include "unofdesc.hxx"
  62 #include "unoapi.hxx"
  63 #include <svx/unofield.hxx>
  64 #include <svx/flditem.hxx>
  65 #include <svx/unoshprp.hxx>
  66 #include <svx/numitem.hxx>
  67 #include <svx/editeng.hxx>
  68
  69 using namespace ::rtl;
  70 using namespace ::vos;
  71 using namespace ::cppu;
  72 using namespace ::com::sun::star;
  73
  74 #define QUERYINT( xint ) \
  75     if( rType == ::getCppuType((const uno::Reference< xint >*)0) ) \
  76         return uno::makeAny(uno::Reference< xint >(this))
  77
  78
  79 extern const SfxItemPropertySet* ImplGetSvxUnoOutlinerTextCursorSfxPropertySet();
  80 const SfxItemPropertyMapEntry* ImplGetSvxTextPortionPropertyMap()
  81 {
  82     // Propertymap fuer einen Outliner Text
  83     static const SfxItemPropertyMapEntry aSvxTextPortionPropertyMap[] =
  84     {
  85         SVX_UNOEDIT_CHAR_PROPERTIES,
  86         SVX_UNOEDIT_FONT_PROPERTIES,
  87         SVX_UNOEDIT_OUTLINER_PROPERTIES,
  88         SVX_UNOEDIT_PARA_PROPERTIES,
  89         {MAP_CHAR_LEN("TextField"),                                             EE_FEATURE_FIELD,       &::getCppuType((const uno::Reference< text::XTextField >*)0),   beans::PropertyAttribute::READONLY, 0 },
  90         {MAP_CHAR_LEN("TextPortionType"),                               WID_PORTIONTYPE,        &::getCppuType((const ::rtl::OUString*)0), beans::PropertyAttribute::READONLY, 0 },
  91         {MAP_CHAR_LEN("TextUserDefinedAttributes"),                     EE_CHAR_XMLATTRIBS,             &::getCppuType((const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameContainer >*)0)  ,            0,     0},
  92         {MAP_CHAR_LEN("ParaUserDefinedAttributes"),                     EE_PARA_XMLATTRIBS,             &::getCppuType((const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameContainer >*)0)  ,            0,     0},
  93         {0,0,0,0,0,0}
  94     };
  95     return aSvxTextPortionPropertyMap;
  96 }
  97 const SvxItemPropertySet* ImplGetSvxTextPortionSvxPropertySet()
  98 {
  99     static SvxItemPropertySet aSvxTextPortionPropertySet( ImplGetSvxTextPortionPropertyMap() );
 100     return &aSvxTextPortionPropertySet;
 101 }
 102
 103 const SfxItemPropertySet* ImplGetSvxTextPortionSfxPropertySet()
 104 {
 105     static SfxItemPropertySet aSvxTextPortionSfxPropertySet( ImplGetSvxTextPortionPropertyMap() );
 106     return &aSvxTextPortionSfxPropertySet;
 107 }
 108
 109 // ====================================================================
 110 // helper fuer Item/Property Konvertierung
 111 // ====================================================================
 112
 113 void GetSelection( struct ESelection& rSel, SvxTextForwarder* pForwarder ) throw()
 114 {
 115     DBG_ASSERT( pForwarder, "I need a valid SvxTextForwarder!" );
 116     if( pForwarder )
 117     {
 118         sal_Int16 nParaCount = pForwarder->GetParagraphCount();
 119         if(nParaCount>0)
 120             nParaCount--;
 121
 122         rSel = ESelection( 0,0, nParaCount, pForwarder->GetTextLen( nParaCount ));
 123     }
 124 }
 125
 126 void CheckSelection( struct ESelection& rSel, SvxTextForwarder* pForwarder ) throw()
 127 {
 128     DBG_ASSERT( pForwarder, "I need a valid SvxTextForwarder!" );
 129     if( pForwarder )
 130     {
 131         if( rSel.nStartPara == 0xffff )
 132         {
 133             ::GetSelection( rSel, pForwarder );
 134         }
 135         else
 136         {
 137             ESelection aMaxSelection;
 138             GetSelection( aMaxSelection, pForwarder );
 139
 140             // check start position
 141             if( rSel.nStartPara < aMaxSelection.nStartPara )
 142             {
 143                 rSel.nStartPara = aMaxSelection.nStartPara;
 144                 rSel.nStartPos = aMaxSelection.nStartPos;
 145             }
 146             else if( rSel.nStartPara > aMaxSelection.nEndPara )
 147             {
 148                 rSel.nStartPara = aMaxSelection.nEndPara;
 149                 rSel.nStartPos = aMaxSelection.nEndPos;
 150             }
 151             else if( rSel.nStartPos  > pForwarder->GetTextLen( rSel.nStartPara ) )
 152             {
 153                 rSel.nStartPos = pForwarder->GetTextLen( rSel.nStartPara );
 154             }
 155
 156             // check end position
 157             if( rSel.nEndPara < aMaxSelection.nStartPara )
 158             {
 159                 rSel.nEndPara = aMaxSelection.nStartPara;
 160                 rSel.nEndPos = aMaxSelection.nStartPos;
 161             }
 162             else if( rSel.nEndPara > aMaxSelection.nEndPara )
 163             {
 164                 rSel.nEndPara = aMaxSelection.nEndPara;
 165                 rSel.nEndPos = aMaxSelection.nEndPos;
 166             }
 167             else if( rSel.nEndPos > pForwarder->GetTextLen( rSel.nEndPara ) )
 168             {
 169                 rSel.nEndPos = pForwarder->GetTextLen( rSel.nEndPara );
 170             }
 171         }
 172     }
 173 }
 174
 175 // ====================================================================
 176 // class SvxUnoTextRangeBase
 177 // ====================================================================
 178
 179 #ifdef DEBUG
 180 class check_me
 181 {
 182 public:
 183     check_me() : mnAllocNum(0) {};
 184     ~check_me();
 185
 186     void add( SvxUnoTextRangeBase* pRange );
 187     void remove( SvxUnoTextRangeBase* pRange );
 188
 189     std::list< std::pair< sal_uInt32, SvxUnoTextRangeBase* > > maRanges;
 190     sal_uInt32 mnAllocNum;
 191 };
 192
 193 void check_me::add( SvxUnoTextRangeBase* pRange )
 194 {
 195     maRanges.push_back( std::pair< sal_uInt32, SvxUnoTextRangeBase* >( mnAllocNum++, pRange ) );
 196 }
 197
 198 void check_me::remove( SvxUnoTextRangeBase* pRange )
 199 {
 200     std::list< std::pair< sal_uInt32, SvxUnoTextRangeBase* > >::iterator aIter;
 201     for( aIter = maRanges.begin(); aIter != maRanges.end(); aIter++ )
 202     {
 203         if( pRange == (*aIter).second )
 204         {
 205             maRanges.erase( aIter );
 206             break;
 207         }
 208     }
 209 }
 210
 211 check_me::~check_me()
 212 {
 213     if( !maRanges.empty() )
 214     {
 215         DBG_ERROR("living text range detected!");
 216         std::list< std::pair< sal_uInt32, SvxUnoTextRangeBase* > >::iterator aIter;
 217         for( aIter = maRanges.begin(); aIter != maRanges.end(); aIter++ )
 218         {
 219             sal_Int32 nAllocNum;
 220             SvxUnoTextRangeBase* pRange;
 221             nAllocNum = (*aIter).first;
 222             pRange = (*aIter).second;
 223         }
 224     }
 225 }
 226
 227 static check_me gNumRanges;
 228 #endif
 229
 230 UNO3_GETIMPLEMENTATION_IMPL( SvxUnoTextRangeBase );
 231
 232 SvxUnoTextRangeBase::SvxUnoTextRangeBase( const SvxItemPropertySet* _pSet ) throw()
 233 : mpEditSource(NULL) , mpPropSet(_pSet)
 234 {
 235 #ifdef DEBUG
 236     gNumRanges.add(this);
 237 #endif
 238 }
 239
 240 SvxUnoTextRangeBase::SvxUnoTextRangeBase( const SvxEditSource* pSource, const SvxItemPropertySet* _pSet ) throw()
 241 : mpPropSet(_pSet)
 242 {
 243     OGuard aGuard( Application::GetSolarMutex() );
 244
 245     DBG_ASSERT(pSource,"SvxUnoTextRangeBase: I need a valid SvxEditSource!");
 246
 247     mpEditSource = pSource->Clone();
 248     ESelection aSelection;
 249     ::GetSelection( aSelection, mpEditSource->GetTextForwarder() );
 250     SetSelection( aSelection );
 251
 252     if( mpEditSource )
 253         mpEditSource->addRange( this );
 254 #ifdef DEBUG
 255     gNumRanges.add(this);
 256 #endif
 257 }
 258
 259 SvxUnoTextRangeBase::SvxUnoTextRangeBase( const SvxUnoTextRangeBase& rRange ) throw()
 260 :       text::XTextRange()
 261 ,       beans::XPropertySet()
 262 ,       beans::XMultiPropertySet()
 263 ,   beans::XMultiPropertyStates()
 264 ,       beans::XPropertyState()
 265 ,       lang::XServiceInfo()
 266 ,       text::XTextRangeCompare()
 267 ,       lang::XUnoTunnel()
 268 ,       mpPropSet(rRange.getPropertySet())
 269 {
 270     OGuard aGuard( Application::GetSolarMutex() );
 271
 272     mpEditSource = rRange.mpEditSource ? rRange.mpEditSource->Clone() : NULL;
 273
 274     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 275     if( pForwarder )
 276     {
 277         maSelection  = rRange.maSelection;
 278         CheckSelection( maSelection, pForwarder );
 279     }
 280
 281     if( mpEditSource )
 282         mpEditSource->addRange( this );
 283
 284 #ifdef DEBUG
 285     gNumRanges.add(this);
 286 #endif
 287 }
 288
 289 SvxUnoTextRangeBase::~SvxUnoTextRangeBase() throw()
 290 {
 291 #ifdef DEBUG
 292     gNumRanges.remove(this);
 293 #endif
 294
 295     if( mpEditSource )
 296         mpEditSource->removeRange( this );
 297
 298     delete mpEditSource;
 299 }
 300
 301 void SvxUnoTextRangeBase::SetEditSource( SvxEditSource* pSource ) throw()
 302 {
 303     DBG_ASSERT(pSource,"SvxUnoTextRangeBase: I need a valid SvxEditSource!");
 304     DBG_ASSERT(mpEditSource==NULL,"SvxUnoTextRangeBase::SetEditSource called while SvxEditSource already set" );
 305
 306     mpEditSource = pSource;
 307
 308     maSelection.nStartPara = 0xffff;
 309
 310     if( mpEditSource )
 311         mpEditSource->addRange( this );
 312 }
 313
 314 /** puts a field item with a copy of the given FieldData into the itemset
 315     corresponding with this range */
 316 void SvxUnoTextRangeBase::attachField( const SvxFieldData* pData ) throw()
 317 {
 318     OGuard aGuard( Application::GetSolarMutex() );
 319
 320     if( pData )
 321     {
 322         SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 323         if( pForwarder )
 324         {
 325             SvxFieldItem aField( *pData, EE_FEATURE_FIELD );
 326             pForwarder->QuickInsertField( aField, maSelection );
 327         }
 328     }
 329 }
 330
 331 void SvxUnoTextRangeBase::SetSelection( const ESelection& rSelection ) throw()
 332 {
 333     OGuard aGuard( Application::GetSolarMutex() );
 334
 335     maSelection = rSelection;
 336     CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
 337 }
 338
 339 // Interface XTextRange ( XText )
 340
 341 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextRangeBase::getStart(void)
 342     throw( uno::RuntimeException )
 343 {
 344     OGuard aGuard( Application::GetSolarMutex() );
 345
 346     uno::Reference< text::XTextRange > xRange;
 347
 348     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 349     if( pForwarder )
 350     {
 351
 352         CheckSelection( maSelection, pForwarder );
 353
 354         SvxUnoTextBase* pText = SvxUnoTextBase::getImplementation( getText() );
 355
 356         if(pText == NULL)
 357             throw uno::RuntimeException();
 358
 359         SvxUnoTextRange* pRange = new SvxUnoTextRange( *pText );
 360         xRange = pRange;
 361
 362         ESelection aNewSel = maSelection;
 363         aNewSel.nEndPara = aNewSel.nStartPara;
 364         aNewSel.nEndPos  = aNewSel.nStartPos;
 365         pRange->SetSelection( aNewSel );
 366     }
 367
 368     return xRange;
 369 }
 370
 371 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextRangeBase::getEnd(void)
 372     throw( uno::RuntimeException )
 373 {
 374     OGuard aGuard( Application::GetSolarMutex() );
 375
 376     uno::Reference< text::XTextRange > xRet;
 377
 378     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 379     if( pForwarder )
 380     {
 381         CheckSelection( maSelection, pForwarder );
 382
 383         SvxUnoTextBase* pText = SvxUnoTextBase::getImplementation( getText() );
 384
 385         if(pText == NULL)
 386             throw uno::RuntimeException();
 387
 388         SvxUnoTextRange* pNew = new SvxUnoTextRange( *pText );
 389         xRet = pNew;
 390
 391         ESelection aNewSel = maSelection;
 392         aNewSel.nStartPara = aNewSel.nEndPara;
 393         aNewSel.nStartPos  = aNewSel.nEndPos;
 394         pNew->SetSelection( aNewSel );
 395     }
 396     return xRet;
 397 }
 398
 399 OUString SAL_CALL SvxUnoTextRangeBase::getString(void)
 400     throw( uno::RuntimeException )
 401 {
 402     OGuard aGuard( Application::GetSolarMutex() );
 403
 404     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 405     if( pForwarder )
 406     {
 407         CheckSelection( maSelection, pForwarder );
 408
 409         return pForwarder->GetText( maSelection );
 410     }
 411     else
 412     {
 413         const OUString aEmpty;
 414         return aEmpty;
 415     }
 416 }
 417
 418 void SAL_CALL SvxUnoTextRangeBase::setString(const OUString& aString)
 419     throw( uno::RuntimeException )
 420 {
 421     OGuard aGuard( Application::GetSolarMutex() );
 422
 423     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 424     if( pForwarder )
 425     {
 426         CheckSelection( maSelection, pForwarder );
 427
 428         String aConverted( aString );
 429         aConverted.ConvertLineEnd( LINEEND_LF );                // Zeilenenden nur einfach zaehlen
 430
 431         pForwarder->QuickInsertText( aConverted, maSelection );
 432         mpEditSource->UpdateData();
 433
 434         //      Selektion anpassen
 435         //!     Wenn die EditEngine bei QuickInsertText die Selektion zurueckgeben wuerde,
 436         //!     waer's einfacher...
 437         CollapseToStart();
 438
 439         sal_uInt16 nLen = aConverted.Len();
 440         if (nLen)
 441             GoRight( nLen, sal_True );
 442     }
 443 }
 444
 445 // Interface beans::XPropertySet
 446 uno::Reference< beans::XPropertySetInfo > SAL_CALL SvxUnoTextRangeBase::getPropertySetInfo(void)
 447     throw( uno::RuntimeException )
 448 {
 449     return mpPropSet->getPropertySetInfo();
 450 }
 451
 452 void SAL_CALL SvxUnoTextRangeBase::setPropertyValue(const OUString& PropertyName, const uno::Any& aValue)
 453     throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException )
 454 {
 455     _setPropertyValue( PropertyName, aValue, -1 );
 456 }
 457
 458 void SAL_CALL SvxUnoTextRangeBase::_setPropertyValue( const OUString& PropertyName, const uno::Any& aValue, sal_Int32 nPara )
 459     throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException )
 460 {
 461     OGuard aGuard( Application::GetSolarMutex() );
 462
 463     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 464     if( pForwarder )
 465     {
 466
 467         CheckSelection( maSelection, pForwarder );
 468
 469         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName );
 470         if ( pMap )
 471         {
 472             ESelection aSel( GetSelection() );
 473             sal_Bool bParaAttrib = (pMap->nWID >= EE_PARA_START) && ( pMap->nWID <= EE_PARA_END );
 474
 475             if( nPara == -1 && !bParaAttrib )
 476             {
 477                 SfxItemSet aOldSet( pForwarder->GetAttribs( aSel ) );
 478                 // we have a selection and no para attribute
 479                 SfxItemSet aNewSet( *aOldSet.GetPool(), aOldSet.GetRanges() );
 480
 481                 setPropertyValue( pMap, aValue, maSelection, aOldSet, aNewSet );
 482
 483
 484                 pForwarder->QuickSetAttribs( aNewSet, GetSelection() );
 485             }
 486             else
 487             {
 488                 sal_Int32 nEndPara;
 489
 490                 if( nPara == -1 )
 491                 {
 492                     nPara = aSel.nStartPara;
 493                     nEndPara = aSel.nEndPara;
 494                 }
 495                 else
 496                 {
 497                     // only one paragraph
 498                     nEndPara = nPara;
 499                 }
 500
 501                 while( nPara <= nEndPara )
 502                 {
 503                     // we have a paragraph
 504                     SfxItemSet aSet( pForwarder->GetParaAttribs( (USHORT)nPara ) );
 505                     setPropertyValue( pMap, aValue, maSelection, aSet, aSet );
 506                     pForwarder->SetParaAttribs( (USHORT)nPara, aSet );
 507                     nPara++;
 508                 }
 509             }
 510
 511             GetEditSource()->UpdateData();
 512             return;
 513         }
 514     }
 515
 516     throw beans::UnknownPropertyException();
 517 }
 518
 519 void SvxUnoTextRangeBase::setPropertyValue( const SfxItemPropertySimpleEntry* pMap, const uno::Any& rValue, const ESelection& rSelection, const SfxItemSet& rOldSet, SfxItemSet& rNewSet ) throw( beans::UnknownPropertyException, lang::IllegalArgumentException )
 520 {
 521     if(!SetPropertyValueHelper( rOldSet, pMap, rValue, rNewSet, &rSelection, (SvxTextEditSource*)GetEditSource() ))
 522     {
 523         //      Fuer Teile von zusammengesetzten Items mit mehreren Properties (z.B. Hintergrund)
 524         //      muss vorher das alte Item aus dem Dokument geholt werden
 525         rNewSet.Put(rOldSet.Get(pMap->nWID));                   // altes Item in neuen Set
 526         mpPropSet->setPropertyValue(pMap, rValue, rNewSet);
 527     }
 528 }
 529
 530 sal_Bool SvxUnoTextRangeBase::SetPropertyValueHelper( const SfxItemSet&, const SfxItemPropertySimpleEntry* pMap, const uno::Any& aValue, SfxItemSet& rNewSet, const ESelection* pSelection /* = NULL */, SvxTextEditSource* pEditSource /* = NULL*/ ) throw( uno::RuntimeException )
 531 {
 532     switch( pMap->nWID )
 533     {
 534     case WID_FONTDESC:
 535         {
 536             awt::FontDescriptor aDesc;
 537             if(aValue >>= aDesc)
 538             {
 539                 SvxUnoFontDescriptor::FillItemSet( aDesc, rNewSet );
 540                 return sal_True;
 541             }
 542         }
 543         break;
 544
 545     case EE_PARA_NUMBULLET:
 546         {
 547             uno::Reference< container::XIndexReplace > xRule;
 548             if( !aValue.hasValue() || ((aValue >>= xRule) && !xRule.is()) )
 549                 return sal_True;
 550
 551             return sal_False;
 552         }
 553
 554     case WID_NUMLEVEL:
 555         {
 556             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : NULL;
 557             if(pForwarder && pSelection)
 558             {
 559                 sal_Int16 nLevel = sal_Int16();
 560                 if( aValue >>= nLevel )
 561                 {
 562                     // #101004# Call interface method instead of unsafe cast
 563                     if(! pForwarder->SetDepth( pSelection->nStartPara, nLevel ) )
 564                         throw lang::IllegalArgumentException();
 565
 566                     return sal_True;
 567                 }
 568             }
 569         }
 570         break;
 571     case WID_NUMBERINGSTARTVALUE:
 572         {
 573             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : NULL;
 574             if(pForwarder && pSelection)
 575             {
 576                 sal_Int16 nStartValue = -1;
 577                 if( aValue >>= nStartValue )
 578                 {
 579                     pForwarder->SetNumberingStartValue( pSelection->nStartPara, nStartValue );
 580                     return sal_True;
 581                 }
 582             }
 583         }
 584         break;
 585     case WID_PARAISNUMBERINGRESTART:
 586         {
 587             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : NULL;
 588             if(pForwarder && pSelection)
 589             {
 590                 sal_Bool bParaIsNumberingRestart = sal_False;
 591                 if( aValue >>= bParaIsNumberingRestart )
 592                 {
 593                     pForwarder->SetParaIsNumberingRestart( pSelection->nStartPara, bParaIsNumberingRestart );
 594                     return sal_True;
 595                 }
 596             }
 597         }
 598         break;
 599     case EE_PARA_BULLETSTATE:
 600         {
 601             sal_Bool bBullet = sal_True;
 602             if( aValue >>= bBullet )
 603             {
 604                 SfxBoolItem aItem( EE_PARA_BULLETSTATE, bBullet );
 605                 rNewSet.Put(aItem);
 606                 return sal_True;
 607             }
 608         }
 609         break;
 610
 611     default:
 612         return sal_False;
 613     }
 614
 615     throw lang::IllegalArgumentException();
 616 }
 617
 618 uno::Any SAL_CALL SvxUnoTextRangeBase::getPropertyValue(const OUString& PropertyName)
 619     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
 620 {
 621     return _getPropertyValue( PropertyName, -1 );
 622 }
 623
 624 uno::Any SAL_CALL SvxUnoTextRangeBase::_getPropertyValue(const OUString& PropertyName, sal_Int32 nPara )
 625     throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
 626 {
 627     OGuard aGuard( Application::GetSolarMutex() );
 628
 629     uno::Any aAny;
 630
 631     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 632     if( pForwarder )
 633     {
 634         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry(PropertyName );
 635         if( pMap )
 636         {
 637             SfxItemSet* pAttribs = NULL;
 638             if( nPara != -1 )
 639                 pAttribs = pForwarder->GetParaAttribs( (USHORT)nPara ).Clone();
 640             else
 641                 pAttribs = pForwarder->GetAttribs( GetSelection() ).Clone();
 642
 643             //  Dontcare durch Default ersetzen, damit man immer eine Reflection hat
 644             pAttribs->ClearInvalidItems();
 645
 646             getPropertyValue( pMap, aAny, *pAttribs );
 647
 648             delete pAttribs;
 649             return aAny;
 650         }
 651     }
 652
 653     throw beans::UnknownPropertyException();
 654 }
 655
 656 void SvxUnoTextRangeBase::getPropertyValue( const SfxItemPropertySimpleEntry* pMap, uno::Any& rAny, const SfxItemSet& rSet ) throw( beans::UnknownPropertyException )
 657 {
 658     switch( pMap->nWID )
 659     {
 660     case EE_FEATURE_FIELD:
 661         if ( rSet.GetItemState( EE_FEATURE_FIELD, sal_False ) == SFX_ITEM_SET )
 662         {
 663             SvxFieldItem* pItem = (SvxFieldItem*)rSet.GetItem( EE_FEATURE_FIELD );
 664             const SvxFieldData* pData = pItem->GetField();
 665             uno::Reference< text::XTextRange > xAnchor( this );
 666
 667             // get presentation string for field
 668             Color* pTColor = NULL;
 669             Color* pFColor = NULL;
 670
 671             SvxTextForwarder* pForwarder = mpEditSource->GetTextForwarder();
 672             OUString aPresentation( pForwarder->CalcFieldValue( SvxFieldItem(*pData, EE_FEATURE_FIELD), maSelection.nStartPara, maSelection.nStartPos, pTColor, pFColor ) );
 673
 674             delete pTColor;
 675             delete pFColor;
 676
 677             uno::Reference< text::XTextField > xField( new SvxUnoTextField( xAnchor, aPresentation, pData ) );
 678             rAny <<= xField;
 679         }
 680         break;
 681
 682     case WID_PORTIONTYPE:
 683         if ( rSet.GetItemState( EE_FEATURE_FIELD, sal_False ) == SFX_ITEM_SET )
 684         {
 685             OUString aType( RTL_CONSTASCII_USTRINGPARAM("TextField") );
 686             rAny <<= aType;
 687         }
 688         else
 689         {
 690             OUString aType( RTL_CONSTASCII_USTRINGPARAM("Text") );
 691             rAny <<= aType;
 692         }
 693         break;
 694
 695     default:
 696         if(!GetPropertyValueHelper( *((SfxItemSet*)(&rSet)), pMap, rAny, &maSelection, (SvxTextEditSource*)GetEditSource() ))
 697             rAny = mpPropSet->getPropertyValue(pMap, rSet);
 698     }
 699 }
 700
 701 sal_Bool SvxUnoTextRangeBase::GetPropertyValueHelper(  SfxItemSet& rSet, const SfxItemPropertySimpleEntry* pMap, uno::Any& aAny, const ESelection* pSelection /* = NULL */, SvxTextEditSource* pEditSource /* = NULL */ )
 702     throw( uno::RuntimeException )
 703 {
 704     switch( pMap->nWID )
 705     {
 706     case WID_FONTDESC:
 707         {
 708             awt::FontDescriptor aDesc;
 709             SvxUnoFontDescriptor::FillFromItemSet( rSet, aDesc );
 710             aAny <<= aDesc;
 711         }
 712         break;
 713
 714     case EE_PARA_NUMBULLET:
 715         {
 716             if((rSet.GetItemState( EE_PARA_NUMBULLET, sal_True ) & (SFX_ITEM_SET|SFX_ITEM_DEFAULT)) == 0)
 717                 throw uno::RuntimeException();
 718
 719             SvxNumBulletItem* pBulletItem = (SvxNumBulletItem*)rSet.GetItem( EE_PARA_NUMBULLET, sal_True );
 720
 721             if( pBulletItem == NULL )
 722                 throw uno::RuntimeException();
 723
 724             aAny <<= SvxCreateNumRule( pBulletItem->GetNumRule() );
 725         }
 726         break;
 727
 728     case WID_NUMLEVEL:
 729         {
 730             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : NULL;
 731             if(pForwarder && pSelection)
 732             {
 733                 sal_Int16 nLevel = pForwarder->GetDepth( pSelection->nStartPara );
 734                 if( nLevel >= 0 )
 735                     aAny <<= nLevel;
 736             }
 737         }
 738         break;
 739     case WID_NUMBERINGSTARTVALUE:
 740         {
 741             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : NULL;
 742             if(pForwarder && pSelection)
 743                 aAny <<= pForwarder->GetNumberingStartValue( pSelection->nStartPara );
 744         }
 745         break;
 746     case WID_PARAISNUMBERINGRESTART:
 747         {
 748             SvxTextForwarder* pForwarder = pEditSource? pEditSource->GetTextForwarder() : NULL;
 749             if(pForwarder && pSelection)
 750                 aAny <<= pForwarder->IsParaIsNumberingRestart( pSelection->nStartPara );
 751         }
 752         break;
 753
 754     case EE_PARA_BULLETSTATE:
 755         {
 756             sal_Bool bState = sal_False;
 757             if( rSet.GetItemState( EE_PARA_BULLETSTATE, sal_True ) & (SFX_ITEM_SET|SFX_ITEM_DEFAULT))
 758             {
 759                 SfxBoolItem* pItem = (SfxBoolItem*)rSet.GetItem( EE_PARA_BULLETSTATE, sal_True );
 760                 bState = pItem->GetValue() ? sal_True : sal_False;
 761             }
 762
 763             aAny <<= bState;
 764         }
 765         break;
 766     default:
 767
 768         return sal_False;
 769     }
 770
 771     return sal_True;
 772 }
 773
 774 // wird (noch) nicht unterstuetzt
 775 void SAL_CALL SvxUnoTextRangeBase::addPropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 776 void SAL_CALL SvxUnoTextRangeBase::removePropertyChangeListener( const OUString& , const uno::Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 777 void SAL_CALL SvxUnoTextRangeBase::addVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 778 void SAL_CALL SvxUnoTextRangeBase::removeVetoableChangeListener( const OUString& , const uno::Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
 779
 780 // XMultiPropertySet
 781 void SAL_CALL SvxUnoTextRangeBase::setPropertyValues( const uno::Sequence< ::rtl::OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues ) throw (beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 782 {
 783     _setPropertyValues( aPropertyNames, aValues, -1 );
 784 }
 785
 786 void SAL_CALL SvxUnoTextRangeBase::_setPropertyValues( const uno::Sequence< ::rtl::OUString >& aPropertyNames, const uno::Sequence< uno::Any >& aValues, sal_Int32 nPara ) throw (beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
 787 {
 788     OGuard aGuard( Application::GetSolarMutex() );
 789
 790     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 791     if( pForwarder )
 792     {
 793         CheckSelection( maSelection, pForwarder );
 794
 795         ESelection aSel( GetSelection() );
 796
 797         const OUString* pPropertyNames = aPropertyNames.getConstArray();
 798         const uno::Any* pValues = aValues.getConstArray();
 799         sal_Int32 nCount = aPropertyNames.getLength();
 800
 801         sal_Int32 nEndPara = nPara;
 802         sal_Int32 nTempPara = nPara;
 803
 804         if( nTempPara == -1 )
 805         {
 806             nTempPara = aSel.nStartPara;
 807             nEndPara = aSel.nEndPara;
 808         }
 809
 810         SfxItemSet* pOldAttrSet = NULL;
 811         SfxItemSet* pNewAttrSet = NULL;
 812
 813         SfxItemSet* pOldParaSet = NULL;
 814         SfxItemSet* pNewParaSet = NULL;
 815
 816         for( ; nCount; nCount--, pPropertyNames++, pValues++ )
 817         {
 818             const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( *pPropertyNames );
 819
 820             if( pMap )
 821             {
 822                 sal_Bool bParaAttrib = (pMap->nWID >= EE_PARA_START) && ( pMap->nWID <= EE_PARA_END );
 823
 824                 if( (nPara == -1) && !bParaAttrib )
 825                 {
 826                     if( NULL == pNewAttrSet )
 827                     {
 828                         const SfxItemSet aSet( pForwarder->GetAttribs( aSel ) );
 829                         pOldAttrSet = new SfxItemSet( aSet );
 830                         pNewAttrSet = new SfxItemSet( *pOldAttrSet->GetPool(), pOldAttrSet->GetRanges() );
 831                     }
 832
 833                     setPropertyValue( pMap, *pValues, GetSelection(), *pOldAttrSet, *pNewAttrSet );
 834
 835                     if( pMap->nWID >= EE_ITEMS_START && pMap->nWID <= EE_ITEMS_END )
 836                     {
 837                         const SfxPoolItem* pItem;
 838                         if( pNewAttrSet->GetItemState( pMap->nWID, sal_True, &pItem ) == SFX_ITEM_SET )
 839                         {
 840                             pOldAttrSet->Put( *pItem );
 841                         }
 842                     }
 843                 }
 844                 else
 845                 {
 846                     if( NULL == pNewParaSet )
 847                     {
 848                         const SfxItemSet aSet( pForwarder->GetParaAttribs( (USHORT)nTempPara ) );
 849                         pOldParaSet = new SfxItemSet( aSet );
 850                         pNewParaSet = new SfxItemSet( *pOldParaSet->GetPool(), pOldParaSet->GetRanges() );
 851                     }
 852
 853                     setPropertyValue( pMap, *pValues, GetSelection(), *pOldParaSet, *pNewParaSet );
 854
 855                     if( pMap->nWID >= EE_ITEMS_START && pMap->nWID <= EE_ITEMS_END )
 856                     {
 857                         const SfxPoolItem* pItem;
 858                         if( pNewParaSet->GetItemState( pMap->nWID, sal_True, &pItem ) == SFX_ITEM_SET )
 859                         {
 860                             pOldParaSet->Put( *pItem );
 861                         }
 862                     }
 863
 864                 }
 865             }
 866         }
 867
 868         sal_Bool bNeedsUpdate = sal_False;
 869
 870         if( pNewParaSet )
 871         {
 872             if( pNewParaSet->Count() )
 873             {
 874                 while( nTempPara <= nEndPara )
 875                 {
 876                     SfxItemSet aSet( pForwarder->GetParaAttribs( (USHORT)nTempPara ) );
 877                     aSet.Put( *pNewParaSet );
 878                     pForwarder->SetParaAttribs( (USHORT)nTempPara, aSet );
 879                     nTempPara++;
 880                 }
 881                 bNeedsUpdate = sal_True;
 882             }
 883
 884             delete pNewParaSet;
 885             delete pOldParaSet;
 886         }
 887
 888         if( pNewAttrSet )
 889         {
 890             if( pNewAttrSet->Count() )
 891             {
 892                 pForwarder->QuickSetAttribs( *pNewAttrSet, GetSelection() );
 893                 bNeedsUpdate = sal_True;
 894             }
 895             delete pNewAttrSet;
 896             delete pOldAttrSet;
 897
 898         }
 899
 900         if( bNeedsUpdate )
 901             GetEditSource()->UpdateData();
 902     }
 903 }
 904
 905 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextRangeBase::getPropertyValues( const uno::Sequence< ::rtl::OUString >& aPropertyNames ) throw (uno::RuntimeException)
 906 {
 907     return _getPropertyValues( aPropertyNames, -1 );
 908 }
 909
 910 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextRangeBase::_getPropertyValues( const uno::Sequence< ::rtl::OUString >& aPropertyNames, sal_Int32 nPara ) throw (uno::RuntimeException)
 911 {
 912     OGuard aGuard( Application::GetSolarMutex() );
 913
 914     sal_Int32 nCount = aPropertyNames.getLength();
 915
 916
 917     uno::Sequence< uno::Any > aValues( nCount );
 918
 919     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 920     if( pForwarder )
 921     {
 922         SfxItemSet* pAttribs = NULL;
 923         if( nPara != -1 )
 924             pAttribs = pForwarder->GetParaAttribs( (USHORT)nPara ).Clone();
 925         else
 926             pAttribs = pForwarder->GetAttribs( GetSelection() ).Clone();
 927
 928         pAttribs->ClearInvalidItems();
 929
 930         const OUString* pPropertyNames = aPropertyNames.getConstArray();
 931         uno::Any* pValues = aValues.getArray();
 932
 933         for( ; nCount; nCount--, pPropertyNames++, pValues++ )
 934         {
 935             const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( *pPropertyNames );
 936             if( pMap )
 937             {
 938                 getPropertyValue( pMap, *pValues, *pAttribs );
 939             }
 940         }
 941
 942         delete pAttribs;
 943
 944     }
 945
 946     return aValues;
 947 }
 948
 949 void SAL_CALL SvxUnoTextRangeBase::addPropertiesChangeListener( const uno::Sequence< ::rtl::OUString >& , const uno::Reference< beans::XPropertiesChangeListener >& ) throw (uno::RuntimeException)
 950 {
 951 }
 952
 953 void SAL_CALL SvxUnoTextRangeBase::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& ) throw (uno::RuntimeException)
 954 {
 955 }
 956
 957 void SAL_CALL SvxUnoTextRangeBase::firePropertiesChangeEvent( const uno::Sequence< ::rtl::OUString >& , const uno::Reference< beans::XPropertiesChangeListener >& ) throw (uno::RuntimeException)
 958 {
 959 }
 960
 961 // beans::XPropertyState
 962 beans::PropertyState SAL_CALL SvxUnoTextRangeBase::getPropertyState( const OUString& PropertyName )
 963     throw(beans::UnknownPropertyException, uno::RuntimeException)
 964 {
 965     return _getPropertyState( PropertyName, -1 );
 966 }
 967
 968 static sal_uInt16 aSvxUnoFontDescriptorWhichMap[] = { EE_CHAR_FONTINFO, EE_CHAR_FONTHEIGHT, EE_CHAR_ITALIC,
 969                                                   EE_CHAR_UNDERLINE, EE_CHAR_WEIGHT, EE_CHAR_STRIKEOUT,
 970                                                   EE_CHAR_WLM, 0 };
 971
 972 beans::PropertyState SAL_CALL SvxUnoTextRangeBase::_getPropertyState(const SfxItemPropertySimpleEntry* pMap, sal_Int32 nPara)
 973     throw( beans::UnknownPropertyException, uno::RuntimeException )
 974 {
 975     if ( pMap )
 976     {
 977         SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
 978         if( pForwarder )
 979         {
 980             SfxItemState eItemState = SFX_ITEM_UNKNOWN;
 981             sal_uInt16 nWID = 0;
 982
 983             switch( pMap->nWID )
 984             {
 985             case WID_FONTDESC:
 986                 {
 987                     sal_uInt16* pWhichId = aSvxUnoFontDescriptorWhichMap;
 988                     SfxItemState eTempItemState;
 989                     while( *pWhichId )
 990                     {
 991                         if(nPara != -1)
 992                             eTempItemState = pForwarder->GetItemState( (USHORT)nPara, *pWhichId );
 993                         else
 994                             eTempItemState = pForwarder->GetItemState( GetSelection(), *pWhichId );
 995
 996                         switch( eTempItemState )
 997                         {
 998                         case SFX_ITEM_DISABLED:
 999                         case SFX_ITEM_DONTCARE:
1000                             eItemState = SFX_ITEM_DONTCARE;
1001                             break;
1002
1003                         case SFX_ITEM_DEFAULT:
1004                             if( eItemState != SFX_ITEM_DEFAULT )
1005                             {
1006                                 if( eItemState == SFX_ITEM_UNKNOWN )
1007                                     eItemState = SFX_ITEM_DEFAULT;
1008                             }
1009                             break;
1010
1011                         case SFX_ITEM_READONLY:
1012                         case SFX_ITEM_SET:
1013                             if( eItemState != SFX_ITEM_SET )
1014                             {
1015                                 if( eItemState == SFX_ITEM_UNKNOWN )
1016                                     eItemState = SFX_ITEM_SET;
1017                             }
1018                             break;
1019                         default:
1020                             throw beans::UnknownPropertyException();
1021                         }
1022
1023                         pWhichId++;
1024                     }
1025                 }
1026                 break;
1027
1028             case WID_NUMLEVEL:
1029             case WID_NUMBERINGSTARTVALUE:
1030             case WID_PARAISNUMBERINGRESTART:
1031                 eItemState = SFX_ITEM_SET;
1032                 break;
1033
1034             default:
1035                 nWID = pMap->nWID;
1036             }
1037
1038             if( nWID != 0 )
1039             {
1040                 if( nPara != -1 )
1041                     eItemState = pForwarder->GetItemState( (USHORT)nPara, nWID );
1042                 else
1043                     eItemState = pForwarder->GetItemState( GetSelection(), nWID );
1044             }
1045
1046             switch( eItemState )
1047             {
1048             case SFX_ITEM_DONTCARE:
1049             case SFX_ITEM_DISABLED:
1050                 return beans::PropertyState_AMBIGUOUS_VALUE;
1051             case SFX_ITEM_READONLY:
1052             case SFX_ITEM_SET:
1053                 return beans::PropertyState_DIRECT_VALUE;
1054             case SFX_ITEM_DEFAULT:
1055                 return beans::PropertyState_DEFAULT_VALUE;
1056 //                      case SFX_ITEM_UNKNOWN:
1057             }
1058         }
1059     }
1060     throw beans::UnknownPropertyException();
1061 }
1062
1063 beans::PropertyState SAL_CALL SvxUnoTextRangeBase::_getPropertyState(const OUString& PropertyName, sal_Int32 nPara /* = -1 */)
1064     throw( beans::UnknownPropertyException, uno::RuntimeException )
1065 {
1066     OGuard aGuard( Application::GetSolarMutex() );
1067
1068     return _getPropertyState( mpPropSet->getPropertyMapEntry( PropertyName ), nPara);
1069 }
1070
1071 uno::Sequence< beans::PropertyState > SAL_CALL SvxUnoTextRangeBase::getPropertyStates( const uno::Sequence< OUString >& aPropertyName )
1072     throw(beans::UnknownPropertyException, uno::RuntimeException)
1073 {
1074     return _getPropertyStates( aPropertyName, -1 );
1075 }
1076
1077 uno::Sequence< beans::PropertyState > SvxUnoTextRangeBase::_getPropertyStates(const uno::Sequence< OUString >& PropertyName, sal_Int32 nPara /* = -1 */)
1078     throw( beans::UnknownPropertyException, uno::RuntimeException )
1079 {
1080     const sal_Int32 nCount = PropertyName.getLength();
1081     const OUString* pNames = PropertyName.getConstArray();
1082
1083     uno::Sequence< beans::PropertyState > aRet( nCount );
1084     beans::PropertyState* pState = aRet.getArray();
1085
1086     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
1087     if( pForwarder )
1088     {
1089         SfxItemSet* pSet = NULL;
1090         if( nPara != -1 )
1091         {
1092             pSet = new SfxItemSet( pForwarder->GetParaAttribs( (USHORT)nPara ) );
1093         }
1094         else
1095         {
1096             ESelection aSel( GetSelection() );
1097             CheckSelection( aSel, pForwarder );
1098             pSet = new SfxItemSet( pForwarder->GetAttribs( aSel, EditEngineAttribs_OnlyHard ) );
1099         }
1100
1101         sal_Bool bUnknownPropertyFound = sal_False;
1102         for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++ )
1103         {
1104             const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( *pNames++ );
1105             if( NULL == pMap )
1106             {
1107                 bUnknownPropertyFound = sal_True;
1108                 break;
1109             }
1110             bUnknownPropertyFound = !_getOnePropertyStates(pSet, pMap, *pState++);
1111         }
1112
1113         delete pSet;
1114
1115         if( bUnknownPropertyFound )
1116             throw beans::UnknownPropertyException();
1117     }
1118
1119     return aRet;
1120 }
1121
1122 sal_Bool SvxUnoTextRangeBase::_getOnePropertyStates(const SfxItemSet* pSet, const SfxItemPropertySimpleEntry* pMap, beans::PropertyState& rState)
1123 {
1124     sal_Bool bUnknownPropertyFound = sal_False;
1125     if(pSet && pMap)
1126     {
1127         SfxItemState eItemState = SFX_ITEM_UNKNOWN;
1128         sal_uInt16 nWID = 0;
1129
1130         switch( pMap->nWID )
1131         {
1132             case WID_FONTDESC:
1133                 {
1134                     sal_uInt16* pWhichId = aSvxUnoFontDescriptorWhichMap;
1135                     SfxItemState eTempItemState;
1136                     while( *pWhichId )
1137                     {
1138                         eTempItemState = pSet->GetItemState( *pWhichId );
1139
1140                         switch( eTempItemState )
1141                         {
1142                         case SFX_ITEM_DISABLED:
1143                         case SFX_ITEM_DONTCARE:
1144                             eItemState = SFX_ITEM_DONTCARE;
1145                             break;
1146
1147                         case SFX_ITEM_DEFAULT:
1148                             if( eItemState != SFX_ITEM_DEFAULT )
1149                             {
1150                                 if( eItemState == SFX_ITEM_UNKNOWN )
1151                                     eItemState = SFX_ITEM_DEFAULT;
1152                             }
1153                             break;
1154
1155                         case SFX_ITEM_READONLY:
1156                         case SFX_ITEM_SET:
1157                             if( eItemState != SFX_ITEM_SET )
1158                             {
1159                                 if( eItemState == SFX_ITEM_UNKNOWN )
1160                                     eItemState = SFX_ITEM_SET;
1161                             }
1162                             break;
1163                         default:
1164                             bUnknownPropertyFound = sal_True;
1165                             break;
1166                         }
1167
1168                         pWhichId++;
1169                     }
1170                 }
1171                 break;
1172
1173             case WID_NUMLEVEL:
1174             case WID_NUMBERINGSTARTVALUE:
1175             case WID_PARAISNUMBERINGRESTART:
1176                 eItemState = SFX_ITEM_SET;
1177                 break;
1178
1179             default:
1180                 nWID = pMap->nWID;
1181         }
1182
1183         if( bUnknownPropertyFound )
1184             return !bUnknownPropertyFound;
1185
1186         if( nWID != 0 )
1187             eItemState = pSet->GetItemState( nWID, sal_False );
1188
1189         switch( eItemState )
1190         {
1191                 case SFX_ITEM_READONLY:
1192                 case SFX_ITEM_SET:
1193                     rState = beans::PropertyState_DIRECT_VALUE;
1194                     break;
1195                 case SFX_ITEM_DEFAULT:
1196                     rState = beans::PropertyState_DEFAULT_VALUE;
1197                     break;
1198 //                                      case SFX_ITEM_UNKNOWN:
1199 //                                      case SFX_ITEM_DONTCARE:
1200 //                                      case SFX_ITEM_DISABLED:
1201                 default:
1202                     rState = beans::PropertyState_AMBIGUOUS_VALUE;
1203         }
1204     }
1205     return !bUnknownPropertyFound;
1206 }
1207
1208 void SAL_CALL SvxUnoTextRangeBase::setPropertyToDefault( const OUString& PropertyName )
1209     throw(beans::UnknownPropertyException, uno::RuntimeException)
1210 {
1211     _setPropertyToDefault( PropertyName, -1 );
1212 }
1213
1214 void SvxUnoTextRangeBase::_setPropertyToDefault(const OUString& PropertyName, sal_Int32 nPara /* = -1 */)
1215     throw( beans::UnknownPropertyException, uno::RuntimeException )
1216 {
1217     OGuard aGuard( Application::GetSolarMutex() );
1218
1219     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
1220
1221     if( pForwarder )
1222     {
1223         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( PropertyName );
1224         if ( pMap )
1225         {
1226             CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1227             _setPropertyToDefault( pForwarder, pMap, nPara );
1228             return;
1229         }
1230     }
1231
1232     throw beans::UnknownPropertyException();
1233 }
1234
1235 void SvxUnoTextRangeBase::_setPropertyToDefault(SvxTextForwarder* pForwarder, const SfxItemPropertySimpleEntry* pMap, sal_Int32 nPara )
1236     throw( beans::UnknownPropertyException, uno::RuntimeException )
1237 {
1238     do
1239     {
1240         SfxItemSet aSet( *pForwarder->GetPool(), TRUE );
1241
1242         if( pMap->nWID == WID_FONTDESC )
1243         {
1244             SvxUnoFontDescriptor::setPropertyToDefault( aSet );
1245         }
1246         else if( pMap->nWID == WID_NUMLEVEL )
1247         {
1248             // #101004# Call interface method instead of unsafe cast
1249             pForwarder->SetDepth( maSelection.nStartPara, -1 );
1250             return;
1251         }
1252         else if( pMap->nWID == WID_NUMBERINGSTARTVALUE )
1253         {
1254             pForwarder->SetNumberingStartValue( maSelection.nStartPara, -1 );
1255         }
1256         else if( pMap->nWID == WID_PARAISNUMBERINGRESTART )
1257         {
1258             pForwarder->SetParaIsNumberingRestart( maSelection.nStartPara, sal_False );
1259         }
1260         else
1261         {
1262             aSet.InvalidateItem( pMap->nWID );
1263         }
1264
1265         if(nPara != -1)
1266             pForwarder->SetParaAttribs( (USHORT)nPara, aSet );
1267         else
1268             pForwarder->QuickSetAttribs( aSet, GetSelection() );
1269
1270         GetEditSource()->UpdateData();
1271
1272         return;
1273     }
1274     while(0);
1275 }
1276
1277 uno::Any SAL_CALL SvxUnoTextRangeBase::getPropertyDefault( const OUString& aPropertyName )
1278     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1279 {
1280     OGuard aGuard( Application::GetSolarMutex() );
1281
1282     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
1283     if( pForwarder )
1284     {
1285         const SfxItemPropertySimpleEntry* pMap = mpPropSet->getPropertyMapEntry( aPropertyName );
1286         if( pMap )
1287         {
1288             SfxItemPool* pPool = pForwarder->GetPool();
1289
1290             switch( pMap->nWID )
1291             {
1292             case WID_FONTDESC:
1293                 return SvxUnoFontDescriptor::getPropertyDefault( pPool );
1294
1295             case WID_NUMLEVEL:
1296                 {
1297                     uno::Any aAny;
1298                     return aAny;
1299                 }
1300
1301             case WID_NUMBERINGSTARTVALUE:
1302                 return uno::Any( (sal_Int16)-1 );
1303
1304             case WID_PARAISNUMBERINGRESTART:
1305                 return uno::Any( (sal_Bool)sal_False );
1306
1307             default:
1308                 {
1309                     // Default aus ItemPool holen
1310                     if(pPool->IsWhich(pMap->nWID))
1311                     {
1312                         SfxItemSet aSet( *pPool,        pMap->nWID, pMap->nWID);
1313                         aSet.Put(pPool->GetDefaultItem(pMap->nWID));
1314                         return mpPropSet->getPropertyValue(pMap, aSet);
1315                     }
1316                 }
1317             }
1318         }
1319     }
1320     throw beans::UnknownPropertyException();
1321 }
1322
1323 // beans::XMultiPropertyStates
1324 void SAL_CALL SvxUnoTextRangeBase::setAllPropertiesToDefault(  ) throw (uno::RuntimeException)
1325 {
1326     OGuard aGuard( Application::GetSolarMutex() );
1327
1328     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
1329
1330     if( pForwarder )
1331     {
1332         PropertyEntryVector_t aEntries = mpPropSet->getPropertyMap()->getPropertyEntries();
1333         PropertyEntryVector_t::const_iterator aIt = aEntries.begin();
1334         while( aIt != aEntries.end() )
1335         {
1336             _setPropertyToDefault( pForwarder, &(*aIt), -1 );
1337             ++aIt;
1338         }
1339     }
1340 }
1341
1342 void SAL_CALL SvxUnoTextRangeBase::setPropertiesToDefault( const uno::Sequence< OUString >& aPropertyNames ) throw (beans::UnknownPropertyException, uno::RuntimeException)
1343 {
1344     sal_Int32 nCount = aPropertyNames.getLength();
1345     for( const OUString* pName = aPropertyNames.getConstArray(); nCount; pName++, nCount-- )
1346     {
1347         setPropertyToDefault( *pName );
1348     }
1349 }
1350
1351 uno::Sequence< uno::Any > SAL_CALL SvxUnoTextRangeBase::getPropertyDefaults( const uno::Sequence< OUString >& aPropertyNames ) throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1352 {
1353     sal_Int32 nCount = aPropertyNames.getLength();
1354     uno::Sequence< uno::Any > ret( nCount );
1355     uno::Any* pDefaults = ret.getArray();
1356
1357     for( const OUString* pName = aPropertyNames.getConstArray(); nCount; pName++, nCount--, pDefaults++ )
1358     {
1359         *pDefaults = getPropertyDefault( *pName );
1360     }
1361
1362     return ret;
1363 }
1364
1365 // internal
1366 void SvxUnoTextRangeBase::CollapseToStart(void) throw()
1367 {
1368     CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1369
1370     maSelection.nEndPara = maSelection.nStartPara;
1371     maSelection.nEndPos  = maSelection.nStartPos;
1372 }
1373
1374 void SvxUnoTextRangeBase::CollapseToEnd(void) throw()
1375 {
1376     CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1377
1378     maSelection.nStartPara = maSelection.nEndPara;
1379     maSelection.nStartPos  = maSelection.nEndPos;
1380 }
1381
1382 sal_Bool SvxUnoTextRangeBase::IsCollapsed(void) throw()
1383 {
1384     CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1385
1386     return ( maSelection.nStartPara == maSelection.nEndPara &&
1387              maSelection.nStartPos  == maSelection.nEndPos );
1388 }
1389
1390 sal_Bool SvxUnoTextRangeBase::GoLeft(sal_Int16 nCount, sal_Bool Expand) throw()
1391 {
1392     CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1393
1394     //  #75098# use end position, as in Writer (start is anchor, end is cursor)
1395     sal_uInt16 nNewPos = maSelection.nEndPos;
1396     sal_uInt16 nNewPar = maSelection.nEndPara;
1397
1398     sal_Bool bOk = sal_True;
1399     SvxTextForwarder* pForwarder = NULL;
1400     while ( nCount > nNewPos && bOk )
1401     {
1402         if ( nNewPar == 0 )
1403             bOk = sal_False;
1404         else
1405         {
1406             if ( !pForwarder )
1407                 pForwarder = mpEditSource->GetTextForwarder();  // erst hier, wenn's noetig ist...
1408
1409             --nNewPar;
1410             nCount -= nNewPos + 1;
1411             nNewPos = pForwarder->GetTextLen( nNewPar );
1412         }
1413     }
1414
1415     if ( bOk )
1416     {
1417         nNewPos = nNewPos - nCount;
1418         maSelection.nStartPara = nNewPar;
1419         maSelection.nStartPos  = nNewPos;
1420     }
1421
1422     if (!Expand)
1423         CollapseToStart();
1424
1425     return bOk;
1426 }
1427
1428 sal_Bool SvxUnoTextRangeBase::GoRight(sal_Int16 nCount, sal_Bool Expand)  throw()
1429 {
1430     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
1431     if( pForwarder )
1432     {
1433         CheckSelection( maSelection, pForwarder );
1434
1435
1436         sal_uInt16 nNewPos = maSelection.nEndPos + nCount;                      //! Ueberlauf ???
1437         sal_uInt16 nNewPar = maSelection.nEndPara;
1438
1439         sal_Bool bOk = sal_True;
1440         sal_uInt16 nParCount = pForwarder->GetParagraphCount();
1441         sal_uInt16 nThisLen = pForwarder->GetTextLen( nNewPar );
1442         while ( nNewPos > nThisLen && bOk )
1443         {
1444             if ( nNewPar + 1 >= nParCount )
1445                 bOk = sal_False;
1446             else
1447             {
1448                 nNewPos -= nThisLen+1;
1449                 ++nNewPar;
1450                 nThisLen = pForwarder->GetTextLen( nNewPar );
1451             }
1452         }
1453
1454         if (bOk)
1455         {
1456             maSelection.nEndPara = nNewPar;
1457             maSelection.nEndPos  = nNewPos;
1458         }
1459
1460         if (!Expand)
1461             CollapseToEnd();
1462
1463         return bOk;
1464     }
1465     return sal_False;
1466 }
1467
1468 void SvxUnoTextRangeBase::GotoStart(sal_Bool Expand) throw()
1469 {
1470     maSelection.nStartPara = 0;
1471     maSelection.nStartPos  = 0;
1472
1473     if (!Expand)
1474         CollapseToStart();
1475 }
1476
1477 void SvxUnoTextRangeBase::GotoEnd(sal_Bool Expand) throw()
1478 {
1479     CheckSelection( maSelection, mpEditSource->GetTextForwarder() );
1480
1481     SvxTextForwarder* pForwarder = mpEditSource ? mpEditSource->GetTextForwarder() : NULL;
1482     if( pForwarder )
1483     {
1484
1485         sal_uInt16 nPar = pForwarder->GetParagraphCount();
1486         if (nPar)
1487             --nPar;
1488
1489         maSelection.nEndPara = nPar;
1490         maSelection.nEndPos  = pForwarder->GetTextLen( nPar );
1491
1492         if (!Expand)
1493             CollapseToEnd();
1494     }
1495 }
1496
1497 // lang::XServiceInfo
1498 sal_Bool SAL_CALL SvxUnoTextRangeBase::supportsService( const OUString& ServiceName )
1499     throw(uno::RuntimeException)
1500 {
1501     return SvxServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
1502 }
1503
1504 uno::Sequence< OUString > SAL_CALL SvxUnoTextRangeBase::getSupportedServiceNames()
1505     throw(uno::RuntimeException)
1506 {
1507     return getSupportedServiceNames_Static();
1508 }
1509
1510 uno::Sequence< OUString > SAL_CALL SvxUnoTextRangeBase::getSupportedServiceNames_Static()
1511     SAL_THROW(())
1512 {
1513     uno::Sequence< OUString >   aSeq;
1514     SvxServiceInfoHelper::addToSequence( aSeq, 3, "com.sun.star.style.CharacterProperties",
1515                                                   "com.sun.star.style.CharacterPropertiesComplex",
1516                                                   "com.sun.star.style.CharacterPropertiesAsian");
1517     return aSeq;
1518 }
1519
1520 // XTextRangeCompare
1521 sal_Int16 SAL_CALL SvxUnoTextRangeBase::compareRegionStarts( const uno::Reference< text::XTextRange >& xR1, const uno::Reference< text::XTextRange >& xR2 ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1522 {
1523     SvxUnoTextRangeBase* pR1 = SvxUnoTextRangeBase::getImplementation( xR1 );
1524     SvxUnoTextRangeBase* pR2 = SvxUnoTextRangeBase::getImplementation( xR2 );
1525
1526     if( (pR1 == 0) || (pR2 == 0) )
1527         throw lang::IllegalArgumentException();
1528
1529     const ESelection& r1 = pR1->maSelection;
1530     const ESelection& r2 = pR2->maSelection;
1531
1532     if( r1.nStartPara == r2.nStartPara )
1533     {
1534         if( r1.nStartPos == r2.nStartPos )
1535             return 0;
1536         else
1537             return r1.nStartPos < r2.nStartPos ? 1 : -1;
1538     }
1539     else
1540     {
1541         return r1.nStartPara < r2.nStartPara ? 1 : -1;
1542     }
1543 }
1544
1545 sal_Int16 SAL_CALL SvxUnoTextRangeBase::compareRegionEnds( const uno::Reference< text::XTextRange >& xR1, const uno::Reference< text::XTextRange >& xR2 ) throw (lang::IllegalArgumentException, uno::RuntimeException)
1546 {
1547     SvxUnoTextRangeBase* pR1 = SvxUnoTextRangeBase::getImplementation( xR1 );
1548     SvxUnoTextRangeBase* pR2 = SvxUnoTextRangeBase::getImplementation( xR2 );
1549
1550     if( (pR1 == 0) || (pR2 == 0) )
1551         throw lang::IllegalArgumentException();
1552
1553     const ESelection& r1 = pR1->maSelection;
1554     const ESelection& r2 = pR2->maSelection;
1555
1556     if( r1.nEndPara == r2.nEndPara )
1557     {
1558         if( r1.nEndPos == r2.nEndPos )
1559             return 0;
1560         else
1561             return r1.nEndPos < r2.nEndPos ? 1 : -1;
1562     }
1563     else
1564     {
1565         return r1.nEndPara < r2.nEndPara ? 1 : -1;
1566     }
1567 }
1568
1569 // ====================================================================
1570 // class SvxUnoTextRange
1571 // ====================================================================
1572
1573 uno::Sequence< uno::Type > SvxUnoTextRange::maTypeSequence;
1574
1575 uno::Reference< uno::XInterface > SvxUnoTextRange_NewInstance()
1576 {
1577     SvxUnoText aText;
1578     uno::Reference< text::XTextRange > xRange( new SvxUnoTextRange( aText ) );
1579 #if (_MSC_VER < 1300)
1580     return xRange;
1581 #else
1582     return (uno::Reference< uno::XInterface >)xRange;
1583 #endif
1584 }
1585
1586 SvxUnoTextRange::SvxUnoTextRange( const SvxUnoTextBase& rParent, sal_Bool bPortion /* = sal_False */ ) throw()
1587 :SvxUnoTextRangeBase( rParent.GetEditSource(), bPortion ? ImplGetSvxTextPortionSvxPropertySet() : rParent.getPropertySet() ),
1588  mbPortion( bPortion )
1589 {
1590     xParentText =  (text::XText*)&rParent;
1591 }
1592
1593 SvxUnoTextRange::~SvxUnoTextRange() throw()
1594 {
1595 }
1596
1597 uno::Any SAL_CALL SvxUnoTextRange::queryAggregation( const uno::Type & rType )
1598     throw(uno::RuntimeException)
1599 {
1600     QUERYINT( text::XTextRange );
1601     else if( rType == ::getCppuType((const uno::Reference< beans::XMultiPropertyStates >*)0) )
1602         return uno::makeAny(uno::Reference< beans::XMultiPropertyStates >(this));
1603     else if( rType == ::getCppuType((const uno::Reference< beans::XPropertySet >*)0) )
1604         return uno::makeAny(uno::Reference< beans::XPropertySet >(this));
1605     else QUERYINT( beans::XPropertyState );
1606     else QUERYINT( text::XTextRangeCompare );
1607     else if( rType == ::getCppuType((const uno::Reference< beans::XMultiPropertySet >*)0) )
1608         return uno::makeAny(uno::Reference< beans::XMultiPropertySet >(this));
1609     else QUERYINT( lang::XServiceInfo );
1610     else QUERYINT( lang::XTypeProvider );
1611     else QUERYINT( lang::XUnoTunnel );
1612     else
1613         return OWeakAggObject::queryAggregation( rType );
1614 }
1615
1616 uno::Any SAL_CALL SvxUnoTextRange::queryInterface( const uno::Type & rType )
1617     throw(uno::RuntimeException)
1618 {
1619     return OWeakAggObject::queryInterface(rType);
1620 }
1621
1622 void SAL_CALL SvxUnoTextRange::acquire()
1623     throw( )
1624 {
1625     OWeakAggObject::acquire();
1626 }
1627
1628 void SAL_CALL SvxUnoTextRange::release()
1629     throw( )
1630 {
1631     OWeakAggObject::release();
1632 }
1633
1634 // XTypeProvider
1635
1636 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextRange::getTypes()
1637     throw (uno::RuntimeException)
1638 {
1639     if( maTypeSequence.getLength() == 0 )
1640     {
1641         maTypeSequence.realloc( 9 ); // !DANGER! keep this updated
1642         uno::Type* pTypes = maTypeSequence.getArray();
1643
1644         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRange >*)0);
1645         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XPropertySet >*)0);
1646         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XMultiPropertySet >*)0);
1647         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XMultiPropertyStates >*)0);
1648         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XPropertyState >*)0);
1649         *pTypes++ = ::getCppuType(( const uno::Reference< lang::XServiceInfo >*)0);
1650         *pTypes++ = ::getCppuType(( const uno::Reference< lang::XTypeProvider >*)0);
1651         *pTypes++ = ::getCppuType(( const uno::Reference< lang::XUnoTunnel >*)0);
1652         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRangeCompare >*)0);
1653     }
1654     return maTypeSequence;
1655 }
1656
1657 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoTextRange::getImplementationId()
1658     throw (uno::RuntimeException)
1659 {
1660     static uno::Sequence< sal_Int8 > aId;
1661     if( aId.getLength() == 0 )
1662     {
1663         aId.realloc( 16 );
1664         rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
1665     }
1666     return aId;
1667 }
1668
1669 // XTextRange
1670 uno::Reference< text::XText > SAL_CALL SvxUnoTextRange::getText()
1671     throw(uno::RuntimeException)
1672 {
1673     return xParentText;
1674 }
1675
1676 // lang::XServiceInfo
1677 OUString SAL_CALL SvxUnoTextRange::getImplementationName()
1678     throw(uno::RuntimeException)
1679 {
1680     return OUString(RTL_CONSTASCII_USTRINGPARAM("SvxUnoTextRange"));
1681 }
1682
1683 // ====================================================================
1684 // class SvxUnoText
1685 // ====================================================================
1686
1687 // UNO3_GETIMPLEMENTATION2_IMPL( SvxUnoText, SvxUnoTextRangeBase );
1688
1689 uno::Sequence< uno::Type > SvxUnoTextBase::maTypeSequence;
1690
1691 SvxUnoTextBase::SvxUnoTextBase() throw()
1692 : SvxUnoTextRangeBase( NULL )
1693 {
1694
1695 }
1696
1697 SvxUnoTextBase::SvxUnoTextBase( const SvxItemPropertySet* _pSet  ) throw()
1698 : SvxUnoTextRangeBase( _pSet )
1699 {
1700 }
1701
1702 SvxUnoTextBase::SvxUnoTextBase( const SvxEditSource* pSource, const SvxItemPropertySet* _pSet  ) throw()
1703 : SvxUnoTextRangeBase( pSource, _pSet )
1704 {
1705     ESelection aSelection;
1706     ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1707     SetSelection( aSelection );
1708 }
1709
1710 SvxUnoTextBase::SvxUnoTextBase( const SvxEditSource* pSource, const SvxItemPropertySet* _pSet, uno::Reference < text::XText > xParent ) throw()
1711 : SvxUnoTextRangeBase( pSource, _pSet )
1712 {
1713     xParentText = xParent;
1714     ESelection aSelection;
1715     ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1716     SetSelection( aSelection );
1717 }
1718
1719 SvxUnoTextBase::SvxUnoTextBase( const SvxUnoTextBase& rText ) throw()
1720 :       SvxUnoTextRangeBase( rText )
1721 , text::XTextAppend()
1722 ,   text::XTextCopy()
1723 ,       container::XEnumerationAccess()
1724 ,       text::XTextRangeMover()
1725 ,       lang::XTypeProvider()
1726 {
1727     xParentText = rText.xParentText;
1728 }
1729
1730 SvxUnoTextBase::~SvxUnoTextBase() throw()
1731 {
1732 }
1733
1734 // Internal
1735 ESelection SvxUnoTextBase::InsertField( const SvxFieldItem& rField ) throw()
1736 {
1737     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : NULL;
1738     if( pForwarder )
1739     {
1740         pForwarder->QuickInsertField( rField, GetSelection() );
1741         GetEditSource()->UpdateData();
1742
1743         //      Selektion anpassen
1744         //!     Wenn die EditEngine bei QuickInsertText die Selektion zurueckgeben wuerde,
1745         //!     waer's einfacher...
1746
1747         CollapseToStart();
1748         GoRight( 1, sal_True );         // Feld ist immer 1 Zeichen
1749     }
1750
1751     return GetSelection();      // Selektion mit dem Feld
1752 }
1753
1754 // XInterface
1755 uno::Any SAL_CALL SvxUnoTextBase::queryAggregation( const uno::Type & rType )
1756     throw(uno::RuntimeException)
1757 {
1758     QUERYINT( text::XText );
1759     QUERYINT( text::XSimpleText );
1760     if( rType == ::getCppuType((const uno::Reference< text::XTextRange >*)0) )
1761         return uno::makeAny(uno::Reference< text::XTextRange >((text::XText*)(this)));
1762     QUERYINT(container::XEnumerationAccess );
1763     QUERYINT( container::XElementAccess );
1764     QUERYINT( beans::XMultiPropertyStates );
1765     QUERYINT( beans::XPropertySet );
1766     QUERYINT( beans::XMultiPropertySet );
1767     QUERYINT( beans::XPropertyState );
1768     QUERYINT( text::XTextRangeCompare );
1769     QUERYINT( lang::XServiceInfo );
1770     QUERYINT( text::XTextRangeMover );
1771     QUERYINT( text::XTextCopy );
1772     QUERYINT( text::XTextAppend );
1773     QUERYINT( text::XParagraphAppend );
1774     QUERYINT( text::XTextPortionAppend );
1775     QUERYINT( lang::XTypeProvider );
1776     QUERYINT( lang::XUnoTunnel );
1777
1778     return uno::Any();
1779 }
1780
1781 // XTypeProvider
1782
1783 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextBase::getStaticTypes() throw()
1784 {
1785     if( maTypeSequence.getLength() == 0 )
1786     {
1787         maTypeSequence.realloc( 15 ); // !DANGER! keep this updated
1788         uno::Type* pTypes = maTypeSequence.getArray();
1789
1790         *pTypes++ = ::getCppuType(( const uno::Reference< text::XText >*)0);
1791         *pTypes++ = ::getCppuType(( const uno::Reference< container::XEnumerationAccess >*)0);
1792         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XPropertySet >*)0);
1793         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XMultiPropertySet >*)0);
1794         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XMultiPropertyStates >*)0);
1795         *pTypes++ = ::getCppuType(( const uno::Reference< beans::XPropertyState >*)0);
1796         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRangeMover >*)0);
1797         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextAppend >*)0);
1798         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextCopy >*)0);
1799         *pTypes++ = ::getCppuType(( const uno::Reference< text::XParagraphAppend >*)0);
1800         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextPortionAppend >*)0);
1801         *pTypes++ = ::getCppuType(( const uno::Reference< lang::XServiceInfo >*)0);
1802         *pTypes++ = ::getCppuType(( const uno::Reference< lang::XTypeProvider >*)0);
1803         *pTypes++ = ::getCppuType(( const uno::Reference< lang::XUnoTunnel >*)0);
1804         *pTypes++ = ::getCppuType(( const uno::Reference< text::XTextRangeCompare >*)0);
1805     }
1806     return maTypeSequence;
1807 }
1808
1809 uno::Sequence< uno::Type > SAL_CALL SvxUnoTextBase::getTypes()
1810     throw (uno::RuntimeException)
1811 {
1812     return getStaticTypes();
1813 }
1814
1815 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoTextBase::getImplementationId()
1816     throw (uno::RuntimeException)
1817 {
1818     static uno::Sequence< sal_Int8 > aId;
1819     if( aId.getLength() == 0 )
1820     {
1821         aId.realloc( 16 );
1822         rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
1823     }
1824     return aId;
1825 }
1826
1827 uno::Reference< text::XTextCursor > SvxUnoTextBase::createTextCursorBySelection( const ESelection& rSel )
1828 {
1829     SvxUnoTextCursor* pCursor = new SvxUnoTextCursor( *this );
1830     uno::Reference< text::XTextCursor >  xCursor( pCursor );
1831     pCursor->SetSelection( rSel );
1832     return xCursor;
1833 }
1834
1835 // XSimpleText
1836
1837 uno::Reference< text::XTextCursor > SAL_CALL SvxUnoTextBase::createTextCursor()
1838     throw(uno::RuntimeException)
1839 {
1840     OGuard aGuard( Application::GetSolarMutex() );
1841     return new SvxUnoTextCursor( *this );
1842 }
1843
1844 uno::Reference< text::XTextCursor > SAL_CALL SvxUnoTextBase::createTextCursorByRange( const uno::Reference< text::XTextRange >& aTextPosition )
1845     throw(uno::RuntimeException)
1846 {
1847     OGuard aGuard( Application::GetSolarMutex() );
1848
1849     uno::Reference< text::XTextCursor >  xCursor;
1850
1851     if( aTextPosition.is() )
1852     {
1853         SvxUnoTextRangeBase* pRange = SvxUnoTextRangeBase::getImplementation( aTextPosition );
1854         if(pRange)
1855             xCursor = createTextCursorBySelection( pRange->GetSelection() );
1856     }
1857
1858     return xCursor;
1859 }
1860
1861 void SAL_CALL SvxUnoTextBase::insertString( const uno::Reference< text::XTextRange >& xRange, const OUString& aString, sal_Bool bAbsorb )
1862     throw(uno::RuntimeException)
1863 {
1864     OGuard aGuard( Application::GetSolarMutex() );
1865
1866     if( !xRange.is() )
1867         return;
1868
1869     ESelection aSelection;
1870     ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
1871     SetSelection( aSelection );
1872
1873     SvxUnoTextRangeBase* pRange = SvxUnoTextRange::getImplementation( xRange );
1874     if(pRange)
1875     {
1876         //      setString am SvxUnoTextRangeBase statt selber QuickInsertText und UpdateData,
1877         //      damit die Selektion am SvxUnoTextRangeBase angepasst wird.
1878         //!     Eigentlich muessten alle Cursor-Objekte dieses Textes angepasst werden!
1879
1880         if (!bAbsorb)                                   // nicht ersetzen -> hinten anhaengen
1881             pRange->CollapseToEnd();
1882
1883         pRange->setString( aString );
1884
1885         pRange->CollapseToEnd();
1886     }
1887 }
1888
1889 void SAL_CALL SvxUnoTextBase::insertControlCharacter( const uno::Reference< text::XTextRange >& xRange, sal_Int16 nControlCharacter, sal_Bool bAbsorb )
1890     throw(lang::IllegalArgumentException, uno::RuntimeException)
1891 {
1892     OGuard aGuard( Application::GetSolarMutex() );
1893
1894     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : NULL;
1895
1896     if( pForwarder )
1897     {
1898         ESelection aSelection;
1899         ::GetSelection( aSelection, pForwarder );
1900         SetSelection( aSelection );
1901
1902         switch( nControlCharacter )
1903         {
1904         case text::ControlCharacter::PARAGRAPH_BREAK:
1905         {
1906             const String aText( (sal_Unicode)13 );      // '\r' geht auf'm Mac nicht
1907             insertString( xRange, aText, bAbsorb );
1908
1909             return;
1910         }
1911         case text::ControlCharacter::LINE_BREAK:
1912         {
1913             SvxUnoTextRangeBase* pRange = SvxUnoTextRange::getImplementation( xRange );
1914             if(pRange)
1915             {
1916                 ESelection aRange = pRange->GetSelection();
1917
1918                 if( bAbsorb )
1919                 {
1920                     const String aEmpty;
1921                     pForwarder->QuickInsertText( aEmpty, aRange );
1922
1923                     aRange.nEndPos = aRange.nStartPos;
1924                     aRange.nEndPara = aRange.nStartPara;
1925                 }
1926                 else
1927                 {
1928                     aRange.nStartPos = aRange.nEndPos;
1929                     aRange.nStartPara = aRange.nStartPara;
1930                 }
1931
1932                 pForwarder->QuickInsertLineBreak( aRange );
1933                 GetEditSource()->UpdateData();
1934
1935                 aRange.nEndPos += 1;
1936                 if( !bAbsorb )
1937                     aRange.nStartPos += 1;
1938
1939                 pRange->SetSelection( aRange );
1940             }
1941             return;
1942         }
1943         case text::ControlCharacter::APPEND_PARAGRAPH:
1944         {
1945             SvxUnoTextRangeBase* pRange = SvxUnoTextRange::getImplementation( xRange );
1946             if(pRange)
1947             {
1948                 ESelection aRange = pRange->GetSelection();
1949 //                              ESelection aOldSelection = aRange;
1950
1951                 aRange.nStartPos  = pForwarder->GetTextLen( aRange.nStartPara );
1952
1953                 aRange.nEndPara = aRange.nStartPara;
1954                 aRange.nEndPos  = aRange.nStartPos;
1955
1956                 pRange->SetSelection( aRange );
1957                 const String aText( (sal_Unicode)13 );  // '\r' geht auf'm Mac nicht
1958                 pRange->setString( aText );
1959
1960                 aRange.nStartPos = 0;
1961                 aRange.nStartPara += 1;
1962                 aRange.nEndPos = 0;
1963                 aRange.nEndPara += 1;
1964
1965                 pRange->SetSelection( aRange );
1966
1967                 return;
1968             }
1969         }
1970         }
1971     }
1972
1973     throw lang::IllegalArgumentException();
1974 }
1975
1976 // XText
1977 void SAL_CALL SvxUnoTextBase::insertTextContent( const uno::Reference< text::XTextRange >& xRange, const uno::Reference< text::XTextContent >& xContent, sal_Bool bAbsorb )
1978     throw(lang::IllegalArgumentException, uno::RuntimeException)
1979 {
1980     OGuard aGuard( Application::GetSolarMutex() );
1981
1982     SvxTextForwarder* pForwarder = GetEditSource() ? GetEditSource()->GetTextForwarder() : NULL;
1983     if( pForwarder )
1984     {
1985
1986         SvxUnoTextRangeBase* pRange = SvxUnoTextRange::getImplementation( xRange );
1987         SvxUnoTextField* pField = SvxUnoTextField::getImplementation( xContent );
1988
1989         if( pRange == NULL || pField == NULL )
1990             throw lang::IllegalArgumentException();
1991
1992         ESelection aSelection = pRange->GetSelection();
1993         if( !bAbsorb )
1994         {
1995             aSelection.nStartPara = aSelection.nEndPara;
1996             aSelection.nStartPos  = aSelection.nEndPos;
1997         }
1998
1999         SvxFieldData* pFieldData = pField->CreateFieldData();
2000         if( pFieldData == NULL )
2001             throw lang::IllegalArgumentException();
2002
2003         SvxFieldItem aField( *pFieldData, EE_FEATURE_FIELD );
2004         pForwarder->QuickInsertField( aField, aSelection );
2005         GetEditSource()->UpdateData();
2006
2007         pField->SetAnchor( uno::Reference< text::XTextRange >::query( (cppu::OWeakObject*)this ) );
2008
2009         aSelection.nEndPos += 1;
2010         aSelection.nStartPos = aSelection.nEndPos;
2011         //maSelection = aSelection; //???
2012         pRange->SetSelection( aSelection );
2013
2014         delete pFieldData;
2015     }
2016 }
2017
2018 void SAL_CALL SvxUnoTextBase::removeTextContent( const uno::Reference< text::XTextContent >& ) throw(container::NoSuchElementException, uno::RuntimeException)
2019 {
2020 }
2021
2022 // XTextRange
2023
2024 uno::Reference< text::XText > SAL_CALL SvxUnoTextBase::getText()
2025     throw(uno::RuntimeException)
2026 {
2027     OGuard aGuard( Application::GetSolarMutex() );
2028
2029     if (GetEditSource())
2030     {
2031         ESelection aSelection;
2032         ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
2033         ((SvxUnoTextBase*)this)->SetSelection( aSelection );
2034     }
2035
2036     return (text::XText*)this;
2037 }
2038
2039 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::getStart()
2040     throw(uno::RuntimeException)
2041 {
2042     return SvxUnoTextRangeBase::getStart();
2043 }
2044
2045 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::getEnd()
2046     throw(uno::RuntimeException)
2047 {
2048     return SvxUnoTextRangeBase::getEnd();
2049 }
2050
2051 OUString SAL_CALL SvxUnoTextBase::getString() throw( uno::RuntimeException )
2052 {
2053     return SvxUnoTextRangeBase::getString();
2054 }
2055
2056 void SAL_CALL SvxUnoTextBase::setString( const OUString& aString ) throw(uno::RuntimeException)
2057 {
2058     SvxUnoTextRangeBase::setString(aString);
2059 }
2060
2061
2062 // XEnumerationAccess
2063 uno::Reference< container::XEnumeration > SAL_CALL SvxUnoTextBase::createEnumeration()
2064     throw(uno::RuntimeException)
2065 {
2066     OGuard aGuard( Application::GetSolarMutex() );
2067
2068     ESelection aSelection;
2069     ::GetSelection( aSelection, GetEditSource()->GetTextForwarder() );
2070     SetSelection( aSelection );
2071
2072     uno::Reference< container::XEnumeration > xEnum( (container::XEnumeration*) new SvxUnoTextContentEnumeration( *this ) );
2073     return xEnum;
2074 }
2075
2076 // XElementAccess ( container::XEnumerationAccess )
2077 uno::Type SAL_CALL SvxUnoTextBase::getElementType(  ) throw(uno::RuntimeException)
2078 {
2079     return ::getCppuType((const uno::Reference< text::XTextRange >*)0 );
2080 }
2081
2082 sal_Bool SAL_CALL SvxUnoTextBase::hasElements(  ) throw(uno::RuntimeException)
2083 {
2084     OGuard aGuard( Application::GetSolarMutex() );
2085
2086     if(GetEditSource())
2087     {
2088         SvxTextForwarder* pForwarder = GetEditSource()->GetTextForwarder();
2089         if(pForwarder)
2090             return pForwarder->GetParagraphCount() != 0;
2091     }
2092
2093     return sal_False;
2094 }
2095
2096 // text::XTextRangeMover
2097 void SAL_CALL SvxUnoTextBase::moveTextRange( const uno::Reference< text::XTextRange >&, sal_Int16 )
2098     throw(uno::RuntimeException)
2099 {
2100 }
2101
2102 void SvxPropertyValuesToItemSet(
2103         SfxItemSet &rItemSet,
2104         const uno::Sequence< beans::PropertyValue > rPropertyVaules,
2105         const SfxItemPropertySet *pPropSet,
2106         SvxTextForwarder *pForwarder /*needed for WID_NUMLEVEL*/,
2107         USHORT nPara /*needed for WID_NUMLEVEL*/)
2108     throw(lang::IllegalArgumentException, beans::UnknownPropertyException, uno::RuntimeException)
2109 {
2110     sal_Int32 nProps = rPropertyVaules.getLength();
2111     const beans::PropertyValue *pProps = rPropertyVaules.getConstArray();
2112     for (sal_Int32 i = 0;  i < nProps;  ++i)
2113     {
2114         const SfxItemPropertySimpleEntry *pEntry = pPropSet->getPropertyMap()->getByName( pProps[i].Name );
2115         if (pEntry)
2116         {
2117             // Note: there is no need to take special care of the properties
2118             //      TextField (EE_FEATURE_FIELD) and
2119             //      TextPortionType (WID_PORTIONTYPE)
2120             //  since they are read-only and thus are already taken care of below.
2121
2122             if (pEntry->nFlags & beans::PropertyAttribute::READONLY)
2123                 // should be PropertyVetoException which is not yet defined for the new import API's functions
2124                 throw uno::RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + pProps[i].Name, static_cast < cppu::OWeakObject * > ( 0 ) );
2125                 //throw PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + pProps[i].Name, static_cast < cppu::OWeakObject * > ( 0 ) );
2126
2127             if (pEntry->nWID == WID_FONTDESC)
2128             {
2129                 awt::FontDescriptor aDesc;
2130                 if (pProps[i].Value >>= aDesc)
2131                     SvxUnoFontDescriptor::FillItemSet( aDesc, rItemSet );
2132             }
2133             else if (pEntry->nWID == WID_NUMLEVEL)
2134             {
2135                 if (pForwarder)
2136                 {
2137                     sal_Int16 nLevel = -1;
2138                     pProps[i].Value >>= nLevel;
2139
2140                     // #101004# Call interface method instead of unsafe cast
2141                     if (!pForwarder->SetDepth( nPara, nLevel ))
2142                         throw lang::IllegalArgumentException();
2143                 }
2144             }
2145             else if (pEntry->nWID == WID_NUMBERINGSTARTVALUE )
2146             {
2147                 if( pForwarder )
2148                 {
2149                     sal_Int16 nStartValue = -1;
2150                     if( !(pProps[i].Value >>= nStartValue) )
2151                         throw lang::IllegalArgumentException();
2152
2153                     pForwarder->SetNumberingStartValue( nPara, nStartValue );
2154                 }
2155             }
2156             else if (pEntry->nWID == WID_PARAISNUMBERINGRESTART )
2157             {
2158                 if( pForwarder )
2159                 {
2160                     sal_Bool bParaIsNumberingRestart = sal_False;
2161                     if( !(pProps[i].Value >>= bParaIsNumberingRestart) )
2162                         throw lang::IllegalArgumentException();
2163
2164                     pForwarder->SetParaIsNumberingRestart( nPara, bParaIsNumberingRestart );
2165                 }
2166             }
2167             else
2168                 pPropSet->setPropertyValue( pProps[i].Name, pProps[i].Value, rItemSet );
2169         }
2170         else
2171             throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pProps[i].Name, static_cast < cppu::OWeakObject * > ( 0 ) );
2172     }
2173 }
2174
2175 // com::sun::star::text::XParagraphAppend (new import API)
2176 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::appendParagraph(
2177         const uno::Sequence< beans::PropertyValue >& rCharAndParaProps )
2178     throw (lang::IllegalArgumentException, beans::UnknownPropertyException, uno::RuntimeException)
2179 {
2180     OGuard aGuard( Application::GetSolarMutex() );
2181     uno::Reference< text::XTextRange > xRet;
2182     SvxEditSource *pEditSource = GetEditSource();
2183     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : 0;
2184     if (pTextForwarder)
2185     {
2186         USHORT nParaCount = pTextForwarder->GetParagraphCount();
2187         DBG_ASSERT( nParaCount > 0, "paragraph count is 0 or negative" );
2188         pTextForwarder->AppendParagraph();
2189
2190         // set properties for new appended (now last) paragraph
2191         ESelection aSel( nParaCount, 0, nParaCount, 0 );
2192         SfxItemSet aItemSet( *pTextForwarder->GetEmptyItemSetPtr() );
2193         SvxPropertyValuesToItemSet( aItemSet, rCharAndParaProps,
2194                             ImplGetSvxUnoOutlinerTextCursorSfxPropertySet(),
2195                             pTextForwarder,
2196                             nParaCount );
2197         pTextForwarder->QuickSetAttribs( aItemSet, aSel );
2198         pEditSource->UpdateData();
2199         SvxUnoTextRange* pRange = new SvxUnoTextRange( *this );
2200         xRet = pRange;
2201         pRange->SetSelection( aSel );
2202     }
2203     return xRet;
2204 }
2205
2206 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::finishParagraph(
2207         const uno::Sequence< beans::PropertyValue >& rCharAndParaProps )
2208     throw (lang::IllegalArgumentException, beans::UnknownPropertyException, uno::RuntimeException)
2209 {
2210     OGuard aGuard( Application::GetSolarMutex() );
2211
2212     uno::Reference< text::XTextRange > xRet;
2213     SvxEditSource *pEditSource = GetEditSource();
2214     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : 0;
2215     if (pTextForwarder)
2216     {
2217         USHORT nParaCount = pTextForwarder->GetParagraphCount();
2218         DBG_ASSERT( nParaCount > 0, "paragraph count is 0 or negative" );
2219         pTextForwarder->AppendParagraph();
2220
2221         // set properties for the previously last paragraph
2222         USHORT nPara = nParaCount - 1;
2223         ESelection aSel( nPara, 0, nPara, 0 );
2224         SfxItemSet aItemSet( *pTextForwarder->GetEmptyItemSetPtr() );
2225         SvxPropertyValuesToItemSet( aItemSet, rCharAndParaProps,
2226                 ImplGetSvxUnoOutlinerTextCursorSfxPropertySet(), pTextForwarder, nPara );
2227         pTextForwarder->QuickSetAttribs( aItemSet, aSel );
2228         pEditSource->UpdateData();
2229         SvxUnoTextRange* pRange = new SvxUnoTextRange( *this );
2230         xRet = pRange;
2231         pRange->SetSelection( aSel );
2232     }
2233     return xRet;
2234 }
2235
2236 // com::sun::star::text::XTextPortionAppend (new import API)
2237 uno::Reference< text::XTextRange > SAL_CALL SvxUnoTextBase::appendTextPortion(
2238         const ::rtl::OUString& rText,
2239         const uno::Sequence< beans::PropertyValue >& rCharAndParaProps )
2240     throw (lang::IllegalArgumentException, beans::UnknownPropertyException, uno::RuntimeException)
2241 {
2242     OGuard aGuard( Application::GetSolarMutex() );
2243
2244     SvxEditSource *pEditSource = GetEditSource();
2245     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : 0;
2246     uno::Reference< text::XTextRange > xRet;
2247     if (pTextForwarder)
2248     {
2249         USHORT nParaCount = pTextForwarder->GetParagraphCount();
2250         DBG_ASSERT( nParaCount > 0, "paragraph count is 0 or negative" );
2251         USHORT nPara = nParaCount - 1;
2252         SfxItemSet aSet( pTextForwarder->GetParaAttribs( nPara ) );
2253         xub_StrLen nStart = pTextForwarder->AppendTextPortion( nPara, rText, aSet );
2254         pEditSource->UpdateData();
2255         xub_StrLen nEnd   = pTextForwarder->GetTextLen( nPara );
2256
2257         // set properties for the new text portion
2258         ESelection aSel( nPara, nStart, nPara, nEnd );
2259         pTextForwarder->RemoveAttribs( aSel, sal_False, 0 );
2260         pEditSource->UpdateData();
2261
2262         SfxItemSet aItemSet( *pTextForwarder->GetEmptyItemSetPtr() );
2263         SvxPropertyValuesToItemSet( aItemSet, rCharAndParaProps,
2264                 ImplGetSvxTextPortionSfxPropertySet(), pTextForwarder, nPara );
2265         pTextForwarder->QuickSetAttribs( aItemSet, aSel );
2266         SvxUnoTextRange* pRange = new SvxUnoTextRange( *this );
2267         xRet = pRange;
2268         pRange->SetSelection( aSel );
2269         const beans::PropertyValue* pProps = rCharAndParaProps.getConstArray();
2270         for( sal_Int32 nProp = 0; nProp < rCharAndParaProps.getLength(); ++nProp )
2271             pRange->setPropertyValue( pProps[nProp].Name, pProps[nProp].Value );
2272     }
2273     return xRet;
2274 }
2275 /*-- 25.03.2008 08:16:09---------------------------------------------------
2276
2277   -----------------------------------------------------------------------*/
2278 void SvxUnoTextBase::copyText(
2279     const uno::Reference< text::XTextCopy >& xSource ) throw ( uno::RuntimeException )
2280 {
2281     OGuard aGuard( Application::GetSolarMutex() );
2282     uno::Reference< lang::XUnoTunnel > xUT( xSource, uno::UNO_QUERY );
2283     SvxEditSource *pEditSource = GetEditSource();
2284     SvxTextForwarder *pTextForwarder = pEditSource ? pEditSource->GetTextForwarder() : 0;
2285     if( !pTextForwarder )
2286         return;
2287     if( xUT.is() )
2288     {
2289         SvxUnoTextBase* pSource = reinterpret_cast<SvxUnoTextBase*>(sal::static_int_cast<sal_uIntPtr>(
2290                                                                     xUT->getSomething( SvxUnoTextBase::getUnoTunnelId())));
2291         SvxEditSource *pSourceEditSource = pSource->GetEditSource();
2292         SvxTextForwarder *pSourceTextForwarder = pSourceEditSource ? pSourceEditSource->GetTextForwarder() : 0;
2293         if( pSourceTextForwarder )
2294         {
2295             pTextForwarder->CopyText( *pSourceTextForwarder );
2296             pEditSource->UpdateData();
2297         }
2298     }
2299     else
2300     {
2301         uno::Reference< text::XText > xSourceText( xSource, uno::UNO_QUERY );
2302         if( xSourceText.is() )
2303         {
2304             setString( xSourceText->getString() );
2305         }
2306     }
2307 }
2308
2309 // lang::XServiceInfo
2310 OUString SAL_CALL SvxUnoTextBase::getImplementationName()
2311     throw(uno::RuntimeException)
2312 {
2313     return OUString(RTL_CONSTASCII_USTRINGPARAM("SvxUnoTextBase"));
2314 }
2315
2316 uno::Sequence< OUString > SAL_CALL SvxUnoTextBase::getSupportedServiceNames(  )
2317     throw(uno::RuntimeException)
2318 {
2319     return getSupportedServiceNames_Static();
2320 }
2321
2322 uno::Sequence< OUString > SAL_CALL SvxUnoTextBase::getSupportedServiceNames_Static(  )
2323     SAL_THROW(())
2324 {
2325     uno::Sequence< OUString > aSeq( SvxUnoTextRangeBase::getSupportedServiceNames_Static() );
2326     SvxServiceInfoHelper::addToSequence( aSeq, 1, "com.sun.star.text.Text" );
2327     return aSeq;
2328 }
2329
2330 const uno::Sequence< sal_Int8 > & SvxUnoTextBase::getUnoTunnelId() throw()
2331 {
2332     static uno::Sequence< sal_Int8 > * pSeq = 0;
2333     if( !pSeq )
2334     {
2335         ::osl::Guard< ::osl::Mutex > aGuard( ::osl::Mutex::getGlobalMutex() );
2336         if( !pSeq )
2337         {
2338             static uno::Sequence< sal_Int8 > aSeq( 16 );
2339             rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
2340             pSeq = &aSeq;
2341         }
2342     }
2343     return *pSeq;
2344 }
2345
2346 SvxUnoTextBase* SvxUnoTextBase::getImplementation( const uno::Reference< uno::XInterface >& xInt )
2347 {
2348     uno::Reference< lang::XUnoTunnel > xUT( xInt, uno::UNO_QUERY );
2349     if( xUT.is() )
2350         return reinterpret_cast<SvxUnoTextBase*>(sal::static_int_cast<sal_uIntPtr>(xUT->getSomething( SvxUnoTextBase::getUnoTunnelId())));
2351     else
2352         return NULL;
2353 }
2354
2355 sal_Int64 SAL_CALL SvxUnoTextBase::getSomething( const uno::Sequence< sal_Int8 >& rId ) throw(uno::RuntimeException) \
2356 {
2357     if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
2358                                                          rId.getConstArray(), 16 ) )
2359     {
2360         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
2361     }
2362     else
2363     {
2364         return SvxUnoTextRangeBase::getSomething( rId );
2365     }
2366 }
2367
2368 // --------------------------------------------------------------------
2369
2370 SvxUnoText::SvxUnoText( ) throw()
2371 {
2372 }
2373
2374 SvxUnoText::SvxUnoText( const SvxItemPropertySet* _pSet ) throw()
2375 : SvxUnoTextBase( _pSet )
2376 {
2377 }
2378
2379 SvxUnoText::SvxUnoText( const SvxEditSource* pSource, const SvxItemPropertySet* _pSet, uno::Reference < text::XText > xParent ) throw()
2380 : SvxUnoTextBase( pSource, _pSet, xParent )
2381 {
2382 }
2383
2384 SvxUnoText::SvxUnoText( const SvxUnoText& rText ) throw()
2385 : SvxUnoTextBase( rText )
2386 , cppu::OWeakAggObject()
2387 {
2388 }
2389
2390 SvxUnoText::~SvxUnoText() throw()
2391 {
2392 }
2393
2394 uno::Sequence< uno::Type > SAL_CALL getStaticTypes() throw()
2395 {
2396     return SvxUnoTextBase::getStaticTypes();
2397 }
2398
2399 // uno::XInterface
2400 uno::Any SAL_CALL SvxUnoText::queryAggregation( const uno::Type & rType ) throw( uno::RuntimeException )
2401 {
2402     uno::Any aAny( SvxUnoTextBase::queryAggregation( rType ) );
2403     if( !aAny.hasValue() )
2404         aAny = OWeakAggObject::queryAggregation( rType );
2405
2406     return aAny;
2407 }
2408
2409 uno::Any SAL_CALL SvxUnoText::queryInterface( const uno::Type & rType ) throw( uno::RuntimeException )
2410 {
2411     return OWeakAggObject::queryInterface( rType );
2412 }
2413
2414 void SAL_CALL SvxUnoText::acquire() throw( )
2415 {
2416     OWeakAggObject::acquire();
2417 }
2418
2419 void SAL_CALL SvxUnoText::release() throw( )
2420 {
2421     OWeakAggObject::release();
2422 }
2423
2424 // lang::XTypeProvider
2425 uno::Sequence< uno::Type > SAL_CALL SvxUnoText::getTypes(  ) throw( uno::RuntimeException )
2426 {
2427     return SvxUnoTextBase::getTypes();
2428 }
2429
2430 uno::Sequence< sal_Int8 > SAL_CALL SvxUnoText::getImplementationId(  ) throw( uno::RuntimeException )
2431 {
2432     static uno::Sequence< sal_Int8 > aId;
2433     if( aId.getLength() == 0 )
2434     {
2435         aId.realloc( 16 );
2436         rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
2437     }
2438     return aId;
2439 }
2440
2441 SvxUnoText* SvxUnoText::getImplementation( const uno::Reference< uno::XInterface >& xInt )
2442 {
2443     uno::Reference< lang::XUnoTunnel > xUT( xInt, uno::UNO_QUERY );
2444     if( xUT.is() )
2445         return reinterpret_cast<SvxUnoText*>(sal::static_int_cast<sal_uIntPtr>(xUT->getSomething( SvxUnoText::getUnoTunnelId())));
2446     else
2447         return NULL;
2448 }
2449
2450 const uno::Sequence< sal_Int8 > & SvxUnoText::getUnoTunnelId() throw()
2451 {
2452     static uno::Sequence< sal_Int8 > * pSeq = 0;
2453     if( !pSeq )
2454     {
2455         ::osl::Guard< ::osl::Mutex > aGuard( ::osl::Mutex::getGlobalMutex() );
2456         if( !pSeq )
2457         {
2458             static uno::Sequence< sal_Int8 > aSeq( 16 );
2459             rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
2460             pSeq = &aSeq;
2461         }
2462     }
2463     return *pSeq;
2464 }
2465
2466 sal_Int64 SAL_CALL SvxUnoText::getSomething( const uno::Sequence< sal_Int8 >& rId ) throw(uno::RuntimeException) \
2467 {
2468     if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
2469                                                          rId.getConstArray(), 16 ) )
2470     {
2471         return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
2472     }
2473     else
2474     {
2475         return SvxUnoTextBase::getSomething( rId );
2476     }
2477 }
2478
2479
2480 // --------------------------------------------------------------------
2481
2482 SvxDummyTextSource::~SvxDummyTextSource()
2483 {
2484 };
2485
2486 SvxEditSource* SvxDummyTextSource::Clone() const
2487 {
2488     return new SvxDummyTextSource();
2489 }
2490
2491 SvxTextForwarder* SvxDummyTextSource::GetTextForwarder()
2492 {
2493     return this;
2494 }
2495
2496 void SvxDummyTextSource::UpdateData()
2497 {
2498 }
2499
2500 sal_uInt16 SvxDummyTextSource::GetParagraphCount() const
2501 {
2502     return 0;
2503 }
2504
2505 sal_uInt16 SvxDummyTextSource::GetTextLen( sal_uInt16 ) const
2506 {
2507     return 0;
2508 }
2509
2510 String SvxDummyTextSource::GetText( const ESelection& ) const
2511 {
2512     return String();
2513 }
2514
2515 SfxItemSet SvxDummyTextSource::GetAttribs( const ESelection&, BOOL ) const
2516 {
2517     // AW: Very dangerous: The former implementation used a SfxItemPool created on the
2518     // fly which of course was deleted again ASAP. Thus, the returned SfxItemSet was using
2519     // a deleted Pool by design.
2520     return SfxItemSet(SdrObject::GetGlobalDrawObjectItemPool());
2521 }
2522
2523 SfxItemSet SvxDummyTextSource::GetParaAttribs( sal_uInt16 ) const
2524 {
2525     return GetAttribs(ESelection());
2526 }
2527
2528 void SvxDummyTextSource::SetParaAttribs( sal_uInt16, const SfxItemSet& )
2529 {
2530 }
2531
2532 void SvxDummyTextSource::RemoveAttribs( const ESelection& , sal_Bool , sal_uInt16 )
2533 {
2534 }
2535
2536 void SvxDummyTextSource::GetPortions( sal_uInt16, SvUShorts& ) const
2537 {
2538 }
2539
2540 sal_uInt16 SvxDummyTextSource::GetItemState( const ESelection&, sal_uInt16 ) const
2541 {
2542     return 0;
2543 }
2544
2545 sal_uInt16 SvxDummyTextSource::GetItemState( sal_uInt16, sal_uInt16 ) const
2546 {
2547     return 0;
2548 }
2549
2550 SfxItemPool* SvxDummyTextSource::GetPool() const
2551 {
2552     return NULL;
2553 }
2554
2555 void SvxDummyTextSource::QuickInsertText( const String&, const ESelection& )
2556 {
2557 }
2558
2559 void SvxDummyTextSource::QuickInsertField( const SvxFieldItem&, const ESelection& )
2560 {
2561 }
2562
2563 void SvxDummyTextSource::QuickSetAttribs( const SfxItemSet&, const ESelection& )
2564 {
2565 }
2566
2567 void SvxDummyTextSource::QuickInsertLineBreak( const ESelection& )
2568 {
2569 };
2570
2571 XubString SvxDummyTextSource::CalcFieldValue( const SvxFieldItem&, sal_uInt16, sal_uInt16, Color*&, Color*& )
2572 {
2573     return XubString();
2574 }
2575
2576 sal_Bool SvxDummyTextSource::IsValid() const
2577 {
2578     return sal_False;
2579 }
2580
2581 void SvxDummyTextSource::SetNotifyHdl( const Link& )
2582 {
2583 }
2584
2585 LanguageType SvxDummyTextSource::GetLanguage( USHORT, USHORT ) const
2586 {
2587     return LANGUAGE_DONTKNOW;
2588 }
2589
2590 USHORT SvxDummyTextSource::GetFieldCount( USHORT ) const
2591 {
2592     return 0;
2593 }
2594
2595 EFieldInfo SvxDummyTextSource::GetFieldInfo( USHORT, USHORT ) const
2596 {
2597     return EFieldInfo();
2598 }
2599
2600 EBulletInfo SvxDummyTextSource::GetBulletInfo( USHORT ) const
2601 {
2602     return EBulletInfo();
2603 }
2604
2605 Rectangle SvxDummyTextSource::GetCharBounds( USHORT, USHORT ) const
2606 {
2607     return Rectangle();
2608 }
2609
2610 Rectangle SvxDummyTextSource::GetParaBounds( USHORT ) const
2611 {
2612     return Rectangle();
2613 }
2614
2615 MapMode SvxDummyTextSource::GetMapMode() const
2616 {
2617     return MapMode();
2618 }
2619
2620 OutputDevice* SvxDummyTextSource::GetRefDevice() const
2621 {
2622     return NULL;
2623 }
2624
2625 sal_Bool SvxDummyTextSource::GetIndexAtPoint( const Point&, USHORT&, USHORT& ) const
2626 {
2627     return sal_False;
2628 }
2629
2630 sal_Bool SvxDummyTextSource::GetWordIndices( USHORT, USHORT, USHORT&, USHORT& ) const
2631 {
2632     return sal_False;
2633 }
2634
2635 sal_Bool SvxDummyTextSource::GetAttributeRun( USHORT&, USHORT&, USHORT, USHORT ) const
2636 {
2637     return sal_False;
2638 }
2639
2640 USHORT SvxDummyTextSource::GetLineCount( USHORT ) const
2641 {
2642     return 0;
2643 }
2644
2645 USHORT SvxDummyTextSource::GetLineLen( USHORT, USHORT ) const
2646 {
2647     return 0;
2648 }
2649
2650 void SvxDummyTextSource::GetLineBoundaries( /*out*/USHORT &rStart, /*out*/USHORT &rEnd, USHORT /*nParagraph*/, USHORT /*nLine*/ ) const
2651 {
2652     rStart = rEnd = 0;
2653 }
2654
2655 USHORT SvxDummyTextSource::GetLineNumberAtIndex( USHORT /*nPara*/, USHORT /*nIndex*/ ) const
2656 {
2657     return 0;
2658 }
2659
2660 sal_Bool SvxDummyTextSource::QuickFormatDoc( BOOL )
2661 {
2662     return sal_False;
2663 }
2664
2665 sal_Int16 SvxDummyTextSource::GetDepth( USHORT ) const
2666 {
2667     return -1;
2668 }
2669
2670 sal_Bool SvxDummyTextSource::SetDepth( USHORT, sal_Int16 nNewDepth )
2671 {
2672     return nNewDepth == 0 ? sal_True : sal_False;
2673 }
2674
2675 sal_Bool SvxDummyTextSource::Delete( const ESelection& )
2676 {
2677     return sal_False;
2678 }
2679
2680 sal_Bool SvxDummyTextSource::InsertText( const String&, const ESelection& )
2681 {
2682     return sal_False;
2683 }
2684
2685 const SfxItemSet * SvxDummyTextSource::GetEmptyItemSetPtr()
2686 {
2687     return 0;
2688 }
2689
2690 void SvxDummyTextSource::AppendParagraph()
2691 {
2692 }
2693
2694 xub_StrLen SvxDummyTextSource::AppendTextPortion( USHORT, const String &, const SfxItemSet & )
2695 {
2696     return 0;
2697 }
2698
2699 void  SvxDummyTextSource::CopyText(const SvxTextForwarder& )
2700 {
2701 }
2702