sc/source/ui/sidebar/AlignmentPropertyPanel.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "AlignmentPropertyPanel.hxx"
  21 #include <editeng/justifyitem.hxx>
  22 #include <sc.hrc>
  23 #include <attrib.hxx>
  24 #include <scitems.hxx>
  25 #include <sfx2/bindings.hxx>
  26 #include <sfx2/dispatch.hxx>
  27 #include <svl/intitem.hxx>
  28 #include <svx/rotmodit.hxx>
  29 #include <svx/sdangitm.hxx>
  30 #include <svtools/unitconv.hxx>
  31 #include <unotools/localedatawrapper.hxx>
  32 #include <com/sun/star/lang/IllegalArgumentException.hpp>
  33 #include <boost/property_tree/json_parser.hpp>
  34 #include <sfx2/lokhelper.hxx>
  35 #include <comphelper/lok.hxx>
  36
  37 using namespace css;
  38 using namespace css::uno;
  39
  40 // namespace open
  41
  42 namespace sc::sidebar {
  43
  44 AlignmentPropertyPanel::AlignmentPropertyPanel(
  45     vcl::Window* pParent,
  46     const css::uno::Reference<css::frame::XFrame>& rxFrame,
  47     SfxBindings* pBindings)
  48     : PanelLayout(pParent, "AlignmentPropertyPanel", "modules/scalc/ui/sidebaralignment.ui", rxFrame, true)
  49     , mxFTLeftIndent(m_xBuilder->weld_label("leftindentlabel"))
  50     , mxMFLeftIndent(m_xBuilder->weld_metric_spin_button("leftindent", FieldUnit::POINT))
  51     , mxCBXWrapText(m_xBuilder->weld_check_button("wraptext"))
  52     , mxCBXMergeCell(m_xBuilder->weld_check_button("mergecells"))
  53     , mxFtRotate(m_xBuilder->weld_label("orientationlabel"))
  54     , mxMtrAngle(m_xBuilder->weld_metric_spin_button("orientationdegrees", FieldUnit::DEGREE))
  55     , mxRefEdgeBottom(m_xBuilder->weld_radio_button("bottom"))
  56     , mxRefEdgeTop(m_xBuilder->weld_radio_button("top"))
  57     , mxRefEdgeStd(m_xBuilder->weld_radio_button("standard"))
  58     , mxCBStacked(m_xBuilder->weld_check_button("stacked"))
  59     , mxTextOrientBox(m_xBuilder->weld_widget("textorientbox"))
  60     , mxHorizontalAlign(m_xBuilder->weld_toolbar("horizontalalignment"))
  61     , mxHorizontalAlignDispatch(new ToolbarUnoDispatcher(*mxHorizontalAlign, rxFrame))
  62     , mxVertAlign(m_xBuilder->weld_toolbar("verticalalignment"))
  63     , mxVertAlignDispatch(new ToolbarUnoDispatcher(*mxVertAlign, rxFrame))
  64     , mxWriteDirection(m_xBuilder->weld_toolbar("writedirection"))
  65     , mxWriteDirectionDispatch(new ToolbarUnoDispatcher(*mxWriteDirection, rxFrame))
  66     , mxIndentButtons(m_xBuilder->weld_toolbar("indentbuttons"))
  67     , mxIndentButtonsDispatch(new ToolbarUnoDispatcher(*mxIndentButtons, rxFrame))
  68     , maAlignHorControl(SID_H_ALIGNCELL, *pBindings, *this)
  69     , maLeftIndentControl(SID_ATTR_ALIGN_INDENT, *pBindings, *this)
  70     , maMergeCellControl(FID_MERGE_TOGGLE, *pBindings, *this)
  71     , maWrapTextControl(SID_ATTR_ALIGN_LINEBREAK, *pBindings, *this)
  72     , maAngleControl(SID_ATTR_ALIGN_DEGREES, *pBindings, *this)
  73     , maVrtStackControl(SID_ATTR_ALIGN_STACKED, *pBindings, *this)
  74     , maRefEdgeControl(SID_ATTR_ALIGN_LOCKPOS, *pBindings, *this)
  75     , mbMultiDisable(false)
  76     , mbSettingToggles(false)
  77     , maContext()
  78     , mpBindings(pBindings)
  79 {
  80     Initialize();
  81 }
  82
  83 AlignmentPropertyPanel::~AlignmentPropertyPanel()
  84 {
  85     disposeOnce();
  86 }
  87
  88 void AlignmentPropertyPanel::dispose()
  89 {
  90     mxIndentButtonsDispatch.reset();
  91     mxIndentButtons.reset();
  92     mxWriteDirectionDispatch.reset();
  93     mxWriteDirection.reset();
  94     mxVertAlignDispatch.reset();
  95     mxVertAlign.reset();
  96     mxHorizontalAlignDispatch.reset();
  97     mxHorizontalAlign.reset();
  98
  99     mxFTLeftIndent.reset();
 100     mxMFLeftIndent.reset();
 101     mxCBXWrapText.reset();
 102     mxCBXMergeCell.reset();
 103     mxFtRotate.reset();
 104     mxMtrAngle.reset();
 105     mxCBStacked.reset();
 106     mxRefEdgeBottom.reset();
 107     mxRefEdgeTop.reset();
 108     mxRefEdgeStd.reset();
 109     mxTextOrientBox.reset();
 110
 111     maAlignHorControl.dispose();
 112     maLeftIndentControl.dispose();
 113     maMergeCellControl.dispose();
 114     maWrapTextControl.dispose();
 115     maAngleControl.dispose();
 116     maVrtStackControl.dispose();
 117     maRefEdgeControl.dispose();
 118
 119     PanelLayout::dispose();
 120 }
 121
 122 void AlignmentPropertyPanel::Initialize()
 123 {
 124     mxFTLeftIndent->set_sensitive(false);
 125     mxMFLeftIndent->set_sensitive(false);
 126     Link<weld::MetricSpinButton&,void> aLink = LINK(this, AlignmentPropertyPanel, MFLeftIndentMdyHdl);
 127     mxMFLeftIndent->connect_value_changed( aLink );
 128
 129     mxCBXMergeCell->connect_toggled( LINK(this, AlignmentPropertyPanel, CBOXMergnCellClkHdl) );
 130
 131     mxCBXWrapText->connect_toggled( LINK(this, AlignmentPropertyPanel, CBOXWrapTextClkHdl) );
 132
 133     //rotation
 134     mxMtrAngle->connect_value_changed(LINK( this, AlignmentPropertyPanel, AngleModifiedHdl));
 135     mxCBStacked->connect_toggled(LINK(this, AlignmentPropertyPanel, ClickStackHdl));
 136
 137     Link<weld::ToggleButton&,void> aLink2 = LINK(this, AlignmentPropertyPanel, ReferenceEdgeHdl);
 138     mxRefEdgeBottom->connect_toggled(aLink2);
 139     mxRefEdgeTop->connect_toggled(aLink2);
 140     mxRefEdgeStd->connect_toggled(aLink2);
 141 }
 142
 143 namespace {
 144
 145 void eraseNode(boost::property_tree::ptree& pTree, const std::string& aValue)
 146 {
 147     boost::optional<boost::property_tree::ptree&> pId;
 148     boost::optional<boost::property_tree::ptree&> pSubTree = pTree.get_child_optional("children");
 149
 150     if (pSubTree)
 151     {
 152         boost::property_tree::ptree::iterator itFound = pSubTree.get().end();
 153         for (boost::property_tree::ptree::iterator it = pSubTree.get().begin(); it != pSubTree.get().end(); ++it)
 154         {
 155             pId = it->second.get_child_optional("id");
 156             if (pId && pId.get().get_value<std::string>("") == aValue)
 157             {
 158                 itFound = it;
 159                 break;
 160             }
 161
 162             eraseNode(it->second, aValue);
 163         }
 164
 165         if (itFound != pSubTree.get().end())
 166         {
 167             pSubTree.get().erase(itFound);
 168         }
 169     }
 170 }
 171
 172 }
 173
 174 boost::property_tree::ptree AlignmentPropertyPanel::DumpAsPropertyTree()
 175 {
 176     boost::property_tree::ptree aTree = PanelLayout::DumpAsPropertyTree();
 177
 178     if (comphelper::LibreOfficeKit::isMobile(SfxLokHelper::getView()))
 179     {
 180         eraseNode(aTree, "textorientbox");
 181     }
 182
 183     return aTree;
 184 }
 185
 186 IMPL_LINK(AlignmentPropertyPanel, ReferenceEdgeHdl, weld::ToggleButton&, rToggle, void)
 187 {
 188     if (mbSettingToggles)
 189         return;
 190     SvxRotateMode eMode;
 191     if (&rToggle == mxRefEdgeBottom.get() && mxRefEdgeBottom->get_active())
 192         eMode = SVX_ROTATE_MODE_BOTTOM;
 193     else if (&rToggle == mxRefEdgeTop.get() && mxRefEdgeTop->get_active())
 194         eMode = SVX_ROTATE_MODE_TOP;
 195     else if (&rToggle == mxRefEdgeStd.get() && mxRefEdgeStd->get_active())
 196         eMode = SVX_ROTATE_MODE_STANDARD;
 197     else
 198         return;
 199     SvxRotateModeItem aItem(eMode, ATTR_ROTATE_MODE);
 200     GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_ALIGN_LOCKPOS,
 201             SfxCallMode::RECORD, { &aItem });
 202 }
 203
 204 IMPL_LINK_NOARG( AlignmentPropertyPanel, AngleModifiedHdl, weld::MetricSpinButton&, void )
 205 {
 206     sal_uInt32 nAngle = mxMtrAngle->get_value(FieldUnit::DEGREE) * 100;
 207     ScRotateValueItem aAngleItem(nAngle);
 208
 209     GetBindings()->GetDispatcher()->ExecuteList(
 210         SID_ATTR_ALIGN_DEGREES, SfxCallMode::RECORD, { &aAngleItem });
 211 }
 212
 213 IMPL_LINK_NOARG( AlignmentPropertyPanel, ClickStackHdl, weld::ToggleButton&, void )
 214 {
 215     bool bVertical = mxCBStacked->get_active();
 216     ScVerticalStackCell aStackItem(bVertical);
 217     GetBindings()->GetDispatcher()->ExecuteList(
 218         SID_ATTR_ALIGN_STACKED, SfxCallMode::RECORD, { &aStackItem });
 219 }
 220
 221 IMPL_LINK_NOARG(AlignmentPropertyPanel, MFLeftIndentMdyHdl, weld::MetricSpinButton&, void)
 222 {
 223     sal_uInt16 nVal = mxMFLeftIndent->get_value(FieldUnit::NONE);
 224     ScIndentItem aItem(static_cast<sal_uInt16>(CalcToUnit(nVal, MapUnit::MapTwip)));
 225
 226     GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_ALIGN_INDENT,
 227             SfxCallMode::RECORD, { &aItem });
 228 }
 229
 230 IMPL_LINK_NOARG(AlignmentPropertyPanel, CBOXMergnCellClkHdl, weld::ToggleButton&, void)
 231 {
 232     bool bState = mxCBXMergeCell->get_active();
 233
 234     if( bState)
 235         GetBindings()->GetDispatcher()->Execute(FID_MERGE_ON, SfxCallMode::RECORD);
 236     else
 237         GetBindings()->GetDispatcher()->Execute(FID_MERGE_OFF, SfxCallMode::RECORD);
 238     GetBindings()->Invalidate(FID_MERGE_TOGGLE,true);
 239 }
 240
 241 IMPL_LINK_NOARG(AlignmentPropertyPanel, CBOXWrapTextClkHdl, weld::ToggleButton&, void)
 242 {
 243     bool bState = mxCBXWrapText->get_active();
 244     ScLineBreakCell aItem(bState);
 245     GetBindings()->GetDispatcher()->ExecuteList(SID_ATTR_ALIGN_LINEBREAK,
 246             SfxCallMode::RECORD, { &aItem });
 247 }
 248
 249 VclPtr<vcl::Window> AlignmentPropertyPanel::Create (
 250     vcl::Window* pParent,
 251     const css::uno::Reference<css::frame::XFrame>& rxFrame,
 252     SfxBindings* pBindings)
 253 {
 254     if (pParent == nullptr)
 255         throw lang::IllegalArgumentException("no parent Window given to AlignmentPropertyPanel::Create", nullptr, 0);
 256     if ( ! rxFrame.is())
 257         throw lang::IllegalArgumentException("no XFrame given to AlignmentPropertyPanel::Create", nullptr, 1);
 258     if (pBindings == nullptr)
 259         throw lang::IllegalArgumentException("no SfxBindings given to AlignmentPropertyPanel::Create", nullptr, 2);
 260
 261     return  VclPtr<AlignmentPropertyPanel>::Create(
 262                         pParent, rxFrame, pBindings);
 263 }
 264
 265 void AlignmentPropertyPanel::DataChanged(
 266     const DataChangedEvent&)
 267 {}
 268
 269 void AlignmentPropertyPanel::HandleContextChange(
 270     const vcl::EnumContext& rContext)
 271 {
 272     if (maContext == rContext)
 273     {
 274         // Nothing to do.
 275         return;
 276     }
 277
 278     maContext = rContext;
 279 }
 280
 281 void AlignmentPropertyPanel::NotifyItemUpdate(
 282     sal_uInt16 nSID,
 283     SfxItemState eState,
 284     const SfxPoolItem* pState)
 285 {
 286     switch(nSID)
 287     {
 288     case SID_H_ALIGNCELL:
 289         {
 290             SvxCellHorJustify meHorAlignState = SvxCellHorJustify::Standard;
 291             if(eState >= SfxItemState::DEFAULT && dynamic_cast<const SvxHorJustifyItem*>( pState) )
 292             {
 293                 const SvxHorJustifyItem* pItem = static_cast<const SvxHorJustifyItem*>(pState);
 294                 meHorAlignState = pItem->GetValue();
 295             }
 296
 297             if( meHorAlignState == SvxCellHorJustify::Repeat )
 298             {
 299                 mxFtRotate->set_sensitive(false);
 300                 mxMtrAngle->set_sensitive(false);
 301             }
 302             else
 303             {
 304                 mxFtRotate->set_sensitive(!mbMultiDisable);
 305                 mxMtrAngle->set_sensitive(!mbMultiDisable);
 306             }
 307
 308             mxFTLeftIndent->set_sensitive( meHorAlignState == SvxCellHorJustify::Left );
 309             mxMFLeftIndent->set_sensitive( meHorAlignState == SvxCellHorJustify::Left );
 310         }
 311         break;
 312     case SID_ATTR_ALIGN_INDENT:
 313         if(eState >= SfxItemState::DEFAULT && dynamic_cast<const SfxUInt16Item*>( pState) )
 314         {
 315                 const SfxUInt16Item* pItem = static_cast<const SfxUInt16Item*>(pState);
 316                 sal_uInt16 nVal = pItem->GetValue();
 317                 mxMFLeftIndent->set_value( CalcToPoint(nVal, MapUnit::MapTwip, 1), FieldUnit::NONE );
 318         }
 319         else
 320         {
 321             mxMFLeftIndent->set_value(0, FieldUnit::NONE);
 322             mxMFLeftIndent->set_text(OUString());
 323         }
 324         break;
 325     case FID_MERGE_TOGGLE:
 326         if(eState >= SfxItemState::DEFAULT && dynamic_cast<const SfxBoolItem*>( pState) )
 327         {
 328             mxCBXMergeCell->set_sensitive(true);
 329             const SfxBoolItem* pItem = static_cast<const SfxBoolItem*>(pState);
 330             mxCBXMergeCell->set_active(pItem->GetValue());
 331         }
 332         else
 333         {
 334             mxCBXMergeCell->set_active(false);
 335             mxCBXMergeCell->set_sensitive(false);
 336         }
 337         break;
 338
 339     case SID_ATTR_ALIGN_LINEBREAK:
 340         if(eState == SfxItemState::DISABLED)
 341         {
 342             mxCBXWrapText->set_active(false);
 343             mxCBXWrapText->set_sensitive(false);
 344         }
 345         else
 346         {
 347             mxCBXWrapText->set_sensitive(true);
 348             if(eState >= SfxItemState::DEFAULT && dynamic_cast<const ScLineBreakCell*>( pState) )
 349             {
 350                 const ScLineBreakCell* pItem = static_cast<const ScLineBreakCell*>(pState);
 351                 mxCBXWrapText->set_active(pItem->GetValue());
 352             }
 353             else if(eState == SfxItemState::DONTCARE)
 354             {
 355                 mxCBXWrapText->set_state(TRISTATE_INDET);
 356             }
 357         }
 358         break;
 359     case SID_ATTR_ALIGN_STACKED:
 360         if (eState >= SfxItemState::DEFAULT)
 361         {
 362             const SfxBoolItem* pStackItem = static_cast<const ScVerticalStackCell*>(pState);
 363             mbMultiDisable = pStackItem->GetValue();
 364             mxCBStacked->set_active(mbMultiDisable);
 365             mxTextOrientBox->set_sensitive(!mbMultiDisable);
 366         }
 367         else
 368         {
 369             mbMultiDisable = true;
 370             mxTextOrientBox->set_sensitive(false);
 371             mxCBStacked->set_state(TRISTATE_INDET);
 372         }
 373         break;
 374     case SID_ATTR_ALIGN_LOCKPOS:
 375         if( eState >= SfxItemState::DEFAULT)
 376         {
 377             mbSettingToggles = true;
 378             const SvxRotateModeItem* pItem = static_cast<const SvxRotateModeItem*>(pState);
 379             SvxRotateMode eMode = pItem->GetValue();
 380             if(eMode == SVX_ROTATE_MODE_BOTTOM)
 381             {
 382                 mxRefEdgeBottom->set_state(TRISTATE_TRUE);
 383             }
 384             else if(eMode == SVX_ROTATE_MODE_TOP)
 385             {
 386                 mxRefEdgeTop->set_state(TRISTATE_TRUE);
 387             }
 388             else if(eMode == SVX_ROTATE_MODE_STANDARD)
 389             {
 390                 mxRefEdgeStd->set_state(TRISTATE_TRUE);
 391             }
 392             mbSettingToggles = false;
 393         }
 394         break;
 395     case SID_ATTR_ALIGN_DEGREES:
 396         if (eState >= SfxItemState::DEFAULT)
 397         {
 398             long nTmp = static_cast<const ScRotateValueItem*>(pState)->GetValue();
 399             mxMtrAngle->set_value(nTmp / 100, FieldUnit::DEGREE);
 400         }
 401         else
 402         {
 403             mxMtrAngle->set_text( OUString() );
 404         }
 405         break;
 406     }
 407 }
 408
 409 // namespace close
 410
 411 } // end of namespace ::sc::sidebar
 412
 413 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */