?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 4.1.6.2
[LibreOffice.git] / sw / source / ui / table / tabledlg.cxx
blobe833ba80676a304ed6c8bb85e6ed6678da60d8a0
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <hintids.hxx>
21 #include <comphelper/string.hxx>
22 #include <vcl/msgbox.hxx>
23 #include <svl/stritem.hxx>
24 #include <svl/intitem.hxx>
25 #include <editeng/keepitem.hxx>
26 #include <editeng/formatbreakitem.hxx>
27 #include <editeng/ulspitem.hxx>
28 #include <editeng/frmdiritem.hxx>
29 #include <svl/ctloptions.hxx>
30 #include <swmodule.hxx>
31 #include <fmtornt.hxx>
32 #include <fmtpdsc.hxx>
33 #include <fmtlsplt.hxx>
34
35 #include <svtools/htmlcfg.hxx>
36 #include <fmtrowsplt.hxx>
37 #include <sfx2/htmlmode.hxx>
38
39 #include "access.hrc"
40
41 #include <docsh.hxx>
42 #include <wrtsh.hxx>
43 #include <view.hxx>
44 #include <viewopt.hxx>
45 #include <uitool.hxx>
46 #include <frmatr.hxx>
47 #include <tabledlg.hxx>
48 #include <tablepg.hxx>
49 #include <tablemgr.hxx>
50 #include <pagedesc.hxx>
51 #include <uiitems.hxx>
52 #include <poolfmt.hxx>
53 #include <SwStyleNameMapper.hxx>
54
55 #include <cmdid.h>
56 #include <table.hrc>
57 #include <svx/svxids.hrc>
58 #include <svx/dialogs.hrc>
59 #include <svx/flagsdef.hxx>
60 #include <svx/svxdlg.hxx>
61
62 using namespace ::com::sun::star;
63
64
65 SwFormatTablePage::SwFormatTablePage(Window* pParent, const SfxItemSet& rSet)
66 : SfxTabPage(pParent, "FormatTablePage", "modules/swriter/ui/formattablepage.ui", rSet)
67 , pTblData(0)
68 , nSaveWidth(0)
69 , nMinTableWidth(MINLAY)
70 , bModified(sal_False)
71 , bFull(0)
72 , bHtmlMode(sal_False)
73 {
74 get(m_pNameED, "name");
75 get(m_pWidthFT, "widthft");
76 m_aWidthMF.set(get<MetricField>("widthmf"));
77 m_aLeftMF.set(get<MetricField>("leftmf"));
78 m_aRightMF.set(get<MetricField>("rightmf"));
79 get(m_pRelWidthCB, "relwidth");
80 get(m_pFullBtn, "full");
81 get(m_pLeftBtn, "left");
82 get(m_pFromLeftBtn, "fromleft");
83 get(m_pRightBtn, "right");
84 get(m_pCenterBtn, "center");
85 get(m_pFreeBtn, "free");
86 get(m_pLeftFT, "leftft");
87 get(m_pRightFT, "rightft");
88 get(m_pTopFT, "aboveft");
89 get(m_pTopMF, "abovemf");
90 get(m_pBottomFT, "belowft");
91 get(m_pBottomMF, "belowmf");
92 get(m_pTextDirectionLB, "textdirection");
93
94 SetExchangeSupport();
95
96 const SfxPoolItem* pItem;
97 if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, sal_False, &pItem))
98 bHtmlMode = 0 != (((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON);
99
100 bool bCTL = SW_MOD()->GetCTLOptions().IsCTLFontEnabled();
101 get<VclContainer>("properties")->Show(!bHtmlMode && bCTL);
102
103 Init();
104 }
105
106
107 void SwFormatTablePage::Init()
108 {
109 m_aLeftMF.SetMetricFieldMin(-999999);
110 m_aRightMF.SetMetricFieldMin(-999999);
111
112 // handler
113 Link aLk = LINK( this, SwFormatTablePage, AutoClickHdl );
114 m_pFullBtn->SetClickHdl( aLk );
115 m_pFreeBtn->SetClickHdl( aLk );
116 m_pLeftBtn->SetClickHdl( aLk );
117 m_pFromLeftBtn->SetClickHdl( aLk );
118 m_pRightBtn->SetClickHdl( aLk );
119 m_pCenterBtn->SetClickHdl( aLk );
120
121 aLk = LINK( this, SwFormatTablePage, UpDownLoseFocusHdl );
122 m_pTopMF->SetUpHdl( aLk );
123 m_pBottomMF->SetUpHdl( aLk );
124 m_aRightMF.SetUpHdl( aLk );
125 m_aLeftMF.SetUpHdl( aLk );
126 m_aWidthMF.SetUpHdl( aLk );
127
128 m_pTopMF->SetDownHdl( aLk );
129 m_pBottomMF->SetDownHdl( aLk );
130 m_aRightMF.SetDownHdl( aLk );
131 m_aLeftMF.SetDownHdl( aLk );
132 m_aWidthMF.SetDownHdl( aLk );
133
134 m_pTopMF->SetLoseFocusHdl( aLk );
135 m_pBottomMF->SetLoseFocusHdl( aLk );
136 m_aRightMF.SetLoseFocusHdl( aLk );
137 m_aLeftMF.SetLoseFocusHdl( aLk );
138 m_aWidthMF.SetLoseFocusHdl( aLk );
139
140 m_pRelWidthCB->SetClickHdl(LINK( this, SwFormatTablePage, RelWidthClickHdl ));
141 }
142
143 IMPL_LINK( SwFormatTablePage, RelWidthClickHdl, CheckBox *, pBtn )
144 {
145 OSL_ENSURE(pTblData, "table data not available?");
146 sal_Bool bIsChecked = pBtn->IsChecked();
147 sal_Int64 nLeft = m_aLeftMF.DenormalizePercent(m_aLeftMF.GetValue(FUNIT_TWIP ));
148 sal_Int64 nRight = m_aRightMF.DenormalizePercent(m_aRightMF.GetValue(FUNIT_TWIP ));
149 m_aWidthMF.ShowPercent(bIsChecked);
150 m_aLeftMF.ShowPercent(bIsChecked);
151 m_aRightMF.ShowPercent(bIsChecked);
152
153 if (bIsChecked)
154 {
155 m_aWidthMF.SetRefValue(pTblData->GetSpace());
156 m_aLeftMF.SetRefValue(pTblData->GetSpace());
157 m_aRightMF.SetRefValue(pTblData->GetSpace());
158 m_aLeftMF.SetMetricFieldMin(0); // will be overwritten by the Percentfield
159 m_aRightMF.SetMetricFieldMin(0); // -""-
160 m_aLeftMF.SetMetricFieldMax(99); //
161 m_aRightMF.SetMetricFieldMax(99); //
162 m_aLeftMF.SetPrcntValue(m_aLeftMF.NormalizePercent(nLeft ), FUNIT_TWIP );
163 m_aRightMF.SetPrcntValue(m_aRightMF.NormalizePercent(nRight ), FUNIT_TWIP );
164 }
165 else
166 ModifyHdl(m_aLeftMF.get()); // correct values again
167
168 if(m_pFreeBtn->IsChecked())
169 {
170 sal_Bool bEnable = !pBtn->IsChecked();
171 m_aRightMF.Enable(bEnable);
172 m_pRightFT->Enable(bEnable);
173 }
174 bModified = sal_True;
175
176 return 0;
177 }
178
179
180 IMPL_LINK( SwFormatTablePage, AutoClickHdl, CheckBox *, pBox )
181 {
182 sal_Bool bRestore = sal_True,
183 bLeftEnable = sal_False,
184 bRightEnable= sal_False,
185 bWidthEnable= sal_False,
186 bOthers = sal_True;
187 if ((RadioButton *)pBox == m_pFullBtn)
188 {
189 m_aLeftMF.SetPrcntValue(0);
190 m_aRightMF.SetPrcntValue(0);
191 nSaveWidth = static_cast< SwTwips >(m_aWidthMF.DenormalizePercent(m_aWidthMF.GetValue(FUNIT_TWIP )));
192 m_aWidthMF.SetPrcntValue(m_aWidthMF.NormalizePercent(pTblData->GetSpace() ), FUNIT_TWIP );
193 bFull = sal_True;
194 bRestore = sal_False;
195 }
196 else if ((RadioButton *)pBox == m_pLeftBtn)
197 {
198 bRightEnable = bWidthEnable = sal_True;
199 m_aLeftMF.SetPrcntValue(0);
200 }
201 else if ((RadioButton *) pBox == m_pFromLeftBtn)
202 {
203 bLeftEnable = bWidthEnable = sal_True;
204 m_aRightMF.SetPrcntValue(0);
205 }
206 else if ((RadioButton *) pBox == m_pRightBtn)
207 {
208 bLeftEnable = bWidthEnable = sal_True;
209 m_aRightMF.SetPrcntValue(0);
210 }
211 else if ((RadioButton *) pBox == m_pCenterBtn)
212 {
213 bLeftEnable = bWidthEnable = sal_True;
214 }
215 else if ((RadioButton *) pBox == m_pFreeBtn)
216 {
217 RightModify();
218 bLeftEnable = sal_True;
219 bWidthEnable = sal_True;
220 bOthers = sal_False;
221 }
222 m_aLeftMF.Enable(bLeftEnable);
223 m_pLeftFT->Enable(bLeftEnable);
224 m_aWidthMF.Enable(bWidthEnable);
225 m_pWidthFT->Enable(bWidthEnable);
226 if ( bOthers )
227 {
228 m_aRightMF.Enable(bRightEnable);
229 m_pRightFT->Enable(bRightEnable);
230 m_pRelWidthCB->Enable(bWidthEnable);
231 }
232
233 if(bFull && bRestore)
234 {
235 // After being switched on automatic, the width was pinned
236 // in order to restore the width while switching back to.
237 bFull = sal_False;
238 m_aWidthMF.SetPrcntValue(m_aWidthMF.NormalizePercent(nSaveWidth ), FUNIT_TWIP );
239 }
240 ModifyHdl(m_aWidthMF.get());
241 bModified = sal_True;
242 return 0;
243 }
244
245 void SwFormatTablePage::RightModify()
246 {
247 if(m_pFreeBtn->IsChecked())
248 {
249 sal_Bool bEnable = m_aRightMF.GetValue() == 0;
250 m_pRelWidthCB->Enable(bEnable);
251 if ( !bEnable )
252 {
253 m_pRelWidthCB->Check(sal_False);
254 RelWidthClickHdl(m_pRelWidthCB);
255 }
256 bEnable = m_pRelWidthCB->IsChecked();
257 m_aRightMF.Enable(!bEnable);
258 m_pRightFT->Enable(!bEnable);
259 }
260 }
261
262
263 IMPL_LINK_INLINE_START( SwFormatTablePage, UpDownLoseFocusHdl, MetricField *, pEdit )
264 {
265 if( m_aRightMF.get() == pEdit)
266 RightModify();
267 ModifyHdl( pEdit );
268 return 0;
269 }
270 IMPL_LINK_INLINE_END( SwFormatTablePage, UpDownLoseFocusHdl, MetricField *, pEdit )
271
272 void SwFormatTablePage::ModifyHdl(const Edit * pEdit)
273 {
274
275 SwTwips nCurWidth = static_cast< SwTwips >(m_aWidthMF.DenormalizePercent(m_aWidthMF.GetValue( FUNIT_TWIP )));
276 SwTwips nPrevWidth = nCurWidth;
277 SwTwips nRight = static_cast< SwTwips >(m_aRightMF.DenormalizePercent(m_aRightMF.GetValue( FUNIT_TWIP )));
278 SwTwips nLeft = static_cast< SwTwips >(m_aLeftMF.DenormalizePercent(m_aLeftMF.GetValue( FUNIT_TWIP )));
279 SwTwips nDiff;
280
281 if (pEdit == m_aWidthMF.get())
282 {
283 if( nCurWidth < MINLAY )
284 nCurWidth = MINLAY;
285 nDiff = nRight + nLeft + nCurWidth - pTblData->GetSpace() ;
286 //right aligned: only change the left margin
287 if(m_pRightBtn->IsChecked())
288 nLeft -= nDiff;
289 //left aligned: only change the right margin
290 else if(m_pLeftBtn->IsChecked())
291 nRight -= nDiff;
292 //left margin and width allowed - first right - then left
293 else if(m_pFromLeftBtn->IsChecked())
294 {
295 if( nRight >= nDiff )
296 nRight -= nDiff;
297 else
298 {
299 nDiff -= nRight;
300 nRight = 0;
301 if(nLeft >= nDiff)
302 nLeft -= nDiff;
303 else
304 {
305 nRight += nLeft - nDiff;
306 nLeft = 0;
307 nCurWidth = pTblData->GetSpace();
308 }
309
310 }
311 }
312 //centered: change both sides equally
313 else if(m_pCenterBtn->IsChecked())
314 {
315 if((nLeft != nRight))
316 {
317 nDiff += nLeft + nRight;
318 nLeft = nDiff/2;
319 nRight = nDiff/2;
320 }
321 else
322 {
323 nLeft -= nDiff/2;
324 nRight -= nDiff/2;
325 }
326 }
327 //free alignment: decrease both margins
328 else if(m_pFreeBtn->IsChecked())
329 {
330 nLeft -= nDiff/2;
331 nRight -= nDiff/2;
332 }
333 }
334 if (pEdit == m_aRightMF.get())
335 {
336
337 if( nRight + nLeft > pTblData->GetSpace() - MINLAY )
338 nRight = pTblData->GetSpace() -nLeft - MINLAY;
339
340 nCurWidth = pTblData->GetSpace() - nLeft - nRight;
341 }
342 if (pEdit == m_aLeftMF.get())
343 {
344 if(!m_pFromLeftBtn->IsChecked())
345 {
346 sal_Bool bCenter = m_pCenterBtn->IsChecked();
347 if( bCenter )
348 nRight = nLeft;
349 if(nRight + nLeft > pTblData->GetSpace() - MINLAY )
350 {
351 nLeft = bCenter ? (pTblData->GetSpace() - MINLAY) /2 :
352 (pTblData->GetSpace() - MINLAY) - nRight;
353 nRight = bCenter ? (pTblData->GetSpace() - MINLAY) /2 : nRight;
354 }
355 nCurWidth = pTblData->GetSpace() - nLeft - nRight;
356 }
357 else
358 {
359 //Upon changes on the left side the right margin will be changed at first,
360 //thereafter the width.
361 nDiff = nRight + nLeft + nCurWidth - pTblData->GetSpace() ;
362
363 nRight -= nDiff;
364 nCurWidth = pTblData->GetSpace() - nLeft - nRight;
365 }
366 }
367 if (nCurWidth != nPrevWidth )
368 m_aWidthMF.SetPrcntValue( m_aWidthMF.NormalizePercent( nCurWidth ), FUNIT_TWIP );
369 m_aRightMF.SetPrcntValue( m_aRightMF.NormalizePercent( nRight ), FUNIT_TWIP );
370 m_aLeftMF.SetPrcntValue( m_aLeftMF.NormalizePercent( nLeft ), FUNIT_TWIP );
371 bModified = sal_True;
372 }
373
374
375 SfxTabPage* SwFormatTablePage::Create( Window* pParent,
376 const SfxItemSet& rAttrSet)
377 {
378 return new SwFormatTablePage( pParent, rAttrSet );
379 }
380
381
382 sal_Bool SwFormatTablePage::FillItemSet( SfxItemSet& rCoreSet )
383 {
384 // Test if one of the controls still has the focus.
385 if (m_aWidthMF.HasFocus())
386 ModifyHdl(m_aWidthMF.get());
387 else if (m_aLeftMF.HasFocus())
388 ModifyHdl(m_aLeftMF.get());
389 else if(m_aRightMF.HasFocus())
390 ModifyHdl(m_aRightMF.get());
391 else if(m_pTopMF->HasFocus())
392 ModifyHdl(m_pTopMF);
393 else if(m_pBottomMF->HasFocus())
394 ModifyHdl(m_pBottomMF);
395
396 if(bModified)
397 {
398 if( m_pBottomMF->GetText() != m_pBottomMF->GetSavedValue() ||
399 m_pTopMF->GetText() != m_pTopMF->GetSavedValue() )
400 {
401 SvxULSpaceItem aULSpace(RES_UL_SPACE);
402 aULSpace.SetUpper( (sal_uInt16) m_pTopMF->Denormalize(
403 m_pTopMF->GetValue( FUNIT_TWIP )));
404 aULSpace.SetLower( (sal_uInt16) m_pBottomMF->Denormalize(
405 m_pBottomMF->GetValue( FUNIT_TWIP )));
406 rCoreSet.Put(aULSpace);
407 }
408
409 }
410 if(m_pNameED->GetText() != m_pNameED->GetSavedValue())
411 {
412 rCoreSet.Put(SfxStringItem( FN_PARAM_TABLE_NAME, m_pNameED->GetText()));
413 bModified = sal_True;
414 }
415
416 sal_uInt16 nPos;
417 if( m_pTextDirectionLB->IsVisible() &&
418 ( nPos = m_pTextDirectionLB->GetSelectEntryPos() ) !=
419 m_pTextDirectionLB->GetSavedValue() )
420 {
421 sal_uInt32 nDirection = (sal_uInt32)(sal_uIntPtr)m_pTextDirectionLB->GetEntryData( nPos );
422 rCoreSet.Put( SvxFrameDirectionItem( (SvxFrameDirection)nDirection, RES_FRAMEDIR));
423 bModified = sal_True;
424 }
425
426 return bModified;
427 }
428
429
430 void SwFormatTablePage::Reset( const SfxItemSet& )
431 {
432 const SfxItemSet& rSet = GetItemSet();
433 const SfxPoolItem* pItem;
434
435 if(bHtmlMode)
436 {
437 m_pNameED->Disable();
438 m_pTopFT->Hide();
439 m_pTopMF->Hide();
440 m_pBottomFT->Hide();
441 m_pBottomMF->Hide();
442 m_pFreeBtn->Enable(sal_False);
443 }
444 FieldUnit aMetric = ::GetDfltMetric(bHtmlMode);
445 m_aWidthMF.SetMetric(aMetric);
446 m_aRightMF.SetMetric(aMetric);
447 m_aLeftMF.SetMetric(aMetric);
448 SetMetric(*m_pTopMF, aMetric);
449 SetMetric(*m_pBottomMF, aMetric);
450
451 //Name
452 if(SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_TABLE_NAME, sal_False, &pItem ))
453 {
454 m_pNameED->SetText(((const SfxStringItem*)pItem)->GetValue());
455 m_pNameED->SaveValue();
456 }
457
458 if(SFX_ITEM_SET == rSet.GetItemState( FN_TABLE_REP, sal_False, &pItem ))
459 {
460 pTblData = (SwTableRep*)((const SwPtrItem*) pItem)->GetValue();
461 nMinTableWidth = pTblData->GetColCount() * MINLAY;
462
463 if(pTblData->GetWidthPercent())
464 {
465 m_pRelWidthCB->Check(sal_True);
466 RelWidthClickHdl(m_pRelWidthCB);
467 m_aWidthMF.SetPrcntValue(pTblData->GetWidthPercent(), FUNIT_CUSTOM);
468
469 m_aWidthMF.SaveValue();
470 nSaveWidth = static_cast< SwTwips >(m_aWidthMF.GetValue(FUNIT_CUSTOM));
471 }
472 else
473 {
474 m_aWidthMF.SetPrcntValue(m_aWidthMF.NormalizePercent(
475 pTblData->GetWidth()), FUNIT_TWIP);
476 m_aWidthMF.SaveValue();
477 nSaveWidth = pTblData->GetWidth();
478 nMinTableWidth = std::min( nSaveWidth, nMinTableWidth );
479 }
480
481 m_aWidthMF.SetRefValue(pTblData->GetSpace());
482 m_aWidthMF.SetLast(m_aWidthMF.NormalizePercent( pTblData->GetSpace() ));
483 m_aLeftMF.SetLast(m_aLeftMF.NormalizePercent( pTblData->GetSpace() ));
484 m_aRightMF.SetLast(m_aRightMF.NormalizePercent( pTblData->GetSpace() ));
485
486 m_aLeftMF.SetPrcntValue(m_aLeftMF.NormalizePercent(
487 pTblData->GetLeftSpace()), FUNIT_TWIP);
488 m_aRightMF.SetPrcntValue(m_aRightMF.NormalizePercent(
489 pTblData->GetRightSpace()), FUNIT_TWIP);
490 m_aLeftMF.SaveValue();
491 m_aRightMF.SaveValue();
492
493 nOldAlign = pTblData->GetAlign();
494
495 bool bSetRight = false, bSetLeft = false;
496 switch( nOldAlign )
497 {
498 case text::HoriOrientation::NONE:
499 m_pFreeBtn->Check();
500 if(m_pRelWidthCB->IsChecked())
501 bSetRight = true;
502 break;
503 case text::HoriOrientation::FULL:
504 {
505 bSetRight = bSetLeft = true;
506 m_pFullBtn->Check();
507 m_aWidthMF.Enable(sal_False);
508 m_pRelWidthCB->Enable(sal_False);
509 m_pWidthFT->Enable(sal_False);
510 }
511 break;
512 case text::HoriOrientation::LEFT:
513 {
514 bSetLeft = true;
515 m_pLeftBtn->Check();
516 }
517 break;
518 case text::HoriOrientation::LEFT_AND_WIDTH :
519 {
520 bSetRight = true;
521 m_pFromLeftBtn->Check();
522 }
523 break;
524 case text::HoriOrientation::RIGHT:
525 {
526 bSetRight = true;
527 m_pRightBtn->Check();
528 }
529 break;
530 case text::HoriOrientation::CENTER:
531 {
532 bSetRight = true;
533 m_pCenterBtn->Check();
534 }
535 break;
536 }
537 if ( bSetRight )
538 {
539 m_aRightMF.Enable(sal_False);
540 m_pRightFT->Enable(sal_False);
541 }
542 if ( bSetLeft )
543 {
544 m_aLeftMF.Enable(sal_False);
545 m_pLeftFT->Enable(sal_False);
546 }
547
548 }
549
550 //Margins
551 if(SFX_ITEM_SET == rSet.GetItemState( RES_UL_SPACE, sal_False,&pItem ))
552 {
553 m_pTopMF->SetValue(m_pTopMF->Normalize(
554 ((const SvxULSpaceItem*)pItem)->GetUpper()), FUNIT_TWIP);
555 m_pBottomMF->SetValue(m_pBottomMF->Normalize(
556 ((const SvxULSpaceItem*)pItem)->GetLower()), FUNIT_TWIP);
557 m_pTopMF->SaveValue();
558 m_pBottomMF->SaveValue();
559 }
560
561 //text direction
562 if( SFX_ITEM_SET == rSet.GetItemState( RES_FRAMEDIR, sal_True, &pItem ) )
563 {
564 sal_uIntPtr nVal = ((SvxFrameDirectionItem*)pItem)->GetValue();
565 sal_uInt16 nPos = m_pTextDirectionLB->GetEntryPos( (void*) nVal );
566 m_pTextDirectionLB->SelectEntryPos( nPos );
567 m_pTextDirectionLB->SaveValue();
568 }
569
570 m_aWidthMF.SetMax( 2*m_aWidthMF.NormalizePercent( pTblData->GetSpace() ), FUNIT_TWIP );
571 m_aRightMF.SetMax( m_aRightMF.NormalizePercent( pTblData->GetSpace() ), FUNIT_TWIP );
572 m_aLeftMF.SetMax( m_aLeftMF.NormalizePercent( pTblData->GetSpace() ), FUNIT_TWIP );
573 m_aWidthMF.SetMin( m_aWidthMF.NormalizePercent( nMinTableWidth ), FUNIT_TWIP );
574
575 }
576
577
578 void SwFormatTablePage::ActivatePage( const SfxItemSet& rSet )
579 {
580 OSL_ENSURE(pTblData, "table data not available?");
581 if(SFX_ITEM_SET == rSet.GetItemState( FN_TABLE_REP ))
582 {
583 SwTwips nCurWidth = text::HoriOrientation::FULL != pTblData->GetAlign() ?
584 pTblData->GetWidth() :
585 pTblData->GetSpace();
586 if(pTblData->GetWidthPercent() == 0 &&
587 nCurWidth != m_aWidthMF.DenormalizePercent(m_aWidthMF.GetValue(FUNIT_TWIP )))
588 {
589 m_aWidthMF.SetPrcntValue(m_aWidthMF.NormalizePercent(
590 nCurWidth), FUNIT_TWIP);
591 m_aWidthMF.SaveValue();
592 nSaveWidth = nCurWidth;
593 m_aLeftMF.SetPrcntValue(m_aLeftMF.NormalizePercent(
594 pTblData->GetLeftSpace()), FUNIT_TWIP);
595 m_aLeftMF.SaveValue();
596 m_aRightMF.SetPrcntValue(m_aRightMF.NormalizePercent(
597 pTblData->GetRightSpace()), FUNIT_TWIP);
598 m_aRightMF.SaveValue();
599 }
600 }
601
602 }
603
604 int SwFormatTablePage::DeactivatePage( SfxItemSet* _pSet )
605 {
606 // os: VCL sorgt nicht dafuer, dass das aktive Control im
607 // dialog bei OK den focus verliert
608 m_pNameED->GrabFocus();
609 // Test the table name for spaces
610 String sTblName = m_pNameED->GetText();
611 if(sTblName.Search(' ') != STRING_NOTFOUND)
612 {
613 InfoBox(this, SW_RES(MSG_WRONG_TABLENAME)).Execute();
614 m_pNameED->GrabFocus();
615 return KEEP_PAGE;
616 }
617 if(_pSet)
618 {
619 FillItemSet(*_pSet);
620 if(bModified)
621 {
622 SwTwips lLeft = static_cast< SwTwips >(m_aLeftMF.DenormalizePercent(m_aLeftMF.GetValue( FUNIT_TWIP )));
623 SwTwips lRight = static_cast< SwTwips >(m_aRightMF.DenormalizePercent(m_aRightMF.GetValue( FUNIT_TWIP )));
624
625
626 if( m_aLeftMF.GetText() != m_aLeftMF.GetSavedValue() ||
627 m_aRightMF.GetText() != m_aRightMF.GetSavedValue() )
628 {
629 pTblData->SetWidthChanged();
630 pTblData->SetLeftSpace( lLeft);
631 pTblData->SetRightSpace( lRight);
632 }
633
634 SwTwips lWidth;
635 if (m_pRelWidthCB->IsChecked() && m_pRelWidthCB->IsEnabled())
636 {
637 lWidth = pTblData->GetSpace() - lRight - lLeft;
638 sal_uInt16 nPercentWidth = (sal_uInt16)m_aWidthMF.GetValue(FUNIT_CUSTOM);
639 if(pTblData->GetWidthPercent() != nPercentWidth)
640 {
641 pTblData->SetWidthPercent(nPercentWidth);
642 pTblData->SetWidthChanged();
643 }
644 }
645 else
646 {
647 pTblData->SetWidthPercent(0);
648 lWidth = static_cast< SwTwips >(m_aWidthMF.DenormalizePercent(m_aWidthMF.GetValue( FUNIT_TWIP )));
649 }
650 pTblData->SetWidth(lWidth);
651
652 SwTwips nColSum = 0;
653 sal_uInt16 i;
654
655 for( i = 0; i < pTblData->GetColCount(); i++)
656 {
657 nColSum += pTblData->GetColumns()[i].nWidth;
658 }
659 if(nColSum != pTblData->GetWidth())
660 {
661 SwTwips nMinWidth = std::min( (long)MINLAY,
662 (long) (pTblData->GetWidth() /
663 pTblData->GetColCount() - 1));
664 SwTwips nDiff = nColSum - pTblData->GetWidth();
665 while ( std::abs(nDiff) > pTblData->GetColCount() + 1 )
666 {
667 SwTwips nSub = nDiff / pTblData->GetColCount();
668 for( i = 0; i < pTblData->GetColCount(); i++)
669 {
670 if(pTblData->GetColumns()[i].nWidth - nMinWidth > nSub)
671 {
672 pTblData->GetColumns()[i].nWidth -= nSub;
673 nDiff -= nSub;
674 }
675 else
676 {
677 nDiff -= pTblData->GetColumns()[i].nWidth - nMinWidth;
678 pTblData->GetColumns()[i].nWidth = nMinWidth;
679 }
680
681 }
682 }
683 }
684
685 sal_Int16 nAlign = 0;
686 if(m_pRightBtn->IsChecked())
687 nAlign = text::HoriOrientation::RIGHT;
688 else if(m_pLeftBtn->IsChecked())
689 nAlign = text::HoriOrientation::LEFT;
690 else if(m_pFromLeftBtn->IsChecked())
691 nAlign = text::HoriOrientation::LEFT_AND_WIDTH;
692 else if(m_pCenterBtn->IsChecked())
693 nAlign = text::HoriOrientation::CENTER;
694 else if(m_pFreeBtn->IsChecked())
695 nAlign = text::HoriOrientation::NONE;
696 else if(m_pFullBtn->IsChecked())
697 {
698 nAlign = text::HoriOrientation::FULL;
699 lWidth = lAutoWidth;
700 }
701 if(nAlign != pTblData->GetAlign())
702 {
703 pTblData->SetWidthChanged();
704 pTblData->SetAlign(nAlign);
705 }
706
707 if(pTblData->GetWidth() != lWidth )
708 {
709 pTblData->SetWidthChanged();
710 pTblData->SetWidth(
711 nAlign == text::HoriOrientation::FULL ? pTblData->GetSpace() : lWidth );
712 }
713 if(pTblData->HasWidthChanged())
714 _pSet->Put(SwPtrItem(FN_TABLE_REP, pTblData));
715 }
716 }
717 return sal_True;
718 }
719 //Description: Page column configuration
720 SwTableColumnPage::SwTableColumnPage(Window* pParent, const SfxItemSet& rSet)
721 : SfxTabPage(pParent, "TableColumnPage",
722 "modules/swriter/ui/tablecolumnpage.ui", rSet)
723 , nTableWidth(0)
724 , nMinWidth(MINLAY)
725 , nNoOfCols(0)
726 , nNoOfVisibleCols(0)
727 , bModified(false)
728 , bModifyTbl(false)
729 , bPercentMode(false)
730 {
731 get(m_pModifyTableCB, "adaptwidth");
732 get(m_pProportionalCB, "adaptcolumns");
733 get(m_pSpaceFT, "spaceft");
734 get(m_pSpaceED, "space-nospin");
735 get(m_pUpBtn, "next");
736 get(m_pDownBtn, "back");
737
738 m_aFieldArr[0].set(get<MetricField>("width1"));
739 m_aFieldArr[1].set(get<MetricField>("width2"));
740 m_aFieldArr[2].set(get<MetricField>("width3"));
741 m_aFieldArr[3].set(get<MetricField>("width4"));
742 m_aFieldArr[4].set(get<MetricField>("width5"));
743 m_aFieldArr[5].set(get<MetricField>("width6"));
744
745 m_pTextArr[0] = get<FixedText>("1");
746 m_pTextArr[1] = get<FixedText>("2");
747 m_pTextArr[2] = get<FixedText>("3");
748 m_pTextArr[3] = get<FixedText>("4");
749 m_pTextArr[4] = get<FixedText>("5");
750 m_pTextArr[5] = get<FixedText>("6");
751
752 SetExchangeSupport();
753
754 const SfxPoolItem* pItem;
755 Init((SFX_ITEM_SET == rSet.GetItemState( SID_HTML_MODE, sal_False,&pItem )
756 && ((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON));
757
758 };
759 //Description: Page column configuration
760 SwTableColumnPage::~SwTableColumnPage()
761 {
762 };
763
764
765 SfxTabPage* SwTableColumnPage::Create( Window* pParent,
766 const SfxItemSet& rAttrSet)
767 {
768 return new SwTableColumnPage( pParent, rAttrSet );
769 };
770
771
772 void SwTableColumnPage::Reset( const SfxItemSet& )
773 {
774 const SfxItemSet& rSet = GetItemSet();
775
776 const SfxPoolItem* pItem;
777 if(SFX_ITEM_SET == rSet.GetItemState( FN_TABLE_REP, sal_False, &pItem ))
778 {
779 pTblData = (SwTableRep*)((const SwPtrItem*) pItem)->GetValue();
780 nNoOfVisibleCols = pTblData->GetColCount();
781 nNoOfCols = pTblData->GetAllColCount();
782 nTableWidth = pTblData->GetAlign() != text::HoriOrientation::FULL &&
783 pTblData->GetAlign() != text::HoriOrientation::LEFT_AND_WIDTH?
784 pTblData->GetWidth() : pTblData->GetSpace();
785
786 sal_uInt16 i;
787 for( i = 0; i < nNoOfCols; i++ )
788 {
789 if( pTblData->GetColumns()[i].nWidth < nMinWidth )
790 nMinWidth = pTblData->GetColumns()[i].nWidth;
791 }
792 sal_Int64 nMinTwips = m_aFieldArr[0].NormalizePercent( nMinWidth );
793 sal_Int64 nMaxTwips = m_aFieldArr[0].NormalizePercent( nTableWidth );
794 for( i = 0; (i < MET_FIELDS) && (i < nNoOfVisibleCols); i++ )
795 {
796 m_aFieldArr[i].SetPrcntValue( m_aFieldArr[i].NormalizePercent(
797 GetVisibleWidth(i) ), FUNIT_TWIP );
798 m_aFieldArr[i].SetMin( nMinTwips , FUNIT_TWIP );
799 m_aFieldArr[i].SetMax( nMaxTwips , FUNIT_TWIP );
800 m_aFieldArr[i].Enable();
801 m_pTextArr[i]->Enable();
802 }
803
804 if( nNoOfVisibleCols > MET_FIELDS )
805 m_pUpBtn->Enable();
806 i = nNoOfVisibleCols;
807 while( i < MET_FIELDS )
808 {
809 m_aFieldArr[i].SetText( aEmptyStr );
810 m_pTextArr[i]->Disable();
811 i++;
812 }
813 }
814 ActivatePage(rSet);
815
816 };
817
818
819 void SwTableColumnPage::Init(sal_Bool bWeb)
820 {
821 FieldUnit aMetric = ::GetDfltMetric(bWeb);
822 Link aLkUp = LINK( this, SwTableColumnPage, UpHdl );
823 Link aLkDown = LINK( this, SwTableColumnPage, DownHdl );
824 Link aLkLF = LINK( this, SwTableColumnPage, LoseFocusHdl );
825 for( sal_uInt16 i = 0; i < MET_FIELDS; i++ )
826 {
827 aValueTbl[i] = i;
828 m_aFieldArr[i].SetMetric(aMetric);
829 m_aFieldArr[i].SetUpHdl( aLkUp );
830 m_aFieldArr[i].SetDownHdl( aLkDown );
831 m_aFieldArr[i].SetLoseFocusHdl( aLkLF );
832 }
833 SetMetric(*m_pSpaceED, aMetric);
834
835 Link aLk = LINK( this, SwTableColumnPage, AutoClickHdl );
836 m_pUpBtn->SetClickHdl( aLk );
837 m_pDownBtn->SetClickHdl( aLk );
838
839 aLk = LINK( this, SwTableColumnPage, ModeHdl );
840 m_pModifyTableCB->SetClickHdl( aLk );
841 m_pProportionalCB->SetClickHdl( aLk );
842 };
843
844
845 IMPL_LINK( SwTableColumnPage, AutoClickHdl, CheckBox *, pBox )
846 {
847 //move display window
848 if(pBox == (CheckBox *)m_pDownBtn)
849 {
850 if(aValueTbl[0] > 0)
851 {
852 for( sal_uInt16 i=0; i < MET_FIELDS; i++ )
853 aValueTbl[i] -= 1;
854 }
855 }
856 if (pBox == (CheckBox *)m_pUpBtn)
857 {
858 if( aValueTbl[ MET_FIELDS -1 ] < nNoOfVisibleCols -1 )
859 {
860 for(sal_uInt16 i=0;i < MET_FIELDS;i++)
861 aValueTbl[i] += 1;
862 }
863 }
864 for( sal_uInt16 i = 0; (i < nNoOfVisibleCols ) && ( i < MET_FIELDS); i++ )
865 {
866 String sEntry = OUString('~');
867 String sIndex = OUString::number( aValueTbl[i] + 1 );
868 sEntry += sIndex;
869 m_pTextArr[i]->SetText( sEntry );
870
871 //added by menghu for SODC_5143,12/12/2006
872 OUString sColumnWidth = SW_RESSTR( STR_ACCESS_COLUMN_WIDTH);
873 sColumnWidth = sColumnWidth.replaceFirst( "%1", sIndex );
874 m_aFieldArr[i].SetAccessibleName( sColumnWidth );
875 }
876
877 m_pDownBtn->Enable(aValueTbl[0] > 0);
878 m_pUpBtn->Enable(aValueTbl[ MET_FIELDS -1 ] < nNoOfVisibleCols -1 );
879 UpdateCols(0);
880 return 0;
881 };
882
883
884 IMPL_LINK_INLINE_START( SwTableColumnPage, UpHdl, MetricField*, pEdit )
885 {
886 bModified = sal_True;
887 ModifyHdl( pEdit );
888 return 0;
889 };
890 IMPL_LINK_INLINE_END( SwTableColumnPage, UpHdl, MetricField*, pEdit )
891
892
893 IMPL_LINK_INLINE_START( SwTableColumnPage, DownHdl, MetricField*, pEdit )
894 {
895 bModified = sal_True;
896 ModifyHdl( pEdit );
897 return 0;
898 };
899 IMPL_LINK_INLINE_END( SwTableColumnPage, DownHdl, MetricField*, pEdit )
900
901
902 IMPL_LINK_INLINE_START( SwTableColumnPage, LoseFocusHdl, MetricField*, pEdit )
903 {
904 if (pEdit->IsModified())
905 {
906 bModified = sal_True;
907 ModifyHdl( pEdit );
908 }
909 return 0;
910 };
911 IMPL_LINK_INLINE_END( SwTableColumnPage, LoseFocusHdl, MetricField*, pEdit )
912
913
914 IMPL_LINK( SwTableColumnPage, ModeHdl, CheckBox*, pBox )
915 {
916 sal_Bool bCheck = pBox->IsChecked();
917 if (pBox == m_pProportionalCB)
918 {
919 if(bCheck)
920 m_pModifyTableCB->Check();
921 m_pModifyTableCB->Enable(!bCheck && bModifyTbl);
922 }
923 return 0;
924 };
925
926
927 sal_Bool SwTableColumnPage::FillItemSet( SfxItemSet& )
928 {
929 for( sal_uInt16 i = 0; i < MET_FIELDS; i++ )
930 {
931 if (m_aFieldArr[i].HasFocus())
932 {
933 LoseFocusHdl(m_aFieldArr[i].get());
934 break;
935 }
936 }
937
938 if(bModified)
939 {
940 pTblData->SetColsChanged();
941 }
942 return bModified;
943 };
944
945
946 void SwTableColumnPage::ModifyHdl( MetricField* pField )
947 {
948 PercentFieldWrap *pEdit = NULL;
949 sal_uInt16 nAktPos;
950 sal_uInt16 i;
951
952 for( i = 0; i < MET_FIELDS; i++)
953 {
954 if (pField == m_aFieldArr[i].get())
955 {
956 pEdit = &m_aFieldArr[i];
957 break;
958 }
959 }
960
961 if (MET_FIELDS <= i || !pEdit)
962 {
963 OSL_ENSURE(false, "cannot happen.");
964 return;
965 }
966
967 SetVisibleWidth(aValueTbl[i], static_cast< SwTwips >(pEdit->DenormalizePercent(pEdit->GetValue( FUNIT_TWIP ))) );
968 nAktPos = aValueTbl[i];
969
970 UpdateCols( nAktPos );
971 };
972
973
974 void SwTableColumnPage::UpdateCols( sal_uInt16 nAktPos )
975 {
976 SwTwips nSum = 0;
977 sal_uInt16 i;
978
979 for( i = 0; i < nNoOfCols; i++ )
980 {
981 nSum += (pTblData->GetColumns())[i].nWidth;
982 }
983 SwTwips nDiff = nSum - nTableWidth;
984
985 sal_Bool bModifyTable = m_pModifyTableCB->IsChecked();
986 sal_Bool bProp = m_pProportionalCB->IsChecked();
987
988 if(!bModifyTable && !bProp )
989 {
990 // the table width is constant, the difference is balanced with the other columns
991 sal_uInt16 nLoopCount = 0;
992 while( nDiff )
993 {
994 if( ++nAktPos == nNoOfVisibleCols)
995 {
996 nAktPos = 0;
997 ++nLoopCount;
998 //#i101353# in small tables it might not be possible to balance column width
999 if( nLoopCount > 1 )
1000 break;
1001 }
1002 if( nDiff < 0 )
1003 {
1004 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) -nDiff);
1005 nDiff = 0;
1006 }
1007 else if( GetVisibleWidth(nAktPos) >= nDiff + nMinWidth )
1008 {
1009 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) -nDiff);
1010 nDiff = 0;
1011 }
1012 if( nDiff > 0 && GetVisibleWidth(nAktPos) > nMinWidth )
1013 {
1014 if( nDiff >= (GetVisibleWidth(nAktPos) - nMinWidth) )
1015 {
1016 nDiff -= (GetVisibleWidth(nAktPos) - nMinWidth);
1017 SetVisibleWidth(nAktPos, nMinWidth);
1018 }
1019 else
1020 {
1021 nDiff = 0;
1022 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) -nDiff);
1023 }
1024 OSL_ENSURE(nDiff >= 0, "nDiff < 0 cannot be here!");
1025 }
1026 }
1027 }
1028 else if(bModifyTable && !bProp)
1029 {
1030 // Difference is balanced by the width of the table,
1031 // other columns remain unchanged.
1032 OSL_ENSURE(nDiff <= pTblData->GetSpace() - nTableWidth, "wrong maximum" );
1033 SwTwips nActSpace = pTblData->GetSpace() - nTableWidth;
1034 if(nDiff > nActSpace)
1035 {
1036 nTableWidth = pTblData->GetSpace();
1037 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) - nDiff + nActSpace );
1038 }
1039 else
1040 {
1041 nTableWidth += nDiff;
1042 }
1043 }
1044 else if(bModifyTable & bProp)
1045 {
1046 // All columns will be changed proportionally with,
1047 // the table width is adjusted accordingly.
1048 OSL_ENSURE(nDiff * nNoOfVisibleCols <= pTblData->GetSpace() - nTableWidth, "wrong maximum" );
1049 long nAdd = nDiff;
1050 if(nDiff * nNoOfVisibleCols > pTblData->GetSpace() - nTableWidth)
1051 {
1052 nAdd = (pTblData->GetSpace() - nTableWidth) / nNoOfVisibleCols;
1053 SetVisibleWidth(nAktPos, GetVisibleWidth(nAktPos) - nDiff + nAdd );
1054 nDiff = nAdd;
1055 }
1056 if(nAdd)
1057 for(i = 0; i < nNoOfVisibleCols; i++ )
1058 {
1059 if(i == nAktPos)
1060 continue;
1061 SwTwips nVisWidth;
1062 if((nVisWidth = GetVisibleWidth(i)) + nDiff < MINLAY)
1063 {
1064 nAdd += nVisWidth - MINLAY;
1065 SetVisibleWidth(i, MINLAY);
1066 }
1067 else
1068 {
1069 SetVisibleWidth(i, nVisWidth + nDiff);
1070 nAdd += nDiff;
1071 }
1072
1073 }
1074 nTableWidth += nAdd;
1075 }
1076
1077 if(!bPercentMode)
1078 m_pSpaceED->SetValue(m_pSpaceED->Normalize( pTblData->GetSpace() - nTableWidth) , FUNIT_TWIP);
1079
1080 for( i = 0; ( i < nNoOfVisibleCols ) && ( i < MET_FIELDS ); i++)
1081 {
1082 m_aFieldArr[i].SetPrcntValue(m_aFieldArr[i].NormalizePercent(
1083 GetVisibleWidth(aValueTbl[i]) ), FUNIT_TWIP);
1084 m_aFieldArr[i].ClearModifyFlag();
1085 }
1086 }
1087
1088 void SwTableColumnPage::ActivatePage( const SfxItemSet& )
1089 {
1090 bPercentMode = pTblData->GetWidthPercent() != 0;
1091 for( sal_uInt16 i = 0; (i < MET_FIELDS) && (i < nNoOfVisibleCols); i++ )
1092 {
1093 m_aFieldArr[i].SetRefValue(pTblData->GetWidth());
1094 m_aFieldArr[i].ShowPercent( bPercentMode );
1095 }
1096
1097 sal_uInt16 nTblAlign = pTblData->GetAlign();
1098 if((text::HoriOrientation::FULL != nTblAlign && nTableWidth != pTblData->GetWidth()) ||
1099 (text::HoriOrientation::FULL == nTblAlign && nTableWidth != pTblData->GetSpace()))
1100 {
1101 nTableWidth = text::HoriOrientation::FULL == nTblAlign ?
1102 pTblData->GetSpace() :
1103 pTblData->GetWidth();
1104 UpdateCols(0);
1105 }
1106 bModifyTbl = sal_True;
1107 if(pTblData->GetWidthPercent() ||
1108 text::HoriOrientation::FULL == nTblAlign ||
1109 pTblData->IsLineSelected() )
1110 bModifyTbl = sal_False;
1111 if(bPercentMode)
1112 {
1113 m_pModifyTableCB->Check(sal_False);
1114 m_pProportionalCB->Check(sal_False);
1115 }
1116 else if( !bModifyTbl )
1117 {
1118 m_pProportionalCB->Check(sal_False);
1119 m_pModifyTableCB->Check(sal_False);
1120 }
1121 m_pSpaceFT->Enable(!bPercentMode);
1122 m_pSpaceED->Enable(!bPercentMode);
1123 m_pModifyTableCB->Enable( !bPercentMode && bModifyTbl );
1124 m_pProportionalCB->Enable(!bPercentMode && bModifyTbl );
1125
1126 m_pSpaceED->SetValue(m_pSpaceED->Normalize(
1127 pTblData->GetSpace() - nTableWidth) , FUNIT_TWIP);
1128
1129 }
1130
1131
1132 int SwTableColumnPage::DeactivatePage( SfxItemSet* _pSet )
1133 {
1134 if(_pSet)
1135 {
1136 FillItemSet(*_pSet);
1137 if(text::HoriOrientation::FULL != pTblData->GetAlign() && pTblData->GetWidth() != nTableWidth)
1138 {
1139 pTblData->SetWidth(nTableWidth);
1140 SwTwips nDiff = pTblData->GetSpace() - pTblData->GetWidth() -
1141 pTblData->GetLeftSpace() - pTblData->GetRightSpace();
1142 switch( pTblData->GetAlign() )
1143 {
1144 case text::HoriOrientation::RIGHT:
1145 pTblData->SetLeftSpace(pTblData->GetLeftSpace() + nDiff);
1146 break;
1147 case text::HoriOrientation::LEFT:
1148 pTblData->SetRightSpace(pTblData->GetRightSpace() + nDiff);
1149 break;
1150 case text::HoriOrientation::NONE:
1151 {
1152 SwTwips nDiff2 = nDiff/2;
1153 if( nDiff > 0 ||
1154 (-nDiff2 < pTblData->GetRightSpace() && - nDiff2 < pTblData->GetLeftSpace()))
1155 {
1156 pTblData->SetRightSpace(pTblData->GetRightSpace() + nDiff2);
1157 pTblData->SetLeftSpace(pTblData->GetLeftSpace() + nDiff2);
1158 }
1159 else
1160 {
1161 if(pTblData->GetRightSpace() > pTblData->GetLeftSpace())
1162 {
1163 pTblData->SetLeftSpace(0);
1164 pTblData->SetRightSpace(pTblData->GetSpace() - pTblData->GetWidth());
1165 }
1166 else
1167 {
1168 pTblData->SetRightSpace(0);
1169 pTblData->SetLeftSpace(pTblData->GetSpace() - pTblData->GetWidth());
1170 }
1171 }
1172 }
1173 break;
1174 case text::HoriOrientation::CENTER:
1175 pTblData->SetRightSpace(pTblData->GetRightSpace() + nDiff/2);
1176 pTblData->SetLeftSpace(pTblData->GetLeftSpace() + nDiff/2);
1177 break;
1178 case text::HoriOrientation::LEFT_AND_WIDTH :
1179 if(nDiff > pTblData->GetRightSpace())
1180 {
1181 pTblData->SetLeftSpace(pTblData->GetSpace() - pTblData->GetWidth());
1182 }
1183 pTblData->SetRightSpace(
1184 pTblData->GetSpace() - pTblData->GetWidth() - pTblData->GetLeftSpace());
1185 break;
1186 }
1187 pTblData->SetWidthChanged();
1188 }
1189 _pSet->Put(SwPtrItem( FN_TABLE_REP, pTblData ));
1190 }
1191 return sal_True;
1192 }
1193
1194
1195 SwTwips SwTableColumnPage::GetVisibleWidth(sal_uInt16 nPos)
1196 {
1197 sal_uInt16 i=0;
1198
1199 while( nPos )
1200 {
1201 if(pTblData->GetColumns()[i].bVisible && nPos)
1202 nPos--;
1203 i++;
1204 }
1205 SwTwips nReturn = pTblData->GetColumns()[i].nWidth;
1206 OSL_ENSURE(i < nNoOfCols, "Array index out of range");
1207 while(!pTblData->GetColumns()[i].bVisible && (i + 1) < nNoOfCols)
1208 nReturn += pTblData->GetColumns()[++i].nWidth;
1209
1210 return nReturn;
1211 }
1212
1213
1214 void SwTableColumnPage::SetVisibleWidth(sal_uInt16 nPos, SwTwips nNewWidth)
1215 {
1216 sal_uInt16 i=0;
1217 while( nPos )
1218 {
1219 if(pTblData->GetColumns()[i].bVisible && nPos)
1220 nPos--;
1221 i++;
1222 }
1223 OSL_ENSURE(i < nNoOfCols, "Array index out of range");
1224 pTblData->GetColumns()[i].nWidth = nNewWidth;
1225 while(!pTblData->GetColumns()[i].bVisible && (i + 1) < nNoOfCols)
1226 pTblData->GetColumns()[++i].nWidth = 0;
1227
1228 }
1229
1230 SwTableTabDlg::SwTableTabDlg(Window* pParent, SfxItemPool&,
1231 const SfxItemSet* pItemSet, SwWrtShell* pSh)
1232 : SfxTabDialog(0, pParent, "TablePropertiesDialog",
1233 "modules/swriter/ui/tableproperties.ui", pItemSet, 0)
1234 , pShell(pSh)
1235 , m_nHtmlMode(::GetHtmlMode(pSh->GetView().GetDocShell()))
1236 {
1237 SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
1238 OSL_ENSURE(pFact, "Dialogdiet fail!");
1239 AddTabPage("table", &SwFormatTablePage::Create, 0);
1240 m_nTextFlowId = AddTabPage("textflow", &SwTextFlowPage::Create, 0);
1241 AddTabPage("columns", &SwTableColumnPage::Create, 0);
1242 m_nBackgroundId = AddTabPage("background", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BACKGROUND), 0);
1243 m_nBorderId = AddTabPage("borders", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BORDER), 0);
1244 }
1245
1246 void SwTableTabDlg::PageCreated(sal_uInt16 nId, SfxTabPage& rPage)
1247 {
1248 SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool()));
1249 if (nId == m_nBackgroundId)
1250 {
1251 sal_Int32 nFlagType = SVX_SHOW_TBLCTL;
1252 if(!( m_nHtmlMode & HTMLMODE_ON ) ||
1253 m_nHtmlMode & HTMLMODE_SOME_STYLES)
1254 nFlagType |= SVX_SHOW_SELECTOR;
1255 aSet.Put (SfxUInt32Item(SID_FLAG_TYPE, nFlagType));
1256 rPage.PageCreated(aSet);
1257 }
1258 else if (nId == m_nBorderId)
1259 {
1260 aSet.Put (SfxUInt16Item(SID_SWMODE_TYPE,SW_BORDER_MODE_TABLE));
1261 rPage.PageCreated(aSet);
1262 }
1263 else if (nId == m_nTextFlowId)
1264 {
1265 ((SwTextFlowPage&)rPage).SetShell(pShell);
1266 const sal_uInt16 eType = pShell->GetFrmType(0,sal_True);
1267 if( !(FRMTYPE_BODY & eType) )
1268 ((SwTextFlowPage&)rPage).DisablePageBreak();
1269 }
1270 }
1271
1272 SwTextFlowPage::SwTextFlowPage(Window* pParent, const SfxItemSet& rSet)
1273 : SfxTabPage(pParent, "TableTextFlowPage",
1274 "modules/swriter/ui/tabletextflowpage.ui", rSet)
1275 , pShell(0)
1276 , bPageBreak(true)
1277 , bHtmlMode(false)
1278 {
1279 get(m_pPgBrkCB, "break");
1280
1281 get(m_pPgBrkRB, "page");
1282 get(m_pColBrkRB, "column");
1283
1284 get(m_pPgBrkBeforeRB, "before");
1285 get(m_pPgBrkAfterRB, "after");
1286
1287 get(m_pPageCollCB, "pagestyle");
1288 get(m_pPageCollLB, "pagestylelb");
1289 get(m_pPageNoFT, "pagenoft");
1290 get(m_pPageNoNF, "pagenonf");
1291
1292 get(m_pSplitCB, "split");
1293 get(m_pSplitRowCB, "splitrow");
1294 get(m_pKeepCB, "keep");
1295 get(m_pHeadLineCB, "headline");
1296
1297 get(m_pRepeatHeaderCombo, "repeatheader");
1298 get(m_pRepeatHeaderNF, "repeatheadernf");
1299
1300 get(m_pTextDirectionLB, "textdirection");
1301 get(m_pVertOrientLB, "vertorient");
1302
1303 m_pPgBrkRB->SetAccessibleRelationMemberOf(m_pPgBrkCB);
1304 m_pColBrkRB->SetAccessibleRelationMemberOf(m_pPgBrkCB);
1305 m_pPgBrkBeforeRB->SetAccessibleRelationMemberOf(m_pPgBrkCB);
1306 m_pPgBrkAfterRB->SetAccessibleRelationMemberOf(m_pPgBrkCB);
1307 m_pPageCollLB->SetAccessibleName(m_pPageCollCB->GetText());
1308
1309 m_pPgBrkCB->SetClickHdl(LINK(this, SwTextFlowPage, PageBreakHdl_Impl));
1310 m_pPgBrkBeforeRB->SetClickHdl(
1311 LINK( this, SwTextFlowPage, PageBreakPosHdl_Impl ) );
1312 m_pPgBrkAfterRB->SetClickHdl(
1313 LINK( this, SwTextFlowPage, PageBreakPosHdl_Impl ) );
1314 m_pPageCollCB->SetClickHdl(
1315 LINK( this, SwTextFlowPage, ApplyCollClickHdl_Impl ) );
1316 m_pColBrkRB->SetClickHdl(
1317 LINK( this, SwTextFlowPage, PageBreakTypeHdl_Impl ) );
1318 m_pPgBrkRB->SetClickHdl(
1319 LINK( this, SwTextFlowPage, PageBreakTypeHdl_Impl ) );
1320 m_pSplitCB->SetClickHdl(
1321 LINK( this, SwTextFlowPage, SplitHdl_Impl));
1322 m_pSplitRowCB->SetClickHdl(
1323 LINK( this, SwTextFlowPage, SplitRowHdl_Impl));
1324 m_pHeadLineCB->SetClickHdl( LINK( this, SwTextFlowPage, HeadLineCBClickHdl ) );
1325
1326 #ifndef SW_FILEFORMAT_40
1327 const SfxPoolItem *pItem;
1328 if(SFX_ITEM_SET == rSet.GetItemState( SID_HTML_MODE, sal_False,&pItem )
1329 && ((const SfxUInt16Item*)pItem)->GetValue() & HTMLMODE_ON)
1330 #endif
1331 {
1332 m_pKeepCB->Hide();
1333 m_pSplitCB->Hide();
1334 m_pSplitRowCB->Hide();
1335 }
1336
1337 HeadLineCBClickHdl();
1338 }
1339
1340 SwTextFlowPage::~SwTextFlowPage()
1341 {
1342 }
1343
1344 SfxTabPage* SwTextFlowPage::Create( Window* pParent,
1345 const SfxItemSet& rAttrSet)
1346 {
1347 return new SwTextFlowPage(pParent, rAttrSet);
1348 }
1349
1350 sal_Bool SwTextFlowPage::FillItemSet( SfxItemSet& rSet )
1351 {
1352 sal_Bool bModified = sal_False;
1353
1354 // Repeat Heading
1355 if(m_pHeadLineCB->IsChecked() != m_pHeadLineCB->GetSavedValue() ||
1356 OUString::number( static_cast< sal_Int32 >(m_pRepeatHeaderNF->GetValue()) ) != m_pRepeatHeaderNF->GetSavedValue() )
1357 {
1358 bModified |= 0 != rSet.Put(
1359 SfxUInt16Item(FN_PARAM_TABLE_HEADLINE, m_pHeadLineCB->IsChecked()? sal_uInt16(m_pRepeatHeaderNF->GetValue()) : 0 ));
1360 }
1361 if(m_pKeepCB->IsChecked() != m_pKeepCB->GetSavedValue())
1362 bModified |= 0 != rSet.Put( SvxFmtKeepItem( m_pKeepCB->IsChecked(), RES_KEEP));
1363
1364 if(m_pSplitCB->IsChecked() != m_pSplitCB->GetSavedValue())
1365 bModified |= 0 != rSet.Put( SwFmtLayoutSplit( m_pSplitCB->IsChecked()));
1366
1367 if(m_pSplitRowCB->IsChecked() != m_pSplitRowCB->GetSavedValue())
1368 bModified |= 0 != rSet.Put( SwFmtRowSplit( m_pSplitRowCB->IsChecked()));
1369
1370
1371 const SvxFmtBreakItem* pBreak = (const SvxFmtBreakItem*)GetOldItem( rSet, RES_BREAK );
1372 const SwFmtPageDesc* pDesc = (const SwFmtPageDesc*) GetOldItem( rSet, RES_PAGEDESC );
1373
1374
1375 sal_Bool bState = m_pPageCollCB->IsChecked();
1376
1377 // If we have a page style, then there's no break
1378 sal_Bool bPageItemPut = sal_False;
1379 if ( bState != m_pPageCollCB->GetSavedValue() ||
1380 ( bState &&
1381 m_pPageCollLB->GetSelectEntryPos() != m_pPageCollLB->GetSavedValue() )
1382 || (m_pPageNoNF->IsEnabled() && m_pPageNoNF->IsValueModified()) )
1383 {
1384 String sPage;
1385
1386 if ( bState )
1387 {
1388 sPage = m_pPageCollLB->GetSelectEntry();
1389 }
1390 sal_uInt16 nPgNum = static_cast< sal_uInt16 >(m_pPageNoNF->GetValue());
1391 if ( !pDesc || !pDesc->GetPageDesc() ||
1392 ( pDesc->GetPageDesc() && ((pDesc->GetPageDesc()->GetName() != sPage) ||
1393 !comphelper::string::equals(m_pPageNoNF->GetSavedValue(), nPgNum))))
1394 {
1395 SwFmtPageDesc aFmt( pShell->FindPageDescByName( sPage, sal_True ) );
1396 aFmt.SetNumOffset(bState ? nPgNum : 0);
1397 bModified |= 0 != rSet.Put( aFmt );
1398 bPageItemPut = bState;
1399 }
1400 }
1401 sal_Bool bIsChecked = m_pPgBrkCB->IsChecked();
1402 if ( !bPageItemPut &&
1403 ( bState != m_pPageCollCB->GetSavedValue() ||
1404 bIsChecked != m_pPgBrkCB->GetSavedValue() ||
1405 m_pPgBrkBeforeRB->IsChecked() != m_pPgBrkBeforeRB->GetSavedValue() ||
1406 m_pPgBrkRB->IsChecked() != m_pPgBrkRB->GetSavedValue() ))
1407 {
1408 SvxFmtBreakItem aBreak(
1409 (const SvxFmtBreakItem&)GetItemSet().Get( RES_BREAK ) );
1410
1411 if(bIsChecked)
1412 {
1413 sal_Bool bBefore = m_pPgBrkBeforeRB->IsChecked();
1414
1415 if ( m_pPgBrkRB->IsChecked() )
1416 {
1417 if ( bBefore )
1418 aBreak.SetValue( SVX_BREAK_PAGE_BEFORE );
1419 else
1420 aBreak.SetValue( SVX_BREAK_PAGE_AFTER );
1421 }
1422 else
1423 {
1424 if ( bBefore )
1425 aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE );
1426 else
1427 aBreak.SetValue( SVX_BREAK_COLUMN_AFTER );
1428 }
1429 }
1430 else
1431 {
1432 aBreak.SetValue( SVX_BREAK_NONE );
1433 }
1434
1435 if ( !pBreak || !( *(const SvxFmtBreakItem*)pBreak == aBreak ) )
1436 {
1437 bModified |= 0 != rSet.Put( aBreak );
1438 }
1439 }
1440
1441 if(m_pTextDirectionLB->GetSelectEntryPos() != m_pTextDirectionLB->GetSavedValue())
1442 {
1443 bModified |= 0 != rSet.Put(
1444 SvxFrameDirectionItem(
1445 (SvxFrameDirection)(sal_uLong)m_pTextDirectionLB->GetEntryData(m_pTextDirectionLB->GetSelectEntryPos())
1446 , FN_TABLE_BOX_TEXTORIENTATION));
1447 }
1448
1449 if(m_pVertOrientLB->GetSelectEntryPos() != m_pVertOrientLB->GetSavedValue())
1450 {
1451 sal_uInt16 nOrient = USHRT_MAX;
1452 switch(m_pVertOrientLB->GetSelectEntryPos())
1453 {
1454 case 0 : nOrient = text::VertOrientation::NONE; break;
1455 case 1 : nOrient = text::VertOrientation::CENTER; break;
1456 case 2 : nOrient = text::VertOrientation::BOTTOM; break;
1457 }
1458 if(nOrient != USHRT_MAX)
1459 bModified |= 0 != rSet.Put(SfxUInt16Item(FN_TABLE_SET_VERT_ALIGN, nOrient));
1460 }
1461
1462 return bModified;
1463
1464 }
1465
1466 void SwTextFlowPage::Reset( const SfxItemSet& rSet )
1467 {
1468 const SfxPoolItem* pItem;
1469 SvxHtmlOptions& rHtmlOpt = SvxHtmlOptions::Get();
1470 bool bFlowAllowed = !bHtmlMode || rHtmlOpt.IsPrintLayoutExtension();
1471 if(bFlowAllowed)
1472 {
1473 // Inserting of the existing page templates in the list box.
1474 const sal_uInt16 nCount = pShell->GetPageDescCnt();
1475 sal_uInt16 i;
1476
1477 for( i = 0; i < nCount; ++i)
1478 {
1479 const SwPageDesc &rPageDesc = pShell->GetPageDesc(i);
1480 m_pPageCollLB->InsertEntry(rPageDesc.GetName());
1481 }
1482
1483 String aFmtName;
1484 for(i = RES_POOLPAGE_BEGIN; i < RES_POOLPAGE_END; ++i)
1485 if( LISTBOX_ENTRY_NOTFOUND == m_pPageCollLB->GetEntryPos(
1486 aFmtName = SwStyleNameMapper::GetUIName( i, aFmtName ) ))
1487 m_pPageCollLB->InsertEntry( aFmtName );
1488
1489 if(SFX_ITEM_SET == rSet.GetItemState( RES_KEEP, sal_False, &pItem ))
1490 {
1491 m_pKeepCB->Check( ((const SvxFmtKeepItem*)pItem)->GetValue() );
1492 m_pKeepCB->SaveValue();
1493 }
1494 if(SFX_ITEM_SET == rSet.GetItemState( RES_LAYOUT_SPLIT, sal_False, &pItem ))
1495 {
1496 m_pSplitCB->Check( ((const SwFmtLayoutSplit*)pItem)->GetValue() );
1497 }
1498 else
1499 m_pSplitCB->Check();
1500
1501 m_pSplitCB->SaveValue();
1502 SplitHdl_Impl(m_pSplitCB);
1503
1504 if(SFX_ITEM_SET == rSet.GetItemState( RES_ROW_SPLIT, sal_False, &pItem ))
1505 {
1506 m_pSplitRowCB->Check( ((const SwFmtRowSplit*)pItem)->GetValue() );
1507 }
1508 else
1509 m_pSplitRowCB->SetState(STATE_DONTKNOW);
1510 m_pSplitRowCB->SaveValue();
1511
1512 if(bPageBreak)
1513 {
1514 if(SFX_ITEM_SET == rSet.GetItemState( RES_PAGEDESC, sal_False, &pItem ))
1515 {
1516 String sPageDesc;
1517 const SwPageDesc* pDesc = ((const SwFmtPageDesc*)pItem)->GetPageDesc();
1518 m_pPageNoNF->SetValue(((const SwFmtPageDesc*)pItem)->GetNumOffset());
1519 if(pDesc)
1520 sPageDesc = pDesc->GetName();
1521 if ( sPageDesc.Len() &&
1522 m_pPageCollLB->GetEntryPos( sPageDesc ) != LISTBOX_ENTRY_NOTFOUND )
1523 {
1524 m_pPageCollLB->SelectEntry( sPageDesc );
1525 m_pPageCollCB->Check();
1526
1527 m_pPgBrkCB->Enable();
1528 m_pPgBrkRB->Enable();
1529 m_pColBrkRB->Enable();
1530 m_pPgBrkBeforeRB->Enable();
1531 m_pPgBrkAfterRB->Enable();
1532 m_pPageCollCB->Enable();
1533 m_pPgBrkCB->Check();
1534
1535 m_pPgBrkCB->Check( sal_True );
1536 m_pColBrkRB->Check( sal_False );
1537 m_pPgBrkBeforeRB->Check( sal_True );
1538 m_pPgBrkAfterRB->Check( sal_False );
1539 }
1540 else
1541 {
1542 m_pPageCollLB->SetNoSelection();
1543 m_pPageCollCB->Check(sal_False);
1544 }
1545 }
1546
1547 if(SFX_ITEM_SET == rSet.GetItemState( RES_BREAK, sal_False, &pItem ))
1548 {
1549 const SvxFmtBreakItem* pPageBreak = (const SvxFmtBreakItem*)pItem;
1550 SvxBreak eBreak = (SvxBreak)pPageBreak->GetValue();
1551
1552 if ( eBreak != SVX_BREAK_NONE )
1553 {
1554 m_pPgBrkCB->Check();
1555 m_pPageCollCB->Enable(sal_False);
1556 m_pPageCollLB->Enable(sal_False);
1557 m_pPageNoFT->Enable(sal_False);
1558 m_pPageNoNF->Enable(sal_False);
1559 }
1560 switch ( eBreak )
1561 {
1562 case SVX_BREAK_PAGE_BEFORE:
1563 m_pPgBrkRB->Check( sal_True );
1564 m_pColBrkRB->Check( sal_False );
1565 m_pPgBrkBeforeRB->Check( sal_True );
1566 m_pPgBrkAfterRB->Check( sal_False );
1567 break;
1568 case SVX_BREAK_PAGE_AFTER:
1569 m_pPgBrkRB->Check( sal_True );
1570 m_pColBrkRB->Check( sal_False );
1571 m_pPgBrkBeforeRB->Check( sal_False );
1572 m_pPgBrkAfterRB->Check( sal_True );
1573 break;
1574 case SVX_BREAK_COLUMN_BEFORE:
1575 m_pPgBrkRB->Check( sal_False );
1576 m_pColBrkRB->Check( sal_True );
1577 m_pPgBrkBeforeRB->Check( sal_True );
1578 m_pPgBrkAfterRB->Check( sal_False );
1579 break;
1580 case SVX_BREAK_COLUMN_AFTER:
1581 m_pPgBrkRB->Check( sal_False );
1582 m_pColBrkRB->Check( sal_True );
1583 m_pPgBrkBeforeRB->Check( sal_False );
1584 m_pPgBrkAfterRB->Check( sal_True );
1585 break;
1586 default:; //prevent warning
1587 }
1588
1589 }
1590 if ( m_pPgBrkBeforeRB->IsChecked() )
1591 PageBreakPosHdl_Impl(m_pPgBrkBeforeRB);
1592 else if ( m_pPgBrkAfterRB->IsChecked() )
1593 PageBreakPosHdl_Impl(m_pPgBrkAfterRB);
1594 PageBreakHdl_Impl( m_pPgBrkCB );
1595 }
1596 }
1597 else
1598 {
1599 m_pPgBrkRB->Enable(sal_False);
1600 m_pColBrkRB->Enable(sal_False);
1601 m_pPgBrkBeforeRB->Enable(sal_False);
1602 m_pPgBrkAfterRB->Enable(sal_False);
1603 m_pKeepCB->Enable(sal_False);
1604 m_pSplitCB->Enable(sal_False);
1605 m_pPgBrkCB->Enable(sal_False);
1606 m_pPageCollCB->Enable(sal_False);
1607 m_pPageCollLB->Enable(sal_False);
1608 }
1609
1610 if(SFX_ITEM_SET == rSet.GetItemState( FN_PARAM_TABLE_HEADLINE, sal_False, &pItem ))
1611 {
1612 sal_uInt16 nRep = ((const SfxUInt16Item*)pItem)->GetValue();
1613 m_pHeadLineCB->Check( nRep > 0 );
1614 m_pHeadLineCB->SaveValue();
1615 m_pRepeatHeaderNF->SetValue( nRep );
1616 m_pRepeatHeaderNF->SaveValue();
1617 }
1618 if ( rSet.GetItemState(FN_TABLE_BOX_TEXTORIENTATION) > SFX_ITEM_AVAILABLE )
1619 {
1620 sal_uLong nDirection = ((const SvxFrameDirectionItem&)rSet.Get(FN_TABLE_BOX_TEXTORIENTATION)).GetValue();
1621 m_pTextDirectionLB->SelectEntryPos(m_pTextDirectionLB->GetEntryPos( (const void*)nDirection ));
1622 }
1623
1624 if ( rSet.GetItemState(FN_TABLE_SET_VERT_ALIGN) > SFX_ITEM_AVAILABLE )
1625 {
1626 sal_uInt16 nVert = ((const SfxUInt16Item&)rSet.Get(FN_TABLE_SET_VERT_ALIGN)).GetValue();
1627 sal_uInt16 nPos = 0;
1628 switch(nVert)
1629 {
1630 case text::VertOrientation::NONE: nPos = 0; break;
1631 case text::VertOrientation::CENTER: nPos = 1; break;
1632 case text::VertOrientation::BOTTOM: nPos = 2; break;
1633 }
1634 m_pVertOrientLB->SelectEntryPos(nPos);
1635 }
1636
1637 m_pPageCollCB->SaveValue();
1638 m_pPageCollLB->SaveValue();
1639 m_pPgBrkCB->SaveValue();
1640 m_pPgBrkRB->SaveValue();
1641 m_pColBrkRB->SaveValue();
1642 m_pPgBrkBeforeRB->SaveValue();
1643 m_pPgBrkAfterRB->SaveValue();
1644 m_pPageNoNF->SaveValue();
1645 m_pTextDirectionLB->SaveValue();
1646 m_pVertOrientLB->SaveValue();
1647
1648 HeadLineCBClickHdl();
1649 }
1650
1651 void SwTextFlowPage::SetShell(SwWrtShell* pSh)
1652 {
1653 pShell = pSh;
1654 bHtmlMode = 0 != (::GetHtmlMode(pShell->GetView().GetDocShell()) & HTMLMODE_ON);
1655 if(bHtmlMode)
1656 {
1657 m_pPageNoNF->Enable(sal_False);
1658 m_pPageNoFT->Enable(sal_False);
1659 }
1660 }
1661
1662 IMPL_LINK_NOARG(SwTextFlowPage, PageBreakHdl_Impl)
1663 {
1664 if( m_pPgBrkCB->IsChecked() )
1665 {
1666 m_pPgBrkRB-> Enable();
1667 m_pColBrkRB-> Enable();
1668 m_pPgBrkBeforeRB-> Enable();
1669 m_pPgBrkAfterRB-> Enable();
1670
1671 if ( m_pPgBrkRB->IsChecked() && m_pPgBrkBeforeRB->IsChecked() )
1672 {
1673 m_pPageCollCB->Enable();
1674
1675 sal_Bool bEnable = m_pPageCollCB->IsChecked() &&
1676 m_pPageCollLB->GetEntryCount();
1677 m_pPageCollLB->Enable(bEnable);
1678 if(!bHtmlMode)
1679 {
1680 m_pPageNoFT->Enable(bEnable);
1681 m_pPageNoNF->Enable(bEnable);
1682 }
1683 }
1684 }
1685 else
1686 {
1687 m_pPageCollCB->Check( sal_False );
1688 m_pPageCollCB->Enable(sal_False);
1689 m_pPageCollLB->Enable(sal_False);
1690 m_pPageNoFT->Enable(sal_False);
1691 m_pPageNoNF->Enable(sal_False);
1692 m_pPgBrkRB-> Enable(sal_False);
1693 m_pColBrkRB-> Enable(sal_False);
1694 m_pPgBrkBeforeRB-> Enable(sal_False);
1695 m_pPgBrkAfterRB-> Enable(sal_False);
1696 }
1697 return 0;
1698 }
1699
1700 IMPL_LINK_NOARG(SwTextFlowPage, ApplyCollClickHdl_Impl)
1701 {
1702 sal_Bool bEnable = sal_False;
1703 if ( m_pPageCollCB->IsChecked() &&
1704 m_pPageCollLB->GetEntryCount() )
1705 {
1706 bEnable = sal_True;
1707 m_pPageCollLB->SelectEntryPos( 0 );
1708 }
1709 else
1710 {
1711 m_pPageCollLB->SetNoSelection();
1712 }
1713 m_pPageCollLB->Enable(bEnable);
1714 if(!bHtmlMode)
1715 {
1716 m_pPageNoFT->Enable(bEnable);
1717 m_pPageNoNF->Enable(bEnable);
1718 }
1719 return 0;
1720 }
1721
1722 IMPL_LINK( SwTextFlowPage, PageBreakPosHdl_Impl, RadioButton*, pBtn )
1723 {
1724 if ( m_pPgBrkCB->IsChecked() )
1725 {
1726 if ( pBtn == m_pPgBrkBeforeRB && m_pPgBrkRB->IsChecked() )
1727 {
1728 m_pPageCollCB->Enable();
1729
1730 sal_Bool bEnable = m_pPageCollCB->IsChecked() &&
1731 m_pPageCollLB->GetEntryCount();
1732
1733 m_pPageCollLB->Enable(bEnable);
1734 if(!bHtmlMode)
1735 {
1736 m_pPageNoFT->Enable(bEnable);
1737 m_pPageNoNF->Enable(bEnable);
1738 }
1739 }
1740 else if (pBtn == m_pPgBrkAfterRB)
1741 {
1742 m_pPageCollCB->Check( sal_False );
1743 m_pPageCollCB->Enable(sal_False);
1744 m_pPageCollLB->Enable(sal_False);
1745 m_pPageNoFT->Enable(sal_False);
1746 m_pPageNoNF->Enable(sal_False);
1747 }
1748 }
1749 return 0;
1750 }
1751
1752 IMPL_LINK( SwTextFlowPage, PageBreakTypeHdl_Impl, RadioButton*, pBtn )
1753 {
1754 if ( pBtn == m_pColBrkRB || m_pPgBrkAfterRB->IsChecked() )
1755 {
1756 m_pPageCollCB->Check(sal_False);
1757 m_pPageCollCB->Enable(sal_False);
1758 m_pPageCollLB->Enable(sal_False);
1759 m_pPageNoFT->Enable(sal_False);
1760 m_pPageNoNF->Enable(sal_False);
1761 }
1762 else if ( m_pPgBrkBeforeRB->IsChecked() )
1763 PageBreakPosHdl_Impl(m_pPgBrkBeforeRB);
1764 return 0;
1765 }
1766
1767 IMPL_LINK( SwTextFlowPage, SplitHdl_Impl, CheckBox*, pBox )
1768 {
1769 m_pSplitRowCB->Enable(pBox->IsChecked());
1770 return 0;
1771 }
1772
1773 IMPL_LINK( SwTextFlowPage, SplitRowHdl_Impl, TriStateBox*, pBox )
1774 {
1775 pBox->EnableTriState(sal_False);
1776 return 0;
1777 }
1778
1779 IMPL_LINK_NOARG(SwTextFlowPage, HeadLineCBClickHdl)
1780 {
1781 m_pRepeatHeaderCombo->Enable(m_pHeadLineCB->IsChecked());
1782
1783 return 0;
1784 }
1785
1786 void SwTextFlowPage::DisablePageBreak()
1787 {
1788 bPageBreak = sal_False;
1789 m_pPgBrkCB->Disable();
1790 m_pPgBrkRB->Disable();
1791 m_pColBrkRB->Disable();
1792 m_pPgBrkBeforeRB->Disable();
1793 m_pPgBrkAfterRB->Disable();
1794 m_pPageCollCB->Disable();
1795 m_pPageCollLB->Disable();
1796 m_pPageNoFT->Disable();
1797 m_pPageNoNF->Disable();
1798 }
1799
1800
1801
1802 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE