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_xmloff.hxx" 26 27 #include "txtexppr.hxx" 28 29 #include <com/sun/star/table/BorderLine.hpp> 30 #include <com/sun/star/text/SizeType.hpp> 31 #include <com/sun/star/text/WrapTextMode.hpp> 32 #include <com/sun/star/text/TextContentAnchorType.hpp> 33 #include <com/sun/star/awt/FontFamily.hpp> 34 #include <com/sun/star/awt/FontPitch.hpp> 35 #include <com/sun/star/awt/FontUnderline.hpp> 36 #include <com/sun/star/text/XChapterNumberingSupplier.hpp> 37 38 #include <tools/debug.hxx> 39 40 #include <xmloff/txtprmap.hxx> 41 #include <xmloff/xmlexp.hxx> 42 #include "XMLSectionFootnoteConfigExport.hxx" 43 44 using ::rtl::OUString; 45 using ::rtl::OUStringBuffer; 46 47 using namespace ::com::sun::star; 48 using namespace ::com::sun::star::uno; 49 using namespace ::com::sun::star::style; 50 using namespace ::com::sun::star::beans; 51 using namespace ::com::sun::star::text; 52 using namespace ::com::sun::star::awt; 53 54 void XMLTextExportPropertySetMapper::handleElementItem( 55 SvXMLExport& rExp, 56 const XMLPropertyState& rProperty, 57 sal_uInt16 nFlags, 58 const ::std::vector< XMLPropertyState > *pProperties, 59 sal_uInt32 nIdx ) const 60 { 61 XMLTextExportPropertySetMapper *pThis = 62 ((XMLTextExportPropertySetMapper *)this); 63 64 switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) ) 65 { 66 case CTF_DROPCAPFORMAT: 67 pThis->maDropCapExport.exportXML( rProperty.maValue, bDropWholeWord, 68 sDropCharStyle ); 69 pThis->bDropWholeWord = sal_False; 70 pThis->sDropCharStyle = OUString(); 71 break; 72 73 case CTF_TABSTOP: 74 pThis->maTabStopExport.Export( rProperty.maValue ); 75 break; 76 77 case CTF_TEXTCOLUMNS: 78 pThis->maTextColumnsExport.exportXML( rProperty.maValue ); 79 break; 80 81 case CTF_BACKGROUND_URL: 82 { 83 DBG_ASSERT( pProperties && nIdx >= 3, 84 "property vector missing" ); 85 const Any *pPos = 0, *pFilter = 0, *pTrans = 0; 86 if( pProperties && nIdx >= 3 ) 87 { 88 const XMLPropertyState& rTrans = (*pProperties)[nIdx-3]; 89 // #99657# transparency may be there, but doesn't have to be. 90 // If it's there, it must be in the right position. 91 if( CTF_BACKGROUND_TRANSPARENCY == getPropertySetMapper() 92 ->GetEntryContextId( rTrans.mnIndex ) ) 93 pTrans = &rTrans.maValue; 94 95 const XMLPropertyState& rPos = (*pProperties)[nIdx-2]; 96 DBG_ASSERT( CTF_BACKGROUND_POS == getPropertySetMapper() 97 ->GetEntryContextId( rPos.mnIndex ), 98 "invalid property map: pos expected" ); 99 if( CTF_BACKGROUND_POS == getPropertySetMapper() 100 ->GetEntryContextId( rPos.mnIndex ) ) 101 pPos = &rPos.maValue; 102 103 const XMLPropertyState& rFilter = (*pProperties)[nIdx-1]; 104 DBG_ASSERT( CTF_BACKGROUND_FILTER == getPropertySetMapper() 105 ->GetEntryContextId( rFilter.mnIndex ), 106 "invalid property map: filter expected" ); 107 if( CTF_BACKGROUND_FILTER == getPropertySetMapper() 108 ->GetEntryContextId( rFilter.mnIndex ) ) 109 pFilter = &rFilter.maValue; 110 } 111 sal_uInt32 nPropIndex = rProperty.mnIndex; 112 pThis->maBackgroundImageExport.exportXML( 113 rProperty.maValue, pPos, pFilter, pTrans, 114 getPropertySetMapper()->GetEntryNameSpace( nPropIndex ), 115 getPropertySetMapper()->GetEntryXMLName( nPropIndex ) ); 116 } 117 break; 118 119 case CTF_SECTION_FOOTNOTE_END: 120 XMLSectionFootnoteConfigExport::exportXML(rExp, sal_False, 121 pProperties, nIdx, 122 getPropertySetMapper()); 123 break; 124 125 case CTF_SECTION_ENDNOTE_END: 126 XMLSectionFootnoteConfigExport::exportXML(rExp, sal_True, 127 pProperties, nIdx, 128 getPropertySetMapper()); 129 break; 130 131 default: 132 SvXMLExportPropertyMapper::handleElementItem( rExp, rProperty, nFlags, pProperties, nIdx ); 133 break; 134 } 135 } 136 137 void XMLTextExportPropertySetMapper::handleSpecialItem( 138 SvXMLAttributeList& rAttrList, 139 const XMLPropertyState& rProperty, 140 const SvXMLUnitConverter& rUnitConverter, 141 const SvXMLNamespaceMap& rNamespaceMap, 142 const ::std::vector< XMLPropertyState > *pProperties, 143 sal_uInt32 nIdx ) const 144 { 145 XMLTextExportPropertySetMapper *pThis = 146 ((XMLTextExportPropertySetMapper *)this); 147 148 switch( getPropertySetMapper()->GetEntryContextId( rProperty.mnIndex ) ) 149 { 150 case CTF_DROPCAPWHOLEWORD: 151 DBG_ASSERT( !bDropWholeWord, "drop whole word is set already!" ); 152 pThis->bDropWholeWord = *(sal_Bool *)rProperty.maValue.getValue(); 153 break; 154 case CTF_DROPCAPCHARSTYLE: 155 DBG_ASSERT( !sDropCharStyle.getLength(), 156 "drop char style is set already!" ); 157 rProperty.maValue >>= pThis->sDropCharStyle; 158 break; 159 case CTF_NUMBERINGSTYLENAME: 160 case CTF_PAGEDESCNAME: 161 case CTF_OLDTEXTBACKGROUND: 162 case CTF_BACKGROUND_POS: 163 case CTF_BACKGROUND_FILTER: 164 case CTF_BACKGROUND_TRANSPARENCY: 165 case CTF_SECTION_FOOTNOTE_NUM_OWN: 166 case CTF_SECTION_FOOTNOTE_NUM_RESTART: 167 case CTF_SECTION_FOOTNOTE_NUM_RESTART_AT: 168 case CTF_SECTION_FOOTNOTE_NUM_TYPE: 169 case CTF_SECTION_FOOTNOTE_NUM_PREFIX: 170 case CTF_SECTION_FOOTNOTE_NUM_SUFFIX: 171 case CTF_SECTION_ENDNOTE_NUM_OWN: 172 case CTF_SECTION_ENDNOTE_NUM_RESTART: 173 case CTF_SECTION_ENDNOTE_NUM_RESTART_AT: 174 case CTF_SECTION_ENDNOTE_NUM_TYPE: 175 case CTF_SECTION_ENDNOTE_NUM_PREFIX: 176 case CTF_SECTION_ENDNOTE_NUM_SUFFIX: 177 case CTF_DEFAULT_OUTLINE_LEVEL: 178 case CTF_OLD_FLOW_WITH_TEXT: 179 // There's nothing to do here! 180 break; 181 default: 182 SvXMLExportPropertyMapper::handleSpecialItem(rAttrList, rProperty, rUnitConverter, rNamespaceMap, pProperties, nIdx ); 183 break; 184 } 185 } 186 187 XMLTextExportPropertySetMapper::XMLTextExportPropertySetMapper( 188 const UniReference< XMLPropertySetMapper >& rMapper, 189 SvXMLExport& rExp ) : 190 SvXMLExportPropertyMapper( rMapper ), 191 rExport( rExp ), 192 bDropWholeWord( sal_False ), 193 maDropCapExport( rExp ), 194 maTabStopExport( rExp ), 195 maTextColumnsExport( rExp ), 196 maBackgroundImageExport( rExp ) 197 { 198 } 199 200 XMLTextExportPropertySetMapper::~XMLTextExportPropertySetMapper() 201 { 202 } 203 204 void XMLTextExportPropertySetMapper::ContextFontFilter( 205 XMLPropertyState *pFontNameState, 206 XMLPropertyState *pFontFamilyNameState, 207 XMLPropertyState *pFontStyleNameState, 208 XMLPropertyState *pFontFamilyState, 209 XMLPropertyState *pFontPitchState, 210 XMLPropertyState *pFontCharsetState ) const 211 { 212 OUString sFamilyName; 213 OUString sStyleName; 214 sal_Int16 nFamily = FontFamily::DONTKNOW; 215 sal_Int16 nPitch = FontPitch::DONTKNOW; 216 rtl_TextEncoding eEnc = RTL_TEXTENCODING_DONTKNOW; 217 218 OUString sTmp; 219 if( pFontFamilyNameState && (pFontFamilyNameState->maValue >>= sTmp ) ) 220 sFamilyName = sTmp; 221 if( pFontStyleNameState && (pFontStyleNameState->maValue >>= sTmp ) ) 222 sStyleName = sTmp; 223 224 sal_Int16 nTmp = sal_Int16(); 225 if( pFontFamilyState && (pFontFamilyState->maValue >>= nTmp ) ) 226 nFamily = nTmp; 227 if( pFontPitchState && (pFontPitchState->maValue >>= nTmp ) ) 228 nPitch = nTmp; 229 if( pFontCharsetState && (pFontCharsetState->maValue >>= nTmp ) ) 230 eEnc = (rtl_TextEncoding)nTmp; 231 232 OUString sName( ((SvXMLExport&)GetExport()).GetFontAutoStylePool()->Find( 233 sFamilyName, sStyleName, nFamily, nPitch, eEnc ) ); 234 if( sName.getLength() ) 235 { 236 pFontNameState->maValue <<= sName; 237 if( pFontFamilyNameState ) 238 pFontFamilyNameState->mnIndex = -1; 239 if( pFontStyleNameState ) 240 pFontStyleNameState->mnIndex = -1; 241 if( pFontFamilyState ) 242 pFontFamilyState->mnIndex = -1; 243 if( pFontPitchState ) 244 pFontPitchState->mnIndex = -1; 245 if( pFontCharsetState ) 246 pFontCharsetState->mnIndex = -1; 247 } 248 else 249 { 250 pFontNameState->mnIndex = -1; 251 } 252 253 if( pFontFamilyNameState && (0 == sFamilyName.getLength()) ) 254 { 255 pFontFamilyNameState->mnIndex = -1; 256 } 257 258 if( pFontStyleNameState && (0 == sStyleName.getLength()) ) 259 { 260 pFontStyleNameState->mnIndex = -1; 261 } 262 } 263 264 void XMLTextExportPropertySetMapper::ContextFontHeightFilter( 265 XMLPropertyState* pCharHeightState, 266 XMLPropertyState* pCharPropHeightState, 267 XMLPropertyState* pCharDiffHeightState ) const 268 { 269 if( pCharPropHeightState ) 270 { 271 sal_Int32 nTemp = 0; 272 pCharPropHeightState->maValue >>= nTemp; 273 if( nTemp == 100 ) 274 { 275 pCharPropHeightState->mnIndex = -1; 276 pCharPropHeightState->maValue.clear(); 277 } 278 else 279 { 280 pCharHeightState->mnIndex = -1; 281 pCharHeightState->maValue.clear(); 282 } 283 } 284 if( pCharDiffHeightState ) 285 { 286 float nTemp = 0; 287 pCharDiffHeightState->maValue >>= nTemp; 288 if( nTemp == 0. ) 289 { 290 pCharDiffHeightState->mnIndex = -1; 291 pCharDiffHeightState->maValue.clear(); 292 } 293 else 294 { 295 pCharHeightState->mnIndex = -1; 296 pCharHeightState->maValue.clear(); 297 } 298 } 299 300 } 301 302 // helper method; implementation below 303 bool lcl_IsOutlineStyle(const SvXMLExport&, const OUString&); 304 305 static void 306 lcl_checkMultiProperty(XMLPropertyState *const pState, 307 XMLPropertyState *const pRelState) 308 { 309 if (pState && pRelState) 310 { 311 sal_Int32 nTemp = 0; 312 pRelState->maValue >>= nTemp; 313 if (100 == nTemp) 314 { 315 pRelState->mnIndex = -1; 316 pRelState->maValue.clear(); 317 } 318 else 319 { 320 pState->mnIndex = -1; 321 pState->maValue.clear(); 322 } 323 } 324 } 325 326 void XMLTextExportPropertySetMapper::ContextFilter( 327 ::std::vector< XMLPropertyState >& rProperties, 328 Reference< XPropertySet > rPropSet ) const 329 { 330 // filter font 331 XMLPropertyState *pFontNameState = 0; 332 XMLPropertyState *pFontFamilyNameState = 0; 333 XMLPropertyState *pFontStyleNameState = 0; 334 XMLPropertyState *pFontFamilyState = 0; 335 XMLPropertyState *pFontPitchState = 0; 336 XMLPropertyState *pFontCharsetState = 0; 337 XMLPropertyState *pFontNameCJKState = 0; 338 XMLPropertyState *pFontFamilyNameCJKState = 0; 339 XMLPropertyState *pFontStyleNameCJKState = 0; 340 XMLPropertyState *pFontFamilyCJKState = 0; 341 XMLPropertyState *pFontPitchCJKState = 0; 342 XMLPropertyState *pFontCharsetCJKState = 0; 343 XMLPropertyState *pFontNameCTLState = 0; 344 XMLPropertyState *pFontFamilyNameCTLState = 0; 345 XMLPropertyState *pFontStyleNameCTLState = 0; 346 XMLPropertyState *pFontFamilyCTLState = 0; 347 XMLPropertyState *pFontPitchCTLState = 0; 348 XMLPropertyState *pFontCharsetCTLState = 0; 349 350 // filter char height point/percent 351 XMLPropertyState* pCharHeightState = NULL; 352 XMLPropertyState* pCharPropHeightState = NULL; 353 XMLPropertyState* pCharDiffHeightState = NULL; 354 XMLPropertyState* pCharHeightCJKState = NULL; 355 XMLPropertyState* pCharPropHeightCJKState = NULL; 356 XMLPropertyState* pCharDiffHeightCJKState = NULL; 357 XMLPropertyState* pCharHeightCTLState = NULL; 358 XMLPropertyState* pCharPropHeightCTLState = NULL; 359 XMLPropertyState* pCharDiffHeightCTLState = NULL; 360 361 // filter left margin measure/percent 362 XMLPropertyState* pParaLeftMarginState = NULL; 363 XMLPropertyState* pParaLeftMarginRelState = NULL; 364 365 // filter right margin measure/percent 366 XMLPropertyState* pParaRightMarginState = NULL; 367 XMLPropertyState* pParaRightMarginRelState = NULL; 368 369 // filter first line indent measure/percent 370 XMLPropertyState* pParaFirstLineState = NULL; 371 XMLPropertyState* pParaFirstLineRelState = NULL; 372 373 // filter ParaTopMargin/Relative 374 XMLPropertyState* pParaTopMarginState = NULL; 375 XMLPropertyState* pParaTopMarginRelState = NULL; 376 377 // filter ParaTopMargin/Relative 378 XMLPropertyState* pParaBottomMarginState = NULL; 379 XMLPropertyState* pParaBottomMarginRelState = NULL; 380 381 // filter (Left|Right|Top|Bottom|)BorderWidth 382 XMLPropertyState* pAllBorderWidthState = NULL; 383 XMLPropertyState* pLeftBorderWidthState = NULL; 384 XMLPropertyState* pRightBorderWidthState = NULL; 385 XMLPropertyState* pTopBorderWidthState = NULL; 386 XMLPropertyState* pBottomBorderWidthState = NULL; 387 388 // filter (Left|Right|Top|)BorderDistance 389 XMLPropertyState* pAllBorderDistanceState = NULL; 390 XMLPropertyState* pLeftBorderDistanceState = NULL; 391 XMLPropertyState* pRightBorderDistanceState = NULL; 392 XMLPropertyState* pTopBorderDistanceState = NULL; 393 XMLPropertyState* pBottomBorderDistanceState = NULL; 394 395 // filter (Left|Right|Top|Bottom|)Border 396 XMLPropertyState* pAllBorderState = NULL; 397 XMLPropertyState* pLeftBorderState = NULL; 398 XMLPropertyState* pRightBorderState = NULL; 399 XMLPropertyState* pTopBorderState = NULL; 400 XMLPropertyState* pBottomBorderState = NULL; 401 402 // filter height properties 403 XMLPropertyState* pHeightMinAbsState = NULL; 404 XMLPropertyState* pHeightMinRelState = NULL; 405 XMLPropertyState* pHeightAbsState = NULL; 406 XMLPropertyState* pHeightRelState = NULL; 407 XMLPropertyState* pSizeTypeState = NULL; 408 409 // filter width properties 410 XMLPropertyState* pWidthMinAbsState = NULL; 411 XMLPropertyState* pWidthMinRelState = NULL; 412 XMLPropertyState* pWidthAbsState = NULL; 413 XMLPropertyState* pWidthRelState = NULL; 414 XMLPropertyState* pWidthTypeState = NULL; 415 416 // wrap 417 XMLPropertyState* pWrapState = NULL; 418 XMLPropertyState* pWrapContourState = NULL; 419 XMLPropertyState* pWrapContourModeState = NULL; 420 XMLPropertyState* pWrapParagraphOnlyState = NULL; 421 422 // anchor 423 XMLPropertyState* pAnchorTypeState = NULL; 424 425 // horizontal position and relation 426 XMLPropertyState* pHoriOrientState = NULL; 427 XMLPropertyState* pHoriOrientMirroredState = NULL; 428 XMLPropertyState* pHoriOrientRelState = NULL; 429 XMLPropertyState* pHoriOrientRelFrameState = NULL; 430 XMLPropertyState* pHoriOrientMirrorState = NULL; 431 // --> OD 2004-08-09 #i28749# - horizontal position and relation for shapes 432 XMLPropertyState* pShapeHoriOrientState = NULL; 433 XMLPropertyState* pShapeHoriOrientMirroredState = NULL; 434 XMLPropertyState* pShapeHoriOrientRelState = NULL; 435 XMLPropertyState* pShapeHoriOrientRelFrameState = NULL; 436 XMLPropertyState* pShapeHoriOrientMirrorState = NULL; 437 // <-- 438 439 // vertical position and relation 440 XMLPropertyState* pVertOrientState = NULL; 441 XMLPropertyState* pVertOrientAtCharState = NULL; 442 XMLPropertyState* pVertOrientRelState = NULL; 443 XMLPropertyState* pVertOrientRelPageState = NULL; 444 XMLPropertyState* pVertOrientRelFrameState = NULL; 445 XMLPropertyState* pVertOrientRelAsCharState = NULL; 446 447 // --> OD 2004-08-09 #i28749# - vertical position and relation for shapes 448 XMLPropertyState* pShapeVertOrientState = NULL; 449 XMLPropertyState* pShapeVertOrientAtCharState = NULL; 450 XMLPropertyState* pShapeVertOrientRelState = NULL; 451 XMLPropertyState* pShapeVertOrientRelPageState = NULL; 452 XMLPropertyState* pShapeVertOrientRelFrameState = NULL; 453 // <-- 454 455 // filter underline color 456 XMLPropertyState* pUnderlineState = NULL; 457 XMLPropertyState* pUnderlineColorState = NULL; 458 XMLPropertyState* pUnderlineHasColorState = NULL; 459 460 // filter list style name 461 XMLPropertyState* pListStyleName = NULL; 462 463 // filter fo:clip 464 XMLPropertyState* pClip11State = NULL; 465 XMLPropertyState* pClipState = NULL; 466 467 XMLPropertyState* pAllParaMargin = NULL; 468 XMLPropertyState* pAllMargin = NULL; 469 470 sal_Bool bNeedsAnchor = sal_False; 471 472 for( ::std::vector< XMLPropertyState >::iterator aIter = rProperties.begin(); 473 aIter != rProperties.end(); 474 ++aIter ) 475 { 476 XMLPropertyState *propertie = &(*aIter); 477 if( propertie->mnIndex == -1 ) 478 continue; 479 480 switch( getPropertySetMapper()->GetEntryContextId( propertie->mnIndex ) ) 481 { 482 case CTF_CHARHEIGHT: pCharHeightState = propertie; break; 483 case CTF_CHARHEIGHT_REL: pCharPropHeightState = propertie; break; 484 case CTF_CHARHEIGHT_DIFF: pCharDiffHeightState = propertie; break; 485 case CTF_CHARHEIGHT_CJK: pCharHeightCJKState = propertie; break; 486 case CTF_CHARHEIGHT_REL_CJK: pCharPropHeightCJKState = propertie; break; 487 case CTF_CHARHEIGHT_DIFF_CJK: pCharDiffHeightCJKState = propertie; break; 488 case CTF_CHARHEIGHT_CTL: pCharHeightCTLState = propertie; break; 489 case CTF_CHARHEIGHT_REL_CTL: pCharPropHeightCTLState = propertie; break; 490 case CTF_CHARHEIGHT_DIFF_CTL: pCharDiffHeightCTLState = propertie; break; 491 case CTF_PARALEFTMARGIN: pParaLeftMarginState = propertie; break; 492 case CTF_PARALEFTMARGIN_REL: pParaLeftMarginRelState = propertie; break; 493 case CTF_PARARIGHTMARGIN: pParaRightMarginState = propertie; break; 494 case CTF_PARARIGHTMARGIN_REL: pParaRightMarginRelState = propertie; break; 495 case CTF_PARAFIRSTLINE: pParaFirstLineState = propertie; break; 496 case CTF_PARAFIRSTLINE_REL: pParaFirstLineRelState = propertie; break; 497 case CTF_PARATOPMARGIN: pParaTopMarginState = propertie; break; 498 case CTF_PARATOPMARGIN_REL: pParaTopMarginRelState = propertie; break; 499 case CTF_PARABOTTOMMARGIN: pParaBottomMarginState = propertie; break; 500 case CTF_PARABOTTOMMARGIN_REL: pParaBottomMarginRelState = propertie; break; 501 case CTF_ALLBORDERWIDTH: pAllBorderWidthState = propertie; break; 502 case CTF_LEFTBORDERWIDTH: pLeftBorderWidthState = propertie; break; 503 case CTF_RIGHTBORDERWIDTH: pRightBorderWidthState = propertie; break; 504 case CTF_TOPBORDERWIDTH: pTopBorderWidthState = propertie; break; 505 case CTF_BOTTOMBORDERWIDTH: pBottomBorderWidthState = propertie; break; 506 case CTF_ALLBORDERDISTANCE: pAllBorderDistanceState = propertie; break; 507 case CTF_LEFTBORDERDISTANCE: pLeftBorderDistanceState = propertie; break; 508 case CTF_RIGHTBORDERDISTANCE: pRightBorderDistanceState = propertie; break; 509 case CTF_TOPBORDERDISTANCE: pTopBorderDistanceState = propertie; break; 510 case CTF_BOTTOMBORDERDISTANCE: pBottomBorderDistanceState = propertie; break; 511 case CTF_ALLBORDER: pAllBorderState = propertie; break; 512 case CTF_LEFTBORDER: pLeftBorderState = propertie; break; 513 case CTF_RIGHTBORDER: pRightBorderState = propertie; break; 514 case CTF_TOPBORDER: pTopBorderState = propertie; break; 515 case CTF_BOTTOMBORDER: pBottomBorderState = propertie; break; 516 517 case CTF_FRAMEHEIGHT_MIN_ABS: pHeightMinAbsState = propertie; break; 518 case CTF_FRAMEHEIGHT_MIN_REL: pHeightMinRelState = propertie; break; 519 case CTF_FRAMEHEIGHT_ABS: pHeightAbsState = propertie; break; 520 case CTF_FRAMEHEIGHT_REL: pHeightRelState = propertie; break; 521 case CTF_SIZETYPE: pSizeTypeState = propertie; break; 522 523 case CTF_FRAMEWIDTH_MIN_ABS: pWidthMinAbsState = propertie; break; 524 case CTF_FRAMEWIDTH_MIN_REL: pWidthMinRelState = propertie; break; 525 case CTF_FRAMEWIDTH_ABS: pWidthAbsState = propertie; break; 526 case CTF_FRAMEWIDTH_REL: pWidthRelState = propertie; break; 527 case CTF_FRAMEWIDTH_TYPE: pWidthTypeState = propertie; break; 528 529 case CTF_WRAP: pWrapState = propertie; break; 530 case CTF_WRAP_CONTOUR: pWrapContourState = propertie; break; 531 case CTF_WRAP_CONTOUR_MODE: pWrapContourModeState = propertie; break; 532 case CTF_WRAP_PARAGRAPH_ONLY: pWrapParagraphOnlyState = propertie; break; 533 case CTF_ANCHORTYPE: pAnchorTypeState = propertie; break; 534 535 case CTF_HORIZONTALPOS: pHoriOrientState = propertie; bNeedsAnchor = sal_True; break; 536 case CTF_HORIZONTALPOS_MIRRORED: pHoriOrientMirroredState = propertie; bNeedsAnchor = sal_True; break; 537 case CTF_HORIZONTALREL: pHoriOrientRelState = propertie; bNeedsAnchor = sal_True; break; 538 case CTF_HORIZONTALREL_FRAME: pHoriOrientRelFrameState = propertie; bNeedsAnchor = sal_True; break; 539 case CTF_HORIZONTALMIRROR: pHoriOrientMirrorState = propertie; bNeedsAnchor = sal_True; break; 540 case CTF_VERTICALPOS: pVertOrientState = propertie; bNeedsAnchor = sal_True; break; 541 case CTF_VERTICALPOS_ATCHAR: pVertOrientAtCharState = propertie; bNeedsAnchor = sal_True; break; 542 case CTF_VERTICALREL: pVertOrientRelState = propertie; bNeedsAnchor = sal_True; break; 543 case CTF_VERTICALREL_PAGE: pVertOrientRelPageState = propertie; bNeedsAnchor = sal_True; break; 544 case CTF_VERTICALREL_FRAME: pVertOrientRelFrameState = propertie; bNeedsAnchor = sal_True; break; 545 case CTF_VERTICALREL_ASCHAR: pVertOrientRelAsCharState = propertie; bNeedsAnchor = sal_True; break; 546 547 // --> OD 2004-08-09 #i28749# - handle new CTFs for shape positioning properties 548 case CTF_SHAPE_HORIZONTALPOS: pShapeHoriOrientState = propertie; bNeedsAnchor = sal_True; break; 549 case CTF_SHAPE_HORIZONTALPOS_MIRRORED: pShapeHoriOrientMirroredState = propertie; bNeedsAnchor = sal_True; break; 550 case CTF_SHAPE_HORIZONTALREL: pShapeHoriOrientRelState = propertie; bNeedsAnchor = sal_True; break; 551 case CTF_SHAPE_HORIZONTALREL_FRAME: pShapeHoriOrientRelFrameState = propertie; bNeedsAnchor = sal_True; break; 552 case CTF_SHAPE_HORIZONTALMIRROR: pShapeHoriOrientMirrorState = propertie; bNeedsAnchor = sal_True; break; 553 case CTF_SHAPE_VERTICALPOS: pShapeVertOrientState = propertie; bNeedsAnchor = sal_True; break; 554 case CTF_SHAPE_VERTICALPOS_ATCHAR: pShapeVertOrientAtCharState = propertie; bNeedsAnchor = sal_True; break; 555 case CTF_SHAPE_VERTICALREL: pShapeVertOrientRelState = propertie; bNeedsAnchor = sal_True; break; 556 case CTF_SHAPE_VERTICALREL_PAGE: pShapeVertOrientRelPageState = propertie; bNeedsAnchor = sal_True; break; 557 case CTF_SHAPE_VERTICALREL_FRAME: pShapeVertOrientRelFrameState = propertie; bNeedsAnchor = sal_True; break; 558 // <-- 559 560 case CTF_FONTNAME: pFontNameState = propertie; break; 561 case CTF_FONTFAMILYNAME: pFontFamilyNameState = propertie; break; 562 case CTF_FONTSTYLENAME: pFontStyleNameState = propertie; break; 563 case CTF_FONTFAMILY: pFontFamilyState = propertie; break; 564 case CTF_FONTPITCH: pFontPitchState = propertie; break; 565 case CTF_FONTCHARSET: pFontCharsetState = propertie; break; 566 567 case CTF_FONTNAME_CJK: pFontNameCJKState = propertie; break; 568 case CTF_FONTFAMILYNAME_CJK: pFontFamilyNameCJKState = propertie; break; 569 case CTF_FONTSTYLENAME_CJK: pFontStyleNameCJKState = propertie; break; 570 case CTF_FONTFAMILY_CJK: pFontFamilyCJKState = propertie; break; 571 case CTF_FONTPITCH_CJK: pFontPitchCJKState = propertie; break; 572 case CTF_FONTCHARSET_CJK: pFontCharsetCJKState = propertie; break; 573 574 case CTF_FONTNAME_CTL: pFontNameCTLState = propertie; break; 575 case CTF_FONTFAMILYNAME_CTL: pFontFamilyNameCTLState = propertie; break; 576 case CTF_FONTSTYLENAME_CTL: pFontStyleNameCTLState = propertie; break; 577 case CTF_FONTFAMILY_CTL: pFontFamilyCTLState = propertie; break; 578 case CTF_FONTPITCH_CTL: pFontPitchCTLState = propertie; break; 579 case CTF_FONTCHARSET_CTL: pFontCharsetCTLState = propertie; break; 580 case CTF_UNDERLINE: pUnderlineState = propertie; break; 581 case CTF_UNDERLINE_COLOR: pUnderlineColorState = propertie; break; 582 case CTF_UNDERLINE_HASCOLOR: pUnderlineHasColorState = propertie; break; 583 case CTF_NUMBERINGSTYLENAME: pListStyleName = propertie; break; 584 case CTF_TEXT_CLIP11: pClip11State = propertie; break; 585 case CTF_TEXT_CLIP: pClipState = propertie; break; 586 case CTF_PARAMARGINALL: pAllParaMargin = propertie; break; 587 case CTF_MARGINALL: pAllMargin = propertie; break; 588 } 589 } 590 591 if( pFontNameState ) 592 ContextFontFilter( pFontNameState, pFontFamilyNameState, 593 pFontStyleNameState, pFontFamilyState, 594 pFontPitchState, pFontCharsetState ); 595 if( pFontNameCJKState ) 596 ContextFontFilter( pFontNameCJKState, pFontFamilyNameCJKState, 597 pFontStyleNameCJKState, pFontFamilyCJKState, 598 pFontPitchCJKState, pFontCharsetCJKState ); 599 if( pFontNameCTLState ) 600 ContextFontFilter( pFontNameCTLState, pFontFamilyNameCTLState, 601 pFontStyleNameCTLState, pFontFamilyCTLState, 602 pFontPitchCTLState, pFontCharsetCTLState ); 603 604 if( pCharHeightState && (pCharPropHeightState || pCharDiffHeightState ) ) 605 ContextFontHeightFilter( pCharHeightState, pCharPropHeightState, 606 pCharDiffHeightState ); 607 if( pCharHeightCJKState && 608 (pCharPropHeightCJKState || pCharDiffHeightCJKState ) ) 609 ContextFontHeightFilter( pCharHeightCJKState, pCharPropHeightCJKState, 610 pCharDiffHeightCJKState ); 611 if( pCharHeightCTLState && 612 (pCharPropHeightCTLState || pCharDiffHeightCTLState ) ) 613 ContextFontHeightFilter( pCharHeightCTLState, pCharPropHeightCTLState, 614 pCharDiffHeightCTLState ); 615 if( pUnderlineColorState || pUnderlineHasColorState ) 616 { 617 sal_Bool bClear = !pUnderlineState; 618 if( !bClear ) 619 { 620 sal_Int16 nUnderline = 0; 621 pUnderlineState->maValue >>= nUnderline; 622 bClear = FontUnderline::NONE == nUnderline; 623 } 624 if( bClear ) 625 { 626 if( pUnderlineColorState ) 627 pUnderlineColorState->mnIndex = -1; 628 if( pUnderlineHasColorState ) 629 pUnderlineHasColorState->mnIndex = -1; 630 } 631 } 632 633 lcl_checkMultiProperty(pParaLeftMarginState, pParaLeftMarginRelState); 634 lcl_checkMultiProperty(pParaRightMarginState, pParaRightMarginRelState); 635 lcl_checkMultiProperty(pParaTopMarginState, pParaTopMarginRelState); 636 lcl_checkMultiProperty(pParaBottomMarginState, pParaBottomMarginRelState); 637 lcl_checkMultiProperty(pParaFirstLineState, pParaFirstLineRelState); 638 639 if (pAllParaMargin) 640 { 641 pAllParaMargin->mnIndex = -1; // just export individual attributes... 642 pAllParaMargin->maValue.clear(); 643 } 644 if (pAllMargin) 645 { 646 pAllMargin->mnIndex = -1; // just export individual attributes... 647 pAllMargin->maValue.clear(); 648 } 649 650 if( pAllBorderWidthState ) 651 { 652 if( pLeftBorderWidthState && pRightBorderWidthState && pTopBorderWidthState && pBottomBorderWidthState ) 653 { 654 table::BorderLine aLeft, aRight, aTop, aBottom; 655 656 pLeftBorderWidthState->maValue >>= aLeft; 657 pRightBorderWidthState->maValue >>= aRight; 658 pTopBorderWidthState->maValue >>= aTop; 659 pBottomBorderWidthState->maValue >>= aBottom; 660 if( aLeft.Color == aRight.Color && aLeft.InnerLineWidth == aRight.InnerLineWidth && 661 aLeft.OuterLineWidth == aRight.OuterLineWidth && aLeft.LineDistance == aRight.LineDistance && 662 aLeft.Color == aTop.Color && aLeft.InnerLineWidth == aTop.InnerLineWidth && 663 aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance && 664 aLeft.Color == aBottom.Color && aLeft.InnerLineWidth == aBottom.InnerLineWidth && 665 aLeft.OuterLineWidth == aBottom.OuterLineWidth && aLeft.LineDistance == aBottom.LineDistance ) 666 { 667 pLeftBorderWidthState->mnIndex = -1; 668 pLeftBorderWidthState->maValue.clear(); 669 pRightBorderWidthState->mnIndex = -1; 670 pRightBorderWidthState->maValue.clear(); 671 pTopBorderWidthState->mnIndex = -1; 672 pTopBorderWidthState->maValue.clear(); 673 pBottomBorderWidthState->mnIndex = -1; 674 pBottomBorderWidthState->maValue.clear(); 675 } 676 else 677 { 678 pAllBorderWidthState->mnIndex = -1; 679 pAllBorderWidthState->maValue.clear(); 680 } 681 } 682 else 683 { 684 pAllBorderWidthState->mnIndex = -1; 685 pAllBorderWidthState->maValue.clear(); 686 } 687 } 688 689 if( pAllBorderDistanceState ) 690 { 691 if( pLeftBorderDistanceState && pRightBorderDistanceState && pTopBorderDistanceState && pBottomBorderDistanceState ) 692 { 693 sal_Int32 aLeft = 0, aRight = 0, aTop = 0, aBottom = 0; 694 695 pLeftBorderDistanceState->maValue >>= aLeft; 696 pRightBorderDistanceState->maValue >>= aRight; 697 pTopBorderDistanceState->maValue >>= aTop; 698 pBottomBorderDistanceState->maValue >>= aBottom; 699 if( aLeft == aRight && aLeft == aTop && aLeft == aBottom ) 700 { 701 pLeftBorderDistanceState->mnIndex = -1; 702 pLeftBorderDistanceState->maValue.clear(); 703 pRightBorderDistanceState->mnIndex = -1; 704 pRightBorderDistanceState->maValue.clear(); 705 pTopBorderDistanceState->mnIndex = -1; 706 pTopBorderDistanceState->maValue.clear(); 707 pBottomBorderDistanceState->mnIndex = -1; 708 pBottomBorderDistanceState->maValue.clear(); 709 } 710 else 711 { 712 pAllBorderDistanceState->mnIndex = -1; 713 pAllBorderDistanceState->maValue.clear(); 714 } 715 } 716 else 717 { 718 pAllBorderDistanceState->mnIndex = -1; 719 pAllBorderDistanceState->maValue.clear(); 720 } 721 } 722 723 if( pAllBorderState ) 724 { 725 if( pLeftBorderState && pRightBorderState && pTopBorderState && pBottomBorderState ) 726 { 727 table::BorderLine aLeft, aRight, aTop, aBottom; 728 729 pLeftBorderState->maValue >>= aLeft; 730 pRightBorderState->maValue >>= aRight; 731 pTopBorderState->maValue >>= aTop; 732 pBottomBorderState->maValue >>= aBottom; 733 if( aLeft.Color == aRight.Color && aLeft.InnerLineWidth == aRight.InnerLineWidth && 734 aLeft.OuterLineWidth == aRight.OuterLineWidth && aLeft.LineDistance == aRight.LineDistance && 735 aLeft.Color == aTop.Color && aLeft.InnerLineWidth == aTop.InnerLineWidth && 736 aLeft.OuterLineWidth == aTop.OuterLineWidth && aLeft.LineDistance == aTop.LineDistance && 737 aLeft.Color == aBottom.Color && aLeft.InnerLineWidth == aBottom.InnerLineWidth && 738 aLeft.OuterLineWidth == aBottom.OuterLineWidth && aLeft.LineDistance == aBottom.LineDistance ) 739 { 740 pLeftBorderState->mnIndex = -1; 741 pLeftBorderState->maValue.clear(); 742 pRightBorderState->mnIndex = -1; 743 pRightBorderState->maValue.clear(); 744 pTopBorderState->mnIndex = -1; 745 pTopBorderState->maValue.clear(); 746 pBottomBorderState->mnIndex = -1; 747 pBottomBorderState->maValue.clear(); 748 } 749 else 750 { 751 pAllBorderState->mnIndex = -1; 752 pAllBorderState->maValue.clear(); 753 } 754 } 755 else 756 { 757 pAllBorderState->mnIndex = -1; 758 pAllBorderState->maValue.clear(); 759 } 760 } 761 762 sal_Int16 nSizeType = SizeType::FIX; 763 if( pSizeTypeState ) 764 { 765 pSizeTypeState->maValue >>= nSizeType; 766 pSizeTypeState->mnIndex = -1; 767 } 768 769 if( pHeightMinAbsState ) 770 { 771 sal_Int16 nRel = sal_Int16(); 772 if( (SizeType::FIX == nSizeType) || 773 ( pHeightMinRelState && 774 ( !(pHeightMinRelState->maValue >>= nRel) || nRel > 0 ) ) ) 775 { 776 pHeightMinAbsState->mnIndex = -1; 777 } 778 779 // export SizeType::VARIABLE als min-width="0" 780 if( SizeType::VARIABLE == nSizeType ) 781 pHeightMinAbsState->maValue <<= static_cast<sal_Int32>( 0 ); 782 } 783 if( pHeightMinRelState && SizeType::MIN != nSizeType) 784 pHeightMinRelState->mnIndex = -1; 785 if( pHeightAbsState && pHeightMinAbsState && 786 -1 != pHeightMinAbsState->mnIndex ) 787 pHeightAbsState->mnIndex = -1; 788 if( pHeightRelState && SizeType::FIX != nSizeType) 789 pHeightRelState->mnIndex = -1; 790 791 // frame width 792 nSizeType = SizeType::FIX; 793 if( pWidthTypeState ) 794 { 795 pWidthTypeState->maValue >>= nSizeType; 796 pWidthTypeState->mnIndex = -1; 797 } 798 if( pWidthMinAbsState ) 799 { 800 sal_Int16 nRel = sal_Int16(); 801 if( (SizeType::FIX == nSizeType) || 802 ( pWidthMinRelState && 803 ( !(pWidthMinRelState->maValue >>= nRel) || nRel > 0 ) ) ) 804 { 805 pWidthMinAbsState->mnIndex = -1; 806 } 807 808 // export SizeType::VARIABLE als min-width="0" 809 if( SizeType::VARIABLE == nSizeType ) 810 pWidthMinAbsState->maValue <<= static_cast<sal_Int32>( 0 ); 811 } 812 if( pWidthMinRelState && SizeType::MIN != nSizeType) 813 pWidthMinRelState->mnIndex = -1; 814 if( pWidthAbsState && pWidthMinAbsState && 815 -1 != pWidthMinAbsState->mnIndex ) 816 pWidthAbsState->mnIndex = -1; 817 if( pWidthRelState && SizeType::FIX != nSizeType) 818 pWidthRelState->mnIndex = -1; 819 820 if( pWrapState ) 821 { 822 WrapTextMode eVal; 823 pWrapState->maValue >>= eVal; 824 switch( eVal ) 825 { 826 case WrapTextMode_NONE: 827 // no wrapping: disable para-only and contour 828 if( pWrapParagraphOnlyState ) 829 pWrapParagraphOnlyState->mnIndex = -1; 830 // no break 831 case WrapTextMode_THROUGHT: 832 // wrap through: disable only contour 833 if( pWrapContourState ) 834 pWrapContourState->mnIndex = -1; 835 break; 836 default: 837 break; 838 } 839 if( pWrapContourModeState && 840 (!pWrapContourState || 841 !*(sal_Bool *)pWrapContourState ->maValue.getValue() ) ) 842 pWrapContourModeState->mnIndex = -1; 843 } 844 845 TextContentAnchorType eAnchor = TextContentAnchorType_AT_PARAGRAPH; 846 if( pAnchorTypeState ) 847 pAnchorTypeState->maValue >>= eAnchor; 848 else if( bNeedsAnchor ) 849 { 850 Any aAny = rPropSet->getPropertyValue( 851 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("AnchorType") ) ); 852 aAny >>= eAnchor; 853 } 854 855 // states for frame positioning attributes 856 { 857 if( pHoriOrientState && pHoriOrientMirroredState ) 858 { 859 if( pHoriOrientMirrorState && 860 *(sal_Bool *)pHoriOrientMirrorState->maValue.getValue() ) 861 pHoriOrientState->mnIndex = -1; 862 else 863 pHoriOrientMirroredState->mnIndex = -1; 864 } 865 if( pHoriOrientMirrorState ) 866 pHoriOrientMirrorState->mnIndex = -1; 867 868 if( pHoriOrientRelState && TextContentAnchorType_AT_FRAME == eAnchor ) 869 pHoriOrientRelState->mnIndex = -1; 870 if( pHoriOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor ) 871 pHoriOrientRelFrameState->mnIndex = -1;; 872 873 if( pVertOrientState && TextContentAnchorType_AT_CHARACTER == eAnchor ) 874 pVertOrientState->mnIndex = -1; 875 if( pVertOrientAtCharState && TextContentAnchorType_AT_CHARACTER != eAnchor ) 876 pVertOrientAtCharState->mnIndex = -1; 877 if( pVertOrientRelState && TextContentAnchorType_AT_PARAGRAPH != eAnchor && 878 TextContentAnchorType_AT_CHARACTER != eAnchor ) 879 pVertOrientRelState->mnIndex = -1; 880 if( pVertOrientRelPageState && TextContentAnchorType_AT_PAGE != eAnchor ) 881 pVertOrientRelPageState->mnIndex = -1; 882 if( pVertOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor ) 883 pVertOrientRelFrameState->mnIndex = -1; 884 if( pVertOrientRelAsCharState && TextContentAnchorType_AS_CHARACTER != eAnchor ) 885 pVertOrientRelAsCharState->mnIndex = -1; 886 } 887 888 // --> OD 2004-08-09 #i28749# - states for shape positioning properties 889 if ( eAnchor != TextContentAnchorType_AS_CHARACTER && 890 ( GetExport().getExportFlags() & EXPORT_OASIS ) == 0 ) 891 { 892 // no export of shape positioning properties, 893 // if shape isn't anchored as-character and 894 // destination file format is OpenOffice.org file format 895 if ( pShapeHoriOrientState ) 896 pShapeHoriOrientState->mnIndex = -1; 897 if ( pShapeHoriOrientMirroredState ) 898 pShapeHoriOrientMirroredState->mnIndex = -1; 899 if ( pShapeHoriOrientRelState ) 900 pShapeHoriOrientRelState->mnIndex = -1; 901 if ( pShapeHoriOrientRelFrameState ) 902 pShapeHoriOrientRelFrameState->mnIndex = -1; 903 if ( pShapeHoriOrientMirrorState ) 904 pShapeHoriOrientMirrorState->mnIndex = -1; 905 if ( pShapeVertOrientState ) 906 pShapeVertOrientState->mnIndex = -1; 907 if ( pShapeVertOrientAtCharState ) 908 pShapeVertOrientAtCharState->mnIndex = -1; 909 if ( pShapeVertOrientRelState ) 910 pShapeVertOrientRelState->mnIndex = -1; 911 if ( pShapeVertOrientRelPageState ) 912 pShapeVertOrientRelPageState->mnIndex = -1; 913 if ( pShapeVertOrientRelFrameState ) 914 pShapeVertOrientRelFrameState->mnIndex = -1; 915 } 916 else 917 { 918 // handling of shape positioning property states as for frames - see above 919 if( pShapeHoriOrientState && pShapeHoriOrientMirroredState ) 920 { 921 if( pShapeHoriOrientMirrorState && 922 *(sal_Bool *)pShapeHoriOrientMirrorState->maValue.getValue() ) 923 pShapeHoriOrientState->mnIndex = -1; 924 else 925 pShapeHoriOrientMirroredState->mnIndex = -1; 926 } 927 if( pShapeHoriOrientMirrorState ) 928 pShapeHoriOrientMirrorState->mnIndex = -1; 929 930 if( pShapeHoriOrientRelState && TextContentAnchorType_AT_FRAME == eAnchor ) 931 pShapeHoriOrientRelState->mnIndex = -1; 932 if( pShapeHoriOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor ) 933 pShapeHoriOrientRelFrameState->mnIndex = -1;; 934 935 if( pShapeVertOrientState && TextContentAnchorType_AT_CHARACTER == eAnchor ) 936 pShapeVertOrientState->mnIndex = -1; 937 if( pShapeVertOrientAtCharState && TextContentAnchorType_AT_CHARACTER != eAnchor ) 938 pShapeVertOrientAtCharState->mnIndex = -1; 939 if( pShapeVertOrientRelState && TextContentAnchorType_AT_PARAGRAPH != eAnchor && 940 TextContentAnchorType_AT_CHARACTER != eAnchor ) 941 pShapeVertOrientRelState->mnIndex = -1; 942 if( pShapeVertOrientRelPageState && TextContentAnchorType_AT_PAGE != eAnchor ) 943 pShapeVertOrientRelPageState->mnIndex = -1; 944 if( pShapeVertOrientRelFrameState && TextContentAnchorType_AT_FRAME != eAnchor ) 945 pShapeVertOrientRelFrameState->mnIndex = -1; 946 } 947 // <-- 948 949 // list style name: remove list style if it is the default outline style 950 if( pListStyleName != NULL ) 951 { 952 OUString sListStyleName; 953 pListStyleName->maValue >>= sListStyleName; 954 if( lcl_IsOutlineStyle( GetExport(), sListStyleName ) ) 955 pListStyleName->mnIndex = -1; 956 } 957 958 if( pClipState != NULL && pClip11State != NULL ) 959 pClip11State->mnIndex = -1; 960 961 SvXMLExportPropertyMapper::ContextFilter(rProperties,rPropSet); 962 } 963 964 965 bool lcl_IsOutlineStyle(const SvXMLExport &rExport, const OUString & rName) 966 { 967 Reference< XChapterNumberingSupplier > 968 xCNSupplier(rExport.GetModel(), UNO_QUERY); 969 970 OUString sOutlineName; 971 OUString sName(RTL_CONSTASCII_USTRINGPARAM("Name")); 972 973 if (xCNSupplier.is()) 974 { 975 Reference<XPropertySet> xNumRule( 976 xCNSupplier->getChapterNumberingRules(), UNO_QUERY ); 977 DBG_ASSERT( xNumRule.is(), "no chapter numbering rules" ); 978 if (xNumRule.is()) 979 { 980 xNumRule->getPropertyValue(sName) >>= sOutlineName; 981 } 982 } 983 984 return rName == sOutlineName; 985 } 986