1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22 // MARKER(update_precomp.py): autogen include statement, do not remove
23 #include "precompiled_sw.hxx"
24
25 #include <svx/svxids.hrc>
26 #include <hintids.hxx>
27 #include <vos/mutex.hxx>
28 #include <vcl/svapp.hxx>
29 #include <svl/smplhint.hxx>
30 #include <svtools/ctrltool.hxx>
31 #include <svl/style.hxx>
32 #include <svl/itemiter.hxx>
33 #include <svx/pageitem.hxx>
34 #include <editeng/sizeitem.hxx>
35 #include <editeng/ulspitem.hxx>
36 #include <editeng/lrspitem.hxx>
37 #include <editeng/boxitem.hxx>
38 #include <editeng/shaditem.hxx>
39 #include <editeng/brshitem.hxx>
40 #include <editeng/flstitem.hxx>
41 #include <editeng/paperinf.hxx>
42 #include <pagedesc.hxx>
43 #include <doc.hxx>
44 #include <IDocumentUndoRedo.hxx>
45 #include <docary.hxx>
46 #include <charfmt.hxx>
47 #include <cmdid.h>
48 #include <unostyle.hxx>
49 #include <unosett.hxx>
50 #include <docsh.hxx>
51 #include <swstyle.h>
52 #include <paratr.hxx>
53 #include <unoprnms.hxx>
54 #include <shellio.hxx>
55 #include <docstyle.hxx>
56 #include <unotextbodyhf.hxx>
57 #include <fmthdft.hxx>
58 #include <fmtpdsc.hxx>
59 #include <tools/urlobj.hxx>
60 #include <poolfmt.hrc>
61 #include <poolfmt.hxx>
62 #include "unoevent.hxx"
63 #include <fmtruby.hxx>
64 #include <SwStyleNameMapper.hxx>
65 #include <sfx2/printer.hxx>
66 #include <com/sun/star/style/ParagraphStyleCategory.hpp>
67 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
68 #include <com/sun/star/beans/PropertyAttribute.hpp>
69 #include <com/sun/star/beans/NamedValue.hpp>
70 #include <com/sun/star/drawing/BitmapMode.hpp>
71 #include <istyleaccess.hxx>
72 #include <GetMetricVal.hxx>
73 #include <fmtfsize.hxx>
74 #include <numrule.hxx>
75
76 //UUUU
77 #include <svx/unobrushitemhelper.hxx>
78 #include <editeng/unoipset.hxx>
79 #include <editeng/memberids.hrc>
80 #include <svx/unoshape.hxx>
81 #include <svx/xflbstit.hxx>
82 #include <svx/xflbmtit.hxx>
83 #include <swunohelper.hxx>
84 #include <svx/xbtmpit.hxx>
85
86 #include <boost/shared_ptr.hpp>
87
88 #include "ccoll.hxx"
89 #include "unocore.hrc"
90
91 #include <set>
92
93 #define STYLE_FAMILY_COUNT 5 // we have 5 style families
94 #define TYPE_BOOL 0
95 #define TYPE_SIZE 1
96 #define TYPE_BRUSH 2
97 #define TYPE_ULSPACE 3
98 #define TYPE_SHADOW 4
99 #define TYPE_LRSPACE 5
100 #define TYPE_BOX 6
101
102 const unsigned short aStyleByIndex[] =
103 {
104 SFX_STYLE_FAMILY_CHAR,
105 SFX_STYLE_FAMILY_PARA,
106 SFX_STYLE_FAMILY_PAGE ,
107 SFX_STYLE_FAMILY_FRAME ,
108 SFX_STYLE_FAMILY_PSEUDO
109 };
110
111 // Already implemented autostyle families: 3
112 #define AUTOSTYLE_FAMILY_COUNT 3
113 const IStyleAccess::SwAutoStyleFamily aAutoStyleByIndex[] =
114 {
115 IStyleAccess::AUTO_STYLE_CHAR,
116 IStyleAccess::AUTO_STYLE_RUBY,
117 IStyleAccess::AUTO_STYLE_PARA
118 };
119
120 using namespace ::com::sun::star;
121 using ::rtl::OUString;
122
123 /******************************************************************************
124 *
125 ******************************************************************************/
126
lcl_GetSwEnumFromSfxEnum(SfxStyleFamily eFamily)127 SwGetPoolIdFromName lcl_GetSwEnumFromSfxEnum ( SfxStyleFamily eFamily )
128 {
129 switch ( eFamily )
130 {
131 case SFX_STYLE_FAMILY_CHAR:
132 return nsSwGetPoolIdFromName::GET_POOLID_CHRFMT;
133 case SFX_STYLE_FAMILY_PARA:
134 return nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL;
135 case SFX_STYLE_FAMILY_FRAME:
136 return nsSwGetPoolIdFromName::GET_POOLID_FRMFMT;
137 case SFX_STYLE_FAMILY_PAGE:
138 return nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC;
139 case SFX_STYLE_FAMILY_PSEUDO:
140 return nsSwGetPoolIdFromName::GET_POOLID_NUMRULE;
141 default:
142 DBG_ASSERT(sal_False, "someone asking for all styles in unostyle.cxx!" );
143 return nsSwGetPoolIdFromName::GET_POOLID_CHRFMT;
144 }
145 }
146
147 class SwAutoStylesEnumImpl
148 {
149 std::vector<SfxItemSet_Pointer_t> mAutoStyles;
150 std::vector<SfxItemSet_Pointer_t>::iterator aIter;
151 SwDoc* pDoc;
152 IStyleAccess::SwAutoStyleFamily eFamily;
153 public:
154 SwAutoStylesEnumImpl( SwDoc* pInitDoc, IStyleAccess::SwAutoStyleFamily eFam );
hasMoreElements()155 ::sal_Bool hasMoreElements() { return aIter != mAutoStyles.end(); }
nextElement()156 SfxItemSet_Pointer_t nextElement() { return *(aIter++); }
getFamily() const157 IStyleAccess::SwAutoStyleFamily getFamily() const { return eFamily; }
getDoc() const158 SwDoc* getDoc() const { return pDoc; }
159 };
160
161
162 /******************************************************************
163 * SwXStyleFamilies
164 ******************************************************************/
165 /* -----------------------------06.04.00 11:24--------------------------------
166
167 ---------------------------------------------------------------------------*/
getImplementationName(void)168 OUString SwXStyleFamilies::getImplementationName(void) throw( uno::RuntimeException )
169 {
170 return C2U("SwXStyleFamilies");
171 }
172 /* -----------------------------06.04.00 11:24--------------------------------
173
174 ---------------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)175 sal_Bool SwXStyleFamilies::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
176 {
177 return C2U("com.sun.star.style.StyleFamilies") == rServiceName;
178 }
179 /* -----------------------------06.04.00 11:24--------------------------------
180
181 ---------------------------------------------------------------------------*/
getSupportedServiceNames(void)182 uno::Sequence< OUString > SwXStyleFamilies::getSupportedServiceNames(void) throw( uno::RuntimeException )
183 {
184 uno::Sequence< OUString > aRet(1);
185 OUString* pArray = aRet.getArray();
186 pArray[0] = C2U("com.sun.star.style.StyleFamilies");
187 return aRet;
188 }
189 /*-- 16.12.98 15:13:26---------------------------------------------------
190
191 -----------------------------------------------------------------------*/
SwXStyleFamilies(SwDocShell & rDocShell)192 SwXStyleFamilies::SwXStyleFamilies(SwDocShell& rDocShell) :
193 SwUnoCollection(rDocShell.GetDoc()),
194 pDocShell(&rDocShell),
195 pxCharStyles(0),
196 pxParaStyles(0),
197 pxFrameStyles(0),
198 pxPageStyles(0),
199 pxNumberingStyles(0)
200 {
201
202 }
203 /*-- 16.12.98 15:13:26---------------------------------------------------
204
205 -----------------------------------------------------------------------*/
~SwXStyleFamilies()206 SwXStyleFamilies::~SwXStyleFamilies()
207 {
208 delete pxCharStyles;
209 delete pxParaStyles;
210 delete pxFrameStyles;
211 delete pxPageStyles;
212 delete pxNumberingStyles;
213 }
214 /*-- 21.12.98 12:05:22---------------------------------------------------
215
216 -----------------------------------------------------------------------*/
getByName(const OUString & Name)217 uno::Any SAL_CALL SwXStyleFamilies::getByName(const OUString& Name)
218 throw(
219 container::NoSuchElementException,
220 lang::WrappedTargetException,
221 uno::RuntimeException )
222 {
223 vos::OGuard aGuard(Application::GetSolarMutex());
224 // der Index kommt aus const unsigned short aStyleByIndex[] =
225 uno::Any aRet;
226 if(!IsValid())
227 throw uno::RuntimeException();
228 if(Name.compareToAscii("CharacterStyles") == 0 )
229 aRet = getByIndex(0);
230 else if(Name.compareToAscii("ParagraphStyles") == 0)
231 aRet = getByIndex(1);
232 else if(Name.compareToAscii("FrameStyles") == 0 )
233 aRet = getByIndex(3);
234 else if(Name.compareToAscii("PageStyles") == 0 )
235 aRet = getByIndex(2);
236 else if(Name.compareToAscii("NumberingStyles") == 0 )
237 aRet = getByIndex(4);
238 else
239 throw container::NoSuchElementException();
240 return aRet;
241 }
242 /*-- 21.12.98 12:05:22---------------------------------------------------
243
244 -----------------------------------------------------------------------*/
getElementNames(void)245 uno::Sequence< OUString > SwXStyleFamilies::getElementNames(void) throw( uno::RuntimeException )
246 {
247 uno::Sequence< OUString > aNames(STYLE_FAMILY_COUNT);
248 OUString* pNames = aNames.getArray();
249 pNames[0] = C2U("CharacterStyles");
250 pNames[1] = C2U("ParagraphStyles");
251 pNames[2] = C2U("FrameStyles");
252 pNames[3] = C2U("PageStyles");
253 pNames[4] = C2U("NumberingStyles");
254 return aNames;
255 }
256 /*-- 21.12.98 12:05:22---------------------------------------------------
257
258 -----------------------------------------------------------------------*/
hasByName(const OUString & Name)259 sal_Bool SwXStyleFamilies::hasByName(const OUString& Name) throw( uno::RuntimeException )
260 {
261 if( Name.compareToAscii("CharacterStyles") == 0 ||
262 Name.compareToAscii("ParagraphStyles") == 0 ||
263 Name.compareToAscii("FrameStyles") == 0 ||
264 Name.compareToAscii("PageStyles") == 0 ||
265 Name.compareToAscii("NumberingStyles") == 0 )
266 return sal_True;
267 else
268 return sal_False;
269 }
270 /*-- 16.12.98 15:13:27---------------------------------------------------
271
272 -----------------------------------------------------------------------*/
getCount(void)273 sal_Int32 SwXStyleFamilies::getCount(void) throw( uno::RuntimeException )
274 {
275 return STYLE_FAMILY_COUNT;
276 }
277 /*-- 16.12.98 15:13:27---------------------------------------------------
278
279 -----------------------------------------------------------------------*/
getByIndex(sal_Int32 nIndex)280 uno::Any SwXStyleFamilies::getByIndex(sal_Int32 nIndex)
281 throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException )
282 {
283 vos::OGuard aGuard(Application::GetSolarMutex());
284 uno::Any aRet;
285 if(nIndex < 0 || nIndex >= STYLE_FAMILY_COUNT)
286 throw lang::IndexOutOfBoundsException();
287 if(IsValid())
288 {
289 uno::Reference< container::XNameContainer > aRef;
290 sal_uInt16 nType = aStyleByIndex[nIndex];
291 switch( nType )
292 {
293 case SFX_STYLE_FAMILY_CHAR:
294 {
295 if(!pxCharStyles)
296 {
297 ((SwXStyleFamilies*)this)->pxCharStyles = new uno::Reference< container::XNameContainer > ();
298 *pxCharStyles = new SwXStyleFamily(pDocShell, nType);
299 }
300 aRef = *pxCharStyles;
301 }
302 break;
303 case SFX_STYLE_FAMILY_PARA:
304 {
305 if(!pxParaStyles)
306 {
307 ((SwXStyleFamilies*)this)->pxParaStyles = new uno::Reference< container::XNameContainer > ();
308 *pxParaStyles = new SwXStyleFamily(pDocShell, nType);
309 }
310 aRef = *pxParaStyles;
311 }
312 break;
313 case SFX_STYLE_FAMILY_PAGE :
314 {
315 if(!pxPageStyles)
316 {
317 ((SwXStyleFamilies*)this)->pxPageStyles = new uno::Reference< container::XNameContainer > ();
318 *pxPageStyles = new SwXStyleFamily(pDocShell, nType);
319 }
320 aRef = *pxPageStyles;
321 }
322 break;
323 case SFX_STYLE_FAMILY_FRAME :
324 {
325 if(!pxFrameStyles)
326 {
327 ((SwXStyleFamilies*)this)->pxFrameStyles = new uno::Reference< container::XNameContainer > ();
328 *pxFrameStyles = new SwXStyleFamily(pDocShell, nType);
329 }
330 aRef = *pxFrameStyles;
331 }
332 break;
333 case SFX_STYLE_FAMILY_PSEUDO:
334 {
335 if(!pxNumberingStyles)
336 {
337 ((SwXStyleFamilies*)this)->pxNumberingStyles = new uno::Reference< container::XNameContainer > ();
338 *pxNumberingStyles = new SwXStyleFamily(pDocShell, nType);
339 }
340 aRef = *pxNumberingStyles;
341 }
342 break;
343 }
344 aRet.setValue(&aRef, ::getCppuType((const uno::Reference<container::XNameContainer>*)0));
345 }
346 else
347 throw uno::RuntimeException();
348 return aRet;
349 }
350 /*-- 16.12.98 15:13:27---------------------------------------------------
351
352 -----------------------------------------------------------------------*/
getElementType(void)353 uno::Type SwXStyleFamilies::getElementType(void)
354 throw( uno::RuntimeException )
355 {
356 return ::getCppuType((const uno::Reference<container::XNameContainer>*)0);
357
358 }
359 /*-- 16.12.98 15:13:28---------------------------------------------------
360
361 -----------------------------------------------------------------------*/
hasElements(void)362 sal_Bool SwXStyleFamilies::hasElements(void) throw( uno::RuntimeException )
363 {
364 return sal_True;
365 }
366 /*-- 16.12.98 15:13:28---------------------------------------------------
367
368 -----------------------------------------------------------------------*/
loadStylesFromURL(const OUString & rURL,const uno::Sequence<beans::PropertyValue> & aOptions)369 void SwXStyleFamilies::loadStylesFromURL(const OUString& rURL,
370 const uno::Sequence< beans::PropertyValue >& aOptions)
371 throw( io::IOException, uno::RuntimeException )
372 {
373 vos::OGuard aGuard(Application::GetSolarMutex());
374 sal_Bool bLoadStyleText = sal_True;
375 sal_Bool bLoadStylePage = sal_True;
376 sal_Bool bLoadStyleOverwrite = sal_True;
377 sal_Bool bLoadStyleNumbering = sal_True;
378 sal_Bool bLoadStyleFrame = sal_True;
379 if(IsValid() && rURL.getLength())
380 {
381 const uno::Any* pVal;
382 int nCount = aOptions.getLength();
383 const beans::PropertyValue* pArray = aOptions.getConstArray();
384 for(int i = 0; i < nCount; i++)
385 if( ( pVal = &pArray[i].Value)->getValueType() ==
386 ::getBooleanCppuType() )
387 {
388 String sName = pArray[i].Name;
389 sal_Bool bVal = *(sal_Bool*)pVal->getValue();
390 if( sName.EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_OVERWRITE_STYLES )))
391 bLoadStyleOverwrite = bVal;
392 else if( sName.EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_LOAD_NUMBERING_STYLES )))
393 bLoadStyleNumbering = bVal;
394 else if( sName.EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_LOAD_PAGE_STYLES )))
395 bLoadStylePage = bVal;
396 else if( sName.EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_LOAD_FRAME_STYLES )))
397 bLoadStyleFrame = bVal;
398 else if( sName.EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_LOAD_TEXT_STYLES )))
399 bLoadStyleText = bVal;
400 }
401
402 SwgReaderOption aOpt;
403 aOpt.SetFrmFmts( bLoadStyleFrame );
404 aOpt.SetTxtFmts( bLoadStyleText );
405 aOpt.SetPageDescs( bLoadStylePage );
406 aOpt.SetNumRules( bLoadStyleNumbering );
407 aOpt.SetMerge( !bLoadStyleOverwrite );
408
409 sal_uLong nErr = pDocShell->LoadStylesFromFile( rURL, aOpt, sal_True );
410 if( nErr )
411 throw io::IOException();
412 }
413 else
414 throw uno::RuntimeException();
415 }
416 /*-- 16.12.98 15:13:28---------------------------------------------------
417
418 -----------------------------------------------------------------------*/
getStyleLoaderOptions(void)419 uno::Sequence< beans::PropertyValue > SwXStyleFamilies::getStyleLoaderOptions(void)
420 throw( uno::RuntimeException )
421 {
422 vos::OGuard aGuard(Application::GetSolarMutex());
423 uno::Sequence< beans::PropertyValue > aSeq(5);
424 beans::PropertyValue* pArray = aSeq.getArray();
425 uno::Any aVal;
426 sal_Bool bTemp = sal_True;
427 aVal.setValue(&bTemp, ::getCppuBooleanType());
428 pArray[0] = beans::PropertyValue(C2U(SW_PROP_NAME_STR(UNO_NAME_LOAD_TEXT_STYLES)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
429 aVal.setValue(&bTemp, ::getCppuBooleanType());
430 pArray[1] = beans::PropertyValue(C2U(SW_PROP_NAME_STR(UNO_NAME_LOAD_FRAME_STYLES)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
431 aVal.setValue(&bTemp, ::getCppuBooleanType());
432 pArray[2] = beans::PropertyValue(C2U(SW_PROP_NAME_STR(UNO_NAME_LOAD_PAGE_STYLES)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
433 aVal.setValue(&bTemp, ::getCppuBooleanType());
434 pArray[3] = beans::PropertyValue(C2U(SW_PROP_NAME_STR(UNO_NAME_LOAD_NUMBERING_STYLES)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
435 aVal.setValue(&bTemp, ::getCppuBooleanType());
436 pArray[4] = beans::PropertyValue(C2U(SW_PROP_NAME_STR(UNO_NAME_OVERWRITE_STYLES)), -1, aVal, beans::PropertyState_DIRECT_VALUE);
437 return aSeq;
438 }
439
440 /******************************************************************
441 * SwXStyleFamily
442 ******************************************************************/
443 /* -----------------------------06.04.00 11:24--------------------------------
444
445 ---------------------------------------------------------------------------*/
getImplementationName(void)446 OUString SwXStyleFamily::getImplementationName(void) throw( uno::RuntimeException )
447 {
448 return C2U("SwXStyleFamily");
449 }
450 /* -----------------------------06.04.00 11:24--------------------------------
451
452 ---------------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)453 sal_Bool SwXStyleFamily::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
454 {
455 return C2U("com.sun.star.style.StyleFamily") == rServiceName;
456 }
457 /* -----------------------------06.04.00 11:24--------------------------------
458
459 ---------------------------------------------------------------------------*/
getSupportedServiceNames(void)460 uno::Sequence< OUString > SwXStyleFamily::getSupportedServiceNames(void) throw( uno::RuntimeException )
461 {
462 uno::Sequence< OUString > aRet(1);
463 OUString* pArray = aRet.getArray();
464 pArray[0] = C2U("com.sun.star.style.StyleFamily");
465 return aRet;
466 }
467 /*-- 16.12.98 16:03:56---------------------------------------------------
468
469 -----------------------------------------------------------------------*/
SwXStyleFamily(SwDocShell * pDocSh,sal_uInt16 nFamily)470 SwXStyleFamily::SwXStyleFamily(SwDocShell* pDocSh, sal_uInt16 nFamily) :
471 eFamily((SfxStyleFamily)nFamily),
472 pBasePool(pDocSh->GetStyleSheetPool()),
473 pDocShell(pDocSh)
474 {
475 /* switch( nFamily )
476 {
477 case SFX_STYLE_FAMILY_CHAR:
478 _pPropMap = aSwMapProvider.GetPropertyMap(PROPERTY_MAP_CHAR_STYLE);
479 break;
480 case SFX_STYLE_FAMILY_PARA:
481 _pPropMap = aSwMapProvider.GetPropertyMap(PROPERTY_MAP_PARA_STYLE);
482 break;
483 case SFX_STYLE_FAMILY_PAGE:
484 _pPropMap = aSwMapProvider.GetPropertyMap(PROPERTY_MAP_PAGE_STYLE);
485 break;
486 case SFX_STYLE_FAMILY_FRAME:
487 _pPropMap = aSwMapProvider.GetPropertyMap(PROPERTY_MAP_FRAME_STYLE);
488 break;
489 case SFX_STYLE_FAMILY_PSEUDO:
490 _pPropMap = aSwMapProvider.GetPropertyMap(PROPERTY_MAP_NUM_STYLE);
491 break;
492 }*/
493 StartListening(*pBasePool);
494 }
495 /*-- 16.12.98 16:03:56---------------------------------------------------
496
497 -----------------------------------------------------------------------*/
~SwXStyleFamily()498 SwXStyleFamily::~SwXStyleFamily()
499 {
500
501 }
lcl_GetCountOrName(const SwDoc & rDoc,SfxStyleFamily eFamily,String * pString,sal_uInt16 nIndex=USHRT_MAX)502 sal_Int32 lcl_GetCountOrName ( const SwDoc &rDoc, SfxStyleFamily eFamily, String *pString, sal_uInt16 nIndex = USHRT_MAX )
503 {
504 sal_Int32 nCount = 0;
505 switch( eFamily )
506 {
507 case SFX_STYLE_FAMILY_CHAR:
508 {
509 sal_uInt16 nBaseCount = RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN +
510 RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN;
511 nIndex = nIndex - nBaseCount;
512 const sal_uInt16 nArrLen = rDoc.GetCharFmts()->Count();
513 for( sal_uInt16 i = 0; i < nArrLen; i++ )
514 {
515 SwCharFmt* pFmt = (*rDoc.GetCharFmts())[ i ];
516 if( pFmt->IsDefault() && pFmt != rDoc.GetDfltCharFmt() )
517 continue;
518 if ( IsPoolUserFmt ( pFmt->GetPoolFmtId() ) )
519 {
520 if ( nIndex == nCount )
521 {
522 // the default character format needs to be set to "Default!"
523 if(rDoc.GetDfltCharFmt() == pFmt)
524 SwStyleNameMapper::FillUIName(
525 RES_POOLCOLL_STANDARD, *pString );
526 else
527 *pString = pFmt->GetName();
528 break;
529 }
530 nCount++;
531 }
532 }
533 nCount += nBaseCount;
534 }
535 break;
536 case SFX_STYLE_FAMILY_PARA:
537 {
538 sal_uInt16 nBaseCount = RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN +
539 RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN +
540 RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN +
541 RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN +
542 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN +
543 RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN;
544 nIndex = nIndex - nBaseCount;
545 const sal_uInt16 nArrLen = rDoc.GetTxtFmtColls()->Count();
546 for ( sal_uInt16 i = 0; i < nArrLen; i++ )
547 {
548 SwTxtFmtColl * pColl = (*rDoc.GetTxtFmtColls())[i];
549 if ( pColl->IsDefault() )
550 continue;
551 if ( IsPoolUserFmt ( pColl->GetPoolFmtId() ) )
552 {
553 if ( nIndex == nCount )
554 {
555 *pString = pColl->GetName();
556 break;
557 }
558 nCount++;
559 }
560 }
561 nCount += nBaseCount;
562 }
563 break;
564 case SFX_STYLE_FAMILY_FRAME:
565 {
566 sal_uInt16 nBaseCount = RES_POOLFRM_END - RES_POOLFRM_BEGIN;
567 nIndex = nIndex - nBaseCount;
568 const sal_uInt16 nArrLen = rDoc.GetFrmFmts()->Count();
569 for( sal_uInt16 i = 0; i < nArrLen; i++ )
570 {
571 SwFrmFmt* pFmt = (*rDoc.GetFrmFmts())[ i ];
572 if(pFmt->IsDefault() || pFmt->IsAuto())
573 continue;
574 if ( IsPoolUserFmt ( pFmt->GetPoolFmtId() ) )
575 {
576 if ( nIndex == nCount )
577 {
578 *pString = pFmt->GetName();
579 break;
580 }
581 nCount++;
582 }
583 }
584 nCount += nBaseCount;
585 }
586 break;
587 case SFX_STYLE_FAMILY_PAGE:
588 {
589 sal_uInt16 nBaseCount = RES_POOLPAGE_END - RES_POOLPAGE_BEGIN;
590 nIndex = nIndex - nBaseCount;
591 const sal_uInt16 nArrLen = rDoc.GetPageDescCnt();
592 for(sal_uInt16 i = 0; i < nArrLen; ++i)
593 {
594 const SwPageDesc& rDesc = rDoc.GetPageDesc(i);
595
596 /*if(rDesc.IsDefault() || rDesc.IsAuto())
597 continue;*/
598 if ( IsPoolUserFmt ( rDesc.GetPoolFmtId() ) )
599 {
600 if ( nIndex == nCount )
601 {
602 *pString = rDesc.GetName();
603 break;
604 }
605 nCount++;
606 }
607 }
608 nCount += nBaseCount;
609 }
610 break;
611 case SFX_STYLE_FAMILY_PSEUDO:
612 {
613 sal_uInt16 nBaseCount = RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN;
614 nIndex = nIndex - nBaseCount;
615 const SwNumRuleTbl& rNumTbl = rDoc.GetNumRuleTbl();
616 for(sal_uInt16 i = 0; i < rNumTbl.Count(); ++i)
617 {
618 const SwNumRule& rRule = *rNumTbl[ i ];
619 if( rRule.IsAutoRule() )
620 continue;
621 if ( IsPoolUserFmt ( rRule.GetPoolFmtId() ) )
622 {
623 if ( nIndex == nCount )
624 {
625 *pString = rRule.GetName();
626 break;
627 }
628 nCount++;
629 }
630 }
631 nCount += nBaseCount;
632 }
633 break;
634
635 default:
636 ;
637 }
638 return nCount;
639 }
640 /*-- 16.12.98 16:03:57---------------------------------------------------
641
642 -----------------------------------------------------------------------*/
getCount(void)643 sal_Int32 SwXStyleFamily::getCount(void) throw( uno::RuntimeException )
644 {
645 vos::OGuard aGuard(Application::GetSolarMutex());
646 return lcl_GetCountOrName ( *pDocShell->GetDoc(), eFamily, NULL );
647 }
648 /*-- 16.12.98 16:03:57---------------------------------------------------
649
650 -----------------------------------------------------------------------*/
getByIndex(sal_Int32 nTempIndex)651 uno::Any SwXStyleFamily::getByIndex(sal_Int32 nTempIndex)
652 throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException )
653 {
654 vos::OGuard aGuard(Application::GetSolarMutex());
655 uno::Any aRet;
656 if ( nTempIndex >= 0 && nTempIndex < USHRT_MAX )
657 {
658 sal_uInt16 nIndex = static_cast < sal_uInt16 > ( nTempIndex );
659 if(pBasePool)
660 {
661 String sStyleName;
662 switch( eFamily )
663 {
664 case SFX_STYLE_FAMILY_CHAR:
665 {
666 if ( nIndex < ( RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN ) )
667 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLCHR_NORMAL_BEGIN + nIndex), sStyleName );
668 else if ( nIndex < ( RES_POOLCHR_HTML_END - RES_POOLCHR_HTML_BEGIN +
669 RES_POOLCHR_NORMAL_END - RES_POOLCHR_NORMAL_BEGIN ) )
670 SwStyleNameMapper::FillUIName ( RES_POOLCHR_HTML_BEGIN
671 - RES_POOLCHR_NORMAL_END + RES_POOLCHR_NORMAL_BEGIN
672 + nIndex, sStyleName );
673 }
674 break;
675 case SFX_STYLE_FAMILY_PARA:
676 {
677 if ( nIndex < ( RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN ) )
678 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLCOLL_TEXT_BEGIN + nIndex), sStyleName );
679 else if ( nIndex < ( RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN +
680 RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN ) )
681 SwStyleNameMapper::FillUIName ( RES_POOLCOLL_LISTS_BEGIN
682 - RES_POOLCOLL_TEXT_END + RES_POOLCOLL_TEXT_BEGIN
683 + nIndex, sStyleName );
684 else if ( nIndex < ( RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN +
685 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN +
686 RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN ) )
687 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLCOLL_EXTRA_BEGIN
688 - RES_POOLCOLL_LISTS_END + RES_POOLCOLL_LISTS_BEGIN
689 - RES_POOLCOLL_TEXT_END + RES_POOLCOLL_TEXT_BEGIN
690 + nIndex), sStyleName );
691 else if ( nIndex < ( RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN +
692 RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN +
693 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN +
694 RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN ) )
695 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLCOLL_REGISTER_BEGIN
696 - RES_POOLCOLL_EXTRA_END + RES_POOLCOLL_EXTRA_BEGIN
697 - RES_POOLCOLL_LISTS_END + RES_POOLCOLL_LISTS_BEGIN
698 - RES_POOLCOLL_TEXT_END + RES_POOLCOLL_TEXT_BEGIN
699 + nIndex), sStyleName );
700 else if ( nIndex < ( RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN +
701 RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN +
702 RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN +
703 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN +
704 RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN ) )
705 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLCOLL_DOC_BEGIN
706 - RES_POOLCOLL_REGISTER_END + RES_POOLCOLL_REGISTER_BEGIN
707 - RES_POOLCOLL_EXTRA_END + RES_POOLCOLL_EXTRA_BEGIN
708 - RES_POOLCOLL_LISTS_END + RES_POOLCOLL_LISTS_BEGIN
709 - RES_POOLCOLL_TEXT_END + RES_POOLCOLL_TEXT_BEGIN
710 + nIndex), sStyleName );
711 else if ( nIndex < ( RES_POOLCOLL_HTML_END - RES_POOLCOLL_HTML_BEGIN +
712 RES_POOLCOLL_DOC_END - RES_POOLCOLL_DOC_BEGIN +
713 RES_POOLCOLL_REGISTER_END - RES_POOLCOLL_REGISTER_BEGIN +
714 RES_POOLCOLL_EXTRA_END - RES_POOLCOLL_EXTRA_BEGIN +
715 RES_POOLCOLL_LISTS_END - RES_POOLCOLL_LISTS_BEGIN +
716 RES_POOLCOLL_TEXT_END - RES_POOLCOLL_TEXT_BEGIN ) )
717 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLCOLL_HTML_BEGIN
718 - RES_POOLCOLL_DOC_END + RES_POOLCOLL_DOC_BEGIN
719 - RES_POOLCOLL_REGISTER_END + RES_POOLCOLL_REGISTER_BEGIN
720 - RES_POOLCOLL_EXTRA_END + RES_POOLCOLL_EXTRA_BEGIN
721 - RES_POOLCOLL_LISTS_END + RES_POOLCOLL_LISTS_BEGIN
722 - RES_POOLCOLL_TEXT_END + RES_POOLCOLL_TEXT_BEGIN
723 + nIndex), sStyleName );
724 }
725 break;
726 case SFX_STYLE_FAMILY_FRAME:
727 {
728 if ( nIndex < ( RES_POOLFRM_END - RES_POOLFRM_BEGIN ) )
729 {
730 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLFRM_BEGIN + nIndex), sStyleName );
731 }
732 }
733 break;
734 case SFX_STYLE_FAMILY_PAGE:
735 {
736 if ( nIndex < ( RES_POOLPAGE_END - RES_POOLPAGE_BEGIN ) )
737 {
738 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLPAGE_BEGIN + nIndex), sStyleName );
739 }
740 }
741 break;
742 case SFX_STYLE_FAMILY_PSEUDO:
743 {
744 if ( nIndex < ( RES_POOLNUMRULE_END - RES_POOLNUMRULE_BEGIN ) )
745 {
746 SwStyleNameMapper::FillUIName ( static_cast< sal_uInt16 >(RES_POOLNUMRULE_BEGIN + nIndex), sStyleName );
747 }
748 }
749 break;
750
751 default:
752 ;
753 }
754 if ( !sStyleName.Len() )
755 lcl_GetCountOrName ( *pDocShell->GetDoc(), eFamily, &sStyleName, nIndex );
756
757 if ( sStyleName.Len() )
758 {
759 SfxStyleSheetBase* pBase = pBasePool->Find( sStyleName, eFamily );
760 if(pBase)
761 {
762 uno::Reference< style::XStyle > xStyle = _FindStyle(sStyleName);
763 if(!xStyle.is())
764 {
765 xStyle = eFamily == SFX_STYLE_FAMILY_PAGE ?
766 new SwXPageStyle(*pBasePool, pDocShell, eFamily, sStyleName) :
767 eFamily == SFX_STYLE_FAMILY_FRAME ?
768 new SwXFrameStyle(*pBasePool, pDocShell->GetDoc(), pBase->GetName()):
769 new SwXStyle(*pBasePool, eFamily, pDocShell->GetDoc(), sStyleName);
770 }
771 aRet.setValue(&xStyle, ::getCppuType((uno::Reference<style::XStyle>*)0));
772 }
773 else
774 throw container::NoSuchElementException();
775 }
776 else
777 throw lang::IndexOutOfBoundsException();
778 }
779 else
780 throw uno::RuntimeException();
781 }
782 else
783 throw lang::IndexOutOfBoundsException();
784
785 return aRet;
786 }
787 /*-- 16.12.98 16:03:57---------------------------------------------------
788
789 -----------------------------------------------------------------------*/
getByName(const OUString & rName)790 uno::Any SwXStyleFamily::getByName(const OUString& rName)
791 throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
792 {
793 vos::OGuard aGuard(Application::GetSolarMutex());
794 uno::Any aRet;
795 String sStyleName;
796 SwStyleNameMapper::FillUIName(rName, sStyleName, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
797 if(pBasePool)
798 {
799 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
800 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
801 if(pBase)
802 {
803 uno::Reference< style::XStyle > xStyle = _FindStyle(sStyleName);
804 if(!xStyle.is())
805 {
806 xStyle = eFamily == SFX_STYLE_FAMILY_PAGE ?
807 new SwXPageStyle(*pBasePool, pDocShell, eFamily, sStyleName) :
808 eFamily == SFX_STYLE_FAMILY_FRAME ?
809 new SwXFrameStyle(*pBasePool, pDocShell->GetDoc(), pBase->GetName()):
810 new SwXStyle(*pBasePool, eFamily, pDocShell->GetDoc(), sStyleName);
811 }
812 aRet.setValue(&xStyle, ::getCppuType((uno::Reference<style::XStyle>*)0));
813 }
814 else
815 throw container::NoSuchElementException();
816 }
817 else
818 throw uno::RuntimeException();
819 return aRet;
820
821 }
822 /*-- 16.12.98 16:03:57---------------------------------------------------
823
824 -----------------------------------------------------------------------*/
getElementNames(void)825 uno::Sequence< OUString > SwXStyleFamily::getElementNames(void) throw( uno::RuntimeException )
826 {
827 vos::OGuard aGuard(Application::GetSolarMutex());
828 uno::Sequence< OUString > aRet;
829 if(pBasePool)
830 {
831 SfxStyleSheetIteratorPtr pIterator = pBasePool->CreateIterator(eFamily, 0xffff);
832 sal_uInt16 nCount = pIterator->Count();
833 aRet.realloc(nCount);
834 OUString* pArray = aRet.getArray();
835 String aString;
836 for(sal_uInt16 i = 0; i < nCount; i++)
837 {
838 SwStyleNameMapper::FillProgName((*pIterator)[i]->GetName(), aString, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
839 pArray[i] = OUString ( aString );
840 }
841 }
842 else
843 throw uno::RuntimeException();
844 return aRet;
845 }
846 /*-- 16.12.98 16:03:57---------------------------------------------------
847
848 -----------------------------------------------------------------------*/
hasByName(const OUString & rName)849 sal_Bool SwXStyleFamily::hasByName(const OUString& rName) throw( uno::RuntimeException )
850 {
851 vos::OGuard aGuard(Application::GetSolarMutex());
852 sal_Bool bRet = sal_False;
853 if(pBasePool)
854 {
855 String sStyleName;
856 SwStyleNameMapper::FillUIName(rName, sStyleName, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
857 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
858 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
859 bRet = 0 != pBase;
860 }
861 else
862 throw uno::RuntimeException();
863 return bRet;
864
865 }
866 /*-- 16.12.98 16:03:58---------------------------------------------------
867
868 -----------------------------------------------------------------------*/
getElementType(void)869 uno::Type SwXStyleFamily::getElementType(void) throw( uno::RuntimeException )
870 {
871 return ::getCppuType((const uno::Reference<style::XStyle>*)0);
872
873 }
874 /*-- 16.12.98 16:03:58---------------------------------------------------
875
876 -----------------------------------------------------------------------*/
hasElements(void)877 sal_Bool SwXStyleFamily::hasElements(void) throw( uno::RuntimeException )
878 {
879 if(!pBasePool)
880 throw uno::RuntimeException();
881 return sal_True;
882 }
883 /*-- 16.12.98 16:03:58---------------------------------------------------
884
885 -----------------------------------------------------------------------*/
insertByName(const OUString & rName,const uno::Any & rElement)886 void SwXStyleFamily::insertByName(const OUString& rName, const uno::Any& rElement)
887 throw( lang::IllegalArgumentException, container::ElementExistException, lang::WrappedTargetException, uno::RuntimeException )
888 {
889 vos::OGuard aGuard(Application::GetSolarMutex());
890 if(pBasePool)
891 {
892 String sStyleName;
893 SwStyleNameMapper::FillUIName(rName, sStyleName, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True);
894 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
895 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
896 SfxStyleSheetBase* pUINameBase = pBasePool->Find( sStyleName );
897 if(pBase || pUINameBase)
898 throw container::ElementExistException();
899 else
900 {
901 if(rElement.getValueType().getTypeClass() ==
902 uno::TypeClass_INTERFACE)
903 {
904 uno::Reference< uno::XInterface > * pxRef =
905 (uno::Reference< uno::XInterface > *)rElement.getValue();
906
907 uno::Reference<lang::XUnoTunnel> xStyleTunnel( *pxRef, uno::UNO_QUERY);
908
909 SwXStyle* pNewStyle = 0;
910 if(xStyleTunnel.is())
911 {
912 pNewStyle = reinterpret_cast< SwXStyle * >(
913 sal::static_int_cast< sal_IntPtr >( xStyleTunnel->getSomething( SwXStyle::getUnoTunnelId()) ));
914 }
915 if(!pNewStyle || !pNewStyle->IsDescriptor() ||
916 pNewStyle->GetFamily() != eFamily)
917 throw lang::IllegalArgumentException();
918 if(pNewStyle)
919 {
920 sal_uInt16 nMask = 0xffff;
921 if(eFamily == SFX_STYLE_FAMILY_PARA && !pNewStyle->IsConditional())
922 nMask &= ~SWSTYLEBIT_CONDCOLL;
923 #if OSL_DEBUG_LEVEL > 1
924 SfxStyleSheetBase& rNewBase =
925 #endif
926 pBasePool->Make(sStyleName, eFamily, nMask);
927 pNewStyle->SetDoc(pDocShell->GetDoc(), pBasePool);
928 pNewStyle->SetStyleName(sStyleName);
929 String sParentStyleName(pNewStyle->GetParentStyleName());
930 if(sParentStyleName.Len())
931 {
932 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
933 SfxStyleSheetBase* pParentBase = pBasePool->Find(sParentStyleName);
934 if(pParentBase && pParentBase->GetFamily() == eFamily &&
935 &pParentBase->GetPool() == pBasePool)
936 pBasePool->SetParent( eFamily, sStyleName, sParentStyleName );
937
938 }
939 #if OSL_DEBUG_LEVEL > 1
940 (void)rNewBase;
941 #endif
942 //so, jetzt sollten noch die Properties des Descriptors angewandt werden
943 pNewStyle->ApplyDescriptorProperties();
944 }
945 else
946 throw lang::IllegalArgumentException();
947 }
948 else
949 throw lang::IllegalArgumentException();
950 }
951 }
952 else
953 throw uno::RuntimeException();
954 }
955 /*-- 16.12.98 16:03:59---------------------------------------------------
956
957 -----------------------------------------------------------------------*/
replaceByName(const OUString & rName,const uno::Any & rElement)958 void SwXStyleFamily::replaceByName(const OUString& rName, const uno::Any& rElement)
959 throw( lang::IllegalArgumentException, container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
960 {
961 vos::OGuard aGuard(Application::GetSolarMutex());
962 if(pBasePool)
963 {
964 pBasePool->SetSearchMask(eFamily);
965 SfxStyleSheetBase* pBase = pBasePool->Find(rName);
966 //Ersetzung geht nur fuer benutzerdefinierte Styles
967 if(!pBase)
968 throw container::NoSuchElementException();
969 if(!pBase->IsUserDefined())
970 throw lang::IllegalArgumentException();
971 //if theres an object available to this style then it must be invalidated
972 uno::Reference< style::XStyle > xStyle = _FindStyle(pBase->GetName());
973 if(xStyle.is())
974 {
975 uno::Reference<lang::XUnoTunnel> xTunnel( xStyle, uno::UNO_QUERY);
976 if(xTunnel.is())
977 {
978 SwXStyle* pStyle = reinterpret_cast< SwXStyle * >(
979 sal::static_int_cast< sal_IntPtr >( xTunnel->getSomething( SwXStyle::getUnoTunnelId()) ));
980 pStyle->Invalidate();
981 }
982 }
983
984 pBasePool->Remove(pBase);
985 insertByName(rName, rElement);
986 }
987 else
988 throw uno::RuntimeException();
989 }
990 /*-- 16.12.98 16:03:59---------------------------------------------------
991
992 -----------------------------------------------------------------------*/
removeByName(const OUString & rName)993 void SwXStyleFamily::removeByName(const OUString& rName) throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
994 {
995 vos::OGuard aGuard(Application::GetSolarMutex());
996 if(pBasePool)
997 {
998 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
999 String aString;
1000 SwStyleNameMapper::FillUIName(rName, aString, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
1001
1002 SfxStyleSheetBase* pBase = pBasePool->Find( aString );
1003 if(pBase)
1004 pBasePool->Remove(pBase);
1005 else
1006 throw container::NoSuchElementException();
1007 }
1008 else
1009 throw uno::RuntimeException();
1010 }
1011
getPropertySetInfo()1012 uno::Reference< beans::XPropertySetInfo > SAL_CALL SwXStyleFamily::getPropertySetInfo( ) throw (uno::RuntimeException)
1013 {
1014 OSL_ENSURE( 0, "###unexpected!" );
1015 return uno::Reference< beans::XPropertySetInfo >();
1016 }
1017
setPropertyValue(const::rtl::OUString &,const uno::Any &)1018 void SAL_CALL SwXStyleFamily::setPropertyValue( const ::rtl::OUString&, const uno::Any& ) throw (beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
1019 {
1020 OSL_ENSURE( 0, "###unexpected!" );
1021 }
1022
getPropertyValue(const::rtl::OUString & sPropertyName)1023 uno::Any SAL_CALL SwXStyleFamily::getPropertyValue( const ::rtl::OUString& sPropertyName ) throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1024 {
1025 uno::Any aRet;
1026
1027 if ( sPropertyName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("DisplayName") ) )
1028 {
1029 vos::OGuard aGuard(Application::GetSolarMutex());
1030 sal_uInt32 nResId = 0;
1031 switch ( eFamily )
1032 {
1033 case SFX_STYLE_FAMILY_CHAR:
1034 nResId = STR_STYLE_FAMILY_CHARACTER; break;
1035 case SFX_STYLE_FAMILY_PARA:
1036 nResId = STR_STYLE_FAMILY_PARAGRAPH; break;
1037 case SFX_STYLE_FAMILY_FRAME:
1038 nResId = STR_STYLE_FAMILY_FRAME; break;
1039 case SFX_STYLE_FAMILY_PAGE:
1040 nResId = STR_STYLE_FAMILY_PAGE; break;
1041 case SFX_STYLE_FAMILY_PSEUDO:
1042 nResId = STR_STYLE_FAMILY_NUMBERING; break;
1043 default:
1044 OSL_ENSURE( 0, "SwXStyleFamily::getPropertyValue(): invalid family" );
1045 }
1046 if ( nResId > 0 )
1047 {
1048 OUString sDisplayName( String( SW_RES( nResId ) ) );
1049 aRet = uno::makeAny( sDisplayName );
1050 }
1051 }
1052 else
1053 {
1054 throw beans::UnknownPropertyException( OUString( RTL_CONSTASCII_USTRINGPARAM("unknown property: ") ) + sPropertyName, static_cast<OWeakObject *>(this) );
1055 }
1056
1057 return aRet;
1058 }
1059
addPropertyChangeListener(const::rtl::OUString &,const uno::Reference<beans::XPropertyChangeListener> &)1060 void SAL_CALL SwXStyleFamily::addPropertyChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XPropertyChangeListener >& ) throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1061 {
1062 OSL_ENSURE( 0, "###unexpected!" );
1063 }
1064
removePropertyChangeListener(const::rtl::OUString &,const uno::Reference<beans::XPropertyChangeListener> &)1065 void SAL_CALL SwXStyleFamily::removePropertyChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XPropertyChangeListener >& ) throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1066 {
1067 OSL_ENSURE( 0, "###unexpected!" );
1068 }
1069
addVetoableChangeListener(const::rtl::OUString &,const uno::Reference<beans::XVetoableChangeListener> &)1070 void SAL_CALL SwXStyleFamily::addVetoableChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XVetoableChangeListener >& ) throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1071 {
1072 OSL_ENSURE( 0, "###unexpected!" );
1073 }
1074
removeVetoableChangeListener(const::rtl::OUString &,const uno::Reference<beans::XVetoableChangeListener> &)1075 void SAL_CALL SwXStyleFamily::removeVetoableChangeListener( const ::rtl::OUString&, const uno::Reference< beans::XVetoableChangeListener >& ) throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
1076 {
1077 OSL_ENSURE( 0, "###unexpected!" );
1078 }
1079
1080
1081 /*-- 16.12.98 16:03:59---------------------------------------------------
1082
1083 -----------------------------------------------------------------------*/
Notify(SfxBroadcaster & rBC,const SfxHint & rHint)1084 void SwXStyleFamily::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
1085 {
1086 SfxSimpleHint *pHint = PTR_CAST( SfxSimpleHint, &rHint );
1087 if( pHint && ( pHint->GetId() & SFX_HINT_DYING ) )
1088 {
1089 pBasePool = 0;
1090 pDocShell = 0;
1091 EndListening(rBC);
1092 }
1093 }
1094 /*-- 16.12.98 16:03:59---------------------------------------------------
1095
1096 -----------------------------------------------------------------------*/
_FindStyle(const String & rStyleName) const1097 SwXStyle* SwXStyleFamily::_FindStyle(const String& rStyleName)const
1098 {
1099 sal_uInt16 nLCount = pBasePool->GetListenerCount();
1100 SfxListener* pListener = 0;
1101 for( sal_uInt16 i = 0; i < nLCount; i++)
1102 {
1103 pListener = pBasePool->GetListener( i );
1104 SwXStyle* pTempStyle = dynamic_cast<SwXStyle*>( pListener );
1105 if(pTempStyle && pTempStyle->GetFamily() == eFamily && pTempStyle->GetStyleName() == rStyleName)
1106 {
1107 return pTempStyle;
1108 }
1109 }
1110 return 0;
1111 }
1112 /******************************************************************
1113 *
1114 ******************************************************************/
1115 class SwStyleProperties_Impl
1116 {
1117 const PropertyEntryVector_t aPropertyEntries;
1118 uno::Any** pAnyArr;
1119 sal_uInt32 nArrLen;
1120
1121 public:
1122 SwStyleProperties_Impl(const SfxItemPropertyMap* _pMap);
1123 ~SwStyleProperties_Impl();
1124
1125 sal_Bool SetProperty(const ::rtl::OUString& rName, uno::Any aVal);
1126 sal_Bool GetProperty(const ::rtl::OUString& rName, uno::Any*& rpAny);
1127 sal_Bool ClearProperty( const ::rtl::OUString& rPropertyName );
1128 void ClearAllProperties( );
1129 void GetProperty(const ::rtl::OUString &rPropertyName, const uno::Reference < beans::XPropertySet > &rxPropertySet, uno::Any& rAny );
1130
GetPropertyVector() const1131 const PropertyEntryVector_t& GetPropertyVector() const {return aPropertyEntries; }
1132
1133 };
1134 //--------------------------------------------------------------------
1135 //--------------------------------------------------------------------
SwStyleProperties_Impl(const SfxItemPropertyMap * pMap)1136 SwStyleProperties_Impl::SwStyleProperties_Impl(const SfxItemPropertyMap* pMap) :
1137 // _pMap(pMap),
1138 aPropertyEntries( pMap->getPropertyEntries() ),
1139 nArrLen(0)
1140 {
1141 nArrLen = aPropertyEntries.size();
1142 //const SfxItemPropertyMap* pTmp = _pMap;
1143
1144 pAnyArr = new uno::Any* [nArrLen];
1145 for ( sal_uInt32 i =0 ; i < nArrLen; i++ )
1146 pAnyArr[i] = 0;
1147 }
1148 //--------------------------------------------------------------------
1149 //--------------------------------------------------------------------
~SwStyleProperties_Impl()1150 SwStyleProperties_Impl::~SwStyleProperties_Impl()
1151 {
1152 for ( sal_uInt16 i =0 ; i < nArrLen; i++ )
1153 delete pAnyArr[i];
1154 delete[] pAnyArr;
1155 }
1156
1157 //--------------------------------------------------------------------
1158 //--------------------------------------------------------------------
SetProperty(const::rtl::OUString & rName,uno::Any aVal)1159 sal_Bool SwStyleProperties_Impl::SetProperty(const ::rtl::OUString& rName, uno::Any aVal)
1160 {
1161 sal_uInt16 nPos = 0;
1162 sal_Bool bRet = sal_False;
1163 PropertyEntryVector_t::const_iterator aIt = aPropertyEntries.begin();
1164 while( aIt != aPropertyEntries.end() )
1165 {
1166 if(rName == aIt->sName)
1167 {
1168 delete pAnyArr[nPos];
1169 pAnyArr[nPos] = new uno::Any ( aVal );
1170 bRet = sal_True;
1171 break;
1172 }
1173 ++nPos;
1174 ++aIt;
1175 }
1176 return bRet;
1177 }
1178
ClearProperty(const OUString & rName)1179 sal_Bool SwStyleProperties_Impl::ClearProperty( const OUString& rName )
1180 {
1181 sal_Bool bRet = sal_False;
1182 sal_uInt16 nPos = 0;
1183 PropertyEntryVector_t::const_iterator aIt = aPropertyEntries.begin();
1184 while( aIt != aPropertyEntries.end() )
1185 {
1186 if( rName == aIt->sName )
1187 {
1188 delete pAnyArr[nPos];
1189 pAnyArr[ nPos ] = 0;
1190 bRet = sal_True;
1191 break;
1192 }
1193 ++nPos;
1194 ++aIt;
1195 }
1196 return bRet;
1197 }
ClearAllProperties()1198 void SwStyleProperties_Impl::ClearAllProperties( )
1199 {
1200 for ( sal_uInt16 i = 0; i < nArrLen; i++ )
1201 {
1202 delete pAnyArr[i];
1203 pAnyArr[ i ] = 0;
1204 }
1205 }
1206 //--------------------------------------------------------------------
1207 //--------------------------------------------------------------------
GetProperty(const::rtl::OUString & rName,uno::Any * & rpAny)1208 sal_Bool SwStyleProperties_Impl::GetProperty(const ::rtl::OUString& rName, uno::Any*& rpAny )
1209 {
1210 sal_Bool bRet = sal_False;
1211 sal_uInt16 nPos = 0;
1212 PropertyEntryVector_t::const_iterator aIt = aPropertyEntries.begin();
1213 while( aIt != aPropertyEntries.end() )
1214 {
1215 if( rName == aIt->sName )
1216 {
1217 rpAny = pAnyArr[nPos];
1218 bRet = sal_True;
1219 break;
1220 }
1221 ++nPos;
1222 ++aIt;
1223 }
1224
1225 return bRet;
1226 }
1227
GetProperty(const OUString & rPropertyName,const uno::Reference<beans::XPropertySet> & rxPropertySet,uno::Any & rAny)1228 void SwStyleProperties_Impl::GetProperty( const OUString &rPropertyName, const uno::Reference < beans::XPropertySet > &rxPropertySet, uno::Any & rAny )
1229 {
1230 rAny = rxPropertySet->getPropertyValue( rPropertyName );
1231 }
1232
1233 /******************************************************************
1234 *
1235 ******************************************************************/
1236 /* -----------------------------10.03.00 18:02--------------------------------
1237
1238 ---------------------------------------------------------------------------*/
getUnoTunnelId()1239 const uno::Sequence< sal_Int8 > & SwXStyle::getUnoTunnelId()
1240 {
1241 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId();
1242 return aSeq;
1243 }
1244 /* -----------------------------10.03.00 18:04--------------------------------
1245
1246 ---------------------------------------------------------------------------*/
getSomething(const uno::Sequence<sal_Int8> & rId)1247 sal_Int64 SAL_CALL SwXStyle::getSomething( const uno::Sequence< sal_Int8 >& rId )
1248 throw(uno::RuntimeException)
1249 {
1250 if( rId.getLength() == 16
1251 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
1252 rId.getConstArray(), 16 ) )
1253 {
1254 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) );
1255 }
1256 return 0;
1257 }
1258
1259 TYPEINIT1(SwXStyle, SfxListener);
1260 /* -----------------------------06.04.00 11:24--------------------------------
1261
1262 ---------------------------------------------------------------------------*/
getImplementationName(void)1263 OUString SwXStyle::getImplementationName(void) throw( uno::RuntimeException )
1264 {
1265 return C2U("SwXStyle");
1266 }
1267 /* -----------------------------06.04.00 11:24--------------------------------
1268
1269 ---------------------------------------------------------------------------*/
supportsService(const OUString & rServiceName)1270 sal_Bool SwXStyle::supportsService(const OUString& rServiceName) throw( uno::RuntimeException )
1271 {
1272 sal_Bool bRet = C2U("com.sun.star.style.Style") == rServiceName;
1273 if(!bRet && SFX_STYLE_FAMILY_CHAR == eFamily)
1274 bRet = !rServiceName.compareToAscii("com.sun.star.style.CharacterStyle")||
1275 !rServiceName.compareToAscii("com.sun.star.style.CharacterProperties")||
1276 !rServiceName.compareToAscii("com.sun.star.style.CharacterPropertiesAsian")||
1277 !rServiceName.compareToAscii("com.sun.star.style.CharacterPropertiesComplex");
1278 if(!bRet && SFX_STYLE_FAMILY_PARA == eFamily)
1279 bRet = (C2U("com.sun.star.style.ParagraphStyle") == rServiceName)||
1280 (C2U("com.sun.star.style.ParagraphProperties") == rServiceName) ||
1281 (C2U("com.sun.star.style.ParagraphPropertiesAsian") == rServiceName) ||
1282 (C2U("com.sun.star.style.ParagraphPropertiesComplex") == rServiceName);
1283 if(!bRet && SFX_STYLE_FAMILY_PAGE == eFamily)
1284 bRet = (C2U("com.sun.star.style.PageStyle") == rServiceName)||
1285 (C2U("com.sun.star.style.PageProperties") == rServiceName);
1286
1287 return bRet;
1288 }
1289 /* -----------------------------06.04.00 11:24--------------------------------
1290
1291 ---------------------------------------------------------------------------*/
getSupportedServiceNames(void)1292 uno::Sequence< OUString > SwXStyle::getSupportedServiceNames(void) throw( uno::RuntimeException )
1293 {
1294 long nCount = 1;
1295 if(SFX_STYLE_FAMILY_PARA == eFamily)
1296 {
1297 nCount = 5;
1298 if(bIsConditional)
1299 nCount++;
1300 }
1301 else if(SFX_STYLE_FAMILY_CHAR == eFamily)
1302 nCount = 5;
1303 else if(SFX_STYLE_FAMILY_PAGE == eFamily)
1304 nCount = 3;
1305 uno::Sequence< OUString > aRet(nCount);
1306 OUString* pArray = aRet.getArray();
1307 pArray[0] = C2U("com.sun.star.style.Style");
1308 switch(eFamily)
1309 {
1310 case SFX_STYLE_FAMILY_CHAR:
1311 pArray[1] = C2U("com.sun.star.style.CharacterStyle");
1312 pArray[2] = C2U("com.sun.star.style.CharacterProperties");
1313 pArray[3] = C2U("com.sun.star.style.CharacterPropertiesAsian");
1314 pArray[4] = C2U("com.sun.star.style.CharacterPropertiesComplex");
1315 break;
1316 case SFX_STYLE_FAMILY_PAGE:
1317 pArray[1] = C2U("com.sun.star.style.PageStyle");
1318 pArray[2] = C2U("com.sun.star.style.PageProperties");
1319 break;
1320 case SFX_STYLE_FAMILY_PARA:
1321 pArray[1] = C2U("com.sun.star.style.ParagraphStyle");
1322 pArray[2] = C2U("com.sun.star.style.ParagraphProperties");
1323 pArray[3] = C2U("com.sun.star.style.ParagraphPropertiesAsian");
1324 pArray[4] = C2U("com.sun.star.style.ParagraphPropertiesComplex");
1325 if(bIsConditional)
1326 pArray[5] = C2U("com.sun.star.style.ConditionalParagraphStyle");
1327 break;
1328
1329 default:
1330 ;
1331 }
1332 return aRet;
1333 }
1334 /*-- 17.12.98 08:26:49---------------------------------------------------
1335
1336 -----------------------------------------------------------------------*/
SwXStyle(SwDoc * pDoc,SfxStyleFamily eFam,sal_Bool bConditional)1337 SwXStyle::SwXStyle( SwDoc *pDoc, SfxStyleFamily eFam, sal_Bool bConditional) :
1338 m_pDoc( pDoc ),
1339 pBasePool(0),
1340 eFamily(eFam),
1341 bIsDescriptor(sal_True),
1342 bIsConditional(bConditional)
1343 {
1344 // Register ourselves as a listener to the document (via the page descriptor)
1345 pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
1346 // get the property set for the default style data
1347 // First get the model
1348 uno::Reference < frame::XModel > xModel = pDoc->GetDocShell()->GetBaseModel();
1349 // Ask the model for it's family supplier interface
1350 uno::Reference < style::XStyleFamiliesSupplier > xFamilySupplier ( xModel, uno::UNO_QUERY );
1351 // Get the style families
1352 uno::Reference < container::XNameAccess > xFamilies = xFamilySupplier->getStyleFamilies();
1353
1354 uno::Any aAny;
1355 sal_uInt16 nMapId = PROPERTY_MAP_NUM_STYLE;
1356 switch( eFamily )
1357 {
1358 case SFX_STYLE_FAMILY_CHAR:
1359 {
1360 nMapId = PROPERTY_MAP_CHAR_STYLE;
1361 aAny = xFamilies->getByName ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "CharacterStyles" ) ) );
1362 // Get the Frame family (and keep it for later)
1363 aAny >>= mxStyleFamily;
1364 //aAny = mxStyleFamily->getByName ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Standard" ) ) );
1365 //aAny >>= mxStyleData;
1366 }
1367 break;
1368 case SFX_STYLE_FAMILY_PARA:
1369 {
1370 nMapId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE;
1371 aAny = xFamilies->getByName ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "ParagraphStyles" ) ) );
1372 // Get the Frame family (and keep it for later)
1373 aAny >>= mxStyleFamily;
1374 aAny = mxStyleFamily->getByName ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Standard" ) ) );
1375 aAny >>= mxStyleData;
1376 }
1377 break;
1378 case SFX_STYLE_FAMILY_PAGE:
1379 {
1380 nMapId = PROPERTY_MAP_PAGE_STYLE;
1381 aAny = xFamilies->getByName ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "PageStyles" ) ) );
1382 // Get the Frame family (and keep it for later)
1383 aAny >>= mxStyleFamily;
1384 aAny = mxStyleFamily->getByName ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Standard" ) ) );
1385 aAny >>= mxStyleData;
1386 }
1387 break;
1388 case SFX_STYLE_FAMILY_FRAME :
1389 {
1390 nMapId = PROPERTY_MAP_FRAME_STYLE;
1391 }
1392 break;
1393 case SFX_STYLE_FAMILY_PSEUDO:
1394 {
1395 nMapId = PROPERTY_MAP_NUM_STYLE;
1396 }
1397 break;
1398
1399 default:
1400 ;
1401 }
1402 pPropImpl = new SwStyleProperties_Impl(aSwMapProvider.GetPropertySet(nMapId)->getPropertyMap());
1403 }
1404
1405
SwXStyle(SfxStyleSheetBasePool & rPool,SfxStyleFamily eFam,SwDoc * pDoc,const String & rStyleName)1406 SwXStyle::SwXStyle(SfxStyleSheetBasePool& rPool, SfxStyleFamily eFam,
1407 SwDoc* pDoc, const String& rStyleName) :
1408 m_pDoc(pDoc),
1409 sStyleName(rStyleName),
1410 pBasePool(&rPool),
1411 eFamily(eFam),
1412 bIsDescriptor(sal_False),
1413 bIsConditional(sal_False),
1414 pPropImpl(0)
1415 {
1416 StartListening(rPool);
1417 if(eFam == SFX_STYLE_FAMILY_PARA)
1418 {
1419 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
1420 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1421 DBG_ASSERT(pBase, "where is the style?" );
1422 if(pBase)
1423 {
1424 const sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(sStyleName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL);
1425 if(nId != USHRT_MAX)
1426 bIsConditional = ::IsConditionalByPoolId( nId );
1427 else
1428 bIsConditional = RES_CONDTXTFMTCOLL == ((SwDocStyleSheet*)pBase)->GetCollection()->Which();
1429 }
1430 }
1431 }
1432 /*-- 17.12.98 08:26:50---------------------------------------------------
1433
1434 -----------------------------------------------------------------------*/
~SwXStyle()1435 SwXStyle::~SwXStyle()
1436 {
1437 if(pBasePool)
1438 EndListening(*pBasePool);
1439 delete pPropImpl;
1440 }
1441 /*-- 17.12.98 08:26:51---------------------------------------------------
1442
1443 -----------------------------------------------------------------------*/
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)1444 void SwXStyle::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
1445 {
1446 ClientModify(this, pOld, pNew);
1447 if(!GetRegisteredIn())
1448 {
1449 m_pDoc = 0;
1450 mxStyleData.clear();
1451 mxStyleFamily.clear();
1452 }
1453 }
getName(void)1454 OUString SwXStyle::getName(void) throw( uno::RuntimeException )
1455 {
1456 vos::OGuard aGuard(Application::GetSolarMutex());
1457 String aString;
1458 if(pBasePool)
1459 {
1460 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
1461 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1462 DBG_ASSERT(pBase, "where is the style?" );
1463 if(!pBase)
1464 throw uno::RuntimeException();
1465 SwStyleNameMapper::FillProgName(pBase->GetName(), aString, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True);
1466 }
1467 else
1468 aString = sStyleName;
1469 return OUString (aString);
1470 }
1471 /*-- 17.12.98 08:26:51---------------------------------------------------
1472
1473 -----------------------------------------------------------------------*/
setName(const OUString & rName)1474 void SwXStyle::setName(const OUString& rName) throw( uno::RuntimeException )
1475 {
1476 vos::OGuard aGuard(Application::GetSolarMutex());
1477 if(pBasePool)
1478 {
1479 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
1480 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1481 DBG_ASSERT(pBase, "where is the style?" );
1482 sal_Bool bExcept = sal_True;
1483 if(pBase && pBase->IsUserDefined())
1484 {
1485 rtl::Reference< SwDocStyleSheet > xTmp( new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ) );
1486 bExcept = !xTmp->SetName(rName);
1487 if(!bExcept)
1488 sStyleName = String(rName);
1489 }
1490 if(bExcept)
1491 throw uno::RuntimeException();
1492 }
1493 else
1494 sStyleName = String(rName);
1495 }
1496 /*-- 17.12.98 08:26:51---------------------------------------------------
1497
1498 -----------------------------------------------------------------------*/
isUserDefined(void)1499 sal_Bool SwXStyle::isUserDefined(void) throw( uno::RuntimeException )
1500 {
1501 vos::OGuard aGuard(Application::GetSolarMutex());
1502 sal_Bool bRet = sal_False;
1503 if(pBasePool)
1504 {
1505 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
1506 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1507 //if it is not found it must be non user defined
1508 if(pBase)
1509 bRet = pBase->IsUserDefined();
1510 }
1511 else
1512 throw uno::RuntimeException();
1513 return bRet;
1514 }
1515 /*-- 17.12.98 08:26:51---------------------------------------------------
1516
1517 -----------------------------------------------------------------------*/
isInUse(void)1518 sal_Bool SwXStyle::isInUse(void) throw( uno::RuntimeException )
1519 {
1520 vos::OGuard aGuard(Application::GetSolarMutex());
1521 sal_Bool bRet = sal_False;
1522 if(pBasePool)
1523 {
1524 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_USED);
1525 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1526 if(pBase)
1527 bRet = pBase->IsUsed();
1528 }
1529 else
1530 throw uno::RuntimeException();
1531 return bRet;
1532 }
1533 /*-- 17.12.98 08:26:52---------------------------------------------------
1534
1535 -----------------------------------------------------------------------*/
getParentStyle(void)1536 OUString SwXStyle::getParentStyle(void) throw( uno::RuntimeException )
1537 {
1538 vos::OGuard aGuard(Application::GetSolarMutex());
1539 String aString;
1540 if(pBasePool)
1541 {
1542 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL);
1543 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1544 if(pBase)
1545 aString = pBase->GetParent();
1546 }
1547 else if(bIsDescriptor)
1548 aString = sParentStyleName;
1549 else
1550 throw uno::RuntimeException();
1551 SwStyleNameMapper::FillProgName(aString, aString, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
1552 return OUString ( aString );
1553 }
1554 /*-- 17.12.98 08:26:52---------------------------------------------------
1555
1556 -----------------------------------------------------------------------*/
setParentStyle(const OUString & rParentStyle)1557 void SwXStyle::setParentStyle(const OUString& rParentStyle)
1558 throw( container::NoSuchElementException, uno::RuntimeException )
1559 {
1560 vos::OGuard aGuard(Application::GetSolarMutex());
1561 String sParentStyle;
1562 SwStyleNameMapper::FillUIName(rParentStyle, sParentStyle, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
1563 if(pBasePool)
1564 {
1565 pBasePool->SetSearchMask(eFamily);
1566 sal_Bool bExcept = sal_False;
1567 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
1568 if(pBase)
1569 {
1570 rtl::Reference< SwDocStyleSheet > xBase( new SwDocStyleSheet(*(SwDocStyleSheet*)pBase) );
1571 //make it a 'real' style - necessary for pooled styles
1572 xBase->GetItemSet();
1573 if(xBase->GetParent() != sParentStyle)
1574 {
1575 bExcept = !xBase->SetParent(sParentStyle);
1576 }
1577 }
1578 else
1579 bExcept = sal_True;
1580 if(bExcept)
1581 throw uno::RuntimeException();
1582 }
1583 else if(bIsDescriptor)
1584 {
1585 sParentStyleName = String(sParentStyle);
1586 try
1587 {
1588 uno::Any aAny = mxStyleFamily->getByName ( sParentStyle );
1589 aAny >>= mxStyleData;
1590 }
1591 catch ( container::NoSuchElementException& )
1592 {
1593 }
1594 catch ( lang::WrappedTargetException& )
1595 {
1596 }
1597 catch ( uno::RuntimeException& )
1598 {
1599 }
1600 }
1601 else
1602 throw uno::RuntimeException();
1603 }
1604 /*-- 17.12.98 08:26:52---------------------------------------------------
1605
1606 -----------------------------------------------------------------------*/
1607
lcl_getPropertySetInfo(SfxStyleFamily eFamily,sal_Bool bIsConditional)1608 uno::Reference< beans::XPropertySetInfo > lcl_getPropertySetInfo( SfxStyleFamily eFamily, sal_Bool bIsConditional )
1609 {
1610 uno::Reference< beans::XPropertySetInfo > xRet;
1611 switch( eFamily )
1612 {
1613 case SFX_STYLE_FAMILY_CHAR:
1614 {
1615 static uno::Reference< beans::XPropertySetInfo > xCharRef;
1616 if(!xCharRef.is())
1617 {
1618 xCharRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CHAR_STYLE)->getPropertySetInfo();
1619 }
1620 xRet = xCharRef;
1621 }
1622 break;
1623 case SFX_STYLE_FAMILY_PARA:
1624 {
1625 static uno::Reference< beans::XPropertySetInfo > xParaRef;
1626 if(!xParaRef.is())
1627 {
1628 sal_uInt16 nMapId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE;
1629 xParaRef = aSwMapProvider.GetPropertySet(nMapId)->getPropertySetInfo();
1630 }
1631 xRet = xParaRef;
1632 }
1633 break;
1634 case SFX_STYLE_FAMILY_PAGE :
1635 {
1636 static uno::Reference< beans::XPropertySetInfo > xPageRef;
1637 if(!xPageRef.is())
1638 {
1639 xPageRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PAGE_STYLE)->getPropertySetInfo();
1640 }
1641 xRet = xPageRef;
1642 }
1643 break;
1644 case SFX_STYLE_FAMILY_FRAME :
1645 {
1646 static uno::Reference< beans::XPropertySetInfo > xFrameRef;
1647 if(!xFrameRef.is())
1648 {
1649 xFrameRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_FRAME_STYLE)->getPropertySetInfo();
1650 }
1651 xRet = xFrameRef;
1652 }
1653 break;
1654 case SFX_STYLE_FAMILY_PSEUDO:
1655 {
1656 static uno::Reference< beans::XPropertySetInfo > xNumRef;
1657 if(!xNumRef.is())
1658 {
1659 xNumRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_NUM_STYLE)->getPropertySetInfo();
1660 }
1661 xRet = xNumRef;
1662 }
1663 break;
1664
1665 default:
1666 ;
1667 }
1668 return xRet;
1669 }
1670
getPropertySetInfo(void)1671 uno::Reference< beans::XPropertySetInfo > SwXStyle::getPropertySetInfo(void)
1672 throw( uno::RuntimeException )
1673 {
1674 return lcl_getPropertySetInfo( eFamily, bIsConditional );
1675 }
1676 /* -----------------23.04.99 13:28-------------------
1677 *
1678 * --------------------------------------------------*/
ApplyDescriptorProperties()1679 void SwXStyle::ApplyDescriptorProperties()
1680 {
1681 bIsDescriptor = sal_False;
1682 mxStyleData.clear();
1683 mxStyleFamily.clear();
1684
1685 const PropertyEntryVector_t& rPropertyVector = pPropImpl->GetPropertyVector();
1686 PropertyEntryVector_t::const_iterator aIt = rPropertyVector.begin();
1687 while(aIt != rPropertyVector.end())
1688 {
1689 uno::Any* pAny;
1690 pPropImpl->GetProperty(aIt->sName, pAny);
1691 if(pAny)
1692 setPropertyValue(aIt->sName, *pAny);
1693 ++aIt;
1694 }
1695 }
1696
1697 /*-- 18.04.01 13:07:27---------------------------------------------------
1698
1699 -----------------------------------------------------------------------*/
1700 class SwStyleBase_Impl
1701 {
1702 private:
1703 SwDoc& mrDoc;
1704 const SwPageDesc* mpOldPageDesc;
1705 rtl::Reference< SwDocStyleSheet > mxNewBase;
1706 SfxItemSet* mpItemSet;
1707 const String& mrStyleName;
1708 sal_uInt16 mnPDescPos;
1709 const SwAttrSet* mpParentStyle;
1710
1711 public:
SwStyleBase_Impl(SwDoc & rSwDoc,const String & rName,const SwAttrSet * pParentStyle)1712 SwStyleBase_Impl(
1713 SwDoc& rSwDoc,
1714 const String& rName,
1715 const SwAttrSet* pParentStyle)
1716 : mrDoc(rSwDoc),
1717 mpOldPageDesc(0),
1718 mxNewBase(),
1719 mpItemSet(0),
1720 mrStyleName(rName),
1721 mnPDescPos(0xffff),
1722 mpParentStyle(pParentStyle)
1723 {
1724 }
1725
~SwStyleBase_Impl()1726 ~SwStyleBase_Impl()
1727 {
1728 delete mpItemSet;
1729 }
1730
getNewBase()1731 rtl::Reference< SwDocStyleSheet >& getNewBase()
1732 {
1733 return mxNewBase;
1734 }
1735
setNewBase(SwDocStyleSheet * pNew)1736 void setNewBase(SwDocStyleSheet* pNew)
1737 {
1738 mxNewBase = pNew;
1739 }
1740
HasItemSet()1741 sal_Bool HasItemSet()
1742 {
1743 return mxNewBase.is();
1744 }
1745
replaceItemSet(SfxItemSet * pNew)1746 SfxItemSet* replaceItemSet(SfxItemSet* pNew)
1747 {
1748 SfxItemSet* pRetval = mpItemSet;
1749 mpItemSet = pNew;
1750 return pRetval;
1751 }
1752
GetItemSet()1753 SfxItemSet& GetItemSet()
1754 {
1755 DBG_ASSERT(mxNewBase.is(), "no SwDocStyleSheet available");
1756
1757 if(!mpItemSet)
1758 {
1759 mpItemSet = new SfxItemSet(mxNewBase->GetItemSet());
1760
1761 //UUUU set parent style to have the correct XFillStyle setting as XFILL_NONE
1762 if(!mpItemSet->GetParent() && mpParentStyle)
1763 {
1764 mpItemSet->SetParent(mpParentStyle);
1765 }
1766 }
1767
1768 return *mpItemSet;
1769 }
1770
1771 const SwPageDesc& GetOldPageDesc();
1772 };
1773 /* -----------------------------25.04.01 12:44--------------------------------
1774
1775 ---------------------------------------------------------------------------*/
GetOldPageDesc()1776 const SwPageDesc& SwStyleBase_Impl::GetOldPageDesc()
1777 {
1778 if(!mpOldPageDesc)
1779 {
1780 sal_uInt16 i;
1781 sal_uInt16 nPDescCount = mrDoc.GetPageDescCnt();
1782 for(i = 0; i < nPDescCount; i++)
1783 {
1784 const SwPageDesc& rDesc =
1785 const_cast<const SwDoc &>(mrDoc).GetPageDesc( i );
1786 if(rDesc.GetName() == mrStyleName)
1787 {
1788 mpOldPageDesc = & rDesc;
1789 mnPDescPos = i;
1790 break;
1791 }
1792 }
1793 if(!mpOldPageDesc)
1794 {
1795 for(i = RC_POOLPAGEDESC_BEGIN; i <= STR_POOLPAGE_LANDSCAPE; ++i)
1796 {
1797 const String aFmtName(SW_RES(i));
1798 if(aFmtName == mrStyleName)
1799 {
1800 mpOldPageDesc = mrDoc.GetPageDescFromPool( static_cast< sal_uInt16 >(RES_POOLPAGE_BEGIN + i - RC_POOLPAGEDESC_BEGIN) );
1801 break;
1802 }
1803 }
1804 for(i = 0; i < nPDescCount + 1; i++)
1805 {
1806 const SwPageDesc& rDesc =
1807 const_cast<const SwDoc &>(mrDoc).GetPageDesc( i );
1808 if(rDesc.GetName() == mrStyleName)
1809 {
1810 mnPDescPos = i;
1811 break;
1812 }
1813 }
1814 }
1815 }
1816 return *mpOldPageDesc;
1817 }
1818
1819 /* -----------------------------19.04.01 09:44--------------------------------
1820
1821 ---------------------------------------------------------------------------*/
1822
lcl_SetStyleProperty(const SfxItemPropertySimpleEntry & rEntry,const SfxItemPropertySet & rPropSet,const uno::Any & rValue,SwStyleBase_Impl & rBase,SfxStyleSheetBasePool * pBasePool,SwDoc * pDoc,SfxStyleFamily eFamily)1823 void lcl_SetStyleProperty(
1824 const SfxItemPropertySimpleEntry& rEntry,
1825 const SfxItemPropertySet& rPropSet,
1826 const uno::Any& rValue,
1827 SwStyleBase_Impl& rBase,
1828 SfxStyleSheetBasePool* pBasePool,
1829 SwDoc* pDoc,
1830 SfxStyleFamily eFamily)
1831 throw(beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
1832 {
1833 //UUUU adapted switch logic to a more readable state; removed goto's and made
1834 // execution of standard setting of proerty in ItemSet dependent of this variable
1835 bool bDone(false);
1836
1837 //UUUU
1838 const sal_uInt8 nMemberId(rEntry.nMemberId & (~SFX_METRIC_ITEM));
1839 uno::Any aValue(rValue);
1840
1841 //UUUU check for needed metric translation
1842 if(rEntry.nMemberId & SFX_METRIC_ITEM)
1843 {
1844 bool bDoIt(true);
1845
1846 if(XATTR_FILLBMP_SIZEX == rEntry.nWID || XATTR_FILLBMP_SIZEY == rEntry.nWID)
1847 {
1848 // exception: If these ItemTypes are used, do not convert when these are negative
1849 // since this means they are intended as percent values
1850 sal_Int32 nValue = 0;
1851
1852 if(aValue >>= nValue)
1853 {
1854 bDoIt = nValue > 0;
1855 }
1856 }
1857
1858 if(bDoIt && pDoc)
1859 {
1860 const SfxItemPool& rPool = pDoc->GetAttrPool();
1861 const SfxMapUnit eMapUnit(rPool.GetMetric(rEntry.nWID));
1862
1863 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
1864 {
1865 SvxUnoConvertFromMM(eMapUnit, aValue);
1866 }
1867 }
1868 }
1869
1870 switch(rEntry.nWID)
1871 {
1872 case XATTR_FILLGRADIENT:
1873 case XATTR_FILLHATCH:
1874 case XATTR_FILLBITMAP:
1875 case XATTR_FILLFLOATTRANSPARENCE:
1876 // not yet needed; activate when LineStyle support may be added
1877 // case XATTR_LINESTART:
1878 // case XATTR_LINEEND:
1879 // case XATTR_LINEDASH:
1880 {
1881 if(MID_NAME == nMemberId)
1882 {
1883 //UUUU add set commands for FillName items
1884 OUString aTempName;
1885 SfxItemSet& rStyleSet = rBase.GetItemSet();
1886
1887 if(!(aValue >>= aTempName))
1888 {
1889 throw lang::IllegalArgumentException();
1890 }
1891
1892 SvxShape::SetFillAttribute(rEntry.nWID, aTempName, rStyleSet);
1893 bDone = true;
1894 }
1895 else if(MID_GRAFURL == nMemberId)
1896 {
1897 if(XATTR_FILLBITMAP == rEntry.nWID)
1898 {
1899 //UUUU Bitmap also has the MID_GRAFURL mode where a Bitmap URL is used
1900 const Graphic aNullGraphic;
1901 SfxItemSet& rStyleSet = rBase.GetItemSet();
1902 XFillBitmapItem aXFillBitmapItem(rStyleSet.GetPool(), aNullGraphic);
1903
1904 aXFillBitmapItem.PutValue(aValue, nMemberId);
1905 rStyleSet.Put(aXFillBitmapItem);
1906 bDone = true;
1907 }
1908 }
1909
1910 break;
1911 }
1912 case RES_BACKGROUND:
1913 {
1914 //UUUU
1915 SfxItemSet& rStyleSet = rBase.GetItemSet();
1916 const SvxBrushItem aOriginalBrushItem(getSvxBrushItemFromSourceSet(rStyleSet, RES_BACKGROUND));
1917 SvxBrushItem aChangedBrushItem(aOriginalBrushItem);
1918
1919 aChangedBrushItem.PutValue(aValue, nMemberId);
1920
1921 if(!(aChangedBrushItem == aOriginalBrushItem))
1922 {
1923 setSvxBrushItemAsFillAttributesToTargetSet(aChangedBrushItem, rStyleSet);
1924 }
1925
1926 bDone = true;
1927 break;
1928 }
1929 case OWN_ATTR_FILLBMP_MODE:
1930 {
1931 //UUUU
1932 drawing::BitmapMode eMode;
1933
1934 if(!(aValue >>= eMode))
1935 {
1936 sal_Int32 nMode = 0;
1937
1938 if(!(aValue >>= nMode))
1939 {
1940 throw lang::IllegalArgumentException();
1941 }
1942
1943 eMode = (drawing::BitmapMode)nMode;
1944 }
1945
1946 SfxItemSet& rStyleSet = rBase.GetItemSet();
1947
1948 rStyleSet.Put(XFillBmpStretchItem(drawing::BitmapMode_STRETCH == eMode));
1949 rStyleSet.Put(XFillBmpTileItem(drawing::BitmapMode_REPEAT == eMode));
1950
1951 bDone = true;
1952 break;
1953 }
1954 case RES_PAPER_BIN:
1955 {
1956 SfxPrinter *pPrinter = pDoc->getPrinter( true );
1957 OUString sTmp;
1958 sal_uInt16 nBin = USHRT_MAX;
1959 if ( !( aValue >>= sTmp ) )
1960 throw lang::IllegalArgumentException();
1961 if ( sTmp.equalsAsciiL ( RTL_CONSTASCII_STRINGPARAM ( "[From printer settings]" ) ) )
1962 nBin = USHRT_MAX-1;
1963 else if ( pPrinter )
1964 {
1965 for (sal_uInt16 i=0, nEnd = pPrinter->GetPaperBinCount(); i < nEnd; i++ )
1966 {
1967 if (sTmp == OUString ( pPrinter->GetPaperBinName ( i ) ) )
1968 {
1969 nBin = i;
1970 break;
1971 }
1972 }
1973 }
1974 if ( nBin == USHRT_MAX )
1975 throw lang::IllegalArgumentException();
1976 else
1977 {
1978 SfxItemSet& rStyleSet = rBase.GetItemSet();
1979 SfxItemSet aSet(*rStyleSet.GetPool(), rEntry.nWID, rEntry.nWID);
1980 aSet.SetParent(&rStyleSet);
1981 rPropSet.setPropertyValue(rEntry, uno::makeAny ( static_cast < sal_Int8 > ( nBin == USHRT_MAX-1 ? -1 : nBin ) ), aSet);
1982 rStyleSet.Put(aSet);
1983 }
1984
1985 bDone = true;
1986 break;
1987 }
1988 case FN_UNO_NUM_RULES: //Sonderbehandlung fuer das SvxNumRuleItem:
1989 {
1990 if(aValue.getValueType() == ::getCppuType((uno::Reference< container::XIndexReplace>*)0) )
1991 {
1992 uno::Reference< container::XIndexReplace > * pxRulesRef =
1993 (uno::Reference< container::XIndexReplace > *)aValue.getValue();
1994
1995 uno::Reference<lang::XUnoTunnel> xNumberTunnel( *pxRulesRef, uno::UNO_QUERY);
1996
1997 SwXNumberingRules* pSwXRules = 0;
1998 if(xNumberTunnel.is())
1999 {
2000 pSwXRules = reinterpret_cast< SwXNumberingRules * >(
2001 sal::static_int_cast< sal_IntPtr >(xNumberTunnel->getSomething( SwXNumberingRules::getUnoTunnelId()) ));
2002 }
2003 if(pSwXRules)
2004 {
2005 const String* pCharStyleNames = pSwXRules->GetNewCharStyleNames();
2006 const String* pBulletFontNames = pSwXRules->GetBulletFontNames();
2007
2008 SwNumRule aSetRule(*pSwXRules->GetNumRule());
2009 const SwCharFmts* pFmts = pDoc->GetCharFmts();
2010 sal_uInt16 nChCount = pFmts->Count();
2011 for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
2012 {
2013
2014 const SwNumFmt* pFmt = aSetRule.GetNumFmt( i );
2015 if(pFmt)
2016 {
2017 SwNumFmt aFmt(*pFmt);
2018 if(
2019 pCharStyleNames[i] != SwXNumberingRules::GetInvalidStyle() &&
2020 ((pCharStyleNames[i].Len() && !pFmt->GetCharFmt()) ||
2021 (pCharStyleNames[i].Len() &&
2022 pFmt->GetCharFmt()->GetName() != pCharStyleNames[i]) ))
2023 {
2024
2025 SwCharFmt* pCharFmt = 0;
2026 if(pCharStyleNames[i].Len())
2027 {
2028 for(sal_uInt16 j = 0; j< nChCount; j++)
2029 {
2030 SwCharFmt* pTmp = (*pFmts)[j];
2031 if(pTmp->GetName() == pCharStyleNames[i])
2032 {
2033 pCharFmt = pTmp;
2034 break;
2035 }
2036 }
2037 if(!pCharFmt)
2038 {
2039
2040 SfxStyleSheetBase* pBase;
2041 pBase = ((SfxStyleSheetBasePool*)pBasePool)->Find(pCharStyleNames[i], SFX_STYLE_FAMILY_CHAR);
2042 if(!pBase)
2043 pBase = &pBasePool->Make(pCharStyleNames[i], SFX_STYLE_FAMILY_CHAR);
2044 pCharFmt = ((SwDocStyleSheet*)pBase)->GetCharFmt();
2045
2046 }
2047
2048 aFmt.SetCharFmt( pCharFmt );
2049 }
2050 }
2051 //jetzt nochmal fuer Fonts
2052 if(pBulletFontNames[i] != SwXNumberingRules::GetInvalidStyle() &&
2053 ((pBulletFontNames[i].Len() && !pFmt->GetBulletFont()) ||
2054 (pBulletFontNames[i].Len() &&
2055 pFmt->GetBulletFont()->GetName() != pBulletFontNames[i]) ))
2056 {
2057 const SvxFontListItem* pFontListItem =
2058 (const SvxFontListItem* )pDoc->GetDocShell()
2059 ->GetItem( SID_ATTR_CHAR_FONTLIST );
2060 const FontList* pList = pFontListItem->GetFontList();
2061 FontInfo aInfo = pList->Get(
2062 pBulletFontNames[i],WEIGHT_NORMAL, ITALIC_NONE);
2063 Font aFont(aInfo);
2064 aFmt.SetBulletFont(&aFont);
2065 }
2066 aSetRule.Set( i, &aFmt );
2067 }
2068 }
2069 rBase.getNewBase()->SetNumRule(aSetRule);
2070 }
2071 }
2072 else
2073 throw lang::IllegalArgumentException();
2074
2075 bDone = true;
2076 break;
2077 }
2078
2079 case RES_PARATR_OUTLINELEVEL:
2080 {
2081 sal_Int16 nLevel = 0;
2082 aValue >>= nLevel;
2083 if( 0 <= nLevel && nLevel <= MAXLEVEL)
2084 rBase.getNewBase()->GetCollection()->SetAttrOutlineLevel( nLevel );
2085
2086 bDone = true;
2087 break;
2088 }
2089
2090 case FN_UNO_FOLLOW_STYLE:
2091 {
2092 OUString sTmp;
2093 aValue >>= sTmp;
2094 String aString;
2095 SwStyleNameMapper::FillUIName(sTmp, aString, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True ) ;
2096 rBase.getNewBase()->SetFollow( aString );
2097
2098 bDone = true;
2099 break;
2100 }
2101 case RES_PAGEDESC :
2102 {
2103 if( MID_PAGEDESC_PAGEDESCNAME == nMemberId)
2104 {
2105 // Sonderbehandlung RES_PAGEDESC
2106 if(aValue.getValueType() != ::getCppuType((const OUString*)0))
2107 throw lang::IllegalArgumentException();
2108 SfxItemSet& rStyleSet = rBase.GetItemSet();
2109
2110 SwFmtPageDesc* pNewDesc = 0;
2111 const SfxPoolItem* pItem;
2112 if(SFX_ITEM_SET == rStyleSet.GetItemState( RES_PAGEDESC, sal_True, &pItem ) )
2113 {
2114 pNewDesc = new SwFmtPageDesc(*((SwFmtPageDesc*)pItem));
2115 }
2116 if(!pNewDesc)
2117 pNewDesc = new SwFmtPageDesc();
2118 OUString uDescName;
2119 aValue >>= uDescName;
2120 String sDescName;
2121 SwStyleNameMapper::FillUIName(uDescName, sDescName, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True );
2122 if(!pNewDesc->GetPageDesc() || pNewDesc->GetPageDesc()->GetName() != sDescName)
2123 {
2124 //sal_uInt16 nCount = pDoc->GetPageDescCnt();
2125 sal_Bool bPut = sal_False;
2126 if(sDescName.Len())
2127 {
2128 SwPageDesc* pPageDesc = ::GetPageDescByName_Impl(*pDoc, sDescName);
2129 if(pPageDesc)
2130 {
2131 pNewDesc->RegisterToPageDesc( *pPageDesc );
2132 bPut = sal_True;
2133 }
2134 else
2135 {
2136 throw lang::IllegalArgumentException();
2137 }
2138 }
2139 if(!bPut)
2140 {
2141 rStyleSet.ClearItem(RES_BREAK);
2142 rStyleSet.Put(SwFmtPageDesc());
2143 }
2144 else
2145 rStyleSet.Put(*pNewDesc);
2146 }
2147
2148 delete pNewDesc;
2149 bDone = true;
2150 }
2151
2152 break;
2153 }
2154 case FN_UNO_IS_AUTO_UPDATE:
2155 {
2156 sal_Bool bAuto = *(sal_Bool*)aValue.getValue();
2157 if(SFX_STYLE_FAMILY_PARA == eFamily)
2158 rBase.getNewBase()->GetCollection()->SetAutoUpdateFmt(bAuto);
2159 else if(SFX_STYLE_FAMILY_FRAME == eFamily)
2160 rBase.getNewBase()->GetFrmFmt()->SetAutoUpdateFmt(bAuto);
2161
2162 bDone = true;
2163 break;
2164 }
2165 case FN_UNO_PARA_STYLE_CONDITIONS:
2166 {
2167 uno::Sequence< beans::NamedValue > aSeq;
2168 if (!(aValue >>= aSeq))
2169 throw lang::IllegalArgumentException();
2170
2171 DBG_ASSERT(COND_COMMAND_COUNT == 28,
2172 "invalid size of comman count?");
2173 const beans::NamedValue *pSeq = aSeq.getConstArray();
2174 sal_Int32 nLen = aSeq.getLength();
2175
2176 sal_Bool bFailed = sal_False;
2177 SwCondCollItem aCondItem;
2178 for(sal_uInt16 i = 0; i < nLen; i++)
2179 {
2180 OUString aTmp;
2181 if ((pSeq[i].Value >>= aTmp))
2182 {
2183 // get UI style name from programmatic style name
2184 String aStyleName;
2185 SwStyleNameMapper::FillUIName( aTmp, aStyleName, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True );
2186
2187 //
2188 // check for correct context and style name
2189 //
2190 sal_Int16 nIdx = GetCommandContextIndex( pSeq[i].Name );
2191 //
2192 pBasePool->SetSearchMask( SFX_STYLE_FAMILY_PARA, SFXSTYLEBIT_ALL );
2193 sal_Bool bStyleFound = sal_False;
2194 const SfxStyleSheetBase* pBase = pBasePool->First();
2195 while (pBase && !bStyleFound)
2196 {
2197 if(pBase->GetName() == aStyleName)
2198 bStyleFound = sal_True;
2199 pBase = pBasePool->Next();
2200 }
2201 //
2202 if (nIdx == -1 || !bStyleFound)
2203 {
2204 bFailed = sal_True;
2205 break;
2206 }
2207
2208 aCondItem.SetStyle( &aStyleName, nIdx);
2209 }
2210 else
2211 bFailed = sal_True;
2212 }
2213 if (bFailed)
2214 throw lang::IllegalArgumentException();
2215 rBase.GetItemSet().Put( aCondItem );
2216 bDone = true;
2217 break;
2218 }
2219 case FN_UNO_CATEGORY:
2220 {
2221 if(!rBase.getNewBase()->IsUserDefined())
2222 throw lang::IllegalArgumentException();
2223 short nSet = 0;
2224 aValue >>= nSet;
2225
2226 sal_uInt16 nId;
2227 switch( nSet )
2228 {
2229 case style::ParagraphStyleCategory::TEXT:
2230 nId = SWSTYLEBIT_TEXT;
2231 break;
2232 case style::ParagraphStyleCategory::CHAPTER:
2233 nId = SWSTYLEBIT_CHAPTER;
2234 break;
2235 case style::ParagraphStyleCategory::LIST:
2236 nId = SWSTYLEBIT_LIST;
2237 break;
2238 case style::ParagraphStyleCategory::INDEX:
2239 nId = SWSTYLEBIT_IDX;
2240 break;
2241 case style::ParagraphStyleCategory::EXTRA:
2242 nId = SWSTYLEBIT_EXTRA;
2243 break;
2244 case style::ParagraphStyleCategory::HTML:
2245 nId = SWSTYLEBIT_HTML;
2246 break;
2247 default: throw lang::IllegalArgumentException();
2248 }
2249
2250 rBase.getNewBase()->SetMask( nId|SFXSTYLEBIT_USERDEF );
2251 bDone = true;
2252 break;
2253 }
2254 case SID_SWREGISTER_COLLECTION:
2255 {
2256 OUString sName;
2257 aValue >>= sName;
2258 SwRegisterItem aReg( sName.getLength() != 0);
2259 aReg.SetWhich(SID_SWREGISTER_MODE);
2260 rBase.GetItemSet().Put(aReg);
2261 String aString;
2262 SwStyleNameMapper::FillUIName(sName, aString, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True);
2263
2264 rBase.GetItemSet().Put(SfxStringItem(SID_SWREGISTER_COLLECTION, aString ) );
2265 bDone = true;
2266 break;
2267 }
2268 case RES_TXTATR_CJK_RUBY:
2269 {
2270 if(MID_RUBY_CHARSTYLE == nMemberId )
2271 {
2272 OUString sTmp;
2273 if(aValue >>= sTmp)
2274 {
2275 SfxItemSet& rStyleSet = rBase.GetItemSet();
2276 SwFmtRuby* pRuby = 0;
2277 const SfxPoolItem* pItem;
2278 if(SFX_ITEM_SET == rStyleSet.GetItemState( RES_TXTATR_CJK_RUBY, sal_True, &pItem ) )
2279 pRuby = new SwFmtRuby(*((SwFmtRuby*)pItem));
2280 if(!pRuby)
2281 pRuby = new SwFmtRuby(aEmptyStr);
2282 String sStyle;
2283 SwStyleNameMapper::FillUIName(sTmp, sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True );
2284 pRuby->SetCharFmtName( sTmp );
2285 pRuby->SetCharFmtId( 0 );
2286 if(sTmp.getLength())
2287 {
2288 sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( sTmp, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
2289 pRuby->SetCharFmtId(nId);
2290 }
2291 rStyleSet.Put(*pRuby);
2292 delete pRuby;
2293 }
2294 else
2295 throw lang::IllegalArgumentException();
2296 }
2297 break;
2298 }
2299 case RES_PARATR_DROP:
2300 {
2301 if( MID_DROPCAP_CHAR_STYLE_NAME == nMemberId)
2302 {
2303 if(aValue.getValueType() == ::getCppuType((const OUString*)0))
2304 {
2305 SfxItemSet& rStyleSet = rBase.GetItemSet();
2306
2307 SwFmtDrop* pDrop = 0;
2308 const SfxPoolItem* pItem;
2309 if(SFX_ITEM_SET == rStyleSet.GetItemState( RES_PARATR_DROP, sal_True, &pItem ) )
2310 pDrop = new SwFmtDrop(*((SwFmtDrop*)pItem));
2311 if(!pDrop)
2312 pDrop = new SwFmtDrop();
2313 OUString uStyle;
2314 aValue >>= uStyle;
2315 String sStyle;
2316 SwStyleNameMapper::FillUIName(uStyle, sStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True );
2317 SwDocStyleSheet* pStyle =
2318 (SwDocStyleSheet*)pDoc->GetDocShell()->GetStyleSheetPool()->Find(sStyle, SFX_STYLE_FAMILY_CHAR);
2319 if(pStyle)
2320 pDrop->SetCharFmt(pStyle->GetCharFmt());
2321 else
2322 throw lang::IllegalArgumentException();
2323 rStyleSet.Put(*pDrop);
2324 delete pDrop;
2325 }
2326 else
2327 throw lang::IllegalArgumentException();
2328
2329 bDone = true;
2330 }
2331 break;
2332 }
2333 default:
2334 {
2335 // nothing to do
2336 break;
2337 }
2338 }
2339
2340 if(!bDone)
2341 {
2342 // default ItemSet handling
2343 SfxItemSet& rStyleSet = rBase.GetItemSet();
2344 SfxItemSet aSet(*rStyleSet.GetPool(), rEntry.nWID, rEntry.nWID);
2345 aSet.SetParent(&rStyleSet);
2346 rPropSet.setPropertyValue(rEntry, aValue, aSet);
2347 rStyleSet.Put(aSet);
2348
2349 // --> OD 2006-10-18 #i70223#
2350 if ( SFX_STYLE_FAMILY_PARA == eFamily &&
2351 rEntry.nWID == RES_PARATR_NUMRULE &&
2352 rBase.getNewBase().is() && rBase.getNewBase()->GetCollection() &&
2353 //rBase.getNewBase()->GetCollection()->GetOutlineLevel() < MAXLEVEL /* assigned to list level of outline style */) //#outline level,removed by zhaojianwei
2354 rBase.getNewBase()->GetCollection()->IsAssignedToListLevelOfOutlineStyle() ) ////<-end,add by zhaojianwei
2355 {
2356 OUString sNewNumberingRuleName;
2357 aValue >>= sNewNumberingRuleName;
2358 String sTmp( sNewNumberingRuleName );
2359 if ( sNewNumberingRuleName.getLength() == 0 || sTmp != pDoc->GetOutlineNumRule()->GetName() )
2360 {
2361 // delete assignment to list level of outline style.
2362 //rBase.getNewBase()->GetCollection()->SetOutlineLevel( NO_NUMBERING ); //#outline level,removed by zhaojianwei
2363 rBase.getNewBase()->GetCollection()->DeleteAssignmentToListLevelOfOutlineStyle(); //<-end,adde by zhaojianwei
2364 }
2365 }
2366 }
2367 }
2368 /* -----------------------------18.04.01 13:29--------------------------------
2369
2370 ---------------------------------------------------------------------------*/
SetPropertyValues_Impl(const uno::Sequence<OUString> & rPropertyNames,const uno::Sequence<uno::Any> & rValues)2371 void SAL_CALL SwXStyle::SetPropertyValues_Impl(
2372 const uno::Sequence< OUString >& rPropertyNames,
2373 const uno::Sequence< uno::Any >& rValues )
2374 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
2375 {
2376 if ( !m_pDoc )
2377 throw uno::RuntimeException();
2378
2379 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_STYLE;
2380
2381 switch(eFamily)
2382 {
2383 case SFX_STYLE_FAMILY_PARA : nPropSetId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE; break;
2384 case SFX_STYLE_FAMILY_FRAME : nPropSetId = PROPERTY_MAP_FRAME_STYLE ;break;
2385 case SFX_STYLE_FAMILY_PAGE : nPropSetId = PROPERTY_MAP_PAGE_STYLE ;break;
2386 case SFX_STYLE_FAMILY_PSEUDO: nPropSetId = PROPERTY_MAP_NUM_STYLE ;break;
2387 default: ;
2388 }
2389
2390 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
2391 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
2392
2393 if(rPropertyNames.getLength() != rValues.getLength())
2394 {
2395 throw lang::IllegalArgumentException();
2396 }
2397
2398 const OUString* pNames = rPropertyNames.getConstArray();
2399 const uno::Any* pValues = rValues.getConstArray();
2400 SwStyleBase_Impl aBaseImpl(*m_pDoc, sStyleName, &GetDoc()->GetDfltTxtFmtColl()->GetAttrSet()); //UUUU add pDfltTxtFmtColl as parent
2401
2402 if(pBasePool)
2403 {
2404 sal_uInt16 nSaveMask = pBasePool->GetSearchMask();
2405 pBasePool->SetSearchMask(eFamily);
2406 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
2407 pBasePool->SetSearchMask(eFamily, nSaveMask );
2408 DBG_ASSERT(pBase, "where is the style?" );
2409
2410 if(pBase)
2411 aBaseImpl.setNewBase(new SwDocStyleSheet(*(SwDocStyleSheet*)pBase));
2412 else
2413 throw uno::RuntimeException();
2414 }
2415
2416 for(sal_Int16 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
2417 {
2418 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(pNames[nProp]);
2419
2420 if(!pEntry ||
2421 (!bIsConditional && pNames[nProp].equalsAsciiL(SW_PROP_NAME(UNO_NAME_PARA_STYLE_CONDITIONS))))
2422 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pNames[nProp], static_cast < cppu::OWeakObject * > ( this ) );
2423 if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
2424 throw beans::PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + pNames[nProp], static_cast < cppu::OWeakObject * > ( this ) );
2425
2426 if(aBaseImpl.getNewBase().is())
2427 {
2428 lcl_SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl, pBasePool, m_pDoc, eFamily);
2429 }
2430 else if(bIsDescriptor)
2431 {
2432 if(!pPropImpl->SetProperty(pNames[nProp], pValues[nProp]))
2433 {
2434 throw lang::IllegalArgumentException();
2435 }
2436 }
2437 else
2438 {
2439 throw uno::RuntimeException();
2440 }
2441 }
2442
2443 if(aBaseImpl.HasItemSet())
2444 {
2445 aBaseImpl.getNewBase()->SetItemSet(aBaseImpl.GetItemSet());
2446 }
2447 }
2448
setPropertyValues(const uno::Sequence<OUString> & rPropertyNames,const uno::Sequence<uno::Any> & rValues)2449 void SwXStyle::setPropertyValues(
2450 const uno::Sequence< OUString >& rPropertyNames,
2451 const uno::Sequence< uno::Any >& rValues )
2452 throw(beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
2453 {
2454 vos::OGuard aGuard(Application::GetSolarMutex());
2455
2456 // workaround for bad designed API
2457 try
2458 {
2459 SetPropertyValues_Impl( rPropertyNames, rValues );
2460 }
2461 catch (beans::UnknownPropertyException &rException)
2462 {
2463 // wrap the original (here not allowed) exception in
2464 // a lang::WrappedTargetException that gets thrown instead.
2465 lang::WrappedTargetException aWExc;
2466 aWExc.TargetException <<= rException;
2467 throw aWExc;
2468 }
2469 }
2470
2471
lcl_GetStyleProperty(const SfxItemPropertySimpleEntry & rEntry,const SfxItemPropertySet & rPropSet,SwStyleBase_Impl & rBase,SfxStyleSheetBase * pBase,SfxStyleFamily eFamily,SwDoc * pDoc)2472 uno::Any lcl_GetStyleProperty(
2473 const SfxItemPropertySimpleEntry& rEntry,
2474 const SfxItemPropertySet& rPropSet,
2475 SwStyleBase_Impl& rBase,
2476 SfxStyleSheetBase* pBase,
2477 SfxStyleFamily eFamily,
2478 SwDoc *pDoc)
2479 throw(uno::RuntimeException)
2480 {
2481 uno::Any aRet;
2482
2483 if(FN_UNO_IS_PHYSICAL == rEntry.nWID)
2484 {
2485 sal_Bool bPhys = pBase != 0;
2486 if(pBase)
2487 {
2488 bPhys = ((SwDocStyleSheet*)pBase)->IsPhysical();
2489 // The standard character format is not existing physically
2490 if( bPhys && SFX_STYLE_FAMILY_CHAR == eFamily &&
2491 ((SwDocStyleSheet*)pBase)->GetCharFmt() &&
2492 ((SwDocStyleSheet*)pBase)->GetCharFmt()->IsDefault() )
2493 bPhys = sal_False;
2494 }
2495 aRet.setValue(&bPhys, ::getBooleanCppuType());
2496 }
2497 else if(pBase)
2498 {
2499 if(!rBase.getNewBase().is())
2500 {
2501 rBase.setNewBase(new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ));
2502 }
2503
2504 //UUUU
2505 const sal_uInt8 nMemberId(rEntry.nMemberId & (~SFX_METRIC_ITEM));
2506
2507 //UUUU adapted switch logic to a more readable state; removed goto's and made
2508 // execution of standard setting of proerty in ItemSet dependent of this variable
2509 bool bDone(false);
2510
2511 switch(rEntry.nWID)
2512 {
2513 case RES_PAPER_BIN:
2514 {
2515 SfxItemSet& rSet = rBase.GetItemSet();
2516 rPropSet.getPropertyValue(rEntry, rSet, aRet);
2517 sal_Int8 nBin = 0;
2518 aRet >>= nBin;
2519 if ( nBin == -1 )
2520 aRet <<= OUString ( RTL_CONSTASCII_USTRINGPARAM ( "[From printer settings]" ) );
2521 else
2522 {
2523 SfxPrinter *pPrinter = pDoc->getPrinter( false );
2524 OUString sTmp;
2525 if (pPrinter )
2526 sTmp = pPrinter->GetPaperBinName ( nBin );
2527 aRet <<= sTmp;
2528 }
2529
2530 bDone = true;
2531 break;
2532 }
2533 case FN_UNO_NUM_RULES: //Sonderbehandlung fuer das SvxNumRuleItem:
2534 {
2535 const SwNumRule* pRule = rBase.getNewBase()->GetNumRule();
2536 DBG_ASSERT(pRule, "Wo ist die NumRule?");
2537 uno::Reference< container::XIndexReplace > xRules = new SwXNumberingRules(*pRule);
2538
2539 aRet.setValue(&xRules, ::getCppuType((uno::Reference<container::XIndexReplace>*)0));
2540 bDone = true;
2541 break;
2542 }
2543 break;
2544 //case FN_UNO_DEFAULT_OUTLINE_LEVEL: //#outline level,removed by zahojianwei
2545 //{
2546 // DBG_ASSERT( SFX_STYLE_FAMILY_PARA == eFamily, "only paras" );
2547 // sal_uInt8 nLevel = rBase.getNewBase()->GetCollection()->GetOutlineLevel();
2548 // if( nLevel != NO_NUMBERING )
2549 // aRet <<= static_cast<sal_Int8>( nLevel );
2550 // bDone = true;
2551 // break;
2552 //}
2553 case RES_PARATR_OUTLINELEVEL: //add by zahojianwei
2554 {
2555 DBG_ASSERT( SFX_STYLE_FAMILY_PARA == eFamily, "only paras" );
2556 int nLevel = rBase.getNewBase()->GetCollection()->GetAttrOutlineLevel();
2557
2558 aRet <<= static_cast<sal_Int16>( nLevel );
2559 bDone = true;
2560 break;
2561 } //<-end,zhaojianwei
2562 case FN_UNO_FOLLOW_STYLE:
2563 {
2564 String aString;
2565
2566 SwStyleNameMapper::FillProgName(rBase.getNewBase()->GetFollow(), aString, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True);
2567 aRet <<= OUString( aString );
2568 bDone = true;
2569 break;
2570 }
2571 case RES_PAGEDESC :
2572 {
2573 if( MID_PAGEDESC_PAGEDESCNAME == nMemberId)
2574 {
2575 // Sonderbehandlung RES_PAGEDESC
2576 const SfxPoolItem* pItem;
2577 if(SFX_ITEM_SET == rBase.GetItemSet().GetItemState( RES_PAGEDESC, sal_True, &pItem ) )
2578 {
2579 const SwPageDesc* pDesc = ((const SwFmtPageDesc*)pItem)->GetPageDesc();
2580 if(pDesc)
2581 {
2582 String aString;
2583 SwStyleNameMapper::FillProgName(pDesc->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True );
2584 aRet <<= OUString( aString );
2585 }
2586 }
2587
2588 bDone = true;
2589 }
2590
2591 break;
2592 }
2593 case FN_UNO_IS_AUTO_UPDATE:
2594 {
2595 sal_Bool bAuto = sal_False;
2596 if(SFX_STYLE_FAMILY_PARA == eFamily)
2597 bAuto = rBase.getNewBase()->GetCollection()->IsAutoUpdateFmt();
2598 else if(SFX_STYLE_FAMILY_FRAME == eFamily)
2599 bAuto = rBase.getNewBase()->GetFrmFmt()->IsAutoUpdateFmt();
2600 aRet.setValue(&bAuto, ::getBooleanCppuType());
2601
2602 bDone = true;
2603 break;
2604 }
2605 case FN_UNO_DISPLAY_NAME:
2606 {
2607 OUString sName(rBase.getNewBase()->GetDisplayName());
2608 aRet <<= sName;
2609
2610 bDone = true;
2611 break;
2612 }
2613 case FN_UNO_PARA_STYLE_CONDITIONS:
2614 {
2615 DBG_ASSERT(COND_COMMAND_COUNT == 28,
2616 "invalid size of comman count?");
2617 //SfxItemSet& rStyleSet = rBase.GetItemSet();
2618 uno::Sequence< beans::NamedValue > aSeq(COND_COMMAND_COUNT);
2619 beans::NamedValue *pSeq = aSeq.getArray();
2620
2621 SwFmt *pFmt = ((SwDocStyleSheet*)pBase)->GetCollection();
2622 const CommandStruct *pCmds = SwCondCollItem::GetCmds();
2623 for (sal_uInt16 n = 0; n < COND_COMMAND_COUNT; ++n)
2624 {
2625 String aStyleName;
2626
2627 const SwCollCondition* pCond = 0;
2628 if( pFmt && RES_CONDTXTFMTCOLL == pFmt->Which() &&
2629 0 != ( pCond = ((SwConditionTxtFmtColl*)pFmt)->
2630 HasCondition( SwCollCondition( 0, pCmds[n].nCnd, pCmds[n].nSubCond ) ) )
2631 && pCond->GetTxtFmtColl() )
2632 {
2633 // get programmatic style name from UI style name
2634 aStyleName = pCond->GetTxtFmtColl()->GetName();
2635 SwStyleNameMapper::FillProgName(aStyleName, aStyleName, lcl_GetSwEnumFromSfxEnum ( eFamily ), sal_True);
2636 }
2637
2638 pSeq[n].Name = GetCommandContextByIndex(n);
2639 pSeq[n].Value <<= rtl::OUString( aStyleName );
2640 }
2641 aRet <<= aSeq;
2642
2643 bDone = true;
2644 break;
2645 }
2646 case FN_UNO_CATEGORY:
2647 {
2648 sal_uInt16 nPoolId = rBase.getNewBase()->GetCollection()->GetPoolFmtId();
2649 short nRet = -1;
2650
2651 switch ( COLL_GET_RANGE_BITS & nPoolId )
2652 {
2653 case COLL_TEXT_BITS:
2654 nRet = style::ParagraphStyleCategory::TEXT;
2655 break;
2656 case COLL_DOC_BITS:
2657 nRet = style::ParagraphStyleCategory::CHAPTER;
2658 break;
2659 case COLL_LISTS_BITS:
2660 nRet = style::ParagraphStyleCategory::LIST;
2661 break;
2662 case COLL_REGISTER_BITS:
2663 nRet = style::ParagraphStyleCategory::INDEX;
2664 break;
2665 case COLL_EXTRA_BITS:
2666 nRet = style::ParagraphStyleCategory::EXTRA;
2667 break;
2668 case COLL_HTML_BITS:
2669 nRet = style::ParagraphStyleCategory::HTML;
2670 break;
2671 }
2672
2673 aRet <<= nRet;
2674 bDone = true;
2675 break;
2676 }
2677 case SID_SWREGISTER_COLLECTION:
2678 {
2679 const SwPageDesc *pPageDesc = rBase.getNewBase()->GetPageDesc();
2680 const SwTxtFmtColl* pCol = 0;
2681 String aString;
2682 if( pPageDesc )
2683 pCol = pPageDesc->GetRegisterFmtColl();
2684 if( pCol )
2685 SwStyleNameMapper::FillProgName(
2686 pCol->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True );
2687
2688 aRet <<= OUString ( aString );
2689 bDone = true;
2690 break;
2691 }
2692 case RES_BACKGROUND:
2693 {
2694 //UUUU
2695 const SfxItemSet& rSet = rBase.GetItemSet();
2696 const SvxBrushItem aOriginalBrushItem(getSvxBrushItemFromSourceSet(rSet, RES_BACKGROUND));
2697
2698 if(!aOriginalBrushItem.QueryValue(aRet, nMemberId))
2699 {
2700 OSL_ENSURE(false, "Error getting attribute from RES_BACKGROUND (!)");
2701 }
2702
2703 bDone = true;
2704 break;
2705 }
2706 case OWN_ATTR_FILLBMP_MODE:
2707 {
2708 //UUUU
2709 const SfxItemSet& rSet = rBase.GetItemSet();
2710 const XFillBmpStretchItem* pStretchItem = dynamic_cast< const XFillBmpStretchItem* >(&rSet.Get(XATTR_FILLBMP_STRETCH));
2711 const XFillBmpTileItem* pTileItem = dynamic_cast< const XFillBmpTileItem* >(&rSet.Get(XATTR_FILLBMP_TILE));
2712
2713 if( pTileItem && pTileItem->GetValue() )
2714 {
2715 aRet <<= drawing::BitmapMode_REPEAT;
2716 }
2717 else if( pStretchItem && pStretchItem->GetValue() )
2718 {
2719 aRet <<= drawing::BitmapMode_STRETCH;
2720 }
2721 else
2722 {
2723 aRet <<= drawing::BitmapMode_NO_REPEAT;
2724 }
2725
2726 bDone = true;
2727 break;
2728 }
2729 default:
2730 {
2731 // nothing to do as default
2732 break;
2733 }
2734 }
2735
2736 if(!bDone)
2737 {
2738 SfxItemSet& rSet = rBase.GetItemSet();
2739 rPropSet.getPropertyValue(rEntry, rSet, aRet);
2740
2741 //UUUU
2742 if(rEntry.pType && *(rEntry.pType) == ::getCppuType((const sal_Int16*)0) && *(rEntry.pType) != aRet.getValueType())
2743 {
2744 // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
2745 sal_Int32 nValue = 0;
2746 aRet >>= nValue;
2747 aRet <<= (sal_Int16)nValue;
2748 }
2749
2750 //UUUU check for needed metric translation
2751 if(rEntry.nMemberId & SFX_METRIC_ITEM)
2752 {
2753 bool bDoIt(true);
2754
2755 if(XATTR_FILLBMP_SIZEX == rEntry.nWID || XATTR_FILLBMP_SIZEY == rEntry.nWID)
2756 {
2757 // exception: If these ItemTypes are used, do not convert when these are negative
2758 // since this means they are intended as percent values
2759 sal_Int32 nValue = 0;
2760
2761 if(aRet >>= nValue)
2762 {
2763 bDoIt = nValue > 0;
2764 }
2765 }
2766
2767 if(bDoIt && pDoc)
2768 {
2769 const SfxItemPool& rPool = pDoc->GetAttrPool();
2770 const SfxMapUnit eMapUnit(rPool.GetMetric(rEntry.nWID));
2771
2772 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
2773 {
2774 SvxUnoConvertToMM(eMapUnit, aRet);
2775 }
2776 }
2777 }
2778 }
2779 }
2780 else
2781 {
2782 throw uno::RuntimeException();
2783 }
2784
2785 return aRet;
2786 }
2787 /* -----------------------------19.04.01 09:26--------------------------------
2788
2789 ---------------------------------------------------------------------------*/
GetPropertyValues_Impl(const uno::Sequence<OUString> & rPropertyNames)2790 uno::Sequence< uno::Any > SAL_CALL SwXStyle::GetPropertyValues_Impl(
2791 const uno::Sequence< OUString > & rPropertyNames )
2792 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2793 {
2794 if ( !m_pDoc )
2795 throw uno::RuntimeException();
2796
2797 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_STYLE;
2798
2799 switch(eFamily)
2800 {
2801 case SFX_STYLE_FAMILY_PARA : nPropSetId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE; break;
2802 case SFX_STYLE_FAMILY_FRAME : nPropSetId = PROPERTY_MAP_FRAME_STYLE ;break;
2803 case SFX_STYLE_FAMILY_PAGE : nPropSetId = PROPERTY_MAP_PAGE_STYLE ;break;
2804 case SFX_STYLE_FAMILY_PSEUDO: nPropSetId = PROPERTY_MAP_NUM_STYLE ;break;
2805 default: ;
2806 }
2807
2808 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
2809 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
2810 const OUString* pNames = rPropertyNames.getConstArray();
2811 uno::Sequence< uno::Any > aRet(rPropertyNames.getLength());
2812 uno::Any* pRet = aRet.getArray();
2813 SwStyleBase_Impl aBase(*m_pDoc, sStyleName, &GetDoc()->GetDfltTxtFmtColl()->GetAttrSet()); //UUUU add pDfltTxtFmtColl as parent
2814 SfxStyleSheetBase* pBase = 0;
2815
2816 for(sal_Int32 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
2817 {
2818 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( pNames[nProp]);
2819 if(!pEntry ||
2820 (!bIsConditional && pNames[nProp].equalsAsciiL(SW_PROP_NAME(UNO_NAME_PARA_STYLE_CONDITIONS))))
2821 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + pNames[nProp], static_cast < cppu::OWeakObject * > ( this ) );
2822
2823 if(pBasePool)
2824 {
2825 if(!pBase)
2826 {
2827 sal_uInt16 nSaveMask = pBasePool->GetSearchMask();
2828 pBasePool->SetSearchMask(eFamily, SFXSTYLEBIT_ALL );
2829 pBase = pBasePool->Find(sStyleName);
2830 pBasePool->SetSearchMask(eFamily, nSaveMask );
2831 }
2832
2833 pRet[nProp] = lcl_GetStyleProperty(*pEntry, *pPropSet, aBase, pBase, eFamily, GetDoc() );
2834 }
2835 else if(bIsDescriptor)
2836 {
2837 uno::Any *pAny = 0;
2838 pPropImpl->GetProperty ( pNames[nProp], pAny );
2839 if( !pAny )
2840 {
2841 sal_Bool bExcept = sal_False;
2842 switch( eFamily )
2843 {
2844 case SFX_STYLE_FAMILY_PSEUDO:
2845 bExcept = sal_True;
2846 break;
2847 case SFX_STYLE_FAMILY_PARA:
2848 case SFX_STYLE_FAMILY_PAGE:
2849 pPropImpl->GetProperty ( pNames[nProp], mxStyleData, pRet[ nProp ] );
2850 break;
2851 case SFX_STYLE_FAMILY_CHAR:
2852 case SFX_STYLE_FAMILY_FRAME :
2853 {
2854 if (pEntry->nWID >= POOLATTR_BEGIN && pEntry->nWID < RES_UNKNOWNATR_END )
2855 {
2856 SwFmt * pFmt;
2857 if ( eFamily == SFX_STYLE_FAMILY_CHAR )
2858 pFmt = m_pDoc->GetDfltCharFmt();
2859 else
2860 pFmt = m_pDoc->GetDfltFrmFmt();
2861 const SwAttrPool * pPool = pFmt->GetAttrSet().GetPool();
2862 const SfxPoolItem & rItem = pPool->GetDefaultItem ( pEntry->nWID );
2863 rItem.QueryValue ( pRet[nProp], pEntry->nMemberId );
2864 }
2865 else
2866 bExcept = sal_True;
2867 }
2868 break;
2869
2870 default:
2871 ;
2872 }
2873 if (bExcept )
2874 {
2875 uno::RuntimeException aExcept;
2876 aExcept.Message = OUString ( RTL_CONSTASCII_USTRINGPARAM ( "No default value for: " ) ) + pNames[nProp];
2877 throw aExcept;
2878 }
2879 }
2880 else
2881 pRet [ nProp ] = *pAny;
2882 }
2883 else
2884 throw uno::RuntimeException();
2885 }
2886 return aRet;
2887 }
2888 /* -----------------------------04.11.03 09:26--------------------------------
2889
2890 ---------------------------------------------------------------------------*/
getPropertyValues(const uno::Sequence<OUString> & rPropertyNames)2891 uno::Sequence< uno::Any > SwXStyle::getPropertyValues(
2892 const uno::Sequence< OUString >& rPropertyNames )
2893 throw(uno::RuntimeException)
2894 {
2895 vos::OGuard aGuard(Application::GetSolarMutex());
2896 uno::Sequence< uno::Any > aValues;
2897
2898 // workaround for bad designed API
2899 try
2900 {
2901 aValues = GetPropertyValues_Impl( rPropertyNames );
2902 }
2903 catch (beans::UnknownPropertyException &)
2904 {
2905 throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property exception caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
2906 }
2907 catch (lang::WrappedTargetException &)
2908 {
2909 throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "WrappedTargetException caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
2910 }
2911
2912 return aValues;
2913 }
2914 /*-- 18.04.01 13:07:29---------------------------------------------------
2915 -----------------------------------------------------------------------*/
addPropertiesChangeListener(const uno::Sequence<OUString> &,const uno::Reference<beans::XPropertiesChangeListener> &)2916 void SwXStyle::addPropertiesChangeListener(
2917 const uno::Sequence< OUString >& /*aPropertyNames*/,
2918 const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
2919 throw(uno::RuntimeException)
2920 {
2921 }
2922 /*-- 18.04.01 13:07:30---------------------------------------------------
2923
2924 -----------------------------------------------------------------------*/
removePropertiesChangeListener(const uno::Reference<beans::XPropertiesChangeListener> &)2925 void SwXStyle::removePropertiesChangeListener(
2926 const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
2927 throw(uno::RuntimeException)
2928 {
2929 }
2930 /*-- 18.04.01 13:07:30---------------------------------------------------
2931
2932 -----------------------------------------------------------------------*/
firePropertiesChangeEvent(const uno::Sequence<OUString> &,const uno::Reference<beans::XPropertiesChangeListener> &)2933 void SwXStyle::firePropertiesChangeEvent(
2934 const uno::Sequence< OUString >& /*aPropertyNames*/,
2935 const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
2936 throw(uno::RuntimeException)
2937 {
2938 }
2939 /*-- 17.12.98 08:26:53---------------------------------------------------
2940
2941 -----------------------------------------------------------------------*/
setPropertyValue(const OUString & rPropertyName,const uno::Any & rValue)2942 void SwXStyle::setPropertyValue(
2943 const OUString& rPropertyName,
2944 const uno::Any& rValue)
2945 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
2946 {
2947 vos::OGuard aGuard(Application::GetSolarMutex());
2948 const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
2949 const uno::Sequence<uno::Any> aValues(&rValue, 1);
2950
2951 SetPropertyValues_Impl( aProperties, aValues );
2952 }
2953 /*-- 17.12.98 08:26:53---------------------------------------------------
2954
2955 -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)2956 uno::Any SwXStyle::getPropertyValue(
2957 const OUString& rPropertyName)
2958 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2959 {
2960 vos::OGuard aGuard(Application::GetSolarMutex());
2961 const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
2962 return GetPropertyValues_Impl(aProperties).getConstArray()[0];
2963
2964 }
2965 /*-- 17.12.98 08:26:53---------------------------------------------------
2966
2967 -----------------------------------------------------------------------*/
addPropertyChangeListener(const OUString &,const uno::Reference<beans::XPropertyChangeListener> &)2968 void SwXStyle::addPropertyChangeListener(
2969 const OUString& /*rPropertyName*/,
2970 const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/)
2971 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2972 {
2973 DBG_WARNING("not implemented");
2974 }
2975 /*-- 17.12.98 08:26:54---------------------------------------------------
2976
2977 -----------------------------------------------------------------------*/
removePropertyChangeListener(const OUString &,const uno::Reference<beans::XPropertyChangeListener> &)2978 void SwXStyle::removePropertyChangeListener(
2979 const OUString& /*rPropertyName*/,
2980 const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/)
2981 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2982 {
2983 DBG_WARNING("not implemented");
2984 }
2985 /*-- 17.12.98 08:26:54---------------------------------------------------
2986
2987 -----------------------------------------------------------------------*/
addVetoableChangeListener(const OUString &,const uno::Reference<beans::XVetoableChangeListener> &)2988 void SwXStyle::addVetoableChangeListener(
2989 const OUString& /*rPropertyName*/,
2990 const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/)
2991 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
2992 {
2993 DBG_WARNING("not implemented");
2994 }
2995 /*-- 17.12.98 08:26:54---------------------------------------------------
2996
2997 -----------------------------------------------------------------------*/
removeVetoableChangeListener(const OUString &,const uno::Reference<beans::XVetoableChangeListener> &)2998 void SwXStyle::removeVetoableChangeListener(
2999 const OUString& /*rPropertyName*/,
3000 const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/)
3001 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
3002 {
3003 DBG_WARNING("not implemented");
3004 }
3005
3006 /*-- 08.03.99 10:50:26---------------------------------------------------
3007
3008 -----------------------------------------------------------------------*/
getPropertyState(const OUString & rPropertyName)3009 beans::PropertyState SwXStyle::getPropertyState(
3010 const OUString& rPropertyName)
3011 throw( beans::UnknownPropertyException, uno::RuntimeException )
3012 {
3013 vos::OGuard aGuard(Application::GetSolarMutex());
3014 uno::Sequence< OUString > aNames(1);
3015 OUString* pNames = aNames.getArray();
3016 pNames[0] = rPropertyName;
3017 uno::Sequence< beans::PropertyState > aStates = getPropertyStates(aNames);
3018 return aStates.getConstArray()[0];
3019 }
3020 /*-- 08.03.99 10:50:27---------------------------------------------------
3021
3022 -----------------------------------------------------------------------*/
3023
getPropertyStates(const uno::Sequence<OUString> & rPropertyNames)3024 uno::Sequence< beans::PropertyState > SwXStyle::getPropertyStates(
3025 const uno::Sequence< OUString >& rPropertyNames)
3026 throw( beans::UnknownPropertyException, uno::RuntimeException )
3027 {
3028 vos::OGuard aGuard(Application::GetSolarMutex());
3029 uno::Sequence< beans::PropertyState > aRet(rPropertyNames.getLength());
3030 beans::PropertyState* pStates = aRet.getArray();
3031
3032 if(pBasePool)
3033 {
3034 pBasePool->SetSearchMask(eFamily );
3035 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
3036 DBG_ASSERT(pBase, "where is the style?" );
3037
3038 if(pBase)
3039 {
3040 const OUString* pNames = rPropertyNames.getConstArray();
3041 rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ) );
3042 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_STYLE;
3043
3044 switch(eFamily)
3045 {
3046 case SFX_STYLE_FAMILY_PARA : nPropSetId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE; break;
3047 case SFX_STYLE_FAMILY_FRAME : nPropSetId = PROPERTY_MAP_FRAME_STYLE ;break;
3048 case SFX_STYLE_FAMILY_PAGE : nPropSetId = PROPERTY_MAP_PAGE_STYLE; break;
3049 case SFX_STYLE_FAMILY_PSEUDO: nPropSetId = PROPERTY_MAP_NUM_STYLE ;break;
3050 default: ;
3051 }
3052
3053 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
3054 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
3055 const SfxItemSet& rSet = xStyle->GetItemSet();
3056
3057 for(sal_Int32 i = 0; i < rPropertyNames.getLength(); i++)
3058 {
3059 const String& rPropName = pNames[i];
3060 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( rPropName);
3061 bool bDone(false);
3062
3063 if(!pEntry)
3064 {
3065 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
3066 }
3067
3068 if( FN_UNO_NUM_RULES == pEntry->nWID || FN_UNO_FOLLOW_STYLE == pEntry->nWID )
3069 {
3070 // handle NumRules first, done
3071 pStates[i] = beans::PropertyState_DIRECT_VALUE;
3072 bDone = true;
3073 }
3074
3075 // allow to retarget the SfxItemSet working on, default correctly. Only
3076 // use pSourceSet below this point (except in header/footer processing)
3077 const SfxItemSet* pSourceSet = &rSet;
3078
3079 if(!bDone)
3080 {
3081 // check for Header/Footer entry
3082 const bool bHeader(SFX_STYLE_FAMILY_PAGE == eFamily && rPropName.EqualsAscii("Header", 0, 6));
3083 const bool bFooter(SFX_STYLE_FAMILY_PAGE == eFamily && rPropName.EqualsAscii("Footer", 0, 6));
3084
3085 if(bHeader || bFooter)
3086 {
3087 const SvxSetItem* pSetItem;
3088
3089 if(SFX_ITEM_SET == rSet.GetItemState(
3090 bFooter ? SID_ATTR_PAGE_FOOTERSET : SID_ATTR_PAGE_HEADERSET,
3091 sal_False,
3092 (const SfxPoolItem**)&pSetItem))
3093 {
3094 // retarget the SfxItemSet to the HeaderFooter SfxSetItem's SfxItenSet
3095 pSourceSet = &pSetItem->GetItemSet();
3096 }
3097 else
3098 {
3099 // if no SetItem, value is ambigous and we are done
3100 pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
3101 bDone = true;
3102 }
3103 }
3104 }
3105
3106 if(!bDone && OWN_ATTR_FILLBMP_MODE == pEntry->nWID)
3107 {
3108 //UUUU
3109 if(SFX_ITEM_SET == pSourceSet->GetItemState(XATTR_FILLBMP_STRETCH, false)
3110 || SFX_ITEM_SET == pSourceSet->GetItemState(XATTR_FILLBMP_TILE, false))
3111 {
3112 pStates[i] = beans::PropertyState_DIRECT_VALUE;
3113 }
3114 else
3115 {
3116 pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
3117 }
3118
3119 bDone = true;
3120 }
3121
3122 //UUUU for FlyFrames we need to mark all properties from type RES_BACKGROUND
3123 // as beans::PropertyState_DIRECT_VALUE to let users of this property call
3124 // getPropertyValue where the member properties will be mapped from the
3125 // fill attributes to the according SvxBrushItem entries
3126 if(!bDone && RES_BACKGROUND == pEntry->nWID
3127 && SWUnoHelper::needToMapFillItemsToSvxBrushItemTypes(*pSourceSet))
3128 {
3129 pStates[i] = beans::PropertyState_DIRECT_VALUE;
3130 bDone = true;
3131 }
3132
3133 if(!bDone)
3134 {
3135 pStates[i] = pPropSet->getPropertyState(*pEntry, *pSourceSet);
3136
3137 if(SFX_STYLE_FAMILY_PAGE == eFamily && SID_ATTR_PAGE_SIZE == pEntry->nWID && beans::PropertyState_DIRECT_VALUE == pStates[i])
3138 {
3139 const SvxSizeItem& rSize = static_cast <const SvxSizeItem&>( rSet.Get(SID_ATTR_PAGE_SIZE));
3140 sal_uInt8 nMemberId = pEntry->nMemberId & 0x7f;
3141
3142 if((LONG_MAX == rSize.GetSize().Width() &&
3143 (MID_SIZE_WIDTH == nMemberId ||
3144 MID_SIZE_SIZE == nMemberId)) ||
3145 (LONG_MAX == rSize.GetSize().Height() &&
3146 MID_SIZE_HEIGHT == nMemberId))
3147 {
3148 pStates[i] = beans::PropertyState_DEFAULT_VALUE;
3149 }
3150 }
3151 }
3152 }
3153 }
3154 else
3155 {
3156 throw uno::RuntimeException();
3157 }
3158 }
3159 else
3160 {
3161 throw uno::RuntimeException();
3162 }
3163
3164 return aRet;
3165 }
3166 /*-- 08.03.99 10:50:27---------------------------------------------------
3167
3168 -----------------------------------------------------------------------*/
setPropertyToDefault(const OUString & rPropertyName)3169 void SwXStyle::setPropertyToDefault(
3170 const OUString& rPropertyName)
3171 throw( beans::UnknownPropertyException, uno::RuntimeException )
3172 {
3173 const uno::Sequence < OUString > aSequence(&rPropertyName,1);
3174 setPropertiesToDefault(aSequence);
3175 }
3176
setPropertiesToDefault(const uno::Sequence<OUString> & aPropertyNames)3177 void SAL_CALL SwXStyle::setPropertiesToDefault(
3178 const uno::Sequence< OUString >& aPropertyNames )
3179 throw (beans::UnknownPropertyException, uno::RuntimeException)
3180 {
3181 vos::OGuard aGuard(Application::GetSolarMutex());
3182 SwFmt *pTargetFmt = 0;
3183
3184 if(pBasePool)
3185 {
3186 pBasePool->SetSearchMask(eFamily);
3187 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
3188 DBG_ASSERT(pBase, "Where is the style?");
3189
3190 if(pBase)
3191 {
3192 rtl::Reference< SwDocStyleSheet > xStyle(new SwDocStyleSheet(*(SwDocStyleSheet*)pBase));
3193 switch(eFamily)
3194 {
3195 case SFX_STYLE_FAMILY_CHAR:
3196 pTargetFmt = xStyle->GetCharFmt();
3197 break;
3198
3199 case SFX_STYLE_FAMILY_PARA:
3200 pTargetFmt = xStyle->GetCollection();
3201 break;
3202
3203 case SFX_STYLE_FAMILY_FRAME:
3204 pTargetFmt = xStyle->GetFrmFmt();
3205 break;
3206
3207 case SFX_STYLE_FAMILY_PAGE:
3208 {
3209 sal_uInt16 nPgDscPos = USHRT_MAX;
3210 SwPageDesc *pDesc = m_pDoc->FindPageDescByName(xStyle->GetPageDesc()->GetName(),&nPgDscPos);
3211
3212 if(pDesc)
3213 {
3214 pTargetFmt = &pDesc->GetMaster();
3215 }
3216 break;
3217 }
3218 case SFX_STYLE_FAMILY_PSEUDO:
3219 break;
3220 default: ;
3221 }
3222 }
3223 }
3224
3225 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_STYLE;
3226
3227 switch(eFamily)
3228 {
3229 case SFX_STYLE_FAMILY_PARA: nPropSetId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE; break;
3230 case SFX_STYLE_FAMILY_FRAME: nPropSetId = PROPERTY_MAP_FRAME_STYLE; break;
3231 case SFX_STYLE_FAMILY_PAGE: nPropSetId = PROPERTY_MAP_PAGE_STYLE; break;
3232 case SFX_STYLE_FAMILY_PSEUDO: nPropSetId = PROPERTY_MAP_NUM_STYLE; break;
3233 default: ;
3234 }
3235
3236 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
3237 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
3238 const OUString* pNames = aPropertyNames.getConstArray();
3239
3240 if(pTargetFmt)
3241 {
3242 for(sal_Int32 nProp = 0,nEnd = aPropertyNames.getLength(); nProp < nEnd; nProp++)
3243 {
3244 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(pNames[nProp]);
3245
3246 if(!pEntry)
3247 {
3248 throw beans::UnknownPropertyException(OUString(RTL_CONSTASCII_USTRINGPARAM("Property is unknown: ")) + pNames[nProp],static_cast <cppu::OWeakObject *> (this));
3249 }
3250
3251 if(pEntry->nWID == FN_UNO_FOLLOW_STYLE || pEntry->nWID == FN_UNO_NUM_RULES)
3252 {
3253 throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("Cannot reset: ")) + pNames[nProp],static_cast <cppu::OWeakObject *> (this));
3254 }
3255
3256 if(pEntry->nFlags & beans::PropertyAttribute::READONLY)
3257 {
3258 throw uno::RuntimeException(OUString(RTL_CONSTASCII_USTRINGPARAM("setPropertiesToDefault: property is read-only: ")) + pNames[nProp],static_cast <cppu::OWeakObject *> (this));
3259 }
3260
3261 if(pEntry->nWID == RES_PARATR_OUTLINELEVEL)
3262 {
3263 static_cast<SwTxtFmtColl*>(pTargetFmt)->DeleteAssignmentToListLevelOfOutlineStyle();
3264 }
3265 else
3266 {
3267 pTargetFmt->ResetFmtAttr(pEntry->nWID);
3268 }
3269
3270 if(OWN_ATTR_FILLBMP_MODE == pEntry->nWID)
3271 {
3272 //UUUU
3273 SwDoc* pDoc = pTargetFmt->GetDoc();
3274 SfxItemSet aSet(pDoc->GetAttrPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST);
3275 aSet.SetParent(&pTargetFmt->GetAttrSet());
3276
3277 aSet.ClearItem(XATTR_FILLBMP_STRETCH);
3278 aSet.ClearItem(XATTR_FILLBMP_TILE);
3279
3280 pTargetFmt->SetFmtAttr(aSet);
3281 }
3282 }
3283 }
3284 else if(bIsDescriptor)
3285 {
3286 for(sal_Int32 nProp = 0,nEnd = aPropertyNames.getLength(); nProp < nEnd; nProp++)
3287 {
3288 pPropImpl->ClearProperty(pNames[nProp]);
3289 }
3290 }
3291 }
3292
setAllPropertiesToDefault()3293 void SAL_CALL SwXStyle::setAllPropertiesToDefault()
3294 throw (uno::RuntimeException)
3295 {
3296 vos::OGuard aGuard(Application::GetSolarMutex());
3297
3298 if(pBasePool)
3299 {
3300 pBasePool->SetSearchMask(eFamily);
3301 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
3302 DBG_ASSERT(pBase, "where is the style, you fiend!?");
3303
3304 if(pBase)
3305 {
3306 rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ) );
3307 SwFmt *pTargetFmt = 0;
3308 sal_uInt16 nPgDscPos = USHRT_MAX;
3309
3310 switch(eFamily)
3311 {
3312 case SFX_STYLE_FAMILY_CHAR:
3313 pTargetFmt = xStyle->GetCharFmt();
3314 break;
3315
3316 case SFX_STYLE_FAMILY_PARA:
3317 {
3318 pTargetFmt = xStyle->GetCollection();
3319
3320 if(xStyle->GetCollection())
3321 {
3322 // xStyle->GetCollection()->SetOutlineLevel( NO_NUMBERING ); //#outline level,removed by zhaojianwei
3323 xStyle->GetCollection()->DeleteAssignmentToListLevelOfOutlineStyle(); //<-end,add by zhaojianwei
3324 }
3325 break;
3326 }
3327
3328 case SFX_STYLE_FAMILY_FRAME:
3329 pTargetFmt = xStyle->GetFrmFmt();
3330 break;
3331
3332 case SFX_STYLE_FAMILY_PAGE:
3333 {
3334 SwPageDesc *pDesc = m_pDoc->FindPageDescByName(xStyle->GetPageDesc()->GetName(),&nPgDscPos);
3335
3336 if(pDesc)
3337 {
3338 pTargetFmt = &pDesc->GetMaster();
3339 pDesc->SetUseOn(nsUseOnPage::PD_ALL);
3340 }
3341 break;
3342 }
3343
3344 case SFX_STYLE_FAMILY_PSEUDO:
3345 break;
3346
3347 default: ;
3348 }
3349
3350 if(pTargetFmt)
3351 {
3352 if(USHRT_MAX != nPgDscPos)
3353 {
3354 SwPageDesc& rPageDesc = m_pDoc->_GetPageDesc(nPgDscPos);
3355 rPageDesc.ResetAllMasterAttr();
3356
3357 SvxLRSpaceItem aLR(RES_LR_SPACE);
3358 sal_Int32 nSize = GetMetricVal(CM_1) * 2;
3359 aLR.SetLeft(nSize);
3360 aLR.SetLeft(nSize);
3361 SvxULSpaceItem aUL(RES_UL_SPACE);
3362 aUL.SetUpper(static_cast <sal_uInt16> (nSize));
3363 aUL.SetLower(static_cast <sal_uInt16> (nSize));
3364 pTargetFmt->SetFmtAttr(aLR);
3365 pTargetFmt->SetFmtAttr(aUL);
3366 SwPageDesc* pStdPgDsc = m_pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD);
3367 SwFmtFrmSize aFrmSz(ATT_FIX_SIZE);
3368
3369 if(RES_POOLPAGE_STANDARD == rPageDesc.GetPoolFmtId())
3370 {
3371 if(m_pDoc->getPrinter(false))
3372 {
3373 const Size aPhysSize(SvxPaperInfo::GetPaperSize(
3374 static_cast<Printer*>(m_pDoc->getPrinter(false))));
3375 aFrmSz.SetSize(aPhysSize);
3376 }
3377 else
3378 {
3379 // --> OD 2008-07-25 #i91928#
3380 // aFrmSz.SetWidth( LONG_MAX );
3381 // aFrmSz.SetHeight( LONG_MAX );
3382 aFrmSz.SetSize(SvxPaperInfo::GetDefaultPaperSize());
3383 // <--
3384 }
3385
3386 }
3387 else
3388 {
3389 aFrmSz = pStdPgDsc->GetMaster().GetFrmSize();
3390 }
3391
3392 if(pStdPgDsc->GetLandscape())
3393 {
3394 SwTwips nTmp = aFrmSz.GetHeight();
3395 aFrmSz.SetHeight(aFrmSz.GetWidth());
3396 aFrmSz.SetWidth(nTmp);
3397 }
3398
3399 pTargetFmt->SetFmtAttr(aFrmSz);
3400 }
3401 else
3402 {
3403 // --> OD 2007-01-25 #i73790# - method renamed
3404 pTargetFmt->ResetAllFmtAttr();
3405 // <--
3406 }
3407
3408 if(USHRT_MAX != nPgDscPos)
3409 {
3410 m_pDoc->ChgPageDesc(nPgDscPos, const_cast<const SwDoc *>(m_pDoc)->GetPageDesc(nPgDscPos));
3411 }
3412 }
3413
3414 }
3415 else
3416 {
3417 throw uno::RuntimeException();
3418 }
3419 }
3420 else if(bIsDescriptor)
3421 {
3422 pPropImpl->ClearAllProperties();
3423 }
3424 else
3425 {
3426 throw uno::RuntimeException();
3427 }
3428 }
3429
getPropertyDefaults(const uno::Sequence<OUString> & aPropertyNames)3430 uno::Sequence< uno::Any > SAL_CALL SwXStyle::getPropertyDefaults(
3431 const uno::Sequence< OUString >& aPropertyNames )
3432 throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
3433 {
3434 vos::OGuard aGuard(Application::GetSolarMutex());
3435 sal_Int32 nCount = aPropertyNames.getLength();
3436 uno::Sequence < uno::Any > aRet(nCount);
3437
3438 if(nCount)
3439 {
3440 if(pBasePool)
3441 {
3442 pBasePool->SetSearchMask(eFamily);
3443 SfxStyleSheetBase* pBase = pBasePool->Find(sStyleName);
3444 DBG_ASSERT(pBase,"Doesn't seem to be a style!");
3445
3446 if(pBase)
3447 {
3448 rtl::Reference< SwDocStyleSheet > xStyle(new SwDocStyleSheet(*(SwDocStyleSheet*)pBase));
3449 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_STYLE;
3450
3451 switch(eFamily)
3452 {
3453 case SFX_STYLE_FAMILY_PARA: nPropSetId = bIsConditional ? PROPERTY_MAP_CONDITIONAL_PARA_STYLE : PROPERTY_MAP_PARA_STYLE; break;
3454 case SFX_STYLE_FAMILY_FRAME: nPropSetId = PROPERTY_MAP_FRAME_STYLE; break;
3455 case SFX_STYLE_FAMILY_PAGE: nPropSetId = PROPERTY_MAP_PAGE_STYLE; break;
3456 case SFX_STYLE_FAMILY_PSEUDO: nPropSetId = PROPERTY_MAP_NUM_STYLE; break;
3457 default: ;
3458 }
3459
3460 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
3461 const SfxItemPropertyMap* pMap = pPropSet->getPropertyMap();
3462 const SfxItemSet &rSet = xStyle->GetItemSet(),*pParentSet = rSet.GetParent();
3463 const OUString *pNames = aPropertyNames.getConstArray();
3464 uno::Any *pRet = aRet.getArray();
3465
3466 for(sal_Int32 i = 0; i < nCount; i++)
3467 {
3468 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(pNames[i]);
3469
3470 if(!pEntry)
3471 {
3472 throw beans::UnknownPropertyException(OUString(RTL_CONSTASCII_USTRINGPARAM("Unknown property: ")) + pNames[i],static_cast <cppu::OWeakObject *> (this));
3473 }
3474
3475 if(pParentSet)
3476 {
3477 aSwMapProvider.GetPropertySet(nPropSetId)->getPropertyValue(pNames[i],*pParentSet,pRet[i]);
3478 }
3479 else if(pEntry->nWID != rSet.GetPool()->GetSlotId(pEntry->nWID))
3480 {
3481 const SfxPoolItem& rItem = rSet.GetPool()->GetDefaultItem(pEntry->nWID);
3482
3483 rItem.QueryValue(pRet[i], pEntry->nMemberId);
3484 }
3485 }
3486 }
3487 else
3488 {
3489 throw uno::RuntimeException();
3490 }
3491 }
3492 else
3493 {
3494 throw uno::RuntimeException();
3495 }
3496 }
3497 return aRet;
3498 }
3499 /*-- 08.03.99 10:50:27---------------------------------------------------
3500
3501 -----------------------------------------------------------------------*/
getPropertyDefault(const OUString & rPropertyName)3502 uno::Any SwXStyle::getPropertyDefault(
3503 const OUString& rPropertyName)
3504 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
3505 {
3506 const uno::Sequence < OUString > aSequence(&rPropertyName,1);
3507 return getPropertyDefaults(aSequence).getConstArray()[0];
3508 }
3509 /* -----------------21.01.99 13:08-------------------
3510 *
3511 * --------------------------------------------------*/
Notify(SfxBroadcaster & rBC,const SfxHint & rHint)3512 void SwXStyle::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )
3513 {
3514 SfxSimpleHint *pHint = PTR_CAST( SfxSimpleHint, &rHint );
3515 if( pHint )
3516 {
3517 if(( pHint->GetId() & SFX_HINT_DYING ) || ( pHint->GetId() & SFX_STYLESHEET_ERASED))
3518 {
3519 pBasePool = 0;
3520 EndListening(rBC);
3521 }
3522 else if( pHint->GetId() &(SFX_STYLESHEET_CHANGED|SFX_STYLESHEET_ERASED) )
3523 {
3524 ((SfxStyleSheetBasePool&)rBC).SetSearchMask(eFamily);
3525 SfxStyleSheetBase* pOwnBase = ((SfxStyleSheetBasePool&)rBC).Find(sStyleName);
3526 if(!pOwnBase)
3527 {
3528 EndListening(rBC);
3529 Invalidate();
3530 }
3531 }
3532 }
3533 }
3534 /* -----------------------------15.08.00 11:35--------------------------------
3535
3536 ---------------------------------------------------------------------------*/
Invalidate()3537 void SwXStyle::Invalidate()
3538 {
3539 sStyleName.Erase();
3540 pBasePool = 0;
3541 m_pDoc = 0;
3542 mxStyleData.clear();
3543 mxStyleFamily.clear();
3544 }
3545
3546
3547 /******************************************************************
3548 * SwXPageStyle
3549 ******************************************************************/
3550 /*-- 17.12.98 08:43:35---------------------------------------------------
3551
3552 -----------------------------------------------------------------------*/
SwXPageStyle(SfxStyleSheetBasePool & rPool,SwDocShell * pDocSh,SfxStyleFamily eFam,const String & rStyleName)3553 SwXPageStyle::SwXPageStyle(
3554 SfxStyleSheetBasePool& rPool,
3555 SwDocShell* pDocSh, SfxStyleFamily eFam,
3556 const String& rStyleName)
3557 : SwXStyle(rPool, eFam, pDocSh->GetDoc(), rStyleName),
3558 pDocShell(pDocSh)
3559 {
3560 }
3561 /* -----------------23.08.99 15:52-------------------
3562
3563 --------------------------------------------------*/
SwXPageStyle(SwDocShell * pDocSh)3564 SwXPageStyle::SwXPageStyle(SwDocShell* pDocSh)
3565 : SwXStyle(pDocSh->GetDoc(), SFX_STYLE_FAMILY_PAGE),
3566 pDocShell(pDocSh)
3567 {
3568 }
3569
3570 /*-- 17.12.98 08:43:35---------------------------------------------------
3571
3572 -----------------------------------------------------------------------*/
~SwXPageStyle()3573 SwXPageStyle::~SwXPageStyle()
3574 {
3575
3576 }
3577 /* -----------------------------18.04.01 13:50--------------------------------
3578
3579 ---------------------------------------------------------------------------*/
SetPropertyValues_Impl(const uno::Sequence<OUString> & rPropertyNames,const uno::Sequence<uno::Any> & rValues)3580 void SAL_CALL SwXPageStyle::SetPropertyValues_Impl(
3581 const uno::Sequence< OUString >& rPropertyNames,
3582 const uno::Sequence< uno::Any >& rValues )
3583 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
3584 {
3585 if(!GetDoc())
3586 throw uno::RuntimeException();
3587
3588 if(rPropertyNames.getLength() != rValues.getLength())
3589 throw lang::IllegalArgumentException();
3590
3591 const OUString* pNames = rPropertyNames.getConstArray();
3592 const uno::Any* pValues = rValues.getConstArray();
3593 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PAGE_STYLE);
3594 const SfxItemPropertyMap* pMap = pPropSet->getPropertyMap();
3595 SwStyleBase_Impl aBaseImpl(*GetDoc(), GetStyleName(), &GetDoc()->GetDfltFrmFmt()->GetAttrSet()); //UUUU add pDfltFrmFmt as parent
3596
3597 if(GetBasePool())
3598 {
3599 sal_uInt16 nSaveMask = GetBasePool()->GetSearchMask();
3600 GetBasePool()->SetSearchMask(GetFamily());
3601 SfxStyleSheetBase* pBase = GetBasePool()->Find(GetStyleName());
3602 GetBasePool()->SetSearchMask(GetFamily(), nSaveMask );
3603 DBG_ASSERT(pBase, "where is the style?" );
3604
3605 if(pBase)
3606 {
3607 aBaseImpl.setNewBase(new SwDocStyleSheet(*(SwDocStyleSheet*)pBase));
3608 }
3609 else
3610 {
3611 throw uno::RuntimeException();
3612 }
3613 }
3614
3615 for(sal_Int16 nProp = 0; nProp < rPropertyNames.getLength(); nProp++)
3616 {
3617 const String& rPropName = pNames[nProp];
3618 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( rPropName );
3619
3620 if (!pEntry)
3621 {
3622 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
3623 }
3624
3625 if ( pEntry->nFlags & beans::PropertyAttribute::READONLY)
3626 {
3627 throw beans::PropertyVetoException ( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
3628 }
3629
3630 if(GetBasePool())
3631 {
3632 switch(pEntry->nWID)
3633 {
3634 case SID_ATTR_PAGE_ON:
3635 case RES_BACKGROUND:
3636 case RES_BOX:
3637 case RES_LR_SPACE:
3638 case RES_SHADOW:
3639 case RES_UL_SPACE:
3640 case SID_ATTR_PAGE_DYNAMIC:
3641 case SID_ATTR_PAGE_SHARED:
3642 case SID_ATTR_PAGE_SIZE:
3643 case RES_HEADER_FOOTER_EAT_SPACING:
3644 {
3645 // these entries are used in Header, Footer and (partially) in the PageStyle itself.
3646 // Check for Header/Footer entry
3647 const bool bHeader(rPropName.EqualsAscii("Header", 0, 6));
3648 const bool bFooter(rPropName.EqualsAscii("Footer", 0, 6));
3649
3650 if(bHeader || bFooter)
3651 {
3652 // it is a Header/Footer entry, access the SvxSetItem containing it's information
3653 const SvxSetItem* pSetItem = 0;
3654
3655 if(SFX_ITEM_SET == aBaseImpl.GetItemSet().GetItemState(bFooter ? SID_ATTR_PAGE_FOOTERSET : SID_ATTR_PAGE_HEADERSET, sal_False, (const SfxPoolItem**)&pSetItem))
3656 {
3657 // create a new SvxSetItem and get it's ItemSet as new target
3658 SvxSetItem* pNewSetItem = static_cast< SvxSetItem* >(pSetItem->Clone());
3659 SfxItemSet& rSetSet = pNewSetItem->GetItemSet();
3660
3661 // set parent to ItemSet to ensure XFILL_NONE as XFillStyleItem
3662 rSetSet.SetParent(&GetDoc()->GetDfltFrmFmt()->GetAttrSet());
3663
3664 // replace the used SfxItemSet at the SwStyleBase_Impl temporarily and use the
3665 // default method to set the property
3666 SfxItemSet* pRememberItemSet = aBaseImpl.replaceItemSet(&rSetSet);
3667 lcl_SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl, GetBasePool(), GetDoc(), GetFamily());
3668 aBaseImpl.replaceItemSet(pRememberItemSet);
3669
3670 // reset paret at ItemSet from SetItem
3671 rSetSet.SetParent(0);
3672
3673 // set the new SvxSetItem at the real target and delete it
3674 aBaseImpl.GetItemSet().Put(*pNewSetItem);
3675 delete pNewSetItem;
3676 }
3677 else if(pEntry->nWID == SID_ATTR_PAGE_ON)
3678 {
3679 sal_Bool bVal = *(sal_Bool*)pValues[nProp].getValue();
3680
3681 if(bVal)
3682 {
3683 // Header/footer gets switched on, create defauts and the needed SfxSetItem
3684 SfxItemSet aTempSet(*aBaseImpl.GetItemSet().GetPool(),
3685 RES_FRMATR_BEGIN,RES_FRMATR_END - 1, // [82
3686
3687 //UUUU FillAttribute support
3688 XATTR_FILL_FIRST, XATTR_FILL_LAST, // [1014
3689
3690 SID_ATTR_BORDER_INNER,SID_ATTR_BORDER_INNER, // [10023
3691 SID_ATTR_PAGE_SIZE,SID_ATTR_PAGE_SIZE, // [10051
3692 SID_ATTR_PAGE_ON,SID_ATTR_PAGE_SHARED, // [10060
3693 0);
3694
3695 //UUUU set correct parent to get the XFILL_NONE FillStyle as needed
3696 aTempSet.SetParent(&GetDoc()->GetDfltFrmFmt()->GetAttrSet());
3697
3698 aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_ON, sal_True));
3699 aTempSet.Put(SvxSizeItem(SID_ATTR_PAGE_SIZE, Size(MM50, MM50)));
3700 aTempSet.Put(SvxLRSpaceItem(RES_LR_SPACE));
3701 aTempSet.Put(SvxULSpaceItem(RES_UL_SPACE));
3702 aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_SHARED, sal_True));
3703 aTempSet.Put(SfxBoolItem(SID_ATTR_PAGE_DYNAMIC, sal_True));
3704
3705 SvxSetItem aNewSetItem(bFooter ? SID_ATTR_PAGE_FOOTERSET : SID_ATTR_PAGE_HEADERSET, aTempSet);
3706 aBaseImpl.GetItemSet().Put(aNewSetItem);
3707 }
3708 }
3709 }
3710 else
3711 {
3712 switch(pEntry->nWID)
3713 {
3714 case SID_ATTR_PAGE_DYNAMIC:
3715 case SID_ATTR_PAGE_SHARED:
3716 case SID_ATTR_PAGE_ON:
3717 case RES_HEADER_FOOTER_EAT_SPACING:
3718 {
3719 // these slots are exclusive to Header/Footer, thus this is an error
3720 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
3721 break;
3722 }
3723 default:
3724 {
3725 // part of PageStyle, fallback to default
3726 lcl_SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl, GetBasePool(), GetDoc(), GetFamily());
3727 }
3728 }
3729 }
3730
3731 break;
3732 }
3733
3734 case XATTR_FILLBMP_SIZELOG:
3735 case XATTR_FILLBMP_TILEOFFSETX:
3736 case XATTR_FILLBMP_TILEOFFSETY:
3737 case XATTR_FILLBMP_POSOFFSETX:
3738 case XATTR_FILLBMP_POSOFFSETY:
3739 case XATTR_FILLBMP_POS:
3740 case XATTR_FILLBMP_SIZEX:
3741 case XATTR_FILLBMP_SIZEY:
3742 case XATTR_FILLBMP_STRETCH:
3743 case XATTR_FILLBMP_TILE:
3744 case OWN_ATTR_FILLBMP_MODE:
3745 case XATTR_FILLCOLOR:
3746 case XATTR_FILLBACKGROUND:
3747 case XATTR_FILLBITMAP:
3748 case XATTR_GRADIENTSTEPCOUNT:
3749 case XATTR_FILLGRADIENT:
3750 case XATTR_FILLHATCH:
3751 case XATTR_FILLSTYLE:
3752 case XATTR_FILLTRANSPARENCE:
3753 case XATTR_FILLFLOATTRANSPARENCE:
3754 case XATTR_SECONDARYFILLCOLOR:
3755 {
3756 // This DrawingLayer FillStyle attributes can be part of Header, Footer and PageStyle
3757 // itself, so decide what to do using the name
3758 const bool bHeader(rPropName.EqualsAscii("Header", 0, 6));
3759 const bool bFooter(rPropName.EqualsAscii("Footer", 0, 6));
3760
3761 if(bHeader || bFooter)
3762 {
3763 const SvxSetItem* pSetItem = 0;
3764
3765 if(SFX_ITEM_SET == aBaseImpl.GetItemSet().GetItemState(bFooter ? SID_ATTR_PAGE_FOOTERSET : SID_ATTR_PAGE_HEADERSET, sal_False, (const SfxPoolItem**)&pSetItem))
3766 {
3767 // create a new SvxSetItem and get it's ItemSet as new target
3768 SvxSetItem* pNewSetItem = static_cast< SvxSetItem* >(pSetItem->Clone());
3769 SfxItemSet& rSetSet = pNewSetItem->GetItemSet();
3770
3771 // set parent to ItemSet to ensure XFILL_NONE as XFillStyleItem
3772 rSetSet.SetParent(&GetDoc()->GetDfltFrmFmt()->GetAttrSet());
3773
3774 // replace the used SfxItemSet at the SwStyleBase_Impl temporarily and use the
3775 // default method to set the property
3776 SfxItemSet* pRememberItemSet = aBaseImpl.replaceItemSet(&rSetSet);
3777 lcl_SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl, GetBasePool(), GetDoc(), GetFamily());
3778 aBaseImpl.replaceItemSet(pRememberItemSet);
3779
3780 // reset paret at ItemSet from SetItem
3781 rSetSet.SetParent(0);
3782
3783 // set the new SvxSetItem at the real target and delete it
3784 aBaseImpl.GetItemSet().Put(*pNewSetItem);
3785 delete pNewSetItem;
3786 }
3787 }
3788 else
3789 {
3790 // part of PageStyle, fallback to default
3791 lcl_SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl, GetBasePool(), GetDoc(), GetFamily());
3792 }
3793
3794 break;
3795 }
3796
3797 case FN_PARAM_FTN_INFO :
3798 {
3799 const SfxPoolItem& rItem = aBaseImpl.GetItemSet().Get(FN_PARAM_FTN_INFO);
3800 SfxPoolItem* pNewFtnItem = rItem.Clone();
3801 sal_Bool bPut = pNewFtnItem->PutValue(pValues[nProp], pEntry->nMemberId);
3802 aBaseImpl.GetItemSet().Put(*pNewFtnItem);
3803 delete pNewFtnItem;
3804 if(!bPut)
3805 throw lang::IllegalArgumentException();
3806
3807 break;
3808 }
3809
3810 case FN_UNO_HEADER :
3811 case FN_UNO_HEADER_LEFT :
3812 case FN_UNO_HEADER_RIGHT :
3813 case FN_UNO_FOOTER :
3814 case FN_UNO_FOOTER_LEFT :
3815 case FN_UNO_FOOTER_RIGHT :
3816 {
3817 throw lang::IllegalArgumentException();
3818 break;
3819 }
3820
3821 default:
3822 {
3823 //UUUU
3824 lcl_SetStyleProperty(*pEntry, *pPropSet, pValues[nProp], aBaseImpl, GetBasePool(), GetDoc(), GetFamily());
3825 break;
3826 }
3827 }
3828 }
3829 else if(IsDescriptor())
3830 {
3831 if(!GetPropImpl()->SetProperty(rPropName, pValues[nProp]))
3832 throw lang::IllegalArgumentException();
3833 }
3834 else
3835 {
3836 throw uno::RuntimeException();
3837 }
3838 }
3839
3840 if(aBaseImpl.HasItemSet())
3841 {
3842 ::sw::UndoGuard const undoGuard(GetDoc()->GetIDocumentUndoRedo());
3843
3844 if (undoGuard.UndoWasEnabled())
3845 {
3846 // Fix i64460: as long as Undo of page styles with header/footer causes trouble...
3847 GetDoc()->GetIDocumentUndoRedo().DelAllUndoObj();
3848 }
3849
3850 aBaseImpl.getNewBase()->SetItemSet(aBaseImpl.GetItemSet());
3851 }
3852 }
3853
setPropertyValues(const uno::Sequence<OUString> & rPropertyNames,const uno::Sequence<uno::Any> & rValues)3854 void SwXPageStyle::setPropertyValues(
3855 const uno::Sequence< OUString >& rPropertyNames,
3856 const uno::Sequence< uno::Any >& rValues )
3857 throw(beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
3858 {
3859 vos::OGuard aGuard(Application::GetSolarMutex());
3860
3861 // workaround for bad designed API
3862 try
3863 {
3864 SetPropertyValues_Impl( rPropertyNames, rValues );
3865 }
3866 catch (beans::UnknownPropertyException &rException)
3867 {
3868 // wrap the original (here not allowed) exception in
3869 // a lang::WrappedTargetException that gets thrown instead.
3870 lang::WrappedTargetException aWExc;
3871 aWExc.TargetException <<= rException;
3872 throw aWExc;
3873 }
3874 }
3875 /* -----------------------------04.11.03 13:50--------------------------------
3876
3877 ---------------------------------------------------------------------------*/
lcl_makeHeaderFooter(const sal_uInt16 nRes,const bool bHeader,SwFrmFmt const * const pFrmFmt)3878 static uno::Reference<text::XText> lcl_makeHeaderFooter(
3879 const sal_uInt16 nRes,
3880 const bool bHeader,
3881 SwFrmFmt const*const pFrmFmt)
3882 {
3883 if (!pFrmFmt) { return 0; }
3884
3885 const SfxItemSet& rSet = pFrmFmt->GetAttrSet();
3886 const SfxPoolItem* pItem;
3887 if (SFX_ITEM_SET == rSet.GetItemState(nRes, sal_True, &pItem))
3888 {
3889 SwFrmFmt *const pHeadFootFmt = (bHeader)
3890 ? static_cast<SwFmtHeader*>(const_cast<SfxPoolItem*>(pItem))->
3891 GetHeaderFmt()
3892 : static_cast<SwFmtFooter*>(const_cast<SfxPoolItem*>(pItem))->
3893 GetFooterFmt();
3894 if (pHeadFootFmt)
3895 {
3896 return SwXHeadFootText::CreateXHeadFootText(*pHeadFootFmt, bHeader);
3897 }
3898 }
3899 return 0;
3900 }
3901
GetPropertyValues_Impl(const uno::Sequence<OUString> & rPropertyNames)3902 uno::Sequence< uno::Any > SAL_CALL SwXPageStyle::GetPropertyValues_Impl(
3903 const uno::Sequence< OUString >& rPropertyNames )
3904 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
3905 {
3906 if(!GetDoc())
3907 throw uno::RuntimeException();
3908
3909 sal_Int32 nLength = rPropertyNames.getLength();
3910 const OUString* pNames = rPropertyNames.getConstArray();
3911 uno::Sequence< uno::Any > aRet ( nLength );
3912 uno::Any* pRet = aRet.getArray();
3913 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PAGE_STYLE);
3914 const SfxItemPropertyMap* pMap = pPropSet->getPropertyMap();
3915 SwStyleBase_Impl aBase(*GetDoc(), GetStyleName(), &GetDoc()->GetDfltFrmFmt()->GetAttrSet()); //UUUU add pDfltFrmFmt as parent
3916 SfxStyleSheetBase* pBase = 0;
3917
3918 for(sal_Int32 nProp = 0; nProp < nLength; nProp++)
3919 {
3920 const String& rPropName = pNames[nProp];
3921 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName( rPropName );
3922
3923 if (!pEntry)
3924 {
3925 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
3926 }
3927
3928 if(GetBasePool())
3929 {
3930 if(!pBase)
3931 {
3932 sal_uInt16 nSaveMask = GetBasePool()->GetSearchMask();
3933 GetBasePool()->SetSearchMask(GetFamily(), SFXSTYLEBIT_ALL );
3934 pBase = GetBasePool()->Find(GetStyleName());
3935 GetBasePool()->SetSearchMask(GetFamily(), nSaveMask );
3936 }
3937
3938 sal_uInt16 nRes = 0;
3939 sal_Bool bAll = sal_False, bLeft = sal_False, bRight = sal_False;
3940 const sal_uInt8 nMemberId(pEntry->nMemberId & (~SFX_METRIC_ITEM));
3941
3942 switch(pEntry->nWID)
3943 {
3944 case SID_ATTR_PAGE_ON:
3945 case RES_BACKGROUND:
3946 case RES_BOX:
3947 case RES_LR_SPACE:
3948 case RES_SHADOW:
3949 case RES_UL_SPACE:
3950 case SID_ATTR_PAGE_DYNAMIC:
3951 case SID_ATTR_PAGE_SHARED:
3952 case SID_ATTR_PAGE_SIZE:
3953 case RES_HEADER_FOOTER_EAT_SPACING:
3954 {
3955 // These slots are used for Header, Footer and (partially) for PageStyle directly.
3956 // Check for Header/Footer entry
3957 const bool bHeader(rPropName.EqualsAscii("Header", 0, 6));
3958 const bool bFooter(rPropName.EqualsAscii("Footer", 0, 6));
3959
3960 if(bHeader || bFooter)
3961 {
3962 // slot is a Header/Footer slot
3963 rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ) );
3964 const SfxItemSet& rSet = xStyle->GetItemSet();
3965 const SvxSetItem* pSetItem;
3966
3967 if(SFX_ITEM_SET == rSet.GetItemState(bFooter ? SID_ATTR_PAGE_FOOTERSET : SID_ATTR_PAGE_HEADERSET, sal_False, (const SfxPoolItem**)&pSetItem))
3968 {
3969 // get from SfxItemSet of the corresponding SfxSetItem
3970 const SfxItemSet& rSetSet = pSetItem->GetItemSet();
3971 SfxItemSet* pRememberItemSet = aBase.replaceItemSet(&const_cast< SfxItemSet& >(rSetSet));
3972 pRet[nProp] = lcl_GetStyleProperty(*pEntry, *pPropSet, aBase, pBase, GetFamily(), GetDoc() );
3973 aBase.replaceItemSet(pRememberItemSet);
3974 }
3975 else if(pEntry->nWID == SID_ATTR_PAGE_ON)
3976 {
3977 // header/footer is not available, thus off. Default is sal_False, though
3978 sal_Bool bRet = sal_False;
3979 pRet[nProp].setValue(&bRet, ::getCppuBooleanType());
3980 }
3981 }
3982 else
3983 {
3984 switch(pEntry->nWID)
3985 {
3986 case SID_ATTR_PAGE_DYNAMIC:
3987 case SID_ATTR_PAGE_SHARED:
3988 case SID_ATTR_PAGE_ON:
3989 case RES_HEADER_FOOTER_EAT_SPACING:
3990 {
3991 // these slots are exclusive to Header/Footer, thus this is an error
3992 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
3993 break;
3994 }
3995 default:
3996 {
3997 // part of PageStyle, fallback to default
3998 pRet[nProp] = lcl_GetStyleProperty(*pEntry, *pPropSet, aBase, pBase, GetFamily(), GetDoc() );
3999 }
4000 }
4001 }
4002
4003 break;
4004 }
4005
4006 case XATTR_FILLBMP_SIZELOG:
4007 case XATTR_FILLBMP_TILEOFFSETX:
4008 case XATTR_FILLBMP_TILEOFFSETY:
4009 case XATTR_FILLBMP_POSOFFSETX:
4010 case XATTR_FILLBMP_POSOFFSETY:
4011 case XATTR_FILLBMP_POS:
4012 case XATTR_FILLBMP_SIZEX:
4013 case XATTR_FILLBMP_SIZEY:
4014 case XATTR_FILLBMP_STRETCH:
4015 case XATTR_FILLBMP_TILE:
4016 case OWN_ATTR_FILLBMP_MODE:
4017 case XATTR_FILLCOLOR:
4018 case XATTR_FILLBACKGROUND:
4019 case XATTR_FILLBITMAP:
4020 case XATTR_GRADIENTSTEPCOUNT:
4021 case XATTR_FILLGRADIENT:
4022 case XATTR_FILLHATCH:
4023 case XATTR_FILLSTYLE:
4024 case XATTR_FILLTRANSPARENCE:
4025 case XATTR_FILLFLOATTRANSPARENCE:
4026 case XATTR_SECONDARYFILLCOLOR:
4027 {
4028 // This DrawingLayer FillStyle attributes can be part of Header, Footer and PageStyle
4029 // itself, so decide what to do using the name
4030 const bool bHeader(rPropName.EqualsAscii("Header", 0, 6));
4031 const bool bFooter(rPropName.EqualsAscii("Footer", 0, 6));
4032
4033 if(bHeader || bFooter)
4034 {
4035 rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ) );
4036 const SfxItemSet& rSet = xStyle->GetItemSet();
4037 const SvxSetItem* pSetItem;
4038
4039 if(SFX_ITEM_SET == rSet.GetItemState(bFooter ? SID_ATTR_PAGE_FOOTERSET : SID_ATTR_PAGE_HEADERSET, sal_False, (const SfxPoolItem**)&pSetItem))
4040 {
4041 // set at SfxItemSet of the corresponding SfxSetItem
4042 const SfxItemSet& rSetSet = pSetItem->GetItemSet();
4043 SfxItemSet* pRememberItemSet = aBase.replaceItemSet(&const_cast< SfxItemSet& >(rSetSet));
4044 pRet[nProp] = lcl_GetStyleProperty(*pEntry, *pPropSet, aBase, pBase, GetFamily(), GetDoc() );
4045 aBase.replaceItemSet(pRememberItemSet);
4046 }
4047 }
4048 else
4049 {
4050 // part of PageStyle, fallback to default
4051 pRet[nProp] = lcl_GetStyleProperty(*pEntry, *pPropSet, aBase, pBase, GetFamily(), GetDoc() );
4052 }
4053
4054 break;
4055 }
4056
4057 case FN_UNO_HEADER:
4058 case FN_UNO_HEADER_LEFT:
4059 case FN_UNO_HEADER_RIGHT:
4060 case FN_UNO_FOOTER:
4061 case FN_UNO_FOOTER_LEFT:
4062 case FN_UNO_FOOTER_RIGHT:
4063 {
4064 //UUUU cleanups for readability (undos removed, rearranged)
4065 bool bHeader(false);
4066
4067 switch(pEntry->nWID)
4068 {
4069 case FN_UNO_HEADER: bHeader = true; nRes = RES_HEADER; bAll = sal_True; break;
4070 case FN_UNO_HEADER_LEFT: bHeader = true; nRes = RES_HEADER; bLeft = sal_True; break;
4071 case FN_UNO_HEADER_RIGHT: bHeader = true; nRes = RES_HEADER; bRight = sal_True; break;
4072 case FN_UNO_FOOTER: bHeader = false; nRes = RES_FOOTER; bAll = sal_True; break;
4073 case FN_UNO_FOOTER_LEFT: bHeader = false; nRes = RES_FOOTER; bLeft = sal_True; break;
4074 case FN_UNO_FOOTER_RIGHT: bHeader = false; nRes = RES_FOOTER; bRight = sal_True; break;
4075 default: break;
4076 }
4077
4078 const SwPageDesc& rDesc = aBase.GetOldPageDesc();
4079 const SwFrmFmt* pFrmFmt = 0;
4080 sal_Bool bShare = (bHeader && rDesc.IsHeaderShared()) || (!bHeader && rDesc.IsFooterShared());
4081 // TextLeft returns the left content if there is one,
4082 // Text and TextRight return the master content.
4083 // TextRight does the same as Text and is for
4084 // comptability only.
4085 if( bLeft && !bShare )
4086 {
4087 pFrmFmt = &rDesc.GetLeft();
4088 }
4089 else
4090 {
4091 pFrmFmt = &rDesc.GetMaster();
4092 }
4093 const uno::Reference< text::XText > xRet =
4094 lcl_makeHeaderFooter(nRes, bHeader, pFrmFmt);
4095 if (xRet.is())
4096 {
4097 pRet[nProp] <<= xRet;
4098 }
4099
4100 break;
4101 }
4102
4103 case FN_PARAM_FTN_INFO :
4104 {
4105 rtl::Reference< SwDocStyleSheet > xStyle( new SwDocStyleSheet( *(SwDocStyleSheet*)pBase ) );
4106 const SfxItemSet& rSet = xStyle->GetItemSet();
4107 const SfxPoolItem& rItem = rSet.Get(FN_PARAM_FTN_INFO);
4108 rItem.QueryValue(pRet[nProp], nMemberId);
4109 break;
4110 }
4111
4112 default:
4113 {
4114 //UUUU
4115 pRet[nProp] = lcl_GetStyleProperty(*pEntry, *pPropSet, aBase, pBase, GetFamily(), GetDoc() );
4116 break;
4117 }
4118 }
4119 }
4120 else if(IsDescriptor())
4121 {
4122 uno::Any* pAny = 0;
4123 GetPropImpl()->GetProperty(rPropName, pAny);
4124
4125 if ( !pAny )
4126 {
4127 GetPropImpl()->GetProperty ( rPropName, mxStyleData, pRet[ nProp ] );
4128 }
4129 else
4130 {
4131 pRet[nProp] = *pAny;
4132 }
4133 }
4134 else
4135 {
4136 throw uno::RuntimeException();
4137 }
4138 }
4139
4140 return aRet;
4141 }
4142 /* -----------------------------18.04.01 13:50--------------------------------
4143
4144 ---------------------------------------------------------------------------*/
getPropertyValues(const uno::Sequence<OUString> & rPropertyNames)4145 uno::Sequence< uno::Any > SwXPageStyle::getPropertyValues(
4146 const uno::Sequence< OUString >& rPropertyNames )
4147 throw(uno::RuntimeException)
4148 {
4149 vos::OGuard aGuard(Application::GetSolarMutex());
4150 uno::Sequence< uno::Any > aValues;
4151
4152 // workaround for bad designed API
4153 try
4154 {
4155 aValues = GetPropertyValues_Impl( rPropertyNames );
4156 }
4157 catch (beans::UnknownPropertyException &)
4158 {
4159 throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property exception caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
4160 }
4161 catch (lang::WrappedTargetException &)
4162 {
4163 throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "WrappedTargetException caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
4164 }
4165
4166 return aValues;
4167 }
4168 /*-- 17.12.98 08:43:36---------------------------------------------------
4169
4170 -----------------------------------------------------------------------*/
getPropertyValue(const OUString & rPropertyName)4171 uno::Any SwXPageStyle::getPropertyValue(
4172 const OUString& rPropertyName)
4173 throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
4174 {
4175 vos::OGuard aGuard(Application::GetSolarMutex());
4176 const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
4177
4178 return GetPropertyValues_Impl(aProperties).getConstArray()[0];
4179 }
4180 /*-- 17.12.98 08:43:36---------------------------------------------------
4181
4182 -----------------------------------------------------------------------*/
setPropertyValue(const OUString & rPropertyName,const uno::Any & rValue)4183 void SwXPageStyle::setPropertyValue(
4184 const OUString& rPropertyName,
4185 const uno::Any& rValue)
4186 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
4187 {
4188 vos::OGuard aGuard(Application::GetSolarMutex());
4189 const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
4190 const uno::Sequence<uno::Any> aValues(&rValue, 1);
4191
4192 SetPropertyValues_Impl( aProperties, aValues );
4193 }
4194
SwXFrameStyle(SwDoc * pDoc)4195 SwXFrameStyle::SwXFrameStyle ( SwDoc *pDoc )
4196 : SwXStyle ( pDoc, SFX_STYLE_FAMILY_FRAME, sal_False)
4197 {
4198 }
4199 /* -----------------------------15.12.00 15:45--------------------------------
4200
4201 ---------------------------------------------------------------------------*/
~SwXFrameStyle()4202 SwXFrameStyle::~SwXFrameStyle()
4203 {
4204 }
4205 /* -----------------------------15.12.00 14:30--------------------------------
4206
4207 ---------------------------------------------------------------------------*/
getTypes()4208 uno::Sequence< uno::Type > SwXFrameStyle::getTypes( ) throw(uno::RuntimeException)
4209 {
4210 uno::Sequence< uno::Type > aTypes = SwXStyle::getTypes();
4211 sal_Int32 nLen = aTypes.getLength();
4212 aTypes.realloc(nLen + 1);
4213 aTypes.getArray()[nLen] = ::getCppuType((uno::Reference<XEventsSupplier>*)0);
4214 return aTypes;
4215 }
4216 /* -----------------------------15.12.00 14:30--------------------------------
4217
4218 ---------------------------------------------------------------------------*/
queryInterface(const uno::Type & rType)4219 uno::Any SwXFrameStyle::queryInterface( const uno::Type& rType ) throw(uno::RuntimeException)
4220 {
4221 uno::Any aRet;
4222 if(rType == ::getCppuType((uno::Reference<XEventsSupplier>*)0))
4223 aRet <<= uno::Reference<XEventsSupplier>(this);
4224 else
4225 aRet = SwXStyle::queryInterface(rType);
4226 return aRet;
4227 }
4228 /* -----------------------------15.12.00 14:30--------------------------------
4229
4230 ---------------------------------------------------------------------------*/
getEvents()4231 uno::Reference< container::XNameReplace > SwXFrameStyle::getEvents( ) throw(uno::RuntimeException)
4232 {
4233 return new SwFrameStyleEventDescriptor( *this );
4234 }
4235 /*-- 19.05.2006 11:23:55---------------------------------------------------
4236
4237 -----------------------------------------------------------------------*/
SwXAutoStyles(SwDocShell & rDocShell)4238 SwXAutoStyles::SwXAutoStyles(SwDocShell& rDocShell) :
4239 SwUnoCollection(rDocShell.GetDoc()), pDocShell( &rDocShell )
4240 {
4241 }
4242 /*-- 19.05.2006 11:23:56---------------------------------------------------
4243
4244 -----------------------------------------------------------------------*/
~SwXAutoStyles()4245 SwXAutoStyles::~SwXAutoStyles()
4246 {
4247 }
4248 /*-- 19.05.2006 11:23:57---------------------------------------------------
4249
4250 -----------------------------------------------------------------------*/
getCount(void)4251 sal_Int32 SwXAutoStyles::getCount(void) throw( uno::RuntimeException )
4252 {
4253 return AUTOSTYLE_FAMILY_COUNT;
4254 }
4255 /*-- 19.05.2006 11:23:57---------------------------------------------------
4256
4257 -----------------------------------------------------------------------*/
getByIndex(sal_Int32 nIndex)4258 uno::Any SwXAutoStyles::getByIndex(sal_Int32 nIndex)
4259 throw( lang::IndexOutOfBoundsException, lang::WrappedTargetException,
4260 uno::RuntimeException )
4261 {
4262 vos::OGuard aGuard(Application::GetSolarMutex());
4263 uno::Any aRet;
4264 if(nIndex < 0 || nIndex >= AUTOSTYLE_FAMILY_COUNT)
4265 throw lang::IndexOutOfBoundsException();
4266 if(IsValid())
4267 {
4268 uno::Reference< style::XAutoStyleFamily > aRef;
4269 IStyleAccess::SwAutoStyleFamily nType = aAutoStyleByIndex[nIndex];
4270 switch( nType )
4271 {
4272 case IStyleAccess::AUTO_STYLE_CHAR:
4273 {
4274 if(!xAutoCharStyles.is())
4275 xAutoCharStyles = new SwXAutoStyleFamily(pDocShell, nType);
4276 aRef = xAutoCharStyles;
4277 }
4278 break;
4279 case IStyleAccess::AUTO_STYLE_RUBY:
4280 {
4281 if(!xAutoRubyStyles.is())
4282 xAutoRubyStyles = new SwXAutoStyleFamily(pDocShell, nType );
4283 aRef = xAutoRubyStyles;
4284 }
4285 break;
4286 case IStyleAccess::AUTO_STYLE_PARA:
4287 {
4288 if(!xAutoParaStyles.is())
4289 xAutoParaStyles = new SwXAutoStyleFamily(pDocShell, nType );
4290 aRef = xAutoParaStyles;
4291 }
4292 break;
4293
4294 default:
4295 ;
4296 }
4297 aRet.setValue(&aRef, ::getCppuType((const uno::Reference<style::XAutoStyleFamily>*)0));
4298 }
4299 else
4300 throw uno::RuntimeException();
4301 return aRet;
4302 }
4303 /*-- 19.05.2006 11:23:57---------------------------------------------------
4304
4305 -----------------------------------------------------------------------*/
getElementType()4306 uno::Type SwXAutoStyles::getElementType( ) throw(uno::RuntimeException)
4307 {
4308 return ::getCppuType((const uno::Reference<style::XAutoStyleFamily>*)0);
4309 }
4310 /*-- 19.05.2006 11:23:58---------------------------------------------------
4311
4312 -----------------------------------------------------------------------*/
hasElements()4313 sal_Bool SwXAutoStyles::hasElements( ) throw(uno::RuntimeException)
4314 {
4315 return sal_True;
4316 }
4317 /*-- 19.05.2006 11:23:58---------------------------------------------------
4318
4319 -----------------------------------------------------------------------*/
getByName(const rtl::OUString & Name)4320 uno::Any SwXAutoStyles::getByName(const rtl::OUString& Name)
4321 throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException )
4322 {
4323 uno::Any aRet;
4324 if(Name.compareToAscii("CharacterStyles") == 0 )
4325 aRet = getByIndex(0);
4326 else if(Name.compareToAscii("RubyStyles") == 0 )
4327 aRet = getByIndex(1);
4328 else if(Name.compareToAscii("ParagraphStyles") == 0 )
4329 aRet = getByIndex(2);
4330 else
4331 throw container::NoSuchElementException();
4332 return aRet;
4333 }
4334 /*-- 19.05.2006 11:23:59---------------------------------------------------
4335
4336 -----------------------------------------------------------------------*/
getElementNames(void)4337 uno::Sequence< rtl::OUString > SwXAutoStyles::getElementNames(void)
4338 throw( uno::RuntimeException )
4339 {
4340 uno::Sequence< OUString > aNames(AUTOSTYLE_FAMILY_COUNT);
4341 OUString* pNames = aNames.getArray();
4342 pNames[0] = C2U("CharacterStyles");
4343 pNames[1] = C2U("RubyStyles");
4344 pNames[2] = C2U("ParagraphStyles");
4345 return aNames;
4346 }
4347 /*-- 19.05.2006 11:24:00---------------------------------------------------
4348
4349 -----------------------------------------------------------------------*/
hasByName(const rtl::OUString & Name)4350 sal_Bool SwXAutoStyles::hasByName(const rtl::OUString& Name)
4351 throw( uno::RuntimeException )
4352 {
4353 if( Name.compareToAscii("CharacterStyles") == 0 ||
4354 Name.compareToAscii("RubyStyles") == 0 ||
4355 Name.compareToAscii("ParagraphStyles") == 0 )
4356 return sal_True;
4357 else
4358 return sal_False;
4359 }
4360
4361 /*-- 19.05.2006 11:24:02---------------------------------------------------
4362
4363 -----------------------------------------------------------------------*/
SwXAutoStyleFamily(SwDocShell * pDocSh,IStyleAccess::SwAutoStyleFamily nFamily)4364 SwXAutoStyleFamily::SwXAutoStyleFamily(SwDocShell* pDocSh, IStyleAccess::SwAutoStyleFamily nFamily) :
4365 pDocShell( pDocSh ), eFamily(nFamily)
4366 {
4367 // Register ourselves as a listener to the document (via the page descriptor)
4368 pDocSh->GetDoc()->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
4369 }
4370 /*-- 19.05.2006 11:24:02---------------------------------------------------
4371
4372 -----------------------------------------------------------------------*/
~SwXAutoStyleFamily()4373 SwXAutoStyleFamily::~SwXAutoStyleFamily()
4374 {
4375 }
4376
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)4377 void SwXAutoStyleFamily::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
4378 {
4379 ClientModify(this, pOld, pNew);
4380 if(!GetRegisteredIn())
4381 pDocShell = 0;
4382 }
4383
4384 /*-- 31.05.2006 11:24:02---------------------------------------------------
4385
4386 -----------------------------------------------------------------------*/
insertStyle(const uno::Sequence<beans::PropertyValue> & Values)4387 uno::Reference< style::XAutoStyle > SwXAutoStyleFamily::insertStyle(
4388 const uno::Sequence< beans::PropertyValue >& Values )
4389 throw (uno::RuntimeException)
4390 {
4391 if( !pDocShell )
4392 {
4393 throw uno::RuntimeException();
4394 }
4395
4396 const sal_uInt16* pRange = 0;
4397 const SfxItemPropertySet* pPropSet = 0;
4398
4399 switch( eFamily )
4400 {
4401 case IStyleAccess::AUTO_STYLE_CHAR:
4402 {
4403 pRange = aCharAutoFmtSetRange;
4404 pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CHAR_AUTO_STYLE);
4405 break;
4406 }
4407 case IStyleAccess::AUTO_STYLE_RUBY:
4408 {
4409 pRange = 0;//aTxtNodeSetRange;
4410 pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_RUBY_AUTO_STYLE);
4411 break;
4412 }
4413 case IStyleAccess::AUTO_STYLE_PARA:
4414 {
4415 pRange = aTxtNodeSetRange; //UUUU checked, already added support for [XATTR_FILL_FIRST, XATTR_FILL_LAST]
4416 pPropSet = aSwMapProvider.GetPropertySet(PROPERTY_MAP_PARA_AUTO_STYLE);
4417 break;
4418 }
4419
4420 default: break;
4421 }
4422
4423 SwAttrSet aSet( pDocShell->GetDoc()->GetAttrPool(), pRange );
4424 const beans::PropertyValue* pSeq = Values.getConstArray();
4425 sal_Int32 nLen = Values.getLength();
4426 const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == eFamily);
4427
4428 if(!bTakeCareOfDrawingLayerFillStyle)
4429 {
4430 for( sal_Int32 i = 0; i < nLen; ++i )
4431 {
4432 try
4433 {
4434 pPropSet->setPropertyValue( pSeq[i].Name, pSeq[i].Value, aSet );
4435 }
4436 catch (beans::UnknownPropertyException &)
4437 {
4438 ASSERT( false, "Unknown property" );
4439 }
4440 catch (lang::IllegalArgumentException &)
4441 {
4442 ASSERT( false, "Illegal argument" );
4443 }
4444 }
4445 }
4446 else
4447 {
4448 //UUUU set parent to ItemSet to ensure XFILL_NONE as XFillStyleItem
4449 // to make cases in RES_BACKGROUND work correct; target *is* a style
4450 // where this is the case
4451 aSet.SetParent(&pDocShell->GetDoc()->GetDfltTxtFmtColl()->GetAttrSet());
4452
4453 //UUUU here the used DrawingLayer FillStyles are imported when family is
4454 // equal to IStyleAccess::AUTO_STYLE_PARA, thus we will need to serve the
4455 // used slots functionality here to do this correctly
4456 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
4457
4458 for( sal_Int32 i = 0; i < nLen; ++i )
4459 {
4460 const OUString& rPropName = pSeq[i].Name;
4461 uno::Any aValue(pSeq[i].Value);
4462 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(rPropName);
4463
4464 if(!pEntry)
4465 {
4466 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
4467 }
4468
4469 const sal_uInt8 nMemberId(pEntry->nMemberId & (~SFX_METRIC_ITEM));
4470 bool bDone(false);
4471
4472 // check for needed metric translation
4473 if(pEntry->nMemberId & SFX_METRIC_ITEM)
4474 {
4475 bool bDoIt(true);
4476
4477 if(XATTR_FILLBMP_SIZEX == pEntry->nWID || XATTR_FILLBMP_SIZEY == pEntry->nWID)
4478 {
4479 // exception: If these ItemTypes are used, do not convert when these are negative
4480 // since this means they are intended as percent values
4481 sal_Int32 nValue = 0;
4482
4483 if(aValue >>= nValue)
4484 {
4485 bDoIt = nValue > 0;
4486 }
4487 }
4488
4489 if(bDoIt)
4490 {
4491 const SfxItemPool& rPool = pDocShell->GetDoc()->GetAttrPool();
4492 const SfxMapUnit eMapUnit(rPool.GetMetric(pEntry->nWID));
4493
4494 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
4495 {
4496 SvxUnoConvertFromMM(eMapUnit, aValue);
4497 }
4498 }
4499 }
4500
4501 switch(pEntry->nWID)
4502 {
4503 case XATTR_FILLGRADIENT:
4504 case XATTR_FILLHATCH:
4505 case XATTR_FILLBITMAP:
4506 case XATTR_FILLFLOATTRANSPARENCE:
4507 // not yet needed; activate when LineStyle support may be added
4508 // case XATTR_LINESTART:
4509 // case XATTR_LINEEND:
4510 // case XATTR_LINEDASH:
4511 {
4512 if(MID_NAME == nMemberId)
4513 {
4514 //UUUU add set commands for FillName items
4515 OUString aTempName;
4516
4517 if(!(aValue >>= aTempName))
4518 {
4519 throw lang::IllegalArgumentException();
4520 }
4521
4522 SvxShape::SetFillAttribute(pEntry->nWID, aTempName, aSet);
4523 bDone = true;
4524 }
4525 else if(MID_GRAFURL == nMemberId)
4526 {
4527 if(XATTR_FILLBITMAP == pEntry->nWID)
4528 {
4529 //UUUU Bitmap also has the MID_GRAFURL mode where a Bitmap URL is used
4530 const Graphic aNullGraphic;
4531 XFillBitmapItem aXFillBitmapItem(aSet.GetPool(), aNullGraphic);
4532
4533 aXFillBitmapItem.PutValue(aValue, nMemberId);
4534 aSet.Put(aXFillBitmapItem);
4535 bDone = true;
4536 }
4537 }
4538
4539 break;
4540 }
4541 case RES_BACKGROUND:
4542 {
4543 //UUUU
4544 const SvxBrushItem aOriginalBrushItem(getSvxBrushItemFromSourceSet(aSet, RES_BACKGROUND));
4545 SvxBrushItem aChangedBrushItem(aOriginalBrushItem);
4546
4547 aChangedBrushItem.PutValue(aValue, nMemberId);
4548
4549 if(!(aChangedBrushItem == aOriginalBrushItem))
4550 {
4551 setSvxBrushItemAsFillAttributesToTargetSet(aChangedBrushItem, aSet);
4552 }
4553
4554 bDone = true;
4555 break;
4556 }
4557 case OWN_ATTR_FILLBMP_MODE:
4558 {
4559 //UUUU
4560 drawing::BitmapMode eMode;
4561
4562 if(!(aValue >>= eMode))
4563 {
4564 sal_Int32 nMode = 0;
4565
4566 if(!(aValue >>= nMode))
4567 {
4568 throw lang::IllegalArgumentException();
4569 }
4570
4571 eMode = (drawing::BitmapMode)nMode;
4572 }
4573
4574 aSet.Put(XFillBmpStretchItem(drawing::BitmapMode_STRETCH == eMode));
4575 aSet.Put(XFillBmpTileItem(drawing::BitmapMode_REPEAT == eMode));
4576
4577 bDone = true;
4578 break;
4579 }
4580 default: break;
4581 }
4582
4583 if(!bDone)
4584 {
4585 pPropSet->setPropertyValue( rPropName, aValue, aSet );
4586 }
4587 }
4588
4589 //UUUU clear parent again
4590 aSet.SetParent(0);
4591 }
4592
4593 //UUUU need to ensure uniqueness of evtl. added NameOrIndex items
4594 // currently in principle only needed when bTakeCareOfDrawingLayerFillStyle,
4595 // but does not hurt and is easily forgotten later eventually, so keep it
4596 // as common case
4597 pDocShell->GetDoc()->CheckForUniqueItemForLineFillNameOrIndex(aSet);
4598
4599 // AutomaticStyle creation
4600 SfxItemSet_Pointer_t pSet = pDocShell->GetDoc()->GetIStyleAccess().cacheAutomaticStyle( aSet, eFamily );
4601 uno::Reference<style::XAutoStyle> xRet = new SwXAutoStyle(pDocShell->GetDoc(), pSet, eFamily);
4602
4603 return xRet;
4604 }
4605 /*-- 31.05.2006 11:24:02---------------------------------------------------
4606
4607 -----------------------------------------------------------------------*/
createEnumeration()4608 uno::Reference< container::XEnumeration > SwXAutoStyleFamily::createEnumeration( )
4609 throw (uno::RuntimeException)
4610 {
4611 if( !pDocShell )
4612 throw uno::RuntimeException();
4613 return uno::Reference< container::XEnumeration >
4614 (new SwXAutoStylesEnumerator( pDocShell->GetDoc(), eFamily ));
4615 }
4616 /*-- 19.05.2006 11:24:03---------------------------------------------------
4617
4618 -----------------------------------------------------------------------*/
getElementType()4619 uno::Type SwXAutoStyleFamily::getElementType( ) throw(uno::RuntimeException)
4620 {
4621 return ::getCppuType((const uno::Reference<style::XAutoStyle>*)0);
4622 }
4623 /*-- 19.05.2006 11:24:04---------------------------------------------------
4624
4625 -----------------------------------------------------------------------*/
hasElements()4626 sal_Bool SwXAutoStyleFamily::hasElements( ) throw(uno::RuntimeException)
4627 {
4628 return sal_False;
4629 }
4630
4631 /*-- 31.05.2006 11:24:05---------------------------------------------------
4632
4633 -----------------------------------------------------------------------*/
SwAutoStylesEnumImpl(SwDoc * pInitDoc,IStyleAccess::SwAutoStyleFamily eFam)4634 SwAutoStylesEnumImpl::SwAutoStylesEnumImpl( SwDoc* pInitDoc, IStyleAccess::SwAutoStyleFamily eFam )
4635 : pDoc( pInitDoc ), eFamily( eFam )
4636 {
4637 // special case for ruby auto styles:
4638 if ( IStyleAccess::AUTO_STYLE_RUBY == eFam )
4639 {
4640 std::set< std::pair< sal_uInt16, sal_uInt16 > > aRubyMap;
4641 SwAttrPool& rAttrPool = pDoc->GetAttrPool();
4642 sal_uInt32 nCount = rAttrPool.GetItemCount2( RES_TXTATR_CJK_RUBY );
4643
4644 for ( sal_uInt32 nI = 0; nI < nCount; ++nI )
4645 {
4646 const SwFmtRuby* pItem = static_cast<const SwFmtRuby*>(rAttrPool.GetItem2( RES_TXTATR_CJK_RUBY, nI ));
4647 if ( pItem && pItem->GetTxtRuby() )
4648 {
4649 std::pair< sal_uInt16, sal_uInt16 > aPair( pItem->GetPosition(), pItem->GetAdjustment() );
4650 if ( aRubyMap.find( aPair ) == aRubyMap.end() )
4651 {
4652 aRubyMap.insert( aPair );
4653 SfxItemSet_Pointer_t pItemSet( new SfxItemSet( rAttrPool, RES_TXTATR_CJK_RUBY, RES_TXTATR_CJK_RUBY ) );
4654 pItemSet->Put( *pItem );
4655 mAutoStyles.push_back( pItemSet );
4656 }
4657 }
4658 }
4659 }
4660 else
4661 {
4662 pDoc->GetIStyleAccess().getAllStyles( mAutoStyles, eFamily );
4663 }
4664
4665 aIter = mAutoStyles.begin();
4666 }
4667
4668 /*-- 31.05.2006 11:24:05---------------------------------------------------
4669
4670 -----------------------------------------------------------------------*/
SwXAutoStylesEnumerator(SwDoc * pDoc,IStyleAccess::SwAutoStyleFamily eFam)4671 SwXAutoStylesEnumerator::SwXAutoStylesEnumerator( SwDoc* pDoc, IStyleAccess::SwAutoStyleFamily eFam )
4672 : pImpl( new SwAutoStylesEnumImpl( pDoc, eFam ) )
4673 {
4674 // Register ourselves as a listener to the document (via the page descriptor)
4675 pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
4676 }
4677 /*-- 31.05.2006 11:24:05---------------------------------------------------
4678
4679 -----------------------------------------------------------------------*/
~SwXAutoStylesEnumerator()4680 SwXAutoStylesEnumerator::~SwXAutoStylesEnumerator()
4681 {
4682 delete pImpl;
4683 }
4684
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)4685 void SwXAutoStylesEnumerator::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew)
4686 {
4687 ClientModify(this, pOld, pNew);
4688 if(!GetRegisteredIn())
4689 {
4690 delete pImpl;
4691 pImpl = 0;
4692 }
4693 }
4694
4695
4696 /*-- 31.05.2006 11:24:05---------------------------------------------------
4697
4698 -----------------------------------------------------------------------*/
hasMoreElements()4699 ::sal_Bool SwXAutoStylesEnumerator::hasMoreElements( )
4700 throw (uno::RuntimeException)
4701 {
4702 if( !pImpl )
4703 throw uno::RuntimeException();
4704 return pImpl->hasMoreElements();
4705 }
4706 /*-- 31.05.2006 11:24:05---------------------------------------------------
4707
4708 -----------------------------------------------------------------------*/
nextElement()4709 uno::Any SwXAutoStylesEnumerator::nextElement( )
4710 throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
4711 {
4712 if( !pImpl )
4713 throw uno::RuntimeException();
4714 uno::Any aRet;
4715 if( pImpl->hasMoreElements() )
4716 {
4717 SfxItemSet_Pointer_t pNextSet = pImpl->nextElement();
4718 uno::Reference< style::XAutoStyle > xAutoStyle = new SwXAutoStyle(pImpl->getDoc(),
4719 pNextSet, pImpl->getFamily());
4720 aRet.setValue(&xAutoStyle, ::getCppuType((uno::Reference<style::XAutoStyle>*)0));
4721 }
4722 return aRet;
4723 }
4724
4725 //////////////////////////////////////////////////////////////////////////////
4726 //UUUU SwXAutoStyle with the family IStyleAccess::AUTO_STYLE_PARA (or
4727 // PROPERTY_MAP_PARA_AUTO_STYLE) now uses DrawingLayer FillStyles to allow
4728 // unified paragraph background fill, thus the UNO API implementation has to
4729 // support the needed slots for these. This seems to be used only for reading
4730 // (no setPropertyValue implementation here), so maybe specialized for saving
4731 // the Writer Doc to ODF
4732
SwXAutoStyle(SwDoc * pDoc,SfxItemSet_Pointer_t pInitSet,IStyleAccess::SwAutoStyleFamily eFam)4733 SwXAutoStyle::SwXAutoStyle(
4734 SwDoc* pDoc,
4735 SfxItemSet_Pointer_t pInitSet,
4736 IStyleAccess::SwAutoStyleFamily eFam)
4737 : mpSet(pInitSet),
4738 meFamily(eFam),
4739 mrDoc(*pDoc)
4740 {
4741 // Register ourselves as a listener to the document (via the page descriptor)
4742 mrDoc.GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this);
4743 }
4744
~SwXAutoStyle()4745 SwXAutoStyle::~SwXAutoStyle()
4746 {
4747 }
4748
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)4749 void SwXAutoStyle::Modify(
4750 const SfxPoolItem* pOld,
4751 const SfxPoolItem *pNew)
4752 {
4753 ClientModify(this, pOld, pNew);
4754
4755 if(!GetRegisteredIn())
4756 {
4757 mpSet.reset();
4758 }
4759 }
4760
getPropertySetInfo()4761 uno::Reference< beans::XPropertySetInfo > SwXAutoStyle::getPropertySetInfo()
4762 throw (uno::RuntimeException)
4763 {
4764 uno::Reference< beans::XPropertySetInfo > xRet;
4765 switch( meFamily )
4766 {
4767 case IStyleAccess::AUTO_STYLE_CHAR:
4768 {
4769 static uno::Reference< beans::XPropertySetInfo > xCharRef;
4770 if(!xCharRef.is())
4771 {
4772 xCharRef = aSwMapProvider.GetPropertySet(PROPERTY_MAP_CHAR_AUTO_STYLE)->getPropertySetInfo();
4773 }
4774 xRet = xCharRef;
4775 }
4776 break;
4777 case IStyleAccess::AUTO_STYLE_RUBY:
4778 {
4779 static uno::Reference< beans::XPropertySetInfo > xRubyRef;
4780 if(!xRubyRef.is())
4781 {
4782 sal_uInt16 nMapId = PROPERTY_MAP_RUBY_AUTO_STYLE;
4783 xRubyRef = aSwMapProvider.GetPropertySet(nMapId)->getPropertySetInfo();
4784 }
4785 xRet = xRubyRef;
4786 }
4787 break;
4788 case IStyleAccess::AUTO_STYLE_PARA:
4789 {
4790 static uno::Reference< beans::XPropertySetInfo > xParaRef;
4791 if(!xParaRef.is())
4792 {
4793 sal_uInt16 nMapId = PROPERTY_MAP_PARA_AUTO_STYLE;
4794 xParaRef = aSwMapProvider.GetPropertySet(nMapId)->getPropertySetInfo();
4795 }
4796 xRet = xParaRef;
4797 }
4798 break;
4799
4800 default:
4801 ;
4802 }
4803
4804 return xRet;
4805 }
4806
setPropertyValue(const OUString &,const uno::Any &)4807 void SwXAutoStyle::setPropertyValue(
4808 const OUString& /*rPropertyName*/,
4809 const uno::Any& /*rValue*/ )
4810 throw( beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
4811 {
4812 }
4813
getPropertyValue(const OUString & rPropertyName)4814 uno::Any SwXAutoStyle::getPropertyValue(
4815 const OUString& rPropertyName )
4816 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
4817 {
4818 vos::OGuard aGuard(Application::GetSolarMutex());
4819 const uno::Sequence<OUString> aProperties(&rPropertyName, 1);
4820
4821 return GetPropertyValues_Impl(aProperties).getConstArray()[0];
4822 }
4823
addPropertyChangeListener(const OUString &,const uno::Reference<beans::XPropertyChangeListener> &)4824 void SwXAutoStyle::addPropertyChangeListener(
4825 const OUString& /*aPropertyName*/,
4826 const uno::Reference< beans::XPropertyChangeListener >& /*xListener*/ )
4827 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
4828 {
4829 }
4830
removePropertyChangeListener(const OUString &,const uno::Reference<beans::XPropertyChangeListener> &)4831 void SwXAutoStyle::removePropertyChangeListener(
4832 const OUString& /*aPropertyName*/,
4833 const uno::Reference< beans::XPropertyChangeListener >& /*aListener*/ )
4834 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
4835 {
4836 }
4837
addVetoableChangeListener(const OUString &,const uno::Reference<beans::XVetoableChangeListener> &)4838 void SwXAutoStyle::addVetoableChangeListener(
4839 const OUString& /*PropertyName*/,
4840 const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
4841 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
4842 {
4843 }
4844
removeVetoableChangeListener(const OUString &,const uno::Reference<beans::XVetoableChangeListener> &)4845 void SwXAutoStyle::removeVetoableChangeListener(
4846 const OUString& /*PropertyName*/,
4847 const uno::Reference< beans::XVetoableChangeListener >& /*aListener*/ )
4848 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
4849 {
4850 }
4851
setPropertyValues(const uno::Sequence<::rtl::OUString> &,const uno::Sequence<uno::Any> &)4852 void SwXAutoStyle::setPropertyValues(
4853 const uno::Sequence< ::rtl::OUString >& /*aPropertyNames*/,
4854 const uno::Sequence< uno::Any >& /*aValues*/ )
4855 throw (beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
4856 {
4857 }
4858
GetPropertyValues_Impl(const uno::Sequence<OUString> & rPropertyNames)4859 uno::Sequence< uno::Any > SwXAutoStyle::GetPropertyValues_Impl(
4860 const uno::Sequence< OUString > & rPropertyNames )
4861 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException )
4862 {
4863 if( !mpSet.get() )
4864 {
4865 throw uno::RuntimeException();
4866 }
4867
4868 // query_item
4869 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE;
4870
4871 switch(meFamily)
4872 {
4873 case IStyleAccess::AUTO_STYLE_CHAR : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE; break;
4874 case IStyleAccess::AUTO_STYLE_RUBY : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE; break;
4875 case IStyleAccess::AUTO_STYLE_PARA : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE; break;
4876 default: ;
4877 }
4878
4879 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
4880 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
4881 const OUString* pNames = rPropertyNames.getConstArray();
4882 const sal_Int32 nLen(rPropertyNames.getLength());
4883 uno::Sequence< uno::Any > aRet( nLen );
4884 uno::Any* pValues = aRet.getArray();
4885 const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == meFamily);
4886
4887 for( sal_Int32 i = 0; i < nLen; ++i )
4888 {
4889 const OUString& rPropName = pNames[i];
4890 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(rPropName);
4891
4892 if(!pEntry)
4893 {
4894 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
4895 }
4896
4897 uno::Any aTarget;
4898 bool bDone(false);
4899
4900 if ( RES_TXTATR_AUTOFMT == pEntry->nWID || RES_AUTO_STYLE == pEntry->nWID )
4901 {
4902 OUString sName(StylePool::nameOf( mpSet ));
4903 aTarget <<= sName;
4904 bDone = true;
4905 }
4906 else if(bTakeCareOfDrawingLayerFillStyle)
4907 {
4908 //UUUU add support for DrawingLayer FillStyle slots
4909 switch(pEntry->nWID)
4910 {
4911 case RES_BACKGROUND:
4912 {
4913 const SvxBrushItem aOriginalBrushItem(getSvxBrushItemFromSourceSet(*mpSet, RES_BACKGROUND));
4914 const sal_uInt8 nMemberId(pEntry->nMemberId & (~SFX_METRIC_ITEM));
4915
4916 if(!aOriginalBrushItem.QueryValue(aTarget, nMemberId))
4917 {
4918 OSL_ENSURE(false, "Error getting attribute from RES_BACKGROUND (!)");
4919 }
4920
4921 bDone = true;
4922 break;
4923 }
4924 case OWN_ATTR_FILLBMP_MODE:
4925 {
4926 const XFillBmpStretchItem* pStretchItem = dynamic_cast< const XFillBmpStretchItem* >(&mpSet->Get(XATTR_FILLBMP_STRETCH));
4927 const XFillBmpTileItem* pTileItem = dynamic_cast< const XFillBmpTileItem* >(&mpSet->Get(XATTR_FILLBMP_TILE));
4928
4929 if( pTileItem && pTileItem->GetValue() )
4930 {
4931 aTarget <<= drawing::BitmapMode_REPEAT;
4932 }
4933 else if( pStretchItem && pStretchItem->GetValue() )
4934 {
4935 aTarget <<= drawing::BitmapMode_STRETCH;
4936 }
4937 else
4938 {
4939 aTarget <<= drawing::BitmapMode_NO_REPEAT;
4940 }
4941
4942 bDone = true;
4943 break;
4944 }
4945 }
4946 }
4947
4948 if(!bDone)
4949 {
4950 pPropSet->getPropertyValue( *pEntry, *mpSet, aTarget );
4951 }
4952
4953 if(bTakeCareOfDrawingLayerFillStyle)
4954 {
4955 if(pEntry->pType && *(pEntry->pType) == ::getCppuType((const sal_Int16*)0) && *(pEntry->pType) != aTarget.getValueType())
4956 {
4957 // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here
4958 sal_Int32 nValue = 0;
4959 aTarget >>= nValue;
4960 aTarget <<= (sal_Int16)nValue;
4961 }
4962
4963 // check for needed metric translation
4964 if(pEntry->nMemberId & SFX_METRIC_ITEM)
4965 {
4966 bool bDoIt(true);
4967
4968 if(XATTR_FILLBMP_SIZEX == pEntry->nWID || XATTR_FILLBMP_SIZEY == pEntry->nWID)
4969 {
4970 // exception: If these ItemTypes are used, do not convert when these are negative
4971 // since this means they are intended as percent values
4972 sal_Int32 nValue = 0;
4973
4974 if(aTarget >>= nValue)
4975 {
4976 bDoIt = nValue > 0;
4977 }
4978 }
4979
4980 if(bDoIt)
4981 {
4982 const SfxItemPool& rPool = mrDoc.GetAttrPool();
4983 const SfxMapUnit eMapUnit(rPool.GetMetric(pEntry->nWID));
4984
4985 if(eMapUnit != SFX_MAPUNIT_100TH_MM)
4986 {
4987 SvxUnoConvertToMM(eMapUnit, aTarget);
4988 }
4989 }
4990 }
4991 }
4992
4993 // add value
4994 pValues[i] = aTarget;
4995 }
4996
4997 return aRet;
4998 }
4999
getPropertyValues(const uno::Sequence<::rtl::OUString> & rPropertyNames)5000 uno::Sequence< uno::Any > SwXAutoStyle::getPropertyValues (
5001 const uno::Sequence< ::rtl::OUString >& rPropertyNames )
5002 throw (uno::RuntimeException)
5003 {
5004 vos::OGuard aGuard(Application::GetSolarMutex());
5005 uno::Sequence< uno::Any > aValues;
5006
5007 // workaround for bad designed API
5008 try
5009 {
5010 aValues = GetPropertyValues_Impl( rPropertyNames );
5011 }
5012 catch (beans::UnknownPropertyException &)
5013 {
5014 throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property exception caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
5015 }
5016 catch (lang::WrappedTargetException &)
5017 {
5018 throw uno::RuntimeException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "WrappedTargetException caught" ) ), static_cast < cppu::OWeakObject * > ( this ) );
5019 }
5020
5021 return aValues;
5022 }
5023
addPropertiesChangeListener(const uno::Sequence<::rtl::OUString> &,const uno::Reference<beans::XPropertiesChangeListener> &)5024 void SwXAutoStyle::addPropertiesChangeListener(
5025 const uno::Sequence< ::rtl::OUString >& /*aPropertyNames*/,
5026 const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
5027 throw (uno::RuntimeException)
5028 {
5029 }
5030
removePropertiesChangeListener(const uno::Reference<beans::XPropertiesChangeListener> &)5031 void SwXAutoStyle::removePropertiesChangeListener(
5032 const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
5033 throw (uno::RuntimeException)
5034 {
5035 }
5036
firePropertiesChangeEvent(const uno::Sequence<::rtl::OUString> &,const uno::Reference<beans::XPropertiesChangeListener> &)5037 void SwXAutoStyle::firePropertiesChangeEvent(
5038 const uno::Sequence< ::rtl::OUString >& /*aPropertyNames*/,
5039 const uno::Reference< beans::XPropertiesChangeListener >& /*xListener*/ )
5040 throw (uno::RuntimeException)
5041 {
5042 }
5043
getPropertyState(const OUString & rPropertyName)5044 beans::PropertyState SwXAutoStyle::getPropertyState(
5045 const OUString& rPropertyName )
5046 throw( beans::UnknownPropertyException, uno::RuntimeException)
5047 {
5048 vos::OGuard aGuard(Application::GetSolarMutex());
5049
5050 uno::Sequence< OUString > aNames(1);
5051 OUString* pNames = aNames.getArray();
5052 pNames[0] = rPropertyName;
5053 uno::Sequence< beans::PropertyState > aStates = getPropertyStates(aNames);
5054 return aStates.getConstArray()[0];
5055 }
5056
setPropertyToDefault(const OUString &)5057 void SwXAutoStyle::setPropertyToDefault(
5058 const OUString& /*PropertyName*/ )
5059 throw( beans::UnknownPropertyException, uno::RuntimeException )
5060 {
5061 }
5062
getPropertyDefault(const OUString & rPropertyName)5063 uno::Any SwXAutoStyle::getPropertyDefault(
5064 const OUString& rPropertyName )
5065 throw( beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
5066 {
5067 const uno::Sequence < OUString > aSequence ( &rPropertyName, 1 );
5068
5069 return getPropertyDefaults ( aSequence ).getConstArray()[0];
5070 }
5071
getPropertyStates(const uno::Sequence<::rtl::OUString> & rPropertyNames)5072 uno::Sequence< beans::PropertyState > SwXAutoStyle::getPropertyStates(
5073 const uno::Sequence< ::rtl::OUString >& rPropertyNames )
5074 throw (beans::UnknownPropertyException, uno::RuntimeException)
5075 {
5076 if( !mpSet.get() )
5077 {
5078 throw uno::RuntimeException();
5079 }
5080
5081 vos::OGuard aGuard(Application::GetSolarMutex());
5082 uno::Sequence< beans::PropertyState > aRet(rPropertyNames.getLength());
5083 beans::PropertyState* pStates = aRet.getArray();
5084 const OUString* pNames = rPropertyNames.getConstArray();
5085 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE;
5086
5087 switch(meFamily)
5088 {
5089 case IStyleAccess::AUTO_STYLE_CHAR : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE; break;
5090 case IStyleAccess::AUTO_STYLE_RUBY : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE; break;
5091 case IStyleAccess::AUTO_STYLE_PARA : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE; break;
5092 default: ;
5093 }
5094
5095 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
5096 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
5097 const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == meFamily);
5098
5099 for(sal_Int32 i = 0; i < rPropertyNames.getLength(); i++)
5100 {
5101 const OUString& rPropName = pNames[i];
5102 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(rPropName);
5103
5104 if(!pEntry)
5105 {
5106 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
5107 }
5108
5109 bool bDone(false);
5110
5111 if(bTakeCareOfDrawingLayerFillStyle)
5112 {
5113 //UUUU DrawingLayer PropertyStyle support
5114 switch(pEntry->nWID)
5115 {
5116 case OWN_ATTR_FILLBMP_MODE:
5117 {
5118 if(SFX_ITEM_SET == mpSet->GetItemState(XATTR_FILLBMP_STRETCH, false)
5119 || SFX_ITEM_SET == mpSet->GetItemState(XATTR_FILLBMP_TILE, false))
5120 {
5121 pStates[i] = beans::PropertyState_DIRECT_VALUE;
5122 }
5123 else
5124 {
5125 pStates[i] = beans::PropertyState_AMBIGUOUS_VALUE;
5126 }
5127
5128 bDone = true;
5129 break;
5130 }
5131 case RES_BACKGROUND:
5132 {
5133 if(SWUnoHelper::needToMapFillItemsToSvxBrushItemTypes(*mpSet))
5134 {
5135 pStates[i] = beans::PropertyState_DIRECT_VALUE;
5136 bDone = true;
5137 }
5138
5139 break;
5140 }
5141 }
5142 }
5143
5144 if(!bDone)
5145 {
5146 pStates[i] = pPropSet->getPropertyState(*pEntry, *mpSet );
5147 }
5148 }
5149
5150 return aRet;
5151 }
5152
setAllPropertiesToDefault()5153 void SwXAutoStyle::setAllPropertiesToDefault( )
5154 throw (uno::RuntimeException)
5155 {
5156 }
5157
setPropertiesToDefault(const uno::Sequence<::rtl::OUString> & rPropertyNames)5158 void SwXAutoStyle::setPropertiesToDefault(
5159 const uno::Sequence< ::rtl::OUString >& rPropertyNames )
5160 throw (beans::UnknownPropertyException, uno::RuntimeException)
5161 {
5162 if( !mpSet.get() )
5163 {
5164 throw uno::RuntimeException();
5165 }
5166
5167 const bool bTakeCareOfDrawingLayerFillStyle(IStyleAccess::AUTO_STYLE_PARA == meFamily);
5168
5169 if(!bTakeCareOfDrawingLayerFillStyle)
5170 {
5171 return;
5172 }
5173
5174 //UUUU support DrawingLayer FillStyle slots from here on
5175 vos::OGuard aGuard(Application::GetSolarMutex());
5176 const OUString* pNames = rPropertyNames.getConstArray();
5177 sal_Int8 nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE;
5178
5179 switch(meFamily)
5180 {
5181 case IStyleAccess::AUTO_STYLE_CHAR : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE; break;
5182 case IStyleAccess::AUTO_STYLE_RUBY : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE; break;
5183 case IStyleAccess::AUTO_STYLE_PARA : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE; break;
5184 default: ;
5185 }
5186
5187 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
5188 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
5189
5190 for(sal_Int32 i = 0; i < rPropertyNames.getLength(); i++)
5191 {
5192 const OUString& rPropName = pNames[i];
5193 const SfxItemPropertySimpleEntry* pEntry = pMap->getByName(rPropName);
5194
5195 if(!pEntry)
5196 {
5197 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropName, static_cast < cppu::OWeakObject * > ( this ) );
5198 }
5199
5200 switch(pEntry->nWID)
5201 {
5202 case OWN_ATTR_FILLBMP_MODE:
5203 {
5204 mpSet->ClearItem(XATTR_FILLBMP_STRETCH);
5205 mpSet->ClearItem(XATTR_FILLBMP_TILE);
5206 }
5207 }
5208 }
5209 }
5210
getPropertyDefaults(const uno::Sequence<::rtl::OUString> &)5211 uno::Sequence< uno::Any > SwXAutoStyle::getPropertyDefaults(
5212 const uno::Sequence< ::rtl::OUString >& /*aPropertyNames*/ )
5213 throw (beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
5214 {
5215 uno::Sequence< uno::Any > aRet(0);
5216
5217 return aRet;
5218 }
5219
getProperties()5220 uno::Sequence< beans::PropertyValue > SwXAutoStyle::getProperties()
5221 throw (uno::RuntimeException)
5222 {
5223 if( !mpSet.get() )
5224 throw uno::RuntimeException();
5225 vos::OGuard aGuard(Application::GetSolarMutex());
5226 std::vector< beans::PropertyValue > aPropertyVector;
5227
5228 sal_Int8 nPropSetId = 0;
5229 switch(meFamily)
5230 {
5231 case IStyleAccess::AUTO_STYLE_CHAR : nPropSetId = PROPERTY_MAP_CHAR_AUTO_STYLE; break;
5232 case IStyleAccess::AUTO_STYLE_RUBY : nPropSetId = PROPERTY_MAP_RUBY_AUTO_STYLE; break;
5233 case IStyleAccess::AUTO_STYLE_PARA : nPropSetId = PROPERTY_MAP_PARA_AUTO_STYLE; break;
5234 default:
5235 ;
5236 }
5237
5238 const SfxItemPropertySet* pPropSet = aSwMapProvider.GetPropertySet(nPropSetId);
5239 const SfxItemPropertyMap *pMap = pPropSet->getPropertyMap();
5240 PropertyEntryVector_t aPropVector = pMap->getPropertyEntries();
5241 // struct compareWhichIds
5242 // {
5243 // bool operator()(const sal_uInt16 w1, const sal_uInt16 w2) const
5244 // {
5245 // return w1 < w2;
5246 // }
5247 // };
5248 // typedef std::map<const sal_uInt16, SfxItemPropertyNamedEntry, compareWhichIds> PropertyMap_t;
5249 // PropertyMap_t aPropMap;
5250 // aPropMap.reserve( aPropVector.size() );
5251 // PropertyEntryVector_t::const_iterator aIt = aPropertyEntries.begin();
5252 // while( aIt != aPropertyEntries.end() )
5253 // {
5254 // aPropMap[aIt->nWID] = *aIt;
5255 // ++aIt;
5256 // }
5257
5258 SfxItemSet& rSet = *mpSet.get();
5259 SfxItemIter aIter(rSet);
5260 const SfxPoolItem* pItem = aIter.FirstItem();
5261
5262 while ( pItem )
5263 {
5264 const sal_uInt16 nWID = pItem->Which();
5265
5266 // PropertyMap_t::const_iterator aMapIt = aPropMap[nWID];
5267 // if( aMapIt != aPropMap.getEnd() )
5268 // {
5269 // beans::PropertyValue aPropertyValue;
5270 // aPropertyValue.Name = aIt->sName;
5271 // pItem->QueryValue( aPropertyValue.Value, aIt->nMemberId );
5272 // aPropertyVector.push_back( aPropertyValue );
5273 // }
5274 // TODO: Optimize - and fix! the old iteration filled each WhichId
5275 // only once but there are more properties than WhichIds
5276 PropertyEntryVector_t::const_iterator aIt = aPropVector.begin();
5277 while( aIt != aPropVector.end() )
5278 {
5279 if ( aIt->nWID == nWID )
5280 {
5281 beans::PropertyValue aPropertyValue;
5282 aPropertyValue.Name = aIt->sName;
5283 pItem->QueryValue( aPropertyValue.Value, aIt->nMemberId );
5284 aPropertyVector.push_back( aPropertyValue );
5285 }
5286 ++aIt;
5287 }
5288 /* int i = 0;
5289 while ( pMap[i].nWID != 0 )
5290 {
5291 if ( pMap[i].nWID == nWID )
5292 {
5293 beans::PropertyValue aPropertyValue;
5294 String sString( OUString::createFromAscii( pMap[i].pName ) );
5295 aPropertyValue.Name = sString;
5296 pItem->QueryValue( aPropertyValue.Value, pMap[i].nMemberId );
5297 aPropertyVector.push_back( aPropertyValue );
5298 break;
5299 }
5300 ++i;
5301 }*/
5302 pItem = aIter.NextItem();
5303 }
5304
5305 const sal_Int32 nCount = aPropertyVector.size();
5306 uno::Sequence< beans::PropertyValue > aRet( nCount );
5307 beans::PropertyValue* pProps = aRet.getArray();
5308
5309 for ( int i = 0; i < nCount; ++i, pProps++ )
5310 {
5311 *pProps = aPropertyVector[i];
5312 }
5313
5314 return aRet;
5315 }
5316
5317 //////////////////////////////////////////////////////////////////////////////
5318 //eof
5319