cui/source/tabpages/align.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 <align.hxx>
  21
  22 #include <editeng/svxenum.hxx>
  23 #include <svx/svxids.hrc>
  24 #include <svx/strings.hrc>
  25 #include <svx/dialmgr.hxx>
  26 #include <bitmaps.hlst>
  27 #include <svx/rotmodit.hxx>
  28
  29 #include <editeng/frmdiritem.hxx>
  30 #include <editeng/justifyitem.hxx>
  31 #include <svl/cjkoptions.hxx>
  32 #include <svl/intitem.hxx>
  33 #include <vcl/settings.hxx>
  34 #include <vcl/event.hxx>
  35
  36 #define IID_BOTTOMLOCK 1
  37 #define IID_TOPLOCK    2
  38 #define IID_CELLLOCK   3
  39
  40 namespace svx {
  41
  42 const sal_uInt16 AlignmentTabPage::s_pRanges[] =
  43 {
  44     SID_ATTR_ALIGN_HOR_JUSTIFY,SID_ATTR_ALIGN_VER_JUSTIFY,
  45     SID_ATTR_ALIGN_STACKED,SID_ATTR_ALIGN_LINEBREAK,
  46     SID_ATTR_ALIGN_INDENT,SID_ATTR_ALIGN_INDENT,
  47     SID_ATTR_ALIGN_DEGREES,SID_ATTR_ALIGN_DEGREES,
  48     SID_ATTR_ALIGN_LOCKPOS,SID_ATTR_ALIGN_LOCKPOS,
  49     SID_ATTR_ALIGN_HYPHENATION,SID_ATTR_ALIGN_HYPHENATION,
  50     SID_ATTR_ALIGN_ASIANVERTICAL,SID_ATTR_ALIGN_ASIANVERTICAL,
  51     SID_ATTR_FRAMEDIRECTION,SID_ATTR_FRAMEDIRECTION,
  52     SID_ATTR_ALIGN_SHRINKTOFIT,SID_ATTR_ALIGN_SHRINKTOFIT,
  53     0
  54 };
  55
  56
  57 namespace {
  58
  59 template<typename JustContainerType, typename JustEnumType>
  60 void lcl_MaybeResetAlignToDistro(
  61     weld::ComboBox& rLB, sal_uInt16 nListPos, const SfxItemSet& rCoreAttrs, sal_uInt16 nWhichAlign, sal_uInt16 nWhichJM, JustEnumType eBlock)
  62 {
  63     const SfxPoolItem* pItem;
  64     if (rCoreAttrs.GetItemState(nWhichAlign, true, &pItem) != SfxItemState::SET)
  65         // alignment not set.
  66         return;
  67
  68     const SfxEnumItemInterface* p = static_cast<const SfxEnumItemInterface*>(pItem);
  69     JustContainerType eVal = static_cast<JustContainerType>(p->GetEnumValue());
  70     if (eVal != eBlock)
  71         // alignment is not 'justify'.  No need to go further.
  72         return;
  73
  74     if (rCoreAttrs.GetItemState(nWhichJM, true, &pItem) != SfxItemState::SET)
  75         // justification method is not set.
  76         return;
  77
  78     p = static_cast<const SfxEnumItemInterface*>(pItem);
  79     SvxCellJustifyMethod eMethod = static_cast<SvxCellJustifyMethod>(p->GetEnumValue());
  80     if (eMethod == SvxCellJustifyMethod::Distribute)
  81     {
  82         // Select the 'distribute' entry in the specified list box.
  83         rLB.set_active(nListPos);
  84     }
  85 }
  86
  87 void lcl_SetJustifyMethodToItemSet(SfxItemSet& rSet, const SfxItemSet& rOldSet, sal_uInt16 nWhichJM, const weld::ComboBox& rLB, sal_uInt16 nListPos)
  88 {
  89     SvxCellJustifyMethod eJM = SvxCellJustifyMethod::Auto;
  90     if (rLB.get_active() == nListPos)
  91         eJM = SvxCellJustifyMethod::Distribute;
  92
  93     // tdf#129300 If it would create no change, don't force it
  94     const SvxJustifyMethodItem& rOldItem = static_cast<const SvxJustifyMethodItem&>(rOldSet.Get(nWhichJM));
  95     if (rOldItem.GetValue() == eJM)
  96     {
  97         rSet.InvalidateItem(nWhichJM);
  98         return;
  99     }
 100
 101     SvxJustifyMethodItem aItem(eJM, nWhichJM);
 102     rSet.Put(aItem);
 103 }
 104
 105 }//namespace
 106
 107 AlignmentTabPage::AlignmentTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rCoreAttrs)
 108     : SfxTabPage(pPage, pController, "cui/ui/cellalignment.ui", "CellAlignPage", &rCoreAttrs)
 109     , m_aVsRefEdge(nullptr)
 110     // text alignment
 111     , m_xLbHorAlign(m_xBuilder->weld_combo_box("comboboxHorzAlign"))
 112     , m_xFtIndent(m_xBuilder->weld_label("labelIndent"))
 113     , m_xEdIndent(m_xBuilder->weld_metric_spin_button("spinIndentFrom", FieldUnit::POINT))
 114     , m_xFtVerAlign(m_xBuilder->weld_label("labelVertAlign"))
 115     , m_xLbVerAlign(m_xBuilder->weld_combo_box("comboboxVertAlign"))
 116     //text rotation
 117     , m_xFtRotate(m_xBuilder->weld_label("labelDegrees"))
 118     , m_xNfRotate(m_xBuilder->weld_spin_button("spinDegrees"))
 119     , m_xFtRefEdge(m_xBuilder->weld_label("labelRefEdge"))
 120     //Asian mode
 121     , m_xCbStacked(m_xBuilder->weld_check_button("checkVertStack"))
 122     , m_xCbAsianMode(m_xBuilder->weld_check_button("checkAsianMode"))
 123     // Properties
 124     , m_xBoxDirection(m_xBuilder->weld_widget("boxDirection"))
 125     , m_xBtnWrap(m_xBuilder->weld_check_button("checkWrapTextAuto"))
 126     , m_xBtnHyphen(m_xBuilder->weld_check_button("checkHyphActive"))
 127     , m_xBtnShrink(m_xBuilder->weld_check_button("checkShrinkFitCellSize"))
 128     , m_xLbFrameDir(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("comboTextDirBox")))
 129     //ValueSet hover strings
 130     , m_xFtBotLock(m_xBuilder->weld_label("labelSTR_BOTTOMLOCK"))
 131     , m_xFtTopLock(m_xBuilder->weld_label("labelSTR_TOPLOCK"))
 132     , m_xFtCelLock(m_xBuilder->weld_label("labelSTR_CELLLOCK"))
 133     , m_xFtABCD(m_xBuilder->weld_label("labelABCD"))
 134     , m_xAlignmentFrame(m_xBuilder->weld_widget("alignment"))
 135     , m_xOrientFrame(m_xBuilder->weld_widget("orientation"))
 136     , m_xPropertiesFrame(m_xBuilder->weld_widget("properties"))
 137     , m_xVsRefEdge(new weld::CustomWeld(*m_xBuilder, "references", m_aVsRefEdge))
 138     , m_xCtrlDial(new weld::CustomWeld(*m_xBuilder, "dialcontrol", m_aCtrlDial))
 139 {
 140     m_aCtrlDial.SetLinkedField(m_xNfRotate.get());
 141     m_aCtrlDial.SetText(m_xFtABCD->get_label());
 142
 143     InitVsRefEgde();
 144
 145     m_xLbHorAlign->connect_changed(LINK(this, AlignmentTabPage, UpdateEnableHdl));
 146
 147     m_xCbStacked->connect_toggled(LINK(this, AlignmentTabPage, StackedClickHdl));
 148     m_xCbAsianMode->connect_toggled(LINK(this, AlignmentTabPage, AsianModeClickHdl));
 149     m_xBtnWrap->connect_toggled(LINK(this, AlignmentTabPage, WrapClickHdl));
 150     m_xBtnHyphen->connect_toggled(LINK(this, AlignmentTabPage, HyphenClickHdl));
 151     m_xBtnShrink->connect_toggled(LINK(this, AlignmentTabPage, ShrinkClickHdl));
 152
 153     // Asian vertical mode
 154     m_xCbAsianMode->set_visible(SvtCJKOptions().IsVerticalTextEnabled());
 155
 156     m_xLbFrameDir->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTR));
 157     m_xLbFrameDir->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTL));
 158     m_xLbFrameDir->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPER));
 159
 160     // This page needs ExchangeSupport.
 161     SetExchangeSupport();
 162 }
 163
 164 AlignmentTabPage::~AlignmentTabPage()
 165 {
 166     m_xCtrlDial.reset();
 167     m_xVsRefEdge.reset();
 168     m_xLbFrameDir.reset();
 169 }
 170
 171 std::unique_ptr<SfxTabPage> AlignmentTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet)
 172 {
 173     return std::make_unique<AlignmentTabPage>(pPage, pController, *rAttrSet);
 174 }
 175
 176 bool AlignmentTabPage::FillItemSet( SfxItemSet* rSet )
 177 {
 178     const SfxItemSet& rOldSet = GetItemSet();
 179
 180     bool bChanged = SfxTabPage::FillItemSet(rSet);
 181
 182     if (m_xLbHorAlign->get_value_changed_from_saved())
 183     {
 184         SvxCellHorJustify eJustify(SvxCellHorJustify::Standard);
 185         switch (m_xLbHorAlign->get_active_id().toInt32())
 186         {
 187             case ALIGNDLG_HORALIGN_STD:
 188                 eJustify = SvxCellHorJustify::Standard;
 189                 break;
 190             case ALIGNDLG_HORALIGN_LEFT:
 191                 eJustify = SvxCellHorJustify::Left;
 192                 break;
 193             case ALIGNDLG_HORALIGN_CENTER:
 194                 eJustify = SvxCellHorJustify::Center;
 195                 break;
 196             case ALIGNDLG_HORALIGN_RIGHT:
 197                 eJustify = SvxCellHorJustify::Right;
 198                 break;
 199             case ALIGNDLG_HORALIGN_BLOCK:
 200             case ALIGNDLG_HORALIGN_DISTRIBUTED:
 201                 eJustify = SvxCellHorJustify::Block;
 202                 break;
 203             case ALIGNDLG_HORALIGN_FILL:
 204                 eJustify = SvxCellHorJustify::Repeat;
 205                 break;
 206         }
 207         rSet->Put(SvxHorJustifyItem(eJustify, GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY)));
 208         bChanged = true;
 209     }
 210
 211     if (m_xEdIndent->get_value_changed_from_saved())
 212     {
 213         rSet->Put(SfxUInt16Item(GetWhich(SID_ATTR_ALIGN_INDENT), m_xEdIndent->get_value(FieldUnit::TWIP)));
 214         bChanged = true;
 215     }
 216
 217     if (m_xLbVerAlign->get_value_changed_from_saved())
 218     {
 219         SvxCellVerJustify eJustify(SvxCellVerJustify::Standard);
 220         switch (m_xLbVerAlign->get_active_id().toInt32())
 221         {
 222             case ALIGNDLG_VERALIGN_STD:
 223                 eJustify = SvxCellVerJustify::Standard;
 224                 break;
 225             case ALIGNDLG_VERALIGN_TOP:
 226                 eJustify = SvxCellVerJustify::Top;
 227                 break;
 228             case ALIGNDLG_VERALIGN_MID:
 229                 eJustify = SvxCellVerJustify::Center;
 230                 break;
 231             case ALIGNDLG_VERALIGN_BOTTOM:
 232                 eJustify = SvxCellVerJustify::Bottom;
 233                 break;
 234             case ALIGNDLG_VERALIGN_BLOCK:
 235             case ALIGNDLG_VERALIGN_DISTRIBUTED:
 236                 eJustify = SvxCellVerJustify::Block;
 237                 break;
 238         }
 239         rSet->Put(SvxVerJustifyItem(eJustify, GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY)));
 240         bChanged = true;
 241     }
 242
 243     if (m_xNfRotate->get_value_changed_from_saved())
 244     {
 245         rSet->Put(SfxInt32Item(GetWhich(SID_ATTR_ALIGN_DEGREES), m_aCtrlDial.GetRotation()));
 246         bChanged = true;
 247     }
 248
 249     if (m_aVsRefEdge.IsValueChangedFromSaved())
 250     {
 251         switch (m_aVsRefEdge.GetSelectedItemId())
 252         {
 253             case IID_CELLLOCK:
 254                 rSet->Put(SvxRotateModeItem(SvxRotateMode::SVX_ROTATE_MODE_STANDARD, GetWhich(SID_ATTR_ALIGN_LOCKPOS)));
 255                 break;
 256             case IID_TOPLOCK:
 257                 rSet->Put(SvxRotateModeItem(SvxRotateMode::SVX_ROTATE_MODE_TOP, GetWhich(SID_ATTR_ALIGN_LOCKPOS)));
 258                 break;
 259             case IID_BOTTOMLOCK:
 260                 rSet->Put(SvxRotateModeItem(SvxRotateMode::SVX_ROTATE_MODE_BOTTOM, GetWhich(SID_ATTR_ALIGN_LOCKPOS)));
 261                 break;
 262             default:
 263                 m_aVsRefEdge.SetNoSelection();
 264                 break;
 265         }
 266         bChanged = true;
 267     }
 268
 269     if (m_xCbStacked->get_state_changed_from_saved())
 270     {
 271         rSet->Put(SfxBoolItem(GetWhich(SID_ATTR_ALIGN_STACKED), m_xCbStacked->get_active()));
 272         bChanged = true;
 273     }
 274
 275     if (m_xCbAsianMode->get_state_changed_from_saved())
 276     {
 277         rSet->Put(SfxBoolItem(GetWhich(SID_ATTR_ALIGN_ASIANVERTICAL), m_xCbAsianMode->get_active()));
 278         bChanged = true;
 279     }
 280
 281     if (m_xBtnWrap->get_state_changed_from_saved())
 282     {
 283         rSet->Put(SfxBoolItem(GetWhich(SID_ATTR_ALIGN_LINEBREAK), m_xBtnWrap->get_active()));
 284         bChanged = true;
 285     }
 286
 287     if (m_xBtnHyphen->get_state_changed_from_saved())
 288     {
 289         rSet->Put(SfxBoolItem(GetWhich(SID_ATTR_ALIGN_HYPHENATION), m_xBtnHyphen->get_active()));
 290         bChanged = true;
 291     }
 292
 293     if (m_xBtnShrink->get_state_changed_from_saved())
 294     {
 295         rSet->Put(SfxBoolItem(GetWhich(SID_ATTR_ALIGN_SHRINKTOFIT), m_xBtnShrink->get_active()));
 296         bChanged = true;
 297     }
 298
 299     if (m_xLbFrameDir->get_visible())
 300     {
 301         if (m_xLbFrameDir->get_value_changed_from_saved())
 302         {
 303             SvxFrameDirection eDir = m_xLbFrameDir->get_active_id();
 304             rSet->Put(SvxFrameDirectionItem(eDir, GetWhich(SID_ATTR_FRAMEDIRECTION)));
 305             bChanged = true;
 306         }
 307     }
 308
 309     // Special treatment for distributed alignment; we need to set the justify
 310     // method to 'distribute' to distinguish from the normal justification.
 311
 312     sal_uInt16 nWhichHorJM = GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY_METHOD);
 313     lcl_SetJustifyMethodToItemSet(*rSet, rOldSet, nWhichHorJM, *m_xLbHorAlign, ALIGNDLG_HORALIGN_DISTRIBUTED);
 314     if (!bChanged)
 315         bChanged = HasAlignmentChanged(*rSet, nWhichHorJM);
 316
 317     sal_uInt16 nWhichVerJM = GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY_METHOD);
 318     lcl_SetJustifyMethodToItemSet(*rSet, rOldSet, nWhichVerJM, *m_xLbVerAlign, ALIGNDLG_VERALIGN_DISTRIBUTED);
 319     if (!bChanged)
 320         bChanged = HasAlignmentChanged(*rSet, nWhichVerJM);
 321
 322     return bChanged;
 323 }
 324
 325 namespace
 326 {
 327     void ResetBool(sal_uInt16 nWhich, const SfxItemSet* pSet, weld::CheckButton& rBtn, weld::TriStateEnabled& rTriState)
 328     {
 329         SfxItemState eState = pSet->GetItemState(nWhich);
 330         switch (eState)
 331         {
 332             case SfxItemState::UNKNOWN:
 333                 rBtn.hide();
 334                 rTriState.bTriStateEnabled = false;
 335                 break;
 336             case SfxItemState::DISABLED:
 337             case SfxItemState::READONLY:
 338                 rBtn.set_sensitive(false);
 339                 rTriState.bTriStateEnabled = false;
 340                 break;
 341             case SfxItemState::DONTCARE:
 342                 rBtn.set_state(TRISTATE_INDET);
 343                 rTriState.bTriStateEnabled = true;
 344                 break;
 345             case SfxItemState::DEFAULT:
 346             case SfxItemState::SET:
 347             {
 348                 const SfxBoolItem& rItem = static_cast<const SfxBoolItem&>(pSet->Get(nWhich));
 349                 rBtn.set_state(static_cast<TriState>(rItem.GetValue()));
 350                 rTriState.bTriStateEnabled = false;
 351                 break;
 352             }
 353         }
 354         rBtn.save_state();
 355     }
 356 }
 357
 358 void AlignmentTabPage::Reset(const SfxItemSet* pCoreAttrs)
 359 {
 360     SfxTabPage::Reset(pCoreAttrs);
 361
 362     ResetBool(GetWhich(SID_ATTR_ALIGN_STACKED), pCoreAttrs, *m_xCbStacked, m_aStackedState);
 363     ResetBool(GetWhich(SID_ATTR_ALIGN_ASIANVERTICAL), pCoreAttrs, *m_xCbAsianMode, m_aAsianModeState);
 364     ResetBool(GetWhich(SID_ATTR_ALIGN_LINEBREAK), pCoreAttrs, *m_xBtnWrap, m_aWrapState);
 365     ResetBool(GetWhich(SID_ATTR_ALIGN_HYPHENATION), pCoreAttrs, *m_xBtnHyphen, m_aHyphenState);
 366     ResetBool(GetWhich(SID_ATTR_ALIGN_SHRINKTOFIT), pCoreAttrs, *m_xBtnShrink, m_aShrinkState);
 367
 368     sal_uInt16 nWhich = GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY);
 369     SfxItemState eState = pCoreAttrs->GetItemState(nWhich);
 370     switch (eState)
 371     {
 372         case SfxItemState::UNKNOWN:
 373             m_xLbHorAlign->hide();
 374             break;
 375         case SfxItemState::DISABLED:
 376         case SfxItemState::READONLY:
 377             m_xLbHorAlign->set_sensitive(false);
 378             break;
 379         case SfxItemState::DONTCARE:
 380             m_xLbHorAlign->set_active(-1);
 381             break;
 382         case SfxItemState::DEFAULT:
 383         case SfxItemState::SET:
 384         {
 385             const SvxHorJustifyItem& rJustifyItem = static_cast<const SvxHorJustifyItem&>(pCoreAttrs->Get(nWhich));
 386             switch (rJustifyItem.GetValue())
 387             {
 388                 case SvxCellHorJustify::Standard:
 389                     m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_STD));
 390                     break;
 391                 case SvxCellHorJustify::Left:
 392                     m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_LEFT));
 393                     break;
 394                 case SvxCellHorJustify::Center:
 395                     m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_CENTER));
 396                     break;
 397                 case SvxCellHorJustify::Right:
 398                     m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_RIGHT));
 399                     break;
 400                 case SvxCellHorJustify::Block:
 401                     m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_BLOCK));
 402                     break;
 403                 case SvxCellHorJustify::Repeat:
 404                     m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_FILL));
 405                     break;
 406             }
 407             break;
 408         }
 409     }
 410
 411     nWhich = GetWhich(SID_ATTR_ALIGN_INDENT);
 412     eState = pCoreAttrs->GetItemState(nWhich);
 413     switch (eState)
 414     {
 415         case SfxItemState::UNKNOWN:
 416             m_xEdIndent->hide();
 417             m_xFtIndent->hide();
 418             break;
 419         case SfxItemState::DISABLED:
 420         case SfxItemState::READONLY:
 421             m_xEdIndent->set_sensitive(false);
 422             break;
 423         case SfxItemState::DONTCARE:
 424             m_xEdIndent->set_text("");
 425             break;
 426         case SfxItemState::DEFAULT:
 427         case SfxItemState::SET:
 428         {
 429             const SfxUInt16Item& rIndentItem = static_cast<const SfxUInt16Item&>(pCoreAttrs->Get(nWhich));
 430             m_xEdIndent->set_value(rIndentItem.GetValue(), FieldUnit::TWIP);
 431             break;
 432         }
 433     }
 434
 435     nWhich = GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY);
 436     eState = pCoreAttrs->GetItemState(nWhich);
 437     switch (eState)
 438     {
 439         case SfxItemState::UNKNOWN:
 440             m_xLbVerAlign->hide();
 441             m_xFtVerAlign->hide();
 442             break;
 443         case SfxItemState::DISABLED:
 444         case SfxItemState::READONLY:
 445             m_xLbVerAlign->set_sensitive(false);
 446             break;
 447         case SfxItemState::DONTCARE:
 448             m_xLbVerAlign->set_active(-1);
 449             break;
 450         case SfxItemState::DEFAULT:
 451         case SfxItemState::SET:
 452         {
 453             const SvxVerJustifyItem& rJustifyItem = static_cast<const SvxVerJustifyItem&>(pCoreAttrs->Get(nWhich));
 454             switch (rJustifyItem.GetValue())
 455             {
 456                 case SvxCellVerJustify::Standard:
 457                     m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_STD));
 458                     break;
 459                 case SvxCellVerJustify::Top:
 460                     m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_TOP));
 461                     break;
 462                 case SvxCellVerJustify::Center:
 463                     m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_MID));
 464                     break;
 465                 case SvxCellVerJustify::Bottom:
 466                     m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_BOTTOM));
 467                     break;
 468                 case SvxCellVerJustify::Block:
 469                     m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_BLOCK));
 470                     break;
 471             }
 472             break;
 473         }
 474     }
 475
 476     nWhich = GetWhich(SID_ATTR_ALIGN_DEGREES);
 477     eState = pCoreAttrs->GetItemState(nWhich);
 478     switch (eState)
 479     {
 480         case SfxItemState::UNKNOWN:
 481             m_xNfRotate->hide();
 482             m_xCtrlDial->hide();
 483             break;
 484         case SfxItemState::DISABLED:
 485         case SfxItemState::READONLY:
 486             m_xNfRotate->set_sensitive(false);
 487             m_xCtrlDial->set_sensitive(false);
 488             break;
 489         case SfxItemState::DONTCARE:
 490             m_aCtrlDial.SetNoRotation();
 491             break;
 492         case SfxItemState::DEFAULT:
 493         case SfxItemState::SET:
 494         {
 495             const SfxInt32Item& rAlignItem = static_cast<const SfxInt32Item&>(pCoreAttrs->Get(nWhich));
 496             m_aCtrlDial.SetRotation(rAlignItem.GetValue());
 497             break;
 498         }
 499     }
 500
 501     nWhich = GetWhich(SID_ATTR_ALIGN_LOCKPOS);
 502     eState = pCoreAttrs->GetItemState(nWhich);
 503     switch (eState)
 504     {
 505         case SfxItemState::UNKNOWN:
 506             m_xVsRefEdge->hide();
 507             break;
 508         case SfxItemState::DISABLED:
 509         case SfxItemState::READONLY:
 510             m_xVsRefEdge->set_sensitive(false);
 511             break;
 512         case SfxItemState::DONTCARE:
 513             m_aVsRefEdge.SetNoSelection();
 514             break;
 515         case SfxItemState::DEFAULT:
 516         case SfxItemState::SET:
 517         {
 518             const SvxRotateModeItem& rRotateModeItem = static_cast<const SvxRotateModeItem&>(pCoreAttrs->Get(nWhich));
 519             switch (rRotateModeItem.GetValue())
 520             {
 521                 case SvxRotateMode::SVX_ROTATE_MODE_STANDARD:
 522                     m_aVsRefEdge.SelectItem(IID_CELLLOCK);
 523                     break;
 524                 case SvxRotateMode::SVX_ROTATE_MODE_TOP:
 525                     m_aVsRefEdge.SelectItem(IID_TOPLOCK);
 526                     break;
 527                 case SvxRotateMode::SVX_ROTATE_MODE_BOTTOM:
 528                     m_aVsRefEdge.SelectItem(IID_BOTTOMLOCK);
 529                     break;
 530                 default:
 531                     m_aVsRefEdge.SetNoSelection();
 532                     break;
 533             }
 534             break;
 535         }
 536     }
 537     m_aVsRefEdge.SaveValue();
 538
 539     //text direction
 540     nWhich = GetWhich(SID_ATTR_FRAMEDIRECTION);
 541     eState = pCoreAttrs->GetItemState(nWhich);
 542     switch (eState)
 543     {
 544         case SfxItemState::UNKNOWN:
 545             m_xLbFrameDir->hide();
 546             break;
 547         case SfxItemState::DISABLED:
 548         case SfxItemState::READONLY:
 549             m_xLbFrameDir->set_sensitive(false);
 550             break;
 551         case SfxItemState::DONTCARE:
 552             m_xLbFrameDir->set_active(-1);
 553             break;
 554         case SfxItemState::DEFAULT:
 555         case SfxItemState::SET:
 556         {
 557             const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>(pCoreAttrs->Get(nWhich));
 558             m_xLbFrameDir->set_active_id(rFrameDirItem.GetValue());
 559             break;
 560         }
 561     }
 562
 563
 564     // Special treatment for distributed alignment; we need to set the justify
 565     // method to 'distribute' to distinguish from the normal justification.
 566
 567     lcl_MaybeResetAlignToDistro<SvxCellHorJustify, SvxCellHorJustify>(
 568         *m_xLbHorAlign, ALIGNDLG_HORALIGN_DISTRIBUTED, *pCoreAttrs,
 569         GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY), GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY_METHOD),
 570         SvxCellHorJustify::Block);
 571
 572     lcl_MaybeResetAlignToDistro<SvxCellVerJustify, SvxCellVerJustify>(
 573         *m_xLbVerAlign, ALIGNDLG_VERALIGN_DISTRIBUTED, *pCoreAttrs,
 574         GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY), GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY_METHOD),
 575         SvxCellVerJustify::Block);
 576
 577     m_xLbHorAlign->save_value();
 578     m_xLbFrameDir->save_value();
 579     m_xLbVerAlign->save_value();
 580     m_xNfRotate->save_value();
 581     m_xEdIndent->save_value();
 582
 583     UpdateEnableControls();
 584 }
 585
 586 DeactivateRC AlignmentTabPage::DeactivatePage( SfxItemSet* _pSet )
 587 {
 588     if( _pSet )
 589         FillItemSet( _pSet );
 590     return DeactivateRC::LeavePage;
 591 }
 592
 593 void AlignmentTabPage::InitVsRefEgde()
 594 {
 595     // remember selection - is deleted in call to ValueSet::Clear()
 596     sal_uInt16 nSel = m_aVsRefEdge.GetSelectedItemId();
 597
 598     Image aBottomLock(StockImage::Yes, RID_SVXBMP_BOTTOMLOCK);
 599     Image aTopLock(StockImage::Yes, RID_SVXBMP_TOPLOCK);
 600     Image aCellLock(StockImage::Yes, RID_SVXBMP_CELLLOCK);
 601
 602     m_aVsRefEdge.Clear();
 603     m_aVsRefEdge.SetStyle(m_aVsRefEdge.GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER);
 604
 605     m_aVsRefEdge.SetColCount(3);
 606     m_aVsRefEdge.InsertItem(IID_BOTTOMLOCK, aBottomLock,  m_xFtBotLock->get_label());
 607     m_aVsRefEdge.InsertItem(IID_TOPLOCK,    aTopLock,     m_xFtTopLock->get_label());
 608     m_aVsRefEdge.InsertItem(IID_CELLLOCK,   aCellLock,    m_xFtCelLock->get_label());
 609     m_aVsRefEdge.SetOptimalSize();
 610
 611     m_aVsRefEdge.SelectItem( nSel );
 612 }
 613
 614 void AlignmentTabPage::UpdateEnableControls()
 615 {
 616     const sal_Int32 nHorAlign = m_xLbHorAlign->get_active();
 617     bool bHorLeft  = (nHorAlign == ALIGNDLG_HORALIGN_LEFT);
 618     bool bHorBlock = (nHorAlign == ALIGNDLG_HORALIGN_BLOCK);
 619     bool bHorFill  = (nHorAlign == ALIGNDLG_HORALIGN_FILL);
 620     bool bHorDist  = (nHorAlign == ALIGNDLG_HORALIGN_DISTRIBUTED);
 621
 622     // indent edit field only for left alignment
 623     m_xFtIndent->set_sensitive( bHorLeft );
 624     m_xEdIndent->set_sensitive( bHorLeft );
 625
 626     // stacked disabled for fill alignment
 627     m_xCbStacked->set_sensitive(!bHorFill);
 628
 629     // hyphenation only for automatic line breaks or for block alignment
 630     m_xBtnHyphen->set_sensitive( m_xBtnWrap->get_active() || bHorBlock );
 631
 632     // shrink only without automatic line break, and not for block, fill or distribute.
 633     m_xBtnShrink->set_sensitive( (m_xBtnWrap->get_state() == TRISTATE_FALSE) && !bHorBlock && !bHorFill && !bHorDist );
 634
 635     // visibility of frames
 636     m_xAlignmentFrame->set_visible(m_xLbHorAlign->get_visible() || m_xEdIndent->get_visible() ||
 637         m_xLbVerAlign->get_visible());
 638     m_xOrientFrame->set_visible(m_xCtrlDial->get_visible() || m_xVsRefEdge->get_visible() ||
 639         m_xCbStacked->get_visible() || m_xCbAsianMode->get_visible());
 640     m_xPropertiesFrame->set_visible(m_xBtnWrap->get_visible() || m_xBtnHyphen->get_visible() ||
 641         m_xBtnShrink->get_visible() || m_xLbFrameDir->get_visible());
 642
 643     bool bStackedText = m_xCbStacked->get_active();
 644     // windows to be disabled, if stacked text is turned ON
 645     m_xFtRotate->set_sensitive(!bStackedText);
 646     m_xFtRefEdge->set_sensitive(!bStackedText);
 647     m_xVsRefEdge->set_sensitive(!bStackedText);
 648     // windows to be disabled, if stacked text is turned OFF
 649     m_xCbAsianMode->set_sensitive(bStackedText);
 650     // rotation/stacked disabled for fill alignment/stacked
 651     m_xCtrlDial->set_sensitive(!bHorFill && !bStackedText);
 652     m_xNfRotate->set_sensitive(!bHorFill && !bStackedText);
 653 }
 654
 655 bool AlignmentTabPage::HasAlignmentChanged( const SfxItemSet& rNew, sal_uInt16 nWhich ) const
 656 {
 657     const SfxItemSet& rOld = GetItemSet();
 658     const SfxPoolItem* pItem;
 659     SvxCellJustifyMethod eMethodOld = SvxCellJustifyMethod::Auto;
 660     SvxCellJustifyMethod eMethodNew = SvxCellJustifyMethod::Auto;
 661     if (rOld.GetItemState(nWhich, true, &pItem) == SfxItemState::SET)
 662     {
 663         const SfxEnumItemInterface* p = static_cast<const SfxEnumItemInterface*>(pItem);
 664         eMethodOld = static_cast<SvxCellJustifyMethod>(p->GetEnumValue());
 665     }
 666
 667     if (rNew.GetItemState(nWhich, true, &pItem) == SfxItemState::SET)
 668     {
 669         const SfxEnumItemInterface* p = static_cast<const SfxEnumItemInterface*>(pItem);
 670         eMethodNew = static_cast<SvxCellJustifyMethod>(p->GetEnumValue());
 671     }
 672
 673     return eMethodOld != eMethodNew;
 674 }
 675
 676 IMPL_LINK(AlignmentTabPage, StackedClickHdl, weld::ToggleButton&, rToggle, void)
 677 {
 678     m_aStackedState.ButtonToggled(rToggle);
 679     UpdateEnableControls();
 680 }
 681
 682 IMPL_LINK(AlignmentTabPage, AsianModeClickHdl, weld::ToggleButton&, rToggle, void)
 683 {
 684     m_aAsianModeState.ButtonToggled(rToggle);
 685 }
 686
 687 IMPL_LINK(AlignmentTabPage, WrapClickHdl, weld::ToggleButton&, rToggle, void)
 688 {
 689     m_aWrapState.ButtonToggled(rToggle);
 690     UpdateEnableControls();
 691 }
 692
 693 IMPL_LINK(AlignmentTabPage, HyphenClickHdl, weld::ToggleButton&, rToggle, void)
 694 {
 695     m_aHyphenState.ButtonToggled(rToggle);
 696 }
 697
 698 IMPL_LINK(AlignmentTabPage, ShrinkClickHdl, weld::ToggleButton&, rToggle, void)
 699 {
 700     m_aShrinkState.ButtonToggled(rToggle);
 701 }
 702
 703 IMPL_LINK_NOARG(AlignmentTabPage, UpdateEnableHdl, weld::ComboBox&, void)
 704 {
 705     UpdateEnableControls();
 706 }
 707
 708 }
 709
 710 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */