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