weld AlignmentPropertyPanel

Change-Id: I3070f5e7b2d5f104f4eea9d3e2f700ce2d1e7375
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/85721
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

2 files changed, 148 insertions, 197 deletions

diff --git a/sc/source/ui/sidebar/AlignmentPropertyPanel.cxx b/sc/source/ui/sidebar/AlignmentPropertyPanel.cxx
index e54e8bc1b16b..20e6fc76de0c 100644
--- a/sc/source/ui/sidebar/AlignmentPropertyPanel.cxx
+++ b/sc/source/ui/sidebar/AlignmentPropertyPanel.cxx
@@ -42,34 +42,39 @@ AlignmentPropertyPanel::AlignmentPropertyPanel(
     vcl::Window* pParent,
     const css::uno::Reference<css::frame::XFrame>& rxFrame,
     SfxBindings* pBindings)
-    : PanelLayout(pParent, "AlignmentPropertyPanel", "modules/scalc/ui/sidebaralignment.ui", rxFrame),
-      maAlignHorControl(SID_H_ALIGNCELL, *pBindings, *this),
-      maLeftIndentControl(SID_ATTR_ALIGN_INDENT, *pBindings, *this),
-      maMergeCellControl(FID_MERGE_TOGGLE, *pBindings, *this),
-      maWrapTextControl(SID_ATTR_ALIGN_LINEBREAK, *pBindings, *this),
-      maAngleControl(SID_ATTR_ALIGN_DEGREES, *pBindings, *this),
-      maVrtStackControl(SID_ATTR_ALIGN_STACKED, *pBindings, *this),
-      maRefEdgeControl(SID_ATTR_ALIGN_LOCKPOS, *pBindings, *this),
-      mbMultiDisable(false),
-      maContext(),
-      mpBindings(pBindings)
+    : PanelLayout(pParent, "AlignmentPropertyPanel", "modules/scalc/ui/sidebaralignment.ui", rxFrame, true)
+    , mxFTLeftIndent(m_xBuilder->weld_label("leftindentlabel"))
+    , mxMFLeftIndent(m_xBuilder->weld_metric_spin_button("leftindent", FieldUnit::POINT))
+    , mxCBXWrapText(m_xBuilder->weld_check_button("wraptext"))
+    , mxCBXMergeCell(m_xBuilder->weld_check_button("mergecells"))
+    , mxFtRotate(m_xBuilder->weld_label("orientationlabel"))
+    , mxMtrAngle(m_xBuilder->weld_metric_spin_button("orientationdegrees", FieldUnit::DEGREE))
+    , mxRefEdgeBottom(m_xBuilder->weld_radio_button("bottom"))
+    , mxRefEdgeTop(m_xBuilder->weld_radio_button("top"))
+    , mxRefEdgeStd(m_xBuilder->weld_radio_button("standard"))
+    , mxCBStacked(m_xBuilder->weld_check_button("stacked"))
+    , mxTextOrientBox(m_xBuilder->weld_widget("textorientbox"))
+    , mxHorizontalAlign(m_xBuilder->weld_toolbar("horizontalalignment"))
+    , mxHorizontalAlignDispatch(new ToolbarUnoDispatcher(*mxHorizontalAlign, rxFrame))
+    , mxVertAlign(m_xBuilder->weld_toolbar("verticalalignment"))
+    , mxVertAlignDispatch(new ToolbarUnoDispatcher(*mxVertAlign, rxFrame))
+    , mxWriteDirection(m_xBuilder->weld_toolbar("writedirection"))
+    , mxWriteDirectionDispatch(new ToolbarUnoDispatcher(*mxWriteDirection, rxFrame))
+    , mxIndentButtons(m_xBuilder->weld_toolbar("indentbuttons"))
+    , mxIndentButtonsDispatch(new ToolbarUnoDispatcher(*mxIndentButtons, rxFrame))
+    , maAlignHorControl(SID_H_ALIGNCELL, *pBindings, *this)
+    , maLeftIndentControl(SID_ATTR_ALIGN_INDENT, *pBindings, *this)
+    , maMergeCellControl(FID_MERGE_TOGGLE, *pBindings, *this)
+    , maWrapTextControl(SID_ATTR_ALIGN_LINEBREAK, *pBindings, *this)
+    , maAngleControl(SID_ATTR_ALIGN_DEGREES, *pBindings, *this)
+    , maVrtStackControl(SID_ATTR_ALIGN_STACKED, *pBindings, *this)
+    , maRefEdgeControl(SID_ATTR_ALIGN_LOCKPOS, *pBindings, *this)
+    , mbMultiDisable(false)
+    , mbSettingToggles(false)
+    , maContext()
+    , mpBindings(pBindings)
 {
-    get(mpFTLeftIndent, "leftindentlabel");
-    get(mpMFLeftIndent, "leftindent");
-    get(mpCBXWrapText, "wraptext");
-    get(mpCBXMergeCell, "mergecells");
-    get(mpFtRotate, "orientationlabel");
-    get(mpMtrAngle, "orientationdegrees");
-    get(mpRefEdgeBottom, "bottom");
-    get(mpRefEdgeTop, "top");
-    get(mpRefEdgeStd, "standard");
-    get(mpCBStacked, "stacked");
-    get(mpTextOrientBox , "textorientbox");
-
     Initialize();
-
-    mpFTLeftIndent->SetBackground(Wallpaper());
-    mpFtRotate->SetBackground(Wallpaper());
 }
 
 AlignmentPropertyPanel::~AlignmentPropertyPanel()
@@ -79,17 +84,26 @@ AlignmentPropertyPanel::~AlignmentPropertyPanel()
 
 void AlignmentPropertyPanel::dispose()
 {
-    mpFTLeftIndent.clear();
-    mpMFLeftIndent.clear();
-    mpCBXWrapText.clear();
-    mpCBXMergeCell.clear();
-    mpFtRotate.clear();
-    mpMtrAngle.clear();
-    mpCBStacked.clear();
-    mpRefEdgeBottom.clear();
-    mpRefEdgeTop.clear();
-    mpRefEdgeStd.clear();
-    mpTextOrientBox.clear();
+    mxIndentButtonsDispatch.reset();
+    mxIndentButtons.reset();
+    mxWriteDirectionDispatch.reset();
+    mxWriteDirection.reset();
+    mxVertAlignDispatch.reset();
+    mxVertAlign.reset();
+    mxHorizontalAlignDispatch.reset();
+    mxHorizontalAlign.reset();
+
+    mxFTLeftIndent.reset();
+    mxMFLeftIndent.reset();
+    mxCBXWrapText.reset();
+    mxCBXMergeCell.reset();
+    mxFtRotate.reset();
+    mxMtrAngle.reset();
+    mxCBStacked.reset();
+    mxRefEdgeBottom.reset();
+    mxRefEdgeTop.reset();
+    mxRefEdgeStd.reset();
+    mxTextOrientBox.reset();
 
     maAlignHorControl.dispose();
     maLeftIndentControl.dispose();
@@ -104,121 +118,83 @@ void AlignmentPropertyPanel::dispose()
 
 void AlignmentPropertyPanel::Initialize()
 {
-    mpFTLeftIndent->Disable();
-    mpMFLeftIndent->Disable();
-    Link<Edit&,void> aLink = LINK(this, AlignmentPropertyPanel, MFLeftIndentMdyHdl);
-    mpMFLeftIndent->SetModifyHdl ( aLink );
+    mxFTLeftIndent->set_sensitive(false);
+    mxMFLeftIndent->set_sensitive(false);
+    Link<weld::MetricSpinButton&,void> aLink = LINK(this, AlignmentPropertyPanel, MFLeftIndentMdyHdl);
+    mxMFLeftIndent->connect_value_changed( aLink );
 
-    mpCBXMergeCell->SetClickHdl ( LINK(this, AlignmentPropertyPanel, CBOXMergnCellClkHdl) );
+    mxCBXMergeCell->connect_toggled( LINK(this, AlignmentPropertyPanel, CBOXMergnCellClkHdl) );
 
-    mpCBXWrapText->SetClickHdl ( LINK(this, AlignmentPropertyPanel, CBOXWrapTextClkHdl) );
+    mxCBXWrapText->connect_toggled( LINK(this, AlignmentPropertyPanel, CBOXWrapTextClkHdl) );
 
     //rotation
-    mpMtrAngle->SetModifyHdl(LINK( this, AlignmentPropertyPanel, AngleModifiedHdl));
-    mpMtrAngle->EnableAutocomplete( false );
-    mpCBStacked->SetClickHdl(LINK(this, AlignmentPropertyPanel, ClickStackHdl));
-
-    Link<Button*,void> aLink2 = LINK(this, AlignmentPropertyPanel, ReferenceEdgeHdl);
-    mpRefEdgeBottom->SetClickHdl(aLink2);
-    mpRefEdgeTop->SetClickHdl(aLink2);
-    mpRefEdgeStd->SetClickHdl(aLink2);
-
-    mpMtrAngle->InsertValue(0, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(45, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(90, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(135, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(180, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(225, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(270, FieldUnit::CUSTOM);
-    mpMtrAngle->InsertValue(315, FieldUnit::CUSTOM);
-    mpMtrAngle->SetDropDownLineCount(mpMtrAngle->GetEntryCount());
+    mxMtrAngle->connect_value_changed(LINK( this, AlignmentPropertyPanel, AngleModifiedHdl));
+    mxCBStacked->connect_toggled(LINK(this, AlignmentPropertyPanel, ClickStackHdl));
+
+    Link<weld::ToggleButton&,void> aLink2 = LINK(this, AlignmentPropertyPanel, ReferenceEdgeHdl);
+    mxRefEdgeBottom->connect_toggled(aLink2);
+    mxRefEdgeTop->connect_toggled(aLink2);
+    mxRefEdgeStd->connect_toggled(aLink2);
 }
 
-IMPL_LINK( AlignmentPropertyPanel, ReferenceEdgeHdl, Button*, pControl, void )
+IMPL_LINK(AlignmentPropertyPanel, ReferenceEdgeHdl, weld::ToggleButton&, rToggle, void)
 {
+    if (mbSettingToggles)
+        return;
     SvxRotateMode eMode;
-    if(pControl == mpRefEdgeBottom)
+    if (&rToggle == mxRefEdgeBottom.get() && mxRefEdgeBottom->get_active())
         eMode = SVX_ROTATE_MODE_BOTTOM;
-    else if(pControl == mpRefEdgeTop)
+    else if (&rToggle == mxRefEdgeTop.get() && mxRefEdgeTop->get_active())
         eMode = SVX_ROTATE_MODE_TOP;
-    else
+    else if (&rToggle == mxRefEdgeStd.get() && mxRefEdgeStd->get_active())
         eMode = SVX_ROTATE_MODE_STANDARD;
-    SvxRotateModeItem aItem(eMode,ATTR_ROTATE_MODE);
+    else
+        return;
+    SvxRotateModeItem aItem(eMode, ATTR_ROTATE_MODE);
     GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_ALIGN_LOCKPOS,
             SfxCallMode::RECORD, { &aItem });
 }
 
-IMPL_LINK_NOARG( AlignmentPropertyPanel, AngleModifiedHdl, Edit&, void )
+IMPL_LINK_NOARG( AlignmentPropertyPanel, AngleModifiedHdl, weld::MetricSpinButton&, void )
 {
-    OUString sTmp = mpMtrAngle->GetText();
-    if (sTmp.isEmpty())
-        return;
-    sal_Unicode nChar = sTmp[0];
-    if( nChar == '-' )
-    {
-        if (sTmp.getLength() < 2)
-            return;
-        nChar = sTmp[1];
-    }
-
-    if( (nChar < '0') || (nChar > '9') )
-        return;
-
-    const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() );
-
-    // Do not check that the entire string was parsed up to its end, there may
-    // be a degree symbol following the number. Note that this also means that
-    // the number recognized just stops at any non-matching character.
-    /* TODO: we could check for the degree symbol stop if there are no other
-     * cases with different symbol characters in any language? */
-    rtl_math_ConversionStatus eStatus;
-    double fTmp = rLocaleWrapper.stringToDouble( sTmp, false, &eStatus, nullptr);
-    if (eStatus != rtl_math_ConversionStatus_Ok)
-        return;
-
-    FormatDegrees(fTmp);
-
-    sal_Int64 nTmp = static_cast<sal_Int64>(fTmp)*100;
-    ScRotateValueItem aAngleItem(static_cast<sal_uInt32>(nTmp));
+    sal_uInt32 nAngle = mxMtrAngle->get_value(FieldUnit::DEGREE) * 100;
+    ScRotateValueItem aAngleItem(nAngle);
 
     GetBindings()->GetDispatcher()->ExecuteList(
         SID_ATTR_ALIGN_DEGREES, SfxCallMode::RECORD, { &aAngleItem });
 }
-IMPL_LINK_NOARG( AlignmentPropertyPanel, ClickStackHdl, Button*, void )
+
+IMPL_LINK_NOARG( AlignmentPropertyPanel, ClickStackHdl, weld::ToggleButton&, void )
 {
-    bool bVertical = mpCBStacked->IsChecked();
+    bool bVertical = mxCBStacked->get_active();
     ScVerticalStackCell aStackItem(bVertical);
     GetBindings()->GetDispatcher()->ExecuteList(
         SID_ATTR_ALIGN_STACKED, SfxCallMode::RECORD, { &aStackItem });
 }
-IMPL_LINK_NOARG(AlignmentPropertyPanel, MFLeftIndentMdyHdl, Edit&, void)
+
+IMPL_LINK_NOARG(AlignmentPropertyPanel, MFLeftIndentMdyHdl, weld::MetricSpinButton&, void)
 {
-    mpCBXWrapText->EnableTriState(false);
-    sal_uInt16 nVal = static_cast<sal_uInt16>(mpMFLeftIndent->GetValue());
-    ScIndentItem aItem(static_cast<sal_uInt16>(CalcToUnit(nVal,  MapUnit::MapTwip)));
+    sal_uInt16 nVal = mxMFLeftIndent->get_value(FieldUnit::NONE);
+    ScIndentItem aItem(static_cast<sal_uInt16>(CalcToUnit(nVal, MapUnit::MapTwip)));
 
     GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_ALIGN_INDENT,
             SfxCallMode::RECORD, { &aItem });
 }
 
-IMPL_LINK_NOARG(AlignmentPropertyPanel, CBOXMergnCellClkHdl, Button*, void)
+IMPL_LINK_NOARG(AlignmentPropertyPanel, CBOXMergnCellClkHdl, weld::ToggleButton&, void)
 {
-    bool bState = mpCBXMergeCell->IsChecked();
+    bool bState = mxCBXMergeCell->get_active();
 
-    //Modified
-    //SfxBoolItem aItem( FID_MERGE_TOGGLE , bState);
-    //GetBindings()->GetDispatcher()->Execute(FID_MERGE_TOGGLE, SfxCallMode::RECORD, &aItem, false, 0L);
-    if(bState)
+    if( bState)
         GetBindings()->GetDispatcher()->Execute(FID_MERGE_ON, SfxCallMode::RECORD);
     else
         GetBindings()->GetDispatcher()->Execute(FID_MERGE_OFF, SfxCallMode::RECORD);
     GetBindings()->Invalidate(FID_MERGE_TOGGLE,true);
-    //modified end
 }
 
-IMPL_LINK_NOARG(AlignmentPropertyPanel, CBOXWrapTextClkHdl, Button*, void)
+IMPL_LINK_NOARG(AlignmentPropertyPanel, CBOXWrapTextClkHdl, weld::ToggleButton&, void)
 {
-    bool bState = mpCBXWrapText->IsChecked();
+    bool bState = mxCBXWrapText->get_active();
     ScLineBreakCell aItem(bState);
     GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_ALIGN_LINEBREAK,
             SfxCallMode::RECORD, { &aItem });
@@ -274,17 +250,17 @@ void AlignmentPropertyPanel::NotifyItemUpdate(
 
             if( meHorAlignState == SvxCellHorJustify::Repeat )
             {
-                mpFtRotate->Disable();
-                mpMtrAngle->Disable();
+                mxFtRotate->set_sensitive(false);
+                mxMtrAngle->set_sensitive(false);
             }
             else
             {
-                mpFtRotate->Enable(!mbMultiDisable);
-                mpMtrAngle->Enable(!mbMultiDisable);
+                mxFtRotate->set_sensitive(!mbMultiDisable);
+                mxMtrAngle->set_sensitive(!mbMultiDisable);
             }
 
-            mpFTLeftIndent->Enable( meHorAlignState == SvxCellHorJustify::Left );
-            mpMFLeftIndent->Enable( meHorAlignState == SvxCellHorJustify::Left );
+            mxFTLeftIndent->set_sensitive( meHorAlignState == SvxCellHorJustify::Left );
+            mxMFLeftIndent->set_sensitive( meHorAlignState == SvxCellHorJustify::Left );
         }
         break;
     case SID_ATTR_ALIGN_INDENT:
@@ -292,128 +268,93 @@ void AlignmentPropertyPanel::NotifyItemUpdate(
         {
                 const SfxUInt16Item* pItem = static_cast<const SfxUInt16Item*>(pState);
                 sal_uInt16 nVal = pItem->GetValue();
-                mpMFLeftIndent->SetValue( CalcToPoint(nVal, MapUnit::MapTwip, 1) );
+                mxMFLeftIndent->set_value( CalcToPoint(nVal, MapUnit::MapTwip, 1), FieldUnit::NONE );
         }
         else
         {
-            mpMFLeftIndent->SetValue(0);
-            mpMFLeftIndent->SetText(OUString());
+            mxMFLeftIndent->set_value(0, FieldUnit::NONE);
+            mxMFLeftIndent->set_text(OUString());
         }
         break;
     case FID_MERGE_TOGGLE:
         if(eState >= SfxItemState::DEFAULT && dynamic_cast<const SfxBoolItem*>( pState) )
         {
-            mpCBXMergeCell->Enable();
+            mxCBXMergeCell->set_sensitive(true);
             const SfxBoolItem* pItem = static_cast<const SfxBoolItem*>(pState);
-            mpCBXMergeCell->Check(pItem->GetValue());
+            mxCBXMergeCell->set_active(pItem->GetValue());
         }
         else
         {
-            mpCBXMergeCell->Check(false);
-            mpCBXMergeCell->Disable();
+            mxCBXMergeCell->set_active(false);
+            mxCBXMergeCell->set_sensitive(false);
         }
         break;
 
     case SID_ATTR_ALIGN_LINEBREAK:
         if(eState == SfxItemState::DISABLED)
         {
-            mpCBXWrapText->EnableTriState(false);
-            mpCBXWrapText->Check(false);
-            mpCBXWrapText->Disable();
+            mxCBXWrapText->set_active(false);
+            mxCBXWrapText->set_sensitive(false);
         }
         else
         {
-            mpCBXWrapText->Enable();
+            mxCBXWrapText->set_sensitive(true);
             if(eState >= SfxItemState::DEFAULT && dynamic_cast<const ScLineBreakCell*>( pState) )
             {
-                mpCBXWrapText->EnableTriState(false);
                 const ScLineBreakCell* pItem = static_cast<const ScLineBreakCell*>(pState);
-                mpCBXWrapText->Check(pItem->GetValue());
+                mxCBXWrapText->set_active(pItem->GetValue());
             }
             else if(eState == SfxItemState::DONTCARE)
             {
-                mpCBXWrapText->EnableTriState();
-                mpCBXWrapText->SetState(TRISTATE_INDET);
+                mxCBXWrapText->set_state(TRISTATE_INDET);
             }
         }
         break;
     case SID_ATTR_ALIGN_STACKED:
         if (eState >= SfxItemState::DEFAULT)
         {
-            mpCBStacked->EnableTriState(false);
             const SfxBoolItem* pStackItem = static_cast<const ScVerticalStackCell*>(pState);
             mbMultiDisable = pStackItem->GetValue();
-            mpCBStacked->Check(mbMultiDisable);
-            mpTextOrientBox->Enable(!mbMultiDisable);
+            mxCBStacked->set_active(mbMultiDisable);
+            mxTextOrientBox->set_sensitive(!mbMultiDisable);
         }
         else
         {
             mbMultiDisable = true;
-            mpTextOrientBox->Disable();
-            mpCBStacked->EnableTriState();
-            mpCBStacked->SetState(TRISTATE_INDET);
+            mxTextOrientBox->set_sensitive(false);
+            mxCBStacked->set_state(TRISTATE_INDET);
         }
         break;
     case SID_ATTR_ALIGN_LOCKPOS:
         if( eState >= SfxItemState::DEFAULT)
         {
+            mbSettingToggles = true;
             const SvxRotateModeItem* pItem = static_cast<const SvxRotateModeItem*>(pState);
             SvxRotateMode eMode = pItem->GetValue();
             if(eMode == SVX_ROTATE_MODE_BOTTOM)
             {
-                mpRefEdgeBottom->SetState(true);
-                mpRefEdgeTop->SetState(false);
-                mpRefEdgeStd->SetState(false);
+                mxRefEdgeBottom->set_state(TRISTATE_TRUE);
             }
             else if(eMode == SVX_ROTATE_MODE_TOP)
             {
-                mpRefEdgeBottom->SetState(false);
-                mpRefEdgeStd->SetState(false);
-                mpRefEdgeTop->SetState(true);
+                mxRefEdgeTop->set_state(TRISTATE_TRUE);
             }
             else if(eMode == SVX_ROTATE_MODE_STANDARD)
             {
-                mpRefEdgeBottom->SetState(false);
-                mpRefEdgeTop->SetState(false);
-                mpRefEdgeStd->SetState(true);
+                mxRefEdgeStd->set_state(TRISTATE_TRUE);
             }
+            mbSettingToggles = false;
         }
         break;
     case SID_ATTR_ALIGN_DEGREES:
         if (eState >= SfxItemState::DEFAULT)
         {
             long nTmp = static_cast<const ScRotateValueItem*>(pState)->GetValue();
-            mpMtrAngle->SetValue( nTmp / 100);  //wj
-            switch(nTmp)
-            {
-                case 0:
-                    mpMtrAngle->SelectEntryPos(0);
-                break;
-                case 4500:
-                    mpMtrAngle->SelectEntryPos(1);
-                break;
-                case 9000:
-                    mpMtrAngle->SelectEntryPos(2);
-                break;
-                case 13500:
-                    mpMtrAngle->SelectEntryPos(3);
-                break;
-                case 18000:
-                    mpMtrAngle->SelectEntryPos(4);
-                break;
-                case 22500:
-                    mpMtrAngle->SelectEntryPos(5);
-                break;
-                case 27000:
-                    mpMtrAngle->SelectEntryPos(6);
-                break;
-                case 31500:
-                    mpMtrAngle->SelectEntryPos(7);
-            }
+            mxMtrAngle->set_value(nTmp / 100, FieldUnit::DEGREE);
         }
         else
         {
-            mpMtrAngle->SetText( OUString() );
+            mxMtrAngle->set_text( OUString() );
         }
         break;
     }
diff --git a/sc/source/ui/sidebar/AlignmentPropertyPanel.hxx b/sc/source/ui/sidebar/AlignmentPropertyPanel.hxx
index 71c8d7efafd4..5087fdda7814 100644
--- a/sc/source/ui/sidebar/AlignmentPropertyPanel.hxx
+++ b/sc/source/ui/sidebar/AlignmentPropertyPanel.hxx
@@ -21,11 +21,8 @@
 
 #include <sfx2/sidebar/ControllerItem.hxx>
 #include <sfx2/sidebar/IContextChangeReceiver.hxx>
+#include <sfx2/weldutils.hxx>
 #include <svx/sidebar/PanelLayout.hxx>
-#include <vcl/fixed.hxx>
-#include <vcl/button.hxx>
-#include <vcl/layout.hxx>
-#include <vcl/field.hxx>
 
 namespace sc { namespace sidebar {
 
@@ -63,17 +60,29 @@ public:
 
 private:
     //ui controls
-    VclPtr<FixedText>                                  mpFTLeftIndent;
-    VclPtr<MetricField>                                mpMFLeftIndent;
-    VclPtr<CheckBox>                                   mpCBXWrapText;
-    VclPtr<CheckBox>                                   mpCBXMergeCell;
-    VclPtr<FixedText>                                  mpFtRotate;
-    VclPtr<MetricBox>                                  mpMtrAngle;
-    VclPtr<RadioButton>                                mpRefEdgeBottom;
-    VclPtr<RadioButton>                                mpRefEdgeTop;
-    VclPtr<RadioButton>                                mpRefEdgeStd;
-    VclPtr<CheckBox>                                   mpCBStacked;
-    VclPtr<VclHBox>                                    mpTextOrientBox;
+    std::unique_ptr<weld::Label> mxFTLeftIndent;
+    std::unique_ptr<weld::MetricSpinButton> mxMFLeftIndent;
+    std::unique_ptr<weld::CheckButton> mxCBXWrapText;
+    std::unique_ptr<weld::CheckButton> mxCBXMergeCell;
+    std::unique_ptr<weld::Label> mxFtRotate;
+    std::unique_ptr<weld::MetricSpinButton> mxMtrAngle;
+    std::unique_ptr<weld::RadioButton> mxRefEdgeBottom;
+    std::unique_ptr<weld::RadioButton> mxRefEdgeTop;
+    std::unique_ptr<weld::RadioButton> mxRefEdgeStd;
+    std::unique_ptr<weld::CheckButton> mxCBStacked;
+    std::unique_ptr<weld::Widget> mxTextOrientBox;
+
+    std::unique_ptr<weld::Toolbar> mxHorizontalAlign;
+    std::unique_ptr<ToolbarUnoDispatcher> mxHorizontalAlignDispatch;
+
+    std::unique_ptr<weld::Toolbar> mxVertAlign;
+    std::unique_ptr<ToolbarUnoDispatcher> mxVertAlignDispatch;
+
+    std::unique_ptr<weld::Toolbar> mxWriteDirection;
+    std::unique_ptr<ToolbarUnoDispatcher> mxWriteDirectionDispatch;
+
+    std::unique_ptr<weld::Toolbar> mxIndentButtons;
+    std::unique_ptr<ToolbarUnoDispatcher> mxIndentButtonsDispatch;
 
     ::sfx2::sidebar::ControllerItem             maAlignHorControl;
     ::sfx2::sidebar::ControllerItem             maLeftIndentControl;
@@ -84,16 +93,17 @@ private:
     ::sfx2::sidebar::ControllerItem             maRefEdgeControl;
 
     bool                                        mbMultiDisable : 1;
+    bool                                        mbSettingToggles : 1;
 
     vcl::EnumContext                            maContext;
     SfxBindings* const                          mpBindings;
 
-    DECL_LINK( MFLeftIndentMdyHdl, Edit&, void );
-    DECL_LINK( CBOXMergnCellClkHdl, Button*, void );
-    DECL_LINK( CBOXWrapTextClkHdl, Button*, void );
-    DECL_LINK( AngleModifiedHdl, Edit&, void );
-    DECL_LINK( ClickStackHdl, Button*, void );
-    DECL_LINK( ReferenceEdgeHdl, Button*, void );
+    DECL_LINK( MFLeftIndentMdyHdl, weld::MetricSpinButton&, void );
+    DECL_LINK( CBOXMergnCellClkHdl, weld::ToggleButton&, void );
+    DECL_LINK( CBOXWrapTextClkHdl, weld::ToggleButton&, void );
+    DECL_LINK( AngleModifiedHdl, weld::MetricSpinButton&, void );
+    DECL_LINK( ClickStackHdl, weld::ToggleButton&, void );
+    DECL_LINK( ReferenceEdgeHdl, weld::ToggleButton&, void );
 
     void Initialize();
     static void FormatDegrees(double& dTmp);