/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx
Warning:	line 669, column 78 Division by zero

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name tabledlg.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -isystem /usr/include/libxml2 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/sw/inc -I /home/maarten/src/libreoffice/core/sw/source/uibase/inc -I /home/maarten/src/libreoffice/core/sw/source/ui/inc -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/sw/sdi -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/oovbaapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx

/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

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>
26#include <editeng/formatbreakitem.hxx>
27#include <editeng/ulspitem.hxx>
28#include <editeng/frmdiritem.hxx>
29#include <svl/ctloptions.hxx>
30#include <swmodule.hxx>
31#include <fmtpdsc.hxx>
32#include <fmtlsplt.hxx>

34#include <svtools/htmlcfg.hxx>
35#include <fmtrowsplt.hxx>
36#include <sfx2/htmlmode.hxx>
37#include <sfx2/sfxdlg.hxx>

39#include <strings.hrc>
40#include <svx/strings.hrc>
41#include <svx/dialmgr.hxx>

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>

56#include <cmdid.h>
57#include <svx/dialogs.hrc>
58#include <svx/flagsdef.hxx>

60#include <com/sun/star/text/HoriOrientation.hpp>
61#include <com/sun/star/text/VertOrientation.hpp>

63using namespace ::com::sun::star;

65SwFormatTablePage::SwFormatTablePage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/formattablepage.ui", "FormatTablePage", &rSet)
  , pTableData(nullptr)
  , nSaveWidth(0)
  , nMinTableWidth(MINLAY23)
  , bModified(false)
  , bFull(false)
  , bHtmlMode(false)
  , m_xNameED(m_xBuilder->weld_entry("name"))
  , m_xWidthFT(m_xBuilder->weld_label("widthft"))
  , m_xWidthMF(new SwPercentField(m_xBuilder->weld_metric_spin_button("widthmf", FieldUnit::CM)))
  , m_xRelWidthCB(m_xBuilder->weld_check_button("relwidth"))
  , m_xFullBtn(m_xBuilder->weld_radio_button("full"))
  , m_xLeftBtn(m_xBuilder->weld_radio_button("left"))
  , m_xFromLeftBtn(m_xBuilder->weld_radio_button("fromleft"))
  , m_xRightBtn(m_xBuilder->weld_radio_button("right"))
  , m_xCenterBtn(m_xBuilder->weld_radio_button("center"))
  , m_xFreeBtn(m_xBuilder->weld_radio_button("free"))
  , m_xLeftFT(m_xBuilder->weld_label("leftft"))
  , m_xLeftMF(new SwPercentField(m_xBuilder->weld_metric_spin_button("leftmf", FieldUnit::CM)))
  , m_xRightFT(m_xBuilder->weld_label("rightft"))
  , m_xRightMF(new SwPercentField(m_xBuilder->weld_metric_spin_button("rightmf", FieldUnit::CM)))
  , m_xTopFT(m_xBuilder->weld_label("aboveft"))
  , m_xTopMF(m_xBuilder->weld_metric_spin_button("abovemf", FieldUnit::CM))
  , m_xBottomFT(m_xBuilder->weld_label("belowft"))
  , m_xBottomMF(m_xBuilder->weld_metric_spin_button("belowmf", FieldUnit::CM))
  , m_xTextDirectionLB(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("textdirection")))
  , m_xProperties(m_xBuilder->weld_widget("properties"))
93{
  m_xWidthMF->GetMetricFieldRange(m_nOrigWidthMin, m_nOrigWidthMax);
  m_xLeftMF->GetMetricFieldRange(m_nOrigLeftMin, m_nOrigLeftMax);
  m_xRightMF->GetMetricFieldRange(m_nOrigRightMin, m_nOrigRightMax);

  //lock these to initial sizes so they don't change on percent to non percent change
  Size aPrefSize(m_xLeftMF->get()->get_preferred_size());
  m_xLeftMF->get()->set_size_request(aPrefSize.Width(), aPrefSize.Height());
  m_xRightMF->get()->set_size_request(aPrefSize.Width(), aPrefSize.Height());
  m_xWidthMF->get()->set_size_request(aPrefSize.Width(), aPrefSize.Height());

  m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTRreinterpret_cast<char const *>("RID_SVXSTR_FRAMEDIR_LTR"
 "\004" u8"Left-to-right (LTR)")));
  m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTLreinterpret_cast<char const *>("RID_SVXSTR_FRAMEDIR_RTL"
 "\004" u8"Right-to-left (RTL)")));
  m_xTextDirectionLB->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPERreinterpret_cast<char const *>("RID_SVXSTR_FRAMEDIR_SUPER"
 "\004" u8"Use superordinate object settings")));

  SetExchangeSupport();

  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rSet.GetItemState(SID_HTML_MODE(10000 + 414), false, &pItem))
      bHtmlMode = 0 != (static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON);

  bool bCTL = SW_MOD()( static_cast<SwModule*>(SfxApplication::GetModule(SfxToolsModule
::Writer)))->GetCTLOptions().IsCTLFontEnabled();
  m_xProperties->set_visible(!bHtmlMode && bCTL);

  Init();
118}

120SwFormatTablePage::~SwFormatTablePage()
121{
122}

124void  SwFormatTablePage::Init()
125{
  m_xLeftMF->SetMetricFieldMin(-999999);
  m_xRightMF->SetMetricFieldMin(-999999);

  //handler
  Link<weld::ToggleButton&,void> aLk2 = LINK( this, SwFormatTablePage, AutoClickHdl )::tools::detail::makeLink( ::tools::detail::castTo<SwFormatTablePage
 *>(this), &SwFormatTablePage::LinkStubAutoClickHdl);
  m_xFullBtn->connect_toggled( aLk2 );
  m_xFreeBtn->connect_toggled( aLk2 );
  m_xLeftBtn->connect_toggled( aLk2 );
  m_xFromLeftBtn->connect_toggled( aLk2 );
  m_xRightBtn->connect_toggled( aLk2 );
  m_xCenterBtn->connect_toggled( aLk2 );

  Link<weld::MetricSpinButton&,void> aLk = LINK(this, SwFormatTablePage, ValueChangedHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwFormatTablePage
 *>(this), &SwFormatTablePage::LinkStubValueChangedHdl
);
  m_xTopMF->connect_value_changed(aLk);
  m_xBottomMF->connect_value_changed(aLk);
  m_xRightMF->connect_value_changed(aLk);
  m_xLeftMF->connect_value_changed(aLk);
  m_xWidthMF->connect_value_changed(aLk);

  m_xRelWidthCB->connect_toggled(LINK( this, SwFormatTablePage, RelWidthClickHdl )::tools::detail::makeLink( ::tools::detail::castTo<SwFormatTablePage
 *>(this), &SwFormatTablePage::LinkStubRelWidthClickHdl
));
146}

148IMPL_LINK( SwFormatTablePage, RelWidthClickHdl, weld::ToggleButton&, rBtn, void )void SwFormatTablePage::LinkStubRelWidthClickHdl(void * instance
, weld::ToggleButton& data) { return static_cast<SwFormatTablePage
 *>(instance)->RelWidthClickHdl(data); } void SwFormatTablePage
::RelWidthClickHdl(weld::ToggleButton& rBtn)
149{
  OSL_ENSURE(pTableData, "table data not available?")do { if (true && (!(pTableData))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "150" ": "), "%s", "table data not available?"); } } while
 (false);
  bool bIsChecked = rBtn.get_active();
  sal_Int64 nLeft  = m_xLeftMF->DenormalizePercent(m_xLeftMF->get_value(FieldUnit::TWIP));
  sal_Int64 nRight = m_xRightMF->DenormalizePercent(m_xRightMF->get_value(FieldUnit::TWIP));
  m_xWidthMF->ShowPercent(bIsChecked);
  m_xLeftMF->ShowPercent(bIsChecked);
  m_xRightMF->ShowPercent(bIsChecked);

  if (bIsChecked)
  {
      m_xWidthMF->SetRefValue(pTableData->GetSpace());
      m_xLeftMF->SetRefValue(pTableData->GetSpace());
      m_xRightMF->SetRefValue(pTableData->GetSpace());
      m_xLeftMF->SetMetricFieldMin(0); //will be overwritten by the Percentfield
      m_xRightMF->SetMetricFieldMin(0); //ditto
      m_xLeftMF->SetMetricFieldMax(99);
      m_xRightMF->SetMetricFieldMax(99);
      m_xLeftMF->set_value(m_xLeftMF->NormalizePercent(nLeft ), FieldUnit::TWIP );
      m_xRightMF->set_value(m_xRightMF->NormalizePercent(nRight ), FieldUnit::TWIP );
  }
  else
      ModifyHdl(*m_xLeftMF->get());    //correct values again

  if (m_xFreeBtn->get_active())
  {
      bool bEnable = !rBtn.get_active();
      m_xRightMF->set_sensitive(bEnable);
      m_xRightFT->set_sensitive(bEnable);
  }
  bModified = true;
180}

182IMPL_LINK_NOARG(SwFormatTablePage, AutoClickHdl, weld::ToggleButton&, void)void SwFormatTablePage::LinkStubAutoClickHdl(void * instance,
 weld::ToggleButton& data) { return static_cast<SwFormatTablePage
 *>(instance)->AutoClickHdl(data); } void SwFormatTablePage
::AutoClickHdl(__attribute__ ((unused)) weld::ToggleButton&
)
183{
  bool bRestore = true,
       bLeftEnable = false,
       bRightEnable= false,
       bWidthEnable= false,
       bOthers = true;
  if (m_xFullBtn->get_active())
  {
      m_xLeftMF->set_value(0);
      m_xRightMF->set_value(0);
      nSaveWidth = static_cast<SwTwips>(m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)));
      m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(pTableData->GetSpace()), FieldUnit::TWIP);
      bFull = true;
      bRestore = false;
  }
  else if (m_xLeftBtn->get_active())
  {
      bRightEnable = bWidthEnable = true;
      m_xLeftMF->set_value(0);
  }
  else if (m_xFromLeftBtn->get_active())
  {
      bLeftEnable = bWidthEnable = true;
      m_xRightMF->set_value(0);
  }
  else if (m_xRightBtn->get_active())
  {
      bLeftEnable = bWidthEnable = true;
      m_xRightMF->set_value(0);
  }
  else if (m_xCenterBtn->get_active())
  {
      bLeftEnable = bWidthEnable = true;
  }
  else if (m_xFreeBtn->get_active())
  {
      RightModify();
      bLeftEnable = true;
      bWidthEnable = true;
      bOthers = false;
  }
  m_xLeftMF->set_sensitive(bLeftEnable);
  m_xLeftFT->set_sensitive(bLeftEnable);
  m_xWidthMF->set_sensitive(bWidthEnable);
  m_xWidthFT->set_sensitive(bWidthEnable);
  if ( bOthers )
  {
      m_xRightMF->set_sensitive(bRightEnable);
      m_xRightFT->set_sensitive(bRightEnable);
      m_xRelWidthCB->set_sensitive(bWidthEnable);
  }

  if(bFull && bRestore)
  {
      //After being switched on automatic, the width was pinned
      //in order to restore the width while switching back to.
      bFull = false;
      m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(nSaveWidth ), FieldUnit::TWIP );
  }
  ModifyHdl(*m_xWidthMF->get());
  bModified = true;
244}

246void SwFormatTablePage::RightModify()
247{
  if (!m_xFreeBtn->get_active())
      return;

  bool bEnable = m_xRightMF->get_value() == 0;
  m_xRelWidthCB->set_sensitive(bEnable);
  if ( !bEnable )
  {
      m_xRelWidthCB->set_active(false);
      RelWidthClickHdl(*m_xRelWidthCB);
  }
  bEnable = m_xRelWidthCB->get_active();
  m_xRightMF->set_sensitive(!bEnable);
  m_xRightFT->set_sensitive(!bEnable);
261}

263IMPL_LINK( SwFormatTablePage, ValueChangedHdl, weld::MetricSpinButton&, rEdit, void )void SwFormatTablePage::LinkStubValueChangedHdl(void * instance
, weld::MetricSpinButton& data) { return static_cast<SwFormatTablePage
 *>(instance)->ValueChangedHdl(data); } void SwFormatTablePage
::ValueChangedHdl(weld::MetricSpinButton& rEdit)
264{
  if (m_xRightMF->get() == &rEdit)
      RightModify();
  ModifyHdl(rEdit);
268}

270void  SwFormatTablePage::ModifyHdl(const weld::MetricSpinButton& rEdit, bool bAllowInconsistencies)
271{
  SwTwips nCurWidth  = static_cast< SwTwips >(m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)));
  SwTwips nPrevWidth = nCurWidth;
  SwTwips nRight = static_cast< SwTwips >(m_xRightMF->DenormalizePercent(m_xRightMF->get_value(FieldUnit::TWIP)));
  SwTwips nLeft  = static_cast< SwTwips >(m_xLeftMF->DenormalizePercent(m_xLeftMF->get_value(FieldUnit::TWIP)));
  SwTwips nDiff;

  if (&rEdit == m_xWidthMF->get())
  {
      if( nCurWidth < MINLAY23 )
          nCurWidth = MINLAY23;
      nDiff = nRight + nLeft + nCurWidth - pTableData->GetSpace() ;
      //right aligned: only change the left margin
      if (m_xRightBtn->get_active())
          nLeft -= nDiff;
      //left aligned: only change the right margin
      else if(m_xLeftBtn->get_active())
          nRight -= nDiff;
      //left margin and width allowed - first right - then left
      else if (m_xFromLeftBtn->get_active())
      {
          if( nRight >= nDiff )
              nRight -= nDiff;
          else
          {
              nDiff -= nRight;
              nRight = 0;
              if(nLeft >= nDiff)
                  nLeft -= nDiff;
              else
              {
                  nRight += nLeft - nDiff;
                  nLeft = 0;
                  nCurWidth = pTableData->GetSpace();
              }
          }
      }
      //centered: change both sides equally
      else if (m_xCenterBtn->get_active())
      {
          if(nLeft != nRight)
          {
              nDiff += nLeft + nRight;
              nLeft = nDiff/2;
              nRight = nDiff/2;
          }
          else
          {
                  nLeft -= nDiff/2;
                  nRight -= nDiff/2;
          }
      }
      //free alignment: decrease both margins
      else if (m_xFreeBtn->get_active())
      {
          nLeft -= nDiff/2;
          nRight -= nDiff/2;
      }
  }
  if (&rEdit == m_xRightMF->get())
  {

      if( nRight + nLeft > pTableData->GetSpace() - MINLAY23 )
          nRight = pTableData->GetSpace() -nLeft - MINLAY23;

      nCurWidth = pTableData->GetSpace() - nLeft - nRight;
  }
  if (&rEdit == m_xLeftMF->get())
  {
      if(!m_xFromLeftBtn->get_active())
      {
          bool bCenter = m_xCenterBtn->get_active();
          if( bCenter )
              nRight = nLeft;
          if(nRight + nLeft > pTableData->GetSpace() - MINLAY23 )
          {
              nLeft  = bCenter ?  (pTableData->GetSpace() - MINLAY23) /2 :
                                  (pTableData->GetSpace() - MINLAY23) - nRight;
              nRight = bCenter ?  (pTableData->GetSpace() - MINLAY23) /2 : nRight;
          }
          nCurWidth = pTableData->GetSpace() - nLeft - nRight;
      }
      else
      {
          //Upon changes on the left side the right margin will be changed at first,
          //thereafter the width.
          nDiff = nRight + nLeft + nCurWidth - pTableData->GetSpace() ;

          nRight -= nDiff;
          nCurWidth = pTableData->GetSpace() - nLeft - nRight;
      }
  }

  m_xRightMF->set_value( m_xRightMF->NormalizePercent( nRight ), FieldUnit::TWIP );
  m_xLeftMF->set_value( m_xLeftMF->NormalizePercent( nLeft ), FieldUnit::TWIP );

  if (nCurWidth != nPrevWidth )
  {
      m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(nCurWidth), FieldUnit::TWIP);

      // tdf#135021 if the user changed the width spinbutton, and in this
      // ModifyHdl we changed the value of that width spinbutton, then rerun
      // the ModifyHdl on the replaced value so the left/right/width value
      // relationships are consistent.
      // But (tdf#135693) only make one effort of rectifying the inconsistency
      if (&rEdit == m_xWidthMF->get() && !bAllowInconsistencies)
          ModifyHdl(rEdit, true);
  }

  bModified = true;
381}

383std::unique_ptr<SfxTabPage> SwFormatTablePage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet)
384{
  return std::make_unique<SwFormatTablePage>(pPage, pController, *rAttrSet);
386}

388bool  SwFormatTablePage::FillItemSet( SfxItemSet* rCoreSet )
389{
  //Test if one of the controls still has the focus
  if (m_xWidthMF->has_focus())
      ModifyHdl(*m_xWidthMF->get());
  else if (m_xLeftMF->has_focus())
      ModifyHdl(*m_xLeftMF->get());
  else if (m_xRightMF->has_focus())
      ModifyHdl(*m_xRightMF->get());
  else if (m_xTopMF->has_focus())
      ModifyHdl(*m_xTopMF);
  else if (m_xBottomMF->has_focus())
      ModifyHdl(*m_xBottomMF);

  if (bModified)
  {
      if (m_xBottomMF->get_value_changed_from_saved() ||
          m_xTopMF->get_value_changed_from_saved() )
      {
          SvxULSpaceItem aULSpace(RES_UL_SPACE);
          aULSpace.SetUpper(m_xTopMF->denormalize(m_xTopMF->get_value(FieldUnit::TWIP)));
          aULSpace.SetLower(m_xBottomMF->denormalize(m_xBottomMF->get_value(FieldUnit::TWIP)));
          rCoreSet->Put(aULSpace);
      }

  }
  if (m_xNameED->get_value_changed_from_saved())
  {
      rCoreSet->Put(SfxStringItem(FN_PARAM_TABLE_NAME((20000 + 1100)+44), m_xNameED->get_text()));
      bModified = true;
  }

  if (m_xTextDirectionLB->get_visible())
  {
      if (m_xTextDirectionLB->get_value_changed_from_saved())
      {
          SvxFrameDirection nDirection = m_xTextDirectionLB->get_active_id();
          rCoreSet->Put(SvxFrameDirectionItem(nDirection, RES_FRAMEDIR));
          bModified = true;
      }
  }

  return bModified;
431}

433void  SwFormatTablePage::Reset( const SfxItemSet* )
434{
  const SfxItemSet& rSet = GetItemSet();
  const SfxPoolItem*  pItem;

  if(bHtmlMode)
  {
      m_xNameED->set_sensitive(false);
      m_xTopFT->hide();
      m_xTopMF->hide();
      m_xBottomFT->hide();
      m_xBottomMF->hide();
      m_xFreeBtn->set_sensitive(false);
  }

  // set back to original state
  m_xRelWidthCB->set_active(false);
  m_xWidthMF->ShowPercent(false);
  m_xLeftMF->ShowPercent(false);
  m_xRightMF->ShowPercent(false);
  m_xWidthMF->SetMetricFieldRange(m_nOrigWidthMin, m_nOrigWidthMax);
  m_xLeftMF->SetMetricFieldRange(m_nOrigLeftMin, m_nOrigLeftMax);
  m_xRightMF->SetMetricFieldRange(m_nOrigRightMin, m_nOrigRightMax);

  FieldUnit aMetric = ::GetDfltMetric(bHtmlMode);
  m_xWidthMF->SetMetric(aMetric);
  m_xRightMF->SetMetric(aMetric);
  m_xLeftMF->SetMetric(aMetric);
  SetFieldUnit(*m_xTopMF, aMetric);
  SetFieldUnit(*m_xBottomMF, aMetric);

  //Name
  if(SfxItemState::SET == rSet.GetItemState( FN_PARAM_TABLE_NAME((20000 + 1100)+44), false, &pItem ))
  {
      m_xNameED->set_text(static_cast<const SfxStringItem*>(pItem)->GetValue());
      m_xNameED->save_value();
  }

  if(SfxItemState::SET == rSet.GetItemState( FN_TABLE_REP((20000 + 400) + 99), false, &pItem ))
  {
      pTableData = static_cast<SwTableRep*>(static_cast<const SwPtrItem*>( pItem)->GetValue());
      if (!m_xOrigTableData)
          m_xOrigTableData.reset(new SwTableRep(*pTableData));
      else // tdf#134925 and tdf#134913, reset back to the original data seen on dialog creation
          *pTableData = *m_xOrigTableData;

      nMinTableWidth = pTableData->GetColCount() * MINLAY23;

      if(pTableData->GetWidthPercent())
      {
          m_xRelWidthCB->set_active(true);
          RelWidthClickHdl(*m_xRelWidthCB);
          m_xWidthMF->set_value(pTableData->GetWidthPercent(), FieldUnit::PERCENT);

          m_xWidthMF->save_value();
          nSaveWidth = static_cast< SwTwips >(m_xWidthMF->get_value(FieldUnit::PERCENT));
      }
      else
      {
          m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(
                  pTableData->GetWidth()), FieldUnit::TWIP);
          m_xWidthMF->save_value();
          nSaveWidth = pTableData->GetWidth();
          nMinTableWidth = std::min( nSaveWidth, nMinTableWidth );
      }

      m_xWidthMF->SetRefValue(pTableData->GetSpace());

      m_xLeftMF->set_value(m_xLeftMF->NormalizePercent(
                  pTableData->GetLeftSpace()), FieldUnit::TWIP);
      m_xRightMF->set_value(m_xRightMF->NormalizePercent(
                  pTableData->GetRightSpace()), FieldUnit::TWIP);
      m_xLeftMF->save_value();
      m_xRightMF->save_value();

      bool bSetRight = false, bSetLeft = false;
      switch( pTableData->GetAlign() )
      {
          case text::HoriOrientation::NONE:
              m_xFreeBtn->set_active(true);
              if (m_xRelWidthCB->get_active())
                  bSetRight = true;
          break;
          case text::HoriOrientation::FULL:
          {
              bSetRight = bSetLeft = true;
              m_xFullBtn->set_active(true);
              m_xWidthMF->set_sensitive(false);
              m_xRelWidthCB->set_sensitive(false);
              m_xWidthFT->set_sensitive(false);
          }
          break;
          case text::HoriOrientation::LEFT:
          {
              bSetLeft = true;
              m_xLeftBtn->set_active(true);
          }
          break;
          case text::HoriOrientation::LEFT_AND_WIDTH :
          {
              bSetRight = true;
              m_xFromLeftBtn->set_active(true);
          }
          break;
          case text::HoriOrientation::RIGHT:
          {
              bSetRight = true;
              m_xRightBtn->set_active(true);
          }
          break;
          case text::HoriOrientation::CENTER:
          {
              bSetRight = true;
              m_xCenterBtn->set_active(true);
          }
          break;
      }
      if ( bSetRight )
      {
          m_xRightMF->set_sensitive(false);
          m_xRightFT->set_sensitive(false);
      }
      if ( bSetLeft )
      {
          m_xLeftMF->set_sensitive(false);
          m_xLeftFT->set_sensitive(false);
      }

  }

  //Margins
  if(SfxItemState::SET == rSet.GetItemState( RES_UL_SPACE, false,&pItem ))
  {
      m_xTopMF->set_value(m_xTopMF->normalize(
                      static_cast<const SvxULSpaceItem*>(pItem)->GetUpper()), FieldUnit::TWIP);
      m_xBottomMF->set_value(m_xBottomMF->normalize(
                      static_cast<const SvxULSpaceItem*>(pItem)->GetLower()), FieldUnit::TWIP);
      m_xTopMF->save_value();
      m_xBottomMF->save_value();
  }

  //Text direction
  if( SfxItemState::SET == rSet.GetItemState( RES_FRAMEDIR, true, &pItem ) )
  {
      SvxFrameDirection nVal = static_cast<const SvxFrameDirectionItem*>(pItem)->GetValue();
      m_xTextDirectionLB->set_active_id(nVal);
      m_xTextDirectionLB->save_value();
  }

  m_xWidthMF->set_max( 2*m_xWidthMF->NormalizePercent( pTableData->GetSpace() ), FieldUnit::TWIP );
  m_xRightMF->set_max( m_xRightMF->NormalizePercent( pTableData->GetSpace() ), FieldUnit::TWIP );
  m_xLeftMF->set_max( m_xLeftMF->NormalizePercent( pTableData->GetSpace() ), FieldUnit::TWIP );
  m_xWidthMF->set_min( m_xWidthMF->NormalizePercent( nMinTableWidth ), FieldUnit::TWIP );
586}

588void    SwFormatTablePage::ActivatePage( const SfxItemSet& rSet )
589{
  OSL_ENSURE(pTableData, "table data not available?")do { if (true && (!(pTableData))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "590" ": "), "%s", "table data not available?"); } } while
 (false);
  if(SfxItemState::SET != rSet.GetItemState( FN_TABLE_REP((20000 + 400) + 99) ))
      return;

  SwTwips nCurWidth = text::HoriOrientation::FULL != pTableData->GetAlign() ?
                                  pTableData->GetWidth() :
                                      pTableData->GetSpace();
  if(pTableData->GetWidthPercent() != 0 ||
     nCurWidth == m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)))
      return;

  m_xWidthMF->set_value(m_xWidthMF->NormalizePercent(
                  nCurWidth), FieldUnit::TWIP);
  m_xWidthMF->save_value();
  nSaveWidth = nCurWidth;
  m_xLeftMF->set_value(m_xLeftMF->NormalizePercent(
                  pTableData->GetLeftSpace()), FieldUnit::TWIP);
  m_xLeftMF->save_value();
  m_xRightMF->set_value(m_xRightMF->NormalizePercent(
                  pTableData->GetRightSpace()), FieldUnit::TWIP);
  m_xRightMF->save_value();
611}

613DeactivateRC SwFormatTablePage::DeactivatePage( SfxItemSet* _pSet )
614{
  //test the table name for spaces
  OUString sTableName = m_xNameED->get_text();
  if(sTableName.indexOf(' ') != -1)
1
Assuming the condition is false→
2
←
Taking false branch→
  {
      std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetFrameWeld(),
                                                    VclMessageType::Info, VclButtonsType::Ok,
                                                    SwResId(STR_WRONG_TABLENAMEreinterpret_cast<char const *>("STR_WRONG_TABLENAME" "\004"
 u8"The name of the table must not contain spaces."))));
      xInfoBox->run();
      m_xNameED->grab_focus();
      return DeactivateRC::KeepPage;
  }
  if(_pSet)
3
←
Assuming '_pSet' is non-null→
4
←
Taking true branch→
  {
      FillItemSet(_pSet);
      if(bModified)
5
←
Assuming field 'bModified' is true→
6
←
Taking true branch→
      {
          SwTwips lLeft  = static_cast< SwTwips >(m_xLeftMF->DenormalizePercent(m_xLeftMF->get_value(FieldUnit::TWIP)));
          SwTwips lRight = static_cast< SwTwips >(m_xRightMF->DenormalizePercent(m_xRightMF->get_value(FieldUnit::TWIP)));

          if( m_xLeftMF->get_value_changed_from_saved() ||
              m_xRightMF->get_value_changed_from_saved() )
          {
              pTableData->SetWidthChanged();
              pTableData->SetLeftSpace( lLeft);
              pTableData->SetRightSpace( lRight);
          }

          SwTwips lWidth;
          if (m_xRelWidthCB->get_active() && m_xRelWidthCB->get_sensitive())
7
←
Assuming the condition is false→
          {
              lWidth = pTableData->GetSpace() - lRight - lLeft;
              const sal_uInt16 nPercentWidth = m_xWidthMF->get_value(FieldUnit::PERCENT);
              if(pTableData->GetWidthPercent() != nPercentWidth)
              {
                  pTableData->SetWidthPercent(nPercentWidth);
                  pTableData->SetWidthChanged();
              }
          }
          else
          {
              pTableData->SetWidthPercent(0);
              lWidth = static_cast<SwTwips>(m_xWidthMF->DenormalizePercent(m_xWidthMF->get_value(FieldUnit::TWIP)));
          }
          pTableData->SetWidth(lWidth);

          SwTwips nColSum = 0;

          for( sal_uInt16 i = 0; i < pTableData->GetColCount(); i++)
8
←
Assuming the condition is false→
9
←
Loop condition is false. Execution continues on line 666→
          {
              nColSum += pTableData->GetColumns()[i].nWidth;
          }
          if(nColSum != pTableData->GetWidth())
10
←
Assuming the condition is true→
11
←
Taking true branch→
          {
              SwTwips nMinWidth = std::min( long(MINLAY23),
                                  static_cast<long>(pTableData->GetWidth() /
15
←
Division by zero
                                          pTableData->GetColCount() - 1));
12
←
Calling 'SwTableRep::GetColCount'→
14
←
Returning from 'SwTableRep::GetColCount'→
              SwTwips nDiff = nColSum - pTableData->GetWidth();
              while ( std::abs(nDiff) > pTableData->GetColCount() + 1 )
              {
                  SwTwips nSub = nDiff / pTableData->GetColCount();
                  for( sal_uInt16 i = 0; i < pTableData->GetColCount(); i++)
                  {
                      if(pTableData->GetColumns()[i].nWidth - nMinWidth > nSub)
                      {
                          pTableData->GetColumns()[i].nWidth -= nSub;
                          nDiff -= nSub;
                      }
                      else
                      {
                          nDiff -= pTableData->GetColumns()[i].nWidth - nMinWidth;
                          pTableData->GetColumns()[i].nWidth = nMinWidth;
                      }

                  }
              }
          }

          sal_Int16 nAlign = 0;
          if (m_xRightBtn->get_active())
              nAlign = text::HoriOrientation::RIGHT;
          else if(m_xLeftBtn->get_active())
              nAlign = text::HoriOrientation::LEFT;
          else if(m_xFromLeftBtn->get_active())
              nAlign = text::HoriOrientation::LEFT_AND_WIDTH;
          else if(m_xCenterBtn->get_active())
              nAlign = text::HoriOrientation::CENTER;
          else if(m_xFreeBtn->get_active())
              nAlign = text::HoriOrientation::NONE;
          else if(m_xFullBtn->get_active())
          {
              nAlign = text::HoriOrientation::FULL;
              lWidth = lAutoWidth;
          }
          if(nAlign != pTableData->GetAlign())
          {
              pTableData->SetWidthChanged();
              pTableData->SetAlign(nAlign);
          }

          if(pTableData->GetWidth() != lWidth )
          {
              pTableData->SetWidthChanged();
              pTableData->SetWidth(
                  nAlign == text::HoriOrientation::FULL ? pTableData->GetSpace() : lWidth );
          }
          if(pTableData->HasWidthChanged())
              _pSet->Put(SwPtrItem(FN_TABLE_REP((20000 + 400) + 99), pTableData));
      }
  }
  return DeactivateRC::LeavePage;
725}

727//Description: Page column configuration
728SwTableColumnPage::SwTableColumnPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/tablecolumnpage.ui", "TableColumnPage", &rSet)
  , m_pTableData(nullptr)
  , m_pSizeHdlEvent(nullptr)
  , m_nTableWidth(0)
  , m_nMinWidth(MINLAY23)
  , m_nMetFields(MET_FIELDS6)
  , m_nNoOfCols(0)
  , m_nNoOfVisibleCols(0)
  , m_bModified(false)
  , m_bModifyTable(false)
  , m_bPercentMode(false)
  , m_aFieldArr { m_xBuilder->weld_metric_spin_button("width1", FieldUnit::CM),
                  m_xBuilder->weld_metric_spin_button("width2", FieldUnit::CM),
                  m_xBuilder->weld_metric_spin_button("width3", FieldUnit::CM),
                  m_xBuilder->weld_metric_spin_button("width4", FieldUnit::CM),
                  m_xBuilder->weld_metric_spin_button("width5", FieldUnit::CM),
                  m_xBuilder->weld_metric_spin_button("width6", FieldUnit::CM) }
  , m_aTextArr { m_xBuilder->weld_label("1"),
                 m_xBuilder->weld_label("2"),
                 m_xBuilder->weld_label("3"),
                 m_xBuilder->weld_label("4"),
                 m_xBuilder->weld_label("5"),
                 m_xBuilder->weld_label("6") }
  , m_xModifyTableCB(m_xBuilder->weld_check_button("adaptwidth"))
  , m_xProportionalCB(m_xBuilder->weld_check_button("adaptcolumns"))
  , m_xSpaceFT(m_xBuilder->weld_label("spaceft"))
  , m_xSpaceSFT(m_xBuilder->weld_label("space"))
  , m_xSpaceED(m_xBuilder->weld_metric_spin_button("spacefmt", FieldUnit::CM))
  , m_xUpBtn(m_xBuilder->weld_button("next"))
  , m_xDownBtn(m_xBuilder->weld_button("back"))
759{
  SetExchangeSupport();

  // fire off this handler to happen on next event loop when all the rest of
  // the pages are instantiated and the dialog preferred size is that of the
  // all the pages that currently exist and the rest to come after this one
  m_pSizeHdlEvent = Application::PostUserEvent(LINK(this, SwTableColumnPage, SizeHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwTableColumnPage
 *>(this), &SwTableColumnPage::LinkStubSizeHdl));

  const SfxPoolItem* pItem;
  Init(SfxItemState::SET == GetItemSet().GetItemState(SID_HTML_MODE(10000 + 414), false, &pItem)
       && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON);
770}

772IMPL_LINK_NOARG(SwTableColumnPage, SizeHdl, void*, void)void SwTableColumnPage::LinkStubSizeHdl(void * instance, void
* data) { return static_cast<SwTableColumnPage *>(instance
)->SizeHdl(data); } void SwTableColumnPage::SizeHdl(__attribute__
 ((unused)) void*)
773{
  m_pSizeHdlEvent = nullptr;

  //tdf#120420 keeping showing column width fields unless
  //the dialog begins to grow, then stop adding them
  weld::Window* pTopLevel = GetFrameWeld();
  Size aOrigSize = pTopLevel->get_preferred_size();
  for (sal_uInt16 i = 0; i < MET_FIELDS6; ++i)
  {
      m_aFieldArr[i].show();
      m_aTextArr[i]->show();

      if (pTopLevel->get_preferred_size().Width() > aOrigSize.Width())
      {
          m_nMetFields = i + 1;
          m_aTextArr[i]->set_grid_width(1);
          m_xUpBtn->set_grid_left_attach(m_nMetFields * 2 - 1);
          break;
      }
  }
793}

795SwTableColumnPage::~SwTableColumnPage()
796{
  if (m_pSizeHdlEvent)
  {
      Application::RemoveUserEvent(m_pSizeHdlEvent);
      m_pSizeHdlEvent = nullptr;
  }
802}

804std::unique_ptr<SfxTabPage> SwTableColumnPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet)
805{
  return std::make_unique<SwTableColumnPage>(pPage, pController, *rAttrSet);
807}

809void  SwTableColumnPage::Reset( const SfxItemSet* )
810{
  const SfxItemSet& rSet = GetItemSet();

  const SfxPoolItem* pItem;
  if(SfxItemState::SET == rSet.GetItemState( FN_TABLE_REP((20000 + 400) + 99), false, &pItem ))
  {
      m_pTableData = static_cast<SwTableRep*>(static_cast<const SwPtrItem*>( pItem)->GetValue());
      if (!m_xOrigTableData)
          m_xOrigTableData.reset(new SwTableRep(*m_pTableData));
      else // tdf#134925 and tdf#134913, reset back to the original data seen on dialog creation
          *m_pTableData = *m_xOrigTableData;

      m_nNoOfVisibleCols = m_pTableData->GetColCount();
      m_nNoOfCols = m_pTableData->GetAllColCount();
      m_nTableWidth = m_pTableData->GetAlign() != text::HoriOrientation::FULL &&
                          m_pTableData->GetAlign() != text::HoriOrientation::LEFT_AND_WIDTH?
                      m_pTableData->GetWidth() : m_pTableData->GetSpace();

      for( sal_uInt16 i = 0; i < m_nNoOfCols; i++ )
      {
          if (m_pTableData->GetColumns()[i].nWidth  < m_nMinWidth)
              m_nMinWidth = m_pTableData->GetColumns()[i].nWidth;
      }
      sal_Int64 nMinTwips = m_aFieldArr[0].NormalizePercent( m_nMinWidth );
      sal_Int64 nMaxTwips = m_aFieldArr[0].NormalizePercent( m_nTableWidth );
      for( sal_uInt16 i = 0; (i < m_nMetFields) && (i < m_nNoOfVisibleCols); i++ )
      {
          m_aFieldArr[i].set_value( m_aFieldArr[i].NormalizePercent(
                                              GetVisibleWidth(i) ), FieldUnit::TWIP );
          m_aFieldArr[i].set_min(nMinTwips, FieldUnit::TWIP);
          m_aFieldArr[i].set_max(nMaxTwips, FieldUnit::TWIP);
          m_aFieldArr[i].set_sensitive(true);
          m_aTextArr[i]->set_sensitive(true);
      }

      if (m_nNoOfVisibleCols > m_nMetFields)
      {
          m_xUpBtn->set_sensitive(true);
      }

      for( sal_uInt16 i = m_nNoOfVisibleCols; i < m_nMetFields; ++i )
      {
          m_aFieldArr[i].set_text(OUString());
          m_aTextArr[i]->set_sensitive(false);
      }
  }
  ActivatePage(rSet);
857}

859void  SwTableColumnPage::Init(bool bWeb)
860{
  FieldUnit aMetric = ::GetDfltMetric(bWeb);
  Link<weld::MetricSpinButton&,void> aLk = LINK(this, SwTableColumnPage, ValueChangedHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwTableColumnPage
 *>(this), &SwTableColumnPage::LinkStubValueChangedHdl
);
  for (sal_uInt16 i = 0; i < MET_FIELDS6; ++i)
  {
      m_aValueTable[i] = i;
      m_aFieldArr[i].SetMetric(aMetric);
      m_aFieldArr[i].connect_value_changed(aLk);
  }
  SetFieldUnit(*m_xSpaceED, aMetric);

  Link<weld::Button&,void> aClickLk = LINK(this, SwTableColumnPage, AutoClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwTableColumnPage
 *>(this), &SwTableColumnPage::LinkStubAutoClickHdl);
  m_xUpBtn->connect_clicked(aClickLk);
  m_xDownBtn->connect_clicked(aClickLk);

  Link<weld::ToggleButton&,void> aToggleLk = LINK(this, SwTableColumnPage, ModeHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwTableColumnPage
 *>(this), &SwTableColumnPage::LinkStubModeHdl);
  m_xModifyTableCB->connect_toggled(aToggleLk);
  m_xProportionalCB->connect_toggled(aToggleLk);
878}

880IMPL_LINK(SwTableColumnPage, AutoClickHdl, weld::Button&, rControl, void)void SwTableColumnPage::LinkStubAutoClickHdl(void * instance,
 weld::Button& data) { return static_cast<SwTableColumnPage
 *>(instance)->AutoClickHdl(data); } void SwTableColumnPage
::AutoClickHdl(weld::Button& rControl)
881{
  //move display window
  if (&rControl == m_xDownBtn.get())
  {
      if(m_aValueTable[0] > 0)
      {
          for(sal_uInt16 & rn : m_aValueTable)
              rn -= 1;
      }
  }
  if (&rControl == m_xUpBtn.get())
  {
      if( m_aValueTable[ m_nMetFields -1 ] < m_nNoOfVisibleCols -1  )
      {
          for(sal_uInt16 & rn : m_aValueTable)
              rn += 1;
      }
  }
  for( sal_uInt16 i = 0; (i < m_nNoOfVisibleCols ) && ( i < m_nMetFields); i++ )
  {
      OUString sEntry('~');
      OUString sIndex = OUString::number( m_aValueTable[i] + 1 );
      sEntry += sIndex;
      m_aTextArr[i]->set_label(sEntry);
  }

  m_xDownBtn->set_sensitive(m_aValueTable[0] > 0);
  m_xUpBtn->set_sensitive(m_aValueTable[ m_nMetFields -1 ] < m_nNoOfVisibleCols -1 );
  UpdateCols(0);
910}

912IMPL_LINK(SwTableColumnPage, ValueChangedHdl, weld::MetricSpinButton&, rEdit, void)void SwTableColumnPage::LinkStubValueChangedHdl(void * instance
, weld::MetricSpinButton& data) { return static_cast<SwTableColumnPage
 *>(instance)->ValueChangedHdl(data); } void SwTableColumnPage
::ValueChangedHdl(weld::MetricSpinButton& rEdit)
913{
  m_bModified = true;
  ModifyHdl(&rEdit);
916}

918IMPL_LINK(SwTableColumnPage, ModeHdl, weld::ToggleButton&, rBox, void)void SwTableColumnPage::LinkStubModeHdl(void * instance, weld
::ToggleButton& data) { return static_cast<SwTableColumnPage
 *>(instance)->ModeHdl(data); } void SwTableColumnPage::
ModeHdl(weld::ToggleButton& rBox)
919{
  const bool bCheck = rBox.get_active();
  if (&rBox == m_xProportionalCB.get())
  {
      if (bCheck)
          m_xModifyTableCB->set_active(true);
      m_xModifyTableCB->set_sensitive(!bCheck && m_bModifyTable);
  }
927}

929bool SwTableColumnPage::FillItemSet( SfxItemSet* )
930{
  for (SwPercentField & i : m_aFieldArr)
  {
      if (i.has_focus())
      {
          ModifyHdl(i.get());
          break;
      }
  }

  if (m_bModified)
  {
      m_pTableData->SetColsChanged();
  }
  return m_bModified;
945}

947void SwTableColumnPage::ModifyHdl(const weld::MetricSpinButton* pField)
948{
  SwPercentField *pEdit = nullptr;
  sal_uInt16 i;

  for( i = 0; i < m_nMetFields; i++)
  {
      if (pField == m_aFieldArr[i].get())
      {
          pEdit = &m_aFieldArr[i];
          break;
      }
  }

  if (m_nMetFields <= i || !pEdit)
  {
      OSL_ENSURE(false, "cannot happen.")do { if (true && (!(false))) { sal_detail_logFormat((
SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "963" ": "), "%s", "cannot happen."); } } while (false);
      return;
  }

  SetVisibleWidth(m_aValueTable[i], pEdit->DenormalizePercent(pEdit->get_value(FieldUnit::TWIP)));

  UpdateCols( m_aValueTable[i] );
970}

972void SwTableColumnPage::UpdateCols( sal_uInt16 nCurrentPos )
973{
  SwTwips nSum = 0;

  for( sal_uInt16 i = 0; i < m_nNoOfCols; i++ )
  {
      nSum += (m_pTableData->GetColumns())[i].nWidth;
  }
  SwTwips nDiff = nSum - m_nTableWidth;

  bool bModifyTableChecked = m_xModifyTableCB->get_active();
  bool bProp = m_xProportionalCB->get_active();

  if (!bModifyTableChecked && !bProp)
  {
      //The table width is constant, the difference is balanced with the other columns
      sal_uInt16 nLoopCount = 0;
      while( nDiff )
      {
          if( ++nCurrentPos == m_nNoOfVisibleCols)
          {
              nCurrentPos = 0;
              ++nLoopCount;
              //#i101353# in small tables it might not be possible to balance column width
              if( nLoopCount > 1 )
                  break;
          }
          if( nDiff < 0 )
          {
              SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) -nDiff);
              nDiff = 0;
          }
          else if( GetVisibleWidth(nCurrentPos) >= nDiff + m_nMinWidth )
          {
              SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) -nDiff);
              nDiff = 0;
          }
          if( nDiff > 0 && GetVisibleWidth(nCurrentPos) > m_nMinWidth )
          {
              if( nDiff >= (GetVisibleWidth(nCurrentPos) - m_nMinWidth) )
              {
                  nDiff -= (GetVisibleWidth(nCurrentPos) - m_nMinWidth);
                  SetVisibleWidth(nCurrentPos, m_nMinWidth);
              }
              else
              {
                  nDiff = 0;
                  SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) -nDiff);
              }
              OSL_ENSURE(nDiff >= 0, "nDiff < 0 cannot be here!")do { if (true && (!(nDiff >= 0))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "1021" ": "), "%s", "nDiff < 0 cannot be here!"); } }
 while (false);
          }
      }
  }
  else if (bModifyTableChecked && !bProp)
  {
      //Difference is balanced by the width of the table,
      //other columns remain unchanged.
      OSL_ENSURE(nDiff <= m_pTableData->GetSpace() - m_nTableWidth, "wrong maximum" )do { if (true && (!(nDiff <= m_pTableData->GetSpace
() - m_nTableWidth))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "1029" ": "), "%s", "wrong maximum"); } } while (false);
      SwTwips nActSpace = m_pTableData->GetSpace() - m_nTableWidth;
      if(nDiff > nActSpace)
      {
          m_nTableWidth = m_pTableData->GetSpace();
          SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) - nDiff + nActSpace );
      }
      else
      {
          m_nTableWidth += nDiff;
      }
  }
  else if (bModifyTableChecked && bProp)
  {
      //All columns will be changed proportionally with,
      //the table width is adjusted accordingly.
      OSL_ENSURE(nDiff * m_nNoOfVisibleCols <= m_pTableData->GetSpace() - m_nTableWidth, "wrong maximum" )do { if (true && (!(nDiff * m_nNoOfVisibleCols <= m_pTableData
->GetSpace() - m_nTableWidth))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "1045" ": "), "%s", "wrong maximum"); } } while (false);
      long nAdd = nDiff;
      if(nDiff * m_nNoOfVisibleCols > m_pTableData->GetSpace() - m_nTableWidth)
      {
          nAdd = (m_pTableData->GetSpace() - m_nTableWidth) / m_nNoOfVisibleCols;
          SetVisibleWidth(nCurrentPos, GetVisibleWidth(nCurrentPos) - nDiff + nAdd );
          nDiff = nAdd;
      }
      if(nAdd)
          for( sal_uInt16 i = 0; i < m_nNoOfVisibleCols; i++ )
          {
              if(i == nCurrentPos)
                  continue;
              SwTwips nVisWidth;
              if((nVisWidth = GetVisibleWidth(i)) + nDiff < MINLAY23)
              {
                  nAdd += nVisWidth - MINLAY23;
                  SetVisibleWidth(i, MINLAY23);
              }
              else
              {
                  SetVisibleWidth(i, nVisWidth + nDiff);
                  nAdd += nDiff;
              }

          }
      m_nTableWidth += nAdd;
  }

  if (!m_bPercentMode)
  {
      m_xSpaceED->set_value(m_xSpaceED->normalize(m_pTableData->GetSpace() - m_nTableWidth), FieldUnit::TWIP);
      m_xSpaceSFT->set_label(m_xSpaceED->get_text());
  }
  else
      m_xSpaceSFT->set_label(OUString());

  for( sal_uInt16 i = 0; ( i < m_nNoOfVisibleCols ) && ( i < m_nMetFields ); i++)
  {
      m_aFieldArr[i].set_value(m_aFieldArr[i].NormalizePercent(
                      GetVisibleWidth(m_aValueTable[i]) ), FieldUnit::TWIP);
  }
1087}

1089void SwTableColumnPage::ActivatePage( const SfxItemSet& )
1090{
  m_bPercentMode = m_pTableData->GetWidthPercent() != 0;
  for( sal_uInt16 i = 0; (i < m_nMetFields) && (i < m_nNoOfVisibleCols); i++ )
  {
      m_aFieldArr[i].SetRefValue(m_pTableData->GetWidth());
      m_aFieldArr[i].ShowPercent( m_bPercentMode );
  }

  const sal_uInt16 nTableAlign = m_pTableData->GetAlign();
  if((text::HoriOrientation::FULL != nTableAlign && m_nTableWidth != m_pTableData->GetWidth()) ||
  (text::HoriOrientation::FULL == nTableAlign && m_nTableWidth != m_pTableData->GetSpace()))
  {
      m_nTableWidth = text::HoriOrientation::FULL == nTableAlign ?
                                  m_pTableData->GetSpace() :
                                      m_pTableData->GetWidth();
      UpdateCols(0);
  }
  m_bModifyTable = true;
  if (m_pTableData->GetWidthPercent() ||
              text::HoriOrientation::FULL == nTableAlign ||
                      m_pTableData->IsLineSelected()  )
      m_bModifyTable = false;
  if (m_bPercentMode)
  {
      m_xModifyTableCB->set_active(false);
      m_xProportionalCB->set_active(false);
  }
  else if (!m_bModifyTable)
  {
      m_xProportionalCB->set_active(false);
      m_xModifyTableCB->set_active(false);
  }
  m_xSpaceFT->set_sensitive(!m_bPercentMode);
  m_xSpaceSFT->set_sensitive(!m_bPercentMode);
  m_xModifyTableCB->set_sensitive( !m_bPercentMode && m_bModifyTable );
  m_xProportionalCB->set_sensitive(!m_bPercentMode && m_bModifyTable );

  m_xSpaceED->set_value(m_xSpaceED->normalize(
              m_pTableData->GetSpace() - m_nTableWidth), FieldUnit::TWIP);
  m_xSpaceSFT->set_label(m_xSpaceED->get_text());

1131}

1133DeactivateRC SwTableColumnPage::DeactivatePage( SfxItemSet* _pSet )
1134{
  if(_pSet)
  {
      FillItemSet(_pSet);
      if(text::HoriOrientation::FULL != m_pTableData->GetAlign() && m_pTableData->GetWidth() != m_nTableWidth)
      {
          m_pTableData->SetWidth(m_nTableWidth);
          SwTwips nDiff = m_pTableData->GetSpace() - m_pTableData->GetWidth() -
                          m_pTableData->GetLeftSpace() - m_pTableData->GetRightSpace();
          switch( m_pTableData->GetAlign()  )
          {
              case text::HoriOrientation::RIGHT:
                  m_pTableData->SetLeftSpace(m_pTableData->GetLeftSpace() + nDiff);
              break;
              case text::HoriOrientation::LEFT:
                  m_pTableData->SetRightSpace(m_pTableData->GetRightSpace() + nDiff);
              break;
              case text::HoriOrientation::NONE:
              {
                  SwTwips nDiff2 = nDiff/2;
                  if( nDiff > 0 ||
                      (-nDiff2 < m_pTableData->GetRightSpace() && - nDiff2 < m_pTableData->GetLeftSpace()))
                  {
                      m_pTableData->SetRightSpace(m_pTableData->GetRightSpace() + nDiff2);
                      m_pTableData->SetLeftSpace(m_pTableData->GetLeftSpace() + nDiff2);
                  }
                  else
                  {
                      if(m_pTableData->GetRightSpace() > m_pTableData->GetLeftSpace())
                      {
                          m_pTableData->SetLeftSpace(0);
                          m_pTableData->SetRightSpace(m_pTableData->GetSpace() - m_pTableData->GetWidth());
                      }
                      else
                      {
                          m_pTableData->SetRightSpace(0);
                          m_pTableData->SetLeftSpace(m_pTableData->GetSpace() - m_pTableData->GetWidth());
                      }
                  }
              }
              break;
              case text::HoriOrientation::CENTER:
                  m_pTableData->SetRightSpace(m_pTableData->GetRightSpace() + nDiff/2);
                  m_pTableData->SetLeftSpace(m_pTableData->GetLeftSpace() + nDiff/2);
              break;
              case text::HoriOrientation::LEFT_AND_WIDTH :
                  if(nDiff > m_pTableData->GetRightSpace())
                  {
                      m_pTableData->SetLeftSpace(m_pTableData->GetSpace() - m_pTableData->GetWidth());
                  }
                  m_pTableData->SetRightSpace(
                      m_pTableData->GetSpace() - m_pTableData->GetWidth() - m_pTableData->GetLeftSpace());
              break;
          }
          m_pTableData->SetWidthChanged();
      }
      _pSet->Put(SwPtrItem( FN_TABLE_REP((20000 + 400) + 99), m_pTableData ));
  }
  return DeactivateRC::LeavePage;
1193}

1195SwTwips  SwTableColumnPage::GetVisibleWidth(sal_uInt16 nPos)
1196{
  sal_uInt16 i=0;

  while( nPos )
  {
      if(m_pTableData->GetColumns()[i].bVisible)
          nPos--;
      i++;
  }
  SwTwips nReturn = m_pTableData->GetColumns()[i].nWidth;
  OSL_ENSURE(i < m_nNoOfCols, "Array index out of range")do { if (true && (!(i < m_nNoOfCols))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "1206" ": "), "%s", "Array index out of range"); } } while
 (false);
  while(!m_pTableData->GetColumns()[i].bVisible && (i + 1) < m_nNoOfCols)
      nReturn += m_pTableData->GetColumns()[++i].nWidth;

  return nReturn;
1211}

1213void SwTableColumnPage::SetVisibleWidth(sal_uInt16 nPos, SwTwips nNewWidth)
1214{
  sal_uInt16 i=0;
  while( nPos )
  {
      if(m_pTableData->GetColumns()[i].bVisible)
          nPos--;
      i++;
  }
  OSL_ENSURE(i < m_nNoOfCols, "Array index out of range")do { if (true && (!(i < m_nNoOfCols))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sw/source/ui/table/tabledlg.cxx"
 ":" "1222" ": "), "%s", "Array index out of range"); } } while
 (false);
  m_pTableData->GetColumns()[i].nWidth = nNewWidth;
  while(!m_pTableData->GetColumns()[i].bVisible && (i + 1) < m_nNoOfCols)
      m_pTableData->GetColumns()[++i].nWidth = 0;

1227}

1229SwTableTabDlg::SwTableTabDlg(weld::Window* pParent, const SfxItemSet* pItemSet, SwWrtShell* pSh)
  : SfxTabDialogController(pParent, "modules/swriter/ui/tableproperties.ui", "TablePropertiesDialog", pItemSet)
  , pShell(pSh)
1232{
  SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create();
  AddTabPage("table", &SwFormatTablePage::Create, nullptr);
  AddTabPage("textflow", &SwTextFlowPage::Create, nullptr);
  AddTabPage("columns", &SwTableColumnPage::Create, nullptr);
  AddTabPage("background", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BKG((10000) + 57)), nullptr);
  AddTabPage("borders", pFact->GetTabPageCreatorFunc(RID_SVXPAGE_BORDER((10000) + 5)), nullptr);
1239}

1241void  SwTableTabDlg::PageCreated(const OString& rId, SfxTabPage& rPage)
1242{
  SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool()));
  if (rId == "background")
  {
      SvxBackgroundTabFlags const nFlagType = SvxBackgroundTabFlags::SHOW_TBLCTL;
      aSet.Put (SfxUInt32Item(SID_FLAG_TYPE( 10000 + 1034 ), static_cast<sal_uInt32>(nFlagType)));
      rPage.PageCreated(aSet);
  }
  else if (rId == "borders")
  {
      aSet.Put (SfxUInt16Item(SID_SWMODE_TYPE( 10000 + 1035 ), static_cast<sal_uInt16>(SwBorderModes::TABLE)));
      rPage.PageCreated(aSet);
  }
  else if (rId == "textflow")
  {
      static_cast<SwTextFlowPage&>(rPage).SetShell(pShell);
      const FrameTypeFlags eType = pShell->GetFrameType(nullptr,true);
      if( !(FrameTypeFlags::BODY & eType) )
          static_cast<SwTextFlowPage&>(rPage).DisablePageBreak();
  }
1262}

1264SwTextFlowPage::SwTextFlowPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet)
  : SfxTabPage(pPage, pController, "modules/swriter/ui/tabletextflowpage.ui", "TableTextFlowPage", &rSet)
  , pShell(nullptr)
  , bPageBreak(true)
  , bHtmlMode(false)
  , m_xPgBrkCB(m_xBuilder->weld_check_button("break"))
  , m_xPgBrkRB(m_xBuilder->weld_radio_button("page"))
  , m_xColBrkRB(m_xBuilder->weld_radio_button("column"))
  , m_xPgBrkBeforeRB(m_xBuilder->weld_radio_button("before"))
  , m_xPgBrkAfterRB(m_xBuilder->weld_radio_button("after"))
  , m_xPageCollCB(m_xBuilder->weld_check_button("pagestyle"))
  , m_xPageCollLB(m_xBuilder->weld_combo_box("pagestylelb"))
  , m_xPageNoCB(m_xBuilder->weld_check_button("pagenoft"))
  , m_xPageNoNF(m_xBuilder->weld_spin_button("pagenonf"))
  , m_xSplitCB(m_xBuilder->weld_check_button("split"))
  , m_xSplitRowCB(m_xBuilder->weld_check_button("splitrow"))
  , m_xKeepCB(m_xBuilder->weld_check_button("keep"))
  , m_xHeadLineCB(m_xBuilder->weld_check_button("headline"))
  , m_xRepeatHeaderCombo(m_xBuilder->weld_widget("repeatheader"))
  , m_xRepeatHeaderNF(m_xBuilder->weld_spin_button("repeatheadernf"))
  , m_xTextDirectionLB(m_xBuilder->weld_combo_box("textorientation"))
  , m_xVertOrientLB(m_xBuilder->weld_combo_box("vertorient"))
1286{
  m_xPgBrkCB->connect_toggled(LINK(this, SwTextFlowPage, PageBreakHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubPageBreakHdl_Impl));
  m_xPgBrkBeforeRB->connect_toggled(
      LINK(this, SwTextFlowPage, PageBreakPosHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubPageBreakPosHdl_Impl
));
  m_xPgBrkAfterRB->connect_toggled(
      LINK(this, SwTextFlowPage, PageBreakPosHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubPageBreakPosHdl_Impl
));
  m_xPageCollCB->connect_toggled(
      LINK(this, SwTextFlowPage, ApplyCollClickHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubApplyCollClickHdl_Impl
));
  m_xColBrkRB->connect_toggled(
      LINK(this, SwTextFlowPage, PageBreakTypeHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubPageBreakTypeHdl_Impl
));
  m_xPgBrkRB->connect_toggled(
      LINK(this, SwTextFlowPage, PageBreakTypeHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubPageBreakTypeHdl_Impl
));
  m_xPageNoCB->connect_toggled(
      LINK(this, SwTextFlowPage, PageNoClickHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubPageNoClickHdl_Impl
));
  m_xSplitCB->connect_toggled(
      LINK(this, SwTextFlowPage, SplitHdl_Impl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubSplitHdl_Impl));
  m_xHeadLineCB->connect_toggled(LINK(this, SwTextFlowPage, HeadLineCBClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<SwTextFlowPage
 *>(this), &SwTextFlowPage::LinkStubHeadLineCBClickHdl
));

  const SfxPoolItem *pItem;
  if(SfxItemState::SET == rSet.GetItemState( SID_HTML_MODE(10000 + 414), false,&pItem )
      && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON)
  {
      m_xKeepCB->hide();
      m_xSplitCB->hide();
      m_xSplitRowCB->hide();
  }

  HeadLineCBClickHdl(*m_xHeadLineCB);
1314}

1316SwTextFlowPage::~SwTextFlowPage()
1317{
1318}

1320std::unique_ptr<SfxTabPage> SwTextFlowPage::Create(weld::Container* pPage, weld::DialogController* pController,
                                                 const SfxItemSet* rAttrSet)
1322{
  return std::make_unique<SwTextFlowPage>(pPage, pController, *rAttrSet);
1324}

1326bool  SwTextFlowPage::FillItemSet( SfxItemSet* rSet )
1327{
  bool bModified = false;

  //Repeat Heading
  if (m_xHeadLineCB->get_state_changed_from_saved() ||
      m_xRepeatHeaderNF->get_value_changed_from_saved() )
  {
      bModified |= nullptr != rSet->Put(
          SfxUInt16Item(FN_PARAM_TABLE_HEADLINE((20000 + 1100)+50), m_xHeadLineCB->get_active() ? sal_uInt16(m_xRepeatHeaderNF->get_value()) : 0));
  }
  if (m_xKeepCB->get_state_changed_from_saved())
      bModified |= nullptr != rSet->Put( SvxFormatKeepItem( m_xKeepCB->get_active(), RES_KEEP));

  if (m_xSplitCB->get_state_changed_from_saved())
      bModified |= nullptr != rSet->Put( SwFormatLayoutSplit( m_xSplitCB->get_active()));

  if (m_xSplitRowCB->get_state_changed_from_saved())
      bModified |= nullptr != rSet->Put( SwFormatRowSplit( m_xSplitRowCB->get_active()));

  const SvxFormatBreakItem* pBreak = GetOldItem( *rSet, RES_BREAK );
  const SwFormatPageDesc* pDesc = GetOldItem( *rSet, RES_PAGEDESC );

  bool bState = m_xPageCollCB->get_active();

  //If we have a page style, then there's no break
  bool bPageItemPut = false;
  if (   bState != (m_xPageCollCB->get_saved_state() == TRISTATE_TRUE)
      || (bState && m_xPageCollLB->get_value_changed_from_saved())
      || (m_xPageNoCB->get_sensitive() && m_xPageNoCB->get_state_changed_from_saved())
      || (m_xPageNoNF->get_sensitive() && m_xPageNoNF->get_value_changed_from_saved()))
  {
      OUString sPage;

      if ( bState )
      {
          sPage = m_xPageCollLB->get_active_text();
      }
      sal_uInt16 nPgNum = static_cast<sal_uInt16>(m_xPageNoNF->get_value());
      bool const usePageNo(bState && m_xPageNoCB->get_active());
      std::optional<sal_uInt16> const oPageNum(
              usePageNo ? nPgNum : std::optional<sal_Int16>());
      if (!pDesc || !pDesc->GetPageDesc()
          || (pDesc->GetPageDesc()->GetName() != sPage)
          || (pDesc->GetNumOffset() != oPageNum))
      {
          SwFormatPageDesc aFormat( pShell->FindPageDescByName( sPage, true ) );
          aFormat.SetNumOffset(oPageNum);
          bModified |= nullptr != rSet->Put( aFormat );
          bPageItemPut = bState;
      }
  }
  bool bIsChecked = m_xPgBrkCB->get_active();
  if ( !bPageItemPut &&
      (   bState != (m_xPageCollCB->get_saved_state() == TRISTATE_TRUE) ||
          bIsChecked != (m_xPgBrkCB->get_saved_state() == TRISTATE_TRUE) ||
          m_xPgBrkBeforeRB->get_state_changed_from_saved()    ||
          m_xPgBrkRB->get_state_changed_from_saved() ))
  {
      SvxFormatBreakItem aBreak( GetItemSet().Get( RES_BREAK ) );

      if(bIsChecked)
      {
          bool bBefore = m_xPgBrkBeforeRB->get_active();

          if (m_xPgBrkRB->get_active())
          {
              if ( bBefore )
                  aBreak.SetValue( SvxBreak::PageBefore );
              else
                  aBreak.SetValue( SvxBreak::PageAfter );
          }
          else
          {
              if ( bBefore )
                  aBreak.SetValue( SvxBreak::ColumnBefore );
              else
                  aBreak.SetValue( SvxBreak::ColumnAfter );
          }
      }
      else
      {
              aBreak.SetValue( SvxBreak::NONE );
      }

      if ( !pBreak || !( *pBreak == aBreak ) )
      {
          bModified |= nullptr != rSet->Put( aBreak );
      }
  }

  if (m_xTextDirectionLB->get_value_changed_from_saved())
  {
        OUString sId = m_xTextDirectionLB->get_active_id();
        bModified |= nullptr != rSet->Put(SvxFrameDirectionItem(static_cast<SvxFrameDirection>(sId.toUInt32()), FN_TABLE_BOX_TEXTORIENTATION((20000 + 400) + 192)));
  }

  if (m_xVertOrientLB->get_value_changed_from_saved())
  {
      sal_uInt16 nOrient = USHRT_MAX(32767 *2 +1);
      switch (m_xVertOrientLB->get_active())
      {
          case 0 : nOrient = text::VertOrientation::NONE; break;
          case 1 : nOrient = text::VertOrientation::CENTER; break;
          case 2 : nOrient = text::VertOrientation::BOTTOM; break;
      }
      if (nOrient != USHRT_MAX(32767 *2 +1))
          bModified |= nullptr != rSet->Put(SfxUInt16Item(FN_TABLE_SET_VERT_ALIGN((20000 + 400) + 188), nOrient));
  }

  return bModified;

1438}

1440void   SwTextFlowPage::Reset( const SfxItemSet* rSet )
1441{
  const SfxPoolItem* pItem;
  SvxHtmlOptions& rHtmlOpt = SvxHtmlOptions::Get();
  bool bFlowAllowed = !bHtmlMode || rHtmlOpt.IsPrintLayoutExtension();
  if(bFlowAllowed)
  {
      //Inserting of the existing page templates in the list box
      const size_t nCount = pShell->GetPageDescCnt();

      for( size_t i = 0; i < nCount; ++i)
      {
          const SwPageDesc &rPageDesc = pShell->GetPageDesc(i);
          m_xPageCollLB->append_text(rPageDesc.GetName());
      }

      OUString aFormatName;
      for (sal_uInt16 i = RES_POOLPAGE_BEGIN; i < RES_POOLPAGE_END; ++i)
      {
          aFormatName = SwStyleNameMapper::GetUIName(i, aFormatName);
          if (m_xPageCollLB->find_text(aFormatName) == -1)
              m_xPageCollLB->append_text(aFormatName);
      }

      if(SfxItemState::SET == rSet->GetItemState( RES_KEEP, false, &pItem ))
      {
          m_xKeepCB->set_active( static_cast<const SvxFormatKeepItem*>(pItem)->GetValue() );
          m_xKeepCB->save_state();
      }
      if(SfxItemState::SET == rSet->GetItemState( RES_LAYOUT_SPLIT, false, &pItem ))
      {
          m_xSplitCB->set_active( static_cast<const SwFormatLayoutSplit*>(pItem)->GetValue() );
      }
      else
          m_xSplitCB->set_active(true);

      m_xSplitCB->save_state();
      SplitHdl_Impl(*m_xSplitCB);

      if(SfxItemState::SET == rSet->GetItemState( RES_ROW_SPLIT, false, &pItem ))
      {
          m_xSplitRowCB->set_active( static_cast<const SwFormatRowSplit*>(pItem)->GetValue() );
      }
      else
          m_xSplitRowCB->set_state(TRISTATE_INDET);
      m_xSplitRowCB->save_state();

      if(bPageBreak)
      {
          if(SfxItemState::SET == rSet->GetItemState( RES_PAGEDESC, false, &pItem ))
          {
              OUString sPageDesc;
              const SwPageDesc* pDesc = static_cast<const SwFormatPageDesc*>(pItem)->GetPageDesc();

              ::std::optional<sal_uInt16> oNumOffset = static_cast<const SwFormatPageDesc*>(pItem)->GetNumOffset();
              if (oNumOffset)
              {
                  m_xPageNoCB->set_active(true);
                  m_xPageNoNF->set_sensitive(true);
                  m_xPageNoNF->set_value(*oNumOffset);
              }
              else
              {
                  m_xPageNoCB->set_active(false);
                  m_xPageNoNF->set_sensitive(false);
              }

              if(pDesc)
                  sPageDesc = pDesc->GetName();
              if (!sPageDesc.isEmpty() && m_xPageCollLB->find_text(sPageDesc) != -1)
              {
                  m_xPageCollLB->set_active_text(sPageDesc);
                  m_xPageCollCB->set_active(true);

                  m_xPgBrkCB->set_sensitive(true);
                  m_xPgBrkRB->set_sensitive(true);
                  m_xColBrkRB->set_sensitive(true);
                  m_xPgBrkBeforeRB->set_sensitive(true);
                  m_xPgBrkAfterRB->set_sensitive(true);
                  m_xPageCollCB->set_sensitive(true);

                  m_xPgBrkCB->set_active(true);
                  m_xColBrkRB->set_active( false );
                  m_xPgBrkBeforeRB->set_active(true);
                  m_xPgBrkAfterRB->set_active( false );
              }
              else
              {
                  m_xPageCollLB->set_active(-1);
                  m_xPageCollCB->set_active(false);
              }
          }

          if(SfxItemState::SET == rSet->GetItemState( RES_BREAK, false, &pItem ))
          {
              const SvxFormatBreakItem* pPageBreak = static_cast<const SvxFormatBreakItem*>(pItem);
              SvxBreak eBreak = pPageBreak->GetBreak();

              if ( eBreak != SvxBreak::NONE )
              {
                  m_xPgBrkCB->set_active(true);
                  m_xPageCollCB->set_sensitive(false);
                  m_xPageCollLB->set_sensitive(false);
                  m_xPageNoCB->set_sensitive(false);
                  m_xPageNoNF->set_sensitive(false);
              }
              switch ( eBreak )
              {
                  case SvxBreak::PageBefore:
                      m_xPgBrkRB->set_active(true);
                      m_xColBrkRB->set_active( false );
                      m_xPgBrkBeforeRB->set_active(true);
                      m_xPgBrkAfterRB->set_active( false );
                      break;
                  case SvxBreak::PageAfter:
                      m_xPgBrkRB->set_active(true);
                      m_xColBrkRB->set_active( false );
                      m_xPgBrkBeforeRB->set_active( false );
                      m_xPgBrkAfterRB->set_active(true);
                      break;
                  case SvxBreak::ColumnBefore:
                      m_xPgBrkRB->set_active( false );
                      m_xColBrkRB->set_active(true);
                      m_xPgBrkBeforeRB->set_active(true);
                      m_xPgBrkAfterRB->set_active( false );
                      break;
                  case SvxBreak::ColumnAfter:
                      m_xPgBrkRB->set_active( false );
                      m_xColBrkRB->set_active(true);
                      m_xPgBrkBeforeRB->set_active( false );
                      m_xPgBrkAfterRB->set_active(true);
                      break;
                  default:; //prevent warning
              }

          }
          if (m_xPgBrkBeforeRB->get_active())
              PageBreakPosHdl_Impl(*m_xPgBrkBeforeRB);
          else if (m_xPgBrkAfterRB->get_active())
              PageBreakPosHdl_Impl(*m_xPgBrkAfterRB);
          PageBreakHdl_Impl(*m_xPgBrkCB);
      }
  }
  else
  {
      m_xPgBrkRB->set_sensitive(false);
      m_xColBrkRB->set_sensitive(false);
      m_xPgBrkBeforeRB->set_sensitive(false);
      m_xPgBrkAfterRB->set_sensitive(false);
      m_xKeepCB->set_sensitive(false);
      m_xSplitCB->set_sensitive(false);
      m_xPgBrkCB->set_sensitive(false);
      m_xPageCollCB->set_sensitive(false);
      m_xPageCollLB->set_sensitive(false);
  }

  if(SfxItemState::SET == rSet->GetItemState( FN_PARAM_TABLE_HEADLINE((20000 + 1100)+50), false, &pItem ))
  {
      sal_uInt16 nRep = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
      m_xHeadLineCB->set_active(nRep > 0);
      m_xHeadLineCB->save_state();
      m_xRepeatHeaderNF->set_value(nRep);
      m_xRepeatHeaderNF->set_min(1);
      m_xRepeatHeaderNF->save_value();
  }
  if ( rSet->GetItemState(FN_TABLE_BOX_TEXTORIENTATION((20000 + 400) + 192)) > SfxItemState::DEFAULT )
  {
      SvxFrameDirection nDirection =
              static_cast<const SvxFrameDirectionItem&>(rSet->Get(FN_TABLE_BOX_TEXTORIENTATION((20000 + 400) + 192))).GetValue();
      m_xTextDirectionLB->set_active_id(OUString::number(static_cast<sal_uInt32>(nDirection)));
  }

  if ( rSet->GetItemState(FN_TABLE_SET_VERT_ALIGN((20000 + 400) + 188)) > SfxItemState::DEFAULT )
  {
      sal_uInt16 nVert = static_cast<const SfxUInt16Item&>(rSet->Get(FN_TABLE_SET_VERT_ALIGN((20000 + 400) + 188))).GetValue();
      sal_uInt16 nPos = 0;
      switch(nVert)
      {
          case text::VertOrientation::NONE:     nPos = 0;   break;
          case text::VertOrientation::CENTER:   nPos = 1;   break;
          case text::VertOrientation::BOTTOM:   nPos = 2;   break;
      }
      m_xVertOrientLB->set_active(nPos);
  }

  m_xPageCollCB->save_state();
  m_xPageCollLB->save_value();
  m_xPgBrkCB->save_state();
  m_xPgBrkRB->save_state();
  m_xColBrkRB->save_state();
  m_xPgBrkBeforeRB->save_state();
  m_xPgBrkAfterRB->save_state();
  m_xPageNoCB->save_state();
  m_xPageNoNF->save_value();
  m_xTextDirectionLB->save_value();
  m_xVertOrientLB->save_value();

  HeadLineCBClickHdl(*m_xHeadLineCB);
1638}

1640void SwTextFlowPage::SetShell(SwWrtShell* pSh)
1641{
  pShell = pSh;
  bHtmlMode = 0 != (::GetHtmlMode(pShell->GetView().GetDocShell()) & HTMLMODE_ON);
  if(bHtmlMode)
  {
      m_xPageNoNF->set_sensitive(false);
      m_xPageNoCB->set_sensitive(false);
  }
1649}

1651IMPL_LINK_NOARG(SwTextFlowPage, PageBreakHdl_Impl, weld::ToggleButton&, void)void SwTextFlowPage::LinkStubPageBreakHdl_Impl(void * instance
, weld::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->PageBreakHdl_Impl(data); } void SwTextFlowPage
::PageBreakHdl_Impl(__attribute__ ((unused)) weld::ToggleButton
&)
1652{
  if (m_xPgBrkCB->get_active())
  {
      m_xPgBrkRB->set_sensitive(true);
      m_xColBrkRB->set_sensitive(true);
      m_xPgBrkBeforeRB->set_sensitive(true);
      m_xPgBrkAfterRB->set_sensitive(true);

      if (m_xPgBrkRB->get_active() && m_xPgBrkBeforeRB->get_active())
      {
          m_xPageCollCB->set_sensitive(true);

          bool bEnable = m_xPageCollCB->get_active() && m_xPageCollLB->get_count();
          m_xPageCollLB->set_sensitive(bEnable);
          if (!bHtmlMode)
          {
              m_xPageNoCB->set_sensitive(bEnable);
              m_xPageNoNF->set_sensitive(bEnable && m_xPageNoCB->get_active());
          }
      }
  }
  else
  {
      m_xPageCollCB->set_active(false);
      m_xPageCollCB->set_sensitive(false);
      m_xPageCollLB->set_sensitive(false);
      m_xPageNoCB->set_sensitive(false);
      m_xPageNoNF->set_sensitive(false);
      m_xPgBrkRB->set_sensitive(false);
      m_xColBrkRB->set_sensitive(false);
      m_xPgBrkBeforeRB->set_sensitive(false);
      m_xPgBrkAfterRB->set_sensitive(false);
  }
1685}

1687IMPL_LINK_NOARG(SwTextFlowPage, ApplyCollClickHdl_Impl, weld::ToggleButton&, void)void SwTextFlowPage::LinkStubApplyCollClickHdl_Impl(void * instance
, weld::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->ApplyCollClickHdl_Impl(data); } void SwTextFlowPage
::ApplyCollClickHdl_Impl(__attribute__ ((unused)) weld::ToggleButton
&)
1688{
  bool bEnable = false;
  if (m_xPageCollCB->get_active() && m_xPageCollLB->get_count())
  {
      bEnable = true;
      m_xPageCollLB->set_active(0);
  }
  else
  {
      m_xPageCollLB->set_active(-1);
  }
  m_xPageCollLB->set_sensitive(bEnable);
  if (!bHtmlMode)
  {
      m_xPageNoCB->set_sensitive(bEnable);
      m_xPageNoNF->set_sensitive(bEnable && m_xPageNoCB->get_active());
  }
1705}

1707IMPL_LINK_NOARG(SwTextFlowPage, PageBreakPosHdl_Impl, weld::ToggleButton&, void)void SwTextFlowPage::LinkStubPageBreakPosHdl_Impl(void * instance
, weld::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->PageBreakPosHdl_Impl(data); } void SwTextFlowPage
::PageBreakPosHdl_Impl(__attribute__ ((unused)) weld::ToggleButton
&)
1708{
  if (!m_xPgBrkCB->get_active())
      return;

  if (m_xPgBrkBeforeRB->get_active() && m_xPgBrkRB->get_active())
  {
      m_xPageCollCB->set_sensitive(true);

      bool bEnable = m_xPageCollCB->get_active() && m_xPageCollLB->get_count();

      m_xPageCollLB->set_sensitive(bEnable);
      if (!bHtmlMode)
      {
          m_xPageNoCB->set_sensitive(bEnable);
          m_xPageNoNF->set_sensitive(bEnable && m_xPageNoCB->get_active());
      }
  }
  else if (m_xPgBrkAfterRB->get_active())
  {
      m_xPageCollCB->set_active(false);
      m_xPageCollCB->set_sensitive(false);
      m_xPageCollLB->set_sensitive(false);
      m_xPageNoCB->set_sensitive(false);
      m_xPageNoNF->set_sensitive(false);
  }
1733}

1735IMPL_LINK_NOARG(SwTextFlowPage, PageBreakTypeHdl_Impl, weld::ToggleButton&, void)void SwTextFlowPage::LinkStubPageBreakTypeHdl_Impl(void * instance
, weld::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->PageBreakTypeHdl_Impl(data); } void SwTextFlowPage
::PageBreakTypeHdl_Impl(__attribute__ ((unused)) weld::ToggleButton
&)
1736{
  if (m_xColBrkRB->get_active() || m_xPgBrkAfterRB->get_active())
  {
      m_xPageCollCB->set_active(false);
      m_xPageCollCB->set_sensitive(false);
      m_xPageCollLB->set_sensitive(false);
      m_xPageNoCB->set_sensitive(false);
      m_xPageNoNF->set_sensitive(false);
  }
  else if (m_xPgBrkBeforeRB->get_active())
      PageBreakPosHdl_Impl(*m_xPgBrkBeforeRB);
1747}

1749IMPL_LINK_NOARG(SwTextFlowPage, PageNoClickHdl_Impl, weld::ToggleButton&, void)void SwTextFlowPage::LinkStubPageNoClickHdl_Impl(void * instance
, weld::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->PageNoClickHdl_Impl(data); } void SwTextFlowPage
::PageNoClickHdl_Impl(__attribute__ ((unused)) weld::ToggleButton
&)
1750{
  m_xPageNoNF->set_sensitive(m_xPageNoCB->get_active());
1752}

1754IMPL_LINK(SwTextFlowPage, SplitHdl_Impl, weld::ToggleButton&, rBox, void)void SwTextFlowPage::LinkStubSplitHdl_Impl(void * instance, weld
::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->SplitHdl_Impl(data); } void SwTextFlowPage
::SplitHdl_Impl(weld::ToggleButton& rBox)
1755{
  m_xSplitRowCB->set_sensitive(rBox.get_active());
1757}

1759IMPL_LINK_NOARG(SwTextFlowPage, HeadLineCBClickHdl, weld::ToggleButton&, void)void SwTextFlowPage::LinkStubHeadLineCBClickHdl(void * instance
, weld::ToggleButton& data) { return static_cast<SwTextFlowPage
 *>(instance)->HeadLineCBClickHdl(data); } void SwTextFlowPage
::HeadLineCBClickHdl(__attribute__ ((unused)) weld::ToggleButton
&)
1760{
  m_xRepeatHeaderCombo->set_sensitive(m_xHeadLineCB->get_active());
1762}

1764void SwTextFlowPage::DisablePageBreak()
1765{
  bPageBreak = false;
  m_xPgBrkCB->set_sensitive(false);
  m_xPgBrkRB->set_sensitive(false);
  m_xColBrkRB->set_sensitive(false);
  m_xPgBrkBeforeRB->set_sensitive(false);
  m_xPgBrkAfterRB->set_sensitive(false);
  m_xPageCollCB->set_sensitive(false);
  m_xPageCollLB->set_sensitive(false);
  m_xPageNoCB->set_sensitive(false);
  m_xPageNoNF->set_sensitive(false);
1776}

1778/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

/home/maarten/src/libreoffice/core/sw/source/uibase/inc/swtablerep.hxx

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
19#ifndef INCLUDED_SW_SOURCE_UIBASE_INC_SWTABLEREP_HXX
20#define INCLUDED_SW_SOURCE_UIBASE_INC_SWTABLEREP_HXX

22#include <memory>
23#include <swdllapi.h>
24#include <swtypes.hxx>

26class SwTabCols;

28struct TColumn
29{
  SwTwips nWidth;
  bool    bVisible;
32};

34class SW_DLLPUBLIC__attribute__ ((visibility("default"))) SwTableRep
35{
  std::vector<TColumn> m_aTColumns;

  SwTwips     m_nTableWidth;
  SwTwips     m_nSpace;
  SwTwips     m_nLeftSpace;
  SwTwips     m_nRightSpace;
  sal_uInt16      m_nAlign;
  sal_uInt16      m_nColCount;
  sal_uInt16      m_nAllCols;
  sal_uInt16      m_nWidthPercent;
  bool        m_bLineSelected : 1;
  bool        m_bWidthChanged : 1;
  bool        m_bColsChanged : 1;

50public:
  SwTableRep( const SwTabCols& rTabCol );
  ~SwTableRep();

  SwTableRep( const SwTableRep& rCopy ) = default;
  SwTableRep( SwTableRep&& rCopy ) = default;
  SwTableRep& operator=(const SwTableRep& rCopy) = default;
  SwTableRep& operator=(SwTableRep&& rCopy) = default;

  bool        FillTabCols( SwTabCols& rTabCol ) const;

  SwTwips     GetLeftSpace() const            {return m_nLeftSpace;}
  void        SetLeftSpace(SwTwips nSet)      {m_nLeftSpace = nSet;}

  SwTwips     GetRightSpace() const           {return m_nRightSpace;}
  void        SetRightSpace(SwTwips nSet)     {m_nRightSpace = nSet;}

  SwTwips     GetWidth() const                {return m_nTableWidth;}
  void        SetWidth(SwTwips nSet)          {m_nTableWidth = nSet;}

  sal_uInt16      GetWidthPercent() const         {return m_nWidthPercent;}
  void        SetWidthPercent(sal_uInt16 nSet)    {m_nWidthPercent = nSet;}

  sal_uInt16      GetAlign() const                {return m_nAlign;}
  void        SetAlign(sal_uInt16 nSet)           {m_nAlign = nSet;}

  sal_uInt16      GetColCount() const             {return m_nColCount;}
13
←
Returning zero→
  sal_uInt16      GetAllColCount() const          {return m_nAllCols;}

  bool        HasColsChanged() const          {return m_bColsChanged;}
  void        SetColsChanged()                {m_bColsChanged = true;}

  bool        HasWidthChanged() const         {return m_bWidthChanged;}
  void        SetWidthChanged()               {m_bWidthChanged  = true;}

  bool        IsLineSelected() const          {return m_bLineSelected;}
  void        SetLineSelected(bool bSet)      {m_bLineSelected = bSet;}

  SwTwips     GetSpace() const                { return m_nSpace;}
  void        SetSpace(SwTwips nSet)          {m_nSpace = nSet;}

  TColumn*    GetColumns()                    {return m_aTColumns.data();}
92};
93#endif

95/* vim:set shiftwidth=4 softtabstop=4 expandtab: */