diff options
Diffstat (limited to 'cui/source/tabpages')
36 files changed, 34593 insertions, 0 deletions
diff --git a/cui/source/tabpages/TextColumnsPage.cxx b/cui/source/tabpages/TextColumnsPage.cxx new file mode 100644 index 000000000..5bfd3b47a --- /dev/null +++ b/cui/source/tabpages/TextColumnsPage.cxx @@ -0,0 +1,82 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <sal/config.h> + +#include <svtools/unitconv.hxx> +#include <svx/dlgutil.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/svddef.hxx> + +#include <TextColumnsPage.hxx> + +const WhichRangesContainer + SvxTextColumnsPage::pRanges(svl::Items<SDRATTR_TEXTCOLUMNS_FIRST, SDRATTR_TEXTCOLUMNS_LAST>); + +SvxTextColumnsPage::SvxTextColumnsPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/textcolumnstabpage.ui", "TextColumnsPage", &rInAttrs) + , m_xColumnsNumber(m_xBuilder->weld_spin_button("FLD_COL_NUMBER")) + , m_xColumnsSpacing( + m_xBuilder->weld_metric_spin_button("MTR_FLD_COL_SPACING", GetModuleFieldUnit(rInAttrs))) +{ +} + +SvxTextColumnsPage::~SvxTextColumnsPage() = default; + +// read the passed item set +void SvxTextColumnsPage::Reset(const SfxItemSet* rAttrs) +{ + SfxItemPool* pPool = rAttrs->GetPool(); + assert(pPool); + + { + auto pItem = GetItem(*rAttrs, SDRATTR_TEXTCOLUMNS_NUMBER); + if (!pItem) + pItem = &pPool->GetDefaultItem(SDRATTR_TEXTCOLUMNS_NUMBER); + m_xColumnsNumber->set_value(pItem->GetValue()); + m_xColumnsNumber->save_value(); + } + + { + MapUnit eUnit = pPool->GetMetric(SDRATTR_TEXTCOLUMNS_SPACING); + auto pItem = GetItem(*rAttrs, SDRATTR_TEXTCOLUMNS_SPACING); + if (!pItem) + pItem = &pPool->GetDefaultItem(SDRATTR_TEXTCOLUMNS_SPACING); + SetMetricValue(*m_xColumnsSpacing, pItem->GetValue(), eUnit); + m_xColumnsSpacing->save_value(); + } +} + +// fill the passed item set with dialog box attributes +bool SvxTextColumnsPage::FillItemSet(SfxItemSet* rAttrs) +{ + if (m_xColumnsNumber->get_value_changed_from_saved()) + rAttrs->Put(SfxInt16Item(SDRATTR_TEXTCOLUMNS_NUMBER, m_xColumnsNumber->get_value())); + + if (m_xColumnsSpacing->get_value_changed_from_saved()) + { + SfxItemPool* pPool = rAttrs->GetPool(); + assert(pPool); + MapUnit eUnit = pPool->GetMetric(SDRATTR_TEXTCOLUMNS_SPACING); + sal_Int32 nValue = GetCoreValue(*m_xColumnsSpacing, eUnit); + rAttrs->Put(SdrMetricItem(SDRATTR_TEXTCOLUMNS_SPACING, nValue)); + } + + return true; +} + +std::unique_ptr<SfxTabPage> SvxTextColumnsPage::Create(weld::Container* pPage, + weld::DialogController* pController, + const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxTextColumnsPage>(pPage, pController, *rAttrs); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/cui/source/tabpages/align.cxx b/cui/source/tabpages/align.cxx new file mode 100644 index 000000000..8d2425e7e --- /dev/null +++ b/cui/source/tabpages/align.cxx @@ -0,0 +1,790 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <align.hxx> + +#include <editeng/svxenum.hxx> +#include <svx/svxids.hrc> +#include <svx/strings.hrc> +#include <svx/dialmgr.hxx> +#include <bitmaps.hlst> +#include <svx/rotmodit.hxx> +#include <svx/sdangitm.hxx> + +#include <editeng/frmdiritem.hxx> +#include <editeng/justifyitem.hxx> +#include <svl/cjkoptions.hxx> +#include <svl/intitem.hxx> +#include <vcl/image.hxx> + +#define IID_BOTTOMLOCK 1 +#define IID_TOPLOCK 2 +#define IID_CELLLOCK 3 + +namespace svx { + +const WhichRangesContainer AlignmentTabPage::s_pRanges( + svl::Items< + SID_ATTR_ALIGN_STACKED, SID_ATTR_ALIGN_LINEBREAK, // 10229 - 10230 + SID_ATTR_ALIGN_INDENT, SID_ATTR_ALIGN_INDENT, // 10460 - 10460 + SID_ATTR_ALIGN_DEGREES, SID_ATTR_ALIGN_DEGREES, // 10577 - 10577 + SID_ATTR_ALIGN_LOCKPOS, SID_ATTR_ALIGN_LOCKPOS, // 10578 - 10578 + SID_ATTR_ALIGN_HYPHENATION, SID_ATTR_ALIGN_HYPHENATION, // 10931 - 10931 + SID_ATTR_FRAMEDIRECTION, SID_ATTR_FRAMEDIRECTION, // 10944 - 10944 + SID_ATTR_ALIGN_ASIANVERTICAL, SID_ATTR_ALIGN_ASIANVERTICAL, // 10949 - 10949 + SID_ATTR_ALIGN_SHRINKTOFIT, SID_ATTR_ALIGN_SHRINKTOFIT, // 11015 - 11015 + SID_ATTR_ALIGN_HOR_JUSTIFY, SID_ATTR_ALIGN_VER_JUSTIFY>); // 11571 - 11572 + + +namespace { + +template<typename JustContainerType, typename JustEnumType> +void lcl_MaybeResetAlignToDistro( + weld::ComboBox& rLB, sal_uInt16 nListId, const SfxItemSet& rCoreAttrs, TypedWhichId<SfxEnumItemInterface> nWhichAlign, TypedWhichId<SfxEnumItemInterface> nWhichJM, JustEnumType eBlock) +{ + const SfxEnumItemInterface* p = rCoreAttrs.GetItemIfSet(nWhichAlign); + if (!p) + // alignment not set. + return; + + JustContainerType eVal = static_cast<JustContainerType>(p->GetEnumValue()); + if (eVal != eBlock) + // alignment is not 'justify'. No need to go further. + return; + + p = rCoreAttrs.GetItemIfSet(nWhichJM); + if (!p) + // justification method is not set. + return; + + SvxCellJustifyMethod eMethod = static_cast<SvxCellJustifyMethod>(p->GetEnumValue()); + if (eMethod == SvxCellJustifyMethod::Distribute) + { + // Select the 'distribute' entry in the specified list box. + rLB.set_active_id(OUString::number(nListId)); + } +} + +void lcl_SetJustifyMethodToItemSet(SfxItemSet& rSet, const SfxItemSet& rOldSet, sal_uInt16 nWhichJM, const weld::ComboBox& rLB, sal_uInt16 nListId) +{ + // tdf#138698 unsupported, e.g. dbaccess + if (rLB.find_id(OUString::number(nListId)) == -1) + return; + + // feature supported , e.g. calc + SvxCellJustifyMethod eJM = SvxCellJustifyMethod::Auto; + if (rLB.get_active_id().toInt32() == nListId) + eJM = SvxCellJustifyMethod::Distribute; + + // tdf#129300 If it would create no change, don't force it + const SvxJustifyMethodItem& rOldItem = static_cast<const SvxJustifyMethodItem&>(rOldSet.Get(nWhichJM)); + if (rOldItem.GetValue() == eJM) + { + rSet.InvalidateItem(nWhichJM); + return; + } + + SvxJustifyMethodItem aItem(eJM, nWhichJM); + rSet.Put(aItem); +} + +}//namespace + +AlignmentTabPage::AlignmentTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rCoreAttrs) + : SfxTabPage(pPage, pController, "cui/ui/cellalignment.ui", "CellAlignPage", &rCoreAttrs) + , m_aVsRefEdge(nullptr) + // text alignment + , m_xLbHorAlign(m_xBuilder->weld_combo_box("comboboxHorzAlign")) + , m_xFtIndent(m_xBuilder->weld_label("labelIndent")) + , m_xEdIndent(m_xBuilder->weld_metric_spin_button("spinIndentFrom", FieldUnit::POINT)) + , m_xFtVerAlign(m_xBuilder->weld_label("labelVertAlign")) + , m_xLbVerAlign(m_xBuilder->weld_combo_box("comboboxVertAlign")) + //text rotation + , m_xFtRotate(m_xBuilder->weld_label("labelDegrees")) + , m_xNfRotate(m_xBuilder->weld_metric_spin_button("spinDegrees", FieldUnit::DEGREE)) + , m_xFtRefEdge(m_xBuilder->weld_label("labelRefEdge")) + //Asian mode + , m_xCbStacked(m_xBuilder->weld_check_button("checkVertStack")) + , m_xCbAsianMode(m_xBuilder->weld_check_button("checkAsianMode")) + // Properties + , m_xBoxDirection(m_xBuilder->weld_widget("boxDirection")) + , m_xBtnWrap(m_xBuilder->weld_check_button("checkWrapTextAuto")) + , m_xBtnHyphen(m_xBuilder->weld_check_button("checkHyphActive")) + , m_xBtnShrink(m_xBuilder->weld_check_button("checkShrinkFitCellSize")) + , m_xLbFrameDir(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("comboTextDirBox"))) + //ValueSet hover strings + , m_xFtBotLock(m_xBuilder->weld_label("labelSTR_BOTTOMLOCK")) + , m_xFtTopLock(m_xBuilder->weld_label("labelSTR_TOPLOCK")) + , m_xFtCelLock(m_xBuilder->weld_label("labelSTR_CELLLOCK")) + , m_xFtABCD(m_xBuilder->weld_label("labelABCD")) + , m_xAlignmentFrame(m_xBuilder->weld_widget("alignment")) + , m_xOrientFrame(m_xBuilder->weld_widget("orientation")) + , m_xPropertiesFrame(m_xBuilder->weld_widget("properties")) + , m_xVsRefEdge(new weld::CustomWeld(*m_xBuilder, "references", m_aVsRefEdge)) + , m_xCtrlDial(new DialControl) + , m_xCtrlDialWin(new weld::CustomWeld(*m_xBuilder, "dialcontrol", *m_xCtrlDial)) +{ + m_xCtrlDial->SetLinkedField(m_xNfRotate.get()); + m_xCtrlDial->SetText(m_xFtABCD->get_label()); + + InitVsRefEgde(); + + m_xLbHorAlign->connect_changed(LINK(this, AlignmentTabPage, UpdateEnableHdl)); + + m_xCbStacked->connect_toggled(LINK(this, AlignmentTabPage, StackedClickHdl)); + m_xCbAsianMode->connect_toggled(LINK(this, AlignmentTabPage, AsianModeClickHdl)); + m_xBtnWrap->connect_toggled(LINK(this, AlignmentTabPage, WrapClickHdl)); + m_xBtnHyphen->connect_toggled(LINK(this, AlignmentTabPage, HyphenClickHdl)); + m_xBtnShrink->connect_toggled(LINK(this, AlignmentTabPage, ShrinkClickHdl)); + + // Asian vertical mode + m_xCbAsianMode->set_visible(SvtCJKOptions::IsVerticalTextEnabled()); + + m_xLbFrameDir->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTR)); + m_xLbFrameDir->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTL)); + m_xLbFrameDir->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPER)); + + // This page needs ExchangeSupport. + SetExchangeSupport(); +} + +AlignmentTabPage::~AlignmentTabPage() +{ + m_xCtrlDialWin.reset(); + m_xCtrlDial.reset(); + m_xVsRefEdge.reset(); + m_xLbFrameDir.reset(); +} + +std::unique_ptr<SfxTabPage> AlignmentTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet) +{ + return std::make_unique<AlignmentTabPage>(pPage, pController, *rAttrSet); +} + +bool AlignmentTabPage::FillItemSet( SfxItemSet* rSet ) +{ + const SfxItemSet& rOldSet = GetItemSet(); + + bool bChanged = SfxTabPage::FillItemSet(rSet); + + sal_uInt16 nWhich = GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY); + if (m_xLbHorAlign->get_value_changed_from_saved()) + { + SvxCellHorJustify eJustify(SvxCellHorJustify::Standard); + switch (m_xLbHorAlign->get_active_id().toInt32()) + { + case ALIGNDLG_HORALIGN_STD: + eJustify = SvxCellHorJustify::Standard; + break; + case ALIGNDLG_HORALIGN_LEFT: + eJustify = SvxCellHorJustify::Left; + break; + case ALIGNDLG_HORALIGN_CENTER: + eJustify = SvxCellHorJustify::Center; + break; + case ALIGNDLG_HORALIGN_RIGHT: + eJustify = SvxCellHorJustify::Right; + break; + case ALIGNDLG_HORALIGN_BLOCK: + case ALIGNDLG_HORALIGN_DISTRIBUTED: + eJustify = SvxCellHorJustify::Block; + break; + case ALIGNDLG_HORALIGN_FILL: + eJustify = SvxCellHorJustify::Repeat; + break; + } + rSet->Put(SvxHorJustifyItem(eJustify, nWhich)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_INDENT); + if (m_xEdIndent->get_value_changed_from_saved()) + { + const SfxUInt16Item* pIndentItem = static_cast<const SfxUInt16Item*>(GetOldItem( + *rSet, SID_ATTR_ALIGN_INDENT)); + assert(pIndentItem); + std::unique_ptr<SfxUInt16Item> pNewIndentItem(pIndentItem->Clone()); + pNewIndentItem->SetValue(m_xEdIndent->get_value(FieldUnit::TWIP)); + rSet->Put(std::move(pNewIndentItem)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY); + if (m_xLbVerAlign->get_value_changed_from_saved()) + { + SvxCellVerJustify eJustify(SvxCellVerJustify::Standard); + switch (m_xLbVerAlign->get_active_id().toInt32()) + { + case ALIGNDLG_VERALIGN_STD: + eJustify = SvxCellVerJustify::Standard; + break; + case ALIGNDLG_VERALIGN_TOP: + eJustify = SvxCellVerJustify::Top; + break; + case ALIGNDLG_VERALIGN_MID: + eJustify = SvxCellVerJustify::Center; + break; + case ALIGNDLG_VERALIGN_BOTTOM: + eJustify = SvxCellVerJustify::Bottom; + break; + case ALIGNDLG_VERALIGN_BLOCK: + case ALIGNDLG_VERALIGN_DISTRIBUTED: + eJustify = SvxCellVerJustify::Block; + break; + } + rSet->Put(SvxVerJustifyItem(eJustify, nWhich)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_DEGREES); + if (m_xNfRotate->get_value_changed_from_saved()) + { + const SdrAngleItem* pAngleItem = static_cast<const SdrAngleItem*>(GetOldItem( + *rSet, SID_ATTR_ALIGN_DEGREES)); + assert(pAngleItem); + std::unique_ptr<SdrAngleItem> pNewAngleItem(pAngleItem->Clone()); + pNewAngleItem->SetValue(m_xCtrlDial->GetRotation()); + rSet->Put(std::move(pNewAngleItem)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + TypedWhichId<SvxRotateModeItem> nWhichLockPos(GetWhich(SID_ATTR_ALIGN_LOCKPOS)); + if (m_aVsRefEdge.IsValueChangedFromSaved()) + { + switch (m_aVsRefEdge.GetSelectedItemId()) + { + case IID_CELLLOCK: + rSet->Put(SvxRotateModeItem(SvxRotateMode::SVX_ROTATE_MODE_STANDARD, nWhichLockPos)); + break; + case IID_TOPLOCK: + rSet->Put(SvxRotateModeItem(SvxRotateMode::SVX_ROTATE_MODE_TOP, nWhichLockPos)); + break; + case IID_BOTTOMLOCK: + rSet->Put(SvxRotateModeItem(SvxRotateMode::SVX_ROTATE_MODE_BOTTOM, nWhichLockPos)); + break; + default: + m_aVsRefEdge.SetNoSelection(); + break; + } + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhichLockPos, false)) + rSet->InvalidateItem(nWhichLockPos); + + nWhich = GetWhich(SID_ATTR_ALIGN_STACKED); + if (m_xCbStacked->get_state_changed_from_saved()) + { + const SfxBoolItem* pStackItem = static_cast<const SfxBoolItem*>(GetOldItem( + *rSet, SID_ATTR_ALIGN_STACKED)); + assert(pStackItem); + std::unique_ptr<SfxBoolItem> pNewStackItem(pStackItem->Clone()); + pNewStackItem->SetValue(m_xCbStacked->get_active()); + rSet->Put(std::move(pNewStackItem)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_ASIANVERTICAL); + if (m_xCbAsianMode->get_state_changed_from_saved()) + { + rSet->Put(SfxBoolItem(nWhich, m_xCbAsianMode->get_active())); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_LINEBREAK); + if (m_xBtnWrap->get_state_changed_from_saved()) + { + const SfxBoolItem* pWrapItem = static_cast<const SfxBoolItem*>(GetOldItem( + *rSet, SID_ATTR_ALIGN_LINEBREAK)); + assert(pWrapItem); + std::unique_ptr<SfxBoolItem> pNewWrapItem(pWrapItem->Clone()); + pNewWrapItem->SetValue(m_xBtnWrap->get_active()); + rSet->Put(std::move(pNewWrapItem)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_HYPHENATION); + if (m_xBtnHyphen->get_state_changed_from_saved()) + { + const SfxBoolItem* pHyphItem = static_cast<const SfxBoolItem*>(GetOldItem( + *rSet, SID_ATTR_ALIGN_HYPHENATION)); + assert(pHyphItem); + std::unique_ptr<SfxBoolItem> pNewHyphItem(pHyphItem->Clone()); + pNewHyphItem->SetValue(m_xBtnHyphen->get_active()); + rSet->Put(std::move(pNewHyphItem)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + nWhich = GetWhich(SID_ATTR_ALIGN_SHRINKTOFIT); + if (m_xBtnShrink->get_state_changed_from_saved()) + { + const SfxBoolItem* pShrinkItem = static_cast<const SfxBoolItem*>(GetOldItem( + *rSet, SID_ATTR_ALIGN_SHRINKTOFIT)); + assert(pShrinkItem); + std::unique_ptr<SfxBoolItem> pNewShrinkItem(pShrinkItem->Clone()); + pNewShrinkItem->SetValue(m_xBtnShrink->get_active()); + rSet->Put(std::move(pNewShrinkItem)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + + if (m_xLbFrameDir->get_visible()) + { + nWhich = GetWhich(SID_ATTR_FRAMEDIRECTION); + if (m_xLbFrameDir->get_value_changed_from_saved()) + { + SvxFrameDirection eDir = m_xLbFrameDir->get_active_id(); + rSet->Put(SvxFrameDirectionItem(eDir, nWhich)); + bChanged = true; + } + else if (SfxItemState::DEFAULT == rOldSet.GetItemState(nWhich, false)) + rSet->InvalidateItem(nWhich); + } + + // Special treatment for distributed alignment; we need to set the justify + // method to 'distribute' to distinguish from the normal justification. + TypedWhichId<SfxEnumItemInterface> nWhichHorJM(GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY_METHOD)); + lcl_SetJustifyMethodToItemSet(*rSet, rOldSet, nWhichHorJM, *m_xLbHorAlign, ALIGNDLG_HORALIGN_DISTRIBUTED); + if (!bChanged) + bChanged = HasAlignmentChanged(*rSet, nWhichHorJM); + + TypedWhichId<SfxEnumItemInterface> nWhichVerJM(GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY_METHOD)); + lcl_SetJustifyMethodToItemSet(*rSet, rOldSet, nWhichVerJM, *m_xLbVerAlign, ALIGNDLG_VERALIGN_DISTRIBUTED); + if (!bChanged) + bChanged = HasAlignmentChanged(*rSet, nWhichVerJM); + + return bChanged; +} + +namespace +{ + void ResetBool(sal_uInt16 nWhich, const SfxItemSet* pSet, weld::CheckButton& rBtn, weld::TriStateEnabled& rTriState) + { + SfxItemState eState = pSet->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + rBtn.hide(); + rTriState.bTriStateEnabled = false; + break; + case SfxItemState::DISABLED: + rBtn.set_sensitive(false); + rTriState.bTriStateEnabled = false; + break; + case SfxItemState::DONTCARE: + rBtn.set_state(TRISTATE_INDET); + rTriState.bTriStateEnabled = true; + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SfxBoolItem& rItem = static_cast<const SfxBoolItem&>(pSet->Get(nWhich)); + rBtn.set_state(static_cast<TriState>(rItem.GetValue())); + rTriState.bTriStateEnabled = false; + break; + } + } + rBtn.save_state(); + } +} + +void AlignmentTabPage::Reset(const SfxItemSet* pCoreAttrs) +{ + SfxTabPage::Reset(pCoreAttrs); + + ResetBool(GetWhich(SID_ATTR_ALIGN_STACKED), pCoreAttrs, *m_xCbStacked, m_aStackedState); + ResetBool(GetWhich(SID_ATTR_ALIGN_ASIANVERTICAL), pCoreAttrs, *m_xCbAsianMode, m_aAsianModeState); + ResetBool(GetWhich(SID_ATTR_ALIGN_LINEBREAK), pCoreAttrs, *m_xBtnWrap, m_aWrapState); + ResetBool(GetWhich(SID_ATTR_ALIGN_HYPHENATION), pCoreAttrs, *m_xBtnHyphen, m_aHyphenState); + ResetBool(GetWhich(SID_ATTR_ALIGN_SHRINKTOFIT), pCoreAttrs, *m_xBtnShrink, m_aShrinkState); + + sal_uInt16 nWhich = GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY); + SfxItemState eState = pCoreAttrs->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + m_xLbHorAlign->hide(); + break; + case SfxItemState::DISABLED: + m_xLbHorAlign->set_sensitive(false); + break; + case SfxItemState::DONTCARE: + m_xLbHorAlign->set_active(-1); + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxHorJustifyItem& rJustifyItem = static_cast<const SvxHorJustifyItem&>(pCoreAttrs->Get(nWhich)); + switch (rJustifyItem.GetValue()) + { + case SvxCellHorJustify::Standard: + m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_STD)); + break; + case SvxCellHorJustify::Left: + m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_LEFT)); + break; + case SvxCellHorJustify::Center: + m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_CENTER)); + break; + case SvxCellHorJustify::Right: + m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_RIGHT)); + break; + case SvxCellHorJustify::Block: + m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_BLOCK)); + break; + case SvxCellHorJustify::Repeat: + m_xLbHorAlign->set_active_id(OUString::number(ALIGNDLG_HORALIGN_FILL)); + break; + } + break; + } + } + + nWhich = GetWhich(SID_ATTR_ALIGN_INDENT); + eState = pCoreAttrs->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + m_xEdIndent->hide(); + m_xFtIndent->hide(); + break; + case SfxItemState::DISABLED: + m_xEdIndent->set_sensitive(false); + break; + case SfxItemState::DONTCARE: + m_xEdIndent->set_text(""); + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SfxUInt16Item& rIndentItem = static_cast<const SfxUInt16Item&>(pCoreAttrs->Get(nWhich)); + m_xEdIndent->set_value(rIndentItem.GetValue(), FieldUnit::TWIP); + break; + } + } + + nWhich = GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY); + eState = pCoreAttrs->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + m_xLbVerAlign->hide(); + m_xFtVerAlign->hide(); + break; + case SfxItemState::DISABLED: + m_xLbVerAlign->set_sensitive(false); + break; + case SfxItemState::DONTCARE: + m_xLbVerAlign->set_active(-1); + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxVerJustifyItem& rJustifyItem = static_cast<const SvxVerJustifyItem&>(pCoreAttrs->Get(nWhich)); + switch (rJustifyItem.GetValue()) + { + case SvxCellVerJustify::Standard: + m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_STD)); + break; + case SvxCellVerJustify::Top: + m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_TOP)); + break; + case SvxCellVerJustify::Center: + m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_MID)); + break; + case SvxCellVerJustify::Bottom: + m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_BOTTOM)); + break; + case SvxCellVerJustify::Block: + m_xLbVerAlign->set_active_id(OUString::number(ALIGNDLG_VERALIGN_BLOCK)); + break; + } + break; + } + } + + nWhich = GetWhich(SID_ATTR_ALIGN_DEGREES); + eState = pCoreAttrs->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + m_xNfRotate->hide(); + m_xCtrlDialWin->hide(); + break; + case SfxItemState::DISABLED: + m_xNfRotate->set_sensitive(false); + m_xCtrlDialWin->set_sensitive(false); + break; + case SfxItemState::DONTCARE: + m_xCtrlDial->SetNoRotation(); + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SdrAngleItem& rAlignItem = static_cast<const SdrAngleItem&>(pCoreAttrs->Get(nWhich)); + m_xCtrlDial->SetRotation(rAlignItem.GetValue()); + break; + } + } + + nWhich = GetWhich(SID_ATTR_ALIGN_LOCKPOS); + eState = pCoreAttrs->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + m_xVsRefEdge->hide(); + break; + case SfxItemState::DISABLED: + m_xVsRefEdge->set_sensitive(false); + break; + case SfxItemState::DONTCARE: + m_aVsRefEdge.SetNoSelection(); + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxRotateModeItem& rRotateModeItem = static_cast<const SvxRotateModeItem&>(pCoreAttrs->Get(nWhich)); + switch (rRotateModeItem.GetValue()) + { + case SvxRotateMode::SVX_ROTATE_MODE_STANDARD: + m_aVsRefEdge.SelectItem(IID_CELLLOCK); + break; + case SvxRotateMode::SVX_ROTATE_MODE_TOP: + m_aVsRefEdge.SelectItem(IID_TOPLOCK); + break; + case SvxRotateMode::SVX_ROTATE_MODE_BOTTOM: + m_aVsRefEdge.SelectItem(IID_BOTTOMLOCK); + break; + default: + m_aVsRefEdge.SetNoSelection(); + break; + } + break; + } + } + m_aVsRefEdge.SaveValue(); + + //text direction + nWhich = GetWhich(SID_ATTR_FRAMEDIRECTION); + eState = pCoreAttrs->GetItemState(nWhich); + switch (eState) + { + case SfxItemState::UNKNOWN: + m_xLbFrameDir->hide(); + break; + case SfxItemState::DISABLED: + m_xLbFrameDir->set_sensitive(false); + break; + case SfxItemState::DONTCARE: + m_xLbFrameDir->set_active(-1); + break; + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>(pCoreAttrs->Get(nWhich)); + m_xLbFrameDir->set_active_id(rFrameDirItem.GetValue()); + break; + } + } + + // Special treatment for distributed alignment; we need to set the justify + // method to 'distribute' to distinguish from the normal justification. + TypedWhichId<SfxEnumItemInterface> nHorJustifyMethodWhich(GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY_METHOD)); + SfxItemState eHorJustifyMethodState = pCoreAttrs->GetItemState(nHorJustifyMethodWhich); + if (eHorJustifyMethodState == SfxItemState::UNKNOWN) + { + // feature unknown, e.g. dbaccess, remove the option + int nDistribId = m_xLbHorAlign->find_id(OUString::number(ALIGNDLG_HORALIGN_DISTRIBUTED)); + if (nDistribId != -1) + m_xLbHorAlign->remove(nDistribId); + } + else + { + // feature known, e.g. calc + lcl_MaybeResetAlignToDistro<SvxCellHorJustify, SvxCellHorJustify>( + *m_xLbHorAlign, ALIGNDLG_HORALIGN_DISTRIBUTED, *pCoreAttrs, + TypedWhichId<SfxEnumItemInterface>(GetWhich(SID_ATTR_ALIGN_HOR_JUSTIFY)), nHorJustifyMethodWhich, + SvxCellHorJustify::Block); + } + + TypedWhichId<SfxEnumItemInterface> nVerJustifyMethodWhich( GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY_METHOD) ); + SfxItemState eVerJustifyMethodState = pCoreAttrs->GetItemState(nVerJustifyMethodWhich); + if (eVerJustifyMethodState == SfxItemState::UNKNOWN) + { + // feature unknown, e.g. dbaccess, remove the option + int nDistribId = m_xLbVerAlign->find_id(OUString::number(ALIGNDLG_VERALIGN_DISTRIBUTED)); + if (nDistribId != -1) + m_xLbVerAlign->remove(nDistribId); + } + else + { + // feature known, e.g. calc + lcl_MaybeResetAlignToDistro<SvxCellVerJustify, SvxCellVerJustify>( + *m_xLbVerAlign, ALIGNDLG_VERALIGN_DISTRIBUTED, *pCoreAttrs, + TypedWhichId<SfxEnumItemInterface>(GetWhich(SID_ATTR_ALIGN_VER_JUSTIFY)), nVerJustifyMethodWhich, + SvxCellVerJustify::Block); + } + + m_xLbHorAlign->save_value(); + m_xLbFrameDir->save_value(); + m_xLbVerAlign->save_value(); + m_xNfRotate->save_value(); + m_xEdIndent->save_value(); + + UpdateEnableControls(); +} + +DeactivateRC AlignmentTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +void AlignmentTabPage::InitVsRefEgde() +{ + // remember selection - is deleted in call to ValueSet::Clear() + sal_uInt16 nSel = m_aVsRefEdge.GetSelectedItemId(); + + Image aBottomLock(StockImage::Yes, RID_SVXBMP_BOTTOMLOCK); + Image aTopLock(StockImage::Yes, RID_SVXBMP_TOPLOCK); + Image aCellLock(StockImage::Yes, RID_SVXBMP_CELLLOCK); + + m_aVsRefEdge.Clear(); + m_aVsRefEdge.SetStyle(m_aVsRefEdge.GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER); + + m_aVsRefEdge.SetColCount(3); + m_aVsRefEdge.InsertItem(IID_BOTTOMLOCK, aBottomLock, m_xFtBotLock->get_label()); + m_aVsRefEdge.InsertItem(IID_TOPLOCK, aTopLock, m_xFtTopLock->get_label()); + m_aVsRefEdge.InsertItem(IID_CELLLOCK, aCellLock, m_xFtCelLock->get_label()); + m_aVsRefEdge.SetOptimalSize(); + + m_aVsRefEdge.SelectItem( nSel ); +} + +void AlignmentTabPage::UpdateEnableControls() +{ + const sal_Int32 nHorAlign = m_xLbHorAlign->get_active_id().toInt32(); + bool bHorLeft = (nHorAlign == ALIGNDLG_HORALIGN_LEFT); + bool bHorBlock = (nHorAlign == ALIGNDLG_HORALIGN_BLOCK); + bool bHorFill = (nHorAlign == ALIGNDLG_HORALIGN_FILL); + bool bHorDist = (nHorAlign == ALIGNDLG_HORALIGN_DISTRIBUTED); + + // indent edit field only for left alignment + m_xFtIndent->set_sensitive( bHorLeft ); + m_xEdIndent->set_sensitive( bHorLeft ); + + // stacked disabled for fill alignment + m_xCbStacked->set_sensitive(!bHorFill); + + // hyphenation only for automatic line breaks or for block alignment + m_xBtnHyphen->set_sensitive( m_xBtnWrap->get_active() || bHorBlock ); + + // shrink only without automatic line break, and not for block, fill or distribute. + m_xBtnShrink->set_sensitive( (m_xBtnWrap->get_state() == TRISTATE_FALSE) && !bHorBlock && !bHorFill && !bHorDist ); + + // visibility of frames + m_xAlignmentFrame->set_visible(m_xLbHorAlign->get_visible() || m_xEdIndent->get_visible() || + m_xLbVerAlign->get_visible()); + m_xOrientFrame->set_visible(m_xCtrlDialWin->get_visible() || m_xVsRefEdge->get_visible() || + m_xCbStacked->get_visible() || m_xCbAsianMode->get_visible()); + m_xPropertiesFrame->set_visible(m_xBtnWrap->get_visible() || m_xBtnHyphen->get_visible() || + m_xBtnShrink->get_visible() || m_xLbFrameDir->get_visible()); + + bool bStackedText = m_xCbStacked->get_active(); + // windows to be disabled, if stacked text is turned ON + m_xFtRotate->set_sensitive(!bStackedText); + m_xFtRefEdge->set_sensitive(!bStackedText); + m_xVsRefEdge->set_sensitive(!bStackedText); + // windows to be disabled, if stacked text is turned OFF + m_xCbAsianMode->set_sensitive(bStackedText); + // rotation/stacked disabled for fill alignment/stacked + m_xCtrlDialWin->set_sensitive(!bHorFill && !bStackedText); + m_xNfRotate->set_sensitive(!bHorFill && !bStackedText); +} + +bool AlignmentTabPage::HasAlignmentChanged( const SfxItemSet& rNew, TypedWhichId<SfxEnumItemInterface> nWhich ) const +{ + const SfxItemSet& rOld = GetItemSet(); + SvxCellJustifyMethod eMethodOld = SvxCellJustifyMethod::Auto; + SvxCellJustifyMethod eMethodNew = SvxCellJustifyMethod::Auto; + if (const SfxEnumItemInterface* p = rOld.GetItemIfSet(nWhich)) + { + eMethodOld = static_cast<SvxCellJustifyMethod>(p->GetEnumValue()); + } + + if (const SfxEnumItemInterface* p = rNew.GetItemIfSet(nWhich)) + { + eMethodNew = static_cast<SvxCellJustifyMethod>(p->GetEnumValue()); + } + + return eMethodOld != eMethodNew; +} + +IMPL_LINK(AlignmentTabPage, StackedClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aStackedState.ButtonToggled(rToggle); + UpdateEnableControls(); +} + +IMPL_LINK(AlignmentTabPage, AsianModeClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aAsianModeState.ButtonToggled(rToggle); +} + +IMPL_LINK(AlignmentTabPage, WrapClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aWrapState.ButtonToggled(rToggle); + UpdateEnableControls(); +} + +IMPL_LINK(AlignmentTabPage, HyphenClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aHyphenState.ButtonToggled(rToggle); +} + +IMPL_LINK(AlignmentTabPage, ShrinkClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aShrinkState.ButtonToggled(rToggle); +} + +IMPL_LINK_NOARG(AlignmentTabPage, UpdateEnableHdl, weld::ComboBox&, void) +{ + UpdateEnableControls(); +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/autocdlg.cxx b/cui/source/tabpages/autocdlg.cxx new file mode 100644 index 000000000..2c978a835 --- /dev/null +++ b/cui/source/tabpages/autocdlg.cxx @@ -0,0 +1,2364 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <i18nutil/unicode.hxx> +#include <o3tl/safeint.hxx> +#include <utility> +#include <vcl/event.hxx> +#include <vcl/keycodes.hxx> +#include <vcl/settings.hxx> +#include <vcl/transfer.hxx> +#include <sfx2/app.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/viewsh.hxx> +#include <unotools/charclass.hxx> +#include <unotools/collatorwrapper.hxx> +#include <comphelper/processfactory.hxx> +#include <vcl/svapp.hxx> +#include <sfx2/module.hxx> +#include <svl/eitem.hxx> +#include <svl/cjkoptions.hxx> +#include <svl/ctloptions.hxx> +#include <svx/SmartTagMgr.hxx> +#include <com/sun/star/smarttags/XSmartTagRecognizer.hpp> +#include <rtl/strbuf.hxx> +#include <o3tl/temporary.hxx> +#include <osl/diagnose.h> +#include <tools/debug.hxx> + +#include <autocdlg.hxx> +#include <editeng/acorrcfg.hxx> +#include <editeng/svxacorr.hxx> +#include <cui/cuicharmap.hxx> +#include <strings.hrc> +#include <dialmgr.hxx> +#include <svx/svxids.hrc> + +static LanguageType eLastDialogLanguage = LANGUAGE_SYSTEM; + +using namespace ::com::sun::star::util; +using namespace ::com::sun::star; + +OfaAutoCorrDlg::OfaAutoCorrDlg(weld::Window* pParent, const SfxItemSet* _pSet ) + : SfxTabDialogController(pParent, "cui/ui/autocorrectdialog.ui", "AutoCorrectDialog", _pSet) + , m_xLanguageBox(m_xBuilder->weld_widget("langbox")) + , m_xLanguageLB(new SvxLanguageBox(m_xBuilder->weld_combo_box("lang"))) +{ + bool bShowSWOptions = false; + bool bOpenSmartTagOptions = false; + + if ( _pSet ) + { + const SfxBoolItem* pItem = SfxItemSet::GetItem<SfxBoolItem>(_pSet, SID_AUTO_CORRECT_DLG, false); + if ( pItem && pItem->GetValue() ) + bShowSWOptions = true; + + const SfxBoolItem* pItem2 = SfxItemSet::GetItem<SfxBoolItem>(_pSet, SID_OPEN_SMARTTAGOPTIONS, false); + if ( pItem2 && pItem2->GetValue() ) + bOpenSmartTagOptions = true; + } + + AddTabPage("options", OfaAutocorrOptionsPage::Create, nullptr); + AddTabPage("applypage", OfaSwAutoFmtOptionsPage::Create, nullptr); + AddTabPage("wordcompletion", OfaAutoCompleteTabPage::Create, nullptr); + AddTabPage("smarttags", OfaSmartTagOptionsTabPage::Create, nullptr); + + if (!bShowSWOptions) + { + RemoveTabPage("applypage"); + RemoveTabPage("wordcompletion"); + RemoveTabPage("smarttags"); + } + else + { + // remove smart tag tab page if no extensions are installed + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags& rOpt = pAutoCorrect->GetSwFlags(); + if (!rOpt.pSmartTagMgr || 0 == rOpt.pSmartTagMgr->NumberOfRecognizers()) + RemoveTabPage("smarttags"); + + RemoveTabPage("options"); + } + + AddTabPage("replace", OfaAutocorrReplacePage::Create, nullptr); + AddTabPage("exceptions", OfaAutocorrExceptPage::Create, nullptr); + AddTabPage("localized", OfaQuoteTabPage::Create, nullptr); + + // initialize languages + //! LANGUAGE_NONE is displayed as '[All]' and the LanguageType + //! will be set to LANGUAGE_UNDETERMINED + SvxLanguageListFlags nLangList = SvxLanguageListFlags::WESTERN; + + if( SvtCTLOptions().IsCTLFontEnabled() ) + nLangList |= SvxLanguageListFlags::CTL; + if( SvtCJKOptions::IsCJKFontEnabled() ) + nLangList |= SvxLanguageListFlags::CJK; + m_xLanguageLB->SetLanguageList( nLangList, true, true ); + m_xLanguageLB->set_active_id( LANGUAGE_NONE ); + int nPos = m_xLanguageLB->get_active(); + DBG_ASSERT(nPos != -1, "listbox entry missing" ); + m_xLanguageLB->set_id(nPos, LANGUAGE_UNDETERMINED); + + // Initializing doesn't work for static on linux - therefore here + if (LANGUAGE_SYSTEM == eLastDialogLanguage) + eLastDialogLanguage = Application::GetSettings().GetLanguageTag().getLanguageType(); + + LanguageType nSelectLang = LANGUAGE_UNDETERMINED; + nPos = m_xLanguageLB->find_id(eLastDialogLanguage); + if (nPos != -1) + nSelectLang = eLastDialogLanguage; + m_xLanguageLB->set_active_id(nSelectLang); + + m_xLanguageLB->connect_changed(LINK(this, OfaAutoCorrDlg, SelectLanguageHdl)); + + if ( bOpenSmartTagOptions ) + SetCurPageId("smarttags"); +} + +OfaAutoCorrDlg::~OfaAutoCorrDlg() +{ +} + +void OfaAutoCorrDlg::EnableLanguage(bool bEnable) +{ + m_xLanguageBox->set_sensitive(bEnable); +} + +static bool lcl_FindEntry(weld::TreeView& rLB, const OUString& rEntry, + CollatorWrapper const & rCmpClass) +{ + int nCount = rLB.n_children(); + int nSelPos = rLB.get_selected_index(); + for (int i = 0; i < nCount; i++) + { + if (0 == rCmpClass.compareString(rEntry, rLB.get_text(i))) + { + rLB.select(i); + return true; + } + } + if (nSelPos != -1) + rLB.unselect(nSelPos); + return false; +} + +IMPL_LINK_NOARG(OfaAutoCorrDlg, SelectLanguageHdl, weld::ComboBox&, void) +{ + LanguageType eNewLang = m_xLanguageLB->get_active_id(); + // save old settings and fill anew + if(eNewLang == eLastDialogLanguage) + return; + + OString sPageId = GetCurPageId(); + if (sPageId == "replace") + { + OfaAutocorrReplacePage* pPage = static_cast<OfaAutocorrReplacePage*>(GetTabPage(sPageId)); + assert(pPage); + pPage->SetLanguage(eNewLang); + } + else if (sPageId == "exceptions") + { + OfaAutocorrExceptPage* pPage = static_cast<OfaAutocorrExceptPage*>(GetTabPage(sPageId)); + assert(pPage); + pPage->SetLanguage(eNewLang); + } +} + +OfaAutocorrOptionsPage::OfaAutocorrOptionsPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/acoroptionspage.ui", "AutocorrectOptionsPage", &rSet) + , m_sInput(CuiResId(RID_CUISTR_USE_REPLACE)) + , m_sDoubleCaps(CuiResId(RID_CUISTR_CPTL_STT_WORD)) + , m_sStartCap(CuiResId(RID_CUISTR_CPTL_STT_SENT)) + , m_sBoldUnderline(CuiResId(RID_CUISTR_BOLD_UNDER)) + , m_sURL(CuiResId(RID_CUISTR_DETECT_URL)) + , m_sNoDblSpaces(CuiResId(RID_CUISTR_NO_DBL_SPACES)) + , m_sDash(CuiResId(RID_CUISTR_DASH)) + , m_sAccidentalCaps(CuiResId(RID_CUISTR_CORRECT_ACCIDENTAL_CAPS_LOCK)) + , m_xCheckLB(m_xBuilder->weld_tree_view("checklist")) +{ + m_xCheckLB->enable_toggle_buttons(weld::ColumnToggleType::Check); + m_xCheckLB->set_size_request(-1, m_xCheckLB->get_height_rows(10)); +} + +OfaAutocorrOptionsPage::~OfaAutocorrOptionsPage() +{ +} + +std::unique_ptr<SfxTabPage> OfaAutocorrOptionsPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rSet) +{ + return std::make_unique<OfaAutocorrOptionsPage>(pPage, pController, *rSet); +} + +#define CBCOL_FIRST 0 +#define CBCOL_SECOND 1 +#define CBCOL_BOTH 2 + +bool OfaAutocorrOptionsPage::FillItemSet( SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + ACFlags nFlags = pAutoCorrect->GetFlags(); + + int nPos = 0; + pAutoCorrect->SetAutoCorrFlag(ACFlags::Autocorrect, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::CapitalStartWord, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::CapitalStartSentence, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgWeightUnderl, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::SetINetAttr, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgToEnEmDash, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::IgnoreDoubleSpace, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::CorrectCapsLock, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + + bool bReturn = nFlags != pAutoCorrect->GetFlags(); + if(bReturn ) + { + SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get(); + rCfg.SetModified(); + rCfg.Commit(); + } + return bReturn; +} + +void OfaAutocorrOptionsPage::ActivatePage( const SfxItemSet& ) +{ + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage(false); +} + +void OfaAutocorrOptionsPage::InsertEntry(const OUString& rTxt) +{ + m_xCheckLB->append(); + const int nRow = m_xCheckLB->n_children() - 1; + m_xCheckLB->set_toggle(nRow, TRISTATE_FALSE); + m_xCheckLB->set_text(nRow, rTxt, 0); +} + +void OfaAutocorrOptionsPage::Reset( const SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + const ACFlags nFlags = pAutoCorrect->GetFlags(); + + m_xCheckLB->freeze(); + m_xCheckLB->clear(); + + InsertEntry(m_sInput); + InsertEntry(m_sDoubleCaps); + InsertEntry(m_sStartCap); + InsertEntry(m_sBoldUnderline); + InsertEntry(m_sURL); + InsertEntry(m_sDash); + InsertEntry(m_sNoDblSpaces); + InsertEntry(m_sAccidentalCaps); + + int nPos = 0; + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::Autocorrect) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::CapitalStartWord) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::CapitalStartSentence) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::ChgWeightUnderl) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::SetINetAttr) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::ChgToEnEmDash) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::IgnoreDoubleSpace) ? TRISTATE_TRUE : TRISTATE_FALSE ); + m_xCheckLB->set_toggle( nPos++, bool(nFlags & ACFlags::CorrectCapsLock) ? TRISTATE_TRUE : TRISTATE_FALSE ); + + m_xCheckLB->thaw(); +} + +/*********************************************************************/ +/* */ +/* helping struct for dUserData of the Checklistbox */ +/* */ +/*********************************************************************/ + +namespace { + +struct ImpUserData +{ + OUString *pString; + vcl::Font *pFont; + + ImpUserData(OUString* pText, vcl::Font* pFnt) + { pString = pText; pFont = pFnt;} +}; + + +/*********************************************************************/ +/* */ +/* dialog for per cent settings */ +/* */ +/*********************************************************************/ + +class OfaAutoFmtPrcntSet : public weld::GenericDialogController +{ + std::unique_ptr<weld::MetricSpinButton> m_xPrcntMF; +public: + explicit OfaAutoFmtPrcntSet(weld::Window* pParent) + : GenericDialogController(pParent, "cui/ui/percentdialog.ui", "PercentDialog") + , m_xPrcntMF(m_xBuilder->weld_metric_spin_button("margin", FieldUnit::PERCENT)) + { + } + + weld::MetricSpinButton& GetPrcntFld() + { + return *m_xPrcntMF; + } +}; + +/*********************************************************************/ +/* */ +/* use TabPage autoformat */ +/* */ +/*********************************************************************/ + +enum OfaAutoFmtOptions +{ + USE_REPLACE_TABLE, + CORR_UPPER, + BEGIN_UPPER, + BOLD_UNDERLINE, + DETECT_URL, + REPLACE_DASHES, + DEL_SPACES_AT_STT_END, + DEL_SPACES_BETWEEN_LINES, + IGNORE_DBLSPACE, + CORRECT_CAPS_LOCK, + APPLY_NUMBERING, + INSERT_BORDER, + CREATE_TABLE, + REPLACE_STYLES, + DEL_EMPTY_NODE, + REPLACE_USER_COLL, + REPLACE_BULLETS, + MERGE_SINGLE_LINE_PARA +}; + +} + +OfaSwAutoFmtOptionsPage::OfaSwAutoFmtOptionsPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rSet ) + : SfxTabPage(pPage, pController, "cui/ui/applyautofmtpage.ui", "ApplyAutoFmtPage", &rSet) + , sDeleteEmptyPara(CuiResId(RID_CUISTR_DEL_EMPTY_PARA)) + , sUseReplaceTbl(CuiResId(RID_CUISTR_USE_REPLACE)) + , sCapitalStartWord(CuiResId(RID_CUISTR_CPTL_STT_WORD)) + , sCapitalStartSentence(CuiResId(RID_CUISTR_CPTL_STT_SENT)) + , sUserStyle(CuiResId(RID_CUISTR_USER_STYLE)) + , sBullet(CuiResId(RID_CUISTR_BULLET)) + , sBoldUnder(CuiResId(RID_CUISTR_BOLD_UNDER)) + , sNoDblSpaces(CuiResId(RID_CUISTR_NO_DBL_SPACES)) + , sCorrectCapsLock(CuiResId(RID_CUISTR_CORRECT_ACCIDENTAL_CAPS_LOCK)) + , sDetectURL(CuiResId(RID_CUISTR_DETECT_URL)) + , sDash(CuiResId(RID_CUISTR_DASH)) + , sRightMargin(CuiResId(RID_CUISTR_RIGHT_MARGIN)) + , sNum(CuiResId(RID_CUISTR_NUM)) + , sBorder(CuiResId(RID_CUISTR_BORDER)) + , sTable(CuiResId(RID_CUISTR_CREATE_TABLE)) + , sReplaceTemplates(CuiResId(RID_CUISTR_REPLACE_TEMPLATES)) + , sDelSpaceAtSttEnd(CuiResId(RID_CUISTR_DEL_SPACES_AT_STT_END)) + , sDelSpaceBetweenLines(CuiResId(RID_CUISTR_DEL_SPACES_BETWEEN_LINES)) + , nPercent(50) + , m_xCheckLB(m_xBuilder->weld_tree_view("list")) + , m_xEditPB(m_xBuilder->weld_button("edit")) +{ + m_xCheckLB->connect_changed(LINK(this, OfaSwAutoFmtOptionsPage, SelectHdl)); + m_xCheckLB->connect_row_activated(LINK(this, OfaSwAutoFmtOptionsPage, DoubleClickEditHdl)); + m_xCheckLB->enable_toggle_buttons(weld::ColumnToggleType::Check); + + std::vector<int> aWidths + { + o3tl::narrowing<int>(m_xCheckLB->get_pixel_size(m_xCheckLB->get_column_title(0)).Width() * 2), + o3tl::narrowing<int>(m_xCheckLB->get_pixel_size(m_xCheckLB->get_column_title(1)).Width() * 2) + }; + m_xCheckLB->set_column_fixed_widths(aWidths); + + m_xEditPB->connect_clicked(LINK(this, OfaSwAutoFmtOptionsPage, EditHdl)); +} + +void OfaSwAutoFmtOptionsPage::CreateEntry(const OUString& rTxt, sal_uInt16 nCol) +{ + m_xCheckLB->append(); + const int nRow = m_xCheckLB->n_children() - 1; + if (nCol == CBCOL_FIRST || nCol == CBCOL_BOTH) + m_xCheckLB->set_toggle(nRow, TRISTATE_FALSE, CBCOL_FIRST); + if (nCol == CBCOL_SECOND || nCol == CBCOL_BOTH) + m_xCheckLB->set_toggle(nRow, TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_text(nRow, rTxt, 2); +} + +OfaSwAutoFmtOptionsPage::~OfaSwAutoFmtOptionsPage() +{ + delete weld::fromId<ImpUserData*>(m_xCheckLB->get_id(REPLACE_BULLETS)); + delete weld::fromId<ImpUserData*>(m_xCheckLB->get_id(APPLY_NUMBERING)); + delete weld::fromId<ImpUserData*>(m_xCheckLB->get_id(MERGE_SINGLE_LINE_PARA)); +} + +std::unique_ptr<SfxTabPage> OfaSwAutoFmtOptionsPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<OfaSwAutoFmtOptionsPage>(pPage, pController, *rAttrSet); +} + +bool OfaSwAutoFmtOptionsPage::FillItemSet( SfxItemSet* ) +{ + bool bModified = false; + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + ACFlags nFlags = pAutoCorrect->GetFlags(); + + bool bCheck = m_xCheckLB->get_toggle(USE_REPLACE_TABLE, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bAutoCorrect != bCheck; + pOpt->bAutoCorrect = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::Autocorrect, + m_xCheckLB->get_toggle(USE_REPLACE_TABLE, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xCheckLB->get_toggle(CORR_UPPER, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bCapitalStartWord != bCheck; + pOpt->bCapitalStartWord = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::CapitalStartWord, + m_xCheckLB->get_toggle(CORR_UPPER, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xCheckLB->get_toggle(BEGIN_UPPER, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bCapitalStartSentence != bCheck; + pOpt->bCapitalStartSentence = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::CapitalStartSentence, + m_xCheckLB->get_toggle(BEGIN_UPPER, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xCheckLB->get_toggle(BOLD_UNDERLINE, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bChgWeightUnderl != bCheck; + pOpt->bChgWeightUnderl = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgWeightUnderl, + m_xCheckLB->get_toggle(BOLD_UNDERLINE, CBCOL_SECOND) == TRISTATE_TRUE); + + pAutoCorrect->SetAutoCorrFlag(ACFlags::IgnoreDoubleSpace, + m_xCheckLB->get_toggle(IGNORE_DBLSPACE, CBCOL_SECOND) == TRISTATE_TRUE); + + pAutoCorrect->SetAutoCorrFlag(ACFlags::CorrectCapsLock, + m_xCheckLB->get_toggle(CORRECT_CAPS_LOCK, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xCheckLB->get_toggle(DETECT_URL, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bSetINetAttr != bCheck; + pOpt->bSetINetAttr = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::SetINetAttr, + m_xCheckLB->get_toggle(DETECT_URL, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xCheckLB->get_toggle(DEL_EMPTY_NODE, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bDelEmptyNode != bCheck; + pOpt->bDelEmptyNode = bCheck; + + bCheck = m_xCheckLB->get_toggle(REPLACE_USER_COLL, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bChgUserColl != bCheck; + pOpt->bChgUserColl = bCheck; + + bCheck = m_xCheckLB->get_toggle(REPLACE_BULLETS, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bChgEnumNum != bCheck; + pOpt->bChgEnumNum = bCheck; + bModified |= aBulletFont != pOpt->aBulletFont; + pOpt->aBulletFont = aBulletFont; + bModified |= sBulletChar != OUString(&pOpt->cBullet, 1); + pOpt->cBullet = sBulletChar.iterateCodePoints(&o3tl::temporary(sal_Int32(0))); + + bModified |= aByInputBulletFont != pOpt->aByInputBulletFont; + bModified |= sByInputBulletChar != OUString(&pOpt->cByInputBullet, 1); + pOpt->aByInputBulletFont = aByInputBulletFont; + pOpt->cByInputBullet = sByInputBulletChar.iterateCodePoints(&o3tl::temporary(sal_Int32(0))); + + bCheck = m_xCheckLB->get_toggle(MERGE_SINGLE_LINE_PARA, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bRightMargin != bCheck; + pOpt->bRightMargin = bCheck; + bModified |= nPercent != pOpt->nRightMargin; + pOpt->nRightMargin = static_cast<sal_uInt8>(nPercent); + + bCheck = m_xCheckLB->get_toggle(APPLY_NUMBERING, CBCOL_SECOND) == TRISTATE_TRUE; + bModified |= pOpt->bSetNumRule != bCheck; + pOpt->bSetNumRule = bCheck; + + bCheck = m_xCheckLB->get_toggle(INSERT_BORDER, CBCOL_SECOND) == TRISTATE_TRUE; + bModified |= pOpt->bSetBorder != bCheck; + pOpt->bSetBorder = bCheck; + + bCheck = m_xCheckLB->get_toggle(CREATE_TABLE, CBCOL_SECOND) == TRISTATE_TRUE; + bModified |= pOpt->bCreateTable != bCheck; + pOpt->bCreateTable = bCheck; + + bCheck = m_xCheckLB->get_toggle(REPLACE_STYLES, CBCOL_SECOND) == TRISTATE_TRUE; + bModified |= pOpt->bReplaceStyles != bCheck; + pOpt->bReplaceStyles = bCheck; + + bCheck = m_xCheckLB->get_toggle(REPLACE_DASHES, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bChgToEnEmDash != bCheck; + pOpt->bChgToEnEmDash = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgToEnEmDash, + m_xCheckLB->get_toggle(REPLACE_DASHES, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xCheckLB->get_toggle(DEL_SPACES_AT_STT_END, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bAFormatDelSpacesAtSttEnd != bCheck; + pOpt->bAFormatDelSpacesAtSttEnd = bCheck; + bCheck = m_xCheckLB->get_toggle(DEL_SPACES_AT_STT_END, CBCOL_SECOND) == TRISTATE_TRUE; + bModified |= pOpt->bAFormatByInpDelSpacesAtSttEnd != bCheck; + pOpt->bAFormatByInpDelSpacesAtSttEnd = bCheck; + + bCheck = m_xCheckLB->get_toggle(DEL_SPACES_BETWEEN_LINES, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bAFormatDelSpacesBetweenLines != bCheck; + pOpt->bAFormatDelSpacesBetweenLines = bCheck; + bCheck = m_xCheckLB->get_toggle(DEL_SPACES_BETWEEN_LINES, CBCOL_SECOND) == TRISTATE_TRUE; + bModified |= pOpt->bAFormatByInpDelSpacesBetweenLines != bCheck; + pOpt->bAFormatByInpDelSpacesBetweenLines = bCheck; + + if(bModified || nFlags != pAutoCorrect->GetFlags()) + { + SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get(); + rCfg.SetModified(); + rCfg.Commit(); + } + + return true; +} + +void OfaSwAutoFmtOptionsPage::ActivatePage( const SfxItemSet& ) +{ + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage(false); +} + +void OfaSwAutoFmtOptionsPage::Reset( const SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + const ACFlags nFlags = pAutoCorrect->GetFlags(); + + aBulletFont = pOpt->aBulletFont; + sBulletChar = OUString(&pOpt->cBullet, 1); + + aByInputBulletFont = pOpt->aByInputBulletFont; + sByInputBulletChar = OUString(&pOpt->cByInputBullet, 1); + + nPercent = pOpt->nRightMargin; + sMargin = unicode::formatPercent(nPercent, Application::GetSettings().GetUILanguageTag()); + + m_xCheckLB->freeze(); + m_xCheckLB->clear(); + + // The following entries have to be inserted in the same order + // as in the OfaAutoFmtOptions-enum! + CreateEntry(sUseReplaceTbl, CBCOL_BOTH ); + CreateEntry(sCapitalStartWord, CBCOL_BOTH ); + CreateEntry(sCapitalStartSentence, CBCOL_BOTH ); + CreateEntry(sBoldUnder, CBCOL_BOTH ); + CreateEntry(sDetectURL, CBCOL_BOTH ); + CreateEntry(sDash, CBCOL_BOTH ); + CreateEntry(sDelSpaceAtSttEnd, CBCOL_BOTH ); + CreateEntry(sDelSpaceBetweenLines, CBCOL_BOTH ); + + CreateEntry(sNoDblSpaces, CBCOL_SECOND); + CreateEntry(sCorrectCapsLock, CBCOL_SECOND); + CreateEntry(sNum.replaceFirst("%1", sBulletChar), CBCOL_SECOND); + CreateEntry(sBorder, CBCOL_SECOND); + CreateEntry(sTable, CBCOL_SECOND); + CreateEntry(sReplaceTemplates, CBCOL_SECOND); + CreateEntry(sDeleteEmptyPara, CBCOL_FIRST ); + CreateEntry(sUserStyle, CBCOL_FIRST ); + CreateEntry(sBullet.replaceFirst("%1", sByInputBulletChar), CBCOL_FIRST); + CreateEntry(sRightMargin.replaceFirst("%1", sMargin), CBCOL_FIRST); + + m_xCheckLB->set_toggle(USE_REPLACE_TABLE, pOpt->bAutoCorrect ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(USE_REPLACE_TABLE, bool(nFlags & ACFlags::Autocorrect) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(CORR_UPPER, pOpt->bCapitalStartWord ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(CORR_UPPER, bool(nFlags & ACFlags::CapitalStartWord) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(BEGIN_UPPER, pOpt->bCapitalStartSentence ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(BEGIN_UPPER, bool(nFlags & ACFlags::CapitalStartSentence) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(BOLD_UNDERLINE, pOpt->bChgWeightUnderl ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(BOLD_UNDERLINE, bool(nFlags & ACFlags::ChgWeightUnderl) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(DETECT_URL, pOpt->bSetINetAttr ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(DETECT_URL, bool(nFlags & ACFlags::SetINetAttr) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(REPLACE_DASHES, pOpt->bChgToEnEmDash ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(REPLACE_DASHES, bool(nFlags & ACFlags::ChgToEnEmDash) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(DEL_SPACES_AT_STT_END, pOpt->bAFormatDelSpacesAtSttEnd ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(DEL_SPACES_AT_STT_END, pOpt->bAFormatByInpDelSpacesAtSttEnd ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(DEL_SPACES_BETWEEN_LINES, pOpt->bAFormatDelSpacesBetweenLines ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(DEL_SPACES_BETWEEN_LINES, pOpt->bAFormatByInpDelSpacesBetweenLines ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(IGNORE_DBLSPACE, bool(nFlags & ACFlags::IgnoreDoubleSpace) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(CORRECT_CAPS_LOCK, bool(nFlags & ACFlags::CorrectCapsLock) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(APPLY_NUMBERING, pOpt->bSetNumRule ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(INSERT_BORDER, pOpt->bSetBorder ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(CREATE_TABLE, pOpt->bCreateTable ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(REPLACE_STYLES, pOpt->bReplaceStyles ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xCheckLB->set_toggle(DEL_EMPTY_NODE, pOpt->bDelEmptyNode ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(REPLACE_USER_COLL, pOpt->bChgUserColl ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(REPLACE_BULLETS, pOpt->bChgEnumNum ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xCheckLB->set_toggle(MERGE_SINGLE_LINE_PARA, pOpt->bRightMargin ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + + ImpUserData* pUserData = new ImpUserData(&sBulletChar, &aBulletFont); + OUString sId(weld::toId(pUserData)); + m_xCheckLB->set_id(REPLACE_BULLETS, sId); + + pUserData = new ImpUserData(&sMargin, nullptr); + sId = weld::toId(pUserData); + m_xCheckLB->set_id(MERGE_SINGLE_LINE_PARA, sId); + + ImpUserData* pUserData2 = new ImpUserData(&sByInputBulletChar, &aByInputBulletFont); + sId = weld::toId(pUserData2); + m_xCheckLB->set_id(APPLY_NUMBERING, sId); + + m_xCheckLB->thaw(); +} + +IMPL_LINK(OfaSwAutoFmtOptionsPage, SelectHdl, weld::TreeView&, rBox, void) +{ + m_xEditPB->set_sensitive(rBox.get_selected_id().toInt64() != 0); +} + +IMPL_LINK_NOARG(OfaSwAutoFmtOptionsPage, DoubleClickEditHdl, weld::TreeView&, bool) +{ + EditHdl(*m_xEditPB); + return true; +} + +IMPL_LINK_NOARG(OfaSwAutoFmtOptionsPage, EditHdl, weld::Button&, void) +{ + int nSelEntryPos = m_xCheckLB->get_selected_index(); + if (nSelEntryPos == REPLACE_BULLETS || nSelEntryPos == APPLY_NUMBERING) + { + SvxCharacterMap aMapDlg(GetFrameWeld(), nullptr, nullptr); + ImpUserData* pUserData = weld::fromId<ImpUserData*>(m_xCheckLB->get_id(nSelEntryPos)); + aMapDlg.SetCharFont(*pUserData->pFont); + aMapDlg.SetChar( (*pUserData->pString)[0] ); + if (RET_OK == aMapDlg.run()) + { + const vcl::Font& aFont(aMapDlg.GetCharFont()); + *pUserData->pFont = aFont; + sal_UCS4 aChar = aMapDlg.GetChar(); + // using the UCS4 constructor + OUString aOUStr( &aChar, 1 ); + *pUserData->pString = aOUStr; + if (nSelEntryPos == REPLACE_BULLETS) + m_xCheckLB->set_text(nSelEntryPos, sNum.replaceFirst("%1", aOUStr), 2); + else + m_xCheckLB->set_text(nSelEntryPos, sBullet.replaceFirst("%1", aOUStr), 2); + } + } + else if( MERGE_SINGLE_LINE_PARA == nSelEntryPos ) + { + // dialog for per cent settings + OfaAutoFmtPrcntSet aDlg(GetFrameWeld()); + aDlg.GetPrcntFld().set_value(nPercent, FieldUnit::PERCENT); + if (aDlg.run() == RET_OK) + { + nPercent = static_cast<sal_uInt16>(aDlg.GetPrcntFld().get_value(FieldUnit::PERCENT)); + sMargin = unicode::formatPercent(nPercent, Application::GetSettings().GetUILanguageTag()); + m_xCheckLB->set_text(nSelEntryPos, sRightMargin.replaceFirst("%1", sMargin), 2); + } + } +} + + +OfaAutocorrReplacePage::OfaAutocorrReplacePage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/acorreplacepage.ui", "AcorReplacePage", &rSet) + , eLang(eLastDialogLanguage) + , bHasSelectionText(false) + , bFirstSelect(true) + , bReplaceEditChanged(false) + , bSWriter(true) + , m_xTextOnlyCB(m_xBuilder->weld_check_button("textonly")) + , m_xShortED(m_xBuilder->weld_entry("origtext")) + , m_xReplaceED(m_xBuilder->weld_entry("newtext")) + , m_xReplaceTLB(m_xBuilder->weld_tree_view("tabview")) + , m_xNewReplacePB(m_xBuilder->weld_button("new")) + , m_xReplacePB(m_xBuilder->weld_button("replace")) + , m_xDeleteReplacePB(m_xBuilder->weld_button("delete")) + , m_xButtonBox(m_xBuilder->weld_container("buttonbox")) +{ + sNew = m_xNewReplacePB->get_label(); + sModify = m_xReplacePB->get_label(); + + // lock down the width of the button box to its max + // desired width + auto nMaxWidth = m_xButtonBox->get_preferred_size().Width(); + m_xButtonBox->set_size_request(nMaxWidth, -1); + m_xReplacePB->hide(); + + // tdf#125348 set some small but fixed initial width size, final width will + // depend on the size of the entry boxes + m_xReplaceTLB->set_size_request(42, m_xReplaceTLB->get_height_rows(10)); + + SfxModule *pMod = SfxApplication::GetModule(SfxToolsModule::Writer); + bSWriter = pMod == SfxModule::GetActiveModule(); + + LanguageTag aLanguageTag( eLastDialogLanguage ); + pCompareClass.reset( new CollatorWrapper( comphelper::getProcessComponentContext() ) ); + pCompareClass->loadDefaultCollator( aLanguageTag.getLocale(), 0 ); + pCharClass.reset( new CharClass( std::move(aLanguageTag) ) ); + + auto nColWidth = m_xReplaceTLB->get_approximate_digit_width() * 32; + m_aReplaceFixedWidths.push_back(nColWidth); + m_aReplaceFixedWidths.push_back(nColWidth); + + m_xReplaceTLB->connect_changed( LINK(this, OfaAutocorrReplacePage, SelectHdl) ); + m_xNewReplacePB->connect_clicked( LINK(this, OfaAutocorrReplacePage, NewDelButtonHdl) ); + m_xDeleteReplacePB->connect_clicked( LINK(this, OfaAutocorrReplacePage, NewDelButtonHdl) ); + m_xShortED->connect_changed( LINK(this, OfaAutocorrReplacePage, ModifyHdl) ); + m_xReplaceED->connect_changed( LINK(this, OfaAutocorrReplacePage, ModifyHdl) ); + m_xShortED->connect_activate( LINK(this, OfaAutocorrReplacePage, NewDelActionHdl) ); + m_xReplaceED->connect_activate( LINK(this, OfaAutocorrReplacePage, NewDelActionHdl) ); + m_xShortED->connect_size_allocate(LINK(this, OfaAutocorrReplacePage, EntrySizeAllocHdl)); + m_xReplaceED->connect_size_allocate(LINK(this, OfaAutocorrReplacePage, EntrySizeAllocHdl)); +} + +OfaAutocorrReplacePage::~OfaAutocorrReplacePage() +{ + aDoubleStringTable.clear(); + aChangesTable.clear(); + + pCompareClass.reset(); + pCharClass.reset(); +} + +std::unique_ptr<SfxTabPage> OfaAutocorrReplacePage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<OfaAutocorrReplacePage>(pPage, pController, *rSet); +} + +void OfaAutocorrReplacePage::ActivatePage( const SfxItemSet& ) +{ + if(eLang != eLastDialogLanguage) + SetLanguage(eLastDialogLanguage); + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage(true); +} + +DeactivateRC OfaAutocorrReplacePage::DeactivatePage( SfxItemSet* ) +{ + return DeactivateRC::LeavePage; +} + +bool OfaAutocorrReplacePage::FillItemSet( SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + + for (StringChangeTable::reverse_iterator it = aChangesTable.rbegin(); it != aChangesTable.rend(); ++it) + { + LanguageType eCurrentLang = it->first; + StringChangeList& rStringChangeList = it->second; + std::vector<SvxAutocorrWord> aDeleteWords; + std::vector<SvxAutocorrWord> aNewWords; + + aDeleteWords.reserve( rStringChangeList.aDeletedEntries.size() ); + for (const DoubleString & deleteEntry : rStringChangeList.aDeletedEntries) + { + SvxAutocorrWord aDeleteWord( deleteEntry.sShort, deleteEntry.sLong ); + aDeleteWords.push_back( aDeleteWord ); + } + + aNewWords.reserve( rStringChangeList.aNewEntries.size() ); + for (const DoubleString & newEntry : rStringChangeList.aNewEntries) + { + //fdo#67697 if the user data is set then we want to retain the + //source formatting of the entry, so don't use the optimized + //text-only MakeCombinedChanges for this entry + bool bKeepSourceFormatting = newEntry.pUserData == &bHasSelectionText; + if (bKeepSourceFormatting) + { + if (SfxObjectShell* pSh = SfxObjectShell::Current()) + pAutoCorrect->PutText(newEntry.sShort, *pSh, eCurrentLang); + continue; + } + + SvxAutocorrWord aNewWord( newEntry.sShort, newEntry.sLong ); + aNewWords.push_back( aNewWord ); + } + pAutoCorrect->MakeCombinedChanges( aNewWords, aDeleteWords, eCurrentLang ); + } + aChangesTable.clear(); + return false; +} + +void OfaAutocorrReplacePage::RefillReplaceBox(bool bFromReset, + LanguageType eOldLanguage, + LanguageType eNewLanguage) +{ + eLang = eNewLanguage; + if(bFromReset) + { + aDoubleStringTable.clear(); + aChangesTable.clear(); + } + else + { + DoubleStringArray* pArray; + if(aDoubleStringTable.find(eOldLanguage) != aDoubleStringTable.end()) + { + pArray = &aDoubleStringTable[eOldLanguage]; + pArray->clear(); + } + else + { + pArray = &aDoubleStringTable[eOldLanguage]; // create new array + } + + m_xReplaceTLB->all_foreach([this, &pArray](weld::TreeIter& rIter) { + pArray->push_back(DoubleString(m_xReplaceTLB->get_text(rIter, 0), + m_xReplaceTLB->get_text(rIter, 1))); + DoubleString& rDouble = pArray->back(); + rDouble.pUserData = weld::fromId<void*>(m_xReplaceTLB->get_id(rIter)); + return false; + }); + } + + if( !bSWriter ) + aFormatText.clear(); + + if (aDoubleStringTable.find(eLang) != aDoubleStringTable.end()) + { + DoubleStringArray& rArray = aDoubleStringTable[eNewLanguage]; + + m_xReplaceTLB->bulk_insert_for_each(rArray.size(), [this, &rArray](weld::TreeIter& rIter, int nIndex) { + DoubleString &rDouble = rArray[nIndex]; + bool bTextOnly = nullptr == rDouble.pUserData; + // formatted text is only in Writer + if (bSWriter || bTextOnly) + { + if (!bTextOnly) + { + // that means: with format info or even with selection text + OUString sId = weld::toId(rDouble.pUserData); + m_xReplaceTLB->set_id(rIter, sId); + } + m_xReplaceTLB->set_text(rIter, rDouble.sShort, 0); + m_xReplaceTLB->set_text(rIter, rDouble.sLong, 1); + } + else + { + aFormatText.insert(rDouble.sShort); + } + }, nullptr, &m_aReplaceFixedWidths); + } + else + { + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxAutocorrWordList* pWordList = pAutoCorrect->LoadAutocorrWordList(eLang); + const SvxAutocorrWordList::AutocorrWordSetType & rContent = pWordList->getSortedContent(); + m_xReplaceTLB->bulk_insert_for_each(rContent.size(), [this, rContent](weld::TreeIter& rIter, int nIndex) { + auto const& elem = rContent[nIndex]; + bool bTextOnly = elem.IsTextOnly(); + // formatted text is only in Writer + if (bSWriter || bTextOnly) + { + if (!bTextOnly) + { + // that means: with format info or even with selection text + OUString sId = weld::toId(m_xTextOnlyCB.get()); + m_xReplaceTLB->set_id(rIter, sId); + } + m_xReplaceTLB->set_text(rIter, elem.GetShort(), 0); + m_xReplaceTLB->set_text(rIter, elem.GetLong(), 1); + } + else + { + aFormatText.insert(elem.GetShort()); + } + }, nullptr, &m_aReplaceFixedWidths); + m_xNewReplacePB->set_sensitive(false); + m_xDeleteReplacePB->set_sensitive(false); + } + + SfxViewShell* pViewShell = SfxViewShell::Current(); + if (pViewShell && pViewShell->HasSelection()) + { + bHasSelectionText = true; + const OUString sSelection( pViewShell->GetSelectionText() ); + m_xReplaceED->set_text(sSelection); + m_xTextOnlyCB->set_active(!bSWriter); + m_xTextOnlyCB->set_sensitive(bSWriter && !sSelection.isEmpty()); + } + else + { + m_xTextOnlyCB->set_active(true); + m_xTextOnlyCB->set_sensitive(false); + } +} + +void OfaAutocorrReplacePage::Reset( const SfxItemSet* ) +{ + RefillReplaceBox(true, eLang, eLang); + m_xShortED->grab_focus(); +} + +void OfaAutocorrReplacePage::SetLanguage(LanguageType eSet) +{ + //save old settings and refill + if(eSet != eLang) + { + RefillReplaceBox(false, eLang, eSet); + eLastDialogLanguage = eSet; + + LanguageTag aLanguageTag( eLastDialogLanguage ); + pCompareClass.reset( new CollatorWrapper( comphelper::getProcessComponentContext() ) ); + pCompareClass->loadDefaultCollator( aLanguageTag.getLocale(), 0 ); + pCharClass.reset( new CharClass( std::move(aLanguageTag) ) ); + ModifyHdl(*m_xShortED); + } +} + +IMPL_LINK(OfaAutocorrReplacePage, SelectHdl, weld::TreeView&, rBox, void) +{ + if(!bFirstSelect || !bHasSelectionText) + { + int nEntry = rBox.get_selected_index(); + OUString sTmpShort(rBox.get_text(nEntry, 0)); + // if the text is set via ModifyHdl, the cursor is always at the beginning + // of a word, although you're editing here + bool bSameContent = 0 == pCompareClass->compareString(sTmpShort, m_xShortED->get_text()); + int nStartPos, nEndPos; + m_xShortED->get_selection_bounds(nStartPos, nEndPos); + if (m_xShortED->get_text() != sTmpShort) + { + m_xShortED->set_text(sTmpShort); + // if it was only a different notation, the selection has to be set again + if (bSameContent) + { + m_xShortED->select_region(nStartPos, nEndPos); + } + } + m_xReplaceED->set_text(rBox.get_text(nEntry, 1)); + // with UserData there is a Formatinfo + m_xTextOnlyCB->set_active(rBox.get_id(nEntry).isEmpty()); + } + else + { + bFirstSelect = false; + } + + m_xNewReplacePB->set_sensitive(false); + m_xDeleteReplacePB->set_sensitive(true); +}; + +void OfaAutocorrReplacePage::NewEntry(const OUString& sShort, const OUString& sLong, bool bKeepSourceFormatting) +{ + DoubleStringArray& rNewArray = aChangesTable[eLang].aNewEntries; + for (size_t i = 0; i < rNewArray.size(); i++) + { + if (rNewArray[i].sShort == sShort) + { + rNewArray.erase(rNewArray.begin() + i); + break; + } + } + + DoubleStringArray& rDeletedArray = aChangesTable[eLang].aDeletedEntries; + for (size_t i = 0; i < rDeletedArray.size(); i++) + { + if (rDeletedArray[i].sShort == sShort) + { + rDeletedArray.erase(rDeletedArray.begin() + i); + break; + } + } + + DoubleString aNewString(sShort, sLong); + rNewArray.push_back(aNewString); + if (bKeepSourceFormatting) + rNewArray.back().pUserData = &bHasSelectionText; +} + +void OfaAutocorrReplacePage::DeleteEntry(const OUString& sShort, const OUString& sLong) +{ + DoubleStringArray& rNewArray = aChangesTable[eLang].aNewEntries; + for (size_t i = 0; i < rNewArray.size(); i++) + { + if (rNewArray[i].sShort == sShort) + { + rNewArray.erase(rNewArray.begin() + i); + break; + } + } + + DoubleStringArray& rDeletedArray = aChangesTable[eLang].aDeletedEntries; + for (size_t i = 0; i < rDeletedArray.size(); i++) + { + if (rDeletedArray[i].sShort == sShort) + { + rDeletedArray.erase(rDeletedArray.begin() + i); + break; + } + } + + DoubleString aDeletedString(sShort, sLong); + rDeletedArray.push_back(aDeletedString); +} + +IMPL_LINK(OfaAutocorrReplacePage, NewDelButtonHdl, weld::Button&, rBtn, void) +{ + NewDelHdl(&rBtn); +} + +IMPL_LINK(OfaAutocorrReplacePage, NewDelActionHdl, weld::Entry&, rEdit, bool) +{ + return NewDelHdl(&rEdit); +} + +IMPL_LINK_NOARG(OfaAutocorrReplacePage, EntrySizeAllocHdl, const Size&, void) +{ + m_aReplaceFixedWidths.clear(); + int x, y, width, height; + if (m_xReplaceED->get_extents_relative_to(*m_xReplaceTLB, x, y, width, height)) + { + m_aReplaceFixedWidths.push_back(x); + m_aReplaceFixedWidths.push_back(width - 1); + m_xReplaceTLB->set_column_fixed_widths(m_aReplaceFixedWidths); + } +} + +bool OfaAutocorrReplacePage::NewDelHdl(const weld::Widget* pBtn) +{ + int nEntry = m_xReplaceTLB->get_selected_index(); + if (pBtn == m_xDeleteReplacePB.get()) + { + DBG_ASSERT( nEntry != -1, "no entry selected" ); + if (nEntry != -1) + { + DeleteEntry(m_xReplaceTLB->get_text(nEntry, 0), m_xReplaceTLB->get_text(nEntry, 1)); + m_xReplaceTLB->remove(nEntry); + ModifyHdl(*m_xShortED); + return true; + } + } + + if (pBtn == m_xNewReplacePB.get() || m_xNewReplacePB->get_sensitive()) + { + OUString sEntry(m_xShortED->get_text()); + if (!sEntry.isEmpty() && (!m_xReplaceED->get_text().isEmpty() || + ( bHasSelectionText && bSWriter ) )) + { + bool bKeepSourceFormatting = !bReplaceEditChanged && !m_xTextOnlyCB->get_active(); + + NewEntry(m_xShortED->get_text(), m_xReplaceED->get_text(), bKeepSourceFormatting); + m_xReplaceTLB->freeze(); + int nPos = -1; + if (nEntry != -1) + { + nPos = nEntry; + m_xReplaceTLB->remove(nEntry); + } + else + { + int j; + int nCount = m_xReplaceTLB->n_children(); + for (j = 0; j < nCount; ++j) + { + if (0 >= pCompareClass->compareString(sEntry, m_xReplaceTLB->get_text(j, 0))) + break; + } + nPos = j; + } + + OUString sId; + if (bKeepSourceFormatting) + { + sId = weld::toId(&bHasSelectionText); // new formatted text + } + + m_xReplaceTLB->insert(nPos, sEntry, &sId, nullptr, nullptr); + m_xReplaceTLB->set_text(nPos, m_xReplaceED->get_text(), 1); + m_xReplaceTLB->thaw(); + m_xReplaceTLB->scroll_to_row(nPos); + // if the request came from the ReplaceEdit, give focus to the ShortEdit + if (m_xReplaceED->has_focus()) + { + m_xShortED->grab_focus(); + } + } + } + else + { + // this can only be an enter in one of the two edit fields + // which means EndDialog() - has to be evaluated in KeyInput + return false; + } + ModifyHdl(*m_xShortED); + return true; +} + +IMPL_LINK(OfaAutocorrReplacePage, ModifyHdl, weld::Entry&, rEdt, void) +{ + std::unique_ptr<weld::TreeIter> xFirstSel(m_xReplaceTLB->make_iterator()); + bool bFirstSelIterSet = m_xReplaceTLB->get_selected(xFirstSel.get()); + bool bShort = &rEdt == m_xShortED.get(); + const OUString rEntry = rEdt.get_text(); + const OUString rRepString = m_xReplaceED->get_text(); + OUString aWordStr(pCharClass->lowercase(rEntry)); + + if(bShort) + { + if(!rEntry.isEmpty()) + { + bool bFound = false; + bool bTmpSelEntry=false; + + m_xReplaceTLB->all_foreach([this, &rEntry, &rRepString, &bFound, + &bTmpSelEntry, &bFirstSelIterSet, + &xFirstSel, &aWordStr](weld::TreeIter& rIter){ + OUString aTestStr = m_xReplaceTLB->get_text(rIter, 0); + if( pCompareClass->compareString(rEntry, aTestStr ) == 0 ) + { + if (!rRepString.isEmpty()) + bFirstSelect = true; + m_xReplaceTLB->set_cursor(rIter); + m_xReplaceTLB->copy_iterator(rIter, *xFirstSel); + bFirstSelIterSet = true; + m_xNewReplacePB->set_label(sModify); + bFound = true; + return true; + } + else + { + aTestStr = pCharClass->lowercase( aTestStr ); + if( aTestStr.startsWith(aWordStr) && !bTmpSelEntry ) + { + m_xReplaceTLB->scroll_to_row(rIter); + bTmpSelEntry = true; + } + } + return false; + }); + if( !bFound ) + { + m_xReplaceTLB->select(-1); + bFirstSelIterSet = false; + m_xNewReplacePB->set_label(sNew); + if( bReplaceEditChanged ) + m_xTextOnlyCB->set_sensitive(false); + } + m_xDeleteReplacePB->set_sensitive(bFound); + } + else if (m_xReplaceTLB->n_children() > 0) + { + m_xReplaceTLB->scroll_to_row(0); + } + + } + else if( !bShort ) + { + bReplaceEditChanged = true; + if (bFirstSelIterSet) + { + m_xNewReplacePB->set_label(sModify); + } + } + + const OUString& rShortTxt = m_xShortED->get_text(); + bool bEnableNew = !rShortTxt.isEmpty() && + ( !rRepString.isEmpty() || + ( bHasSelectionText && bSWriter )) && + ( !bFirstSelIterSet || rRepString != + m_xReplaceTLB->get_text(*xFirstSel, 1) ); + if( bEnableNew ) + { + for (auto const& elem : aFormatText) + { + if(elem == rShortTxt) + { + bEnableNew = false; + break; + } + } + } + m_xNewReplacePB->set_sensitive(bEnableNew); +} + +static bool lcl_FindInArray(std::vector<OUString>& rStrings, std::u16string_view rString) +{ + for (auto const& elem : rStrings) + { + if(elem == rString) + { + return true; + } + } + return false; +} + +OfaAutocorrExceptPage::OfaAutocorrExceptPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/acorexceptpage.ui", "AcorExceptPage", &rSet) + , eLang(eLastDialogLanguage) + , m_xAbbrevED(m_xBuilder->weld_entry("abbrev")) + , m_xAbbrevLB(m_xBuilder->weld_tree_view("abbrevlist")) + , m_xNewAbbrevPB(m_xBuilder->weld_button("newabbrev")) + , m_xDelAbbrevPB(m_xBuilder->weld_button("delabbrev")) + , m_xAutoAbbrevCB(m_xBuilder->weld_check_button("autoabbrev")) + , m_xDoubleCapsED(m_xBuilder->weld_entry("double")) + , m_xDoubleCapsLB(m_xBuilder->weld_tree_view("doublelist")) + , m_xNewDoublePB(m_xBuilder->weld_button("newdouble")) + , m_xDelDoublePB(m_xBuilder->weld_button("deldouble")) + , m_xAutoCapsCB(m_xBuilder->weld_check_button("autodouble")) +{ + m_xAbbrevLB->make_sorted(); + m_xAbbrevLB->set_size_request(-1, m_xAbbrevLB->get_height_rows(6)); + + m_xDoubleCapsLB->make_sorted(); + m_xDoubleCapsLB->set_size_request(-1, m_xDoubleCapsLB->get_height_rows(6)); + + css::lang::Locale aLcl( LanguageTag::convertToLocale(eLastDialogLanguage )); + pCompareClass.reset( new CollatorWrapper( comphelper::getProcessComponentContext() ) ); + pCompareClass->loadDefaultCollator( aLcl, 0 ); + + m_xNewAbbrevPB->connect_clicked(LINK(this, OfaAutocorrExceptPage, NewDelButtonHdl)); + m_xDelAbbrevPB->connect_clicked(LINK(this, OfaAutocorrExceptPage, NewDelButtonHdl)); + m_xNewDoublePB->connect_clicked(LINK(this, OfaAutocorrExceptPage, NewDelButtonHdl)); + m_xDelDoublePB->connect_clicked(LINK(this, OfaAutocorrExceptPage, NewDelButtonHdl)); + + m_xAbbrevLB->connect_changed(LINK(this, OfaAutocorrExceptPage, SelectHdl)); + m_xDoubleCapsLB->connect_changed(LINK(this, OfaAutocorrExceptPage, SelectHdl)); + m_xAbbrevED->connect_changed(LINK(this, OfaAutocorrExceptPage, ModifyHdl)); + m_xDoubleCapsED->connect_changed(LINK(this, OfaAutocorrExceptPage, ModifyHdl)); + + m_xAbbrevED->connect_activate(LINK(this, OfaAutocorrExceptPage, NewDelActionHdl)); + m_xDoubleCapsED->connect_activate(LINK(this, OfaAutocorrExceptPage, NewDelActionHdl)); +} + +OfaAutocorrExceptPage::~OfaAutocorrExceptPage() +{ + aStringsTable.clear(); + pCompareClass.reset(); +} + +std::unique_ptr<SfxTabPage> OfaAutocorrExceptPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rSet) +{ + return std::make_unique<OfaAutocorrExceptPage>(pPage, pController, *rSet); +} + +void OfaAutocorrExceptPage::ActivatePage( const SfxItemSet& ) +{ + if(eLang != eLastDialogLanguage) + SetLanguage(eLastDialogLanguage); + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage(true); +} + +DeactivateRC OfaAutocorrExceptPage::DeactivatePage( SfxItemSet* ) +{ + return DeactivateRC::LeavePage; +} + +bool OfaAutocorrExceptPage::FillItemSet( SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + for(StringsTable::reverse_iterator it1 = aStringsTable.rbegin(); it1 != aStringsTable.rend(); ++it1) + { + LanguageType eCurLang = it1->first; + StringsArrays& rArrays = it1->second; + if(eCurLang != eLang) // current language is treated later + { + SvStringsISortDtor* pWrdList = pAutoCorrect->LoadWordStartExceptList(eCurLang); + + if(pWrdList) + { + size_t nCount = pWrdList->size(); + size_t i; + for( i = nCount; i; ) + { + OUString aString = (*pWrdList)[ --i ]; + + if( !lcl_FindInArray(rArrays.aDoubleCapsStrings, aString)) + { + pWrdList->erase_at(i); + } + } + + for (auto const& elem : rArrays.aDoubleCapsStrings) + { + pWrdList->insert(elem); + } + pAutoCorrect->SaveWordStartExceptList(eCurLang); + } + + SvStringsISortDtor* pCplList = pAutoCorrect->LoadCplSttExceptList(eCurLang); + + if(pCplList) + { + size_t nCount = pCplList->size(); + size_t i; + for( i = nCount; i; ) + { + OUString aString = (*pCplList)[ --i ]; + if( !lcl_FindInArray(rArrays.aAbbrevStrings, aString)) + { + pCplList->erase_at(i); + } + } + + for (auto const& elem : rArrays.aAbbrevStrings) + { + pCplList->insert(elem); + } + + pAutoCorrect->SaveCplSttExceptList(eCurLang); + } + } + } + aStringsTable.clear(); + + SvStringsISortDtor* pWrdList = pAutoCorrect->LoadWordStartExceptList(eLang); + + if(pWrdList) + { + size_t nCount = pWrdList->size(); + size_t i; + for( i = nCount; i; ) + { + OUString aString = (*pWrdList)[ --i ]; + if (m_xDoubleCapsLB->find_text(aString) == -1) + { + pWrdList->erase_at(i); + } + } + nCount = m_xDoubleCapsLB->n_children(); + for( i = 0; i < nCount; ++i ) + { + pWrdList->insert(m_xDoubleCapsLB->get_text(i)); + } + pAutoCorrect->SaveWordStartExceptList(eLang); + } + + SvStringsISortDtor* pCplList = pAutoCorrect->LoadCplSttExceptList(eLang); + + if(pCplList) + { + size_t nCount = pCplList->size(); + for( size_t i = nCount; i; ) + { + OUString aString = (*pCplList)[ --i ]; + if (m_xAbbrevLB->find_text(aString) == -1) + { + pCplList->erase_at(i); + } + } + sal_Int32 nAbbrevCount = m_xAbbrevLB->n_children(); + for( sal_Int32 ia = 0; ia < nAbbrevCount; ++ia ) + { + pCplList->insert(m_xAbbrevLB->get_text(ia)); + } + pAutoCorrect->SaveCplSttExceptList(eLang); + } + if (m_xAutoAbbrevCB->get_state_changed_from_saved()) + pAutoCorrect->SetAutoCorrFlag( ACFlags::SaveWordCplSttLst, m_xAutoAbbrevCB->get_active()); + if (m_xAutoCapsCB->get_state_changed_from_saved()) + pAutoCorrect->SetAutoCorrFlag( ACFlags::SaveWordWordStartLst, m_xAutoCapsCB->get_active()); + return false; +} + +void OfaAutocorrExceptPage::SetLanguage(LanguageType eSet) +{ + if(eLang != eSet) + { + // save old settings and fill anew + RefillReplaceBoxes(false, eLang, eSet); + eLastDialogLanguage = eSet; + pCompareClass.reset( new CollatorWrapper( comphelper::getProcessComponentContext() ) ); + pCompareClass->loadDefaultCollator( LanguageTag::convertToLocale( eLastDialogLanguage ), 0 ); + ModifyHdl(*m_xAbbrevED); + ModifyHdl(*m_xDoubleCapsED); + } +} + +void OfaAutocorrExceptPage::RefillReplaceBoxes(bool bFromReset, + LanguageType eOldLanguage, + LanguageType eNewLanguage) +{ + eLang = eNewLanguage; + if(bFromReset) + { + aStringsTable.clear(); + } + else + { + StringsArrays* pArrays; + if(aStringsTable.find(eOldLanguage) != aStringsTable.end()) + { + pArrays = &aStringsTable[eOldLanguage]; + pArrays->aAbbrevStrings.clear(); + pArrays->aDoubleCapsStrings.clear(); + } + else + { + pArrays = &aStringsTable[eOldLanguage]; // create new array + } + + sal_Int32 i, nCount; + nCount = m_xAbbrevLB->n_children(); + for(i = 0; i < nCount; i++) + pArrays->aAbbrevStrings.push_back(m_xAbbrevLB->get_text(i)); + + nCount = m_xDoubleCapsLB->n_children(); + for(i = 0; i < nCount; i++) + pArrays->aDoubleCapsStrings.push_back(m_xDoubleCapsLB->get_text(i)); + } + m_xDoubleCapsLB->clear(); + m_xAbbrevLB->clear(); + m_xAbbrevED->set_text(""); + m_xDoubleCapsED->set_text(""); + + if(aStringsTable.find(eLang) != aStringsTable.end()) + { + StringsArrays& rArrays = aStringsTable[eLang]; + for (auto const& elem : rArrays.aAbbrevStrings) + m_xAbbrevLB->append_text(elem); + + for (auto const& elem : rArrays.aDoubleCapsStrings) + m_xDoubleCapsLB->append_text(elem); + } + else + { + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + const SvStringsISortDtor* pCplList = pAutoCorrect->GetCplSttExceptList(eLang); + const SvStringsISortDtor* pWrdList = pAutoCorrect->GetWordStartExceptList(eLang); + size_t i; + for( i = 0; i < pCplList->size(); i++ ) + { + m_xAbbrevLB->append_text((*pCplList)[i]); + } + for( i = 0; i < pWrdList->size(); i++ ) + { + m_xDoubleCapsLB->append_text((*pWrdList)[i]); + } + } +} + +void OfaAutocorrExceptPage::Reset( const SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + RefillReplaceBoxes(true, eLang, eLang); + m_xAutoAbbrevCB->set_active(pAutoCorrect->IsAutoCorrFlag( ACFlags::SaveWordCplSttLst)); + m_xAutoCapsCB->set_active(pAutoCorrect->IsAutoCorrFlag( ACFlags::SaveWordWordStartLst)); + m_xAutoAbbrevCB->save_state(); + m_xAutoCapsCB->save_state(); +} + +IMPL_LINK(OfaAutocorrExceptPage, NewDelButtonHdl, weld::Button&, rBtn, void) +{ + NewDelHdl(&rBtn); +} + +IMPL_LINK(OfaAutocorrExceptPage, NewDelActionHdl, weld::Entry&, rEdit, bool) +{ + return NewDelHdl(&rEdit); +} + +bool OfaAutocorrExceptPage::NewDelHdl(const weld::Widget* pBtn) +{ + if ((pBtn == m_xNewAbbrevPB.get() || pBtn == m_xAbbrevED.get()) + && !m_xAbbrevED->get_text().isEmpty() && m_xNewAbbrevPB->get_sensitive()) + { + m_xAbbrevLB->append_text(m_xAbbrevED->get_text()); + ModifyHdl(*m_xAbbrevED); + } + else if(pBtn == m_xDelAbbrevPB.get()) + { + m_xAbbrevLB->remove_text(m_xAbbrevED->get_text()); + ModifyHdl(*m_xAbbrevED); + } + else if((pBtn == m_xNewDoublePB.get() || pBtn == m_xDoubleCapsED.get() ) + && !m_xDoubleCapsED->get_text().isEmpty() && m_xNewDoublePB->get_sensitive()) + { + m_xDoubleCapsLB->append_text(m_xDoubleCapsED->get_text()); + ModifyHdl(*m_xDoubleCapsED); + } + else if (pBtn == m_xDelDoublePB.get()) + { + m_xDoubleCapsLB->remove_text(m_xDoubleCapsED->get_text()); + ModifyHdl(*m_xDoubleCapsED); + } + else + { + // we didn't do anything, if this was because of 'activate' in an + // entry then let it continue to close the dialog like the replace + // page does + return false; + } + return true; +} + +IMPL_LINK(OfaAutocorrExceptPage, SelectHdl, weld::TreeView&, rBox, void) +{ + if (&rBox == m_xAbbrevLB.get()) + { + m_xAbbrevED->set_text(rBox.get_selected_text()); + m_xNewAbbrevPB->set_sensitive(false); + m_xDelAbbrevPB->set_sensitive(true); + } + else + { + m_xDoubleCapsED->set_text(rBox.get_selected_text()); + m_xNewDoublePB->set_sensitive(false); + m_xDelDoublePB->set_sensitive(true); + } +} + +IMPL_LINK(OfaAutocorrExceptPage, ModifyHdl, weld::Entry&, rEdt, void) +{ + const OUString& sEntry = rEdt.get_text(); + bool bEntryLen = !sEntry.isEmpty(); + if (&rEdt == m_xAbbrevED.get()) + { + bool bSame = lcl_FindEntry(*m_xAbbrevLB, sEntry, *pCompareClass); + if(bSame && sEntry != m_xAbbrevLB->get_selected_text()) + rEdt.set_text(m_xAbbrevLB->get_selected_text()); + m_xNewAbbrevPB->set_sensitive(!bSame && bEntryLen); + m_xDelAbbrevPB->set_sensitive(bSame && bEntryLen); + } + else + { + bool bSame = lcl_FindEntry(*m_xDoubleCapsLB, sEntry, *pCompareClass); + if(bSame && sEntry != m_xDoubleCapsLB->get_selected_text()) + rEdt.set_text(m_xDoubleCapsLB->get_selected_text()); + m_xNewDoublePB->set_sensitive(!bSame && bEntryLen); + m_xDelDoublePB->set_sensitive(bSame && bEntryLen); + } +} + +namespace { + +enum OfaQuoteOptions +{ + ADD_NONBRK_SPACE, + REPLACE_1ST, + TRANSLITERATE_RTL, + REPLACE_ANGLE_QUOTES +}; + +} + +void OfaQuoteTabPage::CreateEntry(weld::TreeView& rCheckLB, const OUString& rTxt, sal_uInt16 nCol, sal_uInt16 nTextCol) +{ + rCheckLB.append(); + const int nRow = rCheckLB.n_children() - 1; + if (nCol == CBCOL_FIRST || nCol == CBCOL_BOTH) + rCheckLB.set_toggle(nRow, TRISTATE_FALSE, CBCOL_FIRST); + if (nCol == CBCOL_SECOND || nCol == CBCOL_BOTH) + rCheckLB.set_toggle(nRow, TRISTATE_FALSE, CBCOL_SECOND); + rCheckLB.set_text(nRow, rTxt, nTextCol); +} + +OfaQuoteTabPage::OfaQuoteTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/applylocalizedpage.ui", "ApplyLocalizedPage", &rSet) + , sNonBrkSpace(CuiResId(RID_CUISTR_NON_BREAK_SPACE)) + , sOrdinal(CuiResId(RID_CUISTR_ORDINAL)) + , sTransliterateRTL(CuiResId(RID_CUISTR_OLD_HUNGARIAN)) + , sAngleQuotes(CuiResId(RID_CUISTR_ANGLE_QUOTES)) + , cSglStartQuote(0) + , cSglEndQuote(0) + , cStartQuote(0) + , cEndQuote(0) + , m_xSingleTypoCB(m_xBuilder->weld_check_button("singlereplace")) + , m_xSglStartQuotePB(m_xBuilder->weld_button("startsingle")) + , m_xSglStartExFT(m_xBuilder->weld_label("singlestartex")) + , m_xSglEndQuotePB(m_xBuilder->weld_button("endsingle")) + , m_xSglEndExFT(m_xBuilder->weld_label("singleendex")) + , m_xSglStandardPB(m_xBuilder->weld_button("defaultsingle")) + , m_xDoubleTypoCB(m_xBuilder->weld_check_button("doublereplace")) + , m_xDblStartQuotePB(m_xBuilder->weld_button("startdouble")) + , m_xDblStartExFT(m_xBuilder->weld_label("doublestartex")) + , m_xDblEndQuotePB(m_xBuilder->weld_button("enddouble")) + , m_xDblEndExFT(m_xBuilder->weld_label("doubleendex")) + , m_xDblStandardPB(m_xBuilder->weld_button("defaultdouble")) + , m_sStandard(m_xSglStartExFT->get_label()) + , m_xCheckLB(m_xBuilder->weld_tree_view("checklist")) + , m_xSwCheckLB(m_xBuilder->weld_tree_view("list")) +{ + m_xSwCheckLB->set_size_request(m_xSwCheckLB->get_approximate_digit_width() * 50, + m_xSwCheckLB->get_height_rows(6)); + + bool bShowSWOptions = false; + + const SfxBoolItem* pItem = rSet.GetItem<SfxBoolItem>(SID_AUTO_CORRECT_DLG, false); + if ( pItem && pItem->GetValue() ) + bShowSWOptions = true; + + if ( bShowSWOptions ) + { + m_xSwCheckLB->enable_toggle_buttons(weld::ColumnToggleType::Check); + std::vector<int> aWidths + { + o3tl::narrowing<int>(m_xSwCheckLB->get_pixel_size(m_xSwCheckLB->get_column_title(0)).Width() * 2), + o3tl::narrowing<int>(m_xSwCheckLB->get_pixel_size(m_xSwCheckLB->get_column_title(1)).Width() * 2) + }; + m_xSwCheckLB->set_column_fixed_widths(aWidths); + m_xCheckLB->hide(); + } + else + { + m_xCheckLB->enable_toggle_buttons(weld::ColumnToggleType::Check); + m_xSwCheckLB->hide(); + } + + m_xDblStartQuotePB->connect_clicked(LINK(this, OfaQuoteTabPage, QuoteHdl)); + m_xDblEndQuotePB->connect_clicked(LINK(this, OfaQuoteTabPage, QuoteHdl)); + m_xSglStartQuotePB->connect_clicked(LINK(this, OfaQuoteTabPage, QuoteHdl)); + m_xSglEndQuotePB->connect_clicked(LINK(this, OfaQuoteTabPage, QuoteHdl)); + m_xDblStandardPB->connect_clicked(LINK(this, OfaQuoteTabPage, StdQuoteHdl)); + m_xSglStandardPB->connect_clicked(LINK(this, OfaQuoteTabPage, StdQuoteHdl)); +} + +OfaQuoteTabPage::~OfaQuoteTabPage() +{ +} + +std::unique_ptr<SfxTabPage> OfaQuoteTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<OfaQuoteTabPage>(pPage, pController, *rAttrSet); +} + +bool OfaQuoteTabPage::FillItemSet( SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + + ACFlags nFlags = pAutoCorrect->GetFlags(); + + if (m_xCheckLB->get_visible()) + { + int nPos = 0; + pAutoCorrect->SetAutoCorrFlag(ACFlags::AddNonBrkSpace, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgOrdinalNumber, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::TransliterateRTL, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgAngleQuotes, m_xCheckLB->get_toggle(nPos++) == TRISTATE_TRUE); + } + + bool bModified = false; + if (m_xSwCheckLB->get_visible()) + { + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + + bool bCheck = m_xSwCheckLB->get_toggle(ADD_NONBRK_SPACE, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bAddNonBrkSpace != bCheck; + pOpt->bAddNonBrkSpace = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::AddNonBrkSpace, + m_xSwCheckLB->get_toggle(ADD_NONBRK_SPACE, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xSwCheckLB->get_toggle(REPLACE_1ST, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bChgOrdinalNumber != bCheck; + pOpt->bChgOrdinalNumber = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgOrdinalNumber, + m_xSwCheckLB->get_toggle(REPLACE_1ST, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xSwCheckLB->get_toggle(TRANSLITERATE_RTL, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bTransliterateRTL != bCheck; + pOpt->bTransliterateRTL = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::TransliterateRTL, + m_xSwCheckLB->get_toggle(TRANSLITERATE_RTL, CBCOL_SECOND) == TRISTATE_TRUE); + + bCheck = m_xSwCheckLB->get_toggle(REPLACE_ANGLE_QUOTES, CBCOL_FIRST) == TRISTATE_TRUE; + bModified |= pOpt->bChgAngleQuotes != bCheck; + pOpt->bChgAngleQuotes = bCheck; + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgAngleQuotes, + m_xSwCheckLB->get_toggle(REPLACE_ANGLE_QUOTES, CBCOL_SECOND) == TRISTATE_TRUE); + } + + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgQuotes, m_xDoubleTypoCB->get_active()); + pAutoCorrect->SetAutoCorrFlag(ACFlags::ChgSglQuotes, m_xSingleTypoCB->get_active()); + bool bReturn = nFlags != pAutoCorrect->GetFlags(); + if(cStartQuote != pAutoCorrect->GetStartDoubleQuote()) + { + bReturn = true; + sal_Unicode cUCS2 = static_cast<sal_Unicode>(cStartQuote); //TODO + pAutoCorrect->SetStartDoubleQuote(cUCS2); + } + if(cEndQuote != pAutoCorrect->GetEndDoubleQuote()) + { + bReturn = true; + sal_Unicode cUCS2 = static_cast<sal_Unicode>(cEndQuote); //TODO + pAutoCorrect->SetEndDoubleQuote(cUCS2); + } + if(cSglStartQuote != pAutoCorrect->GetStartSingleQuote()) + { + bReturn = true; + sal_Unicode cUCS2 = static_cast<sal_Unicode>(cSglStartQuote); //TODO + pAutoCorrect->SetStartSingleQuote(cUCS2); + } + if(cSglEndQuote != pAutoCorrect->GetEndSingleQuote()) + { + bReturn = true; + sal_Unicode cUCS2 = static_cast<sal_Unicode>(cSglEndQuote); //TODO + pAutoCorrect->SetEndSingleQuote(cUCS2); + } + + if( bModified || bReturn ) + { + SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get(); + rCfg.SetModified(); + rCfg.Commit(); + } + return bReturn; +} + +void OfaQuoteTabPage::ActivatePage( const SfxItemSet& ) +{ + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage(false); +} + +void OfaQuoteTabPage::Reset( const SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + const ACFlags nFlags = pAutoCorrect->GetFlags(); + + // Initialize the Sw options + if (m_xSwCheckLB->get_visible()) + { + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + + m_xSwCheckLB->freeze(); + m_xSwCheckLB->clear(); + + CreateEntry(*m_xSwCheckLB, sNonBrkSpace, CBCOL_BOTH, 2); + CreateEntry(*m_xSwCheckLB, sOrdinal, CBCOL_BOTH, 2); + CreateEntry(*m_xSwCheckLB, sTransliterateRTL, CBCOL_BOTH, 2); + CreateEntry(*m_xSwCheckLB, sAngleQuotes, CBCOL_BOTH, 2); + + m_xSwCheckLB->set_toggle(ADD_NONBRK_SPACE, pOpt->bAddNonBrkSpace ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xSwCheckLB->set_toggle(ADD_NONBRK_SPACE, bool(nFlags & ACFlags::AddNonBrkSpace) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xSwCheckLB->set_toggle(REPLACE_1ST, pOpt->bChgOrdinalNumber ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xSwCheckLB->set_toggle(REPLACE_1ST, bool(nFlags & ACFlags::ChgOrdinalNumber) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xSwCheckLB->set_toggle(TRANSLITERATE_RTL, pOpt->bTransliterateRTL ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xSwCheckLB->set_toggle(TRANSLITERATE_RTL, bool(nFlags & ACFlags::TransliterateRTL) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + m_xSwCheckLB->set_toggle(REPLACE_ANGLE_QUOTES, pOpt->bChgAngleQuotes ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_FIRST); + m_xSwCheckLB->set_toggle(REPLACE_ANGLE_QUOTES, bool(nFlags & ACFlags::ChgAngleQuotes) ? TRISTATE_TRUE : TRISTATE_FALSE, CBCOL_SECOND); + + m_xSwCheckLB->thaw(); + } + + // Initialize the non Sw options + if (m_xCheckLB->get_visible()) + { + m_xCheckLB->freeze(); + m_xCheckLB->clear(); + + int nPos = 0; + m_xCheckLB->append(); + m_xCheckLB->set_toggle(nPos, bool(nFlags & ACFlags::AddNonBrkSpace) ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xCheckLB->set_text(nPos++, sNonBrkSpace, 0); + m_xCheckLB->append(); + m_xCheckLB->set_toggle(nPos, bool(nFlags & ACFlags::ChgOrdinalNumber) ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xCheckLB->set_text(nPos++, sOrdinal, 0); + m_xCheckLB->append(); + m_xCheckLB->set_toggle(nPos, bool(nFlags & ACFlags::TransliterateRTL) ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xCheckLB->set_text(nPos++, sTransliterateRTL, 0); + m_xCheckLB->append(); + m_xCheckLB->set_toggle(nPos, bool(nFlags & ACFlags::ChgAngleQuotes) ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xCheckLB->set_text(nPos++, sAngleQuotes, 0); + + m_xCheckLB->thaw(); + } + + // Initialize the quote stuffs + m_xDoubleTypoCB->set_active(bool(nFlags & ACFlags::ChgQuotes)); + m_xSingleTypoCB->set_active(bool(nFlags & ACFlags::ChgSglQuotes)); + m_xDoubleTypoCB->save_state(); + m_xSingleTypoCB->save_state(); + + cStartQuote = pAutoCorrect->GetStartDoubleQuote(); + cEndQuote = pAutoCorrect->GetEndDoubleQuote(); + cSglStartQuote = pAutoCorrect->GetStartSingleQuote(); + cSglEndQuote = pAutoCorrect->GetEndSingleQuote(); + + m_xSglStartExFT->set_label(ChangeStringExt_Impl(cSglStartQuote)); + m_xSglEndExFT->set_label(ChangeStringExt_Impl(cSglEndQuote)); + m_xDblStartExFT->set_label(ChangeStringExt_Impl(cStartQuote)); + m_xDblEndExFT->set_label(ChangeStringExt_Impl(cEndQuote)); +} + +#define SGL_START 0 +#define DBL_START 1 +#define SGL_END 2 +#define DBL_END 3 + + +IMPL_LINK(OfaQuoteTabPage, QuoteHdl, weld::Button&, rBtn, void) +{ + sal_uInt16 nMode = SGL_START; + if (&rBtn == m_xSglEndQuotePB.get()) + nMode = SGL_END; + else if (&rBtn == m_xDblStartQuotePB.get()) + nMode = DBL_START; + else if (&rBtn == m_xDblEndQuotePB.get()) + nMode = DBL_END; + // start character selection dialog + SvxCharacterMap aMap(GetFrameWeld(), nullptr, nullptr); + aMap.SetCharFont( OutputDevice::GetDefaultFont(DefaultFontType::LATIN_TEXT, + LANGUAGE_ENGLISH_US, GetDefaultFontFlags::OnlyOne )); + aMap.set_title(nMode < SGL_END ? CuiResId(RID_CUISTR_STARTQUOTE) : CuiResId(RID_CUISTR_ENDQUOTE)); + sal_UCS4 cDlg; + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + LanguageType eLang = Application::GetSettings().GetLanguageTag().getLanguageType(); + switch( nMode ) + { + case SGL_START: + cDlg = cSglStartQuote; + if(cDlg == 0) + cDlg = pAutoCorrect->GetQuote('\'', true, eLang); + break; + case SGL_END: + cDlg = cSglEndQuote; + if(cDlg == 0) + cDlg = pAutoCorrect->GetQuote('\'', false, eLang); + break; + case DBL_START: + cDlg = cStartQuote; + if(cDlg == 0) + cDlg = pAutoCorrect->GetQuote('\"', true, eLang); + break; + case DBL_END: + cDlg = cEndQuote; + if(cDlg == 0) + cDlg = pAutoCorrect->GetQuote('\"', false, eLang); + break; + default: + OSL_FAIL("svx::OfaQuoteTabPage::QuoteHdl(), how to initialize cDlg?" ); + cDlg = 0; + break; + + } + aMap.SetChar( cDlg ); + aMap.DisableFontSelection(); + if (aMap.run() != RET_OK) + return; + + sal_UCS4 cNewChar = aMap.GetChar(); + switch( nMode ) + { + case SGL_START: + cSglStartQuote = cNewChar; + m_xSglStartExFT->set_label(ChangeStringExt_Impl(cNewChar)); + break; + case SGL_END: + cSglEndQuote = cNewChar; + m_xSglEndExFT->set_label(ChangeStringExt_Impl(cNewChar)); + break; + case DBL_START: + cStartQuote = cNewChar; + m_xDblStartExFT->set_label(ChangeStringExt_Impl(cNewChar)); + break; + case DBL_END: + cEndQuote = cNewChar; + m_xDblEndExFT->set_label(ChangeStringExt_Impl(cNewChar)); + break; + } +} + +IMPL_LINK(OfaQuoteTabPage, StdQuoteHdl, weld::Button&, rBtn, void) +{ + if (&rBtn == m_xDblStandardPB.get()) + { + cStartQuote = 0; + m_xDblStartExFT->set_label(ChangeStringExt_Impl(0)); + cEndQuote = 0; + m_xDblEndExFT->set_label(ChangeStringExt_Impl(0)); + + } + else + { + cSglStartQuote = 0; + m_xSglStartExFT->set_label(ChangeStringExt_Impl(0)); + cSglEndQuote = 0; + m_xSglEndExFT->set_label(ChangeStringExt_Impl(0)); + } +} + +OUString OfaQuoteTabPage::ChangeStringExt_Impl( sal_UCS4 cChar ) +{ + if (!cChar) + return m_sStandard; + + // convert codepoint value to unicode-hex string + sal_UCS4 aStrCodes[32] = { 0, ' ', '(', 'U', '+', '0' }; + aStrCodes[0] = cChar; + int nFullLen = 5; + int nHexLen = 4; + while( (cChar >> (4*nHexLen)) != 0 ) + ++nHexLen; + for( int i = nHexLen; --i >= 0;) + { + sal_UCS4 cHexDigit = ((cChar >> (4*i)) & 0x0f) + '0'; + if( cHexDigit > '9' ) + cHexDigit += 'A' - ('9' + 1); + aStrCodes[ nFullLen++ ] = cHexDigit; + } + aStrCodes[ nFullLen++ ] = ')'; + // using the new UCS4 constructor + OUString aOUStr( aStrCodes, nFullLen ); + return aOUStr; +} + +OfaAutoCompleteTabPage::OfaAutoCompleteTabPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/wordcompletionpage.ui", + "WordCompletionPage", &rSet) + , m_pAutoCompleteList(nullptr) + , m_nAutoCmpltListCnt(0) + , m_xCBActiv(m_xBuilder->weld_check_button("enablewordcomplete")) + , m_xCBAppendSpace(m_xBuilder->weld_check_button("appendspace")) + , m_xCBAsTip(m_xBuilder->weld_check_button("showastip")) + , m_xCBCollect(m_xBuilder->weld_check_button("collectwords")) + , m_xCBRemoveList(m_xBuilder->weld_check_button("whenclosing")) + , m_xDCBExpandKey(m_xBuilder->weld_combo_box("acceptwith")) + , m_xNFMinWordlen(m_xBuilder->weld_spin_button("minwordlen")) + , m_xNFMaxEntries(m_xBuilder->weld_spin_button("maxentries")) + , m_xLBEntries(m_xBuilder->weld_tree_view("entries")) + , m_xPBEntries(m_xBuilder->weld_button("delete")) +{ + //fdo#65595, we need height-for-width support here, but for now we can + //bodge it + Size aPrefSize(m_xCBRemoveList->get_preferred_size()); + int nMaxWidth = m_xCBRemoveList->get_approximate_digit_width() * 40; + if (aPrefSize.Width() > nMaxWidth) + { + m_xCBRemoveList->set_label_wrap(true); + m_xCBRemoveList->set_size_request(nMaxWidth, -1); + } + + m_xLBEntries->set_size_request(m_xLBEntries->get_approximate_digit_width() * 30, + m_xLBEntries->get_height_rows(10)); + m_xLBEntries->set_selection_mode(SelectionMode::Multiple); + + // the defined KEYs + static const sal_uInt16 aKeyCodes[] = { + KEY_END, + KEY_RETURN, + KEY_SPACE, + KEY_RIGHT, + KEY_TAB, + 0 + }; + + for( const sal_uInt16* pKeys = aKeyCodes; *pKeys; ++pKeys ) + { + vcl::KeyCode aKCode(*pKeys); + m_xDCBExpandKey->append(OUString::number(static_cast<sal_Int32>(*pKeys)), aKCode.GetName()); + if (KEY_RETURN == *pKeys) // default to RETURN + m_xDCBExpandKey->set_active(std::distance(aKeyCodes, pKeys)); + } + + m_xPBEntries->connect_clicked(LINK(this, OfaAutoCompleteTabPage, DeleteHdl)); + m_xCBActiv->connect_toggled(LINK(this, OfaAutoCompleteTabPage, CheckHdl)); + m_xCBCollect->connect_toggled(LINK(this, OfaAutoCompleteTabPage, CheckHdl)); + m_xLBEntries->connect_key_release(LINK(this, OfaAutoCompleteTabPage, KeyReleaseHdl)); +} + +OfaAutoCompleteTabPage::~OfaAutoCompleteTabPage() +{ +} + +std::unique_ptr<SfxTabPage> OfaAutoCompleteTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rSet) +{ + return std::make_unique<OfaAutoCompleteTabPage>(pPage, pController, *rSet); +} + +bool OfaAutoCompleteTabPage::FillItemSet( SfxItemSet* ) +{ + bool bModified = false, bCheck; + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + sal_uInt16 nVal; + + bCheck = m_xCBActiv->get_active(); + bModified |= pOpt->bAutoCompleteWords != bCheck; + pOpt->bAutoCompleteWords = bCheck; + bCheck = m_xCBCollect->get_active(); + bModified |= pOpt->bAutoCmpltCollectWords != bCheck; + pOpt->bAutoCmpltCollectWords = bCheck; + bCheck = !m_xCBRemoveList->get_active(); // inverted value! + bModified |= pOpt->bAutoCmpltKeepList != bCheck; + pOpt->bAutoCmpltKeepList = bCheck; + bCheck = m_xCBAppendSpace->get_active(); + bModified |= pOpt->bAutoCmpltAppendBlank != bCheck; + pOpt->bAutoCmpltAppendBlank = bCheck; + bCheck = m_xCBAsTip->get_active(); + bModified |= pOpt->bAutoCmpltShowAsTip != bCheck; + pOpt->bAutoCmpltShowAsTip = bCheck; + + nVal = static_cast<sal_uInt16>(m_xNFMinWordlen->get_value()); + bModified |= nVal != pOpt->nAutoCmpltWordLen; + pOpt->nAutoCmpltWordLen = nVal; + + nVal = static_cast<sal_uInt16>(m_xNFMaxEntries->get_value()); + bModified |= nVal != pOpt->nAutoCmpltListLen; + pOpt->nAutoCmpltListLen = nVal; + + const int nPos = m_xDCBExpandKey->get_active(); + if (nPos != -1) + { + sal_Int32 nKey = m_xDCBExpandKey->get_id(nPos).toInt32(); + bModified |= nKey != pOpt->nAutoCmpltExpandKey; + pOpt->nAutoCmpltExpandKey = static_cast<sal_uInt16>(nKey); + } + + if (m_pAutoCompleteList && m_nAutoCmpltListCnt != m_xLBEntries->n_children()) + { + bModified = true; + pOpt->m_pAutoCompleteList = m_pAutoCompleteList; + } + if( bModified ) + { + SvxAutoCorrCfg& rCfg = SvxAutoCorrCfg::Get(); + rCfg.SetModified(); + rCfg.Commit(); + } + return true; +} + +void OfaAutoCompleteTabPage::Reset( const SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + + m_xCBActiv->set_active( pOpt->bAutoCompleteWords ); + m_xCBCollect->set_active( pOpt->bAutoCmpltCollectWords ); + m_xCBRemoveList->set_active( !pOpt->bAutoCmpltKeepList ); //inverted value! + m_xCBAppendSpace->set_active( pOpt->bAutoCmpltAppendBlank ); + m_xCBAsTip->set_active( pOpt->bAutoCmpltShowAsTip ); + + m_xNFMinWordlen->set_value( pOpt->nAutoCmpltWordLen ); + m_xNFMaxEntries->set_value( pOpt->nAutoCmpltListLen ); + + // select the specific KeyCode: + { + sal_Int32 nKey = pOpt->nAutoCmpltExpandKey; + for (int n = 0, nCnt = m_xDCBExpandKey->get_count(); n < nCnt; ++n) + { + if (nKey == m_xDCBExpandKey->get_id(n).toInt32()) + { + m_xDCBExpandKey->set_active(n); + break; + } + } + } + + if (pOpt->m_pAutoCompleteList && !pOpt->m_pAutoCompleteList->empty()) + { + m_pAutoCompleteList = const_cast<editeng::SortedAutoCompleteStrings*>( + pOpt->m_pAutoCompleteList); + pOpt->m_pAutoCompleteList = nullptr; + m_nAutoCmpltListCnt = m_pAutoCompleteList->size(); + for (size_t n = 0; n < m_nAutoCmpltListCnt; ++n) + { + const OUString* pStr = + &(*m_pAutoCompleteList)[n]->GetAutoCompleteString(); + OUString sId(weld::toId(pStr)); + m_xLBEntries->append(sId, *pStr); + } + } + else + { + m_xLBEntries->set_sensitive(false); + m_xPBEntries->set_sensitive(false); + } + + CheckHdl(*m_xCBActiv); + CheckHdl(*m_xCBCollect); +} + +void OfaAutoCompleteTabPage::ActivatePage( const SfxItemSet& ) +{ + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage( false ); +} + +IMPL_LINK_NOARG(OfaAutoCompleteTabPage, DeleteHdl, weld::Button&, void) +{ + auto rows = m_xLBEntries->get_selected_rows(); + std::sort(rows.begin(), rows.end()); + while (!rows.empty()) + { + sal_Int32 nPos = rows.back(); + OUString* pStr = weld::fromId<OUString*>(m_xLBEntries->get_id(nPos)); + m_xLBEntries->remove(nPos); + editeng::IAutoCompleteString hack(*pStr); // UGLY + m_pAutoCompleteList->erase(&hack); + rows.pop_back(); + } +} + +IMPL_LINK(OfaAutoCompleteTabPage, CheckHdl, weld::Toggleable&, rBox, void) +{ + bool bEnable = rBox.get_active(); + if (&rBox == m_xCBActiv.get()) + { + m_xCBAppendSpace->set_sensitive(bEnable); + m_xCBAppendSpace->set_sensitive(bEnable); + m_xCBAsTip->set_sensitive(bEnable); + m_xDCBExpandKey->set_sensitive(bEnable); + } + else if (&rBox == m_xCBCollect.get()) + m_xCBRemoveList->set_sensitive(bEnable); +} + +void OfaAutoCompleteTabPage::CopyToClipboard() const +{ + auto rows = m_xLBEntries->get_selected_rows(); + if (!m_pAutoCompleteList || rows.empty()) + return; + + rtl::Reference<TransferDataContainer> pCntnr = new TransferDataContainer; + + OStringBuffer sData; + + rtl_TextEncoding nEncode = osl_getThreadTextEncoding(); + + for (auto a : rows) + { + sData.append(OUStringToOString(m_xLBEntries->get_text(a), nEncode)); +#if defined(_WIN32) + sData.append("\015\012"); +#else + sData.append("\012"); +#endif + } + pCntnr->CopyByteString( SotClipboardFormatId::STRING, sData.makeStringAndClear() ); + pCntnr->CopyToClipboard(m_xLBEntries->get_clipboard()); +} + +IMPL_LINK(OfaAutoCompleteTabPage, KeyReleaseHdl, const KeyEvent&, rEvent, bool) +{ + bool bHandled = false; + const vcl::KeyCode& rKeyCode = rEvent.GetKeyCode(); + switch (rKeyCode.GetModifier() | rKeyCode.GetCode()) + { + case KEY_DELETE: + DeleteHdl(*m_xPBEntries); + bHandled = true; + break; + default: + if (KeyFuncType::COPY == rKeyCode.GetFunction()) + { + CopyToClipboard(); + bHandled = true; + } + break; + } + return bHandled; +} + +// class OfaSmartTagOptionsTabPage --------------------------------------------- + +OfaSmartTagOptionsTabPage::OfaSmartTagOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rSet ) + : SfxTabPage(pPage, pController, "cui/ui/smarttagoptionspage.ui", "SmartTagOptionsPage", &rSet) + , m_xMainCB(m_xBuilder->weld_check_button("main")) + , m_xSmartTagTypesLB(m_xBuilder->weld_tree_view("list")) + , m_xPropertiesPB(m_xBuilder->weld_button("properties")) +{ + m_xSmartTagTypesLB->set_size_request(m_xSmartTagTypesLB->get_approximate_digit_width() * 50, + m_xSmartTagTypesLB->get_height_rows(6)); + + m_xSmartTagTypesLB->enable_toggle_buttons(weld::ColumnToggleType::Check); + + // set the handlers: + m_xMainCB->connect_toggled(LINK(this, OfaSmartTagOptionsTabPage, CheckHdl)); + m_xPropertiesPB->connect_clicked(LINK(this, OfaSmartTagOptionsTabPage, ClickHdl)); + m_xSmartTagTypesLB->connect_changed(LINK(this, OfaSmartTagOptionsTabPage, SelectHdl)); +} + +OfaSmartTagOptionsTabPage::~OfaSmartTagOptionsTabPage() +{ +} + +std::unique_ptr<SfxTabPage> OfaSmartTagOptionsTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<OfaSmartTagOptionsTabPage>(pPage, pController, *rSet); +} + +namespace { + +/** This struct is used to associate list box entries with smart tag data +*/ +struct ImplSmartTagLBUserData +{ + OUString maSmartTagType; + uno::Reference< smarttags::XSmartTagRecognizer > mxRec; + sal_Int32 mnSmartTagIdx; + + ImplSmartTagLBUserData( OUString aSmartTagType, + uno::Reference< smarttags::XSmartTagRecognizer > xRec, + sal_Int32 nSmartTagIdx ) : + maSmartTagType(std::move( aSmartTagType )), + mxRec(std::move( xRec )), + mnSmartTagIdx( nSmartTagIdx ) {} +}; + +} + +/** Clears m_xSmartTagTypesLB +*/ +void OfaSmartTagOptionsTabPage::ClearListBox() +{ + const int nCount = m_xSmartTagTypesLB->n_children(); + for (int i = 0; i < nCount; ++i) + { + const ImplSmartTagLBUserData* pUserData = weld::fromId<ImplSmartTagLBUserData*>(m_xSmartTagTypesLB->get_id(i)); + delete pUserData; + } + + m_xSmartTagTypesLB->clear(); +} + +/** Inserts items into m_xSmartTagTypesLB +*/ +void OfaSmartTagOptionsTabPage::FillListBox( const SmartTagMgr& rSmartTagMgr ) +{ + // first we have to clear the list box: + ClearListBox(); + + // fill list box: + const sal_uInt32 nNumberOfRecognizers = rSmartTagMgr.NumberOfRecognizers(); + const lang::Locale aLocale( LanguageTag::convertToLocale( eLastDialogLanguage ) ); + + for ( sal_uInt32 i = 0; i < nNumberOfRecognizers; ++i ) + { + const uno::Reference< smarttags::XSmartTagRecognizer >& xRec = rSmartTagMgr.GetRecognizer(i); + + const OUString aName = xRec->getName( aLocale ); + const sal_Int32 nNumberOfSupportedSmartTags = xRec->getSmartTagCount(); + + for ( sal_Int32 j = 0; j < nNumberOfSupportedSmartTags; ++j ) + { + const OUString aSmartTagType = xRec->getSmartTagName(j); + OUString aSmartTagCaption = rSmartTagMgr.GetSmartTagCaption( aSmartTagType, aLocale ); + + if ( aSmartTagCaption.isEmpty() ) + aSmartTagCaption = aSmartTagType; + + const OUString aLBEntry = aSmartTagCaption + " (" + aName + ")"; + + m_xSmartTagTypesLB->append(); + const int nRow = m_xSmartTagTypesLB->n_children() - 1; + const bool bCheck = rSmartTagMgr.IsSmartTagTypeEnabled( aSmartTagType ); + m_xSmartTagTypesLB->set_toggle(nRow, bCheck ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xSmartTagTypesLB->set_text(nRow, aLBEntry, 0); + m_xSmartTagTypesLB->set_id(nRow, weld::toId(new ImplSmartTagLBUserData(aSmartTagType, xRec, j))); + } + } +} + +/** Handler for the push button +*/ +IMPL_LINK_NOARG(OfaSmartTagOptionsTabPage, ClickHdl, weld::Button&, void) +{ + const int nPos = m_xSmartTagTypesLB->get_selected_index(); + const ImplSmartTagLBUserData* pUserData = weld::fromId<ImplSmartTagLBUserData*>(m_xSmartTagTypesLB->get_id(nPos)); + uno::Reference< smarttags::XSmartTagRecognizer > xRec = pUserData->mxRec; + const sal_Int32 nSmartTagIdx = pUserData->mnSmartTagIdx; + + const lang::Locale aLocale( LanguageTag::convertToLocale( eLastDialogLanguage ) ); + if ( xRec->hasPropertyPage( nSmartTagIdx, aLocale ) ) + xRec->displayPropertyPage( nSmartTagIdx, aLocale ); +} + +/** Handler for the check box +*/ +IMPL_LINK_NOARG(OfaSmartTagOptionsTabPage, CheckHdl, weld::Toggleable&, void) +{ + const bool bEnable = m_xMainCB->get_active(); + m_xSmartTagTypesLB->set_sensitive(bEnable); + m_xPropertiesPB->set_sensitive(false); + + // if the controls are currently enabled, we still have to check + // if the properties button should be disabled because the currently + // selected smart tag type does not have a properties dialog. + // We do this by calling SelectHdl: + if (bEnable) + SelectHdl(*m_xSmartTagTypesLB); +} + +/** Handler for the list box +*/ +IMPL_LINK_NOARG(OfaSmartTagOptionsTabPage, SelectHdl, weld::TreeView&, void) +{ + const int nPos = m_xSmartTagTypesLB->get_selected_index(); + if (nPos == -1) + return; + const ImplSmartTagLBUserData* pUserData = weld::fromId<ImplSmartTagLBUserData*>(m_xSmartTagTypesLB->get_id(nPos)); + uno::Reference< smarttags::XSmartTagRecognizer > xRec = pUserData->mxRec; + const sal_Int32 nSmartTagIdx = pUserData->mnSmartTagIdx; + + const lang::Locale aLocale( LanguageTag::convertToLocale( eLastDialogLanguage ) ); + if ( xRec->hasPropertyPage( nSmartTagIdx, aLocale ) ) + m_xPropertiesPB->set_sensitive(true); + else + m_xPropertiesPB->set_sensitive(false); +} + +/** Propagates the current settings to the smart tag manager. +*/ +bool OfaSmartTagOptionsTabPage::FillItemSet( SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + SmartTagMgr* pSmartTagMgr = pOpt->pSmartTagMgr; + + // robust! + if ( !pSmartTagMgr ) + return false; + + bool bModifiedSmartTagTypes = false; + std::vector< OUString > aDisabledSmartTagTypes; + + const int nCount = m_xSmartTagTypesLB->n_children(); + + for (int i = 0; i < nCount; ++i) + { + const ImplSmartTagLBUserData* pUserData = weld::fromId<ImplSmartTagLBUserData*>(m_xSmartTagTypesLB->get_id(i)); + const bool bChecked = m_xSmartTagTypesLB->get_toggle(i) == TRISTATE_TRUE; + const bool bIsCurrentlyEnabled = pSmartTagMgr->IsSmartTagTypeEnabled( pUserData->maSmartTagType ); + + bModifiedSmartTagTypes = bModifiedSmartTagTypes || ( !bChecked != !bIsCurrentlyEnabled ); + + if ( !bChecked ) + aDisabledSmartTagTypes.push_back( pUserData->maSmartTagType ); + + delete pUserData; + } + + const bool bModifiedRecognize = ( !m_xMainCB->get_active() != !pSmartTagMgr->IsLabelTextWithSmartTags() ); + if ( bModifiedSmartTagTypes || bModifiedRecognize ) + { + bool bLabelTextWithSmartTags = m_xMainCB->get_active(); + pSmartTagMgr->WriteConfiguration( bModifiedRecognize ? &bLabelTextWithSmartTags : nullptr, + bModifiedSmartTagTypes ? &aDisabledSmartTagTypes : nullptr ); + } + + return true; +} + +/** Sets the controls based on the current settings at SmartTagMgr. +*/ +void OfaSmartTagOptionsTabPage::Reset( const SfxItemSet* ) +{ + SvxAutoCorrect* pAutoCorrect = SvxAutoCorrCfg::Get().GetAutoCorrect(); + SvxSwAutoFormatFlags *pOpt = &pAutoCorrect->GetSwFlags(); + const SmartTagMgr* pSmartTagMgr = pOpt->pSmartTagMgr; + + // robust, should not happen! + if ( !pSmartTagMgr ) + return; + + FillListBox(*pSmartTagMgr); + m_xSmartTagTypesLB->select(0); + m_xMainCB->set_active(pSmartTagMgr->IsLabelTextWithSmartTags()); + CheckHdl(*m_xMainCB); +} + +void OfaSmartTagOptionsTabPage::ActivatePage( const SfxItemSet& ) +{ + static_cast<OfaAutoCorrDlg*>(GetDialogController())->EnableLanguage( false ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/backgrnd.cxx b/cui/source/tabpages/backgrnd.cxx new file mode 100644 index 000000000..14269ad3c --- /dev/null +++ b/cui/source/tabpages/backgrnd.cxx @@ -0,0 +1,338 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <sfx2/objsh.hxx> +#include <svx/svxids.hrc> +#include <editeng/colritem.hxx> +#include <backgrnd.hxx> +#include <svx/drawitem.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/flagsdef.hxx> +#include <svl/intitem.hxx> +#include <svx/unobrushitemhelper.hxx> + +using namespace css; + +// table background +#define TBL_DEST_CELL 0 +#define TBL_DEST_ROW 1 +#define TBL_DEST_TBL 2 + +const WhichRangesContainer SvxBkgTabPage::pPageRanges(svl::Items< + SID_ATTR_BRUSH, SID_ATTR_BRUSH, + SID_ATTR_BRUSH_CHAR, SID_ATTR_BRUSH_CHAR +>); + +static sal_uInt16 lcl_GetTableDestSlot(sal_Int32 nTblDest) +{ + switch (nTblDest) + { + default: + case TBL_DEST_CELL: + { + return SID_ATTR_BRUSH; + } + case TBL_DEST_ROW: + { + return SID_ATTR_BRUSH_ROW; + } + case TBL_DEST_TBL: + { + return SID_ATTR_BRUSH_TABLE; + } + } +} + +SvxBkgTabPage::SvxBkgTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxAreaTabPage(pPage, pController, rInAttrs), + bHighlighting(false), + bCharBackColor(false), + maSet(rInAttrs) +{ + m_xBtnGradient->hide(); + m_xBtnHatch->hide(); + m_xBtnBitmap->hide(); + m_xBtnPattern->hide(); + + SfxObjectShell* pDocSh = SfxObjectShell::Current(); + + XColorListRef pColorTable; + if ( pDocSh ) + if (auto pItem = pDocSh->GetItem( SID_COLOR_TABLE )) + pColorTable = pItem->GetColorList(); + + if ( !pColorTable.is() ) + pColorTable = XColorList::CreateStdColorList(); + + XBitmapListRef pBitmapList; + if ( pDocSh ) + if (auto pItem = pDocSh->GetItem( SID_BITMAP_LIST ) ) + pBitmapList = pItem->GetBitmapList(); + + SetColorList(pColorTable); + SetBitmapList(pBitmapList); +} + +SvxBkgTabPage::~SvxBkgTabPage() +{ + m_xTblLBox.reset(); +} + +void SvxBkgTabPage::ActivatePage( const SfxItemSet& ) +{ + SvxAreaTabPage::ActivatePage( maSet ); +} + +DeactivateRC SvxBkgTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( DeactivateRC::KeepPage == SvxAreaTabPage::DeactivatePage( &maSet ) ) + return DeactivateRC::KeepPage; + + if ( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + +void SvxBkgTabPage::Reset( const SfxItemSet* ) +{ + maSet.Set( *m_pResetSet ); + if ( m_xTblLBox && m_xTblLBox->get_visible() ) + { + m_nActPos = -1; + if ( const SfxUInt16Item* pDestItem = m_pResetSet->GetItemIfSet( SID_BACKGRND_DESTINATION, false ) ) + { + sal_uInt16 nDestValue = pDestItem->GetValue(); + m_xTblLBox->set_active( nDestValue ); + TblDestinationHdl_Impl( *m_xTblLBox ); + } + m_xTblLBox->save_value(); + } + SvxAreaTabPage::Reset( &maSet ); +} + +bool SvxBkgTabPage::FillItemSet( SfxItemSet* rCoreSet ) +{ + sal_uInt16 nSlot = SID_ATTR_BRUSH; + if (m_xTblLBox && m_xTblLBox->get_visible()) + nSlot = lcl_GetTableDestSlot(m_xTblLBox->get_active()); + else if ( bHighlighting ) + nSlot = SID_ATTR_BRUSH_CHAR; + else if( bCharBackColor ) + nSlot = SID_ATTR_CHAR_BACK_COLOR; + + sal_uInt16 nWhich = GetWhich(nSlot); + + drawing::FillStyle eFillType = maSet.Get( XATTR_FILLSTYLE ).GetValue(); + switch( eFillType ) + { + case drawing::FillStyle_NONE: + { + if ( IsBtnClicked() ) + { + if ( SID_ATTR_CHAR_BACK_COLOR == nSlot ) + { + maSet.Put( SvxColorItem( COL_TRANSPARENT, nWhich ) ); + rCoreSet->Put( SvxColorItem( COL_TRANSPARENT, nWhich ) ); + } + else + { + maSet.Put( SvxBrushItem( COL_TRANSPARENT, nWhich ) ); + rCoreSet->Put( SvxBrushItem( COL_TRANSPARENT, nWhich ) ); + } + } + break; + } + case drawing::FillStyle_SOLID: + { + XFillColorItem aColorItem( maSet.Get( XATTR_FILLCOLOR ) ); + if ( SID_ATTR_CHAR_BACK_COLOR == nSlot ) + { + maSet.Put( SvxColorItem( aColorItem.GetColorValue(), nWhich ) ); + rCoreSet->Put( SvxColorItem( aColorItem.GetColorValue(), nWhich ) ); + } + else + { + maSet.Put( SvxBrushItem( aColorItem.GetColorValue(), nWhich ) ); + rCoreSet->Put( SvxBrushItem( aColorItem.GetColorValue(), nWhich ) ); + } + break; + } + case drawing::FillStyle_BITMAP: + { + std::unique_ptr<SvxBrushItem> aBrushItem( getSvxBrushItemFromSourceSet( maSet, nWhich ) ); + if ( GraphicType::NONE != aBrushItem->GetGraphicObject()->GetType() ) + rCoreSet->Put( std::move(aBrushItem) ); + break; + } + default: + break; + } + + if (!m_xTblLBox || !m_xTblLBox->get_visible()) + return true; + + if (nSlot != SID_ATTR_BRUSH) + { + nWhich = maSet.GetPool()->GetWhich(SID_ATTR_BRUSH); + if (SfxItemState::SET == maSet.GetItemState(nWhich)) + { + SvxBrushItem aBrushItem(static_cast<const SvxBrushItem&>(maSet.Get(nWhich))); + rCoreSet->Put(aBrushItem); + } + } + if (nSlot != SID_ATTR_BRUSH_ROW) + { + if (SfxItemState::SET == maSet.GetItemState(SID_ATTR_BRUSH_ROW)) + { + SvxBrushItem aBrushItem(maSet.Get(SID_ATTR_BRUSH_ROW)); + rCoreSet->Put(aBrushItem); + } + } + if (nSlot != SID_ATTR_BRUSH_TABLE) + { + if (SfxItemState::SET == maSet.GetItemState(SID_ATTR_BRUSH_TABLE)) + { + SvxBrushItem aBrushItem(maSet.Get(SID_ATTR_BRUSH_TABLE)); + rCoreSet->Put(aBrushItem); + } + } + + if (m_xTblLBox->get_value_changed_from_saved()) + { + rCoreSet->Put(SfxUInt16Item(SID_BACKGRND_DESTINATION, m_xTblLBox->get_active())); + } + + return true; +} + +std::unique_ptr<SfxTabPage> SvxBkgTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + auto xRet = std::make_unique<SvxBkgTabPage>(pPage, pController, *rAttrs); + xRet->SetOptimalSize(pController); + return xRet; +} + +void SvxBkgTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt32Item* pFlagItem = aSet.GetItem<SfxUInt32Item>(SID_FLAG_TYPE, false); + if (pFlagItem) + { + SvxBackgroundTabFlags nFlags = static_cast<SvxBackgroundTabFlags>(pFlagItem->GetValue()); + if ( nFlags & SvxBackgroundTabFlags::SHOW_TBLCTL ) + { + m_xBtnBitmap->show(); + m_xTblLBox = m_xBuilder->weld_combo_box("tablelb"); + m_xTblLBox->connect_changed(LINK(this, SvxBkgTabPage, TblDestinationHdl_Impl)); + m_xTblLBox->show(); + } + if ((nFlags & SvxBackgroundTabFlags::SHOW_HIGHLIGHTING) || + (nFlags & SvxBackgroundTabFlags::SHOW_CHAR_BKGCOLOR)) + { + bHighlighting = bool(nFlags & SvxBackgroundTabFlags::SHOW_HIGHLIGHTING); + bCharBackColor = bool(nFlags & SvxBackgroundTabFlags::SHOW_CHAR_BKGCOLOR); + } + if (nFlags & SvxBackgroundTabFlags::SHOW_SELECTOR) + m_xBtnBitmap->show(); + SetOptimalSize(GetDialogController()); + } + + if ( bCharBackColor ) + { + sal_uInt16 nWhich(maSet.GetPool()->GetWhich(SID_ATTR_CHAR_BACK_COLOR)); + Color aBackColor(static_cast<const SvxColorItem&>(maSet.Get(nWhich)).GetValue()); + SvxBrushItem aBrushItem(SvxBrushItem(aBackColor, SID_ATTR_BRUSH_CHAR)); + setSvxBrushItemAsFillAttributesToTargetSet(aBrushItem, maSet); + } + else + { + sal_uInt16 nWhich(maSet.GetPool()->GetWhich(bHighlighting ? SID_ATTR_BRUSH_CHAR : SID_ATTR_BRUSH)); + SvxBrushItem aBrushItem(static_cast<const SvxBrushItem&>(maSet.Get(nWhich))); + setSvxBrushItemAsFillAttributesToTargetSet(aBrushItem, maSet); + } + + m_pResetSet = maSet.Clone(); + + SvxAreaTabPage::PageCreated(aSet); +} + +IMPL_LINK(SvxBkgTabPage, TblDestinationHdl_Impl, weld::ComboBox&, rBox, void) +{ + if (m_nActPos > -1) + { + // fill local item set with XATTR_FILL settings gathered from tab page + // and convert to SvxBrushItem and store in table destination slot Which + SvxAreaTabPage::FillItemSet(&maSet); + maSet.Put(getSvxBrushItemFromSourceSet(maSet, maSet.GetPool()->GetWhich(lcl_GetTableDestSlot(m_nActPos)))); + } + + sal_Int32 nSelPos = rBox.get_active(); + if (m_nActPos == nSelPos) + return; + + m_nActPos = nSelPos; + + // fill local item set with XATTR_FILL created from SvxBushItem for table destination slot Which + sal_uInt16 nWhich = maSet.GetPool()->GetWhich(lcl_GetTableDestSlot(nSelPos)); + if (SfxItemState::SET == maSet.GetItemState(nWhich)) + { + SvxBrushItem aBrushItem(static_cast<const SvxBrushItem&>(maSet.Get(nWhich))); + setSvxBrushItemAsFillAttributesToTargetSet(aBrushItem, maSet); + } + else + { + SelectFillType(*m_xBtnNone, &maSet); + return; + } + + // show tab page + drawing::FillStyle eXFS = drawing::FillStyle_NONE; + if (maSet.GetItemState(XATTR_FILLSTYLE) != SfxItemState::DONTCARE) + { + XFillStyleItem aFillStyleItem(maSet.Get(GetWhich( XATTR_FILLSTYLE))); + eXFS = aFillStyleItem.GetValue(); + } + switch(eXFS) + { + default: + case drawing::FillStyle_NONE: + { + SelectFillType(*m_xBtnNone, &maSet); + break; + } + case drawing::FillStyle_SOLID: + { + SelectFillType(*m_xBtnColor, &maSet); + // color tab page Active and New preview controls are same after SelectFillType + // hack to restore color tab page Active preview + setSvxBrushItemAsFillAttributesToTargetSet(static_cast<const SvxBrushItem&>(m_pResetSet->Get(nWhich)), *m_pResetSet); + static_cast<SvxColorTabPage*>(GetFillTabPage())->SetCtlPreviewOld(*m_pResetSet); + break; + } + case drawing::FillStyle_BITMAP: + { + SelectFillType(*m_xBtnBitmap, &maSet); + break; + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/bbdlg.cxx b/cui/source/tabpages/bbdlg.cxx new file mode 100644 index 000000000..488fc5283 --- /dev/null +++ b/cui/source/tabpages/bbdlg.cxx @@ -0,0 +1,89 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <bbdlg.hxx> +#include <border.hxx> +#include <backgrnd.hxx> +#include <svx/svxids.hrc> +#include <svl/intitem.hxx> +#include <cuitabarea.hxx> + +SvxBorderBackgroundDlg::SvxBorderBackgroundDlg(weld::Window *pParent, + const SfxItemSet& rCoreSet, + bool bEnableSelector, + bool bEnableDrawingLayerFillStyles) + : SfxTabDialogController(pParent, + bEnableDrawingLayerFillStyles + ? OUString("cui/ui/borderareatransparencydialog.ui") + : OUString("cui/ui/borderbackgrounddialog.ui"), + bEnableDrawingLayerFillStyles + ? OString("BorderAreaTransparencyDialog") + : OString("BorderBackgroundDialog"), + &rCoreSet) + , mbEnableBackgroundSelector(bEnableSelector) +{ + AddTabPage("borders", SvxBorderTabPage::Create, nullptr ); + if (bEnableDrawingLayerFillStyles) + { + // Here we want full DrawingLayer FillStyle access, so add Area and Transparency TabPages + AddTabPage("area", SvxAreaTabPage::Create, nullptr); + AddTabPage("transparence", SvxTransparenceTabPage::Create, nullptr); + } + else + { + AddTabPage("background", SvxBkgTabPage::Create, nullptr ); + } +} + +void SvxBorderBackgroundDlg::PageCreated(const OString& rPageId, SfxTabPage& rTabPage) +{ + if (rPageId == "background") + { + SfxAllItemSet aSet(*(GetInputSetImpl()->GetPool())); + // allow switching between Color/graphic + if (mbEnableBackgroundSelector) + aSet.Put(SfxUInt32Item(SID_FLAG_TYPE, static_cast<sal_uInt32>(SvxBackgroundTabFlags::SHOW_SELECTOR))); + rTabPage.PageCreated(aSet); + } + // inits for Area and Transparency TabPages + // The selection attribute lists (XPropertyList derivates, e.g. XColorList for + // the color table) need to be added as items (e.g. SvxColorTableItem) to make + // these pages find the needed attributes for fill style suggestions. + // These are added in SwDocStyleSheet::GetItemSet() for the SfxStyleFamily::Para on + // demand, but could also be directly added from the DrawModel. + else if (rPageId == "area") + { + SfxItemSetFixed<SID_COLOR_TABLE, SID_PATTERN_LIST, + SID_OFFER_IMPORT, SID_OFFER_IMPORT> + aNew(*GetInputSetImpl()->GetPool()); + + aNew.Put(*GetInputSetImpl()); + + // add flag for direct graphic content selection + aNew.Put(SfxBoolItem(SID_OFFER_IMPORT, true)); + + rTabPage.PageCreated(aNew); + } + else if (rPageId == "transparence") + { + rTabPage.PageCreated(*GetInputSetImpl()); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/border.cxx b/cui/source/tabpages/border.cxx new file mode 100644 index 000000000..30313dfce --- /dev/null +++ b/cui/source/tabpages/border.cxx @@ -0,0 +1,1704 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <sal/config.h> + +#include <sfx2/objsh.hxx> +#include <svx/strings.hrc> +#include <svx/svxids.hrc> + +#include <strings.hrc> +#include <bitmaps.hlst> + +#include <editeng/boxitem.hxx> +#include <editeng/lineitem.hxx> +#include <border.hxx> +#include <svx/dlgutil.hxx> +#include <dialmgr.hxx> +#include <sfx2/htmlmode.hxx> +#include <vcl/fieldvalues.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <svx/dialmgr.hxx> +#include <svx/flagsdef.hxx> +#include <svl/grabbagitem.hxx> +#include <svl/intitem.hxx> +#include <svl/ilstitem.hxx> +#include <svl/int64item.hxx> +#include <sal/macros.h> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <comphelper/lok.hxx> +#include <svtools/unitconv.hxx> + +using namespace ::editeng; +using ::com::sun::star::uno::Reference; +using ::com::sun::star::lang::XServiceInfo; +using ::com::sun::star::uno::UNO_QUERY; + + +/* + * [Description:] + * TabPage for setting the border attributes. + * Needs + * a SvxShadowItem: shadow + * a SvxBoxItem: lines left, right, top, bottom, + * a SvxBoxInfo: lines vertical, horizontal, distance, flags + * + * Lines can have three conditions: + * 1. Show ( -> valid values ) + * 2. Hide ( -> NULL-Pointer ) + * 3. DontCare ( -> special Valid-Flags in the InfoItem ) + */ + +// static ---------------------------------------------------------------- + +const WhichRangesContainer SvxBorderTabPage::pRanges( + svl::Items< + SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_SHADOW, + SID_ATTR_ALIGN_MARGIN, SID_ATTR_ALIGN_MARGIN, + SID_ATTR_BORDER_CONNECT, SID_ATTR_BORDER_CONNECT, + SID_SW_COLLAPSING_BORDERS, SID_SW_COLLAPSING_BORDERS, + SID_ATTR_BORDER_DIAG_TLBR, SID_ATTR_BORDER_DIAG_BLTR>); + +namespace +{ +int lcl_twipsToPt(sal_Int64 nTwips) +{ + return vcl::ConvertDoubleValue(nTwips, 0, FieldUnit::TWIP, MapUnit::MapPoint) * 100; +} +} + +const std::vector<int> SvxBorderTabPage::m_aLineWidths = { + lcl_twipsToPt(SvxBorderLineWidth::Hairline), + lcl_twipsToPt(SvxBorderLineWidth::VeryThin), + lcl_twipsToPt(SvxBorderLineWidth::Thin), + lcl_twipsToPt(SvxBorderLineWidth::Medium), + lcl_twipsToPt(SvxBorderLineWidth::Thick), + lcl_twipsToPt(SvxBorderLineWidth::ExtraThick), + -1 +}; + +static void lcl_SetDecimalDigitsTo1(weld::MetricSpinButton& rField) +{ + auto nMin = rField.denormalize(rField.get_min(FieldUnit::TWIP)); + rField.set_digits(1); + rField.set_min(rField.normalize(nMin), FieldUnit::TWIP); +} + +// returns in pt +static sal_Int64 lcl_GetMinLineWidth(SvxBorderLineStyle aStyle) +{ + switch (aStyle) + { + case SvxBorderLineStyle::NONE: + return 0; + + case SvxBorderLineStyle::SOLID: + case SvxBorderLineStyle::DOTTED: + case SvxBorderLineStyle::DASHED: + case SvxBorderLineStyle::FINE_DASHED: + case SvxBorderLineStyle::DASH_DOT: + case SvxBorderLineStyle::DASH_DOT_DOT: + return 15; + + // Double lines + case SvxBorderLineStyle::DOUBLE: return 15; + case SvxBorderLineStyle::DOUBLE_THIN: return 15; + case SvxBorderLineStyle::THINTHICK_SMALLGAP: return 20; + case SvxBorderLineStyle::THINTHICK_MEDIUMGAP: return 15; + case SvxBorderLineStyle::THINTHICK_LARGEGAP: return 15; + case SvxBorderLineStyle::THICKTHIN_SMALLGAP: return 20; + case SvxBorderLineStyle::THICKTHIN_MEDIUMGAP: return 15; + case SvxBorderLineStyle::THICKTHIN_LARGEGAP: return 15; + + case SvxBorderLineStyle::EMBOSSED: return 15; + case SvxBorderLineStyle::ENGRAVED: return 15; + + case SvxBorderLineStyle::OUTSET: return 10; + case SvxBorderLineStyle::INSET: return 10; + + default: + return 15; + } +} + +// number of preset images to show +const sal_uInt16 BORDER_PRESET_COUNT = 5; + +// number of shadow images to show +const sal_uInt16 BORDER_SHADOW_COUNT = 5; + +ShadowControlsWrapper::ShadowControlsWrapper(ValueSet& rVsPos, weld::MetricSpinButton& rMfSize, ColorListBox& rLbColor) + : mrVsPos(rVsPos) + , mrMfSize(rMfSize) + , mrLbColor(rLbColor) +{ +} + +SvxShadowItem ShadowControlsWrapper::GetControlValue(const SvxShadowItem& rItem) const +{ + SvxShadowItem aItem(rItem); + if (!mrVsPos.IsNoSelection()) + { + switch (mrVsPos.GetSelectedItemId()) + { + case 1: + aItem.SetLocation(SvxShadowLocation::NONE); + break; + case 2: + aItem.SetLocation(SvxShadowLocation::BottomRight); + break; + case 3: + aItem.SetLocation(SvxShadowLocation::TopRight); + break; + case 4: + aItem.SetLocation(SvxShadowLocation::BottomLeft); + break; + case 5: + aItem.SetLocation(SvxShadowLocation::TopLeft); + break; + default: + aItem.SetLocation(SvxShadowLocation::NONE); + break; + } + } + // Default value was saved; so don't change the aItem's width if the control + // has not changed its value, to avoid round-trip errors (like twip->cm->twip) + // E.g., initial 100 twip will become 0.18 cm, which will return as 102 twip + if (mrMfSize.get_value_changed_from_saved()) + aItem.SetWidth(mrMfSize.denormalize(mrMfSize.get_value(FieldUnit::TWIP))); + if (!mrLbColor.IsNoSelection()) + aItem.SetColor(mrLbColor.GetSelectEntryColor()); + return aItem; +} + +void ShadowControlsWrapper::SetControlValue(const SvxShadowItem& rItem) +{ + switch (rItem.GetLocation()) + { + case SvxShadowLocation::NONE: + mrVsPos.SelectItem(1); + break; + case SvxShadowLocation::BottomRight: + mrVsPos.SelectItem(2); + break; + case SvxShadowLocation::TopRight: + mrVsPos.SelectItem(3); + break; + case SvxShadowLocation::BottomLeft: + mrVsPos.SelectItem(4); + break; + case SvxShadowLocation::TopLeft: + mrVsPos.SelectItem(5); + break; + default: + mrVsPos.SetNoSelection(); + break; + } + mrVsPos.SaveValue(); + mrMfSize.set_value(mrMfSize.normalize(rItem.GetWidth()), FieldUnit::TWIP); + mrMfSize.save_value(); + mrLbColor.SelectEntry(rItem.GetColor()); + mrLbColor.SaveValue(); +} + +bool ShadowControlsWrapper::get_value_changed_from_saved() const +{ + return mrVsPos.IsValueChangedFromSaved() || + mrMfSize.get_value_changed_from_saved() || + mrLbColor.IsValueChangedFromSaved(); +} + +void ShadowControlsWrapper::SetControlDontKnow() +{ + mrVsPos.SetNoSelection(); + mrMfSize.set_text(""); + mrLbColor.SetNoSelection(); +} + +MarginControlsWrapper::MarginControlsWrapper(weld::MetricSpinButton& rMfLeft, weld::MetricSpinButton& rMfRight, + weld::MetricSpinButton& rMfTop, weld::MetricSpinButton& rMfBottom) + : mrLeftWrp(rMfLeft) + , mrRightWrp(rMfRight) + , mrTopWrp(rMfTop) + , mrBottomWrp(rMfBottom) +{ +} + +SvxMarginItem MarginControlsWrapper::GetControlValue(const SvxMarginItem &rItem) const +{ + SvxMarginItem aItem(rItem); + if (mrLeftWrp.get_sensitive()) + aItem.SetLeftMargin(mrLeftWrp.denormalize(mrLeftWrp.get_value(FieldUnit::TWIP))); + if (mrRightWrp.get_sensitive()) + aItem.SetRightMargin(mrRightWrp.denormalize(mrRightWrp.get_value(FieldUnit::TWIP))); + if (mrTopWrp.get_sensitive()) + aItem.SetTopMargin(mrTopWrp.denormalize(mrTopWrp.get_value(FieldUnit::TWIP))); + if (mrBottomWrp.get_sensitive()) + aItem.SetBottomMargin(mrBottomWrp.denormalize(mrBottomWrp.get_value(FieldUnit::TWIP))); + return aItem; +} + +bool MarginControlsWrapper::get_value_changed_from_saved() const +{ + return mrLeftWrp.get_value_changed_from_saved() || + mrRightWrp.get_value_changed_from_saved() || + mrTopWrp.get_value_changed_from_saved() || + mrBottomWrp.get_value_changed_from_saved(); +} + +void MarginControlsWrapper::SetControlValue(const SvxMarginItem& rItem) +{ + mrLeftWrp.set_value(mrLeftWrp.normalize(rItem.GetLeftMargin()), FieldUnit::TWIP); + mrRightWrp.set_value(mrRightWrp.normalize(rItem.GetRightMargin()), FieldUnit::TWIP); + mrTopWrp.set_value(mrTopWrp.normalize(rItem.GetTopMargin()), FieldUnit::TWIP); + mrBottomWrp.set_value(mrBottomWrp.normalize(rItem.GetBottomMargin()), FieldUnit::TWIP); + mrLeftWrp.save_value(); + mrRightWrp.save_value(); + mrTopWrp.save_value(); + mrBottomWrp.save_value(); +} + +void MarginControlsWrapper::SetControlDontKnow() +{ + const OUString sEmpty; + mrLeftWrp.set_text(sEmpty); + mrRightWrp.set_text(sEmpty); + mrTopWrp.set_text(sEmpty); + mrBottomWrp.set_text(sEmpty); +} + +SvxBorderTabPage::SvxBorderTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rCoreAttrs) + : SfxTabPage(pPage, pController, "cui/ui/borderpage.ui", "BorderPage", &rCoreAttrs) + , nMinValue(0) + , nSWMode(SwBorderModes::NONE) + , mnBoxSlot(SID_ATTR_BORDER_OUTER) + , mnShadowSlot(SID_ATTR_BORDER_SHADOW) + , mbHorEnabled(false) + , mbVerEnabled(false) + , mbTLBREnabled(false) + , mbBLTREnabled(false) + , mbUseMarginItem(false) + , mbLeftModified(false) + , mbRightModified(false) + , mbTopModified(false) + , mbBottomModified(false) + , mbSync(true) + , mbRemoveAdjacentCellBorders(false) + , bIsCalcDoc(false) + , m_xWndPresets(new ValueSet(nullptr)) + , m_xWndPresetsWin(new weld::CustomWeld(*m_xBuilder, "presets", *m_xWndPresets)) + , m_xUserDefFT(m_xBuilder->weld_label("userdefft")) + , m_xFrameSelWin(new weld::CustomWeld(*m_xBuilder, "framesel", m_aFrameSel)) + , m_xLbLineStyle(new SvtLineListBox(m_xBuilder->weld_menu_button("linestylelb"))) + , m_xLbLineColor(new ColorListBox(m_xBuilder->weld_menu_button("linecolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xLineWidthLB(m_xBuilder->weld_combo_box("linewidthlb")) + , m_xLineWidthMF(m_xBuilder->weld_metric_spin_button("linewidthmf", FieldUnit::POINT)) + , m_xSpacingFrame(m_xBuilder->weld_container("spacing")) + , m_xLeftFT(m_xBuilder->weld_label("leftft")) + , m_xLeftMF(m_xBuilder->weld_metric_spin_button("leftmf", FieldUnit::MM)) + , m_xRightFT(m_xBuilder->weld_label("rightft")) + , m_xRightMF(m_xBuilder->weld_metric_spin_button("rightmf", FieldUnit::MM)) + , m_xTopFT(m_xBuilder->weld_label("topft")) + , m_xTopMF(m_xBuilder->weld_metric_spin_button("topmf", FieldUnit::MM)) + , m_xBottomFT(m_xBuilder->weld_label("bottomft")) + , m_xBottomMF(m_xBuilder->weld_metric_spin_button("bottommf", FieldUnit::MM)) + , m_xSynchronizeCB(m_xBuilder->weld_check_button("sync")) + , m_xShadowFrame(m_xBuilder->weld_container("shadow")) + , m_xWndShadows(new ValueSet(nullptr)) + , m_xWndShadowsWin(new weld::CustomWeld(*m_xBuilder, "shadows", *m_xWndShadows)) + , m_xFtShadowSize(m_xBuilder->weld_label("distanceft")) + , m_xEdShadowSize(m_xBuilder->weld_metric_spin_button("distancemf", FieldUnit::MM)) + , m_xFtShadowColor(m_xBuilder->weld_label("shadowcolorft")) + , m_xLbShadowColor(new ColorListBox(m_xBuilder->weld_menu_button("shadowcolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xPropertiesFrame(m_xBuilder->weld_container("properties")) + , m_xMergeWithNextCB(m_xBuilder->weld_check_button("mergewithnext")) + , m_xMergeAdjacentBordersCB(m_xBuilder->weld_check_button("mergeadjacent")) + , m_xRemoveAdjacentCellBordersCB(m_xBuilder->weld_check_button("rmadjcellborders")) + , m_xRemoveAdjacentCellBordersFT(m_xBuilder->weld_label("rmadjcellbordersft")) +{ + static std::vector<OUString> aBorderImageIds; + + if (aBorderImageIds.empty()) + { + if (comphelper::LibreOfficeKit::isActive()) + { + aBorderImageIds.insert(aBorderImageIds.end(), { + RID_SVXBMP_CELL_NONE_32, + RID_SVXBMP_CELL_ALL_32, + RID_SVXBMP_CELL_LR_32, + RID_SVXBMP_CELL_TB_32, + RID_SVXBMP_CELL_L_32, + RID_SVXBMP_CELL_DIAG_32 + }); + } + else + { + aBorderImageIds.insert(aBorderImageIds.end(), { + RID_SVXBMP_CELL_NONE, + RID_SVXBMP_CELL_ALL, + RID_SVXBMP_CELL_LR, + RID_SVXBMP_CELL_TB, + RID_SVXBMP_CELL_L, + RID_SVXBMP_CELL_DIAG + }); + } + aBorderImageIds.insert(aBorderImageIds.end(), { + RID_SVXBMP_HOR_NONE, + RID_SVXBMP_HOR_OUTER, + RID_SVXBMP_HOR_HOR, + RID_SVXBMP_HOR_ALL, + RID_SVXBMP_HOR_OUTER2, + RID_SVXBMP_VER_NONE, + RID_SVXBMP_VER_OUTER, + RID_SVXBMP_VER_VER, + RID_SVXBMP_VER_ALL, + RID_SVXBMP_VER_OUTER2, + RID_SVXBMP_TABLE_NONE, + RID_SVXBMP_TABLE_OUTER, + RID_SVXBMP_TABLE_OUTERH, + RID_SVXBMP_TABLE_ALL, + RID_SVXBMP_TABLE_OUTER2 + }); + } + + for (auto const & rImageId : aBorderImageIds) + m_aBorderImgVec.emplace_back(StockImage::Yes, rImageId); + + static std::vector<OUString> aShadowImageIds; + if (aShadowImageIds.empty()) + { + if (comphelper::LibreOfficeKit::isActive()) + { + aShadowImageIds.insert(aShadowImageIds.end(), { + RID_SVXBMP_SHADOWNONE_32, + RID_SVXBMP_SHADOW_BOT_RIGHT_32, + RID_SVXBMP_SHADOW_TOP_RIGHT_32, + RID_SVXBMP_SHADOW_BOT_LEFT_32, + RID_SVXBMP_SHADOW_TOP_LEFT_32 + }); + } + else + { + aShadowImageIds.insert(aShadowImageIds.end(), { + RID_SVXBMP_SHADOWNONE, + RID_SVXBMP_SHADOW_BOT_RIGHT, + RID_SVXBMP_SHADOW_TOP_RIGHT, + RID_SVXBMP_SHADOW_BOT_LEFT, + RID_SVXBMP_SHADOW_TOP_LEFT + }); + } + } + + for (auto const & rImageId : aShadowImageIds) + m_aShadowImgVec.emplace_back(StockImage::Yes, rImageId); + + assert(m_aShadowImgVec.size() == BORDER_SHADOW_COUNT); + + // this page needs ExchangeSupport + SetExchangeSupport(); + + /* Use SvxMarginItem instead of margins from SvxBoxItem, if present. + -> Remember this state in mbUseMarginItem, because other special handling + is needed across various functions... */ + mbUseMarginItem = rCoreAttrs.GetItemState(GetWhich(SID_ATTR_ALIGN_MARGIN)) != SfxItemState::UNKNOWN; + + if (const SfxIntegerListItem* p = rCoreAttrs.GetItemIfSet(SID_ATTR_BORDER_STYLES)) + { + std::vector<sal_Int32> aUsedStyles = p->GetList(); + for (int aUsedStyle : aUsedStyles) + maUsedBorderStyles.insert(static_cast<SvxBorderLineStyle>(aUsedStyle)); + } + + if (const SfxInt64Item* p = rCoreAttrs.GetItemIfSet(SID_ATTR_BORDER_DEFAULT_WIDTH)) + { + // The caller specifies default line width. Honor it. + SetLineWidth(p->GetValue()); + } + + // set metric + FieldUnit eFUnit = GetModuleFieldUnit( rCoreAttrs ); + + if( mbUseMarginItem ) + { + // copied from SvxAlignmentTabPage + switch ( eFUnit ) + { + // #103396# the default value (1pt) can't be accurately represented in + // inches or pica with two decimals, so point is used instead. + case FieldUnit::PICA: + case FieldUnit::INCH: + case FieldUnit::FOOT: + case FieldUnit::MILE: + eFUnit = FieldUnit::POINT; + break; + + case FieldUnit::CM: + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + break; + default: ;//prevent warning + } + } + else + { + switch ( eFUnit ) + { + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + break; + default: ; //prevent warning + } + } + + SetFieldUnit(*m_xEdShadowSize, eFUnit); + + sal_uInt16 nWhich = GetWhich( SID_ATTR_BORDER_INNER, false ); + bool bIsDontCare = true; + + if ( rCoreAttrs.GetItemState( nWhich ) >= SfxItemState::DEFAULT ) + { + // paragraph or table + const SvxBoxInfoItem* pBoxInfo = + static_cast<const SvxBoxInfoItem*>(&( rCoreAttrs.Get( nWhich ) )); + + mbHorEnabled = pBoxInfo->IsHorEnabled(); + mbVerEnabled = pBoxInfo->IsVerEnabled(); + mbTLBREnabled = rCoreAttrs.GetItemState(GetWhich(SID_ATTR_BORDER_DIAG_TLBR)) != SfxItemState::UNKNOWN; + mbBLTREnabled = rCoreAttrs.GetItemState(GetWhich(SID_ATTR_BORDER_DIAG_BLTR)) != SfxItemState::UNKNOWN; + + if(pBoxInfo->IsDist()) + { + SetFieldUnit(*m_xLeftMF, eFUnit); + SetFieldUnit(*m_xRightMF, eFUnit); + SetFieldUnit(*m_xTopMF, eFUnit); + SetFieldUnit(*m_xBottomMF, eFUnit); + m_xSynchronizeCB->connect_toggled(LINK(this, SvxBorderTabPage, SyncHdl_Impl)); + m_xLeftMF->connect_value_changed(LINK(this, SvxBorderTabPage, ModifyDistanceHdl_Impl)); + m_xRightMF->connect_value_changed(LINK(this, SvxBorderTabPage, ModifyDistanceHdl_Impl)); + m_xTopMF->connect_value_changed(LINK(this, SvxBorderTabPage, ModifyDistanceHdl_Impl)); + m_xBottomMF->connect_value_changed(LINK(this, SvxBorderTabPage, ModifyDistanceHdl_Impl)); + } + else + { + m_xSpacingFrame->hide(); + } + bIsDontCare = !pBoxInfo->IsValid( SvxBoxInfoItemValidFlags::DISABLE ); + } + if(!mbUseMarginItem && eFUnit == FieldUnit::MM && MapUnit::MapTwip == rCoreAttrs.GetPool()->GetMetric( GetWhich( SID_ATTR_BORDER_INNER ) )) + { + //#i91548# changing the number of decimal digits changes the minimum values, too + lcl_SetDecimalDigitsTo1(*m_xLeftMF); + lcl_SetDecimalDigitsTo1(*m_xRightMF); + lcl_SetDecimalDigitsTo1(*m_xTopMF); + lcl_SetDecimalDigitsTo1(*m_xBottomMF); + lcl_SetDecimalDigitsTo1(*m_xEdShadowSize); + } + + FrameSelFlags nFlags = FrameSelFlags::Outer; + if( mbHorEnabled ) + nFlags |= FrameSelFlags::InnerHorizontal; + if( mbVerEnabled ) + nFlags |= FrameSelFlags::InnerVertical; + if( mbTLBREnabled ) + nFlags |= FrameSelFlags::DiagonalTLBR; + if( mbBLTREnabled ) + nFlags |= FrameSelFlags::DiagonalBLTR; + if( bIsDontCare ) + nFlags |= FrameSelFlags::DontCare; + m_aFrameSel.Initialize( nFlags ); + + m_aFrameSel.SetSelectHdl(LINK(this, SvxBorderTabPage, LinesChanged_Impl)); + m_xLbLineStyle->SetSelectHdl( LINK( this, SvxBorderTabPage, SelStyleHdl_Impl ) ); + m_xLbLineColor->SetSelectHdl( LINK( this, SvxBorderTabPage, SelColHdl_Impl ) ); + m_xLineWidthLB->connect_changed(LINK(this, SvxBorderTabPage, ModifyWidthLBHdl_Impl)); + m_xLineWidthMF->connect_value_changed(LINK(this, SvxBorderTabPage, ModifyWidthMFHdl_Impl)); + m_xWndPresets->SetSelectHdl( LINK( this, SvxBorderTabPage, SelPreHdl_Impl ) ); + m_xWndShadows->SetSelectHdl( LINK( this, SvxBorderTabPage, SelSdwHdl_Impl ) ); + + FillValueSets(); + FillLineListBox_Impl(); + + // Reapply line width: probably one of predefined values should be selected + SetLineWidth(m_xLineWidthMF->get_value(FieldUnit::NONE)); + + // connections + const SfxPoolItem* pItem = nullptr; + if (rCoreAttrs.HasItem(GetWhich(SID_ATTR_PARA_GRABBAG), &pItem)) + { + const SfxGrabBagItem* pGrabBag = static_cast<const SfxGrabBagItem*>(pItem); + auto it = pGrabBag->GetGrabBag().find("DialogUseCharAttr"); + if (it != pGrabBag->GetGrabBag().end()) + { + bool bDialogUseCharAttr = false; + it->second >>= bDialogUseCharAttr; + if (bDialogUseCharAttr) + { + mnShadowSlot = SID_ATTR_CHAR_SHADOW; + mnBoxSlot = SID_ATTR_CHAR_BOX; + } + } + } + + bool bSupportsShadow = !SfxItemPool::IsSlot(GetWhich(mnShadowSlot)); + if( bSupportsShadow ) + m_xShadowControls.reset(new ShadowControlsWrapper(*m_xWndShadows, *m_xEdShadowSize, *m_xLbShadowColor)); + else + HideShadowControls(); + + if (mbUseMarginItem) + m_xMarginControls.reset(new MarginControlsWrapper(*m_xLeftMF, *m_xRightMF, *m_xTopMF, *m_xBottomMF)); + + // checkbox "Merge with next paragraph" only visible for Writer dialog format.paragraph + m_xMergeWithNextCB->hide(); + // checkbox "Merge adjacent line styles" only visible for Writer dialog format.table + m_xMergeAdjacentBordersCB->hide(); + + if (SfxObjectShell* pDocSh = SfxObjectShell::Current()) + { + Reference< XServiceInfo > xSI( pDocSh->GetModel(), UNO_QUERY ); + if ( xSI.is() ) + bIsCalcDoc = xSI->supportsService("com.sun.star.sheet.SpreadsheetDocument"); + } + if( bIsCalcDoc ) + { + m_xRemoveAdjacentCellBordersCB->connect_toggled(LINK(this, SvxBorderTabPage, RemoveAdjacentCellBorderHdl_Impl)); + m_xRemoveAdjacentCellBordersCB->show(); + m_xRemoveAdjacentCellBordersCB->set_sensitive(false); + } + else + { + m_xRemoveAdjacentCellBordersCB->hide(); + m_xRemoveAdjacentCellBordersFT->hide(); + } +} + +SvxBorderTabPage::~SvxBorderTabPage() +{ + m_xLbShadowColor.reset(); + m_xWndShadowsWin.reset(); + m_xWndShadows.reset(); + m_xLbLineColor.reset(); + m_xLbLineStyle.reset(); + m_xFrameSelWin.reset(); + m_xWndPresetsWin.reset(); + m_xWndPresets.reset(); +} + +std::unique_ptr<SfxTabPage> SvxBorderTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet ) +{ + return std::make_unique<SvxBorderTabPage>(pPage, pController, *rAttrSet); +} + +void SvxBorderTabPage::ResetFrameLine_Impl( svx::FrameBorderType eBorder, const SvxBorderLine* pCoreLine, bool bValid ) +{ + if( m_aFrameSel.IsBorderEnabled( eBorder ) ) + { + if( bValid ) + m_aFrameSel.ShowBorder( eBorder, pCoreLine ); + else + m_aFrameSel.SetBorderDontCare( eBorder ); + } +} + +bool SvxBorderTabPage::IsBorderLineStyleAllowed( SvxBorderLineStyle nStyle ) const +{ + if (maUsedBorderStyles.empty()) + // All border styles are allowed. + return true; + + return maUsedBorderStyles.count(nStyle) > 0; +} + +void SvxBorderTabPage::Reset( const SfxItemSet* rSet ) +{ + SfxItemPool* pPool = rSet->GetPool(); + + if (m_aFrameSel.IsBorderEnabled(svx::FrameBorderType::TLBR)) + { + sal_uInt16 nBorderDiagId = pPool->GetWhich(SID_ATTR_BORDER_DIAG_TLBR); + if (const SvxLineItem* pLineItem = static_cast<const SvxLineItem*>(rSet->GetItem(nBorderDiagId))) + m_aFrameSel.ShowBorder(svx::FrameBorderType::TLBR, pLineItem->GetLine()); + else + m_aFrameSel.SetBorderDontCare(svx::FrameBorderType::TLBR); + } + + if (m_aFrameSel.IsBorderEnabled(svx::FrameBorderType::BLTR)) + { + sal_uInt16 nBorderDiagId = pPool->GetWhich(SID_ATTR_BORDER_DIAG_BLTR); + if (const SvxLineItem* pLineItem = static_cast<const SvxLineItem*>(rSet->GetItem(nBorderDiagId))) + m_aFrameSel.ShowBorder(svx::FrameBorderType::BLTR, pLineItem->GetLine()); + else + m_aFrameSel.SetBorderDontCare(svx::FrameBorderType::BLTR); + } + + if (m_xShadowControls) + { + sal_uInt16 nShadowId = pPool->GetWhich(mnShadowSlot); + const SfxPoolItem* pItem = rSet->GetItem(nShadowId); + if (pItem) + m_xShadowControls->SetControlValue(*static_cast<const SvxShadowItem*>(pItem)); + else + m_xShadowControls->SetControlDontKnow(); + } + + if (m_xMarginControls) + { + sal_uInt16 nAlignMarginId = pPool->GetWhich(SID_ATTR_ALIGN_MARGIN); + const SfxPoolItem* pItem = rSet->GetItem(nAlignMarginId); + if (pItem) + m_xMarginControls->SetControlValue(*static_cast<const SvxMarginItem*>(pItem)); + else + m_xMarginControls->SetControlDontKnow(); + } + + sal_uInt16 nMergeAdjacentBordersId = pPool->GetWhich(SID_SW_COLLAPSING_BORDERS); + const SfxBoolItem *pMergeAdjacentBorders = static_cast<const SfxBoolItem*>(rSet->GetItem(nMergeAdjacentBordersId)); + if (!pMergeAdjacentBorders) + m_xMergeAdjacentBordersCB->set_state(TRISTATE_INDET); + else + m_xMergeAdjacentBordersCB->set_active(pMergeAdjacentBorders->GetValue()); + m_xMergeAdjacentBordersCB->save_state(); + + sal_uInt16 nMergeWithNextId = pPool->GetWhich(SID_ATTR_BORDER_CONNECT); + const SfxBoolItem *pMergeWithNext = static_cast<const SfxBoolItem*>(rSet->GetItem(nMergeWithNextId)); + if (!pMergeWithNext) + m_xMergeWithNextCB->set_state(TRISTATE_INDET); + else + m_xMergeWithNextCB->set_active(pMergeWithNext->GetValue()); + m_xMergeWithNextCB->save_state(); + + const SvxBoxItem* pBoxItem; + const SvxBoxInfoItem* pBoxInfoItem; + sal_uInt16 nWhichBox = GetWhich(mnBoxSlot); + MapUnit eCoreUnit; + + pBoxItem = static_cast<const SvxBoxItem*>(GetItem( *rSet, mnBoxSlot )); + + pBoxInfoItem = GetItem( *rSet, SID_ATTR_BORDER_INNER, false ); + + eCoreUnit = pPool->GetMetric( nWhichBox ); + + if ( pBoxItem && pBoxInfoItem ) // -> Don't Care + { + ResetFrameLine_Impl( svx::FrameBorderType::Left, pBoxItem->GetLeft(), pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::LEFT ) ); + ResetFrameLine_Impl( svx::FrameBorderType::Right, pBoxItem->GetRight(), pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::RIGHT ) ); + ResetFrameLine_Impl( svx::FrameBorderType::Top, pBoxItem->GetTop(), pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::TOP ) ); + ResetFrameLine_Impl( svx::FrameBorderType::Bottom, pBoxItem->GetBottom(), pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::BOTTOM ) ); + ResetFrameLine_Impl( svx::FrameBorderType::Vertical, pBoxInfoItem->GetVert(), pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::VERT ) ); + ResetFrameLine_Impl( svx::FrameBorderType::Horizontal, pBoxInfoItem->GetHori(), pBoxInfoItem->IsValid( SvxBoxInfoItemValidFlags::HORI ) ); + + + // distance inside + + if( !mbUseMarginItem ) + { + if (m_xLeftMF->get_visible()) + { + SetMetricValue(*m_xLeftMF, pBoxInfoItem->GetDefDist(), eCoreUnit); + SetMetricValue(*m_xRightMF, pBoxInfoItem->GetDefDist(), eCoreUnit); + SetMetricValue(*m_xTopMF, pBoxInfoItem->GetDefDist(), eCoreUnit); + SetMetricValue(*m_xBottomMF, pBoxInfoItem->GetDefDist(), eCoreUnit); + + nMinValue = m_xLeftMF->get_value(FieldUnit::NONE); + + if ( pBoxInfoItem->IsDist() ) + { + if( rSet->GetItemState( nWhichBox ) >= SfxItemState::DEFAULT ) + { + bool bIsAnyBorderVisible = m_aFrameSel.IsAnyBorderVisible(); + if( !bIsAnyBorderVisible || !pBoxInfoItem->IsMinDist() ) + { + m_xLeftMF->set_min(0, FieldUnit::NONE); + m_xRightMF->set_min(0, FieldUnit::NONE); + m_xTopMF->set_min(0, FieldUnit::NONE); + m_xBottomMF->set_min(0, FieldUnit::NONE); + } + tools::Long nLeftDist = pBoxItem->GetDistance( SvxBoxItemLine::LEFT); + SetMetricValue(*m_xLeftMF, nLeftDist, eCoreUnit); + tools::Long nRightDist = pBoxItem->GetDistance( SvxBoxItemLine::RIGHT); + SetMetricValue(*m_xRightMF, nRightDist, eCoreUnit); + tools::Long nTopDist = pBoxItem->GetDistance( SvxBoxItemLine::TOP); + SetMetricValue( *m_xTopMF, nTopDist, eCoreUnit ); + tools::Long nBottomDist = pBoxItem->GetDistance( SvxBoxItemLine::BOTTOM); + SetMetricValue( *m_xBottomMF, nBottomDist, eCoreUnit ); + + // if the distance is set with no active border line + // or it is null with an active border line + // no automatic changes should be made + const tools::Long nDefDist = bIsAnyBorderVisible ? pBoxInfoItem->GetDefDist() : 0; + bool bDiffDist = (nDefDist != nLeftDist || + nDefDist != nRightDist || + nDefDist != nTopDist || + nDefDist != nBottomDist); + if ((pBoxItem->GetSmallestDistance() || bIsAnyBorderVisible) && bDiffDist ) + { + mbLeftModified = true; + mbRightModified = true; + mbTopModified = true; + mbBottomModified = true; + } + } + else + { + // #106224# different margins -> do not fill the edits + m_xLeftMF->set_text( OUString() ); + m_xRightMF->set_text( OUString() ); + m_xTopMF->set_text( OUString() ); + m_xBottomMF->set_text( OUString() ); + } + } + m_xLeftMF->save_value(); + m_xRightMF->save_value(); + m_xTopMF->save_value(); + m_xBottomMF->save_value(); + } + } + } + else + { + // avoid ResetFrameLine-calls: + m_aFrameSel.HideAllBorders(); + } + + if( !m_aFrameSel.IsAnyBorderVisible() ) + m_aFrameSel.DeselectAllBorders(); + + // depict line (color) in controllers if unambiguous: + + { + // Do all visible lines show the same line widths? + tools::Long nWidth; + SvxBorderLineStyle nStyle; + bool bWidthEq = m_aFrameSel.GetVisibleWidth( nWidth, nStyle ); + if( bWidthEq ) + { + // Determine the width first as some styles can be missing depending on it + sal_Int64 nWidthPt = static_cast<sal_Int64>(vcl::ConvertDoubleValue( + sal_Int64( nWidth ), m_xLineWidthMF->get_digits(), + MapUnit::MapTwip, FieldUnit::POINT )); + SetLineWidth(nWidthPt); + m_xLbLineStyle->SetWidth(nWidth); + + // then set the style + m_xLbLineStyle->SelectEntry( nStyle ); + } + else + m_xLbLineStyle->SelectEntry(SvxBorderLineStyle::SOLID); + + // Do all visible lines show the same line color? + Color aColor; + bool bColorEq = m_aFrameSel.GetVisibleColor( aColor ); + if( !bColorEq ) + aColor = COL_BLACK; + + m_xLbLineColor->SelectEntry(aColor); + auto nTextColor = Application::GetSettings().GetStyleSettings().GetWindowTextColor(); + m_xLbLineStyle->SetColor(nTextColor); + + // Select all visible lines, if they are all equal. + if( bWidthEq && bColorEq ) + m_aFrameSel.SelectAllVisibleBorders(); + + // set the current style and color (caches style in control even if nothing is selected) + SelStyleHdl_Impl(*m_xLbLineStyle); + SelColHdl_Impl(*m_xLbLineColor); + } + + bool bEnable = m_xWndShadows->GetSelectedItemId() > 1 ; + m_xFtShadowSize->set_sensitive(bEnable); + m_xEdShadowSize->set_sensitive(bEnable); + m_xFtShadowColor->set_sensitive(bEnable); + m_xLbShadowColor->set_sensitive(bEnable); + + m_xWndPresets->SetNoSelection(); + + // - no line - should not be selected + + if (m_xLbLineStyle->GetSelectEntryStyle() == SvxBorderLineStyle::NONE) + { + m_xLbLineStyle->SelectEntry(SvxBorderLineStyle::SOLID); + SelStyleHdl_Impl(*m_xLbLineStyle); + } + + const SfxUInt16Item* pHtmlModeItem = rSet->GetItemIfSet(SID_HTML_MODE, false); + if(!pHtmlModeItem) + { + if (SfxObjectShell* pShell = SfxObjectShell::Current()) + pHtmlModeItem = pShell->GetItem(SID_HTML_MODE); + } + if(pHtmlModeItem) + { + sal_uInt16 nHtmlMode = pHtmlModeItem->GetValue(); + if(nHtmlMode & HTMLMODE_ON) + { + // there are no shadows in Html-mode and only complete borders + m_xShadowFrame->set_sensitive(false); + + if( !(nSWMode & SwBorderModes::TABLE) ) + { + m_xUserDefFT->set_sensitive(false); + m_xFrameSelWin->set_sensitive(false); + m_xWndPresets->RemoveItem(3); + m_xWndPresets->RemoveItem(4); + m_xWndPresets->RemoveItem(5); + } + } + } + + LinesChanged_Impl( nullptr ); + if (m_xLeftMF->get_value(FieldUnit::NONE) == m_xRightMF->get_value(FieldUnit::NONE) && + m_xTopMF->get_value(FieldUnit::NONE) == m_xBottomMF->get_value(FieldUnit::NONE) && + m_xTopMF->get_value(FieldUnit::NONE) == m_xLeftMF->get_value(FieldUnit::NONE)) + { + mbSync = true; + } + else + mbSync = false; + m_xSynchronizeCB->set_active(mbSync); + + mbRemoveAdjacentCellBorders = false; + m_xRemoveAdjacentCellBordersCB->set_active(false); + m_xRemoveAdjacentCellBordersCB->set_sensitive(false); +} + +void SvxBorderTabPage::ChangesApplied() +{ + m_xLeftMF->save_value(); + m_xRightMF->save_value(); + m_xTopMF->save_value(); + m_xBottomMF->save_value(); + m_xMergeWithNextCB->save_state(); + m_xMergeAdjacentBordersCB->save_state(); +} + +DeactivateRC SvxBorderTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + +bool SvxBorderTabPage::FillItemSet( SfxItemSet* rCoreAttrs ) +{ + bool bAttrsChanged = false; + + SfxItemPool* pPool = rCoreAttrs->GetPool(); + + if (m_aFrameSel.IsBorderEnabled(svx::FrameBorderType::TLBR) && + m_aFrameSel.GetFrameBorderState(svx::FrameBorderType::TLBR) != svx::FrameBorderState::DontCare) + { + if (const SfxPoolItem* pOldItem = GetOldItem(*rCoreAttrs, SID_ATTR_BORDER_DIAG_TLBR)) + { + SvxLineItem aLineItem(*static_cast<const SvxLineItem*>(pOldItem)); + aLineItem.SetLine(m_aFrameSel.GetFrameBorderStyle(svx::FrameBorderType::TLBR)); + rCoreAttrs->Put(aLineItem); + bAttrsChanged = true; + } + } + + if (m_aFrameSel.IsBorderEnabled(svx::FrameBorderType::BLTR) && + m_aFrameSel.GetFrameBorderState(svx::FrameBorderType::BLTR) != svx::FrameBorderState::DontCare) + { + if (const SfxPoolItem* pOldItem = GetOldItem(*rCoreAttrs, SID_ATTR_BORDER_DIAG_BLTR)) + { + SvxLineItem aLineItem(*static_cast<const SvxLineItem*>(pOldItem)); + aLineItem.SetLine(m_aFrameSel.GetFrameBorderStyle(svx::FrameBorderType::BLTR)); + rCoreAttrs->Put(aLineItem); + bAttrsChanged = true; + } + } + + if (m_xShadowControls && m_xShadowControls->get_value_changed_from_saved()) + { + if (const SfxPoolItem* pOldItem = GetOldItem(*rCoreAttrs, mnShadowSlot)) + { + const SvxShadowItem& rOldShadowItem = *static_cast<const SvxShadowItem*>(pOldItem); + rCoreAttrs->Put(m_xShadowControls->GetControlValue(rOldShadowItem)); + bAttrsChanged = true; + } + } + + if (m_xMarginControls && m_xMarginControls->get_value_changed_from_saved()) + { + if (const SfxPoolItem* pOldItem = GetOldItem(*rCoreAttrs, SID_ATTR_ALIGN_MARGIN)) + { + const SvxMarginItem& rOldMarginItem = *static_cast<const SvxMarginItem*>(pOldItem); + rCoreAttrs->Put(m_xMarginControls->GetControlValue(rOldMarginItem)); + bAttrsChanged = true; + } + } + + if (m_xMergeAdjacentBordersCB->get_state_changed_from_saved()) + { + auto nState = m_xMergeAdjacentBordersCB->get_state(); + if (nState == TRISTATE_INDET) + { + sal_uInt16 nMergeAdjacentBordersId = pPool->GetWhich(SID_SW_COLLAPSING_BORDERS); + rCoreAttrs->ClearItem(nMergeAdjacentBordersId); + } + else + { + if (const SfxPoolItem* pOldItem = GetOldItem(*rCoreAttrs, SID_SW_COLLAPSING_BORDERS)) + { + std::unique_ptr<SfxBoolItem> xNewItem(static_cast<SfxBoolItem*>(pOldItem->Clone())); + xNewItem->SetValue(static_cast<bool>(nState)); + rCoreAttrs->Put(std::move(xNewItem)); + } + } + bAttrsChanged = true; + } + + if (m_xMergeWithNextCB->get_state_changed_from_saved()) + { + auto nState = m_xMergeWithNextCB->get_state(); + if (nState == TRISTATE_INDET) + { + sal_uInt16 nMergeWithNextId = pPool->GetWhich(SID_ATTR_BORDER_CONNECT); + rCoreAttrs->ClearItem(nMergeWithNextId); + } + else + { + if (const SfxPoolItem* pOldItem = GetOldItem(*rCoreAttrs, SID_ATTR_BORDER_CONNECT)) + { + std::unique_ptr<SfxBoolItem> xNewItem(static_cast<SfxBoolItem*>(pOldItem->Clone())); + xNewItem->SetValue(static_cast<bool>(nState)); + rCoreAttrs->Put(std::move(xNewItem)); + } + } + bAttrsChanged = true; + } + + bool bPut = true; + sal_uInt16 nBoxWhich = GetWhich( mnBoxSlot ); + sal_uInt16 nBoxInfoWhich = pPool->GetWhich( SID_ATTR_BORDER_INNER, false ); + const SfxItemSet& rOldSet = GetItemSet(); + SvxBoxItem aBoxItem ( nBoxWhich ); + SvxBoxInfoItem aBoxInfoItem ( nBoxInfoWhich ); + const SvxBoxItem* pOldBoxItem = static_cast<const SvxBoxItem*>(GetOldItem( *rCoreAttrs, mnBoxSlot )); + + MapUnit eCoreUnit = rOldSet.GetPool()->GetMetric( nBoxWhich ); + + + // outer border: + + std::pair<svx::FrameBorderType,SvxBoxItemLine> eTypes1[] = { + { svx::FrameBorderType::Top,SvxBoxItemLine::TOP }, + { svx::FrameBorderType::Bottom,SvxBoxItemLine::BOTTOM }, + { svx::FrameBorderType::Left,SvxBoxItemLine::LEFT }, + { svx::FrameBorderType::Right,SvxBoxItemLine::RIGHT }, + }; + + for (std::pair<svx::FrameBorderType,SvxBoxItemLine> const & i : eTypes1) + aBoxItem.SetLine( m_aFrameSel.GetFrameBorderStyle( i.first ), i.second ); + + + aBoxItem.SetRemoveAdjacentCellBorder( mbRemoveAdjacentCellBorders ); + // border hor/ver and TableFlag + + std::pair<svx::FrameBorderType,SvxBoxInfoItemLine> eTypes2[] = { + { svx::FrameBorderType::Horizontal,SvxBoxInfoItemLine::HORI }, + { svx::FrameBorderType::Vertical,SvxBoxInfoItemLine::VERT } + }; + for (std::pair<svx::FrameBorderType,SvxBoxInfoItemLine> const & j : eTypes2) + aBoxInfoItem.SetLine( m_aFrameSel.GetFrameBorderStyle( j.first ), j.second ); + + aBoxInfoItem.EnableHor( mbHorEnabled ); + aBoxInfoItem.EnableVer( mbVerEnabled ); + + + // inner distance + + if (m_xLeftMF->get_visible()) + { + // #i40405# enable distance controls for next dialog call + aBoxInfoItem.SetDist( true ); + + if( !mbUseMarginItem ) + { + // #106224# all edits empty: do nothing + if( !m_xLeftMF->get_text().isEmpty() || !m_xRightMF->get_text().isEmpty() || + !m_xTopMF->get_text().isEmpty() || !m_xBottomMF->get_text().isEmpty() ) + { + const SvxBoxInfoItem* pOldBoxInfoItem = GetOldItem( *rCoreAttrs, SID_ATTR_BORDER_INNER ); + if ( + !pOldBoxItem || + m_xLeftMF->get_value_changed_from_saved() || + m_xRightMF->get_value_changed_from_saved() || + m_xTopMF->get_value_changed_from_saved() || + m_xBottomMF->get_value_changed_from_saved() || + nMinValue == m_xLeftMF->get_value(FieldUnit::NONE) || + nMinValue == m_xRightMF->get_value(FieldUnit::NONE) || + nMinValue == m_xTopMF->get_value(FieldUnit::NONE) || + nMinValue == m_xBottomMF->get_value(FieldUnit::NONE) || + (pOldBoxInfoItem && !pOldBoxInfoItem->IsValid(SvxBoxInfoItemValidFlags::DISTANCE)) + ) + { + aBoxItem.SetDistance( static_cast<sal_uInt16>(GetCoreValue(*m_xLeftMF, eCoreUnit )), SvxBoxItemLine::LEFT ); + aBoxItem.SetDistance( static_cast<sal_uInt16>(GetCoreValue(*m_xRightMF, eCoreUnit )), SvxBoxItemLine::RIGHT ); + aBoxItem.SetDistance( static_cast<sal_uInt16>(GetCoreValue(*m_xTopMF, eCoreUnit )), SvxBoxItemLine::TOP ); + aBoxItem.SetDistance( static_cast<sal_uInt16>(GetCoreValue(*m_xBottomMF, eCoreUnit )), SvxBoxItemLine::BOTTOM); + } + else + { + aBoxItem.SetDistance(pOldBoxItem->GetDistance(SvxBoxItemLine::LEFT ), SvxBoxItemLine::LEFT); + aBoxItem.SetDistance(pOldBoxItem->GetDistance(SvxBoxItemLine::RIGHT), SvxBoxItemLine::RIGHT); + aBoxItem.SetDistance(pOldBoxItem->GetDistance(SvxBoxItemLine::TOP ), SvxBoxItemLine::TOP); + aBoxItem.SetDistance(pOldBoxItem->GetDistance(SvxBoxItemLine::BOTTOM), SvxBoxItemLine::BOTTOM); + } + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::DISTANCE ); + } + } + } + + + // note Don't Care Status in the Info-Item: + + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::TOP, m_aFrameSel.GetFrameBorderState( svx::FrameBorderType::Top ) != svx::FrameBorderState::DontCare ); + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::BOTTOM, m_aFrameSel.GetFrameBorderState( svx::FrameBorderType::Bottom ) != svx::FrameBorderState::DontCare ); + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::LEFT, m_aFrameSel.GetFrameBorderState( svx::FrameBorderType::Left ) != svx::FrameBorderState::DontCare ); + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::RIGHT, m_aFrameSel.GetFrameBorderState( svx::FrameBorderType::Right ) != svx::FrameBorderState::DontCare ); + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::HORI, m_aFrameSel.GetFrameBorderState( svx::FrameBorderType::Horizontal ) != svx::FrameBorderState::DontCare ); + aBoxInfoItem.SetValid( SvxBoxInfoItemValidFlags::VERT, m_aFrameSel.GetFrameBorderState( svx::FrameBorderType::Vertical ) != svx::FrameBorderState::DontCare ); + + + // Put or Clear of the border? + + bPut = true; + + if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nBoxWhich, false )) + { + bPut = aBoxItem != static_cast<const SvxBoxItem&>(rOldSet.Get(nBoxWhich)); + } + if( SfxItemState::DEFAULT == rOldSet.GetItemState( nBoxInfoWhich, false ) ) + { + const SvxBoxInfoItem& rOldBoxInfo = static_cast<const SvxBoxInfoItem&>( + rOldSet.Get(nBoxInfoWhich)); + + aBoxInfoItem.SetMinDist( rOldBoxInfo.IsMinDist() ); + aBoxInfoItem.SetDefDist( rOldBoxInfo.GetDefDist() ); + bPut |= (aBoxInfoItem != rOldBoxInfo ); + } + + if ( bPut ) + { + if ( !pOldBoxItem || *pOldBoxItem != aBoxItem ) + { + rCoreAttrs->Put( aBoxItem ); + bAttrsChanged = true; + } + const SfxPoolItem* pOld = GetOldItem( *rCoreAttrs, SID_ATTR_BORDER_INNER, false ); + + if ( !pOld || *static_cast<const SvxBoxInfoItem*>(pOld) != aBoxInfoItem ) + { + rCoreAttrs->Put( aBoxInfoItem ); + bAttrsChanged = true; + } + } + else + { + rCoreAttrs->ClearItem( nBoxWhich ); + rCoreAttrs->ClearItem( nBoxInfoWhich ); + } + + return bAttrsChanged; +} + +void SvxBorderTabPage::HideShadowControls() +{ + m_xShadowFrame->hide(); +} + +#define IID_PRE_CELL_NONE 1 +#define IID_PRE_CELL_ALL 2 +#define IID_PRE_CELL_LR 3 +#define IID_PRE_CELL_TB 4 +#define IID_PRE_CELL_L 5 +#define IID_PRE_CELL_DIAG 6 +#define IID_PRE_HOR_NONE 7 +#define IID_PRE_HOR_OUTER 8 +#define IID_PRE_HOR_HOR 9 +#define IID_PRE_HOR_ALL 10 +#define IID_PRE_HOR_OUTER2 11 +#define IID_PRE_VER_NONE 12 +#define IID_PRE_VER_OUTER 13 +#define IID_PRE_VER_VER 14 +#define IID_PRE_VER_ALL 15 +#define IID_PRE_VER_OUTER2 16 +#define IID_PRE_TABLE_NONE 17 +#define IID_PRE_TABLE_OUTER 18 +#define IID_PRE_TABLE_OUTERH 19 +#define IID_PRE_TABLE_ALL 20 +#define IID_PRE_TABLE_OUTER2 21 + +IMPL_LINK_NOARG(SvxBorderTabPage, SelPreHdl_Impl, ValueSet*, void) +{ + const svx::FrameBorderState SHOW = svx::FrameBorderState::Show; + const svx::FrameBorderState HIDE = svx::FrameBorderState::Hide; + const svx::FrameBorderState DONT = svx::FrameBorderState::DontCare; + + static const svx::FrameBorderState ppeStates[][ svx::FRAMEBORDERTYPE_COUNT ] = + { /* Left Right Top Bot Hor Ver TLBR BLTR */ +/* ---------------------+--------------------------------------------------- */ +/* IID_PRE_CELL_NONE */ { HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_CELL_ALL */ { SHOW, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_CELL_LR */ { SHOW, SHOW, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_CELL_TB */ { HIDE, HIDE, SHOW, SHOW, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_CELL_L */ { SHOW, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_CELL_DIAG */ { HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, SHOW, SHOW }, +/* IID_PRE_HOR_NONE */ { HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_HOR_OUTER */ { SHOW, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_HOR_HOR */ { HIDE, HIDE, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE }, +/* IID_PRE_HOR_ALL */ { SHOW, SHOW, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE }, +/* IID_PRE_HOR_OUTER2 */ { SHOW, SHOW, SHOW, SHOW, DONT, HIDE, HIDE, HIDE }, +/* IID_PRE_VER_NONE */ { HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_VER_OUTER */ { SHOW, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_VER_VER */ { SHOW, SHOW, HIDE, HIDE, HIDE, SHOW, HIDE, HIDE }, +/* IID_PRE_VER_ALL */ { SHOW, SHOW, SHOW, SHOW, HIDE, SHOW, HIDE, HIDE }, +/* IID_PRE_VER_OUTER2 */ { SHOW, SHOW, SHOW, SHOW, HIDE, DONT, HIDE, HIDE }, +/* IID_PRE_TABLE_NONE */ { HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_TABLE_OUTER */ { SHOW, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE, HIDE }, +/* IID_PRE_TABLE_OUTERH */ { SHOW, SHOW, SHOW, SHOW, SHOW, HIDE, HIDE, HIDE }, +/* IID_PRE_TABLE_ALL */ { SHOW, SHOW, SHOW, SHOW, SHOW, SHOW, HIDE, HIDE }, +/* IID_PRE_TABLE_OUTER2 */ { SHOW, SHOW, SHOW, SHOW, DONT, DONT, HIDE, HIDE } + }; + + // first hide and deselect all frame borders + m_aFrameSel.HideAllBorders(); + m_aFrameSel.DeselectAllBorders(); + + // Using image ID to find correct line in table above. + sal_uInt16 nLine = GetPresetImageId( m_xWndPresets->GetSelectedItemId() ) - 1; + + // Apply all styles from the table + for( int nBorder = 0; nBorder < svx::FRAMEBORDERTYPE_COUNT; ++nBorder ) + { + svx::FrameBorderType eBorder = svx::GetFrameBorderTypeFromIndex( nBorder ); + switch( ppeStates[ nLine ][ nBorder ] ) + { + case SHOW: m_aFrameSel.SelectBorder( eBorder ); break; + case HIDE: /* nothing to do */ break; + case DONT: m_aFrameSel.SetBorderDontCare( eBorder ); break; + } + } + + // Show all lines that have been selected above + if( m_aFrameSel.IsAnyBorderSelected() ) + { + // any visible style, but "no-line" in line list box? -> use hair-line + if (m_xLbLineStyle->GetSelectEntryStyle() == SvxBorderLineStyle::NONE) + m_xLbLineStyle->SelectEntry(SvxBorderLineStyle::SOLID); + + // set current style to all previously selected lines + SelStyleHdl_Impl(*m_xLbLineStyle); + SelColHdl_Impl(*m_xLbLineColor); + } + + // Presets ValueSet does not show a selection (used as push buttons). + m_xWndPresets->SetNoSelection(); + + LinesChanged_Impl( nullptr ); + UpdateRemoveAdjCellBorderCB( nLine + 1 ); +} + +IMPL_LINK_NOARG(SvxBorderTabPage, SelSdwHdl_Impl, ValueSet*, void) +{ + bool bEnable = m_xWndShadows->GetSelectedItemId() > 1; + m_xFtShadowSize->set_sensitive(bEnable); + m_xEdShadowSize->set_sensitive(bEnable); + m_xFtShadowColor->set_sensitive(bEnable); + m_xLbShadowColor->set_sensitive(bEnable); +} + +IMPL_LINK(SvxBorderTabPage, SelColHdl_Impl, ColorListBox&, rColorBox, void) +{ + Color aColor = rColorBox.GetSelectEntryColor(); + m_aFrameSel.SetColorToSelection(aColor); +} + +IMPL_LINK_NOARG(SvxBorderTabPage, ModifyWidthLBHdl_Impl, weld::ComboBox&, void) +{ + sal_Int32 nPos = m_xLineWidthLB->get_active(); + sal_Int32 nRemovedType = 0; + if (m_xLineWidthLB->get_values_changed_from_saved()) { + nRemovedType = m_aLineWidths.size() - m_xLineWidthLB->get_count(); + } + + SetLineWidth(m_aLineWidths[nPos + nRemovedType], nRemovedType); + + // Call the spinner handler to trigger all related modifications + ModifyWidthMFHdl_Impl(*m_xLineWidthMF); +} + +IMPL_LINK_NOARG(SvxBorderTabPage, ModifyWidthMFHdl_Impl, weld::MetricSpinButton&, void) +{ + sal_Int64 nVal = m_xLineWidthMF->get_value(FieldUnit::NONE); + + // for DOUBLE_THIN line style we cannot allow thinner line width then 1.10pt + if (m_xLbLineStyle->GetSelectEntryStyle() == SvxBorderLineStyle::DOUBLE_THIN) + m_xLineWidthMF->set_min(110, FieldUnit::NONE); + else + m_xLineWidthMF->set_min(5, FieldUnit::NONE); + + nVal = static_cast<sal_Int64>(vcl::ConvertDoubleValue( + nVal, + m_xLineWidthMF->get_digits(), + FieldUnit::POINT, MapUnit::MapTwip )); + m_xLbLineStyle->SetWidth( nVal ); + + m_aFrameSel.SetStyleToSelection( nVal, + m_xLbLineStyle->GetSelectEntryStyle() ); +} + +IMPL_LINK_NOARG(SvxBorderTabPage, SelStyleHdl_Impl, SvtLineListBox&, void) +{ + sal_Int64 nOldWidth = m_xLineWidthMF->get_value(FieldUnit::NONE); + + // for DOUBLE_THIN line style we cannot allow thinner line width then 1.10pt + if (m_xLbLineStyle->GetSelectEntryStyle() == SvxBorderLineStyle::DOUBLE_THIN) + m_xLineWidthMF->set_min(110, FieldUnit::NONE); + else + m_xLineWidthMF->set_min(5, FieldUnit::NONE); + + nOldWidth = static_cast<sal_Int64>(vcl::ConvertDoubleValue( + nOldWidth, + m_xLineWidthMF->get_digits(), + FieldUnit::POINT, + MapUnit::MapTwip)); + + const sal_Int64 nOldMinWidth = lcl_GetMinLineWidth(m_aFrameSel.getCurrentStyleLineStyle()); + const sal_Int64 nNewMinWidth = lcl_GetMinLineWidth(m_xLbLineStyle->GetSelectEntryStyle()); + + // auto change line-width if it doesn't correspond to minimal value + // let's change only in case when user has not changed the line-width into some custom value + sal_Int64 nNewWidth = (nOldMinWidth == nOldWidth) ? nNewMinWidth : nOldWidth; + + // if we had selected a predefined border width under SvxBorderLineWidth::Medium set the Medium as default + // otherwise if we had a cusom border width under 1.10pt then set the spinner to the maximum allowed value for double border styles + bool bNewDoubleHairline = m_xLbLineStyle->GetSelectEntryStyle() == SvxBorderLineStyle::DOUBLE_THIN && !m_xLineWidthMF->get_visible() && + (nOldWidth == SvxBorderLineWidth::Hairline || nOldWidth == SvxBorderLineWidth::VeryThin || nOldWidth == SvxBorderLineWidth::Thin); + if (bNewDoubleHairline && nNewWidth < SvxBorderLineWidth::Medium) + nNewWidth = SvxBorderLineWidth::Medium; + + // set value inside edit box + if (nOldWidth != nNewWidth) + { + const sal_Int64 nNewWidthPt = static_cast<sal_Int64>(vcl::ConvertDoubleValue( + nNewWidth, + m_xLineWidthMF->get_digits(), + MapUnit::MapTwip, + FieldUnit::POINT)); + SetLineWidth(nNewWidthPt); + } + + if (m_xLbLineStyle->GetSelectEntryStyle() == SvxBorderLineStyle::DOUBLE_THIN) + { + for (size_t i = 0; i < 3; i++) + { + m_xLineWidthLB->save_values_by_id(OUString::number(i)); + m_xLineWidthLB->remove_id(OUString::number(i)); + } + if (m_xLineWidthLB->get_active_id().isEmpty()) + m_xLineWidthLB->set_active_id("3"); + } + else + { + if (m_xLineWidthLB->get_values_changed_from_saved()) + { + for (size_t i = 0; i < 3; i++) + m_xLineWidthLB->append(i, OUString::number(i), m_xLineWidthLB->get_saved_values(i)); + m_xLineWidthLB->removeSavedValues(); + } + } + + // set value inside style box + m_aFrameSel.SetStyleToSelection( nNewWidth, + m_xLbLineStyle->GetSelectEntryStyle() ); +} + + +// ValueSet handling +sal_uInt16 SvxBorderTabPage::GetPresetImageId( sal_uInt16 nValueSetIdx ) const +{ + // table with all sets of predefined border styles + static const sal_uInt16 ppnImgIds[][ BORDER_PRESET_COUNT ] = + { + // simple cell without diagonal frame borders + { IID_PRE_CELL_NONE, IID_PRE_CELL_ALL, IID_PRE_CELL_LR, IID_PRE_CELL_TB, IID_PRE_CELL_L }, + // simple cell with diagonal frame borders + { IID_PRE_CELL_NONE, IID_PRE_CELL_ALL, IID_PRE_CELL_LR, IID_PRE_CELL_TB, IID_PRE_CELL_DIAG }, + // with horizontal inner frame border + { IID_PRE_HOR_NONE, IID_PRE_HOR_OUTER, IID_PRE_HOR_HOR, IID_PRE_HOR_ALL, IID_PRE_HOR_OUTER2 }, + // with vertical inner frame border + { IID_PRE_VER_NONE, IID_PRE_VER_OUTER, IID_PRE_VER_VER, IID_PRE_VER_ALL, IID_PRE_VER_OUTER2 }, + // with horizontal and vertical inner frame borders + { IID_PRE_TABLE_NONE, IID_PRE_TABLE_OUTER, IID_PRE_TABLE_OUTERH, IID_PRE_TABLE_ALL, IID_PRE_TABLE_OUTER2 } + }; + + // find correct set of presets + int nLine = 0; + if( !mbHorEnabled && !mbVerEnabled ) + nLine = (mbTLBREnabled || mbBLTREnabled) ? 1 : 0; + else if( mbHorEnabled && !mbVerEnabled ) + nLine = 2; + else if( !mbHorEnabled && mbVerEnabled ) + nLine = 3; + else + nLine = 4; + + DBG_ASSERT( (1 <= nValueSetIdx) && (nValueSetIdx <= BORDER_PRESET_COUNT), + "SvxBorderTabPage::GetPresetImageId - wrong index" ); + return ppnImgIds[ nLine ][ nValueSetIdx - 1 ]; +} + +TranslateId SvxBorderTabPage::GetPresetStringId( sal_uInt16 nValueSetIdx ) const +{ + // string resource IDs for each image (in order of the IID_PRE_* image IDs) + static const TranslateId pnStrIds[] = + { + RID_SVXSTR_TABLE_PRESET_NONE, + RID_SVXSTR_PARA_PRESET_ALL, + RID_SVXSTR_PARA_PRESET_LEFTRIGHT, + RID_SVXSTR_PARA_PRESET_TOPBOTTOM, + RID_SVXSTR_PARA_PRESET_ONLYLEFT, + RID_SVXSTR_PARA_PRESET_DIAGONAL, + + RID_SVXSTR_TABLE_PRESET_NONE, + RID_SVXSTR_TABLE_PRESET_ONLYOUTER, + RID_SVXSTR_HOR_PRESET_ONLYHOR, + RID_SVXSTR_TABLE_PRESET_OUTERALL, + RID_SVXSTR_TABLE_PRESET_OUTERINNER, + + RID_SVXSTR_TABLE_PRESET_NONE, + RID_SVXSTR_TABLE_PRESET_ONLYOUTER, + RID_SVXSTR_VER_PRESET_ONLYVER, + RID_SVXSTR_TABLE_PRESET_OUTERALL, + RID_SVXSTR_TABLE_PRESET_OUTERINNER, + + RID_SVXSTR_TABLE_PRESET_NONE, + RID_SVXSTR_TABLE_PRESET_ONLYOUTER, + RID_SVXSTR_TABLE_PRESET_OUTERHORI, + RID_SVXSTR_TABLE_PRESET_OUTERALL, + RID_SVXSTR_TABLE_PRESET_OUTERINNER + }; + return pnStrIds[ GetPresetImageId( nValueSetIdx ) - 1 ]; +} + +void SvxBorderTabPage::FillPresetVS() +{ + // basic initialization of the ValueSet + m_xWndPresets->SetStyle( m_xWndPresets->GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER ); + m_xWndPresets->SetColCount( BORDER_PRESET_COUNT ); + + // insert images and help texts + for( sal_uInt16 nVSIdx = 1; nVSIdx <= BORDER_PRESET_COUNT; ++nVSIdx ) + { + m_xWndPresets->InsertItem( nVSIdx ); + m_xWndPresets->SetItemImage(nVSIdx, m_aBorderImgVec[GetPresetImageId(nVSIdx) - 1]); + m_xWndPresets->SetItemText( nVSIdx, SvxResId( GetPresetStringId( nVSIdx ) ) ); + } + + // show the control + m_xWndPresets->SetNoSelection(); + m_xWndPresets->SetOptimalSize(); + m_xWndPresets->Show(); +} + +void SvxBorderTabPage::FillShadowVS() +{ + // basic initialization of the ValueSet + m_xWndShadows->SetStyle( m_xWndShadows->GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER ); + m_xWndShadows->SetColCount( BORDER_SHADOW_COUNT ); + + // string resource IDs for each image + static const TranslateId pnStrIds[ BORDER_SHADOW_COUNT ] = + { RID_CUISTR_SHADOW_STYLE_NONE, RID_CUISTR_SHADOW_STYLE_BOTTOMRIGHT, RID_CUISTR_SHADOW_STYLE_TOPRIGHT, RID_CUISTR_SHADOW_STYLE_BOTTOMLEFT, RID_CUISTR_SHADOW_STYLE_TOPLEFT }; + + // insert images and help texts + for( sal_uInt16 nVSIdx = 1; nVSIdx <= BORDER_SHADOW_COUNT; ++nVSIdx ) + { + m_xWndShadows->InsertItem( nVSIdx ); + m_xWndShadows->SetItemImage(nVSIdx, m_aShadowImgVec[nVSIdx-1]); + m_xWndShadows->SetItemText( nVSIdx, CuiResId( pnStrIds[ nVSIdx - 1 ] ) ); + } + + // show the control + m_xWndShadows->SelectItem( 1 ); + m_xWndShadows->SetOptimalSize(); + m_xWndShadows->Show(); +} + + +void SvxBorderTabPage::FillValueSets() +{ + FillPresetVS(); + FillShadowVS(); +} + +void SvxBorderTabPage::SetLineWidth( sal_Int64 nWidth, sal_Int32 nRemovedType ) +{ + if ( nWidth >= 0 ) + m_xLineWidthMF->set_value( nWidth, FieldUnit::POINT ); + + auto it = std::find_if( m_aLineWidths.begin(), m_aLineWidths.end(), + [nWidth](const int val) -> bool { return val == nWidth; } ); + + if ( it != m_aLineWidths.end() && *it >= 0 ) + { + // Select predefined value in combobox + m_xLineWidthMF->hide(); + m_xLineWidthLB->set_active(std::distance(m_aLineWidths.begin(), it) - nRemovedType); + } + else + { + // This is not one of predefined values. Show spinner + m_xLineWidthLB->set_active(m_aLineWidths.size() - nRemovedType -1); + m_xLineWidthMF->show(); + } +} + +static Color lcl_mediumColor( Color aMain, Color /*aDefault*/ ) +{ + return SvxBorderLine::threeDMediumColor( aMain ); +} + +void SvxBorderTabPage::FillLineListBox_Impl() +{ + using namespace ::com::sun::star::table::BorderLineStyle; + + static struct { + SvxBorderLineStyle mnStyle; + SvtLineListBox::ColorFunc mpColor1Fn; + SvtLineListBox::ColorFunc mpColor2Fn; + SvtLineListBox::ColorDistFunc mpColorDistFn; + } const aLines[] = { + // Simple lines + { SvxBorderLineStyle::SOLID, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::DOTTED, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::DASHED, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::FINE_DASHED, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::DASH_DOT, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::DASH_DOT_DOT, &sameColor, &sameColor, &sameDistColor }, + + // Double lines + { SvxBorderLineStyle::DOUBLE, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::DOUBLE_THIN, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::THINTHICK_SMALLGAP, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::THINTHICK_MEDIUMGAP, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::THINTHICK_LARGEGAP, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::THICKTHIN_SMALLGAP, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::THICKTHIN_MEDIUMGAP, &sameColor, &sameColor, &sameDistColor }, + { SvxBorderLineStyle::THICKTHIN_LARGEGAP, &sameColor, &sameColor, &sameDistColor }, + + { SvxBorderLineStyle::EMBOSSED, &SvxBorderLine::threeDLightColor, &SvxBorderLine::threeDDarkColor, &lcl_mediumColor }, + { SvxBorderLineStyle::ENGRAVED, &SvxBorderLine::threeDDarkColor, &SvxBorderLine::threeDLightColor, &lcl_mediumColor }, + + { SvxBorderLineStyle::OUTSET, &SvxBorderLine::lightColor, &SvxBorderLine::darkColor, &sameDistColor }, + { SvxBorderLineStyle::INSET, &SvxBorderLine::darkColor, &SvxBorderLine::lightColor, &sameDistColor } + }; + + m_xLbLineStyle->SetSourceUnit( FieldUnit::TWIP ); + + for (size_t i = 0; i < std::size(aLines); ++i) + { + if (!IsBorderLineStyleAllowed(aLines[i].mnStyle)) + continue; + + m_xLbLineStyle->InsertEntry( + SvxBorderLine::getWidthImpl(aLines[i].mnStyle), + aLines[i].mnStyle, + lcl_GetMinLineWidth(aLines[i].mnStyle), + aLines[i].mpColor1Fn, + aLines[i].mpColor2Fn, + aLines[i].mpColorDistFn); + } + + sal_Int64 nVal = m_xLineWidthMF->get_value(FieldUnit::NONE); + nVal = static_cast<sal_Int64>(vcl::ConvertDoubleValue(nVal, m_xLineWidthMF->get_digits(), + m_xLineWidthMF->get_unit(), MapUnit::MapTwip)); + m_xLbLineStyle->SetWidth( nVal ); +} + + +IMPL_LINK_NOARG(SvxBorderTabPage, LinesChanged_Impl, LinkParamNone*, void) +{ + if (!mbUseMarginItem && m_xLeftMF->get_visible()) + { + bool bLineSet = m_aFrameSel.IsAnyBorderVisible(); + bool bSpaceModified = mbLeftModified || + mbRightModified || + mbTopModified || + mbBottomModified; + + if(bLineSet) + { + if(!bSpaceModified) + { + m_xLeftMF->set_value(nMinValue, FieldUnit::NONE); + m_xRightMF->set_value(nMinValue, FieldUnit::NONE); + m_xTopMF->set_value(nMinValue, FieldUnit::NONE); + m_xBottomMF->set_value(nMinValue, FieldUnit::NONE); + } + } + else + { + m_xLeftMF->set_min(0, FieldUnit::NONE); + m_xRightMF->set_min(0, FieldUnit::NONE); + m_xTopMF->set_min(0, FieldUnit::NONE); + m_xBottomMF->set_min(0, FieldUnit::NONE); + } + // for tables everything is allowed + SvxBoxInfoItemValidFlags nValid = SvxBoxInfoItemValidFlags::TOP|SvxBoxInfoItemValidFlags::BOTTOM|SvxBoxInfoItemValidFlags::LEFT|SvxBoxInfoItemValidFlags::RIGHT; + + m_xLeftFT->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::LEFT) ); + m_xRightFT->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::RIGHT) ); + m_xTopFT->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::TOP) ); + m_xBottomFT->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::BOTTOM) ); + m_xLeftMF->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::LEFT) ); + m_xRightMF->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::RIGHT) ); + m_xTopMF->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::TOP) ); + m_xBottomMF->set_sensitive( bool(nValid & SvxBoxInfoItemValidFlags::BOTTOM) ); + m_xSynchronizeCB->set_sensitive(m_xRightMF->get_sensitive() || m_xTopMF->get_sensitive() || + m_xBottomMF->get_sensitive() || m_xLeftMF->get_sensitive()); + } + UpdateRemoveAdjCellBorderCB( SAL_MAX_UINT16 ); +} + + +IMPL_LINK( SvxBorderTabPage, ModifyDistanceHdl_Impl, weld::MetricSpinButton&, rField, void) +{ + if (&rField == m_xLeftMF.get()) + mbLeftModified = true; + else if (&rField == m_xRightMF.get()) + mbRightModified = true; + else if (&rField == m_xTopMF.get()) + mbTopModified = true; + else if (&rField == m_xBottomMF.get()) + mbBottomModified = true; + + if (mbSync) + { + const auto nVal = rField.get_value(FieldUnit::NONE); + if (&rField != m_xLeftMF.get()) + m_xLeftMF->set_value(nVal, FieldUnit::NONE); + if (&rField != m_xRightMF.get()) + m_xRightMF->set_value(nVal, FieldUnit::NONE); + if (&rField != m_xTopMF.get()) + m_xTopMF->set_value(nVal, FieldUnit::NONE); + if (&rField != m_xBottomMF.get()) + m_xBottomMF->set_value(nVal, FieldUnit::NONE); + } +} + +IMPL_LINK( SvxBorderTabPage, SyncHdl_Impl, weld::Toggleable&, rBox, void) +{ + mbSync = rBox.get_active(); +} + +IMPL_LINK( SvxBorderTabPage, RemoveAdjacentCellBorderHdl_Impl, weld::Toggleable&, rBox, void) +{ + mbRemoveAdjacentCellBorders = rBox.get_active(); +} + +void SvxBorderTabPage::UpdateRemoveAdjCellBorderCB( sal_uInt16 nPreset ) +{ + if( !bIsCalcDoc ) + return; + const SfxItemSet& rOldSet = GetItemSet(); + const SvxBoxInfoItem* pOldBoxInfoItem = GetOldItem( rOldSet, SID_ATTR_BORDER_INNER ); + const SvxBoxItem* pOldBoxItem = static_cast<const SvxBoxItem*>(GetOldItem( rOldSet, mnBoxSlot )); + if( !pOldBoxInfoItem || !pOldBoxItem ) + return; + std::pair<svx::FrameBorderType, SvxBoxInfoItemValidFlags> eTypes1[] = { + { svx::FrameBorderType::Top,SvxBoxInfoItemValidFlags::TOP }, + { svx::FrameBorderType::Bottom,SvxBoxInfoItemValidFlags::BOTTOM }, + { svx::FrameBorderType::Left,SvxBoxInfoItemValidFlags::LEFT }, + { svx::FrameBorderType::Right,SvxBoxInfoItemValidFlags::RIGHT }, + }; + SvxBoxItemLine const eTypes2[] = { + SvxBoxItemLine::TOP, + SvxBoxItemLine::BOTTOM, + SvxBoxItemLine::LEFT, + SvxBoxItemLine::RIGHT, + }; + + // Check if current selection involves deletion of at least one border + bool bBorderDeletionReq = false; + for ( size_t i=0; i < std::size( eTypes1 ); ++i ) + { + if( pOldBoxItem->GetLine( eTypes2[i] ) || !( pOldBoxInfoItem->IsValid( eTypes1[i].second ) ) ) + { + if( m_aFrameSel.GetFrameBorderState( eTypes1[i].first ) == svx::FrameBorderState::Hide ) + { + bBorderDeletionReq = true; + break; + } + } + } + + if( !bBorderDeletionReq && ( nPreset == IID_PRE_CELL_NONE || nPreset == IID_PRE_TABLE_NONE ) ) + bBorderDeletionReq = true; + + m_xRemoveAdjacentCellBordersCB->set_sensitive(bBorderDeletionReq); + + if( !bBorderDeletionReq ) + { + mbRemoveAdjacentCellBorders = false; + m_xRemoveAdjacentCellBordersCB->set_active(false); + } +} + +void SvxBorderTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt16Item* pSWModeItem = aSet.GetItem<SfxUInt16Item>(SID_SWMODE_TYPE, false); + const SfxUInt32Item* pFlagItem = aSet.GetItem<SfxUInt32Item>(SID_FLAG_TYPE, false); + if (pSWModeItem) + { + nSWMode = static_cast<SwBorderModes>(pSWModeItem->GetValue()); + // #i43593# + // show checkbox <m_xMergeWithNextCB> for format.paragraph + if ( nSWMode == SwBorderModes::PARA ) + { + m_xMergeWithNextCB->show(); + m_xPropertiesFrame->show(); + } + // show checkbox <m_xMergeAdjacentBordersCB> for format.paragraph + else if ( nSWMode == SwBorderModes::TABLE ) + { + m_xMergeAdjacentBordersCB->show(); + m_xPropertiesFrame->show(); + } + } + if (pFlagItem) + if ( ( pFlagItem->GetValue() & SVX_HIDESHADOWCTL ) == SVX_HIDESHADOWCTL ) + HideShadowControls(); +} + +void SvxBorderTabPage::SetTableMode() +{ + nSWMode = SwBorderModes::TABLE; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/chardlg.cxx b/cui/source/tabpages/chardlg.cxx new file mode 100644 index 000000000..5bf0975bb --- /dev/null +++ b/cui/source/tabpages/chardlg.cxx @@ -0,0 +1,3230 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <vcl/svapp.hxx> +#include <vcl/idle.hxx> +#include <svtools/ctrltool.hxx> +#include <sfx2/objsh.hxx> +#include <svx/svxids.hrc> +#include <svtools/unitconv.hxx> +#include <svl/cjkoptions.hxx> +#include <svl/ctloptions.hxx> +#include <chardlg.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/postitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/contouritem.hxx> +#include <editeng/langitem.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/shdditem.hxx> +#include <editeng/escapementitem.hxx> +#include <editeng/wrlmitem.hxx> +#include <editeng/cmapitem.hxx> +#include <editeng/kernitem.hxx> +#include <editeng/flstitem.hxx> +#include <editeng/autokernitem.hxx> +#include <editeng/colritem.hxx> +#include <dialmgr.hxx> +#include <sfx2/htmlmode.hxx> +#include <cui/cuicharmap.hxx> +#include "chardlg.h" +#include <editeng/emphasismarkitem.hxx> +#include <editeng/charreliefitem.hxx> +#include <editeng/twolinesitem.hxx> +#include <editeng/charhiddenitem.hxx> +#include <editeng/charscaleitem.hxx> +#include <editeng/charrotateitem.hxx> +#include <officecfg/Office/Common.hxx> +#include <strings.hrc> +#include <twolines.hrc> +#include <svl/intitem.hxx> +#include <svx/flagsdef.hxx> +#include <FontFeatures.hxx> +#include <FontFeaturesDialog.hxx> +#include <sal/log.hxx> +#include <osl/diagnose.h> +#include <o3tl/unit_conversion.hxx> +#include <o3tl/string_view.hxx> + +using namespace ::com::sun::star; + +// static ---------------------------------------------------------------- + +const WhichRangesContainer SvxCharNamePage::pNameRanges(svl::Items< + SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_WEIGHT, + SID_ATTR_CHAR_FONTHEIGHT, SID_ATTR_CHAR_FONTHEIGHT, + SID_ATTR_CHAR_COLOR, SID_ATTR_CHAR_COLOR, + SID_ATTR_CHAR_LANGUAGE, SID_ATTR_CHAR_LANGUAGE, + SID_ATTR_CHAR_CJK_FONT, SID_ATTR_CHAR_CJK_WEIGHT, + SID_ATTR_CHAR_CTL_FONT, SID_ATTR_CHAR_CTL_WEIGHT +>); + +const WhichRangesContainer SvxCharEffectsPage::pEffectsRanges(svl::Items< + SID_ATTR_CHAR_SHADOWED, SID_ATTR_CHAR_UNDERLINE, + SID_ATTR_CHAR_COLOR, SID_ATTR_CHAR_COLOR, + SID_ATTR_CHAR_CASEMAP, SID_ATTR_CHAR_CASEMAP, + SID_ATTR_FLASH, SID_ATTR_FLASH, + SID_ATTR_CHAR_EMPHASISMARK, SID_ATTR_CHAR_EMPHASISMARK, + SID_ATTR_CHAR_RELIEF, SID_ATTR_CHAR_RELIEF, + SID_ATTR_CHAR_HIDDEN, SID_ATTR_CHAR_HIDDEN, + SID_ATTR_CHAR_OVERLINE, SID_ATTR_CHAR_OVERLINE +>); + +const WhichRangesContainer SvxCharPositionPage::pPositionRanges(svl::Items< + SID_ATTR_CHAR_KERNING, SID_ATTR_CHAR_KERNING, + SID_ATTR_CHAR_ESCAPEMENT, SID_ATTR_CHAR_ESCAPEMENT, + SID_ATTR_CHAR_AUTOKERN, SID_ATTR_CHAR_AUTOKERN, + SID_ATTR_CHAR_ROTATED, SID_ATTR_CHAR_SCALEWIDTH, + SID_ATTR_CHAR_WIDTH_FIT_TO_LINE, SID_ATTR_CHAR_WIDTH_FIT_TO_LINE +>); + +const WhichRangesContainer SvxCharTwoLinesPage::pTwoLinesRanges(svl::Items< + SID_ATTR_CHAR_TWO_LINES, SID_ATTR_CHAR_TWO_LINES +>); + +// C-Function ------------------------------------------------------------ + +static bool StateToAttr( TriState aState ) +{ + return ( TRISTATE_TRUE == aState ); +} + +namespace +{ + void setPrevFontEscapement(SvxFont& _rFont,sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc ) + { + _rFont.SetPropr( nProp ); + _rFont.SetProprRel( nEscProp ); + _rFont.SetEscapement( nEsc ); + } +} + +inline SvxFont& SvxCharBasePage::GetPreviewFont() +{ + return m_aPreviewWin.GetFont(); +} + +inline SvxFont& SvxCharBasePage::GetPreviewCJKFont() +{ + return m_aPreviewWin.GetCJKFont(); +} + +inline SvxFont& SvxCharBasePage::GetPreviewCTLFont() +{ + return m_aPreviewWin.GetCTLFont(); +} + +SvxCharBasePage::SvxCharBasePage(weld::Container* pPage, weld::DialogController* pController, const OUString& rUIXMLDescription, const OString& rID, const SfxItemSet& rItemset) + : SfxTabPage(pPage, pController, rUIXMLDescription, rID, &rItemset) + , m_bPreviewBackgroundToCharacter( false ) +{ +} + +SvxCharBasePage::~SvxCharBasePage() +{ +} + +void SvxCharBasePage::ActivatePage(const SfxItemSet& rSet) +{ + m_aPreviewWin.SetFromItemSet(rSet, m_bPreviewBackgroundToCharacter); +} + +void SvxCharBasePage::SetPrevFontWidthScale( const SfxItemSet& rSet ) +{ + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH ); + if (rSet.GetItemState(nWhich)>=SfxItemState::DEFAULT) + { + const SvxCharScaleWidthItem &rItem = static_cast<const SvxCharScaleWidthItem&>( rSet.Get( nWhich ) ); + m_aPreviewWin.SetFontWidthScale(rItem.GetValue()); + } +} + +void SvxCharBasePage::SetPrevFontEscapement( sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc ) +{ + setPrevFontEscapement(GetPreviewFont(),nProp,nEscProp,nEsc); + setPrevFontEscapement(GetPreviewCJKFont(),nProp,nEscProp,nEsc); + setPrevFontEscapement(GetPreviewCTLFont(),nProp,nEscProp,nEsc); + m_aPreviewWin.Invalidate(); +} + + +// SvxCharNamePage_Impl -------------------------------------------------- + +struct SvxCharNamePage_Impl +{ + Idle m_aUpdateIdle { "cui SvxCharNamePage_Impl m_aUpdateIdle" }; + OUString m_aNoStyleText; + std::unique_ptr<FontList> m_pFontList; + int m_nExtraEntryPos; + bool m_bInSearchMode; + + SvxCharNamePage_Impl() + : m_nExtraEntryPos(std::numeric_limits<int>::max()) + , m_bInSearchMode(false) + + { + m_aUpdateIdle.SetPriority( TaskPriority::LOWEST ); + } +}; + +// class SvxCharNamePage ------------------------------------------------- + +SvxCharNamePage::SvxCharNamePage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInSet) + : SvxCharBasePage(pPage, pController, "cui/ui/charnamepage.ui", "CharNamePage", rInSet) + , m_pImpl(new SvxCharNamePage_Impl) + // Western + , m_xWestern(m_xBuilder->weld_notebook("nbWestern")) + , m_xWestFontNameFT(m_xBuilder->weld_label("lbWestFontname")) + , m_xWestFontStyleFT(m_xBuilder->weld_label("lbWestStyle")) + , m_xWestFontStyleLB(new FontStyleBox(m_xBuilder->weld_combo_box("cbWestStyle"))) + , m_xWestFontSizeFT(m_xBuilder->weld_label("lbWestSize")) + , m_xWestFontSizeLB(new FontSizeBox(m_xBuilder->weld_combo_box("cbWestSize"))) + , m_xWestFontLanguageFT(m_xBuilder->weld_label("lbWestLanguage")) + , m_xWestFontLanguageLB(new SvxLanguageBox(m_xBuilder->weld_combo_box("cbWestLanguage"))) + , m_xWestFontFeaturesButton(m_xBuilder->weld_button("btnWestFeatures")) + , m_xWestFontTypeFT(m_xBuilder->weld_label("lbWestFontinfo")) + , m_xCJK_CTL(m_xBuilder->weld_notebook("nbCJKCTL")) + // CJK + , m_xEastFontNameFT(m_xBuilder->weld_label("lbCJKFontname")) + , m_xEastFontStyleFT(m_xBuilder->weld_label("lbCJKStyle")) + , m_xEastFontStyleLB(new FontStyleBox(m_xBuilder->weld_combo_box("cbCJKStyle"))) + , m_xEastFontSizeFT(m_xBuilder->weld_label("lbCJKSize")) + , m_xEastFontSizeLB(new FontSizeBox(m_xBuilder->weld_combo_box("cbCJKSize"))) + , m_xEastFontLanguageFT(m_xBuilder->weld_label("lbCJKLanguage")) + , m_xEastFontLanguageLB(new SvxLanguageBox(m_xBuilder->weld_combo_box("cbCJKLanguage"))) + , m_xEastFontFeaturesButton(m_xBuilder->weld_button("btnCJKFeatures")) + , m_xEastFontTypeFT(m_xBuilder->weld_label("lbCJKFontinfo")) + // CTL + , m_xCTLFontNameFT(m_xBuilder->weld_label("lbCTLFontname")) + // tree + , m_xCTLFontStyleFT(m_xBuilder->weld_label("lbCTLStyle")) + , m_xCTLFontStyleLB(new FontStyleBox(m_xBuilder->weld_combo_box("cbCTLStyle"))) + , m_xCTLFontSizeFT(m_xBuilder->weld_label("lbCTLSize")) + , m_xCTLFontSizeLB(new FontSizeBox(m_xBuilder->weld_combo_box("cbCTLSize"))) + , m_xCTLFontLanguageFT(m_xBuilder->weld_label("lbCTLLanguage")) + , m_xCTLFontLanguageLB(new SvxLanguageBox(m_xBuilder->weld_combo_box("cbCTLLanguage"))) + , m_xCTLFontFeaturesButton(m_xBuilder->weld_button("btnCTLFeatures")) + , m_xCTLFontTypeFT(m_xBuilder->weld_label("lbCTLFontinfo")) + + , m_xVDev(*Application::GetDefaultDevice(), DeviceFormat::DEFAULT, DeviceFormat::DEFAULT) +{ + m_xPreviewWin.reset(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWin)); +#ifdef IOS + m_xPreviewWin->hide(); +#endif + m_pImpl->m_aNoStyleText = CuiResId( RID_CUISTR_CHARNAME_NOSTYLE ); + + std::unique_ptr<weld::EntryTreeView> xWestFontName = m_xBuilder->weld_entry_tree_view("gdWestern", "edWestFontName", "trWestFontName"); + std::unique_ptr<weld::EntryTreeView> xCJKFontName = m_xBuilder->weld_entry_tree_view("gdCJK", "edCJKFontName", "trCJKFontName"); + std::unique_ptr<weld::EntryTreeView> xCTLFontName = m_xBuilder->weld_entry_tree_view("gdCTL", "edCTLFontName", "trCTLFontName"); + + // 7 lines in the treeview + xWestFontName->set_height_request_by_rows(7); + xCJKFontName->set_height_request_by_rows(7); + xCTLFontName->set_height_request_by_rows(7); + + m_xWestFontNameLB = std::move(xWestFontName); + m_xEastFontNameLB = std::move(xCJKFontName); + m_xCTLFontNameLB = std::move(xCTLFontName); + + SvtCTLOptions aCTLLanguageOptions; + bool bShowCJK = SvtCJKOptions::IsCJKFontEnabled(); + bool bShowCTL = aCTLLanguageOptions.IsCTLFontEnabled(); + bool bShowNonWestern = bShowCJK || bShowCTL; + if (!bShowNonWestern) + { + m_xCJK_CTL->hide(); + m_xWestern->set_show_tabs(false); //hide single tab in case of Western only + } + else if (!bShowCJK) m_xCJK_CTL->remove_page("nbCJK"); + else if (!bShowCTL) m_xCJK_CTL->remove_page("nbCTL"); + + + //In MacOSX the standard dialogs name font-name, font-style as + //Family, Typeface + //In GNOME the standard dialogs name font-name, font-style as + //Family, Style + //In Windows the standard dialogs name font-name, font-style as + //Font, Style +#ifdef _WIN32 + OUString sFontFamilyString(CuiResId(RID_CUISTR_CHARNAME_FONT)); +#else + OUString sFontFamilyString(CuiResId(RID_CUISTR_CHARNAME_FAMILY)); +#endif + m_xWestFontNameFT->set_label(sFontFamilyString); + m_xCTLFontNameFT->set_label(sFontFamilyString); + m_xEastFontNameFT->set_label(sFontFamilyString); + +#ifdef MACOSX + OUString sFontStyleString(CuiResId(RID_CUISTR_CHARNAME_TYPEFACE)); +#else + OUString sFontStyleString(CuiResId(RID_CUISTR_CHARNAME_STYLE)); +#endif + m_xWestFontStyleFT->set_label(sFontStyleString); + m_xEastFontStyleFT->set_label(sFontStyleString); + m_xCTLFontStyleFT->set_label(sFontStyleString); + + m_xWestFontLanguageLB->SetLanguageList(SvxLanguageListFlags::WESTERN, true, false, true, true, + LANGUAGE_SYSTEM, css::i18n::ScriptType::LATIN); + m_xEastFontLanguageLB->SetLanguageList(SvxLanguageListFlags::CJK, true, false, true, true, + LANGUAGE_SYSTEM, css::i18n::ScriptType::ASIAN); + m_xCTLFontLanguageLB->SetLanguageList(SvxLanguageListFlags::CTL, true, false, true, true, + LANGUAGE_SYSTEM, css::i18n::ScriptType::COMPLEX); + int nVisibleChars = 15; + // read-only combobox / HasEntry asserts on set_width_char() + m_xWestFontLanguageLB->set_width_chars(nVisibleChars); + m_xEastFontLanguageLB->set_width_chars(nVisibleChars); + m_xCTLFontLanguageLB->set_width_chars(nVisibleChars); + + Initialize(); +} + +SvxCharNamePage::~SvxCharNamePage() +{ + m_pImpl.reset(); + m_xCTLFontStyleLB.reset(); + m_xEastFontLanguageLB.reset(); + m_xWestFontStyleLB.reset(); + m_xCTLFontSizeLB.reset(); + m_xEastFontSizeLB.reset(); + m_xWestFontSizeLB.reset(); + m_xWestFontLanguageLB.reset(); + m_xPreviewWin.reset(); + m_xCTLFontLanguageLB.reset(); + m_xEastFontLanguageLB.reset(); +} + +void SvxCharNamePage::Initialize() +{ + // to handle the changes of the other pages + SetExchangeSupport(); + + Link<weld::ComboBox&,void> aLink = LINK(this, SvxCharNamePage, FontModifyComboBoxHdl_Impl); + m_xWestFontNameLB->connect_changed(aLink); + m_xWestFontStyleLB->connect_changed(aLink); + m_xWestFontSizeLB->connect_changed(aLink); + m_xWestFontLanguageLB->connect_changed(aLink); + + m_xWestFontFeaturesButton->connect_clicked(LINK(this, SvxCharNamePage, FontFeatureButtonClicked)); + + m_xEastFontNameLB->connect_changed(aLink); + m_xEastFontStyleLB->connect_changed(aLink); + m_xEastFontSizeLB->connect_changed(aLink); + m_xEastFontLanguageLB->connect_changed(aLink); + m_xEastFontFeaturesButton->connect_clicked(LINK(this, SvxCharNamePage, FontFeatureButtonClicked)); + + m_xCTLFontNameLB->connect_changed(aLink); + m_xCTLFontStyleLB->connect_changed(aLink); + m_xCTLFontSizeLB->connect_changed(aLink); + m_xCTLFontLanguageLB->connect_changed(aLink); + m_xCTLFontFeaturesButton->connect_clicked(LINK(this, SvxCharNamePage, FontFeatureButtonClicked)); + + m_pImpl->m_aUpdateIdle.SetInvokeHandler( LINK( this, SvxCharNamePage, UpdateHdl_Impl ) ); +} + +const FontList* SvxCharNamePage::GetFontList() const +{ + if ( !m_pImpl->m_pFontList ) + { + /* #110771# SvxFontListItem::GetFontList can return NULL */ + if (SfxObjectShell* pDocSh = SfxObjectShell::Current()) + { + const SfxPoolItem* pItem = pDocSh->GetItem( SID_ATTR_CHAR_FONTLIST ); + if ( pItem != nullptr ) + { + DBG_ASSERT(nullptr != static_cast<const SvxFontListItem*>(pItem)->GetFontList(), + "Where is the font list?"); + m_pImpl->m_pFontList = static_cast<const SvxFontListItem*>(pItem )->GetFontList()->Clone(); + } + } + if(!m_pImpl->m_pFontList) + { + m_pImpl->m_pFontList.reset(new FontList( Application::GetDefaultDevice() )); + } + } + + return m_pImpl->m_pFontList.get(); +} + + +namespace +{ + FontMetric calcFontMetrics( SvxFont& _rFont, + SvxCharNamePage const * _pPage, + const weld::ComboBox* _pFontNameLB, + const FontStyleBox* _pFontStyleLB, + const FontSizeBox* _pFontSizeLB, + const SvxLanguageBox* _pLanguageLB, + const FontList* _pFontList, + sal_uInt16 _nFontWhich, + sal_uInt16 _nFontHeightWhich) + { + Size aSize = _rFont.GetFontSize(); + aSize.setWidth( 0 ); + FontMetric aFontMetrics; + OUString sFontName(_pFontNameLB->get_active_text()); + bool bFontAvailable = _pFontList->IsAvailable( sFontName ); + if (bFontAvailable || _pFontNameLB->get_value_changed_from_saved()) + aFontMetrics = _pFontList->Get(sFontName, _pFontStyleLB->get_active_text()); + else + { + //get the font from itemset + SfxItemState eState = _pPage->GetItemSet().GetItemState( _nFontWhich ); + if ( eState >= SfxItemState::DEFAULT ) + { + const SvxFontItem* pFontItem = static_cast<const SvxFontItem*>(&( _pPage->GetItemSet().Get( _nFontWhich ) )); + aFontMetrics.SetFamilyName(pFontItem->GetFamilyName()); + aFontMetrics.SetStyleName(pFontItem->GetStyleName()); + aFontMetrics.SetFamily(pFontItem->GetFamily()); + aFontMetrics.SetPitch(pFontItem->GetPitch()); + aFontMetrics.SetCharSet(pFontItem->GetCharSet()); + } + } + if ( _pFontSizeLB->IsRelative() ) + { + DBG_ASSERT( _pPage->GetItemSet().GetParent(), "No parent set" ); + const SvxFontHeightItem& rOldItem = static_cast<const SvxFontHeightItem&>(_pPage->GetItemSet().GetParent()->Get( _nFontHeightWhich )); + + // old value, scaled + tools::Long nHeight; + if ( _pFontSizeLB->IsPtRelative() ) + nHeight = rOldItem.GetHeight() + + o3tl::convert(_pFontSizeLB->get_value(), o3tl::Length::pt, + o3tl::Length::twip) / 10; + else + nHeight = static_cast<tools::Long>(rOldItem.GetHeight() * _pFontSizeLB->get_value() / 100); + + // conversion twips for the example-window + aSize.setHeight( + ItemToControl( nHeight, _pPage->GetItemSet().GetPool()->GetMetric( _nFontHeightWhich ), FieldUnit::TWIP ) ); + } + else if ( !_pFontSizeLB->get_active_text().isEmpty() ) + aSize.setHeight(o3tl::convert(_pFontSizeLB->get_value(), o3tl::Length::pt, + o3tl::Length::twip) / 10); + else + aSize.setHeight( 200 ); // default 10pt + aFontMetrics.SetFontSize( aSize ); + + _rFont.SetLanguage(_pLanguageLB->get_active_id()); + + _rFont.SetFamily( aFontMetrics.GetFamilyType() ); + _rFont.SetFamilyName( aFontMetrics.GetFamilyName() ); + _rFont.SetStyleName( aFontMetrics.GetStyleName() ); + _rFont.SetPitch( aFontMetrics.GetPitch() ); + _rFont.SetCharSet( aFontMetrics.GetCharSet() ); + _rFont.SetWeight( aFontMetrics.GetWeight() ); + _rFont.SetItalic( aFontMetrics.GetItalic() ); + _rFont.SetFontSize( aFontMetrics.GetFontSize() ); + + return aFontMetrics; + } +} + + +void SvxCharNamePage::UpdatePreview_Impl() +{ + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + // Font + const FontList* pFontList = GetFontList(); + + FontMetric aWestFontMetric = calcFontMetrics(rFont, this, m_xWestFontNameLB.get(), + m_xWestFontStyleLB.get(), m_xWestFontSizeLB.get(), m_xWestFontLanguageLB.get(), + pFontList, GetWhich(SID_ATTR_CHAR_FONT), + GetWhich(SID_ATTR_CHAR_FONTHEIGHT)); + + m_xWestFontTypeFT->set_label(pFontList->GetFontMapText(aWestFontMetric)); + + FontMetric aEastFontMetric = calcFontMetrics(rCJKFont, this, m_xEastFontNameLB.get(), + m_xEastFontStyleLB.get(), m_xEastFontSizeLB.get(), m_xEastFontLanguageLB.get(), + pFontList, GetWhich(SID_ATTR_CHAR_CJK_FONT), + GetWhich(SID_ATTR_CHAR_CJK_FONTHEIGHT)); + + m_xEastFontTypeFT->set_label(pFontList->GetFontMapText(aEastFontMetric)); + + FontMetric aCTLFontMetric = calcFontMetrics(rCTLFont, + this, m_xCTLFontNameLB.get(), m_xCTLFontStyleLB.get(), m_xCTLFontSizeLB.get(), + m_xCTLFontLanguageLB.get(), pFontList, GetWhich(SID_ATTR_CHAR_CTL_FONT), + GetWhich(SID_ATTR_CHAR_CTL_FONTHEIGHT)); + + m_xCTLFontTypeFT->set_label(pFontList->GetFontMapText(aCTLFontMetric)); + + m_aPreviewWin.Invalidate(); +} +void SvxCharNamePage::EnableFeatureButton(const weld::Widget& rNameBox) +{ + OUString sFontName; + weld::Button* pButton= nullptr; + if (m_xWestFontNameLB.get() == &rNameBox) + { + sFontName = m_xWestFontNameLB->get_active_text(); + pButton= m_xWestFontFeaturesButton.get(); + } + else if (m_xEastFontNameLB.get() == &rNameBox) + { + sFontName = m_xEastFontNameLB->get_active_text(); + pButton=m_xEastFontFeaturesButton.get(); + } + else if (m_xCTLFontNameLB.get() == &rNameBox) + { + sFontName = m_xCTLFontNameLB->get_active_text(); + pButton= m_xCTLFontFeaturesButton.get(); + } + else + { + SAL_WARN( "cui.tabpages", "invalid font name box" ); + return; + } + + bool bEnable = !getFontFeatureList(sFontName, *m_xVDev).empty(); + + pButton->set_sensitive(bEnable); +} + +void SvxCharNamePage::FillStyleBox_Impl(const weld::Widget& rNameBox) +{ + const FontList* pFontList = GetFontList(); + DBG_ASSERT( pFontList, "no fontlist" ); + + FontStyleBox* pStyleBox = nullptr; + OUString sFontName; + + if (m_xWestFontNameLB.get() == &rNameBox) + { + pStyleBox = m_xWestFontStyleLB.get(); + sFontName = m_xWestFontNameLB->get_active_text(); + } + else if (m_xEastFontNameLB.get() == &rNameBox) + { + pStyleBox = m_xEastFontStyleLB.get(); + sFontName = m_xEastFontStyleLB->get_active_text(); + } + else if (m_xCTLFontNameLB.get() == &rNameBox) + { + pStyleBox = m_xCTLFontStyleLB.get(); + sFontName = m_xCTLFontNameLB->get_active_text(); + } + else + { + SAL_WARN( "cui.tabpages", "invalid font name box" ); + return; + } + + pStyleBox->Fill(sFontName, pFontList); + + if ( !m_pImpl->m_bInSearchMode ) + return; + + // additional entries for the search: + // "not bold" and "not italic" + OUString aEntry = m_pImpl->m_aNoStyleText; + const char sS[] = "%1"; + aEntry = aEntry.replaceFirst( sS, pFontList->GetBoldStr() ); + m_pImpl->m_nExtraEntryPos = pStyleBox->get_count(); + pStyleBox->append_text( aEntry ); + aEntry = m_pImpl->m_aNoStyleText; + aEntry = aEntry.replaceFirst( sS, pFontList->GetItalicStr() ); + pStyleBox->append_text(aEntry); +} + +void SvxCharNamePage::FillSizeBox_Impl(const weld::Widget& rNameBox) +{ + const FontList* pFontList = GetFontList(); + DBG_ASSERT( pFontList, "no fontlist" ); + + FontSizeBox* pSizeBox = nullptr; + + if (m_xWestFontNameLB.get() == &rNameBox) + { + pSizeBox = m_xWestFontSizeLB.get(); + } + else if (m_xEastFontNameLB.get() == &rNameBox) + { + pSizeBox = m_xEastFontSizeLB.get(); + } + else if (m_xCTLFontNameLB.get() == &rNameBox) + { + pSizeBox = m_xCTLFontSizeLB.get(); + } + else + { + SAL_WARN( "cui.tabpages", "invalid font name box" ); + return; + } + + pSizeBox->Fill( pFontList ); +} + +namespace +{ + void FillFontNames(weld::ComboBox& rBox, const FontList& rList) + { + // insert fonts + sal_uInt16 nFontCount = rList.GetFontNameCount(); + std::vector<weld::ComboBoxEntry> aVector; + aVector.reserve(nFontCount); + for (sal_uInt16 i = 0; i < nFontCount; ++i) + { + const FontMetric& rFontMetric = rList.GetFontName(i); + aVector.emplace_back(rFontMetric.GetFamilyName()); + } + rBox.insert_vector(aVector, false); + } +} + +void SvxCharNamePage::Reset_Impl( const SfxItemSet& rSet, LanguageGroup eLangGrp ) +{ + weld::ComboBox* pNameBox = nullptr; + weld::Label* pStyleLabel = nullptr; + FontStyleBox* pStyleBox = nullptr; + weld::Label* pSizeLabel = nullptr; + FontSizeBox* pSizeBox = nullptr; + weld::Label* pLangFT = nullptr; + SvxLanguageBox* pLangBox = nullptr; + sal_uInt16 nWhich = 0; + + switch ( eLangGrp ) + { + case Western : + pNameBox = m_xWestFontNameLB.get(); + pStyleLabel = m_xWestFontStyleFT.get(); + pStyleBox = m_xWestFontStyleLB.get(); + pSizeLabel = m_xWestFontSizeFT.get(); + pSizeBox = m_xWestFontSizeLB.get(); + pLangFT = m_xWestFontLanguageFT.get(); + pLangBox = m_xWestFontLanguageLB.get(); + nWhich = GetWhich( SID_ATTR_CHAR_FONT ); + break; + + case Asian : + pNameBox = m_xEastFontNameLB.get(); + pStyleLabel = m_xEastFontStyleFT.get(); + pStyleBox = m_xEastFontStyleLB.get(); + pSizeLabel = m_xEastFontSizeFT.get(); + pSizeBox = m_xEastFontSizeLB.get(); + pLangFT = m_xEastFontLanguageFT.get(); + pLangBox = m_xEastFontLanguageLB.get(); + nWhich = GetWhich( SID_ATTR_CHAR_CJK_FONT ); + break; + + case Ctl : + pNameBox = m_xCTLFontNameLB.get(); + pStyleLabel = m_xCTLFontStyleFT.get(); + pStyleBox = m_xCTLFontStyleLB.get(); + pSizeLabel = m_xCTLFontSizeFT.get(); + pSizeBox = m_xCTLFontSizeLB.get(); + pLangFT = m_xCTLFontLanguageFT.get(); + pLangBox = m_xCTLFontLanguageLB.get(); + nWhich = GetWhich( SID_ATTR_CHAR_CTL_FONT ); + break; + } + + const FontList* pFontList = GetFontList(); + FillFontNames(*pNameBox, *pFontList); + + const SvxFontItem* pFontItem = nullptr; + SfxItemState eState = rSet.GetItemState( nWhich ); + + if ( eState >= SfxItemState::DEFAULT ) + { + pFontItem = static_cast<const SvxFontItem*>(&( rSet.Get( nWhich ) )); + const OUString &rName = pFontItem->GetFamilyName(); + int nIndex = pNameBox->find_text(rName); + pNameBox->set_active(nIndex); + // tdf#122992 if it didn't exist in the list, set the entry text to it anyway + if (nIndex == -1) + pNameBox->set_entry_text(rName); + } + else + { + pNameBox->set_active_text( OUString() ); + } + + FillStyleBox_Impl(*pNameBox); + + bool bStyle = false; + bool bStyleAvailable = true; + FontItalic eItalic = ITALIC_NONE; + FontWeight eWeight = WEIGHT_NORMAL; + switch ( eLangGrp ) + { + case Western : nWhich = GetWhich( SID_ATTR_CHAR_POSTURE ); break; + case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_POSTURE ); break; + case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_POSTURE ); break; + } + eState = rSet.GetItemState( nWhich ); + + if ( eState >= SfxItemState::DEFAULT ) + { + const SvxPostureItem& rItem = static_cast<const SvxPostureItem&>(rSet.Get( nWhich )); + eItalic = rItem.GetValue(); + bStyle = true; + } + bStyleAvailable = bStyleAvailable && (eState >= SfxItemState::DONTCARE); + + switch ( eLangGrp ) + { + case Western : nWhich = GetWhich( SID_ATTR_CHAR_WEIGHT ); break; + case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_WEIGHT ); break; + case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_WEIGHT ); break; + } + eState = rSet.GetItemState( nWhich ); + + if ( eState >= SfxItemState::DEFAULT ) + { + const SvxWeightItem& rItem = static_cast<const SvxWeightItem&>(rSet.Get( nWhich )); + eWeight = rItem.GetValue(); + } + else + bStyle = false; + bStyleAvailable = bStyleAvailable && (eState >= SfxItemState::DONTCARE); + + // currently chosen font + if ( bStyle && pFontItem ) + { + FontMetric aFontMetric = pFontList->Get( pFontItem->GetFamilyName(), eWeight, eItalic ); + pStyleBox->set_active_text( pFontList->GetStyleName( aFontMetric ) ); + } + else if ( !m_pImpl->m_bInSearchMode || !bStyle ) + { + pStyleBox->set_active_text( OUString() ); + } + else if ( bStyle ) + { + FontMetric aFontMetric = pFontList->Get( OUString(), eWeight, eItalic ); + pStyleBox->set_active_text( pFontList->GetStyleName( aFontMetric ) ); + } + if (!bStyleAvailable) + { + pStyleBox->set_sensitive(false); + pStyleLabel->set_sensitive(false); + } + + FillSizeBox_Impl(*pNameBox); + switch ( eLangGrp ) + { + case Western : nWhich = GetWhich( SID_ATTR_CHAR_FONTHEIGHT ); break; + case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT ); break; + case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT ); break; + } + eState = rSet.GetItemState( nWhich ); + + if ( pSizeBox->IsRelativeMode() ) + { + MapUnit eUnit = rSet.GetPool()->GetMetric( nWhich ); + const SvxFontHeightItem& rItem = static_cast<const SvxFontHeightItem&>(rSet.Get( nWhich )); + + if( rItem.GetProp() != 100 || MapUnit::MapRelative != rItem.GetPropUnit() ) + { + bool bPtRel = MapUnit::MapPoint == rItem.GetPropUnit(); + pSizeBox->SetPtRelative( bPtRel ); + pSizeBox->set_value( bPtRel ? static_cast<short>(rItem.GetProp()) * 10 : rItem.GetProp() ); + } + else + { + pSizeBox->SetRelative(false); + pSizeBox->set_value( CalcToPoint( rItem.GetHeight(), eUnit, 10 ) ); + } + } + else if ( eState >= SfxItemState::DEFAULT ) + { + MapUnit eUnit = rSet.GetPool()->GetMetric( nWhich ); + const SvxFontHeightItem& rItem = static_cast<const SvxFontHeightItem&>(rSet.Get( nWhich )); + pSizeBox->set_value( CalcToPoint( rItem.GetHeight(), eUnit, 10 ) ); + } + else + { + pSizeBox->set_active_or_entry_text(OUString()); + if ( eState <= SfxItemState::DISABLED ) + { + pSizeBox->set_sensitive(false); + pSizeLabel->set_sensitive(false); + } + } + + switch ( eLangGrp ) + { + case Western : nWhich = GetWhich( SID_ATTR_CHAR_LANGUAGE ); break; + case Asian : nWhich = GetWhich( SID_ATTR_CHAR_CJK_LANGUAGE ); break; + case Ctl : nWhich = GetWhich( SID_ATTR_CHAR_CTL_LANGUAGE ); break; + } + pLangBox->set_active(-1); + eState = rSet.GetItemState( nWhich ); + + switch ( eState ) + { + case SfxItemState::UNKNOWN: + pLangFT->hide(); + pLangBox->hide(); + break; + + case SfxItemState::DISABLED: + pLangFT->set_sensitive(false); + pLangBox->set_sensitive(false); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxLanguageItem& rItem = static_cast<const SvxLanguageItem&>(rSet.Get( nWhich )); + LanguageType eLangType = rItem.GetValue(); + DBG_ASSERT( eLangType != LANGUAGE_SYSTEM, "LANGUAGE_SYSTEM not allowed" ); + if (eLangType != LANGUAGE_DONTKNOW) + pLangBox->set_active_id(eLangType); + break; + } + case SfxItemState::DONTCARE: + break; + } + + OUString sMapText(pFontList->GetFontMapText( + pFontList->Get(pNameBox->get_active_text(), pStyleBox->get_active_text()))); + + switch (eLangGrp) + { + case Western: + m_xWestFontTypeFT->set_label(sMapText); + break; + case Asian: + m_xEastFontTypeFT->set_label(sMapText); + break; + case Ctl: + m_xCTLFontTypeFT->set_label(sMapText); + break; + } + + EnableFeatureButton(*pNameBox); + + // save these settings + pNameBox->save_value(); + pStyleBox->save_value(); + pSizeBox->save_value(); + pLangBox->save_active_id(); +} + +bool SvxCharNamePage::FillItemSet_Impl( SfxItemSet& rSet, LanguageGroup eLangGrp ) +{ + bool bModified = false; + + weld::ComboBox* pNameBox = nullptr; + FontStyleBox* pStyleBox = nullptr; + FontSizeBox* pSizeBox = nullptr; + SvxLanguageBox* pLangBox = nullptr; + sal_uInt16 nWhich = 0; + sal_uInt16 nSlot = 0; + + switch ( eLangGrp ) + { + case Western : + pNameBox = m_xWestFontNameLB.get(); + pStyleBox = m_xWestFontStyleLB.get(); + pSizeBox = m_xWestFontSizeLB.get(); + pLangBox = m_xWestFontLanguageLB.get(); + nSlot = SID_ATTR_CHAR_FONT; + break; + + case Asian : + pNameBox = m_xEastFontNameLB.get(); + pStyleBox = m_xEastFontStyleLB.get(); + pSizeBox = m_xEastFontSizeLB.get(); + pLangBox = m_xEastFontLanguageLB.get(); + nSlot = SID_ATTR_CHAR_CJK_FONT; + break; + + case Ctl : + pNameBox = m_xCTLFontNameLB.get(); + pStyleBox = m_xCTLFontStyleLB.get(); + pSizeBox = m_xCTLFontSizeLB.get(); + pLangBox = m_xCTLFontLanguageLB.get(); + nSlot = SID_ATTR_CHAR_CTL_FONT; + break; + } + + nWhich = GetWhich( nSlot ); + const SfxPoolItem* pItem = nullptr; + const SfxItemSet& rOldSet = GetItemSet(); + const SfxPoolItem* pOld = nullptr; + + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + + bool bChanged = true; + const OUString& rFontName = pNameBox->get_active_text(); + const FontList* pFontList = GetFontList(); + OUString aStyleBoxText = pStyleBox->get_active_text(); + int nEntryPos = pStyleBox->find_text(aStyleBoxText); + if (nEntryPos >= m_pImpl->m_nExtraEntryPos) + aStyleBoxText.clear(); + FontMetric aInfo( pFontList->Get( rFontName, aStyleBoxText ) ); + SvxFontItem aFontItem( aInfo.GetFamilyType(), aInfo.GetFamilyName(), aInfo.GetStyleName(), + aInfo.GetPitch(), aInfo.GetCharSet(), nWhich ); + pOld = GetOldItem( rSet, nSlot ); + + if ( pOld ) + { + const SvxFontItem& rItem = *static_cast<const SvxFontItem*>(pOld); + + if ( rItem.GetFamilyName() == aFontItem.GetFamilyName() ) + bChanged = false; + } + + if ( !bChanged ) + bChanged = pNameBox->get_saved_value().isEmpty(); + + if ( !bChanged && pExampleSet && + pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + static_cast<const SvxFontItem*>(pItem)->GetFamilyName() != aFontItem.GetFamilyName() ) + bChanged = true; + + if ( bChanged && !rFontName.isEmpty() ) + { + rSet.Put( aFontItem ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet.ClearItem( nWhich ); + + + bChanged = true; + switch ( eLangGrp ) + { + case Western : nSlot = SID_ATTR_CHAR_WEIGHT; break; + case Asian : nSlot = SID_ATTR_CHAR_CJK_WEIGHT; break; + case Ctl : nSlot = SID_ATTR_CHAR_CTL_WEIGHT; break; + } + nWhich = GetWhich( nSlot ); + FontWeight eWeight = aInfo.GetWeight(); + if ( nEntryPos >= m_pImpl->m_nExtraEntryPos ) + eWeight = WEIGHT_NORMAL; + SvxWeightItem aWeightItem( eWeight, nWhich ); + pOld = GetOldItem( rSet, nSlot ); + + if ( pOld ) + { + const SvxWeightItem& rItem = *static_cast<const SvxWeightItem*>(pOld); + + if ( rItem.GetValue() == aWeightItem.GetValue() ) + bChanged = false; + } + + if ( !bChanged ) + { + bChanged = pStyleBox->get_saved_value().isEmpty(); + + if ( m_pImpl->m_bInSearchMode && bChanged && + aInfo.GetWeight() == WEIGHT_NORMAL && aInfo.GetItalic() != ITALIC_NONE ) + bChanged = false; + } + + if ( !bChanged && pExampleSet && + pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + static_cast<const SvxWeightItem*>(pItem)->GetValue() != aWeightItem.GetValue() ) + bChanged = true; + + if ( nEntryPos >= m_pImpl->m_nExtraEntryPos ) + bChanged = ( nEntryPos == m_pImpl->m_nExtraEntryPos ); + + OUString aText( pStyleBox->get_active_text() ); // Tristate, then text empty + + if ( bChanged && !aText.isEmpty() ) + { + rSet.Put( aWeightItem ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet.InvalidateItem(nWhich); + + bChanged = true; + switch ( eLangGrp ) + { + case Western : nSlot = SID_ATTR_CHAR_POSTURE; break; + case Asian : nSlot = SID_ATTR_CHAR_CJK_POSTURE; break; + case Ctl : nSlot = SID_ATTR_CHAR_CTL_POSTURE; break; + } + nWhich = GetWhich( nSlot ); + FontItalic eItalic = aInfo.GetItalic(); + if ( nEntryPos >= m_pImpl->m_nExtraEntryPos ) + eItalic = ITALIC_NONE; + SvxPostureItem aPostureItem( eItalic, nWhich ); + pOld = GetOldItem( rSet, nSlot ); + + if ( pOld ) + { + const SvxPostureItem& rItem = *static_cast<const SvxPostureItem*>(pOld); + + if ( rItem.GetValue() == aPostureItem.GetValue() ) + bChanged = false; + } + + if ( !bChanged ) + { + bChanged = pStyleBox->get_saved_value().isEmpty(); + + if ( m_pImpl->m_bInSearchMode && bChanged && + aInfo.GetItalic() == ITALIC_NONE && aInfo.GetWeight() != WEIGHT_NORMAL ) + bChanged = false; + } + + if ( !bChanged && pExampleSet && + pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + static_cast<const SvxPostureItem*>(pItem)->GetValue() != aPostureItem.GetValue() ) + bChanged = true; + + if ( nEntryPos >= m_pImpl->m_nExtraEntryPos ) + bChanged = ( nEntryPos == ( m_pImpl->m_nExtraEntryPos + 1 ) ); + + if ( bChanged && !aText.isEmpty() ) + { + rSet.Put( aPostureItem ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet.InvalidateItem(nWhich); + + // FontSize + tools::Long nSize = pSizeBox->get_value(); + + if ( pSizeBox->get_active_text().isEmpty() ) // GetValue() returns the min-value + nSize = 0; + tools::Long nSavedSize = pSizeBox->get_saved_value(); + const bool bRel = pSizeBox->IsRelative(); + + switch ( eLangGrp ) + { + case Western : nSlot = SID_ATTR_CHAR_FONTHEIGHT; break; + case Asian : nSlot = SID_ATTR_CHAR_CJK_FONTHEIGHT; break; + case Ctl : nSlot = SID_ATTR_CHAR_CTL_FONTHEIGHT; break; + } + nWhich = GetWhich( nSlot ); + const SvxFontHeightItem* pOldHeight = static_cast<const SvxFontHeightItem*>(GetOldItem( rSet, nSlot )); + bChanged = ( nSize != nSavedSize ); + + if ( !bChanged && pExampleSet && + pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET ) + { + float fSize = static_cast<float>(nSize) / 10; + tools::Long nVal = CalcToUnit( fSize, rSet.GetPool()->GetMetric( nWhich ) ); + if ( static_cast<const SvxFontHeightItem*>(pItem)->GetHeight() != static_cast<sal_uInt32>(nVal) ) + bChanged = true; + } + + if ( bChanged || !pOldHeight || + bRel != ( MapUnit::MapRelative != pOldHeight->GetPropUnit() || 100 != pOldHeight->GetProp() ) ) + { + MapUnit eUnit = rSet.GetPool()->GetMetric( nWhich ); + if ( pSizeBox->IsRelative() ) + { + DBG_ASSERT( GetItemSet().GetParent(), "No parent set" ); + const SvxFontHeightItem& rOldItem = + static_cast<const SvxFontHeightItem&>(GetItemSet().GetParent()->Get( nWhich )); + + SvxFontHeightItem aHeight( 240, 100, nWhich ); + if ( pSizeBox->IsPtRelative() ) + aHeight.SetHeight( rOldItem.GetHeight(), static_cast<sal_uInt16>( nSize / 10 ), MapUnit::MapPoint, eUnit ); + else + aHeight.SetHeight( rOldItem.GetHeight(), static_cast<sal_uInt16>(nSize) ); + rSet.Put( aHeight ); + } + else + { + float fSize = static_cast<float>(nSize) / 10; + rSet.Put( SvxFontHeightItem( CalcToUnit( fSize, eUnit ), 100, nWhich ) ); + } + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet.InvalidateItem(nWhich); + + bChanged = true; + switch ( eLangGrp ) + { + case Western : nSlot = SID_ATTR_CHAR_LANGUAGE; break; + case Asian : nSlot = SID_ATTR_CHAR_CJK_LANGUAGE; break; + case Ctl : nSlot = SID_ATTR_CHAR_CTL_LANGUAGE; break; + } + nWhich = GetWhich( nSlot ); + pOld = GetOldItem( rSet, nSlot ); + + // For language list boxes acting as ComboBox, check for, add and select an + // edited entry. + if (pLangBox == m_xWestFontLanguageLB.get()) + { + switch (pLangBox->GetEditedAndValid()) + { + case SvxLanguageBox::EditedAndValid::No: + ; // nothing to do + break; + case SvxLanguageBox::EditedAndValid::Valid: + { + const int nPos = pLangBox->SaveEditedAsEntry(); + if (nPos != -1) + pLangBox->set_active(nPos); + } + break; + case SvxLanguageBox::EditedAndValid::Invalid: + pLangBox->set_active_id(pLangBox->get_saved_active_id()); + break; + } + } + + int nLangPos = pLangBox->get_active(); + LanguageType eLangType = pLangBox->get_active_id(); + + if (pOld) + { + const SvxLanguageItem& rItem = *static_cast<const SvxLanguageItem*>(pOld); + if (nLangPos == -1 || eLangType == rItem.GetValue()) + bChanged = false; + } + + if (!bChanged) + bChanged = pLangBox->get_active_id_changed_from_saved(); + + if (bChanged && nLangPos != -1) + { + rSet.Put(SvxLanguageItem(eLangType, nWhich)); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet.InvalidateItem(nWhich); + + return bModified; +} + +IMPL_LINK_NOARG(SvxCharNamePage, UpdateHdl_Impl, Timer *, void) +{ + UpdatePreview_Impl(); +} + +IMPL_LINK(SvxCharNamePage, FontModifyComboBoxHdl_Impl, weld::ComboBox&, rBox, void) +{ + FontModifyHdl_Impl(rBox); +} + +IMPL_LINK(SvxCharNamePage, FontFeatureButtonClicked, weld::Button&, rButton, void) +{ + OUString sFontName; + weld::ComboBox* pNameBox = nullptr; + + if (&rButton == m_xWestFontFeaturesButton.get()) + { + pNameBox = m_xWestFontNameLB.get(); + sFontName = GetPreviewFont().GetFamilyName(); + } + else if (&rButton == m_xEastFontFeaturesButton.get()) + { + pNameBox = m_xEastFontNameLB.get(); + sFontName = GetPreviewCJKFont().GetFamilyName(); + } + else if (&rButton == m_xCTLFontFeaturesButton.get()) + { + pNameBox = m_xCTLFontNameLB.get(); + sFontName = GetPreviewCTLFont().GetFamilyName(); + } + + if (!sFontName.isEmpty() && pNameBox) + { + cui::FontFeaturesDialog aDialog(GetFrameWeld(), sFontName); + if (aDialog.run() == RET_OK) + { + pNameBox->set_entry_text(aDialog.getResultFontName()); + UpdatePreview_Impl(); + } + } +} + +void SvxCharNamePage::FontModifyHdl_Impl(const weld::Widget& rNameBox) +{ + m_pImpl->m_aUpdateIdle.Start(); + + if (m_xWestFontNameLB.get() == &rNameBox || m_xEastFontNameLB.get() == &rNameBox || m_xCTLFontNameLB.get() == &rNameBox) + { + FillStyleBox_Impl(rNameBox); + FillSizeBox_Impl(rNameBox); + EnableFeatureButton(rNameBox); + } +} + +void SvxCharNamePage::ActivatePage( const SfxItemSet& rSet ) +{ + SvxCharBasePage::ActivatePage( rSet ); + + UpdatePreview_Impl(); // instead of asynchronous calling in ctor +} + +DeactivateRC SvxCharNamePage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +std::unique_ptr<SfxTabPage> SvxCharNamePage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxCharNamePage>(pPage, pController, *rSet ); +} + +void SvxCharNamePage::Reset( const SfxItemSet* rSet ) +{ + Reset_Impl( *rSet, Western ); + Reset_Impl( *rSet, Asian ); + Reset_Impl( *rSet, Ctl ); + + SetPrevFontWidthScale( *rSet ); + UpdatePreview_Impl(); +} + +void SvxCharNamePage::ChangesApplied() +{ + m_xWestFontNameLB->save_value(); + m_xWestFontStyleLB->save_value(); + m_xWestFontSizeLB->save_value(); + m_xWestFontLanguageLB->save_active_id(); + m_xEastFontNameLB->save_value(); + m_xEastFontStyleLB->save_value(); + m_xEastFontSizeLB->save_value(); + m_xEastFontLanguageLB->save_active_id(); + m_xCTLFontNameLB->save_value(); + m_xCTLFontStyleLB->save_value(); + m_xCTLFontSizeLB->save_value(); + m_xCTLFontLanguageLB->save_active_id(); +} + +bool SvxCharNamePage::FillItemSet( SfxItemSet* rSet ) +{ + bool bModified = FillItemSet_Impl( *rSet, Western ); + bModified |= FillItemSet_Impl( *rSet, Asian ); + bModified |= FillItemSet_Impl( *rSet, Ctl ); + return bModified; +} + +void SvxCharNamePage::SetFontList( const SvxFontListItem& rItem ) +{ + m_pImpl->m_pFontList = rItem.GetFontList()->Clone(); +} + +namespace +{ + void enableRelativeMode( SvxCharNamePage const * _pPage, FontSizeBox* _pFontSizeLB, sal_uInt16 _nHeightWhich ) + { + _pFontSizeLB->EnableRelativeMode( 5, 995 ); // min 5%, max 995%, step 5 + + const SvxFontHeightItem& rHeightItem = + static_cast<const SvxFontHeightItem&>(_pPage->GetItemSet().GetParent()->Get( _nHeightWhich )); + MapUnit eUnit = _pPage->GetItemSet().GetPool()->GetMetric( _nHeightWhich ); + short nCurHeight = + static_cast< short >( CalcToPoint( rHeightItem.GetHeight(), eUnit, 1 ) * 10 ); + + // based on the current height: + // - negative until minimum of 2 pt + // - positive until maximum of 999 pt + _pFontSizeLB->EnablePtRelativeMode( sal::static_int_cast< short >(-(nCurHeight - 20)), (9999 - nCurHeight) ); + } +} + +void SvxCharNamePage::EnableRelativeMode() +{ + DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no ParentSet!" ); + enableRelativeMode(this,m_xWestFontSizeLB.get(),GetWhich( SID_ATTR_CHAR_FONTHEIGHT )); + enableRelativeMode(this,m_xEastFontSizeLB.get(),GetWhich( SID_ATTR_CHAR_CJK_FONTHEIGHT )); + enableRelativeMode(this,m_xCTLFontSizeLB.get(),GetWhich( SID_ATTR_CHAR_CTL_FONTHEIGHT )); +} + +void SvxCharNamePage::EnableSearchMode() +{ + m_pImpl->m_bInSearchMode = true; +} + +void SvxCharNamePage::DisableControls( sal_uInt16 nDisable ) +{ + if ( DISABLE_HIDE_LANGUAGE & nDisable ) + { + if ( m_xWestFontLanguageFT ) m_xWestFontLanguageFT->hide(); + if ( m_xWestFontLanguageLB ) m_xWestFontLanguageLB->hide(); + if ( m_xEastFontLanguageFT ) m_xEastFontLanguageFT->hide(); + if ( m_xEastFontLanguageLB ) m_xEastFontLanguageLB->hide(); + if ( m_xCTLFontLanguageFT ) m_xCTLFontLanguageFT->hide(); + if ( m_xCTLFontLanguageLB ) m_xCTLFontLanguageLB->hide(); + } +} + +void SvxCharNamePage::PageCreated(const SfxAllItemSet& aSet) +{ + const SvxFontListItem* pFontListItem = aSet.GetItem<SvxFontListItem>(SID_ATTR_CHAR_FONTLIST, false); + const SfxUInt32Item* pFlagItem = aSet.GetItem<SfxUInt32Item>(SID_FLAG_TYPE, false); + const SfxUInt16Item* pDisableItem = aSet.GetItem<SfxUInt16Item>(SID_DISABLE_CTL, false); + if (pFontListItem) + SetFontList(*pFontListItem); + + if (pFlagItem) + { + sal_uInt32 nFlags=pFlagItem->GetValue(); + if ( ( nFlags & SVX_RELATIVE_MODE ) == SVX_RELATIVE_MODE ) + EnableRelativeMode(); + if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER ) + // the writer uses SID_ATTR_BRUSH as font background + m_bPreviewBackgroundToCharacter = true; + } + if (pDisableItem) + DisableControls(pDisableItem->GetValue()); +} +// class SvxCharEffectsPage ---------------------------------------------- + +SvxCharEffectsPage::SvxCharEffectsPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInSet) + : SvxCharBasePage(pPage, pController, "cui/ui/effectspage.ui", "EffectsPage", rInSet) + , m_bOrigFontColor(false) + , m_bNewFontColor(false) + , m_bEnableNoneFontColor(false) + , m_xFontColorFT(m_xBuilder->weld_label("fontcolorft")) + , m_xFontColorLB(new ColorListBox(m_xBuilder->weld_menu_button("fontcolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xFontTransparencyFT(m_xBuilder->weld_label("fonttransparencyft")) + , m_xFontTransparencyMtr( + m_xBuilder->weld_metric_spin_button("fonttransparencymtr", FieldUnit::PERCENT)) + , m_xEffectsFT(m_xBuilder->weld_label("effectsft")) + , m_xEffectsLB(m_xBuilder->weld_combo_box("effectslb")) + , m_xReliefFT(m_xBuilder->weld_label("reliefft")) + , m_xReliefLB(m_xBuilder->weld_combo_box("relieflb")) + , m_xOutlineBtn(m_xBuilder->weld_check_button("outlinecb")) + , m_xShadowBtn(m_xBuilder->weld_check_button("shadowcb")) + , m_xHiddenBtn(m_xBuilder->weld_check_button("hiddencb")) + , m_xOverlineLB(m_xBuilder->weld_combo_box("overlinelb")) + , m_xOverlineColorFT(m_xBuilder->weld_label("overlinecolorft")) + , m_xOverlineColorLB(new ColorListBox(m_xBuilder->weld_menu_button("overlinecolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xStrikeoutLB(m_xBuilder->weld_combo_box("strikeoutlb")) + , m_xUnderlineLB(m_xBuilder->weld_combo_box("underlinelb")) + , m_xUnderlineColorFT(m_xBuilder->weld_label("underlinecolorft")) + , m_xUnderlineColorLB(new ColorListBox(m_xBuilder->weld_menu_button("underlinecolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xIndividualWordsBtn(m_xBuilder->weld_check_button("individualwordscb")) + , m_xEmphasisFT(m_xBuilder->weld_label("emphasisft")) + , m_xEmphasisLB(m_xBuilder->weld_combo_box("emphasislb")) + , m_xPositionFT(m_xBuilder->weld_label("positionft")) + , m_xPositionLB(m_xBuilder->weld_combo_box("positionlb")) + , m_xA11yWarningFT(m_xBuilder->weld_label("a11ywarning")) +{ + m_xPreviewWin.reset(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWin)); +#ifdef IOS + m_xPreviewWin->hide(); +#endif + m_xFontColorLB->SetSlotId(SID_ATTR_CHAR_COLOR); + m_xOverlineColorLB->SetSlotId(SID_ATTR_CHAR_COLOR); + m_xUnderlineColorLB->SetSlotId(SID_ATTR_CHAR_COLOR); + Initialize(); +} + +void SvxCharEffectsPage::EnableNoneFontColor() +{ + m_xFontColorLB->SetSlotId(SID_ATTR_CHAR_COLOR, true); + m_bEnableNoneFontColor = true; +} + +SvxCharEffectsPage::~SvxCharEffectsPage() +{ + m_xUnderlineColorLB.reset(); + m_xOverlineColorLB.reset(); + m_xFontTransparencyMtr.reset(); + m_xFontColorLB.reset(); +} + +void SvxCharEffectsPage::Initialize() +{ + // to handle the changes of the other pages + SetExchangeSupport(); + + // HTML-Mode + const SfxUInt16Item* pHtmlModeItem = GetItemSet().GetItemIfSet( SID_HTML_MODE, false ); + if ( !pHtmlModeItem) + { + if (SfxObjectShell* pShell = SfxObjectShell::Current()) + pHtmlModeItem = pShell->GetItem( SID_HTML_MODE ); + } + if (pHtmlModeItem) + { + m_nHtmlMode = pHtmlModeItem->GetValue(); + if ( ( m_nHtmlMode & HTMLMODE_ON ) == HTMLMODE_ON ) + { + //!!! hide some controls please + } + } + + m_xFontColorLB->SetSelectHdl(LINK(this, SvxCharEffectsPage, ColorBoxSelectHdl_Impl)); + m_xFontTransparencyMtr->connect_value_changed( + LINK(this, SvxCharEffectsPage, ModifyFontTransparencyHdl_Impl)); + + // handler + Link<weld::ComboBox&,void> aLink = LINK( this, SvxCharEffectsPage, SelectListBoxHdl_Impl ); + m_xUnderlineLB->connect_changed( aLink ); + m_xUnderlineColorLB->SetSelectHdl(LINK(this, SvxCharEffectsPage, ColorBoxSelectHdl_Impl)); + m_xOverlineLB->connect_changed( aLink ); + m_xOverlineColorLB->SetSelectHdl(LINK(this, SvxCharEffectsPage, ColorBoxSelectHdl_Impl)); + m_xStrikeoutLB->connect_changed( aLink ); + m_xEmphasisLB->connect_changed( aLink ); + m_xPositionLB->connect_changed( aLink ); + m_xEffectsLB->connect_changed( aLink ); + m_xReliefLB->connect_changed( aLink ); + + m_xUnderlineLB->set_active( 0 ); + m_xOverlineLB->set_active( 0 ); + m_xStrikeoutLB->set_active( 0 ); + m_xEmphasisLB->set_active( 0 ); + m_xPositionLB->set_active( 0 ); + SelectHdl_Impl(nullptr); + SelectHdl_Impl(m_xEmphasisLB.get()); + + m_xEffectsLB->set_active( 0 ); + + m_xHiddenBtn->connect_toggled(LINK(this, SvxCharEffectsPage, HiddenBtnClickHdl)); + m_xIndividualWordsBtn->connect_toggled(LINK(this, SvxCharEffectsPage, CbClickHdl_Impl)); + m_xOutlineBtn->connect_toggled(LINK(this, SvxCharEffectsPage, OutlineBtnClickHdl)); + m_xShadowBtn->connect_toggled(LINK(this, SvxCharEffectsPage, ShadowBtnClickHdl)); + + if ( !SvtCJKOptions::IsAsianTypographyEnabled() ) + { + m_xEmphasisFT->hide(); + m_xEmphasisLB->hide(); + m_xPositionFT->hide(); + m_xPositionLB->hide(); + } + + m_xA11yWarningFT->set_visible(officecfg::Office::Common::Accessibility::IsAutomaticFontColor::get()); +} + +void SvxCharEffectsPage::UpdatePreview_Impl() +{ + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + + const Color& rSelectedColor = m_xFontColorLB->GetSelectEntryColor(); + rFont.SetColor(rSelectedColor); + rCJKFont.SetColor(rSelectedColor); + rCTLFont.SetColor(rSelectedColor); + m_aPreviewWin.AutoCorrectFontColor(); // handle color COL_AUTO + + FontLineStyle eUnderline = static_cast<FontLineStyle>(m_xUnderlineLB->get_active_id().toInt32()); + FontLineStyle eOverline = static_cast<FontLineStyle>(m_xOverlineLB->get_active_id().toInt32()); + FontStrikeout eStrikeout = static_cast<FontStrikeout>(m_xStrikeoutLB->get_active_id().toInt32()); + rFont.SetUnderline( eUnderline ); + rCJKFont.SetUnderline( eUnderline ); + rCTLFont.SetUnderline( eUnderline ); + m_aPreviewWin.SetTextLineColor( m_xUnderlineColorLB->GetSelectEntryColor() ); + rFont.SetOverline( eOverline ); + rCJKFont.SetOverline( eOverline ); + rCTLFont.SetOverline( eOverline ); + m_aPreviewWin.SetOverlineColor( m_xOverlineColorLB->GetSelectEntryColor() ); + rFont.SetStrikeout( eStrikeout ); + rCJKFont.SetStrikeout( eStrikeout ); + rCTLFont.SetStrikeout( eStrikeout ); + + auto nEmphasis = m_xEmphasisLB->get_active(); + if (nEmphasis != -1) + { + bool bUnder = (CHRDLG_POSITION_UNDER == m_xPositionLB->get_active_id().toInt32()); + FontEmphasisMark eMark = static_cast<FontEmphasisMark>(nEmphasis); + eMark |= bUnder ? FontEmphasisMark::PosBelow : FontEmphasisMark::PosAbove; + rFont.SetEmphasisMark( eMark ); + rCJKFont.SetEmphasisMark( eMark ); + rCTLFont.SetEmphasisMark( eMark ); + } + + auto nRelief = m_xReliefLB->get_active(); + if (nRelief != -1) + { + rFont.SetRelief( static_cast<FontRelief>(nRelief) ); + rCJKFont.SetRelief( static_cast<FontRelief>(nRelief) ); + rCTLFont.SetRelief( static_cast<FontRelief>(nRelief) ); + } + + rFont.SetOutline( StateToAttr( m_xOutlineBtn->get_state() ) ); + rCJKFont.SetOutline( rFont.IsOutline() ); + rCTLFont.SetOutline( rFont.IsOutline() ); + + rFont.SetShadow( StateToAttr( m_xShadowBtn->get_state() ) ); + rCJKFont.SetShadow( rFont.IsShadow() ); + rCTLFont.SetShadow( rFont.IsShadow() ); + + auto nCapsPos = m_xEffectsLB->get_active(); + if (nCapsPos != -1) + { + SvxCaseMap eCaps = static_cast<SvxCaseMap>(nCapsPos); + rFont.SetCaseMap( eCaps ); + rCJKFont.SetCaseMap( eCaps ); + // #i78474# small caps do not exist in CTL fonts + rCTLFont.SetCaseMap( eCaps == SvxCaseMap::SmallCaps ? SvxCaseMap::NotMapped : eCaps ); + } + + bool bWordLine = StateToAttr( m_xIndividualWordsBtn->get_state() ); + rFont.SetWordLineMode( bWordLine ); + rCJKFont.SetWordLineMode( bWordLine ); + rCTLFont.SetWordLineMode( bWordLine ); + + m_aPreviewWin.Invalidate(); +} + +void SvxCharEffectsPage::SetCaseMap_Impl( SvxCaseMap eCaseMap ) +{ + if ( SvxCaseMap::End > eCaseMap ) + m_xEffectsLB->set_active( + sal::static_int_cast< sal_Int32 >( eCaseMap ) ); + else + { + // not mapped + m_xEffectsLB->set_active(-1); + } + + UpdatePreview_Impl(); +} + +void SvxCharEffectsPage::ResetColor_Impl( const SfxItemSet& rSet ) +{ + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_COLOR ); + SfxItemState eState = rSet.GetItemState( nWhich ); + + m_bOrigFontColor = false; + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_xFontColorFT->hide(); + m_xFontColorLB->hide(); + break; + + case SfxItemState::DISABLED: + m_xFontColorFT->set_sensitive(false); + m_xFontColorLB->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + //Related: tdf#106080 if there is no font color, then allow "none" + //as a color so the listbox can display that state. + EnableNoneFontColor(); + m_xFontColorLB->SetNoSelection(); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + + const SvxColorItem& rItem = static_cast<const SvxColorItem&>(rSet.Get( nWhich )); + Color aColor = rItem.GetValue(); + rFont.SetColor(aColor); + rCJKFont.SetColor(aColor); + rCTLFont.SetColor(aColor); + m_aPreviewWin.AutoCorrectFontColor(); // handle color COL_AUTO + + m_aPreviewWin.Invalidate(); + + Color aRGBColor = aColor; + if (aRGBColor.IsTransparent() && aColor != COL_AUTO) + { + aRGBColor.SetAlpha(255); + } + m_xFontColorLB->SelectEntry(aRGBColor); + + if (m_xFontTransparencyMtr->get_visible() && aColor != COL_AUTO) + { + double fTransparency = (255 - aColor.GetAlpha()) * 100.0 / 255; + m_xFontTransparencyMtr->set_value(basegfx::fround(fTransparency), + FieldUnit::PERCENT); + } + + m_aOrigFontColor = aColor; + m_bOrigFontColor = true; + break; + } + } + m_bNewFontColor = false; +} + +bool SvxCharEffectsPage::FillItemSetColor_Impl( SfxItemSet& rSet ) +{ + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_COLOR ); + const SfxItemSet& rOldSet = GetItemSet(); + + svx::NamedThemedColor aSelectedColor; + bool bChanged = m_bNewFontColor; + + if (bChanged) + { + aSelectedColor = m_xFontColorLB->GetSelectedEntryThemedColor(); + + if (m_xFontTransparencyMtr->get_value_changed_from_saved()) + { + double fTransparency + = m_xFontTransparencyMtr->get_value(FieldUnit::PERCENT) * 255.0 / 100; + aSelectedColor.m_aColor.SetAlpha(255 - static_cast<sal_uInt8>(basegfx::fround(fTransparency))); + } + + if (m_bOrigFontColor) + bChanged = aSelectedColor.m_aColor != m_aOrigFontColor; + if (m_bEnableNoneFontColor && bChanged && aSelectedColor.m_aColor == COL_NONE_COLOR) + bChanged = false; + } + + if (bChanged) + { + SvxColorItem aItem( aSelectedColor.m_aColor, nWhich ); + + if (aSelectedColor.m_nThemeIndex != -1) + { + // The color was picked from the theme palette, remember its index. + aItem.GetThemeColor().SetThemeIndex(aSelectedColor.m_nThemeIndex); + aItem.GetThemeColor().SetLumMod(aSelectedColor.m_nLumMod); + aItem.GetThemeColor().SetLumOff(aSelectedColor.m_nLumOff); + } + + rSet.Put(aItem); + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet.InvalidateItem(nWhich); + + return bChanged; +} + +IMPL_LINK( SvxCharEffectsPage, SelectListBoxHdl_Impl, weld::ComboBox&, rBox, void ) +{ + SelectHdl_Impl(&rBox); +} + +void SvxCharEffectsPage::SelectHdl_Impl(const weld::ComboBox* pBox) +{ + if (m_xEmphasisLB.get() == pBox) + { + auto nEPos = m_xEmphasisLB->get_active(); + bool bEnable = nEPos > 0; + m_xPositionFT->set_sensitive( bEnable ); + m_xPositionLB->set_sensitive( bEnable ); + } + else if (m_xReliefLB.get() == pBox) + { + bool bEnable = ( pBox->get_active() == 0 ); + m_xOutlineBtn->set_sensitive( bEnable ); + m_xShadowBtn->set_sensitive( bEnable ); + } + else if (m_xPositionLB.get() != pBox) + { + auto nUPos = m_xUnderlineLB->get_active(); + bool bUEnable = nUPos > 0; + m_xUnderlineColorFT->set_sensitive(bUEnable); + m_xUnderlineColorLB->set_sensitive(bUEnable); + + auto nOPos = m_xOverlineLB->get_active(); + bool bOEnable = nOPos > 0; + m_xOverlineColorFT->set_sensitive(bOEnable); + m_xOverlineColorLB->set_sensitive(bOEnable); + + auto nSPos = m_xStrikeoutLB->get_active(); + m_xIndividualWordsBtn->set_sensitive( bUEnable || bOEnable || nSPos > 0); + } + UpdatePreview_Impl(); +} + +IMPL_LINK(SvxCharEffectsPage, CbClickHdl_Impl, weld::Toggleable&, rToggle, void) +{ + m_aIndividualWordsState.ButtonToggled(rToggle); + UpdatePreview_Impl(); + UpdatePreview_Impl(); +} + +IMPL_LINK(SvxCharEffectsPage, ColorBoxSelectHdl_Impl, ColorListBox&, rBox, void) +{ + if (m_xFontColorLB.get() == &rBox) + m_bNewFontColor = true; + UpdatePreview_Impl(); +} + +IMPL_LINK_NOARG(SvxCharEffectsPage, ModifyFontTransparencyHdl_Impl, weld::MetricSpinButton&, void) +{ + m_bNewFontColor = true; +} + +DeactivateRC SvxCharEffectsPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +std::unique_ptr<SfxTabPage> SvxCharEffectsPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet ) +{ + return std::make_unique<SvxCharEffectsPage>( pPage, pController, *rSet ); +} + +void SvxCharEffectsPage::Reset( const SfxItemSet* rSet ) +{ + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + + bool bEnable = false; + + // Underline + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE ); + rFont.SetUnderline( LINESTYLE_NONE ); + rCJKFont.SetUnderline( LINESTYLE_NONE ); + rCTLFont.SetUnderline( LINESTYLE_NONE ); + + m_xUnderlineLB->set_active( 0 ); + SfxItemState eState = rSet->GetItemState( nWhich ); + + if ( eState >= SfxItemState::DONTCARE ) + { + if ( eState == SfxItemState::DONTCARE ) + m_xUnderlineLB->set_active(-1); + else + { + const SvxUnderlineItem& rItem = static_cast<const SvxUnderlineItem&>(rSet->Get( nWhich )); + FontLineStyle eUnderline = rItem.GetValue(); + rFont.SetUnderline( eUnderline ); + rCJKFont.SetUnderline( eUnderline ); + rCTLFont.SetUnderline( eUnderline ); + + if ( eUnderline != LINESTYLE_NONE ) + { + auto nPos = m_xUnderlineLB->find_id(OUString::number(eUnderline)); + if (nPos != -1) + { + m_xUnderlineLB->set_active(nPos); + bEnable = true; + } + Color aColor = rItem.GetColor(); + m_xUnderlineColorLB->SelectEntry(aColor); + } + else + { + m_xUnderlineColorLB->SelectEntry(COL_AUTO); + m_xUnderlineColorLB->set_sensitive(false); + } + } + } + + // Overline + nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE ); + rFont.SetOverline( LINESTYLE_NONE ); + rCJKFont.SetOverline( LINESTYLE_NONE ); + rCTLFont.SetOverline( LINESTYLE_NONE ); + + m_xOverlineLB->set_active( 0 ); + eState = rSet->GetItemState( nWhich ); + + if ( eState >= SfxItemState::DONTCARE ) + { + if ( eState == SfxItemState::DONTCARE ) + m_xOverlineLB->set_active(-1); + else + { + const SvxOverlineItem& rItem = static_cast<const SvxOverlineItem&>(rSet->Get( nWhich )); + FontLineStyle eOverline = rItem.GetValue(); + rFont.SetOverline( eOverline ); + rCJKFont.SetOverline( eOverline ); + rCTLFont.SetOverline( eOverline ); + + if ( eOverline != LINESTYLE_NONE ) + { + auto nPos = m_xOverlineLB->find_id(OUString::number(eOverline)); + if (nPos != -1) + { + m_xOverlineLB->set_active(nPos); + bEnable = true; + } + Color aColor = rItem.GetColor(); + m_xOverlineColorLB->SelectEntry(aColor); + } + else + { + m_xOverlineColorLB->SelectEntry(COL_AUTO); + m_xOverlineColorLB->set_sensitive(false); + } + } + } + + // Strikeout + nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT ); + rFont.SetStrikeout( STRIKEOUT_NONE ); + rCJKFont.SetStrikeout( STRIKEOUT_NONE ); + rCTLFont.SetStrikeout( STRIKEOUT_NONE ); + + m_xStrikeoutLB->set_active( 0 ); + eState = rSet->GetItemState( nWhich ); + + if ( eState >= SfxItemState::DONTCARE ) + { + if ( eState == SfxItemState::DONTCARE ) + m_xStrikeoutLB->set_active(-1); + else + { + const SvxCrossedOutItem& rItem = static_cast<const SvxCrossedOutItem&>(rSet->Get( nWhich )); + FontStrikeout eStrikeout = rItem.GetValue(); + rFont.SetStrikeout( eStrikeout ); + rCJKFont.SetStrikeout( eStrikeout ); + rCTLFont.SetStrikeout( eStrikeout ); + + if ( eStrikeout != STRIKEOUT_NONE ) + { + auto nPos = m_xStrikeoutLB->find_id(OUString::number(eStrikeout)); + if (nPos != -1) + { + m_xStrikeoutLB->set_active(nPos); + bEnable = true; + } + } + } + } + + // WordLineMode + nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE ); + eState = rSet->GetItemState( nWhich ); + + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_aIndividualWordsState.bTriStateEnabled = false; + m_xIndividualWordsBtn->hide(); + break; + + case SfxItemState::DISABLED: + m_aIndividualWordsState.bTriStateEnabled = false; + m_xIndividualWordsBtn->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + m_aIndividualWordsState.bTriStateEnabled = true; + m_xIndividualWordsBtn->set_state( TRISTATE_INDET ); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxWordLineModeItem& rItem = static_cast<const SvxWordLineModeItem&>(rSet->Get( nWhich )); + rFont.SetWordLineMode( rItem.GetValue() ); + rCJKFont.SetWordLineMode( rItem.GetValue() ); + rCTLFont.SetWordLineMode( rItem.GetValue() ); + + m_aIndividualWordsState.bTriStateEnabled = false; + m_xIndividualWordsBtn->set_active(rItem.GetValue()); + m_xIndividualWordsBtn->set_sensitive(bEnable); + break; + } + } + + // Emphasis + nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK ); + eState = rSet->GetItemState( nWhich ); + + if ( eState >= SfxItemState::DEFAULT ) + { + const SvxEmphasisMarkItem& rItem = static_cast<const SvxEmphasisMarkItem&>(rSet->Get( nWhich )); + FontEmphasisMark eMark = rItem.GetEmphasisMark(); + rFont.SetEmphasisMark( eMark ); + rCJKFont.SetEmphasisMark( eMark ); + rCTLFont.SetEmphasisMark( eMark ); + + m_xEmphasisLB->set_active( static_cast<sal_Int32>(FontEmphasisMark( eMark & FontEmphasisMark::Style )) ); + eMark &= ~FontEmphasisMark::Style; + int nEntryData = ( eMark == FontEmphasisMark::PosAbove ) + ? CHRDLG_POSITION_OVER + : ( eMark == FontEmphasisMark::PosBelow ) ? CHRDLG_POSITION_UNDER : 0; + + auto nPos = m_xPositionLB->find_id(OUString::number(nEntryData)); + if (nPos != -1) + m_xPositionLB->set_active(nPos); + } + else if ( eState == SfxItemState::DONTCARE ) + m_xEmphasisLB->set_active(-1); + else if ( eState == SfxItemState::UNKNOWN ) + { + m_xEmphasisFT->hide(); + m_xEmphasisLB->hide(); + } + else // SfxItemState::DISABLED + { + m_xEmphasisFT->set_sensitive(false); + m_xEmphasisLB->set_sensitive(false); + } + + // the select handler for the underline/overline/strikeout list boxes + SelectHdl_Impl(m_xUnderlineLB.get()); + + // the select handler for the emphasis listbox + SelectHdl_Impl(m_xEmphasisLB.get()); + + // Effects + SvxCaseMap eCaseMap = SvxCaseMap::End; + nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP ); + eState = rSet->GetItemState( nWhich ); + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_xEffectsFT->hide(); + m_xEffectsLB->hide(); + break; + + case SfxItemState::DISABLED: + m_xEffectsFT->set_sensitive(false); + m_xEffectsLB->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + m_xEffectsLB->set_active(-1); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxCaseMapItem& rItem = static_cast<const SvxCaseMapItem&>(rSet->Get( nWhich )); + eCaseMap = rItem.GetValue(); + break; + } + } + SetCaseMap_Impl( eCaseMap ); + + //Relief + nWhich = GetWhich(SID_ATTR_CHAR_RELIEF); + eState = rSet->GetItemState( nWhich ); + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_xReliefFT->hide(); + m_xReliefLB->hide(); + break; + + case SfxItemState::DISABLED: + m_xReliefFT->set_sensitive(false); + m_xReliefLB->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + m_xReliefLB->set_active(-1); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxCharReliefItem& rItem = static_cast<const SvxCharReliefItem&>(rSet->Get( nWhich )); + m_xReliefLB->set_active(static_cast<sal_Int32>(rItem.GetValue())); + SelectHdl_Impl(m_xReliefLB.get()); + break; + } + } + + // Outline + nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR ); + eState = rSet->GetItemState( nWhich ); + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_aOutlineState.bTriStateEnabled = false; + m_xOutlineBtn->hide(); + break; + + case SfxItemState::DISABLED: + m_aOutlineState.bTriStateEnabled = false; + m_xOutlineBtn->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + m_aOutlineState.bTriStateEnabled = true; + m_xOutlineBtn->set_state(TRISTATE_INDET); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxContourItem& rItem = static_cast<const SvxContourItem&>(rSet->Get( nWhich )); + m_aOutlineState.bTriStateEnabled = false; + m_xOutlineBtn->set_state(static_cast<TriState>(rItem.GetValue())); + break; + } + } + + // Shadow + nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED ); + eState = rSet->GetItemState( nWhich ); + + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_aShadowState.bTriStateEnabled = false; + m_xShadowBtn->hide(); + break; + + case SfxItemState::DISABLED: + m_aShadowState.bTriStateEnabled = false; + m_xShadowBtn->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + m_aShadowState.bTriStateEnabled = true; + m_xShadowBtn->set_state( TRISTATE_INDET ); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxShadowedItem& rItem = static_cast<const SvxShadowedItem&>(rSet->Get( nWhich )); + m_aShadowState.bTriStateEnabled = false; + m_xShadowBtn->set_state( static_cast<TriState>(rItem.GetValue()) ); + break; + } + } + + // Hidden + nWhich = GetWhich( SID_ATTR_CHAR_HIDDEN ); + eState = rSet->GetItemState( nWhich ); + + switch ( eState ) + { + case SfxItemState::UNKNOWN: + m_aHiddenState.bTriStateEnabled = false; + m_xHiddenBtn->hide(); + break; + + case SfxItemState::DISABLED: + m_aHiddenState.bTriStateEnabled = false; + m_xHiddenBtn->set_sensitive(false); + break; + + case SfxItemState::DONTCARE: + m_aHiddenState.bTriStateEnabled = true; + m_xHiddenBtn->set_state(TRISTATE_INDET); + break; + + case SfxItemState::DEFAULT: + case SfxItemState::SET: + { + const SvxCharHiddenItem& rItem = static_cast<const SvxCharHiddenItem&>(rSet->Get( nWhich )); + m_aHiddenState.bTriStateEnabled = false; + m_xHiddenBtn->set_state(static_cast<TriState>(rItem.GetValue())); + break; + } + } + + SetPrevFontWidthScale( *rSet ); + ResetColor_Impl( *rSet ); + + // preview update + m_aPreviewWin.Invalidate(); + + // save this settings + ChangesApplied(); +} + +IMPL_LINK(SvxCharEffectsPage, HiddenBtnClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aHiddenState.ButtonToggled(rToggle); +} + +IMPL_LINK(SvxCharEffectsPage, OutlineBtnClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aOutlineState.ButtonToggled(rToggle); + UpdatePreview_Impl(); +} + +IMPL_LINK(SvxCharEffectsPage, ShadowBtnClickHdl, weld::Toggleable&, rToggle, void) +{ + m_aShadowState.ButtonToggled(rToggle); + UpdatePreview_Impl(); +} + +void SvxCharEffectsPage::ChangesApplied() +{ + m_xUnderlineLB->save_value(); + m_xOverlineLB->save_value(); + m_xStrikeoutLB->save_value(); + m_xIndividualWordsBtn->save_state(); + m_xEmphasisLB->save_value(); + m_xPositionLB->save_value(); + m_xEffectsLB->save_value(); + m_xReliefLB->save_value(); + m_xOutlineBtn->save_state(); + m_xShadowBtn->save_state(); + m_xHiddenBtn->save_state(); + m_xFontTransparencyMtr->save_value(); +} + +bool SvxCharEffectsPage::FillItemSet( SfxItemSet* rSet ) +{ + const SfxPoolItem* pOld = nullptr; + const SfxItemSet& rOldSet = GetItemSet(); + bool bModified = false; + bool bChanged = true; + + // Underline + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_UNDERLINE ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_UNDERLINE ); + auto nPos = m_xUnderlineLB->get_active(); + FontLineStyle eUnder = static_cast<FontLineStyle>(m_xUnderlineLB->get_active_id().toInt32()); + + if ( pOld ) + { + //! if there are different underline styles in the selection the + //! item-state in the 'rOldSet' will be invalid. In this case + //! changing the underline style will be allowed if a style is + //! selected in the listbox. + bool bAllowChg = nPos != -1 && + SfxItemState::DEFAULT > rOldSet.GetItemState( nWhich ); + + const SvxUnderlineItem& rItem = *static_cast<const SvxUnderlineItem*>(pOld); + if ( rItem.GetValue() == eUnder && + ( LINESTYLE_NONE == eUnder || rItem.GetColor() == m_xUnderlineColorLB->GetSelectEntryColor() ) && + ! bAllowChg ) + bChanged = false; + } + + if ( bChanged ) + { + SvxUnderlineItem aNewItem( eUnder, nWhich ); + aNewItem.SetColor( m_xUnderlineColorLB->GetSelectEntryColor() ); + rSet->Put( aNewItem ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Overline + nWhich = GetWhich( SID_ATTR_CHAR_OVERLINE ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_OVERLINE ); + nPos = m_xOverlineLB->get_active(); + FontLineStyle eOver = static_cast<FontLineStyle>(m_xOverlineLB->get_active_id().toInt32()); + + if ( pOld ) + { + //! if there are different underline styles in the selection the + //! item-state in the 'rOldSet' will be invalid. In this case + //! changing the underline style will be allowed if a style is + //! selected in the listbox. + bool bAllowChg = nPos != -1 && + SfxItemState::DEFAULT > rOldSet.GetItemState( nWhich ); + + const SvxOverlineItem& rItem = *static_cast<const SvxOverlineItem*>(pOld); + if ( rItem.GetValue() == eOver && + ( LINESTYLE_NONE == eOver || rItem.GetColor() == m_xOverlineColorLB->GetSelectEntryColor() ) && + ! bAllowChg ) + bChanged = false; + } + + if ( bChanged ) + { + SvxOverlineItem aNewItem( eOver, nWhich ); + aNewItem.SetColor( m_xOverlineColorLB->GetSelectEntryColor() ); + rSet->Put( aNewItem ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Strikeout + nWhich = GetWhich( SID_ATTR_CHAR_STRIKEOUT ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_STRIKEOUT ); + nPos = m_xStrikeoutLB->get_active(); + FontStrikeout eStrike = static_cast<FontStrikeout>(m_xStrikeoutLB->get_active_id().toInt32()); + + if ( pOld ) + { + //! if there are different strikeout styles in the selection the + //! item-state in the 'rOldSet' will be invalid. In this case + //! changing the strikeout style will be allowed if a style is + //! selected in the listbox. + bool bAllowChg = nPos != -1 && + SfxItemState::DEFAULT > rOldSet.GetItemState( nWhich ); + + const SvxCrossedOutItem& rItem = *static_cast<const SvxCrossedOutItem*>(pOld); + if ( !m_xStrikeoutLB->get_sensitive() + || (rItem.GetValue() == eStrike && !bAllowChg) ) + bChanged = false; + } + + if ( bChanged ) + { + rSet->Put( SvxCrossedOutItem( eStrike, nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Individual words + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + nWhich = GetWhich( SID_ATTR_CHAR_WORDLINEMODE ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_WORDLINEMODE ); + TriState eState = m_xIndividualWordsBtn->get_state(); + const SfxPoolItem* pItem; + + if ( pOld ) + { + const SvxWordLineModeItem& rItem = *static_cast<const SvxWordLineModeItem*>(pOld); + if ( rItem.GetValue() == StateToAttr( eState ) && m_xIndividualWordsBtn->get_saved_state() == eState ) + bChanged = false; + } + + if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + !StateToAttr( eState ) && static_cast<const SvxWordLineModeItem*>(pItem)->GetValue() ) + bChanged = true; + + if ( bChanged && eState != TRISTATE_INDET ) + { + rSet->Put( SvxWordLineModeItem( StateToAttr( eState ), nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Emphasis + nWhich = GetWhich( SID_ATTR_CHAR_EMPHASISMARK ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_EMPHASISMARK ); + int nMarkPos = m_xEmphasisLB->get_active(); + OUString sMarkPos = m_xEmphasisLB->get_active_text(); + OUString sPosPos = m_xPositionLB->get_active_text(); + FontEmphasisMark eMark = static_cast<FontEmphasisMark>(nMarkPos); + if (m_xPositionLB->get_sensitive()) + { + eMark |= (CHRDLG_POSITION_UNDER == m_xPositionLB->get_active_id().toInt32()) + ? FontEmphasisMark::PosBelow : FontEmphasisMark::PosAbove; + } + + if ( pOld ) + { + if( rOldSet.GetItemState( nWhich ) != SfxItemState::DONTCARE ) + { + const SvxEmphasisMarkItem& rItem = *static_cast<const SvxEmphasisMarkItem*>(pOld); + if ( rItem.GetEmphasisMark() == eMark ) + bChanged = false; + } + } + + if (rOldSet.GetItemState( nWhich ) == SfxItemState::DONTCARE && + m_xEmphasisLB->get_saved_value() == sMarkPos && m_xPositionLB->get_saved_value() == sPosPos) + { + bChanged = false; + } + + if (bChanged) + { + rSet->Put( SvxEmphasisMarkItem( eMark, nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Effects + nWhich = GetWhich( SID_ATTR_CHAR_CASEMAP ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_CASEMAP ); + SvxCaseMap eCaseMap = SvxCaseMap::NotMapped; + bool bChecked = false; + auto nCapsPos = m_xEffectsLB->get_active(); + if (nCapsPos != -1) + { + eCaseMap = static_cast<SvxCaseMap>(nCapsPos); + bChecked = true; + } + + if ( pOld ) + { + //! if there are different effect styles in the selection the + //! item-state in the 'rOldSet' will be invalid. In this case + //! changing the effect style will be allowed if a style is + //! selected in the listbox. + bool bAllowChg = nPos != -1 && + SfxItemState::DEFAULT > rOldSet.GetItemState( nWhich ); + + const SvxCaseMapItem& rItem = *static_cast<const SvxCaseMapItem*>(pOld); + if ( rItem.GetValue() == eCaseMap && !bAllowChg ) + bChanged = false; + } + + if ( bChanged && bChecked ) + { + rSet->Put( SvxCaseMapItem( eCaseMap, nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + //Relief + nWhich = GetWhich(SID_ATTR_CHAR_RELIEF); + if (m_xReliefLB->get_value_changed_from_saved()) + { + m_xReliefLB->save_value(); + SvxCharReliefItem aRelief(static_cast<FontRelief>(m_xReliefLB->get_active()), nWhich); + rSet->Put(aRelief); + } + + // Outline + nWhich = GetWhich( SID_ATTR_CHAR_CONTOUR ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_CONTOUR ); + eState = m_xOutlineBtn->get_state(); + + if ( pOld ) + { + const SvxContourItem& rItem = *static_cast<const SvxContourItem*>(pOld); + if ( rItem.GetValue() == StateToAttr( eState ) && m_xOutlineBtn->get_saved_state() == eState ) + bChanged = false; + } + + if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + !StateToAttr( eState ) && static_cast<const SvxContourItem*>(pItem)->GetValue() ) + bChanged = true; + + if ( bChanged && eState != TRISTATE_INDET ) + { + rSet->Put( SvxContourItem( StateToAttr( eState ), nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Shadow + nWhich = GetWhich( SID_ATTR_CHAR_SHADOWED ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_SHADOWED ); + eState = m_xShadowBtn->get_state(); + + if ( pOld ) + { + const SvxShadowedItem& rItem = *static_cast<const SvxShadowedItem*>(pOld); + if ( rItem.GetValue() == StateToAttr( eState ) && m_xShadowBtn->get_saved_state() == eState ) + bChanged = false; + } + + if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + !StateToAttr( eState ) && static_cast<const SvxShadowedItem*>(pItem)->GetValue() ) + bChanged = true; + + if ( bChanged && eState != TRISTATE_INDET ) + { + rSet->Put( SvxShadowedItem( StateToAttr( eState ), nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Hidden + nWhich = GetWhich( SID_ATTR_CHAR_HIDDEN ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_HIDDEN ); + eState = m_xHiddenBtn->get_state(); + bChanged = true; + + if ( pOld ) + { + const SvxCharHiddenItem& rItem = *static_cast<const SvxCharHiddenItem*>(pOld); + if ( rItem.GetValue() == StateToAttr( eState ) && m_xHiddenBtn->get_saved_state() == eState ) + bChanged = false; + } + + if ( !bChanged && pExampleSet && pExampleSet->GetItemState( nWhich, false, &pItem ) == SfxItemState::SET && + !StateToAttr( eState ) && static_cast<const SvxCharHiddenItem*>(pItem)->GetValue() ) + bChanged = true; + + if ( bChanged && eState != TRISTATE_INDET ) + { + rSet->Put( SvxCharHiddenItem( StateToAttr( eState ), nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bModified |= FillItemSetColor_Impl( *rSet ); + + return bModified; +} + +void SvxCharEffectsPage::DisableControls( sal_uInt16 nDisable ) +{ + if ( ( DISABLE_CASEMAP & nDisable ) == DISABLE_CASEMAP ) + { + m_xEffectsFT->set_sensitive(false); + m_xEffectsLB->set_sensitive(false); + } +} + +void SvxCharEffectsPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt16Item* pDisableCtlItem = aSet.GetItem<SfxUInt16Item>(SID_DISABLE_CTL, false); + const SfxUInt32Item* pFlagItem = aSet.GetItem<SfxUInt32Item>(SID_FLAG_TYPE, false); + if (pDisableCtlItem) + DisableControls(pDisableCtlItem->GetValue()); + + if (!pFlagItem) + return; + + sal_uInt32 nFlags=pFlagItem->GetValue(); + if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER ) + // the writer uses SID_ATTR_BRUSH as font background + m_bPreviewBackgroundToCharacter = true; + if ((nFlags & SVX_ENABLE_CHAR_TRANSPARENCY) != SVX_ENABLE_CHAR_TRANSPARENCY) + { + // Only show these in case client code explicitly wants this. + m_xFontTransparencyFT->hide(); + m_xFontTransparencyMtr->hide(); + } +} + +// class SvxCharPositionPage --------------------------------------------- + +SvxCharPositionPage::SvxCharPositionPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInSet) + : SvxCharBasePage(pPage, pController, "cui/ui/positionpage.ui", "PositionPage", rInSet) + , m_nSuperEsc(short(DFLT_ESC_SUPER)) + , m_nSubEsc(short(DFLT_ESC_SUB)) + , m_nScaleWidthItemSetVal(100) + , m_nScaleWidthInitialVal(100) + , m_nSuperProp(sal_uInt8(DFLT_ESC_PROP)) + , m_nSubProp(sal_uInt8(DFLT_ESC_PROP)) + , m_xHighPosBtn(m_xBuilder->weld_radio_button("superscript")) + , m_xNormalPosBtn(m_xBuilder->weld_radio_button("normal")) + , m_xLowPosBtn(m_xBuilder->weld_radio_button("subscript")) + , m_xHighLowFT(m_xBuilder->weld_label("raiselower")) + , m_xHighLowMF(m_xBuilder->weld_metric_spin_button("raiselowersb", FieldUnit::PERCENT)) + , m_xHighLowRB(m_xBuilder->weld_check_button("automatic")) + , m_xFontSizeFT(m_xBuilder->weld_label("relativefontsize")) + , m_xFontSizeMF(m_xBuilder->weld_metric_spin_button("fontsizesb", FieldUnit::PERCENT)) + , m_xRotationContainer(m_xBuilder->weld_widget("rotationcontainer")) + , m_xScalingFT(m_xBuilder->weld_label("scale")) + , m_xScalingAndRotationFT(m_xBuilder->weld_label("rotateandscale")) + , m_x0degRB(m_xBuilder->weld_radio_button("0deg")) + , m_x90degRB(m_xBuilder->weld_radio_button("90deg")) + , m_x270degRB(m_xBuilder->weld_radio_button("270deg")) + , m_xFitToLineCB(m_xBuilder->weld_check_button("fittoline")) + , m_xScaleWidthMF(m_xBuilder->weld_metric_spin_button("scalewidthsb", FieldUnit::PERCENT)) + , m_xKerningMF(m_xBuilder->weld_metric_spin_button("kerningsb", FieldUnit::POINT)) + , m_xPairKerningBtn(m_xBuilder->weld_check_button("pairkerning")) +{ + m_xPreviewWin.reset(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWin)); +#ifdef IOS + m_xPreviewWin->hide(); +#endif + Initialize(); +} + +SvxCharPositionPage::~SvxCharPositionPage() +{ +} + + +void SvxCharPositionPage::Initialize() +{ + // to handle the changes of the other pages + SetExchangeSupport(); + + GetPreviewFont().SetFontSize( Size( 0, 240 ) ); + GetPreviewCJKFont().SetFontSize( Size( 0, 240 ) ); + GetPreviewCTLFont().SetFontSize( Size( 0, 240 ) ); + + m_xNormalPosBtn->set_active(true); + PositionHdl_Impl(*m_xNormalPosBtn); + + Link<weld::Toggleable&,void> aLink2 = LINK(this, SvxCharPositionPage, PositionHdl_Impl); + m_xHighPosBtn->connect_toggled(aLink2); + m_xNormalPosBtn->connect_toggled(aLink2); + m_xLowPosBtn->connect_toggled(aLink2); + + aLink2 = LINK( this, SvxCharPositionPage, RotationHdl_Impl ); + m_x0degRB->connect_toggled(aLink2); + m_x90degRB->connect_toggled(aLink2); + m_x270degRB->connect_toggled(aLink2); + + Link<weld::MetricSpinButton&,void> aLink3 = LINK(this, SvxCharPositionPage, ValueChangedHdl_Impl); + m_xHighLowMF->connect_value_changed(aLink3); + m_xFontSizeMF->connect_value_changed(aLink3); + + m_xHighLowRB->connect_toggled(LINK(this, SvxCharPositionPage, AutoPositionHdl_Impl)); + m_xFitToLineCB->connect_toggled(LINK(this, SvxCharPositionPage, FitToLineHdl_Impl)); + m_xKerningMF->connect_value_changed(LINK(this, SvxCharPositionPage, KerningModifyHdl_Impl)); + m_xScaleWidthMF->connect_value_changed(LINK(this, SvxCharPositionPage, ScaleWidthModifyHdl_Impl)); +} + +void SvxCharPositionPage::UpdatePreview_Impl( sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc ) +{ + SetPrevFontEscapement( nProp, nEscProp, nEsc ); +} + + +void SvxCharPositionPage::SetEscapement_Impl( SvxEscapement nEsc ) +{ + SvxEscapementItem aEscItm( nEsc, SID_ATTR_CHAR_ESCAPEMENT ); + + if ( SvxEscapement::Superscript == nEsc ) + { + aEscItm.GetEsc() = m_nSuperEsc; + aEscItm.GetProportionalHeight() = m_nSuperProp; + } + else if ( SvxEscapement::Subscript == nEsc ) + { + aEscItm.GetEsc() = m_nSubEsc; + aEscItm.GetProportionalHeight() = m_nSubProp; + } + + short nFac = aEscItm.GetEsc() < 0 ? -1 : 1; + + m_xHighLowMF->set_value(aEscItm.GetEsc() * nFac, FieldUnit::PERCENT); + m_xFontSizeMF->set_value(aEscItm.GetProportionalHeight(), FieldUnit::PERCENT); + + if ( SvxEscapement::Off == nEsc ) + { + m_xHighLowFT->set_sensitive(false); + m_xHighLowMF->set_sensitive(false); + m_xFontSizeFT->set_sensitive(false); + m_xFontSizeMF->set_sensitive(false); + m_xHighLowRB->set_sensitive(false); + } + else + { + m_xFontSizeFT->set_sensitive(true); + m_xFontSizeMF->set_sensitive(true); + m_xHighLowRB->set_sensitive(true); + + if (!m_xHighLowRB->get_active()) + { + m_xHighLowFT->set_sensitive(true); + m_xHighLowMF->set_sensitive(true); + } + else + AutoPositionHdl_Impl(*m_xHighLowRB); + } + + UpdatePreview_Impl( 100, aEscItm.GetProportionalHeight(), aEscItm.GetEsc() ); +} + + +IMPL_LINK_NOARG(SvxCharPositionPage, PositionHdl_Impl, weld::Toggleable&, void) +{ + SvxEscapement nEsc = SvxEscapement::Off; // also when pBtn == NULL + + if (m_xHighPosBtn->get_active()) + nEsc = SvxEscapement::Superscript; + else if (m_xLowPosBtn->get_active()) + nEsc = SvxEscapement::Subscript; + + SetEscapement_Impl( nEsc ); +} + +IMPL_LINK_NOARG(SvxCharPositionPage, RotationHdl_Impl, weld::Toggleable&, void) +{ + bool bEnable = false; + if (m_x90degRB->get_active() || m_x270degRB->get_active()) + bEnable = true; + else + OSL_ENSURE(m_x0degRB->get_active(), "unexpected button"); + m_xFitToLineCB->set_sensitive(bEnable); +} + +void SvxCharPositionPage::FontModifyHdl_Impl() +{ + sal_uInt8 nEscProp = static_cast<sal_uInt8>(m_xFontSizeMF->get_value(FieldUnit::PERCENT)); + short nEsc = static_cast<short>(m_xHighLowMF->get_value(FieldUnit::PERCENT)); + nEsc *= m_xLowPosBtn->get_active() ? -1 : 1; + UpdatePreview_Impl( 100, nEscProp, nEsc ); +} + +IMPL_LINK(SvxCharPositionPage, AutoPositionHdl_Impl, weld::Toggleable&, rBox, void) +{ + if (rBox.get_active()) + { + m_xHighLowFT->set_sensitive(false); + m_xHighLowMF->set_sensitive(false); + } + else + PositionHdl_Impl(m_xHighPosBtn->get_active() ? *m_xHighPosBtn + : m_xLowPosBtn->get_active() ? *m_xLowPosBtn + : *m_xNormalPosBtn); +} + +IMPL_LINK_NOARG(SvxCharPositionPage, FitToLineHdl_Impl, weld::Toggleable&, void) +{ + sal_uInt16 nVal = m_nScaleWidthInitialVal; + if (m_xFitToLineCB->get_active()) + nVal = m_nScaleWidthItemSetVal; + m_xScaleWidthMF->set_value(nVal, FieldUnit::PERCENT); + m_aPreviewWin.SetFontWidthScale( nVal ); +} + +IMPL_LINK_NOARG(SvxCharPositionPage, KerningModifyHdl_Impl, weld::MetricSpinButton&, void) +{ + tools::Long nVal = static_cast<tools::Long>(m_xKerningMF->get_value(FieldUnit::POINT)); + nVal = o3tl::convert(nVal, o3tl::Length::pt, o3tl::Length::twip); + + tools::Long nKern = static_cast<short>(m_xKerningMF->denormalize(nVal)); + + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + + rFont.SetFixKerning( static_cast<short>(nKern) ); + rCJKFont.SetFixKerning( static_cast<short>(nKern) ); + rCTLFont.SetFixKerning( static_cast<short>(nKern) ); + m_aPreviewWin.Invalidate(); +} + +IMPL_LINK(SvxCharPositionPage, ValueChangedHdl_Impl, weld::MetricSpinButton&, rField, void) +{ + bool bHigh = m_xHighPosBtn->get_active(); + bool bLow = m_xLowPosBtn->get_active(); + DBG_ASSERT( bHigh || bLow, "normal position is not valid" ); + + if (m_xHighLowMF.get() == &rField) + { + if ( bLow ) + m_nSubEsc = static_cast<short>(m_xHighLowMF->get_value(FieldUnit::PERCENT)) * -1; + else + m_nSuperEsc = static_cast<short>(m_xHighLowMF->get_value(FieldUnit::PERCENT)); + } + else if (m_xFontSizeMF.get() == &rField) + { + if ( bLow ) + m_nSubProp = static_cast<sal_uInt8>(m_xFontSizeMF->get_value(FieldUnit::PERCENT)); + else + m_nSuperProp = static_cast<sal_uInt8>(m_xFontSizeMF->get_value(FieldUnit::PERCENT)); + } + + FontModifyHdl_Impl(); +} + +IMPL_LINK_NOARG(SvxCharPositionPage, ScaleWidthModifyHdl_Impl, weld::MetricSpinButton&, void) +{ + m_aPreviewWin.SetFontWidthScale(sal_uInt16(m_xScaleWidthMF->get_value(FieldUnit::PERCENT))); +} + +DeactivateRC SvxCharPositionPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +std::unique_ptr<SfxTabPage> SvxCharPositionPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxCharPositionPage>(pPage, pController, *rSet); +} + +void SvxCharPositionPage::Reset( const SfxItemSet* rSet ) +{ + OUString sUser = GetUserData(); + + if ( !sUser.isEmpty() ) + { + sal_Int32 nIdx {0}; + m_nSuperEsc = static_cast<short>(o3tl::toInt32(o3tl::getToken(sUser, 0, ';', nIdx ))); + m_nSubEsc = static_cast<short>(o3tl::toInt32(o3tl::getToken(sUser, 0, ';', nIdx ))); + m_nSuperProp = static_cast<sal_uInt8>(o3tl::toInt32(o3tl::getToken(sUser, 0, ';', nIdx ))); + m_nSubProp = static_cast<sal_uInt8>(o3tl::toInt32(o3tl::getToken(sUser, 0, ';', nIdx ))); + + m_xHighLowMF->set_max(MAX_ESC_POS, FieldUnit::PERCENT); + + //fdo#75307 validate all the entries and discard all of them if any are + //out of range + bool bValid = true; + if (m_nSuperEsc < m_xHighLowMF->get_min(FieldUnit::PERCENT) || m_nSuperEsc > m_xHighLowMF->get_max(FieldUnit::PERCENT)) + bValid = false; + if (m_nSubEsc*-1 < m_xHighLowMF->get_min(FieldUnit::PERCENT) || m_nSubEsc*-1 > m_xHighLowMF->get_max(FieldUnit::PERCENT)) + bValid = false; + if (m_nSuperProp < m_xFontSizeMF->get_min(FieldUnit::PERCENT) || m_nSuperProp > m_xFontSizeMF->get_max(FieldUnit::PERCENT)) + bValid = false; + if (m_nSubProp < m_xFontSizeMF->get_min(FieldUnit::PERCENT) || m_nSubProp > m_xFontSizeMF->get_max(FieldUnit::PERCENT)) + bValid = false; + + if (!bValid) + { + m_nSuperEsc = DFLT_ESC_SUPER; + m_nSubEsc = DFLT_ESC_SUB; + m_nSuperProp = DFLT_ESC_PROP; + m_nSubProp = DFLT_ESC_PROP; + } + } + + short nEsc = 0; + sal_uInt8 nEscProp = 100; + + m_xHighLowFT->set_sensitive(false); + m_xHighLowMF->set_sensitive(false); + m_xFontSizeFT->set_sensitive(false); + m_xFontSizeMF->set_sensitive(false); + + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT ); + + if ( rSet->GetItemState( nWhich ) >= SfxItemState::DEFAULT ) + { + const SvxEscapementItem& rItem = static_cast<const SvxEscapementItem&>(rSet->Get( nWhich )); + nEsc = rItem.GetEsc(); + nEscProp = rItem.GetProportionalHeight(); + + if ( nEsc != 0 ) + { + m_xHighLowFT->set_sensitive(true); + m_xHighLowMF->set_sensitive(true); + m_xFontSizeFT->set_sensitive(true); + m_xFontSizeMF->set_sensitive(true); + + short nFac; + bool bAutomatic(false); + + if ( nEsc > 0 ) + { + nFac = 1; + m_xHighPosBtn->set_active(true); + if ( nEsc == DFLT_ESC_AUTO_SUPER ) + { + nEsc = .8 * (100 - nEscProp); //approximation of actual percentage used + bAutomatic = true; + } + } + else + { + nFac = -1; + m_xLowPosBtn->set_active(true); + if ( nEsc == DFLT_ESC_AUTO_SUB ) + { + nEsc = .2 * -(100 - nEscProp); //approximation of actual percentage used + bAutomatic = true; + } + } + if (!m_xHighLowRB->get_sensitive()) + { + m_xHighLowRB->set_sensitive(true); + } + m_xHighLowRB->set_active(bAutomatic); + + if (m_xHighLowRB->get_active()) + { + m_xHighLowFT->set_sensitive(false); + m_xHighLowMF->set_sensitive(false); + } + m_xHighLowMF->set_value(m_xHighLowMF->normalize(nFac * nEsc), FieldUnit::PERCENT); + } + else + { + m_xNormalPosBtn->set_active(true); + m_xHighLowRB->set_active(true); + PositionHdl_Impl(*m_xNormalPosBtn); + } + //the height has to be set after the handler is called to keep the value also if the escapement is zero + m_xFontSizeMF->set_value(m_xFontSizeMF->normalize(nEscProp), FieldUnit::PERCENT); + } + else + { + m_xHighPosBtn->set_active(false); + m_xNormalPosBtn->set_active(false); + m_xLowPosBtn->set_active(false); + } + + // set BspFont + SetPrevFontEscapement( 100, nEscProp, nEsc ); + + // Kerning + nWhich = GetWhich( SID_ATTR_CHAR_KERNING ); + + if ( rSet->GetItemState( nWhich ) >= SfxItemState::DEFAULT ) + { + const SvxKerningItem& rItem = static_cast<const SvxKerningItem&>(rSet->Get( nWhich )); + MapUnit eUnit = rSet->GetPool()->GetMetric( nWhich ); + tools::Long nBig = static_cast<tools::Long>(m_xKerningMF->normalize( static_cast<tools::Long>(rItem.GetValue()) )); + tools::Long nKerning = OutputDevice::LogicToLogic(nBig, eUnit, MapUnit::MapPoint); + + // set Kerning at the Font, convert into Twips before + tools::Long nKern = OutputDevice::LogicToLogic(rItem.GetValue(), eUnit, MapUnit::MapTwip); + rFont.SetFixKerning( static_cast<short>(nKern) ); + rCJKFont.SetFixKerning( static_cast<short>(nKern) ); + rCTLFont.SetFixKerning( static_cast<short>(nKern) ); + + //the attribute value must be displayed also if it's above/below the maximum allowed value + tools::Long nVal = static_cast<tools::Long>(m_xKerningMF->get_max(FieldUnit::POINT)); + if(nVal < nKerning) + m_xKerningMF->set_max(nKerning, FieldUnit::POINT); + nVal = static_cast<tools::Long>(m_xKerningMF->get_min(FieldUnit::POINT)); + if (nVal > nKerning) + m_xKerningMF->set_min(nKerning, FieldUnit::POINT); + m_xKerningMF->set_value(nKerning, FieldUnit::POINT); + } + else + m_xKerningMF->set_text(OUString()); + + // Pair kerning + nWhich = GetWhich( SID_ATTR_CHAR_AUTOKERN ); + + if ( rSet->GetItemState( nWhich ) >= SfxItemState::DEFAULT ) + { + const SvxAutoKernItem& rItem = static_cast<const SvxAutoKernItem&>(rSet->Get( nWhich )); + m_xPairKerningBtn->set_active(rItem.GetValue()); + } + else + m_xPairKerningBtn->set_active(false); + + // Scale Width + nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH ); + if ( rSet->GetItemState( nWhich ) >= SfxItemState::DEFAULT ) + { + const SvxCharScaleWidthItem& rItem = static_cast<const SvxCharScaleWidthItem&>( rSet->Get( nWhich ) ); + m_nScaleWidthInitialVal = rItem.GetValue(); + m_xScaleWidthMF->set_value(m_nScaleWidthInitialVal, FieldUnit::PERCENT); + } + else + m_xScaleWidthMF->set_value(100, FieldUnit::PERCENT); + + if ( rSet->GetItemState( SID_ATTR_CHAR_WIDTH_FIT_TO_LINE ) >= SfxItemState::DEFAULT ) + m_nScaleWidthItemSetVal = static_cast<const SfxUInt16Item&>( rSet->Get( SID_ATTR_CHAR_WIDTH_FIT_TO_LINE )).GetValue(); + + // Rotation + nWhich = GetWhich( SID_ATTR_CHAR_ROTATED ); + SfxItemState eState = rSet->GetItemState( nWhich ); + if( SfxItemState::UNKNOWN == eState ) + { + m_xRotationContainer->hide(); + m_xScalingAndRotationFT->hide(); + m_xScalingFT->show(); + } + else + { + m_xRotationContainer->show(); + m_xScalingAndRotationFT->show(); + m_xScalingFT->hide(); + + if( eState >= SfxItemState::DEFAULT ) + { + const SvxCharRotateItem& rItem = + static_cast<const SvxCharRotateItem&>( rSet->Get( nWhich )); + if (rItem.IsBottomToTop()) + m_x90degRB->set_active(true); + else if (rItem.IsTopToBottom()) + m_x270degRB->set_active(true); + else + { + DBG_ASSERT( 0_deg10 == rItem.GetValue(), "incorrect value" ); + m_x0degRB->set_active(true); + } + m_xFitToLineCB->set_active(rItem.IsFitToLine()); + } + else + { + if( eState == SfxItemState::DONTCARE ) + { + m_x0degRB->set_active(false); + m_x90degRB->set_active(false); + m_x270degRB->set_active(false); + } + else + m_x0degRB->set_active(true); + + m_xFitToLineCB->set_active(false); + } + m_xFitToLineCB->set_sensitive(!m_x0degRB->get_active()); + + // is this value set? + if( SfxItemState::UNKNOWN == rSet->GetItemState( + SID_ATTR_CHAR_WIDTH_FIT_TO_LINE )) + m_xFitToLineCB->hide(); + } + ChangesApplied(); +} + +void SvxCharPositionPage::ChangesApplied() +{ + m_xHighPosBtn->save_state(); + m_xNormalPosBtn->save_state(); + m_xLowPosBtn->save_state(); + m_xHighLowRB->save_state(); + m_x0degRB->save_state(); + m_x90degRB->save_state(); + m_x270degRB->save_state(); + m_xFitToLineCB->save_state(); + m_xScaleWidthMF->save_value(); + m_xKerningMF->save_value(); + m_xPairKerningBtn->save_state(); +} + +bool SvxCharPositionPage::FillItemSet( SfxItemSet* rSet ) +{ + // Position (high, normal or low) + const SfxItemSet& rOldSet = GetItemSet(); + bool bModified = false, bChanged = true; + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_ESCAPEMENT ); + const SfxPoolItem* pOld = GetOldItem( *rSet, SID_ATTR_CHAR_ESCAPEMENT ); + const bool bHigh = m_xHighPosBtn->get_active(); + short nEsc; + sal_uInt8 nEscProp; + + if (bHigh || m_xLowPosBtn->get_active()) + { + if (m_xHighLowRB->get_active()) + nEsc = bHigh ? DFLT_ESC_AUTO_SUPER : DFLT_ESC_AUTO_SUB; + else + { + nEsc = static_cast<short>(m_xHighLowMF->denormalize(m_xHighLowMF->get_value(FieldUnit::PERCENT))); + nEsc *= (bHigh ? 1 : -1); + } + nEscProp = static_cast<sal_uInt8>(m_xFontSizeMF->denormalize(m_xFontSizeMF->get_value(FieldUnit::PERCENT))); + } + else + { + nEsc = 0; + nEscProp = 100; + } + + if ( pOld ) + { + const SvxEscapementItem& rItem = *static_cast<const SvxEscapementItem*>(pOld); + if (rItem.GetEsc() == nEsc && rItem.GetProportionalHeight() == nEscProp) + bChanged = false; + } + + if ( !bChanged && !m_xHighPosBtn->get_saved_state() && + !m_xNormalPosBtn->get_saved_state() && !m_xLowPosBtn->get_saved_state() ) + bChanged = true; + + if ( bChanged && + ( m_xHighPosBtn->get_active() || m_xNormalPosBtn->get_active() || m_xLowPosBtn->get_active() ) ) + { + rSet->Put( SvxEscapementItem( nEsc, nEscProp, nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + bChanged = true; + + // Kerning + nWhich = GetWhich( SID_ATTR_CHAR_KERNING ); + pOld = GetOldItem( *rSet, SID_ATTR_CHAR_KERNING ); + short nKerning = 0; + MapUnit eUnit = rSet->GetPool()->GetMetric( nWhich ); + + tools::Long nTmp = static_cast<tools::Long>(m_xKerningMF->get_value(FieldUnit::POINT)); + tools::Long nVal = OutputDevice::LogicToLogic(nTmp, MapUnit::MapPoint, eUnit); + nKerning = static_cast<short>(m_xKerningMF->denormalize( nVal )); + + SfxItemState eOldKernState = rOldSet.GetItemState( nWhich, false ); + if ( pOld ) + { + const SvxKerningItem& rItem = *static_cast<const SvxKerningItem*>(pOld); + if ( (eOldKernState >= SfxItemState::DEFAULT || m_xKerningMF->get_text().isEmpty()) && rItem.GetValue() == nKerning ) + bChanged = false; + } + + if ( bChanged ) + { + rSet->Put( SvxKerningItem( nKerning, nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == eOldKernState ) + rSet->InvalidateItem(nWhich); + + // Pair-Kerning + nWhich = GetWhich( SID_ATTR_CHAR_AUTOKERN ); + + if (m_xPairKerningBtn->get_state_changed_from_saved()) + { + rSet->Put( SvxAutoKernItem( m_xPairKerningBtn->get_active(), nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + // Scale Width + nWhich = GetWhich( SID_ATTR_CHAR_SCALEWIDTH ); + if (m_xScaleWidthMF->get_value_changed_from_saved()) + { + rSet->Put(SvxCharScaleWidthItem(static_cast<sal_uInt16>(m_xScaleWidthMF->get_value(FieldUnit::PERCENT)), nWhich)); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + // Rotation + nWhich = GetWhich( SID_ATTR_CHAR_ROTATED ); + if ( m_x0degRB->get_state_changed_from_saved() || + m_x90degRB->get_state_changed_from_saved() || + m_x270degRB->get_state_changed_from_saved() || + m_xFitToLineCB->get_state_changed_from_saved() ) + { + SvxCharRotateItem aItem( 0_deg10, m_xFitToLineCB->get_active(), nWhich ); + if (m_x90degRB->get_active()) + aItem.SetBottomToTop(); + else if (m_x270degRB->get_active()) + aItem.SetTopToBottom(); + rSet->Put( aItem ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + return bModified; +} + + +void SvxCharPositionPage::FillUserData() +{ + static const OUStringLiteral cTok( u";" ); + + OUString sUser = OUString::number( m_nSuperEsc ) + cTok + + OUString::number( m_nSubEsc ) + cTok + + OUString::number( m_nSuperProp ) + cTok + + OUString::number( m_nSubProp ); + SetUserData( sUser ); +} + + +void SvxCharPositionPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt32Item* pFlagItem = aSet.GetItem<SfxUInt32Item>(SID_FLAG_TYPE, false); + if (pFlagItem) + { + sal_uInt32 nFlags=pFlagItem->GetValue(); + if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER ) + // the writer uses SID_ATTR_BRUSH as font background + m_bPreviewBackgroundToCharacter = true; + } +} +// class SvxCharTwoLinesPage ------------------------------------------------ + +SvxCharTwoLinesPage::SvxCharTwoLinesPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInSet) + : SvxCharBasePage(pPage, pController, "cui/ui/twolinespage.ui", "TwoLinesPage", rInSet) + , m_nStartBracketPosition( 0 ) + , m_nEndBracketPosition( 0 ) + , m_xTwoLinesBtn(m_xBuilder->weld_check_button("twolines")) + , m_xEnclosingFrame(m_xBuilder->weld_widget("enclosing")) + , m_xStartBracketLB(m_xBuilder->weld_tree_view("startbracket")) + , m_xEndBracketLB(m_xBuilder->weld_tree_view("endbracket")) +{ + for (size_t i = 0; i < std::size(TWOLINE_OPEN); ++i) + m_xStartBracketLB->append(OUString::number(TWOLINE_OPEN[i].second), CuiResId(TWOLINE_OPEN[i].first)); + for (size_t i = 0; i < std::size(TWOLINE_CLOSE); ++i) + m_xEndBracketLB->append(OUString::number(TWOLINE_CLOSE[i].second), CuiResId(TWOLINE_CLOSE[i].first)); + + m_xPreviewWin.reset(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWin)); +#ifdef IOS + m_xPreviewWin->hide(); +#endif + Initialize(); +} + +SvxCharTwoLinesPage::~SvxCharTwoLinesPage() +{ +} + +void SvxCharTwoLinesPage::Initialize() +{ + m_xTwoLinesBtn->set_active(false); + TwoLinesHdl_Impl(*m_xTwoLinesBtn); + + m_xTwoLinesBtn->connect_toggled(LINK(this, SvxCharTwoLinesPage, TwoLinesHdl_Impl)); + + Link<weld::TreeView&,void> aLink = LINK(this, SvxCharTwoLinesPage, CharacterMapHdl_Impl); + m_xStartBracketLB->connect_changed(aLink); + m_xEndBracketLB->connect_changed(aLink); + + SvxFont& rFont = GetPreviewFont(); + SvxFont& rCJKFont = GetPreviewCJKFont(); + SvxFont& rCTLFont = GetPreviewCTLFont(); + rFont.SetFontSize( Size( 0, 220 ) ); + rCJKFont.SetFontSize( Size( 0, 220 ) ); + rCTLFont.SetFontSize( Size( 0, 220 ) ); +} + +void SvxCharTwoLinesPage::SelectCharacter(weld::TreeView* pBox) +{ + bool bStart = pBox == m_xStartBracketLB.get(); + SvxCharacterMap aDlg(GetFrameWeld(), nullptr, nullptr); + aDlg.DisableFontSelection(); + + if (aDlg.run() == RET_OK) + { + sal_Unicode cChar = static_cast<sal_Unicode>(aDlg.GetChar()); + SetBracket( cChar, bStart ); + } + else + { + pBox->select(bStart ? m_nStartBracketPosition : m_nEndBracketPosition); + } +} + + +void SvxCharTwoLinesPage::SetBracket( sal_Unicode cBracket, bool bStart ) +{ + int nEntryPos = 0; + weld::TreeView* pBox = bStart ? m_xStartBracketLB.get() : m_xEndBracketLB.get(); + if (cBracket == 0) + pBox->select(0); + else + { + bool bFound = false; + for (int i = 1; i < pBox->n_children(); ++i) + { + if (pBox->get_id(i).toInt32() != CHRDLG_ENCLOSE_SPECIAL_CHAR) + { + const sal_Unicode cChar = pBox->get_text(i)[0]; + if (cChar == cBracket) + { + pBox->select(i); + nEntryPos = i; + bFound = true; + break; + } + } + } + + if (!bFound) + { + pBox->append_text(OUString(cBracket)); + nEntryPos = pBox->n_children() - 1; + pBox->select(nEntryPos); + } + } + if (bStart) + m_nStartBracketPosition = nEntryPos; + else + m_nEndBracketPosition = nEntryPos; +} + +IMPL_LINK_NOARG(SvxCharTwoLinesPage, TwoLinesHdl_Impl, weld::Toggleable&, void) +{ + bool bChecked = m_xTwoLinesBtn->get_active(); + m_xEnclosingFrame->set_sensitive(bChecked); + UpdatePreview_Impl(); +} + +IMPL_LINK(SvxCharTwoLinesPage, CharacterMapHdl_Impl, weld::TreeView&, rBox, void) +{ + int nPos = rBox.get_selected_index(); + if (rBox.get_id(nPos).toInt32() == CHRDLG_ENCLOSE_SPECIAL_CHAR) + SelectCharacter( &rBox ); + else + { + bool bStart = &rBox == m_xStartBracketLB.get(); + if (bStart) + m_nStartBracketPosition = nPos; + else + m_nEndBracketPosition = nPos; + } + UpdatePreview_Impl(); +} + +void SvxCharTwoLinesPage::ActivatePage( const SfxItemSet& rSet ) +{ + SvxCharBasePage::ActivatePage(rSet); +} + +DeactivateRC SvxCharTwoLinesPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +std::unique_ptr<SfxTabPage> SvxCharTwoLinesPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxCharTwoLinesPage>(pPage, pController, *rSet); +} + +void SvxCharTwoLinesPage::Reset( const SfxItemSet* rSet ) +{ + m_xTwoLinesBtn->set_active(false); + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_TWO_LINES ); + SfxItemState eState = rSet->GetItemState( nWhich ); + + if ( eState >= SfxItemState::DONTCARE ) + { + const SvxTwoLinesItem& rItem = static_cast<const SvxTwoLinesItem&>(rSet->Get( nWhich )); + m_xTwoLinesBtn->set_active(rItem.GetValue()); + + if ( rItem.GetValue() ) + { + SetBracket( rItem.GetStartBracket(), true ); + SetBracket( rItem.GetEndBracket(), false ); + } + } + TwoLinesHdl_Impl(*m_xTwoLinesBtn); + + SetPrevFontWidthScale( *rSet ); +} + +bool SvxCharTwoLinesPage::FillItemSet( SfxItemSet* rSet ) +{ + const SfxItemSet& rOldSet = GetItemSet(); + bool bModified = false, bChanged = true; + sal_uInt16 nWhich = GetWhich( SID_ATTR_CHAR_TWO_LINES ); + const SfxPoolItem* pOld = GetOldItem( *rSet, SID_ATTR_CHAR_TWO_LINES ); + bool bOn = m_xTwoLinesBtn->get_active(); + sal_Unicode cStart = ( bOn && m_xStartBracketLB->get_selected_index() > 0 ) + ? m_xStartBracketLB->get_selected_text()[0] : 0; + sal_Unicode cEnd = ( bOn && m_xEndBracketLB->get_selected_index() > 0 ) + ? m_xEndBracketLB->get_selected_text()[0] : 0; + + if ( pOld ) + { + const SvxTwoLinesItem& rItem = *static_cast<const SvxTwoLinesItem*>(pOld); + if ( rItem.GetValue() == bOn && + ( !bOn || ( rItem.GetStartBracket() == cStart && rItem.GetEndBracket() == cEnd ) ) ) + bChanged = false; + } + + if ( bChanged ) + { + rSet->Put( SvxTwoLinesItem( bOn, cStart, cEnd, nWhich ) ); + bModified = true; + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich, false ) ) + rSet->InvalidateItem(nWhich); + + return bModified; +} + +void SvxCharTwoLinesPage::UpdatePreview_Impl() +{ + sal_Unicode cStart = m_xStartBracketLB->get_selected_index() > 0 + ? m_xStartBracketLB->get_selected_text()[0] : 0; + sal_Unicode cEnd = m_xEndBracketLB->get_selected_index() > 0 + ? m_xEndBracketLB->get_selected_text()[0] : 0; + m_aPreviewWin.SetBrackets(cStart, cEnd); + m_aPreviewWin.SetTwoLines(m_xTwoLinesBtn->get_active()); + m_aPreviewWin.Invalidate(); +} + +void SvxCharTwoLinesPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt32Item* pFlagItem = aSet.GetItem<SfxUInt32Item>(SID_FLAG_TYPE, false); + if (pFlagItem) + { + sal_uInt32 nFlags=pFlagItem->GetValue(); + if ( ( nFlags & SVX_PREVIEW_CHARACTER ) == SVX_PREVIEW_CHARACTER ) + // the writer uses SID_ATTR_BRUSH as font background + m_bPreviewBackgroundToCharacter = true; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/chardlg.h b/cui/source/tabpages/chardlg.h new file mode 100644 index 000000000..4a52cb24b --- /dev/null +++ b/cui/source/tabpages/chardlg.h @@ -0,0 +1,26 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ +#pragma once + +// define ---------------------------------------------------------------- + +#define CHRDLG_POSITION_OVER 0 +#define CHRDLG_POSITION_UNDER 1 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/connect.cxx b/cui/source/tabpages/connect.cxx new file mode 100644 index 000000000..d668a2a6b --- /dev/null +++ b/cui/source/tabpages/connect.cxx @@ -0,0 +1,415 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <strings.hrc> +#include <dialmgr.hxx> + +#include <svx/connctrl.hxx> +#include <svx/svxids.hrc> +#include <svx/dlgutil.hxx> +#include <svx/ofaitem.hxx> + +#include <svx/svdview.hxx> +#include <svx/sxekitm.hxx> +#include <svx/sxelditm.hxx> +#include <svx/sxenditm.hxx> +#include <svtools/unitconv.hxx> + +#include <connect.hxx> + +const WhichRangesContainer SvxConnectionPage::pRanges( + svl::Items<SDRATTR_EDGE_FIRST, SDRATTR_EDGE_LAST>); + +/************************************************************************* +|* +|* dialog for changing connectors +|* +\************************************************************************/ +SvxConnectionDialog::SvxConnectionDialog(weld::Window* pParent, const SfxItemSet& rInAttrs, const SdrView* pSdrView) + : SfxSingleTabDialogController(pParent, &rInAttrs) +{ + auto xPage = std::make_unique<SvxConnectionPage>(get_content_area(), this, rInAttrs); + + xPage->SetView(pSdrView); + xPage->Construct(); + + SetTabPage(std::move(xPage)); + m_xDialog->set_title(CuiResId(RID_CUISTR_CONNECTOR)); +} + +/************************************************************************* +|* +|* page for changing connectors +|* +\************************************************************************/ + +SvxConnectionPage::SvxConnectionPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/connectortabpage.ui", "ConnectorTabPage", &rInAttrs) + , rOutAttrs(rInAttrs) + , aAttrSet(*rInAttrs.GetPool()) + , pView(nullptr) + , m_xLbType(m_xBuilder->weld_combo_box("LB_TYPE")) + , m_xFtLine1(m_xBuilder->weld_label("FT_LINE_1")) + , m_xMtrFldLine1(m_xBuilder->weld_metric_spin_button("MTR_FLD_LINE_1", FieldUnit::CM)) + , m_xFtLine2(m_xBuilder->weld_label("FT_LINE_2")) + , m_xMtrFldLine2(m_xBuilder->weld_metric_spin_button("MTR_FLD_LINE_2", FieldUnit::CM)) + , m_xFtLine3(m_xBuilder->weld_label("FT_LINE_3")) + , m_xMtrFldLine3(m_xBuilder->weld_metric_spin_button("MTR_FLD_LINE_3", FieldUnit::CM)) + , m_xMtrFldHorz1(m_xBuilder->weld_metric_spin_button("MTR_FLD_HORZ_1", FieldUnit::MM)) + , m_xMtrFldVert1(m_xBuilder->weld_metric_spin_button("MTR_FLD_VERT_1", FieldUnit::MM)) + , m_xMtrFldHorz2(m_xBuilder->weld_metric_spin_button("MTR_FLD_HORZ_2", FieldUnit::MM)) + , m_xMtrFldVert2(m_xBuilder->weld_metric_spin_button("MTR_FLD_VERT_2", FieldUnit::MM)) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview)) +{ + SfxItemPool* pPool = rOutAttrs.GetPool(); + DBG_ASSERT( pPool, "Where is the pool" ); + eUnit = pPool->GetMetric( SDRATTR_EDGENODE1HORZDIST ); + + FillTypeLB(); + + const FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs ); + SetFieldUnit( *m_xMtrFldHorz1, eFUnit ); + SetFieldUnit( *m_xMtrFldHorz2, eFUnit ); + SetFieldUnit( *m_xMtrFldVert1, eFUnit ); + SetFieldUnit( *m_xMtrFldVert2, eFUnit ); + SetFieldUnit( *m_xMtrFldLine1, eFUnit ); + SetFieldUnit( *m_xMtrFldLine2, eFUnit ); + SetFieldUnit( *m_xMtrFldLine3, eFUnit ); + if( eFUnit == FieldUnit::MM ) + { + m_xMtrFldHorz1->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldHorz2->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldVert1->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldVert2->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldLine1->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldLine2->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldLine3->set_increments(50, 500, FieldUnit::NONE); + } + + Link<weld::MetricSpinButton&,void> aLink(LINK(this, SvxConnectionPage, ChangeAttrEditHdl_Impl)); + m_xMtrFldHorz1->connect_value_changed(aLink); + m_xMtrFldVert1->connect_value_changed(aLink); + m_xMtrFldHorz2->connect_value_changed(aLink); + m_xMtrFldVert2->connect_value_changed(aLink); + m_xMtrFldLine1->connect_value_changed(aLink); + m_xMtrFldLine2->connect_value_changed(aLink); + m_xMtrFldLine3->connect_value_changed(aLink); + m_xLbType->connect_changed(LINK(this, SvxConnectionPage, ChangeAttrListBoxHdl_Impl)); +} + +SvxConnectionPage::~SvxConnectionPage() +{ + m_xCtlPreview.reset(); +} + +/************************************************************************* +|* +|* reads passed Item-Set +|* +\************************************************************************/ + +void SvxConnectionPage::Reset( const SfxItemSet* rAttrs ) +{ + const SfxPoolItem* pItem = GetItem( *rAttrs, SDRATTR_EDGENODE1HORZDIST ); + const SfxItemPool* pPool = rAttrs->GetPool(); + + // SdrEdgeNode1HorzDistItem + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGENODE1HORZDIST ); + SetMetricValue(*m_xMtrFldHorz1, static_cast<const SdrEdgeNode1HorzDistItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldHorz1->save_value(); + + // SdrEdgeNode2HorzDistItem + pItem = GetItem( *rAttrs, SDRATTR_EDGENODE2HORZDIST ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGENODE2HORZDIST ); + SetMetricValue(*m_xMtrFldHorz2, static_cast<const SdrEdgeNode2HorzDistItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldHorz2->save_value(); + + // SdrEdgeNode1VertDistItem + pItem = GetItem( *rAttrs, SDRATTR_EDGENODE1VERTDIST ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGENODE1VERTDIST ); + SetMetricValue(*m_xMtrFldVert1, static_cast<const SdrEdgeNode1VertDistItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldVert1->save_value(); + + // SdrEdgeNode2VertDistItem + pItem = GetItem( *rAttrs, SDRATTR_EDGENODE2VERTDIST ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGENODE2VERTDIST ); + SetMetricValue(*m_xMtrFldVert2, static_cast<const SdrEdgeNode2VertDistItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldVert2->save_value(); + + // SdrEdgeLine1DeltaItem + pItem = GetItem( *rAttrs, SDRATTR_EDGELINE1DELTA ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGELINE1DELTA ); + SetMetricValue(*m_xMtrFldLine1, static_cast<const SdrMetricItem*>(pItem)->GetValue(), eUnit); + m_xMtrFldLine1->save_value(); + + // SdrEdgeLine2DeltaItem + pItem = GetItem( *rAttrs, SDRATTR_EDGELINE2DELTA ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGELINE2DELTA ); + SetMetricValue(*m_xMtrFldLine2, static_cast<const SdrMetricItem*>(pItem)->GetValue(), eUnit); + m_xMtrFldLine2->save_value(); + + // SdrEdgeLine3DeltaItem + pItem = GetItem( *rAttrs, SDRATTR_EDGELINE3DELTA ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGELINE3DELTA ); + SetMetricValue(*m_xMtrFldLine3, static_cast<const SdrMetricItem*>(pItem)->GetValue(), eUnit); + m_xMtrFldLine3->save_value(); + + // SdrEdgeLineDeltaAnzItem + pItem = GetItem( *rAttrs, SDRATTR_EDGELINEDELTACOUNT ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGELINEDELTACOUNT ); + switch (static_cast<const SdrEdgeLineDeltaCountItem*>(pItem)->GetValue()) + { + case 0: + m_xFtLine1->set_sensitive(false); + m_xMtrFldLine1->set_sensitive(false); + m_xMtrFldLine1->set_text(""); + [[fallthrough]]; + case 1: + m_xFtLine2->set_sensitive(false); + m_xMtrFldLine2->set_sensitive(false); + m_xMtrFldLine2->set_text(""); + [[fallthrough]]; + case 2: + m_xFtLine3->set_sensitive(false); + m_xMtrFldLine3->set_sensitive(false); + m_xMtrFldLine3->set_text(""); + break; + } + + // SdrEdgeKindItem + pItem = GetItem( *rAttrs, SDRATTR_EDGEKIND ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGEKIND ); + m_xLbType->set_active( + sal::static_int_cast<sal_uInt16>(static_cast<const SdrEdgeKindItem*>(pItem)->GetValue())); + m_xLbType->save_value(); +} + +/************************************************************************* +|* +|* fills the passed Item-Set width Dialogbox attributes +|* +\************************************************************************/ + +bool SvxConnectionPage::FillItemSet( SfxItemSet* rAttrs) +{ + bool bModified = false; + sal_Int32 nValue; + + if (m_xMtrFldHorz1->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldHorz1, eUnit); + rAttrs->Put( SdrEdgeNode1HorzDistItem( nValue ) ); + bModified = true; + } + + if (m_xMtrFldHorz2->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldHorz2, eUnit); + rAttrs->Put( SdrEdgeNode2HorzDistItem( nValue ) ); + bModified = true; + } + + if (m_xMtrFldVert1->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldVert1, eUnit); + rAttrs->Put( SdrEdgeNode1VertDistItem( nValue ) ); + bModified = true; + } + + if (m_xMtrFldVert2->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldVert2, eUnit); + rAttrs->Put( SdrEdgeNode2VertDistItem( nValue ) ); + bModified = true; + } + + if (m_xMtrFldLine1->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldLine1, eUnit); + rAttrs->Put( makeSdrEdgeLine1DeltaItem( nValue ) ); + bModified = true; + } + + if (m_xMtrFldLine2->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldLine2, eUnit); + rAttrs->Put( makeSdrEdgeLine2DeltaItem( nValue ) ); + bModified = true; + } + + if (m_xMtrFldLine3->get_value_changed_from_saved()) + { + nValue = GetCoreValue(*m_xMtrFldLine3, eUnit); + rAttrs->Put( makeSdrEdgeLine3DeltaItem( nValue ) ); + bModified = true; + } + + int nPos = m_xLbType->get_active(); + if (m_xLbType->get_value_changed_from_saved()) + { + if (nPos != -1) + { + rAttrs->Put( SdrEdgeKindItem( static_cast<SdrEdgeKind>(nPos) ) ); + bModified = true; + } + } + + return bModified; +} + +void SvxConnectionPage::Construct() +{ + DBG_ASSERT( pView, "No valid View transfer!" ); + + m_aCtlPreview.SetView(pView); + m_aCtlPreview.Construct(); +} + +/************************************************************************* +|* +|* creates the page +|* +\************************************************************************/ +std::unique_ptr<SfxTabPage> SvxConnectionPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxConnectionPage>(pPage, pController, *rAttrs); +} + +IMPL_LINK_NOARG(SvxConnectionPage, ChangeAttrListBoxHdl_Impl, weld::ComboBox&, void) +{ + int nPos = m_xLbType->get_active(); + if (nPos != -1) + { + aAttrSet.Put( SdrEdgeKindItem( static_cast<SdrEdgeKind>(nPos) ) ); + } + + m_aCtlPreview.SetAttributes(aAttrSet); + + // get the number of line displacements + sal_uInt16 nCount = m_aCtlPreview.GetLineDeltaCount(); + + m_xFtLine3->set_sensitive( nCount > 2 ); + m_xMtrFldLine3->set_sensitive( nCount > 2 ); + if( nCount > 2 ) + m_xMtrFldLine3->set_value(m_xMtrFldLine3->get_value(FieldUnit::NONE), FieldUnit::NONE); + else + m_xMtrFldLine3->set_text(""); + + m_xFtLine2->set_sensitive( nCount > 1 ); + m_xMtrFldLine2->set_sensitive( nCount > 1 ); + if( nCount > 1 ) + m_xMtrFldLine2->set_value(m_xMtrFldLine2->get_value(FieldUnit::NONE), FieldUnit::NONE); + else + m_xMtrFldLine2->set_text(""); + + m_xFtLine1->set_sensitive( nCount > 0 ); + m_xMtrFldLine1->set_sensitive( nCount > 0 ); + if( nCount > 0 ) + m_xMtrFldLine1->set_value(m_xMtrFldLine1->get_value(FieldUnit::NONE), FieldUnit::NONE); + else + m_xMtrFldLine1->set_text(""); +} + +IMPL_LINK(SvxConnectionPage, ChangeAttrEditHdl_Impl, weld::MetricSpinButton&, r, void) +{ + if (&r == m_xMtrFldHorz1.get()) + { + sal_Int32 nValue = GetCoreValue(*m_xMtrFldHorz1, eUnit); + aAttrSet.Put( SdrEdgeNode1HorzDistItem( nValue ) ); + } + + if (&r == m_xMtrFldHorz2.get()) + { + sal_Int32 nValue = GetCoreValue( *m_xMtrFldHorz2, eUnit ); + aAttrSet.Put( SdrEdgeNode2HorzDistItem( nValue ) ); + } + + if (&r == m_xMtrFldVert1.get()) + { + sal_Int32 nValue = GetCoreValue(*m_xMtrFldVert1, eUnit); + aAttrSet.Put( SdrEdgeNode1VertDistItem( nValue ) ); + } + + if (&r == m_xMtrFldVert2.get()) + { + sal_Int32 nValue = GetCoreValue(*m_xMtrFldVert2, eUnit); + aAttrSet.Put( SdrEdgeNode2VertDistItem( nValue ) ); + } + + if (&r == m_xMtrFldLine1.get()) + { + sal_Int32 nValue = GetCoreValue(*m_xMtrFldLine1, eUnit); + aAttrSet.Put( makeSdrEdgeLine1DeltaItem( nValue ) ); + } + + if (&r == m_xMtrFldLine2.get()) + { + sal_Int32 nValue = GetCoreValue(*m_xMtrFldLine2, eUnit); + aAttrSet.Put( makeSdrEdgeLine2DeltaItem( nValue ) ); + } + + if (&r == m_xMtrFldLine3.get()) + { + sal_Int32 nValue = GetCoreValue(*m_xMtrFldLine3, eUnit); + aAttrSet.Put( makeSdrEdgeLine3DeltaItem( nValue ) ); + } + + m_aCtlPreview.SetAttributes(aAttrSet); +} + +void SvxConnectionPage::FillTypeLB() +{ + // fill ListBox with connector names + const SfxPoolItem* pItem = GetItem( rOutAttrs, SDRATTR_EDGEKIND ); + const SfxItemPool* pPool = rOutAttrs.GetPool(); + + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_EDGEKIND ); + const SdrEdgeKindItem* pEdgeKindItem = static_cast<const SdrEdgeKindItem*>(pItem); + const sal_uInt16 nCount = pEdgeKindItem->GetValueCount(); + for (sal_uInt16 i = 0; i < nCount; i++) + { + OUString aStr = SdrEdgeKindItem::GetValueTextByPos(i); + m_xLbType->append_text(aStr); + } +} +void SvxConnectionPage::PageCreated(const SfxAllItemSet& aSet) +{ + const OfaPtrItem* pOfaPtrItem = aSet.GetItem<OfaPtrItem>(SID_OBJECT_LIST, false); + if (pOfaPtrItem) + SetView( static_cast<SdrView *>(pOfaPtrItem->GetValue()) ); + + Construct(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/grfpage.cxx b/cui/source/tabpages/grfpage.cxx new file mode 100644 index 000000000..1bbc73c3a --- /dev/null +++ b/cui/source/tabpages/grfpage.cxx @@ -0,0 +1,806 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <svl/eitem.hxx> +#include <svl/stritem.hxx> +#include <dialmgr.hxx> +#include <svx/dlgutil.hxx> +#include <editeng/sizeitem.hxx> +#include <editeng/brushitem.hxx> +#include <grfpage.hxx> +#include <svx/grfcrop.hxx> +#include <rtl/ustring.hxx> +#include <tools/debug.hxx> +#include <tools/fract.hxx> +#include <svx/svxids.hrc> +#include <strings.hrc> +#include <vcl/fieldvalues.hxx> +#include <vcl/outdev.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <svtools/unitconv.hxx> +#include <svtools/optionsdrawinglayer.hxx> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <o3tl/unit_conversion.hxx> + +constexpr auto CM_1_TO_TWIP = o3tl::convert(1, o3tl::Length::cm, o3tl::Length::twip); // 567 + + +static int lcl_GetValue(const weld::MetricSpinButton& rMetric, FieldUnit eUnit) +{ + return rMetric.denormalize(rMetric.get_value(eUnit)); +} + +/*-------------------------------------------------------------------- + description: crop graphic + --------------------------------------------------------------------*/ + +SvxGrfCropPage::SvxGrfCropPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet &rSet) + : SfxTabPage(pPage, pController, "cui/ui/croppage.ui", "CropPage", &rSet) + , m_nOldWidth(0) + , m_nOldHeight(0) + , m_bSetOrigSize(false) + , m_aPreferredDPI(0) + , m_xCropFrame(m_xBuilder->weld_widget("cropframe")) + , m_xZoomConstRB(m_xBuilder->weld_radio_button("keepscale")) + , m_xSizeConstRB(m_xBuilder->weld_radio_button("keepsize")) + , m_xLeftMF(m_xBuilder->weld_metric_spin_button("left", FieldUnit::CM)) + , m_xRightMF(m_xBuilder->weld_metric_spin_button("right", FieldUnit::CM)) + , m_xTopMF(m_xBuilder->weld_metric_spin_button("top", FieldUnit::CM)) + , m_xBottomMF(m_xBuilder->weld_metric_spin_button("bottom", FieldUnit::CM)) + , m_xScaleFrame(m_xBuilder->weld_widget("scaleframe")) + , m_xWidthZoomMF(m_xBuilder->weld_metric_spin_button("widthzoom", FieldUnit::PERCENT)) + , m_xHeightZoomMF(m_xBuilder->weld_metric_spin_button("heightzoom", FieldUnit::PERCENT)) + , m_xSizeFrame(m_xBuilder->weld_widget("sizeframe")) + , m_xWidthMF(m_xBuilder->weld_metric_spin_button("width", FieldUnit::CM)) + , m_xHeightMF(m_xBuilder->weld_metric_spin_button("height", FieldUnit::CM)) + , m_xOrigSizeGrid(m_xBuilder->weld_widget("origsizegrid")) + , m_xOrigSizeFT(m_xBuilder->weld_label("origsizeft")) + , m_xOrigSizePB(m_xBuilder->weld_button("origsize")) + , m_xExampleWN(new weld::CustomWeld(*m_xBuilder, "preview", m_aExampleWN)) +{ + SetExchangeSupport(); + + // set the correct metric + const FieldUnit eMetric = GetModuleFieldUnit( rSet ); + + SetFieldUnit( *m_xWidthMF, eMetric ); + SetFieldUnit( *m_xHeightMF, eMetric ); + SetFieldUnit( *m_xLeftMF, eMetric ); + SetFieldUnit( *m_xRightMF, eMetric ); + SetFieldUnit( *m_xTopMF , eMetric ); + SetFieldUnit( *m_xBottomMF, eMetric ); + + Link<weld::MetricSpinButton&,void> aLk = LINK(this, SvxGrfCropPage, SizeHdl); + m_xWidthMF->connect_value_changed( aLk ); + m_xHeightMF->connect_value_changed( aLk ); + + aLk = LINK(this, SvxGrfCropPage, ZoomHdl); + m_xWidthZoomMF->connect_value_changed( aLk ); + m_xHeightZoomMF->connect_value_changed( aLk ); + + aLk = LINK(this, SvxGrfCropPage, CropModifyHdl); + m_xLeftMF->connect_value_changed( aLk ); + m_xRightMF->connect_value_changed( aLk ); + m_xTopMF->connect_value_changed( aLk ); + m_xBottomMF->connect_value_changed( aLk ); + + m_xOrigSizePB->connect_clicked(LINK(this, SvxGrfCropPage, OrigSizeHdl)); +} + +SvxGrfCropPage::~SvxGrfCropPage() +{ + m_xExampleWN.reset(); +} + +std::unique_ptr<SfxTabPage> SvxGrfCropPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet *rSet) +{ + return std::make_unique<SvxGrfCropPage>(pPage, pController, *rSet); +} + +void SvxGrfCropPage::Reset( const SfxItemSet *rSet ) +{ + const SfxPoolItem* pItem; + const SfxItemPool& rPool = *rSet->GetPool(); + + if(SfxItemState::SET == rSet->GetItemState( rPool.GetWhich( + SID_ATTR_GRAF_KEEP_ZOOM ), true, &pItem )) + { + if( static_cast<const SfxBoolItem*>(pItem)->GetValue() ) + m_xZoomConstRB->set_active(true); + else + m_xSizeConstRB->set_active(true); + m_xZoomConstRB->save_state(); + } + + sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_CROP ); + if( SfxItemState::SET == rSet->GetItemState( nW, true, &pItem)) + { + FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW )); + + const SvxGrfCrop* pCrop = static_cast<const SvxGrfCrop*>(pItem); + + m_aExampleWN.SetLeft(pCrop->GetLeft()); + m_aExampleWN.SetRight(pCrop->GetRight()); + m_aExampleWN.SetTop(pCrop->GetTop()); + m_aExampleWN.SetBottom(pCrop->GetBottom()); + + m_xLeftMF->set_value( m_xLeftMF->normalize( pCrop->GetLeft()), eUnit ); + m_xRightMF->set_value( m_xRightMF->normalize( pCrop->GetRight()), eUnit ); + m_xTopMF->set_value( m_xTopMF->normalize( pCrop->GetTop()), eUnit ); + m_xBottomMF->set_value( m_xBottomMF->normalize( pCrop->GetBottom()), eUnit ); + } + else + { + m_xLeftMF->set_value(0, FieldUnit::NONE); + m_xRightMF->set_value(0, FieldUnit::NONE); + m_xTopMF->set_value(0, FieldUnit::NONE); + m_xBottomMF->set_value(0, FieldUnit::NONE); + } + + m_xLeftMF->save_value(); + m_xRightMF->save_value(); + m_xTopMF->save_value(); + m_xBottomMF->save_value(); + + nW = rPool.GetWhich( SID_ATTR_PAGE_SIZE ); + if ( SfxItemState::SET == rSet->GetItemState( nW, false, &pItem ) ) + { + // orientation and size from the PageItem + FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW )); + + m_aPageSize = static_cast<const SvxSizeItem*>(pItem)->GetSize(); + + auto nMin = m_xWidthMF->normalize( 23 ); + auto nMax = m_xHeightMF->normalize(m_aPageSize.Height()); + m_xHeightMF->set_range(nMin, nMax, eUnit); + nMax = m_xWidthMF->normalize(m_aPageSize.Width()); + m_xWidthMF->set_range(nMin, nMax, eUnit); + } + else + { + m_aPageSize = OutputDevice::LogicToLogic( + Size( CM_1_TO_TWIP, CM_1_TO_TWIP ), + MapMode( MapUnit::MapTwip ), + MapMode( rSet->GetPool()->GetMetric( nW ) ) ); + } + + bool bFound = false; + if( const SvxBrushItem* pGraphicItem = rSet->GetItemIfSet( SID_ATTR_GRAF_GRAPHIC, false ) ) + { + OUString referer; + SfxStringItem const * it = static_cast<SfxStringItem const *>( + rSet->GetItem(SID_REFERER)); + if (it != nullptr) { + referer = it->GetValue(); + } + const Graphic* pGrf = pGraphicItem->GetGraphic(referer); + if( pGrf ) + { + m_aOrigSize = GetGrfOrigSize( *pGrf ); + if (pGrf->GetType() == GraphicType::Bitmap && m_aOrigSize.Width() && m_aOrigSize.Height()) + { + m_aOrigPixelSize = pGrf->GetSizePixel(); + } + + if( m_aOrigSize.Width() && m_aOrigSize.Height() ) + { + CalcMinMaxBorder(); + m_aExampleWN.SetGraphic( *pGrf ); + m_aExampleWN.SetFrameSize( m_aOrigSize ); + + bFound = true; + if( !pGraphicItem->GetGraphicLink().isEmpty() ) + m_aGraphicName = pGraphicItem->GetGraphicLink(); + } + } + } + + GraphicHasChanged( bFound ); + ActivatePage( *rSet ); +} + +bool SvxGrfCropPage::FillItemSet(SfxItemSet *rSet) +{ + const SfxItemPool& rPool = *rSet->GetPool(); + bool bModified = false; + if( m_xWidthMF->get_value_changed_from_saved() || + m_xHeightMF->get_value_changed_from_saved() ) + { + constexpr TypedWhichId<SvxSizeItem> nW = SID_ATTR_GRAF_FRMSIZE; + FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW )); + + std::shared_ptr<SvxSizeItem> aSz(std::make_shared<SvxSizeItem>(nW)); + + // size could already have been set from another page + const SfxItemSet* pExSet = GetDialogExampleSet(); + const SvxSizeItem* pSizeItem = nullptr; + if( pExSet && (pSizeItem = pExSet->GetItemIfSet( nW, false )) ) + { + aSz.reset(pSizeItem->Clone()); + } + else + { + aSz.reset(GetItemSet().Get(nW).Clone()); + } + + Size aTmpSz( aSz->GetSize() ); + if( m_xWidthMF->get_value_changed_from_saved() ) + aTmpSz.setWidth( lcl_GetValue( *m_xWidthMF, eUnit ) ); + if( m_xHeightMF->get_value_changed_from_saved() ) + aTmpSz.setHeight( lcl_GetValue( *m_xHeightMF, eUnit ) ); + aSz->SetSize( aTmpSz ); + m_xWidthMF->save_value(); + m_xHeightMF->save_value(); + + bModified |= nullptr != rSet->Put( *aSz ); + + if (m_bSetOrigSize) + { + bModified |= nullptr != rSet->Put( SvxSizeItem( rPool.GetWhich( + SID_ATTR_GRAF_FRMSIZE_PERCENT ), Size( 0, 0 )) ); + } + } + if( m_xLeftMF->get_value_changed_from_saved() || m_xRightMF->get_value_changed_from_saved() || + m_xTopMF->get_value_changed_from_saved() || m_xBottomMF->get_value_changed_from_saved() ) + { + sal_uInt16 nW = rPool.GetWhich( SID_ATTR_GRAF_CROP ); + FieldUnit eUnit = MapToFieldUnit( rSet->GetPool()->GetMetric( nW )); + std::unique_ptr<SvxGrfCrop> pNew(static_cast<SvxGrfCrop*>(rSet->Get( nW ).Clone())); + + pNew->SetLeft( lcl_GetValue( *m_xLeftMF, eUnit ) ); + pNew->SetRight( lcl_GetValue( *m_xRightMF, eUnit ) ); + pNew->SetTop( lcl_GetValue( *m_xTopMF, eUnit ) ); + pNew->SetBottom( lcl_GetValue( *m_xBottomMF, eUnit ) ); + bModified |= nullptr != rSet->Put( std::move(pNew) ); + } + + if( m_xZoomConstRB->get_state_changed_from_saved() ) + { + bModified |= nullptr != rSet->Put( SfxBoolItem( rPool.GetWhich( + SID_ATTR_GRAF_KEEP_ZOOM), m_xZoomConstRB->get_active() ) ); + } + + return bModified; +} + +void SvxGrfCropPage::ActivatePage(const SfxItemSet& rSet) +{ +#ifdef DBG_UTIL + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); +#endif + + auto& aProperties = getAdditionalProperties(); + auto aIterator = aProperties.find("PreferredDPI"); + if (aIterator != aProperties.end()) + m_aPreferredDPI = aIterator->second.get<sal_Int32>(); + + m_bSetOrigSize = false; + + // Size + Size aSize; + if( const SvxSizeItem* pFrmSizeItem = rSet.GetItemIfSet( SID_ATTR_GRAF_FRMSIZE, false ) ) + aSize = pFrmSizeItem->GetSize(); + + m_nOldWidth = aSize.Width(); + m_nOldHeight = aSize.Height(); + + auto nWidth = m_xWidthMF->normalize(m_nOldWidth); + auto nHeight = m_xHeightMF->normalize(m_nOldHeight); + + if (nWidth != m_xWidthMF->get_value(FieldUnit::TWIP)) + m_xWidthMF->set_value(nWidth, FieldUnit::TWIP); + m_xWidthMF->save_value(); + + if (nHeight != m_xHeightMF->get_value(FieldUnit::TWIP)) + m_xHeightMF->set_value(nHeight, FieldUnit::TWIP); + m_xHeightMF->save_value(); + + if( const SvxBrushItem* pBrushItem = rSet.GetItemIfSet( SID_ATTR_GRAF_GRAPHIC, false ) ) + { + if( !pBrushItem->GetGraphicLink().isEmpty() && + m_aGraphicName != pBrushItem->GetGraphicLink() ) + m_aGraphicName = pBrushItem->GetGraphicLink(); + + OUString referer; + SfxStringItem const * it = static_cast<SfxStringItem const *>( + rSet.GetItem(SID_REFERER)); + if (it != nullptr) { + referer = it->GetValue(); + } + const Graphic* pGrf = pBrushItem->GetGraphic(referer); + if( pGrf ) + { + m_aExampleWN.SetGraphic( *pGrf ); + m_aOrigSize = GetGrfOrigSize( *pGrf ); + if (pGrf->GetType() == GraphicType::Bitmap && m_aOrigSize.Width() > 1 && m_aOrigSize.Height() > 1) { + m_aOrigPixelSize = pGrf->GetSizePixel(); + } + m_aExampleWN.SetFrameSize(m_aOrigSize); + GraphicHasChanged( m_aOrigSize.Width() && m_aOrigSize.Height() ); + CalcMinMaxBorder(); + } + else + GraphicHasChanged( false ); + } + + CalcZoom(); +} + +DeactivateRC SvxGrfCropPage::DeactivatePage(SfxItemSet *_pSet) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +/*-------------------------------------------------------------------- + description: scale changed, adjust size + --------------------------------------------------------------------*/ + +IMPL_LINK( SvxGrfCropPage, ZoomHdl, weld::MetricSpinButton&, rField, void ) +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) ) ); + + if (&rField == m_xWidthZoomMF.get()) + { + tools::Long nLRBorders = lcl_GetValue(*m_xLeftMF, eUnit) + +lcl_GetValue(*m_xRightMF, eUnit); + m_xWidthMF->set_value( m_xWidthMF->normalize( + ((m_aOrigSize.Width() - nLRBorders) * rField.get_value(FieldUnit::NONE))/100), + eUnit); + } + else + { + tools::Long nULBorders = lcl_GetValue(*m_xTopMF, eUnit) + +lcl_GetValue(*m_xBottomMF, eUnit); + m_xHeightMF->set_value( m_xHeightMF->normalize( + ((m_aOrigSize.Height() - nULBorders ) * rField.get_value(FieldUnit::NONE))/100) , + eUnit ); + } +} + +/*-------------------------------------------------------------------- + description: change size, adjust scale + --------------------------------------------------------------------*/ + +IMPL_LINK( SvxGrfCropPage, SizeHdl, weld::MetricSpinButton&, rField, void ) +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) ) ); + + Size aSize( lcl_GetValue(*m_xWidthMF, eUnit), + lcl_GetValue(*m_xHeightMF, eUnit) ); + + if(&rField == m_xWidthMF.get()) + { + tools::Long nWidth = m_aOrigSize.Width() - + ( lcl_GetValue(*m_xLeftMF, eUnit) + + lcl_GetValue(*m_xRightMF, eUnit) ); + if(!nWidth) + nWidth++; + sal_uInt16 nZoom = static_cast<sal_uInt16>( aSize.Width() * 100 / nWidth); + m_xWidthZoomMF->set_value(nZoom, FieldUnit::NONE); + } + else + { + tools::Long nHeight = m_aOrigSize.Height() - + ( lcl_GetValue(*m_xTopMF, eUnit) + + lcl_GetValue(*m_xBottomMF, eUnit)); + if(!nHeight) + nHeight++; + sal_uInt16 nZoom = static_cast<sal_uInt16>( aSize.Height() * 100 / nHeight); + m_xHeightZoomMF->set_value(nZoom, FieldUnit::NONE); + } +} + +/*-------------------------------------------------------------------- + description: evaluate border + --------------------------------------------------------------------*/ + +IMPL_LINK( SvxGrfCropPage, CropModifyHdl, weld::MetricSpinButton&, rField, void ) +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) ) ); + + bool bZoom = m_xZoomConstRB->get_active(); + if (&rField == m_xLeftMF.get() || &rField == m_xRightMF.get()) + { + tools::Long nLeft = lcl_GetValue( *m_xLeftMF, eUnit ); + tools::Long nRight = lcl_GetValue( *m_xRightMF, eUnit ); + tools::Long nWidthZoom = static_cast<tools::Long>(m_xWidthZoomMF->get_value(FieldUnit::NONE)); + if (bZoom && nWidthZoom != 0 && ( ( ( m_aOrigSize.Width() - (nLeft + nRight )) * nWidthZoom ) + / 100 >= m_aPageSize.Width() ) ) + { + if (&rField == m_xLeftMF.get()) + { + nLeft = m_aOrigSize.Width() - + ( m_aPageSize.Width() * 100 / nWidthZoom + nRight ); + m_xLeftMF->set_value( m_xLeftMF->normalize( nLeft ), eUnit ); + } + else + { + nRight = m_aOrigSize.Width() - + ( m_aPageSize.Width() * 100 / nWidthZoom + nLeft ); + m_xRightMF->set_value( m_xRightMF->normalize( nRight ), eUnit ); + } + } + if (AllSettings::GetLayoutRTL()) + { + m_aExampleWN.SetLeft(nRight); + m_aExampleWN.SetRight(nLeft); + } + else + { + m_aExampleWN.SetLeft(nLeft); + m_aExampleWN.SetRight(nRight); + } + if(bZoom) + { + // scale stays, recompute width + ZoomHdl(*m_xWidthZoomMF); + } + } + else + { + tools::Long nTop = lcl_GetValue( *m_xTopMF, eUnit ); + tools::Long nBottom = lcl_GetValue( *m_xBottomMF, eUnit ); + tools::Long nHeightZoom = static_cast<tools::Long>(m_xHeightZoomMF->get_value(FieldUnit::NONE)); + if(bZoom && ( ( ( m_aOrigSize.Height() - (nTop + nBottom )) * nHeightZoom) + / 100 >= m_aPageSize.Height())) + { + assert(nHeightZoom && "div-by-zero"); + if(&rField == m_xTopMF.get()) + { + nTop = m_aOrigSize.Height() - + ( m_aPageSize.Height() * 100 / nHeightZoom + nBottom); + m_xTopMF->set_value( m_xWidthMF->normalize( nTop ), eUnit ); + } + else + { + nBottom = m_aOrigSize.Height() - + ( m_aPageSize.Height() * 100 / nHeightZoom + nTop); + m_xBottomMF->set_value( m_xWidthMF->normalize( nBottom ), eUnit ); + } + } + m_aExampleWN.SetTop( nTop ); + m_aExampleWN.SetBottom( nBottom ); + if(bZoom) + { + // scale stays, recompute height + ZoomHdl(*m_xHeightZoomMF); + } + } + m_aExampleWN.Invalidate(); + // size and border changed -> recompute scale + if(!bZoom) + CalcZoom(); + CalcMinMaxBorder(); +} +/*-------------------------------------------------------------------- + description: set original size + --------------------------------------------------------------------*/ + +IMPL_LINK_NOARG(SvxGrfCropPage, OrigSizeHdl, weld::Button&, void) +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) ) ); + + tools::Long nWidth = m_aOrigSize.Width() - + lcl_GetValue( *m_xLeftMF, eUnit ) - + lcl_GetValue( *m_xRightMF, eUnit ); + m_xWidthMF->set_value( m_xWidthMF->normalize( nWidth ), eUnit ); + tools::Long nHeight = m_aOrigSize.Height() - + lcl_GetValue( *m_xTopMF, eUnit ) - + lcl_GetValue( *m_xBottomMF, eUnit ); + m_xHeightMF->set_value( m_xHeightMF->normalize( nHeight ), eUnit ); + m_xWidthZoomMF->set_value(100, FieldUnit::NONE); + m_xHeightZoomMF->set_value(100, FieldUnit::NONE); + m_bSetOrigSize = true; +} +/*-------------------------------------------------------------------- + description: compute scale + --------------------------------------------------------------------*/ + +void SvxGrfCropPage::CalcZoom() +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) ) ); + + tools::Long nWidth = lcl_GetValue( *m_xWidthMF, eUnit ); + tools::Long nHeight = lcl_GetValue( *m_xHeightMF, eUnit ); + tools::Long nLRBorders = lcl_GetValue( *m_xLeftMF, eUnit ) + + lcl_GetValue( *m_xRightMF, eUnit ); + tools::Long nULBorders = lcl_GetValue( *m_xTopMF, eUnit ) + + lcl_GetValue( *m_xBottomMF, eUnit ); + sal_uInt16 nZoom = 0; + tools::Long nDen; + if( (nDen = m_aOrigSize.Width() - nLRBorders) > 0) + nZoom = static_cast<sal_uInt16>((( nWidth * 1000 / nDen )+5)/10); + m_xWidthZoomMF->set_value(nZoom, FieldUnit::NONE); + if( (nDen = m_aOrigSize.Height() - nULBorders) > 0) + nZoom = static_cast<sal_uInt16>((( nHeight * 1000 / nDen )+5)/10); + else + nZoom = 0; + m_xHeightZoomMF->set_value(nZoom, FieldUnit::NONE); +} + +/*-------------------------------------------------------------------- + description: set minimum/maximum values for the margins + --------------------------------------------------------------------*/ + +void SvxGrfCropPage::CalcMinMaxBorder() +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) ) ); + tools::Long nR = lcl_GetValue(*m_xRightMF, eUnit ); + tools::Long nMinWidth = (m_aOrigSize.Width() * 10) /11; + tools::Long nMin = nMinWidth - (nR >= 0 ? nR : 0); + m_xLeftMF->set_max( m_xLeftMF->normalize(nMin), eUnit ); + + tools::Long nL = lcl_GetValue(*m_xLeftMF, eUnit ); + nMin = nMinWidth - (nL >= 0 ? nL : 0); + m_xRightMF->set_max( m_xRightMF->normalize(nMin), eUnit ); + + tools::Long nUp = lcl_GetValue( *m_xTopMF, eUnit ); + tools::Long nMinHeight = (m_aOrigSize.Height() * 10) /11; + nMin = nMinHeight - (nUp >= 0 ? nUp : 0); + m_xBottomMF->set_max( m_xBottomMF->normalize(nMin), eUnit ); + + tools::Long nLow = lcl_GetValue(*m_xBottomMF, eUnit ); + nMin = nMinHeight - (nLow >= 0 ? nLow : 0); + m_xTopMF->set_max( m_xTopMF->normalize(nMin), eUnit ); +} +/*-------------------------------------------------------------------- + description: set spinsize to 1/20 of the original size, + fill FixedText with the original size + --------------------------------------------------------------------*/ + +void SvxGrfCropPage::GraphicHasChanged( bool bFound ) +{ + if( bFound ) + { + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( pPool->GetWhich( + SID_ATTR_GRAF_CROP ) )); + + sal_Int64 nSpin = m_xLeftMF->normalize(m_aOrigSize.Width()) / 20; + nSpin = vcl::ConvertValue( nSpin, m_aOrigSize.Width(), 0, + eUnit, m_xLeftMF->get_unit()); + + // if the margin is too big, it is set to 1/3 on both pages + tools::Long nR = lcl_GetValue( *m_xRightMF, eUnit ); + tools::Long nL = lcl_GetValue( *m_xLeftMF, eUnit ); + if((nL + nR) < - m_aOrigSize.Width()) + { + tools::Long nVal = m_aOrigSize.Width() / -3; + m_xRightMF->set_value( m_xRightMF->normalize( nVal ), eUnit ); + m_xLeftMF->set_value( m_xLeftMF->normalize( nVal ), eUnit ); + m_aExampleWN.SetLeft(nVal); + m_aExampleWN.SetRight(nVal); + } + tools::Long nUp = lcl_GetValue(*m_xTopMF, eUnit ); + tools::Long nLow = lcl_GetValue(*m_xBottomMF, eUnit ); + if((nUp + nLow) < - m_aOrigSize.Height()) + { + tools::Long nVal = m_aOrigSize.Height() / -3; + m_xTopMF->set_value( m_xTopMF->normalize( nVal ), eUnit ); + m_xBottomMF->set_value( m_xBottomMF->normalize( nVal ), eUnit ); + m_aExampleWN.SetTop(nVal); + m_aExampleWN.SetBottom(nVal); + } + + m_xLeftMF->set_increments(nSpin, nSpin * 10, FieldUnit::NONE); + m_xRightMF->set_increments(nSpin, nSpin * 10, FieldUnit::NONE); + nSpin = m_xTopMF->normalize(m_aOrigSize.Height()) / 20; + nSpin = vcl::ConvertValue( nSpin, m_aOrigSize.Width(), 0, + eUnit, m_xLeftMF->get_unit() ); + m_xTopMF->set_increments(nSpin, nSpin * 10, FieldUnit::NONE); + m_xBottomMF->set_increments(nSpin, nSpin * 10, FieldUnit::NONE); + + // display original size + const FieldUnit eMetric = GetModuleFieldUnit( GetItemSet() ); + + OUString sTemp; + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/spinbox.ui")); + std::unique_ptr<weld::Dialog> xTopLevel(xBuilder->weld_dialog("SpinDialog")); + std::unique_ptr<weld::MetricSpinButton> xFld(xBuilder->weld_metric_spin_button("spin", FieldUnit::CM)); + SetFieldUnit( *xFld, eMetric ); + xFld->set_digits(m_xWidthMF->get_digits()); + xFld->set_max(INT_MAX - 1, FieldUnit::NONE); + + xFld->set_value(xFld->normalize(m_aOrigSize.Width()), eUnit); + sTemp = xFld->get_text(); + xFld->set_value(xFld->normalize(m_aOrigSize.Height()), eUnit); + // multiplication sign (U+00D7) + sTemp += u"\u00D7" + xFld->get_text(); + } + + if ( m_aOrigPixelSize.Width() && m_aOrigPixelSize.Height() ) { + sal_Int32 ax = 0.5 + m_aOrigPixelSize.Width() / + o3tl::convert<double>(m_aOrigSize.Width(), o3tl::Length::twip, + o3tl::Length::in); + sal_Int32 ay = 0.5 + m_aOrigPixelSize.Height() / + o3tl::convert<double>(m_aOrigSize.Height(), o3tl::Length::twip, + o3tl::Length::in); + OUString sPPI = OUString::number(ax); + if (abs(ax - ay) > 1) { + sPPI += u"\u00D7" + OUString::number(ay); + } + sTemp += " " + CuiResId(RID_CUISTR_PPI).replaceAll("%1", sPPI); + } + sTemp += "\n" + OUString::number(m_aOrigPixelSize.Width()) + u"\u00D7" + OUString::number(m_aOrigPixelSize.Height()) + " px"; + m_xOrigSizeFT->set_label(sTemp); + } + + m_xCropFrame->set_sensitive(bFound); + m_xScaleFrame->set_sensitive(bFound); + m_xSizeFrame->set_sensitive(bFound); + m_xOrigSizeGrid->set_sensitive(bFound); + m_xZoomConstRB->set_sensitive(bFound); +} + +Size SvxGrfCropPage::GetGrfOrigSize(const Graphic& rGrf) +{ + Size aSize; + + if (m_aPreferredDPI > 0) + { + Size aPixelSize = rGrf.GetSizePixel(); + double fWidth = aPixelSize.Width() / double(m_aPreferredDPI); + double fHeight = aPixelSize.Height() / double(m_aPreferredDPI); + fWidth = o3tl::convert(fWidth, o3tl::Length::in, o3tl::Length::twip); + fHeight = o3tl::convert(fHeight, o3tl::Length::in, o3tl::Length::twip); + aSize = Size(fWidth, fHeight); + } + else + { + const MapMode aMapTwip( MapUnit::MapTwip ); + aSize = rGrf.GetPrefSize(); + if( MapUnit::MapPixel == rGrf.GetPrefMapMode().GetMapUnit() ) + aSize = Application::GetDefaultDevice()->PixelToLogic(aSize, aMapTwip); + else + aSize = OutputDevice::LogicToLogic( aSize, + rGrf.GetPrefMapMode(), aMapTwip ); + } + return aSize; +} + +/*****************************************************************/ + +SvxCropExample::SvxCropExample() + : m_aTopLeft(0, 0) + , m_aBottomRight(0, 0) +{ +} + +void SvxCropExample::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + OutputDevice& rDevice = pDrawingArea->get_ref_device(); + Size aSize(rDevice.LogicToPixel(Size(78, 78), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + + m_aMapMode = rDevice.GetMapMode(); + m_aFrameSize = OutputDevice::LogicToLogic( + Size(CM_1_TO_TWIP / 2, CM_1_TO_TWIP / 2), + MapMode(MapUnit::MapTwip), m_aMapMode); +} + +void SvxCropExample::Paint(vcl::RenderContext& rRenderContext, const ::tools::Rectangle&) +{ + rRenderContext.Push(vcl::PushFlags::MAPMODE); + rRenderContext.SetMapMode(m_aMapMode); + + // Win BG + const Size aWinSize(rRenderContext.PixelToLogic(GetOutputSizePixel())); + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetWindowColor()); + rRenderContext.DrawRect(::tools::Rectangle(Point(), aWinSize)); + + // use AA, the Graphic may be a metafile/svg and would then look ugly + rRenderContext.SetAntialiasing(AntialiasingFlags::Enable); + + // draw Graphic + ::tools::Rectangle aRect( + Point((aWinSize.Width() - m_aFrameSize.Width())/2, (aWinSize.Height() - m_aFrameSize.Height())/2), + m_aFrameSize); + m_aGrf.Draw(rRenderContext, aRect.TopLeft(), aRect.GetSize()); + + // Remove one more case that uses XOR paint (RasterOp::Invert). + // Get colors and logic DashLength from settings, use equal to + // PolygonMarkerPrimitive2D, may be changed to that primitive later. + // Use this to guarantee good visibility - that was the purpose of + // the former used XOR paint. + const Color aColA(SvtOptionsDrawinglayer::GetStripeColorA().getBColor()); + const Color aColB(SvtOptionsDrawinglayer::GetStripeColorB().getBColor()); + const double fStripeLength(SvtOptionsDrawinglayer::GetStripeLength()); + const basegfx::B2DVector aDashVector(rRenderContext.GetInverseViewTransformation() * basegfx::B2DVector(fStripeLength, 0.0)); + const double fLogicDashLength(aDashVector.getX()); + + // apply current crop settings + aRect.AdjustLeft(m_aTopLeft.Y()); + aRect.AdjustTop(m_aTopLeft.X()); + aRect.AdjustRight(-m_aBottomRight.Y()); + aRect.AdjustBottom(-m_aBottomRight.X()); + + // apply dash with direct paint callbacks + basegfx::utils::applyLineDashing( + basegfx::utils::createPolygonFromRect( + basegfx::B2DRange(aRect.Left(), aRect.Top(), aRect.Right(), aRect.Bottom())), + std::vector< double >(2, fLogicDashLength), + [&aColA,&rRenderContext](const basegfx::B2DPolygon& rSnippet) + { + rRenderContext.SetLineColor(aColA); + rRenderContext.DrawPolyLine(rSnippet); + }, + [&aColB,&rRenderContext](const basegfx::B2DPolygon& rSnippet) + { + rRenderContext.SetLineColor(aColB); + rRenderContext.DrawPolyLine(rSnippet); + }, + 2.0 * fLogicDashLength); + + rRenderContext.Pop(); +} + +void SvxCropExample::Resize() +{ + SetFrameSize(m_aFrameSize); +} + +void SvxCropExample::SetFrameSize( const Size& rSz ) +{ + m_aFrameSize = rSz; + if (!m_aFrameSize.Width()) + m_aFrameSize.setWidth( 1 ); + if (!m_aFrameSize.Height()) + m_aFrameSize.setHeight( 1 ); + Size aWinSize( GetOutputSizePixel() ); + Fraction aXScale( aWinSize.Width() * 4, m_aFrameSize.Width() * 5 ); + Fraction aYScale( aWinSize.Height() * 4, m_aFrameSize.Height() * 5 ); + + if( aYScale < aXScale ) + aXScale = aYScale; + + m_aMapMode.SetScaleX(aXScale); + m_aMapMode.SetScaleY(aXScale); + + Invalidate(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/labdlg.cxx b/cui/source/tabpages/labdlg.cxx new file mode 100644 index 000000000..cb048426c --- /dev/null +++ b/cui/source/tabpages/labdlg.cxx @@ -0,0 +1,507 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <swpossizetabpage.hxx> +#include <svtools/unitconv.hxx> + +#include <svx/svddef.hxx> +#include <svx/sxcecitm.hxx> +#include <svx/sxcgitm.hxx> +#include <svx/sxcllitm.hxx> +#include <svx/sxctitm.hxx> + +#include <svx/dlgutil.hxx> +#include <labdlg.hxx> +#include <transfrm.hxx> +#include <bitmaps.hlst> + +// define ---------------------------------------------------------------- + +#define EXT_OPTIMAL 0 +#define EXT_FROM_TOP 1 +#define EXT_FROM_LEFT 2 +#define EXT_HORIZONTAL 3 +#define EXT_VERTICAL 4 + +#define POS_TOP 0 +#define POS_MIDDLE 1 +#define POS_BOTTOM 2 + +#define BMP_CAPTTYPE_1 1 +#define BMP_CAPTTYPE_2 2 +#define BMP_CAPTTYPE_3 3 + +// static ---------------------------------------------------------------- + +const WhichRangesContainer SvxCaptionTabPage::pCaptionRanges( + svl::Items< + SDRATTR_CAPTIONTYPE, SDRATTR_CAPTIONFIXEDANGLE, + SDRATTR_CAPTIONANGLE, SDRATTR_CAPTIONGAP, + SDRATTR_CAPTIONESCDIR, SDRATTR_CAPTIONESCISREL, + SDRATTR_CAPTIONESCREL, SDRATTR_CAPTIONESCABS, + SDRATTR_CAPTIONLINELEN, SDRATTR_CAPTIONFITLINELEN>); + +SvxCaptionTabPage::SvxCaptionTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/calloutpage.ui", "CalloutPage", &rInAttrs) + , nCaptionType(SdrCaptionType::Type1) + , nGap(0) + , nEscDir(SdrCaptionEscDir::Horizontal) + , bEscRel(false) + , nEscAbs(0) + , nEscRel(0) + , nLineLen(0) + , bFitLineLen(false) + , nPosition(0) + , nExtension(0) + , rOutAttrs(rInAttrs) + , pView(nullptr) + , m_xMF_SPACING(m_xBuilder->weld_metric_spin_button("spacing", FieldUnit::MM)) + , m_xLB_EXTENSION(m_xBuilder->weld_combo_box("extension")) + , m_xFT_BYFT(m_xBuilder->weld_label("byft")) + , m_xMF_BY(m_xBuilder->weld_metric_spin_button("by", FieldUnit::MM)) + , m_xFT_POSITIONFT(m_xBuilder->weld_label("positionft")) + , m_xLB_POSITION(m_xBuilder->weld_combo_box("position")) + , m_xLineTypes(m_xBuilder->weld_combo_box("linetypes")) + , m_xFT_LENGTHFT(m_xBuilder->weld_label("lengthft")) + , m_xMF_LENGTH(m_xBuilder->weld_metric_spin_button("length", FieldUnit::MM)) + , m_xCB_OPTIMAL(m_xBuilder->weld_check_button("optimal")) + , m_xCT_CAPTTYPE(new ValueSet(m_xBuilder->weld_scrolled_window("valuesetwin", true))) + , m_xCT_CAPTTYPEWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xCT_CAPTTYPE)) +{ + Size aSize(m_xCT_CAPTTYPE->GetDrawingArea()->get_ref_device().LogicToPixel(Size(187, 38), MapMode(MapUnit::MapAppFont))); + m_xCT_CAPTTYPEWin->set_size_request(aSize.Width(), aSize.Height()); + + assert(m_xLB_POSITION->get_count() == 6); + for (int i = 0; i < 3; ++i) + m_aStrHorzList.push_back(m_xLB_POSITION->get_text(i)); + for (int i = 3; i < 6; ++i) + m_aStrVertList.push_back(m_xLB_POSITION->get_text(i)); + m_xLB_POSITION->clear(); + + assert(m_xLineTypes->get_count() == 3); + std::vector<OUString> aLineTypes; + aLineTypes.reserve(3); + for (int i = 0; i < 3; ++i) + aLineTypes.push_back(m_xLineTypes->get_text(i)); + + static_assert(CAPTYPE_BITMAPS_COUNT == 3, "unexpected"); + m_aBmpCapTypes[0] = Image(StockImage::Yes, RID_SVXBMP_LEGTYP1); + m_aBmpCapTypes[1] = Image(StockImage::Yes, RID_SVXBMP_LEGTYP2); + m_aBmpCapTypes[2] = Image(StockImage::Yes, RID_SVXBMP_LEGTYP3); + + //------------install ValueSet-------------------------- + m_xCT_CAPTTYPE->SetStyle( m_xCT_CAPTTYPE->GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER | WB_NAMEFIELD ); + m_xCT_CAPTTYPE->SetColCount(5);//XXX + m_xCT_CAPTTYPE->SetLineCount(1); + m_xCT_CAPTTYPE->SetSelectHdl(LINK( this, SvxCaptionTabPage, SelectCaptTypeHdl_Impl)); + + Image aImage; + m_xCT_CAPTTYPE->InsertItem(BMP_CAPTTYPE_1, aImage, aLineTypes[0]); + m_xCT_CAPTTYPE->InsertItem(BMP_CAPTTYPE_2, aImage, aLineTypes[1]); + m_xCT_CAPTTYPE->InsertItem(BMP_CAPTTYPE_3, aImage, aLineTypes[2]); + + FillValueSet(); + + m_xLB_EXTENSION->connect_changed(LINK(this, SvxCaptionTabPage, ExtensionSelectHdl_Impl)); + m_xLB_POSITION->connect_changed(LINK(this, SvxCaptionTabPage, PositionSelectHdl_Impl)); + m_xCB_OPTIMAL->connect_toggled(LINK(this, SvxCaptionTabPage, LineOptHdl_Impl)); +} + +SvxCaptionTabPage::~SvxCaptionTabPage() +{ + m_xCT_CAPTTYPEWin.reset(); + m_xCT_CAPTTYPE.reset(); +} + +void SvxCaptionTabPage::Construct() +{ + // set rectangle and working area + DBG_ASSERT( pView, "No valid View transferred!" ); +} + +bool SvxCaptionTabPage::FillItemSet( SfxItemSet* _rOutAttrs) +{ + SfxItemPool* pPool = _rOutAttrs->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + + MapUnit eUnit; + + nCaptionType = static_cast<SdrCaptionType>(m_xCT_CAPTTYPE->GetSelectedItemId()-1); + + _rOutAttrs->Put( SdrCaptionTypeItem( nCaptionType ) ); + + if (m_xMF_SPACING->get_value_changed_from_saved()) + { + eUnit = pPool->GetMetric( GetWhich( SDRATTR_CAPTIONGAP ) ); + _rOutAttrs->Put( SdrCaptionGapItem( GetCoreValue(*m_xMF_SPACING, eUnit ) ) ); + } + + // special treatment!!! XXX + if( nCaptionType==SdrCaptionType::Type1 ) + { + switch( nEscDir ) + { + case SdrCaptionEscDir::Horizontal: nEscDir=SdrCaptionEscDir::Vertical;break; + case SdrCaptionEscDir::Vertical: nEscDir=SdrCaptionEscDir::Horizontal;break; + default: break; + } + } + + _rOutAttrs->Put( SdrCaptionEscDirItem( nEscDir ) ); + + bEscRel = m_xLB_POSITION->get_visible(); + _rOutAttrs->Put( SdrCaptionEscIsRelItem( bEscRel ) ); + + if( bEscRel ) + { + tools::Long nVal = 0; + + switch (m_xLB_POSITION->get_active()) + { + case POS_TOP: nVal=0;break; + case POS_MIDDLE: nVal=5000;break; + case POS_BOTTOM: nVal=10000;break; + } + _rOutAttrs->Put( SdrCaptionEscRelItem( nVal ) ); + } + else + { + if (m_xMF_BY->get_value_changed_from_saved()) + { + eUnit = pPool->GetMetric( GetWhich( SDRATTR_CAPTIONESCABS ) ); + _rOutAttrs->Put( SdrCaptionEscAbsItem( GetCoreValue(*m_xMF_BY, eUnit ) ) ); + } + } + + bFitLineLen = m_xCB_OPTIMAL->get_active(); + _rOutAttrs->Put( SdrCaptionFitLineLenItem( bFitLineLen ) ); + + if( ! bFitLineLen ) + { + if (m_xMF_LENGTH->get_value_changed_from_saved()) + { + eUnit = pPool->GetMetric( GetWhich( SDRATTR_CAPTIONLINELEN ) ); + _rOutAttrs->Put( SdrCaptionLineLenItem( GetCoreValue(*m_xMF_LENGTH, eUnit ) ) ); + } + } + +//NYI-------------the angles have to be added here!!! XXX---------------------- + + return true; +} + +void SvxCaptionTabPage::Reset( const SfxItemSet* ) +{ + + //------------set metric----------------------------- + + FieldUnit eFUnit = GetModuleFieldUnit( rOutAttrs ); + + switch ( eFUnit ) + { + case FieldUnit::CM: + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + break; + default: ;//prevent warning + } + SetFieldUnit( *m_xMF_SPACING, eFUnit ); + SetFieldUnit( *m_xMF_BY, eFUnit ); + SetFieldUnit( *m_xMF_LENGTH, eFUnit ); + + SfxItemPool* pPool = rOutAttrs.GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + + sal_uInt16 nWhich; + MapUnit eUnit; + + nWhich = GetWhich( SDRATTR_CAPTIONESCABS ); + eUnit = pPool->GetMetric( nWhich ); + nEscAbs = static_cast<const SdrCaptionEscAbsItem&>( rOutAttrs.Get( nWhich ) ).GetValue(); + SetMetricValue( *m_xMF_BY, nEscAbs, eUnit ); + nEscAbs = m_xMF_BY->get_value(FieldUnit::NONE); + + nWhich = GetWhich( SDRATTR_CAPTIONESCREL ); + nEscRel = static_cast<tools::Long>(static_cast<const SdrCaptionEscRelItem&>( rOutAttrs.Get( nWhich ) ).GetValue()); + + //------- line length ---------- + nWhich = GetWhich( SDRATTR_CAPTIONLINELEN ); + eUnit = pPool->GetMetric( nWhich ); + nLineLen = static_cast<const SdrCaptionLineLenItem&>( rOutAttrs.Get( nWhich ) ).GetValue(); + SetMetricValue( *m_xMF_LENGTH, nLineLen, eUnit ); + nLineLen = m_xMF_LENGTH->get_value(FieldUnit::NONE); + + //------- distance to box ---------- + nWhich = GetWhich( SDRATTR_CAPTIONGAP ); + eUnit = pPool->GetMetric( nWhich ); + nGap = static_cast<const SdrCaptionGapItem&>( rOutAttrs.Get( nWhich ) ).GetValue(); + SetMetricValue( *m_xMF_SPACING, nGap, eUnit ); + nGap = m_xMF_SPACING->get_value(FieldUnit::NONE); + + nCaptionType = rOutAttrs.Get( GetWhich( SDRATTR_CAPTIONTYPE ) ).GetValue(); + bFitLineLen = static_cast<const SfxBoolItem&>( rOutAttrs.Get( GetWhich( SDRATTR_CAPTIONFITLINELEN ) ) ).GetValue(); + nEscDir = rOutAttrs.Get( GetWhich( SDRATTR_CAPTIONESCDIR ) ).GetValue(); + bEscRel = static_cast<const SfxBoolItem&>( rOutAttrs.Get( GetWhich( SDRATTR_CAPTIONESCISREL ) ) ).GetValue(); + + // special treatment!!! XXX + if( nCaptionType==SdrCaptionType::Type1 ) + { + switch( nEscDir ) + { + case SdrCaptionEscDir::Horizontal: nEscDir=SdrCaptionEscDir::Vertical;break; + case SdrCaptionEscDir::Vertical: nEscDir=SdrCaptionEscDir::Horizontal;break; + default: break; + } + } + + nPosition = POS_MIDDLE; + nExtension = EXT_OPTIMAL; + + m_xMF_SPACING->set_value(nGap, FieldUnit::NONE); + + if( nEscDir == SdrCaptionEscDir::Horizontal ) + { + if( bEscRel ) + { + if( nEscRel < 3333 ) + nPosition = POS_TOP; + if( nEscRel > 6666 ) + nPosition = POS_BOTTOM; + nExtension = EXT_HORIZONTAL; + } + else + { + nExtension = EXT_FROM_TOP; + m_xMF_BY->set_value(nEscAbs, FieldUnit::NONE); + } + } + else if( nEscDir == SdrCaptionEscDir::Vertical ) + { + if( bEscRel ) + { + if( nEscRel < 3333 ) + nPosition = POS_TOP; + if( nEscRel > 6666 ) + nPosition = POS_BOTTOM; + nExtension = EXT_VERTICAL; + } + else + { + nExtension = EXT_FROM_LEFT; + m_xMF_BY->set_value(nEscAbs, FieldUnit::NONE); + } + } + else if( nEscDir == SdrCaptionEscDir::BestFit ) + { + nExtension = EXT_OPTIMAL; + } + + m_xCB_OPTIMAL->set_active(bFitLineLen); + m_xMF_LENGTH->set_value(nLineLen, FieldUnit::NONE); + + m_xLB_EXTENSION->set_active(nExtension); + + SetupExtension_Impl( nExtension ); + m_xCT_CAPTTYPE->SelectItem( static_cast<int>(nCaptionType)+1 ); // Enum starts at 0! + SetupType_Impl( nCaptionType ); +} + +std::unique_ptr<SfxTabPage> SvxCaptionTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rOutAttrs) +{ + return std::make_unique<SvxCaptionTabPage>(pPage, pController, *rOutAttrs); +} + +void SvxCaptionTabPage::SetupExtension_Impl( sal_uInt16 nType ) +{ + switch( nType ) + { + case EXT_OPTIMAL: + m_xMF_BY->show(); + m_xFT_BYFT->show(); + m_xFT_POSITIONFT->hide(); + m_xLB_POSITION->hide(); + nEscDir = SdrCaptionEscDir::BestFit; + break; + + case EXT_FROM_TOP: + m_xMF_BY->show(); + m_xFT_BYFT->show(); + m_xFT_POSITIONFT->hide(); + m_xLB_POSITION->hide(); + nEscDir = SdrCaptionEscDir::Horizontal; + break; + + case EXT_FROM_LEFT: + m_xMF_BY->show(); + m_xFT_BYFT->show(); + m_xFT_POSITIONFT->hide(); + m_xLB_POSITION->hide(); + nEscDir = SdrCaptionEscDir::Vertical; + break; + + case EXT_HORIZONTAL: + m_xLB_POSITION->clear(); + for (const OUString & i : m_aStrHorzList) + m_xLB_POSITION->append_text(i); + m_xLB_POSITION->set_active(nPosition); + + m_xMF_BY->hide(); + m_xFT_BYFT->hide(); + m_xFT_POSITIONFT->show(); + m_xLB_POSITION->show(); + nEscDir = SdrCaptionEscDir::Horizontal; + break; + + case EXT_VERTICAL: + m_xLB_POSITION->clear(); + for (const OUString & i : m_aStrVertList) + m_xLB_POSITION->append_text(i); + m_xLB_POSITION->set_active(nPosition); + + m_xMF_BY->hide(); + m_xFT_BYFT->hide(); + m_xFT_POSITIONFT->show(); + m_xLB_POSITION->show(); + nEscDir = SdrCaptionEscDir::Vertical; + break; + } +} + +IMPL_LINK(SvxCaptionTabPage, ExtensionSelectHdl_Impl, weld::ComboBox&, rListBox, void) +{ + if (&rListBox == m_xLB_EXTENSION.get()) + { + SetupExtension_Impl(m_xLB_EXTENSION->get_active()); + } +} + +IMPL_LINK(SvxCaptionTabPage, PositionSelectHdl_Impl, weld::ComboBox&, rListBox, void) +{ + if (&rListBox == m_xLB_POSITION.get()) + { + nPosition = m_xLB_POSITION->get_active(); + } +} + +IMPL_LINK( SvxCaptionTabPage, LineOptHdl_Impl, weld::Toggleable&, rButton, void ) +{ + if (&rButton != m_xCB_OPTIMAL.get()) + return; + + if (m_xCB_OPTIMAL->get_active() || !m_xCB_OPTIMAL->get_sensitive()) + { + m_xFT_LENGTHFT->set_sensitive(false); + m_xMF_LENGTH->set_sensitive(false); + } + else + { + m_xFT_LENGTHFT->set_sensitive(true); + m_xMF_LENGTH->set_sensitive(true); + } +} + +IMPL_LINK_NOARG(SvxCaptionTabPage, SelectCaptTypeHdl_Impl, ValueSet*, void) +{ + SetupType_Impl( static_cast<SdrCaptionType>(m_xCT_CAPTTYPE->GetSelectedItemId()) ); +} + +void SvxCaptionTabPage::SetupType_Impl( SdrCaptionType nType ) +{ + switch( nType ) + { + case SdrCaptionType::Type1: + case SdrCaptionType::Type2: + m_xFT_LENGTHFT->set_sensitive(false); + m_xCB_OPTIMAL->set_sensitive(false); + LineOptHdl_Impl(*m_xCB_OPTIMAL); + break; + case SdrCaptionType::Type3: + case SdrCaptionType::Type4: + m_xFT_LENGTHFT->set_sensitive(true); + m_xCB_OPTIMAL->set_sensitive(true); + LineOptHdl_Impl(*m_xCB_OPTIMAL); + break; + } +} + +void SvxCaptionTabPage::FillValueSet() +{ + m_xCT_CAPTTYPE->SetItemImage(BMP_CAPTTYPE_1, m_aBmpCapTypes[0] ); + m_xCT_CAPTTYPE->SetItemImage(BMP_CAPTTYPE_2, m_aBmpCapTypes[1] ); + m_xCT_CAPTTYPE->SetItemImage(BMP_CAPTTYPE_3, m_aBmpCapTypes[2] ); +} + +SvxCaptionTabDialog::SvxCaptionTabDialog(weld::Window* pParent, const SdrView* pSdrView, + SvxAnchorIds nAnchorTypes) + : SfxTabDialogController(pParent, "cui/ui/calloutdialog.ui", "CalloutDialog") + , pView(pSdrView) + , nAnchorCtrls(nAnchorTypes) +{ + assert(pView); // No valid View transferred! + + //different positioning page in Writer + if (nAnchorCtrls & (SvxAnchorIds::Paragraph | SvxAnchorIds::Character | SvxAnchorIds::Page | SvxAnchorIds::Fly)) + { + AddTabPage("RID_SVXPAGE_SWPOSSIZE", SvxSwPosSizeTabPage::Create, + SvxSwPosSizeTabPage::GetRanges ); + RemoveTabPage("RID_SVXPAGE_POSITION_SIZE"); + } + else + { + AddTabPage("RID_SVXPAGE_POSITION_SIZE", SvxPositionSizeTabPage::Create, + SvxPositionSizeTabPage::GetRanges ); + RemoveTabPage("RID_SVXPAGE_SWPOSSIZE"); + } + AddTabPage("RID_SVXPAGE_CAPTION", SvxCaptionTabPage::Create, + SvxCaptionTabPage::GetRanges ); +} + +void SvxCaptionTabDialog::PageCreated(const OString& rId, SfxTabPage &rPage) +{ + if (rId == "RID_SVXPAGE_POSITION_SIZE") + { + static_cast<SvxPositionSizeTabPage&>( rPage ).SetView( pView ); + static_cast<SvxPositionSizeTabPage&>( rPage ).Construct(); + if( nAnchorCtrls & SvxAnchorIds::NoResize ) + static_cast<SvxPositionSizeTabPage&>( rPage ).DisableResize(); + + if( nAnchorCtrls & SvxAnchorIds::NoProtect ) + static_cast<SvxPositionSizeTabPage&>( rPage ).DisableProtect(); + } + else if (rId == "RID_SVXPAGE_SWPOSSIZE") + { + SvxSwPosSizeTabPage& rSwPage = static_cast<SvxSwPosSizeTabPage&>(rPage); + rSwPage.EnableAnchorTypes(nAnchorCtrls); + rSwPage.SetValidateFramePosLink( aValidateLink ); + } + else if (rId == "RID_SVXPAGE_CAPTION") + { + static_cast<SvxCaptionTabPage&>( rPage ).SetView( pView ); + static_cast<SvxCaptionTabPage&>( rPage ).Construct(); + } +} + +void SvxCaptionTabDialog::SetValidateFramePosLink( const Link<SvxSwFrameValidation&,void>& rLink ) +{ + aValidateLink = rLink; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/macroass.cxx b/cui/source/tabpages/macroass.cxx new file mode 100644 index 000000000..e80e471ff --- /dev/null +++ b/cui/source/tabpages/macroass.cxx @@ -0,0 +1,397 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <macroass.hxx> +#include <o3tl/safeint.hxx> +#include <o3tl/string_view.hxx> +#include <osl/diagnose.h> +#include <comphelper/string.hxx> +#include <comphelper/processfactory.hxx> +#include <svl/macitem.hxx> +#include <svx/svxids.hrc> +#include <tools/debug.hxx> +#include <vcl/idle.hxx> +#include <cfgutil.hxx> +#include <sfx2/evntconf.hxx> +#include <headertablistbox.hxx> + +using ::com::sun::star::uno::Reference; +using ::com::sun::star::frame::XFrame; + +class SfxMacroTabPage_Impl +{ +public: + SfxMacroTabPage_Impl(); + + OUString m_aStaticMacroLBLabel; + std::unique_ptr<weld::Button> m_xAssignPB; + std::unique_ptr<weld::Button> m_xDeletePB; + std::unique_ptr<MacroEventListBox> m_xEventLB; + std::unique_ptr<weld::Widget> m_xGroupFrame; + std::unique_ptr<CuiConfigGroupListBox> m_xGroupLB; + std::unique_ptr<weld::Frame> m_xMacroFrame; + std::unique_ptr<CuiConfigFunctionListBox> m_xMacroLB; + + Idle m_aFillGroupIdle { "cui SfxMacroTabPage m_aFillGroupIdle" }; + bool m_bGotEvents; +}; + +SfxMacroTabPage_Impl::SfxMacroTabPage_Impl() + : m_bGotEvents(false) +{ +} + +static sal_uInt16 aPageRg[] = { + SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, + 0 +}; + +static OUString ConvertToUIName_Impl( SvxMacro const *pMacro ) +{ + OUString aName( pMacro->GetMacName() ); + if ( pMacro->GetLanguage() != "JavaScript" ) + { + const sal_Int32 nCount = comphelper::string::getTokenCount(aName, '.'); + OUString aEntry = aName.getToken( nCount-1, '.' ); + if ( nCount > 2 ) + { + aEntry += OUString::Concat("(") + o3tl::getToken(aName, 0, '.' ) + "." + o3tl::getToken(aName, nCount-2, '.' ) + ")"; + } + return aEntry; + } + else + return aName; +} + +void SfxMacroTabPage::EnableButtons() +{ + // don't do anything as long as the eventbox is empty + weld::TreeView& rTreeView = mpImpl->m_xEventLB->GetListBox(); + int nSelected = rTreeView.get_selected_index(); + if (nSelected != -1) + { + // get bound macro + const SvxMacro* pM = aTbl.Get(static_cast<SvMacroItemId>(rTreeView.get_selected_id().toInt32())); + mpImpl->m_xDeletePB->set_sensitive(nullptr != pM); + + OUString sEventMacro = rTreeView.get_text(nSelected, 1); + + OUString sScriptURI = mpImpl->m_xMacroLB->GetSelectedScriptURI(); + mpImpl->m_xAssignPB->set_sensitive(!sScriptURI.equalsIgnoreAsciiCase(sEventMacro)); + } + else + mpImpl->m_xAssignPB->set_sensitive(false); +} + +SfxMacroTabPage::SfxMacroTabPage(weld::Container* pPage, weld::DialogController* pController, const Reference< XFrame >& rxDocumentFrame, const SfxItemSet& rAttrSet ) + : SfxTabPage(pPage, pController, "cui/ui/eventassignpage.ui", "EventAssignPage", &rAttrSet) +{ + mpImpl.reset(new SfxMacroTabPage_Impl); + + mpImpl->m_aFillGroupIdle.SetInvokeHandler( LINK( this, SfxMacroTabPage, TimeOut_Impl ) ); + mpImpl->m_aFillGroupIdle.SetPriority( TaskPriority::HIGHEST ); + + mpImpl->m_xEventLB.reset(new MacroEventListBox(m_xBuilder->weld_tree_view("assignments"))); + mpImpl->m_xAssignPB = m_xBuilder->weld_button("assign"); + mpImpl->m_xDeletePB = m_xBuilder->weld_button("delete"); + mpImpl->m_xGroupFrame = m_xBuilder->weld_widget("groupframe"); + mpImpl->m_xGroupLB.reset(new CuiConfigGroupListBox(m_xBuilder->weld_tree_view("libraries"))); + mpImpl->m_xMacroFrame = m_xBuilder->weld_frame("macroframe"); + mpImpl->m_aStaticMacroLBLabel = mpImpl->m_xMacroFrame->get_label(); + mpImpl->m_xMacroLB.reset(new CuiConfigFunctionListBox(m_xBuilder->weld_tree_view("macros"))); + + SetFrame( rxDocumentFrame ); + + InitAndSetHandler(); + + ScriptChanged(); +} + +SfxMacroTabPage::~SfxMacroTabPage() +{ + mpImpl.reset(); +} + +void SfxMacroTabPage::AddEvent(const OUString& rEventName, SvMacroItemId nEventId) +{ + weld::TreeView& rTreeView = mpImpl->m_xEventLB->GetListBox(); + rTreeView.append(OUString::number(static_cast<sal_Int32>(nEventId)), rEventName); + + // if the table is valid already + SvxMacro* pM = aTbl.Get(nEventId); + if (pM) + { + OUString sNew(ConvertToUIName_Impl(pM)); + rTreeView.set_text(rTreeView.n_children() - 1, sNew, 1); + } +} + +void SfxMacroTabPage::ScriptChanged() +{ + // get new areas and their functions + mpImpl->m_xGroupFrame->show(); + mpImpl->m_xMacroFrame->show(); + + EnableButtons(); +} + +bool SfxMacroTabPage::FillItemSet( SfxItemSet* rSet ) +{ + SvxMacroItem aItem( GetWhich( aPageRg[0] ) ); + const_cast<SvxMacroTableDtor&>(aItem.GetMacroTable()) = aTbl; + + const SfxPoolItem* pItem = nullptr; + SfxItemState eState = GetItemSet().GetItemState(aItem.Which(), true, &pItem); + if (eState == SfxItemState::DEFAULT && aTbl.empty()) + { + // Don't touch the item set if there was no input and our table is empty. + return false; + } + if (SfxItemState::SET != eState || aItem != *static_cast<const SvxMacroItem*>(pItem)) + { + rSet->Put( aItem ); + return true; + } + return false; +} + +void SfxMacroTabPage::LaunchFillGroup() +{ + if (! mpImpl->m_aFillGroupIdle.IsActive() ) + mpImpl->m_aFillGroupIdle.Start(); +} + +void SfxMacroTabPage::ActivatePage( const SfxItemSet& ) +{ + LaunchFillGroup(); +} + +void SfxMacroTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + if( mpImpl->m_bGotEvents ) + return; + if( const SfxEventNamesItem* pEventsItem = aSet.GetItemIfSet( SID_EVENTCONFIG ) ) + { + mpImpl->m_bGotEvents = true; + const SfxEventNamesList& rList = pEventsItem->GetEvents(); + for ( size_t nNo = 0, nCnt = rList.size(); nNo < nCnt; ++nNo ) + { + const SfxEventName &rOwn = rList.at(nNo); + AddEvent( rOwn.maUIName, rOwn.mnId ); + } + } +} + +void SfxMacroTabPage::Reset( const SfxItemSet* rSet ) +{ + const SfxPoolItem* pItem; + if( SfxItemState::SET == rSet->GetItemState( GetWhich( aPageRg[0] ), true, &pItem )) + aTbl = static_cast<const SvxMacroItem*>(pItem)->GetMacroTable(); + + const SfxEventNamesItem* pEventsItem; + if( !mpImpl->m_bGotEvents && (pEventsItem = rSet->GetItemIfSet( SID_EVENTCONFIG ) ) ) + { + mpImpl->m_bGotEvents = true; + const SfxEventNamesList& rList = pEventsItem->GetEvents(); + for ( size_t nNo = 0, nCnt = rList.size(); nNo < nCnt; ++nNo ) + { + const SfxEventName &rOwn = rList.at(nNo); + AddEvent( rOwn.maUIName, rOwn.mnId ); + } + } + + FillEvents(); + + weld::TreeView& rListBox = mpImpl->m_xEventLB->GetListBox(); + std::unique_ptr<weld::TreeIter> xIter(rListBox.make_iterator()); + if (rListBox.get_iter_first(*xIter)) + rListBox.set_cursor(*xIter); +} + +bool SfxMacroTabPage::IsReadOnly() const +{ + return false; +} + +IMPL_LINK_NOARG(SfxMacroTabPage, SelectEvent_Impl, weld::TreeView&, void) +{ + weld::TreeView& rListBox = mpImpl->m_xEventLB->GetListBox(); + int nSelected = rListBox.get_selected_index(); + if (nSelected == -1) + { + DBG_ASSERT(nSelected != -1, "Where does the empty entry come from?"); + return; + } + + ScriptChanged(); + EnableButtons(); +} + +IMPL_LINK_NOARG(SfxMacroTabPage, SelectGroup_Impl, weld::TreeView&, void) +{ + mpImpl->m_xGroupLB->GroupSelected(); + const OUString sScriptURI = mpImpl->m_xMacroLB->GetSelectedScriptURI(); + OUString aLabelText; + if( !sScriptURI.isEmpty() ) + aLabelText = mpImpl->m_aStaticMacroLBLabel; + mpImpl->m_xMacroFrame->set_label( aLabelText ); + + EnableButtons(); +} + +IMPL_LINK_NOARG(SfxMacroTabPage, SelectMacro_Impl, weld::TreeView&, void) +{ + EnableButtons(); +} + +IMPL_LINK(SfxMacroTabPage, AssignDeleteClickHdl_Impl, weld::Button&, rBtn, void) +{ + AssignDeleteHdl(&rBtn); +} + +IMPL_LINK(SfxMacroTabPage, AssignDeleteHdl_Impl, weld::TreeView&, rBtn, bool) +{ + AssignDeleteHdl(&rBtn); + return true; +} + +void SfxMacroTabPage::AssignDeleteHdl(const weld::Widget* pBtn) +{ + weld::TreeView& rListBox = mpImpl->m_xEventLB->GetListBox(); + int nSelected = rListBox.get_selected_index(); + if (nSelected == -1) + { + DBG_ASSERT(nSelected != -1, "Where does the empty entry come from?"); + return; + } + + const bool bAssEnabled = pBtn != mpImpl->m_xDeletePB.get() && mpImpl->m_xAssignPB->get_sensitive(); + + // remove from the table + SvMacroItemId nEvent = static_cast<SvMacroItemId>(rListBox.get_selected_id().toInt32()); + aTbl.Erase( nEvent ); + + OUString sScriptURI; + if( bAssEnabled ) + { + sScriptURI = mpImpl->m_xMacroLB->GetSelectedScriptURI(); + if( sScriptURI.startsWith( "vnd.sun.star.script:" ) ) + { + aTbl.Insert( + nEvent, SvxMacro( sScriptURI, SVX_MACRO_LANGUAGE_SF ) ); + } + else + { + OSL_ENSURE( false, "SfxMacroTabPage::AssignDeleteHdl_Impl: this branch is *not* dead? (out of interest: tell fs, please!)" ); + aTbl.Insert( + nEvent, SvxMacro( sScriptURI, SVX_MACRO_LANGUAGE_STARBASIC ) ); + } + } + + rListBox.set_text(nSelected, sScriptURI, 1); + + EnableButtons(); +} + +IMPL_LINK( SfxMacroTabPage, TimeOut_Impl, Timer*,, void ) +{ + // FillMacroList() can take a long time -> show wait cursor and disable input + weld::Window* pDialog = GetFrameWeld(); + // perhaps the tabpage is part of a SingleTabDialog then pDialog == nullptr + std::unique_ptr<weld::WaitObject> xWait(pDialog ? new weld::WaitObject(pDialog) : nullptr); + // fill macro list + mpImpl->m_xGroupLB->Init(comphelper::getProcessComponentContext(), GetFrame(), + OUString(), false); +} + +void SfxMacroTabPage::InitAndSetHandler() +{ + weld::TreeView& rListBox = mpImpl->m_xEventLB->GetListBox(); + Link<weld::TreeView&,bool> aLnk(LINK(this, SfxMacroTabPage, AssignDeleteHdl_Impl)); + mpImpl->m_xMacroLB->connect_row_activated( aLnk); + mpImpl->m_xDeletePB->connect_clicked(LINK(this, SfxMacroTabPage, AssignDeleteClickHdl_Impl)); + mpImpl->m_xAssignPB->connect_clicked(LINK(this, SfxMacroTabPage, AssignDeleteClickHdl_Impl)); + rListBox.connect_row_activated(aLnk); + + rListBox.connect_changed(LINK(this, SfxMacroTabPage, SelectEvent_Impl)); + mpImpl->m_xGroupLB->connect_changed(LINK(this, SfxMacroTabPage, SelectGroup_Impl)); + mpImpl->m_xMacroLB->connect_changed(LINK(this, SfxMacroTabPage, SelectMacro_Impl)); + + std::vector<int> aWidths + { + o3tl::narrowing<int>(rListBox.get_approximate_digit_width() * 35) + }; + rListBox.set_column_fixed_widths(aWidths); + + mpImpl->m_xEventLB->show(); + + mpImpl->m_xEventLB->set_sensitive(true); + mpImpl->m_xGroupLB->set_sensitive(true); + mpImpl->m_xMacroLB->set_sensitive(true); + + mpImpl->m_xGroupLB->SetFunctionListBox(mpImpl->m_xMacroLB.get()); +} + +void SfxMacroTabPage::FillEvents() +{ + weld::TreeView& rListBox = mpImpl->m_xEventLB->GetListBox(); + + int nEntryCnt = rListBox.n_children(); + + // get events from the table and fill the EventListBox respectively + for (int n = 0 ; n < nEntryCnt; ++n) + { + OUString sOld = rListBox.get_text(n, 1); + OUString sNew; + SvMacroItemId nEventId = static_cast<SvMacroItemId>(rListBox.get_id(n).toInt32()); + if (aTbl.IsKeyValid(nEventId)) + sNew = ConvertToUIName_Impl(aTbl.Get(nEventId)); + + if (sOld == sNew) + continue; + + rListBox.set_text(n, sNew, 1); + } +} + +namespace +{ + std::unique_ptr<SfxMacroTabPage> CreateSfxMacroTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttrSet) + { + return std::make_unique<SfxMacroTabPage>( pPage, pController, nullptr, rAttrSet ); + } +} + +std::unique_ptr<SfxTabPage> SfxMacroTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrSet) +{ + return CreateSfxMacroTabPage(pPage, pController, *rAttrSet); +} + +SfxMacroAssignDlg::SfxMacroAssignDlg(weld::Widget* pParent, + const Reference< XFrame >& rxDocumentFrame, const SfxItemSet& rSet) + : SfxSingleTabDialogController(pParent, &rSet,"cui/ui/eventassigndialog.ui", + "EventAssignDialog") +{ + std::unique_ptr<SfxMacroTabPage> xPage = CreateSfxMacroTabPage(get_content_area(), this, rSet); + xPage->SetFrame(rxDocumentFrame); + SetTabPage(std::move(xPage)); + GetTabPage()->LaunchFillGroup(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/measure.cxx b/cui/source/tabpages/measure.cxx new file mode 100644 index 000000000..fe61ed53a --- /dev/null +++ b/cui/source/tabpages/measure.cxx @@ -0,0 +1,755 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <strings.hrc> +#include <dialmgr.hxx> + +#include <svx/svxids.hrc> +#include <svx/dlgutil.hxx> +#include <svx/measctrl.hxx> +#include <svx/ofaitem.hxx> +#include <svx/strarray.hxx> +#include <svx/svdview.hxx> +#include <svx/sxmbritm.hxx> +#include <svx/sxmlhitm.hxx> +#include <svx/sxmtfitm.hxx> +#include <svx/sxmtpitm.hxx> +#include <svx/sxmtritm.hxx> +#include <svx/sxmuitm.hxx> +#include <svtools/unitconv.hxx> + +#include <measure.hxx> + +const WhichRangesContainer SvxMeasurePage::pRanges( + svl::Items<SDRATTR_MEASURE_FIRST, SDRATTR_MEASURE_LAST>); + +/************************************************************************* +|* +|* Dialog to change measure-attributes +|* +\************************************************************************/ +SvxMeasureDialog::SvxMeasureDialog(weld::Window* pParent, const SfxItemSet& rInAttrs, + const SdrView* pSdrView) + : SfxSingleTabDialogController(pParent, &rInAttrs) +{ + auto xPage = std::make_unique<SvxMeasurePage>(get_content_area(), this, rInAttrs); + + xPage->SetView(pSdrView); + xPage->Construct(); + + SetTabPage(std::move(xPage)); + m_xDialog->set_title(CuiResId(RID_CUISTR_DIMENSION_LINE)); +} + +/************************************************************************* +|* +|* Tabpage for changing measure-attributes +|* +\************************************************************************/ + +SvxMeasurePage::SvxMeasurePage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxTabPage(pPage, pController, "cui/ui/dimensionlinestabpage.ui", "DimensionLinesTabPage", rInAttrs) + , rOutAttrs(rInAttrs) + , aAttrSet(*rInAttrs.GetPool()) + , pView(nullptr) + , eUnit(MapUnit::Map100thMM) + , bPositionModified(false) + , m_aCtlPosition(this) + , m_xMtrFldLineDist(m_xBuilder->weld_metric_spin_button("MTR_LINE_DIST", FieldUnit::MM)) + , m_xMtrFldHelplineOverhang(m_xBuilder->weld_metric_spin_button("MTR_FLD_HELPLINE_OVERHANG", FieldUnit::MM)) + , m_xMtrFldHelplineDist(m_xBuilder->weld_metric_spin_button("MTR_FLD_HELPLINE_DIST", FieldUnit::MM)) + , m_xMtrFldHelpline1Len(m_xBuilder->weld_metric_spin_button("MTR_FLD_HELPLINE1_LEN", FieldUnit::MM)) + , m_xMtrFldHelpline2Len(m_xBuilder->weld_metric_spin_button("MTR_FLD_HELPLINE2_LEN", FieldUnit::MM)) + , m_xTsbBelowRefEdge(m_xBuilder->weld_check_button("TSB_BELOW_REF_EDGE")) + , m_xMtrFldDecimalPlaces(m_xBuilder->weld_spin_button("MTR_FLD_DECIMALPLACES")) + , m_xTsbAutoPosV(m_xBuilder->weld_check_button("TSB_AUTOPOSV")) + , m_xTsbAutoPosH(m_xBuilder->weld_check_button("TSB_AUTOPOSH")) + , m_xTsbShowUnit(m_xBuilder->weld_check_button("TSB_SHOW_UNIT")) + , m_xLbUnit(m_xBuilder->weld_combo_box("LB_UNIT")) + , m_xTsbParallel(m_xBuilder->weld_check_button("TSB_PARALLEL")) + , m_xFtAutomatic(m_xBuilder->weld_label("STR_MEASURE_AUTOMATIC")) + , m_xCtlPosition(new weld::CustomWeld(*m_xBuilder, "CTL_POSITION", m_aCtlPosition)) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview)) +{ + m_aCtlPreview.SetAttributes(rInAttrs); + + FillUnitLB(); + + const FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs ); + SetFieldUnit( *m_xMtrFldLineDist, eFUnit ); + SetFieldUnit( *m_xMtrFldHelplineOverhang, eFUnit ); + SetFieldUnit( *m_xMtrFldHelplineDist, eFUnit ); + SetFieldUnit( *m_xMtrFldHelpline1Len, eFUnit ); + SetFieldUnit( *m_xMtrFldHelpline2Len, eFUnit ); + if( eFUnit == FieldUnit::MM ) + { + m_xMtrFldLineDist->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldHelplineOverhang->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldHelplineDist->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldHelpline1Len->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldHelpline2Len->set_increments(50, 500, FieldUnit::NONE); + } + + m_xTsbAutoPosV->connect_toggled(LINK( this, SvxMeasurePage, ClickAutoPosHdl_Impl)); + m_xTsbAutoPosH->connect_toggled(LINK(this, SvxMeasurePage, ClickAutoPosHdl_Impl)); + + Link<weld::MetricSpinButton&,void> aLink(LINK(this, SvxMeasurePage, ChangeAttrEditHdl_Impl)); + m_xMtrFldLineDist->set_range(-10000, 10000, FieldUnit::MM); + m_xMtrFldLineDist->connect_value_changed(aLink); + m_xMtrFldHelplineOverhang->connect_value_changed(aLink); + m_xMtrFldHelplineOverhang->set_range(-10000, 10000, FieldUnit::MM); + m_xMtrFldHelplineDist->connect_value_changed(aLink); + m_xMtrFldHelplineDist->set_range(-10000, 10000, FieldUnit::MM); + m_xMtrFldHelpline1Len->connect_value_changed(aLink); + m_xMtrFldHelpline1Len->set_range(-10000, 10000, FieldUnit::MM); + m_xMtrFldHelpline2Len->connect_value_changed(aLink); + m_xMtrFldHelpline2Len->set_range(-10000, 10000, FieldUnit::MM); + m_xMtrFldDecimalPlaces->connect_value_changed(LINK(this, SvxMeasurePage, ChangeAttrSpinHdl_Impl)); + m_xTsbBelowRefEdge->connect_toggled(LINK(this, SvxMeasurePage, ChangeAttrClickHdl_Impl)); + m_xTsbParallel->connect_toggled( LINK( this, SvxMeasurePage, ChangeAttrClickHdl_Impl)); + m_xTsbShowUnit->connect_toggled(LINK(this, SvxMeasurePage, ChangeAttrClickHdl_Impl)); + m_xLbUnit->connect_changed(LINK(this, SvxMeasurePage, ChangeAttrListBoxHdl_Impl)); +} + +SvxMeasurePage::~SvxMeasurePage() +{ + m_xCtlPreview.reset(); + m_xCtlPosition.reset(); +} + +/************************************************************************* +|* +|* read the delivered Item-Set +|* +\************************************************************************/ + +void SvxMeasurePage::Reset( const SfxItemSet* rAttrs ) +{ + SfxItemPool* pPool = rAttrs->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + eUnit = pPool->GetMetric( SDRATTR_MEASURELINEDIST ); + + const SfxPoolItem* pItem = GetItem( *rAttrs, SDRATTR_MEASURELINEDIST ); + + // SdrMeasureLineDistItem + if( pItem == nullptr ) + pItem = &pPool->GetDefaultItem( SDRATTR_MEASURELINEDIST ); + SetMetricValue(*m_xMtrFldLineDist, static_cast<const SdrMetricItem*>(pItem)->GetValue(), eUnit); + m_xMtrFldLineDist->save_value(); + + // SdrMeasureHelplineOverhangItem + pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINEOVERHANG ); + if( pItem == nullptr ) + pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINEOVERHANG ); + SetMetricValue(*m_xMtrFldHelplineOverhang, static_cast<const SdrMetricItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldHelplineOverhang->save_value(); + + // SdrMeasureHelplineDistItem + pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINEDIST ); + if( pItem == nullptr ) + pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINEDIST ); + SetMetricValue(*m_xMtrFldHelplineDist, static_cast<const SdrMetricItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldHelplineDist->save_value(); + + // SdrMeasureHelpline1LenItem + pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINE1LEN ); + if( pItem == nullptr ) + pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINE1LEN ); + SetMetricValue(*m_xMtrFldHelpline1Len, static_cast<const SdrMetricItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldHelpline1Len->save_value(); + + // SdrMeasureHelpline2LenItem + pItem = GetItem( *rAttrs, SDRATTR_MEASUREHELPLINE2LEN ); + if( pItem == nullptr ) + pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREHELPLINE2LEN ); + SetMetricValue(*m_xMtrFldHelpline2Len, static_cast<const SdrMetricItem*>(pItem)->GetValue(), + eUnit); + m_xMtrFldHelpline2Len->save_value(); + + // SdrMeasureBelowRefEdgeItem + if( rAttrs->GetItemState( SDRATTR_MEASUREBELOWREFEDGE ) != SfxItemState::DONTCARE ) + { + m_xTsbBelowRefEdge->set_state( rAttrs->Get( SDRATTR_MEASUREBELOWREFEDGE ). + GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + else + { + m_xTsbBelowRefEdge->set_state( TRISTATE_INDET ); + } + m_xTsbBelowRefEdge->save_state(); + + // SdrMeasureDecimalPlacesItem + pItem = GetItem( *rAttrs, SDRATTR_MEASUREDECIMALPLACES ); + if( pItem == nullptr ) + pItem = &pPool->GetDefaultItem( SDRATTR_MEASUREDECIMALPLACES ); + m_xMtrFldDecimalPlaces->set_value( + static_cast<const SdrMeasureDecimalPlacesItem*>(pItem)->GetValue()); + m_xMtrFldDecimalPlaces->save_value(); + + // SdrMeasureTextRota90Item + // Attention: negate ! + if( rAttrs->GetItemState( SDRATTR_MEASURETEXTROTA90 ) != SfxItemState::DONTCARE ) + { + m_xTsbParallel->set_state( rAttrs->Get( SDRATTR_MEASURETEXTROTA90 ). + GetValue() ? TRISTATE_FALSE : TRISTATE_TRUE ); + } + else + { + m_xTsbParallel->set_state( TRISTATE_INDET ); + } + m_xTsbParallel->save_state(); + + // SdrMeasureShowUnitItem + if( rAttrs->GetItemState( SDRATTR_MEASURESHOWUNIT ) != SfxItemState::DONTCARE ) + { + m_xTsbShowUnit->set_state( rAttrs->Get( SDRATTR_MEASURESHOWUNIT ). + GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + else + { + m_xTsbShowUnit->set_state( TRISTATE_INDET ); + } + m_xTsbShowUnit->save_state(); + + // SdrMeasureUnitItem + if( rAttrs->GetItemState( SDRATTR_MEASUREUNIT ) != SfxItemState::DONTCARE ) + { + tools::Long nFieldUnit = static_cast<tools::Long>(rAttrs->Get( SDRATTR_MEASUREUNIT ).GetValue()); + + for (sal_Int32 i = 0; i < m_xLbUnit->get_count(); ++i) + { + if (m_xLbUnit->get_id(i).toInt32() == nFieldUnit) + { + m_xLbUnit->set_active(i); + break; + } + } + } + else + { + m_xLbUnit->set_active(-1); + } + m_xLbUnit->save_value(); + + // Position + if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTVPOS ) != SfxItemState::DONTCARE ) + { + css::drawing::MeasureTextVertPos eVPos = + rAttrs->Get( SDRATTR_MEASURETEXTVPOS ).GetValue(); + { + if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTHPOS ) != SfxItemState::DONTCARE ) + { + css::drawing::MeasureTextHorzPos eHPos = + rAttrs->Get( SDRATTR_MEASURETEXTHPOS ).GetValue(); + RectPoint eRP = RectPoint::MM; + switch( eVPos ) + { + case css::drawing::MeasureTextVertPos_EAST: + switch( eHPos ) + { + case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: eRP = RectPoint::LT; break; + case css::drawing::MeasureTextHorzPos_INSIDE: eRP = RectPoint::MT; break; + case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: eRP = RectPoint::RT; break; + case css::drawing::MeasureTextHorzPos_AUTO: eRP = RectPoint::MT; break; + default: break; + } + break; + case css::drawing::MeasureTextVertPos_CENTERED: + switch( eHPos ) + { + case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: eRP = RectPoint::LM; break; + case css::drawing::MeasureTextHorzPos_INSIDE: eRP = RectPoint::MM; break; + case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: eRP = RectPoint::RM; break; + case css::drawing::MeasureTextHorzPos_AUTO: eRP = RectPoint::MM; break; + default: break; + } + break; + case css::drawing::MeasureTextVertPos_WEST: + switch( eHPos ) + { + case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: eRP = RectPoint::LB; break; + case css::drawing::MeasureTextHorzPos_INSIDE: eRP = RectPoint::MB; break; + case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: eRP = RectPoint::RB; break; + case css::drawing::MeasureTextHorzPos_AUTO: eRP = RectPoint::MB; break; + default: break; + } + break; + case css::drawing::MeasureTextVertPos_AUTO: + switch( eHPos ) + { + case css::drawing::MeasureTextHorzPos_LEFTOUTSIDE: eRP = RectPoint::LM; break; + case css::drawing::MeasureTextHorzPos_INSIDE: eRP = RectPoint::MM; break; + case css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE: eRP = RectPoint::RM; break; + case css::drawing::MeasureTextHorzPos_AUTO: eRP = RectPoint::MM; break; + default: break; + } + break; + default: ;//prevent warning + } + + CTL_STATE nState = CTL_STATE::NONE; + + if (eHPos == css::drawing::MeasureTextHorzPos_AUTO) + { + m_xTsbAutoPosH->set_state( TRISTATE_TRUE ); + nState = CTL_STATE::NOHORZ; + } + + if (eVPos == css::drawing::MeasureTextVertPos_AUTO) + { + m_xTsbAutoPosV->set_state( TRISTATE_TRUE ); + nState |= CTL_STATE::NOVERT; + } + + m_aCtlPosition.SetState(nState); + m_aCtlPosition.SetActualRP(eRP); + } + } + } + else + { + m_aCtlPosition.Reset(); + m_xTsbAutoPosV->set_state( TRISTATE_INDET ); + m_xTsbAutoPosH->set_state( TRISTATE_INDET ); + } + + // put the attributes to the preview-control, + // otherwise the control don't know about + // the settings of the dialog (#67930) + ChangeAttrHdl_Impl(m_xTsbShowUnit.get()); + m_aCtlPreview.SetAttributes(*rAttrs); + + bPositionModified = false; +} + +/************************************************************************* +|* +|* Fill the delivered Item-Set with dialogbox-attributes +|* +\************************************************************************/ + +bool SvxMeasurePage::FillItemSet( SfxItemSet* rAttrs) +{ + bool bModified = false; + sal_Int32 nValue; + TriState eState; + + if( m_xMtrFldLineDist->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldLineDist, eUnit ); + rAttrs->Put( makeSdrMeasureLineDistItem( nValue ) ); + bModified = true; + } + + if( m_xMtrFldHelplineOverhang->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldHelplineOverhang, eUnit ); + rAttrs->Put( makeSdrMeasureHelplineOverhangItem( nValue ) ); + bModified = true; + } + + if( m_xMtrFldHelplineDist->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldHelplineDist, eUnit ); + rAttrs->Put( makeSdrMeasureHelplineDistItem( nValue ) ); + bModified = true; + } + + if( m_xMtrFldHelpline1Len->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldHelpline1Len, eUnit ); + rAttrs->Put( makeSdrMeasureHelpline1LenItem( nValue ) ); + bModified = true; + } + + if( m_xMtrFldHelpline2Len->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldHelpline2Len, eUnit ); + rAttrs->Put( makeSdrMeasureHelpline2LenItem( nValue ) ); + bModified = true; + } + + eState = m_xTsbBelowRefEdge->get_state(); + if( m_xTsbBelowRefEdge->get_state_changed_from_saved() ) + { + rAttrs->Put( SdrMeasureBelowRefEdgeItem( TRISTATE_TRUE == eState ) ); + bModified = true; + } + + if( m_xMtrFldDecimalPlaces->get_value_changed_from_saved() ) + { + nValue = m_xMtrFldDecimalPlaces->get_value(); + rAttrs->Put( + SdrMeasureDecimalPlacesItem( + sal::static_int_cast< sal_Int16 >( nValue ) ) ); + bModified = true; + } + + eState = m_xTsbParallel->get_state(); + if( m_xTsbParallel->get_state_changed_from_saved() ) + { + rAttrs->Put( SdrMeasureTextRota90Item( TRISTATE_FALSE == eState ) ); + bModified = true; + } + + eState = m_xTsbShowUnit->get_state(); + if( m_xTsbShowUnit->get_state_changed_from_saved() ) + { + rAttrs->Put( SdrYesNoItem(SDRATTR_MEASURESHOWUNIT, TRISTATE_TRUE == eState ) ); + bModified = true; + } + + int nPos = m_xLbUnit->get_active(); + if( m_xLbUnit->get_value_changed_from_saved() ) + { + if (nPos != -1) + { + sal_uInt16 nFieldUnit = m_xLbUnit->get_id(nPos).toUInt32(); + FieldUnit _eUnit = static_cast<FieldUnit>(nFieldUnit); + rAttrs->Put( SdrMeasureUnitItem( _eUnit ) ); + bModified = true; + } + } + + if( bPositionModified ) + { + // Position + css::drawing::MeasureTextVertPos eVPos; + css::drawing::MeasureTextHorzPos eHPos; + + RectPoint eRP = m_aCtlPosition.GetActualRP(); + switch( eRP ) + { + default: + case RectPoint::LT: eVPos = css::drawing::MeasureTextVertPos_EAST; + eHPos = css::drawing::MeasureTextHorzPos_LEFTOUTSIDE; break; + case RectPoint::LM: eVPos = css::drawing::MeasureTextVertPos_CENTERED; + eHPos = css::drawing::MeasureTextHorzPos_LEFTOUTSIDE; break; + case RectPoint::LB: eVPos = css::drawing::MeasureTextVertPos_WEST; + eHPos = css::drawing::MeasureTextHorzPos_LEFTOUTSIDE; break; + case RectPoint::MT: eVPos = css::drawing::MeasureTextVertPos_EAST; + eHPos = css::drawing::MeasureTextHorzPos_INSIDE; break; + case RectPoint::MM: eVPos = css::drawing::MeasureTextVertPos_CENTERED; + eHPos = css::drawing::MeasureTextHorzPos_INSIDE; break; + case RectPoint::MB: eVPos = css::drawing::MeasureTextVertPos_WEST; + eHPos = css::drawing::MeasureTextHorzPos_INSIDE; break; + case RectPoint::RT: eVPos = css::drawing::MeasureTextVertPos_EAST; + eHPos = css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE; break; + case RectPoint::RM: eVPos = css::drawing::MeasureTextVertPos_CENTERED; + eHPos = css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE; break; + case RectPoint::RB: eVPos = css::drawing::MeasureTextVertPos_WEST; + eHPos = css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE; break; + } + if (m_xTsbAutoPosH->get_state() == TRISTATE_TRUE) + eHPos = css::drawing::MeasureTextHorzPos_AUTO; + + if (m_xTsbAutoPosV->get_state() == TRISTATE_TRUE) + eVPos = css::drawing::MeasureTextVertPos_AUTO; + + if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTVPOS ) != SfxItemState::DONTCARE ) + { + css::drawing::MeasureTextVertPos eOldVPos = rOutAttrs.Get(SDRATTR_MEASURETEXTVPOS).GetValue(); + if( eOldVPos != eVPos ) + { + rAttrs->Put( SdrMeasureTextVPosItem( eVPos ) ); + bModified = true; + } + } + else + { + rAttrs->Put( SdrMeasureTextVPosItem( eVPos ) ); + bModified = true; + } + + if ( rAttrs->GetItemState( SDRATTR_MEASURETEXTHPOS ) != SfxItemState::DONTCARE ) + { + css::drawing::MeasureTextHorzPos eOldHPos = rOutAttrs.Get( SDRATTR_MEASURETEXTHPOS ).GetValue(); + if( eOldHPos != eHPos ) + { + rAttrs->Put( SdrMeasureTextHPosItem( eHPos ) ); + bModified = true; + } + } + else + { + rAttrs->Put( SdrMeasureTextHPosItem( eHPos ) ); + bModified = true; + } + } + + return bModified; +} + +/************************************************************************* +|* +|* The View have to set at the measure-object to be able to notify +|* unit and floatingpoint-values +|* +\************************************************************************/ + +void SvxMeasurePage::Construct() +{ + DBG_ASSERT( pView, "No valid View transferred!" ); + + // TTTT + // pMeasureObj is member of SvxXMeasurePreview and can only be accessed due to + // SvxMeasurePage being a friend. It has its own SdrModel (also in SvxXMeasurePreview) + // and 'setting' the SdrModel is a hack. The comment above about 'notify unit and + // floatingpoint-values' is not clear, but has to be done another way - if needed. + // Checked on original aw080, is just commented out there, too. + + m_aCtlPreview.Invalidate(); +} + +std::unique_ptr<SfxTabPage> SvxMeasurePage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxMeasurePage>(pPage, pController, *rAttrs); +} + +void SvxMeasurePage::PointChanged(weld::DrawingArea* pDrawingArea, RectPoint /*eRP*/) +{ + ChangeAttrHdl_Impl(pDrawingArea); +} + +IMPL_LINK( SvxMeasurePage, ClickAutoPosHdl_Impl, weld::Toggleable&, rBox, void ) +{ + if (m_xTsbAutoPosH->get_state() == TRISTATE_TRUE) + { + switch( m_aCtlPosition.GetActualRP() ) + { + case RectPoint::LT: + case RectPoint::RT: + m_aCtlPosition.SetActualRP( RectPoint::MT ); + break; + + case RectPoint::LM: + case RectPoint::RM: + m_aCtlPosition.SetActualRP( RectPoint::MM ); + break; + + case RectPoint::LB: + case RectPoint::RB: + m_aCtlPosition.SetActualRP( RectPoint::MB ); + break; + default: ;//prevent warning + } + } + if (m_xTsbAutoPosV->get_state() == TRISTATE_TRUE) + { + switch( m_aCtlPosition.GetActualRP() ) + { + case RectPoint::LT: + case RectPoint::LB: + m_aCtlPosition.SetActualRP( RectPoint::LM ); + break; + + case RectPoint::MT: + case RectPoint::MB: + m_aCtlPosition.SetActualRP( RectPoint::MM ); + break; + + case RectPoint::RT: + case RectPoint::RB: + m_aCtlPosition.SetActualRP( RectPoint::RM ); + break; + default: ;//prevent warning + } + } + ChangeAttrHdl_Impl(&rBox); +} + +IMPL_LINK(SvxMeasurePage, ChangeAttrClickHdl_Impl, weld::Toggleable&, r, void) +{ + ChangeAttrHdl_Impl(&r); +} + +IMPL_LINK(SvxMeasurePage, ChangeAttrListBoxHdl_Impl, weld::ComboBox&, rBox, void) +{ + ChangeAttrHdl_Impl(&rBox); +} + +IMPL_LINK(SvxMeasurePage, ChangeAttrEditHdl_Impl, weld::MetricSpinButton&, rBox, void) +{ + ChangeAttrHdl_Impl(&rBox); +} + +IMPL_LINK( SvxMeasurePage, ChangeAttrSpinHdl_Impl, weld::SpinButton&, rBox, void ) +{ + ChangeAttrHdl_Impl(&rBox); +} + +void SvxMeasurePage::ChangeAttrHdl_Impl( void const * p ) +{ + if (p == m_xMtrFldLineDist.get()) + { + sal_Int32 nValue = GetCoreValue( *m_xMtrFldLineDist, eUnit ); + aAttrSet.Put( makeSdrMeasureLineDistItem( nValue ) ); + } + + if (p == m_xMtrFldHelplineOverhang.get()) + { + sal_Int32 nValue = GetCoreValue( *m_xMtrFldHelplineOverhang, eUnit ); + aAttrSet.Put( makeSdrMeasureHelplineOverhangItem( nValue) ); + } + + if (p == m_xMtrFldHelplineDist.get()) + { + sal_Int32 nValue = GetCoreValue( *m_xMtrFldHelplineDist, eUnit ); + aAttrSet.Put( makeSdrMeasureHelplineDistItem( nValue) ); + } + + if (p == m_xMtrFldHelpline1Len.get()) + { + sal_Int32 nValue = GetCoreValue( *m_xMtrFldHelpline1Len, eUnit ); + aAttrSet.Put( makeSdrMeasureHelpline1LenItem( nValue ) ); + } + + if (p == m_xMtrFldHelpline2Len.get()) + { + sal_Int32 nValue = GetCoreValue( *m_xMtrFldHelpline2Len, eUnit ); + aAttrSet.Put( makeSdrMeasureHelpline2LenItem( nValue ) ); + } + + if (p == m_xTsbBelowRefEdge.get()) + { + TriState eState = m_xTsbBelowRefEdge->get_state(); + if( eState != TRISTATE_INDET ) + aAttrSet.Put( SdrMeasureBelowRefEdgeItem( TRISTATE_TRUE == eState ) ); + } + + if (p == m_xMtrFldDecimalPlaces.get()) + { + sal_Int16 nValue = sal::static_int_cast< sal_Int16 >( + m_xMtrFldDecimalPlaces->get_value() ); + aAttrSet.Put( SdrMeasureDecimalPlacesItem( nValue ) ); + } + + if (p == m_xTsbParallel.get()) + { + TriState eState = m_xTsbParallel->get_state(); + if( eState != TRISTATE_INDET ) + aAttrSet.Put( SdrMeasureTextRota90Item( TRISTATE_FALSE == eState ) ); + } + + if (p == m_xTsbShowUnit.get()) + { + TriState eState = m_xTsbShowUnit->get_state(); + if( eState != TRISTATE_INDET ) + aAttrSet.Put( SdrYesNoItem( SDRATTR_MEASURESHOWUNIT, TRISTATE_TRUE == eState ) ); + } + + if (p == m_xLbUnit.get()) + { + int nPos = m_xLbUnit->get_active(); + if (nPos != -1) + { + sal_uInt16 nFieldUnit = m_xLbUnit->get_id(nPos).toUInt32(); + FieldUnit _eUnit = static_cast<FieldUnit>(nFieldUnit); + aAttrSet.Put( SdrMeasureUnitItem( _eUnit ) ); + } + } + + if (p == m_xTsbAutoPosV.get() || p == m_xTsbAutoPosH.get() || p == m_aCtlPosition.GetDrawingArea()) + { + bPositionModified = true; + + // Position + RectPoint eRP = m_aCtlPosition.GetActualRP(); + css::drawing::MeasureTextVertPos eVPos; + css::drawing::MeasureTextHorzPos eHPos; + + switch( eRP ) + { + default: + case RectPoint::LT: eVPos = css::drawing::MeasureTextVertPos_EAST; + eHPos = css::drawing::MeasureTextHorzPos_LEFTOUTSIDE; break; + case RectPoint::LM: eVPos = css::drawing::MeasureTextVertPos_CENTERED; + eHPos = css::drawing::MeasureTextHorzPos_LEFTOUTSIDE; break; + case RectPoint::LB: eVPos = css::drawing::MeasureTextVertPos_WEST; + eHPos = css::drawing::MeasureTextHorzPos_LEFTOUTSIDE; break; + case RectPoint::MT: eVPos = css::drawing::MeasureTextVertPos_EAST; + eHPos = css::drawing::MeasureTextHorzPos_INSIDE; break; + case RectPoint::MM: eVPos = css::drawing::MeasureTextVertPos_CENTERED; + eHPos = css::drawing::MeasureTextHorzPos_INSIDE; break; + case RectPoint::MB: eVPos = css::drawing::MeasureTextVertPos_WEST; + eHPos = css::drawing::MeasureTextHorzPos_INSIDE; break; + case RectPoint::RT: eVPos = css::drawing::MeasureTextVertPos_EAST; + eHPos = css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE; break; + case RectPoint::RM: eVPos = css::drawing::MeasureTextVertPos_CENTERED; + eHPos = css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE; break; + case RectPoint::RB: eVPos = css::drawing::MeasureTextVertPos_WEST; + eHPos = css::drawing::MeasureTextHorzPos_RIGHTOUTSIDE; break; + } + + CTL_STATE nState = CTL_STATE::NONE; + + if (m_xTsbAutoPosH->get_state() == TRISTATE_TRUE) + { + eHPos = css::drawing::MeasureTextHorzPos_AUTO; + nState = CTL_STATE::NOHORZ; + } + + if (m_xTsbAutoPosV->get_state() == TRISTATE_TRUE) + { + eVPos = css::drawing::MeasureTextVertPos_AUTO; + nState |= CTL_STATE::NOVERT; + } + + if (p == m_xTsbAutoPosV.get() || p == m_xTsbAutoPosH.get()) + m_aCtlPosition.SetState( nState ); + + aAttrSet.Put( SdrMeasureTextVPosItem( eVPos ) ); + aAttrSet.Put( SdrMeasureTextHPosItem( eHPos ) ); + } + + m_aCtlPreview.SetAttributes(aAttrSet); + m_aCtlPreview.Invalidate(); +} + +void SvxMeasurePage::FillUnitLB() +{ + // fill ListBox with metrics + + FieldUnit nUnit = FieldUnit::NONE; + OUString aStrMetric(m_xFtAutomatic->get_label()); + m_xLbUnit->append(OUString::number(sal_uInt32(nUnit)), aStrMetric); + + for( sal_uInt32 i = 0; i < SvxFieldUnitTable::Count(); ++i ) + { + aStrMetric = SvxFieldUnitTable::GetString(i); + nUnit = SvxFieldUnitTable::GetValue(i); + m_xLbUnit->append(OUString::number(sal_uInt32(nUnit)), aStrMetric); + } +} + +void SvxMeasurePage::PageCreated(const SfxAllItemSet& aSet) +{ + const OfaPtrItem* pOfaPtrItem = aSet.GetItem<OfaPtrItem>(SID_OBJECT_LIST, false); + + if (pOfaPtrItem) + SetView( static_cast<SdrView *>(pOfaPtrItem->GetValue())); + + Construct(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/numfmt.cxx b/cui/source/tabpages/numfmt.cxx new file mode 100644 index 000000000..4e804bc44 --- /dev/null +++ b/cui/source/tabpages/numfmt.cxx @@ -0,0 +1,1746 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <sal/config.h> + +#include <o3tl/safeint.hxx> +#include <svl/eitem.hxx> +#include <svl/intitem.hxx> +#include <sfx2/objsh.hxx> +#include <vcl/outdev.hxx> +#include <i18nlangtag/lang.h> +#include <svx/svxids.hrc> +#include <svtools/colorcfg.hxx> + +#include <numcategories.hrc> +#include <strings.hrc> + +#include <svx/numinf.hxx> + +#include <numfmt.hxx> +#include <svx/numfmtsh.hxx> +#include <dialmgr.hxx> +#include <sfx2/basedlgs.hxx> +#include <svx/flagsdef.hxx> +#include <vector> +#include <com/sun/star/frame/XModel.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <limits> +#include <memory> + +using ::com::sun::star::uno::Reference; +using ::com::sun::star::lang::XServiceInfo; +using ::com::sun::star::uno::UNO_QUERY; + +#define NUMKEY_UNDEFINED SAL_MAX_UINT32 + +// static ---------------------------------------------------------------- + +const WhichRangesContainer SvxNumberFormatTabPage::pRanges( + svl::Items< + SID_ATTR_NUMBERFORMAT_VALUE, SID_ATTR_NUMBERFORMAT_INFO, // 10085 - 10086 + SID_ATTR_NUMBERFORMAT_ONE_AREA, SID_ATTR_NUMBERFORMAT_ONE_AREA, // 10580 - 10580 + SID_ATTR_NUMBERFORMAT_NOLANGUAGE, SID_ATTR_NUMBERFORMAT_NOLANGUAGE, // 10700 - 10700 + SID_ATTR_NUMBERFORMAT_SOURCE, SID_ATTR_NUMBERFORMAT_SOURCE>); // 10932 - 10932 + +/************************************************************************* +#* Method: SvxNumberPreview +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberPreview +#* Function: Constructor of the class SvxNumberPreview +#* Input: Window, Resource-ID +#* Output: --- +#* +#************************************************************************/ + +SvxNumberPreview::SvxNumberPreview() + : mnPos(-1) + , mnChar(0x0) +{ +} + +/************************************************************************* +#* Method: NotifyChange +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberPreview +#* Function: Function for changing the preview string +#* Input: String, color +#* Output: --- +#* +#************************************************************************/ + +void SvxNumberPreview::NotifyChange( const OUString& rPrevStr, + const Color* pColor ) +{ + // detect and strip out '*' related placeholders + aPrevStr = rPrevStr; + mnPos = aPrevStr.indexOf( 0x1B ); + if ( mnPos != -1 ) + { + // Right during user input the star symbol is the very + // last character before the user enters another one. + if (mnPos < aPrevStr.getLength() - 1) + { + mnChar = aPrevStr[ mnPos + 1 ]; + // delete placeholder and char to repeat + aPrevStr = aPrevStr.replaceAt( mnPos, 2, u"" ); + } + else + { + // delete placeholder + aPrevStr = aPrevStr.replaceAt( mnPos, 1, u"" ); + // do not attempt to draw a 0 fill character + mnPos = -1; + } + } + svtools::ColorConfig aColorConfig; + Color aWindowTextColor( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor ); + aPrevCol = pColor ? *pColor : aWindowTextColor; + Invalidate(); +} + +/************************************************************************* +#* Method: Paint +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberPreview +#* Function: Function for repainting the window. +#* Input: --- +#* Output: --- +#* +#************************************************************************/ + +void SvxNumberPreview::Paint(vcl::RenderContext& rRenderContext, const ::tools::Rectangle&) +{ + rRenderContext.Push(vcl::PushFlags::ALL); + + svtools::ColorConfig aColorConfig; + rRenderContext.SetTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + rRenderContext.SetBackground(aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor); + + vcl::Font aDrawFont = rRenderContext.GetFont(); + Size aSzWnd(GetOutputSizePixel()); + OUString aTmpStr(aPrevStr); + tools::Long nLeadSpace = (aSzWnd.Width() - rRenderContext.GetTextWidth(aTmpStr)) / 2; + + aDrawFont.SetTransparent(true); + aDrawFont.SetColor(aPrevCol); + rRenderContext.SetFont(aDrawFont); + + if (mnPos != -1) + { + tools::Long nCharWidth = rRenderContext.GetTextWidth(OUString(mnChar)); + + int nNumCharsToInsert = 0; + if (nCharWidth > 0) + nNumCharsToInsert = nLeadSpace / nCharWidth; + + if (nNumCharsToInsert > 0) + { + for (int i = 0; i < nNumCharsToInsert; ++i) + aTmpStr = aTmpStr.replaceAt(mnPos, 0, rtl::OUStringChar(mnChar)); + } + } + + tools::Long nX = 0; + if (mnPos == -1 && nLeadSpace > 0) //tdf#122120 if it won't fit anyway, then left align it + { + nX = nLeadSpace; + } + + Point aPosText(nX, (aSzWnd.Height() - GetTextHeight()) / 2); + rRenderContext.DrawText(aPosText, aTmpStr); + rRenderContext.Pop(); +} + +// class SvxNumberFormatTabPage ------------------------------------------ + +#define REMOVE_DONTKNOW() \ + if (!m_xFtLanguage->get_sensitive()) \ + { \ + m_xFtLanguage->set_sensitive(true); \ + m_xLbLanguage->set_sensitive(true); \ + m_xLbLanguage->set_active_id(pNumFmtShell->GetCurLanguage()); \ + } + +SvxNumberFormatTabPage::SvxNumberFormatTabPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rCoreAttrs) + : SfxTabPage(pPage, pController, "cui/ui/numberingformatpage.ui", "NumberingFormatPage", &rCoreAttrs) + , nInitFormat(std::numeric_limits<sal_uInt32>::max()) + , m_nLbFormatSelPosEdComment(SELPOS_NONE) + , bLegacyAutomaticCurrency(false) + , sAutomaticLangEntry(CuiResId(RID_CUISTR_AUTO_ENTRY)) + , m_xFtCategory(m_xBuilder->weld_label("categoryft")) + , m_xLbCategory(m_xBuilder->weld_tree_view("categorylb")) + , m_xFtFormat(m_xBuilder->weld_label("formatft")) + , m_xLbCurrency(m_xBuilder->weld_combo_box("currencylb")) + , m_xLbFormat(m_xBuilder->weld_tree_view("formatlb")) + , m_xFtLanguage(m_xBuilder->weld_label("languageft")) + , m_xCbSourceFormat(m_xBuilder->weld_check_button("sourceformat")) + , m_xFtOptions(m_xBuilder->weld_label("optionsft")) + , m_xFtDecimals(m_xBuilder->weld_label("decimalsft")) + , m_xEdDecimals(m_xBuilder->weld_spin_button("decimalsed")) + , m_xFtDenominator(m_xBuilder->weld_label("denominatorft")) + , m_xEdDenominator(m_xBuilder->weld_spin_button("denominatored")) + , m_xBtnNegRed(m_xBuilder->weld_check_button("negnumred")) + , m_xFtLeadZeroes(m_xBuilder->weld_label("leadzerosft")) + , m_xEdLeadZeroes(m_xBuilder->weld_spin_button("leadzerosed")) + , m_xBtnThousand(m_xBuilder->weld_check_button("thousands")) + , m_xBtnEngineering(m_xBuilder->weld_check_button("engineering")) + , m_xFormatCodeFrame(m_xBuilder->weld_widget("formatcode")) + , m_xEdFormat(m_xBuilder->weld_entry("formatted")) + , m_xIbAdd(m_xBuilder->weld_button("add")) + , m_xIbInfo(m_xBuilder->weld_button("edit")) + , m_xIbRemove(m_xBuilder->weld_button("delete")) + , m_xFtComment(m_xBuilder->weld_label("commentft")) + , m_xEdComment(m_xBuilder->weld_entry("commented")) + , m_xLbLanguage(new SvxLanguageBox(m_xBuilder->weld_combo_box("languagelb"))) + , m_xWndPreview(new weld::CustomWeld(*m_xBuilder, "preview", m_aWndPreview)) +{ + for (size_t i = 0; i < std::size(NUM_CATEGORIES); ++i) + m_xLbCategory->append_text(CuiResId(NUM_CATEGORIES[i])); + + auto nWidth = m_xLbCategory->get_approximate_digit_width() * 22; + m_xLbCategory->set_size_request(nWidth, m_xLbCategory->get_height_rows(7)); + m_xLbFormat->set_size_request(nWidth, m_xLbFormat->get_height_rows(5)); + m_xLbCurrency->set_size_request(nWidth, -1); // force using (narrower) width of its LbFormat sibling + + // Initially remove the "Automatically" entry. + m_xLbCurrency->set_active(-1); // First ensure that nothing is selected. + sAutomaticCurrencyEntry = m_xLbCurrency->get_text(0); + m_xLbCurrency->remove(0); + + Init_Impl(); + SetExchangeSupport(); // this page needs ExchangeSupport + nFixedCategory=-1; +} + +SvxNumberFormatTabPage::~SvxNumberFormatTabPage() +{ + pNumFmtShell.reset(); + pNumItem.reset(); + m_xWndPreview.reset(); + m_xLbLanguage.reset(); +} + +void SvxNumberFormatTabPage::Init_Impl() +{ + bNumItemFlag=true; + bOneAreaFlag=false; + + m_xIbAdd->set_sensitive(false ); + m_xIbRemove->set_sensitive(false ); + m_xIbInfo->set_sensitive(false ); + + m_xEdComment->set_text(m_xLbCategory->get_text(1)); // string for user defined + + m_xEdComment->hide(); + + m_xCbSourceFormat->set_active( false ); + m_xCbSourceFormat->set_sensitive(false); + m_xCbSourceFormat->hide(); + + Link<weld::TreeView&,void> aLink2 = LINK(this, SvxNumberFormatTabPage, SelFormatTreeListBoxHdl_Impl); + Link<weld::ComboBox&,void> aLink3 = LINK(this, SvxNumberFormatTabPage, SelFormatListBoxHdl_Impl); + m_xLbCategory->connect_changed(aLink2); + m_xLbCategory->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xLbFormat->connect_changed(aLink2); + m_xLbFormat->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xLbLanguage->connect_changed(aLink3); + m_xLbLanguage->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xLbCurrency->connect_changed(aLink3); + m_xLbCurrency->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xCbSourceFormat->connect_toggled(LINK(this, SvxNumberFormatTabPage, SelFormatClickHdl_Impl)); + m_xCbSourceFormat->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + + Link<weld::SpinButton&,void> aLink = LINK( this, SvxNumberFormatTabPage, OptEditHdl_Impl ); + + m_xEdDecimals->connect_value_changed(aLink); + m_xEdDecimals->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xEdDenominator->connect_value_changed(aLink); + m_xEdDenominator->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xEdLeadZeroes->connect_value_changed(aLink); + m_xEdLeadZeroes->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + + m_xBtnNegRed->connect_toggled(LINK(this, SvxNumberFormatTabPage, OptClickHdl_Impl)); + m_xBtnNegRed->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xBtnThousand->connect_toggled(LINK(this, SvxNumberFormatTabPage, OptClickHdl_Impl)); + m_xBtnThousand->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xBtnEngineering->connect_toggled(LINK(this, SvxNumberFormatTabPage, OptClickHdl_Impl)); + m_xBtnEngineering->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xLbFormat->connect_row_activated(LINK(this, SvxNumberFormatTabPage, DoubleClickHdl_Impl)); + m_xEdFormat->connect_changed(LINK(this, SvxNumberFormatTabPage, EditModifyHdl_Impl)); + m_xEdFormat->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xIbAdd->connect_clicked(LINK(this, SvxNumberFormatTabPage, ClickHdl_Impl)); + m_xIbAdd->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xIbRemove->connect_clicked(LINK(this, SvxNumberFormatTabPage, ClickHdl_Impl)); + m_xIbRemove->connect_focus_in(LINK(this, SvxNumberFormatTabPage, LostFocusHdl_Impl)); + m_xIbInfo->connect_clicked(LINK(this, SvxNumberFormatTabPage, ClickHdl_Impl)); + UpdateThousandEngineeringCheckBox(); + UpdateDecimalsDenominatorEditBox(); + + // initialize language ListBox + + m_xLbLanguage->SetLanguageList(SvxLanguageListFlags::ALL | SvxLanguageListFlags::ONLY_KNOWN, + false, false, false, true, LANGUAGE_SYSTEM, + css::i18n::ScriptType::WEAK); +} + +std::unique_ptr<SfxTabPage> SvxNumberFormatTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet ) +{ + return std::make_unique<SvxNumberFormatTabPage>(pPage, pController, *rAttrSet); +} + + +/************************************************************************* +#* Method: Reset +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: The dialog's attributes are reset +#* using the Itemset. +#* Input: SfxItemSet +#* Output: --- +#* +#************************************************************************/ + +void SvxNumberFormatTabPage::set_active_currency(sal_Int32 nPos) +{ + static_assert(SELPOS_NONE == -1, "SELPOS_NONE was -1 at time of writing"); + if (nPos == 0 && !bLegacyAutomaticCurrency) + { + // Insert "Automatically" if currently used so it is selectable. + m_xLbCurrency->insert_text(0, sAutomaticCurrencyEntry); + bLegacyAutomaticCurrency = true; + } + if (nPos != -1 && !bLegacyAutomaticCurrency) + --nPos; + m_xLbCurrency->set_active(nPos); +} + +sal_uInt32 SvxNumberFormatTabPage::get_active_currency() const +{ + static_assert(SELPOS_NONE == -1, "SELPOS_NONE was -1 at time of writing"); + sal_Int32 nCurrencyPos = m_xLbCurrency->get_active(); + if (nCurrencyPos != -1 && !bLegacyAutomaticCurrency) + ++nCurrencyPos; + return nCurrencyPos; +} + +void SvxNumberFormatTabPage::Reset( const SfxItemSet* rSet ) +{ + const SfxUInt32Item* pValFmtAttr = nullptr; + const SfxPoolItem* pItem = nullptr; + const SfxBoolItem* pAutoEntryAttr = nullptr; + + sal_uInt16 nCatLbSelPos = 0; + sal_uInt16 nFmtLbSelPos = 0; + LanguageType eLangType = LANGUAGE_DONTKNOW; + std::vector<OUString> aFmtEntryList; + SvxNumberValueType eValType = SvxNumberValueType::Undefined; + double nValDouble = 0; + OUString aValString; + + if(const SfxBoolItem* pBoolLangItem = rSet->GetItemIfSet( SID_ATTR_NUMBERFORMAT_NOLANGUAGE )) + { + if(pBoolLangItem->GetValue()) + { + HideLanguage(); + } + else + { + HideLanguage(false); + } + + } + + SfxItemState eState = rSet->GetItemState( GetWhich( SID_ATTR_NUMBERFORMAT_INFO ),true,&pItem); + + if(eState==SfxItemState::SET) + { + if(pNumItem==nullptr) + { + bNumItemFlag=true; + pNumItem.reset( static_cast<SvxNumberInfoItem *>(pItem->Clone()) ); + } + else + { + bNumItemFlag=false; + } + } + else + { + bNumItemFlag=false; + } + + + eState = rSet->GetItemState( GetWhich( SID_ATTR_NUMBERFORMAT_ONE_AREA )); + + if(eState==SfxItemState::SET) + { + const SfxBoolItem* pBoolItem = static_cast<const SfxBoolItem*>( + GetItem( *rSet, SID_ATTR_NUMBERFORMAT_ONE_AREA)); + + if(pBoolItem!=nullptr) + { + bOneAreaFlag= pBoolItem->GetValue(); + } + } + + eState = rSet->GetItemState( SID_ATTR_NUMBERFORMAT_SOURCE ); + + if ( eState == SfxItemState::SET ) + { + const SfxBoolItem* pBoolItem = + GetItem( *rSet, SID_ATTR_NUMBERFORMAT_SOURCE ); + if ( pBoolItem ) + m_xCbSourceFormat->set_active(pBoolItem->GetValue()); + else + m_xCbSourceFormat->set_active( false ); + m_xCbSourceFormat->set_sensitive(true); + m_xCbSourceFormat->show(); + } + else + { + bool bInit = false; // set to sal_True for debug test + m_xCbSourceFormat->set_active( bInit ); + m_xCbSourceFormat->set_sensitive( bInit ); + m_xCbSourceFormat->set_visible( bInit ); + } + + // pNumItem must have been set from outside! + DBG_ASSERT( pNumItem, "No NumberInfo, no NumberFormatter, goodbye. CRASH. :-(" ); + + eState = rSet->GetItemState( GetWhich( SID_ATTR_NUMBERFORMAT_VALUE ) ); + + if ( SfxItemState::DONTCARE != eState ) + pValFmtAttr = GetItem( *rSet, SID_ATTR_NUMBERFORMAT_VALUE ); + + eValType = pNumItem->GetValueType(); + + switch ( eValType ) + { + case SvxNumberValueType::String: + aValString = pNumItem->GetValueString(); + break; + case SvxNumberValueType::Number: + // #50441# string may be set in addition to the value + aValString = pNumItem->GetValueString(); + nValDouble = pNumItem->GetValueDouble(); + break; + case SvxNumberValueType::Undefined: + default: + break; + } + + pNumFmtShell.reset(); // delete old shell if applicable (== reset) + + nInitFormat = pValFmtAttr // memorize init key + ? pValFmtAttr->GetValue() // (for FillItemSet()) + : std::numeric_limits<sal_uInt32>::max(); // == DONT_KNOW + + + if ( eValType == SvxNumberValueType::String ) + pNumFmtShell.reset( SvxNumberFormatShell::Create( + pNumItem->GetNumberFormatter(), + pValFmtAttr ? nInitFormat : 0, + eValType, + aValString ) ); + else + pNumFmtShell.reset( SvxNumberFormatShell::Create( + pNumItem->GetNumberFormatter(), + pValFmtAttr ? nInitFormat : 0, + eValType, + nValDouble, + &aValString ) ); + + + bool bUseStarFormat = false; + if (SfxObjectShell* pDocSh = SfxObjectShell::Current()) + { + // is this a calc document + Reference< XServiceInfo > xSI( pDocSh->GetModel(), UNO_QUERY ); + if ( xSI.is() ) + bUseStarFormat = xSI->supportsService("com.sun.star.sheet.SpreadsheetDocument"); + } + pNumFmtShell->SetUseStarFormat( bUseStarFormat ); + + FillCurrencyBox(); + + OUString aPrevString; + const Color* pDummy = nullptr; + pNumFmtShell->GetInitSettings( nCatLbSelPos, eLangType, nFmtLbSelPos, + aFmtEntryList, aPrevString, pDummy ); + + if (nCatLbSelPos==CAT_CURRENCY) + set_active_currency(pNumFmtShell->GetCurrencySymbol()); + + nFixedCategory=nCatLbSelPos; + if(bOneAreaFlag) + { + OUString sFixedCategory = m_xLbCategory->get_text(nFixedCategory); + m_xLbCategory->clear(); + m_xLbCategory->append_text(sFixedCategory); + SetCategory(0); + } + else + { + SetCategory(nCatLbSelPos ); + } + eState = rSet->GetItemState( SID_ATTR_NUMBERFORMAT_ADD_AUTO ); + if(SfxItemState::SET == eState) + pAutoEntryAttr = GetItem( *rSet, SID_ATTR_NUMBERFORMAT_ADD_AUTO ); + // no_NO is an alias for nb_NO and normally isn't listed, we need it for + // backwards compatibility, but only if the format passed is of + // LanguageType no_NO. + if ( eLangType == LANGUAGE_NORWEGIAN ) + { + m_xLbLanguage->remove_id(eLangType); // in case we're already called + m_xLbLanguage->InsertLanguage( eLangType ); + } + m_xLbLanguage->set_active_id(eLangType); + if(pAutoEntryAttr) + AddAutomaticLanguage_Impl(eLangType, pAutoEntryAttr->GetValue()); + UpdateFormatListBox_Impl(false,true); + +//! This spoils everything because it rematches currency formats based on +//! the selected m_xLbCurrency entry instead of the current format. +//! Besides that everything seems to be initialized by now, so why call it? +// SelFormatHdl_Impl(m_xLbCategory.get()); + + if ( pValFmtAttr ) + { + EditHdl_Impl(m_xEdFormat.get()); // UpdateOptions_Impl() as a side effect + } + else // DONT_KNOW + { + // everything disabled except direct input or changing the category + Obstructing(); + } + + if ( m_xCbSourceFormat->get_active() ) + { + // everything disabled except SourceFormat checkbox + EnableBySourceFormat_Impl(); + } +} + +/************************************************************************* +#* Method: Obstructing +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Disable the controls except from changing the category +#* and direct input. +#* Input: --- +#* Output: --- +#* +#************************************************************************/ +void SvxNumberFormatTabPage::Obstructing() +{ + m_xLbFormat->select(-1); + m_xLbLanguage->set_active(-1); + m_xFtLanguage->set_sensitive(false); + m_xLbLanguage->set_sensitive(false); + + m_xIbAdd->set_sensitive(false ); + m_xIbRemove->set_sensitive(false ); + m_xIbInfo->set_sensitive(false ); + + m_xBtnNegRed->set_sensitive(false); + m_xBtnThousand->set_sensitive(false); + m_xBtnEngineering->set_sensitive(false); + m_xFtLeadZeroes->set_sensitive(false); + m_xFtDecimals->set_sensitive(false); + m_xFtDenominator->set_sensitive(false); + m_xEdLeadZeroes->set_sensitive(false); + m_xEdDecimals->set_sensitive(false); + m_xEdDenominator->set_sensitive(false); + m_xFtOptions->set_sensitive(false); + m_xEdDecimals->set_text( OUString() ); + m_xEdLeadZeroes->set_text( OUString() ); + m_xBtnNegRed->set_active( false ); + m_xBtnThousand->set_active( false ); + m_xBtnEngineering->set_active( false ); + m_aWndPreview.NotifyChange( OUString() ); + + m_xLbCategory->select(0); + m_xEdFormat->set_text( OUString() ); + m_xFtComment->set_label( OUString() ); + m_xEdComment->set_text(m_xLbCategory->get_text(1)); // string for user defined + + m_xEdFormat->grab_focus(); +} + + +/************************************************************************* +#* Enable/Disable dialog parts depending on the value of the SourceFormat +#* checkbox. +#************************************************************************/ +void SvxNumberFormatTabPage::EnableBySourceFormat_Impl() +{ + bool bEnable = !m_xCbSourceFormat->get_active(); + if ( !bEnable ) + m_xCbSourceFormat->grab_focus(); + m_xFtCategory->set_sensitive( bEnable ); + m_xLbCategory->set_sensitive( bEnable ); + m_xFtFormat->set_sensitive( bEnable ); + m_xLbCurrency->set_sensitive( bEnable ); + m_xLbFormat->set_sensitive( bEnable ); + m_xFtLanguage->set_sensitive( bEnable ); + m_xLbLanguage->set_sensitive( bEnable ); + m_xFtDecimals->set_sensitive( bEnable ); + m_xEdDecimals->set_sensitive( bEnable ); + m_xFtDenominator->set_sensitive( bEnable ); + m_xEdDenominator->set_sensitive( bEnable ); + m_xFtLeadZeroes->set_sensitive( bEnable ); + m_xEdLeadZeroes->set_sensitive( bEnable ); + m_xBtnNegRed->set_sensitive( bEnable ); + m_xBtnThousand->set_sensitive( bEnable ); + m_xBtnEngineering->set_sensitive( bEnable ); + m_xFtOptions->set_sensitive( bEnable ); + m_xFormatCodeFrame->set_sensitive( bEnable ); +} + + +/************************************************************************* +#* Method: HideLanguage +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Hides the language settings: +#* Input: sal_Bool nFlag +#* Output: --- +#* +#************************************************************************/ + +void SvxNumberFormatTabPage::HideLanguage(bool bFlag) +{ + m_xFtLanguage->set_visible(!bFlag); + m_xLbLanguage->set_visible(!bFlag); +} + +/************************************************************************* +#* Method: FillItemSet +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Adjusts the attributes in the ItemSet, +#* and - if bNumItemFlag is not set - the +#* numItem in the DocShell. +#* Input: SfxItemSet +#* Output: --- +#* +#************************************************************************/ + +bool SvxNumberFormatTabPage::FillItemSet( SfxItemSet* rCoreAttrs ) +{ + bool bDataChanged = m_xFtLanguage->get_sensitive() || m_xCbSourceFormat->get_sensitive(); + if ( bDataChanged ) + { + const SfxItemSet& rMyItemSet = GetItemSet(); + sal_uInt16 nWhich = GetWhich( SID_ATTR_NUMBERFORMAT_VALUE ); + SfxItemState eItemState = rMyItemSet.GetItemState( nWhich, false ); + + // OK chosen - Is format code input entered already taken over? + // If not, simulate Add. Upon syntax error ignore input and prevent Put. + OUString aFormat = m_xEdFormat->get_text(); + sal_uInt32 nCurKey = pNumFmtShell->GetCurNumFmtKey(); + + if ( m_xIbAdd->get_sensitive() || pNumFmtShell->IsTmpCurrencyFormat(aFormat) ) + { // #79599# It is not sufficient to just add the format code (or + // delete it in case of bOneAreaFlag and resulting category change). + // Upon switching tab pages we need all settings to be consistent + // in case this page will be redisplayed later. + bDataChanged = Click_Impl(*m_xIbAdd); + nCurKey = pNumFmtShell->GetCurNumFmtKey(); + } + else if(nCurKey == NUMKEY_UNDEFINED) + { // something went wrong, e.g. in Writer #70281# + pNumFmtShell->FindEntry(aFormat, &nCurKey); + } + + + // Chosen format: + + if ( bDataChanged ) + { + bDataChanged = ( nInitFormat != nCurKey ); + + if (bDataChanged) + { + rCoreAttrs->Put( SfxUInt32Item( nWhich, nCurKey ) ); + } + else if(SfxItemState::DEFAULT == eItemState) + { + rCoreAttrs->ClearItem( nWhich ); + } + } + + + // List of changed user defined formats: + + std::vector<sal_uInt32> const & aDelFormats = pNumFmtShell->GetUpdateData(); + + if ( !aDelFormats.empty() ) + { + + pNumItem->SetDelFormats( std::vector(aDelFormats) ); + + if(bNumItemFlag) + { + rCoreAttrs->Put( *pNumItem ); + } + else + { + SfxObjectShell* pDocSh = SfxObjectShell::Current(); + DBG_ASSERT( pDocSh, "DocShell not found!" ); + if (pDocSh) + pDocSh->PutItem( *pNumItem ); + } + } + + + // Whether source format is to be taken or not: + + if ( m_xCbSourceFormat->get_sensitive() ) + { + SfxItemState _eItemState = rMyItemSet.GetItemState( SID_ATTR_NUMBERFORMAT_SOURCE, false ); + const SfxBoolItem* pBoolItem = + GetItem( rMyItemSet, SID_ATTR_NUMBERFORMAT_SOURCE ); + bool bOld = pBoolItem && pBoolItem->GetValue(); + rCoreAttrs->Put( SfxBoolItem( SID_ATTR_NUMBERFORMAT_SOURCE, m_xCbSourceFormat->get_active() ) ); + if ( !bDataChanged ) + bDataChanged = (bOld != m_xCbSourceFormat->get_active() || + _eItemState != SfxItemState::SET); + } + + // FillItemSet is only called on OK, here we can notify the + // NumberFormatShell that all new user defined formats are valid. + pNumFmtShell->ValidateNewEntries(); + if(m_xLbLanguage->get_visible() && + m_xLbLanguage->find_text(sAutomaticLangEntry) != -1) + rCoreAttrs->Put(SfxBoolItem(SID_ATTR_NUMBERFORMAT_ADD_AUTO, + m_xLbLanguage->get_active_text() == sAutomaticLangEntry)); + } + + return bDataChanged; +} + + +DeactivateRC SvxNumberFormatTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +void SvxNumberFormatTabPage::FillFormatListBox_Impl( std::vector<OUString>& rEntries ) +{ + OUString aEntry; + OUString aTmpString; + size_t i = 0; + short nTmpCatPos; + + m_xLbFormat->clear(); + if (rEntries.empty()) + return; + + m_xLbFormat->freeze(); + + if(bOneAreaFlag) + { + nTmpCatPos=nFixedCategory; + } + else + { + nTmpCatPos=m_xLbCategory->get_selected_index(); + } + + switch (nTmpCatPos) + { + case CAT_ALL: + case CAT_TEXT: + case CAT_NUMBER: i=1; + aEntry=rEntries[0]; + if (nTmpCatPos == CAT_TEXT) + aTmpString=aEntry; + else + aTmpString = pNumFmtShell->GetStandardName(); + m_xLbFormat->append_text(aTmpString); + break; + + default: break; + } + + if(pNumFmtShell!=nullptr) + { + for ( ; i < rEntries.size(); ++i ) + { + aEntry = rEntries[i]; + short aPrivCat = pNumFmtShell->GetCategory4Entry( static_cast<short>(i) ); + if(aPrivCat!=CAT_TEXT) + { + const Color* pPreviewColor = nullptr; + OUString aPreviewString( GetExpColorString( pPreviewColor, aEntry, aPrivCat ) ); + m_xLbFormat->append_text(aPreviewString); + if (pPreviewColor) + m_xLbFormat->set_font_color(m_xLbFormat->n_children() - 1, *pPreviewColor); + } + else + { + m_xLbFormat->append_text(aEntry); + } + } + } + m_xLbFormat->thaw(); + rEntries.clear(); +} + +/************************************************************************* +#* Method: UpdateOptions_Impl +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Adjusts the options attributes +#* depending on the selected format. +#* Input: Flag, whether the category has changed. +#* Output: --- +#* +#************************************************************************/ + +void SvxNumberFormatTabPage::UpdateOptions_Impl( bool bCheckCatChange /*= sal_False*/ ) +{ + OUString theFormat = m_xEdFormat->get_text(); + sal_Int32 nCurCategory = m_xLbCategory->get_selected_index(); + sal_uInt16 nCategory = static_cast<sal_uInt16>(nCurCategory); + sal_uInt16 nDecimals = 0; + sal_uInt16 nZeroes = 0; + bool bNegRed = false; + bool bThousand = false; + sal_Int32 nCurrencyPos = get_active_currency(); + + if(bOneAreaFlag) + nCurCategory=nFixedCategory; + + + pNumFmtShell->GetOptions( theFormat, + bThousand, bNegRed, + nDecimals, nZeroes, + nCategory ); + bool bDoIt=false; + if(nCategory==CAT_CURRENCY) + { + sal_uInt16 nTstPos=pNumFmtShell->FindCurrencyFormat(theFormat); + if(nCurrencyPos!=static_cast<sal_Int32>(nTstPos) && nTstPos!=sal_uInt16(-1)) + { + set_active_currency(nTstPos); + pNumFmtShell->SetCurrencySymbol(nTstPos); + bDoIt=true; + } + } + + if ( nCategory != nCurCategory || bDoIt) + { + if ( bCheckCatChange ) + { + if(bOneAreaFlag) + SetCategory(0); + else + SetCategory(nCategory ); + + UpdateFormatListBox_Impl( true, false ); + } + } + else if ( m_xLbFormat->n_children() > 0 ) + { + sal_uInt32 nCurEntryKey=NUMKEY_UNDEFINED; + if(!pNumFmtShell->FindEntry( m_xEdFormat->get_text(),&nCurEntryKey)) + { + m_xLbFormat->select(-1); + } + } + if(bOneAreaFlag) + { + nCategory=nFixedCategory; + } + + UpdateThousandEngineeringCheckBox(); + UpdateDecimalsDenominatorEditBox(); + switch ( nCategory ) + { + case CAT_SCIENTIFIC: // bThousand is for Engineering notation + { + sal_uInt16 nIntDigits = pNumFmtShell->GetFormatIntegerDigits(theFormat); + bThousand = (nIntDigits > 0) && (nIntDigits % 3 == 0); + m_xBtnEngineering->set_sensitive(true); + m_xBtnEngineering->set_active( bThousand ); + } + [[fallthrough]]; + case CAT_NUMBER: + case CAT_PERCENT: + case CAT_CURRENCY: + case CAT_FRACTION: + case CAT_TIME: + m_xFtOptions->set_sensitive(true); + if ( nCategory == CAT_FRACTION ) + { + m_xFtDenominator->set_sensitive(true); + m_xEdDenominator->set_sensitive(true); + } + else + { + m_xFtDecimals->set_sensitive(true); + m_xEdDecimals->set_sensitive(true); + } + m_xFtLeadZeroes->set_sensitive( nCategory != CAT_TIME ); + m_xEdLeadZeroes->set_sensitive( nCategory != CAT_TIME ); + m_xBtnNegRed->set_sensitive(true); + if ( nCategory == CAT_NUMBER && m_xLbFormat->get_selected_index() == 0 ) + m_xEdDecimals->set_text( "" ); //General format tdf#44399 + else + if ( nCategory == CAT_FRACTION ) + m_xEdDenominator->set_value( nDecimals ); + else + m_xEdDecimals->set_value( nDecimals ); + if ( nCategory != CAT_TIME ) + m_xEdLeadZeroes->set_value( nZeroes ); + m_xBtnNegRed->set_active( bNegRed ); + if ( nCategory != CAT_SCIENTIFIC ) + { + m_xBtnThousand->set_sensitive( nCategory != CAT_TIME ); + m_xBtnThousand->set_active( bThousand && nCategory != CAT_TIME ); + } + break; + + case CAT_ALL: + case CAT_USERDEFINED: + case CAT_TEXT: + case CAT_DATE: + case CAT_BOOLEAN: + default: + m_xFtOptions->set_sensitive(false); + m_xFtDecimals->set_sensitive(false); + m_xEdDecimals->set_sensitive(false); + m_xFtDenominator->set_sensitive(false); + m_xEdDenominator->set_sensitive(false); + m_xFtLeadZeroes->set_sensitive(false); + m_xEdLeadZeroes->set_sensitive(false); + m_xBtnNegRed->set_sensitive(false); + m_xBtnThousand->set_sensitive(false); + m_xBtnEngineering->set_sensitive(false); + m_xEdDecimals->set_text( OUString() ); + m_xEdLeadZeroes->set_text( OUString() ); + m_xBtnNegRed->set_active( false ); + m_xBtnThousand->set_active( false ); + m_xBtnEngineering->set_active( false ); + } +} + + +/************************************************************************* +#* Method: UpdateFormatListBox_Impl +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Updates the format listbox and additionally the +#* string in the editbox is changed depending on +#* the bUpdateEdit flag. +#* Input: Flags for category and editbox. +#* Output: --- +#* +#************************************************************************/ + +void SvxNumberFormatTabPage::UpdateFormatListBox_Impl + ( + bool bCat, // Category or country/language ListBox? + bool bUpdateEdit + ) +{ + std::vector<OUString> aEntryList; + short nFmtLbSelPos = 0; + short nTmpCatPos; + + if(bOneAreaFlag) + { + nTmpCatPos=nFixedCategory; + } + else + { + nTmpCatPos=m_xLbCategory->get_selected_index(); + } + + + if ( bCat ) + { + if(nTmpCatPos!=CAT_CURRENCY) + m_xLbCurrency->hide(); + else + m_xLbCurrency->show(); + + pNumFmtShell->CategoryChanged(nTmpCatPos,nFmtLbSelPos, aEntryList); + } + else + pNumFmtShell->LanguageChanged(m_xLbLanguage->get_active_id(), + nFmtLbSelPos,aEntryList); + + REMOVE_DONTKNOW() // possibly UI-Enable + + + if ( (!aEntryList.empty()) && (nFmtLbSelPos != SELPOS_NONE) ) + { + if(bUpdateEdit) + { + OUString aFormat=aEntryList[nFmtLbSelPos]; + m_xEdFormat->set_text(aFormat); + m_xFtComment->set_label(pNumFmtShell->GetComment4Entry(nFmtLbSelPos)); + } + + if(!bOneAreaFlag || !bCat) + { + FillFormatListBox_Impl( aEntryList ); + m_xLbFormat->select(nFmtLbSelPos); + + m_xFtComment->set_label(pNumFmtShell->GetComment4Entry(nFmtLbSelPos)); + if(pNumFmtShell->GetUserDefined4Entry(nFmtLbSelPos)) + { + if(pNumFmtShell->GetComment4Entry(nFmtLbSelPos).isEmpty()) + { + m_xFtComment->set_label(m_xLbCategory->get_text(1)); + } + } + ChangePreviewText( static_cast<sal_uInt16>(nFmtLbSelPos) ); + } + + } + else + { + FillFormatListBox_Impl( aEntryList ); + if(nFmtLbSelPos != SELPOS_NONE) + { + m_xLbFormat->select(static_cast<sal_uInt16>(nFmtLbSelPos)); + + m_xFtComment->set_label(pNumFmtShell->GetComment4Entry(nFmtLbSelPos)); + if(pNumFmtShell->GetUserDefined4Entry(nFmtLbSelPos)) + { + if(pNumFmtShell->GetComment4Entry(nFmtLbSelPos).isEmpty()) + { + m_xFtComment->set_label(m_xLbCategory->get_text(1)); + } + } + } + else + { + m_xLbFormat->select(-1); + } + + if ( bUpdateEdit ) + { + m_xEdFormat->set_text( OUString() ); + m_aWndPreview.NotifyChange( OUString() ); + } + } + + aEntryList.clear(); +} + + +/** + * Change visible checkbox according to category format + * if scientific format "Engineering notation" + * else "Thousands separator" + */ + +void SvxNumberFormatTabPage::UpdateThousandEngineeringCheckBox() +{ + bool bIsScientific = m_xLbCategory->get_selected_index() == CAT_SCIENTIFIC; + m_xBtnThousand->set_visible( !bIsScientific ); + m_xBtnEngineering->set_visible( bIsScientific ); +} + + +/** + * Change visible Edit box and Fixed text according to category format + * if fraction format "Denominator places" + * else "Decimal places" + */ + +void SvxNumberFormatTabPage::UpdateDecimalsDenominatorEditBox() +{ + bool bIsFraction = m_xLbCategory->get_selected_index() == CAT_FRACTION; + m_xFtDecimals->set_visible( !bIsFraction ); + m_xEdDecimals->set_visible( !bIsFraction ); + m_xFtDenominator->set_visible( bIsFraction ); + m_xEdDenominator->set_visible( bIsFraction ); +} + + +/************************************************************************* +#* Handle: DoubleClickHdl_Impl +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: On a double click in the format listbox the +#* value is adopted and the OK button pushed. +#* Input: Pointer on the Listbox +#* Output: --- +#* +#************************************************************************/ +IMPL_LINK(SvxNumberFormatTabPage, DoubleClickHdl_Impl, weld::TreeView&, rLb, bool) +{ + SelFormatHdl_Impl(&rLb); + + SfxOkDialogController* pController = GetDialogController(); + assert(pController); + weld::Button& rOkButton = pController->GetOKButton(); + rOkButton.clicked(); + + return true; +} + +/************************************************************************* +#* Method: SelFormatHdl_Impl +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Is called when the language, the category or the format +#* is changed. Accordingly the settings are adjusted. +#* Input: Pointer on the Listbox +#* Output: --- +#* +#************************************************************************/ + +IMPL_LINK(SvxNumberFormatTabPage, SelFormatClickHdl_Impl, weld::Toggleable&, rLb, void) +{ + SelFormatHdl_Impl(&rLb); +} + +IMPL_LINK(SvxNumberFormatTabPage, SelFormatTreeListBoxHdl_Impl, weld::TreeView&, rLb, void) +{ + SelFormatHdl_Impl(&rLb); +} + +IMPL_LINK(SvxNumberFormatTabPage, SelFormatListBoxHdl_Impl, weld::ComboBox&, rLb, void) +{ + SelFormatHdl_Impl(&rLb); +} + +void SvxNumberFormatTabPage::SelFormatHdl_Impl(weld::Widget* pLb) +{ + if (m_nLbFormatSelPosEdComment != SELPOS_NONE) + { + // Click handler is called before focus change handler, so finish + // comment editing of previous format, otherwise a new format will have + // the old comment displayed after LostFocusHdl_Impl() is called + // later. Also, clicking into another category invalidates the format + // list and SvxNumberFormatShell::SetComment4Entry() could either + // access a wrong format from aCurEntryList[nEntry] or crash there if + // the new vector has less elements. + LostFocusHdl_Impl(*pLb); + } + + if (pLb == m_xCbSourceFormat.get()) + { + EnableBySourceFormat_Impl(); // enable/disable everything else + if ( m_xCbSourceFormat->get_active() ) + return; // just disabled everything else + + // Reinit options enable/disable for current selection. + + // Current category may be UserDefined with no format entries defined. + if (m_xLbFormat->get_selected_index() == -1) + pLb = m_xLbCategory.get(); // continue with the current category selected + else + pLb = m_xLbFormat.get(); // continue with the current format selected + } + + sal_Int32 nTmpCatPos; + + if(bOneAreaFlag) + { + nTmpCatPos=nFixedCategory; + } + else + { + nTmpCatPos=m_xLbCategory->get_selected_index(); + } + + if (nTmpCatPos==CAT_CURRENCY && pLb == m_xLbCurrency.get()) + pNumFmtShell->SetCurrencySymbol(get_active_currency()); + + // Format-ListBox ---------------------------------------------------- + if (pLb == m_xLbFormat.get()) + { + int nSelPos = m_xLbFormat->get_selected_index(); + short nFmtLbSelPos = static_cast<short>(nSelPos); + + OUString aFormat = pNumFmtShell->GetFormat4Entry(nFmtLbSelPos); + OUString aComment = pNumFmtShell->GetComment4Entry(nFmtLbSelPos); + + if(pNumFmtShell->GetUserDefined4Entry(nFmtLbSelPos)) + { + if(aComment.isEmpty()) + { + aComment = m_xLbCategory->get_text(1); + } + } + + if ( !aFormat.isEmpty() ) + { + if (!m_xEdFormat->has_focus()) + m_xEdFormat->set_text( aFormat ); + m_xFtComment->set_label(aComment); + ChangePreviewText( static_cast<sal_uInt16>(nSelPos) ); + } + + REMOVE_DONTKNOW() // possibly UI-Enable + + if ( pNumFmtShell->FindEntry( aFormat) ) + { + m_xIbAdd->set_sensitive(false ); + bool bIsUserDef=pNumFmtShell->IsUserDefined( aFormat ); + m_xIbRemove->set_sensitive(bIsUserDef); + m_xIbInfo->set_sensitive(bIsUserDef); + + } + else + { + m_xIbAdd->set_sensitive(true); + m_xIbInfo->set_sensitive(true); + m_xIbRemove->set_sensitive(false ); + m_xFtComment->set_label(m_xEdComment->get_text()); + + } + UpdateOptions_Impl( false ); + + return; + } + + + // category-ListBox ------------------------------------------------- + if (pLb == m_xLbCategory.get() || pLb == m_xLbCurrency.get()) + { + UpdateFormatListBox_Impl( true, true ); + EditHdl_Impl( nullptr ); + UpdateOptions_Impl( false ); + + return; + } + + + // language/country-ListBox ---------------------------------------------- + if (pLb == m_xLbLanguage->get_widget()) + { + UpdateFormatListBox_Impl( false, true ); + EditHdl_Impl(m_xEdFormat.get()); + + return; + } +} + + +/************************************************************************* +#* Method: ClickHdl_Impl, weld::Button& rIB +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Called when the add or delete button is pushed, +#* adjusts the number format list. +#* Input: Toolbox- Button +#* Output: --- +#* +#************************************************************************/ + +IMPL_LINK( SvxNumberFormatTabPage, ClickHdl_Impl, weld::Button&, rIB, void) +{ + Click_Impl(rIB); +} + +bool SvxNumberFormatTabPage::Click_Impl(const weld::Button& rIB) +{ + sal_uInt8 nReturn = 0; + constexpr sal_uInt8 nReturnChanged = 0x1; // THE boolean return value + constexpr sal_uInt8 nReturnAdded = 0x2; // temp: format added + constexpr sal_uInt8 nReturnOneArea = 0x4; // temp: one area but category changed => ignored + + if (&rIB == m_xIbAdd.get()) + { // Also called from FillItemSet() if a temporary currency format has + // to be added, not only if the Add button is enabled. + OUString aFormat = m_xEdFormat->get_text(); + std::vector<OUString> aEntryList; + std::vector<OUString> a2EntryList; + sal_uInt16 nCatLbSelPos = 0; + short nFmtLbSelPos = SELPOS_NONE; + sal_Int32 nErrPos=0; + + pNumFmtShell->SetCurCurrencyEntry(nullptr); + bool bAdded = pNumFmtShell->AddFormat( aFormat, nErrPos, + nCatLbSelPos, nFmtLbSelPos, + aEntryList); + if ( bAdded ) + nReturn |= nReturnChanged | nReturnAdded; + + if (m_xEdComment->get_visible()) + { + m_xEdFormat->grab_focus(); + m_xEdComment->hide(); + m_xFtComment->show(); + m_xFtComment->set_label(m_xEdComment->get_text()); + } + + if ( !nErrPos ) // Syntax ok? + { + // May be sorted under a different locale if LCID was parsed. + if (bAdded) + m_xLbLanguage->set_active_id(pNumFmtShell->GetCurLanguage()); + + if (nCatLbSelPos==CAT_CURRENCY) + set_active_currency(pNumFmtShell->GetCurrencySymbol()); + + if(bOneAreaFlag && (nFixedCategory!=nCatLbSelPos)) + { + if(bAdded) aEntryList.clear(); + pNumFmtShell->RemoveFormat( aFormat, + nCatLbSelPos, + nFmtLbSelPos, + a2EntryList); + a2EntryList.clear(); + m_xEdFormat->grab_focus(); + m_xEdFormat->select_region(0, -1); + nReturn |= nReturnOneArea; + } + else + { + if ( bAdded && (nFmtLbSelPos != SELPOS_NONE) ) + { + // everything all right + if(bOneAreaFlag) //@@ ??? + SetCategory(0); + else + SetCategory(nCatLbSelPos ); + + FillFormatListBox_Impl( aEntryList ); + if (m_xEdComment->get_text()!=m_xLbCategory->get_text(1)) + { + pNumFmtShell->SetComment4Entry(nFmtLbSelPos, + m_xEdComment->get_text()); + } + else + { + pNumFmtShell->SetComment4Entry(nFmtLbSelPos, + OUString()); + } + m_xLbFormat->select(static_cast<sal_uInt16>(nFmtLbSelPos)); + m_xEdFormat->set_text( aFormat ); + + m_xEdComment->set_text(m_xLbCategory->get_text(1)); // String for user defined + + ChangePreviewText( static_cast<sal_uInt16>(nFmtLbSelPos) ); + } + } + } + else // syntax error + { + m_xEdFormat->grab_focus(); + m_xEdFormat->select_region(nErrPos == -1 ? m_xEdFormat->get_text().getLength() : nErrPos, -1); + } + EditHdl_Impl(m_xEdFormat.get()); + nReturn = ((nReturn & nReturnOneArea) ? 0 : (nReturn & nReturnChanged)); + + aEntryList.clear(); + a2EntryList.clear(); + } + else if (&rIB == m_xIbRemove.get()) + { + OUString aFormat = m_xEdFormat->get_text(); + std::vector<OUString> aEntryList; + sal_uInt16 nCatLbSelPos = 0; + short nFmtLbSelPos = SELPOS_NONE; + + pNumFmtShell->RemoveFormat( aFormat, + nCatLbSelPos, + nFmtLbSelPos, + aEntryList ); + + m_xEdComment->set_text(m_xLbCategory->get_text(1)); + + if( nFmtLbSelPos>=0 && o3tl::make_unsigned(nFmtLbSelPos)<aEntryList.size() ) + { + aFormat = aEntryList[nFmtLbSelPos]; + } + + FillFormatListBox_Impl( aEntryList ); + + if ( nFmtLbSelPos != SELPOS_NONE ) + { + if(bOneAreaFlag) //@@ ??? + SetCategory(0); + else + SetCategory(nCatLbSelPos ); + + m_xLbFormat->select(static_cast<sal_uInt16>(nFmtLbSelPos)); + m_xEdFormat->set_text( aFormat ); + ChangePreviewText( static_cast<sal_uInt16>(nFmtLbSelPos) ); + } + else + { + // set to "all/standard" + SetCategory(0); + SelFormatHdl_Impl(m_xLbCategory.get()); + } + + EditHdl_Impl(m_xEdFormat.get()); + + aEntryList.clear(); + } + else if (&rIB == m_xIbInfo.get()) + { + if (!m_xEdComment->get_visible()) + { + if (!m_xIbAdd->get_sensitive()) + // Editing for existing format. + m_nLbFormatSelPosEdComment = m_xLbFormat->get_selected_index(); + + m_xEdComment->set_text(m_xFtComment->get_label()); + m_xEdComment->show(); + m_xFtComment->hide(); + m_xEdComment->grab_focus(); + } + else + { + m_xEdFormat->grab_focus(); + m_xFtComment->set_label( m_xEdComment->get_text()); + m_xEdComment->hide(); + m_xFtComment->show(); + } + } + + return nReturn; +} + + +/************************************************************************* +#* Method: EditHdl_Impl +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: When the entry in the edit field is changed +#* the preview is updated and +#* Input: Pointer on Editbox +#* Output: --- +#* +#************************************************************************/ + +IMPL_LINK(SvxNumberFormatTabPage, EditModifyHdl_Impl, weld::Entry&, rEdit, void) +{ + EditHdl_Impl(&rEdit); +} + +void SvxNumberFormatTabPage::EditHdl_Impl(const weld::Entry* pEdFormat) +{ + sal_uInt32 nCurKey = NUMKEY_UNDEFINED; + + if ( m_xEdFormat->get_text().isEmpty() ) + { + m_xIbAdd->set_sensitive(false ); + m_xIbRemove->set_sensitive(false ); + m_xIbInfo->set_sensitive(false ); + m_xFtComment->set_label(OUString()); + } + else + { + OUString aFormat = m_xEdFormat->get_text(); + MakePreviewText( aFormat ); + + if ( pNumFmtShell->FindEntry( aFormat, &nCurKey ) ) + { + m_xIbAdd->set_sensitive(false ); + bool bUserDef=pNumFmtShell->IsUserDefined( aFormat ); + + m_xIbRemove->set_sensitive(bUserDef); + m_xIbInfo->set_sensitive(bUserDef); + + if(bUserDef) + { + sal_uInt16 nTmpCurPos=pNumFmtShell->FindCurrencyFormat(aFormat ); + if (nTmpCurPos != sal_uInt16(-1)) + set_active_currency(nTmpCurPos); + } + short nPosi=pNumFmtShell->GetListPos4Entry( nCurKey, aFormat); + if(nPosi>=0) + m_xLbFormat->select(static_cast<sal_uInt16>(nPosi)); + + } + else + { + + m_xIbAdd->set_sensitive(true); + m_xIbInfo->set_sensitive(true); + m_xIbRemove->set_sensitive(false ); + + m_xFtComment->set_label(m_xEdComment->get_text()); + + } + } + + if (pEdFormat) + { + pNumFmtShell->SetCurNumFmtKey( nCurKey ); + UpdateOptions_Impl( true ); + } +} + + +/************************************************************************* +#* Method: NotifyChange +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Does changes in the number attributes. +#* Input: Options- Controls +#* Output: --- +#* +#************************************************************************/ + +IMPL_LINK(SvxNumberFormatTabPage, OptClickHdl_Impl, weld::Toggleable&, rOptCtrl, void) +{ + OptHdl_Impl(&rOptCtrl); +} + +IMPL_LINK(SvxNumberFormatTabPage, OptEditHdl_Impl, weld::SpinButton&, rEdit, void) +{ + OptHdl_Impl(&rEdit); +} + +void SvxNumberFormatTabPage::OptHdl_Impl(const weld::Widget* pOptCtrl) +{ + if ( !(pOptCtrl == m_xEdLeadZeroes.get() + || pOptCtrl == m_xEdDecimals.get() + || pOptCtrl == m_xEdDenominator.get() + || pOptCtrl == m_xBtnNegRed.get() + || pOptCtrl == m_xBtnThousand.get() + || pOptCtrl == m_xBtnEngineering.get())) + return; + + OUString aFormat; + bool bThousand = ( m_xBtnThousand->get_visible() && m_xBtnThousand->get_sensitive() && m_xBtnThousand->get_active() ) + || ( m_xBtnEngineering->get_visible() && m_xBtnEngineering->get_sensitive() && m_xBtnEngineering->get_active() ); + bool bNegRed = m_xBtnNegRed->get_sensitive() && m_xBtnNegRed->get_active(); + sal_uInt16 nPrecision = (m_xEdDecimals->get_sensitive() && m_xEdDecimals->get_visible()) + ? static_cast<sal_uInt16>(m_xEdDecimals->get_value()) + : ( (m_xEdDenominator->get_sensitive() && m_xEdDenominator->get_visible()) + ? static_cast<sal_uInt16>(m_xEdDenominator->get_value()) + : sal_uInt16(0) ); + sal_uInt16 nLeadZeroes = (m_xEdLeadZeroes->get_sensitive()) + ? static_cast<sal_uInt16>(m_xEdLeadZeroes->get_value()) + : sal_uInt16(0); + if ( pNumFmtShell->GetStandardName() == m_xEdFormat->get_text() ) + { + m_xEdDecimals->set_value(nPrecision); + } + + pNumFmtShell->MakeFormat( aFormat, + bThousand, bNegRed, + nPrecision, nLeadZeroes, + static_cast<sal_uInt16>(m_xLbFormat->get_selected_index()) ); + + m_xEdFormat->set_text( aFormat ); + MakePreviewText( aFormat ); + + if ( pNumFmtShell->FindEntry( aFormat ) ) + { + m_xIbAdd->set_sensitive(false ); + bool bUserDef=pNumFmtShell->IsUserDefined( aFormat ); + m_xIbRemove->set_sensitive(bUserDef); + m_xIbInfo->set_sensitive(bUserDef); + EditHdl_Impl(m_xEdFormat.get()); + + } + else + { + EditHdl_Impl( nullptr ); + m_xLbFormat->select(-1); + } +} + +/************************************************************************* +#* Method: LostFocusHdl_Impl +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Does changes in the number attributes. +#* Input: Options- Controls +#* Output: --- +#* +#************************************************************************/ + +IMPL_LINK_NOARG(SvxNumberFormatTabPage, LostFocusHdl_Impl, weld::Widget&, void) +{ + if (!pNumFmtShell) + return; + + const bool bAddSensitive = m_xIbAdd->get_sensitive(); + if (bAddSensitive || m_nLbFormatSelPosEdComment != SELPOS_NONE) + // Comment editing was possible. + m_xFtComment->set_label(m_xEdComment->get_text()); + + m_xEdComment->hide(); + m_xFtComment->show(); + if (m_nLbFormatSelPosEdComment != SELPOS_NONE) + { + // Save edited comment of existing format. + pNumFmtShell->SetComment4Entry( m_nLbFormatSelPosEdComment, m_xEdComment->get_text()); + m_nLbFormatSelPosEdComment = SELPOS_NONE; + } + if (!bAddSensitive) + { + // String for user defined, if present + OUString sEntry = m_xLbCategory->n_children() > 1 ? m_xLbCategory->get_text(1) : OUString(); + m_xEdComment->set_text(sEntry); + } +} + +/************************************************************************* +#* Method: NotifyChange +#*------------------------------------------------------------------------ +#* +#* Class: SvxNumberFormatTabPage +#* Function: Does changes in the number attributes. +#* Input: Options- Controls +#* Output: --- +#* +#************************************************************************/ + +OUString SvxNumberFormatTabPage::GetExpColorString( + const Color*& rpPreviewColor, const OUString& rFormatStr, short nTmpCatPos) +{ + SvxNumValCategory i; + switch (nTmpCatPos) + { + case CAT_ALL: i=SvxNumValCategory::Standard; break; + + case CAT_NUMBER: i=SvxNumValCategory::Standard; break; + + case CAT_PERCENT: i=SvxNumValCategory::Percent; break; + + case CAT_CURRENCY: i=SvxNumValCategory::Currency; break; + + case CAT_DATE: i=SvxNumValCategory::Date; break; + + case CAT_TIME: i=SvxNumValCategory::Time; break; + + case CAT_SCIENTIFIC: i=SvxNumValCategory::Scientific; break; + + case CAT_FRACTION: i=SvxNumValCategory::Fraction; break; + + case CAT_BOOLEAN: i=SvxNumValCategory::Boolean; break; + + case CAT_USERDEFINED: i=SvxNumValCategory::Standard; break; + + case CAT_TEXT: + default: i=SvxNumValCategory::NoValue;break; + } + double fVal = fSvxNumValConst[i]; + + OUString aPreviewString; + pNumFmtShell->MakePrevStringFromVal( rFormatStr, aPreviewString, rpPreviewColor, fVal ); + return aPreviewString; +} + +void SvxNumberFormatTabPage::MakePreviewText( const OUString& rFormat ) +{ + OUString aPreviewString; + const Color* pPreviewColor = nullptr; + pNumFmtShell->MakePreviewString( rFormat, aPreviewString, pPreviewColor ); + m_aWndPreview.NotifyChange( aPreviewString, pPreviewColor ); +} + +void SvxNumberFormatTabPage::ChangePreviewText( sal_uInt16 nPos ) +{ + OUString aPreviewString; + const Color* pPreviewColor = nullptr; + pNumFmtShell->FormatChanged( nPos, aPreviewString, pPreviewColor ); + m_aWndPreview.NotifyChange( aPreviewString, pPreviewColor ); +} + +void SvxNumberFormatTabPage::FillCurrencyBox() +{ + std::vector<OUString> aList; + + sal_uInt16 nSelPos=0; + pNumFmtShell->GetCurrencySymbols(aList, &nSelPos); + + m_xLbCurrency->freeze(); + m_xLbCurrency->clear(); + bLegacyAutomaticCurrency = false; + for (std::vector<OUString>::iterator i = aList.begin() + 1;i != aList.end(); ++i) + m_xLbCurrency->append_text(*i); + m_xLbCurrency->thaw(); + + set_active_currency(nSelPos); +} + +void SvxNumberFormatTabPage::SetCategory(sal_uInt16 nPos) +{ + int nCurCategory = m_xLbCategory->get_selected_index(); + sal_uInt16 nTmpCatPos; + + if (bOneAreaFlag) + { + nTmpCatPos=nFixedCategory; + } + else + { + nTmpCatPos=nPos; + } + + if(m_xLbCategory->n_children()==1 || nCurCategory!=nPos) + { + if(nTmpCatPos!=CAT_CURRENCY) + m_xLbCurrency->hide(); + else + m_xLbCurrency->show(); + } + m_xLbCategory->select(nPos); +} + +/* to support Writer text field language handling an + additional entry needs to be inserted into the ListBox + which marks a certain language as automatically detected + Additionally the "Default" language is removed +*/ +void SvxNumberFormatTabPage::AddAutomaticLanguage_Impl(LanguageType eAutoLang, bool bSelect) +{ + m_xLbLanguage->remove_id(LANGUAGE_SYSTEM); + m_xLbLanguage->append(eAutoLang, sAutomaticLangEntry); + if (bSelect) + m_xLbLanguage->set_active_id(eAutoLang); +} + +void SvxNumberFormatTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SvxNumberInfoItem* pNumberInfoItem = aSet.GetItem<SvxNumberInfoItem>(SID_ATTR_NUMBERFORMAT_INFO, false); + if (pNumberInfoItem && !pNumItem) + pNumItem.reset(pNumberInfoItem->Clone()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/numpages.cxx b/cui/source/tabpages/numpages.cxx new file mode 100644 index 000000000..0c66f69ee --- /dev/null +++ b/cui/source/tabpages/numpages.cxx @@ -0,0 +1,3355 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <com/sun/star/text/HoriOrientation.hpp> +#include <com/sun/star/text/VertOrientation.hpp> + +#include <numpages.hxx> +#include <dialmgr.hxx> +#include <tools/mapunit.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <i18nlangtag/mslangid.hxx> +#include <editeng/numitem.hxx> +#include <svl/eitem.hxx> +#include <vcl/svapp.hxx> +#include <svx/colorbox.hxx> +#include <svx/dlgutil.hxx> +#include <svx/strarray.hxx> +#include <svx/gallery.hxx> +#include <editeng/brushitem.hxx> +#include <svl/intitem.hxx> +#include <sfx2/objsh.hxx> +#include <vcl/graph.hxx> +#include <vcl/settings.hxx> +#include <cui/cuicharmap.hxx> +#include <editeng/flstitem.hxx> +#include <svx/numvset.hxx> +#include <sfx2/htmlmode.hxx> +#include <unotools/pathoptions.hxx> +#include <svtools/ctrltool.hxx> +#include <svtools/unitconv.hxx> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/text/XDefaultNumberingProvider.hpp> +#include <com/sun/star/text/XNumberingFormatter.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <comphelper/processfactory.hxx> +#include <comphelper/propertyvalue.hxx> +#include <svx/svxids.hrc> +#include <o3tl/string_view.hxx> + +#include <algorithm> +#include <memory> +#include <vector> +#include <sfx2/opengrf.hxx> + +#include <strings.hrc> +#include <svl/stritem.hxx> +#include <svl/slstitm.hxx> +#include <sfx2/filedlghelper.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <com/sun/star/ucb/SimpleFileAccess.hpp> +#include <sal/log.hxx> +#include <vcl/cvtgrf.hxx> +#include <vcl/graphicfilter.hxx> +#include <svx/SvxNumOptionsTabPageHelper.hxx> +#include <tools/urlobj.hxx> +#include <o3tl/temporary.hxx> +#include <osl/diagnose.h> + +using namespace css; +using namespace css::uno; +using namespace css::beans; +using namespace css::lang; +using namespace css::text; +using namespace css::container; +using namespace css::style; + +#define SHOW_NUMBERING 0 +#define SHOW_BULLET 1 +#define SHOW_BITMAP 2 + +#define MAX_BMP_WIDTH 16 +#define MAX_BMP_HEIGHT 16 +#define SEARCHPATH_DELIMITER u';' +#define SEARCHFILENAME_DELIMITER u'/' + +static bool bLastRelative = false; + +static SvxNumSettings_Impl* lcl_CreateNumSettingsPtr(const Sequence<PropertyValue>& rLevelProps) +{ + const PropertyValue* pValues = rLevelProps.getConstArray(); + SvxNumSettings_Impl* pNew = new SvxNumSettings_Impl; + for(sal_Int32 j = 0; j < rLevelProps.getLength(); j++) + { + if ( pValues[j].Name == "NumberingType" ) + { + sal_Int16 nTmp; + if (pValues[j].Value >>= nTmp) + pNew->nNumberType = static_cast<SvxNumType>(nTmp); + } + else if ( pValues[j].Name == "Prefix" ) + pValues[j].Value >>= pNew->sPrefix; + else if ( pValues[j].Name == "Suffix" ) + pValues[j].Value >>= pNew->sSuffix; + else if ( pValues[j].Name == "ParentNumbering" ) + pValues[j].Value >>= pNew->nParentNumbering; + else if ( pValues[j].Name == "BulletChar" ) + pValues[j].Value >>= pNew->sBulletChar; + else if ( pValues[j].Name == "BulletFontName" ) + pValues[j].Value >>= pNew->sBulletFont; + } + return pNew; +} + +// the selection of bullets from the OpenSymbol +const sal_Unicode aBulletTypes[] = +{ + 0x2022, + 0x25cf, + 0xe00c, + 0xe00a, + 0x2794, + 0x27a2, + 0x2717, + 0x2714 +}; + +// Is one of the masked formats set? +static bool lcl_IsNumFmtSet(SvxNumRule const * pNum, sal_uInt16 nLevelMask) +{ + bool bRet = false; + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < SVX_MAX_NUM && !bRet; i++ ) + { + if(nLevelMask & nMask) + bRet |= nullptr != pNum->Get( i ); + nMask <<= 1 ; + } + return bRet; +} + +static const vcl::Font& lcl_GetDefaultBulletFont() +{ + static vcl::Font aDefBulletFont = []() + { + vcl::Font tmp("OpenSymbol", "", Size(0, 14)); + tmp.SetCharSet( RTL_TEXTENCODING_SYMBOL ); + tmp.SetFamily( FAMILY_DONTKNOW ); + tmp.SetPitch( PITCH_DONTKNOW ); + tmp.SetWeight( WEIGHT_DONTKNOW ); + tmp.SetTransparent( true ); + return tmp; + }(); + return aDefBulletFont; +} + +SvxSingleNumPickTabPage::SvxSingleNumPickTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/picknumberingpage.ui", "PickNumberingPage", &rSet) + , nActNumLvl(SAL_MAX_UINT16) + , bModified(false) + , bPreset(false) + , nNumItemId(SID_ATTR_NUMBERING_RULE) + , m_xExamplesVS(new SvxNumValueSet(m_xBuilder->weld_scrolled_window("valuesetwin", true))) + , m_xExamplesVSWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xExamplesVS)) +{ + SetExchangeSupport(); + m_xExamplesVS->init(NumberingPageType::SINGLENUM); + m_xExamplesVS->SetSelectHdl(LINK(this, SvxSingleNumPickTabPage, NumSelectHdl_Impl)); + m_xExamplesVS->SetDoubleClickHdl(LINK(this, SvxSingleNumPickTabPage, DoubleClickHdl_Impl)); + + Reference<XDefaultNumberingProvider> xDefNum = SvxNumOptionsTabPageHelper::GetNumberingProvider(); + if(!xDefNum.is()) + return; + + Sequence< Sequence< PropertyValue > > aNumberings; + const Locale& rLocale = Application::GetSettings().GetLanguageTag().getLocale(); + try + { + aNumberings = + xDefNum->getDefaultContinuousNumberingLevels( rLocale ); + + + sal_Int32 nLength = std::min<sal_Int32>(aNumberings.getLength(), NUM_VALUSET_COUNT); + + const Sequence<PropertyValue>* pValuesArr = aNumberings.getConstArray(); + for(sal_Int32 i = 0; i < nLength; i++) + { + SvxNumSettings_Impl* pNew = lcl_CreateNumSettingsPtr(pValuesArr[i]); + aNumSettingsArr.push_back(std::unique_ptr<SvxNumSettings_Impl>(pNew)); + } + } + catch(const Exception&) + { + } + Reference<XNumberingFormatter> xFormat(xDefNum, UNO_QUERY); + m_xExamplesVS->SetNumberingSettings(aNumberings, xFormat, rLocale); +} + +SvxSingleNumPickTabPage::~SvxSingleNumPickTabPage() +{ + m_xExamplesVSWin.reset(); + m_xExamplesVS.reset(); +} + +std::unique_ptr<SfxTabPage> SvxSingleNumPickTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<SvxSingleNumPickTabPage>(pPage, pController, *rAttrSet); +} + +bool SvxSingleNumPickTabPage::FillItemSet( SfxItemSet* rSet ) +{ + if( (bPreset || bModified) && pSaveNum) + { + *pSaveNum = *pActNum; + rSet->Put(SvxNumBulletItem( *pSaveNum, nNumItemId )); + rSet->Put(SfxBoolItem(SID_PARAM_NUM_PRESET, bPreset)); + } + + return bModified; +} + +void SvxSingleNumPickTabPage::ActivatePage(const SfxItemSet& rSet) +{ + bPreset = false; + bool bIsPreset = false; + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + if(pExampleSet) + { + if(const SfxBoolItem* pPresetItem = pExampleSet->GetItemIfSet(SID_PARAM_NUM_PRESET, false)) + bIsPreset = pPresetItem->GetValue(); + if(const SfxUInt16Item* pLevelItem = pExampleSet->GetItemIfSet(SID_PARAM_CUR_NUM_LEVEL, false)) + nActNumLvl = pLevelItem->GetValue(); + } + if(const SvxNumBulletItem* pNumItem = rSet.GetItemIfSet(nNumItemId, false)) + { + pSaveNum.reset( new SvxNumRule(pNumItem->GetNumRule()) ); + } + if(pActNum && *pSaveNum != *pActNum) + { + *pActNum = *pSaveNum; + m_xExamplesVS->SetNoSelection(); + } + + if(pActNum && (!lcl_IsNumFmtSet(pActNum.get(), nActNumLvl) || bIsPreset)) + { + m_xExamplesVS->SelectItem(1); + NumSelectHdl_Impl(m_xExamplesVS.get()); + bPreset = true; + } + bPreset |= bIsPreset; + + bModified = false; +} + +DeactivateRC SvxSingleNumPickTabPage::DeactivatePage(SfxItemSet *_pSet) +{ + if(_pSet) + FillItemSet(_pSet); + return DeactivateRC::LeavePage; +} + +void SvxSingleNumPickTabPage::Reset( const SfxItemSet* rSet ) +{ + const SfxPoolItem* pItem; + + // in Draw the item exists as WhichId, in Writer only as SlotId + SfxItemState eState = rSet->GetItemState(SID_ATTR_NUMBERING_RULE, false, &pItem); + if(eState != SfxItemState::SET) + { + nNumItemId = rSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); + eState = rSet->GetItemState(nNumItemId, false, &pItem); + + if( eState != SfxItemState::SET ) + { + pItem = & rSet->Get( nNumItemId ); + eState = SfxItemState::SET; + } + } + DBG_ASSERT(eState == SfxItemState::SET, "no item found!"); + pSaveNum.reset( new SvxNumRule(static_cast<const SvxNumBulletItem*>(pItem)->GetNumRule()) ); + + if(!pActNum) + pActNum.reset( new SvxNumRule(*pSaveNum) ); + else if(*pSaveNum != *pActNum) + *pActNum = *pSaveNum; +} + +IMPL_LINK_NOARG(SvxSingleNumPickTabPage, NumSelectHdl_Impl, ValueSet*, void) +{ + if(!pActNum) + return; + + bPreset = false; + bModified = true; + sal_uInt16 nIdx = m_xExamplesVS->GetSelectedItemId() - 1; + DBG_ASSERT(aNumSettingsArr.size() > nIdx, "wrong index"); + if(aNumSettingsArr.size() <= nIdx) + return; + SvxNumSettings_Impl* _pSet = aNumSettingsArr[nIdx].get(); + SvxNumType eNewType = _pSet->nNumberType; + const sal_Unicode cLocalPrefix = !_pSet->sPrefix.isEmpty() ? _pSet->sPrefix[0] : 0; + const sal_Unicode cLocalSuffix = !_pSet->sSuffix.isEmpty() ? _pSet->sSuffix[0] : 0; + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aFmt(pActNum->GetLevel(i)); + aFmt.SetNumberingType(eNewType); + aFmt.SetListFormat(cLocalPrefix == ' ' ? "" : _pSet->sPrefix, + cLocalSuffix == ' ' ? "" : _pSet->sSuffix, i); + aFmt.SetCharFormatName(""); + aFmt.SetBulletRelSize(100); + pActNum->SetLevel(i, aFmt); + } + nMask <<= 1; + } +} + +IMPL_LINK_NOARG(SvxSingleNumPickTabPage, DoubleClickHdl_Impl, ValueSet*, void) +{ + NumSelectHdl_Impl(m_xExamplesVS.get()); + weld::Button& rOk = GetDialogController()->GetOKButton(); + rOk.clicked(); +} + +SvxBulletPickTabPage::SvxBulletPickTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/pickbulletpage.ui", "PickBulletPage", &rSet) + , nActNumLvl(SAL_MAX_UINT16) + , bModified(false) + , bPreset(false) + , nNumItemId(SID_ATTR_NUMBERING_RULE) + , m_xExamplesVS(new SvxNumValueSet(m_xBuilder->weld_scrolled_window("valuesetwin", true))) + , m_xExamplesVSWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xExamplesVS)) +{ + SetExchangeSupport(); + m_xExamplesVS->init(NumberingPageType::BULLET); + m_xExamplesVS->SetSelectHdl(LINK(this, SvxBulletPickTabPage, NumSelectHdl_Impl)); + m_xExamplesVS->SetDoubleClickHdl(LINK(this, SvxBulletPickTabPage, DoubleClickHdl_Impl)); +} + +SvxBulletPickTabPage::~SvxBulletPickTabPage() +{ + m_xExamplesVSWin.reset(); + m_xExamplesVS.reset(); +} + +std::unique_ptr<SfxTabPage> SvxBulletPickTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<SvxBulletPickTabPage>(pPage, pController, *rAttrSet); +} + +bool SvxBulletPickTabPage::FillItemSet( SfxItemSet* rSet ) +{ + if( (bPreset || bModified) && pActNum) + { + *pSaveNum = *pActNum; + rSet->Put(SvxNumBulletItem( *pSaveNum, nNumItemId )); + rSet->Put(SfxBoolItem(SID_PARAM_NUM_PRESET, bPreset)); + } + return bModified; +} + +void SvxBulletPickTabPage::ActivatePage(const SfxItemSet& rSet) +{ + bPreset = false; + bool bIsPreset = false; + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + if(pExampleSet) + { + if(const SfxBoolItem* pPresetItem = pExampleSet->GetItemIfSet(SID_PARAM_NUM_PRESET, false)) + bIsPreset = pPresetItem->GetValue(); + if(const SfxUInt16Item* pLevelItem = pExampleSet->GetItemIfSet(SID_PARAM_CUR_NUM_LEVEL, false)) + nActNumLvl = pLevelItem->GetValue(); + } + if(const SvxNumBulletItem* pBulletItem = rSet.GetItemIfSet(nNumItemId, false)) + { + pSaveNum.reset( new SvxNumRule(pBulletItem->GetNumRule()) ); + } + if(pActNum && *pSaveNum != *pActNum) + { + *pActNum = *pSaveNum; + m_xExamplesVS->SetNoSelection(); + } + + if(pActNum && (!lcl_IsNumFmtSet(pActNum.get(), nActNumLvl) || bIsPreset)) + { + m_xExamplesVS->SelectItem(1); + NumSelectHdl_Impl(m_xExamplesVS.get()); + bPreset = true; + } + bPreset |= bIsPreset; + bModified = false; +} + +DeactivateRC SvxBulletPickTabPage::DeactivatePage(SfxItemSet *_pSet) +{ + if(_pSet) + FillItemSet(_pSet); + return DeactivateRC::LeavePage; +} + +void SvxBulletPickTabPage::Reset( const SfxItemSet* rSet ) +{ + // in Draw the item exists as WhichId, in Writer only as SlotId + const SvxNumBulletItem* pItem = rSet->GetItemIfSet(SID_ATTR_NUMBERING_RULE, false); + if(!pItem) + { + nNumItemId = rSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); + pItem = rSet->GetItemIfSet(nNumItemId, false); + + if( !pItem ) + { + pItem = & rSet->Get( nNumItemId ); + } + + } + pSaveNum.reset( new SvxNumRule(pItem->GetNumRule()) ); + + if(!pActNum) + pActNum.reset( new SvxNumRule(*pSaveNum) ); + else if(*pSaveNum != *pActNum) + *pActNum = *pSaveNum; +} + +IMPL_LINK_NOARG(SvxBulletPickTabPage, NumSelectHdl_Impl, ValueSet*, void) +{ + if(!pActNum) + return; + + bPreset = false; + bModified = true; + sal_Unicode cChar = aBulletTypes[m_xExamplesVS->GetSelectedItemId() - 1]; + const vcl::Font& rActBulletFont = lcl_GetDefaultBulletFont(); + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aFmt(pActNum->GetLevel(i)); + aFmt.SetNumberingType( SVX_NUM_CHAR_SPECIAL ); + // #i93908# clear suffix for bullet lists + aFmt.SetListFormat("", "", i); + aFmt.SetBulletFont(&rActBulletFont); + aFmt.SetBulletChar(cChar ); + aFmt.SetCharFormatName(sBulletCharFormatName); + aFmt.SetBulletRelSize(45); + pActNum->SetLevel(i, aFmt); + } + nMask <<= 1; + } +} + +IMPL_LINK_NOARG(SvxBulletPickTabPage, DoubleClickHdl_Impl, ValueSet*, void) +{ + NumSelectHdl_Impl(m_xExamplesVS.get()); + weld::Button& rOk = GetDialogController()->GetOKButton(); + rOk.clicked(); +} + +void SvxBulletPickTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxStringItem* pBulletCharFmt = aSet.GetItem<SfxStringItem>(SID_BULLET_CHAR_FMT, false); + + if (pBulletCharFmt) + sBulletCharFormatName = pBulletCharFmt->GetValue(); +} + +SvxNumPickTabPage::SvxNumPickTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/pickoutlinepage.ui", "PickOutlinePage", &rSet) + , nActNumLvl(SAL_MAX_UINT16) + , nNumItemId(SID_ATTR_NUMBERING_RULE) + , bModified(false) + , bPreset(false) + , m_xExamplesVS(new SvxNumValueSet(m_xBuilder->weld_scrolled_window("valuesetwin", true))) + , m_xExamplesVSWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xExamplesVS)) +{ + SetExchangeSupport(); + + m_xExamplesVS->init(NumberingPageType::OUTLINE); + m_xExamplesVS->SetSelectHdl(LINK(this, SvxNumPickTabPage, NumSelectHdl_Impl)); + m_xExamplesVS->SetDoubleClickHdl(LINK(this, SvxNumPickTabPage, DoubleClickHdl_Impl)); + + Reference<XDefaultNumberingProvider> xDefNum = SvxNumOptionsTabPageHelper::GetNumberingProvider(); + if(!xDefNum.is()) + return; + + Sequence<Reference<XIndexAccess> > aOutlineAccess; + const Locale& rLocale = Application::GetSettings().GetLanguageTag().getLocale(); + try + { + aOutlineAccess = xDefNum->getDefaultOutlineNumberings( rLocale ); + + for(sal_Int32 nItem = 0; + nItem < aOutlineAccess.getLength() && nItem < NUM_VALUSET_COUNT; + nItem++ ) + { + SvxNumSettingsArr_Impl& rItemArr = aNumSettingsArrays[ nItem ]; + + Reference<XIndexAccess> xLevel = aOutlineAccess.getConstArray()[nItem]; + for(sal_Int32 nLevel = 0; nLevel < xLevel->getCount() && nLevel < 5; nLevel++) + { + Any aValueAny = xLevel->getByIndex(nLevel); + Sequence<PropertyValue> aLevelProps; + aValueAny >>= aLevelProps; + SvxNumSettings_Impl* pNew = lcl_CreateNumSettingsPtr(aLevelProps); + rItemArr.push_back( std::unique_ptr<SvxNumSettings_Impl>(pNew) ); + } + } + } + catch(const Exception&) + { + } + Reference<XNumberingFormatter> xFormat(xDefNum, UNO_QUERY); + m_xExamplesVS->SetOutlineNumberingSettings(aOutlineAccess, xFormat, rLocale); +} + +SvxNumPickTabPage::~SvxNumPickTabPage() +{ + m_xExamplesVSWin.reset(); + m_xExamplesVS.reset(); +} + +std::unique_ptr<SfxTabPage> SvxNumPickTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<SvxNumPickTabPage>(pPage, pController, *rAttrSet); +} + +bool SvxNumPickTabPage::FillItemSet( SfxItemSet* rSet ) +{ + if( (bPreset || bModified) && pActNum) + { + *pSaveNum = *pActNum; + rSet->Put(SvxNumBulletItem( *pSaveNum, nNumItemId )); + rSet->Put(SfxBoolItem(SID_PARAM_NUM_PRESET, bPreset)); + } + return bModified; +} + +void SvxNumPickTabPage::ActivatePage(const SfxItemSet& rSet) +{ + bPreset = false; + bool bIsPreset = false; + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + if(pExampleSet) + { + if(const SfxBoolItem* pPresetItem = pExampleSet->GetItemIfSet(SID_PARAM_NUM_PRESET, false)) + bIsPreset = pPresetItem->GetValue(); + if(const SfxUInt16Item* pLevelItem = pExampleSet->GetItemIfSet(SID_PARAM_CUR_NUM_LEVEL, false)) + nActNumLvl = pLevelItem->GetValue(); + } + if(const SvxNumBulletItem* pBulletItem = rSet.GetItemIfSet(nNumItemId, false)) + { + pSaveNum.reset( new SvxNumRule(pBulletItem->GetNumRule()) ); + } + if(pActNum && *pSaveNum != *pActNum) + { + *pActNum = *pSaveNum; + m_xExamplesVS->SetNoSelection(); + } + + if(pActNum && (!lcl_IsNumFmtSet(pActNum.get(), nActNumLvl) || bIsPreset)) + { + m_xExamplesVS->SelectItem(1); + NumSelectHdl_Impl(m_xExamplesVS.get()); + bPreset = true; + } + bPreset |= bIsPreset; + bModified = false; +} + +DeactivateRC SvxNumPickTabPage::DeactivatePage(SfxItemSet *_pSet) +{ + if(_pSet) + FillItemSet(_pSet); + return DeactivateRC::LeavePage; +} + +void SvxNumPickTabPage::Reset( const SfxItemSet* rSet ) +{ + // in Draw the item exists as WhichId, in Writer only as SlotId + const SvxNumBulletItem* pItem = rSet->GetItemIfSet(SID_ATTR_NUMBERING_RULE, false); + if(!pItem) + { + nNumItemId = rSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); + pItem = rSet->GetItemIfSet(nNumItemId, false); + + if( !pItem ) + { + pItem = & rSet->Get( nNumItemId ); + } + } + pSaveNum.reset( new SvxNumRule(pItem->GetNumRule()) ); + + if(!pActNum) + pActNum.reset( new SvxNumRule(*pSaveNum) ); + else if(*pSaveNum != *pActNum) + *pActNum = *pSaveNum; + +} + +// all levels are changed here +IMPL_LINK_NOARG(SvxNumPickTabPage, NumSelectHdl_Impl, ValueSet*, void) +{ + if(!pActNum) + return; + + bPreset = false; + bModified = true; + + const FontList* pList = nullptr; + + SvxNumSettingsArr_Impl& rItemArr = aNumSettingsArrays[m_xExamplesVS->GetSelectedItemId() - 1]; + + const vcl::Font& rActBulletFont = lcl_GetDefaultBulletFont(); + SvxNumSettings_Impl* pLevelSettings = nullptr; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(rItemArr.size() > i) + pLevelSettings = rItemArr[i].get(); + if(!pLevelSettings) + break; + SvxNumberFormat aFmt(pActNum->GetLevel(i)); + aFmt.SetNumberingType( pLevelSettings->nNumberType ); + sal_uInt16 nUpperLevelOrChar = static_cast<sal_uInt16>(pLevelSettings->nParentNumbering); + if(aFmt.GetNumberingType() == SVX_NUM_CHAR_SPECIAL) + { + // #i93908# clear suffix for bullet lists + aFmt.SetListFormat("", "", i); + if( !pLevelSettings->sBulletFont.isEmpty() && + pLevelSettings->sBulletFont != rActBulletFont.GetFamilyName()) + { + //search for the font + if(!pList) + { + if (SfxObjectShell* pCurDocShell = SfxObjectShell::Current()) + { + const SvxFontListItem* pFontListItem = + static_cast<const SvxFontListItem*>( pCurDocShell + ->GetItem( SID_ATTR_CHAR_FONTLIST )); + pList = pFontListItem ? pFontListItem->GetFontList() : nullptr; + } + } + if(pList && pList->IsAvailable( pLevelSettings->sBulletFont ) ) + { + FontMetric aFontMetric = pList->Get( + pLevelSettings->sBulletFont,WEIGHT_NORMAL, ITALIC_NONE); + vcl::Font aFont(aFontMetric); + aFmt.SetBulletFont(&aFont); + } + else + { + //if it cannot be found then create a new one + vcl::Font aCreateFont( pLevelSettings->sBulletFont, + OUString(), Size( 0, 14 ) ); + aCreateFont.SetCharSet( RTL_TEXTENCODING_DONTKNOW ); + aCreateFont.SetFamily( FAMILY_DONTKNOW ); + aCreateFont.SetPitch( PITCH_DONTKNOW ); + aCreateFont.SetWeight( WEIGHT_DONTKNOW ); + aCreateFont.SetTransparent( true ); + aFmt.SetBulletFont( &aCreateFont ); + } + } + else + aFmt.SetBulletFont( &rActBulletFont ); + + aFmt.SetBulletChar( !pLevelSettings->sBulletChar.isEmpty() + ? pLevelSettings->sBulletChar.iterateCodePoints( + &o3tl::temporary(sal_Int32(0))) + : 0 ); + aFmt.SetCharFormatName( sBulletCharFormatName ); + aFmt.SetBulletRelSize(45); + } + else + { + aFmt.SetIncludeUpperLevels(sal::static_int_cast< sal_uInt8 >(0 != nUpperLevelOrChar ? pActNum->GetLevelCount() : 1)); + aFmt.SetCharFormatName(sNumCharFmtName); + aFmt.SetBulletRelSize(100); + // #i93908# + aFmt.SetListFormat(pLevelSettings->sPrefix, pLevelSettings->sSuffix, i); + } + pActNum->SetLevel(i, aFmt); + } +} + +IMPL_LINK_NOARG(SvxNumPickTabPage, DoubleClickHdl_Impl, ValueSet*, void) +{ + NumSelectHdl_Impl(m_xExamplesVS.get()); + weld::Button& rOk = GetDialogController()->GetOKButton(); + rOk.clicked(); +} + +void SvxNumPickTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxStringItem* pNumCharFmt = aSet.GetItem<SfxStringItem>(SID_NUM_CHAR_FMT, false); + const SfxStringItem* pBulletCharFmt = aSet.GetItem<SfxStringItem>(SID_BULLET_CHAR_FMT, false); + + + if (pNumCharFmt &&pBulletCharFmt) + SetCharFormatNames( pNumCharFmt->GetValue(),pBulletCharFmt->GetValue()); +} + +SvxBitmapPickTabPage::SvxBitmapPickTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/pickgraphicpage.ui", "PickGraphicPage", &rSet) + , nActNumLvl(SAL_MAX_UINT16) + , nNumItemId(SID_ATTR_NUMBERING_RULE) + , bModified(false) + , bPreset(false) + , m_xErrorText(m_xBuilder->weld_label("errorft")) + , m_xBtBrowseFile(m_xBuilder->weld_button("browseBtn")) + , m_xExamplesVS(new SvxBmpNumValueSet(m_xBuilder->weld_scrolled_window("valuesetwin", true))) + , m_xExamplesVSWin(new weld::CustomWeld(*m_xBuilder, "valueset", *m_xExamplesVS)) +{ + SetExchangeSupport(); + + m_xExamplesVS->init(); + m_xExamplesVS->SetSelectHdl(LINK(this, SvxBitmapPickTabPage, NumSelectHdl_Impl)); + m_xExamplesVS->SetDoubleClickHdl(LINK(this, SvxBitmapPickTabPage, DoubleClickHdl_Impl)); + m_xBtBrowseFile->connect_clicked(LINK(this, SvxBitmapPickTabPage, ClickAddBrowseHdl_Impl)); + + eCoreUnit = rSet.GetPool()->GetMetric(rSet.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE)); + + // determine graphic name + GalleryExplorer::FillObjList(GALLERY_THEME_BULLETS, aGrfNames); + + size_t i = 0; + for (auto & grfName : aGrfNames) + { + m_xExamplesVS->InsertItem( i + 1, i); + + INetURLObject aObj(grfName); + if (aObj.GetProtocol() == INetProtocol::File) + { + // tdf#114070 - only show the last name of the filename without its extension + aObj.removeExtension(); + grfName = aObj.GetLastName(INetURLObject::DecodeMechanism::Unambiguous); + } + + m_xExamplesVS->SetItemText( i + 1, grfName ); + ++i; + } + + if(aGrfNames.empty()) + { + m_xErrorText->show(); + } + else + { + m_xExamplesVS->Show(); + m_xExamplesVS->SetFormat(); + m_xExamplesVS->Invalidate(); + } +} + +SvxBitmapPickTabPage::~SvxBitmapPickTabPage() +{ + m_xExamplesVSWin.reset(); + m_xExamplesVS.reset(); +} + +std::unique_ptr<SfxTabPage> SvxBitmapPickTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<SvxBitmapPickTabPage>(pPage, pController, *rAttrSet); +} + +void SvxBitmapPickTabPage::ActivatePage(const SfxItemSet& rSet) +{ + bPreset = false; + bool bIsPreset = false; + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + if(pExampleSet) + { + if(const SfxBoolItem* pPresetItem = pExampleSet->GetItemIfSet(SID_PARAM_NUM_PRESET, false)) + bIsPreset = pPresetItem->GetValue(); + if(const SfxUInt16Item* pLevelItem = pExampleSet->GetItemIfSet(SID_PARAM_CUR_NUM_LEVEL, false)) + nActNumLvl = pLevelItem->GetValue(); + } + if(const SvxNumBulletItem* pBulletItem = rSet.GetItemIfSet(nNumItemId, false)) + { + pSaveNum.reset( new SvxNumRule(pBulletItem->GetNumRule()) ); + } + if(pActNum && *pSaveNum != *pActNum) + { + *pActNum = *pSaveNum; + m_xExamplesVS->SetNoSelection(); + } + + if(!aGrfNames.empty() && + (pActNum && (!lcl_IsNumFmtSet(pActNum.get(), nActNumLvl) || bIsPreset))) + { + m_xExamplesVS->SelectItem(1); + NumSelectHdl_Impl(m_xExamplesVS.get()); + bPreset = true; + } + bPreset |= bIsPreset; + bModified = false; +} + +DeactivateRC SvxBitmapPickTabPage::DeactivatePage(SfxItemSet *_pSet) +{ + if(_pSet) + FillItemSet(_pSet); + return DeactivateRC::LeavePage; +} + +bool SvxBitmapPickTabPage::FillItemSet( SfxItemSet* rSet ) +{ + if ( aGrfNames.empty() ) + { + return false; + } + if( (bPreset || bModified) && pActNum) + { + *pSaveNum = *pActNum; + rSet->Put(SvxNumBulletItem( *pSaveNum, nNumItemId ) ); + rSet->Put(SfxBoolItem(SID_PARAM_NUM_PRESET, bPreset)); + } + + return bModified; +} + +void SvxBitmapPickTabPage::Reset( const SfxItemSet* rSet ) +{ + // in Draw the item exists as WhichId, in Writer only as SlotId + const SvxNumBulletItem* pItem = rSet->GetItemIfSet(SID_ATTR_NUMBERING_RULE, false); + if(!pItem) + { + nNumItemId = rSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); + pItem = rSet->GetItemIfSet(nNumItemId, false); + + if( !pItem ) + { + pItem = & rSet->Get( nNumItemId ); + } + + } + DBG_ASSERT(pItem, "no item found!"); + pSaveNum.reset( new SvxNumRule(pItem->GetNumRule()) ); + + if(!pActNum) + pActNum.reset( new SvxNumRule(*pSaveNum) ); + else if(*pSaveNum != *pActNum) + *pActNum = *pSaveNum; +} + +IMPL_LINK_NOARG(SvxBitmapPickTabPage, NumSelectHdl_Impl, ValueSet*, void) +{ + if(!pActNum) + return; + + bPreset = false; + bModified = true; + sal_uInt16 nIdx = m_xExamplesVS->GetSelectedItemId() - 1; + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aFmt(pActNum->GetLevel(i)); + aFmt.SetNumberingType(SVX_NUM_BITMAP); + aFmt.SetListFormat("", "", i); + aFmt.SetCharFormatName( "" ); + + Graphic aGraphic; + if(GalleryExplorer::GetGraphicObj( GALLERY_THEME_BULLETS, nIdx, &aGraphic)) + { + Size aSize = SvxNumberFormat::GetGraphicSizeMM100(&aGraphic); + sal_Int16 eOrient = text::VertOrientation::LINE_CENTER; + aSize = OutputDevice::LogicToLogic(aSize, MapMode(MapUnit::Map100thMM), MapMode(eCoreUnit)); + SvxBrushItem aBrush(aGraphic, GPOS_AREA, SID_ATTR_BRUSH ); + aFmt.SetGraphicBrush( &aBrush, &aSize, &eOrient ); + } + else if(aGrfNames.size() > nIdx) + aFmt.SetGraphic( aGrfNames[nIdx] ); + pActNum->SetLevel(i, aFmt); + } + nMask <<= 1; + } +} + +IMPL_LINK_NOARG(SvxBitmapPickTabPage, DoubleClickHdl_Impl, ValueSet*, void) +{ + NumSelectHdl_Impl(m_xExamplesVS.get()); + weld::Button& rOk = GetDialogController()->GetOKButton(); + rOk.clicked(); +} + +IMPL_LINK_NOARG(SvxBitmapPickTabPage, ClickAddBrowseHdl_Impl, weld::Button&, void) +{ + sfx2::FileDialogHelper aFileDialog(0, FileDialogFlags::NONE, GetFrameWeld()); + aFileDialog.SetContext(sfx2::FileDialogHelper::BulletsAddImage); + aFileDialog.SetTitle(CuiResId(RID_CUISTR_ADD_IMAGE)); + if ( aFileDialog.Execute() != ERRCODE_NONE ) + return; + + OUString aPath = SvtPathOptions().GetGalleryPath(); + std::u16string_view aPathToken = o3tl::getToken(aPath, 1 , SEARCHPATH_DELIMITER ); + + OUString aUserImageURL = aFileDialog.GetPath(); + + OUString aFileName; + const sal_Int32 nPos {aUserImageURL.lastIndexOf(SEARCHFILENAME_DELIMITER)+1}; + if (nPos<=0) + aFileName = aUserImageURL; + else if (nPos<aUserImageURL.getLength()) + aFileName = aUserImageURL.copy(nPos); + + OUString aUserGalleryURL = OUString::Concat(aPathToken) + "/" + aFileName; + INetURLObject aURL( aUserImageURL ); + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + + GraphicDescriptor aDescriptor(aURL); + if (!aDescriptor.Detect()) + return; + + uno::Reference< lang::XMultiServiceFactory > xFactory = ::comphelper::getProcessServiceFactory(); + uno::Reference<ucb::XSimpleFileAccess3> xSimpleFileAccess( + ucb::SimpleFileAccess::create( ::comphelper::getComponentContext(xFactory) ) ); + if ( !xSimpleFileAccess->exists( aUserImageURL )) + return; + + xSimpleFileAccess->copy( aUserImageURL, aUserGalleryURL ); + INetURLObject gURL( aUserGalleryURL ); + std::unique_ptr<SvStream> pIn(::utl::UcbStreamHelper::CreateStream( + gURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ )); + if ( !pIn ) + return; + + Graphic aGraphic; + GraphicConverter::Import( *pIn, aGraphic ); + + BitmapEx aBitmap = aGraphic.GetBitmapEx(); + tools::Long nPixelX = aBitmap.GetSizePixel().Width(); + tools::Long nPixelY = aBitmap.GetSizePixel().Height(); + double ratio = nPixelY/static_cast<double>(nPixelX); + if(nPixelX > 30) + { + nPixelX = 30; + nPixelY = static_cast<tools::Long>(nPixelX*ratio); + } + if(nPixelY > 30) + { + nPixelY = 30; + nPixelX = static_cast<tools::Long>(nPixelY/ratio); + } + + aBitmap.Scale( Size( nPixelX, nPixelY ), BmpScaleFlag::Fast ); + Graphic aScaledGraphic( aBitmap ); + GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter(); + + Sequence< PropertyValue > aFilterData{ + comphelper::makePropertyValue("Compression", sal_Int32(-1)), + comphelper::makePropertyValue("Quality", sal_Int32(1)) + }; + + sal_uInt16 nFilterFormat = rFilter.GetExportFormatNumberForShortName( gURL.GetFileExtension() ); + rFilter.ExportGraphic( aScaledGraphic, gURL , nFilterFormat, &aFilterData ); + GalleryExplorer::InsertURL( GALLERY_THEME_BULLETS, aUserGalleryURL ); + + aGrfNames.push_back(aUserGalleryURL); + size_t i = 0; + for (auto & grfName : aGrfNames) + { + m_xExamplesVS->InsertItem( i + 1, i); + INetURLObject aObj(grfName); + if (aObj.GetProtocol() == INetProtocol::File) + { + // tdf#114070 - only show the last name of the filename without its extension + aObj.removeExtension(); + grfName = aObj.GetLastName(INetURLObject::DecodeMechanism::Unambiguous); + } + m_xExamplesVS->SetItemText( i + 1, grfName ); + ++i; + } + + if(aGrfNames.empty()) + { + m_xErrorText->show(); + } + else + { + m_xExamplesVS->Show(); + m_xExamplesVS->SetFormat(); + } +} + +// tabpage numbering options +SvxNumOptionsTabPage::SvxNumOptionsTabPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/numberingoptionspage.ui", "NumberingOptionsPage", &rSet) + , aInvalidateTimer("cui SvxNumOptionsTabPage aInvalidateTimer") + , m_pLevelHdlEvent(nullptr) + , bLastWidthModified(false) + , bModified(false) + , bPreset(false) + , bAutomaticCharStyles(true) + , bHTMLMode(false) + , nBullet(0xff) + , nActNumLvl(1) + , nNumItemId(SID_ATTR_NUMBERING_RULE) + , m_xGrid(m_xBuilder->weld_widget("grid2")) + , m_xLevelLB(m_xBuilder->weld_tree_view("levellb")) + , m_xFmtLB(m_xBuilder->weld_combo_box("numfmtlb")) + , m_xSeparatorFT(m_xBuilder->weld_label("separator")) + , m_xPrefixFT(m_xBuilder->weld_label("prefixft")) + , m_xPrefixED(m_xBuilder->weld_entry("prefix")) + , m_xSuffixFT(m_xBuilder->weld_label("suffixft")) + , m_xSuffixED(m_xBuilder->weld_entry("suffix")) + , m_xCharFmtFT(m_xBuilder->weld_label("charstyleft")) + , m_xCharFmtLB(m_xBuilder->weld_combo_box("charstyle")) + , m_xBulColorFT(m_xBuilder->weld_label("colorft")) + , m_xBulColLB(new ColorListBox(m_xBuilder->weld_menu_button("color"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xBulRelSizeFT(m_xBuilder->weld_label("relsizeft")) + , m_xBulRelSizeMF(m_xBuilder->weld_metric_spin_button("relsize", FieldUnit::PERCENT)) + , m_xAllLevelFT(m_xBuilder->weld_label("sublevelsft")) + , m_xAllLevelNF(m_xBuilder->weld_spin_button("sublevels")) + , m_xStartFT(m_xBuilder->weld_label("startatft")) + , m_xStartED(m_xBuilder->weld_spin_button("startat")) + , m_xBulletFT(m_xBuilder->weld_label("bulletft")) + , m_xBulletPB(m_xBuilder->weld_button("bullet")) + , m_xBitmapFT(m_xBuilder->weld_label("bitmapft")) + , m_xBitmapMB(m_xBuilder->weld_menu_button("bitmap")) + , m_xWidthFT(m_xBuilder->weld_label("widthft")) + , m_xWidthMF(m_xBuilder->weld_metric_spin_button("widthmf", FieldUnit::CM)) + , m_xHeightFT(m_xBuilder->weld_label("heightft")) + , m_xHeightMF(m_xBuilder->weld_metric_spin_button("heightmf", FieldUnit::CM)) + , m_xRatioCB(m_xBuilder->weld_check_button("keepratio")) + , m_xOrientFT(m_xBuilder->weld_label("orientft")) + , m_xOrientLB(m_xBuilder->weld_combo_box("orientlb")) + , m_xAllLevelsFrame(m_xBuilder->weld_widget("levelsframe")) + , m_xSameLevelCB(m_xBuilder->weld_check_button("allsame")) + , m_xPreviewWIN(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWIN)) +{ + m_xBulColLB->SetSlotId(SID_ATTR_CHAR_COLOR); + m_xBulRelSizeMF->set_min(SVX_NUM_REL_SIZE_MIN, FieldUnit::PERCENT); + m_xBulRelSizeMF->set_increments(5, 50, FieldUnit::PERCENT); + SetExchangeSupport(); + aActBulletFont = lcl_GetDefaultBulletFont(); + + m_xBulletPB->connect_clicked(LINK(this, SvxNumOptionsTabPage, BulletHdl_Impl)); + m_xFmtLB->connect_changed(LINK(this, SvxNumOptionsTabPage, NumberTypeSelectHdl_Impl)); + m_xBitmapMB->connect_selected(LINK(this, SvxNumOptionsTabPage, GraphicHdl_Impl)); + m_xBitmapMB->connect_toggled(LINK(this, SvxNumOptionsTabPage, PopupActivateHdl_Impl)); + m_xLevelLB->set_selection_mode(SelectionMode::Multiple); + m_xLevelLB->connect_changed(LINK(this, SvxNumOptionsTabPage, LevelHdl_Impl)); + m_xCharFmtLB->connect_changed(LINK(this, SvxNumOptionsTabPage, CharFmtHdl_Impl)); + m_xWidthMF->connect_value_changed(LINK(this, SvxNumOptionsTabPage, SizeHdl_Impl)); + m_xHeightMF->connect_value_changed(LINK(this, SvxNumOptionsTabPage, SizeHdl_Impl)); + m_xRatioCB->connect_toggled(LINK(this, SvxNumOptionsTabPage, RatioHdl_Impl)); + m_xStartED->connect_value_changed(LINK(this, SvxNumOptionsTabPage, SpinModifyHdl_Impl)); + m_xPrefixED->connect_changed(LINK(this, SvxNumOptionsTabPage, EditModifyHdl_Impl)); + m_xSuffixED->connect_changed(LINK(this, SvxNumOptionsTabPage, EditModifyHdl_Impl)); + m_xAllLevelNF->connect_value_changed(LINK(this,SvxNumOptionsTabPage, AllLevelHdl_Impl)); + m_xOrientLB->connect_changed(LINK(this, SvxNumOptionsTabPage, OrientHdl_Impl)); + m_xSameLevelCB->connect_toggled(LINK(this, SvxNumOptionsTabPage, SameLevelHdl_Impl)); + m_xBulRelSizeMF->connect_value_changed(LINK(this,SvxNumOptionsTabPage, BulRelSizeHdl_Impl)); + m_xBulColLB->SetSelectHdl(LINK(this, SvxNumOptionsTabPage, BulColorHdl_Impl)); + aInvalidateTimer.SetInvokeHandler(LINK(this, SvxNumOptionsTabPage, PreviewInvalidateHdl_Impl)); + aInvalidateTimer.SetTimeout(50); + + eCoreUnit = rSet.GetPool()->GetMetric(rSet.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE)); + + // Fill ListBox with predefined / translated numbering types. + sal_uInt32 nCount = SvxNumberingTypeTable::Count(); + for (sal_uInt32 i = 0; i < nCount; ++i) + { + m_xFmtLB->append(OUString::number(SvxNumberingTypeTable::GetValue(i)), SvxNumberingTypeTable::GetString(i)); + } + + // Get advanced numbering types from the component. + // Watch out for the ugly + // 136 == 0x88 == SVX_NUM_BITMAP|0x80 == SVX_NUM_BITMAP|LINK_TOKEN + // to not remove that. + SvxNumOptionsTabPageHelper::GetI18nNumbering( *m_xFmtLB, (SVX_NUM_BITMAP | LINK_TOKEN)); + + m_xFmtLB->set_active(0); + + m_xCharFmtLB->set_size_request(m_xCharFmtLB->get_approximate_digit_width() * 10, -1); + Size aSize(m_xGrid->get_preferred_size()); + m_xGrid->set_size_request(aSize.Width(), -1); +} + +SvxNumOptionsTabPage::~SvxNumOptionsTabPage() +{ + m_xPreviewWIN.reset(); + m_xBulColLB.reset(); + pActNum.reset(); + pSaveNum.reset(); + if (m_pLevelHdlEvent) + { + Application::RemoveUserEvent(m_pLevelHdlEvent); + m_pLevelHdlEvent = nullptr; + } +} + +void SvxNumOptionsTabPage::SetMetric(FieldUnit eMetric) +{ + if(eMetric == FieldUnit::MM) + { + m_xWidthMF->set_digits(1); + m_xHeightMF->set_digits(1); + } + m_xWidthMF->set_unit(eMetric); + m_xHeightMF->set_unit(eMetric); +} + +std::unique_ptr<SfxTabPage> SvxNumOptionsTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<SvxNumOptionsTabPage>(pPage, pController, *rAttrSet); +}; + +void SvxNumOptionsTabPage::ActivatePage(const SfxItemSet& rSet) +{ + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + sal_uInt16 nTmpNumLvl = 1; + if(pExampleSet) + { + if(const SfxBoolItem* pPresetItem = pExampleSet->GetItemIfSet(SID_PARAM_NUM_PRESET, false)) + bPreset = pPresetItem->GetValue(); + if(const SfxUInt16Item* pLevelItem = pExampleSet->GetItemIfSet(SID_PARAM_CUR_NUM_LEVEL, false)) + nTmpNumLvl = pLevelItem->GetValue(); + } + if(const SvxNumBulletItem* pBulletItem = rSet.GetItemIfSet(nNumItemId, false)) + { + pSaveNum.reset( new SvxNumRule(pBulletItem->GetNumRule()) ); + } + + bModified = (!pActNum->Get( 0 ) || bPreset); + if(*pActNum == *pSaveNum && nActNumLvl == nTmpNumLvl) + return; + + nActNumLvl = nTmpNumLvl; + sal_uInt16 nMask = 1; + m_xLevelLB->unselect_all(); + if (nActNumLvl == SAL_MAX_UINT16) + m_xLevelLB->select(pActNum->GetLevelCount()); + if(nActNumLvl != SAL_MAX_UINT16) + { + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + m_xLevelLB->select(i); + nMask <<= 1 ; + } + } + *pActNum = *pSaveNum; + + InitControls(); +} + +DeactivateRC SvxNumOptionsTabPage::DeactivatePage(SfxItemSet * _pSet) +{ + if(_pSet) + FillItemSet(_pSet); + return DeactivateRC::LeavePage; +} + +bool SvxNumOptionsTabPage::FillItemSet( SfxItemSet* rSet ) +{ + rSet->Put(SfxUInt16Item(SID_PARAM_CUR_NUM_LEVEL, nActNumLvl)); + if(bModified && pActNum) + { + *pSaveNum = *pActNum; + rSet->Put(SvxNumBulletItem( *pSaveNum, nNumItemId )); + rSet->Put(SfxBoolItem(SID_PARAM_NUM_PRESET, false)); + } + return bModified; +}; + +void SvxNumOptionsTabPage::Reset( const SfxItemSet* rSet ) +{ + // in Draw the item exists as WhichId, in Writer only as SlotId + const SvxNumBulletItem* pBulletItem = + rSet->GetItemIfSet(SID_ATTR_NUMBERING_RULE, false); + if(!pBulletItem) + { + nNumItemId = rSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); + pBulletItem = rSet->GetItemIfSet(nNumItemId, false); + + if( !pBulletItem ) + { + pBulletItem = & rSet->Get( nNumItemId ); + } + } + DBG_ASSERT(pBulletItem, "no item found!"); + pSaveNum.reset( new SvxNumRule(pBulletItem->GetNumRule()) ); + + // insert levels + if (!m_xLevelLB->n_children()) + { + for(sal_uInt16 i = 1; i <= pSaveNum->GetLevelCount(); i++) + m_xLevelLB->append_text(OUString::number(i)); + if(pSaveNum->GetLevelCount() > 1) + { + OUString sEntry = "1 - " + OUString::number( pSaveNum->GetLevelCount() ); + m_xLevelLB->append_text(sEntry); + m_xLevelLB->select_text(sEntry); + } + else + m_xLevelLB->select(0); + } + else + m_xLevelLB->select(m_xLevelLB->n_children() - 1); + + sal_uInt16 nMask = 1; + m_xLevelLB->unselect_all(); + if (nActNumLvl == SAL_MAX_UINT16) + { + m_xLevelLB->select( pSaveNum->GetLevelCount() ); + } + else + { + for(sal_uInt16 i = 0; i < pSaveNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + m_xLevelLB->select( i ); + nMask <<= 1 ; + } + } + + if(!pActNum) + pActNum.reset( new SvxNumRule(*pSaveNum) ); + else if(*pSaveNum != *pActNum) + *pActNum = *pSaveNum; + m_aPreviewWIN.SetNumRule(pActNum.get()); + m_xSameLevelCB->set_active(pActNum->IsContinuousNumbering()); + + const SfxUInt16Item* pHtmlModeItem = + rSet->GetItemIfSet( SID_HTML_MODE, false ); + if (!pHtmlModeItem) + { + if (SfxObjectShell* pShell = SfxObjectShell::Current()) + pHtmlModeItem = pShell->GetItem( SID_HTML_MODE ); + } + if ( pHtmlModeItem ) + { + sal_uInt16 nHtmlMode = pHtmlModeItem->GetValue(); + bHTMLMode = 0 != (nHtmlMode&HTMLMODE_ON); + } + + bool bCharFmt = pActNum->IsFeatureSupported(SvxNumRuleFlags::CHAR_STYLE); + m_xCharFmtFT->set_visible(bCharFmt); + m_xCharFmtLB->set_visible(bCharFmt); + + bool bContinuous = pActNum->IsFeatureSupported(SvxNumRuleFlags::CONTINUOUS); + + bool bAllLevel = bContinuous && !bHTMLMode; + m_xAllLevelFT->set_visible(bAllLevel); + m_xAllLevelNF->set_visible(bAllLevel); + + m_xAllLevelsFrame->set_visible(bContinuous); + + // again misusage: in Draw there is numeration only until the bitmap + // without SVX_NUM_NUMBER_NONE + //remove types that are unsupported by Draw/Impress + if(!bContinuous) + { + sal_Int32 nFmtCount = m_xFmtLB->get_count(); + for(sal_Int32 i = nFmtCount; i; i--) + { + sal_uInt16 nEntryData = m_xFmtLB->get_id(i - 1).toUInt32(); + if(/*SVX_NUM_NUMBER_NONE == nEntryData ||*/ + (SVX_NUM_BITMAP|LINK_TOKEN) == nEntryData) + m_xFmtLB->remove(i - 1); + } + } + //one must be enabled + if(!pActNum->IsFeatureSupported(SvxNumRuleFlags::ENABLE_LINKED_BMP)) + { + auto nPos = m_xFmtLB->find_id(OUString::number(SVX_NUM_BITMAP|LINK_TOKEN)); + if (nPos != -1) + m_xFmtLB->remove(nPos); + } + else if(!pActNum->IsFeatureSupported(SvxNumRuleFlags::ENABLE_EMBEDDED_BMP)) + { + auto nPos = m_xFmtLB->find_id(OUString::number(SVX_NUM_BITMAP)); + if (nPos != -1) + m_xFmtLB->remove(nPos); + } + + // MegaHack: because of a not-fixable 'design mistake/error' in Impress + // delete all kinds of numeric enumerations + if(pActNum->IsFeatureSupported(SvxNumRuleFlags::NO_NUMBERS)) + { + sal_Int32 nFmtCount = m_xFmtLB->get_count(); + for(sal_Int32 i = nFmtCount; i; i--) + { + sal_uInt16 nEntryData = m_xFmtLB->get_id(i - 1).toUInt32(); + if( /*nEntryData >= SVX_NUM_CHARS_UPPER_LETTER &&*/ nEntryData <= SVX_NUM_NUMBER_NONE) + m_xFmtLB->remove(i - 1); + } + } + + InitControls(); + bModified = false; +} + +void SvxNumOptionsTabPage::InitControls() +{ + bool bShowBullet = true; + bool bShowBitmap = true; + bool bSameType = true; + bool bSameStart = true; + bool bSamePrefix = true; + bool bSameSuffix = true; + bool bAllLevel = true; + bool bSameCharFmt = true; + bool bSameVOrient = true; + bool bSameSize = true; + bool bSameBulColor = true; + bool bSameBulRelSize= true; + + const SvxNumberFormat* aNumFmtArr[SVX_MAX_NUM]; + OUString sFirstCharFmt; + sal_Int16 eFirstOrient = text::VertOrientation::NONE; + Size aFirstSize(0,0); + sal_uInt16 nMask = 1; + sal_uInt16 nLvl = SAL_MAX_UINT16; + sal_uInt16 nHighestLevel = 0; + + bool bBullColor = pActNum->IsFeatureSupported(SvxNumRuleFlags::BULLET_COLOR); + bool bBullRelSize = pActNum->IsFeatureSupported(SvxNumRuleFlags::BULLET_REL_SIZE); + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + aNumFmtArr[i] = &pActNum->GetLevel(i); + bShowBullet &= aNumFmtArr[i]->GetNumberingType() == SVX_NUM_CHAR_SPECIAL; + bShowBitmap &= (aNumFmtArr[i]->GetNumberingType()&(~LINK_TOKEN)) == SVX_NUM_BITMAP; + if(SAL_MAX_UINT16 == nLvl) + { + nLvl = i; + sFirstCharFmt = aNumFmtArr[i]->GetCharFormatName(); + eFirstOrient = aNumFmtArr[i]->GetVertOrient(); + if(bShowBitmap) + aFirstSize = aNumFmtArr[i]->GetGraphicSize(); + } + if( i > nLvl) + { + bSameType &= aNumFmtArr[i]->GetNumberingType() == aNumFmtArr[nLvl]->GetNumberingType(); + bSameStart = aNumFmtArr[i]->GetStart() == aNumFmtArr[nLvl]->GetStart(); + + bSamePrefix = aNumFmtArr[i]->GetPrefix() == aNumFmtArr[nLvl]->GetPrefix(); + bSameSuffix = aNumFmtArr[i]->GetSuffix() == aNumFmtArr[nLvl]->GetSuffix(); + bAllLevel &= aNumFmtArr[i]->GetIncludeUpperLevels() == aNumFmtArr[nLvl]->GetIncludeUpperLevels(); + bSameCharFmt &= sFirstCharFmt == aNumFmtArr[i]->GetCharFormatName(); + bSameVOrient &= eFirstOrient == aNumFmtArr[i]->GetVertOrient(); + if(bShowBitmap && bSameSize) + bSameSize &= aNumFmtArr[i]->GetGraphicSize() == aFirstSize; + bSameBulColor &= aNumFmtArr[i]->GetBulletColor() == aNumFmtArr[nLvl]->GetBulletColor(); + bSameBulRelSize &= aNumFmtArr[i]->GetBulletRelSize() == aNumFmtArr[nLvl]->GetBulletRelSize(); + } + nHighestLevel = i; + } + else + aNumFmtArr[i] = nullptr; + + nMask <<= 1 ; + } + SwitchNumberType(bShowBullet ? 1 : bShowBitmap ? 2 : 0); + + sal_uInt16 nNumberingType; + if (nLvl != SAL_MAX_UINT16) + nNumberingType = aNumFmtArr[nLvl]->GetNumberingType(); + else + { + nNumberingType = SVX_NUM_NUMBER_NONE; + bAllLevel = false; + bSameBulRelSize = false; + bSameBulColor = false; + bSameStart = false; + bSamePrefix = false; + bSameSuffix = false; + } + + CheckForStartValue_Impl(nNumberingType); + + if(bShowBitmap) + { + if(!bSameVOrient || eFirstOrient == text::VertOrientation::NONE) + m_xOrientLB->set_active(-1); + else + m_xOrientLB->set_active( + sal::static_int_cast< sal_Int32 >(eFirstOrient - 1)); + // no text::VertOrientation::NONE + + if(bSameSize) + { + SetMetricValue(*m_xHeightMF, aFirstSize.Height(), eCoreUnit); + SetMetricValue(*m_xWidthMF, aFirstSize.Width(), eCoreUnit); + } + else + { + m_xHeightMF->set_text(""); + m_xWidthMF->set_text(""); + } + } + + if(bSameType) + { + sal_uInt16 nLBData = nNumberingType; + m_xFmtLB->set_active_id(OUString::number(nLBData)); + } + else + m_xFmtLB->set_active(-1); + + m_xAllLevelNF->set_sensitive(nHighestLevel > 0 && !m_xSameLevelCB->get_active()); + m_xAllLevelNF->set_max(nHighestLevel + 1); + if(bAllLevel) + { + m_xAllLevelNF->set_value(aNumFmtArr[nLvl]->GetIncludeUpperLevels()); + } + else + { + m_xAllLevelNF->set_text(""); + } + + if(bBullRelSize) + { + if(bSameBulRelSize) + m_xBulRelSizeMF->set_value(aNumFmtArr[nLvl]->GetBulletRelSize(), FieldUnit::PERCENT); + else + m_xBulRelSizeMF->set_text(""); + } + if(bBullColor) + { + if(bSameBulColor) + m_xBulColLB->SelectEntry(aNumFmtArr[nLvl]->GetBulletColor()); + else + m_xBulColLB->SetNoSelection(); + } + switch(nBullet) + { + case SHOW_NUMBERING: + if(bSameStart) + { + m_xStartED->set_value(aNumFmtArr[nLvl]->GetStart()); + } + else + m_xStartED->set_text(""); + break; + case SHOW_BULLET: + break; + case SHOW_BITMAP: + break; + } + + if(bSamePrefix) + m_xPrefixED->set_text(aNumFmtArr[nLvl]->GetPrefix()); + else + m_xPrefixED->set_text(""); + if(bSameSuffix) + m_xSuffixED->set_text(aNumFmtArr[nLvl]->GetSuffix()); + else + m_xSuffixED->set_text(""); + + if(bSameCharFmt) + { + if (!sFirstCharFmt.isEmpty()) + m_xCharFmtLB->set_active_text(sFirstCharFmt); + else + m_xCharFmtLB->set_active(0); + } + else + m_xCharFmtLB->set_active(-1); + + m_aPreviewWIN.SetLevel(nActNumLvl); + m_aPreviewWIN.Invalidate(); +} + +// 0 - Number; 1 - Bullet; 2 - Bitmap +void SvxNumOptionsTabPage::SwitchNumberType( sal_uInt8 nType ) +{ + if(nBullet == nType) + return; + nBullet = nType; + bool bBullet = (nType == SHOW_BULLET); + bool bBitmap = (nType == SHOW_BITMAP); + bool bEnableBitmap = (nType == SHOW_BITMAP); + bool bNumeric = !(bBitmap||bBullet); + m_xSeparatorFT->set_visible(bNumeric); + m_xPrefixFT->set_visible(bNumeric); + m_xPrefixED->set_visible(bNumeric); + m_xSuffixFT->set_visible(bNumeric); + m_xSuffixED->set_visible(bNumeric); + + bool bCharFmt = pActNum->IsFeatureSupported(SvxNumRuleFlags::CHAR_STYLE); + m_xCharFmtFT->set_visible(!bBitmap && bCharFmt); + m_xCharFmtLB->set_visible(!bBitmap && bCharFmt); + + // this is rather misusage, as there is no own flag + // for complete numeration + bool bAllLevelFeature = pActNum->IsFeatureSupported(SvxNumRuleFlags::CONTINUOUS); + bool bAllLevel = bNumeric && bAllLevelFeature && !bHTMLMode; + m_xAllLevelFT->set_visible(bAllLevel); + m_xAllLevelNF->set_visible(bAllLevel); + + m_xStartFT->set_visible(!(bBullet||bBitmap)); + m_xStartED->set_visible(!(bBullet||bBitmap)); + + m_xBulletFT->set_visible(bBullet); + m_xBulletPB->set_visible(bBullet); + bool bBullColor = pActNum->IsFeatureSupported(SvxNumRuleFlags::BULLET_COLOR); + m_xBulColorFT->set_visible(!bBitmap && bBullColor); + m_xBulColLB->set_visible(!bBitmap && bBullColor); + bool bBullResSize = pActNum->IsFeatureSupported(SvxNumRuleFlags::BULLET_REL_SIZE); + m_xBulRelSizeFT->set_visible(!bBitmap && bBullResSize); + m_xBulRelSizeMF->set_visible(!bBitmap && bBullResSize); + + m_xBitmapFT->set_visible(bBitmap); + m_xBitmapMB->set_visible(bBitmap); + + m_xWidthFT->set_visible(bBitmap); + m_xWidthMF->set_visible(bBitmap); + m_xHeightFT->set_visible(bBitmap); + m_xHeightMF->set_visible(bBitmap); + m_xRatioCB->set_visible(bBitmap); + + m_xOrientFT->set_visible(bBitmap && bAllLevelFeature); + m_xOrientLB->set_visible(bBitmap && bAllLevelFeature); + + m_xWidthFT->set_sensitive(bEnableBitmap); + m_xWidthMF->set_sensitive(bEnableBitmap); + m_xHeightFT->set_sensitive(bEnableBitmap); + m_xHeightMF->set_sensitive(bEnableBitmap); + m_xRatioCB->set_sensitive(bEnableBitmap); + m_xOrientFT->set_sensitive(bEnableBitmap); + m_xOrientLB->set_sensitive(bEnableBitmap); +} + +IMPL_LINK_NOARG(SvxNumOptionsTabPage, LevelHdl_Impl, weld::TreeView&, void) +{ + if (m_pLevelHdlEvent) + return; + // tdf#127112 (borrowing tdf#127120 solution) multiselection may be implemented by deselect follow by select so + // fire off the handler to happen on next event loop and only process the + // final state + m_pLevelHdlEvent = Application::PostUserEvent(LINK(this, SvxNumOptionsTabPage, LevelHdl)); +} + +IMPL_LINK_NOARG(SvxNumOptionsTabPage, LevelHdl, void*, void) +{ + m_pLevelHdlEvent = nullptr; + + sal_uInt16 nSaveNumLvl = nActNumLvl; + nActNumLvl = 0; + std::vector<int> aSelectedRows = m_xLevelLB->get_selected_rows(); + if (std::find(aSelectedRows.begin(), aSelectedRows.end(), pActNum->GetLevelCount()) != aSelectedRows.end() && + (aSelectedRows.size() == 1 || nSaveNumLvl != 0xffff)) + { + nActNumLvl = 0xFFFF; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++ ) + m_xLevelLB->unselect(i); + } + else if (!aSelectedRows.empty()) + { + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++ ) + { + if (std::find(aSelectedRows.begin(), aSelectedRows.end(), i) != aSelectedRows.end()) + nActNumLvl |= nMask; + nMask <<= 1; + } + m_xLevelLB->unselect(pActNum->GetLevelCount()); + } + else + { + nActNumLvl = nSaveNumLvl; + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++ ) + { + if(nActNumLvl & nMask) + { + m_xLevelLB->select(i); + break; + } + nMask <<=1; + } + } + InitControls(); +} + +IMPL_LINK_NOARG(SvxNumOptionsTabPage, PreviewInvalidateHdl_Impl, Timer *, void) +{ + m_aPreviewWIN.Invalidate(); +} + +IMPL_LINK(SvxNumOptionsTabPage, AllLevelHdl_Impl, weld::SpinButton&, rBox, void) +{ + sal_uInt16 nMask = 1; + for(sal_uInt16 e = 0; e < pActNum->GetLevelCount(); e++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(e)); + aNumFmt.SetIncludeUpperLevels(static_cast<sal_uInt8>(std::min(rBox.get_value(), sal_Int64(e + 1))) ); + // Set the same prefix/suffix to generate list format with changed IncludedUpperLevels + aNumFmt.SetListFormat(aNumFmt.GetPrefix(), aNumFmt.GetSuffix(), e); + pActNum->SetLevel(e, aNumFmt); + } + nMask <<= 1; + } + SetModified(); +} + +IMPL_LINK(SvxNumOptionsTabPage, NumberTypeSelectHdl_Impl, weld::ComboBox&, rBox, void) +{ + OUString sSelectStyle; + bool bShowOrient = false; + bool bBmp = false; + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + // PAGEDESC does not exist + SvxNumType nNumType = static_cast<SvxNumType>(rBox.get_active_id().toUInt32()); + aNumFmt.SetNumberingType(nNumType); + sal_uInt16 nNumberingType = aNumFmt.GetNumberingType(); + if(SVX_NUM_BITMAP == (nNumberingType&(~LINK_TOKEN))) + { + bBmp |= nullptr != aNumFmt.GetBrush(); + aNumFmt.SetIncludeUpperLevels( 1 ); + aNumFmt.SetListFormat("", "", i); + if(!bBmp) + aNumFmt.SetGraphic(""); + pActNum->SetLevel(i, aNumFmt); + SwitchNumberType(SHOW_BITMAP); + bShowOrient = true; + } + else if( SVX_NUM_CHAR_SPECIAL == nNumberingType ) + { + aNumFmt.SetIncludeUpperLevels( 1 ); + aNumFmt.SetListFormat("", "", i); + if( !aNumFmt.GetBulletFont() ) + aNumFmt.SetBulletFont(&aActBulletFont); + if( !aNumFmt.GetBulletChar() ) + aNumFmt.SetBulletChar( SVX_DEF_BULLET ); + pActNum->SetLevel(i, aNumFmt); + SwitchNumberType(SHOW_BULLET); + // allocation of the drawing pattern is automatic + if(bAutomaticCharStyles) + { + sSelectStyle = m_sBulletCharFormatName; + } + } + else + { + aNumFmt.SetListFormat(m_xPrefixED->get_text(), m_xSuffixED->get_text(), i); + + SwitchNumberType(SHOW_NUMBERING); + pActNum->SetLevel(i, aNumFmt); + CheckForStartValue_Impl(nNumberingType); + + // allocation of the drawing pattern is automatic + if(bAutomaticCharStyles) + { + sSelectStyle = m_sNumCharFmtName; + } + } + } + nMask <<= 1; + } + bool bAllLevelFeature = pActNum->IsFeatureSupported(SvxNumRuleFlags::CONTINUOUS); + if(bShowOrient && bAllLevelFeature) + { + m_xOrientFT->show(); + m_xOrientLB->show(); + } + else + { + m_xOrientFT->hide(); + m_xOrientLB->hide(); + } + SetModified(); + if(!sSelectStyle.isEmpty()) + { + m_xCharFmtLB->set_active_text(sSelectStyle); + CharFmtHdl_Impl(*m_xCharFmtLB); + bAutomaticCharStyles = true; + } +} + +void SvxNumOptionsTabPage::CheckForStartValue_Impl(sal_uInt16 nNumberingType) +{ + bool bIsNull = m_xStartED->get_value() == 0; + bool bNoZeroAllowed = nNumberingType < SVX_NUM_ARABIC || + SVX_NUM_CHARS_UPPER_LETTER_N == nNumberingType || + SVX_NUM_CHARS_LOWER_LETTER_N == nNumberingType; + m_xStartED->set_min(bNoZeroAllowed ? 1 : 0); + if (bIsNull && bNoZeroAllowed) + EditModifyHdl_Impl(*m_xStartED); +} + +IMPL_LINK(SvxNumOptionsTabPage, OrientHdl_Impl, weld::ComboBox&, rBox, void) +{ + sal_Int32 nPos = rBox.get_active(); + nPos ++; // no VERT_NONE + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + if(SVX_NUM_BITMAP == (aNumFmt.GetNumberingType()&(~LINK_TOKEN))) + { + const SvxBrushItem* pBrushItem = aNumFmt.GetBrush(); + const Size& rSize = aNumFmt.GetGraphicSize(); + sal_Int16 eOrient = static_cast<sal_Int16>(nPos); + aNumFmt.SetGraphicBrush( pBrushItem, &rSize, &eOrient ); + pActNum->SetLevel(i, aNumFmt); + } + } + nMask <<= 1; + } + SetModified(false); +} + +IMPL_LINK(SvxNumOptionsTabPage, SameLevelHdl_Impl, weld::Toggleable&, rBox, void) +{ + bool bSet = rBox.get_active(); + pActNum->SetContinuousNumbering(bSet); + bool bRepaint = false; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + if(aNumFmt.GetNumberingType() != SVX_NUM_NUMBER_NONE) + { + bRepaint = true; + break; + } + } + SetModified(bRepaint); + InitControls(); +} + +IMPL_LINK(SvxNumOptionsTabPage, BulColorHdl_Impl, ColorListBox&, rColorBox, void) +{ + Color nSetColor = rColorBox.GetSelectEntryColor(); + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + aNumFmt.SetBulletColor(nSetColor); + pActNum->SetLevel(i, aNumFmt); + } + nMask <<= 1; + } + SetModified(); +} + +IMPL_LINK(SvxNumOptionsTabPage, BulRelSizeHdl_Impl, weld::MetricSpinButton&, rField, void) +{ + sal_uInt16 nRelSize = rField.get_value(FieldUnit::PERCENT); + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + aNumFmt.SetBulletRelSize(nRelSize); + pActNum->SetLevel(i, aNumFmt); + } + nMask <<= 1; + } + SetModified(); +} + +IMPL_LINK(SvxNumOptionsTabPage, GraphicHdl_Impl, const OString&, rIdent, void) +{ + OUString aGrfName; + Size aSize; + bool bSucc(false); + SvxOpenGraphicDialog aGrfDlg(CuiResId(RID_CUISTR_EDIT_GRAPHIC), GetFrameWeld()); + + OString sNumber; + if (rIdent.startsWith("gallery", &sNumber)) + { + auto idx = sNumber.toUInt32(); + if (idx < aGrfNames.size()) + { + aGrfName = aGrfNames[idx]; + Graphic aGraphic; + if(GalleryExplorer::GetGraphicObj( GALLERY_THEME_BULLETS, idx, &aGraphic)) + { + aSize = SvxNumberFormat::GetGraphicSizeMM100(&aGraphic); + bSucc = true; + } + } + } + else if (rIdent == "fromfile") + { + aGrfDlg.EnableLink( false ); + aGrfDlg.AsLink( false ); + if ( !aGrfDlg.Execute() ) + { + // memorize selected filter + aGrfName = aGrfDlg.GetPath(); + + Graphic aGraphic; + if( !aGrfDlg.GetGraphic(aGraphic) ) + { + aSize = SvxNumberFormat::GetGraphicSizeMM100(&aGraphic); + bSucc = true; + } + } + } + if(!bSucc) + return; + + aSize = OutputDevice::LogicToLogic(aSize, MapMode(MapUnit::Map100thMM), MapMode(eCoreUnit)); + + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + aNumFmt.SetCharFormatName(m_sNumCharFmtName); + aNumFmt.SetGraphic(aGrfName); + + // set size for a later comparison + const SvxBrushItem* pBrushItem = aNumFmt.GetBrush(); + // initiate asynchronous loading + sal_Int16 eOrient = aNumFmt.GetVertOrient(); + aNumFmt.SetGraphicBrush( pBrushItem, &aSize, &eOrient ); + aInitSize[i] = aNumFmt.GetGraphicSize(); + + pActNum->SetLevel(i, aNumFmt); + } + nMask <<= 1; + } + m_xRatioCB->set_sensitive(true); + m_xWidthFT->set_sensitive(true); + m_xHeightFT->set_sensitive(true); + m_xWidthMF->set_sensitive(true); + m_xHeightMF->set_sensitive(true); + SetMetricValue(*m_xWidthMF, aSize.Width(), eCoreUnit); + SetMetricValue(*m_xHeightMF, aSize.Height(), eCoreUnit); + m_xOrientFT->set_sensitive(true); + m_xOrientLB->set_sensitive(true); + SetModified(); + //needed due to asynchronous loading of graphics in the SvxBrushItem + aInvalidateTimer.Start(); +} + +IMPL_LINK_NOARG(SvxNumOptionsTabPage, PopupActivateHdl_Impl, weld::Toggleable&, void) +{ + if (m_xGalleryMenu) + return; + + m_xGalleryMenu = m_xBuilder->weld_menu("gallerysubmenu"); + weld::WaitObject aWait(GetFrameWeld()); + + if (!GalleryExplorer::FillObjList(GALLERY_THEME_BULLETS, aGrfNames)) + return; + + GalleryExplorer::BeginLocking(GALLERY_THEME_BULLETS); + + Graphic aGraphic; + OUString sGrfName; + ScopedVclPtrInstance< VirtualDevice > pVD; + size_t i = 0; + for (const auto & grfName : aGrfNames) + { + sGrfName = grfName; + OUString sItemId = "gallery" + OUString::number(i); + INetURLObject aObj(sGrfName); + if (aObj.GetProtocol() == INetProtocol::File) + { + // tdf#141334 - only show the last name of the filename without its extension + aObj.removeExtension(); + sGrfName = aObj.GetLastName(INetURLObject::DecodeMechanism::Unambiguous); + } + if(GalleryExplorer::GetGraphicObj( GALLERY_THEME_BULLETS, i, &aGraphic)) + { + BitmapEx aBitmap(aGraphic.GetBitmapEx()); + Size aSize(aBitmap.GetSizePixel()); + if(aSize.Width() > MAX_BMP_WIDTH || + aSize.Height() > MAX_BMP_HEIGHT) + { + bool bWidth = aSize.Width() > aSize.Height(); + double nScale = bWidth ? + double(MAX_BMP_WIDTH) / static_cast<double>(aSize.Width()): + double(MAX_BMP_HEIGHT) / static_cast<double>(aSize.Height()); + aBitmap.Scale(nScale, nScale); + } + pVD->SetOutputSizePixel(aBitmap.GetSizePixel(), false); + pVD->DrawBitmapEx(Point(), aBitmap); + m_xGalleryMenu->append(sItemId, sGrfName, *pVD); + } + else + { + m_xGalleryMenu->append(sItemId, sGrfName); + } + ++i; + } + GalleryExplorer::EndLocking(GALLERY_THEME_BULLETS); +} + +IMPL_LINK_NOARG(SvxNumOptionsTabPage, BulletHdl_Impl, weld::Button&, void) +{ + SvxCharacterMap aMap(GetFrameWeld(), nullptr, nullptr); + + sal_uInt16 nMask = 1; + std::optional<vcl::Font> pFmtFont; + bool bSameBullet = true; + sal_UCS4 cBullet = 0; + bool bFirst = true; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + const SvxNumberFormat& rCurFmt = pActNum->GetLevel(i); + if(bFirst) + { + cBullet = rCurFmt.GetBulletChar(); + } + else if(rCurFmt.GetBulletChar() != cBullet ) + { + bSameBullet = false; + break; + } + if(!pFmtFont) + pFmtFont = rCurFmt.GetBulletFont(); + bFirst = false; + } + nMask <<= 1; + + } + + if (pFmtFont) + aMap.SetCharFont(*pFmtFont); + else + aMap.SetCharFont(aActBulletFont); + if (bSameBullet) + aMap.SetChar(cBullet); + if (aMap.run() != RET_OK) + return; + + // change Font Numrules + aActBulletFont = aMap.GetCharFont(); + + sal_uInt16 _nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & _nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + aNumFmt.SetBulletFont(&aActBulletFont); + aNumFmt.SetBulletChar(aMap.GetChar()); + pActNum->SetLevel(i, aNumFmt); + } + _nMask <<= 1; + } + + SetModified(); +} + +IMPL_LINK( SvxNumOptionsTabPage, SizeHdl_Impl, weld::MetricSpinButton&, rField, void) +{ + bool bWidth = &rField == m_xWidthMF.get(); + bLastWidthModified = bWidth; + bool bRatio = m_xRatioCB->get_active(); + tools::Long nWidthVal = static_cast<tools::Long>(m_xWidthMF->denormalize(m_xWidthMF->get_value(FieldUnit::MM_100TH))); + tools::Long nHeightVal = static_cast<tools::Long>(m_xHeightMF->denormalize(m_xHeightMF->get_value(FieldUnit::MM_100TH))); + nWidthVal = OutputDevice::LogicToLogic( nWidthVal , + MapUnit::Map100thMM, eCoreUnit ); + nHeightVal = OutputDevice::LogicToLogic( nHeightVal, + MapUnit::Map100thMM, eCoreUnit); + double fSizeRatio; + + bool bRepaint = false; + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + if(SVX_NUM_BITMAP == (aNumFmt.GetNumberingType()&(~LINK_TOKEN))) + { + Size aSize(aNumFmt.GetGraphicSize() ); + Size aSaveSize(aSize); + + if (aInitSize[i].Height()) + fSizeRatio = static_cast<double>(aInitSize[i].Width()) / static_cast<double>(aInitSize[i].Height()); + else + fSizeRatio = double(1); + + if(bWidth) + { + tools::Long nDelta = nWidthVal - aInitSize[i].Width(); + aSize.setWidth( nWidthVal ); + if (bRatio) + { + aSize.setHeight( aInitSize[i].Height() + static_cast<tools::Long>(static_cast<double>(nDelta) / fSizeRatio) ); + m_xHeightMF->set_value(m_xHeightMF->normalize( + OutputDevice::LogicToLogic( aSize.Height(), eCoreUnit, MapUnit::Map100thMM )), + FieldUnit::MM_100TH); + } + } + else + { + tools::Long nDelta = nHeightVal - aInitSize[i].Height(); + aSize.setHeight( nHeightVal ); + if (bRatio) + { + aSize.setWidth( aInitSize[i].Width() + static_cast<tools::Long>(static_cast<double>(nDelta) * fSizeRatio) ); + m_xWidthMF->set_value(m_xWidthMF->normalize( + OutputDevice::LogicToLogic( aSize.Width(), eCoreUnit, MapUnit::Map100thMM )), + FieldUnit::MM_100TH); + } + } + const SvxBrushItem* pBrushItem = aNumFmt.GetBrush(); + sal_Int16 eOrient = aNumFmt.GetVertOrient(); + if(aSize != aSaveSize) + bRepaint = true; + aNumFmt.SetGraphicBrush( pBrushItem, &aSize, &eOrient ); + pActNum->SetLevel(i, aNumFmt); + } + } + nMask <<= 1; + } + SetModified(bRepaint); +} + +IMPL_LINK(SvxNumOptionsTabPage, RatioHdl_Impl, weld::Toggleable&, rBox, void) +{ + if (rBox.get_active()) + { + if (bLastWidthModified) + SizeHdl_Impl(*m_xWidthMF); + else + SizeHdl_Impl(*m_xHeightMF); + } +} + +IMPL_LINK_NOARG(SvxNumOptionsTabPage, CharFmtHdl_Impl, weld::ComboBox&, void) +{ + bAutomaticCharStyles = false; + sal_Int32 nEntryPos = m_xCharFmtLB->get_active(); + OUString sEntry = m_xCharFmtLB->get_active_text(); + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + if( 0 == nEntryPos ) + aNumFmt.SetCharFormatName(""); + else + { + if(SVX_NUM_BITMAP != (aNumFmt.GetNumberingType()&(~LINK_TOKEN))) + aNumFmt.SetCharFormatName(sEntry); + } + pActNum->SetLevel(i, aNumFmt); + } + nMask <<= 1; + } + SetModified(false); +}; + +IMPL_LINK(SvxNumOptionsTabPage, EditModifyHdl_Impl, weld::Entry&, rEdit, void) +{ + EditModifyHdl_Impl(&rEdit); +} + +IMPL_LINK(SvxNumOptionsTabPage, SpinModifyHdl_Impl, weld::SpinButton&, rSpinButton, void) +{ + EditModifyHdl_Impl(&rSpinButton); +} + +void SvxNumOptionsTabPage::EditModifyHdl_Impl(const weld::Entry* pEdit) +{ + bool bPrefixSuffix = (pEdit == m_xPrefixED.get())|| (pEdit == m_xSuffixED.get()); + bool bStart = pEdit == m_xStartED.get(); + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + if (bPrefixSuffix) + aNumFmt.SetListFormat(m_xPrefixED->get_text(), m_xSuffixED->get_text(), i); + else if(bStart) + aNumFmt.SetStart(m_xStartED->get_value()); + pActNum->SetLevel(i, aNumFmt); + } + nMask <<= 1; + } + SetModified(); +} + +static tools::Long lcl_DrawGraphic(VirtualDevice& rVDev, const SvxNumberFormat &rFmt, tools::Long nXStart, + tools::Long nYMiddle, tools::Long nDivision) +{ + const SvxBrushItem* pBrushItem = rFmt.GetBrush(); + tools::Long nRet = 0; + if(pBrushItem) + { + const Graphic* pGrf = pBrushItem->GetGraphic(); + if(pGrf) + { + Size aGSize( rFmt.GetGraphicSize() ); + aGSize.setWidth( aGSize.Width() / nDivision ); + nRet = aGSize.Width(); + aGSize.setHeight( aGSize.Height() / nDivision ); + pGrf->Draw(rVDev, Point(nXStart,nYMiddle - ( aGSize.Height() / 2) ), + rVDev.PixelToLogic( aGSize ) ); + } + } + return nRet; + +} + +static tools::Long lcl_DrawBullet(VirtualDevice* pVDev, + const SvxNumberFormat& rFmt, tools::Long nXStart, + tools::Long nYStart, const Size& rSize) +{ + vcl::Font aTmpFont(pVDev->GetFont()); + + // via Uno it's possible that no font has been set! + vcl::Font aFont(rFmt.GetBulletFont() ? *rFmt.GetBulletFont() : aTmpFont); + Size aTmpSize(rSize); + aTmpSize.setWidth( aTmpSize.Width() * ( rFmt.GetBulletRelSize()) ); + aTmpSize.setWidth( aTmpSize.Width() / 100 ) ; + aTmpSize.setHeight( aTmpSize.Height() * ( rFmt.GetBulletRelSize()) ); + aTmpSize.setHeight( aTmpSize.Height() / 100 ) ; + // in case of a height of zero it is drawn in original height + if(!aTmpSize.Height()) + aTmpSize.setHeight( 1 ); + aFont.SetFontSize(aTmpSize); + aFont.SetTransparent(true); + Color aBulletColor = rFmt.GetBulletColor(); + if(aBulletColor == COL_AUTO) + aBulletColor = pVDev->GetFillColor().IsDark() ? COL_WHITE : COL_BLACK; + else if(aBulletColor == pVDev->GetFillColor()) + aBulletColor.Invert(); + aFont.SetColor(aBulletColor); + pVDev->SetFont( aFont ); + sal_UCS4 cChar = rFmt.GetBulletChar(); + OUString aText(&cChar, 1); + tools::Long nY = nYStart; + nY -= ((aTmpSize.Height() - rSize.Height())/ 2); + pVDev->DrawText( Point(nXStart, nY), aText ); + tools::Long nRet = pVDev->GetTextWidth(aText); + + pVDev->SetFont(aTmpFont); + return nRet; +} + +SvxNumberingPreview::SvxNumberingPreview() + : pActNum(nullptr) + , bPosition(false) + , nActLevel(SAL_MAX_UINT16) +{ +} + +// paint preview of numeration +void SvxNumberingPreview::Paint(vcl::RenderContext& rRenderContext, const ::tools::Rectangle& /*rRect*/) +{ + Size aSize(rRenderContext.PixelToLogic(GetOutputSizePixel())); + + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + const Color aBackColor = rStyleSettings.GetFieldColor(); + const Color aTextColor = rStyleSettings.GetFieldTextColor(); + + ScopedVclPtrInstance<VirtualDevice> pVDev(rRenderContext); + pVDev->EnableRTL(rRenderContext.IsRTLEnabled()); + pVDev->SetMapMode(rRenderContext.GetMapMode()); + pVDev->SetOutputSize(aSize); + + Color aLineColor(COL_LIGHTGRAY); + if (aLineColor == aBackColor) + aLineColor.Invert(); + pVDev->SetLineColor(aLineColor); + pVDev->SetFillColor(aBackColor); + + if (pActNum) + { + tools::Long nWidthRelation = 30; // chapter dialog + + // height per level + tools::Long nXStep = aSize.Width() / (pActNum->GetLevelCount() > 1 ? 3 * pActNum->GetLevelCount() : 3); + if (pActNum->GetLevelCount() < 10) + nXStep /= 2; + tools::Long nYStart = 4; + // the whole height mustn't be used for a single level + tools::Long nYStep = (aSize.Height() - 6)/ (pActNum->GetLevelCount() > 1 ? pActNum->GetLevelCount() : 5); + + aStdFont = OutputDevice::GetDefaultFont(DefaultFontType::UI_SANS, MsLangId::getConfiguredSystemLanguage(), GetDefaultFontFlags::OnlyOne); + aStdFont.SetColor(aTextColor); + aStdFont.SetFillColor(aBackColor); + + tools::Long nFontHeight = nYStep * 6 / 10; + if (bPosition) + nFontHeight = nYStep * 15 / 10; + aStdFont.SetFontSize(Size( 0, nFontHeight )); + + SvxNodeNum aNum; + sal_uInt16 nPreNum = pActNum->GetLevel(0).GetStart(); + + if (bPosition) + { + tools::Long nLineHeight = nFontHeight * 8 / 7; + sal_uInt8 nStart = 0; + while (!(nActLevel & (1<<nStart))) + { + nStart++; + } + if (nStart) + nStart--; + sal_uInt8 nEnd = std::min(sal_uInt8(nStart + 3), sal_uInt8(pActNum->GetLevelCount())); + for (sal_uInt8 nLevel = nStart; nLevel < nEnd; ++nLevel) + { + const SvxNumberFormat &rFmt = pActNum->GetLevel(nLevel); + aNum.GetLevelVal()[nLevel] = rFmt.GetStart(); + + tools::Long nXStart( 0 ); + short nTextOffset( 0 ); + tools::Long nNumberXPos( 0 ); + if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION) + { + nXStart = rFmt.GetAbsLSpace() / nWidthRelation; + nTextOffset = rFmt.GetCharTextDistance() / nWidthRelation; + nNumberXPos = nXStart; + tools::Long nFirstLineOffset = (-rFmt.GetFirstLineOffset()) / nWidthRelation; + + if (nFirstLineOffset <= nNumberXPos) + nNumberXPos = nNumberXPos - nFirstLineOffset; + else + nNumberXPos = 0; + // in draw this is valid + if (nTextOffset < 0) + nNumberXPos = nNumberXPos + nTextOffset; + } + else if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT) + { + const tools::Long nTmpNumberXPos((rFmt.GetIndentAt() + rFmt.GetFirstLineIndent() ) / nWidthRelation); + if (nTmpNumberXPos < 0) + { + nNumberXPos = 0; + } + else + { + nNumberXPos = nTmpNumberXPos; + } + } + + tools::Long nBulletWidth = 0; + if (SVX_NUM_BITMAP == (rFmt.GetNumberingType() &(~LINK_TOKEN))) + { + tools::Long nYMiddle = nYStart + ( nFontHeight / 2 ); + nBulletWidth = rFmt.IsShowSymbol() ? lcl_DrawGraphic(*pVDev, rFmt, nNumberXPos, nYMiddle, nWidthRelation) : 0; + } + else if (SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType()) + { + nBulletWidth = rFmt.IsShowSymbol() ? lcl_DrawBullet(pVDev.get(), rFmt, nNumberXPos, nYStart, aStdFont.GetFontSize()) : 0; + } + else + { + pVDev->SetFont(aStdFont); + aNum.SetLevel(nLevel); + if (pActNum->IsContinuousNumbering()) + aNum.GetLevelVal()[nLevel] = nPreNum; + OUString aText(pActNum->MakeNumString( aNum )); + vcl::Font aSaveFont = pVDev->GetFont(); + vcl::Font aColorFont(aSaveFont); + Color aTmpBulletColor = rFmt.GetBulletColor(); + if (aTmpBulletColor == COL_AUTO) + aTmpBulletColor = aBackColor.IsDark() ? COL_WHITE : COL_BLACK; + else if (aTmpBulletColor == aBackColor) + aTmpBulletColor.Invert(); + aColorFont.SetColor(aTmpBulletColor); + pVDev->SetFont(aColorFont); + pVDev->DrawText(Point(nNumberXPos, nYStart), aText); + pVDev->SetFont(aSaveFont); + nBulletWidth = pVDev->GetTextWidth(aText); + nPreNum++; + } + if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT && + rFmt.GetLabelFollowedBy() == SvxNumberFormat::SPACE ) + { + pVDev->SetFont(aStdFont); + OUString aText(' '); + pVDev->DrawText( Point(nNumberXPos, nYStart), aText ); + nBulletWidth = nBulletWidth + pVDev->GetTextWidth(aText); + } + + tools::Long nTextXPos( 0 ); + if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION) + { + nTextXPos = nXStart; + if (nTextOffset < 0) + nTextXPos = nTextXPos + nTextOffset; + if (nNumberXPos + nBulletWidth + nTextOffset > nTextXPos) + nTextXPos = nNumberXPos + nBulletWidth + nTextOffset; + } + else if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT) + { + switch (rFmt.GetLabelFollowedBy()) + { + case SvxNumberFormat::LISTTAB: + { + nTextXPos = rFmt.GetListtabPos() / nWidthRelation; + if (nTextXPos < nNumberXPos + nBulletWidth) + { + nTextXPos = nNumberXPos + nBulletWidth; + } + } + break; + case SvxNumberFormat::SPACE: + case SvxNumberFormat::NOTHING: + case SvxNumberFormat::NEWLINE: + { + nTextXPos = nNumberXPos + nBulletWidth; + } + break; + } + + nXStart = rFmt.GetIndentAt() / nWidthRelation; + } + + ::tools::Rectangle aRect1(Point(nTextXPos, nYStart + nFontHeight / 2), Size(aSize.Width() / 2, 2)); + pVDev->SetFillColor(aBackColor); + pVDev->DrawRect(aRect1); + + ::tools::Rectangle aRect2(Point(nXStart, nYStart + nLineHeight + nFontHeight / 2 ), Size(aSize.Width() / 2, 2)); + pVDev->DrawRect(aRect2); + nYStart += 2 * nLineHeight; + } + } + else + { + //#i5153# painting gray or black rectangles as 'normal' numbering text + tools::Long nWidth = pVDev->GetTextWidth("Preview"); + tools::Long nTextHeight = pVDev->GetTextHeight(); + tools::Long nRectHeight = nTextHeight * 2 / 3; + tools::Long nTopOffset = nTextHeight - nRectHeight; + Color aBlackColor(COL_BLACK); + if (aBlackColor == aBackColor) + aBlackColor.Invert(); + + for (sal_uInt16 nLevel = 0; nLevel < pActNum->GetLevelCount(); ++nLevel, nYStart = nYStart + nYStep) + { + const SvxNumberFormat &rFmt = pActNum->GetLevel(nLevel); + aNum.GetLevelVal()[ nLevel ] = rFmt.GetStart(); + tools::Long nXStart( 0 ); + pVDev->SetFillColor( aBackColor ); + + if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION) + { + nXStart = rFmt.GetAbsLSpace() / nWidthRelation; + } + else if (rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT) + { + const tools::Long nTmpXStart((rFmt.GetIndentAt() + rFmt.GetFirstLineIndent() ) / nWidthRelation); + if (nTmpXStart < 0) + { + nXStart = 0; + } + else + { + nXStart = nTmpXStart; + } + } + nXStart /= 2; + nXStart += 2; + tools::Long nTextOffset = 2 * nXStep; + if (SVX_NUM_BITMAP == (rFmt.GetNumberingType()&(~LINK_TOKEN))) + { + if (rFmt.IsShowSymbol()) + { + tools::Long nYMiddle = nYStart + ( nFontHeight / 2 ); + nTextOffset = lcl_DrawGraphic(*pVDev, rFmt, nXStart, nYMiddle, nWidthRelation); + nTextOffset = nTextOffset + nXStep; + } + } + else if (SVX_NUM_CHAR_SPECIAL == rFmt.GetNumberingType()) + { + if (rFmt.IsShowSymbol()) + { + nTextOffset = lcl_DrawBullet(pVDev.get(), rFmt, nXStart, nYStart, aStdFont.GetFontSize()); + nTextOffset = nTextOffset + nXStep; + } + } + else + { + vcl::Font aFont(aStdFont); + Size aTmpSize(aStdFont.GetFontSize()); + if(pActNum->IsFeatureSupported(SvxNumRuleFlags::BULLET_REL_SIZE)) + { + aTmpSize.setWidth( aTmpSize.Width() * ( rFmt.GetBulletRelSize()) ); + aTmpSize.setWidth( aTmpSize.Width() / 100 ) ; + aTmpSize.setHeight( aTmpSize.Height() * ( rFmt.GetBulletRelSize()) ); + aTmpSize.setHeight( aTmpSize.Height() / 100 ) ; + } + if(!aTmpSize.Height()) + aTmpSize.setHeight( 1 ); + aFont.SetFontSize(aTmpSize); + Color aTmpBulletColor = rFmt.GetBulletColor(); + if (aTmpBulletColor == COL_AUTO) + aTmpBulletColor = aBackColor.IsDark() ? COL_WHITE : COL_BLACK; + else if (aTmpBulletColor == aBackColor) + aTmpBulletColor.Invert(); + aFont.SetColor(aTmpBulletColor); + pVDev->SetFont(aFont); + aNum.SetLevel( nLevel ); + if (pActNum->IsContinuousNumbering()) + aNum.GetLevelVal()[nLevel] = nPreNum; + OUString aText(pActNum->MakeNumString(aNum)); + tools::Long nY = nYStart; + nY -= (pVDev->GetTextHeight() - nTextHeight - pVDev->GetFontMetric().GetDescent()); + pVDev->DrawText(Point(nXStart, nY), aText); + nTextOffset = pVDev->GetTextWidth(aText); + nTextOffset = nTextOffset + nXStep; + nPreNum++; + pVDev->SetFont(aStdFont); + } + //#i5153# the selected rectangle(s) should be black + if (0 != (nActLevel & (1<<nLevel))) + { + pVDev->SetFillColor( aBlackColor ); + pVDev->SetLineColor( aBlackColor ); + } + else + { + //#i5153# unselected levels are gray + pVDev->SetFillColor( aLineColor ); + pVDev->SetLineColor( aLineColor ); + } + ::tools::Rectangle aRect1(Point(nXStart + nTextOffset, nYStart + nTopOffset), Size(nWidth, nRectHeight)); + pVDev->DrawRect(aRect1); + } + } + } + rRenderContext.DrawOutDev(Point(), aSize, Point(), aSize, *pVDev); +} + + +//See uiconfig/swriter/ui/outlinepositionpage.ui for effectively a duplicate +//dialog to this one, except with a different preview window impl. +//TODO, determine if SwNumPositionTabPage and SvxNumPositionTabPage can be +//merged +SvxNumPositionTabPage::SvxNumPositionTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/numberingpositionpage.ui", "NumberingPositionPage", &rSet) + , m_pLevelHdlEvent(nullptr) + , nActNumLvl(1) + , nNumItemId(SID_ATTR_NUMBERING_RULE) + , bModified(false) + , bPreset(false) + , bInInintControl(false) + , bLabelAlignmentPosAndSpaceModeActive(false) + , m_xLevelLB(m_xBuilder->weld_tree_view("levellb")) + , m_xDistBorderFT(m_xBuilder->weld_label("indent")) + , m_xDistBorderMF(m_xBuilder->weld_metric_spin_button("indentmf", FieldUnit::CM)) + , m_xRelativeCB(m_xBuilder->weld_check_button("relative")) + , m_xIndentFT(m_xBuilder->weld_label("numberingwidth")) + , m_xIndentMF(m_xBuilder->weld_metric_spin_button("numberingwidthmf", FieldUnit::CM)) + , m_xDistNumFT(m_xBuilder->weld_label("numdist")) + , m_xDistNumMF(m_xBuilder->weld_metric_spin_button("numdistmf", FieldUnit::CM)) + , m_xAlignFT(m_xBuilder->weld_label("numalign")) + , m_xAlignLB(m_xBuilder->weld_combo_box("numalignlb")) + , m_xLabelFollowedByFT(m_xBuilder->weld_label("numfollowedby")) + , m_xLabelFollowedByLB(m_xBuilder->weld_combo_box("numfollowedbylb")) + , m_xListtabFT(m_xBuilder->weld_label("at")) + , m_xListtabMF(m_xBuilder->weld_metric_spin_button("atmf", FieldUnit::CM)) + , m_xAlign2FT(m_xBuilder->weld_label("num2align")) + , m_xAlign2LB(m_xBuilder->weld_combo_box("num2alignlb")) + , m_xAlignedAtFT(m_xBuilder->weld_label("alignedat")) + , m_xAlignedAtMF(m_xBuilder->weld_metric_spin_button("alignedatmf", FieldUnit::CM)) + , m_xIndentAtFT(m_xBuilder->weld_label("indentat")) + , m_xIndentAtMF(m_xBuilder->weld_metric_spin_button("indentatmf", FieldUnit::CM)) + , m_xStandardPB(m_xBuilder->weld_button("standard")) + , m_xPreviewWIN(new weld::CustomWeld(*m_xBuilder, "preview", m_aPreviewWIN)) +{ + SetExchangeSupport(); + + // set metric + FieldUnit eFUnit = GetModuleFieldUnit(rSet); + + SetFieldUnit( *m_xDistBorderMF, eFUnit ); + SetFieldUnit( *m_xIndentMF, eFUnit ); + SetFieldUnit( *m_xDistNumMF, eFUnit ); + + m_xAlignedAtMF->set_range(0, SAL_MAX_INT32, FieldUnit::NONE); + m_xListtabMF->set_range(0, SAL_MAX_INT32, FieldUnit::NONE); + m_xIndentAtMF->set_range(0, SAL_MAX_INT32, FieldUnit::NONE); + + m_xRelativeCB->set_active(true); + m_xAlignLB->connect_changed(LINK(this, SvxNumPositionTabPage, EditModifyHdl_Impl)); + m_xAlign2LB->connect_changed(LINK(this, SvxNumPositionTabPage, EditModifyHdl_Impl)); + for ( sal_Int32 i = 0; i < m_xAlignLB->get_count(); ++i ) + { + m_xAlign2LB->append_text(m_xAlignLB->get_text(i)); + } + + Link<weld::MetricSpinButton&,void> aLk3 = LINK(this, SvxNumPositionTabPage, DistanceHdl_Impl); + m_xDistBorderMF->connect_value_changed(aLk3); + m_xDistNumMF->connect_value_changed(aLk3); + m_xIndentMF->connect_value_changed(aLk3); + + m_xLabelFollowedByLB->connect_changed(LINK(this, SvxNumPositionTabPage, LabelFollowedByHdl_Impl)); + + m_xListtabMF->connect_value_changed(LINK(this, SvxNumPositionTabPage, ListtabPosHdl_Impl)); + m_xAlignedAtMF->connect_value_changed(LINK(this, SvxNumPositionTabPage, AlignAtHdl_Impl)); + m_xIndentAtMF->connect_value_changed(LINK(this, SvxNumPositionTabPage, IndentAtHdl_Impl)); + + m_xLevelLB->set_selection_mode(SelectionMode::Multiple); + m_xLevelLB->connect_changed(LINK(this, SvxNumPositionTabPage, LevelHdl_Impl)); + m_xRelativeCB->connect_toggled(LINK(this, SvxNumPositionTabPage, RelativeHdl_Impl)); + m_xStandardPB->connect_clicked(LINK(this, SvxNumPositionTabPage, StandardHdl_Impl)); + + m_xRelativeCB->set_active(bLastRelative); + m_aPreviewWIN.SetPositionMode(); + eCoreUnit = rSet.GetPool()->GetMetric(rSet.GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE)); +} + +SvxNumPositionTabPage::~SvxNumPositionTabPage() +{ + if (m_pLevelHdlEvent) + { + Application::RemoveUserEvent(m_pLevelHdlEvent); + m_pLevelHdlEvent = nullptr; + } + m_xPreviewWIN.reset(); +} + +/*-------------------------------------------------------*/ + +void SvxNumPositionTabPage::InitControls() +{ + bInInintControl = true; + const bool bRelative = !bLabelAlignmentPosAndSpaceModeActive && + m_xRelativeCB->get_sensitive() && m_xRelativeCB->get_active(); + const bool bSingleSelection = m_xLevelLB->count_selected_rows() == 1 && + SAL_MAX_UINT16 != nActNumLvl; + + m_xDistBorderMF->set_sensitive( !bLabelAlignmentPosAndSpaceModeActive && + ( bSingleSelection || bRelative ) ); + m_xDistBorderFT->set_sensitive( !bLabelAlignmentPosAndSpaceModeActive && + ( bSingleSelection || bRelative ) ); + + bool bSetDistEmpty = false; + bool bSameDistBorderNum = !bLabelAlignmentPosAndSpaceModeActive; + bool bSameDist = !bLabelAlignmentPosAndSpaceModeActive; + bool bSameIndent = !bLabelAlignmentPosAndSpaceModeActive; + bool bSameAdjust = true; + + bool bSameLabelFollowedBy = bLabelAlignmentPosAndSpaceModeActive; + bool bSameListtab = bLabelAlignmentPosAndSpaceModeActive; + bool bSameAlignAt = bLabelAlignmentPosAndSpaceModeActive; + bool bSameIndentAt = bLabelAlignmentPosAndSpaceModeActive; + + const SvxNumberFormat* aNumFmtArr[SVX_MAX_NUM]; + sal_uInt16 nMask = 1; + sal_uInt16 nLvl = SAL_MAX_UINT16; + tools::Long nFirstBorderTextRelative = -1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + aNumFmtArr[i] = &pActNum->GetLevel(i); + if(nActNumLvl & nMask) + { + if(SAL_MAX_UINT16 == nLvl) + nLvl = i; + + if( i > nLvl) + { + bSameAdjust &= aNumFmtArr[i]->GetNumAdjust() == aNumFmtArr[nLvl]->GetNumAdjust(); + if ( !bLabelAlignmentPosAndSpaceModeActive ) + { + if(bRelative) + { + if(nFirstBorderTextRelative == -1) + nFirstBorderTextRelative = + (aNumFmtArr[i]->GetAbsLSpace() + aNumFmtArr[i]->GetFirstLineOffset() - + aNumFmtArr[i - 1]->GetAbsLSpace() + aNumFmtArr[i - 1]->GetFirstLineOffset()); + else + bSameDistBorderNum &= nFirstBorderTextRelative == + (aNumFmtArr[i]->GetAbsLSpace() + aNumFmtArr[i]->GetFirstLineOffset() - + aNumFmtArr[i - 1]->GetAbsLSpace() + aNumFmtArr[i - 1]->GetFirstLineOffset()); + } + else + bSameDistBorderNum &= + aNumFmtArr[i]->GetAbsLSpace() - aNumFmtArr[i]->GetFirstLineOffset() == + aNumFmtArr[i - 1]->GetAbsLSpace() - aNumFmtArr[i - 1]->GetFirstLineOffset(); + + bSameDist &= aNumFmtArr[i]->GetCharTextDistance() == aNumFmtArr[nLvl]->GetCharTextDistance(); + bSameIndent &= aNumFmtArr[i]->GetFirstLineOffset() == aNumFmtArr[nLvl]->GetFirstLineOffset(); + } + else + { + bSameLabelFollowedBy &= + aNumFmtArr[i]->GetLabelFollowedBy() == aNumFmtArr[nLvl]->GetLabelFollowedBy(); + bSameListtab &= + aNumFmtArr[i]->GetListtabPos() == aNumFmtArr[nLvl]->GetListtabPos(); + bSameAlignAt &= + ( ( aNumFmtArr[i]->GetIndentAt() + aNumFmtArr[i]->GetFirstLineIndent() ) + == ( aNumFmtArr[nLvl]->GetIndentAt() + aNumFmtArr[nLvl]->GetFirstLineIndent() ) ); + bSameIndentAt &= + aNumFmtArr[i]->GetIndentAt() == aNumFmtArr[nLvl]->GetIndentAt(); + } + } + } + nMask <<= 1; + + } + if (SVX_MAX_NUM <= nLvl) + { + OSL_ENSURE(false, "cannot happen."); + return; + } + + if(bSameDistBorderNum) + { + tools::Long nDistBorderNum; + if(bRelative) + { + nDistBorderNum = static_cast<tools::Long>(aNumFmtArr[nLvl]->GetAbsLSpace())+ aNumFmtArr[nLvl]->GetFirstLineOffset(); + if(nLvl) + nDistBorderNum -= static_cast<tools::Long>(aNumFmtArr[nLvl - 1]->GetAbsLSpace())+ aNumFmtArr[nLvl - 1]->GetFirstLineOffset(); + } + else + { + nDistBorderNum = static_cast<tools::Long>(aNumFmtArr[nLvl]->GetAbsLSpace())+ aNumFmtArr[nLvl]->GetFirstLineOffset(); + } + SetMetricValue(*m_xDistBorderMF, nDistBorderNum, eCoreUnit); + } + else + bSetDistEmpty = true; + + if(bSameDist) + SetMetricValue(*m_xDistNumMF, aNumFmtArr[nLvl]->GetCharTextDistance(), eCoreUnit); + else + m_xDistNumMF->set_text(""); + if(bSameIndent) + SetMetricValue(*m_xIndentMF, - aNumFmtArr[nLvl]->GetFirstLineOffset(), eCoreUnit); + else + m_xIndentMF->set_text(""); + + if(bSameAdjust) + { + sal_Int32 nPos = 1; // centered + if(aNumFmtArr[nLvl]->GetNumAdjust() == SvxAdjust::Left) + nPos = 0; + else if(aNumFmtArr[nLvl]->GetNumAdjust() == SvxAdjust::Right) + nPos = 2; + m_xAlignLB->set_active(nPos); + m_xAlign2LB->set_active(nPos); + } + else + { + m_xAlignLB->set_active(-1); + m_xAlign2LB->set_active(-1); + } + + if ( bSameLabelFollowedBy ) + { + sal_Int32 nPos = 0; // LISTTAB + if ( aNumFmtArr[nLvl]->GetLabelFollowedBy() == SvxNumberFormat::SPACE ) + { + nPos = 1; + } + else if ( aNumFmtArr[nLvl]->GetLabelFollowedBy() == SvxNumberFormat::NOTHING ) + { + nPos = 2; + } + else if ( aNumFmtArr[nLvl]->GetLabelFollowedBy() == SvxNumberFormat::NEWLINE ) + { + nPos = 3; + } + m_xLabelFollowedByLB->set_active(nPos); + } + else + { + m_xLabelFollowedByLB->set_active(-1); + } + + if ( aNumFmtArr[nLvl]->GetLabelFollowedBy() == SvxNumberFormat::LISTTAB ) + { + m_xListtabFT->set_sensitive(true); + m_xListtabMF->set_sensitive(true); + if ( bSameListtab ) + { + SetMetricValue(*m_xListtabMF, aNumFmtArr[nLvl]->GetListtabPos(), eCoreUnit); + } + else + { + m_xListtabMF->set_text(""); + } + } + else + { + m_xListtabFT->set_sensitive(false); + m_xListtabMF->set_sensitive(false); + m_xListtabMF->set_text(""); + } + + if ( bSameAlignAt ) + { + SetMetricValue(*m_xAlignedAtMF, + aNumFmtArr[nLvl]->GetIndentAt() + aNumFmtArr[nLvl]->GetFirstLineIndent(), + eCoreUnit); + } + else + { + m_xAlignedAtMF->set_text(""); + } + + if ( bSameIndentAt ) + { + SetMetricValue(*m_xIndentAtMF, aNumFmtArr[nLvl]->GetIndentAt(), eCoreUnit); + } + else + { + m_xIndentAtMF->set_text(""); + } + + if ( bSetDistEmpty ) + m_xDistBorderMF->set_text(""); + + bInInintControl = false; +} + +void SvxNumPositionTabPage::ActivatePage(const SfxItemSet& rSet) +{ + sal_uInt16 nTmpNumLvl = 1; + const SfxItemSet* pExampleSet = GetDialogExampleSet(); + if(pExampleSet) + { + if(const SfxBoolItem* pPresetItem = pExampleSet->GetItemIfSet(SID_PARAM_NUM_PRESET, false)) + bPreset = pPresetItem->GetValue(); + if(const SfxUInt16Item* pLevelItem = pExampleSet->GetItemIfSet(SID_PARAM_CUR_NUM_LEVEL, false)) + nTmpNumLvl = pLevelItem->GetValue(); + } + if(const SvxNumBulletItem* pBulletItem = rSet.GetItemIfSet(nNumItemId, false)) + { + pSaveNum.reset( new SvxNumRule(pBulletItem->GetNumRule()) ); + } + bModified = (!pActNum->Get( 0 ) || bPreset); + if(*pSaveNum != *pActNum || + nActNumLvl != nTmpNumLvl ) + { + *pActNum = *pSaveNum; + nActNumLvl = nTmpNumLvl; + sal_uInt16 nMask = 1; + m_xLevelLB->unselect_all(); + if (nActNumLvl == SAL_MAX_UINT16) + m_xLevelLB->select(pActNum->GetLevelCount()); + if (nActNumLvl != SAL_MAX_UINT16) + for (sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if (nActNumLvl & nMask) + m_xLevelLB->select(i); + nMask <<= 1 ; + } + m_xRelativeCB->set_sensitive(nActNumLvl != 1); + + InitPosAndSpaceMode(); + ShowControlsDependingOnPosAndSpaceMode(); + + InitControls(); + } + m_aPreviewWIN.SetLevel(nActNumLvl); + m_aPreviewWIN.Invalidate(); +} + +DeactivateRC SvxNumPositionTabPage::DeactivatePage(SfxItemSet *_pSet) +{ + if(_pSet) + { + if (m_xDistBorderMF->get_sensitive()) + DistanceHdl_Impl(*m_xDistBorderMF); + DistanceHdl_Impl(*m_xIndentMF); + FillItemSet(_pSet); + } + return DeactivateRC::LeavePage; +} + +bool SvxNumPositionTabPage::FillItemSet( SfxItemSet* rSet ) +{ + rSet->Put(SfxUInt16Item(SID_PARAM_CUR_NUM_LEVEL, nActNumLvl)); + + if(bModified && pActNum) + { + *pSaveNum = *pActNum; + rSet->Put(SvxNumBulletItem( *pSaveNum, nNumItemId )); + rSet->Put(SfxBoolItem(SID_PARAM_NUM_PRESET, false)); + } + return bModified; +} + +void SvxNumPositionTabPage::Reset( const SfxItemSet* rSet ) +{ + // in Draw the item exists as WhichId, in Writer only as SlotId + const SvxNumBulletItem* pItem = + rSet->GetItemIfSet(SID_ATTR_NUMBERING_RULE, false); + if(!pItem) + { + nNumItemId = rSet->GetPool()->GetWhich(SID_ATTR_NUMBERING_RULE); + pItem = rSet->GetItemIfSet(nNumItemId, false); + + if( !pItem ) + { + pItem = & rSet->Get( nNumItemId ); + } + } + DBG_ASSERT(pItem, "no item found!"); + pSaveNum.reset( new SvxNumRule(pItem->GetNumRule()) ); + + // insert levels + if (!m_xLevelLB->count_selected_rows()) + { + for(sal_uInt16 i = 1; i <= pSaveNum->GetLevelCount(); i++) + m_xLevelLB->append_text(OUString::number(i)); + if(pSaveNum->GetLevelCount() > 1) + { + OUString sEntry = "1 - " + OUString::number( pSaveNum->GetLevelCount() ); + m_xLevelLB->append_text(sEntry); + m_xLevelLB->select_text(sEntry); + } + else + m_xLevelLB->select(0); + } + else + m_xLevelLB->select(m_xLevelLB->count_selected_rows() - 1); + sal_uInt16 nMask = 1; + m_xLevelLB->unselect_all(); + if (nActNumLvl == SAL_MAX_UINT16) + { + m_xLevelLB->select(pSaveNum->GetLevelCount()); + } + else + { + for(sal_uInt16 i = 0; i < pSaveNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + m_xLevelLB->select(i); + nMask <<= 1; + } + } + + if(!pActNum) + pActNum.reset( new SvxNumRule(*pSaveNum) ); + else if(*pSaveNum != *pActNum) + *pActNum = *pSaveNum; + m_aPreviewWIN.SetNumRule(pActNum.get()); + + InitPosAndSpaceMode(); + ShowControlsDependingOnPosAndSpaceMode(); + + InitControls(); + bModified = false; +} + +void SvxNumPositionTabPage::InitPosAndSpaceMode() +{ + if ( pActNum == nullptr ) + { + SAL_WARN( "cui.tabpages", + "<SvxNumPositionTabPage::InitPosAndSpaceMode()> - misusage of method -> <pAktNum> has to be already set!" ); + return; + } + + SvxNumberFormat::SvxNumPositionAndSpaceMode ePosAndSpaceMode = + SvxNumberFormat::LABEL_ALIGNMENT; + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); ++i ) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel(i) ); + ePosAndSpaceMode = aNumFmt.GetPositionAndSpaceMode(); + if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT ) + { + break; + } + } + nMask <<= 1; + } + + bLabelAlignmentPosAndSpaceModeActive = + ePosAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT; +} + +void SvxNumPositionTabPage::ShowControlsDependingOnPosAndSpaceMode() +{ + m_xDistBorderFT->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + m_xDistBorderMF->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + m_xRelativeCB->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + m_xIndentFT->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + m_xIndentMF->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + m_xDistNumFT->set_visible( !bLabelAlignmentPosAndSpaceModeActive && + pActNum->IsFeatureSupported(SvxNumRuleFlags::CONTINUOUS) ); + m_xDistNumMF->set_visible( !bLabelAlignmentPosAndSpaceModeActive && + pActNum->IsFeatureSupported(SvxNumRuleFlags::CONTINUOUS)); + m_xAlignFT->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + m_xAlignLB->set_visible( !bLabelAlignmentPosAndSpaceModeActive ); + + m_xLabelFollowedByFT->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xLabelFollowedByLB->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xListtabFT->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xListtabMF->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xAlign2FT->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xAlign2LB->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xAlignedAtFT->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xAlignedAtMF->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xIndentAtFT->set_visible( bLabelAlignmentPosAndSpaceModeActive ); + m_xIndentAtMF->set_visible( bLabelAlignmentPosAndSpaceModeActive ); +} + +std::unique_ptr<SfxTabPage> SvxNumPositionTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrSet) +{ + return std::make_unique<SvxNumPositionTabPage>(pPage, pController, *rAttrSet); +} + +void SvxNumPositionTabPage::SetMetric(FieldUnit eMetric) +{ + if (eMetric == FieldUnit::MM) + { + m_xDistBorderMF->set_digits(1); + m_xDistNumMF->set_digits(1); + m_xIndentMF->set_digits(1); + m_xListtabMF->set_digits(1); + m_xAlignedAtMF->set_digits(1); + m_xIndentAtMF->set_digits(1); + } + m_xDistBorderMF->set_unit(eMetric); + m_xDistNumMF->set_unit(eMetric); + m_xIndentMF->set_unit(eMetric); + m_xListtabMF->set_unit(eMetric); + m_xAlignedAtMF->set_unit(eMetric); + m_xIndentAtMF->set_unit(eMetric); +} + +IMPL_LINK_NOARG(SvxNumPositionTabPage, EditModifyHdl_Impl, weld::ComboBox&, void) +{ + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt(pActNum->GetLevel(i)); + + const sal_Int32 nPos = m_xAlignLB->get_visible() + ? m_xAlignLB->get_active() + : m_xAlign2LB->get_active(); + SvxAdjust eAdjust = SvxAdjust::Center; + if(nPos == 0) + eAdjust = SvxAdjust::Left; + else if(nPos == 2) + eAdjust = SvxAdjust::Right; + aNumFmt.SetNumAdjust( eAdjust ); + pActNum->SetLevel(i, aNumFmt); + } + nMask <<= 1; + } + SetModified(); +} + +IMPL_LINK_NOARG(SvxNumPositionTabPage, LevelHdl_Impl, weld::TreeView&, void) +{ + if (m_pLevelHdlEvent) + return; + // tdf#127120 multiselection may be implemented by deselect follow by select so + // fire off the handler to happen on next event loop and only process the + // final state + m_pLevelHdlEvent = Application::PostUserEvent(LINK(this, SvxNumPositionTabPage, LevelHdl)); +} + +IMPL_LINK_NOARG(SvxNumPositionTabPage, LevelHdl, void*, void) +{ + m_pLevelHdlEvent = nullptr; + + sal_uInt16 nSaveNumLvl = nActNumLvl; + nActNumLvl = 0; + std::vector<int> aSelectedRows = m_xLevelLB->get_selected_rows(); + if (std::find(aSelectedRows.begin(), aSelectedRows.end(), pActNum->GetLevelCount()) != aSelectedRows.end() && + (aSelectedRows.size() == 1 || nSaveNumLvl != 0xffff)) + { + nActNumLvl = 0xFFFF; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++ ) + m_xLevelLB->unselect(i); + } + else if (!aSelectedRows.empty()) + { + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++ ) + { + if (std::find(aSelectedRows.begin(), aSelectedRows.end(), i) != aSelectedRows.end()) + nActNumLvl |= nMask; + nMask <<= 1; + } + m_xLevelLB->unselect(pActNum->GetLevelCount()); + } + else + { + nActNumLvl = nSaveNumLvl; + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++ ) + { + if(nActNumLvl & nMask) + { + m_xLevelLB->select(i); + break; + } + nMask <<=1; + } + } + m_xRelativeCB->set_sensitive(nActNumLvl != 1); + SetModified(); + InitPosAndSpaceMode(); + ShowControlsDependingOnPosAndSpaceMode(); + InitControls(); +} + +IMPL_LINK(SvxNumPositionTabPage, DistanceHdl_Impl, weld::MetricSpinButton&, rFld, void) +{ + if(bInInintControl) + return; + tools::Long nValue = GetCoreValue(rFld, eCoreUnit); + sal_uInt16 nMask = 1; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel( i ) ); + if (&rFld == m_xDistBorderMF.get()) + { + + if (m_xRelativeCB->get_active()) + { + if(0 == i) + { + auto const nTmp = aNumFmt.GetFirstLineOffset(); + aNumFmt.SetAbsLSpace( nValue - nTmp); + } + else + { + tools::Long nTmp = pActNum->GetLevel( i - 1 ).GetAbsLSpace() + + pActNum->GetLevel( i - 1 ).GetFirstLineOffset() - + pActNum->GetLevel( i ).GetFirstLineOffset(); + + aNumFmt.SetAbsLSpace( nValue + nTmp); + } + } + else + { + aNumFmt.SetAbsLSpace( nValue - aNumFmt.GetFirstLineOffset()); + } + } + else if (&rFld == m_xDistNumMF.get()) + { + aNumFmt.SetCharTextDistance( static_cast<short>(nValue) ); + } + else if (&rFld == m_xIndentMF.get()) + { + // together with the FirstLineOffset the AbsLSpace must be changed, too + tools::Long nDiff = nValue + aNumFmt.GetFirstLineOffset(); + auto const nAbsLSpace = aNumFmt.GetAbsLSpace(); + aNumFmt.SetAbsLSpace(nAbsLSpace + nDiff); + aNumFmt.SetFirstLineOffset( -nValue ); + } + + pActNum->SetLevel( i, aNumFmt ); + } + nMask <<= 1; + } + + SetModified(); + if (!m_xDistBorderMF->get_sensitive()) + { + m_xDistBorderMF->set_text(""); + } +} + +IMPL_LINK(SvxNumPositionTabPage, RelativeHdl_Impl, weld::Toggleable&, rBox, void) +{ + bool bOn = rBox.get_active(); + bool bSingleSelection = m_xLevelLB->count_selected_rows() == 1 && SAL_MAX_UINT16 != nActNumLvl; + bool bSetValue = false; + tools::Long nValue = 0; + if(bOn || bSingleSelection) + { + sal_uInt16 nMask = 1; + bool bFirst = true; + bSetValue = true; + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + const SvxNumberFormat &rNumFmt = pActNum->GetLevel(i); + if(bFirst) + { + nValue = rNumFmt.GetAbsLSpace() + rNumFmt.GetFirstLineOffset(); + if(bOn && i) + nValue -= (pActNum->GetLevel(i - 1).GetAbsLSpace() + pActNum->GetLevel(i - 1).GetFirstLineOffset()); + } + else + bSetValue = nValue == + (rNumFmt.GetAbsLSpace() + rNumFmt.GetFirstLineOffset()) - + (pActNum->GetLevel(i - 1).GetAbsLSpace() + pActNum->GetLevel(i - 1).GetFirstLineOffset()); + bFirst = false; + } + nMask <<= 1; + } + + } + if(bSetValue) + SetMetricValue(*m_xDistBorderMF, nValue, eCoreUnit); + else + m_xDistBorderMF->set_text(""); + m_xDistBorderMF->set_sensitive(bOn || bSingleSelection); + m_xDistBorderFT->set_sensitive(bOn || bSingleSelection); + bLastRelative = bOn; +} + +IMPL_LINK_NOARG(SvxNumPositionTabPage, LabelFollowedByHdl_Impl, weld::ComboBox&, void) +{ + // determine value to be set at the chosen list levels + SvxNumberFormat::LabelFollowedBy eLabelFollowedBy = SvxNumberFormat::LISTTAB; + { + const auto nPos = m_xLabelFollowedByLB->get_active(); + if ( nPos == 1 ) + { + eLabelFollowedBy = SvxNumberFormat::SPACE; + } + else if ( nPos == 2 ) + { + eLabelFollowedBy = SvxNumberFormat::NOTHING; + } + else if ( nPos == 3 ) + { + eLabelFollowedBy = SvxNumberFormat::NEWLINE; + } + } + + // set value at the chosen list levels + bool bSameListtabPos = true; + sal_uInt16 nFirstLvl = SAL_MAX_UINT16; + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); ++i ) + { + if ( nActNumLvl & nMask ) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel(i) ); + aNumFmt.SetLabelFollowedBy( eLabelFollowedBy ); + pActNum->SetLevel( i, aNumFmt ); + + if ( nFirstLvl == SAL_MAX_UINT16 ) + { + nFirstLvl = i; + } + else + { + bSameListtabPos &= aNumFmt.GetListtabPos() == + pActNum->GetLevel( nFirstLvl ).GetListtabPos(); + } + } + nMask <<= 1; + } + + // enable/disable metric field for list tab stop position depending on + // selected item following the list label. + m_xListtabFT->set_sensitive( eLabelFollowedBy == SvxNumberFormat::LISTTAB ); + m_xListtabMF->set_sensitive( eLabelFollowedBy == SvxNumberFormat::LISTTAB ); + if ( bSameListtabPos && eLabelFollowedBy == SvxNumberFormat::LISTTAB ) + { + SetMetricValue(*m_xListtabMF, pActNum->GetLevel( nFirstLvl ).GetListtabPos(), eCoreUnit); + } + else + { + m_xListtabMF->set_text(OUString()); + } + + SetModified(); +} + +IMPL_LINK(SvxNumPositionTabPage, ListtabPosHdl_Impl, weld::MetricSpinButton&, rFld, void) +{ + // determine value to be set at the chosen list levels + const tools::Long nValue = GetCoreValue(rFld, eCoreUnit); + + // set value at the chosen list levels + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); ++i ) + { + if ( nActNumLvl & nMask ) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel(i) ); + aNumFmt.SetListtabPos( nValue ); + pActNum->SetLevel( i, aNumFmt ); + } + nMask <<= 1; + } + + SetModified(); +} + +IMPL_LINK(SvxNumPositionTabPage, AlignAtHdl_Impl, weld::MetricSpinButton&, rFld, void) +{ + // determine value to be set at the chosen list levels + const tools::Long nValue = GetCoreValue(rFld, eCoreUnit); + + // set value at the chosen list levels + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); ++i ) + { + if ( nActNumLvl & nMask ) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel(i) ); + const tools::Long nFirstLineIndent = nValue - aNumFmt.GetIndentAt(); + aNumFmt.SetFirstLineIndent( nFirstLineIndent ); + pActNum->SetLevel( i, aNumFmt ); + } + nMask <<= 1; + } + + SetModified(); +} + +IMPL_LINK(SvxNumPositionTabPage, IndentAtHdl_Impl, weld::MetricSpinButton&, rFld, void) +{ + // determine value to be set at the chosen list levels + const tools::Long nValue = GetCoreValue(rFld, eCoreUnit); + + // set value at the chosen list levels + sal_uInt16 nMask = 1; + for( sal_uInt16 i = 0; i < pActNum->GetLevelCount(); ++i ) + { + if ( nActNumLvl & nMask ) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel(i) ); + const tools::Long nAlignedAt = aNumFmt.GetIndentAt() + + aNumFmt.GetFirstLineIndent(); + aNumFmt.SetIndentAt( nValue ); + const tools::Long nNewFirstLineIndent = nAlignedAt - nValue; + aNumFmt.SetFirstLineIndent( nNewFirstLineIndent ); + pActNum->SetLevel( i, aNumFmt ); + } + nMask <<= 1; + } + + SetModified(); +} + +IMPL_LINK_NOARG(SvxNumPositionTabPage, StandardHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nMask = 1; + SvxNumRule aTmpNumRule( pActNum->GetFeatureFlags(), + pActNum->GetLevelCount(), + pActNum->IsContinuousNumbering(), + SvxNumRuleType::NUMBERING, + pActNum->GetLevel( 0 ).GetPositionAndSpaceMode() ); + for(sal_uInt16 i = 0; i < pActNum->GetLevelCount(); i++) + { + if(nActNumLvl & nMask) + { + SvxNumberFormat aNumFmt( pActNum->GetLevel( i ) ); + const SvxNumberFormat& aTempFmt(aTmpNumRule.GetLevel( i )); + aNumFmt.SetPositionAndSpaceMode( aTempFmt.GetPositionAndSpaceMode() ); + if ( aTempFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION ) + { + aNumFmt.SetAbsLSpace( aTempFmt.GetAbsLSpace() ); + aNumFmt.SetCharTextDistance( aTempFmt.GetCharTextDistance() ); + aNumFmt.SetFirstLineOffset( aTempFmt.GetFirstLineOffset() ); + } + else if ( aTempFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT ) + { + aNumFmt.SetNumAdjust( aTempFmt.GetNumAdjust() ); + aNumFmt.SetLabelFollowedBy( aTempFmt.GetLabelFollowedBy() ); + aNumFmt.SetListtabPos( aTempFmt.GetListtabPos() ); + aNumFmt.SetFirstLineIndent( aTempFmt.GetFirstLineIndent() ); + aNumFmt.SetIndentAt( aTempFmt.GetIndentAt() ); + } + + pActNum->SetLevel( i, aNumFmt ); + } + nMask <<= 1; + } + + InitControls(); + SetModified(); +} + +void SvxNumPositionTabPage::SetModified() +{ + bModified = true; + m_aPreviewWIN.SetLevel(nActNumLvl); + m_aPreviewWIN.Invalidate(); +} + +void SvxNumOptionsTabPage::SetModified(bool bRepaint) +{ + bModified = true; + if (bRepaint) + { + m_aPreviewWIN.SetLevel(nActNumLvl); + m_aPreviewWIN.Invalidate(); + } +} + +void SvxNumOptionsTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxStringListItem* pListItem = aSet.GetItem<SfxStringListItem>(SID_CHAR_FMT_LIST_BOX, false); + const SfxStringItem* pNumCharFmt = aSet.GetItem<SfxStringItem>(SID_NUM_CHAR_FMT, false); + const SfxStringItem* pBulletCharFmt = aSet.GetItem<SfxStringItem>(SID_BULLET_CHAR_FMT, false); + const SfxUInt16Item* pMetricItem = aSet.GetItem<SfxUInt16Item>(SID_METRIC_ITEM, false); + + if (pNumCharFmt &&pBulletCharFmt) + SetCharFmts( pNumCharFmt->GetValue(),pBulletCharFmt->GetValue()); + + if (pListItem) + { + const std::vector<OUString> &aList = pListItem->GetList(); + sal_uInt32 nCount = aList.size(); + for(sal_uInt32 i = 0; i < nCount; i++) + m_xCharFmtLB->append_text(aList[i]); + } + if (pMetricItem) + SetMetric(static_cast<FieldUnit>(pMetricItem->GetValue())); +} + +void SvxNumPositionTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt16Item* pMetricItem = aSet.GetItem<SfxUInt16Item>(SID_METRIC_ITEM, false); + + if (pMetricItem) + SetMetric(static_cast<FieldUnit>(pMetricItem->GetValue())); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/page.cxx b/cui/source/tabpages/page.cxx new file mode 100644 index 000000000..bb4976324 --- /dev/null +++ b/cui/source/tabpages/page.cxx @@ -0,0 +1,1667 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <o3tl/unit_conversion.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/printer.hxx> +#include <sfx2/viewsh.hxx> +#include <svl/cjkoptions.hxx> +#include <svl/ctloptions.hxx> +#include <svtools/unitconv.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <sfx2/htmlmode.hxx> +#include <sal/macros.h> +#include <osl/diagnose.h> + +#include <svx/strings.hrc> +#include <svx/dialmgr.hxx> +#include <page.hxx> +#include <svx/pageitem.hxx> +#include <editeng/brushitem.hxx> +#include <editeng/boxitem.hxx> +#include <editeng/shaditem.hxx> +#include <editeng/pbinitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/sizeitem.hxx> +#include <editeng/frmdiritem.hxx> +#include <svx/dlgutil.hxx> +#include <editeng/paperinf.hxx> +#include <svl/stritem.hxx> +#include <editeng/eerdll.hxx> +#include <editeng/editrids.hrc> +#include <svx/svxids.hrc> +#include <svtools/optionsdrawinglayer.hxx> +#include <svl/slstitm.hxx> +#include <svx/xdef.hxx> +#include <svx/unobrushitemhelper.hxx> +#include <svx/SvxNumOptionsTabPageHelper.hxx> +#include <sal/log.hxx> +#include <svl/grabbagitem.hxx> + +// static ---------------------------------------------------------------- + +// #i19922# - tdf#126051 see svx/source/dialog/hdft.cxx and sw/source/uibase/sidebar/PageMarginControl.hxx +constexpr tools::Long MINBODY = o3tl::toTwips(1, o3tl::Length::mm); // 1mm in twips rounded + +const WhichRangesContainer SvxPageDescPage::pRanges( + svl::Items< + SID_ATTR_BORDER_OUTER, SID_ATTR_BORDER_SHADOW, + SID_ATTR_LRSPACE, SID_ATTR_PAGE_SHARED, + SID_SWREGISTER_COLLECTION, SID_SWREGISTER_MODE>); +// ------- Mapping page layout ------------------------------------------ + +const SvxPageUsage aArr[] = +{ + SvxPageUsage::All, + SvxPageUsage::Mirror, + SvxPageUsage::Right, + SvxPageUsage::Left +}; + + +static sal_uInt16 PageUsageToPos_Impl( SvxPageUsage nUsage ) +{ + for ( size_t i = 0; i < std::size(aArr); ++i ) + if ( aArr[i] == nUsage ) + return i; + return 3; +} + + +static SvxPageUsage PosToPageUsage_Impl( sal_uInt16 nPos ) +{ + if ( nPos >= std::size(aArr) ) + return SvxPageUsage::NONE; + return aArr[nPos]; +} + + +static Size GetMinBorderSpace_Impl( const SvxShadowItem& rShadow, const SvxBoxItem& rBox ) +{ + Size aSz; + aSz.setHeight( rShadow.CalcShadowSpace( SvxShadowItemSide::BOTTOM ) + rBox.CalcLineSpace( SvxBoxItemLine::BOTTOM ) ); + aSz.AdjustHeight(rShadow.CalcShadowSpace( SvxShadowItemSide::TOP ) + rBox.CalcLineSpace( SvxBoxItemLine::TOP ) ); + aSz.setWidth( rShadow.CalcShadowSpace( SvxShadowItemSide::LEFT ) + rBox.CalcLineSpace( SvxBoxItemLine::LEFT ) ); + aSz.AdjustWidth(rShadow.CalcShadowSpace( SvxShadowItemSide::RIGHT ) + rBox.CalcLineSpace( SvxBoxItemLine::RIGHT ) ); + return aSz; +} + + +static tools::Long ConvertLong_Impl( const tools::Long nIn, MapUnit eUnit ) +{ + return OutputDevice::LogicToLogic( nIn, eUnit, MapUnit::MapTwip ); +} + +static bool IsEqualSize_Impl( const SvxSizeItem* pSize, const Size& rSize ) +{ + if ( pSize ) + { + Size aSize = pSize->GetSize(); + tools::Long nDiffW = std::abs( rSize.Width () - aSize.Width () ); + tools::Long nDiffH = std::abs( rSize.Height() - aSize.Height() ); + return ( nDiffW < 10 && nDiffH < 10 ); + } + else + return false; +} + + +#define MARGIN_LEFT ( MarginPosition(0x0001) ) +#define MARGIN_RIGHT ( MarginPosition(0x0002) ) +#define MARGIN_TOP ( MarginPosition(0x0004) ) +#define MARGIN_BOTTOM ( MarginPosition(0x0008) ) + +// class SvxPageDescPage -------------------------------------------------- + +std::unique_ptr<SfxTabPage> SvxPageDescPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet ) +{ + return std::make_unique<SvxPageDescPage>(pPage, pController, *rSet); +} + +SvxPageDescPage::SvxPageDescPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr) + : SfxTabPage(pPage, pController, "cui/ui/pageformatpage.ui", "PageFormatPage", &rAttr) + , bLandscape(false) + , eMode(SVX_PAGE_MODE_STANDARD) + , ePaperStart(PAPER_A3) + , m_nPos(0) + , mpDefPrinter(nullptr) + , mbDelPrinter(false) + , mbEnableDrawingLayerFillStyles(false) + , m_xPaperSizeBox(new SvxPaperSizeListBox(m_xBuilder->weld_combo_box("comboPageFormat"))) + , m_xPaperWidthEdit(m_xBuilder->weld_metric_spin_button("spinWidth", FieldUnit::CM)) + , m_xPaperHeightEdit(m_xBuilder->weld_metric_spin_button("spinHeight", FieldUnit::CM)) + , m_xOrientationFT(m_xBuilder->weld_label("labelOrientation")) + , m_xPortraitBtn(m_xBuilder->weld_radio_button("radiobuttonPortrait")) + , m_xLandscapeBtn(m_xBuilder->weld_radio_button("radiobuttonLandscape")) + , m_xTextFlowLbl(m_xBuilder->weld_label("labelTextFlow")) + , m_xTextFlowBox(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("comboTextFlowBox"))) + , m_xPaperTrayBox(m_xBuilder->weld_combo_box("comboPaperTray")) + , m_xLeftMarginLbl(m_xBuilder->weld_label("labelLeftMargin")) + , m_xLeftMarginEdit(m_xBuilder->weld_metric_spin_button("spinMargLeft", FieldUnit::CM)) + , m_xRightMarginLbl(m_xBuilder->weld_label("labelRightMargin")) + , m_xRightMarginEdit(m_xBuilder->weld_metric_spin_button("spinMargRight", FieldUnit::CM)) + , m_xTopMarginEdit(m_xBuilder->weld_metric_spin_button("spinMargTop", FieldUnit::CM)) + , m_xBottomMarginEdit(m_xBuilder->weld_metric_spin_button("spinMargBot", FieldUnit::CM)) + , m_xGutterMarginLbl(m_xBuilder->weld_label("labelGutterMargin")) + , m_xGutterMarginEdit(m_xBuilder->weld_metric_spin_button("spinMargGut", FieldUnit::CM)) + , m_xPageText(m_xBuilder->weld_label("labelPageLayout")) + , m_xLayoutBox(m_xBuilder->weld_combo_box("comboPageLayout")) + , m_xNumberFormatText(m_xBuilder->weld_label("labelPageNumbers")) + , m_xNumberFormatBox(new SvxPageNumberListBox(m_xBuilder->weld_combo_box("comboLayoutFormat"))) + , m_xTblAlignFT(m_xBuilder->weld_label("labelTblAlign")) + , m_xHorzBox(m_xBuilder->weld_check_button("checkbuttonHorz")) + , m_xVertBox(m_xBuilder->weld_check_button("checkbuttonVert")) + , m_xAdaptBox(m_xBuilder->weld_check_button("checkAdaptBox")) + , m_xRegisterCB(m_xBuilder->weld_check_button("checkRegisterTrue")) + , m_xRegisterFT(m_xBuilder->weld_label("labelRegisterStyle")) + , m_xRegisterLB(m_xBuilder->weld_combo_box("comboRegisterStyle")) + , m_xGutterPositionFT(m_xBuilder->weld_label("labelGutterPosition")) + , m_xGutterPositionLB(m_xBuilder->weld_combo_box("comboGutterPosition")) + , m_xRtlGutterCB(m_xBuilder->weld_check_button("checkRtlGutter")) + , m_xBackgroundFullSizeCB(m_xBuilder->weld_check_button("checkBackgroundFullSize")) + // Strings stored in UI + , m_xInsideLbl(m_xBuilder->weld_label("labelInner")) + , m_xOutsideLbl(m_xBuilder->weld_label("labelOuter")) + , m_xPrintRangeQueryText(m_xBuilder->weld_label("labelMsg")) + , m_xBspWin(new weld::CustomWeld(*m_xBuilder, "drawingareaPageDirection", m_aBspWin)) +{ + m_xRegisterLB->set_size_request(m_xRegisterLB->get_approximate_digit_width() * 20, -1); + + bBorderModified = false; + m_aBspWin.EnableRTL(false); + + // this page needs ExchangeSupport + SetExchangeSupport(); + + SvtCTLOptions aCTLLanguageOptions; + bool bCJK = SvtCJKOptions::IsAsianTypographyEnabled(); + bool bCTL = aCTLLanguageOptions.IsCTLFontEnabled(); + bool bWeb = false; + + const SfxUInt16Item* pHtmlModeItem = rAttr.GetItemIfSet(SID_HTML_MODE, false); + if (!pHtmlModeItem) + { + if (SfxObjectShell* pShell = SfxObjectShell::Current()) + pHtmlModeItem = pShell->GetItem(SID_HTML_MODE); + } + if (pHtmlModeItem) + bWeb = 0 != (pHtmlModeItem->GetValue() & HTMLMODE_ON); + + // fill text flow listbox with valid entries + + m_xTextFlowBox->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_PAGEDIR_LTR_HORI)); + + if (bCTL) + m_xTextFlowBox->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_PAGEDIR_RTL_HORI)); + + + // #109989# do not show vertical directions in Writer/Web + if( !bWeb && bCJK ) + { + m_xTextFlowBox->append(SvxFrameDirection::Vertical_RL_TB, SvxResId(RID_SVXSTR_PAGEDIR_RTL_VERT)); + m_xTextFlowBox->append(SvxFrameDirection::Vertical_LR_TB, SvxResId(RID_SVXSTR_PAGEDIR_LTR_VERT)); + } + + // #109989# show the text direction box in Writer/Web too + if( (bCJK || bCTL) && + SfxItemState::UNKNOWN < rAttr.GetItemState(GetWhich( SID_ATTR_FRAMEDIRECTION ))) + { + m_xTextFlowLbl->show(); + m_xTextFlowBox->show(); + m_xTextFlowBox->connect_changed(LINK(this, SvxPageDescPage, FrameDirectionModify_Impl)); + + m_aBspWin.EnableFrameDirection(true); + } + Init_Impl(); + + FieldUnit eFUnit = GetModuleFieldUnit( rAttr ); + SetFieldUnit( *m_xLeftMarginEdit, eFUnit ); + SetFieldUnit( *m_xRightMarginEdit, eFUnit ); + SetFieldUnit( *m_xTopMarginEdit, eFUnit ); + SetFieldUnit( *m_xBottomMarginEdit, eFUnit ); + SetFieldUnit(*m_xGutterMarginEdit, eFUnit); + SetFieldUnit( *m_xPaperWidthEdit, eFUnit ); + SetFieldUnit( *m_xPaperHeightEdit, eFUnit ); + + if ( SfxViewShell::Current() && SfxViewShell::Current()->GetPrinter() ) + { + mpDefPrinter = SfxViewShell::Current()->GetPrinter(); + } + else + { + mpDefPrinter = VclPtr<Printer>::Create(); + mbDelPrinter = true; + } + + MapMode aOldMode = mpDefPrinter->GetMapMode(); + mpDefPrinter->SetMapMode(MapMode(MapUnit::MapTwip)); + + // set first- and last-values for the margins + Size aPaperSize = mpDefPrinter->GetPaperSize(); + Size aPrintSize = mpDefPrinter->GetOutputSize(); + + /* + * To convert a point ( 0,0 ) into logic coordinates + * looks like nonsense; but it makes sense when the + * coordinate system's origin has been moved. + */ + Point aPrintOffset = mpDefPrinter->GetPageOffset() - mpDefPrinter->PixelToLogic( Point() ); + mpDefPrinter->SetMapMode( aOldMode ); + + nFirstLeftMargin = m_xLeftMarginEdit->convert_value_from(m_xLeftMarginEdit->normalize(aPrintOffset.X()), FieldUnit::TWIP); + nFirstRightMargin = m_xRightMarginEdit->convert_value_from(m_xRightMarginEdit->normalize(aPaperSize.Width() - aPrintSize.Width() - aPrintOffset.X()), FieldUnit::TWIP); + nFirstTopMargin = m_xTopMarginEdit->convert_value_from(m_xTopMarginEdit->normalize(aPrintOffset.Y() ), FieldUnit::TWIP); + nFirstBottomMargin = m_xBottomMarginEdit->convert_value_from(m_xBottomMarginEdit->normalize(aPaperSize.Height() - aPrintSize.Height() - aPrintOffset.Y()), FieldUnit::TWIP ); + nLastLeftMargin = m_xLeftMarginEdit->convert_value_from(m_xLeftMarginEdit->normalize(aPrintOffset.X() + aPrintSize.Width()), FieldUnit::TWIP); + nLastRightMargin = m_xRightMarginEdit->convert_value_from(m_xRightMarginEdit->normalize(aPrintOffset.X() + aPrintSize.Width()), FieldUnit::TWIP); + nLastTopMargin = m_xTopMarginEdit->convert_value_from(m_xTopMarginEdit->normalize(aPrintOffset.Y() + aPrintSize.Height()), FieldUnit::TWIP); + nLastBottomMargin = m_xBottomMarginEdit->convert_value_from(m_xBottomMarginEdit->normalize(aPrintOffset.Y() + aPrintSize.Height()), FieldUnit::TWIP); + + // #i4219# take Maximum now from configuration (1/100th cm) + // was: 11900 -> 119 cm ;new value 3 meters -> 300 cm -> 30000 + m_xPaperWidthEdit->set_max(m_xPaperWidthEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperWidth()), FieldUnit::CM); + m_xPaperHeightEdit->set_max(m_xPaperHeightEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperHeight()), FieldUnit::CM); + + // #i4219# also for margins (1/100th cm). Was: 9999, keeping. + m_xLeftMarginEdit->set_max(m_xLeftMarginEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperLeftMargin()), FieldUnit::MM); + m_xRightMarginEdit->set_max(m_xRightMarginEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperRightMargin()), FieldUnit::MM); + m_xTopMarginEdit->set_max(m_xTopMarginEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperTopMargin()), FieldUnit::MM); + m_xBottomMarginEdit->set_max(m_xBottomMarginEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperBottomMargin()), FieldUnit::MM); + m_xGutterMarginEdit->set_max( + m_xGutterMarginEdit->normalize(SvtOptionsDrawinglayer::GetMaximumPaperLeftMargin()), + FieldUnit::MM); + + // Get the i18n framework numberings and add them to the listbox. + SvxNumOptionsTabPageHelper::GetI18nNumbering(m_xNumberFormatBox->get_widget(), std::numeric_limits<sal_uInt16>::max()); +} + +SvxPageDescPage::~SvxPageDescPage() +{ + if(mbDelPrinter) + { + mpDefPrinter.disposeAndClear(); + mbDelPrinter = false; + } +} + +void SvxPageDescPage::Init_Impl() +{ + // adjust the handler + m_xLayoutBox->connect_changed(LINK(this, SvxPageDescPage, LayoutHdl_Impl)); + m_xGutterPositionLB->connect_changed(LINK(this, SvxPageDescPage, GutterPositionHdl_Impl)); + + m_xPaperSizeBox->connect_changed(LINK(this, SvxPageDescPage, PaperSizeSelect_Impl)); + m_xPaperWidthEdit->connect_value_changed( LINK(this, SvxPageDescPage, PaperSizeModify_Impl)); + m_xPaperHeightEdit->connect_value_changed(LINK(this, SvxPageDescPage, PaperSizeModify_Impl)); + m_xLandscapeBtn->connect_toggled(LINK(this, SvxPageDescPage, SwapOrientation_Impl)); + m_xPortraitBtn->connect_toggled(LINK(this, SvxPageDescPage, SwapOrientation_Impl)); + + Link<weld::MetricSpinButton&, void> aLink = LINK(this, SvxPageDescPage, BorderModify_Impl); + m_xLeftMarginEdit->connect_value_changed(aLink); + m_xRightMarginEdit->connect_value_changed(aLink); + m_xTopMarginEdit->connect_value_changed(aLink); + m_xBottomMarginEdit->connect_value_changed(aLink); + m_xGutterMarginEdit->connect_value_changed(aLink); + + m_xHorzBox->connect_toggled(LINK(this, SvxPageDescPage, CenterHdl_Impl)); + m_xVertBox->connect_toggled(LINK(this, SvxPageDescPage, CenterHdl_Impl)); +} + +void SvxPageDescPage::Reset( const SfxItemSet* rSet ) +{ + SfxItemPool* pPool = rSet->GetPool(); + SAL_WARN_IF(!pPool, "cui.tabpages", "Where is the pool?"); + MapUnit eUnit = pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ); + + // adjust margins (right/left) + const SfxPoolItem* pItem = GetItem( *rSet, SID_ATTR_LRSPACE ); + + if ( pItem ) + { + const SvxLRSpaceItem& rLRSpace = static_cast<const SvxLRSpaceItem&>(*pItem); + SetMetricValue( *m_xLeftMarginEdit, rLRSpace.GetLeft(), eUnit ); + SetMetricValue(*m_xGutterMarginEdit, rLRSpace.GetGutterMargin(), eUnit); + m_aBspWin.SetLeft( + static_cast<sal_uInt16>(ConvertLong_Impl( rLRSpace.GetLeft(), eUnit )) ); + SetMetricValue( *m_xRightMarginEdit, rLRSpace.GetRight(), eUnit ); + m_aBspWin.SetRight( + static_cast<sal_uInt16>(ConvertLong_Impl( rLRSpace.GetRight(), eUnit )) ); + } + + // adjust margins (top/bottom) + pItem = GetItem( *rSet, SID_ATTR_ULSPACE ); + + if ( pItem ) + { + const SvxULSpaceItem& rULSpace = static_cast<const SvxULSpaceItem&>(*pItem); + SetMetricValue( *m_xTopMarginEdit, rULSpace.GetUpper(), eUnit ); + m_aBspWin.SetTop( + static_cast<sal_uInt16>(ConvertLong_Impl( static_cast<tools::Long>(rULSpace.GetUpper()), eUnit )) ); + SetMetricValue( *m_xBottomMarginEdit, rULSpace.GetLower(), eUnit ); + m_aBspWin.SetBottom( + static_cast<sal_uInt16>(ConvertLong_Impl( static_cast<tools::Long>(rULSpace.GetLower()), eUnit )) ); + } + + if (const SfxGrabBagItem* pGragbagItem = rSet->GetItemIfSet(SID_ATTR_CHAR_GRABBAG)) + { + bool bGutterAtTop{}; + auto it = pGragbagItem->GetGrabBag().find("GutterAtTop"); + if (it != pGragbagItem->GetGrabBag().end()) + { + it->second >>= bGutterAtTop; + } + + if (bGutterAtTop) + { + m_xGutterPositionLB->set_active(1); + } + else + { + // Left. + m_xGutterPositionLB->set_active(0); + } + it = pGragbagItem->GetGrabBag().find("RtlGutter"); + bool bRtlGutter{}; + if (it != pGragbagItem->GetGrabBag().end()) + { + it->second >>= bRtlGutter; + m_xRtlGutterCB->set_active(bRtlGutter); + m_xRtlGutterCB->show(); + } + it = pGragbagItem->GetGrabBag().find("BackgroundFullSize"); + bool isBackgroundFullSize{}; + if (it != pGragbagItem->GetGrabBag().end()) + { + it->second >>= isBackgroundFullSize; + m_xBackgroundFullSizeCB->set_active(isBackgroundFullSize); + m_xBackgroundFullSizeCB->show(); + } + } + + // general page data + SvxNumType eNumType = SVX_NUM_ARABIC; + bLandscape = ( mpDefPrinter->GetOrientation() == Orientation::Landscape ); + SvxPageUsage nUse = SvxPageUsage::All; + pItem = GetItem( *rSet, SID_ATTR_PAGE ); + + if ( pItem ) + { + const SvxPageItem& rItem = static_cast<const SvxPageItem&>(*pItem); + eNumType = rItem.GetNumType(); + nUse = rItem.GetPageUsage(); + bLandscape = rItem.IsLandscape(); + } + + // alignment + m_xLayoutBox->set_active(::PageUsageToPos_Impl(nUse)); + m_aBspWin.SetUsage( nUse ); + LayoutHdl_Impl( *m_xLayoutBox ); + + //adjust numeration type of the page style + m_xNumberFormatBox->set_active_id(eNumType); + + m_xPaperTrayBox->clear(); + sal_uInt8 nPaperBin = PAPERBIN_PRINTER_SETTINGS; + pItem = GetItem( *rSet, SID_ATTR_PAGE_PAPERBIN ); + + if ( pItem ) + { + nPaperBin = static_cast<const SvxPaperBinItem*>(pItem)->GetValue(); + + if ( nPaperBin >= mpDefPrinter->GetPaperBinCount() ) + nPaperBin = PAPERBIN_PRINTER_SETTINGS; + } + + OUString aBinName; + + if ( PAPERBIN_PRINTER_SETTINGS == nPaperBin ) + aBinName = EditResId(RID_SVXSTR_PAPERBIN_SETTINGS); + else + aBinName = mpDefPrinter->GetPaperBinName( static_cast<sal_uInt16>(nPaperBin) ); + + m_xPaperTrayBox->append(OUString::number(nPaperBin), aBinName); + m_xPaperTrayBox->set_active_text(aBinName); + // reset focus handler to default first so know none already connected + m_xPaperTrayBox->connect_focus_in(Link<weld::Widget&, void>()); + // update the list when widget gets focus + m_xPaperTrayBox->connect_focus_in(LINK(this, SvxPageDescPage, PaperBinHdl_Impl)); + + Size aPaperSize = SvxPaperInfo::GetPaperSize( mpDefPrinter ); + pItem = GetItem( *rSet, SID_ATTR_PAGE_SIZE ); + + if ( pItem ) + aPaperSize = static_cast<const SvxSizeItem*>(pItem)->GetSize(); + + bool bOrientationSupport = + mpDefPrinter->HasSupport( PrinterSupport::SetOrientation ); + + if ( !bOrientationSupport && + aPaperSize.Width() > aPaperSize.Height() ) + bLandscape = true; + + // tdf#130548 disable callbacks on the other of a pair of the radiogroup + // when toggling its partner + m_xLandscapeBtn->connect_toggled(Link<weld::Toggleable&, void>()); + m_xPortraitBtn->connect_toggled(Link<weld::Toggleable&, void>()); + + m_xLandscapeBtn->set_active(bLandscape); + m_xPortraitBtn->set_active(!bLandscape); + + m_xLandscapeBtn->connect_toggled(LINK(this, SvxPageDescPage, SwapOrientation_Impl)); + m_xPortraitBtn->connect_toggled(LINK(this, SvxPageDescPage, SwapOrientation_Impl)); + + m_aBspWin.SetSize( Size( ConvertLong_Impl( aPaperSize.Width(), eUnit ), + ConvertLong_Impl( aPaperSize.Height(), eUnit ) ) ); + + aPaperSize = OutputDevice::LogicToLogic(aPaperSize, MapMode(eUnit), MapMode(MapUnit::Map100thMM)); + if ( bLandscape ) + Swap( aPaperSize ); + + // Actual Paper Format + Paper ePaper = SvxPaperInfo::GetSvxPaper( aPaperSize, MapUnit::Map100thMM ); + + if ( PAPER_USER != ePaper ) + aPaperSize = SvxPaperInfo::GetPaperSize( ePaper, MapUnit::Map100thMM ); + + if ( bLandscape ) + Swap( aPaperSize ); + + // write values into the edits + SetMetricValue( *m_xPaperHeightEdit, aPaperSize.Height(), MapUnit::Map100thMM ); + SetMetricValue( *m_xPaperWidthEdit, aPaperSize.Width(), MapUnit::Map100thMM ); + m_xPaperSizeBox->clear(); + + m_xPaperSizeBox->FillPaperSizeEntries( ( ePaperStart == PAPER_A3 ) ? PaperSizeApp::Std : PaperSizeApp::Draw ); + m_xPaperSizeBox->set_active_id( ePaper ); + + // application specific + + switch ( eMode ) + { + case SVX_PAGE_MODE_CENTER: + { + m_xTblAlignFT->show(); + m_xHorzBox->show(); + m_xVertBox->show(); + DisableVerticalPageDir(); + + // horizontal alignment + pItem = GetItem( *rSet, SID_ATTR_PAGE_EXT1 ); + m_xHorzBox->set_active(pItem && static_cast<const SfxBoolItem*>(pItem)->GetValue()); + + // vertical alignment + pItem = GetItem( *rSet, SID_ATTR_PAGE_EXT2 ); + m_xVertBox->set_active(pItem && static_cast<const SfxBoolItem*>(pItem)->GetValue()); + + // set example window on the table + m_aBspWin.SetTable( true ); + m_aBspWin.SetHorz(m_xHorzBox->get_active()); + m_aBspWin.SetVert(m_xVertBox->get_active()); + + m_xGutterMarginLbl->hide(); + m_xGutterMarginEdit->hide(); + m_xGutterPositionFT->hide(); + m_xGutterPositionLB->hide(); + + break; + } + + case SVX_PAGE_MODE_PRESENTATION: + { + DisableVerticalPageDir(); + m_xAdaptBox->show(); + pItem = GetItem( *rSet, SID_ATTR_PAGE_EXT1 ); + m_xAdaptBox->set_active( pItem && + static_cast<const SfxBoolItem*>(pItem)->GetValue() ); + + //!!! hidden, because not implemented by StarDraw + m_xLayoutBox->hide(); + m_xPageText->hide(); + + m_xGutterMarginLbl->hide(); + m_xGutterMarginEdit->hide(); + m_xGutterPositionFT->hide(); + m_xGutterPositionLB->hide(); + + break; + } + default: ;//prevent warning + } + + + // display background and border in the example + ResetBackground_Impl( *rSet ); +//! UpdateExample_Impl(); + RangeHdl_Impl(); + + InitHeadFoot_Impl( *rSet ); + + bBorderModified = false; + SwapFirstValues_Impl( false ); + UpdateExample_Impl(); + + m_xLeftMarginEdit->save_value(); + m_xRightMarginEdit->save_value(); + m_xTopMarginEdit->save_value(); + m_xBottomMarginEdit->save_value(); + m_xGutterMarginEdit->save_value(); + m_xLayoutBox->save_value(); + m_xNumberFormatBox->save_value(); + m_xPaperSizeBox->save_value(); + m_xPaperWidthEdit->save_value(); + m_xPaperHeightEdit->save_value(); + m_xPortraitBtn->save_state(); + m_xLandscapeBtn->save_state(); + m_xPaperTrayBox->save_value(); + m_xVertBox->save_state(); + m_xHorzBox->save_state(); + m_xAdaptBox->save_state(); + m_xGutterPositionLB->save_value(); + m_xRtlGutterCB->save_state(); + m_xBackgroundFullSizeCB->save_state(); + + CheckMarginEdits( true ); + + + if(SfxItemState::SET == rSet->GetItemState(SID_SWREGISTER_MODE)) + { + m_xRegisterCB->set_active(rSet->Get(SID_SWREGISTER_MODE).GetValue()); + m_xRegisterCB->save_state(); + RegisterModify(*m_xRegisterCB); + } + if(SfxItemState::SET == rSet->GetItemState(SID_SWREGISTER_COLLECTION)) + { + m_xRegisterLB->set_active_text( + rSet->Get(SID_SWREGISTER_COLLECTION).GetValue()); + m_xRegisterLB->save_value(); + } + + SfxItemState eState = rSet->GetItemState( GetWhich( SID_ATTR_FRAMEDIRECTION ), + true, &pItem ); + if( SfxItemState::UNKNOWN != eState ) + { + SvxFrameDirection nVal = SfxItemState::SET == eState + ? static_cast<const SvxFrameDirectionItem*>(pItem)->GetValue() + : SvxFrameDirection::Horizontal_LR_TB; + m_xTextFlowBox->set_active_id(nVal); + + m_xTextFlowBox->save_value(); + m_aBspWin.SetFrameDirection(nVal); + } +} + +void SvxPageDescPage::FillUserData() +{ + if (SVX_PAGE_MODE_PRESENTATION == eMode) + SetUserData(m_xAdaptBox->get_active() ? OUString("1") : OUString("0")) ; + +} + +bool SvxPageDescPage::FillItemSet( SfxItemSet* rSet ) +{ + bool bModified = false; + const SfxItemSet& rOldSet = GetItemSet(); + SfxItemPool* pPool = rOldSet.GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + sal_uInt16 nWhich = GetWhich( SID_ATTR_LRSPACE ); + MapUnit eUnit = pPool->GetMetric( nWhich ); + const SfxPoolItem* pOld = nullptr; + + // copy old left and right margins + SvxLRSpaceItem aMargin( static_cast<const SvxLRSpaceItem&>(rOldSet.Get( nWhich )) ); + + // copy old top and bottom margins + nWhich = GetWhich( SID_ATTR_ULSPACE ); + SvxULSpaceItem aTopMargin( static_cast<const SvxULSpaceItem&>(rOldSet.Get( nWhich )) ); + + if (m_xLeftMarginEdit->get_value_changed_from_saved()) + { + aMargin.SetLeft( static_cast<sal_uInt16>(GetCoreValue( *m_xLeftMarginEdit, eUnit )) ); + bModified = true; + } + + if (m_xRightMarginEdit->get_value_changed_from_saved()) + { + aMargin.SetRight( static_cast<sal_uInt16>(GetCoreValue( *m_xRightMarginEdit, eUnit )) ); + bModified = true; + } + + if (m_xGutterMarginEdit->get_value_changed_from_saved()) + { + aMargin.SetGutterMargin(static_cast<sal_uInt16>(GetCoreValue(*m_xGutterMarginEdit, eUnit))); + bModified = true; + } + + // set left and right margins + if (bModified) + { + pOld = GetOldItem( *rSet, SID_ATTR_LRSPACE ); + + if ( !pOld || *static_cast<const SvxLRSpaceItem*>(pOld) != aMargin ) + rSet->Put( aMargin ); + else + bModified = false; + } + + if (rOldSet.HasItem(SID_ATTR_CHAR_GRABBAG)) + { + // Set gutter position. + SfxGrabBagItem aGrabBagItem(rOldSet.Get(SID_ATTR_CHAR_GRABBAG)); + if (m_xGutterPositionLB->get_value_changed_from_saved()) + { + bool bGutterAtTop = m_xGutterPositionLB->get_active() == 1; + aGrabBagItem.GetGrabBag()["GutterAtTop"] <<= bGutterAtTop; + bModified = true; + } + if (m_xRtlGutterCB->get_state_changed_from_saved()) + { + bool const bRtlGutter(m_xRtlGutterCB->get_active()); + aGrabBagItem.GetGrabBag()["RtlGutter"] <<= bRtlGutter; + bModified = true; + } + if (m_xBackgroundFullSizeCB->get_state_changed_from_saved()) + { + bool const isBackgroundFullSize(m_xBackgroundFullSizeCB->get_active()); + aGrabBagItem.GetGrabBag()["BackgroundFullSize"] <<= isBackgroundFullSize; + bModified = true; + } + + if (bModified) + { + pOld = rOldSet.GetItem(SID_ATTR_CHAR_GRABBAG); + + if (!pOld || static_cast<const SfxGrabBagItem&>(*pOld) != aGrabBagItem) + rSet->Put(aGrabBagItem); + else + bModified = false; + } + } + + bool bMod = false; + + if (m_xTopMarginEdit->get_value_changed_from_saved()) + { + aTopMargin.SetUpper( static_cast<sal_uInt16>(GetCoreValue( *m_xTopMarginEdit, eUnit )) ); + bMod = true; + } + + if (m_xBottomMarginEdit->get_value_changed_from_saved()) + { + aTopMargin.SetLower( static_cast<sal_uInt16>(GetCoreValue( *m_xBottomMarginEdit, eUnit )) ); + bMod = true; + } + + // set top and bottom margins + + if ( bMod ) + { + pOld = GetOldItem( *rSet, SID_ATTR_ULSPACE ); + + if ( !pOld || *static_cast<const SvxULSpaceItem*>(pOld) != aTopMargin ) + { + bModified = true; + rSet->Put( aTopMargin ); + } + } + + // paper tray + nWhich = GetWhich( SID_ATTR_PAGE_PAPERBIN ); + sal_Int32 nPos = m_xPaperTrayBox->get_active(); + sal_uInt16 nBin = m_xPaperTrayBox->get_id(nPos).toInt32(); + pOld = GetOldItem( *rSet, SID_ATTR_PAGE_PAPERBIN ); + + if ( !pOld || static_cast<const SvxPaperBinItem*>(pOld)->GetValue() != nBin ) + { + rSet->Put( SvxPaperBinItem( nWhich, static_cast<sal_uInt8>(nBin) ) ); + bModified = true; + } + + Paper ePaper = m_xPaperSizeBox->get_active_id(); + bool bChecked = m_xLandscapeBtn->get_active(); + + if ( PAPER_USER == ePaper ) + { + if ( m_xPaperSizeBox->get_value_changed_from_saved() || + m_xPaperWidthEdit->get_value_changed_from_saved() || + m_xPaperHeightEdit->get_value_changed_from_saved() || + m_xLandscapeBtn->get_state_changed_from_saved() ) + { + Size aSize( GetCoreValue( *m_xPaperWidthEdit, eUnit ), + GetCoreValue( *m_xPaperHeightEdit, eUnit ) ); + pOld = GetOldItem( *rSet, SID_ATTR_PAGE_SIZE ); + + if ( !pOld || static_cast<const SvxSizeItem*>(pOld)->GetSize() != aSize ) + { + rSet->Put( SvxSizeItem( GetWhich(SID_ATTR_PAGE_SIZE), aSize ) ); + bModified = true; + } + } + } + else + { + if (m_xPaperSizeBox->get_value_changed_from_saved() || m_xLandscapeBtn->get_state_changed_from_saved()) + { + Size aSize( SvxPaperInfo::GetPaperSize( ePaper, eUnit ) ); + + if ( bChecked ) + Swap( aSize ); + + pOld = GetOldItem( *rSet, SID_ATTR_PAGE_SIZE ); + + if ( !pOld || static_cast<const SvxSizeItem*>(pOld)->GetSize() != aSize ) + { + rSet->Put( SvxSizeItem( GetWhich(SID_ATTR_PAGE_SIZE), aSize ) ); + bModified = true; + } + } + } + + nWhich = GetWhich( SID_ATTR_PAGE ); + SvxPageItem aPage( static_cast<const SvxPageItem&>(rOldSet.Get( nWhich )) ); + bMod = m_xLayoutBox->get_value_changed_from_saved(); + + if ( bMod ) + aPage.SetPageUsage(::PosToPageUsage_Impl(m_xLayoutBox->get_active())); + + if (m_xLandscapeBtn->get_state_changed_from_saved()) + { + aPage.SetLandscape(bChecked); + bMod = true; + } + + //Get the NumType value + if (m_xNumberFormatBox->get_value_changed_from_saved()) + { + SvxNumType nEntryData = m_xNumberFormatBox->get_active_id(); + aPage.SetNumType( nEntryData ); + bMod = true; + } + + if ( bMod ) + { + pOld = GetOldItem( *rSet, SID_ATTR_PAGE ); + + if ( !pOld || *static_cast<const SvxPageItem*>(pOld) != aPage ) + { + rSet->Put( aPage ); + bModified = true; + } + } + else if ( SfxItemState::DEFAULT == rOldSet.GetItemState( nWhich ) ) + rSet->ClearItem( nWhich ); + else + rSet->Put( rOldSet.Get( nWhich ) ); + + // evaluate mode specific controls + + switch ( eMode ) + { + case SVX_PAGE_MODE_CENTER: + { + if (m_xHorzBox->get_state_changed_from_saved()) + { + SfxBoolItem aHorz( GetWhich( SID_ATTR_PAGE_EXT1 ), + m_xHorzBox->get_active() ); + rSet->Put( aHorz ); + bModified = true; + } + + if (m_xVertBox->get_state_changed_from_saved()) + { + SfxBoolItem aVert( GetWhich( SID_ATTR_PAGE_EXT2 ), + m_xVertBox->get_active() ); + rSet->Put( aVert ); + bModified = true; + } + break; + } + + case SVX_PAGE_MODE_PRESENTATION: + { + // always put so that draw can evaluate this + rSet->Put( SfxBoolItem( GetWhich( SID_ATTR_PAGE_EXT1 ), + m_xAdaptBox->get_active() ) ); + bModified = true; + break; + } + default: ;//prevent warning + + } + + if (m_xRegisterCB->get_visible() && + (m_xRegisterCB->get_active() || m_xRegisterCB->get_state_changed_from_saved())) + { + const SfxBoolItem& rRegItem = rOldSet.Get(SID_SWREGISTER_MODE); + std::unique_ptr<SfxBoolItem> pRegItem(rRegItem.Clone()); + bool bCheck = m_xRegisterCB->get_active(); + pRegItem->SetValue(bCheck); + rSet->Put(std::move(pRegItem)); + bModified = true; + if(bCheck) + { + bModified = true; + rSet->Put(SfxStringItem(SID_SWREGISTER_COLLECTION, + m_xRegisterLB->get_active_text())); + } + } + + if (m_xTextFlowBox->get_visible() && m_xTextFlowBox->get_value_changed_from_saved()) + { + SvxFrameDirection eDirection = m_xTextFlowBox->get_active_id(); + rSet->Put( SvxFrameDirectionItem( eDirection, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) ); + bModified = true; + } + + return bModified; +} + +IMPL_LINK_NOARG(SvxPageDescPage, LayoutHdl_Impl, weld::ComboBox&, void) +{ + // switch inside outside + const SvxPageUsage nUsage = PosToPageUsage_Impl(m_xLayoutBox->get_active()); + + if (nUsage == SvxPageUsage::Mirror) + { + m_xLeftMarginLbl->hide(); + m_xRightMarginLbl->hide(); + m_xInsideLbl->show(); + m_xOutsideLbl->show(); + } + else + { + m_xLeftMarginLbl->show(); + m_xRightMarginLbl->show(); + m_xInsideLbl->hide(); + m_xOutsideLbl->hide(); + } + UpdateExample_Impl( true ); +} + +IMPL_LINK_NOARG(SvxPageDescPage, GutterPositionHdl_Impl, weld::ComboBox&, void) +{ + UpdateExample_Impl(true); +} + +IMPL_LINK_NOARG(SvxPageDescPage, PaperBinHdl_Impl, weld::Widget&, void) +{ + // tdf#124226 disconnect so not called again, unless Reset occurs + m_xPaperTrayBox->connect_focus_in(Link<weld::Widget&, void>()); + + OUString aOldName = m_xPaperTrayBox->get_active_text(); + m_xPaperTrayBox->freeze(); + m_xPaperTrayBox->clear(); + m_xPaperTrayBox->append(OUString::number(PAPERBIN_PRINTER_SETTINGS), EditResId(RID_SVXSTR_PAPERBIN_SETTINGS)); + OUString aPaperBin(EditResId(RID_SVXSTR_PAPERBIN)); + const sal_uInt16 nBinCount = mpDefPrinter->GetPaperBinCount(); + + for (sal_uInt16 i = 0; i < nBinCount; ++i) + { + OUString aName = mpDefPrinter->GetPaperBinName(i); + if (aName.isEmpty()) + { + aName = aPaperBin + " " + OUString::number( i+1 ); + } + m_xPaperTrayBox->append(OUString::number(i), aName); + } + m_xPaperTrayBox->set_active_text(aOldName); + m_xPaperTrayBox->thaw(); + + // tdf#123650 explicitly grab-focus after the modification otherwise gtk loses track + // of there the focus should be + m_xPaperTrayBox->grab_focus(); +} + +IMPL_LINK_NOARG(SvxPageDescPage, PaperSizeSelect_Impl, weld::ComboBox&, void) +{ + Paper ePaper = m_xPaperSizeBox->get_active_id(); + + if ( ePaper == PAPER_USER ) + return; + + Size aSize( SvxPaperInfo::GetPaperSize( ePaper, MapUnit::Map100thMM ) ); + + if (m_xLandscapeBtn->get_active()) + Swap( aSize ); + + if ( aSize.Height() < m_xPaperHeightEdit->get_min( FieldUnit::MM_100TH ) ) + m_xPaperHeightEdit->set_min( + m_xPaperHeightEdit->normalize( aSize.Height() ), FieldUnit::MM_100TH ); + if ( aSize.Width() < m_xPaperWidthEdit->get_min( FieldUnit::MM_100TH ) ) + m_xPaperWidthEdit->set_min( + m_xPaperWidthEdit->normalize( aSize.Width() ), FieldUnit::MM_100TH ); + SetMetricValue( *m_xPaperHeightEdit, aSize.Height(), MapUnit::Map100thMM ); + SetMetricValue( *m_xPaperWidthEdit, aSize.Width(), MapUnit::Map100thMM ); + + CalcMargin_Impl(); + + RangeHdl_Impl(); + UpdateExample_Impl( true ); + + if ( eMode != SVX_PAGE_MODE_PRESENTATION ) + return; + + // Draw: if paper format the margin shall be 1 cm + tools::Long nTmp = 0; + bool bScreen = (( PAPER_SCREEN_4_3 == ePaper )||( PAPER_SCREEN_16_9 == ePaper)||( PAPER_SCREEN_16_10 == ePaper)||( PAPER_WIDESCREEN == ePaper)||( PAPER_ONSCREENSHOW_4_3 == ePaper)||( PAPER_ONSCREENSHOW_16_9 == ePaper)||( PAPER_ONSCREENSHOW_16_10 == ePaper)); + + if ( !bScreen ) + // no margin if screen + nTmp = 1; // accordingly 1 cm + + if ( bScreen || m_xRightMarginEdit->get_value(FieldUnit::NONE) == 0 ) + SetMetricValue( *m_xRightMarginEdit, nTmp, MapUnit::MapCM ); + if ( bScreen || m_xLeftMarginEdit->get_value(FieldUnit::NONE) == 0 ) + SetMetricValue( *m_xLeftMarginEdit, nTmp, MapUnit::MapCM ); + if ( bScreen || m_xBottomMarginEdit->get_value(FieldUnit::NONE) == 0 ) + SetMetricValue( *m_xBottomMarginEdit, nTmp, MapUnit::MapCM ); + if ( bScreen || m_xTopMarginEdit->get_value(FieldUnit::NONE) == 0 ) + SetMetricValue( *m_xTopMarginEdit, nTmp, MapUnit::MapCM ); + UpdateExample_Impl( true ); +} + +IMPL_LINK_NOARG(SvxPageDescPage, PaperSizeModify_Impl, weld::MetricSpinButton&, void) +{ + sal_uInt16 nWhich = GetWhich( SID_ATTR_LRSPACE ); + MapUnit eUnit = GetItemSet().GetPool()->GetMetric( nWhich ); + Size aSize( GetCoreValue( *m_xPaperWidthEdit, eUnit ), + GetCoreValue( *m_xPaperHeightEdit, eUnit ) ); + + if ( aSize.Width() > aSize.Height() ) + { + m_xLandscapeBtn->set_active(true); + bLandscape = true; + } + else + { + m_xPortraitBtn->set_active(true); + bLandscape = false; + } + + Paper ePaper = SvxPaperInfo::GetSvxPaper( aSize, eUnit ); + m_xPaperSizeBox->set_active_id( ePaper ); + UpdateExample_Impl( true ); + + RangeHdl_Impl(); +} + +IMPL_LINK(SvxPageDescPage, SwapOrientation_Impl, weld::Toggleable&, rBtn, void) +{ + if (!rBtn.get_active()) + return; + + bLandscape = m_xLandscapeBtn->get_active(); + + const tools::Long lWidth = GetCoreValue( *m_xPaperWidthEdit, MapUnit::Map100thMM ); + const tools::Long lHeight = GetCoreValue( *m_xPaperHeightEdit, MapUnit::Map100thMM ); + + // swap width and height + SetMetricValue(*m_xPaperWidthEdit, lHeight, MapUnit::Map100thMM); + SetMetricValue(*m_xPaperHeightEdit, lWidth, MapUnit::Map100thMM); + + // recalculate margins if necessary + CalcMargin_Impl(); + + PaperSizeSelect_Impl(m_xPaperSizeBox->get_widget()); + RangeHdl_Impl(); + SwapFirstValues_Impl(bBorderModified); + UpdateExample_Impl(true); +} + +void SvxPageDescPage::SwapFirstValues_Impl( bool bSet ) +{ + MapMode aOldMode = mpDefPrinter->GetMapMode(); + Orientation eOri = Orientation::Portrait; + + if ( bLandscape ) + eOri = Orientation::Landscape; + Orientation eOldOri = mpDefPrinter->GetOrientation(); + mpDefPrinter->SetOrientation( eOri ); + mpDefPrinter->SetMapMode(MapMode(MapUnit::MapTwip)); + + // set first- and last-values for margins + Size aPaperSize = mpDefPrinter->GetPaperSize(); + Size aPrintSize = mpDefPrinter->GetOutputSize(); + /* + * To convert a point ( 0,0 ) into logic coordinates + * looks like nonsense; but it makes sense if the + * coordinate system's origin has been moved. + */ + Point aPrintOffset = mpDefPrinter->GetPageOffset() - mpDefPrinter->PixelToLogic( Point() ); + mpDefPrinter->SetMapMode( aOldMode ); + mpDefPrinter->SetOrientation( eOldOri ); + + sal_Int64 nSetL = m_xLeftMarginEdit->denormalize( + m_xLeftMarginEdit->get_value( FieldUnit::TWIP ) ); + sal_Int64 nSetR = m_xRightMarginEdit->denormalize( + m_xRightMarginEdit->get_value( FieldUnit::TWIP ) ); + sal_Int64 nSetT = m_xTopMarginEdit->denormalize( + m_xTopMarginEdit->get_value( FieldUnit::TWIP ) ); + sal_Int64 nSetB = m_xBottomMarginEdit->denormalize( + m_xBottomMarginEdit->get_value( FieldUnit::TWIP ) ); + + tools::Long nNewL = aPrintOffset.X(); + tools::Long nNewR = aPaperSize.Width() - aPrintSize.Width() - aPrintOffset.X(); + tools::Long nNewT = aPrintOffset.Y(); + tools::Long nNewB = aPaperSize.Height() - aPrintSize.Height() - aPrintOffset.Y(); + + nFirstLeftMargin = m_xLeftMarginEdit->convert_value_from(m_xLeftMarginEdit->normalize(nNewL), FieldUnit::TWIP); + nFirstRightMargin = m_xRightMarginEdit->convert_value_from(m_xRightMarginEdit->normalize(nNewR), FieldUnit::TWIP); + nFirstTopMargin = m_xTopMarginEdit->convert_value_from(m_xTopMarginEdit->normalize(nNewT), FieldUnit::TWIP); + nFirstBottomMargin = m_xBottomMarginEdit->convert_value_from(m_xBottomMarginEdit->normalize(nNewB), FieldUnit::TWIP); + + if ( !bSet ) + return; + + if ( nSetL < nNewL ) + m_xLeftMarginEdit->set_value( m_xLeftMarginEdit->normalize( nNewL ), + FieldUnit::TWIP ); + if ( nSetR < nNewR ) + m_xRightMarginEdit->set_value( m_xRightMarginEdit->normalize( nNewR ), + FieldUnit::TWIP ); + if ( nSetT < nNewT ) + m_xTopMarginEdit->set_value( m_xTopMarginEdit->normalize( nNewT ), + FieldUnit::TWIP ); + if ( nSetB < nNewB ) + m_xBottomMarginEdit->set_value( m_xBottomMarginEdit->normalize( nNewB ), + FieldUnit::TWIP ); +} + +IMPL_LINK_NOARG(SvxPageDescPage, BorderModify_Impl, weld::MetricSpinButton&, void) +{ + if ( !bBorderModified ) + bBorderModified = true; + UpdateExample_Impl(); + + RangeHdl_Impl(); +} + +void SvxPageDescPage::UpdateExample_Impl( bool bResetbackground ) +{ + // Size + Size aSize( GetCoreValue( *m_xPaperWidthEdit, MapUnit::MapTwip ), + GetCoreValue( *m_xPaperHeightEdit, MapUnit::MapTwip ) ); + + m_aBspWin.SetSize( aSize ); + + // Margins + bool bGutterAtTop = m_xGutterPositionLB->get_active() == 1; + tools::Long nTop = GetCoreValue(*m_xTopMarginEdit, MapUnit::MapTwip); + if (bGutterAtTop) + { + nTop += GetCoreValue(*m_xGutterMarginEdit, MapUnit::MapTwip); + } + m_aBspWin.SetTop(nTop); + m_aBspWin.SetBottom( GetCoreValue( *m_xBottomMarginEdit, MapUnit::MapTwip ) ); + tools::Long nLeft = GetCoreValue(*m_xLeftMarginEdit, MapUnit::MapTwip); + if (!bGutterAtTop) + { + nLeft += GetCoreValue(*m_xGutterMarginEdit, MapUnit::MapTwip); + } + m_aBspWin.SetLeft(nLeft); + m_aBspWin.SetRight( GetCoreValue( *m_xRightMarginEdit, MapUnit::MapTwip ) ); + + // Layout + m_aBspWin.SetUsage(PosToPageUsage_Impl(m_xLayoutBox->get_active())); + if ( bResetbackground ) + m_aBspWin.ResetBackground(); + m_aBspWin.Invalidate(); +} + + +void SvxPageDescPage::ResetBackground_Impl(const SfxItemSet& rSet) +{ + sal_uInt16 nWhich(GetWhich(SID_ATTR_PAGE_HEADERSET)); + + if (SfxItemState::SET == rSet.GetItemState(nWhich, false)) + { + const SvxSetItem& rSetItem = static_cast< const SvxSetItem& >(rSet.Get(nWhich, false)); + const SfxItemSet& rTmpSet = rSetItem.GetItemSet(); + const SfxBoolItem& rOn = rTmpSet.Get(GetWhich(SID_ATTR_PAGE_ON)); + + if(rOn.GetValue()) + { + drawinglayer::attribute::SdrAllFillAttributesHelperPtr aHeaderFillAttributes; + + if(mbEnableDrawingLayerFillStyles) + { + // create FillAttributes directly from DrawingLayer FillStyle entries + aHeaderFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(rTmpSet); + } + else + { + nWhich = GetWhich(SID_ATTR_BRUSH); + + if(SfxItemState::SET == rTmpSet.GetItemState(nWhich)) + { + // create FillAttributes from SvxBrushItem + const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(rTmpSet.Get(nWhich)); + SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aTempSet(*rTmpSet.GetPool()); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aHeaderFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + m_aBspWin.setHeaderFillAttributes(aHeaderFillAttributes); + } + } + + nWhich = GetWhich(SID_ATTR_PAGE_FOOTERSET); + + if (SfxItemState::SET == rSet.GetItemState(nWhich, false)) + { + const SvxSetItem& rSetItem = static_cast< const SvxSetItem& >(rSet.Get(nWhich,false)); + const SfxItemSet& rTmpSet = rSetItem.GetItemSet(); + const SfxBoolItem& rOn = rTmpSet.Get(GetWhich(SID_ATTR_PAGE_ON)); + + if(rOn.GetValue()) + { + drawinglayer::attribute::SdrAllFillAttributesHelperPtr aFooterFillAttributes; + + if(mbEnableDrawingLayerFillStyles) + { + // create FillAttributes directly from DrawingLayer FillStyle entries + aFooterFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(rTmpSet); + } + else + { + nWhich = GetWhich(SID_ATTR_BRUSH); + + if(SfxItemState::SET == rTmpSet.GetItemState(nWhich)) + { + // create FillAttributes from SvxBrushItem + const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(rTmpSet.Get(nWhich)); + SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aTempSet(*rTmpSet.GetPool()); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aFooterFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + m_aBspWin.setFooterFillAttributes(aFooterFillAttributes); + } + } + + drawinglayer::attribute::SdrAllFillAttributesHelperPtr aPageFillAttributes; + + if(mbEnableDrawingLayerFillStyles) + { + // create FillAttributes directly from DrawingLayer FillStyle entries + aPageFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(rSet); + } + else + { + const SfxPoolItem* pItem = GetItem(rSet, SID_ATTR_BRUSH); + + if(pItem) + { + // create FillAttributes from SvxBrushItem + const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(*pItem); + SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aTempSet(*rSet.GetPool()); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aPageFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + m_aBspWin.setPageFillAttributes(aPageFillAttributes); +} + +void SvxPageDescPage::InitHeadFoot_Impl( const SfxItemSet& rSet ) +{ + bLandscape = m_xLandscapeBtn->get_active(); + const SfxPoolItem* pItem = GetItem( rSet, SID_ATTR_PAGE_SIZE ); + + if ( pItem ) + m_aBspWin.SetSize( static_cast<const SvxSizeItem*>(pItem)->GetSize() ); + + const SvxSetItem* pSetItem = nullptr; + + // evaluate header attributes + + if ( SfxItemState::SET == + rSet.GetItemState( GetWhich( SID_ATTR_PAGE_HEADERSET ), + false, reinterpret_cast<const SfxPoolItem**>(&pSetItem) ) ) + { + const SfxItemSet& rHeaderSet = pSetItem->GetItemSet(); + const SfxBoolItem& rHeaderOn = + rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_ON ) ); + + if ( rHeaderOn.GetValue() ) + { + const SvxSizeItem& rSize = + rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) ); + const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>( + rHeaderSet.Get( GetWhich( SID_ATTR_ULSPACE ) )); + tools::Long nDist = rUL.GetLower(); + m_aBspWin.SetHdHeight( rSize.GetSize().Height() - nDist ); + m_aBspWin.SetHdDist( nDist ); + const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>( + rHeaderSet.Get( GetWhich( SID_ATTR_LRSPACE ) )); + m_aBspWin.SetHdLeft( rLR.GetLeft() ); + m_aBspWin.SetHdRight( rLR.GetRight() ); + m_aBspWin.SetHeader( true ); + } + else + m_aBspWin.SetHeader( false ); + + // show background and border in the example + drawinglayer::attribute::SdrAllFillAttributesHelperPtr aHeaderFillAttributes; + + if(mbEnableDrawingLayerFillStyles) + { + // create FillAttributes directly from DrawingLayer FillStyle entries + aHeaderFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(rHeaderSet); + } + else + { + const sal_uInt16 nWhich(GetWhich(SID_ATTR_BRUSH)); + + if(rHeaderSet.GetItemState(nWhich) >= SfxItemState::DEFAULT) + { + // aBspWin.SetHdColor(rItem.GetColor()); + const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(rHeaderSet.Get(nWhich)); + SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aTempSet(*rHeaderSet.GetPool()); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aHeaderFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + m_aBspWin.setHeaderFillAttributes(aHeaderFillAttributes); + } + + // evaluate footer attributes + + if ( SfxItemState::SET != + rSet.GetItemState( GetWhich( SID_ATTR_PAGE_FOOTERSET ), + false, reinterpret_cast<const SfxPoolItem**>(&pSetItem) ) ) + return; + + const SfxItemSet& rFooterSet = pSetItem->GetItemSet(); + const SfxBoolItem& rFooterOn = + rFooterSet.Get( GetWhich( SID_ATTR_PAGE_ON ) ); + + if ( rFooterOn.GetValue() ) + { + const SvxSizeItem& rSize = + rFooterSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) ); + const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>( + rFooterSet.Get( GetWhich( SID_ATTR_ULSPACE ) )); + tools::Long nDist = rUL.GetUpper(); + m_aBspWin.SetFtHeight( rSize.GetSize().Height() - nDist ); + m_aBspWin.SetFtDist( nDist ); + const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>( + rFooterSet.Get( GetWhich( SID_ATTR_LRSPACE ) )); + m_aBspWin.SetFtLeft( rLR.GetLeft() ); + m_aBspWin.SetFtRight( rLR.GetRight() ); + m_aBspWin.SetFooter( true ); + } + else + m_aBspWin.SetFooter( false ); + + // show background and border in the example + drawinglayer::attribute::SdrAllFillAttributesHelperPtr aFooterFillAttributes; + + if(mbEnableDrawingLayerFillStyles) + { + // create FillAttributes directly from DrawingLayer FillStyle entries + aFooterFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(rFooterSet); + } + else + { + const sal_uInt16 nWhich(GetWhich(SID_ATTR_BRUSH)); + + if(rFooterSet.GetItemState(nWhich) >= SfxItemState::DEFAULT) + { + // aBspWin.SetFtColor(rItem.GetColor()); + const SvxBrushItem& rItem = static_cast<const SvxBrushItem&>(rFooterSet.Get(nWhich)); + SfxItemSetFixed<XATTR_FILL_FIRST, XATTR_FILL_LAST> aTempSet(*rFooterSet.GetPool()); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aFooterFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + m_aBspWin.setFooterFillAttributes(aFooterFillAttributes); +} + +void SvxPageDescPage::ActivatePage( const SfxItemSet& rSet ) +{ + InitHeadFoot_Impl( rSet ); + UpdateExample_Impl(); + ResetBackground_Impl( rSet ); + RangeHdl_Impl(); +} + +DeactivateRC SvxPageDescPage::DeactivatePage( SfxItemSet* _pSet ) +{ + // Inquiry whether the page margins are beyond the printing area. + // If not, ask user whether they shall be taken. + // If not, stay on the TabPage. + Paper ePaper = m_xPaperSizeBox->get_active_id(); + + if ( ePaper != PAPER_SCREEN_4_3 && ePaper != PAPER_SCREEN_16_9 && ePaper != PAPER_SCREEN_16_10 && ePaper != PAPER_WIDESCREEN && ePaper != PAPER_ONSCREENSHOW_4_3 && ePaper != PAPER_ONSCREENSHOW_16_9 && ePaper != PAPER_ONSCREENSHOW_16_10 && IsMarginOutOfRange() ) + { + std::unique_ptr<weld::MessageDialog> xQueryBox(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Question, VclButtonsType::YesNo, + m_xPrintRangeQueryText->get_label())); + xQueryBox->set_default_response(RET_NO); + if (xQueryBox->run() == RET_NO) + { + weld::MetricSpinButton* pField = nullptr; + if ( IsPrinterRangeOverflow( *m_xLeftMarginEdit, nFirstLeftMargin, nLastLeftMargin, MARGIN_LEFT ) ) + pField = m_xLeftMarginEdit.get(); + if ( IsPrinterRangeOverflow( *m_xRightMarginEdit, nFirstRightMargin, nLastRightMargin, MARGIN_RIGHT ) + && !pField ) + pField = m_xRightMarginEdit.get(); + if ( IsPrinterRangeOverflow( *m_xTopMarginEdit, nFirstTopMargin, nLastTopMargin, MARGIN_TOP ) + && !pField ) + pField = m_xTopMarginEdit.get(); + if ( IsPrinterRangeOverflow( *m_xBottomMarginEdit, nFirstBottomMargin, nLastBottomMargin, MARGIN_BOTTOM ) + && !pField ) + pField = m_xBottomMarginEdit.get(); + if ( pField ) + pField->grab_focus(); + UpdateExample_Impl(); + return DeactivateRC::KeepPage; + } + else + CheckMarginEdits( false ); + } + + if ( _pSet ) + { + FillItemSet( _pSet ); + + // put portray/landscape if applicable + sal_uInt16 nWh = GetWhich( SID_ATTR_PAGE_SIZE ); + MapUnit eUnit = GetItemSet().GetPool()->GetMetric( nWh ); + Size aSize( GetCoreValue( *m_xPaperWidthEdit, eUnit ), + GetCoreValue( *m_xPaperHeightEdit, eUnit ) ); + + // put, if current size is different to the value in _pSet + const SvxSizeItem* pSize = GetItem( *_pSet, SID_ATTR_PAGE_SIZE ); + if ( aSize.Width() && ( !pSize || !IsEqualSize_Impl( pSize, aSize ) ) ) + _pSet->Put( SvxSizeItem( nWh, aSize ) ); + } + + return DeactivateRC::LeavePage; +} + +void SvxPageDescPage::RangeHdl_Impl() +{ + // example window + tools::Long nHHeight = m_aBspWin.GetHdHeight(); + tools::Long nHDist = m_aBspWin.GetHdDist(); + + tools::Long nFHeight = m_aBspWin.GetFtHeight(); + tools::Long nFDist = m_aBspWin.GetFtDist(); + + tools::Long nHFLeft = std::max(m_aBspWin.GetHdLeft(), m_aBspWin.GetFtLeft()); + tools::Long nHFRight = std::max(m_aBspWin.GetHdRight(), m_aBspWin.GetFtRight()); + + // current values for page margins + tools::Long nBT = static_cast<tools::Long>(m_xTopMarginEdit->denormalize(m_xTopMarginEdit->get_value(FieldUnit::TWIP))); + tools::Long nBB = static_cast<tools::Long>(m_xBottomMarginEdit->denormalize(m_xBottomMarginEdit->get_value(FieldUnit::TWIP))); + tools::Long nBL = static_cast<tools::Long>(m_xLeftMarginEdit->denormalize(m_xLeftMarginEdit->get_value(FieldUnit::TWIP))); + tools::Long nBR = static_cast<tools::Long>(m_xRightMarginEdit->denormalize(m_xRightMarginEdit->get_value(FieldUnit::TWIP))); + + // calculate width of page border + const SfxItemSet* _pSet = &GetItemSet(); + Size aBorder; + + if ( _pSet->GetItemState( GetWhich(SID_ATTR_BORDER_SHADOW) ) >= + SfxItemState::DEFAULT && + _pSet->GetItemState( GetWhich(SID_ATTR_BORDER_OUTER) ) >= + SfxItemState::DEFAULT ) + { + aBorder = GetMinBorderSpace_Impl( + static_cast<const SvxShadowItem&>(_pSet->Get(GetWhich(SID_ATTR_BORDER_SHADOW))), + static_cast<const SvxBoxItem&>(_pSet->Get(GetWhich(SID_ATTR_BORDER_OUTER)))); + } + + // limits paper + // maximum is 54 cm + + tools::Long nMin = nHHeight + nHDist + nFDist + nFHeight + nBT + nBB + + MINBODY + aBorder.Height(); + m_xPaperHeightEdit->set_min(m_xPaperHeightEdit->normalize(nMin), FieldUnit::TWIP); + + nMin = MINBODY + nBL + nBR + aBorder.Width(); + m_xPaperWidthEdit->set_min(m_xPaperWidthEdit->normalize(nMin), FieldUnit::TWIP); + + tools::Long nH = static_cast<tools::Long>(m_xPaperHeightEdit->denormalize(m_xPaperHeightEdit->get_value(FieldUnit::TWIP))); + tools::Long nW = static_cast<tools::Long>(m_xPaperWidthEdit->denormalize(m_xPaperWidthEdit->get_value(FieldUnit::TWIP))); + + // Top + tools::Long nMax = nH - nBB - aBorder.Height() - MINBODY - + nFDist - nFHeight - nHDist - nHHeight; + + m_xTopMarginEdit->set_max(m_xTopMarginEdit->normalize(nMax), FieldUnit::TWIP); + + // Bottom + nMax = nH - nBT - aBorder.Height() - MINBODY - + nFDist - nFHeight - nHDist - nHHeight; + + m_xBottomMarginEdit->set_max(m_xTopMarginEdit->normalize(nMax), FieldUnit::TWIP); + + // Left + nMax = nW - nBR - MINBODY - aBorder.Width() - nHFLeft - nHFRight; + m_xLeftMarginEdit->set_max(m_xLeftMarginEdit->normalize(nMax), FieldUnit::TWIP); + + // Right + nMax = nW - nBL - MINBODY - aBorder.Width() - nHFLeft - nHFRight; + m_xRightMarginEdit->set_max(m_xRightMarginEdit->normalize(nMax), FieldUnit::TWIP); +} + +void SvxPageDescPage::CalcMargin_Impl() +{ + // current values for page margins + tools::Long nBT = GetCoreValue( *m_xTopMarginEdit, MapUnit::MapTwip ); + tools::Long nBB = GetCoreValue( *m_xBottomMarginEdit, MapUnit::MapTwip ); + + tools::Long nBL = GetCoreValue( *m_xLeftMarginEdit, MapUnit::MapTwip ); + tools::Long nBR = GetCoreValue( *m_xRightMarginEdit, MapUnit::MapTwip ); + + tools::Long nH = GetCoreValue( *m_xPaperHeightEdit, MapUnit::MapTwip ); + tools::Long nW = GetCoreValue( *m_xPaperWidthEdit, MapUnit::MapTwip ); + + tools::Long nWidth = nBL + nBR + MINBODY; + tools::Long nHeight = nBT + nBB + MINBODY; + + if ( nWidth <= nW && nHeight <= nH ) + return; + + if ( nWidth > nW ) + { + tools::Long nTmp = nBL <= nBR ? nBR : nBL; + nTmp -= nWidth - nW; + + if ( nBL <= nBR ) + SetMetricValue( *m_xRightMarginEdit, nTmp, MapUnit::MapTwip ); + else + SetMetricValue( *m_xLeftMarginEdit, nTmp, MapUnit::MapTwip ); + } + + if ( nHeight > nH ) + { + tools::Long nTmp = nBT <= nBB ? nBB : nBT; + nTmp -= nHeight - nH; + + if ( nBT <= nBB ) + SetMetricValue( *m_xBottomMarginEdit, nTmp, MapUnit::MapTwip ); + else + SetMetricValue( *m_xTopMarginEdit, nTmp, MapUnit::MapTwip ); + } +} + +IMPL_LINK_NOARG(SvxPageDescPage, CenterHdl_Impl, weld::Toggleable&, void) +{ + m_aBspWin.SetHorz(m_xHorzBox->get_active()); + m_aBspWin.SetVert(m_xVertBox->get_active()); + UpdateExample_Impl(); +} + +void SvxPageDescPage::SetCollectionList(const std::vector<OUString> &aList) +{ + OSL_ENSURE(!aList.empty(), "Empty string list"); + + sStandardRegister = aList[0]; + m_xRegisterLB->freeze(); + for (size_t i = 1; i < aList.size(); ++i) + m_xRegisterLB->append_text(aList[i]); + m_xRegisterLB->thaw(); + + m_xRegisterCB->show(); + m_xRegisterFT->show(); + m_xRegisterLB->show(); + m_xRegisterCB->connect_toggled(LINK(this, SvxPageDescPage, RegisterModify)); +} + +IMPL_LINK(SvxPageDescPage, RegisterModify, weld::Toggleable&, rBox, void) +{ + bool bEnable = false; + if (rBox.get_active()) + { + bEnable = true; + if (m_xRegisterLB->get_active() == -1) + m_xRegisterLB->set_active_text(sStandardRegister); + } + m_xRegisterFT->set_sensitive(bEnable); + m_xRegisterLB->set_sensitive(bEnable); +} + +void SvxPageDescPage::DisableVerticalPageDir() +{ + m_xTextFlowBox->remove_id(SvxFrameDirection::Vertical_RL_TB); + m_xTextFlowBox->remove_id(SvxFrameDirection::Vertical_LR_TB); + if (m_xTextFlowBox->get_count() < 2) + { + m_xTextFlowLbl->hide(); + m_xTextFlowBox->hide(); + m_aBspWin.EnableFrameDirection( false ); + } +} + +IMPL_LINK_NOARG(SvxPageDescPage, FrameDirectionModify_Impl, weld::ComboBox&, void) +{ + m_aBspWin.SetFrameDirection(m_xTextFlowBox->get_active_id()); + m_aBspWin.Invalidate(); +} + +bool SvxPageDescPage::IsPrinterRangeOverflow( + weld::MetricSpinButton& rField, tools::Long nFirstMargin, tools::Long nLastMargin, MarginPosition nPos ) +{ + bool bRet = false; + bool bCheck = ( ( m_nPos & nPos ) == 0 ); + tools::Long nValue = rField.get_value(FieldUnit::NONE); + if ( bCheck && + ( nValue < nFirstMargin || nValue > nLastMargin ) && + rField.get_value_changed_from_saved() ) + { + rField.set_value(nValue < nFirstMargin ? nFirstMargin : nLastMargin, FieldUnit::NONE); + bRet = true; + } + + return bRet; +} + +/** Check if a value of a margin edit is outside the printer paper margins + and save this information. +*/ +void SvxPageDescPage::CheckMarginEdits( bool _bClear ) +{ + if ( _bClear ) + m_nPos = 0; + + sal_Int64 nValue = m_xLeftMarginEdit->get_value(FieldUnit::NONE); + if ( nValue < nFirstLeftMargin || nValue > nLastLeftMargin ) + m_nPos |= MARGIN_LEFT; + nValue = m_xRightMarginEdit->get_value(FieldUnit::NONE); + if ( nValue < nFirstRightMargin || nValue > nLastRightMargin ) + m_nPos |= MARGIN_RIGHT; + nValue = m_xTopMarginEdit->get_value(FieldUnit::NONE); + if ( nValue < nFirstTopMargin || nValue > nLastTopMargin ) + m_nPos |= MARGIN_TOP; + nValue = m_xBottomMarginEdit->get_value(FieldUnit::NONE); + if ( nValue < nFirstBottomMargin || nValue > nLastBottomMargin ) + m_nPos |= MARGIN_BOTTOM; +} + +bool SvxPageDescPage::IsMarginOutOfRange() const +{ + bool bRet = ( ( ( !( m_nPos & MARGIN_LEFT ) && + m_xLeftMarginEdit->get_value_changed_from_saved() ) && + ( m_xLeftMarginEdit->get_value(FieldUnit::NONE) < nFirstLeftMargin || + m_xLeftMarginEdit->get_value(FieldUnit::NONE) > nLastLeftMargin ) ) || + ( ( !( m_nPos & MARGIN_RIGHT ) && + m_xRightMarginEdit->get_value_changed_from_saved() ) && + ( m_xRightMarginEdit->get_value(FieldUnit::NONE) < nFirstRightMargin || + m_xRightMarginEdit->get_value(FieldUnit::NONE) > nLastRightMargin ) ) || + ( ( !( m_nPos & MARGIN_TOP ) && + m_xTopMarginEdit->get_value_changed_from_saved() ) && + ( m_xTopMarginEdit->get_value(FieldUnit::NONE) < nFirstTopMargin || + m_xTopMarginEdit->get_value(FieldUnit::NONE) > nLastTopMargin ) ) || + ( ( !( m_nPos & MARGIN_BOTTOM ) && + m_xBottomMarginEdit->get_value_changed_from_saved() ) && + ( m_xBottomMarginEdit->get_value(FieldUnit::NONE) < nFirstBottomMargin || + m_xBottomMarginEdit->get_value(FieldUnit::NONE) > nLastBottomMargin ) ) ); + return bRet; +} + +void SvxPageDescPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt16Item* pModeItem = aSet.GetItem(SID_ENUM_PAGE_MODE, false); + const SfxUInt16Item* pPaperStartItem = aSet.GetItem(SID_PAPER_START, false); + const SfxUInt16Item* pPaperEndItem = aSet.GetItem(SID_PAPER_END, false); + const SfxStringListItem* pCollectListItem = aSet.GetItem<SfxStringListItem>(SID_COLLECT_LIST, false); + const SfxBoolItem* pSupportDrawingLayerFillStyleItem = aSet.GetItem<SfxBoolItem>(SID_DRAWINGLAYER_FILLSTYLES, false); + const SfxBoolItem* pIsImpressDoc = aSet.GetItem<SfxBoolItem>(SID_IMPRESS_DOC, false); + + if (pModeItem) + { + eMode = static_cast<SvxModeType>(pModeItem->GetValue()); + } + + if(pPaperStartItem && pPaperEndItem) + { + SetPaperFormatRanges(static_cast<Paper>(pPaperStartItem->GetValue())); + } + + if(pCollectListItem) + { + SetCollectionList(pCollectListItem->GetList()); + } + + if(pSupportDrawingLayerFillStyleItem) + { + const bool bNew(pSupportDrawingLayerFillStyleItem->GetValue()); + + mbEnableDrawingLayerFillStyles = bNew; + } + + if (pIsImpressDoc) + m_xNumberFormatText->set_label(SvxResId(STR_SLIDE_NUMBERS)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/paragrph.cxx b/cui/source/tabpages/paragrph.cxx new file mode 100644 index 000000000..b2cd167a5 --- /dev/null +++ b/cui/source/tabpages/paragrph.cxx @@ -0,0 +1,2330 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <osl/diagnose.h> +#include <svl/style.hxx> +#include <sfx2/objsh.hxx> +#include <vcl/mnemonic.hxx> +#include <vcl/settings.hxx> +#include <svx/flagsdef.hxx> +#include <svx/svxids.hrc> + +#include <svl/cjkoptions.hxx> +#include <editeng/pgrditem.hxx> +#include <svx/strings.hrc> +#include <svx/dialmgr.hxx> +#include <paragrph.hxx> +#include <editeng/frmdiritem.hxx> +#include <editeng/lspcitem.hxx> +#include <editeng/adjustitem.hxx> +#include <editeng/orphitem.hxx> +#include <editeng/widwitem.hxx> +#include <editeng/tstpitem.hxx> +#include <editeng/pmdlitem.hxx> +#include <editeng/spltitem.hxx> +#include <editeng/hyphenzoneitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/formatbreakitem.hxx> +#include <editeng/keepitem.hxx> +#include <svx/dlgutil.hxx> +#include <sfx2/htmlmode.hxx> +#include <editeng/paravertalignitem.hxx> +#include <svl/eitem.hxx> +#include <svl/intitem.hxx> + +const WhichRangesContainer SvxStdParagraphTabPage::pStdRanges( + svl::Items< + SID_ATTR_PARA_LINESPACE, SID_ATTR_PARA_LINESPACE, // 10033 + SID_ATTR_LRSPACE, SID_ATTR_ULSPACE, // 10048 - 10049 + SID_ATTR_PARA_REGISTER, SID_ATTR_PARA_REGISTER // 10413 + >); + +const WhichRangesContainer SvxParaAlignTabPage::pAlignRanges( + svl::Items<SID_ATTR_PARA_ADJUST, SID_ATTR_PARA_ADJUST>); // 10027 + +const WhichRangesContainer SvxExtParagraphTabPage::pExtRanges(svl::Items< + SID_ATTR_PARA_PAGEBREAK, SID_ATTR_PARA_WIDOWS, // 10037 - 10041 + SID_ATTR_PARA_MODEL, SID_ATTR_PARA_KEEP // 10065 - 10066 +>); + +#define MAX_DURCH 31680 // tdf#68335: 1584 pt for UX interoperability with Word +#define FIX_DIST_DEF 283 // standard fix distance 0,5 cm + +namespace { + +enum LineSpaceList +{ + LLINESPACE_1 = 0, + LLINESPACE_115 = 1, + LLINESPACE_15 = 2, + LLINESPACE_2 = 3, + LLINESPACE_PROP = 4, + LLINESPACE_MIN = 5, + LLINESPACE_DURCH= 6, + LLINESPACE_FIX = 7 +}; + +} + +static void SetLineSpace_Impl( SvxLineSpacingItem&, int, tools::Long lValue = 0 ); + +void SetLineSpace_Impl( SvxLineSpacingItem& rLineSpace, + int eSpace, tools::Long lValue ) +{ + switch ( eSpace ) + { + case LLINESPACE_1: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + break; + + case LLINESPACE_115: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( 115 ); + break; + + case LLINESPACE_15: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( 150 ); + break; + + case LLINESPACE_2: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( 200 ); + break; + + case LLINESPACE_PROP: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetPropLineSpace( static_cast<sal_uInt16>(lValue) ); + break; + + case LLINESPACE_MIN: + rLineSpace.SetLineHeight( static_cast<sal_uInt16>(lValue) ); + rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + break; + + case LLINESPACE_DURCH: + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto ); + rLineSpace.SetInterLineSpace( static_cast<sal_uInt16>(lValue) ); + break; + + case LLINESPACE_FIX: + rLineSpace.SetLineHeight(static_cast<sal_uInt16>(lValue)); + rLineSpace.SetLineSpaceRule( SvxLineSpaceRule::Fix ); + rLineSpace.SetInterLineSpaceRule( SvxInterLineSpaceRule::Off ); + break; + } +} + +static sal_uInt16 GetHtmlMode_Impl(const SfxItemSet& rSet) +{ + sal_uInt16 nHtmlMode = 0; + const SfxUInt16Item* pItem = rSet.GetItemIfSet(SID_HTML_MODE, false); + if (!pItem) + { + if (SfxObjectShell* pShell = SfxObjectShell::Current()) + pItem = pShell->GetItem(SID_HTML_MODE); + } + if(pItem) + { + nHtmlMode = pItem->GetValue(); + } + return nHtmlMode; + +} + +void SvxStdParagraphTabPage::ELRLoseFocus() +{ + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = + MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) ); + + sal_Int64 nL = m_xLeftIndent->denormalize(m_xLeftIndent->get_value(eUnit)); + sal_Int64 nR = m_xRightIndent->denormalize(m_xRightIndent->get_value(eUnit)); + OUString aTmp = m_xFLineIndent->get_text(); + + if (m_xLeftIndent->get_min(FieldUnit::NONE) < 0) + m_xFLineIndent->set_min(-99999, FieldUnit::MM); + else + m_xFLineIndent->set_min(m_xFLineIndent->normalize(-nL), eUnit); + + // Check only for concrete width (Shell) + sal_Int64 nTmp = nWidth - nL - nR - MM50; + m_xFLineIndent->set_max(m_xFLineIndent->normalize(nTmp), eUnit); + + if (aTmp.isEmpty()) + m_xFLineIndent->set_text(OUString()); + // maximum left right + aTmp = m_xLeftIndent->get_text(); + nTmp = nWidth - nR - MM50; + m_xLeftIndent->set_max(m_xLeftIndent->normalize(nTmp), eUnit); + + if ( aTmp.isEmpty() ) + m_xLeftIndent->set_text(OUString()); + aTmp = m_xRightIndent->get_text(); + nTmp = nWidth - nL - MM50; + m_xRightIndent->set_max(m_xRightIndent->normalize(nTmp), eUnit); + + if ( aTmp.isEmpty() ) + m_xRightIndent->set_text(OUString()); + + UpdateExample_Impl(); +} + +IMPL_LINK_NOARG(SvxStdParagraphTabPage, ELRLoseFocusHdl, weld::MetricSpinButton&, void) +{ + ELRLoseFocus(); +} + +std::unique_ptr<SfxTabPage> SvxStdParagraphTabPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxStdParagraphTabPage>(pPage, pController, *rSet); +} + +bool SvxStdParagraphTabPage::FillItemSet( SfxItemSet* rOutSet ) +{ + const SfxPoolItem* pOld = nullptr; + SfxItemPool* pPool = rOutSet->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + + bool bModified = false; + sal_uInt16 nWhich; + int nPos = m_xLineDist->get_active(); + + if ( nPos != -1 && + ( m_bLineDistToggled || + m_xLineDist->get_value_changed_from_saved() || + m_xLineDistAtPercentBox->get_value_changed_from_saved() || + m_xLineDistAtMetricBox->get_value_changed_from_saved() ) ) + { + nWhich = GetWhich( SID_ATTR_PARA_LINESPACE ); + MapUnit eUnit = pPool->GetMetric( nWhich ); + SvxLineSpacingItem aSpacing( + static_cast<const SvxLineSpacingItem&>(GetItemSet().Get( nWhich )) ); + + switch ( nPos ) + { + case LLINESPACE_1: + case LLINESPACE_115: + case LLINESPACE_15: + case LLINESPACE_2: + SetLineSpace_Impl( aSpacing, nPos ); + break; + + case LLINESPACE_PROP: + SetLineSpace_Impl( aSpacing, nPos, + static_cast<tools::Long>(m_xLineDistAtPercentBox->denormalize( + m_xLineDistAtPercentBox->get_value(FieldUnit::NONE) )) ); + break; + + case LLINESPACE_MIN: + case LLINESPACE_DURCH: + case LLINESPACE_FIX: + SetLineSpace_Impl( aSpacing, nPos, + GetCoreValue( *m_xLineDistAtMetricBox, eUnit ) ); + break; + + default: + OSL_FAIL( "unknown LineDist entry" ); + break; + } + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_LINESPACE ); + + if ( m_bLineDistToggled || + !pOld || !( *static_cast<const SvxLineSpacingItem*>(pOld) == aSpacing ) || + SfxItemState::DONTCARE == GetItemSet().GetItemState( nWhich ) ) + { + rOutSet->Put( aSpacing ); + bModified = true; + } + } + + if ( m_xTopDist->get_value_changed_from_saved() || m_xBottomDist->get_value_changed_from_saved() + || m_xContextualCB->get_state_changed_from_saved()) + { + nWhich = GetWhich( SID_ATTR_ULSPACE ); + MapUnit eUnit = pPool->GetMetric( nWhich ); + pOld = GetOldItem( *rOutSet, SID_ATTR_ULSPACE ); + SvxULSpaceItem aMargin( nWhich ); + + if ( bRelativeMode ) + { + DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" ); + + const SvxULSpaceItem& rOldItem = + static_cast<const SvxULSpaceItem&>(GetItemSet().GetParent()->Get( nWhich )); + + if ( m_xTopDist->IsRelative() ) + aMargin.SetUpper( rOldItem.GetUpper(), + static_cast<sal_uInt16>(m_xTopDist->get_value(FieldUnit::NONE)) ); + else + aMargin.SetUpper( static_cast<sal_uInt16>(m_xTopDist->GetCoreValue(eUnit)) ); + + if ( m_xBottomDist->IsRelative() ) + aMargin.SetLower( rOldItem.GetLower(), + static_cast<sal_uInt16>(m_xBottomDist->get_value(FieldUnit::NONE)) ); + else + aMargin.SetLower( static_cast<sal_uInt16>(m_xBottomDist->GetCoreValue(eUnit)) ); + + } + else + { + aMargin.SetUpper(static_cast<sal_uInt16>(m_xTopDist->GetCoreValue(eUnit))); + aMargin.SetLower(static_cast<sal_uInt16>(m_xBottomDist->GetCoreValue(eUnit))); + } + aMargin.SetContextValue(m_xContextualCB->get_active()); + + if ( !pOld || *static_cast<const SvxULSpaceItem*>(pOld) != aMargin || + SfxItemState::DONTCARE == GetItemSet().GetItemState( nWhich ) ) + { + rOutSet->Put( aMargin ); + bModified = true; + } + } + bool bNullTab = false; + + if ( m_xLeftIndent->get_value_changed_from_saved() || + m_xFLineIndent->get_value_changed_from_saved() || + m_xRightIndent->get_value_changed_from_saved() || + m_xAutoCB->get_state_changed_from_saved() ) + { + nWhich = GetWhich( SID_ATTR_LRSPACE ); + MapUnit eUnit = pPool->GetMetric( nWhich ); + SvxLRSpaceItem aMargin( nWhich ); + pOld = GetOldItem( *rOutSet, SID_ATTR_LRSPACE ); + + if ( bRelativeMode ) + { + DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" ); + + const SvxLRSpaceItem& rOldItem = + static_cast<const SvxLRSpaceItem&>(GetItemSet().GetParent()->Get( nWhich )); + + if (m_xLeftIndent->IsRelative()) + aMargin.SetTextLeft( rOldItem.GetTextLeft(), + static_cast<sal_uInt16>(m_xLeftIndent->get_value(FieldUnit::NONE)) ); + else + aMargin.SetTextLeft(m_xLeftIndent->GetCoreValue(eUnit)); + + if ( m_xRightIndent->IsRelative() ) + aMargin.SetRight( rOldItem.GetRight(), + static_cast<sal_uInt16>(m_xRightIndent->get_value(FieldUnit::NONE)) ); + else + aMargin.SetRight(m_xRightIndent->GetCoreValue(eUnit)); + + if ( m_xFLineIndent->IsRelative() ) + aMargin.SetTextFirstLineOffset( rOldItem.GetTextFirstLineOffset(), + static_cast<sal_uInt16>(m_xFLineIndent->get_value(FieldUnit::NONE)) ); + else + aMargin.SetTextFirstLineOffset(static_cast<sal_uInt16>(m_xFLineIndent->GetCoreValue(eUnit))); + } + else + { + aMargin.SetTextLeft(m_xLeftIndent->GetCoreValue(eUnit)); + aMargin.SetRight(m_xRightIndent->GetCoreValue(eUnit)); + aMargin.SetTextFirstLineOffset(static_cast<sal_uInt16>(m_xFLineIndent->GetCoreValue(eUnit))); + } + aMargin.SetAutoFirst(m_xAutoCB->get_active()); + if ( aMargin.GetTextFirstLineOffset() < 0 ) + bNullTab = true; + + if ( !pOld || *static_cast<const SvxLRSpaceItem*>(pOld) != aMargin || + SfxItemState::DONTCARE == GetItemSet().GetItemState( nWhich ) ) + { + rOutSet->Put( aMargin ); + bModified = true; + } + } + + if ( bNullTab ) + { + MapUnit eUnit = pPool->GetMetric( GetWhich( SID_ATTR_TABSTOP ) ); + if ( MapUnit::Map100thMM != eUnit ) + { + + // negative first line indent -> set null default tabstob if applicable + sal_uInt16 _nWhich = GetWhich( SID_ATTR_TABSTOP ); + const SfxItemSet& rInSet = GetItemSet(); + + if ( rInSet.GetItemState( _nWhich ) >= SfxItemState::DEFAULT ) + { + const SvxTabStopItem& rTabItem = + static_cast<const SvxTabStopItem&>(rInSet.Get( _nWhich )); + SvxTabStopItem aNullTab( rTabItem ); + SvxTabStop aNull( 0, SvxTabAdjust::Default ); + aNullTab.Insert( aNull ); + rOutSet->Put( aNullTab ); + } + } + } + if (m_xRegisterCB->get_visible()) + { + const SfxBoolItem* pBoolItem = static_cast<const SfxBoolItem*>(GetOldItem( + *rOutSet, SID_ATTR_PARA_REGISTER)); + if (!pBoolItem) + return bModified; + sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_REGISTER ); + bool bSet = pBoolItem->GetValue(); + + if (m_xRegisterCB->get_active() != bSet) + { + std::unique_ptr<SfxBoolItem> pRegItem(pBoolItem->Clone()); + pRegItem->SetValue(!bSet); + rOutSet->Put(std::move(pRegItem)); + bModified = true; + } + else if ( SfxItemState::DEFAULT == GetItemSet().GetItemState( _nWhich, false ) ) + rOutSet->ClearItem(_nWhich); + } + + return bModified; +} + +void SvxStdParagraphTabPage::Reset( const SfxItemSet* rSet ) +{ + SfxItemPool* pPool = rSet->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + + // adjust metric + FieldUnit eFUnit = GetModuleFieldUnit( *rSet ); + + bool bApplyCharUnit = GetApplyCharUnit( *rSet ); + + if(SvtCJKOptions::IsAsianTypographyEnabled() && bApplyCharUnit ) + eFUnit = FieldUnit::CHAR; + + m_xLeftIndent->SetFieldUnit(eFUnit); + m_xRightIndent->SetFieldUnit(eFUnit); + m_xFLineIndent->SetFieldUnit(eFUnit); + if ( eFUnit == FieldUnit::CHAR ) + { + m_xTopDist->SetFieldUnit(FieldUnit::LINE); + m_xBottomDist->SetFieldUnit(FieldUnit::LINE); + SetFieldUnit(*m_xLineDistAtMetricBox, FieldUnit::POINT); + } + else + { + m_xTopDist->SetFieldUnit(eFUnit); + m_xBottomDist->SetFieldUnit(eFUnit); + SetFieldUnit(*m_xLineDistAtMetricBox, eFUnit); + } + + sal_uInt16 _nWhich = GetWhich( SID_ATTR_LRSPACE ); + SfxItemState eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + MapUnit eUnit = pPool->GetMetric( _nWhich ); + + if ( bRelativeMode ) + { + const SvxLRSpaceItem& rOldItem = + static_cast<const SvxLRSpaceItem&>(rSet->Get( _nWhich )); + + if ( rOldItem.GetPropLeft() != 100 ) + { + m_xLeftIndent->SetRelative( true ); + m_xLeftIndent->set_value(rOldItem.GetPropLeft(), FieldUnit::NONE); + } + else + { + m_xLeftIndent->SetRelative(false); + m_xLeftIndent->SetFieldUnit(eFUnit); + m_xLeftIndent->SetMetricValue(rOldItem.GetTextLeft(), eUnit); + } + + if ( rOldItem.GetPropRight() != 100 ) + { + m_xRightIndent->SetRelative( true ); + m_xRightIndent->set_value(rOldItem.GetPropRight(), FieldUnit::NONE); + } + else + { + m_xRightIndent->SetRelative(false); + m_xRightIndent->SetFieldUnit(eFUnit); + m_xRightIndent->SetMetricValue(rOldItem.GetRight(), eUnit); + } + + if ( rOldItem.GetPropTextFirstLineOffset() != 100 ) + { + m_xFLineIndent->SetRelative(true); + m_xFLineIndent->set_value(rOldItem.GetPropTextFirstLineOffset(), FieldUnit::NONE); + } + else + { + m_xFLineIndent->SetRelative(false); + m_xFLineIndent->set_min(-9999, FieldUnit::NONE); + m_xFLineIndent->SetFieldUnit(eFUnit); + m_xFLineIndent->SetMetricValue(rOldItem.GetTextFirstLineOffset(), eUnit); + } + m_xAutoCB->set_active(rOldItem.IsAutoFirst()); + } + else + { + const SvxLRSpaceItem& rSpace = + static_cast<const SvxLRSpaceItem&>(rSet->Get( _nWhich )); + + m_xLeftIndent->SetMetricValue(rSpace.GetTextLeft(), eUnit); + m_xRightIndent->SetMetricValue(rSpace.GetRight(), eUnit); + m_xFLineIndent->SetMetricValue(rSpace.GetTextFirstLineOffset(), eUnit); + m_xAutoCB->set_active(rSpace.IsAutoFirst()); + } + AutoHdl_Impl(*m_xAutoCB); + } + else + { + m_xLeftIndent->set_text(OUString()); + m_xRightIndent->set_text(OUString()); + m_xFLineIndent->set_text(OUString()); + } + + _nWhich = GetWhich( SID_ATTR_ULSPACE ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + MapUnit eUnit = pPool->GetMetric( _nWhich ); + + const SvxULSpaceItem& rOldItem = + static_cast<const SvxULSpaceItem&>(rSet->Get( _nWhich )); + if ( bRelativeMode ) + { + + if ( rOldItem.GetPropUpper() != 100 ) + { + m_xTopDist->SetRelative( true ); + m_xTopDist->set_value(rOldItem.GetPropUpper(), FieldUnit::NONE); + } + else + { + m_xTopDist->SetRelative(false); + if (eFUnit == FieldUnit::CHAR) + m_xTopDist->SetFieldUnit(FieldUnit::LINE); + else + m_xTopDist->SetFieldUnit(eFUnit); + m_xTopDist->SetMetricValue(rOldItem.GetUpper(), eUnit); + } + + if ( rOldItem.GetPropLower() != 100 ) + { + m_xBottomDist->SetRelative( true ); + m_xBottomDist->set_value(rOldItem.GetPropLower(), FieldUnit::NONE); + } + else + { + m_xBottomDist->SetRelative(false); + if (eFUnit == FieldUnit::CHAR) + m_xBottomDist->SetFieldUnit(FieldUnit::LINE); + else + m_xBottomDist->SetFieldUnit(eFUnit); + m_xBottomDist->SetMetricValue(rOldItem.GetLower(), eUnit); + } + } + else + { + m_xTopDist->SetMetricValue(rOldItem.GetUpper(), eUnit); + m_xBottomDist->SetMetricValue(rOldItem.GetLower(), eUnit); + } + m_xContextualCB->set_active(rOldItem.GetContext()); + } + else + { + m_xTopDist->set_text(OUString()); + m_xBottomDist->set_text(OUString()); + } + + _nWhich = GetWhich( SID_ATTR_PARA_LINESPACE ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + SetLineSpacing_Impl( static_cast<const SvxLineSpacingItem &>(rSet->Get( _nWhich )) ); + else + m_xLineDist->set_active(-1); + + _nWhich = GetWhich( SID_ATTR_PARA_REGISTER ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + m_xRegisterCB->set_active( static_cast<const SfxBoolItem &>(rSet->Get( _nWhich )).GetValue()); + m_xRegisterCB->save_state(); + sal_uInt16 nHtmlMode = GetHtmlMode_Impl(*rSet); + if(nHtmlMode & HTMLMODE_ON) + { + m_xRegisterCB->hide(); + m_xAutoCB->hide(); + } + + // this sets the min/max limits; do this _after_ setting the values, + // because for Impress the min of first-line indent depends on value of + // left-indent! + ELRLoseFocus(); + ChangesApplied(); +} + +void SvxStdParagraphTabPage::ChangesApplied() +{ + m_xLeftIndent->save_value(); + m_xRightIndent->save_value(); + m_xFLineIndent->save_value(); + m_xLineDist->save_value(); + m_xLineDistAtPercentBox->save_value(); + m_xLineDistAtMetricBox->save_value(); + m_xRegisterCB->save_state(); + m_xTopDist->save_value(); + m_xBottomDist->save_value(); + m_xContextualCB->save_state(); + m_xAutoCB->save_state(); +} + +void SvxStdParagraphTabPage::EnableRelativeMode() +{ + DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no parent-set!" ); + + m_xLeftIndent->EnableRelativeMode( 0, 999 ); + m_xFLineIndent->EnableRelativeMode( 0, 999 ); + m_xRightIndent->EnableRelativeMode( 0, 999 ); + m_xTopDist->EnableRelativeMode( 0, 999 ); + m_xBottomDist->EnableRelativeMode( 0, 999 ); + bRelativeMode = true; +} + +void SvxStdParagraphTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST ); + SfxItemState eItemState = rSet.GetItemState( _nWhich ); + + if ( eItemState < SfxItemState::DEFAULT ) + return; + + const SvxAdjustItem& rAdj = static_cast<const SvxAdjustItem&>( rSet.Get( _nWhich ) ); + SvxAdjust eAdjust = rAdj.GetAdjust(); + if ( eAdjust == SvxAdjust::Center || eAdjust == SvxAdjust::Block ) + { + _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION ); + eItemState = rSet.GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>( rSet.Get( _nWhich ) ); + SvxFrameDirection eFrameDirection = rFrameDirItem.GetValue(); + + m_aExampleWin.EnableRTL( SvxFrameDirection::Horizontal_RL_TB == eFrameDirection ); + + if ( eAdjust == SvxAdjust::Block ) + m_aExampleWin.SetLastLine( rAdj.GetLastBlock() ); + } + } + else + { + m_aExampleWin.EnableRTL( eAdjust == SvxAdjust::Right ); + eAdjust = SvxAdjust::Left; //required for correct preview display + m_aExampleWin.SetLastLine( eAdjust ); + } + m_aExampleWin.SetAdjust( eAdjust ); + + UpdateExample_Impl(); +} + +DeactivateRC SvxStdParagraphTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + ELRLoseFocus(); + + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +SvxStdParagraphTabPage::SvxStdParagraphTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr) + : SfxTabPage(pPage, pController, "cui/ui/paraindentspacing.ui", "ParaIndentSpacing", &rAttr) + , nWidth(11905 /*567 * 50*/) + , nMinFixDist(0) + , bRelativeMode(false) + , m_xLeftIndent(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("spinED_LEFTINDENT", FieldUnit::CM))) + , m_xRightLabel(m_xBuilder->weld_label("labelFT_RIGHTINDENT")) + , m_xRightIndent(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("spinED_RIGHTINDENT", FieldUnit::CM))) + , m_xFLineLabel(m_xBuilder->weld_label("labelFT_FLINEINDENT")) + , m_xFLineIndent(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("spinED_FLINEINDENT", FieldUnit::CM))) + , m_xAutoCB(m_xBuilder->weld_check_button("checkCB_AUTO")) + , m_xTopDist(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("spinED_TOPDIST", FieldUnit::CM))) + , m_xBottomDist(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("spinED_BOTTOMDIST", FieldUnit::CM))) + , m_xContextualCB(m_xBuilder->weld_check_button("checkCB_CONTEXTUALSPACING")) + , m_xLineDist(m_xBuilder->weld_combo_box("comboLB_LINEDIST")) + , m_xLineDistAtPercentBox(m_xBuilder->weld_metric_spin_button("spinED_LINEDISTPERCENT", FieldUnit::PERCENT)) + , m_xLineDistAtMetricBox(m_xBuilder->weld_metric_spin_button("spinED_LINEDISTMETRIC", FieldUnit::CM)) + , m_xLineDistAtLabel(m_xBuilder->weld_label("labelFT_LINEDIST")) + , m_xAbsDist(m_xBuilder->weld_label("labelST_LINEDIST_ABS")) + , m_xRegisterCB(m_xBuilder->weld_check_button("checkCB_REGISTER")) + , m_xExampleWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWN_EXAMPLE", m_aExampleWin)) +{ + sAbsDist = m_xAbsDist->get_label(); + + // this page needs ExchangeSupport + SetExchangeSupport(); + + m_xLineDistAtMetricBox->hide(); + + Init_Impl(); + m_xFLineIndent->set_min(-9999, FieldUnit::NONE); // is set to 0 on default +} + +SvxStdParagraphTabPage::~SvxStdParagraphTabPage() +{ +} + +void SvxStdParagraphTabPage::EnableNegativeMode() +{ + m_xLeftIndent->set_min(-9999, FieldUnit::NONE); + m_xRightIndent->set_min(-9999, FieldUnit::NONE); + m_xRightIndent->EnableNegativeMode(); + m_xLeftIndent->EnableNegativeMode(); +} + +void SvxStdParagraphTabPage::SetLineSpacing_Impl +( + const SvxLineSpacingItem &rAttr +) +{ + MapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() ); + + switch( rAttr.GetLineSpaceRule() ) + { + case SvxLineSpaceRule::Auto: + { + SvxInterLineSpaceRule eInter = rAttr.GetInterLineSpaceRule(); + + switch( eInter ) + { + // Default single line spacing + case SvxInterLineSpaceRule::Off: + m_xLineDist->set_active( LLINESPACE_1 ); + break; + + // Default single line spacing + case SvxInterLineSpaceRule::Prop: + if ( 100 == rAttr.GetPropLineSpace() ) + { + m_xLineDist->set_active( LLINESPACE_1 ); + break; + } + // 1.15 line spacing + if ( 115 == rAttr.GetPropLineSpace() ) + { + m_xLineDist->set_active( LLINESPACE_115 ); + break; + } + // 1.5 line spacing + if ( 150 == rAttr.GetPropLineSpace() ) + { + m_xLineDist->set_active( LLINESPACE_15 ); + break; + } + // double line spacing + if ( 200 == rAttr.GetPropLineSpace() ) + { + m_xLineDist->set_active( LLINESPACE_2 ); + break; + } + // the set per cent value + m_xLineDistAtPercentBox->set_value(m_xLineDistAtPercentBox->normalize(rAttr.GetPropLineSpace()), FieldUnit::NONE); + m_xLineDist->set_active( LLINESPACE_PROP ); + break; + + case SvxInterLineSpaceRule::Fix: + SetMetricValue( *m_xLineDistAtMetricBox, rAttr.GetInterLineSpace(), eUnit ); + m_xLineDist->set_active( LLINESPACE_DURCH ); + break; + default: ;//prevent warning + } + } + break; + case SvxLineSpaceRule::Fix: + SetMetricValue(*m_xLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit); + m_xLineDist->set_active( LLINESPACE_FIX ); + break; + + case SvxLineSpaceRule::Min: + SetMetricValue(*m_xLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit); + m_xLineDist->set_active( LLINESPACE_MIN ); + break; + default: ;//prevent warning + } + LineDistHdl_Impl( *m_xLineDist ); +} + +IMPL_LINK_NOARG(SvxStdParagraphTabPage, LineDistPopupHdl_Impl, weld::ComboBox&, void) +{ + m_bLineDistToggled = true; +} + +IMPL_LINK(SvxStdParagraphTabPage, LineDistHdl_Impl, weld::ComboBox&, rBox, void) +{ + switch (rBox.get_active()) + { + case LLINESPACE_1: + case LLINESPACE_115: + case LLINESPACE_15: + case LLINESPACE_2: + m_xLineDistAtLabel->set_sensitive(false); + m_xLineDistAtPercentBox->set_sensitive(false); + m_xLineDistAtPercentBox->set_text(OUString()); + m_xLineDistAtMetricBox->set_sensitive(false); + m_xLineDistAtMetricBox->set_text(OUString()); + break; + + case LLINESPACE_DURCH: + // setting a sensible default? + // limit MS min(10, aPageSize) + m_xLineDistAtMetricBox->set_min(0, FieldUnit::NONE); + + if (m_xLineDistAtMetricBox->get_text().isEmpty()) + m_xLineDistAtMetricBox->set_value(m_xLineDistAtMetricBox->normalize(1), FieldUnit::NONE); + m_xLineDistAtPercentBox->hide(); + m_xLineDistAtMetricBox->show(); + m_xLineDistAtMetricBox->set_sensitive(true); + m_xLineDistAtLabel->set_sensitive(true); + break; + + case LLINESPACE_MIN: + m_xLineDistAtMetricBox->set_min(0, FieldUnit::NONE); + + if (m_xLineDistAtMetricBox->get_text().isEmpty()) + m_xLineDistAtMetricBox->set_value(m_xLineDistAtMetricBox->normalize(10), FieldUnit::TWIP); + m_xLineDistAtPercentBox->hide(); + m_xLineDistAtMetricBox->show(); + m_xLineDistAtMetricBox->set_sensitive(true); + m_xLineDistAtLabel->set_sensitive(true); + break; + + case LLINESPACE_PROP: + + if (m_xLineDistAtPercentBox->get_text().isEmpty()) + m_xLineDistAtPercentBox->set_value(m_xLineDistAtPercentBox->normalize(100), FieldUnit::TWIP); + m_xLineDistAtMetricBox->hide(); + m_xLineDistAtPercentBox->show(); + m_xLineDistAtPercentBox->set_sensitive(true); + m_xLineDistAtLabel->set_sensitive(true); + break; + case LLINESPACE_FIX: + { + auto nTemp = m_xLineDistAtMetricBox->get_value(FieldUnit::NONE); + m_xLineDistAtMetricBox->set_min(m_xLineDistAtMetricBox->normalize(nMinFixDist), FieldUnit::TWIP); + + // if the value has been changed at SetMin, + // it is time for the default + if (m_xLineDistAtMetricBox->get_value(FieldUnit::NONE) != nTemp) + SetMetricValue( *m_xLineDistAtMetricBox, FIX_DIST_DEF, MapUnit::MapTwip ); // fix is only in Writer + m_xLineDistAtPercentBox->hide(); + m_xLineDistAtMetricBox->show(); + m_xLineDistAtMetricBox->set_sensitive(true); + m_xLineDistAtLabel->set_sensitive(true); + } + break; + } + UpdateExample_Impl(); +} + +IMPL_LINK_NOARG(SvxStdParagraphTabPage, ModifyHdl_Impl, weld::MetricSpinButton&, void) +{ + UpdateExample_Impl(); +} + +void SvxStdParagraphTabPage::Init_Impl() +{ + m_xLineDist->connect_popup_toggled(LINK(this, SvxStdParagraphTabPage, LineDistPopupHdl_Impl)); + m_xLineDist->connect_changed(LINK(this, SvxStdParagraphTabPage, LineDistHdl_Impl)); + + Link<weld::MetricSpinButton&,void> aLink2 = LINK(this, SvxStdParagraphTabPage, ELRLoseFocusHdl); + m_xFLineIndent->connect_value_changed(aLink2); + m_xLeftIndent->connect_value_changed(aLink2); + m_xRightIndent->connect_value_changed(aLink2); + + Link<weld::MetricSpinButton&,void> aLink = LINK(this, SvxStdParagraphTabPage, ModifyHdl_Impl); + m_xTopDist->connect_value_changed(aLink); + m_xBottomDist->connect_value_changed(aLink); + + m_xAutoCB->connect_toggled(LINK(this, SvxStdParagraphTabPage, AutoHdl_Impl)); + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) ); + + m_xTopDist->set_max( m_xTopDist->normalize( MAX_DURCH ), eUnit ); + m_xBottomDist->set_max( m_xBottomDist->normalize( MAX_DURCH ), eUnit ); + m_xLineDistAtMetricBox->set_max( m_xLineDistAtMetricBox->normalize( MAX_DURCH ), eUnit ); +} + +void SvxStdParagraphTabPage::UpdateExample_Impl() +{ + m_aExampleWin.SetFirstLineOffset( static_cast<short>(m_xFLineIndent->denormalize( m_xFLineIndent->get_value( FieldUnit::TWIP ) )) ); + m_aExampleWin.SetLeftMargin( static_cast<tools::Long>(m_xLeftIndent->denormalize( m_xLeftIndent->get_value( FieldUnit::TWIP ) ) ) ); + m_aExampleWin.SetRightMargin( static_cast<tools::Long>(m_xRightIndent->denormalize( m_xRightIndent->get_value( FieldUnit::TWIP ) ) ) ); + m_aExampleWin.SetUpper( static_cast<sal_uInt16>(m_xTopDist->denormalize( m_xTopDist->get_value( FieldUnit::TWIP ) )) ); + m_aExampleWin.SetLower( static_cast<sal_uInt16>(m_xBottomDist->denormalize( m_xBottomDist->get_value( FieldUnit::TWIP ) )) ); + + int nPos = m_xLineDist->get_active(); + + switch ( nPos ) + { + case LLINESPACE_1: + case LLINESPACE_115: + case LLINESPACE_15: + case LLINESPACE_2: + case LLINESPACE_PROP: + case LLINESPACE_MIN: + case LLINESPACE_DURCH: + case LLINESPACE_FIX: + m_aExampleWin.SetLineSpace( static_cast<SvxPrevLineSpace>(nPos) ); + break; + } + m_aExampleWin.Invalidate(); +} + +void SvxStdParagraphTabPage::EnableRegisterMode() +{ + m_xRegisterCB->show(); +} + +void SvxStdParagraphTabPage::EnableContextualMode() +{ + m_xContextualCB->show(); +} + +IMPL_LINK(SvxStdParagraphTabPage, AutoHdl_Impl, weld::Toggleable&, rBox, void) +{ + bool bEnable = !rBox.get_active(); + m_xFLineLabel->set_sensitive(bEnable); + m_xFLineIndent->set_sensitive(bEnable); +} + +void SvxStdParagraphTabPage::EnableAutoFirstLine() +{ + m_xAutoCB->show(); +} + +void SvxStdParagraphTabPage::EnableAbsLineDist(tools::Long nMinTwip) +{ + m_xLineDist->append_text(sAbsDist); + nMinFixDist = nMinTwip; +} + +void SvxStdParagraphTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + +/* different bit represent call to different method of SvxStdParagraphTabPage + 0x0001 --->EnableRelativeMode() + 0x0002 --->EnableRegisterMode() + 0x0004 --->EnableAutoFirstLine() + 0x0008 --->EnableNegativeMode() + 0x0010 --->EnableContextualMode() + */ + const SfxUInt16Item* pPageWidthItem = aSet.GetItem<SfxUInt16Item>(SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH, false); + const SfxUInt32Item* pFlagSetItem = aSet.GetItem<SfxUInt32Item>(SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET, false); + const SfxUInt32Item* pLineDistItem = aSet.GetItem<SfxUInt32Item>(SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST, false); + + if (pPageWidthItem) + nWidth = pPageWidthItem->GetValue(); + + if (pFlagSetItem ) + { + if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 ) + EnableRelativeMode(); + + if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 ) + EnableRegisterMode(); + + if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 ) + EnableAutoFirstLine(); + } + + if(pLineDistItem) + EnableAbsLineDist(pLineDistItem->GetValue()); + + if (pFlagSetItem) + { + if (( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 ) + EnableNegativeMode(); + + if (( 0x0010 & pFlagSetItem->GetValue()) == 0x0010 ) + EnableContextualMode(); + } +} + +#define LASTLINEPOS_DEFAULT 0 +#define LASTLINEPOS_LEFT 1 + +#define LASTLINECOUNT_OLD 3 +#define LASTLINECOUNT_NEW 4 + +SvxParaAlignTabPage::SvxParaAlignTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/paragalignpage.ui", "ParaAlignPage", &rSet) + , m_xLeft(m_xBuilder->weld_radio_button("radioBTN_LEFTALIGN")) + , m_xRight(m_xBuilder->weld_radio_button("radioBTN_RIGHTALIGN")) + , m_xCenter(m_xBuilder->weld_radio_button("radioBTN_CENTERALIGN")) + , m_xJustify(m_xBuilder->weld_radio_button("radioBTN_JUSTIFYALIGN")) + , m_xLeftBottom(m_xBuilder->weld_label("labelST_LEFTALIGN_ASIAN")) + , m_xRightTop(m_xBuilder->weld_label("labelST_RIGHTALIGN_ASIAN")) + , m_xLastLineFT(m_xBuilder->weld_label("labelLB_LASTLINE")) + , m_xLastLineLB(m_xBuilder->weld_combo_box("comboLB_LASTLINE")) + , m_xExpandCB(m_xBuilder->weld_check_button("checkCB_EXPAND")) + , m_xSnapToGridCB(m_xBuilder->weld_check_button("checkCB_SNAP")) + , m_xExampleWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWN_EXAMPLE", m_aExampleWin)) + , m_xVertAlignFL(m_xBuilder->weld_widget("frameFL_VERTALIGN")) + , m_xVertAlignLB(m_xBuilder->weld_combo_box("comboLB_VERTALIGN")) + , m_xPropertiesFL(m_xBuilder->weld_widget("framePROPERTIES")) + , m_xTextDirectionLB(new svx::FrameDirectionListBox(m_xBuilder->weld_combo_box("comboLB_TEXTDIRECTION"))) +{ + SetExchangeSupport(); + + sal_uInt16 nLastLinePos = LASTLINEPOS_DEFAULT; + + if ( SvtCJKOptions::IsAsianTypographyEnabled() ) + { + m_xLeft->set_label(m_xLeftBottom->get_label()); + m_xRight->set_label(m_xRightTop->get_label()); + + OUString sLeft(m_xLeft->get_label()); + sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft ); + + if (m_xLastLineLB->get_count() == LASTLINECOUNT_OLD) + { + m_xLastLineLB->remove(0); + m_xLastLineLB->insert_text(0, sLeft); + } + else + nLastLinePos = LASTLINEPOS_LEFT; + } + + // remove "Default" or "Left" entry, depends on CJKOptions + if (m_xLastLineLB->get_count() == LASTLINECOUNT_NEW) + m_xLastLineLB->remove(nLastLinePos); + + Link<weld::Toggleable&, void> aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl ); + m_xLeft->connect_toggled(aLink); + m_xRight->connect_toggled(aLink); + m_xCenter->connect_toggled(aLink); + m_xJustify->connect_toggled(aLink); + m_xLastLineLB->connect_changed(LINK(this, SvxParaAlignTabPage, LastLineHdl_Impl)); + m_xTextDirectionLB->connect_changed(LINK(this, SvxParaAlignTabPage, TextDirectionHdl_Impl)); + + m_xTextDirectionLB->append(SvxFrameDirection::Environment, SvxResId(RID_SVXSTR_FRAMEDIR_SUPER)); + m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_LR_TB, SvxResId(RID_SVXSTR_FRAMEDIR_LTR)); + m_xTextDirectionLB->append(SvxFrameDirection::Horizontal_RL_TB, SvxResId(RID_SVXSTR_FRAMEDIR_RTL)); +} + +SvxParaAlignTabPage::~SvxParaAlignTabPage() +{ +} + +DeactivateRC SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +std::unique_ptr<SfxTabPage> SvxParaAlignTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxParaAlignTabPage>(pPage, pController, *rSet); +} + +bool SvxParaAlignTabPage::FillItemSet( SfxItemSet* rOutSet ) +{ + bool bModified = false; + + bool bAdj = false; + SvxAdjust eAdjust = SvxAdjust::Left; + + if (m_xLeft->get_active()) + { + eAdjust = SvxAdjust::Left; + bAdj = m_xLeft->get_saved_state() == TRISTATE_FALSE; + } + else if (m_xRight->get_active()) + { + eAdjust = SvxAdjust::Right; + bAdj = m_xRight->get_saved_state() == TRISTATE_FALSE; + } + else if (m_xCenter->get_active()) + { + eAdjust = SvxAdjust::Center; + bAdj = m_xCenter->get_saved_state() == TRISTATE_FALSE; + } + else if (m_xJustify->get_active()) + { + eAdjust = SvxAdjust::Block; + bAdj = m_xJustify->get_saved_state() == TRISTATE_FALSE || + m_xExpandCB->get_state_changed_from_saved() || + m_xLastLineLB->get_value_changed_from_saved(); + } + + sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST ); + + if (bAdj) + { + SvxAdjust eOneWord = m_xExpandCB->get_active() ? SvxAdjust::Block : SvxAdjust::Left; + + int nLBPos = m_xLastLineLB->get_active(); + SvxAdjust eLastBlock = SvxAdjust::Left; + if ( 1 == nLBPos ) + eLastBlock = SvxAdjust::Center; + else if ( 2 == nLBPos ) + eLastBlock = SvxAdjust::Block; + + SvxAdjustItem aAdj( static_cast<const SvxAdjustItem&>(GetItemSet().Get( _nWhich )) ); + aAdj.SetAdjust( eAdjust ); + aAdj.SetOneWord( eOneWord ); + aAdj.SetLastBlock( eLastBlock ); + rOutSet->Put( aAdj ); + bModified = true; + } + + if (m_xSnapToGridCB->get_state_changed_from_saved()) + { + rOutSet->Put(SvxParaGridItem(m_xSnapToGridCB->get_active(), GetWhich( SID_ATTR_PARA_SNAPTOGRID ))); + bModified = true; + } + + if (m_xVertAlignLB->get_value_changed_from_saved()) + { + rOutSet->Put(SvxParaVertAlignItem(static_cast<SvxParaVertAlignItem::Align>(m_xVertAlignLB->get_active()), GetWhich( SID_PARA_VERTALIGN ))); + bModified = true; + } + + if (m_xTextDirectionLB->get_visible()) + { + if (m_xTextDirectionLB->get_value_changed_from_saved()) + { + SvxFrameDirection eDir = m_xTextDirectionLB->get_active_id(); + rOutSet->Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) ); + bModified = true; + } + } + + return bModified; +} + +void SvxParaAlignTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + Reset( &rSet ); +} + +void SvxParaAlignTabPage::Reset( const SfxItemSet* rSet ) +{ + sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST ); + SfxItemState eItemState = rSet->GetItemState( _nWhich ); + + sal_Int32 nLBSelect = 0; + if ( eItemState >= SfxItemState::DEFAULT ) + { + const SvxAdjustItem& rAdj = static_cast<const SvxAdjustItem&>(rSet->Get( _nWhich )); + + switch ( rAdj.GetAdjust() /*!!! ask VB rAdj.GetLastBlock()*/ ) + { + case SvxAdjust::Left: m_xLeft->set_active(true); break; + + case SvxAdjust::Right: m_xRight->set_active(true); break; + + case SvxAdjust::Center: m_xCenter->set_active(true); break; + + case SvxAdjust::Block: m_xJustify->set_active(true); break; + default: ; //prevent warning + } + bool bEnable = m_xJustify->get_active(); + m_xLastLineFT->set_sensitive(bEnable); + m_xLastLineLB->set_sensitive(bEnable); + + switch(rAdj.GetLastBlock()) + { + case SvxAdjust::Left: nLBSelect = 0; break; + + case SvxAdjust::Center: nLBSelect = 1; break; + + case SvxAdjust::Block: nLBSelect = 2; break; + default: ; //prevent warning + } + m_xExpandCB->set_sensitive(bEnable && nLBSelect == 2); + m_xExpandCB->set_active(SvxAdjust::Block == rAdj.GetOneWord()); + } + else + { + m_xLeft->set_active(false); + m_xRight->set_active(false); + m_xCenter->set_active(false); + m_xJustify->set_active(false); + } + m_xLastLineLB->set_active(nLBSelect); + + sal_uInt16 nHtmlMode = GetHtmlMode_Impl(*rSet); + if(nHtmlMode & HTMLMODE_ON) + { + m_xLastLineLB->hide(); + m_xLastLineFT->hide(); + m_xExpandCB->hide(); + if(!(nHtmlMode & HTMLMODE_FULL_STYLES) ) + m_xJustify->set_sensitive(false); + m_xSnapToGridCB->hide(); + } + _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID); + eItemState = rSet->GetItemState( _nWhich ); + if ( eItemState >= SfxItemState::DEFAULT ) + { + const SvxParaGridItem& rSnap = static_cast<const SvxParaGridItem&>(rSet->Get( _nWhich )); + m_xSnapToGridCB->set_active(rSnap.GetValue()); + } + + _nWhich = GetWhich( SID_PARA_VERTALIGN ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + m_xVertAlignFL->show(); + + const SvxParaVertAlignItem& rAlign = static_cast<const SvxParaVertAlignItem&>(rSet->Get( _nWhich )); + + m_xVertAlignLB->set_active(static_cast<sal_Int32>(rAlign.GetValue())); + } + + _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION ); + //text direction + if( SfxItemState::DEFAULT <= rSet->GetItemState( _nWhich ) ) + { + const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>( rSet->Get( _nWhich ) ); + m_xTextDirectionLB->set_active_id(rFrameDirItem.GetValue()); + m_xTextDirectionLB->save_value(); + } + + m_xSnapToGridCB->save_state(); + m_xVertAlignLB->save_value(); + m_xLeft->save_state(); + m_xRight->save_state(); + m_xCenter->save_state(); + m_xJustify->save_state(); + m_xLastLineLB->save_value(); + m_xExpandCB->save_state(); + + UpdateExample_Impl(); +} + +void SvxParaAlignTabPage::ChangesApplied() +{ + m_xTextDirectionLB->save_value(); + m_xSnapToGridCB->save_state(); + m_xVertAlignLB->save_value(); + m_xLeft->save_state(); + m_xRight->save_state(); + m_xCenter->save_state(); + m_xJustify->save_state(); + m_xLastLineLB->save_value(); + m_xExpandCB->save_state(); +} + +IMPL_LINK_NOARG(SvxParaAlignTabPage, AlignHdl_Impl, weld::Toggleable&, void) +{ + bool bJustify = m_xJustify->get_active(); + m_xLastLineFT->set_sensitive(bJustify); + m_xLastLineLB->set_sensitive(bJustify); + bool bLastLineIsBlock = m_xLastLineLB->get_active() == 2; + m_xExpandCB->set_sensitive(bJustify && bLastLineIsBlock); + //set last line listbox to entry position 0 if not enabled + if (!m_xLastLineLB->get_sensitive()) + m_xLastLineLB->set_active(0); + //uncheck 'Expand ... word' when check box is not enabled + if (!m_xExpandCB->get_sensitive()) + m_xExpandCB->set_active(false); + UpdateExample_Impl(); +} + +IMPL_LINK_NOARG(SvxParaAlignTabPage, LastLineHdl_Impl, weld::ComboBox&, void) +{ + //fdo#41350 only enable 'Expand last word' if last line is also justified + bool bLastLineIsBlock = m_xLastLineLB->get_active() == 2; + m_xExpandCB->set_sensitive(bLastLineIsBlock); + //uncheck 'Expand ... word' when check box is not enabled + if (!m_xExpandCB->get_sensitive()) + m_xExpandCB->set_active(false); + UpdateExample_Impl(); +} + +IMPL_LINK_NOARG(SvxParaAlignTabPage, TextDirectionHdl_Impl, weld::ComboBox&, void) +{ + UpdateExample_Impl(); +} + +void SvxParaAlignTabPage::UpdateExample_Impl() +{ + if (m_xLeft->get_active()) + { + m_aExampleWin.EnableRTL(false); + m_aExampleWin.SetAdjust(SvxAdjust::Left); + m_aExampleWin.SetLastLine(SvxAdjust::Left); + } + else if (m_xRight->get_active()) + { + m_aExampleWin.EnableRTL(true); + m_aExampleWin.SetAdjust(SvxAdjust::Left); + m_aExampleWin.SetLastLine(SvxAdjust::Left); + } + else + { + SvxFrameDirection eDir = m_xTextDirectionLB->get_active_id(); + switch ( eDir ) + { + case SvxFrameDirection::Environment : + if ( !m_xRight->get_active() ) + m_aExampleWin.EnableRTL( AllSettings::GetLayoutRTL() ); + break; + case SvxFrameDirection::Horizontal_RL_TB : + if ( !m_xLeft->get_active() ) + m_aExampleWin.EnableRTL( true ); + break; + case SvxFrameDirection::Horizontal_LR_TB : + if ( !m_xRight->get_active() ) + m_aExampleWin.EnableRTL( false ); + break; + default: ; //prevent warning + } + if (m_xCenter->get_active()) + m_aExampleWin.SetAdjust( SvxAdjust::Center ); + else if (m_xJustify->get_active()) + { + m_aExampleWin.SetAdjust( SvxAdjust::Block ); + int nLBPos = m_xLastLineLB->get_active(); + if (nLBPos == 0) + m_aExampleWin.SetLastLine(SvxAdjust::Left); + else if (nLBPos == 1) + m_aExampleWin.SetLastLine(SvxAdjust::Center); + else if (nLBPos == 2) + m_aExampleWin.SetLastLine(SvxAdjust::Block); + } + } + + m_aExampleWin.Invalidate(); +} + +void SvxParaAlignTabPage::EnableJustifyExt() +{ + m_xLastLineFT->show(); + m_xLastLineLB->show(); + m_xExpandCB->show(); + if (SvtCJKOptions::IsAsianTypographyEnabled()) + m_xSnapToGridCB->show(); + +} + +void SvxParaAlignTabPage::PageCreated (const SfxAllItemSet& aSet) +{ + const SfxBoolItem* pBoolItem = aSet.GetItem<SfxBoolItem>(SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT, false); + if (pBoolItem && pBoolItem->GetValue()) + EnableJustifyExt(); +} + +std::unique_ptr<SfxTabPage> SvxExtParagraphTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxExtParagraphTabPage>(pPage, pController, *rSet); +} + +bool SvxExtParagraphTabPage::FillItemSet( SfxItemSet* rOutSet ) +{ + bool bModified = false; + sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE ); + const TriState eHyphenState = m_xHyphenBox->get_state(); + const SfxPoolItem* pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_HYPHENZONE ); + + if ( m_xHyphenBox->get_state_changed_from_saved() || + m_xHyphenNoCapsBox->get_state_changed_from_saved() || + m_xHyphenNoLastWordBox->get_state_changed_from_saved() || + m_xExtHyphenBeforeBox->get_value_changed_from_saved() || + m_xExtHyphenAfterBox->get_value_changed_from_saved() || + m_xMaxHyphenEdit->get_value_changed_from_saved() || + m_xMinWordLength->get_value_changed_from_saved() || + m_xHyphenZone->get_value_changed_from_saved() ) + { + SvxHyphenZoneItem aHyphen( + static_cast<const SvxHyphenZoneItem&>(GetItemSet().Get( _nWhich )) ); + aHyphen.SetHyphen( eHyphenState == TRISTATE_TRUE ); + aHyphen.SetNoCapsHyphenation(m_xHyphenNoCapsBox->get_state() == TRISTATE_TRUE); + aHyphen.SetNoLastWordHyphenation(m_xHyphenNoLastWordBox->get_state() == TRISTATE_TRUE); + + if ( eHyphenState == TRISTATE_TRUE ) + { + aHyphen.GetMinLead() = static_cast<sal_uInt8>(m_xExtHyphenBeforeBox->get_value()); + aHyphen.GetMinTrail() = static_cast<sal_uInt8>(m_xExtHyphenAfterBox->get_value()); + aHyphen.GetMinWordLength() = static_cast<sal_uInt8>(m_xMinWordLength->get_value()); + } + aHyphen.GetMaxHyphens() = static_cast<sal_uInt8>(m_xMaxHyphenEdit->get_value()); + + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + MapUnit eUnit = pPool->GetMetric( _nWhich ); + aHyphen.GetTextHyphenZone() = static_cast<sal_uInt16>(m_xHyphenZone->GetCoreValue(eUnit)); + + if ( !pOld || + *static_cast<const SvxHyphenZoneItem*>(pOld) != aHyphen || + m_xHyphenBox->get_state_changed_from_saved()) + { + rOutSet->Put( aHyphen ); + bModified = true; + } + } + + if (m_xPageNumBox->get_sensitive() + && (m_xPageNumBox->get_state_changed_from_saved() || m_xPagenumEdit->get_value_changed_from_saved())) + { + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_PAGENUM ); + + if (TRISTATE_TRUE == m_xPageNumBox->get_state() + && (!pOld || IsInvalidItem(pOld) + || static_cast<const SfxUInt16Item*>(pOld)->GetValue() != m_xPagenumEdit->get_value())) + { + SfxUInt16Item aPageNum(SID_ATTR_PARA_PAGENUM, + static_cast<sal_uInt16>(m_xPagenumEdit->get_value())); + rOutSet->Put( aPageNum ); + bModified = true; + } + else if (TRISTATE_FALSE == m_xPageNumBox->get_state() + && (pOld || IsInvalidItem(pOld))) + { + // need to tell sw to remove the item + rOutSet->DisableItem(SID_ATTR_PARA_PAGENUM); + bModified = true; + } + } + + // pagebreak + + TriState eState = m_xApplyCollBtn->get_state(); + bool bIsPageModel = false; + + OUString sPage; + if ( m_xApplyCollBtn->get_state_changed_from_saved() || + ( TRISTATE_TRUE == eState && + m_xApplyCollBox->get_value_changed_from_saved() ) ) + { + if ( eState == TRISTATE_TRUE ) + { + sPage = m_xApplyCollBox->get_active_text(); + bIsPageModel = !sPage.isEmpty(); + } + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_MODEL ); + + if ( !pOld || static_cast<const SvxPageModelItem*>(pOld)->GetValue() != sPage ) + { + rOutSet->Put( SvxPageModelItem( sPage, false, SID_ATTR_PARA_MODEL ) ); + bModified = true; + } + else + bIsPageModel = false; + } + else if(TRISTATE_TRUE == eState && m_xApplyCollBtn->get_sensitive()) + bIsPageModel = true; + else + rOutSet->Put( SvxPageModelItem( sPage, false, SID_ATTR_PARA_MODEL ) ); + + _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK ); + + if ( bIsPageModel ) + // if PageModel is turned on, always turn off PageBreak + rOutSet->Put( SvxFormatBreakItem( SvxBreak::NONE, _nWhich ) ); + else + { + eState = m_xPageBreakBox->get_state(); + SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, false); + + if ( (eModelState == SfxItemState::SET && TRISTATE_TRUE == m_xPageBreakBox->get_state()) || + m_xPageBreakBox->get_state_changed_from_saved() || + m_xBreakTypeLB->get_value_changed_from_saved() || + m_xBreakPositionLB->get_value_changed_from_saved() ) + { + const SvxFormatBreakItem rOldBreak( + static_cast<const SvxFormatBreakItem&>(GetItemSet().Get( _nWhich ))); + SvxFormatBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which()); + + switch ( eState ) + { + case TRISTATE_TRUE: + { + bool bBefore = m_xBreakPositionLB->get_active() == 0; + + if (m_xBreakTypeLB->get_active() == 0) + { + if ( bBefore ) + aBreak.SetValue( SvxBreak::PageBefore ); + else + aBreak.SetValue( SvxBreak::PageAfter ); + } + else + { + if ( bBefore ) + aBreak.SetValue( SvxBreak::ColumnBefore ); + else + aBreak.SetValue( SvxBreak::ColumnAfter ); + } + break; + } + + case TRISTATE_FALSE: + aBreak.SetValue( SvxBreak::NONE ); + break; + default: ; //prevent warning + } + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_PAGEBREAK ); + + if ( eState != m_xPageBreakBox->get_saved_state() || + !pOld || !( *static_cast<const SvxFormatBreakItem*>(pOld) == aBreak ) ) + { + bModified = true; + rOutSet->Put( aBreak ); + } + } + } + + // paragraph split + _nWhich = GetWhich( SID_ATTR_PARA_SPLIT ); + eState = m_xKeepTogetherBox->get_state(); + + if (m_xKeepTogetherBox->get_state_changed_from_saved()) + { + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_SPLIT ); + + if ( !pOld || static_cast<const SvxFormatSplitItem*>(pOld)->GetValue() != + ( eState == TRISTATE_FALSE ) ) + { + rOutSet->Put( SvxFormatSplitItem( eState == TRISTATE_FALSE, _nWhich ) ); + bModified = true; + } + } + + // keep paragraphs + _nWhich = GetWhich( SID_ATTR_PARA_KEEP ); + eState = m_xKeepParaBox->get_state(); + + if (m_xKeepParaBox->get_state_changed_from_saved()) + { + // if the status has changed, putting is necessary + rOutSet->Put( SvxFormatKeepItem( eState == TRISTATE_TRUE, _nWhich ) ); + bModified = true; + } + + // widows and orphans + _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS ); + eState = m_xWidowBox->get_state(); + + if ( m_xWidowBox->get_state_changed_from_saved() || + m_xWidowRowNo->get_value_changed_from_saved() ) + { + SvxWidowsItem rItem( eState == TRISTATE_TRUE ? + static_cast<sal_uInt8>(m_xWidowRowNo->get_value()) : 0, _nWhich ); + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_WIDOWS ); + + if ( m_xWidowBox->get_state_changed_from_saved() || !pOld || !( *static_cast<const SvxWidowsItem*>(pOld) == rItem ) ) + { + rOutSet->Put( rItem ); + bModified = true; + } + } + + _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS ); + eState = m_xOrphanBox->get_state(); + + if ( m_xOrphanBox->get_state_changed_from_saved() || + m_xOrphanRowNo->get_value_changed_from_saved() ) + { + SvxOrphansItem rItem( eState == TRISTATE_TRUE ? + static_cast<sal_uInt8>(m_xOrphanRowNo->get_value()) : 0, _nWhich ); + pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_ORPHANS ); + + if ( m_xOrphanBox->get_state_changed_from_saved() || + !pOld || + !( *static_cast<const SvxOrphansItem*>(pOld) == rItem ) ) + { + rOutSet->Put( rItem ); + bModified = true; + } + } + + return bModified; +} +void SvxExtParagraphTabPage::Reset( const SfxItemSet* rSet ) +{ + SfxItemPool* pPool = rSet->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + + // adjust metric + FieldUnit eFUnit = GetModuleFieldUnit( *rSet ); + + bool bApplyCharUnit = GetApplyCharUnit( *rSet ); + + if( SvtCJKOptions::IsAsianTypographyEnabled() && bApplyCharUnit ) + eFUnit = FieldUnit::CHAR; + + sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE ); + SfxItemState eItemState = rSet->GetItemState( _nWhich ); + + bool bItemAvailable = eItemState >= SfxItemState::DEFAULT; + bool bIsHyphen = false; + if( !bHtmlMode && bItemAvailable ) + { + const SvxHyphenZoneItem& rHyphen = + static_cast<const SvxHyphenZoneItem&>(rSet->Get( _nWhich )); + aHyphenState.bTriStateEnabled = false; + + bIsHyphen = rHyphen.IsHyphen(); + m_xHyphenBox->set_state(bIsHyphen ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xHyphenNoCapsBox->set_state(rHyphen.IsNoCapsHyphenation() ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xHyphenNoLastWordBox->set_state(rHyphen.IsNoLastWordHyphenation() ? TRISTATE_TRUE : TRISTATE_FALSE); + + m_xExtHyphenBeforeBox->set_value(rHyphen.GetMinLead()); + m_xExtHyphenAfterBox->set_value(rHyphen.GetMinTrail()); + m_xMaxHyphenEdit->set_value(rHyphen.GetMaxHyphens()); + m_xMinWordLength->set_value(rHyphen.GetMinWordLength()); + m_xHyphenZone->SetFieldUnit(eFUnit); + m_xHyphenZone->SetMetricValue(rHyphen.GetTextHyphenZone(), MapUnit::MapTwip); + } + else + { + m_xHyphenBox->set_state(TRISTATE_INDET); + m_xHyphenNoCapsBox->set_state(TRISTATE_INDET); + m_xHyphenNoLastWordBox->set_state(TRISTATE_INDET); + } + bool bEnable = bItemAvailable && bIsHyphen; + m_xHyphenNoCapsBox->set_sensitive(bEnable); + m_xHyphenNoLastWordBox->set_sensitive(bEnable); + m_xExtHyphenBeforeBox->set_sensitive(bEnable); + m_xExtHyphenAfterBox->set_sensitive(bEnable); + m_xBeforeText->set_sensitive(bEnable); + m_xAfterText->set_sensitive(bEnable); + m_xMaxHyphenLabel->set_sensitive(bEnable); + m_xMaxHyphenEdit->set_sensitive(bEnable); + m_xMinWordLabel->set_sensitive(bEnable); + m_xMinWordLength->set_sensitive(bEnable); + m_xHyphenZoneLabel->set_sensitive(bEnable); + m_xHyphenZone->set_sensitive(bEnable); + + switch (rSet->GetItemState(SID_ATTR_PARA_PAGENUM)) + { + case SfxItemState::SET: + { + aPageNumState.bTriStateEnabled = false; + m_xPageNumBox->set_state(TRISTATE_TRUE); + SfxUInt16Item const*const pItem(rSet->GetItem<SfxUInt16Item>(SID_ATTR_PARA_PAGENUM)); + const sal_uInt16 nPageNum(pItem->GetValue()); + m_xPagenumEdit->set_value(nPageNum); + break; + } + case SfxItemState::DONTCARE: + { + aPageNumState.bTriStateEnabled = true; + m_xPageNumBox->set_state(TRISTATE_INDET); + break; + } + case SfxItemState::UNKNOWN: + case SfxItemState::DEFAULT: + case SfxItemState::DISABLED: + { + aPageNumState.bTriStateEnabled = false; + m_xPageNumBox->set_state(TRISTATE_FALSE); + break; + } + default: + assert(false); // unexpected + break; + } + + if ( bPageBreak ) + { + // first handle PageModel + bool bIsPageModel = false; + eItemState = rSet->GetItemState( SID_ATTR_PARA_MODEL ); + + if ( eItemState >= SfxItemState::SET ) + { + aApplyCollState.bTriStateEnabled = false; + + const SvxPageModelItem& rModel = rSet->Get( SID_ATTR_PARA_MODEL ); + const OUString& aStr( rModel.GetValue() ); + + if (!aStr.isEmpty() && m_xApplyCollBox->find_text(aStr) != -1) + { + m_xApplyCollBox->set_active_text(aStr); + m_xApplyCollBtn->set_state(TRISTATE_TRUE); + bIsPageModel = true; + + m_xPageBreakBox->set_sensitive(true); + aPageBreakState.bTriStateEnabled = false; + m_xBreakTypeFT->set_sensitive(true); + m_xBreakTypeLB->set_sensitive(true); + m_xBreakPositionFT->set_sensitive(true); + m_xBreakPositionLB->set_sensitive(true); + m_xApplyCollBtn->set_sensitive(false); + m_xPageBreakBox->set_state(TRISTATE_TRUE); + + //select page break + m_xBreakTypeLB->set_active(0); + //select break before + m_xBreakPositionLB->set_active(0); + } + else + { + m_xApplyCollBox->set_active(-1); + m_xApplyCollBtn->set_state(TRISTATE_FALSE); + } + } + else if ( SfxItemState::DONTCARE == eItemState ) + { + aApplyCollState.bTriStateEnabled = true; + m_xApplyCollBtn->set_state(TRISTATE_INDET); + m_xApplyCollBox->set_active(-1); + } + else + { + m_xApplyCollBtn->set_sensitive(false); + m_xApplyCollBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(false); + m_xPageNumBox->set_sensitive(false); + } + + if ( !bIsPageModel ) + { + _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + const SvxFormatBreakItem& rPageBreak = + static_cast<const SvxFormatBreakItem&>(rSet->Get( _nWhich )); + + SvxBreak eBreak = rPageBreak.GetBreak(); + + // PageBreak not via CTRL-RETURN, + // then CheckBox can be freed + m_xPageBreakBox->set_sensitive(true); + aPageBreakState.bTriStateEnabled = false; + m_xBreakTypeFT->set_sensitive(true); + m_xBreakTypeLB->set_sensitive(true); + m_xBreakPositionFT->set_sensitive(true); + m_xBreakPositionLB->set_sensitive(true); + + m_xPageBreakBox->set_state(TRISTATE_TRUE); + + bool _bEnable = eBreak != SvxBreak::NONE && + eBreak != SvxBreak::ColumnBefore && + eBreak != SvxBreak::ColumnAfter; + m_xApplyCollBtn->set_sensitive(_bEnable); + if (!_bEnable) + { + m_xApplyCollBox->set_sensitive(_bEnable); + m_xPageNumBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(_bEnable); + } + + if ( eBreak == SvxBreak::NONE ) + m_xPageBreakBox->set_state(TRISTATE_FALSE); + + sal_Int32 nType = 0; // selection position in break type ListBox : Page + sal_Int32 nPosition = 0; // selection position in break position ListBox : Before + switch ( eBreak ) + { + case SvxBreak::PageBefore: + break; + case SvxBreak::PageAfter: + nPosition = 1; + break; + case SvxBreak::ColumnBefore: + nType = 1; + break; + case SvxBreak::ColumnAfter: + nType = 1; + nPosition = 1; + break; + default: ;//prevent warning + } + m_xBreakTypeLB->set_active(nType); + m_xBreakPositionLB->set_active(nPosition); + } + else if ( SfxItemState::DONTCARE == eItemState ) + m_xPageBreakBox->set_state(TRISTATE_INDET); + else + { + m_xPageBreakBox->set_sensitive(false); + m_xBreakTypeFT->set_sensitive(false); + m_xBreakTypeLB->set_sensitive(false); + m_xBreakPositionFT->set_sensitive(false); + m_xBreakPositionLB->set_sensitive(false); + } + } + + PageBreakPosHdl_Impl(*m_xBreakPositionLB); + PageBreakHdl(); + } + + _nWhich = GetWhich( SID_ATTR_PARA_KEEP ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + aKeepParaState.bTriStateEnabled = false; + const SvxFormatKeepItem& rKeep = + static_cast<const SvxFormatKeepItem&>(rSet->Get( _nWhich )); + + if ( rKeep.GetValue() ) + m_xKeepParaBox->set_state(TRISTATE_TRUE); + else + m_xKeepParaBox->set_state(TRISTATE_FALSE); + } + else if ( SfxItemState::DONTCARE == eItemState ) + m_xKeepParaBox->set_state(TRISTATE_INDET); + else + m_xKeepParaBox->set_sensitive(false); + + _nWhich = GetWhich( SID_ATTR_PARA_SPLIT ); + eItemState = rSet->GetItemState( _nWhich ); + + if ( eItemState >= SfxItemState::DEFAULT ) + { + const SvxFormatSplitItem& rSplit = + static_cast<const SvxFormatSplitItem&>(rSet->Get( _nWhich )); + aKeepTogetherState.bTriStateEnabled = false; + + if ( !rSplit.GetValue() ) + m_xKeepTogetherBox->set_state(TRISTATE_TRUE); + else + { + m_xKeepTogetherBox->set_state(TRISTATE_FALSE); + // default widows and orphans to enabled + m_xWidowBox->set_sensitive(true); + m_xOrphanBox->set_sensitive(true); + } + + // widows and orphans + _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS ); + SfxItemState eTmpState = rSet->GetItemState( _nWhich ); + + if ( eTmpState >= SfxItemState::DEFAULT ) + { + const SvxWidowsItem& rWidow = + static_cast<const SvxWidowsItem&>(rSet->Get( _nWhich )); + aWidowState.bTriStateEnabled = false; + const sal_uInt16 nLines = rWidow.GetValue(); + + bool _bEnable = nLines > 0; + m_xWidowRowNo->set_value(m_xWidowRowNo->normalize(nLines)); + m_xWidowBox->set_state(_bEnable ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xWidowRowNo->set_sensitive(_bEnable); + } + else if ( SfxItemState::DONTCARE == eTmpState ) + m_xWidowBox->set_state( TRISTATE_INDET ); + else + m_xWidowBox->set_sensitive(false); + + _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS ); + eTmpState = rSet->GetItemState( _nWhich ); + + if ( eTmpState >= SfxItemState::DEFAULT ) + { + const SvxOrphansItem& rOrphan = + static_cast<const SvxOrphansItem&>(rSet->Get( _nWhich )); + const sal_uInt16 nLines = rOrphan.GetValue(); + aOrphanState.bTriStateEnabled = false; + + bool _bEnable = nLines > 0; + m_xOrphanBox->set_state(_bEnable ? TRISTATE_TRUE : TRISTATE_FALSE); + m_xOrphanRowNo->set_value(m_xOrphanRowNo->normalize(nLines)); + m_xOrphanRowNo->set_sensitive(_bEnable); + m_xOrphanRowLabel->set_sensitive(_bEnable); + + } + else if ( SfxItemState::DONTCARE == eTmpState ) + m_xOrphanBox->set_state(TRISTATE_INDET); + else + m_xOrphanBox->set_sensitive(false); + aOrphanState.eState = m_xOrphanBox->get_state(); + } + else if ( SfxItemState::DONTCARE == eItemState ) + m_xKeepTogetherBox->set_state(TRISTATE_INDET); + else + m_xKeepTogetherBox->set_sensitive(false); + + // so that everything is enabled correctly + KeepTogetherHdl(); + WidowHdl(); + OrphanHdl(); + ChangesApplied(); +} +void SvxExtParagraphTabPage::ChangesApplied() +{ + m_xHyphenBox->save_state(); + m_xHyphenNoCapsBox->save_state(); + m_xHyphenNoLastWordBox->save_state(); + m_xExtHyphenBeforeBox->set_value(m_xExtHyphenBeforeBox->get_value()); + m_xExtHyphenAfterBox->set_value(m_xExtHyphenAfterBox->get_value()); + m_xMaxHyphenEdit->set_value(m_xMaxHyphenEdit->get_value()); + m_xMinWordLength->set_value(m_xMinWordLength->get_value()); + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + FieldUnit eUnit = + MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_PARA_HYPHENZONE ) ) ); + m_xHyphenZone->set_value(m_xHyphenZone->get_value(eUnit), eUnit); + m_xPageBreakBox->save_state(); + m_xBreakPositionLB->save_value(); + m_xBreakTypeLB->save_value(); + m_xApplyCollBtn->save_state(); + m_xApplyCollBox->save_value(); + m_xPageNumBox->save_state(); + m_xPagenumEdit->save_value(); + m_xKeepTogetherBox->save_state(); + m_xKeepParaBox->save_state(); + m_xWidowBox->save_state(); + m_xOrphanBox->save_state(); + m_xOrphanRowNo->save_value(); + m_xWidowRowNo->save_value(); +} + +DeactivateRC SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +void SvxExtParagraphTabPage::DisablePageBreak() +{ + bPageBreak = false; + m_xPageBreakBox->set_sensitive(false); + m_xBreakTypeLB->remove(0); + m_xBreakPositionFT->set_sensitive(false); + m_xBreakPositionLB->set_sensitive(false); + m_xApplyCollBtn->set_sensitive(false); + m_xApplyCollBox->set_sensitive(false); + m_xPageNumBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(false); +} + +SvxExtParagraphTabPage::SvxExtParagraphTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr) + : SfxTabPage(pPage, pController, "cui/ui/textflowpage.ui", "TextFlowPage", &rAttr) + , bPageBreak(true) + , bHtmlMode(false) + , nStdPos(0) + // Hyphenation + , m_xHyphenBox(m_xBuilder->weld_check_button("checkAuto")) + , m_xHyphenNoCapsBox(m_xBuilder->weld_check_button("checkNoCaps")) + , m_xHyphenNoLastWordBox(m_xBuilder->weld_check_button("checkNoLastWord")) + , m_xBeforeText(m_xBuilder->weld_label("labelLineBegin")) + , m_xExtHyphenBeforeBox(m_xBuilder->weld_spin_button("spinLineEnd")) + , m_xAfterText(m_xBuilder->weld_label("labelLineEnd")) + , m_xExtHyphenAfterBox(m_xBuilder->weld_spin_button("spinLineBegin")) + , m_xMaxHyphenLabel(m_xBuilder->weld_label("labelMaxNum")) + , m_xMaxHyphenEdit(m_xBuilder->weld_spin_button("spinMaxNum")) + , m_xMinWordLabel(m_xBuilder->weld_label("labelMinLen")) + , m_xMinWordLength(m_xBuilder->weld_spin_button("spinMinLen")) + , m_xHyphenZoneLabel(m_xBuilder->weld_label("labelHyphenZone")) + , m_xHyphenZone(new SvxRelativeField(m_xBuilder->weld_metric_spin_button("spinHyphenZone", FieldUnit::CM))) + //Page break + , m_xPageBreakBox(m_xBuilder->weld_check_button("checkInsert")) + , m_xBreakTypeFT(m_xBuilder->weld_label("labelType")) + , m_xBreakTypeLB(m_xBuilder->weld_combo_box("comboBreakType")) + , m_xBreakPositionFT(m_xBuilder->weld_label("labelPosition")) + , m_xBreakPositionLB(m_xBuilder->weld_combo_box("comboBreakPosition")) + , m_xApplyCollBtn(m_xBuilder->weld_check_button("checkPageStyle")) + , m_xApplyCollBox(m_xBuilder->weld_combo_box("comboPageStyle")) + , m_xPageNumBox(m_xBuilder->weld_check_button("labelPageNum")) + , m_xPagenumEdit(m_xBuilder->weld_spin_button("spinPageNumber")) + // Options + , m_xKeepTogetherBox(m_xBuilder->weld_check_button("checkSplitPara")) + , m_xKeepParaBox(m_xBuilder->weld_check_button("checkKeepPara")) + , m_xOrphanBox(m_xBuilder->weld_check_button("checkOrphan")) + , m_xOrphanRowNo(m_xBuilder->weld_spin_button("spinOrphan")) + , m_xOrphanRowLabel(m_xBuilder->weld_label("labelOrphan")) + , m_xWidowBox(m_xBuilder->weld_check_button("checkWidow")) + , m_xWidowRowNo(m_xBuilder->weld_spin_button("spinWidow")) + , m_xWidowRowLabel(m_xBuilder->weld_label("labelWidow")) +{ + // this page needs ExchangeSupport + SetExchangeSupport(); + + m_xHyphenBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, HyphenClickHdl_Impl)); + m_xPageBreakBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, PageBreakHdl_Impl)); + m_xKeepTogetherBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, KeepTogetherHdl_Impl)); + m_xWidowBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, WidowHdl_Impl)); + m_xOrphanBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, OrphanHdl_Impl)); + m_xApplyCollBtn->connect_toggled(LINK(this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl)); + m_xBreakTypeLB->connect_changed(LINK(this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl)); + m_xBreakPositionLB->connect_changed(LINK(this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl)); + m_xPageNumBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, PageNumBoxClickHdl_Impl)); + m_xKeepParaBox->connect_toggled(LINK(this, SvxExtParagraphTabPage, KeepParaBoxClickHdl_Impl)); + + if (SfxObjectShell* pSh = SfxObjectShell::Current()) + { + SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool(); + SfxStyleSheetBase* pStyle = pPool->First(SfxStyleFamily::Page); + OUString aStdName; + + // tdf139131 - sort page styles + m_xApplyCollBox->make_sorted(); + while( pStyle ) + { + if ( aStdName.isEmpty() ) + // first style == standard style + aStdName = pStyle->GetName(); + m_xApplyCollBox->append_text(pStyle->GetName()); + pStyle = pPool->Next(); + } + nStdPos = m_xApplyCollBox->find_text(aStdName); + } + + sal_uInt16 nHtmlMode = GetHtmlMode_Impl( rAttr ); + if ( !(nHtmlMode & HTMLMODE_ON) ) + return; + + bHtmlMode = true; + m_xHyphenBox->set_sensitive(false); + m_xHyphenNoCapsBox->set_sensitive(false); + m_xHyphenNoLastWordBox->set_sensitive(false); + m_xBeforeText->set_sensitive(false); + m_xExtHyphenBeforeBox->set_sensitive(false); + m_xAfterText->set_sensitive(false); + m_xExtHyphenAfterBox->set_sensitive(false); + m_xMaxHyphenLabel->set_sensitive(false); + m_xMaxHyphenEdit->set_sensitive(false); + m_xMinWordLabel->set_sensitive(false); + m_xMinWordLength->set_sensitive(false); + m_xHyphenZoneLabel->set_sensitive(false); + m_xHyphenZone->set_sensitive(false); + m_xPageNumBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(false); + // no column break in HTML + m_xBreakTypeLB->remove(1); +} + +SvxExtParagraphTabPage::~SvxExtParagraphTabPage() +{ +} + +void SvxExtParagraphTabPage::PageBreakHdl() +{ + switch (m_xPageBreakBox->get_state()) + { + case TRISTATE_TRUE: + m_xBreakTypeFT->set_sensitive(true); + m_xBreakTypeLB->set_sensitive(true); + m_xBreakPositionFT->set_sensitive(true); + m_xBreakPositionLB->set_sensitive(true); + + if (0 == m_xBreakTypeLB->get_active() && 0 == m_xBreakPositionLB->get_active()) + { + m_xApplyCollBtn->set_sensitive(true); + + bool bEnable = TRISTATE_TRUE == m_xApplyCollBtn->get_state() && + m_xApplyCollBox->get_count(); + m_xApplyCollBox->set_sensitive(bEnable); + if(!bHtmlMode) + { + m_xPageNumBox->set_sensitive(bEnable); + m_xPagenumEdit->set_sensitive(bEnable && m_xPageNumBox->get_state() == TRISTATE_TRUE); + } + } + break; + + case TRISTATE_FALSE: + case TRISTATE_INDET: + m_xApplyCollBtn->set_state(TRISTATE_FALSE); + m_xApplyCollBtn->set_sensitive(false); + m_xApplyCollBox->set_sensitive(false); + m_xPageNumBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(false); + m_xBreakTypeFT->set_sensitive(false); + m_xBreakTypeLB->set_sensitive(false); + m_xBreakPositionFT->set_sensitive(false); + m_xBreakPositionLB->set_sensitive(false); + break; + } +} + +IMPL_LINK(SvxExtParagraphTabPage, PageBreakHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aPageBreakState.ButtonToggled(rToggle); + PageBreakHdl(); +} + +void SvxExtParagraphTabPage::KeepTogetherHdl() +{ + bool bEnable = m_xKeepTogetherBox->get_state() == TRISTATE_FALSE; + m_xWidowBox->set_sensitive(bEnable); + m_xOrphanBox->set_sensitive(bEnable); +} + +IMPL_LINK(SvxExtParagraphTabPage, KeepTogetherHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aKeepTogetherState.ButtonToggled(rToggle); + KeepTogetherHdl(); +} + +void SvxExtParagraphTabPage::WidowHdl() +{ + switch (m_xWidowBox->get_state()) + { + case TRISTATE_TRUE: + m_xWidowRowNo->set_sensitive(true); + m_xWidowRowLabel->set_sensitive(true); + m_xKeepTogetherBox->set_sensitive(false); + break; + case TRISTATE_FALSE: + if (m_xOrphanBox->get_state() == TRISTATE_FALSE) + m_xKeepTogetherBox->set_sensitive(true); + [[fallthrough]]; + case TRISTATE_INDET: + m_xWidowRowNo->set_sensitive(false); + m_xWidowRowLabel->set_sensitive(false); + break; + } +} + +IMPL_LINK(SvxExtParagraphTabPage, WidowHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aWidowState.ButtonToggled(rToggle); + WidowHdl(); +} + +IMPL_LINK(SvxExtParagraphTabPage, OrphanHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aOrphanState.ButtonToggled(rToggle); + OrphanHdl(); +} + +void SvxExtParagraphTabPage::OrphanHdl() +{ + switch (m_xOrphanBox->get_state()) + { + case TRISTATE_TRUE: + m_xOrphanRowNo->set_sensitive(true); + m_xOrphanRowLabel->set_sensitive(true); + m_xKeepTogetherBox->set_sensitive(false); + break; + + case TRISTATE_FALSE: + if (m_xWidowBox->get_state() == TRISTATE_FALSE) + m_xKeepTogetherBox->set_sensitive(true); + [[fallthrough]]; + case TRISTATE_INDET: + m_xOrphanRowNo->set_sensitive(false); + m_xOrphanRowLabel->set_sensitive(false); + break; + } +} + +void SvxExtParagraphTabPage::HyphenClickHdl() +{ + bool bEnable = m_xHyphenBox->get_state() == TRISTATE_TRUE; + m_xHyphenNoCapsBox->set_sensitive(bEnable); + m_xHyphenNoLastWordBox->set_sensitive(bEnable); + m_xBeforeText->set_sensitive(bEnable); + m_xExtHyphenBeforeBox->set_sensitive(bEnable); + m_xAfterText->set_sensitive(bEnable); + m_xExtHyphenAfterBox->set_sensitive(bEnable); + m_xMaxHyphenLabel->set_sensitive(bEnable); + m_xMaxHyphenEdit->set_sensitive(bEnable); + m_xMinWordLabel->set_sensitive(bEnable); + m_xMinWordLength->set_sensitive(bEnable); + m_xHyphenZoneLabel->set_sensitive(bEnable); + m_xHyphenZone->set_sensitive(bEnable); + m_xHyphenBox->set_state(bEnable ? TRISTATE_TRUE : TRISTATE_FALSE); +} + +IMPL_LINK(SvxExtParagraphTabPage, HyphenClickHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aHyphenState.ButtonToggled(rToggle); + HyphenClickHdl(); +} + +void SvxExtParagraphTabPage::ApplyCollClickHdl() +{ + bool bEnable = false; + if (m_xApplyCollBtn->get_state() == TRISTATE_TRUE && m_xApplyCollBox->get_count()) + { + bEnable = true; + m_xApplyCollBox->set_active(nStdPos); + } + else + { + m_xApplyCollBox->set_active(-1); + } + m_xApplyCollBox->set_sensitive(bEnable); + if (!bHtmlMode) + { + m_xPageNumBox->set_sensitive(bEnable); + m_xPagenumEdit->set_sensitive(bEnable && m_xPageNumBox->get_state() == TRISTATE_TRUE); + } +} + +IMPL_LINK(SvxExtParagraphTabPage, ApplyCollClickHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aApplyCollState.ButtonToggled(rToggle); + ApplyCollClickHdl(); +} + +IMPL_LINK(SvxExtParagraphTabPage, PageBreakPosHdl_Impl, weld::ComboBox&, rListBox, void) +{ + if (0 == rListBox.get_active()) + { + m_xApplyCollBtn->set_sensitive(true); + + bool bEnable = m_xApplyCollBtn->get_state() == TRISTATE_TRUE && m_xApplyCollBox->get_count(); + + m_xApplyCollBox->set_sensitive(bEnable); + if (!bHtmlMode) + { + m_xPageNumBox->set_sensitive(bEnable); + m_xPagenumEdit->set_sensitive(bEnable && m_xPageNumBox->get_state() == TRISTATE_TRUE); + } + } + else if (1 == rListBox.get_active()) + { + m_xApplyCollBtn->set_state(TRISTATE_FALSE); + m_xApplyCollBtn->set_sensitive(false); + m_xApplyCollBox->set_sensitive(false); + m_xPageNumBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(false); + } +} + +IMPL_LINK(SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, weld::ComboBox&, rListBox, void) +{ + //column break or break after + int nBreakPos = m_xBreakPositionLB->get_active(); + if (rListBox.get_active() == 1 || 1 == nBreakPos) + { + m_xApplyCollBtn->set_state(TRISTATE_FALSE); + m_xApplyCollBtn->set_sensitive(false); + m_xApplyCollBox->set_sensitive(false); + m_xPageNumBox->set_sensitive(false); + m_xPagenumEdit->set_sensitive(false); + } + else + PageBreakPosHdl_Impl(*m_xBreakPositionLB); +} + +void SvxExtParagraphTabPage::PageNumBoxClickHdl() +{ + m_xPagenumEdit->set_sensitive(m_xPageNumBox->get_state() == TRISTATE_TRUE); +} + +IMPL_LINK(SvxExtParagraphTabPage, PageNumBoxClickHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aPageNumState.ButtonToggled(rToggle); + PageNumBoxClickHdl(); +} + +IMPL_LINK(SvxExtParagraphTabPage, KeepParaBoxClickHdl_Impl, weld::Toggleable&, rToggle, void) +{ + aKeepParaState.ButtonToggled(rToggle); +} + +void SvxExtParagraphTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxBoolItem* pDisablePageBreakItem = aSet.GetItem<SfxBoolItem>(SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK, false); + + if (pDisablePageBreakItem) + if ( pDisablePageBreakItem->GetValue()) + DisablePageBreak(); +} + +SvxAsianTabPage::SvxAsianTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) + : SfxTabPage(pPage, pController, "cui/ui/asiantypography.ui", "AsianTypography", &rSet) + , m_xForbiddenRulesCB(m_xBuilder->weld_check_button("checkForbidList")) + , m_xHangingPunctCB(m_xBuilder->weld_check_button("checkHangPunct")) + , m_xScriptSpaceCB(m_xBuilder->weld_check_button("checkApplySpacing")) +{ +} + +SvxAsianTabPage::~SvxAsianTabPage() +{ +} + +std::unique_ptr<SfxTabPage> SvxAsianTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxAsianTabPage>(pPage, pController, *rSet); +} + +WhichRangesContainer SvxAsianTabPage::GetRanges() +{ + return WhichRangesContainer(svl::Items<SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES>); +} + +bool SvxAsianTabPage::FillItemSet( SfxItemSet* rSet ) +{ + bool bRet = false; + SfxItemPool* pPool = rSet->GetPool(); + if (m_xScriptSpaceCB->get_sensitive() && m_xScriptSpaceCB->get_state_changed_from_saved()) + { + std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get( + pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone())); + pNewItem->SetValue(m_xScriptSpaceCB->get_active()); + rSet->Put(std::move(pNewItem)); + bRet = true; + } + if (m_xHangingPunctCB->get_sensitive() && m_xHangingPunctCB->get_state_changed_from_saved()) + { + std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get( + pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone())); + pNewItem->SetValue(m_xHangingPunctCB->get_active()); + rSet->Put(std::move(pNewItem)); + bRet = true; + } + if (m_xForbiddenRulesCB->get_sensitive() && m_xForbiddenRulesCB->get_state_changed_from_saved()) + { + std::unique_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get( + pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone())); + pNewItem->SetValue(m_xForbiddenRulesCB->get_active()); + rSet->Put(std::move(pNewItem)); + bRet = true; + } + return bRet; +} + +static void lcl_SetBox(const SfxItemSet& rSet, sal_uInt16 nSlotId, weld::CheckButton& rBox) +{ + sal_uInt16 _nWhich = rSet.GetPool()->GetWhich(nSlotId); + SfxItemState eState = rSet.GetItemState(_nWhich); + if( eState == SfxItemState::UNKNOWN || eState == SfxItemState::DISABLED ) + rBox.set_sensitive(false); + else if(eState >= SfxItemState::DEFAULT) + rBox.set_active(static_cast<const SfxBoolItem&>(rSet.Get(_nWhich)).GetValue()); + else + rBox.set_state(TRISTATE_INDET); + rBox.save_state(); +} + +void SvxAsianTabPage::Reset( const SfxItemSet* rSet ) +{ + lcl_SetBox(*rSet, SID_ATTR_PARA_FORBIDDEN_RULES, *m_xForbiddenRulesCB ); + lcl_SetBox(*rSet, SID_ATTR_PARA_HANGPUNCTUATION, *m_xHangingPunctCB ); + + //character distance not yet available + lcl_SetBox(*rSet, SID_ATTR_PARA_SCRIPTSPACE, *m_xScriptSpaceCB ); +} + +void SvxAsianTabPage::ChangesApplied() +{ + m_xForbiddenRulesCB->save_state(); + m_xHangingPunctCB->save_state(); + m_xScriptSpaceCB->save_state(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/swpossizetabpage.cxx b/cui/source/tabpages/swpossizetabpage.cxx new file mode 100644 index 000000000..e8a1e4eb9 --- /dev/null +++ b/cui/source/tabpages/swpossizetabpage.cxx @@ -0,0 +1,1878 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <cstddef> +#include <swpossizetabpage.hxx> +#include <svx/dlgutil.hxx> +#include <svx/anchorid.hxx> +#include <svl/intitem.hxx> +#include <svx/swframevalidation.hxx> +#include <sfx2/htmlmode.hxx> +#include <svx/svdview.hxx> +#include <svx/svdpagv.hxx> +#include <svx/swframeposstrings.hxx> +#include <svx/rectenum.hxx> +#include <sal/macros.h> +#include <com/sun/star/text/HoriOrientation.hpp> +#include <com/sun/star/text/VertOrientation.hpp> +#include <com/sun/star/text/RelOrientation.hpp> +#include <svx/svxids.hrc> +#include <svtools/unitconv.hxx> +#include <osl/diagnose.h> + +using namespace ::com::sun::star::text; + +namespace { + +enum class LB; + +} + +struct FrmMap +{ + SvxSwFramePosString::StringId eStrId; + SvxSwFramePosString::StringId eMirrorStrId; + short nAlign; + LB nLBRelations; +}; + +namespace { + +struct RelationMap +{ + SvxSwFramePosString::StringId eStrId; + SvxSwFramePosString::StringId eMirrorStrId; + LB nLBRelation; + short nRelation; +}; +struct StringIdPair_Impl +{ + SvxSwFramePosString::StringId eHori; + SvxSwFramePosString::StringId eVert; +}; + +enum class LB { + NONE = 0x000000, + Frame = 0x000001, // paragraph text area + PrintArea = 0x000002, // paragraph text area + indents + VertFrame = 0x000004, // vertical paragraph text area + VertPrintArea = 0x000008, // vertical paragraph text area + indents + RelFrameLeft = 0x000010, // left paragraph margin + RelFrameRight = 0x000020, // right paragraph margin + + RelPageLeft = 0x000040, // left page margin + RelPageRight = 0x000080, // right page margin + RelPageFrame = 0x000100, // complete page + RelPagePrintArea = 0x000200, // text area of page + + FlyRelPageLeft = 0x000400, // left frame margin + FlyRelPageRight = 0x000800, // right frame margin + FlyRelPageFrame = 0x001000, // complete frame + FlyRelPagePrintArea = 0x002000, // frame interior + + RelBase = 0x004000, // as char, relative to baseline + RelChar = 0x008000, // as char, relative to character + RelRow = 0x010000, // as char, relative to line + +// #i22305# + FlyVertFrame = 0x020000, // vertical entire frame + FlyVertPrintArea = 0x040000, // vertical frame text area + +// #i22341# + VertLine = 0x080000, // vertical text line + + RelPagePrintAreaBottom = 0x100000, // bottom of text area of page + RelPagePrintAreaTop = 0x200000, + + LAST = 0x400000 +}; + +} + +namespace o3tl { + template<> struct typed_flags<LB> : is_typed_flags<LB, 0x3fffff> {}; +} + +RelationMap const aRelationMap[] = +{ + {SvxSwFramePosString::FRAME, SvxSwFramePosString::FRAME, LB::Frame, RelOrientation::FRAME}, + {SvxSwFramePosString::PRTAREA, SvxSwFramePosString::PRTAREA, LB::PrintArea, RelOrientation::PRINT_AREA}, + {SvxSwFramePosString::REL_PG_LEFT, SvxSwFramePosString::MIR_REL_PG_LEFT, LB::RelPageLeft, RelOrientation::PAGE_LEFT}, + {SvxSwFramePosString::REL_PG_RIGHT, SvxSwFramePosString::MIR_REL_PG_RIGHT, LB::RelPageRight, RelOrientation::PAGE_RIGHT}, + {SvxSwFramePosString::REL_FRM_LEFT, SvxSwFramePosString::MIR_REL_FRM_LEFT, LB::RelFrameLeft, RelOrientation::FRAME_LEFT}, + {SvxSwFramePosString::REL_FRM_RIGHT, SvxSwFramePosString::MIR_REL_FRM_RIGHT, LB::RelFrameRight, RelOrientation::FRAME_RIGHT}, + {SvxSwFramePosString::REL_PG_FRAME, SvxSwFramePosString::REL_PG_FRAME, LB::RelPageFrame, RelOrientation::PAGE_FRAME}, + {SvxSwFramePosString::REL_PG_PRTAREA,SvxSwFramePosString::REL_PG_PRTAREA, LB::RelPagePrintArea, RelOrientation::PAGE_PRINT_AREA}, + {SvxSwFramePosString::REL_PG_PRTAREA_TOP,SvxSwFramePosString::REL_PG_PRTAREA_TOP, LB::RelPagePrintAreaTop, RelOrientation::PAGE_PRINT_AREA_TOP}, + {SvxSwFramePosString::REL_PG_PRTAREA_BOTTOM,SvxSwFramePosString::REL_PG_PRTAREA_BOTTOM, LB::RelPagePrintAreaBottom, RelOrientation::PAGE_PRINT_AREA_BOTTOM}, + {SvxSwFramePosString::REL_CHAR, SvxSwFramePosString::REL_CHAR, LB::RelChar, RelOrientation::CHAR}, + + {SvxSwFramePosString::FLY_REL_PG_LEFT, SvxSwFramePosString::FLY_MIR_REL_PG_LEFT, LB::FlyRelPageLeft, RelOrientation::PAGE_LEFT}, + {SvxSwFramePosString::FLY_REL_PG_RIGHT, SvxSwFramePosString::FLY_MIR_REL_PG_RIGHT, LB::FlyRelPageRight, RelOrientation::PAGE_RIGHT}, + {SvxSwFramePosString::FLY_REL_PG_FRAME, SvxSwFramePosString::FLY_REL_PG_FRAME, LB::FlyRelPageFrame, RelOrientation::PAGE_FRAME}, + {SvxSwFramePosString::FLY_REL_PG_PRTAREA, SvxSwFramePosString::FLY_REL_PG_PRTAREA, LB::FlyRelPagePrintArea, RelOrientation::PAGE_PRINT_AREA}, + + {SvxSwFramePosString::REL_BORDER, SvxSwFramePosString::REL_BORDER, LB::VertFrame, RelOrientation::FRAME}, + {SvxSwFramePosString::REL_PRTAREA, SvxSwFramePosString::REL_PRTAREA, LB::VertPrintArea, RelOrientation::PRINT_AREA}, + + // #i22305# + {SvxSwFramePosString::FLY_REL_PG_FRAME, SvxSwFramePosString::FLY_REL_PG_FRAME, LB::FlyVertFrame, RelOrientation::FRAME}, + {SvxSwFramePosString::FLY_REL_PG_PRTAREA, SvxSwFramePosString::FLY_REL_PG_PRTAREA, LB::FlyVertPrintArea, RelOrientation::PRINT_AREA}, + + // #i22341# + {SvxSwFramePosString::REL_LINE, SvxSwFramePosString::REL_LINE, LB::VertLine, RelOrientation::TEXT_LINE} +}; + +RelationMap const aAsCharRelationMap[] = +{ + {SvxSwFramePosString::REL_BASE, SvxSwFramePosString::REL_BASE, LB::RelBase, RelOrientation::FRAME}, + {SvxSwFramePosString::REL_CHAR, SvxSwFramePosString::REL_CHAR, LB::RelChar, RelOrientation::FRAME}, + {SvxSwFramePosString::REL_ROW, SvxSwFramePosString::REL_ROW, LB::RelRow, RelOrientation::FRAME} +}; + +/*-------------------------------------------------------------------- + Anchored at page + --------------------------------------------------------------------*/ + +constexpr auto HORI_PAGE_REL = LB::RelPageFrame|LB::RelPagePrintArea|LB::RelPageLeft| + LB::RelPageRight; + +FrmMap const aHPageMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, HORI_PAGE_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::MIR_RIGHT, HoriOrientation::RIGHT, HORI_PAGE_REL}, + {SvxSwFramePosString::CENTER_HORI,SvxSwFramePosString::CENTER_HORI, HoriOrientation::CENTER, HORI_PAGE_REL}, + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, HORI_PAGE_REL} +}; + +FrmMap const aHPageHtmlMap[] = +{ + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, LB::RelPageFrame} +}; + +#define VERT_PAGE_REL (LB::RelPageFrame|LB::RelPagePrintArea) + +FrmMap const aVPageMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, VERT_PAGE_REL}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::BOTTOM, VERT_PAGE_REL}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CENTER, VERT_PAGE_REL}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, VERT_PAGE_REL} +}; + +FrmMap const aVPageHtmlMap[] = +{ + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, LB::RelPageFrame} +}; + +/*-------------------------------------------------------------------- + Anchored at frame + --------------------------------------------------------------------*/ + +constexpr auto HORI_FRAME_REL = LB::FlyRelPageFrame|LB::FlyRelPagePrintArea| + LB::FlyRelPageLeft|LB::FlyRelPageRight; + +FrmMap const aHFrameMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, HORI_FRAME_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::MIR_RIGHT, HoriOrientation::RIGHT, HORI_FRAME_REL}, + {SvxSwFramePosString::CENTER_HORI, SvxSwFramePosString::CENTER_HORI, HoriOrientation::CENTER, HORI_FRAME_REL}, + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, HORI_FRAME_REL} +}; + +FrmMap const aHFlyHtmlMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, LB::FlyRelPageFrame}, + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, LB::FlyRelPageFrame} +}; + +// #i18732# - own vertical alignment map for to frame anchored objects +// #i22305# +#define VERT_FRAME_REL (LB::FlyVertFrame|LB::FlyVertPrintArea) + +FrmMap const aVFrameMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, VERT_FRAME_REL}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::BOTTOM, VERT_FRAME_REL}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CENTER, VERT_FRAME_REL}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, VERT_FRAME_REL} +}; + +FrmMap const aVFlyHtmlMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, LB::FlyVertFrame}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, LB::FlyVertFrame} +}; + +FrmMap const aVMultiSelectionMap[] = +{ + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, LB::NONE} +}; +FrmMap const aHMultiSelectionMap[] = +{ + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::FROMLEFT, HoriOrientation::NONE, LB::NONE} +}; + +/*-------------------------------------------------------------------- + Anchored at paragraph + --------------------------------------------------------------------*/ + +constexpr auto HORI_PARA_REL = LB::Frame|LB::PrintArea|LB::RelPageLeft|LB::RelPageRight| + LB::RelPageFrame|LB::RelPagePrintArea|LB::RelFrameLeft| + LB::RelFrameRight; + +FrmMap const aHParaMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, HORI_PARA_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::MIR_RIGHT, HoriOrientation::RIGHT, HORI_PARA_REL}, + {SvxSwFramePosString::CENTER_HORI, SvxSwFramePosString::CENTER_HORI, HoriOrientation::CENTER, HORI_PARA_REL}, + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, HORI_PARA_REL} +}; + +#define HTML_HORI_PARA_REL (LB::Frame|LB::PrintArea) + +FrmMap const aHParaHtmlMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::LEFT, HoriOrientation::LEFT, HTML_HORI_PARA_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::RIGHT, HoriOrientation::RIGHT, HTML_HORI_PARA_REL} +}; + +FrmMap const aHParaHtmlAbsMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, HTML_HORI_PARA_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::MIR_RIGHT, HoriOrientation::RIGHT, HTML_HORI_PARA_REL} +}; + + +constexpr auto VERT_PARA_REL = LB::VertFrame|LB::VertPrintArea| + LB::RelPageFrame|LB::RelPagePrintArea| LB::RelPagePrintAreaTop |LB::RelPagePrintAreaBottom; + +FrmMap const aVParaMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, VERT_PARA_REL}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::BOTTOM, VERT_PARA_REL}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CENTER, VERT_PARA_REL}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, VERT_PARA_REL} +}; + +FrmMap const aVParaHtmlMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, LB::VertPrintArea} +}; + +/*-------------------------------------------------------------------- + Anchored at character + --------------------------------------------------------------------*/ + +constexpr auto HORI_CHAR_REL = LB::Frame|LB::PrintArea|LB::RelPageLeft|LB::RelPageRight| + LB::RelPageFrame|LB::RelPagePrintArea|LB::RelFrameLeft| + LB::RelFrameRight|LB::RelChar; + +static FrmMap aHCharMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, HORI_CHAR_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::MIR_RIGHT, HoriOrientation::RIGHT, HORI_CHAR_REL}, + {SvxSwFramePosString::CENTER_HORI, SvxSwFramePosString::CENTER_HORI, HoriOrientation::CENTER, HORI_CHAR_REL}, + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, HORI_CHAR_REL} +}; + +#define HTML_HORI_CHAR_REL (LB::Frame|LB::PrintArea|LB::RelChar) + +static FrmMap aHCharHtmlMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::LEFT, HoriOrientation::LEFT, HTML_HORI_CHAR_REL}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::RIGHT, HoriOrientation::RIGHT, HTML_HORI_CHAR_REL} +}; + +static FrmMap aHCharHtmlAbsMap[] = +{ + {SvxSwFramePosString::LEFT, SvxSwFramePosString::MIR_LEFT, HoriOrientation::LEFT, LB::PrintArea|LB::RelChar}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::MIR_RIGHT, HoriOrientation::RIGHT, LB::PrintArea}, + {SvxSwFramePosString::FROMLEFT, SvxSwFramePosString::MIR_FROMLEFT, HoriOrientation::NONE, LB::RelPageFrame} +}; + +// #i18732# - allow vertical alignment at page areas +// #i22341# - handle <LB::RelChar> on its own +constexpr auto VERT_CHAR_REL = LB::VertFrame|LB::VertPrintArea| + LB::RelPageFrame|LB::RelPagePrintArea|LB::RelPagePrintAreaBottom; + +static FrmMap aVCharMap[] = +{ + // #i22341# + // introduce mappings for new vertical alignment at top of line <LB::VertLine> + // and correct mapping for vertical alignment at character for position <FROM_BOTTOM> + // Note: because of these adjustments the map becomes ambiguous in its values + // <eStrId>/<eMirrorStrId> and <nAlign>. These ambiguities are considered + // in the methods <SwFrmPage::FillRelLB(..)>, <SwFrmPage::GetAlignment(..)> + // and <SwFrmPage::FillPosLB(..)> + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, VERT_CHAR_REL|LB::RelChar}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::BOTTOM, VERT_CHAR_REL|LB::RelChar}, + {SvxSwFramePosString::BELOW, SvxSwFramePosString::BELOW, VertOrientation::CHAR_BOTTOM, LB::RelChar}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CENTER, VERT_CHAR_REL|LB::RelChar}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMTOP, VertOrientation::NONE, VERT_CHAR_REL}, + {SvxSwFramePosString::FROMBOTTOM, SvxSwFramePosString::FROMBOTTOM, VertOrientation::NONE, LB::RelChar|LB::VertLine}, + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::LINE_TOP, LB::VertLine}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::LINE_BOTTOM, LB::VertLine}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::LINE_CENTER, LB::VertLine} +}; + + +FrmMap const aVCharHtmlMap[] = +{ + {SvxSwFramePosString::BELOW, SvxSwFramePosString::BELOW, VertOrientation::CHAR_BOTTOM, LB::RelChar} +}; + +FrmMap const aVCharHtmlAbsMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, LB::RelChar}, + {SvxSwFramePosString::BELOW, SvxSwFramePosString::BELOW, VertOrientation::CHAR_BOTTOM, LB::RelChar} +}; +/*-------------------------------------------------------------------- + anchored as character + --------------------------------------------------------------------*/ + +FrmMap const aVAsCharMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, LB::RelBase}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::BOTTOM, LB::RelBase}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CENTER, LB::RelBase}, + + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::CHAR_TOP, LB::RelChar}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::CHAR_BOTTOM, LB::RelChar}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CHAR_CENTER, LB::RelChar}, + + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::LINE_TOP, LB::RelRow}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::LINE_BOTTOM, LB::RelRow}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::LINE_CENTER, LB::RelRow}, + + {SvxSwFramePosString::FROMBOTTOM, SvxSwFramePosString::FROMBOTTOM, VertOrientation::NONE, LB::RelBase} +}; + +FrmMap const aVAsCharHtmlMap[] = +{ + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::TOP, LB::RelBase}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::CENTER, LB::RelBase}, + + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::CHAR_TOP, LB::RelChar}, + + {SvxSwFramePosString::TOP, SvxSwFramePosString::TOP, VertOrientation::LINE_TOP, LB::RelRow}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::BOTTOM, VertOrientation::LINE_BOTTOM, LB::RelRow}, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_VERT, VertOrientation::LINE_CENTER, LB::RelRow} +}; + +static std::size_t lcl_GetFrmMapCount(const FrmMap* pMap) +{ + if( !pMap ) + return 0; + + if( pMap == aVParaHtmlMap ) + return std::size(aVParaHtmlMap); + if( pMap == aVAsCharHtmlMap ) + return std::size( aVAsCharHtmlMap ); + if( pMap == aHParaHtmlMap ) + return std::size( aHParaHtmlMap ); + if( pMap == aHParaHtmlAbsMap ) + return std::size( aHParaHtmlAbsMap ); + if( pMap == aVPageMap ) + return std::size( aVPageMap ); + if( pMap == aVPageHtmlMap ) + return std::size( aVPageHtmlMap ); + if( pMap == aVAsCharMap ) + return std::size( aVAsCharMap ); + if( pMap == aVParaMap ) + return std::size( aVParaMap ); + if( pMap == aHParaMap ) + return std::size( aHParaMap ); + if( pMap == aHFrameMap ) + return std::size( aHFrameMap ); + if( pMap == aVFrameMap ) + return std::size( aVFrameMap ); + if( pMap == aHCharMap ) + return std::size( aHCharMap ); + if( pMap == aHCharHtmlMap ) + return std::size( aHCharHtmlMap ); + if( pMap == aHCharHtmlAbsMap ) + return std::size( aHCharHtmlAbsMap ); + if( pMap == aVCharMap ) + return std::size( aVCharMap ); + if( pMap == aVCharHtmlMap ) + return std::size( aVCharHtmlMap ); + if( pMap == aVCharHtmlAbsMap ) + return std::size( aVCharHtmlAbsMap ); + if( pMap == aHPageHtmlMap ) + return std::size( aHPageHtmlMap ); + if( pMap == aHFlyHtmlMap ) + return std::size( aHFlyHtmlMap ); + if( pMap == aVFlyHtmlMap ) + return std::size( aVFlyHtmlMap ); + if( pMap == aVMultiSelectionMap ) + return std::size( aVMultiSelectionMap ); + if( pMap == aHMultiSelectionMap ) + return std::size( aHMultiSelectionMap ); + return std::size(aHPageMap); +} + +static SvxSwFramePosString::StringId lcl_ChangeResIdToVerticalOrRTL( + SvxSwFramePosString::StringId eStringId, bool bVertical, bool bRTL) +{ + //special handling of STR_FROMLEFT + if(SvxSwFramePosString::FROMLEFT == eStringId) + { + eStringId = bVertical ? + bRTL ? SvxSwFramePosString::FROMBOTTOM : SvxSwFramePosString::FROMTOP : + bRTL ? SvxSwFramePosString::FROMRIGHT : SvxSwFramePosString::FROMLEFT; + return eStringId; + } + if(bVertical) + { + //exchange horizontal strings with vertical strings and vice versa + static const StringIdPair_Impl aHoriIds[] = + { + {SvxSwFramePosString::LEFT, SvxSwFramePosString::TOP}, + {SvxSwFramePosString::RIGHT, SvxSwFramePosString::BOTTOM}, + {SvxSwFramePosString::CENTER_HORI, SvxSwFramePosString::CENTER_VERT}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMRIGHT}, + {SvxSwFramePosString::REL_PG_LEFT, SvxSwFramePosString::REL_PG_TOP}, + {SvxSwFramePosString::REL_PG_RIGHT, SvxSwFramePosString::REL_PG_BOTTOM} , + {SvxSwFramePosString::REL_FRM_LEFT, SvxSwFramePosString::REL_FRM_TOP}, + {SvxSwFramePosString::REL_FRM_RIGHT, SvxSwFramePosString::REL_FRM_BOTTOM} + }; + static const StringIdPair_Impl aVertIds[] = + { + {SvxSwFramePosString::TOP, SvxSwFramePosString::RIGHT}, + {SvxSwFramePosString::BOTTOM, SvxSwFramePosString::LEFT }, + {SvxSwFramePosString::CENTER_VERT, SvxSwFramePosString::CENTER_HORI}, + {SvxSwFramePosString::FROMTOP, SvxSwFramePosString::FROMRIGHT }, + {SvxSwFramePosString::REL_PG_TOP, SvxSwFramePosString::REL_PG_LEFT }, + {SvxSwFramePosString::REL_PG_BOTTOM, SvxSwFramePosString::REL_PG_RIGHT } , + {SvxSwFramePosString::REL_FRM_TOP, SvxSwFramePosString::REL_FRM_LEFT }, + {SvxSwFramePosString::REL_FRM_BOTTOM, SvxSwFramePosString::REL_FRM_RIGHT } + }; + for(const auto &a : aHoriIds) + { + if(a.eHori == eStringId) + { + eStringId = a.eVert; + return eStringId; + } + } + for(const auto &a : aVertIds) + { + if(a.eHori == eStringId) + { + eStringId = a.eVert; + break; + } + } + } + return eStringId; +} +// #i22341# - helper method in order to determine all possible +// listbox relations in a relation map for a given relation +static LB lcl_GetLBRelationsForRelations( const sal_uInt16 _nRel ) +{ + LB nLBRelations = LB::NONE; + + for (RelationMap const & nRelMapPos : aRelationMap) + { + if ( nRelMapPos.nRelation == _nRel ) + { + nLBRelations |= nRelMapPos.nLBRelation; + } + } + + return nLBRelations; +} + +// #i22341# - helper method on order to determine all possible +// listbox relations in a relation map for a given string ID +static LB lcl_GetLBRelationsForStrID(const FrmMap* _pMap, + const SvxSwFramePosString::StringId _eStrId, + const bool _bUseMirrorStr ) +{ + LB nLBRelations = LB::NONE; + + std::size_t nRelMapSize = lcl_GetFrmMapCount( _pMap ); + for ( std::size_t nRelMapPos = 0; nRelMapPos < nRelMapSize; ++nRelMapPos ) + { + if ( ( !_bUseMirrorStr && _pMap[nRelMapPos].eStrId == _eStrId ) || + ( _bUseMirrorStr && _pMap[nRelMapPos].eMirrorStrId == _eStrId ) ) + { + nLBRelations |= _pMap[nRelMapPos].nLBRelations; + } + } + + return nLBRelations; +} + +SvxSwPosSizeTabPage::SvxSwPosSizeTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/swpossizepage.ui", "SwPosSizePage", &rInAttrs) + , m_pVMap(nullptr) + , m_pHMap(nullptr) + , m_pSdrView(nullptr) + , m_nOldH(HoriOrientation::CENTER) + , m_nOldHRel(RelOrientation::FRAME) + , m_nOldV(VertOrientation::TOP) + , m_nOldVRel(RelOrientation::PRINT_AREA) + , m_fWidthHeightRatio(1.0) + , m_bHtmlMode(false) + , m_bIsVerticalFrame(false) + , m_bPositioningDisabled(false) + , m_bIsMultiSelection(false) + , m_bIsInRightToLeft(false) + , m_nProtectSizeState(TRISTATE_FALSE) + , m_xWidthMF(m_xBuilder->weld_metric_spin_button("width", FieldUnit::CM)) + , m_xHeightMF(m_xBuilder->weld_metric_spin_button("height", FieldUnit::CM)) + , m_xKeepRatioCB(m_xBuilder->weld_check_button("ratio")) + , m_xToPageRB(m_xBuilder->weld_radio_button("topage")) + , m_xToParaRB(m_xBuilder->weld_radio_button("topara")) + , m_xToCharRB(m_xBuilder->weld_radio_button("tochar")) + , m_xAsCharRB(m_xBuilder->weld_radio_button("aschar")) + , m_xToFrameRB(m_xBuilder->weld_radio_button("toframe")) + , m_xPositionCB(m_xBuilder->weld_check_button("pos")) + , m_xSizeCB(m_xBuilder->weld_check_button("size")) + , m_xPosFrame(m_xBuilder->weld_widget("posframe")) + , m_xHoriFT(m_xBuilder->weld_label("horiposft")) + , m_xHoriLB(m_xBuilder->weld_combo_box("horipos")) + , m_xHoriByFT(m_xBuilder->weld_label("horibyft")) + , m_xHoriByMF(m_xBuilder->weld_metric_spin_button("byhori", FieldUnit::CM)) + , m_xHoriToFT(m_xBuilder->weld_label("horitoft")) + , m_xHoriToLB(m_xBuilder->weld_combo_box("horianchor")) + , m_xHoriMirrorCB(m_xBuilder->weld_check_button("mirror")) + , m_xVertFT(m_xBuilder->weld_label("vertposft")) + , m_xVertLB(m_xBuilder->weld_combo_box("vertpos")) + , m_xVertByFT(m_xBuilder->weld_label("vertbyft")) + , m_xVertByMF(m_xBuilder->weld_metric_spin_button("byvert", FieldUnit::CM)) + , m_xVertToFT(m_xBuilder->weld_label("verttoft")) + , m_xVertToLB(m_xBuilder->weld_combo_box("vertanchor")) + , m_xFollowCB(m_xBuilder->weld_check_button("followtextflow")) + , m_xExampleWN(new weld::CustomWeld(*m_xBuilder, "preview", m_aExampleWN)) +{ + setOptimalFrmWidth(); + setOptimalRelWidth(); + + FieldUnit eDlgUnit = GetModuleFieldUnit( rInAttrs ); + SetFieldUnit(*m_xHoriByMF, eDlgUnit, true); + SetFieldUnit(*m_xVertByMF, eDlgUnit, true); + SetFieldUnit(*m_xWidthMF , eDlgUnit, true); + SetFieldUnit(*m_xHeightMF, eDlgUnit, true); + + SetExchangeSupport(); + + Link<weld::Widget&,void> aLk3 = LINK(this, SvxSwPosSizeTabPage, RangeModifyHdl); + m_xWidthMF->connect_focus_out(aLk3); + m_xHeightMF->connect_focus_out(aLk3); + m_xHoriByMF->connect_focus_out(aLk3); + m_xVertByMF->connect_focus_out(aLk3); + m_xFollowCB->connect_toggled(LINK(this, SvxSwPosSizeTabPage, RangeModifyClickHdl)); + + Link<weld::MetricSpinButton&,void> aLk = LINK(this, SvxSwPosSizeTabPage, ModifyHdl); + m_xWidthMF->connect_value_changed( aLk ); + m_xHeightMF->connect_value_changed( aLk ); + m_xHoriByMF->connect_value_changed( aLk ); + m_xVertByMF->connect_value_changed( aLk ); + + Link<weld::Toggleable&,void> aLk2 = LINK(this, SvxSwPosSizeTabPage, AnchorTypeHdl); + m_xToPageRB->connect_toggled( aLk2 ); + m_xToParaRB->connect_toggled( aLk2 ); + m_xToCharRB->connect_toggled( aLk2 ); + m_xAsCharRB->connect_toggled( aLk2 ); + m_xToFrameRB->connect_toggled( aLk2 ); + + m_xHoriLB->connect_changed(LINK(this, SvxSwPosSizeTabPage, PosHdl)); + m_xVertLB->connect_changed(LINK(this, SvxSwPosSizeTabPage, PosHdl)); + + m_xHoriToLB->connect_changed(LINK(this, SvxSwPosSizeTabPage, RelHdl)); + m_xVertToLB->connect_changed(LINK(this, SvxSwPosSizeTabPage, RelHdl)); + + m_xHoriMirrorCB->connect_toggled(LINK(this, SvxSwPosSizeTabPage, MirrorHdl)); + m_xPositionCB->connect_toggled(LINK(this, SvxSwPosSizeTabPage, ProtectHdl)); +} + +SvxSwPosSizeTabPage::~SvxSwPosSizeTabPage() +{ + m_xWidthMF.reset(); + m_xHeightMF.reset(); + m_xHoriByMF.reset(); + m_xVertByMF.reset(); +} + +namespace +{ + struct FrmMaps + { + FrmMap const *pMap; + size_t nCount; + }; +} + +void SvxSwPosSizeTabPage::setOptimalFrmWidth() +{ + static const FrmMaps aMaps[] = { + { aHPageMap, std::size(aHPageMap) }, + { aHPageHtmlMap, std::size(aHPageHtmlMap) }, + { aVPageMap, std::size(aVPageMap) }, + { aVPageHtmlMap, std::size(aVPageHtmlMap) }, + { aHFrameMap, std::size(aHFrameMap) }, + { aHFlyHtmlMap, std::size(aHFlyHtmlMap) }, + { aVFrameMap, std::size(aVFrameMap) }, + { aVFlyHtmlMap, std::size(aVFlyHtmlMap) }, + { aHParaMap, std::size(aHParaMap) }, + { aHParaHtmlMap, std::size(aHParaHtmlMap) }, + { aHParaHtmlAbsMap, std::size(aHParaHtmlAbsMap) }, + { aVParaMap, std::size(aVParaMap) }, + { aVParaHtmlMap, std::size(aVParaHtmlMap) }, + { aHCharMap, std::size(aHCharMap) }, + { aHCharHtmlMap, std::size(aHCharHtmlMap) }, + { aHCharHtmlAbsMap, std::size(aHCharHtmlAbsMap) }, + { aVCharMap, std::size(aVCharMap) }, + { aVCharHtmlMap, std::size(aVCharHtmlMap) }, + { aVCharHtmlAbsMap, std::size(aVCharHtmlAbsMap) }, + { aVAsCharMap, std::size(aVAsCharMap) }, + { aVAsCharHtmlMap, std::size(aVAsCharHtmlMap) } + }; + + std::vector<SvxSwFramePosString::StringId> aFrames; + for (const FrmMaps& aMap : aMaps) + { + for (size_t j = 0; j < aMap.nCount; ++j) + { + aFrames.push_back(aMap.pMap[j].eStrId); + aFrames.push_back(aMap.pMap[j].eMirrorStrId); + } + } + + std::sort(aFrames.begin(), aFrames.end()); + aFrames.erase(std::unique(aFrames.begin(), aFrames.end()), aFrames.end()); + + for (auto const& frame : aFrames) + { + m_xHoriLB->append_text(SvxSwFramePosString::GetString(frame)); + } + + Size aBiggest(m_xHoriLB->get_preferred_size()); + m_xHoriLB->set_size_request(aBiggest.Width(), -1); + m_xVertLB->set_size_request(aBiggest.Width(), -1); + m_xHoriLB->clear(); +} + +namespace +{ + struct RelationMaps + { + RelationMap const *pMap; + size_t nCount; + }; +} + +void SvxSwPosSizeTabPage::setOptimalRelWidth() +{ + static const RelationMaps aMaps[] = { + { aRelationMap, std::size(aRelationMap) }, + { aAsCharRelationMap, std::size(aAsCharRelationMap) } + }; + + std::vector<SvxSwFramePosString::StringId> aRels; + for (const RelationMaps& aMap : aMaps) + { + for (size_t j = 0; j < aMap.nCount; ++j) + { + aRels.push_back(aMap.pMap[j].eStrId); + aRels.push_back(aMap.pMap[j].eMirrorStrId); + } + } + + std::sort(aRels.begin(), aRels.end()); + aRels.erase(std::unique(aRels.begin(), aRels.end()), aRels.end()); + + for (auto const& elem : aRels) + { + m_xHoriLB->append_text(SvxSwFramePosString::GetString(elem)); + } + + Size aBiggest(m_xHoriLB->get_preferred_size()); + m_xHoriLB->set_size_request(aBiggest.Width(), -1); + m_xVertLB->set_size_request(aBiggest.Width(), -1); + m_xHoriLB->clear(); +} + +std::unique_ptr<SfxTabPage> SvxSwPosSizeTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxSwPosSizeTabPage>(pPage, pController, *rSet); +} + +WhichRangesContainer SvxSwPosSizeTabPage::GetRanges() +{ + static const WhichRangesContainer ranges(svl::Items< + SID_ATTR_TRANSFORM_POS_X, SID_ATTR_TRANSFORM_POS_Y, + SID_ATTR_TRANSFORM_WIDTH, SID_ATTR_TRANSFORM_SIZE_POINT, + SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_INTERN, + SID_ATTR_TRANSFORM_AUTOWIDTH, SID_ATTR_TRANSFORM_VERT_ORIENT, + SID_HTML_MODE, SID_HTML_MODE, + SID_SW_FOLLOW_TEXT_FLOW, SID_SW_FOLLOW_TEXT_FLOW, + SID_ATTR_TRANSFORM_HORI_POSITION, SID_ATTR_TRANSFORM_VERT_POSITION + >); + return ranges; +} + +bool SvxSwPosSizeTabPage::FillItemSet( SfxItemSet* rSet) +{ + bool bAnchorChanged = false; + RndStdIds nAnchor = GetAnchorType(&bAnchorChanged); + bool bModified = false; + if(bAnchorChanged) + { + rSet->Put(SfxInt16Item(SID_ATTR_TRANSFORM_ANCHOR, static_cast<sal_Int16>(nAnchor))); + bModified = true; + } + if (m_xPositionCB->get_state_changed_from_saved()) + { + if (m_xPositionCB->get_inconsistent()) + rSet->InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_POS ); + else + rSet->Put( + SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_POS, + m_xPositionCB->get_state() == TRISTATE_TRUE ) ); + bModified = true; + } + + if (m_xSizeCB->get_state_changed_from_saved()) + { + if (m_xSizeCB->get_inconsistent()) + rSet->InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_SIZE ); + else + rSet->Put( + SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_SIZE, + m_xSizeCB->get_state() == TRISTATE_TRUE ) ); + bModified = true; + } + + const SfxItemSet& rOldSet = GetItemSet(); + + if(!m_bPositioningDisabled) + { + //on multiple selections the positioning is set via SdrView + if (m_bIsMultiSelection) + { + if (m_xHoriByMF->get_value_changed_from_saved() || m_xVertByMF->get_value_changed_from_saved()) + { + auto nHoriByPos = m_xHoriByMF->denormalize(m_xHoriByMF->get_value(FieldUnit::TWIP)); + auto nVertByPos = m_xVertByMF->denormalize(m_xVertByMF->get_value(FieldUnit::TWIP)); + + // old rectangle with CoreUnit + m_aRect = m_pSdrView->GetAllMarkedRect(); + m_pSdrView->GetSdrPageView()->LogicToPagePos( m_aRect ); + + nHoriByPos += m_aAnchorPos.X(); + nVertByPos += m_aAnchorPos.Y(); + + rSet->Put( SfxInt32Item( SID_ATTR_TRANSFORM_POS_X, nHoriByPos ) ); + rSet->Put( SfxInt32Item( SID_ATTR_TRANSFORM_POS_Y, nVertByPos ) ); + + bModified = true; + } + } + else + { + if ( m_pHMap ) + { + const SfxInt16Item& rHoriOrient = + rOldSet.Get( SID_ATTR_TRANSFORM_HORI_ORIENT ); + const SfxInt16Item& rHoriRelation = + rOldSet.Get( SID_ATTR_TRANSFORM_HORI_RELATION); + const SfxInt32Item& rHoriPosition = + rOldSet.Get( SID_ATTR_TRANSFORM_HORI_POSITION); + + sal_uInt16 nMapPos = GetMapPos(m_pHMap, *m_xHoriLB); + short nAlign = GetAlignment(m_pHMap, nMapPos, *m_xHoriToLB); + short nRel = GetRelation(*m_xHoriToLB); + const auto nHoriByPos = m_xHoriByMF->denormalize(m_xHoriByMF->get_value(FieldUnit::TWIP)); + if ( + nAlign != rHoriOrient.GetValue() || + nRel != rHoriRelation.GetValue() || + (m_xHoriByMF->get_sensitive() && nHoriByPos != rHoriPosition.GetValue()) + ) + { + rSet->Put(SfxInt16Item(SID_ATTR_TRANSFORM_HORI_ORIENT, nAlign)); + rSet->Put(SfxInt16Item(SID_ATTR_TRANSFORM_HORI_RELATION, nRel)); + if(m_xHoriByMF->get_sensitive()) + rSet->Put(SfxInt32Item(SID_ATTR_TRANSFORM_HORI_POSITION, nHoriByPos)); + bModified = true; + } + } + if (m_xHoriMirrorCB->get_sensitive() && m_xHoriMirrorCB->get_state_changed_from_saved()) + bModified |= nullptr != rSet->Put(SfxBoolItem(SID_ATTR_TRANSFORM_HORI_MIRROR, m_xHoriMirrorCB->get_active())); + + if ( m_pVMap ) + { + const SfxInt16Item& rVertOrient = + rOldSet.Get( SID_ATTR_TRANSFORM_VERT_ORIENT); + const SfxInt16Item& rVertRelation = + rOldSet.Get( SID_ATTR_TRANSFORM_VERT_RELATION); + const SfxInt32Item& rVertPosition = + rOldSet.Get( SID_ATTR_TRANSFORM_VERT_POSITION); + + sal_uInt16 nMapPos = GetMapPos(m_pVMap, *m_xVertLB); + short nAlign = GetAlignment(m_pVMap, nMapPos, *m_xVertToLB); + short nRel = GetRelation(*m_xVertToLB); + // #i34055# - convert vertical position for + // as-character anchored objects + auto nVertByPos = m_xVertByMF->denormalize(m_xVertByMF->get_value(FieldUnit::TWIP)); + if (GetAnchorType() == RndStdIds::FLY_AS_CHAR) + { + nVertByPos *= -1; + } + if ( nAlign != rVertOrient.GetValue() || + nRel != rVertRelation.GetValue() || + ( m_xVertByMF->get_sensitive() && + nVertByPos != rVertPosition.GetValue() ) ) + { + rSet->Put(SfxInt16Item(SID_ATTR_TRANSFORM_VERT_ORIENT, nAlign)); + rSet->Put(SfxInt16Item(SID_ATTR_TRANSFORM_VERT_RELATION, nRel)); + if(m_xVertByMF->get_sensitive()) + rSet->Put(SfxInt32Item(SID_ATTR_TRANSFORM_VERT_POSITION, nVertByPos)); + bModified = true; + } + } + + // #i18732# + if (m_xFollowCB->get_state_changed_from_saved()) + { + //Writer internal type - based on SfxBoolItem + const SfxPoolItem* pItem = GetItem( rOldSet, SID_SW_FOLLOW_TEXT_FLOW); + if(pItem) + { + std::unique_ptr<SfxBoolItem> pFollow(static_cast<SfxBoolItem*>(pItem->Clone())); + pFollow->SetValue(m_xFollowCB->get_active()); + bModified |= nullptr != rSet->Put(std::move(pFollow)); + } + } + } + } + if (m_xWidthMF->get_value_changed_from_saved() || m_xHeightMF->get_value_changed_from_saved()) + { + sal_uInt32 nWidth = static_cast<sal_uInt32>(m_xWidthMF->denormalize(m_xWidthMF->get_value(FieldUnit::TWIP))); + sal_uInt32 nHeight = static_cast<sal_uInt32>(m_xHeightMF->denormalize(m_xHeightMF->get_value(FieldUnit::TWIP))); + rSet->Put( SfxUInt32Item( SID_ATTR_TRANSFORM_WIDTH, nWidth ) ); + rSet->Put( SfxUInt32Item( SID_ATTR_TRANSFORM_HEIGHT, nHeight ) ); + //this item is required by SdrEditView::SetGeoAttrToMarked() + rSet->Put( SfxUInt16Item( SID_ATTR_TRANSFORM_SIZE_POINT, sal_uInt16(RectPoint::LT) ) ); + + bModified = true; + } + + return bModified; +} + +void SvxSwPosSizeTabPage::Reset( const SfxItemSet* rSet) +{ + const SfxPoolItem* pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_ANCHOR ); + bool bInvalidateAnchor = false; + RndStdIds nAnchorType = RndStdIds::FLY_AT_PARA; + if(pItem) + { + nAnchorType = static_cast<RndStdIds>(static_cast<const SfxInt16Item*>(pItem)->GetValue()); + switch(nAnchorType) + { + case RndStdIds::FLY_AT_PAGE: m_xToPageRB->set_active(true); break; + case RndStdIds::FLY_AT_PARA: m_xToParaRB->set_active(true); break; + case RndStdIds::FLY_AT_CHAR: m_xToCharRB->set_active(true); break; + case RndStdIds::FLY_AS_CHAR: m_xAsCharRB->set_active(true); break; + case RndStdIds::FLY_AT_FLY: m_xToFrameRB->set_active(true); break; + default : bInvalidateAnchor = true; + } + m_xToPageRB->save_state(); + m_xToParaRB->save_state(); + m_xToCharRB->save_state(); + m_xAsCharRB->save_state(); + m_xToFrameRB->save_state(); + } + if (bInvalidateAnchor) + { + m_xToPageRB->set_sensitive( false ); + m_xToParaRB->set_sensitive( false ); + m_xToCharRB->set_sensitive( false ); + m_xAsCharRB->set_sensitive( false ); + m_xToFrameRB->set_sensitive( false ); + } + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_PROTECT_POS ); + if (pItem) + { + bool bProtected = static_cast<const SfxBoolItem*>(pItem)->GetValue(); + m_xPositionCB->set_active(bProtected); + m_xSizeCB->set_sensitive(!bProtected); + } + else + { + m_xPositionCB->set_inconsistent(true); + } + + m_xPositionCB->save_state(); + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_PROTECT_SIZE ); + + if (pItem) + { + m_xSizeCB->set_active(static_cast<const SfxBoolItem*>(pItem)->GetValue()); + } + else + m_xSizeCB->set_inconsistent(true); + m_xSizeCB->save_state(); + + pItem = GetItem( *rSet, SID_HTML_MODE ); + if(pItem) + { + m_bHtmlMode = + (static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON) + != 0; + } + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_IN_VERTICAL_TEXT ); + if(pItem && static_cast<const SfxBoolItem*>(pItem)->GetValue()) + { + OUString sHLabel = m_xHoriFT->get_label(); + m_xHoriFT->set_label(m_xVertFT->get_label()); + m_xVertFT->set_label(sHLabel); + m_bIsVerticalFrame = true; + } + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_IN_RTL_TEXT); + if(pItem) + m_bIsInRightToLeft = static_cast<const SfxBoolItem*>(pItem)->GetValue(); + + pItem = GetItem( *rSet, SID_SW_FOLLOW_TEXT_FLOW); + if(pItem) + { + const bool bFollowTextFlow = + static_cast<const SfxBoolItem*>(pItem)->GetValue(); + m_xFollowCB->set_active(bFollowTextFlow); + } + m_xFollowCB->save_state(); + + if(m_bHtmlMode) + { + m_xHoriMirrorCB->hide(); + m_xKeepRatioCB->set_sensitive(false); + // #i18732# - hide checkbox in HTML mode + m_xFollowCB->hide(); + } + else + { + // #i18732# correct enable/disable of check box 'Mirror on..' + m_xHoriMirrorCB->set_sensitive(!m_xAsCharRB->get_active() && !m_bIsMultiSelection); + + // #i18732# - enable/disable check box 'Follow text flow'. + m_xFollowCB->set_sensitive(m_xToParaRB->get_active() || + m_xToCharRB->get_active()); + } + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_WIDTH ); + sal_Int32 nWidth = std::max( pItem ? ( static_cast<const SfxUInt32Item*>(pItem)->GetValue()) : 0, sal_uInt32(1) ); + + m_xWidthMF->set_value(m_xWidthMF->normalize(nWidth), FieldUnit::TWIP); + m_xWidthMF->save_value(); + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_HEIGHT ); + sal_Int32 nHeight = std::max( pItem ? ( static_cast<const SfxUInt32Item*>(pItem)->GetValue()) : 0, sal_uInt32(1) ); + m_xHeightMF->set_value(m_xHeightMF->normalize(nHeight), FieldUnit::TWIP); + m_xHeightMF->save_value(); + m_fWidthHeightRatio = double(nWidth) / double(nHeight); + + if(m_bPositioningDisabled) + return; + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_HORI_ORIENT); + if(pItem) + { + short nHoriOrientation = static_cast< const SfxInt16Item*>(pItem)->GetValue(); + m_nOldH = nHoriOrientation; + } + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_VERT_ORIENT); + if(pItem) + { + short nVertOrientation = static_cast< const SfxInt16Item*>(pItem)->GetValue(); + m_nOldV = nVertOrientation; + } + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_HORI_RELATION); + if(pItem) + { + m_nOldHRel = static_cast< const SfxInt16Item*>(pItem)->GetValue(); + } + + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_VERT_RELATION); + if(pItem) + { + m_nOldVRel = static_cast< const SfxInt16Item*>(pItem)->GetValue(); + } + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_HORI_MIRROR); + if(pItem) + m_xHoriMirrorCB->set_active(static_cast<const SfxBoolItem*>(pItem)->GetValue()); + m_xHoriMirrorCB->save_state(); + + sal_Int32 nHoriPos = 0; + sal_Int32 nVertPos = 0; + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_HORI_POSITION); + if(pItem) + nHoriPos = static_cast<const SfxInt32Item*>(pItem)->GetValue(); + pItem = GetItem( *rSet, SID_ATTR_TRANSFORM_VERT_POSITION); + if(pItem) + nVertPos = static_cast<const SfxInt32Item*>(pItem)->GetValue(); + + InitPos(nAnchorType, m_nOldH, m_nOldHRel, m_nOldV, m_nOldVRel, nHoriPos, nVertPos); + + m_xVertByMF->save_value(); + m_xHoriByMF->save_value(); + // #i18732# + m_xFollowCB->save_state(); + + RangeModifyHdl(m_xWidthMF->get_widget()); // initially set maximum values +} + +DeactivateRC SvxSwPosSizeTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + { + _pSet->Put(SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_POS, + m_xPositionCB->get_active())); + _pSet->Put(SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_SIZE, + m_xSizeCB->get_active())); + FillItemSet( _pSet ); + } + return DeactivateRC::LeavePage; +} + +void SvxSwPosSizeTabPage::EnableAnchorTypes(SvxAnchorIds nAnchorEnable) +{ + if (nAnchorEnable & SvxAnchorIds::Fly) + m_xToFrameRB->show(); + if (!(nAnchorEnable & SvxAnchorIds::Page)) + m_xToPageRB->set_sensitive(false); +} + +RndStdIds SvxSwPosSizeTabPage::GetAnchorType(bool* pbHasChanged) +{ + RndStdIds nRet = RndStdIds::UNKNOWN; + weld::RadioButton* pCheckedButton = nullptr; + if(m_xToParaRB->get_sensitive()) + { + if(m_xToPageRB->get_active()) + { + nRet = RndStdIds::FLY_AT_PAGE; + pCheckedButton = m_xToPageRB.get(); + } + else if(m_xToParaRB->get_active()) + { + nRet = RndStdIds::FLY_AT_PARA; + pCheckedButton = m_xToParaRB.get(); + } + else if(m_xToCharRB->get_active()) + { + nRet = RndStdIds::FLY_AT_CHAR; + pCheckedButton = m_xToCharRB.get(); + } + else if(m_xAsCharRB->get_active()) + { + nRet = RndStdIds::FLY_AS_CHAR; + pCheckedButton = m_xAsCharRB.get(); + } + else if(m_xToFrameRB->get_active()) + { + nRet = RndStdIds::FLY_AT_FLY; + pCheckedButton = m_xToFrameRB.get(); + } + } + if(pbHasChanged) + { + if(pCheckedButton) + *pbHasChanged = pCheckedButton->get_state_changed_from_saved(); + else + *pbHasChanged = false; + } + return nRet; +} + +IMPL_LINK_NOARG(SvxSwPosSizeTabPage, RangeModifyClickHdl, weld::Toggleable&, void) +{ + RangeModifyHdl(m_xWidthMF->get_widget()); +} + +IMPL_LINK_NOARG(SvxSwPosSizeTabPage, RangeModifyHdl, weld::Widget&, void) +{ + if (m_bPositioningDisabled) + return; + SvxSwFrameValidation aVal; + + aVal.nAnchorType = GetAnchorType(); + aVal.bAutoHeight = false; + aVal.bMirror = m_xHoriMirrorCB->get_active(); + // #i18732# + aVal.bFollowTextFlow = m_xFollowCB->get_active(); + + if ( m_pHMap ) + { + // horizontal alignment + sal_uInt16 nMapPos = GetMapPos(m_pHMap, *m_xHoriToLB); + sal_uInt16 nAlign = GetAlignment(m_pHMap, nMapPos, *m_xHoriToLB); + sal_uInt16 nRel = GetRelation(*m_xHoriToLB); + + aVal.nHoriOrient = static_cast<short>(nAlign); + aVal.nHRelOrient = static_cast<short>(nRel); + } + else + aVal.nHoriOrient = HoriOrientation::NONE; + + if ( m_pVMap ) + { + // vertical alignment + sal_uInt16 nMapPos = GetMapPos(m_pVMap, *m_xVertLB); + sal_uInt16 nAlign = GetAlignment(m_pVMap, nMapPos, *m_xVertToLB); + sal_uInt16 nRel = GetRelation(*m_xVertToLB); + + aVal.nVertOrient = static_cast<short>(nAlign); + aVal.nVRelOrient = static_cast<short>(nRel); + } + else + aVal.nVertOrient = VertOrientation::NONE; + + const auto nAtHorzPosVal = m_xHoriByMF->denormalize(m_xHoriByMF->get_value(FieldUnit::TWIP)); + const auto nAtVertPosVal = m_xVertByMF->denormalize(m_xVertByMF->get_value(FieldUnit::TWIP)); + + aVal.nHPos = nAtHorzPosVal; + aVal.nVPos = nAtVertPosVal; + + sal_Int32 nWidth = static_cast<sal_uInt32>(m_xWidthMF->denormalize(m_xWidthMF->get_value(FieldUnit::TWIP))); + sal_Int32 nHeight = static_cast<sal_uInt32>(m_xHeightMF->denormalize(m_xHeightMF->get_value(FieldUnit::TWIP))); + aVal.nWidth = nWidth; + aVal.nHeight = nHeight; + + m_aValidateLink.Call(aVal); + + // minimum width also for style + m_xHeightMF->set_min(m_xHeightMF->normalize(aVal.nMinHeight), FieldUnit::TWIP); + m_xWidthMF->set_min(m_xWidthMF->normalize(aVal.nMinWidth), FieldUnit::TWIP); + + sal_Int32 nMaxWidth(aVal.nMaxWidth); + sal_Int32 nMaxHeight(aVal.nMaxHeight); + + sal_Int64 nTmp = m_xHeightMF->normalize(nMaxHeight); + m_xHeightMF->set_max(nTmp, FieldUnit::TWIP); + + nTmp = m_xWidthMF->normalize(nMaxWidth); + m_xWidthMF->set_max(nTmp, FieldUnit::TWIP); + + m_xHoriByMF->set_range(m_xHoriByMF->normalize(aVal.nMinHPos), + m_xHoriByMF->normalize(aVal.nMaxHPos), FieldUnit::TWIP); + if ( aVal.nHPos != nAtHorzPosVal ) + m_xHoriByMF->set_value(m_xHoriByMF->normalize(aVal.nHPos), FieldUnit::TWIP); + + m_xVertByMF->set_range(m_xVertByMF->normalize(aVal.nMinVPos), + m_xVertByMF->normalize(aVal.nMaxVPos), FieldUnit::TWIP); + if ( aVal.nVPos != nAtVertPosVal ) + m_xVertByMF->set_value(m_xVertByMF->normalize(aVal.nVPos), FieldUnit::TWIP); +} + +IMPL_LINK_NOARG(SvxSwPosSizeTabPage, AnchorTypeHdl, weld::Toggleable&, void) +{ + m_xHoriMirrorCB->set_sensitive(!m_xAsCharRB->get_active() && !m_bIsMultiSelection); + + // #i18732# - enable check box 'Follow text flow' for anchor + // type to-paragraph' and to-character + m_xFollowCB->set_sensitive(m_xToParaRB->get_active() || m_xToCharRB->get_active()); + + RndStdIds nId = GetAnchorType(); + + InitPos( nId, USHRT_MAX, 0, USHRT_MAX, 0, LONG_MAX, LONG_MAX); + RangeModifyHdl(m_xWidthMF->get_widget()); + + if(m_bHtmlMode) + { + PosHdl(*m_xHoriLB); + PosHdl(*m_xVertLB); + } +} + +IMPL_LINK_NOARG(SvxSwPosSizeTabPage, MirrorHdl, weld::Toggleable&, void) +{ + RndStdIds nId = GetAnchorType(); + InitPos( nId, USHRT_MAX, 0, USHRT_MAX, 0, LONG_MAX, LONG_MAX); +} + +IMPL_LINK( SvxSwPosSizeTabPage, RelHdl, weld::ComboBox&, rLB, void ) +{ + bool bHori = &rLB == m_xHoriToLB.get(); + + UpdateExample(); + + if (m_bHtmlMode && RndStdIds::FLY_AT_CHAR == GetAnchorType()) // again special treatment + { + if(bHori) + { + sal_uInt16 nRel = GetRelation(*m_xHoriToLB); + if(RelOrientation::PRINT_AREA == nRel && 0 == m_xVertLB->get_active()) + { + m_xVertLB->set_active(1); + } + else if(RelOrientation::CHAR == nRel && 1 == m_xVertLB->get_active()) + { + m_xVertLB->set_active(0); + } + } + } + RangeModifyHdl(m_xWidthMF->get_widget()); +} + +IMPL_LINK(SvxSwPosSizeTabPage, PosHdl, weld::ComboBox&, rLB, void) +{ + bool bHori = &rLB == m_xHoriLB.get(); + weld::ComboBox* pRelLB = bHori ? m_xHoriToLB.get() : m_xVertToLB.get(); + weld::Label* pRelFT = bHori ? m_xHoriToFT.get() : m_xVertToFT.get(); + FrmMap const *pMap = bHori ? m_pHMap : m_pVMap; + + + sal_uInt16 nMapPos = GetMapPos(pMap, rLB); + sal_uInt16 nAlign = GetAlignment(pMap, nMapPos, *pRelLB); + + if (bHori) + { + bool bEnable = HoriOrientation::NONE == nAlign; + m_xHoriByMF->set_sensitive( bEnable ); + m_xHoriByFT->set_sensitive( bEnable ); + } + else + { + bool bEnable = VertOrientation::NONE == nAlign; + m_xVertByMF->set_sensitive( bEnable ); + m_xVertByFT->set_sensitive( bEnable ); + } + + RangeModifyHdl(m_xWidthMF->get_widget()); + + short nRel = 0; + if (rLB.get_active() != -1) + { + if (pRelLB->get_active() != -1) + nRel = weld::fromId<RelationMap*>(pRelLB->get_active_id())->nRelation; + + FillRelLB(pMap, nMapPos, nAlign, nRel, *pRelLB, *pRelFT); + } + else + pRelLB->clear(); + + UpdateExample(); + + // special treatment for HTML-Mode with horz-vert-dependencies + if (!(m_bHtmlMode && RndStdIds::FLY_AT_CHAR == GetAnchorType())) + return; + + bool bSet = false; + if(bHori) + { + // on the right only below is allowed - from the left only at the top + // from the left at the character -> below + if((HoriOrientation::LEFT == nAlign || HoriOrientation::RIGHT == nAlign) && + 0 == m_xVertLB->get_active()) + { + if(RelOrientation::FRAME == nRel) + m_xVertLB->set_active(1); + else + m_xVertLB->set_active(0); + bSet = true; + } + else if(HoriOrientation::LEFT == nAlign && 1 == m_xVertLB->get_active()) + { + m_xVertLB->set_active(0); + bSet = true; + } + else if(HoriOrientation::NONE == nAlign && 1 == m_xVertLB->get_active()) + { + m_xVertLB->set_active(0); + bSet = true; + } + if(bSet) + PosHdl(*m_xVertLB); + } + else + { + if(VertOrientation::TOP == nAlign) + { + if(1 == m_xHoriLB->get_active()) + { + m_xHoriLB->set_active(0); + bSet = true; + } + m_xHoriToLB->set_active(1); + } + else if(VertOrientation::CHAR_BOTTOM == nAlign) + { + if(2 == m_xHoriLB->get_active()) + { + m_xHoriLB->set_active(0); + bSet = true; + } + m_xHoriToLB->set_active(0) ; + } + if(bSet) + PosHdl(*m_xHoriLB); + } +} + +IMPL_LINK( SvxSwPosSizeTabPage, ModifyHdl, weld::MetricSpinButton&, rEdit, void ) +{ + auto nWidth = m_xWidthMF->denormalize(m_xWidthMF->get_value(FieldUnit::TWIP)); + auto nHeight = m_xHeightMF->denormalize(m_xHeightMF->get_value(FieldUnit::TWIP)); + if (m_xKeepRatioCB->get_active()) + { + if ( &rEdit == m_xWidthMF.get() ) + { + nHeight = int(static_cast<double>(nWidth) / m_fWidthHeightRatio); + m_xHeightMF->set_value(m_xHeightMF->normalize(nHeight), FieldUnit::TWIP); + } + else if(&rEdit == m_xHeightMF.get()) + { + nWidth = int(static_cast<double>(nHeight) * m_fWidthHeightRatio); + m_xWidthMF->set_value(m_xWidthMF->normalize(nWidth), FieldUnit::TWIP); + } + } + m_fWidthHeightRatio = nHeight ? double(nWidth) / double(nHeight) : 1.0; + UpdateExample(); +} + +IMPL_LINK_NOARG(SvxSwPosSizeTabPage, ProtectHdl, weld::Toggleable&, void) +{ + if (m_xSizeCB->get_sensitive()) + { + m_nProtectSizeState = m_xSizeCB->get_state(); + } + + m_xSizeCB->set_state(m_xPositionCB->get_state() == TRISTATE_TRUE ? TRISTATE_TRUE : m_nProtectSizeState); + m_xSizeCB->set_sensitive(m_xPositionCB->get_sensitive() && !m_xPositionCB->get_active()); +} + +short SvxSwPosSizeTabPage::GetRelation(const weld::ComboBox& rRelationLB) +{ + short nRel = 0; + int nPos = rRelationLB.get_active(); + if (nPos != -1) + { + RelationMap *pEntry = weld::fromId<RelationMap*>(rRelationLB.get_id(nPos)); + nRel = pEntry->nRelation; + } + + return nRel; +} + +short SvxSwPosSizeTabPage::GetAlignment(FrmMap const *pMap, sal_uInt16 nMapPos, const weld::ComboBox& rRelationLB) +{ + short nAlign = 0; + + // #i22341# - special handling also for map <aVCharMap>, + // because it contains ambiguous items for alignment + if (pMap == aVAsCharHtmlMap || pMap == aVAsCharMap || + pMap == aVCharMap ) + { + if (rRelationLB.get_active() != -1) + { + LB nRel = weld::fromId<RelationMap*>(rRelationLB.get_active_id())->nLBRelation; + std::size_t nMapCount = ::lcl_GetFrmMapCount(pMap); + SvxSwFramePosString::StringId eStrId = pMap[nMapPos].eStrId; + + for (std::size_t i = 0; i < nMapCount; i++) + { + if (pMap[i].eStrId == eStrId) + { + LB nLBRelations = pMap[i].nLBRelations; + if (nLBRelations & nRel) + { + nAlign = pMap[i].nAlign; + break; + } + } + } + } + } + else if (pMap) + nAlign = pMap[nMapPos].nAlign; + + return nAlign; +} + +sal_uInt16 SvxSwPosSizeTabPage::GetMapPos(FrmMap const *pMap, const weld::ComboBox& rAlignLB) +{ + sal_uInt16 nMapPos = 0; + int nLBSelPos = rAlignLB.get_active(); + + if (nLBSelPos != -1) + { + if (pMap == aVAsCharHtmlMap || pMap == aVAsCharMap) + { + std::size_t nMapCount = ::lcl_GetFrmMapCount(pMap); + OUString sSelEntry(rAlignLB.get_active_text()); + + for (std::size_t i = 0; i < nMapCount; i++) + { + SvxSwFramePosString::StringId eResId = pMap[i].eStrId; + + OUString sEntry = SvxSwFramePosString::GetString(eResId); + + if (sEntry == sSelEntry) + { + nMapPos = sal::static_int_cast< sal_uInt16 >(i); + break; + } + } + } + else + nMapPos = nLBSelPos; + } + + return nMapPos; +} + +void SvxSwPosSizeTabPage::InitPos(RndStdIds nAnchor, + sal_uInt16 nH, + sal_uInt16 nHRel, + sal_uInt16 nV, + sal_uInt16 nVRel, + tools::Long nX, + tools::Long nY) +{ + int nPos = m_xVertLB->get_active(); + if (nPos != -1 && m_pVMap) + { + m_nOldV = m_pVMap[nPos].nAlign; + nPos = m_xVertToLB->get_active(); + if (nPos != -1) + m_nOldVRel = weld::fromId<RelationMap*>(m_xVertToLB->get_id(nPos))->nRelation; + } + + nPos = m_xHoriLB->get_active(); + if (nPos != -1 && m_pHMap) + { + m_nOldH = m_pHMap[nPos].nAlign; + + nPos = m_xHoriToLB->get_active(); + if (nPos != -1) + m_nOldHRel = weld::fromId<RelationMap*>(m_xHoriToLB->get_id(nPos))->nRelation; + } + + bool bEnable = true; + if( m_bIsMultiSelection ) + { + m_pVMap = aVMultiSelectionMap; + m_pHMap = aHMultiSelectionMap; + } + else if (nAnchor == RndStdIds::FLY_AT_PAGE) + { + m_pVMap = m_bHtmlMode ? aVPageHtmlMap : aVPageMap; + m_pHMap = m_bHtmlMode ? aHPageHtmlMap : aHPageMap; + } + else if (nAnchor == RndStdIds::FLY_AT_FLY) + { + // #i18732# - own vertical alignment map for to frame + // anchored objects. + m_pVMap = m_bHtmlMode ? aVFlyHtmlMap : aVFrameMap; + m_pHMap = m_bHtmlMode ? aHFlyHtmlMap : aHFrameMap; + } + else if (nAnchor == RndStdIds::FLY_AT_PARA) + { + if(m_bHtmlMode) + { + m_pVMap = aVParaHtmlMap; + m_pHMap = aHParaHtmlAbsMap; + } + else + { + m_pVMap = aVParaMap; + m_pHMap = aHParaMap; + } + } + else if (nAnchor == RndStdIds::FLY_AT_CHAR) + { + if(m_bHtmlMode) + { + m_pVMap = aVCharHtmlAbsMap; + m_pHMap = aHCharHtmlAbsMap; + } + else + { + m_pVMap = aVCharMap; + m_pHMap = aHCharMap; + } + } + else if (nAnchor == RndStdIds::FLY_AS_CHAR) + { + m_pVMap = m_bHtmlMode ? aVAsCharHtmlMap : aVAsCharMap; + m_pHMap = nullptr; + bEnable = false; + } + m_xHoriLB->set_sensitive(bEnable); + m_xHoriFT->set_sensitive(bEnable); + + // select current Pos + // horizontal + if ( nH == USHRT_MAX ) + { + nH = m_nOldH; + nHRel = m_nOldHRel; + } + // #i22341# - pass <nHRel> as 3rd parameter to method <FillPosLB> + sal_uInt16 nMapPos = FillPosLB(m_pHMap, nH, nHRel, *m_xHoriLB); + FillRelLB(m_pHMap, nMapPos, nH, nHRel, *m_xHoriToLB, *m_xHoriToFT); + + // vertical + if ( nV == USHRT_MAX ) + { + nV = m_nOldV; + nVRel = m_nOldVRel; + } + // #i22341# - pass <nVRel> as 3rd parameter to method <FillPosLB> + nMapPos = FillPosLB(m_pVMap, nV, nVRel, *m_xVertLB); + FillRelLB(m_pVMap, nMapPos, nV, nVRel, *m_xVertToLB, *m_xVertToFT); + + // Edits init + bEnable = nH == HoriOrientation::NONE && nAnchor != RndStdIds::FLY_AS_CHAR; //#61359# why not in formats&& !bFormat; + if (!bEnable) + { + m_xHoriByMF->set_value(0, FieldUnit::TWIP); + } + else if(m_bIsMultiSelection) + { + m_xHoriByMF->set_value(m_xHoriByMF->normalize(m_aRect.Left()), FieldUnit::TWIP); + } + else + { + if (nX != LONG_MAX) + m_xHoriByMF->set_value(m_xHoriByMF->normalize(nX), FieldUnit::TWIP); + } + m_xHoriByFT->set_sensitive(bEnable); + m_xHoriByMF->set_sensitive(bEnable); + + bEnable = nV == VertOrientation::NONE; + if ( !bEnable ) + { + m_xVertByMF->set_value( 0, FieldUnit::TWIP ); + } + else if(m_bIsMultiSelection) + { + m_xVertByMF->set_value(m_xVertByMF->normalize(m_aRect.Top()), FieldUnit::TWIP); + } + else + { + if (nAnchor == RndStdIds::FLY_AS_CHAR) + { + if ( nY == LONG_MAX ) + nY = 0; + else + nY *= -1; + } + if ( nY != LONG_MAX ) + m_xVertByMF->set_value( m_xVertByMF->normalize(nY), FieldUnit::TWIP ); + } + m_xVertByFT->set_sensitive( bEnable ); + m_xVertByMF->set_sensitive( bEnable ); + UpdateExample(); +} + +void SvxSwPosSizeTabPage::UpdateExample() +{ + int nPos = m_xHoriLB->get_active(); + if (m_pHMap && nPos != -1) + { + sal_uInt16 nMapPos = GetMapPos(m_pHMap, *m_xHoriLB); + short nAlign = GetAlignment(m_pHMap, nMapPos, *m_xHoriToLB); + short nRel = GetRelation(*m_xHoriToLB); + + m_aExampleWN.SetHAlign(nAlign); + m_aExampleWN.SetHoriRel(nRel); + } + + nPos = m_xVertLB->get_active(); + if (m_pVMap && nPos != -1) + { + sal_uInt16 nMapPos = GetMapPos(m_pVMap, *m_xVertLB); + sal_uInt16 nAlign = GetAlignment(m_pVMap, nMapPos, *m_xVertToLB); + sal_uInt16 nRel = GetRelation(*m_xVertToLB); + + m_aExampleWN.SetVAlign(nAlign); + m_aExampleWN.SetVertRel(nRel); + } + + // Size + auto nXPos = m_xHoriByMF->denormalize(m_xHoriByMF->get_value(FieldUnit::TWIP)); + auto nYPos = m_xVertByMF->denormalize(m_xVertByMF->get_value(FieldUnit::TWIP)); + m_aExampleWN.SetRelPos(Point(nXPos, nYPos)); + + m_aExampleWN.SetAnchor( GetAnchorType() ); + m_aExampleWN.Invalidate(); +} + +void SvxSwPosSizeTabPage::FillRelLB(FrmMap const *pMap, sal_uInt16 nMapPos, sal_uInt16 nAlign, + sal_uInt16 nRel, weld::ComboBox& rLB, weld::Label& rFT) +{ + OUString sSelEntry; + LB nLBRelations = LB::NONE; + std::size_t nMapCount = ::lcl_GetFrmMapCount(pMap); + + rLB.clear(); + + if (nMapPos < nMapCount) + { + if (pMap == aVAsCharHtmlMap || pMap == aVAsCharMap) + { + OUString sOldEntry(rLB.get_active_text()); + SvxSwFramePosString::StringId eStrId = pMap[nMapPos].eStrId; + + for (std::size_t _nMapPos = 0; _nMapPos < nMapCount; _nMapPos++) + { + if (pMap[_nMapPos].eStrId == eStrId) + { + nLBRelations = pMap[_nMapPos].nLBRelations; + for (size_t nRelPos = 0; nRelPos < std::size(aAsCharRelationMap); nRelPos++) + { + if (nLBRelations & aAsCharRelationMap[nRelPos].nLBRelation) + { + SvxSwFramePosString::StringId sStrId1 = aAsCharRelationMap[nRelPos].eStrId; + + sStrId1 = lcl_ChangeResIdToVerticalOrRTL(sStrId1, m_bIsVerticalFrame, m_bIsInRightToLeft); + OUString sEntry = SvxSwFramePosString::GetString(sStrId1); + rLB.append(weld::toId(&aAsCharRelationMap[nRelPos]), sEntry); + if (pMap[_nMapPos].nAlign == nAlign) + sSelEntry = sEntry; + break; + } + } + } + } + if (!sSelEntry.isEmpty()) + rLB.set_active_text(sSelEntry); + else + { + rLB.set_active_text(sOldEntry); + if (rLB.get_active() == -1) + { + for (int i = 0; i < rLB.get_count(); i++) + { + RelationMap *pEntry = weld::fromId<RelationMap*>(rLB.get_id(i)); + if (pEntry->nLBRelation == LB::RelChar) // Default + { + rLB.set_active(i); + break; + } + } + } + } + } + else + { + // #i22341# - special handling for map <aVCharMap>, + // because its ambiguous in its <eStrId>/<eMirrorStrId>. + if ( pMap == aVCharMap ) + { + nLBRelations = ::lcl_GetLBRelationsForStrID( pMap, + ( m_xHoriMirrorCB->get_active() + ? pMap[nMapPos].eMirrorStrId + : pMap[nMapPos].eStrId ), + m_xHoriMirrorCB->get_active() ); + } + else + { + nLBRelations = pMap[nMapPos].nLBRelations; + } + + for (sal_uLong nBit = 1; nBit < sal_uLong(LB::LAST); nBit <<= 1) + { + if (nLBRelations & static_cast<LB>(nBit)) + { + for (size_t nRelPos = 0; nRelPos < std::size(aRelationMap); nRelPos++) + { + if (aRelationMap[nRelPos].nLBRelation == static_cast<LB>(nBit)) + { + SvxSwFramePosString::StringId sStrId1 = m_xHoriMirrorCB->get_active() ? aRelationMap[nRelPos].eMirrorStrId : aRelationMap[nRelPos].eStrId; + sStrId1 = lcl_ChangeResIdToVerticalOrRTL(sStrId1, m_bIsVerticalFrame, m_bIsInRightToLeft); + OUString sEntry = SvxSwFramePosString::GetString(sStrId1); + rLB.append(weld::toId(&aRelationMap[nRelPos]), sEntry); + if (sSelEntry.isEmpty() && aRelationMap[nRelPos].nRelation == nRel) + sSelEntry = sEntry; + } + } + } + } + if (!sSelEntry.isEmpty()) + rLB.set_active_text(sSelEntry); + else + { + // Probably anchor change. So look for a similar relation. + switch (nRel) + { + case RelOrientation::FRAME: nRel = RelOrientation::PAGE_FRAME; break; + case RelOrientation::PRINT_AREA: nRel = RelOrientation::PAGE_PRINT_AREA; break; + case RelOrientation::PAGE_LEFT: nRel = RelOrientation::FRAME_LEFT; break; + case RelOrientation::PAGE_RIGHT: nRel = RelOrientation::FRAME_RIGHT; break; + case RelOrientation::FRAME_LEFT: nRel = RelOrientation::PAGE_LEFT; break; + case RelOrientation::FRAME_RIGHT: nRel = RelOrientation::PAGE_RIGHT; break; + case RelOrientation::PAGE_FRAME: nRel = RelOrientation::FRAME; break; + case RelOrientation::PAGE_PRINT_AREA: nRel = RelOrientation::PRINT_AREA; break; + + default: + if (rLB.get_count()) + { + RelationMap *pEntry = weld::fromId<RelationMap*>(rLB.get_id(rLB.get_count() - 1)); + nRel = pEntry->nRelation; + } + break; + } + + for (int i = 0; i < rLB.get_count(); ++i) + { + RelationMap *pEntry = weld::fromId<RelationMap*>(rLB.get_id(i)); + if (pEntry->nRelation == nRel) + { + rLB.set_active(i); + break; + } + } + + if (rLB.get_active() == -1) + rLB.set_active(0); + } + } + } + + rLB.set_sensitive(rLB.get_count() != 0); + rFT.set_sensitive(rLB.get_count() != 0); + + RelHdl(rLB); +} + +sal_uInt16 SvxSwPosSizeTabPage::FillPosLB(FrmMap const *_pMap, + sal_uInt16 _nAlign, + const sal_uInt16 _nRel, + weld::ComboBox& _rLB) +{ + OUString sSelEntry, sOldEntry; + sOldEntry = _rLB.get_active_text(); + + _rLB.clear(); + + // #i22341# - determine all possible listbox relations for + // given relation for map <aVCharMap> + const LB nLBRelations = (_pMap != aVCharMap) + ? LB::NONE + : ::lcl_GetLBRelationsForRelations( _nRel ); + + // fill listbox + std::size_t nCount = ::lcl_GetFrmMapCount(_pMap); + for (std::size_t i = 0; _pMap && i < nCount; ++i) + { + SvxSwFramePosString::StringId eStrId = m_xHoriMirrorCB->get_active() ? _pMap[i].eMirrorStrId : _pMap[i].eStrId; + eStrId = lcl_ChangeResIdToVerticalOrRTL(eStrId, m_bIsVerticalFrame, m_bIsInRightToLeft); + OUString sEntry(SvxSwFramePosString::GetString(eStrId)); + if (_rLB.find_text(sEntry) == -1) + { + // don't insert duplicate entries at character wrapped borders + _rLB.append_text(sEntry); + } + // #i22341# - add condition to handle map <aVCharMap> + // that is ambiguous in the alignment. + if ( _pMap[i].nAlign == _nAlign && + ( _pMap != aVCharMap || _pMap[i].nLBRelations & nLBRelations ) ) + { + sSelEntry = sEntry; + } + } + + _rLB.set_active_text(sSelEntry); + if (_rLB.get_active() == -1) + _rLB.set_active_text(sOldEntry); + + if (_rLB.get_active() == -1) + _rLB.set_active(0); + + PosHdl(_rLB); + + return GetMapPos(_pMap, _rLB); +} + +void SvxSwPosSizeTabPage::SetView( const SdrView* pSdrView ) +{ + m_pSdrView = pSdrView; + if(!m_pSdrView) + { + OSL_FAIL("No SdrView* set"); + return; + } + + // setting of the rectangle and the working area + m_aRect = m_pSdrView->GetAllMarkedRect(); + m_pSdrView->GetSdrPageView()->LogicToPagePos( m_aRect ); + + // get WorkArea + m_aWorkArea = m_pSdrView->GetWorkArea(); + + // consider anchor position (for Writer) + const SdrMarkList& rMarkList = m_pSdrView->GetMarkedObjectList(); + if( rMarkList.GetMarkCount() > 0 ) + { + const SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + m_aAnchorPos = pObj->GetAnchorPos(); + + if( m_aAnchorPos != Point(0,0) ) // -> Writer + { + for( size_t i = 1; i < rMarkList.GetMarkCount(); ++i ) + { + pObj = rMarkList.GetMark( i )->GetMarkedSdrObj(); + if( m_aAnchorPos != pObj->GetAnchorPos() ) + { + // different anchor positions -> disable positioning + m_xPosFrame->set_sensitive(false); + m_bPositioningDisabled = true; + return; + } + } + } + Point aPt = m_aAnchorPos * -1; + Point aPt2 = aPt; + + aPt += m_aWorkArea.TopLeft(); + m_aWorkArea.SetPos( aPt ); + + aPt2 += m_aRect.TopLeft(); + m_aRect.SetPos( aPt2 ); + } + + // this should happen via SID_ATTR_TRANSFORM_AUTOSIZE + if( rMarkList.GetMarkCount() != 1 ) + m_bIsMultiSelection = true; +#if OSL_DEBUG_LEVEL > 1 + else + { + const SdrObject* pObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + SdrObjKind eKind = (SdrObjKind) pObj->GetObjIdentifier(); + if( ( pObj->GetObjInventor() == SdrInventor::Default ) && + ( eKind==SdrObjKind::Text || eKind==SdrObjKind::TitleText || eKind==SdrObjKind::OutlineText) && + pObj->HasText() ) + { + OSL_FAIL("AutoWidth/AutoHeight should be enabled"); + } + } +#endif +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tabarea.cxx b/cui/source/tabpages/tabarea.cxx new file mode 100644 index 000000000..d03199c7b --- /dev/null +++ b/cui/source/tabpages/tabarea.cxx @@ -0,0 +1,252 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <sfx2/objsh.hxx> +#include <unotools/pathoptions.hxx> +#include <svx/svxids.hrc> + +#include <svx/xtable.hxx> +#include <svx/svdmodel.hxx> +#include <svx/drawitem.hxx> +#include <cuitabarea.hxx> + +SvxAreaTabDialog::SvxAreaTabDialog +( + weld::Window* pParent, + const SfxItemSet* pAttr, + SdrModel* pModel, + bool bShadow, + bool bSlideBackground +) + : SfxTabDialogController(pParent, "cui/ui/areadialog.ui", "AreaDialog", pAttr) + , mpDrawModel ( pModel ), + mpColorList ( pModel->GetColorList() ), + mpNewColorList ( pModel->GetColorList() ), + mpGradientList ( pModel->GetGradientList() ), + mpNewGradientList ( pModel->GetGradientList() ), + mpHatchingList ( pModel->GetHatchList() ), + mpNewHatchingList ( pModel->GetHatchList() ), + mpBitmapList ( pModel->GetBitmapList() ), + mpNewBitmapList ( pModel->GetBitmapList() ), + mpPatternList ( pModel->GetPatternList() ), + mpNewPatternList ( pModel->GetPatternList() ), + + mnColorListState ( ChangeType::NONE ), + mnBitmapListState ( ChangeType::NONE ), + mnPatternListState ( ChangeType::NONE ), + mnGradientListState ( ChangeType::NONE ), + mnHatchingListState ( ChangeType::NONE ) +{ + if (bSlideBackground) + AddTabPage("RID_SVXPAGE_AREA", SvxAreaTabPage::CreateWithSlideBackground, nullptr); + else + AddTabPage("RID_SVXPAGE_AREA", SvxAreaTabPage::Create, nullptr); + + if (bShadow) + { + AddTabPage("RID_SVXPAGE_SHADOW", SvxShadowTabPage::Create, nullptr); + } + else + { + RemoveTabPage( "RID_SVXPAGE_SHADOW" ); + } + + AddTabPage( "RID_SVXPAGE_TRANSPARENCE", SvxTransparenceTabPage::Create, nullptr); + + weld::Button& rBtnCancel = GetCancelButton(); + rBtnCancel.connect_clicked(LINK(this, SvxAreaTabDialog, CancelHdlImpl)); +} + +void SvxAreaTabDialog::SavePalettes() +{ + SfxObjectShell* pShell = SfxObjectShell::Current(); + if( mpNewColorList != mpDrawModel->GetColorList() ) + { + mpDrawModel->SetPropertyList( static_cast<XPropertyList *>(mpNewColorList.get()) ); + SvxColorListItem aColorListItem( mpNewColorList, SID_COLOR_TABLE ); + if ( pShell ) + pShell->PutItem( aColorListItem ); + else + mpDrawModel->GetItemPool().Put(aColorListItem,SID_COLOR_TABLE); + mpColorList = mpDrawModel->GetColorList(); + } + if( mpNewGradientList != mpDrawModel->GetGradientList() ) + { + mpDrawModel->SetPropertyList( static_cast<XPropertyList *>(mpNewGradientList.get()) ); + SvxGradientListItem aItem( mpNewGradientList, SID_GRADIENT_LIST ); + if ( pShell ) + pShell->PutItem( aItem ); + else + mpDrawModel->GetItemPool().Put(aItem,SID_GRADIENT_LIST); + mpGradientList = mpDrawModel->GetGradientList(); + } + if( mpNewHatchingList != mpDrawModel->GetHatchList() ) + { + mpDrawModel->SetPropertyList( static_cast<XPropertyList *>(mpNewHatchingList.get()) ); + SvxHatchListItem aItem( mpNewHatchingList, SID_HATCH_LIST ); + if ( pShell ) + pShell->PutItem( aItem ); + else + mpDrawModel->GetItemPool().Put(aItem,SID_HATCH_LIST); + mpHatchingList = mpDrawModel->GetHatchList(); + } + if( mpNewBitmapList != mpDrawModel->GetBitmapList() ) + { + mpDrawModel->SetPropertyList( static_cast<XPropertyList *>(mpNewBitmapList.get()) ); + SvxBitmapListItem aItem( mpNewBitmapList, SID_BITMAP_LIST ); + if ( pShell ) + pShell->PutItem( aItem ); + else + mpDrawModel->GetItemPool().Put(aItem,SID_BITMAP_LIST); + mpBitmapList = mpDrawModel->GetBitmapList(); + } + if( mpNewPatternList != mpDrawModel->GetPatternList() ) + { + mpDrawModel->SetPropertyList( static_cast<XPropertyList *>(mpNewPatternList.get()) ); + SvxPatternListItem aItem( mpNewPatternList, SID_PATTERN_LIST ); + if( pShell ) + pShell->PutItem( aItem ); + else + mpDrawModel->GetItemPool().Put(aItem,SID_PATTERN_LIST); + mpPatternList = mpDrawModel->GetPatternList(); + } + + // save the tables when they have been changed + + OUString aPalettePath(SvtPathOptions().GetPalettePath()); + OUString aPath; + sal_Int32 nIndex = 0; + do + { + aPath = aPalettePath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + if( mnHatchingListState & ChangeType::MODIFIED ) + { + mpHatchingList->SetPath( aPath ); + mpHatchingList->Save(); + + SvxHatchListItem aItem( mpHatchingList, SID_HATCH_LIST ); + // ToolBoxControls are informed: + if ( pShell ) + pShell->PutItem( aItem ); + else + mpDrawModel->GetItemPool().Put(aItem); + } + + if( mnBitmapListState & ChangeType::MODIFIED ) + { + mpBitmapList->SetPath( aPath ); + mpBitmapList->Save(); + + SvxBitmapListItem aItem( mpBitmapList, SID_BITMAP_LIST ); + // ToolBoxControls are informed: + if ( pShell ) + pShell->PutItem( aItem ); + else + { + mpDrawModel->GetItemPool().Put(aItem); + } + } + + if( mnPatternListState & ChangeType::MODIFIED ) + { + mpPatternList->SetPath( aPath ); + mpPatternList->Save(); + + SvxPatternListItem aItem( mpPatternList, SID_PATTERN_LIST ); + // ToolBoxControls are informed: + if( pShell ) + pShell->PutItem( aItem ); + else + mpDrawModel->GetItemPool().Put(aItem); + } + + if( mnGradientListState & ChangeType::MODIFIED ) + { + mpGradientList->SetPath( aPath ); + mpGradientList->Save(); + + SvxGradientListItem aItem( mpGradientList, SID_GRADIENT_LIST ); + // ToolBoxControls are informed: + if ( pShell ) + pShell->PutItem( aItem ); + else + { + mpDrawModel->GetItemPool().Put(aItem); + } + } + + if (mnColorListState & ChangeType::MODIFIED && mpColorList.is()) + { + SvxColorListItem aItem( mpColorList, SID_COLOR_TABLE ); + // ToolBoxControls are informed: + if ( pShell ) + pShell->PutItem( aItem ); + else + { + mpDrawModel->GetItemPool().Put(aItem); + } + } +} + +short SvxAreaTabDialog::Ok() +{ + SavePalettes(); + // RET_OK is returned, if at least one + // TabPage returns sal_True in FillItemSet(). + // This happens by default at the moment. + return SfxTabDialogController::Ok(); +} + +IMPL_LINK_NOARG(SvxAreaTabDialog, CancelHdlImpl, weld::Button&, void) +{ + SavePalettes(); + m_xDialog->response(RET_CANCEL); +} + +void SvxAreaTabDialog::PageCreated(const OString& rId, SfxTabPage &rPage) +{ + if (rId == "RID_SVXPAGE_AREA") + { + static_cast<SvxAreaTabPage&>(rPage).SetColorList( mpColorList ); + static_cast<SvxAreaTabPage&>(rPage).SetGradientList( mpGradientList ); + static_cast<SvxAreaTabPage&>(rPage).SetHatchingList( mpHatchingList ); + static_cast<SvxAreaTabPage&>(rPage).SetBitmapList( mpBitmapList ); + static_cast<SvxAreaTabPage&>(rPage).SetPatternList( mpPatternList ); + static_cast<SvxAreaTabPage&>(rPage).SetGrdChgd( &mnGradientListState ); + static_cast<SvxAreaTabPage&>(rPage).SetHtchChgd( &mnHatchingListState ); + static_cast<SvxAreaTabPage&>(rPage).SetBmpChgd( &mnBitmapListState ); + static_cast<SvxAreaTabPage&>(rPage).SetPtrnChgd( &mnPatternListState ); + static_cast<SvxAreaTabPage&>(rPage).SetColorChgd( &mnColorListState ); + } + else if (rId == "RID_SVXPAGE_SHADOW") + { + static_cast<SvxShadowTabPage&>(rPage).SetColorList( mpColorList ); + static_cast<SvxShadowTabPage&>(rPage).SetColorChgd( &mnColorListState ); + } + else if (rId == "RID_SVXPAGE_TRANSPARENCE") + { + static_cast<SvxTransparenceTabPage&>(rPage).SetPageType( PageType::Area ); + static_cast<SvxTransparenceTabPage&>(rPage).SetDlgType( 0 ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tabline.cxx b/cui/source/tabpages/tabline.cxx new file mode 100644 index 000000000..1cf548850 --- /dev/null +++ b/cui/source/tabpages/tabline.cxx @@ -0,0 +1,207 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <unotools/pathoptions.hxx> +#include <sfx2/objsh.hxx> +#include <svx/svxids.hrc> +#include <cuitabarea.hxx> +#include <cuitabline.hxx> +#include <svx/svdmodel.hxx> +#include <svx/xtable.hxx> +#include <svx/drawitem.hxx> + +SvxLineTabDialog::SvxLineTabDialog(weld::Window* pParent, const SfxItemSet* pAttr, + SdrModel* pModel, const SdrObject* pSdrObj, bool bHasObj) + : SfxTabDialogController(pParent, "cui/ui/linedialog.ui", "LineDialog", pAttr) + , pDrawModel(pModel) + , pObj(pSdrObj) + , pColorList(pModel->GetColorList()) + , mpNewColorList(pModel->GetColorList()) + , pDashList(pModel->GetDashList()) + , pNewDashList(pModel->GetDashList()) + , pLineEndList(pModel->GetLineEndList()) + , pNewLineEndList(pModel->GetLineEndList()) + , bObjSelected(bHasObj) + , nLineEndListState(ChangeType::NONE) + , nDashListState(ChangeType::NONE) + , mnColorListState(ChangeType::NONE) + , nPageType(PageType::Area) // We use it here primarily to get the right attributes with FillItemSet + , nPosDashLb(0) + , nPosLineEndLb(0) +{ + bool bLineOnly = false; + if( pObj && pObj->GetObjInventor() == SdrInventor::Default ) + { + switch( pObj->GetObjIdentifier() ) + { + case SdrObjKind::Line: + case SdrObjKind::PolyLine: + case SdrObjKind::PathLine: + case SdrObjKind::FreehandLine: + case SdrObjKind::Measure: + case SdrObjKind::Edge: + bLineOnly = true; + break; + + default: + break; + } + + } + + AddTabPage("RID_SVXPAGE_LINE", SvxLineTabPage::Create, nullptr); + if( bLineOnly ) + AddTabPage("RID_SVXPAGE_SHADOW", SvxShadowTabPage::Create, nullptr); + else + RemoveTabPage( "RID_SVXPAGE_SHADOW" ); + + AddTabPage("RID_SVXPAGE_LINE_DEF", SvxLineDefTabPage::Create, nullptr); + AddTabPage("RID_SVXPAGE_LINEEND_DEF", SvxLineEndDefTabPage::Create, nullptr); + + weld::Button& rBtnCancel = GetCancelButton(); + rBtnCancel.connect_clicked(LINK(this, SvxLineTabDialog, CancelHdlImpl)); +} + +void SvxLineTabDialog::SavePalettes() +{ + SfxObjectShell* pShell = SfxObjectShell::Current(); + if( mpNewColorList != pDrawModel->GetColorList() ) + { + pDrawModel->SetPropertyList( static_cast<XPropertyList *>(mpNewColorList.get()) ); + if ( pShell ) + pShell->PutItem( SvxColorListItem( mpNewColorList, SID_COLOR_TABLE ) ); + pColorList = pDrawModel->GetColorList(); + } + if( pNewDashList != pDrawModel->GetDashList() ) + { + pDrawModel->SetPropertyList( static_cast<XPropertyList *>(pNewDashList.get()) ); + if ( pShell ) + pShell->PutItem( SvxDashListItem( pNewDashList, SID_DASH_LIST ) ); + pDashList = pDrawModel->GetDashList(); + } + if( pNewLineEndList != pDrawModel->GetLineEndList() ) + { + pDrawModel->SetPropertyList( static_cast<XPropertyList *>(pNewLineEndList.get()) ); + if ( pShell ) + pShell->PutItem( SvxLineEndListItem( pNewLineEndList, SID_LINEEND_LIST ) ); + pLineEndList = pDrawModel->GetLineEndList(); + } + + // Save the tables when they have been changed + OUString aPalettePath(SvtPathOptions().GetPalettePath()); + OUString aPath; + sal_Int32 nIndex = 0; + do + { + aPath = aPalettePath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + if( nDashListState & ChangeType::MODIFIED ) + { + pDashList->SetPath( aPath ); + pDashList->Save(); + + // Notify ToolBoxControls + if ( pShell ) + pShell->PutItem( SvxDashListItem( pDashList, SID_DASH_LIST ) ); + } + + if( nLineEndListState & ChangeType::MODIFIED ) + { + pLineEndList->SetPath( aPath ); + pLineEndList->Save(); + + // Notify ToolBoxControls + if ( pShell ) + pShell->PutItem( SvxLineEndListItem( pLineEndList, SID_LINEEND_LIST ) ); + } + + if( mnColorListState & ChangeType::MODIFIED ) + { + pColorList->SetPath( aPath ); + pColorList->Save(); + + // Notify ToolBoxControls + if ( pShell ) + pShell->PutItem( SvxColorListItem( pColorList, SID_COLOR_TABLE ) ); + } +} + +short SvxLineTabDialog::Ok() +{ + SavePalettes(); + + // We return RET_OK if at least one TabPage in FillItemSet() returns sal_True. + // We do this by default at the moment. + return SfxTabDialogController::Ok(); +} + +IMPL_LINK_NOARG(SvxLineTabDialog, CancelHdlImpl, weld::Button&, void) +{ + SavePalettes(); + + m_xDialog->response(RET_CANCEL); +} + +void SvxLineTabDialog::PageCreated(const OString& rId, SfxTabPage &rPage) +{ + if (rId == "RID_SVXPAGE_LINE") + { + static_cast<SvxLineTabPage&>(rPage).SetDashList( pDashList ); + static_cast<SvxLineTabPage&>(rPage).SetLineEndList( pLineEndList ); + static_cast<SvxLineTabPage&>(rPage).SetDlgType( 0 ); + static_cast<SvxLineTabPage&>(rPage).SetPageType( nPageType ); + static_cast<SvxLineTabPage&>(rPage).SetPosDashLb( &nPosDashLb ); + static_cast<SvxLineTabPage&>(rPage).SetPosLineEndLb( &nPosLineEndLb ); + static_cast<SvxLineTabPage&>(rPage).SetDashChgd( &nDashListState ); + static_cast<SvxLineTabPage&>(rPage).SetLineEndChgd( &nLineEndListState ); + static_cast<SvxLineTabPage&>(rPage).SetObjSelected( bObjSelected ); + static_cast<SvxLineTabPage&>(rPage).Construct(); + static_cast<SvxLineTabPage&>(rPage).SetColorChgd( &mnColorListState ); + } + else if (rId == "RID_SVXPAGE_LINE_DEF") + { + static_cast<SvxLineDefTabPage&>(rPage).SetDashList( pDashList ); + static_cast<SvxLineDefTabPage&>(rPage).SetDlgType( 0 ); + static_cast<SvxLineDefTabPage&>(rPage).SetPageType( &nPageType ); + static_cast<SvxLineDefTabPage&>(rPage).SetPosDashLb( &nPosDashLb ); + static_cast<SvxLineDefTabPage&>(rPage).SetDashChgd( &nDashListState ); + static_cast<SvxLineDefTabPage&>(rPage).Construct(); + } + else if (rId == "RID_SVXPAGE_LINEEND_DEF") + { + static_cast<SvxLineEndDefTabPage&>(rPage).SetLineEndList( pLineEndList ); + static_cast<SvxLineEndDefTabPage&>(rPage).SetPolyObj( pObj ); + static_cast<SvxLineEndDefTabPage&>(rPage).SetDlgType( 0 ); + static_cast<SvxLineEndDefTabPage&>(rPage).SetPageType( &nPageType ); + static_cast<SvxLineEndDefTabPage&>(rPage).SetPosLineEndLb( &nPosLineEndLb ); + static_cast<SvxLineEndDefTabPage&>(rPage).SetLineEndChgd( &nLineEndListState ); + static_cast<SvxLineEndDefTabPage&>(rPage).Construct(); + } + else if (rId == "RID_SVXPAGE_SHADOW") + { + static_cast<SvxShadowTabPage&>(rPage).SetColorList( pColorList ); + static_cast<SvxShadowTabPage&>(rPage).SetPageType( nPageType ); + static_cast<SvxShadowTabPage&>(rPage).SetDlgType( 0 ); + static_cast<SvxShadowTabPage&>(rPage).SetColorChgd( &mnColorListState ); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tabstpge.cxx b/cui/source/tabpages/tabstpge.cxx new file mode 100644 index 000000000..b3a1745c2 --- /dev/null +++ b/cui/source/tabpages/tabstpge.cxx @@ -0,0 +1,663 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <svtools/ruler.hxx> +#include <svtools/unitconv.hxx> +#include <svx/svxids.hrc> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +#include <editeng/lrspitem.hxx> +#include <tabstpge.hxx> +#include <svx/dlgutil.hxx> +#include <svl/cjkoptions.hxx> +#include <unotools/localedatawrapper.hxx> +#include <svl/intitem.hxx> + +constexpr FieldUnit eDefUnit = FieldUnit::MM_100TH; + +const WhichRangesContainer SvxTabulatorTabPage::pRanges( + svl::Items<SID_ATTR_TABSTOP, SID_ATTR_TABSTOP_OFFSET>); + +static void FillUpWithDefTabs_Impl( tools::Long nDefDist, SvxTabStopItem& rTabs ) +{ + if( rTabs.Count() ) + return; + { + SvxTabStop aSwTabStop( nDefDist, SvxTabAdjust::Default ); + rTabs.Insert( aSwTabStop ); + } +} + +void TabWin_Impl::Paint(vcl::RenderContext& rRenderContext, const ::tools::Rectangle&) +{ + // Paint tabulators + Point aPoint; + Size aSize(GetOutputSizePixel()); + aPoint.setX( aSize.Width() / 2 ); + aPoint.setY( aSize.Height() / 2 ); + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + rRenderContext.SetLineColor(rStyleSettings.GetShadowColor()); + rRenderContext.SetFillColor(rStyleSettings.GetDialogColor()); + rRenderContext.DrawRect(tools::Rectangle(Point(0,0), rRenderContext.GetOutputSize())); + Ruler::DrawTab(rRenderContext, rStyleSettings.GetDialogTextColor(), aPoint, nTabStyle); +} + +SvxTabulatorTabPage::SvxTabulatorTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr) + : SfxTabPage(pPage, pController, "cui/ui/paratabspage.ui", "ParagraphTabsPage", &rAttr) + , aCurrentTab(0) + , aNewTabs(std::make_unique<SvxTabStopItem>(0, 0, SvxTabAdjust::Left, GetWhich(SID_ATTR_TABSTOP))) + , nDefDist(0) + , m_xTabSpin(m_xBuilder->weld_metric_spin_button("SP_TABPOS", FieldUnit::CM)) + , m_xTabBox(m_xBuilder->weld_entry_tree_view("tabgrid", "ED_TABPOS", "LB_TABPOS")) + , m_xCenterTab(m_xBuilder->weld_radio_button("radiobuttonBTN_TABTYPE_CENTER")) + , m_xDezTab(m_xBuilder->weld_radio_button("radiobuttonBTN_TABTYPE_DECIMAL")) + , m_xDezChar(m_xBuilder->weld_entry("entryED_TABTYPE_DECCHAR")) + , m_xDezCharLabel(m_xBuilder->weld_label("labelFT_TABTYPE_DECCHAR")) + // lower radio buttons + , m_xNoFillChar(m_xBuilder->weld_radio_button("radiobuttonBTN_FILLCHAR_NO")) + , m_xFillPoints(m_xBuilder->weld_radio_button("radiobuttonBTN_FILLCHAR_POINTS")) + , m_xFillDashLine(m_xBuilder->weld_radio_button("radiobuttonBTN_FILLCHAR_DASHLINE")) + , m_xFillSolidLine(m_xBuilder->weld_radio_button("radiobuttonBTN_FILLCHAR_UNDERSCORE")) + , m_xFillSpecial(m_xBuilder->weld_radio_button("radiobuttonBTN_FILLCHAR_OTHER")) + , m_xFillChar(m_xBuilder->weld_entry("entryED_FILLCHAR_OTHER")) + // button bar + , m_xNewBtn(m_xBuilder->weld_button("buttonBTN_NEW")) + , m_xDelAllBtn(m_xBuilder->weld_button("buttonBTN_DELALL")) + , m_xDelBtn(m_xBuilder->weld_button("buttonBTN_DEL")) + , m_xTypeFrame(m_xBuilder->weld_container("frameFL_TABTYPE")) + , m_xFillFrame(m_xBuilder->weld_container("frameFL_FILLCHAR")) + // the tab images + , m_xLeftWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWIN_TABLEFT", m_aLeftWin)) + , m_xRightWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWIN_TABRIGHT", m_aRightWin)) + , m_xCenterWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWIN_TABCENTER", m_aCenterWin)) + , m_xDezWin(new weld::CustomWeld(*m_xBuilder, "drawingareaWIN_TABDECIMAL", m_aDezWin)) +{ + m_aLeftWin.SetTabStyle(sal_uInt16(RULER_TAB_LEFT|WB_HORZ)); + m_aRightWin.SetTabStyle(sal_uInt16(RULER_TAB_RIGHT|WB_HORZ)); + m_aCenterWin.SetTabStyle(sal_uInt16(RULER_TAB_CENTER|WB_HORZ)); + m_aDezWin.SetTabStyle(sal_uInt16(RULER_TAB_DECIMAL|WB_HORZ)); + //upper radiobuttons + m_xLeftTab = m_xBuilder->weld_radio_button(SvtCJKOptions::IsAsianTypographyEnabled() ? "radiobuttonST_LEFTTAB_ASIAN" : "radiobuttonBTN_TABTYPE_LEFT"); + m_xRightTab = m_xBuilder->weld_radio_button(SvtCJKOptions::IsAsianTypographyEnabled() ? "radiobuttonST_RIGHTTAB_ASIAN" : "radiobuttonBTN_TABTYPE_RIGHT"); + m_xLeftTab->show(); + m_xRightTab->show(); + + // This page needs ExchangeSupport + SetExchangeSupport(); + + // Set metric + FieldUnit eFUnit = GetModuleFieldUnit( rAttr ); + SetFieldUnit(*m_xTabSpin, eFUnit); + + // Initialize buttons + m_xNewBtn->connect_clicked(LINK(this,SvxTabulatorTabPage, NewHdl_Impl)); + m_xDelBtn->connect_clicked(LINK(this,SvxTabulatorTabPage, DelHdl_Impl)); + m_xDelAllBtn->connect_clicked(LINK(this,SvxTabulatorTabPage, DelAllHdl_Impl)); + + Link<weld::Toggleable&,void> aLink = LINK(this, SvxTabulatorTabPage, TabTypeCheckHdl_Impl); + m_xLeftTab->connect_toggled(aLink); + m_xRightTab->connect_toggled(aLink); + m_xDezTab->connect_toggled(aLink); + m_xCenterTab->connect_toggled(aLink); + + m_xDezChar->connect_focus_out(LINK(this, SvxTabulatorTabPage, GetDezCharHdl_Impl)); + m_xDezChar->set_sensitive(false); + m_xDezCharLabel->set_sensitive(false); + + aLink = LINK(this, SvxTabulatorTabPage, FillTypeCheckHdl_Impl); + m_xNoFillChar->connect_toggled(aLink); + m_xFillPoints->connect_toggled(aLink); + m_xFillDashLine->connect_toggled(aLink); + m_xFillSolidLine->connect_toggled(aLink); + m_xFillSpecial->connect_toggled(aLink); + m_xFillChar->connect_focus_out(LINK(this, SvxTabulatorTabPage, GetFillCharHdl_Impl)); + m_xFillChar->set_sensitive(false); + + m_xTabBox->connect_row_activated(LINK(this, SvxTabulatorTabPage, SelectHdl_Impl)); + m_xTabBox->connect_changed(LINK(this, SvxTabulatorTabPage, ModifyHdl_Impl)); + m_xTabBox->connect_focus_out(LINK(this, SvxTabulatorTabPage, ReformatHdl_Impl)); + + // Get the default decimal char from the system + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() ); + aCurrentTab.GetDecimal() = rLocaleWrapper.getNumDecimalSep()[0]; +} + +SvxTabulatorTabPage::~SvxTabulatorTabPage() +{ + m_xDezWin.reset(); + m_xCenterWin.reset(); + m_xRightWin.reset(); + m_xLeftWin.reset(); + m_xFillChar.reset(); + m_xDezChar.reset(); + m_xTabBox.reset(); +} + +bool SvxTabulatorTabPage::FillItemSet(SfxItemSet* rSet) +{ + bool bModified = false; + + // Put the controls' values in here + if (m_xNewBtn->get_sensitive()) + NewHdl_Impl(nullptr); + + // Call the LoseFocus-Handler first + GetDezCharHdl_Impl(*m_xDezChar); + GetFillCharHdl_Impl(*m_xFillChar); + + FillUpWithDefTabs_Impl(nDefDist, *aNewTabs); + SfxItemPool* pPool = rSet->GetPool(); + MapUnit eUnit = pPool->GetMetric(GetWhich(SID_ATTR_TABSTOP)); + const SfxPoolItem* pOld = GetOldItem(*rSet, SID_ATTR_TABSTOP); + + if (MapUnit::Map100thMM != eUnit) + { + // If the ItemSet contains a LRSpaceItem with negative first line indent, + // the TabStopItem needs to have a DefTab at position 0. + const SfxPoolItem* pLRSpace; + // If not in the new set, then maybe in the old one + if (SfxItemState::SET != rSet->GetItemState(GetWhich(SID_ATTR_LRSPACE), true, &pLRSpace)) + pLRSpace = GetOldItem(*rSet, SID_ATTR_LRSPACE); + + if (pLRSpace && static_cast<const SvxLRSpaceItem*>(pLRSpace)->GetTextFirstLineOffset() < 0) + { + SvxTabStop aNull(0, SvxTabAdjust::Default); + aNewTabs->Insert(aNull); + } + + std::unique_ptr<SvxTabStopItem> aTmp(aNewTabs->Clone()); + aTmp->Remove(0, aTmp->Count()); + + for (sal_uInt16 i = 0; i < aNewTabs->Count(); ++i) + { + SvxTabStop aTmpStop = (*aNewTabs)[i]; + aTmpStop.GetTabPos() = OutputDevice::LogicToLogic(aTmpStop.GetTabPos(), MapUnit::Map100thMM, eUnit); + aTmp->Insert(aTmpStop); + } + + if (!pOld || *static_cast<const SvxTabStopItem*>(pOld) != *aTmp) + { + rSet->Put(std::move(aTmp)); + bModified = true; + } + } + else if (!pOld || *static_cast<const SvxTabStopItem*>(pOld) != *aNewTabs) + { + rSet->Put(*aNewTabs); + bModified = true; + } + + return bModified; +} + +std::unique_ptr<SfxTabPage> SvxTabulatorTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxTabulatorTabPage>(pPage, pController, *rSet); +} + +void SvxTabulatorTabPage::Reset(const SfxItemSet* rSet) +{ + SfxItemPool* pPool = rSet->GetPool(); + MapUnit eUnit = pPool->GetMetric(GetWhich(SID_ATTR_TABSTOP)); + + // Current tabs + const SfxPoolItem* pItem = GetItem(*rSet, SID_ATTR_TABSTOP); + + if (pItem) + { + if (MapUnit::Map100thMM != eUnit) + { + std::unique_ptr<SvxTabStopItem> aTmp(static_cast<SvxTabStopItem*>(pItem->Clone())); + aNewTabs->Remove(0, aNewTabs->Count()); + + for (sal_uInt16 i = 0; i < aTmp->Count(); ++i) + { + SvxTabStop aTmpStop = (*aTmp)[i]; + aTmpStop.GetTabPos() = OutputDevice::LogicToLogic(aTmpStop.GetTabPos(), eUnit, MapUnit::Map100thMM); + aNewTabs->Insert(aTmpStop); + } + } + else + { + aNewTabs.reset(static_cast<SvxTabStopItem*>(pItem->Clone())); + } + } + else + { + aNewTabs->Remove(0, aNewTabs->Count()); + } + + // Default tab distance + nDefDist = SVX_TAB_DEFDIST; + pItem = GetItem(*rSet, SID_ATTR_TABSTOP_DEFAULTS); + + if (pItem) + nDefDist = OutputDevice::LogicToLogic(tools::Long(static_cast<const SfxUInt16Item*>(pItem)->GetValue()), eUnit, MapUnit::Map100thMM); + + // Tab pos currently selected + sal_uInt16 nTabPos = 0; + pItem = GetItem(*rSet, SID_ATTR_TABSTOP_POS); + + if (pItem) + nTabPos = static_cast<const SfxUInt16Item*>(pItem)->GetValue(); + + InitTabPos_Impl(nTabPos); +} + +void SvxTabulatorTabPage::DisableControls(const TabulatorDisableFlags nFlag) +{ + if (TabulatorDisableFlags::TypeLeft & nFlag) + { + m_xLeftTab->set_sensitive(false); + m_xLeftWin->set_sensitive(false); + } + if (TabulatorDisableFlags::TypeRight & nFlag) + { + m_xRightTab->set_sensitive(false); + m_xRightWin->set_sensitive(false); + } + if (TabulatorDisableFlags::TypeCenter & nFlag) + { + m_xCenterTab->set_sensitive(false); + m_xCenterWin->set_sensitive(false); + } + if (TabulatorDisableFlags::TypeDecimal & nFlag) + { + m_xDezTab->set_sensitive(false); + m_xDezWin->set_sensitive(false); + m_xDezCharLabel->set_sensitive(false); + m_xDezChar->set_sensitive(false); + } + if (TabulatorDisableFlags::TypeMask & nFlag) + m_xTypeFrame->set_sensitive(false); + if (TabulatorDisableFlags::FillNone & nFlag) + m_xNoFillChar->set_sensitive(false); + if (TabulatorDisableFlags::FillPoint & nFlag) + m_xFillPoints->set_sensitive(false); + if (TabulatorDisableFlags::FillDashLine & nFlag) + m_xFillDashLine->set_sensitive(false); + if (TabulatorDisableFlags::FillSolidLine & nFlag) + m_xFillSolidLine->set_sensitive(false); + if (TabulatorDisableFlags::FillSpecial & nFlag) + { + m_xFillSpecial->set_sensitive(false); + m_xFillChar->set_sensitive(false); + } + if (TabulatorDisableFlags::FillMask & nFlag) + m_xFillFrame->set_sensitive(false); +} + +DeactivateRC SvxTabulatorTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +void SvxTabulatorTabPage::InitTabPos_Impl( sal_uInt16 nTabPos ) +{ + m_xTabBox->clear(); + + tools::Long nOffset = 0; + if (const SfxInt32Item* pOffSetItem = GetItemSet().GetItemIfSet(SID_ATTR_TABSTOP_OFFSET)) + { + nOffset = pOffSetItem->GetValue(); + MapUnit eUnit = GetItemSet().GetPool()->GetMetric(GetWhich(SID_ATTR_TABSTOP)); + nOffset = OutputDevice::LogicToLogic(nOffset, eUnit, MapUnit::Map100thMM); + } + + // Correct current TabPos and default tabs + for ( sal_uInt16 i = 0; i < aNewTabs->Count(); i++ ) + { + if ( (*aNewTabs)[i].GetAdjustment() != SvxTabAdjust::Default ) + { + m_xTabSpin->set_value(m_xTabSpin->normalize((*aNewTabs)[i].GetTabPos() + nOffset ), eDefUnit); + m_xTabBox->append_text(m_xTabSpin->get_text()); + } + else + { + aNewTabs->Remove( i-- ); + } + } + + // Select current tabulator + const sal_uInt16 nSize = aNewTabs->Count(); + + if ( nTabPos >= nSize ) + nTabPos = 0; + + // Switch off all RadioButtons for a start + m_xLeftTab->set_active(true); + m_xNoFillChar->set_active(true); + + if (m_xTabBox->get_count() > 0) + { + m_xTabBox->set_active(nTabPos); + aCurrentTab = (*aNewTabs)[nTabPos]; + + SetFillAndTabType_Impl(); + m_xNewBtn->set_sensitive(false); + m_xDelBtn->set_sensitive(true); + } + else + { // If no entry, 0 is the default value + m_xTabSpin->set_value(0, eDefUnit); + m_xTabBox->set_entry_text(m_xTabSpin->get_text()); + + m_xNewBtn->set_sensitive(true); + m_xDelBtn->set_sensitive(false); + } +} + +void SvxTabulatorTabPage::SetFillAndTabType_Impl() +{ + weld::RadioButton* pTypeBtn = nullptr; + weld::RadioButton* pFillBtn = nullptr; + + m_xDezChar->set_sensitive(false); + m_xDezCharLabel->set_sensitive(false); + + if ( aCurrentTab.GetAdjustment() == SvxTabAdjust::Left ) + pTypeBtn = m_xLeftTab.get(); + else if ( aCurrentTab.GetAdjustment() == SvxTabAdjust::Right ) + pTypeBtn = m_xRightTab.get(); + else if ( aCurrentTab.GetAdjustment() == SvxTabAdjust::Decimal ) + { + pTypeBtn = m_xDezTab.get(); + m_xDezChar->set_sensitive(true); + m_xDezCharLabel->set_sensitive(true); + m_xDezChar->set_text(OUString(aCurrentTab.GetDecimal())); + } + else if ( aCurrentTab.GetAdjustment() == SvxTabAdjust::Center ) + pTypeBtn = m_xCenterTab.get(); + + if (pTypeBtn) + pTypeBtn->set_active(true); + + m_xFillChar->set_sensitive(false); + m_xFillChar->set_text(""); + + if ( aCurrentTab.GetFill() == ' ' ) + pFillBtn = m_xNoFillChar.get(); + else if ( aCurrentTab.GetFill() == '-' ) + pFillBtn = m_xFillDashLine.get(); + else if ( aCurrentTab.GetFill() == '_' ) + pFillBtn = m_xFillSolidLine.get(); + else if ( aCurrentTab.GetFill() == '.' ) + pFillBtn = m_xFillPoints.get(); + else + { + pFillBtn = m_xFillSpecial.get(); + m_xFillChar->set_sensitive(true); + m_xFillChar->set_text(OUString(aCurrentTab.GetFill())); + } + pFillBtn->set_active(true); +} + +IMPL_LINK(SvxTabulatorTabPage, NewHdl_Impl, weld::Button&, rBtn, void) +{ + NewHdl_Impl(&rBtn); +} + +void SvxTabulatorTabPage::NewHdl_Impl(const weld::Button* pBtn) +{ + // Add a new one and select it + // Get the value from the display + ReformatHdl_Impl(*m_xTabBox); + m_xTabSpin->set_text(m_xTabBox->get_active_text()); + auto nVal = m_xTabSpin->denormalize(m_xTabSpin->get_value(eDefUnit)); + + // If the pBtn == 0 && the value == 0 then do not create a tab, because we create via OK + if (nVal == 0 && pBtn == nullptr) + return; + + tools::Long nOffset = 0; + + if ( const SfxInt32Item* pOffsetItem = GetItemSet().GetItemIfSet( SID_ATTR_TABSTOP_OFFSET ) ) + { + nOffset = pOffsetItem->GetValue(); + MapUnit eUnit = GetItemSet().GetPool()->GetMetric( GetWhich( SID_ATTR_TABSTOP ) ); + nOffset = OutputDevice::LogicToLogic( nOffset, eUnit, MapUnit::Map100thMM ); + } + const tools::Long nReal = nVal - nOffset; + sal_Int32 nSize = m_xTabBox->get_count(); + + sal_Int32 i; + for( i = 0; i < nSize; i++ ) + { + if ( nReal < (*aNewTabs)[i].GetTabPos() ) + break; + } + + // Make ListBox entry + m_xTabSpin->set_value(m_xTabSpin->normalize(nVal), eDefUnit); + m_xTabBox->insert_text(i, m_xTabSpin->get_text()); + + aCurrentTab.GetTabPos() = nReal; + SvxTabAdjust eAdj = SvxTabAdjust::Left; + + if (m_xRightTab->get_active()) + eAdj = SvxTabAdjust::Right; + else if (m_xCenterTab->get_active()) + eAdj = SvxTabAdjust::Center; + else if (m_xDezTab->get_active()) + eAdj = SvxTabAdjust::Decimal; + + aCurrentTab.GetAdjustment() = eAdj; + aNewTabs->Insert( aCurrentTab ); + + m_xNewBtn->set_sensitive(false); + m_xDelBtn->set_sensitive(true); + m_xTabBox->grab_focus(); + + // Set the selection into the position Edit + m_xTabBox->select_entry_region(0, -1); +} + +int SvxTabulatorTabPage::FindCurrentTab() +{ + return m_xTabBox->find_text(FormatTab()); +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, DelHdl_Impl, weld::Button&, void) +{ + int nPos = FindCurrentTab(); + if (nPos == -1) + return; + + if (m_xTabBox->get_count() == 1) + { + DelAllHdl_Impl(*m_xDelAllBtn); + return; + } + + // Delete Tab + m_xTabBox->remove(nPos); + aNewTabs->Remove( nPos ); + + // Reset aCurrentTab + const sal_uInt16 nSize = aNewTabs->Count(); + + if ( nSize > 0 ) + { + // Correct Pos + nPos = ( ( nSize - 1 ) >= nPos) ? nPos : nPos - 1; + m_xTabBox->set_active(nPos); + aCurrentTab = (*aNewTabs)[nPos]; + } + + // If no Tabs Enable Disable Controls + if (m_xTabBox->get_count() == 0) + { + m_xDelBtn->set_sensitive(false); + m_xNewBtn->set_sensitive(true); + m_xTabBox->grab_focus(); + } +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, DelAllHdl_Impl, weld::Button&, void) +{ + if ( aNewTabs->Count() ) + { + aNewTabs = std::make_unique<SvxTabStopItem>(GetWhich(SID_ATTR_TABSTOP)); + InitTabPos_Impl(); + } +} + +IMPL_LINK(SvxTabulatorTabPage, TabTypeCheckHdl_Impl, weld::Toggleable&, rBox, void) +{ + if (!rBox.get_active()) + return; + + SvxTabAdjust eAdj; + m_xDezChar->set_sensitive(false); + m_xDezCharLabel->set_sensitive(false); + m_xDezChar->set_text(""); + + if (&rBox == m_xLeftTab.get()) + eAdj = SvxTabAdjust::Left; + else if (&rBox == m_xRightTab.get()) + eAdj = SvxTabAdjust::Right; + else if (&rBox == m_xCenterTab.get()) + eAdj = SvxTabAdjust::Center; + else + { + eAdj = SvxTabAdjust::Decimal; + m_xDezChar->set_sensitive(true); + m_xDezCharLabel->set_sensitive(true); + m_xDezChar->set_text(OUString(aCurrentTab.GetDecimal())); + } + + aCurrentTab.GetAdjustment() = eAdj; + int nPos = FindCurrentTab(); + if (nPos != -1) + { + aNewTabs->Remove( nPos ); + aNewTabs->Insert( aCurrentTab ); + } +} + +IMPL_LINK(SvxTabulatorTabPage, FillTypeCheckHdl_Impl, weld::Toggleable&, rBox, void) +{ + if (!rBox.get_active()) + return; + + sal_uInt8 cFill = ' '; + m_xFillChar->set_text( "" ); + m_xFillChar->set_sensitive(false); + + if (&rBox == m_xFillSpecial.get()) + m_xFillChar->set_sensitive(true); + else if (&rBox == m_xNoFillChar.get()) + cFill = ' '; + else if (&rBox == m_xFillSolidLine.get()) + cFill = '_'; + else if (&rBox == m_xFillPoints.get()) + cFill = '.'; + else if (&rBox == m_xFillDashLine.get()) + cFill = '-'; + + aCurrentTab.GetFill() = cFill; + int nPos = FindCurrentTab(); + if (nPos != -1) + { + aNewTabs->Remove( nPos ); + aNewTabs->Insert( aCurrentTab ); + } +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, GetFillCharHdl_Impl, weld::Widget&, void) +{ + OUString aChar(m_xFillChar->get_text()); + if ( !aChar.isEmpty() ) + aCurrentTab.GetFill() = aChar[0]; + + const int nPos = FindCurrentTab(); + if (nPos != -1) + { + aNewTabs->Remove( nPos ); + aNewTabs->Insert( aCurrentTab ); + } +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, GetDezCharHdl_Impl, weld::Widget&, void) +{ + OUString aChar(m_xDezChar->get_text()); + if ( !aChar.isEmpty() && ( aChar[0] >= ' ')) + aCurrentTab.GetDecimal() = aChar[0]; + + const int nPos = FindCurrentTab(); + if (nPos != -1) + { + aNewTabs->Remove( nPos ); + aNewTabs->Insert( aCurrentTab ); + } +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, SelectHdl_Impl, weld::TreeView&, bool) +{ + const int nPos = FindCurrentTab(); + if (nPos != -1) + { + aCurrentTab = (*aNewTabs)[nPos]; + m_xNewBtn->set_sensitive(false); + SetFillAndTabType_Impl(); + } + return true; +} + +OUString SvxTabulatorTabPage::FormatTab() +{ + m_xTabSpin->set_text(m_xTabBox->get_active_text()); + m_xTabSpin->reformat(); + return m_xTabSpin->get_text(); +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, ReformatHdl_Impl, weld::Widget&, void) +{ + m_xTabBox->set_entry_text(FormatTab()); +} + +IMPL_LINK_NOARG(SvxTabulatorTabPage, ModifyHdl_Impl, weld::ComboBox&, void) +{ + const int nPos = FindCurrentTab(); + if (nPos != -1) + { + aCurrentTab = (*aNewTabs)[nPos]; + SetFillAndTabType_Impl(); + + m_xTabSpin->set_text(m_xTabBox->get_active_text()); + aCurrentTab.GetTabPos() = m_xTabSpin->denormalize(m_xTabSpin->get_value(eDefUnit)); + m_xNewBtn->set_sensitive(false); + m_xDelBtn->set_sensitive(true); + return; + } + m_xNewBtn->set_sensitive(true); + m_xDelBtn->set_sensitive(false); +} + +void SvxTabulatorTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt16Item* pControlItem = aSet.GetItem<SfxUInt16Item>(SID_SVXTABULATORTABPAGE_DISABLEFLAGS, false); + if (pControlItem) + DisableControls(static_cast<TabulatorDisableFlags>(pControlItem->GetValue())); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/textanim.cxx b/cui/source/tabpages/textanim.cxx new file mode 100644 index 000000000..e086969bb --- /dev/null +++ b/cui/source/tabpages/textanim.cxx @@ -0,0 +1,534 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <textanim.hxx> +#include <textattr.hxx> +#include <TextColumnsPage.hxx> +#include <svx/dlgutil.hxx> +#include <svx/svdmark.hxx> +#include <svx/svdview.hxx> +#include <svx/sdtaaitm.hxx> +#include <svx/sdtacitm.hxx> +#include <svx/sdtaiitm.hxx> +#include <svx/sdtayitm.hxx> +#include <svtools/unitconv.hxx> + +const WhichRangesContainer SvxTextAnimationPage::pRanges( + svl::Items<SDRATTR_TEXT_ANIKIND, SDRATTR_TEXT_ANIAMOUNT>); + +/************************************************************************* +|* +|* constructor of the tab dialog: adds pages to the dialog +|* +\************************************************************************/ + +SvxTextTabDialog::SvxTextTabDialog(weld::Window* pParent, const SfxItemSet* pAttr, const SdrView* pSdrView) + : SfxTabDialogController(pParent, "cui/ui/textdialog.ui", "TextDialog", pAttr) + , pView(pSdrView) +{ + AddTabPage("RID_SVXPAGE_TEXTATTR", SvxTextAttrPage::Create, nullptr); + AddTabPage("RID_SVXPAGE_TEXTANIMATION", SvxTextAnimationPage::Create, nullptr); + AddTabPage("RID_SVXPAGE_TEXTCOLUMNS", SvxTextColumnsPage::Create, nullptr); +} + +/************************************************************************* +|* +|* PageCreated() +|* +\************************************************************************/ + +void SvxTextTabDialog::PageCreated(const OString& rId, SfxTabPage &rPage) +{ + if (rId != "RID_SVXPAGE_TEXTATTR") + return; + + SdrObjKind eKind = SdrObjKind::NONE; + if (pView) + { + const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); + bool bHasMarked = rMarkList.GetMarkCount() > 0; + if (bHasMarked) + { + if (rMarkList.GetMarkCount() == 1) + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + eKind = pObj->GetObjIdentifier(); + } + } + } + static_cast<SvxTextAttrPage&>(rPage).SetObjKind(eKind); + static_cast<SvxTextAttrPage&>(rPage).Construct(); +} + +/************************************************************************* +|* +|* Page +|* +\************************************************************************/ +SvxTextAnimationPage::SvxTextAnimationPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/textanimtabpage.ui", "TextAnimation", &rInAttrs) + , eAniKind(SdrTextAniKind::NONE) + , m_aUpState(TRISTATE_INDET) + , m_aLeftState(TRISTATE_INDET) + , m_aRightState(TRISTATE_INDET) + , m_aDownState(TRISTATE_INDET) + , m_xLbEffect(m_xBuilder->weld_combo_box("LB_EFFECT")) + , m_xBoxDirection(m_xBuilder->weld_widget("boxDIRECTION")) + , m_xBtnUp(m_xBuilder->weld_toggle_button("BTN_UP")) + , m_xBtnLeft(m_xBuilder->weld_toggle_button("BTN_LEFT")) + , m_xBtnRight(m_xBuilder->weld_toggle_button("BTN_RIGHT")) + , m_xBtnDown(m_xBuilder->weld_toggle_button("BTN_DOWN")) + , m_xFlProperties(m_xBuilder->weld_frame("FL_PROPERTIES")) + , m_xTsbStartInside(m_xBuilder->weld_check_button("TSB_START_INSIDE")) + , m_xTsbStopInside(m_xBuilder->weld_check_button("TSB_STOP_INSIDE")) + , m_xBoxCount(m_xBuilder->weld_widget("boxCOUNT")) + , m_xTsbEndless(m_xBuilder->weld_check_button("TSB_ENDLESS")) + , m_xNumFldCount(m_xBuilder->weld_spin_button("NUM_FLD_COUNT")) + , m_xTsbPixel(m_xBuilder->weld_check_button("TSB_PIXEL")) + , m_xMtrFldAmount(m_xBuilder->weld_metric_spin_button("MTR_FLD_AMOUNT", FieldUnit::PIXEL)) + , m_xTsbAuto(m_xBuilder->weld_check_button("TSB_AUTO")) + , m_xMtrFldDelay(m_xBuilder->weld_metric_spin_button("MTR_FLD_DELAY", FieldUnit::MILLISECOND)) +{ + eFUnit = GetModuleFieldUnit( rInAttrs ); + SfxItemPool* pPool = rInAttrs.GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + eUnit = pPool->GetMetric( SDRATTR_TEXT_LEFTDIST ); + + m_xLbEffect->connect_changed( LINK( this, SvxTextAnimationPage, SelectEffectHdl_Impl ) ); + m_xTsbEndless->connect_toggled( LINK( this, SvxTextAnimationPage, ClickEndlessHdl_Impl ) ); + m_xTsbAuto->connect_toggled( LINK( this, SvxTextAnimationPage, ClickAutoHdl_Impl ) ); + m_xTsbPixel->connect_toggled( LINK( this, SvxTextAnimationPage, ClickPixelHdl_Impl ) ); + + Link<weld::Button&,void> aLink( LINK( this, SvxTextAnimationPage, ClickDirectionHdl_Impl ) ); + m_xBtnUp->connect_clicked( aLink ); + m_xBtnLeft->connect_clicked( aLink ); + m_xBtnRight->connect_clicked( aLink ); + m_xBtnDown->connect_clicked( aLink ); +} + +SvxTextAnimationPage::~SvxTextAnimationPage() +{ +} + +/************************************************************************* +|* +|* reads the passed item set +|* +\************************************************************************/ + +void SvxTextAnimationPage::Reset( const SfxItemSet* rAttrs ) +{ + const SfxItemPool* pPool = rAttrs->GetPool(); + + // animation type + const SfxPoolItem* pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANIKIND ); + + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANIKIND ); + + eAniKind = static_cast<const SdrTextAniKindItem*>(pItem)->GetValue(); + m_xLbEffect->set_active(sal::static_int_cast<sal_Int32>(eAniKind)); + m_xLbEffect->save_value(); + + // animation direction + pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANIDIRECTION ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANIDIRECTION ); + + SelectDirection(static_cast<const SdrTextAniDirectionItem*>(pItem)->GetValue()); + m_aUpState = m_xBtnUp->get_state(); + m_aLeftState = m_xBtnLeft->get_state(); + m_aRightState = m_xBtnRight->get_state(); + m_aDownState = m_xBtnDown->get_state(); + + // Start inside + pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANISTARTINSIDE ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANISTARTINSIDE ); + + if (static_cast<const SdrTextAniStartInsideItem*>(pItem)->GetValue()) + m_xTsbStartInside->set_state(TRISTATE_TRUE); + else + m_xTsbStartInside->set_state(TRISTATE_FALSE); + m_xTsbStartInside->save_state(); + + // Stop inside + pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANISTOPINSIDE ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANISTOPINSIDE ); + + if (static_cast<const SdrTextAniStopInsideItem*>(pItem)->GetValue()) + m_xTsbStopInside->set_state(TRISTATE_TRUE); + else + m_xTsbStopInside->set_state(TRISTATE_FALSE); + m_xTsbStopInside->save_state(); + + // quantity + pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANICOUNT ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANICOUNT ); + + tools::Long nValue = static_cast<tools::Long>(static_cast<const SdrTextAniCountItem*>(pItem)->GetValue()); + m_xNumFldCount->set_value(nValue); + if (nValue == 0) + { + if (eAniKind == SdrTextAniKind::Slide) + { + m_xTsbEndless->set_state(TRISTATE_FALSE); + m_xTsbEndless->set_sensitive(false); + } + else + { + m_xTsbEndless->set_state(TRISTATE_TRUE); + m_xNumFldCount->set_text(""); + } + } + else + m_xTsbEndless->set_state(TRISTATE_FALSE); + m_xTsbEndless->save_state(); + m_xNumFldCount->save_value(); + + // delay + pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANIDELAY ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANIDELAY ); + + nValue = static_cast<tools::Long>(static_cast<const SdrTextAniDelayItem*>(pItem)->GetValue()); + m_xMtrFldDelay->set_value(nValue, FieldUnit::NONE); + if (nValue == 0) + { + m_xTsbAuto->set_state(TRISTATE_TRUE); + m_xMtrFldDelay->set_text(""); + } + else + m_xTsbAuto->set_state(TRISTATE_FALSE); + m_xTsbAuto->save_state(); + m_xMtrFldDelay->save_value(); + + // step size + pItem = GetItem( *rAttrs, SDRATTR_TEXT_ANIAMOUNT ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_ANIAMOUNT ); + + nValue = static_cast<tools::Long>(static_cast<const SdrTextAniAmountItem*>(pItem)->GetValue()); + if (nValue <= 0) + { + m_xTsbPixel->set_state(TRISTATE_TRUE); + nValue = -nValue; + if (nValue == 0) + nValue++; + m_xMtrFldAmount->set_unit(FieldUnit::CUSTOM); + m_xMtrFldAmount->set_digits(0); + + m_xMtrFldAmount->set_increments(1, 10, FieldUnit::NONE); + m_xMtrFldAmount->set_range(1, 100, FieldUnit::NONE); + m_xMtrFldAmount->set_value(nValue, FieldUnit::NONE); + } + else + { + m_xTsbPixel->set_state(TRISTATE_FALSE); + m_xMtrFldAmount->set_unit(eFUnit); + m_xMtrFldAmount->set_digits(2); + + m_xMtrFldAmount->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldAmount->set_range(1, 10000, FieldUnit::NONE); + + SetMetricValue(*m_xMtrFldAmount, nValue, eUnit); + } + m_xTsbPixel->save_state(); + m_xMtrFldAmount->save_value(); + + SelectEffectHdl_Impl(*m_xLbEffect); + ClickEndlessHdl_Impl(*m_xTsbEndless); + ClickAutoHdl_Impl(*m_xTsbAuto); +} + +/************************************************************************* +|* +|* fills the passed item set with dialog box attributes +|* +\************************************************************************/ + +bool SvxTextAnimationPage::FillItemSet( SfxItemSet* rAttrs) +{ + bool bModified = false; + TriState eState; + + // animation type + int nPos = m_xLbEffect->get_active(); + if( nPos != -1 && + m_xLbEffect->get_value_changed_from_saved() ) + { + rAttrs->Put( SdrTextAniKindItem( static_cast<SdrTextAniKind>(nPos) ) ); + bModified = true; + } + + // animation direction + if (m_aUpState != m_xBtnUp->get_state() || + m_aLeftState != m_xBtnLeft->get_state() || + m_aRightState != m_xBtnRight->get_state() || + m_aDownState != m_xBtnDown->get_state()) + { + SdrTextAniDirection eValue = static_cast<SdrTextAniDirection>(GetSelectedDirection()); + rAttrs->Put( SdrTextAniDirectionItem( eValue ) ); + bModified = true; + } + + // Start inside + eState = m_xTsbStartInside->get_state(); + if (m_xTsbStartInside->get_state_changed_from_saved()) + { + rAttrs->Put( SdrTextAniStartInsideItem( TRISTATE_TRUE == eState ) ); + bModified = true; + } + + // Stop inside + eState = m_xTsbStopInside->get_state(); + if (m_xTsbStopInside->get_state_changed_from_saved()) + { + rAttrs->Put( SdrTextAniStopInsideItem( TRISTATE_TRUE == eState ) ); + bModified = true; + } + + // quantity + eState = m_xTsbEndless->get_state(); + if (m_xTsbEndless->get_state_changed_from_saved() || + m_xNumFldCount->get_value_changed_from_saved()) + { + sal_Int64 nValue = 0; + if( eState == TRISTATE_TRUE /*#89844#*/ && m_xTsbEndless->get_sensitive()) + bModified = true; + else + { + if( m_xNumFldCount->get_value_changed_from_saved() ) + { + nValue = m_xNumFldCount->get_value(); + bModified = true; + } + } + if( bModified ) + rAttrs->Put( SdrTextAniCountItem( static_cast<sal_uInt16>(nValue) ) ); + } + + // delay + eState = m_xTsbAuto->get_state(); + if (m_xTsbAuto->get_state_changed_from_saved() || + m_xMtrFldDelay->get_value_changed_from_saved()) + { + sal_Int64 nValue = 0; + if( eState == TRISTATE_TRUE ) + bModified = true; + else + { + if( m_xMtrFldDelay->get_value_changed_from_saved() ) + { + nValue = m_xMtrFldDelay->get_value(FieldUnit::NONE); + bModified = true; + } + } + if( bModified ) + rAttrs->Put( SdrTextAniDelayItem( static_cast<sal_uInt16>(nValue) ) ); + } + + // step size + eState = m_xTsbPixel->get_state(); + if (m_xTsbPixel->get_state_changed_from_saved() || + m_xMtrFldAmount->get_value_changed_from_saved()) + { + sal_Int64 nValue = 0; + if( eState == TRISTATE_TRUE ) + { + nValue = m_xMtrFldAmount->get_value(FieldUnit::NONE); + nValue = -nValue; + } + else + { + nValue = GetCoreValue( *m_xMtrFldAmount, eUnit ); + } + rAttrs->Put( SdrTextAniAmountItem( static_cast<sal_Int16>(nValue) ) ); + + bModified = true; + } + + return bModified; +} + +/************************************************************************* +|* +|* creates the page +|* +\************************************************************************/ + +std::unique_ptr<SfxTabPage> SvxTextAnimationPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxTextAnimationPage>(pPage, pController, *rAttrs); +} + +IMPL_LINK_NOARG(SvxTextAnimationPage, SelectEffectHdl_Impl, weld::ComboBox&, void) +{ + int nPos = m_xLbEffect->get_active(); + if (nPos == -1) + return; + + eAniKind = static_cast<SdrTextAniKind>(nPos); + switch( eAniKind ) + { + case SdrTextAniKind::NONE: + { + m_xBoxDirection->set_sensitive(false); + m_xFlProperties->set_sensitive(false); + } + break; + + case SdrTextAniKind::Blink: + case SdrTextAniKind::Scroll: + case SdrTextAniKind::Alternate: + case SdrTextAniKind::Slide: + { + m_xFlProperties->set_sensitive(true); + if( eAniKind == SdrTextAniKind::Slide ) + { + m_xTsbStartInside->set_sensitive(false); + m_xTsbStopInside->set_sensitive(false); + m_xTsbEndless->set_sensitive(false); + m_xNumFldCount->set_sensitive(true); + m_xNumFldCount->set_value(m_xNumFldCount->get_value()); + } + else + { + m_xTsbStartInside->set_sensitive(true); + m_xTsbStopInside->set_sensitive(true); + m_xTsbEndless->set_sensitive(true); + ClickEndlessHdl_Impl(*m_xTsbEndless); + } + + m_xTsbAuto->set_sensitive(true); + ClickAutoHdl_Impl(*m_xTsbAuto); + + if( eAniKind == SdrTextAniKind::Blink ) + { + m_xBoxDirection->set_sensitive(false); + m_xBoxCount->set_sensitive(false); + } + else + { + m_xBoxDirection->set_sensitive(true); + m_xBoxCount->set_sensitive(true); + } + } + break; + } +} + +IMPL_LINK_NOARG(SvxTextAnimationPage, ClickEndlessHdl_Impl, weld::Toggleable&, void) +{ + if( eAniKind == SdrTextAniKind::Slide ) + return; + + TriState eState = m_xTsbEndless->get_state(); + if( eState != TRISTATE_FALSE ) + { + m_xNumFldCount->set_sensitive(false); + m_xNumFldCount->set_text(""); + } + else + { + m_xNumFldCount->set_sensitive(true); + m_xNumFldCount->set_value(m_xNumFldCount->get_value()); + } +} + +IMPL_LINK_NOARG(SvxTextAnimationPage, ClickAutoHdl_Impl, weld::Toggleable&, void) +{ + TriState eState = m_xTsbAuto->get_state(); + if( eState != TRISTATE_FALSE ) + { + m_xMtrFldDelay->set_sensitive(false); + m_xMtrFldDelay->set_text(""); + } + else + { + m_xMtrFldDelay->set_sensitive(true); + m_xMtrFldDelay->set_value(m_xMtrFldDelay->get_value(FieldUnit::NONE), FieldUnit::NONE); //to-do + } +} + +IMPL_LINK_NOARG(SvxTextAnimationPage, ClickPixelHdl_Impl, weld::Toggleable&, void) +{ + TriState eState = m_xTsbPixel->get_state(); + if (eState == TRISTATE_TRUE) + { + int nValue = m_xMtrFldAmount->get_value(FieldUnit::NONE) / 10; + m_xMtrFldAmount->set_sensitive(true); + m_xMtrFldAmount->set_unit(FieldUnit::CUSTOM); + m_xMtrFldAmount->set_digits(0); + + m_xMtrFldAmount->set_increments(1, 10, FieldUnit::NONE); + m_xMtrFldAmount->set_range(1, 100, FieldUnit::NONE); + + m_xMtrFldAmount->set_value(nValue, FieldUnit::NONE); + } + else if( eState == TRISTATE_FALSE ) + { + int nValue = m_xMtrFldAmount->get_value(FieldUnit::NONE) * 10; + m_xMtrFldAmount->set_sensitive(true); + m_xMtrFldAmount->set_unit(eFUnit); + m_xMtrFldAmount->set_digits(2); + + m_xMtrFldAmount->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldAmount->set_range(1, 10000, FieldUnit::NONE); + + m_xMtrFldAmount->set_value(nValue, FieldUnit::NONE); + } +} + +IMPL_LINK(SvxTextAnimationPage, ClickDirectionHdl_Impl, weld::Button&, rBtn, void) +{ + m_xBtnUp->set_active(&rBtn == m_xBtnUp.get()); + m_xBtnLeft->set_active(&rBtn == m_xBtnLeft.get()); + m_xBtnRight->set_active(&rBtn == m_xBtnRight.get()); + m_xBtnDown->set_active(&rBtn == m_xBtnDown.get()); +} + +void SvxTextAnimationPage::SelectDirection( SdrTextAniDirection nValue ) +{ + m_xBtnUp->set_active( nValue == SdrTextAniDirection::Up ); + m_xBtnLeft->set_active( nValue == SdrTextAniDirection::Left ); + m_xBtnRight->set_active( nValue == SdrTextAniDirection::Right ); + m_xBtnDown->set_active( nValue == SdrTextAniDirection::Down ); +} + +sal_uInt16 SvxTextAnimationPage::GetSelectedDirection() const +{ + SdrTextAniDirection nValue = SdrTextAniDirection::Left; + + if( m_xBtnUp->get_active() ) + nValue = SdrTextAniDirection::Up; + else if( m_xBtnLeft->get_active() ) + nValue = SdrTextAniDirection::Left; + else if( m_xBtnRight->get_active() ) + nValue = SdrTextAniDirection::Right; + else if( m_xBtnDown->get_active() ) + nValue = SdrTextAniDirection::Down; + + return static_cast<sal_uInt16>(nValue); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/textattr.cxx b/cui/source/tabpages/textattr.cxx new file mode 100644 index 000000000..f773be6b8 --- /dev/null +++ b/cui/source/tabpages/textattr.cxx @@ -0,0 +1,665 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <svx/svddef.hxx> +#include <svx/sdasitm.hxx> +#include <svx/sdtditm.hxx> +#include <svx/sdtagitm.hxx> +#include <svx/sdtaitm.hxx> +#include <svx/sdtfsitm.hxx> +#include <svx/sdtcfitm.hxx> +#include <svx/svxids.hrc> + +#include <textattr.hxx> +#include <svx/dlgutil.hxx> +#include <editeng/writingmodeitem.hxx> +#include <svtools/unitconv.hxx> +#include <osl/diagnose.h> + +using namespace ::com::sun::star; + +const WhichRangesContainer SvxTextAttrPage::pRanges( + svl::Items< + SDRATTR_MISC_FIRST ,SDRATTR_TEXT_HORZADJUST, + SDRATTR_TEXT_WORDWRAP, SDRATTR_TEXT_WORDWRAP +>); + +/************************************************************************* +|* +|* dialog (page) for copying objects +|* +\************************************************************************/ +SvxTextAttrPage::SvxTextAttrPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxTabPage(pPage, pController, "cui/ui/textattrtabpage.ui", "TextAttributesPage", rInAttrs) + , rOutAttrs(rInAttrs) + , m_eObjKind(SdrObjKind::NONE) + , bAutoGrowSizeEnabled(false) + , bContourEnabled(false) + , bAutoGrowWidthEnabled(false) + , bAutoGrowHeightEnabled(false) + , bWordWrapTextEnabled(false) + , bFitToSizeEnabled(false) + , m_aCtlPosition(this) + , m_xDrawingText(m_xBuilder->weld_widget("drawingtext")) + , m_xCustomShapeText(m_xBuilder->weld_widget("customshapetext")) + , m_xTsbAutoGrowWidth(m_xBuilder->weld_check_button("TSB_AUTOGROW_WIDTH")) + , m_xTsbAutoGrowHeight(m_xBuilder->weld_check_button("TSB_AUTOGROW_HEIGHT")) + , m_xTsbFitToSize(m_xBuilder->weld_check_button("TSB_FIT_TO_SIZE")) + , m_xTsbContour(m_xBuilder->weld_check_button("TSB_CONTOUR")) + , m_xTsbWordWrapText(m_xBuilder->weld_check_button("TSB_WORDWRAP_TEXT")) + , m_xTsbAutoGrowSize(m_xBuilder->weld_check_button("TSB_AUTOGROW_SIZE")) + , m_xFlDistance(m_xBuilder->weld_frame("FL_DISTANCE")) + , m_xMtrFldLeft(m_xBuilder->weld_metric_spin_button("MTR_FLD_LEFT", FieldUnit::CM)) + , m_xMtrFldRight(m_xBuilder->weld_metric_spin_button("MTR_FLD_RIGHT", FieldUnit::CM)) + , m_xMtrFldTop(m_xBuilder->weld_metric_spin_button("MTR_FLD_TOP", FieldUnit::CM)) + , m_xMtrFldBottom(m_xBuilder->weld_metric_spin_button("MTR_FLD_BOTTOM", FieldUnit::CM)) + , m_xFlPosition(m_xBuilder->weld_frame("FL_POSITION")) + , m_xCtlPosition(new weld::CustomWeld(*m_xBuilder, "CTL_POSITION", m_aCtlPosition)) + , m_xTsbFullWidth(m_xBuilder->weld_check_button("TSB_FULL_WIDTH")) +{ + m_aCtlPosition.SetControlSettings(RectPoint::MM, 240); + + FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs ); + SetFieldUnit( *m_xMtrFldLeft, eFUnit ); + SetFieldUnit( *m_xMtrFldRight, eFUnit ); + SetFieldUnit( *m_xMtrFldTop, eFUnit ); + SetFieldUnit( *m_xMtrFldBottom, eFUnit ); + + Link<weld::Toggleable&,void> aLink( LINK( this, SvxTextAttrPage, ClickHdl_Impl ) ); + m_xTsbAutoGrowWidth->connect_toggled( aLink ); + m_xTsbAutoGrowHeight->connect_toggled( aLink ); + m_xTsbAutoGrowSize->connect_toggled( aLink ); + m_xTsbFitToSize->connect_toggled( aLink ); + m_xTsbContour->connect_toggled( aLink ); + + m_xTsbFullWidth->connect_toggled(LINK( this, SvxTextAttrPage, ClickFullWidthHdl_Impl ) ); +} + +SvxTextAttrPage::~SvxTextAttrPage() +{ +} + +/************************************************************************* +|* +|* reads the passed item set +|* +\************************************************************************/ + +void SvxTextAttrPage::Reset( const SfxItemSet* rAttrs ) +{ + SfxItemPool* pPool = rAttrs->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + MapUnit eUnit = pPool->GetMetric( SDRATTR_TEXT_LEFTDIST ); + + const SdrMetricItem* pItem = GetItem(*rAttrs, SDRATTR_TEXT_LEFTDIST); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_LEFTDIST ); + + SetMetricValue(*m_xMtrFldLeft, pItem->GetValue(), eUnit); + m_xMtrFldLeft->save_value(); + + pItem = GetItem( *rAttrs, SDRATTR_TEXT_RIGHTDIST ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_RIGHTDIST ); + + SetMetricValue(*m_xMtrFldRight, pItem->GetValue(), eUnit); + m_xMtrFldRight->save_value(); + + pItem = GetItem( *rAttrs, SDRATTR_TEXT_UPPERDIST ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_UPPERDIST ); + + SetMetricValue(*m_xMtrFldTop, pItem->GetValue(), eUnit); + m_xMtrFldTop->save_value(); + + pItem = GetItem( *rAttrs, SDRATTR_TEXT_LOWERDIST ); + if( !pItem ) + pItem = &pPool->GetDefaultItem( SDRATTR_TEXT_LOWERDIST ); + + SetMetricValue(*m_xMtrFldBottom, pItem->GetValue(), eUnit); + m_xMtrFldBottom->save_value(); + + // adjust to height and autogrowsize + if ( rAttrs->GetItemState( SDRATTR_TEXT_AUTOGROWHEIGHT ) != SfxItemState::DONTCARE ) + { + m_xTsbAutoGrowHeight->set_state( rAttrs->Get( SDRATTR_TEXT_AUTOGROWHEIGHT ). + GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE ); + + m_xTsbAutoGrowSize->set_state( rAttrs->Get( SDRATTR_TEXT_AUTOGROWHEIGHT ). + GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + else + { + m_xTsbAutoGrowHeight->set_state( TRISTATE_INDET ); + m_xTsbAutoGrowSize->set_state( TRISTATE_INDET ); + } + m_xTsbAutoGrowHeight->save_state(); + m_xTsbAutoGrowSize->save_state(); + + // adjust to width + if ( rAttrs->GetItemState( SDRATTR_TEXT_AUTOGROWWIDTH ) != SfxItemState::DONTCARE ) + { + m_xTsbAutoGrowWidth->set_state( rAttrs->Get( SDRATTR_TEXT_AUTOGROWWIDTH ). + GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + else + m_xTsbAutoGrowWidth->set_state( TRISTATE_INDET ); + m_xTsbAutoGrowWidth->save_state(); + + // wordwrap text + if ( rAttrs->GetItemState( SDRATTR_TEXT_WORDWRAP ) != SfxItemState::DONTCARE ) + { + m_xTsbWordWrapText->set_state( rAttrs->Get( SDRATTR_TEXT_WORDWRAP ). + GetValue() ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + else + m_xTsbWordWrapText->set_state( TRISTATE_INDET ); + m_xTsbWordWrapText->save_state(); + + + // #103516# Do the setup based on states of hor/ver adjust + // Setup center field and FullWidth + SfxItemState eVState = rAttrs->GetItemState( SDRATTR_TEXT_VERTADJUST ); + SfxItemState eHState = rAttrs->GetItemState( SDRATTR_TEXT_HORZADJUST ); + + if(SfxItemState::DONTCARE != eVState && SfxItemState::DONTCARE != eHState) + { + // VertAdjust and HorAdjust are unequivocal, thus + SdrTextVertAdjust eTVA = rAttrs->Get(SDRATTR_TEXT_VERTADJUST).GetValue(); + SdrTextHorzAdjust eTHA = rAttrs->Get(SDRATTR_TEXT_HORZADJUST).GetValue(); + RectPoint eRP = RectPoint::LB; + + if (m_xTsbFullWidth->get_state() == TRISTATE_INDET) + m_xTsbFullWidth->set_state(TRISTATE_FALSE); + + // Translate item values into local anchor position. + switch (eTVA) + { + case SDRTEXTVERTADJUST_TOP: + { + switch (eTHA) + { + case SDRTEXTHORZADJUST_LEFT: eRP = RectPoint::LT; break; + case SDRTEXTHORZADJUST_BLOCK: + case SDRTEXTHORZADJUST_CENTER: eRP = RectPoint::MT; break; + case SDRTEXTHORZADJUST_RIGHT: eRP = RectPoint::RT; break; + } + break; + } + case SDRTEXTVERTADJUST_BLOCK: + case SDRTEXTVERTADJUST_CENTER: + { + switch (eTHA) + { + case SDRTEXTHORZADJUST_LEFT: eRP = RectPoint::LM; break; + case SDRTEXTHORZADJUST_BLOCK: + case SDRTEXTHORZADJUST_CENTER: eRP = RectPoint::MM; break; + case SDRTEXTHORZADJUST_RIGHT: eRP = RectPoint::RM; break; + } + break; + } + case SDRTEXTVERTADJUST_BOTTOM: + { + switch (eTHA) + { + case SDRTEXTHORZADJUST_LEFT: eRP = RectPoint::LB; break; + case SDRTEXTHORZADJUST_BLOCK: + case SDRTEXTHORZADJUST_CENTER: eRP = RectPoint::MB; break; + case SDRTEXTHORZADJUST_RIGHT: eRP = RectPoint::RB; break; + } + break; + } + default: + break; + } + + // See if we have to check the "full width" check button. + bool bLeftToRight(IsTextDirectionLeftToRight()); + + if((bLeftToRight && (SDRTEXTHORZADJUST_BLOCK == eTHA)) || (!bLeftToRight && (SDRTEXTVERTADJUST_BLOCK == eTVA))) + { + // Move anchor to valid position. + ClickFullWidthHdl_Impl(*m_xTsbFullWidth); + m_xTsbFullWidth->set_state(TRISTATE_TRUE); + } + + m_aCtlPosition.SetActualRP( eRP ); + } + else + { + // VertAdjust or HorAdjust is not unequivocal + m_aCtlPosition.Reset(); + + m_aCtlPosition.SetState(CTL_STATE::NOVERT); + m_aCtlPosition.DoCompletelyDisable(true); + + m_xTsbFullWidth->set_state(TRISTATE_INDET); + m_xFlPosition->set_sensitive( false ); + } + + // adjust to border + if (rAttrs->GetItemState(SDRATTR_TEXT_FITTOSIZE) != SfxItemState::DONTCARE) + { + drawing::TextFitToSizeType const eFTS = + rAttrs->Get( SDRATTR_TEXT_FITTOSIZE ).GetValue(); + if (eFTS == drawing::TextFitToSizeType_AUTOFIT || eFTS == drawing::TextFitToSizeType_NONE) + m_xTsbFitToSize->set_state( TRISTATE_FALSE ); + else + m_xTsbFitToSize->set_state( TRISTATE_TRUE ); + } + else + m_xTsbFitToSize->set_state( TRISTATE_INDET ); + m_xTsbFitToSize->save_state(); + + if( rAttrs->GetItemState( SDRATTR_TEXT_CONTOURFRAME ) != SfxItemState::DONTCARE ) + { + bool bContour = rAttrs->Get( SDRATTR_TEXT_CONTOURFRAME ).GetValue(); + m_xTsbContour->set_state( bContour ? TRISTATE_TRUE : TRISTATE_FALSE ); + } + else + m_xTsbContour->set_state( TRISTATE_INDET ); + m_xTsbContour->save_state(); + + ClickHdl_Impl(*m_xTsbContour); +} + +/************************************************************************* +|* +|* fills the passed item set with dialog box attributes +|* +\************************************************************************/ + +bool SvxTextAttrPage::FillItemSet( SfxItemSet* rAttrs) +{ + SfxItemPool* pPool = rAttrs->GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + MapUnit eUnit = pPool->GetMetric( SDRATTR_TEXT_LEFTDIST ); + + sal_Int32 nValue; + TriState eState; + + if( m_xMtrFldLeft->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldLeft, eUnit ); + rAttrs->Put( makeSdrTextLeftDistItem( nValue ) ); + } + + if( m_xMtrFldRight->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldRight, eUnit ); + rAttrs->Put( makeSdrTextRightDistItem( nValue ) ); + } + + if( m_xMtrFldTop->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldTop, eUnit ); + rAttrs->Put( makeSdrTextUpperDistItem( nValue ) ); + } + + if( m_xMtrFldBottom->get_value_changed_from_saved() ) + { + nValue = GetCoreValue( *m_xMtrFldBottom, eUnit ); + rAttrs->Put( makeSdrTextLowerDistItem( nValue ) ); + } + + eState = m_xTsbAutoGrowHeight->get_state(); + if( m_xTsbAutoGrowHeight->get_state_changed_from_saved() ) + { + rAttrs->Put( makeSdrTextAutoGrowHeightItem( TRISTATE_TRUE == eState ) ); + } + + eState = m_xTsbAutoGrowWidth->get_state(); + if( m_xTsbAutoGrowWidth->get_state_changed_from_saved() ) + { + rAttrs->Put( makeSdrTextAutoGrowWidthItem( TRISTATE_TRUE == eState ) ); + } + + eState = m_xTsbAutoGrowSize->get_state(); + if( m_xTsbAutoGrowSize->get_state_changed_from_saved() ) + { + rAttrs->Put( makeSdrTextAutoGrowHeightItem( TRISTATE_TRUE == eState ) ); + } + + eState = m_xTsbWordWrapText->get_state(); + if( m_xTsbWordWrapText->get_state_changed_from_saved() ) + { + rAttrs->Put( makeSdrTextWordWrapItem( TRISTATE_TRUE == eState ) ); + } + + eState = m_xTsbContour->get_state(); + if( m_xTsbContour->get_state_changed_from_saved() ) + { + rAttrs->Put( makeSdrTextContourFrameItem( TRISTATE_TRUE == eState ) ); + } + + eState = m_xTsbFitToSize->get_state(); + if( m_xTsbFitToSize->get_state_changed_from_saved() ) + { + drawing::TextFitToSizeType eFTS; + switch( eState ) + { + default: ; //prevent warning + OSL_FAIL( "svx::SvxTextAttrPage::FillItemSet(), unhandled state!" ); + [[fallthrough]]; + case TRISTATE_FALSE: eFTS = drawing::TextFitToSizeType_AUTOFIT; break; + case TRISTATE_TRUE: eFTS = drawing::TextFitToSizeType_PROPORTIONAL; break; + } + rAttrs->Put( SdrTextFitToSizeTypeItem( eFTS ) ); + } + + // centered + RectPoint eRP = m_aCtlPosition.GetActualRP(); + SdrTextVertAdjust eTVA; + SdrTextHorzAdjust eTHA; + + switch( eRP ) + { + default: + case RectPoint::LT: eTVA = SDRTEXTVERTADJUST_TOP; + eTHA = SDRTEXTHORZADJUST_LEFT; break; + case RectPoint::LM: eTVA = SDRTEXTVERTADJUST_CENTER; + eTHA = SDRTEXTHORZADJUST_LEFT; break; + case RectPoint::LB: eTVA = SDRTEXTVERTADJUST_BOTTOM; + eTHA = SDRTEXTHORZADJUST_LEFT; break; + case RectPoint::MT: eTVA = SDRTEXTVERTADJUST_TOP; + eTHA = SDRTEXTHORZADJUST_CENTER; break; + case RectPoint::MM: eTVA = SDRTEXTVERTADJUST_CENTER; + eTHA = SDRTEXTHORZADJUST_CENTER; break; + case RectPoint::MB: eTVA = SDRTEXTVERTADJUST_BOTTOM; + eTHA = SDRTEXTHORZADJUST_CENTER; break; + case RectPoint::RT: eTVA = SDRTEXTVERTADJUST_TOP; + eTHA = SDRTEXTHORZADJUST_RIGHT; break; + case RectPoint::RM: eTVA = SDRTEXTVERTADJUST_CENTER; + eTHA = SDRTEXTHORZADJUST_RIGHT; break; + case RectPoint::RB: eTVA = SDRTEXTVERTADJUST_BOTTOM; + eTHA = SDRTEXTHORZADJUST_RIGHT; break; + } + + // #103516# Do not change values if adjust controls were disabled. + bool bIsDisabled(m_aCtlPosition.IsCompletelyDisabled()); + + if(bIsDisabled) + return true; + + if( m_xTsbFullWidth->get_state() == TRISTATE_TRUE ) + { + if (IsTextDirectionLeftToRight()) + eTHA = SDRTEXTHORZADJUST_BLOCK; + else + eTVA = SDRTEXTVERTADJUST_BLOCK; + } + + if ( rOutAttrs.GetItemState( SDRATTR_TEXT_VERTADJUST ) != SfxItemState::DONTCARE ) + { + SdrTextVertAdjust eOldTVA = rOutAttrs.Get( SDRATTR_TEXT_VERTADJUST ).GetValue(); + if( eOldTVA != eTVA ) + rAttrs->Put( SdrTextVertAdjustItem( eTVA ) ); + } + else + rAttrs->Put( SdrTextVertAdjustItem( eTVA ) ); + + if ( rOutAttrs.GetItemState( SDRATTR_TEXT_HORZADJUST ) != SfxItemState::DONTCARE ) + { + SdrTextHorzAdjust eOldTHA = rOutAttrs.Get( SDRATTR_TEXT_HORZADJUST ).GetValue(); + if( eOldTHA != eTHA ) + rAttrs->Put( SdrTextHorzAdjustItem( eTHA ) ); + } + else + rAttrs->Put( SdrTextHorzAdjustItem( eTHA ) ); + + return true; +} + +void SvxTextAttrPage::Construct() +{ + switch (m_eObjKind) + { + case SdrObjKind::NONE: + // indeterminate, show them all + bFitToSizeEnabled = bContourEnabled = bWordWrapTextEnabled = + bAutoGrowSizeEnabled = bAutoGrowWidthEnabled = bAutoGrowHeightEnabled = true; + m_xCustomShapeText->show(); + m_xDrawingText->show(); + break; + case SdrObjKind::Text: + case SdrObjKind::TitleText: + case SdrObjKind::OutlineText: + case SdrObjKind::Caption: + // contour NOT possible for pure text objects + bContourEnabled = bWordWrapTextEnabled = bAutoGrowSizeEnabled = false; + + // adjusting width and height is ONLY possible for pure text objects + bFitToSizeEnabled = bAutoGrowWidthEnabled = bAutoGrowHeightEnabled = true; + m_xCustomShapeText->hide(); + m_xDrawingText->show(); + break; + case SdrObjKind::CustomShape: + bFitToSizeEnabled = bContourEnabled = bAutoGrowWidthEnabled = bAutoGrowHeightEnabled = false; + bWordWrapTextEnabled = bAutoGrowSizeEnabled = true; + m_xDrawingText->hide(); + m_xCustomShapeText->show(); + break; + default: + bFitToSizeEnabled = bContourEnabled = true; + bWordWrapTextEnabled = bAutoGrowSizeEnabled = bAutoGrowWidthEnabled = bAutoGrowHeightEnabled = false; + m_xCustomShapeText->hide(); + m_xDrawingText->show(); + break; + } + + m_xTsbAutoGrowHeight->set_visible( bAutoGrowHeightEnabled ); + m_xTsbAutoGrowWidth->set_visible( bAutoGrowWidthEnabled ); + m_xTsbFitToSize->set_visible( bFitToSizeEnabled ); + m_xTsbContour->set_visible( bContourEnabled ); + m_xTsbAutoGrowSize->set_visible( bAutoGrowSizeEnabled ); + m_xTsbWordWrapText->set_visible( bWordWrapTextEnabled ); +} + +std::unique_ptr<SfxTabPage> SvxTextAttrPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxTextAttrPage>(pPage, pController, *rAttrs); +} + +/** Check whether we have to uncheck the "Full width" check box. +*/ +void SvxTextAttrPage::PointChanged(weld::DrawingArea*, RectPoint eRP) +{ + if (m_xTsbFullWidth->get_state() != TRISTATE_TRUE) + return; + + // Depending on write direction and currently checked anchor we have + // to uncheck the "full width" button. + if (IsTextDirectionLeftToRight()) + switch( eRP ) + { + case RectPoint::LT: + case RectPoint::LM: + case RectPoint::LB: + case RectPoint::RT: + case RectPoint::RM: + case RectPoint::RB: + m_xTsbFullWidth->set_state( TRISTATE_FALSE ); + break; + default: ;//prevent warning + } + else + switch (eRP) + { + case RectPoint::LT: + case RectPoint::MT: + case RectPoint::RT: + case RectPoint::LB: + case RectPoint::MB: + case RectPoint::RB: + m_xTsbFullWidth->set_state( TRISTATE_FALSE ); + break; + default: ;//prevent warning + } +} + + +/************************************************************************* +|* +|* possibly changes the position of the position-control +|* +\************************************************************************/ + +/** When switching the "full width" check button on the text anchor may have + to be moved to a valid and adjacent position. This position depends on + the current anchor position and the text writing direction. +*/ +IMPL_LINK_NOARG(SvxTextAttrPage, ClickFullWidthHdl_Impl, weld::Toggleable&, void) +{ + if( m_xTsbFullWidth->get_state() != TRISTATE_TRUE ) + return; + + if (IsTextDirectionLeftToRight()) + { + // Move text anchor to horizontal middle axis. + switch( m_aCtlPosition.GetActualRP() ) + { + case RectPoint::LT: + case RectPoint::RT: + m_aCtlPosition.SetActualRP( RectPoint::MT ); + break; + + case RectPoint::LM: + case RectPoint::RM: + m_aCtlPosition.SetActualRP( RectPoint::MM ); + break; + + case RectPoint::LB: + case RectPoint::RB: + m_aCtlPosition.SetActualRP( RectPoint::MB ); + break; + default: ;//prevent warning + } + } + else + { + // Move text anchor to vertical middle axis. + switch( m_aCtlPosition.GetActualRP() ) + { + case RectPoint::LT: + case RectPoint::LB: + m_aCtlPosition.SetActualRP( RectPoint::LM ); + break; + + case RectPoint::MT: + case RectPoint::MB: + m_aCtlPosition.SetActualRP( RectPoint::MM ); + break; + + case RectPoint::RT: + case RectPoint::RB: + m_aCtlPosition.SetActualRP( RectPoint::RM ); + break; + default: ;//prevent warning + } + } +} + +/************************************************************************* +|* +|* enables/disables "size at text" or "adjust to frame" +|* +\************************************************************************/ + +IMPL_LINK(SvxTextAttrPage, ClickHdl_Impl, weld::Toggleable&, rButton, void) +{ + if (&rButton == m_xTsbAutoGrowSize.get()) + { + m_xTsbAutoGrowHeight->set_state(m_xTsbAutoGrowSize->get_state()); + if (m_xTsbAutoGrowSize->get_state() == TRISTATE_TRUE) + { + m_xTsbFitToSize->set_state(TRISTATE_FALSE); + m_xTsbContour->set_state(TRISTATE_FALSE); + } + } + else if (&rButton == m_xTsbAutoGrowHeight.get()) + m_xTsbAutoGrowSize->set_state(m_xTsbAutoGrowHeight->get_state()); + + bool bAutoGrowWidth = m_xTsbAutoGrowWidth->get_state() == TRISTATE_TRUE; + bool bAutoGrowHeight = m_xTsbAutoGrowHeight->get_state() == TRISTATE_TRUE; + bool bFitToSize = m_xTsbFitToSize->get_state() == TRISTATE_TRUE; + bool bContour = m_xTsbContour->get_state() == TRISTATE_TRUE; + + m_xTsbContour->set_sensitive( !bFitToSize && + !( ( bAutoGrowWidth && bAutoGrowWidthEnabled ) || ( bAutoGrowHeight && bAutoGrowHeightEnabled ) ) && + bContourEnabled ); + + m_xTsbAutoGrowWidth->set_sensitive( !bFitToSize && + !( bContour && bContourEnabled ) && + bAutoGrowWidthEnabled ); + + m_xTsbAutoGrowHeight->set_sensitive( !bFitToSize && + !( bContour && bContourEnabled ) && + bAutoGrowHeightEnabled ); + + m_xTsbFitToSize->set_sensitive( !( ( bAutoGrowWidth && bAutoGrowWidthEnabled ) || ( bAutoGrowHeight && bAutoGrowHeightEnabled ) ) && + !( bContour && bContourEnabled ) && + bFitToSizeEnabled ); + + // #101901# enable/disable metric fields and decorations dependent of contour + m_xFlDistance->set_sensitive(!bContour); + + if( bContour && bContourEnabled ) + { + m_xMtrFldLeft->set_value(0, FieldUnit::NONE); + m_xMtrFldRight->set_value(0, FieldUnit::NONE); + m_xMtrFldTop->set_value(0, FieldUnit::NONE); + m_xMtrFldBottom->set_value(0, FieldUnit::NONE); + } + + // #103516# Do the setup based on states of hor/ver adjust + SfxItemState eVState = rOutAttrs.GetItemState( SDRATTR_TEXT_VERTADJUST ); + SfxItemState eHState = rOutAttrs.GetItemState( SDRATTR_TEXT_HORZADJUST ); + bool bHorAndVer(SfxItemState::DONTCARE == eVState || SfxItemState::DONTCARE == eHState); + + // #83698# enable/disable text anchoring dependent of contour + m_xFlPosition->set_sensitive(!bContour && !bHorAndVer); +} + + +bool SvxTextAttrPage::IsTextDirectionLeftToRight() const +{ + // Determine the text writing direction with left to right as default. + bool bLeftToRightDirection = true; + SfxItemState eState = rOutAttrs.GetItemState(SDRATTR_TEXTDIRECTION); + + if(SfxItemState::DONTCARE != eState) + { + const SvxWritingModeItem& rItem = rOutAttrs.Get(SDRATTR_TEXTDIRECTION); + if (rItem.GetValue() == css::text::WritingMode_TB_RL) + bLeftToRightDirection = false; + } + return bLeftToRightDirection; +} + +void SvxTextAttrPage::PageCreated(const SfxAllItemSet& aSet) +{ + const CntUInt16Item* pObjTypeItem = aSet.GetItem<CntUInt16Item>(SID_SVXTEXTATTRPAGE_OBJKIND, false); + + if (pObjTypeItem) + SetObjKind(static_cast<SdrObjKind>(pObjTypeItem->GetValue())); + + Construct(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/themepage.cxx b/cui/source/tabpages/themepage.cxx new file mode 100644 index 000000000..a7ea42801 --- /dev/null +++ b/cui/source/tabpages/themepage.cxx @@ -0,0 +1,176 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */ +/* + * 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/. + */ + +#include <sal/config.h> + +#include <themepage.hxx> + +#include <com/sun/star/beans/PropertyValues.hpp> +#include <com/sun/star/util/Color.hpp> + +#include <comphelper/sequence.hxx> +#include <comphelper/sequenceashashmap.hxx> +#include <editeng/editids.hrc> +#include <sal/log.hxx> +#include <svl/grabbagitem.hxx> +#include <svx/colorbox.hxx> + +using namespace com::sun::star; + +const WhichRangesContainer + SvxThemePage::m_pRanges(svl::Items<SID_ATTR_CHAR_GRABBAG, SID_ATTR_CHAR_GRABBAG>); + +SvxThemePage::SvxThemePage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/themetabpage.ui", "ThemePage", &rInAttrs) + , m_xThemeName(m_xBuilder->weld_entry("themeName")) + , m_xColorSetName(m_xBuilder->weld_entry("colorSetName")) + , m_xDk1(new ColorListBox(m_xBuilder->weld_menu_button("btnDk1"), + [this] { return GetDialogController()->getDialog(); })) + , m_xLt1(new ColorListBox(m_xBuilder->weld_menu_button("btnLt1"), + [this] { return GetDialogController()->getDialog(); })) + , m_xDk2(new ColorListBox(m_xBuilder->weld_menu_button("btnDk2"), + [this] { return GetDialogController()->getDialog(); })) + , m_xLt2(new ColorListBox(m_xBuilder->weld_menu_button("btnLt2"), + [this] { return GetDialogController()->getDialog(); })) + , m_xAccent1(new ColorListBox(m_xBuilder->weld_menu_button("btnAccent1"), + [this] { return GetDialogController()->getDialog(); })) + , m_xAccent2(new ColorListBox(m_xBuilder->weld_menu_button("btnAccent2"), + [this] { return GetDialogController()->getDialog(); })) + , m_xAccent3(new ColorListBox(m_xBuilder->weld_menu_button("btnAccent3"), + [this] { return GetDialogController()->getDialog(); })) + , m_xAccent4(new ColorListBox(m_xBuilder->weld_menu_button("btnAccent4"), + [this] { return GetDialogController()->getDialog(); })) + , m_xAccent5(new ColorListBox(m_xBuilder->weld_menu_button("btnAccent5"), + [this] { return GetDialogController()->getDialog(); })) + , m_xAccent6(new ColorListBox(m_xBuilder->weld_menu_button("btnAccent6"), + [this] { return GetDialogController()->getDialog(); })) + , m_xHlink(new ColorListBox(m_xBuilder->weld_menu_button("btnHlink"), + [this] { return GetDialogController()->getDialog(); })) + , m_xFolHlink(new ColorListBox(m_xBuilder->weld_menu_button("btnFolHlink"), + [this] { return GetDialogController()->getDialog(); })) +{ +} + +SvxThemePage::~SvxThemePage() = default; + +void SvxThemePage::Reset(const SfxItemSet* pAttrs) +{ + const SfxGrabBagItem* pGrabBagItem = pAttrs->GetItemIfSet(SID_ATTR_CHAR_GRABBAG); + if (!pGrabBagItem) + { + SAL_WARN("cui.tabpages", "SvxThemePage::Reset: no SfxGrabBagItem"); + return; + } + + auto itTheme = pGrabBagItem->GetGrabBag().find("Theme"); + if (itTheme == pGrabBagItem->GetGrabBag().end()) + { + // No theme was defined previously, allow specifying colors. + m_xDk1->set_sensitive(true); + m_xLt1->set_sensitive(true); + m_xDk2->set_sensitive(true); + m_xLt2->set_sensitive(true); + m_xAccent1->set_sensitive(true); + m_xAccent2->set_sensitive(true); + m_xAccent3->set_sensitive(true); + m_xAccent4->set_sensitive(true); + m_xAccent5->set_sensitive(true); + m_xAccent6->set_sensitive(true); + m_xHlink->set_sensitive(true); + m_xFolHlink->set_sensitive(true); + return; + } + + comphelper::SequenceAsHashMap aMap(itTheme->second); + auto it = aMap.find("Name"); + if (it != aMap.end()) + { + OUString aName; + it->second >>= aName; + m_xThemeName->set_text(aName); + } + + it = aMap.find("ColorSchemeName"); + if (it != aMap.end()) + { + OUString aName; + it->second >>= aName; + m_xColorSetName->set_text(aName); + } + + it = aMap.find("ColorScheme"); + if (it != aMap.end()) + { + uno::Sequence<util::Color> aColors; + it->second >>= aColors; + m_xDk1->SelectEntry(Color(ColorTransparency, aColors[0])); + m_xLt1->SelectEntry(Color(ColorTransparency, aColors[1])); + m_xDk2->SelectEntry(Color(ColorTransparency, aColors[2])); + m_xLt2->SelectEntry(Color(ColorTransparency, aColors[3])); + m_xAccent1->SelectEntry(Color(ColorTransparency, aColors[4])); + m_xAccent2->SelectEntry(Color(ColorTransparency, aColors[5])); + m_xAccent3->SelectEntry(Color(ColorTransparency, aColors[6])); + m_xAccent4->SelectEntry(Color(ColorTransparency, aColors[7])); + m_xAccent5->SelectEntry(Color(ColorTransparency, aColors[8])); + m_xAccent6->SelectEntry(Color(ColorTransparency, aColors[9])); + m_xHlink->SelectEntry(Color(ColorTransparency, aColors[10])); + m_xFolHlink->SelectEntry(Color(ColorTransparency, aColors[11])); + } +} + +bool SvxThemePage::FillItemSet(SfxItemSet* pAttrs) +{ + const SfxItemSet& rOldSet = GetItemSet(); + + if (!rOldSet.HasItem(SID_ATTR_CHAR_GRABBAG)) + return true; + + SfxGrabBagItem aGrabBagItem(rOldSet.Get(SID_ATTR_CHAR_GRABBAG)); + + comphelper::SequenceAsHashMap aMap; + auto it = aGrabBagItem.GetGrabBag().find("Theme"); + if (it != aGrabBagItem.GetGrabBag().end()) + { + aMap << it->second; + } + + aMap["Name"] <<= m_xThemeName->get_text(); + aMap["ColorSchemeName"] <<= m_xColorSetName->get_text(); + std::vector<util::Color> aColorScheme = { + static_cast<sal_Int32>(m_xDk1->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xLt1->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xDk2->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xLt2->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xAccent1->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xAccent2->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xAccent3->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xAccent4->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xAccent5->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xAccent6->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xHlink->GetSelectEntryColor()), + static_cast<sal_Int32>(m_xFolHlink->GetSelectEntryColor()), + }; + aMap["ColorScheme"] <<= comphelper::containerToSequence(aColorScheme); + + beans::PropertyValues aTheme = aMap.getAsConstPropertyValueList(); + aGrabBagItem.GetGrabBag()["Theme"] <<= aTheme; + pAttrs->Put(aGrabBagItem); + + return true; +} + +std::unique_ptr<SfxTabPage> SvxThemePage::Create(weld::Container* pPage, + weld::DialogController* pController, + const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxThemePage>(pPage, pController, *rAttrs); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */ diff --git a/cui/source/tabpages/tparea.cxx b/cui/source/tabpages/tparea.cxx new file mode 100644 index 000000000..bbdb9733a --- /dev/null +++ b/cui/source/tabpages/tparea.cxx @@ -0,0 +1,510 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <svx/svxids.hrc> +#include <svx/xfillit0.hxx> +#include <svx/xfilluseslidebackgrounditem.hxx> +#include <svx/xflbckit.hxx> +#include <svx/drawitem.hxx> +#include <svx/xflclit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xbtmpit.hxx> +#include <cuitabarea.hxx> +#include <sfx2/tabdlg.hxx> + +using namespace com::sun::star; + +// static ---------------------------------------------------------------- + +namespace { + +enum FillType +{ + TRANSPARENT, + SOLID, + GRADIENT, + HATCH, + BITMAP, + PATTERN, + USE_BACKGROUND_FILL +}; + +} + +const WhichRangesContainer SvxAreaTabPage::pAreaRanges( + svl::Items< + XATTR_GRADIENTSTEPCOUNT, XATTR_GRADIENTSTEPCOUNT, + SID_ATTR_FILL_STYLE, SID_ATTR_FILL_BITMAP>); + +namespace +{ + +void lclExtendSize(Size& rSize, const Size& rInputSize) +{ + if (rSize.Width() < rInputSize.Width()) + rSize.setWidth( rInputSize.Width() ); + if (rSize.Height() < rInputSize.Height()) + rSize.setHeight( rInputSize.Height() ); +} + +} // end anonymous namespace + +/************************************************************************* +|* +|* Dialog to modify fill-attributes +|* +\************************************************************************/ + +SvxAreaTabPage::SvxAreaTabPage(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet& rInAttrs, bool bSlideBackground) + : SfxTabPage(pPage, pController, "cui/ui/areatabpage.ui", "AreaTabPage", &rInAttrs) + // local fixed not o be changed values for local pointers + , maFixed_ChangeType(ChangeType::NONE) + // init with pointers to fixed ChangeType + , m_pnColorListState(&maFixed_ChangeType) + , m_pnBitmapListState(&maFixed_ChangeType) + , m_pnPatternListState(&maFixed_ChangeType) + , m_pnGradientListState(&maFixed_ChangeType) + , m_pnHatchingListState(&maFixed_ChangeType) + , m_aXFillAttr(rInAttrs.GetPool()) + , m_rXFSet(m_aXFillAttr.GetItemSet()) + , m_xFillTab(m_xBuilder->weld_container("fillstylebox")) + , m_xBtnNone(m_xBuilder->weld_toggle_button("btnnone")) + , m_xBtnColor(m_xBuilder->weld_toggle_button("btncolor")) + , m_xBtnGradient(m_xBuilder->weld_toggle_button("btngradient")) + , m_xBtnHatch(m_xBuilder->weld_toggle_button("btnhatch")) + , m_xBtnBitmap(m_xBuilder->weld_toggle_button("btnbitmap")) + , m_xBtnPattern(m_xBuilder->weld_toggle_button("btnpattern")) + , m_xBtnUseBackground(m_xBuilder->weld_toggle_button("btnusebackground")) +{ + maBox.AddButton(m_xBtnNone.get()); + maBox.AddButton(m_xBtnColor.get()); + maBox.AddButton(m_xBtnGradient.get()); + maBox.AddButton(m_xBtnHatch.get()); + maBox.AddButton(m_xBtnBitmap.get()); + maBox.AddButton(m_xBtnPattern.get()); + + Link<weld::Toggleable&, void> aLink = LINK(this, SvxAreaTabPage, SelectFillTypeHdl_Impl); + m_xBtnNone->connect_toggled(aLink); + m_xBtnColor->connect_toggled(aLink); + m_xBtnGradient->connect_toggled(aLink); + m_xBtnHatch->connect_toggled(aLink); + m_xBtnBitmap->connect_toggled(aLink); + m_xBtnPattern->connect_toggled(aLink); + if (bSlideBackground) + { + maBox.AddButton(m_xBtnUseBackground.get()); + m_xBtnUseBackground->connect_toggled(aLink); + } + else + m_xBtnUseBackground->hide(); + + SetExchangeSupport(); +} + +void SvxAreaTabPage::SetOptimalSize(weld::DialogController* pController) +{ + m_xFillTab->set_size_request(-1, -1); + + // Calculate optimal size of all pages... + m_xFillTabPage = SvxColorTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet); + Size aSize(m_xFillTab->get_preferred_size()); + + if (m_xBtnGradient->get_visible()) + { + m_xFillTabPage = SvxGradientTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet); + Size aGradientSize = m_xFillTab->get_preferred_size(); + lclExtendSize(aSize, aGradientSize); + } + if (m_xBtnBitmap->get_visible()) + { + m_xFillTabPage = SvxBitmapTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet); + Size aBitmapSize = m_xFillTab->get_preferred_size(); + lclExtendSize(aSize, aBitmapSize); + } + if (m_xBtnHatch->get_visible()) + { + m_xFillTabPage = SvxHatchTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet); + Size aHatchSize = m_xFillTab->get_preferred_size(); + lclExtendSize(aSize, aHatchSize); + } + if (m_xBtnPattern->get_visible()) + { + m_xFillTabPage = SvxPatternTabPage::Create(m_xFillTab.get(), pController, &m_rXFSet); + Size aPatternSize = m_xFillTab->get_preferred_size(); + lclExtendSize(aSize, aPatternSize); + } + m_xFillTabPage.reset(); + + aSize.extendBy(10, 10); // apply a bit of margin + + m_xFillTab->set_size_request(aSize.Width(), aSize.Height()); +} + +SvxAreaTabPage::~SvxAreaTabPage() +{ + m_xFillTabPage.reset(); +} + +void SvxAreaTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + drawing::FillStyle eXFS = drawing::FillStyle_NONE; + if( rSet.GetItemState( XATTR_FILLSTYLE ) != SfxItemState::DONTCARE ) + { + XFillStyleItem aFillStyleItem( rSet.Get( GetWhich( XATTR_FILLSTYLE ) ) ); + eXFS = aFillStyleItem.GetValue(); + m_rXFSet.Put( aFillStyleItem ); + } + + switch(eXFS) + { + default: + case drawing::FillStyle_NONE: + { + XFillUseSlideBackgroundItem aBckItem( rSet.Get(XATTR_FILLUSESLIDEBACKGROUND)); + if (aBckItem.GetValue()) + SelectFillType(*m_xBtnUseBackground); + else + SelectFillType(*m_xBtnNone); + break; + } + case drawing::FillStyle_SOLID: + { + m_rXFSet.Put( rSet.Get( GetWhich( XATTR_FILLCOLOR ) ) ); + SelectFillType(*m_xBtnColor); + break; + } + case drawing::FillStyle_GRADIENT: + { + m_rXFSet.Put( rSet.Get( GetWhich( XATTR_FILLGRADIENT ) ) ); + SelectFillType(*m_xBtnGradient); + break; + } + case drawing::FillStyle_HATCH: + { + m_rXFSet.Put( rSet.Get(XATTR_FILLHATCH) ); + m_rXFSet.Put( rSet.Get(XATTR_FILLUSESLIDEBACKGROUND) ); + m_rXFSet.Put( rSet.Get(XATTR_FILLCOLOR) ); + SelectFillType(*m_xBtnHatch); + break; + } + case drawing::FillStyle_BITMAP: + { + const bool bPattern = rSet.Get(GetWhich(XATTR_FILLBITMAP)).isPattern(); + // pass full item set here, bitmap fill has many attributes (tiling, size, offset etc.) + m_rXFSet.Put( rSet ); + if (!bPattern) + SelectFillType(*m_xBtnBitmap); + else + SelectFillType(*m_xBtnPattern); + break; + } + } +} + +template< typename TTabPage > +DeactivateRC SvxAreaTabPage::DeactivatePage_Impl( SfxItemSet* _pSet ) +{ + return static_cast<TTabPage&>(*m_xFillTabPage).DeactivatePage(_pSet); +} + +DeactivateRC SvxAreaTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + FillType eFillType = static_cast<FillType>(maBox.GetCurrentButtonPos()); + switch( eFillType ) + { + case TRANSPARENT: + { + // Fill: None doesn't have its own tabpage and thus + // implementation of FillItemSet, so we supply it here + if ( m_bBtnClicked ) + { + XFillStyleItem aStyleItem( drawing::FillStyle_NONE ); + _pSet->Put( aStyleItem ); + if (_pSet->HasItem(XATTR_FILLUSESLIDEBACKGROUND)) + { + XFillUseSlideBackgroundItem aFillBgItem( false ); + _pSet->Put( aFillBgItem ); + } + } + break; + } + case SOLID: + return DeactivatePage_Impl<SvxColorTabPage>(_pSet); + case GRADIENT: + return DeactivatePage_Impl<SvxGradientTabPage>(_pSet); + case HATCH: + return DeactivatePage_Impl<SvxHatchTabPage>(_pSet); + case BITMAP: + return DeactivatePage_Impl<SvxBitmapTabPage&>(_pSet); + case PATTERN: + return DeactivatePage_Impl<SvxPatternTabPage>(_pSet); + case USE_BACKGROUND_FILL: + { + if ( m_bBtnClicked ) + { + XFillStyleItem aStyleItem( drawing::FillStyle_NONE ); + _pSet->Put( aStyleItem ); + XFillUseSlideBackgroundItem aFillBgItem( true ); + _pSet->Put( aFillBgItem ); + } + break; + } + default: + break; + } + return DeactivateRC::LeavePage; +} + +template< typename TTabPage > +bool SvxAreaTabPage::FillItemSet_Impl( SfxItemSet* rAttrs) +{ + return static_cast<TTabPage&>( *m_xFillTabPage ).FillItemSet( rAttrs ); +} + +bool SvxAreaTabPage::FillItemSet( SfxItemSet* rAttrs ) +{ + FillType eFillType = static_cast<FillType>(maBox.GetCurrentButtonPos()); + switch( eFillType ) + { + case TRANSPARENT: + { + rAttrs->Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + rAttrs->Put( XFillUseSlideBackgroundItem( false ) ); + return true; + } + case SOLID: + { + return FillItemSet_Impl<SvxColorTabPage>( rAttrs ); + } + case GRADIENT: + { + return FillItemSet_Impl<SvxGradientTabPage>( rAttrs ); + } + case HATCH: + { + return FillItemSet_Impl<SvxHatchTabPage>( rAttrs ); + } + case BITMAP: + { + return FillItemSet_Impl<SvxBitmapTabPage>( rAttrs ); + } + case PATTERN: + { + return FillItemSet_Impl<SvxPatternTabPage>( rAttrs ); + } + case USE_BACKGROUND_FILL: + { + rAttrs->Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + rAttrs->Put( XFillUseSlideBackgroundItem( true ) ); + return true; + } + default: + return false; + } +} + +template< typename TTabPage > +void SvxAreaTabPage::Reset_Impl( const SfxItemSet* rAttrs ) +{ + static_cast<TTabPage&>( *m_xFillTabPage ).Reset( rAttrs ); +} + +void SvxAreaTabPage::Reset( const SfxItemSet* rAttrs ) +{ + m_bBtnClicked = false; + auto eFillType = maBox.GetCurrentButtonPos(); + switch(eFillType) + { + case SOLID: + { + Reset_Impl<SvxColorTabPage>( rAttrs ); + break; + } + case GRADIENT: + { + Reset_Impl<SvxGradientTabPage>( rAttrs ); + break; + } + case HATCH: + { + Reset_Impl<SvxHatchTabPage>( rAttrs ); + break; + } + case BITMAP: + { + Reset_Impl<SvxBitmapTabPage>( rAttrs ); + break; + } + case PATTERN: + { + Reset_Impl<SvxPatternTabPage>( rAttrs ); + break; + } + default: + break; + } +} + +std::unique_ptr<SfxTabPage> SvxAreaTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + auto xRet = std::make_unique<SvxAreaTabPage>(pPage, pController, *rAttrs); + xRet->SetOptimalSize(pController); + return xRet; +} + +std::unique_ptr<SfxTabPage> SvxAreaTabPage::CreateWithSlideBackground( + weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + auto xRet = std::make_unique<SvxAreaTabPage>(pPage, pController, *rAttrs, true); + xRet->SetOptimalSize(pController); + return xRet; +} + +namespace { + +std::unique_ptr<SfxTabPage> lcl_CreateFillStyleTabPage(sal_uInt16 nId, weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet) +{ + CreateTabPage fnCreate = nullptr; + switch(nId) + { + case TRANSPARENT: fnCreate = nullptr; break; + case SOLID: fnCreate = &SvxColorTabPage::Create; break; + case GRADIENT: fnCreate = &SvxGradientTabPage::Create; break; + case HATCH: fnCreate = &SvxHatchTabPage::Create; break; + case BITMAP: fnCreate = &SvxBitmapTabPage::Create; break; + case PATTERN: fnCreate = &SvxPatternTabPage::Create; break; + case USE_BACKGROUND_FILL: fnCreate = nullptr; break; + } + return fnCreate ? (*fnCreate)( pPage, pController, &rSet ) : nullptr; +} + +} + +IMPL_LINK(SvxAreaTabPage, SelectFillTypeHdl_Impl, weld::Toggleable&, rButton, void) +{ + //tdf#124549 - If the button is already active do not toggle it back. + if(!rButton.get_active()) + rButton.set_active(true); + + SelectFillType(rButton); + m_bBtnClicked = true; +} + +void SvxAreaTabPage::SelectFillType(weld::Toggleable& rButton, const SfxItemSet* _pSet) +{ + if (_pSet) + m_rXFSet.Set(*_pSet); + + sal_Int32 nPos = maBox.GetButtonPos(&rButton); + if (nPos != -1 && (_pSet || nPos != maBox.GetCurrentButtonPos())) + { + maBox.SelectButton(&rButton); + FillType eFillType = static_cast<FillType>(maBox.GetCurrentButtonPos()); + m_xFillTabPage = lcl_CreateFillStyleTabPage(eFillType, m_xFillTab.get(), GetDialogController(), m_rXFSet); + if (m_xFillTabPage) + { + m_xFillTabPage->SetDialogController(GetDialogController()); + CreatePage(eFillType, *m_xFillTabPage); + } + } +} + +void SvxAreaTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SvxColorListItem* pColorListItem = aSet.GetItem<SvxColorListItem>(SID_COLOR_TABLE, false); + const SvxGradientListItem* pGradientListItem = aSet.GetItem<SvxGradientListItem>(SID_GRADIENT_LIST, false); + const SvxHatchListItem* pHatchingListItem = aSet.GetItem<SvxHatchListItem>(SID_HATCH_LIST, false); + const SvxBitmapListItem* pBitmapListItem = aSet.GetItem<SvxBitmapListItem>(SID_BITMAP_LIST, false); + const SvxPatternListItem* pPatternListItem = aSet.GetItem<SvxPatternListItem>(SID_PATTERN_LIST, false); + + if (pColorListItem) + SetColorList(pColorListItem->GetColorList()); + if (pGradientListItem) + SetGradientList(pGradientListItem->GetGradientList()); + if (pHatchingListItem) + SetHatchingList(pHatchingListItem->GetHatchList()); + if (pBitmapListItem) + SetBitmapList(pBitmapListItem->GetBitmapList()); + if (pPatternListItem) + SetPatternList(pPatternListItem->GetPatternList()); +} + +void SvxAreaTabPage::CreatePage(sal_Int32 nId, SfxTabPage& rTab) +{ + if(nId == SOLID ) + { + auto& rColorTab = static_cast<SvxColorTabPage&>(rTab); + rColorTab.SetColorList(m_pColorList); + rColorTab.SetColorChgd(m_pnColorListState); + rColorTab.Construct(); + rColorTab.ActivatePage(m_rXFSet); + rColorTab.Reset(&m_rXFSet); + rColorTab.set_visible(true); + } + else if(nId == GRADIENT) + { + auto& rGradientTab = static_cast<SvxGradientTabPage&>(rTab); + rGradientTab.SetColorList(m_pColorList); + rGradientTab.SetGradientList(m_pGradientList); + rGradientTab.SetGrdChgd(m_pnGradientListState); + rGradientTab.SetColorChgd(m_pnColorListState); + rGradientTab.Construct(); + rGradientTab.ActivatePage(m_rXFSet); + rGradientTab.Reset(&m_rXFSet); + rGradientTab.set_visible(true); + } + else if(nId == HATCH) + { + auto& rHatchTab = static_cast<SvxHatchTabPage&>(rTab); + rHatchTab.SetColorList(m_pColorList); + rHatchTab.SetHatchingList(m_pHatchingList); + rHatchTab.SetHtchChgd(m_pnHatchingListState); + rHatchTab.SetColorChgd(m_pnColorListState); + rHatchTab.Construct(); + rHatchTab.ActivatePage(m_rXFSet); + rHatchTab.Reset(&m_rXFSet); + rHatchTab.set_visible(true); + } + else if(nId == BITMAP) + { + auto& rBitmapTab = static_cast<SvxBitmapTabPage&>(rTab); + rBitmapTab.SetBitmapList(m_pBitmapList); + rBitmapTab.SetBmpChgd(m_pnBitmapListState); + rBitmapTab.Construct(); + rBitmapTab.ActivatePage(m_rXFSet); + rBitmapTab.Reset(&m_rXFSet); + rBitmapTab.set_visible(true); + } + else if(nId == PATTERN) + { + auto& rPatternTab = static_cast<SvxPatternTabPage&>(rTab); + rPatternTab.SetColorList(m_pColorList); + rPatternTab.SetPatternList(m_pPatternList); + rPatternTab.SetPtrnChgd(m_pnPatternListState); + rPatternTab.SetColorChgd(m_pnColorListState); + rPatternTab.Construct(); + rPatternTab.ActivatePage(m_rXFSet); + rPatternTab.Reset(&m_rXFSet); + rPatternTab.set_visible(true); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tpbitmap.cxx b/cui/source/tabpages/tpbitmap.cxx new file mode 100644 index 000000000..bf3b742a1 --- /dev/null +++ b/cui/source/tabpages/tpbitmap.cxx @@ -0,0 +1,824 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <stdlib.h> +#include <tools/urlobj.hxx> +#include <svx/xbtmpit.hxx> +#include <svx/svxids.hrc> +#include <strings.hrc> +#include <svx/xfillit0.hxx> +#include <svx/xtable.hxx> +#include <svx/xflbmsxy.hxx> +#include <svx/xflbmtit.hxx> +#include <svx/xflbstit.hxx> +#include <svx/xflbmsli.hxx> +#include <svx/xflbmpit.hxx> +#include <svx/xflboxy.hxx> +#include <svx/xflbtoxy.hxx> +#include <cuitabarea.hxx> +#include <dialmgr.hxx> +#include <svx/dlgutil.hxx> +#include <svl/intitem.hxx> +#include <sfx2/opengrf.hxx> +#include <vcl/image.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <svx/svxdlg.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/dialoghelper.hxx> +#include <sal/log.hxx> +#include <comphelper/lok.hxx> +#include <svtools/unitconv.hxx> + +using namespace com::sun::star; + +namespace { + +enum BitmapStyle +{ + CUSTOM, + TILED, + STRETCHED +}; + +enum TileOffset +{ + ROW, + COLUMN +}; + +} + +SvxBitmapTabPage::SvxBitmapTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/imagetabpage.ui", "ImageTabPage", &rInAttrs) + , m_rOutAttrs(rInAttrs) + , m_pnBitmapListState(nullptr) + , m_fObjectWidth(0.0) + , m_fObjectHeight(0.0) + , m_bLogicalSize(false) + , m_aXFillAttr(rInAttrs.GetPool()) + , m_rXFSet(m_aXFillAttr.GetItemSet()) + , mpView(nullptr) + , m_xBitmapLB(new SvxPresetListBox(m_xBuilder->weld_scrolled_window("imagewin", true))) + , m_xBitmapStyleLB(m_xBuilder->weld_combo_box("imagestyle")) + , m_xSizeBox(m_xBuilder->weld_container("sizebox")) + , m_xTsbScale(m_xBuilder->weld_check_button("scaletsb")) + , m_xBitmapWidth(m_xBuilder->weld_metric_spin_button("width", FieldUnit::PERCENT)) + , m_xBitmapHeight(m_xBuilder->weld_metric_spin_button("height", FieldUnit::PERCENT)) + , m_xPositionBox(m_xBuilder->weld_container("posbox")) + , m_xPositionLB(m_xBuilder->weld_combo_box("positionlb")) + , m_xPositionOffBox(m_xBuilder->weld_container("posoffbox")) + , m_xPositionOffX(m_xBuilder->weld_metric_spin_button("posoffx", FieldUnit::PERCENT)) + , m_xPositionOffY(m_xBuilder->weld_metric_spin_button("posoffy", FieldUnit::PERCENT)) + , m_xTileOffBox(m_xBuilder->weld_container("tileoffbox")) + , m_xTileOffLB(m_xBuilder->weld_combo_box("tileofflb")) + , m_xTileOffset(m_xBuilder->weld_metric_spin_button("tileoffmtr", FieldUnit::PERCENT)) + , m_xBtnImport(m_xBuilder->weld_button("BTN_IMPORT")) + , m_xCtlBitmapPreview(new weld::CustomWeld(*m_xBuilder, "CTL_IMAGE_PREVIEW", m_aCtlBitmapPreview)) + , m_xBitmapLBWin(new weld::CustomWeld(*m_xBuilder, "IMAGE", *m_xBitmapLB)) +{ + // setting the output device + m_rXFSet.Put( XFillStyleItem(drawing::FillStyle_BITMAP) ); + m_rXFSet.Put( XFillBitmapItem(OUString(), Graphic()) ); + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + + m_xBitmapLB->SetSelectHdl( LINK(this, SvxBitmapTabPage, ModifyBitmapHdl) ); + m_xBitmapLB->SetRenameHdl( LINK(this, SvxBitmapTabPage, ClickRenameHdl) ); + m_xBitmapLB->SetDeleteHdl( LINK(this, SvxBitmapTabPage, ClickDeleteHdl) ); + m_xBitmapStyleLB->connect_changed( LINK(this, SvxBitmapTabPage, ModifyBitmapStyleHdl) ); + Link<weld::MetricSpinButton&, void> aLink1( LINK(this, SvxBitmapTabPage, ModifyBitmapSizeHdl) ); + m_xBitmapWidth->connect_value_changed( aLink1 ); + m_xBitmapHeight->connect_value_changed( aLink1 ); + m_xTsbScale->connect_toggled(LINK(this, SvxBitmapTabPage, ClickScaleHdl)); + m_xPositionLB->connect_changed( LINK( this, SvxBitmapTabPage, ModifyBitmapPositionHdl ) ); + Link<weld::MetricSpinButton&, void> aLink( LINK( this, SvxBitmapTabPage, ModifyPositionOffsetHdl ) ); + m_xPositionOffX->connect_value_changed(aLink); + m_xPositionOffY->connect_value_changed(aLink); + m_xTileOffset->connect_value_changed( LINK( this, SvxBitmapTabPage, ModifyTileOffsetHdl ) ); + m_xBtnImport->connect_clicked( LINK(this, SvxBitmapTabPage, ClickImportHdl) ); + if (comphelper::LibreOfficeKit::isActive()) + m_xBtnImport->hide(); + + // Calculate size of display boxes + Size aSize = getDrawPreviewOptimalSize(m_aCtlBitmapPreview.GetDrawingArea()->get_ref_device()); + m_xBitmapLB->set_size_request(aSize.Width(), aSize.Height()); + m_xCtlBitmapPreview->set_size_request(aSize.Width(), aSize.Height()); + + SfxItemPool* pPool = m_rXFSet.GetPool(); + mePoolUnit = pPool->GetMetric( XATTR_FILLBMP_SIZEX ); + meFieldUnit = GetModuleFieldUnit( rInAttrs ); + SetFieldUnit( *m_xBitmapWidth, meFieldUnit, true ); + SetFieldUnit( *m_xBitmapHeight, meFieldUnit, true ); + + m_xBitmapLB->SetStyle(WB_FLATVALUESET | WB_NO_DIRECTSELECT | WB_TABSTOP); + + SfxViewShell* pViewShell = SfxViewShell::Current(); + if( pViewShell ) + mpView = pViewShell->GetDrawView(); + DBG_ASSERT( mpView, "no valid view (!)" ); +} + +SvxBitmapTabPage::~SvxBitmapTabPage() +{ + m_xBitmapLBWin.reset(); + m_xBitmapLB.reset(); + m_xCtlBitmapPreview.reset(); +} + +void SvxBitmapTabPage::Construct() +{ + m_xBitmapLB->FillPresetListBox( *m_pBitmapList ); +} + +void SvxBitmapTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + XFillBitmapItem aItem( rSet.Get(XATTR_FILLBITMAP) ); + + sal_Int32 nPos( 0 ); + if ( !aItem.isPattern() ) + { + nPos = SearchBitmapList( aItem.GetGraphicObject() ); + if (nPos == -1) + return; + } + else + { + m_xBitmapWidth->set_value( 100, FieldUnit::NONE ); + m_xBitmapHeight->set_value( 100, FieldUnit::NONE ); + const_cast<SfxItemSet&>(rSet).Put( XFillBmpSizeXItem( GetCoreValue( *m_xBitmapWidth, mePoolUnit ) ) ); + const_cast<SfxItemSet&>(rSet).Put( XFillBmpSizeYItem( GetCoreValue( *m_xBitmapHeight, mePoolUnit ) ) ); + } + + sal_uInt16 nId = m_xBitmapLB->GetItemId( static_cast<size_t>( nPos ) ); + m_xBitmapLB->SelectItem( nId ); +} + +DeactivateRC SvxBitmapTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + + +bool SvxBitmapTabPage::FillItemSet( SfxItemSet* rAttrs ) +{ + rAttrs->Put(XFillStyleItem(drawing::FillStyle_BITMAP)); + size_t nPos = m_xBitmapLB->GetSelectItemPos(); + if(VALUESET_ITEM_NOTFOUND != nPos) + { + const XBitmapEntry* pXBitmapEntry = m_pBitmapList->GetBitmap(nPos); + const OUString aString(m_xBitmapLB->GetItemText( m_xBitmapLB->GetSelectedItemId() )); + rAttrs->Put(XFillBitmapItem(aString, pXBitmapEntry->GetGraphicObject())); + } + + BitmapStyle eStylePos = static_cast<BitmapStyle>(m_xBitmapStyleLB->get_active()); + bool bIsStretched( eStylePos == STRETCHED ); + bool bIsTiled( eStylePos == TILED ); + + rAttrs->Put( XFillBmpTileItem(bIsTiled) ); + rAttrs->Put( XFillBmpStretchItem(bIsStretched) ); + + if(!bIsStretched) + { + Size aSetBitmapSize; + switch(eStylePos) + { + case CUSTOM: + case TILED: + { + sal_Int64 nWidthPercent = m_xBitmapWidth->get_value(FieldUnit::NONE); + sal_Int64 nHeightPercent = m_xBitmapHeight->get_value(FieldUnit::NONE); + if (m_xTsbScale->get_sensitive() && m_xTsbScale->get_state() == TRISTATE_TRUE) + { + aSetBitmapSize.setWidth( -nWidthPercent ); + aSetBitmapSize.setHeight( -nHeightPercent ); + } + else if (!m_bLogicalSize) + { + aSetBitmapSize.setWidth( GetCoreValue(*m_xBitmapWidth, mePoolUnit) ); + aSetBitmapSize.setHeight( GetCoreValue(*m_xBitmapHeight, mePoolUnit) ); + } + else + { + rAttrs->Put( XFillBmpSizeLogItem(true) ); + aSetBitmapSize.setWidth( 0 ); + aSetBitmapSize.setHeight( 0 ); + } + + break; + } + default: + break; + } + + rAttrs->Put( XFillBmpSizeXItem( aSetBitmapSize.Width() ) ); + rAttrs->Put( XFillBmpSizeYItem( aSetBitmapSize.Height() ) ); + } + + if (m_xPositionLB->get_sensitive()) + rAttrs->Put( XFillBmpPosItem( static_cast<RectPoint>( m_xPositionLB->get_active() ) ) ); + if (m_xPositionOffX->get_sensitive()) + rAttrs->Put( XFillBmpPosOffsetXItem(m_xPositionOffX->get_value(FieldUnit::PERCENT))); + if (m_xPositionOffY->get_sensitive()) + rAttrs->Put( XFillBmpPosOffsetYItem(m_xPositionOffY->get_value(FieldUnit::PERCENT))); + if (m_xTileOffBox->get_sensitive()) + { + TileOffset eValue = static_cast<TileOffset>(m_xTileOffLB->get_active()); + sal_uInt16 nOffsetValue = static_cast<sal_uInt16>(m_xTileOffset->get_value(FieldUnit::PERCENT)); + sal_uInt16 nRowOff = (eValue == ROW) ? nOffsetValue : 0; + sal_uInt16 nColOff = (eValue == COLUMN) ? nOffsetValue : 0; + rAttrs->Put( XFillBmpTileOffsetXItem(nRowOff) ); + rAttrs->Put( XFillBmpTileOffsetYItem(nColOff) ); + } + return true; +} + + +void SvxBitmapTabPage::Reset( const SfxItemSet* rAttrs ) +{ + double transfWidth = 0.0; + double transfHeight = 0.0; + double fUIScale = 1.0; + if (mpView) + { + fUIScale = ( mpView->GetModel() ? double(mpView->GetModel()->GetUIScale()) : 1.0); + + + if (mpView->AreObjectsMarked()) + { + SfxItemSet rGeoAttr(mpView->GetGeoAttrFromMarked()); + transfWidth = static_cast<double>(GetItem( rGeoAttr, SID_ATTR_TRANSFORM_WIDTH )->GetValue()); + transfHeight= static_cast<double>(GetItem( rGeoAttr, SID_ATTR_TRANSFORM_HEIGHT )->GetValue()); + } + } + m_fObjectWidth = std::max( transfWidth, 1.0 ); + m_fObjectHeight = std::max( transfHeight, 1.0 ); + double fTmpWidth((OutputDevice::LogicToLogic(static_cast<sal_Int32>(m_fObjectWidth), mePoolUnit, MapUnit::Map100thMM )) / fUIScale); + m_fObjectWidth = fTmpWidth; + + double fTmpHeight((OutputDevice::LogicToLogic(static_cast<sal_Int32>(m_fObjectHeight), mePoolUnit, MapUnit::Map100thMM )) / fUIScale); + m_fObjectHeight = fTmpHeight; + + XFillBitmapItem aItem( rAttrs->Get(XATTR_FILLBITMAP) ); + + if(!aItem.isPattern()) + { + m_rXFSet.Put( aItem ); + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); + } + else + m_xCtlBitmapPreview->set_sensitive(false); + + std::unique_ptr<GraphicObject> pGraphicObject; + pGraphicObject.reset( new GraphicObject(aItem.GetGraphicObject()) ); + + BitmapEx aBmpEx(pGraphicObject->GetGraphic().GetBitmapEx()); + Size aTempBitmapSize = aBmpEx.GetSizePixel(); + rBitmapSize = Application::GetDefaultDevice()->PixelToLogic(aTempBitmapSize, MapMode(MapUnit::Map100thMM)); + CalculateBitmapPresetSize(); + + bool bTiled = false; bool bStretched = false; + if(rAttrs->GetItemState( XATTR_FILLBMP_TILE ) != SfxItemState::DONTCARE) + bTiled = rAttrs->Get( XATTR_FILLBMP_TILE ).GetValue(); + if(rAttrs->GetItemState( XATTR_FILLBMP_STRETCH ) != SfxItemState::DONTCARE) + bStretched = rAttrs->Get( XATTR_FILLBMP_STRETCH ).GetValue(); + + if (bTiled) + m_xBitmapStyleLB->set_active(static_cast<sal_Int32>(TILED)); + else if (bStretched) + m_xBitmapStyleLB->set_active(static_cast<sal_Int32>(STRETCHED)); + else + m_xBitmapStyleLB->set_active(static_cast<sal_Int32>(CUSTOM)); + + tools::Long nWidth = 0; + tools::Long nHeight = 0; + + if(rAttrs->GetItemState(XATTR_FILLBMP_SIZELOG) != SfxItemState::DONTCARE) + { + if (rAttrs->Get( XATTR_FILLBMP_SIZELOG ).GetValue()) + { + m_xTsbScale->set_state(TRISTATE_FALSE); + m_bLogicalSize = true; + } + else + { + m_xTsbScale->set_state(TRISTATE_TRUE); + m_bLogicalSize = false; + } + } + else + m_xTsbScale->set_state(TRISTATE_INDET); + + TriState eRelative = TRISTATE_FALSE; + if(rAttrs->GetItemState(XATTR_FILLBMP_SIZEX) != SfxItemState::DONTCARE) + { + nWidth = static_cast<const XFillBmpSizeXItem&>( rAttrs->Get( XATTR_FILLBMP_SIZEX ) ).GetValue(); + if(nWidth == 0) + nWidth = rBitmapSize.Width(); + else if(nWidth < 0) + { + eRelative = TRISTATE_TRUE; + nWidth = std::abs(nWidth); + } + } + + if(rAttrs->GetItemState( XATTR_FILLBMP_SIZEY ) != SfxItemState::DONTCARE) + { + nHeight = rAttrs->Get( XATTR_FILLBMP_SIZEY ).GetValue(); + if(nHeight == 0) + nHeight = rBitmapSize.Height(); + else if(nHeight < 0) + { + eRelative = TRISTATE_TRUE; + nHeight = std::abs(nHeight); + } + } + m_xTsbScale->set_state(eRelative); + ClickScaleHdl(*m_xTsbScale); + + + if(!rBitmapSize.IsEmpty()) + { + if (eRelative == TRISTATE_TRUE) + { + m_xBitmapWidth->set_value(nWidth, FieldUnit::NONE); + m_xBitmapHeight->set_value(nHeight, FieldUnit::NONE); + } + else + { + SetMetricValue(*m_xBitmapWidth, nWidth, mePoolUnit); + SetMetricValue(*m_xBitmapHeight, nHeight, mePoolUnit); + } + } + + if( rAttrs->GetItemState( XATTR_FILLBMP_POS ) != SfxItemState::DONTCARE ) + { + RectPoint eValue = rAttrs->Get( XATTR_FILLBMP_POS ).GetValue(); + m_xPositionLB->set_active( static_cast< sal_Int32 >(eValue) ); + } + + if( rAttrs->GetItemState( XATTR_FILLBMP_POSOFFSETX ) != SfxItemState::DONTCARE ) + { + sal_Int32 nValue = rAttrs->Get( XATTR_FILLBMP_POSOFFSETX ).GetValue(); + m_xPositionOffX->set_value(nValue, FieldUnit::PERCENT); + } + else + m_xPositionOffX->set_text(""); + + if( rAttrs->GetItemState( XATTR_FILLBMP_POSOFFSETY ) != SfxItemState::DONTCARE ) + { + sal_Int32 nValue = rAttrs->Get( XATTR_FILLBMP_POSOFFSETY ).GetValue(); + m_xPositionOffY->set_value(nValue, FieldUnit::PERCENT); + } + else + m_xPositionOffY->set_text(""); + + if( rAttrs->GetItemState( XATTR_FILLBMP_TILEOFFSETX ) != SfxItemState::DONTCARE) + { + sal_Int32 nValue = rAttrs->Get( XATTR_FILLBMP_TILEOFFSETX ).GetValue(); + if(nValue > 0) + { + m_xTileOffLB->set_active(static_cast<sal_Int32>(ROW)); + m_xTileOffset->set_value(nValue, FieldUnit::PERCENT); + } + } + + if( rAttrs->GetItemState( XATTR_FILLBMP_TILEOFFSETY ) != SfxItemState::DONTCARE ) + { + sal_Int32 nValue = rAttrs->Get( XATTR_FILLBMP_TILEOFFSETY ).GetValue(); + if(nValue > 0) + { + m_xTileOffLB->set_active(static_cast<sal_Int32>(COLUMN)); + m_xTileOffset->set_value(nValue, FieldUnit::PERCENT); + } + } + + ClickBitmapHdl_Impl(); +} + +std::unique_ptr<SfxTabPage> SvxBitmapTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxBitmapTabPage>(pPage, pController, *rAttrs); +} + +void SvxBitmapTabPage::ClickBitmapHdl_Impl() +{ + m_xBitmapLBWin->set_sensitive(true); + m_xCtlBitmapPreview->set_sensitive(true); + + ModifyBitmapHdl(m_xBitmapLB.get()); +} + +void SvxBitmapTabPage::CalculateBitmapPresetSize() +{ + if(rBitmapSize.IsEmpty()) + return; + + tools::Long nObjectWidth = static_cast<tools::Long>(m_fObjectWidth); + tools::Long nObjectHeight = static_cast<tools::Long>(m_fObjectHeight); + + if(std::abs(rBitmapSize.Width() - nObjectWidth) < std::abs(rBitmapSize.Height() - nObjectHeight)) + { + rFilledSize.setWidth( nObjectWidth ); + rFilledSize.setHeight( rBitmapSize.Height()*nObjectWidth/rBitmapSize.Width() ); + rZoomedSize.setWidth( rBitmapSize.Width()*nObjectHeight/rBitmapSize.Height() ); + rZoomedSize.setHeight( nObjectHeight ); + } + else + { + rFilledSize.setWidth( rBitmapSize.Width()*nObjectHeight/rBitmapSize.Height() ); + rFilledSize.setHeight( nObjectHeight ); + rZoomedSize.setWidth( nObjectWidth ); + rZoomedSize.setHeight( rBitmapSize.Height()*nObjectWidth/rBitmapSize.Width() ); + } +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ModifyBitmapHdl, ValueSet*, void) +{ + std::unique_ptr<GraphicObject> pGraphicObject; + size_t nPos = m_xBitmapLB->GetSelectItemPos(); + + if( nPos != VALUESET_ITEM_NOTFOUND ) + { + pGraphicObject.reset(new GraphicObject(m_pBitmapList->GetBitmap( static_cast<sal_uInt16>(nPos) )->GetGraphicObject())); + } + else + { + if(const XFillStyleItem* pFillStyleItem = m_rOutAttrs.GetItemIfSet(GetWhich(XATTR_FILLSTYLE))) + { + const drawing::FillStyle eXFS(pFillStyleItem->GetValue()); + + const XFillBitmapItem* pBitmapItem; + if((drawing::FillStyle_BITMAP == eXFS) && (pBitmapItem = m_rOutAttrs.GetItemIfSet(GetWhich(XATTR_FILLBITMAP)))) + { + pGraphicObject.reset(new GraphicObject(pBitmapItem->GetGraphicObject())); + } + } + + if(!pGraphicObject) + { + sal_uInt16 nId = m_xBitmapLB->GetItemId(0); + m_xBitmapLB->SelectItem(nId); + + if(0 != nId) + { + pGraphicObject.reset(new GraphicObject(m_pBitmapList->GetBitmap(0)->GetGraphicObject())); + } + } + } + + if(pGraphicObject) + { + BitmapEx aBmpEx(pGraphicObject->GetGraphic().GetBitmapEx()); + Size aTempBitmapSize = aBmpEx.GetSizePixel(); + const double fUIScale = ( (mpView && mpView->GetModel()) ? double(mpView->GetModel()->GetUIScale()) : 1.0); + Size aBitmapSize100mm = o3tl::convert(aTempBitmapSize, o3tl::Length::pt, o3tl::Length::mm100); + + rBitmapSize.setWidth(aBitmapSize100mm.Width() / fUIScale); + rBitmapSize.setHeight(aBitmapSize100mm.Height() / fUIScale); + CalculateBitmapPresetSize(); + ModifyBitmapStyleHdl( *m_xBitmapStyleLB ); + ModifyBitmapPositionHdl( *m_xPositionLB ); + + m_rXFSet.ClearItem(XATTR_FILLBITMAP); + m_rXFSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP)); + m_rXFSet.Put(XFillBitmapItem(OUString(), *pGraphicObject)); + + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); + } + else + { + SAL_WARN("cui.tabpages", "SvxBitmapTabPage::ModifyBitmapHdl(): null pGraphicObject"); + } + +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ClickRenameHdl, SvxPresetListBox*, void) +{ + sal_uInt16 nId = m_xBitmapLB->GetSelectedItemId(); + size_t nPos = m_xBitmapLB->GetSelectItemPos(); + + if( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aDesc( CuiResId( RID_CUISTR_DESC_NEW_BITMAP ) ); + OUString aName( m_pBitmapList->GetBitmap( nPos )->GetName() ); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + + bool bLoop = true; + while( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + sal_Int32 nBitmapPos = SearchBitmapList( aName ); + bool bValidBitmapName = (nBitmapPos == static_cast<sal_Int32>(nPos) ) || (nBitmapPos == -1); + + if(bValidBitmapName) + { + bLoop = false; + m_pBitmapList->GetBitmap(nPos)->SetName(aName); + + m_xBitmapLB->SetItemText(nId, aName); + m_xBitmapLB->SelectItem( nId ); + + *m_pnBitmapListState |= ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xBox->run(); + } + } +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ClickDeleteHdl, SvxPresetListBox*, void) +{ + sal_uInt16 nId = m_xBitmapLB->GetSelectedItemId(); + size_t nPos = m_xBitmapLB->GetSelectItemPos(); + + if( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querydeletebitmapdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskDelBitmapDialog")); + + if (xQueryBox->run() != RET_YES) + return; + + sal_uInt16 nNextId = m_xBitmapLB->GetItemId(nPos + 1); + if (!nNextId) + nNextId = m_xBitmapLB->GetItemId(nPos - 1); + + m_pBitmapList->Remove( static_cast<sal_uInt16>(nPos) ); + m_xBitmapLB->RemoveItem( nId ); + + m_xBitmapLB->SelectItem(nNextId); + + m_aCtlBitmapPreview.Invalidate(); + ModifyBitmapHdl(m_xBitmapLB.get()); + *m_pnBitmapListState |= ChangeType::MODIFIED; +} + +IMPL_LINK_NOARG( SvxBitmapTabPage, ModifyBitmapSizeHdl, weld::MetricSpinButton&, void ) +{ + m_bLogicalSize = false; + if (m_xTsbScale->get_state() != TRISTATE_TRUE && static_cast<BitmapStyle>(m_xBitmapStyleLB->get_active()) != TILED) + { + sal_Int64 nWidthPercent = m_xBitmapWidth->denormalize(m_xBitmapWidth->get_value(FieldUnit::NONE)); + sal_Int64 nHeightPercent = m_xBitmapHeight->denormalize(m_xBitmapHeight->get_value(FieldUnit::NONE)); + if (nWidthPercent == 100 && nHeightPercent == 100) + m_xBitmapStyleLB->set_active(static_cast<sal_Int32>(CUSTOM)); + } + ModifyBitmapStyleHdl(*m_xBitmapStyleLB); + + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); +} + +IMPL_LINK_NOARG( SvxBitmapTabPage, ClickScaleHdl, weld::Toggleable&, void ) +{ + if (m_xTsbScale->get_state() == TRISTATE_TRUE) + { + m_xBitmapWidth->set_digits( 0 ); + m_xBitmapWidth->set_unit(FieldUnit::PERCENT); + m_xBitmapWidth->set_value(100, FieldUnit::NONE); + m_xBitmapWidth->set_range(0, 100, FieldUnit::NONE); + + m_xBitmapHeight->set_digits( 0 ); + m_xBitmapHeight->set_unit(FieldUnit::PERCENT); + m_xBitmapHeight->set_value(100, FieldUnit::NONE); + m_xBitmapHeight->set_range(0, 100, FieldUnit::NONE); + } + else + { + m_xBitmapWidth->set_digits( 2 ); + m_xBitmapWidth->set_unit(meFieldUnit); + m_xBitmapWidth->set_value(100, FieldUnit::NONE); + m_xBitmapWidth->set_range(0, 999900, FieldUnit::NONE); + + m_xBitmapHeight->set_digits( 2 ); + m_xBitmapHeight->set_unit(meFieldUnit); + m_xBitmapHeight->set_value(100, FieldUnit::NONE); + m_xBitmapHeight->set_range(0, 999900, FieldUnit::NONE); + } + + ModifyBitmapStyleHdl( *m_xBitmapStyleLB ); +} + +IMPL_LINK_NOARG( SvxBitmapTabPage, ModifyBitmapStyleHdl, weld::ComboBox&, void ) +{ + BitmapStyle eStylePos = static_cast<BitmapStyle>(m_xBitmapStyleLB->get_active()); + bool bIsStretched( eStylePos == STRETCHED ); + bool bIsTiled( eStylePos == TILED ); + + m_xSizeBox->set_sensitive( !bIsStretched ); + m_xPositionBox->set_sensitive( !bIsStretched ); + m_xPositionOffBox->set_sensitive( bIsTiled ); + m_xTileOffBox->set_sensitive( bIsTiled ); + + m_rXFSet.Put( XFillBmpTileItem( bIsTiled ) ); + m_rXFSet.Put( XFillBmpStretchItem( bIsStretched ) ); + + if(!bIsStretched) + { + Size aSetBitmapSize; + switch(eStylePos) + { + case CUSTOM: + case TILED: + { + if (m_xTsbScale->get_sensitive() && m_xTsbScale->get_state() == TRISTATE_TRUE) + { + aSetBitmapSize.setWidth(-m_xBitmapWidth->get_value(FieldUnit::NONE)); + aSetBitmapSize.setHeight(-m_xBitmapHeight->get_value(FieldUnit::NONE)); + } + else + { + aSetBitmapSize.setWidth( GetCoreValue( *m_xBitmapWidth, mePoolUnit ) ); + aSetBitmapSize.setHeight( GetCoreValue( *m_xBitmapHeight, mePoolUnit ) ); + } + } + break; + default: + break; + } + + m_rXFSet.Put( XFillBmpSizeXItem( aSetBitmapSize.Width() ) ); + m_rXFSet.Put( XFillBmpSizeYItem( aSetBitmapSize.Height() ) ); + } + + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ModifyBitmapPositionHdl, weld::ComboBox&, void) +{ + if (m_xPositionLB->get_sensitive()) + m_rXFSet.Put( XFillBmpPosItem( static_cast< RectPoint >( m_xPositionLB->get_active() ) ) ); + + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ModifyPositionOffsetHdl, weld::MetricSpinButton&, void) +{ + if (m_xPositionOffX->get_sensitive()) + m_rXFSet.Put( XFillBmpPosOffsetXItem( m_xPositionOffX->get_value(FieldUnit::PERCENT) ) ); + + if (m_xPositionOffY->get_sensitive()) + m_rXFSet.Put( XFillBmpPosOffsetYItem( m_xPositionOffY->get_value(FieldUnit::PERCENT) ) ); + + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ModifyTileOffsetHdl, weld::MetricSpinButton&, void) +{ + sal_uInt16 nTileXOff = 0; + sal_uInt16 nTileYOff = 0; + + if(m_xTileOffLB->get_active() == static_cast<sal_Int32>(ROW)) + nTileXOff = m_xTileOffset->get_value(FieldUnit::PERCENT); + + if(m_xTileOffLB->get_active() == static_cast<sal_Int32>(COLUMN)) + nTileYOff = m_xTileOffset->get_value(FieldUnit::PERCENT); + + m_rXFSet.Put( XFillBmpTileOffsetXItem(nTileXOff) ); + m_rXFSet.Put( XFillBmpTileOffsetYItem(nTileYOff) ); + + m_aCtlBitmapPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxBitmapTabPage, ClickImportHdl, weld::Button&, void) +{ + weld::Window* pDialogFrameWeld = GetFrameWeld(); + + SvxOpenGraphicDialog aDlg(CuiResId(RID_CUISTR_ADD_IMAGE), pDialogFrameWeld); + aDlg.EnableLink(false); + tools::Long nCount = m_pBitmapList->Count(); + + if( aDlg.Execute() ) + return; + + Graphic aGraphic; + + std::unique_ptr<weld::WaitObject> xWait(new weld::WaitObject(pDialogFrameWeld)); + ErrCode nError = aDlg.GetGraphic( aGraphic ); + xWait.reset(); + + if( !nError ) + { + OUString aDesc(CuiResId(RID_CUISTR_DESC_EXT_BITMAP)); + + // convert file URL to UI name + OUString aName; + INetURLObject aURL( aDlg.GetPath() ); + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog( + pDialogFrameWeld, aURL.GetLastName().getToken(0, '.'), aDesc)); + nError = ErrCode(1); + + while( pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + + bool bDifferent = true; + + for( tools::Long i = 0; i < nCount && bDifferent; i++ ) + if( aName == m_pBitmapList->GetBitmap( i )->GetName() ) + bDifferent = false; + + if( bDifferent ) { + nError = ERRCODE_NONE; + break; + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pDialogFrameWeld, "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + if (xBox->run() != RET_OK) + break; + } + + pDlg.disposeAndClear(); + + if( !nError ) + { + m_pBitmapList->Insert(std::make_unique<XBitmapEntry>(aGraphic, aName), nCount); + + sal_Int32 nId = m_xBitmapLB->GetItemId( nCount - 1 ); + BitmapEx aBitmap = m_pBitmapList->GetBitmapForPreview( nCount, m_xBitmapLB->GetIconSize() ); + + m_xBitmapLB->InsertItem( nId + 1, Image(aBitmap), aName ); + m_xBitmapLB->SelectItem( nId + 1 ); + *m_pnBitmapListState |= ChangeType::MODIFIED; + + ModifyBitmapHdl(m_xBitmapLB.get()); + } + } + else + { + // graphic couldn't be loaded + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pDialogFrameWeld, "cui/ui/querynoloadedfiledialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("NoLoadedFileDialog")); + xBox->run(); + } +} + +sal_Int32 SvxBitmapTabPage::SearchBitmapList(const GraphicObject& rGraphicObject) +{ + tools::Long nCount = m_pBitmapList->Count(); + sal_Int32 nPos = -1; + + for(tools::Long i = 0;i < nCount;i++) + { + if(rGraphicObject.GetUniqueID() == m_pBitmapList->GetBitmap( i )->GetGraphicObject().GetUniqueID()) + { + nPos = i; + break; + } + } + return nPos; +} + +sal_Int32 SvxBitmapTabPage::SearchBitmapList(std::u16string_view rBitmapName) +{ + tools::Long nCount = m_pBitmapList->Count(); + bool bValidBitmapName = true; + sal_Int32 nPos = -1; + + for(tools::Long i = 0;i < nCount && bValidBitmapName;i++) + { + if(rBitmapName == m_pBitmapList->GetBitmap( i )->GetName()) + { + nPos = i; + bValidBitmapName = false; + } + } + return nPos; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tpcolor.cxx b/cui/source/tabpages/tpcolor.cxx new file mode 100644 index 000000000..e65c49617 --- /dev/null +++ b/cui/source/tabpages/tpcolor.cxx @@ -0,0 +1,794 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <i18nutil/unicode.hxx> +#include <svtools/colrdlg.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> + +#include <strings.hrc> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/xtable.hxx> +#include <cuitabarea.hxx> +#include <svx/svxdlg.hxx> +#include <dialmgr.hxx> +#include <cuitabline.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <officecfg/Office/Common.hxx> +#include <osl/diagnose.h> +#include <comphelper/dispatchcommand.hxx> +#include <comphelper/propertyvalue.hxx> + +using namespace com::sun::star; + +SvxColorTabPage::SvxColorTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/colorpage.ui", "ColorPage", &rInAttrs) + , rOutAttrs ( rInAttrs ) + // All the horrific pointers we store and should not + , pnColorListState( nullptr ) + , aXFillAttr( rInAttrs.GetPool() ) + , rXFSet( aXFillAttr.GetItemSet() ) + , eCM( ColorModel::RGB ) + , m_xValSetColorList(new SvxColorValueSet(m_xBuilder->weld_scrolled_window("colorsetwin", true))) + , m_xValSetRecentList(new SvxColorValueSet(nullptr)) + , m_xSelectPalette(m_xBuilder->weld_combo_box("paletteselector")) + , m_xRbRGB(m_xBuilder->weld_radio_button("RGB")) + , m_xRbCMYK(m_xBuilder->weld_radio_button("CMYK")) + , m_xRGBcustom(m_xBuilder->weld_widget("rgbcustom")) + , m_xRGBpreset(m_xBuilder->weld_widget("rgbpreset")) + , m_xRpreset(m_xBuilder->weld_entry("R_preset")) + , m_xGpreset(m_xBuilder->weld_entry("G_preset")) + , m_xBpreset(m_xBuilder->weld_entry("B_preset")) + , m_xRcustom(m_xBuilder->weld_spin_button("R_custom")) + , m_xGcustom(m_xBuilder->weld_spin_button("G_custom")) + , m_xBcustom(m_xBuilder->weld_spin_button("B_custom")) + , m_xHexpreset(new weld::HexColorControl(m_xBuilder->weld_entry("hex_preset"))) + , m_xHexcustom(new weld::HexColorControl(m_xBuilder->weld_entry("hex_custom"))) + , m_xCMYKcustom(m_xBuilder->weld_widget("cmykcustom")) + , m_xCMYKpreset(m_xBuilder->weld_widget("cmykpreset")) + , m_xCpreset(m_xBuilder->weld_entry("C_preset")) + , m_xYpreset(m_xBuilder->weld_entry("Y_preset")) + , m_xMpreset(m_xBuilder->weld_entry("M_preset")) + , m_xKpreset(m_xBuilder->weld_entry("K_preset")) + , m_xCcustom(m_xBuilder->weld_metric_spin_button("C_custom", FieldUnit::PERCENT)) + , m_xYcustom(m_xBuilder->weld_metric_spin_button("Y_custom", FieldUnit::PERCENT)) + , m_xMcustom(m_xBuilder->weld_metric_spin_button("M_custom", FieldUnit::PERCENT)) + , m_xKcustom(m_xBuilder->weld_metric_spin_button("K_custom", FieldUnit::PERCENT)) + , m_xBtnAdd(m_xBuilder->weld_button("add")) + , m_xBtnDelete(m_xBuilder->weld_button("delete")) + , m_xBtnWorkOn(m_xBuilder->weld_button("edit")) + , m_xMoreColors(m_xBuilder->weld_button("btnMoreColors")) + , m_xCtlPreviewOld(new weld::CustomWeld(*m_xBuilder, "oldpreview", m_aCtlPreviewOld)) + , m_xCtlPreviewNew(new weld::CustomWeld(*m_xBuilder, "newpreview", m_aCtlPreviewNew)) + , m_xValSetColorListWin(new weld::CustomWeld(*m_xBuilder, "colorset", *m_xValSetColorList)) + , m_xValSetRecentListWin(new weld::CustomWeld(*m_xBuilder, "recentcolorset", *m_xValSetRecentList)) +{ + Size aSize(m_xBtnWorkOn->get_approximate_digit_width() * 25, + m_xBtnWorkOn->get_text_height() * 10); + m_xValSetColorList->set_size_request(aSize.Width(), aSize.Height()); + aSize = Size(m_xBtnWorkOn->get_approximate_digit_width() * 8, + m_xBtnWorkOn->get_text_height() * 3); + m_aCtlPreviewOld.set_size_request(aSize.Width(), aSize.Height()); + m_aCtlPreviewNew.set_size_request(aSize.Width(), aSize.Height()); + // this page needs ExchangeSupport + SetExchangeSupport(); + + // setting the output device + rXFSet.Put( XFillStyleItem(drawing::FillStyle_SOLID) ); + rXFSet.Put( XFillColorItem(OUString(), COL_BLACK) ); + m_aCtlPreviewOld.SetAttributes( aXFillAttr.GetItemSet() ); + m_aCtlPreviewNew.SetAttributes( aXFillAttr.GetItemSet() ); + + // set handler + m_xSelectPalette->connect_changed(LINK(this, SvxColorTabPage, SelectPaletteLBHdl)); + Link<ValueSet*, void> aValSelectLink = LINK(this, SvxColorTabPage, SelectValSetHdl_Impl); + m_xValSetColorList->SetSelectHdl(aValSelectLink); + m_xValSetRecentList->SetSelectHdl(aValSelectLink); + + Link<weld::SpinButton&,void> aSpinLink = LINK(this, SvxColorTabPage, SpinValueHdl_Impl); + m_xRcustom->connect_value_changed(aSpinLink); + m_xGcustom->connect_value_changed(aSpinLink); + m_xBcustom->connect_value_changed(aSpinLink); + Link<weld::Entry&,void> aEntryLink = LINK(this, SvxColorTabPage, ModifiedHdl_Impl); + m_xHexcustom->connect_changed(aEntryLink); + Link<weld::MetricSpinButton&,void> aMetricSpinLink = LINK(this, SvxColorTabPage, MetricSpinValueHdl_Impl); + m_xCcustom->connect_value_changed(aMetricSpinLink); + m_xYcustom->connect_value_changed(aMetricSpinLink); + m_xMcustom->connect_value_changed(aMetricSpinLink); + m_xKcustom->connect_value_changed(aMetricSpinLink); + + Link<weld::Toggleable&,void> aLink2 = LINK( this, SvxColorTabPage, SelectColorModeHdl_Impl ); + m_xRbRGB->connect_toggled(aLink2); + m_xRbCMYK->connect_toggled(aLink2); + SetColorModel( eCM ); + ChangeColorModel(); + + m_xBtnAdd->connect_clicked( LINK( this, SvxColorTabPage, ClickAddHdl_Impl ) ); + m_xBtnWorkOn->connect_clicked( LINK( this, SvxColorTabPage, ClickWorkOnHdl_Impl ) ); + m_xBtnDelete->connect_clicked( LINK( this, SvxColorTabPage, ClickDeleteHdl_Impl ) ); + // disable modify buttons + // Color palettes can't be modified + m_xBtnDelete->set_sensitive(false); + m_xBtnDelete->set_tooltip_text( CuiResId(RID_CUISTR_DELETEUSERCOLOR1) ); + + m_xMoreColors->set_from_icon_name("cmd/sc_additionsdialog.png"); + m_xMoreColors->connect_clicked(LINK(this, SvxColorTabPage, OnMoreColorsClick)); + + // disable preset color values + m_xRGBpreset->set_sensitive(false); + m_xCMYKpreset->set_sensitive(false); + + // ValueSet + m_xValSetColorList->SetStyle(m_xValSetColorList->GetStyle() | + WB_FLATVALUESET | WB_ITEMBORDER | WB_NO_DIRECTSELECT | WB_TABSTOP); + m_xValSetColorList->Show(); + + m_xValSetRecentList->SetStyle(m_xValSetRecentList->GetStyle() | + WB_FLATVALUESET | WB_ITEMBORDER | WB_NO_DIRECTSELECT | WB_TABSTOP); + m_xValSetRecentList->Show(); + + maPaletteManager.ReloadRecentColorSet(*m_xValSetRecentList); + aSize = m_xValSetRecentList->layoutAllVisible(maPaletteManager.GetRecentColorCount()); + m_xValSetRecentList->set_size_request(aSize.Width(), aSize.Height()); +} + +SvxColorTabPage::~SvxColorTabPage() +{ + m_xValSetRecentListWin.reset(); + m_xValSetRecentList.reset(); + m_xValSetColorListWin.reset(); + m_xValSetColorList.reset(); +} + +void SvxColorTabPage::ImpColorCountChanged() +{ + if (!pColorList.is()) + return; + m_xValSetColorList->SetColCount(SvxColorValueSet::getColumnCount()); + m_xValSetRecentList->SetColCount(SvxColorValueSet::getColumnCount()); +} + +void SvxColorTabPage::FillPaletteLB() +{ + m_xSelectPalette->clear(); + std::vector<OUString> aPaletteList = maPaletteManager.GetPaletteList(); + for (auto const& palette : aPaletteList) + { + m_xSelectPalette->append_text(palette); + } + OUString aPaletteName( officecfg::Office::Common::UserColors::PaletteName::get() ); + m_xSelectPalette->set_active_text(aPaletteName); + if (m_xSelectPalette->get_active() != -1) + { + SelectPaletteLBHdl(*m_xSelectPalette); + } +} + +void SvxColorTabPage::Construct() +{ + if (pColorList.is()) + { + FillPaletteLB(); + ImpColorCountChanged(); + } +} + +void SvxColorTabPage::ActivatePage( const SfxItemSet& ) +{ + if( !pColorList.is() ) + return; + + if( const XFillColorItem* pFillColorItem = rOutAttrs.GetItemIfSet( GetWhich( XATTR_FILLCOLOR ) ) ) + { + SetColorModel( ColorModel::RGB ); + ChangeColorModel(); + + const Color aColor = pFillColorItem->GetColorValue(); + svx::NamedThemedColor aThemedColor; + aThemedColor.m_aColor = aColor; + ChangeColor( aThemedColor ); + sal_Int32 nPos = FindInPalette( aColor ); + + if ( nPos != -1 ) + m_xValSetColorList->SelectItem(m_xValSetColorList->GetItemId(nPos)); + // else search in other palettes? + + } + + m_aCtlPreviewOld.SetAttributes(aXFillAttr.GetItemSet()); + m_aCtlPreviewOld.Invalidate(); + + SelectValSetHdl_Impl(m_xValSetColorList.get()); +} + +DeactivateRC SvxColorTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + +bool SvxColorTabPage::FillItemSet( SfxItemSet* rSet ) +{ + Color aColor = m_xValSetColorList->GetItemColor( m_xValSetColorList->GetSelectedItemId() ); + OUString sColorName; + if ( aCurrentColor.m_aColor == aColor ) + sColorName = m_xValSetColorList->GetItemText( m_xValSetColorList->GetSelectedItemId() ); + else + sColorName = "#" + aCurrentColor.m_aColor.AsRGBHexString().toAsciiUpperCase(); + maPaletteManager.AddRecentColor( aCurrentColor.m_aColor, sColorName ); + XFillColorItem aColorItem( sColorName, aCurrentColor.m_aColor ); + if (aCurrentColor.m_nThemeIndex != -1) + { + aColorItem.GetThemeColor().SetThemeIndex(aCurrentColor.m_nThemeIndex); + } + if (aCurrentColor.m_nLumMod != 10000) + { + aColorItem.GetThemeColor().SetLumMod(aCurrentColor.m_nLumMod); + } + if (aCurrentColor.m_nLumOff != 0) + { + aColorItem.GetThemeColor().SetLumOff(aCurrentColor.m_nLumOff); + } + rSet->Put( aColorItem ); + rSet->Put( XFillStyleItem( drawing::FillStyle_SOLID ) ); + return true; +} + +void SvxColorTabPage::UpdateModified() +{ + bool bEnable = pColorList.is() && pColorList->Count(); + m_xBtnWorkOn->set_sensitive(bEnable); +} + +void SvxColorTabPage::Reset( const SfxItemSet* rSet ) +{ + SfxItemState nState = rSet->GetItemState( XATTR_FILLCOLOR ); + + Color aNewColor; + + if ( nState >= SfxItemState::DEFAULT ) + { + XFillColorItem aColorItem( rSet->Get( XATTR_FILLCOLOR ) ); + aPreviousColor = aColorItem.GetColorValue(); + aNewColor = aColorItem.GetColorValue(); + } + + // set color model + OUString aStr = GetUserData(); + eCM = static_cast<ColorModel>(aStr.toInt32()); + SetColorModel( eCM ); + ChangeColorModel(); + + svx::NamedThemedColor aThemedColor; + aThemedColor.m_aColor = aNewColor; + ChangeColor(aThemedColor); + + UpdateModified(); +} + +std::unique_ptr<SfxTabPage> SvxColorTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rOutAttrs) +{ + return std::make_unique<SvxColorTabPage>(pPage, pController, *rOutAttrs); +} + +// is called when the content of the MtrFields is changed for color values +IMPL_LINK_NOARG(SvxColorTabPage, SpinValueHdl_Impl, weld::SpinButton&, void) +{ + // read current MtrFields, if cmyk, then k-value as transparency + aCurrentColor.m_aColor = Color(static_cast<sal_uInt8>(PercentToColor_Impl(m_xRcustom->get_value())), + static_cast<sal_uInt8>(PercentToColor_Impl(m_xGcustom->get_value())), + static_cast<sal_uInt8>(PercentToColor_Impl(m_xBcustom->get_value()))); + UpdateColorValues(); + + rXFSet.Put( XFillColorItem( OUString(), aCurrentColor.m_aColor ) ); + m_aCtlPreviewNew.SetAttributes( aXFillAttr.GetItemSet() ); + + m_aCtlPreviewNew.Invalidate(); +} + +IMPL_LINK_NOARG(SvxColorTabPage, MetricSpinValueHdl_Impl, weld::MetricSpinButton&, void) +{ + // read current MtrFields, if cmyk, then k-value as transparency + aCurrentColor.m_aColor = Color(ColorTransparency, static_cast<sal_uInt8>(PercentToColor_Impl(m_xKcustom->get_value(FieldUnit::NONE))), + static_cast<sal_uInt8>(PercentToColor_Impl(m_xCcustom->get_value(FieldUnit::NONE))), + static_cast<sal_uInt8>(PercentToColor_Impl(m_xYcustom->get_value(FieldUnit::NONE))), + static_cast<sal_uInt8>(PercentToColor_Impl(m_xMcustom->get_value(FieldUnit::NONE)))); + ConvertColorValues (aCurrentColor.m_aColor, ColorModel::RGB); + + rXFSet.Put( XFillColorItem( OUString(), aCurrentColor.m_aColor ) ); + m_aCtlPreviewNew.SetAttributes( aXFillAttr.GetItemSet() ); + + m_aCtlPreviewNew.Invalidate(); +} + +IMPL_LINK_NOARG(SvxColorTabPage, ModifiedHdl_Impl, weld::Entry&, void) +{ + aCurrentColor.m_aColor = m_xHexcustom->GetColor(); + UpdateColorValues(); + + rXFSet.Put( XFillColorItem( OUString(), aCurrentColor.m_aColor ) ); + m_aCtlPreviewNew.SetAttributes( aXFillAttr.GetItemSet() ); + + m_aCtlPreviewNew.Invalidate(); +} + +IMPL_LINK_NOARG(SvxColorTabPage, ClickAddHdl_Impl, weld::Button&, void) +{ + OUString aNewName( SvxResId( RID_SVXSTR_COLOR ) ); + OUString aDesc( CuiResId( RID_CUISTR_DESC_COLOR ) ); + OUString aName; + + tools::Long j = 1; + bool bValidColorName = false; + // check if name is already existing + while (!bValidColorName) + { + aName = aNewName + " " + OUString::number( j++ ); + bValidColorName = (FindInCustomColors(aName) == -1); + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + sal_uInt16 nError = 1; + + while (pDlg->Execute() == RET_OK) + { + pDlg->GetName( aName ); + + bValidColorName = (FindInCustomColors(aName) == -1); + if (bValidColorName) + { + nError = 0; + break; + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarnBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + if (xWarnBox->run() != RET_OK) + break; + } + + pDlg.disposeAndClear(); + + if (!nError) + { + m_xSelectPalette->set_active(0); + SelectPaletteLBHdl(*m_xSelectPalette); + std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create()); + css::uno::Sequence< sal_Int32 > aCustomColorList(officecfg::Office::Common::UserColors::CustomColor::get()); + css::uno::Sequence< OUString > aCustomColorNameList(officecfg::Office::Common::UserColors::CustomColorName::get()); + sal_Int32 nSize = aCustomColorList.getLength(); + aCustomColorList.realloc( nSize + 1 ); + aCustomColorNameList.realloc( nSize + 1 ); + aCustomColorList.getArray()[nSize] = sal_Int32(aCurrentColor.m_aColor); + aCustomColorNameList.getArray()[nSize] = aName; + officecfg::Office::Common::UserColors::CustomColor::set(aCustomColorList, batch); + officecfg::Office::Common::UserColors::CustomColorName::set(aCustomColorNameList, batch); + batch->commit(); + sal_uInt16 nId = m_xValSetColorList->GetItemId(nSize - 1); + m_xValSetColorList->InsertItem( nId + 1 , aCurrentColor.m_aColor, aName ); + m_xValSetColorList->SelectItem( nId + 1 ); + m_xBtnDelete->set_sensitive(false); + m_xBtnDelete->set_tooltip_text( CuiResId(RID_CUISTR_DELETEUSERCOLOR2) ); + ImpColorCountChanged(); + } + + UpdateModified(); +} + +IMPL_LINK_NOARG(SvxColorTabPage, ClickWorkOnHdl_Impl, weld::Button&, void) +{ + SvColorDialog aColorDlg; + + aColorDlg.SetColor (aCurrentColor.m_aColor); + aColorDlg.SetMode( svtools::ColorPickerMode::Modify ); + + if (aColorDlg.Execute(GetFrameWeld()) == RET_OK) + { + Color aPreviewColor = aColorDlg.GetColor(); + aCurrentColor.m_aColor = aPreviewColor; + UpdateColorValues( false ); + // fill ItemSet and pass it on to XOut + rXFSet.Put( XFillColorItem( OUString(), aPreviewColor ) ); + //m_aCtlPreviewOld.SetAttributes( aXFillAttr ); + m_aCtlPreviewNew.SetAttributes( aXFillAttr.GetItemSet() ); + + m_aCtlPreviewNew.Invalidate(); + } +} + +IMPL_LINK_NOARG(SvxColorTabPage, ClickDeleteHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nId = m_xValSetColorList->GetSelectedItemId(); + size_t nPos = m_xValSetColorList->GetSelectItemPos(); + if (m_xSelectPalette->get_active() != 0 || nPos == VALUESET_ITEM_NOTFOUND) + return; + + std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create()); + css::uno::Sequence< sal_Int32 > aCustomColorList(officecfg::Office::Common::UserColors::CustomColor::get()); + auto aCustomColorListRange = asNonConstRange(aCustomColorList); + css::uno::Sequence< OUString > aCustomColorNameList(officecfg::Office::Common::UserColors::CustomColorName::get()); + auto aCustomColorNameListRange = asNonConstRange(aCustomColorNameList); + sal_Int32 nSize = aCustomColorList.getLength() - 1; + for(sal_Int32 nIndex = static_cast<sal_Int32>(nPos);nIndex < nSize;nIndex++) + { + aCustomColorListRange[nIndex] = aCustomColorList[nIndex+1]; + aCustomColorNameListRange[nIndex] = aCustomColorNameList[nIndex+1]; + } + aCustomColorList.realloc(nSize); + aCustomColorNameList.realloc(nSize); + officecfg::Office::Common::UserColors::CustomColor::set(aCustomColorList, batch); + officecfg::Office::Common::UserColors::CustomColorName::set(aCustomColorNameList, batch); + batch->commit(); + m_xValSetColorList->RemoveItem(nId); + if (m_xValSetColorList->GetItemCount() != 0) + { + nId = m_xValSetColorList->GetItemId(0); + m_xValSetColorList->SelectItem(nId); + SelectValSetHdl_Impl(m_xValSetColorList.get()); + } + else + { + m_xBtnDelete->set_sensitive(false); + m_xBtnDelete->set_tooltip_text( CuiResId(RID_CUISTR_DELETEUSERCOLOR2) ); + } +} + +IMPL_LINK_NOARG(SvxColorTabPage, SelectPaletteLBHdl, weld::ComboBox&, void) +{ + m_xValSetColorList->Clear(); + sal_Int32 nPos = m_xSelectPalette->get_active(); + maPaletteManager.SetPalette( nPos ); + maPaletteManager.ReloadColorSet(*m_xValSetColorList); + + if(nPos != maPaletteManager.GetPaletteCount() - 1 && nPos != 0) + { + XColorListRef pList = XPropertyList::AsColorList( + XPropertyList::CreatePropertyListFromURL( + XPropertyListType::Color, maPaletteManager.GetSelectedPalettePath())); + pList->SetName(maPaletteManager.GetPaletteName()); + if(pList->Load()) + { + SfxOkDialogController* pController = GetDialogController(); + SvxAreaTabDialog* pArea = dynamic_cast<SvxAreaTabDialog*>(pController); + SvxLineTabDialog* pLine = dynamic_cast<SvxLineTabDialog*>(pController); + pColorList = pList; + if( pArea ) + pArea->SetNewColorList(pList); + else if( pLine ) + pLine->SetNewColorList(pList); + else + SetColorList(pList); + *pnColorListState |= ChangeType::CHANGED; + *pnColorListState &= ~ChangeType::MODIFIED; + } + } + if (nPos != 0) + { + m_xBtnDelete->set_sensitive(false); + m_xBtnDelete->set_tooltip_text( CuiResId(RID_CUISTR_DELETEUSERCOLOR1) ); + } + + m_xValSetColorList->Resize(); +} + +IMPL_LINK(SvxColorTabPage, SelectValSetHdl_Impl, ValueSet*, pValSet, void) +{ + sal_Int32 nPos = pValSet->GetSelectedItemId(); + if( nPos == 0 ) + return; + + Color aColor = pValSet->GetItemColor( nPos ); + + rXFSet.Put( XFillColorItem( OUString(), aColor ) ); + m_aCtlPreviewNew.SetAttributes( aXFillAttr.GetItemSet() ); + m_aCtlPreviewNew.Invalidate(); + + bool bThemePaletteSelected = false; + if (pValSet == m_xValSetColorList.get()) + { + bThemePaletteSelected = maPaletteManager.IsThemePaletteSelected(); + } + svx::NamedThemedColor aThemedColor; + aThemedColor.m_aColor = aColor; + if (bThemePaletteSelected) + { + PaletteManager::GetThemeIndexLumModOff(nPos, aThemedColor.m_nThemeIndex, aThemedColor.m_nLumMod, aThemedColor.m_nLumOff); + } + + ChangeColor(aThemedColor, false); + + if (pValSet == m_xValSetColorList.get()) + { + m_xValSetRecentList->SetNoSelection(); + if (m_xSelectPalette->get_active() == 0 && m_xValSetColorList->GetSelectedItemId() != 0) + { + m_xBtnDelete->set_sensitive(true); + m_xBtnDelete->set_tooltip_text(""); + } + else + { + m_xBtnDelete->set_sensitive(false); + m_xBtnDelete->set_tooltip_text( CuiResId(RID_CUISTR_DELETEUSERCOLOR1) ); + } + } + if (pValSet == m_xValSetRecentList.get()) + { + m_xValSetColorList->SetNoSelection(); + m_xBtnDelete->set_sensitive(false); + m_xBtnDelete->set_tooltip_text( CuiResId(RID_CUISTR_DELETEUSERCOLOR2) ); + } +} + +void SvxColorTabPage::ConvertColorValues (Color& rColor, ColorModel eModell) +{ + switch (eModell) + { + case ColorModel::RGB: + { + CmykToRgb_Impl (rColor, static_cast<sal_uInt16>(255 - rColor.GetAlpha()) ); + rColor.SetAlpha (255); + } + break; + + case ColorModel::CMYK: + { + sal_uInt16 nK; + RgbToCmyk_Impl (rColor, nK ); + rColor.SetAlpha (255 - static_cast<sal_uInt8>(nK)); + } + break; + } +} + +IMPL_LINK_NOARG(SvxColorTabPage, SelectColorModeHdl_Impl, weld::Toggleable&, void) +{ + if (m_xRbRGB->get_active()) + eCM = ColorModel::RGB; + else if (m_xRbCMYK->get_active()) + eCM = ColorModel::CMYK; + ChangeColorModel(); + UpdateColorValues(); +} + + +IMPL_STATIC_LINK_NOARG(SvxColorTabPage, OnMoreColorsClick, weld::Button&, void) +{ + css::uno::Sequence<css::beans::PropertyValue> aArgs{ comphelper::makePropertyValue( + "AdditionsTag", OUString("Color Palette")) }; + comphelper::dispatchCommand(".uno:AdditionsDialog", aArgs); +} + +void SvxColorTabPage::ChangeColor(const svx::NamedThemedColor &rNewColor, bool bUpdatePreset ) +{ + aPreviousColor = rNewColor.m_aColor; + aCurrentColor = rNewColor; + UpdateColorValues( bUpdatePreset ); + // fill ItemSet and pass it on to XOut + rXFSet.Put( XFillColorItem( OUString(), aCurrentColor.m_aColor ) ); + m_aCtlPreviewNew.SetAttributes(aXFillAttr.GetItemSet()); + m_aCtlPreviewNew.Invalidate(); +} + +void SvxColorTabPage::SetColorModel( ColorModel eModel ) +{ + if (eModel == ColorModel::RGB) + m_xRbRGB->set_active(true); + else if (eModel == ColorModel::CMYK) + m_xRbCMYK->set_active(true); +} + +void SvxColorTabPage::ChangeColorModel() +{ + switch( eCM ) + { + case ColorModel::RGB: + { + m_xRGBcustom->show(); + m_xRGBpreset->show(); + m_xCMYKcustom->hide(); + m_xCMYKpreset->hide(); + } + break; + + case ColorModel::CMYK: + { + m_xCMYKcustom->show(); + m_xCMYKpreset->show(); + m_xRGBcustom->hide(); + m_xRGBpreset->hide(); + } + break; + } +} + +void SvxColorTabPage::UpdateColorValues( bool bUpdatePreset ) +{ + if (eCM != ColorModel::RGB) + { + ConvertColorValues (aPreviousColor, eCM ); + ConvertColorValues (aCurrentColor.m_aColor, eCM); + + m_xCcustom->set_value( ColorToPercent_Impl( aCurrentColor.m_aColor.GetRed() ), FieldUnit::PERCENT ); + m_xMcustom->set_value( ColorToPercent_Impl( aCurrentColor.m_aColor.GetBlue() ), FieldUnit::PERCENT ); + m_xYcustom->set_value( ColorToPercent_Impl( aCurrentColor.m_aColor.GetGreen() ), FieldUnit::PERCENT ); + m_xKcustom->set_value( ColorToPercent_Impl( 255 - aCurrentColor.m_aColor.GetAlpha() ), FieldUnit::PERCENT ); + + if( bUpdatePreset ) + { + m_xCpreset->set_text(unicode::formatPercent(ColorToPercent_Impl(aPreviousColor.GetRed()), + Application::GetSettings().GetUILanguageTag())); + m_xMpreset->set_text(unicode::formatPercent(ColorToPercent_Impl(aPreviousColor.GetBlue()), + Application::GetSettings().GetUILanguageTag())); + m_xYpreset->set_text(unicode::formatPercent(ColorToPercent_Impl(aPreviousColor.GetGreen()), + Application::GetSettings().GetUILanguageTag())); + m_xKpreset->set_text(unicode::formatPercent(ColorToPercent_Impl(255 - aPreviousColor.GetAlpha()), + Application::GetSettings().GetUILanguageTag())); + } + + ConvertColorValues (aPreviousColor, ColorModel::RGB); + ConvertColorValues (aCurrentColor.m_aColor, ColorModel::RGB); + } + else + { + m_xRcustom->set_value( ColorToPercent_Impl( aCurrentColor.m_aColor.GetRed() ) ); + m_xGcustom->set_value( ColorToPercent_Impl( aCurrentColor.m_aColor.GetGreen() ) ); + m_xBcustom->set_value( ColorToPercent_Impl( aCurrentColor.m_aColor.GetBlue() ) ); + m_xHexcustom->SetColor( aCurrentColor.m_aColor ); + + if( bUpdatePreset ) + { + m_xRpreset->set_text(OUString::number(ColorToPercent_Impl(aPreviousColor.GetRed()))); + m_xGpreset->set_text(OUString::number(ColorToPercent_Impl(aPreviousColor.GetGreen()))); + m_xBpreset->set_text(OUString::number(ColorToPercent_Impl(aPreviousColor.GetBlue()))); + m_xHexpreset->SetColor( aPreviousColor ); + } + } +} + +sal_Int32 SvxColorTabPage::FindInCustomColors(std::u16string_view aColorName) +{ + css::uno::Sequence< OUString > aCustomColorNameList(officecfg::Office::Common::UserColors::CustomColorName::get()); + tools::Long nCount = aCustomColorNameList.getLength(); + bool bValidColorName = true; + sal_Int32 nPos = -1; + + for(tools::Long i = 0;i < nCount && bValidColorName;i++) + { + if(aColorName == aCustomColorNameList[i]) + { + nPos = i; + bValidColorName = false; + } + } + return nPos; +} + +sal_Int32 SvxColorTabPage::FindInPalette( const Color& rColor ) +{ + return pColorList->GetIndexOfColor(rColor); +} + +// A RGB value is converted to a CMYK value - not in an ideal way as +// R is converted into C, G into M and B into Y. The K value is held in an +// extra variable. For further color models one should develop own +// classes which should contain the respective casts. + +void SvxColorTabPage::RgbToCmyk_Impl( Color& rColor, sal_uInt16& rK ) +{ + sal_uInt16 const nColor1 = 255 - rColor.GetRed(); + sal_uInt16 const nColor2 = 255 - rColor.GetGreen(); + sal_uInt16 const nColor3 = 255 - rColor.GetBlue(); + + rK = std::min( std::min( nColor1, nColor2 ), nColor3 ); + + rColor.SetRed( sal::static_int_cast< sal_uInt8 >( nColor1 - rK ) ); + rColor.SetGreen( sal::static_int_cast< sal_uInt8 >( nColor2 - rK ) ); + rColor.SetBlue( sal::static_int_cast< sal_uInt8 >( nColor3 - rK ) ); +} + + +// reverse case to RgbToCmyk_Impl (see above) + +void SvxColorTabPage::CmykToRgb_Impl( Color& rColor, const sal_uInt16 nK ) +{ + tools::Long lTemp; + + lTemp = 255 - ( rColor.GetRed() + nK ); + + if( lTemp < 0 ) + lTemp = 0; + rColor.SetRed( static_cast<sal_uInt8>(lTemp) ); + + lTemp = 255 - ( rColor.GetGreen() + nK ); + + if( lTemp < 0 ) + lTemp = 0; + rColor.SetGreen( static_cast<sal_uInt8>(lTemp) ); + + lTemp = 255 - ( rColor.GetBlue() + nK ); + + if( lTemp < 0 ) + lTemp = 0; + rColor.SetBlue( static_cast<sal_uInt8>(lTemp) ); +} + + +sal_uInt16 SvxColorTabPage::ColorToPercent_Impl( sal_uInt16 nColor ) +{ + sal_uInt16 nValue = 0; + + switch (eCM) + { + case ColorModel::RGB : + nValue = nColor; + break; + + case ColorModel::CMYK: + nValue = static_cast<sal_uInt16>( static_cast<double>(nColor) * 100.0 / 255.0 + 0.5 ); + break; + } + + return nValue; +} + + +sal_uInt16 SvxColorTabPage::PercentToColor_Impl( sal_uInt16 nPercent ) +{ + sal_uInt16 nValue = 0; + + switch (eCM) + { + case ColorModel::RGB : + nValue = nPercent; + break; + + case ColorModel::CMYK: + nValue = static_cast<sal_uInt16>( static_cast<double>(nPercent) * 255.0 / 100.0 + 0.5 ); + break; + } + + return nValue; +} + + +void SvxColorTabPage::FillUserData() +{ + // the color model is saved in the Ini-file + SetUserData( OUString::number( static_cast<int>(eCM) ) ); +} + + +void SvxColorTabPage::SetPropertyList( XPropertyListType t, const XPropertyListRef &xRef ) +{ + OSL_ASSERT( t == XPropertyListType::Color ); + pColorList = XColorListRef( static_cast<XColorList *>(xRef.get() ) ); +} + +void SvxColorTabPage::SetColorList( const XColorListRef& pColList ) +{ + SetPropertyList( XPropertyListType::Color, XPropertyListRef( ( pColList.get() ) ) ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tpgradnt.cxx b/cui/source/tabpages/tpgradnt.cxx new file mode 100644 index 000000000..31a846d9c --- /dev/null +++ b/cui/source/tabpages/tpgradnt.cxx @@ -0,0 +1,633 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <tools/urlobj.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <sfx2/dialoghelper.hxx> + +#include <strings.hrc> +#include <svx/xfillit0.hxx> +#include <svx/xflgrit.hxx> +#include <svx/colorbox.hxx> +#include <svx/xtable.hxx> +#include <svx/xgrscit.hxx> +#include <cuitabarea.hxx> +#include <svx/svxdlg.hxx> +#include <dialmgr.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <sal/log.hxx> + +#define DEFAULT_GRADIENTSTEP 64 + +using namespace com::sun::star; + +SvxGradientTabPage::SvxGradientTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/gradientpage.ui", "GradientPage", &rInAttrs) + , m_rOutAttrs(rInAttrs) + , m_pnGradientListState(nullptr) + , m_pnColorListState(nullptr) + , m_aXFillAttr(rInAttrs.GetPool()) + , m_rXFSet(m_aXFillAttr.GetItemSet()) + , m_xLbGradientType(m_xBuilder->weld_combo_box("gradienttypelb")) + , m_xFtCenter(m_xBuilder->weld_label("centerft")) + , m_xMtrCenterX(m_xBuilder->weld_metric_spin_button("centerxmtr", FieldUnit::PERCENT)) + , m_xMtrCenterY(m_xBuilder->weld_metric_spin_button("centerymtr", FieldUnit::PERCENT)) + , m_xFtAngle(m_xBuilder->weld_label("angleft")) + , m_xMtrAngle(m_xBuilder->weld_metric_spin_button("anglemtr", FieldUnit::DEGREE)) + , m_xSliderAngle(m_xBuilder->weld_scale("angleslider")) + , m_xMtrBorder(m_xBuilder->weld_metric_spin_button("bordermtr", FieldUnit::PERCENT)) + , m_xSliderBorder(m_xBuilder->weld_scale("borderslider")) + , m_xLbColorFrom(new ColorListBox(m_xBuilder->weld_menu_button("colorfromlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xMtrColorFrom(m_xBuilder->weld_metric_spin_button("colorfrommtr", FieldUnit::PERCENT)) + , m_xLbColorTo(new ColorListBox(m_xBuilder->weld_menu_button("colortolb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xMtrColorTo(m_xBuilder->weld_metric_spin_button("colortomtr", FieldUnit::PERCENT)) + , m_xGradientLB(new SvxPresetListBox(m_xBuilder->weld_scrolled_window("gradientpresetlistwin", true))) + , m_xMtrIncrement(m_xBuilder->weld_spin_button("incrementmtr")) + , m_xCbIncrement(m_xBuilder->weld_check_button("autoincrement")) + , m_xBtnAdd(m_xBuilder->weld_button("add")) + , m_xBtnModify(m_xBuilder->weld_button("modify")) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "previewctl", m_aCtlPreview)) + , m_xGradientLBWin(new weld::CustomWeld(*m_xBuilder, "gradientpresetlist", *m_xGradientLB)) +{ + Size aSize = getDrawPreviewOptimalSize(m_aCtlPreview.GetDrawingArea()->get_ref_device()); + m_xGradientLB->set_size_request(aSize.Width(), aSize.Height()); + m_xCtlPreview->set_size_request(aSize.Width(), aSize.Height()); + // this page needs ExchangeSupport + SetExchangeSupport(); + + // as long as NOT supported by the item + + m_xMtrColorTo->set_value(100, FieldUnit::PERCENT); + m_xMtrColorFrom->set_value(100, FieldUnit::PERCENT); + + // setting the output device + m_rXFSet.Put( XFillStyleItem(drawing::FillStyle_GRADIENT) ); + m_rXFSet.Put( XFillGradientItem(OUString(), XGradient( COL_BLACK, COL_WHITE )) ); + m_aCtlPreview.SetAttributes(m_aXFillAttr.GetItemSet()); + + // set handler + m_xGradientLB->SetSelectHdl( LINK( this, SvxGradientTabPage, ChangeGradientHdl ) ); + m_xGradientLB->SetRenameHdl( LINK( this, SvxGradientTabPage, ClickRenameHdl_Impl ) ); + m_xGradientLB->SetDeleteHdl( LINK( this, SvxGradientTabPage, ClickDeleteHdl_Impl ) ); + m_xBtnAdd->connect_clicked(LINK(this, SvxGradientTabPage, ClickAddHdl_Impl)); + m_xBtnModify->connect_clicked(LINK(this, SvxGradientTabPage, ClickModifyHdl_Impl)); + + Link<weld::MetricSpinButton&,void> aLink = LINK( this, SvxGradientTabPage, ModifiedMetricHdl_Impl ); + Link<weld::ComboBox&,void> aLink2 = LINK( this, SvxGradientTabPage, ModifiedListBoxHdl_Impl ); + m_xLbGradientType->connect_changed( aLink2 ); + m_xCbIncrement->connect_toggled(LINK(this, SvxGradientTabPage, ChangeAutoStepHdl_Impl)); + m_xMtrIncrement->connect_value_changed(LINK(this, SvxGradientTabPage, ModifiedEditHdl_Impl)); + m_xMtrCenterX->connect_value_changed( aLink ); + m_xMtrCenterY->connect_value_changed( aLink ); + m_xMtrAngle->connect_value_changed( aLink ); + m_xSliderAngle->connect_value_changed(LINK(this, SvxGradientTabPage, ModifiedSliderHdl_Impl)); + m_xMtrBorder->connect_value_changed( aLink ); + m_xSliderBorder->connect_value_changed(LINK(this, SvxGradientTabPage, ModifiedSliderHdl_Impl)); + m_xMtrColorFrom->connect_value_changed( aLink ); + Link<ColorListBox&,void> aLink3 = LINK( this, SvxGradientTabPage, ModifiedColorListBoxHdl_Impl ); + m_xLbColorFrom->SetSelectHdl( aLink3 ); + m_xMtrColorTo->connect_value_changed( aLink ); + m_xLbColorTo->SetSelectHdl( aLink3 ); + + m_xGradientLB->SetStyle(WB_FLATVALUESET | WB_NO_DIRECTSELECT | WB_TABSTOP); + + // #i76307# always paint the preview in LTR, because this is what the document does + m_aCtlPreview.EnableRTL(false); +} + +SvxGradientTabPage::~SvxGradientTabPage() +{ + m_xCtlPreview.reset(); + m_xGradientLBWin.reset(); + m_xGradientLB.reset(); + m_xLbColorTo.reset(); + m_xLbColorFrom.reset(); +} + +void SvxGradientTabPage::Construct() +{ + m_xGradientLB->FillPresetListBox( *m_pGradientList ); +} + +void SvxGradientTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + if( !m_pColorList.is() ) + return; + + // ColorList + if( *m_pnColorListState & ChangeType::CHANGED || + *m_pnColorListState & ChangeType::MODIFIED ) + { + SvxAreaTabDialog* pArea = (*m_pnColorListState & ChangeType::CHANGED) ? + dynamic_cast<SvxAreaTabDialog*>(GetDialogController()) : nullptr; + if (pArea) + m_pColorList = pArea->GetNewColorList(); + + ModifiedHdl_Impl( this ); + } + + // determining (and possibly cutting) the name and + // displaying it in the GroupBox + OUString aString = CuiResId( RID_CUISTR_TABLE ) + ": "; + INetURLObject aURL( m_pGradientList->GetPath() ); + + aURL.Append( m_pGradientList->GetName() ); + SAL_WARN_IF( aURL.GetProtocol() == INetProtocol::NotValid, "cui.tabpages", "invalid URL" ); + + if ( aURL.getBase().getLength() > 18 ) + { + aString += OUString::Concat(aURL.getBase().subView( 0, 15 )) + "..."; + } + else + aString += aURL.getBase(); + + sal_Int32 nPos = SearchGradientList( rSet.Get(XATTR_FILLGRADIENT).GetName() ); + if ( nPos != -1) + { + sal_uInt16 nId = m_xGradientLB->GetItemId( static_cast<size_t>( nPos ) ); + m_xGradientLB->SelectItem( nId ); + } + // colors could have been deleted + ChangeGradientHdl_Impl(); +} + + +DeactivateRC SvxGradientTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + +bool SvxGradientTabPage::FillItemSet( SfxItemSet* rSet ) +{ + std::unique_ptr<XGradient> pXGradient; + size_t nPos = m_xGradientLB->IsNoSelection() ? VALUESET_ITEM_NOTFOUND : m_xGradientLB->GetSelectItemPos(); + if( nPos != VALUESET_ITEM_NOTFOUND ) + { + pXGradient.reset(new XGradient( m_pGradientList->GetGradient( static_cast<sal_uInt16>(nPos) )->GetGradient() )); + OUString aString = m_xGradientLB->GetItemText( m_xGradientLB->GetSelectedItemId() ); + rSet->Put( XFillGradientItem( aString, *pXGradient ) ); + } + else + // gradient was passed (unidentified) + { + pXGradient.reset(new XGradient( m_xLbColorFrom->GetSelectEntryColor(), + m_xLbColorTo->GetSelectEntryColor(), + static_cast<css::awt::GradientStyle>(m_xLbGradientType->get_active()), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)), // should be changed in resource + static_cast<sal_uInt16>(m_xMtrCenterX->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrCenterY->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrBorder->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorFrom->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorTo->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrIncrement->get_value()) )); + rSet->Put( XFillGradientItem( OUString(), *pXGradient ) ); + } + + sal_uInt16 nValue = 0; + if (!m_xCbIncrement->get_active()) + nValue = m_xMtrIncrement->get_value(); + + assert( pXGradient && "XGradient could not be created" ); + rSet->Put( XFillStyleItem( drawing::FillStyle_GRADIENT ) ); + rSet->Put( XGradientStepCountItem( nValue ) ); + return true; +} + +void SvxGradientTabPage::Reset( const SfxItemSet* ) +{ + m_xMtrIncrement->set_value(DEFAULT_GRADIENTSTEP); + ChangeGradientHdl_Impl(); + + // determine state of the buttons + if( m_pGradientList->Count() ) + m_xBtnModify->set_sensitive(true); + else + m_xBtnModify->set_sensitive(false); +} + +std::unique_ptr<SfxTabPage> SvxGradientTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rOutAttrs ) +{ + return std::make_unique<SvxGradientTabPage>(pPage, pController, *rOutAttrs); +} + +IMPL_LINK( SvxGradientTabPage, ModifiedListBoxHdl_Impl, weld::ComboBox&, rListBox, void ) +{ + ModifiedHdl_Impl(&rListBox); + // gradient params changed, it is no longer one of the presets + m_xGradientLB->SetNoSelection(); +} + +IMPL_LINK( SvxGradientTabPage, ModifiedColorListBoxHdl_Impl, ColorListBox&, rListBox, void ) +{ + ModifiedHdl_Impl(&rListBox); + m_xGradientLB->SetNoSelection(); +} + +IMPL_LINK( SvxGradientTabPage, ModifiedEditHdl_Impl, weld::SpinButton&, rBox, void ) +{ + ModifiedHdl_Impl(&rBox); + m_xGradientLB->SetNoSelection(); +} + +IMPL_LINK( SvxGradientTabPage, ModifiedMetricHdl_Impl, weld::MetricSpinButton&, rBox, void ) +{ + ModifiedHdl_Impl(&rBox); + m_xGradientLB->SetNoSelection(); +} + +IMPL_LINK( SvxGradientTabPage, ModifiedSliderHdl_Impl, weld::Scale&, rSlider, void ) +{ + ModifiedHdl_Impl(&rSlider); + m_xGradientLB->SetNoSelection(); +} + +IMPL_LINK_NOARG( SvxGradientTabPage, ChangeAutoStepHdl_Impl, weld::Toggleable&, void ) +{ + if (m_xCbIncrement->get_active()) + { + m_xMtrIncrement->set_sensitive(false); + } + else + { + m_xMtrIncrement->set_sensitive(true); + } + ModifiedHdl_Impl(m_xMtrIncrement.get()); +} + +void SvxGradientTabPage::ModifiedHdl_Impl( void const * pControl ) +{ + if (pControl == m_xMtrBorder.get()) + m_xSliderBorder->set_value(m_xMtrBorder->get_value(FieldUnit::NONE)); + if (pControl == m_xSliderBorder.get()) + m_xMtrBorder->set_value(m_xSliderBorder->get_value(), FieldUnit::NONE); + if (pControl == m_xMtrAngle.get()) + m_xSliderAngle->set_value(m_xMtrAngle->get_value(FieldUnit::NONE)); + if (pControl == m_xSliderAngle.get()) + m_xMtrAngle->set_value(m_xSliderAngle->get_value(), FieldUnit::NONE); + + css::awt::GradientStyle eXGS = static_cast<css::awt::GradientStyle>(m_xLbGradientType->get_active()); + + XGradient aXGradient( m_xLbColorFrom->GetSelectEntryColor(), + m_xLbColorTo->GetSelectEntryColor(), + eXGS, + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)), // should be changed in resource + static_cast<sal_uInt16>(m_xMtrCenterX->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrCenterY->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrBorder->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorFrom->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorTo->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrIncrement->get_value()) ); + + // enable/disable controls + if (pControl == m_xLbGradientType.get() || pControl == this) + SetControlState_Impl( eXGS ); + + sal_uInt16 nValue = 0; + if (!m_xCbIncrement->get_active()) + nValue = static_cast<sal_uInt16>(m_xMtrIncrement->get_value()); + m_rXFSet.Put( XGradientStepCountItem( nValue ) ); + + // displaying in XOutDev + m_rXFSet.Put( XFillGradientItem( OUString(), aXGradient ) ); + m_aCtlPreview.SetAttributes(m_aXFillAttr.GetItemSet()); + m_aCtlPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxGradientTabPage, ClickAddHdl_Impl, weld::Button&, void) +{ + OUString aNewName( SvxResId( RID_SVXSTR_GRADIENT ) ); + OUString aDesc( CuiResId( RID_CUISTR_DESC_GRADIENT ) ); + OUString aName; + + tools::Long nCount = m_pGradientList->Count(); + tools::Long j = 1; + bool bValidGradientName = false; + + while( !bValidGradientName ) + { + aName = aNewName + " " + OUString::number( j++ ); + bValidGradientName = (SearchGradientList(aName) == -1); + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + sal_uInt16 nError = 1; + + while (pDlg->Execute() == RET_OK) + { + pDlg->GetName( aName ); + + bValidGradientName = (SearchGradientList(aName) == -1); + + if (bValidGradientName) + { + nError = 0; + break; + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarnBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + if (xWarnBox->run() != RET_OK) + break; + } + pDlg.disposeAndClear(); + + if( !nError ) + { + XGradient aXGradient( m_xLbColorFrom->GetSelectEntryColor(), + m_xLbColorTo->GetSelectEntryColor(), + static_cast<css::awt::GradientStyle>(m_xLbGradientType->get_active()), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)), // should be changed in resource + static_cast<sal_uInt16>(m_xMtrCenterX->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrCenterY->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrBorder->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorFrom->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorTo->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrIncrement->get_value()) ); + + m_pGradientList->Insert(std::make_unique<XGradientEntry>(aXGradient, aName), nCount); + + sal_Int32 nId = m_xGradientLB->GetItemId(nCount - 1); //calculate the last ID + BitmapEx aBitmap = m_pGradientList->GetBitmapForPreview( nCount, m_xGradientLB->GetIconSize() ); + m_xGradientLB->InsertItem( nId + 1, Image(aBitmap), aName ); + m_xGradientLB->SelectItem( nId + 1 ); + m_xGradientLB->Resize(); + + *m_pnGradientListState |= ChangeType::MODIFIED; + + ChangeGradientHdl_Impl(); + } + + // determine button state + if (m_pGradientList->Count()) + m_xBtnModify->set_sensitive(true); +} + + +IMPL_LINK_NOARG(SvxGradientTabPage, ClickModifyHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nId = m_xGradientLB->GetSelectedItemId(); + size_t nPos = m_xGradientLB->GetSelectItemPos(); + + if ( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aName( m_pGradientList->GetGradient( static_cast<sal_uInt16>(nPos) )->GetName() ); + + XGradient aXGradient( m_xLbColorFrom->GetSelectEntryColor(), + m_xLbColorTo->GetSelectEntryColor(), + static_cast<css::awt::GradientStyle>(m_xLbGradientType->get_active()), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)), // should be changed in resource + static_cast<sal_uInt16>(m_xMtrCenterX->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrCenterY->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrBorder->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorFrom->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrColorTo->get_value(FieldUnit::NONE)), + static_cast<sal_uInt16>(m_xMtrIncrement->get_value()) ); + + m_pGradientList->Replace(std::make_unique<XGradientEntry>(aXGradient, aName), nPos); + + BitmapEx aBitmap = m_pGradientList->GetBitmapForPreview( static_cast<sal_uInt16>(nPos), m_xGradientLB->GetIconSize() ); + m_xGradientLB->RemoveItem( nId ); + m_xGradientLB->InsertItem( nId, Image(aBitmap), aName, static_cast<sal_uInt16>(nPos) ); + m_xGradientLB->SelectItem( nId ); + + *m_pnGradientListState |= ChangeType::MODIFIED; +} + +IMPL_LINK_NOARG(SvxGradientTabPage, ClickDeleteHdl_Impl, SvxPresetListBox*, void) +{ + sal_uInt16 nId = m_xGradientLB->GetSelectedItemId(); + size_t nPos = m_xGradientLB->GetSelectItemPos(); + + if( nPos != VALUESET_ITEM_NOTFOUND ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querydeletegradientdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskDelGradientDialog")); + if (xQueryBox->run() == RET_YES) + { + m_pGradientList->Remove(nPos); + m_xGradientLB->RemoveItem( nId ); + nId = m_xGradientLB->GetItemId( 0 ); + m_xGradientLB->SelectItem( nId ); + m_xGradientLB->Resize(); + + m_aCtlPreview.Invalidate(); + + ChangeGradientHdl_Impl(); + + *m_pnGradientListState |= ChangeType::MODIFIED; + } + } + // determine button state + if( !m_pGradientList->Count() ) + m_xBtnModify->set_sensitive(false); +} + +IMPL_LINK_NOARG(SvxGradientTabPage, ClickRenameHdl_Impl, SvxPresetListBox*, void) +{ + sal_uInt16 nId = m_xGradientLB->GetSelectedItemId(); + size_t nPos = m_xGradientLB->GetSelectItemPos(); + + if ( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aDesc( CuiResId( RID_CUISTR_DESC_GRADIENT ) ); + OUString aName( m_pGradientList->GetGradient( nPos )->GetName() ); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + + bool bLoop = true; + while( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + sal_Int32 nGradientPos = SearchGradientList(aName); + bool bValidGradientName = (nGradientPos == static_cast<sal_Int32>(nPos) ) || (nGradientPos == -1); + + if( bValidGradientName ) + { + bLoop = false; + m_pGradientList->GetGradient(nPos)->SetName(aName); + + m_xGradientLB->SetItemText( nId, aName ); + m_xGradientLB->SelectItem( nId ); + + *m_pnGradientListState |= ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xBox->run(); + } + } +} + +IMPL_LINK_NOARG(SvxGradientTabPage, ChangeGradientHdl, ValueSet*, void) +{ + ChangeGradientHdl_Impl(); +} + +void SvxGradientTabPage::ChangeGradientHdl_Impl() +{ + std::unique_ptr<XGradient> pGradient; + size_t nPos = m_xGradientLB->GetSelectItemPos(); + + if( nPos != VALUESET_ITEM_NOTFOUND ) + pGradient.reset(new XGradient( m_pGradientList->GetGradient( static_cast<sal_uInt16>( nPos ) )->GetGradient() )); + else + { + if( const XFillStyleItem* pFillStyleItem = m_rOutAttrs.GetItemIfSet( GetWhich( XATTR_FILLSTYLE ) ) ) + { + const XFillGradientItem* pGradientItem; + if( ( drawing::FillStyle_GRADIENT == pFillStyleItem->GetValue() ) && + ( pGradientItem = m_rOutAttrs.GetItemIfSet( GetWhich( XATTR_FILLGRADIENT ) ) ) ) + { + pGradient.reset(new XGradient( pGradientItem->GetGradientValue() )); + } + } + if( !pGradient ) + { + sal_uInt16 nPosition = m_xGradientLB->GetItemId(0); + m_xGradientLB->SelectItem( nPosition ); + if( nPosition != 0 ) + pGradient.reset(new XGradient( m_pGradientList->GetGradient( 0 )->GetGradient() )); + } + } + + if( !pGradient ) + return; + + css::awt::GradientStyle eXGS = pGradient->GetGradientStyle(); + sal_uInt16 nValue = pGradient->GetSteps(); + if( nValue == 0 ) + { + m_xCbIncrement->set_state(TRISTATE_TRUE); + m_xMtrIncrement->set_sensitive(false); + } + else + { + m_xCbIncrement->set_state(TRISTATE_FALSE); + m_xMtrIncrement->set_sensitive(true); + m_xMtrIncrement->set_value( nValue ); + } + m_xLbGradientType->set_active( + sal::static_int_cast< sal_Int32 >( eXGS ) ); + // if the entry is not in the listbox, + // colors are added temporarily + m_xLbColorFrom->SetNoSelection(); + m_xLbColorFrom->SelectEntry( pGradient->GetStartColor() ); + + m_xLbColorTo->SetNoSelection(); + m_xLbColorTo->SelectEntry( pGradient->GetEndColor() ); + + m_xMtrAngle->set_value(pGradient->GetAngle().get() / 10, FieldUnit::NONE); // should be changed in resource + m_xSliderAngle->set_value(pGradient->GetAngle().get() / 10); + m_xMtrBorder->set_value(pGradient->GetBorder(), FieldUnit::NONE); + m_xSliderBorder->set_value(pGradient->GetBorder()); + m_xMtrCenterX->set_value(pGradient->GetXOffset(), FieldUnit::NONE); + m_xMtrCenterY->set_value(pGradient->GetYOffset(), FieldUnit::NONE); + m_xMtrColorFrom->set_value(pGradient->GetStartIntens(), FieldUnit::NONE); + m_xMtrColorTo->set_value(pGradient->GetEndIntens(), FieldUnit::NONE); + + // disable/enable controls + SetControlState_Impl( eXGS ); + + // fill ItemSet and pass it on to aCtlPreview + m_rXFSet.Put( XFillGradientItem( OUString(), *pGradient ) ); + m_rXFSet.Put( XGradientStepCountItem( nValue ) ); + m_aCtlPreview.SetAttributes(m_aXFillAttr.GetItemSet()); + + m_aCtlPreview.Invalidate(); +} + +void SvxGradientTabPage::SetControlState_Impl( css::awt::GradientStyle eXGS ) +{ + switch( eXGS ) + { + case css::awt::GradientStyle_LINEAR: + case css::awt::GradientStyle_AXIAL: + m_xFtCenter->set_sensitive(false); + m_xMtrCenterX->set_sensitive(false); + m_xMtrCenterY->set_sensitive(false); + m_xFtAngle->set_sensitive(true); + m_xMtrAngle->set_sensitive(true); + m_xSliderAngle->set_sensitive(true); + break; + + case css::awt::GradientStyle_RADIAL: + m_xFtCenter->set_sensitive(true); + m_xMtrCenterX->set_sensitive(true); + m_xMtrCenterY->set_sensitive(true); + m_xFtAngle->set_sensitive(false); + m_xMtrAngle->set_sensitive(false); + m_xSliderAngle->set_sensitive(false); + break; + + case css::awt::GradientStyle_ELLIPTICAL: + m_xFtCenter->set_sensitive(true); + m_xMtrCenterX->set_sensitive(true); + m_xMtrCenterY->set_sensitive(true); + m_xFtAngle->set_sensitive(true); + m_xMtrAngle->set_sensitive(true); + m_xSliderAngle->set_sensitive(true); + break; + + case css::awt::GradientStyle_SQUARE: + case css::awt::GradientStyle_RECT: + m_xFtCenter->set_sensitive(true); + m_xMtrCenterX->set_sensitive(true); + m_xMtrCenterY->set_sensitive(true); + m_xFtAngle->set_sensitive(true); + m_xMtrAngle->set_sensitive(true); + m_xSliderAngle->set_sensitive(true); + break; + default: + break; + } +} + +sal_Int32 SvxGradientTabPage::SearchGradientList(std::u16string_view rGradientName) +{ + tools::Long nCount = m_pGradientList->Count(); + bool bValidGradientName = true; + sal_Int32 nPos = -1; + + for(tools::Long i = 0;i < nCount && bValidGradientName;i++) + { + if(rGradientName == m_pGradientList->GetGradient( i )->GetName()) + { + nPos = i; + bValidGradientName = false; + } + } + return nPos; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tphatch.cxx b/cui/source/tabpages/tphatch.cxx new file mode 100644 index 000000000..1a3511473 --- /dev/null +++ b/cui/source/tabpages/tphatch.cxx @@ -0,0 +1,562 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <tools/urlobj.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <sfx2/dialoghelper.hxx> + +#include <strings.hrc> +#include <svx/xfillit0.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xflclit.hxx> +#include <svx/colorbox.hxx> +#include <svx/xtable.hxx> +#include <svx/xflbckit.hxx> +#include <cuitabarea.hxx> +#include <svx/svxdlg.hxx> +#include <dialmgr.hxx> +#include <svx/dlgutil.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include <sal/log.hxx> +#include <svtools/unitconv.hxx> + +using namespace com::sun::star; + +SvxHatchTabPage::SvxHatchTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/hatchpage.ui", "HatchPage", &rInAttrs) + , m_rOutAttrs(rInAttrs) + , m_pnHatchingListState(nullptr) + , m_pnColorListState(nullptr) + , m_aXFillAttr(rInAttrs.GetPool()) + , m_rXFSet(m_aXFillAttr.GetItemSet()) + , m_xMtrDistance(m_xBuilder->weld_metric_spin_button("distancemtr", FieldUnit::MM)) + , m_xMtrAngle(m_xBuilder->weld_metric_spin_button("anglemtr", FieldUnit::DEGREE)) + , m_xSliderAngle(m_xBuilder->weld_scale("angleslider")) + , m_xLbLineType(m_xBuilder->weld_combo_box("linetypelb")) + , m_xLbLineColor(new ColorListBox(m_xBuilder->weld_menu_button("linecolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xCbBackgroundColor(m_xBuilder->weld_check_button("backgroundcolor")) + , m_xLbBackgroundColor(new ColorListBox(m_xBuilder->weld_menu_button("backgroundcolorlb"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xHatchLB(new SvxPresetListBox(m_xBuilder->weld_scrolled_window("hatchpresetlistwin", true))) + , m_xBtnAdd(m_xBuilder->weld_button("add")) + , m_xBtnModify(m_xBuilder->weld_button("modify")) + , m_xHatchLBWin(new weld::CustomWeld(*m_xBuilder, "hatchpresetlist", *m_xHatchLB)) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "previewctl", m_aCtlPreview)) +{ + Size aSize = getDrawPreviewOptimalSize(m_aCtlPreview.GetDrawingArea()->get_ref_device()); + m_xHatchLBWin->set_size_request(aSize.Width(), aSize.Height()); + m_xCtlPreview->set_size_request(aSize.Width(), aSize.Height()); + + // this page needs ExchangeSupport + SetExchangeSupport(); + + // adjust metric + FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs ); + + switch ( eFUnit ) + { + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + break; + default: ;//prevent warning + } + SetFieldUnit( *m_xMtrDistance, eFUnit ); + + // determine PoolUnit + SfxItemPool* pPool = m_rOutAttrs.GetPool(); + assert( pPool && "Where is the pool?" ); + m_ePoolUnit = pPool->GetMetric( SID_ATTR_FILL_HATCH ); + + // setting the output device + m_rXFSet.Put( XFillStyleItem(drawing::FillStyle_HATCH) ); + m_rXFSet.Put( XFillHatchItem(OUString(), XHatch()) ); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_xHatchLB->SetSelectHdl( LINK( this, SvxHatchTabPage, ChangeHatchHdl ) ); + m_xHatchLB->SetRenameHdl( LINK( this, SvxHatchTabPage, ClickRenameHdl_Impl ) ); + m_xHatchLB->SetDeleteHdl( LINK( this, SvxHatchTabPage, ClickDeleteHdl_Impl ) ); + + Link<weld::MetricSpinButton&,void> aLink = LINK( this, SvxHatchTabPage, ModifiedEditHdl_Impl ); + Link<weld::ComboBox&,void> aLink2 = LINK( this, SvxHatchTabPage, ModifiedListBoxHdl_Impl ); + m_xMtrDistance->connect_value_changed( aLink ); + m_xMtrAngle->connect_value_changed( aLink ); + m_xSliderAngle->connect_value_changed(LINK(this, SvxHatchTabPage, ModifiedSliderHdl_Impl)); + m_xLbLineType->connect_changed( aLink2 ); + Link<ColorListBox&,void> aLink3 = LINK( this, SvxHatchTabPage, ModifiedColorListBoxHdl_Impl ); + m_xLbLineColor->SetSelectHdl( aLink3 ); + m_xCbBackgroundColor->connect_toggled( LINK( this, SvxHatchTabPage, ToggleHatchBackgroundColor_Impl ) ); + m_xLbBackgroundColor->SetSelectHdl( LINK( this, SvxHatchTabPage, ModifiedBackgroundHdl_Impl ) ); + + m_xBtnAdd->connect_clicked( LINK( this, SvxHatchTabPage, ClickAddHdl_Impl ) ); + m_xBtnModify->connect_clicked( LINK( this, SvxHatchTabPage, ClickModifyHdl_Impl ) ); + + m_xHatchLB->SetStyle(WB_FLATVALUESET | WB_NO_DIRECTSELECT | WB_TABSTOP); + + m_aCtlPreview.SetDrawMode(Application::GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR); +} + +SvxHatchTabPage::~SvxHatchTabPage() +{ + m_xCtlPreview.reset(); + m_xHatchLBWin.reset(); + m_xHatchLB.reset(); + m_xLbBackgroundColor.reset(); + m_xLbLineColor.reset(); +} + +void SvxHatchTabPage::Construct() +{ + m_xHatchLB->FillPresetListBox(*m_pHatchingList); +} + +void SvxHatchTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + if( m_pColorList.is() ) + { + // ColorList + if( *m_pnColorListState & ChangeType::CHANGED || + *m_pnColorListState & ChangeType::MODIFIED ) + { + SvxAreaTabDialog* pArea = (*m_pnColorListState & ChangeType::CHANGED) ? + dynamic_cast<SvxAreaTabDialog*>(GetDialogController()) : nullptr; + if (pArea) + m_pColorList = pArea->GetNewColorList(); + + ModifiedHdl_Impl( this ); + } + + // determining (possibly cutting) the name + // and displaying it in the GroupBox + OUString aString = CuiResId( RID_CUISTR_TABLE ) + ": "; + INetURLObject aURL( m_pHatchingList->GetPath() ); + + aURL.Append( m_pHatchingList->GetName() ); + SAL_WARN_IF( aURL.GetProtocol() == INetProtocol::NotValid, "cui.tabpages", "invalid URL" ); + + if ( aURL.getBase().getLength() > 18 ) + { + aString += OUString::Concat(aURL.getBase().subView( 0, 15 )) + "..."; + } + else + aString += aURL.getBase(); + + sal_Int32 nPos = SearchHatchList( rSet.Get(XATTR_FILLHATCH).GetName() ); + if( nPos != -1) + { + sal_uInt16 nId = m_xHatchLB->GetItemId( static_cast<size_t>( nPos ) ); + m_xHatchLB->SelectItem( nId ); + } + // colors could have been deleted + ChangeHatchHdl_Impl(); + } + + XFillBackgroundItem aBckItem( rSet.Get(XATTR_FILLBACKGROUND)); + m_rXFSet.Put( aBckItem ); + + if (aBckItem.GetValue()) + { + m_xCbBackgroundColor->set_state(TRISTATE_TRUE); + XFillColorItem aColorItem( rSet.Get(XATTR_FILLCOLOR) ); + Color aColor(aColorItem.GetColorValue()); + m_xLbBackgroundColor->SelectEntry(aColor); + m_xLbBackgroundColor->set_sensitive(true); + m_rXFSet.Put( aColorItem ); + } + else + { + m_xCbBackgroundColor->set_state(TRISTATE_FALSE); + m_xLbBackgroundColor->SelectEntry(COL_AUTO); + m_xLbBackgroundColor->set_sensitive(false); + } + + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); +} + +DeactivateRC SvxHatchTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + +sal_Int32 SvxHatchTabPage::SearchHatchList(std::u16string_view rHatchName) +{ + tools::Long nCount = m_pHatchingList->Count(); + bool bValidHatchName = true; + sal_Int32 nPos = -1; + + for(tools::Long i = 0;i < nCount && bValidHatchName;i++) + { + if(rHatchName == m_pHatchingList->GetHatch( i )->GetName()) + { + nPos = i; + bValidHatchName = false; + } + } + return nPos; +} + +bool SvxHatchTabPage::FillItemSet( SfxItemSet* rSet ) +{ + std::unique_ptr<XHatch> pXHatch; + OUString aString; + size_t nPos = m_xHatchLB->IsNoSelection() ? VALUESET_ITEM_NOTFOUND : m_xHatchLB->GetSelectItemPos(); + if( nPos != VALUESET_ITEM_NOTFOUND ) + { + pXHatch.reset(new XHatch( m_pHatchingList->GetHatch( static_cast<sal_uInt16>(nPos) )->GetHatch() )); + aString = m_xHatchLB->GetItemText( m_xHatchLB->GetSelectedItemId() ); + } + // unidentified hatch has been passed + else + { + pXHatch.reset(new XHatch( m_xLbLineColor->GetSelectEntryColor(), + static_cast<css::drawing::HatchStyle>(m_xLbLineType->get_active()), + GetCoreValue( *m_xMtrDistance, m_ePoolUnit ), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)) )); + } + assert( pXHatch && "XHatch couldn't be created" ); + rSet->Put( XFillStyleItem( drawing::FillStyle_HATCH ) ); + rSet->Put( XFillHatchItem( aString, *pXHatch ) ); + rSet->Put( XFillBackgroundItem( m_xCbBackgroundColor->get_active() ) ); + if (m_xCbBackgroundColor->get_active()) + { + NamedColor aColor = m_xLbBackgroundColor->GetSelectedEntry(); + rSet->Put(XFillColorItem(aColor.second, aColor.first)); + } + return true; +} + +void SvxHatchTabPage::Reset( const SfxItemSet* rSet ) +{ + ChangeHatchHdl_Impl(); + + XFillColorItem aColItem( rSet->Get(XATTR_FILLCOLOR) ); + m_xLbBackgroundColor->SelectEntry(aColItem.GetColorValue()); + m_rXFSet.Put( aColItem ); + + XFillBackgroundItem aBckItem( rSet->Get(XATTR_FILLBACKGROUND) ); + if(aBckItem.GetValue()) + m_xCbBackgroundColor->set_state(TRISTATE_TRUE); + else + m_xCbBackgroundColor->set_state(TRISTATE_FALSE); + m_rXFSet.Put( aBckItem ); + + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); +} + +std::unique_ptr<SfxTabPage> SvxHatchTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rSet ) +{ + return std::make_unique<SvxHatchTabPage>(pPage, pController, *rSet); +} + +IMPL_LINK( SvxHatchTabPage, ModifiedListBoxHdl_Impl, weld::ComboBox&, rListBox, void ) +{ + ModifiedHdl_Impl(&rListBox); + // hatch params have changed, it is no longer one of the presets + m_xHatchLB->SetNoSelection(); +} + +IMPL_LINK( SvxHatchTabPage, ModifiedColorListBoxHdl_Impl, ColorListBox&, rListBox, void ) +{ + ModifiedHdl_Impl(&rListBox); + m_xHatchLB->SetNoSelection(); +} + +IMPL_LINK_NOARG( SvxHatchTabPage, ToggleHatchBackgroundColor_Impl, weld::Toggleable&, void ) +{ + if (m_xCbBackgroundColor->get_active()) + m_xLbBackgroundColor->set_sensitive(true); + else + m_xLbBackgroundColor->set_sensitive(false); + m_rXFSet.Put( XFillBackgroundItem( m_xCbBackgroundColor->get_active() ) ); + ModifiedBackgroundHdl_Impl(*m_xLbBackgroundColor); +} + +IMPL_LINK_NOARG( SvxHatchTabPage, ModifiedBackgroundHdl_Impl, ColorListBox&, void ) +{ + Color aColor(COL_TRANSPARENT); + if (m_xCbBackgroundColor->get_active()) + { + aColor = m_xLbBackgroundColor->GetSelectEntryColor(); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); + } + m_rXFSet.Put(XFillColorItem( OUString(), aColor )); + + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); +} + +IMPL_LINK( SvxHatchTabPage, ModifiedEditHdl_Impl, weld::MetricSpinButton&, rEdit, void ) +{ + ModifiedHdl_Impl(&rEdit); + m_xHatchLB->SetNoSelection(); +} + +IMPL_LINK( SvxHatchTabPage, ModifiedSliderHdl_Impl, weld::Scale&, rSlider, void ) +{ + ModifiedHdl_Impl(&rSlider); + m_xHatchLB->SetNoSelection(); +} + +void SvxHatchTabPage::ModifiedHdl_Impl( void const * p ) +{ + if (p == m_xMtrAngle.get()) + m_xSliderAngle->set_value(m_xMtrAngle->get_value(FieldUnit::NONE)); + + if (p == m_xSliderAngle.get()) + m_xMtrAngle->set_value(m_xSliderAngle->get_value(), FieldUnit::NONE); + + XHatch aXHatch( m_xLbLineColor->GetSelectEntryColor(), + static_cast<css::drawing::HatchStyle>(m_xLbLineType->get_active()), + GetCoreValue( *m_xMtrDistance, m_ePoolUnit ), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)) ); + + m_rXFSet.Put( XFillHatchItem( OUString(), aXHatch ) ); + + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxHatchTabPage, ChangeHatchHdl, ValueSet*, void) +{ + ChangeHatchHdl_Impl(); +} + +void SvxHatchTabPage::ChangeHatchHdl_Impl() +{ + std::unique_ptr<XHatch> pHatch; + size_t nPos = m_xHatchLB->GetSelectItemPos(); + + if( nPos != VALUESET_ITEM_NOTFOUND ) + pHatch.reset(new XHatch( m_pHatchingList->GetHatch( static_cast<sal_uInt16>(nPos) )->GetHatch() )); + else + { + if( const XFillStyleItem* pFillStyleItem = m_rOutAttrs.GetItemIfSet( GetWhich( XATTR_FILLSTYLE ) ) ) + { + const XFillHatchItem* pFillHatchItem; + if( ( drawing::FillStyle_HATCH == pFillStyleItem->GetValue() ) && + ( pFillHatchItem = m_rOutAttrs.GetItemIfSet( GetWhich( XATTR_FILLHATCH ) ) ) ) + { + pHatch.reset(new XHatch( pFillHatchItem->GetHatchValue() )); + } + } + if( !pHatch ) + { + sal_uInt16 nPosition = m_xHatchLB->GetItemId( 0 ); + m_xHatchLB->SelectItem( nPosition ); + if( nPosition != 0 ) + pHatch.reset( new XHatch( m_pHatchingList->GetHatch( 0 )->GetHatch() ) ); + } + } + if( pHatch ) + { + m_xLbLineType->set_active( + sal::static_int_cast< sal_Int32 >( pHatch->GetHatchStyle() ) ); + m_xLbLineColor->SetNoSelection(); + m_xLbLineColor->SelectEntry( pHatch->GetColor() ); + SetMetricValue( *m_xMtrDistance, pHatch->GetDistance(), m_ePoolUnit ); + tools::Long nHatchAngle = pHatch->GetAngle().get() / 10; + m_xMtrAngle->set_value(nHatchAngle, FieldUnit::NONE); + m_xSliderAngle->set_value(nHatchAngle); + + // fill ItemSet and pass it on to m_aCtlPreview + m_rXFSet.Put( XFillHatchItem( OUString(), *pHatch ) ); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + + m_aCtlPreview.Invalidate(); + pHatch.reset(); + } + m_xMtrDistance->save_value(); + m_xMtrAngle->save_value(); + m_xLbLineType->save_value(); + m_xLbLineColor->SaveValue(); + m_xLbBackgroundColor->SaveValue(); +} + +IMPL_LINK_NOARG(SvxHatchTabPage, ClickAddHdl_Impl, weld::Button&, void) +{ + OUString aNewName( SvxResId( RID_SVXSTR_HATCH ) ); + OUString aDesc( CuiResId( RID_CUISTR_DESC_HATCH ) ); + OUString aName; + + tools::Long nCount = m_pHatchingList->Count(); + tools::Long j = 1; + bool bValidHatchName = false; + + while( !bValidHatchName ) + { + aName = aNewName + " " + OUString::number( j++ ); + bValidHatchName = (SearchHatchList(aName) == -1); + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + sal_uInt16 nError = 1; + + while( pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + + bValidHatchName = (SearchHatchList(aName) == -1); + if( bValidHatchName ) + { + nError = 0; + break; + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarnBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + if (xWarnBox->run() != RET_OK) + break; + } + pDlg.disposeAndClear(); + + if( nError ) + return; + + XHatch aXHatch( m_xLbLineColor->GetSelectEntryColor(), + static_cast<css::drawing::HatchStyle>(m_xLbLineType->get_active()), + GetCoreValue( *m_xMtrDistance, m_ePoolUnit ), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)) ); + + m_pHatchingList->Insert(std::make_unique<XHatchEntry>(aXHatch, aName), nCount); + + sal_Int32 nId = m_xHatchLB->GetItemId(nCount - 1); // calculate the last ID + BitmapEx aBitmap = m_pHatchingList->GetBitmapForPreview( nCount, m_xHatchLB->GetIconSize() ); + // Insert the new entry at the next ID + m_xHatchLB->InsertItem( nId + 1, Image(aBitmap), aName ); + m_xHatchLB->SelectItem( nId + 1 ); + m_xHatchLB->Resize(); + + *m_pnHatchingListState |= ChangeType::MODIFIED; + + ChangeHatchHdl_Impl(); +} + +IMPL_LINK_NOARG(SvxHatchTabPage, ClickModifyHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nId = m_xHatchLB->GetSelectedItemId(); + size_t nPos = m_xHatchLB->GetSelectItemPos(); + + if( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aName( m_pHatchingList->GetHatch( static_cast<sal_uInt16>(nPos) )->GetName() ); + + XHatch aXHatch( m_xLbLineColor->GetSelectEntryColor(), + static_cast<css::drawing::HatchStyle>(m_xLbLineType->get_active()), + GetCoreValue( *m_xMtrDistance, m_ePoolUnit ), + Degree10(static_cast<sal_Int16>(m_xMtrAngle->get_value(FieldUnit::NONE) * 10)) ); + + m_pHatchingList->Replace(std::make_unique<XHatchEntry>(aXHatch, aName), nPos); + + BitmapEx aBitmap = m_pHatchingList->GetBitmapForPreview( static_cast<sal_uInt16>(nPos), m_xHatchLB->GetIconSize() ); + m_xHatchLB->RemoveItem( nId ); + m_xHatchLB->InsertItem( nId, Image(aBitmap), aName, static_cast<sal_uInt16>(nPos) ); + m_xHatchLB->SelectItem( nId ); + + // save values for changes recognition (-> method) + m_xMtrDistance->save_value(); + m_xMtrAngle->save_value(); + m_xLbLineType->save_value(); + m_xLbLineColor->SaveValue(); + m_xLbBackgroundColor->SaveValue(); + + *m_pnHatchingListState |= ChangeType::MODIFIED; +} + +IMPL_LINK_NOARG(SvxHatchTabPage, ClickDeleteHdl_Impl, SvxPresetListBox*, void) +{ + sal_uInt16 nId = m_xHatchLB->GetSelectedItemId(); + size_t nPos = m_xHatchLB->GetSelectItemPos(); + + if( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querydeletehatchdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskDelHatchDialog")); + if (xQueryBox->run() != RET_YES) + return; + + m_pHatchingList->Remove(nPos); + m_xHatchLB->RemoveItem( nId ); + nId = m_xHatchLB->GetItemId(0); + m_xHatchLB->SelectItem( nId ); + m_xHatchLB->Resize(); + + m_aCtlPreview.Invalidate(); + + ChangeHatchHdl_Impl(); + + *m_pnHatchingListState |= ChangeType::MODIFIED; +} + +IMPL_LINK_NOARG(SvxHatchTabPage, ClickRenameHdl_Impl, SvxPresetListBox*, void ) +{ + sal_uInt16 nId = m_xHatchLB->GetSelectedItemId(); + size_t nPos = m_xHatchLB->GetSelectItemPos(); + + if( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aDesc( CuiResId( RID_CUISTR_DESC_HATCH ) ); + OUString aName( m_pHatchingList->GetHatch( nPos )->GetName() ); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + + bool bLoop = true; + while( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + sal_Int32 nHatchPos = SearchHatchList( aName ); + bool bValidHatchName = (nHatchPos == static_cast<sal_Int32>(nPos) ) || (nHatchPos == -1); + + if(bValidHatchName) + { + bLoop = false; + m_pHatchingList->GetHatch(nPos)->SetName(aName); + + m_xHatchLB->SetItemText(nId, aName); + m_xHatchLB->SelectItem( nId ); + + *m_pnHatchingListState |= ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xBox->run(); + } + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tpline.cxx b/cui/source/tabpages/tpline.cxx new file mode 100644 index 000000000..04eaa41b9 --- /dev/null +++ b/cui/source/tabpages/tpline.cxx @@ -0,0 +1,1695 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <editeng/sizeitem.hxx> +#include <osl/file.hxx> +#include <tools/urlobj.hxx> + +#include <strings.hrc> +#include <svx/colorbox.hxx> +#include <svx/dlgctrl.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlinjoit.hxx> +#include <svx/xlncapit.hxx> +#include <svx/xlndsit.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlnstwit.hxx> +#include <svx/xlnedwit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnedit.hxx> +#include <svx/xlnstcit.hxx> +#include <svx/xlnedcit.hxx> + + +#include <svx/tabline.hxx> +#include <svx/xtable.hxx> +#include <svx/drawitem.hxx> +#include <cuitabline.hxx> +#include <dialmgr.hxx> +#include <svx/dlgutil.hxx> +#include <svx/svxgraphicitem.hxx> +#include <svx/ofaitem.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdview.hxx> +#include <svx/svdmodel.hxx> +#include <svx/xlntrit.hxx> +#include <svx/xfltrit.hxx> +#include <editeng/numitem.hxx> +#include <editeng/brushitem.hxx> +#include <svx/gallery.hxx> +#include <sfx2/opengrf.hxx> +#include <svx/dialmgr.hxx> +#include <svx/svxids.hrc> +#include <svx/strings.hrc> +#include <cuitabarea.hxx> +#include <svtools/unitconv.hxx> +#include <comphelper/lok.hxx> + +#define MAX_BMP_WIDTH 16 +#define MAX_BMP_HEIGHT 16 + +using namespace com::sun::star; + +// static ---------------------------------------------------------------- + +const WhichRangesContainer SvxLineTabPage::pLineRanges(svl::Items< + XATTR_LINETRANSPARENCE, XATTR_LINETRANSPARENCE, + SID_ATTR_LINE_STYLE, SID_ATTR_LINE_ENDCENTER +>); + +SvxLineTabPage::SvxLineTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/linetabpage.ui", "LineTabPage", &rInAttrs) + , m_pSymbolList(nullptr) + , m_bNewSize(false) + , m_nSymbolType(SVX_SYMBOLTYPE_UNKNOWN) // unknown respectively unchanged + , m_bLastWidthModified(false) + , m_aSymbolLastSize(Size(0,0)) + , m_bSymbols(false) + , m_rOutAttrs(rInAttrs) + , m_bObjSelected(false) + , m_aXLineAttr(rInAttrs.GetPool()) + , m_rXLSet(m_aXLineAttr.GetItemSet()) + , m_pnLineEndListState(nullptr) + , m_pnDashListState(nullptr) + , m_pnColorListState(nullptr) + , m_nPageType(PageType::Area) + , m_nDlgType(0) + , m_pPosDashLb(nullptr) + , m_pPosLineEndLb(nullptr) + , m_xBoxColor(m_xBuilder->weld_widget("boxCOLOR")) + , m_xLbLineStyle(new SvxLineLB(m_xBuilder->weld_combo_box("LB_LINE_STYLE"))) + , m_xLbColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_COLOR"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xBoxWidth(m_xBuilder->weld_widget("boxWIDTH")) + , m_xMtrLineWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_LINE_WIDTH", FieldUnit::CM)) + , m_xBoxTransparency(m_xBuilder->weld_widget("boxTRANSPARENCY")) + , m_xMtrTransparent(m_xBuilder->weld_metric_spin_button("MTR_LINE_TRANSPARENT", FieldUnit::PERCENT)) + , m_xFlLineEnds(m_xBuilder->weld_widget("FL_LINE_ENDS")) + , m_xBoxArrowStyles(m_xBuilder->weld_widget("boxARROW_STYLES")) + , m_xLbStartStyle(new SvxLineEndLB(m_xBuilder->weld_combo_box("LB_START_STYLE"))) + , m_xBoxStart(m_xBuilder->weld_widget("boxSTART")) + , m_xMtrStartWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_START_WIDTH", FieldUnit::CM)) + , m_xTsbCenterStart(m_xBuilder->weld_check_button("TSB_CENTER_START")) + , m_xBoxEnd(m_xBuilder->weld_widget("boxEND")) + , m_xLbEndStyle(new SvxLineEndLB(m_xBuilder->weld_combo_box("LB_END_STYLE"))) + , m_xMtrEndWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_END_WIDTH", FieldUnit::CM)) + , m_xTsbCenterEnd(m_xBuilder->weld_check_button("TSB_CENTER_END")) + , m_xCbxSynchronize(m_xBuilder->weld_check_button("CBX_SYNCHRONIZE")) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview)) + , m_xFLEdgeStyle(m_xBuilder->weld_widget("FL_EDGE_STYLE")) + , m_xGridEdgeCaps(m_xBuilder->weld_widget("gridEDGE_CAPS")) + , m_xLBEdgeStyle(m_xBuilder->weld_combo_box("LB_EDGE_STYLE")) + , m_xLBCapStyle(m_xBuilder->weld_combo_box("LB_CAP_STYLE")) // LineCaps + , m_xFlSymbol(m_xBuilder->weld_widget("FL_SYMBOL_FORMAT")) //#58425# Symbols on a line (e.g. StarChart) + , m_xGridIconSize(m_xBuilder->weld_widget("gridICON_SIZE")) + , m_xSymbolMB(m_xBuilder->weld_menu_button("MB_SYMBOL_BITMAP")) + , m_xSymbolWidthMF(m_xBuilder->weld_metric_spin_button("MF_SYMBOL_WIDTH", FieldUnit::CM)) + , m_xSymbolHeightMF(m_xBuilder->weld_metric_spin_button("MF_SYMBOL_HEIGHT", FieldUnit::CM)) + , m_xSymbolRatioCB(m_xBuilder->weld_check_button("CB_SYMBOL_RATIO")) +{ + // This Page requires ExchangeSupport + SetExchangeSupport(); + + // Metric set + FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs ); + + switch ( eFUnit ) + { + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + [[fallthrough]]; // we now have mm + case FieldUnit::MM: + m_xMtrLineWidth->set_increments(50, 500, FieldUnit::NONE); + m_xMtrStartWidth->set_increments(50, 500, FieldUnit::NONE); + m_xMtrEndWidth->set_increments(50, 500, FieldUnit::NONE); + break; + + case FieldUnit::INCH: + m_xMtrLineWidth->set_increments(2, 20, FieldUnit::NONE); + m_xMtrStartWidth->set_increments(2, 20, FieldUnit::NONE); + m_xMtrEndWidth->set_increments(2, 20, FieldUnit::NONE); + break; + default: ;// prevent warning + } + SetFieldUnit( *m_xMtrLineWidth, eFUnit ); + SetFieldUnit( *m_xMtrStartWidth, eFUnit ); + SetFieldUnit( *m_xMtrEndWidth, eFUnit ); + + // determine PoolUnit + SfxItemPool* pPool = m_rOutAttrs.GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + m_ePoolUnit = pPool->GetMetric( SID_ATTR_LINE_WIDTH ); + + m_xLbLineStyle->connect_changed(LINK(this, SvxLineTabPage, ClickInvisibleHdl_Impl)); + m_xLbColor->SetSelectHdl( LINK( this, SvxLineTabPage, ChangePreviewListBoxHdl_Impl ) ); + m_xMtrLineWidth->connect_value_changed(LINK(this, SvxLineTabPage, ChangePreviewModifyHdl_Impl)); + m_xMtrTransparent->connect_value_changed(LINK( this, SvxLineTabPage, ChangeTransparentHdl_Impl)); + + m_xLbStartStyle->connect_changed(LINK(this, SvxLineTabPage, ChangeStartListBoxHdl_Impl)); + m_xLbEndStyle->connect_changed(LINK(this, SvxLineTabPage, ChangeEndListBoxHdl_Impl)); + m_xMtrStartWidth->connect_value_changed(LINK(this, SvxLineTabPage, ChangeStartModifyHdl_Impl)); + m_xMtrEndWidth->connect_value_changed(LINK( this, SvxLineTabPage, ChangeEndModifyHdl_Impl)); + m_xTsbCenterStart->connect_toggled(LINK(this, SvxLineTabPage, ChangeStartClickHdl_Impl)); + m_xTsbCenterEnd->connect_toggled(LINK(this, SvxLineTabPage, ChangeEndClickHdl_Impl)); + + Link<weld::ComboBox&,void> aEdgeStyle = LINK(this, SvxLineTabPage, ChangeEdgeStyleHdl_Impl); + m_xLBEdgeStyle->connect_changed(aEdgeStyle); + + // LineCaps + Link<weld::ComboBox&,void> aCapStyle = LINK(this, SvxLineTabPage, ChangeCapStyleHdl_Impl); + m_xLBCapStyle->connect_changed(aCapStyle); + + // Symbols on a line (eg star charts), MB-handler set + m_xSymbolMB->connect_selected(LINK(this, SvxLineTabPage, GraphicHdl_Impl)); + m_xSymbolMB->connect_toggled(LINK(this, SvxLineTabPage, MenuCreateHdl_Impl)); + m_xSymbolWidthMF->connect_value_changed(LINK(this, SvxLineTabPage, SizeHdl_Impl)); + m_xSymbolHeightMF->connect_value_changed(LINK(this, SvxLineTabPage, SizeHdl_Impl)); + m_xSymbolRatioCB->connect_toggled(LINK(this, SvxLineTabPage, RatioHdl_Impl)); + + m_xSymbolRatioCB->set_active(true); + ShowSymbolControls(false); + + m_nActLineWidth = -1; +} + +void SvxLineTabPage::ShowSymbolControls(bool bOn) +{ + // Symbols on a line (e.g. StarCharts), symbol-enable controls + + m_bSymbols=bOn; + m_xFlSymbol->set_visible(bOn); + m_aCtlPreview.ShowSymbol(bOn); +} + +SvxLineTabPage::~SvxLineTabPage() +{ + m_xCtlPreview.reset(); + m_xLbEndStyle.reset(); + m_xLbStartStyle.reset(); + m_xLbColor.reset(); + m_xLbLineStyle.reset(); + m_aGalleryBrushItems.clear(); + m_aSymbolBrushItems.clear(); +} + +void SvxLineTabPage::Construct() +{ + FillListboxes(); +} + +void SvxLineTabPage::FillListboxes() +{ + // Line styles + auto nOldSelect = m_xLbLineStyle->get_active(); + // aLbLineStyle.FillStyles(); + m_xLbLineStyle->Fill( m_pDashList ); + m_xLbLineStyle->set_active( nOldSelect ); + + // Line end style + OUString sNone( comphelper::LibreOfficeKit::isActive() ? SvxResId( RID_SVXSTR_INVISIBLE ) + : SvxResId( RID_SVXSTR_NONE ) ); + nOldSelect = m_xLbStartStyle->get_active(); + m_xLbStartStyle->clear(); + m_xLbStartStyle->append_text(sNone); + m_xLbStartStyle->Fill(m_pLineEndList); + m_xLbStartStyle->set_active(nOldSelect); + nOldSelect = m_xLbEndStyle->get_active(); + m_xLbEndStyle->clear(); + m_xLbEndStyle->append_text(sNone); + m_xLbEndStyle->Fill(m_pLineEndList, false); + m_xLbEndStyle->set_active(nOldSelect); +} + +void SvxLineTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + const CntUInt16Item* pPageTypeItem = rSet.GetItem<CntUInt16Item>(SID_PAGE_TYPE, false); + if (pPageTypeItem) + SetPageType(static_cast<PageType>(pPageTypeItem->GetValue())); + if( m_nDlgType == 0 && m_pDashList.is() ) + { + sal_Int32 nPos; + sal_Int32 nCount; + + // Dash list + if( ( *m_pnDashListState & ChangeType::MODIFIED ) || + ( *m_pnDashListState & ChangeType::CHANGED ) ) + { + if( *m_pnDashListState & ChangeType::CHANGED ) + m_pDashList = static_cast<SvxLineTabDialog*>(GetDialogController() )->GetNewDashList(); + + *m_pnDashListState = ChangeType::NONE; + + // Style list + nPos = m_xLbLineStyle->get_active(); + + m_xLbLineStyle->clear(); + m_xLbLineStyle->append_text(SvxResId(RID_SVXSTR_INVISIBLE)); + m_xLbLineStyle->append_text(SvxResId(RID_SVXSTR_SOLID)); + m_xLbLineStyle->Fill(m_pDashList); + nCount = m_xLbLineStyle->get_count(); + + if ( nCount == 0 ) + ; // This case should never occur + else if( nCount <= nPos ) + m_xLbLineStyle->set_active(0); + else + m_xLbLineStyle->set_active(nPos); + } + + INetURLObject aDashURL( m_pDashList->GetPath() ); + + aDashURL.Append( m_pDashList->GetName() ); + DBG_ASSERT( aDashURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + // LineEnd list + if( ( *m_pnLineEndListState & ChangeType::MODIFIED ) || ( *m_pnLineEndListState & ChangeType::CHANGED ) ) + { + if( *m_pnLineEndListState & ChangeType::CHANGED ) + m_pLineEndList = static_cast<SvxLineTabDialog*>(GetDialogController())->GetNewLineEndList(); + + *m_pnLineEndListState = ChangeType::NONE; + + nPos = m_xLbLineStyle->get_active(); + OUString sNone( comphelper::LibreOfficeKit::isActive() ? SvxResId( RID_SVXSTR_INVISIBLE ) + : SvxResId( RID_SVXSTR_NONE ) ); + + m_xLbStartStyle->clear(); + m_xLbStartStyle->append_text(sNone); + + m_xLbStartStyle->Fill( m_pLineEndList ); + nCount = m_xLbStartStyle->get_count(); + if( nCount == 0 ) + ; // This case should never occur + else if( nCount <= nPos ) + m_xLbStartStyle->set_active(0); + else + m_xLbStartStyle->set_active(nPos); + + m_xLbEndStyle->clear(); + m_xLbEndStyle->append_text(sNone); + + m_xLbEndStyle->Fill( m_pLineEndList, false ); + nCount = m_xLbEndStyle->get_count(); + + if( nCount == 0 ) + ; // This case should never occur + else if( nCount <= nPos ) + m_xLbEndStyle->set_active(0); + else + m_xLbEndStyle->set_active(nPos); + } + INetURLObject aLineURL( m_pLineEndList->GetPath() ); + + aLineURL.Append( m_pLineEndList->GetName() ); + DBG_ASSERT( aLineURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + // Evaluate if another TabPage set another fill type + if( m_xLbLineStyle->get_active() != 0 ) + { + if( m_nPageType == PageType::Hatch ) // 1 + { + m_xLbLineStyle->set_active(*m_pPosDashLb + 2); // +2 due to SOLID and INVISIBLE + ChangePreviewHdl_Impl( nullptr ); + } + if( m_nPageType == PageType::Bitmap ) + { + m_xLbStartStyle->set_active(*m_pPosLineEndLb + 1);// +1 due to SOLID + m_xLbEndStyle->set_active(*m_pPosLineEndLb + 1);// +1 due to SOLID + ChangePreviewHdl_Impl( nullptr ); + } + } + + // ColorList + if( *m_pnColorListState != ChangeType::NONE ) + { + ChangePreviewHdl_Impl( nullptr ); + } + + m_nPageType = PageType::Area; + } + // Page does not yet exist in the ctor, that's why we do it here! + + else if (m_nDlgType == 1101) // nNoArrowNoShadowDlg from chart2/source/controller/dialogs/dlg_ObjectProperties.cxx + { + m_xFlLineEnds->hide(); + m_xFLEdgeStyle->hide(); + } +} + + +DeactivateRC SvxLineTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( m_nDlgType == 0 ) // Line dialog + { + m_nPageType = PageType::Gradient; // possibly for extensions + *m_pPosDashLb = m_xLbLineStyle->get_active() - 2;// First entry SOLID!!! + sal_Int32 nPos = m_xLbStartStyle->get_active(); + if (nPos != -1) + nPos--; + *m_pPosLineEndLb = nPos; + } + + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + + +bool SvxLineTabPage::FillItemSet( SfxItemSet* rAttrs ) +{ + const SfxPoolItem* pOld = nullptr; + sal_Int32 nPos; + bool bModified = false; + + // To prevent modifications to the list, we do not set other page's items. + if( m_nDlgType != 0 || m_nPageType != PageType::Hatch ) + { + nPos = m_xLbLineStyle->get_active(); + if( nPos != -1 && + m_xLbLineStyle->get_value_changed_from_saved() ) + { + std::unique_ptr<XLineStyleItem> pStyleItem; + + if( nPos == 0 ) + pStyleItem.reset(new XLineStyleItem( drawing::LineStyle_NONE )); + else if( nPos == 1 ) + pStyleItem.reset(new XLineStyleItem( drawing::LineStyle_SOLID )); + else + { + pStyleItem.reset(new XLineStyleItem( drawing::LineStyle_DASH )); + + // For added security + if( m_pDashList->Count() > static_cast<tools::Long>( nPos - 2 ) ) + { + XLineDashItem aDashItem( m_xLbLineStyle->get_active_text(), + m_pDashList->GetDash( nPos - 2 )->GetDash() ); + pOld = GetOldItem( *rAttrs, XATTR_LINEDASH ); + if ( !pOld || !( *static_cast<const XLineDashItem*>(pOld) == aDashItem ) ) + { + rAttrs->Put( aDashItem ); + bModified = true; + } + } + } + pOld = GetOldItem( *rAttrs, XATTR_LINESTYLE ); + if ( !pOld || !( *static_cast<const XLineStyleItem*>(pOld) == *pStyleItem ) ) + { + rAttrs->Put( std::move(pStyleItem) ); + bModified = true; + } + } + } + // Line width + // GetSavedValue() returns OUString! + if( m_xMtrLineWidth->get_value_changed_from_saved() ) + { + XLineWidthItem aItem( GetCoreValue( *m_xMtrLineWidth, m_ePoolUnit ) ); + pOld = GetOldItem( *rAttrs, XATTR_LINEWIDTH ); + if ( !pOld || !( *static_cast<const XLineWidthItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + // Width line start + if( m_xMtrStartWidth->get_value_changed_from_saved() ) + { + XLineStartWidthItem aItem( GetCoreValue( *m_xMtrStartWidth, m_ePoolUnit ) ); + pOld = GetOldItem( *rAttrs, XATTR_LINESTARTWIDTH ); + if ( !pOld || !( *static_cast<const XLineStartWidthItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + // Width line end + if( m_xMtrEndWidth->get_value_changed_from_saved() ) + { + XLineEndWidthItem aItem( GetCoreValue( *m_xMtrEndWidth, m_ePoolUnit ) ); + pOld = GetOldItem( *rAttrs, XATTR_LINEENDWIDTH ); + if ( !pOld || !( *static_cast<const XLineEndWidthItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + // Line color + if (m_xLbColor->IsValueChangedFromSaved()) + { + NamedColor aColor = m_xLbColor->GetSelectedEntry(); + XLineColorItem aItem(aColor.second, aColor.first); + pOld = GetOldItem( *rAttrs, XATTR_LINECOLOR ); + if ( !pOld || !( *static_cast<const XLineColorItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + if( m_nDlgType != 0 || m_nPageType != PageType::Bitmap ) + { + // Line start + nPos = m_xLbStartStyle->get_active(); + if( nPos != -1 && m_xLbStartStyle->get_value_changed_from_saved() ) + { + std::unique_ptr<XLineStartItem> pItem; + if( nPos == 0 ) + pItem.reset(new XLineStartItem()); + else if( m_pLineEndList->Count() > static_cast<tools::Long>( nPos - 1 ) ) + pItem.reset(new XLineStartItem( m_xLbStartStyle->get_active_text(), m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() )); + pOld = GetOldItem( *rAttrs, XATTR_LINESTART ); + if( pItem && ( !pOld || *pOld != *pItem ) ) + { + rAttrs->Put( std::move(pItem) ); + bModified = true; + } + } + // Line end + nPos = m_xLbEndStyle->get_active(); + if( nPos != -1 && m_xLbEndStyle->get_value_changed_from_saved() ) + { + std::unique_ptr<XLineEndItem> pItem; + if( nPos == 0 ) + pItem.reset(new XLineEndItem()); + else if( m_pLineEndList->Count() > static_cast<tools::Long>( nPos - 1 ) ) + pItem.reset(new XLineEndItem( m_xLbEndStyle->get_active_text(), m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() )); + pOld = GetOldItem( *rAttrs, XATTR_LINEEND ); + if( pItem && + ( !pOld || !( *static_cast<const XLineEndItem*>(pOld) == *pItem ) ) ) + { + rAttrs->Put( std::move(pItem) ); + bModified = true; + } + } + } + + // Centered line end + TriState eState = m_xTsbCenterStart->get_state(); + if( m_xTsbCenterStart->get_state_changed_from_saved() ) + { + XLineStartCenterItem aItem( eState != TRISTATE_FALSE ); + pOld = GetOldItem( *rAttrs, XATTR_LINESTARTCENTER ); + if ( !pOld || !( *static_cast<const XLineStartCenterItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + eState = m_xTsbCenterEnd->get_state(); + if( m_xTsbCenterEnd->get_state_changed_from_saved() ) + { + XLineEndCenterItem aItem( eState != TRISTATE_FALSE ); + pOld = GetOldItem( *rAttrs, XATTR_LINEENDCENTER ); + if ( !pOld || !( *static_cast<const XLineEndCenterItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + // Transparency + sal_uInt16 nVal = m_xMtrTransparent->get_value(FieldUnit::PERCENT); + if( m_xMtrTransparent->get_value_changed_from_saved() ) + { + XLineTransparenceItem aItem( nVal ); + pOld = GetOldItem( *rAttrs, XATTR_LINETRANSPARENCE ); + if ( !pOld || !( *static_cast<const XLineTransparenceItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + nPos = m_xLBEdgeStyle->get_active(); + if (nPos != -1 && m_xLBEdgeStyle->get_value_changed_from_saved()) + { + std::unique_ptr<XLineJointItem> pNew; + + switch(nPos) + { + case 0: // Rounded, default + { + pNew.reset(new XLineJointItem(css::drawing::LineJoint_ROUND)); + break; + } + case 1: // - none - + { + pNew.reset(new XLineJointItem(css::drawing::LineJoint_NONE)); + break; + } + case 2: // Miter + { + pNew.reset(new XLineJointItem(css::drawing::LineJoint_MITER)); + break; + } + case 3: // Bevel + { + pNew.reset(new XLineJointItem(css::drawing::LineJoint_BEVEL)); + break; + } + } + + if(pNew) + { + pOld = GetOldItem( *rAttrs, XATTR_LINEJOINT ); + + if(!pOld || !(*static_cast<const XLineJointItem*>(pOld) == *pNew)) + { + rAttrs->Put( std::move(pNew) ); + bModified = true; + } + } + } + + // LineCaps + nPos = m_xLBCapStyle->get_active(); + if (nPos != -1 && m_xLBCapStyle->get_value_changed_from_saved()) + { + std::unique_ptr<XLineCapItem> pNew; + + switch(nPos) + { + case 0: // Butt (=Flat), default + { + pNew.reset(new XLineCapItem(css::drawing::LineCap_BUTT)); + break; + } + case 1: // Round + { + pNew.reset(new XLineCapItem(css::drawing::LineCap_ROUND)); + break; + } + case 2: // Square + { + pNew.reset(new XLineCapItem(css::drawing::LineCap_SQUARE)); + break; + } + } + + if(pNew) + { + pOld = GetOldItem( *rAttrs, XATTR_LINECAP ); + + if(!pOld || !(*static_cast<const XLineCapItem*>(pOld) == *pNew)) + { + rAttrs->Put( std::move(pNew) ); + bModified = true; + } + } + } + + if(m_nSymbolType!=SVX_SYMBOLTYPE_UNKNOWN || m_bNewSize) + { + // Was set by selection or the size is different + SvxSizeItem aSItem(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE),m_aSymbolSize); + const SfxPoolItem* pSOld = GetOldItem( *rAttrs, rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE) ); + m_bNewSize = pSOld ? *static_cast<const SvxSizeItem *>(pSOld) != aSItem : m_bNewSize ; + if(m_bNewSize) + { + rAttrs->Put(aSItem); + bModified=true; + } + + SfxInt32Item aTItem(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE),m_nSymbolType); + const SfxPoolItem* pTOld = GetOldItem( *rAttrs, rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE) ); + bool bNewType = pTOld == nullptr || *static_cast<const SfxInt32Item*>(pTOld) != aTItem; + if(bNewType && m_nSymbolType==SVX_SYMBOLTYPE_UNKNOWN) + bNewType=false; // a small fix, type wasn't set -> don't create a type item after all! + if(bNewType) + { + rAttrs->Put(aTItem); + bModified=true; + } + + if(m_nSymbolType!=SVX_SYMBOLTYPE_NONE) + { + SvxBrushItem aBItem(m_aSymbolGraphic,GPOS_MM,rAttrs->GetPool()->GetWhich(SID_ATTR_BRUSH)); + const SfxPoolItem* pBOld = GetOldItem( *rAttrs, rAttrs->GetPool()->GetWhich(SID_ATTR_BRUSH) ); + bool bNewBrush = + pBOld == nullptr || *static_cast<const SvxBrushItem*>(pBOld) != aBItem; + if(bNewBrush) + { + rAttrs->Put(aBItem); + bModified=true; + } + } + } + rAttrs->Put (CntUInt16Item(SID_PAGE_TYPE, static_cast<sal_uInt16>(m_nPageType))); + return bModified; +} + + +void SvxLineTabPage::FillXLSet_Impl() +{ + sal_Int32 nPos; + + if (m_xLbLineStyle->get_active() == -1) + { + m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + } + else if (m_xLbLineStyle->get_active() == 0) + m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + else if (m_xLbLineStyle->get_active() == 1) + m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_SOLID ) ); + else + { + m_rXLSet.Put( XLineStyleItem( drawing::LineStyle_DASH ) ); + + nPos = m_xLbLineStyle->get_active(); + if (nPos != -1) + { + m_rXLSet.Put( XLineDashItem( m_xLbLineStyle->get_active_text(), + m_pDashList->GetDash( nPos - 2 )->GetDash() ) ); + } + } + + nPos = m_xLbStartStyle->get_active(); + if (nPos != -1) + { + if( nPos == 0 ) + m_rXLSet.Put( XLineStartItem() ); + else + m_rXLSet.Put( XLineStartItem( m_xLbStartStyle->get_active_text(), + m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ) ); + } + nPos = m_xLbEndStyle->get_active(); + if (nPos != -1) + { + if( nPos == 0 ) + m_rXLSet.Put( XLineEndItem() ); + else + m_rXLSet.Put( XLineEndItem( m_xLbEndStyle->get_active_text(), + m_pLineEndList->GetLineEnd( nPos - 1 )->GetLineEnd() ) ); + } + + nPos = m_xLBEdgeStyle->get_active(); + if (nPos != -1) + { + switch(nPos) + { + case 0: // Rounded, default + { + m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_ROUND)); + break; + } + case 1: // - none - + { + m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_NONE)); + break; + } + case 2: // Miter + { + m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_MITER)); + break; + } + case 3: // Bevel + { + m_rXLSet.Put(XLineJointItem(css::drawing::LineJoint_BEVEL)); + break; + } + } + } + + // LineCaps + nPos = m_xLBCapStyle->get_active(); + if (nPos != -1) + { + switch(nPos) + { + case 0: // Butt (=Flat), default + { + m_rXLSet.Put(XLineCapItem(css::drawing::LineCap_BUTT)); + break; + } + case 1: // Round + { + m_rXLSet.Put(XLineCapItem(css::drawing::LineCap_ROUND)); + break; + } + case 2: // Square + { + m_rXLSet.Put(XLineCapItem(css::drawing::LineCap_SQUARE)); + break; + } + } + } + + m_rXLSet.Put( XLineStartWidthItem( GetCoreValue( *m_xMtrStartWidth, m_ePoolUnit ) ) ); + m_rXLSet.Put( XLineEndWidthItem( GetCoreValue( *m_xMtrEndWidth, m_ePoolUnit ) ) ); + + m_rXLSet.Put( XLineWidthItem( GetCoreValue( *m_xMtrLineWidth, m_ePoolUnit ) ) ); + NamedColor aColor = m_xLbColor->GetSelectedEntry(); + m_rXLSet.Put(XLineColorItem(aColor.second, aColor.first)); + + // Centered line end + if( m_xTsbCenterStart->get_state() == TRISTATE_TRUE ) + m_rXLSet.Put( XLineStartCenterItem( true ) ); + else if( m_xTsbCenterStart->get_state() == TRISTATE_FALSE ) + m_rXLSet.Put( XLineStartCenterItem( false ) ); + + if( m_xTsbCenterEnd->get_state() == TRISTATE_TRUE ) + m_rXLSet.Put( XLineEndCenterItem( true ) ); + else if( m_xTsbCenterEnd->get_state() == TRISTATE_FALSE ) + m_rXLSet.Put( XLineEndCenterItem( false ) ); + + // Transparency + sal_uInt16 nVal = m_xMtrTransparent->get_value(FieldUnit::PERCENT); + m_rXLSet.Put( XLineTransparenceItem( nVal ) ); + + m_aCtlPreview.SetLineAttributes(m_aXLineAttr.GetItemSet()); +} + + +void SvxLineTabPage::Reset( const SfxItemSet* rAttrs ) +{ + drawing::LineStyle eXLS; // drawing::LineStyle_NONE, drawing::LineStyle_SOLID, drawing::LineStyle_DASH + + // Line style + tools::Long nSymType=SVX_SYMBOLTYPE_UNKNOWN; + bool bPrevSym=false; + bool bEnable=true; + bool bIgnoreGraphic=false; + bool bIgnoreSize=false; + if(const SfxInt32Item* pSymbolTypeItem = rAttrs->GetItemIfSet(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLTYPE))) + { + nSymType = pSymbolTypeItem->GetValue(); + } + + if(nSymType == SVX_SYMBOLTYPE_AUTO) + { + m_aSymbolGraphic=m_aAutoSymbolGraphic; + m_aSymbolSize=m_aSymbolLastSize=m_aAutoSymbolGraphic.GetPrefSize(); + bPrevSym=true; + } + else if(nSymType == SVX_SYMBOLTYPE_NONE) + { + bEnable=false; + bIgnoreGraphic=true; + bIgnoreSize=true; + } + else if(nSymType >= 0) + { + ScopedVclPtrInstance< VirtualDevice > pVDev; + pVDev->SetMapMode(MapMode(MapUnit::Map100thMM)); + + std::unique_ptr<SdrModel> pModel( + new SdrModel(nullptr, nullptr, true)); + pModel->GetItemPool().FreezeIdRanges(); + rtl::Reference<SdrPage> pPage = new SdrPage( *pModel, false ); + pPage->SetSize(Size(1000,1000)); + pModel->InsertPage( pPage.get(), 0 ); + { + SdrView aView( *pModel, pVDev ); + aView.hideMarkHandles(); + aView.ShowSdrPage(pPage.get()); + size_t nSymTmp = static_cast<size_t>(nSymType); + if(m_pSymbolList) + { + if(m_pSymbolList->GetObjCount()) + { + nSymTmp %= m_pSymbolList->GetObjCount(); // Treat list as cyclic! + SdrObject *pObj=m_pSymbolList->GetObj(nSymTmp); + if(pObj) + { + // directly clone to target SdrModel + pObj = pObj->CloneSdrObject(*pModel); + + if(m_xSymbolAttr) + { + pObj->SetMergedItemSet(*m_xSymbolAttr); + } + else + { + pObj->SetMergedItemSet(m_rOutAttrs); + } + + pPage->NbcInsertObject(pObj); + + // Generate invisible square to give all symbol types a + // bitmap size, which is independent from specific glyph + SdrObject* pInvisibleSquare(m_pSymbolList->GetObj(0)); + + // directly clone to target SdrModel + pInvisibleSquare = pInvisibleSquare->CloneSdrObject(*pModel); + + pPage->NbcInsertObject(pInvisibleSquare); + pInvisibleSquare->SetMergedItem(XFillTransparenceItem(100)); + pInvisibleSquare->SetMergedItem(XLineTransparenceItem(100)); + + aView.MarkAll(); + GDIMetaFile aMeta(aView.GetMarkedObjMetaFile()); + + m_aSymbolGraphic=Graphic(aMeta); + m_aSymbolSize=pObj->GetSnapRect().GetSize(); + m_aSymbolGraphic.SetPrefSize(pInvisibleSquare->GetSnapRect().GetSize()); + m_aSymbolGraphic.SetPrefMapMode(MapMode(MapUnit::Map100thMM)); + bPrevSym=true; + bEnable=true; + bIgnoreGraphic=true; + + aView.UnmarkAll(); + pInvisibleSquare=pPage->RemoveObject(1); + SdrObject::Free( pInvisibleSquare); + pObj=pPage->RemoveObject(0); + SdrObject::Free( pObj ); + } + } + } + } + } + if(const SvxBrushItem* pBrushItem = rAttrs->GetItemIfSet(rAttrs->GetPool()->GetWhich(SID_ATTR_BRUSH))) + { + const Graphic* pGraphic = pBrushItem->GetGraphic(); + if( pGraphic ) + { + if(!bIgnoreGraphic) + { + m_aSymbolGraphic=*pGraphic; + } + if(!bIgnoreSize) + { + m_aSymbolSize=OutputDevice::LogicToLogic( pGraphic->GetPrefSize(), + pGraphic->GetPrefMapMode(), + MapMode(MapUnit::Map100thMM)); + } + bPrevSym=true; + } + } + + if(const SvxSizeItem* pSymbolSizeItem = rAttrs->GetItemIfSet(rAttrs->GetPool()->GetWhich(SID_ATTR_SYMBOLSIZE))) + { + m_aSymbolSize = pSymbolSizeItem->GetSize(); + } + + m_xGridIconSize->set_sensitive(bEnable); + + if(bPrevSym) + { + SetMetricValue(*m_xSymbolWidthMF, m_aSymbolSize.Width(), m_ePoolUnit); + SetMetricValue(*m_xSymbolHeightMF, m_aSymbolSize.Height(),m_ePoolUnit); + m_aCtlPreview.SetSymbol(&m_aSymbolGraphic,m_aSymbolSize); + m_aSymbolLastSize=m_aSymbolSize; + } + + if( rAttrs->GetItemState( XATTR_LINESTYLE ) != SfxItemState::DONTCARE ) + { + eXLS = rAttrs->Get( XATTR_LINESTYLE ).GetValue(); + + switch( eXLS ) + { + case drawing::LineStyle_NONE: + m_xLbLineStyle->set_active(0); + break; + case drawing::LineStyle_SOLID: + m_xLbLineStyle->set_active(1); + break; + + case drawing::LineStyle_DASH: + m_xLbLineStyle->set_active(-1); + m_xLbLineStyle->set_active_text(rAttrs->Get( XATTR_LINEDASH ).GetName()); + break; + + default: + break; + } + } + else + { + m_xLbLineStyle->set_active(-1); + } + + // Line strength + if( rAttrs->GetItemState( XATTR_LINEWIDTH ) != SfxItemState::DONTCARE ) + { + SetMetricValue( *m_xMtrLineWidth, rAttrs->Get( XATTR_LINEWIDTH ).GetValue(), m_ePoolUnit ); + } + else + m_xMtrLineWidth->set_text(""); + + // Line color + m_xLbColor->SetNoSelection(); + + if ( rAttrs->GetItemState( XATTR_LINECOLOR ) != SfxItemState::DONTCARE ) + { + Color aCol = rAttrs->Get( XATTR_LINECOLOR ).GetColorValue(); + m_xLbColor->SelectEntry( aCol ); + } + + // Line start + if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINESTART ) == SfxItemState::DEFAULT ) + { + m_xLbStartStyle->set_sensitive(false); + } + else if( rAttrs->GetItemState( XATTR_LINESTART ) != SfxItemState::DONTCARE ) + { + // #86265# select entry using list and polygon, not string + bool bSelected(false); + const basegfx::B2DPolyPolygon& rItemPolygon = rAttrs->Get(XATTR_LINESTART).GetLineStartValue(); + + for(tools::Long a(0);!bSelected && a < m_pLineEndList->Count(); a++) + { + const XLineEndEntry* pEntry = m_pLineEndList->GetLineEnd(a); + const basegfx::B2DPolyPolygon& rEntryPolygon = pEntry->GetLineEnd(); + + if(rItemPolygon == rEntryPolygon) + { + // select this entry + m_xLbStartStyle->set_active(a + 1); + bSelected = true; + } + } + + if(!bSelected) + m_xLbStartStyle->set_active(0); + } + else + { + m_xLbStartStyle->set_active(-1); + } + + // Line end + if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINEEND ) == SfxItemState::DEFAULT ) + { + m_xLbEndStyle->set_sensitive(false); + } + else if( rAttrs->GetItemState( XATTR_LINEEND ) != SfxItemState::DONTCARE ) + { + // #86265# select entry using list and polygon, not string + bool bSelected(false); + const basegfx::B2DPolyPolygon& rItemPolygon = rAttrs->Get(XATTR_LINEEND).GetLineEndValue(); + + for(tools::Long a(0);!bSelected && a < m_pLineEndList->Count(); a++) + { + const XLineEndEntry* pEntry = m_pLineEndList->GetLineEnd(a); + const basegfx::B2DPolyPolygon& rEntryPolygon = pEntry->GetLineEnd(); + + if(rItemPolygon == rEntryPolygon) + { + // select this entry + m_xLbEndStyle->set_active(a + 1); + bSelected = true; + } + } + + if(!bSelected) + m_xLbEndStyle->set_active(0); + } + else + { + m_xLbEndStyle->set_active(-1); + } + + // Line start strength + if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINESTARTWIDTH ) == SfxItemState::DEFAULT ) + { + m_xMtrStartWidth->set_sensitive(false); + } + else if( rAttrs->GetItemState( XATTR_LINESTARTWIDTH ) != SfxItemState::DONTCARE ) + { + SetMetricValue( *m_xMtrStartWidth, + rAttrs->Get( XATTR_LINESTARTWIDTH ).GetValue(), + m_ePoolUnit ); + } + else + m_xMtrStartWidth->set_text( "" ); + + // Line end strength + if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINEENDWIDTH ) == SfxItemState::DEFAULT ) + { + m_xMtrEndWidth->set_sensitive(false); + } + else if( rAttrs->GetItemState( XATTR_LINEENDWIDTH ) != SfxItemState::DONTCARE ) + { + SetMetricValue( *m_xMtrEndWidth, + rAttrs->Get( XATTR_LINEENDWIDTH ).GetValue(), + m_ePoolUnit ); + } + else + m_xMtrEndWidth->set_text(""); + + // Centered line end (start) + if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINESTARTCENTER ) == SfxItemState::DEFAULT ) + { + m_xTsbCenterStart->set_sensitive(false); + } + else if( rAttrs->GetItemState( XATTR_LINESTARTCENTER ) != SfxItemState::DONTCARE ) + { + if( rAttrs->Get( XATTR_LINESTARTCENTER ).GetValue() ) + m_xTsbCenterStart->set_state(TRISTATE_TRUE); + else + m_xTsbCenterStart->set_state(TRISTATE_FALSE); + } + else + { + m_xTsbCenterStart->set_state(TRISTATE_INDET); + } + + // Centered line end (end) + if( m_bObjSelected && rAttrs->GetItemState( XATTR_LINEENDCENTER ) == SfxItemState::DEFAULT ) + { + m_xTsbCenterEnd->set_sensitive(false); + } + else if( rAttrs->GetItemState( XATTR_LINEENDCENTER ) != SfxItemState::DONTCARE ) + { + if( rAttrs->Get( XATTR_LINEENDCENTER ).GetValue() ) + m_xTsbCenterEnd->set_state(TRISTATE_TRUE); + else + m_xTsbCenterEnd->set_state(TRISTATE_FALSE); + } + else + { + m_xTsbCenterEnd->set_state(TRISTATE_INDET); + } + + // Transparency + if( rAttrs->GetItemState( XATTR_LINETRANSPARENCE ) != SfxItemState::DONTCARE ) + { + sal_uInt16 nTransp = rAttrs->Get( XATTR_LINETRANSPARENCE ).GetValue(); + m_xMtrTransparent->set_value(nTransp, FieldUnit::PERCENT); + ChangeTransparentHdl_Impl(*m_xMtrTransparent); + } + else + m_xMtrTransparent->set_text( "" ); + + if( !m_xLbStartStyle->get_sensitive() && + !m_xLbEndStyle->get_sensitive() && + !m_xMtrStartWidth->get_sensitive() && + !m_xMtrEndWidth->get_sensitive() && + !m_xTsbCenterStart->get_sensitive()&& + !m_xTsbCenterEnd->get_sensitive() ) + { + m_xCbxSynchronize->set_sensitive(false); + m_xFlLineEnds->set_sensitive(false); + } + + // Synchronize + // We get the value from the INI file now + OUString aStr = GetUserData(); + m_xCbxSynchronize->set_active(aStr.toInt32() != 0); + + if(m_bObjSelected && SfxItemState::DEFAULT == rAttrs->GetItemState(XATTR_LINEJOINT)) + { +// maFTEdgeStyle.set_sensitive(false); + m_xLBEdgeStyle->set_sensitive(false); + } + else if(SfxItemState::DONTCARE != rAttrs->GetItemState(XATTR_LINEJOINT)) + { + const css::drawing::LineJoint eLineJoint = rAttrs->Get(XATTR_LINEJOINT).GetValue(); + + switch(eLineJoint) + { + case css::drawing::LineJoint::LineJoint_MAKE_FIXED_SIZE: // fallback to round, unused value + case css::drawing::LineJoint_ROUND : m_xLBEdgeStyle->set_active(0); break; + case css::drawing::LineJoint_NONE : m_xLBEdgeStyle->set_active(1); break; + case css::drawing::LineJoint_MIDDLE : // fallback to mitre, unused value + case css::drawing::LineJoint_MITER : m_xLBEdgeStyle->set_active(2); break; + case css::drawing::LineJoint_BEVEL : m_xLBEdgeStyle->set_active(3); break; + } + } + else + { + m_xLBEdgeStyle->set_active(-1); + } + + // fdo#43209 + if(m_bObjSelected && SfxItemState::DEFAULT == rAttrs->GetItemState(XATTR_LINECAP)) + { + m_xLBCapStyle->set_sensitive(false); + } + else if(SfxItemState::DONTCARE != rAttrs->GetItemState(XATTR_LINECAP)) + { + const css::drawing::LineCap eLineCap(rAttrs->Get(XATTR_LINECAP).GetValue()); + + switch(eLineCap) + { + case css::drawing::LineCap_ROUND: m_xLBCapStyle->set_active(1); break; + case css::drawing::LineCap_SQUARE : m_xLBCapStyle->set_active(2); break; + default /*css::drawing::LineCap_BUTT*/: m_xLBCapStyle->set_active(0); break; + } + } + else + { + m_xLBCapStyle->set_active(-1); + } + + // Save values + m_xLbLineStyle->save_value(); + m_xMtrLineWidth->save_value(); + m_xLbColor->SaveValue(); + m_xLbStartStyle->save_value(); + m_xLbEndStyle->save_value(); + m_xMtrStartWidth->save_value(); + m_xMtrEndWidth->save_value(); + m_xTsbCenterStart->save_state(); + m_xTsbCenterEnd->save_state(); + m_xMtrTransparent->save_value(); + + m_xLBEdgeStyle->save_value(); + + // LineCaps + m_xLBCapStyle->save_value(); + + ClickInvisibleHdl_Impl(); + + ChangePreviewHdl_Impl( nullptr ); +} + +std::unique_ptr<SfxTabPage> SvxLineTabPage::Create(weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxLineTabPage>(pPage, pController, *rAttrs); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangePreviewListBoxHdl_Impl, ColorListBox&, void) +{ + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK(SvxLineTabPage, ChangePreviewModifyHdl_Impl, weld::MetricSpinButton&, rEdit, void) +{ + ChangePreviewHdl_Impl(&rEdit); +} + +void SvxLineTabPage::ChangePreviewHdl_Impl(const weld::MetricSpinButton* pCntrl) +{ + if (pCntrl == m_xMtrLineWidth.get()) + { + // Line width and start end width + sal_Int32 nNewLineWidth = GetCoreValue( *m_xMtrLineWidth, m_ePoolUnit ); + if(m_nActLineWidth == -1) + { + // Don't initialize yet, get the start value + const SfxPoolItem* pOld = GetOldItem( m_rXLSet, XATTR_LINEWIDTH ); + sal_Int32 nStartLineWidth = 0; + if(pOld) + nStartLineWidth = static_cast<const XLineWidthItem *>(pOld)->GetValue(); + m_nActLineWidth = nStartLineWidth; + } + + if(m_nActLineWidth != nNewLineWidth) + { + // Adapt start/end width + sal_Int32 nValAct = GetCoreValue( *m_xMtrStartWidth, m_ePoolUnit ); + sal_Int32 nValNew = nValAct + (((nNewLineWidth - m_nActLineWidth) * 15) / 10); + if(nValNew < 0) + nValNew = 0; + SetMetricValue( *m_xMtrStartWidth, nValNew, m_ePoolUnit ); + + nValAct = GetCoreValue( *m_xMtrEndWidth, m_ePoolUnit ); + nValNew = nValAct + (((nNewLineWidth - m_nActLineWidth) * 15) / 10); + if(nValNew < 0) + nValNew = 0; + SetMetricValue( *m_xMtrEndWidth, nValNew, m_ePoolUnit ); + } + + // Remember current value + m_nActLineWidth = nNewLineWidth; + } + + FillXLSet_Impl(); + m_aCtlPreview.Invalidate(); + + // Make transparency accessible accordingly + if( m_xLbLineStyle->get_active() == 0 ) // invisible + { + m_xBoxTransparency->set_sensitive(false); + } + else + { + m_xBoxTransparency->set_sensitive(true); + } + + const bool bHasLineStyle = m_xLbLineStyle->get_active() !=0; + const bool bHasLineStart = m_xLbStartStyle->get_active() != 0; + + m_xBoxStart->set_sensitive(bHasLineStart && bHasLineStyle); + + const bool bHasLineEnd = m_xLbEndStyle->get_active() != 0; + + m_xBoxEnd->set_sensitive(bHasLineEnd && bHasLineStyle); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeStartClickHdl_Impl, weld::Toggleable&, void) +{ + if (m_xCbxSynchronize->get_active()) + m_xTsbCenterEnd->set_state(m_xTsbCenterStart->get_state()); + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeStartListBoxHdl_Impl, weld::ComboBox&, void) +{ + if (m_xCbxSynchronize->get_active()) + m_xLbEndStyle->set_active(m_xLbStartStyle->get_active()); + + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeStartModifyHdl_Impl, weld::MetricSpinButton&, void) +{ + if (m_xCbxSynchronize->get_active()) + m_xMtrEndWidth->set_value(m_xMtrStartWidth->get_value(FieldUnit::NONE), FieldUnit::NONE); + + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeEdgeStyleHdl_Impl, weld::ComboBox&, void) +{ + ChangePreviewHdl_Impl( nullptr ); +} + +// fdo#43209 +IMPL_LINK_NOARG(SvxLineTabPage, ChangeCapStyleHdl_Impl, weld::ComboBox&, void) +{ + ChangePreviewHdl_Impl( nullptr ); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ClickInvisibleHdl_Impl, weld::ComboBox&, void) +{ + ClickInvisibleHdl_Impl(); +} + +void SvxLineTabPage::ClickInvisibleHdl_Impl() +{ + if( m_xLbLineStyle->get_active() == 0 ) // invisible + { + if(!m_bSymbols) + m_xBoxColor->set_sensitive(false); + + m_xBoxWidth->set_sensitive(false); + + if( m_xFlLineEnds->get_sensitive() ) + { + m_xBoxStart->set_sensitive(false); + m_xBoxArrowStyles->set_sensitive(false); + m_xGridEdgeCaps->set_sensitive(false); + } + } + else + { + // set cap style associated to the line style + sal_Int32 nPos = m_xLbLineStyle->get_active(); + if( nPos > 1 && m_pDashList->Count() > static_cast<tools::Long>( nPos - 2 ) ) + { + css::drawing::DashStyle eStyle = + m_pDashList->GetDash( nPos - 2 )->GetDash().GetDashStyle(); + if ( eStyle == drawing::DashStyle_RECT || eStyle == drawing::DashStyle_RECTRELATIVE) + m_xLBCapStyle->set_active(0); + else + m_xLBCapStyle->set_active(1); + } + + m_xBoxColor->set_sensitive(true); + m_xBoxWidth->set_sensitive(true); + + if (m_xFlLineEnds->get_sensitive()) + { + m_xBoxArrowStyles->set_sensitive(true); + m_xGridEdgeCaps->set_sensitive(true); + } + } + ChangePreviewHdl_Impl( nullptr ); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeEndClickHdl_Impl, weld::Toggleable&, void) +{ + if (m_xCbxSynchronize->get_active()) + m_xTsbCenterStart->set_state(m_xTsbCenterEnd->get_state()); + + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeEndListBoxHdl_Impl, weld::ComboBox&, void) +{ + if (m_xCbxSynchronize->get_active()) + m_xLbStartStyle->set_active(m_xLbEndStyle->get_active()); + + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeEndModifyHdl_Impl, weld::MetricSpinButton&, void) +{ + if (m_xCbxSynchronize->get_active()) + m_xMtrStartWidth->set_value(m_xMtrEndWidth->get_value(FieldUnit::NONE), FieldUnit::NONE); + + ChangePreviewHdl_Impl(nullptr); +} + +IMPL_LINK_NOARG(SvxLineTabPage, ChangeTransparentHdl_Impl, weld::MetricSpinButton&, void) +{ + sal_uInt16 nVal = m_xMtrTransparent->get_value(FieldUnit::PERCENT); + + m_rXLSet.Put(XLineTransparenceItem(nVal)); + + FillXLSet_Impl(); + + m_aCtlPreview.Invalidate(); +} + +void SvxLineTabPage::FillUserData() +{ + // Write the synched value to the INI file + OUString aStrUserData = OUString::boolean(m_xCbxSynchronize->get_active()); + SetUserData( aStrUserData ); +} + +// #58425# Symbols on a list (e.g. StarChart) +// Handler for the symbol selection's popup menu (NumMenueButton) +// The following link originates from SvxNumOptionsTabPage +IMPL_LINK_NOARG(SvxLineTabPage, MenuCreateHdl_Impl, weld::Toggleable&, void) +{ + ScopedVclPtrInstance< VirtualDevice > pVD; + + // Initialize popup + if (!m_xGalleryMenu) + { + m_xGalleryMenu = m_xBuilder->weld_menu("gallerysubmenu"); + weld::WaitObject aWait(GetFrameWeld()); + // Get gallery entries + GalleryExplorer::FillObjList(GALLERY_THEME_BULLETS, m_aGrfNames); + + sal_uInt32 i = 0; + for (auto const& grfName : m_aGrfNames) + { + const OUString *pUIName = &grfName; + + // Convert URL encodings to UI characters (e.g. %20 for spaces) + OUString aPhysicalName; + if (osl::FileBase::getSystemPathFromFileURL(grfName, aPhysicalName) + == osl::FileBase::E_None) + { + pUIName = &aPhysicalName; + } + + SvxBmpItemInfo* pInfo = new SvxBmpItemInfo; + pInfo->pBrushItem.reset(new SvxBrushItem(grfName, "", GPOS_AREA, SID_ATTR_BRUSH)); + pInfo->sItemId = "gallery" + OUString::number(i); + m_aGalleryBrushItems.emplace_back(pInfo); + const Graphic* pGraphic = pInfo->pBrushItem->GetGraphic(); + + if(pGraphic) + { + BitmapEx aBitmap(pGraphic->GetBitmapEx()); + Size aSize(aBitmap.GetSizePixel()); + if(aSize.Width() > MAX_BMP_WIDTH || aSize.Height() > MAX_BMP_HEIGHT) + { + bool bWidth = aSize.Width() > aSize.Height(); + double nScale = bWidth ? + double(MAX_BMP_WIDTH) / static_cast<double>(aSize.Width()): + double(MAX_BMP_HEIGHT) / static_cast<double>(aSize.Height()); + aBitmap.Scale(nScale, nScale); + + } + pVD->SetOutputSizePixel(aBitmap.GetSizePixel()); + pVD->DrawBitmapEx(Point(), aBitmap); + m_xGalleryMenu->append(pInfo->sItemId, *pUIName, *pVD); + } + else + { + m_xGalleryMenu->append(pInfo->sItemId, *pUIName); + } + ++i; + } + + if (m_aGrfNames.empty()) + m_xSymbolMB->set_item_sensitive("gallery", false); + } + + if (m_xSymbolsMenu || !m_pSymbolList) + return; + + m_xSymbolsMenu = m_xBuilder->weld_menu("symbolssubmenu"); + ScopedVclPtrInstance< VirtualDevice > pVDev; + pVDev->SetMapMode(MapMode(MapUnit::Map100thMM)); + std::unique_ptr<SdrModel> pModel( + new SdrModel(nullptr, nullptr, true)); + pModel->GetItemPool().FreezeIdRanges(); + // Page + rtl::Reference<SdrPage> pPage = new SdrPage( *pModel, false ); + pPage->SetSize(Size(1000,1000)); + pModel->InsertPage( pPage.get(), 0 ); + { + // 3D View + SdrView aView( *pModel, pVDev ); + aView.hideMarkHandles(); + aView.ShowSdrPage(pPage.get()); + + // Generate invisible square to give all symbols a + // bitmap size, which is independent from specific glyph + SdrObject *pInvisibleSquare=m_pSymbolList->GetObj(0); + + // directly clone to target SdrModel + pInvisibleSquare = pInvisibleSquare->CloneSdrObject(*pModel); + + pPage->NbcInsertObject(pInvisibleSquare); + pInvisibleSquare->SetMergedItem(XFillTransparenceItem(100)); + pInvisibleSquare->SetMergedItem(XLineTransparenceItem(100)); + + for(size_t i=0; i < m_pSymbolList->GetObjCount(); ++i) + { + SdrObject *pObj=m_pSymbolList->GetObj(i); + assert(pObj); + + // directly clone to target SdrModel + pObj = pObj->CloneSdrObject(*pModel); + + m_aGrfNames.emplace_back(""); + pPage->NbcInsertObject(pObj); + if(m_xSymbolAttr) + { + pObj->SetMergedItemSet(*m_xSymbolAttr); + } + else + { + pObj->SetMergedItemSet(m_rOutAttrs); + } + aView.MarkAll(); + BitmapEx aBitmapEx(aView.GetMarkedObjBitmapEx()); + GDIMetaFile aMeta(aView.GetMarkedObjMetaFile()); + aView.UnmarkAll(); + pObj=pPage->RemoveObject(1); + SdrObject::Free(pObj); + + SvxBmpItemInfo* pInfo = new SvxBmpItemInfo; + pInfo->pBrushItem.reset(new SvxBrushItem(Graphic(aMeta), GPOS_AREA, SID_ATTR_BRUSH)); + pInfo->sItemId = "symbol" + OUString::number(i); + m_aSymbolBrushItems.emplace_back(pInfo); + + Size aSize(aBitmapEx.GetSizePixel()); + if(aSize.Width() > MAX_BMP_WIDTH || aSize.Height() > MAX_BMP_HEIGHT) + { + bool bWidth = aSize.Width() > aSize.Height(); + double nScale = bWidth ? + double(MAX_BMP_WIDTH) / static_cast<double>(aSize.Width()): + double(MAX_BMP_HEIGHT) / static_cast<double>(aSize.Height()); + aBitmapEx.Scale(nScale, nScale); + } + pVD->SetOutputSizePixel(aBitmapEx.GetSizePixel()); + pVD->DrawBitmapEx(Point(), aBitmapEx); + m_xSymbolsMenu->append(pInfo->sItemId, "", *pVD); + } + pInvisibleSquare=pPage->RemoveObject(0); + SdrObject::Free(pInvisibleSquare); + + if (m_aGrfNames.empty()) + m_xSymbolMB->set_item_sensitive("symbols", false); + } +} + +// #58425# Symbols on a list (e.g. StarChart) +// Handler for menu button +IMPL_LINK(SvxLineTabPage, GraphicHdl_Impl, const OString&, rIdent, void) +{ + const Graphic* pGraphic = nullptr; + Graphic aGraphic; + bool bResetSize = false; + bool bEnable = true; + tools::Long nPreviousSymbolType = m_nSymbolType; + + OString sNumber; + if (rIdent.startsWith("gallery", &sNumber)) + { + SvxBmpItemInfo* pInfo = m_aGalleryBrushItems[sNumber.toUInt32()].get(); + pGraphic = pInfo->pBrushItem->GetGraphic(); + m_nSymbolType = SVX_SYMBOLTYPE_BRUSHITEM; + } + else if (rIdent.startsWith("symbol", &sNumber)) + { + m_nSymbolType = sNumber.toUInt32(); + SvxBmpItemInfo* pInfo = m_aSymbolBrushItems[m_nSymbolType].get(); + pGraphic = pInfo->pBrushItem->GetGraphic(); + } + else if (rIdent == "automatic") + { + pGraphic=&m_aAutoSymbolGraphic; + m_aAutoSymbolGraphic.SetPrefSize( Size(253,253) ); + m_nSymbolType=SVX_SYMBOLTYPE_AUTO; + } + else if (rIdent == "none") + { + m_nSymbolType=SVX_SYMBOLTYPE_NONE; + pGraphic=nullptr; + bEnable = false; + } + else if (rIdent == "file") + { + SvxOpenGraphicDialog aGrfDlg(CuiResId(RID_CUISTR_EDIT_GRAPHIC), GetFrameWeld()); + aGrfDlg.EnableLink(false); + aGrfDlg.AsLink(false); + if( !aGrfDlg.Execute() ) + { + // Remember selected filters + if( !aGrfDlg.GetGraphic(aGraphic) ) + { + m_nSymbolType=SVX_SYMBOLTYPE_BRUSHITEM; + pGraphic = &aGraphic; + bResetSize = true; + } + } + if( !pGraphic ) + return; + } + + if (pGraphic) + { + Size aSize = SvxNumberFormat::GetGraphicSizeMM100(pGraphic); + aSize = OutputDevice::LogicToLogic(aSize, MapMode(MapUnit::Map100thMM), MapMode(m_ePoolUnit)); + m_aSymbolGraphic=*pGraphic; + if( bResetSize ) + { + m_aSymbolSize=aSize; + } + else if( nPreviousSymbolType == SVX_SYMBOLTYPE_BRUSHITEM ) + { //#i31097# Data Point Symbol size changes when a different symbol is chosen(maoyg) + if( m_aSymbolSize.Width() != m_aSymbolSize.Height() ) + { + aSize.setWidth( static_cast<tools::Long>( m_aSymbolSize.Width() + m_aSymbolSize.Height() )/2 ); + aSize.setHeight( static_cast<tools::Long>( m_aSymbolSize.Width() + m_aSymbolSize.Height() )/2 ); + m_aSymbolSize = aSize; + } + } + m_aCtlPreview.SetSymbol(&m_aSymbolGraphic,m_aSymbolSize); + } + else + { + m_aSymbolGraphic=Graphic(); + m_aCtlPreview.SetSymbol(nullptr,m_aSymbolSize); + bEnable = false; + } + m_aSymbolLastSize=m_aSymbolSize; + SetMetricValue(*m_xSymbolWidthMF, m_aSymbolSize.Width(), m_ePoolUnit); + SetMetricValue(*m_xSymbolHeightMF, m_aSymbolSize.Height(), m_ePoolUnit); + + m_xGridIconSize->set_sensitive(bEnable); + m_aCtlPreview.Invalidate(); +} + +IMPL_LINK( SvxLineTabPage, SizeHdl_Impl, weld::MetricSpinButton&, rField, void) +{ + m_bNewSize = true; + bool bWidth = &rField == m_xSymbolWidthMF.get(); + m_bLastWidthModified = bWidth; + bool bRatio = m_xSymbolRatioCB->get_active(); + tools::Long nWidthVal = static_cast<tools::Long>(m_xSymbolWidthMF->denormalize(m_xSymbolWidthMF->get_value(FieldUnit::MM_100TH))); + tools::Long nHeightVal= static_cast<tools::Long>(m_xSymbolHeightMF->denormalize(m_xSymbolHeightMF->get_value(FieldUnit::MM_100TH))); + nWidthVal = OutputDevice::LogicToLogic(nWidthVal,MapUnit::Map100thMM, m_ePoolUnit ); + nHeightVal = OutputDevice::LogicToLogic(nHeightVal,MapUnit::Map100thMM, m_ePoolUnit); + m_aSymbolSize = Size(nWidthVal,nHeightVal); + double fSizeRatio = double(1); + + if(bRatio) + { + if (m_aSymbolLastSize.Height() && m_aSymbolLastSize.Width()) + fSizeRatio = static_cast<double>(m_aSymbolLastSize.Width()) / m_aSymbolLastSize.Height(); + } + + if (bWidth) + { + tools::Long nDelta = nWidthVal - m_aSymbolLastSize.Width(); + m_aSymbolSize.setWidth( nWidthVal ); + if (bRatio) + { + m_aSymbolSize.setHeight( m_aSymbolLastSize.Height() + static_cast<tools::Long>(static_cast<double>(nDelta) / fSizeRatio) ); + m_aSymbolSize.setHeight( OutputDevice::LogicToLogic( m_aSymbolSize.Height(), m_ePoolUnit, MapUnit::Map100thMM ) ); +//TODO m_xSymbolHeightMF->SetUserValue(m_xSymbolHeightMF->normalize(m_aSymbolSize.Height()), FieldUnit::MM_100TH); + m_xSymbolHeightMF->set_value(m_xSymbolHeightMF->normalize(m_aSymbolSize.Height()), FieldUnit::MM_100TH); + } + } + else + { + tools::Long nDelta = nHeightVal - m_aSymbolLastSize.Height(); + m_aSymbolSize.setHeight( nHeightVal ); + if (bRatio) + { + m_aSymbolSize.setWidth( m_aSymbolLastSize.Width() + static_cast<tools::Long>(static_cast<double>(nDelta) * fSizeRatio) ); + m_aSymbolSize.setWidth( OutputDevice::LogicToLogic( m_aSymbolSize.Width(), m_ePoolUnit, MapUnit::Map100thMM ) ); +//TODO m_xSymbolWidthMF->SetUserValue(m_xSymbolWidthMF->normalize(m_aSymbolSize.Width()), FieldUnit::MM_100TH); + m_xSymbolWidthMF->set_value(m_xSymbolWidthMF->normalize(m_aSymbolSize.Width()), FieldUnit::MM_100TH); + } + } + m_aCtlPreview.ResizeSymbol(m_aSymbolSize); + m_aSymbolLastSize=m_aSymbolSize; +} + +IMPL_LINK(SvxLineTabPage, RatioHdl_Impl, weld::Toggleable&, rBox, void) +{ + if (rBox.get_active()) + { + if (m_bLastWidthModified) + SizeHdl_Impl(*m_xSymbolWidthMF); + else + SizeHdl_Impl(*m_xSymbolHeightMF); + } +} + +void SvxLineTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SvxDashListItem* pDashListItem = aSet.GetItem<SvxDashListItem>(SID_DASH_LIST, false); + const SvxLineEndListItem* pLineEndListItem = aSet.GetItem<SvxLineEndListItem>(SID_LINEEND_LIST, false); + const SfxUInt16Item* pPageTypeItem = aSet.GetItem<SfxUInt16Item>(SID_PAGE_TYPE, false); + const SfxUInt16Item* pDlgTypeItem = aSet.GetItem<SfxUInt16Item>(SID_DLG_TYPE, false); + const OfaPtrItem* pSdrObjListItem = aSet.GetItem<OfaPtrItem>(SID_OBJECT_LIST, false); + const SfxTabDialogItem* pSymbolAttrItem = aSet.GetItem<SfxTabDialogItem>(SID_ATTR_SET, false); + const SvxGraphicItem* pGraphicItem = aSet.GetItem<SvxGraphicItem>(SID_GRAPHIC, false); + + if (pDashListItem) + SetDashList(pDashListItem->GetDashList()); + if (pLineEndListItem) + SetLineEndList(pLineEndListItem->GetLineEndList()); + if (pPageTypeItem) + SetPageType(static_cast<PageType>(pPageTypeItem->GetValue())); + if (pDlgTypeItem) + SetDlgType(pDlgTypeItem->GetValue()); + Construct(); + + if(pSdrObjListItem) //symbols + { + ShowSymbolControls(true); + m_pSymbolList = static_cast<SdrObjList*>(pSdrObjListItem->GetValue()); + if (pSymbolAttrItem) + m_xSymbolAttr.reset(new SfxItemSet(pSymbolAttrItem->GetItemSet())); + if(pGraphicItem) + m_aAutoSymbolGraphic = pGraphicItem->GetGraphic(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tplnedef.cxx b/cui/source/tabpages/tplnedef.cxx new file mode 100644 index 000000000..66fea1aba --- /dev/null +++ b/cui/source/tabpages/tplnedef.cxx @@ -0,0 +1,840 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <tools/urlobj.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <unotools/pathoptions.hxx> +#include <sfx2/filedlghelper.hxx> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> + +#include <strings.hrc> + +#include <svx/xlineit0.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlndsit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xtable.hxx> + +#include <svx/dlgctrl.hxx> +#include <cuitabline.hxx> +#include <defdlgname.hxx> +#include <svx/svxdlg.hxx> +#include <dialmgr.hxx> +#include <svx/dlgutil.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include <cuitabarea.hxx> +#include <svtools/unitconv.hxx> +#include <osl/diagnose.h> + +#define XOUT_WIDTH 150 + +using namespace com::sun::star; + + +SvxLineDefTabPage::SvxLineDefTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/linestyletabpage.ui", "LineStylePage", &rInAttrs) + , rOutAttrs(rInAttrs) + , aXLineAttr(rInAttrs.GetPool()) + , rXLSet(aXLineAttr.GetItemSet()) + , pnDashListState(nullptr) + , pPageType(nullptr) + , nDlgType(0) + , pPosDashLb(nullptr) + , m_xLbLineStyles(new SvxLineLB(m_xBuilder->weld_combo_box("LB_LINESTYLES"))) + , m_xLbType1(m_xBuilder->weld_combo_box("LB_TYPE_1")) + , m_xLbType2(m_xBuilder->weld_combo_box("LB_TYPE_2")) + , m_xNumFldNumber1(m_xBuilder->weld_spin_button("NUM_FLD_1")) + , m_xNumFldNumber2(m_xBuilder->weld_spin_button("NUM_FLD_2")) + , m_xMtrLength1(m_xBuilder->weld_metric_spin_button("MTR_FLD_LENGTH_1", FieldUnit::CM)) + , m_xMtrLength2(m_xBuilder->weld_metric_spin_button("MTR_FLD_LENGTH_2", FieldUnit::CM)) + , m_xMtrDistance(m_xBuilder->weld_metric_spin_button("MTR_FLD_DISTANCE", FieldUnit::CM)) + , m_xCbxSynchronize(m_xBuilder->weld_check_button("CBX_SYNCHRONIZE")) + , m_xBtnAdd(m_xBuilder->weld_button("BTN_ADD")) + , m_xBtnModify(m_xBuilder->weld_button("BTN_MODIFY")) + , m_xBtnDelete(m_xBuilder->weld_button("BTN_DELETE")) + , m_xBtnLoad(m_xBuilder->weld_button("BTN_LOAD")) + , m_xBtnSave(m_xBuilder->weld_button("BTN_SAVE")) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview)) +{ + // this page needs ExchangeSupport + SetExchangeSupport(); + + // adjust metric + eFUnit = GetModuleFieldUnit( rInAttrs ); + + switch ( eFUnit ) + { + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + break; + default: ; //prevent warning + } + SetFieldUnit(*m_xMtrDistance, eFUnit); + SetFieldUnit(*m_xMtrLength1, eFUnit); + SetFieldUnit(*m_xMtrLength2, eFUnit); + + // determine PoolUnit + SfxItemPool* pPool = rOutAttrs.GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + ePoolUnit = pPool->GetMetric( SID_ATTR_LINE_WIDTH ); + + rXLSet.Put( XLineStyleItem(drawing::LineStyle_DASH) ); + rXLSet.Put( XLineWidthItem(XOUT_WIDTH) ); + rXLSet.Put( XLineDashItem( OUString(), XDash( css::drawing::DashStyle_RECT, 3, 7, 2, 40, 15 ) ) ); + rXLSet.Put( XLineColorItem(OUString(), COL_BLACK) ); + + // #i34740# + m_aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet()); + + m_xBtnAdd->connect_clicked(LINK(this, SvxLineDefTabPage, ClickAddHdl_Impl)); + m_xBtnModify->connect_clicked(LINK(this, SvxLineDefTabPage, ClickModifyHdl_Impl)); + m_xBtnDelete->connect_clicked(LINK(this, SvxLineDefTabPage, ClickDeleteHdl_Impl)); + m_xBtnLoad->connect_clicked(LINK(this, SvxLineDefTabPage, ClickLoadHdl_Impl)); + m_xBtnSave->connect_clicked(LINK(this, SvxLineDefTabPage, ClickSaveHdl_Impl)); + + m_xNumFldNumber1->connect_value_changed(LINK(this, SvxLineDefTabPage, ChangeNumber1Hdl_Impl)); + m_xNumFldNumber2->connect_value_changed(LINK(this, SvxLineDefTabPage, ChangeNumber2Hdl_Impl)); + m_xLbLineStyles->connect_changed(LINK(this, SvxLineDefTabPage, SelectLinestyleListBoxHdl_Impl)); + + // #i122042# switch off default adding of 'none' and 'solid' entries + // for this ListBox; we want to select only editable/dashed styles + m_xLbLineStyles->setAddStandardFields(false); + + // absolute (in mm) or relative (in %) + m_xCbxSynchronize->connect_toggled(LINK(this, SvxLineDefTabPage, ChangeMetricHdl_Impl)); + + // preview must be updated when there's something changed + Link<weld::ComboBox&, void> aLink = LINK(this, SvxLineDefTabPage, SelectTypeListBoxHdl_Impl); + m_xLbType1->connect_changed(aLink); + m_xLbType2->connect_changed(aLink); + Link<weld::MetricSpinButton&,void> aLink2 = LINK( this, SvxLineDefTabPage, ChangePreviewHdl_Impl ); + m_xMtrLength1->connect_value_changed(aLink2); + m_xMtrLength2->connect_value_changed(aLink2); + m_xMtrDistance->connect_value_changed(aLink2); + + pDashList = nullptr; +} + +SvxLineDefTabPage::~SvxLineDefTabPage() +{ + m_xCtlPreview.reset(); + m_xLbLineStyles.reset(); +} + +void SvxLineDefTabPage::Construct() +{ + // Line style fill; do *not* add default fields here + m_xLbLineStyles->Fill( pDashList ); +} + +void SvxLineDefTabPage::ActivatePage( const SfxItemSet& ) +{ + if( nDlgType != 0 ) // area dialog + return; + + // ActivatePage() is called before the dialog receives PageCreated() !!! + if( !pDashList.is() ) + return; + + if (*pPageType == PageType::Gradient && + *pPosDashLb != -1) + { + m_xLbLineStyles->set_active(*pPosDashLb); + } + // so that a possibly existing line style is discarded + SelectLinestyleHdl_Impl( nullptr ); + + // determining (and possibly cutting) the name + // and displaying it in the GroupBox +// OUString aString( CuiResId( RID_CUISTR_TABLE ) ); +// aString += ": "; + INetURLObject aURL( pDashList->GetPath() ); + + aURL.Append( pDashList->GetName() ); + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + + *pPageType = PageType::Area; // 2 + *pPosDashLb = -1; +} + + +DeactivateRC SvxLineDefTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + CheckChanges_Impl(); + + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + +void SvxLineDefTabPage::CheckChanges_Impl() +{ + // is here used to NOT lose changes + //css::drawing::DashStyle eXDS; + + if( m_xNumFldNumber1->get_value_changed_from_saved() || + m_xMtrLength1->get_value_changed_from_saved() || + m_xLbType1->get_value_changed_from_saved() || + m_xNumFldNumber2->get_value_changed_from_saved() || + m_xMtrLength2->get_value_changed_from_saved() || + m_xLbType2->get_value_changed_from_saved() || + m_xMtrDistance->get_value_changed_from_saved() ) + { + std::unique_ptr<weld::MessageDialog> xMessDlg(Application::CreateMessageDialog(GetFrameWeld(), + VclMessageType::Warning, VclButtonsType::Cancel, + CuiResId(RID_CUISTR_ASK_CHANGE_LINESTYLE))); + xMessDlg->set_title(SvxResId(RID_SVXSTR_LINESTYLE)); + xMessDlg->add_button(CuiResId(RID_CUISTR_CHANGE), RET_BTN_1); + xMessDlg->add_button(CuiResId(RID_CUISTR_ADD), RET_BTN_2); + + short nRet = xMessDlg->run(); + + switch( nRet ) + { + case RET_BTN_1: + { + ClickModifyHdl_Impl(*m_xBtnModify); + } + break; + + case RET_BTN_2: + { + ClickAddHdl_Impl(*m_xBtnAdd); + } + break; + + case RET_CANCEL: + break; + } + } + + int nPos = m_xLbLineStyles->get_active(); + if (nPos != -1) + { + *pPosDashLb = nPos; + } +} + + +bool SvxLineDefTabPage::FillItemSet( SfxItemSet* rAttrs ) +{ + if( nDlgType == 0 ) // line dialog + { + if( *pPageType == PageType::Hatch ) + { + FillDash_Impl(); + + OUString aString(m_xLbLineStyles->get_active_text()); + rAttrs->Put( XLineStyleItem( drawing::LineStyle_DASH ) ); + rAttrs->Put( XLineDashItem( aString, aDash ) ); + } + } + return true; +} + + +void SvxLineDefTabPage::Reset( const SfxItemSet* rAttrs ) +{ + if( rAttrs->GetItemState( GetWhich( XATTR_LINESTYLE ) ) != SfxItemState::DONTCARE ) + { + drawing::LineStyle eXLS = rAttrs->Get( GetWhich( XATTR_LINESTYLE ) ).GetValue(); + + switch( eXLS ) + { + case drawing::LineStyle_NONE: + case drawing::LineStyle_SOLID: + m_xLbLineStyles->set_active(0); + break; + case drawing::LineStyle_DASH: + { + const XLineDashItem& rDashItem = rAttrs->Get( XATTR_LINEDASH ); + aDash = rDashItem.GetDashValue(); + + m_xLbLineStyles->set_active(-1); + m_xLbLineStyles->set_active_text(rDashItem.GetName()); + break; + } + default: + break; + } + } + SelectLinestyleHdl_Impl( nullptr ); + + // determine button state + if( pDashList->Count() ) + { + m_xBtnModify->set_sensitive(true); + m_xBtnDelete->set_sensitive(true); + m_xBtnSave->set_sensitive(true); + } + else + { + m_xBtnModify->set_sensitive(false); + m_xBtnDelete->set_sensitive(false); + m_xBtnSave->set_sensitive(false); + } +} + +std::unique_ptr<SfxTabPage> SvxLineDefTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rOutAttrs ) +{ + return std::make_unique<SvxLineDefTabPage>(pPage, pController, *rOutAttrs); +} + +IMPL_LINK(SvxLineDefTabPage, SelectLinestyleListBoxHdl_Impl, weld::ComboBox&, rListBox, void) +{ + SelectLinestyleHdl_Impl(&rListBox); +} + +void SvxLineDefTabPage::SelectLinestyleHdl_Impl(const weld::ComboBox* p) +{ + if(!pDashList->Count()) + return; + + int nTmp = m_xLbLineStyles->get_active(); + if (nTmp == -1) + { + OSL_ENSURE(false, "OOps, non-existent LineDash selected (!)"); + nTmp = 1; + } + + aDash = pDashList->GetDash( nTmp )->GetDash(); + + FillDialog_Impl(); + + rXLSet.Put( XLineDashItem( OUString(), aDash ) ); + + // #i34740# + m_aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet()); + m_aCtlPreview.Invalidate(); + + // Is not set before, in order to take the new style + // only if there was an entry selected in the ListBox. + // If it was called via Reset(), then p is == NULL + if( p ) + *pPageType = PageType::Hatch; +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ChangePreviewHdl_Impl, weld::MetricSpinButton&, void) +{ + FillDash_Impl(); + m_aCtlPreview.Invalidate(); +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ChangeNumber1Hdl_Impl, weld::SpinButton&, void) +{ + if (m_xNumFldNumber1->get_value() == 0) + { + m_xNumFldNumber2->set_min(1); + } + else + { + m_xNumFldNumber2->set_min(0); + } + + ChangePreviewHdl_Impl(*m_xMtrLength1); +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ChangeNumber2Hdl_Impl, weld::SpinButton&, void) +{ + if (m_xNumFldNumber2->get_value() == 0) + { + m_xNumFldNumber1->set_min(1); + } + else + { + m_xNumFldNumber1->set_min(0); + } + + ChangePreviewHdl_Impl(*m_xMtrLength1); +} + +IMPL_LINK( SvxLineDefTabPage, ChangeMetricHdl_Impl, weld::Toggleable&, r, void) +{ + ChangeMetricHdl_Impl(&r); +} + +void SvxLineDefTabPage::ChangeMetricHdl_Impl(const weld::Toggleable* p) +{ + if( !m_xCbxSynchronize->get_active() && m_xMtrLength1->get_unit() != eFUnit ) + { + tools::Long nTmp1, nTmp2, nTmp3; + + // was changed with Control + if( p ) + { + nTmp1 = GetCoreValue( *m_xMtrLength1, ePoolUnit ) * XOUT_WIDTH / 100; + nTmp2 = GetCoreValue( *m_xMtrLength2, ePoolUnit ) * XOUT_WIDTH / 100; + nTmp3 = GetCoreValue( *m_xMtrDistance, ePoolUnit ) * XOUT_WIDTH / 100; + } + else + { + nTmp1 = GetCoreValue( *m_xMtrLength1, ePoolUnit ); + nTmp2 = GetCoreValue( *m_xMtrLength2, ePoolUnit ); + nTmp3 = GetCoreValue( *m_xMtrDistance, ePoolUnit ); + } + m_xMtrLength1->set_digits(2); + m_xMtrLength2->set_digits(2); + m_xMtrDistance->set_digits(2); + + // adjust metric + m_xMtrLength1->set_unit(eFUnit); + m_xMtrLength2->set_unit(eFUnit); + m_xMtrDistance->set_unit(eFUnit); + + // tdf#126736 max 5cm + m_xMtrLength1->set_range(0, 500, FieldUnit::CM); + m_xMtrLength2->set_range(0, 500, FieldUnit::CM); + m_xMtrDistance->set_range(0, 500, FieldUnit::CM); + + SetMetricValue( *m_xMtrLength1, nTmp1, ePoolUnit ); + SetMetricValue( *m_xMtrLength2, nTmp2, ePoolUnit ); + SetMetricValue( *m_xMtrDistance, nTmp3, ePoolUnit ); + } + else if( m_xCbxSynchronize->get_active() && m_xMtrLength1->get_unit() != FieldUnit::PERCENT ) + { + tools::Long nTmp1, nTmp2, nTmp3; + + // was changed with Control + if( p ) + { + nTmp1 = GetCoreValue( *m_xMtrLength1, ePoolUnit ) * 100 / XOUT_WIDTH; + nTmp2 = GetCoreValue( *m_xMtrLength2, ePoolUnit ) * 100 / XOUT_WIDTH; + nTmp3 = GetCoreValue( *m_xMtrDistance, ePoolUnit ) * 100 / XOUT_WIDTH; + } + else + { + nTmp1 = GetCoreValue( *m_xMtrLength1, ePoolUnit ); + nTmp2 = GetCoreValue( *m_xMtrLength2, ePoolUnit ); + nTmp3 = GetCoreValue( *m_xMtrDistance, ePoolUnit ); + } + + m_xMtrLength1->set_digits(0); + m_xMtrLength2->set_digits(0); + m_xMtrDistance->set_digits(0); + + m_xMtrLength1->set_unit(FieldUnit::PERCENT); + m_xMtrLength2->set_unit(FieldUnit::PERCENT); + m_xMtrDistance->set_unit(FieldUnit::PERCENT); + + // tdf#126736 800% + m_xMtrLength1->set_range(0, 800, FieldUnit::PERCENT); + m_xMtrLength2->set_range(0, 800, FieldUnit::PERCENT); + m_xMtrDistance->set_range(0, 800, FieldUnit::PERCENT); + + m_xMtrLength1->set_value(nTmp1, FieldUnit::PERCENT); + m_xMtrLength2->set_value(nTmp2, FieldUnit::PERCENT); + m_xMtrDistance->set_value(nTmp3, FieldUnit::PERCENT); + } + SelectTypeHdl_Impl( nullptr ); +} + +IMPL_LINK( SvxLineDefTabPage, SelectTypeListBoxHdl_Impl, weld::ComboBox&, rListBox, void ) +{ + SelectTypeHdl_Impl(&rListBox); +} + +void SvxLineDefTabPage::SelectTypeHdl_Impl(const weld::ComboBox* p) +{ + if (p == m_xLbType1.get() || !p) + { + if (m_xLbType1->get_active() == 0) + { + m_xMtrLength1->set_sensitive(false); + m_xMtrLength1->set_text(""); + } + else if (!m_xMtrLength1->get_sensitive()) + { + m_xMtrLength1->set_sensitive(true); + m_xMtrLength1->reformat(); + } + } + + if (p == m_xLbType2.get() || !p) + { + if (m_xLbType2->get_active() == 0) + { + m_xMtrLength2->set_sensitive(false); + m_xMtrLength2->set_text(""); + } + else if (!m_xMtrLength2->get_sensitive()) + { + m_xMtrLength2->set_sensitive(true); + m_xMtrLength2->reformat(); + } + } + ChangePreviewHdl_Impl(*m_xMtrLength1); +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ClickAddHdl_Impl, weld::Button&, void) +{ + OUString aNewName(SvxResId(RID_SVXSTR_LINESTYLE)); + OUString aDesc(CuiResId(RID_CUISTR_DESC_LINESTYLE)); + OUString aName; + + tools::Long nCount = pDashList->Count(); + tools::Long j = 1; + bool bDifferent = false; + + while ( !bDifferent ) + { + aName = aNewName + " " + OUString::number( j++ ); + bDifferent = true; + + for ( tools::Long i = 0; i < nCount && bDifferent; i++ ) + if ( aName == pDashList->GetDash( i )->GetName() ) + bDifferent = false; + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + bool bLoop = true; + + while ( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + bDifferent = true; + + for( tools::Long i = 0; i < nCount && bDifferent; i++ ) + { + if( aName == pDashList->GetDash( i )->GetName() ) + bDifferent = false; + } + + if( bDifferent ) + { + bLoop = false; + FillDash_Impl(); + + tools::Long nDashCount = pDashList->Count(); + pDashList->Insert( std::make_unique<XDashEntry>(aDash, aName), nDashCount ); + m_xLbLineStyles->Append( *pDashList->GetDash(nDashCount), pDashList->GetUiBitmap(nDashCount) ); + + m_xLbLineStyles->set_active(m_xLbLineStyles->get_count() - 1); + + *pnDashListState |= ChangeType::MODIFIED; + + *pPageType = PageType::Hatch; + + // save values for changes recognition (-> method) + m_xNumFldNumber1->save_value(); + m_xMtrLength1->save_value(); + m_xLbType1->save_value(); + m_xNumFldNumber2->save_value(); + m_xMtrLength2->save_value(); + m_xLbType2->save_value(); + m_xMtrDistance->save_value(); + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xBox->run(); + } + } + pDlg.disposeAndClear(); + + // determine button state + if ( pDashList->Count() ) + { + m_xBtnModify->set_sensitive(true); + m_xBtnDelete->set_sensitive(true); + m_xBtnSave->set_sensitive(true); + } +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ClickModifyHdl_Impl, weld::Button&, void) +{ + int nPos = m_xLbLineStyles->get_active(); + if (nPos == -1) + return; + + OUString aDesc(CuiResId(RID_CUISTR_DESC_LINESTYLE)); + OUString aName( pDashList->GetDash( nPos )->GetName() ); + OUString aOldName = aName; + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + + tools::Long nCount = pDashList->Count(); + bool bLoop = true; + + while ( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + bool bDifferent = true; + + for( tools::Long i = 0; i < nCount && bDifferent; i++ ) + { + if( aName == pDashList->GetDash( i )->GetName() && + aName != aOldName ) + bDifferent = false; + } + + if ( bDifferent ) + { + bLoop = false; + FillDash_Impl(); + + pDashList->Replace(std::make_unique<XDashEntry>(aDash, aName), nPos); + m_xLbLineStyles->Modify(*pDashList->GetDash(nPos), nPos, pDashList->GetUiBitmap(nPos)); + + m_xLbLineStyles->set_active(nPos); + + *pnDashListState |= ChangeType::MODIFIED; + + *pPageType = PageType::Hatch; + + // save values for changes recognition (-> method) + m_xNumFldNumber1->save_value(); + m_xMtrLength1->save_value(); + m_xLbType1->save_value(); + m_xNumFldNumber2->save_value(); + m_xMtrLength2->save_value(); + m_xLbType2->save_value(); + m_xMtrDistance->save_value(); + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xBox->run(); + } + } +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ClickDeleteHdl_Impl, weld::Button&, void) +{ + int nPos = m_xLbLineStyles->get_active(); + if (nPos != -1) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querydeletelinestyledialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskDelLineStyleDialog")); + if (xQueryBox->run() == RET_YES) + { + pDashList->Remove(nPos); + m_xLbLineStyles->remove(nPos); + m_xLbLineStyles->set_active(0); + + SelectLinestyleHdl_Impl( nullptr ); + *pPageType = PageType::Area; // style should not be taken + + *pnDashListState |= ChangeType::MODIFIED; + + ChangePreviewHdl_Impl( *m_xMtrLength1 ); + } + } + + // determine button state + if ( !pDashList->Count() ) + { + m_xBtnModify->set_sensitive(false); + m_xBtnDelete->set_sensitive(false); + m_xBtnSave->set_sensitive(false); + } +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ClickLoadHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nReturn = RET_YES; + + if ( *pnDashListState & ChangeType::MODIFIED ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querysavelistdialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("AskSaveList")); + + nReturn = xBox->run(); + + if ( nReturn == RET_YES ) + pDashList->Save(); + } + + if ( nReturn != RET_CANCEL ) + { + ::sfx2::FileDialogHelper aDlg(css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, + FileDialogFlags::NONE, GetFrameWeld()); + OUString aStrFilterType( "*.sod" ); + aDlg.AddFilter( aStrFilterType, aStrFilterType ); + OUString aPalettePath(SvtPathOptions().GetPalettePath()); + OUString aLastDir; + sal_Int32 nIndex = 0; + do + { + aLastDir = aPalettePath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + INetURLObject aFile(aLastDir); + aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if( aDlg.Execute() == ERRCODE_NONE ) + { + INetURLObject aURL( aDlg.GetPath() ); + INetURLObject aPathURL( aURL ); + + aPathURL.removeSegment(); + aPathURL.removeFinalSlash(); + + XDashListRef pDshLst = XPropertyList::AsDashList(XPropertyList::CreatePropertyList( XPropertyListType::Dash, aPathURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), "" )); + pDshLst->SetName( aURL.getName() ); + + if( pDshLst->Load() ) + { + pDashList = pDshLst; + static_cast<SvxLineTabDialog*>(GetDialogController())->SetNewDashList( pDashList ); + + m_xLbLineStyles->clear(); + m_xLbLineStyles->Fill( pDashList ); + Reset( &rOutAttrs ); + + pDashList->SetName( aURL.getName() ); + + *pnDashListState |= ChangeType::CHANGED; + *pnDashListState &= ~ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querynoloadedfiledialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("NoLoadedFileDialog")); + xBox->run(); + } + } + } + + // determine button state + if ( pDashList->Count() ) + { + m_xBtnModify->set_sensitive(true); + m_xBtnDelete->set_sensitive(true); + m_xBtnSave->set_sensitive(true); + } + else + { + m_xBtnModify->set_sensitive(false); + m_xBtnDelete->set_sensitive(false); + m_xBtnSave->set_sensitive(false); + } +} + +IMPL_LINK_NOARG(SvxLineDefTabPage, ClickSaveHdl_Impl, weld::Button&, void) +{ + ::sfx2::FileDialogHelper aDlg(css::ui::dialogs::TemplateDescription::FILESAVE_SIMPLE, FileDialogFlags::NONE, GetFrameWeld()); + OUString aStrFilterType( "*.sod" ); + aDlg.AddFilter( aStrFilterType, aStrFilterType ); + + OUString aPalettePath(SvtPathOptions().GetPalettePath()); + OUString aLastDir; + sal_Int32 nIndex = 0; + do + { + aLastDir = aPalettePath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + INetURLObject aFile(aLastDir); + DBG_ASSERT( aFile.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + + if( !pDashList->GetName().isEmpty() ) + { + aFile.Append( pDashList->GetName() ); + + if( aFile.getExtension().isEmpty() ) + aFile.SetExtension( u"sod" ); + } + + aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + if ( aDlg.Execute() != ERRCODE_NONE ) + return; + + INetURLObject aURL( aDlg.GetPath() ); + INetURLObject aPathURL( aURL ); + + aPathURL.removeSegment(); + aPathURL.removeFinalSlash(); + + pDashList->SetName( aURL.getName() ); + pDashList->SetPath( aPathURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if( pDashList->Save() ) + { + *pnDashListState &= ~ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querynosavefiledialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("NoSaveFileDialog")); + xBox->run(); + } +} + +void SvxLineDefTabPage::FillDash_Impl() +{ + css::drawing::DashStyle eXDS; + + if (m_xCbxSynchronize->get_active()) + eXDS = css::drawing::DashStyle_RECTRELATIVE; + else + eXDS = css::drawing::DashStyle_RECT; + + aDash.SetDashStyle( eXDS ); + aDash.SetDots( static_cast<sal_uInt8>(m_xNumFldNumber1->get_value()) ); + aDash.SetDotLen( m_xLbType1->get_active() == 0 ? 0 : GetCoreValue( *m_xMtrLength1, ePoolUnit ) ); + aDash.SetDashes( static_cast<sal_uInt8>(m_xNumFldNumber2->get_value()) ); + aDash.SetDashLen( m_xLbType2->get_active() == 0 ? 0 : GetCoreValue( *m_xMtrLength2, ePoolUnit ) ); + aDash.SetDistance( GetCoreValue( *m_xMtrDistance, ePoolUnit ) ); + + rXLSet.Put( XLineDashItem( OUString(), aDash ) ); + + // #i34740# + m_aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet()); +} + +void SvxLineDefTabPage::FillDialog_Impl() +{ + css::drawing::DashStyle eXDS = aDash.GetDashStyle(); // css::drawing::DashStyle_RECT, css::drawing::DashStyle_ROUND + if( eXDS == css::drawing::DashStyle_RECTRELATIVE ) + m_xCbxSynchronize->set_active(true); + else + m_xCbxSynchronize->set_active(false); + + m_xNumFldNumber1->set_value(aDash.GetDots()); + SetMetricValue( *m_xMtrLength1, aDash.GetDotLen(), ePoolUnit ); + m_xLbType1->set_active(aDash.GetDotLen() == 0 ? 0 : 1); + m_xNumFldNumber2->set_value(aDash.GetDashes()); + SetMetricValue( *m_xMtrLength2, aDash.GetDashLen(), ePoolUnit ); + m_xLbType2->set_active(aDash.GetDashLen() == 0 ? 0 : 1); + SetMetricValue( *m_xMtrDistance, aDash.GetDistance(), ePoolUnit ); + + ChangeMetricHdl_Impl(nullptr); + + // save values for changes recognition (-> method) + m_xNumFldNumber1->save_value(); + m_xMtrLength1->save_value(); + m_xLbType1->save_value(); + m_xNumFldNumber2->save_value(); + m_xMtrLength2->save_value(); + m_xLbType2->save_value(); + m_xMtrDistance->save_value(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tplneend.cxx b/cui/source/tabpages/tplneend.cxx new file mode 100644 index 000000000..951b27632 --- /dev/null +++ b/cui/source/tabpages/tplneend.cxx @@ -0,0 +1,610 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <tools/urlobj.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <unotools/pathoptions.hxx> +#include <sfx2/filedlghelper.hxx> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> + +#include <strings.hrc> +#include <svx/dialmgr.hxx> +#include <svx/dlgctrl.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdopath.hxx> +#include <svx/xtable.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlnwtit.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xlnstwit.hxx> +#include <svx/xlnedwit.hxx> +#include <svx/xlnstit.hxx> +#include <svx/xlnedit.hxx> +#include <cuitabline.hxx> +#include <cuitabarea.hxx> +#include <svx/svxdlg.hxx> +#include <dialmgr.hxx> +#include <basegfx/range/b2drange.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> +#include <svx/strings.hrc> +#include <osl/diagnose.h> + +#define XOUT_WIDTH 150 + +SvxLineEndDefTabPage::SvxLineEndDefTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/lineendstabpage.ui", "LineEndPage", &rInAttrs) + , rOutAttrs(rInAttrs) + , pPolyObj(nullptr) + , aXLineAttr(rInAttrs.GetPool()) + , rXLSet(aXLineAttr.GetItemSet()) + , pnLineEndListState(nullptr) + , pPageType(nullptr) + , nDlgType(0) + , pPosLineEndLb(nullptr) + , m_xEdtName(m_xBuilder->weld_entry("EDT_NAME")) + , m_xLbLineEnds(new SvxLineEndLB(m_xBuilder->weld_combo_box("LB_LINEENDS"))) + , m_xBtnAdd(m_xBuilder->weld_button("BTN_ADD")) + , m_xBtnModify(m_xBuilder->weld_button("BTN_MODIFY")) + , m_xBtnDelete(m_xBuilder->weld_button("BTN_DELETE")) + , m_xBtnLoad(m_xBuilder->weld_button("BTN_LOAD")) + , m_xBtnSave(m_xBuilder->weld_button("BTN_SAVE")) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview)) +{ + // this page needs ExchangeSupport + SetExchangeSupport(); + + rXLSet.Put( XLineStyleItem(css::drawing::LineStyle_SOLID) ); + rXLSet.Put( XLineWidthItem(XOUT_WIDTH) ); + rXLSet.Put( XLineColorItem( OUString(), COL_BLACK ) ); + rXLSet.Put( XLineStartWidthItem( m_aCtlPreview.GetOutputSize().Height() / 2 ) ); + rXLSet.Put( XLineEndWidthItem( m_aCtlPreview.GetOutputSize().Height() / 2 ) ); + + // #i34740# + m_aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet()); + + m_xBtnAdd->connect_clicked(LINK(this, SvxLineEndDefTabPage, ClickAddHdl_Impl)); + m_xBtnModify->connect_clicked(LINK( this, SvxLineEndDefTabPage, ClickModifyHdl_Impl)); + m_xBtnDelete->connect_clicked(LINK( this, SvxLineEndDefTabPage, ClickDeleteHdl_Impl)); + m_xBtnLoad->connect_clicked(LINK( this, SvxLineEndDefTabPage, ClickLoadHdl_Impl)); + m_xBtnSave->connect_clicked(LINK( this, SvxLineEndDefTabPage, ClickSaveHdl_Impl)); + + m_xLbLineEnds->connect_changed(LINK(this, SvxLineEndDefTabPage, SelectLineEndHdl_Impl)); +} + +SvxLineEndDefTabPage::~SvxLineEndDefTabPage() +{ + m_xCtlPreview.reset(); + m_xLbLineEnds.reset(); +} + +void SvxLineEndDefTabPage::Construct() +{ + m_xLbLineEnds->Fill( pLineEndList ); + + bool bCreateArrowPossible = true; + + if( !pPolyObj ) + { + bCreateArrowPossible = false; + } + else if( nullptr == dynamic_cast<const SdrPathObj*>( pPolyObj) ) + { + SdrObjTransformInfoRec aInfoRec; + pPolyObj->TakeObjInfo( aInfoRec ); + SdrObjectUniquePtr pNewObj; + if( aInfoRec.bCanConvToPath ) + pNewObj = pPolyObj->ConvertToPolyObj( true, false ); + + bCreateArrowPossible = nullptr != dynamic_cast<const SdrPathObj*>( pNewObj.get()); + } + + if( !bCreateArrowPossible ) + m_xBtnAdd->set_sensitive(false); +} + +void SvxLineEndDefTabPage::ActivatePage( const SfxItemSet& ) +{ + if( nDlgType != 0 ) // area dialog + return; + + // ActivatePage() is called before the dialog receives PageCreated() !!! + if( !pLineEndList.is() ) + return; + + if( *pPosLineEndLb != -1) + { + m_xLbLineEnds->set_active(*pPosLineEndLb); + SelectLineEndHdl_Impl(); + } + INetURLObject aURL( pLineEndList->GetPath() ); + + aURL.Append( pLineEndList->GetName() ); + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + *pPageType = PageType::Area; // 3 + *pPosLineEndLb = -1; +} + + +DeactivateRC SvxLineEndDefTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + CheckChanges_Impl(); + + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + + +void SvxLineEndDefTabPage::CheckChanges_Impl() +{ + int nPos = m_xLbLineEnds->get_active(); + + if (nPos != -1) + { + OUString aString = m_xEdtName->get_text(); + + if( aString != m_xLbLineEnds->get_active_text() ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querychangelineenddialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskChangeLineEndDialog")); + if (xQueryBox->run() == RET_YES) + ClickModifyHdl_Impl(*m_xBtnModify); + } + } + nPos = m_xLbLineEnds->get_active(); + + if (nPos != -1) + *pPosLineEndLb = nPos; +} + + +bool SvxLineEndDefTabPage::FillItemSet( SfxItemSet* rSet ) +{ + if( nDlgType == 0 ) // line dialog + { + if( *pPageType == PageType::Bitmap ) + { + CheckChanges_Impl(); + + int nPos = m_xLbLineEnds->get_active(); + const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nPos); + + rSet->Put( XLineStartItem( pEntry->GetName(), pEntry->GetLineEnd() ) ); + rSet->Put( XLineEndItem( pEntry->GetName(), pEntry->GetLineEnd() ) ); + } + } + return true; +} + +void SvxLineEndDefTabPage::Reset( const SfxItemSet* ) +{ + m_xLbLineEnds->set_active(0); + + // Update lineend + if( pLineEndList->Count() > 0 ) + { + int nPos = m_xLbLineEnds->get_active(); + + const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nPos); + + m_xEdtName->set_text(m_xLbLineEnds->get_active_text()); + + rXLSet.Put( XLineStartItem( OUString(), pEntry->GetLineEnd() ) ); + rXLSet.Put( XLineEndItem( OUString(), pEntry->GetLineEnd() ) ); + + // #i34740# + m_aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet()); + m_aCtlPreview.Invalidate(); + } + + // determine button state + if( pLineEndList->Count() ) + { + m_xBtnModify->set_sensitive(true); + m_xBtnDelete->set_sensitive(true); + m_xBtnSave->set_sensitive(true); + } + else + { + m_xBtnModify->set_sensitive(false); + m_xBtnDelete->set_sensitive(false); + m_xBtnSave->set_sensitive(false); + } +} + +std::unique_ptr<SfxTabPage> SvxLineEndDefTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxLineEndDefTabPage>(pPage, pController, *rSet ); +} + +void SvxLineEndDefTabPage::SelectLineEndHdl_Impl() +{ + if( pLineEndList->Count() <= 0 ) + return; + + int nPos = m_xLbLineEnds->get_active(); + + const XLineEndEntry* pEntry = pLineEndList->GetLineEnd(nPos); + + m_xEdtName->set_text(m_xLbLineEnds->get_active_text()); + + rXLSet.Put( XLineStartItem( OUString(), pEntry->GetLineEnd() ) ); + rXLSet.Put( XLineEndItem( OUString(), pEntry->GetLineEnd() ) ); + + // #i34740# + m_aCtlPreview.SetLineAttributes(aXLineAttr.GetItemSet()); + m_aCtlPreview.Invalidate(); + + // Is not set before, in order to only take the new style, + // if there is an entry selected in the ListBox + *pPageType = PageType::Bitmap; +} + +IMPL_LINK_NOARG(SvxLineEndDefTabPage, SelectLineEndHdl_Impl, weld::ComboBox&, void) +{ + SelectLineEndHdl_Impl(); +} + +IMPL_LINK_NOARG(SvxLineEndDefTabPage, ClickModifyHdl_Impl, weld::Button&, void) +{ + int nPos = m_xLbLineEnds->get_active(); + if (nPos == -1) + return; + + OUString aDesc(CuiResId(RID_CUISTR_DESC_LINEEND)); + OUString aName(m_xEdtName->get_text()); + tools::Long nCount = pLineEndList->Count(); + bool bDifferent = true; + + // check whether the name is existing already + for ( tools::Long i = 0; i < nCount && bDifferent; i++ ) + if ( aName == pLineEndList->GetLineEnd( i )->GetName() ) + bDifferent = false; + + // if yes, repeat and demand a new name + if ( !bDifferent ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarningBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xWarningBox->run(); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + bool bLoop = true; + + while( !bDifferent && bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + bDifferent = true; + + for( tools::Long i = 0; i < nCount && bDifferent; i++ ) + { + if( aName == pLineEndList->GetLineEnd( i )->GetName() ) + bDifferent = false; + } + + if( bDifferent ) + bLoop = false; + else + xWarningBox->run(); + } + } + + // if not existing, enter the entry + if( !bDifferent ) + return; + + const XLineEndEntry* pOldEntry = pLineEndList->GetLineEnd(nPos); + + if(pOldEntry) + { + // #123497# Need to replace the existing entry with a new one + pLineEndList->Replace(std::make_unique<XLineEndEntry>(pOldEntry->GetLineEnd(), aName), nPos); + + m_xEdtName->set_text(aName); + + m_xLbLineEnds->Modify(*pLineEndList->GetLineEnd(nPos), nPos, pLineEndList->GetUiBitmap(nPos)); + m_xLbLineEnds->set_active(nPos); + + // set flag for modified + *pnLineEndListState |= ChangeType::MODIFIED; + + *pPageType = PageType::Bitmap; + } + else + { + OSL_ENSURE(false, "LineEnd to be modified not existing (!)"); + } +} + +IMPL_LINK_NOARG(SvxLineEndDefTabPage, ClickAddHdl_Impl, weld::Button&, void) +{ + if( pPolyObj ) + { + const SdrObject* pNewObj; + SdrObjectUniquePtr pConvPolyObj; + + if( nullptr != dynamic_cast<const SdrPathObj*>( pPolyObj) ) + { + pNewObj = pPolyObj; + } + else + { + SdrObjTransformInfoRec aInfoRec; + pPolyObj->TakeObjInfo( aInfoRec ); + + if( aInfoRec.bCanConvToPath ) + { + pConvPolyObj = pPolyObj->ConvertToPolyObj( true, false ); + pNewObj = pConvPolyObj.get(); + + if( !pNewObj || nullptr == dynamic_cast<const SdrPathObj*>( pNewObj) ) + return; // cancel, additional safety, which + // has no use for group objects though. + } + else return; // cancel + } + + basegfx::B2DPolyPolygon aNewPolyPolygon(static_cast<const SdrPathObj*>(pNewObj)->GetPathPoly()); + basegfx::B2DRange aNewRange(basegfx::utils::getRange(aNewPolyPolygon)); + + // normalize + aNewPolyPolygon.transform(basegfx::utils::createTranslateB2DHomMatrix( -aNewRange.getMinX(), -aNewRange.getMinY())); + + pConvPolyObj.reset(); + + OUString aNewName(SvxResId(RID_SVXSTR_LINEEND)); + OUString aDesc(CuiResId(RID_CUISTR_DESC_LINEEND)); + OUString aName; + + tools::Long nCount = pLineEndList->Count(); + tools::Long j = 1; + bool bDifferent = false; + + while ( !bDifferent ) + { + aName = aNewName + " " + OUString::number( j++ ); + bDifferent = true; + + for( tools::Long i = 0; i < nCount && bDifferent; i++ ) + if ( aName == pLineEndList->GetLineEnd( i )->GetName() ) + bDifferent = false; + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc )); + bool bLoop = true; + + while ( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + bDifferent = true; + + for( tools::Long i = 0; i < nCount && bDifferent; i++ ) + { + if( aName == pLineEndList->GetLineEnd( i )->GetName() ) + bDifferent = false; + } + + if( bDifferent ) + { + bLoop = false; + + auto nLineEndCount = pLineEndList->Count(); + pLineEndList->Insert(std::make_unique<XLineEndEntry>(aNewPolyPolygon, aName), nLineEndCount); + + // add to the ListBox + m_xLbLineEnds->Append(*pLineEndList->GetLineEnd(nLineEndCount), pLineEndList->GetUiBitmap(nLineEndCount)); + m_xLbLineEnds->set_active(m_xLbLineEnds->get_count() - 1); + + *pnLineEndListState |= ChangeType::MODIFIED; + + SelectLineEndHdl_Impl(); + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarningBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xWarningBox->run(); + } + } + } + else + m_xBtnAdd->set_sensitive(false); + + // determine button state + if ( pLineEndList->Count() ) + { + m_xBtnModify->set_sensitive(true); + m_xBtnDelete->set_sensitive(true); + m_xBtnSave->set_sensitive(true); + } +} + +IMPL_LINK_NOARG(SvxLineEndDefTabPage, ClickDeleteHdl_Impl, weld::Button&, void) +{ + int nPos = m_xLbLineEnds->get_active(); + + if (nPos != -1) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querydeletelineenddialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskDelLineEndDialog")); + + if (xQueryBox->run() == RET_YES) + { + pLineEndList->Remove(nPos); + m_xLbLineEnds->remove(nPos); + m_xLbLineEnds->set_active(0); + + SelectLineEndHdl_Impl(); + *pPageType = PageType::Area; // LineEnd shall not be taken over + + *pnLineEndListState |= ChangeType::MODIFIED; + + m_aCtlPreview.Invalidate(); + } + } + // determine button state + if( !pLineEndList->Count() ) + { + m_xBtnModify->set_sensitive(false); + m_xBtnDelete->set_sensitive(false); + m_xBtnSave->set_sensitive(false); + } +} + +IMPL_LINK_NOARG(SvxLineEndDefTabPage, ClickLoadHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nReturn = RET_YES; + + if ( *pnLineEndListState & ChangeType::MODIFIED ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querysavelistdialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("AskSaveList")); + + nReturn = xBox->run(); + + if ( nReturn == RET_YES ) + pLineEndList->Save(); + } + + if ( nReturn != RET_CANCEL ) + { + ::sfx2::FileDialogHelper aDlg(css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, + FileDialogFlags::NONE, GetFrameWeld()); + OUString aStrFilterType( "*.soe" ); + aDlg.AddFilter( aStrFilterType, aStrFilterType ); + + OUString aPalettePath(SvtPathOptions().GetPalettePath()); + OUString aLastDir; + sal_Int32 nIndex = 0; + do + { + aLastDir = aPalettePath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + INetURLObject aFile(aLastDir); + aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if( aDlg.Execute() == ERRCODE_NONE ) + { + INetURLObject aURL( aDlg.GetPath() ); + INetURLObject aPathURL( aURL ); + + aPathURL.removeSegment(); + aPathURL.removeFinalSlash(); + + XLineEndListRef pLeList = XPropertyList::AsLineEndList( + XPropertyList::CreatePropertyList( + XPropertyListType::LineEnd, + aPathURL.GetMainURL(INetURLObject::DecodeMechanism::NONE), "")); + pLeList->SetName( aURL.getName() ); + if( pLeList->Load() ) + { + pLineEndList = pLeList; + static_cast<SvxLineTabDialog*>(GetDialogController())->SetNewLineEndList( pLineEndList ); + m_xLbLineEnds->clear(); + m_xLbLineEnds->Fill( pLineEndList ); + Reset( &rOutAttrs ); + + pLineEndList->SetName( aURL.getName() ); + + *pnLineEndListState |= ChangeType::CHANGED; + *pnLineEndListState &= ~ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querynoloadedfiledialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("NoLoadedFileDialog")); + xBox->run(); + } + } + } + + // determine button state + if ( pLineEndList->Count() ) + { + m_xBtnModify->set_sensitive(true); + m_xBtnDelete->set_sensitive(true); + m_xBtnSave->set_sensitive(true); + } + else + { + m_xBtnModify->set_sensitive(false); + m_xBtnDelete->set_sensitive(false); + m_xBtnSave->set_sensitive(false); + } +} + +IMPL_LINK_NOARG(SvxLineEndDefTabPage, ClickSaveHdl_Impl, weld::Button&, void) +{ + ::sfx2::FileDialogHelper aDlg(css::ui::dialogs::TemplateDescription::FILESAVE_SIMPLE, FileDialogFlags::NONE, GetFrameWeld()); + OUString aStrFilterType( "*.soe" ); + aDlg.AddFilter( aStrFilterType, aStrFilterType ); + + OUString aPalettePath(SvtPathOptions().GetPalettePath()); + OUString aLastDir; + sal_Int32 nIndex = 0; + do + { + aLastDir = aPalettePath.getToken(0, ';', nIndex); + } + while (nIndex >= 0); + + INetURLObject aFile(aLastDir); + DBG_ASSERT( aFile.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + + if( !pLineEndList->GetName().isEmpty() ) + { + aFile.Append( pLineEndList->GetName() ); + + if( aFile.getExtension().isEmpty() ) + aFile.SetExtension( u"soe" ); + } + + aDlg.SetDisplayDirectory( aFile.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + if ( aDlg.Execute() != ERRCODE_NONE ) + return; + + INetURLObject aURL( aDlg.GetPath() ); + INetURLObject aPathURL( aURL ); + + aPathURL.removeSegment(); + aPathURL.removeFinalSlash(); + + pLineEndList->SetName( aURL.getName() ); + pLineEndList->SetPath( aPathURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + + if( pLineEndList->Save() ) + { + *pnLineEndListState &= ~ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querynosavefiledialog.ui")); + std::unique_ptr<weld::MessageDialog> xBox(xBuilder->weld_message_dialog("NoSaveFileDialog")); + xBox->run(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tppattern.cxx b/cui/source/tabpages/tppattern.cxx new file mode 100644 index 000000000..4976a0a0e --- /dev/null +++ b/cui/source/tabpages/tppattern.cxx @@ -0,0 +1,553 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <memory> +#include <tools/urlobj.hxx> +#include <sfx2/dialoghelper.hxx> +#include <svx/colorbox.hxx> +#include <svx/dialmgr.hxx> +#include <vcl/BitmapTools.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <svx/strings.hrc> + +#include <strings.hrc> +#include <svx/xfillit0.hxx> +#include <svx/xbtmpit.hxx> +#include <svx/xtable.hxx> +#include <svx/xflbmtit.hxx> +#include <cuitabarea.hxx> +#include <svx/svxdlg.hxx> +#include <dialmgr.hxx> +#include <sal/log.hxx> + +using namespace com::sun::star; + +/************************************************************************* +|* Preview control for the display of bitmaps +\************************************************************************/ + +class SvxBitmapCtl +{ +private: + Color aPixelColor, aBackgroundColor; + std::array<sal_uInt8,64> const * pBmpArray; + +public: + // Constructor: BitmapCtl for SvxPixelCtl + SvxBitmapCtl() + : pBmpArray(nullptr) + { + } + + // BitmapCtl: Returns the Bitmap + BitmapEx GetBitmapEx() const + { + if (!pBmpArray) + return BitmapEx(); + return vcl::bitmap::createHistorical8x8FromArray(*pBmpArray, aPixelColor, aBackgroundColor); + } + + void SetBmpArray( std::array<sal_uInt8,64> const & pPixel ) { pBmpArray = &pPixel; } + void SetPixelColor( Color aColor ) { aPixelColor = aColor; } + void SetBackgroundColor( Color aColor ) { aBackgroundColor = aColor; } +}; + +SvxPatternTabPage::SvxPatternTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxTabPage(pPage, pController, "cui/ui/patterntabpage.ui", "PatternTabPage", rInAttrs) + , m_rOutAttrs(rInAttrs) + , m_pnPatternListState(nullptr) + , m_pnColorListState(nullptr) + , m_aXFillAttr(rInAttrs.GetPool()) + , m_rXFSet(m_aXFillAttr.GetItemSet()) + , m_xCtlPixel(new SvxPixelCtl(this)) + , m_xLbColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_COLOR"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xLbBackgroundColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_BACKGROUND_COLOR"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xPatternLB(new SvxPresetListBox(m_xBuilder->weld_scrolled_window("patternpresetlistwin", true))) + , m_xBtnAdd(m_xBuilder->weld_button("BTN_ADD")) + , m_xBtnModify(m_xBuilder->weld_button("BTN_MODIFY")) + , m_xCtlPixelWin(new weld::CustomWeld(*m_xBuilder, "CTL_PIXEL", *m_xCtlPixel)) + , m_xCtlPreview(new weld::CustomWeld(*m_xBuilder, "CTL_PREVIEW", m_aCtlPreview)) + , m_xPatternLBWin(new weld::CustomWeld(*m_xBuilder, "patternpresetlist", *m_xPatternLB)) +{ + // size of the bitmap display + Size aSize = getDrawPreviewOptimalSize(m_aCtlPreview.GetDrawingArea()->get_ref_device()); + m_xPatternLB->set_size_request(aSize.Width(), aSize.Height()); + m_xCtlPreview->set_size_request(aSize.Width(), aSize.Height()); + + m_xBitmapCtl.reset(new SvxBitmapCtl); + + // this page needs ExchangeSupport + SetExchangeSupport(); + + // setting the output device + m_rXFSet.Put( XFillStyleItem(drawing::FillStyle_BITMAP) ); + m_rXFSet.Put( XFillBitmapItem(OUString(), Graphic()) ); + + m_xBtnAdd->connect_clicked( LINK( this, SvxPatternTabPage, ClickAddHdl_Impl ) ); + m_xBtnModify->connect_clicked( LINK( this, SvxPatternTabPage, ClickModifyHdl_Impl ) ); + + m_xPatternLB->SetSelectHdl( LINK( this, SvxPatternTabPage, ChangePatternHdl_Impl ) ); + m_xPatternLB->SetRenameHdl( LINK( this, SvxPatternTabPage, ClickRenameHdl_Impl ) ); + m_xPatternLB->SetDeleteHdl( LINK( this, SvxPatternTabPage, ClickDeleteHdl_Impl ) ); + m_xLbColor->SetSelectHdl( LINK( this, SvxPatternTabPage, ChangeColorHdl_Impl ) ); + m_xLbBackgroundColor->SetSelectHdl( LINK( this, SvxPatternTabPage, ChangeColorHdl_Impl ) ); + + m_xPatternLB->SetStyle(WB_FLATVALUESET | WB_NO_DIRECTSELECT | WB_TABSTOP); +} + +SvxPatternTabPage::~SvxPatternTabPage() +{ + m_xPatternLBWin.reset(); + m_xCtlPreview.reset(); + m_xCtlPixelWin.reset(); + m_xPatternLB.reset(); + m_xLbBackgroundColor.reset(); + m_xLbColor.reset(); + m_xCtlPixel.reset(); +} + +void SvxPatternTabPage::Construct() +{ + m_xPatternLB->FillPresetListBox( *m_pPatternList ); +} + +void SvxPatternTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + if( !m_pColorList.is() ) + return; + + // ColorList + if( *m_pnColorListState & ChangeType::CHANGED || + *m_pnColorListState & ChangeType::MODIFIED ) + { + SvxAreaTabDialog* pArea = (*m_pnColorListState & ChangeType::CHANGED) ? + dynamic_cast<SvxAreaTabDialog*>(GetDialogController()) : nullptr; + if (pArea) + m_pColorList = pArea->GetNewColorList(); + } + + // determining (possibly cutting) the name and + // displaying it in the GroupBox + OUString aString = CuiResId( RID_CUISTR_TABLE ) + ": "; + INetURLObject aURL( m_pPatternList->GetPath() ); + + aURL.Append( m_pPatternList->GetName() ); + SAL_WARN_IF( aURL.GetProtocol() == INetProtocol::NotValid, "cui.tabpages", "invalid URL" ); + + if( aURL.getBase().getLength() > 18 ) + { + aString += OUString::Concat(aURL.getBase().subView( 0, 15 )) + "..."; + } + else + aString += aURL.getBase(); + + XFillBitmapItem aItem( rSet.Get( XATTR_FILLBITMAP ) ); + + if ( aItem.isPattern() ) + { + sal_Int32 nPos = SearchPatternList( aItem.GetName() ); + if ( nPos != -1) + { + sal_uInt16 nId = m_xPatternLB->GetItemId( static_cast<size_t>( nPos ) ); + m_xPatternLB->SelectItem( nId ); + } + } + else + m_xPatternLB->SelectItem( m_xPatternLB->GetItemId( static_cast<size_t>( 0 ) ) ); +} + + +DeactivateRC SvxPatternTabPage::DeactivatePage( SfxItemSet* _pSet) +{ + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + + +bool SvxPatternTabPage::FillItemSet( SfxItemSet* _rOutAttrs ) +{ + _rOutAttrs->Put(XFillStyleItem(drawing::FillStyle_BITMAP)); + size_t nPos = m_xPatternLB->IsNoSelection() ? VALUESET_ITEM_NOTFOUND : m_xPatternLB->GetSelectItemPos(); + if(VALUESET_ITEM_NOTFOUND != nPos) + { + const XBitmapEntry* pXBitmapEntry = m_pPatternList->GetBitmap( static_cast<sal_uInt16>(nPos) ); + const OUString aString( m_xPatternLB->GetItemText( m_xPatternLB->GetSelectedItemId() ) ); + + _rOutAttrs->Put(XFillBitmapItem(aString, pXBitmapEntry->GetGraphicObject())); + } + else + { + const BitmapEx aBitmapEx(m_xBitmapCtl->GetBitmapEx()); + + _rOutAttrs->Put(XFillBitmapItem(OUString(), Graphic(aBitmapEx))); + } + _rOutAttrs->Put(XFillBmpTileItem(true)); + return true; +} + + +void SvxPatternTabPage::Reset( const SfxItemSet* ) +{ + m_xBitmapCtl->SetPixelColor( m_xLbColor->GetSelectEntryColor() ); + m_xBitmapCtl->SetBackgroundColor( m_xLbBackgroundColor->GetSelectEntryColor() ); + m_xBitmapCtl->SetBmpArray( m_xCtlPixel->GetBitmapPixelPtr() ); + + // get bitmap and display it + const XFillBitmapItem aBmpItem(OUString(), Graphic(m_xBitmapCtl->GetBitmapEx())); + if(aBmpItem.isPattern()) + { + m_rXFSet.Put( aBmpItem ); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); + } + + ChangePatternHdl_Impl(m_xPatternLB.get()); + + // determine button state + if( m_pPatternList.is() && m_pPatternList->Count() ) + { + m_xBtnAdd->set_sensitive(true); + m_xBtnModify->set_sensitive(true); + } + else + { + m_xBtnModify->set_sensitive(false); + } +} + +std::unique_ptr<SfxTabPage> SvxPatternTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rSet ) +{ + return std::make_unique<SvxPatternTabPage>(pPage, pController, *rSet); +} + +IMPL_LINK_NOARG(SvxPatternTabPage, ChangePatternHdl_Impl, ValueSet*, void) +{ + std::unique_ptr<GraphicObject> pGraphicObject; + size_t nPos = m_xPatternLB->GetSelectItemPos(); + + if(VALUESET_ITEM_NOTFOUND != nPos) + { + pGraphicObject.reset(new GraphicObject(m_pPatternList->GetBitmap( static_cast<sal_uInt16>(nPos) )->GetGraphicObject())); + } + else + { + if(const XFillStyleItem* pFillStyleItem = m_rOutAttrs.GetItemIfSet(GetWhich(XATTR_FILLSTYLE))) + { + const drawing::FillStyle eXFS(pFillStyleItem->GetValue()); + + const XFillBitmapItem* pBitmapItem; + if((drawing::FillStyle_BITMAP == eXFS) && (pBitmapItem = m_rOutAttrs.GetItemIfSet(GetWhich(XATTR_FILLBITMAP)))) + { + pGraphicObject.reset(new GraphicObject(pBitmapItem->GetGraphicObject())); + } + } + + if(!pGraphicObject) + { + sal_uInt16 nPosition = m_xPatternLB->GetItemId( 0 ); + m_xPatternLB->SelectItem( nPosition ); + if( nPosition != 0 ) + { + pGraphicObject.reset(new GraphicObject(m_pPatternList->GetBitmap(0)->GetGraphicObject())); + } + } + } + + if(!pGraphicObject) + return; + + Color aBackColor; + Color aPixelColor; + bool bIs8x8(vcl::bitmap::isHistorical8x8(pGraphicObject->GetGraphic().GetBitmapEx(), aBackColor, aPixelColor)); + + m_xLbColor->SetNoSelection(); + m_xLbBackgroundColor->SetNoSelection(); + + if(bIs8x8) + { + m_xCtlPixel->SetPaintable( true ); + m_xBtnModify->set_sensitive(true); + m_xBtnAdd->set_sensitive(true); + + // setting the pixel control + + m_xCtlPixel->SetXBitmap(pGraphicObject->GetGraphic().GetBitmapEx()); + + m_xLbColor->SelectEntry( aPixelColor ); + m_xLbBackgroundColor->SelectEntry( aBackColor ); + + // update m_xBitmapCtl, rXFSet and m_aCtlPreview + m_xBitmapCtl->SetPixelColor( aPixelColor ); + m_xBitmapCtl->SetBackgroundColor( aBackColor ); + m_rXFSet.ClearItem(); + m_rXFSet.Put(XFillStyleItem(drawing::FillStyle_BITMAP)); + m_rXFSet.Put(XFillBitmapItem(OUString(), Graphic(m_xBitmapCtl->GetBitmapEx()))); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); + } + else + { + m_xCtlPixel->Reset(); + m_xCtlPixel->SetPaintable( false ); + m_xBtnModify->set_sensitive(false); + m_xBtnAdd->set_sensitive(false); + } + + m_xCtlPixel->Invalidate(); +} + +IMPL_LINK_NOARG(SvxPatternTabPage, ClickAddHdl_Impl, weld::Button&, void) +{ + + OUString aNewName( SvxResId( RID_SVXSTR_PATTERN_UNTITLED ) ); + OUString aDesc( CuiResId( RID_CUISTR_DESC_NEW_PATTERN ) ); + OUString aName; + + tools::Long nCount = m_pPatternList->Count(); + tools::Long j = 1; + bool bValidPatternName = false; + + while( !bValidPatternName ) + { + aName = aNewName + " " + OUString::number( j++ ); + bValidPatternName = (SearchPatternList(aName) == -1); + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + sal_uInt16 nError(1); + + while( pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + + bValidPatternName = (SearchPatternList(aName) == -1); + + if( bValidPatternName ) { + nError = 0; + break; + } + + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarnBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + if (xWarnBox->run() != RET_OK) + break; + } + + pDlg.disposeAndClear(); + + if( !nError ) + { + std::unique_ptr<XBitmapEntry> pEntry; + if( m_xCtlPixel->IsEnabled() ) + { + const BitmapEx aBitmapEx(m_xBitmapCtl->GetBitmapEx()); + + pEntry.reset(new XBitmapEntry(Graphic(aBitmapEx), aName)); + } + else // it must be a not existing imported bitmap + { + if(const XFillBitmapItem* pFillBmpItem = m_rOutAttrs.GetItemIfSet(XATTR_FILLBITMAP)) + { + pEntry.reset(new XBitmapEntry(pFillBmpItem->GetGraphicObject(), aName)); + } + else + assert(!"SvxPatternTabPage::ClickAddHdl_Impl(), XBitmapEntry* pEntry == nullptr ?"); + } + + if( pEntry ) + { + m_pPatternList->Insert(std::move(pEntry), nCount); + sal_Int32 nId = m_xPatternLB->GetItemId( nCount - 1 ); + BitmapEx aBitmap = m_pPatternList->GetBitmapForPreview( nCount, m_xPatternLB->GetIconSize() ); + m_xPatternLB->InsertItem( nId + 1, Image(aBitmap), aName ); + m_xPatternLB->SelectItem( nId + 1 ); + m_xPatternLB->Resize(); + + *m_pnPatternListState |= ChangeType::MODIFIED; + + ChangePatternHdl_Impl(m_xPatternLB.get()); + } + } + + // determine button state + if( m_pPatternList->Count() ) + { + m_xBtnModify->set_sensitive(true); + } +} + +IMPL_LINK_NOARG(SvxPatternTabPage, ClickModifyHdl_Impl, weld::Button&, void) +{ + sal_uInt16 nId = m_xPatternLB->GetSelectedItemId(); + size_t nPos = m_xPatternLB->GetSelectItemPos(); + + if ( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aName( m_pPatternList->GetBitmap( static_cast<sal_uInt16>(nPos) )->GetName() ); + + const BitmapEx aBitmapEx(m_xBitmapCtl->GetBitmapEx()); + + // #i123497# Need to replace the existing entry with a new one (old returned needs to be deleted) + m_pPatternList->Replace(std::make_unique<XBitmapEntry>(Graphic(aBitmapEx), aName), nPos); + + BitmapEx aBitmap = m_pPatternList->GetBitmapForPreview( static_cast<sal_uInt16>( nPos ), m_xPatternLB->GetIconSize() ); + m_xPatternLB->RemoveItem(nId); + m_xPatternLB->InsertItem( nId, Image(aBitmap), aName, static_cast<sal_uInt16>(nPos) ); + m_xPatternLB->SelectItem( nId ); + + *m_pnPatternListState |= ChangeType::MODIFIED; +} + + +IMPL_LINK_NOARG(SvxPatternTabPage, ClickRenameHdl_Impl, SvxPresetListBox*, void) +{ + size_t nPos = m_xPatternLB->GetSelectItemPos(); + sal_Int32 nId = m_xPatternLB->GetSelectedItemId(); + + if ( nPos == VALUESET_ITEM_NOTFOUND ) + return; + + OUString aDesc(CuiResId(RID_CUISTR_DESC_NEW_PATTERN)); + OUString aName(m_pPatternList->GetBitmap(nPos)->GetName()); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxNameDialog> pDlg(pFact->CreateSvxNameDialog(GetFrameWeld(), aName, aDesc)); + + bool bLoop = true; + + while( bLoop && pDlg->Execute() == RET_OK ) + { + pDlg->GetName( aName ); + sal_Int32 nPatternPos = SearchPatternList(aName); + bool bValidPatternName = (nPatternPos == static_cast<sal_Int32>(nPos) ) || (nPatternPos == -1); + + if( bValidPatternName ) + { + bLoop = false; + + m_pPatternList->GetBitmap(nPos)->SetName(aName); + + m_xPatternLB->SetItemText( nId, aName ); + m_xPatternLB->SelectItem( nId ); + + *m_pnPatternListState |= ChangeType::MODIFIED; + } + else + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/queryduplicatedialog.ui")); + std::unique_ptr<weld::MessageDialog> xWarnBox(xBuilder->weld_message_dialog("DuplicateNameDialog")); + xWarnBox->run(); + } + } +} + +IMPL_LINK_NOARG(SvxPatternTabPage, ClickDeleteHdl_Impl, SvxPresetListBox*, void) +{ + sal_uInt16 nId = m_xPatternLB->GetSelectedItemId(); + size_t nPos = m_xPatternLB->GetSelectItemPos(); + + if( nPos != VALUESET_ITEM_NOTFOUND ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetFrameWeld(), "cui/ui/querydeletebitmapdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQueryBox(xBuilder->weld_message_dialog("AskDelBitmapDialog")); + if (xQueryBox->run() == RET_YES) + { + m_pPatternList->Remove(nPos); + m_xPatternLB->RemoveItem( nId ); + nId = m_xPatternLB->GetItemId(0); + m_xPatternLB->SelectItem( nId ); + m_xPatternLB->Resize(); + + m_aCtlPreview.Invalidate(); + m_xCtlPixel->Invalidate(); + + ChangePatternHdl_Impl(m_xPatternLB.get()); + + *m_pnPatternListState |= ChangeType::MODIFIED; + } + } + // determine button state + if( !m_pPatternList->Count() ) + { + m_xBtnModify->set_sensitive(false); + } +} + +IMPL_LINK_NOARG(SvxPatternTabPage, ChangeColorHdl_Impl, ColorListBox&, void) +{ + ChangeColor_Impl(); + m_xPatternLB->SetNoSelection(); +} + +void SvxPatternTabPage::ChangeColor_Impl() +{ + m_xCtlPixel->SetPixelColor( m_xLbColor->GetSelectEntryColor() ); + m_xCtlPixel->SetBackgroundColor( m_xLbBackgroundColor->GetSelectEntryColor() ); + m_xCtlPixel->Invalidate(); + + m_xBitmapCtl->SetPixelColor( m_xLbColor->GetSelectEntryColor() ); + m_xBitmapCtl->SetBackgroundColor( m_xLbBackgroundColor->GetSelectEntryColor() ); + + // get bitmap and display it + m_rXFSet.Put(XFillBitmapItem(OUString(), Graphic(m_xBitmapCtl->GetBitmapEx()))); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); +} + +void SvxPatternTabPage::PointChanged(weld::DrawingArea* pDrawingArea, RectPoint) +{ + if (pDrawingArea == m_xCtlPixel->GetDrawingArea()) + { + m_xBitmapCtl->SetBmpArray(m_xCtlPixel->GetBitmapPixelPtr()); + + // get bitmap and display it + m_rXFSet.Put(XFillBitmapItem(OUString(), Graphic(m_xBitmapCtl->GetBitmapEx()))); + m_aCtlPreview.SetAttributes( m_aXFillAttr.GetItemSet() ); + m_aCtlPreview.Invalidate(); + } + + m_xPatternLB->SetNoSelection(); +} + +sal_Int32 SvxPatternTabPage::SearchPatternList(std::u16string_view rPatternName) +{ + tools::Long nCount = m_pPatternList->Count(); + bool bValidPatternName = true; + sal_Int32 nPos = -1; + + for(tools::Long i = 0;i < nCount && bValidPatternName;i++) + { + if(rPatternName == m_pPatternList->GetBitmap( i )->GetName()) + { + nPos = i; + bValidPatternName = false; + } + } + return nPos; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tpshadow.cxx b/cui/source/tabpages/tpshadow.cxx new file mode 100644 index 000000000..795a57f13 --- /dev/null +++ b/cui/source/tabpages/tpshadow.cxx @@ -0,0 +1,515 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <svx/colorbox.hxx> +#include <svx/svxids.hrc> +#include <svtools/unitconv.hxx> + +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xbtmpit.hxx> +#include <svx/sdmetitm.hxx> +#include <svx/sdooitm.hxx> +#include <svx/sdprcitm.hxx> +#include <svx/sdshcitm.hxx> +#include <svx/sdshitm.hxx> +#include <svx/sdshtitm.hxx> +#include <svx/sdsxyitm.hxx> +#include <svx/drawitem.hxx> +#include <svx/xfltrit.hxx> +#include <cuitabarea.hxx> +#include <svx/dlgutil.hxx> +#include <cuitabline.hxx> + +using namespace com::sun::star; + +const WhichRangesContainer SvxShadowTabPage::pShadowRanges(svl::Items< + SDRATTR_SHADOWCOLOR, SDRATTR_SHADOWTRANSPARENCE, + SDRATTR_SHADOWBLUR, SDRATTR_SHADOWBLUR, + SID_ATTR_FILL_SHADOW, SID_ATTR_FILL_SHADOW, + SID_ATTR_SHADOW_BLUR, SID_ATTR_SHADOW_BLUR, + SID_ATTR_SHADOW_TRANSPARENCE, SID_ATTR_SHADOW_YDISTANCE +>); + +SvxShadowTabPage::SvxShadowTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxTabPage(pPage, pController, "cui/ui/shadowtabpage.ui", "ShadowTabPage", rInAttrs) + , m_rOutAttrs(rInAttrs) + , m_pnColorListState(nullptr) + , m_nPageType(PageType::Area) + , m_nDlgType(0) + , m_aXFillAttr(rInAttrs.GetPool()) + , m_rXFSet(m_aXFillAttr.GetItemSet()) + , m_aCtlPosition(this) + , m_xTsbShowShadow(m_xBuilder->weld_check_button("TSB_SHOW_SHADOW")) + , m_xGridShadow(m_xBuilder->weld_widget("gridSHADOW")) + , m_xMtrDistance(m_xBuilder->weld_metric_spin_button("MTR_FLD_DISTANCE", FieldUnit::CM)) + , m_xLbShadowColor(new ColorListBox(m_xBuilder->weld_menu_button("LB_SHADOW_COLOR"), + [this]{ return GetDialogController()->getDialog(); })) + , m_xMtrTransparent(m_xBuilder->weld_metric_spin_button("MTR_SHADOW_TRANSPARENT", FieldUnit::PERCENT)) + , m_xLbShadowBlurMetric(m_xBuilder->weld_metric_spin_button("LB_SHADOW_BLUR", FieldUnit::POINT)) + , m_xCtlPosition(new weld::CustomWeld(*m_xBuilder, "CTL_POSITION", m_aCtlPosition)) + , m_xCtlXRectPreview(new weld::CustomWeld(*m_xBuilder, "CTL_COLOR_PREVIEW", m_aCtlXRectPreview)) +{ + // this page needs ExchangeSupport + SetExchangeSupport(); + + // adjust metric + FieldUnit eFUnit = GetModuleFieldUnit( rInAttrs ); + + switch ( eFUnit ) + { + case FieldUnit::M: + case FieldUnit::KM: + eFUnit = FieldUnit::MM; + break; + default: ;//prevent warning + } + SetFieldUnit( *m_xMtrDistance, eFUnit ); + + // determine PoolUnit + SfxItemPool* pPool = m_rOutAttrs.GetPool(); + DBG_ASSERT( pPool, "Where is the pool?" ); + m_ePoolUnit = pPool->GetMetric( SDRATTR_SHADOWXDIST ); + + // setting the output device + drawing::FillStyle eXFS = drawing::FillStyle_SOLID; + if( m_rOutAttrs.GetItemState( XATTR_FILLSTYLE ) != SfxItemState::DONTCARE ) + { + eXFS = m_rOutAttrs.Get( GetWhich( XATTR_FILLSTYLE ) ).GetValue(); + switch( eXFS ) + { + case drawing::FillStyle_SOLID: + if( SfxItemState::DONTCARE != m_rOutAttrs.GetItemState( XATTR_FILLCOLOR ) ) + { + m_rXFSet.Put( m_rOutAttrs.Get( XATTR_FILLCOLOR ) ); + } + break; + + case drawing::FillStyle_GRADIENT: + if( SfxItemState::DONTCARE != m_rOutAttrs.GetItemState( XATTR_FILLGRADIENT ) ) + { + m_rXFSet.Put( m_rOutAttrs.Get( XATTR_FILLGRADIENT ) ); + } + break; + + case drawing::FillStyle_HATCH: + if( SfxItemState::DONTCARE != m_rOutAttrs.GetItemState( XATTR_FILLHATCH ) ) + { + m_rXFSet.Put( m_rOutAttrs.Get( XATTR_FILLHATCH ) ); + } + break; + + case drawing::FillStyle_BITMAP: + { + if( SfxItemState::DONTCARE != m_rOutAttrs.GetItemState( XATTR_FILLBITMAP ) ) + { + m_rXFSet.Put( m_rOutAttrs.Get( XATTR_FILLBITMAP ) ); + } + } + break; + case drawing::FillStyle_NONE : break; + default: break; + } + } + else + { + m_rXFSet.Put( XFillColorItem( OUString(), COL_LIGHTRED ) ); + } + + if(drawing::FillStyle_NONE == eXFS) + { + // #i96350# + // fallback to solid fillmode when no fill mode is provided to have + // a reasonable shadow preview. The used color will be a set one or + // the default (currently blue8) + eXFS = drawing::FillStyle_SOLID; + } + + m_rXFSet.Put( XFillStyleItem( eXFS ) ); + m_aCtlXRectPreview.SetRectangleAttributes(m_aXFillAttr.GetItemSet()); + + m_xTsbShowShadow->connect_toggled(LINK( this, SvxShadowTabPage, ClickShadowHdl_Impl)); + m_xLbShadowColor->SetSelectHdl( LINK( this, SvxShadowTabPage, SelectShadowHdl_Impl ) ); + Link<weld::MetricSpinButton&,void> aLink = LINK( this, SvxShadowTabPage, ModifyShadowHdl_Impl ); + m_xLbShadowBlurMetric->connect_value_changed(aLink); + m_xMtrTransparent->connect_value_changed(aLink); + m_xMtrDistance->connect_value_changed(aLink); +} + +SvxShadowTabPage::~SvxShadowTabPage() +{ + m_xCtlXRectPreview.reset(); + m_xLbShadowColor.reset(); + m_xCtlPosition.reset(); + m_xLbShadowBlurMetric.reset(); +} + +void SvxShadowTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + const SfxUInt16Item* pPageTypeItem = rSet.GetItem<SfxUInt16Item>(SID_PAGE_TYPE, false); + if (pPageTypeItem) + SetPageType(static_cast<PageType>(pPageTypeItem->GetValue())); + + if( m_nDlgType != 0 ) + return; + + if( !m_pColorList.is() ) + return; + + // ColorList + if( *m_pnColorListState & ChangeType::CHANGED || + *m_pnColorListState & ChangeType::MODIFIED ) + { + if( *m_pnColorListState & ChangeType::CHANGED ) + { + SvxAreaTabDialog* pArea = dynamic_cast<SvxAreaTabDialog*>(GetDialogController()); + if( pArea ) + { + m_pColorList = pArea->GetNewColorList(); + } + else + { + SvxLineTabDialog* pLine = dynamic_cast<SvxLineTabDialog*>(GetDialogController()); + if( pLine ) + m_pColorList = pLine->GetNewColorList(); + } + } + + SfxItemSet rAttribs( rSet ); + // rSet contains shadow attributes too, but we want + // to use it for updating rectangle attributes only, + // so set the shadow to none here + SdrOnOffItem aItem( makeSdrShadowItem( false )); + rAttribs.Put( aItem ); + + m_aCtlXRectPreview.SetRectangleAttributes( rAttribs ); + ModifyShadowHdl_Impl( *m_xMtrTransparent ); + } + m_nPageType = PageType::Shadow; +} + + +DeactivateRC SvxShadowTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + FillItemSet( _pSet ); + + return DeactivateRC::LeavePage; +} + + +bool SvxShadowTabPage::FillItemSet( SfxItemSet* rAttrs ) +{ + bool bModified = false; + + const SfxPoolItem* pOld = nullptr; + + if (m_xTsbShowShadow->get_state_changed_from_saved()) + { + TriState eState = m_xTsbShowShadow->get_state(); + assert(eState != TRISTATE_INDET); + // given how m_xTsbShowShadow is set up and saved in Reset(), + // eState == TRISTATE_INDET would imply + // !IsValueChangedFromSaved() + SdrOnOffItem aItem( makeSdrShadowItem(eState == TRISTATE_TRUE) ); + pOld = GetOldItem( *rAttrs, SDRATTR_SHADOW ); + if ( !pOld || !( *static_cast<const SdrOnOffItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + // shadow removal + // a bit intricate inquiry whether there was something changed, + // as the items can't be displayed directly on controls + sal_Int32 nX = 0, nY = 0; + sal_Int32 nXY = GetCoreValue( *m_xMtrDistance, m_ePoolUnit ); + + switch (m_aCtlPosition.GetActualRP()) + { + case RectPoint::LT: nX = nY = -nXY; break; + case RectPoint::MT: nY = -nXY; break; + case RectPoint::RT: nX = nXY; nY = -nXY; break; + case RectPoint::LM: nX = -nXY; break; + case RectPoint::RM: nX = nXY; break; + case RectPoint::LB: nX = -nXY; nY = nXY; break; + case RectPoint::MB: nY = nXY; break; + case RectPoint::RB: nX = nY = nXY; break; + case RectPoint::MM: break; + } + + // If the values of the shadow distances==SfxItemState::DONTCARE and the displayed + // string in the respective MetricField=="", then the comparison of the old + // and the new distance values would return a wrong result because in such a + // case the new distance values would match the default values of the MetricField !!!! + if ( !m_xMtrDistance->get_text().isEmpty() || + m_rOutAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SfxItemState::DONTCARE || + m_rOutAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SfxItemState::DONTCARE ) + { + sal_Int32 nOldX = 9876543; // impossible value, so DontCare + sal_Int32 nOldY = 9876543; + if( m_rOutAttrs.GetItemState( SDRATTR_SHADOWXDIST ) != SfxItemState::DONTCARE && + m_rOutAttrs.GetItemState( SDRATTR_SHADOWYDIST ) != SfxItemState::DONTCARE ) + { + nOldX = m_rOutAttrs.Get( SDRATTR_SHADOWXDIST ).GetValue(); + nOldY = m_rOutAttrs.Get( SDRATTR_SHADOWYDIST ).GetValue(); + } + SdrMetricItem aXItem( makeSdrShadowXDistItem(nX) ); + pOld = GetOldItem( *rAttrs, SDRATTR_SHADOWXDIST ); + if ( nX != nOldX && + ( !pOld || !( *static_cast<const SdrMetricItem*>(pOld) == aXItem ) ) ) + { + rAttrs->Put( aXItem ); + bModified = true; + } + SdrMetricItem aYItem( makeSdrShadowYDistItem(nY) ); + pOld = GetOldItem( *rAttrs, SDRATTR_SHADOWYDIST ); + if ( nY != nOldY && + ( !pOld || !( *static_cast<const SdrMetricItem*>(pOld) == aYItem ) ) ) + { + rAttrs->Put( aYItem ); + bModified = true; + } + } + + // ShadowColor + { + XColorItem aItem(makeSdrShadowColorItem(m_xLbShadowColor->GetSelectEntryColor())); + pOld = GetOldItem( *rAttrs, SDRATTR_SHADOWCOLOR ); + if ( !pOld || !( *static_cast<const XColorItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + // transparency + sal_uInt16 nVal = static_cast<sal_uInt16>(m_xMtrTransparent->get_value(FieldUnit::PERCENT)); + if (m_xMtrTransparent->get_value_changed_from_saved()) + { + SdrPercentItem aItem( makeSdrShadowTransparenceItem(nVal) ); + pOld = GetOldItem( *rAttrs, SDRATTR_SHADOWTRANSPARENCE ); + if ( !pOld || !( *static_cast<const SdrPercentItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + if (m_xLbShadowBlurMetric->get_value_changed_from_saved()) + { + SdrMetricItem aItem(SDRATTR_SHADOWBLUR, m_xLbShadowBlurMetric->get_value(FieldUnit::MM_100TH)); + pOld = GetOldItem( *rAttrs, SDRATTR_SHADOWBLUR ); + if ( !pOld || !( *static_cast<const SdrMetricItem*>(pOld) == aItem ) ) + { + rAttrs->Put( aItem ); + bModified = true; + } + } + + rAttrs->Put (CntUInt16Item(SID_PAGE_TYPE, static_cast<sal_uInt16>(m_nPageType))); + + return bModified; +} + + +void SvxShadowTabPage::Reset( const SfxItemSet* rAttrs ) +{ + // all objects can have a shadow + // at the moment there are only 8 possible positions where a shadow can be set + + // has a shadow been set? + if( rAttrs->GetItemState( SDRATTR_SHADOW ) != SfxItemState::DONTCARE ) + { + if( rAttrs->Get( SDRATTR_SHADOW ).GetValue() ) + m_xTsbShowShadow->set_state(TRISTATE_TRUE); + else + { + m_xTsbShowShadow->set_state(TRISTATE_FALSE); + } + } + else + m_xTsbShowShadow->set_state(TRISTATE_INDET); + + // distance (only 8 possible positions), + // so there is only one item evaluated + + if( rAttrs->GetItemState( SDRATTR_SHADOWXDIST ) != SfxItemState::DONTCARE && + rAttrs->GetItemState( SDRATTR_SHADOWYDIST ) != SfxItemState::DONTCARE ) + { + sal_Int32 nX = rAttrs->Get( SDRATTR_SHADOWXDIST ).GetValue(); + sal_Int32 nY = rAttrs->Get( SDRATTR_SHADOWYDIST ).GetValue(); + + if( nX != 0 ) + SetMetricValue( *m_xMtrDistance, nX < 0 ? -nX : nX, m_ePoolUnit ); + else + SetMetricValue( *m_xMtrDistance, nY < 0 ? -nY : nY, m_ePoolUnit ); + + // setting the shadow control + if ( nX < 0 && nY < 0 ) m_aCtlPosition.SetActualRP( RectPoint::LT ); + else if( nX == 0 && nY < 0 ) m_aCtlPosition.SetActualRP( RectPoint::MT ); + else if( nX > 0 && nY < 0 ) m_aCtlPosition.SetActualRP( RectPoint::RT ); + else if( nX < 0 && nY == 0 ) m_aCtlPosition.SetActualRP( RectPoint::LM ); + // there's no center point anymore + else if( nX == 0 && nY == 0 ) m_aCtlPosition.SetActualRP( RectPoint::RB ); + else if( nX > 0 && nY == 0 ) m_aCtlPosition.SetActualRP( RectPoint::RM ); + else if( nX < 0 && nY > 0 ) m_aCtlPosition.SetActualRP( RectPoint::LB ); + else if( nX == 0 && nY > 0 ) m_aCtlPosition.SetActualRP( RectPoint::MB ); + else if( nX > 0 && nY > 0 ) m_aCtlPosition.SetActualRP( RectPoint::RB ); + } + else + { + // determine default-distance + SfxItemPool* pPool = m_rOutAttrs.GetPool(); + { + sal_Int32 n = pPool->GetDefaultItem(SDRATTR_SHADOWXDIST).GetValue(); + if (n == 0) + n = pPool->GetDefaultItem(SDRATTR_SHADOWYDIST).GetValue(); + SetMetricValue(*m_xMtrDistance, std::abs(n), m_ePoolUnit); + } + + // Tristate, e. g. multiple objects have been marked of which some have a shadow and some don't. + // The text (which shall be displayed) of the MetricFields is set to "" and serves as an + // identification in the method FillItemSet for the fact that the distance value was NOT changed !!!! + m_xMtrDistance->set_text( "" ); + m_aCtlPosition.SetActualRP( RectPoint::MM ); + } + + if( rAttrs->GetItemState( SDRATTR_SHADOWCOLOR ) != SfxItemState::DONTCARE ) + { + m_xLbShadowColor->SelectEntry( rAttrs->Get( SDRATTR_SHADOWCOLOR ).GetColorValue() ); + } + else + m_xLbShadowColor->SetNoSelection(); + + if( rAttrs->GetItemState( SDRATTR_SHADOWTRANSPARENCE ) != SfxItemState::DONTCARE ) + { + sal_uInt16 nTransp = rAttrs->Get( SDRATTR_SHADOWTRANSPARENCE ).GetValue(); + m_xMtrTransparent->set_value(nTransp, FieldUnit::PERCENT); + } + else + m_xMtrTransparent->set_text(""); + + if( rAttrs->GetItemState( SDRATTR_SHADOWBLUR ) != SfxItemState::DONTCARE ) + { + sal_uInt16 nBlur = rAttrs->Get( SDRATTR_SHADOWBLUR ).GetValue(); + m_xLbShadowBlurMetric->set_value(nBlur, FieldUnit::MM_100TH); + } + else + m_xLbShadowBlurMetric->set_text(""); + + //aCtlPosition + m_xMtrDistance->save_value(); + m_xLbShadowColor->SaveValue(); + m_xTsbShowShadow->save_state(); + m_xLbShadowBlurMetric->save_value(); + + // #66832# This field was not saved, but used to determine changes. + // Why? Seems to be the error. + // It IS the error. + m_xMtrTransparent->save_value(); + + ClickShadowHdl_Impl(*m_xTsbShowShadow); + ModifyShadowHdl_Impl(*m_xMtrTransparent); +} + +std::unique_ptr<SfxTabPage> SvxShadowTabPage::Create( weld::Container* pPage, weld::DialogController* pController, + const SfxItemSet* rAttrs ) +{ + return std::make_unique<SvxShadowTabPage>(pPage, pController, *rAttrs); +} + +IMPL_LINK_NOARG(SvxShadowTabPage, ClickShadowHdl_Impl, weld::Toggleable&, void) +{ + if (m_xTsbShowShadow->get_state() == TRISTATE_FALSE) + { + m_xGridShadow->set_sensitive(false); + m_xCtlPosition->set_sensitive(false); + } + else + { + m_xGridShadow->set_sensitive(true); + m_xCtlPosition->set_sensitive(true); + } + m_aCtlPosition.Invalidate(); + ModifyShadowHdl_Impl(*m_xMtrTransparent); +} + +IMPL_LINK_NOARG(SvxShadowTabPage, SelectShadowHdl_Impl, ColorListBox&, void) +{ + ModifyShadowHdl_Impl(*m_xMtrTransparent); +} + +IMPL_LINK_NOARG(SvxShadowTabPage, ModifyShadowHdl_Impl, weld::MetricSpinButton&, void) +{ + if (m_xTsbShowShadow->get_state() == TRISTATE_TRUE) + m_rXFSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) ); + else + m_rXFSet.Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + + m_rXFSet.Put( XFillColorItem( OUString(), m_xLbShadowColor->GetSelectEntryColor() ) ); + sal_uInt16 nVal = static_cast<sal_uInt16>(m_xMtrTransparent->get_value(FieldUnit::PERCENT)); + m_rXFSet.Put( XFillTransparenceItem( nVal ) ); + + // shadow removal + sal_Int32 nX = 0, nY = 0; + sal_Int32 nXY = GetCoreValue( *m_xMtrDistance, m_ePoolUnit ); + switch( m_aCtlPosition.GetActualRP() ) + { + case RectPoint::LT: nX = nY = -nXY; break; + case RectPoint::MT: nY = -nXY; break; + case RectPoint::RT: nX = nXY; nY = -nXY; break; + case RectPoint::LM: nX = -nXY; break; + case RectPoint::RM: nX = nXY; break; + case RectPoint::LB: nX = -nXY; nY = nXY; break; + case RectPoint::MB: nY = nXY; break; + case RectPoint::RB: nX = nY = nXY; break; + case RectPoint::MM: break; + } + + m_aCtlXRectPreview.SetShadowPosition(Point(nX, nY)); + + m_aCtlXRectPreview.SetShadowAttributes(m_aXFillAttr.GetItemSet()); + m_aCtlXRectPreview.Invalidate(); +} + +void SvxShadowTabPage::PointChanged( weld::DrawingArea*, RectPoint ) +{ + // repaint shadow + ModifyShadowHdl_Impl( *m_xMtrTransparent ); +} + +void SvxShadowTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SvxColorListItem* pColorListItem = aSet.GetItem<SvxColorListItem>(SID_COLOR_TABLE, false); + const SfxUInt16Item* pPageTypeItem = aSet.GetItem<SfxUInt16Item>(SID_PAGE_TYPE, false); + const SfxUInt16Item* pDlgTypeItem = aSet.GetItem<SfxUInt16Item>(SID_DLG_TYPE, false); + + if (pColorListItem) + SetColorList(pColorListItem->GetColorList()); + if (pPageTypeItem) + SetPageType(static_cast<PageType>(pPageTypeItem->GetValue())); + if (pDlgTypeItem) + SetDlgType(pDlgTypeItem->GetValue()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/tptrans.cxx b/cui/source/tabpages/tptrans.cxx new file mode 100644 index 000000000..75180022f --- /dev/null +++ b/cui/source/tabpages/tptrans.cxx @@ -0,0 +1,519 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <svx/svxids.hrc> + +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/xflftrit.hxx> +#include <svx/xflgrit.hxx> +#include <svx/xflhtit.hxx> +#include <svx/xbtmpit.hxx> +#include <svx/xflbckit.hxx> +#include <svx/sdshtitm.hxx> +#include <svx/xfltrit.hxx> +#include <cuitabarea.hxx> +#include <svl/intitem.hxx> + +using namespace com::sun::star; + +const WhichRangesContainer SvxTransparenceTabPage::pTransparenceRanges(svl::Items< + XATTR_FILLTRANSPARENCE, XATTR_FILLTRANSPARENCE, + XATTR_FILLFLOATTRANSPARENCE, XATTR_FILLFLOATTRANSPARENCE, + SDRATTR_SHADOWTRANSPARENCE, SDRATTR_SHADOWTRANSPARENCE +>); + +/************************************************************************* +|* +|* Dialog for transparence +|* +\************************************************************************/ + +IMPL_LINK_NOARG(SvxTransparenceTabPage, ClickTransOffHdl_Impl, weld::Toggleable&, void) +{ + // disable all other controls + ActivateLinear(false); + ActivateGradient(false); + + // Preview + rXFSet.ClearItem(XATTR_FILLTRANSPARENCE); + rXFSet.ClearItem(XATTR_FILLFLOATTRANSPARENCE); + m_aCtlXRectPreview.SetAttributes( aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.SetAttributes( aXFillAttr.GetItemSet() ); + + InvalidatePreview(false); +} + +IMPL_LINK_NOARG(SvxTransparenceTabPage, ClickTransLinearHdl_Impl, weld::Toggleable&, void) +{ + // enable linear, disable other + ActivateLinear(true); + ActivateGradient(false); + + // preview + rXFSet.ClearItem (XATTR_FILLFLOATTRANSPARENCE); + ModifyTransparentHdl_Impl(*m_xMtrTransparent); +} + +IMPL_LINK_NOARG(SvxTransparenceTabPage, ClickTransGradientHdl_Impl, weld::Toggleable&, void) +{ + // enable gradient, disable other + ActivateLinear(false); + ActivateGradient(true); + + // preview + rXFSet.ClearItem (XATTR_FILLTRANSPARENCE); + ModifiedTrgrHdl_Impl(nullptr); +} + +SvxTransparenceTabPage::~SvxTransparenceTabPage() +{ +} + +void SvxTransparenceTabPage::ActivateLinear(bool bActivate) +{ + m_xMtrTransparent->set_sensitive(bActivate); +} + +IMPL_LINK_NOARG(SvxTransparenceTabPage, ModifyTransparentHdl_Impl, weld::MetricSpinButton&, void) +{ + sal_uInt16 nPos = m_xMtrTransparent->get_value(FieldUnit::PERCENT); + rXFSet.Put(XFillTransparenceItem(nPos)); + + // preview + InvalidatePreview(); +} + +IMPL_LINK(SvxTransparenceTabPage, ModifiedTrgrListBoxHdl_Impl, weld::ComboBox&, rListBox, void) +{ + ModifiedTrgrHdl_Impl(&rListBox); +} + +IMPL_LINK_NOARG(SvxTransparenceTabPage, ModifiedTrgrEditHdl_Impl, weld::MetricSpinButton&, void) +{ + ModifiedTrgrHdl_Impl(nullptr); +} + +void SvxTransparenceTabPage::ModifiedTrgrHdl_Impl(const weld::ComboBox* pControl) +{ + if (pControl == m_xLbTrgrGradientType.get()) + { + css::awt::GradientStyle eXGS = static_cast<css::awt::GradientStyle>(m_xLbTrgrGradientType->get_active()); + SetControlState_Impl( eXGS ); + } + + // preview + sal_uInt8 nStartCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(m_xMtrTrgrStartValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt8 nEndCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(m_xMtrTrgrEndValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + XGradient aTmpGradient( + Color(nStartCol, nStartCol, nStartCol), + Color(nEndCol, nEndCol, nEndCol), + static_cast<css::awt::GradientStyle>(m_xLbTrgrGradientType->get_active()), + Degree10(static_cast<sal_Int16>(m_xMtrTrgrAngle->get_value(FieldUnit::DEGREE)) * 10), + static_cast<sal_uInt16>(m_xMtrTrgrCenterX->get_value(FieldUnit::PERCENT)), + static_cast<sal_uInt16>(m_xMtrTrgrCenterY->get_value(FieldUnit::PERCENT)), + static_cast<sal_uInt16>(m_xMtrTrgrBorder->get_value(FieldUnit::PERCENT)), + 100, 100); + + XFillFloatTransparenceItem aItem( aTmpGradient); + rXFSet.Put ( aItem ); + + InvalidatePreview(); +} + +void SvxTransparenceTabPage::ActivateGradient(bool bActivate) +{ + m_xGridGradient->set_sensitive(bActivate); + + if (bActivate) + { + css::awt::GradientStyle eXGS = static_cast<css::awt::GradientStyle>(m_xLbTrgrGradientType->get_active()); + SetControlState_Impl( eXGS ); + } +} + +void SvxTransparenceTabPage::SetControlState_Impl(css::awt::GradientStyle eXGS) +{ + switch(eXGS) + { + case css::awt::GradientStyle_LINEAR: + case css::awt::GradientStyle_AXIAL: + m_xFtTrgrCenterX->set_sensitive(false); + m_xMtrTrgrCenterX->set_sensitive(false); + m_xFtTrgrCenterY->set_sensitive(false); + m_xMtrTrgrCenterY->set_sensitive(false); + m_xFtTrgrAngle->set_sensitive(true); + m_xMtrTrgrAngle->set_sensitive(true); + break; + + case css::awt::GradientStyle_RADIAL: + m_xFtTrgrCenterX->set_sensitive(true); + m_xMtrTrgrCenterX->set_sensitive(true); + m_xFtTrgrCenterY->set_sensitive(true); + m_xMtrTrgrCenterY->set_sensitive(true); + m_xFtTrgrAngle->set_sensitive(false); + m_xMtrTrgrAngle->set_sensitive(false); + break; + + case css::awt::GradientStyle_ELLIPTICAL: + case css::awt::GradientStyle_SQUARE: + case css::awt::GradientStyle_RECT: + m_xFtTrgrCenterX->set_sensitive(true); + m_xMtrTrgrCenterX->set_sensitive(true); + m_xFtTrgrCenterY->set_sensitive(true); + m_xMtrTrgrCenterY->set_sensitive(true); + m_xFtTrgrAngle->set_sensitive(true); + m_xMtrTrgrAngle->set_sensitive(true); + break; + default: + break; + } +} + +SvxTransparenceTabPage::SvxTransparenceTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/transparencytabpage.ui", "TransparencyTabPage", &rInAttrs) + , rOutAttrs(rInAttrs) + , nPageType(PageType::Area) + , nDlgType(0) + , bBitmap(false) + , aXFillAttr(rInAttrs.GetPool()) + , rXFSet(aXFillAttr.GetItemSet()) + , m_xRbtTransOff(m_xBuilder->weld_radio_button("RBT_TRANS_OFF")) + , m_xRbtTransLinear(m_xBuilder->weld_radio_button("RBT_TRANS_LINEAR")) + , m_xRbtTransGradient(m_xBuilder->weld_radio_button("RBT_TRANS_GRADIENT")) + , m_xMtrTransparent(m_xBuilder->weld_metric_spin_button("MTR_TRANSPARENT", FieldUnit::PERCENT)) + , m_xGridGradient(m_xBuilder->weld_widget("gridGradient")) + , m_xLbTrgrGradientType(m_xBuilder->weld_combo_box("LB_TRGR_GRADIENT_TYPES")) + , m_xFtTrgrCenterX(m_xBuilder->weld_label("FT_TRGR_CENTER_X")) + , m_xMtrTrgrCenterX(m_xBuilder->weld_metric_spin_button("MTR_TRGR_CENTER_X", FieldUnit::PERCENT)) + , m_xFtTrgrCenterY(m_xBuilder->weld_label("FT_TRGR_CENTER_Y")) + , m_xMtrTrgrCenterY(m_xBuilder->weld_metric_spin_button("MTR_TRGR_CENTER_Y", FieldUnit::PERCENT)) + , m_xFtTrgrAngle(m_xBuilder->weld_label("FT_TRGR_ANGLE")) + , m_xMtrTrgrAngle(m_xBuilder->weld_metric_spin_button("MTR_TRGR_ANGLE", FieldUnit::DEGREE)) + , m_xMtrTrgrBorder(m_xBuilder->weld_metric_spin_button("MTR_TRGR_BORDER", FieldUnit::PERCENT)) + , m_xMtrTrgrStartValue(m_xBuilder->weld_metric_spin_button("MTR_TRGR_START_VALUE", FieldUnit::PERCENT)) + , m_xMtrTrgrEndValue(m_xBuilder->weld_metric_spin_button("MTR_TRGR_END_VALUE", FieldUnit::PERCENT)) + , m_xCtlBitmapBorder(m_xBuilder->weld_widget("bitmap_border")) + , m_xCtlXRectBorder(m_xBuilder->weld_widget("trans_border")) + , m_xCtlBitmapPreview(new weld::CustomWeld(*m_xBuilder, "CTL_IMAGE_PREVIEW", m_aCtlBitmapPreview)) + , m_xCtlXRectPreview(new weld::CustomWeld(*m_xBuilder, "CTL_TRANS_PREVIEW", m_aCtlXRectPreview)) +{ + // main selection + m_xRbtTransOff->connect_toggled(LINK(this, SvxTransparenceTabPage, ClickTransOffHdl_Impl)); + m_xRbtTransLinear->connect_toggled(LINK(this, SvxTransparenceTabPage, ClickTransLinearHdl_Impl)); + m_xRbtTransGradient->connect_toggled(LINK(this, SvxTransparenceTabPage, ClickTransGradientHdl_Impl)); + + // linear transparency + m_xMtrTransparent->set_value(50, FieldUnit::PERCENT); + m_xMtrTransparent->connect_value_changed(LINK(this, SvxTransparenceTabPage, ModifyTransparentHdl_Impl)); + + // gradient transparency + m_xMtrTrgrEndValue->set_value(100, FieldUnit::PERCENT); + m_xMtrTrgrStartValue->set_value(0, FieldUnit::PERCENT); + Link<weld::MetricSpinButton&,void> aLink = LINK( this, SvxTransparenceTabPage, ModifiedTrgrEditHdl_Impl); + m_xLbTrgrGradientType->connect_changed(LINK(this, SvxTransparenceTabPage, ModifiedTrgrListBoxHdl_Impl)); + m_xMtrTrgrCenterX->connect_value_changed( aLink ); + m_xMtrTrgrCenterY->connect_value_changed( aLink ); + m_xMtrTrgrAngle->connect_value_changed( aLink ); + m_xMtrTrgrBorder->connect_value_changed( aLink ); + m_xMtrTrgrStartValue->connect_value_changed( aLink ); + m_xMtrTrgrEndValue->connect_value_changed( aLink ); + + // this page needs ExchangeSupport + SetExchangeSupport(); +} + +std::unique_ptr<SfxTabPage> SvxTransparenceTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rAttrs) +{ + return std::make_unique<SvxTransparenceTabPage>(pPage, pController, *rAttrs); +} + +bool SvxTransparenceTabPage::FillItemSet(SfxItemSet* rAttrs) +{ + const SfxPoolItem* pGradientItem = nullptr; + const SfxPoolItem* pLinearItem = nullptr; + SfxItemState eStateGradient(rOutAttrs.GetItemState(XATTR_FILLFLOATTRANSPARENCE, true, &pGradientItem)); + SfxItemState eStateLinear(rOutAttrs.GetItemState(XATTR_FILLTRANSPARENCE, true, &pLinearItem)); + bool bGradActive = (eStateGradient == SfxItemState::SET && static_cast<const XFillFloatTransparenceItem*>(pGradientItem)->IsEnabled()); + bool bLinearActive = (eStateLinear == SfxItemState::SET && static_cast<const XFillTransparenceItem*>(pLinearItem)->GetValue() != 0); + + bool bGradUsed = (eStateGradient == SfxItemState::DONTCARE); + bool bLinearUsed = (eStateLinear == SfxItemState::DONTCARE); + + bool bModified(false); + bool bSwitchOffLinear(false); + bool bSwitchOffGradient(false); + + if (m_xMtrTransparent->get_sensitive()) + { + // linear transparence + sal_uInt16 nPos = m_xMtrTransparent->get_value(FieldUnit::PERCENT); + if (m_xMtrTransparent->get_value_changed_from_saved() || !bLinearActive) + { + XFillTransparenceItem aItem(nPos); + SdrPercentItem aShadowItem(makeSdrShadowTransparenceItem(nPos)); + const SfxPoolItem* pOld = GetOldItem(*rAttrs, XATTR_FILLTRANSPARENCE); + if(!pOld || !(*static_cast<const XFillTransparenceItem*>(pOld) == aItem) || !bLinearActive) + { + rAttrs->Put(aItem); + rAttrs->Put(aShadowItem); + bModified = true; + bSwitchOffGradient = true; + } + } + } + else if (m_xGridGradient->get_sensitive()) + { + // transparence gradient, fill ItemSet from values + if (!bGradActive + || m_xLbTrgrGradientType->get_value_changed_from_saved() + || m_xMtrTrgrAngle->get_value_changed_from_saved() + || m_xMtrTrgrCenterX->get_value_changed_from_saved() + || m_xMtrTrgrCenterY->get_value_changed_from_saved() + || m_xMtrTrgrBorder->get_value_changed_from_saved() + || m_xMtrTrgrStartValue->get_value_changed_from_saved() + || m_xMtrTrgrEndValue->get_value_changed_from_saved()) + { + sal_uInt8 nStartCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(m_xMtrTrgrStartValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + sal_uInt8 nEndCol = static_cast<sal_uInt8>((static_cast<sal_uInt16>(m_xMtrTrgrEndValue->get_value(FieldUnit::PERCENT)) * 255) / 100); + XGradient aTmpGradient( + Color(nStartCol, nStartCol, nStartCol), + Color(nEndCol, nEndCol, nEndCol), + static_cast<css::awt::GradientStyle>(m_xLbTrgrGradientType->get_active()), + Degree10(static_cast<sal_Int16>(m_xMtrTrgrAngle->get_value(FieldUnit::DEGREE)) * 10), + static_cast<sal_uInt16>(m_xMtrTrgrCenterX->get_value(FieldUnit::PERCENT)), + static_cast<sal_uInt16>(m_xMtrTrgrCenterY->get_value(FieldUnit::PERCENT)), + static_cast<sal_uInt16>(m_xMtrTrgrBorder->get_value(FieldUnit::PERCENT)), + 100, 100); + + XFillFloatTransparenceItem aItem(aTmpGradient); + const SfxPoolItem* pOld = GetOldItem(*rAttrs, XATTR_FILLFLOATTRANSPARENCE); + + if(!pOld || !(*static_cast<const XFillFloatTransparenceItem*>(pOld) == aItem) || !bGradActive) + { + rAttrs->Put(aItem); + bModified = true; + bSwitchOffLinear = true; + } + } + } + else + { + // no transparence + bSwitchOffGradient = true; + bSwitchOffLinear = true; + } + + // disable unused XFillFloatTransparenceItem + if(bSwitchOffGradient && (bGradActive || bGradUsed)) + { + XGradient aGrad(COL_BLACK, COL_WHITE); + aGrad.SetStartIntens(100); + aGrad.SetEndIntens(100); + XFillFloatTransparenceItem aItem(aGrad); + aItem.SetEnabled(false); + rAttrs->Put(aItem); + bModified = true; + } + + // disable unused XFillFloatTransparenceItem + if(bSwitchOffLinear && (bLinearActive || bLinearUsed)) + { + XFillTransparenceItem aItem(0); + SdrPercentItem aShadowItem(makeSdrShadowTransparenceItem(0)); + rAttrs->Put(aItem); + rAttrs->Put(aShadowItem); + bModified = true; + } + rAttrs->Put(CntUInt16Item(SID_PAGE_TYPE, static_cast<sal_uInt16>(nPageType))); + return bModified; +} + +void SvxTransparenceTabPage::Reset(const SfxItemSet* rAttrs) +{ + const XFillFloatTransparenceItem* pGradientItem = + rAttrs->GetItemIfSet(XATTR_FILLFLOATTRANSPARENCE); + bool bGradActive = (pGradientItem && pGradientItem->IsEnabled()); + if(!pGradientItem) + pGradientItem = &rAttrs->Get(XATTR_FILLFLOATTRANSPARENCE); + + const XFillTransparenceItem* pLinearItem = + rAttrs->GetItemIfSet(XATTR_FILLTRANSPARENCE); + bool bLinearActive = (pLinearItem && pLinearItem->GetValue() != 0); + if(!pLinearItem) + pLinearItem = &rAttrs->Get(XATTR_FILLTRANSPARENCE); + + // transparence gradient + const XGradient& rGradient = pGradientItem->GetGradientValue(); + css::awt::GradientStyle eXGS(rGradient.GetGradientStyle()); + m_xLbTrgrGradientType->set_active(sal::static_int_cast< sal_Int32 >(eXGS)); + m_xMtrTrgrAngle->set_value(rGradient.GetAngle().get() / 10, FieldUnit::DEGREE); + m_xMtrTrgrBorder->set_value(rGradient.GetBorder(), FieldUnit::PERCENT); + m_xMtrTrgrCenterX->set_value(rGradient.GetXOffset(), FieldUnit::PERCENT); + m_xMtrTrgrCenterY->set_value(rGradient.GetYOffset(), FieldUnit::PERCENT); + m_xMtrTrgrStartValue->set_value(static_cast<sal_uInt16>(((static_cast<sal_uInt16>(rGradient.GetStartColor().GetRed()) + 1) * 100) / 255), FieldUnit::PERCENT); + m_xMtrTrgrEndValue->set_value(static_cast<sal_uInt16>(((static_cast<sal_uInt16>(rGradient.GetEndColor().GetRed()) + 1) * 100) / 255), FieldUnit::PERCENT); + + // linear transparence + sal_uInt16 nTransp = pLinearItem->GetValue(); + m_xMtrTransparent->set_value(bLinearActive ? nTransp : 50, FieldUnit::PERCENT); + ModifyTransparentHdl_Impl(*m_xMtrTransparent); + + // select the correct radio button + if(bGradActive) + { + // transparence gradient, set controls appropriate to item + m_xRbtTransGradient->set_active(true); + ClickTransGradientHdl_Impl(*m_xRbtTransGradient); + } + else if(bLinearActive) + { + // linear transparence + m_xRbtTransLinear->set_active(true); + ClickTransLinearHdl_Impl(*m_xRbtTransLinear); + } + else + { + // no transparence + m_xRbtTransOff->set_active(true); + ClickTransOffHdl_Impl(*m_xRbtTransOff); + ModifiedTrgrHdl_Impl(nullptr); + } + + // save values + ChangesApplied(); + bool bActive = InitPreview ( *rAttrs ); + InvalidatePreview ( bActive ); +} + +void SvxTransparenceTabPage::ChangesApplied() +{ + m_xMtrTransparent->save_value(); + m_xLbTrgrGradientType->save_value(); + m_xMtrTrgrCenterX->save_value(); + m_xMtrTrgrCenterY->save_value(); + m_xMtrTrgrAngle->save_value(); + m_xMtrTrgrBorder->save_value(); + m_xMtrTrgrStartValue->save_value(); + m_xMtrTrgrEndValue->save_value(); +} + +void SvxTransparenceTabPage::ActivatePage(const SfxItemSet& rSet) +{ + const CntUInt16Item* pPageTypeItem = rSet.GetItem<CntUInt16Item>(SID_PAGE_TYPE, false); + if (pPageTypeItem) + SetPageType(static_cast<PageType>(pPageTypeItem->GetValue())); + + if(nDlgType == 0) // area dialog + nPageType = PageType::Transparence; + + InitPreview ( rSet ); +} + +DeactivateRC SvxTransparenceTabPage::DeactivatePage(SfxItemSet* _pSet) +{ + if( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +// Preview-Methods + +bool SvxTransparenceTabPage::InitPreview(const SfxItemSet& rSet) +{ + // set transparencetype for preview + if (m_xRbtTransOff->get_active()) + { + ClickTransOffHdl_Impl(*m_xRbtTransOff); + } + else if (m_xRbtTransLinear->get_active()) + { + ClickTransLinearHdl_Impl(*m_xRbtTransLinear); + } + else if (m_xRbtTransGradient->get_active()) + { + ClickTransGradientHdl_Impl(*m_xRbtTransGradient); + } + + // Get fillstyle for preview + rXFSet.Put ( rSet.Get(XATTR_FILLSTYLE) ); + rXFSet.Put ( rSet.Get(XATTR_FILLCOLOR) ); + rXFSet.Put ( rSet.Get(XATTR_FILLGRADIENT) ); + rXFSet.Put ( rSet.Get(XATTR_FILLHATCH) ); + rXFSet.Put ( rSet.Get(XATTR_FILLBACKGROUND) ); + rXFSet.Put ( rSet.Get(XATTR_FILLBITMAP) ); + + m_aCtlXRectPreview.SetAttributes( aXFillAttr.GetItemSet() ); + m_aCtlBitmapPreview.SetAttributes( aXFillAttr.GetItemSet() ); + + bBitmap = rSet.Get(XATTR_FILLSTYLE).GetValue() == drawing::FillStyle_BITMAP; + + // show the right preview window + if ( bBitmap ) + { + m_xCtlBitmapBorder->show(); + m_xCtlXRectBorder->hide(); + } + else + { + m_xCtlBitmapBorder->hide(); + m_xCtlXRectBorder->show(); + } + + return !m_xRbtTransOff->get_active(); +} + +void SvxTransparenceTabPage::InvalidatePreview (bool bEnable) +{ + if ( bBitmap ) + { + if ( bEnable ) + { + m_xCtlBitmapPreview->set_sensitive(true); + m_aCtlBitmapPreview.SetAttributes( aXFillAttr.GetItemSet() ); + } + else + m_xCtlBitmapPreview->set_sensitive(false); + m_xCtlBitmapPreview->queue_draw(); + } + else + { + if ( bEnable ) + { + m_xCtlXRectPreview->set_sensitive(true); + m_aCtlXRectPreview.SetAttributes( aXFillAttr.GetItemSet() ); + } + else + m_xCtlXRectPreview->set_sensitive(false); + m_xCtlXRectPreview->queue_draw(); + } +} + +void SvxTransparenceTabPage::PageCreated(const SfxAllItemSet& aSet) +{ + const SfxUInt16Item* pPageTypeItem = aSet.GetItem<SfxUInt16Item>(SID_PAGE_TYPE, false); + const SfxUInt16Item* pDlgTypeItem = aSet.GetItem<SfxUInt16Item>(SID_DLG_TYPE, false); + + if (pPageTypeItem) + SetPageType(static_cast<PageType>(pPageTypeItem->GetValue())); + if (pDlgTypeItem) + SetDlgType(pDlgTypeItem->GetValue()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/cui/source/tabpages/transfrm.cxx b/cui/source/tabpages/transfrm.cxx new file mode 100644 index 000000000..c9fd14095 --- /dev/null +++ b/cui/source/tabpages/transfrm.cxx @@ -0,0 +1,1562 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * 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 . + */ + +#include <sal/config.h> + +#include <algorithm> + +#include <svx/EnhancedCustomShape2d.hxx> +#include <svx/sdangitm.hxx> +#include <svx/svdundo.hxx> +#include <svx/svdview.hxx> +#include <svx/svdobj.hxx> +#include <svx/svdpagv.hxx> +#include <svx/svdoashp.hxx> +#include <svx/sderitm.hxx> +#include <svx/svxids.hrc> +#include <svx/transfrmhelper.hxx> +#include <svtools/unitconv.hxx> + +#include <transfrm.hxx> +#include <svx/dlgutil.hxx> +#include <svx/anchorid.hxx> +#include <svl/rectitem.hxx> +#include <swpossizetabpage.hxx> +#include <vcl/canvastools.hxx> +#include <vcl/fieldvalues.hxx> + +// static ---------------------------------------------------------------- + +const WhichRangesContainer SvxPositionSizeTabPage::pPosSizeRanges(svl::Items< + SID_ATTR_TRANSFORM_POS_X, SID_ATTR_TRANSFORM_POS_Y, + SID_ATTR_TRANSFORM_WIDTH, SID_ATTR_TRANSFORM_SIZE_POINT, + SID_ATTR_TRANSFORM_PROTECT_POS, SID_ATTR_TRANSFORM_INTERN, + SID_ATTR_TRANSFORM_AUTOWIDTH, SID_ATTR_TRANSFORM_AUTOHEIGHT, + SID_ATTR_TRANSFORM_ANCHOR, SID_ATTR_TRANSFORM_VERT_ORIENT +>); + +const WhichRangesContainer SvxAngleTabPage::pAngleRanges(svl::Items< + SID_ATTR_TRANSFORM_ROT_X, SID_ATTR_TRANSFORM_ANGLE, + SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_INTERN +>); + +const WhichRangesContainer SvxSlantTabPage::pSlantRanges(svl::Items< + SDRATTR_CORNER_RADIUS, SDRATTR_CORNER_RADIUS, + SID_ATTR_TRANSFORM_INTERN, SID_ATTR_TRANSFORM_INTERN, + SID_ATTR_TRANSFORM_SHEAR, SID_ATTR_TRANSFORM_SHEAR_VERTICAL +>); + +/************************************************************************* +|* +|* constructor of the tab dialog: adds the pages to the dialog +|* +\************************************************************************/ + +SvxTransformTabDialog::SvxTransformTabDialog(weld::Window* pParent, const SfxItemSet* pAttr, + const SdrView* pSdrView, SvxAnchorIds nAnchorTypes) + : SfxTabDialogController(pParent, "cui/ui/positionsizedialog.ui", "PositionAndSizeDialog", pAttr) + , pView(pSdrView) + , nAnchorCtrls(nAnchorTypes) +{ + DBG_ASSERT(pView, "no valid view (!)"); + + //different positioning page in Writer + if(nAnchorCtrls & (SvxAnchorIds::Paragraph | SvxAnchorIds::Character | SvxAnchorIds::Page | SvxAnchorIds::Fly)) + { + AddTabPage("RID_SVXPAGE_SWPOSSIZE", SvxSwPosSizeTabPage::Create, SvxSwPosSizeTabPage::GetRanges); + RemoveTabPage("RID_SVXPAGE_POSITION_SIZE"); + } + else + { + AddTabPage("RID_SVXPAGE_POSITION_SIZE", SvxPositionSizeTabPage::Create, SvxPositionSizeTabPage::GetRanges); + RemoveTabPage("RID_SVXPAGE_SWPOSSIZE"); + } + + AddTabPage("RID_SVXPAGE_ANGLE", SvxAngleTabPage::Create, SvxAngleTabPage::GetRanges); + AddTabPage("RID_SVXPAGE_SLANT", SvxSlantTabPage::Create, SvxSlantTabPage::GetRanges); +} + + +void SvxTransformTabDialog::PageCreated(const OString& rId, SfxTabPage &rPage) +{ + if (rId == "RID_SVXPAGE_POSITION_SIZE") + { + SvxPositionSizeTabPage& rSvxPos = static_cast<SvxPositionSizeTabPage&>(rPage); + rSvxPos.SetView(pView); + rSvxPos.Construct(); + + if(nAnchorCtrls & SvxAnchorIds::NoResize) + { + rSvxPos.DisableResize(); + } + + if(nAnchorCtrls & SvxAnchorIds::NoProtect) + { + rSvxPos.DisableProtect(); + rSvxPos.UpdateControlStates(); + } + } + else if (rId == "RID_SVXPAGE_SWPOSSIZE") + { + SvxSwPosSizeTabPage& rSwPos = static_cast<SvxSwPosSizeTabPage&>(rPage); + + rSwPos.EnableAnchorTypes(nAnchorCtrls); + rSwPos.SetValidateFramePosLink(aValidateLink); + rSwPos.SetView(pView); + } + else if (rId == "RID_SVXPAGE_ANGLE") + { + SvxAngleTabPage& rSvxAng = static_cast<SvxAngleTabPage&>(rPage); + + rSvxAng.SetView( pView ); + rSvxAng.Construct(); + } + else if (rId == "RID_SVXPAGE_SLANT") + { + SvxSlantTabPage& rSvxSlnt = static_cast<SvxSlantTabPage&>(rPage); + + rSvxSlnt.SetView( pView ); + rSvxSlnt.Construct(); + } +} + +void SvxTransformTabDialog::SetValidateFramePosLink(const Link<SvxSwFrameValidation&,void>& rLink) +{ + aValidateLink = rLink; +} + +/************************************************************************* +|* +|* dialog for changing the positions of the rotation +|* angle and the rotation angle of the graphic objects +|* +\************************************************************************/ +SvxAngleTabPage::SvxAngleTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxTabPage(pPage, pController, "cui/ui/rotationtabpage.ui", "Rotation", rInAttrs) + , pView(nullptr) + , eDlgUnit(FieldUnit::NONE) + , m_aCtlRect(this) + , m_xFlPosition(m_xBuilder->weld_widget("FL_POSITION")) + , m_xMtrPosX(m_xBuilder->weld_metric_spin_button("MTR_FLD_POS_X", FieldUnit::CM)) + , m_xMtrPosY(m_xBuilder->weld_metric_spin_button("MTR_FLD_POS_Y", FieldUnit::CM)) + , m_xCtlRect(new weld::CustomWeld(*m_xBuilder, "CTL_RECT", m_aCtlRect)) + , m_xFlAngle(m_xBuilder->weld_widget("FL_ANGLE")) + , m_xNfAngle(m_xBuilder->weld_metric_spin_button("NF_ANGLE", FieldUnit::DEGREE)) + , m_xCtlAngle(new svx::DialControl) + , m_xCtlAngleWin(new weld::CustomWeld(*m_xBuilder, "CTL_ANGLE", *m_xCtlAngle)) +{ + // calculate PoolUnit + SfxItemPool* pPool = rInAttrs.GetPool(); + DBG_ASSERT( pPool, "no pool (!)" ); + ePoolUnit = pPool->GetMetric(SID_ATTR_TRANSFORM_POS_X); + + m_xCtlAngle->SetLinkedField(m_xNfAngle.get(), 2); +} + +SvxAngleTabPage::~SvxAngleTabPage() +{ +} + +void SvxAngleTabPage::Construct() +{ + DBG_ASSERT(pView, "No valid view (!)"); + eDlgUnit = GetModuleFieldUnit(GetItemSet()); + SetFieldUnit(*m_xMtrPosX, eDlgUnit, true); + SetFieldUnit(*m_xMtrPosY, eDlgUnit, true); + + if (FieldUnit::MILE == eDlgUnit || FieldUnit::KM == eDlgUnit) + { + m_xMtrPosX->set_digits(3); + m_xMtrPosY->set_digits(3); + } + + { // #i75273# + ::tools::Rectangle aTempRect(pView->GetAllMarkedRect()); + pView->GetSdrPageView()->LogicToPagePos(aTempRect); + maRange = vcl::unotools::b2DRectangleFromRectangle(aTempRect); + } + + // Take anchor into account (Writer) + const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); + + if(rMarkList.GetMarkCount()) + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + maAnchor = basegfx::B2DPoint(pObj->GetAnchorPos().X(), pObj->GetAnchorPos().Y()); + + if(!maAnchor.equalZero()) // -> Writer + { + maRange = basegfx::B2DRange(maRange.getMinimum() - maAnchor, maRange.getMaximum() - maAnchor); + } + } + + // take scale into account + const Fraction aUIScale(pView->GetModel()->GetUIScale()); + TransfrmHelper::ScaleRect(maRange, aUIScale); + + // take UI units into account + sal_uInt16 nDigits(m_xMtrPosX->get_digits()); + TransfrmHelper::ConvertRect(maRange, nDigits, ePoolUnit, eDlgUnit); + + if(!pView->IsRotateAllowed()) + { + m_xFlPosition->set_sensitive(false); + m_xFlAngle->set_sensitive(false); + } +} + +bool SvxAngleTabPage::FillItemSet(SfxItemSet* rSet) +{ + bool bModified = false; + + if (m_xCtlAngle->IsValueModified() || m_xMtrPosX->get_value_changed_from_saved() || m_xMtrPosY->get_value_changed_from_saved()) + { + const double fUIScale(double(pView->GetModel()->GetUIScale())); + const double fTmpX((GetCoreValue(*m_xMtrPosX, ePoolUnit) + maAnchor.getX()) * fUIScale); + const double fTmpY((GetCoreValue(*m_xMtrPosY, ePoolUnit) + maAnchor.getY()) * fUIScale); + + rSet->Put(SdrAngleItem(SID_ATTR_TRANSFORM_ANGLE, m_xCtlAngle->GetRotation())); + rSet->Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_X, basegfx::fround(fTmpX))); + rSet->Put(SfxInt32Item(SID_ATTR_TRANSFORM_ROT_Y, basegfx::fround(fTmpY))); + + bModified = true; + } + + return bModified; +} + + +void SvxAngleTabPage::Reset(const SfxItemSet* rAttrs) +{ + const double fUIScale(double(pView->GetModel()->GetUIScale())); + + const SfxPoolItem* pItem = GetItem( *rAttrs, SID_ATTR_TRANSFORM_ROT_X ); + if(pItem) + { + const double fTmp((static_cast<double>(static_cast<const SfxInt32Item*>(pItem)->GetValue()) - maAnchor.getX()) / fUIScale); + SetMetricValue(*m_xMtrPosX, basegfx::fround(fTmp), ePoolUnit); + } + else + { + m_xMtrPosX->set_text(OUString()); + } + + pItem = GetItem(*rAttrs, SID_ATTR_TRANSFORM_ROT_Y); + if(pItem) + { + const double fTmp((static_cast<double>(static_cast<const SfxInt32Item*>(pItem)->GetValue()) - maAnchor.getY()) / fUIScale); + SetMetricValue(*m_xMtrPosY, basegfx::fround(fTmp), ePoolUnit); + } + else + { + m_xMtrPosY->set_text(OUString()); + } + + pItem = GetItem( *rAttrs, SID_ATTR_TRANSFORM_ANGLE ); + if(pItem) + { + m_xCtlAngle->SetRotation(static_cast<const SdrAngleItem*>(pItem)->GetValue()); + } + else + { + m_xCtlAngle->SetRotation(0_deg100); + } + m_xCtlAngle->SaveValue(); + m_xMtrPosX->save_value(); + m_xMtrPosY->save_value(); +} + +std::unique_ptr<SfxTabPage> SvxAngleTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet) +{ + return std::make_unique<SvxAngleTabPage>(pPage, pController, *rSet); +} + +void SvxAngleTabPage::ActivatePage(const SfxItemSet& rSet) +{ + if(SfxBoolItem const * bPosProtect = rSet.GetItemIfSet( SID_ATTR_TRANSFORM_PROTECT_POS, false )) + { + m_xFlPosition->set_sensitive(!bPosProtect->GetValue()); + m_xFlAngle->set_sensitive(!bPosProtect->GetValue()); + } +} + +DeactivateRC SvxAngleTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if(_pSet) + { + FillItemSet(_pSet); + } + + return DeactivateRC::LeavePage; +} + +void SvxAngleTabPage::PointChanged(weld::DrawingArea* pDrawingArea, RectPoint eRP) +{ + if (pDrawingArea != m_aCtlRect.GetDrawingArea()) + return; + + switch(eRP) + { + case RectPoint::LT: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMinX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMinY()), FieldUnit::NONE ); + break; + } + case RectPoint::MT: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getCenter().getX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMinY()), FieldUnit::NONE ); + break; + } + case RectPoint::RT: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMaxX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMinY()), FieldUnit::NONE ); + break; + } + case RectPoint::LM: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMinX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getCenter().getY()), FieldUnit::NONE ); + break; + } + case RectPoint::MM: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getCenter().getX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getCenter().getY()), FieldUnit::NONE ); + break; + } + case RectPoint::RM: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMaxX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getCenter().getY()), FieldUnit::NONE ); + break; + } + case RectPoint::LB: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMinX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMaxY()), FieldUnit::NONE ); + break; + } + case RectPoint::MB: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getCenter().getX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMaxY()), FieldUnit::NONE ); + break; + } + case RectPoint::RB: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMaxX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMaxY()), FieldUnit::NONE ); + break; + } + } +} + +/************************************************************************* +|* +|* dialog for changing slant and corner radius +|* +\************************************************************************/ +SvxSlantTabPage::SvxSlantTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SfxTabPage(pPage, pController, "cui/ui/slantcornertabpage.ui", "SlantAndCornerRadius", &rInAttrs) + , pView(nullptr) + , eDlgUnit(FieldUnit::NONE) + , m_xFlRadius(m_xBuilder->weld_widget("FL_RADIUS")) + , m_xMtrRadius(m_xBuilder->weld_metric_spin_button("MTR_FLD_RADIUS", FieldUnit::CM)) + , m_xFlAngle(m_xBuilder->weld_widget("FL_SLANT")) + , m_xMtrAngle(m_xBuilder->weld_metric_spin_button("MTR_FLD_ANGLE", FieldUnit::DEGREE)) +{ + for (int i = 0; i < 2; ++i) + { + m_aControlGroups[i] = m_xBuilder->weld_widget("controlgroups" + OString::number(i+1)); + m_aControlGroupX[i] = m_xBuilder->weld_widget("controlgroupx" + OString::number(i+1)); + m_aControlX[i] = m_xBuilder->weld_metric_spin_button("controlx" + OString::number(i+1), FieldUnit::CM); + m_aControlGroupY[i] = m_xBuilder->weld_widget("controlgroupy" + OString::number(i+1)); + m_aControlY[i] = m_xBuilder->weld_metric_spin_button("controly" + OString::number(i+1), FieldUnit::CM); + } + + // this page needs ExchangeSupport + SetExchangeSupport(); + + // evaluate PoolUnit + SfxItemPool* pPool = rInAttrs.GetPool(); + assert(pPool && "no pool (!)"); + ePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X ); +} + +SvxSlantTabPage::~SvxSlantTabPage() +{ +} + +void SvxSlantTabPage::Construct() +{ + // get the range + DBG_ASSERT(pView, "no valid view (!)"); + eDlgUnit = GetModuleFieldUnit(GetItemSet()); + SetFieldUnit(*m_xMtrRadius, eDlgUnit, true); + for (int i = 0; i < 2; ++i) + { + SetFieldUnit(*m_aControlX[i], eDlgUnit, true); + SetFieldUnit(*m_aControlY[i], eDlgUnit, true); + } + + { // #i75273# + ::tools::Rectangle aTempRect(pView->GetAllMarkedRect()); + pView->GetSdrPageView()->LogicToPagePos(aTempRect); + } +} + +bool SvxSlantTabPage::FillItemSet(SfxItemSet* rAttrs) +{ + bool bModified = false; + + if (m_xMtrRadius->get_value_changed_from_saved()) + { + Fraction aUIScale = pView->GetModel()->GetUIScale(); + tools::Long nTmp = tools::Long(GetCoreValue(*m_xMtrRadius, ePoolUnit) * aUIScale); + + rAttrs->Put( makeSdrEckenradiusItem( nTmp ) ); + bModified = true; + } + + if (m_xMtrAngle->get_value_changed_from_saved()) + { + sal_Int32 nValue = static_cast<sal_Int32>(m_xMtrAngle->get_value(FieldUnit::NONE)); + rAttrs->Put( SdrAngleItem( SID_ATTR_TRANSFORM_SHEAR, Degree100(nValue) ) ); + bModified = true; + } + + if( bModified ) + { + // set reference points + ::tools::Rectangle aObjectRect(pView->GetAllMarkedRect()); + pView->GetSdrPageView()->LogicToPagePos(aObjectRect); + Point aPt = aObjectRect.Center(); + + rAttrs->Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_X, aPt.X())); + rAttrs->Put(SfxInt32Item(SID_ATTR_TRANSFORM_SHEAR_Y, aPt.Y())); + rAttrs->Put( SfxBoolItem( SID_ATTR_TRANSFORM_SHEAR_VERTICAL, false ) ); + } + + bool bControlPointsChanged = false; + for (int i = 0; i < 2; ++i) + { + bControlPointsChanged |= (m_aControlX[i]->get_value_changed_from_saved() || + m_aControlY[i]->get_value_changed_from_saved()); + } + + if (!bControlPointsChanged) + return bModified; + + bool bSelectionIsSdrObjCustomShape(false); + + while(true) + { + if(nullptr == pView) + { + break; + } + + if(0 == pView->GetMarkedObjectList().GetMarkCount()) + { + break; + } + + SdrObject* pCandidate(pView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj()); + + if(nullptr == pCandidate) + { + break; + } + + if(nullptr == dynamic_cast< SdrObjCustomShape* >(pCandidate)) + { + break; + } + + bSelectionIsSdrObjCustomShape = true; + break; + } + + if(bSelectionIsSdrObjCustomShape) + { + SdrObjCustomShape& rSdrObjCustomShape( + static_cast< SdrObjCustomShape& >( + *pView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj())); + SdrModel& rModel(rSdrObjCustomShape.getSdrModelFromSdrObject()); + std::unique_ptr<SdrUndoAction> pUndo; + if (rModel.IsUndoEnabled()) + pUndo = rModel.GetSdrUndoFactory().CreateUndoAttrObject(rSdrObjCustomShape); + + if(pUndo) + { + rModel.BegUndo(pUndo->GetComment()); + } + + EnhancedCustomShape2d aShape(rSdrObjCustomShape); + ::tools::Rectangle aLogicRect = aShape.GetLogicRect(); + + for (int i = 0; i < 2; ++i) + { + if (m_aControlX[i]->get_value_changed_from_saved() || m_aControlY[i]->get_value_changed_from_saved()) + { + Point aNewPosition(GetCoreValue(*m_aControlX[i], ePoolUnit), + GetCoreValue(*m_aControlY[i], ePoolUnit)); + aNewPosition.Move(aLogicRect.Left(), aLogicRect.Top()); + + css::awt::Point aPosition; + aPosition.X = aNewPosition.X(); + aPosition.Y = aNewPosition.Y(); + + aShape.SetHandleControllerPosition(i, aPosition); + } + } + + rSdrObjCustomShape.SetChanged(); + rSdrObjCustomShape.BroadcastObjectChange(); + bModified = true; + + if (pUndo) + { + rModel.AddUndo(std::move(pUndo)); + rModel.EndUndo(); + } + } + + return bModified; +} + +void SvxSlantTabPage::Reset(const SfxItemSet* rAttrs) +{ + // if the view has selected objects, items with SfxItemState::DEFAULT need to be disabled + const SfxPoolItem* pItem; + + // corner radius + if(!pView->IsEdgeRadiusAllowed()) + { + m_xMtrRadius->set_text(""); + m_xFlRadius->set_sensitive(false); + } + else + { + pItem = GetItem( *rAttrs, SDRATTR_CORNER_RADIUS ); + + if( pItem ) + { + const double fUIScale(double(pView->GetModel()->GetUIScale())); + const double fTmp(static_cast<double>(static_cast<const SdrMetricItem*>(pItem)->GetValue()) / fUIScale); + SetMetricValue(*m_xMtrRadius, basegfx::fround(fTmp), ePoolUnit); + } + else + { + m_xMtrRadius->set_text(""); + } + } + + m_xMtrRadius->save_value(); + + // slant: angle + if( !pView->IsShearAllowed() ) + { + m_xMtrAngle->set_text( "" ); + m_xFlAngle->set_sensitive(false); + } + else + { + pItem = GetItem( *rAttrs, SID_ATTR_TRANSFORM_SHEAR ); + + if( pItem ) + { + m_xMtrAngle->set_value(static_cast<const SdrAngleItem*>(pItem)->GetValue().get(), FieldUnit::NONE); + } + else + { + m_xMtrAngle->set_text(""); + } + } + + m_xMtrAngle->save_value(); + + bool bSelectionIsSdrObjCustomShape(false); + + while(true) + { + if(1 != pView->GetMarkedObjectList().GetMarkCount()) + { + break; + } + + SdrObject* pCandidate(pView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj()); + + if(nullptr == pCandidate) + { + break; + } + + if(nullptr == dynamic_cast< SdrObjCustomShape* >(pCandidate)) + { + break; + } + + bSelectionIsSdrObjCustomShape = true; + break; + } + + if(bSelectionIsSdrObjCustomShape) + { + SdrObjCustomShape& rSdrObjCustomShape( + static_cast< SdrObjCustomShape& >( + *pView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj())); + + //save geometry + const bool bOrigModelChangeState = pView->GetModel()->IsChanged(); + SdrCustomShapeGeometryItem aInitialGeometry(rSdrObjCustomShape.GetMergedItem(SDRATTR_CUSTOMSHAPE_GEOMETRY)); + EnhancedCustomShape2d aShape(rSdrObjCustomShape); + + for (int i = 0; i < 2; ++i) + { + Point aInitialPosition; + if (!aShape.GetHandlePosition(i, aInitialPosition)) + break; + m_aControlGroups[i]->set_sensitive(true); + css::awt::Point aPosition; + + aPosition.X = SAL_MAX_INT32/2; + aPosition.Y = SAL_MAX_INT32/2; + aShape.SetHandleControllerPosition(i, aPosition); + Point aMaxPosition; + aShape.GetHandlePosition(i, aMaxPosition); + + aPosition.X = SAL_MIN_INT32/2; + aPosition.Y = SAL_MIN_INT32/2; + aShape.SetHandleControllerPosition(i, aPosition); + Point aMinPosition; + aShape.GetHandlePosition(i, aMinPosition); + + ::tools::Rectangle aLogicRect = aShape.GetLogicRect(); + aInitialPosition.Move(-aLogicRect.Left(), -aLogicRect.Top()); + aMaxPosition.Move(-aLogicRect.Left(), -aLogicRect.Top()); + aMinPosition.Move(-aLogicRect.Left(), -aLogicRect.Top()); + + SetMetricValue(*m_aControlX[i], aInitialPosition.X(), ePoolUnit); + SetMetricValue(*m_aControlY[i], aInitialPosition.Y(), ePoolUnit); + + if (aMaxPosition.X() == aMinPosition.X()) + m_aControlGroupX[i]->set_sensitive(false); + else + m_aControlX[i]->set_range(aMinPosition.X(), aMaxPosition.X(), FieldUnit::MM); + if (aMaxPosition.Y() == aMinPosition.Y()) + m_aControlGroupY[i]->set_sensitive(false); + else + m_aControlY[i]->set_range(aMinPosition.Y(), aMaxPosition.Y(), FieldUnit::MM); + } + + //restore geometry + rSdrObjCustomShape.SetMergedItem(aInitialGeometry); + pView->GetModel()->SetChanged(bOrigModelChangeState); + } + + for (int i = 0; i < 2; ++i) + { + m_aControlX[i]->save_value(); + m_aControlY[i]->save_value(); + } +} + +std::unique_ptr<SfxTabPage> SvxSlantTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rOutAttrs) +{ + return std::make_unique<SvxSlantTabPage>(pPage, pController, *rOutAttrs); +} + +void SvxSlantTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + if(SfxBoolItem const * bPosProtect = rSet.GetItemIfSet( SID_ATTR_TRANSFORM_PROTECT_POS, false )) + { + m_xFlAngle->set_sensitive(!bPosProtect->GetValue()); + } + if(SfxBoolItem const * bSizeProtect = rSet.GetItemIfSet( SID_ATTR_TRANSFORM_PROTECT_SIZE, false )) + { + m_xFlAngle->set_sensitive(!bSizeProtect->GetValue()); + } + +} + +DeactivateRC SvxSlantTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if(_pSet) + { + FillItemSet(_pSet); + } + + return DeactivateRC::LeavePage; +} + + +/************************************************************************* +|* +|* Dialog for changing position and size of graphic objects +|* +\************************************************************************/ +SvxPositionSizeTabPage::SvxPositionSizeTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rInAttrs) + : SvxTabPage(pPage, pController, "cui/ui/possizetabpage.ui", "PositionAndSize", rInAttrs) + , mrOutAttrs(rInAttrs) + , mpView(nullptr) + , meDlgUnit(FieldUnit::NONE) + , mnProtectSizeState(TRISTATE_FALSE) + , mbPageDisabled(false) + , mbProtectDisabled(false) + , mbSizeDisabled(false) + , mbAdjustDisabled(true) + , mbIgnoreAutoGrowWidth(true) + , mbIgnoreAutoGrowHeight(true) + , mfOldWidth(0.0) + , mfOldHeight(0.0) + , m_aCtlPos(this) + , m_aCtlSize(this) + , m_xFlPosition(m_xBuilder->weld_widget("FL_POSITION")) + , m_xMtrPosX(m_xBuilder->weld_metric_spin_button("MTR_FLD_POS_X", FieldUnit::CM)) + , m_xMtrPosY(m_xBuilder->weld_metric_spin_button("MTR_FLD_POS_Y", FieldUnit::CM)) + , m_xCtlPos(new weld::CustomWeld(*m_xBuilder, "CTL_POSRECT", m_aCtlPos)) + , m_xFlSize(m_xBuilder->weld_widget("FL_SIZE")) + , m_xFtWidth(m_xBuilder->weld_label("FT_WIDTH")) + , m_xMtrWidth(m_xBuilder->weld_metric_spin_button("MTR_FLD_WIDTH", FieldUnit::CM)) + , m_xFtHeight(m_xBuilder->weld_label("FT_HEIGHT")) + , m_xMtrHeight(m_xBuilder->weld_metric_spin_button("MTR_FLD_HEIGHT", FieldUnit::CM)) + , m_xCbxScale(m_xBuilder->weld_check_button("CBX_SCALE")) + , m_xCtlSize(new weld::CustomWeld(*m_xBuilder, "CTL_SIZERECT", m_aCtlSize)) + , m_xFlProtect(m_xBuilder->weld_widget("FL_PROTECT")) + , m_xTsbPosProtect(m_xBuilder->weld_check_button("TSB_POSPROTECT")) + , m_xTsbSizeProtect(m_xBuilder->weld_check_button("TSB_SIZEPROTECT")) + , m_xFlAdjust(m_xBuilder->weld_widget("FL_ADJUST")) + , m_xTsbAutoGrowWidth(m_xBuilder->weld_check_button("TSB_AUTOGROW_WIDTH")) + , m_xTsbAutoGrowHeight(m_xBuilder->weld_check_button("TSB_AUTOGROW_HEIGHT")) +{ + // this page needs ExchangeSupport + SetExchangeSupport(); + + // evaluate PoolUnit + SfxItemPool* pPool = mrOutAttrs.GetPool(); + DBG_ASSERT( pPool, "no pool (!)" ); + mePoolUnit = pPool->GetMetric( SID_ATTR_TRANSFORM_POS_X ); + + m_aCtlPos.SetActualRP(RectPoint::LT); + m_aCtlSize.SetActualRP(RectPoint::LT); + meRP = RectPoint::LT; // see above + + m_xMtrWidth->connect_value_changed( LINK( this, SvxPositionSizeTabPage, ChangeWidthHdl ) ); + m_xMtrHeight->connect_value_changed( LINK( this, SvxPositionSizeTabPage, ChangeHeightHdl ) ); + m_xCbxScale->connect_toggled( LINK( this, SvxPositionSizeTabPage, ClickAutoHdl ) ); + + m_xFlAdjust->set_sensitive(false); + + // #i2379# disable controls when protected + m_xTsbPosProtect->connect_toggled( LINK( this, SvxPositionSizeTabPage, ChangePosProtectHdl ) ); + m_xTsbSizeProtect->connect_toggled( LINK( this, SvxPositionSizeTabPage, ChangeSizeProtectHdl ) ); +} + +SvxPositionSizeTabPage::~SvxPositionSizeTabPage() +{ +} + +void SvxPositionSizeTabPage::Construct() +{ + // get range and work area + DBG_ASSERT( mpView, "no valid view (!)" ); + meDlgUnit = GetModuleFieldUnit( GetItemSet() ); + SetFieldUnit( *m_xMtrPosX, meDlgUnit, true ); + SetFieldUnit( *m_xMtrPosY, meDlgUnit, true ); + SetFieldUnit( *m_xMtrWidth, meDlgUnit, true ); + SetFieldUnit( *m_xMtrHeight, meDlgUnit, true ); + + if(FieldUnit::MILE == meDlgUnit || FieldUnit::KM == meDlgUnit) + { + m_xMtrPosX->set_digits( 3 ); + m_xMtrPosY->set_digits( 3 ); + m_xMtrWidth->set_digits( 3 ); + m_xMtrHeight->set_digits( 3 ); + } + + { // #i75273# + ::tools::Rectangle aTempRect(mpView->GetAllMarkedRect()); + mpView->GetSdrPageView()->LogicToPagePos(aTempRect); + maRange = vcl::unotools::b2DRectangleFromRectangle(aTempRect); + } + + { // #i75273# + ::tools::Rectangle aTempRect(mpView->GetWorkArea()); + mpView->GetSdrPageView()->LogicToPagePos(aTempRect); + maWorkRange = vcl::unotools::b2DRectangleFromRectangle(aTempRect); + } + + // take anchor into account (Writer) + const SdrMarkList& rMarkList = mpView->GetMarkedObjectList(); + + if(rMarkList.GetMarkCount()) + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + maAnchor = basegfx::B2DPoint(pObj->GetAnchorPos().X(), pObj->GetAnchorPos().Y()); + + if(!maAnchor.equalZero()) // -> Writer + { + for(size_t i = 1; i < rMarkList.GetMarkCount(); ++i) + { + pObj = rMarkList.GetMark(i)->GetMarkedSdrObj(); + + if(maAnchor != basegfx::B2DPoint(pObj->GetAnchorPos().X(), pObj->GetAnchorPos().Y())) + { + // different anchor positions + m_xMtrPosX->set_text(""); + m_xMtrPosY->set_text(""); + mbPageDisabled = true; + return; + } + } + + // translate ranges about anchor + maRange = basegfx::B2DRange(maRange.getMinimum() - maAnchor, maRange.getMaximum() - maAnchor); + maWorkRange = basegfx::B2DRange(maWorkRange.getMinimum() - maAnchor, maWorkRange.getMaximum() - maAnchor); + } + } + + // this should happen via SID_ATTR_TRANSFORM_AUTOSIZE + if(1 == rMarkList.GetMarkCount()) + { + const SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj(); + const SdrObjKind eKind(pObj->GetObjIdentifier()); + + if((pObj->GetObjInventor() == SdrInventor::Default) && + (SdrObjKind::Text == eKind || SdrObjKind::TitleText == eKind || SdrObjKind::OutlineText == eKind) && + pObj->HasText()) + { + mbAdjustDisabled = false; + + m_xFlAdjust->set_sensitive(true); + + m_xTsbAutoGrowWidth->connect_toggled( LINK( this, SvxPositionSizeTabPage, ClickSizeProtectHdl ) ); + m_xTsbAutoGrowHeight->connect_toggled( LINK( this, SvxPositionSizeTabPage, ClickSizeProtectHdl ) ); + + // is used as flag to evaluate if it's selectable + mbIgnoreAutoGrowWidth = false; + mbIgnoreAutoGrowHeight = false; + } + } + + // take scale into account + const Fraction aUIScale(mpView->GetModel()->GetUIScale()); + TransfrmHelper::ScaleRect( maWorkRange, aUIScale ); + TransfrmHelper::ScaleRect( maRange, aUIScale ); + + // take UI units into account + const sal_uInt16 nDigits(m_xMtrPosX->get_digits()); + TransfrmHelper::ConvertRect( maWorkRange, nDigits, mePoolUnit, meDlgUnit ); + TransfrmHelper::ConvertRect( maRange, nDigits, mePoolUnit, meDlgUnit ); + + SetMinMaxPosition(); +} + + +bool SvxPositionSizeTabPage::FillItemSet( SfxItemSet* rOutAttrs ) +{ + bool bModified(false); + + if ( m_xMtrWidth->has_focus() ) + { + ChangeWidthHdl( *m_xMtrWidth ); + } + + if ( m_xMtrHeight->has_focus() ) + { + ChangeHeightHdl( *m_xMtrHeight ); + } + + if( !mbPageDisabled ) + { + if (m_xMtrPosX->get_value_changed_from_saved() || m_xMtrPosY->get_value_changed_from_saved()) + { + const double fUIScale(double(mpView->GetModel()->GetUIScale())); + double fX((GetCoreValue( *m_xMtrPosX, mePoolUnit ) + maAnchor.getX()) * fUIScale); + double fY((GetCoreValue( *m_xMtrPosY, mePoolUnit ) + maAnchor.getY()) * fUIScale); + + { // #i75273# + ::tools::Rectangle aTempRect(mpView->GetAllMarkedRect()); + mpView->GetSdrPageView()->LogicToPagePos(aTempRect); + maRange = vcl::unotools::b2DRectangleFromRectangle(aTempRect); + } + + // #101581# GetTopLeftPosition(...) needs coordinates after UI scaling, in real PagePositions + GetTopLeftPosition(fX, fY, maRange); + + rOutAttrs->Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_X, basegfx::fround(fX))); + rOutAttrs->Put(SfxInt32Item(SID_ATTR_TRANSFORM_POS_Y, basegfx::fround(fY))); + + bModified = true; + } + + if (m_xTsbPosProtect->get_state_changed_from_saved()) + { + if( m_xTsbPosProtect->get_inconsistent() ) + { + rOutAttrs->InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_POS ); + } + else + { + rOutAttrs->Put( + SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_POS, + m_xTsbPosProtect->get_active() ) ); + } + + bModified = true; + } + } + + if (m_xMtrWidth->get_value_changed_from_saved() || m_xMtrHeight->get_value_changed_from_saved()) + { + Fraction aUIScale = mpView->GetModel()->GetUIScale(); + + // get Width + double nWidth = static_cast<double>(m_xMtrWidth->get_value(FieldUnit::MM_100TH)); + tools::Long lWidth = tools::Long(nWidth * static_cast<double>(aUIScale)); + lWidth = OutputDevice::LogicToLogic( lWidth, MapUnit::Map100thMM, mePoolUnit ); + lWidth = static_cast<tools::Long>(m_xMtrWidth->denormalize( lWidth )); + + // get Height + double nHeight = static_cast<double>(m_xMtrHeight->get_value(FieldUnit::MM_100TH)); + tools::Long lHeight = tools::Long(nHeight * static_cast<double>(aUIScale)); + lHeight = OutputDevice::LogicToLogic( lHeight, MapUnit::Map100thMM, mePoolUnit ); + lHeight = static_cast<tools::Long>(m_xMtrHeight->denormalize( lHeight )); + + // put Width & Height to itemset + rOutAttrs->Put( SfxUInt32Item( SID_ATTR_TRANSFORM_WIDTH, static_cast<sal_uInt32>(lWidth) ) ); + rOutAttrs->Put( SfxUInt32Item( SID_ATTR_TRANSFORM_HEIGHT, static_cast<sal_uInt32>(lHeight) ) ); + rOutAttrs->Put( SfxUInt16Item( SID_ATTR_TRANSFORM_SIZE_POINT, sal::static_int_cast< sal_uInt16 >( meRP ) ) ); + bModified = true; + } + + if (m_xTsbSizeProtect->get_state_changed_from_saved()) + { + if ( m_xTsbSizeProtect->get_inconsistent() ) + rOutAttrs->InvalidateItem( SID_ATTR_TRANSFORM_PROTECT_SIZE ); + else + rOutAttrs->Put( + SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_SIZE, + m_xTsbSizeProtect->get_active() ) ); + bModified = true; + } + + if (m_xTsbAutoGrowWidth->get_state_changed_from_saved()) + { + if (!mbIgnoreAutoGrowWidth) + { + if( m_xTsbAutoGrowWidth->get_inconsistent() ) + rOutAttrs->InvalidateItem( SID_ATTR_TRANSFORM_AUTOWIDTH ); + else + rOutAttrs->Put( + SfxBoolItem( SID_ATTR_TRANSFORM_AUTOWIDTH, + m_xTsbAutoGrowWidth->get_active() ) ); + } + bModified = true; + } + + if (m_xTsbAutoGrowHeight->get_state_changed_from_saved()) + { + if (!mbIgnoreAutoGrowHeight) + { + if (m_xTsbAutoGrowHeight->get_inconsistent()) + { + rOutAttrs->InvalidateItem( SID_ATTR_TRANSFORM_AUTOHEIGHT ); + } + else + { + rOutAttrs->Put( + SfxBoolItem( SID_ATTR_TRANSFORM_AUTOHEIGHT, + m_xTsbAutoGrowHeight->get_active() ) ); + } + } + bModified = true; + } + + return bModified; +} + +void SvxPositionSizeTabPage::Reset( const SfxItemSet* ) +{ + const SfxPoolItem* pItem; + const double fUIScale(double(mpView->GetModel()->GetUIScale())); + + if ( !mbPageDisabled ) + { + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_POS_X ); + if ( pItem ) + { + const double fTmp((static_cast<const SfxInt32Item*>(pItem)->GetValue() - maAnchor.getX()) / fUIScale); + SetMetricValue(*m_xMtrPosX, basegfx::fround(fTmp), mePoolUnit); + } + + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_POS_Y ); + if ( pItem ) + { + const double fTmp((static_cast<const SfxInt32Item*>(pItem)->GetValue() - maAnchor.getY()) / fUIScale); + SetMetricValue(*m_xMtrPosY, basegfx::fround(fTmp), mePoolUnit); + } + + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_PROTECT_POS ); + if ( pItem ) + { + bool bProtected = static_cast<const SfxBoolItem*>( pItem )->GetValue(); + m_xTsbPosProtect->set_active(bProtected); + } + else + { + m_xTsbPosProtect->set_inconsistent(true); + } + + m_xTsbPosProtect->save_state(); + m_aCtlPos.Reset(); + + // #i2379# Disable controls for protected objects + ChangePosProtectHdl(*m_xTsbPosProtect); + } + + { // #i75273# set width + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_WIDTH ); + mfOldWidth = std::max( pItem ? static_cast<double>(static_cast<const SfxUInt32Item*>(pItem)->GetValue()) : 0.0, 1.0 ); + double fTmpWidth((OutputDevice::LogicToLogic(static_cast<sal_Int32>(mfOldWidth), mePoolUnit, MapUnit::Map100thMM)) / fUIScale); + if (m_xMtrWidth->get_digits()) + fTmpWidth *= pow(10.0, m_xMtrWidth->get_digits()); + m_xMtrWidth->set_value(fTmpWidth, FieldUnit::MM_100TH); + } + + { // #i75273# set height + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_HEIGHT ); + mfOldHeight = std::max( pItem ? static_cast<double>(static_cast<const SfxUInt32Item*>(pItem)->GetValue()) : 0.0, 1.0 ); + double fTmpHeight((OutputDevice::LogicToLogic(static_cast<sal_Int32>(mfOldHeight), mePoolUnit, MapUnit::Map100thMM)) / fUIScale); + if (m_xMtrHeight->get_digits()) + fTmpHeight *= pow(10.0, m_xMtrHeight->get_digits()); + m_xMtrHeight->set_value(fTmpHeight, FieldUnit::MM_100TH); + } + + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_PROTECT_SIZE ); + if ( pItem ) + { + m_xTsbSizeProtect->set_active(static_cast<const SfxBoolItem*>(pItem)->GetValue()); + } + else + m_xTsbSizeProtect->set_inconsistent(true); + + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_AUTOWIDTH ); + if ( pItem ) + { + m_xTsbAutoGrowWidth->set_active(static_cast<const SfxBoolItem*>( pItem )->GetValue()); + } + else + m_xTsbAutoGrowWidth->set_inconsistent(true); + + pItem = GetItem( mrOutAttrs, SID_ATTR_TRANSFORM_AUTOHEIGHT ); + if ( pItem ) + { + m_xTsbAutoGrowHeight->set_active(static_cast<const SfxBoolItem*>( pItem )->GetValue()); + } + else + m_xTsbAutoGrowHeight->set_inconsistent(true); + + // Is matching set? + OUString aStr = GetUserData(); + m_xCbxScale->set_active(aStr.toInt32() != 0); + + m_xMtrPosX->save_value(); + m_xMtrPosY->save_value(); + m_xMtrWidth->save_value(); + m_xMtrHeight->save_value(); + + m_xTsbSizeProtect->save_state(); + m_xTsbAutoGrowWidth->save_state(); + m_xTsbAutoGrowHeight->save_state(); + ClickSizeProtectHdl(*m_xTsbAutoGrowHeight); + + // #i2379# Disable controls for protected objects + ChangeSizeProtectHdl(*m_xTsbSizeProtect); +} + +std::unique_ptr<SfxTabPage> SvxPositionSizeTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rOutAttrs) +{ + return std::make_unique<SvxPositionSizeTabPage>(pPage, pController, *rOutAttrs); +} + +void SvxPositionSizeTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + if( SfxRectangleItem const * pRectItem = rSet.GetItemIfSet( SID_ATTR_TRANSFORM_INTERN, false ) ) + { + { // #i75273# + const ::tools::Rectangle aTempRect(pRectItem->GetValue()); + maRange = vcl::unotools::b2DRectangleFromRectangle(aTempRect); + } + + SetMinMaxPosition(); + } +} + + +DeactivateRC SvxPositionSizeTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if( _pSet ) + { + double fX(static_cast<double>(m_xMtrPosX->get_value(FieldUnit::NONE))); + double fY(static_cast<double>(m_xMtrPosY->get_value(FieldUnit::NONE))); + + GetTopLeftPosition(fX, fY, maRange); + const ::tools::Rectangle aOutRectangle( + basegfx::fround(fX), basegfx::fround(fY), + basegfx::fround(fX + maRange.getWidth()), basegfx::fround(fY + maRange.getHeight())); + _pSet->Put(SfxRectangleItem(SID_ATTR_TRANSFORM_INTERN, aOutRectangle)); + _pSet->Put(SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_POS, + m_xTsbPosProtect->get_state() == TRISTATE_TRUE )); + _pSet->Put(SfxBoolItem( SID_ATTR_TRANSFORM_PROTECT_SIZE, + m_xTsbSizeProtect->get_state() == TRISTATE_TRUE )); + FillItemSet(_pSet); + } + + return DeactivateRC::LeavePage; +} + + +IMPL_LINK_NOARG(SvxPositionSizeTabPage, ChangePosProtectHdl, weld::Toggleable&, void) +{ + // #106572# Remember user's last choice + m_xTsbSizeProtect->set_state(m_xTsbPosProtect->get_state() == TRISTATE_TRUE ? TRISTATE_TRUE : mnProtectSizeState); + UpdateControlStates(); +} + + +void SvxPositionSizeTabPage::UpdateControlStates() +{ + const bool bPosProtect = m_xTsbPosProtect->get_state() == TRISTATE_TRUE; + const bool bSizeProtect = m_xTsbSizeProtect->get_state() == TRISTATE_TRUE; + const bool bHeightChecked = !mbIgnoreAutoGrowHeight && (m_xTsbAutoGrowHeight->get_active()); + const bool bWidthChecked = !mbIgnoreAutoGrowWidth && (m_xTsbAutoGrowWidth->get_active()); + + m_xFlPosition->set_sensitive(!bPosProtect && !mbPageDisabled); + + m_xTsbPosProtect->set_sensitive( !mbProtectDisabled && !mbPageDisabled ); + + m_xFlSize->set_sensitive( !mbSizeDisabled && !bSizeProtect ); + + m_xFtWidth->set_sensitive( !mbSizeDisabled && !bSizeProtect && !bWidthChecked ); + m_xMtrWidth->set_sensitive( !mbSizeDisabled && !bSizeProtect && !bWidthChecked ); + + m_xFtHeight->set_sensitive( !mbSizeDisabled && !bSizeProtect && !bHeightChecked ); + m_xMtrHeight->set_sensitive( !mbSizeDisabled && !bSizeProtect && !bHeightChecked ); + + m_xCbxScale->set_sensitive( !mbSizeDisabled && !bSizeProtect && !bHeightChecked && !bWidthChecked ); + m_xCtlSize->set_sensitive( !mbSizeDisabled && !bSizeProtect && (!bHeightChecked || !bWidthChecked) ); + + m_xFlProtect->set_sensitive( !mbProtectDisabled ); + m_xTsbSizeProtect->set_sensitive( !mbProtectDisabled && !bPosProtect ); + + m_xFlAdjust->set_sensitive( !mbSizeDisabled && !bSizeProtect && !mbAdjustDisabled ); + + m_aCtlSize.Invalidate(); + m_aCtlPos.Invalidate(); +} + +IMPL_LINK_NOARG(SvxPositionSizeTabPage, ChangeSizeProtectHdl, weld::Toggleable&, void) +{ + if (m_xTsbSizeProtect->get_sensitive()) + { + // #106572# Remember user's last choice + + // Note: this works only as long as the dialog is open. When + // the user closes the dialog, there is no way to remember + // whether size was enabled or disabled before pos protect was + // clicked. Thus, if pos protect is selected, the dialog is + // closed and reopened again, unchecking pos protect will + // always uncheck size protect, too. That's life. + mnProtectSizeState = m_xTsbSizeProtect->get_state(); + } + + UpdateControlStates(); +} + +void SvxPositionSizeTabPage::SetMinMaxPosition() +{ + // position + double fLeft(maWorkRange.getMinX()); + double fTop(maWorkRange.getMinY()); + double fRight(maWorkRange.getMaxX()); + double fBottom(maWorkRange.getMaxY()); + + switch (m_aCtlPos.GetActualRP()) + { + case RectPoint::LT: + { + fRight -= maRange.getWidth(); + fBottom -= maRange.getHeight(); + break; + } + case RectPoint::MT: + { + fLeft += maRange.getWidth() / 2.0; + fRight -= maRange.getWidth() / 2.0; + fBottom -= maRange.getHeight(); + break; + } + case RectPoint::RT: + { + fLeft += maRange.getWidth(); + fBottom -= maRange.getHeight(); + break; + } + case RectPoint::LM: + { + fRight -= maRange.getWidth(); + fTop += maRange.getHeight() / 2.0; + fBottom -= maRange.getHeight() / 2.0; + break; + } + case RectPoint::MM: + { + fLeft += maRange.getWidth() / 2.0; + fRight -= maRange.getWidth() / 2.0; + fTop += maRange.getHeight() / 2.0; + fBottom -= maRange.getHeight() / 2.0; + break; + } + case RectPoint::RM: + { + fLeft += maRange.getWidth(); + fTop += maRange.getHeight() / 2.0; + fBottom -= maRange.getHeight() / 2.0; + break; + } + case RectPoint::LB: + { + fRight -= maRange.getWidth(); + fTop += maRange.getHeight(); + break; + } + case RectPoint::MB: + { + fLeft += maRange.getWidth() / 2.0; + fRight -= maRange.getWidth() / 2.0; + fTop += maRange.getHeight(); + break; + } + case RectPoint::RB: + { + fLeft += maRange.getWidth(); + fTop += maRange.getHeight(); + break; + } + } + + const double fMaxLong(vcl::ConvertValue(std::numeric_limits<sal_Int64>::max(), 0, MapUnit::Map100thMM, meDlgUnit) - 1); + fLeft = std::clamp(fLeft, -fMaxLong, fMaxLong); + fRight = std::clamp(fRight, -fMaxLong, fMaxLong); + fTop = std::clamp(fTop, - fMaxLong, fMaxLong); + fBottom = std::clamp(fBottom, -fMaxLong, fMaxLong); + + // #i75273# normalizing when setting the min/max values was wrong, removed + m_xMtrPosX->set_range(basegfx::fround64(fLeft), basegfx::fround64(fRight), FieldUnit::NONE); + m_xMtrPosY->set_range(basegfx::fround64(fTop), basegfx::fround64(fBottom), FieldUnit::NONE); + + // size + fLeft = maWorkRange.getMinX(); + fTop = maWorkRange.getMinY(); + fRight = maWorkRange.getMaxX(); + fBottom = maWorkRange.getMaxY(); + double fNewX(0); + double fNewY(0); + + switch (m_aCtlSize.GetActualRP()) + { + case RectPoint::LT: + { + fNewX = maWorkRange.getWidth() - ( maRange.getMinX() - fLeft ); + fNewY = maWorkRange.getHeight() - ( maRange.getMinY() - fTop ); + break; + } + case RectPoint::MT: + { + fNewX = std::min( maRange.getCenter().getX() - fLeft, fRight - maRange.getCenter().getX() ) * 2.0; + fNewY = maWorkRange.getHeight() - ( maRange.getMinY() - fTop ); + break; + } + case RectPoint::RT: + { + fNewX = maWorkRange.getWidth() - ( fRight - maRange.getMaxX() ); + fNewY = maWorkRange.getHeight() - ( maRange.getMinY() - fTop ); + break; + } + case RectPoint::LM: + { + fNewX = maWorkRange.getWidth() - ( maRange.getMinX() - fLeft ); + fNewY = std::min( maRange.getCenter().getY() - fTop, fBottom - maRange.getCenter().getY() ) * 2.0; + break; + } + case RectPoint::MM: + { + const double f1(maRange.getCenter().getX() - fLeft); + const double f2(fRight - maRange.getCenter().getX()); + const double f3(std::min(f1, f2)); + const double f4(maRange.getCenter().getY() - fTop); + const double f5(fBottom - maRange.getCenter().getY()); + const double f6(std::min(f4, f5)); + + fNewX = f3 * 2.0; + fNewY = f6 * 3.0; + + break; + } + case RectPoint::RM: + { + fNewX = maWorkRange.getWidth() - ( fRight - maRange.getMaxX() ); + fNewY = std::min( maRange.getCenter().getY() - fTop, fBottom - maRange.getCenter().getY() ) * 2.0; + break; + } + case RectPoint::LB: + { + fNewX = maWorkRange.getWidth() - ( maRange.getMinX() - fLeft ); + fNewY = maWorkRange.getHeight() - ( fBottom - maRange.getMaxY() ); + break; + } + case RectPoint::MB: + { + fNewX = std::min( maRange.getCenter().getX() - fLeft, fRight - maRange.getCenter().getX() ) * 2.0; + fNewY = maWorkRange.getHeight() - ( maRange.getMaxY() - fBottom ); + break; + } + case RectPoint::RB: + { + fNewX = maWorkRange.getWidth() - ( fRight - maRange.getMaxX() ); + fNewY = maWorkRange.getHeight() - ( fBottom - maRange.getMaxY() ); + break; + } + } + + // #i75273# normalizing when setting the min/max values was wrong, removed + m_xMtrWidth->set_max(basegfx::fround64(fNewX), FieldUnit::NONE); + m_xMtrHeight->set_max(basegfx::fround64(fNewY), FieldUnit::NONE); +} + +void SvxPositionSizeTabPage::GetTopLeftPosition(double& rfX, double& rfY, const basegfx::B2DRange& rRange) +{ + switch (m_aCtlPos.GetActualRP()) + { + case RectPoint::LT: + { + break; + } + case RectPoint::MT: + { + rfX -= rRange.getCenter().getX() - rRange.getMinX(); + break; + } + case RectPoint::RT: + { + rfX -= rRange.getWidth(); + break; + } + case RectPoint::LM: + { + rfY -= rRange.getCenter().getY() - rRange.getMinY(); + break; + } + case RectPoint::MM: + { + rfX -= rRange.getCenter().getX() - rRange.getMinX(); + rfY -= rRange.getCenter().getY() - rRange.getMinY(); + break; + } + case RectPoint::RM: + { + rfX -= rRange.getWidth(); + rfY -= rRange.getCenter().getY() - rRange.getMinY(); + break; + } + case RectPoint::LB: + { + rfY -= rRange.getHeight(); + break; + } + case RectPoint::MB: + { + rfX -= rRange.getCenter().getX() - rRange.getMinX(); + rfY -= rRange.getHeight(); + break; + } + case RectPoint::RB: + { + rfX -= rRange.getWidth(); + rfY -= rRange.getHeight(); + break; + } + } +} + +void SvxPositionSizeTabPage::PointChanged(weld::DrawingArea* pDrawingArea, RectPoint eRP) +{ + if (pDrawingArea == m_aCtlPos.GetDrawingArea()) + { + SetMinMaxPosition(); + switch( eRP ) + { + case RectPoint::LT: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMinX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMinY()), FieldUnit::NONE ); + break; + } + case RectPoint::MT: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getCenter().getX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMinY()), FieldUnit::NONE ); + break; + } + case RectPoint::RT: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMaxX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMinY()), FieldUnit::NONE ); + break; + } + case RectPoint::LM: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMinX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getCenter().getY()), FieldUnit::NONE ); + break; + } + case RectPoint::MM: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getCenter().getX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getCenter().getY()), FieldUnit::NONE ); + break; + } + case RectPoint::RM: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMaxX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getCenter().getY()), FieldUnit::NONE ); + break; + } + case RectPoint::LB: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMinX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMaxY()), FieldUnit::NONE ); + break; + } + case RectPoint::MB: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getCenter().getX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMaxY()), FieldUnit::NONE ); + break; + } + case RectPoint::RB: + { + m_xMtrPosX->set_value( basegfx::fround64(maRange.getMaxX()), FieldUnit::NONE ); + m_xMtrPosY->set_value( basegfx::fround64(maRange.getMaxY()), FieldUnit::NONE ); + break; + } + } + } + else + { + meRP = eRP; + SetMinMaxPosition(); + } +} + +void SvxPositionSizeTabPage::DisableResize() +{ + mbSizeDisabled = true; +} + + +void SvxPositionSizeTabPage::DisableProtect() +{ + mbProtectDisabled = true; +} + + +IMPL_LINK_NOARG(SvxPositionSizeTabPage, ChangeWidthHdl, weld::MetricSpinButton&, void) +{ + if( !(m_xCbxScale->get_active() && m_xCbxScale->get_sensitive()) ) + return; + + sal_Int64 nHeight(basegfx::fround64((mfOldHeight * static_cast<double>(m_xMtrWidth->get_value(FieldUnit::NONE))) / mfOldWidth)); + sal_Int64 nMin, nMax; + m_xMtrHeight->get_range(nMin, nMax, FieldUnit::NONE); + + if (nHeight <= nMax) + { + m_xMtrHeight->set_value(nHeight, FieldUnit::NONE); + } + else + { + nHeight = nMax; + m_xMtrHeight->set_value(nHeight, FieldUnit::NONE); + + const sal_Int64 nWidth(basegfx::fround64((mfOldWidth * static_cast<double>(nHeight)) / mfOldHeight)); + m_xMtrWidth->set_value(nWidth, FieldUnit::NONE); + } +} + +IMPL_LINK_NOARG(SvxPositionSizeTabPage, ChangeHeightHdl, weld::MetricSpinButton&, void) +{ + if( !(m_xCbxScale->get_active() && m_xCbxScale->get_sensitive()) ) + return; + + sal_Int64 nWidth(basegfx::fround64((mfOldWidth * static_cast<double>(m_xMtrHeight->get_value(FieldUnit::NONE))) / mfOldHeight)); + sal_Int64 nMin, nMax; + m_xMtrWidth->get_range(nMin, nMax, FieldUnit::NONE); + + if (nWidth <= nMax) + { + m_xMtrWidth->set_value(nWidth, FieldUnit::NONE); + } + else + { + nWidth = nMax; + m_xMtrWidth->set_value(nWidth, FieldUnit::NONE); + + const sal_Int64 nHeight(basegfx::fround64((mfOldHeight * static_cast<double>(nWidth)) / mfOldWidth)); + m_xMtrHeight->set_value(nHeight, FieldUnit::NONE); + } +} + +IMPL_LINK_NOARG(SvxPositionSizeTabPage, ClickSizeProtectHdl, weld::Toggleable&, void) +{ + UpdateControlStates(); +} + +IMPL_LINK_NOARG(SvxPositionSizeTabPage, ClickAutoHdl, weld::Toggleable&, void) +{ + if (m_xCbxScale->get_active()) + { + mfOldWidth = std::max( static_cast<double>(GetCoreValue( *m_xMtrWidth, mePoolUnit )), 1.0 ); + mfOldHeight = std::max( static_cast<double>(GetCoreValue( *m_xMtrHeight, mePoolUnit )), 1.0 ); + } +} + +void SvxPositionSizeTabPage::FillUserData() +{ + // matching is saved in the Ini-file + OUString aStr = m_xCbxScale->get_active() ? OUString("1") : OUString("0"); + SetUserData( aStr ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |