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