LibreOffice Module sw (master)  1
tabledlg.cxx
Go to the documentation of this file.
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 <vcl/svapp.hxx>
22 #include <vcl/weld.hxx>
23 #include <svl/stritem.hxx>
24 #include <svl/intitem.hxx>
25 #include <editeng/keepitem.hxx>
27 #include <editeng/ulspitem.hxx>
28 #include <editeng/frmdiritem.hxx>
29 #include <svl/ctloptions.hxx>
30 #include <swmodule.hxx>
31 #include <fmtpdsc.hxx>
32 #include <fmtlsplt.hxx>
33 
34 #include <svtools/htmlcfg.hxx>
35 #include <fmtrowsplt.hxx>
36 #include <sfx2/htmlmode.hxx>
37 #include <sfx2/sfxdlg.hxx>
38 
39 #include <strings.hrc>
40 #include <svx/strings.hrc>
41 #include <svx/dialmgr.hxx>
42 
43 #include <wrtsh.hxx>
44 #include <view.hxx>
45 #include <viewopt.hxx>
46 #include <uitool.hxx>
47 #include <tabledlg.hxx>
48 #include "../../uibase/table/tablepg.hxx"
49 #include <tablemgr.hxx>
50 #include <pagedesc.hxx>
51 #include <uiitems.hxx>
52 #include <poolfmt.hxx>
53 #include <swtablerep.hxx>
54 #include <SwStyleNameMapper.hxx>
55 
56 #include <cmdid.h>
57 #include <svx/dialogs.hrc>
58 #include <svx/flagsdef.hxx>
59 #include <osl/diagnose.h>
60 
61 #include <com/sun/star/text/HoriOrientation.hpp>
62 #include <com/sun/star/text/VertOrientation.hpp>
63 
64 using namespace ::com::sun::star;
65 
67  : SfxTabPage(pPage, pController, "modules/swriter/ui/formattablepage.ui", "FormatTablePage", &rSet)
68  , pTableData(nullptr)
69  , nSaveWidth(0)
70  , nMinTableWidth(MINLAY)
71  , bModified(false)
72  , bFull(false)
73  , bHtmlMode(false)
74  , m_xNameED(m_xBuilder->weld_entry("name"))
75  , m_xWidthFT(m_xBuilder->weld_label("widthft"))
76  , m_xWidthMF(new SwPercentField(m_xBuilder->weld_metric_spin_button("widthmf", FieldUnit::CM)))
77  , m_xRelWidthCB(m_xBuilder->weld_check_button("relwidth"))
78  , m_xFullBtn(m_xBuilder->weld_radio_button("full"))
79  , m_xLeftBtn(m_xBuilder->weld_radio_button("left"))
80  , m_xFromLeftBtn(m_xBuilder->weld_radio_button("fromleft"))
81  , m_xRightBtn(m_xBuilder->weld_radio_button("right"))
82  , m_xCenterBtn(m_xBuilder->weld_radio_button("center"))
83  , m_xFreeBtn(m_xBuilder->weld_radio_button("free"))
84  , m_xLeftFT(m_xBuilder->weld_label("leftft"))
85  , m_xLeftMF(new SwPercentField(m_xBuilder->weld_metric_spin_button("leftmf", FieldUnit::CM)))
86  , m_xRightFT(m_xBuilder->weld_label("rightft"))
87  , m_xRightMF(new SwPercentField(m_xBuilder->weld_metric_spin_button("rightmf", FieldUnit::CM)))
88  , m_xTopFT(m_xBuilder->weld_label("aboveft"))
89  , m_xTopMF(m_xBuilder->weld_metric_spin_button("abovemf", FieldUnit::CM))
90  , m_xBottomFT(m_xBuilder->weld_label("belowft"))
91  , m_xBottomMF(m_xBuilder->weld_metric_spin_button("belowmf", FieldUnit::CM))
92  , m_xTextDirectionLB(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("textdirection")))
93  , m_xProperties(m_xBuilder->weld_widget("properties"))
94 {
95  m_xWidthMF->GetMetricFieldRange(m_nOrigWidthMin, m_nOrigWidthMax);
96  m_xLeftMF->GetMetricFieldRange(m_nOrigLeftMin, m_nOrigLeftMax);
97  m_xRightMF->GetMetricFieldRange(m_nOrigRightMin, m_nOrigRightMax);
98 
99  //lock these to initial sizes so they don't change on percent to non percent change
100  Size aPrefSize(m_xLeftMF->get()->get_preferred_size());
101  m_xLeftMF->get()->set_size_request(aPrefSize.Width(), aPrefSize.Height());
102  m_xRightMF->get()->set_size_request(aPrefSize.Width(), aPrefSize.Height());
103  m_xWidthMF->get()->set_size_request(aPrefSize.Width(), aPrefSize.Height());
104 
105  m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTR));
106  m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTL));
107  m_xTextDirectionLB->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPER));
108 
110 
111  const SfxPoolItem* pItem;
112  if(SfxItemState::SET == rSet.GetItemState(SID_HTML_MODE, false, &pItem))
113  bHtmlMode = 0 != (static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON);
114 
115  bool bCTL = SW_MOD()->GetCTLOptions().IsCTLFontEnabled();
116  m_xProperties->set_visible(!bHtmlMode && bCTL);
117 
118  Init();
119 }
120 
122 {
123 }
124 
126 {
127  m_xLeftMF->SetMetricFieldMin(-999999);
128  m_xRightMF->SetMetricFieldMin(-999999);
129 
130  //handler
131  Link<weld::Toggleable&,void> aLk2 = LINK( this, SwFormatTablePage, AutoClickHdl );
132  m_xFullBtn->connect_toggled( aLk2 );
133  m_xFreeBtn->connect_toggled( aLk2 );
134  m_xLeftBtn->connect_toggled( aLk2 );
135  m_xFromLeftBtn->connect_toggled( aLk2 );
136  m_xRightBtn->connect_toggled( aLk2 );
137  m_xCenterBtn->connect_toggled( aLk2 );
138 
139  Link<weld::MetricSpinButton&,void> aLk = LINK(this, SwFormatTablePage, ValueChangedHdl);
140  m_xTopMF->connect_value_changed(aLk);
141  m_xBottomMF->connect_value_changed(aLk);
142  m_xRightMF->connect_value_changed(aLk);
143  m_xLeftMF->connect_value_changed(aLk);
144  m_xWidthMF->connect_value_changed(aLk);
145 
146  m_xRelWidthCB->connect_toggled(LINK( this, SwFormatTablePage, RelWidthClickHdl ));
147 }
148 
149 IMPL_LINK( SwFormatTablePage, RelWidthClickHdl, weld::Toggleable&, rBtn, void )
150 {
151  OSL_ENSURE(pTableData, "table data not available?");
152  bool bIsChecked = rBtn.get_active();
153  sal_Int64 nLeft = m_xLeftMF->DenormalizePercent(m_xLeftMF->get_value(FieldUnit::TWIP));
154  sal_Int64 nRight = m_xRightMF->DenormalizePercent(m_xRightMF->get_value(FieldUnit::TWIP));
155  m_xWidthMF->ShowPercent(bIsChecked);
156  m_xLeftMF->ShowPercent(bIsChecked);
157  m_xRightMF->ShowPercent(bIsChecked);
158 
159  if (bIsChecked)
160  {
161  m_xWidthMF->SetRefValue(pTableData->GetSpace());
162  m_xLeftMF->SetRefValue(pTableData->GetSpace());
163  m_xRightMF->SetRefValue(pTableData->GetSpace());
164  m_xLeftMF->SetMetricFieldMin(0); //will be overwritten by the Percentfield
165  m_xRightMF->SetMetricFieldMin(0); //ditto
166  m_xLeftMF->SetMetricFieldMax(99);
167  m_xRightMF->SetMetricFieldMax(99);
168  m_xLeftMF->set_value(m_xLeftMF->NormalizePercent(nLeft ), FieldUnit::TWIP );
169  m_xRightMF->set_value(m_xRightMF->NormalizePercent(nRight ), FieldUnit::TWIP );
170  }
171  else
172  ModifyHdl(*m_xLeftMF->get()); //correct values again
173 
174  if (m_xFreeBtn->get_active())
175  {
176  bool bEnable = !rBtn.get_active();
177  m_xRightMF->set_sensitive(bEnable);
178  m_xRightFT->set_sensitive(bEnable);
179  }
180  bModified = true;
181 }
182 
184 {
185  bool bRestore = true,
186  bLeftEnable = false,
187  bRightEnable= false,
188  bWidthEnable= false,
189  bOthers = true;
190  if (m_xFullBtn->get_active())
191  {
192  m_xLeftMF->set_value(0);
193  m_xRightMF->set_value(0);
194  nSaveWidth = static_cast<SwTwips>(m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)));
195  m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(pTableData->GetSpace()), FieldUnit::TWIP);
196  bFull = true;
197  bRestore = false;
198  }
199  else if (m_xLeftBtn->get_active())
200  {
201  bRightEnable = bWidthEnable = true;
202  m_xLeftMF->set_value(0);
203  }
204  else if (m_xFromLeftBtn->get_active())
205  {
206  bLeftEnable = bWidthEnable = true;
207  m_xRightMF->set_value(0);
208  }
209  else if (m_xRightBtn->get_active())
210  {
211  bLeftEnable = bWidthEnable = true;
212  m_xRightMF->set_value(0);
213  }
214  else if (m_xCenterBtn->get_active())
215  {
216  bLeftEnable = bWidthEnable = true;
217  }
218  else if (m_xFreeBtn->get_active())
219  {
220  RightModify();
221  bLeftEnable = true;
222  bWidthEnable = true;
223  bOthers = false;
224  }
225  m_xLeftMF->set_sensitive(bLeftEnable);
226  m_xLeftFT->set_sensitive(bLeftEnable);
227  m_xWidthMF->set_sensitive(bWidthEnable);
228  m_xWidthFT->set_sensitive(bWidthEnable);
229  if ( bOthers )
230  {
231  m_xRightMF->set_sensitive(bRightEnable);
232  m_xRightFT->set_sensitive(bRightEnable);
233  m_xRelWidthCB->set_sensitive(bWidthEnable);
234  }
235 
236  if(bFull && bRestore)
237  {
238  //After being switched on automatic, the width was pinned
239  //in order to restore the width while switching back to.
240  bFull = false;
241  m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(nSaveWidth ), FieldUnit::TWIP );
242  }
243  ModifyHdl(*m_xWidthMF->get());
244  bModified = true;
245 }
246 
248 {
249  if (!m_xFreeBtn->get_active())
250  return;
251 
252  bool bEnable = m_xRightMF->get_value() == 0;
253  m_xRelWidthCB->set_sensitive(bEnable);
254  if ( !bEnable )
255  {
256  m_xRelWidthCB->set_active(false);
257  RelWidthClickHdl(*m_xRelWidthCB);
258  }
259  bEnable = m_xRelWidthCB->get_active();
260  m_xRightMF->set_sensitive(!bEnable);
261  m_xRightFT->set_sensitive(!bEnable);
262 }
263 
264 IMPL_LINK( SwFormatTablePage, ValueChangedHdl, weld::MetricSpinButton&, rEdit, void )
265 {
266  if (m_xRightMF->get() == &rEdit)
267  RightModify();
268  ModifyHdl(rEdit);
269 }
270 
271 void SwFormatTablePage::ModifyHdl(const weld::MetricSpinButton& rEdit, bool bAllowInconsistencies)
272 {
273  SwTwips nCurWidth = static_cast< SwTwips >(m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)));
274  SwTwips nPrevWidth = nCurWidth;
275  SwTwips nRight = static_cast< SwTwips >(m_xRightMF->DenormalizePercent(m_xRightMF->get_value(FieldUnit::TWIP)));
276  SwTwips nLeft = static_cast< SwTwips >(m_xLeftMF->DenormalizePercent(m_xLeftMF->get_value(FieldUnit::TWIP)));
277  SwTwips nDiff;
278 
279  if (&rEdit == m_xWidthMF->get())
280  {
281  if( nCurWidth < MINLAY )
282  nCurWidth = MINLAY;
283  nDiff = nRight + nLeft + nCurWidth - pTableData->GetSpace() ;
284  //right aligned: only change the left margin
285  if (m_xRightBtn->get_active())
286  nLeft -= nDiff;
287  //left aligned: only change the right margin
288  else if(m_xLeftBtn->get_active())
289  nRight -= nDiff;
290  //left margin and width allowed - first right - then left
291  else if (m_xFromLeftBtn->get_active())
292  {
293  if( nRight >= nDiff )
294  nRight -= nDiff;
295  else
296  {
297  nDiff -= nRight;
298  nRight = 0;
299  if(nLeft >= nDiff)
300  nLeft -= nDiff;
301  else
302  {
303  nRight += nLeft - nDiff;
304  nLeft = 0;
305  nCurWidth = pTableData->GetSpace();
306  }
307  }
308  }
309  //centered: change both sides equally
310  else if (m_xCenterBtn->get_active())
311  {
312  if(nLeft != nRight)
313  {
314  nDiff += nLeft + nRight;
315  nLeft = nDiff/2;
316  nRight = nDiff/2;
317  }
318  else
319  {
320  nLeft -= nDiff/2;
321  nRight -= nDiff/2;
322  }
323  }
324  //free alignment: decrease both margins
325  else if (m_xFreeBtn->get_active())
326  {
327  nLeft -= nDiff/2;
328  nRight -= nDiff/2;
329  }
330  }
331  if (&rEdit == m_xRightMF->get())
332  {
333 
334  if( nRight + nLeft > pTableData->GetSpace() - MINLAY )
335  nRight = pTableData->GetSpace() -nLeft - MINLAY;
336 
337  nCurWidth = pTableData->GetSpace() - nLeft - nRight;
338  }
339  if (&rEdit == m_xLeftMF->get())
340  {
341  if(!m_xFromLeftBtn->get_active())
342  {
343  bool bCenter = m_xCenterBtn->get_active();
344  if( bCenter )
345  nRight = nLeft;
346  if(nRight + nLeft > pTableData->GetSpace() - MINLAY )
347  {
348  nLeft = bCenter ? (pTableData->GetSpace() - MINLAY) /2 :
349  (pTableData->GetSpace() - MINLAY) - nRight;
350  nRight = bCenter ? (pTableData->GetSpace() - MINLAY) /2 : nRight;
351  }
352  nCurWidth = pTableData->GetSpace() - nLeft - nRight;
353  }
354  else
355  {
356  //Upon changes on the left side the right margin will be changed at first,
357  //thereafter the width.
358  nDiff = nRight + nLeft + nCurWidth - pTableData->GetSpace() ;
359 
360  nRight -= nDiff;
361  nCurWidth = pTableData->GetSpace() - nLeft - nRight;
362  }
363  }
364 
365  m_xRightMF->set_value( m_xRightMF->NormalizePercent( nRight ), FieldUnit::TWIP );
366  m_xLeftMF->set_value( m_xLeftMF->NormalizePercent( nLeft ), FieldUnit::TWIP );
367 
368  if (nCurWidth != nPrevWidth )
369  {
370  m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(nCurWidth), FieldUnit::TWIP);
371 
372  // tdf#135021 if the user changed the width spinbutton, and in this
373  // ModifyHdl we changed the value of that width spinbutton, then rerun
374  // the ModifyHdl on the replaced value so the left/right/width value
375  // relationships are consistent.
376  // But (tdf#135693) only make one effort of rectifying the inconsistency
377  if (&rEdit == m_xWidthMF->get() && !bAllowInconsistencies)
378  ModifyHdl(rEdit, true);
379  }
380 
381  bModified = true;
382 }
383 
384 std::unique_ptr<SfxTabPage> SwFormatTablePage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet)
385 {
386  return std::make_unique<SwFormatTablePage>(pPage, pController, *rAttrSet);
387 }
388 
390 {
391  //Test if one of the controls still has the focus
392  if (m_xWidthMF->has_focus())
393  ModifyHdl(*m_xWidthMF->get());
394  else if (m_xLeftMF->has_focus())
395  ModifyHdl(*m_xLeftMF->get());
396  else if (m_xRightMF->has_focus())
397  ModifyHdl(*m_xRightMF->get());
398  else if (m_xTopMF->has_focus())
400  else if (m_xBottomMF->has_focus())
402 
403  if (bModified)
404  {
405  if (m_xBottomMF->get_value_changed_from_saved() ||
406  m_xTopMF->get_value_changed_from_saved() )
407  {
408  SvxULSpaceItem aULSpace(RES_UL_SPACE);
409  aULSpace.SetUpper(m_xTopMF->denormalize(m_xTopMF->get_value(FieldUnit::TWIP)));
410  aULSpace.SetLower(m_xBottomMF->denormalize(m_xBottomMF->get_value(FieldUnit::TWIP)));
411  rCoreSet->Put(aULSpace);
412  }
413 
414  }
415  if (m_xNameED->get_value_changed_from_saved())
416  {
417  rCoreSet->Put(SfxStringItem(FN_PARAM_TABLE_NAME, m_xNameED->get_text()));
418  bModified = true;
419  }
420 
421  if (m_xTextDirectionLB->get_visible())
422  {
423  if (m_xTextDirectionLB->get_value_changed_from_saved())
424  {
425  SvxFrameDirection nDirection = m_xTextDirectionLB->get_active_id();
426  rCoreSet->Put(SvxFrameDirectionItem(nDirection, RES_FRAMEDIR));
427  bModified = true;
428  }
429  }
430 
431  return bModified;
432 }
433 
435 {
436  const SfxItemSet& rSet = GetItemSet();
437  const SfxPoolItem* pItem;
438 
439  if(bHtmlMode)
440  {
441  m_xNameED->set_sensitive(false);
442  m_xTopFT->hide();
443  m_xTopMF->hide();
444  m_xBottomFT->hide();
445  m_xBottomMF->hide();
446  m_xFreeBtn->set_sensitive(false);
447  }
448 
449  // set back to original state
450  m_xRelWidthCB->set_active(false);
451  m_xWidthMF->ShowPercent(false);
452  m_xLeftMF->ShowPercent(false);
453  m_xRightMF->ShowPercent(false);
454  m_xWidthMF->SetMetricFieldRange(m_nOrigWidthMin, m_nOrigWidthMax);
455  m_xLeftMF->SetMetricFieldRange(m_nOrigLeftMin, m_nOrigLeftMax);
456  m_xRightMF->SetMetricFieldRange(m_nOrigRightMin, m_nOrigRightMax);
457 
459  m_xWidthMF->SetMetric(aMetric);
460  m_xRightMF->SetMetric(aMetric);
461  m_xLeftMF->SetMetric(aMetric);
462  SetFieldUnit(*m_xTopMF, aMetric);
463  SetFieldUnit(*m_xBottomMF, aMetric);
464 
465  //Name
466  if(SfxItemState::SET == rSet.GetItemState( FN_PARAM_TABLE_NAME, false, &pItem ))
467  {
468  m_xNameED->set_text(static_cast<const SfxStringItem*>(pItem)->GetValue());
469  m_xNameED->save_value();
470  }
471 
472  if(SfxItemState::SET == rSet.GetItemState( FN_TABLE_REP, false, &pItem ))
473  {
474  pTableData = static_cast<SwTableRep*>(static_cast<const SwPtrItem*>( pItem)->GetValue());
475  if (!m_xOrigTableData)
477  else // tdf#134925 and tdf#134913, reset back to the original data seen on dialog creation
479 
481 
483  {
484  m_xRelWidthCB->set_active(true);
485  RelWidthClickHdl(*m_xRelWidthCB);
486  m_xWidthMF->set_value(pTableData->GetWidthPercent(), FieldUnit::PERCENT);
487 
488  m_xWidthMF->save_value();
489  nSaveWidth = static_cast< SwTwips >(m_xWidthMF->get_value(FieldUnit::PERCENT));
490  }
491  else
492  {
493  m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(
494  pTableData->GetWidth()), FieldUnit::TWIP);
495  m_xWidthMF->save_value();
498  }
499 
500  m_xWidthMF->SetRefValue(pTableData->GetSpace());
501 
502  m_xLeftMF->set_value(m_xLeftMF->NormalizePercent(
503  pTableData->GetLeftSpace()), FieldUnit::TWIP);
504  m_xRightMF->set_value(m_xRightMF->NormalizePercent(
505  pTableData->GetRightSpace()), FieldUnit::TWIP);
506  m_xLeftMF->save_value();
507  m_xRightMF->save_value();
508 
509  bool bSetRight = false, bSetLeft = false;
510  switch( pTableData->GetAlign() )
511  {
513  m_xFreeBtn->set_active(true);
514  if (m_xRelWidthCB->get_active())
515  bSetRight = true;
516  break;
517  case text::HoriOrientation::FULL:
518  {
519  bSetRight = bSetLeft = true;
520  m_xFullBtn->set_active(true);
521  m_xWidthMF->set_sensitive(false);
522  m_xRelWidthCB->set_sensitive(false);
523  m_xWidthFT->set_sensitive(false);
524  }
525  break;
526  case text::HoriOrientation::LEFT:
527  {
528  bSetLeft = true;
529  m_xLeftBtn->set_active(true);
530  }
531  break;
532  case text::HoriOrientation::LEFT_AND_WIDTH :
533  {
534  bSetRight = true;
535  m_xFromLeftBtn->set_active(true);
536  }
537  break;
538  case text::HoriOrientation::RIGHT:
539  {
540  bSetRight = true;
541  m_xRightBtn->set_active(true);
542  }
543  break;
544  case text::HoriOrientation::CENTER:
545  {
546  bSetRight = true;
547  m_xCenterBtn->set_active(true);
548  }
549  break;
550  }
551  if ( bSetRight )
552  {
553  m_xRightMF->set_sensitive(false);
554  m_xRightFT->set_sensitive(false);
555  }
556  if ( bSetLeft )
557  {
558  m_xLeftMF->set_sensitive(false);
559  m_xLeftFT->set_sensitive(false);
560  }
561 
562  }
563 
564  //Margins
565  if(SfxItemState::SET == rSet.GetItemState( RES_UL_SPACE, false,&pItem ))
566  {
567  m_xTopMF->set_value(m_xTopMF->normalize(
568  static_cast<const SvxULSpaceItem*>(pItem)->GetUpper()), FieldUnit::TWIP);
569  m_xBottomMF->set_value(m_xBottomMF->normalize(
570  static_cast<const SvxULSpaceItem*>(pItem)->GetLower()), FieldUnit::TWIP);
571  m_xTopMF->save_value();
572  m_xBottomMF->save_value();
573  }
574 
575  //Text direction
576  if( SfxItemState::SET == rSet.GetItemState( RES_FRAMEDIR, true, &pItem ) )
577  {
578  SvxFrameDirection nVal = static_cast<const SvxFrameDirectionItem*>(pItem)->GetValue();
579  m_xTextDirectionLB->set_active_id(nVal);
580  m_xTextDirectionLB->save_value();
581  }
582 
583  m_xWidthMF->set_max( 2*m_xWidthMF->NormalizePercent( pTableData->GetSpace() ), FieldUnit::TWIP );
584  m_xRightMF->set_max( m_xRightMF->NormalizePercent( pTableData->GetSpace() ), FieldUnit::TWIP );
585  m_xLeftMF->set_max( m_xLeftMF->NormalizePercent( pTableData->GetSpace() ), FieldUnit::TWIP );
586  m_xWidthMF->set_min( m_xWidthMF->NormalizePercent( nMinTableWidth ), FieldUnit::TWIP );
587 }
588 
590 {
591  OSL_ENSURE(pTableData, "table data not available?");
592  if(SfxItemState::SET != rSet.GetItemState( FN_TABLE_REP ))
593  return;
594 
595  SwTwips nCurWidth = text::HoriOrientation::FULL != pTableData->GetAlign() ?
596  pTableData->GetWidth() :
597  pTableData->GetSpace();
598  if(pTableData->GetWidthPercent() != 0 ||
599  nCurWidth == m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)))
600  return;
601 
602  m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(
603  nCurWidth), FieldUnit::TWIP);
604  m_xWidthMF->save_value();
605  nSaveWidth = nCurWidth;
606  m_xLeftMF->set_value(m_xLeftMF->NormalizePercent(
607  pTableData->GetLeftSpace()), FieldUnit::TWIP);
608  m_xLeftMF->save_value();
609  m_xRightMF->set_value(m_xRightMF->NormalizePercent(
610  pTableData->GetRightSpace()), FieldUnit::TWIP);
611  m_xRightMF->save_value();
612 }
613 
615 {
616  //test the table name for spaces
617  OUString sTableName = m_xNameED->get_text();
618  if(sTableName.indexOf(' ') != -1)
619  {
620  std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
621  VclMessageType::Info, VclButtonsType::Ok,
622  SwResId(STR_WRONG_TABLENAME)));
623  xInfoBox->run();
624  m_xNameED->grab_focus();
625  return DeactivateRC::KeepPage;
626  }
627  if(_pSet)
628  {
629  FillItemSet(_pSet);
630  if(bModified)
631  {
632  SwTwips lLeft = static_cast< SwTwips >(m_xLeftMF->DenormalizePercent(m_xLeftMF->get_value(FieldUnit::TWIP)));
633  SwTwips lRight = static_cast< SwTwips >(m_xRightMF->DenormalizePercent(m_xRightMF->get_value(FieldUnit::TWIP)));
634 
635  if( m_xLeftMF->get_value_changed_from_saved() ||
636  m_xRightMF->get_value_changed_from_saved() )
637  {
639  pTableData->SetLeftSpace( lLeft);
640  pTableData->SetRightSpace( lRight);
641  }
642 
643  SwTwips lWidth;
644  if (m_xRelWidthCB->get_active() && m_xRelWidthCB->get_sensitive())
645  {
646  lWidth = pTableData->GetSpace() - lRight - lLeft;
647  const sal_uInt16 nPercentWidth = m_xWidthMF->get_value(FieldUnit::PERCENT);
648  if(pTableData->GetWidthPercent() != nPercentWidth)
649  {
650  pTableData->SetWidthPercent(nPercentWidth);
652  }
653  }
654  else
655  {
657  lWidth = static_cast<SwTwips>(m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)));
658  }
659  pTableData->SetWidth(lWidth);
660 
661  SwTwips nColSum = 0;
662 
663  for( sal_uInt16 i = 0; i < pTableData->GetColCount(); i++)
664  {
665  nColSum += pTableData->GetColumns()[i].nWidth;
666  }
667  if(nColSum != pTableData->GetWidth())
668  {
669  SwTwips nMinWidth = std::min( tools::Long(MINLAY),
670  static_cast<tools::Long>(pTableData->GetWidth() /
671  pTableData->GetColCount() - 1));
672  SwTwips nDiff = nColSum - pTableData->GetWidth();
673  while ( std::abs(nDiff) > pTableData->GetColCount() + 1 )
674  {
675  SwTwips nSub = nDiff / pTableData->GetColCount();
676  for( sal_uInt16 i = 0; i < pTableData->GetColCount(); i++)
677  {
678  if(pTableData->GetColumns()[i].nWidth - nMinWidth > nSub)
679  {
680  pTableData->GetColumns()[i].nWidth -= nSub;
681  nDiff -= nSub;
682  }
683  else
684  {
685  nDiff -= pTableData->GetColumns()[i].nWidth - nMinWidth;
686  pTableData->GetColumns()[i].nWidth = nMinWidth;
687  }
688 
689  }
690  }
691  }
692 
693  sal_Int16 nAlign = 0;
694  if (m_xRightBtn->get_active())
695  nAlign = text::HoriOrientation::RIGHT;
696  else if(m_xLeftBtn->get_active())
697  nAlign = text::HoriOrientation::LEFT;
698  else if(m_xFromLeftBtn->get_active())
699  nAlign = text::HoriOrientation::LEFT_AND_WIDTH;
700  else if(m_xCenterBtn->get_active())
701  nAlign = text::HoriOrientation::CENTER;
702  else if(m_xFreeBtn->get_active())
704  else if(m_xFullBtn->get_active())
705  {
706  nAlign = text::HoriOrientation::FULL;
707  lWidth = lAutoWidth;
708  }
709  if(nAlign != pTableData->GetAlign())
710  {
712  pTableData->SetAlign(nAlign);
713  }
714 
715  if(pTableData->GetWidth() != lWidth )
716  {
719  nAlign == text::HoriOrientation::FULL ? pTableData->GetSpace() : lWidth );
720  }
723  }
724  }
725  return DeactivateRC::LeavePage;
726 }
727 
728 //Description: Page column configuration
730  : SfxTabPage(pPage, pController, "modules/swriter/ui/tablecolumnpage.ui", "TableColumnPage", &rSet)
731  , m_pTableData(nullptr)
732  , m_pSizeHdlEvent(nullptr)
733  , m_nTableWidth(0)
734  , m_nMinWidth(MINLAY)
735  , m_nMetFields(MET_FIELDS)
736  , m_nNoOfCols(0)
737  , m_nNoOfVisibleCols(0)
738  , m_bModified(false)
739  , m_bModifyTable(false)
740  , m_bPercentMode(false)
741  , m_aFieldArr { m_xBuilder->weld_metric_spin_button("width1", FieldUnit::CM),
742  m_xBuilder->weld_metric_spin_button("width2", FieldUnit::CM),
743  m_xBuilder->weld_metric_spin_button("width3", FieldUnit::CM),
744  m_xBuilder->weld_metric_spin_button("width4", FieldUnit::CM),
745  m_xBuilder->weld_metric_spin_button("width5", FieldUnit::CM)}
746  , m_aTextArr { m_xBuilder->weld_label("1"),
747  m_xBuilder->weld_label("2"),
748  m_xBuilder->weld_label("3"),
749  m_xBuilder->weld_label("4"),
750  m_xBuilder->weld_label("5")}
751  , m_xModifyTableCB(m_xBuilder->weld_check_button("adaptwidth"))
752  , m_xProportionalCB(m_xBuilder->weld_check_button("adaptcolumns"))
753  , m_xSpaceFT(m_xBuilder->weld_label("spaceft"))
754  , m_xSpaceSFT(m_xBuilder->weld_label("space"))
755  , m_xSpaceED(m_xBuilder->weld_metric_spin_button("spacefmt", FieldUnit::CM))
756  , m_xUpBtn(m_xBuilder->weld_button("next"))
757  , m_xDownBtn(m_xBuilder->weld_button("back"))
758 {
759  SetExchangeSupport();
760 
761  // fire off this handler to happen on next event loop when all the rest of
762  // the pages are instantiated and the dialog preferred size is that of the
763  // all the pages that currently exist and the rest to come after this one
764  m_pSizeHdlEvent = Application::PostUserEvent(LINK(this, SwTableColumnPage, SizeHdl));
765 
766  const SfxPoolItem* pItem;
767  Init(SfxItemState::SET == GetItemSet().GetItemState(SID_HTML_MODE, false, &pItem)
768  && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON);
769 }
770 
771 IMPL_LINK_NOARG(SwTableColumnPage, SizeHdl, void*, void)
772 {
773  m_pSizeHdlEvent = nullptr;
774 
775  //tdf#120420 keeping showing column width fields unless
776  //the dialog begins to grow, then stop adding them
777  weld::Window* pTopLevel = GetFrameWeld();
778  Size aOrigSize = pTopLevel->get_preferred_size();
779  for (sal_uInt16 i = 0; i < MET_FIELDS; ++i)
780  {
781  m_aFieldArr[i].show();
782  m_aTextArr[i]->show();
783 
784  if (pTopLevel->get_preferred_size().Width() > aOrigSize.Width())
785  {
786  m_nMetFields = i + 1;
787  m_aTextArr[i]->set_grid_width(1);
788  m_xUpBtn->set_grid_left_attach(m_nMetFields * 2 - 1);
789  break;
790  }
791  }
792 }
793 
795 {
796  if (m_pSizeHdlEvent)
797  {
799  m_pSizeHdlEvent = nullptr;
800  }
801 }
802 
803 std::unique_ptr<SfxTabPage> SwTableColumnPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet)
804 {
805  return std::make_unique<SwTableColumnPage>(pPage, pController, *rAttrSet);
806 }
807 
809 {
810  const SfxItemSet& rSet = GetItemSet();
811 
812  const SfxPoolItem* pItem;
813  if(SfxItemState::SET == rSet.GetItemState( FN_TABLE_REP, false, &pItem ))
814  {
815  m_pTableData = static_cast<SwTableRep*>(static_cast<const SwPtrItem*>( pItem)->GetValue());
816  if (!m_xOrigTableData)
818  else // tdf#134925 and tdf#134913, reset back to the original data seen on dialog creation
820 
823  m_nTableWidth = m_pTableData->GetAlign() != text::HoriOrientation::FULL &&
824  m_pTableData->GetAlign() != text::HoriOrientation::LEFT_AND_WIDTH?
826 
827  for( sal_uInt16 i = 0; i < m_nNoOfCols; i++ )
828  {
831  }
832  sal_Int64 nMinTwips = m_aFieldArr[0].NormalizePercent( m_nMinWidth );
833  sal_Int64 nMaxTwips = m_aFieldArr[0].NormalizePercent( m_nTableWidth );
834  for( sal_uInt16 i = 0; (i < m_nMetFields) && (i < m_nNoOfVisibleCols); i++ )
835  {
836  m_aFieldArr[i].set_value( m_aFieldArr[i].NormalizePercent(
837  GetVisibleWidth(i) ), FieldUnit::TWIP );
838  m_aFieldArr[i].set_min(nMinTwips, FieldUnit::TWIP);
839  m_aFieldArr[i].set_max(nMaxTwips, FieldUnit::TWIP);
840  m_aFieldArr[i].set_sensitive(true);
841  m_aTextArr[i]->set_sensitive(true);
842  }
843 
845  {
846  m_xUpBtn->set_sensitive(true);
847  }
848 
849  for( sal_uInt16 i = m_nNoOfVisibleCols; i < m_nMetFields; ++i )
850  {
851  m_aFieldArr[i].set_text(OUString());
852  m_aTextArr[i]->set_sensitive(false);
853  }
854  }
855  ActivatePage(rSet);
856 }
857 
858 void SwTableColumnPage::Init(bool bWeb)
859 {
860  FieldUnit aMetric = ::GetDfltMetric(bWeb);
861  Link<weld::MetricSpinButton&,void> aLk = LINK(this, SwTableColumnPage, ValueChangedHdl);
862  for (sal_uInt16 i = 0; i < MET_FIELDS; ++i)
863  {
864  m_aValueTable[i] = i;
865  m_aFieldArr[i].SetMetric(aMetric);
867  }
868  SetFieldUnit(*m_xSpaceED, aMetric);
869 
870  Link<weld::Button&,void> aClickLk = LINK(this, SwTableColumnPage, AutoClickHdl);
871  m_xUpBtn->connect_clicked(aClickLk);
872  m_xDownBtn->connect_clicked(aClickLk);
873 
874  Link<weld::Toggleable&,void> aToggleLk = LINK(this, SwTableColumnPage, ModeHdl);
875  m_xModifyTableCB->connect_toggled(aToggleLk);
876  m_xProportionalCB->connect_toggled(aToggleLk);
877 }
878 
879 IMPL_LINK(SwTableColumnPage, AutoClickHdl, weld::Button&, rControl, void)
880 {
881  //move display window
882  if (&rControl == m_xDownBtn.get())
883  {
884  if(m_aValueTable[0] > 0)
885  {
886  for(sal_uInt16 & rn : m_aValueTable)
887  rn -= 1;
888  }
889  }
890  if (&rControl == m_xUpBtn.get())
891  {
892  if( m_aValueTable[ m_nMetFields -1 ] < m_nNoOfVisibleCols -1 )
893  {
894  for(sal_uInt16 & rn : m_aValueTable)
895  rn += 1;
896  }
897  }
898  for( sal_uInt16 i = 0; (i < m_nNoOfVisibleCols ) && ( i < m_nMetFields); i++ )
899  {
900  OUString sEntry('~');
901  OUString sIndex = OUString::number( m_aValueTable[i] + 1 );
902  sEntry += sIndex;
903  m_aTextArr[i]->set_label(sEntry);
904  }
905 
906  m_xDownBtn->set_sensitive(m_aValueTable[0] > 0);
907  m_xUpBtn->set_sensitive(m_aValueTable[ m_nMetFields -1 ] < m_nNoOfVisibleCols -1 );
908  UpdateCols(0);
909 }
910 
911 IMPL_LINK(SwTableColumnPage, ValueChangedHdl, weld::MetricSpinButton&, rEdit, void)
912 {
913  m_bModified = true;
914  ModifyHdl(&rEdit);
915 }
916 
918 {
919  const bool bCheck = rBox.get_active();
920  if (&rBox == m_xProportionalCB.get())
921  {
922  if (bCheck)
923  m_xModifyTableCB->set_active(true);
924  m_xModifyTableCB->set_sensitive(!bCheck && m_bModifyTable);
925  }
926 }
927 
929 {
930  for (SwPercentField & i : m_aFieldArr)
931  {
932  if (i.has_focus())
933  {
934  ModifyHdl(i.get());
935  break;
936  }
937  }
938 
939  if (m_bModified)
940  {
942  }
943  return m_bModified;
944 }
945 
947 {
948  SwPercentField *pEdit = nullptr;
949  sal_uInt16 i;
950 
951  for( i = 0; i < m_nMetFields; i++)
952  {
953  if (pField == m_aFieldArr[i].get())
954  {
955  pEdit = &m_aFieldArr[i];
956  break;
957  }
958  }
959 
960  if (m_nMetFields <= i || !pEdit)
961  {
962  OSL_ENSURE(false, "cannot happen.");
963  return;
964  }
965 
966  SetVisibleWidth(m_aValueTable[i], pEdit->DenormalizePercent(pEdit->get_value(FieldUnit::TWIP)));
967 
969 }
970 
971 void SwTableColumnPage::UpdateCols( sal_uInt16 nCurrentPos )
972 {
973  SwTwips nSum = 0;
974 
975  for( sal_uInt16 i = 0; i < m_nNoOfCols; i++ )
976  {
977  nSum += (m_pTableData->GetColumns())[i].nWidth;
978  }
979  SwTwips nDiff = nSum - m_nTableWidth;
980 
981  bool bModifyTableChecked = m_xModifyTableCB->get_active();
982  bool bProp = m_xProportionalCB->get_active();
983 
984  if (!bModifyTableChecked && !bProp)
985  {
986  //The table width is constant, the difference is balanced with the other columns
987  sal_uInt16 nLoopCount = 0;
988  while( nDiff )
989  {
990  if( ++nCurrentPos == m_nNoOfVisibleCols)
991  {
992  nCurrentPos = 0;
993  ++nLoopCount;
994  //#i101353# in small tables it might not be possible to balance column width
995  if( nLoopCount > 1 )
996  break;
997  }
998  if( nDiff < 0 )
999  {
1000  SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) -nDiff);
1001  nDiff = 0;
1002  }
1003  else if( GetVisibleWidth(nCurrentPos) >= nDiff + m_nMinWidth )
1004  {
1005  SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) -nDiff);
1006  nDiff = 0;
1007  }
1008  if( nDiff > 0 && GetVisibleWidth(nCurrentPos) > m_nMinWidth )
1009  {
1010  if( nDiff >= (GetVisibleWidth(nCurrentPos) - m_nMinWidth) )
1011  {
1012  nDiff -= (GetVisibleWidth(nCurrentPos) - m_nMinWidth);
1013  SetVisibleWidth(nCurrentPos, m_nMinWidth);
1014  }
1015  else
1016  {
1017  nDiff = 0;
1018  SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) -nDiff);
1019  }
1020  OSL_ENSURE(nDiff >= 0, "nDiff < 0 cannot be here!");
1021  }
1022  }
1023  }
1024  else if (bModifyTableChecked && !bProp)
1025  {
1026  //Difference is balanced by the width of the table,
1027  //other columns remain unchanged.
1028  OSL_ENSURE(nDiff <= m_pTableData->GetSpace() - m_nTableWidth, "wrong maximum" );
1029  SwTwips nActSpace = m_pTableData->GetSpace() - m_nTableWidth;
1030  if(nDiff > nActSpace)
1031  {
1032  m_nTableWidth = m_pTableData->GetSpace();
1033  SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) - nDiff + nActSpace );
1034  }
1035  else
1036  {
1037  m_nTableWidth += nDiff;
1038  }
1039  }
1040  else if (bModifyTableChecked && bProp)
1041  {
1042  //All columns will be changed proportionally with,
1043  //the table width is adjusted accordingly.
1044  const double fOrigColWidth = std::max(SwTwips(1), GetVisibleWidth(nCurrentPos) - nDiff);
1045  const double fMaxWidth = std::max(m_pTableData->GetSpace(), m_nTableWidth);
1046  const double fMaxPercent = fMaxWidth / m_nTableWidth;
1047  const double fPercentChange = std::min(fMaxPercent, GetVisibleWidth(nCurrentPos)/fOrigColWidth);
1048  SwTwips nNewTableSize = 0;
1049  for( sal_uInt16 i = 0; i < m_nNoOfVisibleCols; i++ )
1050  {
1051  SwTwips nNewColWidth = round( fPercentChange * (i == nCurrentPos ? fOrigColWidth : GetVisibleWidth(i)) );
1052  if ( nNewColWidth < MINLAY )
1053  nNewColWidth = MINLAY;
1054  SetVisibleWidth(i, nNewColWidth);
1055  nNewTableSize += nNewColWidth;
1056  }
1057  m_nTableWidth = nNewTableSize;
1058  }
1059 
1060  if (!m_bPercentMode)
1061  {
1062  m_xSpaceED->set_value(m_xSpaceED->normalize(m_pTableData->GetSpace() - m_nTableWidth), FieldUnit::TWIP);
1063  m_xSpaceSFT->set_label(m_xSpaceED->get_text());
1064  }
1065  else
1066  m_xSpaceSFT->set_label(OUString());
1067 
1068  for( sal_uInt16 i = 0; ( i < m_nNoOfVisibleCols ) && ( i < m_nMetFields ); i++)
1069  {
1070  m_aFieldArr[i].set_value(m_aFieldArr[i].NormalizePercent(
1071  GetVisibleWidth(m_aValueTable[i]) ), FieldUnit::TWIP);
1072  }
1073 }
1074 
1076 {
1078  for( sal_uInt16 i = 0; (i < m_nMetFields) && (i < m_nNoOfVisibleCols); i++ )
1079  {
1082  }
1083 
1084  const sal_uInt16 nTableAlign = m_pTableData->GetAlign();
1085  if((text::HoriOrientation::FULL != nTableAlign && m_nTableWidth != m_pTableData->GetWidth()) ||
1086  (text::HoriOrientation::FULL == nTableAlign && m_nTableWidth != m_pTableData->GetSpace()))
1087  {
1088  m_nTableWidth = text::HoriOrientation::FULL == nTableAlign ?
1089  m_pTableData->GetSpace() :
1091  UpdateCols(0);
1092  }
1093  m_bModifyTable = true;
1094  if (m_pTableData->GetWidthPercent() ||
1095  text::HoriOrientation::FULL == nTableAlign ||
1097  m_bModifyTable = false;
1098  if (m_bPercentMode)
1099  {
1100  m_xModifyTableCB->set_active(false);
1101  m_xProportionalCB->set_active(false);
1102  }
1103  else if (!m_bModifyTable)
1104  {
1105  m_xProportionalCB->set_active(false);
1106  m_xModifyTableCB->set_active(false);
1107  }
1108  m_xSpaceFT->set_sensitive(!m_bPercentMode);
1109  m_xSpaceSFT->set_sensitive(!m_bPercentMode);
1110  m_xModifyTableCB->set_sensitive( !m_bPercentMode && m_bModifyTable );
1111  m_xProportionalCB->set_sensitive(!m_bPercentMode && m_bModifyTable );
1112 
1113  m_xSpaceED->set_value(m_xSpaceED->normalize(
1114  m_pTableData->GetSpace() - m_nTableWidth), FieldUnit::TWIP);
1115  m_xSpaceSFT->set_label(m_xSpaceED->get_text());
1116 
1117 }
1118 
1120 {
1121  if(_pSet)
1122  {
1123  FillItemSet(_pSet);
1124  if(text::HoriOrientation::FULL != m_pTableData->GetAlign() && m_pTableData->GetWidth() != m_nTableWidth)
1125  {
1129  switch( m_pTableData->GetAlign() )
1130  {
1131  case text::HoriOrientation::RIGHT:
1133  break;
1134  case text::HoriOrientation::LEFT:
1136  break;
1138  {
1139  SwTwips nDiff2 = nDiff/2;
1140  if( nDiff > 0 ||
1141  (-nDiff2 < m_pTableData->GetRightSpace() && - nDiff2 < m_pTableData->GetLeftSpace()))
1142  {
1145  }
1146  else
1147  {
1149  {
1152  }
1153  else
1154  {
1157  }
1158  }
1159  }
1160  break;
1161  case text::HoriOrientation::CENTER:
1164  break;
1165  case text::HoriOrientation::LEFT_AND_WIDTH :
1166  if(nDiff > m_pTableData->GetRightSpace())
1167  {
1169  }
1172  break;
1173  }
1175  }
1176  _pSet->Put(SwPtrItem( FN_TABLE_REP, m_pTableData ));
1177  }
1178  return DeactivateRC::LeavePage;
1179 }
1180 
1182 {
1183  sal_uInt16 i=0;
1184 
1185  while( nPos )
1186  {
1187  if(m_pTableData->GetColumns()[i].bVisible)
1188  nPos--;
1189  i++;
1190  }
1191  SwTwips nReturn = m_pTableData->GetColumns()[i].nWidth;
1192  OSL_ENSURE(i < m_nNoOfCols, "Array index out of range");
1193  while(!m_pTableData->GetColumns()[i].bVisible && (i + 1) < m_nNoOfCols)
1194  nReturn += m_pTableData->GetColumns()[++i].nWidth;
1195 
1196  return nReturn;
1197 }
1198 
1199 void SwTableColumnPage::SetVisibleWidth(sal_uInt16 nPos, SwTwips nNewWidth)
1200 {
1201  sal_uInt16 i=0;
1202  while( nPos )
1203  {
1204  if(m_pTableData->GetColumns()[i].bVisible)
1205  nPos--;
1206  i++;
1207  }
1208  OSL_ENSURE(i < m_nNoOfCols, "Array index out of range");
1209  m_pTableData->GetColumns()[i].nWidth = nNewWidth;
1210  while(!m_pTableData->GetColumns()[i].bVisible && (i + 1) < m_nNoOfCols)
1211  m_pTableData->GetColumns()[++i].nWidth = 0;
1212 
1213 }
1214 
1216  : SfxTabDialogController(pParent, "modules/swriter/ui/tableproperties.ui", "TablePropertiesDialog", pItemSet)
1217  , pShell(pSh)
1218 {
1220  AddTabPage("table", &SwFormatTablePage::Create, nullptr);
1221  AddTabPage("textflow", &SwTextFlowPage::Create, nullptr);
1222  AddTabPage("columns", &SwTableColumnPage::Create, nullptr);
1223  AddTabPage("background", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BKG), nullptr);
1224  AddTabPage("borders", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BORDER), nullptr);
1225 }
1226 
1227 void SwTableTabDlg::PageCreated(const OString& rId, SfxTabPage& rPage)
1228 {
1229  SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool()));
1230  if (rId == "background")
1231  {
1232  SvxBackgroundTabFlags const nFlagType = SvxBackgroundTabFlags::SHOW_TBLCTL;
1233  aSet.Put (SfxUInt32Item(SID_FLAG_TYPE, static_cast<sal_uInt32>(nFlagType)));
1234  rPage.PageCreated(aSet);
1235  }
1236  else if (rId == "borders")
1237  {
1238  aSet.Put (SfxUInt16Item(SID_SWMODE_TYPE, static_cast<sal_uInt16>(SwBorderModes::TABLE)));
1239  rPage.PageCreated(aSet);
1240  }
1241  else if (rId == "textflow")
1242  {
1243  static_cast<SwTextFlowPage&>(rPage).SetShell(pShell);
1244  const FrameTypeFlags eType = pShell->GetFrameType(nullptr,true);
1245  if( !(FrameTypeFlags::BODY & eType) )
1246  static_cast<SwTextFlowPage&>(rPage).DisablePageBreak();
1247  }
1248 }
1249 
1251  : SfxTabPage(pPage, pController, "modules/swriter/ui/tabletextflowpage.ui", "TableTextFlowPage", &rSet)
1252  , pShell(nullptr)
1253  , bPageBreak(true)
1254  , bHtmlMode(false)
1255  , m_xPgBrkCB(m_xBuilder->weld_check_button("break"))
1256  , m_xPgBrkRB(m_xBuilder->weld_radio_button("page"))
1257  , m_xColBrkRB(m_xBuilder->weld_radio_button("column"))
1258  , m_xPgBrkBeforeRB(m_xBuilder->weld_radio_button("before"))
1259  , m_xPgBrkAfterRB(m_xBuilder->weld_radio_button("after"))
1260  , m_xPageCollCB(m_xBuilder->weld_check_button("pagestyle"))
1261  , m_xPageCollLB(m_xBuilder->weld_combo_box("pagestylelb"))
1262  , m_xPageNoCB(m_xBuilder->weld_check_button("pagenoft"))
1263  , m_xPageNoNF(m_xBuilder->weld_spin_button("pagenonf"))
1264  , m_xSplitCB(m_xBuilder->weld_check_button("split"))
1265  , m_xSplitRowCB(m_xBuilder->weld_check_button("splitrow"))
1266  , m_xKeepCB(m_xBuilder->weld_check_button("keep"))
1267  , m_xHeadLineCB(m_xBuilder->weld_check_button("headline"))
1268  , m_xRepeatHeaderCombo(m_xBuilder->weld_widget("repeatheader"))
1269  , m_xRepeatHeaderNF(m_xBuilder->weld_spin_button("repeatheadernf"))
1270  , m_xTextDirectionLB(m_xBuilder->weld_combo_box("textorientation"))
1271  , m_xVertOrientLB(m_xBuilder->weld_combo_box("vertorient"))
1272 {
1273  m_xPgBrkCB->connect_toggled(LINK(this, SwTextFlowPage, PageBreakHdl_Impl));
1274  m_xPgBrkBeforeRB->connect_toggled(
1275  LINK(this, SwTextFlowPage, PageBreakPosHdl_Impl));
1276  m_xPgBrkAfterRB->connect_toggled(
1277  LINK(this, SwTextFlowPage, PageBreakPosHdl_Impl));
1278  m_xPageCollCB->connect_toggled(
1279  LINK(this, SwTextFlowPage, ApplyCollClickHdl_Impl));
1280  m_xColBrkRB->connect_toggled(
1281  LINK(this, SwTextFlowPage, PageBreakTypeHdl_Impl));
1282  m_xPgBrkRB->connect_toggled(
1283  LINK(this, SwTextFlowPage, PageBreakTypeHdl_Impl));
1284  m_xPageNoCB->connect_toggled(
1285  LINK(this, SwTextFlowPage, PageNoClickHdl_Impl));
1286  m_xSplitCB->connect_toggled(
1287  LINK(this, SwTextFlowPage, SplitHdl_Impl));
1288  m_xHeadLineCB->connect_toggled(LINK(this, SwTextFlowPage, HeadLineCBClickHdl));
1289 
1290  const SfxPoolItem *pItem;
1291  if(SfxItemState::SET == rSet.GetItemState( SID_HTML_MODE, false,&pItem )
1292  && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON)
1293  {
1294  m_xKeepCB->hide();
1295  m_xSplitCB->hide();
1296  m_xSplitRowCB->hide();
1297  }
1298 
1299  HeadLineCBClickHdl(*m_xHeadLineCB);
1300 }
1301 
1303 {
1304 }
1305 
1306 std::unique_ptr<SfxTabPage> SwTextFlowPage::Create(weld::Container* pPage, weld::DialogController* pController,
1307  const SfxItemSet* rAttrSet)
1308 {
1309  return std::make_unique<SwTextFlowPage>(pPage, pController, *rAttrSet);
1310 }
1311 
1313 {
1314  bool bModified = false;
1315 
1316  //Repeat Heading
1317  if (m_xHeadLineCB->get_state_changed_from_saved() ||
1318  m_xRepeatHeaderNF->get_value_changed_from_saved() )
1319  {
1320  bModified |= nullptr != rSet->Put(
1321  SfxUInt16Item(FN_PARAM_TABLE_HEADLINE, m_xHeadLineCB->get_active() ? sal_uInt16(m_xRepeatHeaderNF->get_value()) : 0));
1322  }
1323  if (m_xKeepCB->get_state_changed_from_saved())
1324  bModified |= nullptr != rSet->Put( SvxFormatKeepItem( m_xKeepCB->get_active(), RES_KEEP));
1325 
1326  if (m_xSplitCB->get_state_changed_from_saved())
1327  bModified |= nullptr != rSet->Put( SwFormatLayoutSplit( m_xSplitCB->get_active()));
1328 
1329  if (m_xSplitRowCB->get_state_changed_from_saved())
1330  bModified |= nullptr != rSet->Put( SwFormatRowSplit( m_xSplitRowCB->get_active()));
1331 
1332  const SvxFormatBreakItem* pBreak = GetOldItem( *rSet, RES_BREAK );
1333  const SwFormatPageDesc* pDesc = GetOldItem( *rSet, RES_PAGEDESC );
1334 
1335  bool bState = m_xPageCollCB->get_active();
1336 
1337  //If we have a page style, then there's no break
1338  bool bPageItemPut = false;
1339  if ( bState != (m_xPageCollCB->get_saved_state() == TRISTATE_TRUE)
1340  || (bState && m_xPageCollLB->get_value_changed_from_saved())
1341  || (m_xPageNoCB->get_sensitive() && m_xPageNoCB->get_state_changed_from_saved())
1342  || (m_xPageNoNF->get_sensitive() && m_xPageNoNF->get_value_changed_from_saved()))
1343  {
1344  OUString sPage;
1345 
1346  if ( bState )
1347  {
1348  sPage = m_xPageCollLB->get_active_text();
1349  }
1350  sal_uInt16 nPgNum = o3tl::narrowing<sal_uInt16>(m_xPageNoNF->get_value());
1351  bool const usePageNo(bState && m_xPageNoCB->get_active());
1352  std::optional<sal_uInt16> const oPageNum(
1353  usePageNo ? nPgNum : std::optional<sal_Int16>());
1354  if (!pDesc || !pDesc->GetPageDesc()
1355  || (pDesc->GetPageDesc()->GetName() != sPage)
1356  || (pDesc->GetNumOffset() != oPageNum))
1357  {
1358  SwFormatPageDesc aFormat( pShell->FindPageDescByName( sPage, true ) );
1359  aFormat.SetNumOffset(oPageNum);
1360  bModified |= nullptr != rSet->Put( aFormat );
1361  bPageItemPut = bState;
1362  }
1363  }
1364  bool bIsChecked = m_xPgBrkCB->get_active();
1365  if ( !bPageItemPut &&
1366  ( bState != (m_xPageCollCB->get_saved_state() == TRISTATE_TRUE) ||
1367  bIsChecked != (m_xPgBrkCB->get_saved_state() == TRISTATE_TRUE) ||
1368  m_xPgBrkBeforeRB->get_state_changed_from_saved() ||
1369  m_xPgBrkRB->get_state_changed_from_saved() ))
1370  {
1371  SvxFormatBreakItem aBreak( GetItemSet().Get( RES_BREAK ) );
1372 
1373  if(bIsChecked)
1374  {
1375  bool bBefore = m_xPgBrkBeforeRB->get_active();
1376 
1377  if (m_xPgBrkRB->get_active())
1378  {
1379  if ( bBefore )
1380  aBreak.SetValue( SvxBreak::PageBefore );
1381  else
1382  aBreak.SetValue( SvxBreak::PageAfter );
1383  }
1384  else
1385  {
1386  if ( bBefore )
1387  aBreak.SetValue( SvxBreak::ColumnBefore );
1388  else
1389  aBreak.SetValue( SvxBreak::ColumnAfter );
1390  }
1391  }
1392  else
1393  {
1394  aBreak.SetValue( SvxBreak::NONE );
1395  }
1396 
1397  if ( !pBreak || !( *pBreak == aBreak ) )
1398  {
1399  bModified |= nullptr != rSet->Put( aBreak );
1400  }
1401  }
1402 
1403  if (m_xTextDirectionLB->get_value_changed_from_saved())
1404  {
1405  OUString sId = m_xTextDirectionLB->get_active_id();
1406  bModified |= nullptr != rSet->Put(SvxFrameDirectionItem(static_cast<SvxFrameDirection>(sId.toUInt32()), FN_TABLE_BOX_TEXTORIENTATION));
1407  }
1408 
1409  if (m_xVertOrientLB->get_value_changed_from_saved())
1410  {
1411  sal_uInt16 nOrient = USHRT_MAX;
1412  switch (m_xVertOrientLB->get_active())
1413  {
1414  case 0 : nOrient = text::VertOrientation::NONE; break;
1415  case 1 : nOrient = text::VertOrientation::CENTER; break;
1416  case 2 : nOrient = text::VertOrientation::BOTTOM; break;
1417  }
1418  if (nOrient != USHRT_MAX)
1419  bModified |= nullptr != rSet->Put(SfxUInt16Item(FN_TABLE_SET_VERT_ALIGN, nOrient));
1420  }
1421 
1422  return bModified;
1423 
1424 }
1425 
1427 {
1428  const SfxPoolItem* pItem;
1429  bool bFlowAllowed = !bHtmlMode || SvxHtmlOptions::IsPrintLayoutExtension();
1430  if(bFlowAllowed)
1431  {
1432  //Inserting of the existing page templates in the list box
1433  const size_t nCount = pShell->GetPageDescCnt();
1434 
1435  for( size_t i = 0; i < nCount; ++i)
1436  {
1437  const SwPageDesc &rPageDesc = pShell->GetPageDesc(i);
1438  m_xPageCollLB->append_text(rPageDesc.GetName());
1439  }
1440 
1441  OUString aFormatName;
1442  for (sal_uInt16 i = RES_POOLPAGE_BEGIN; i < RES_POOLPAGE_END; ++i)
1443  {
1444  aFormatName = SwStyleNameMapper::GetUIName(i, aFormatName);
1445  if (m_xPageCollLB->find_text(aFormatName) == -1)
1446  m_xPageCollLB->append_text(aFormatName);
1447  }
1448 
1449  if(SfxItemState::SET == rSet->GetItemState( RES_KEEP, false, &pItem ))
1450  {
1451  m_xKeepCB->set_active( static_cast<const SvxFormatKeepItem*>(pItem)->GetValue() );
1452  m_xKeepCB->save_state();
1453  }
1454  if(SfxItemState::SET == rSet->GetItemState( RES_LAYOUT_SPLIT, false, &pItem ))
1455  {
1456  m_xSplitCB->set_active( static_cast<const SwFormatLayoutSplit*>(pItem)->GetValue() );
1457  }
1458  else
1459  m_xSplitCB->set_active(true);
1460 
1461  m_xSplitCB->save_state();
1462  SplitHdl_Impl(*m_xSplitCB);
1463 
1464  if(SfxItemState::SET == rSet->GetItemState( RES_ROW_SPLIT, false, &pItem ))
1465  {
1466  m_xSplitRowCB->set_active( static_cast<const SwFormatRowSplit*>(pItem)->GetValue() );
1467  }
1468  else
1469  m_xSplitRowCB->set_state(TRISTATE_INDET);
1470  m_xSplitRowCB->save_state();
1471 
1472  if(bPageBreak)
1473  {
1474  if(SfxItemState::SET == rSet->GetItemState( RES_PAGEDESC, false, &pItem ))
1475  {
1476  OUString sPageDesc;
1477  const SwPageDesc* pDesc = static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc();
1478 
1479  ::std::optional<sal_uInt16> oNumOffset = static_cast<const SwFormatPageDesc*>(pItem)->GetNumOffset();
1480  if (oNumOffset)
1481  {
1482  m_xPageNoCB->set_active(true);
1483  m_xPageNoNF->set_sensitive(true);
1484  m_xPageNoNF->set_value(*oNumOffset);
1485  }
1486  else
1487  {
1488  m_xPageNoCB->set_active(false);
1489  m_xPageNoNF->set_sensitive(false);
1490  }
1491 
1492  if(pDesc)
1493  sPageDesc = pDesc->GetName();
1494  if (!sPageDesc.isEmpty() && m_xPageCollLB->find_text(sPageDesc) != -1)
1495  {
1496  m_xPageCollLB->set_active_text(sPageDesc);
1497  m_xPageCollCB->set_active(true);
1498 
1499  m_xPgBrkCB->set_sensitive(true);
1500  m_xPgBrkRB->set_sensitive(true);
1501  m_xColBrkRB->set_sensitive(true);
1502  m_xPgBrkBeforeRB->set_sensitive(true);
1503  m_xPgBrkAfterRB->set_sensitive(true);
1504  m_xPageCollCB->set_sensitive(true);
1505 
1506  m_xPgBrkCB->set_active(true);
1507  m_xColBrkRB->set_active( false );
1508  m_xPgBrkBeforeRB->set_active(true);
1509  m_xPgBrkAfterRB->set_active( false );
1510  }
1511  else
1512  {
1513  m_xPageCollLB->set_active(-1);
1514  m_xPageCollCB->set_active(false);
1515  }
1516  }
1517 
1518  if(SfxItemState::SET == rSet->GetItemState( RES_BREAK, false, &pItem ))
1519  {
1520  const SvxFormatBreakItem* pPageBreak = static_cast<const SvxFormatBreakItem*>(pItem);
1521  SvxBreak eBreak = pPageBreak->GetBreak();
1522 
1523  if ( eBreak != SvxBreak::NONE )
1524  {
1525  m_xPgBrkCB->set_active(true);
1526  m_xPageCollCB->set_sensitive(false);
1527  m_xPageCollLB->set_sensitive(false);
1528  m_xPageNoCB->set_sensitive(false);
1529  m_xPageNoNF->set_sensitive(false);
1530  }
1531  switch ( eBreak )
1532  {
1533  case SvxBreak::PageBefore:
1534  m_xPgBrkRB->set_active(true);
1535  m_xColBrkRB->set_active( false );
1536  m_xPgBrkBeforeRB->set_active(true);
1537  m_xPgBrkAfterRB->set_active( false );
1538  break;
1539  case SvxBreak::PageAfter:
1540  m_xPgBrkRB->set_active(true);
1541  m_xColBrkRB->set_active( false );
1542  m_xPgBrkBeforeRB->set_active( false );
1543  m_xPgBrkAfterRB->set_active(true);
1544  break;
1545  case SvxBreak::ColumnBefore:
1546  m_xPgBrkRB->set_active( false );
1547  m_xColBrkRB->set_active(true);
1548  m_xPgBrkBeforeRB->set_active(true);
1549  m_xPgBrkAfterRB->set_active( false );
1550  break;
1551  case SvxBreak::ColumnAfter:
1552  m_xPgBrkRB->set_active( false );
1553  m_xColBrkRB->set_active(true);
1554  m_xPgBrkBeforeRB->set_active( false );
1555  m_xPgBrkAfterRB->set_active(true);
1556  break;
1557  default:; //prevent warning
1558  }
1559 
1560  }
1561  if (m_xPgBrkBeforeRB->get_active())
1562  PageBreakPosHdl_Impl(*m_xPgBrkBeforeRB);
1563  else if (m_xPgBrkAfterRB->get_active())
1564  PageBreakPosHdl_Impl(*m_xPgBrkAfterRB);
1565  PageBreakHdl_Impl(*m_xPgBrkCB);
1566  }
1567  }
1568  else
1569  {
1570  m_xPgBrkRB->set_sensitive(false);
1571  m_xColBrkRB->set_sensitive(false);
1572  m_xPgBrkBeforeRB->set_sensitive(false);
1573  m_xPgBrkAfterRB->set_sensitive(false);
1574  m_xKeepCB->set_sensitive(false);
1575  m_xSplitCB->set_sensitive(false);
1576  m_xPgBrkCB->set_sensitive(false);
1577  m_xPageCollCB->set_sensitive(false);
1578  m_xPageCollLB->set_sensitive(false);
1579  }
1580 
1581  if(SfxItemState::SET == rSet->GetItemState( FN_PARAM_TABLE_HEADLINE, false, &pItem ))
1582  {
1583  sal_uInt16 nRep = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1584  m_xHeadLineCB->set_active(nRep > 0);
1585  m_xHeadLineCB->save_state();
1586  m_xRepeatHeaderNF->set_value(nRep);
1587  m_xRepeatHeaderNF->set_min(1);
1588  m_xRepeatHeaderNF->save_value();
1589  }
1590  if ( rSet->GetItemState(FN_TABLE_BOX_TEXTORIENTATION) > SfxItemState::DEFAULT )
1591  {
1592  SvxFrameDirection nDirection =
1593  static_cast<const SvxFrameDirectionItem&>(rSet->Get(FN_TABLE_BOX_TEXTORIENTATION)).GetValue();
1594  m_xTextDirectionLB->set_active_id(OUString::number(static_cast<sal_uInt32>(nDirection)));
1595  }
1596 
1597  if ( rSet->GetItemState(FN_TABLE_SET_VERT_ALIGN) > SfxItemState::DEFAULT )
1598  {
1599  sal_uInt16 nVert = static_cast<const SfxUInt16Item&>(rSet->Get(FN_TABLE_SET_VERT_ALIGN)).GetValue();
1600  sal_uInt16 nPos = 0;
1601  switch(nVert)
1602  {
1603  case text::VertOrientation::NONE: nPos = 0; break;
1604  case text::VertOrientation::CENTER: nPos = 1; break;
1605  case text::VertOrientation::BOTTOM: nPos = 2; break;
1606  }
1607  m_xVertOrientLB->set_active(nPos);
1608  }
1609 
1610  m_xPageCollCB->save_state();
1611  m_xPageCollLB->save_value();
1612  m_xPgBrkCB->save_state();
1613  m_xPgBrkRB->save_state();
1614  m_xColBrkRB->save_state();
1615  m_xPgBrkBeforeRB->save_state();
1616  m_xPgBrkAfterRB->save_state();
1617  m_xPageNoCB->save_state();
1618  m_xPageNoNF->save_value();
1619  m_xTextDirectionLB->save_value();
1620  m_xVertOrientLB->save_value();
1621 
1622  HeadLineCBClickHdl(*m_xHeadLineCB);
1623 }
1624 
1626 {
1627  pShell = pSh;
1629  if(bHtmlMode)
1630  {
1631  m_xPageNoNF->set_sensitive(false);
1632  m_xPageNoCB->set_sensitive(false);
1633  }
1634 }
1635 
1637 {
1638  if (m_xPgBrkCB->get_active())
1639  {
1640  m_xPgBrkRB->set_sensitive(true);
1641  m_xColBrkRB->set_sensitive(true);
1642  m_xPgBrkBeforeRB->set_sensitive(true);
1643  m_xPgBrkAfterRB->set_sensitive(true);
1644 
1645  if (m_xPgBrkRB->get_active() && m_xPgBrkBeforeRB->get_active())
1646  {
1647  m_xPageCollCB->set_sensitive(true);
1648 
1649  bool bEnable = m_xPageCollCB->get_active() && m_xPageCollLB->get_count();
1650  m_xPageCollLB->set_sensitive(bEnable);
1651  if (!bHtmlMode)
1652  {
1653  m_xPageNoCB->set_sensitive(bEnable);
1654  m_xPageNoNF->set_sensitive(bEnable && m_xPageNoCB->get_active());
1655  }
1656  }
1657  }
1658  else
1659  {
1660  m_xPageCollCB->set_active(false);
1661  m_xPageCollCB->set_sensitive(false);
1662  m_xPageCollLB->set_sensitive(false);
1663  m_xPageNoCB->set_sensitive(false);
1664  m_xPageNoNF->set_sensitive(false);
1665  m_xPgBrkRB->set_sensitive(false);
1666  m_xColBrkRB->set_sensitive(false);
1667  m_xPgBrkBeforeRB->set_sensitive(false);
1668  m_xPgBrkAfterRB->set_sensitive(false);
1669  }
1670 }
1671 
1672 IMPL_LINK_NOARG(SwTextFlowPage, ApplyCollClickHdl_Impl, weld::Toggleable&, void)
1673 {
1674  bool bEnable = false;
1675  if (m_xPageCollCB->get_active() && m_xPageCollLB->get_count())
1676  {
1677  bEnable = true;
1678  m_xPageCollLB->set_active(0);
1679  }
1680  else
1681  {
1682  m_xPageCollLB->set_active(-1);
1683  }
1684  m_xPageCollLB->set_sensitive(bEnable);
1685  if (!bHtmlMode)
1686  {
1687  m_xPageNoCB->set_sensitive(bEnable);
1688  m_xPageNoNF->set_sensitive(bEnable && m_xPageNoCB->get_active());
1689  }
1690 }
1691 
1692 IMPL_LINK_NOARG(SwTextFlowPage, PageBreakPosHdl_Impl, weld::Toggleable&, void)
1693 {
1694  if (!m_xPgBrkCB->get_active())
1695  return;
1696 
1697  if (m_xPgBrkBeforeRB->get_active() && m_xPgBrkRB->get_active())
1698  {
1699  m_xPageCollCB->set_sensitive(true);
1700 
1701  bool bEnable = m_xPageCollCB->get_active() && m_xPageCollLB->get_count();
1702 
1703  m_xPageCollLB->set_sensitive(bEnable);
1704  if (!bHtmlMode)
1705  {
1706  m_xPageNoCB->set_sensitive(bEnable);
1707  m_xPageNoNF->set_sensitive(bEnable && m_xPageNoCB->get_active());
1708  }
1709  }
1710  else if (m_xPgBrkAfterRB->get_active())
1711  {
1712  m_xPageCollCB->set_active(false);
1713  m_xPageCollCB->set_sensitive(false);
1714  m_xPageCollLB->set_sensitive(false);
1715  m_xPageNoCB->set_sensitive(false);
1716  m_xPageNoNF->set_sensitive(false);
1717  }
1718 }
1719 
1720 IMPL_LINK_NOARG(SwTextFlowPage, PageBreakTypeHdl_Impl, weld::Toggleable&, void)
1721 {
1722  if (m_xColBrkRB->get_active() || m_xPgBrkAfterRB->get_active())
1723  {
1724  m_xPageCollCB->set_active(false);
1725  m_xPageCollCB->set_sensitive(false);
1726  m_xPageCollLB->set_sensitive(false);
1727  m_xPageNoCB->set_sensitive(false);
1728  m_xPageNoNF->set_sensitive(false);
1729  }
1730  else if (m_xPgBrkBeforeRB->get_active())
1731  PageBreakPosHdl_Impl(*m_xPgBrkBeforeRB);
1732 }
1733 
1734 IMPL_LINK_NOARG(SwTextFlowPage, PageNoClickHdl_Impl, weld::Toggleable&, void)
1735 {
1736  m_xPageNoNF->set_sensitive(m_xPageNoCB->get_active());
1737 }
1738 
1739 IMPL_LINK(SwTextFlowPage, SplitHdl_Impl, weld::Toggleable&, rBox, void)
1740 {
1741  m_xSplitRowCB->set_sensitive(rBox.get_active());
1742 }
1743 
1745 {
1746  m_xRepeatHeaderCombo->set_sensitive(m_xHeadLineCB->get_active());
1747 }
1748 
1750 {
1751  bPageBreak = false;
1752  m_xPgBrkCB->set_sensitive(false);
1753  m_xPgBrkRB->set_sensitive(false);
1754  m_xColBrkRB->set_sensitive(false);
1755  m_xPgBrkBeforeRB->set_sensitive(false);
1756  m_xPgBrkAfterRB->set_sensitive(false);
1757  m_xPageCollCB->set_sensitive(false);
1758  m_xPageCollLB->set_sensitive(false);
1759  m_xPageNoCB->set_sensitive(false);
1760  m_xPageNoNF->set_sensitive(false);
1761 }
1762 
1763 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
SvxBreak
void SetFieldUnit(weld::MetricSpinButton &rField, FieldUnit eUnit, bool bAll)
constexpr TypedWhichId< SvxFrameDirectionItem > RES_FRAMEDIR(120)
constexpr TypedWhichId< SwFormatPageDesc > RES_PAGEDESC(93)
std::unique_ptr< weld::Label > m_xRightFT
Definition: tablepg.hxx:54
const ::std::optional< sal_uInt16 > & GetNumOffset() const
Definition: fmtpdsc.hxx:64
std::unique_ptr< weld::Label > m_xSpaceFT
Definition: tablepg.hxx:113
SwTwips nWidth
Definition: swtablerep.hxx:29
sal_uInt16 m_nNoOfVisibleCols
Definition: tablepg.hxx:102
std::unique_ptr< SwTableRep > m_xOrigTableData
Definition: tablepg.hxx:96
FieldUnit
std::unique_ptr< weld::ComboBox > m_xVertOrientLB
Definition: tablepg.hxx:163
SwFormatTablePage(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet &rSet)
Definition: tabledlg.cxx:66
void SetRefValue(int nValue)
Definition: prcntfld.cxx:39
SwTableColumnPage(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet &rSet)
Definition: tabledlg.cxx:729
void SetLeftSpace(SwTwips nSet)
Definition: swtablerep.hxx:61
void Init()
Pagedescriptor Client of SwPageDesc that is "described" by the attribute.
Definition: fmtpdsc.hxx:35
size_t GetPageDescCnt() const
Definition: fedesc.cxx:38
TColumn * GetColumns()
Definition: swtablerep.hxx:90
SwPageDesc * GetPageDesc()
Definition: fmtpdsc.hxx:61
std::unique_ptr< weld::RadioButton > m_xFreeBtn
Definition: tablepg.hxx:50
SwTextFlowPage(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet &rSet)
Definition: tabledlg.cxx:1250
virtual void PageCreated(const SfxAllItemSet &aSet)
static SfxAbstractDialogFactory * Create()
SwTwips GetLeftSpace() const
Definition: swtablerep.hxx:60
std::unique_ptr< weld::Label > m_xLeftFT
Definition: tablepg.hxx:52
std::string GetValue
sal_uInt16 m_aValueTable[MET_FIELDS]
Definition: tablepg.hxx:104
void UpdateCols(sal_uInt16 nCurrentPos)
Definition: tabledlg.cxx:971
bool HasWidthChanged() const
Definition: swtablerep.hxx:81
constexpr TypedWhichId< SvxFormatKeepItem > RES_KEEP(110)
virtual DeactivateRC DeactivatePage(SfxItemSet *pSet) override
Definition: tabledlg.cxx:1119
SwTwips m_nMinWidth
Definition: tablepg.hxx:99
sal_uInt16 char char * pDesc
SvxBreak GetBreak() const
void SetAlign(sal_uInt16 nSet)
Definition: swtablerep.hxx:73
void SetShell(SwViewShell *pSh)
Definition: newfrm.cxx:352
long Long
void ShowPercent(bool bPercent)
Definition: prcntfld.cxx:49
#define MINLAY
Definition: swtypes.hxx:63
SwWrtShell * pShell
Definition: tabledlg.hxx:30
void ModifyHdl(const weld::MetricSpinButton &rEdit, bool bAllowInconsistencies=false)
Definition: tabledlg.cxx:271
std::unique_ptr< weld::RadioButton > m_xFullBtn
Definition: tablepg.hxx:45
void SetColsChanged()
Definition: swtablerep.hxx:79
static ImplSVEvent * PostUserEvent(const Link< void *, void > &rLink, void *pCaller=nullptr, bool bReferenceLink=false)
constexpr TypedWhichId< SvxFormatBreakItem > RES_BREAK(94)
std::unique_ptr< weld::SpinButton > m_xRepeatHeaderNF
Definition: tablepg.hxx:161
SvxFrameDirection
SfxItemSet * GetInputSetImpl()
#define FN_PARAM_TABLE_NAME
Definition: cmdid.h:781
SwTwips GetRightSpace() const
Definition: swtablerep.hxx:63
std::unique_ptr< weld::Label > m_xBottomFT
Definition: tablepg.hxx:58
TRISTATE_TRUE
virtual void Reset(const SfxItemSet *rSet) override
Definition: tabledlg.cxx:1426
SwTwips GetWidth() const
Definition: swtablerep.hxx:66
void set_min(int nNewMin, FieldUnit eInUnit)
Definition: prcntfld.cxx:135
void SetRightSpace(SwTwips nSet)
Definition: swtablerep.hxx:64
const OUString & GetName() const
Definition: pagedesc.hxx:196
constexpr TypedWhichId< SwFormatLayoutSplit > RES_LAYOUT_SPLIT(113)
std::unique_ptr< weld::Button > m_xDownBtn
Definition: tablepg.hxx:117
Used by the UI to modify the document model.
Definition: wrtsh.hxx:93
#define FN_PARAM_TABLE_HEADLINE
Definition: cmdid.h:782
OUString SwResId(TranslateId aId)
Definition: swmodule.cxx:165
constexpr tools::Long Width() const
std::unique_ptr< weld::CheckButton > m_xSplitCB
Definition: tablepg.hxx:156
const SwView & GetView() const
Definition: wrtsh.hxx:431
std::unique_ptr< SwPercentField > m_xRightMF
Definition: tablepg.hxx:55
virtual CreateTabPage GetTabPageCreatorFunc(sal_uInt16 nId)=0
void set_value(int nNewValue, FieldUnit eInUnit=FieldUnit::NONE)
Definition: prcntfld.cxx:107
SvxBackgroundTabFlags
std::unique_ptr< SwPercentField > m_xWidthMF
Definition: tablepg.hxx:42
sal_uInt16 GetAlign() const
Definition: swtablerep.hxx:72
std::unique_ptr< weld::CheckButton > m_xPageNoCB
Definition: tablepg.hxx:154
std::unique_ptr< weld::Label > m_xTopFT
Definition: tablepg.hxx:56
virtual void ActivatePage(const SfxItemSet &rSet) override
Definition: tabledlg.cxx:589
void SetExchangeSupport()
int nCount
OUString SvxResId(TranslateId aId)
SwTableTabDlg(weld::Window *pParent, const SfxItemSet *pItemSet, SwWrtShell *pSh)
Definition: tabledlg.cxx:1215
void set_sensitive(bool bEnable)
Definition: prcntfld.hxx:51
virtual bool FillItemSet(SfxItemSet *rSet) override
Definition: tabledlg.cxx:928
void connect_value_changed(const Link< weld::MetricSpinButton &, void > &rLink)
Definition: prcntfld.hxx:49
std::unique_ptr< weld::Entry > m_xNameED
Definition: tablepg.hxx:40
std::unique_ptr< weld::CheckButton > m_xKeepCB
Definition: tablepg.hxx:158
sal_uInt16 GetAllColCount() const
Definition: swtablerep.hxx:76
std::unique_ptr< weld::Label > m_aTextArr[MET_FIELDS]
Definition: tablepg.hxx:110
sal_uInt16 GetColCount() const
Definition: swtablerep.hxx:75
std::unique_ptr< weld::Widget > m_xProperties
Definition: tablepg.hxx:62
void SetWidth(SwTwips nSet)
Definition: swtablerep.hxx:67
TRISTATE_INDET
std::unique_ptr< weld::ComboBox > m_xPageCollLB
Definition: tablepg.hxx:153
sal_uInt16 GetWidthPercent() const
Definition: swtablerep.hxx:69
void SetLower(const sal_uInt16 nL, const sal_uInt16 nProp=100)
std::unique_ptr< weld::CheckButton > m_xSplitRowCB
Definition: tablepg.hxx:157
const SfxItemSet & GetItemSet() const
constexpr TypedWhichId< SwFormatRowSplit > RES_ROW_SPLIT(122)
DocumentType eType
static void RemoveUserEvent(ImplSVEvent *nUserEvent)
weld::Window * GetFrameWeld(const SfxFrame *pFrame)
Definition: dialoghelp.cxx:19
const SfxPoolItem * GetOldItem(const SfxItemSet &rSet, sal_uInt16 nSlot, bool bDeep=true)
bool IsPrintLayoutExtension()
void DisablePageBreak()
Definition: tabledlg.cxx:1749
#define SW_MOD()
Definition: swmodule.hxx:256
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
SW_DLLPUBLIC FieldUnit GetDfltMetric(bool bWeb)
Definition: uitool.cxx:763
int i
void set_max(int nNewMax, FieldUnit eInUnit)
Definition: prcntfld.cxx:150
virtual ~SwFormatTablePage() override
Definition: tabledlg.cxx:121
std::unique_ptr< weld::RadioButton > m_xPgBrkBeforeRB
Definition: tablepg.hxx:150
int NormalizePercent(int nValue)
Definition: prcntfld.cxx:156
int get_value(FieldUnit eOutUnit=FieldUnit::NONE)
Definition: prcntfld.cxx:130
SwPercentField m_aFieldArr[MET_FIELDS]
Definition: tablepg.hxx:109
const SwPageDesc & GetPageDesc(size_t i) const
Definition: fedesc.cxx:126
HTMLMODE_ON
FrameTypeFlags
values can be combined via logical or
Definition: fesh.hxx:62
sal_uInt16 GetHtmlMode(const SwDocShell *pShell)
Definition: viewopt.cxx:354
SwTwips GetSpace() const
Definition: swtablerep.hxx:87
void SetWidthChanged()
Definition: swtablerep.hxx:82
sal_uInt16 m_nMetFields
Definition: tablepg.hxx:100
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: tabledlg.cxx:803
std::unique_ptr< SwPercentField > m_xLeftMF
Definition: tablepg.hxx:53
const SfxItemSet * GetItemSet(const SfxPoolItem &rAttr)
Returns the item set associated with a character/inet/auto style.
Definition: atrstck.cxx:132
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: tabledlg.cxx:384
std::unique_ptr< weld::ComboBox > m_xTextDirectionLB
Definition: tablepg.hxx:162
std::unique_ptr< weld::CheckButton > m_xPageCollCB
Definition: tablepg.hxx:152
std::unique_ptr< weld::MetricSpinButton > m_xSpaceED
Definition: tablepg.hxx:115
virtual Size get_preferred_size() const =0
tools::Long SwTwips
Definition: swtypes.hxx:52
static sal_uInt16 nPgNum
Definition: viewport.cxx:52
SwTwips nMinTableWidth
Definition: tablepg.hxx:35
SwDocShell * GetDocShell()
Definition: view.cxx:1127
std::unique_ptr< weld::RadioButton > m_xPgBrkRB
Definition: tablepg.hxx:148
SwTwips nSaveWidth
Definition: tablepg.hxx:34
#define MET_FIELDS
Definition: tablepg.hxx:91
void ModifyHdl(const weld::MetricSpinButton *pEdit)
Definition: tabledlg.cxx:946
virtual void Reset(const SfxItemSet *rSet) override
Definition: tabledlg.cxx:808
std::unique_ptr< weld::SpinButton > m_xPageNoNF
Definition: tablepg.hxx:155
std::unique_ptr< svx::FrameDirectionListBox > m_xTextDirectionLB
Definition: tablepg.hxx:61
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
void SetWidthPercent(sal_uInt16 nSet)
Definition: swtablerep.hxx:70
weld::Window * GetFrameWeld() const
std::unique_ptr< weld::RadioButton > m_xLeftBtn
Definition: tablepg.hxx:46
void SetShell(SwWrtShell *pSh)
Definition: tabledlg.cxx:1625
weld::Entry & rEdit
std::unique_ptr< weld::CheckButton > m_xHeadLineCB
Definition: tablepg.hxx:159
std::unique_ptr< weld::MetricSpinButton > m_xBottomMF
Definition: tablepg.hxx:59
sal_uInt16 m_nNoOfCols
Definition: tablepg.hxx:101
SwWrtShell * pShell
Definition: tablepg.hxx:143
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
std::unique_ptr< weld::RadioButton > m_xFromLeftBtn
Definition: tablepg.hxx:47
#define FN_TABLE_REP
Definition: cmdid.h:345
void SetVisibleWidth(sal_uInt16 nPos, SwTwips nNewWidth)
Definition: tabledlg.cxx:1199
std::unique_ptr< weld::RadioButton > m_xColBrkRB
Definition: tablepg.hxx:149
virtual void PageCreated(const OString &rId, SfxTabPage &rPage) override
Definition: tabledlg.cxx:1227
virtual ~SwTableColumnPage() override
Definition: tabledlg.cxx:794
virtual ~SwTextFlowPage() override
Definition: tabledlg.cxx:1302
void AddTabPage(const OString &rName, CreateTabPage pCreateFunc, GetTabPageRanges pRangesFunc)
int DenormalizePercent(int nValue)
Definition: prcntfld.cxx:165
static const OUString & GetUIName(const OUString &rName, SwGetPoolIdFromName)
std::unique_ptr< weld::MetricSpinButton > m_xTopMF
Definition: tablepg.hxx:57
#define FN_TABLE_BOX_TEXTORIENTATION
Definition: cmdid.h:428
SwTwips GetVisibleWidth(sal_uInt16 nPos)
Definition: tabledlg.cxx:1181
DeactivateRC
IMPL_LINK(SwFormatTablePage, RelWidthClickHdl, weld::Toggleable &, rBtn, void)
Definition: tabledlg.cxx:149
SwPageDesc * FindPageDescByName(const OUString &rName, bool bGetFromPool=false, size_t *pPos=nullptr)
Definition: fedesc.cxx:131
std::unique_ptr< weld::Label > m_xSpaceSFT
Definition: tablepg.hxx:114
IMPL_LINK_NOARG(SwFormatTablePage, AutoClickHdl, weld::Toggleable &, void)
Definition: tabledlg.cxx:183
bool IsLineSelected() const
Definition: swtablerep.hxx:84
bool bVisible
Definition: swtablerep.hxx:30
std::unique_ptr< weld::Label > m_xWidthFT
Definition: tablepg.hxx:41
std::unique_ptr< weld::CheckButton > m_xProportionalCB
Definition: tablepg.hxx:112
SVXCORE_DLLPUBLIC MSO_SPT Get(const OUString &)
void SetNumOffset(const ::std::optional< sal_uInt16 > &oNum)
Definition: fmtpdsc.hxx:65
void SetMetric(FieldUnit eUnit)
Definition: prcntfld.hxx:50
std::unique_ptr< SwTableRep > m_xOrigTableData
Definition: tablepg.hxx:33
std::unique_ptr< weld::RadioButton > m_xPgBrkAfterRB
Definition: tablepg.hxx:151
virtual void ActivatePage(const SfxItemSet &rSet) override
Definition: tabledlg.cxx:1075
void set_text(const OUString &rStr)
Definition: prcntfld.hxx:56
std::unique_ptr< weld::CheckButton > m_xPgBrkCB
Definition: tablepg.hxx:147
static std::unique_ptr< SfxTabPage > Create(weld::Container *pPage, weld::DialogController *pController, const SfxItemSet *rAttrSet)
Definition: tabledlg.cxx:1306
void SetUpper(const sal_uInt16 nU, const sal_uInt16 nProp=100)
SwTableRep * pTableData
Definition: tablepg.hxx:32
#define FN_TABLE_SET_VERT_ALIGN
Definition: cmdid.h:424
virtual bool FillItemSet(SfxItemSet *rSet) override
Definition: tabledlg.cxx:389
std::unique_ptr< weld::RadioButton > m_xCenterBtn
Definition: tablepg.hxx:49
FrameTypeFlags GetFrameType(const Point *pPt, bool bStopAtFly) const
For return values see above FrameType.
Definition: fews.cxx:237
constexpr TypedWhichId< SvxULSpaceItem > RES_UL_SPACE(92)
std::unique_ptr< weld::RadioButton > m_xRightBtn
Definition: tablepg.hxx:48
const SwTwips lAutoWidth
Definition: tablemgr.hxx:39
static weld::MessageDialog * CreateMessageDialog(weld::Widget *pParent, VclMessageType eMessageType, VclButtonsType eButtonType, const OUString &rPrimaryMessage, bool bMobile=false)
virtual void Reset(const SfxItemSet *rSet) override
Definition: tabledlg.cxx:434
virtual bool FillItemSet(SfxItemSet *rSet) override
Definition: tabledlg.cxx:1312
std::unique_ptr< weld::CheckButton > m_xModifyTableCB
Definition: tablepg.hxx:111
SwTableRep * m_pTableData
Definition: tablepg.hxx:95
ImplSVEvent * m_pSizeHdlEvent
Definition: tablepg.hxx:97
virtual DeactivateRC DeactivatePage(SfxItemSet *pSet) override
Definition: tabledlg.cxx:614
sal_uInt16 nPos
void Init(bool bWeb)
Definition: tabledlg.cxx:858
std::unique_ptr< weld::CheckButton > m_xRelWidthCB
Definition: tablepg.hxx:43
SwTwips m_nTableWidth
Definition: tablepg.hxx:98
std::unique_ptr< weld::Button > m_xUpBtn
Definition: tablepg.hxx:116
OUString sId