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_sw.hxx" 26 27 #include <com/sun/star/table/TableSortField.hpp> 28 29 #include <osl/endian.h> 30 #include <rtl/ustrbuf.hxx> 31 #include <unotools/collatorwrapper.hxx> 32 #include <swtypes.hxx> 33 #include <hintids.hxx> 34 #include <cmdid.h> 35 #include <hints.hxx> 36 #include <IMark.hxx> 37 #include <frmfmt.hxx> 38 #include <doc.hxx> 39 #include <IDocumentUndoRedo.hxx> 40 #include <istyleaccess.hxx> 41 #include <ndtxt.hxx> 42 #include <ndnotxt.hxx> 43 #include <unocrsr.hxx> 44 #include <unocrsrhelper.hxx> 45 #include <swundo.hxx> 46 #include <rootfrm.hxx> 47 #include <flyfrm.hxx> 48 #include <ftnidx.hxx> 49 #include <sfx2/linkmgr.hxx> 50 #include <docary.hxx> 51 #include <paratr.hxx> 52 #include <tools/urlobj.hxx> 53 #include <pam.hxx> 54 #include <tools/cachestr.hxx> 55 #include <shellio.hxx> 56 #include <swerror.h> 57 #include <swtblfmt.hxx> 58 #include <fmtruby.hxx> 59 #include <docsh.hxx> 60 #include <docstyle.hxx> 61 #include <charfmt.hxx> 62 #include <txtfld.hxx> 63 #include <fmtfld.hxx> 64 #include <fmtpdsc.hxx> 65 #include <pagedesc.hxx> 66 #include <poolfmt.hrc> 67 #include <poolfmt.hxx> 68 #include <edimp.hxx> 69 #include <fchrfmt.hxx> 70 #include <fmtautofmt.hxx> 71 #include <cntfrm.hxx> 72 #include <pagefrm.hxx> 73 #include <doctxm.hxx> 74 #include <sfx2/docfilt.hxx> 75 #include <sfx2/docfile.hxx> 76 #include <sfx2/fcontnr.hxx> 77 #include <fmtrfmrk.hxx> 78 #include <txtrfmrk.hxx> 79 #include <unotextrange.hxx> 80 #include <unotextcursor.hxx> 81 #include <unomap.hxx> 82 #include <unosett.hxx> 83 #include <unoprnms.hxx> 84 #include <unotbl.hxx> 85 #include <unodraw.hxx> 86 #include <unocoll.hxx> 87 #include <unostyle.hxx> 88 #include <unofield.hxx> 89 #include <unometa.hxx> 90 #include <fmtanchr.hxx> 91 #include <editeng/flstitem.hxx> 92 #include <svtools/ctrltool.hxx> 93 #include <flypos.hxx> 94 #include <txtftn.hxx> 95 #include <fmtftn.hxx> 96 #include <com/sun/star/text/WrapTextMode.hpp> 97 #include <com/sun/star/text/TextContentAnchorType.hpp> 98 #include <com/sun/star/style/PageStyleLayout.hpp> 99 #include <com/sun/star/text/XTextDocument.hpp> 100 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp> 101 #include <com/sun/star/drawing/XDrawPageSupplier.hpp> 102 #include <com/sun/star/text/TextMarkupType.hpp> 103 #include <unoidx.hxx> 104 #include <unoframe.hxx> 105 #include <fmthdft.hxx> 106 #include <vos/mutex.hxx> 107 #include <vcl/svapp.hxx> 108 #include <fmtflcnt.hxx> 109 #define _SVSTDARR_USHORTS 110 #define _SVSTDARR_USHORTSSORT 111 #include <svl/svstdarr.hxx> 112 #include <editeng/brshitem.hxx> 113 #include <editeng/unolingu.hxx> 114 #include <fmtclds.hxx> 115 #include <dcontact.hxx> 116 #include <SwStyleNameMapper.hxx> 117 #include <crsskip.hxx> 118 #include <sortopt.hxx> 119 #include <com/sun/star/beans/PropertyAttribute.hpp> 120 #include <memory> 121 #include <unoparaframeenum.hxx> 122 #include <unoparagraph.hxx> 123 124 125 using namespace ::com::sun::star; 126 using ::rtl::OUString; 127 using ::rtl::OUStringBuffer; 128 129 130 /**************************************************************************** 131 static methods 132 ****************************************************************************/ 133 uno::Sequence< sal_Int8 > CreateUnoTunnelId() 134 { 135 static osl::Mutex aCreateMutex; 136 osl::Guard<osl::Mutex> aGuard( aCreateMutex ); 137 uno::Sequence< sal_Int8 > aSeq( 16 ); 138 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); 139 return aSeq; 140 } 141 /**************************************************************************** 142 Hilfsklassen 143 ****************************************************************************/ 144 145 /* -----------------13.05.98 12:15------------------- 146 * 147 * --------------------------------------------------*/ 148 SwUnoInternalPaM::SwUnoInternalPaM(SwDoc& rDoc) : 149 SwPaM(rDoc.GetNodes()) 150 { 151 } 152 SwUnoInternalPaM::~SwUnoInternalPaM() 153 { 154 while( GetNext() != this) 155 { 156 delete GetNext(); 157 } 158 } 159 160 SwUnoInternalPaM& SwUnoInternalPaM::operator=(const SwPaM& rPaM) 161 { 162 const SwPaM* pTmp = &rPaM; 163 *GetPoint() = *rPaM.GetPoint(); 164 if(rPaM.HasMark()) 165 { 166 SetMark(); 167 *GetMark() = *rPaM.GetMark(); 168 } 169 else 170 DeleteMark(); 171 while(&rPaM != (pTmp = (const SwPaM*)pTmp->GetNext())) 172 { 173 if(pTmp->HasMark()) 174 new SwPaM(*pTmp->GetMark(), *pTmp->GetPoint(), this); 175 else 176 new SwPaM(*pTmp->GetPoint(), this); 177 } 178 return *this; 179 } 180 181 /*-----------------09.03.98 08:29------------------- 182 183 --------------------------------------------------*/ 184 void SwUnoCursorHelper::SelectPam(SwPaM & rPam, const bool bExpand) 185 { 186 if (bExpand) 187 { 188 if (!rPam.HasMark()) 189 { 190 rPam.SetMark(); 191 } 192 } 193 else if (rPam.HasMark()) 194 { 195 rPam.DeleteMark(); 196 } 197 } 198 199 /* -----------------20.05.98 14:59------------------- 200 * 201 * --------------------------------------------------*/ 202 void SwUnoCursorHelper::GetTextFromPam(SwPaM & rPam, OUString & rBuffer) 203 { 204 if (!rPam.HasMark()) 205 { 206 return; 207 } 208 SvCacheStream aStream( 20480 ); 209 #ifdef OSL_BIGENDIAN 210 aStream.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN ); 211 #else 212 aStream.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN ); 213 #endif 214 WriterRef xWrt; 215 // TODO/MBA: looks like a BaseURL doesn't make sense here 216 SwReaderWriter::GetWriter( C2S(FILTER_TEXT_DLG), String(), xWrt ); 217 if( xWrt.Is() ) 218 { 219 SwWriter aWriter( aStream, rPam ); 220 xWrt->bASCII_NoLastLineEnd = sal_True; 221 xWrt->bExportPargraphNumbering = sal_False; 222 SwAsciiOptions aOpt = xWrt->GetAsciiOptions(); 223 aOpt.SetCharSet( RTL_TEXTENCODING_UNICODE ); 224 xWrt->SetAsciiOptions( aOpt ); 225 xWrt->bUCS2_WithStartChar = sal_False; 226 // --> FME #i68522# 227 const sal_Bool bOldShowProgress = xWrt->bShowProgress; 228 xWrt->bShowProgress = sal_False; 229 // <-- 230 231 long lLen; 232 if( !IsError( aWriter.Write( xWrt ) ) && 233 0x7ffffff > (( lLen = aStream.GetSize() ) 234 / sizeof( sal_Unicode )) + 1 ) 235 { 236 aStream << (sal_Unicode)'\0'; 237 238 long lUniLen = (lLen / sizeof( sal_Unicode )); 239 ::rtl::OUStringBuffer aStrBuffer( lUniLen ); 240 aStream.Seek( 0 ); 241 aStream.ResetError(); 242 while(lUniLen) 243 { 244 String sBuf; 245 sal_Int32 nLocalLen = 0; 246 if( lUniLen >= STRING_MAXLEN ) 247 { 248 nLocalLen = STRING_MAXLEN - 1; 249 } 250 else 251 { 252 nLocalLen = lUniLen; 253 } 254 sal_Unicode *const pStrBuf = 255 sBuf.AllocBuffer( xub_StrLen( nLocalLen + 1)); 256 aStream.Read( pStrBuf, 2 * nLocalLen ); 257 pStrBuf[ nLocalLen ] = '\0'; 258 aStrBuffer.append( pStrBuf, nLocalLen ); 259 lUniLen -= nLocalLen; 260 } 261 rBuffer = aStrBuffer.makeStringAndClear(); 262 } 263 xWrt->bShowProgress = bOldShowProgress; 264 } 265 } 266 267 /* -----------------06.07.98 07:33------------------- 268 * 269 * --------------------------------------------------*/ 270 static void 271 lcl_setCharStyle(SwDoc *const pDoc, const uno::Any & rValue, SfxItemSet & rSet) 272 throw (lang::IllegalArgumentException) 273 { 274 SwDocShell *const pDocSh = pDoc->GetDocShell(); 275 if(pDocSh) 276 { 277 OUString uStyle; 278 if (!(rValue >>= uStyle)) 279 { 280 throw lang::IllegalArgumentException(); 281 } 282 String sStyle; 283 SwStyleNameMapper::FillUIName(uStyle, sStyle, 284 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True); 285 SwDocStyleSheet *const pStyle = static_cast<SwDocStyleSheet*>( 286 pDocSh->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_CHAR)); 287 if (!pStyle) 288 { 289 throw lang::IllegalArgumentException(); 290 } 291 const SwFmtCharFmt aFmt(pStyle->GetCharFmt()); 292 rSet.Put(aFmt); 293 } 294 }; 295 /* -----------------08.06.06 10:43------------------- 296 * 297 * --------------------------------------------------*/ 298 static void 299 lcl_setAutoStyle(IStyleAccess & rStyleAccess, const uno::Any & rValue, 300 SfxItemSet & rSet, const bool bPara) 301 throw (lang::IllegalArgumentException) 302 { 303 OUString uStyle; 304 if (!(rValue >>= uStyle)) 305 { 306 throw lang::IllegalArgumentException(); 307 } 308 StylePool::SfxItemSet_Pointer_t pStyle = bPara ? 309 rStyleAccess.getByName(uStyle, IStyleAccess::AUTO_STYLE_PARA ): 310 rStyleAccess.getByName(uStyle, IStyleAccess::AUTO_STYLE_CHAR ); 311 if(pStyle.get()) 312 { 313 SwFmtAutoFmt aFmt( (bPara) 314 ? sal::static_int_cast< sal_uInt16 >(RES_AUTO_STYLE) 315 : sal::static_int_cast< sal_uInt16 >(RES_TXTATR_AUTOFMT) ); 316 aFmt.SetStyleHandle( pStyle ); 317 rSet.Put(aFmt); 318 } 319 else 320 { 321 throw lang::IllegalArgumentException(); 322 } 323 }; 324 /* -----------------30.06.98 08:46------------------- 325 * 326 * --------------------------------------------------*/ 327 void 328 SwUnoCursorHelper::SetTxtFmtColl(const uno::Any & rAny, SwPaM & rPaM) 329 throw (lang::IllegalArgumentException) 330 { 331 SwDoc *const pDoc = rPaM.GetDoc(); 332 SwDocShell *const pDocSh = pDoc->GetDocShell(); 333 if(!pDocSh) 334 return; 335 OUString uStyle; 336 rAny >>= uStyle; 337 String sStyle; 338 SwStyleNameMapper::FillUIName(uStyle, sStyle, 339 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True ); 340 SwDocStyleSheet *const pStyle = static_cast<SwDocStyleSheet*>( 341 pDocSh->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_PARA)); 342 if (!pStyle) 343 { 344 throw lang::IllegalArgumentException(); 345 } 346 347 SwTxtFmtColl *const pLocal = pStyle->GetCollection(); 348 UnoActionContext aAction(pDoc); 349 pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL ); 350 SwPaM *pTmpCrsr = &rPaM; 351 do { 352 pDoc->SetTxtFmtColl(*pTmpCrsr, pLocal); 353 pTmpCrsr = static_cast<SwPaM*>(pTmpCrsr->GetNext()); 354 } while ( pTmpCrsr != &rPaM ); 355 pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL ); 356 } 357 358 /* -----------------06.07.98 07:38------------------- 359 * 360 * --------------------------------------------------*/ 361 bool 362 SwUnoCursorHelper::SetPageDesc( 363 const uno::Any& rValue, SwDoc & rDoc, SfxItemSet & rSet) 364 { 365 OUString uDescName; 366 if (!(rValue >>= uDescName)) 367 { 368 return false; 369 } 370 ::std::auto_ptr<SwFmtPageDesc> pNewDesc; 371 const SfxPoolItem* pItem; 372 if(SFX_ITEM_SET == rSet.GetItemState( RES_PAGEDESC, sal_True, &pItem ) ) 373 { 374 pNewDesc.reset(new SwFmtPageDesc( 375 *static_cast<const SwFmtPageDesc*>(pItem))); 376 } 377 if (!pNewDesc.get()) 378 { 379 pNewDesc.reset(new SwFmtPageDesc()); 380 } 381 String sDescName; 382 SwStyleNameMapper::FillUIName(uDescName, sDescName, 383 nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True); 384 if (!pNewDesc->GetPageDesc() || 385 (pNewDesc->GetPageDesc()->GetName() != sDescName)) 386 { 387 sal_Bool bPut = sal_False; 388 if(sDescName.Len()) 389 { 390 SwPageDesc *const pPageDesc = 391 ::GetPageDescByName_Impl(rDoc, sDescName); 392 if (!pPageDesc) 393 { 394 throw lang::IllegalArgumentException(); 395 } 396 pNewDesc.get()->RegisterToPageDesc( *pPageDesc ); 397 bPut = sal_True; 398 } 399 if(!bPut) 400 { 401 rSet.ClearItem(RES_BREAK); 402 rSet.Put(SwFmtPageDesc()); 403 } 404 else 405 { 406 rSet.Put(*pNewDesc); 407 } 408 } 409 return true; 410 } 411 412 /* -----------------30.06.98 10:29------------------- 413 * 414 * --------------------------------------------------*/ 415 static void 416 lcl_SetNodeNumStart(SwPaM & rCrsr, uno::Any const& rValue) 417 { 418 sal_Int16 nTmp = 1; 419 rValue >>= nTmp; 420 sal_uInt16 nStt = (nTmp < 0 ? USHRT_MAX : (sal_uInt16)nTmp); 421 SwDoc* pDoc = rCrsr.GetDoc(); 422 UnoActionContext aAction(pDoc); 423 424 if( rCrsr.GetNext() != &rCrsr ) // Mehrfachselektion ? 425 { 426 pDoc->GetIDocumentUndoRedo().StartUndo( UNDO_START, NULL ); 427 SwPamRanges aRangeArr( rCrsr ); 428 SwPaM aPam( *rCrsr.GetPoint() ); 429 for( sal_uInt16 n = 0; n < aRangeArr.Count(); ++n ) 430 { 431 pDoc->SetNumRuleStart(*aRangeArr.SetPam( n, aPam ).GetPoint()); 432 pDoc->SetNodeNumStart(*aRangeArr.SetPam( n, aPam ).GetPoint(), 433 nStt ); 434 } 435 pDoc->GetIDocumentUndoRedo().EndUndo( UNDO_END, NULL ); 436 } 437 else 438 { 439 pDoc->SetNumRuleStart( *rCrsr.GetPoint()); 440 pDoc->SetNodeNumStart( *rCrsr.GetPoint(), nStt ); 441 } 442 } 443 444 static bool 445 lcl_setCharFmtSequence(SwPaM & rPam, uno::Any const& rValue) 446 { 447 uno::Sequence<OUString> aCharStyles; 448 if (!(rValue >>= aCharStyles)) 449 { 450 return false; 451 } 452 453 for (sal_Int32 nStyle = 0; nStyle < aCharStyles.getLength(); nStyle++) 454 { 455 uno::Any aStyle; 456 rPam.GetDoc()->GetIDocumentUndoRedo().StartUndo(UNDO_START, NULL); 457 aStyle <<= aCharStyles.getConstArray()[nStyle]; 458 // create a local set and apply each format directly 459 SfxItemSet aSet(rPam.GetDoc()->GetAttrPool(), 460 RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT); 461 lcl_setCharStyle(rPam.GetDoc(), aStyle, aSet); 462 // the first style should replace the current attributes, 463 // all other have to be added 464 SwUnoCursorHelper::SetCrsrAttr(rPam, aSet, (nStyle) 465 ? nsSetAttrMode::SETATTR_DONTREPLACE 466 : nsSetAttrMode::SETATTR_DEFAULT); 467 rPam.GetDoc()->GetIDocumentUndoRedo().EndUndo(UNDO_START, NULL); 468 } 469 return true; 470 } 471 472 static void 473 lcl_setDropcapCharStyle(SwPaM & rPam, SfxItemSet & rItemSet, 474 uno::Any const& rValue) 475 { 476 OUString uStyle; 477 if (!(rValue >>= uStyle)) 478 { 479 throw lang::IllegalArgumentException(); 480 } 481 String sStyle; 482 SwStyleNameMapper::FillUIName(uStyle, sStyle, 483 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True); 484 SwDoc *const pDoc = rPam.GetDoc(); 485 //default character style must not be set as default format 486 SwDocStyleSheet *const pStyle = static_cast<SwDocStyleSheet*>( 487 pDoc->GetDocShell() 488 ->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_CHAR)); 489 if (!pStyle || 490 (static_cast<SwDocStyleSheet*>(pStyle)->GetCharFmt() == 491 pDoc->GetDfltCharFmt())) 492 { 493 throw lang::IllegalArgumentException(); 494 } 495 ::std::auto_ptr<SwFmtDrop> pDrop; 496 SfxPoolItem const* pItem(0); 497 if (SFX_ITEM_SET == 498 rItemSet.GetItemState(RES_PARATR_DROP, sal_True, &pItem)) 499 { 500 pDrop.reset(new SwFmtDrop(*static_cast<const SwFmtDrop*>(pItem))); 501 } 502 if (!pDrop.get()) 503 { 504 pDrop.reset(new SwFmtDrop); 505 } 506 const rtl::Reference<SwDocStyleSheet> xStyle(new SwDocStyleSheet(*pStyle)); 507 pDrop->SetCharFmt(xStyle->GetCharFmt()); 508 rItemSet.Put(*pDrop); 509 } 510 511 static void 512 lcl_setRubyCharstyle(SfxItemSet & rItemSet, uno::Any const& rValue) 513 { 514 OUString sTmp; 515 if (!(rValue >>= sTmp)) 516 { 517 throw lang::IllegalArgumentException(); 518 } 519 520 ::std::auto_ptr<SwFmtRuby> pRuby; 521 const SfxPoolItem* pItem; 522 if (SFX_ITEM_SET == 523 rItemSet.GetItemState(RES_TXTATR_CJK_RUBY, sal_True, &pItem)) 524 { 525 pRuby.reset(new SwFmtRuby(*static_cast<const SwFmtRuby*>(pItem))); 526 } 527 if (!pRuby.get()) 528 { 529 pRuby.reset(new SwFmtRuby(aEmptyStr)); 530 } 531 String sStyle; 532 SwStyleNameMapper::FillUIName(sTmp, sStyle, 533 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True ); 534 pRuby->SetCharFmtName(sStyle); 535 pRuby->SetCharFmtId(0); 536 if (sStyle.Len() > 0) 537 { 538 const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( 539 sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT); 540 pRuby->SetCharFmtId(nId); 541 } 542 rItemSet.Put(*pRuby); 543 } 544 545 /* -----------------17.09.98 09:44------------------- 546 * 547 * --------------------------------------------------*/ 548 bool 549 SwUnoCursorHelper::SetCursorPropertyValue( 550 SfxItemPropertySimpleEntry const& rEntry, const uno::Any& rValue, 551 SwPaM & rPam, SfxItemSet & rItemSet) 552 throw (lang::IllegalArgumentException) 553 { 554 if (!(rEntry.nFlags & beans::PropertyAttribute::MAYBEVOID) && 555 (rValue.getValueType() == ::getCppuVoidType())) 556 { 557 return false; 558 } 559 bool bRet = true; 560 switch (rEntry.nWID) 561 { 562 case RES_TXTATR_CHARFMT: 563 lcl_setCharStyle(rPam.GetDoc(), rValue, rItemSet); 564 break; 565 case RES_TXTATR_AUTOFMT: 566 lcl_setAutoStyle(rPam.GetDoc()->GetIStyleAccess(), 567 rValue, rItemSet, false); 568 break; 569 case FN_UNO_CHARFMT_SEQUENCE: 570 lcl_setCharFmtSequence(rPam, rValue); 571 break; 572 case FN_UNO_PARA_STYLE : 573 SwUnoCursorHelper::SetTxtFmtColl(rValue, rPam); 574 break; 575 case RES_AUTO_STYLE: 576 lcl_setAutoStyle(rPam.GetDoc()->GetIStyleAccess(), 577 rValue, rItemSet, true); 578 break; 579 case FN_UNO_PAGE_STYLE: 580 //FIXME nothing here? 581 break; 582 case FN_UNO_NUM_START_VALUE: 583 lcl_SetNodeNumStart( rPam, rValue ); 584 break; 585 case FN_UNO_NUM_LEVEL: 586 // --> OD 2008-07-14 #i91601# 587 case FN_UNO_LIST_ID: 588 // <-- 589 case FN_UNO_IS_NUMBER: 590 { 591 // multi selection is not considered 592 SwTxtNode *const pTxtNd = rPam.GetNode()->GetTxtNode(); 593 // --> OD 2008-05-14 #refactorlists# - check on list style not needed 594 // const SwNumRule* pRule = pTxtNd->GetNumRule(); 595 // if( FN_UNO_NUM_LEVEL == rEntry.nWID && pRule != NULL ) 596 if (FN_UNO_NUM_LEVEL == rEntry.nWID) 597 // <-- 598 { 599 sal_Int16 nLevel = 0; 600 if (rValue >>= nLevel) 601 { 602 pTxtNd->SetAttrListLevel(nLevel); 603 } 604 } 605 // --> OD 2008-07-14 #i91601# 606 else if (FN_UNO_LIST_ID == rEntry.nWID) 607 { 608 ::rtl::OUString sListId; 609 if (rValue >>= sListId) 610 { 611 pTxtNd->SetListId( sListId ); 612 } 613 } 614 // <-- 615 else if (FN_UNO_IS_NUMBER == rEntry.nWID) 616 { 617 sal_Bool bIsNumber(sal_False); 618 if (rValue >>= bIsNumber) 619 { 620 if (!bIsNumber) 621 { 622 pTxtNd->SetCountedInList( false ); 623 } 624 } 625 } 626 //PROPERTY_MAYBEVOID! 627 } 628 break; 629 case FN_NUMBER_NEWSTART: 630 { 631 sal_Bool bVal = sal_False; 632 if (!(rValue >>= bVal)) 633 { 634 throw lang::IllegalArgumentException(); 635 } 636 rPam.GetDoc()->SetNumRuleStart(*rPam.GetPoint(), bVal); 637 } 638 break; 639 case FN_UNO_NUM_RULES: 640 SwUnoCursorHelper::setNumberingProperty(rValue, rPam); 641 break; 642 case RES_PARATR_DROP: 643 { 644 if (MID_DROPCAP_CHAR_STYLE_NAME == rEntry.nMemberId) 645 { 646 lcl_setDropcapCharStyle(rPam, rItemSet, rValue); 647 } 648 else 649 { 650 bRet = false; 651 } 652 } 653 break; 654 case RES_TXTATR_CJK_RUBY: 655 { 656 if (MID_RUBY_CHARSTYLE == rEntry.nMemberId) 657 { 658 lcl_setRubyCharstyle(rItemSet, rValue); 659 } 660 else 661 { 662 bRet = false; 663 } 664 } 665 break; 666 case RES_PAGEDESC: 667 { 668 if (MID_PAGEDESC_PAGEDESCNAME == rEntry.nMemberId) 669 { 670 SwUnoCursorHelper::SetPageDesc( 671 rValue, *rPam.GetDoc(), rItemSet); 672 } 673 else 674 { 675 bRet = false; 676 } 677 } 678 break; 679 default: 680 bRet = false; 681 } 682 return bRet; 683 } 684 685 /* -----------------30.06.98 08:39------------------- 686 * 687 * --------------------------------------------------*/ 688 SwFmtColl * 689 SwUnoCursorHelper::GetCurTxtFmtColl(SwPaM & rPaM, const bool bConditional) 690 { 691 static const sal_uInt16 nMaxLookup = 1000; 692 SwFmtColl *pFmt = 0; 693 694 // if ( GetCrsrCnt() > nMaxLookup ) 695 // return 0; 696 bool bError = false; 697 SwPaM *pTmpCrsr = &rPaM; 698 do 699 { 700 const sal_uLong nSttNd = pTmpCrsr->Start()->nNode.GetIndex(); 701 const sal_uLong nEndNd = pTmpCrsr->End()->nNode.GetIndex(); 702 703 if( nEndNd - nSttNd >= nMaxLookup ) 704 { 705 pFmt = 0; 706 break; 707 } 708 709 const SwNodes& rNds = rPaM.GetDoc()->GetNodes(); 710 for( sal_uLong n = nSttNd; n <= nEndNd; ++n ) 711 { 712 SwTxtNode const*const pNd = rNds[ n ]->GetTxtNode(); 713 if( pNd ) 714 { 715 SwFmtColl *const pNdFmt = (bConditional) 716 ? pNd->GetFmtColl() : &pNd->GetAnyFmtColl(); 717 if( !pFmt ) 718 { 719 pFmt = pNdFmt; 720 } 721 else if( pFmt != pNdFmt ) 722 { 723 bError = true; 724 break; 725 } 726 } 727 } 728 729 pTmpCrsr = static_cast<SwPaM*>(pTmpCrsr->GetNext()); 730 } while ( pTmpCrsr != &rPaM ); 731 return (bError) ? 0 : pFmt; 732 } 733 734 /* -----------------26.06.98 16:20------------------- 735 * Hilfsfunktion fuer PageDesc 736 * --------------------------------------------------*/ 737 SwPageDesc* GetPageDescByName_Impl(SwDoc& rDoc, const String& rName) 738 { 739 SwPageDesc* pRet = 0; 740 sal_uInt16 nDCount = rDoc.GetPageDescCnt(); 741 sal_uInt16 i; 742 743 for( i = 0; i < nDCount; i++ ) 744 { 745 SwPageDesc* pDsc = &rDoc._GetPageDesc( i ); 746 if(pDsc->GetName() == rName) 747 { 748 pRet = pDsc; 749 break; 750 } 751 } 752 if(!pRet) 753 { 754 for(i = RC_POOLPAGEDESC_BEGIN; i <= STR_POOLPAGE_LANDSCAPE; ++i) 755 { 756 const String aFmtName(SW_RES(i)); 757 if(aFmtName == rName) 758 { 759 pRet = rDoc.GetPageDescFromPool( static_cast< sal_uInt16 >( 760 RES_POOLPAGE_BEGIN + i - RC_POOLPAGEDESC_BEGIN) ); 761 break; 762 } 763 } 764 } 765 766 return pRet; 767 } 768 769 /****************************************************************** 770 * SwXTextCursor 771 ******************************************************************/ 772 773 class SwXTextCursor::Impl 774 : public SwClient 775 { 776 777 public: 778 779 const SfxItemPropertySet & m_rPropSet; 780 const enum CursorType m_eType; 781 const uno::Reference< text::XText > m_xParentText; 782 SwEventListenerContainer m_ListenerContainer; 783 bool m_bIsDisposed; 784 785 Impl( SwXTextCursor & rThis, 786 SwDoc & rDoc, 787 const enum CursorType eType, 788 uno::Reference<text::XText> xParent, 789 SwPosition const& rPoint, SwPosition const*const pMark) 790 : SwClient(rDoc.CreateUnoCrsr(rPoint, sal_False)) 791 , m_rPropSet(*aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR)) 792 , m_eType(eType) 793 , m_xParentText(xParent) 794 , m_ListenerContainer(static_cast< ::cppu::OWeakObject* >(&rThis)) 795 , m_bIsDisposed(false) 796 { 797 if (pMark) 798 { 799 GetCursor()->SetMark(); 800 *GetCursor()->GetMark() = *pMark; 801 } 802 } 803 804 ~Impl() { 805 // Impl owns the cursor; delete it here: SolarMutex is locked 806 delete GetRegisteredIn(); 807 } 808 809 SwUnoCrsr * GetCursor() { 810 return (m_bIsDisposed) ? 0 : 811 static_cast<SwUnoCrsr*>(const_cast<SwModify*>(GetRegisteredIn())); 812 } 813 814 SwUnoCrsr & GetCursorOrThrow() { 815 SwUnoCrsr *const pUnoCursor( GetCursor() ); 816 if (!pUnoCursor) { 817 throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM( 818 "SwXTextCursor: disposed or invalid")), 0); 819 } 820 return *pUnoCursor; 821 } 822 823 void Invalidate() { 824 m_bIsDisposed = true; 825 m_ListenerContainer.Disposing(); 826 } 827 protected: 828 // SwClient 829 virtual void Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew); 830 831 }; 832 833 void SwXTextCursor::Impl::Modify(const SfxPoolItem *pOld, const SfxPoolItem *pNew) 834 { 835 ClientModify(this, pOld, pNew); 836 837 if (!GetRegisteredIn() || 838 // if the cursor leaves its designated section, it becomes invalid 839 ((pOld != NULL) && (pOld->Which() == RES_UNOCURSOR_LEAVES_SECTION))) 840 { 841 Invalidate(); 842 } 843 } 844 845 846 SwUnoCrsr const* SwXTextCursor::GetCursor() const 847 { 848 return m_pImpl->GetCursor(); 849 } 850 851 SwUnoCrsr * SwXTextCursor::GetCursor() 852 { 853 return m_pImpl->GetCursor(); 854 } 855 856 /*-- 09.12.98 14:19:01--------------------------------------------------- 857 858 -----------------------------------------------------------------------*/ 859 SwPaM const* SwXTextCursor::GetPaM() const 860 { 861 return m_pImpl->GetCursor(); 862 } 863 864 SwPaM * SwXTextCursor::GetPaM() 865 { 866 return m_pImpl->GetCursor(); 867 } 868 869 /*-- 09.12.98 14:19:02--------------------------------------------------- 870 871 -----------------------------------------------------------------------*/ 872 SwDoc const* SwXTextCursor::GetDoc() const 873 { 874 return m_pImpl->GetCursor() ? m_pImpl->GetCursor()->GetDoc() : 0; 875 } 876 /* -----------------22.07.99 13:52------------------- 877 878 --------------------------------------------------*/ 879 SwDoc * SwXTextCursor::GetDoc() 880 { 881 return m_pImpl->GetCursor() ? m_pImpl->GetCursor()->GetDoc() : 0; 882 } 883 884 885 /*-- 09.12.98 14:19:19--------------------------------------------------- 886 887 -----------------------------------------------------------------------*/ 888 SwXTextCursor::SwXTextCursor( 889 SwDoc & rDoc, 890 uno::Reference< text::XText > const& xParent, 891 const enum CursorType eType, 892 const SwPosition& rPos, 893 SwPosition const*const pMark) 894 : m_pImpl( new SwXTextCursor::Impl(*this, rDoc, eType, xParent, 895 rPos, pMark ) ) 896 { 897 } 898 899 /* -----------------04.03.99 09:02------------------- 900 * 901 * --------------------------------------------------*/ 902 SwXTextCursor::SwXTextCursor(uno::Reference< text::XText > const& xParent, 903 SwPaM const& rSourceCursor, const enum CursorType eType) 904 : m_pImpl( new SwXTextCursor::Impl(*this, *rSourceCursor.GetDoc(), eType, 905 xParent, *rSourceCursor.GetPoint(), 906 rSourceCursor.HasMark() ? rSourceCursor.GetMark() : 0) ) 907 { 908 } 909 910 /*-- 09.12.98 14:19:20--------------------------------------------------- 911 912 -----------------------------------------------------------------------*/ 913 SwXTextCursor::~SwXTextCursor() 914 { 915 } 916 917 /*-- 09.12.98 14:19:18--------------------------------------------------- 918 919 -----------------------------------------------------------------------*/ 920 void SwXTextCursor::DeleteAndInsert(const ::rtl::OUString& rText, 921 const bool bForceExpandHints) 922 { 923 SwUnoCrsr *const pUnoCrsr = m_pImpl->GetCursor(); 924 if(pUnoCrsr) 925 { 926 // Start/EndAction 927 SwDoc* pDoc = pUnoCrsr->GetDoc(); 928 UnoActionContext aAction(pDoc); 929 const xub_StrLen nTxtLen = rText.getLength(); 930 pDoc->GetIDocumentUndoRedo().StartUndo(UNDO_INSERT, NULL); 931 SwCursor * pCurrent = pUnoCrsr; 932 do 933 { 934 if (pCurrent->HasMark()) 935 { 936 pDoc->DeleteAndJoin(*pCurrent); 937 } 938 if(nTxtLen) 939 { 940 const bool bSuccess( 941 SwUnoCursorHelper::DocInsertStringSplitCR( 942 *pDoc, *pCurrent, rText, bForceExpandHints ) ); 943 DBG_ASSERT( bSuccess, "Doc->Insert(Str) failed." ); 944 (void) bSuccess; 945 946 SwUnoCursorHelper::SelectPam(*pUnoCrsr, true); 947 pCurrent->Left(rText.getLength(), 948 CRSR_SKIP_CHARS, sal_False, sal_False); 949 } 950 pCurrent = static_cast<SwCursor *>(pCurrent->GetNext()); 951 } while (pCurrent != pUnoCrsr); 952 pDoc->GetIDocumentUndoRedo().EndUndo(UNDO_INSERT, NULL); 953 } 954 } 955 956 957 enum ForceIntoMetaMode { META_CHECK_BOTH, META_INIT_START, META_INIT_END }; 958 959 static sal_Bool 960 lcl_ForceIntoMeta(SwPaM & rCursor, 961 uno::Reference<text::XText> const & xParentText, 962 const enum ForceIntoMetaMode eMode) 963 { 964 sal_Bool bRet( sal_True ); // means not forced in META_CHECK_BOTH 965 SwXMeta const * const pXMeta( dynamic_cast<SwXMeta*>(xParentText.get()) ); 966 ASSERT(pXMeta, "no parent?"); 967 if (!pXMeta) 968 throw uno::RuntimeException(); 969 SwTxtNode * pTxtNode; 970 xub_StrLen nStart; 971 xub_StrLen nEnd; 972 const bool bSuccess( pXMeta->SetContentRange(pTxtNode, nStart, nEnd) ); 973 ASSERT(bSuccess, "no pam?"); 974 if (!bSuccess) 975 throw uno::RuntimeException(); 976 // force the cursor back into the meta if it has moved outside 977 SwPosition start(*pTxtNode, nStart); 978 SwPosition end(*pTxtNode, nEnd); 979 switch (eMode) 980 { 981 case META_INIT_START: 982 *rCursor.GetPoint() = start; 983 break; 984 case META_INIT_END: 985 *rCursor.GetPoint() = end; 986 break; 987 case META_CHECK_BOTH: 988 if (*rCursor.Start() < start) 989 { 990 *rCursor.Start() = start; 991 bRet = sal_False; 992 } 993 if (*rCursor.End() > end) 994 { 995 *rCursor.End() = end; 996 bRet = sal_False; 997 } 998 break; 999 } 1000 return bRet; 1001 } 1002 1003 bool SwXTextCursor::IsAtEndOfMeta() const 1004 { 1005 if (CURSOR_META == m_pImpl->m_eType) 1006 { 1007 SwUnoCrsr const * const pCursor( m_pImpl->GetCursor() ); 1008 SwXMeta const*const pXMeta( 1009 dynamic_cast<SwXMeta*>(m_pImpl->m_xParentText.get()) ); 1010 ASSERT(pXMeta, "no meta?"); 1011 if (pCursor && pXMeta) 1012 { 1013 SwTxtNode * pTxtNode; 1014 xub_StrLen nStart; 1015 xub_StrLen nEnd; 1016 const bool bSuccess( 1017 pXMeta->SetContentRange(pTxtNode, nStart, nEnd) ); 1018 ASSERT(bSuccess, "no pam?"); 1019 if (bSuccess) 1020 { 1021 const SwPosition end(*pTxtNode, nEnd); 1022 if ( (*pCursor->GetPoint() == end) 1023 || (*pCursor->GetMark() == end)) 1024 { 1025 return true; 1026 } 1027 } 1028 } 1029 } 1030 return false; 1031 } 1032 1033 /*-- 09.12.98 14:19:19--------------------------------------------------- 1034 1035 -----------------------------------------------------------------------*/ 1036 OUString SwXTextCursor::getImplementationName() throw (uno::RuntimeException) 1037 { 1038 return C2U("SwXTextCursor"); 1039 } 1040 1041 /*-- 09.12.98 14:19:19--------------------------------------------------- 1042 1043 -----------------------------------------------------------------------*/ 1044 static char const*const g_ServicesTextCursor[] = 1045 { 1046 "com.sun.star.text.TextCursor", 1047 "com.sun.star.style.CharacterProperties", 1048 "com.sun.star.style.CharacterPropertiesAsian", 1049 "com.sun.star.style.CharacterPropertiesComplex", 1050 "com.sun.star.style.ParagraphProperties", 1051 "com.sun.star.style.ParagraphPropertiesAsian", 1052 "com.sun.star.style.ParagraphPropertiesComplex", 1053 "com.sun.star.text.TextSortable", 1054 }; 1055 static const size_t g_nServicesTextCursor( 1056 sizeof(g_ServicesTextCursor)/sizeof(g_ServicesTextCursor[0])); 1057 1058 sal_Bool SAL_CALL SwXTextCursor::supportsService(const OUString& rServiceName) 1059 throw (uno::RuntimeException) 1060 { 1061 return ::sw::SupportsServiceImpl( 1062 g_nServicesTextCursor, g_ServicesTextCursor, rServiceName); 1063 } 1064 1065 uno::Sequence< OUString > SAL_CALL 1066 SwXTextCursor::getSupportedServiceNames() throw (uno::RuntimeException) 1067 { 1068 return ::sw::GetSupportedServiceNamesImpl( 1069 g_nServicesTextCursor, g_ServicesTextCursor); 1070 } 1071 1072 /* -----------------------------10.03.00 18:02-------------------------------- 1073 1074 ---------------------------------------------------------------------------*/ 1075 const uno::Sequence< sal_Int8 > & SwXTextCursor::getUnoTunnelId() 1076 { 1077 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); 1078 return aSeq; 1079 } 1080 /* -----------------------------10.03.00 18:04-------------------------------- 1081 1082 ---------------------------------------------------------------------------*/ 1083 sal_Int64 SAL_CALL 1084 SwXTextCursor::getSomething(const uno::Sequence< sal_Int8 >& rId) 1085 throw (uno::RuntimeException) 1086 { 1087 const sal_Int64 nRet( ::sw::UnoTunnelImpl<SwXTextCursor>(rId, this) ); 1088 return (nRet) ? nRet : OTextCursorHelper::getSomething(rId); 1089 } 1090 1091 /*-- 09.12.98 14:18:12--------------------------------------------------- 1092 1093 -----------------------------------------------------------------------*/ 1094 void SAL_CALL SwXTextCursor::collapseToStart() throw (uno::RuntimeException) 1095 { 1096 vos::OGuard aGuard(Application::GetSolarMutex()); 1097 1098 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1099 1100 if (rUnoCursor.HasMark()) 1101 { 1102 if (*rUnoCursor.GetPoint() > *rUnoCursor.GetMark()) 1103 { 1104 rUnoCursor.Exchange(); 1105 } 1106 rUnoCursor.DeleteMark(); 1107 } 1108 } 1109 /*-- 09.12.98 14:18:14--------------------------------------------------- 1110 1111 -----------------------------------------------------------------------*/ 1112 void SAL_CALL SwXTextCursor::collapseToEnd() throw (uno::RuntimeException) 1113 { 1114 vos::OGuard aGuard(Application::GetSolarMutex()); 1115 1116 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1117 1118 if (rUnoCursor.HasMark()) 1119 { 1120 if (*rUnoCursor.GetPoint() < *rUnoCursor.GetMark()) 1121 { 1122 rUnoCursor.Exchange(); 1123 } 1124 rUnoCursor.DeleteMark(); 1125 } 1126 } 1127 /*-- 09.12.98 14:18:41--------------------------------------------------- 1128 1129 -----------------------------------------------------------------------*/ 1130 sal_Bool SAL_CALL SwXTextCursor::isCollapsed() throw (uno::RuntimeException) 1131 { 1132 vos::OGuard aGuard(Application::GetSolarMutex()); 1133 1134 sal_Bool bRet = sal_True; 1135 SwUnoCrsr *const pUnoCrsr = m_pImpl->GetCursor(); 1136 if(pUnoCrsr && pUnoCrsr->GetMark()) 1137 { 1138 bRet = (*pUnoCrsr->GetPoint() == *pUnoCrsr->GetMark()); 1139 } 1140 return bRet; 1141 } 1142 1143 /*-- 09.12.98 14:18:42--------------------------------------------------- 1144 1145 -----------------------------------------------------------------------*/ 1146 sal_Bool SAL_CALL 1147 SwXTextCursor::goLeft(sal_Int16 nCount, sal_Bool Expand) 1148 throw (uno::RuntimeException) 1149 { 1150 vos::OGuard aGuard(Application::GetSolarMutex()); 1151 1152 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1153 1154 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1155 sal_Bool bRet = rUnoCursor.Left( nCount, CRSR_SKIP_CHARS, sal_False, sal_False); 1156 if (CURSOR_META == m_pImpl->m_eType) 1157 { 1158 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1159 META_CHECK_BOTH) 1160 && bRet; 1161 } 1162 return bRet; 1163 } 1164 /*-- 09.12.98 14:18:42--------------------------------------------------- 1165 1166 -----------------------------------------------------------------------*/ 1167 sal_Bool SAL_CALL 1168 SwXTextCursor::goRight(sal_Int16 nCount, sal_Bool Expand) 1169 throw (uno::RuntimeException) 1170 { 1171 vos::OGuard aGuard(Application::GetSolarMutex()); 1172 1173 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1174 1175 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1176 sal_Bool bRet = rUnoCursor.Right(nCount, CRSR_SKIP_CHARS, sal_False, sal_False); 1177 if (CURSOR_META == m_pImpl->m_eType) 1178 { 1179 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1180 META_CHECK_BOTH) 1181 && bRet; 1182 } 1183 return bRet; 1184 } 1185 1186 /*-- 09.12.98 14:18:43--------------------------------------------------- 1187 1188 -----------------------------------------------------------------------*/ 1189 void SAL_CALL 1190 SwXTextCursor::gotoStart(sal_Bool Expand) throw (uno::RuntimeException) 1191 { 1192 vos::OGuard aGuard(Application::GetSolarMutex()); 1193 1194 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1195 1196 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1197 if (CURSOR_BODY == m_pImpl->m_eType) 1198 { 1199 rUnoCursor.Move( fnMoveBackward, fnGoDoc ); 1200 //check, that the cursor is not in a table 1201 SwTableNode * pTblNode = rUnoCursor.GetNode()->FindTableNode(); 1202 SwCntntNode * pCNode = 0; 1203 while (pTblNode) 1204 { 1205 rUnoCursor.GetPoint()->nNode = *pTblNode->EndOfSectionNode(); 1206 pCNode = GetDoc()->GetNodes().GoNext(&rUnoCursor.GetPoint()->nNode); 1207 pTblNode = (pCNode) ? pCNode->FindTableNode() : 0; 1208 } 1209 if (pCNode) 1210 { 1211 rUnoCursor.GetPoint()->nContent.Assign(pCNode, 0); 1212 } 1213 SwStartNode const*const pTmp = 1214 rUnoCursor.GetNode()->StartOfSectionNode(); 1215 if (pTmp->IsSectionNode()) 1216 { 1217 SwSectionNode const*const pSectionStartNode = 1218 static_cast<SwSectionNode const*>(pTmp); 1219 if (pSectionStartNode->GetSection().IsHiddenFlag()) 1220 { 1221 pCNode = GetDoc()->GetNodes().GoNextSection( 1222 &rUnoCursor.GetPoint()->nNode, sal_True, sal_False); 1223 if (pCNode) 1224 { 1225 rUnoCursor.GetPoint()->nContent.Assign(pCNode, 0); 1226 } 1227 } 1228 } 1229 } 1230 else if ( (CURSOR_FRAME == m_pImpl->m_eType) 1231 || (CURSOR_TBLTEXT == m_pImpl->m_eType) 1232 || (CURSOR_HEADER == m_pImpl->m_eType) 1233 || (CURSOR_FOOTER == m_pImpl->m_eType) 1234 || (CURSOR_FOOTNOTE== m_pImpl->m_eType) 1235 || (CURSOR_REDLINE == m_pImpl->m_eType)) 1236 { 1237 rUnoCursor.MoveSection(fnSectionCurr, fnSectionStart); 1238 } 1239 else if (CURSOR_META == m_pImpl->m_eType) 1240 { 1241 lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, META_INIT_START); 1242 } 1243 } 1244 /*-- 09.12.98 14:18:43--------------------------------------------------- 1245 1246 -----------------------------------------------------------------------*/ 1247 void SAL_CALL 1248 SwXTextCursor::gotoEnd(sal_Bool Expand) throw (uno::RuntimeException) 1249 { 1250 vos::OGuard aGuard(Application::GetSolarMutex()); 1251 1252 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1253 1254 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1255 if (CURSOR_BODY == m_pImpl->m_eType) 1256 { 1257 rUnoCursor.Move( fnMoveForward, fnGoDoc ); 1258 } 1259 else if ( (CURSOR_FRAME == m_pImpl->m_eType) 1260 || (CURSOR_TBLTEXT == m_pImpl->m_eType) 1261 || (CURSOR_HEADER == m_pImpl->m_eType) 1262 || (CURSOR_FOOTER == m_pImpl->m_eType) 1263 || (CURSOR_FOOTNOTE== m_pImpl->m_eType) 1264 || (CURSOR_REDLINE == m_pImpl->m_eType)) 1265 { 1266 rUnoCursor.MoveSection( fnSectionCurr, fnSectionEnd); 1267 } 1268 else if (CURSOR_META == m_pImpl->m_eType) 1269 { 1270 lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, META_INIT_END); 1271 } 1272 } 1273 1274 void SAL_CALL 1275 SwXTextCursor::gotoRange( 1276 const uno::Reference< text::XTextRange > & xRange, sal_Bool bExpand) 1277 throw (uno::RuntimeException) 1278 { 1279 vos::OGuard aGuard(Application::GetSolarMutex()); 1280 1281 if (!xRange.is()) 1282 { 1283 throw uno::RuntimeException(); 1284 } 1285 1286 SwUnoCrsr & rOwnCursor( m_pImpl->GetCursorOrThrow() ); 1287 1288 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xRange, uno::UNO_QUERY); 1289 SwXTextRange* pRange = 0; 1290 OTextCursorHelper* pCursor = 0; 1291 if(xRangeTunnel.is()) 1292 { 1293 pRange = ::sw::UnoTunnelGetImplementation<SwXTextRange>(xRangeTunnel); 1294 pCursor = 1295 ::sw::UnoTunnelGetImplementation<OTextCursorHelper>(xRangeTunnel); 1296 } 1297 1298 if (!pRange && !pCursor) 1299 { 1300 throw uno::RuntimeException(); 1301 } 1302 1303 SwPaM aPam(GetDoc()->GetNodes()); 1304 const SwPaM * pPam(0); 1305 if (pCursor) 1306 { 1307 pPam = pCursor->GetPaM(); 1308 } 1309 else if (pRange) 1310 { 1311 if (pRange->GetPositions(aPam)) 1312 { 1313 pPam = & aPam; 1314 } 1315 } 1316 1317 if (!pPam) 1318 { 1319 throw uno::RuntimeException(); 1320 } 1321 1322 { 1323 SwStartNodeType eSearchNodeType = SwNormalStartNode; 1324 switch (m_pImpl->m_eType) 1325 { 1326 case CURSOR_FRAME: eSearchNodeType = SwFlyStartNode; break; 1327 case CURSOR_TBLTEXT: eSearchNodeType = SwTableBoxStartNode; break; 1328 case CURSOR_FOOTNOTE: eSearchNodeType = SwFootnoteStartNode; break; 1329 case CURSOR_HEADER: eSearchNodeType = SwHeaderStartNode; break; 1330 case CURSOR_FOOTER: eSearchNodeType = SwFooterStartNode; break; 1331 //case CURSOR_INVALID: 1332 //case CURSOR_BODY: 1333 default: 1334 ; 1335 } 1336 1337 const SwStartNode* pOwnStartNode = rOwnCursor.GetNode()->FindSttNodeByType(eSearchNodeType); 1338 while ( pOwnStartNode != NULL 1339 && pOwnStartNode->IsSectionNode()) 1340 { 1341 pOwnStartNode = pOwnStartNode->StartOfSectionNode(); 1342 } 1343 1344 const SwStartNode* pTmp = 1345 pPam->GetNode()->FindSttNodeByType(eSearchNodeType); 1346 while ( pTmp != NULL 1347 && pTmp->IsSectionNode() ) 1348 { 1349 pTmp = pTmp->StartOfSectionNode(); 1350 } 1351 1352 if ( eSearchNodeType == SwTableBoxStartNode ) 1353 { 1354 if ( pOwnStartNode->FindTableNode() != pTmp->FindTableNode() ) 1355 { 1356 throw uno::RuntimeException(); 1357 } 1358 } 1359 else 1360 { 1361 if ( pOwnStartNode != pTmp ) 1362 { 1363 throw uno::RuntimeException(); 1364 } 1365 } 1366 } 1367 1368 if (CURSOR_META == m_pImpl->m_eType) 1369 { 1370 SwPaM CopyPam(*pPam->GetMark(), *pPam->GetPoint()); 1371 const bool bNotForced( lcl_ForceIntoMeta( 1372 CopyPam, m_pImpl->m_xParentText, META_CHECK_BOTH) ); 1373 if (!bNotForced) 1374 { 1375 throw uno::RuntimeException( 1376 C2U("gotoRange: parameter range not contained in nesting" 1377 " text content for which this cursor was created"), 1378 static_cast<text::XWordCursor*>(this)); 1379 } 1380 } 1381 1382 //jetzt muss die Selektion erweitert werden 1383 if(bExpand) 1384 { 1385 // der Cursor soll alles einschliessen, was bisher von ihm und dem uebergebenen 1386 // Range eingeschlossen wurde 1387 const SwPosition aOwnLeft(*rOwnCursor.Start()); 1388 const SwPosition aOwnRight(*rOwnCursor.End()); 1389 SwPosition const& rParamLeft = *pPam->Start(); 1390 SwPosition const& rParamRight = *pPam->End(); 1391 1392 // jetzt sind vier SwPositions da, zwei davon werden gebraucht, also welche? 1393 *rOwnCursor.GetPoint() = (aOwnRight > rParamRight) 1394 ? aOwnRight : *rOwnCursor.GetPoint() = rParamRight; 1395 rOwnCursor.SetMark(); 1396 *rOwnCursor.GetMark() = (aOwnLeft < rParamLeft) 1397 ? aOwnLeft : *rOwnCursor.GetMark() = rParamLeft; 1398 } 1399 else 1400 { 1401 // cursor should be the given range 1402 *rOwnCursor.GetPoint() = *pPam->GetPoint(); 1403 if (pPam->HasMark()) 1404 { 1405 rOwnCursor.SetMark(); 1406 *rOwnCursor.GetMark() = *pPam->GetMark(); 1407 } 1408 else 1409 { 1410 rOwnCursor.DeleteMark(); 1411 } 1412 } 1413 } 1414 1415 /*-- 09.12.98 14:18:44--------------------------------------------------- 1416 1417 -----------------------------------------------------------------------*/ 1418 sal_Bool SAL_CALL SwXTextCursor::isStartOfWord() throw (uno::RuntimeException) 1419 { 1420 vos::OGuard aGuard(Application::GetSolarMutex()); 1421 1422 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1423 1424 const sal_Bool bRet = 1425 rUnoCursor.IsStartWordWT( i18n::WordType::DICTIONARY_WORD ); 1426 return bRet; 1427 } 1428 /*-- 09.12.98 14:18:44--------------------------------------------------- 1429 1430 -----------------------------------------------------------------------*/ 1431 sal_Bool SAL_CALL SwXTextCursor::isEndOfWord() throw (uno::RuntimeException) 1432 { 1433 vos::OGuard aGuard(Application::GetSolarMutex()); 1434 1435 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1436 1437 const sal_Bool bRet = 1438 rUnoCursor.IsEndWordWT( i18n::WordType::DICTIONARY_WORD ); 1439 return bRet; 1440 } 1441 1442 /*-- 09.12.98 14:18:44--------------------------------------------------- 1443 1444 -----------------------------------------------------------------------*/ 1445 sal_Bool SAL_CALL 1446 SwXTextCursor::gotoNextWord(sal_Bool Expand) throw (uno::RuntimeException) 1447 { 1448 vos::OGuard aGuard(Application::GetSolarMutex()); 1449 1450 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1451 1452 //Probleme gibt's noch mit einem Absatzanfang, an dem kein Wort beginnt. 1453 sal_Bool bRet = sal_False; 1454 // remember old position to check if cursor has moved 1455 // since the called functions are sometimes a bit unreliable 1456 // in specific cases... 1457 SwPosition *const pPoint = rUnoCursor.GetPoint(); 1458 SwNode *const pOldNode = &pPoint->nNode.GetNode(); 1459 xub_StrLen const nOldIndex = pPoint->nContent.GetIndex(); 1460 1461 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1462 // end of paragraph 1463 if (rUnoCursor.GetCntntNode() && 1464 (pPoint->nContent == rUnoCursor.GetCntntNode()->Len())) 1465 { 1466 rUnoCursor.Right(1, CRSR_SKIP_CHARS, sal_False, sal_False); 1467 } 1468 else 1469 { 1470 const bool bTmp = 1471 rUnoCursor.GoNextWordWT( i18n::WordType::DICTIONARY_WORD ); 1472 // if there is no next word within the current paragraph 1473 // try to go to the start of the next paragraph 1474 if (!bTmp) 1475 { 1476 rUnoCursor.MovePara(fnParaNext, fnParaStart); 1477 } 1478 } 1479 1480 // return true if cursor has moved 1481 bRet = (&pPoint->nNode.GetNode() != pOldNode) || 1482 (pPoint->nContent.GetIndex() != nOldIndex); 1483 if (bRet && (CURSOR_META == m_pImpl->m_eType)) 1484 { 1485 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1486 META_CHECK_BOTH); 1487 } 1488 1489 return bRet; 1490 } 1491 1492 /*-- 09.12.98 14:18:45--------------------------------------------------- 1493 1494 -----------------------------------------------------------------------*/ 1495 sal_Bool SAL_CALL 1496 SwXTextCursor::gotoPreviousWord(sal_Bool Expand) throw (uno::RuntimeException) 1497 { 1498 vos::OGuard aGuard(Application::GetSolarMutex()); 1499 1500 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1501 1502 // hier machen Leerzeichen am Absatzanfang Probleme 1503 sal_Bool bRet = sal_False; 1504 SwPosition *const pPoint = rUnoCursor.GetPoint(); 1505 SwNode *const pOldNode = &pPoint->nNode.GetNode(); 1506 xub_StrLen const nOldIndex = pPoint->nContent.GetIndex(); 1507 1508 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1509 // start of paragraph? 1510 if (pPoint->nContent == 0) 1511 { 1512 rUnoCursor.Left(1, CRSR_SKIP_CHARS, sal_False, sal_False); 1513 } 1514 else 1515 { 1516 rUnoCursor.GoPrevWordWT( i18n::WordType::DICTIONARY_WORD ); 1517 if (pPoint->nContent == 0) 1518 { 1519 rUnoCursor.Left(1, CRSR_SKIP_CHARS, sal_False, sal_False); 1520 } 1521 } 1522 1523 // return true if cursor has moved 1524 bRet = (&pPoint->nNode.GetNode() != pOldNode) || 1525 (pPoint->nContent.GetIndex() != nOldIndex); 1526 if (bRet && (CURSOR_META == m_pImpl->m_eType)) 1527 { 1528 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1529 META_CHECK_BOTH); 1530 } 1531 1532 return bRet; 1533 } 1534 1535 /*-- 09.12.98 14:18:45--------------------------------------------------- 1536 1537 -----------------------------------------------------------------------*/ 1538 sal_Bool SAL_CALL 1539 SwXTextCursor::gotoEndOfWord(sal_Bool Expand) throw (uno::RuntimeException) 1540 { 1541 vos::OGuard aGuard(Application::GetSolarMutex()); 1542 1543 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1544 1545 sal_Bool bRet = sal_False; 1546 SwPosition *const pPoint = rUnoCursor.GetPoint(); 1547 SwNode & rOldNode = pPoint->nNode.GetNode(); 1548 xub_StrLen const nOldIndex = pPoint->nContent.GetIndex(); 1549 1550 const sal_Int16 nWordType = i18n::WordType::DICTIONARY_WORD; 1551 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1552 if (!rUnoCursor.IsEndWordWT( nWordType )) 1553 { 1554 rUnoCursor.GoEndWordWT( nWordType ); 1555 } 1556 1557 // restore old cursor if we are not at the end of a word by now 1558 // otherwise use current one 1559 bRet = rUnoCursor.IsEndWordWT( nWordType ); 1560 if (!bRet) 1561 { 1562 pPoint->nNode = rOldNode; 1563 pPoint->nContent = nOldIndex; 1564 } 1565 else if (CURSOR_META == m_pImpl->m_eType) 1566 { 1567 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1568 META_CHECK_BOTH); 1569 } 1570 1571 return bRet; 1572 } 1573 /*-- 09.12.98 14:18:46--------------------------------------------------- 1574 1575 -----------------------------------------------------------------------*/ 1576 sal_Bool SAL_CALL 1577 SwXTextCursor::gotoStartOfWord(sal_Bool Expand) throw (uno::RuntimeException) 1578 { 1579 vos::OGuard aGuard(Application::GetSolarMutex()); 1580 1581 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1582 1583 sal_Bool bRet = sal_False; 1584 SwPosition *const pPoint = rUnoCursor.GetPoint(); 1585 SwNode & rOldNode = pPoint->nNode.GetNode(); 1586 xub_StrLen const nOldIndex = pPoint->nContent.GetIndex(); 1587 1588 const sal_Int16 nWordType = i18n::WordType::DICTIONARY_WORD; 1589 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1590 if (!rUnoCursor.IsStartWordWT( nWordType )) 1591 { 1592 rUnoCursor.GoStartWordWT( nWordType ); 1593 } 1594 1595 // restore old cursor if we are not at the start of a word by now 1596 // otherwise use current one 1597 bRet = rUnoCursor.IsStartWordWT( nWordType ); 1598 if (!bRet) 1599 { 1600 pPoint->nNode = rOldNode; 1601 pPoint->nContent = nOldIndex; 1602 } 1603 else if (CURSOR_META == m_pImpl->m_eType) 1604 { 1605 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1606 META_CHECK_BOTH); 1607 } 1608 1609 return bRet; 1610 } 1611 1612 /*-- 09.12.98 14:18:46--------------------------------------------------- 1613 1614 -----------------------------------------------------------------------*/ 1615 sal_Bool SAL_CALL 1616 SwXTextCursor::isStartOfSentence() throw (uno::RuntimeException) 1617 { 1618 vos::OGuard aGuard(Application::GetSolarMutex()); 1619 1620 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1621 1622 // start of paragraph? 1623 sal_Bool bRet = rUnoCursor.GetPoint()->nContent == 0; 1624 // with mark ->no sentence start 1625 // (check if cursor is no selection, i.e. it does not have 1626 // a mark or else point and mark are identical) 1627 if (!bRet && (!rUnoCursor.HasMark() || 1628 *rUnoCursor.GetPoint() == *rUnoCursor.GetMark())) 1629 { 1630 SwCursor aCrsr(*rUnoCursor.GetPoint(),0,false); 1631 SwPosition aOrigPos = *aCrsr.GetPoint(); 1632 aCrsr.GoSentence(SwCursor::START_SENT ); 1633 bRet = aOrigPos == *aCrsr.GetPoint(); 1634 } 1635 return bRet; 1636 } 1637 /*-- 09.12.98 14:18:47--------------------------------------------------- 1638 1639 -----------------------------------------------------------------------*/ 1640 sal_Bool SAL_CALL 1641 SwXTextCursor::isEndOfSentence() throw (uno::RuntimeException) 1642 { 1643 vos::OGuard aGuard(Application::GetSolarMutex()); 1644 1645 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1646 1647 // end of paragraph? 1648 sal_Bool bRet = rUnoCursor.GetCntntNode() && 1649 (rUnoCursor.GetPoint()->nContent == rUnoCursor.GetCntntNode()->Len()); 1650 // with mark->no sentence end 1651 // (check if cursor is no selection, i.e. it does not have 1652 // a mark or else point and mark are identical) 1653 if (!bRet && (!rUnoCursor.HasMark() || 1654 *rUnoCursor.GetPoint() == *rUnoCursor.GetMark())) 1655 { 1656 SwCursor aCrsr(*rUnoCursor.GetPoint(), 0, false); 1657 SwPosition aOrigPos = *aCrsr.GetPoint(); 1658 aCrsr.GoSentence(SwCursor::END_SENT); 1659 bRet = aOrigPos == *aCrsr.GetPoint(); 1660 } 1661 return bRet; 1662 } 1663 1664 /*-- 09.12.98 14:18:47--------------------------------------------------- 1665 1666 -----------------------------------------------------------------------*/ 1667 sal_Bool SAL_CALL 1668 SwXTextCursor::gotoNextSentence(sal_Bool Expand) throw (uno::RuntimeException) 1669 { 1670 vos::OGuard aGuard(Application::GetSolarMutex()); 1671 1672 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1673 1674 const bool bWasEOS = isEndOfSentence(); 1675 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1676 sal_Bool bRet = rUnoCursor.GoSentence(SwCursor::NEXT_SENT); 1677 if (!bRet) 1678 { 1679 bRet = rUnoCursor.MovePara(fnParaNext, fnParaStart); 1680 } 1681 1682 // if at the end of the sentence (i.e. at the space after the '.') 1683 // advance to next word in order for GoSentence to work properly 1684 // next time and have isStartOfSentence return true after this call 1685 if (!rUnoCursor.IsStartWord()) 1686 { 1687 const bool bNextWord = rUnoCursor.GoNextWord(); 1688 if (bWasEOS && !bNextWord) 1689 { 1690 bRet = sal_False; 1691 } 1692 } 1693 if (CURSOR_META == m_pImpl->m_eType) 1694 { 1695 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1696 META_CHECK_BOTH) 1697 && bRet; 1698 } 1699 return bRet; 1700 } 1701 /*-- 09.12.98 14:18:47--------------------------------------------------- 1702 1703 -----------------------------------------------------------------------*/ 1704 sal_Bool SAL_CALL 1705 SwXTextCursor::gotoPreviousSentence(sal_Bool Expand) 1706 throw (uno::RuntimeException) 1707 { 1708 vos::OGuard aGuard(Application::GetSolarMutex()); 1709 1710 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1711 1712 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1713 sal_Bool bRet = rUnoCursor.GoSentence(SwCursor::PREV_SENT); 1714 if (!bRet) 1715 { 1716 bRet = rUnoCursor.MovePara(fnParaPrev, fnParaStart); 1717 if (bRet) 1718 { 1719 rUnoCursor.MovePara(fnParaCurr, fnParaEnd); 1720 // at the end of a paragraph move to the sentence end again 1721 rUnoCursor.GoSentence(SwCursor::PREV_SENT); 1722 } 1723 } 1724 if (CURSOR_META == m_pImpl->m_eType) 1725 { 1726 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1727 META_CHECK_BOTH) 1728 && bRet; 1729 } 1730 return bRet; 1731 } 1732 1733 /* -----------------15.10.99 08:24------------------- 1734 1735 --------------------------------------------------*/ 1736 sal_Bool SAL_CALL 1737 SwXTextCursor::gotoStartOfSentence(sal_Bool Expand) 1738 throw (uno::RuntimeException) 1739 { 1740 vos::OGuard aGuard(Application::GetSolarMutex()); 1741 1742 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1743 1744 sal_Bool bRet = sal_False; 1745 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1746 // if we're at the para start then we wont move 1747 // but bRet is also true if GoSentence failed but 1748 // the start of the sentence is reached 1749 bRet = SwUnoCursorHelper::IsStartOfPara(rUnoCursor) 1750 || rUnoCursor.GoSentence(SwCursor::START_SENT) 1751 || SwUnoCursorHelper::IsStartOfPara(rUnoCursor); 1752 if (CURSOR_META == m_pImpl->m_eType) 1753 { 1754 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1755 META_CHECK_BOTH) 1756 && bRet; 1757 } 1758 return bRet; 1759 } 1760 /* -----------------15.10.99 08:24------------------- 1761 1762 --------------------------------------------------*/ 1763 sal_Bool SAL_CALL 1764 SwXTextCursor::gotoEndOfSentence(sal_Bool Expand) throw (uno::RuntimeException) 1765 { 1766 vos::OGuard aGuard(Application::GetSolarMutex()); 1767 1768 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1769 1770 sal_Bool bRet = sal_False; 1771 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1772 // bRet is true if GoSentence() succeeded or if the 1773 // MovePara() succeeded while the end of the para is 1774 // not reached already 1775 sal_Bool bAlreadyParaEnd = SwUnoCursorHelper::IsEndOfPara(rUnoCursor); 1776 bRet = !bAlreadyParaEnd 1777 && (rUnoCursor.GoSentence(SwCursor::END_SENT) 1778 || rUnoCursor.MovePara(fnParaCurr, fnParaEnd)); 1779 if (CURSOR_META == m_pImpl->m_eType) 1780 { 1781 bRet = lcl_ForceIntoMeta(rUnoCursor, m_pImpl->m_xParentText, 1782 META_CHECK_BOTH) 1783 && bRet; 1784 } 1785 return bRet; 1786 } 1787 1788 /*-- 09.12.98 14:18:48--------------------------------------------------- 1789 1790 -----------------------------------------------------------------------*/ 1791 sal_Bool SAL_CALL 1792 SwXTextCursor::isStartOfParagraph() throw (uno::RuntimeException) 1793 { 1794 vos::OGuard aGuard(Application::GetSolarMutex()); 1795 1796 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1797 1798 const sal_Bool bRet = SwUnoCursorHelper::IsStartOfPara(rUnoCursor); 1799 return bRet; 1800 } 1801 /*-- 09.12.98 14:18:48--------------------------------------------------- 1802 1803 -----------------------------------------------------------------------*/ 1804 sal_Bool SAL_CALL 1805 SwXTextCursor::isEndOfParagraph() throw (uno::RuntimeException) 1806 { 1807 vos::OGuard aGuard(Application::GetSolarMutex()); 1808 1809 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1810 1811 const sal_Bool bRet = SwUnoCursorHelper::IsEndOfPara(rUnoCursor); 1812 return bRet; 1813 } 1814 1815 /*-- 09.12.98 14:18:49--------------------------------------------------- 1816 1817 -----------------------------------------------------------------------*/ 1818 sal_Bool SAL_CALL 1819 SwXTextCursor::gotoStartOfParagraph(sal_Bool Expand) 1820 throw (uno::RuntimeException) 1821 { 1822 vos::OGuard aGuard(Application::GetSolarMutex()); 1823 1824 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1825 1826 if (CURSOR_META == m_pImpl->m_eType) 1827 { 1828 return sal_False; 1829 } 1830 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1831 sal_Bool bRet = SwUnoCursorHelper::IsStartOfPara(rUnoCursor); 1832 if (!bRet) 1833 { 1834 bRet = rUnoCursor.MovePara(fnParaCurr, fnParaStart); 1835 } 1836 1837 // since MovePara(fnParaCurr, fnParaStart) only returns false 1838 // if we were already at the start of the paragraph this function 1839 // should always complete successfully. 1840 DBG_ASSERT( bRet, "gotoStartOfParagraph failed" ); 1841 return bRet; 1842 } 1843 /*-- 09.12.98 14:18:49--------------------------------------------------- 1844 1845 -----------------------------------------------------------------------*/ 1846 sal_Bool SAL_CALL 1847 SwXTextCursor::gotoEndOfParagraph(sal_Bool Expand) throw (uno::RuntimeException) 1848 { 1849 vos::OGuard aGuard(Application::GetSolarMutex()); 1850 1851 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1852 1853 if (CURSOR_META == m_pImpl->m_eType) 1854 { 1855 return sal_False; 1856 } 1857 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1858 sal_Bool bRet = SwUnoCursorHelper::IsEndOfPara(rUnoCursor); 1859 if (!bRet) 1860 { 1861 bRet = rUnoCursor.MovePara(fnParaCurr, fnParaEnd); 1862 } 1863 1864 // since MovePara(fnParaCurr, fnParaEnd) only returns false 1865 // if we were already at the end of the paragraph this function 1866 // should always complete successfully. 1867 DBG_ASSERT( bRet, "gotoEndOfParagraph failed" ); 1868 return bRet; 1869 } 1870 1871 /*-- 09.12.98 14:18:50--------------------------------------------------- 1872 1873 -----------------------------------------------------------------------*/ 1874 sal_Bool SAL_CALL 1875 SwXTextCursor::gotoNextParagraph(sal_Bool Expand) throw (uno::RuntimeException) 1876 { 1877 vos::OGuard aGuard(Application::GetSolarMutex()); 1878 1879 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1880 1881 if (CURSOR_META == m_pImpl->m_eType) 1882 { 1883 return sal_False; 1884 } 1885 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1886 const sal_Bool bRet = rUnoCursor.MovePara(fnParaNext, fnParaStart); 1887 return bRet; 1888 } 1889 /*-- 09.12.98 14:18:50--------------------------------------------------- 1890 1891 -----------------------------------------------------------------------*/ 1892 sal_Bool SAL_CALL 1893 SwXTextCursor::gotoPreviousParagraph(sal_Bool Expand) 1894 throw (uno::RuntimeException) 1895 { 1896 vos::OGuard aGuard(Application::GetSolarMutex()); 1897 1898 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1899 1900 if (CURSOR_META == m_pImpl->m_eType) 1901 { 1902 return sal_False; 1903 } 1904 SwUnoCursorHelper::SelectPam(rUnoCursor, Expand); 1905 const sal_Bool bRet = rUnoCursor.MovePara(fnParaPrev, fnParaStart); 1906 return bRet; 1907 } 1908 1909 /*-- 09.12.98 14:18:50--------------------------------------------------- 1910 1911 -----------------------------------------------------------------------*/ 1912 uno::Reference< text::XText > SAL_CALL 1913 SwXTextCursor::getText() throw (uno::RuntimeException) 1914 { 1915 vos::OGuard g(Application::GetSolarMutex()); 1916 1917 return m_pImpl->m_xParentText; 1918 } 1919 1920 /*-- 09.12.98 14:18:50--------------------------------------------------- 1921 1922 -----------------------------------------------------------------------*/ 1923 uno::Reference< text::XTextRange > SAL_CALL 1924 SwXTextCursor::getStart() throw (uno::RuntimeException) 1925 { 1926 vos::OGuard aGuard(Application::GetSolarMutex()); 1927 1928 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1929 1930 uno::Reference< text::XTextRange > xRet; 1931 SwPaM aPam(*rUnoCursor.Start()); 1932 const uno::Reference< text::XText > xParent = getText(); 1933 if (CURSOR_META == m_pImpl->m_eType) 1934 { 1935 // return cursor to prevent modifying SwXTextRange for META 1936 SwXTextCursor * const pXCursor( 1937 new SwXTextCursor(*rUnoCursor.GetDoc(), xParent, CURSOR_META, 1938 *rUnoCursor.GetPoint()) ); 1939 pXCursor->gotoStart(sal_False); 1940 xRet = static_cast<text::XWordCursor*>(pXCursor); 1941 } 1942 else 1943 { 1944 xRet = new SwXTextRange(aPam, xParent); 1945 } 1946 return xRet; 1947 } 1948 /*-- 09.12.98 14:18:51--------------------------------------------------- 1949 1950 -----------------------------------------------------------------------*/ 1951 uno::Reference< text::XTextRange > SAL_CALL 1952 SwXTextCursor::getEnd() throw (uno::RuntimeException) 1953 { 1954 vos::OGuard aGuard(Application::GetSolarMutex()); 1955 1956 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1957 1958 uno::Reference< text::XTextRange > xRet; 1959 SwPaM aPam(*rUnoCursor.End()); 1960 const uno::Reference< text::XText > xParent = getText(); 1961 if (CURSOR_META == m_pImpl->m_eType) 1962 { 1963 // return cursor to prevent modifying SwXTextRange for META 1964 SwXTextCursor * const pXCursor( 1965 new SwXTextCursor(*rUnoCursor.GetDoc(), xParent, CURSOR_META, 1966 *rUnoCursor.GetPoint()) ); 1967 pXCursor->gotoEnd(sal_False); 1968 xRet = static_cast<text::XWordCursor*>(pXCursor); 1969 } 1970 else 1971 { 1972 xRet = new SwXTextRange(aPam, xParent); 1973 } 1974 return xRet; 1975 } 1976 1977 /*-- 09.12.98 14:18:51--------------------------------------------------- 1978 1979 -----------------------------------------------------------------------*/ 1980 OUString SAL_CALL SwXTextCursor::getString() throw (uno::RuntimeException) 1981 { 1982 vos::OGuard aGuard(Application::GetSolarMutex()); 1983 1984 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1985 1986 OUString aTxt; 1987 SwUnoCursorHelper::GetTextFromPam(rUnoCursor, aTxt); 1988 return aTxt; 1989 } 1990 /*-- 09.12.98 14:18:52--------------------------------------------------- 1991 1992 -----------------------------------------------------------------------*/ 1993 void SAL_CALL 1994 SwXTextCursor::setString(const OUString& aString) throw (uno::RuntimeException) 1995 { 1996 vos::OGuard aGuard(Application::GetSolarMutex()); 1997 1998 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 1999 (void) rUnoCursor; // just to check if valid 2000 2001 const bool bForceExpandHints( (CURSOR_META != m_pImpl->m_eType) 2002 ? false 2003 : dynamic_cast<SwXMeta*>(m_pImpl->m_xParentText.get()) 2004 ->CheckForOwnMemberMeta(*GetPaM(), true) ); 2005 DeleteAndInsert(aString, bForceExpandHints); 2006 } 2007 2008 /* -----------------------------03.05.00 12:56-------------------------------- 2009 2010 ---------------------------------------------------------------------------*/ 2011 uno::Any SwUnoCursorHelper::GetPropertyValue( 2012 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, 2013 const OUString& rPropertyName) 2014 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2015 uno::RuntimeException) 2016 { 2017 uno::Any aAny; 2018 SfxItemPropertySimpleEntry const*const pEntry = 2019 rPropSet.getPropertyMap()->getByName(rPropertyName); 2020 2021 if (!pEntry) 2022 { 2023 throw beans::UnknownPropertyException( 2024 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2025 + rPropertyName, static_cast<cppu::OWeakObject *>(0)); 2026 } 2027 2028 beans::PropertyState eTemp; 2029 const sal_Bool bDone = SwUnoCursorHelper::getCrsrPropertyValue( 2030 *pEntry, rPaM, &aAny, eTemp ); 2031 2032 if (!bDone) 2033 { 2034 SfxItemSet aSet(rPaM.GetDoc()->GetAttrPool(), 2035 RES_CHRATR_BEGIN, RES_FRMATR_END - 1, 2036 RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER, 2037 RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER, 2038 0L); 2039 SwUnoCursorHelper::GetCrsrAttr(rPaM, aSet); 2040 2041 rPropSet.getPropertyValue(*pEntry, aSet, aAny); 2042 } 2043 2044 return aAny; 2045 } 2046 /* -----------------------------03.05.00 12:57-------------------------------- 2047 2048 ---------------------------------------------------------------------------*/ 2049 void SwUnoCursorHelper::SetPropertyValue( 2050 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, 2051 const OUString& rPropertyName, 2052 const uno::Any& rValue, 2053 const SetAttrMode nAttrMode, const bool bTableMode) 2054 throw (beans::UnknownPropertyException, beans::PropertyVetoException, 2055 lang::IllegalArgumentException, lang::WrappedTargetException, 2056 uno::RuntimeException) 2057 { 2058 SwDoc *const pDoc = rPaM.GetDoc(); 2059 SfxItemPropertySimpleEntry const*const pEntry = 2060 rPropSet.getPropertyMap()->getByName(rPropertyName); 2061 if (!pEntry) 2062 { 2063 throw beans::UnknownPropertyException( 2064 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2065 + rPropertyName, 2066 static_cast<cppu::OWeakObject *>(0)); 2067 } 2068 2069 if (pEntry->nFlags & beans::PropertyAttribute::READONLY) 2070 { 2071 throw beans::PropertyVetoException( 2072 OUString(RTL_CONSTASCII_USTRINGPARAM("Property is read-only: ")) 2073 + rPropertyName, 2074 static_cast<cppu::OWeakObject *>(0)); 2075 } 2076 2077 SfxItemSet aItemSet( pDoc->GetAttrPool(), pEntry->nWID, pEntry->nWID ); 2078 SwUnoCursorHelper::GetCrsrAttr( rPaM, aItemSet ); 2079 2080 if (!SwUnoCursorHelper::SetCursorPropertyValue( 2081 *pEntry, rValue, rPaM, aItemSet)) 2082 { 2083 rPropSet.setPropertyValue(*pEntry, rValue, aItemSet ); 2084 } 2085 SwUnoCursorHelper::SetCrsrAttr(rPaM, aItemSet, nAttrMode, bTableMode); 2086 } 2087 2088 /* -----------------------------03.05.00 13:16-------------------------------- 2089 2090 ---------------------------------------------------------------------------*/ 2091 uno::Sequence< beans::PropertyState > 2092 SwUnoCursorHelper::GetPropertyStates( 2093 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, 2094 const uno::Sequence< OUString >& rPropertyNames, 2095 const SwGetPropertyStatesCaller eCaller) 2096 throw (beans::UnknownPropertyException, uno::RuntimeException) 2097 { 2098 const OUString* pNames = rPropertyNames.getConstArray(); 2099 uno::Sequence< beans::PropertyState > aRet(rPropertyNames.getLength()); 2100 beans::PropertyState* pStates = aRet.getArray(); 2101 SfxItemPropertyMap const*const pMap = rPropSet.getPropertyMap(); 2102 ::std::auto_ptr<SfxItemSet> pSet; 2103 ::std::auto_ptr<SfxItemSet> pSetParent; 2104 2105 for (sal_Int32 i = 0, nEnd = rPropertyNames.getLength(); i < nEnd; i++) 2106 { 2107 SfxItemPropertySimpleEntry const*const pEntry = 2108 pMap->getByName( pNames[i] ); 2109 if(!pEntry) 2110 { 2111 if (pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)) || 2112 pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT))) 2113 { 2114 pStates[i] = beans::PropertyState_DEFAULT_VALUE; 2115 continue; 2116 } 2117 else if (SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION_TOLERANT == 2118 eCaller) 2119 { 2120 //this values marks the element as unknown property 2121 pStates[i] = beans::PropertyState_MAKE_FIXED_SIZE; 2122 continue; 2123 } 2124 else 2125 { 2126 throw beans::UnknownPropertyException( 2127 OUString( RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2128 + pNames[i], 2129 static_cast<cppu::OWeakObject *>(0)); 2130 } 2131 } 2132 if (((SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION == eCaller) || 2133 (SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION_TOLERANT == eCaller)) && 2134 pEntry->nWID < FN_UNO_RANGE_BEGIN && 2135 pEntry->nWID > FN_UNO_RANGE_END && 2136 pEntry->nWID < RES_CHRATR_BEGIN && 2137 pEntry->nWID > RES_TXTATR_END ) 2138 { 2139 pStates[i] = beans::PropertyState_DEFAULT_VALUE; 2140 } 2141 else 2142 { 2143 if ( pEntry->nWID >= FN_UNO_RANGE_BEGIN && 2144 pEntry->nWID <= FN_UNO_RANGE_END ) 2145 { 2146 SwUnoCursorHelper::getCrsrPropertyValue( 2147 *pEntry, rPaM, 0, pStates[i] ); 2148 } 2149 else 2150 { 2151 if (!pSet.get()) 2152 { 2153 switch ( eCaller ) 2154 { 2155 case SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION_TOLERANT: 2156 case SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION: 2157 pSet.reset( 2158 new SfxItemSet( rPaM.GetDoc()->GetAttrPool(), 2159 RES_CHRATR_BEGIN, RES_TXTATR_END )); 2160 break; 2161 case SW_PROPERTY_STATE_CALLER_SINGLE_VALUE_ONLY: 2162 pSet.reset( 2163 new SfxItemSet( rPaM.GetDoc()->GetAttrPool(), 2164 pEntry->nWID, pEntry->nWID )); 2165 break; 2166 default: 2167 pSet.reset( new SfxItemSet( 2168 rPaM.GetDoc()->GetAttrPool(), 2169 RES_CHRATR_BEGIN, RES_FRMATR_END - 1, 2170 RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER, 2171 RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER, 2172 0L )); 2173 } 2174 // --> OD 2006-07-12 #i63870# 2175 SwUnoCursorHelper::GetCrsrAttr( rPaM, *pSet ); 2176 // <-- 2177 } 2178 2179 pStates[i] = ( pSet->Count() ) 2180 ? rPropSet.getPropertyState( *pEntry, *pSet ) 2181 : beans::PropertyState_DEFAULT_VALUE; 2182 2183 //try again to find out if a value has been inherited 2184 if( beans::PropertyState_DIRECT_VALUE == pStates[i] ) 2185 { 2186 if (!pSetParent.get()) 2187 { 2188 pSetParent.reset( pSet->Clone( sal_False ) ); 2189 // --> OD 2006-07-12 #i63870# 2190 SwUnoCursorHelper::GetCrsrAttr( 2191 rPaM, *pSetParent, sal_True, sal_False ); 2192 // <-- 2193 } 2194 2195 pStates[i] = ( (pSetParent)->Count() ) 2196 ? rPropSet.getPropertyState( *pEntry, *pSetParent ) 2197 : beans::PropertyState_DEFAULT_VALUE; 2198 } 2199 } 2200 } 2201 } 2202 return aRet; 2203 } 2204 /* -----------------------------03.05.00 13:17-------------------------------- 2205 2206 ---------------------------------------------------------------------------*/ 2207 beans::PropertyState SwUnoCursorHelper::GetPropertyState( 2208 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, 2209 const OUString& rPropertyName) 2210 throw (beans::UnknownPropertyException, uno::RuntimeException) 2211 { 2212 uno::Sequence< OUString > aStrings ( 1 ); 2213 aStrings[0] = rPropertyName; 2214 uno::Sequence< beans::PropertyState > aSeq = 2215 GetPropertyStates(rPaM, rPropSet, aStrings, 2216 SW_PROPERTY_STATE_CALLER_SINGLE_VALUE_ONLY ); 2217 return aSeq[0]; 2218 } 2219 /* -----------------------------03.05.00 13:20-------------------------------- 2220 2221 ---------------------------------------------------------------------------*/ 2222 static void 2223 lcl_SelectParaAndReset( SwPaM &rPaM, SwDoc & rDoc, 2224 SvUShortsSort const*const pWhichIds = 0 ) 2225 { 2226 // if we are reseting paragraph attributes, we need to select the full paragraph first 2227 SwPosition aStart = *rPaM.Start(); 2228 SwPosition aEnd = *rPaM.End(); 2229 ::std::auto_ptr< SwUnoCrsr > pTemp ( rDoc.CreateUnoCrsr(aStart, sal_False) ); 2230 if(!SwUnoCursorHelper::IsStartOfPara(*pTemp)) 2231 { 2232 pTemp->MovePara(fnParaCurr, fnParaStart); 2233 } 2234 pTemp->SetMark(); 2235 *pTemp->GetPoint() = aEnd; 2236 SwUnoCursorHelper::SelectPam(*pTemp, true); 2237 if(!SwUnoCursorHelper::IsEndOfPara(*pTemp)) 2238 { 2239 pTemp->MovePara(fnParaCurr, fnParaEnd); 2240 } 2241 rDoc.ResetAttrs(*pTemp, sal_True, pWhichIds); 2242 } 2243 2244 2245 void SwUnoCursorHelper::SetPropertyToDefault( 2246 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, 2247 const OUString& rPropertyName) 2248 throw (beans::UnknownPropertyException, uno::RuntimeException) 2249 { 2250 SwDoc & rDoc = *rPaM.GetDoc(); 2251 SfxItemPropertySimpleEntry const*const pEntry = 2252 rPropSet.getPropertyMap()->getByName(rPropertyName); 2253 if (!pEntry) 2254 { 2255 throw beans::UnknownPropertyException( 2256 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2257 + rPropertyName, static_cast<cppu::OWeakObject *>(0)); 2258 } 2259 2260 if (pEntry->nFlags & beans::PropertyAttribute::READONLY) 2261 { 2262 throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM( 2263 "setPropertyToDefault: property is read-only: ")) 2264 + rPropertyName, 0); 2265 } 2266 2267 if (pEntry->nWID < RES_FRMATR_END) 2268 { 2269 SvUShortsSort aWhichIds; 2270 aWhichIds.Insert(pEntry->nWID); 2271 if (pEntry->nWID < RES_PARATR_BEGIN) 2272 { 2273 rDoc.ResetAttrs(rPaM, sal_True, &aWhichIds); 2274 } 2275 else 2276 { 2277 lcl_SelectParaAndReset ( rPaM, rDoc, &aWhichIds ); 2278 } 2279 } 2280 else 2281 { 2282 SwUnoCursorHelper::resetCrsrPropertyValue(*pEntry, rPaM); 2283 } 2284 } 2285 2286 /* -----------------------------03.05.00 13:19-------------------------------- 2287 2288 ---------------------------------------------------------------------------*/ 2289 uno::Any SwUnoCursorHelper::GetPropertyDefault( 2290 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, 2291 const OUString& rPropertyName) 2292 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2293 uno::RuntimeException) 2294 { 2295 SfxItemPropertySimpleEntry const*const pEntry = 2296 rPropSet.getPropertyMap()->getByName(rPropertyName); 2297 if (!pEntry) 2298 { 2299 throw beans::UnknownPropertyException( 2300 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2301 + rPropertyName, static_cast<cppu::OWeakObject *>(0)); 2302 } 2303 2304 uno::Any aRet; 2305 if (pEntry->nWID < RES_FRMATR_END) 2306 { 2307 SwDoc & rDoc = *rPaM.GetDoc(); 2308 const SfxPoolItem& rDefItem = 2309 rDoc.GetAttrPool().GetDefaultItem(pEntry->nWID); 2310 rDefItem.QueryValue(aRet, pEntry->nMemberId); 2311 } 2312 return aRet; 2313 } 2314 2315 /*-- 09.12.98 14:18:54--------------------------------------------------- 2316 2317 -----------------------------------------------------------------------*/ 2318 uno::Reference< beans::XPropertySetInfo > SAL_CALL 2319 SwXTextCursor::getPropertySetInfo() throw (uno::RuntimeException) 2320 { 2321 vos::OGuard g(Application::GetSolarMutex()); 2322 2323 static uno::Reference< beans::XPropertySetInfo > xRef; 2324 if(!xRef.is()) 2325 { 2326 static SfxItemPropertyMapEntry aCrsrExtMap_Impl[] = 2327 { 2328 { SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT), FN_SKIP_HIDDEN_TEXT, &::getBooleanCppuType(), PROPERTY_NONE, 0}, 2329 { SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT), FN_SKIP_PROTECTED_TEXT, &::getBooleanCppuType(), PROPERTY_NONE, 0}, 2330 {0,0,0,0,0,0} 2331 }; 2332 const uno::Reference< beans::XPropertySetInfo > xInfo = 2333 m_pImpl->m_rPropSet.getPropertySetInfo(); 2334 // PropertySetInfo verlaengern! 2335 const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties(); 2336 xRef = new SfxExtItemPropertySetInfo( 2337 aCrsrExtMap_Impl, 2338 aPropSeq ); 2339 } 2340 return xRef; 2341 } 2342 2343 /*-- 09.12.98 14:18:54--------------------------------------------------- 2344 2345 -----------------------------------------------------------------------*/ 2346 void SAL_CALL 2347 SwXTextCursor::setPropertyValue( 2348 const OUString& rPropertyName, const uno::Any& rValue) 2349 throw (beans::UnknownPropertyException, beans::PropertyVetoException, 2350 lang::IllegalArgumentException, lang::WrappedTargetException, 2351 uno::RuntimeException) 2352 { 2353 vos::OGuard aGuard(Application::GetSolarMutex()); 2354 2355 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2356 2357 if (rPropertyName.equalsAsciiL(SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT))) 2358 { 2359 sal_Bool bSet(sal_False); 2360 if (!(rValue >>= bSet)) 2361 { 2362 throw lang::IllegalArgumentException(); 2363 } 2364 rUnoCursor.SetSkipOverHiddenSections(bSet); 2365 } 2366 else if (rPropertyName.equalsAsciiL( 2367 SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT))) 2368 { 2369 sal_Bool bSet(sal_False); 2370 if (!(rValue >>= bSet)) 2371 { 2372 throw lang::IllegalArgumentException(); 2373 } 2374 rUnoCursor.SetSkipOverProtectSections(bSet); 2375 } 2376 else 2377 { 2378 SwUnoCursorHelper::SetPropertyValue(rUnoCursor, 2379 m_pImpl->m_rPropSet, rPropertyName, rValue); 2380 } 2381 } 2382 2383 /*-- 09.12.98 14:18:55--------------------------------------------------- 2384 2385 -----------------------------------------------------------------------*/ 2386 uno::Any SAL_CALL 2387 SwXTextCursor::getPropertyValue(const OUString& rPropertyName) 2388 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2389 uno::RuntimeException) 2390 { 2391 vos::OGuard aGuard(Application::GetSolarMutex()); 2392 2393 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2394 2395 uno::Any aAny; 2396 if (rPropertyName.equalsAsciiL(SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT))) 2397 { 2398 const sal_Bool bSet = rUnoCursor.IsSkipOverHiddenSections(); 2399 aAny <<= bSet; 2400 } 2401 else if (rPropertyName.equalsAsciiL( 2402 SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT))) 2403 { 2404 const sal_Bool bSet = rUnoCursor.IsSkipOverProtectSections(); 2405 aAny <<= bSet; 2406 } 2407 else 2408 { 2409 aAny = SwUnoCursorHelper::GetPropertyValue(rUnoCursor, 2410 m_pImpl->m_rPropSet, rPropertyName); 2411 } 2412 return aAny; 2413 } 2414 2415 /*-- 09.12.98 14:18:55--------------------------------------------------- 2416 2417 -----------------------------------------------------------------------*/ 2418 void SAL_CALL 2419 SwXTextCursor::addPropertyChangeListener( 2420 const ::rtl::OUString& /*rPropertyName*/, 2421 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) 2422 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2423 uno::RuntimeException) 2424 { 2425 OSL_ENSURE(false, 2426 "SwXTextCursor::addPropertyChangeListener(): not implemented"); 2427 } 2428 2429 /*-- 09.12.98 14:18:57--------------------------------------------------- 2430 2431 -----------------------------------------------------------------------*/ 2432 void SAL_CALL 2433 SwXTextCursor::removePropertyChangeListener( 2434 const ::rtl::OUString& /*rPropertyName*/, 2435 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/) 2436 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2437 uno::RuntimeException) 2438 { 2439 OSL_ENSURE(false, 2440 "SwXTextCursor::removePropertyChangeListener(): not implemented"); 2441 } 2442 2443 /*-- 09.12.98 14:18:57--------------------------------------------------- 2444 2445 -----------------------------------------------------------------------*/ 2446 void SAL_CALL 2447 SwXTextCursor::addVetoableChangeListener( 2448 const ::rtl::OUString& /*rPropertyName*/, 2449 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) 2450 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2451 uno::RuntimeException) 2452 { 2453 OSL_ENSURE(false, 2454 "SwXTextCursor::addVetoableChangeListener(): not implemented"); 2455 } 2456 2457 /*-- 09.12.98 14:18:58--------------------------------------------------- 2458 2459 -----------------------------------------------------------------------*/ 2460 void SAL_CALL 2461 SwXTextCursor::removeVetoableChangeListener( 2462 const ::rtl::OUString& /*rPropertyName*/, 2463 const uno::Reference< beans::XVetoableChangeListener >& /*xListener*/) 2464 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2465 uno::RuntimeException) 2466 { 2467 OSL_ENSURE(false, 2468 "SwXTextCursor::removeVetoableChangeListener(): not implemented"); 2469 } 2470 2471 /*-- 05.03.99 11:36:11--------------------------------------------------- 2472 2473 -----------------------------------------------------------------------*/ 2474 beans::PropertyState SAL_CALL 2475 SwXTextCursor::getPropertyState(const OUString& rPropertyName) 2476 throw (beans::UnknownPropertyException, uno::RuntimeException) 2477 { 2478 vos::OGuard aGuard(Application::GetSolarMutex()); 2479 2480 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2481 2482 const beans::PropertyState eRet = SwUnoCursorHelper::GetPropertyState( 2483 rUnoCursor, m_pImpl->m_rPropSet, rPropertyName); 2484 return eRet; 2485 } 2486 /*-- 05.03.99 11:36:11--------------------------------------------------- 2487 2488 -----------------------------------------------------------------------*/ 2489 uno::Sequence< beans::PropertyState > SAL_CALL 2490 SwXTextCursor::getPropertyStates( 2491 const uno::Sequence< OUString >& rPropertyNames) 2492 throw (beans::UnknownPropertyException, uno::RuntimeException) 2493 { 2494 vos::OGuard aGuard(Application::GetSolarMutex()); 2495 2496 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2497 2498 return SwUnoCursorHelper::GetPropertyStates( 2499 rUnoCursor, m_pImpl->m_rPropSet, rPropertyNames); 2500 } 2501 2502 /*-- 05.03.99 11:36:12--------------------------------------------------- 2503 2504 -----------------------------------------------------------------------*/ 2505 void SAL_CALL 2506 SwXTextCursor::setPropertyToDefault(const OUString& rPropertyName) 2507 throw (beans::UnknownPropertyException, uno::RuntimeException) 2508 { 2509 // forward: need no solar mutex here 2510 uno::Sequence < OUString > aSequence ( &rPropertyName, 1 ); 2511 setPropertiesToDefault ( aSequence ); 2512 } 2513 /*-- 05.03.99 11:36:12--------------------------------------------------- 2514 2515 -----------------------------------------------------------------------*/ 2516 uno::Any SAL_CALL 2517 SwXTextCursor::getPropertyDefault(const OUString& rPropertyName) 2518 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2519 uno::RuntimeException) 2520 { 2521 // forward: need no solar mutex here 2522 const uno::Sequence < OUString > aSequence ( &rPropertyName, 1 ); 2523 return getPropertyDefaults ( aSequence ).getConstArray()[0]; 2524 } 2525 2526 // para specific attribut ranges 2527 static sal_uInt16 g_ParaResetableSetRange[] = { 2528 RES_FRMATR_BEGIN, RES_FRMATR_END-1, 2529 RES_PARATR_BEGIN, RES_PARATR_END-1, 2530 // --> OD 2008-02-25 #refactorlists# 2531 RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END-1, 2532 // <-- 2533 RES_UNKNOWNATR_BEGIN, RES_UNKNOWNATR_END-1, 2534 0 2535 }; 2536 2537 // selection specific attribut ranges 2538 static sal_uInt16 g_ResetableSetRange[] = { 2539 RES_CHRATR_BEGIN, RES_CHRATR_END-1, 2540 RES_TXTATR_INETFMT, RES_TXTATR_INETFMT, 2541 RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT, 2542 RES_TXTATR_CJK_RUBY, RES_TXTATR_CJK_RUBY, 2543 RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER, 2544 0 2545 }; 2546 2547 static void 2548 lcl_EnumerateIds(sal_uInt16 const* pIdRange, SvUShortsSort & rWhichIds) 2549 { 2550 while (*pIdRange) 2551 { 2552 const sal_uInt16 nStart = sal::static_int_cast<sal_uInt16>(*pIdRange++); 2553 const sal_uInt16 nEnd = sal::static_int_cast<sal_uInt16>(*pIdRange++); 2554 for (sal_uInt16 nId = nStart + 1; nId <= nEnd; ++nId) 2555 { 2556 rWhichIds.Insert( nId ); 2557 } 2558 } 2559 } 2560 2561 void SAL_CALL 2562 SwXTextCursor::setAllPropertiesToDefault() 2563 throw (uno::RuntimeException) 2564 { 2565 vos::OGuard aGuard(Application::GetSolarMutex()); 2566 2567 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2568 2569 SvUShortsSort aParaWhichIds; 2570 SvUShortsSort aWhichIds; 2571 lcl_EnumerateIds(g_ParaResetableSetRange, aParaWhichIds); 2572 lcl_EnumerateIds(g_ResetableSetRange, aWhichIds); 2573 if (aParaWhichIds.Count()) 2574 { 2575 lcl_SelectParaAndReset(rUnoCursor, *rUnoCursor.GetDoc(), 2576 &aParaWhichIds); 2577 } 2578 if (aWhichIds.Count()) 2579 { 2580 rUnoCursor.GetDoc()->ResetAttrs(rUnoCursor, sal_True, &aWhichIds); 2581 } 2582 } 2583 2584 void SAL_CALL 2585 SwXTextCursor::setPropertiesToDefault( 2586 const uno::Sequence< OUString >& rPropertyNames) 2587 throw (beans::UnknownPropertyException, uno::RuntimeException) 2588 { 2589 vos::OGuard aGuard(Application::GetSolarMutex()); 2590 2591 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2592 2593 const sal_Int32 nCount = rPropertyNames.getLength(); 2594 if ( nCount ) 2595 { 2596 SwDoc & rDoc = *rUnoCursor.GetDoc(); 2597 const OUString * pNames = rPropertyNames.getConstArray(); 2598 SvUShortsSort aWhichIds; 2599 SvUShortsSort aParaWhichIds; 2600 for (sal_Int32 i = 0; i < nCount; i++) 2601 { 2602 SfxItemPropertySimpleEntry const*const pEntry = 2603 m_pImpl->m_rPropSet.getPropertyMap()->getByName( pNames[i] ); 2604 if (!pEntry) 2605 { 2606 if (pNames[i].equalsAsciiL( 2607 SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)) || 2608 pNames[i].equalsAsciiL( 2609 SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT))) 2610 { 2611 continue; 2612 } 2613 throw beans::UnknownPropertyException( 2614 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2615 + pNames[i], 2616 static_cast<cppu::OWeakObject *>(this)); 2617 } 2618 if (pEntry->nFlags & beans::PropertyAttribute::READONLY) 2619 { 2620 throw uno::RuntimeException( 2621 OUString(RTL_CONSTASCII_USTRINGPARAM( 2622 "setPropertiesToDefault: property is read-only: ")) 2623 + pNames[i], 2624 static_cast<cppu::OWeakObject *>(this)); 2625 } 2626 2627 if (pEntry->nWID < RES_FRMATR_END) 2628 { 2629 if (pEntry->nWID < RES_PARATR_BEGIN) 2630 { 2631 aWhichIds.Insert(pEntry->nWID); 2632 } 2633 else 2634 { 2635 aParaWhichIds.Insert(pEntry->nWID); 2636 } 2637 } 2638 else if (pEntry->nWID == FN_UNO_NUM_START_VALUE) 2639 { 2640 SwUnoCursorHelper::resetCrsrPropertyValue(*pEntry, rUnoCursor); 2641 } 2642 } 2643 2644 if (aParaWhichIds.Count()) 2645 { 2646 lcl_SelectParaAndReset(rUnoCursor, rDoc, &aParaWhichIds); 2647 } 2648 if (aWhichIds.Count()) 2649 { 2650 rDoc.ResetAttrs(rUnoCursor, sal_True, &aWhichIds); 2651 } 2652 } 2653 } 2654 2655 uno::Sequence< uno::Any > SAL_CALL 2656 SwXTextCursor::getPropertyDefaults( 2657 const uno::Sequence< OUString >& rPropertyNames) 2658 throw (beans::UnknownPropertyException, lang::WrappedTargetException, 2659 uno::RuntimeException) 2660 { 2661 vos::OGuard aGuard(Application::GetSolarMutex()); 2662 2663 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2664 2665 const sal_Int32 nCount = rPropertyNames.getLength(); 2666 uno::Sequence< uno::Any > aRet(nCount); 2667 if ( nCount ) 2668 { 2669 SwDoc & rDoc = *rUnoCursor.GetDoc(); 2670 const OUString *pNames = rPropertyNames.getConstArray(); 2671 uno::Any *pAny = aRet.getArray(); 2672 for (sal_Int32 i = 0; i < nCount; i++) 2673 { 2674 SfxItemPropertySimpleEntry const*const pEntry = 2675 m_pImpl->m_rPropSet.getPropertyMap()->getByName( pNames[i] ); 2676 if (!pEntry) 2677 { 2678 if (pNames[i].equalsAsciiL( 2679 SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)) || 2680 pNames[i].equalsAsciiL( 2681 SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT))) 2682 { 2683 continue; 2684 } 2685 throw beans::UnknownPropertyException( 2686 OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) 2687 + pNames[i], 2688 static_cast<cppu::OWeakObject *>(0)); 2689 } 2690 if (pEntry->nWID < RES_FRMATR_END) 2691 { 2692 const SfxPoolItem& rDefItem = 2693 rDoc.GetAttrPool().GetDefaultItem(pEntry->nWID); 2694 rDefItem.QueryValue(pAny[i], pEntry->nMemberId); 2695 } 2696 } 2697 } 2698 return aRet; 2699 } 2700 2701 void SAL_CALL SwXTextCursor::invalidateMarkings(::sal_Int32 nType) 2702 throw (uno::RuntimeException) 2703 { 2704 vos::OGuard aGuard(Application::GetSolarMutex()); 2705 2706 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2707 2708 SwNode* node = rUnoCursor.GetNode(); 2709 2710 if (node == 0) return; 2711 2712 SwTxtNode* txtNode = node->GetTxtNode(); 2713 2714 if (txtNode == 0) return; 2715 2716 if ( text::TextMarkupType::SPELLCHECK == nType ) 2717 { 2718 txtNode->SetWrongDirty(true); 2719 txtNode->SetWrong(0, true); 2720 } 2721 else if( text::TextMarkupType::PROOFREADING == nType ) 2722 { 2723 txtNode->SetGrammarCheckDirty(true); 2724 txtNode->SetGrammarCheck(0,true); 2725 } 2726 else if ( text::TextMarkupType::SMARTTAG == nType ) 2727 { 2728 txtNode->SetSmartTagDirty(true); 2729 txtNode->SetSmartTags (0, true); 2730 } 2731 else return; 2732 2733 SwFmtColl* fmtColl=txtNode->GetFmtColl(); 2734 2735 if (fmtColl == 0) return; 2736 2737 SwFmtChg aNew( fmtColl ); 2738 txtNode->NotifyClients( 0, &aNew ); 2739 } 2740 2741 2742 /*-- 10.03.2008 09:58:47--------------------------------------------------- 2743 2744 -----------------------------------------------------------------------*/ 2745 void SAL_CALL 2746 SwXTextCursor::makeRedline( 2747 const ::rtl::OUString& rRedlineType, 2748 const uno::Sequence< beans::PropertyValue >& rRedlineProperties) 2749 throw (lang::IllegalArgumentException, uno::RuntimeException) 2750 { 2751 vos::OGuard aGuard(Application::GetSolarMutex()); 2752 2753 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2754 2755 SwUnoCursorHelper::makeRedline(rUnoCursor, rRedlineType, rRedlineProperties); 2756 } 2757 2758 /*-- 09.12.98 14:18:58--------------------------------------------------- 2759 2760 -----------------------------------------------------------------------*/ 2761 void SAL_CALL SwXTextCursor::insertDocumentFromURL(const OUString& rURL, 2762 const uno::Sequence< beans::PropertyValue >& rOptions) 2763 throw (lang::IllegalArgumentException, io::IOException, 2764 uno::RuntimeException) 2765 { 2766 vos::OGuard aGuard(Application::GetSolarMutex()); 2767 2768 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 2769 2770 SwUnoCursorHelper::InsertFile(&rUnoCursor, rURL, rOptions); 2771 } 2772 2773 /* -----------------------------15.12.00 14:01-------------------------------- 2774 2775 ---------------------------------------------------------------------------*/ 2776 uno::Sequence< beans::PropertyValue > 2777 SwUnoCursorHelper::CreateSortDescriptor(const bool bFromTable) 2778 { 2779 uno::Sequence< beans::PropertyValue > aRet(5); 2780 beans::PropertyValue* pArray = aRet.getArray(); 2781 2782 uno::Any aVal; 2783 aVal.setValue( &bFromTable, ::getCppuBooleanType()); 2784 pArray[0] = beans::PropertyValue(C2U("IsSortInTable"), -1, aVal, 2785 beans::PropertyState_DIRECT_VALUE); 2786 2787 aVal <<= sal_Unicode(' '); 2788 pArray[1] = beans::PropertyValue(C2U("Delimiter"), -1, aVal, 2789 beans::PropertyState_DIRECT_VALUE); 2790 2791 aVal <<= (sal_Bool) sal_False; 2792 pArray[2] = beans::PropertyValue(C2U("IsSortColumns"), -1, aVal, 2793 beans::PropertyState_DIRECT_VALUE); 2794 2795 aVal <<= (sal_Int32) 3; 2796 pArray[3] = beans::PropertyValue(C2U("MaxSortFieldsCount"), -1, aVal, 2797 beans::PropertyState_DIRECT_VALUE); 2798 2799 uno::Sequence< table::TableSortField > aFields(3); 2800 table::TableSortField* pFields = aFields.getArray(); 2801 2802 lang::Locale aLang( SvxCreateLocale( LANGUAGE_SYSTEM ) ); 2803 // get collator algorithm to be used for the locale 2804 uno::Sequence< OUString > aSeq( 2805 GetAppCollator().listCollatorAlgorithms( aLang ) ); 2806 const sal_Int32 nLen = aSeq.getLength(); 2807 DBG_ASSERT( nLen > 0, "list of collator algorithms is empty!"); 2808 OUString aCollAlg; 2809 if (nLen > 0) 2810 { 2811 aCollAlg = aSeq.getConstArray()[0]; 2812 } 2813 2814 #if OSL_DEBUG_LEVEL > 1 2815 const OUString *pTxt = aSeq.getConstArray(); 2816 (void)pTxt; 2817 #endif 2818 2819 pFields[0].Field = 1; 2820 pFields[0].IsAscending = sal_True; 2821 pFields[0].IsCaseSensitive = sal_False; 2822 pFields[0].FieldType = table::TableSortFieldType_ALPHANUMERIC; 2823 pFields[0].CollatorLocale = aLang; 2824 pFields[0].CollatorAlgorithm = aCollAlg; 2825 2826 pFields[1].Field = 1; 2827 pFields[1].IsAscending = sal_True; 2828 pFields[1].IsCaseSensitive = sal_False; 2829 pFields[1].FieldType = table::TableSortFieldType_ALPHANUMERIC; 2830 pFields[1].CollatorLocale = aLang; 2831 pFields[1].CollatorAlgorithm = aCollAlg; 2832 2833 pFields[2].Field = 1; 2834 pFields[2].IsAscending = sal_True; 2835 pFields[2].IsCaseSensitive = sal_False; 2836 pFields[2].FieldType = table::TableSortFieldType_ALPHANUMERIC; 2837 pFields[2].CollatorLocale = aLang; 2838 pFields[2].CollatorAlgorithm = aCollAlg; 2839 2840 aVal <<= aFields; 2841 pArray[4] = beans::PropertyValue(C2U("SortFields"), -1, aVal, 2842 beans::PropertyState_DIRECT_VALUE); 2843 2844 return aRet; 2845 } 2846 2847 /*-- 09.12.98 14:18:58--------------------------------------------------- 2848 2849 -----------------------------------------------------------------------*/ 2850 uno::Sequence< beans::PropertyValue > SAL_CALL 2851 SwXTextCursor::createSortDescriptor() throw (uno::RuntimeException) 2852 { 2853 vos::OGuard aGuard(Application::GetSolarMutex()); 2854 2855 return SwUnoCursorHelper::CreateSortDescriptor(false); 2856 } 2857 2858 /* -----------------------------15.12.00 14:06-------------------------------- 2859 2860 ---------------------------------------------------------------------------*/ 2861 sal_Bool SwUnoCursorHelper::ConvertSortProperties( 2862 const uno::Sequence< beans::PropertyValue >& rDescriptor, 2863 SwSortOptions& rSortOpt) 2864 { 2865 sal_Bool bRet = sal_True; 2866 const beans::PropertyValue* pProperties = rDescriptor.getConstArray(); 2867 2868 rSortOpt.bTable = sal_False; 2869 rSortOpt.cDeli = ' '; 2870 rSortOpt.eDirection = SRT_COLUMNS; //!! UI text may be contrary though !! 2871 2872 SwSortKey* pKey1 = new SwSortKey; 2873 pKey1->nColumnId = USHRT_MAX; 2874 pKey1->bIsNumeric = sal_True; 2875 pKey1->eSortOrder = SRT_ASCENDING; 2876 2877 SwSortKey* pKey2 = new SwSortKey; 2878 pKey2->nColumnId = USHRT_MAX; 2879 pKey2->bIsNumeric = sal_True; 2880 pKey2->eSortOrder = SRT_ASCENDING; 2881 2882 SwSortKey* pKey3 = new SwSortKey; 2883 pKey3->nColumnId = USHRT_MAX; 2884 pKey3->bIsNumeric = sal_True; 2885 pKey3->eSortOrder = SRT_ASCENDING; 2886 SwSortKey* aKeys[3] = {pKey1, pKey2, pKey3}; 2887 2888 sal_Bool bOldSortdescriptor(sal_False); 2889 sal_Bool bNewSortdescriptor(sal_False); 2890 2891 for (sal_Int32 n = 0; n < rDescriptor.getLength(); ++n) 2892 { 2893 uno::Any aValue( pProperties[n].Value ); 2894 // String sPropName = pProperties[n].Name; 2895 const OUString& rPropName = pProperties[n].Name; 2896 2897 // old and new sortdescriptor 2898 if (rPropName.equalsAscii("IsSortInTable")) 2899 { 2900 if (aValue.getValueType() == ::getBooleanCppuType()) 2901 { 2902 rSortOpt.bTable = *(sal_Bool*)aValue.getValue(); 2903 } 2904 else 2905 { 2906 bRet = sal_False; 2907 } 2908 } 2909 else if (rPropName.equalsAscii("Delimiter")) 2910 { 2911 sal_Unicode uChar = sal_Unicode(); 2912 if (aValue >>= uChar) 2913 { 2914 rSortOpt.cDeli = uChar; 2915 } 2916 else 2917 { 2918 bRet = sal_False; 2919 } 2920 } 2921 // old sortdescriptor 2922 else if (rPropName.equalsAscii("SortColumns")) 2923 { 2924 bOldSortdescriptor = sal_True; 2925 sal_Bool bTemp(sal_False); 2926 if (aValue >>= bTemp) 2927 { 2928 rSortOpt.eDirection = bTemp ? SRT_COLUMNS : SRT_ROWS; 2929 } 2930 else 2931 { 2932 bRet = sal_False; 2933 } 2934 } 2935 else if ( rPropName.equalsAscii("IsCaseSensitive")) 2936 { 2937 bOldSortdescriptor = sal_True; 2938 sal_Bool bTemp(sal_False); 2939 if (aValue >>= bTemp) 2940 { 2941 rSortOpt.bIgnoreCase = !bTemp; 2942 } 2943 else 2944 { 2945 bRet = sal_False; 2946 } 2947 } 2948 else if (rPropName.equalsAscii("CollatorLocale")) 2949 { 2950 bOldSortdescriptor = sal_True; 2951 lang::Locale aLocale; 2952 if (aValue >>= aLocale) 2953 { 2954 rSortOpt.nLanguage = SvxLocaleToLanguage( aLocale ); 2955 } 2956 else 2957 { 2958 bRet = sal_False; 2959 } 2960 } 2961 else if (rPropName.matchAsciiL("CollatorAlgorithm", 17) && 2962 rPropName.getLength() == 18 && 2963 (rPropName.getStr()[17] >= '0' && rPropName.getStr()[17] <= '9')) 2964 { 2965 bOldSortdescriptor = sal_True; 2966 sal_uInt16 nIndex = rPropName.getStr()[17]; 2967 nIndex -= '0'; 2968 OUString aTxt; 2969 if ((aValue >>= aTxt) && nIndex < 3) 2970 { 2971 aKeys[nIndex]->sSortType = aTxt; 2972 } 2973 else 2974 { 2975 bRet = sal_False; 2976 } 2977 } 2978 else if (rPropName.matchAsciiL("SortRowOrColumnNo", 17) && 2979 rPropName.getLength() == 18 && 2980 (rPropName.getStr()[17] >= '0' && rPropName.getStr()[17] <= '9')) 2981 { 2982 bOldSortdescriptor = sal_True; 2983 sal_uInt16 nIndex = rPropName.getStr()[17]; 2984 nIndex -= '0'; 2985 sal_Int16 nCol = -1; 2986 if (aValue.getValueType() == ::getCppuType((const sal_Int16*)0) 2987 && nIndex < 3) 2988 { 2989 aValue >>= nCol; 2990 } 2991 if (nCol >= 0) 2992 { 2993 aKeys[nIndex]->nColumnId = nCol; 2994 } 2995 else 2996 { 2997 bRet = sal_False; 2998 } 2999 } 3000 else if (0 == rPropName.indexOf(C2U("IsSortNumeric")) && 3001 rPropName.getLength() == 14 && 3002 (rPropName.getStr()[13] >= '0' && rPropName.getStr()[13] <= '9')) 3003 { 3004 bOldSortdescriptor = sal_True; 3005 sal_uInt16 nIndex = rPropName.getStr()[13]; 3006 nIndex = nIndex - '0'; 3007 if (aValue.getValueType() == ::getBooleanCppuType() && nIndex < 3) 3008 { 3009 sal_Bool bTemp = *(sal_Bool*)aValue.getValue(); 3010 aKeys[nIndex]->bIsNumeric = bTemp; 3011 } 3012 else 3013 { 3014 bRet = sal_False; 3015 } 3016 } 3017 else if (0 == rPropName.indexOf(C2U("IsSortAscending")) && 3018 rPropName.getLength() == 16 && 3019 (rPropName.getStr()[15] >= '0' && rPropName.getStr()[15] <= '9')) 3020 { 3021 bOldSortdescriptor = sal_True; 3022 sal_uInt16 nIndex = rPropName.getStr()[15]; 3023 nIndex -= '0'; 3024 if (aValue.getValueType() == ::getBooleanCppuType() && nIndex < 3) 3025 { 3026 sal_Bool bTemp = *(sal_Bool*)aValue.getValue(); 3027 aKeys[nIndex]->eSortOrder = (bTemp) 3028 ? SRT_ASCENDING : SRT_DESCENDING; 3029 } 3030 else 3031 { 3032 bRet = sal_False; 3033 } 3034 } 3035 // new sortdescriptor 3036 else if (rPropName.equalsAscii("IsSortColumns")) 3037 { 3038 bNewSortdescriptor = sal_True; 3039 if (aValue.getValueType() == ::getBooleanCppuType()) 3040 { 3041 sal_Bool bTemp = *(sal_Bool*)aValue.getValue(); 3042 rSortOpt.eDirection = bTemp ? SRT_COLUMNS : SRT_ROWS; 3043 } 3044 else 3045 { 3046 bRet = sal_False; 3047 } 3048 } 3049 else if (rPropName.equalsAscii("SortFields")) 3050 { 3051 bNewSortdescriptor = sal_True; 3052 uno::Sequence < table::TableSortField > aFields; 3053 if (aValue >>= aFields) 3054 { 3055 sal_Int32 nCount(aFields.getLength()); 3056 if (nCount <= 3) 3057 { 3058 table::TableSortField* pFields = aFields.getArray(); 3059 for (sal_Int32 i = 0; i < nCount; ++i) 3060 { 3061 rSortOpt.bIgnoreCase = !pFields[i].IsCaseSensitive; 3062 rSortOpt.nLanguage = 3063 SvxLocaleToLanguage( pFields[i].CollatorLocale ); 3064 aKeys[i]->sSortType = pFields[i].CollatorAlgorithm; 3065 aKeys[i]->nColumnId = 3066 static_cast<sal_uInt16>(pFields[i].Field); 3067 aKeys[i]->bIsNumeric = (pFields[i].FieldType == 3068 table::TableSortFieldType_NUMERIC); 3069 aKeys[i]->eSortOrder = (pFields[i].IsAscending) 3070 ? SRT_ASCENDING : SRT_DESCENDING; 3071 } 3072 } 3073 else 3074 { 3075 bRet = sal_False; 3076 } 3077 } 3078 else 3079 { 3080 bRet = sal_False; 3081 } 3082 } 3083 } 3084 3085 if (bNewSortdescriptor && bOldSortdescriptor) 3086 { 3087 DBG_ERROR("someone tried to set the old deprecated and " 3088 "the new sortdescriptor"); 3089 bRet = sal_False; 3090 } 3091 3092 if (pKey1->nColumnId != USHRT_MAX) 3093 { 3094 rSortOpt.aKeys.C40_INSERT(SwSortKey, pKey1, rSortOpt.aKeys.Count()); 3095 } 3096 if (pKey2->nColumnId != USHRT_MAX) 3097 { 3098 rSortOpt.aKeys.C40_INSERT(SwSortKey, pKey2, rSortOpt.aKeys.Count()); 3099 } 3100 if (pKey3->nColumnId != USHRT_MAX) 3101 { 3102 rSortOpt.aKeys.C40_INSERT(SwSortKey, pKey3, rSortOpt.aKeys.Count()); 3103 } 3104 3105 return bRet && rSortOpt.aKeys.Count() > 0; 3106 } 3107 3108 /*-- 09.12.98 14:19:00--------------------------------------------------- 3109 3110 -----------------------------------------------------------------------*/ 3111 void SAL_CALL 3112 SwXTextCursor::sort(const uno::Sequence< beans::PropertyValue >& rDescriptor) 3113 throw (uno::RuntimeException) 3114 { 3115 vos::OGuard aGuard(Application::GetSolarMutex()); 3116 3117 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 3118 3119 if (rUnoCursor.HasMark()) 3120 { 3121 SwSortOptions aSortOpt; 3122 if (!SwUnoCursorHelper::ConvertSortProperties(rDescriptor, aSortOpt)) 3123 { 3124 throw uno::RuntimeException(); 3125 } 3126 UnoActionContext aContext( rUnoCursor.GetDoc() ); 3127 3128 SwPosition & rStart = *rUnoCursor.Start(); 3129 SwPosition & rEnd = *rUnoCursor.End(); 3130 3131 SwNodeIndex aPrevIdx( rStart.nNode, -1 ); 3132 const sal_uLong nOffset = rEnd.nNode.GetIndex() - rStart.nNode.GetIndex(); 3133 const xub_StrLen nCntStt = rStart.nContent.GetIndex(); 3134 3135 rUnoCursor.GetDoc()->SortText(rUnoCursor, aSortOpt); 3136 3137 // Selektion wieder setzen 3138 rUnoCursor.DeleteMark(); 3139 rUnoCursor.GetPoint()->nNode.Assign( aPrevIdx.GetNode(), +1 ); 3140 SwCntntNode *const pCNd = rUnoCursor.GetCntntNode(); 3141 xub_StrLen nLen = pCNd->Len(); 3142 if (nLen > nCntStt) 3143 { 3144 nLen = nCntStt; 3145 } 3146 rUnoCursor.GetPoint()->nContent.Assign(pCNd, nLen ); 3147 rUnoCursor.SetMark(); 3148 3149 rUnoCursor.GetPoint()->nNode += nOffset; 3150 SwCntntNode *const pCNd2 = rUnoCursor.GetCntntNode(); 3151 rUnoCursor.GetPoint()->nContent.Assign( pCNd2, pCNd2->Len() ); 3152 } 3153 } 3154 3155 /* -----------------------------03.04.00 09:11-------------------------------- 3156 3157 ---------------------------------------------------------------------------*/ 3158 uno::Reference< container::XEnumeration > SAL_CALL 3159 SwXTextCursor::createContentEnumeration(const OUString& rServiceName) 3160 throw (uno::RuntimeException) 3161 { 3162 vos::OGuard g(Application::GetSolarMutex()); 3163 3164 if (!rServiceName.equalsAscii("com.sun.star.text.TextContent")) 3165 { 3166 throw uno::RuntimeException(); 3167 } 3168 3169 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 3170 3171 uno::Reference< container::XEnumeration > xRet = 3172 new SwXParaFrameEnumeration(rUnoCursor, PARAFRAME_PORTION_TEXTRANGE); 3173 return xRet; 3174 } 3175 3176 /* -----------------------------07.03.01 14:53-------------------------------- 3177 3178 ---------------------------------------------------------------------------*/ 3179 uno::Reference< container::XEnumeration > SAL_CALL 3180 SwXTextCursor::createEnumeration() throw (uno::RuntimeException) 3181 { 3182 vos::OGuard g(Application::GetSolarMutex()); 3183 3184 SwUnoCrsr & rUnoCursor( m_pImpl->GetCursorOrThrow() ); 3185 3186 const uno::Reference<lang::XUnoTunnel> xTunnel( 3187 m_pImpl->m_xParentText, uno::UNO_QUERY); 3188 SwXText* pParentText = 0; 3189 if (xTunnel.is()) 3190 { 3191 pParentText = ::sw::UnoTunnelGetImplementation<SwXText>(xTunnel); 3192 } 3193 DBG_ASSERT(pParentText, "parent is not a SwXText"); 3194 if (!pParentText) 3195 { 3196 throw uno::RuntimeException(); 3197 } 3198 3199 ::std::auto_ptr<SwUnoCrsr> pNewCrsr( 3200 rUnoCursor.GetDoc()->CreateUnoCrsr(*rUnoCursor.GetPoint()) ); 3201 if (rUnoCursor.HasMark()) 3202 { 3203 pNewCrsr->SetMark(); 3204 *pNewCrsr->GetMark() = *rUnoCursor.GetMark(); 3205 } 3206 const CursorType eSetType = (CURSOR_TBLTEXT == m_pImpl->m_eType) 3207 ? CURSOR_SELECTION_IN_TABLE : CURSOR_SELECTION; 3208 SwTableNode const*const pStartNode( (CURSOR_TBLTEXT == m_pImpl->m_eType) 3209 ? rUnoCursor.GetPoint()->nNode.GetNode().FindTableNode() 3210 : 0); 3211 SwTable const*const pTable( 3212 (pStartNode) ? & pStartNode->GetTable() : 0 ); 3213 const uno::Reference< container::XEnumeration > xRet = 3214 new SwXParagraphEnumeration( 3215 pParentText, pNewCrsr, eSetType, pStartNode, pTable); 3216 3217 return xRet; 3218 } 3219 3220 /* -----------------------------07.03.01 15:43-------------------------------- 3221 3222 ---------------------------------------------------------------------------*/ 3223 uno::Type SAL_CALL 3224 SwXTextCursor::getElementType() throw (uno::RuntimeException) 3225 { 3226 return text::XTextRange::static_type(); 3227 } 3228 3229 /* -----------------------------07.03.01 15:43-------------------------------- 3230 3231 ---------------------------------------------------------------------------*/ 3232 sal_Bool SAL_CALL SwXTextCursor::hasElements() throw (uno::RuntimeException) 3233 { 3234 return sal_True; 3235 } 3236 3237 /* -----------------------------03.04.00 09:11-------------------------------- 3238 3239 ---------------------------------------------------------------------------*/ 3240 uno::Sequence< OUString > SAL_CALL 3241 SwXTextCursor::getAvailableServiceNames() throw (uno::RuntimeException) 3242 { 3243 uno::Sequence< OUString > aRet(1); 3244 OUString* pArray = aRet.getArray(); 3245 pArray[0] = OUString::createFromAscii("com.sun.star.text.TextContent"); 3246 return aRet; 3247 } 3248 3249 // --------------------------------------------------------------------------- 3250 IMPLEMENT_FORWARD_REFCOUNT( SwXTextCursor,SwXTextCursor_Base ) 3251 3252 uno::Any SAL_CALL 3253 SwXTextCursor::queryInterface(const uno::Type& rType) 3254 throw (uno::RuntimeException) 3255 { 3256 return (rType == lang::XUnoTunnel::static_type()) 3257 ? OTextCursorHelper::queryInterface(rType) 3258 : SwXTextCursor_Base::queryInterface(rType); 3259 } 3260 3261