1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_sw.hxx" 26 27 #include <sfx2/docfile.hxx> 28 #include <sfx2/frame.hxx> 29 #include <sfx2/linkmgr.hxx> 30 #include <svx/svxids.hrc> 31 #include <editeng/memberids.hrc> 32 #include <swtypes.hxx> 33 #include <cmdid.h> 34 #include <hintids.hxx> 35 #include "poolfmt.hrc" 36 #include "poolfmt.hxx" 37 #include <fmtcol.hxx> 38 #include <unomap.hxx> 39 #include <unostyle.hxx> 40 #include <unosett.hxx> 41 #include <unoprnms.hxx> 42 #include <ftninfo.hxx> 43 #include <doc.hxx> 44 #include <pagedesc.hxx> 45 #include <charfmt.hxx> 46 #include <lineinfo.hxx> 47 #include <docsh.hxx> 48 #include <docary.hxx> 49 #include <docstyle.hxx> 50 #include <fmtclds.hxx> 51 #include <editeng/brshitem.hxx> 52 #include <com/sun/star/text/XFootnotesSettingsSupplier.hpp> 53 #include <com/sun/star/text/XFootnote.hpp> 54 #include <com/sun/star/text/XFootnotesSupplier.hpp> 55 #include <com/sun/star/text/XEndnotesSupplier.hpp> 56 #include <com/sun/star/text/XEndnotesSettingsSupplier.hpp> 57 #include <com/sun/star/text/FootnoteNumbering.hpp> 58 #include <com/sun/star/text/HoriOrientation.hpp> 59 #include <com/sun/star/style/LineNumberPosition.hpp> 60 #include <com/sun/star/awt/XBitmap.hpp> 61 #include <com/sun/star/beans/PropertyAttribute.hpp> 62 #include <com/sun/star/style/VerticalAlignment.hpp> 63 #include <vcl/font.hxx> 64 #include <editeng/flstitem.hxx> 65 #include <vcl/metric.hxx> 66 #include <svtools/ctrltool.hxx> 67 #include <vos/mutex.hxx> 68 #include <vcl/svapp.hxx> 69 #include <toolkit/helper/vclunohelper.hxx> 70 #include <editeng/unofdesc.hxx> 71 #include <fmtornt.hxx> 72 #include <SwStyleNameMapper.hxx> 73 // --> OD 2008-01-15 #newlistlevelattrs# 74 #include <com/sun/star/text/PositionAndSpaceMode.hpp> 75 #include <com/sun/star/text/LabelFollow.hpp> 76 // <-- 77 #include <numrule.hxx> 78 79 using ::rtl::OUString; 80 using namespace ::com::sun::star; 81 using namespace ::com::sun::star::uno; 82 using namespace ::com::sun::star::lang; 83 using namespace ::com::sun::star::beans; 84 using namespace ::com::sun::star::text; 85 using namespace ::com::sun::star::style; 86 87 struct PropValData 88 { 89 uno::Any aVal; 90 OUString sPropName; 91 PropValData(void* pVal, const char* cPropName, uno::Type aType ) : 92 aVal(pVal, aType), 93 sPropName(OUString::createFromAscii(cPropName)) 94 {} 95 PropValData(const uno::Any& rVal, const OUString& rPropName) : 96 aVal(rVal), 97 sPropName(rPropName) 98 {} 99 }; 100 101 typedef PropValData* PropValDataPtr; 102 SV_DECL_PTRARR(PropValDataArr, PropValDataPtr, 5, 5 ) 103 SV_IMPL_PTRARR(PropValDataArr, PropValDataPtr) 104 105 106 #define WID_PREFIX 0 107 #define WID_SUFFIX 1 108 #define WID_NUMBERING_TYPE 2 109 #define WID_START_AT 3 110 #define WID_FOOTNOTE_COUNTING 4 111 #define WID_PARAGRAPH_STYLE 5 112 #define WID_PAGE_STYLE 6 113 #define WID_CHARACTER_STYLE 7 114 #define WID_POSITION_END_OF_DOC 8 115 #define WID_END_NOTICE 9 116 #define WID_BEGIN_NOTICE 10 117 #define WID_ANCHOR_CHARACTER_STYLE 11 118 119 const SfxItemPropertySet* GetFootnoteSet() 120 { 121 static SfxItemPropertyMapEntry aFootnoteMap_Impl[] = 122 { 123 { SW_PROP_NAME(UNO_NAME_ANCHOR_CHAR_STYLE_NAME),WID_ANCHOR_CHARACTER_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 124 { SW_PROP_NAME(UNO_NAME_BEGIN_NOTICE), WID_BEGIN_NOTICE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 125 { SW_PROP_NAME(UNO_NAME_CHAR_STYLE_NAME), WID_CHARACTER_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 126 { SW_PROP_NAME(UNO_NAME_END_NOTICE), WID_END_NOTICE , &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 127 { SW_PROP_NAME(UNO_NAME_FOOTNOTE_COUNTING), WID_FOOTNOTE_COUNTING, &::getCppuType((const sal_Int16*)0), PROPERTY_NONE, 0}, 128 { SW_PROP_NAME(UNO_NAME_NUMBERING_TYPE), WID_NUMBERING_TYPE, &::getCppuType((const sal_Int16*)0), PROPERTY_NONE, 0}, 129 { SW_PROP_NAME(UNO_NAME_PAGE_STYLE_NAME), WID_PAGE_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 130 { SW_PROP_NAME(UNO_NAME_PARA_STYLE_NAME), WID_PARAGRAPH_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 131 { SW_PROP_NAME(UNO_NAME_POSITION_END_OF_DOC), WID_POSITION_END_OF_DOC,&::getBooleanCppuType(), PROPERTY_NONE, 0}, 132 { SW_PROP_NAME(UNO_NAME_PREFIX), WID_PREFIX, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 133 { SW_PROP_NAME(UNO_NAME_START_AT), WID_START_AT , &::getCppuType((const sal_Int16*)0), PROPERTY_NONE, 0}, 134 { SW_PROP_NAME(UNO_NAME_SUFFIX), WID_SUFFIX, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 135 {0,0,0,0,0,0} 136 }; 137 static SfxItemPropertySet aFootnoteSet_Impl(aFootnoteMap_Impl); 138 return &aFootnoteSet_Impl; 139 } 140 const SfxItemPropertySet* GetEndnoteSet() 141 { 142 static SfxItemPropertyMapEntry aEndnoteMap_Impl[] = 143 { 144 { SW_PROP_NAME(UNO_NAME_ANCHOR_CHAR_STYLE_NAME),WID_ANCHOR_CHARACTER_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 145 { SW_PROP_NAME(UNO_NAME_CHAR_STYLE_NAME), WID_CHARACTER_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 146 { SW_PROP_NAME(UNO_NAME_NUMBERING_TYPE), WID_NUMBERING_TYPE, &::getCppuType((const sal_Int16*)0), PROPERTY_NONE, 0}, 147 { SW_PROP_NAME(UNO_NAME_PAGE_STYLE_NAME), WID_PAGE_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 148 { SW_PROP_NAME(UNO_NAME_PARA_STYLE_NAME), WID_PARAGRAPH_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 149 { SW_PROP_NAME(UNO_NAME_PREFIX), WID_PREFIX, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 150 { SW_PROP_NAME(UNO_NAME_START_AT), WID_START_AT , &::getCppuType((const sal_Int16*)0), PROPERTY_NONE, 0}, 151 { SW_PROP_NAME(UNO_NAME_SUFFIX), WID_SUFFIX, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 152 {0,0,0,0,0,0} 153 }; 154 static SfxItemPropertySet aEndnoteSet_Impl(aEndnoteMap_Impl); 155 return &aEndnoteSet_Impl; 156 } 157 const SfxItemPropertySet* GetNumberingRulesSet() 158 { 159 static SfxItemPropertyMapEntry aNumberingRulesMap_Impl[] = 160 { 161 { SW_PROP_NAME(UNO_NAME_IS_ABSOLUTE_MARGINS), WID_IS_ABS_MARGINS, &::getBooleanCppuType(), PROPERTY_NONE, 0}, 162 { SW_PROP_NAME(UNO_NAME_IS_AUTOMATIC), WID_IS_AUTOMATIC, &::getBooleanCppuType(), PROPERTY_NONE, 0}, 163 { SW_PROP_NAME(UNO_NAME_IS_CONTINUOUS_NUMBERING), WID_CONTINUOUS, &::getBooleanCppuType(), PROPERTY_NONE, 0}, 164 { SW_PROP_NAME(UNO_NAME_NAME), WID_RULE_NAME , &::getCppuType((const OUString*)0), PropertyAttribute::READONLY, 0}, 165 { SW_PROP_NAME(UNO_NAME_NUMBERING_IS_OUTLINE), WID_IS_OUTLINE, &::getBooleanCppuType(), PROPERTY_NONE, 0}, 166 { SW_PROP_NAME(UNO_NAME_DEFAULT_LIST_ID), WID_DEFAULT_LIST_ID, &::getCppuType((const OUString*)0), PropertyAttribute::READONLY, 0}, 167 {0,0,0,0,0,0} 168 }; 169 static SfxItemPropertySet aNumberingRulesSet_Impl( aNumberingRulesMap_Impl ); 170 return &aNumberingRulesSet_Impl; 171 } 172 #define WID_NUM_ON 0 173 #define WID_SEPARATOR_INTERVAL 1 174 #define WID_NUMBERING_TYPE 2 175 #define WID_NUMBER_POSITION 3 176 #define WID_DISTANCE 4 177 #define WID_INTERVAL 5 178 #define WID_SEPARATOR_TEXT 6 179 //#define WID_CHARACTER_STYLE 7 180 #define WID_COUNT_EMPTY_LINES 8 181 #define WID_COUNT_LINES_IN_FRAMES 9 182 #define WID_RESTART_AT_EACH_PAGE 10 183 184 const SfxItemPropertySet* GetLineNumberingSet() 185 { 186 static SfxItemPropertyMapEntry aLineNumberingMap_Impl[] = 187 { 188 { SW_PROP_NAME(UNO_NAME_CHAR_STYLE_NAME), WID_CHARACTER_STYLE, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 189 { SW_PROP_NAME(UNO_NAME_COUNT_EMPTY_LINES), WID_COUNT_EMPTY_LINES , &::getBooleanCppuType(),PROPERTY_NONE, 0}, 190 { SW_PROP_NAME(UNO_NAME_COUNT_LINES_IN_FRAMES), WID_COUNT_LINES_IN_FRAMES, &::getBooleanCppuType(),PROPERTY_NONE, 0}, 191 { SW_PROP_NAME(UNO_NAME_DISTANCE ), WID_DISTANCE , &::getCppuType((const sal_Int32*)0),PROPERTY_NONE, 0}, 192 { SW_PROP_NAME(UNO_NAME_IS_ON), WID_NUM_ON, &::getBooleanCppuType() , PROPERTY_NONE, 0}, 193 { SW_PROP_NAME(UNO_NAME_INTERVAL ), WID_INTERVAL , &::getCppuType((const sal_Int16*)0),PROPERTY_NONE, 0}, 194 { SW_PROP_NAME(UNO_NAME_SEPARATOR_TEXT ), WID_SEPARATOR_TEXT, &::getCppuType((const OUString*)0), PROPERTY_NONE, 0}, 195 { SW_PROP_NAME(UNO_NAME_NUMBER_POSITION), WID_NUMBER_POSITION, &::getCppuType((const sal_Int16*)0),PROPERTY_NONE, 0}, 196 { SW_PROP_NAME(UNO_NAME_NUMBERING_TYPE), WID_NUMBERING_TYPE , &::getCppuType((const sal_Int16*)0),PROPERTY_NONE, 0}, 197 { SW_PROP_NAME(UNO_NAME_RESTART_AT_EACH_PAGE), WID_RESTART_AT_EACH_PAGE, &::getBooleanCppuType() , PROPERTY_NONE, 0}, 198 { SW_PROP_NAME(UNO_NAME_SEPARATOR_INTERVAL), WID_SEPARATOR_INTERVAL, &::getCppuType((const sal_Int16*)0),PROPERTY_NONE, 0}, 199 {0,0,0,0,0,0} 200 }; 201 static SfxItemPropertySet aLineNumberingSet_Impl(aLineNumberingMap_Impl); 202 return &aLineNumberingSet_Impl; 203 } 204 205 /* -----------------05.05.98 08:30------------------- 206 * 207 * --------------------------------------------------*/ 208 SwCharFmt* lcl_getCharFmt(SwDoc* pDoc, const uno::Any& aValue) 209 { 210 SwCharFmt* pRet = 0; 211 String sStandard(SW_RES(STR_POOLCOLL_STANDARD)); 212 OUString uTmp; 213 aValue >>= uTmp; 214 String sCharFmt; 215 SwStyleNameMapper::FillUIName(uTmp, sCharFmt, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True); 216 if(sStandard != sCharFmt) 217 { 218 pRet = pDoc->FindCharFmtByName( sCharFmt ); 219 } 220 if(!pRet) 221 { 222 sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(sCharFmt, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT); 223 if(USHRT_MAX != nId) 224 pRet = pDoc->GetCharFmtFromPool( nId ); 225 } 226 return pRet; 227 } 228 /* -----------------05.05.98 08:30------------------- 229 * 230 * --------------------------------------------------*/ 231 SwTxtFmtColl* lcl_GetParaStyle(SwDoc* pDoc, const uno::Any& aValue) 232 { 233 OUString uTmp; 234 aValue >>= uTmp; 235 String sParaStyle; 236 SwStyleNameMapper::FillUIName(uTmp, sParaStyle, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True ); 237 SwTxtFmtColl* pRet = pDoc->FindTxtFmtCollByName( sParaStyle ); 238 if( !pRet ) 239 { 240 sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( sParaStyle, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL ); 241 if( USHRT_MAX != nId ) 242 pRet = pDoc->GetTxtCollFromPool( nId ); 243 } 244 return pRet; 245 } 246 /* -----------------05.05.98 08:30------------------- 247 * 248 * --------------------------------------------------*/ 249 SwPageDesc* lcl_GetPageDesc(SwDoc* pDoc, const uno::Any& aValue) 250 { 251 SwPageDesc* pRet = 0; 252 sal_uInt16 nCount = pDoc->GetPageDescCnt(); 253 OUString uTmp; 254 aValue >>= uTmp; 255 String sPageDesc; 256 SwStyleNameMapper::FillUIName(uTmp, sPageDesc, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True ); 257 for( sal_uInt16 i = 0; i < nCount; i++) 258 { 259 const SwPageDesc& rDesc = const_cast<const SwDoc *>(pDoc) 260 ->GetPageDesc( i ); 261 if(rDesc.GetName() == sPageDesc) 262 { 263 pRet = (SwPageDesc*)&rDesc; 264 break; 265 } 266 } 267 if(!pRet) 268 { 269 sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName(sPageDesc, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC); 270 if(USHRT_MAX != nId) 271 pRet = pDoc->GetPageDescFromPool( nId ); 272 } 273 return pRet; 274 } 275 /****************************************************************************** 276 * 277 ******************************************************************************/ 278 // Numerierung 279 const unsigned short aSvxToUnoAdjust[] = 280 { 281 text::HoriOrientation::LEFT, //3 282 text::HoriOrientation::RIGHT, //1 283 USHRT_MAX, 284 text::HoriOrientation::CENTER, //2 285 USHRT_MAX, 286 USHRT_MAX 287 }; 288 289 const unsigned short aUnoToSvxAdjust[] = 290 { 291 USHRT_MAX, 292 SVX_ADJUST_RIGHT, // 1 293 SVX_ADJUST_CENTER, // 3 294 SVX_ADJUST_LEFT, // 0 295 USHRT_MAX, 296 USHRT_MAX 297 }; 298 299 /****************************************************************** 300 * SwXFootnoteProperties 301 ******************************************************************/ 302 /* -----------------------------06.04.00 11:43-------------------------------- 303 304 ---------------------------------------------------------------------------*/ 305 OUString SwXFootnoteProperties::getImplementationName(void) 306 { 307 return C2U("SwXFootnoteProperties"); 308 } 309 /* -----------------------------06.04.00 11:43-------------------------------- 310 311 ---------------------------------------------------------------------------*/ 312 sal_Bool SwXFootnoteProperties::supportsService(const OUString& rServiceName) 313 { 314 return C2U("com.sun.star.text.FootnoteSettings") == rServiceName; 315 } 316 /* -----------------------------06.04.00 11:43-------------------------------- 317 318 ---------------------------------------------------------------------------*/ 319 Sequence< OUString > SwXFootnoteProperties::getSupportedServiceNames(void) 320 { 321 Sequence< OUString > aRet(1); 322 OUString* pArray = aRet.getArray(); 323 pArray[0] = C2U("com.sun.star.text.FootnoteSettings"); 324 return aRet; 325 } 326 /*-- 14.12.98 14:03:20--------------------------------------------------- 327 328 -----------------------------------------------------------------------*/ 329 SwXFootnoteProperties::SwXFootnoteProperties(SwDoc* pDc) : 330 pDoc(pDc), 331 m_pPropertySet(GetFootnoteSet()) 332 { 333 } 334 /*-- 14.12.98 14:03:20--------------------------------------------------- 335 336 -----------------------------------------------------------------------*/ 337 SwXFootnoteProperties::~SwXFootnoteProperties() 338 { 339 340 } 341 /*-- 14.12.98 14:03:20--------------------------------------------------- 342 343 -----------------------------------------------------------------------*/ 344 uno::Reference< beans::XPropertySetInfo > SwXFootnoteProperties::getPropertySetInfo(void) 345 { 346 static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); 347 return aRef; 348 } 349 /*-- 14.12.98 14:03:20--------------------------------------------------- 350 351 -----------------------------------------------------------------------*/ 352 void SwXFootnoteProperties::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue) 353 { 354 vos::OGuard aGuard(Application::GetSolarMutex()); 355 if(pDoc) 356 { 357 const SfxItemPropertySimpleEntry* pEntry = m_pPropertySet->getPropertyMap()->getByName( rPropertyName ); 358 if(pEntry) 359 { 360 if ( pEntry->nFlags & PropertyAttribute::READONLY) 361 throw PropertyVetoException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 362 SwFtnInfo aFtnInfo(pDoc->GetFtnInfo()); 363 switch(pEntry->nWID) 364 { 365 case WID_PREFIX: 366 { 367 OUString uTmp; 368 aValue >>= uTmp; 369 aFtnInfo.SetPrefix(uTmp); 370 } 371 break; 372 case WID_SUFFIX: 373 { 374 OUString uTmp; 375 aValue >>= uTmp; 376 aFtnInfo.SetSuffix(uTmp); 377 } 378 break; 379 case WID_NUMBERING_TYPE : 380 { 381 sal_Int16 nTmp = 0; 382 aValue >>= nTmp; 383 if(nTmp >= 0 && 384 (nTmp <= SVX_NUM_ARABIC || 385 nTmp > SVX_NUM_BITMAP)) 386 aFtnInfo.aFmt.SetNumberingType(nTmp); 387 else 388 throw lang::IllegalArgumentException(); 389 } 390 break; 391 case WID_START_AT: 392 { 393 sal_Int16 nTmp = 0; 394 aValue >>= nTmp; 395 aFtnInfo.nFtnOffset = nTmp; 396 } 397 break; 398 case WID_FOOTNOTE_COUNTING : 399 { 400 sal_Int16 nTmp = 0; 401 aValue >>= nTmp; 402 switch(nTmp) 403 { 404 case FootnoteNumbering::PER_PAGE: 405 aFtnInfo.eNum = FTNNUM_PAGE; 406 break; 407 case FootnoteNumbering::PER_CHAPTER: 408 aFtnInfo.eNum = FTNNUM_CHAPTER; 409 break; 410 case FootnoteNumbering::PER_DOCUMENT: 411 aFtnInfo.eNum = FTNNUM_DOC; 412 break; 413 } 414 } 415 break; 416 case WID_PARAGRAPH_STYLE : 417 { 418 SwTxtFmtColl* pColl = lcl_GetParaStyle(pDoc, aValue); 419 if(pColl) 420 aFtnInfo.SetFtnTxtColl(*pColl); 421 } 422 break; 423 case WID_PAGE_STYLE : 424 { 425 SwPageDesc* pDesc = lcl_GetPageDesc(pDoc, aValue); 426 if(pDesc) 427 aFtnInfo.ChgPageDesc( pDesc ); 428 } 429 break; 430 case WID_ANCHOR_CHARACTER_STYLE: 431 case WID_CHARACTER_STYLE : 432 { 433 SwCharFmt* pFmt = lcl_getCharFmt(pDoc, aValue); 434 if(pFmt) 435 { 436 if(pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE) 437 aFtnInfo.SetAnchorCharFmt(pFmt); 438 else 439 aFtnInfo.SetCharFmt(pFmt); 440 } 441 } 442 break; 443 case WID_POSITION_END_OF_DOC: 444 { 445 sal_Bool bVal = *(sal_Bool*)aValue.getValue(); 446 aFtnInfo.ePos = bVal ? FTNPOS_CHAPTER : FTNPOS_PAGE; 447 } 448 break; 449 case WID_END_NOTICE : 450 { 451 OUString uTmp; 452 aValue >>= uTmp; 453 aFtnInfo.aQuoVadis = String(uTmp); 454 } 455 break; 456 case WID_BEGIN_NOTICE : 457 { 458 OUString uTmp; 459 aValue >>= uTmp; 460 aFtnInfo.aErgoSum = String(uTmp); 461 } 462 break; 463 } 464 pDoc->SetFtnInfo(aFtnInfo); 465 } 466 else 467 throw beans::UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 468 } 469 else 470 throw uno::RuntimeException(); 471 } 472 /*-- 14.12.98 14:03:21--------------------------------------------------- 473 474 -----------------------------------------------------------------------*/ 475 uno::Any SwXFootnoteProperties::getPropertyValue(const OUString& rPropertyName) 476 { 477 vos::OGuard aGuard(Application::GetSolarMutex()); 478 uno::Any aRet; 479 if(pDoc) 480 { 481 const SfxItemPropertySimpleEntry* pEntry = m_pPropertySet->getPropertyMap()->getByName( rPropertyName ); 482 if(pEntry) 483 { 484 const SwFtnInfo& rFtnInfo = pDoc->GetFtnInfo(); 485 switch(pEntry->nWID) 486 { 487 case WID_PREFIX: 488 { 489 aRet <<= OUString(rFtnInfo.GetPrefix()); 490 } 491 break; 492 case WID_SUFFIX: 493 { 494 aRet <<= OUString(rFtnInfo.GetSuffix()); 495 } 496 break; 497 case WID_NUMBERING_TYPE : 498 { 499 aRet <<= rFtnInfo.aFmt.GetNumberingType(); 500 } 501 break; 502 case WID_START_AT: 503 aRet <<= (sal_Int16)rFtnInfo.nFtnOffset; 504 break; 505 case WID_FOOTNOTE_COUNTING : 506 { 507 sal_Int16 nRet = 0; 508 switch(rFtnInfo.eNum) 509 { 510 case FTNNUM_PAGE: 511 nRet = FootnoteNumbering::PER_PAGE; 512 break; 513 case FTNNUM_CHAPTER: 514 nRet = FootnoteNumbering::PER_CHAPTER; 515 break; 516 case FTNNUM_DOC: 517 nRet = FootnoteNumbering::PER_DOCUMENT; 518 break; 519 } 520 aRet <<= nRet; 521 } 522 break; 523 case WID_PARAGRAPH_STYLE : 524 { 525 SwTxtFmtColl* pColl = rFtnInfo.GetFtnTxtColl(); 526 String aString; 527 if(pColl) 528 aString = String ( pColl->GetName() ); 529 SwStyleNameMapper::FillProgName(aString, aString, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True); 530 aRet <<= OUString ( aString ); 531 } 532 break; 533 case WID_PAGE_STYLE : 534 { 535 String aString; 536 if( rFtnInfo.KnowsPageDesc() ) 537 { 538 SwStyleNameMapper::FillProgName( 539 rFtnInfo.GetPageDesc( *pDoc )->GetName(), 540 aString, 541 nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, 542 sal_True); 543 } 544 aRet <<= OUString ( aString ); 545 } 546 break; 547 case WID_ANCHOR_CHARACTER_STYLE: 548 case WID_CHARACTER_STYLE: 549 { 550 String aString; 551 const SwCharFmt* pCharFmt = 0; 552 if( pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE ) 553 { 554 if( rFtnInfo.GetAnchorCharFmtDep()->GetRegisteredIn() ) 555 pCharFmt = rFtnInfo.GetAnchorCharFmt(*pDoc); 556 } 557 else 558 { 559 if( rFtnInfo.GetCharFmtDep()->GetRegisteredIn() ) 560 pCharFmt = rFtnInfo.GetCharFmt(*pDoc); 561 } 562 if( pCharFmt ) 563 { 564 SwStyleNameMapper::FillProgName( 565 pCharFmt->GetName(), 566 aString, 567 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, 568 sal_True); 569 } 570 aRet <<= OUString ( aString ); 571 } 572 break; 573 case WID_POSITION_END_OF_DOC: 574 { 575 sal_Bool bTemp = FTNPOS_CHAPTER == rFtnInfo.ePos; 576 aRet.setValue(&bTemp, ::getCppuBooleanType()); 577 } 578 break; 579 case WID_END_NOTICE : 580 aRet <<= OUString(rFtnInfo.aQuoVadis); 581 break; 582 case WID_BEGIN_NOTICE : 583 aRet <<= OUString(rFtnInfo.aErgoSum); 584 break; 585 } 586 } 587 else 588 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 589 } 590 else 591 throw uno::RuntimeException(); 592 return aRet; 593 } 594 /*-- 14.12.98 14:03:21--------------------------------------------------- 595 596 -----------------------------------------------------------------------*/ 597 void SwXFootnoteProperties::addPropertyChangeListener( 598 const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) 599 { 600 DBG_WARNING("not implemented"); 601 } 602 /*-- 14.12.98 14:03:21--------------------------------------------------- 603 604 -----------------------------------------------------------------------*/ 605 void SwXFootnoteProperties::removePropertyChangeListener( 606 const OUString& /*rPropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) 607 { 608 DBG_WARNING("not implemented"); 609 } 610 /*-- 14.12.98 14:03:21--------------------------------------------------- 611 612 -----------------------------------------------------------------------*/ 613 void SwXFootnoteProperties::addVetoableChangeListener( 614 const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) 615 { 616 DBG_WARNING("not implemented"); 617 } 618 /*-- 14.12.98 14:03:22--------------------------------------------------- 619 620 -----------------------------------------------------------------------*/ 621 void SwXFootnoteProperties::removeVetoableChangeListener( 622 const OUString& /*rPropertyName*/, const uno::Reference< beans::XVetoableChangeListener > & /*xListener*/) 623 { 624 DBG_WARNING("not implemented"); 625 } 626 627 /****************************************************************** 628 * SwXEndnoteProperties 629 ******************************************************************/ 630 /* -----------------------------06.04.00 11:45-------------------------------- 631 632 ---------------------------------------------------------------------------*/ 633 OUString SwXEndnoteProperties::getImplementationName(void) 634 { 635 return C2U("SwXEndnoteProperties"); 636 } 637 /* -----------------------------06.04.00 11:45-------------------------------- 638 639 ---------------------------------------------------------------------------*/ 640 sal_Bool SwXEndnoteProperties::supportsService(const OUString& rServiceName) 641 { 642 return C2U("com.sun.star.text.FootnoteSettings") == rServiceName; 643 } 644 /* -----------------------------06.04.00 11:45-------------------------------- 645 646 ---------------------------------------------------------------------------*/ 647 Sequence< OUString > SwXEndnoteProperties::getSupportedServiceNames(void) 648 { 649 Sequence< OUString > aRet(1); 650 OUString* pArray = aRet.getArray(); 651 pArray[0] = C2U("com.sun.star.text.FootnoteSettings"); 652 return aRet; 653 } 654 /*-- 14.12.98 14:27:39--------------------------------------------------- 655 656 -----------------------------------------------------------------------*/ 657 SwXEndnoteProperties::SwXEndnoteProperties(SwDoc* pDc) : 658 pDoc(pDc), 659 m_pPropertySet(GetEndnoteSet()) 660 { 661 662 } 663 /*-- 14.12.98 14:27:39--------------------------------------------------- 664 665 -----------------------------------------------------------------------*/ 666 SwXEndnoteProperties::~SwXEndnoteProperties() 667 { 668 669 } 670 /*-- 14.12.98 14:27:40--------------------------------------------------- 671 672 -----------------------------------------------------------------------*/ 673 uno::Reference< beans::XPropertySetInfo > SwXEndnoteProperties::getPropertySetInfo(void) 674 { 675 static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); 676 return aRef; 677 } 678 /*-- 14.12.98 14:27:40--------------------------------------------------- 679 680 -----------------------------------------------------------------------*/ 681 void SwXEndnoteProperties::setPropertyValue(const OUString& rPropertyName, const uno::Any& aValue) 682 { 683 vos::OGuard aGuard(Application::GetSolarMutex()); 684 if(pDoc) 685 { 686 const SfxItemPropertySimpleEntry* pEntry = m_pPropertySet->getPropertyMap()->getByName( rPropertyName ); 687 if(pEntry) 688 { 689 if ( pEntry->nFlags & PropertyAttribute::READONLY) 690 throw PropertyVetoException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 691 SwEndNoteInfo aEndInfo(pDoc->GetEndNoteInfo()); 692 switch(pEntry->nWID) 693 { 694 case WID_PREFIX: 695 { 696 OUString uTmp; 697 aValue >>= uTmp; 698 aEndInfo.SetPrefix(uTmp); 699 } 700 break; 701 case WID_SUFFIX: 702 { 703 OUString uTmp; 704 aValue >>= uTmp; 705 aEndInfo.SetSuffix(uTmp); 706 } 707 break; 708 case WID_NUMBERING_TYPE : 709 { 710 sal_Int16 nTmp = 0; 711 aValue >>= nTmp; 712 aEndInfo.aFmt.SetNumberingType(nTmp); 713 } 714 break; 715 case WID_START_AT: 716 { 717 sal_Int16 nTmp = 0; 718 aValue >>= nTmp; 719 aEndInfo.nFtnOffset = nTmp; 720 } 721 break; 722 case WID_PARAGRAPH_STYLE : 723 { 724 SwTxtFmtColl* pColl = lcl_GetParaStyle(pDoc, aValue); 725 if(pColl) 726 aEndInfo.SetFtnTxtColl(*pColl); 727 } 728 break; 729 case WID_PAGE_STYLE : 730 { 731 SwPageDesc* pDesc = lcl_GetPageDesc(pDoc, aValue); 732 if(pDesc) 733 aEndInfo.ChgPageDesc( pDesc ); 734 } 735 break; 736 case WID_ANCHOR_CHARACTER_STYLE: 737 case WID_CHARACTER_STYLE : 738 { 739 SwCharFmt* pFmt = lcl_getCharFmt(pDoc, aValue); 740 if(pFmt) 741 { 742 if(pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE) 743 aEndInfo.SetAnchorCharFmt(pFmt); 744 else 745 aEndInfo.SetCharFmt(pFmt); 746 } 747 } 748 break; 749 } 750 pDoc->SetEndNoteInfo(aEndInfo); 751 } 752 else 753 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 754 } 755 } 756 /*-- 14.12.98 14:27:41--------------------------------------------------- 757 758 -----------------------------------------------------------------------*/ 759 uno::Any SwXEndnoteProperties::getPropertyValue(const OUString& rPropertyName) 760 { 761 vos::OGuard aGuard(Application::GetSolarMutex()); 762 uno::Any aRet; 763 if(pDoc) 764 { 765 const SfxItemPropertySimpleEntry* pEntry = m_pPropertySet->getPropertyMap()->getByName( rPropertyName ); 766 if(pEntry) 767 { 768 const SwEndNoteInfo& rEndInfo = pDoc->GetEndNoteInfo(); 769 switch(pEntry->nWID) 770 { 771 case WID_PREFIX: 772 aRet <<= OUString(rEndInfo.GetPrefix()); 773 break; 774 case WID_SUFFIX: 775 aRet <<= OUString(rEndInfo.GetSuffix()); 776 break; 777 case WID_NUMBERING_TYPE : 778 aRet <<= rEndInfo.aFmt.GetNumberingType(); 779 break; 780 case WID_START_AT: 781 aRet <<= (sal_Int16)rEndInfo.nFtnOffset; 782 break; 783 case WID_PARAGRAPH_STYLE : 784 { 785 SwTxtFmtColl* pColl = rEndInfo.GetFtnTxtColl(); 786 String aString; 787 if(pColl) 788 aString = pColl->GetName(); 789 SwStyleNameMapper::FillProgName( 790 aString, 791 aString, 792 nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, 793 sal_True); 794 aRet <<= OUString ( aString ); 795 796 } 797 break; 798 case WID_PAGE_STYLE : 799 { 800 String aString; 801 if( rEndInfo.KnowsPageDesc() ) 802 { 803 SwStyleNameMapper::FillProgName( 804 rEndInfo.GetPageDesc( *pDoc )->GetName(), 805 aString, 806 nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, 807 sal_True ); 808 } 809 aRet <<= OUString ( aString ); 810 } 811 break; 812 case WID_ANCHOR_CHARACTER_STYLE: 813 case WID_CHARACTER_STYLE: 814 { 815 String aString; 816 const SwCharFmt* pCharFmt = 0; 817 if( pEntry->nWID == WID_ANCHOR_CHARACTER_STYLE ) 818 { 819 if( rEndInfo.GetAnchorCharFmtDep()->GetRegisteredIn() ) 820 pCharFmt = rEndInfo.GetAnchorCharFmt(*pDoc); 821 } 822 else 823 { 824 if( rEndInfo.GetCharFmtDep()->GetRegisteredIn() ) 825 pCharFmt = rEndInfo.GetCharFmt(*pDoc); 826 } 827 if( pCharFmt ) 828 { 829 SwStyleNameMapper::FillProgName( 830 pCharFmt->GetName(), 831 aString, 832 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, 833 sal_True ); 834 } 835 aRet <<= OUString ( aString ); 836 } 837 break; 838 } 839 } 840 else 841 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 842 } 843 return aRet; 844 } 845 /*-- 14.12.98 14:27:41--------------------------------------------------- 846 847 -----------------------------------------------------------------------*/ 848 void SwXEndnoteProperties::addPropertyChangeListener( 849 const OUString& /*PropertyName*/, const uno::Reference< beans::XPropertyChangeListener > & /*xListener*/) 850 { 851 DBG_WARNING("not implemented"); 852 } 853 /*-- 14.12.98 14:27:41--------------------------------------------------- 854 855 -----------------------------------------------------------------------*/ 856 void SwXEndnoteProperties::removePropertyChangeListener(const OUString& /*PropertyName*/, 857 const uno:: Reference< beans::XPropertyChangeListener > & /*xListener*/) 858 { 859 DBG_WARNING("not implemented"); 860 } 861 /*-- 14.12.98 14:27:41--------------------------------------------------- 862 863 -----------------------------------------------------------------------*/ 864 void SwXEndnoteProperties::addVetoableChangeListener(const OUString& /*PropertyName*/, 865 const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) 866 { 867 DBG_WARNING("not implemented"); 868 } 869 /*-- 14.12.98 14:27:42--------------------------------------------------- 870 871 -----------------------------------------------------------------------*/ 872 void SwXEndnoteProperties::removeVetoableChangeListener(const OUString& /*PropertyName*/, const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) 873 { 874 DBG_WARNING("not implemented"); 875 } 876 /****************************************************************** 877 * SwXLineNumberingProperties 878 ******************************************************************/ 879 /* -----------------------------06.04.00 11:47-------------------------------- 880 881 ---------------------------------------------------------------------------*/ 882 OUString SwXLineNumberingProperties::getImplementationName(void) 883 { 884 return C2U("SwXLineNumberingProperties"); 885 } 886 /* -----------------------------06.04.00 11:47-------------------------------- 887 888 ---------------------------------------------------------------------------*/ 889 sal_Bool SwXLineNumberingProperties::supportsService(const OUString& rServiceName) 890 { 891 return C2U("com.sun.star.text.LineNumberingProperties") == rServiceName; 892 } 893 /* -----------------------------06.04.00 11:47-------------------------------- 894 895 ---------------------------------------------------------------------------*/ 896 Sequence< OUString > SwXLineNumberingProperties::getSupportedServiceNames(void) 897 { 898 Sequence< OUString > aRet(1); 899 OUString* pArray = aRet.getArray(); 900 pArray[0] = C2U("com.sun.star.text.LineNumberingProperties"); 901 return aRet; 902 } 903 /*-- 14.12.98 14:33:36--------------------------------------------------- 904 905 -----------------------------------------------------------------------*/ 906 SwXLineNumberingProperties::SwXLineNumberingProperties(SwDoc* pDc) : 907 pDoc(pDc), 908 m_pPropertySet(GetLineNumberingSet()) 909 { 910 911 } 912 /*-- 14.12.98 14:33:37--------------------------------------------------- 913 914 -----------------------------------------------------------------------*/ 915 SwXLineNumberingProperties::~SwXLineNumberingProperties() 916 { 917 918 } 919 /*-- 14.12.98 14:33:37--------------------------------------------------- 920 921 -----------------------------------------------------------------------*/ 922 uno::Reference< beans::XPropertySetInfo > SwXLineNumberingProperties::getPropertySetInfo(void) 923 { 924 static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); 925 return aRef; 926 } 927 /*-- 14.12.98 14:33:37--------------------------------------------------- 928 929 -----------------------------------------------------------------------*/ 930 void SwXLineNumberingProperties::setPropertyValue( 931 const OUString& rPropertyName, const Any& aValue) 932 { 933 vos::OGuard aGuard(Application::GetSolarMutex()); 934 if(pDoc) 935 { 936 const SfxItemPropertySimpleEntry* pEntry = m_pPropertySet->getPropertyMap()->getByName( rPropertyName ); 937 if(pEntry) 938 { 939 if ( pEntry->nFlags & PropertyAttribute::READONLY) 940 throw PropertyVetoException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 941 SwLineNumberInfo aInfo(pDoc->GetLineNumberInfo()); 942 switch(pEntry->nWID) 943 { 944 case WID_NUM_ON: 945 { 946 sal_Bool bVal = *(sal_Bool*)aValue.getValue(); 947 aInfo.SetPaintLineNumbers(bVal); 948 } 949 break; 950 case WID_CHARACTER_STYLE : 951 { 952 SwCharFmt* pFmt = lcl_getCharFmt(pDoc, aValue); 953 if(pFmt) 954 aInfo.SetCharFmt(pFmt); 955 } 956 break; 957 case WID_NUMBERING_TYPE : 958 { 959 SvxNumberType aNumType(aInfo.GetNumType()); 960 sal_Int16 nTmp = 0; 961 aValue >>= nTmp; 962 aNumType.SetNumberingType(nTmp); 963 aInfo.SetNumType(aNumType); 964 } 965 break; 966 case WID_NUMBER_POSITION : 967 { 968 sal_Int16 nTmp = 0; 969 aValue >>= nTmp; 970 switch(nTmp) 971 { 972 case style::LineNumberPosition::LEFT: 973 aInfo.SetPos(LINENUMBER_POS_LEFT); ; 974 break; 975 case style::LineNumberPosition::RIGHT : 976 aInfo.SetPos(LINENUMBER_POS_RIGHT); ; 977 break; 978 case style::LineNumberPosition::INSIDE: 979 aInfo.SetPos(LINENUMBER_POS_INSIDE); ; 980 break; 981 case style::LineNumberPosition::OUTSIDE: 982 aInfo.SetPos(LINENUMBER_POS_OUTSIDE); 983 break; 984 } 985 } 986 break; 987 case WID_DISTANCE : 988 { 989 sal_Int32 nVal = 0; 990 aValue >>= nVal; 991 sal_Int32 nTmp = MM100_TO_TWIP(nVal); 992 if (nTmp > USHRT_MAX) 993 nTmp = USHRT_MAX; 994 aInfo.SetPosFromLeft( static_cast< sal_uInt16 >(nTmp) ); 995 } 996 break; 997 case WID_INTERVAL : 998 { 999 sal_Int16 nTmp = 0; 1000 aValue >>= nTmp; 1001 if( nTmp > 0) 1002 aInfo.SetCountBy(nTmp); 1003 } 1004 break; 1005 case WID_SEPARATOR_TEXT : 1006 { 1007 OUString uTmp; 1008 aValue >>= uTmp; 1009 aInfo.SetDivider(uTmp); 1010 } 1011 break; 1012 case WID_SEPARATOR_INTERVAL: 1013 { 1014 sal_Int16 nTmp = 0; 1015 aValue >>= nTmp; 1016 if( nTmp >= 0) 1017 aInfo.SetDividerCountBy(nTmp); 1018 } 1019 break; 1020 case WID_COUNT_EMPTY_LINES : 1021 { 1022 sal_Bool bVal = *(sal_Bool*)aValue.getValue(); 1023 aInfo.SetCountBlankLines(bVal); 1024 } 1025 break; 1026 case WID_COUNT_LINES_IN_FRAMES : 1027 { 1028 sal_Bool bVal = *(sal_Bool*)aValue.getValue(); 1029 aInfo.SetCountInFlys(bVal); 1030 } 1031 break; 1032 case WID_RESTART_AT_EACH_PAGE : 1033 { 1034 sal_Bool bVal = *(sal_Bool*)aValue.getValue(); 1035 aInfo.SetRestartEachPage(bVal); 1036 } 1037 break; 1038 } 1039 pDoc->SetLineNumberInfo(aInfo); 1040 } 1041 else 1042 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 1043 } 1044 else 1045 throw uno::RuntimeException(); 1046 } 1047 /*-- 14.12.98 14:33:38--------------------------------------------------- 1048 1049 -----------------------------------------------------------------------*/ 1050 Any SwXLineNumberingProperties::getPropertyValue(const OUString& rPropertyName) 1051 { 1052 vos::OGuard aGuard(Application::GetSolarMutex()); 1053 Any aRet; 1054 if(pDoc) 1055 { 1056 const SfxItemPropertySimpleEntry* pEntry = m_pPropertySet->getPropertyMap()->getByName( rPropertyName ); 1057 if(pEntry) 1058 { 1059 const SwLineNumberInfo& rInfo = pDoc->GetLineNumberInfo(); 1060 switch(pEntry->nWID) 1061 { 1062 case WID_NUM_ON: 1063 { 1064 sal_Bool bTemp = rInfo.IsPaintLineNumbers(); 1065 aRet.setValue(&bTemp, ::getCppuBooleanType()); 1066 } 1067 break; 1068 case WID_CHARACTER_STYLE : 1069 { 1070 String aString; 1071 // return empty string if no char format is set 1072 // otherwise it would be created here 1073 if(rInfo.HasCharFormat()) 1074 { 1075 SwStyleNameMapper::FillProgName( 1076 rInfo.GetCharFmt(*pDoc)->GetName(), 1077 aString, 1078 nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, 1079 sal_True); 1080 } 1081 aRet <<= OUString ( aString ); 1082 } 1083 break; 1084 case WID_NUMBERING_TYPE : 1085 aRet <<= rInfo.GetNumType().GetNumberingType(); 1086 break; 1087 case WID_NUMBER_POSITION : 1088 { 1089 sal_Int16 nRet = 0; 1090 switch(rInfo.GetPos()) 1091 { 1092 case LINENUMBER_POS_LEFT: 1093 nRet = style::LineNumberPosition::LEFT; 1094 break; 1095 case LINENUMBER_POS_RIGHT : 1096 nRet = style::LineNumberPosition::RIGHT ; 1097 break; 1098 case LINENUMBER_POS_INSIDE: 1099 nRet = style::LineNumberPosition::INSIDE ; 1100 break; 1101 case LINENUMBER_POS_OUTSIDE : 1102 nRet = style::LineNumberPosition::OUTSIDE ; 1103 break; 1104 } 1105 aRet <<= nRet; 1106 } 1107 break; 1108 case WID_DISTANCE : 1109 { 1110 sal_uInt32 nPos = rInfo.GetPosFromLeft(); 1111 if(USHRT_MAX == nPos) 1112 nPos = 0; 1113 aRet <<= static_cast < sal_Int32 >(TWIP_TO_MM100_UNSIGNED(nPos)); 1114 } 1115 break; 1116 case WID_INTERVAL : 1117 aRet <<= (sal_Int16)rInfo.GetCountBy(); 1118 break; 1119 case WID_SEPARATOR_TEXT : 1120 aRet <<= OUString(rInfo.GetDivider()); 1121 break; 1122 case WID_SEPARATOR_INTERVAL: 1123 aRet <<= (sal_Int16)rInfo.GetDividerCountBy(); 1124 break; 1125 case WID_COUNT_EMPTY_LINES : 1126 { 1127 sal_Bool bTemp = rInfo.IsCountBlankLines(); 1128 aRet.setValue(&bTemp, ::getCppuBooleanType()); 1129 } 1130 break; 1131 case WID_COUNT_LINES_IN_FRAMES : 1132 { 1133 sal_Bool bTemp = rInfo.IsCountInFlys(); 1134 aRet.setValue(&bTemp, ::getCppuBooleanType()); 1135 } 1136 break; 1137 case WID_RESTART_AT_EACH_PAGE : 1138 { 1139 sal_Bool bTemp = rInfo.IsRestartEachPage(); 1140 aRet.setValue(&bTemp, ::getCppuBooleanType()); 1141 } 1142 break; 1143 } 1144 } 1145 else 1146 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 1147 } 1148 else 1149 throw uno::RuntimeException(); 1150 return aRet; 1151 } 1152 /*-- 14.12.98 14:33:38--------------------------------------------------- 1153 1154 -----------------------------------------------------------------------*/ 1155 void SwXLineNumberingProperties::addPropertyChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XPropertyChangeListener > & /*xListener*/) 1156 { 1157 DBG_WARNING("not implemented"); 1158 } 1159 /*-- 14.12.98 14:33:38--------------------------------------------------- 1160 1161 -----------------------------------------------------------------------*/ 1162 void SwXLineNumberingProperties::removePropertyChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XPropertyChangeListener > & /*xListener*/) 1163 { 1164 DBG_WARNING("not implemented"); 1165 } 1166 /*-- 14.12.98 14:33:39--------------------------------------------------- 1167 1168 -----------------------------------------------------------------------*/ 1169 void SwXLineNumberingProperties::addVetoableChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) 1170 { 1171 DBG_WARNING("not implemented"); 1172 } 1173 /*-- 14.12.98 14:33:39--------------------------------------------------- 1174 1175 -----------------------------------------------------------------------*/ 1176 void SwXLineNumberingProperties::removeVetoableChangeListener(const OUString& /*rPropertyName*/, const uno:: Reference< beans::XVetoableChangeListener > & /*xListener*/) 1177 { 1178 DBG_WARNING("not implemented"); 1179 } 1180 /****************************************************************** 1181 * SwXNumberingRules 1182 ******************************************************************/ 1183 String SwXNumberingRules::sInvalidStyle(String::CreateFromAscii("__XXX___invalid")); 1184 1185 const String& SwXNumberingRules::GetInvalidStyle() 1186 { 1187 return sInvalidStyle; 1188 } 1189 /* -----------------------------10.03.00 17:05-------------------------------- 1190 1191 ---------------------------------------------------------------------------*/ 1192 const uno::Sequence< sal_Int8 > & SwXNumberingRules::getUnoTunnelId() 1193 { 1194 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); 1195 return aSeq; 1196 } 1197 /* -----------------------------10.03.00 17:05-------------------------------- 1198 1199 ---------------------------------------------------------------------------*/ 1200 // return implementation specific data 1201 sal_Int64 SwXNumberingRules::getSomething( const uno::Sequence< sal_Int8 > & rId ) 1202 { 1203 if( rId.getLength() == 16 1204 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), 1205 rId.getConstArray(), 16 ) ) 1206 { 1207 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) ); 1208 } 1209 return 0; 1210 } 1211 1212 /* -----------------------------06.04.00 11:47-------------------------------- 1213 1214 ---------------------------------------------------------------------------*/ 1215 OUString SwXNumberingRules::getImplementationName(void) 1216 { 1217 return C2U("SwXNumberingRules"); 1218 } 1219 /* -----------------------------06.04.00 11:47-------------------------------- 1220 1221 ---------------------------------------------------------------------------*/ 1222 sal_Bool SwXNumberingRules::supportsService(const OUString& rServiceName) 1223 { 1224 return C2U("com.sun.star.text.NumberingRules") == rServiceName; 1225 } 1226 /* -----------------------------06.04.00 11:47-------------------------------- 1227 1228 ---------------------------------------------------------------------------*/ 1229 Sequence< OUString > SwXNumberingRules::getSupportedServiceNames(void) 1230 { 1231 Sequence< OUString > aRet(1); 1232 OUString* pArray = aRet.getArray(); 1233 pArray[0] = C2U("com.sun.star.text.NumberingRules"); 1234 return aRet; 1235 } 1236 1237 /*-- 14.12.98 14:57:57--------------------------------------------------- 1238 1239 -----------------------------------------------------------------------*/ 1240 SwXNumberingRules::SwXNumberingRules(const SwNumRule& rRule) : 1241 pDoc(0), 1242 pDocShell(0), 1243 pNumRule(new SwNumRule(rRule)), 1244 m_pPropertySet(GetNumberingRulesSet()), 1245 bOwnNumRuleCreated(sal_True) 1246 { 1247 sal_uInt16 i; 1248 1249 //erstmal das Doc organisieren; es haengt an den gesetzten Zeichenvorlagen - wenn 1250 // keine gesetzt sind, muss es auch ohne gehen 1251 for( i = 0; i < MAXLEVEL; i++) 1252 { 1253 SwNumFmt rFmt(pNumRule->Get(i)); 1254 SwCharFmt* pCharFmt = rFmt.GetCharFmt(); 1255 if(pCharFmt) 1256 { 1257 pDoc = pCharFmt->GetDoc(); 1258 break; 1259 } 1260 } 1261 if(pDoc) 1262 pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this); 1263 for(i = 0; i < MAXLEVEL; i++) 1264 { 1265 sNewCharStyleNames[i] = SwXNumberingRules::GetInvalidStyle(); 1266 sNewBulletFontNames[i] = SwXNumberingRules::GetInvalidStyle(); 1267 } 1268 } 1269 /* -----------------22.02.99 16:35------------------- 1270 * 1271 * --------------------------------------------------*/ 1272 SwXNumberingRules::SwXNumberingRules(SwDocShell& rDocSh) : 1273 pDoc(0), 1274 pDocShell(&rDocSh), 1275 pNumRule(0), 1276 m_pPropertySet(GetNumberingRulesSet()), 1277 bOwnNumRuleCreated(sal_False) 1278 { 1279 pDocShell->GetDoc()->GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this); 1280 } 1281 /* -----------------------------24.08.00 11:36-------------------------------- 1282 1283 ---------------------------------------------------------------------------*/ 1284 SwXNumberingRules::SwXNumberingRules(SwDoc& rDoc) : 1285 pDoc(&rDoc), 1286 pDocShell(0), 1287 pNumRule(0), 1288 m_pPropertySet(GetNumberingRulesSet()), 1289 bOwnNumRuleCreated(sal_False) 1290 { 1291 rDoc.GetPageDescFromPool(RES_POOLPAGE_STANDARD)->Add(this); 1292 sCreatedNumRuleName = rDoc.GetUniqueNumRuleName(); 1293 #if OSL_DEBUG_LEVEL > 1 1294 sal_uInt16 nIndex = 1295 #endif 1296 // --> OD 2008-02-11 #newlistlevelattrs# 1297 rDoc.MakeNumRule( sCreatedNumRuleName, 0, sal_False, 1298 // --> OD 2008-06-06 #i89178# 1299 numfunc::GetDefaultPositionAndSpaceMode() ); 1300 // <-- 1301 // <-- 1302 #if OSL_DEBUG_LEVEL > 1 1303 (void)nIndex; 1304 #endif 1305 } 1306 /*-- 14.12.98 14:57:57--------------------------------------------------- 1307 1308 -----------------------------------------------------------------------*/ 1309 SwXNumberingRules::~SwXNumberingRules() 1310 { 1311 vos::OGuard aGuard(Application::GetSolarMutex()); 1312 if(pDoc && sCreatedNumRuleName.Len()) 1313 pDoc->DelNumRule( sCreatedNumRuleName ); 1314 if( pNumRule && bOwnNumRuleCreated ) 1315 delete pNumRule; 1316 } 1317 /*-- 14.12.98 14:57:58--------------------------------------------------- 1318 1319 -----------------------------------------------------------------------*/ 1320 void SwXNumberingRules::replaceByIndex(sal_Int32 nIndex, const uno::Any& rElement) 1321 { 1322 vos::OGuard aGuard(Application::GetSolarMutex()); 1323 if(nIndex < 0 || MAXLEVEL <= nIndex) 1324 throw lang::IndexOutOfBoundsException(); 1325 1326 if(rElement.getValueType().getTypeClass() != uno::TypeClass_SEQUENCE) 1327 throw lang::IllegalArgumentException(); 1328 const uno::Sequence<beans::PropertyValue>& rProperties = 1329 *(const uno::Sequence<beans::PropertyValue>*)rElement.getValue(); 1330 SwNumRule* pRule = 0; 1331 if(pNumRule) 1332 SwXNumberingRules::SetNumberingRuleByIndex( *pNumRule, 1333 rProperties, nIndex); 1334 else if(pDocShell) 1335 { 1336 // --> OD 2008-04-21 #i87650# - correction of cws swwarnings: 1337 // Do not set member <pNumRule> 1338 // pNumRule = pDocShell->GetDoc()->GetOutlineNumRule(); 1339 // SwNumRule aNumRule(*pNumRule); 1340 SwNumRule aNumRule( *(pDocShell->GetDoc()->GetOutlineNumRule()) ); 1341 // <-- 1342 SwXNumberingRules::SetNumberingRuleByIndex( aNumRule, 1343 rProperties, nIndex); 1344 //hier noch die Zeichenformate bei Bedarf setzen 1345 const SwCharFmts* pFmts = pDocShell->GetDoc()->GetCharFmts(); 1346 sal_uInt16 nChCount = pFmts->Count(); 1347 for(sal_uInt16 i = 0; i < MAXLEVEL;i++) 1348 { 1349 SwNumFmt aFmt(aNumRule.Get( i )); 1350 if(sNewCharStyleNames[i].Len() && 1351 !sNewCharStyleNames[i].EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_CHARACTER_FORMAT_NONE)) && 1352 (!aFmt.GetCharFmt() || 1353 aFmt.GetCharFmt()->GetName()!= sNewCharStyleNames[i] )) 1354 { 1355 SwCharFmt* pCharFmt = 0; 1356 for(sal_uInt16 j = 0; j< nChCount; j++) 1357 { 1358 SwCharFmt* pTmp = (*pFmts)[j]; 1359 if(pTmp->GetName() == sNewCharStyleNames[i]) 1360 { 1361 pCharFmt = pTmp; 1362 break; 1363 } 1364 } 1365 if(!pCharFmt) 1366 { 1367 SfxStyleSheetBase* pBase; 1368 pBase = pDocShell->GetStyleSheetPool()->Find(sNewCharStyleNames[i], 1369 SFX_STYLE_FAMILY_CHAR); 1370 if(!pBase) 1371 pBase = &pDocShell->GetStyleSheetPool()->Make(sNewCharStyleNames[i], SFX_STYLE_FAMILY_CHAR); 1372 pCharFmt = ((SwDocStyleSheet*)pBase)->GetCharFmt(); 1373 1374 } 1375 aFmt.SetCharFmt( pCharFmt ); 1376 aNumRule.Set( i, aFmt ); 1377 } 1378 } 1379 pDocShell->GetDoc()->SetOutlineNumRule( aNumRule ); 1380 } 1381 else if(!pNumRule && pDoc && sCreatedNumRuleName.Len() && 1382 0 != (pRule = pDoc->FindNumRulePtr( sCreatedNumRuleName ))) 1383 { 1384 SwXNumberingRules::SetNumberingRuleByIndex( *pRule, 1385 rProperties, nIndex); 1386 1387 pRule->Validate(); 1388 } 1389 else 1390 throw uno::RuntimeException(); 1391 1392 } 1393 /*-- 14.12.98 14:57:58--------------------------------------------------- 1394 1395 -----------------------------------------------------------------------*/ 1396 sal_Int32 SwXNumberingRules::getCount(void) 1397 { 1398 return MAXLEVEL; 1399 } 1400 /*-- 14.12.98 14:57:58--------------------------------------------------- 1401 1402 -----------------------------------------------------------------------*/ 1403 uno::Any SwXNumberingRules::getByIndex(sal_Int32 nIndex) 1404 { 1405 vos::OGuard aGuard(Application::GetSolarMutex()); 1406 if(nIndex < 0 || MAXLEVEL <= nIndex) 1407 throw lang::IndexOutOfBoundsException(); 1408 1409 uno::Any aVal; 1410 const SwNumRule* pRule = pNumRule; 1411 if(!pRule && pDoc && sCreatedNumRuleName.Len()) 1412 pRule = pDoc->FindNumRulePtr( sCreatedNumRuleName ); 1413 if(pRule) 1414 { 1415 uno::Sequence<beans::PropertyValue> aRet = GetNumberingRuleByIndex( 1416 *pRule, nIndex); 1417 aVal.setValue(&aRet, ::getCppuType((uno::Sequence<beans::PropertyValue>*)0)); 1418 1419 } 1420 else if(pDocShell) 1421 { 1422 uno::Sequence<beans::PropertyValue> aRet = GetNumberingRuleByIndex( 1423 *pDocShell->GetDoc()->GetOutlineNumRule(), nIndex); 1424 aVal.setValue(&aRet, ::getCppuType((uno::Sequence<beans::PropertyValue>*)0)); 1425 } 1426 else 1427 throw uno::RuntimeException(); 1428 return aVal; 1429 } 1430 /*-- 14.12.98 14:57:59--------------------------------------------------- 1431 1432 -----------------------------------------------------------------------*/ 1433 uno::Type SwXNumberingRules::getElementType(void) 1434 { 1435 return ::getCppuType((uno::Sequence<beans::PropertyValue>*)0); 1436 } 1437 /*-- 14.12.98 14:57:59--------------------------------------------------- 1438 1439 -----------------------------------------------------------------------*/ 1440 sal_Bool SwXNumberingRules::hasElements(void) 1441 { 1442 return sal_True; 1443 } 1444 /*-- 14.12.98 14:57:59--------------------------------------------------- 1445 1446 -----------------------------------------------------------------------*/ 1447 uno::Sequence<beans::PropertyValue> SwXNumberingRules::GetNumberingRuleByIndex( 1448 const SwNumRule& rNumRule, sal_Int32 nIndex) const 1449 { 1450 vos::OGuard aGuard(Application::GetSolarMutex()); 1451 DBG_ASSERT( 0 <= nIndex && nIndex < MAXLEVEL, "index out of range" ); 1452 1453 const SwNumFmt& rFmt = rNumRule.Get( (sal_uInt16)nIndex ); 1454 1455 sal_Bool bChapterNum = pDocShell != 0; 1456 1457 PropValDataArr aPropertyValues; 1458 //fill all properties into the array 1459 1460 //adjust 1461 SvxAdjust eAdj = rFmt.GetNumAdjust(); 1462 sal_Int16 nINT16 = aSvxToUnoAdjust[(sal_uInt16)eAdj]; 1463 PropValData* pData = new PropValData((void*)&nINT16, "Adjust", ::getCppuType((const sal_Int16*)0) ); 1464 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1465 1466 //parentnumbering 1467 nINT16 = rFmt.GetIncludeUpperLevels(); 1468 pData = new PropValData((void*)&nINT16, "ParentNumbering", ::getCppuType((const sal_Int16*)0)); 1469 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1470 1471 //prefix 1472 OUString aUString = rFmt.GetPrefix(); 1473 pData = new PropValData((void*)&aUString, "Prefix", ::getCppuType((const OUString*)0)); 1474 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1475 1476 //suffix 1477 aUString = rFmt.GetSuffix(); 1478 pData = new PropValData((void*)&aUString, "Suffix", ::getCppuType((const OUString*)0)); 1479 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1480 1481 //char style name 1482 SwCharFmt* pCharFmt = rFmt.GetCharFmt(); 1483 String CharStyleName; 1484 if(pCharFmt) 1485 CharStyleName = pCharFmt->GetName(); 1486 //egal ob ein Style vorhanden ist oder nicht ueberschreibt der Array-Eintrag diesen String 1487 if(sNewCharStyleNames[(sal_uInt16)nIndex].Len() && 1488 SwXNumberingRules::sInvalidStyle != sNewCharStyleNames[(sal_uInt16)nIndex]) 1489 CharStyleName = sNewCharStyleNames[(sal_uInt16)nIndex]; 1490 1491 String aString; 1492 SwStyleNameMapper::FillProgName( CharStyleName, aString, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True ); 1493 aUString = aString; 1494 pData = new PropValData((void*)&aUString, "CharStyleName", ::getCppuType((const OUString*)0)); 1495 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1496 1497 //startvalue 1498 nINT16 = rFmt.GetStart(); 1499 pData = new PropValData((void*)&nINT16, "StartWith", ::getCppuType((const sal_Int16*)0)); 1500 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1501 1502 // --> OD 2008-01-23 #newlistlevelattrs# 1503 if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) 1504 { 1505 //leftmargin 1506 sal_Int32 nINT32 = TWIP_TO_MM100(rFmt.GetAbsLSpace()); 1507 pData = new PropValData((void*)&nINT32, SW_PROP_NAME_STR(UNO_NAME_LEFT_MARGIN), ::getCppuType((const sal_Int32*)0)); 1508 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1509 1510 //chartextoffset 1511 nINT32 = TWIP_TO_MM100(rFmt.GetCharTextDistance()); 1512 pData = new PropValData((void*)&nINT32, SW_PROP_NAME_STR(UNO_NAME_SYMBOL_TEXT_DISTANCE), ::getCppuType((const sal_Int32*)0)); 1513 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1514 1515 //firstlineoffset 1516 nINT32 = TWIP_TO_MM100(rFmt.GetFirstLineOffset()); 1517 pData = new PropValData((void*)&nINT32, SW_PROP_NAME_STR(UNO_NAME_FIRST_LINE_OFFSET), ::getCppuType((const sal_Int32*)0)); 1518 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1519 } 1520 // <-- 1521 1522 // --> OD 2008-01-15 #newlistlevelattrs# 1523 // PositionAndSpaceMode 1524 nINT16 = PositionAndSpaceMode::LABEL_WIDTH_AND_POSITION; 1525 if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ) 1526 { 1527 nINT16 = PositionAndSpaceMode::LABEL_ALIGNMENT; 1528 } 1529 pData = new PropValData( (void*)&nINT16, 1530 SW_PROP_NAME_STR(UNO_NAME_POSITION_AND_SPACE_MODE), 1531 ::getCppuType((const sal_Int16*)0) ); 1532 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1533 1534 if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ) 1535 { 1536 // LabelFollowedBy 1537 nINT16 = LabelFollow::LISTTAB; 1538 if ( rFmt.GetLabelFollowedBy() == SvxNumberFormat::SPACE ) 1539 { 1540 nINT16 = LabelFollow::SPACE; 1541 } 1542 else if ( rFmt.GetLabelFollowedBy() == SvxNumberFormat::NOTHING ) 1543 { 1544 nINT16 = LabelFollow::NOTHING; 1545 } 1546 pData = new PropValData( (void*)&nINT16, 1547 SW_PROP_NAME_STR(UNO_NAME_LABEL_FOLLOWED_BY), 1548 ::getCppuType((const sal_Int16*)0) ); 1549 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1550 1551 // ListtabStopPosition 1552 sal_Int32 nINT32 = TWIP_TO_MM100(rFmt.GetListtabPos()); 1553 pData = new PropValData( (void*)&nINT32, 1554 SW_PROP_NAME_STR(UNO_NAME_LISTTAB_STOP_POSITION), 1555 ::getCppuType((const sal_Int32*)0)); 1556 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1557 1558 // FirstLineIndent 1559 nINT32 = TWIP_TO_MM100(rFmt.GetFirstLineIndent()); 1560 pData = new PropValData( (void*)&nINT32, 1561 SW_PROP_NAME_STR(UNO_NAME_FIRST_LINE_INDENT), 1562 ::getCppuType((const sal_Int32*)0)); 1563 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1564 1565 // IndentAt 1566 nINT32 = TWIP_TO_MM100(rFmt.GetIndentAt()); 1567 pData = new PropValData( (void*)&nINT32, 1568 SW_PROP_NAME_STR(UNO_NAME_INDENT_AT), 1569 ::getCppuType((const sal_Int32*)0)); 1570 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1571 } 1572 // <-- 1573 1574 //numberingtype 1575 nINT16 = rFmt.GetNumberingType(); 1576 pData = new PropValData((void*)&nINT16, "NumberingType", ::getCppuType((const sal_Int16*)0)); 1577 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1578 1579 if(!bChapterNum) 1580 { 1581 if(SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType()) 1582 { 1583 //BulletId 1584 nINT16 = rFmt.GetBulletChar(); 1585 pData = new PropValData((void*)&nINT16, "BulletId", ::getCppuType((const sal_Int16*)0)); 1586 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1587 1588 const Font* pFont = rFmt.GetBulletFont(); 1589 1590 //BulletChar 1591 aUString = OUString(rFmt.GetBulletChar()); 1592 pData = new PropValData((void*)&aUString, "BulletChar", ::getCppuType((const OUString*)0)); 1593 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1594 1595 //BulletFontName 1596 String sBulletFontName; 1597 if(pFont) 1598 sBulletFontName = pFont->GetStyleName(); 1599 aUString = sBulletFontName; 1600 pData = new PropValData((void*)&aUString, "BulletFontName", ::getCppuType((const OUString*)0)); 1601 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1602 1603 //BulletFont 1604 if(pFont) 1605 { 1606 awt::FontDescriptor aDesc; 1607 SvxUnoFontDescriptor::ConvertFromFont( *pFont, aDesc ); 1608 pData = new PropValData((void*)&aDesc, SW_PROP_NAME_STR(UNO_NAME_BULLET_FONT), ::getCppuType((const awt::FontDescriptor*)0)); 1609 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1610 } 1611 } 1612 if(SVX_NUM_BITMAP == rFmt.GetNumberingType()) 1613 { 1614 //GraphicURL 1615 const SvxBrushItem* pBrush = rFmt.GetBrush(); 1616 if(pBrush) 1617 { 1618 Any aAny; 1619 pBrush->QueryValue( aAny, MID_GRAPHIC_URL ); 1620 aAny >>= aUString; 1621 } 1622 else 1623 aUString = aEmptyStr; 1624 pData = new PropValData((void*)&aUString, SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_URL), ::getCppuType((const OUString*)0)); 1625 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1626 1627 //graphicbitmap 1628 const Graphic* pGraphic = 0; 1629 if(pBrush ) 1630 pGraphic = pBrush->GetGraphic(); 1631 if(pGraphic) 1632 { 1633 uno::Reference<awt::XBitmap> xBmp = VCLUnoHelper::CreateBitmap( pGraphic->GetBitmapEx() ); 1634 pData = new PropValData((void*)&xBmp, SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_BITMAP), 1635 ::getCppuType((const uno::Reference<awt::XBitmap>*)0)); 1636 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1637 } 1638 Size aSize = rFmt.GetGraphicSize(); 1639 // --> OD 2010-05-04 #i101131# - applying patch from CMC 1640 // adjust conversion due to type mismatch between <Size> and <awt::Size> 1641 // aSize.Width() = TWIP_TO_MM100( aSize.Width() ); 1642 // aSize.Height() = TWIP_TO_MM100( aSize.Height() ); 1643 // pData = new PropValData((void*)&aSize, SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_SIZE), ::getCppuType((const awt::Size*)0)); 1644 awt::Size aAwtSize(TWIP_TO_MM100(aSize.Width()), TWIP_TO_MM100(aSize.Height())); 1645 pData = new PropValData((void*)&aAwtSize, SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_SIZE), ::getCppuType((const awt::Size*)0)); 1646 // <-- 1647 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1648 1649 const SwFmtVertOrient* pOrient = rFmt.GetGraphicOrientation(); 1650 if(pOrient) 1651 { 1652 pData = new PropValData((void*)0, SW_PROP_NAME_STR(UNO_NAME_VERT_ORIENT), ::getCppuType((const sal_Int16*)0)); 1653 ((const SfxPoolItem*)pOrient)->QueryValue(pData->aVal, MID_VERTORIENT_ORIENT); 1654 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1655 } 1656 } 1657 1658 } 1659 else 1660 { 1661 //Vorlagenname 1662 String sValue(SW_RES(STR_POOLCOLL_HEADLINE1 + nIndex)); 1663 const SwTxtFmtColls* pColls = pDocShell->GetDoc()->GetTxtFmtColls(); 1664 const sal_uInt16 nCount = pColls->Count(); 1665 for(sal_uInt16 i = 0; i < nCount;++i) 1666 { 1667 SwTxtFmtColl &rTxtColl = *pColls->operator[](i); 1668 if(rTxtColl.IsDefault()) 1669 continue; 1670 1671 //sal_Int8 nOutLevel = rTxtColl.GetOutlineLevel(); //#outline level,zhaojianwei 1672 const sal_Int16 nOutLevel = rTxtColl.IsAssignedToListLevelOfOutlineStyle() 1673 ? static_cast<sal_Int16>(rTxtColl.GetAssignedOutlineStyleLevel()) 1674 : MAXLEVEL; //<-end,zhaojianwei 1675 if ( nOutLevel == nIndex ) 1676 { 1677 sValue = rTxtColl.GetName(); 1678 break; // the style for the level in question has been found 1679 } 1680 else if( sValue==rTxtColl.GetName() ) 1681 { 1682 // if the default for the level is existing, but its 1683 // level is different, then it cannot be the default. 1684 sValue.Erase(); 1685 } 1686 } 1687 String aName; 1688 SwStyleNameMapper::FillProgName(sValue, aName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True); 1689 aUString = aName; 1690 1691 pData = new PropValData((void*)&aUString, SW_PROP_NAME_STR(UNO_NAME_HEADING_STYLE_NAME), ::getCppuType((const OUString*)0)); 1692 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1693 } 1694 1695 uno::Sequence<beans::PropertyValue> aSeq(aPropertyValues.Count()); 1696 beans::PropertyValue* pArray = aSeq.getArray(); 1697 1698 for(sal_uInt16 i = 0; i < aPropertyValues.Count(); i++) 1699 { 1700 pData = aPropertyValues.GetObject(i); 1701 pArray[i].Value = pData->aVal; 1702 pArray[i].Name = pData->sPropName; 1703 pArray[i].Handle = -1; 1704 } 1705 aPropertyValues.DeleteAndDestroy(0, aPropertyValues.Count()); 1706 return aSeq; 1707 } 1708 /*-- 14.12.98 14:57:59--------------------------------------------------- 1709 1710 -----------------------------------------------------------------------*/ 1711 PropValData* lcl_FindProperty(const char* cName, PropValDataArr& rPropertyValues) 1712 { 1713 OUString sCmp = C2U(cName); 1714 for(sal_uInt16 i = 0; i < rPropertyValues.Count(); i++) 1715 { 1716 PropValData* pTemp = rPropertyValues.GetObject(i); 1717 if(sCmp == pTemp->sPropName) 1718 return pTemp; 1719 } 1720 return 0; 1721 } 1722 //----------------------------------------------------------------------- 1723 1724 void SwXNumberingRules::SetNumberingRuleByIndex( 1725 SwNumRule& rNumRule, 1726 const uno::Sequence<beans::PropertyValue>& rProperties, sal_Int32 nIndex) 1727 { 1728 vos::OGuard aGuard(Application::GetSolarMutex()); 1729 DBG_ASSERT( 0 <= nIndex && nIndex < MAXLEVEL, "index out of range" ); 1730 1731 // the order of the names is important! 1732 static const char* aNumPropertyNames[] = 1733 { 1734 "Adjust", //0 1735 "ParentNumbering", //1 1736 "Prefix", //2 1737 "Suffix", //3 1738 "CharStyleName", //4 1739 "StartWith", //5 1740 SW_PROP_NAME_STR(UNO_NAME_LEFT_MARGIN), //6 1741 SW_PROP_NAME_STR(UNO_NAME_SYMBOL_TEXT_DISTANCE), //7 1742 SW_PROP_NAME_STR(UNO_NAME_FIRST_LINE_OFFSET), //8 1743 // --> OD 2008-01-15 #newlistlevelattrs# 1744 SW_PROP_NAME_STR(UNO_NAME_POSITION_AND_SPACE_MODE), //9 1745 SW_PROP_NAME_STR(UNO_NAME_LABEL_FOLLOWED_BY), //10 1746 SW_PROP_NAME_STR(UNO_NAME_LISTTAB_STOP_POSITION), //11 1747 SW_PROP_NAME_STR(UNO_NAME_FIRST_LINE_INDENT), //12 1748 SW_PROP_NAME_STR(UNO_NAME_INDENT_AT), //13 1749 // <-- 1750 "NumberingType", //14 1751 "BulletId", //15 1752 SW_PROP_NAME_STR(UNO_NAME_BULLET_FONT), //16 1753 "BulletFontName", //17 1754 "BulletChar", //18 1755 SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_URL), //19 1756 SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_BITMAP), //20 1757 SW_PROP_NAME_STR(UNO_NAME_GRAPHIC_SIZE), //21 1758 SW_PROP_NAME_STR(UNO_NAME_VERT_ORIENT), //22 1759 SW_PROP_NAME_STR(UNO_NAME_HEADING_STYLE_NAME) //23 1760 }; 1761 // --> OD 2008-01-15 #newlistlevelattrs# 1762 const sal_uInt16 nPropNameCount = 24; 1763 const sal_uInt16 nNotInChapter = 15; 1764 // <-- 1765 1766 const beans::PropertyValue* pPropArray = rProperties.getConstArray(); 1767 PropValDataArr aPropertyValues; 1768 sal_Bool bExcept = sal_False; 1769 for(int i = 0; i < rProperties.getLength() && !bExcept; i++) 1770 { 1771 const beans::PropertyValue& rProp = pPropArray[i]; 1772 bExcept = sal_True; 1773 for(sal_uInt16 j = 0; j < (pDocShell ? nPropNameCount : nPropNameCount - 1); j++) 1774 { 1775 //some values not in chapter numbering 1776 if(pDocShell && j == nNotInChapter) 1777 j = nPropNameCount - 1; 1778 if(COMPARE_EQUAL == rProp.Name.compareToAscii(aNumPropertyNames[j])) 1779 { 1780 bExcept = sal_False; 1781 break; 1782 } 1783 } 1784 if(bExcept && 1785 (rProp.Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("BulletRelSize")) || 1786 rProp.Name.equalsAsciiL(RTL_CONSTASCII_STRINGPARAM("BulletColor")) ) ) 1787 { 1788 bExcept = sal_False; 1789 } 1790 PropValData* pData = new PropValData(rProp.Value, rProp.Name ); 1791 aPropertyValues.Insert(pData, aPropertyValues.Count()); 1792 } 1793 1794 SwNumFmt aFmt(rNumRule.Get( (sal_uInt16)nIndex )); 1795 sal_Bool bWrongArg = sal_False; 1796 if(!bExcept) 1797 { 1798 SvxBrushItem* pSetBrush = 0; 1799 Size* pSetSize = 0; 1800 SwFmtVertOrient* pSetVOrient = 0; 1801 sal_Bool bCharStyleNameSet = sal_False; 1802 1803 for(sal_uInt16 i = 0; i < nPropNameCount && !bExcept && !bWrongArg; i++) 1804 { 1805 PropValData* pData = lcl_FindProperty(aNumPropertyNames[i], aPropertyValues); 1806 if(!pData) 1807 continue; 1808 switch(i) 1809 { 1810 case 0: //"Adjust" 1811 { 1812 sal_Int16 nValue = 0; 1813 pData->aVal >>= nValue; 1814 if(nValue > 0 && 1815 nValue <= text::HoriOrientation::LEFT && 1816 USHRT_MAX != aUnoToSvxAdjust[nValue]) 1817 { 1818 aFmt.SetNumAdjust((SvxAdjust)aUnoToSvxAdjust[nValue]); 1819 } 1820 else 1821 bWrongArg = sal_True; 1822 } 1823 break; 1824 case 1: //"ParentNumbering", 1825 { 1826 sal_Int16 nSet = 0; 1827 pData->aVal >>= nSet; 1828 if(nSet >= 0 && MAXLEVEL >= nSet) 1829 aFmt.SetIncludeUpperLevels( static_cast< sal_uInt8 >(nSet) ); 1830 } 1831 break; 1832 case 2: //"Prefix", 1833 { 1834 OUString uTmp; 1835 pData->aVal >>= uTmp; 1836 aFmt.SetPrefix(uTmp); 1837 } 1838 break; 1839 case 3: //"Suffix", 1840 { 1841 OUString uTmp; 1842 pData->aVal >>= uTmp; 1843 aFmt.SetSuffix(uTmp); 1844 } 1845 break; 1846 case 4: //"CharStyleName", 1847 { 1848 bCharStyleNameSet = sal_True; 1849 OUString uTmp; 1850 pData->aVal >>= uTmp; 1851 String sCharFmtName; 1852 SwStyleNameMapper::FillUIName( uTmp, sCharFmtName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT, sal_True ); 1853 if(sCharFmtName.EqualsAscii(SW_PROP_NAME_STR(UNO_NAME_CHARACTER_FORMAT_NONE))) 1854 { 1855 sNewCharStyleNames[(sal_uInt16)nIndex] = SwXNumberingRules::GetInvalidStyle(); 1856 aFmt.SetCharFmt(0); 1857 } 1858 else if(pDocShell || pDoc) 1859 { 1860 SwDoc* pLocalDoc = pDoc ? pDoc : pDocShell->GetDoc(); 1861 const SwCharFmts* pFmts = pLocalDoc->GetCharFmts(); 1862 sal_uInt16 nChCount = pFmts->Count(); 1863 1864 SwCharFmt* pCharFmt = 0; 1865 if(sCharFmtName.Len()) 1866 { 1867 for(sal_uInt16 j = 0; j< nChCount; j++) 1868 { 1869 SwCharFmt* pTmp = (*pFmts)[j]; 1870 if(pTmp->GetName() == sCharFmtName) 1871 { 1872 pCharFmt = pTmp; 1873 break; 1874 } 1875 } 1876 if(!pCharFmt) 1877 { 1878 1879 SfxStyleSheetBase* pBase; 1880 SfxStyleSheetBasePool* pPool = pLocalDoc->GetDocShell()->GetStyleSheetPool(); 1881 pBase = ((SfxStyleSheetBasePool*)pPool)->Find(sCharFmtName, SFX_STYLE_FAMILY_CHAR); 1882 if(!pBase) 1883 pBase = &pPool->Make(sCharFmtName, SFX_STYLE_FAMILY_CHAR); 1884 pCharFmt = ((SwDocStyleSheet*)pBase)->GetCharFmt(); 1885 } 1886 } 1887 aFmt.SetCharFmt( pCharFmt ); 1888 // os 2005-08-22 #i51842# 1889 // If the character format has been found it's name should not be in the 1890 // char style names array 1891 //sNewCharStyleNames[(sal_uInt16)nIndex] = sCharFmtName; 1892 sNewCharStyleNames[(sal_uInt16)nIndex].Erase(); 1893 } 1894 else 1895 sNewCharStyleNames[(sal_uInt16)nIndex] = sCharFmtName; 1896 } 1897 break; 1898 case 5: //"StartWith", 1899 { 1900 sal_Int16 nVal = 0; 1901 pData->aVal >>= nVal; 1902 aFmt.SetStart(nVal); 1903 } 1904 break; 1905 case 6: //UNO_NAME_LEFT_MARGIN, 1906 { 1907 sal_Int32 nValue = 0; 1908 pData->aVal >>= nValue; 1909 // #i23727# nValue can be negative 1910 aFmt.SetAbsLSpace((sal_uInt16) MM100_TO_TWIP(nValue)); 1911 } 1912 break; 1913 case 7: //UNO_NAME_SYMBOL_TEXT_DISTANCE, 1914 { 1915 sal_Int32 nValue = 0; 1916 pData->aVal >>= nValue; 1917 if(nValue >= 0) 1918 aFmt.SetCharTextDistance((sal_uInt16) MM100_TO_TWIP(nValue)); 1919 else 1920 bWrongArg = sal_True; 1921 } 1922 break; 1923 case 8: //UNO_NAME_FIRST_LINE_OFFSET, 1924 { 1925 sal_Int32 nValue = 0; 1926 pData->aVal >>= nValue; 1927 // #i23727# nValue can be positive 1928 nValue = MM100_TO_TWIP(nValue); 1929 aFmt.SetFirstLineOffset((short)nValue); 1930 } 1931 break; 1932 // --> OD 2008-01-15 #newlistlevelattrs# 1933 case 9: // UNO_NAME_POSITION_AND_SPACE_MODE 1934 { 1935 sal_Int16 nValue = 0; 1936 pData->aVal >>= nValue; 1937 if ( nValue == 0 ) 1938 { 1939 aFmt.SetPositionAndSpaceMode( SvxNumberFormat::LABEL_WIDTH_AND_POSITION ); 1940 } 1941 else if ( nValue == 1 ) 1942 { 1943 aFmt.SetPositionAndSpaceMode( SvxNumberFormat::LABEL_ALIGNMENT ); 1944 } 1945 else 1946 { 1947 bWrongArg = sal_True; 1948 } 1949 } 1950 break; 1951 case 10: // UNO_NAME_LABEL_FOLLOWED_BY 1952 { 1953 sal_Int16 nValue = 0; 1954 pData->aVal >>= nValue; 1955 if ( nValue == 0 ) 1956 { 1957 aFmt.SetLabelFollowedBy( SvxNumberFormat::LISTTAB ); 1958 } 1959 else if ( nValue == 1 ) 1960 { 1961 aFmt.SetLabelFollowedBy( SvxNumberFormat::SPACE ); 1962 } 1963 else if ( nValue == 2 ) 1964 { 1965 aFmt.SetLabelFollowedBy( SvxNumberFormat::NOTHING ); 1966 } 1967 else 1968 { 1969 bWrongArg = sal_True; 1970 } 1971 } 1972 break; 1973 case 11: // UNO_NAME_LISTTAB_STOP_POSITION 1974 { 1975 sal_Int32 nValue = 0; 1976 pData->aVal >>= nValue; 1977 nValue = MM100_TO_TWIP(nValue); 1978 if ( nValue >= 0 ) 1979 { 1980 aFmt.SetListtabPos( nValue ); 1981 } 1982 else 1983 { 1984 bWrongArg = sal_True; 1985 } 1986 } 1987 break; 1988 case 12: // UNO_NAME_FIRST_LINE_INDENT 1989 { 1990 sal_Int32 nValue = 0; 1991 pData->aVal >>= nValue; 1992 nValue = MM100_TO_TWIP(nValue); 1993 aFmt.SetFirstLineIndent( nValue ); 1994 } 1995 break; 1996 case 13: // UNO_NAME_INDENT_AT 1997 { 1998 sal_Int32 nValue = 0; 1999 pData->aVal >>= nValue; 2000 nValue = MM100_TO_TWIP(nValue); 2001 aFmt.SetIndentAt( nValue ); 2002 } 2003 break; 2004 // <-- 2005 case 14: //"NumberingType" 2006 { 2007 sal_Int16 nSet = 0; 2008 pData->aVal >>= nSet; 2009 if(nSet >= 0) 2010 aFmt.SetNumberingType(nSet); 2011 else 2012 bWrongArg = sal_True; 2013 } 2014 break; 2015 case 15: //"BulletId", 2016 { 2017 sal_Int16 nSet = 0; 2018 if( pData->aVal >>= nSet ) 2019 aFmt.SetBulletChar(nSet); 2020 else 2021 bWrongArg = sal_True; 2022 } 2023 break; 2024 case 16: //UNO_NAME_BULLET_FONT, 2025 { 2026 awt::FontDescriptor* pDesc = (awt::FontDescriptor*)pData->aVal.getValue(); 2027 if(pDesc) 2028 { 2029 // --> OD 2008-09-11 #i93725# 2030 // do not accept "empty" font 2031 if ( pDesc->Name.getLength() > 0 ) 2032 { 2033 Font aFont; 2034 SvxUnoFontDescriptor::ConvertToFont( *pDesc, aFont ); 2035 aFmt.SetBulletFont(&aFont); 2036 } 2037 // <-- 2038 } 2039 else 2040 bWrongArg = sal_True; 2041 } 2042 break; 2043 case 17: //"BulletFontName", 2044 { 2045 OUString uTmp; 2046 pData->aVal >>= uTmp; 2047 String sBulletFontName(uTmp); 2048 SwDocShell* pLclDocShell = pDocShell ? pDocShell : pDoc ? pDoc->GetDocShell() : 0; 2049 if( sBulletFontName.Len() && pLclDocShell ) 2050 { 2051 const SvxFontListItem* pFontListItem = 2052 (const SvxFontListItem* )pLclDocShell 2053 ->GetItem( SID_ATTR_CHAR_FONTLIST ); 2054 const FontList* pList = pFontListItem->GetFontList(); 2055 FontInfo aInfo = pList->Get( 2056 sBulletFontName, WEIGHT_NORMAL, ITALIC_NONE); 2057 Font aFont(aInfo); 2058 aFmt.SetBulletFont(&aFont); 2059 } 2060 else 2061 sNewBulletFontNames[(sal_uInt16)nIndex] = sBulletFontName; 2062 } 2063 break; 2064 case 18: //"BulletChar", 2065 { 2066 OUString aChar; 2067 pData->aVal >>= aChar; 2068 if(aChar.getLength() == 1) 2069 { 2070 aFmt.SetBulletChar(aChar.toChar()); 2071 } 2072 else 2073 bWrongArg = sal_True; 2074 } 2075 break; 2076 case 19: //UNO_NAME_GRAPHIC_URL, 2077 { 2078 OUString sBrushURL; 2079 pData->aVal >>= sBrushURL; 2080 // We could have pDoc, but not pDocShell, or vice-versa 2081 SwDoc* myDoc = pDoc; 2082 SwDocShell* myDocShell = pDocShell; 2083 if ( myDoc && ( myDocShell == NULL ) ) { 2084 myDocShell = myDoc->GetDocShell(); 2085 } else if ( ( myDoc == NULL ) && myDocShell ) { 2086 myDoc = myDocShell->GetDoc(); 2087 } 2088 if ( myDoc && myDocShell ) { 2089 // The following access to the window is copied from SwDoc::UpdateLinks() 2090 SfxMedium* pMedium = myDocShell->GetMedium(); 2091 SfxFrame* pFrm = pMedium ? pMedium->GetLoadTargetFrame() : 0; 2092 sfx2::LinkManager& pLinkMgr = myDoc->GetLinkManager(); 2093 if ( pLinkMgr.urlIsVendor( sBrushURL ) ) { 2094 break; // Stop here 2095 } 2096 if ( !pLinkMgr.urlIsSafe( sBrushURL ) ) { 2097 Window* pDlgParent = 0; 2098 if ( pFrm ) 2099 pDlgParent = &pFrm->GetWindow(); 2100 if ( !pDlgParent ) 2101 pDlgParent = myDocShell->GetDialogParent( pMedium ); 2102 if ( pDlgParent ) 2103 if ( !pLinkMgr.GetUserAllowsLinkUpdate( pDlgParent )) { 2104 break; // Stop here 2105 } 2106 } 2107 } 2108 if(!pSetBrush) 2109 { 2110 const SvxBrushItem* pOrigBrush = aFmt.GetBrush(); 2111 if(pOrigBrush) 2112 { 2113 pSetBrush = new SvxBrushItem(*pOrigBrush); 2114 } 2115 else 2116 pSetBrush = new SvxBrushItem(aEmptyStr, aEmptyStr, GPOS_AREA, RES_BACKGROUND); 2117 } 2118 pSetBrush->PutValue( pData->aVal, MID_GRAPHIC_URL ); 2119 } 2120 break; 2121 case 20: //UNO_NAME_GRAPHIC_BITMAP, 2122 { 2123 uno::Reference< awt::XBitmap >* pBitmap = (uno::Reference< awt::XBitmap > *)pData->aVal.getValue(); 2124 if(pBitmap) 2125 { 2126 if(!pSetBrush) 2127 { 2128 const SvxBrushItem* pOrigBrush = aFmt.GetBrush(); 2129 if(pOrigBrush) 2130 { 2131 pSetBrush = new SvxBrushItem(*pOrigBrush); 2132 } 2133 else 2134 pSetBrush = new SvxBrushItem(aEmptyStr, aEmptyStr, GPOS_AREA, RES_BACKGROUND); 2135 } 2136 2137 BitmapEx aBmp = VCLUnoHelper::GetBitmap( *pBitmap ); 2138 Graphic aNewGr(aBmp); 2139 pSetBrush->SetGraphic( aNewGr ); 2140 } 2141 else 2142 bWrongArg = sal_True; 2143 } 2144 break; 2145 case 21: //UNO_NAME_GRAPHIC_SIZE, 2146 { 2147 if(!pSetSize) 2148 pSetSize = new Size; 2149 if(pData->aVal.getValueType() == ::getCppuType((awt::Size*)0)) 2150 { 2151 awt::Size* pSize = (awt::Size*)pData->aVal.getValue(); 2152 pSize->Width = MM100_TO_TWIP(pSize->Width); 2153 pSize->Height = MM100_TO_TWIP(pSize->Height); 2154 pSetSize->Width() = pSize->Width; 2155 pSetSize->Height() = pSize->Height; 2156 } 2157 else 2158 bWrongArg = sal_True; 2159 } 2160 break; 2161 case 22: //VertOrient 2162 { 2163 if(!pSetVOrient) 2164 { 2165 if(aFmt.GetGraphicOrientation()) 2166 pSetVOrient = (SwFmtVertOrient*)aFmt.GetGraphicOrientation()->Clone(); 2167 else 2168 pSetVOrient = new SwFmtVertOrient; 2169 } 2170 ((SfxPoolItem*)pSetVOrient)->PutValue(pData->aVal, MID_VERTORIENT_ORIENT); 2171 } 2172 break; 2173 case 23: //"HeadingStyleName" 2174 { 2175 OUString uTmp; 2176 pData->aVal >>= uTmp; 2177 String sStyleName; 2178 SwStyleNameMapper::FillUIName( uTmp, sStyleName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL, sal_True ); 2179 const SwTxtFmtColls* pColls = pDocShell->GetDoc()->GetTxtFmtColls(); 2180 const sal_uInt16 nCount = pColls->Count(); 2181 for ( sal_uInt16 k = 0; k < nCount; ++k ) 2182 { 2183 SwTxtFmtColl &rTxtColl = *( ( *pColls )[k] ); 2184 if ( rTxtColl.IsDefault() ) 2185 continue; 2186 if ( rTxtColl.IsAssignedToListLevelOfOutlineStyle() 2187 && rTxtColl.GetAssignedOutlineStyleLevel() == nIndex 2188 && rTxtColl.GetName() != sStyleName ) 2189 { 2190 rTxtColl.DeleteAssignmentToListLevelOfOutlineStyle(); 2191 } 2192 else if ( rTxtColl.GetName() == sStyleName ) 2193 { 2194 rTxtColl.AssignToListLevelOfOutlineStyle( nIndex ); 2195 } 2196 } 2197 } 2198 break; 2199 case 24: // BulletRelSize - unsupported - only available in Impress 2200 break; 2201 } 2202 } 2203 if(!bExcept && !bWrongArg && (pSetBrush || pSetSize || pSetVOrient)) 2204 { 2205 if(!pSetBrush && aFmt.GetBrush()) 2206 pSetBrush = new SvxBrushItem(*aFmt.GetBrush()); 2207 2208 if(pSetBrush) 2209 { 2210 if(!pSetVOrient && aFmt.GetGraphicOrientation()) 2211 pSetVOrient = new SwFmtVertOrient(*aFmt.GetGraphicOrientation()); 2212 2213 if(!pSetSize) 2214 { 2215 pSetSize = new Size(aFmt.GetGraphicSize()); 2216 if(!pSetSize->Width() || !pSetSize->Height()) 2217 { 2218 const Graphic* pGraphic = pSetBrush->GetGraphic(); 2219 if(pGraphic) 2220 *pSetSize = ::GetGraphicSizeTwip(*pGraphic, 0); 2221 } 2222 } 2223 sal_Int16 eOrient = pSetVOrient ? 2224 (sal_Int16)pSetVOrient->GetVertOrient() : text::VertOrientation::NONE; 2225 aFmt.SetGraphicBrush( pSetBrush, pSetSize, text::VertOrientation::NONE == eOrient ? 0 : &eOrient ); 2226 } 2227 } 2228 if((!bCharStyleNameSet || !sNewCharStyleNames[(sal_uInt16)nIndex].Len()) && 2229 aFmt.GetNumberingType() == NumberingType::BITMAP && !aFmt.GetCharFmt() 2230 && SwXNumberingRules::GetInvalidStyle() != sNewCharStyleNames[(sal_uInt16)nIndex]) 2231 { 2232 SwStyleNameMapper::FillProgName ( RES_POOLCHR_BUL_LEVEL, sNewCharStyleNames[(sal_uInt16)nIndex] ); 2233 } 2234 delete pSetBrush; 2235 delete pSetSize; 2236 delete pSetVOrient; 2237 } 2238 aPropertyValues.DeleteAndDestroy(0, aPropertyValues.Count()); 2239 2240 if(bWrongArg) 2241 throw lang::IllegalArgumentException(); 2242 else if(bExcept) 2243 throw uno::RuntimeException(); 2244 rNumRule.Set( (sal_uInt16)nIndex, aFmt ); 2245 2246 } 2247 /*-- 19.07.00 07:49:17--------------------------------------------------- 2248 2249 -----------------------------------------------------------------------*/ 2250 uno::Reference< XPropertySetInfo > SwXNumberingRules::getPropertySetInfo() 2251 { 2252 static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropertySet->getPropertySetInfo(); 2253 return aRef; 2254 } 2255 /*-- 19.07.00 07:49:17--------------------------------------------------- 2256 2257 -----------------------------------------------------------------------*/ 2258 void SwXNumberingRules::setPropertyValue( const OUString& rPropertyName, const Any& rValue ) 2259 { 2260 Any aRet; 2261 SwNumRule* pDocRule = 0; 2262 SwNumRule* pCreatedRule = 0; 2263 if(!pNumRule) 2264 { 2265 if(!pNumRule && pDocShell) 2266 { 2267 pDocRule = new SwNumRule(*pDocShell->GetDoc()->GetOutlineNumRule()); 2268 } 2269 else if(pDoc && sCreatedNumRuleName.Len()) 2270 { 2271 pCreatedRule = pDoc->FindNumRulePtr( sCreatedNumRuleName); 2272 } 2273 2274 } 2275 if(!pNumRule && !pDocRule && !pCreatedRule) 2276 throw RuntimeException(); 2277 2278 2279 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_AUTOMATIC))) 2280 { 2281 sal_Bool bVal = *(sal_Bool*)rValue.getValue(); 2282 if(!pCreatedRule) 2283 pDocRule ? pDocRule->SetAutoRule(bVal) : pNumRule->SetAutoRule(bVal); 2284 } 2285 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_CONTINUOUS_NUMBERING))) 2286 { 2287 sal_Bool bVal = *(sal_Bool*)rValue.getValue(); 2288 pDocRule ? pDocRule->SetContinusNum(bVal) : 2289 pCreatedRule ? pCreatedRule->SetContinusNum(bVal) : pNumRule->SetContinusNum(bVal); 2290 } 2291 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NAME))) 2292 { 2293 delete pDocRule; 2294 throw IllegalArgumentException(); 2295 } 2296 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_ABSOLUTE_MARGINS))) 2297 { 2298 sal_Bool bVal = *(sal_Bool*)rValue.getValue(); 2299 pDocRule ? pDocRule->SetAbsSpaces(bVal) : 2300 pCreatedRule ? pCreatedRule->SetAbsSpaces(bVal) : pNumRule->SetAbsSpaces(bVal); 2301 } 2302 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NUMBERING_IS_OUTLINE))) 2303 { 2304 sal_Bool bVal = *(sal_Bool*)rValue.getValue(); 2305 SwNumRuleType eNumRuleType = bVal ? OUTLINE_RULE : NUM_RULE; 2306 pDocRule ? pDocRule->SetRuleType(eNumRuleType) : 2307 pCreatedRule ? pCreatedRule->SetRuleType(eNumRuleType) : pNumRule->SetRuleType(eNumRuleType); 2308 } 2309 // --> OD 2008-04-23 #refactorlists# 2310 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DEFAULT_LIST_ID))) 2311 { 2312 delete pDocRule; 2313 throw IllegalArgumentException(); 2314 } 2315 // <-- 2316 else 2317 throw UnknownPropertyException(); 2318 2319 if(pDocRule) 2320 { 2321 pDocShell->GetDoc()->SetOutlineNumRule(*pDocRule); 2322 delete pDocRule; 2323 } 2324 else if(pCreatedRule) 2325 { 2326 pCreatedRule->Validate(); 2327 } 2328 } 2329 /*-- 19.07.00 07:49:18--------------------------------------------------- 2330 2331 -----------------------------------------------------------------------*/ 2332 Any SwXNumberingRules::getPropertyValue( const OUString& rPropertyName ) 2333 { 2334 Any aRet; 2335 const SwNumRule* pRule = pNumRule; 2336 if(!pRule && pDocShell) 2337 pRule = pDocShell->GetDoc()->GetOutlineNumRule(); 2338 else if(pDoc && sCreatedNumRuleName.Len()) 2339 pRule = pDoc->FindNumRulePtr( sCreatedNumRuleName ); 2340 if(!pRule) 2341 throw RuntimeException(); 2342 2343 if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_AUTOMATIC))) 2344 { 2345 sal_Bool bVal = pRule->IsAutoRule(); 2346 aRet.setValue(&bVal, ::getBooleanCppuType()); 2347 } 2348 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_CONTINUOUS_NUMBERING))) 2349 { 2350 sal_Bool bVal = pRule->IsContinusNum(); 2351 aRet.setValue(&bVal, ::getBooleanCppuType()); 2352 } 2353 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NAME))) 2354 aRet <<= OUString(pRule->GetName()); 2355 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_IS_ABSOLUTE_MARGINS))) 2356 { 2357 sal_Bool bVal = pRule->IsAbsSpaces(); 2358 aRet.setValue(&bVal, ::getBooleanCppuType()); 2359 } 2360 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_NUMBERING_IS_OUTLINE))) 2361 { 2362 sal_Bool bVal = pRule->IsOutlineRule(); 2363 aRet.setValue(&bVal, ::getBooleanCppuType()); 2364 } 2365 // --> OD 2008-04-23 #refactorlists# 2366 else if(rPropertyName.equalsAsciiL( SW_PROP_NAME(UNO_NAME_DEFAULT_LIST_ID))) 2367 { 2368 ASSERT( pRule->GetDefaultListId().Len() != 0, 2369 "<SwXNumberingRules::getPropertyValue(..)> - no default list id found. Serious defect -> please inform OD." ); 2370 aRet <<= OUString(pRule->GetDefaultListId()); 2371 } 2372 // <-- 2373 else 2374 throw UnknownPropertyException(); 2375 return aRet; 2376 } 2377 /*-- 19.07.00 07:49:18--------------------------------------------------- 2378 2379 -----------------------------------------------------------------------*/ 2380 void SwXNumberingRules::addPropertyChangeListener( 2381 const OUString& /*rPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) 2382 { 2383 } 2384 /*-- 19.07.00 07:49:18--------------------------------------------------- 2385 2386 -----------------------------------------------------------------------*/ 2387 void SwXNumberingRules::removePropertyChangeListener( 2388 const OUString& /*rPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) 2389 { 2390 } 2391 /*-- 19.07.00 07:49:18--------------------------------------------------- 2392 2393 -----------------------------------------------------------------------*/ 2394 void SwXNumberingRules::addVetoableChangeListener( 2395 const OUString& /*rPropertyName*/, const uno::Reference< XVetoableChangeListener >& /*xListener*/ ) 2396 { 2397 } 2398 /*-- 19.07.00 07:49:18--------------------------------------------------- 2399 2400 -----------------------------------------------------------------------*/ 2401 void SwXNumberingRules::removeVetoableChangeListener( 2402 const OUString& /*rPropertyName*/, const uno::Reference< XVetoableChangeListener >& /*xListener*/ ) 2403 { 2404 } 2405 /* -----------------------------17.10.00 14:23-------------------------------- 2406 2407 ---------------------------------------------------------------------------*/ 2408 OUString SwXNumberingRules::getName() 2409 { 2410 String aString; 2411 if(pNumRule) 2412 { 2413 SwStyleNameMapper::FillProgName(pNumRule->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, sal_True ); 2414 return OUString ( aString ); 2415 } 2416 // --> OD 2005-10-25 #126347# - consider chapter numbering <SwXNumberingRules> 2417 else if ( pDocShell ) 2418 { 2419 SwStyleNameMapper::FillProgName( pDocShell->GetDoc()->GetOutlineNumRule()->GetName(), 2420 aString, nsSwGetPoolIdFromName::GET_POOLID_NUMRULE, sal_True ); 2421 return OUString ( aString ); 2422 } 2423 // <-- 2424 else 2425 return sCreatedNumRuleName; 2426 } 2427 /* -----------------------------17.10.00 14:23-------------------------------- 2428 2429 ---------------------------------------------------------------------------*/ 2430 void SwXNumberingRules::setName(const OUString& /*rName*/) 2431 { 2432 RuntimeException aExcept; 2433 aExcept.Message = C2U("readonly"); 2434 throw aExcept; 2435 } 2436 /*-- 14.12.98 14:58:00--------------------------------------------------- 2437 2438 -----------------------------------------------------------------------*/ 2439 void SwXNumberingRules::Modify( const SfxPoolItem* pOld, const SfxPoolItem *pNew) 2440 { 2441 ClientModify(this, pOld, pNew); 2442 if(!GetRegisteredIn()) 2443 { 2444 if(bOwnNumRuleCreated) 2445 delete pNumRule; 2446 pNumRule = 0; 2447 pDoc = 0; 2448 } 2449 } 2450 /* -----------------------------06.04.00 11:47-------------------------------- 2451 2452 ---------------------------------------------------------------------------*/ 2453 OUString SwXChapterNumbering::getImplementationName(void) 2454 { 2455 return C2U("SwXChapterNumbering"); 2456 } 2457 /* -----------------------------06.04.00 11:47-------------------------------- 2458 2459 ---------------------------------------------------------------------------*/ 2460 sal_Bool SwXChapterNumbering::supportsService(const OUString& rServiceName) 2461 { 2462 String sServiceName(rServiceName); 2463 return sServiceName.EqualsAscii("com.sun.star.text.ChapterNumbering") || 2464 sServiceName.EqualsAscii("com.sun.star.text.NumberingRules"); 2465 } 2466 /* -----------------------------06.04.00 11:47-------------------------------- 2467 2468 ---------------------------------------------------------------------------*/ 2469 Sequence< OUString > SwXChapterNumbering::getSupportedServiceNames(void) 2470 { 2471 Sequence< OUString > aRet(2); 2472 OUString* pArray = aRet.getArray(); 2473 pArray[0] = C2U("com.sun.star.text.ChapterNumbering"); 2474 pArray[1] = C2U("com.sun.star.text.NumberingRules"); 2475 return aRet; 2476 } 2477 /* -----------------22.02.99 16:33------------------- 2478 * 2479 * --------------------------------------------------*/ 2480 SwXChapterNumbering::SwXChapterNumbering(SwDocShell& rDocSh) : 2481 SwXNumberingRules(rDocSh) 2482 { 2483 } 2484 /* -----------------22.02.99 16:33------------------- 2485 * 2486 * --------------------------------------------------*/ 2487 SwXChapterNumbering::~SwXChapterNumbering() 2488 { 2489 } 2490 2491 /****************************************************************** 2492 * SwXTextColumns 2493 ******************************************************************/ 2494 /* -----------------------------06.04.00 11:47-------------------------------- 2495 2496 ---------------------------------------------------------------------------*/ 2497 OUString SwXTextColumns::getImplementationName(void) 2498 { 2499 return C2U("SwXTextColumns"); 2500 } 2501 /* -----------------------------06.04.00 11:47-------------------------------- 2502 2503 ---------------------------------------------------------------------------*/ 2504 sal_Bool SwXTextColumns::supportsService(const OUString& rServiceName) 2505 { 2506 return C2U("com.sun.star.text.TextColumns") == rServiceName; 2507 } 2508 /* -----------------------------06.04.00 11:47-------------------------------- 2509 2510 ---------------------------------------------------------------------------*/ 2511 Sequence< OUString > SwXTextColumns::getSupportedServiceNames(void) 2512 { 2513 Sequence< OUString > aRet(1); 2514 OUString* pArray = aRet.getArray(); 2515 pArray[0] = C2U("com.sun.star.text.TextColumns"); 2516 return aRet; 2517 } 2518 /* -----------------------------24.10.00 16:45-------------------------------- 2519 2520 ---------------------------------------------------------------------------*/ 2521 SwXTextColumns::SwXTextColumns(sal_uInt16 nColCount) : 2522 nReference(0), 2523 bIsAutomaticWidth(sal_True), 2524 nAutoDistance(0), 2525 m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_COLUMS)), 2526 nSepLineWidth(0), 2527 nSepLineColor(0), //black 2528 nSepLineHeightRelative(100),//full height 2529 nSepLineVertAlign(style::VerticalAlignment_MIDDLE), 2530 bSepLineIsOn(sal_False) 2531 { 2532 if(nColCount) 2533 setColumnCount(nColCount); 2534 } 2535 /*-- 16.12.98 14:06:53--------------------------------------------------- 2536 2537 -----------------------------------------------------------------------*/ 2538 SwXTextColumns::SwXTextColumns(const SwFmtCol& rFmtCol) : 2539 nReference(0), 2540 aTextColumns(rFmtCol.GetNumCols()), 2541 bIsAutomaticWidth(rFmtCol.IsOrtho()), 2542 m_pPropSet(aSwMapProvider.GetPropertySet(PROPERTY_MAP_TEXT_COLUMS)) 2543 { 2544 sal_uInt16 nItemGutterWidth = rFmtCol.GetGutterWidth(); 2545 nAutoDistance = bIsAutomaticWidth ? 2546 USHRT_MAX == nItemGutterWidth ? DEF_GUTTER_WIDTH : (sal_Int32)nItemGutterWidth 2547 : 0; 2548 nAutoDistance = TWIP_TO_MM100(nAutoDistance); 2549 2550 TextColumn* pColumns = aTextColumns.getArray(); 2551 const SwColumns& rCols = rFmtCol.GetColumns(); 2552 for(sal_uInt16 i = 0; i < aTextColumns.getLength(); i++) 2553 { 2554 SwColumn* pCol = rCols[i]; 2555 2556 pColumns[i].Width = pCol->GetWishWidth(); 2557 nReference += pColumns[i].Width; 2558 pColumns[i].LeftMargin = TWIP_TO_MM100_UNSIGNED(pCol->GetLeft ()); 2559 pColumns[i].RightMargin = TWIP_TO_MM100_UNSIGNED(pCol->GetRight()); 2560 } 2561 if(!aTextColumns.getLength()) 2562 nReference = USHRT_MAX; 2563 2564 nSepLineWidth = rFmtCol.GetLineWidth(); 2565 nSepLineColor = rFmtCol.GetLineColor().GetColor(); 2566 nSepLineHeightRelative = rFmtCol.GetLineHeight(); 2567 bSepLineIsOn = rFmtCol.GetLineAdj() != COLADJ_NONE; 2568 switch(rFmtCol.GetLineAdj()) 2569 { 2570 case COLADJ_TOP: nSepLineVertAlign = style::VerticalAlignment_TOP; break; 2571 case COLADJ_BOTTOM: nSepLineVertAlign = style::VerticalAlignment_BOTTOM; break; 2572 case COLADJ_CENTER: 2573 case COLADJ_NONE: nSepLineVertAlign = style::VerticalAlignment_MIDDLE; 2574 } 2575 } 2576 /*-- 16.12.98 14:06:54--------------------------------------------------- 2577 2578 -----------------------------------------------------------------------*/ 2579 SwXTextColumns::~SwXTextColumns() 2580 { 2581 2582 } 2583 /*-- 16.12.98 14:06:54--------------------------------------------------- 2584 2585 -----------------------------------------------------------------------*/ 2586 sal_Int32 SwXTextColumns::getReferenceValue(void) 2587 { 2588 vos::OGuard aGuard(Application::GetSolarMutex()); 2589 return nReference; 2590 } 2591 /*-- 16.12.98 14:06:55--------------------------------------------------- 2592 2593 -----------------------------------------------------------------------*/ 2594 sal_Int16 SwXTextColumns::getColumnCount(void) 2595 { 2596 vos::OGuard aGuard(Application::GetSolarMutex()); 2597 return static_cast< sal_Int16>( aTextColumns.getLength() ); 2598 } 2599 /*-- 16.12.98 14:06:55--------------------------------------------------- 2600 2601 -----------------------------------------------------------------------*/ 2602 void SwXTextColumns::setColumnCount(sal_Int16 nColumns) 2603 { 2604 vos::OGuard aGuard(Application::GetSolarMutex()); 2605 if(nColumns <= 0) 2606 throw uno::RuntimeException(); 2607 bIsAutomaticWidth = sal_True; 2608 aTextColumns.realloc(nColumns); 2609 TextColumn* pCols = aTextColumns.getArray(); 2610 nReference = USHRT_MAX; 2611 sal_Int32 nWidth = nReference / nColumns; 2612 sal_Int32 nDiff = nReference - nWidth * nColumns; 2613 sal_Int32 nDist = nAutoDistance / 2; 2614 for(sal_Int16 i = 0; i < nColumns; i++) 2615 { 2616 pCols[i].Width = nWidth; 2617 pCols[i].LeftMargin = i == 0 ? 0 : nDist; 2618 pCols[i].RightMargin = i == nColumns - 1 ? 0 : nDist; 2619 } 2620 pCols[nColumns - 1].Width += nDiff; 2621 } 2622 /*-- 16.12.98 14:06:55--------------------------------------------------- 2623 2624 -----------------------------------------------------------------------*/ 2625 uno::Sequence< TextColumn > SwXTextColumns::getColumns(void) 2626 { 2627 vos::OGuard aGuard(Application::GetSolarMutex()); 2628 return aTextColumns; 2629 } 2630 /*-- 16.12.98 14:06:56--------------------------------------------------- 2631 2632 -----------------------------------------------------------------------*/ 2633 void SwXTextColumns::setColumns(const uno::Sequence< TextColumn >& rColumns) 2634 { 2635 vos::OGuard aGuard(Application::GetSolarMutex()); 2636 sal_Int32 nReferenceTemp = 0; 2637 const TextColumn* prCols = rColumns.getConstArray(); 2638 for(long i = 0; i < rColumns.getLength(); i++) 2639 { 2640 nReferenceTemp += prCols[i].Width; 2641 } 2642 bIsAutomaticWidth = sal_False; 2643 nReference = !nReferenceTemp ? USHRT_MAX : nReferenceTemp; 2644 aTextColumns = rColumns; 2645 } 2646 /*-- 25.10.00 10:15:39--------------------------------------------------- 2647 2648 -----------------------------------------------------------------------*/ 2649 uno::Reference< XPropertySetInfo > SwXTextColumns::getPropertySetInfo( ) 2650 { 2651 static uno::Reference< beans::XPropertySetInfo > aRef = m_pPropSet->getPropertySetInfo(); 2652 return aRef; 2653 } 2654 /*-- 25.10.00 10:15:39--------------------------------------------------- 2655 2656 -----------------------------------------------------------------------*/ 2657 void SwXTextColumns::setPropertyValue( const OUString& rPropertyName, const Any& aValue ) 2658 { 2659 const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName ); 2660 if (!pEntry) 2661 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 2662 if ( pEntry->nFlags & PropertyAttribute::READONLY) 2663 throw PropertyVetoException( OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Property is read-only: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 2664 2665 switch(pEntry->nWID) 2666 { 2667 case WID_TXTCOL_LINE_WIDTH: 2668 { 2669 sal_Int32 nTmp = 0; 2670 aValue >>= nTmp; 2671 if(nTmp < 0) 2672 throw IllegalArgumentException(); 2673 nSepLineWidth = MM100_TO_TWIP(nTmp); 2674 } 2675 break; 2676 case WID_TXTCOL_LINE_COLOR: 2677 aValue >>= nSepLineColor; 2678 break; 2679 case WID_TXTCOL_LINE_REL_HGT: 2680 { 2681 sal_Int8 nTmp = 0; 2682 aValue >>= nTmp; 2683 if(nTmp < 0) 2684 throw IllegalArgumentException(); 2685 nSepLineHeightRelative = nTmp; 2686 } 2687 break; 2688 case WID_TXTCOL_LINE_ALIGN: 2689 { 2690 style::VerticalAlignment eAlign; 2691 if(!(aValue >>= eAlign) ) 2692 { 2693 sal_Int8 nTmp = 0; 2694 if (! ( aValue >>= nTmp ) ) 2695 throw IllegalArgumentException(); 2696 else 2697 nSepLineVertAlign = nTmp; 2698 } 2699 else 2700 nSepLineVertAlign = static_cast< sal_Int8 >(eAlign); 2701 } 2702 break; 2703 case WID_TXTCOL_LINE_IS_ON: 2704 bSepLineIsOn = *(sal_Bool*)aValue.getValue(); 2705 break; 2706 case WID_TXTCOL_AUTO_DISTANCE: 2707 { 2708 sal_Int32 nTmp = 0; 2709 aValue >>= nTmp; 2710 if(nTmp < 0 || nTmp >= nReference) 2711 throw IllegalArgumentException(); 2712 nAutoDistance = nTmp; 2713 sal_Int32 nColumns = aTextColumns.getLength(); 2714 TextColumn* pCols = aTextColumns.getArray(); 2715 sal_Int32 nDist = nAutoDistance / 2; 2716 for(sal_Int32 i = 0; i < nColumns; i++) 2717 { 2718 pCols[i].LeftMargin = i == 0 ? 0 : nDist; 2719 pCols[i].RightMargin = i == nColumns - 1 ? 0 : nDist; 2720 } 2721 } 2722 break; 2723 } 2724 } 2725 /*-- 25.10.00 10:15:40--------------------------------------------------- 2726 2727 -----------------------------------------------------------------------*/ 2728 Any SwXTextColumns::getPropertyValue( const OUString& rPropertyName ) 2729 { 2730 const SfxItemPropertySimpleEntry* pEntry = m_pPropSet->getPropertyMap()->getByName( rPropertyName ); 2731 if (!pEntry) 2732 throw UnknownPropertyException(OUString ( RTL_CONSTASCII_USTRINGPARAM ( "Unknown property: " ) ) + rPropertyName, static_cast < cppu::OWeakObject * > ( this ) ); 2733 2734 Any aRet; 2735 switch(pEntry->nWID) 2736 { 2737 case WID_TXTCOL_LINE_WIDTH: 2738 aRet <<= static_cast < sal_Int32 >(TWIP_TO_MM100(nSepLineWidth)); 2739 break; 2740 case WID_TXTCOL_LINE_COLOR: 2741 aRet <<= nSepLineColor; 2742 break; 2743 case WID_TXTCOL_LINE_REL_HGT: 2744 aRet <<= nSepLineHeightRelative; 2745 break; 2746 case WID_TXTCOL_LINE_ALIGN: 2747 aRet <<= (style::VerticalAlignment)nSepLineVertAlign; 2748 break; 2749 case WID_TXTCOL_LINE_IS_ON: 2750 aRet.setValue(&bSepLineIsOn, ::getBooleanCppuType()); 2751 break; 2752 case WID_TXTCOL_IS_AUTOMATIC : 2753 aRet.setValue(&bIsAutomaticWidth, ::getBooleanCppuType()); 2754 break; 2755 case WID_TXTCOL_AUTO_DISTANCE: 2756 aRet <<= nAutoDistance; 2757 break; 2758 } 2759 return aRet; 2760 } 2761 /*-- 25.10.00 10:15:40--------------------------------------------------- 2762 2763 -----------------------------------------------------------------------*/ 2764 void SwXTextColumns::addPropertyChangeListener( 2765 const OUString& /*rPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) 2766 { 2767 } 2768 /*-- 25.10.00 10:15:40--------------------------------------------------- 2769 2770 -----------------------------------------------------------------------*/ 2771 void SwXTextColumns::removePropertyChangeListener( 2772 const OUString& /*rPropertyName*/, const uno::Reference< XPropertyChangeListener >& /*xListener*/ ) 2773 { 2774 } 2775 /*-- 25.10.00 10:15:40--------------------------------------------------- 2776 2777 -----------------------------------------------------------------------*/ 2778 void SwXTextColumns::addVetoableChangeListener( 2779 const OUString& /*rPropertyName*/, const uno::Reference< XVetoableChangeListener >& /*xListener*/ ) 2780 { 2781 } 2782 /*-- 25.10.00 10:15:40--------------------------------------------------- 2783 2784 -----------------------------------------------------------------------*/ 2785 void SwXTextColumns::removeVetoableChangeListener( 2786 const OUString& /*rPropertyName*/, const uno::Reference< XVetoableChangeListener >& /*xListener*/ ) 2787 { 2788 } 2789 /* -----------------------------25.10.00 11:04-------------------------------- 2790 2791 ---------------------------------------------------------------------------*/ 2792 const uno::Sequence< sal_Int8 > & SwXTextColumns::getUnoTunnelId() 2793 { 2794 static uno::Sequence< sal_Int8 > aSeq = ::CreateUnoTunnelId(); 2795 return aSeq; 2796 } 2797 /* -----------------------------10.03.00 18:04-------------------------------- 2798 2799 ---------------------------------------------------------------------------*/ 2800 sal_Int64 SAL_CALL SwXTextColumns::getSomething( const uno::Sequence< sal_Int8 >& rId ) 2801 { 2802 if( rId.getLength() == 16 2803 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), 2804 rId.getConstArray(), 16 ) ) 2805 { 2806 return sal::static_int_cast< sal_Int64 >( reinterpret_cast< sal_IntPtr >(this) ); 2807 } 2808 return 0; 2809 } 2810