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 #ifdef SW_DLLIMPLEMENTATION 28 #undef SW_DLLIMPLEMENTATION 29 #endif 30 31 32 #include <hintids.hxx> 33 #include <tools/list.hxx> 34 #include <vcl/msgbox.hxx> 35 #include <svl/stritem.hxx> 36 #include <svl/intitem.hxx> 37 #include <svx/htmlmode.hxx> 38 #include <editeng/keepitem.hxx> 39 #include <editeng/brkitem.hxx> 40 #include <editeng/ulspitem.hxx> 41 #include <editeng/frmdiritem.hxx> 42 #include <svl/ctloptions.hxx> 43 #include <swmodule.hxx> 44 #include <fmtornt.hxx> 45 #include <fmtpdsc.hxx> 46 #include <fmtlsplt.hxx> 47 48 #include <svtools/htmlcfg.hxx> 49 #include <fmtrowsplt.hxx> 50 #include <svx/htmlmode.hxx> 51 52 #include "access.hrc" 53 54 #ifndef _DOCSH_HXX 55 #include <docsh.hxx> 56 #endif 57 #include <wrtsh.hxx> 58 #ifndef _VIEW_HXX 59 #include <view.hxx> 60 #endif 61 #include <viewopt.hxx> 62 #include <uitool.hxx> 63 #include <frmatr.hxx> 64 #include <tabledlg.hxx> 65 #ifndef _TABLEPG_HXX 66 #include <tablepg.hxx> 67 #endif 68 #include <tablemgr.hxx> 69 #include <pagedesc.hxx> 70 #include <uiitems.hxx> 71 #include <poolfmt.hxx> 72 #include <SwStyleNameMapper.hxx> 73 74 #ifndef _CMDID_H 75 #include <cmdid.h> 76 #endif 77 #ifndef _TABLEDLG_HRC 78 #include <tabledlg.hrc> 79 #endif 80 #ifndef _TABLE_HRC 81 #include <table.hrc> 82 #endif 83 #include <svx/svxids.hrc> 84 #include <svx/dialogs.hrc> 85 #include <svx/flagsdef.hxx> 86 #include <svx/svxdlg.hxx> 87 88 using namespace ::com::sun::star; 89 90 91 #ifdef DEBUG_TBLDLG 92 void DbgTblRep(SwTableRep* pRep) 93 { 94 DBG_ERROR(String(pRep->GetColCount())) 95 DBG_ERROR(String(pRep->GetAllColCount())) 96 SwTwips nSum = 0; 97 for(sal_uInt16 i = 0; i < pRep->GetAllColCount(); i++) 98 { 99 String sMsg(i); 100 sMsg += pRep->GetColumns()[i].bVisible ? " v " : " h "; 101 sMsg += pRep->GetColumns()[i].nWidth; 102 nSum +=pRep->GetColumns()[i].nWidth; 103 DBG_ERROR(sMsg) 104 } 105 String sMsg("Spaltensumme: "); 106 sMsg += nSum; 107 sMsg += " Tblbreite: "; 108 sMsg += pRep->GetWidth(); 109 DBG_ERROR(sMsg) 110 sMsg = "Gesamt/Links/Rechts: "; 111 sMsg += pRep->GetSpace(); 112 sMsg += '/'; 113 sMsg += pRep->GetLeftSpace(); 114 sMsg += '/'; 115 sMsg += pRep->GetRightSpace(); 116 DBG_ERROR(sMsg) 117 sMsg = "Align: "; 118 sMsg += pRep->GetAlign(); 119 DBG_ERROR(sMsg) 120 121 }; 122 123 #endif 124 125 126 SwFormatTablePage::SwFormatTablePage( Window* pParent, const SfxItemSet& rSet ) : 127 SfxTabPage(pParent, SW_RES( TP_FORMAT_TABLE ), rSet ), 128 aOptionsFL(this, SW_RES( FL_OPTIONS )), 129 aNameFT(this, SW_RES( FT_NAME )), 130 aNameED(this, SW_RES( ED_NAME )), 131 aWidthFT(this, SW_RES( FT_WIDTH )), 132 aWidthMF(this, SW_RES( ED_WIDTH )), 133 aRelWidthCB(this, SW_RES( CB_REL_WIDTH )), 134 135 aPosFL(this, SW_RES( FL_POS )), 136 aFullBtn(this, SW_RES( RB_FULL )), 137 aLeftBtn(this, SW_RES( RB_LEFT )), 138 aFromLeftBtn(this, SW_RES( RB_FROM_LEFT )), 139 aRightBtn(this, SW_RES( RB_RIGHT )), 140 aCenterBtn(this, SW_RES( RB_CENTER )), 141 aFreeBtn(this, SW_RES( RB_FREE )), 142 143 aDistFL(this, SW_RES( FL_DIST )), 144 aLeftFT(this, SW_RES( FT_LEFT_DIST )), 145 aLeftMF(this, SW_RES( ED_LEFT_DIST )), 146 aRightFT(this, SW_RES( FT_RIGHT_DIST )), 147 aRightMF(this, SW_RES( ED_RIGHT_DIST )), 148 aTopFT (this, SW_RES( FT_TOP_DIST )), 149 aTopMF(this, SW_RES( ED_TOP_DIST )), 150 aBottomFT(this, SW_RES( FT_BOTTOM_DIST )), 151 aBottomMF(this, SW_RES( ED_BOTTOM_DIST )), 152 153 aPropertiesFL(this, SW_RES( FL_PROPERTIES )), 154 aTextDirectionFT(this, SW_RES( FT_TEXTDIRECTION )), 155 aTextDirectionLB(this, SW_RES( LB_TEXTDIRECTION )), 156 157 pTblData(0), 158 nSaveWidth(0), 159 nMinTableWidth(MINLAY), 160 bModified(sal_False), 161 bFull(0), 162 bHtmlMode(sal_False) 163 { 164 FreeResource(); 165 SetExchangeSupport(); 166 167 const SfxPoolItem* pItem; 168 if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, sal_False, &pItem)) 169 bHtmlMode = 0 != (((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON); 170 171 sal_Bool bCTL = SW_MOD()->GetCTLOptions().IsCTLFontEnabled(); 172 if( !bHtmlMode && bCTL ) 173 { 174 aPropertiesFL.Show(); 175 aTextDirectionFT.Show(); 176 aTextDirectionLB.Show(); 177 } 178 179 Init(); 180 } 181 182 /*------------------------------------------------------------------------ 183 ------------------------------------------------------------------------*/ 184 void SwFormatTablePage::Init() 185 { 186 aLeftMF.MetricField::SetMin(-999999); 187 aRightMF.MetricField::SetMin(-999999); 188 189 // handler 190 Link aLk = LINK( this, SwFormatTablePage, AutoClickHdl ); 191 aFullBtn.SetClickHdl( aLk ); 192 aFreeBtn.SetClickHdl( aLk ); 193 aLeftBtn.SetClickHdl( aLk ); 194 aFromLeftBtn.SetClickHdl( aLk ); 195 aRightBtn.SetClickHdl( aLk ); 196 aCenterBtn.SetClickHdl( aLk ); 197 198 aLk = LINK( this, SwFormatTablePage, UpDownLoseFocusHdl ); 199 aTopMF.SetUpHdl( aLk ); 200 aBottomMF.SetUpHdl( aLk ); 201 aRightMF.SetUpHdl( aLk ); 202 aLeftMF.SetUpHdl( aLk ); 203 aWidthMF.SetUpHdl( aLk ); 204 205 aTopMF.SetDownHdl( aLk ); 206 aBottomMF.SetDownHdl( aLk ); 207 aRightMF.SetDownHdl( aLk ); 208 aLeftMF.SetDownHdl( aLk ); 209 aWidthMF.SetDownHdl( aLk ); 210 211 aTopMF.SetLoseFocusHdl( aLk ); 212 aBottomMF.SetLoseFocusHdl( aLk ); 213 aRightMF.SetLoseFocusHdl( aLk ); 214 aLeftMF.SetLoseFocusHdl( aLk ); 215 aWidthMF.SetLoseFocusHdl( aLk ); 216 217 aRelWidthCB.SetClickHdl(LINK( this, SwFormatTablePage, RelWidthClickHdl )); 218 } 219 220 /*------------------------------------------------------------------------*/ 221 222 IMPL_LINK( SwFormatTablePage, RelWidthClickHdl, CheckBox *, pBtn ) 223 { 224 DBG_ASSERT(pTblData, "Tabellendaten nicht da?"); 225 sal_Bool bIsChecked = pBtn->IsChecked(); 226 sal_Int64 nLeft = aLeftMF.DenormalizePercent(aLeftMF.GetValue(FUNIT_TWIP )); 227 sal_Int64 nRight = aRightMF.DenormalizePercent(aRightMF.GetValue(FUNIT_TWIP )); 228 aWidthMF.ShowPercent(bIsChecked); 229 aLeftMF.ShowPercent(bIsChecked); 230 aRightMF.ShowPercent(bIsChecked); 231 232 if (bIsChecked) 233 { 234 aWidthMF.SetRefValue(pTblData->GetSpace()); 235 aLeftMF.SetRefValue(pTblData->GetSpace()); 236 aRightMF.SetRefValue(pTblData->GetSpace()); 237 aLeftMF.MetricField::SetMin(0); // wird vom Percentfield ueberschrieben 238 aRightMF.MetricField::SetMin(0);// -""- 239 aLeftMF.MetricField::SetMax(99); // 240 aRightMF.MetricField::SetMax(99);// 241 aLeftMF.SetPrcntValue(aLeftMF.NormalizePercent(nLeft ), FUNIT_TWIP ); 242 aRightMF.SetPrcntValue(aRightMF.NormalizePercent(nRight ), FUNIT_TWIP ); 243 } 244 else 245 ModifyHdl(&aLeftMF); // Werte wieder korrigieren 246 247 if(aFreeBtn.IsChecked()) 248 { 249 sal_Bool bEnable = !pBtn->IsChecked(); 250 aRightMF.Enable(bEnable); 251 aRightFT.Enable(bEnable); 252 } 253 bModified = sal_True; 254 255 return 0; 256 } 257 258 /*------------------------------------------------------------------------ 259 ------------------------------------------------------------------------*/ 260 IMPL_LINK( SwFormatTablePage, AutoClickHdl, CheckBox *, pBox ) 261 { 262 sal_Bool bRestore = sal_True, 263 bLeftEnable = sal_False, 264 bRightEnable= sal_False, 265 bWidthEnable= sal_False, 266 bOthers = sal_True; 267 if( (RadioButton *) pBox == &aFullBtn ) 268 { 269 aLeftMF.SetPrcntValue(0); 270 aRightMF.SetPrcntValue(0); 271 nSaveWidth = static_cast< SwTwips >(aWidthMF.DenormalizePercent(aWidthMF.GetValue(FUNIT_TWIP ))); 272 aWidthMF.SetPrcntValue(aWidthMF.NormalizePercent(pTblData->GetSpace() ), FUNIT_TWIP ); 273 bFull = sal_True; 274 bRestore = sal_False; 275 } 276 else if( (RadioButton *) pBox == &aLeftBtn ) 277 { 278 bRightEnable = bWidthEnable = sal_True; 279 aLeftMF.SetPrcntValue(0); 280 } 281 else if( (RadioButton *) pBox == &aFromLeftBtn ) 282 { 283 bLeftEnable = bWidthEnable = sal_True; 284 aRightMF.SetPrcntValue(0); 285 } 286 else if( (RadioButton *) pBox == &aRightBtn ) 287 { 288 bLeftEnable = bWidthEnable = sal_True; 289 aRightMF.SetPrcntValue(0); 290 } 291 else if( ( RadioButton * ) pBox == &aCenterBtn ) 292 { 293 bLeftEnable = bWidthEnable = sal_True; 294 } 295 else if( ( RadioButton * ) pBox == &aFreeBtn ) 296 { 297 RightModifyHdl(&aRightMF); 298 bLeftEnable = sal_True; 299 bWidthEnable = sal_True; 300 bOthers = sal_False; 301 } 302 aLeftMF.Enable(bLeftEnable); 303 aLeftFT.Enable(bLeftEnable); 304 aWidthMF.Enable(bWidthEnable); 305 aWidthFT.Enable(bWidthEnable); 306 if ( bOthers ) 307 { 308 aRightMF.Enable(bRightEnable); 309 aRightFT.Enable(bRightEnable); 310 aRelWidthCB.Enable(bWidthEnable); 311 } 312 313 if(bFull && bRestore) 314 { 315 // nachdem auf autom. geschaltet wurde, wurde die Breite gemerkt, 316 // um sie beim Zurueckschalten restaurieren zu koennen 317 bFull = sal_False; 318 aWidthMF.SetPrcntValue(aWidthMF.NormalizePercent(nSaveWidth ), FUNIT_TWIP ); 319 } 320 ModifyHdl(&aWidthMF); 321 bModified = sal_True; 322 return 0; 323 } 324 325 /*----------------------------------------------------------------------*/ 326 IMPL_LINK( SwFormatTablePage, RightModifyHdl, MetricField *, EMPTYARG ) 327 { 328 if(aFreeBtn.IsChecked()) 329 { 330 sal_Bool bEnable = aRightMF.GetValue() == 0; 331 // aWidthMF.Enable(bEnable); 332 aRelWidthCB.Enable(bEnable); 333 // aWidthFT.Enable(bEnable); 334 if ( !bEnable ) 335 { 336 aRelWidthCB.Check(sal_False); 337 RelWidthClickHdl(&aRelWidthCB); 338 } 339 bEnable = aRelWidthCB.IsChecked(); 340 aRightMF.Enable(!bEnable); 341 aRightFT.Enable(!bEnable); 342 } 343 return 0; 344 } 345 346 /*------------------------------------------------------------------------ 347 ------------------------------------------------------------------------*/ 348 IMPL_LINK_INLINE_START( SwFormatTablePage, UpDownLoseFocusHdl, MetricField *, pEdit ) 349 { 350 if( &aRightMF == pEdit) 351 RightModifyHdl(pEdit); 352 ModifyHdl( pEdit ); 353 return 0; 354 } 355 IMPL_LINK_INLINE_END( SwFormatTablePage, UpDownLoseFocusHdl, MetricField *, pEdit ) 356 357 void SwFormatTablePage::ModifyHdl( Edit* pEdit ) 358 { 359 360 SwTwips nCurWidth = static_cast< SwTwips >(aWidthMF.DenormalizePercent(aWidthMF.GetValue( FUNIT_TWIP ))); 361 SwTwips nPrevWidth = nCurWidth; 362 SwTwips nRight = static_cast< SwTwips >(aRightMF.DenormalizePercent(aRightMF.GetValue( FUNIT_TWIP ))); 363 SwTwips nLeft = static_cast< SwTwips >(aLeftMF.DenormalizePercent(aLeftMF.GetValue( FUNIT_TWIP ))); 364 SwTwips nDiff; 365 366 if( pEdit == &aWidthMF ) 367 { 368 if( nCurWidth < MINLAY ) 369 nCurWidth = MINLAY; 370 nDiff = nRight + nLeft + nCurWidth - pTblData->GetSpace() ; 371 //rechtsbuendig nur linken Rand veraendern 372 if(aRightBtn.IsChecked()) 373 nLeft -= nDiff; 374 //linksbuendig nur rechten Rand veraendern 375 else if(aLeftBtn.IsChecked()) 376 nRight -= nDiff; 377 //linker Rand und Breite erlaubt - erst rechts - dann links 378 else if(aFromLeftBtn.IsChecked()) 379 { 380 if( nRight >= nDiff ) 381 nRight -= nDiff; 382 else 383 { 384 nDiff -= nRight; 385 nRight = 0; 386 if(nLeft >= nDiff) 387 nLeft -= nDiff; 388 else 389 { 390 nRight += nLeft - nDiff; 391 nLeft = 0; 392 nCurWidth = pTblData->GetSpace(); 393 } 394 395 } 396 } 397 //zentriert beide Seiten gleichmaessig veraendern 398 else if(aCenterBtn.IsChecked()) 399 { 400 if((nLeft != nRight)) 401 { 402 nDiff += nLeft + nRight; 403 nLeft = nDiff/2; 404 nRight = nDiff/2; 405 } 406 else 407 { 408 nLeft -= nDiff/2; 409 nRight -= nDiff/2; 410 } 411 } 412 //freie Ausrichtung: beide Raender verkleinern 413 else if(aFreeBtn.IsChecked()) 414 { 415 nLeft -= nDiff/2; 416 nRight -= nDiff/2; 417 } 418 } 419 if( pEdit == &aRightMF ) 420 { 421 422 if( nRight + nLeft > pTblData->GetSpace() - MINLAY ) 423 nRight = pTblData->GetSpace() -nLeft - MINLAY; 424 425 nCurWidth = pTblData->GetSpace() - nLeft - nRight; 426 } 427 if( pEdit == &aLeftMF ) 428 { 429 if(!aFromLeftBtn.IsChecked()) 430 { 431 sal_Bool bCenter = aCenterBtn.IsChecked(); 432 if( bCenter ) 433 nRight = nLeft; 434 if(nRight + nLeft > pTblData->GetSpace() - MINLAY ) 435 { 436 nLeft = bCenter ? (pTblData->GetSpace() - MINLAY) /2 : 437 (pTblData->GetSpace() - MINLAY) - nRight; 438 nRight = bCenter ? (pTblData->GetSpace() - MINLAY) /2 : nRight; 439 } 440 nCurWidth = pTblData->GetSpace() - nLeft - nRight; 441 } 442 else 443 { 444 //hier wird bei Aenderung an der linken Seite zuerst der 445 //rechte Rand veraendert, dann die Breite 446 nDiff = nRight + nLeft + nCurWidth - pTblData->GetSpace() ; 447 448 nRight -= nDiff; 449 nCurWidth = pTblData->GetSpace() - nLeft - nRight; 450 } 451 } 452 if (nCurWidth != nPrevWidth ) 453 aWidthMF.SetPrcntValue( aWidthMF.NormalizePercent( nCurWidth ), FUNIT_TWIP ); 454 aRightMF.SetPrcntValue( aRightMF.NormalizePercent( nRight ), FUNIT_TWIP ); 455 aLeftMF.SetPrcntValue( aLeftMF.NormalizePercent( nLeft ), FUNIT_TWIP ); 456 bModified = sal_True; 457 } 458 459 /*------------------------------------------------------------------------ 460 ------------------------------------------------------------------------*/ 461 SfxTabPage* SwFormatTablePage::Create( Window* pParent, 462 const SfxItemSet& rAttrSet) 463 { 464 return new SwFormatTablePage( pParent, rAttrSet ); 465 } 466 467 /*------------------------------------------------------------------------ 468 -------------------------------------------------------------------------*/ 469 sal_Bool SwFormatTablePage::FillItemSet( SfxItemSet& rCoreSet ) 470 { 471 // Testen, ob eins der Control noch den Focus hat 472 if(aWidthMF.HasFocus()) 473 ModifyHdl(&aWidthMF); 474 else if(aLeftMF.HasFocus()) 475 ModifyHdl(&aLeftMF); 476 else if(aRightMF.HasFocus()) 477 ModifyHdl(&aRightMF); 478 else if(aTopMF.HasFocus()) 479 ModifyHdl(&aTopMF); 480 else if(aBottomMF.HasFocus()) 481 ModifyHdl(&aBottomMF); 482 483 if(bModified) 484 { 485 if( aBottomMF.GetText() != aBottomMF.GetSavedValue() || 486 aTopMF.GetText() != aTopMF.GetSavedValue() ) 487 { 488 SvxULSpaceItem aULSpace(RES_UL_SPACE); 489 aULSpace.SetUpper( (sal_uInt16) aTopMF.Denormalize( 490 aTopMF.GetValue( FUNIT_TWIP ))); 491 aULSpace.SetLower( (sal_uInt16) aBottomMF.Denormalize( 492 aBottomMF.GetValue( FUNIT_TWIP ))); 493 rCoreSet.Put(aULSpace); 494 } 495 496 } 497 if(aNameED.GetText() != aNameED.GetSavedValue()) 498 { 499 rCoreSet.Put(SfxStringItem( FN_PARAM_TABLE_NAME, aNameED.GetText())); 500 bModified = sal_True; 501 } 502 503 sal_uInt16 nPos; 504 if( aTextDirectionLB.IsVisible() && 505 ( nPos = aTextDirectionLB.GetSelectEntryPos() ) != 506 aTextDirectionLB.GetSavedValue() ) 507 { 508 sal_uInt32 nDirection = (sal_uInt32)(sal_uIntPtr)aTextDirectionLB.GetEntryData( nPos ); 509 rCoreSet.Put( SvxFrameDirectionItem( (SvxFrameDirection)nDirection, RES_FRAMEDIR)); 510 bModified = sal_True; 511 } 512 513 return bModified; 514 } 515 516 /*------------------------------------------------------------------------ 517 ------------------------------------------------------------------------*/ 518 void SwFormatTablePage::Reset( const SfxItemSet& ) 519 { 520 const SfxItemSet& rSet = GetItemSet(); 521 const SfxPoolItem* pItem; 522 523 if(bHtmlMode) 524 { 525 aNameED .Disable(); 526 aTopFT .Hide(); 527 aTopMF .Hide(); 528 aBottomFT.Hide(); 529 aBottomMF.Hide(); 530 aFreeBtn.Enable(sal_False); 531 } 532 FieldUnit aMetric = ::GetDfltMetric(bHtmlMode); 533 SetMetric( aWidthMF, aMetric ); 534 SetMetric( aRightMF, aMetric ); 535 SetMetric( aLeftMF, aMetric ); 536 SetMetric( aTopMF, aMetric ); 537 SetMetric( aBottomMF, aMetric ); 538 539 //Name 540 if(SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_TABLE_NAME, sal_False, &pItem )) 541 { 542 aNameED.SetText(((const SfxStringItem*)pItem)->GetValue()); 543 aNameED.SaveValue(); 544 } 545 546 if(SFX_ITEM_SET == rSet.GetItemState( FN_TABLE_REP, sal_False, &pItem )) 547 { 548 pTblData = (SwTableRep*)((const SwPtrItem*) pItem)->GetValue(); 549 nMinTableWidth = pTblData->GetColCount() * MINLAY; 550 551 if(pTblData->GetWidthPercent()) 552 { 553 aRelWidthCB.Check(sal_True); 554 RelWidthClickHdl(&aRelWidthCB); 555 aWidthMF.SetPrcntValue(pTblData->GetWidthPercent(), FUNIT_CUSTOM); 556 557 aWidthMF.SaveValue(); 558 nSaveWidth = static_cast< SwTwips >(aWidthMF.GetValue(FUNIT_CUSTOM)); 559 } 560 else 561 { 562 aWidthMF.SetPrcntValue(aWidthMF.NormalizePercent( 563 pTblData->GetWidth()), FUNIT_TWIP); 564 aWidthMF.SaveValue(); 565 nSaveWidth = pTblData->GetWidth(); 566 nMinTableWidth = Min( nSaveWidth, nMinTableWidth ); 567 } 568 569 aWidthMF.SetRefValue(pTblData->GetSpace()); 570 aWidthMF.SetLast(aWidthMF.NormalizePercent( pTblData->GetSpace() )); 571 aLeftMF.SetLast(aLeftMF.NormalizePercent( pTblData->GetSpace() )); 572 aRightMF.SetLast(aRightMF.NormalizePercent( pTblData->GetSpace() )); 573 574 aLeftMF.SetPrcntValue(aLeftMF.NormalizePercent( 575 pTblData->GetLeftSpace()), FUNIT_TWIP); 576 aRightMF.SetPrcntValue(aRightMF.NormalizePercent( 577 pTblData->GetRightSpace()), FUNIT_TWIP); 578 aLeftMF.SaveValue(); 579 aRightMF.SaveValue(); 580 581 nOldAlign = pTblData->GetAlign(); 582 583 sal_Bool bSetRight = sal_False, bRightEnable = sal_False, 584 bSetLeft = sal_False, bLeftEnable = sal_False; 585 switch( nOldAlign ) 586 { 587 case text::HoriOrientation::NONE: 588 aFreeBtn.Check(); 589 if(aRelWidthCB.IsChecked()) 590 bSetRight = sal_True; 591 break; 592 case text::HoriOrientation::FULL: 593 { 594 bSetRight = bSetLeft = sal_True; 595 aFullBtn.Check(); 596 aWidthMF.Enable(sal_False); 597 aRelWidthCB.Enable(sal_False); 598 aWidthFT.Enable(sal_False); 599 } 600 break; 601 case text::HoriOrientation::LEFT: 602 { 603 bSetLeft = sal_True; 604 aLeftBtn.Check(); 605 } 606 break; 607 case text::HoriOrientation::LEFT_AND_WIDTH : 608 { 609 bSetRight = sal_True; 610 aFromLeftBtn.Check(); 611 } 612 break; 613 case text::HoriOrientation::RIGHT: 614 { 615 bSetRight = sal_True; 616 aRightBtn.Check(); 617 } 618 break; 619 case text::HoriOrientation::CENTER: 620 { 621 bSetRight = sal_True; 622 aCenterBtn.Check(); 623 } 624 break; 625 } 626 if ( bSetRight ) 627 { 628 aRightMF.Enable(bRightEnable); 629 aRightFT.Enable(bRightEnable); 630 } 631 if ( bSetLeft ) 632 { 633 aLeftMF.Enable(bLeftEnable); 634 aLeftFT.Enable(bLeftEnable); 635 } 636 637 } 638 639 //Raender 640 if(SFX_ITEM_SET == rSet.GetItemState( RES_UL_SPACE, sal_False,&pItem )) 641 { 642 aTopMF.SetValue(aTopMF.Normalize( 643 ((const SvxULSpaceItem*)pItem)->GetUpper()), FUNIT_TWIP); 644 aBottomMF.SetValue(aBottomMF.Normalize( 645 ((const SvxULSpaceItem*)pItem)->GetLower()), FUNIT_TWIP); 646 aTopMF.SaveValue(); 647 aBottomMF.SaveValue(); 648 } 649 650 //text direction 651 if( SFX_ITEM_SET == rSet.GetItemState( RES_FRAMEDIR, sal_True, &pItem ) ) 652 { 653 sal_uInt32 nVal = ((SvxFrameDirectionItem*)pItem)->GetValue(); 654 sal_uInt16 nPos = aTextDirectionLB.GetEntryPos( (void*) nVal ); 655 aTextDirectionLB.SelectEntryPos( nPos ); 656 aTextDirectionLB.SaveValue(); 657 } 658 659 aWidthMF.SetMax( 2*aWidthMF.NormalizePercent( pTblData->GetSpace() ), FUNIT_TWIP ); 660 aRightMF.SetMax( aRightMF.NormalizePercent( pTblData->GetSpace() ), FUNIT_TWIP ); 661 aLeftMF.SetMax( aLeftMF.NormalizePercent( pTblData->GetSpace() ), FUNIT_TWIP ); 662 aWidthMF.SetMin( aWidthMF.NormalizePercent( nMinTableWidth ), FUNIT_TWIP ); 663 664 } 665 666 /*------------------------------------------------------------------------ 667 ------------------------------------------------------------------------*/ 668 void SwFormatTablePage::ActivatePage( const SfxItemSet& rSet ) 669 { 670 DBG_ASSERT(pTblData, "Tabellendaten nicht da?"); 671 if(SFX_ITEM_SET == rSet.GetItemState( FN_TABLE_REP )) 672 { 673 SwTwips nCurWidth = text::HoriOrientation::FULL != pTblData->GetAlign() ? 674 pTblData->GetWidth() : 675 pTblData->GetSpace(); 676 if(pTblData->GetWidthPercent() == 0 && 677 nCurWidth != aWidthMF.DenormalizePercent(aWidthMF.GetValue(FUNIT_TWIP ))) 678 { 679 aWidthMF.SetPrcntValue(aWidthMF.NormalizePercent( 680 nCurWidth), FUNIT_TWIP); 681 aWidthMF.SaveValue(); 682 nSaveWidth = nCurWidth; 683 aLeftMF.SetPrcntValue(aLeftMF.NormalizePercent( 684 pTblData->GetLeftSpace()), FUNIT_TWIP); 685 aLeftMF.SaveValue(); 686 aRightMF.SetPrcntValue(aRightMF.NormalizePercent( 687 pTblData->GetRightSpace()), FUNIT_TWIP); 688 aRightMF.SaveValue(); 689 } 690 } 691 692 } 693 /*------------------------------------------------------------------------ 694 ------------------------------------------------------------------------*/ 695 int SwFormatTablePage::DeactivatePage( SfxItemSet* _pSet ) 696 { 697 // os: VCL sorgt nicht dafuer, dass das aktive Control im 698 // dialog bei OK den focus verliert 699 aNameED.GrabFocus(); 700 // Test des Tabellennamens auf Leerzeichen 701 String sTblName = aNameED.GetText(); 702 if(sTblName.Search(' ') != STRING_NOTFOUND) 703 { 704 InfoBox(this, SW_RES(MSG_WRONG_TABLENAME)).Execute(); 705 aNameED.GrabFocus(); 706 return KEEP_PAGE; 707 } 708 if(_pSet) 709 { 710 FillItemSet(*_pSet); 711 if(bModified) 712 { 713 SwTwips lLeft = static_cast< SwTwips >(aLeftMF.DenormalizePercent(aLeftMF.GetValue( FUNIT_TWIP ))); 714 SwTwips lRight = static_cast< SwTwips >(aRightMF.DenormalizePercent(aRightMF.GetValue( FUNIT_TWIP ))); 715 716 717 if( aLeftMF.GetText() != aLeftMF.GetSavedValue() || 718 aRightMF.GetText() != aRightMF.GetSavedValue() ) 719 { 720 pTblData->SetWidthChanged(); 721 pTblData->SetLeftSpace( lLeft); 722 pTblData->SetRightSpace( lRight); 723 } 724 725 SwTwips lWidth; 726 if (aRelWidthCB.IsChecked() && aRelWidthCB.IsEnabled()) 727 { 728 lWidth = pTblData->GetSpace() - lRight - lLeft; 729 sal_uInt16 nPercentWidth = (sal_uInt16)aWidthMF.GetValue(FUNIT_CUSTOM); 730 if(pTblData->GetWidthPercent() != nPercentWidth) 731 { 732 pTblData->SetWidthPercent(nPercentWidth); 733 pTblData->SetWidthChanged(); 734 } 735 } 736 else 737 { 738 pTblData->SetWidthPercent(0); 739 lWidth = static_cast< SwTwips >(aWidthMF.DenormalizePercent(aWidthMF.GetValue( FUNIT_TWIP ))); 740 } 741 pTblData->SetWidth(lWidth); 742 743 SwTwips nColSum = 0; 744 sal_uInt16 i; 745 746 for( i = 0; i < pTblData->GetColCount(); i++) 747 { 748 nColSum += pTblData->GetColumns()[i].nWidth; 749 } 750 if(nColSum != pTblData->GetWidth()) 751 { 752 SwTwips nMinWidth = Min( (long)MINLAY, 753 (long) (pTblData->GetWidth() / 754 pTblData->GetColCount() - 1)); 755 SwTwips nDiff = nColSum - pTblData->GetWidth(); 756 while ( Abs(nDiff) > pTblData->GetColCount() + 1 ) 757 { 758 SwTwips nSub = nDiff / pTblData->GetColCount(); 759 for( i = 0; i < pTblData->GetColCount(); i++) 760 { 761 if(pTblData->GetColumns()[i].nWidth - nMinWidth > nSub) 762 { 763 pTblData->GetColumns()[i].nWidth -= nSub; 764 nDiff -= nSub; 765 } 766 else 767 { 768 nDiff -= pTblData->GetColumns()[i].nWidth - nMinWidth; 769 pTblData->GetColumns()[i].nWidth = nMinWidth; 770 } 771 772 } 773 } 774 } 775 776 sal_Int16 nAlign = 0; 777 if(aRightBtn.IsChecked()) 778 nAlign = text::HoriOrientation::RIGHT; 779 else if(aLeftBtn.IsChecked()) 780 nAlign = text::HoriOrientation::LEFT; 781 else if(aFromLeftBtn.IsChecked()) 782 nAlign = text::HoriOrientation::LEFT_AND_WIDTH; 783 else if(aCenterBtn.IsChecked()) 784 nAlign = text::HoriOrientation::CENTER; 785 else if(aFreeBtn.IsChecked()) 786 nAlign = text::HoriOrientation::NONE; 787 else if(aFullBtn.IsChecked()) 788 { 789 nAlign = text::HoriOrientation::FULL; 790 lWidth = lAutoWidth; 791 } 792 if(nAlign != pTblData->GetAlign()) 793 { 794 pTblData->SetWidthChanged(); 795 pTblData->SetAlign(nAlign); 796 } 797 798 799 // if( text::HoriOrientation::CENTER && lWidth != (SwTwips)aWidthMF.GetSavedValue()) 800 if(pTblData->GetWidth() != lWidth ) 801 { 802 pTblData->SetWidthChanged(); 803 pTblData->SetWidth( 804 nAlign == text::HoriOrientation::FULL ? pTblData->GetSpace() : lWidth ); 805 } 806 if(pTblData->HasWidthChanged()) 807 _pSet->Put(SwPtrItem(FN_TABLE_REP, pTblData)); 808 } 809 #ifdef DEBUG_TBLDLG 810 DbgTblRep(pTblData) 811 #endif 812 } 813 return sal_True; 814 } 815 /*------------------------------------------------------------------------ 816 Beschreibung: Seite Spaltenkonfiguration 817 ------------------------------------------------------------------------*/ 818 SwTableColumnPage::SwTableColumnPage( Window* pParent, 819 const SfxItemSet& rSet ) : 820 SfxTabPage(pParent, SW_RES( TP_TABLE_COLUMN ), rSet ), 821 aModifyTableCB(this, SW_RES(CB_MOD_TBL)), 822 aProportionalCB(this, SW_RES(CB_PROP)), 823 aSpaceFT(this, SW_RES(FT_SPACE)), 824 aSpaceED(this, SW_RES(ED_SPACE)), 825 826 aColFL(this, SW_RES(COL_FL_LAYOUT)), 827 aUpBtn(this, SW_RES(COL_BTN_UP)), 828 aFT1(this, SW_RES(COL_FT_1)), 829 aMF1(this, SW_RES(COL_MF_1)), 830 aFT2(this, SW_RES(COL_FT_2)), 831 aMF2(this, SW_RES(COL_MF_2)), 832 aFT3(this, SW_RES(COL_FT_3)), 833 aMF3(this, SW_RES(COL_MF_3)), 834 aFT4(this, SW_RES(COL_FT_4)), 835 aMF4(this, SW_RES(COL_MF_4)), 836 aFT5(this, SW_RES(COL_FT_5)), 837 aMF5(this, SW_RES(COL_MF_5)), 838 aFT6(this, SW_RES(COL_FT_6)), 839 aMF6(this, SW_RES(COL_MF_6)), 840 aDownBtn(this, SW_RES(COL_BTN_DOWN)), 841 842 nTableWidth(0), 843 nMinWidth( MINLAY ), 844 nNoOfCols( 0 ), 845 nNoOfVisibleCols( 0 ), 846 bModified(sal_False), 847 bModifyTbl(sal_False), 848 bPercentMode(sal_False) 849 { 850 FreeResource(); 851 SetExchangeSupport(); 852 853 aDownBtn.SetAccessibleRelationMemberOf(&aColFL); 854 aUpBtn.SetAccessibleRelationMemberOf(&aColFL); 855 856 pFieldArr[0] = &aMF1; 857 pFieldArr[1] = &aMF2; 858 pFieldArr[2] = &aMF3; 859 pFieldArr[3] = &aMF4; 860 pFieldArr[4] = &aMF5; 861 pFieldArr[5] = &aMF6; 862 863 pTextArr[0] = &aFT1; 864 pTextArr[1] = &aFT2; 865 pTextArr[2] = &aFT3; 866 pTextArr[3] = &aFT4; 867 pTextArr[4] = &aFT5; 868 pTextArr[5] = &aFT6; 869 870 const SfxPoolItem* pItem; 871 Init((SFX_ITEM_SET == rSet.GetItemState( SID_HTML_MODE, sal_False,&pItem ) 872 && ((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON)); 873 874 }; 875 /*------------------------------------------------------------------------ 876 Beschreibung: Seite Spaltenkonfiguration 877 ------------------------------------------------------------------------*/ 878 SwTableColumnPage::~SwTableColumnPage() 879 { 880 }; 881 882 /*------------------------------------------------------------------------ 883 ------------------------------------------------------------------------*/ 884 SfxTabPage* SwTableColumnPage::Create( Window* pParent, 885 const SfxItemSet& rAttrSet) 886 { 887 return new SwTableColumnPage( pParent, rAttrSet ); 888 }; 889 890 /*------------------------------------------------------------------------ 891 ------------------------------------------------------------------------*/ 892 void SwTableColumnPage::Reset( const SfxItemSet& ) 893 { 894 const SfxItemSet& rSet = GetItemSet(); 895 896 const SfxPoolItem* pItem; 897 if(SFX_ITEM_SET == rSet.GetItemState( FN_TABLE_REP, sal_False, &pItem )) 898 { 899 pTblData = (SwTableRep*)((const SwPtrItem*) pItem)->GetValue(); 900 nNoOfVisibleCols = pTblData->GetColCount(); 901 nNoOfCols = pTblData->GetAllColCount(); 902 nTableWidth = pTblData->GetAlign() != text::HoriOrientation::FULL && 903 pTblData->GetAlign() != text::HoriOrientation::LEFT_AND_WIDTH? 904 pTblData->GetWidth() : pTblData->GetSpace(); 905 906 sal_uInt16 i; 907 for( i = 0; i < nNoOfCols; i++ ) 908 { 909 if( pTblData->GetColumns()[i].nWidth < nMinWidth ) 910 nMinWidth = pTblData->GetColumns()[i].nWidth; 911 } 912 sal_Int64 nMinTwips = pFieldArr[0]->NormalizePercent( nMinWidth ); 913 sal_Int64 nMaxTwips = pFieldArr[0]->NormalizePercent( nTableWidth ); 914 for( i = 0; (i < MET_FIELDS) && (i < nNoOfVisibleCols); i++ ) 915 { 916 pFieldArr[i]->SetPrcntValue( pFieldArr[i]->NormalizePercent( 917 GetVisibleWidth(i) ), FUNIT_TWIP ); 918 pFieldArr[i]->SetMin( nMinTwips , FUNIT_TWIP ); 919 pFieldArr[i]->SetMax( nMaxTwips , FUNIT_TWIP ); 920 pFieldArr[i]->Enable(); 921 pTextArr[i]->Enable(); 922 } 923 924 if( nNoOfVisibleCols > MET_FIELDS ) 925 aUpBtn.Enable(); 926 i = nNoOfVisibleCols; 927 while( i < MET_FIELDS ) 928 { 929 pFieldArr[i]->SetText( aEmptyStr ); 930 pTextArr[i]->Hide(); 931 i++; 932 } 933 } 934 ActivatePage(rSet); 935 936 }; 937 938 /*------------------------------------------------------------------------ 939 ------------------------------------------------------------------------*/ 940 void SwTableColumnPage::Init(sal_Bool bWeb) 941 { 942 FieldUnit aMetric = ::GetDfltMetric(bWeb); 943 Link aLkUp = LINK( this, SwTableColumnPage, UpHdl ); 944 Link aLkDown = LINK( this, SwTableColumnPage, DownHdl ); 945 Link aLkLF = LINK( this, SwTableColumnPage, LoseFocusHdl ); 946 for( sal_uInt16 i = 0; i < MET_FIELDS; i++ ) 947 { 948 aValueTbl[i] = i; 949 SetMetric(*pFieldArr[i], aMetric); 950 pFieldArr[i]->SetUpHdl( aLkUp ); 951 pFieldArr[i]->SetDownHdl( aLkDown ); 952 pFieldArr[i]->SetLoseFocusHdl( aLkLF ); 953 954 } 955 SetMetric(aSpaceED, aMetric); 956 957 Link aLk = LINK( this, SwTableColumnPage, AutoClickHdl ); 958 aUpBtn.SetClickHdl( aLk ); 959 aDownBtn.SetClickHdl( aLk ); 960 961 aLk = LINK( this, SwTableColumnPage, ModeHdl ); 962 aModifyTableCB .SetClickHdl( aLk ); 963 aProportionalCB.SetClickHdl( aLk ); 964 }; 965 966 /*------------------------------------------------------------------------ 967 ------------------------------------------------------------------------*/ 968 IMPL_LINK( SwTableColumnPage, AutoClickHdl, CheckBox *, pBox ) 969 { 970 //Anzeigefenster verschieben 971 if(pBox == (CheckBox *)&aDownBtn) 972 { 973 if(aValueTbl[0] > 0) 974 { 975 for( sal_uInt16 i=0; i < MET_FIELDS; i++ ) 976 aValueTbl[i] -= 1; 977 } 978 } 979 if(pBox == (CheckBox *)&aUpBtn) 980 { 981 if( aValueTbl[ MET_FIELDS -1 ] < nNoOfVisibleCols -1 ) 982 { 983 for(sal_uInt16 i=0;i < MET_FIELDS;i++) 984 aValueTbl[i] += 1; 985 } 986 } 987 for( sal_uInt16 i = 0; (i < nNoOfVisibleCols ) && ( i < MET_FIELDS); i++ ) 988 { 989 String sEntry('~'); 990 String sIndex = String::CreateFromInt32( aValueTbl[i] + 1 ); 991 sEntry += sIndex; 992 pTextArr[i]->SetText( sEntry ); 993 String sColumnWidth = SW_RESSTR( STR_ACCESS_COLUMN_WIDTH); 994 sColumnWidth.SearchAndReplace( DEFINE_CONST_UNICODE("%1"), sIndex ); 995 pFieldArr[i]->SetAccessibleName( sColumnWidth ); 996 } 997 998 aDownBtn.Enable(aValueTbl[0] > 0); 999 aUpBtn.Enable(aValueTbl[ MET_FIELDS -1 ] < nNoOfVisibleCols -1 ); 1000 UpdateCols(0); 1001 return 0; 1002 }; 1003 1004 /*------------------------------------------------------------------------ 1005 ------------------------------------------------------------------------*/ 1006 IMPL_LINK_INLINE_START( SwTableColumnPage, UpHdl, PercentField *, pEdit ) 1007 { 1008 bModified = sal_True; 1009 ModifyHdl( pEdit ); 1010 return 0; 1011 }; 1012 IMPL_LINK_INLINE_END( SwTableColumnPage, UpHdl, PercentField *, pEdit ) 1013 1014 /*------------------------------------------------------------------------ 1015 ------------------------------------------------------------------------*/ 1016 IMPL_LINK_INLINE_START( SwTableColumnPage, DownHdl, PercentField *, pEdit ) 1017 { 1018 bModified = sal_True; 1019 ModifyHdl( pEdit ); 1020 return 0; 1021 }; 1022 IMPL_LINK_INLINE_END( SwTableColumnPage, DownHdl, PercentField *, pEdit ) 1023 1024 /*------------------------------------------------------------------------ 1025 ------------------------------------------------------------------------*/ 1026 IMPL_LINK_INLINE_START( SwTableColumnPage, LoseFocusHdl, PercentField *, pEdit ) 1027 { 1028 if(pEdit->IsModified()) 1029 { 1030 bModified = sal_True; 1031 ModifyHdl( pEdit ); 1032 } 1033 return 0; 1034 }; 1035 IMPL_LINK_INLINE_END( SwTableColumnPage, LoseFocusHdl, PercentField *, pEdit ) 1036 1037 /*------------------------------------------------------------------------ 1038 ------------------------------------------------------------------------*/ 1039 IMPL_LINK( SwTableColumnPage, ModeHdl, CheckBox*, pBox ) 1040 { 1041 sal_Bool bCheck = pBox->IsChecked(); 1042 if(pBox == &aProportionalCB) 1043 { 1044 if(bCheck) 1045 aModifyTableCB.Check(); 1046 aModifyTableCB.Enable(!bCheck && bModifyTbl); 1047 } 1048 return 0; 1049 }; 1050 1051 /*------------------------------------------------------------------------ 1052 ------------------------------------------------------------------------*/ 1053 sal_Bool SwTableColumnPage::FillItemSet( SfxItemSet& ) 1054 { 1055 for( sal_uInt16 i = 0; i < MET_FIELDS; i++ ) 1056 { 1057 if(pFieldArr[i]->HasFocus()) 1058 { 1059 LoseFocusHdl(pFieldArr[i]); 1060 break; 1061 } 1062 } 1063 1064 if(bModified) 1065 { 1066 pTblData->SetColsChanged(); 1067 } 1068 return bModified; 1069 }; 1070 1071 /*------------------------------------------------------------------------ 1072 ------------------------------------------------------------------------*/ 1073 void SwTableColumnPage::ModifyHdl( PercentField* pEdit ) 1074 { 1075 sal_uInt16 nAktPos; 1076 sal_uInt16 i; 1077 1078 for( i = 0; i < MET_FIELDS; i++) 1079 if(pEdit == pFieldArr[i]) 1080 break; 1081 1082 if (MET_FIELDS <= i) 1083 { 1084 OSL_ENSURE(false, "cannot happen."); 1085 return; 1086 } 1087 1088 SetVisibleWidth(aValueTbl[i], static_cast< SwTwips >(pEdit->DenormalizePercent(pEdit->GetValue( FUNIT_TWIP ))) ); 1089 nAktPos = aValueTbl[i]; 1090 1091 UpdateCols( nAktPos ); 1092 }; 1093 1094 /*------------------------------------------------------------------------ 1095 ------------------------------------------------------------------------*/ 1096 void SwTableColumnPage::UpdateCols( sal_uInt16 nAktPos ) 1097 { 1098 SwTwips nSum = 0; 1099 sal_uInt16 i; 1100 1101 for( i = 0; i < nNoOfCols; i++ ) 1102 { 1103 nSum += (pTblData->GetColumns())[i].nWidth; 1104 } 1105 SwTwips nDiff = nSum - nTableWidth; 1106 1107 sal_Bool bModifyTable = aModifyTableCB.IsChecked(); 1108 sal_Bool bProp = aProportionalCB.IsChecked(); 1109 1110 if(!bModifyTable && !bProp ) 1111 { 1112 // the table width is constant, the difference is balanced with the other columns 1113 sal_uInt16 nLoopCount = 0; 1114 while( nDiff ) 1115 { 1116 if( ++nAktPos == nNoOfVisibleCols) 1117 { 1118 nAktPos = 0; 1119 ++nLoopCount; 1120 //#i101353# in small tables it might not be possible to balance column width 1121 if( nLoopCount > 1 ) 1122 break; 1123 } 1124 if( nDiff < 0 ) 1125 { 1126 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) -nDiff); 1127 nDiff = 0; 1128 } 1129 else if( GetVisibleWidth(nAktPos) >= nDiff + nMinWidth ) 1130 { 1131 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) -nDiff); 1132 nDiff = 0; 1133 } 1134 if( nDiff > 0 && GetVisibleWidth(nAktPos) > nMinWidth ) 1135 { 1136 if( nDiff >= (GetVisibleWidth(nAktPos) - nMinWidth) ) 1137 { 1138 nDiff -= (GetVisibleWidth(nAktPos) - nMinWidth); 1139 SetVisibleWidth(nAktPos, nMinWidth); 1140 } 1141 else 1142 { 1143 nDiff = 0; 1144 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) -nDiff); 1145 } 1146 DBG_ASSERT(nDiff >= 0, "nDiff < 0 kann hier nicht sein!"); 1147 } 1148 } 1149 } 1150 else if(bModifyTable && !bProp) 1151 { 1152 // Differenz wird ueber die Tabellenbreite ausgeglichen, 1153 // andere Spalten bleiben unveraendert 1154 DBG_ASSERT(nDiff <= pTblData->GetSpace() - nTableWidth, "Maximum falsch eingestellt" ); 1155 SwTwips nActSpace = pTblData->GetSpace() - nTableWidth; 1156 if(nDiff > nActSpace) 1157 { 1158 nTableWidth = pTblData->GetSpace(); 1159 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) - nDiff + nActSpace ); 1160 } 1161 else 1162 { 1163 nTableWidth += nDiff; 1164 } 1165 } 1166 else if(bModifyTable & bProp) 1167 { 1168 // Alle Spalten werden proportional mitveraendert, die Tabellenbreite wird 1169 // entsprechend angepasst 1170 DBG_ASSERT(nDiff * nNoOfVisibleCols <= pTblData->GetSpace() - nTableWidth, "Maximum falsch eingestellt" ); 1171 long nAdd = nDiff; 1172 if(nDiff * nNoOfVisibleCols > pTblData->GetSpace() - nTableWidth) 1173 { 1174 nAdd = (pTblData->GetSpace() - nTableWidth) / nNoOfVisibleCols; 1175 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) - nDiff + nAdd ); 1176 nDiff = nAdd; 1177 } 1178 if(nAdd) 1179 for(i = 0; i < nNoOfVisibleCols; i++ ) 1180 { 1181 if(i == nAktPos) 1182 continue; 1183 SwTwips nVisWidth; 1184 if((nVisWidth = GetVisibleWidth(i)) + nDiff < MINLAY) 1185 { 1186 nAdd += nVisWidth - MINLAY; 1187 SetVisibleWidth(i, MINLAY); 1188 } 1189 else 1190 { 1191 SetVisibleWidth(i, nVisWidth + nDiff); 1192 nAdd += nDiff; 1193 } 1194 1195 } 1196 nTableWidth += nAdd; 1197 1198 } 1199 else 1200 { 1201 // Die Differenz wird gleichmaessig auf alle anderen Spalten aufgeteilt 1202 // die Tabellenbreite bleibt konstant 1203 /* 1204 SwTwips nDiffn = nDiff/(nNoOfVisibleCols - 1); 1205 if(nDiff < 0 && (nNoOfVisibleCols - 1) * nDiffn != nDiff) 1206 nDiffn-- ; 1207 sal_uInt16 nStart = nAktPos++; 1208 if(nAktPos == nNoOfVisibleCols) 1209 nStart = 0; 1210 for(sal_uInt16 i = 0; i < nNoOfVisibleCols; i++ ) 1211 { 1212 if((nVisWidth = GetVisibleWidth(i)) + nDiff < MINLAY) 1213 { 1214 nAdd += nVisWidth - MINLAY; 1215 SetVisibleWidth(i, MINLAY); 1216 } 1217 } 1218 */ 1219 1220 } 1221 1222 #ifdef DEBUG_TBLDLG 1223 DbgTblRep(pTblData) 1224 #endif 1225 1226 if(!bPercentMode) 1227 aSpaceED.SetValue(aSpaceED.Normalize( pTblData->GetSpace() - nTableWidth) , FUNIT_TWIP); 1228 1229 for( i = 0; ( i < nNoOfVisibleCols ) && ( i < MET_FIELDS ); i++) 1230 { 1231 pFieldArr[i]->SetPrcntValue(pFieldArr[i]->NormalizePercent( 1232 GetVisibleWidth(aValueTbl[i]) ), FUNIT_TWIP); 1233 pFieldArr[i]->ClearModifyFlag(); 1234 } 1235 1236 } 1237 1238 /*------------------------------------------------------------------------ 1239 ------------------------------------------------------------------------*/ 1240 void SwTableColumnPage::ActivatePage( const SfxItemSet& ) 1241 { 1242 bPercentMode = pTblData->GetWidthPercent() != 0; 1243 for( sal_uInt16 i = 0; (i < MET_FIELDS) && (i < nNoOfVisibleCols); i++ ) 1244 { 1245 pFieldArr[i]->SetRefValue(pTblData->GetWidth()); 1246 pFieldArr[i]->ShowPercent( bPercentMode ); 1247 } 1248 1249 sal_uInt16 nTblAlign = pTblData->GetAlign(); 1250 if((text::HoriOrientation::FULL != nTblAlign && nTableWidth != pTblData->GetWidth()) || 1251 (text::HoriOrientation::FULL == nTblAlign && nTableWidth != pTblData->GetSpace())) 1252 { 1253 nTableWidth = text::HoriOrientation::FULL == nTblAlign ? 1254 pTblData->GetSpace() : 1255 pTblData->GetWidth(); 1256 UpdateCols(0); 1257 } 1258 bModifyTbl = sal_True; 1259 if(pTblData->GetWidthPercent() || 1260 text::HoriOrientation::FULL == nTblAlign || 1261 pTblData->IsLineSelected() ) 1262 bModifyTbl = sal_False; 1263 if(bPercentMode) 1264 { 1265 aModifyTableCB .Check(sal_False); 1266 aProportionalCB .Check(sal_False); 1267 } 1268 else if( !bModifyTbl ) 1269 { 1270 aProportionalCB.Check(sal_False); 1271 aModifyTableCB.Check(sal_False); 1272 } 1273 aSpaceFT.Enable(!bPercentMode); 1274 aSpaceED.Enable(!bPercentMode); 1275 aModifyTableCB.Enable( !bPercentMode && bModifyTbl ); 1276 aProportionalCB.Enable(!bPercentMode && bModifyTbl ); 1277 1278 /* if(pTblData->IsLineSelected() && pTblData->IsComplex()) 1279 { 1280 1281 }*/ 1282 aSpaceED.SetValue(aSpaceED.Normalize( 1283 pTblData->GetSpace() - nTableWidth) , FUNIT_TWIP); 1284 1285 } 1286 1287 /*------------------------------------------------------------------------ 1288 ------------------------------------------------------------------------*/ 1289 int SwTableColumnPage::DeactivatePage( SfxItemSet* _pSet ) 1290 { 1291 if(_pSet) 1292 { 1293 FillItemSet(*_pSet); 1294 if(text::HoriOrientation::FULL != pTblData->GetAlign() && pTblData->GetWidth() != nTableWidth) 1295 { 1296 pTblData->SetWidth(nTableWidth); 1297 SwTwips nDiff = pTblData->GetSpace() - pTblData->GetWidth() - 1298 pTblData->GetLeftSpace() - pTblData->GetRightSpace(); 1299 switch( pTblData->GetAlign() ) 1300 { 1301 case text::HoriOrientation::RIGHT: 1302 pTblData->SetLeftSpace(pTblData->GetLeftSpace() + nDiff); 1303 break; 1304 case text::HoriOrientation::LEFT: 1305 pTblData->SetRightSpace(pTblData->GetRightSpace() + nDiff); 1306 break; 1307 case text::HoriOrientation::NONE: 1308 { 1309 SwTwips nDiff2 = nDiff/2; 1310 if( nDiff > 0 || 1311 (-nDiff2 < pTblData->GetRightSpace() && - nDiff2 < pTblData->GetLeftSpace())) 1312 { 1313 pTblData->SetRightSpace(pTblData->GetRightSpace() + nDiff2); 1314 pTblData->SetLeftSpace(pTblData->GetLeftSpace() + nDiff2); 1315 } 1316 else 1317 { 1318 if(pTblData->GetRightSpace() > pTblData->GetLeftSpace()) 1319 { 1320 pTblData->SetLeftSpace(0); 1321 pTblData->SetRightSpace(pTblData->GetSpace() - pTblData->GetWidth()); 1322 } 1323 else 1324 { 1325 pTblData->SetRightSpace(0); 1326 pTblData->SetLeftSpace(pTblData->GetSpace() - pTblData->GetWidth()); 1327 } 1328 } 1329 } 1330 break; 1331 case text::HoriOrientation::CENTER: 1332 pTblData->SetRightSpace(pTblData->GetRightSpace() + nDiff/2); 1333 pTblData->SetLeftSpace(pTblData->GetLeftSpace() + nDiff/2); 1334 break; 1335 case text::HoriOrientation::LEFT_AND_WIDTH : 1336 if(nDiff > pTblData->GetRightSpace()) 1337 { 1338 pTblData->SetLeftSpace(pTblData->GetSpace() - pTblData->GetWidth()); 1339 } 1340 pTblData->SetRightSpace( 1341 pTblData->GetSpace() - pTblData->GetWidth() - pTblData->GetLeftSpace()); 1342 break; 1343 } 1344 pTblData->SetWidthChanged(); 1345 } 1346 #ifdef DEBUG_TBLDLG 1347 DbgTblRep(pTblData) 1348 #endif 1349 _pSet->Put(SwPtrItem( FN_TABLE_REP, pTblData )); 1350 } 1351 return sal_True; 1352 } 1353 1354 /*------------------------------------------------------------------------ 1355 ------------------------------------------------------------------------*/ 1356 SwTwips SwTableColumnPage::GetVisibleWidth(sal_uInt16 nPos) 1357 { 1358 sal_uInt16 i=0; 1359 1360 while( nPos ) 1361 { 1362 if(pTblData->GetColumns()[i].bVisible && nPos) 1363 nPos--; 1364 i++; 1365 } 1366 SwTwips nReturn = pTblData->GetColumns()[i].nWidth; 1367 DBG_ASSERT(i < nNoOfCols, "Array index out of range"); 1368 while(!pTblData->GetColumns()[i].bVisible && (i + 1) < nNoOfCols) 1369 nReturn += pTblData->GetColumns()[++i].nWidth; 1370 1371 // return (*ppTableColumns)[i].nWidth; 1372 return nReturn; 1373 } 1374 1375 /*------------------------------------------------------------------------ 1376 ------------------------------------------------------------------------*/ 1377 void SwTableColumnPage::SetVisibleWidth(sal_uInt16 nPos, SwTwips nNewWidth) 1378 { 1379 sal_uInt16 i=0; 1380 while( nPos ) 1381 { 1382 if(pTblData->GetColumns()[i].bVisible && nPos) 1383 nPos--; 1384 i++; 1385 } 1386 DBG_ASSERT(i < nNoOfCols, "Array index out of range"); 1387 pTblData->GetColumns()[i].nWidth = nNewWidth; 1388 while(!pTblData->GetColumns()[i].bVisible && (i + 1) < nNoOfCols) 1389 pTblData->GetColumns()[++i].nWidth = 0; 1390 1391 } 1392 1393 /*------------------------------------------------------------------------ 1394 ------------------------------------------------------------------------*/ 1395 SwTableTabDlg::SwTableTabDlg(Window* pParent, SfxItemPool& , 1396 const SfxItemSet* pItemSet, SwWrtShell* pSh ) : 1397 SfxTabDialog(pParent, SW_RES(DLG_FORMAT_TABLE), pItemSet,0), 1398 pShell(pSh), 1399 nHtmlMode(::GetHtmlMode(pSh->GetView().GetDocShell())) 1400 { 1401 FreeResource(); 1402 SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); 1403 DBG_ASSERT(pFact, "Dialogdiet fail!"); 1404 AddTabPage(TP_FORMAT_TABLE, &SwFormatTablePage::Create, 0 ); 1405 AddTabPage(TP_TABLE_TEXTFLOW, &SwTextFlowPage::Create, 0 ); 1406 AddTabPage(TP_TABLE_COLUMN, &SwTableColumnPage::Create, 0 ); 1407 AddTabPage(TP_BACKGROUND, pFact->GetTabPageCreatorFunc( RID_SVXPAGE_BACKGROUND ), 0 ); 1408 AddTabPage(TP_BORDER, pFact->GetTabPageCreatorFunc( RID_SVXPAGE_BORDER ), 0 ); 1409 } 1410 1411 1412 /*------------------------------------------------------------------------ 1413 ------------------------------------------------------------------------*/ 1414 void SwTableTabDlg::PageCreated(sal_uInt16 nId, SfxTabPage& rPage) 1415 { 1416 SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool())); 1417 if( TP_BACKGROUND == nId ) 1418 { 1419 sal_Int32 nFlagType = SVX_SHOW_TBLCTL; 1420 if(!( nHtmlMode & HTMLMODE_ON ) || 1421 nHtmlMode & HTMLMODE_SOME_STYLES) 1422 nFlagType |= SVX_SHOW_SELECTOR; 1423 aSet.Put (SfxUInt32Item(SID_FLAG_TYPE, nFlagType)); 1424 rPage.PageCreated(aSet); 1425 } 1426 else if(TP_BORDER == nId) 1427 { 1428 aSet.Put (SfxUInt16Item(SID_SWMODE_TYPE,SW_BORDER_MODE_TABLE)); 1429 rPage.PageCreated(aSet); 1430 } 1431 else if(TP_TABLE_TEXTFLOW == nId) 1432 { 1433 ((SwTextFlowPage&)rPage).SetShell(pShell); 1434 const sal_uInt16 eType = pShell->GetFrmType(0,sal_True); 1435 if( !(FRMTYPE_BODY & eType) ) 1436 ((SwTextFlowPage&)rPage).DisablePageBreak(); 1437 } 1438 } 1439 1440 /*-----------------12.12.96 12.22------------------- 1441 --------------------------------------------------*/ 1442 SwTextFlowPage::SwTextFlowPage( Window* pParent, 1443 const SfxItemSet& rSet ) : 1444 SfxTabPage(pParent, SW_RES( TP_TABLE_TEXTFLOW ), rSet ), 1445 aFlowFL (this, SW_RES(FL_FLOW )), 1446 aPgBrkCB (this, SW_RES(CB_PAGEBREAK )), 1447 aPgBrkRB (this, SW_RES(RB_BREAKPAGE )), 1448 aColBrkRB (this, SW_RES(RB_BREAKCOLUMN )), 1449 aPgBrkBeforeRB (this, SW_RES(RB_PAGEBREAKBEFORE)), 1450 aPgBrkAfterRB (this, SW_RES(RB_PAGEBREAKAFTER )), 1451 aPageCollCB (this, SW_RES(CB_PAGECOLL )), 1452 aPageCollLB (this, SW_RES(LB_PAGECOLL )), 1453 aPageNoFT (this, SW_RES(FT_PAGENUM )), 1454 aPageNoNF (this, SW_RES(NF_PAGENUM )), 1455 aSplitCB (this, SW_RES(CB_SPLIT )), 1456 aSplitRowCB (this, SW_RES(CB_SPLIT_ROW )), 1457 aKeepCB (this, SW_RES(CB_KEEP )), 1458 aHeadLineCB (this, SW_RES(CB_HEADLINE )), 1459 aRepeatHeaderFT (this, SW_RES(FT_REPEAT_HEADER )), 1460 aRepeatHeaderBeforeFT (this), 1461 aRepeatHeaderNF (this, SW_RES(NF_REPEAT_HEADER )), 1462 aRepeatHeaderAfterFT (this), 1463 aRepeatHeaderCombo (this, SW_RES(WIN_REPEAT_HEADER), aRepeatHeaderNF, aRepeatHeaderBeforeFT, aRepeatHeaderAfterFT), 1464 aTextDirectionFT(this, SW_RES(FT_TEXTDIRECTION )), 1465 aTextDirectionLB(this, SW_RES(LB_TEXTDIRECTION )), 1466 1467 aVertOrientFL (this, SW_RES(FL_VERT_ORIENT )), 1468 aVertOrientFT(this, SW_RES(FT_VERTORIENT )), 1469 aVertOrientLB(this, SW_RES(LB_VERTORIENT )), 1470 1471 pShell(0), 1472 1473 bPageBreak(sal_True), 1474 bHtmlMode(sal_False) 1475 { 1476 FreeResource(); 1477 1478 aPgBrkRB.SetAccessibleRelationMemberOf(&aPgBrkCB); 1479 aColBrkRB.SetAccessibleRelationMemberOf(&aPgBrkCB); 1480 aPgBrkBeforeRB.SetAccessibleRelationMemberOf(&aPgBrkCB); 1481 aPgBrkAfterRB.SetAccessibleRelationMemberOf(&aPgBrkCB); 1482 aPageCollLB.SetAccessibleRelationLabeledBy(&aPageCollCB); 1483 aPageCollLB.SetAccessibleName(aPageCollCB.GetText()); 1484 1485 aPgBrkCB.SetClickHdl(LINK(this, SwTextFlowPage, PageBreakHdl_Impl)); 1486 aPgBrkBeforeRB.SetClickHdl( 1487 LINK( this, SwTextFlowPage, PageBreakPosHdl_Impl ) ); 1488 aPgBrkAfterRB.SetClickHdl( 1489 LINK( this, SwTextFlowPage, PageBreakPosHdl_Impl ) ); 1490 aPageCollCB.SetClickHdl( 1491 LINK( this, SwTextFlowPage, ApplyCollClickHdl_Impl ) ); 1492 aColBrkRB.SetClickHdl( 1493 LINK( this, SwTextFlowPage, PageBreakTypeHdl_Impl ) ); 1494 aPgBrkRB.SetClickHdl( 1495 LINK( this, SwTextFlowPage, PageBreakTypeHdl_Impl ) ); 1496 aSplitCB.SetClickHdl( 1497 LINK( this, SwTextFlowPage, SplitHdl_Impl)); 1498 aSplitRowCB.SetClickHdl( 1499 LINK( this, SwTextFlowPage, SplitRowHdl_Impl)); 1500 aHeadLineCB.SetClickHdl( LINK( this, SwTextFlowPage, HeadLineCBClickHdl ) ); 1501 1502 #ifndef SW_FILEFORMAT_40 1503 const SfxPoolItem *pItem; 1504 if(SFX_ITEM_SET == rSet.GetItemState( SID_HTML_MODE, sal_False,&pItem ) 1505 && ((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON) 1506 #endif 1507 { 1508 aKeepCB.Hide(); 1509 aSplitCB.Hide(); 1510 aSplitRowCB.Hide(); 1511 } 1512 1513 aRepeatHeaderCombo.Arrange( aRepeatHeaderFT ); 1514 1515 HeadLineCBClickHdl(); 1516 } 1517 1518 /*-----------------12.12.96 12.22------------------- 1519 --------------------------------------------------*/ 1520 SwTextFlowPage::~SwTextFlowPage() 1521 { 1522 } 1523 1524 /*-----------------12.12.96 12.22------------------- 1525 --------------------------------------------------*/ 1526 SfxTabPage* SwTextFlowPage::Create( Window* pParent, 1527 const SfxItemSet& rAttrSet) 1528 { 1529 return new SwTextFlowPage(pParent, rAttrSet); 1530 } 1531 1532 /*-----------------12.12.96 12.22------------------- 1533 --------------------------------------------------*/ 1534 sal_Bool SwTextFlowPage::FillItemSet( SfxItemSet& rSet ) 1535 { 1536 sal_Bool bModified = sal_False; 1537 1538 //Ueberschrift wiederholen 1539 if(aHeadLineCB.IsChecked() != aHeadLineCB.GetSavedValue() || 1540 String::CreateFromInt32( static_cast< sal_Int32 >(aRepeatHeaderNF.GetValue()) ) != aRepeatHeaderNF.GetSavedValue() ) 1541 { 1542 bModified |= 0 != rSet.Put( 1543 SfxUInt16Item(FN_PARAM_TABLE_HEADLINE, aHeadLineCB.IsChecked()? sal_uInt16(aRepeatHeaderNF.GetValue()) : 0 )); 1544 } 1545 if(aKeepCB.IsChecked() != aKeepCB.GetSavedValue()) 1546 bModified |= 0 != rSet.Put( SvxFmtKeepItem( aKeepCB.IsChecked(), RES_KEEP)); 1547 1548 if(aSplitCB.IsChecked() != aSplitCB.GetSavedValue()) 1549 bModified |= 0 != rSet.Put( SwFmtLayoutSplit( aSplitCB.IsChecked())); 1550 1551 if(aSplitRowCB.IsChecked() != aSplitRowCB.GetSavedValue()) 1552 bModified |= 0 != rSet.Put( SwFmtRowSplit( aSplitRowCB.IsChecked())); 1553 1554 1555 const SvxFmtBreakItem* pBreak = (const SvxFmtBreakItem*)GetOldItem( rSet, RES_BREAK ); 1556 const SwFmtPageDesc* pDesc = (const SwFmtPageDesc*) GetOldItem( rSet, RES_PAGEDESC ); 1557 1558 1559 sal_Bool bState = aPageCollCB.IsChecked(); 1560 1561 //Wenn Seitenvorlage, dann kein Break 1562 sal_Bool bPageItemPut = sal_False; 1563 if ( bState != aPageCollCB.GetSavedValue() || 1564 ( bState && 1565 aPageCollLB.GetSelectEntryPos() != aPageCollLB.GetSavedValue() ) 1566 || (aPageNoNF.IsEnabled() && aPageNoNF.IsValueModified()) ) 1567 { 1568 String sPage; 1569 1570 if ( bState ) 1571 { 1572 sPage = aPageCollLB.GetSelectEntry(); 1573 } 1574 sal_uInt16 nPgNum = static_cast< sal_uInt16 >(aPageNoNF.GetValue()); 1575 if ( !pDesc || !pDesc->GetPageDesc() || 1576 ( pDesc->GetPageDesc() && ((pDesc->GetPageDesc()->GetName() != sPage) || 1577 aPageNoNF.GetSavedValue() != (String)nPgNum))) 1578 { 1579 SwFmtPageDesc aFmt( pShell->FindPageDescByName( sPage, sal_True ) ); 1580 aFmt.SetNumOffset(bState ? nPgNum : 0); 1581 bModified |= 0 != rSet.Put( aFmt ); 1582 bPageItemPut = bState; 1583 } 1584 } 1585 sal_Bool bIsChecked = aPgBrkCB.IsChecked(); 1586 if ( !bPageItemPut && 1587 ( bState != aPageCollCB.GetSavedValue() || 1588 bIsChecked != aPgBrkCB.GetSavedValue() || 1589 aPgBrkBeforeRB.IsChecked() != aPgBrkBeforeRB.GetSavedValue() || 1590 aPgBrkRB.IsChecked() != aPgBrkRB.GetSavedValue() )) 1591 { 1592 SvxFmtBreakItem aBreak( 1593 (const SvxFmtBreakItem&)GetItemSet().Get( RES_BREAK ) ); 1594 1595 if(bIsChecked) 1596 { 1597 sal_Bool bBefore = aPgBrkBeforeRB.IsChecked(); 1598 1599 if ( aPgBrkRB.IsChecked() ) 1600 { 1601 if ( bBefore ) 1602 aBreak.SetValue( SVX_BREAK_PAGE_BEFORE ); 1603 else 1604 aBreak.SetValue( SVX_BREAK_PAGE_AFTER ); 1605 } 1606 else 1607 { 1608 if ( bBefore ) 1609 aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE ); 1610 else 1611 aBreak.SetValue( SVX_BREAK_COLUMN_AFTER ); 1612 } 1613 } 1614 else 1615 { 1616 aBreak.SetValue( SVX_BREAK_NONE ); 1617 } 1618 1619 if ( !pBreak || !( *(const SvxFmtBreakItem*)pBreak == aBreak ) ) 1620 { 1621 bModified |= 0 != rSet.Put( aBreak ); 1622 } 1623 } 1624 1625 if(aTextDirectionLB.GetSelectEntryPos() != aTextDirectionLB.GetSavedValue()) 1626 { 1627 bModified |= 0 != rSet.Put( 1628 SvxFrameDirectionItem( 1629 (SvxFrameDirection)(sal_uLong)aTextDirectionLB.GetEntryData(aTextDirectionLB.GetSelectEntryPos()) 1630 , FN_TABLE_BOX_TEXTDIRECTION)); 1631 } 1632 1633 if(aVertOrientLB.GetSelectEntryPos() != aVertOrientLB.GetSavedValue()) 1634 { 1635 sal_uInt16 nOrient = USHRT_MAX; 1636 switch(aVertOrientLB.GetSelectEntryPos()) 1637 { 1638 case 0 : nOrient = text::VertOrientation::NONE; break; 1639 case 1 : nOrient = text::VertOrientation::CENTER; break; 1640 case 2 : nOrient = text::VertOrientation::BOTTOM; break; 1641 } 1642 if(nOrient != USHRT_MAX) 1643 bModified |= 0 != rSet.Put(SfxUInt16Item(FN_TABLE_SET_VERT_ALIGN, nOrient)); 1644 } 1645 1646 return bModified; 1647 1648 } 1649 1650 /*-----------------12.12.96 12.22------------------- 1651 --------------------------------------------------*/ 1652 void SwTextFlowPage::Reset( const SfxItemSet& rSet ) 1653 { 1654 const SfxPoolItem* pItem; 1655 SvxHtmlOptions* pHtmlOpt = SvxHtmlOptions::Get(); 1656 sal_Bool bFlowAllowed = !bHtmlMode || pHtmlOpt->IsPrintLayoutExtension(); 1657 if(bFlowAllowed) 1658 { 1659 // Einfuegen der vorhandenen Seitenvorlagen in die Listbox 1660 const sal_uInt16 nCount = pShell->GetPageDescCnt(); 1661 sal_uInt16 i; 1662 1663 for( i = 0; i < nCount; ++i) 1664 { 1665 const SwPageDesc &rPageDesc = pShell->GetPageDesc(i); 1666 aPageCollLB.InsertEntry(rPageDesc.GetName()); 1667 } 1668 1669 String aFmtName; 1670 for(i = RES_POOLPAGE_BEGIN; i < RES_POOLPAGE_END; ++i) 1671 if( LISTBOX_ENTRY_NOTFOUND == aPageCollLB.GetEntryPos( 1672 aFmtName = SwStyleNameMapper::GetUIName( i, aFmtName ) )) 1673 aPageCollLB.InsertEntry( aFmtName ); 1674 1675 if(SFX_ITEM_SET == rSet.GetItemState( RES_KEEP, sal_False, &pItem )) 1676 { 1677 aKeepCB.Check( ((const SvxFmtKeepItem*)pItem)->GetValue() ); 1678 aKeepCB.SaveValue(); 1679 } 1680 if(SFX_ITEM_SET == rSet.GetItemState( RES_LAYOUT_SPLIT, sal_False, &pItem )) 1681 { 1682 aSplitCB.Check( ((const SwFmtLayoutSplit*)pItem)->GetValue() ); 1683 } 1684 else 1685 aSplitCB.Check(); 1686 1687 aSplitCB.SaveValue(); 1688 SplitHdl_Impl(&aSplitCB); 1689 1690 if(SFX_ITEM_SET == rSet.GetItemState( RES_ROW_SPLIT, sal_False, &pItem )) 1691 { 1692 aSplitRowCB.Check( ((const SwFmtRowSplit*)pItem)->GetValue() ); 1693 } 1694 else 1695 aSplitRowCB.SetState(STATE_DONTKNOW); 1696 aSplitRowCB.SaveValue(); 1697 1698 if(bPageBreak) 1699 { 1700 if(SFX_ITEM_SET == rSet.GetItemState( RES_PAGEDESC, sal_False, &pItem )) 1701 { 1702 String sPageDesc; 1703 const SwPageDesc* pDesc = ((const SwFmtPageDesc*)pItem)->GetPageDesc(); 1704 aPageNoNF.SetValue(((const SwFmtPageDesc*)pItem)->GetNumOffset()); 1705 if(pDesc) 1706 sPageDesc = pDesc->GetName(); 1707 if ( sPageDesc.Len() && 1708 aPageCollLB.GetEntryPos( sPageDesc ) != LISTBOX_ENTRY_NOTFOUND ) 1709 { 1710 aPageCollLB.SelectEntry( sPageDesc ); 1711 aPageCollCB.Check(); 1712 1713 aPgBrkCB.Enable(); 1714 aPgBrkRB.Enable(); 1715 aColBrkRB.Enable(); 1716 aPgBrkBeforeRB.Enable(); 1717 aPgBrkAfterRB.Enable(); 1718 aPageCollCB.Enable(); 1719 aPgBrkCB.Check(); 1720 1721 aPgBrkCB.Check( sal_True ); 1722 aColBrkRB.Check( sal_False ); 1723 aPgBrkBeforeRB.Check( sal_True ); 1724 aPgBrkAfterRB.Check( sal_False ); 1725 } 1726 else 1727 { 1728 aPageCollLB.SetNoSelection(); 1729 aPageCollCB.Check(sal_False); 1730 } 1731 } 1732 1733 if(SFX_ITEM_SET == rSet.GetItemState( RES_BREAK, sal_False, &pItem )) 1734 { 1735 const SvxFmtBreakItem* pPageBreak = (const SvxFmtBreakItem*)pItem; 1736 SvxBreak eBreak = (SvxBreak)pPageBreak->GetValue(); 1737 1738 if ( eBreak != SVX_BREAK_NONE ) 1739 { 1740 aPgBrkCB.Check(); 1741 aPageCollCB.Enable(sal_False); 1742 aPageCollLB.Enable(sal_False); 1743 aPageNoFT.Enable(sal_False); 1744 aPageNoNF.Enable(sal_False); 1745 } 1746 switch ( eBreak ) 1747 { 1748 case SVX_BREAK_PAGE_BEFORE: 1749 aPgBrkRB.Check( sal_True ); 1750 aColBrkRB.Check( sal_False ); 1751 aPgBrkBeforeRB.Check( sal_True ); 1752 aPgBrkAfterRB.Check( sal_False ); 1753 break; 1754 case SVX_BREAK_PAGE_AFTER: 1755 aPgBrkRB.Check( sal_True ); 1756 aColBrkRB.Check( sal_False ); 1757 aPgBrkBeforeRB.Check( sal_False ); 1758 aPgBrkAfterRB.Check( sal_True ); 1759 break; 1760 case SVX_BREAK_COLUMN_BEFORE: 1761 aPgBrkRB.Check( sal_False ); 1762 aColBrkRB.Check( sal_True ); 1763 aPgBrkBeforeRB.Check( sal_True ); 1764 aPgBrkAfterRB.Check( sal_False ); 1765 break; 1766 case SVX_BREAK_COLUMN_AFTER: 1767 aPgBrkRB.Check( sal_False ); 1768 aColBrkRB.Check( sal_True ); 1769 aPgBrkBeforeRB.Check( sal_False ); 1770 aPgBrkAfterRB.Check( sal_True ); 1771 break; 1772 default:; //prevent warning 1773 } 1774 1775 } 1776 if ( aPgBrkBeforeRB.IsChecked() ) 1777 PageBreakPosHdl_Impl( &aPgBrkBeforeRB ); 1778 else if ( aPgBrkAfterRB.IsChecked() ) 1779 PageBreakPosHdl_Impl( &aPgBrkAfterRB ); 1780 PageBreakHdl_Impl( &aPgBrkCB ); 1781 } 1782 } 1783 else 1784 { 1785 aPgBrkRB.Enable(sal_False); 1786 aColBrkRB.Enable(sal_False); 1787 aPgBrkBeforeRB.Enable(sal_False); 1788 aPgBrkAfterRB.Enable(sal_False); 1789 aKeepCB .Enable(sal_False); 1790 aSplitCB.Enable(sal_False); 1791 aPgBrkCB.Enable(sal_False); 1792 aPageCollCB.Enable(sal_False); 1793 aPageCollLB.Enable(sal_False); 1794 } 1795 1796 if(SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_TABLE_HEADLINE, sal_False, &pItem )) 1797 { 1798 sal_uInt16 nRep = ((const SfxUInt16Item*)pItem)->GetValue(); 1799 aHeadLineCB.Check( nRep > 0 ); 1800 aHeadLineCB.SaveValue(); 1801 aRepeatHeaderNF.SetValue( nRep ); 1802 aRepeatHeaderNF.SaveValue(); 1803 } 1804 if ( rSet.GetItemState(FN_TABLE_BOX_TEXTDIRECTION) > SFX_ITEM_AVAILABLE ) 1805 { 1806 sal_uLong nDirection = ((const SvxFrameDirectionItem&)rSet.Get(FN_TABLE_BOX_TEXTDIRECTION)).GetValue(); 1807 aTextDirectionLB.SelectEntryPos(aTextDirectionLB.GetEntryPos( (const void*)nDirection )); 1808 } 1809 1810 if ( rSet.GetItemState(FN_TABLE_SET_VERT_ALIGN) > SFX_ITEM_AVAILABLE ) 1811 { 1812 sal_uInt16 nVert = ((const SfxUInt16Item&)rSet.Get(FN_TABLE_SET_VERT_ALIGN)).GetValue(); 1813 sal_uInt16 nPos = 0; 1814 switch(nVert) 1815 { 1816 case text::VertOrientation::NONE: nPos = 0; break; 1817 case text::VertOrientation::CENTER: nPos = 1; break; 1818 case text::VertOrientation::BOTTOM: nPos = 2; break; 1819 } 1820 aVertOrientLB.SelectEntryPos(nPos); 1821 } 1822 1823 aPageCollCB.SaveValue(); 1824 aPageCollLB.SaveValue(); 1825 aPgBrkCB.SaveValue(); 1826 aPgBrkRB.SaveValue(); 1827 aColBrkRB.SaveValue(); 1828 aPgBrkBeforeRB.SaveValue(); 1829 aPgBrkAfterRB.SaveValue(); 1830 aPageNoNF.SaveValue(); 1831 aTextDirectionLB.SaveValue(); 1832 aVertOrientLB.SaveValue(); 1833 1834 HeadLineCBClickHdl(); 1835 } 1836 /*-----------------16.04.98 14:48------------------- 1837 1838 --------------------------------------------------*/ 1839 1840 void SwTextFlowPage::SetShell(SwWrtShell* pSh) 1841 { 1842 pShell = pSh; 1843 bHtmlMode = 0 != (::GetHtmlMode(pShell->GetView().GetDocShell()) & HTMLMODE_ON); 1844 if(bHtmlMode) 1845 { 1846 aPageNoNF.Enable(sal_False); 1847 aPageNoFT.Enable(sal_False); 1848 } 1849 } 1850 1851 /*-----------------12.12.96 16.18------------------- 1852 --------------------------------------------------*/ 1853 IMPL_LINK( SwTextFlowPage, PageBreakHdl_Impl, CheckBox*, EMPTYARG ) 1854 { 1855 if( aPgBrkCB.IsChecked() ) 1856 { 1857 aPgBrkRB. Enable(); 1858 aColBrkRB. Enable(); 1859 aPgBrkBeforeRB. Enable(); 1860 aPgBrkAfterRB. Enable(); 1861 1862 if ( aPgBrkRB.IsChecked() && aPgBrkBeforeRB.IsChecked() ) 1863 { 1864 aPageCollCB.Enable(); 1865 1866 sal_Bool bEnable = aPageCollCB.IsChecked() && 1867 aPageCollLB.GetEntryCount(); 1868 aPageCollLB.Enable(bEnable); 1869 if(!bHtmlMode) 1870 { 1871 aPageNoFT.Enable(bEnable); 1872 aPageNoNF.Enable(bEnable); 1873 } 1874 } 1875 } 1876 else 1877 { 1878 aPageCollCB.Check( sal_False ); 1879 aPageCollCB.Enable(sal_False); 1880 aPageCollLB.Enable(sal_False); 1881 aPageNoFT.Enable(sal_False); 1882 aPageNoNF.Enable(sal_False); 1883 aPgBrkRB. Enable(sal_False); 1884 aColBrkRB. Enable(sal_False); 1885 aPgBrkBeforeRB. Enable(sal_False); 1886 aPgBrkAfterRB. Enable(sal_False); 1887 } 1888 return 0; 1889 } 1890 1891 /*-----------------12.12.96 16.18------------------- 1892 --------------------------------------------------*/ 1893 IMPL_LINK( SwTextFlowPage, ApplyCollClickHdl_Impl, CheckBox*, EMPTYARG ) 1894 { 1895 sal_Bool bEnable = sal_False; 1896 if ( aPageCollCB.IsChecked() && 1897 aPageCollLB.GetEntryCount() ) 1898 { 1899 bEnable = sal_True; 1900 aPageCollLB.SelectEntryPos( 0 ); 1901 } 1902 else 1903 { 1904 aPageCollLB.SetNoSelection(); 1905 } 1906 aPageCollLB.Enable(bEnable); 1907 if(!bHtmlMode) 1908 { 1909 aPageNoFT.Enable(bEnable); 1910 aPageNoNF.Enable(bEnable); 1911 } 1912 return 0; 1913 } 1914 1915 /*-----------------12.12.96 16.18------------------- 1916 --------------------------------------------------*/ 1917 IMPL_LINK( SwTextFlowPage, PageBreakPosHdl_Impl, RadioButton*, pBtn ) 1918 { 1919 if ( aPgBrkCB.IsChecked() ) 1920 { 1921 if ( pBtn == &aPgBrkBeforeRB && aPgBrkRB.IsChecked() ) 1922 { 1923 aPageCollCB.Enable(); 1924 1925 sal_Bool bEnable = aPageCollCB.IsChecked() && 1926 aPageCollLB.GetEntryCount(); 1927 1928 aPageCollLB.Enable(bEnable); 1929 if(!bHtmlMode) 1930 { 1931 aPageNoFT.Enable(bEnable); 1932 aPageNoNF.Enable(bEnable); 1933 } 1934 } 1935 else if ( pBtn == &aPgBrkAfterRB ) 1936 { 1937 aPageCollCB .Check( sal_False ); 1938 aPageCollCB .Enable(sal_False); 1939 aPageCollLB .Enable(sal_False); 1940 aPageNoFT .Enable(sal_False); 1941 aPageNoNF .Enable(sal_False); 1942 } 1943 } 1944 return 0; 1945 } 1946 1947 /*-----------------12.12.96 16.18------------------- 1948 --------------------------------------------------*/ 1949 IMPL_LINK( SwTextFlowPage, PageBreakTypeHdl_Impl, RadioButton*, pBtn ) 1950 { 1951 if ( pBtn == &aColBrkRB || aPgBrkAfterRB.IsChecked() ) 1952 { 1953 aPageCollCB .Check(sal_False); 1954 aPageCollCB .Enable(sal_False); 1955 aPageCollLB .Enable(sal_False); 1956 aPageNoFT .Enable(sal_False); 1957 aPageNoNF .Enable(sal_False); 1958 } 1959 else if ( aPgBrkBeforeRB.IsChecked() ) 1960 PageBreakPosHdl_Impl( &aPgBrkBeforeRB ); 1961 return 0; 1962 } 1963 /*-----------------17.11.2003 11:30----------------- 1964 * 1965 * --------------------------------------------------*/ 1966 IMPL_LINK( SwTextFlowPage, SplitHdl_Impl, CheckBox*, pBox ) 1967 { 1968 aSplitRowCB.Enable(pBox->IsChecked()); 1969 return 0; 1970 } 1971 /*-----------------17.11.2003 11:30----------------- 1972 * 1973 * --------------------------------------------------*/ 1974 IMPL_LINK( SwTextFlowPage, SplitRowHdl_Impl, TriStateBox*, pBox ) 1975 { 1976 pBox->EnableTriState(sal_False); 1977 return 0; 1978 } 1979 1980 IMPL_LINK( SwTextFlowPage, HeadLineCBClickHdl, void*, EMPTYARG ) 1981 { 1982 aRepeatHeaderCombo.Enable(aHeadLineCB.IsChecked()); 1983 1984 return 0; 1985 } 1986 1987 /*-----------------30.05.97 07:37------------------- 1988 1989 --------------------------------------------------*/ 1990 void SwTextFlowPage::DisablePageBreak() 1991 { 1992 bPageBreak = sal_False; 1993 aPgBrkCB .Disable(); 1994 aPgBrkRB .Disable(); 1995 aColBrkRB .Disable(); 1996 aPgBrkBeforeRB .Disable(); 1997 aPgBrkAfterRB .Disable(); 1998 aPageCollCB .Disable(); 1999 aPageCollLB .Disable(); 2000 aPageNoFT .Disable(); 2001 aPageNoNF .Disable(); 2002 } 2003 2004 2005 2006