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 28 #include <hintids.hxx> 29 #include <com/sun/star/text/RelOrientation.hpp> 30 #include <com/sun/star/text/VertOrientation.hpp> 31 #include <com/sun/star/text/HorizontalAdjust.hpp> 32 #include <com/sun/star/text/DocumentStatistic.hpp> 33 #include <com/sun/star/text/HoriOrientation.hpp> 34 #include <com/sun/star/text/HoriOrientationFormat.hpp> 35 #include <com/sun/star/text/NotePrintMode.hpp> 36 #include <com/sun/star/text/SizeType.hpp> 37 #include <com/sun/star/text/VertOrientationFormat.hpp> 38 #include <com/sun/star/text/WrapTextMode.hpp> 39 #include <com/sun/star/text/XTextFrame.hpp> 40 #include <com/sun/star/text/TextContentAnchorType.hpp> 41 #include <com/sun/star/text/InvalidTextContentException.hpp> 42 #include <com/sun/star/container/XIndexContainer.hpp> 43 #include <com/sun/star/text/TextGridMode.hpp> 44 #include <com/sun/star/awt/Size.hpp> 45 #include <svtools/unoimap.hxx> 46 #include <svtools/unoevent.hxx> 47 #include <basic/sbxvar.hxx> 48 #include <svtools/imap.hxx> 49 #include <svtools/imapobj.hxx> 50 #include <editeng/ulspitem.hxx> 51 #include <editeng/lrspitem.hxx> 52 #include <svx/svdmodel.hxx> 53 #include <svx/svdpage.hxx> 54 #include <svl/itemiter.hxx> 55 #include <unosett.hxx> 56 #include <unostyle.hxx> 57 #include <fmtclds.hxx> 58 #include <fmtornt.hxx> 59 #include <fmthdft.hxx> 60 #include <fmtpdsc.hxx> 61 #include <fmtcntnt.hxx> 62 #include <fmtfsize.hxx> 63 #include <fmtfordr.hxx> 64 #include <fmtsrnd.hxx> 65 #include <fmtanchr.hxx> 66 #include <fmtlsplt.hxx> 67 #include <fmtrowsplt.hxx> 68 #include <fmtftntx.hxx> 69 #include <fmteiro.hxx> 70 #include <fmturl.hxx> 71 #include <fmtcnct.hxx> 72 #include <node.hxx> 73 #include <section.hxx> 74 #include <fmtline.hxx> 75 #include <tgrditem.hxx> 76 #include <hfspacingitem.hxx> 77 #include <doc.hxx> 78 #include <IDocumentUndoRedo.hxx> 79 #include <pagefrm.hxx> 80 #include <rootfrm.hxx> 81 #include <cntfrm.hxx> 82 #include <crsrsh.hxx> 83 #include <pam.hxx> 84 #include <dflyobj.hxx> 85 #include <dcontact.hxx> 86 #include <flyfrm.hxx> 87 #include <frmtool.hxx> 88 #include <flyfrms.hxx> 89 #include <pagedesc.hxx> 90 #include <grfatr.hxx> 91 #include <ndnotxt.hxx> 92 #include <docary.hxx> 93 #include <node2lay.hxx> 94 #include <fmtclbl.hxx> 95 #include <swunohelper.hxx> 96 #include <unoframe.hxx> 97 #include <unotextbodyhf.hxx> 98 #include <SwStyleNameMapper.hxx> 99 #include <editeng/brshitem.hxx> 100 #include <svtools/grfmgr.hxx> 101 #include <cmdid.h> 102 #include <unomid.h> 103 #include <comcore.hrc> 104 #include <svx/svdundo.hxx> // #111827# 105 #include <sortedobjs.hxx> 106 #include <HandleAnchorNodeChg.hxx> 107 #include <svl/cjkoptions.hxx> 108 #include <switerator.hxx> 109 #include <pagedeschint.hxx> 110 111 //UUUU 112 #include <svx/sdr/attribute/sdrallfillattributeshelper.hxx> 113 #include <svx/xfillit0.hxx> 114 115 using namespace ::com::sun::star; 116 using ::rtl::OUString; 117 118 SV_IMPL_PTRARR(SwColumns,SwColumn*) 119 120 TYPEINIT1(SwFmtVertOrient, SfxPoolItem); 121 TYPEINIT1(SwFmtHoriOrient, SfxPoolItem); 122 TYPEINIT2(SwFmtHeader, SfxPoolItem, SwClient ); 123 TYPEINIT2(SwFmtFooter, SfxPoolItem, SwClient ); 124 TYPEINIT2(SwFmtPageDesc, SfxPoolItem, SwClient ); 125 TYPEINIT1_AUTOFACTORY(SwFmtLineNumber, SfxPoolItem); 126 127 /* -----------------19.05.98 09:26------------------- 128 * Umwandlung fuer QueryValue 129 * --------------------------------------------------*/ 130 sal_Int16 lcl_RelToINT(sal_Int16 eRelation) 131 { 132 sal_Int16 nRet = text::RelOrientation::FRAME; 133 switch(eRelation) 134 { 135 case text::RelOrientation::PRINT_AREA: nRet = text::RelOrientation::PRINT_AREA; break; 136 case text::RelOrientation::CHAR: nRet = text::RelOrientation::CHAR; break; 137 case text::RelOrientation::PAGE_LEFT: nRet = text::RelOrientation::PAGE_LEFT; break; 138 case text::RelOrientation::PAGE_RIGHT: nRet = text::RelOrientation::PAGE_RIGHT; break; 139 case text::RelOrientation::FRAME_LEFT: nRet = text::RelOrientation::FRAME_LEFT; break; 140 case text::RelOrientation::FRAME_RIGHT: nRet = text::RelOrientation::FRAME_RIGHT; break; 141 case text::RelOrientation::PAGE_FRAME: nRet = text::RelOrientation::PAGE_FRAME; break; 142 case text::RelOrientation::PAGE_PRINT_AREA: nRet = text::RelOrientation::PAGE_PRINT_AREA; break; 143 // OD 13.11.2003 #i22341# 144 case text::RelOrientation::TEXT_LINE: nRet = text::RelOrientation::TEXT_LINE; break; 145 default: break; 146 } 147 return nRet; 148 } 149 150 sal_Int16 lcl_IntToRelation(const uno::Any& rVal) 151 { 152 sal_Int16 eRet = text::RelOrientation::FRAME; 153 sal_Int16 nVal = 0; 154 rVal >>= nVal; 155 switch(nVal) 156 { 157 case text::RelOrientation::PRINT_AREA: eRet = text::RelOrientation::PRINT_AREA ; break; 158 case text::RelOrientation::CHAR: eRet = text::RelOrientation::CHAR ; break; 159 case text::RelOrientation::PAGE_LEFT: eRet = text::RelOrientation::PAGE_LEFT ; break; 160 case text::RelOrientation::PAGE_RIGHT: eRet = text::RelOrientation::PAGE_RIGHT ; break; 161 case text::RelOrientation::FRAME_LEFT: eRet = text::RelOrientation::FRAME_LEFT ; break; 162 case text::RelOrientation::FRAME_RIGHT: eRet = text::RelOrientation::FRAME_RIGHT ; break; 163 case text::RelOrientation::PAGE_FRAME: eRet = text::RelOrientation::PAGE_FRAME ; break; 164 case text::RelOrientation::PAGE_PRINT_AREA: eRet = text::RelOrientation::PAGE_PRINT_AREA ; break; 165 // OD 13.11.2003 #i22341# 166 case text::RelOrientation::TEXT_LINE: eRet = text::RelOrientation::TEXT_LINE; break; 167 } 168 return eRet; 169 } 170 171 void DelHFFormat( SwClient *pToRemove, SwFrmFmt *pFmt ) 172 { 173 //Wenn der Client der letzte ist der das Format benutzt, so muss dieses 174 //vernichtet werden. Zuvor muss jedoch ggf. die Inhaltssection vernichtet 175 //werden. 176 SwDoc* pDoc = pFmt->GetDoc(); 177 pFmt->Remove( pToRemove ); 178 if( pDoc->IsInDtor() ) 179 { 180 delete pFmt; 181 return; 182 } 183 184 //Nur noch Frms angemeldet? 185 sal_Bool bDel = sal_True; 186 { 187 // Klammer, weil im DTOR SwClientIter das Flag bTreeChg zurueck 188 // gesetzt wird. Unguenstig, wenn das Format vorher zerstoert wird. 189 SwClientIter aIter( *pFmt ); // TODO 190 SwClient *pLast = aIter.GoStart(); 191 if( pLast ) 192 do { 193 bDel = pLast->IsA( TYPE(SwFrm) ) 194 || SwXHeadFootText::IsXHeadFootText(pLast); 195 } while( bDel && 0 != ( pLast = ++aIter )); 196 } 197 198 if ( bDel ) 199 { 200 //Wenn in einem der Nodes noch ein Crsr angemeldet ist, muss das 201 //ParkCrsr einer (beliebigen) Shell gerufen werden. 202 SwFmtCntnt& rCnt = (SwFmtCntnt&)pFmt->GetCntnt(); 203 if ( rCnt.GetCntntIdx() ) 204 { 205 SwNode *pNode = 0; 206 { 207 // --> OD 2008-10-07 #i92993# 208 // Begin with start node of page header/footer to assure that 209 // complete content is checked for cursors and the complete content 210 // is deleted on below made method call <pDoc->DeleteSection(pNode)> 211 // SwNodeIndex aIdx( *rCnt.GetCntntIdx(), 1 ); 212 SwNodeIndex aIdx( *rCnt.GetCntntIdx(), 0 ); 213 // <-- 214 //Wenn in einem der Nodes noch ein Crsr angemeldet ist, muss das 215 //ParkCrsr einer (beliebigen) Shell gerufen werden. 216 pNode = & aIdx.GetNode(); 217 sal_uInt32 nEnd = pNode->EndOfSectionIndex(); 218 while ( aIdx < nEnd ) 219 { 220 if ( pNode->IsCntntNode() && 221 ((SwCntntNode*)pNode)->GetDepends() ) 222 { 223 SwCrsrShell *pShell = SwIterator<SwCrsrShell,SwCntntNode>::FirstElement( *(SwCntntNode*)pNode ); 224 if( pShell ) 225 { 226 pShell->ParkCrsr( aIdx ); 227 aIdx = nEnd-1; 228 } 229 } 230 aIdx++; 231 pNode = & aIdx.GetNode(); 232 } 233 } 234 rCnt.SetNewCntntIdx( (const SwNodeIndex*)0 ); 235 236 // beim Loeschen von Header/Footer-Formaten IMMER das Undo 237 // abschalten! (Bug 31069) 238 ::sw::UndoGuard const undoGuard(pDoc->GetIDocumentUndoRedo()); 239 240 ASSERT( pNode, "Ein grosses Problem." ); 241 pDoc->DeleteSection( pNode ); 242 } 243 delete pFmt; 244 } 245 } 246 247 // class SwFmtFrmSize 248 // Implementierung teilweise inline im hxx 249 250 SwFmtFrmSize::SwFmtFrmSize( SwFrmSize eSize, SwTwips nWidth, SwTwips nHeight ) 251 : SfxPoolItem( RES_FRM_SIZE ), 252 aSize( nWidth, nHeight ), 253 eFrmHeightType( eSize ), 254 eFrmWidthType( ATT_FIX_SIZE ) 255 { 256 nWidthPercent = nHeightPercent = 0; 257 } 258 259 SwFmtFrmSize& SwFmtFrmSize::operator=( const SwFmtFrmSize& rCpy ) 260 { 261 aSize = rCpy.GetSize(); 262 eFrmHeightType = rCpy.GetHeightSizeType(); 263 eFrmWidthType = rCpy.GetWidthSizeType(); 264 nHeightPercent = rCpy.GetHeightPercent(); 265 nWidthPercent = rCpy.GetWidthPercent(); 266 return *this; 267 } 268 269 int SwFmtFrmSize::operator==( const SfxPoolItem& rAttr ) const 270 { 271 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 272 return( eFrmHeightType == ((SwFmtFrmSize&)rAttr).eFrmHeightType && 273 eFrmWidthType == ((SwFmtFrmSize&)rAttr).eFrmWidthType && 274 aSize == ((SwFmtFrmSize&)rAttr).GetSize()&& 275 nWidthPercent == ((SwFmtFrmSize&)rAttr).GetWidthPercent() && 276 nHeightPercent == ((SwFmtFrmSize&)rAttr).GetHeightPercent() ); 277 } 278 279 SfxPoolItem* SwFmtFrmSize::Clone( SfxItemPool* ) const 280 { 281 return new SwFmtFrmSize( *this ); 282 } 283 284 285 /* -----------------24.04.98 11:36------------------- 286 * 287 * --------------------------------------------------*/ 288 sal_Bool SwFmtFrmSize::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 289 { 290 // hier wird immer konvertiert! 291 nMemberId &= ~CONVERT_TWIPS; 292 switch ( nMemberId ) 293 { 294 case MID_FRMSIZE_SIZE: 295 { 296 awt::Size aTmp; 297 aTmp.Height = TWIP_TO_MM100(aSize.Height()); 298 aTmp.Width = TWIP_TO_MM100(aSize.Width()); 299 rVal.setValue(&aTmp, ::getCppuType((const awt::Size*)0)); 300 } 301 break; 302 case MID_FRMSIZE_REL_HEIGHT: 303 rVal <<= (sal_Int16)(GetHeightPercent() != 0xFF ? GetHeightPercent() : 0); 304 break; 305 case MID_FRMSIZE_REL_WIDTH: 306 rVal <<= (sal_Int16)(GetWidthPercent() != 0xFF ? GetWidthPercent() : 0); 307 break; 308 case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH: 309 { 310 sal_Bool bTmp = 0xFF == GetHeightPercent(); 311 rVal.setValue(&bTmp, ::getBooleanCppuType()); 312 } 313 break; 314 case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT: 315 { 316 sal_Bool bTmp = 0xFF == GetWidthPercent(); 317 rVal.setValue(&bTmp, ::getBooleanCppuType()); 318 } 319 break; 320 case MID_FRMSIZE_WIDTH : 321 rVal <<= (sal_Int32)TWIP_TO_MM100(aSize.Width()); 322 break; 323 case MID_FRMSIZE_HEIGHT: 324 // #95848# returned size should never be zero. 325 // (there was a bug that allowed for setting height to 0. 326 // Thus there some documents existing with that not allowed 327 // attribut value which may cause problems on import.) 328 rVal <<= (sal_Int32)TWIP_TO_MM100(aSize.Height() < MINLAY ? MINLAY : aSize.Height() ); 329 break; 330 case MID_FRMSIZE_SIZE_TYPE: 331 rVal <<= (sal_Int16)GetHeightSizeType(); 332 break; 333 case MID_FRMSIZE_IS_AUTO_HEIGHT: 334 { 335 sal_Bool bTmp = ATT_FIX_SIZE != GetHeightSizeType(); 336 rVal.setValue(&bTmp, ::getBooleanCppuType()); 337 } 338 break; 339 case MID_FRMSIZE_WIDTH_TYPE: 340 rVal <<= (sal_Int16)GetWidthSizeType(); 341 break; 342 } 343 return sal_True; 344 } 345 346 /* -----------------24.04.98 11:36------------------- 347 * 348 * --------------------------------------------------*/ 349 sal_Bool SwFmtFrmSize::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 350 { 351 sal_Bool bConvert = 0 != (nMemberId&CONVERT_TWIPS); 352 nMemberId &= ~CONVERT_TWIPS; 353 sal_Bool bRet = sal_True; 354 switch ( nMemberId ) 355 { 356 case MID_FRMSIZE_SIZE: 357 { 358 awt::Size aVal; 359 if(!(rVal >>= aVal)) 360 bRet = sal_False; 361 else 362 { 363 Size aTmp(aVal.Width, aVal.Height); 364 if(bConvert) 365 { 366 aTmp.Height() = MM100_TO_TWIP(aTmp.Height()); 367 aTmp.Width() = MM100_TO_TWIP(aTmp.Width()); 368 } 369 if(aTmp.Height() && aTmp.Width()) 370 aSize = aTmp; 371 else 372 bRet = sal_False; 373 } 374 } 375 break; 376 case MID_FRMSIZE_REL_HEIGHT: 377 { 378 sal_Int16 nSet = 0; 379 rVal >>= nSet; 380 if(nSet >= 0 && nSet <= 0xfe) 381 SetHeightPercent((sal_uInt8)nSet); 382 else 383 bRet = sal_False; 384 } 385 break; 386 case MID_FRMSIZE_REL_WIDTH: 387 { 388 sal_Int16 nSet = 0; 389 rVal >>= nSet; 390 if(nSet >= 0 && nSet <= 0xfe) 391 SetWidthPercent((sal_uInt8)nSet); 392 else 393 bRet = sal_False; 394 } 395 break; 396 case MID_FRMSIZE_IS_SYNC_HEIGHT_TO_WIDTH: 397 { 398 sal_Bool bSet = *(sal_Bool*)rVal.getValue(); 399 if(bSet) 400 SetHeightPercent(0xff); 401 else if( 0xff == GetHeightPercent() ) 402 SetHeightPercent( 0 ); 403 } 404 break; 405 case MID_FRMSIZE_IS_SYNC_WIDTH_TO_HEIGHT: 406 { 407 sal_Bool bSet = *(sal_Bool*)rVal.getValue(); 408 if(bSet) 409 SetWidthPercent(0xff); 410 else if( 0xff == GetWidthPercent() ) 411 SetWidthPercent(0); 412 } 413 break; 414 case MID_FRMSIZE_WIDTH : 415 { 416 sal_Int32 nWd = 0; 417 if(rVal >>= nWd) 418 { 419 if(bConvert) 420 nWd = MM100_TO_TWIP(nWd); 421 if(nWd < MINLAY) 422 nWd = MINLAY; 423 aSize.Width() = nWd; 424 } 425 else 426 bRet = sal_False; 427 } 428 break; 429 case MID_FRMSIZE_HEIGHT: 430 { 431 sal_Int32 nHg = 0; 432 if(rVal >>= nHg) 433 { 434 if(bConvert) 435 nHg = MM100_TO_TWIP(nHg); 436 if(nHg < MINLAY) 437 nHg = MINLAY; 438 aSize.Height() = nHg; 439 } 440 else 441 bRet = sal_False; 442 } 443 break; 444 case MID_FRMSIZE_SIZE_TYPE: 445 { 446 sal_Int16 nType = 0; 447 if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE ) 448 { 449 SetHeightSizeType((SwFrmSize)nType); 450 } 451 else 452 bRet = sal_False; 453 } 454 break; 455 case MID_FRMSIZE_IS_AUTO_HEIGHT: 456 { 457 sal_Bool bSet = *(sal_Bool*)rVal.getValue(); 458 SetHeightSizeType(bSet ? ATT_VAR_SIZE : ATT_FIX_SIZE); 459 } 460 break; 461 case MID_FRMSIZE_WIDTH_TYPE: 462 { 463 sal_Int16 nType = 0; 464 if((rVal >>= nType) && nType >= 0 && nType <= ATT_MIN_SIZE ) 465 { 466 SetWidthSizeType((SwFrmSize)nType); 467 } 468 else 469 bRet = sal_False; 470 } 471 break; 472 default: 473 bRet = sal_False; 474 } 475 return bRet; 476 } 477 478 // class SwFmtFillOrder 479 // Implementierung teilweise inline im hxx 480 481 SwFmtFillOrder::SwFmtFillOrder( SwFillOrder nFO ) 482 : SfxEnumItem( RES_FILL_ORDER, sal_uInt16(nFO) ) 483 {} 484 485 SfxPoolItem* SwFmtFillOrder::Clone( SfxItemPool* ) const 486 { 487 return new SwFmtFillOrder( GetFillOrder() ); 488 } 489 490 sal_uInt16 SwFmtFillOrder::GetValueCount() const 491 { 492 return SW_FILL_ORDER_END - SW_FILL_ORDER_BEGIN; 493 } 494 495 // class SwFmtHeader 496 // Implementierung teilweise inline im hxx 497 498 SwFmtHeader::SwFmtHeader( SwFrmFmt *pHeaderFmt ) 499 : SfxPoolItem( RES_HEADER ), 500 SwClient( pHeaderFmt ), 501 bActive( pHeaderFmt ? sal_True : sal_False ) 502 { 503 } 504 505 SwFmtHeader::SwFmtHeader( const SwFmtHeader &rCpy ) 506 : SfxPoolItem( RES_HEADER ), 507 SwClient( (SwModify*)rCpy.GetRegisteredIn() ), 508 bActive( rCpy.IsActive() ) 509 { 510 } 511 512 SwFmtHeader::SwFmtHeader( sal_Bool bOn ) 513 : SfxPoolItem( RES_HEADER ), 514 SwClient( 0 ), 515 bActive( bOn ) 516 { 517 } 518 519 SwFmtHeader::~SwFmtHeader() 520 { 521 if ( GetHeaderFmt() ) 522 DelHFFormat( this, GetHeaderFmt() ); 523 } 524 525 int SwFmtHeader::operator==( const SfxPoolItem& rAttr ) const 526 { 527 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 528 return ( GetRegisteredIn() == ((SwFmtHeader&)rAttr).GetRegisteredIn() && 529 bActive == ((SwFmtHeader&)rAttr).IsActive() ); 530 } 531 532 SfxPoolItem* SwFmtHeader::Clone( SfxItemPool* ) const 533 { 534 return new SwFmtHeader( *this ); 535 } 536 537 void SwFmtHeader::RegisterToFormat( SwFmt& rFmt ) 538 { 539 rFmt.Add(this); 540 } 541 542 // class SwFmtFooter 543 // Implementierung teilweise inline im hxx 544 545 SwFmtFooter::SwFmtFooter( SwFrmFmt *pFooterFmt ) 546 : SfxPoolItem( RES_FOOTER ), 547 SwClient( pFooterFmt ), 548 bActive( pFooterFmt ? sal_True : sal_False ) 549 { 550 } 551 552 SwFmtFooter::SwFmtFooter( const SwFmtFooter &rCpy ) 553 : SfxPoolItem( RES_FOOTER ), 554 SwClient( (SwModify*)rCpy.GetRegisteredIn() ), 555 bActive( rCpy.IsActive() ) 556 { 557 } 558 559 SwFmtFooter::SwFmtFooter( sal_Bool bOn ) 560 : SfxPoolItem( RES_FOOTER ), 561 SwClient( 0 ), 562 bActive( bOn ) 563 { 564 } 565 566 SwFmtFooter::~SwFmtFooter() 567 { 568 if ( GetFooterFmt() ) 569 DelHFFormat( this, GetFooterFmt() ); 570 } 571 572 void SwFmtFooter::RegisterToFormat( SwFmt& rFmt ) 573 { 574 rFmt.Add(this); 575 } 576 577 int SwFmtFooter::operator==( const SfxPoolItem& rAttr ) const 578 { 579 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 580 return ( GetRegisteredIn() == ((SwFmtFooter&)rAttr).GetRegisteredIn() && 581 bActive == ((SwFmtFooter&)rAttr).IsActive() ); 582 } 583 584 SfxPoolItem* SwFmtFooter::Clone( SfxItemPool* ) const 585 { 586 return new SwFmtFooter( *this ); 587 } 588 589 // class SwFmtCntnt 590 // Implementierung teilweise inline im hxx 591 592 SwFmtCntnt::SwFmtCntnt( const SwFmtCntnt &rCpy ) 593 : SfxPoolItem( RES_CNTNT ) 594 { 595 pStartNode = rCpy.GetCntntIdx() ? 596 new SwNodeIndex( *rCpy.GetCntntIdx() ) : 0; 597 } 598 599 SwFmtCntnt::SwFmtCntnt( const SwStartNode *pStartNd ) 600 : SfxPoolItem( RES_CNTNT ) 601 { 602 pStartNode = pStartNd ? new SwNodeIndex( *pStartNd ) : 0; 603 } 604 605 SwFmtCntnt::~SwFmtCntnt() 606 { 607 delete pStartNode; 608 } 609 610 void SwFmtCntnt::SetNewCntntIdx( const SwNodeIndex *pIdx ) 611 { 612 delete pStartNode; 613 pStartNode = pIdx ? new SwNodeIndex( *pIdx ) : 0; 614 } 615 616 int SwFmtCntnt::operator==( const SfxPoolItem& rAttr ) const 617 { 618 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 619 if( (long)pStartNode ^ (long)((SwFmtCntnt&)rAttr).pStartNode ) 620 return 0; 621 if( pStartNode ) 622 return ( *pStartNode == *((SwFmtCntnt&)rAttr).GetCntntIdx() ); 623 return 1; 624 } 625 626 SfxPoolItem* SwFmtCntnt::Clone( SfxItemPool* ) const 627 { 628 return new SwFmtCntnt( *this ); 629 } 630 631 // class SwFmtPageDesc 632 // Implementierung teilweise inline im hxx 633 634 SwFmtPageDesc::SwFmtPageDesc( const SwFmtPageDesc &rCpy ) 635 : SfxPoolItem( RES_PAGEDESC ), 636 SwClient( (SwPageDesc*)rCpy.GetPageDesc() ), 637 nNumOffset( rCpy.nNumOffset ), 638 nDescNameIdx( rCpy.nDescNameIdx ), 639 pDefinedIn( 0 ) 640 { 641 } 642 643 SwFmtPageDesc::SwFmtPageDesc( const SwPageDesc *pDesc ) 644 : SfxPoolItem( RES_PAGEDESC ), 645 SwClient( (SwPageDesc*)pDesc ), 646 nNumOffset( 0 ), 647 nDescNameIdx( 0xFFFF ), // IDX_NO_VALUE 648 pDefinedIn( 0 ) 649 { 650 } 651 652 SwFmtPageDesc::~SwFmtPageDesc() {} 653 654 bool SwFmtPageDesc::KnowsPageDesc() const 655 { 656 return (GetRegisteredIn() != 0); 657 } 658 659 int SwFmtPageDesc::operator==( const SfxPoolItem& rAttr ) const 660 { 661 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 662 return ( pDefinedIn == ((SwFmtPageDesc&)rAttr).pDefinedIn ) && 663 ( nNumOffset == ((SwFmtPageDesc&)rAttr).nNumOffset ) && 664 ( GetPageDesc() == ((SwFmtPageDesc&)rAttr).GetPageDesc() ); 665 } 666 667 SfxPoolItem* SwFmtPageDesc::Clone( SfxItemPool* ) const 668 { 669 return new SwFmtPageDesc( *this ); 670 } 671 672 void SwFmtPageDesc::SwClientNotify( const SwModify&, const SfxHint& rHint ) 673 { 674 const SwPageDescHint* pHint = dynamic_cast<const SwPageDescHint*>(&rHint); 675 if ( pHint ) 676 { 677 // mba: shouldn't that be broadcasted also? 678 SwFmtPageDesc aDfltDesc( pHint->GetPageDesc() ); 679 SwPageDesc* pDesc = pHint->GetPageDesc(); 680 const SwModify* pMod = GetDefinedIn(); 681 if ( pMod ) 682 { 683 if( pMod->ISA( SwCntntNode ) ) 684 ((SwCntntNode*)pMod)->SetAttr( aDfltDesc ); 685 else if( pMod->ISA( SwFmt )) 686 ((SwFmt*)pMod)->SetFmtAttr( aDfltDesc ); 687 else 688 { 689 DBG_ERROR( "What kind of SwModify is this?" ); 690 RegisterToPageDesc( *pDesc ); 691 } 692 } 693 else 694 // there could be an Undo-copy 695 RegisterToPageDesc( *pDesc ); 696 } 697 } 698 699 void SwFmtPageDesc::RegisterToPageDesc( SwPageDesc& rDesc ) 700 { 701 rDesc.Add( this ); 702 } 703 704 void SwFmtPageDesc::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew ) 705 { 706 if( !pDefinedIn ) 707 return; 708 709 const sal_uInt16 nWhichId = pOld ? pOld->Which() : pNew ? pNew->Which() : 0; 710 switch( nWhichId ) 711 { 712 case RES_OBJECTDYING: 713 //Der Pagedesc, bei dem ich angemeldet bin stirbt, ich trage 714 //mich also bei meinem Format aus. 715 //Dabei werden ich Deletet!!! 716 if( IS_TYPE( SwFmt, pDefinedIn )) 717 #ifdef DBG_UTIL 718 { 719 sal_Bool bDel = ((SwFmt*)pDefinedIn)->ResetFmtAttr( RES_PAGEDESC ); 720 ASSERT( bDel, ";-) FmtPageDesc nicht zerstoert." ); 721 } 722 #else 723 ((SwFmt*)pDefinedIn)->ResetFmtAttr( RES_PAGEDESC ); 724 #endif 725 else if( IS_TYPE( SwCntntNode, pDefinedIn )) 726 #ifdef DBG_UTIL 727 { 728 sal_Bool bDel = ((SwCntntNode*)pDefinedIn)->ResetAttr( RES_PAGEDESC ); 729 ASSERT( bDel, ";-) FmtPageDesc nicht zerstoert." ); 730 } 731 #else 732 ((SwCntntNode*)pDefinedIn)->ResetAttr( RES_PAGEDESC ); 733 #endif 734 break; 735 736 default: 737 /* do nothing */; 738 } 739 } 740 741 sal_Bool SwFmtPageDesc::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 742 { 743 // hier wird immer konvertiert! 744 nMemberId &= ~CONVERT_TWIPS; 745 sal_Bool bRet = sal_True; 746 switch ( nMemberId ) 747 { 748 case MID_PAGEDESC_PAGENUMOFFSET: 749 rVal <<= (sal_Int16)GetNumOffset(); 750 break; 751 752 case MID_PAGEDESC_PAGEDESCNAME: 753 { 754 const SwPageDesc* pDesc = GetPageDesc(); 755 if( pDesc ) 756 { 757 String aString; 758 SwStyleNameMapper::FillProgName(pDesc->GetName(), aString, nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC, sal_True ); 759 rVal <<= OUString( aString ); 760 } 761 else 762 rVal.clear(); 763 } 764 break; 765 default: 766 ASSERT( sal_False, "unknown MemberId" ); 767 bRet = sal_False; 768 } 769 return bRet; 770 } 771 772 sal_Bool SwFmtPageDesc::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 773 { 774 // hier wird immer konvertiert! 775 nMemberId &= ~CONVERT_TWIPS; 776 sal_Bool bRet = sal_True; 777 switch ( nMemberId ) 778 { 779 case MID_PAGEDESC_PAGENUMOFFSET: 780 { 781 sal_Int16 nOffset = 0; 782 if(rVal >>= nOffset) 783 SetNumOffset( nOffset ); 784 else 785 bRet = sal_False; 786 } 787 break; 788 789 case MID_PAGEDESC_PAGEDESCNAME: 790 /* geht nicht, weil das Attribut eigentlich nicht den Namen 791 * sondern einen Pointer auf den PageDesc braucht (ist Client davon). 792 * Der Pointer waere aber ueber den Namen nur vom Dokument zu erfragen. 793 */ 794 default: 795 ASSERT( sal_False, "unknown MemberId" ); 796 bRet = sal_False; 797 } 798 return bRet; 799 } 800 801 802 // class SwFmtCol 803 // Implementierung teilweise inline im hxx 804 805 SwColumn::SwColumn() : 806 nWish ( 0 ), 807 nUpper( 0 ), 808 nLower( 0 ), 809 nLeft ( 0 ), 810 nRight( 0 ) 811 { 812 } 813 814 sal_Bool SwColumn::operator==( const SwColumn &rCmp ) 815 { 816 return (nWish == rCmp.GetWishWidth() && 817 GetLeft() == rCmp.GetLeft() && 818 GetRight() == rCmp.GetRight() && 819 GetUpper() == rCmp.GetUpper() && 820 GetLower() == rCmp.GetLower()) ? sal_True : sal_False; 821 } 822 823 SwFmtCol::SwFmtCol( const SwFmtCol& rCpy ) 824 : SfxPoolItem( RES_COL ), 825 nLineWidth( rCpy.nLineWidth), 826 aLineColor( rCpy.aLineColor), 827 nLineHeight( rCpy.GetLineHeight() ), 828 eAdj( rCpy.GetLineAdj() ), 829 aColumns( (sal_Int8)rCpy.GetNumCols(), 1 ), 830 nWidth( rCpy.GetWishWidth() ), 831 aWidthAdjustValue( rCpy.aWidthAdjustValue ), 832 bOrtho( rCpy.IsOrtho() ) 833 { 834 for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i ) 835 { 836 SwColumn *pCol = new SwColumn( *rCpy.GetColumns()[i] ); 837 aColumns.Insert( pCol, aColumns.Count() ); 838 } 839 } 840 841 SwFmtCol::~SwFmtCol() {} 842 843 SwFmtCol& SwFmtCol::operator=( const SwFmtCol& rCpy ) 844 { 845 nLineWidth = rCpy.nLineWidth; 846 aLineColor = rCpy.aLineColor; 847 nLineHeight = rCpy.GetLineHeight(); 848 eAdj = rCpy.GetLineAdj(); 849 nWidth = rCpy.GetWishWidth(); 850 bOrtho = rCpy.IsOrtho(); 851 aWidthAdjustValue = rCpy.aWidthAdjustValue; 852 853 if ( aColumns.Count() ) 854 aColumns.DeleteAndDestroy( 0, aColumns.Count() ); 855 for ( sal_uInt16 i = 0; i < rCpy.GetNumCols(); ++i ) 856 { 857 SwColumn *pCol = new SwColumn( *rCpy.GetColumns()[i] ); 858 aColumns.Insert( pCol, aColumns.Count() ); 859 } 860 return *this; 861 } 862 863 SwFmtCol::SwFmtCol() 864 : SfxPoolItem( RES_COL ), 865 nLineWidth(0), 866 nLineHeight( 100 ), 867 eAdj( COLADJ_NONE ), 868 nWidth( USHRT_MAX ), 869 aWidthAdjustValue( 0 ), 870 bOrtho( sal_True ) 871 { 872 } 873 874 int SwFmtCol::operator==( const SfxPoolItem& rAttr ) const 875 { 876 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 877 const SwFmtCol &rCmp = (const SwFmtCol&)rAttr; 878 if( !(nLineWidth == rCmp.nLineWidth && 879 aLineColor == rCmp.aLineColor && 880 nLineHeight == rCmp.GetLineHeight() && 881 eAdj == rCmp.GetLineAdj() && 882 nWidth == rCmp.GetWishWidth() && 883 bOrtho == rCmp.IsOrtho() && 884 aColumns.Count() == rCmp.GetNumCols() && 885 aWidthAdjustValue == rCmp.GetAdjustValue() 886 ) ) 887 return 0; 888 889 for ( sal_uInt16 i = 0; i < aColumns.Count(); ++i ) 890 if ( !(*aColumns[i] == *rCmp.GetColumns()[i]) ) 891 return 0; 892 893 return 1; 894 } 895 896 SfxPoolItem* SwFmtCol::Clone( SfxItemPool* ) const 897 { 898 return new SwFmtCol( *this ); 899 } 900 901 sal_uInt16 SwFmtCol::GetGutterWidth( sal_Bool bMin ) const 902 { 903 sal_uInt16 nRet = 0; 904 if ( aColumns.Count() == 2 ) 905 nRet = aColumns[0]->GetRight() + aColumns[1]->GetLeft(); 906 else if ( aColumns.Count() > 2 ) 907 { 908 sal_Bool bSet = sal_False; 909 for ( sal_uInt16 i = 1; i < aColumns.Count()-1; ++i ) 910 { 911 const sal_uInt16 nTmp = aColumns[i]->GetRight() + aColumns[i+1]->GetLeft(); 912 if ( bSet ) 913 { 914 if ( nTmp != nRet ) 915 { 916 if ( !bMin ) 917 return USHRT_MAX; 918 if ( nRet > nTmp ) 919 nRet = nTmp; 920 } 921 } 922 else 923 { bSet = sal_True; 924 nRet = nTmp; 925 } 926 } 927 } 928 return nRet; 929 } 930 931 void SwFmtCol::SetGutterWidth( sal_uInt16 nNew, sal_uInt16 nAct ) 932 { 933 if ( bOrtho ) 934 Calc( nNew, nAct ); 935 else 936 { 937 sal_uInt16 nHalf = nNew / 2; 938 for ( sal_uInt16 i = 0; i < aColumns.Count(); ++i ) 939 { SwColumn *pCol = aColumns[i]; 940 pCol->SetLeft ( nHalf ); 941 pCol->SetRight( nHalf ); 942 if ( i == 0 ) 943 pCol->SetLeft( 0 ); 944 else if ( i == (aColumns.Count() - 1) ) 945 pCol->SetRight( 0 ); 946 } 947 } 948 } 949 950 void SwFmtCol::Init( sal_uInt16 nNumCols, sal_uInt16 nGutterWidth, sal_uInt16 nAct ) 951 { 952 //Loeschen scheint hier auf den erste Blick vielleicht etwas zu heftig; 953 //anderfalls muessten allerdings alle Werte der verbleibenden SwColumn's 954 //initialisiert werden. 955 if ( aColumns.Count() ) 956 aColumns.DeleteAndDestroy( 0, aColumns.Count() ); 957 for ( sal_uInt16 i = 0; i < nNumCols; ++i ) 958 { SwColumn *pCol = new SwColumn; 959 aColumns.Insert( pCol, i ); 960 } 961 bOrtho = sal_True; 962 nWidth = USHRT_MAX; 963 if( nNumCols ) 964 Calc( nGutterWidth, nAct ); 965 } 966 967 void SwFmtCol::SetOrtho( sal_Bool bNew, sal_uInt16 nGutterWidth, sal_uInt16 nAct ) 968 { 969 bOrtho = bNew; 970 if ( bNew && aColumns.Count() ) 971 Calc( nGutterWidth, nAct ); 972 } 973 974 sal_uInt16 SwFmtCol::CalcColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const 975 { 976 ASSERT( nCol < aColumns.Count(), ":-( ColumnsArr ueberindiziert." ); 977 if ( nWidth != nAct ) 978 { 979 long nW = aColumns[nCol]->GetWishWidth(); 980 nW *= nAct; 981 nW /= nWidth; 982 return sal_uInt16(nW); 983 } 984 else 985 return aColumns[nCol]->GetWishWidth(); 986 } 987 988 sal_uInt16 SwFmtCol::CalcPrtColWidth( sal_uInt16 nCol, sal_uInt16 nAct ) const 989 { 990 ASSERT( nCol < aColumns.Count(), ":-( ColumnsArr ueberindiziert." ); 991 sal_uInt16 nRet = CalcColWidth( nCol, nAct ); 992 SwColumn *pCol = aColumns[nCol]; 993 nRet = nRet - pCol->GetLeft(); 994 nRet = nRet - pCol->GetRight(); 995 return nRet; 996 } 997 998 void SwFmtCol::Calc( sal_uInt16 nGutterWidth, sal_uInt16 nAct ) 999 { 1000 if(!GetNumCols()) 1001 return; 1002 //Erstmal die Spalten mit der Aktuellen Breite einstellen, dann die 1003 //Wunschbreite der Spalten anhand der Gesamtwunschbreite hochrechnen. 1004 1005 const sal_uInt16 nGutterHalf = nGutterWidth ? nGutterWidth / 2 : 0; 1006 1007 //Breite der PrtAreas ist Gesamtbreite - Zwischenraeume / Anzahl 1008 const sal_uInt16 nPrtWidth = 1009 (nAct - ((GetNumCols()-1) * nGutterWidth)) / GetNumCols(); 1010 sal_uInt16 nAvail = nAct; 1011 1012 //Die erste Spalte ist PrtBreite + (Zwischenraumbreite/2) 1013 const sal_uInt16 nLeftWidth = nPrtWidth + nGutterHalf; 1014 SwColumn *pCol = aColumns[0]; 1015 pCol->SetWishWidth( nLeftWidth ); 1016 pCol->SetRight( nGutterHalf ); 1017 pCol->SetLeft ( 0 ); 1018 nAvail = nAvail - nLeftWidth; 1019 1020 //Spalte 2 bis n-1 ist PrtBreite + Zwischenraumbreite 1021 const sal_uInt16 nMidWidth = nPrtWidth + nGutterWidth; 1022 sal_uInt16 i; 1023 1024 for ( i = 1; i < GetNumCols()-1; ++i ) 1025 { 1026 pCol = aColumns[i]; 1027 pCol->SetWishWidth( nMidWidth ); 1028 pCol->SetLeft ( nGutterHalf ); 1029 pCol->SetRight( nGutterHalf ); 1030 nAvail = nAvail - nMidWidth; 1031 } 1032 1033 //Die Letzte Spalte entspricht wieder der ersten, um Rundungsfehler 1034 //auszugleichen wird der letzten Spalte alles zugeschlagen was die 1035 //anderen nicht verbraucht haben. 1036 pCol = aColumns[aColumns.Count()-1]; 1037 pCol->SetWishWidth( nAvail ); 1038 pCol->SetLeft ( nGutterHalf ); 1039 pCol->SetRight( 0 ); 1040 1041 //Umrechnen der aktuellen Breiten in Wunschbreiten. 1042 for ( i = 0; i < aColumns.Count(); ++i ) 1043 { 1044 pCol = aColumns[i]; 1045 long nTmp = pCol->GetWishWidth(); 1046 nTmp *= GetWishWidth(); 1047 nTmp /= nAct; 1048 pCol->SetWishWidth( sal_uInt16(nTmp) ); 1049 } 1050 } 1051 1052 sal_Bool SwFmtCol::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1053 { 1054 // hier wird immer konvertiert! 1055 nMemberId &= ~CONVERT_TWIPS; 1056 if(MID_COLUMN_SEPARATOR_LINE == nMemberId) 1057 { 1058 DBG_ERROR("not implemented"); 1059 } 1060 else 1061 { 1062 uno::Reference< text::XTextColumns > xCols = new SwXTextColumns(*this); 1063 rVal.setValue(&xCols, ::getCppuType((uno::Reference< text::XTextColumns>*)0)); 1064 } 1065 return sal_True; 1066 } 1067 1068 sal_Bool SwFmtCol::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1069 { 1070 // hier wird immer konvertiert! 1071 nMemberId &= ~CONVERT_TWIPS; 1072 sal_Bool bRet = sal_False; 1073 if(MID_COLUMN_SEPARATOR_LINE == nMemberId) 1074 { 1075 DBG_ERROR("not implemented"); 1076 } 1077 else 1078 { 1079 uno::Reference< text::XTextColumns > xCols; 1080 rVal >>= xCols; 1081 if(xCols.is()) 1082 { 1083 uno::Sequence<text::TextColumn> aSetColumns = xCols->getColumns(); 1084 const text::TextColumn* pArray = aSetColumns.getConstArray(); 1085 aColumns.DeleteAndDestroy(0, aColumns.Count()); 1086 //max. Count ist hier 64K - das kann das Array aber nicht 1087 sal_uInt16 nCount = Min( (sal_uInt16)aSetColumns.getLength(), 1088 (sal_uInt16) 0x3fff ); 1089 sal_uInt16 nWidthSum = 0; 1090 // #101224# one column is no column 1091 // 1092 if(nCount > 1) 1093 for(sal_uInt16 i = 0; i < nCount; i++) 1094 { 1095 SwColumn* pCol = new SwColumn; 1096 pCol->SetWishWidth( static_cast<sal_uInt16>(pArray[i].Width) ); 1097 nWidthSum = static_cast<sal_uInt16>(nWidthSum + pArray[i].Width); 1098 pCol->SetLeft ( static_cast<sal_uInt16>(MM100_TO_TWIP(pArray[i].LeftMargin)) ); 1099 pCol->SetRight( static_cast<sal_uInt16>(MM100_TO_TWIP(pArray[i].RightMargin)) ); 1100 aColumns.Insert(pCol, i); 1101 } 1102 bRet = sal_True; 1103 nWidth = nWidthSum; 1104 bOrtho = sal_False; 1105 1106 uno::Reference<lang::XUnoTunnel> xNumTunnel(xCols, uno::UNO_QUERY); 1107 SwXTextColumns* pSwColums = 0; 1108 if(xNumTunnel.is()) 1109 { 1110 pSwColums = reinterpret_cast< SwXTextColumns * >( 1111 sal::static_int_cast< sal_IntPtr >( 1112 xNumTunnel->getSomething( SwXTextColumns::getUnoTunnelId() ))); 1113 } 1114 if(pSwColums) 1115 { 1116 bOrtho = pSwColums->IsAutomaticWidth(); 1117 nLineWidth = pSwColums->GetSepLineWidth(); 1118 aLineColor.SetColor(pSwColums->GetSepLineColor()); 1119 nLineHeight = pSwColums->GetSepLineHeightRelative(); 1120 if(!pSwColums->GetSepLineIsOn()) 1121 eAdj = COLADJ_NONE; 1122 else switch(pSwColums->GetSepLineVertAlign()) 1123 { 1124 case 0: eAdj = COLADJ_TOP; break; //VerticalAlignment_TOP 1125 case 1: eAdj = COLADJ_CENTER;break; //VerticalAlignment_MIDDLE 1126 case 2: eAdj = COLADJ_BOTTOM;break; //VerticalAlignment_BOTTOM 1127 default: ASSERT( sal_False, "unknown alignment" ); break; 1128 } 1129 } 1130 } 1131 } 1132 return bRet; 1133 } 1134 1135 1136 // class SwFmtSurround 1137 // Implementierung teilweise inline im hxx 1138 1139 SwFmtSurround::SwFmtSurround( SwSurround eFly ) : 1140 SfxEnumItem( RES_SURROUND, sal_uInt16( eFly ) ) 1141 { 1142 bAnchorOnly = bContour = bOutside = sal_False; 1143 } 1144 1145 SwFmtSurround::SwFmtSurround( const SwFmtSurround &rCpy ) : 1146 SfxEnumItem( RES_SURROUND, rCpy.GetValue() ) 1147 { 1148 bAnchorOnly = rCpy.bAnchorOnly; 1149 bContour = rCpy.bContour; 1150 bOutside = rCpy.bOutside; 1151 } 1152 1153 int SwFmtSurround::operator==( const SfxPoolItem& rAttr ) const 1154 { 1155 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 1156 return ( GetValue() == ((SwFmtSurround&)rAttr).GetValue() && 1157 bAnchorOnly== ((SwFmtSurround&)rAttr).bAnchorOnly && 1158 bContour== ((SwFmtSurround&)rAttr).bContour && 1159 bOutside== ((SwFmtSurround&)rAttr).bOutside ); 1160 } 1161 1162 SfxPoolItem* SwFmtSurround::Clone( SfxItemPool* ) const 1163 { 1164 return new SwFmtSurround( *this ); 1165 } 1166 1167 sal_uInt16 SwFmtSurround::GetValueCount() const 1168 { 1169 return SURROUND_END - SURROUND_BEGIN; 1170 } 1171 1172 1173 sal_Bool SwFmtSurround::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1174 { 1175 // hier wird immer konvertiert! 1176 nMemberId &= ~CONVERT_TWIPS; 1177 sal_Bool bRet = sal_True; 1178 switch ( nMemberId ) 1179 { 1180 case MID_SURROUND_SURROUNDTYPE: 1181 rVal <<= (text::WrapTextMode)GetSurround(); 1182 break; 1183 case MID_SURROUND_ANCHORONLY: 1184 { 1185 sal_Bool bTmp = IsAnchorOnly(); 1186 rVal.setValue(&bTmp, ::getBooleanCppuType()); 1187 } 1188 break; 1189 case MID_SURROUND_CONTOUR: 1190 { 1191 sal_Bool bTmp = IsContour(); 1192 rVal.setValue(&bTmp, ::getBooleanCppuType()); 1193 } 1194 break; 1195 case MID_SURROUND_CONTOUROUTSIDE: 1196 { 1197 sal_Bool bTmp = IsOutside(); 1198 rVal.setValue(&bTmp, ::getBooleanCppuType()); 1199 } 1200 break; 1201 default: 1202 ASSERT( sal_False, "unknown MemberId" ); 1203 bRet = sal_False; 1204 } 1205 return bRet; 1206 } 1207 1208 sal_Bool SwFmtSurround::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1209 { 1210 // hier wird immer konvertiert! 1211 nMemberId &= ~CONVERT_TWIPS; 1212 sal_Bool bRet = sal_True; 1213 switch ( nMemberId ) 1214 { 1215 case MID_SURROUND_SURROUNDTYPE: 1216 { 1217 sal_Int32 eVal = SWUnoHelper::GetEnumAsInt32( rVal ); 1218 if( eVal >= 0 && eVal < (sal_Int16)SURROUND_END ) 1219 SetValue( static_cast<sal_uInt16>(eVal) ); 1220 else { 1221 //exception 1222 ; 1223 } 1224 } 1225 break; 1226 1227 case MID_SURROUND_ANCHORONLY: 1228 SetAnchorOnly( *(sal_Bool*)rVal.getValue() ); 1229 break; 1230 case MID_SURROUND_CONTOUR: 1231 SetContour( *(sal_Bool*)rVal.getValue() ); 1232 break; 1233 case MID_SURROUND_CONTOUROUTSIDE: 1234 SetOutside( *(sal_Bool*)rVal.getValue() ); 1235 break; 1236 default: 1237 ASSERT( sal_False, "unknown MemberId" ); 1238 bRet = sal_False; 1239 } 1240 return bRet; 1241 } 1242 1243 // class SwFmtVertOrient 1244 // Implementierung teilweise inline im hxx 1245 1246 SwFmtVertOrient::SwFmtVertOrient( SwTwips nY, sal_Int16 eVert, 1247 sal_Int16 eRel ) 1248 : SfxPoolItem( RES_VERT_ORIENT ), 1249 nYPos( nY ), 1250 eOrient( eVert ), 1251 eRelation( eRel ) 1252 {} 1253 1254 int SwFmtVertOrient::operator==( const SfxPoolItem& rAttr ) const 1255 { 1256 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 1257 return ( nYPos == ((SwFmtVertOrient&)rAttr).nYPos && 1258 eOrient == ((SwFmtVertOrient&)rAttr).eOrient && 1259 eRelation == ((SwFmtVertOrient&)rAttr).eRelation ); 1260 } 1261 1262 SfxPoolItem* SwFmtVertOrient::Clone( SfxItemPool* ) const 1263 { 1264 return new SwFmtVertOrient( nYPos, eOrient, eRelation ); 1265 } 1266 1267 sal_Bool SwFmtVertOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1268 { 1269 // hier wird immer konvertiert! 1270 nMemberId &= ~CONVERT_TWIPS; 1271 sal_Bool bRet = sal_True; 1272 switch ( nMemberId ) 1273 { 1274 case MID_VERTORIENT_ORIENT: 1275 { 1276 sal_Int16 nRet = text::VertOrientation::NONE; 1277 switch( eOrient ) 1278 { 1279 case text::VertOrientation::TOP : nRet = text::VertOrientation::TOP ;break; 1280 case text::VertOrientation::CENTER : nRet = text::VertOrientation::CENTER ;break; 1281 case text::VertOrientation::BOTTOM : nRet = text::VertOrientation::BOTTOM ;break; 1282 case text::VertOrientation::CHAR_TOP : nRet = text::VertOrientation::CHAR_TOP ;break; 1283 case text::VertOrientation::CHAR_CENTER: nRet = text::VertOrientation::CHAR_CENTER;break; 1284 case text::VertOrientation::CHAR_BOTTOM: nRet = text::VertOrientation::CHAR_BOTTOM;break; 1285 case text::VertOrientation::LINE_TOP : nRet = text::VertOrientation::LINE_TOP ;break; 1286 case text::VertOrientation::LINE_CENTER: nRet = text::VertOrientation::LINE_CENTER;break; 1287 case text::VertOrientation::LINE_BOTTOM: nRet = text::VertOrientation::LINE_BOTTOM;break; 1288 default: break; 1289 } 1290 rVal <<= nRet; 1291 } 1292 break; 1293 case MID_VERTORIENT_RELATION: 1294 rVal <<= lcl_RelToINT(eRelation); 1295 break; 1296 case MID_VERTORIENT_POSITION: 1297 rVal <<= (sal_Int32)TWIP_TO_MM100(GetPos()); 1298 break; 1299 default: 1300 ASSERT( sal_False, "unknown MemberId" ); 1301 bRet = sal_False; 1302 } 1303 return bRet; 1304 } 1305 1306 sal_Bool SwFmtVertOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1307 { 1308 sal_Bool bConvert = 0 != (nMemberId&CONVERT_TWIPS); 1309 nMemberId &= ~CONVERT_TWIPS; 1310 sal_Bool bRet = sal_True; 1311 switch ( nMemberId ) 1312 { 1313 case MID_VERTORIENT_ORIENT: 1314 { 1315 sal_uInt16 nVal = 0; 1316 rVal >>= nVal; 1317 switch( nVal ) 1318 { 1319 case text::VertOrientation::NONE: eOrient = text::VertOrientation::NONE; break; 1320 case text::VertOrientation::TOP : eOrient = text::VertOrientation::TOP; break; 1321 case text::VertOrientation::CENTER : eOrient = text::VertOrientation::CENTER; break; 1322 case text::VertOrientation::BOTTOM : eOrient = text::VertOrientation::BOTTOM; break; 1323 case text::VertOrientation::CHAR_TOP : eOrient = text::VertOrientation::CHAR_TOP; break; 1324 case text::VertOrientation::CHAR_CENTER: eOrient = text::VertOrientation::CHAR_CENTER;break; 1325 case text::VertOrientation::CHAR_BOTTOM: eOrient = text::VertOrientation::CHAR_BOTTOM;break; 1326 case text::VertOrientation::LINE_TOP : eOrient = text::VertOrientation::LINE_TOP; break; 1327 case text::VertOrientation::LINE_CENTER: eOrient = text::VertOrientation::LINE_CENTER;break; 1328 case text::VertOrientation::LINE_BOTTOM: eOrient = text::VertOrientation::LINE_BOTTOM;break; 1329 } 1330 } 1331 break; 1332 case MID_VERTORIENT_RELATION: 1333 { 1334 eRelation = lcl_IntToRelation(rVal); 1335 } 1336 break; 1337 case MID_VERTORIENT_POSITION: 1338 { 1339 sal_Int32 nVal = 0; 1340 rVal >>= nVal; 1341 if(bConvert) 1342 nVal = MM100_TO_TWIP(nVal); 1343 SetPos( nVal ); 1344 } 1345 break; 1346 default: 1347 ASSERT( sal_False, "unknown MemberId" ); 1348 bRet = sal_False; 1349 } 1350 return bRet; 1351 } 1352 1353 1354 1355 // class SwFmtHoriOrient 1356 // Implementierung teilweise inline im hxx 1357 1358 SwFmtHoriOrient::SwFmtHoriOrient( SwTwips nX, sal_Int16 eHori, 1359 sal_Int16 eRel, sal_Bool bPos ) 1360 : SfxPoolItem( RES_HORI_ORIENT ), 1361 nXPos( nX ), 1362 eOrient( eHori ), 1363 eRelation( eRel ), 1364 bPosToggle( bPos ) 1365 {} 1366 1367 int SwFmtHoriOrient::operator==( const SfxPoolItem& rAttr ) const 1368 { 1369 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 1370 return ( nXPos == ((SwFmtHoriOrient&)rAttr).nXPos && 1371 eOrient == ((SwFmtHoriOrient&)rAttr).eOrient && 1372 eRelation == ((SwFmtHoriOrient&)rAttr).eRelation && 1373 bPosToggle == ((SwFmtHoriOrient&)rAttr).bPosToggle ); 1374 } 1375 1376 SfxPoolItem* SwFmtHoriOrient::Clone( SfxItemPool* ) const 1377 { 1378 return new SwFmtHoriOrient( nXPos, eOrient, eRelation, bPosToggle ); 1379 } 1380 1381 sal_Bool SwFmtHoriOrient::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1382 { 1383 // hier wird immer konvertiert! 1384 nMemberId &= ~CONVERT_TWIPS; 1385 sal_Bool bRet = sal_True; 1386 switch ( nMemberId ) 1387 { 1388 case MID_HORIORIENT_ORIENT: 1389 { 1390 sal_Int16 nRet = text::HoriOrientation::NONE; 1391 switch( eOrient ) 1392 { 1393 case text::HoriOrientation::RIGHT: nRet = text::HoriOrientation::RIGHT; break; 1394 case text::HoriOrientation::CENTER : nRet = text::HoriOrientation::CENTER; break; 1395 case text::HoriOrientation::LEFT : nRet = text::HoriOrientation::LEFT; break; 1396 case text::HoriOrientation::INSIDE : nRet = text::HoriOrientation::INSIDE; break; 1397 case text::HoriOrientation::OUTSIDE: nRet = text::HoriOrientation::OUTSIDE; break; 1398 case text::HoriOrientation::FULL: nRet = text::HoriOrientation::FULL; break; 1399 case text::HoriOrientation::LEFT_AND_WIDTH : 1400 nRet = text::HoriOrientation::LEFT_AND_WIDTH; 1401 break; 1402 default: 1403 break; 1404 1405 } 1406 rVal <<= nRet; 1407 } 1408 break; 1409 case MID_HORIORIENT_RELATION: 1410 rVal <<= lcl_RelToINT(eRelation); 1411 break; 1412 case MID_HORIORIENT_POSITION: 1413 rVal <<= (sal_Int32)TWIP_TO_MM100(GetPos()); 1414 break; 1415 case MID_HORIORIENT_PAGETOGGLE: 1416 { 1417 sal_Bool bTmp = IsPosToggle(); 1418 rVal.setValue(&bTmp, ::getBooleanCppuType()); 1419 } 1420 break; 1421 default: 1422 ASSERT( sal_False, "unknown MemberId" ); 1423 bRet = sal_False; 1424 } 1425 return bRet; 1426 } 1427 1428 sal_Bool SwFmtHoriOrient::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1429 { 1430 sal_Bool bConvert = 0 != (nMemberId&CONVERT_TWIPS); 1431 nMemberId &= ~CONVERT_TWIPS; 1432 sal_Bool bRet = sal_True; 1433 switch ( nMemberId ) 1434 { 1435 case MID_HORIORIENT_ORIENT: 1436 { 1437 sal_Int16 nVal = 0; 1438 rVal >>= nVal; 1439 switch( nVal ) 1440 { 1441 case text::HoriOrientation::NONE: eOrient = text::HoriOrientation::NONE ; break; 1442 case text::HoriOrientation::RIGHT: eOrient = text::HoriOrientation::RIGHT; break; 1443 case text::HoriOrientation::CENTER : eOrient = text::HoriOrientation::CENTER; break; 1444 case text::HoriOrientation::LEFT : eOrient = text::HoriOrientation::LEFT; break; 1445 case text::HoriOrientation::INSIDE : eOrient = text::HoriOrientation::INSIDE; break; 1446 case text::HoriOrientation::OUTSIDE: eOrient = text::HoriOrientation::OUTSIDE; break; 1447 case text::HoriOrientation::FULL: eOrient = text::HoriOrientation::FULL; break; 1448 case text::HoriOrientation::LEFT_AND_WIDTH: 1449 eOrient = text::HoriOrientation::LEFT_AND_WIDTH; 1450 break; 1451 } 1452 } 1453 break; 1454 case MID_HORIORIENT_RELATION: 1455 { 1456 eRelation = lcl_IntToRelation(rVal); 1457 } 1458 break; 1459 case MID_HORIORIENT_POSITION: 1460 { 1461 sal_Int32 nVal = 0; 1462 if(!(rVal >>= nVal)) 1463 bRet = sal_False; 1464 if(bConvert) 1465 nVal = MM100_TO_TWIP(nVal); 1466 SetPos( nVal ); 1467 } 1468 break; 1469 case MID_HORIORIENT_PAGETOGGLE: 1470 SetPosToggle( *(sal_Bool*)rVal.getValue()); 1471 break; 1472 default: 1473 ASSERT( sal_False, "unknown MemberId" ); 1474 bRet = sal_False; 1475 } 1476 return bRet; 1477 } 1478 1479 1480 1481 // class SwFmtAnchor 1482 // Implementierung teilweise inline im hxx 1483 1484 SwFmtAnchor::SwFmtAnchor( RndStdIds nRnd, sal_uInt16 nPage ) 1485 : SfxPoolItem( RES_ANCHOR ), 1486 pCntntAnchor( 0 ), 1487 nAnchorId( nRnd ), 1488 nPageNum( nPage ), 1489 // OD 2004-05-05 #i28701# - get always new increased order number 1490 mnOrder( ++mnOrderCounter ) 1491 {} 1492 1493 SwFmtAnchor::SwFmtAnchor( const SwFmtAnchor &rCpy ) 1494 : SfxPoolItem( RES_ANCHOR ), 1495 nAnchorId( rCpy.GetAnchorId() ), 1496 nPageNum( rCpy.GetPageNum() ), 1497 // OD 2004-05-05 #i28701# - get always new increased order number 1498 mnOrder( ++mnOrderCounter ) 1499 { 1500 pCntntAnchor = rCpy.GetCntntAnchor() ? 1501 new SwPosition( *rCpy.GetCntntAnchor() ) : 0; 1502 } 1503 1504 SwFmtAnchor::~SwFmtAnchor() 1505 { 1506 delete pCntntAnchor; 1507 } 1508 1509 void SwFmtAnchor::SetAnchor( const SwPosition *pPos ) 1510 { 1511 if ( pCntntAnchor ) 1512 delete pCntntAnchor; 1513 pCntntAnchor = pPos ? new SwPosition( *pPos ) : 0; 1514 //AM Absatz gebundene Flys sollten nie in den Absatz hineinzeigen. 1515 if (pCntntAnchor && 1516 ((FLY_AT_PARA == nAnchorId) || (FLY_AT_FLY == nAnchorId))) 1517 { 1518 pCntntAnchor->nContent.Assign( 0, 0 ); 1519 } 1520 } 1521 1522 SwFmtAnchor& SwFmtAnchor::operator=(const SwFmtAnchor& rAnchor) 1523 { 1524 nAnchorId = rAnchor.GetAnchorId(); 1525 nPageNum = rAnchor.GetPageNum(); 1526 // OD 2004-05-05 #i28701# - get always new increased order number 1527 mnOrder = ++mnOrderCounter; 1528 1529 delete pCntntAnchor; 1530 pCntntAnchor = rAnchor.pCntntAnchor ? 1531 new SwPosition(*(rAnchor.pCntntAnchor)) : 0; 1532 return *this; 1533 } 1534 1535 int SwFmtAnchor::operator==( const SfxPoolItem& rAttr ) const 1536 { 1537 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 1538 // OD 2004-05-05 #i28701# - Note: <mnOrder> hasn't to be considered. 1539 return ( nAnchorId == ((SwFmtAnchor&)rAttr).GetAnchorId() && 1540 nPageNum == ((SwFmtAnchor&)rAttr).GetPageNum() && 1541 //Anker vergleichen. Entweder zeigen beide auf das gleiche 1542 //Attribut bzw. sind 0 oder die SwPosition* sind beide 1543 //gueltig und die SwPositions sind gleich. 1544 (pCntntAnchor == ((SwFmtAnchor&)rAttr).GetCntntAnchor() || 1545 (pCntntAnchor && ((SwFmtAnchor&)rAttr).GetCntntAnchor() && 1546 *pCntntAnchor == *((SwFmtAnchor&)rAttr).GetCntntAnchor()))); 1547 } 1548 1549 SfxPoolItem* SwFmtAnchor::Clone( SfxItemPool* ) const 1550 { 1551 return new SwFmtAnchor( *this ); 1552 } 1553 1554 // OD 2004-05-05 #i28701# 1555 sal_uInt32 SwFmtAnchor::mnOrderCounter = 0; 1556 1557 // OD 2004-05-05 #i28701# 1558 sal_uInt32 SwFmtAnchor::GetOrder() const 1559 { 1560 return mnOrder; 1561 } 1562 1563 /*-----------------16.02.98 15:21------------------- 1564 1565 --------------------------------------------------*/ 1566 sal_Bool SwFmtAnchor::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1567 { 1568 // hier wird immer konvertiert! 1569 nMemberId &= ~CONVERT_TWIPS; 1570 sal_Bool bRet = sal_True; 1571 switch ( nMemberId ) 1572 { 1573 case MID_ANCHOR_ANCHORTYPE: 1574 1575 text::TextContentAnchorType eRet; 1576 switch (GetAnchorId()) 1577 { 1578 case FLY_AT_CHAR: 1579 eRet = text::TextContentAnchorType_AT_CHARACTER; 1580 break; 1581 case FLY_AT_PAGE: 1582 eRet = text::TextContentAnchorType_AT_PAGE; 1583 break; 1584 case FLY_AT_FLY: 1585 eRet = text::TextContentAnchorType_AT_FRAME; 1586 break; 1587 case FLY_AS_CHAR: 1588 eRet = text::TextContentAnchorType_AS_CHARACTER; 1589 break; 1590 //case FLY_AT_PARA: 1591 default: 1592 eRet = text::TextContentAnchorType_AT_PARAGRAPH; 1593 } 1594 rVal <<= eRet; 1595 break; 1596 case MID_ANCHOR_PAGENUM: 1597 rVal <<= (sal_Int16)GetPageNum(); 1598 break; 1599 case MID_ANCHOR_ANCHORFRAME: 1600 { 1601 if(pCntntAnchor && FLY_AT_FLY == nAnchorId) 1602 { 1603 SwFrmFmt* pFmt = pCntntAnchor->nNode.GetNode().GetFlyFmt(); 1604 if(pFmt) 1605 { 1606 uno::Reference<container::XNamed> xNamed = SwXFrames::GetObject( *pFmt, FLYCNTTYPE_FRM ); 1607 uno::Reference<text::XTextFrame> xRet(xNamed, uno::UNO_QUERY); 1608 rVal <<= xRet; 1609 } 1610 } 1611 } 1612 break; 1613 default: 1614 ASSERT( sal_False, "unknown MemberId" ); 1615 bRet = sal_False; 1616 } 1617 return bRet; 1618 } 1619 1620 sal_Bool SwFmtAnchor::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1621 { 1622 // hier wird immer konvertiert! 1623 nMemberId &= ~CONVERT_TWIPS; 1624 sal_Bool bRet = sal_True; 1625 switch ( nMemberId ) 1626 { 1627 case MID_ANCHOR_ANCHORTYPE: 1628 { 1629 RndStdIds eAnchor; 1630 switch( SWUnoHelper::GetEnumAsInt32( rVal ) ) 1631 { 1632 case text::TextContentAnchorType_AS_CHARACTER: 1633 eAnchor = FLY_AS_CHAR; 1634 break; 1635 case text::TextContentAnchorType_AT_PAGE: 1636 eAnchor = FLY_AT_PAGE; 1637 if( GetPageNum() > 0 && pCntntAnchor ) 1638 { 1639 // If the anchor type is page and a valid page number 1640 // has been set, the content position isn't required 1641 // any longer. 1642 delete pCntntAnchor; 1643 pCntntAnchor = 0; 1644 } 1645 break; 1646 case text::TextContentAnchorType_AT_FRAME: 1647 eAnchor = FLY_AT_FLY; 1648 break; 1649 case text::TextContentAnchorType_AT_CHARACTER: 1650 eAnchor = FLY_AT_CHAR; 1651 break; 1652 //case text::TextContentAnchorType_AT_PARAGRAPH: 1653 default: 1654 eAnchor = FLY_AT_PARA; 1655 break; 1656 } 1657 SetType( eAnchor ); 1658 } 1659 break; 1660 case MID_ANCHOR_PAGENUM: 1661 { 1662 sal_Int16 nVal = 0; 1663 if((rVal >>= nVal) && nVal > 0) 1664 { 1665 SetPageNum( nVal ); 1666 if ((FLY_AT_PAGE == GetAnchorId()) && pCntntAnchor) 1667 { 1668 // If the anchor type is page and a valid page number 1669 // is set, the content paoition has to be deleted to not 1670 // confuse the layout (frmtool.cxx). However, if the 1671 // anchor type is not page, any content position will 1672 // be kept. 1673 delete pCntntAnchor; 1674 pCntntAnchor = 0; 1675 } 1676 } 1677 else 1678 bRet = sal_False; 1679 } 1680 break; 1681 case MID_ANCHOR_ANCHORFRAME: 1682 //no break here!; 1683 default: 1684 ASSERT( sal_False, "unknown MemberId" ); 1685 bRet = sal_False; 1686 } 1687 return bRet; 1688 } 1689 1690 // class SwFmtURL 1691 // Implementierung teilweise inline im hxx 1692 1693 SwFmtURL::SwFmtURL() : 1694 SfxPoolItem( RES_URL ), 1695 pMap( 0 ), 1696 bIsServerMap( sal_False ) 1697 { 1698 } 1699 1700 SwFmtURL::SwFmtURL( const SwFmtURL &rURL) : 1701 SfxPoolItem( RES_URL ), 1702 sTargetFrameName( rURL.GetTargetFrameName() ), 1703 sURL( rURL.GetURL() ), 1704 sName( rURL.GetName() ), 1705 bIsServerMap( rURL.IsServerMap() ) 1706 { 1707 pMap = rURL.GetMap() ? new ImageMap( *rURL.GetMap() ) : 0; 1708 } 1709 1710 SwFmtURL::~SwFmtURL() 1711 { 1712 if ( pMap ) 1713 delete pMap; 1714 } 1715 1716 int SwFmtURL::operator==( const SfxPoolItem &rAttr ) const 1717 { 1718 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 1719 const SwFmtURL &rCmp = (SwFmtURL&)rAttr; 1720 sal_Bool bRet = bIsServerMap == rCmp.IsServerMap() && 1721 sURL == rCmp.GetURL() && 1722 sTargetFrameName == rCmp.GetTargetFrameName() && 1723 sName == rCmp.GetName(); 1724 if ( bRet ) 1725 { 1726 if ( pMap && rCmp.GetMap() ) 1727 bRet = *pMap == *rCmp.GetMap(); 1728 else 1729 bRet = pMap == rCmp.GetMap(); 1730 } 1731 return bRet; 1732 } 1733 1734 SfxPoolItem* SwFmtURL::Clone( SfxItemPool* ) const 1735 { 1736 return new SwFmtURL( *this ); 1737 } 1738 1739 void SwFmtURL::SetURL( const XubString &rURL, sal_Bool bServerMap ) 1740 { 1741 sURL = rURL; 1742 bIsServerMap = bServerMap; 1743 } 1744 1745 void SwFmtURL::SetMap( const ImageMap *pM ) 1746 { 1747 if ( pMap ) 1748 delete pMap; 1749 pMap = pM ? new ImageMap( *pM ) : 0; 1750 } 1751 extern const SvEventDescription* lcl_GetSupportedMacroItems(); 1752 1753 sal_Bool SwFmtURL::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1754 { 1755 // hier wird immer konvertiert! 1756 nMemberId &= ~CONVERT_TWIPS; 1757 sal_Bool bRet = sal_True; 1758 switch ( nMemberId ) 1759 { 1760 case MID_URL_URL: 1761 { 1762 OUString sRet = GetURL(); 1763 rVal <<= sRet; 1764 } 1765 break; 1766 case MID_URL_TARGET: 1767 { 1768 OUString sRet = GetTargetFrameName(); 1769 rVal <<= sRet; 1770 } 1771 break; 1772 case MID_URL_HYPERLINKNAME: 1773 rVal <<= OUString( GetName() ); 1774 break; 1775 case MID_URL_CLIENTMAP: 1776 { 1777 uno::Reference< uno::XInterface > xInt; 1778 if(pMap) 1779 { 1780 xInt = SvUnoImageMap_createInstance( *pMap, lcl_GetSupportedMacroItems() ); 1781 } 1782 else 1783 { 1784 ImageMap aEmptyMap; 1785 xInt = SvUnoImageMap_createInstance( aEmptyMap, lcl_GetSupportedMacroItems() ); 1786 } 1787 uno::Reference< container::XIndexContainer > xCont(xInt, uno::UNO_QUERY); 1788 rVal <<= xCont; 1789 } 1790 break; 1791 case MID_URL_SERVERMAP: 1792 { 1793 sal_Bool bTmp = IsServerMap(); 1794 rVal.setValue(&bTmp, ::getBooleanCppuType()); 1795 } 1796 break; 1797 default: 1798 ASSERT( sal_False, "unknown MemberId" ); 1799 bRet = sal_False; 1800 } 1801 return bRet; 1802 } 1803 1804 sal_Bool SwFmtURL::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1805 { 1806 // hier wird immer konvertiert! 1807 nMemberId &= ~CONVERT_TWIPS; 1808 sal_Bool bRet = sal_True; 1809 switch ( nMemberId ) 1810 { 1811 case MID_URL_URL: 1812 { 1813 OUString sTmp; 1814 rVal >>= sTmp; 1815 SetURL( sTmp, bIsServerMap ); 1816 } 1817 break; 1818 case MID_URL_TARGET: 1819 { 1820 OUString sTmp; 1821 rVal >>= sTmp; 1822 SetTargetFrameName( sTmp ); 1823 } 1824 break; 1825 case MID_URL_HYPERLINKNAME: 1826 { 1827 OUString sTmp; 1828 rVal >>= sTmp; 1829 SetName( sTmp ); 1830 } 1831 break; 1832 case MID_URL_CLIENTMAP: 1833 { 1834 uno::Reference<container::XIndexContainer> xCont; 1835 if(!rVal.hasValue()) 1836 DELETEZ(pMap); 1837 else if(rVal >>= xCont) 1838 { 1839 if(!pMap) 1840 pMap = new ImageMap; 1841 bRet = SvUnoImageMap_fillImageMap( xCont, *pMap ); 1842 } 1843 else 1844 bRet = sal_False; 1845 } 1846 break; 1847 case MID_URL_SERVERMAP: 1848 bIsServerMap = *(sal_Bool*)rVal.getValue(); 1849 break; 1850 default: 1851 ASSERT( sal_False, "unknown MemberId" ); 1852 bRet = sal_False; 1853 } 1854 return bRet; 1855 } 1856 1857 1858 // class SwNoReadOnly 1859 1860 SfxPoolItem* SwFmtEditInReadonly::Clone( SfxItemPool* ) const 1861 { 1862 return new SwFmtEditInReadonly( Which(), GetValue() ); 1863 } 1864 1865 // class SwFmtLayoutSplit 1866 1867 SfxPoolItem* SwFmtLayoutSplit::Clone( SfxItemPool* ) const 1868 { 1869 return new SwFmtLayoutSplit( GetValue() ); 1870 } 1871 1872 // class SwFmtRowSplit 1873 1874 SfxPoolItem* SwFmtRowSplit::Clone( SfxItemPool* ) const 1875 { 1876 return new SwFmtRowSplit( GetValue() ); 1877 } 1878 1879 1880 // class SwFmtNoBalancedColumns 1881 1882 SfxPoolItem* SwFmtNoBalancedColumns::Clone( SfxItemPool* ) const 1883 { 1884 return new SwFmtNoBalancedColumns( GetValue() ); 1885 } 1886 1887 // class SwFmtFtnEndAtTxtEnd 1888 1889 sal_uInt16 SwFmtFtnEndAtTxtEnd::GetValueCount() const 1890 { 1891 return sal_uInt16( FTNEND_ATTXTEND_END ); 1892 } 1893 1894 SwFmtFtnEndAtTxtEnd& SwFmtFtnEndAtTxtEnd::operator=( 1895 const SwFmtFtnEndAtTxtEnd& rAttr ) 1896 { 1897 SfxEnumItem::SetValue( rAttr.GetValue() ); 1898 aFmt = rAttr.aFmt; 1899 nOffset = rAttr.nOffset; 1900 sPrefix = rAttr.sPrefix; 1901 sSuffix = rAttr.sSuffix; 1902 return *this; 1903 } 1904 1905 int SwFmtFtnEndAtTxtEnd::operator==( const SfxPoolItem& rItem ) const 1906 { 1907 const SwFmtFtnEndAtTxtEnd& rAttr = (SwFmtFtnEndAtTxtEnd&)rItem; 1908 return SfxEnumItem::operator==( rAttr ) && 1909 aFmt.GetNumberingType() == rAttr.aFmt.GetNumberingType() && 1910 nOffset == rAttr.nOffset && 1911 sPrefix == rAttr.sPrefix && 1912 sSuffix == rAttr.sSuffix; 1913 } 1914 1915 sal_Bool SwFmtFtnEndAtTxtEnd::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 1916 { 1917 nMemberId &= ~CONVERT_TWIPS; 1918 switch(nMemberId) 1919 { 1920 case MID_COLLECT : 1921 { 1922 sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND; 1923 rVal.setValue(&bVal, ::getBooleanCppuType()); 1924 } 1925 break; 1926 case MID_RESTART_NUM : 1927 { 1928 sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ; 1929 rVal.setValue(&bVal, ::getBooleanCppuType()); 1930 } 1931 break; 1932 case MID_NUM_START_AT: rVal <<= (sal_Int16) nOffset; break; 1933 case MID_OWN_NUM : 1934 { 1935 sal_Bool bVal = GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT; 1936 rVal.setValue(&bVal, ::getBooleanCppuType()); 1937 } 1938 break; 1939 case MID_NUM_TYPE : rVal <<= aFmt.GetNumberingType(); break; 1940 case MID_PREFIX : rVal <<= OUString(sPrefix); break; 1941 case MID_SUFFIX : rVal <<= OUString(sSuffix); break; 1942 default: return sal_False; 1943 } 1944 return sal_True; 1945 } 1946 1947 sal_Bool SwFmtFtnEndAtTxtEnd::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 1948 { 1949 sal_Bool bRet = sal_True; 1950 nMemberId &= ~CONVERT_TWIPS; 1951 switch(nMemberId) 1952 { 1953 case MID_COLLECT : 1954 { 1955 sal_Bool bVal = *(sal_Bool*)rVal.getValue(); 1956 if(!bVal && GetValue() >= FTNEND_ATTXTEND) 1957 SetValue(FTNEND_ATPGORDOCEND); 1958 else if(bVal && GetValue() < FTNEND_ATTXTEND) 1959 SetValue(FTNEND_ATTXTEND); 1960 } 1961 break; 1962 case MID_RESTART_NUM : 1963 { 1964 sal_Bool bVal = *(sal_Bool*)rVal.getValue(); 1965 if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMSEQ) 1966 SetValue(FTNEND_ATTXTEND); 1967 else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMSEQ) 1968 SetValue(FTNEND_ATTXTEND_OWNNUMSEQ); 1969 } 1970 break; 1971 case MID_NUM_START_AT: 1972 { 1973 sal_Int16 nVal = 0; 1974 rVal >>= nVal; 1975 if(nVal >= 0) 1976 nOffset = nVal; 1977 else 1978 bRet = sal_False; 1979 } 1980 break; 1981 case MID_OWN_NUM : 1982 { 1983 sal_Bool bVal = *(sal_Bool*)rVal.getValue(); 1984 if(!bVal && GetValue() >= FTNEND_ATTXTEND_OWNNUMANDFMT) 1985 SetValue(FTNEND_ATTXTEND_OWNNUMSEQ); 1986 else if(bVal && GetValue() < FTNEND_ATTXTEND_OWNNUMANDFMT) 1987 SetValue(FTNEND_ATTXTEND_OWNNUMANDFMT); 1988 } 1989 break; 1990 case MID_NUM_TYPE : 1991 { 1992 sal_Int16 nVal = 0; 1993 rVal >>= nVal; 1994 if(nVal >= 0 && 1995 (nVal <= SVX_NUM_ARABIC || 1996 SVX_NUM_CHARS_UPPER_LETTER_N == nVal || 1997 SVX_NUM_CHARS_LOWER_LETTER_N == nVal )) 1998 aFmt.SetNumberingType(nVal); 1999 else 2000 bRet = sal_False; 2001 } 2002 break; 2003 case MID_PREFIX : 2004 { 2005 OUString sVal; rVal >>= sVal; 2006 sPrefix = sVal; 2007 } 2008 break; 2009 case MID_SUFFIX : 2010 { 2011 OUString sVal; rVal >>= sVal; 2012 sSuffix = sVal; 2013 } 2014 break; 2015 default: bRet = sal_False; 2016 } 2017 return bRet; 2018 } 2019 2020 2021 // class SwFmtFtnAtTxtEnd 2022 2023 SfxPoolItem* SwFmtFtnAtTxtEnd::Clone( SfxItemPool* ) const 2024 { 2025 SwFmtFtnAtTxtEnd* pNew = new SwFmtFtnAtTxtEnd; 2026 *pNew = *this; 2027 return pNew; 2028 } 2029 2030 // class SwFmtEndAtTxtEnd 2031 2032 SfxPoolItem* SwFmtEndAtTxtEnd::Clone( SfxItemPool* ) const 2033 { 2034 SwFmtEndAtTxtEnd* pNew = new SwFmtEndAtTxtEnd; 2035 *pNew = *this; 2036 return pNew; 2037 } 2038 2039 //class SwFmtChain 2040 2041 2042 int SwFmtChain::operator==( const SfxPoolItem &rAttr ) const 2043 { 2044 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 2045 2046 return GetPrev() == ((SwFmtChain&)rAttr).GetPrev() && 2047 GetNext() == ((SwFmtChain&)rAttr).GetNext(); 2048 } 2049 2050 SwFmtChain::SwFmtChain( const SwFmtChain &rCpy ) : 2051 SfxPoolItem( RES_CHAIN ) 2052 { 2053 SetPrev( rCpy.GetPrev() ); 2054 SetNext( rCpy.GetNext() ); 2055 } 2056 2057 SfxPoolItem* SwFmtChain::Clone( SfxItemPool* ) const 2058 { 2059 SwFmtChain *pRet = new SwFmtChain; 2060 pRet->SetPrev( GetPrev() ); 2061 pRet->SetNext( GetNext() ); 2062 return pRet; 2063 } 2064 2065 void SwFmtChain::SetPrev( SwFlyFrmFmt *pFmt ) 2066 { 2067 if ( pFmt ) 2068 pFmt->Add( &aPrev ); 2069 else if ( aPrev.GetRegisteredIn() ) 2070 ((SwModify*)aPrev.GetRegisteredIn())->Remove( &aPrev ); 2071 } 2072 2073 void SwFmtChain::SetNext( SwFlyFrmFmt *pFmt ) 2074 { 2075 if ( pFmt ) 2076 pFmt->Add( &aNext ); 2077 else if ( aNext.GetRegisteredIn() ) 2078 ((SwModify*)aNext.GetRegisteredIn())->Remove( &aNext ); 2079 } 2080 2081 sal_Bool SwFmtChain::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 2082 { 2083 // hier wird immer konvertiert! 2084 nMemberId &= ~CONVERT_TWIPS; 2085 sal_Bool bRet = sal_True; 2086 XubString aRet; 2087 switch ( nMemberId ) 2088 { 2089 case MID_CHAIN_PREVNAME: 2090 if ( GetPrev() ) 2091 aRet = GetPrev()->GetName(); 2092 break; 2093 case MID_CHAIN_NEXTNAME: 2094 if ( GetNext() ) 2095 aRet = GetNext()->GetName(); 2096 break; 2097 default: 2098 ASSERT( sal_False, "unknown MemberId" ); 2099 bRet = sal_False; 2100 } 2101 rVal <<= OUString(aRet); 2102 return bRet; 2103 } 2104 2105 2106 2107 2108 //class SwFmtLineNumber 2109 2110 SwFmtLineNumber::SwFmtLineNumber() : 2111 SfxPoolItem( RES_LINENUMBER ) 2112 { 2113 nStartValue = 0; 2114 bCountLines = sal_True; 2115 } 2116 2117 SwFmtLineNumber::~SwFmtLineNumber() 2118 { 2119 } 2120 2121 int SwFmtLineNumber::operator==( const SfxPoolItem &rAttr ) const 2122 { 2123 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 2124 2125 return nStartValue == ((SwFmtLineNumber&)rAttr).GetStartValue() && 2126 bCountLines == ((SwFmtLineNumber&)rAttr).IsCount(); 2127 } 2128 2129 SfxPoolItem* SwFmtLineNumber::Clone( SfxItemPool* ) const 2130 { 2131 return new SwFmtLineNumber( *this ); 2132 } 2133 2134 sal_Bool SwFmtLineNumber::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 2135 { 2136 // hier wird immer konvertiert! 2137 nMemberId &= ~CONVERT_TWIPS; 2138 sal_Bool bRet = sal_True; 2139 switch ( nMemberId ) 2140 { 2141 case MID_LINENUMBER_COUNT: 2142 { 2143 sal_Bool bTmp = IsCount(); 2144 rVal.setValue(&bTmp, ::getBooleanCppuType()); 2145 } 2146 break; 2147 case MID_LINENUMBER_STARTVALUE: 2148 rVal <<= (sal_Int32)GetStartValue(); 2149 break; 2150 default: 2151 ASSERT( sal_False, "unknown MemberId" ); 2152 bRet = sal_False; 2153 } 2154 return bRet; 2155 } 2156 2157 sal_Bool SwFmtLineNumber::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 2158 { 2159 // hier wird immer konvertiert! 2160 nMemberId &= ~CONVERT_TWIPS; 2161 sal_Bool bRet = sal_True; 2162 switch ( nMemberId ) 2163 { 2164 case MID_LINENUMBER_COUNT: 2165 SetCountLines( *(sal_Bool*)rVal.getValue() ); 2166 break; 2167 case MID_LINENUMBER_STARTVALUE: 2168 { 2169 sal_Int32 nVal = 0; 2170 if(rVal >>= nVal) 2171 SetStartValue( nVal ); 2172 else 2173 bRet = sal_False; 2174 } 2175 break; 2176 default: 2177 ASSERT( sal_False, "unknown MemberId" ); 2178 bRet = sal_False; 2179 } 2180 return bRet; 2181 } 2182 2183 /************************************************************************* 2184 * class SwTextGridItem 2185 *************************************************************************/ 2186 2187 SwTextGridItem::SwTextGridItem() 2188 : SfxPoolItem( RES_TEXTGRID ) 2189 , aColor( COL_LIGHTGRAY ) 2190 , nLines( 20 ) 2191 , nBaseHeight( 400 ) 2192 , nRubyHeight( 200 ) 2193 , eGridType( GRID_NONE ) 2194 , bRubyTextBelow( 0 ) 2195 , bPrintGrid( 1 ) 2196 , bDisplayGrid( 1 ) 2197 , nBaseWidth( 400 ) 2198 , bSnapToChars( 1 ) 2199 , bSquaredMode( 1 ) 2200 { 2201 } 2202 2203 SwTextGridItem::~SwTextGridItem() 2204 { 2205 } 2206 2207 int SwTextGridItem::operator==( const SfxPoolItem& rAttr ) const 2208 { 2209 ASSERT( SfxPoolItem::operator==( rAttr ), "keine gleichen Attribute" ); 2210 return eGridType == ((SwTextGridItem&)rAttr).GetGridType() && 2211 nLines == ((SwTextGridItem&)rAttr).GetLines() && 2212 nBaseHeight == ((SwTextGridItem&)rAttr).GetBaseHeight() && 2213 nRubyHeight == ((SwTextGridItem&)rAttr).GetRubyHeight() && 2214 bRubyTextBelow == ((SwTextGridItem&)rAttr).GetRubyTextBelow() && 2215 bDisplayGrid == ((SwTextGridItem&)rAttr).GetDisplayGrid() && 2216 bPrintGrid == ((SwTextGridItem&)rAttr).GetPrintGrid() && 2217 aColor == ((SwTextGridItem&)rAttr).GetColor() && 2218 nBaseWidth == ((SwTextGridItem&)rAttr).GetBaseWidth() && 2219 bSnapToChars == ((SwTextGridItem&)rAttr).GetSnapToChars() && 2220 bSquaredMode == ((SwTextGridItem&)rAttr).GetSquaredMode(); 2221 } 2222 2223 SfxPoolItem* SwTextGridItem::Clone( SfxItemPool* ) const 2224 { 2225 return new SwTextGridItem( *this ); 2226 } 2227 2228 SwTextGridItem& SwTextGridItem::operator=( const SwTextGridItem& rCpy ) 2229 { 2230 aColor = rCpy.GetColor(); 2231 nLines = rCpy.GetLines(); 2232 nBaseHeight = rCpy.GetBaseHeight(); 2233 nRubyHeight = rCpy.GetRubyHeight(); 2234 eGridType = rCpy.GetGridType(); 2235 bRubyTextBelow = rCpy.GetRubyTextBelow(); 2236 bPrintGrid = rCpy.GetPrintGrid(); 2237 bDisplayGrid = rCpy.GetDisplayGrid(); 2238 nBaseWidth = rCpy.GetBaseWidth(); 2239 bSnapToChars = rCpy.GetSnapToChars(); 2240 bSquaredMode = rCpy.GetSquaredMode(); 2241 2242 return *this; 2243 } 2244 2245 sal_Bool SwTextGridItem::QueryValue( uno::Any& rVal, sal_uInt8 nMemberId ) const 2246 { 2247 sal_Bool bRet = sal_True; 2248 2249 switch( nMemberId & ~CONVERT_TWIPS ) 2250 { 2251 case MID_GRID_COLOR: 2252 rVal <<= GetColor().GetColor(); 2253 break; 2254 case MID_GRID_LINES: 2255 rVal <<= GetLines(); 2256 break; 2257 case MID_GRID_RUBY_BELOW: 2258 rVal.setValue( &bRubyTextBelow, ::getBooleanCppuType() ); 2259 break; 2260 case MID_GRID_PRINT: 2261 rVal.setValue( &bPrintGrid, ::getBooleanCppuType() ); 2262 break; 2263 case MID_GRID_DISPLAY: 2264 rVal.setValue( &bDisplayGrid, ::getBooleanCppuType() ); 2265 break; 2266 case MID_GRID_BASEHEIGHT: 2267 DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0, 2268 "This value needs TWIPS-MM100 conversion" ); 2269 rVal <<= (sal_Int32) TWIP_TO_MM100_UNSIGNED(nBaseHeight); 2270 break; 2271 case MID_GRID_BASEWIDTH: 2272 DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0, 2273 "This value needs TWIPS-MM100 conversion" ); 2274 rVal <<= (sal_Int32) TWIP_TO_MM100_UNSIGNED(nBaseWidth); 2275 break; 2276 case MID_GRID_RUBYHEIGHT: 2277 DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0, 2278 "This value needs TWIPS-MM100 conversion" ); 2279 rVal <<= (sal_Int32)TWIP_TO_MM100_UNSIGNED(nRubyHeight); 2280 break; 2281 case MID_GRID_TYPE: 2282 switch( GetGridType() ) 2283 { 2284 case GRID_NONE: 2285 rVal <<= text::TextGridMode::NONE; 2286 break; 2287 case GRID_LINES_ONLY: 2288 rVal <<= text::TextGridMode::LINES; 2289 break; 2290 case GRID_LINES_CHARS: 2291 rVal <<= text::TextGridMode::LINES_AND_CHARS; 2292 break; 2293 default: 2294 DBG_ERROR("unknown SwTextGrid value"); 2295 bRet = sal_False; 2296 break; 2297 } 2298 break; 2299 case MID_GRID_SNAPTOCHARS: 2300 rVal.setValue( &bSnapToChars, ::getBooleanCppuType() ); 2301 break; 2302 case MID_GRID_STANDARD_MODE: 2303 { 2304 sal_Bool bStandardMode = !bSquaredMode; 2305 rVal.setValue( &bStandardMode, ::getBooleanCppuType() ); 2306 } 2307 break; 2308 default: 2309 DBG_ERROR("Unknown SwTextGridItem member"); 2310 bRet = sal_False; 2311 break; 2312 } 2313 2314 return bRet; 2315 } 2316 2317 sal_Bool SwTextGridItem::PutValue( const uno::Any& rVal, sal_uInt8 nMemberId ) 2318 { 2319 sal_Bool bRet = sal_True; 2320 switch( nMemberId & ~CONVERT_TWIPS ) 2321 { 2322 case MID_GRID_COLOR: 2323 { 2324 sal_Int32 nTmp = 0; 2325 bRet = (rVal >>= nTmp); 2326 if( bRet ) 2327 SetColor( Color(nTmp) ); 2328 } 2329 break; 2330 case MID_GRID_LINES: 2331 { 2332 sal_Int16 nTmp = 0; 2333 bRet = (rVal >>= nTmp); 2334 if( bRet && (nTmp >= 0) ) 2335 SetLines( (sal_uInt16)nTmp ); 2336 else 2337 bRet = sal_False; 2338 } 2339 break; 2340 case MID_GRID_RUBY_BELOW: 2341 SetRubyTextBelow( *(sal_Bool*)rVal.getValue() ); 2342 break; 2343 case MID_GRID_PRINT: 2344 SetPrintGrid( *(sal_Bool*)rVal.getValue() ); 2345 break; 2346 case MID_GRID_DISPLAY: 2347 SetDisplayGrid( *(sal_Bool*)rVal.getValue() ); 2348 break; 2349 case MID_GRID_BASEHEIGHT: 2350 case MID_GRID_BASEWIDTH: 2351 case MID_GRID_RUBYHEIGHT: 2352 { 2353 DBG_ASSERT( (nMemberId & CONVERT_TWIPS) != 0, 2354 "This value needs TWIPS-MM100 conversion" ); 2355 sal_Int32 nTmp = 0; 2356 bRet = (rVal >>= nTmp); 2357 nTmp = MM100_TO_TWIP( nTmp ); 2358 if( bRet && (nTmp >= 0) && ( nTmp <= USHRT_MAX) ) 2359 if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEHEIGHT ) 2360 SetBaseHeight( (sal_uInt16)nTmp ); 2361 else if( (nMemberId & ~CONVERT_TWIPS) == MID_GRID_BASEWIDTH ) 2362 SetBaseWidth( (sal_uInt16)nTmp ); 2363 else 2364 SetRubyHeight( (sal_uInt16)nTmp ); 2365 else 2366 bRet = sal_False; 2367 } 2368 break; 2369 case MID_GRID_TYPE: 2370 { 2371 sal_Int16 nTmp = 0; 2372 bRet = (rVal >>= nTmp); 2373 if( bRet ) 2374 { 2375 switch( nTmp ) 2376 { 2377 case text::TextGridMode::NONE: 2378 SetGridType( GRID_NONE ); 2379 break; 2380 case text::TextGridMode::LINES: 2381 SetGridType( GRID_LINES_ONLY ); 2382 break; 2383 case text::TextGridMode::LINES_AND_CHARS: 2384 SetGridType( GRID_LINES_CHARS ); 2385 break; 2386 default: 2387 bRet = sal_False; 2388 break; 2389 } 2390 } 2391 break; 2392 } 2393 case MID_GRID_SNAPTOCHARS: 2394 SetSnapToChars( *(sal_Bool*)rVal.getValue() ); 2395 break; 2396 case MID_GRID_STANDARD_MODE: 2397 { 2398 sal_Bool bStandard = *(sal_Bool*)rVal.getValue(); 2399 SetSquaredMode( !bStandard ); 2400 break; 2401 } 2402 default: 2403 DBG_ERROR("Unknown SwTextGridItem member"); 2404 bRet = sal_False; 2405 } 2406 2407 return bRet; 2408 } 2409 2410 void SwTextGridItem::SwitchPaperMode(sal_Bool bNew) 2411 { 2412 if( bNew == bSquaredMode ) 2413 { 2414 //same paper mode, not switch 2415 return; 2416 } 2417 2418 // use default value when grid is disable 2419 if( eGridType == GRID_NONE ) 2420 { 2421 bSquaredMode = bNew; 2422 Init(); 2423 return; 2424 } 2425 2426 if( bSquaredMode ) 2427 { 2428 //switch from "squared mode" to "standard mode" 2429 nBaseWidth = nBaseHeight; 2430 nBaseHeight = nBaseHeight + nRubyHeight; 2431 nRubyHeight = 0; 2432 } 2433 else 2434 { 2435 //switch from "standard mode" to "squared mode" 2436 nRubyHeight = nBaseHeight/3; 2437 nBaseHeight = nBaseHeight - nRubyHeight; 2438 nBaseWidth = nBaseHeight; 2439 } 2440 bSquaredMode = !bSquaredMode; 2441 } 2442 2443 void SwTextGridItem::Init() 2444 { 2445 if( bSquaredMode ) 2446 { 2447 nLines = 20; 2448 nBaseHeight = 400; 2449 nRubyHeight = 200; 2450 eGridType = GRID_NONE; 2451 bRubyTextBelow = 0; 2452 bPrintGrid = 1; 2453 bDisplayGrid = 1; 2454 bSnapToChars = 1; 2455 nBaseWidth = 400; 2456 } 2457 else 2458 { 2459 nLines = 44; 2460 nBaseHeight = 312; 2461 nRubyHeight = 0; 2462 eGridType = GRID_NONE; 2463 bRubyTextBelow = 0; 2464 bPrintGrid = 1; 2465 bDisplayGrid = 1; 2466 nBaseWidth = 210; 2467 bSnapToChars = 1; 2468 2469 //default grid type is line only in CJK env 2470 //disable this function due to type area change 2471 //if grid type change. 2472 //if(SvtCJKOptions().IsAsianTypographyEnabled()) 2473 //{ 2474 // bDisplayGrid = 0; 2475 // eGridType = GRID_LINES_ONLY; 2476 //} 2477 } 2478 } 2479 // class SwHeaderAndFooterEatSpacingItem 2480 2481 SfxPoolItem* SwHeaderAndFooterEatSpacingItem::Clone( SfxItemPool* ) const 2482 { 2483 return new SwHeaderAndFooterEatSpacingItem( Which(), GetValue() ); 2484 } 2485 2486 ////////////////////////////////////////////////////////////////////////////// 2487 // class SwFrmFmt 2488 // Implementierung teilweise inline im hxx 2489 2490 TYPEINIT1( SwFrmFmt, SwFmt ); 2491 IMPL_FIXEDMEMPOOL_NEWDEL_DLL( SwFrmFmt, 20, 20 ) 2492 2493 SwFrmFmt::SwFrmFmt( 2494 SwAttrPool& rPool, 2495 const sal_Char* pFmtNm, 2496 SwFrmFmt *pDrvdFrm, 2497 sal_uInt16 nFmtWhich, 2498 const sal_uInt16* pWhichRange) 2499 : SwFmt(rPool, pFmtNm, (pWhichRange ? pWhichRange : aFrmFmtSetRange), pDrvdFrm, nFmtWhich), 2500 m_wXObject(), 2501 maFillAttributes(), 2502 pCaptionFmt(0) 2503 { 2504 } 2505 2506 SwFrmFmt::SwFrmFmt( 2507 SwAttrPool& rPool, 2508 const String &rFmtNm, 2509 SwFrmFmt *pDrvdFrm, 2510 sal_uInt16 nFmtWhich, 2511 const sal_uInt16* pWhichRange) 2512 : SwFmt(rPool, rFmtNm, (pWhichRange ? pWhichRange : aFrmFmtSetRange), pDrvdFrm, nFmtWhich), 2513 m_wXObject(), 2514 maFillAttributes(), 2515 pCaptionFmt(0) 2516 { 2517 } 2518 2519 //UUUU 2520 SwFrmFmt::~SwFrmFmt() 2521 { 2522 } 2523 2524 void SwFrmFmt::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew ) 2525 { 2526 SwFmtHeader *pH = 0; 2527 SwFmtFooter *pF = 0; 2528 2529 sal_uInt16 nWhich = pNew ? pNew->Which() : 0; 2530 2531 if( RES_ATTRSET_CHG == nWhich ) 2532 { 2533 ((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState( 2534 RES_HEADER, sal_False, (const SfxPoolItem**)&pH ); 2535 ((SwAttrSetChg*)pNew)->GetChgSet()->GetItemState( 2536 RES_FOOTER, sal_False, (const SfxPoolItem**)&pF ); 2537 2538 //UUUU reset fill information 2539 if(maFillAttributes.get() && supportsFullDrawingLayerFillAttributeSet()) 2540 { 2541 SfxItemIter aIter(*((SwAttrSetChg*)pNew)->GetChgSet()); 2542 bool bReset(false); 2543 2544 for(const SfxPoolItem* pItem = aIter.FirstItem(); pItem && !bReset; pItem = aIter.NextItem()) 2545 { 2546 bReset = !IsInvalidItem(pItem) && pItem->Which() >= XATTR_FILL_FIRST && pItem->Which() <= XATTR_FILL_LAST; 2547 } 2548 2549 if(bReset) 2550 { 2551 maFillAttributes.reset(); 2552 } 2553 } 2554 } 2555 else if(RES_FMT_CHG == nWhich) 2556 { 2557 //UUUU reset fill information on format change (e.g. style changed) 2558 if(maFillAttributes.get() && supportsFullDrawingLayerFillAttributeSet()) 2559 { 2560 maFillAttributes.reset(); 2561 } 2562 } 2563 else if( RES_HEADER == nWhich ) 2564 pH = (SwFmtHeader*)pNew; 2565 else if( RES_FOOTER == nWhich ) 2566 pF = (SwFmtFooter*)pNew; 2567 2568 if( pH && pH->IsActive() && !pH->GetHeaderFmt() ) 2569 { //Hat er keinen, mach ich ihm einen 2570 SwFrmFmt *pFmt = GetDoc()->MakeLayoutFmt( RND_STD_HEADER, 0 ); 2571 pH->RegisterToFormat( *pFmt ); 2572 } 2573 2574 if( pF && pF->IsActive() && !pF->GetFooterFmt() ) 2575 { //Hat er keinen, mach ich ihm einen 2576 SwFrmFmt *pFmt = GetDoc()->MakeLayoutFmt( RND_STD_FOOTER, 0 ); 2577 pF->RegisterToFormat( *pFmt ); 2578 } 2579 2580 // MIB 24.3.98: Modify der Basisklasse muss immer gerufen werden, z.B. 2581 // wegen RESET_FMTWRITTEN. 2582 // if ( GetDepends() ) 2583 SwFmt::Modify( pOld, pNew ); 2584 2585 if (pOld && (RES_REMOVE_UNO_OBJECT == pOld->Which())) 2586 { // invalidate cached uno object 2587 SetXObject(uno::Reference<uno::XInterface>(0)); 2588 } 2589 } 2590 2591 void SwFrmFmt::RegisterToFormat( SwFmt& rFmt ) 2592 { 2593 rFmt.Add( this ); 2594 } 2595 2596 //Vernichtet alle Frms, die in aDepend angemeldet sind. 2597 2598 void SwFrmFmt::DelFrms() 2599 { 2600 SwIterator<SwFrm,SwFmt> aIter( *this ); 2601 SwFrm * pLast = aIter.First(); 2602 if( pLast ) 2603 do { 2604 pLast->Cut(); 2605 delete pLast; 2606 } while( 0 != ( pLast = aIter.Next() )); 2607 } 2608 2609 void SwFrmFmt::MakeFrms() 2610 { 2611 ASSERT( sal_False, "Sorry not implemented." ); 2612 } 2613 2614 2615 2616 SwRect SwFrmFmt::FindLayoutRect( const sal_Bool bPrtArea, const Point* pPoint, 2617 const sal_Bool bCalcFrm ) const 2618 { 2619 SwRect aRet; 2620 SwFrm *pFrm = 0; 2621 if( ISA( SwSectionFmt ) ) 2622 { 2623 // dann den frame::Frame per Node2Layout besorgen 2624 SwSectionNode* pSectNd = ((SwSectionFmt*)this)->GetSectionNode(); 2625 if( pSectNd ) 2626 { 2627 SwNode2Layout aTmp( *pSectNd, pSectNd->GetIndex() - 1 ); 2628 pFrm = aTmp.NextFrm(); 2629 2630 if( pFrm && !pFrm->KnowsFormat(*this) ) 2631 { 2632 // die Section hat keinen eigenen frame::Frame, also falls 2633 // jemand die tatsaechliche Groe?e braucht, so muss das 2634 // noch implementier werden, in dem sich vom Ende noch 2635 // der entsprechende frame::Frame besorgt wird. 2636 // PROBLEM: was passiert bei SectionFrames, die auf unter- 2637 // schiedlichen Seiten stehen?? 2638 if( bPrtArea ) 2639 aRet = pFrm->Prt(); 2640 else 2641 { 2642 aRet = pFrm->Frm(); 2643 --aRet.Pos().Y(); 2644 } 2645 pFrm = 0; // das Rect ist ja jetzt fertig 2646 } 2647 } 2648 } 2649 else 2650 { 2651 sal_uInt16 nFrmType = RES_FLYFRMFMT == Which() ? FRM_FLY : USHRT_MAX; 2652 pFrm = ::GetFrmOfModify( 0, *(SwModify*)this, nFrmType, pPoint, 2653 0, bCalcFrm ); 2654 } 2655 2656 if( pFrm ) 2657 { 2658 if( bPrtArea ) 2659 aRet = pFrm->Prt(); 2660 else 2661 aRet = pFrm->Frm(); 2662 } 2663 return aRet; 2664 } 2665 2666 SwContact* SwFrmFmt::FindContactObj() 2667 { 2668 return SwIterator<SwContact,SwFmt>::FirstElement( *this ); 2669 } 2670 2671 SdrObject* SwFrmFmt::FindSdrObject() 2672 { 2673 // --> OD 2005-01-06 #i30669# - use method <FindContactObj()> instead of 2674 // duplicated code. 2675 SwContact* pFoundContact = FindContactObj(); 2676 return pFoundContact ? pFoundContact->GetMaster() : 0; 2677 // <-- 2678 } 2679 2680 SdrObject* SwFrmFmt::FindRealSdrObject() 2681 { 2682 if( RES_FLYFRMFMT == Which() ) 2683 { 2684 Point aNullPt; 2685 SwFlyFrm* pFly = (SwFlyFrm*)::GetFrmOfModify( 0, *this, FRM_FLY, 2686 &aNullPt, 0, sal_False ); 2687 return pFly ? pFly->GetVirtDrawObj() : 0; 2688 } 2689 return FindSdrObject(); 2690 } 2691 2692 2693 sal_Bool SwFrmFmt::IsLowerOf( const SwFrmFmt& rFmt ) const 2694 { 2695 //Auch eine Verkettung von Innen nach aussen oder von aussen 2696 //nach innen ist nicht zulaessig. 2697 SwFlyFrm *pSFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement(*this); 2698 if( pSFly ) 2699 { 2700 SwFlyFrm *pAskFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement(rFmt); 2701 if( pAskFly ) 2702 return pSFly->IsLowerOf( pAskFly ); 2703 } 2704 2705 // dann mal ueber die Node-Positionen versuchen 2706 const SwFmtAnchor* pAnchor = &rFmt.GetAnchor(); 2707 if ((FLY_AT_PAGE != pAnchor->GetAnchorId()) && pAnchor->GetCntntAnchor()) 2708 { 2709 const SwSpzFrmFmts& rFmts = *GetDoc()->GetSpzFrmFmts(); 2710 const SwNode* pFlyNd = pAnchor->GetCntntAnchor()->nNode.GetNode(). 2711 FindFlyStartNode(); 2712 while( pFlyNd ) 2713 { 2714 // dann ueber den Anker nach oben "hangeln" 2715 sal_uInt16 n; 2716 for( n = 0; n < rFmts.Count(); ++n ) 2717 { 2718 const SwFrmFmt* pFmt = rFmts[ n ]; 2719 const SwNodeIndex* pIdx = pFmt->GetCntnt().GetCntntIdx(); 2720 if( pIdx && pFlyNd == &pIdx->GetNode() ) 2721 { 2722 if( pFmt == this ) 2723 return sal_True; 2724 2725 pAnchor = &pFmt->GetAnchor(); 2726 if ((FLY_AT_PAGE == pAnchor->GetAnchorId()) || 2727 !pAnchor->GetCntntAnchor() ) 2728 { 2729 return sal_False; 2730 } 2731 2732 pFlyNd = pAnchor->GetCntntAnchor()->nNode.GetNode(). 2733 FindFlyStartNode(); 2734 break; 2735 } 2736 } 2737 if( n >= rFmts.Count() ) 2738 { 2739 ASSERT( sal_False, "Fly-Section but no format found" ); 2740 return sal_False; 2741 } 2742 } 2743 } 2744 return sal_False; 2745 } 2746 2747 // --> OD 2004-07-27 #i31698# 2748 SwFrmFmt::tLayoutDir SwFrmFmt::GetLayoutDir() const 2749 { 2750 return SwFrmFmt::HORI_L2R; 2751 } 2752 2753 void SwFrmFmt::SetLayoutDir( const SwFrmFmt::tLayoutDir ) 2754 { 2755 // empty body, because default implementation does nothing 2756 } 2757 // <-- 2758 2759 // --> OD 2004-08-06 #i28749# 2760 sal_Int16 SwFrmFmt::GetPositionLayoutDir() const 2761 { 2762 return text::PositionLayoutDir::PositionInLayoutDirOfAnchor; 2763 } 2764 void SwFrmFmt::SetPositionLayoutDir( const sal_Int16 ) 2765 { 2766 // empty body, because default implementation does nothing 2767 } 2768 // <-- 2769 String SwFrmFmt::GetDescription() const 2770 { 2771 return SW_RES(STR_FRAME); 2772 } 2773 2774 // class SwFlyFrmFmt 2775 // Implementierung teilweise inline im hxx 2776 2777 TYPEINIT1( SwFlyFrmFmt, SwFrmFmt ); 2778 IMPL_FIXEDMEMPOOL_NEWDEL( SwFlyFrmFmt, 10, 10 ) 2779 2780 SwFlyFrmFmt::~SwFlyFrmFmt() 2781 { 2782 SwIterator<SwFlyFrm,SwFmt> aIter( *this ); 2783 SwFlyFrm * pLast = aIter.First(); 2784 if( pLast ) 2785 do { 2786 delete pLast; 2787 } while( 0 != ( pLast = aIter.Next() )); 2788 2789 SwIterator<SwFlyDrawContact,SwFmt> a2ndIter( *this ); 2790 SwFlyDrawContact* pC = a2ndIter.First(); 2791 if( pC ) 2792 do { 2793 delete pC; 2794 2795 } while( 0 != ( pC = a2ndIter.Next() )); 2796 } 2797 2798 //Erzeugen der Frms wenn das Format einen Absatzgebundenen Rahmen beschreibt. 2799 //MA: 14. Feb. 94, Erzeugen der Frms auch fuer Seitengebundene Rahmen. 2800 2801 void SwFlyFrmFmt::MakeFrms() 2802 { 2803 // gibts ueberhaupt ein Layout ?? 2804 if( !GetDoc()->GetCurrentViewShell() ) 2805 return; //swmod 071108//swmod 071225 2806 2807 SwModify *pModify = 0; 2808 // OD 24.07.2003 #111032# - create local copy of anchor attribute for possible changes. 2809 SwFmtAnchor aAnchorAttr( GetAnchor() ); 2810 switch( aAnchorAttr.GetAnchorId() ) 2811 { 2812 case FLY_AS_CHAR: 2813 case FLY_AT_PARA: 2814 case FLY_AT_CHAR: 2815 if( aAnchorAttr.GetCntntAnchor() ) 2816 { 2817 pModify = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode(); 2818 } 2819 break; 2820 2821 case FLY_AT_FLY: 2822 if( aAnchorAttr.GetCntntAnchor() ) 2823 { 2824 //Erst einmal ueber den Inhalt suchen, weil konstant schnell. Kann 2825 //Bei verketteten Rahmen aber auch schief gehen, weil dann evtl. 2826 //niemals ein frame::Frame zu dem Inhalt existiert. Dann muss leider noch 2827 //die Suche vom StartNode zum FrameFormat sein. 2828 SwNodeIndex aIdx( aAnchorAttr.GetCntntAnchor()->nNode ); 2829 SwCntntNode *pCNd = GetDoc()->GetNodes().GoNext( &aIdx ); 2830 // --> OD 2009-12-28 #i105535# 2831 if ( pCNd == 0 ) 2832 { 2833 pCNd = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode(); 2834 } 2835 if ( pCNd ) 2836 // <-- 2837 { 2838 if( SwIterator<SwFrm,SwCntntNode>::FirstElement( *pCNd ) ) 2839 { 2840 pModify = pCNd; 2841 } 2842 } 2843 // --> OD 2009-12-28 #i105535# 2844 if ( pModify == 0 ) 2845 // <-- 2846 { 2847 const SwNodeIndex &rIdx = aAnchorAttr.GetCntntAnchor()->nNode; 2848 SwSpzFrmFmts& rFmts = *GetDoc()->GetSpzFrmFmts(); 2849 for( sal_uInt16 i = 0; i < rFmts.Count(); ++i ) 2850 { 2851 SwFrmFmt* pFlyFmt = rFmts[i]; 2852 if( pFlyFmt->GetCntnt().GetCntntIdx() && 2853 rIdx == *pFlyFmt->GetCntnt().GetCntntIdx() ) 2854 { 2855 pModify = pFlyFmt; 2856 break; 2857 } 2858 } 2859 } 2860 } 2861 break; 2862 2863 case FLY_AT_PAGE: 2864 { 2865 sal_uInt16 nPgNum = aAnchorAttr.GetPageNum(); 2866 SwPageFrm *pPage = (SwPageFrm*)GetDoc()->GetCurrentLayout()->Lower(); //swmod 080218 2867 if( nPgNum == 0 && aAnchorAttr.GetCntntAnchor() ) 2868 { 2869 SwCntntNode *pCNd = aAnchorAttr.GetCntntAnchor()->nNode.GetNode().GetCntntNode(); 2870 SwIterator<SwFrm,SwCntntNode> aIter( *pCNd ); 2871 for ( SwFrm* pFrm = aIter.First(); pFrm != NULL; pFrm = aIter.Next() ) 2872 { 2873 pPage = pFrm->FindPageFrm(); 2874 if( pPage ) 2875 { 2876 nPgNum = pPage->GetPhyPageNum(); 2877 aAnchorAttr.SetPageNum( nPgNum ); 2878 aAnchorAttr.SetAnchor( 0 ); 2879 SetFmtAttr( aAnchorAttr ); 2880 break; 2881 } 2882 } 2883 } 2884 while ( pPage ) 2885 { 2886 if ( pPage->GetPhyPageNum() == nPgNum ) 2887 { 2888 pPage->PlaceFly( 0, this ); 2889 break; 2890 } 2891 pPage = (SwPageFrm*)pPage->GetNext(); 2892 } 2893 } 2894 break; 2895 default: 2896 break; 2897 } 2898 2899 if( pModify ) 2900 { 2901 SwIterator<SwFrm,SwModify> aIter( *pModify ); 2902 for( SwFrm *pFrm = aIter.First(); pFrm; pFrm = aIter.Next() ) 2903 { 2904 sal_Bool bAdd = !pFrm->IsCntntFrm() || 2905 !((SwCntntFrm*)pFrm)->IsFollow(); 2906 2907 if ( FLY_AT_FLY == aAnchorAttr.GetAnchorId() && !pFrm->IsFlyFrm() ) 2908 { 2909 // --> OD 2009-12-28 #i105535# 2910 // fallback to anchor type at-paragraph, if no fly frame is found. 2911 // pFrm = pFrm->FindFlyFrm(); 2912 SwFrm* pFlyFrm = pFrm->FindFlyFrm(); 2913 if ( pFlyFrm ) 2914 { 2915 pFrm = pFlyFrm; 2916 } 2917 else 2918 { 2919 aAnchorAttr.SetType( FLY_AT_PARA ); 2920 SetFmtAttr( aAnchorAttr ); 2921 MakeFrms(); 2922 return; 2923 } 2924 // <-- 2925 } 2926 2927 if( pFrm->GetDrawObjs() ) 2928 { 2929 // --> OD 2004-07-01 #i28701# - new type <SwSortedObjs> 2930 SwSortedObjs &rObjs = *pFrm->GetDrawObjs(); 2931 for( sal_uInt16 i = 0; i < rObjs.Count(); ++i) 2932 { 2933 // --> OD 2004-07-01 #i28701# - consider changed type of 2934 // <SwSortedObjs> entries. 2935 SwAnchoredObject* pObj = rObjs[i]; 2936 if( pObj->ISA(SwFlyFrm) && 2937 (&pObj->GetFrmFmt()) == this ) 2938 { 2939 bAdd = sal_False; 2940 break; 2941 } 2942 } 2943 } 2944 2945 if( bAdd ) 2946 { 2947 SwFlyFrm *pFly = 0; 2948 switch( aAnchorAttr.GetAnchorId() ) 2949 { 2950 case FLY_AT_FLY: 2951 pFly = new SwFlyLayFrm( this, pFrm, pFrm ); 2952 break; 2953 2954 case FLY_AT_PARA: 2955 case FLY_AT_CHAR: 2956 pFly = new SwFlyAtCntFrm( this, pFrm, pFrm ); 2957 break; 2958 2959 case FLY_AS_CHAR: 2960 pFly = new SwFlyInCntFrm( this, pFrm, pFrm ); 2961 break; 2962 default: 2963 ASSERT( sal_False, "New anchor type" ) 2964 break; 2965 } 2966 pFrm->AppendFly( pFly ); 2967 SwPageFrm *pPage = pFly->FindPageFrm(); 2968 if( pPage ) 2969 ::RegistFlys( pPage, pFly ); 2970 } 2971 } 2972 } 2973 } 2974 2975 SwFlyFrm* SwFlyFrmFmt::GetFrm( const Point* pPoint, const sal_Bool bCalcFrm ) const 2976 { 2977 return (SwFlyFrm*)::GetFrmOfModify( 0, *(SwModify*)this, FRM_FLY, 2978 pPoint, 0, bCalcFrm ); 2979 } 2980 2981 SwAnchoredObject* SwFlyFrmFmt::GetAnchoredObj( const Point* pPoint, const sal_Bool bCalcFrm ) const 2982 { 2983 SwFlyFrm* pFlyFrm( GetFrm( pPoint, bCalcFrm ) ); 2984 if ( pFlyFrm ) 2985 { 2986 return dynamic_cast<SwAnchoredObject*>(pFlyFrm); 2987 } 2988 else 2989 { 2990 return 0L; 2991 } 2992 } 2993 2994 2995 sal_Bool SwFlyFrmFmt::GetInfo( SfxPoolItem& rInfo ) const 2996 { 2997 sal_Bool bRet = sal_True; 2998 switch( rInfo.Which() ) 2999 { 3000 case RES_CONTENT_VISIBLE: 3001 { 3002 ((SwPtrMsgPoolItem&)rInfo).pObject = SwIterator<SwFrm,SwFmt>::FirstElement( *this ); 3003 } 3004 bRet = sal_False; 3005 break; 3006 3007 default: 3008 bRet = SwFrmFmt::GetInfo( rInfo ); 3009 break; 3010 } 3011 return bRet; 3012 } 3013 3014 // --> OD 2009-07-14 #i73249# 3015 void SwFlyFrmFmt::SetObjTitle( const String& rTitle, bool bBroadcast ) 3016 { 3017 SdrObject* pMasterObject = FindSdrObject(); 3018 ASSERT( pMasterObject, 3019 "<SwNoTxtNode::SetObjTitle(..)> - missing <SdrObject> instance" ); 3020 if ( !pMasterObject ) 3021 { 3022 return; 3023 } 3024 3025 if( bBroadcast ) 3026 { 3027 SwStringMsgPoolItem aOld( RES_TITLE_CHANGED, pMasterObject->GetTitle() ); 3028 SwStringMsgPoolItem aNew( RES_TITLE_CHANGED, rTitle ); 3029 pMasterObject->SetTitle( rTitle ); 3030 ModifyNotification( &aOld, &aNew ); 3031 } 3032 else 3033 { 3034 pMasterObject->SetTitle( rTitle ); 3035 } 3036 } 3037 3038 const String SwFlyFrmFmt::GetObjTitle() const 3039 { 3040 const SdrObject* pMasterObject = FindSdrObject(); 3041 ASSERT( pMasterObject, 3042 "<SwFlyFrmFmt::GetObjTitle(..)> - missing <SdrObject> instance" ); 3043 if ( !pMasterObject ) 3044 { 3045 return aEmptyStr; 3046 } 3047 3048 return pMasterObject->GetTitle(); 3049 } 3050 3051 void SwFlyFrmFmt::SetObjDescription( const String& rDescription, bool bBroadcast ) 3052 { 3053 SdrObject* pMasterObject = FindSdrObject(); 3054 ASSERT( pMasterObject, 3055 "<SwFlyFrmFmt::SetDescription(..)> - missing <SdrObject> instance" ); 3056 if ( !pMasterObject ) 3057 { 3058 return; 3059 } 3060 3061 if( bBroadcast ) 3062 { 3063 SwStringMsgPoolItem aOld( RES_DESCRIPTION_CHANGED, pMasterObject->GetDescription() ); 3064 SwStringMsgPoolItem aNew( RES_DESCRIPTION_CHANGED, rDescription ); 3065 pMasterObject->SetDescription( rDescription ); 3066 ModifyNotification( &aOld, &aNew ); 3067 } 3068 else 3069 { 3070 pMasterObject->SetDescription( rDescription ); 3071 } 3072 } 3073 3074 const String SwFlyFrmFmt::GetObjDescription() const 3075 { 3076 const SdrObject* pMasterObject = FindSdrObject(); 3077 ASSERT( pMasterObject, 3078 "<SwNoTxtNode::GetDescription(..)> - missing <SdrObject> instance" ); 3079 if ( !pMasterObject ) 3080 { 3081 return aEmptyStr; 3082 } 3083 3084 return pMasterObject->GetDescription(); 3085 } 3086 // <-- 3087 3088 /** SwFlyFrmFmt::IsBackgroundTransparent - for #99657# 3089 3090 OD 22.08.2002 - overloading virtual method and its default implementation, 3091 because format of fly frame provides transparent backgrounds. 3092 Method determines, if background of fly frame is transparent. 3093 3094 @author OD 3095 3096 @return true, if background color is transparent, but not "no fill" 3097 or the transparency of a existing background graphic is set. 3098 */ 3099 sal_Bool SwFlyFrmFmt::IsBackgroundTransparent() const 3100 { 3101 //UUUU 3102 if(supportsFullDrawingLayerFillAttributeSet() && getSdrAllFillAttributesHelper()) 3103 { 3104 return getSdrAllFillAttributesHelper()->isTransparent(); 3105 } 3106 3107 /// NOTE: If background color is "no fill"/"auto fill" (COL_TRANSPARENT) 3108 /// and there is no background graphic, it "inherites" the background 3109 /// from its anchor. 3110 if ( (GetBackground().GetColor().GetTransparency() != 0) && 3111 (GetBackground().GetColor() != COL_TRANSPARENT) 3112 ) 3113 { 3114 return sal_True; 3115 } 3116 else 3117 { 3118 const GraphicObject *pTmpGrf = 3119 static_cast<const GraphicObject*>(GetBackground().GetGraphicObject()); 3120 if ( (pTmpGrf) && 3121 (pTmpGrf->GetAttr().GetTransparency() != 0) 3122 ) 3123 { 3124 return sal_True; 3125 } 3126 } 3127 3128 return sal_False; 3129 } 3130 3131 /** SwFlyFrmFmt::IsBackgroundBrushInherited - for #103898# 3132 3133 OD 08.10.2002 - method to determine, if the brush for drawing the 3134 background is "inherited" from its parent/grandparent. 3135 This is the case, if no background graphic is set and the background 3136 color is "no fill"/"auto fill" 3137 NOTE: condition is "copied" from method <SwFrm::GetBackgroundBrush(..). 3138 3139 @author OD 3140 3141 @return true, if background brush is "inherited" from parent/grandparent 3142 */ 3143 sal_Bool SwFlyFrmFmt::IsBackgroundBrushInherited() const 3144 { 3145 //UUUU 3146 if(supportsFullDrawingLayerFillAttributeSet() && getSdrAllFillAttributesHelper()) 3147 { 3148 return !getSdrAllFillAttributesHelper()->isUsed(); 3149 } 3150 else if ( (GetBackground().GetColor() == COL_TRANSPARENT) && 3151 !(GetBackground().GetGraphicObject()) ) 3152 { 3153 return sal_True; 3154 } 3155 3156 return sal_False; 3157 } 3158 3159 // --> OD 2006-02-28 #125892# 3160 SwHandleAnchorNodeChg::SwHandleAnchorNodeChg( SwFlyFrmFmt& _rFlyFrmFmt, 3161 const SwFmtAnchor& _rNewAnchorFmt, 3162 SwFlyFrm* _pKeepThisFlyFrm ) 3163 : mrFlyFrmFmt( _rFlyFrmFmt ), 3164 mbAnchorNodeChanged( false ) 3165 { 3166 const RndStdIds nNewAnchorType( _rNewAnchorFmt.GetAnchorId() ); 3167 if ( ((nNewAnchorType == FLY_AT_PARA) || 3168 (nNewAnchorType == FLY_AT_CHAR)) && 3169 _rNewAnchorFmt.GetCntntAnchor() && 3170 _rNewAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode() ) 3171 { 3172 const SwFmtAnchor& aOldAnchorFmt( _rFlyFrmFmt.GetAnchor() ); 3173 if ( aOldAnchorFmt.GetAnchorId() == nNewAnchorType && 3174 aOldAnchorFmt.GetCntntAnchor() && 3175 aOldAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode() && 3176 aOldAnchorFmt.GetCntntAnchor()->nNode != 3177 _rNewAnchorFmt.GetCntntAnchor()->nNode ) 3178 { 3179 // determine 'old' number of anchor frames 3180 sal_uInt32 nOldNumOfAnchFrm( 0L ); 3181 SwIterator<SwFrm,SwCntntNode> aOldIter( *(aOldAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode()) ); 3182 for( SwFrm* pOld = aOldIter.First(); pOld; pOld = aOldIter.Next() ) 3183 { 3184 ++nOldNumOfAnchFrm; 3185 } 3186 // determine 'new' number of anchor frames 3187 sal_uInt32 nNewNumOfAnchFrm( 0L ); 3188 SwIterator<SwFrm,SwCntntNode> aNewIter( *(_rNewAnchorFmt.GetCntntAnchor()->nNode.GetNode().GetCntntNode()) ); 3189 for( SwFrm* pNew = aNewIter.First(); pNew; pNew = aNewIter.Next() ) 3190 { 3191 ++nNewNumOfAnchFrm; 3192 } 3193 if ( nOldNumOfAnchFrm != nNewNumOfAnchFrm ) 3194 { 3195 // delete existing fly frames except <_pKeepThisFlyFrm> 3196 SwIterator<SwFrm,SwFmt> aIter( mrFlyFrmFmt ); 3197 SwFrm* pFrm = aIter.First(); 3198 if ( pFrm ) 3199 { 3200 do { 3201 if ( pFrm != _pKeepThisFlyFrm ) 3202 { 3203 pFrm->Cut(); 3204 delete pFrm; 3205 } 3206 } while( 0 != ( pFrm = aIter.Next() )); 3207 } 3208 // indicate, that re-creation of fly frames necessary 3209 mbAnchorNodeChanged = true; 3210 } 3211 } 3212 } 3213 } 3214 3215 SwHandleAnchorNodeChg::~SwHandleAnchorNodeChg() 3216 { 3217 if ( mbAnchorNodeChanged ) 3218 { 3219 mrFlyFrmFmt.MakeFrms(); 3220 } 3221 } 3222 // <-- 3223 // class SwDrawFrmFmt 3224 // Implementierung teilweise inline im hxx 3225 3226 TYPEINIT1( SwDrawFrmFmt, SwFrmFmt ); 3227 IMPL_FIXEDMEMPOOL_NEWDEL( SwDrawFrmFmt, 10, 10 ) 3228 3229 SwDrawFrmFmt::~SwDrawFrmFmt() 3230 { 3231 SwContact *pContact = FindContactObj(); 3232 delete pContact; 3233 } 3234 3235 void SwDrawFrmFmt::MakeFrms() 3236 { 3237 SwDrawContact *pContact = (SwDrawContact*)FindContactObj(); 3238 if ( pContact ) 3239 pContact->ConnectToLayout(); 3240 } 3241 3242 void SwDrawFrmFmt::DelFrms() 3243 { 3244 SwDrawContact *pContact = (SwDrawContact *)FindContactObj(); 3245 if ( pContact ) //fuer den Reader und andere Unabwaegbarkeiten. 3246 pContact->DisconnectFromLayout(); 3247 } 3248 3249 // --> OD 2004-07-27 #i31698# 3250 SwFrmFmt::tLayoutDir SwDrawFrmFmt::GetLayoutDir() const 3251 { 3252 return meLayoutDir; 3253 } 3254 3255 void SwDrawFrmFmt::SetLayoutDir( const SwFrmFmt::tLayoutDir _eLayoutDir ) 3256 { 3257 meLayoutDir = _eLayoutDir; 3258 } 3259 // <-- 3260 3261 // --> OD 2004-08-06 #i28749# 3262 sal_Int16 SwDrawFrmFmt::GetPositionLayoutDir() const 3263 { 3264 return mnPositionLayoutDir; 3265 } 3266 void SwDrawFrmFmt::SetPositionLayoutDir( const sal_Int16 _nPositionLayoutDir ) 3267 { 3268 switch ( _nPositionLayoutDir ) 3269 { 3270 case text::PositionLayoutDir::PositionInHoriL2R: 3271 case text::PositionLayoutDir::PositionInLayoutDirOfAnchor: 3272 { 3273 mnPositionLayoutDir = _nPositionLayoutDir; 3274 } 3275 break; 3276 default: 3277 { 3278 ASSERT( false, 3279 "<SwDrawFrmFmt::SetPositionLayoutDir(..)> - invalid attribute value." ); 3280 } 3281 } 3282 } 3283 // <-- 3284 3285 String SwDrawFrmFmt::GetDescription() const 3286 { 3287 String aResult; 3288 const SdrObject * pSdrObj = FindSdrObject(); 3289 3290 if (pSdrObj) 3291 { 3292 if (pSdrObj != pSdrObjCached) 3293 { 3294 SdrObject * pSdrObjCopy = pSdrObj->Clone(); 3295 SdrUndoNewObj * pSdrUndo = new SdrUndoNewObj(*pSdrObjCopy); 3296 sSdrObjCachedComment = pSdrUndo->GetComment(); 3297 3298 delete pSdrUndo; 3299 3300 pSdrObjCached = pSdrObj; 3301 } 3302 3303 aResult = sSdrObjCachedComment; 3304 } 3305 else 3306 aResult = SW_RES(STR_GRAPHIC); 3307 3308 return aResult; 3309 } 3310 3311 IMapObject* SwFrmFmt::GetIMapObject( const Point& rPoint, 3312 const SwFlyFrm *pFly ) const 3313 { 3314 const SwFmtURL &rURL = GetURL(); 3315 if( !rURL.GetMap() ) 3316 return 0; 3317 3318 if( !pFly ) 3319 { 3320 pFly = SwIterator<SwFlyFrm,SwFmt>::FirstElement( *this ); 3321 if( !pFly ) 3322 return 0; 3323 } 3324 3325 //Orignialgroesse fuer OLE und Grafik ist die TwipSize, 3326 //ansonsten die Groesse vom FrmFmt des Fly. 3327 const SwFrm *pRef; 3328 SwNoTxtNode *pNd = 0; 3329 Size aOrigSz; 3330 if( pFly->Lower() && pFly->Lower()->IsNoTxtFrm() ) 3331 { 3332 pRef = pFly->Lower(); 3333 pNd = ((SwCntntFrm*)pRef)->GetNode()->GetNoTxtNode(); 3334 aOrigSz = pNd->GetTwipSize(); 3335 } 3336 else 3337 { 3338 pRef = pFly; 3339 aOrigSz = pFly->GetFmt()->GetFrmSize().GetSize(); 3340 } 3341 3342 if( aOrigSz.Width() != 0 && aOrigSz.Height() != 0 ) 3343 { 3344 Point aPos( rPoint ); 3345 Size aActSz ( pRef == pFly ? pFly->Frm().SSize() : pRef->Prt().SSize() ); 3346 const MapMode aSrc ( MAP_TWIP ); 3347 const MapMode aDest( MAP_100TH_MM ); 3348 aOrigSz = OutputDevice::LogicToLogic( aOrigSz, aSrc, aDest ); 3349 aActSz = OutputDevice::LogicToLogic( aActSz, aSrc, aDest ); 3350 aPos -= pRef->Frm().Pos(); 3351 aPos -= pRef->Prt().Pos(); 3352 aPos = OutputDevice::LogicToLogic( aPos, aSrc, aDest ); 3353 sal_uInt32 nFlags = 0; 3354 if ( pFly != pRef && pNd->IsGrfNode() ) 3355 { 3356 const sal_uInt16 nMirror = pNd->GetSwAttrSet(). 3357 GetMirrorGrf().GetValue(); 3358 if ( RES_MIRROR_GRAPH_BOTH == nMirror ) 3359 nFlags = IMAP_MIRROR_HORZ | IMAP_MIRROR_VERT; 3360 else if ( RES_MIRROR_GRAPH_VERT == nMirror ) 3361 nFlags = IMAP_MIRROR_VERT; 3362 else if ( RES_MIRROR_GRAPH_HOR == nMirror ) 3363 nFlags = IMAP_MIRROR_HORZ; 3364 3365 } 3366 return ((ImageMap*)rURL.GetMap())->GetHitIMapObject( aOrigSz, 3367 aActSz, aPos, nFlags ); 3368 } 3369 3370 return 0; 3371 } 3372 3373 sal_Bool SwFrmFmt::HasCaption() const 3374 { 3375 if(pCaptionFmt != NULL && pCaptionFmt->GetDepends()) 3376 return sal_True; 3377 return sal_False; 3378 } 3379 3380 void SwFrmFmt::SetCaptionFmt(SwFrmFmt * pFmt) 3381 { 3382 pCaptionFmt = pFmt; 3383 } 3384 3385 SwFrmFmt* SwFrmFmt::GetCaptionFmt() const 3386 { 3387 return pCaptionFmt; 3388 } 3389 3390 //UUUU 3391 drawinglayer::attribute::SdrAllFillAttributesHelperPtr SwFrmFmt::getSdrAllFillAttributesHelper() const 3392 { 3393 if(supportsFullDrawingLayerFillAttributeSet()) 3394 { 3395 // create FillAttributes on demand 3396 if(!maFillAttributes.get()) 3397 { 3398 const_cast< SwFrmFmt* >(this)->maFillAttributes.reset(new drawinglayer::attribute::SdrAllFillAttributesHelper(GetAttrSet())); 3399 } 3400 } 3401 else 3402 { 3403 // FALLBACKBREAKHERE assert wrong usage 3404 OSL_ENSURE(false, "getSdrAllFillAttributesHelper() call only valid for RES_FLYFRMFMT and RES_FRMFMT (!)"); 3405 } 3406 3407 return maFillAttributes; 3408 } 3409 3410 // eof 3411