?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / sw / source / core / unocore / unoobj.cxx
blobcb327b1962085ece88e2ef82e5d13c7c2a3a7b28
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: unoobj.cxx,v $
10 * $Revision: 1.111.80.1 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33
34
35 #include <osl/endian.h>
36 #include <rtl/ustrbuf.hxx>
37 #include <swtypes.hxx>
38 #include <hintids.hxx>
39 #include <cmdid.h>
40 #include <hints.hxx>
41 #include <IMark.hxx>
42 #include <frmfmt.hxx>
43 #include <doc.hxx>
44 #include <istyleaccess.hxx>
45 #include <ndtxt.hxx>
46 #include <ndnotxt.hxx>
47 #include <unocrsrhelper.hxx>
48 #include <swundo.hxx>
49 #include <rootfrm.hxx>
50 #include <flyfrm.hxx>
51 #include <ftnidx.hxx>
52 #include <sfx2/linkmgr.hxx>
53 #include <docary.hxx>
54 #include <paratr.hxx>
55 #include <tools/urlobj.hxx>
56 #include <pam.hxx>
57 #include <tools/cachestr.hxx>
58 #include <shellio.hxx>
59 #include <swerror.h>
60 #include <swtblfmt.hxx>
61 #include <fmtruby.hxx>
62 #include <docsh.hxx>
63 #include <docstyle.hxx>
64 #include <charfmt.hxx>
65 #include <txtfld.hxx>
66 #include <fmtfld.hxx>
67 #include <fmtpdsc.hxx>
68 #include <pagedesc.hxx>
69 #ifndef _POOLFMT_HRC
70 #include <poolfmt.hrc>
71 #endif
72 #include <poolfmt.hxx>
73 #include <edimp.hxx>
74 #include <fchrfmt.hxx>
75 #include <fmtautofmt.hxx>
76 #include <cntfrm.hxx>
77 #include <pagefrm.hxx>
78 #include <doctxm.hxx>
79 #include <sfx2/docfilt.hxx>
80 #include <sfx2/docfile.hxx>
81 #include <sfx2/fcontnr.hxx>
82 #include <fmtrfmrk.hxx>
83 #include <txtrfmrk.hxx>
84 #include <unoclbck.hxx>
85 #include <unoobj.hxx>
86 #include <unomap.hxx>
87 #include <unosett.hxx>
88 #include <unoprnms.hxx>
89 #include <unotbl.hxx>
90 #include <unodraw.hxx>
91 #include <unocoll.hxx>
92 #include <unostyle.hxx>
93 #include <unofield.hxx>
94 #include <unometa.hxx>
95 #include <fmtanchr.hxx>
96 #include <svx/flstitem.hxx>
97 #include <svtools/ctrltool.hxx>
98 #include <flypos.hxx>
99 #include <txtftn.hxx>
100 #include <fmtftn.hxx>
101 #include <com/sun/star/text/WrapTextMode.hpp>
102 #include <com/sun/star/text/TextContentAnchorType.hpp>
103 #include <com/sun/star/style/PageStyleLayout.hpp>
104 #include <com/sun/star/text/XTextDocument.hpp>
105 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
106 #include <com/sun/star/drawing/XDrawPageSupplier.hpp>
107 #include <unoidx.hxx>
108 #include <unoframe.hxx>
109 #include <fmthdft.hxx>
110 #include <vos/mutex.hxx>
111 #include <vcl/svapp.hxx>
112 #include <fmtflcnt.hxx>
113 #define _SVSTDARR_USHORTS
114 #define _SVSTDARR_USHORTSSORT
115 #include <svtools/svstdarr.hxx>
116 #include <svx/brshitem.hxx>
117 #include <fmtclds.hxx>
118 #include <dcontact.hxx>
119 #include <SwStyleNameMapper.hxx>
120 #include <crsskip.hxx>
121 #include <com/sun/star/beans/PropertyAttribute.hpp>
122 #include <memory>
123
124
125 using namespace ::com::sun::star;
126 using namespace ::com::sun::star::uno;
127 using namespace ::com::sun::star::lang;
128 using namespace ::com::sun::star::uno;
129 using namespace ::com::sun::star::text;
130 using namespace ::com::sun::star::container;
131 using namespace ::com::sun::star::beans;
132 using namespace ::com::sun::star::drawing;
133 using std::auto_ptr;
134 using ::rtl::OUString;
135 using ::rtl::OUStringBuffer;
136
137 /****************************************************************************
138 static methods
139 ****************************************************************************/
140 uno::Sequence< sal_Int8 > CreateUnoTunnelId()
141 {
142 static osl::Mutex aCreateMutex;
143 osl::Guard<osl::Mutex> aGuard( aCreateMutex );
144 uno::Sequence< sal_Int8 > aSeq( 16 );
145 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
146 return aSeq;
147 }
148 /****************************************************************************
149 Hilfsklassen
150 ****************************************************************************/
151
152 /* -----------------13.05.98 12:15-------------------
153 *
154 * --------------------------------------------------*/
155 SwUnoInternalPaM::SwUnoInternalPaM(SwDoc& rDoc) :
156 SwPaM(rDoc.GetNodes())
157 {
158 }
159 SwUnoInternalPaM::~SwUnoInternalPaM()
160 {
161 while( GetNext() != this)
162 {
163 delete GetNext();
164 }
165 }
166
167 SwUnoInternalPaM& SwUnoInternalPaM::operator=(const SwPaM& rPaM)
168 {
169 const SwPaM* pTmp = &rPaM;
170 *GetPoint() = *rPaM.GetPoint();
171 if(rPaM.HasMark())
172 {
173 SetMark();
174 *GetMark() = *rPaM.GetMark();
175 }
176 else
177 DeleteMark();
178 while(&rPaM != (pTmp = (const SwPaM*)pTmp->GetNext()))
179 {
180 if(pTmp->HasMark())
181 new SwPaM(*pTmp->GetMark(), *pTmp->GetPoint(), this);
182 else
183 new SwPaM(*pTmp->GetPoint(), this);
184 }
185 return *this;
186 }
187 /****************************************************************************
188 ActionContext
189 ****************************************************************************/
190 UnoActionContext::UnoActionContext(SwDoc* pDc) :
191 pDoc(pDc)
192 {
193 SwRootFrm* pRootFrm = pDoc->GetRootFrm();
194 if(pRootFrm)
195 pRootFrm->StartAllAction();
196 }
197 /*-----------------04.03.98 11:56-------------------
198
199 --------------------------------------------------*/
200 UnoActionContext::~UnoActionContext()
201 {
202 //das Doc kann hier schon entfernt worden sein
203 if(pDoc)
204 {
205 SwRootFrm* pRootFrm = pDoc->GetRootFrm();
206 if(pRootFrm)
207 pRootFrm->EndAllAction();
208 }
209 }
210
211 /****************************************************************************
212 ActionRemoveContext
213 ****************************************************************************/
214 UnoActionRemoveContext::UnoActionRemoveContext(SwDoc* pDc) :
215 pDoc(pDc)
216 {
217 SwRootFrm* pRootFrm = pDoc->GetRootFrm();
218 if(pRootFrm)
219 pRootFrm->UnoRemoveAllActions();
220 }
221 /* -----------------07.07.98 12:05-------------------
222 *
223 * --------------------------------------------------*/
224 UnoActionRemoveContext::~UnoActionRemoveContext()
225 {
226 SwRootFrm* pRootFrm = pDoc->GetRootFrm();
227 if(pRootFrm)
228 pRootFrm->UnoRestoreAllActions();
229
230 }
231
232 /*-----------------09.03.98 08:29-------------------
233
234 --------------------------------------------------*/
235 void SwXTextCursor::SelectPam(SwPaM& rCrsr, sal_Bool bExpand)
236 {
237 if(bExpand)
238 {
239 if(!rCrsr.HasMark())
240 rCrsr.SetMark();
241 }
242 else if(rCrsr.HasMark())
243 rCrsr.DeleteMark();
244
245 }
246
247 /* -----------------20.05.98 14:59-------------------
248 *
249 * --------------------------------------------------*/
250 void SwXTextCursor::getTextFromPam(SwPaM& aCrsr, OUString& rBuffer)
251 {
252 if(!aCrsr.HasMark())
253 return;
254 SvCacheStream aStream( 20480 );
255 #ifdef OSL_BIGENDIAN
256 aStream.SetNumberFormatInt( NUMBERFORMAT_INT_BIGENDIAN );
257 #else
258 aStream.SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
259 #endif
260 WriterRef xWrt;
261 // TODO/MBA: looks like a BaseURL doesn't make sense here
262 SwReaderWriter::GetWriter( C2S(FILTER_TEXT_DLG), String(), xWrt );
263 if( xWrt.Is() )
264 {
265 SwWriter aWriter( aStream, aCrsr );
266 xWrt->bASCII_NoLastLineEnd = sal_True;
267 xWrt->bExportPargraphNumbering = sal_False;
268 SwAsciiOptions aOpt = xWrt->GetAsciiOptions();
269 aOpt.SetCharSet( RTL_TEXTENCODING_UNICODE );
270 xWrt->SetAsciiOptions( aOpt );
271 xWrt->bUCS2_WithStartChar = FALSE;
272 // --> FME #i68522#
273 const BOOL bOldShowProgress = xWrt->bShowProgress;
274 xWrt->bShowProgress = FALSE;
275 // <--
276
277 long lLen;
278 if( !IsError( aWriter.Write( xWrt ) ) &&
279 0x7ffffff > (( lLen = aStream.GetSize() )
280 / sizeof( sal_Unicode )) + 1 )
281 {
282 aStream << (sal_Unicode)'\0';
283
284 long lUniLen = (lLen / sizeof( sal_Unicode ));
285 ::rtl::OUStringBuffer aStrBuffer( lUniLen );
286 aStream.Seek( 0 );
287 aStream.ResetError();
288 while(lUniLen)
289 {
290 String sBuf;
291 sal_Int32 nLocalLen = 0;
292 if( lUniLen >= STRING_MAXLEN )
293 nLocalLen = STRING_MAXLEN - 1;
294 else
295 nLocalLen = lUniLen;
296 sal_Unicode* pStrBuf = sBuf.AllocBuffer( xub_StrLen( nLocalLen + 1));
297 aStream.Read( pStrBuf, 2 * nLocalLen );
298 pStrBuf[ nLocalLen ] = '\0';
299 aStrBuffer.append( pStrBuf, nLocalLen );
300 lUniLen -= nLocalLen;
301 }
302 rBuffer = aStrBuffer.makeStringAndClear();
303 }
304 xWrt->bShowProgress = bOldShowProgress;
305 }
306 }
307
308 /* -----------------06.07.98 07:33-------------------
309 *
310 * --------------------------------------------------*/
311 void lcl_setCharStyle(SwDoc* pDoc, const uno::Any aValue, SfxItemSet& rSet)
312 throw (lang::IllegalArgumentException)
313 {
314 SwDocShell* pDocSh = pDoc->GetDocShell();
315 if(pDocSh)
316 {
317 OUString uStyle;
318 aValue >>= uStyle;
319 String sStyle;
320 SwStyleNameMapper::FillUIName(uStyle, sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True );
321 SwDocStyleSheet* pStyle =
322 (SwDocStyleSheet*)pDocSh->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_CHAR);
323 if(pStyle)
324 {
325 SwFmtCharFmt aFmt(pStyle->GetCharFmt());
326 rSet.Put(aFmt);
327 }
328 else
329 {
330 throw lang::IllegalArgumentException();
331 }
332
333 }
334 };
335 /* -----------------08.06.06 10:43-------------------
336 *
337 * --------------------------------------------------*/
338 void lcl_setAutoStyle(IStyleAccess& rStyleAccess, const uno::Any aValue, SfxItemSet& rSet, bool bPara )
339 throw (lang::IllegalArgumentException)
340 {
341 OUString uStyle;
342 aValue >>= uStyle;
343 String sStyle;
344 StylePool::SfxItemSet_Pointer_t pStyle = bPara ?
345 rStyleAccess.getByName(uStyle, IStyleAccess::AUTO_STYLE_PARA ):
346 rStyleAccess.getByName(uStyle, IStyleAccess::AUTO_STYLE_CHAR );
347 if(pStyle.get())
348 {
349 SwFmtAutoFmt aFmt( bPara ? sal::static_int_cast< USHORT >(RES_AUTO_STYLE)
350 : sal::static_int_cast< USHORT >(RES_TXTATR_AUTOFMT) );
351 aFmt.SetStyleHandle( pStyle );
352 rSet.Put(aFmt);
353 }
354 else
355 {
356 throw lang::IllegalArgumentException();
357 }
358 };
359 /* -----------------30.06.98 08:46-------------------
360 *
361 * --------------------------------------------------*/
362 void lcl_SetTxtFmtColl(const uno::Any& rAny, SwPaM& rPaM)
363 throw (lang::IllegalArgumentException)
364 {
365 SwDoc* pDoc = rPaM.GetDoc();
366 SwDocShell* pDocSh = pDoc->GetDocShell();
367 if(!pDocSh)
368 return;
369 OUString uStyle;
370 rAny >>= uStyle;
371 String sStyle;
372 SwStyleNameMapper::FillUIName(uStyle, sStyle, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True );
373 SwDocStyleSheet* pStyle =
374 (SwDocStyleSheet*)pDocSh->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_PARA);
375 if(pStyle)
376 {
377 SwTxtFmtColl *pLocal = pStyle->GetCollection();
378 UnoActionContext aAction(pDoc);
379 pDoc->StartUndo( UNDO_START, NULL );
380 SwPaM *pTmpCrsr = &rPaM;
381 do {
382 pDoc->SetTxtFmtColl(*pTmpCrsr, pLocal);
383 pTmpCrsr = static_cast<SwPaM*>(pTmpCrsr->GetNext());
384 } while ( pTmpCrsr != &rPaM );
385 pDoc->EndUndo( UNDO_END, NULL );
386 }
387 else
388 {
389 throw lang::IllegalArgumentException();
390 }
391
392 }
393 /* -----------------06.07.98 07:38-------------------
394 *
395 * --------------------------------------------------*/
396 void lcl_setPageDesc(SwDoc* pDoc, const uno::Any& aValue, SfxItemSet& rSet)
397 {
398 if(aValue.getValueType() != ::getCppuType((const OUString*)0))
399 return;
400 SwFmtPageDesc *pNewDesc = 0 ;
401 const SfxPoolItem* pItem;
402 if(SFX_ITEM_SET == rSet.GetItemState( RES_PAGEDESC, sal_True, &pItem ) )
403 {
404 pNewDesc = new SwFmtPageDesc(*((SwFmtPageDesc*)pItem));
405 }
406 if(!pNewDesc)
407 pNewDesc = new SwFmtPageDesc();
408 OUString uDescName;
409 aValue >>= uDescName;
410 String sDescName;
411 SwStyleNameMapper::FillUIName(uDescName, sDescName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True );
412 if(!pNewDesc->GetPageDesc() || pNewDesc->GetPageDesc()->GetName() != sDescName)
413 {
414 sal_Bool bPut = sal_False;
415 if(sDescName.Len())
416 {
417 SwPageDesc* pPageDesc = ::GetPageDescByName_Impl(*pDoc, sDescName);
418 if(pPageDesc)
419 {
420 pPageDesc->Add( pNewDesc );
421 bPut = sal_True;
422 }
423 else
424 {
425 throw lang::IllegalArgumentException();
426 }
427 }
428 if(!bPut)
429 {
430 rSet.ClearItem(RES_BREAK);
431 rSet.Put(SwFmtPageDesc());
432 }
433 else
434 rSet.Put(*pNewDesc);
435 }
436 delete pNewDesc;
437 }
438 /* -----------------30.06.98 10:29-------------------
439 *
440 * --------------------------------------------------*/
441 void lcl_SetNodeNumStart( SwPaM& rCrsr, uno::Any aValue )
442 {
443 sal_Int16 nTmp = 1;
444 aValue >>= nTmp;
445 sal_uInt16 nStt = (nTmp < 0 ? USHRT_MAX : (sal_uInt16)nTmp);
446 SwDoc* pDoc = rCrsr.GetDoc();
447 UnoActionContext aAction(pDoc);
448
449 if( rCrsr.GetNext() != &rCrsr ) // Mehrfachselektion ?
450 {
451 pDoc->StartUndo( UNDO_START, NULL );
452 SwPamRanges aRangeArr( rCrsr );
453 SwPaM aPam( *rCrsr.GetPoint() );
454 for( sal_uInt16 n = 0; n < aRangeArr.Count(); ++n )
455 {
456 pDoc->SetNumRuleStart(*aRangeArr.SetPam( n, aPam ).GetPoint());
457 pDoc->SetNodeNumStart(*aRangeArr.SetPam( n, aPam ).GetPoint(),
458 nStt );
459 }
460 pDoc->EndUndo( UNDO_END, NULL);
461 }
462 else
463 {
464 pDoc->SetNumRuleStart( *rCrsr.GetPoint());
465 pDoc->SetNodeNumStart( *rCrsr.GetPoint(), nStt );
466 }
467 }
468
469 /* -----------------17.09.98 09:44-------------------
470 *
471 * --------------------------------------------------*/
472 sal_Bool lcl_setCrsrPropertyValue(const SfxItemPropertySimpleEntry* pEntry,
473 SwPaM& rPam,
474 SfxItemSet& rItemSet,
475 const uno::Any& aValue ) throw (lang::IllegalArgumentException)
476 {
477 sal_Bool bRet = sal_True;
478 if(0 == ( pEntry->nFlags&PropertyAttribute::MAYBEVOID ) &&
479 aValue.getValueType() == ::getCppuVoidType())
480 bRet = sal_False;
481 else
482 {
483 switch(pEntry->nWID)
484 {
485 case RES_TXTATR_CHARFMT:
486 lcl_setCharStyle(rPam.GetDoc(), aValue, rItemSet );
487 break;
488 case RES_TXTATR_AUTOFMT:
489 lcl_setAutoStyle(rPam.GetDoc()->GetIStyleAccess(), aValue, rItemSet, false );
490 break;
491 case FN_UNO_CHARFMT_SEQUENCE:
492 {
493 Sequence<OUString> aCharStyles;
494 if(aValue >>= aCharStyles)
495 {
496 for(sal_Int32 nStyle = 0; nStyle < aCharStyles.getLength(); nStyle++)
497 {
498 Any aStyle;
499 rPam.GetDoc()->StartUndo( UNDO_START, NULL);
500 aStyle <<= aCharStyles.getConstArray()[nStyle];
501 //create a local set and apply each format directly
502 SfxItemSet aSet(rPam.GetDoc()->GetAttrPool(), RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT );
503 lcl_setCharStyle(rPam.GetDoc(), aStyle, aSet );
504 //the first style should replace the current attributes, all other have to be added
505 SwXTextCursor::SetCrsrAttr(rPam, aSet, nStyle ? CRSR_ATTR_MODE_DONTREPLACE : 0);
506 rPam.GetDoc()->EndUndo( UNDO_START, NULL );
507 }
508 }
509 else
510 bRet = sal_False;
511 }
512 break;
513 case FN_UNO_PARA_STYLE :
514 lcl_SetTxtFmtColl(aValue, rPam);
515 break;
516 case RES_AUTO_STYLE:
517 lcl_setAutoStyle(rPam.GetDoc()->GetIStyleAccess(), aValue, rItemSet, true );
518 break;
519 case FN_UNO_PAGE_STYLE :
520 break;
521 case FN_UNO_NUM_START_VALUE :
522 lcl_SetNodeNumStart( rPam, aValue );
523 break;
524 case FN_UNO_NUM_LEVEL :
525 // --> OD 2008-07-14 #i91601#
526 case FN_UNO_LIST_ID:
527 // <--
528 case FN_UNO_IS_NUMBER :
529 {
530 // multi selection is not considered
531 SwTxtNode* pTxtNd = rPam.GetNode()->GetTxtNode();
532 // --> OD 2008-05-14 #refactorlists# - check on list style not needed
533 // const SwNumRule* pRule = pTxtNd->GetNumRule();
534 // if( FN_UNO_NUM_LEVEL == pEntry->nWID && pRule != NULL )
535 if ( FN_UNO_NUM_LEVEL == pEntry->nWID )
536 // <--
537 {
538 sal_Int16 nLevel = 0;
539 aValue >>= nLevel;
540
541 pTxtNd->SetAttrListLevel(nLevel);
542
543 }
544 // --> OD 2008-07-14 #i91601#
545 else if( FN_UNO_LIST_ID == pEntry->nWID )
546 {
547 ::rtl::OUString sListId;
548 aValue >>= sListId;
549 pTxtNd->SetListId( sListId );
550 }
551 // <--
552 else if( FN_UNO_IS_NUMBER == pEntry->nWID )
553 {
554 BOOL bIsNumber = *(sal_Bool*) aValue.getValue();
555 if(!bIsNumber)
556 pTxtNd->SetCountedInList( false );
557 }
558 //PROPERTY_MAYBEVOID!
559 }
560 break;
561 case FN_NUMBER_NEWSTART :
562 {
563 sal_Bool bVal = sal_False;
564 if (aValue >>= bVal)
565 rPam.GetDoc()->SetNumRuleStart(*rPam.GetPoint(), bVal);
566 else
567 throw lang::IllegalArgumentException();
568 }
569 break;
570 case FN_UNO_NUM_RULES:
571 SwUnoCursorHelper::setNumberingProperty(aValue, rPam);
572 break;
573 case RES_PARATR_DROP:
574 {
575 if( MID_DROPCAP_CHAR_STYLE_NAME == pEntry->nMemberId)
576 {
577 OUString uStyle;
578 if(aValue >>= uStyle)
579 {
580 String sStyle;
581 SwStyleNameMapper::FillUIName(uStyle, sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True );
582 SwDoc* pDoc = rPam.GetDoc();
583 //default character style mustn't be set as default format
584 SwDocStyleSheet* pStyle =
585 (SwDocStyleSheet*)pDoc->GetDocShell()->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_CHAR);
586 SwFmtDrop* pDrop = 0;
587 if(pStyle &&
588 ((SwDocStyleSheet*)pStyle)->GetCharFmt() != pDoc->GetDfltCharFmt())
589 {
590 const SfxPoolItem* pItem;
591 if(SFX_ITEM_SET == rItemSet.GetItemState( RES_PARATR_DROP, sal_True, &pItem ) )
592 pDrop = new SwFmtDrop(*((SwFmtDrop*)pItem));
593 if(!pDrop)
594 pDrop = new SwFmtDrop();
595 rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *(SwDocStyleSheet*)pStyle ) );
596 pDrop->SetCharFmt(xStyle->GetCharFmt());
597 }
598 else
599 throw lang::IllegalArgumentException();
600 rItemSet.Put(*pDrop);
601 delete pDrop;
602 }
603 else
604 throw lang::IllegalArgumentException();
605 }
606 else
607 bRet = sal_False;
608 }
609 break;
610 case RES_TXTATR_CJK_RUBY:
611 if(MID_RUBY_CHARSTYLE == pEntry->nMemberId )
612 {
613 OUString sTmp;
614 if(aValue >>= sTmp)
615 {
616 SwFmtRuby* pRuby = 0;
617 const SfxPoolItem* pItem;
618 if(SFX_ITEM_SET == rItemSet.GetItemState( RES_TXTATR_CJK_RUBY, sal_True, &pItem ) )
619 pRuby = new SwFmtRuby(*((SwFmtRuby*)pItem));
620 if(!pRuby)
621 pRuby = new SwFmtRuby(aEmptyStr);
622 String sStyle;
623 SwStyleNameMapper::FillUIName(sTmp, sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True );
624 pRuby->SetCharFmtName( sStyle );
625 pRuby->SetCharFmtId( 0 );
626 if(sStyle.Len() > 0)
627 {
628 sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
629 pRuby->SetCharFmtId(nId);
630 }
631 rItemSet.Put(*pRuby);
632 delete pRuby;
633 }
634 else
635 throw lang::IllegalArgumentException();
636 bRet = sal_True;
637 }
638 else
639 bRet = sal_False;
640 break;
641 case RES_PAGEDESC :
642 if(MID_PAGEDESC_PAGEDESCNAME == pEntry->nMemberId )
643 {
644 lcl_setPageDesc(rPam.GetDoc(), aValue, rItemSet);
645 break;
646 }
647 //hier kein break
648 default: bRet = sal_False;
649 }
650 }
651 return bRet;
652 }
653
654 /* -----------------30.06.98 08:39-------------------
655 *
656 * --------------------------------------------------*/
657 SwFmtColl* SwXTextCursor::GetCurTxtFmtColl(SwPaM& rPaM, BOOL bConditional)
658 {
659 static const sal_uInt16 nMaxLookup = 1000;
660 SwFmtColl *pFmt = 0;
661
662 // if ( GetCrsrCnt() > nMaxLookup )
663 // return 0;
664 sal_Bool bError = sal_False;
665 SwPaM *pTmpCrsr = &rPaM;
666 do {
667
668 ULONG nSttNd = pTmpCrsr->GetMark()->nNode.GetIndex();
669 ULONG nEndNd = pTmpCrsr->GetPoint()->nNode.GetIndex();
670 xub_StrLen nSttCnt = pTmpCrsr->GetMark()->nContent.GetIndex();
671 xub_StrLen nEndCnt = pTmpCrsr->GetPoint()->nContent.GetIndex();
672
673 if( nSttNd > nEndNd || ( nSttNd == nEndNd && nSttCnt > nEndCnt ))
674 {
675 sal_uInt32 nTmp = nSttNd; nSttNd = nEndNd; nEndNd = nTmp;
676 nTmp = nSttCnt; nSttCnt = nEndCnt; nEndCnt = (sal_uInt16)nTmp;
677 }
678
679 if( nEndNd - nSttNd >= nMaxLookup )
680 {
681 pFmt = 0;
682 break;
683 }
684
685 const SwNodes& rNds = rPaM.GetDoc()->GetNodes();
686 for( ULONG n = nSttNd; n <= nEndNd; ++n )
687 {
688 const SwTxtNode* pNd = rNds[ n ]->GetTxtNode();
689 if( pNd )
690 {
691 SwFmtColl* pNdFmt = bConditional ? pNd->GetFmtColl()
692 : &pNd->GetAnyFmtColl();
693 if( !pFmt )
694 pFmt = pNdFmt;
695 else if( pFmt != pNdFmt )
696 {
697 bError = sal_True;
698 break;
699 }
700 }
701 }
702 if(bError)
703 break;
704
705 pTmpCrsr = static_cast<SwPaM*>(pTmpCrsr->GetNext());
706 } while ( pTmpCrsr != &rPaM );
707 return bError ? 0 : pFmt;
708 }
709
710 /* -----------------26.06.98 16:20-------------------
711 * Hilfsfunktion fuer PageDesc
712 * --------------------------------------------------*/
713 SwPageDesc* GetPageDescByName_Impl(SwDoc& rDoc, const String& rName)
714 {
715 SwPageDesc* pRet = 0;
716 sal_uInt16 nDCount = rDoc.GetPageDescCnt();
717 sal_uInt16 i;
718
719 for( i = 0; i < nDCount; i++ )
720 {
721 SwPageDesc* pDsc = &rDoc._GetPageDesc( i );
722 if(pDsc->GetName() == rName)
723 {
724 pRet = pDsc;
725 break;
726 }
727 }
728 if(!pRet)
729 {
730 for(i = RC_POOLPAGEDESC_BEGIN; i <= STR_POOLPAGE_LANDSCAPE; ++i)
731 {
732 const String aFmtName(SW_RES(i));
733 if(aFmtName == rName)
734 {
735 pRet = rDoc.GetPageDescFromPool( static_cast< sal_uInt16 >(RES_POOLPAGE_BEGIN + i - RC_POOLPAGEDESC_BEGIN) );
736 break;
737 }
738 }
739 }
740
741 return pRet;
742 }
743 /******************************************************************************
744 ******************************************************************************
745 ******************************************************************************
746 * Taskforce ONE51
747 ******************************************************************************/
748
749 /******************************************************************
750 * SwXTextCursor
751 ******************************************************************/
752
753 /*-- 09.12.98 14:19:19---------------------------------------------------
754
755 -----------------------------------------------------------------------*/
756 OUString SwXTextCursor::getImplementationName(void) throw( RuntimeException )
757 {
758 return C2U("SwXTextCursor");
759 }
760 /*-- 09.12.98 14:19:19---------------------------------------------------
761
762 -----------------------------------------------------------------------*/
763 BOOL SwXTextCursor::supportsService(const OUString& rServiceName) throw( RuntimeException )
764 {
765 String sServiceName(rServiceName);
766 return sServiceName.EqualsAscii("com.sun.star.text.TextCursor") ||
767 sServiceName.EqualsAscii("com.sun.star.style.CharacterProperties")||
768 sServiceName.EqualsAscii("com.sun.star.style.CharacterPropertiesAsian")||
769 sServiceName.EqualsAscii("com.sun.star.style.CharacterPropertiesComplex")||
770 sServiceName.EqualsAscii("com.sun.star.style.ParagraphProperties") ||
771 sServiceName.EqualsAscii("com.sun.star.style.ParagraphPropertiesAsian") ||
772 sServiceName.EqualsAscii("com.sun.star.style.ParagraphPropertiesComplex") ||
773 sServiceName.EqualsAscii("com.sun.star.text.TextSortable");
774 }
775 /*-- 09.12.98 14:19:19---------------------------------------------------
776
777 -----------------------------------------------------------------------*/
778 Sequence< OUString > SwXTextCursor::getSupportedServiceNames(void) throw( RuntimeException )
779 {
780 Sequence< OUString > aRet(8);
781 OUString* pArray = aRet.getArray();
782 pArray[0] = C2U("com.sun.star.text.TextCursor");
783 pArray[1] = C2U("com.sun.star.style.CharacterProperties");
784 pArray[2] = C2U("com.sun.star.style.CharacterPropertiesAsian");
785 pArray[3] = C2U("com.sun.star.style.CharacterPropertiesComplex");
786 pArray[4] = C2U("com.sun.star.style.ParagraphProperties");
787 pArray[5] = C2U("com.sun.star.style.ParagraphPropertiesAsian");
788 pArray[6] = C2U("com.sun.star.style.ParagraphPropertiesComplex");
789 pArray[7] = C2U("com.sun.star.text.TextSortable");
790 return aRet;
791 }
792 /*-- 09.12.98 14:19:19---------------------------------------------------
793
794 -----------------------------------------------------------------------*/
795 SwXTextCursor::SwXTextCursor(uno::Reference< XText > xParent, const SwPosition& rPos,
796 CursorType eSet, SwDoc* pDoc, const SwPosition* pMark) :
797 aLstnrCntnr(( util::XSortable*)this),
798 m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR)),
799 xParentText(xParent),
800 pLastSortOptions(0),
801 eType(eSet),
802 mbRemoveUserEvent( false )
803 {
804 SwUnoCrsr* pUnoCrsr = pDoc->CreateUnoCrsr(rPos, sal_False);
805 if(pMark)
806 {
807 pUnoCrsr->SetMark();
808 *pUnoCrsr->GetMark() = *pMark;
809 }
810 pUnoCrsr->Add(this);
811 }
812
813 /* -----------------04.03.99 09:02-------------------
814 *
815 * --------------------------------------------------*/
816 SwXTextCursor::SwXTextCursor(uno::Reference< XText > xParent,
817 SwUnoCrsr* pSourceCrsr, CursorType eSet) :
818 aLstnrCntnr( (util::XSortable*)this),
819 m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_CURSOR)),
820 xParentText(xParent),
821 pLastSortOptions(0),
822 eType(eSet),
823 mbRemoveUserEvent( false )
824 {
825 SwUnoCrsr* pUnoCrsr = pSourceCrsr->GetDoc()->CreateUnoCrsr(*pSourceCrsr->GetPoint(), sal_False);
826 if(pSourceCrsr->HasMark())
827 {
828 pUnoCrsr->SetMark();
829 *pUnoCrsr->GetMark() = *pSourceCrsr->GetMark();
830 }
831 pUnoCrsr->Add(this);
832 }
833
834 /*-- 09.12.98 14:19:20---------------------------------------------------
835
836 -----------------------------------------------------------------------*/
837 SwXTextCursor::~SwXTextCursor()
838 {
839 vos::OGuard aGuard(Application::GetSolarMutex());
840
841 // --> FME 2006-03-07 #126177# A user event has been posted in order
842 // to delete the SwUnoCursor. Remove the user event if the SwXTextCursor
843 // is destroyed before the user event could be handled.
844 if ( mbRemoveUserEvent )
845 {
846 mbRemoveUserEvent = false;
847 Application::RemoveUserEvent( mnUserEventId );
848 }
849 // <--
850
851 SwUnoCrsr* pUnoCrsr = GetCrsr();
852 delete pUnoCrsr;
853 delete pLastSortOptions;
854 }
855 /*-- 09.12.98 14:19:18---------------------------------------------------
856
857 -----------------------------------------------------------------------*/
858 void SwXTextCursor::DeleteAndInsert(const String& rText,
859 const bool bForceExpandHints)
860 {
861 SwUnoCrsr* pUnoCrsr = GetCrsr();
862 if(pUnoCrsr)
863 {
864 // Start/EndAction
865 SwDoc* pDoc = pUnoCrsr->GetDoc();
866 UnoActionContext aAction(pDoc);
867 xub_StrLen nTxtLen = rText.Len();
868 pDoc->StartUndo(UNDO_INSERT, NULL);
869 SwCursor *_pStartCrsr = pUnoCrsr;
870 do
871 {
872 if(_pStartCrsr->HasMark())
873 {
874 pDoc->DeleteAndJoin(*_pStartCrsr);
875 }
876 if(nTxtLen)
877 {
878 const bool bSuccess(
879 SwUnoCursorHelper::DocInsertStringSplitCR(
880 *pDoc, *_pStartCrsr, rText, bForceExpandHints ) );
881 DBG_ASSERT( bSuccess, "Doc->Insert(Str) failed." );
882 (void) bSuccess;
883
884 SwXTextCursor::SelectPam(*pUnoCrsr, sal_True);
885 _pStartCrsr->Left(rText.Len(), CRSR_SKIP_CHARS, FALSE, FALSE);
886 }
887 } while( (_pStartCrsr=(SwCursor*)_pStartCrsr->GetNext()) != pUnoCrsr );
888 pDoc->EndUndo(UNDO_INSERT, NULL);
889 }
890 }
891
892
893 enum ForceIntoMetaMode { META_CHECK_BOTH, META_INIT_START, META_INIT_END };
894
895 sal_Bool lcl_ForceIntoMeta(SwPaM & rCursor,
896 uno::Reference<text::XText> const & xParentText,
897 const enum ForceIntoMetaMode eMode)
898 {
899 sal_Bool bRet( sal_True ); // means not forced in META_CHECK_BOTH
900 SwXMeta const * const pXMeta( dynamic_cast<SwXMeta*>(xParentText.get()) );
901 ASSERT(pXMeta, "no parent?");
902 if (!pXMeta)
903 throw uno::RuntimeException();
904 SwTxtNode * pTxtNode;
905 xub_StrLen nStart;
906 xub_StrLen nEnd;
907 const bool bSuccess( pXMeta->SetContentRange(pTxtNode, nStart, nEnd) );
908 ASSERT(bSuccess, "no pam?");
909 if (!bSuccess)
910 throw uno::RuntimeException();
911 // force the cursor back into the meta if it has moved outside
912 SwPosition start(*pTxtNode, nStart);
913 SwPosition end(*pTxtNode, nEnd);
914 switch (eMode)
915 {
916 case META_INIT_START:
917 *rCursor.GetPoint() = start;
918 break;
919 case META_INIT_END:
920 *rCursor.GetPoint() = end;
921 break;
922 case META_CHECK_BOTH:
923 if (*rCursor.Start() < start)
924 {
925 *rCursor.Start() = start;
926 bRet = sal_False;
927 }
928 if (*rCursor.End() > end)
929 {
930 *rCursor.End() = end;
931 bRet = sal_False;
932 }
933 break;
934 }
935 return bRet;
936 }
937
938 bool SwXTextCursor::IsAtEndOfMeta() const
939 {
940 if (CURSOR_META == eType)
941 {
942 SwUnoCrsr const * const pCursor( GetCrsr() );
943 SwXMeta const*const pXMeta( dynamic_cast<SwXMeta*>(xParentText.get()) );
944 ASSERT(pXMeta, "no meta?");
945 if (pCursor && pXMeta)
946 {
947 SwTxtNode * pTxtNode;
948 xub_StrLen nStart;
949 xub_StrLen nEnd;
950 const bool bSuccess(
951 pXMeta->SetContentRange(pTxtNode, nStart, nEnd) );
952 ASSERT(bSuccess, "no pam?");
953 if (bSuccess)
954 {
955 const SwPosition end(*pTxtNode, nEnd);
956 if ( (*pCursor->GetPoint() == end)
957 || (*pCursor->GetMark() == end))
958 {
959 return true;
960 }
961 }
962 }
963 }
964 return false;
965 }
966
967 /* -----------------------------10.03.00 18:02--------------------------------
968
969 ---------------------------------------------------------------------------*/
970 const uno::Sequence< sal_Int8 > & SwXTextCursor::getUnoTunnelId()
971 {
972 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
973 return aSeq;
974 }
975 /* -----------------------------10.03.00 18:04--------------------------------
976
977 ---------------------------------------------------------------------------*/
978 sal_Int64 SAL_CALL SwXTextCursor::getSomething( const uno::Sequence< sal_Int8 >& rId )
979 throw(uno::RuntimeException)
980 {
981 if( rId.getLength() == 16
982 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
983 rId.getConstArray(), 16 ) )
984 {
985 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
986 }
987 return OTextCursorHelper::getSomething(rId);
988 }
989
990 /*-- 09.12.98 14:18:12---------------------------------------------------
991
992 -----------------------------------------------------------------------*/
993 void SwXTextCursor::collapseToStart(void) throw( uno::RuntimeException )
994 {
995 vos::OGuard aGuard(Application::GetSolarMutex());
996 SwUnoCrsr* pUnoCrsr = GetCrsr();
997 if(pUnoCrsr)
998 {
999 if(pUnoCrsr->HasMark())
1000 {
1001 if(*pUnoCrsr->GetPoint() > *pUnoCrsr->GetMark())
1002 pUnoCrsr->Exchange();
1003 pUnoCrsr->DeleteMark();
1004 }
1005 }
1006 else
1007 {
1008 throw uno::RuntimeException();
1009 }
1010 }
1011 /*-- 09.12.98 14:18:14---------------------------------------------------
1012
1013 -----------------------------------------------------------------------*/
1014 void SwXTextCursor::collapseToEnd(void) throw( uno::RuntimeException )
1015 {
1016 vos::OGuard aGuard(Application::GetSolarMutex());
1017 SwUnoCrsr* pUnoCrsr = GetCrsr();
1018 if(pUnoCrsr)
1019 {
1020 if(pUnoCrsr->HasMark())
1021 {
1022 if(*pUnoCrsr->GetPoint() < *pUnoCrsr->GetMark())
1023 pUnoCrsr->Exchange();
1024 pUnoCrsr->DeleteMark();
1025 }
1026 }
1027 else
1028 {
1029 throw uno::RuntimeException();
1030 }
1031 }
1032 /*-- 09.12.98 14:18:41---------------------------------------------------
1033
1034 -----------------------------------------------------------------------*/
1035 sal_Bool SwXTextCursor::isCollapsed(void) throw( uno::RuntimeException )
1036 {
1037 vos::OGuard aGuard(Application::GetSolarMutex());
1038 sal_Bool bRet = sal_True;
1039 SwUnoCrsr* pUnoCrsr = GetCrsr();
1040 if(pUnoCrsr && pUnoCrsr->GetMark())
1041 {
1042 bRet = (*pUnoCrsr->GetPoint() == *pUnoCrsr->GetMark());
1043 }
1044 return bRet;
1045 }
1046 /*-- 09.12.98 14:18:42---------------------------------------------------
1047
1048 -----------------------------------------------------------------------*/
1049 sal_Bool SwXTextCursor::goLeft(sal_Int16 nCount, sal_Bool Expand) throw( uno::RuntimeException )
1050 {
1051 vos::OGuard aGuard(Application::GetSolarMutex());
1052 sal_Bool bRet = sal_False;
1053 SwUnoCrsr* pUnoCrsr = GetCrsr();
1054 if(pUnoCrsr)
1055 {
1056 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1057 bRet = pUnoCrsr->Left( nCount, CRSR_SKIP_CHARS, FALSE, FALSE);
1058 if (CURSOR_META == eType)
1059 {
1060 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH)
1061 && bRet;
1062 }
1063 }
1064 else
1065 {
1066 throw uno::RuntimeException();
1067 }
1068 return bRet;
1069 }
1070 /*-- 09.12.98 14:18:42---------------------------------------------------
1071
1072 -----------------------------------------------------------------------*/
1073 sal_Bool SwXTextCursor::goRight(sal_Int16 nCount, sal_Bool Expand) throw( uno::RuntimeException )
1074 {
1075 vos::OGuard aGuard(Application::GetSolarMutex());
1076 sal_Bool bRet = sal_False;
1077 SwUnoCrsr* pUnoCrsr = GetCrsr();
1078 if(pUnoCrsr)
1079 {
1080 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1081 bRet = pUnoCrsr->Right(nCount, CRSR_SKIP_CHARS, FALSE, FALSE);
1082 if (CURSOR_META == eType)
1083 {
1084 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH)
1085 && bRet;
1086 }
1087 }
1088 else
1089 {
1090 throw uno::RuntimeException();
1091 }
1092 return bRet;
1093 }
1094 /*-- 09.12.98 14:18:43---------------------------------------------------
1095
1096 -----------------------------------------------------------------------*/
1097 void SwXTextCursor::gotoStart(sal_Bool Expand) throw( uno::RuntimeException )
1098 {
1099 vos::OGuard aGuard(Application::GetSolarMutex());
1100 SwUnoCrsr* pUnoCrsr = GetCrsr();
1101 if(pUnoCrsr)
1102 {
1103 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1104 if(eType == CURSOR_BODY)
1105 {
1106 pUnoCrsr->Move( fnMoveBackward, fnGoDoc );
1107 //check, that the cursor is not in a table
1108 SwTableNode* pTblNode = pUnoCrsr->GetNode()->FindTableNode();
1109 SwCntntNode* pCont = 0;
1110 while( pTblNode )
1111 {
1112 pUnoCrsr->GetPoint()->nNode = *pTblNode->EndOfSectionNode();
1113 pCont = GetDoc()->GetNodes().GoNext(&pUnoCrsr->GetPoint()->nNode);
1114 pTblNode = pCont ? pCont->FindTableNode() : 0;
1115 }
1116 if(pCont)
1117 pUnoCrsr->GetPoint()->nContent.Assign(pCont, 0);
1118 const SwStartNode* pTmp = pUnoCrsr->GetNode()->StartOfSectionNode();
1119 if(pTmp->IsSectionNode())
1120 {
1121 SwSectionNode* pSectionStartNode = (SwSectionNode*)pTmp;
1122 if(pSectionStartNode->GetSection().IsHiddenFlag())
1123 {
1124 pCont = GetDoc()->GetNodes().GoNextSection(
1125 &pUnoCrsr->GetPoint()->nNode, sal_True, sal_False);
1126 if(pCont)
1127 pUnoCrsr->GetPoint()->nContent.Assign(pCont, 0);
1128 }
1129 }
1130 }
1131 else if(eType == CURSOR_FRAME ||
1132 eType == CURSOR_TBLTEXT ||
1133 eType == CURSOR_HEADER ||
1134 eType == CURSOR_FOOTER ||
1135 eType == CURSOR_FOOTNOTE||
1136 eType == CURSOR_REDLINE)
1137 {
1138 pUnoCrsr->MoveSection( fnSectionCurr, fnSectionStart);
1139 }
1140 else if (CURSOR_META == eType)
1141 {
1142 lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_INIT_START);
1143 }
1144 }
1145 else
1146 {
1147 throw uno::RuntimeException();
1148 }
1149 }
1150 /*-- 09.12.98 14:18:43---------------------------------------------------
1151
1152 -----------------------------------------------------------------------*/
1153 void SwXTextCursor::gotoEnd(sal_Bool Expand) throw( uno::RuntimeException )
1154 {
1155 vos::OGuard aGuard(Application::GetSolarMutex());
1156 SwUnoCrsr* pUnoCrsr = GetCrsr();
1157 if(pUnoCrsr)
1158 {
1159 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1160 if(eType == CURSOR_BODY)
1161 {
1162 pUnoCrsr->Move( fnMoveForward, fnGoDoc );
1163 }
1164 else if(eType == CURSOR_FRAME ||
1165 eType == CURSOR_TBLTEXT ||
1166 eType == CURSOR_HEADER ||
1167 eType == CURSOR_FOOTER ||
1168 eType == CURSOR_FOOTNOTE||
1169 eType == CURSOR_REDLINE)
1170 {
1171 pUnoCrsr->MoveSection( fnSectionCurr, fnSectionEnd);
1172 }
1173 else if (CURSOR_META == eType)
1174 {
1175 lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_INIT_END);
1176 }
1177 }
1178 else
1179 {
1180 throw uno::RuntimeException();
1181 }
1182 }
1183
1184 void SwXTextCursor::gotoRange(const uno::Reference< XTextRange > & xRange, sal_Bool bExpand )
1185 throw( uno::RuntimeException )
1186 {
1187 vos::OGuard aGuard(Application::GetSolarMutex());
1188 SwUnoCrsr* pOwnCursor = GetCrsr();
1189 if(!pOwnCursor || !xRange.is())
1190 {
1191 throw uno::RuntimeException();
1192 }
1193
1194 uno::Reference<lang::XUnoTunnel> xRangeTunnel( xRange, uno::UNO_QUERY);
1195 SwXTextRange* pRange = 0;
1196 OTextCursorHelper* pCursor = 0;
1197 if(xRangeTunnel.is())
1198 {
1199 pRange = reinterpret_cast< SwXTextRange * >(
1200 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( SwXTextRange::getUnoTunnelId()) ));
1201 pCursor = reinterpret_cast< OTextCursorHelper * >(
1202 sal::static_int_cast< sal_IntPtr >( xRangeTunnel->getSomething( OTextCursorHelper::getUnoTunnelId()) ));
1203 }
1204
1205 if (!pRange && !pCursor)
1206 {
1207 throw uno::RuntimeException();
1208 }
1209
1210 SwStartNodeType eSearchNodeType = SwNormalStartNode;
1211 switch(eType)
1212 {
1213 case CURSOR_FRAME: eSearchNodeType = SwFlyStartNode; break;
1214 case CURSOR_TBLTEXT: eSearchNodeType = SwTableBoxStartNode; break;
1215 case CURSOR_FOOTNOTE: eSearchNodeType = SwFootnoteStartNode; break;
1216 case CURSOR_HEADER: eSearchNodeType = SwHeaderStartNode; break;
1217 case CURSOR_FOOTER: eSearchNodeType = SwFooterStartNode; break;
1218 //case CURSOR_INVALID:
1219 //case CURSOR_BODY:
1220 default:
1221 ;
1222 }
1223 const SwStartNode* pOwnStartNode = pOwnCursor->GetNode()->
1224 FindSttNodeByType(eSearchNodeType);
1225
1226 const SwNode* pSrcNode = 0;
1227 if(pCursor && pCursor->GetPaM())
1228 {
1229 pSrcNode = pCursor->GetPaM()->GetNode();
1230 }
1231 else if(pRange && pRange->GetBookmark())
1232 {
1233 ::sw::mark::IMark const * const pBkmk = pRange->GetBookmark();
1234 pSrcNode = &pBkmk->GetMarkPos().nNode.GetNode();
1235 }
1236 const SwStartNode* pTmp = pSrcNode ? pSrcNode->FindSttNodeByType(eSearchNodeType) : 0;
1237
1238 //SectionNodes ueberspringen
1239 while(pTmp && pTmp->IsSectionNode())
1240 {
1241 pTmp = pTmp->StartOfSectionNode();
1242 }
1243 while(pOwnStartNode && pOwnStartNode->IsSectionNode())
1244 {
1245 pOwnStartNode = pOwnStartNode->StartOfSectionNode();
1246 }
1247 if(pOwnStartNode != pTmp)
1248 {
1249 throw uno::RuntimeException();
1250 }
1251
1252 if (CURSOR_META == eType)
1253 {
1254 const SwPosition & rPoint( (pRange)
1255 ? pRange->GetBookmark()->GetMarkPos()
1256 : *pCursor->GetPaM()->GetPoint() );
1257 const SwPosition & rMark ( (pRange)
1258 ? ((pRange->GetBookmark()->IsExpanded())
1259 ? pRange->GetBookmark()->GetOtherMarkPos() : rPoint)
1260 : *pCursor->GetPaM()->GetMark() );
1261 SwPaM aPam(rPoint, rMark);
1262 const bool bNotForced(
1263 lcl_ForceIntoMeta(aPam, xParentText, META_CHECK_BOTH) );
1264 if (!bNotForced)
1265 {
1266 throw uno::RuntimeException(
1267 C2U("gotoRange: parameter range not contained in nesting"
1268 " text content for which this cursor was created"),
1269 static_cast<text::XWordCursor*>(this));
1270 }
1271 }
1272
1273 //jetzt muss die Selektion erweitert werden
1274 if(bExpand)
1275 {
1276 // der Cursor soll alles einschliessen, was bisher von ihm und dem uebergebenen
1277 // Range eingeschlossen wurde
1278 SwPosition aOwnLeft(*pOwnCursor->GetPoint());
1279 SwPosition aOwnRight(pOwnCursor->HasMark() ? *pOwnCursor->GetMark() : aOwnLeft);
1280 if(aOwnRight < aOwnLeft)
1281 {
1282 SwPosition aTmp = aOwnLeft;
1283 aOwnLeft = aOwnRight;
1284 aOwnRight = aTmp;
1285 }
1286 SwPosition* pParamLeft;
1287 SwPosition* pParamRight;
1288 if(pCursor)
1289 {
1290 const SwPaM* pTmp2 = pCursor->GetPaM();
1291 pParamLeft = new SwPosition(*pTmp2->GetPoint());
1292 pParamRight = new SwPosition(pTmp2->HasMark() ? *pTmp2->GetMark() : *pParamLeft);
1293 }
1294 else
1295 {
1296 ::sw::mark::IMark const * const pBkmk = pRange->GetBookmark();
1297 pParamLeft = new SwPosition(pBkmk->GetMarkPos());
1298 pParamRight = new SwPosition(pBkmk->IsExpanded() ? pBkmk->GetOtherMarkPos() : *pParamLeft);
1299 }
1300 if(*pParamRight < *pParamLeft)
1301 {
1302 SwPosition* pTmp2 = pParamLeft;
1303 pParamLeft = pParamRight;
1304 pParamRight = pTmp2;
1305 }
1306 // jetzt sind vier SwPositions da, zwei davon werden gebraucht, also welche?
1307 if(aOwnRight > *pParamRight)
1308 *pOwnCursor->GetPoint() = aOwnRight;
1309 else
1310 *pOwnCursor->GetPoint() = *pParamRight;
1311 pOwnCursor->SetMark();
1312 if(aOwnLeft < *pParamLeft)
1313 *pOwnCursor->GetMark() = aOwnLeft;
1314 else
1315 *pOwnCursor->GetMark() = *pParamLeft;
1316 delete pParamLeft;
1317 delete pParamRight;
1318 }
1319 else
1320 {
1321 //der Cursor soll dem uebergebenen Range entsprechen
1322 if(pCursor)
1323 {
1324 const SwPaM* pTmp2 = pCursor->GetPaM();
1325 *pOwnCursor->GetPoint() = *pTmp2->GetPoint();
1326 if(pTmp2->HasMark())
1327 {
1328 pOwnCursor->SetMark();
1329 *pOwnCursor->GetMark() = *pTmp2->GetMark();
1330 }
1331 else
1332 pOwnCursor->DeleteMark();
1333 }
1334 else
1335 {
1336 ::sw::mark::IMark const * const pBkmk = pRange->GetBookmark();
1337 *pOwnCursor->GetPoint() = pBkmk->GetMarkPos();
1338 if(pBkmk->IsExpanded())
1339 {
1340 pOwnCursor->SetMark();
1341 *pOwnCursor->GetMark() = pBkmk->GetOtherMarkPos();
1342 }
1343 else
1344 pOwnCursor->DeleteMark();
1345 }
1346 }
1347 }
1348
1349 /*-- 09.12.98 14:18:44---------------------------------------------------
1350
1351 -----------------------------------------------------------------------*/
1352 sal_Bool SwXTextCursor::isStartOfWord(void) throw( uno::RuntimeException )
1353 {
1354 vos::OGuard aGuard(Application::GetSolarMutex());
1355 sal_Bool bRet = sal_False;
1356 SwUnoCrsr* pUnoCrsr = GetCrsr();
1357 if(pUnoCrsr)
1358 {
1359 bRet = pUnoCrsr->IsStartWordWT( i18n::WordType::DICTIONARY_WORD );
1360 }
1361 else
1362 {
1363 throw uno::RuntimeException();
1364 }
1365 return bRet;
1366 }
1367 /*-- 09.12.98 14:18:44---------------------------------------------------
1368
1369 -----------------------------------------------------------------------*/
1370 sal_Bool SwXTextCursor::isEndOfWord(void) throw( uno::RuntimeException )
1371 {
1372 vos::OGuard aGuard(Application::GetSolarMutex());
1373 sal_Bool bRet = sal_False;
1374 SwUnoCrsr* pUnoCrsr = GetCrsr();
1375 if(pUnoCrsr)
1376 {
1377 bRet = pUnoCrsr->IsEndWordWT( i18n::WordType::DICTIONARY_WORD );
1378 }
1379 else
1380 {
1381 throw uno::RuntimeException();
1382 }
1383 return bRet;
1384 }
1385 /*-- 09.12.98 14:18:44---------------------------------------------------
1386
1387 -----------------------------------------------------------------------*/
1388 sal_Bool SwXTextCursor::gotoNextWord(sal_Bool Expand) throw( uno::RuntimeException )
1389 {
1390 vos::OGuard aGuard(Application::GetSolarMutex());
1391 //Probleme gibt's noch mit einem Absatzanfang, an dem kein Wort beginnt.
1392
1393 SwUnoCrsr* pUnoCrsr = GetCrsr();
1394
1395 sal_Bool bRet = sal_False;
1396 if(pUnoCrsr)
1397 {
1398 // remember old position to check if cursor has moved
1399 // since the called functions are sometimes a bit unreliable
1400 // in specific cases...
1401 SwPosition *pPoint = pUnoCrsr->GetPoint();
1402 SwNode *pOldNode = &pPoint->nNode.GetNode();
1403 xub_StrLen nOldIndex = pPoint->nContent.GetIndex();
1404
1405 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1406 //Absatzende?
1407 if(pUnoCrsr->GetCntntNode() &&
1408 pPoint->nContent == pUnoCrsr->GetCntntNode()->Len())
1409 {
1410 pUnoCrsr->Right(1, CRSR_SKIP_CHARS, FALSE, FALSE);
1411 }
1412 else
1413 {
1414 sal_Bool bTmp = pUnoCrsr->GoNextWordWT( i18n::WordType::DICTIONARY_WORD );
1415 //if there is no next word within the current paragraph try to go to the start of the next paragraph
1416 if(!bTmp)
1417 pUnoCrsr->MovePara(fnParaNext, fnParaStart);
1418 }
1419
1420 // return true if cursor has moved
1421 bRet = &pPoint->nNode.GetNode() != pOldNode ||
1422 pPoint->nContent.GetIndex() != nOldIndex;
1423 if (bRet && (CURSOR_META == eType))
1424 {
1425 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH);
1426 }
1427 }
1428 else
1429 {
1430 throw uno::RuntimeException();
1431 }
1432
1433 return bRet;
1434 }
1435 /*-- 09.12.98 14:18:45---------------------------------------------------
1436
1437 -----------------------------------------------------------------------*/
1438 sal_Bool SwXTextCursor::gotoPreviousWord(sal_Bool Expand) throw( uno::RuntimeException )
1439 {
1440 vos::OGuard aGuard(Application::GetSolarMutex());
1441 // hier machen Leerzeichen am Absatzanfang Probleme
1442 SwUnoCrsr* pUnoCrsr = GetCrsr();
1443
1444 sal_Bool bRet = sal_False;
1445 if(pUnoCrsr)
1446 {
1447 SwPosition *pPoint = pUnoCrsr->GetPoint();
1448 SwNode *pOldNode = &pPoint->nNode.GetNode();
1449 xub_StrLen nOldIndex = pPoint->nContent.GetIndex();
1450
1451 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1452 //Absatzanfang ?
1453 if(pPoint->nContent == 0)
1454 {
1455 pUnoCrsr->Left(1, CRSR_SKIP_CHARS, FALSE, FALSE);
1456 }
1457 else
1458 {
1459 pUnoCrsr->GoPrevWordWT( i18n::WordType::DICTIONARY_WORD );
1460 if(pPoint->nContent == 0)
1461 pUnoCrsr->Left(1, CRSR_SKIP_CHARS, FALSE, FALSE);
1462 }
1463
1464 // return true if cursor has moved
1465 bRet = &pPoint->nNode.GetNode() != pOldNode ||
1466 pPoint->nContent.GetIndex() != nOldIndex;
1467 if (bRet && (CURSOR_META == eType))
1468 {
1469 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH);
1470 }
1471 }
1472 else
1473 {
1474 throw uno::RuntimeException();
1475 }
1476
1477 return bRet;
1478 }
1479 /*-- 09.12.98 14:18:45---------------------------------------------------
1480
1481 -----------------------------------------------------------------------*/
1482 sal_Bool SwXTextCursor::gotoEndOfWord(sal_Bool Expand) throw( uno::RuntimeException )
1483 {
1484 vos::OGuard aGuard(Application::GetSolarMutex());
1485 SwUnoCrsr* pUnoCrsr = GetCrsr();
1486
1487 sal_Bool bRet = sal_False;
1488 if(pUnoCrsr)
1489 {
1490 SwPosition *pPoint = pUnoCrsr->GetPoint();
1491 SwNode &rOldNode = pPoint->nNode.GetNode();
1492 xub_StrLen nOldIndex = pPoint->nContent.GetIndex();
1493
1494 sal_Int16 nWordType = i18n::WordType::DICTIONARY_WORD;
1495 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1496 if(!pUnoCrsr->IsEndWordWT( nWordType ))
1497 pUnoCrsr->GoEndWordWT( nWordType );
1498
1499 // restore old cursor if we are not at the end of a word by now
1500 // otherwise use current one
1501 bRet = pUnoCrsr->IsEndWordWT( nWordType );
1502 if (!bRet)
1503 {
1504 pPoint->nNode = rOldNode;
1505 pPoint->nContent = nOldIndex;
1506 }
1507 else if (CURSOR_META == eType)
1508 {
1509 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH);
1510 }
1511 }
1512 else
1513 {
1514 throw uno::RuntimeException();
1515 }
1516
1517 return bRet;
1518 }
1519 /*-- 09.12.98 14:18:46---------------------------------------------------
1520
1521 -----------------------------------------------------------------------*/
1522 sal_Bool SwXTextCursor::gotoStartOfWord(sal_Bool Expand) throw( uno::RuntimeException )
1523 {
1524 vos::OGuard aGuard(Application::GetSolarMutex());
1525 SwUnoCrsr* pUnoCrsr = GetCrsr();
1526
1527 sal_Bool bRet = sal_False;
1528 if(pUnoCrsr)
1529 {
1530 SwPosition *pPoint = pUnoCrsr->GetPoint();
1531 SwNode &rOldNode = pPoint->nNode.GetNode();
1532 xub_StrLen nOldIndex = pPoint->nContent.GetIndex();
1533
1534 sal_Int16 nWordType = i18n::WordType::DICTIONARY_WORD;
1535 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1536 if(!pUnoCrsr->IsStartWordWT( nWordType ))
1537 pUnoCrsr->GoStartWordWT( nWordType );
1538
1539 // restore old cursor if we are not at the start of a word by now
1540 // otherwise use current one
1541 bRet = pUnoCrsr->IsStartWordWT( nWordType );
1542 if (!bRet)
1543 {
1544 pPoint->nNode = rOldNode;
1545 pPoint->nContent = nOldIndex;
1546 }
1547 else if (CURSOR_META == eType)
1548 {
1549 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH);
1550 }
1551 }
1552 else
1553 {
1554 throw uno::RuntimeException();
1555 }
1556
1557 return bRet;
1558 }
1559 /*-- 09.12.98 14:18:46---------------------------------------------------
1560
1561 -----------------------------------------------------------------------*/
1562 sal_Bool SwXTextCursor::isStartOfSentence(void) throw( uno::RuntimeException )
1563 {
1564 vos::OGuard aGuard(Application::GetSolarMutex());
1565 sal_Bool bRet = sal_False;
1566 SwUnoCrsr* pUnoCrsr = GetCrsr();
1567 if(pUnoCrsr)
1568 {
1569 // start of paragraph?
1570 bRet = pUnoCrsr->GetPoint()->nContent == 0;
1571 // with mark ->no sentence start
1572 // (check if cursor is no selection, i.e. it does not have
1573 // a mark or else point and mark are identical)
1574 if(!bRet && (!pUnoCrsr->HasMark() ||
1575 *pUnoCrsr->GetPoint() == *pUnoCrsr->GetMark()))
1576 {
1577 SwCursor aCrsr(*pUnoCrsr->GetPoint(),0,false);
1578 SwPosition aOrigPos = *aCrsr.GetPoint();
1579 aCrsr.GoSentence(SwCursor::START_SENT );
1580 bRet = aOrigPos == *aCrsr.GetPoint();
1581 }
1582 }
1583 else
1584 throw uno::RuntimeException();
1585 return bRet;
1586 }
1587 /*-- 09.12.98 14:18:47---------------------------------------------------
1588
1589 -----------------------------------------------------------------------*/
1590 sal_Bool SwXTextCursor::isEndOfSentence(void) throw( uno::RuntimeException )
1591 {
1592 vos::OGuard aGuard(Application::GetSolarMutex());
1593 sal_Bool bRet = sal_False;
1594 SwUnoCrsr* pUnoCrsr = GetCrsr();
1595 if(pUnoCrsr)
1596 {
1597 //end of paragraph?
1598 bRet = pUnoCrsr->GetCntntNode() &&
1599 pUnoCrsr->GetPoint()->nContent == pUnoCrsr->GetCntntNode()->Len();
1600 // with mark->no sentence end
1601 // (check if cursor is no selection, i.e. it does not have
1602 // a mark or else point and mark are identical)
1603 if(!bRet && (!pUnoCrsr->HasMark() ||
1604 *pUnoCrsr->GetPoint() == *pUnoCrsr->GetMark()))
1605 {
1606 SwCursor aCrsr(*pUnoCrsr->GetPoint(),0,false);
1607 SwPosition aOrigPos = *aCrsr.GetPoint();
1608 aCrsr.GoSentence(SwCursor::END_SENT );
1609 bRet = aOrigPos == *aCrsr.GetPoint();
1610 }
1611 }
1612 else
1613 throw uno::RuntimeException();
1614 return bRet;
1615 }
1616 /*-- 09.12.98 14:18:47---------------------------------------------------
1617
1618 -----------------------------------------------------------------------*/
1619 sal_Bool SwXTextCursor::gotoNextSentence(sal_Bool Expand) throw( uno::RuntimeException )
1620 {
1621 vos::OGuard aGuard(Application::GetSolarMutex());
1622 sal_Bool bRet = sal_False;
1623 SwUnoCrsr* pUnoCrsr = GetCrsr();
1624 if(pUnoCrsr)
1625 {
1626 BOOL bWasEOS = isEndOfSentence();
1627 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1628 bRet = pUnoCrsr->GoSentence(SwCursor::NEXT_SENT);
1629 if(!bRet)
1630 bRet = pUnoCrsr->MovePara(fnParaNext, fnParaStart);
1631
1632 // if at the end of the sentence (i.e. at the space after the '.')
1633 // advance to next word in order for GoSentence to work properly
1634 // next time and have isStartOfSentence return true after this call
1635 if (!pUnoCrsr->IsStartWord())
1636 {
1637 BOOL bNextWord = pUnoCrsr->GoNextWord();
1638 if (bWasEOS && !bNextWord)
1639 bRet = sal_False;
1640 }
1641 if (CURSOR_META == eType)
1642 {
1643 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH)
1644 && bRet;
1645 }
1646 }
1647 else
1648 throw uno::RuntimeException();
1649 return bRet;
1650 }
1651 /*-- 09.12.98 14:18:47---------------------------------------------------
1652
1653 -----------------------------------------------------------------------*/
1654 sal_Bool SwXTextCursor::gotoPreviousSentence(sal_Bool Expand) throw( uno::RuntimeException )
1655 {
1656 vos::OGuard aGuard(Application::GetSolarMutex());
1657 sal_Bool bRet = sal_False;
1658 SwUnoCrsr* pUnoCrsr = GetCrsr();
1659 if(pUnoCrsr)
1660 {
1661 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1662 bRet = pUnoCrsr->GoSentence(SwCursor::PREV_SENT);
1663 if(!bRet)
1664 {
1665 if(0 != (bRet = pUnoCrsr->MovePara(fnParaPrev, fnParaStart)))
1666 {
1667 pUnoCrsr->MovePara(fnParaCurr, fnParaEnd);
1668 //at the end of a paragraph move to the sentence end again
1669 //
1670 pUnoCrsr->GoSentence(SwCursor::PREV_SENT);
1671 }
1672 }
1673 if (CURSOR_META == eType)
1674 {
1675 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH)
1676 && bRet;
1677 }
1678 }
1679 else
1680 throw uno::RuntimeException();
1681 return bRet;
1682 }
1683 /* -----------------15.10.99 08:24-------------------
1684
1685 --------------------------------------------------*/
1686 sal_Bool SwXTextCursor::gotoStartOfSentence(sal_Bool Expand) throw( uno::RuntimeException )
1687 {
1688 vos::OGuard aGuard(Application::GetSolarMutex());
1689 sal_Bool bRet = sal_False;
1690 SwUnoCrsr* pUnoCrsr = GetCrsr();
1691 if(pUnoCrsr)
1692 {
1693 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1694 // if we're at the para start then we wont move
1695 // but bRet is also true if GoSentence failed but
1696 // the start of the sentence is reached
1697 bRet = SwUnoCursorHelper::IsStartOfPara(*pUnoCrsr)
1698 || pUnoCrsr->GoSentence(SwCursor::START_SENT) ||
1699 SwUnoCursorHelper::IsStartOfPara(*pUnoCrsr);
1700 if (CURSOR_META == eType)
1701 {
1702 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH)
1703 && bRet;
1704 }
1705 }
1706 else
1707 throw uno::RuntimeException();
1708 return bRet;
1709 }
1710 /* -----------------15.10.99 08:24-------------------
1711
1712 --------------------------------------------------*/
1713 sal_Bool SwXTextCursor::gotoEndOfSentence(sal_Bool Expand) throw( uno::RuntimeException )
1714 {
1715 vos::OGuard aGuard(Application::GetSolarMutex());
1716 sal_Bool bRet = sal_False;
1717 SwUnoCrsr* pUnoCrsr = GetCrsr();
1718 if(pUnoCrsr)
1719 {
1720 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1721 // bRet is true if GoSentence() succeeded or if the
1722 // MovePara() succeeded while the end of the para is
1723 // not reached already
1724 sal_Bool bAlreadyParaEnd = SwUnoCursorHelper::IsEndOfPara(*pUnoCrsr);
1725 bRet = !bAlreadyParaEnd &&
1726 (pUnoCrsr->GoSentence(SwCursor::END_SENT) ||
1727 pUnoCrsr->MovePara(fnParaCurr, fnParaEnd));
1728 if (CURSOR_META == eType)
1729 {
1730 bRet = lcl_ForceIntoMeta(*pUnoCrsr, xParentText, META_CHECK_BOTH)
1731 && bRet;
1732 }
1733 }
1734 else
1735 throw uno::RuntimeException();
1736 return bRet;
1737 }
1738
1739 /*-- 09.12.98 14:18:48---------------------------------------------------
1740
1741 -----------------------------------------------------------------------*/
1742 sal_Bool SwXTextCursor::isStartOfParagraph(void) throw( uno::RuntimeException )
1743 {
1744 vos::OGuard aGuard(Application::GetSolarMutex());
1745 sal_Bool bRet = sal_False;
1746 SwUnoCrsr* pUnoCrsr = GetCrsr();
1747 if(pUnoCrsr)
1748 bRet = SwUnoCursorHelper::IsStartOfPara(*pUnoCrsr);
1749 else
1750 throw uno::RuntimeException();
1751 return bRet;
1752 }
1753 /*-- 09.12.98 14:18:48---------------------------------------------------
1754
1755 -----------------------------------------------------------------------*/
1756 sal_Bool SwXTextCursor::isEndOfParagraph(void) throw( uno::RuntimeException )
1757 {
1758 vos::OGuard aGuard(Application::GetSolarMutex());
1759 sal_Bool bRet = sal_False;
1760 SwUnoCrsr* pUnoCrsr = GetCrsr();
1761 if(pUnoCrsr)
1762 bRet = SwUnoCursorHelper::IsEndOfPara(*pUnoCrsr);
1763 else
1764 throw uno::RuntimeException();
1765 return bRet;
1766 }
1767 /*-- 09.12.98 14:18:49---------------------------------------------------
1768
1769 -----------------------------------------------------------------------*/
1770 sal_Bool SwXTextCursor::gotoStartOfParagraph(sal_Bool Expand) throw( uno::RuntimeException )
1771 {
1772 vos::OGuard aGuard(Application::GetSolarMutex());
1773 sal_Bool bRet = sal_False;
1774 if (CURSOR_META == eType)
1775 return bRet;
1776 SwUnoCrsr* pUnoCrsr = GetCrsr();
1777 if(pUnoCrsr )
1778 {
1779 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1780 bRet = SwUnoCursorHelper::IsStartOfPara(*pUnoCrsr);
1781 if(!bRet)
1782 bRet = pUnoCrsr->MovePara(fnParaCurr, fnParaStart);
1783 }
1784 else
1785 throw uno::RuntimeException();
1786
1787 // since MovePara(fnParaCurr, fnParaStart) only returns false
1788 // if we were already at the start of the paragraph this function
1789 // should always complete successfully.
1790 DBG_ASSERT( bRet, "gotoStartOfParagraph failed" );
1791 return bRet;
1792 }
1793 /*-- 09.12.98 14:18:49---------------------------------------------------
1794
1795 -----------------------------------------------------------------------*/
1796 sal_Bool SwXTextCursor::gotoEndOfParagraph(sal_Bool Expand) throw( uno::RuntimeException )
1797 {
1798 vos::OGuard aGuard(Application::GetSolarMutex());
1799 sal_Bool bRet = sal_False;
1800 if (CURSOR_META == eType)
1801 return bRet;
1802 SwUnoCrsr* pUnoCrsr = GetCrsr();
1803 if(pUnoCrsr)
1804 {
1805 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1806 bRet = SwUnoCursorHelper::IsEndOfPara(*pUnoCrsr);
1807 if(!bRet)
1808 bRet = pUnoCrsr->MovePara(fnParaCurr, fnParaEnd);
1809 }
1810 else
1811 throw uno::RuntimeException();
1812
1813 // since MovePara(fnParaCurr, fnParaEnd) only returns false
1814 // if we were already at the end of the paragraph this function
1815 // should always complete successfully.
1816 DBG_ASSERT( bRet, "gotoEndOfParagraph failed" );
1817 return bRet;
1818 }
1819 /*-- 09.12.98 14:18:50---------------------------------------------------
1820
1821 -----------------------------------------------------------------------*/
1822 sal_Bool SwXTextCursor::gotoNextParagraph(sal_Bool Expand) throw( uno::RuntimeException )
1823 {
1824 vos::OGuard aGuard(Application::GetSolarMutex());
1825 sal_Bool bRet = sal_False;
1826 if (CURSOR_META == eType)
1827 return bRet;
1828 SwUnoCrsr* pUnoCrsr = GetCrsr();
1829 if(pUnoCrsr)
1830 {
1831 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1832 bRet = pUnoCrsr->MovePara(fnParaNext, fnParaStart);
1833 }
1834 else
1835 throw uno::RuntimeException();
1836 return bRet;
1837 }
1838 /*-- 09.12.98 14:18:50---------------------------------------------------
1839
1840 -----------------------------------------------------------------------*/
1841 sal_Bool SwXTextCursor::gotoPreviousParagraph(sal_Bool Expand) throw( uno::RuntimeException )
1842 {
1843 vos::OGuard aGuard(Application::GetSolarMutex());
1844 sal_Bool bRet = sal_False;
1845 if (CURSOR_META == eType)
1846 return bRet;
1847 SwUnoCrsr* pUnoCrsr = GetCrsr();
1848 if(pUnoCrsr)
1849 {
1850 SwXTextCursor::SelectPam(*pUnoCrsr, Expand);
1851 bRet = pUnoCrsr->MovePara(fnParaPrev, fnParaStart);
1852 }
1853 else
1854 throw uno::RuntimeException();
1855 return bRet;
1856 }
1857 /*-- 09.12.98 14:18:50---------------------------------------------------
1858
1859 -----------------------------------------------------------------------*/
1860 uno::Reference< XText > SwXTextCursor::getText(void) throw( uno::RuntimeException )
1861 {
1862 return xParentText;
1863 }
1864 /*-- 09.12.98 14:18:50---------------------------------------------------
1865
1866 -----------------------------------------------------------------------*/
1867 uno::Reference< XTextRange > SwXTextCursor::getStart(void) throw( uno::RuntimeException )
1868 {
1869 vos::OGuard aGuard(Application::GetSolarMutex());
1870 uno::Reference< XTextRange > xRet;
1871 SwUnoCrsr* pUnoCrsr = ((SwXTextCursor*)this)->GetCrsr();
1872 if( pUnoCrsr)
1873 {
1874 SwPaM aPam(*pUnoCrsr->Start());
1875 uno::Reference< XText > xParent = getText();
1876 if (CURSOR_META == eType)
1877 {
1878 // return cursor to prevent modifying SwXTextRange for META
1879 SwXTextCursor * const pCursor(
1880 new SwXTextCursor(xParent, *pUnoCrsr->GetPoint(),
1881 CURSOR_META, pUnoCrsr->GetDoc()) );
1882 pCursor->gotoStart(sal_False);
1883 xRet = static_cast<text::XWordCursor*>(pCursor);
1884 }
1885 else
1886 {
1887 xRet = new SwXTextRange(aPam, xParent);
1888 }
1889 }
1890 else
1891 throw uno::RuntimeException();
1892 return xRet;
1893 }
1894 /*-- 09.12.98 14:18:51---------------------------------------------------
1895
1896 -----------------------------------------------------------------------*/
1897 uno::Reference< XTextRange > SwXTextCursor::getEnd(void) throw( uno::RuntimeException )
1898 {
1899 vos::OGuard aGuard(Application::GetSolarMutex());
1900 uno::Reference< XTextRange > xRet;
1901 SwUnoCrsr* pUnoCrsr = ((SwXTextCursor*)this)->GetCrsr();
1902 if( pUnoCrsr)
1903 {
1904 SwPaM aPam(*pUnoCrsr->End());
1905 uno::Reference< XText > xParent = getText();
1906 if (CURSOR_META == eType)
1907 {
1908 // return cursor to prevent modifying SwXTextRange for META
1909 SwXTextCursor * const pCursor(
1910 new SwXTextCursor(xParent, *pUnoCrsr->GetPoint(),
1911 CURSOR_META, pUnoCrsr->GetDoc()) );
1912 pCursor->gotoEnd(sal_False);
1913 xRet = static_cast<text::XWordCursor*>(pCursor);
1914 }
1915 else
1916 {
1917 xRet = new SwXTextRange(aPam, xParent);
1918 }
1919 }
1920 else
1921 throw uno::RuntimeException();
1922 return xRet;
1923 }
1924 /*-- 09.12.98 14:18:51---------------------------------------------------
1925
1926 -----------------------------------------------------------------------*/
1927 OUString SwXTextCursor::getString(void) throw( uno::RuntimeException )
1928 {
1929 vos::OGuard aGuard(Application::GetSolarMutex());
1930 OUString aTxt;
1931 SwUnoCrsr* pUnoCrsr = ((SwXTextCursor*)this)->GetCrsr();
1932 if( pUnoCrsr)
1933 {
1934 /* if( pUnoCrsr->GetPoint()->nNode.GetIndex() ==
1935 pUnoCrsr->GetMark()->nNode.GetIndex() )
1936 {
1937 SwTxtNode* pTxtNd = pUnoCrsr->GetNode()->GetTxtNode();
1938 if( pTxtNd )
1939 {
1940 sal_uInt16 nStt = pUnoCrsr->Start()->nContent.GetIndex();
1941 aTxt = pTxtNd->GetExpandTxt( nStt,
1942 pUnoCrsr->End()->nContent.GetIndex() - nStt );
1943 }
1944 }
1945 else
1946 */ {
1947 //Text ueber mehrere Absaetze
1948 SwXTextCursor::getTextFromPam(*pUnoCrsr, aTxt);
1949 }
1950 }
1951 else
1952 throw uno::RuntimeException();
1953 return aTxt;
1954 }
1955 /*-- 09.12.98 14:18:52---------------------------------------------------
1956
1957 -----------------------------------------------------------------------*/
1958 void SwXTextCursor::setString(const OUString& aString) throw( uno::RuntimeException )
1959 {
1960 vos::OGuard aGuard(Application::GetSolarMutex());
1961 SwUnoCrsr* pUnoCrsr = GetCrsr();
1962 if(!pUnoCrsr)
1963 throw uno::RuntimeException();
1964
1965 const bool bForceExpandHints( (CURSOR_META != eType)
1966 ? false
1967 : dynamic_cast<SwXMeta*>(xParentText.get())->CheckForOwnMemberMeta(
1968 0, GetPaM(), true) );
1969 DeleteAndInsert(aString, bForceExpandHints);
1970 }
1971 /* -----------------------------03.05.00 12:56--------------------------------
1972
1973 ---------------------------------------------------------------------------*/
1974 Any SwXTextCursor::GetPropertyValue(
1975 SwPaM& rPaM, const SfxItemPropertySet& rPropSet,
1976 const OUString& rPropertyName)
1977 throw( UnknownPropertyException, WrappedTargetException, RuntimeException)
1978 {
1979 Any aAny;
1980 const SfxItemPropertySimpleEntry* pEntry = rPropSet.getPropertyMap()->getByName(
1981 rPropertyName);
1982 if(pEntry)
1983 {
1984 PropertyState eTemp;
1985 BOOL bDone = SwUnoCursorHelper::getCrsrPropertyValue( *pEntry, rPaM, &aAny, eTemp );
1986 if(!bDone)
1987 {
1988 SfxItemSet aSet(rPaM.GetDoc()->GetAttrPool(),
1989 RES_CHRATR_BEGIN, RES_FRMATR_END -1,
1990 RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER,
1991 RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER,
1992 0L);
1993 SwXTextCursor::GetCrsrAttr(rPaM, aSet);
1994
1995 rPropSet.getPropertyValue(*pEntry, aSet, aAny);
1996 }
1997 }
1998 else
1999 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( 0 ) );
2000
2001 return aAny;
2002 }
2003 /* -----------------------------03.05.00 12:57--------------------------------
2004
2005 ---------------------------------------------------------------------------*/
2006 void SwXTextCursor::SetPropertyValue(
2007 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, const OUString& rPropertyName,
2008 const Any& aValue, USHORT nAttrMode)
2009 throw (UnknownPropertyException, PropertyVetoException,
2010 IllegalArgumentException, WrappedTargetException, RuntimeException)
2011 {
2012 SwDoc* pDoc = rPaM.GetDoc();
2013 const SfxItemPropertySimpleEntry* pEntry = rPropSet.getPropertyMap()->getByName(rPropertyName);
2014 if(pEntry)
2015 {
2016 if( pEntry->nFlags & PropertyAttribute::READONLY)
2017 throw PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( 0 ) );
2018
2019 SfxItemSet aItemSet( pDoc->GetAttrPool(), pEntry->nWID, pEntry->nWID );
2020 SwXTextCursor::GetCrsrAttr( rPaM, aItemSet );
2021
2022 if(!lcl_setCrsrPropertyValue( pEntry, rPaM, aItemSet, aValue ))
2023 rPropSet.setPropertyValue(*pEntry, aValue, aItemSet );
2024 SwXTextCursor::SetCrsrAttr(rPaM, aItemSet, nAttrMode );
2025 }
2026 else
2027 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( 0 ) );
2028 }
2029 /* -----------------------------03.05.00 13:16--------------------------------
2030
2031 ---------------------------------------------------------------------------*/
2032 Sequence< PropertyState > SwXTextCursor::GetPropertyStates(
2033 SwPaM& rPaM, const SfxItemPropertySet& rPropSet,
2034 const Sequence< OUString >& PropertyNames,
2035 SwGetPropertyStatesCaller eCaller )
2036 throw(UnknownPropertyException, RuntimeException)
2037 {
2038 const OUString* pNames = PropertyNames.getConstArray();
2039 Sequence< PropertyState > aRet ( PropertyNames.getLength() );
2040 PropertyState* pStates = aRet.getArray();
2041
2042 SfxItemSet *pSet = 0, *pSetParent = 0;
2043 const SfxItemPropertyMap *pMap = rPropSet.getPropertyMap();
2044 for( INT32 i = 0, nEnd = PropertyNames.getLength(); i < nEnd; i++ )
2045 {
2046 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( pNames[i] );
2047 if(!pEntry)
2048 {
2049 if(pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)) ||
2050 pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT)))
2051 {
2052 pStates[i] = beans::PropertyState_DEFAULT_VALUE;
2053 continue;
2054 }
2055 else if( SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION_TOLERANT == eCaller )
2056 {
2057 //this values marks the element as unknown property
2058 pStates[i] = beans::PropertyState_MAKE_FIXED_SIZE;
2059 continue;
2060 }
2061 else
2062 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pNames[i], static_cast < cppu::OWeakObject * > ( 0 ) );
2063 }
2064 if ((eCaller == SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION || eCaller == SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION_TOLERANT) &&
2065 pEntry->nWID < FN_UNO_RANGE_BEGIN &&
2066 pEntry->nWID > FN_UNO_RANGE_END &&
2067 pEntry->nWID < RES_CHRATR_BEGIN &&
2068 pEntry->nWID > RES_TXTATR_END )
2069 pStates[i] = beans::PropertyState_DEFAULT_VALUE;
2070 else
2071 {
2072 if ( pEntry->nWID >= FN_UNO_RANGE_BEGIN &&
2073 pEntry->nWID <= FN_UNO_RANGE_END )
2074 SwUnoCursorHelper::getCrsrPropertyValue(*pEntry, rPaM, 0, pStates[i] );
2075 else
2076 {
2077 if( !pSet )
2078 {
2079 switch ( eCaller )
2080 {
2081 case SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION_TOLERANT:
2082 case SW_PROPERTY_STATE_CALLER_SWX_TEXT_PORTION:
2083 pSet = new SfxItemSet( rPaM.GetDoc()->GetAttrPool(),
2084 RES_CHRATR_BEGIN, RES_TXTATR_END );
2085 break;
2086 case SW_PROPERTY_STATE_CALLER_SINGLE_VALUE_ONLY:
2087 pSet = new SfxItemSet( rPaM.GetDoc()->GetAttrPool(),
2088 pEntry->nWID, pEntry->nWID );
2089 break;
2090 default:
2091 pSet = new SfxItemSet( rPaM.GetDoc()->GetAttrPool(),
2092 RES_CHRATR_BEGIN, RES_FRMATR_END - 1,
2093 RES_UNKNOWNATR_CONTAINER, RES_UNKNOWNATR_CONTAINER,
2094 RES_TXTATR_UNKNOWN_CONTAINER, RES_TXTATR_UNKNOWN_CONTAINER,
2095 0L );
2096 }
2097 // --> OD 2006-07-12 #i63870#
2098 SwXTextCursor::GetCrsrAttr( rPaM, *pSet );
2099 // <--
2100 }
2101
2102 if( pSet->Count() )
2103 pStates[i] = rPropSet.getPropertyState( *pEntry, *pSet );
2104 else
2105 pStates[i] = PropertyState_DEFAULT_VALUE;
2106
2107 //try again to find out if a value has been inherited
2108 if( beans::PropertyState_DIRECT_VALUE == pStates[i] )
2109 {
2110 if( !pSetParent )
2111 {
2112 pSetParent = pSet->Clone( FALSE );
2113 // --> OD 2006-07-12 #i63870#
2114 SwXTextCursor::GetCrsrAttr( rPaM, *pSetParent, TRUE, FALSE );
2115 // <--
2116 }
2117
2118 if( (pSetParent)->Count() )
2119 pStates[i] = rPropSet.getPropertyState( *pEntry, *pSetParent );
2120 else
2121 pStates[i] = PropertyState_DEFAULT_VALUE;
2122 }
2123 }
2124 }
2125 }
2126 delete pSet;
2127 delete pSetParent;
2128 return aRet;
2129 }
2130 /* -----------------------------03.05.00 13:17--------------------------------
2131
2132 ---------------------------------------------------------------------------*/
2133 PropertyState SwXTextCursor::GetPropertyState(
2134 SwPaM& rPaM, const SfxItemPropertySet& rPropSet, const OUString& rPropertyName)
2135 throw(UnknownPropertyException, RuntimeException)
2136 {
2137 Sequence < OUString > aStrings ( 1 );
2138 aStrings[0] = rPropertyName;
2139 Sequence < PropertyState > aSeq = GetPropertyStates( rPaM, rPropSet, aStrings, SW_PROPERTY_STATE_CALLER_SINGLE_VALUE_ONLY );
2140 return aSeq[0];
2141 }
2142 /* -----------------------------03.05.00 13:20--------------------------------
2143
2144 ---------------------------------------------------------------------------*/
2145 void lcl_SelectParaAndReset ( SwPaM &rPaM, SwDoc* pDoc, const SvUShortsSort* pWhichIds = 0 )
2146 {
2147 // if we are reseting paragraph attributes, we need to select the full paragraph first
2148 SwPosition aStart = *rPaM.Start();
2149 SwPosition aEnd = *rPaM.End();
2150 auto_ptr < SwUnoCrsr > pTemp ( pDoc->CreateUnoCrsr(aStart, FALSE) );
2151 if(!SwUnoCursorHelper::IsStartOfPara(*pTemp))
2152 pTemp->MovePara(fnParaCurr, fnParaStart);
2153 pTemp->SetMark();
2154 *pTemp->GetPoint() = aEnd;
2155 SwXTextCursor::SelectPam(*pTemp, sal_True);
2156 if(!SwUnoCursorHelper::IsEndOfPara(*pTemp))
2157 pTemp->MovePara(fnParaCurr, fnParaEnd);
2158 pDoc->ResetAttrs(*pTemp, sal_True, pWhichIds);
2159 }
2160
2161
2162 void SwXTextCursor::SetPropertyToDefault(
2163 SwPaM& rPaM, const SfxItemPropertySet& rPropSet,
2164 const OUString& rPropertyName)
2165 throw(UnknownPropertyException, RuntimeException)
2166 {
2167 NAMESPACE_VOS(OGuard) aGuard(Application::GetSolarMutex());
2168 SwDoc* pDoc = rPaM.GetDoc();
2169 const SfxItemPropertySimpleEntry* pEntry = rPropSet.getPropertyMap()->getByName( rPropertyName);
2170 if(pEntry)
2171 {
2172 if ( pEntry->nFlags & PropertyAttribute::READONLY)
2173 throw RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "setPropertyToDefault: property is read-only: " ) ) + rPropertyName, 0 );
2174 if(pEntry->nWID < RES_FRMATR_END)
2175 {
2176 SvUShortsSort aWhichIds;
2177 aWhichIds.Insert(pEntry->nWID);
2178 if(pEntry->nWID < RES_PARATR_BEGIN)
2179 pDoc->ResetAttrs(rPaM, sal_True, &aWhichIds);
2180 else
2181 lcl_SelectParaAndReset ( rPaM, pDoc, &aWhichIds );
2182 }
2183 else
2184 SwUnoCursorHelper::resetCrsrPropertyValue(*pEntry, rPaM);
2185 }
2186 else
2187 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( 0 ) );
2188 }
2189 /* -----------------------------03.05.00 13:19--------------------------------
2190
2191 ---------------------------------------------------------------------------*/
2192 Any SwXTextCursor::GetPropertyDefault(
2193 SwPaM& rPaM, const SfxItemPropertySet& rPropSet,
2194 const OUString& rPropertyName)
2195 throw( UnknownPropertyException, WrappedTargetException, RuntimeException)
2196 {
2197 Any aRet;
2198 SwDoc* pDoc = rPaM.GetDoc();
2199 const SfxItemPropertySimpleEntry* pEntry = rPropSet.getPropertyMap()->getByName( rPropertyName);
2200 if(pEntry)
2201 {
2202 if(pEntry->nWID < RES_FRMATR_END)
2203 {
2204 const SfxPoolItem& rDefItem = pDoc->GetAttrPool().GetDefaultItem(pEntry->nWID);
2205 rDefItem.QueryValue(aRet, pEntry->nMemberId);
2206 }
2207 }
2208 else
2209 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( 0 ) );
2210 return aRet;
2211 }
2212 /*-- 09.12.98 14:18:54---------------------------------------------------
2213
2214 -----------------------------------------------------------------------*/
2215 uno::Reference< beans::XPropertySetInfo > SwXTextCursor::getPropertySetInfo(void) throw( uno::RuntimeException )
2216 {
2217 static uno::Reference< beans::XPropertySetInfo > xRef;
2218 if(!xRef.is())
2219 {
2220 static SfxItemPropertyMapEntry aCrsrExtMap_Impl[] =
2221 {
2222 { SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT), FN_SKIP_HIDDEN_TEXT, &::getBooleanCppuType(), PROPERTY_NONE, 0},
2223 { SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT), FN_SKIP_PROTECTED_TEXT, &::getBooleanCppuType(), PROPERTY_NONE, 0},
2224 {0,0,0,0,0,0}
2225 };
2226 uno::Reference< beans::XPropertySetInfo > xInfo = m_pPropSet->getPropertySetInfo();
2227 // PropertySetInfo verlaengern!
2228 const uno::Sequence<beans::Property> aPropSeq = xInfo->getProperties();
2229 xRef = new SfxExtItemPropertySetInfo(
2230 aCrsrExtMap_Impl,
2231 aPropSeq );
2232 }
2233 return xRef;
2234 }
2235 /*-- 09.12.98 14:18:54---------------------------------------------------
2236
2237 -----------------------------------------------------------------------*/
2238 void SwXTextCursor::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue)
2239 throw( beans::UnknownPropertyException, beans::PropertyVetoException,
2240 lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
2241 {
2242 vos::OGuard aGuard(Application::GetSolarMutex());
2243 SwUnoCrsr* pUnoCrsr = GetCrsr();
2244 if(pUnoCrsr)
2245 {
2246 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)))
2247 {
2248 sal_Bool bSet = *(sal_Bool*)aValue.getValue();
2249 pUnoCrsr->SetSkipOverHiddenSections(bSet);
2250 }
2251 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT)))
2252 {
2253 sal_Bool bSet = *(sal_Bool*)aValue.getValue();
2254 pUnoCrsr->SetSkipOverProtectSections(bSet);
2255 }
2256 else
2257 SetPropertyValue(*pUnoCrsr, *m_pPropSet, rPropertyName, aValue);
2258 }
2259 else
2260 throw uno::RuntimeException();
2261
2262 }
2263 /*-- 09.12.98 14:18:55---------------------------------------------------
2264
2265 -----------------------------------------------------------------------*/
2266 Any SwXTextCursor::getPropertyValue(const OUString& rPropertyName)
2267 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2268 {
2269 vos::OGuard aGuard(Application::GetSolarMutex());
2270 uno::Any aAny;
2271 SwUnoCrsr* pUnoCrsr = GetCrsr();
2272 if(pUnoCrsr)
2273 {
2274 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)))
2275 {
2276 BOOL bSet = pUnoCrsr->IsSkipOverHiddenSections();
2277 aAny.setValue(&bSet, ::getBooleanCppuType());
2278 }
2279 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT)))
2280 {
2281 BOOL bSet = pUnoCrsr->IsSkipOverProtectSections();
2282 aAny.setValue(&bSet, ::getBooleanCppuType());
2283 }
2284 else
2285 aAny = GetPropertyValue(*pUnoCrsr, *m_pPropSet, rPropertyName);
2286 }
2287 else
2288 throw uno::RuntimeException();
2289 return aAny;
2290
2291 }
2292 /*-- 09.12.98 14:18:55---------------------------------------------------
2293
2294 -----------------------------------------------------------------------*/
2295 void SwXTextCursor::addPropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2296 {
2297 DBG_WARNING("not implemented");
2298 }
2299 /*-- 09.12.98 14:18:57---------------------------------------------------
2300
2301 -----------------------------------------------------------------------*/
2302 void SwXTextCursor::removePropertyChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2303 {
2304 DBG_WARNING("not implemented");
2305 }
2306 /*-- 09.12.98 14:18:57---------------------------------------------------
2307
2308 -----------------------------------------------------------------------*/
2309 void SwXTextCursor::addVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2310 {
2311 DBG_WARNING("not implemented");
2312 }
2313 /*-- 09.12.98 14:18:58---------------------------------------------------
2314
2315 -----------------------------------------------------------------------*/
2316 void SwXTextCursor::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*aListener*/) throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2317 {
2318 DBG_WARNING("not implemented");
2319 }
2320 /*-- 05.03.99 11:36:11---------------------------------------------------
2321
2322 -----------------------------------------------------------------------*/
2323 beans::PropertyState SwXTextCursor::getPropertyState(const OUString& rPropertyName)
2324 throw( beans::UnknownPropertyException, uno::RuntimeException )
2325 {
2326 vos::OGuard aGuard(Application::GetSolarMutex());
2327 beans::PropertyState eRet = beans::PropertyState_DEFAULT_VALUE;
2328 SwUnoCrsr* pUnoCrsr = GetCrsr();
2329 if(pUnoCrsr)
2330 {
2331 eRet = GetPropertyState(*pUnoCrsr, *m_pPropSet, rPropertyName);
2332 }
2333 else
2334 throw RuntimeException();
2335 return eRet;
2336 }
2337 /*-- 05.03.99 11:36:11---------------------------------------------------
2338
2339 -----------------------------------------------------------------------*/
2340 uno::Sequence< beans::PropertyState > SwXTextCursor::getPropertyStates(
2341 const uno::Sequence< OUString >& PropertyNames)
2342 throw( beans::UnknownPropertyException, uno::RuntimeException )
2343 {
2344 vos::OGuard aGuard(Application::GetSolarMutex());
2345 SwUnoCrsr* pUnoCrsr = GetCrsr();
2346 if(!pUnoCrsr)
2347 throw RuntimeException();
2348 return GetPropertyStates(*pUnoCrsr, *m_pPropSet, PropertyNames);
2349 }
2350 /*-- 05.03.99 11:36:12---------------------------------------------------
2351
2352 -----------------------------------------------------------------------*/
2353 void SwXTextCursor::setPropertyToDefault(const OUString& rPropertyName)
2354 throw( beans::UnknownPropertyException, uno::RuntimeException )
2355 {
2356 Sequence < OUString > aSequence ( &rPropertyName, 1 );
2357 setPropertiesToDefault ( aSequence );
2358 }
2359 /*-- 05.03.99 11:36:12---------------------------------------------------
2360
2361 -----------------------------------------------------------------------*/
2362 uno::Any SwXTextCursor::getPropertyDefault(const OUString& rPropertyName)
2363 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2364 {
2365 const Sequence < OUString > aSequence ( &rPropertyName, 1 );
2366 return getPropertyDefaults ( aSequence ).getConstArray()[0];
2367 }
2368
2369 void SAL_CALL SwXTextCursor::setAllPropertiesToDefault()
2370 throw (RuntimeException)
2371 {
2372 vos::OGuard aGuard(Application::GetSolarMutex());
2373
2374 SwUnoCrsr* pUnoCrsr = GetCrsr();
2375 if (pUnoCrsr)
2376 {
2377 // para specific attribut ranges
2378 USHORT aParaResetableSetRange[] = {
2379 RES_FRMATR_BEGIN, RES_FRMATR_END-1,
2380 RES_PARATR_BEGIN, RES_PARATR_END-1,
2381 // --> OD 2008-02-25 #refactorlists#
2382 RES_PARATR_LIST_BEGIN, RES_PARATR_LIST_END-1,
2383 // <--
2384 RES_UNKNOWNATR_BEGIN, RES_UNKNOWNATR_END-1,
2385 0
2386 };
2387 // selection specific attribut ranges
2388 USHORT aResetableSetRange[] = {
2389 RES_CHRATR_BEGIN, RES_CHRATR_END-1,
2390 RES_TXTATR_CHARFMT, RES_TXTATR_CHARFMT,
2391 RES_TXTATR_INETFMT, RES_TXTATR_INETFMT,
2392 RES_TXTATR_CJK_RUBY, RES_TXTATR_UNKNOWN_CONTAINER,
2393 0
2394 };
2395 SvUShortsSort aParaWhichIds;
2396 SvUShortsSort aWhichIds;
2397 for (USHORT k = 0; k < 2; ++k)
2398 {
2399 SvUShortsSort &rWhichIds = k == 0? aParaWhichIds : aWhichIds;
2400 USHORT *pResetableSetRange = k == 0? aParaResetableSetRange : aResetableSetRange;
2401 while (*pResetableSetRange)
2402 {
2403 USHORT nStart = sal::static_int_cast< USHORT >(*pResetableSetRange++);
2404 USHORT nEnd = sal::static_int_cast< USHORT >(*pResetableSetRange++);
2405 for (USHORT nId = nStart + 1; nId <= nEnd; ++nId)
2406 rWhichIds.Insert( nId );
2407 }
2408 }
2409 if (aParaWhichIds.Count())
2410 lcl_SelectParaAndReset( *pUnoCrsr, pUnoCrsr->GetDoc(), &aParaWhichIds );
2411 if (aWhichIds.Count() )
2412 pUnoCrsr->GetDoc()->ResetAttrs( *pUnoCrsr, sal_True, &aWhichIds );
2413 }
2414 else
2415 throw uno::RuntimeException();
2416 }
2417
2418 void SAL_CALL SwXTextCursor::setPropertiesToDefault( const Sequence< OUString >& aPropertyNames )
2419 throw (UnknownPropertyException, RuntimeException)
2420 {
2421 vos::OGuard aGuard(Application::GetSolarMutex());
2422 sal_Int32 nCount = aPropertyNames.getLength();
2423 if ( nCount )
2424 {
2425 SwUnoCrsr* pUnoCrsr = GetCrsr();
2426 if(pUnoCrsr)
2427 {
2428 SwDoc* pDoc = pUnoCrsr->GetDoc();
2429 const OUString * pNames = aPropertyNames.getConstArray();
2430 SvUShortsSort aWhichIds, aParaWhichIds;
2431 for ( sal_Int32 i = 0; i < nCount; i++ )
2432 {
2433 const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( pNames[i] );
2434 if(!pEntry)
2435 {
2436 if(pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)) ||
2437 pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT)))
2438 {
2439 continue;
2440 }
2441 else
2442 throw UnknownPropertyException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pNames[i], static_cast < cppu::OWeakObject * > ( 0 ) );
2443 }
2444 if( pEntry->nFlags & PropertyAttribute::READONLY)
2445 throw RuntimeException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "setPropertiesToDefault: property is read-only: " ) ) + pNames[i], static_cast < cppu::OWeakObject * > ( this ) );
2446
2447 if( pEntry->nWID < RES_FRMATR_END)
2448 {
2449 if(pEntry->nWID < RES_PARATR_BEGIN)
2450 aWhichIds.Insert(pEntry->nWID);
2451 else
2452 aParaWhichIds.Insert (pEntry->nWID);
2453 }
2454 else if ( pEntry->nWID == FN_UNO_NUM_START_VALUE )
2455 SwUnoCursorHelper::resetCrsrPropertyValue(*pEntry, *pUnoCrsr);
2456 }
2457
2458 if ( aParaWhichIds.Count() )
2459 lcl_SelectParaAndReset ( *pUnoCrsr, pDoc, &aParaWhichIds );
2460 if (aWhichIds.Count() )
2461 pDoc->ResetAttrs(*pUnoCrsr, sal_True, &aWhichIds);
2462 }
2463 else
2464 throw uno::RuntimeException();
2465 }
2466 }
2467 Sequence< Any > SAL_CALL SwXTextCursor::getPropertyDefaults( const Sequence< OUString >& aPropertyNames )
2468 throw (UnknownPropertyException, WrappedTargetException, RuntimeException)
2469 {
2470 vos::OGuard aGuard(Application::GetSolarMutex());
2471 sal_Int32 nCount = aPropertyNames.getLength();
2472 Sequence < Any > aRet ( nCount );
2473 if ( nCount )
2474 {
2475 SwUnoCrsr* pUnoCrsr = GetCrsr();
2476 if (pUnoCrsr)
2477 {
2478 SwDoc* pDoc = pUnoCrsr->GetDoc();
2479 const OUString *pNames = aPropertyNames.getConstArray();
2480 Any *pAny = aRet.getArray();
2481 for ( sal_Int32 i = 0; i < nCount; i++)
2482 {
2483 const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( pNames[i] );
2484 if(!pEntry)
2485 {
2486 if(pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_HIDDEN_TEXT)) ||
2487 pNames[i].equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_SKIP_PROTECTED_TEXT)))
2488 {
2489 continue;
2490 }
2491 else
2492 throw UnknownPropertyException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pNames[i], static_cast < cppu::OWeakObject * > ( 0 ) );
2493 }
2494 if(pEntry->nWID < RES_FRMATR_END)
2495 {
2496 const SfxPoolItem& rDefItem = pDoc->GetAttrPool().GetDefaultItem(pEntry->nWID);
2497 rDefItem.QueryValue(pAny[i], pEntry->nMemberId);
2498 }
2499 }
2500 }
2501 else
2502 throw UnknownPropertyException();
2503 }
2504 return aRet;
2505 }
2506
2507 /*-- 10.03.2008 09:58:47---------------------------------------------------
2508
2509 -----------------------------------------------------------------------*/
2510 void SwXTextCursor::makeRedline(
2511 const ::rtl::OUString& rRedlineType,
2512 const uno::Sequence< beans::PropertyValue >& rRedlineProperties )
2513 throw (lang::IllegalArgumentException, uno::RuntimeException)
2514 {
2515 vos::OGuard aGuard(Application::GetSolarMutex());
2516 SwUnoCrsr* pUnoCrsr = GetCrsr();
2517 if(pUnoCrsr)
2518 SwUnoCursorHelper::makeRedline( *pUnoCrsr, rRedlineType, rRedlineProperties );
2519 else
2520 throw uno::RuntimeException();
2521 }
vba interoperability for OOo