1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sd.hxx" 26 27 #include <com/sun/star/beans/PropertyAttribute.hpp> 28 #include <com/sun/star/lang/DisposedException.hpp> 29 #include <com/sun/star/style/XStyle.hpp> 30 31 #include <osl/mutex.hxx> 32 #include <vos/mutex.hxx> 33 #include <vcl/svapp.hxx> 34 #include <comphelper/serviceinfohelper.hxx> 35 #include <boost/bind.hpp> 36 37 #include "eetext.hxx" 38 #include <editeng/eeitem.hxx> 39 #include <editeng/fhgtitem.hxx> 40 #include <svx/svdoattr.hxx> 41 #include <editeng/ulspitem.hxx> 42 #include <svl/smplhint.hxx> 43 #include <svl/itemset.hxx> 44 45 #include <svx/xflbmtit.hxx> 46 #include <svx/xflbstit.hxx> 47 #include <editeng/bulitem.hxx> 48 #include <editeng/lrspitem.hxx> 49 #include <svx/unoshprp.hxx> 50 #include <svx/unoshape.hxx> 51 #include <svx/svdpool.hxx> 52 #include "stlsheet.hxx" 53 #include "sdresid.hxx" 54 #include "sdpage.hxx" 55 #include "drawdoc.hxx" 56 #include "stlpool.hxx" 57 #include "glob.hrc" 58 #include "app.hrc" 59 #include "glob.hxx" 60 #include "helpids.h" 61 #include "../ui/inc/DrawViewShell.hxx" 62 #include "../ui/inc/ViewShellBase.hxx" 63 #include <editeng/boxitem.hxx> 64 65 using ::rtl::OUString; 66 using ::osl::MutexGuard; 67 using ::osl::ClearableMutexGuard; 68 using ::cppu::OInterfaceContainerHelper; 69 using ::com::sun::star::table::BorderLine; 70 using namespace ::vos; 71 using namespace ::com::sun::star::uno; 72 using namespace ::com::sun::star::util; 73 using namespace ::com::sun::star::lang; 74 using namespace ::com::sun::star::style; 75 using namespace ::com::sun::star::beans; 76 using namespace ::com::sun::star::container; 77 using namespace ::com::sun::star::drawing; 78 79 #define WID_STYLE_DISPNAME 7998 80 #define WID_STYLE_FAMILY 7999 81 82 static SvxItemPropertySet& GetStylePropertySet() 83 { 84 static const SfxItemPropertyMapEntry aFullPropertyMap_Impl[] = 85 { 86 { RTL_CONSTASCII_STRINGPARAM("Family"), WID_STYLE_FAMILY, &::getCppuType((const OUString*)0), PropertyAttribute::READONLY, 0}, 87 { RTL_CONSTASCII_STRINGPARAM("UserDefinedAttributes"), SDRATTR_XMLATTRIBUTES, &XNameContainer::static_type(), 0, 0}, 88 { RTL_CONSTASCII_STRINGPARAM("DisplayName"), WID_STYLE_DISPNAME, &::getCppuType((const OUString*)0), PropertyAttribute::READONLY, 0}, 89 90 SVX_UNOEDIT_NUMBERING_PROPERTIE, 91 SHADOW_PROPERTIES 92 LINE_PROPERTIES 93 LINE_PROPERTIES_START_END 94 FILL_PROPERTIES 95 EDGERADIUS_PROPERTIES 96 TEXT_PROPERTIES_DEFAULTS 97 CONNECTOR_PROPERTIES 98 SPECIAL_DIMENSIONING_PROPERTIES_DEFAULTS 99 { MAP_CHAR_LEN("TopBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, TOP_BORDER }, \ 100 { MAP_CHAR_LEN("BottomBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, BOTTOM_BORDER }, \ 101 { MAP_CHAR_LEN("LeftBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, LEFT_BORDER }, \ 102 { MAP_CHAR_LEN("RightBorder"), SDRATTR_TABLE_BORDER, &::getCppuType((const BorderLine*)0), 0, RIGHT_BORDER }, \ 103 {0,0,0,0,0,0} 104 }; 105 106 static SvxItemPropertySet aPropSet( aFullPropertyMap_Impl, SdrObject::GetGlobalDrawObjectItemPool() ); 107 return aPropSet; 108 } 109 110 class ModifyListenerForewarder : public SfxListener 111 { 112 public: 113 ModifyListenerForewarder( SdStyleSheet* pStyleSheet ); 114 115 virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint); 116 117 private: 118 SdStyleSheet* mpStyleSheet; 119 }; 120 121 ModifyListenerForewarder::ModifyListenerForewarder( SdStyleSheet* pStyleSheet ) 122 : mpStyleSheet( pStyleSheet ) 123 { 124 if( pStyleSheet ) 125 { 126 SfxBroadcaster& rBC = static_cast< SfxBroadcaster& >( *pStyleSheet ); 127 StartListening( rBC ); 128 } 129 } 130 131 void ModifyListenerForewarder::Notify(SfxBroadcaster& /*rBC*/, const SfxHint& /*rHint*/) 132 { 133 if( mpStyleSheet ) 134 mpStyleSheet->notifyModifyListener(); 135 } 136 137 SdStyleSheet::SdStyleSheet(const OUString& rDisplayName, SfxStyleSheetBasePool& _rPool, SfxStyleFamily eFamily, sal_uInt16 _nMask) 138 : SdStyleSheetBase( UniString( rDisplayName ), _rPool, eFamily, _nMask) 139 , ::cppu::BaseMutex() 140 , msApiName( rDisplayName ) 141 , mxPool( const_cast< SfxStyleSheetBasePool* >(&_rPool) ) 142 , mrBHelper( m_aMutex ) 143 { 144 } 145 146 SdStyleSheet::SdStyleSheet( const SdStyleSheet & r ) 147 : SdStyleSheetBase( r ) 148 , ::cppu::BaseMutex() 149 , msApiName( r.msApiName ) 150 , mxPool( r.mxPool ) 151 , mrBHelper( m_aMutex ) 152 { 153 } 154 155 SdStyleSheet::~SdStyleSheet() 156 { 157 delete pSet; 158 pSet = NULL; // damit nachfolgende Destruktoren eine Chance haben 159 } 160 161 void SdStyleSheet::SetApiName( const OUString& rApiName ) 162 { 163 msApiName = rApiName; 164 } 165 166 rtl::OUString SdStyleSheet::GetApiName() const 167 { 168 if( msApiName.getLength() ) 169 return msApiName; 170 else 171 return GetName(); 172 } 173 174 175 void SdStyleSheet::Load (SvStream& rIn, sal_uInt16 nVersion) 176 { 177 SfxStyleSheetBase::Load(rIn, nVersion); 178 179 // Die Default-Maske war frueher 0xAFFE. 180 // Aus dieser Default-Maske wurden die benoetigten Flags ausmaskiert. 181 // Nun wurde das Flag SFXSTYLEBIT_READONLY eingefuehrt, was dazu 182 // das alle StyleSheets read-only waren. 183 // Da im Draw kein StyleSheet read-only sein soll, wird an dieser Stelle 184 // das Flag zurueckgesetzt. 185 nMask &= ~SFXSTYLEBIT_READONLY; 186 } 187 188 /************************************************************************* 189 |* 190 |* Store 191 |* 192 \************************************************************************/ 193 194 void SdStyleSheet::Store(SvStream& rOut) 195 { 196 SfxStyleSheetBase::Store(rOut); 197 } 198 199 /************************************************************************* 200 |* 201 |* Parent setzen 202 |* 203 \************************************************************************/ 204 205 sal_Bool SdStyleSheet::SetParent(const String& rParentName) 206 { 207 sal_Bool bResult = sal_False; 208 209 if (SfxStyleSheet::SetParent(rParentName)) 210 { 211 // PseudoStyleSheets haben keine eigenen ItemSets 212 if (nFamily != SD_STYLE_FAMILY_PSEUDO) 213 { 214 if( rParentName.Len() ) 215 { 216 SfxStyleSheetBase* pStyle = rPool.Find(rParentName, nFamily); 217 if (pStyle) 218 { 219 bResult = sal_True; 220 SfxItemSet& rParentSet = pStyle->GetItemSet(); 221 GetItemSet().SetParent(&rParentSet); 222 Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) ); 223 } 224 } 225 else 226 { 227 bResult = sal_True; 228 GetItemSet().SetParent(NULL); 229 Broadcast( SfxSimpleHint( SFX_HINT_DATACHANGED ) ); 230 } 231 } 232 else 233 { 234 bResult = sal_True; 235 } 236 } 237 return bResult; 238 } 239 240 /************************************************************************* 241 |* 242 |* ItemSet ggfs. erzeugen und herausreichen 243 |* 244 \************************************************************************/ 245 246 SfxItemSet& SdStyleSheet::GetItemSet() 247 { 248 if (nFamily == SD_STYLE_FAMILY_GRAPHICS || nFamily == SD_STYLE_FAMILY_MASTERPAGE) 249 { 250 // ggfs. das ItemSet 'on demand' anlegen 251 if (!pSet) 252 { 253 sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, XATTR_LINE_LAST, 254 XATTR_FILL_FIRST, XATTR_FILL_LAST, 255 256 SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST, 257 SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_CONTOURFRAME, 258 259 SDRATTR_TEXT_WORDWRAP, SDRATTR_TEXT_AUTOGROWSIZE, 260 261 SDRATTR_EDGE_FIRST, SDRATTR_EDGE_LAST, 262 SDRATTR_MEASURE_FIRST, SDRATTR_MEASURE_LAST, 263 264 EE_PARA_START, EE_CHAR_END, 265 266 SDRATTR_XMLATTRIBUTES, SDRATTR_TEXT_USEFIXEDCELLHEIGHT, 267 268 SDRATTR_3D_FIRST, SDRATTR_3D_LAST, 269 0, 0 }; 270 271 pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable); 272 } 273 274 return *pSet; 275 } 276 277 else if( nFamily == SD_STYLE_FAMILY_CELL ) 278 { 279 if (!pSet) 280 { 281 sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, XATTR_LINE_LAST, 282 XATTR_FILL_FIRST, XATTR_FILL_LAST, 283 284 SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST, 285 SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_CONTOURFRAME, 286 287 SDRATTR_TEXT_WORDWRAP, SDRATTR_TEXT_AUTOGROWSIZE, 288 289 EE_PARA_START, EE_CHAR_END, 290 291 SDRATTR_TABLE_FIRST, SDRATTR_TABLE_LAST, 292 SDRATTR_XMLATTRIBUTES, SDRATTR_XMLATTRIBUTES, 293 294 0, 0 }; 295 296 pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable); 297 } 298 299 return *pSet; 300 } 301 302 // dies ist eine Stellvertretervorlage fuer die interne Vorlage des 303 // aktuellen Praesentationslayouts: dessen ItemSet returnieren 304 else 305 { 306 // return (GetRealStyleSheet()->GetItemSet()); 307 308 SdStyleSheet* pSdSheet = GetRealStyleSheet(); 309 310 if (pSdSheet) 311 { 312 return(pSdSheet->GetItemSet()); 313 } 314 else 315 { 316 if (!pSet) 317 { 318 sal_uInt16 nWhichPairTable[] = { XATTR_LINE_FIRST, XATTR_LINE_LAST, 319 XATTR_FILL_FIRST, XATTR_FILL_LAST, 320 321 SDRATTR_SHADOW_FIRST, SDRATTR_SHADOW_LAST, 322 SDRATTR_TEXT_MINFRAMEHEIGHT, SDRATTR_TEXT_CONTOURFRAME, 323 324 SDRATTR_TEXT_WORDWRAP, SDRATTR_TEXT_AUTOGROWSIZE, 325 326 SDRATTR_EDGE_FIRST, SDRATTR_EDGE_LAST, 327 SDRATTR_MEASURE_FIRST, SDRATTR_MEASURE_LAST, 328 329 EE_PARA_START, EE_CHAR_END, 330 331 SDRATTR_XMLATTRIBUTES, SDRATTR_TEXT_USEFIXEDCELLHEIGHT, 332 333 SDRATTR_3D_FIRST, SDRATTR_3D_LAST, 334 0, 0 }; 335 336 pSet = new SfxItemSet(GetPool().GetPool(), nWhichPairTable); 337 } 338 339 return(*pSet); 340 } 341 } 342 } 343 344 /************************************************************************* 345 |* 346 |* IsUsed(), eine Vorlage gilt als benutzt, wenn sie von eingefuegten Objekten 347 |* oder von benutzten Vorlagen referenziert wird 348 |* 349 \************************************************************************/ 350 351 sal_Bool SdStyleSheet::IsUsed() const 352 { 353 sal_Bool bResult = sal_False; 354 355 sal_uInt16 nListenerCount = GetListenerCount(); 356 if (nListenerCount > 0) 357 { 358 for (sal_uInt16 n = 0; n < nListenerCount; n++) 359 { 360 SfxListener* pListener = GetListener(n); 361 if( pListener == this ) 362 continue; 363 364 // NULL-Pointer ist im Listener-Array erlaubt 365 if (pListener && pListener->ISA(SdrAttrObj)) 366 { 367 bResult = ((SdrAttrObj*)pListener)->IsInserted(); 368 } 369 else if (pListener && pListener->ISA(SfxStyleSheet)) 370 { 371 bResult = ((SfxStyleSheet*)pListener)->IsUsed(); 372 } 373 if (bResult) 374 break; 375 } 376 } 377 378 if( !bResult ) 379 { 380 MutexGuard aGuard( mrBHelper.rMutex ); 381 382 OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( XModifyListener::static_type() ); 383 if( pContainer ) 384 { 385 Sequence< Reference< XInterface > > aModifyListeners( pContainer->getElements() ); 386 Reference< XInterface > *p = aModifyListeners.getArray(); 387 sal_Int32 nCount = aModifyListeners.getLength(); 388 while( nCount-- && !bResult ) 389 { 390 Reference< XStyle > xStyle( *p++, UNO_QUERY ); 391 if( xStyle.is() ) 392 bResult = xStyle->isInUse(); 393 } 394 } 395 } 396 return bResult; 397 } 398 399 /************************************************************************* 400 |* 401 |* das StyleSheet ermitteln, fuer das dieses StyleSheet steht 402 |* 403 \************************************************************************/ 404 405 SdStyleSheet* SdStyleSheet::GetRealStyleSheet() const 406 { 407 String aRealStyle; 408 String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); 409 SdStyleSheet* pRealStyle = NULL; 410 SdDrawDocument* pDoc = ((SdStyleSheetPool&) rPool).GetDoc(); 411 412 ::sd::DrawViewShell* pDrawViewShell = 0; 413 414 ::sd::ViewShellBase* pBase = dynamic_cast< ::sd::ViewShellBase* >( SfxViewShell::Current() ); 415 if( pBase ) 416 pDrawViewShell = dynamic_cast< ::sd::DrawViewShell* >( pBase->GetMainViewShell().get() ); 417 418 if (pDrawViewShell && pDrawViewShell->GetDoc() == pDoc) 419 { 420 SdPage* pPage = pDrawViewShell->getCurrentPage(); 421 if( pPage ) 422 { 423 aRealStyle = pPage->GetLayoutName(); 424 // cut after seperator string 425 aRealStyle.Erase(aRealStyle.Search(aSep) + aSep.Len()); 426 } 427 } 428 429 if (aRealStyle.Len() == 0) 430 { 431 SdPage* pPage = pDoc->GetSdPage(0, PK_STANDARD); 432 433 if (pPage) 434 { 435 aRealStyle = pDoc->GetSdPage(0, PK_STANDARD)->GetLayoutName(); 436 } 437 else 438 { 439 // Noch keine Seite vorhanden 440 // Dieses kann beim Aktualisieren vonDokumentvorlagen vorkommen 441 SfxStyleSheetIterator aIter(&rPool, SD_STYLE_FAMILY_MASTERPAGE); 442 SfxStyleSheetBase* pSheet = aIter.First(); 443 if( pSheet ) 444 aRealStyle = pSheet->GetName(); 445 } 446 447 aRealStyle.Erase(aRealStyle.Search(aSep) + aSep.Len()); 448 } 449 450 // jetzt vom Namen (landessprachlich angepasst) auf den internen 451 // Namen (unabhaengig von der Landessprache) mappen 452 String aInternalName; 453 454 if (aName == String(SdResId(STR_PSEUDOSHEET_TITLE))) 455 { 456 aInternalName = String(SdResId(STR_LAYOUT_TITLE)); 457 } 458 else if (aName == String(SdResId(STR_PSEUDOSHEET_SUBTITLE))) 459 { 460 aInternalName = String(SdResId(STR_LAYOUT_SUBTITLE)); 461 } 462 else if (aName == String(SdResId(STR_PSEUDOSHEET_BACKGROUND))) 463 { 464 aInternalName = String(SdResId(STR_LAYOUT_BACKGROUND)); 465 } 466 else if (aName == String(SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS))) 467 { 468 aInternalName = String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS)); 469 } 470 else if (aName == String(SdResId(STR_PSEUDOSHEET_NOTES))) 471 { 472 aInternalName = String(SdResId(STR_LAYOUT_NOTES)); 473 } 474 else 475 { 476 String aOutlineStr(SdResId(STR_PSEUDOSHEET_OUTLINE)); 477 sal_uInt16 nPos = aName.Search(aOutlineStr); 478 if (nPos != STRING_NOTFOUND) 479 { 480 String aNumStr(aName.Copy(aOutlineStr.Len())); 481 aInternalName = String(SdResId(STR_LAYOUT_OUTLINE)); 482 aInternalName += aNumStr; 483 } 484 } 485 486 aRealStyle += aInternalName; 487 pRealStyle = static_cast< SdStyleSheet* >( rPool.Find(aRealStyle, SD_STYLE_FAMILY_MASTERPAGE) ); 488 489 #ifdef DBG_UTIL 490 if( !pRealStyle ) 491 { 492 SfxStyleSheetIterator aIter(&rPool, SD_STYLE_FAMILY_MASTERPAGE); 493 if( aIter.Count() > 0 ) 494 // StyleSheet not found, but pool already loaded 495 DBG_ASSERT(pRealStyle, "Internal StyleSheet not found"); 496 } 497 #endif 498 499 return pRealStyle; 500 } 501 502 /************************************************************************* 503 |* 504 |* das PseudoStyleSheet ermitteln, durch das dieses StyleSheet vertreten wird 505 |* 506 \************************************************************************/ 507 508 SdStyleSheet* SdStyleSheet::GetPseudoStyleSheet() const 509 { 510 SdStyleSheet* pPseudoStyle = NULL; 511 String aSep( RTL_CONSTASCII_USTRINGPARAM( SD_LT_SEPARATOR )); 512 String aStyleName(aName); 513 // ohne Layoutnamen und Separator 514 aStyleName.Erase(0, aStyleName.Search(aSep) + aSep.Len()); 515 516 if (aStyleName == String(SdResId(STR_LAYOUT_TITLE))) 517 { 518 aStyleName = String(SdResId(STR_PSEUDOSHEET_TITLE)); 519 } 520 else if (aStyleName == String(SdResId(STR_LAYOUT_SUBTITLE))) 521 { 522 aStyleName = String(SdResId(STR_PSEUDOSHEET_SUBTITLE)); 523 } 524 else if (aStyleName == String(SdResId(STR_LAYOUT_BACKGROUND))) 525 { 526 aStyleName = String(SdResId(STR_PSEUDOSHEET_BACKGROUND)); 527 } 528 else if (aStyleName == String(SdResId(STR_LAYOUT_BACKGROUNDOBJECTS))) 529 { 530 aStyleName = String(SdResId(STR_PSEUDOSHEET_BACKGROUNDOBJECTS)); 531 } 532 else if (aStyleName == String(SdResId(STR_LAYOUT_NOTES))) 533 { 534 aStyleName = String(SdResId(STR_PSEUDOSHEET_NOTES)); 535 } 536 else 537 { 538 String aOutlineStr((SdResId(STR_LAYOUT_OUTLINE))); 539 sal_uInt16 nPos = aStyleName.Search(aOutlineStr); 540 if (nPos != STRING_NOTFOUND) 541 { 542 String aNumStr(aStyleName.Copy(aOutlineStr.Len())); 543 aStyleName = String(SdResId(STR_PSEUDOSHEET_OUTLINE)); 544 aStyleName += aNumStr; 545 } 546 } 547 548 pPseudoStyle = static_cast<SdStyleSheet*>(rPool.Find(aStyleName, SD_STYLE_FAMILY_PSEUDO)); 549 DBG_ASSERT(pPseudoStyle, "PseudoStyleSheet nicht gefunden"); 550 551 return pPseudoStyle; 552 } 553 554 555 /************************************************************************* 556 |* 557 |* Notify 558 |* 559 \************************************************************************/ 560 561 void SdStyleSheet::Notify(SfxBroadcaster& rBC, const SfxHint& rHint) 562 { 563 // erstmal die Basisklassenfunktionalitaet 564 SfxStyleSheet::Notify(rBC, rHint); 565 566 // wenn der Stellvertreter ein Notify bezueglich geaenderter Attribute 567 // bekommt, sorgt er dafuer, dass das eigentlich gemeinte StyleSheet 568 // broadcastet 569 SfxSimpleHint* pSimple = PTR_CAST(SfxSimpleHint, &rHint); 570 sal_uLong nId = pSimple == NULL ? 0 : pSimple->GetId(); 571 if (nId == SFX_HINT_DATACHANGED && nFamily == SD_STYLE_FAMILY_PSEUDO) 572 { 573 SdStyleSheet* pRealStyle = GetRealStyleSheet(); 574 if (pRealStyle) 575 pRealStyle->Broadcast(rHint); 576 } 577 } 578 579 /************************************************************************* 580 |* AdjustToFontHeight passt die Bulletbreite und den linken Texteinzug 581 |* des uebergebenen ItemSets dessen Fonthoehe an. Die neuen Werte werden so 582 |* berechnet, dass das Verhaeltnis zur Fonthoehe so ist wie im StyleSheet. 583 |* 584 |* bOnlyMissingItems legt fest, ob lediglich nicht gesetzte Items ergaenzt 585 |* (sal_True) oder explizit gesetzte Items ueberschreiben werden sollen (sal_False) 586 |* 587 \************************************************************************/ 588 589 void SdStyleSheet::AdjustToFontHeight(SfxItemSet& rSet, sal_Bool bOnlyMissingItems) 590 { 591 // Bulletbreite und Texteinzug an neue Fonthoehe 592 // anpassen, wenn sie nicht explizit gesetzt wurden 593 SfxStyleFamily eFamily = nFamily; 594 String aStyleName(aName); 595 if (eFamily == SD_STYLE_FAMILY_PSEUDO) 596 { 597 SfxStyleSheet* pRealStyle = GetRealStyleSheet(); 598 eFamily = pRealStyle->GetFamily(); 599 aStyleName = pRealStyle->GetName(); 600 } 601 602 if (eFamily == SD_STYLE_FAMILY_MASTERPAGE && 603 aStyleName.Search(String(SdResId(STR_LAYOUT_OUTLINE))) != STRING_NOTFOUND && 604 rSet.GetItemState(EE_CHAR_FONTHEIGHT) == SFX_ITEM_SET) 605 { 606 const SfxItemSet* pCurSet = &GetItemSet(); 607 sal_uInt32 nNewHeight = ((SvxFontHeightItem&)rSet.Get(EE_CHAR_FONTHEIGHT)).GetHeight(); 608 sal_uInt32 nOldHeight = ((SvxFontHeightItem&)pCurSet->Get(EE_CHAR_FONTHEIGHT)).GetHeight(); 609 610 if (rSet.GetItemState(EE_PARA_BULLET) != SFX_ITEM_SET || !bOnlyMissingItems) 611 { 612 const SvxBulletItem& rBItem = (const SvxBulletItem&)pCurSet->Get(EE_PARA_BULLET); 613 double fBulletFraction = double(rBItem.GetWidth()) / nOldHeight; 614 SvxBulletItem aNewBItem(rBItem); 615 aNewBItem.SetWidth((sal_uInt32)(fBulletFraction * nNewHeight)); 616 rSet.Put(aNewBItem); 617 } 618 619 if (rSet.GetItemState(EE_PARA_LRSPACE) != SFX_ITEM_SET || !bOnlyMissingItems) 620 { 621 const SvxLRSpaceItem& rLRItem = (const SvxLRSpaceItem&)pCurSet->Get(EE_PARA_LRSPACE); 622 double fIndentFraction = double(rLRItem.GetTxtLeft()) / nOldHeight; 623 SvxLRSpaceItem aNewLRItem(rLRItem); 624 aNewLRItem.SetTxtLeft((sal_uInt16)(fIndentFraction * nNewHeight)); 625 double fFirstIndentFraction = double(rLRItem.GetTxtFirstLineOfst()) / nOldHeight; 626 aNewLRItem.SetTxtFirstLineOfst((short)(fFirstIndentFraction * nNewHeight)); 627 rSet.Put(aNewLRItem); 628 } 629 630 if (rSet.GetItemState(EE_PARA_ULSPACE) != SFX_ITEM_SET || !bOnlyMissingItems) 631 { 632 const SvxULSpaceItem& rULItem = (const SvxULSpaceItem&)pCurSet->Get(EE_PARA_ULSPACE); 633 SvxULSpaceItem aNewULItem(rULItem); 634 double fLowerFraction = double(rULItem.GetLower()) / nOldHeight; 635 aNewULItem.SetLower((sal_uInt16)(fLowerFraction * nNewHeight)); 636 double fUpperFraction = double(rULItem.GetUpper()) / nOldHeight; 637 aNewULItem.SetUpper((sal_uInt16)(fUpperFraction * nNewHeight)); 638 rSet.Put(aNewULItem); 639 } 640 } 641 } 642 643 // -------------------------------------------------------------------- 644 645 sal_Bool SdStyleSheet::HasFollowSupport() const 646 { 647 return sal_False; 648 } 649 650 // -------------------------------------------------------------------- 651 652 sal_Bool SdStyleSheet::HasParentSupport() const 653 { 654 return sal_True; 655 } 656 657 // -------------------------------------------------------------------- 658 659 sal_Bool SdStyleSheet::HasClearParentSupport() const 660 { 661 return sal_True; 662 } 663 664 // -------------------------------------------------------------------- 665 666 sal_Bool SdStyleSheet::SetName( const UniString& rName ) 667 { 668 return SfxStyleSheet::SetName( rName ); 669 } 670 671 // -------------------------------------------------------------------- 672 673 void SdStyleSheet::SetHelpId( const String& r, sal_uLong nId ) 674 { 675 SfxStyleSheet::SetHelpId( r, nId ); 676 677 if( (nId >= HID_PSEUDOSHEET_OUTLINE1) && ( nId <= HID_PSEUDOSHEET_OUTLINE9 ) ) 678 { 679 msApiName = OUString( RTL_CONSTASCII_USTRINGPARAM("outline") ); 680 msApiName += OUString( (sal_Unicode)( '1' + (nId - HID_PSEUDOSHEET_OUTLINE1) ) ); 681 } 682 else 683 { 684 static struct ApiNameMap 685 { 686 const sal_Char* mpApiName; 687 sal_uInt32 mnApiNameLength; 688 sal_uInt32 mnHelpId; 689 } 690 pApiNameMap[] = 691 { 692 { RTL_CONSTASCII_STRINGPARAM( "title" ), HID_PSEUDOSHEET_TITLE }, 693 { RTL_CONSTASCII_STRINGPARAM( "subtitle" ), HID_PSEUDOSHEET_SUBTITLE }, 694 { RTL_CONSTASCII_STRINGPARAM( "background" ), HID_PSEUDOSHEET_BACKGROUND }, 695 { RTL_CONSTASCII_STRINGPARAM( "backgroundobjects" ),HID_PSEUDOSHEET_BACKGROUNDOBJECTS }, 696 { RTL_CONSTASCII_STRINGPARAM( "notes" ), HID_PSEUDOSHEET_NOTES }, 697 { RTL_CONSTASCII_STRINGPARAM( "standard" ), HID_STANDARD_STYLESHEET_NAME }, 698 { RTL_CONSTASCII_STRINGPARAM( "objectwitharrow" ), HID_POOLSHEET_OBJWITHARROW }, 699 { RTL_CONSTASCII_STRINGPARAM( "objectwithshadow" ), HID_POOLSHEET_OBJWITHSHADOW }, 700 { RTL_CONSTASCII_STRINGPARAM( "objectwithoutfill" ),HID_POOLSHEET_OBJWITHOUTFILL }, 701 { RTL_CONSTASCII_STRINGPARAM( "text" ), HID_POOLSHEET_TEXT }, 702 { RTL_CONSTASCII_STRINGPARAM( "textbody" ), HID_POOLSHEET_TEXTBODY }, 703 { RTL_CONSTASCII_STRINGPARAM( "textbodyjustfied" ), HID_POOLSHEET_TEXTBODY_JUSTIFY }, 704 { RTL_CONSTASCII_STRINGPARAM( "textbodyindent" ), HID_POOLSHEET_TEXTBODY_INDENT }, 705 { RTL_CONSTASCII_STRINGPARAM( "title" ), HID_POOLSHEET_TITLE }, 706 { RTL_CONSTASCII_STRINGPARAM( "title1" ), HID_POOLSHEET_TITLE1 }, 707 { RTL_CONSTASCII_STRINGPARAM( "title2" ), HID_POOLSHEET_TITLE2 }, 708 { RTL_CONSTASCII_STRINGPARAM( "headline" ), HID_POOLSHEET_HEADLINE }, 709 { RTL_CONSTASCII_STRINGPARAM( "headline1" ), HID_POOLSHEET_HEADLINE1 }, 710 { RTL_CONSTASCII_STRINGPARAM( "headline2" ), HID_POOLSHEET_HEADLINE2 }, 711 { RTL_CONSTASCII_STRINGPARAM( "measure" ), HID_POOLSHEET_MEASURE }, 712 { 0, 0, 0 } 713 }; 714 715 ApiNameMap* p = pApiNameMap; 716 while( p->mpApiName ) 717 { 718 if( nId == p->mnHelpId ) 719 { 720 msApiName = OUString( p->mpApiName, p->mnApiNameLength, RTL_TEXTENCODING_ASCII_US ); 721 break; 722 } 723 p++; 724 } 725 } 726 } 727 728 // -------------------------------------------------------------------- 729 730 OUString SdStyleSheet::GetFamilyString( SfxStyleFamily eFamily ) 731 { 732 switch( eFamily ) 733 { 734 case SD_STYLE_FAMILY_CELL: 735 return OUString( RTL_CONSTASCII_USTRINGPARAM( "cell" ) ); 736 default: 737 DBG_ERROR( "SdStyleSheet::GetFamilyString(), illegal family!" ); 738 case SD_STYLE_FAMILY_GRAPHICS: 739 return OUString( RTL_CONSTASCII_USTRINGPARAM( "graphics" ) ); 740 } 741 } 742 743 // -------------------------------------------------------------------- 744 745 void SdStyleSheet::throwIfDisposed() throw (RuntimeException) 746 { 747 if( !mxPool.is() ) 748 throw DisposedException(); 749 } 750 751 // -------------------------------------------------------------------- 752 753 SdStyleSheet* SdStyleSheet::CreateEmptyUserStyle( SfxStyleSheetBasePool& rPool, SfxStyleFamily eFamily ) 754 { 755 OUString aPrefix( RTL_CONSTASCII_USTRINGPARAM("user") ); 756 OUString aName; 757 sal_Int32 nIndex = 1; 758 do 759 { 760 aName = aPrefix + OUString::valueOf( nIndex++ ); 761 } 762 while( rPool.Find( aName, eFamily ) != 0 ); 763 764 return new SdStyleSheet(aName, rPool, eFamily, SFXSTYLEBIT_USERDEF); 765 } 766 767 // -------------------------------------------------------------------- 768 // XInterface 769 // -------------------------------------------------------------------- 770 771 /* 772 Any SAL_CALL SdStyleSheet::queryInterface( const ::com::sun::star::uno::Type& aType ) throw (RuntimeException) 773 { 774 return SdStyleSheetBase::queryInterface( aType ); 775 } 776 777 // -------------------------------------------------------------------- 778 779 void SAL_CALL SdStyleSheet::acquire( ) throw () 780 { 781 SdStyleSheetBase::acquire(); 782 } 783 784 // -------------------------------------------------------------------- 785 */ 786 void SAL_CALL SdStyleSheet::release( ) throw () 787 { 788 if (osl_decrementInterlockedCount( &m_refCount ) == 0) 789 { 790 // restore reference count: 791 osl_incrementInterlockedCount( &m_refCount ); 792 if (! mrBHelper.bDisposed) try 793 { 794 dispose(); 795 } 796 catch (RuntimeException const& exc) 797 { // don't break throw () 798 OSL_ENSURE( 799 false, OUStringToOString( 800 exc.Message, RTL_TEXTENCODING_ASCII_US ).getStr() ); 801 static_cast<void>(exc); 802 } 803 OSL_ASSERT( mrBHelper.bDisposed ); 804 SdStyleSheetBase::release(); 805 } 806 } 807 808 // -------------------------------------------------------------------- 809 // XWeak 810 // -------------------------------------------------------------------- 811 /* 812 Reference< XAdapter > SAL_CALL SdStyleSheet::queryAdapter( ) throw (RuntimeException) 813 { 814 return SdStyleSheetBase::queryAdapter(); 815 } 816 817 // -------------------------------------------------------------------- 818 // XTypeProvider 819 // -------------------------------------------------------------------- 820 821 Sequence< Type > SAL_CALL SdStyleSheet::getTypes( ) throw (RuntimeException) 822 { 823 return SdStyleSheetBase::getTypes(); 824 } 825 826 // -------------------------------------------------------------------- 827 828 Sequence< ::sal_Int8 > SAL_CALL SdStyleSheet::getImplementationId( ) throw (RuntimeException) 829 { 830 return SdStyleSheetBase::getImplementationId(); 831 } 832 */ 833 // -------------------------------------------------------------------- 834 // XComponent 835 // -------------------------------------------------------------------- 836 837 void SAL_CALL SdStyleSheet::dispose( ) throw (RuntimeException) 838 { 839 ClearableMutexGuard aGuard( mrBHelper.rMutex ); 840 if (!mrBHelper.bDisposed && !mrBHelper.bInDispose) 841 { 842 mrBHelper.bInDispose = sal_True; 843 aGuard.clear(); 844 try 845 { 846 // side effect: keeping a reference to this 847 EventObject aEvt( static_cast< OWeakObject * >( this ) ); 848 try 849 { 850 mrBHelper.aLC.disposeAndClear( aEvt ); 851 disposing(); 852 } 853 catch (...) 854 { 855 MutexGuard aGuard2( mrBHelper.rMutex ); 856 // bDisposed and bInDispose must be set in this order: 857 mrBHelper.bDisposed = sal_True; 858 mrBHelper.bInDispose = sal_False; 859 throw; 860 } 861 MutexGuard aGuard2( mrBHelper.rMutex ); 862 // bDisposed and bInDispose must be set in this order: 863 mrBHelper.bDisposed = sal_True; 864 mrBHelper.bInDispose = sal_False; 865 } 866 catch (RuntimeException &) 867 { 868 throw; 869 } 870 catch (Exception & exc) 871 { 872 throw RuntimeException( 873 OUString( RTL_CONSTASCII_USTRINGPARAM( 874 "unexpected UNO exception caught: ") ) + 875 exc.Message, Reference< XInterface >() ); 876 } 877 } 878 } 879 880 // -------------------------------------------------------------------- 881 882 void SdStyleSheet::disposing() 883 { 884 mxPool.clear(); 885 } 886 887 // -------------------------------------------------------------------- 888 889 void SAL_CALL SdStyleSheet::addEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException) 890 { 891 ClearableMutexGuard aGuard( mrBHelper.rMutex ); 892 if (mrBHelper.bDisposed || mrBHelper.bInDispose) 893 { 894 aGuard.clear(); 895 EventObject aEvt( static_cast< OWeakObject * >( this ) ); 896 xListener->disposing( aEvt ); 897 } 898 else 899 { 900 mrBHelper.addListener( ::getCppuType( &xListener ), xListener ); 901 } 902 } 903 904 // -------------------------------------------------------------------- 905 906 void SAL_CALL SdStyleSheet::removeEventListener( const Reference< XEventListener >& xListener ) throw (RuntimeException) 907 { 908 mrBHelper.removeListener( ::getCppuType( &xListener ), xListener ); 909 } 910 911 //------------------------------------------------------------------------ 912 // XModifyBroadcaster 913 //------------------------------------------------------------------------ 914 915 void SAL_CALL SdStyleSheet::addModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException) 916 { 917 ClearableMutexGuard aGuard( mrBHelper.rMutex ); 918 if (mrBHelper.bDisposed || mrBHelper.bInDispose) 919 { 920 aGuard.clear(); 921 EventObject aEvt( static_cast< OWeakObject * >( this ) ); 922 xListener->disposing( aEvt ); 923 } 924 else 925 { 926 if( !mpModifyListenerForewarder.get() ) 927 mpModifyListenerForewarder.reset( new ModifyListenerForewarder( this ) ); 928 mrBHelper.addListener( XModifyListener::static_type(), xListener ); 929 } 930 } 931 932 //------------------------------------------------------------------------ 933 934 void SAL_CALL SdStyleSheet::removeModifyListener( const Reference< XModifyListener >& xListener ) throw (RuntimeException) 935 { 936 mrBHelper.removeListener( XModifyListener::static_type(), xListener ); 937 } 938 939 //------------------------------------------------------------------------ 940 941 void SdStyleSheet::notifyModifyListener() 942 { 943 MutexGuard aGuard( mrBHelper.rMutex ); 944 945 OInterfaceContainerHelper * pContainer = mrBHelper.getContainer( XModifyListener::static_type() ); 946 if( pContainer ) 947 { 948 EventObject aEvt( static_cast< OWeakObject * >( this ) ); 949 pContainer->forEach<XModifyListener>( boost::bind( &XModifyListener::modified, _1, boost::cref( aEvt ) ) ); 950 } 951 } 952 953 954 // -------------------------------------------------------------------- 955 // XServiceInfo 956 // -------------------------------------------------------------------- 957 958 OUString SAL_CALL SdStyleSheet::getImplementationName() throw(RuntimeException) 959 { 960 return OUString::createFromAscii( "SdStyleSheet" ); 961 } 962 963 // -------------------------------------------------------------------- 964 965 sal_Bool SAL_CALL SdStyleSheet::supportsService( const OUString& ServiceName ) throw(RuntimeException) 966 { 967 return comphelper::ServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() ); 968 } 969 970 // -------------------------------------------------------------------- 971 972 Sequence< OUString > SAL_CALL SdStyleSheet::getSupportedServiceNames() throw(RuntimeException) 973 { 974 Sequence< OUString > aNameSequence( 10 ); 975 OUString* pStrings = aNameSequence.getArray(); 976 977 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.Style" ) ); 978 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.FillProperties" ) ); 979 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.LineProperties" ) ); 980 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.ShadowProperties" ) ); 981 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.ConnectorProperties" ) ); 982 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.MeasureProperties" ) ); 983 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.ParagraphProperties" ) ); 984 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.style.CharacterProperties" ) ); 985 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.TextProperties" ) ); 986 *pStrings++ = OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.Text" ) ); 987 988 return aNameSequence; 989 } 990 991 // -------------------------------------------------------------------- 992 // XNamed 993 // -------------------------------------------------------------------- 994 995 OUString SAL_CALL SdStyleSheet::getName() throw(RuntimeException) 996 { 997 OGuard aGuard( Application::GetSolarMutex() ); 998 throwIfDisposed(); 999 return GetApiName(); 1000 } 1001 1002 // -------------------------------------------------------------------- 1003 1004 void SAL_CALL SdStyleSheet::setName( const OUString& rName ) throw(RuntimeException) 1005 { 1006 OGuard aGuard( Application::GetSolarMutex() ); 1007 throwIfDisposed(); 1008 1009 if( SetName( rName ) ) 1010 { 1011 msApiName = rName; 1012 Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); 1013 } 1014 } 1015 1016 // -------------------------------------------------------------------- 1017 // XStyle 1018 // -------------------------------------------------------------------- 1019 1020 sal_Bool SAL_CALL SdStyleSheet::isUserDefined() throw(RuntimeException) 1021 { 1022 OGuard aGuard( Application::GetSolarMutex() ); 1023 throwIfDisposed(); 1024 return IsUserDefined() ? sal_True : sal_False; 1025 } 1026 1027 // -------------------------------------------------------------------- 1028 1029 sal_Bool SAL_CALL SdStyleSheet::isInUse() throw(RuntimeException) 1030 { 1031 OGuard aGuard( Application::GetSolarMutex() ); 1032 throwIfDisposed(); 1033 return IsUsed() ? sal_True : sal_False; 1034 } 1035 1036 // -------------------------------------------------------------------- 1037 1038 OUString SAL_CALL SdStyleSheet::getParentStyle() throw(RuntimeException) 1039 { 1040 OGuard aGuard( Application::GetSolarMutex() ); 1041 throwIfDisposed(); 1042 1043 if( GetParent().Len() ) 1044 { 1045 SdStyleSheet* pParentStyle = static_cast< SdStyleSheet* >( mxPool->Find( GetParent(), nFamily ) ); 1046 if( pParentStyle ) 1047 return pParentStyle->msApiName; 1048 } 1049 return OUString(); 1050 } 1051 1052 // -------------------------------------------------------------------- 1053 1054 void SAL_CALL SdStyleSheet::setParentStyle( const OUString& rParentName ) throw(NoSuchElementException, RuntimeException) 1055 { 1056 OGuard aGuard( Application::GetSolarMutex() ); 1057 throwIfDisposed(); 1058 1059 if( rParentName.getLength() ) 1060 { 1061 const SfxStyles& rStyles = mxPool->GetStyles(); 1062 1063 for( SfxStyles::const_iterator iter( rStyles.begin() ); iter != rStyles.end(); iter++ ) 1064 { 1065 SdStyleSheet* pStyle = static_cast< SdStyleSheet* >( (*iter).get() ); 1066 if( pStyle && (pStyle->nFamily == nFamily) && (pStyle->msApiName == rParentName) ) 1067 { 1068 if( pStyle != this ) 1069 SetParent( pStyle->GetName() ); 1070 return; 1071 } 1072 } 1073 throw NoSuchElementException(); 1074 } 1075 else 1076 { 1077 SetParent( rParentName ); 1078 } 1079 } 1080 1081 // -------------------------------------------------------------------- 1082 // XPropertySet 1083 // -------------------------------------------------------------------- 1084 1085 Reference< XPropertySetInfo > SdStyleSheet::getPropertySetInfo() throw(RuntimeException) 1086 { 1087 throwIfDisposed(); 1088 static Reference< XPropertySetInfo > xInfo; 1089 if( !xInfo.is() ) 1090 xInfo = GetStylePropertySet().getPropertySetInfo(); 1091 return xInfo; 1092 } 1093 1094 // -------------------------------------------------------------------- 1095 1096 void SAL_CALL SdStyleSheet::setPropertyValue( const OUString& aPropertyName, const Any& aValue ) throw(UnknownPropertyException, PropertyVetoException, IllegalArgumentException, WrappedTargetException, RuntimeException) 1097 { 1098 OGuard aGuard( Application::GetSolarMutex() ); 1099 throwIfDisposed(); 1100 1101 const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName ); 1102 if( pEntry == NULL ) 1103 { 1104 throw UnknownPropertyException(); 1105 } 1106 else 1107 { 1108 if( pEntry->nWID == SDRATTR_TEXTDIRECTION ) 1109 return; // not yet implemented for styles 1110 1111 if( pEntry->nWID == WID_STYLE_FAMILY ) 1112 throw PropertyVetoException(); 1113 1114 if( (pEntry->nWID == EE_PARA_NUMBULLET) && (GetFamily() == SD_STYLE_FAMILY_MASTERPAGE) ) 1115 { 1116 String aStr; 1117 const sal_uInt32 nTempHelpId = GetHelpId( aStr ); 1118 1119 if( (nTempHelpId >= HID_PSEUDOSHEET_OUTLINE2) && (nTempHelpId <= HID_PSEUDOSHEET_OUTLINE9) ) 1120 return; 1121 } 1122 1123 SfxItemSet &rStyleSet = GetItemSet(); 1124 1125 if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE ) 1126 { 1127 BitmapMode eMode; 1128 if( aValue >>= eMode ) 1129 { 1130 rStyleSet.Put( XFillBmpStretchItem( eMode == BitmapMode_STRETCH ) ); 1131 rStyleSet.Put( XFillBmpTileItem( eMode == BitmapMode_REPEAT ) ); 1132 return; 1133 } 1134 throw IllegalArgumentException(); 1135 } 1136 1137 SfxItemSet aSet( GetPool().GetPool(), pEntry->nWID, pEntry->nWID); 1138 aSet.Put( rStyleSet ); 1139 1140 if( !aSet.Count() ) 1141 { 1142 if( EE_PARA_NUMBULLET == pEntry->nWID ) 1143 { 1144 Font aBulletFont; 1145 SdStyleSheetPool::PutNumBulletItem( this, aBulletFont ); 1146 aSet.Put( rStyleSet ); 1147 } 1148 else 1149 { 1150 aSet.Put( GetPool().GetPool().GetDefaultItem( pEntry->nWID ) ); 1151 } 1152 } 1153 1154 if( pEntry->nMemberId == MID_NAME && 1155 ( pEntry->nWID == XATTR_FILLBITMAP || pEntry->nWID == XATTR_FILLGRADIENT || 1156 pEntry->nWID == XATTR_FILLHATCH || pEntry->nWID == XATTR_FILLFLOATTRANSPARENCE || 1157 pEntry->nWID == XATTR_LINESTART || pEntry->nWID == XATTR_LINEEND || pEntry->nWID == XATTR_LINEDASH) ) 1158 { 1159 OUString aTempName; 1160 if(!(aValue >>= aTempName )) 1161 throw IllegalArgumentException(); 1162 1163 SvxShape::SetFillAttribute( pEntry->nWID, aTempName, aSet ); 1164 } 1165 else if(!SvxUnoTextRangeBase::SetPropertyValueHelper( aSet, pEntry, aValue, aSet )) 1166 { 1167 SvxItemPropertySet_setPropertyValue( GetStylePropertySet(), pEntry, aValue, aSet ); 1168 } 1169 1170 rStyleSet.Put( aSet ); 1171 Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); 1172 } 1173 } 1174 1175 // -------------------------------------------------------------------- 1176 1177 Any SAL_CALL SdStyleSheet::getPropertyValue( const OUString& PropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 1178 { 1179 OGuard aGuard( Application::GetSolarMutex() ); 1180 1181 throwIfDisposed(); 1182 1183 const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName ); 1184 if( pEntry == NULL ) 1185 { 1186 throw UnknownPropertyException(); 1187 } 1188 else 1189 { 1190 Any aAny; 1191 1192 if( pEntry->nWID == WID_STYLE_FAMILY ) 1193 { 1194 if( nFamily == SD_STYLE_FAMILY_MASTERPAGE ) 1195 { 1196 const OUString aLayoutName( GetName() ); 1197 aAny <<= aLayoutName.copy( 0, aLayoutName.indexOf(OUString( RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR) ) ) ); 1198 } 1199 else 1200 { 1201 aAny <<= GetFamilyString(nFamily); 1202 } 1203 } 1204 else if( pEntry->nWID == WID_STYLE_DISPNAME ) 1205 { 1206 aAny <<= maDisplayName; 1207 } 1208 else if( pEntry->nWID == SDRATTR_TEXTDIRECTION ) 1209 { 1210 aAny <<= sal_False; 1211 } 1212 else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE ) 1213 { 1214 SfxItemSet &rStyleSet = GetItemSet(); 1215 1216 XFillBmpStretchItem* pStretchItem = (XFillBmpStretchItem*)rStyleSet.GetItem(XATTR_FILLBMP_STRETCH); 1217 XFillBmpTileItem* pTileItem = (XFillBmpTileItem*)rStyleSet.GetItem(XATTR_FILLBMP_TILE); 1218 1219 if( pStretchItem && pTileItem ) 1220 { 1221 if( pTileItem->GetValue() ) 1222 aAny <<= BitmapMode_REPEAT; 1223 else if( pStretchItem->GetValue() ) 1224 aAny <<= BitmapMode_STRETCH; 1225 else 1226 aAny <<= BitmapMode_NO_REPEAT; 1227 } 1228 } 1229 else 1230 { 1231 SfxItemSet aSet( GetPool().GetPool(), pEntry->nWID, pEntry->nWID); 1232 1233 const SfxPoolItem* pItem; 1234 SfxItemSet& rStyleSet = GetItemSet(); 1235 1236 if( rStyleSet.GetItemState( pEntry->nWID, sal_True, &pItem ) == SFX_ITEM_SET ) 1237 aSet.Put( *pItem ); 1238 1239 if( !aSet.Count() ) 1240 aSet.Put( GetPool().GetPool().GetDefaultItem( pEntry->nWID ) ); 1241 1242 if(SvxUnoTextRangeBase::GetPropertyValueHelper( aSet, pEntry, aAny )) 1243 return aAny; 1244 1245 // Hole Wert aus ItemSet 1246 aAny = SvxItemPropertySet_getPropertyValue( GetStylePropertySet(),pEntry, aSet ); 1247 } 1248 1249 if( *pEntry->pType != aAny.getValueType() ) 1250 { 1251 // since the sfx uint16 item now exports a sal_Int32, we may have to fix this here 1252 if( ( *pEntry->pType == ::getCppuType((const sal_Int16*)0)) && aAny.getValueType() == ::getCppuType((const sal_Int32*)0) ) 1253 { 1254 sal_Int32 nValue = 0; 1255 aAny >>= nValue; 1256 aAny <<= (sal_Int16)nValue; 1257 } 1258 else 1259 { 1260 DBG_ERROR("SvxShape::GetAnyForItem() Returnvalue has wrong Type!" ); 1261 } 1262 } 1263 1264 return aAny; 1265 } 1266 } 1267 1268 // -------------------------------------------------------------------- 1269 1270 void SAL_CALL SdStyleSheet::addPropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >& ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {} 1271 void SAL_CALL SdStyleSheet::removePropertyChangeListener( const OUString& , const Reference< XPropertyChangeListener >& ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {} 1272 void SAL_CALL SdStyleSheet::addVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >& ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {} 1273 void SAL_CALL SdStyleSheet::removeVetoableChangeListener( const OUString& , const Reference< XVetoableChangeListener >& ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) {} 1274 1275 // -------------------------------------------------------------------- 1276 // XPropertyState 1277 // -------------------------------------------------------------------- 1278 1279 PropertyState SAL_CALL SdStyleSheet::getPropertyState( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException) 1280 { 1281 OGuard aGuard( Application::GetSolarMutex() ); 1282 1283 throwIfDisposed(); 1284 1285 const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName ); 1286 1287 if( pEntry == NULL ) 1288 throw UnknownPropertyException(); 1289 1290 if( pEntry->nWID == WID_STYLE_FAMILY ) 1291 { 1292 return PropertyState_DIRECT_VALUE; 1293 } 1294 else if( pEntry->nWID == SDRATTR_TEXTDIRECTION ) 1295 { 1296 return PropertyState_DEFAULT_VALUE; 1297 } 1298 else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE ) 1299 { 1300 const SfxItemSet& rSet = GetItemSet(); 1301 1302 if( rSet.GetItemState( XATTR_FILLBMP_STRETCH, false ) == SFX_ITEM_SET || 1303 rSet.GetItemState( XATTR_FILLBMP_TILE, false ) == SFX_ITEM_SET ) 1304 { 1305 return PropertyState_DIRECT_VALUE; 1306 } 1307 else 1308 { 1309 return PropertyState_AMBIGUOUS_VALUE; 1310 } 1311 } 1312 else 1313 { 1314 SfxItemSet &rStyleSet = GetItemSet(); 1315 1316 PropertyState eState; 1317 1318 switch( rStyleSet.GetItemState( pEntry->nWID, sal_False ) ) 1319 { 1320 case SFX_ITEM_READONLY: 1321 case SFX_ITEM_SET: 1322 eState = PropertyState_DIRECT_VALUE; 1323 break; 1324 case SFX_ITEM_DEFAULT: 1325 eState = PropertyState_DEFAULT_VALUE; 1326 break; 1327 // case SFX_ITEM_DONTCARE: 1328 // case SFX_ITEM_DISABLED: 1329 default: 1330 eState = PropertyState_AMBIGUOUS_VALUE; 1331 break; 1332 } 1333 1334 // if a item is set, this doesn't mean we want it :) 1335 if( ( PropertyState_DIRECT_VALUE == eState ) ) 1336 { 1337 switch( pEntry->nWID ) 1338 { 1339 case XATTR_FILLBITMAP: 1340 case XATTR_FILLGRADIENT: 1341 case XATTR_FILLHATCH: 1342 case XATTR_FILLFLOATTRANSPARENCE: 1343 case XATTR_LINEEND: 1344 case XATTR_LINESTART: 1345 case XATTR_LINEDASH: 1346 { 1347 NameOrIndex* pItem = (NameOrIndex*)rStyleSet.GetItem((sal_uInt16)pEntry->nWID); 1348 if( ( pItem == NULL ) || ( pItem->GetName().Len() == 0) ) 1349 eState = PropertyState_DEFAULT_VALUE; 1350 } 1351 } 1352 } 1353 1354 return eState; 1355 } 1356 } 1357 1358 // -------------------------------------------------------------------- 1359 1360 Sequence< PropertyState > SAL_CALL SdStyleSheet::getPropertyStates( const Sequence< OUString >& aPropertyName ) throw(UnknownPropertyException, RuntimeException) 1361 { 1362 OGuard aGuard( Application::GetSolarMutex() ); 1363 1364 throwIfDisposed(); 1365 1366 sal_Int32 nCount = aPropertyName.getLength(); 1367 const OUString* pNames = aPropertyName.getConstArray(); 1368 1369 Sequence< PropertyState > aPropertyStateSequence( nCount ); 1370 PropertyState* pState = aPropertyStateSequence.getArray(); 1371 1372 while( nCount-- ) 1373 *pState++ = getPropertyState( *pNames++ ); 1374 1375 return aPropertyStateSequence; 1376 } 1377 1378 // -------------------------------------------------------------------- 1379 1380 void SAL_CALL SdStyleSheet::setPropertyToDefault( const OUString& PropertyName ) throw(UnknownPropertyException, RuntimeException) 1381 { 1382 OGuard aGuard( Application::GetSolarMutex() ); 1383 1384 throwIfDisposed(); 1385 1386 const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( PropertyName ); 1387 if( pEntry == NULL ) 1388 throw UnknownPropertyException(); 1389 1390 SfxItemSet &rStyleSet = GetItemSet(); 1391 1392 if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE ) 1393 { 1394 rStyleSet.ClearItem( XATTR_FILLBMP_STRETCH ); 1395 rStyleSet.ClearItem( XATTR_FILLBMP_TILE ); 1396 } 1397 else 1398 { 1399 rStyleSet.ClearItem( pEntry->nWID ); 1400 } 1401 Broadcast(SfxSimpleHint(SFX_HINT_DATACHANGED)); 1402 } 1403 1404 // -------------------------------------------------------------------- 1405 1406 Any SAL_CALL SdStyleSheet::getPropertyDefault( const OUString& aPropertyName ) throw(UnknownPropertyException, WrappedTargetException, RuntimeException) 1407 { 1408 OGuard aGuard( Application::GetSolarMutex() ); 1409 1410 throwIfDisposed(); 1411 1412 const SfxItemPropertySimpleEntry* pEntry = getPropertyMapEntry( aPropertyName ); 1413 if( pEntry == NULL ) 1414 throw UnknownPropertyException(); 1415 Any aRet; 1416 if( pEntry->nWID == WID_STYLE_FAMILY ) 1417 { 1418 aRet <<= GetFamilyString(nFamily); 1419 } 1420 else if( pEntry->nWID == SDRATTR_TEXTDIRECTION ) 1421 { 1422 aRet <<= sal_False; 1423 } 1424 else if( pEntry->nWID == OWN_ATTR_FILLBMP_MODE ) 1425 { 1426 aRet <<= BitmapMode_REPEAT; 1427 } 1428 else 1429 { 1430 SfxItemPool& rMyPool = GetPool().GetPool(); 1431 SfxItemSet aSet( rMyPool, pEntry->nWID, pEntry->nWID); 1432 aSet.Put( rMyPool.GetDefaultItem( pEntry->nWID ) ); 1433 aRet = SvxItemPropertySet_getPropertyValue( GetStylePropertySet(), pEntry, aSet ); 1434 } 1435 return aRet; 1436 } 1437 1438 // -------------------------------------------------------------------- 1439 1440 /** this is used because our property map is not sorted yet */ 1441 const SfxItemPropertySimpleEntry* SdStyleSheet::getPropertyMapEntry( const OUString& rPropertyName ) const throw() 1442 { 1443 return GetStylePropertySet().getPropertyMapEntry(rPropertyName); 1444 } 1445 1446