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