xref: /aoo41x/main/sw/source/ui/table/tabledlg.cxx (revision 4d7c9de0)
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
DbgTblRep(SwTableRep * pRep)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 
SwFormatTablePage(Window * pParent,const SfxItemSet & rSet)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 ------------------------------------------------------------------------*/
Init()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 
IMPL_LINK(SwFormatTablePage,RelWidthClickHdl,CheckBox *,pBtn)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 ------------------------------------------------------------------------*/
IMPL_LINK(SwFormatTablePage,AutoClickHdl,CheckBox *,pBox)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 /*----------------------------------------------------------------------*/
IMPL_LINK(SwFormatTablePage,RightModifyHdl,MetricField *,EMPTYARG)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 ------------------------------------------------------------------------*/
IMPL_LINK_INLINE_START(SwFormatTablePage,UpDownLoseFocusHdl,MetricField *,pEdit)348 IMPL_LINK_INLINE_START( SwFormatTablePage, UpDownLoseFocusHdl, MetricField *, pEdit )
349 {
350     if( &aRightMF == pEdit)
351         RightModifyHdl(pEdit);
352     ModifyHdl( pEdit );
353 	return 0;
354 }
IMPL_LINK_INLINE_END(SwFormatTablePage,UpDownLoseFocusHdl,MetricField *,pEdit)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 ------------------------------------------------------------------------*/
Create(Window * pParent,const SfxItemSet & rAttrSet)461 SfxTabPage*  SwFormatTablePage::Create( Window* pParent,
462 								   const SfxItemSet& rAttrSet)
463 {
464 	return new SwFormatTablePage( pParent, rAttrSet );
465 }
466 
467 /*------------------------------------------------------------------------
468 -------------------------------------------------------------------------*/
FillItemSet(SfxItemSet & rCoreSet)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 ------------------------------------------------------------------------*/
Reset(const SfxItemSet &)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 ------------------------------------------------------------------------*/
ActivatePage(const SfxItemSet & rSet)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 ------------------------------------------------------------------------*/
DeactivatePage(SfxItemSet * _pSet)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 ------------------------------------------------------------------------*/
SwTableColumnPage(Window * pParent,const SfxItemSet & rSet)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 ------------------------------------------------------------------------*/
~SwTableColumnPage()878  SwTableColumnPage::~SwTableColumnPage()
879 {
880 };
881 
882 /*------------------------------------------------------------------------
883 ------------------------------------------------------------------------*/
Create(Window * pParent,const SfxItemSet & rAttrSet)884 SfxTabPage*   SwTableColumnPage::Create( Window* pParent,
885 								const SfxItemSet& rAttrSet)
886 {
887 	return new SwTableColumnPage( pParent, rAttrSet );
888 };
889 
890 /*------------------------------------------------------------------------
891 ------------------------------------------------------------------------*/
Reset(const SfxItemSet &)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 ------------------------------------------------------------------------*/
Init(sal_Bool bWeb)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 ------------------------------------------------------------------------*/
IMPL_LINK(SwTableColumnPage,AutoClickHdl,CheckBox *,pBox)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 ------------------------------------------------------------------------*/
IMPL_LINK_INLINE_START(SwTableColumnPage,UpHdl,PercentField *,pEdit)1006 IMPL_LINK_INLINE_START( SwTableColumnPage, UpHdl, PercentField *, pEdit )
1007 {
1008 	bModified = sal_True;
1009 	ModifyHdl( pEdit );
1010 	return 0;
1011 };
IMPL_LINK_INLINE_END(SwTableColumnPage,UpHdl,PercentField *,pEdit)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 };
IMPL_LINK_INLINE_END(SwTableColumnPage,DownHdl,PercentField *,pEdit)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 };
IMPL_LINK_INLINE_END(SwTableColumnPage,LoseFocusHdl,PercentField *,pEdit)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 ------------------------------------------------------------------------*/
FillItemSet(SfxItemSet &)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 ------------------------------------------------------------------------*/
ModifyHdl(PercentField * pEdit)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 ------------------------------------------------------------------------*/
UpdateCols(sal_uInt16 nAktPos)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 ------------------------------------------------------------------------*/
ActivatePage(const SfxItemSet &)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 ------------------------------------------------------------------------*/
DeactivatePage(SfxItemSet * _pSet)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 ------------------------------------------------------------------------*/
GetVisibleWidth(sal_uInt16 nPos)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 ------------------------------------------------------------------------*/
SetVisibleWidth(sal_uInt16 nPos,SwTwips nNewWidth)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 ------------------------------------------------------------------------*/
SwTableTabDlg(Window * pParent,SfxItemPool &,const SfxItemSet * pItemSet,SwWrtShell * pSh)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 ------------------------------------------------------------------------*/
PageCreated(sal_uInt16 nId,SfxTabPage & rPage)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 --------------------------------------------------*/
SwTextFlowPage(Window * pParent,const SfxItemSet & rSet)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 --------------------------------------------------*/
~SwTextFlowPage()1520  SwTextFlowPage::~SwTextFlowPage()
1521 {
1522 }
1523 
1524 /*-----------------12.12.96 12.22-------------------
1525 --------------------------------------------------*/
Create(Window * pParent,const SfxItemSet & rAttrSet)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 --------------------------------------------------*/
FillItemSet(SfxItemSet & rSet)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 --------------------------------------------------*/
Reset(const SfxItemSet & rSet)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 
SetShell(SwWrtShell * pSh)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 --------------------------------------------------*/
IMPL_LINK(SwTextFlowPage,PageBreakHdl_Impl,CheckBox *,EMPTYARG)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 --------------------------------------------------*/
IMPL_LINK(SwTextFlowPage,ApplyCollClickHdl_Impl,CheckBox *,EMPTYARG)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 --------------------------------------------------*/
IMPL_LINK(SwTextFlowPage,PageBreakPosHdl_Impl,RadioButton *,pBtn)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 --------------------------------------------------*/
IMPL_LINK(SwTextFlowPage,PageBreakTypeHdl_Impl,RadioButton *,pBtn)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  * --------------------------------------------------*/
IMPL_LINK(SwTextFlowPage,SplitHdl_Impl,CheckBox *,pBox)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  * --------------------------------------------------*/
IMPL_LINK(SwTextFlowPage,SplitRowHdl_Impl,TriStateBox *,pBox)1974 IMPL_LINK( SwTextFlowPage, SplitRowHdl_Impl, TriStateBox*, pBox )
1975 {
1976     pBox->EnableTriState(sal_False);
1977     return 0;
1978 }
1979 
IMPL_LINK(SwTextFlowPage,HeadLineCBClickHdl,void *,EMPTYARG)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 --------------------------------------------------*/
DisablePageBreak()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