diff options
Diffstat (limited to '')
76 files changed, 34954 insertions, 0 deletions
diff --git a/svx/source/dialog/AccessibilityCheckDialog.cxx b/svx/source/dialog/AccessibilityCheckDialog.cxx new file mode 100644 index 000000000..4032e62f8 --- /dev/null +++ b/svx/source/dialog/AccessibilityCheckDialog.cxx @@ -0,0 +1,64 @@ +/* -*- 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/. + * + */ + +#include <svx/AccessibilityCheckDialog.hxx> + +#include <sfx2/AccessibilityIssue.hxx> +#include <vcl/svapp.hxx> + +namespace svx +{ +AccessibilityCheckEntry::AccessibilityCheckEntry( + weld::Container* pParent, std::shared_ptr<sfx::AccessibilityIssue> const& rAccessibilityIssue) + : m_xBuilder(Application::CreateBuilder(pParent, "svx/ui/accessibilitycheckentry.ui")) + , m_xContainer(m_xBuilder->weld_container("accessibilityCheckEntryBox")) + , m_xLabel(m_xBuilder->weld_label("accessibilityCheckEntryLabel")) + , m_xGotoButton(m_xBuilder->weld_button("accessibilityCheckEntryGotoButton")) + , m_pAccessibilityIssue(rAccessibilityIssue) +{ + m_xLabel->set_label(m_pAccessibilityIssue->m_aIssueText); + m_xGotoButton->set_visible(m_pAccessibilityIssue->canGotoIssue()); + m_xGotoButton->connect_clicked(LINK(this, AccessibilityCheckEntry, GotoButtonClicked)); + m_xContainer->show(); +} + +IMPL_LINK_NOARG(AccessibilityCheckEntry, GotoButtonClicked, weld::Button&, void) +{ + m_pAccessibilityIssue->gotoIssue(); +} + +AccessibilityCheckDialog::AccessibilityCheckDialog( + weld::Window* pParent, sfx::AccessibilityIssueCollection const& rIssueCollection) + : GenericDialogController(pParent, "svx/ui/accessibilitycheckdialog.ui", + "AccessibilityCheckDialog") + , m_aIssueCollection(rIssueCollection) + , m_xAccessibilityCheckBox(m_xBuilder->weld_box("accessibilityCheckBox")) +{ +} + +AccessibilityCheckDialog::~AccessibilityCheckDialog() {} + +short AccessibilityCheckDialog::run() +{ + sal_Int32 i = 0; + + for (std::shared_ptr<sfx::AccessibilityIssue> const& pIssue : m_aIssueCollection.getIssues()) + { + auto xEntry + = std::make_unique<AccessibilityCheckEntry>(m_xAccessibilityCheckBox.get(), pIssue); + m_xAccessibilityCheckBox->reorder_child(xEntry->get_widget(), i++); + m_aAccessibilityCheckEntries.push_back(std::move(xEntry)); + } + return GenericDialogController::run(); +} + +} // end svx namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/ClassificationCommon.cxx b/svx/source/dialog/ClassificationCommon.cxx new file mode 100644 index 000000000..d5561ec5b --- /dev/null +++ b/svx/source/dialog/ClassificationCommon.cxx @@ -0,0 +1,125 @@ +/* -*- 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/. + * + */ + +#include <svx/ClassificationCommon.hxx> +#include <svx/ClassificationField.hxx> +#include <rtl/ustrbuf.hxx> + +#include <com/sun/star/beans/PropertyAttribute.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertyContainer.hpp> + +using namespace css; + +namespace svx::classification +{ +OUString convertClassificationResultToString(std::vector<svx::ClassificationResult> const& rResults) +{ + OUStringBuffer sRepresentation; + + for (svx::ClassificationResult const& rResult : rResults) + { + switch (rResult.meType) + { + case svx::ClassificationType::CATEGORY: + case svx::ClassificationType::INTELLECTUAL_PROPERTY_PART: + case svx::ClassificationType::MARKING: + case svx::ClassificationType::TEXT: + sRepresentation.append(rResult.msName); + break; + + case svx::ClassificationType::PARAGRAPH: + sRepresentation.append(" "); + break; + } + } + return sRepresentation.makeStringAndClear(); +} + +OUString getProperty(uno::Reference<beans::XPropertyContainer> const& rxPropertyContainer, + OUString const& rName) +{ + try + { + uno::Reference<beans::XPropertySet> xPropertySet(rxPropertyContainer, uno::UNO_QUERY); + return xPropertySet->getPropertyValue(rName).get<OUString>(); + } + catch (const css::uno::Exception&) + { + } + + return OUString(); +} + +bool containsProperty(uno::Sequence<beans::Property> const& rProperties, OUString const& rName) +{ + return std::any_of(rProperties.begin(), rProperties.end(), + [&](const beans::Property& rProperty) { return rProperty.Name == rName; }); +} + +void removeAllProperties(uno::Reference<beans::XPropertyContainer> const& rxPropertyContainer) +{ + uno::Reference<beans::XPropertySet> xPropertySet(rxPropertyContainer, uno::UNO_QUERY); + const uno::Sequence<beans::Property> aProperties + = xPropertySet->getPropertySetInfo()->getProperties(); + + for (const beans::Property& rProperty : aProperties) + { + rxPropertyContainer->removeProperty(rProperty.Name); + } +} + +bool addOrInsertDocumentProperty( + uno::Reference<beans::XPropertyContainer> const& rxPropertyContainer, OUString const& rsKey, + OUString const& rsValue) +{ + uno::Reference<beans::XPropertySet> xPropertySet(rxPropertyContainer, uno::UNO_QUERY); + + try + { + if (containsProperty(xPropertySet->getPropertySetInfo()->getProperties(), rsKey)) + xPropertySet->setPropertyValue(rsKey, uno::makeAny(rsValue)); + else + rxPropertyContainer->addProperty(rsKey, beans::PropertyAttribute::REMOVABLE, + uno::makeAny(rsValue)); + } + catch (const uno::Exception& /*rException*/) + { + return false; + } + return true; +} + +void insertFullTextualRepresentationAsDocumentProperty( + uno::Reference<beans::XPropertyContainer> const& rxPropertyContainer, + sfx::ClassificationKeyCreator const& rKeyCreator, + std::vector<svx::ClassificationResult> const& rResults) +{ + OUString sString = convertClassificationResultToString(rResults); + addOrInsertDocumentProperty(rxPropertyContainer, rKeyCreator.makeFullTextualRepresentationKey(), + sString); +} + +void insertCreationOrigin(uno::Reference<beans::XPropertyContainer> const& rxPropertyContainer, + sfx::ClassificationKeyCreator const& rKeyCreator, + sfx::ClassificationCreationOrigin eOrigin) +{ + // Nothing to do if origin is "NONE" + if (eOrigin == sfx::ClassificationCreationOrigin::NONE) + return; + + OUString sValue = (eOrigin == sfx::ClassificationCreationOrigin::BAF_POLICY) + ? OUString("BAF_POLICY") + : OUString("MANUAL"); + addOrInsertDocumentProperty(rxPropertyContainer, rKeyCreator.makeCreationOriginKey(), sValue); +} +} // end svx::classification namespace + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/ClassificationDialog.cxx b/svx/source/dialog/ClassificationDialog.cxx new file mode 100644 index 000000000..25144cc8e --- /dev/null +++ b/svx/source/dialog/ClassificationDialog.cxx @@ -0,0 +1,693 @@ +/* -*- 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/. + * + */ + +#include <svx/ClassificationDialog.hxx> +#include <svx/ClassificationCommon.hxx> + +#include <editeng/flditem.hxx> +#include <editeng/eeitem.hxx> +#include <editeng/section.hxx> +#include <editeng/editobj.hxx> +#include <editeng/wghtitem.hxx> +#include <svl/itemset.hxx> +#include <osl/file.hxx> +#include <rtl/bootstrap.hxx> +#include <config_folders.h> +#include <tools/stream.hxx> +#include <tools/XmlWriter.hxx> +#include <tools/XmlWalker.hxx> +#include <vcl/customweld.hxx> +#include <vcl/event.hxx> +#include <vcl/svapp.hxx> +#include <sfx2/objsh.hxx> + +#include <officecfg/Office/Common.hxx> + +#include "ClassificationEditView.hxx" + +namespace svx { + +IMPL_STATIC_LINK(ClassificationDialog, KeyInput, const KeyEvent&, rKeyEvent, bool) +{ + bool bTextIsFreeForm = officecfg::Office::Common::Classification::IntellectualPropertyTextInputIsFreeForm::get(); + + if (!bTextIsFreeForm) + { + // Ignore key combination with modifier keys + if (rKeyEvent.GetKeyCode().IsMod3() + || rKeyEvent.GetKeyCode().IsMod2() + || rKeyEvent.GetKeyCode().IsMod1()) + { + return true; + } + + switch (rKeyEvent.GetKeyCode().GetCode()) + { + // Allowed characters + case KEY_BACKSPACE: + case KEY_DELETE: + case KEY_DIVIDE: + case KEY_SEMICOLON: + case KEY_SPACE: + return false; + // Anything else is ignored + default: + return true; + break; + } + } + + return false; +} + +namespace { + +constexpr size_t RECENTLY_USED_LIMIT = 5; + +const OUString constRecentlyUsedFileName("recentlyUsed.xml"); + +OUString lcl_getClassificationUserPath() +{ + OUString sPath("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/user/classification/"); + rtl::Bootstrap::expandMacros(sPath); + return sPath; +} + +const SvxFieldItem* findField(editeng::Section const & rSection) +{ + for (SfxPoolItem const * pPool : rSection.maAttributes) + { + if (pPool->Which() == EE_FEATURE_FIELD) + return static_cast<const SvxFieldItem*>(pPool); + } + return nullptr; +} + +bool fileExists(OUString const & sFilename) +{ + osl::File aFile(sFilename); + osl::FileBase::RC eRC = aFile.open(osl_File_OpenFlag_Read); + return osl::FileBase::E_None == eRC; +} + +bool stringToClassificationType(OString const & rsType, svx::ClassificationType & reType) +{ + if (rsType == "CATEGORY") + reType = svx::ClassificationType::CATEGORY; + else if (rsType == "INTELLECTUAL_PROPERTY_PART") + reType = svx::ClassificationType::INTELLECTUAL_PROPERTY_PART; + else if (rsType == "MARKING") + reType = svx::ClassificationType::MARKING; + else if (rsType == "PARAGRAPH") + reType = svx::ClassificationType::PARAGRAPH; + else if (rsType == "TEXT") + reType = svx::ClassificationType::TEXT; + else + return false; + return true; +} + +OUString classificationTypeToString(svx::ClassificationType const & reType) +{ + switch(reType) + { + case svx::ClassificationType::CATEGORY: + return "CATEGORY"; break; + case svx::ClassificationType::MARKING: + return "MARKING"; break; + case svx::ClassificationType::TEXT: + return "TEXT"; break; + case svx::ClassificationType::INTELLECTUAL_PROPERTY_PART: + return "INTELLECTUAL_PROPERTY_PART"; break; + case svx::ClassificationType::PARAGRAPH: + return "PARAGRAPH"; break; + } + return OUString(); +} + +void writeResultToXml(tools::XmlWriter & rXmlWriter, + std::vector<ClassificationResult> const & rResultCollection) +{ + for (ClassificationResult const & rResult : rResultCollection) + { + rXmlWriter.startElement("element"); + OUString sType = classificationTypeToString(rResult.meType); + rXmlWriter.attribute("type", sType); + rXmlWriter.startElement("string"); + rXmlWriter.content(rResult.msName); + rXmlWriter.endElement(); + rXmlWriter.startElement("abbreviatedString"); + rXmlWriter.content(rResult.msAbbreviatedName); + rXmlWriter.endElement(); + rXmlWriter.startElement("identifier"); + rXmlWriter.content(rResult.msIdentifier); + rXmlWriter.endElement(); + rXmlWriter.endElement(); + } +} + +} // end anonymous namespace + +ClassificationDialog::ClassificationDialog(weld::Window* pParent, const bool bPerParagraph, const std::function<void()>& rParagraphSignHandler) + : GenericDialogController(pParent, "svx/ui/classificationdialog.ui", "AdvancedDocumentClassificationDialog") + , maHelper(SfxObjectShell::Current()->getDocProperties()) + , maInternationalHelper(SfxObjectShell::Current()->getDocProperties(), /*bUseLocalizedPolicy*/ false) + , m_bPerParagraph(bPerParagraph) + , m_aParagraphSignHandler(rParagraphSignHandler) + , m_nCurrentSelectedCategory(-1) + , m_xOkButton(m_xBuilder->weld_button("ok")) + , m_xSignButton(m_xBuilder->weld_button("signButton")) + , m_xToolBox(m_xBuilder->weld_toggle_button("toolbox")) + , m_xRecentlyUsedListBox(m_xBuilder->weld_combo_box("recentlyUsedCB")) + , m_xClassificationListBox(m_xBuilder->weld_combo_box("classificationCB")) + , m_xInternationalClassificationListBox(m_xBuilder->weld_combo_box("internationalClassificationCB")) + , m_xMarkingLabel(m_xBuilder->weld_label("markingLabel")) + , m_xMarkingListBox(m_xBuilder->weld_tree_view("markingLB")) + , m_xIntellectualPropertyPartListBox(m_xBuilder->weld_tree_view("intellectualPropertyPartLB")) + , m_xIntellectualPropertyPartNumberListBox(m_xBuilder->weld_tree_view("intellectualPropertyPartNumberLB")) + , m_xIntellectualPropertyPartAddButton(m_xBuilder->weld_button("intellectualPropertyPartAddButton")) + , m_xIntellectualPropertyPartEdit(m_xBuilder->weld_entry("intellectualPropertyPartEntry")) + , m_xIntellectualPropertyExpander(m_xBuilder->weld_expander("intellectualPropertyExpander")) + , m_xEditWindow(new ClassificationEditView) + , m_xEditWindowWeld(new weld::CustomWeld(*m_xBuilder, "classificationEditWindow", *m_xEditWindow)) +{ + m_xOkButton->connect_clicked(LINK(this, ClassificationDialog, OkHdl)); + m_xSignButton->connect_clicked(LINK(this, ClassificationDialog, ButtonClicked)); + m_xSignButton->set_visible(m_bPerParagraph); + + m_xIntellectualPropertyPartEdit->connect_key_press(LINK(this, ClassificationDialog, KeyInput)); + + // no need for BOLD if we do paragraph classification + if (m_bPerParagraph) + { + m_xToolBox->hide(); + } + else + { + m_xToolBox->connect_toggled(LINK(this, ClassificationDialog, SelectToolboxHdl)); + } + + m_xIntellectualPropertyPartAddButton->connect_clicked(LINK(this, ClassificationDialog, ButtonClicked)); + + m_xClassificationListBox->set_size_request(m_xClassificationListBox->get_approximate_digit_width() * 20, -1); + m_xClassificationListBox->connect_changed(LINK(this, ClassificationDialog, SelectClassificationHdl)); + for (const OUString& rName : maHelper.GetBACNames()) + m_xClassificationListBox->append_text(rName); + + m_xInternationalClassificationListBox->set_size_request(m_xInternationalClassificationListBox->get_approximate_digit_width() * 20, -1); + m_xInternationalClassificationListBox->connect_changed(LINK(this, ClassificationDialog, SelectClassificationHdl)); + for (const OUString& rName : maInternationalHelper.GetBACNames()) + m_xInternationalClassificationListBox->append_text(rName); + + if (!maHelper.GetMarkings().empty()) + { + m_xMarkingListBox->set_size_request(m_xMarkingListBox->get_approximate_digit_width() * 10, + m_xMarkingListBox->get_height_rows(4)); + m_xMarkingListBox->connect_row_activated(LINK(this, ClassificationDialog, SelectMarkingHdl)); + + for (const OUString& rName : maHelper.GetMarkings()) + m_xMarkingListBox->append_text(rName); + } + else + { + m_xMarkingListBox->hide(); + m_xMarkingLabel->hide(); + } + + m_xIntellectualPropertyPartNumberListBox->set_size_request(m_xIntellectualPropertyPartNumberListBox->get_approximate_digit_width() * 10, + m_xIntellectualPropertyPartNumberListBox->get_height_rows(5)); + m_xIntellectualPropertyPartNumberListBox->connect_row_activated(LINK(this, ClassificationDialog, SelectIPPartNumbersHdl)); + for (const OUString& rName : maHelper.GetIntellectualPropertyPartNumbers()) + m_xIntellectualPropertyPartNumberListBox->append_text(rName); + + m_xIntellectualPropertyPartNumberListBox->set_size_request(m_xIntellectualPropertyPartNumberListBox->get_approximate_digit_width() * 20, + m_xIntellectualPropertyPartListBox->get_height_rows(5)); + m_xIntellectualPropertyPartListBox->connect_row_activated(LINK(this, ClassificationDialog, SelectIPPartHdl)); + for (const OUString& rName : maHelper.GetIntellectualPropertyParts()) + m_xIntellectualPropertyPartListBox->append_text(rName); + + m_xRecentlyUsedListBox->set_size_request(m_xRecentlyUsedListBox->get_approximate_digit_width() * 5, -1); + m_xRecentlyUsedListBox->connect_changed(LINK(this, ClassificationDialog, SelectRecentlyUsedHdl)); + + m_xIntellectualPropertyExpander->connect_expanded(LINK(this, ClassificationDialog, ExpandedHdl)); + if (officecfg::Office::Common::Classification::IntellectualPropertySectionExpanded::get()) + m_nAsyncExpandEvent = Application::PostUserEvent(LINK(this, ClassificationDialog, OnAsyncExpandHdl)); + else + m_nAsyncExpandEvent = nullptr; + + m_xEditWindow->SetModifyHdl(LINK(this, ClassificationDialog, EditWindowModifiedHdl)); + + readRecentlyUsed(); + toggleWidgetsDependingOnCategory(); + + int nNumber = 1; + if (m_aRecentlyUsedValuesCollection.empty()) + { + m_xRecentlyUsedListBox->set_sensitive(false); + } + else + { + for (std::vector<ClassificationResult> const & rResults : m_aRecentlyUsedValuesCollection) + { + OUString rContentRepresentation = svx::classification::convertClassificationResultToString(rResults); + OUString rDescription = OUString::number(nNumber) + ": " + rContentRepresentation; + nNumber++; + + m_xRecentlyUsedListBox->append_text(rDescription); + } + } +} + +//do it async so gtk has a chance to shrink it to best size, otherwise its larger than min +IMPL_LINK_NOARG(ClassificationDialog, OnAsyncExpandHdl, void*, void) +{ + m_nAsyncExpandEvent = nullptr; + m_xIntellectualPropertyExpander->set_expanded(true); +} + +ClassificationDialog::~ClassificationDialog() +{ + if (m_nAsyncExpandEvent) + Application::RemoveUserEvent(m_nAsyncExpandEvent); +} + +void ClassificationDialog::insertCategoryField(sal_Int32 nID) +{ + const OUString aFullString = maHelper.GetBACNames()[nID]; + const OUString aAbbreviatedString = maHelper.GetAbbreviatedBACNames()[nID]; + const OUString aIdentifierString = maHelper.GetBACIdentifiers()[nID]; + insertField(ClassificationType::CATEGORY, aAbbreviatedString, aFullString, aIdentifierString); +} + +void ClassificationDialog::insertField(ClassificationType eType, OUString const & rString, OUString const & rFullString, OUString const & rIdentifier) +{ + ClassificationField aField(eType, rString, rFullString, rIdentifier); + m_xEditWindow->InsertField(SvxFieldItem(aField, EE_FEATURE_FIELD)); +} + +void ClassificationDialog::setupValues(std::vector<ClassificationResult> const & rInput) +{ + m_aInitialValues = rInput; + readIn(m_aInitialValues); +} + +void ClassificationDialog::readRecentlyUsed() +{ + OUString sPath = lcl_getClassificationUserPath(); + OUString sFilePath(sPath + constRecentlyUsedFileName); + + if (!fileExists(sFilePath)) + return; + + SvFileStream aFileStream(sFilePath, StreamMode::READ); + tools::XmlWalker aWalker; + if (!aWalker.open(&aFileStream)) + return; + + if (aWalker.name() == "recentlyUsedClassifications") + { + aWalker.children(); + while (aWalker.isValid()) + { + if (aWalker.name() == "elementGroup") + { + std::vector<ClassificationResult> aResults; + + aWalker.children(); + + while (aWalker.isValid()) + { + if (aWalker.name() == "element") + { + svx::ClassificationType eType = svx::ClassificationType::TEXT; + OUString sString; + OUString sAbbreviatedString; + OUString sIdentifier; + + // Convert string to classification type, but continue only if + // conversion was successful. + if (stringToClassificationType(aWalker.attribute("type"), eType)) + { + aWalker.children(); + + while (aWalker.isValid()) + { + if (aWalker.name() == "string") + { + sString = OStringToOUString(aWalker.content(), RTL_TEXTENCODING_UTF8); + } + else if (aWalker.name() == "abbreviatedString") + { + sAbbreviatedString = OStringToOUString(aWalker.content(), RTL_TEXTENCODING_UTF8); + } + else if (aWalker.name() == "identifier") + { + sIdentifier = OStringToOUString(aWalker.content(), RTL_TEXTENCODING_UTF8); + } + aWalker.next(); + } + aWalker.parent(); + + aResults.push_back({ eType, sString, sAbbreviatedString, sIdentifier }); + } + } + aWalker.next(); + } + aWalker.parent(); + m_aRecentlyUsedValuesCollection.push_back(aResults); + } + aWalker.next(); + } + aWalker.parent(); + } +} + +void ClassificationDialog::writeRecentlyUsed() +{ + OUString sPath = lcl_getClassificationUserPath(); + osl::Directory::createPath(sPath); + OUString sFilePath(sPath + constRecentlyUsedFileName); + + std::unique_ptr<SvStream> pStream; + pStream.reset(new SvFileStream(sFilePath, StreamMode::STD_READWRITE | StreamMode::TRUNC)); + + tools::XmlWriter aXmlWriter(pStream.get()); + + if (!aXmlWriter.startDocument()) + return; + + aXmlWriter.startElement("recentlyUsedClassifications"); + + aXmlWriter.startElement("elementGroup"); + + writeResultToXml(aXmlWriter, getResult()); + + aXmlWriter.endElement(); + + if (m_aRecentlyUsedValuesCollection.size() >= RECENTLY_USED_LIMIT) + m_aRecentlyUsedValuesCollection.pop_back(); + + for (std::vector<ClassificationResult> const & rResultCollection : m_aRecentlyUsedValuesCollection) + { + aXmlWriter.startElement("elementGroup"); + + writeResultToXml(aXmlWriter, rResultCollection); + + aXmlWriter.endElement(); + } + + aXmlWriter.endElement(); + + aXmlWriter.endDocument(); +} + +void ClassificationDialog::readIn(std::vector<ClassificationResult> const & rInput) +{ + sal_Int32 nParagraph = -1; + + for (ClassificationResult const & rClassificationResult : rInput) + { + + switch (rClassificationResult.meType) + { + case svx::ClassificationType::TEXT: + { + m_xEditWindow->getEditView().InsertText(rClassificationResult.msName); + } + break; + + case svx::ClassificationType::CATEGORY: + { + OUString sName; + if (rClassificationResult.msName.isEmpty()) + sName = maHelper.GetBACNameForIdentifier(rClassificationResult.msIdentifier); + else + sName = rClassificationResult.msName; + + OUString sAbbreviatedName = rClassificationResult.msAbbreviatedName; + if (sAbbreviatedName.isEmpty()) + sAbbreviatedName = maHelper.GetAbbreviatedBACName(sName); + + m_xClassificationListBox->set_active_text(sName); + m_nCurrentSelectedCategory = m_xClassificationListBox->get_active(); + m_xInternationalClassificationListBox->set_active(m_xClassificationListBox->get_active()); + + insertField(rClassificationResult.meType, sAbbreviatedName, sName, rClassificationResult.msIdentifier); + } + break; + + case svx::ClassificationType::MARKING: + { + m_xMarkingListBox->select_text(rClassificationResult.msName); + insertField(rClassificationResult.meType, rClassificationResult.msName, rClassificationResult.msName, rClassificationResult.msIdentifier); + } + break; + + case svx::ClassificationType::INTELLECTUAL_PROPERTY_PART: + { + insertField(rClassificationResult.meType, rClassificationResult.msName, rClassificationResult.msName, rClassificationResult.msIdentifier); + } + break; + + case svx::ClassificationType::PARAGRAPH: + { + nParagraph++; + + if (nParagraph != 0) + m_xEditWindow->getEditView().InsertParaBreak(); + + // Set paragraph font weight + FontWeight eWeight = (rClassificationResult.msName == "BOLD") ? WEIGHT_BOLD : WEIGHT_NORMAL; + + ClassificationEditEngine& rEdEngine = m_xEditWindow->getEditEngine(); + std::unique_ptr<SfxItemSet> pSet(new SfxItemSet(rEdEngine.GetParaAttribs(nParagraph))); + pSet->Put(SvxWeightItem(eWeight, EE_CHAR_WEIGHT)); + rEdEngine.SetParaAttribs(nParagraph, *pSet); + } + break; + + default: + break; + } + } + toggleWidgetsDependingOnCategory(); +} + +void ClassificationDialog::toggleWidgetsDependingOnCategory() +{ + const EditEngine& rEditEngine = m_xEditWindow->getEditEngine(); + + for (sal_Int32 nParagraph = 0; nParagraph < rEditEngine.GetParagraphCount(); ++nParagraph) + { + sal_uInt16 nFieldCount = rEditEngine.GetFieldCount(nParagraph); + for (sal_uInt16 nField = 0; nField < nFieldCount; ++nField) + { + EFieldInfo aFieldInfo = rEditEngine.GetFieldInfo(nParagraph, nField); + if (aFieldInfo.pFieldItem) + { + const ClassificationField* pClassificationField = dynamic_cast<const ClassificationField*>(aFieldInfo.pFieldItem->GetField()); + if (pClassificationField && pClassificationField->meType == ClassificationType::CATEGORY) + { + m_xOkButton->set_sensitive(true); + return; + } + } + } + } + + // Category field in the text edit has been deleted, so reset the list boxes + m_xOkButton->set_sensitive(false); + m_xClassificationListBox->set_active(-1); + m_xInternationalClassificationListBox->set_active(-1); +} + +std::vector<ClassificationResult> ClassificationDialog::getResult() +{ + std::vector<ClassificationResult> aClassificationResults; + + ClassificationEditEngine& rEdEngine = m_xEditWindow->getEditEngine(); + std::unique_ptr<EditTextObject> pEditText(rEdEngine.CreateTextObject()); + + sal_Int32 nCurrentParagraph = -1; + + std::vector<editeng::Section> aSections; + pEditText->GetAllSections(aSections); + for (editeng::Section const & rSection : aSections) + { + while (nCurrentParagraph < rSection.mnParagraph) + { + nCurrentParagraph++; + + // Get Weight of current paragraph + FontWeight eFontWeight = WEIGHT_NORMAL; + SfxItemSet aItemSet(rEdEngine.GetParaAttribs(nCurrentParagraph)); + if (const SfxPoolItem* pItem = aItemSet.GetItem(EE_CHAR_WEIGHT, false)) + { + const SvxWeightItem* pWeightItem = dynamic_cast<const SvxWeightItem*>(pItem); + if (pWeightItem && pWeightItem->GetWeight() == WEIGHT_BOLD) + eFontWeight = WEIGHT_BOLD; + } + // Font weight to string + OUString sWeightProperty = "NORMAL"; + if (eFontWeight == WEIGHT_BOLD) + sWeightProperty = "BOLD"; + // Insert into collection + OUString sBlank; + aClassificationResults.push_back({ ClassificationType::PARAGRAPH, sWeightProperty, sBlank, sBlank }); + } + + const SvxFieldItem* pFieldItem = findField(rSection); + + ESelection aSelection(rSection.mnParagraph, rSection.mnStart, rSection.mnParagraph, rSection.mnEnd); + const OUString sDisplayString = rEdEngine.GetText(aSelection); + if (!sDisplayString.isEmpty()) + { + const ClassificationField* pClassificationField = pFieldItem ? dynamic_cast<const ClassificationField*>(pFieldItem->GetField()) : nullptr; + + if (pClassificationField) + { + aClassificationResults.push_back({ pClassificationField->meType, pClassificationField->msFullClassName, + pClassificationField->msDescription, pClassificationField->msIdentifier }); + } + else + { + aClassificationResults.push_back({ ClassificationType::TEXT, sDisplayString, sDisplayString, OUString() }); + } + } + } + + return aClassificationResults; +} + +IMPL_LINK(ClassificationDialog, SelectClassificationHdl, weld::ComboBox&, rBox, void) +{ + const sal_Int32 nSelected = rBox.get_active(); + if (nSelected < 0 || m_nCurrentSelectedCategory == nSelected) + return; + + std::unique_ptr<EditTextObject> pEditText(m_xEditWindow->getEditEngine().CreateTextObject()); + std::vector<editeng::Section> aSections; + pEditText->GetAllSections(aSections); + + // if we are replacing an existing field + bool bReplaceExisting = false; + // selection of the existing field, which will be replaced + ESelection aExistingFieldSelection; + + for (editeng::Section const & rSection : aSections) + { + const SvxFieldItem* pFieldItem = findField(rSection); + if (pFieldItem) + { + const ClassificationField* pClassificationField = dynamic_cast<const ClassificationField*>(pFieldItem->GetField()); + if (pClassificationField && pClassificationField->meType == ClassificationType::CATEGORY) + { + aExistingFieldSelection = ESelection(rSection.mnParagraph, rSection.mnStart, + rSection.mnParagraph, rSection.mnEnd); + bReplaceExisting = true; + } + } + } + + if (bReplaceExisting) + m_xEditWindow->getEditView().SetSelection(aExistingFieldSelection); + + insertCategoryField(nSelected); + + // Change category to the new selection + m_xInternationalClassificationListBox->set_active(nSelected); + m_xClassificationListBox->set_active(nSelected); + m_nCurrentSelectedCategory = nSelected; +} + +IMPL_LINK(ClassificationDialog, SelectMarkingHdl, weld::TreeView&, rBox, bool) +{ + sal_Int32 nSelected = rBox.get_selected_index(); + if (nSelected >= 0) + { + const OUString aString = maHelper.GetMarkings()[nSelected]; + insertField(ClassificationType::MARKING, aString, aString); + } + return true; +} + +IMPL_LINK(ClassificationDialog, SelectIPPartNumbersHdl, weld::TreeView&, rBox, bool) +{ + sal_Int32 nSelected = rBox.get_selected_index(); + if (nSelected >= 0) + { + OUString sString = maHelper.GetIntellectualPropertyPartNumbers()[nSelected]; + m_xIntellectualPropertyPartEdit->replace_selection(sString); + m_xIntellectualPropertyPartEdit->grab_focus(); + } + return true; +} + +IMPL_LINK(ClassificationDialog, SelectRecentlyUsedHdl, weld::ComboBox&, rBox, void) +{ + sal_Int32 nSelected = rBox.get_active(); + if (nSelected >= 0) + { + m_xEditWindow->getEditEngine().Clear(); + readIn(m_aRecentlyUsedValuesCollection[nSelected]); + } +} + +IMPL_LINK(ClassificationDialog, SelectIPPartHdl, weld::TreeView&, rBox, bool) +{ + const sal_Int32 nSelected = rBox.get_selected_index(); + if (nSelected >= 0) + { + const OUString sString = maHelper.GetIntellectualPropertyParts()[nSelected]; + m_xIntellectualPropertyPartEdit->replace_selection(sString); + m_xIntellectualPropertyPartEdit->grab_focus(); + } + return true; +} + +IMPL_LINK(ClassificationDialog, ButtonClicked, weld::Button&, rButton, void) +{ + if (&rButton == m_xSignButton.get()) + { + m_aParagraphSignHandler(); + } + else if (&rButton == m_xIntellectualPropertyPartAddButton.get()) + { + const OUString sString = m_xIntellectualPropertyPartEdit->get_text(); + insertField(ClassificationType::INTELLECTUAL_PROPERTY_PART, sString, sString); + } +} + +IMPL_LINK_NOARG(ClassificationDialog, OkHdl, weld::Button&, void) +{ + writeRecentlyUsed(); + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(ClassificationDialog, SelectToolboxHdl, weld::ToggleButton&, void) +{ + m_xEditWindow->InvertSelectionWeight(); +} + +IMPL_LINK_NOARG(ClassificationDialog, EditWindowModifiedHdl, LinkParamNone*, void) +{ + toggleWidgetsDependingOnCategory(); +} + +IMPL_STATIC_LINK(ClassificationDialog, ExpandedHdl, weld::Expander&, rExpander, void) +{ + std::shared_ptr<comphelper::ConfigurationChanges> aConfigurationChanges(comphelper::ConfigurationChanges::create()); + officecfg::Office::Common::Classification::IntellectualPropertySectionExpanded::set(rExpander.get_expanded(), aConfigurationChanges); + aConfigurationChanges->commit(); +} + +} // end svx + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/ClassificationEditView.cxx b/svx/source/dialog/ClassificationEditView.cxx new file mode 100644 index 000000000..4dd5c337e --- /dev/null +++ b/svx/source/dialog/ClassificationEditView.cxx @@ -0,0 +1,81 @@ +/* -*- 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/. + * + */ + +#include <svx/ClassificationField.hxx> + +#include <svl/itemset.hxx> +#include <editeng/wghtitem.hxx> +#include <editeng/eeitem.hxx> + +#include "ClassificationEditView.hxx" + +namespace svx { + +ClassificationEditEngine::ClassificationEditEngine(SfxItemPool* pItemPool) + : EditEngine(pItemPool) +{} + +OUString ClassificationEditEngine::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 /*nPara*/, + sal_Int32 /*nPos*/, std::optional<Color>& /*rTxtColor*/, std::optional<Color>& /*rFldColor*/) +{ + OUString aString; + const ClassificationField* pClassificationField = dynamic_cast<const ClassificationField*>(rField.GetField()); + if (pClassificationField) + aString = pClassificationField->msDescription; + else + aString = "Unknown"; + return aString; +} + +ClassificationEditView::ClassificationEditView() +{ +} + +void ClassificationEditView::makeEditEngine() +{ + m_xEditEngine.reset(new ClassificationEditEngine(EditEngine::CreatePool())); +} + +ClassificationEditView::~ClassificationEditView() +{ +} + +void ClassificationEditView::InsertField(const SvxFieldItem& rFieldItem) +{ + m_xEditView->InsertField(rFieldItem); + m_xEditView->Invalidate(); +} + +void ClassificationEditView::InvertSelectionWeight() +{ + ESelection aSelection = m_xEditView->GetSelection(); + + for (sal_Int32 nParagraph = aSelection.nStartPara; nParagraph <= aSelection.nEndPara; ++nParagraph) + { + FontWeight eFontWeight = WEIGHT_BOLD; + + std::unique_ptr<SfxItemSet> pSet(new SfxItemSet(m_xEditEngine->GetParaAttribs(nParagraph))); + if (const SfxPoolItem* pItem = pSet->GetItem(EE_CHAR_WEIGHT, false)) + { + const SvxWeightItem* pWeightItem = dynamic_cast<const SvxWeightItem*>(pItem); + if (pWeightItem && pWeightItem->GetWeight() == WEIGHT_BOLD) + eFontWeight = WEIGHT_NORMAL; + } + SvxWeightItem aWeight(eFontWeight, EE_CHAR_WEIGHT); + pSet->Put(aWeight); + m_xEditEngine->SetParaAttribs(nParagraph, *pSet); + } + + m_xEditView->Invalidate(); +} + +} // end sfx2 + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/ClassificationEditView.hxx b/svx/source/dialog/ClassificationEditView.hxx new file mode 100644 index 000000000..96adf83ab --- /dev/null +++ b/svx/source/dialog/ClassificationEditView.hxx @@ -0,0 +1,57 @@ +/* -*- 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/. + * + */ + +#ifndef INCLUDED_SVX_CLASSIFICATIONEDITVIEW_HXX +#define INCLUDED_SVX_CLASSIFICATIONEDITVIEW_HXX + +#include <sal/config.h> +#include <svx/svxdllapi.h> +#include <svx/weldeditview.hxx> +#include <editeng/svxenum.hxx> +#include <vcl/customweld.hxx> + +namespace svx { + +class ClassificationEditEngine final : public EditEngine +{ +public: + ClassificationEditEngine(SfxItemPool* pItemPool); + + virtual OUString CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, std::optional<Color>& rTxtColor, std::optional<Color>& rFldColor) override; +}; + +class ClassificationEditView final : public WeldEditView +{ +public: + ClassificationEditView(); + virtual ~ClassificationEditView() override; + + virtual void makeEditEngine() override; + + void InsertField(const SvxFieldItem& rField); + + void InvertSelectionWeight(); + + ClassificationEditEngine& getEditEngine() + { + return *static_cast<ClassificationEditEngine*>(m_xEditEngine.get()); + } + + EditView& getEditView() + { + return *m_xEditView; + } +}; + +} // end svx namespace + +#endif // INCLUDED_SVX_CLASSIFICATIONEDITVIEW_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/SafeModeDialog.cxx b/svx/source/dialog/SafeModeDialog.cxx new file mode 100644 index 000000000..b74d2a93d --- /dev/null +++ b/svx/source/dialog/SafeModeDialog.cxx @@ -0,0 +1,342 @@ +/* -*- 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/. + */ + +#include "SafeModeDialog.hxx" + +#include <osl/file.hxx> +#include <sfx2/safemode.hxx> +#include <tools/diagnose_ex.h> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> +#include <comphelper/processfactory.hxx> +#include <unotools/ZipPackageHelper.hxx> +#include <unotools/configmgr.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> + +#include <com/sun/star/task/OfficeRestartManager.hpp> +#include <com/sun/star/task/XInteractionHandler.hpp> +#include <com/sun/star/system/XSystemShellExecute.hpp> +#include <com/sun/star/system/SystemShellExecuteFlags.hpp> +#include <com/sun/star/system/SystemShellExecute.hpp> + +using namespace css; + +SafeModeDialog::SafeModeDialog(weld::Window* pParent) + : GenericDialogController(pParent, "svx/ui/safemodedialog.ui", "SafeModeDialog") + , mxBtnContinue(m_xBuilder->weld_button("btn_continue")) + , mxBtnRestart(m_xBuilder->weld_button("btn_restart")) + , mxBtnApply(m_xBuilder->weld_button("btn_apply")) + , mxBoxRestore(m_xBuilder->weld_container("group_restore")) + , mxBoxConfigure(m_xBuilder->weld_container("group_configure")) + , mxBoxDeinstall(m_xBuilder->weld_container("group_deinstall")) + , mxBoxReset(m_xBuilder->weld_container("group_reset")) + , mxRadioRestore(m_xBuilder->weld_radio_button("radio_restore")) + , mxRadioConfigure(m_xBuilder->weld_radio_button("radio_configure")) + , mxRadioExtensions(m_xBuilder->weld_radio_button("radio_extensions")) + , mxRadioReset(m_xBuilder->weld_radio_button("radio_reset")) + , mxCBCheckProfilesafeConfig(m_xBuilder->weld_check_button("check_profilesafe_config")) + , mxCBCheckProfilesafeExtensions(m_xBuilder->weld_check_button("check_profilesafe_extensions")) + , mxCBDisableAllExtensions(m_xBuilder->weld_check_button("check_disable_all_extensions")) + , mxCBDeinstallUserExtensions(m_xBuilder->weld_check_button("check_deinstall_user_extensions")) + , mxCBResetSharedExtensions(m_xBuilder->weld_check_button("check_reset_shared_extensions")) + , mxCBResetBundledExtensions(m_xBuilder->weld_check_button("check_reset_bundled_extensions")) + , mxCBDisableHWAcceleration(m_xBuilder->weld_check_button("check_disable_hw_acceleration")) + , mxCBResetCustomizations(m_xBuilder->weld_check_button("check_reset_customizations")) + , mxCBResetWholeUserProfile(m_xBuilder->weld_check_button("check_reset_whole_userprofile")) + , mxBugLink(m_xBuilder->weld_link_button("linkbutton_bugs")) + , mxUserProfileLink(m_xBuilder->weld_link_button("linkbutton_profile")) + , mxBtnCreateZip(m_xBuilder->weld_button("btn_create_zip")) + , mxExpander(m_xBuilder->weld_expander("expander")) + , maBackupFileHelper() +{ + m_xDialog->set_centered_on_parent(false); + mxRadioRestore->connect_clicked(LINK(this, SafeModeDialog, RadioBtnHdl)); + mxRadioConfigure->connect_clicked(LINK(this, SafeModeDialog, RadioBtnHdl)); + mxRadioExtensions->connect_clicked(LINK(this, SafeModeDialog, RadioBtnHdl)); + mxRadioReset->connect_clicked(LINK(this, SafeModeDialog, RadioBtnHdl)); + + mxBtnContinue->connect_clicked(LINK(this, SafeModeDialog, DialogBtnHdl)); + mxBtnRestart->connect_clicked(LINK(this, SafeModeDialog, DialogBtnHdl)); + mxBtnApply->connect_clicked(LINK(this, SafeModeDialog, DialogBtnHdl)); + + mxCBCheckProfilesafeConfig->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBCheckProfilesafeExtensions->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBDisableAllExtensions->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBDeinstallUserExtensions->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBResetSharedExtensions->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBResetBundledExtensions->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBDisableHWAcceleration->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBResetCustomizations->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + mxCBResetWholeUserProfile->connect_toggled(LINK(this, SafeModeDialog, CheckBoxHdl)); + + mxBtnCreateZip->connect_clicked(LINK(this, SafeModeDialog, CreateZipBtnHdl)); + + // Disable restart btn until some checkbox is active + mxBtnApply->set_sensitive(false); + + // Check the first radio button and call its handler, + // it'll disable the relevant parts + mxRadioRestore->set_active(true); + RadioBtnHdl(*mxRadioRestore); + + // Set URL for help button (module=safemode) + OUString sURL("http://hub.libreoffice.org/send-feedback/?LOversion=" + utl::ConfigManager::getAboutBoxProductVersion() + + "&LOlocale=" + utl::ConfigManager::getUILocale() + "&LOmodule=safemode"); + mxBugLink->set_uri(sURL); + + mxUserProfileLink->set_uri(comphelper::BackupFileHelper::getUserProfileURL()); +} + +SafeModeDialog::~SafeModeDialog() +{ +} + +void SafeModeDialog::enableDisableWidgets() +{ + mxCBCheckProfilesafeConfig->set_sensitive(maBackupFileHelper.isPopPossible()); + mxCBCheckProfilesafeExtensions->set_sensitive(maBackupFileHelper.isPopPossibleExtensionInfo()); + mxCBDisableAllExtensions->set_sensitive(comphelper::BackupFileHelper::isTryDisableAllExtensionsPossible()); + mxCBDeinstallUserExtensions->set_sensitive(comphelper::BackupFileHelper::isTryDeinstallUserExtensionsPossible()); + mxCBResetSharedExtensions->set_sensitive(comphelper::BackupFileHelper::isTryResetSharedExtensionsPossible()); + mxCBResetBundledExtensions->set_sensitive(comphelper::BackupFileHelper::isTryResetBundledExtensionsPossible()); + mxCBResetCustomizations->set_sensitive(comphelper::BackupFileHelper::isTryResetCustomizationsPossible()); + + // no disable of mxCBResetWholeUserProfile, always possible (as last choice) +} + +short SafeModeDialog::run() +{ + short nRet = weld::GenericDialogController::run(); + // Remove the safe mode flag before exiting this dialog + sfx2::SafeMode::removeFlag(); + return nRet; +} + +void SafeModeDialog::applyChanges() +{ + // Restore + if (mxRadioRestore->get_active()) + { + if (mxCBCheckProfilesafeConfig->get_active()) + { + // reset UserConfiguration to last known working state + // ProfileSafeMode/BackupFileHelper + maBackupFileHelper.tryPop(); + } + + if (mxCBCheckProfilesafeExtensions->get_active()) + { + // reset State of installed Extensions to last known working state + // ProfileSafeMode/BackupFileHelper + maBackupFileHelper.tryPopExtensionInfo(); + } + } + + // Configure + if (mxRadioConfigure->get_active()) + { + if (mxCBDisableAllExtensions->get_active()) + { + // Disable all extensions + comphelper::BackupFileHelper::tryDisableAllExtensions(); + } + + if (mxCBDisableHWAcceleration->get_active()) + { + comphelper::BackupFileHelper::tryDisableHWAcceleration(); + } + } + + // Deinstall + if (mxRadioExtensions->get_active()) + { + if (mxCBDeinstallUserExtensions->get_active()) + { + // Deinstall all User Extensions (installed for User only) + comphelper::BackupFileHelper::tryDeinstallUserExtensions(); + } + + if (mxCBResetSharedExtensions->get_active()) + { + // Reset shared Extensions + comphelper::BackupFileHelper::tryResetSharedExtensions(); + } + if (mxCBResetBundledExtensions->get_active()) + { + // Reset bundled Extensions + comphelper::BackupFileHelper::tryResetBundledExtensions(); + } + } + + // Reset + if (mxRadioReset->get_active()) + { + if (mxCBResetCustomizations->get_active()) + { + // Reset customizations (Settings and UserInterface modifications) + comphelper::BackupFileHelper::tryResetCustomizations(); + } + + if (mxCBResetWholeUserProfile->get_active()) + { + // Reset the whole UserProfile + comphelper::BackupFileHelper::tryResetUserProfile(); + } + } + + // finally, restart + css::task::OfficeRestartManager::get(comphelper::getProcessComponentContext())->requestRestart( + css::uno::Reference< css::task::XInteractionHandler >()); +} + +IMPL_LINK(SafeModeDialog, RadioBtnHdl, weld::Button&, rBtn, void) +{ + if (&rBtn == mxRadioRestore.get()) + { + // Enable the currently selected box + mxBoxRestore->set_sensitive(true); + // Make sure only possible choices are active + enableDisableWidgets(); + // Disable the unselected boxes + mxBoxReset->set_sensitive(false); + mxBoxConfigure->set_sensitive(false); + mxBoxDeinstall->set_sensitive(false); + } + else if (&rBtn == mxRadioConfigure.get()) + { + // Enable the currently selected box + mxBoxConfigure->set_sensitive(true); + // Make sure only possible choices are active + enableDisableWidgets(); + // Disable the unselected boxes + mxBoxRestore->set_sensitive(false); + mxBoxReset->set_sensitive(false); + mxBoxDeinstall->set_sensitive(false); + + } + else if (&rBtn == mxRadioExtensions.get()) + { + // Enable the currently selected box + mxBoxDeinstall->set_sensitive(true); + // Make sure only possible choices are active + enableDisableWidgets(); + // Disable the unselected boxes + mxBoxRestore->set_sensitive(false); + mxBoxConfigure->set_sensitive(false); + mxBoxReset->set_sensitive(false); + } + else if (&rBtn == mxRadioReset.get()) + { + // Enable the currently selected box + mxBoxReset->set_sensitive(true); + // Make sure only possible choices are active + enableDisableWidgets(); + // Disable the unselected boxes + mxBoxConfigure->set_sensitive(false); + mxBoxRestore->set_sensitive(false); + mxBoxDeinstall->set_sensitive(false); + } +} + +IMPL_LINK(SafeModeDialog, DialogBtnHdl, weld::Button&, rBtn, void) +{ + if (&rBtn == mxBtnContinue.get()) + { + m_xDialog->response(RET_CLOSE); + } + else if (&rBtn == mxBtnRestart.get()) + { + sfx2::SafeMode::putRestartFlag(); + m_xDialog->response(RET_CLOSE); + uno::Reference< uno::XComponentContext > xContext = comphelper::getProcessComponentContext(); + css::task::OfficeRestartManager::get(xContext)->requestRestart( + css::uno::Reference< css::task::XInteractionHandler >()); + } + else if (&rBtn == mxBtnApply.get()) + { + sfx2::SafeMode::putRestartFlag(); + m_xDialog->response(RET_CLOSE); + applyChanges(); + } +} + +namespace { + class ProfileExportedDialog : public weld::GenericDialogController + { + private: + std::unique_ptr<weld::Button> m_xButton; + + DECL_LINK(OpenHdl, weld::Button&, void); + public: + explicit ProfileExportedDialog(weld::Window* pParent); + }; + + ProfileExportedDialog::ProfileExportedDialog(weld::Window* pParent) + : GenericDialogController(pParent, "svx/ui/profileexporteddialog.ui", "ProfileExportedDialog") + , m_xButton(m_xBuilder->weld_button("ok")) + { + m_xButton->connect_clicked(LINK(this, ProfileExportedDialog, OpenHdl)); + } + + IMPL_LINK_NOARG(ProfileExportedDialog, OpenHdl, weld::Button&, void) + { + const OUString uri(comphelper::BackupFileHelper::getUserProfileURL()); + css::uno::Reference< css::system::XSystemShellExecute > exec( + css::system::SystemShellExecute::create(comphelper::getProcessComponentContext())); + try { + exec->execute(uri, OUString(), css::system::SystemShellExecuteFlags::URIS_ONLY); + } catch (const css::uno::Exception &) { + TOOLS_WARN_EXCEPTION("svx.dialog", "opening <" << uri << "> failed:"); + } + m_xDialog->response(RET_OK); + } +} + +IMPL_LINK(SafeModeDialog, CreateZipBtnHdl, weld::Button&, /*rBtn*/, void) +{ + const OUString zipFileName("libreoffice-profile.zip"); + const OUString zipFileURL(comphelper::BackupFileHelper::getUserProfileURL() + "/" + zipFileName); + osl::File::remove(zipFileURL); // Remove previous exports + try + { + utl::ZipPackageHelper aZipHelper(comphelper::getProcessComponentContext(), zipFileURL); + aZipHelper.addFolderWithContent(aZipHelper.getRootFolder(), comphelper::BackupFileHelper::getUserProfileWorkURL()); + aZipHelper.savePackage(); + } + catch (const uno::Exception &) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + SvxResId(RID_SVXSTR_SAFEMODE_ZIP_FAILURE))); + xBox->run(); + return; + } + + ProfileExportedDialog aDialog(m_xDialog.get()); + aDialog.run(); +} + +IMPL_LINK(SafeModeDialog, CheckBoxHdl, weld::ToggleButton&, /*pCheckBox*/, void) +{ + const bool bEnable( + mxCBCheckProfilesafeConfig->get_active() || + mxCBCheckProfilesafeExtensions->get_active() || + mxCBDisableAllExtensions->get_active() || + mxCBDeinstallUserExtensions->get_active() || + mxCBResetSharedExtensions->get_active() || + mxCBResetBundledExtensions->get_active() || + mxCBDisableHWAcceleration->get_active() || + mxCBResetCustomizations->get_active() || + mxCBResetWholeUserProfile->get_active()); + + mxBtnApply->set_sensitive(bEnable); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/SafeModeDialog.hxx b/svx/source/dialog/SafeModeDialog.hxx new file mode 100644 index 000000000..daba66caf --- /dev/null +++ b/svx/source/dialog/SafeModeDialog.hxx @@ -0,0 +1,67 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_SVX_SOURCE_DIALOG_SAFEMODEDIALOG_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_SAFEMODEDIALOG_HXX + +#include <comphelper/backupfilehelper.hxx> +#include <vcl/weld.hxx> + +class SafeModeDialog : public weld::GenericDialogController +{ +public: + explicit SafeModeDialog(weld::Window* pParent); + virtual short run() override; + virtual ~SafeModeDialog() override; + +private: + std::unique_ptr<weld::Button> mxBtnContinue; + std::unique_ptr<weld::Button> mxBtnRestart; + std::unique_ptr<weld::Button> mxBtnApply; + + std::unique_ptr<weld::Container> mxBoxRestore; + std::unique_ptr<weld::Container> mxBoxConfigure; + std::unique_ptr<weld::Container> mxBoxDeinstall; + std::unique_ptr<weld::Container> mxBoxReset; + + std::unique_ptr<weld::RadioButton> mxRadioRestore; + std::unique_ptr<weld::RadioButton> mxRadioConfigure; + std::unique_ptr<weld::RadioButton> mxRadioExtensions; + std::unique_ptr<weld::RadioButton> mxRadioReset; + + std::unique_ptr<weld::CheckButton> mxCBCheckProfilesafeConfig; + std::unique_ptr<weld::CheckButton> mxCBCheckProfilesafeExtensions; + std::unique_ptr<weld::CheckButton> mxCBDisableAllExtensions; + std::unique_ptr<weld::CheckButton> mxCBDeinstallUserExtensions; + std::unique_ptr<weld::CheckButton> mxCBResetSharedExtensions; + std::unique_ptr<weld::CheckButton> mxCBResetBundledExtensions; + std::unique_ptr<weld::CheckButton> mxCBDisableHWAcceleration; + std::unique_ptr<weld::CheckButton> mxCBResetCustomizations; + std::unique_ptr<weld::CheckButton> mxCBResetWholeUserProfile; + + std::unique_ptr<weld::LinkButton> mxBugLink; + std::unique_ptr<weld::LinkButton> mxUserProfileLink; + std::unique_ptr<weld::Button> mxBtnCreateZip; + std::unique_ptr<weld::Expander> mxExpander; + + // local BackupFileHelper for handling possible restores + comphelper::BackupFileHelper maBackupFileHelper; + + void enableDisableWidgets(); + void applyChanges(); + + DECL_LINK(RadioBtnHdl, weld::Button&, void); + DECL_LINK(CheckBoxHdl, weld::ToggleButton&, void); + DECL_LINK(CreateZipBtnHdl, weld::Button&, void); + DECL_LINK(DialogBtnHdl, weld::Button&, void); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/SafeModeUI.cxx b/svx/source/dialog/SafeModeUI.cxx new file mode 100644 index 000000000..541057e0c --- /dev/null +++ b/svx/source/dialog/SafeModeUI.cxx @@ -0,0 +1,81 @@ +/* -*- 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/. + */ + +#include <cppuhelper/implbase.hxx> +#include <com/sun/star/frame/XSynchronousDispatch.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> + +#include <cppuhelper/supportsservice.hxx> + +#include <vcl/svapp.hxx> +#include <vcl/window.hxx> + +#include "SafeModeDialog.hxx" + +namespace { + +class SafeModeUI : public ::cppu::WeakImplHelper< css::lang::XServiceInfo, + css::frame::XSynchronousDispatch > // => XDispatch! +{ +public: + SafeModeUI(); + + // css.lang.XServiceInfo + virtual OUString SAL_CALL getImplementationName() override; + + virtual sal_Bool SAL_CALL supportsService(const OUString& sServiceName) override; + + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + + virtual css::uno::Any SAL_CALL dispatchWithReturnValue(const css::util::URL& aURL, + const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override; +}; + +SafeModeUI::SafeModeUI() +{ +} + +OUString SAL_CALL SafeModeUI::getImplementationName() +{ + return "com.sun.star.comp.svx.SafeModeUI"; +} + +sal_Bool SAL_CALL SafeModeUI::supportsService(const OUString& sServiceName) +{ + return cppu::supportsService(this, sServiceName); +} + +css::uno::Sequence< OUString > SAL_CALL SafeModeUI::getSupportedServiceNames() +{ + return { "com.sun.star.dialog.SafeModeUI" }; +} + +css::uno::Any SAL_CALL SafeModeUI::dispatchWithReturnValue(const css::util::URL&, + const css::uno::Sequence< css::beans::PropertyValue >& ) +{ + SolarMutexGuard aGuard; + css::uno::Any aRet; + vcl::Window* pParentWindow = Application::GetDefDialogParent(); + SafeModeDialog aDialog(pParentWindow ? pParentWindow->GetFrameWeld() : nullptr); + aDialog.run(); + return aRet; +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_comp_svx_SafeModeUI_get_implementation( + css::uno::XComponentContext * /*context*/, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new SafeModeUI); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/SpellDialogChildWindow.cxx b/svx/source/dialog/SpellDialogChildWindow.cxx new file mode 100644 index 000000000..ae82769df --- /dev/null +++ b/svx/source/dialog/SpellDialogChildWindow.cxx @@ -0,0 +1,90 @@ +/* -*- 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/SpellDialogChildWindow.hxx> + +#include <svx/svxdlg.hxx> +#include <osl/diagnose.h> + +namespace svx { + + +SpellDialogChildWindow::SpellDialogChildWindow ( + vcl::Window* _pParent, + sal_uInt16 nId, + SfxBindings* pBindings) + : SfxChildWindow (_pParent, nId) +{ + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + m_xAbstractSpellDialog = pFact->CreateSvxSpellDialog(_pParent->GetFrameWeld(), + pBindings, + this ); + SetController(m_xAbstractSpellDialog->GetController()); + SetHideNotDelete(true); +} + +SpellDialogChildWindow::~SpellDialogChildWindow() +{ + m_xAbstractSpellDialog.disposeAndClear(); +} + +SfxBindings& SpellDialogChildWindow::GetBindings() const +{ + assert(m_xAbstractSpellDialog); + return m_xAbstractSpellDialog->GetBindings(); +} + +void SpellDialogChildWindow::InvalidateSpellDialog() +{ + OSL_ASSERT (m_xAbstractSpellDialog); + if (m_xAbstractSpellDialog) + m_xAbstractSpellDialog->InvalidateDialog(); +} + +bool SpellDialogChildWindow::HasAutoCorrection() +{ + return false; +} + +void SpellDialogChildWindow::AddAutoCorrection( + const OUString& /*rOld*/, + const OUString& /*rNew*/, + LanguageType /*eLanguage*/) +{ + OSL_FAIL("AutoCorrection should have been overridden - if available"); +} + +bool SpellDialogChildWindow::HasGrammarChecking() +{ + return false; +} + +bool SpellDialogChildWindow::IsGrammarChecking() +{ + OSL_FAIL("Grammar checking should have been overridden - if available"); + return false; +} + +void SpellDialogChildWindow::SetGrammarChecking(bool ) +{ + OSL_FAIL("Grammar checking should have been overridden - if available"); +} +} // end of namespace ::svx + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/SvxNumOptionsTabPageHelper.cxx b/svx/source/dialog/SvxNumOptionsTabPageHelper.cxx new file mode 100644 index 000000000..5eb062b17 --- /dev/null +++ b/svx/source/dialog/SvxNumOptionsTabPageHelper.cxx @@ -0,0 +1,88 @@ +/* -*- 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/SvxNumOptionsTabPageHelper.hxx> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/text/DefaultNumberingProvider.hpp> +#include <com/sun/star/text/XNumberingTypeInfo.hpp> +#include <comphelper/processfactory.hxx> + +using namespace css; +using namespace css::uno; +using namespace css::text; +using namespace css::style; + +Reference<XDefaultNumberingProvider> SvxNumOptionsTabPageHelper::GetNumberingProvider() +{ + Reference<XComponentContext> xContext( ::comphelper::getProcessComponentContext() ); + Reference<XDefaultNumberingProvider> xRet = text::DefaultNumberingProvider::create(xContext); + return xRet; +} + +void SvxNumOptionsTabPageHelper::GetI18nNumbering(weld::ComboBox& rFmtLB, sal_uInt16 nDoNotRemove) +{ + Reference<XDefaultNumberingProvider> xDefNum = GetNumberingProvider(); + Reference<XNumberingTypeInfo> xInfo(xDefNum, UNO_QUERY); + + // Extended numbering schemes present in the resource but not offered by + // the i18n framework per configuration must be removed from the listbox. + // Do not remove a special entry matching nDoNotRemove. + const sal_uInt16 nDontRemove = SAL_MAX_UINT16; + ::std::vector< sal_uInt16> aRemove( rFmtLB.get_count(), nDontRemove); + for (size_t i=0; i<aRemove.size(); ++i) + { + sal_uInt16 nEntryData = rFmtLB.get_id(i).toInt32(); + if (nEntryData > NumberingType::CHARS_LOWER_LETTER_N && nEntryData != nDoNotRemove) + aRemove[i] = nEntryData; + } + if(xInfo.is()) + { + Sequence<sal_Int16> aTypes = xInfo->getSupportedNumberingTypes( ); + for(const sal_Int16 nCurrent : aTypes) + { + if(nCurrent > NumberingType::CHARS_LOWER_LETTER_N) + { + bool bInsert = true; + for (int nEntry = 0; nEntry < rFmtLB.get_count(); ++nEntry) + { + sal_uInt16 nEntryData = rFmtLB.get_id(nEntry).toInt32(); + if (nEntryData == static_cast<sal_uInt16>(nCurrent)) + { + bInsert = false; + aRemove[nEntry] = nDontRemove; + break; + } + } + if(bInsert) + { + OUString aIdent = xInfo->getNumberingIdentifier( nCurrent ); + rFmtLB.append(OUString::number(nCurrent), aIdent); + } + } + } + } + for (unsigned short i : aRemove) + { + if (i == nDontRemove) + continue; + rFmtLB.remove_id(OUString::number(i)); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/_bmpmask.cxx b/svx/source/dialog/_bmpmask.cxx new file mode 100644 index 000000000..05957ba37 --- /dev/null +++ b/svx/source/dialog/_bmpmask.cxx @@ -0,0 +1,1057 @@ +/* -*- 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/event.hxx> +#include <vcl/metaact.hxx> +#include <vcl/virdev.hxx> +#include <svtools/valueset.hxx> +#include <svl/eitem.hxx> +#include <sfx2/dispatch.hxx> +#include <svtools/colrdlg.hxx> + +#include <svx/colorbox.hxx> +#include <svx/dialmgr.hxx> +#include <svx/bmpmask.hxx> +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include <memory> +#include <helpids.h> + +#define OWN_CALLMODE SfxCallMode::ASYNCHRON | SfxCallMode::RECORD + + +#define TEST_COLS() \ +{ \ + nR = aCol.GetRed(); nG = aCol.GetGreen(); nB = aCol.GetBlue(); \ + for( i = 0; i < nCount; i++ ) \ + { \ + if ( ( pMinR[i] <= nR ) && ( pMaxR[i] >= nR ) && \ + ( pMinG[i] <= nG ) && ( pMaxG[i] >= nG ) && \ + ( pMinB[i] <= nB ) && ( pMaxB[i] >= nB ) ) \ + { \ + aCol = pDstCols[i]; bReplace = true; break; \ + } \ + } \ +} + +SFX_IMPL_DOCKINGWINDOW_WITHID( SvxBmpMaskChildWindow, SID_BMPMASK ) + +class BmpColorWindow : public weld::CustomWidgetController +{ + Color aColor; + + +public: + explicit BmpColorWindow() + : aColor( COL_WHITE ) + { + } + + void SetColor( const Color& rColor ) + { + aColor = rColor; + Invalidate(); + } + + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + + virtual void SetDrawingArea(weld::DrawingArea* pArea) override + { + Size aSize(pArea->get_ref_device().LogicToPixel(Size(43, 14), MapMode(MapUnit::MapAppFont))); + CustomWidgetController::SetDrawingArea(pArea); + pArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + } +}; + +class MaskSet : public ValueSet +{ + VclPtr<SvxBmpMask> pSvxBmpMask; + +public: + MaskSet(SvxBmpMask* pMask); + virtual void Select() override; + virtual bool KeyInput( const KeyEvent& rKEvt ) override; + virtual void GetFocus() override; + virtual void SetDrawingArea(weld::DrawingArea* pArea) override + { + Size aSize(pArea->get_ref_device().LogicToPixel(Size(24, 12), MapMode(MapUnit::MapAppFont))); + ValueSet::SetDrawingArea(pArea); + pArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + SetHelpId(HID_BMPMASK_CTL_QCOL_1); + } + void onEditColor(); +}; + +MaskSet::MaskSet(SvxBmpMask* pMask) + : ValueSet(nullptr) + , pSvxBmpMask(pMask) +{ +} + +void MaskSet::Select() +{ + ValueSet::Select(); + + pSvxBmpMask->onSelect( this ); +} + +void MaskSet::GetFocus() +{ + ValueSet::GetFocus(); + SelectItem( 1 ); + pSvxBmpMask->onSelect( this ); +} + +bool MaskSet::KeyInput( const KeyEvent& rKEvt ) +{ + bool bRet = false; + + vcl::KeyCode aCode = rKEvt.GetKeyCode(); + + // if the key has a modifier we don't care + if( aCode.GetModifier() ) + { + bRet = ValueSet::KeyInput( rKEvt ); + } + else + { + // check for keys that interests us + switch ( aCode.GetCode() ) + { + case KEY_SPACE: + onEditColor(); + bRet = true; + break; + default: + bRet = ValueSet::KeyInput( rKEvt ); + } + } + return bRet; +} + +void MaskSet::onEditColor() +{ + SvColorDialog aColorDlg; + + aColorDlg.SetColor(GetItemColor(1)); + + if (aColorDlg.Execute(pSvxBmpMask->GetFrameWeld())) + SetItemColor(1, aColorDlg.GetColor()); +} + +class MaskData +{ + VclPtr<SvxBmpMask> pMask; + bool bIsReady; + bool bExecState; + SfxBindings& rBindings; + +public: + MaskData( SvxBmpMask* pBmpMask, SfxBindings& rBind ); + + bool IsCbxReady() const { return bIsReady; } + void SetExecState( bool bState ) { bExecState = bState; } + bool IsExecReady() const { return bExecState; } + + DECL_LINK( PipetteHdl, const OString&, void ); + DECL_LINK( CbxHdl, weld::ToggleButton&, void); + DECL_LINK( CbxTransHdl, weld::ToggleButton&, void ); + DECL_LINK( FocusLbHdl, weld::Widget&, void ); + DECL_LINK(ExecHdl, weld::Button&, void); +}; + + +MaskData::MaskData( SvxBmpMask* pBmpMask, SfxBindings& rBind ) : + + pMask ( pBmpMask ), + bIsReady ( false ), + bExecState ( false ), + rBindings ( rBind ) + +{ +} + +IMPL_LINK( MaskData, PipetteHdl, const OString&, rId, void ) +{ + SfxBoolItem aBItem( SID_BMPMASK_PIPETTE, + pMask->m_xTbxPipette->get_item_active(rId) ); + + rBindings.GetDispatcher()->ExecuteList(SID_BMPMASK_PIPETTE, OWN_CALLMODE, + { &aBItem }); +} + +IMPL_LINK( MaskData, CbxHdl, weld::ToggleButton&, rCbx, void ) +{ + bIsReady = pMask->m_xCbx1->get_active() || pMask->m_xCbx2->get_active() || + pMask->m_xCbx3->get_active() || pMask->m_xCbx4->get_active(); + + if ( bIsReady && IsExecReady() ) + pMask->m_xBtnExec->set_sensitive(true); + else + pMask->m_xBtnExec->set_sensitive(false); + + // When a checkbox is checked, the pipette is enabled + if ( rCbx.get_active() ) + { + MaskSet* pSet = nullptr; + + if (&rCbx == pMask->m_xCbx1.get()) + pSet = pMask->m_xQSet1.get(); + else if (&rCbx == pMask->m_xCbx2.get()) + pSet = pMask->m_xQSet2.get(); + else if (&rCbx == pMask->m_xCbx3.get()) + pSet = pMask->m_xQSet3.get(); + else // if ( &rCbx == pMask->m_xCbx4 ) + pSet = pMask->m_xQSet4.get(); + + pSet->SelectItem( 1 ); + pSet->Select(); + + pMask->m_xTbxPipette->set_item_active("pipette", true); + PipetteHdl("pipette"); + } +} + +IMPL_LINK( MaskData, CbxTransHdl, weld::ToggleButton&, rCbx, void ) +{ + bIsReady = rCbx.get_active(); + if ( bIsReady ) + { + pMask->m_xQSet1->Disable(); + pMask->m_xQSet2->Disable(); + pMask->m_xQSet3->Disable(); + pMask->m_xQSet4->Disable(); + pMask->m_xCtlPipette->Disable(); + pMask->m_xCbx1->set_sensitive(false); + pMask->m_xSp1->set_sensitive(false); + pMask->m_xCbx2->set_sensitive(false); + pMask->m_xSp2->set_sensitive(false); + pMask->m_xCbx3->set_sensitive(false); + pMask->m_xSp3->set_sensitive(false); + pMask->m_xCbx4->set_sensitive(false); + pMask->m_xSp4->set_sensitive(false); + pMask->m_xTbxPipette->set_sensitive(false); + + pMask->m_xLbColor1->set_sensitive(false); + pMask->m_xLbColor2->set_sensitive(false); + pMask->m_xLbColor3->set_sensitive(false); + pMask->m_xLbColor4->set_sensitive(false); + pMask->m_xLbColorTrans->set_sensitive(true); + } + else + { + pMask->m_xQSet1->Enable(); + pMask->m_xQSet2->Enable(); + pMask->m_xQSet3->Enable(); + pMask->m_xQSet4->Enable(); + pMask->m_xCtlPipette->Enable(); + pMask->m_xCbx1->set_sensitive(true); + pMask->m_xSp1->set_sensitive(true); + pMask->m_xCbx2->set_sensitive(true); + pMask->m_xSp2->set_sensitive(true); + pMask->m_xCbx3->set_sensitive(true); + pMask->m_xSp3->set_sensitive(true); + pMask->m_xCbx4->set_sensitive(true); + pMask->m_xSp4->set_sensitive(true); + pMask->m_xTbxPipette->set_sensitive(true); + + pMask->m_xLbColor1->set_sensitive(true); + pMask->m_xLbColor2->set_sensitive(true); + pMask->m_xLbColor3->set_sensitive(true); + pMask->m_xLbColor4->set_sensitive(true); + pMask->m_xLbColorTrans->set_sensitive(false); + + bIsReady = pMask->m_xCbx1->get_active() || pMask->m_xCbx2->get_active() || + pMask->m_xCbx3->get_active() || pMask->m_xCbx4->get_active(); + } + + if ( bIsReady && IsExecReady() ) + pMask->m_xBtnExec->set_sensitive(true); + else + pMask->m_xBtnExec->set_sensitive(false); +} + +IMPL_LINK( MaskData, FocusLbHdl, weld::Widget&, rLb, void ) +{ + pMask->m_xQSet1->SelectItem( &rLb == &pMask->m_xLbColor1->get_widget() ? 1 : 0 /* , false */ ); + pMask->m_xQSet2->SelectItem( &rLb == &pMask->m_xLbColor2->get_widget() ? 1 : 0 /* , false */ ); + pMask->m_xQSet3->SelectItem( &rLb == &pMask->m_xLbColor3->get_widget() ? 1 : 0 /* , false */ ); + pMask->m_xQSet4->SelectItem( &rLb == &pMask->m_xLbColor4->get_widget() ? 1 : 0 /* , false */ ); +} + +IMPL_LINK_NOARG(MaskData, ExecHdl, weld::Button&, void) +{ + SfxBoolItem aBItem( SID_BMPMASK_EXEC, true ); + rBindings.GetDispatcher()->ExecuteList(SID_BMPMASK_EXEC, OWN_CALLMODE, + { &aBItem }); +} + +void BmpColorWindow::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& /*Rect*/) +{ + rRenderContext.Push(PushFlags::LINECOLOR | PushFlags::FILLCOLOR); + rRenderContext.SetLineColor(aColor); + rRenderContext.SetFillColor(aColor); + rRenderContext.DrawRect(tools::Rectangle(Point(), GetOutputSizePixel())); + rRenderContext.Pop(); +} + +SvxBmpMaskSelectItem::SvxBmpMaskSelectItem( SvxBmpMask& rMask, + SfxBindings& rBindings ) : + SfxControllerItem ( SID_BMPMASK_EXEC, rBindings ), + rBmpMask ( rMask) +{ +} + +void SvxBmpMaskSelectItem::StateChanged( sal_uInt16 nSID, SfxItemState /*eState*/, + const SfxPoolItem* pItem ) +{ + if ( ( nSID == SID_BMPMASK_EXEC ) && pItem ) + { + const SfxBoolItem* pStateItem = dynamic_cast<const SfxBoolItem*>( pItem ); + assert(pStateItem); // SfxBoolItem expected + if (pStateItem) + rBmpMask.SetExecState( pStateItem->GetValue() ); + } +} + +SvxBmpMaskChildWindow::SvxBmpMaskChildWindow(vcl::Window* pParent_, sal_uInt16 nId, + SfxBindings* pBindings, + SfxChildWinInfo* pInfo) + : SfxChildWindow(pParent_, nId) +{ + VclPtr<SvxBmpMask> pDlg = VclPtr<SvxBmpMask>::Create(pBindings, this, pParent_); + + SetWindow( pDlg ); + + pDlg->Initialize( pInfo ); +} + +SvxBmpMask::SvxBmpMask(SfxBindings *pBindinx, SfxChildWindow *pCW, vcl::Window* pParent) + : SfxDockingWindow(pBindinx, pCW, pParent, "DockingColorReplace", + "svx/ui/dockingcolorreplace.ui") + , m_xTbxPipette(m_xBuilder->weld_toolbar("toolbar")) + , m_xCtlPipette(new BmpColorWindow) + , m_xCtlPipetteWin(new weld::CustomWeld(*m_xBuilder, "toolcolor", *m_xCtlPipette)) + , m_xBtnExec(m_xBuilder->weld_button("replace")) + , m_xCbx1(m_xBuilder->weld_check_button("cbx1")) + , m_xQSet1(new MaskSet(this)) + , m_xQSetWin1(new weld::CustomWeld(*m_xBuilder, "qset1", *m_xQSet1)) + , m_xSp1(m_xBuilder->weld_metric_spin_button("tol1", FieldUnit::PERCENT)) + , m_xLbColor1(new ColorListBox(m_xBuilder->weld_menu_button("color1"), GetFrameWeld())) + , m_xCbx2(m_xBuilder->weld_check_button("cbx2")) + , m_xQSet2(new MaskSet(this)) + , m_xQSetWin2(new weld::CustomWeld(*m_xBuilder, "qset2", *m_xQSet2)) + , m_xSp2(m_xBuilder->weld_metric_spin_button("tol2", FieldUnit::PERCENT)) + , m_xLbColor2(new ColorListBox(m_xBuilder->weld_menu_button("color2"), GetFrameWeld())) + , m_xCbx3(m_xBuilder->weld_check_button("cbx3")) + , m_xQSet3(new MaskSet(this)) + , m_xQSetWin3(new weld::CustomWeld(*m_xBuilder, "qset3", *m_xQSet3)) + , m_xSp3(m_xBuilder->weld_metric_spin_button("tol3", FieldUnit::PERCENT)) + , m_xLbColor3(new ColorListBox(m_xBuilder->weld_menu_button("color3"), GetFrameWeld())) + , m_xCbx4(m_xBuilder->weld_check_button("cbx4")) + , m_xQSet4(new MaskSet(this)) + , m_xQSetWin4(new weld::CustomWeld(*m_xBuilder, "qset4", *m_xQSet4)) + , m_xSp4(m_xBuilder->weld_metric_spin_button("tol4", FieldUnit::PERCENT)) + , m_xLbColor4(new ColorListBox(m_xBuilder->weld_menu_button("color4"), GetFrameWeld())) + , m_xCbxTrans(m_xBuilder->weld_check_button("cbx5")) + , m_xLbColorTrans(new ColorListBox(m_xBuilder->weld_menu_button("color5"), GetFrameWeld())) + , m_xData(new MaskData(this, *pBindinx)) + , aPipetteColor(COL_WHITE) + , aSelItem(*this, *pBindinx) +{ + SetText(SvxResId(RID_SVXDLG_BMPMASK_STR_TITLE)); + + m_xLbColor1->SetSlotId(SID_BMPMASK_COLOR); + m_xLbColor2->SetSlotId(SID_BMPMASK_COLOR); + m_xLbColor3->SetSlotId(SID_BMPMASK_COLOR); + m_xLbColor4->SetSlotId(SID_BMPMASK_COLOR); + + m_xLbColorTrans->SelectEntry(COL_BLACK); + m_xLbColor1->SelectEntry(COL_TRANSPARENT); + m_xLbColor2->SelectEntry(COL_TRANSPARENT); + m_xLbColor3->SelectEntry(COL_TRANSPARENT); + m_xLbColor4->SelectEntry(COL_TRANSPARENT); + + m_xTbxPipette->connect_clicked( LINK( m_xData.get(), MaskData, PipetteHdl ) ); + m_xBtnExec->connect_clicked( LINK( m_xData.get(), MaskData, ExecHdl ) ); + + m_xCbx1->connect_toggled( LINK( m_xData.get(), MaskData, CbxHdl ) ); + m_xCbx2->connect_toggled( LINK( m_xData.get(), MaskData, CbxHdl ) ); + m_xCbx3->connect_toggled( LINK( m_xData.get(), MaskData, CbxHdl ) ); + m_xCbx4->connect_toggled( LINK( m_xData.get(), MaskData, CbxHdl ) ); + m_xCbxTrans->connect_toggled( LINK( m_xData.get(), MaskData, CbxTransHdl ) ); + + SetAccessibleNames (); + + m_xLbColor1->connect_focus_in( LINK( m_xData.get(), MaskData, FocusLbHdl ) ); + m_xLbColor2->connect_focus_in( LINK( m_xData.get(), MaskData, FocusLbHdl ) ); + m_xLbColor3->connect_focus_in( LINK( m_xData.get(), MaskData, FocusLbHdl ) ); + m_xLbColor4->connect_focus_in( LINK( m_xData.get(), MaskData, FocusLbHdl ) ); + m_xLbColorTrans->set_sensitive(false); + + OUString sColorPalette (SvxResId( RID_SVXDLG_BMPMASK_STR_PALETTE)); + OUString sColorPaletteN; + + m_xQSet1->SetStyle( m_xQSet1->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); + m_xQSet1->SetColCount(); + m_xQSet1->SetLineCount( 1 ); + sColorPaletteN = sColorPalette + " 1"; + m_xQSet1->InsertItem( 1, aPipetteColor, sColorPaletteN); + m_xQSet1->SelectItem( 1 ); + + m_xQSet2->SetStyle( m_xQSet2->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); + m_xQSet2->SetColCount(); + m_xQSet2->SetLineCount( 1 ); + sColorPaletteN = sColorPalette + " 2"; + m_xQSet2->InsertItem( 1, aPipetteColor, sColorPaletteN); + m_xQSet2->SelectItem( 0 ); + + m_xQSet3->SetStyle( m_xQSet3->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); + m_xQSet3->SetColCount(); + m_xQSet3->SetLineCount( 1 ); + sColorPaletteN = sColorPalette + " 3"; + m_xQSet3->InsertItem( 1, aPipetteColor, sColorPaletteN); + m_xQSet3->SelectItem( 0 ); + + m_xQSet4->SetStyle( m_xQSet4->GetStyle() | WB_DOUBLEBORDER | WB_ITEMBORDER ); + m_xQSet4->SetColCount(); + m_xQSet4->SetLineCount( 1 ); + sColorPaletteN = sColorPalette + " 4"; + m_xQSet4->InsertItem( 1, aPipetteColor, sColorPaletteN); + m_xQSet4->SelectItem( 0 ); + + m_xQSet1->Show(); + m_xQSet2->Show(); + m_xQSet3->Show(); + m_xQSet4->Show(); +} + +SvxBmpMask::~SvxBmpMask() +{ + disposeOnce(); +} + +void SvxBmpMask::dispose() +{ + m_xQSetWin1.reset(); + m_xQSet1.reset(); + m_xQSetWin2.reset(); + m_xQSet2.reset(); + m_xQSetWin3.reset(); + m_xQSet3.reset(); + m_xQSetWin4.reset(); + m_xQSet4.reset(); + m_xCtlPipetteWin.reset(); + m_xCtlPipette.reset(); + m_xData.reset(); + m_xTbxPipette.reset(); + m_xBtnExec.reset(); + m_xCbx1.reset(); + m_xSp1.reset(); + m_xLbColor1.reset(); + m_xCbx2.reset(); + m_xSp2.reset(); + m_xLbColor2.reset(); + m_xCbx3.reset(); + m_xSp3.reset(); + m_xLbColor3.reset(); + m_xCbx4.reset(); + m_xSp4.reset(); + m_xLbColor4.reset(); + m_xCbxTrans.reset(); + m_xLbColorTrans.reset(); + aSelItem.dispose(); + SfxDockingWindow::dispose(); +} + +/** is called by a MaskSet when it is selected */ +void SvxBmpMask::onSelect( MaskSet* pSet ) +{ + // now deselect all other value sets + if( pSet != m_xQSet1.get() ) + m_xQSet1->SelectItem( 0 ); + + if( pSet != m_xQSet2.get() ) + m_xQSet2->SelectItem( 0 ); + + if( pSet != m_xQSet3.get() ) + m_xQSet3->SelectItem( 0 ); + + if( pSet != m_xQSet4.get() ) + m_xQSet4->SelectItem( 0 ); +} + +bool SvxBmpMask::Close() +{ + SfxBoolItem aItem2( SID_BMPMASK_PIPETTE, false ); + GetBindings().GetDispatcher()->ExecuteList(SID_BMPMASK_PIPETTE, + OWN_CALLMODE, { &aItem2 }); + + return SfxDockingWindow::Close(); +} + +void SvxBmpMask::SetColor( const Color& rColor ) +{ + aPipetteColor = rColor; + m_xCtlPipette->SetColor( aPipetteColor ); +} + +void SvxBmpMask::PipetteClicked() +{ + if( m_xQSet1->GetSelectedItemId() == 1 ) + { + m_xCbx1->set_active(true); + m_xData->CbxHdl(*m_xCbx1); + m_xQSet1->SetItemColor( 1, aPipetteColor ); + m_xQSet1->SetFormat(); + } + else if( m_xQSet2->GetSelectedItemId() == 1 ) + { + m_xCbx2->set_active(true); + m_xData->CbxHdl(*m_xCbx2); + m_xQSet2->SetItemColor( 1, aPipetteColor ); + m_xQSet2->SetFormat(); + } + else if( m_xQSet3->GetSelectedItemId() == 1 ) + { + m_xCbx3->set_active(true); + m_xData->CbxHdl(*m_xCbx3); + m_xQSet3->SetItemColor( 1, aPipetteColor ); + m_xQSet3->SetFormat(); + } + else if( m_xQSet4->GetSelectedItemId() == 1 ) + { + m_xCbx4->set_active(true); + m_xData->CbxHdl(*m_xCbx4); + m_xQSet4->SetItemColor( 1, aPipetteColor ); + m_xQSet4->SetFormat(); + } + + m_xTbxPipette->set_item_active("pipette", false); + m_xData->PipetteHdl("pipette"); +} + +void SvxBmpMask::SetExecState( bool bEnable ) +{ + m_xData->SetExecState( bEnable ); + + if ( m_xData->IsExecReady() && m_xData->IsCbxReady() ) + m_xBtnExec->set_sensitive(true); + else + m_xBtnExec->set_sensitive(false); +} + + +sal_uInt16 SvxBmpMask::InitColorArrays( Color* pSrcCols, Color* pDstCols, sal_uInt8* pTols ) +{ + sal_uInt16 nCount = 0; + + if ( m_xCbx1->get_active() ) + { + pSrcCols[nCount] = m_xQSet1->GetItemColor( 1 ); + pDstCols[nCount] = m_xLbColor1->GetSelectEntryColor(); + pTols[nCount++] = static_cast<sal_uInt8>(m_xSp1->get_value(FieldUnit::PERCENT)); + } + + if ( m_xCbx2->get_active() ) + { + pSrcCols[nCount] = m_xQSet2->GetItemColor( 1 ); + pDstCols[nCount] = m_xLbColor2->GetSelectEntryColor(); + pTols[nCount++] = static_cast<sal_uInt8>(m_xSp2->get_value(FieldUnit::PERCENT)); + } + + if ( m_xCbx3->get_active() ) + { + pSrcCols[nCount] = m_xQSet3->GetItemColor( 1 ); + pDstCols[nCount] = m_xLbColor3->GetSelectEntryColor(); + pTols[nCount++] = static_cast<sal_uInt8>(m_xSp3->get_value(FieldUnit::PERCENT)); + } + + if ( m_xCbx4->get_active() ) + { + pSrcCols[nCount] = m_xQSet4->GetItemColor( 1 ); + pDstCols[nCount] = m_xLbColor4->GetSelectEntryColor(); + pTols[nCount++] = static_cast<sal_uIntPtr>(m_xSp4->get_value(FieldUnit::PERCENT)); + } + + return nCount; +} + +void SvxBmpMask::ImpMask( BitmapEx& rBitmap ) +{ + Color pSrcCols[4]; + Color pDstCols[4]; + sal_uInt8 pTols[4]; + const sal_uInt16 nCount = InitColorArrays( pSrcCols, pDstCols, pTols ); + + EnterWait(); + rBitmap.Replace( pSrcCols, pDstCols, nCount, pTols ); + LeaveWait(); +} + +BitmapEx SvxBmpMask::ImpMaskTransparent( const BitmapEx& rBitmapEx, const Color& rColor, const sal_uInt8 nTol ) +{ + EnterWait(); + + BitmapEx aBmpEx; + Bitmap aMask( rBitmapEx.GetBitmap().CreateMask( rColor, nTol ) ); + + if( rBitmapEx.IsTransparent() ) + aMask.CombineSimple( rBitmapEx.GetMask(), BmpCombine::Or ); + + aBmpEx = BitmapEx( rBitmapEx.GetBitmap(), aMask ); + LeaveWait(); + + return aBmpEx; +} + + +Animation SvxBmpMask::ImpMask( const Animation& rAnimation ) +{ + Animation aAnimation( rAnimation ); + Color pSrcCols[4]; + Color pDstCols[4]; + sal_uInt8 pTols[4]; + InitColorArrays( pSrcCols, pDstCols, pTols ); + sal_uInt16 nAnimationCount = aAnimation.Count(); + + for( sal_uInt16 i = 0; i < nAnimationCount; i++ ) + { + AnimationBitmap aAnimationBitmap( aAnimation.Get( i ) ); + aAnimationBitmap.maBitmapEx = Mask(aAnimationBitmap.maBitmapEx).GetBitmapEx(); + aAnimation.Replace(aAnimationBitmap, i); + } + + return aAnimation; +} + + +GDIMetaFile SvxBmpMask::ImpMask( const GDIMetaFile& rMtf ) +{ + GDIMetaFile aMtf; + Color pSrcCols[4]; + Color pDstCols[4]; + sal_uInt8 pTols[4]; + sal_uInt16 nCount = InitColorArrays( pSrcCols, pDstCols, pTols ); + + // If no color is selected, we copy only the Mtf + if( !nCount ) + aMtf = rMtf; + else + { + bool pTrans[4]; + Color aCol; + long nR; + long nG; + long nB; + std::unique_ptr<long[]> pMinR(new long[nCount]); + std::unique_ptr<long[]> pMaxR(new long[nCount]); + std::unique_ptr<long[]> pMinG(new long[nCount]); + std::unique_ptr<long[]> pMaxG(new long[nCount]); + std::unique_ptr<long[]> pMinB(new long[nCount]); + std::unique_ptr<long[]> pMaxB(new long[nCount]); + sal_uInt16 i; + + aMtf.SetPrefSize( rMtf.GetPrefSize() ); + aMtf.SetPrefMapMode( rMtf.GetPrefMapMode() ); + + // Prepare Color comparison array + for( i = 0; i < nCount; i++ ) + { + long nTol = ( pTols[i] * 255 ) / 100; + + long nVal = static_cast<long>(pSrcCols[i].GetRed()); + pMinR[i] = std::max( nVal - nTol, 0L ); + pMaxR[i] = std::min( nVal + nTol, 255L ); + + nVal = static_cast<long>(pSrcCols[i].GetGreen()); + pMinG[i] = std::max( nVal - nTol, 0L ); + pMaxG[i] = std::min( nVal + nTol, 255L ); + + nVal = static_cast<long>(pSrcCols[i].GetBlue()); + pMinB[i] = std::max( nVal - nTol, 0L ); + pMaxB[i] = std::min( nVal + nTol, 255L ); + + pTrans[ i ] = (pDstCols[ i ] == COL_TRANSPARENT); + } + + // Investigate actions and if necessary replace colors + for( size_t nAct = 0, nActCount = rMtf.GetActionSize(); nAct < nActCount; nAct++ ) + { + MetaAction* pAction = rMtf.GetAction( nAct ); + + bool bReplace = false; + + switch( pAction->GetType() ) + { + case MetaActionType::PIXEL: + { + MetaPixelAction* pAct = static_cast<MetaPixelAction*>(pAction); + + aCol = pAct->GetColor(); + TEST_COLS(); + + if( bReplace ) + pAct = new MetaPixelAction( pAct->GetPoint(), aCol ); + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::LINECOLOR: + { + MetaLineColorAction* pAct = static_cast<MetaLineColorAction*>(pAction); + + aCol = pAct->GetColor(); + TEST_COLS(); + + if( bReplace ) + pAct = new MetaLineColorAction( aCol, !pTrans[ i ] ); + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::FILLCOLOR: + { + MetaFillColorAction* pAct = static_cast<MetaFillColorAction*>(pAction); + + aCol = pAct->GetColor(); + TEST_COLS(); + + if( bReplace ) + pAct = new MetaFillColorAction( aCol, !pTrans[ i ] ); + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::TEXTCOLOR: + { + MetaTextColorAction* pAct = static_cast<MetaTextColorAction*>(pAction); + + aCol = pAct->GetColor(); + TEST_COLS(); + + if( bReplace ) + pAct = new MetaTextColorAction( aCol ); + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::TEXTFILLCOLOR: + { + MetaTextFillColorAction* pAct = static_cast<MetaTextFillColorAction*>(pAction); + + aCol = pAct->GetColor(); + TEST_COLS(); + + if( bReplace ) + pAct = new MetaTextFillColorAction( aCol, !pTrans[ i ] ); + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::FONT: + { + MetaFontAction* pAct = static_cast<MetaFontAction*>(pAction); + vcl::Font aFont( pAct->GetFont() ); + + aCol = aFont.GetColor(); + TEST_COLS(); + + if( bReplace ) + { + aFont.SetColor( aCol ); + pAct = new MetaFontAction( aFont ); + } + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::WALLPAPER: + { + MetaWallpaperAction* pAct = static_cast<MetaWallpaperAction*>(pAction); + Wallpaper aWall( pAct->GetWallpaper() ); + + aCol = aWall.GetColor(); + TEST_COLS(); + + if( bReplace ) + { + aWall.SetColor( aCol ); + pAct = new MetaWallpaperAction( pAct->GetRect(), aWall ); + } + + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::BMP: + { + MetaBmpAction* pAct = static_cast<MetaBmpAction*>(pAction); + const Bitmap aBmp( Mask( pAct->GetBitmap() ).GetBitmapEx().GetBitmap() ); + + pAct = new MetaBmpAction( pAct->GetPoint(), aBmp ); + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::BMPSCALE: + { + MetaBmpScaleAction* pAct = static_cast<MetaBmpScaleAction*>(pAction); + const Bitmap aBmp( Mask( pAct->GetBitmap() ).GetBitmapEx().GetBitmap() ); + + pAct = new MetaBmpScaleAction( pAct->GetPoint(), pAct->GetSize(), aBmp ); + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::BMPSCALEPART: + { + MetaBmpScalePartAction* pAct = static_cast<MetaBmpScalePartAction*>(pAction); + const Bitmap aBmp( Mask( pAct->GetBitmap() ).GetBitmapEx().GetBitmap() ); + + pAct = new MetaBmpScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(), + pAct->GetSrcPoint(), pAct->GetSrcSize(), aBmp ); + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::BMPEX: + { + MetaBmpExAction* pAct = static_cast<MetaBmpExAction*>(pAction); + const BitmapEx aBmpEx( Mask( pAct->GetBitmapEx() ).GetBitmapEx() ); + + pAct = new MetaBmpExAction( pAct->GetPoint(), aBmpEx ); + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::BMPEXSCALE: + { + MetaBmpExScaleAction* pAct = static_cast<MetaBmpExScaleAction*>(pAction); + const BitmapEx aBmpEx( Mask( pAct->GetBitmapEx() ).GetBitmapEx() ); + + pAct = new MetaBmpExScaleAction( pAct->GetPoint(), pAct->GetSize(), aBmpEx ); + aMtf.AddAction( pAct ); + } + break; + + case MetaActionType::BMPEXSCALEPART: + { + MetaBmpExScalePartAction* pAct = static_cast<MetaBmpExScalePartAction*>(pAction); + const BitmapEx aBmpEx( Mask( pAct->GetBitmapEx() ).GetBitmapEx() ); + + pAct = new MetaBmpExScalePartAction( pAct->GetDestPoint(), pAct->GetDestSize(), + pAct->GetSrcPoint(), pAct->GetSrcSize(), aBmpEx ); + aMtf.AddAction( pAct ); + } + break; + + default: + { + aMtf.AddAction( pAction ); + } + break; + } + } + } + + LeaveWait(); + + return aMtf; +} + + +Animation SvxBmpMask::ImpReplaceTransparency( const Animation& rAnim, const Color& rColor ) +{ + Animation aAnimation( rAnim ); + sal_uInt16 nAnimationCount = aAnimation.Count(); + + for( sal_uInt16 i = 0; i < nAnimationCount; i++ ) + { + AnimationBitmap aAnimationBitmap(aAnimation.Get(i)); + aAnimationBitmap.maBitmapEx.ReplaceTransparency(rColor); + aAnimation.Replace(aAnimationBitmap, i); + } + + return aAnimation; +} + + +GDIMetaFile SvxBmpMask::ImpReplaceTransparency( const GDIMetaFile& rMtf, const Color& rColor ) +{ + ScopedVclPtrInstance< VirtualDevice > pVDev; + GDIMetaFile aMtf; + const MapMode& rPrefMap = rMtf.GetPrefMapMode(); + const Size& rPrefSize = rMtf.GetPrefSize(); + const size_t nActionCount = rMtf.GetActionSize(); + + pVDev->EnableOutput( false ); + aMtf.Record( pVDev ); + aMtf.SetPrefSize( rPrefSize ); + aMtf.SetPrefMapMode( rPrefMap ); + pVDev->SetLineColor( rColor ); + pVDev->SetFillColor( rColor ); + + // retrieve one action at the time; first + // set the whole area to the replacement color. + pVDev->DrawRect( tools::Rectangle( rPrefMap.GetOrigin(), rPrefSize ) ); + for ( size_t i = 0; i < nActionCount; i++ ) + { + MetaAction* pAct = rMtf.GetAction( i ); + aMtf.AddAction( pAct ); + } + + aMtf.Stop(); + aMtf.WindStart(); + + return aMtf; +} + +GDIMetaFile SvxBmpMask::GetMetaFile(const Graphic& rGraphic) +{ + // Replace transparency? + if (m_xCbxTrans->get_active()) + return ImpReplaceTransparency(rGraphic.GetGDIMetaFile(), m_xLbColorTrans->GetSelectEntryColor()); + return ImpMask(rGraphic.GetGDIMetaFile()); +} + +Graphic SvxBmpMask::Mask( const Graphic& rGraphic ) +{ + Graphic aGraphic( rGraphic ); + const Color aReplColor( m_xLbColorTrans->GetSelectEntryColor() ); + + switch( rGraphic.GetType() ) + { + case GraphicType::Bitmap: + { + if( rGraphic.IsAnimated() ) + { + // Replace transparency? + if ( m_xCbxTrans->get_active() ) + aGraphic = ImpReplaceTransparency( rGraphic.GetAnimation(), aReplColor ); + else + aGraphic = ImpMask( rGraphic.GetAnimation() ); + } + else + { + // Replace transparency? + if( m_xCbxTrans->get_active() ) + { + BitmapEx aBmpEx = aGraphic.GetBitmapEx(); + aBmpEx.ReplaceTransparency(aReplColor); + aGraphic = aBmpEx; + } + else + { + Color pSrcCols[4]; + Color pDstCols[4]; + sal_uInt8 pTols[4]; + sal_uInt16 nCount = InitColorArrays( pSrcCols, pDstCols, pTols ); + + if( nCount ) + { + // first set all transparent colors + for( sal_uInt16 i = 0; i < nCount; i++ ) + { + // Do we have a transparent color? + if (pDstCols[i] == COL_TRANSPARENT) + { + BitmapEx aBmpEx( ImpMaskTransparent( aGraphic.GetBitmapEx(), + pSrcCols[ i ], pTols[ i ] ) ); + const Size aSize( aBmpEx.GetSizePixel() ); + + if( aSize.Width() && aSize.Height() ) + aGraphic = aBmpEx; + } + } + + // now replace it again with the normal colors + BitmapEx aBitmapEx( aGraphic.GetBitmapEx() ); + if ( aBitmapEx.GetSizePixel().Width() && aBitmapEx.GetSizePixel().Height() ) + { + ImpMask( aBitmapEx ); + if ( aGraphic.IsTransparent() ) + aGraphic = Graphic( BitmapEx( aBitmapEx.GetBitmap(), aBitmapEx.GetMask() ) ); + else + aGraphic = aBitmapEx; + } + } + } + } + } + break; + + case GraphicType::GdiMetafile: + { + GDIMetaFile aMtf(GetMetaFile(rGraphic)); + Size aSize( aMtf.GetPrefSize() ); + if ( aSize.Width() && aSize.Height() ) + aGraphic = Graphic( aMtf ); + else + aGraphic = rGraphic; + } + break; + + default: + aGraphic = rGraphic; + break; + } + + if( aGraphic != rGraphic ) + { + aGraphic.SetPrefSize( rGraphic.GetPrefSize() ); + aGraphic.SetPrefMapMode( rGraphic.GetPrefMapMode() ); + } + + return aGraphic; +} + +bool SvxBmpMask::IsEyedropping() const +{ + return m_xTbxPipette->get_item_active("pipette"); +} + +/** Set an accessible name for the source color check boxes. Without this + the lengthy description is read. +*/ +void SvxBmpMask::SetAccessibleNames() +{ + // set the accessible name for valueset + OUString sColorPalette (SvxResId( RID_SVXDLG_BMPMASK_STR_PALETTE)); + OUString sColorPaletteN; + + sColorPaletteN = sColorPalette + " 1"; + m_xQSet1->SetText (sColorPaletteN); + sColorPaletteN = sColorPalette + " 2"; + m_xQSet2->SetText (sColorPaletteN); + sColorPaletteN = sColorPalette + " 3"; + m_xQSet3->SetText (sColorPaletteN); + sColorPaletteN = sColorPalette + " 4"; + m_xQSet4->SetText (sColorPaletteN); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/_contdlg.cxx b/svx/source/dialog/_contdlg.cxx new file mode 100644 index 000000000..d82004f47 --- /dev/null +++ b/svx/source/dialog/_contdlg.cxx @@ -0,0 +1,675 @@ +/* -*- 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 <tools/helpers.hxx> +#include <svl/eitem.hxx> +#include <sfx2/ctrlitem.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/module.hxx> +#include <unotools/localedatawrapper.hxx> + +#include <svx/svxids.hrc> +#include <svx/contdlg.hxx> +#include "contimp.hxx" +#include "contwnd.hxx" +#include <svx/svdopath.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <vcl/virdev.hxx> +#include "dlgunit.hxx" +#include <vcl/weld.hxx> + +SFX_IMPL_MODELESSDIALOGCONTOLLER_WITHID(SvxContourDlgChildWindow, SID_CONTOUR_DLG); + +SvxContourDlgItem::SvxContourDlgItem( SvxSuperContourDlg& rContourDlg, SfxBindings& rBindings ) : + SfxControllerItem ( SID_CONTOUR_EXEC, rBindings ), + rDlg ( rContourDlg ) +{ +} + +void SvxContourDlgItem::StateChanged( sal_uInt16 nSID, SfxItemState /*eState*/, const SfxPoolItem* pItem ) +{ + if ( pItem && ( SID_CONTOUR_EXEC == nSID ) ) + { + const SfxBoolItem* pStateItem = dynamic_cast<const SfxBoolItem*>( pItem ); + assert(pStateItem); //SfxBoolItem expected + if (pStateItem) + rDlg.SetExecState(!pStateItem->GetValue()); + } +} + +SvxContourDlgChildWindow::SvxContourDlgChildWindow(vcl::Window* _pParent, sal_uInt16 nId, + SfxBindings* pBindings, SfxChildWinInfo const * pInfo) + : SfxChildWindow( _pParent, nId ) +{ + SetController(std::make_shared<SvxContourDlg>(pBindings, this, _pParent->GetFrameWeld())); + SvxContourDlg* pDlg = static_cast<SvxContourDlg*>(GetController().get()); + pDlg->Initialize( pInfo ); +} + +SvxContourDlg::SvxContourDlg(SfxBindings* _pBindings, SfxChildWindow* pCW, + weld::Window* _pParent) + : SfxModelessDialogController(_pBindings, pCW, _pParent, "svx/ui/floatingcontour.ui", "FloatingContour") + , m_xImpl(std::make_unique<SvxSuperContourDlg>(*m_xBuilder, *m_xDialog, _pBindings)) +{ +} + +SvxContourDlg::~SvxContourDlg() +{ +} + +tools::PolyPolygon SvxContourDlg::CreateAutoContour( const Graphic& rGraphic, + const tools::Rectangle* pRect ) +{ + Bitmap aBmp; + bool bContourEdgeDetect = false; + + if ( rGraphic.GetType() == GraphicType::Bitmap ) + { + if( rGraphic.IsAnimated() ) + { + ScopedVclPtrInstance< VirtualDevice > pVDev; + MapMode aTransMap; + const Animation aAnim( rGraphic.GetAnimation() ); + const Size& rSizePix = aAnim.GetDisplaySizePixel(); + const sal_uInt16 nCount = aAnim.Count(); + + if ( pVDev->SetOutputSizePixel( rSizePix ) ) + { + pVDev->SetLineColor( COL_BLACK ); + pVDev->SetFillColor( COL_BLACK ); + + for( sal_uInt16 i = 0; i < nCount; i++ ) + { + const AnimationBitmap& rStepBmp = aAnim.Get( i ); + + // Push Polygon output to the right place; this is the + // offset of the sub-image within the total animation + aTransMap.SetOrigin( Point( rStepBmp.maPositionPixel.X(), rStepBmp.maPositionPixel.Y() ) ); + pVDev->SetMapMode( aTransMap ); + pVDev->DrawPolyPolygon( CreateAutoContour( rStepBmp.maBitmapEx, pRect ) ); + } + + aTransMap.SetOrigin( Point() ); + pVDev->SetMapMode( aTransMap ); + aBmp = pVDev->GetBitmap( Point(), rSizePix ); + aBmp.Convert( BmpConversion::N1BitThreshold ); + } + } + else if( rGraphic.IsTransparent() ) + aBmp = rGraphic.GetBitmapEx().GetMask(); + else + { + aBmp = rGraphic.GetBitmapEx().GetBitmap(); + bContourEdgeDetect = true; + } + } + else if( rGraphic.GetType() != GraphicType::NONE ) + { + const Graphic aTmpGrf( rGraphic.GetGDIMetaFile().GetMonochromeMtf( COL_BLACK ) ); + ScopedVclPtrInstance< VirtualDevice > pVDev; + Size aSizePix( pVDev->LogicToPixel( aTmpGrf.GetPrefSize(), aTmpGrf.GetPrefMapMode() ) ); + + if( aSizePix.Width() && aSizePix.Height() && ( aSizePix.Width() > 512 || aSizePix.Height() > 512 ) ) + { + double fWH = static_cast<double>(aSizePix.Width()) / aSizePix.Height(); + + if( fWH <= 1.0 ) + { + aSizePix.setHeight(512); + aSizePix.setWidth( FRound( ( aSizePix.Height() ) * fWH ) ); + } + else + { + aSizePix.setWidth(512); + aSizePix.setHeight( FRound( ( aSizePix.Width() ) / fWH ) ); + } + } + + if( pVDev->SetOutputSizePixel( aSizePix ) ) + { + const Point aPt; + aTmpGrf.Draw( pVDev, aPt, aSizePix ); + aBmp = pVDev->GetBitmap( aPt, aSizePix ); + } + + bContourEdgeDetect = true; + } + + aBmp.SetPrefSize( rGraphic.GetPrefSize() ); + aBmp.SetPrefMapMode( rGraphic.GetPrefMapMode() ); + + return tools::PolyPolygon( BitmapEx(aBmp).GetContour( bContourEdgeDetect, pRect ) ); +} + +// Loop through to super class, no virtual Methods to not become incompatible +// due to IF changes + +const Graphic& SvxContourDlg::GetGraphic() const +{ + return m_xImpl->GetGraphic(); +} + +bool SvxContourDlg::IsGraphicChanged() const +{ + return m_xImpl->IsGraphicChanged(); +} + +tools::PolyPolygon SvxContourDlg::GetPolyPolygon() +{ + return m_xImpl->GetPolyPolygon(); +} + +const void* SvxContourDlg::GetEditingObject() const +{ + return m_xImpl->GetEditingObject(); +} + +void SvxContourDlg::Update( const Graphic& rGraphic, bool bGraphicLinked, + const tools::PolyPolygon* pPolyPoly, void* pEditingObj ) +{ + m_xImpl->UpdateGraphic( rGraphic, bGraphicLinked, pPolyPoly, pEditingObj ); +} + +SvxSuperContourDlg::SvxSuperContourDlg(weld::Builder& rBuilder, + weld::Dialog& rDialog, SfxBindings* pBindings) + : aUpdateIdle( "SvxSuperContourDlg UpdateIdle" ) + , aCreateIdle( "SvxSuperContourDlg CreateIdle" ) + , mpBindings(pBindings) + , pUpdateEditingObject( nullptr ) + , pCheckObj( nullptr ) + , aContourItem( *this, *pBindings ) + , mnGrfChanged( 0 ) + , bExecState( false ) + , bUpdateGraphicLinked( false ) + , bGraphicLinked( false ) + , m_rDialog(rDialog) + , m_xContourWnd(new ContourWindow(&rDialog)) + , m_xStbStatusColor(new StatusColor(*m_xContourWnd)) + , m_xTbx1(rBuilder.weld_toolbar("toolbar")) + , m_xMtfTolerance(rBuilder.weld_metric_spin_button("spinbutton", FieldUnit::PERCENT)) + , m_xStbStatus2(rBuilder.weld_label("statuspos")) + , m_xStbStatus3(rBuilder.weld_label("statussize")) + , m_xCancelBtn(rBuilder.weld_button("cancel")) + , m_xStbStatusColorWeld(new weld::CustomWeld(rBuilder, "statuscolor", *m_xStbStatusColor)) + , m_xContourWndWeld(new weld::CustomWeld(rBuilder, "container", *m_xContourWnd)) +{ + m_xCancelBtn->connect_clicked(LINK(this, SvxSuperContourDlg, CancelHdl)); + + m_xContourWnd->SetMousePosLink( LINK( this, SvxSuperContourDlg, MousePosHdl ) ); + m_xContourWnd->SetGraphSizeLink( LINK( this, SvxSuperContourDlg, GraphSizeHdl ) ); + m_xContourWnd->SetUpdateLink( LINK( this, SvxSuperContourDlg, StateHdl ) ); + m_xContourWnd->SetPipetteHdl( LINK( this, SvxSuperContourDlg, PipetteHdl ) ); + m_xContourWnd->SetPipetteClickHdl( LINK( this, SvxSuperContourDlg, PipetteClickHdl ) ); + m_xContourWnd->SetWorkplaceClickHdl( LINK( this, SvxSuperContourDlg, WorkplaceClickHdl ) ); + + m_xTbx1->connect_clicked( LINK( this, SvxSuperContourDlg, Tbx1ClickHdl ) ); + + m_xMtfTolerance->set_value(10, FieldUnit::PERCENT); + + aUpdateIdle.SetInvokeHandler( LINK( this, SvxSuperContourDlg, UpdateHdl ) ); + + aCreateIdle.SetPriority( TaskPriority::RESIZE ); + aCreateIdle.SetInvokeHandler( LINK( this, SvxSuperContourDlg, CreateHdl ) ); +} + +SvxSuperContourDlg::~SvxSuperContourDlg() +{ + m_xContourWnd->SetUpdateLink( Link<GraphCtrl*,void>() ); + m_xContourWnd.reset(); +} + +IMPL_LINK_NOARG(SvxSuperContourDlg, CancelHdl, weld::Button&, void) +{ + bool bRet = true; + + if (m_xTbx1->get_item_sensitive("TBI_APPLY")) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(&m_rDialog, "svx/ui/querysavecontchangesdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QuerySaveContourChangesDialog")); + const short nRet = xQBox->run(); + + if ( nRet == RET_YES ) + { + SfxBoolItem aBoolItem( SID_CONTOUR_EXEC, true ); + GetBindings().GetDispatcher()->ExecuteList( + SID_CONTOUR_EXEC, SfxCallMode::SYNCHRON | SfxCallMode::RECORD, + { &aBoolItem }); + } + else if ( nRet == RET_CANCEL ) + bRet = false; + } + + if (bRet) + m_rDialog.response(RET_CANCEL); +} + +// Enabled or disabled all Controls + +void SvxSuperContourDlg::SetExecState( bool bEnable ) +{ + bExecState = bEnable; +} + +void SvxSuperContourDlg::SetGraphic( const Graphic& rGraphic ) +{ + aUndoGraphic = aRedoGraphic = Graphic(); + aGraphic = rGraphic; + mnGrfChanged = 0; + m_xContourWnd->SetGraphic( aGraphic ); +} + +void SvxSuperContourDlg::SetPolyPolygon( const tools::PolyPolygon& rPolyPoly ) +{ + DBG_ASSERT( m_xContourWnd->GetGraphic().GetType() != GraphicType::NONE, "Graphic must've been set first!" ); + + tools::PolyPolygon aPolyPoly( rPolyPoly ); + const MapMode aMap100( MapUnit::Map100thMM ); + const MapMode aGrfMap( aGraphic.GetPrefMapMode() ); + OutputDevice* pOutDev = Application::GetDefaultDevice(); + bool bPixelMap = aGrfMap.GetMapUnit() == MapUnit::MapPixel; + + for ( sal_uInt16 j = 0, nPolyCount = aPolyPoly.Count(); j < nPolyCount; j++ ) + { + tools::Polygon& rPoly = aPolyPoly[ j ]; + + for ( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ ) + { + Point& rPt = rPoly[ i ]; + + if ( !bPixelMap ) + rPt = pOutDev->LogicToPixel( rPt, aGrfMap ); + + rPt = pOutDev->PixelToLogic( rPt, aMap100 ); + } + } + + m_xContourWnd->SetPolyPolygon( aPolyPoly ); + m_xContourWnd->GetSdrModel()->SetChanged(); +} + +tools::PolyPolygon SvxSuperContourDlg::GetPolyPolygon() +{ + tools::PolyPolygon aRetPolyPoly( m_xContourWnd->GetPolyPolygon() ); + + const MapMode aMap100( MapUnit::Map100thMM ); + const MapMode aGrfMap( aGraphic.GetPrefMapMode() ); + OutputDevice* pOutDev = Application::GetDefaultDevice(); + bool bPixelMap = aGrfMap.GetMapUnit() == MapUnit::MapPixel; + + for ( sal_uInt16 j = 0, nPolyCount = aRetPolyPoly.Count(); j < nPolyCount; j++ ) + { + tools::Polygon& rPoly = aRetPolyPoly[ j ]; + + for ( sal_uInt16 i = 0, nCount = rPoly.GetSize(); i < nCount; i++ ) + { + Point& rPt = rPoly[ i ]; + + rPt = pOutDev->LogicToPixel( rPt, aMap100 ); + + if ( !bPixelMap ) + rPt = pOutDev->PixelToLogic( rPt, aGrfMap ); + } + } + + return aRetPolyPoly; +} + +void SvxSuperContourDlg::UpdateGraphic( const Graphic& rGraphic, bool _bGraphicLinked, + const tools::PolyPolygon* pPolyPoly, void* pEditingObj ) +{ + aUpdateGraphic = rGraphic; + bUpdateGraphicLinked = _bGraphicLinked; + pUpdateEditingObject = pEditingObj; + + if ( pPolyPoly ) + aUpdatePolyPoly = *pPolyPoly; + else + aUpdatePolyPoly = tools::PolyPolygon(); + + aUpdateIdle.Start(); +} + +// Click handler for ToolBox + +IMPL_LINK(SvxSuperContourDlg, Tbx1ClickHdl, const OString&, rId, void) +{ + if (rId == "TBI_APPLY") + { + SfxBoolItem aBoolItem( SID_CONTOUR_EXEC, true ); + GetBindings().GetDispatcher()->ExecuteList( + SID_CONTOUR_EXEC, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, + { &aBoolItem }); + } + else if (rId == "TBI_WORKPLACE") + { + if (m_xTbx1->get_item_active("TBI_WORKPLACE")) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(&m_rDialog, "svx/ui/querydeletecontourdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QueryDeleteContourDialog")); + + if (!m_xContourWnd->IsContourChanged() || (xQBox->run() == RET_YES)) + m_xContourWnd->SetWorkplaceMode( true ); + else + m_xTbx1->set_item_active("TBI_WORKPLACE", false); + } + else + m_xContourWnd->SetWorkplaceMode( false ); + } + else if (rId == "TBI_SELECT") + { + SetActiveTool(rId); + m_xContourWnd->SetEditMode( true ); + } + else if (rId == "TBI_RECT") + { + SetActiveTool(rId); + m_xContourWnd->SetObjKind( OBJ_RECT ); + } + else if (rId == "TBI_CIRCLE") + { + SetActiveTool(rId); + m_xContourWnd->SetObjKind( OBJ_CIRC ); + } + else if (rId == "TBI_POLY") + { + SetActiveTool(rId); + m_xContourWnd->SetObjKind( OBJ_POLY ); + } + else if (rId == "TBI_POLYEDIT") + { + m_xContourWnd->SetPolyEditMode(m_xTbx1->get_item_active("TBI_POLYEDIT") ? SID_BEZIER_MOVE : 0); + } + else if (rId == "TBI_POLYMOVE") + { + SetActivePoly(rId); + m_xContourWnd->SetPolyEditMode( SID_BEZIER_MOVE ); + } + else if (rId == "TBI_POLYINSERT") + { + SetActivePoly(rId); + m_xContourWnd->SetPolyEditMode( SID_BEZIER_INSERT ); + } + else if (rId == "TBI_POLYDELETE") + { + m_xContourWnd->GetSdrView()->DeleteMarkedPoints(); + } + else if (rId == "TBI_UNDO") + { + mnGrfChanged = mnGrfChanged ? mnGrfChanged - 1 : 0; + aRedoGraphic = aGraphic; + aGraphic = aUndoGraphic; + aUndoGraphic = Graphic(); + m_xContourWnd->SetGraphic( aGraphic, false ); + } + else if (rId == "TBI_REDO") + { + mnGrfChanged++; + aUndoGraphic = aGraphic; + aGraphic = aRedoGraphic; + aRedoGraphic = Graphic(); + m_xContourWnd->SetGraphic( aGraphic, false ); + } + else if (rId == "TBI_AUTOCONTOUR") + { + aCreateIdle.Start(); + } + else if (rId == "TBI_PIPETTE") + { + bool bPipette = m_xTbx1->get_item_active("TBI_PIPETTE"); + + if ( !bPipette ) + m_xStbStatusColor->Invalidate(); + else if ( bGraphicLinked ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(&m_rDialog, "svx/ui/queryunlinkgraphicsdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QueryUnlinkGraphicsDialog")); + + if (xQBox->run() != RET_YES) + { + bPipette = false; + m_xTbx1->set_item_active("TBI_PIPETTE", bPipette); + m_xStbStatusColor->Invalidate(); + } + } + + m_xContourWnd->SetPipetteMode( bPipette ); + } + m_xContourWnd->QueueIdleUpdate(); +} + +void SvxSuperContourDlg::SetActiveTool(const OString& rId) +{ + m_xTbx1->set_item_active("TBI_SELECT", rId == "TBI_SELECT"); + m_xTbx1->set_item_active("TBI_RECT", rId == "TBI_RECT"); + m_xTbx1->set_item_active("TBI_CIRCLE", rId == "TBI_CIRCLE"); + m_xTbx1->set_item_active("TBI_POLY", rId == "TBI_POLY"); +} + +void SvxSuperContourDlg::SetActivePoly(const OString& rId) +{ + m_xTbx1->set_item_active("TBI_POLYMOVE", rId == "TBI_POLYMOVE"); + m_xTbx1->set_item_active("TBI_POLYINSERT", rId == "TBI_POLYINSERT"); +} + +IMPL_LINK( SvxSuperContourDlg, MousePosHdl, GraphCtrl*, pWnd, void ) +{ + OUString aStr; + const FieldUnit eFieldUnit = GetBindings().GetDispatcher()->GetModule()->GetFieldUnit(); + const Point& rMousePos = pWnd->GetMousePos(); + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() ); + const sal_Unicode cSep = rLocaleWrapper.getNumDecimalSep()[0]; + + aStr = GetUnitString( rMousePos.X(), eFieldUnit, cSep ) + + " / " + + GetUnitString( rMousePos.Y(), eFieldUnit, cSep ); + + m_xStbStatus2->set_label( aStr ); +} + +IMPL_LINK( SvxSuperContourDlg, GraphSizeHdl, GraphCtrl*, pWnd, void ) +{ + OUString aStr; + const FieldUnit eFieldUnit = GetBindings().GetDispatcher()->GetModule()->GetFieldUnit(); + const Size& rSize = pWnd->GetGraphicSize(); + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() ); + const sal_Unicode cSep = rLocaleWrapper.getNumDecimalSep()[0]; + + aStr = GetUnitString( rSize.Width(), eFieldUnit, cSep ) + + " x " + + GetUnitString( rSize.Height(), eFieldUnit, cSep ); + + m_xStbStatus3->set_label( aStr ); +} + +IMPL_LINK_NOARG(SvxSuperContourDlg, UpdateHdl, Timer *, void) +{ + aUpdateIdle.Stop(); + + if ( pUpdateEditingObject != pCheckObj ) + { + if( !GetEditingObject() ) + m_xContourWnd->GrabFocus(); + + SetGraphic( aUpdateGraphic ); + SetPolyPolygon( aUpdatePolyPoly ); + pCheckObj = pUpdateEditingObject; + bGraphicLinked = bUpdateGraphicLinked; + + aUpdateGraphic = Graphic(); + aUpdatePolyPoly = tools::PolyPolygon(); + bUpdateGraphicLinked = false; + + m_xContourWnd->GetSdrModel()->SetChanged( false ); + } + + GetBindings().Invalidate( SID_CONTOUR_EXEC ); + m_xContourWnd->QueueIdleUpdate(); +} + +IMPL_LINK_NOARG(SvxSuperContourDlg, CreateHdl, Timer *, void) +{ + aCreateIdle.Stop(); + + const tools::Rectangle aWorkRect = m_xContourWnd->GetDrawingArea()->get_ref_device().LogicToPixel( + m_xContourWnd->GetWorkRect(), MapMode( MapUnit::Map100thMM)); + + const Graphic& rGraphic = m_xContourWnd->GetGraphic(); + const bool bValid = aWorkRect.Left() != aWorkRect.Right() && aWorkRect.Top() != aWorkRect.Bottom(); + + weld::WaitObject aWaitObj(&m_rDialog); + SetPolyPolygon( SvxContourDlg::CreateAutoContour( rGraphic, bValid ? &aWorkRect : nullptr ) ); +} + +IMPL_LINK( SvxSuperContourDlg, StateHdl, GraphCtrl*, pWnd, void ) +{ + const SdrObject* pObj = pWnd->GetSelectedSdrObject(); + const SdrView* pView = pWnd->GetSdrView(); + const bool bPolyEdit = ( pObj != nullptr ) && dynamic_cast<const SdrPathObj*>( pObj) != nullptr; + const bool bDrawEnabled = !(bPolyEdit && m_xTbx1->get_item_active("TBI_POLYEDIT")); + const bool bPipette = m_xTbx1->get_item_active("TBI_PIPETTE"); + const bool bWorkplace = m_xTbx1->get_item_active("TBI_WORKPLACE"); + const bool bDontHide = !( bPipette || bWorkplace ); + const bool bBitmap = pWnd->GetGraphic().GetType() == GraphicType::Bitmap; + + m_xTbx1->set_item_sensitive("TBI_APPLY", bDontHide && bExecState && pWnd->IsChanged()); + + m_xTbx1->set_item_sensitive("TBI_WORKPLACE", !bPipette && bDrawEnabled); + + m_xTbx1->set_item_sensitive("TBI_SELECT", bDontHide && bDrawEnabled); + m_xTbx1->set_item_sensitive("TBI_RECT", bDontHide && bDrawEnabled); + m_xTbx1->set_item_sensitive("TBI_CIRCLE", bDontHide && bDrawEnabled); + m_xTbx1->set_item_sensitive("TBI_POLY", bDontHide && bDrawEnabled); + + m_xTbx1->set_item_sensitive("TBI_POLYEDIT", bDontHide && bPolyEdit); + m_xTbx1->set_item_sensitive("TBI_POLYMOVE", bDontHide && !bDrawEnabled); + m_xTbx1->set_item_sensitive("TBI_POLYINSERT", bDontHide && !bDrawEnabled); + m_xTbx1->set_item_sensitive("TBI_POLYDELETE", bDontHide && !bDrawEnabled && pView->IsDeleteMarkedPointsPossible()); + + m_xTbx1->set_item_sensitive("TBI_AUTOCONTOUR", bDontHide && bDrawEnabled); + m_xTbx1->set_item_sensitive("TBI_PIPETTE", !bWorkplace && bDrawEnabled && bBitmap); + + m_xTbx1->set_item_sensitive("TBI_UNDO", bDontHide && aUndoGraphic.GetType() != GraphicType::NONE); + m_xTbx1->set_item_sensitive("TBI_REDO", bDontHide && aRedoGraphic.GetType() != GraphicType::NONE); + + if ( bPolyEdit ) + { + switch( pWnd->GetPolyEditMode() ) + { + case SID_BEZIER_MOVE: + SetActivePoly("TBI_POLYMOVE"); + break; + case SID_BEZIER_INSERT: + SetActivePoly("TBI_POLYINSERT"); + break; + default: + break; + } + } + else + { + m_xTbx1->set_item_active("TBI_POLYEDIT", false); + SetActivePoly("TBI_POLYMOVE"); + pWnd->SetPolyEditMode( 0 ); + } +} + +IMPL_LINK_NOARG(SvxSuperContourDlg, PipetteHdl, ContourWindow&, void) +{ + m_xStbStatusColor->Invalidate(); +} + +void StatusColor::Paint(vcl::RenderContext& rDevice, const tools::Rectangle&) +{ + const Color& rOldLineColor = rDevice.GetLineColor(); + const Color& rOldFillColor = rDevice.GetFillColor(); + + tools::Rectangle aRect(Point(), GetOutputSizePixel()); + const Color& rColor = m_rWnd.GetPipetteColor(); + + rDevice.SetLineColor(rColor); + rDevice.SetFillColor(rColor); + + aRect.AdjustLeft(4 ); + aRect.AdjustTop(4 ); + aRect.AdjustRight( -4 ); + aRect.AdjustBottom( -4 ); + + rDevice.DrawRect( aRect ); + + rDevice.SetLineColor(rOldLineColor); + rDevice.SetFillColor(rOldFillColor); +} + +IMPL_LINK( SvxSuperContourDlg, PipetteClickHdl, ContourWindow&, rWnd, void ) +{ + if ( rWnd.IsClickValid() ) + { + const Color& rColor = rWnd.GetPipetteColor(); + + weld::WaitObject aWaitObj(&m_rDialog); + + if( aGraphic.GetType() == GraphicType::Bitmap ) + { + const long nTol = static_cast<long>(m_xMtfTolerance->get_value(FieldUnit::PERCENT) * 255 / 100); + + Bitmap aMask = aGraphic.GetBitmapEx().GetBitmap().CreateMask( rColor, nTol ); + + if( aGraphic.IsTransparent() ) + aMask.CombineSimple( aGraphic.GetBitmapEx().GetMask(), BmpCombine::Or ); + + if( !!aMask ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(&m_rDialog, "svx/ui/querynewcontourdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QueryNewContourDialog")); + + bool bNewContour; + + aRedoGraphic = Graphic(); + aUndoGraphic = aGraphic; + Bitmap aBmp = aGraphic.GetBitmapEx().GetBitmap(); + aGraphic = Graphic( BitmapEx( aBmp, aMask ) ); + mnGrfChanged++; + + bNewContour = (xQBox->run() == RET_YES); + rWnd.SetGraphic( aGraphic, bNewContour ); + + if( bNewContour ) + aCreateIdle.Start(); + } + } + } + + m_xTbx1->set_item_active("TBI_PIPETTE", false); + rWnd.SetPipetteMode( false ); + m_xStbStatusColor->Invalidate(); +} + +IMPL_LINK( SvxSuperContourDlg, WorkplaceClickHdl, ContourWindow&, rWnd, void ) +{ + m_xTbx1->set_item_active("TBI_WORKPLACE", false); + m_xTbx1->set_item_active("TBI_SELECT", true); + rWnd.SetWorkplaceMode( false ); + + m_xContourWnd->QueueIdleUpdate(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/charmap.cxx b/svx/source/dialog/charmap.cxx new file mode 100644 index 000000000..c43cafb9e --- /dev/null +++ b/svx/source/dialog/charmap.cxx @@ -0,0 +1,1872 @@ +/* -*- 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/event.hxx> +#include <vcl/fontcharmap.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <vcl/virdev.hxx> + +#include <svx/ucsubset.hxx> + + +#include <svx/strings.hrc> + +#include <svx/charmap.hxx> +#include <svx/dialmgr.hxx> + +#include <charmapacc.hxx> +#include <uiobject.hxx> + +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/datatransfer/clipboard/XFlushableClipboard.hpp> +#include <com/sun/star/datatransfer/clipboard/SystemClipboard.hpp> +#include <officecfg/Office/Common.hxx> +#include <comphelper/processfactory.hxx> +#include <unicode/uchar.h> +#include <vcl/textview.hxx> +#include <rtl/ustrbuf.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star; + +sal_uInt32& SvxShowCharSet::getSelectedChar() +{ + static sal_uInt32 cSelectedChar = ' '; // keeps selected character over app lifetime + return cSelectedChar; +} + +FactoryFunction SvxShowCharSet::GetUITestFactory() const +{ + return SvxShowCharSetUIObject::create; +} + +SvxShowCharSet::SvxShowCharSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow, const VclPtr<VirtualDevice>& rVirDev) + : mxVirDev(rVirDev) + , mxScrollArea(std::move(pScrolledWindow)) + , mxContext(comphelper::getProcessComponentContext()) + , nX(0) + , nY(0) + , maFontSize(0, 0) + , maPosition(0,0) + , mbRecalculateFont(true) + , mbUpdateForeground(true) + , mbUpdateBackground(true) +{ + init(); + + mxScrollArea->set_user_managed_scrolling(); +} + +void SvxShowCharSet::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + + Size aSize(COLUMN_COUNT * pDrawingArea->get_approximate_digit_width() * 5.25, + ROW_COUNT * pDrawingArea->get_text_height() * 2); + + nX = aSize.Width() / COLUMN_COUNT; + nY = aSize.Height() / ROW_COUNT; + + // tdf#121232 set a size request that will result in a 0 m_nXGap by default + mxScrollArea->set_size_request(COLUMN_COUNT * nX + mxScrollArea->get_vscroll_width() + 2, + ROW_COUNT * nY); +} + +void SvxShowCharSet::init() +{ + nSelectedIndex = -1; // TODO: move into init list when it is no longer static + m_nXGap = 0; + m_nYGap = 0; + + mxScrollArea->connect_vadjustment_changed(LINK(this, SvxShowCharSet, VscrollHdl)); + getFavCharacterList(); + // other settings depend on selected font => see RecalculateFont + + bDrag = false; +} + +void SvxShowCharSet::Resize() +{ + mbRecalculateFont = true; +} + +void SvxShowCharSet::GetFocus() +{ + SelectIndex(nSelectedIndex, true); +} + +void SvxShowCharSet::LoseFocus() +{ + SelectIndex(nSelectedIndex); +} + +bool SvxShowCharSet::MouseButtonDown(const MouseEvent& rMEvt) +{ + if ( rMEvt.IsLeft() ) + { + if ( rMEvt.GetClicks() == 1 ) + { + GrabFocus(); + bDrag = true; + CaptureMouse(); + + int nIndex = PixelToMapIndex( rMEvt.GetPosPixel() ); + // Fire the focus event + SelectIndex( nIndex, true); + } + + if ( !(rMEvt.GetClicks() % 2) ) + aDoubleClkHdl.Call( this ); + } + + if (rMEvt.IsRight()) + { + Point aPosition (rMEvt.GetPosPixel()); + maPosition = aPosition; + int nIndex = PixelToMapIndex( rMEvt.GetPosPixel() ); + // Fire the focus event + SelectIndex( nIndex, true); + createContextMenu(); + } + + return true; +} + +bool SvxShowCharSet::MouseButtonUp(const MouseEvent& rMEvt) +{ + if ( bDrag && rMEvt.IsLeft() ) + { + // released mouse over character map + if ( tools::Rectangle(Point(), GetOutputSizePixel()).IsInside(rMEvt.GetPosPixel())) + aSelectHdl.Call( this ); + ReleaseMouse(); + bDrag = false; + } + + return true; +} + +bool SvxShowCharSet::MouseMove(const MouseEvent& rMEvt) +{ + if ( rMEvt.IsLeft() && bDrag ) + { + Point aPos = rMEvt.GetPosPixel(); + Size aSize = GetOutputSizePixel(); + + if ( aPos.X() < 0 ) + aPos.setX( 0 ); + else if ( aPos.X() > aSize.Width()-5 ) + aPos.setX( aSize.Width()-5 ); + if ( aPos.Y() < 0 ) + aPos.setY( 0 ); + else if ( aPos.Y() > aSize.Height()-5 ) + aPos.setY( aSize.Height()-5 ); + + int nIndex = PixelToMapIndex( aPos ); + // Fire the focus event. + SelectIndex( nIndex, true ); + } + + return true; +} + +sal_uInt16 SvxShowCharSet::GetRowPos(sal_uInt16 _nPos) +{ + return _nPos / COLUMN_COUNT ; +} + +void SvxShowCharSet::getFavCharacterList() +{ + maFavCharList.clear(); + maFavCharFontList.clear(); + //retrieve recent character list + css::uno::Sequence< OUString > rFavCharList( officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterList::get() ); + comphelper::sequenceToContainer(maFavCharList, rFavCharList); + + //retrieve recent character font list + css::uno::Sequence< OUString > rFavCharFontList( officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterFontList::get() ); + comphelper::sequenceToContainer(maFavCharFontList, rFavCharFontList); +} + +bool SvxShowCharSet::isFavChar(const OUString& sTitle, const OUString& rFont) +{ + auto isFavCharTitleExists = std::any_of(maFavCharList.begin(), + maFavCharList.end(), + [sTitle] (const OUString & a) { return a == sTitle; }); + + auto isFavCharFontExists = std::any_of(maFavCharFontList.begin(), + maFavCharFontList.end(), + [rFont] (const OUString & a) { return a == rFont; }); + + // if Fav char to be added is already in list, return true + return isFavCharTitleExists && isFavCharFontExists; +} + +void SvxShowCharSet::createContextMenu() +{ + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetDrawingArea(), "svx/ui/charsetmenu.ui")); + std::unique_ptr<weld::Menu> xItemMenu(xBuilder->weld_menu("charsetmenu")); + + sal_UCS4 cChar = GetSelectCharacter(); + OUString aOUStr( &cChar, 1 ); + if (isFavChar(aOUStr, mxVirDev->GetFont().GetFamilyName()) || maFavCharList.size() >= 16) + xItemMenu->set_visible("add", false); + else + xItemMenu->set_visible("remove", false); + + ContextMenuSelect(xItemMenu->popup_at_rect(GetDrawingArea(), tools::Rectangle(maPosition, Size(1,1)))); + GrabFocus(); + Invalidate(); +} + +void SvxShowCharSet::ContextMenuSelect(const OString& rIdent) +{ + sal_UCS4 cChar = GetSelectCharacter(); + OUString aOUStr(&cChar, 1); + + if (rIdent == "insert") + aDoubleClkHdl.Call(this); + else if (rIdent == "add" || rIdent == "remove") + { + updateFavCharacterList(aOUStr, mxVirDev->GetFont().GetFamilyName()); + aFavClickHdl.Call(this); + } + else if (rIdent == "copy") + CopyToClipboard(aOUStr); +} + +void SvxShowCharSet::CopyToClipboard(const OUString& rOUStr) +{ + css::uno::Reference<css::datatransfer::clipboard::XClipboard> xClipboard = + css::datatransfer::clipboard::SystemClipboard::create(comphelper::getProcessComponentContext()); + + if (xClipboard.is()) + { + TETextDataObject* pDataObj = new TETextDataObject(rOUStr); + + try + { + xClipboard->setContents( pDataObj, nullptr ); + + css::uno::Reference<css::datatransfer::clipboard::XFlushableClipboard> xFlushableClipboard(xClipboard, css::uno::UNO_QUERY); + if( xFlushableClipboard.is() ) + xFlushableClipboard->flushClipboard(); + } + catch( const css::uno::Exception& ) + { + } + } +} + +void SvxShowCharSet::updateFavCharacterList(const OUString& sTitle, const OUString& rFont) +{ + if(isFavChar(sTitle, rFont)) + { + auto itChar = std::find(maFavCharList.begin(), maFavCharList.end(), sTitle); + auto itChar2 = std::find(maFavCharFontList.begin(), maFavCharFontList.end(), rFont); + + // if Fav char to be added is already in list, remove it + if( itChar != maFavCharList.end() && itChar2 != maFavCharFontList.end() ) + { + maFavCharList.erase( itChar ); + maFavCharFontList.erase( itChar2); + } + + css::uno::Sequence< OUString > aFavCharList(maFavCharList.size()); + css::uno::Sequence< OUString > aFavCharFontList(maFavCharFontList.size()); + + for (size_t i = 0; i < maFavCharList.size(); ++i) + { + aFavCharList[i] = maFavCharList[i]; + aFavCharFontList[i] = maFavCharFontList[i]; + } + + std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create(mxContext)); + officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterList::set(aFavCharList, batch); + officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterFontList::set(aFavCharFontList, batch); + batch->commit(); + return; + } + + auto itChar = std::find(maFavCharList.begin(), maFavCharList.end(), sTitle); + auto itChar2 = std::find(maFavCharFontList.begin(), maFavCharFontList.end(), rFont); + + // if Fav char to be added is already in list, remove it + if( itChar != maFavCharList.end() && itChar2 != maFavCharFontList.end() ) + { + maFavCharList.erase( itChar ); + maFavCharFontList.erase( itChar2); + } + + if (maFavCharList.size() == 16) + { + maFavCharList.pop_back(); + maFavCharFontList.pop_back(); + } + + maFavCharList.push_back(sTitle); + maFavCharFontList.push_back(rFont); + + css::uno::Sequence< OUString > aFavCharList(maFavCharList.size()); + css::uno::Sequence< OUString > aFavCharFontList(maFavCharFontList.size()); + + for (size_t i = 0; i < maFavCharList.size(); ++i) + { + aFavCharList[i] = maFavCharList[i]; + aFavCharFontList[i] = maFavCharFontList[i]; + } + + std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create(mxContext)); + officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterList::set(aFavCharList, batch); + officecfg::Office::Common::FavoriteCharacters::FavoriteCharacterFontList::set(aFavCharFontList, batch); + batch->commit(); +} + +sal_uInt16 SvxShowCharSet::GetColumnPos(sal_uInt16 _nPos) +{ + return _nPos % COLUMN_COUNT ; +} + +int SvxShowCharSet::FirstInView() const +{ + return mxScrollArea->vadjustment_get_value() * COLUMN_COUNT; +} + +int SvxShowCharSet::LastInView() const +{ + sal_uInt32 nIndex = FirstInView(); + nIndex += ROW_COUNT * COLUMN_COUNT - 1; + sal_uInt32 nCompare = mxFontCharMap->GetCharCount() - 1; + if (nIndex > nCompare) + nIndex = nCompare; + return nIndex; +} + +Point SvxShowCharSet::MapIndexToPixel( int nIndex ) const +{ + const int nBase = FirstInView(); + int x = ((nIndex - nBase) % COLUMN_COUNT) * nX; + int y = ((nIndex - nBase) / COLUMN_COUNT) * nY; + return Point( x + m_nXGap, y + m_nYGap ); +} + + +int SvxShowCharSet::PixelToMapIndex( const Point& point) const +{ + int nBase = FirstInView(); + return (nBase + ((point.X() - m_nXGap)/nX) + ((point.Y() - m_nYGap)/nY) * COLUMN_COUNT); +} + +bool SvxShowCharSet::KeyInput(const KeyEvent& rKEvt) +{ + vcl::KeyCode aCode = rKEvt.GetKeyCode(); + + if (aCode.GetModifier()) + return false; + + bool bRet = true; + + int tmpSelected = nSelectedIndex; + + switch (aCode.GetCode()) + { + case KEY_SPACE: + aSelectHdl.Call( this ); + break; + case KEY_LEFT: + --tmpSelected; + break; + case KEY_RIGHT: + ++tmpSelected; + break; + case KEY_UP: + tmpSelected -= COLUMN_COUNT; + break; + case KEY_DOWN: + tmpSelected += COLUMN_COUNT; + break; + case KEY_PAGEUP: + tmpSelected -= ROW_COUNT * COLUMN_COUNT; + break; + case KEY_PAGEDOWN: + tmpSelected += ROW_COUNT * COLUMN_COUNT; + break; + case KEY_HOME: + tmpSelected = 0; + break; + case KEY_END: + tmpSelected = mxFontCharMap->GetCharCount() - 1; + break; + case KEY_TAB: // some fonts have a character at these unicode control codes + case KEY_ESCAPE: + case KEY_RETURN: + tmpSelected = - 1; // mark as invalid + bRet = false; + break; + default: + { + sal_UCS4 cChar = rKEvt.GetCharCode(); + sal_UCS4 cNext = mxFontCharMap->GetNextChar(cChar - 1); + tmpSelected = mxFontCharMap->GetIndexFromChar(cNext); + if (tmpSelected < 0 || (cChar != cNext)) + { + tmpSelected = - 1; // mark as invalid + bRet = false; + } + break; + } + } + + if ( tmpSelected >= 0 ) + { + SelectIndex( tmpSelected, true ); + aPreSelectHdl.Call( this ); + } + + return bRet; +} + +void SvxShowCharSet::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + InitSettings(rRenderContext); + RecalculateFont(rRenderContext); + DrawChars_Impl(rRenderContext, FirstInView(), LastInView()); +} + +void SvxShowCharSet::SetFont( const vcl::Font& rFont ) +{ + maFont = rFont; + mbRecalculateFont = true; + Invalidate(); +} + +void SvxShowCharSet::DeSelect() +{ + Invalidate(); +} + +// stretch a grid rectangle if its at the edge to fill unused space +tools::Rectangle SvxShowCharSet::getGridRectangle(const Point &rPointUL, const Size &rOutputSize) +{ + long x = rPointUL.X() - 1; + long y = rPointUL.Y() - 1; + Point aPointUL(x+1, y+1); + Size aGridSize(nX-1, nY-1); + + long nXDistFromLeft = x - m_nXGap; + if (nXDistFromLeft <= 1) + { + aPointUL.setX( 1 ); + aGridSize.AdjustWidth(m_nXGap + nXDistFromLeft ); + } + long nXDistFromRight = rOutputSize.Width() - m_nXGap - nX - x; + if (nXDistFromRight <= 1) + aGridSize.AdjustWidth(m_nXGap + nXDistFromRight ); + + long nXDistFromTop = y - m_nYGap; + if (nXDistFromTop <= 1) + { + aPointUL.setY( 1 ); + aGridSize.AdjustHeight(m_nYGap + nXDistFromTop ); + } + long nXDistFromBottom = rOutputSize.Height() - m_nYGap - nY - y; + if (nXDistFromBottom <= 1) + aGridSize.AdjustHeight(m_nYGap + nXDistFromBottom ); + + return tools::Rectangle(aPointUL, aGridSize); +} + +void SvxShowCharSet::DrawChars_Impl(vcl::RenderContext& rRenderContext, int n1, int n2) +{ + if (n1 > LastInView() || n2 < FirstInView()) + return; + + Size aOutputSize(GetOutputSizePixel()); + + int i; + for (i = 1; i < COLUMN_COUNT; ++i) + { + rRenderContext.DrawLine(Point(nX * i + m_nXGap, 0), + Point(nX * i + m_nXGap, aOutputSize.Height())); + } + for (i = 1; i < ROW_COUNT; ++i) + { + rRenderContext.DrawLine(Point(0, nY * i + m_nYGap), + Point(aOutputSize.Width(), nY * i + m_nYGap)); + } + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Color aWindowTextColor(rStyleSettings.GetFieldTextColor()); + Color aHighlightColor(rStyleSettings.GetHighlightColor()); + Color aHighlightTextColor(rStyleSettings.GetHighlightTextColor()); + Color aFaceColor(rStyleSettings.GetFaceColor()); + Color aLightColor(rStyleSettings.GetLightColor()); + Color aShadowColor(rStyleSettings.GetShadowColor()); + + int nTextHeight = rRenderContext.GetTextHeight(); + tools::Rectangle aBoundRect; + for (i = n1; i <= n2; ++i) + { + Point pix = MapIndexToPixel(i); + int x = pix.X(); + int y = pix.Y(); + + sal_UCS4 nChar = mxFontCharMap->GetCharFromIndex(i); + OUString aCharStr(&nChar, 1); + int nTextWidth = rRenderContext.GetTextWidth(aCharStr); + int tx = x + (nX - nTextWidth + 1) / 2; + int ty = y + (nY - nTextHeight + 1) / 2; + Point aPointTxTy(tx, ty); + + // adjust position before it gets out of bounds + if (rRenderContext.GetTextBoundRect(aBoundRect, aCharStr) && !aBoundRect.IsEmpty()) + { + // zero advance width => use ink width to center glyph + if (!nTextWidth) + { + aPointTxTy.setX( x - aBoundRect.Left() + (nX - aBoundRect.GetWidth() + 1) / 2 ); + } + + aBoundRect += aPointTxTy; + + // shift back vertically if needed + int nYLDelta = aBoundRect.Top() - y; + int nYHDelta = (y + nY) - aBoundRect.Bottom(); + if (nYLDelta <= 0) + aPointTxTy.AdjustY( -(nYLDelta - 1) ); + else if (nYHDelta <= 0) + aPointTxTy.AdjustY(nYHDelta - 1 ); + + // shift back horizontally if needed + int nXLDelta = aBoundRect.Left() - x; + int nXHDelta = (x + nX) - aBoundRect.Right(); + if (nXLDelta <= 0) + aPointTxTy.AdjustX( -(nXLDelta - 1) ); + else if (nXHDelta <= 0) + aPointTxTy.AdjustX(nXHDelta - 1 ); + } + + Color aTextCol = rRenderContext.GetTextColor(); + if (i != nSelectedIndex) + { + rRenderContext.SetTextColor(aWindowTextColor); + rRenderContext.DrawText(aPointTxTy, aCharStr); + } + else + { + Color aLineCol = rRenderContext.GetLineColor(); + Color aFillCol = rRenderContext.GetFillColor(); + rRenderContext.SetLineColor(); + Point aPointUL(x + 1, y + 1); + if (HasFocus()) + { + rRenderContext.SetFillColor(aHighlightColor); + rRenderContext.DrawRect(getGridRectangle(aPointUL, aOutputSize)); + + rRenderContext.SetTextColor(aHighlightTextColor); + rRenderContext.DrawText(aPointTxTy, aCharStr); + } + else + { + rRenderContext.SetFillColor(aFaceColor); + rRenderContext.DrawRect(getGridRectangle(aPointUL, aOutputSize)); + + rRenderContext.SetLineColor(aLightColor); + rRenderContext.DrawLine(aPointUL, Point(x + nX - 1, y + 1)); + rRenderContext.DrawLine(aPointUL, Point(x + 1, y + nY - 1)); + + rRenderContext.SetLineColor(aShadowColor); + rRenderContext.DrawLine(Point(x + 1, y + nY - 1), Point(x + nX - 1, y + nY - 1)); + rRenderContext.DrawLine(Point(x + nX - 1, y + nY - 1), Point(x + nX - 1, y + 1)); + + rRenderContext.DrawText(aPointTxTy, aCharStr); + } + rRenderContext.SetLineColor(aLineCol); + rRenderContext.SetFillColor(aFillCol); + } + rRenderContext.SetTextColor(aTextCol); + } +} + + +void SvxShowCharSet::InitSettings(vcl::RenderContext& rRenderContext) +{ + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + + if (mbUpdateForeground) + { + rRenderContext.SetTextColor(rStyleSettings.GetDialogTextColor()); + mbUpdateForeground = false; + } + + if (mbUpdateBackground) + { + rRenderContext.SetBackground(rStyleSettings.GetWindowColor()); + rRenderContext.Erase(); + mbUpdateBackground = false; + } + + vcl::Font aFont(maFont); + aFont.SetWeight(WEIGHT_LIGHT); + aFont.SetAlignment(ALIGN_TOP); + aFont.SetFontSize(maFontSize); + aFont.SetTransparent(true); + rRenderContext.SetFont(aFont); +} + +sal_UCS4 SvxShowCharSet::GetSelectCharacter() const +{ + if( nSelectedIndex >= 0 ) + getSelectedChar() = mxFontCharMap->GetCharFromIndex( nSelectedIndex ); + return getSelectedChar(); +} + + +void SvxShowCharSet::RecalculateFont(vcl::RenderContext& rRenderContext) +{ + if (!mbRecalculateFont) + return; + + // save last selected unicode + if (nSelectedIndex >= 0) + getSelectedChar() = mxFontCharMap->GetCharFromIndex(nSelectedIndex); + + Size aSize(GetOutputSizePixel()); + + vcl::Font aFont = maFont; + aFont.SetWeight(WEIGHT_LIGHT); + aFont.SetAlignment(ALIGN_TOP); + int nFontHeight = (aSize.Height() - 5) * 2 / (3 * ROW_COUNT); + maFontSize = rRenderContext.PixelToLogic(Size(0, nFontHeight)); + aFont.SetFontSize(maFontSize); + aFont.SetTransparent(true); + rRenderContext.SetFont(aFont); + rRenderContext.GetFontCharMap(mxFontCharMap); + getFavCharacterList(); + + nX = aSize.Width() / COLUMN_COUNT; + nY = aSize.Height() / ROW_COUNT; + + const int nLastRow = (mxFontCharMap->GetCharCount() - 1 + COLUMN_COUNT) / COLUMN_COUNT; + mxScrollArea->vadjustment_configure(mxScrollArea->vadjustment_get_value(), 0, nLastRow, 1, ROW_COUNT - 1, ROW_COUNT); + + // restore last selected unicode + int nMapIndex = mxFontCharMap->GetIndexFromChar(getSelectedChar()); + if (nMapIndex != nSelectedIndex) + SelectIndex(nMapIndex); + + // rearrange CharSet element in sync with nX- and nY-multiples + Size aDrawSize(nX * COLUMN_COUNT, nY * ROW_COUNT); + m_nXGap = (aSize.Width() - aDrawSize.Width()) / 2; + m_nYGap = (aSize.Height() - aDrawSize.Height()) / 2; + + mbRecalculateFont = false; +} + +void SvxShowCharSet::SelectIndex(int nNewIndex, bool bFocus) +{ + if (!mxFontCharMap.is()) + RecalculateFont(*mxVirDev); + + if( nNewIndex < 0 ) + { + // need to scroll see closest unicode + sal_uInt32 cPrev = mxFontCharMap->GetPrevChar( getSelectedChar() ); + int nMapIndex = mxFontCharMap->GetIndexFromChar( cPrev ); + int nNewPos = nMapIndex / COLUMN_COUNT; + mxScrollArea->vadjustment_set_value(nNewPos); + nSelectedIndex = bFocus ? nMapIndex+1 : -1; + Invalidate(); + } + else if( nNewIndex < FirstInView() ) + { + // need to scroll up to see selected item + int nOldPos = mxScrollArea->vadjustment_get_value(); + int nDelta = (FirstInView() - nNewIndex + COLUMN_COUNT-1) / COLUMN_COUNT; + mxScrollArea->vadjustment_set_value(nOldPos - nDelta); + nSelectedIndex = nNewIndex; + Invalidate(); + } + else if( nNewIndex > LastInView() ) + { + // need to scroll down to see selected item + int nOldPos = mxScrollArea->vadjustment_get_value(); + int nDelta = (nNewIndex - LastInView() + COLUMN_COUNT) / COLUMN_COUNT; + mxScrollArea->vadjustment_set_value(nOldPos + nDelta); + if( nNewIndex < mxFontCharMap->GetCharCount() ) + { + nSelectedIndex = nNewIndex; + Invalidate(); + } + else if (nOldPos != mxScrollArea->vadjustment_get_value()) + { + Invalidate(); + } + } + else + { + nSelectedIndex = nNewIndex; + Invalidate(); + } + + if( nSelectedIndex >= 0 ) + { + getSelectedChar() = mxFontCharMap->GetCharFromIndex( nSelectedIndex ); + if( m_xAccessible.is() ) + { + svx::SvxShowCharSetItem* pItem = ImplGetItem(nSelectedIndex); + // Don't fire the focus event. + if ( bFocus ) + m_xAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), makeAny(pItem->GetAccessible()) ); // this call assures that m_pItem is set + else + m_xAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS, Any(), makeAny(pItem->GetAccessible()) ); // this call assures that m_pItem is set + + assert(pItem->m_xItem.is() && "No accessible created!"); + Any aOldAny, aNewAny; + aNewAny <<= AccessibleStateType::FOCUSED; + // Don't fire the focus event. + if ( bFocus ) + pItem->m_xItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny ); + + aNewAny <<= AccessibleStateType::SELECTED; + pItem->m_xItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny ); + } + } + aHighHdl.Call( this ); +} + +void SvxShowCharSet::OutputIndex( int nNewIndex ) +{ + SelectIndex( nNewIndex, true ); + aSelectHdl.Call( this ); +} + + +void SvxShowCharSet::SelectCharacter( sal_UCS4 cNew ) +{ + if ( !mxFontCharMap.is() ) + RecalculateFont(*mxVirDev); + + // get next available char of current font + sal_UCS4 cNext = mxFontCharMap->GetNextChar( (cNew > 0) ? cNew - 1 : cNew ); + + int nMapIndex = mxFontCharMap->GetIndexFromChar( cNext ); + SelectIndex( nMapIndex ); + // move selected item to top row if not in focus + mxScrollArea->vadjustment_set_value(nMapIndex / COLUMN_COUNT); + Invalidate(); +} + +IMPL_LINK_NOARG(SvxShowCharSet, VscrollHdl, weld::ScrolledWindow&, void) +{ + if( nSelectedIndex < FirstInView() ) + { + SelectIndex( FirstInView() + (nSelectedIndex % COLUMN_COUNT) ); + } + else if( nSelectedIndex > LastInView() ) + { + if( m_xAccessible.is() ) + { + css::uno::Any aOldAny, aNewAny; + int nLast = LastInView(); + for ( ; nLast != nSelectedIndex; ++nLast) + { + aOldAny <<= ImplGetItem(nLast)->GetAccessible(); + m_xAccessible ->fireEvent( AccessibleEventId::CHILD, aOldAny, aNewAny ); + } + } + SelectIndex( (LastInView() - COLUMN_COUNT + 1) + (nSelectedIndex % COLUMN_COUNT) ); + } + + Invalidate(); +} + +SvxShowCharSet::~SvxShowCharSet() +{ + if (m_xAccessible.is()) + { + m_aItems.clear(); + m_xAccessible->clearCharSetControl(); + m_xAccessible.clear(); + } +} + +css::uno::Reference< XAccessible > SvxShowCharSet::CreateAccessible() +{ + OSL_ENSURE(!m_xAccessible.is(),"Accessible already created!"); + m_xAccessible = new svx::SvxShowCharSetAcc(this); + return m_xAccessible.get(); +} + +svx::SvxShowCharSetItem* SvxShowCharSet::ImplGetItem( int _nPos ) +{ + ItemsMap::iterator aFind = m_aItems.find(_nPos); + if ( aFind == m_aItems.end() ) + { + OSL_ENSURE(m_xAccessible.is(), "Who wants to create a child of my table without a parent?"); + auto xItem = std::make_shared<svx::SvxShowCharSetItem>(*this, + m_xAccessible.get(), sal::static_int_cast< sal_uInt16 >(_nPos)); + aFind = m_aItems.emplace(_nPos, xItem).first; + OUStringBuffer buf; + buf.appendUtf32( mxFontCharMap->GetCharFromIndex( _nPos ) ); + aFind->second->maText = buf.makeStringAndClear(); + Point pix = MapIndexToPixel( _nPos ); + aFind->second->maRect = tools::Rectangle( Point( pix.X() + 1, pix.Y() + 1 ), Size(nX-1,nY-1) ); + } + + return aFind->second.get(); +} + +sal_Int32 SvxShowCharSet::getMaxCharCount() const +{ + return mxFontCharMap->GetCharCount(); +} + +FontCharMapRef const & SvxShowCharSet::GetFontCharMap() +{ + RecalculateFont(*mxVirDev); + return mxFontCharMap; +} + +// TODO: should be moved into Font Attributes stuff +// we let it mature here though because it is currently the only use + +SubsetMap::SubsetMap( const FontCharMapRef& rxFontCharMap ) +{ + InitList(); + ApplyCharMap(rxFontCharMap); +} + +const SubsetVec& SubsetMap::GetSubsetMap() const +{ + return maSubsets; +} + +const Subset* SubsetMap::GetSubsetByUnicode( sal_UCS4 cChar ) const +{ + for (auto const& subset : maSubsets) + if( (subset.GetRangeMin() <= cChar) && (cChar <= subset.GetRangeMax()) ) + return ⊂ + return nullptr; +} + +inline Subset::Subset(sal_UCS4 nMin, sal_UCS4 nMax, const OUString& rName) +: mnRangeMin(nMin), mnRangeMax(nMax), maRangeName(rName) +{ +} + +void SubsetMap::InitList() +{ + static SubsetVec s_aAllSubsets = [&]() + { + SubsetVec aAllSubsets; + //I wish icu had a way to give me the block ranges + for (int i = UBLOCK_BASIC_LATIN; i < UBLOCK_COUNT; ++i) + { + UBlockCode eBlock = static_cast<UBlockCode>(i); + switch (eBlock) + { + case UBLOCK_NO_BLOCK: + case UBLOCK_INVALID_CODE: + case UBLOCK_COUNT: + case UBLOCK_HIGH_SURROGATES: + case UBLOCK_HIGH_PRIVATE_USE_SURROGATES: + case UBLOCK_LOW_SURROGATES: + break; + case UBLOCK_BASIC_LATIN: + aAllSubsets.emplace_back( 0x0000, 0x007F, SvxResId(RID_SUBSETSTR_BASIC_LATIN) ); + break; + case UBLOCK_LATIN_1_SUPPLEMENT: + aAllSubsets.emplace_back( 0x0080, 0x00FF, SvxResId(RID_SUBSETSTR_LATIN_1) ); + break; + case UBLOCK_LATIN_EXTENDED_A: + aAllSubsets.emplace_back( 0x0100, 0x017F, SvxResId(RID_SUBSETSTR_LATIN_EXTENDED_A) ); + break; + case UBLOCK_LATIN_EXTENDED_B: + aAllSubsets.emplace_back( 0x0180, 0x024F, SvxResId(RID_SUBSETSTR_LATIN_EXTENDED_B) ); + break; + case UBLOCK_IPA_EXTENSIONS: + aAllSubsets.emplace_back( 0x0250, 0x02AF, SvxResId(RID_SUBSETSTR_IPA_EXTENSIONS) ); + break; + case UBLOCK_SPACING_MODIFIER_LETTERS: + aAllSubsets.emplace_back( 0x02B0, 0x02FF, SvxResId(RID_SUBSETSTR_SPACING_MODIFIERS) ); + break; + case UBLOCK_COMBINING_DIACRITICAL_MARKS: + aAllSubsets.emplace_back( 0x0300, 0x036F, SvxResId(RID_SUBSETSTR_COMB_DIACRITICAL) ); + break; + case UBLOCK_GREEK: + aAllSubsets.emplace_back( 0x0370, 0x03FF, SvxResId(RID_SUBSETSTR_BASIC_GREEK) ); + break; + case UBLOCK_CYRILLIC: + aAllSubsets.emplace_back( 0x0400, 0x04FF, SvxResId(RID_SUBSETSTR_CYRILLIC) ); + break; + case UBLOCK_ARMENIAN: + aAllSubsets.emplace_back( 0x0530, 0x058F, SvxResId(RID_SUBSETSTR_ARMENIAN) ); + break; + case UBLOCK_HEBREW: + aAllSubsets.emplace_back( 0x0590, 0x05FF, SvxResId(RID_SUBSETSTR_BASIC_HEBREW) ); + break; + case UBLOCK_ARABIC: + aAllSubsets.emplace_back( 0x0600, 0x065F, SvxResId(RID_SUBSETSTR_BASIC_ARABIC) ); + break; + case UBLOCK_SYRIAC: + aAllSubsets.emplace_back( 0x0700, 0x074F, SvxResId(RID_SUBSETSTR_SYRIAC) ); + break; + case UBLOCK_THAANA: + aAllSubsets.emplace_back( 0x0780, 0x07BF, SvxResId(RID_SUBSETSTR_THAANA) ); + break; + case UBLOCK_DEVANAGARI: + aAllSubsets.emplace_back( 0x0900, 0x097F, SvxResId(RID_SUBSETSTR_DEVANAGARI) ); + break; + case UBLOCK_BENGALI: + aAllSubsets.emplace_back( 0x0980, 0x09FF, SvxResId(RID_SUBSETSTR_BENGALI) ); + break; + case UBLOCK_GURMUKHI: + aAllSubsets.emplace_back( 0x0A00, 0x0A7F, SvxResId(RID_SUBSETSTR_GURMUKHI) ); + break; + case UBLOCK_GUJARATI: + aAllSubsets.emplace_back( 0x0A80, 0x0AFF, SvxResId(RID_SUBSETSTR_GUJARATI) ); + break; + case UBLOCK_ORIYA: + aAllSubsets.emplace_back( 0x0B00, 0x0B7F, SvxResId(RID_SUBSETSTR_ODIA) ); + break; + case UBLOCK_TAMIL: + aAllSubsets.emplace_back( 0x0B80, 0x0BFF, SvxResId(RID_SUBSETSTR_TAMIL) ); + break; + case UBLOCK_TELUGU: + aAllSubsets.emplace_back( 0x0C00, 0x0C7F, SvxResId(RID_SUBSETSTR_TELUGU) ); + break; + case UBLOCK_KANNADA: + aAllSubsets.emplace_back( 0x0C80, 0x0CFF, SvxResId(RID_SUBSETSTR_KANNADA) ); + break; + case UBLOCK_MALAYALAM: + aAllSubsets.emplace_back( 0x0D00, 0x0D7F, SvxResId(RID_SUBSETSTR_MALAYALAM) ); + break; + case UBLOCK_SINHALA: + aAllSubsets.emplace_back( 0x0D80, 0x0DFF, SvxResId(RID_SUBSETSTR_SINHALA) ); + break; + case UBLOCK_THAI: + aAllSubsets.emplace_back( 0x0E00, 0x0E7F, SvxResId(RID_SUBSETSTR_THAI) ); + break; + case UBLOCK_LAO: + aAllSubsets.emplace_back( 0x0E80, 0x0EFF, SvxResId(RID_SUBSETSTR_LAO) ); + break; + case UBLOCK_TIBETAN: + aAllSubsets.emplace_back( 0x0F00, 0x0FBF, SvxResId(RID_SUBSETSTR_TIBETAN) ); + break; + case UBLOCK_MYANMAR: + aAllSubsets.emplace_back( 0x1000, 0x109F, SvxResId(RID_SUBSETSTR_MYANMAR) ); + break; + case UBLOCK_GEORGIAN: + aAllSubsets.emplace_back( 0x10A0, 0x10FF, SvxResId(RID_SUBSETSTR_BASIC_GEORGIAN) ); + break; + case UBLOCK_HANGUL_JAMO: + aAllSubsets.emplace_back( 0x1100, 0x11FF, SvxResId(RID_SUBSETSTR_HANGUL_JAMO) ); + break; + case UBLOCK_ETHIOPIC: + aAllSubsets.emplace_back( 0x1200, 0x137F, SvxResId(RID_SUBSETSTR_ETHIOPIC) ); + break; + case UBLOCK_CHEROKEE: + aAllSubsets.emplace_back( 0x13A0, 0x13FF, SvxResId(RID_SUBSETSTR_CHEROKEE) ); + break; + case UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS: + aAllSubsets.emplace_back( 0x1400, 0x167F, SvxResId(RID_SUBSETSTR_CANADIAN_ABORIGINAL) ); + break; + case UBLOCK_OGHAM: + aAllSubsets.emplace_back( 0x1680, 0x169F, SvxResId(RID_SUBSETSTR_OGHAM) ); + break; + case UBLOCK_RUNIC: + aAllSubsets.emplace_back( 0x16A0, 0x16F0, SvxResId(RID_SUBSETSTR_RUNIC) ); + break; + case UBLOCK_KHMER: + aAllSubsets.emplace_back( 0x1780, 0x17FF, SvxResId(RID_SUBSETSTR_KHMER) ); + break; + case UBLOCK_MONGOLIAN: + aAllSubsets.emplace_back( 0x1800, 0x18AF, SvxResId(RID_SUBSETSTR_MONGOLIAN) ); + break; + case UBLOCK_LATIN_EXTENDED_ADDITIONAL: + aAllSubsets.emplace_back( 0x1E00, 0x1EFF, SvxResId(RID_SUBSETSTR_LATIN_EXTENDED_ADDS) ); + break; + case UBLOCK_GREEK_EXTENDED: + aAllSubsets.emplace_back( 0x1F00, 0x1FFF, SvxResId(RID_SUBSETSTR_GREEK_EXTENDED) ); + break; + case UBLOCK_GENERAL_PUNCTUATION: + aAllSubsets.emplace_back( 0x2000, 0x206F, SvxResId(RID_SUBSETSTR_GENERAL_PUNCTUATION) ); + break; + case UBLOCK_SUPERSCRIPTS_AND_SUBSCRIPTS: + aAllSubsets.emplace_back( 0x2070, 0x209F, SvxResId(RID_SUBSETSTR_SUB_SUPER_SCRIPTS) ); + break; + case UBLOCK_CURRENCY_SYMBOLS: + aAllSubsets.emplace_back( 0x20A0, 0x20CF, SvxResId(RID_SUBSETSTR_CURRENCY_SYMBOLS) ); + break; + case UBLOCK_COMBINING_MARKS_FOR_SYMBOLS: + aAllSubsets.emplace_back( 0x20D0, 0x20FF, SvxResId(RID_SUBSETSTR_COMB_DIACRITIC_SYMS) ); + break; + case UBLOCK_LETTERLIKE_SYMBOLS: + aAllSubsets.emplace_back( 0x2100, 0x214F, SvxResId(RID_SUBSETSTR_LETTERLIKE_SYMBOLS) ); + break; + case UBLOCK_NUMBER_FORMS: + aAllSubsets.emplace_back( 0x2150, 0x218F, SvxResId(RID_SUBSETSTR_NUMBER_FORMS) ); + break; + case UBLOCK_ARROWS: + aAllSubsets.emplace_back( 0x2190, 0x21FF, SvxResId(RID_SUBSETSTR_ARROWS) ); + break; + case UBLOCK_MATHEMATICAL_OPERATORS: + aAllSubsets.emplace_back( 0x2200, 0x22FF, SvxResId(RID_SUBSETSTR_MATH_OPERATORS) ); + break; + case UBLOCK_MISCELLANEOUS_TECHNICAL: + aAllSubsets.emplace_back( 0x2300, 0x23FF, SvxResId(RID_SUBSETSTR_MISC_TECHNICAL) ); + break; + case UBLOCK_CONTROL_PICTURES: + aAllSubsets.emplace_back( 0x2400, 0x243F, SvxResId(RID_SUBSETSTR_CONTROL_PICTURES) ); + break; + case UBLOCK_OPTICAL_CHARACTER_RECOGNITION: + aAllSubsets.emplace_back( 0x2440, 0x245F, SvxResId(RID_SUBSETSTR_OPTICAL_CHAR_REC) ); + break; + case UBLOCK_ENCLOSED_ALPHANUMERICS: + aAllSubsets.emplace_back( 0x2460, 0x24FF, SvxResId(RID_SUBSETSTR_ENCLOSED_ALPHANUM) ); + break; + case UBLOCK_BOX_DRAWING: + aAllSubsets.emplace_back( 0x2500, 0x257F, SvxResId(RID_SUBSETSTR_BOX_DRAWING) ); + break; + case UBLOCK_BLOCK_ELEMENTS: + aAllSubsets.emplace_back( 0x2580, 0x259F, SvxResId(RID_SUBSETSTR_BLOCK_ELEMENTS) ); + break; + case UBLOCK_GEOMETRIC_SHAPES: + aAllSubsets.emplace_back( 0x25A0, 0x25FF, SvxResId(RID_SUBSETSTR_GEOMETRIC_SHAPES) ); + break; + case UBLOCK_MISCELLANEOUS_SYMBOLS: + aAllSubsets.emplace_back( 0x2600, 0x26FF, SvxResId(RID_SUBSETSTR_MISC_DINGBATS) ); + break; + case UBLOCK_DINGBATS: + aAllSubsets.emplace_back( 0x2700, 0x27BF, SvxResId(RID_SUBSETSTR_DINGBATS) ); + break; + case UBLOCK_BRAILLE_PATTERNS: + aAllSubsets.emplace_back( 0x2800, 0x28FF, SvxResId(RID_SUBSETSTR_BRAILLE_PATTERNS) ); + break; + case UBLOCK_CJK_RADICALS_SUPPLEMENT: + aAllSubsets.emplace_back( 0x2E80, 0x2EFF, SvxResId(RID_SUBSETSTR_CJK_RADICAL_SUPPL) ); + break; + case UBLOCK_KANGXI_RADICALS: + aAllSubsets.emplace_back( 0x2F00, 0x2FDF, SvxResId(RID_SUBSETSTR_KANGXI_RADICALS) ); + break; + case UBLOCK_IDEOGRAPHIC_DESCRIPTION_CHARACTERS: + aAllSubsets.emplace_back( 0x2FF0, 0x2FFF, SvxResId(RID_SUBSETSTR_IDEO_DESC_CHARS) ); + break; + case UBLOCK_CJK_SYMBOLS_AND_PUNCTUATION: + aAllSubsets.emplace_back( 0x3000, 0x303F, SvxResId(RID_SUBSETSTR_CJK_SYMS_PUNCTUATION) ); + break; + case UBLOCK_HIRAGANA: + aAllSubsets.emplace_back( 0x3040, 0x309F, SvxResId(RID_SUBSETSTR_HIRAGANA) ); + break; + case UBLOCK_KATAKANA: + aAllSubsets.emplace_back( 0x30A0, 0x30FF, SvxResId(RID_SUBSETSTR_KATAKANA) ); + break; + case UBLOCK_BOPOMOFO: + aAllSubsets.emplace_back( 0x3100, 0x312F, SvxResId(RID_SUBSETSTR_BOPOMOFO) ); + break; + case UBLOCK_HANGUL_COMPATIBILITY_JAMO: + aAllSubsets.emplace_back( 0x3130, 0x318F, SvxResId(RID_SUBSETSTR_HANGUL_COMPAT_JAMO) ); + break; + case UBLOCK_KANBUN: + aAllSubsets.emplace_back( 0x3190, 0x319F, SvxResId(RID_SUBSETSTR_KANBUN) ); + break; + case UBLOCK_BOPOMOFO_EXTENDED: + aAllSubsets.emplace_back( 0x31A0, 0x31BF, SvxResId(RID_SUBSETSTR_BOPOMOFO_EXTENDED) ); + break; + case UBLOCK_ENCLOSED_CJK_LETTERS_AND_MONTHS: + aAllSubsets.emplace_back( 0x3200, 0x32FF, SvxResId(RID_SUBSETSTR_ENCLOSED_CJK_LETTERS) ); + break; + case UBLOCK_CJK_COMPATIBILITY: + aAllSubsets.emplace_back( 0x3300, 0x33FF, SvxResId(RID_SUBSETSTR_CJK_COMPATIBILITY) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A: + aAllSubsets.emplace_back( 0x3400, 0x4DBF, SvxResId(RID_SUBSETSTR_CJK_EXT_A_UNIFIED_IDGRAPH) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS: + aAllSubsets.emplace_back( 0x4E00, 0x9FA5, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDGRAPH) ); + break; + case UBLOCK_YI_SYLLABLES: + aAllSubsets.emplace_back( 0xA000, 0xA48F, SvxResId(RID_SUBSETSTR_YI_SYLLABLES) ); + break; + case UBLOCK_YI_RADICALS: + aAllSubsets.emplace_back( 0xA490, 0xA4CF, SvxResId(RID_SUBSETSTR_YI_RADICALS) ); + break; + case UBLOCK_HANGUL_SYLLABLES: + aAllSubsets.emplace_back( 0xAC00, 0xD7AF, SvxResId(RID_SUBSETSTR_HANGUL) ); + break; + case UBLOCK_PRIVATE_USE_AREA: + aAllSubsets.emplace_back( 0xE000, 0xF8FF, SvxResId(RID_SUBSETSTR_PRIVATE_USE_AREA) ); + break; + case UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS: + aAllSubsets.emplace_back( 0xF900, 0xFAFF, SvxResId(RID_SUBSETSTR_CJK_COMPAT_IDGRAPHS) ); + break; + case UBLOCK_ALPHABETIC_PRESENTATION_FORMS: + aAllSubsets.emplace_back( 0xFB00, 0xFB4F, SvxResId(RID_SUBSETSTR_ALPHA_PRESENTATION) ); + break; + case UBLOCK_ARABIC_PRESENTATION_FORMS_A: + aAllSubsets.emplace_back( 0xFB50, 0xFDFF, SvxResId(RID_SUBSETSTR_ARABIC_PRESENT_A) ); + break; + case UBLOCK_COMBINING_HALF_MARKS: + aAllSubsets.emplace_back( 0xFE20, 0xFE2F, SvxResId(RID_SUBSETSTR_COMBINING_HALF_MARKS) ); + break; + case UBLOCK_CJK_COMPATIBILITY_FORMS: + aAllSubsets.emplace_back( 0xFE30, 0xFE4F, SvxResId(RID_SUBSETSTR_CJK_COMPAT_FORMS) ); + break; + case UBLOCK_SMALL_FORM_VARIANTS: + aAllSubsets.emplace_back( 0xFE50, 0xFE6F, SvxResId(RID_SUBSETSTR_SMALL_FORM_VARIANTS) ); + break; + case UBLOCK_ARABIC_PRESENTATION_FORMS_B: + aAllSubsets.emplace_back( 0xFE70, 0xFEFF, SvxResId(RID_SUBSETSTR_ARABIC_PRESENT_B) ); + break; + case UBLOCK_SPECIALS: + aAllSubsets.emplace_back( 0xFFF0, 0xFFFF, SvxResId(RID_SUBSETSTR_SPECIALS) ); + break; + case UBLOCK_HALFWIDTH_AND_FULLWIDTH_FORMS: + aAllSubsets.emplace_back( 0xFF00, 0xFFEF, SvxResId(RID_SUBSETSTR_HALFW_FULLW_FORMS) ); + break; + case UBLOCK_OLD_ITALIC: + aAllSubsets.emplace_back( 0x10300, 0x1032F, SvxResId(RID_SUBSETSTR_OLD_ITALIC) ); + break; + case UBLOCK_GOTHIC: + aAllSubsets.emplace_back( 0x10330, 0x1034F, SvxResId(RID_SUBSETSTR_GOTHIC) ); + break; + case UBLOCK_DESERET: + aAllSubsets.emplace_back( 0x10400, 0x1044F, SvxResId(RID_SUBSETSTR_DESERET) ); + break; + case UBLOCK_BYZANTINE_MUSICAL_SYMBOLS: + aAllSubsets.emplace_back( 0x1D000, 0x1D0FF, SvxResId(RID_SUBSETSTR_BYZANTINE_MUSICAL_SYMBOLS) ); + break; + case UBLOCK_MUSICAL_SYMBOLS: + aAllSubsets.emplace_back( 0x1D100, 0x1D1FF, SvxResId(RID_SUBSETSTR_MUSICAL_SYMBOLS) ); + break; + case UBLOCK_MATHEMATICAL_ALPHANUMERIC_SYMBOLS: + aAllSubsets.emplace_back( 0x1D400, 0x1D7FF, SvxResId(RID_SUBSETSTR_MATHEMATICAL_ALPHANUMERIC_SYMBOLS) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B: + aAllSubsets.emplace_back( 0x20000, 0x2A6DF, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B) ); + break; + case UBLOCK_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT: + aAllSubsets.emplace_back( 0x2F800, 0x2FA1F, SvxResId(RID_SUBSETSTR_CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT) ); + break; + case UBLOCK_TAGS: + aAllSubsets.emplace_back( 0xE0000, 0xE007F, SvxResId(RID_SUBSETSTR_TAGS) ); + break; + case UBLOCK_CYRILLIC_SUPPLEMENTARY: + aAllSubsets.emplace_back( 0x0500, 0x052F, SvxResId(RID_SUBSETSTR_CYRILLIC_SUPPLEMENTARY) ); + break; + case UBLOCK_TAGALOG: + aAllSubsets.emplace_back( 0x1700, 0x171F, SvxResId(RID_SUBSETSTR_TAGALOG) ); + break; + case UBLOCK_HANUNOO: + aAllSubsets.emplace_back( 0x1720, 0x173F, SvxResId(RID_SUBSETSTR_HANUNOO) ); + break; + case UBLOCK_BUHID: + aAllSubsets.emplace_back( 0x1740, 0x175F, SvxResId(RID_SUBSETSTR_BUHID) ); + break; + case UBLOCK_TAGBANWA: + aAllSubsets.emplace_back( 0x1760, 0x177F, SvxResId(RID_SUBSETSTR_TAGBANWA) ); + break; + case UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A: + aAllSubsets.emplace_back( 0x27C0, 0x27EF, SvxResId(RID_SUBSETSTR_MISC_MATH_SYMS_A) ); + break; + case UBLOCK_SUPPLEMENTAL_ARROWS_A: + aAllSubsets.emplace_back( 0x27F0, 0x27FF, SvxResId(RID_SUBSETSTR_SUPPL_ARROWS_A) ); + break; + case UBLOCK_SUPPLEMENTAL_ARROWS_B: + aAllSubsets.emplace_back( 0x2900, 0x297F, SvxResId(RID_SUBSETSTR_SUPPL_ARROWS_B) ); + break; + case UBLOCK_MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B: + aAllSubsets.emplace_back( 0x2980, 0x29FF, SvxResId(RID_SUBSETSTR_MISC_MATH_SYMS_B) ); + break; + case UBLOCK_SUPPLEMENTAL_MATHEMATICAL_OPERATORS: + aAllSubsets.emplace_back( 0x2A00, 0x2AFF, SvxResId(RID_SUBSETSTR_MISC_MATH_SYMS_B) ); + break; + case UBLOCK_KATAKANA_PHONETIC_EXTENSIONS: + aAllSubsets.emplace_back( 0x31F0, 0x31FF, SvxResId(RID_SUBSETSTR_KATAKANA_PHONETIC) ); + break; + case UBLOCK_VARIATION_SELECTORS: + aAllSubsets.emplace_back( 0xFE00, 0xFE0F, SvxResId(RID_SUBSETSTR_VARIATION_SELECTORS) ); + break; + case UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_A: + aAllSubsets.emplace_back( 0xF0000, 0xFFFFF, SvxResId(RID_SUBSETSTR_SUPPLEMENTARY_PRIVATE_USE_AREA_A) ); + break; + case UBLOCK_SUPPLEMENTARY_PRIVATE_USE_AREA_B: + aAllSubsets.emplace_back( 0x100000, 0x10FFFF, SvxResId(RID_SUBSETSTR_SUPPLEMENTARY_PRIVATE_USE_AREA_B) ); + break; + case UBLOCK_LIMBU: + aAllSubsets.emplace_back( 0x1900, 0x194F, SvxResId(RID_SUBSETSTR_LIMBU) ); + break; + case UBLOCK_TAI_LE: + aAllSubsets.emplace_back( 0x1950, 0x197F, SvxResId(RID_SUBSETSTR_TAI_LE) ); + break; + case UBLOCK_KHMER_SYMBOLS: + aAllSubsets.emplace_back( 0x19E0, 0x19FF, SvxResId(RID_SUBSETSTR_KHMER_SYMBOLS) ); + break; + case UBLOCK_PHONETIC_EXTENSIONS: + aAllSubsets.emplace_back( 0x1D00, 0x1D7F, SvxResId(RID_SUBSETSTR_PHONETIC_EXTENSIONS) ); + break; + case UBLOCK_MISCELLANEOUS_SYMBOLS_AND_ARROWS: + aAllSubsets.emplace_back( 0x2B00, 0x2BFF, SvxResId(RID_SUBSETSTR_MISCELLANEOUS_SYMBOLS_AND_ARROWS) ); + break; + case UBLOCK_YIJING_HEXAGRAM_SYMBOLS: + aAllSubsets.emplace_back( 0x4DC0, 0x4DFF, SvxResId(RID_SUBSETSTR_YIJING_HEXAGRAM_SYMBOLS) ); + break; + case UBLOCK_LINEAR_B_SYLLABARY: + aAllSubsets.emplace_back( 0x10000, 0x1007F, SvxResId(RID_SUBSETSTR_LINEAR_B_SYLLABARY) ); + break; + case UBLOCK_LINEAR_B_IDEOGRAMS: + aAllSubsets.emplace_back( 0x10080, 0x100FF, SvxResId(RID_SUBSETSTR_LINEAR_B_IDEOGRAMS) ); + break; + case UBLOCK_AEGEAN_NUMBERS: + aAllSubsets.emplace_back( 0x10100, 0x1013F, SvxResId(RID_SUBSETSTR_AEGEAN_NUMBERS) ); + break; + case UBLOCK_UGARITIC: + aAllSubsets.emplace_back( 0x10380, 0x1039F, SvxResId(RID_SUBSETSTR_UGARITIC) ); + break; + case UBLOCK_SHAVIAN: + aAllSubsets.emplace_back( 0x10450, 0x1047F, SvxResId(RID_SUBSETSTR_SHAVIAN) ); + break; + case UBLOCK_OSMANYA: + aAllSubsets.emplace_back( 0x10480, 0x104AF, SvxResId(RID_SUBSETSTR_OSMANYA) ); + break; + case UBLOCK_CYPRIOT_SYLLABARY: + aAllSubsets.emplace_back( 0x10800, 0x1083F, SvxResId(RID_SUBSETSTR_CYPRIOT_SYLLABARY) ); + break; + case UBLOCK_TAI_XUAN_JING_SYMBOLS: + aAllSubsets.emplace_back( 0x1D300, 0x1D35F, SvxResId(RID_SUBSETSTR_TAI_XUAN_JING_SYMBOLS) ); + break; + case UBLOCK_VARIATION_SELECTORS_SUPPLEMENT: + aAllSubsets.emplace_back( 0xE0100, 0xE01EF, SvxResId(RID_SUBSETSTR_VARIATION_SELECTORS_SUPPLEMENT) ); + break; + case UBLOCK_ANCIENT_GREEK_MUSICAL_NOTATION: + aAllSubsets.emplace_back(0x1D200, 0x1D24F, SvxResId(RID_SUBSETSTR_ANCIENT_GREEK_MUSICAL_NOTATION) ); + break; + case UBLOCK_ANCIENT_GREEK_NUMBERS: + aAllSubsets.emplace_back(0x10140, 0x1018F , SvxResId(RID_SUBSETSTR_ANCIENT_GREEK_NUMBERS) ); + break; + case UBLOCK_ARABIC_SUPPLEMENT: + aAllSubsets.emplace_back(0x0750, 0x077F , SvxResId(RID_SUBSETSTR_ARABIC_SUPPLEMENT) ); + break; + case UBLOCK_BUGINESE: + aAllSubsets.emplace_back(0x1A00, 0x1A1F , SvxResId(RID_SUBSETSTR_BUGINESE) ); + break; + case UBLOCK_CJK_STROKES: + aAllSubsets.emplace_back( 0x31C0, 0x31EF, SvxResId(RID_SUBSETSTR_CJK_STROKES) ); + break; + case UBLOCK_COMBINING_DIACRITICAL_MARKS_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1DC0, 0x1DFF , SvxResId(RID_SUBSETSTR_COMBINING_DIACRITICAL_MARKS_SUPPLEMENT) ); + break; + case UBLOCK_COPTIC: + aAllSubsets.emplace_back( 0x2C80, 0x2CFF , SvxResId(RID_SUBSETSTR_COPTIC) ); + break; + case UBLOCK_ETHIOPIC_EXTENDED: + aAllSubsets.emplace_back( 0x2D80, 0x2DDF , SvxResId(RID_SUBSETSTR_ETHIOPIC_EXTENDED) ); + break; + case UBLOCK_ETHIOPIC_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1380, 0x139F, SvxResId(RID_SUBSETSTR_ETHIOPIC_SUPPLEMENT) ); + break; + case UBLOCK_GEORGIAN_SUPPLEMENT: + aAllSubsets.emplace_back( 0x2D00, 0x2D2F, SvxResId(RID_SUBSETSTR_GEORGIAN_SUPPLEMENT) ); + break; + case UBLOCK_GLAGOLITIC: + aAllSubsets.emplace_back( 0x2C00, 0x2C5F, SvxResId(RID_SUBSETSTR_GLAGOLITIC) ); + break; + case UBLOCK_KHAROSHTHI: + aAllSubsets.emplace_back( 0x10A00, 0x10A5F, SvxResId(RID_SUBSETSTR_KHAROSHTHI) ); + break; + case UBLOCK_MODIFIER_TONE_LETTERS: + aAllSubsets.emplace_back( 0xA700, 0xA71F, SvxResId(RID_SUBSETSTR_MODIFIER_TONE_LETTERS) ); + break; + case UBLOCK_NEW_TAI_LUE: + aAllSubsets.emplace_back( 0x1980, 0x19DF, SvxResId(RID_SUBSETSTR_NEW_TAI_LUE) ); + break; + case UBLOCK_OLD_PERSIAN: + aAllSubsets.emplace_back( 0x103A0, 0x103DF, SvxResId(RID_SUBSETSTR_OLD_PERSIAN) ); + break; + case UBLOCK_PHONETIC_EXTENSIONS_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1D80, 0x1DBF, SvxResId(RID_SUBSETSTR_PHONETIC_EXTENSIONS_SUPPLEMENT) ); + break; + case UBLOCK_SUPPLEMENTAL_PUNCTUATION: + aAllSubsets.emplace_back( 0x2E00, 0x2E7F, SvxResId(RID_SUBSETSTR_SUPPLEMENTAL_PUNCTUATION) ); + break; + case UBLOCK_SYLOTI_NAGRI: + aAllSubsets.emplace_back( 0xA800, 0xA82F, SvxResId(RID_SUBSETSTR_SYLOTI_NAGRI) ); + break; + case UBLOCK_TIFINAGH: + aAllSubsets.emplace_back( 0x2D30, 0x2D7F, SvxResId(RID_SUBSETSTR_TIFINAGH) ); + break; + case UBLOCK_VERTICAL_FORMS: + aAllSubsets.emplace_back( 0xFE10, 0xFE1F, SvxResId(RID_SUBSETSTR_VERTICAL_FORMS) ); + break; + case UBLOCK_NKO: + aAllSubsets.emplace_back( 0x07C0, 0x07FF, SvxResId(RID_SUBSETSTR_NKO) ); + break; + case UBLOCK_BALINESE: + aAllSubsets.emplace_back( 0x1B00, 0x1B7F, SvxResId(RID_SUBSETSTR_BALINESE) ); + break; + case UBLOCK_LATIN_EXTENDED_C: + aAllSubsets.emplace_back( 0x2C60, 0x2C7F, SvxResId(RID_SUBSETSTR_LATIN_EXTENDED_C) ); + break; + case UBLOCK_LATIN_EXTENDED_D: + aAllSubsets.emplace_back( 0xA720, 0xA7FF, SvxResId(RID_SUBSETSTR_LATIN_EXTENDED_D) ); + break; + case UBLOCK_PHAGS_PA: + aAllSubsets.emplace_back( 0xA840, 0xA87F, SvxResId(RID_SUBSETSTR_PHAGS_PA) ); + break; + case UBLOCK_PHOENICIAN: + aAllSubsets.emplace_back( 0x10900, 0x1091F, SvxResId(RID_SUBSETSTR_PHOENICIAN) ); + break; + case UBLOCK_CUNEIFORM: + aAllSubsets.emplace_back( 0x12000, 0x123FF, SvxResId(RID_SUBSETSTR_CUNEIFORM) ); + break; + case UBLOCK_CUNEIFORM_NUMBERS_AND_PUNCTUATION: + aAllSubsets.emplace_back( 0x12400, 0x1247F, SvxResId(RID_SUBSETSTR_CUNEIFORM_NUMBERS_AND_PUNCTUATION) ); + break; + case UBLOCK_COUNTING_ROD_NUMERALS: + aAllSubsets.emplace_back( 0x1D360, 0x1D37F, SvxResId(RID_SUBSETSTR_COUNTING_ROD_NUMERALS) ); + break; + case UBLOCK_SUNDANESE: + aAllSubsets.emplace_back( 0x1B80, 0x1BBF, SvxResId(RID_SUBSETSTR_SUNDANESE) ); + break; + case UBLOCK_LEPCHA: + aAllSubsets.emplace_back( 0x1C00, 0x1C4F, SvxResId(RID_SUBSETSTR_LEPCHA) ); + break; + case UBLOCK_OL_CHIKI: + aAllSubsets.emplace_back( 0x1C50, 0x1C7F, SvxResId(RID_SUBSETSTR_OL_CHIKI) ); + break; + case UBLOCK_CYRILLIC_EXTENDED_A: + aAllSubsets.emplace_back( 0x2DE0, 0x2DFF, SvxResId(RID_SUBSETSTR_CYRILLIC_EXTENDED_A) ); + break; + case UBLOCK_VAI: + aAllSubsets.emplace_back( 0xA500, 0xA63F, SvxResId(RID_SUBSETSTR_VAI) ); + break; + case UBLOCK_CYRILLIC_EXTENDED_B: + aAllSubsets.emplace_back( 0xA640, 0xA69F, SvxResId(RID_SUBSETSTR_CYRILLIC_EXTENDED_B) ); + break; + case UBLOCK_SAURASHTRA: + aAllSubsets.emplace_back( 0xA880, 0xA8DF, SvxResId(RID_SUBSETSTR_SAURASHTRA) ); + break; + case UBLOCK_KAYAH_LI: + aAllSubsets.emplace_back( 0xA900, 0xA92F, SvxResId(RID_SUBSETSTR_KAYAH_LI) ); + break; + case UBLOCK_REJANG: + aAllSubsets.emplace_back( 0xA930, 0xA95F, SvxResId(RID_SUBSETSTR_REJANG) ); + break; + case UBLOCK_CHAM: + aAllSubsets.emplace_back( 0xAA00, 0xAA5F, SvxResId(RID_SUBSETSTR_CHAM) ); + break; + case UBLOCK_ANCIENT_SYMBOLS: + aAllSubsets.emplace_back( 0x10190, 0x101CF, SvxResId(RID_SUBSETSTR_ANCIENT_SYMBOLS) ); + break; + case UBLOCK_PHAISTOS_DISC: + aAllSubsets.emplace_back( 0x101D0, 0x101FF, SvxResId(RID_SUBSETSTR_PHAISTOS_DISC) ); + break; + case UBLOCK_LYCIAN: + aAllSubsets.emplace_back( 0x10280, 0x1029F, SvxResId(RID_SUBSETSTR_LYCIAN) ); + break; + case UBLOCK_CARIAN: + aAllSubsets.emplace_back( 0x102A0, 0x102DF, SvxResId(RID_SUBSETSTR_CARIAN) ); + break; + case UBLOCK_LYDIAN: + aAllSubsets.emplace_back( 0x10920, 0x1093F, SvxResId(RID_SUBSETSTR_LYDIAN) ); + break; + case UBLOCK_MAHJONG_TILES: + aAllSubsets.emplace_back( 0x1F000, 0x1F02F, SvxResId(RID_SUBSETSTR_MAHJONG_TILES) ); + break; + case UBLOCK_DOMINO_TILES: + aAllSubsets.emplace_back( 0x1F030, 0x1F09F, SvxResId(RID_SUBSETSTR_DOMINO_TILES) ); + break; +#if (U_ICU_VERSION_MAJOR_NUM > 4) || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM >= 4) + case UBLOCK_SAMARITAN: + aAllSubsets.emplace_back( 0x0800, 0x083F, SvxResId(RID_SUBSETSTR_SAMARITAN) ); + break; + case UBLOCK_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED: + aAllSubsets.emplace_back( 0x18B0, 0x18FF, SvxResId(RID_SUBSETSTR_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED) ); + break; + case UBLOCK_TAI_THAM: + aAllSubsets.emplace_back( 0x1A20, 0x1AAF, SvxResId(RID_SUBSETSTR_TAI_THAM) ); + break; + case UBLOCK_VEDIC_EXTENSIONS: + aAllSubsets.emplace_back( 0x1CD0, 0x1CFF, SvxResId(RID_SUBSETSTR_VEDIC_EXTENSIONS) ); + break; + case UBLOCK_LISU: + aAllSubsets.emplace_back( 0xA4D0, 0xA4FF, SvxResId(RID_SUBSETSTR_LISU) ); + break; + case UBLOCK_BAMUM: + aAllSubsets.emplace_back( 0xA6A0, 0xA6FF, SvxResId(RID_SUBSETSTR_BAMUM) ); + break; + case UBLOCK_COMMON_INDIC_NUMBER_FORMS: + aAllSubsets.emplace_back( 0xA830, 0xA83F, SvxResId(RID_SUBSETSTR_COMMON_INDIC_NUMBER_FORMS) ); + break; + case UBLOCK_DEVANAGARI_EXTENDED: + aAllSubsets.emplace_back( 0xA8E0, 0xA8FF, SvxResId(RID_SUBSETSTR_DEVANAGARI_EXTENDED) ); + break; + case UBLOCK_HANGUL_JAMO_EXTENDED_A: + aAllSubsets.emplace_back( 0xA960, 0xA97F, SvxResId(RID_SUBSETSTR_HANGUL_JAMO_EXTENDED_A) ); + break; + case UBLOCK_JAVANESE: + aAllSubsets.emplace_back( 0xA980, 0xA9DF, SvxResId(RID_SUBSETSTR_JAVANESE) ); + break; + case UBLOCK_MYANMAR_EXTENDED_A: + aAllSubsets.emplace_back( 0xAA60, 0xAA7F, SvxResId(RID_SUBSETSTR_MYANMAR_EXTENDED_A) ); + break; + case UBLOCK_TAI_VIET: + aAllSubsets.emplace_back( 0xAA80, 0xAADF, SvxResId(RID_SUBSETSTR_TAI_VIET) ); + break; + case UBLOCK_MEETEI_MAYEK: + aAllSubsets.emplace_back( 0xABC0, 0xABFF, SvxResId(RID_SUBSETSTR_MEETEI_MAYEK) ); + break; + case UBLOCK_HANGUL_JAMO_EXTENDED_B: + aAllSubsets.emplace_back( 0xD7B0, 0xD7FF, SvxResId(RID_SUBSETSTR_HANGUL_JAMO_EXTENDED_B) ); + break; + case UBLOCK_IMPERIAL_ARAMAIC: + aAllSubsets.emplace_back( 0x10840, 0x1085F, SvxResId(RID_SUBSETSTR_IMPERIAL_ARAMAIC) ); + break; + case UBLOCK_OLD_SOUTH_ARABIAN: + aAllSubsets.emplace_back( 0x10A60, 0x10A7F, SvxResId(RID_SUBSETSTR_OLD_SOUTH_ARABIAN) ); + break; + case UBLOCK_AVESTAN: + aAllSubsets.emplace_back( 0x10B00, 0x10B3F, SvxResId(RID_SUBSETSTR_AVESTAN) ); + break; + case UBLOCK_INSCRIPTIONAL_PARTHIAN: + aAllSubsets.emplace_back( 0x10B40, 0x10B5F, SvxResId(RID_SUBSETSTR_INSCRIPTIONAL_PARTHIAN) ); + break; + case UBLOCK_INSCRIPTIONAL_PAHLAVI: + aAllSubsets.emplace_back( 0x10B60, 0x10B7F, SvxResId(RID_SUBSETSTR_INSCRIPTIONAL_PAHLAVI) ); + break; + case UBLOCK_OLD_TURKIC: + aAllSubsets.emplace_back( 0x10C00, 0x10C4F, SvxResId(RID_SUBSETSTR_OLD_TURKIC) ); + break; + case UBLOCK_RUMI_NUMERAL_SYMBOLS: + aAllSubsets.emplace_back( 0x10E60, 0x10E7F, SvxResId(RID_SUBSETSTR_RUMI_NUMERAL_SYMBOLS) ); + break; + case UBLOCK_KAITHI: + aAllSubsets.emplace_back( 0x11080, 0x110CF, SvxResId(RID_SUBSETSTR_KAITHI) ); + break; + case UBLOCK_EGYPTIAN_HIEROGLYPHS: + aAllSubsets.emplace_back( 0x13000, 0x1342F, SvxResId(RID_SUBSETSTR_EGYPTIAN_HIEROGLYPHS) ); + break; + case UBLOCK_ENCLOSED_ALPHANUMERIC_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1F100, 0x1F1FF, SvxResId(RID_SUBSETSTR_ENCLOSED_ALPHANUMERIC_SUPPLEMENT) ); + break; + case UBLOCK_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1F200, 0x1F2FF, SvxResId(RID_SUBSETSTR_ENCLOSED_IDEOGRAPHIC_SUPPLEMENT) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C: + aAllSubsets.emplace_back( 0x2A700, 0x2B73F, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C) ); + break; +#endif +#if (U_ICU_VERSION_MAJOR_NUM > 4) || (U_ICU_VERSION_MAJOR_NUM == 4 && U_ICU_VERSION_MINOR_NUM >= 6) + case UBLOCK_MANDAIC: + aAllSubsets.emplace_back( 0x0840, 0x085F, SvxResId(RID_SUBSETSTR_MANDAIC) ); + break; + case UBLOCK_BATAK: + aAllSubsets.emplace_back( 0x1BC0, 0x1BFF, SvxResId(RID_SUBSETSTR_BATAK) ); + break; + case UBLOCK_ETHIOPIC_EXTENDED_A: + aAllSubsets.emplace_back( 0xAB00, 0xAB2F, SvxResId(RID_SUBSETSTR_ETHIOPIC_EXTENDED_A) ); + break; + case UBLOCK_BRAHMI: + aAllSubsets.emplace_back( 0x11000, 0x1107F, SvxResId(RID_SUBSETSTR_BRAHMI) ); + break; + case UBLOCK_BAMUM_SUPPLEMENT: + aAllSubsets.emplace_back( 0x16800, 0x16A3F, SvxResId(RID_SUBSETSTR_BAMUM_SUPPLEMENT) ); + break; + case UBLOCK_KANA_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1B000, 0x1B0FF, SvxResId(RID_SUBSETSTR_KANA_SUPPLEMENT) ); + break; + case UBLOCK_PLAYING_CARDS: + aAllSubsets.emplace_back( 0x1F0A0, 0x1F0FF, SvxResId(RID_SUBSETSTR_PLAYING_CARDS) ); + break; + case UBLOCK_MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS: + aAllSubsets.emplace_back( 0x1F300, 0x1F5FF, SvxResId(RID_SUBSETSTR_MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS) ); + break; + case UBLOCK_EMOTICONS: + aAllSubsets.emplace_back( 0x1F600, 0x1F64F, SvxResId(RID_SUBSETSTR_EMOTICONS) ); + break; + case UBLOCK_TRANSPORT_AND_MAP_SYMBOLS: + aAllSubsets.emplace_back( 0x1F680, 0x1F6FF, SvxResId(RID_SUBSETSTR_TRANSPORT_AND_MAP_SYMBOLS) ); + break; + case UBLOCK_ALCHEMICAL_SYMBOLS: + aAllSubsets.emplace_back( 0x1F700, 0x1F77F, SvxResId(RID_SUBSETSTR_ALCHEMICAL_SYMBOLS) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D: + aAllSubsets.emplace_back( 0x2B740, 0x2B81F, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D) ); + break; +#endif +// Note ICU version 49 (NOT 4.9), so the MAJOR_NUM is two digits. +#if U_ICU_VERSION_MAJOR_NUM >= 49 + case UBLOCK_ARABIC_EXTENDED_A: + aAllSubsets.emplace_back( 0x08A0, 0x08FF, SvxResId(RID_SUBSETSTR_ARABIC_EXTENDED_A) ); + break; + case UBLOCK_ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS: + aAllSubsets.emplace_back( 0x1EE00, 0x1EEFF, SvxResId(RID_SUBSETSTR_ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS) ); + break; + case UBLOCK_CHAKMA: + aAllSubsets.emplace_back( 0x11100, 0x1114F, SvxResId(RID_SUBSETSTR_CHAKMA) ); + break; + case UBLOCK_MEETEI_MAYEK_EXTENSIONS: + aAllSubsets.emplace_back( 0xAAE0, 0xAAFF, SvxResId(RID_SUBSETSTR_MEETEI_MAYEK_EXTENSIONS) ); + break; + case UBLOCK_MEROITIC_CURSIVE: + aAllSubsets.emplace_back( 0x109A0, 0x109FF, SvxResId(RID_SUBSETSTR_MEROITIC_CURSIVE) ); + break; + case UBLOCK_MEROITIC_HIEROGLYPHS: + aAllSubsets.emplace_back( 0x10980, 0x1099F, SvxResId(RID_SUBSETSTR_MEROITIC_HIEROGLYPHS) ); + break; + case UBLOCK_MIAO: + aAllSubsets.emplace_back( 0x16F00, 0x16F9F, SvxResId(RID_SUBSETSTR_MIAO) ); + break; + case UBLOCK_SHARADA: + aAllSubsets.emplace_back( 0x11180, 0x111DF, SvxResId(RID_SUBSETSTR_SHARADA) ); + break; + case UBLOCK_SORA_SOMPENG: + aAllSubsets.emplace_back( 0x110D0, 0x110FF, SvxResId(RID_SUBSETSTR_SORA_SOMPENG) ); + break; + case UBLOCK_SUNDANESE_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1CC0, 0x1CCF, SvxResId(RID_SUBSETSTR_SUNDANESE_SUPPLEMENT) ); + break; + case UBLOCK_TAKRI: + aAllSubsets.emplace_back( 0x11680, 0x116CF, SvxResId(RID_SUBSETSTR_TAKRI) ); + break; +#endif +#if U_ICU_VERSION_MAJOR_NUM >= 54 + case UBLOCK_BASSA_VAH: + aAllSubsets.emplace_back( 0x16AD0, 0x16AFF, SvxResId(RID_SUBSETSTR_BASSA_VAH) ); + break; + case UBLOCK_CAUCASIAN_ALBANIAN: + aAllSubsets.emplace_back( 0x10530, 0x1056F, SvxResId(RID_SUBSETSTR_CAUCASIAN_ALBANIAN) ); + break; + case UBLOCK_COPTIC_EPACT_NUMBERS: + aAllSubsets.emplace_back( 0x102E0, 0x102FF, SvxResId(RID_SUBSETSTR_COPTIC_EPACT_NUMBERS) ); + break; + case UBLOCK_COMBINING_DIACRITICAL_MARKS_EXTENDED: + aAllSubsets.emplace_back( 0x1AB0, 0x1AFF, SvxResId(RID_SUBSETSTR_COMBINING_DIACRITICAL_MARKS_EXTENDED) ); + break; + case UBLOCK_DUPLOYAN: + aAllSubsets.emplace_back( 0x1BC00, 0x1BC9F, SvxResId(RID_SUBSETSTR_DUPLOYAN) ); + break; + case UBLOCK_ELBASAN: + aAllSubsets.emplace_back( 0x10500, 0x1052F, SvxResId(RID_SUBSETSTR_ELBASAN) ); + break; + case UBLOCK_GEOMETRIC_SHAPES_EXTENDED: + aAllSubsets.emplace_back( 0x1F780, 0x1F7FF, SvxResId(RID_SUBSETSTR_GEOMETRIC_SHAPES_EXTENDED) ); + break; + case UBLOCK_GRANTHA: + aAllSubsets.emplace_back( 0x11300, 0x1137F, SvxResId(RID_SUBSETSTR_GRANTHA) ); + break; + case UBLOCK_KHOJKI: + aAllSubsets.emplace_back( 0x11200, 0x1124F, SvxResId(RID_SUBSETSTR_KHOJKI) ); + break; + case UBLOCK_KHUDAWADI: + aAllSubsets.emplace_back( 0x112B0, 0x112FF, SvxResId(RID_SUBSETSTR_KHUDAWADI) ); + break; + case UBLOCK_LATIN_EXTENDED_E: + aAllSubsets.emplace_back( 0xAB30, 0xAB6F, SvxResId(RID_SUBSETSTR_LATIN_EXTENDED_E) ); + break; + case UBLOCK_LINEAR_A: + aAllSubsets.emplace_back( 0x10600, 0x1077F, SvxResId(RID_SUBSETSTR_LINEAR_A) ); + break; + case UBLOCK_MAHAJANI: + aAllSubsets.emplace_back( 0x11150, 0x1117F, SvxResId(RID_SUBSETSTR_MAHAJANI) ); + break; + case UBLOCK_MANICHAEAN: + aAllSubsets.emplace_back( 0x10AC0, 0x10AFF, SvxResId(RID_SUBSETSTR_MANICHAEAN) ); + break; + case UBLOCK_MENDE_KIKAKUI: + aAllSubsets.emplace_back( 0x1E800, 0x1E8DF, SvxResId(RID_SUBSETSTR_MENDE_KIKAKUI) ); + break; + case UBLOCK_MODI: + aAllSubsets.emplace_back( 0x11600, 0x1165F, SvxResId(RID_SUBSETSTR_MODI) ); + break; + case UBLOCK_MRO: + aAllSubsets.emplace_back( 0x16A40, 0x16A6F, SvxResId(RID_SUBSETSTR_MRO) ); + break; + case UBLOCK_MYANMAR_EXTENDED_B: + aAllSubsets.emplace_back( 0xA9E0, 0xA9FF, SvxResId(RID_SUBSETSTR_MYANMAR_EXTENDED_B) ); + break; + case UBLOCK_NABATAEAN: + aAllSubsets.emplace_back( 0x10880, 0x108AF, SvxResId(RID_SUBSETSTR_NABATAEAN) ); + break; + case UBLOCK_OLD_NORTH_ARABIAN: + aAllSubsets.emplace_back( 0x10A80, 0x10A9F, SvxResId(RID_SUBSETSTR_OLD_NORTH_ARABIAN) ); + break; + case UBLOCK_OLD_PERMIC: + aAllSubsets.emplace_back( 0x10350, 0x1037F, SvxResId(RID_SUBSETSTR_OLD_PERMIC) ); + break; + case UBLOCK_ORNAMENTAL_DINGBATS: + aAllSubsets.emplace_back( 0x1F650, 0x1F67F, SvxResId(RID_SUBSETSTR_ORNAMENTAL_DINGBATS) ); + break; + case UBLOCK_PAHAWH_HMONG: + aAllSubsets.emplace_back( 0x16B00, 0x16B8F, SvxResId(RID_SUBSETSTR_PAHAWH_HMONG) ); + break; + case UBLOCK_PALMYRENE: + aAllSubsets.emplace_back( 0x10860, 0x1087F, SvxResId(RID_SUBSETSTR_PALMYRENE) ); + break; + case UBLOCK_PAU_CIN_HAU: + aAllSubsets.emplace_back( 0x11AC0, 0x11AFF, SvxResId(RID_SUBSETSTR_PAU_CIN_HAU) ); + break; + case UBLOCK_PSALTER_PAHLAVI: + aAllSubsets.emplace_back( 0x10B80, 0x10BAF, SvxResId(RID_SUBSETSTR_PSALTER_PAHLAVI) ); + break; + case UBLOCK_SHORTHAND_FORMAT_CONTROLS: + aAllSubsets.emplace_back( 0x1BCA0, 0x1BCAF, SvxResId(RID_SUBSETSTR_SHORTHAND_FORMAT_CONTROLS) ); + break; + case UBLOCK_SIDDHAM: + aAllSubsets.emplace_back( 0x11580, 0x115FF, SvxResId(RID_SUBSETSTR_SIDDHAM) ); + break; + case UBLOCK_SINHALA_ARCHAIC_NUMBERS: + aAllSubsets.emplace_back( 0x111E0, 0x111FF, SvxResId(RID_SUBSETSTR_SINHALA_ARCHAIC_NUMBERS) ); + break; + case UBLOCK_SUPPLEMENTAL_ARROWS_C: + aAllSubsets.emplace_back( 0x1F800, 0x1F8FF, SvxResId(RID_SUBSETSTR_SUPPLEMENTAL_ARROWS_C) ); + break; + case UBLOCK_TIRHUTA: + aAllSubsets.emplace_back( 0x11480, 0x114DF, SvxResId(RID_SUBSETSTR_TIRHUTA) ); + break; + case UBLOCK_WARANG_CITI: + aAllSubsets.emplace_back( 0x118A0, 0x118FF, SvxResId(RID_SUBSETSTR_WARANG_CITI) ); + break; +#endif +#if U_ICU_VERSION_MAJOR_NUM >= 56 + case UBLOCK_AHOM: + aAllSubsets.emplace_back( 0x11700, 0x1173F, SvxResId(RID_SUBSETSTR_AHOM) ); + break; + case UBLOCK_ANATOLIAN_HIEROGLYPHS: + aAllSubsets.emplace_back( 0x14400, 0x1467F, SvxResId(RID_SUBSETSTR_ANATOLIAN_HIEROGLYPHS) ); + break; + case UBLOCK_CHEROKEE_SUPPLEMENT: + aAllSubsets.emplace_back( 0xAB70, 0xABBF, SvxResId(RID_SUBSETSTR_CHEROKEE_SUPPLEMENT) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E: + aAllSubsets.emplace_back( 0x2B820, 0x2CEAF, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E) ); + break; + case UBLOCK_EARLY_DYNASTIC_CUNEIFORM: + aAllSubsets.emplace_back( 0x12480, 0x1254F, SvxResId(RID_SUBSETSTR_EARLY_DYNASTIC_CUNEIFORM) ); + break; + case UBLOCK_HATRAN: + aAllSubsets.emplace_back( 0x108E0, 0x108FF, SvxResId(RID_SUBSETSTR_HATRAN) ); + break; + case UBLOCK_MULTANI: + aAllSubsets.emplace_back( 0x11280, 0x112AF, SvxResId(RID_SUBSETSTR_MULTANI) ); + break; + case UBLOCK_OLD_HUNGARIAN: + aAllSubsets.emplace_back( 0x10C80, 0x10CFF, SvxResId(RID_SUBSETSTR_OLD_HUNGARIAN) ); + break; + case UBLOCK_SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS: + aAllSubsets.emplace_back( 0x1F900, 0x1F9FF, SvxResId(RID_SUBSETSTR_SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS) ); + break; + case UBLOCK_SUTTON_SIGNWRITING: + aAllSubsets.emplace_back( 0x1D800, 0x1DAAF, SvxResId(RID_SUBSETSTR_SUTTON_SIGNWRITING) ); + break; +#endif +#if (U_ICU_VERSION_MAJOR_NUM >= 58) + case UBLOCK_ADLAM: + aAllSubsets.emplace_back( 0x1E900, 0x1E95F, SvxResId(RID_SUBSETSTR_ADLAM) ); + break; + case UBLOCK_BHAIKSUKI: + aAllSubsets.emplace_back( 0x11C00, 0x11C6F, SvxResId(RID_SUBSETSTR_BHAIKSUKI) ); + break; + case UBLOCK_CYRILLIC_EXTENDED_C: + aAllSubsets.emplace_back( 0x1C80, 0x1C8F, SvxResId(RID_SUBSETSTR_CYRILLIC_EXTENDED_C) ); + break; + case UBLOCK_GLAGOLITIC_SUPPLEMENT: + aAllSubsets.emplace_back( 0x1E000, 0x1E02F, SvxResId(RID_SUBSETSTR_GLAGOLITIC_SUPPLEMENT) ); + break; + case UBLOCK_IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION: + aAllSubsets.emplace_back( 0x16FE0, 0x16FFF, SvxResId(RID_SUBSETSTR_IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION) ); + break; + case UBLOCK_MARCHEN: + aAllSubsets.emplace_back( 0x11C70, 0x11CBF, SvxResId(RID_SUBSETSTR_MARCHEN) ); + break; + case UBLOCK_MONGOLIAN_SUPPLEMENT: + aAllSubsets.emplace_back( 0x11660, 0x1167F, SvxResId(RID_SUBSETSTR_MONGOLIAN_SUPPLEMENT) ); + break; + case UBLOCK_NEWA: + aAllSubsets.emplace_back( 0x11400, 0x1147F, SvxResId(RID_SUBSETSTR_NEWA) ); + break; + case UBLOCK_OSAGE: + aAllSubsets.emplace_back( 0x104B0, 0x104FF, SvxResId(RID_SUBSETSTR_OSAGE) ); + break; + case UBLOCK_TANGUT: + aAllSubsets.emplace_back( 0x17000, 0x187FF, SvxResId(RID_SUBSETSTR_TANGUT) ); + break; + case UBLOCK_TANGUT_COMPONENTS: + aAllSubsets.emplace_back( 0x18800, 0x18AFF, SvxResId(RID_SUBSETSTR_TANGUT_COMPONENTS) ); + break; +#endif +#if (U_ICU_VERSION_MAJOR_NUM >= 60) + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F: + aAllSubsets.emplace_back( 0x2CEB0, 0x2EBE0, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F) ); + break; + case UBLOCK_KANA_EXTENDED_A: + aAllSubsets.emplace_back( 0x1B100, 0x1B12F, SvxResId(RID_SUBSETSTR_KANA_EXTENDED_A) ); + break; + case UBLOCK_MASARAM_GONDI: + aAllSubsets.emplace_back( 0x11D00, 0x11D5F, SvxResId(RID_SUBSETSTR_MASARAM_GONDI) ); + break; + case UBLOCK_NUSHU: + aAllSubsets.emplace_back( 0x1B170, 0x1B2FF, SvxResId(RID_SUBSETSTR_NUSHU) ); + break; + case UBLOCK_SOYOMBO: + aAllSubsets.emplace_back( 0x11A50, 0x11AAF, SvxResId(RID_SUBSETSTR_SOYOMBO) ); + break; + case UBLOCK_SYRIAC_SUPPLEMENT: + aAllSubsets.emplace_back( 0x0860, 0x086f, SvxResId(RID_SUBSETSTR_SYRIAC_SUPPLEMENT) ); + break; + case UBLOCK_ZANABAZAR_SQUARE: + aAllSubsets.emplace_back( 0x11A00, 0x11A4F, SvxResId(RID_SUBSETSTR_ZANABAZAR_SQUARE) ); + break; +#endif +#if (U_ICU_VERSION_MAJOR_NUM >= 62) + case UBLOCK_CHESS_SYMBOLS: + aAllSubsets.emplace_back( 0x1FA00, 0x1FA6F, SvxResId(RID_SUBSETSTR_CHESS_SYMBOLS) ); + break; + case UBLOCK_DOGRA: + aAllSubsets.emplace_back( 0x11800, 0x1184F, SvxResId(RID_SUBSETSTR_DOGRA) ); + break; + case UBLOCK_GEORGIAN_EXTENDED: + aAllSubsets.emplace_back( 0x1C90, 0x1CBF, SvxResId(RID_SUBSETSTR_GEORGIAN_EXTENDED) ); + break; + case UBLOCK_GUNJALA_GONDI: + aAllSubsets.emplace_back( 0x11D60, 0x11DAF, SvxResId(RID_SUBSETSTR_GUNJALA_GONDI) ); + break; + case UBLOCK_HANIFI_ROHINGYA: + aAllSubsets.emplace_back( 0x10D00, 0x10D3F, SvxResId(RID_SUBSETSTR_HANIFI_ROHINGYA) ); + break; + case UBLOCK_INDIC_SIYAQ_NUMBERS: + aAllSubsets.emplace_back( 0x1EC70, 0x1ECBF, SvxResId(RID_SUBSETSTR_INDIC_SIYAQ_NUMBERS) ); + break; + case UBLOCK_MAKASAR: + aAllSubsets.emplace_back( 0x11EE0, 0x11EFF, SvxResId(RID_SUBSETSTR_MAKASAR) ); + break; + case UBLOCK_MAYAN_NUMERALS: + aAllSubsets.emplace_back( 0x1D2E0, 0x1D2FF, SvxResId(RID_SUBSETSTR_MAYAN_NUMERALS) ); + break; + case UBLOCK_MEDEFAIDRIN: + aAllSubsets.emplace_back( 0x16E40, 0x16E9F, SvxResId(RID_SUBSETSTR_MEDEFAIDRIN) ); + break; + case UBLOCK_OLD_SOGDIAN: + aAllSubsets.emplace_back( 0x10F00, 0x10F2F, SvxResId(RID_SUBSETSTR_OLD_SOGDIAN) ); + break; + case UBLOCK_SOGDIAN: + aAllSubsets.emplace_back( 0x10F30, 0x10F6F, SvxResId(RID_SUBSETSTR_SOGDIAN) ); + break; +#endif +#if (U_ICU_VERSION_MAJOR_NUM >= 64) + case UBLOCK_EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS: + aAllSubsets.emplace_back( 0x13430, 0x1343F, SvxResId(RID_SUBSETSTR_EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS) ); + break; + case UBLOCK_ELYMAIC: + aAllSubsets.emplace_back( 0x10FE0, 0x10FFF, SvxResId(RID_SUBSETSTR_ELYMAIC) ); + break; + case UBLOCK_NANDINAGARI: + aAllSubsets.emplace_back( 0x119A0, 0x119FF, SvxResId(RID_SUBSETSTR_NANDINAGARI) ); + break; + case UBLOCK_NYIAKENG_PUACHUE_HMONG: + aAllSubsets.emplace_back( 0x1E100, 0x1E14F, SvxResId(RID_SUBSETSTR_NYIAKENG_PUACHUE_HMONG) ); + break; + case UBLOCK_OTTOMAN_SIYAQ_NUMBERS: + aAllSubsets.emplace_back( 0x1ED00, 0x1ED4F, SvxResId(RID_SUBSETSTR_OTTOMAN_SIYAQ_NUMBERS) ); + break; + case UBLOCK_SMALL_KANA_EXTENSION: + aAllSubsets.emplace_back( 0x1B130, 0x1B16F, SvxResId(RID_SUBSETSTR_SMALL_KANA_EXTENSION) ); + break; + case UBLOCK_SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A: + aAllSubsets.emplace_back( 0x1FA70, 0x1FAFF, SvxResId(RID_SUBSETSTR_SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A) ); + break; + case UBLOCK_TAMIL_SUPPLEMENT: + aAllSubsets.emplace_back( 0x11FC0, 0x11FFF, SvxResId(RID_SUBSETSTR_TAMIL_SUPPLEMENT) ); + break; + case UBLOCK_WANCHO: + aAllSubsets.emplace_back( 0x1E2C0, 0x1E2FF, SvxResId(RID_SUBSETSTR_WANCHO) ); + break; +#endif +#if (U_ICU_VERSION_MAJOR_NUM >= 66) + case UBLOCK_CHORASMIAN: + aAllSubsets.emplace_back( 0x10FB0, 0x10FDF, SvxResId(RID_SUBSETSTR_CHORASMIAN) ); + break; + case UBLOCK_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_G: + aAllSubsets.emplace_back( 0x30000, 0x3134F, SvxResId(RID_SUBSETSTR_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_G) ); + break; + case UBLOCK_DIVES_AKURU: + aAllSubsets.emplace_back( 0x11900, 0x1195F, SvxResId(RID_SUBSETSTR_DIVES_AKURU) ); + break; + case UBLOCK_KHITAN_SMALL_SCRIPT: + aAllSubsets.emplace_back( 0x18B00, 0x18CFF, SvxResId(RID_SUBSETSTR_KHITAN_SMALL_SCRIPT) ); + break; + case UBLOCK_LISU_SUPPLEMENT: + aAllSubsets.emplace_back( 0x11FB0, 0x11FBF, SvxResId(RID_SUBSETSTR_LISU_SUPPLEMENT) ); + break; + case UBLOCK_SYMBOLS_FOR_LEGACY_COMPUTING: + aAllSubsets.emplace_back( 0x1FB00, 0x1FBFF, SvxResId(RID_SUBSETSTR_SYMBOLS_FOR_LEGACY_COMPUTING) ); + break; + case UBLOCK_TANGUT_SUPPLEMENT: + aAllSubsets.emplace_back( 0x18D00, 0x18D8F, SvxResId(RID_SUBSETSTR_TANGUT_SUPPLEMENT) ); + break; + case UBLOCK_YEZIDI: + aAllSubsets.emplace_back( 0x10E80, 0x10EBF, SvxResId(RID_SUBSETSTR_YEZIDI) ); + break; +#endif + + } + +#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG + if (eBlock != UBLOCK_NO_BLOCK && + eBlock != UBLOCK_INVALID_CODE && + eBlock != UBLOCK_COUNT && + eBlock != UBLOCK_HIGH_SURROGATES && + eBlock != UBLOCK_HIGH_PRIVATE_USE_SURROGATES && + eBlock != UBLOCK_LOW_SURROGATES) + + { + UBlockCode eBlockStart = ublock_getCode(aAllSubsets.back().GetRangeMin()); + UBlockCode eBlockEnd = ublock_getCode(aAllSubsets.back().GetRangeMax()); + assert(eBlockStart == eBlockEnd && eBlockStart == eBlock); + } +#endif + } + + std::stable_sort(aAllSubsets.begin(), aAllSubsets.end()); + return aAllSubsets; + }(); + + maSubsets = s_aAllSubsets; +} + +void SubsetMap::ApplyCharMap( const FontCharMapRef& rxFontCharMap ) +{ + if( !rxFontCharMap.is() ) + return; + + // remove subsets that are not matched in any range + maSubsets.erase(std::remove_if(maSubsets.begin(), maSubsets.end(), + [&rxFontCharMap](const Subset& rSubset) { + sal_uInt32 cMin = rSubset.GetRangeMin(); + sal_uInt32 cMax = rSubset.GetRangeMax(); + int nCount = rxFontCharMap->CountCharsInRange( cMin, cMax ); + return nCount <= 0; + }), + maSubsets.end()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/compressgraphicdialog.cxx b/svx/source/dialog/compressgraphicdialog.cxx new file mode 100644 index 000000000..14b4c809f --- /dev/null +++ b/svx/source/dialog/compressgraphicdialog.cxx @@ -0,0 +1,432 @@ +/* -*- 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 "dlgunit.hxx" +#include <vcl/fieldvalues.hxx> +#include <vcl/graph.hxx> +#include <vcl/graphicfilter.hxx> +#include <vcl/virdev.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <vcl/weld.hxx> +#include <svx/strings.hrc> +#include <svx/svdograf.hxx> +#include <svx/sdgcpitm.hxx> +#include <svx/dialmgr.hxx> +#include <svx/compressgraphicdialog.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/module.hxx> +#include <comphelper/fileformat.h> +#include <com/sun/star/uno/Sequence.hxx> +#include <tools/stream.hxx> +#include <unotools/localedatawrapper.hxx> + +using namespace com::sun::star::uno; +using namespace com::sun::star::beans; + +CompressGraphicsDialog::CompressGraphicsDialog( weld::Window* pParent, SdrGrafObj* pGraphicObj, SfxBindings& rBindings ) : + GenericDialogController( pParent, "svx/ui/compressgraphicdialog.ui", "CompressGraphicDialog" ), + m_xGraphicObj ( pGraphicObj ), + m_aGraphic ( pGraphicObj->GetGraphicObject().GetGraphic() ), + m_aViewSize100mm ( pGraphicObj->GetLogicRect().GetSize() ), + m_rBindings ( rBindings ), + m_dResolution ( 300 ) +{ + const SdrGrafCropItem& rCrop = m_xGraphicObj->GetMergedItem(SDRATTR_GRAFCROP); + m_aCropRectangle = tools::Rectangle(rCrop.GetLeft(), rCrop.GetTop(), rCrop.GetRight(), rCrop.GetBottom()); + + Initialize(); +} + +CompressGraphicsDialog::CompressGraphicsDialog( weld::Window* pParent, Graphic const & rGraphic, Size rViewSize100mm, tools::Rectangle const & rCropRectangle, SfxBindings& rBindings ) : + GenericDialogController( pParent, "svx/ui/compressgraphicdialog.ui", "CompressGraphicDialog" ), + m_xGraphicObj ( nullptr ), + m_aGraphic ( rGraphic ), + m_aViewSize100mm ( rViewSize100mm ), + m_aCropRectangle ( rCropRectangle ), + m_rBindings ( rBindings ), + m_dResolution ( 300 ) +{ + Initialize(); +} + +CompressGraphicsDialog::~CompressGraphicsDialog() +{ +} + +void CompressGraphicsDialog::Initialize() +{ + m_xLabelGraphicType = m_xBuilder->weld_label("label-graphic-type"); + m_xFixedText2 = m_xBuilder->weld_label("label-original-size"); + m_xFixedText3 = m_xBuilder->weld_label("label-view-size"); + m_xFixedText5 = m_xBuilder->weld_label("label-image-capacity"); + m_xFixedText6 = m_xBuilder->weld_label("label-new-capacity"); + m_xJpegCompRB = m_xBuilder->weld_radio_button("radio-jpeg"); + m_xCompressionMF = m_xBuilder->weld_spin_button("spin-compression"); + m_xCompressionSlider = m_xBuilder->weld_scale("scale-compression"); + m_xLosslessRB = m_xBuilder->weld_radio_button("radio-lossless"); + m_xQualityMF = m_xBuilder->weld_spin_button("spin-quality"); + m_xQualitySlider = m_xBuilder->weld_scale("scale-quality"); + m_xReduceResolutionCB = m_xBuilder->weld_check_button("checkbox-reduce-resolution"); + m_xMFNewWidth = m_xBuilder->weld_spin_button("spin-new-width"); + m_xMFNewHeight = m_xBuilder->weld_spin_button("spin-new-height"); + m_xResolutionLB = m_xBuilder->weld_combo_box("combo-resolution"); + m_xBtnCalculate = m_xBuilder->weld_button("calculate"); + m_xInterpolationCombo = m_xBuilder->weld_combo_box("interpolation-method-combo"); + + m_xInterpolationCombo->set_active_text("Lanczos"); + + m_xInterpolationCombo->connect_changed(LINK(this, CompressGraphicsDialog, NewInterpolationModifiedHdl)); + + m_xMFNewWidth->connect_changed( LINK( this, CompressGraphicsDialog, NewWidthModifiedHdl )); + m_xMFNewHeight->connect_changed( LINK( this, CompressGraphicsDialog, NewHeightModifiedHdl )); + + m_xResolutionLB->connect_changed( LINK( this, CompressGraphicsDialog, ResolutionModifiedHdl )); + m_xBtnCalculate->connect_clicked( LINK( this, CompressGraphicsDialog, CalculateClickHdl ) ); + + m_xLosslessRB->connect_toggled( LINK( this, CompressGraphicsDialog, ToggleCompressionRB ) ); + m_xJpegCompRB->connect_toggled( LINK( this, CompressGraphicsDialog, ToggleCompressionRB ) ); + + m_xReduceResolutionCB->connect_toggled( LINK( this, CompressGraphicsDialog, ToggleReduceResolutionRB ) ); + + m_xQualitySlider->connect_value_changed( LINK( this, CompressGraphicsDialog, SlideHdl )); + m_xCompressionSlider->connect_value_changed( LINK( this, CompressGraphicsDialog, SlideHdl )); + m_xQualityMF->connect_changed( LINK( this, CompressGraphicsDialog, NewQualityModifiedHdl )); + m_xCompressionMF->connect_changed( LINK( this, CompressGraphicsDialog, NewCompressionModifiedHdl )); + + m_xJpegCompRB->set_active(true); + m_xReduceResolutionCB->set_active(true); + + UpdateNewWidthMF(); + UpdateNewHeightMF(); + UpdateResolutionLB(); + Update(); +} + +void CompressGraphicsDialog::Update() +{ + GfxLinkType aLinkType = m_aGraphic.GetGfxLink().GetType(); + OUString aGraphicTypeString; + switch(aLinkType) + { + case GfxLinkType::NativeGif: + aGraphicTypeString = SvxResId(STR_IMAGE_GIF); + break; + case GfxLinkType::NativeJpg: + aGraphicTypeString = SvxResId(STR_IMAGE_JPEG); + break; + case GfxLinkType::NativePng: + aGraphicTypeString = SvxResId(STR_IMAGE_PNG); + break; + case GfxLinkType::NativeTif: + aGraphicTypeString = SvxResId(STR_IMAGE_TIFF); + break; + case GfxLinkType::NativeWmf: + aGraphicTypeString = SvxResId(STR_IMAGE_WMF); + break; + case GfxLinkType::NativeMet: + aGraphicTypeString = SvxResId(STR_IMAGE_MET); + break; + case GfxLinkType::NativePct: + aGraphicTypeString = SvxResId(STR_IMAGE_PCT); + break; + case GfxLinkType::NativeSvg: + aGraphicTypeString = SvxResId(STR_IMAGE_SVG); + break; + case GfxLinkType::NativeBmp: + aGraphicTypeString = SvxResId(STR_IMAGE_BMP); + break; + default: + aGraphicTypeString = SvxResId(STR_IMAGE_UNKNOWN); + break; + } + m_xLabelGraphicType->set_label(aGraphicTypeString); + + const FieldUnit eFieldUnit = m_rBindings.GetDispatcher()->GetModule()->GetFieldUnit(); + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() ); + sal_Unicode cSeparator = rLocaleWrapper.getNumDecimalSep()[0]; + + ScopedVclPtrInstance<VirtualDevice> pDummyVDev; + pDummyVDev->EnableOutput( false ); + pDummyVDev->SetMapMode( m_aGraphic.GetPrefMapMode() ); + + Size aPixelSize = m_aGraphic.GetSizePixel(); + Size aOriginalSize100mm(pDummyVDev->PixelToLogic(m_aGraphic.GetSizePixel(), MapMode(MapUnit::Map100thMM))); + + OUString aBitmapSizeString = SvxResId(STR_IMAGE_ORIGINAL_SIZE); + OUString aWidthString = GetUnitString( aOriginalSize100mm.Width(), eFieldUnit, cSeparator ); + OUString aHeightString = GetUnitString( aOriginalSize100mm.Height(), eFieldUnit, cSeparator ); + aBitmapSizeString = aBitmapSizeString.replaceAll("$(WIDTH)", aWidthString); + aBitmapSizeString = aBitmapSizeString.replaceAll("$(HEIGHT)", aHeightString); + aBitmapSizeString = aBitmapSizeString.replaceAll("$(WIDTH_IN_PX)", OUString::number(aPixelSize.Width())); + aBitmapSizeString = aBitmapSizeString.replaceAll("$(HEIGHT_IN_PX)", OUString::number(aPixelSize.Height())); + m_xFixedText2->set_label(aBitmapSizeString); + + int aValX = static_cast<int>(aPixelSize.Width() / GetViewWidthInch()); + + OUString aViewSizeString = SvxResId(STR_IMAGE_VIEW_SIZE); + + aWidthString = GetUnitString( m_aViewSize100mm.Width(), eFieldUnit, cSeparator ); + aHeightString = GetUnitString( m_aViewSize100mm.Height(), eFieldUnit, cSeparator ); + aViewSizeString = aViewSizeString.replaceAll("$(WIDTH)", aWidthString); + aViewSizeString = aViewSizeString.replaceAll("$(HEIGHT)", aHeightString); + aViewSizeString = aViewSizeString.replaceAll("$(DPI)", OUString::number(aValX)); + m_xFixedText3->set_label(aViewSizeString); + + SvMemoryStream aMemStream; + aMemStream.SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + m_aGraphic.ExportNative(aMemStream); + sal_Int32 aNativeSize = aMemStream.TellEnd(); + + OUString aNativeSizeString = SvxResId(STR_IMAGE_CAPACITY); + aNativeSizeString = aNativeSizeString.replaceAll("$(CAPACITY)", OUString::number(aNativeSize / 1024)); + m_xFixedText5->set_label(aNativeSizeString); + + m_xFixedText6->set_label("??"); +} + +void CompressGraphicsDialog::UpdateNewWidthMF() +{ + int nPixelX = static_cast<sal_Int32>( GetViewWidthInch() * m_dResolution ); + m_xMFNewWidth->set_value(nPixelX); +} + +void CompressGraphicsDialog::UpdateNewHeightMF() +{ + int nPixelY = static_cast<sal_Int32>( GetViewHeightInch() * m_dResolution ); + m_xMFNewHeight->set_value(nPixelY); +} + +void CompressGraphicsDialog::UpdateResolutionLB() +{ + m_xResolutionLB->set_entry_text( OUString::number( static_cast<sal_Int32>(m_dResolution) ) ); +} + +double CompressGraphicsDialog::GetViewWidthInch() const +{ + return static_cast<double>(vcl::ConvertValue(m_aViewSize100mm.Width(), 2, MapUnit::Map100thMM, FieldUnit::INCH)) / 100.0; +} + +double CompressGraphicsDialog::GetViewHeightInch() const +{ + return static_cast<double>(vcl::ConvertValue(m_aViewSize100mm.Height(), 2, MapUnit::Map100thMM, FieldUnit::INCH)) / 100.0; +} + +BmpScaleFlag CompressGraphicsDialog::GetSelectedInterpolationType() const +{ + OUString aSelectionText = m_xInterpolationCombo->get_active_text(); + + if( aSelectionText == "Lanczos" ) { + return BmpScaleFlag::Lanczos; + } else if( aSelectionText == "Bilinear" ) { + return BmpScaleFlag::BiLinear; + } else if( aSelectionText == "Bicubic" ) { + return BmpScaleFlag::BiCubic; + } else if ( aSelectionText == "None" ) { + return BmpScaleFlag::Fast; + } + return BmpScaleFlag::BestQuality; +} + +void CompressGraphicsDialog::Compress(SvStream& aStream) +{ + BitmapEx aBitmap = m_aGraphic.GetBitmapEx(); + if ( m_xReduceResolutionCB->get_active() ) + { + long nPixelX = static_cast<long>( GetViewWidthInch() * m_dResolution ); + long nPixelY = static_cast<long>( GetViewHeightInch() * m_dResolution ); + + aBitmap.Scale( Size( nPixelX, nPixelY ), GetSelectedInterpolationType() ); + } + Graphic aScaledGraphic( aBitmap ); + GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter(); + + Sequence< PropertyValue > aFilterData( 3 ); + aFilterData[ 0 ].Name = "Interlaced"; + aFilterData[ 0 ].Value <<= sal_Int32(0); + aFilterData[ 1 ].Name = "Compression"; + aFilterData[ 1 ].Value <<= static_cast<sal_Int32>(m_xCompressionMF->get_value()); + aFilterData[ 2 ].Name = "Quality"; + aFilterData[ 2 ].Value <<= static_cast<sal_Int32>(m_xQualityMF->get_value()); + + OUString aGraphicFormatName = m_xLosslessRB->get_active() ? OUString( "png" ) : OUString( "jpg" ); + + sal_uInt16 nFilterFormat = rFilter.GetExportFormatNumberForShortName( aGraphicFormatName ); + rFilter.ExportGraphic( aScaledGraphic, "none", aStream, nFilterFormat, &aFilterData ); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, NewWidthModifiedHdl, weld::Entry&, void ) +{ + m_dResolution = m_xMFNewWidth->get_value() / GetViewWidthInch(); + + UpdateNewHeightMF(); + UpdateResolutionLB(); + Update(); +} + +IMPL_LINK( CompressGraphicsDialog, SlideHdl, weld::Scale&, rScale, void ) +{ + if (&rScale == m_xQualitySlider.get()) + m_xQualityMF->set_value(m_xQualitySlider->get_value()); + else + m_xCompressionMF->set_value(m_xCompressionSlider->get_value()); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, NewInterpolationModifiedHdl, weld::ComboBox&, void ) +{ + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, NewQualityModifiedHdl, weld::Entry&, void ) +{ + m_xQualitySlider->set_value(m_xQualityMF->get_value()); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, NewCompressionModifiedHdl, weld::Entry&, void ) +{ + m_xCompressionSlider->set_value(m_xCompressionMF->get_value()); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, NewHeightModifiedHdl, weld::Entry&, void ) +{ + m_dResolution = m_xMFNewHeight->get_value() / GetViewHeightInch(); + + UpdateNewWidthMF(); + UpdateResolutionLB(); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, ResolutionModifiedHdl, weld::ComboBox&, void ) +{ + m_dResolution = static_cast<double>(m_xResolutionLB->get_active_text().toInt32()); + + UpdateNewWidthMF(); + UpdateNewHeightMF(); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, ToggleCompressionRB, weld::ToggleButton&, void ) +{ + bool choice = m_xLosslessRB->get_active(); + m_xCompressionMF->set_sensitive(choice); + m_xCompressionSlider->set_sensitive(choice); + m_xQualityMF->set_sensitive(!choice); + m_xQualitySlider->set_sensitive(!choice); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, ToggleReduceResolutionRB, weld::ToggleButton&, void ) +{ + bool choice = m_xReduceResolutionCB->get_active(); + m_xMFNewWidth->set_sensitive(choice); + m_xMFNewHeight->set_sensitive(choice); + m_xResolutionLB->set_sensitive(choice); + m_xInterpolationCombo->set_sensitive(choice); + Update(); +} + +IMPL_LINK_NOARG( CompressGraphicsDialog, CalculateClickHdl, weld::Button&, void ) +{ + sal_Int32 aSize = 0; + + if ( m_dResolution > 0.0 ) + { + SvMemoryStream aMemStream; + aMemStream.SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + Compress( aMemStream ); + aSize = aMemStream.TellEnd(); + } + + if ( aSize > 0 ) + { + OUString aSizeAsString = OUString::number(aSize / 1024); + + OUString aNewSizeString = SvxResId(STR_IMAGE_CAPACITY); + aNewSizeString = aNewSizeString.replaceAll("$(CAPACITY)", aSizeAsString); + m_xFixedText6->set_label(aNewSizeString); + } +} + +tools::Rectangle CompressGraphicsDialog::GetScaledCropRectangle() const +{ + if ( m_xReduceResolutionCB->get_active() ) + { + long nPixelX = static_cast<long>( GetViewWidthInch() * m_dResolution ); + long nPixelY = static_cast<long>( GetViewHeightInch() * m_dResolution ); + Size aSize = m_aGraphic.GetBitmapEx().GetSizePixel(); + double aScaleX = nPixelX / static_cast<double>(aSize.Width()); + double aScaleY = nPixelY / static_cast<double>(aSize.Height()); + + return tools::Rectangle( + m_aCropRectangle.Left() * aScaleX, + m_aCropRectangle.Top() * aScaleY, + m_aCropRectangle.Right() * aScaleX, + m_aCropRectangle.Bottom()* aScaleY); + } + else + { + return m_aCropRectangle; + } +} + +Graphic CompressGraphicsDialog::GetCompressedGraphic() +{ + if ( m_dResolution > 0.0 ) + { + SvMemoryStream aMemStream; + aMemStream.SetVersion( SOFFICE_FILEFORMAT_CURRENT ); + Compress( aMemStream ); + aMemStream.Seek( STREAM_SEEK_TO_BEGIN ); + Graphic aResultGraphic; + GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter(); + rFilter.ImportGraphic( aResultGraphic, OUString("import"), aMemStream ); + + return aResultGraphic; + } + return Graphic(); +} + +SdrGrafObj* CompressGraphicsDialog::GetCompressedSdrGrafObj() +{ + if ( m_dResolution > 0.0 ) + { + SdrGrafObj* pNewObject(m_xGraphicObj->CloneSdrObject(m_xGraphicObj->getSdrModelFromSdrObject())); + + if ( m_xReduceResolutionCB->get_active() ) + { + tools::Rectangle aScaledCropedRectangle = GetScaledCropRectangle(); + SdrGrafCropItem aNewCrop( + aScaledCropedRectangle.Left(), + aScaledCropedRectangle.Top(), + aScaledCropedRectangle.Right(), + aScaledCropedRectangle.Bottom()); + + pNewObject->SetMergedItem(aNewCrop); + } + pNewObject->SetGraphic( GetCompressedGraphic() ); + + return pNewObject; + } + return nullptr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/connctrl.cxx b/svx/source/dialog/connctrl.cxx new file mode 100644 index 000000000..b3006fe24 --- /dev/null +++ b/svx/source/dialog/connctrl.cxx @@ -0,0 +1,310 @@ +/* -*- 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 <svx/connctrl.hxx> +#include <svx/dlgutil.hxx> + +#include <svx/sdr/contact/displayinfo.hxx> +#include <sdr/contact/objectcontactofobjlistpainter.hxx> +#include <svx/svdmark.hxx> +#include <svx/svdoedge.hxx> +#include <svx/svdpage.hxx> +#include <svx/svdview.hxx> +#include <svx/sxelditm.hxx> + +#include <vcl/settings.hxx> +#include <memory> + +SvxXConnectionPreview::SvxXConnectionPreview() + : pEdgeObj(nullptr) + , pView(nullptr) +{ + SetMapMode(MapMode(MapUnit::Map100thMM)); +} + +void SvxXConnectionPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + weld::CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(118 , 121), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); +} + +SvxXConnectionPreview::~SvxXConnectionPreview() +{ +} + +void SvxXConnectionPreview::Resize() +{ + AdaptSize(); + + Invalidate(); +} + +void SvxXConnectionPreview::AdaptSize() +{ + // Adapt size + if( !pSdrPage ) + return; + + SetMapMode(MapMode(MapUnit::Map100thMM)); + + OutputDevice* pOD = pView->GetFirstOutputDevice(); // GetWin( 0 ); + tools::Rectangle aRect = pSdrPage->GetAllObjBoundRect(); + + MapMode aMapMode = GetMapMode(); + aMapMode.SetMapUnit( pOD->GetMapMode().GetMapUnit() ); + SetMapMode( aMapMode ); + + MapMode aDisplayMap( aMapMode ); + Point aNewPos; + Size aNewSize; + const Size aWinSize = GetDrawingArea()->get_ref_device().PixelToLogic(GetOutputSizePixel(), aDisplayMap); + const long nWidth = aWinSize.Width(); + const long nHeight = aWinSize.Height(); + if (aRect.GetHeight() == 0) + return; + double fRectWH = static_cast<double>(aRect.GetWidth()) / aRect.GetHeight(); + if (nHeight == 0) + return; + double fWinWH = static_cast<double>(nWidth) / nHeight; + + // Adapt bitmap to Thumb size (not here!) + if ( fRectWH < fWinWH) + { + aNewSize.setWidth( static_cast<long>( static_cast<double>(nHeight) * fRectWH ) ); + aNewSize.setHeight( nHeight ); + } + else + { + aNewSize.setWidth( nWidth ); + aNewSize.setHeight( static_cast<long>( static_cast<double>(nWidth) / fRectWH ) ); + } + + Fraction aFrac1( aWinSize.Width(), aRect.GetWidth() ); + Fraction aFrac2( aWinSize.Height(), aRect.GetHeight() ); + Fraction aMinFrac( aFrac1 <= aFrac2 ? aFrac1 : aFrac2 ); + + // Implement MapMode + aDisplayMap.SetScaleX( aMinFrac ); + aDisplayMap.SetScaleY( aMinFrac ); + + // Centering + aNewPos.setX( ( nWidth - aNewSize.Width() ) >> 1 ); + aNewPos.setY( ( nHeight - aNewSize.Height() ) >> 1 ); + + aDisplayMap.SetOrigin(OutputDevice::LogicToLogic(aNewPos, aMapMode, aDisplayMap)); + SetMapMode( aDisplayMap ); + + // Origin + aNewPos = aDisplayMap.GetOrigin(); + aNewPos -= Point( aRect.TopLeft().X(), aRect.TopLeft().Y() ); + aDisplayMap.SetOrigin( aNewPos ); + SetMapMode( aDisplayMap ); + + MouseEvent aMEvt( Point(), 1, MouseEventModifiers::NONE, MOUSE_RIGHT ); + MouseButtonDown( aMEvt ); +} + +void SvxXConnectionPreview::Construct() +{ + DBG_ASSERT( pView, "No valid view is passed on! "); + + const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); + const size_t nMarkCount = rMarkList.GetMarkCount(); + + if( nMarkCount >= 1 ) + { + bool bFound = false; + + for( size_t i = 0; i < nMarkCount && !bFound; ++i ) + { + const SdrObject* pObj = rMarkList.GetMark( i )->GetMarkedSdrObj(); + SdrInventor nInv = pObj->GetObjInventor(); + sal_uInt16 nId = pObj->GetObjIdentifier(); + if( nInv == SdrInventor::Default && nId == OBJ_EDGE ) + { + bFound = true; + + // potential memory leak here (!). Create SdrObjList only when there is + // not yet one. + if(!pSdrPage) + { + pSdrPage.reset( new SdrPage( + pView->getSdrModelFromSdrView(), + false) ); + } + + const SdrEdgeObj* pTmpEdgeObj = static_cast<const SdrEdgeObj*>(pObj); + pEdgeObj = pTmpEdgeObj->CloneSdrObject(pSdrPage->getSdrModelFromSdrPage()); + + SdrObjConnection& rConn1 = pEdgeObj->GetConnection( true ); + SdrObjConnection& rConn2 = pEdgeObj->GetConnection( false ); + + rConn1 = pTmpEdgeObj->GetConnection( true ); + rConn2 = pTmpEdgeObj->GetConnection( false ); + + SdrObject* pTmpObj1 = pTmpEdgeObj->GetConnectedNode( true ); + SdrObject* pTmpObj2 = pTmpEdgeObj->GetConnectedNode( false ); + + if( pTmpObj1 ) + { + SdrObject* pObj1 = pTmpObj1->CloneSdrObject(pSdrPage->getSdrModelFromSdrPage()); + pSdrPage->InsertObject( pObj1 ); + pEdgeObj->ConnectToNode( true, pObj1 ); + } + + if( pTmpObj2 ) + { + SdrObject* pObj2 = pTmpObj2->CloneSdrObject(pSdrPage->getSdrModelFromSdrPage()); + pSdrPage->InsertObject( pObj2 ); + pEdgeObj->ConnectToNode( false, pObj2 ); + } + + pSdrPage->InsertObject( pEdgeObj ); + } + } + } + + if( !pEdgeObj ) + { + pEdgeObj = new SdrEdgeObj(pView->getSdrModelFromSdrView()); + } + + AdaptSize(); +} + +void SvxXConnectionPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.Push(PushFlags::ALL); + + rRenderContext.SetMapMode(GetMapMode()); + + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + rRenderContext.SetDrawMode(rStyles.GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR); + rRenderContext.SetBackground(Wallpaper(rStyles.GetFieldColor())); + + if (pSdrPage) + { + // This will not work anymore. To not start at Adam and Eve, i will + // ATM not try to change all this stuff to really using an own model + // and a view. I will just try to provide a mechanism to paint such + // objects without own model and without a page/view with the new + // mechanism. + + // New stuff: Use an ObjectContactOfObjListPainter. + sdr::contact::SdrObjectVector aObjectVector; + + for (size_t a = 0; a < pSdrPage->GetObjCount(); ++a) + { + SdrObject* pObject = pSdrPage->GetObj(a); + DBG_ASSERT(pObject, + "SvxXConnectionPreview::Paint: Corrupt ObjectList (!)"); + aObjectVector.push_back(pObject); + } + + sdr::contact::ObjectContactOfObjListPainter aPainter(rRenderContext, aObjectVector, nullptr); + sdr::contact::DisplayInfo aDisplayInfo; + + // do processing + aPainter.ProcessDisplay(aDisplayInfo); + } + + rRenderContext.Pop(); +} + +void SvxXConnectionPreview::SetAttributes( const SfxItemSet& rInAttrs ) +{ + pEdgeObj->SetMergedItemSetAndBroadcast(rInAttrs); + + Invalidate(); +} + +// Get number of lines which are offset based on the preview object + +sal_uInt16 SvxXConnectionPreview::GetLineDeltaCount() const +{ + const SfxItemSet& rSet = pEdgeObj->GetMergedItemSet(); + sal_uInt16 nCount(0); + + if(SfxItemState::DONTCARE != rSet.GetItemState(SDRATTR_EDGELINEDELTACOUNT)) + nCount = rSet.Get(SDRATTR_EDGELINEDELTACOUNT).GetValue(); + + return nCount; +} + +bool SvxXConnectionPreview::MouseButtonDown( const MouseEvent& rMEvt ) +{ + bool bZoomIn = rMEvt.IsLeft() && !rMEvt.IsShift(); + bool bZoomOut = rMEvt.IsRight() || rMEvt.IsShift(); + bool bCtrl = rMEvt.IsMod1(); + + if( bZoomIn || bZoomOut ) + { + MapMode aMapMode = GetMapMode(); + Fraction aXFrac = aMapMode.GetScaleX(); + Fraction aYFrac = aMapMode.GetScaleY(); + std::unique_ptr<Fraction> pMultFrac; + + if( bZoomIn ) + { + if( bCtrl ) + pMultFrac.reset(new Fraction( 3, 2 )); + else + pMultFrac.reset(new Fraction( 11, 10 )); + } + else + { + if( bCtrl ) + pMultFrac.reset(new Fraction( 2, 3 )); + else + pMultFrac.reset(new Fraction( 10, 11 )); + } + + aXFrac *= *pMultFrac; + aYFrac *= *pMultFrac; + if( static_cast<double>(aXFrac) > 0.001 && static_cast<double>(aXFrac) < 1000.0 && + static_cast<double>(aYFrac) > 0.001 && static_cast<double>(aYFrac) < 1000.0 ) + { + aMapMode.SetScaleX( aXFrac ); + aMapMode.SetScaleY( aYFrac ); + SetMapMode( aMapMode ); + + Size aOutSize(GetOutputSizePixel()); + aOutSize = GetDrawingArea()->get_ref_device().PixelToLogic(aOutSize); + + Point aPt( aMapMode.GetOrigin() ); + long nX = static_cast<long>( ( static_cast<double>(aOutSize.Width()) - ( static_cast<double>(aOutSize.Width()) * static_cast<double>(*pMultFrac) ) ) / 2.0 + 0.5 ); + long nY = static_cast<long>( ( static_cast<double>(aOutSize.Height()) - ( static_cast<double>(aOutSize.Height()) * static_cast<double>(*pMultFrac) ) ) / 2.0 + 0.5 ); + aPt.AdjustX(nX ); + aPt.AdjustY(nY ); + + aMapMode.SetOrigin( aPt ); + SetMapMode( aMapMode ); + + Invalidate(); + } + } + + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/contimp.hxx b/svx/source/dialog/contimp.hxx new file mode 100644 index 000000000..c8b59cb72 --- /dev/null +++ b/svx/source/dialog/contimp.hxx @@ -0,0 +1,132 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_DIALOG_CONTIMP_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_CONTIMP_HXX + +#include <sfx2/ctrlitem.hxx> +#include "contwnd.hxx" +#include <vcl/idle.hxx> + +class SvxSuperContourDlg; + +class SvxContourDlgItem : public SfxControllerItem +{ + SvxSuperContourDlg& rDlg; + +protected: + + virtual void StateChanged( sal_uInt16 nSID, SfxItemState eState, const SfxPoolItem* pState ) override; + +public: + + SvxContourDlgItem( SvxSuperContourDlg& rDlg, SfxBindings& rBindings ); +}; + +class ContourWindow; + +class StatusColor : public weld::CustomWidgetController +{ +private: + ContourWindow& m_rWnd; +public: + StatusColor(ContourWindow& rWnd) + : m_rWnd(rWnd) + { + } + virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; + virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override + { + weld::CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aSize(pDrawingArea->get_approximate_digit_width() * 3, + pDrawingArea->get_text_height()); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + } +}; + +class SvxSuperContourDlg +{ + Graphic aGraphic; + Graphic aUndoGraphic; + Graphic aRedoGraphic; + Graphic aUpdateGraphic; + tools::PolyPolygon aUpdatePolyPoly; + Idle aUpdateIdle; + Idle aCreateIdle; + SfxBindings* mpBindings; + void* pUpdateEditingObject; + void* pCheckObj; + SvxContourDlgItem aContourItem; + sal_Int32 mnGrfChanged; + bool bExecState; + bool bUpdateGraphicLinked; + bool bGraphicLinked; + + weld::Dialog& m_rDialog; + std::unique_ptr<ContourWindow> m_xContourWnd; + std::unique_ptr<StatusColor> m_xStbStatusColor; + std::unique_ptr<weld::Toolbar> m_xTbx1; + std::unique_ptr<weld::MetricSpinButton> m_xMtfTolerance; + std::unique_ptr<weld::Label> m_xStbStatus2; + std::unique_ptr<weld::Label> m_xStbStatus3; + std::unique_ptr<weld::Button> m_xCancelBtn; + std::unique_ptr<weld::CustomWeld> m_xStbStatusColorWeld; + std::unique_ptr<weld::CustomWeld> m_xContourWndWeld; + + DECL_LINK( Tbx1ClickHdl, const OString&, void ); + DECL_LINK( MousePosHdl, GraphCtrl*, void ); + DECL_LINK( GraphSizeHdl, GraphCtrl*, void ); + DECL_LINK( UpdateHdl, Timer *, void ); + DECL_LINK( CreateHdl, Timer *, void ); + DECL_LINK( StateHdl, GraphCtrl*, void ); + DECL_LINK( PipetteHdl, ContourWindow&, void ); + DECL_LINK( PipetteClickHdl, ContourWindow&, void ); + DECL_LINK( WorkplaceClickHdl, ContourWindow&, void ); + DECL_LINK( CancelHdl, weld::Button&, void ); + + void SetActiveTool(const OString& rId); + void SetActivePoly(const OString& rId); + + SfxBindings& GetBindings() { return *mpBindings; } + +public: + + SvxSuperContourDlg(weld::Builder& rBuilder, weld::Dialog& rDialog, SfxBindings* pBindings); + ~SvxSuperContourDlg(); + + void SetExecState( bool bEnable ); + + void SetGraphic( const Graphic& rGraphic ); + const Graphic& GetGraphic() const { return aGraphic; } + bool IsGraphicChanged() const { return mnGrfChanged > 0; } + + void SetPolyPolygon( const tools::PolyPolygon& rPolyPoly ); + tools::PolyPolygon GetPolyPolygon(); + + const void* GetEditingObject() const { return pCheckObj; } + + void UpdateGraphic( const Graphic& rGraphic, bool bGraphicLinked, + const tools::PolyPolygon* pPolyPoly, + void* pEditingObj ); +}; + + +#endif // INCLUDED_SVX_SOURCE_DIALOG_CONTIMP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/contwnd.cxx b/svx/source/dialog/contwnd.cxx new file mode 100644 index 000000000..593b459c5 --- /dev/null +++ b/svx/source/dialog/contwnd.cxx @@ -0,0 +1,271 @@ +/* -*- 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 "contwnd.hxx" +#include <svx/svdpage.hxx> +#include <svx/svdopath.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xfltrit.hxx> +#include <svx/xflclit.hxx> +#include <basegfx/polygon/b2dpolypolygontools.hxx> +#include <svx/sdrpaintwindow.hxx> +#include <vcl/ptrstyle.hxx> + +using namespace css; + +#define TRANSCOL COL_WHITE + +ContourWindow::ContourWindow(weld::Dialog* pDialog) + : GraphCtrl(pDialog) + , aWorkRect(0, 0, 0, 0) + , bPipetteMode(false) + , bWorkplaceMode(false) + , bClickValid(false) +{ +} + +void ContourWindow::SetPolyPolygon(const tools::PolyPolygon& rPolyPoly) +{ + SdrPage* pPage = pModel->GetPage(0); + const sal_uInt16 nPolyCount = rPolyPoly.Count(); + + // First delete all drawing objects + aPolyPoly = rPolyPoly; + + // To avoid to have destroyed objects which are still selected, it is necessary to deselect + // them first (!) + pView->UnmarkAllObj(); + + // clear SdrObjects with broadcasting + pPage->ClearSdrObjList(); + + for (sal_uInt16 i = 0; i < nPolyCount; i++) + { + basegfx::B2DPolyPolygon aPolyPolygon; + aPolyPolygon.append(aPolyPoly[ i ].getB2DPolygon()); + SdrPathObj* pPathObj = new SdrPathObj( + *pModel, + OBJ_PATHFILL, + aPolyPolygon); + + SfxItemSet aSet(pModel->GetItemPool()); + + aSet.Put(XFillStyleItem(drawing::FillStyle_SOLID)); + aSet.Put(XFillColorItem("", TRANSCOL)); + aSet.Put(XFillTransparenceItem(50) ); + + pPathObj->SetMergedItemSetAndBroadcast(aSet); + + pPage->InsertObject( pPathObj ); + } + + if (nPolyCount) + { + pView->MarkAll(); + pView->CombineMarkedObjects(false); + } + + pModel->SetChanged(false); +} + +const tools::PolyPolygon& ContourWindow::GetPolyPolygon() +{ + if ( pModel->IsChanged() ) + { + SdrPage* pPage = pModel->GetPage( 0 ); + + aPolyPoly = tools::PolyPolygon(); + + if ( pPage && pPage->GetObjCount() ) + { + SdrPathObj* pPathObj = static_cast<SdrPathObj*>(pPage->GetObj(0)); + // Not sure if subdivision is needed for ContourWindow, but maybe it cannot handle + // curves at all. Keeping subdivision here for security + const basegfx::B2DPolyPolygon aB2DPolyPolygon(basegfx::utils::adaptiveSubdivideByAngle(pPathObj->GetPathPoly())); + aPolyPoly = tools::PolyPolygon(aB2DPolyPolygon); + } + + pModel->SetChanged( false ); + } + + return aPolyPoly; +} + +void ContourWindow::InitSdrModel() +{ + GraphCtrl::InitSdrModel(); + + SfxItemSet aSet( pModel->GetItemPool() ); + + aSet.Put( XFillColorItem( "", TRANSCOL ) ); + aSet.Put( XFillTransparenceItem( 50 ) ); + pView->SetAttributes( aSet ); + pView->SetFrameDragSingles(); +} + +void ContourWindow::SdrObjCreated( const SdrObject& ) +{ + pView->MarkAll(); + pView->CombineMarkedObjects( false ); +} + +bool ContourWindow::IsContourChanged() const +{ + SdrPage* pPage = pModel->GetPage( 0 ); + bool bRet = false; + + if ( pPage && pPage->GetObjCount() ) + bRet = static_cast<SdrPathObj*>( pPage->GetObj( 0 ) )->GetPathPoly().count() && pModel->IsChanged(); + + return bRet; +} + +bool ContourWindow::MouseButtonDown( const MouseEvent& rMEvt ) +{ + if ( bWorkplaceMode ) + { + const Point aLogPt(GetDrawingArea()->get_ref_device().PixelToLogic(rMEvt.GetPosPixel())); + + SetPolyPolygon( tools::PolyPolygon() ); + aWorkRect = tools::Rectangle( aLogPt, aLogPt ); + Invalidate(tools::Rectangle(Point(), GetGraphicSize())); + SetEditMode( true ); + } + + if (!bPipetteMode) + return GraphCtrl::MouseButtonDown( rMEvt ); + + return true; +} + +bool ContourWindow::MouseMove( const MouseEvent& rMEvt ) +{ + bClickValid = false; + + if ( bPipetteMode ) + { + const Point aLogPt( GetDrawingArea()->get_ref_device().PixelToLogic( rMEvt.GetPosPixel() ) ); + + aPipetteColor = GetDrawingArea()->get_ref_device().GetPixel( aLogPt ); + weld::CustomWidgetController::MouseMove( rMEvt ); + + if ( aPipetteLink.IsSet() && tools::Rectangle( Point(), GetGraphicSize() ).IsInside( aLogPt ) ) + { + SetPointer( PointerStyle::RefHand ); + aPipetteLink.Call( *this ); + } + + return true; + } + + return GraphCtrl::MouseMove( rMEvt ); +} + +bool ContourWindow::MouseButtonUp(const MouseEvent& rMEvt) +{ + const tools::Rectangle aGraphRect( Point(), GetGraphicSize() ); + const Point aLogPt( GetDrawingArea()->get_ref_device().PixelToLogic( rMEvt.GetPosPixel() ) ); + + bClickValid = aGraphRect.IsInside( aLogPt ); + ReleaseMouse(); + + if ( bPipetteMode ) + { + weld::CustomWidgetController::MouseButtonUp( rMEvt ); + + aPipetteClickLink.Call( *this ); + + return true; + } + else if ( bWorkplaceMode ) + { + GraphCtrl::MouseButtonUp( rMEvt ); + + aWorkRect.SetRight( aLogPt.X() ); + aWorkRect.SetBottom( aLogPt.Y() ); + aWorkRect.Intersection( aGraphRect ); + aWorkRect.Justify(); + + if ( aWorkRect.Left() != aWorkRect.Right() && aWorkRect.Top() != aWorkRect.Bottom() ) + { + tools::PolyPolygon _aPolyPoly( GetPolyPolygon() ); + + _aPolyPoly.Clip( aWorkRect ); + SetPolyPolygon( _aPolyPoly ); + pView->SetWorkArea( aWorkRect ); + } + else + pView->SetWorkArea( aGraphRect ); + + Invalidate( aGraphRect ); + + aWorkplaceClickLink.Call( *this ); + + return false; + } + + return GraphCtrl::MouseButtonUp( rMEvt ); +} + +void ContourWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) +{ + // #i75482# + // encapsulate the redraw using Begin/End and use the returned + // data to get the target output device (e.g. when pre-rendering) + SdrPaintWindow* pPaintWindow = pView->BeginCompleteRedraw(&rRenderContext); + pPaintWindow->SetOutputToWindow(true); + OutputDevice& rTarget = pPaintWindow->GetTargetOutputDevice(); + + const Graphic& rGraphic = GetGraphic(); + rTarget.Push(PushFlags::LINECOLOR |PushFlags::FILLCOLOR); + rTarget.SetLineColor(COL_BLACK); + rTarget.SetFillColor(COL_WHITE); + rTarget.DrawRect( tools::Rectangle( Point(), GetGraphicSize() ) ); + rTarget.Pop(); + + if (rGraphic.GetType() != GraphicType::NONE) + rGraphic.Draw(&rTarget, Point(), GetGraphicSize()); + + if (aWorkRect.Left() != aWorkRect.Right() && aWorkRect.Top() != aWorkRect.Bottom()) + { + tools::PolyPolygon _aPolyPoly(2); + rTarget.Push(PushFlags::FILLCOLOR); + _aPolyPoly.Insert(tools::Rectangle(Point(), GetGraphicSize())); + _aPolyPoly.Insert(aWorkRect); + rTarget.SetFillColor(COL_LIGHTRED); + rTarget.DrawTransparent(_aPolyPoly, 50); + rTarget.Pop(); + } + + // #i75482# + const vcl::Region aRepaintRegion(rRect); + pView->DoCompleteRedraw(*pPaintWindow, aRepaintRegion); + pView->EndCompleteRedraw(*pPaintWindow, true); +} + +void ContourWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + GraphCtrl::SetDrawingArea(pDrawingArea); + Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(270, 170), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + SetSdrMode(true); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/contwnd.hxx b/svx/source/dialog/contwnd.hxx new file mode 100644 index 000000000..1bad623c0 --- /dev/null +++ b/svx/source/dialog/contwnd.hxx @@ -0,0 +1,70 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_DIALOG_CONTWND_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_CONTWND_HXX + +#include <tools/poly.hxx> +#include <svx/graphctl.hxx> + +class ContourWindow final : public GraphCtrl +{ + tools::PolyPolygon aPolyPoly; + Color aPipetteColor; + tools::Rectangle aWorkRect; + Link<ContourWindow&,void> aPipetteLink; + Link<ContourWindow&,void> aPipetteClickLink; + Link<ContourWindow&,void> aWorkplaceClickLink; + bool bPipetteMode; + bool bWorkplaceMode; + bool bClickValid; + + virtual bool MouseButtonDown(const MouseEvent& rMEvt) override; + virtual bool MouseMove(const MouseEvent& rMEvt) override; + virtual bool MouseButtonUp(const MouseEvent& rMEvt) override; + virtual void SdrObjCreated( const SdrObject& rObj ) override; + virtual void InitSdrModel() override; + virtual void Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect ) override; + virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override; + +public: + + ContourWindow(weld::Dialog* pDialog); + + void SetPolyPolygon( const tools::PolyPolygon& rPolyPoly ); + const tools::PolyPolygon& GetPolyPolygon(); + + void SetPipetteMode( const bool bPipette ) { bPipetteMode = bPipette; } + const Color& GetPipetteColor() const { return aPipetteColor; } + + bool IsClickValid() const { return bClickValid; } + bool IsContourChanged() const; + + void SetWorkplaceMode( const bool bWorkplace ) { bWorkplaceMode = bWorkplace; } + const tools::Rectangle& GetWorkRect() const { return aWorkRect; } + + void SetPipetteHdl( const Link<ContourWindow&,void>& rLink ) { aPipetteLink = rLink; } + void SetPipetteClickHdl( const Link<ContourWindow&,void>& rLink ) { aPipetteClickLink = rLink; } + void SetWorkplaceClickHdl( const Link<ContourWindow&,void>& rLink ) { aWorkplaceClickLink = rLink; } +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/crashreportdlg.cxx b/svx/source/dialog/crashreportdlg.cxx new file mode 100644 index 000000000..0f56078b5 --- /dev/null +++ b/svx/source/dialog/crashreportdlg.cxx @@ -0,0 +1,105 @@ +/* -*- 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/. + */ + +#include "crashreportdlg.hxx" + + +#include <desktop/crashreport.hxx> +#include <sfx2/safemode.hxx> +#include <comphelper/processfactory.hxx> + +#include <com/sun/star/task/OfficeRestartManager.hpp> +#include <com/sun/star/task/XInteractionHandler.hpp> + +CrashReportDialog::CrashReportDialog(weld::Window* pParent) + : GenericDialogController(pParent, "svx/ui/crashreportdlg.ui", + "CrashReportDialog") + , mxBtnSend(m_xBuilder->weld_button("btn_send")) + , mxBtnCancel(m_xBuilder->weld_button("btn_cancel")) + , mxBtnClose(m_xBuilder->weld_button("btn_close")) + , mxEditPreUpload(m_xBuilder->weld_label("ed_pre")) + , mxEditPostUpload(m_xBuilder->weld_text_view("ed_post")) + , mxFtBugReport(m_xBuilder->weld_text_view("ed_bugreport")) + , mxCBSafeMode(m_xBuilder->weld_check_button("check_safemode")) +{ + maSuccessMsg = mxEditPostUpload->get_text(); + + auto nWidth = mxEditPreUpload->get_preferred_size().Width(); + nWidth = std::max(nWidth, mxCBSafeMode->get_size_request().Width()); + mxEditPreUpload->set_size_request(nWidth, -1); + mxCBSafeMode->set_size_request(nWidth, -1); + + mxBtnSend->connect_clicked(LINK(this, CrashReportDialog, BtnHdl)); + mxBtnCancel->connect_clicked(LINK(this, CrashReportDialog, BtnHdl)); + mxBtnClose->connect_clicked(LINK(this, CrashReportDialog, BtnHdl)); +} + +CrashReportDialog::~CrashReportDialog() +{ +} + +short CrashReportDialog::run() +{ + short nRet = GenericDialogController::run(); + + // Check whether to go to safe mode + if (mxCBSafeMode->get_active()) + { + sfx2::SafeMode::putFlag(); + css::task::OfficeRestartManager::get(comphelper::getProcessComponentContext())->requestRestart( + css::uno::Reference< css::task::XInteractionHandler >()); + } + return nRet; +} + +IMPL_LINK(CrashReportDialog, BtnHdl, weld::Button&, rBtn, void) +{ + if (&rBtn == mxBtnSend.get()) + { + std::string response; + bool bSuccess = CrashReporter::readSendConfig(response); + + OUString aCrashID = OUString::createFromAscii(response.c_str()); + + if (bSuccess) + { + OUString aProcessedMessage = maSuccessMsg.replaceAll("%CRASHID", aCrashID.replaceAll("Crash-ID=","")); + + // vclbuilder seems to replace _ with ~ even in text + mxEditPostUpload->set_text(aProcessedMessage.replaceAll("~", "_")); + } + else + { + mxEditPostUpload->set_text(aCrashID); + } + + mxBtnClose->show(); + mxFtBugReport->show(); + mxEditPostUpload->show(); + mxBtnSend->set_sensitive(false); + mxBtnCancel->set_sensitive(false); + mxBtnClose->grab_focus(); + + mxEditPreUpload->hide(); + mxBtnSend->hide(); + mxBtnCancel->hide(); + + m_xDialog->resize_to_request(); + } + else if (&rBtn == mxBtnCancel.get()) + { + m_xDialog->response(RET_CLOSE); + } + else if (&rBtn == mxBtnClose.get()) + { + m_xDialog->response(RET_CLOSE); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/crashreportdlg.hxx b/svx/source/dialog/crashreportdlg.hxx new file mode 100644 index 000000000..f913cabac --- /dev/null +++ b/svx/source/dialog/crashreportdlg.hxx @@ -0,0 +1,38 @@ +/* -*- 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/. + */ + +#ifndef INCLUDED_SVX_SOURCE_DIALOG_CRASHREPORTDLG_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_CRASHREPORTDLG_HXX + +#include <vcl/weld.hxx> + +class CrashReportDialog : public weld::GenericDialogController +{ +public: + explicit CrashReportDialog(weld::Window* pParent); + virtual short run() override; + virtual ~CrashReportDialog() override; + +private: + std::unique_ptr<weld::Button> mxBtnSend; + std::unique_ptr<weld::Button> mxBtnCancel; + std::unique_ptr<weld::Button> mxBtnClose; + std::unique_ptr<weld::Label> mxEditPreUpload; + std::unique_ptr<weld::TextView> mxEditPostUpload; + std::unique_ptr<weld::TextView> mxFtBugReport; + std::unique_ptr<weld::CheckButton> mxCBSafeMode; + + OUString maSuccessMsg; + + DECL_LINK(BtnHdl, weld::Button&, void); +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/crashreportui.cxx b/svx/source/dialog/crashreportui.cxx new file mode 100644 index 000000000..5384e3c18 --- /dev/null +++ b/svx/source/dialog/crashreportui.cxx @@ -0,0 +1,81 @@ +/* -*- 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/. + */ + +#include <cppuhelper/implbase.hxx> +#include <com/sun/star/frame/XSynchronousDispatch.hpp> +#include <com/sun/star/lang/XServiceInfo.hpp> + +#include <cppuhelper/supportsservice.hxx> + +#include <vcl/svapp.hxx> + +#include "crashreportdlg.hxx" + +namespace { + +class CrashReportUI : public ::cppu::WeakImplHelper< css::lang::XServiceInfo , + css::frame::XSynchronousDispatch > // => XDispatch! +{ +public: + explicit CrashReportUI(); + + // css.lang.XServiceInfo + + virtual OUString SAL_CALL getImplementationName() override; + + virtual sal_Bool SAL_CALL supportsService(const OUString& sServiceName) override; + + virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override; + + + virtual css::uno::Any SAL_CALL dispatchWithReturnValue(const css::util::URL& aURL, + const css::uno::Sequence< css::beans::PropertyValue >& lArguments ) override; +}; + +CrashReportUI::CrashReportUI() +{ + +} + +OUString SAL_CALL CrashReportUI::getImplementationName() +{ + return "com.sun.star.comp.svx.CrashReportUI"; +} + +sal_Bool SAL_CALL CrashReportUI::supportsService(const OUString& sServiceName) +{ + return cppu::supportsService(this, sServiceName); +} + +css::uno::Sequence< OUString > SAL_CALL CrashReportUI::getSupportedServiceNames() +{ + return { "com.sun.star.dialog.CrashReportUI" }; +} + +css::uno::Any SAL_CALL CrashReportUI::dispatchWithReturnValue(const css::util::URL&, + const css::uno::Sequence< css::beans::PropertyValue >& ) +{ + SolarMutexGuard aGuard; + css::uno::Any aRet; + CrashReportDialog aDialog(nullptr); + aDialog.run(); + return aRet; +} + +} + +extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface * +com_sun_star_comp_svx_CrashReportUI_get_implementation( + css::uno::XComponentContext * /*context*/, + css::uno::Sequence<css::uno::Any> const &) +{ + return cppu::acquire(new CrashReportUI()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/ctredlin.cxx b/svx/source/dialog/ctredlin.cxx new file mode 100644 index 000000000..3116ec7ec --- /dev/null +++ b/svx/source/dialog/ctredlin.cxx @@ -0,0 +1,1023 @@ +/* -*- 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 <comphelper/processfactory.hxx> +#include <comphelper/string.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <svtools/ctrlbox.hxx> +#include <unotools/textsearch.hxx> + +#include <svx/ctredlin.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> + +#define WRITER_DATE 2 +#define CALC_DATE 3 + +RedlinData::RedlinData() + : aDateTime(DateTime::EMPTY) + , pData(nullptr) + , eType(RedlineType::Any) + , bDisabled(false) +{ +} + +RedlinData::~RedlinData() +{ +} + +SvxRedlinTable::SvxRedlinTable(std::unique_ptr<weld::TreeView> xWriterControl, + std::unique_ptr<weld::TreeView> xCalcControl) + : xSorter(new comphelper::string::NaturalStringSorter(::comphelper::getProcessComponentContext(), + Application::GetSettings().GetUILanguageTag().getLocale())) + , xWriterTreeView(std::move(xWriterControl)) + , xCalcTreeView(std::move(xCalcControl)) + , pTreeView(nullptr) + , nDatePos(WRITER_DATE) + , bAuthor(false) + , bDate(false) + , bComment(false) + , bSorted(false) + , nDaTiMode(SvxRedlinDateMode::BEFORE) + , aDaTiFirst( DateTime::EMPTY ) + , aDaTiLast( DateTime::EMPTY ) + , aDaTiFilterFirst( DateTime::EMPTY ) + , aDaTiFilterLast( DateTime::EMPTY ) +{ + if (xWriterTreeView) + { + xWriterTreeView->connect_column_clicked(LINK(this, SvxRedlinTable, HeaderBarClick)); + xWriterTreeView->set_sort_func([this](const weld::TreeIter& rLeft, const weld::TreeIter& rRight){ + return ColCompare(rLeft, rRight); + }); + pTreeView = xWriterTreeView.get(); + } + if (xCalcTreeView) + { + xCalcTreeView->connect_column_clicked(LINK(this, SvxRedlinTable, HeaderBarClick)); + xCalcTreeView->set_sort_func([this](const weld::TreeIter& rLeft, const weld::TreeIter& rRight){ + return ColCompare(rLeft, rRight); + }); + pTreeView = xCalcTreeView.get(); + } +} + +void SvxRedlinTable::set_size_request(int nWidth, int nHeight) +{ + if (xWriterTreeView) + xWriterTreeView->set_size_request(nWidth, nHeight); + if (xCalcTreeView) + xCalcTreeView->set_size_request(nWidth, nHeight); +} + +SvxRedlinTable::~SvxRedlinTable() +{ +} + +IMPL_LINK(SvxRedlinTable, HeaderBarClick, int, nColumn, void) +{ + if (!bSorted) + { + pTreeView->make_sorted(); + bSorted = true; + } + + bool bSortAtoZ = pTreeView->get_sort_order(); + + //set new arrow positions in headerbar + if (nColumn == pTreeView->get_sort_column()) + { + bSortAtoZ = !bSortAtoZ; + pTreeView->set_sort_order(bSortAtoZ); + } + else + { + int nOldSortColumn = pTreeView->get_sort_column(); + if (nOldSortColumn != -1) + pTreeView->set_sort_indicator(TRISTATE_INDET, nOldSortColumn); + pTreeView->set_sort_column(nColumn); + } + + if (nColumn != -1) + { + //sort lists + pTreeView->set_sort_indicator(bSortAtoZ ? TRISTATE_TRUE : TRISTATE_FALSE, nColumn); + } +} + +int SvxRedlinTable::ColCompare(const weld::TreeIter& rLeft, const weld::TreeIter& rRight) +{ + sal_Int32 nCompare = 0; + + int nSortCol = pTreeView->get_sort_column(); + + if (pTreeView == xWriterTreeView.get() && nSortCol == 0) + { + RedlinData *pLeftData = reinterpret_cast<RedlinData*>(pTreeView->get_id(rLeft).toInt64()); + RedlinData *pRightData = reinterpret_cast<RedlinData*>(pTreeView->get_id(rRight).toInt64()); + + if (pLeftData && pRightData) + { + if (pLeftData->eType < pRightData->eType) + nCompare = -1; + else if (pLeftData->eType > pRightData->eType) + nCompare = 1; + return nCompare; + } + } + + if (nSortCol == nDatePos) + { + RedlinData *pLeftData = reinterpret_cast<RedlinData*>(pTreeView->get_id(rLeft).toInt64()); + RedlinData *pRightData = reinterpret_cast<RedlinData*>(pTreeView->get_id(rRight).toInt64()); + + if (pLeftData && pRightData) + { + if (pLeftData->aDateTime < pRightData->aDateTime) + nCompare = -1; + else if (pLeftData->aDateTime > pRightData->aDateTime) + nCompare = 1; + return nCompare; + } + } + + return xSorter->compare(pTreeView->get_text(rLeft, nSortCol), + pTreeView->get_text(rRight, nSortCol)); +} + +void SvxRedlinTable::UpdateFilterTest() +{ + Date aDateMax( Date::SYSTEM ); + aDateMax.AddYears(100); + Date aDateMin(1,1,1989); + tools::Time aTMin(0); + tools::Time aTMax(23,59,59); + + DateTime aDTMin(aDateMin); + DateTime aDTMax(aDateMax); + + switch(nDaTiMode) + { + case SvxRedlinDateMode::BEFORE: + aDaTiFilterFirst=aDTMin; + aDaTiFilterLast=aDaTiFirst; + break; + case SvxRedlinDateMode::SAVE: + case SvxRedlinDateMode::SINCE: + aDaTiFilterFirst=aDaTiFirst; + aDaTiFilterLast=aDTMax; + break; + case SvxRedlinDateMode::EQUAL: + aDaTiFilterFirst=aDaTiFirst; + aDaTiFilterLast=aDaTiFirst; + aDaTiFilterFirst.SetTime(aTMin.GetTime()); + aDaTiFilterLast.SetTime(aTMax.GetTime()); + break; + case SvxRedlinDateMode::NOTEQUAL: + aDaTiFilterFirst=aDaTiFirst; + aDaTiFilterLast=aDaTiFirst; + aDaTiFilterFirst.SetTime(aTMin.GetTime()); + aDaTiFilterLast.SetTime(aTMax.GetTime()); + break; + case SvxRedlinDateMode::BETWEEN: + aDaTiFilterFirst=aDaTiFirst; + aDaTiFilterLast=aDaTiLast; + break; + case SvxRedlinDateMode::NONE: + break; + } +} + +void SvxRedlinTable::SetFilterDate(bool bFlag) +{ + bDate=bFlag; +} + +void SvxRedlinTable::SetDateTimeMode(SvxRedlinDateMode nMode) +{ + nDaTiMode=nMode; +} + +void SvxRedlinTable::SetFirstDate(const Date& aDate) +{ + aDaTiFirst.SetDate(aDate.GetDate()); +} + +void SvxRedlinTable::SetLastDate(const Date& aDate) +{ + aDaTiLast.SetDate(aDate.GetDate()); +} + +void SvxRedlinTable::SetFirstTime(const tools::Time& aTime) +{ + aDaTiFirst.SetTime(aTime.GetTime()); +} + +void SvxRedlinTable::SetLastTime(const tools::Time& aTime) +{ + aDaTiLast.SetTime(aTime.GetTime()); +} + +void SvxRedlinTable::SetFilterAuthor(bool bFlag) +{ + bAuthor=bFlag; +} + +void SvxRedlinTable::SetAuthor(const OUString &aString) +{ + aAuthor=aString; +} + +void SvxRedlinTable::SetFilterComment(bool bFlag) +{ + bComment=bFlag; +} + +void SvxRedlinTable::SetCommentParams( const utl::SearchParam* pSearchPara ) +{ + if(pSearchPara!=nullptr) + { + pCommentSearcher.reset(new utl::TextSearch(*pSearchPara, LANGUAGE_SYSTEM )); + } +} + +bool SvxRedlinTable::IsValidEntry(const OUString &rAuthorStr, + const DateTime &rDateTime, + const OUString &rCommentStr) +{ + return IsValidEntry(rAuthorStr, rDateTime) && IsValidComment(rCommentStr); +} + +bool SvxRedlinTable::IsValidEntry(const OUString &rAuthorStr, const DateTime &rDateTime) +{ + if (bAuthor && aAuthor!=rAuthorStr) + return false; + + if (!bDate) + return true; + + const bool bRes = rDateTime.IsBetween(aDaTiFilterFirst, aDaTiFilterLast); + return nDaTiMode!=SvxRedlinDateMode::NOTEQUAL ? bRes : !bRes; +} + +bool SvxRedlinTable::IsValidComment(const OUString &rCommentStr) +{ + if (!bComment) + return true; + + sal_Int32 nStartPos = 0; + sal_Int32 nEndPos = rCommentStr.getLength(); + return pCommentSearcher->SearchForward( rCommentStr, &nStartPos, &nEndPos); +} + +SvxTPage::~SvxTPage() +{ +} + +void SvxTPage::ActivatePage() +{ +} + +SvxTPView::SvxTPView(weld::Container* pParent, weld::Window* pDialog, weld::Builder* pTopLevel) + : SvxTPage(pParent, "svx/ui/redlineviewpage.ui", "RedlineViewPage") + , bEnableAccept(true) + , bEnableAcceptAll(true) + , bEnableReject(true) + , bEnableRejectAll(true) + , bEnableUndo(true) + , bEnableClearFormat(false) + , bEnableClearFormatAll(false) + , m_pDialog(pDialog) + , m_xAccept(pTopLevel->weld_button("accept")) + , m_xReject(pTopLevel->weld_button("reject")) + , m_xAcceptAll(pTopLevel->weld_button("acceptall")) + , m_xRejectAll(pTopLevel->weld_button("rejectall")) + , m_xUndo(pTopLevel->weld_button("undo")) + , m_xViewData(new SvxRedlinTable(m_xBuilder->weld_tree_view("writerchanges"), + m_xBuilder->weld_tree_view("calcchanges"))) +{ + Size aControlSize(80, 65); + m_xViewData->set_size_request(aControlSize.Width(), aControlSize.Height()); + + Link<weld::Button&,void> aLink=LINK( this, SvxTPView, PbClickHdl); + + m_xAccept->connect_clicked(aLink); + m_xAcceptAll->connect_clicked(aLink); + m_xReject->connect_clicked(aLink); + m_xRejectAll->connect_clicked(aLink); + m_xUndo->connect_clicked(aLink); +} + +void SvxTPView::ActivatePage() +{ + m_xAccept->set_sensitive(bEnableAccept); + m_xReject->set_sensitive(bEnableReject); + m_xAcceptAll->set_sensitive(bEnableAcceptAll); + m_xRejectAll->set_sensitive(bEnableRejectAll); + m_xUndo->set_sensitive(bEnableUndo); +} + +void SvxTPView::DeactivatePage() +{ + m_xAccept->set_sensitive(false); + m_xReject->set_sensitive(false); + m_xAcceptAll->set_sensitive(false); + m_xRejectAll->set_sensitive(false); + m_xUndo->set_sensitive(false); +} + +SvxTPView::~SvxTPView() +{ +} + +void SvxRedlinTable::SetWriterView() +{ + nDatePos = WRITER_DATE; + if (xCalcTreeView) + xCalcTreeView->hide(); + xWriterTreeView->show(); + pTreeView = xWriterTreeView.get(); + + auto nDigitWidth = pTreeView->get_approximate_digit_width(); + std::vector<int> aWidths; + aWidths.push_back(nDigitWidth * 10); + aWidths.push_back(nDigitWidth * 20); + aWidths.push_back(nDigitWidth * 20); + pTreeView->set_column_fixed_widths(aWidths); +} + +void SvxRedlinTable::SetCalcView() +{ + nDatePos = CALC_DATE; + if (xWriterTreeView) + xWriterTreeView->hide(); + xCalcTreeView->show(); + pTreeView = xCalcTreeView.get(); + + auto nDigitWidth = pTreeView->get_approximate_digit_width(); + std::vector<int> aWidths; + aWidths.push_back(nDigitWidth * 20); + aWidths.push_back(nDigitWidth * 20); + aWidths.push_back(nDigitWidth * 20); + aWidths.push_back(nDigitWidth * 20); + pTreeView->set_column_fixed_widths(aWidths); +} + +void SvxTPView::EnableAccept(bool bFlag) +{ + bEnableAccept = bFlag; + m_xAccept->set_sensitive(bFlag); +} + +void SvxTPView::EnableAcceptAll(bool bFlag) +{ + bEnableAcceptAll = bFlag; + m_xAcceptAll->set_sensitive(bFlag); +} + +void SvxTPView::EnableReject(bool bFlag) +{ + bEnableReject = bFlag; + m_xReject->set_sensitive(bFlag); +} + +void SvxTPView::EnableRejectAll(bool bFlag) +{ + bEnableRejectAll = bFlag; + m_xRejectAll->set_sensitive(bFlag); +} + +void SvxTPView::EnableClearFormatButton(weld::Button& rButton, bool bFlag) +{ + OUString sText = rButton.get_label(); + OUString sClearFormat = SvxResId(RID_SVXSTR_CLEARFORM); + sal_Int32 nPos = sText.indexOf(sClearFormat); + + // add or remove "Clear formatting" to get "Reject" or "Reject/Clear formatting" + if (bFlag) + { + if (nPos == -1) + { + rButton.set_label(sText + "/" + sClearFormat); + } + } + else + { + if (nPos > 0) + { + rButton.set_label(sText.copy(0, nPos - 1)); + } + } + + if (m_pDialog) + { + // tdf#127218 allow dialog to shrink + m_pDialog->resize_to_request(); + } +} + +void SvxTPView::EnableClearFormat(bool bFlag) +{ + if (bEnableClearFormat == bFlag) + return; + EnableClearFormatButton(*m_xReject, bFlag); + bEnableClearFormat = bFlag; +} + +void SvxTPView::EnableClearFormatAll(bool bFlag) +{ + if (bEnableClearFormatAll == bFlag) + return; + EnableClearFormatButton(*m_xRejectAll, bFlag); + bEnableClearFormatAll = bFlag; +} + +void SvxTPView::ShowUndo() +{ + m_xUndo->show(); +} + +void SvxTPView::EnableUndo(bool bFlag) +{ + bEnableUndo = bFlag; + m_xUndo->set_sensitive(bFlag); +} + +IMPL_LINK( SvxTPView, PbClickHdl, weld::Button&, rPushB, void) +{ + if (&rPushB == m_xAccept.get()) + { + AcceptClickLk.Call(this); + } + else if (&rPushB == m_xAcceptAll.get()) + { + AcceptAllClickLk.Call(this); + } + else if (&rPushB == m_xReject.get()) + { + RejectClickLk.Call(this); + } + else if (&rPushB == m_xRejectAll.get()) + { + RejectAllClickLk.Call(this); + } + else if (&rPushB == m_xUndo.get()) + { + UndoClickLk.Call(this); + } +} + +SvxTPage::SvxTPage(weld::Container* pParent, const OUString& rUIXMLDescription, const OString& rID) + : m_xBuilder(Application::CreateBuilder(pParent, rUIXMLDescription)) + , m_xContainer(m_xBuilder->weld_container(rID)) +{ +} + +SvxTPFilter::SvxTPFilter(weld::Container* pParent) + : SvxTPage(pParent, "svx/ui/redlinefilterpage.ui", "RedlineFilterPage") + , bModified(false) + , m_pRedlinTable(nullptr) + , m_xCbDate(m_xBuilder->weld_check_button("date")) + , m_xLbDate(m_xBuilder->weld_combo_box("datecond")) + , m_xDfDate(new SvtCalendarBox(m_xBuilder->weld_menu_button("startdate"))) + , m_xTfDate(m_xBuilder->weld_time_spin_button("starttime", TimeFieldFormat::F_NONE)) + , m_xIbClock(m_xBuilder->weld_button("startclock")) + , m_xFtDate2(m_xBuilder->weld_label("and")) + , m_xDfDate2(new SvtCalendarBox(m_xBuilder->weld_menu_button("enddate"))) + , m_xTfDate2(m_xBuilder->weld_time_spin_button("endtime", TimeFieldFormat::F_NONE)) + , m_xIbClock2(m_xBuilder->weld_button("endclock")) + , m_xCbAuthor(m_xBuilder->weld_check_button("author")) + , m_xLbAuthor(m_xBuilder->weld_combo_box("authorlist")) + , m_xCbRange(m_xBuilder->weld_check_button("range")) + , m_xEdRange(m_xBuilder->weld_entry("rangeedit")) + , m_xBtnRange(m_xBuilder->weld_button("dotdotdot")) + , m_xCbAction(m_xBuilder->weld_check_button("action")) + , m_xLbAction(m_xBuilder->weld_combo_box("actionlist")) + , m_xCbComment(m_xBuilder->weld_check_button("comment")) + , m_xEdComment(m_xBuilder->weld_entry("commentedit")) +{ + m_xLbDate->set_active(0); + m_xLbDate->connect_changed( LINK( this, SvxTPFilter, SelDateHdl ) ); + m_xIbClock->connect_clicked( LINK( this, SvxTPFilter, TimeHdl) ); + m_xIbClock2->connect_clicked( LINK( this, SvxTPFilter,TimeHdl) ); + m_xBtnRange->connect_clicked( LINK( this, SvxTPFilter, RefHandle)); + + Link<weld::Button&,void> aLink=LINK( this, SvxTPFilter, RowEnableHdl) ; + m_xCbDate->connect_clicked(aLink); + m_xCbAuthor->connect_clicked(aLink); + m_xCbRange->connect_clicked(aLink); + m_xCbAction->connect_clicked(aLink); + m_xCbComment->connect_clicked(aLink); + + Link<SvtCalendarBox&,void> a2Link=LINK(this, SvxTPFilter, ModifyDate); + m_xDfDate->connect_activated(a2Link); + m_xDfDate2->connect_activated(a2Link); + + Link<weld::TimeSpinButton&,void> a3Link=LINK(this, SvxTPFilter, ModifyTime); + m_xTfDate->connect_value_changed(a3Link); + m_xTfDate2->connect_value_changed(a3Link); + + Link<weld::Entry&,void> a4Link=LINK( this, SvxTPFilter, ModifyHdl); + m_xEdRange->connect_changed(a4Link); + m_xEdComment->connect_changed(a4Link); + m_xLbAction->connect_changed(LINK( this, SvxTPFilter, ModifyListBoxHdl)); + m_xLbAuthor->connect_changed(LINK( this, SvxTPFilter, ModifyListBoxHdl)); + + RowEnableHdl(*m_xCbDate); + RowEnableHdl(*m_xCbAuthor); + RowEnableHdl(*m_xCbRange); + RowEnableHdl(*m_xCbAction); + RowEnableHdl(*m_xCbComment); + + DateTime aDateTime( DateTime::SYSTEM ); + m_xDfDate->set_date(aDateTime); + m_xDfDate2->set_date(aDateTime); + m_xTfDate->set_value(aDateTime); + m_xTfDate2->set_value(aDateTime); + HideRange(); + ShowAction(); + bModified=false; +} + +SvxTPFilter::~SvxTPFilter() +{ +} + +void SvxTPFilter::SetRedlinTable(SvxRedlinTable* pTable) +{ + m_pRedlinTable = pTable; +} + +void SvxTPFilter::EnableDateLine1(bool bFlag) +{ + if(bFlag && m_xCbDate->get_active()) + { + m_xDfDate->set_sensitive(true); + m_xTfDate->set_sensitive(true); + m_xIbClock->set_sensitive(true); + } + else + { + m_xDfDate->set_sensitive(false); + m_xTfDate->set_sensitive(false); + m_xIbClock->set_sensitive(false); + } +} +void SvxTPFilter::EnableDateLine2(bool bFlag) +{ + if(bFlag && m_xCbDate->get_active()) + { + m_xFtDate2->set_sensitive(true); + m_xDfDate2->set_sensitive(true); + m_xTfDate2->set_sensitive(true); + m_xIbClock2->set_sensitive(true); + } + else + { + m_xFtDate2->set_sensitive(false); + m_xDfDate2->set_sensitive(false); + m_xDfDate2->set_label(OUString()); + m_xTfDate2->set_sensitive(false); + m_xTfDate2->set_text(OUString()); + m_xIbClock2->set_sensitive(false); + } +} + +Date SvxTPFilter::GetFirstDate() const +{ + return m_xDfDate->get_date(); +} + +void SvxTPFilter::SetFirstDate(const Date &aDate) +{ + m_xDfDate->set_date(aDate); +} + +tools::Time SvxTPFilter::GetFirstTime() const +{ + return m_xTfDate->get_value(); +} + +void SvxTPFilter::SetFirstTime(const tools::Time &aTime) +{ + m_xTfDate->set_value(aTime); +} + +Date SvxTPFilter::GetLastDate() const +{ + return m_xDfDate2->get_date(); +} + +void SvxTPFilter::SetLastDate(const Date &aDate) +{ + m_xDfDate2->set_date(aDate); +} + +tools::Time SvxTPFilter::GetLastTime() const +{ + return m_xTfDate2->get_value(); +} + +void SvxTPFilter::SetLastTime(const tools::Time &aTime) +{ + m_xTfDate2->set_value(aTime); +} + +void SvxTPFilter::SetDateMode(sal_uInt16 nMode) +{ + m_xLbDate->set_active(nMode); + SelDateHdl(*m_xLbDate); +} + +SvxRedlinDateMode SvxTPFilter::GetDateMode() const +{ + return static_cast<SvxRedlinDateMode>(m_xLbDate->get_active()); +} +void SvxTPFilter::ClearAuthors() +{ + m_xLbAuthor->clear(); +} + +void SvxTPFilter::InsertAuthor( const OUString& rString) +{ + m_xLbAuthor->append_text(rString); +} + +OUString SvxTPFilter::GetSelectedAuthor() const +{ + return m_xLbAuthor->get_active_text(); +} + +void SvxTPFilter::SelectedAuthorPos(sal_Int32 nPos) +{ + m_xLbAuthor->set_active(nPos); +} + +sal_Int32 SvxTPFilter::SelectAuthor(const OUString& aString) +{ + m_xLbAuthor->set_active_text(aString); + return m_xLbAuthor->get_active(); +} + +void SvxTPFilter::SetRange(const OUString& rString) +{ + m_xEdRange->set_text(rString); +} + +OUString SvxTPFilter::GetRange() const +{ + return m_xEdRange->get_text(); +} + +void SvxTPFilter::SetFocusToRange() +{ + m_xEdRange->grab_focus(); +} + +void SvxTPFilter::HideRange(bool bHide) +{ + if (bHide) + { + m_xCbRange->hide(); + m_xEdRange->hide(); + m_xBtnRange->hide(); + } + else + { + ShowAction(false); + m_xCbRange->show(); + m_xEdRange->show(); + m_xBtnRange->show(); + } +} + +void SvxTPFilter::SetComment(const OUString &rComment) +{ + m_xEdComment->set_text(rComment); +} + +OUString SvxTPFilter::GetComment()const +{ + return m_xEdComment->get_text(); +} + +bool SvxTPFilter::IsDate() const +{ + return m_xCbDate->get_active(); +} + +bool SvxTPFilter::IsAuthor() const +{ + return m_xCbAuthor->get_active(); +} + +bool SvxTPFilter::IsRange() const +{ + return m_xCbRange->get_active(); +} + +bool SvxTPFilter::IsAction() const +{ + return m_xCbAction->get_active(); +} + +bool SvxTPFilter::IsComment() const +{ + return m_xCbComment->get_active(); +} + +void SvxTPFilter::CheckDate(bool bFlag) +{ + m_xCbDate->set_active(bFlag); + RowEnableHdl(*m_xCbDate); + bModified=false; +} + +void SvxTPFilter::CheckAuthor(bool bFlag) +{ + m_xCbAuthor->set_active(bFlag); + RowEnableHdl(*m_xCbAuthor); + bModified=false; +} + +void SvxTPFilter::CheckRange(bool bFlag) +{ + m_xCbRange->set_active(bFlag); + RowEnableHdl(*m_xCbRange); + bModified=false; +} + +void SvxTPFilter::CheckAction(bool bFlag) +{ + m_xCbAction->set_active(bFlag); + RowEnableHdl(*m_xCbAction); + bModified=false; +} + +void SvxTPFilter::CheckComment(bool bFlag) +{ + m_xCbComment->set_active(bFlag); + RowEnableHdl(*m_xCbComment); + bModified=false; +} + +void SvxTPFilter::ShowAction(bool bShow) +{ + if(!bShow) + { + m_xCbAction->hide(); + m_xLbAction->hide(); + } + else + { + HideRange(); + m_xCbAction->show(); + m_xLbAction->show(); + } +} + +IMPL_LINK_NOARG(SvxTPFilter, SelDateHdl, weld::ComboBox&, void) +{ + SvxRedlinDateMode nKind = static_cast<SvxRedlinDateMode>(m_xLbDate->get_active()); + switch(nKind) + { + case SvxRedlinDateMode::BEFORE: + EnableDateLine1(true); + EnableDateLine2(false); + break; + case SvxRedlinDateMode::SINCE: + EnableDateLine1(true); + EnableDateLine2(false); + break; + case SvxRedlinDateMode::EQUAL: + EnableDateLine1(true); + m_xTfDate->set_sensitive(false); + m_xTfDate->set_text(OUString()); + EnableDateLine2(false); + break; + case SvxRedlinDateMode::NOTEQUAL: + EnableDateLine1(true); + m_xTfDate->set_sensitive(false); + m_xTfDate->set_text(OUString()); + EnableDateLine2(false); + break; + case SvxRedlinDateMode::BETWEEN: + EnableDateLine1(true); + EnableDateLine2(true); + break; + case SvxRedlinDateMode::SAVE: + EnableDateLine1(false); + EnableDateLine2(false); + break; + case SvxRedlinDateMode::NONE: + break; + } + bModified = true; +} + +IMPL_LINK(SvxTPFilter, RowEnableHdl, weld::Button&, rCB, void) +{ + if (&rCB == m_xCbDate.get()) + { + m_xLbDate->set_sensitive(m_xCbDate->get_active()); + EnableDateLine1(false); + EnableDateLine2(false); + if(m_xCbDate->get_active()) SelDateHdl(*m_xLbDate); + } + else if (&rCB == m_xCbAuthor.get()) + { + m_xLbAuthor->set_sensitive(m_xCbAuthor->get_active()); + } + else if (&rCB == m_xCbRange.get()) + { + m_xEdRange->set_sensitive(m_xCbRange->get_active()); + m_xBtnRange->set_sensitive(m_xCbRange->get_active()); + } + else if (&rCB == m_xCbAction.get()) + { + m_xLbAction->set_sensitive(m_xCbAction->get_active()); + } + else if (&rCB == m_xCbComment.get()) + { + m_xEdComment->set_sensitive(m_xCbComment->get_active()); + } + bModified = true; +} + +IMPL_LINK(SvxTPFilter, TimeHdl, weld::Button&, rIB, void) +{ + DateTime aDateTime( DateTime::SYSTEM ); + if (&rIB == m_xIbClock.get()) + { + m_xDfDate->set_date(aDateTime); + m_xTfDate->set_value(aDateTime); + } + else if (&rIB == m_xIbClock2.get()) + { + m_xDfDate2->set_date(aDateTime); + m_xTfDate2->set_value(aDateTime); + } + bModified=true; +} + +IMPL_LINK_NOARG(SvxTPFilter, ModifyHdl, weld::Entry&, void) +{ + bModified=true; +} + +IMPL_LINK_NOARG(SvxTPFilter, ModifyListBoxHdl, weld::ComboBox&, void) +{ + bModified=true; +} + +void SvxTPFilter::DeactivatePage() +{ + if(bModified) + { + if (m_pRedlinTable) + { + m_pRedlinTable->SetFilterDate(IsDate()); + m_pRedlinTable->SetDateTimeMode(GetDateMode()); + m_pRedlinTable->SetFirstDate(m_xDfDate->get_date()); + m_pRedlinTable->SetLastDate(m_xDfDate2->get_date()); + m_pRedlinTable->SetFirstTime(m_xTfDate->get_value()); + m_pRedlinTable->SetLastTime(m_xTfDate2->get_value()); + m_pRedlinTable->SetFilterAuthor(IsAuthor()); + m_pRedlinTable->SetAuthor(GetSelectedAuthor()); + + m_pRedlinTable->SetFilterComment(IsComment()); + + utl::SearchParam aSearchParam( m_xEdComment->get_text(), + utl::SearchParam::SearchType::Regexp,false ); + + m_pRedlinTable->SetCommentParams(&aSearchParam); + + m_pRedlinTable->UpdateFilterTest(); + } + + aReadyLink.Call(this); + } + bModified=false; +} + +void SvxTPFilter::Enable(bool bEnable) +{ + m_xContainer->set_sensitive(bEnable); + if (m_xCbDate->get_sensitive()) + { + RowEnableHdl(*m_xCbDate); + RowEnableHdl(*m_xCbAuthor); + RowEnableHdl(*m_xCbRange); + RowEnableHdl(*m_xCbComment); + } +} + +IMPL_LINK(SvxTPFilter, ModifyDate, SvtCalendarBox&, rTF, void) +{ + Date aDate( Date::SYSTEM ); + if (m_xDfDate.get() == &rTF) + { + if (m_xDfDate->get_label().isEmpty()) + m_xDfDate->set_date(aDate); + + if(m_pRedlinTable!=nullptr) + m_pRedlinTable->SetFirstDate(m_xDfDate->get_date()); + } + else if (m_xDfDate2.get() == &rTF) + { + if (m_xDfDate2->get_label().isEmpty()) + m_xDfDate2->set_date(aDate); + + if (m_pRedlinTable) + m_pRedlinTable->SetLastDate(m_xDfDate2->get_date()); + } + bModified=true; +} + +IMPL_LINK(SvxTPFilter, ModifyTime, weld::TimeSpinButton&, rTF, void) +{ + tools::Time aTime(0); + if (m_xTfDate.get() == &rTF) + { + if (m_xTfDate->get_text().isEmpty()) + m_xTfDate->set_value(aTime); + + if(m_pRedlinTable!=nullptr) + m_pRedlinTable->SetFirstTime(m_xTfDate->get_value()); + } + else if (m_xTfDate2.get() == &rTF) + { + if (m_xTfDate2->get_text().isEmpty()) + m_xTfDate2->set_value(aTime); + + if(m_pRedlinTable!=nullptr) + m_pRedlinTable->SetLastTime(m_xTfDate2->get_value()); + + } + bModified=true; +} + +IMPL_LINK_NOARG(SvxTPFilter, RefHandle, weld::Button&, void) +{ + aRefLink.Call(this); +} + +SvxAcceptChgCtr::SvxAcceptChgCtr(weld::Container* pParent, weld::Window* pDialog, weld::Builder* pTopLevel) + : m_xBuilder(Application::CreateBuilder(pParent, "svx/ui/redlinecontrol.ui")) + , m_xTabCtrl(m_xBuilder->weld_notebook("tabcontrol")) +{ + m_xTabCtrl->connect_enter_page(LINK(this, SvxAcceptChgCtr, ActivatePageHdl)); + m_xTabCtrl->connect_leave_page(LINK(this, SvxAcceptChgCtr, DeactivatePageHdl)); + + m_xTPFilter.reset(new SvxTPFilter(m_xTabCtrl->get_page("filter"))); + m_xTPView.reset(new SvxTPView(m_xTabCtrl->get_page("view"), pDialog, pTopLevel)); + m_xTPFilter->SetRedlinTable(m_xTPView->GetTableControl()); + m_xTabCtrl->set_current_page("view"); + m_xTabCtrl->show(); +} + +SvxAcceptChgCtr::~SvxAcceptChgCtr() +{ +} + +void SvxAcceptChgCtr::ShowFilterPage() +{ + m_xTabCtrl->set_current_page("filter"); +} + +IMPL_LINK(SvxAcceptChgCtr, ActivatePageHdl, const OString&, rPage, void) +{ + if (rPage == "filter") + m_xTPFilter->ActivatePage(); + else if (rPage == "view") + m_xTPView->ActivatePage(); +} + +IMPL_LINK(SvxAcceptChgCtr, DeactivatePageHdl, const OString&, rPage, bool) +{ + if (rPage == "filter") + m_xTPFilter->DeactivatePage(); + else if (rPage == "view") + m_xTPView->DeactivatePage(); + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/databaseregistrationui.cxx b/svx/source/dialog/databaseregistrationui.cxx new file mode 100644 index 000000000..93efd7cbc --- /dev/null +++ b/svx/source/dialog/databaseregistrationui.cxx @@ -0,0 +1,45 @@ +/* -*- 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/databaseregistrationui.hxx> + +#include <svx/svxdlg.hxx> +#include <svx/dialogs.hrc> + +#include <sfx2/app.hxx> +#include <svl/itemset.hxx> + +namespace svx +{ + sal_uInt16 administrateDatabaseRegistration(weld::Window* parentWindow) + { + sal_uInt16 nResult = RET_CANCEL; + + SfxItemSet aRegistrationItems( SfxGetpApp()->GetPool(), svl::Items<SID_SB_DB_REGISTER, SID_SB_DB_REGISTER>{} ); + + SvxAbstractDialogFactory* pDialogFactory = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<SfxAbstractDialog> pDialog(pDialogFactory->CreateSfxDialog(parentWindow, aRegistrationItems, nullptr, RID_SFXPAGE_DBREGISTER)); + nResult = pDialog->Execute(); + + return nResult; + } + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/dialcontrol.cxx b/svx/source/dialog/dialcontrol.cxx new file mode 100644 index 000000000..7faf0d985 --- /dev/null +++ b/svx/source/dialog/dialcontrol.cxx @@ -0,0 +1,479 @@ +/* -*- 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/dialcontrol.hxx> +#include <cmath> +#include <vcl/virdev.hxx> +#include <vcl/svapp.hxx> +#include <vcl/bitmapex.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <i18nlangtag/languagetag.hxx> + +namespace svx { + +const long DIAL_OUTER_WIDTH = 8; + +DialControlBmp::DialControlBmp(OutputDevice& rReference) + : VirtualDevice(rReference, DeviceFormat::DEFAULT, DeviceFormat::DEFAULT) + , mbEnabled(true) + , mrParent(rReference) + , mnCenterX(0) + , mnCenterY(0) +{ + EnableRTL(false); +} + +void DialControlBmp::InitBitmap(const vcl::Font& rFont) +{ + Init(); + SetFont(rFont); +} + +void DialControlBmp::CopyBackground( const DialControlBmp& rSrc ) +{ + Init(); + SetSize(rSrc.maRect.GetSize()); + mbEnabled = rSrc.mbEnabled; + Point aPos; + DrawBitmapEx( aPos, rSrc.GetBitmapEx( aPos, maRect.GetSize() ) ); +} + +void DialControlBmp::DrawBackground( const Size& rSize, bool bEnabled ) +{ + Init(); + SetSize(rSize); + mbEnabled = bEnabled; + DrawBackground(); +} + +void DialControlBmp::DrawElements( const OUString& rText, sal_Int32 nAngle ) +{ + double fAngle = basegfx::deg2rad(nAngle) / 100.0; + double fSin = sin( fAngle ); + double fCos = cos( fAngle ); + double fWidth = GetTextWidth( rText ) / 2.0; + double fHeight = GetTextHeight() / 2.0; + + if ( !rText.isEmpty() ) + { + // rotated text + vcl::Font aFont( GetFont() ); + aFont.SetColor( GetTextColor() ); + aFont.SetOrientation( static_cast< short >( (nAngle + 5) / 10 ) ); // Font uses 1/10 degrees + aFont.SetWeight( WEIGHT_BOLD ); + SetFont( aFont ); + + long nX = static_cast< long >( mnCenterX - fWidth * fCos - fHeight * fSin ); + long nY = static_cast< long >( mnCenterY + fWidth * fSin - fHeight * fCos ); + tools::Rectangle aRect( nX, nY, 2 * mnCenterX - nX, 2 * mnCenterY - nY ); + DrawText( aRect, rText, mbEnabled ? DrawTextFlags::NONE : DrawTextFlags::Disable ); + } + else + { + // only a line + const sal_Int32 nDx (fCos * (maRect.GetWidth()-4) / 2); + const sal_Int32 nDy (-fSin * (maRect.GetHeight()-4) / 2); + Point pt1( maRect.Center() ); + Point pt2( pt1.X() + nDx, pt1.Y() + nDy); + + SetLineColor( GetTextColor() ); + DrawLine( pt1, pt2 ); + } + + // *** drag button *** + + bool bMain = (nAngle % 4500) != 0; + SetLineColor( GetButtonLineColor() ); + SetFillColor( GetButtonFillColor( bMain ) ); + + long nX = mnCenterX - static_cast< long >( (DIAL_OUTER_WIDTH / 2 - mnCenterX) * fCos ); + long nY = mnCenterY - static_cast< long >( (mnCenterY - DIAL_OUTER_WIDTH / 2) * fSin ); + long nSize = bMain ? (DIAL_OUTER_WIDTH / 4) : (DIAL_OUTER_WIDTH / 2 - 1); + DrawEllipse( tools::Rectangle( nX - nSize, nY - nSize, nX + nSize, nY + nSize ) ); +} + +Color DialControlBmp::GetBackgroundColor() const +{ + return GetSettings().GetStyleSettings().GetDialogColor(); +} + +const Color& DialControlBmp::GetTextColor() const +{ + return GetSettings().GetStyleSettings().GetLabelTextColor(); +} + +const Color& DialControlBmp::GetScaleLineColor() const +{ + const StyleSettings& rSett = GetSettings().GetStyleSettings(); + return mbEnabled ? rSett.GetButtonTextColor() : rSett.GetDisableColor(); +} + +const Color& DialControlBmp::GetButtonLineColor() const +{ + const StyleSettings& rSett = GetSettings().GetStyleSettings(); + return mbEnabled ? rSett.GetButtonTextColor() : rSett.GetDisableColor(); +} + +const Color& DialControlBmp::GetButtonFillColor( bool bMain ) const +{ + const StyleSettings& rSett = GetSettings().GetStyleSettings(); + return mbEnabled ? (bMain ? rSett.GetMenuColor() : rSett.GetHighlightColor()) : rSett.GetDisableColor(); +} + +void DialControlBmp::Init() +{ + SetSettings(mrParent.GetSettings()); + SetBackground(GetBackgroundColor()); +} + +void DialControlBmp::SetSize( const Size& rSize ) +{ + maRect.SetPos( Point( 0, 0 ) ); + maRect.SetSize( rSize ); + mnCenterX = rSize.Width() / 2; + mnCenterY = rSize.Height() / 2; + SetOutputSize( rSize ); +} + +void DialControlBmp::DrawBackground() +{ + // *** background with 3D effect *** + + SetLineColor(); + SetFillColor(); + Erase(); + + EnableRTL(); // draw 3D effect in correct direction + + sal_uInt8 nDiff = mbEnabled ? 0x18 : 0x10; + Color aColor; + + aColor = GetBackgroundColor(); + SetFillColor( aColor ); + DrawPie( maRect, maRect.TopRight(), maRect.TopCenter() ); + DrawPie( maRect, maRect.BottomLeft(), maRect.BottomCenter() ); + + aColor.DecreaseLuminance( nDiff ); + SetFillColor( aColor ); + DrawPie( maRect, maRect.BottomCenter(), maRect.TopRight() ); + + aColor.DecreaseLuminance( nDiff ); + SetFillColor( aColor ); + DrawPie( maRect, maRect.BottomRight(), maRect.RightCenter() ); + + aColor = GetBackgroundColor(); + aColor.IncreaseLuminance( nDiff ); + SetFillColor( aColor ); + DrawPie( maRect, maRect.TopCenter(), maRect.BottomLeft() ); + + aColor.IncreaseLuminance( nDiff ); + SetFillColor( aColor ); + DrawPie( maRect, maRect.TopLeft(), maRect.LeftCenter() ); + + EnableRTL( false ); + + // *** calibration *** + + Point aStartPos( mnCenterX, mnCenterY ); + Color aFullColor( GetScaleLineColor() ); + Color aLightColor( GetBackgroundColor() ); + aLightColor.Merge( aFullColor, 128 ); + + for( int nAngle = 0; nAngle < 360; nAngle += 15 ) + { + SetLineColor( (nAngle % 45) ? aLightColor : aFullColor ); + double fAngle = basegfx::deg2rad(nAngle); + long nX = static_cast< long >( -mnCenterX * cos( fAngle ) ); + long nY = static_cast< long >( mnCenterY * sin( fAngle ) ); + DrawLine( aStartPos, Point( mnCenterX - nX, mnCenterY - nY ) ); + } + + // *** clear inner area *** + + SetLineColor(); + SetFillColor( GetBackgroundColor() ); + tools::Rectangle aEllipseRect = maRect; + aEllipseRect.shrink(DIAL_OUTER_WIDTH); + DrawEllipse( aEllipseRect ); +} + +DialControl::DialControl_Impl::DialControl_Impl(OutputDevice& rReference) : + mxBmpEnabled(VclPtr<DialControlBmp>::Create(rReference)), + mxBmpDisabled(VclPtr<DialControlBmp>::Create(rReference)), + mxBmpBuffered(VclPtr<DialControlBmp>::Create(rReference)), + mpLinkField( nullptr ), + mnLinkedFieldValueMultiplyer( 0 ), + mnAngle( 0 ), + mnInitialAngle( 0 ), + mnOldAngle( 0 ), + mnCenterX( 0 ), + mnCenterY( 0 ), + mbNoRot( false ) +{ +} + +void DialControl::DialControl_Impl::Init( const Size& rWinSize, const vcl::Font& rWinFont ) +{ + maWinFont = rWinFont; + maWinFont.SetTransparent(true); + mxBmpBuffered->InitBitmap(maWinFont); + SetSize(rWinSize); +} + +void DialControl::DialControl_Impl::SetSize( const Size& rWinSize ) +{ + // make the control squared, and adjusted so that we have a well-defined + // center ["(x - 1) | 1" creates odd value <= x] + long nMin = (std::min(rWinSize.Width(), rWinSize.Height()) - 1) | 1; + + maWinSize = Size( nMin, nMin ); + + mnCenterX = maWinSize.Width() / 2; + mnCenterY = maWinSize.Height() / 2; + + mxBmpEnabled->DrawBackground( maWinSize, true ); + mxBmpDisabled->DrawBackground( maWinSize, false ); + mxBmpBuffered->SetSize( maWinSize ); +} + +void DialControl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + //use same logic as DialControl_Impl::SetSize + int nDim = (std::min<int>(pDrawingArea->get_approximate_digit_width() * 12, + pDrawingArea->get_text_height() * 6) - 1) | 1; + Size aSize(nDim, nDim); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + mpImpl.reset(new DialControl_Impl(pDrawingArea->get_ref_device())); + //set size and use that + Init(aSize); +} + +void DialControl::Resize() +{ + mpImpl->SetSize(GetOutputSizePixel()); + InvalidateControl(); +} + +void DialControl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + Point aPos; + rRenderContext.DrawBitmapEx(aPos, mpImpl->mxBmpBuffered->GetBitmapEx(aPos, mpImpl->maWinSize)); +} + +void DialControl::StyleUpdated() +{ + CustomWidgetController::StyleUpdated(); + Init( mpImpl->maWinSize, mpImpl->maWinFont ); + InvalidateControl(); +} + +bool DialControl::MouseButtonDown(const MouseEvent& rMEvt) +{ + if( rMEvt.IsLeft() ) + { + GrabFocus(); + CaptureMouse(); + mpImpl->mnOldAngle = mpImpl->mnAngle; + HandleMouseEvent( rMEvt.GetPosPixel(), true ); + } + return true; +} + +bool DialControl::MouseMove( const MouseEvent& rMEvt ) +{ + if( IsMouseCaptured() && rMEvt.IsLeft() ) + HandleMouseEvent( rMEvt.GetPosPixel(), false ); + return true; +} + +bool DialControl::MouseButtonUp(const MouseEvent&) +{ + if( IsMouseCaptured() ) + { + ReleaseMouse(); + if( mpImpl->mpLinkField ) + mpImpl->mpLinkField->grab_focus(); + } + return true; +} + +bool DialControl::KeyInput( const KeyEvent& rKEvt ) +{ + const vcl::KeyCode& rKCode = rKEvt.GetKeyCode(); + if( !rKCode.GetModifier() && (rKCode.GetCode() == KEY_ESCAPE) ) + { + HandleEscapeEvent(); + return true; + } + return CustomWidgetController::KeyInput(rKEvt); +} + +void DialControl::LoseFocus() +{ + // release captured mouse + HandleEscapeEvent(); +} + +bool DialControl::HasRotation() const +{ + return !mpImpl->mbNoRot; +} + +void DialControl::SetNoRotation() +{ + if( !mpImpl->mbNoRot ) + { + mpImpl->mbNoRot = true; + InvalidateControl(); + if (mpImpl->mpLinkField) + mpImpl->mpLinkField->set_text(""); + } +} + +sal_Int32 DialControl::GetRotation() const +{ + return mpImpl->mnAngle; +} + +void DialControl::SetRotation(sal_Int32 nAngle) +{ + SetRotation(nAngle, false); +} + +void DialControl::SetLinkedField(weld::MetricSpinButton* pField, sal_Int32 nDecimalPlaces) +{ + mpImpl->mnLinkedFieldValueMultiplyer = 100 / std::pow(10.0, double(nDecimalPlaces)); + + // remove modify handler from old linked field + if( mpImpl->mpLinkField ) + { + weld::MetricSpinButton& rField = *mpImpl->mpLinkField; + rField.connect_value_changed(Link<weld::MetricSpinButton&,void>()); + } + // remember the new linked field + mpImpl->mpLinkField = pField; + // set modify handler at new linked field + if( mpImpl->mpLinkField ) + { + weld::MetricSpinButton& rField = *mpImpl->mpLinkField; + rField.connect_value_changed(LINK(this, DialControl, LinkedFieldModifyHdl)); + } +} + +IMPL_LINK_NOARG(DialControl, LinkedFieldModifyHdl, weld::MetricSpinButton&, void) +{ + SetRotation(mpImpl->mpLinkField->get_value(FieldUnit::DEGREE) * mpImpl->mnLinkedFieldValueMultiplyer, true); +} + +void DialControl::SaveValue() +{ + mpImpl->mnInitialAngle = mpImpl->mnAngle; +} + +bool DialControl::IsValueModified() const +{ + return mpImpl->mnInitialAngle != mpImpl->mnAngle; +} + +void DialControl::Init( const Size& rWinSize, const vcl::Font& rWinFont ) +{ + mpImpl->Init( rWinSize, rWinFont ); + EnableRTL( false ); // don't mirror mouse handling + SetOutputSizePixel( mpImpl->maWinSize ); +} + +void DialControl::Init( const Size& rWinSize ) +{ + //hidpi TODO: GetDefaultFont() picks a font size too small, so fix it here. + vcl::Font aDefaultSize = Application::GetSettings().GetStyleSettings().GetLabelFont(); + + vcl::Font aFont( OutputDevice::GetDefaultFont( + DefaultFontType::UI_SANS, Application::GetSettings().GetUILanguageTag().getLanguageType(), GetDefaultFontFlags::OnlyOne ) ); + + aFont.SetFontHeight(aDefaultSize.GetFontHeight()); + Init( rWinSize, aFont ); +} + +void DialControl::InvalidateControl() +{ + mpImpl->mxBmpBuffered->CopyBackground( IsEnabled() ? *mpImpl->mxBmpEnabled : *mpImpl->mxBmpDisabled ); + if( !mpImpl->mbNoRot ) + mpImpl->mxBmpBuffered->DrawElements(GetText(), mpImpl->mnAngle); + Invalidate(); +} + +void DialControl::SetRotation(sal_Int32 nAngle, bool bBroadcast) +{ + bool bOldSel = mpImpl->mbNoRot; + mpImpl->mbNoRot = false; + + while (nAngle < 0) + nAngle += 36000; + + if (!bOldSel || (mpImpl->mnAngle != nAngle)) + { + mpImpl->mnAngle = nAngle; + InvalidateControl(); + if( mpImpl->mpLinkField ) + mpImpl->mpLinkField->set_value(GetRotation() / mpImpl->mnLinkedFieldValueMultiplyer, FieldUnit::DEGREE); + if( bBroadcast ) + mpImpl->maModifyHdl.Call(*this); + } +} + +void DialControl::SetModifyHdl( const Link<DialControl&,void>& rLink ) +{ + mpImpl->maModifyHdl = rLink; +} + +void DialControl::HandleMouseEvent( const Point& rPos, bool bInitial ) +{ + long nX = rPos.X() - mpImpl->mnCenterX; + long nY = mpImpl->mnCenterY - rPos.Y(); + double fH = sqrt( static_cast< double >( nX ) * nX + static_cast< double >( nY ) * nY ); + if( fH != 0.0 ) + { + double fAngle = acos( nX / fH ); + sal_Int32 nAngle = static_cast<sal_Int32>(basegfx::rad2deg(fAngle) * 100.0); + if( nY < 0 ) + nAngle = 36000 - nAngle; + if( bInitial ) // round to entire 15 degrees + nAngle = ((nAngle + 750) / 1500) * 1500; + // Round up to 1 degree + nAngle = (((nAngle + 50) / 100) * 100) % 36000; + SetRotation(nAngle, true); + } +} + +void DialControl::HandleEscapeEvent() +{ + if( IsMouseCaptured() ) + { + ReleaseMouse(); + SetRotation(mpImpl->mnOldAngle, true); + if( mpImpl->mpLinkField ) + mpImpl->mpLinkField->grab_focus(); + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/dialmgr.cxx b/svx/source/dialog/dialmgr.cxx new file mode 100644 index 000000000..cba8fbcc9 --- /dev/null +++ b/svx/source/dialog/dialmgr.cxx @@ -0,0 +1,33 @@ +/* -*- 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/resmgr.hxx> +#include <svx/dialmgr.hxx> + +std::locale SvxResLocale() +{ + return Translate::Create("svx"); +} + +OUString SvxResId(const char* pId) +{ + return Translate::get(pId, SvxResLocale()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/dlgctl3d.cxx b/svx/source/dialog/dlgctl3d.cxx new file mode 100644 index 000000000..2a2e58dab --- /dev/null +++ b/svx/source/dialog/dlgctl3d.cxx @@ -0,0 +1,1182 @@ +/* -*- 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/def3d.hxx> +#include <svx/dlgctl3d.hxx> +#include <svx/strings.hrc> +#include <svx/view3d.hxx> +#include <svx/fmmodel.hxx> +#include <svl/itempool.hxx> +#include <svx/fmpage.hxx> +#include <svx/sphere3d.hxx> +#include <svx/cube3d.hxx> +#include <svx/scene3d.hxx> +#include <vcl/svapp.hxx> +#include <svx/helperhittest3d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> +#include <polygn3d.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xlnclit.hxx> +#include <svx/xlnwtit.hxx> +#include <helpids.h> +#include <svx/dialmgr.hxx> +#include <tools/helpers.hxx> +#include <vcl/settings.hxx> + +using namespace com::sun::star; + +Svx3DPreviewControl::Svx3DPreviewControl() + : mpFmPage(nullptr) + , mpScene(nullptr) + , mp3DObj(nullptr) + , mnObjectType(SvxPreviewObjectType::SPHERE) +{ +} + +void Svx3DPreviewControl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(80, 100), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + CustomWidgetController::SetDrawingArea(pDrawingArea); + SetOutputSizePixel(aSize); + + Construct(); +} + +Svx3DPreviewControl::~Svx3DPreviewControl() +{ + mp3DView.reset(); + mpModel.reset(); +} + +void Svx3DPreviewControl::Construct() +{ + // Do never mirror the preview window. This explicitly includes right + // to left writing environments. + EnableRTL (false); + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + rDevice.SetMapMode(MapMode(MapUnit::Map100thMM)); + + // Model + mpModel.reset(new FmFormModel()); + mpModel->GetItemPool().FreezeIdRanges(); + + // Page + mpFmPage = new FmFormPage( *mpModel ); + mpModel->InsertPage( mpFmPage, 0 ); + + // 3D View + mp3DView.reset(new E3dView(*mpModel, &rDevice)); + mp3DView->SetBufferedOutputAllowed(true); + mp3DView->SetBufferedOverlayAllowed(true); + + // 3D Scene + mpScene = new E3dScene(*mpModel); + + // initially create object + SetObjectType(SvxPreviewObjectType::SPHERE); + + // camera and perspective + Camera3D rCamera = mpScene->GetCamera(); + const basegfx::B3DRange& rVolume = mpScene->GetBoundVolume(); + double fW = rVolume.getWidth(); + double fH = rVolume.getHeight(); + double fCamZ = rVolume.getMaxZ() + ((fW + fH) / 2.0); + + rCamera.SetAutoAdjustProjection(false); + rCamera.SetViewWindow(- fW / 2, - fH / 2, fW, fH); + basegfx::B3DPoint aLookAt; + double fDefaultCamPosZ = mp3DView->GetDefaultCamPosZ(); + basegfx::B3DPoint aCamPos(0.0, 0.0, fCamZ < fDefaultCamPosZ ? fDefaultCamPosZ : fCamZ); + rCamera.SetPosAndLookAt(aCamPos, aLookAt); + double fDefaultCamFocal = mp3DView->GetDefaultCamFocal(); + rCamera.SetFocalLength(fDefaultCamFocal); + + mpScene->SetCamera( rCamera ); + mpFmPage->InsertObject( mpScene ); + + basegfx::B3DHomMatrix aRotation; + aRotation.rotate(DEG2RAD( 25 ), 0.0, 0.0); + aRotation.rotate(0.0, DEG2RAD( 40 ), 0.0); + mpScene->SetTransform(aRotation * mpScene->GetTransform()); + + // invalidate SnapRects of objects + mpScene->SetRectsDirty(); + + SfxItemSet aSet( mpModel->GetItemPool(), + svl::Items<XATTR_LINESTYLE, XATTR_LINESTYLE, + XATTR_FILL_FIRST, XATTR_FILLBITMAP>{} ); + aSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + aSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) ); + aSet.Put( XFillColorItem( "", COL_WHITE ) ); + + mpScene->SetMergedItemSet(aSet); + + // PageView + SdrPageView* pPageView = mp3DView->ShowSdrPage( mpFmPage ); + mp3DView->hideMarkHandles(); + + // mark scene + mp3DView->MarkObj( mpScene, pPageView ); +} + +void Svx3DPreviewControl::Resize() +{ + // size of page + Size aSize(GetOutputSizePixel()); + aSize = GetDrawingArea()->get_ref_device().PixelToLogic(aSize); + mpFmPage->SetSize(aSize); + + // set size + Size aObjSize( aSize.Width()*5/6, aSize.Height()*5/6 ); + Point aObjPoint( (aSize.Width() - aObjSize.Width()) / 2, + (aSize.Height() - aObjSize.Height()) / 2); + tools::Rectangle aRect( aObjPoint, aObjSize); + mpScene->SetSnapRect( aRect ); +} + +void Svx3DPreviewControl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) +{ + mp3DView->CompleteRedraw(&rRenderContext, vcl::Region(rRect)); +} + +bool Svx3DPreviewControl::MouseButtonDown(const MouseEvent& rMEvt) +{ + if (rMEvt.IsShift() && rMEvt.IsMod1()) + { + if(SvxPreviewObjectType::SPHERE == GetObjectType()) + { + SetObjectType(SvxPreviewObjectType::CUBE); + } + else + { + SetObjectType(SvxPreviewObjectType::SPHERE); + } + } + return false; +} + +void Svx3DPreviewControl::SetObjectType(SvxPreviewObjectType nType) +{ + if( mnObjectType != nType || !mp3DObj) + { + SfxItemSet aSet(mpModel->GetItemPool(), svl::Items<SDRATTR_START, SDRATTR_END>{}); + mnObjectType = nType; + + if( mp3DObj ) + { + aSet.Put(mp3DObj->GetMergedItemSet()); + mpScene->RemoveObject( mp3DObj->GetOrdNum() ); + // always use SdrObject::Free(...) for SdrObjects (!) + SdrObject* pTemp(mp3DObj); + SdrObject::Free(pTemp); + } + + switch( nType ) + { + case SvxPreviewObjectType::SPHERE: + { + mp3DObj = new E3dSphereObj( + *mpModel, + mp3DView->Get3DDefaultAttributes(), + basegfx::B3DPoint( 0, 0, 0 ), + basegfx::B3DVector( 5000, 5000, 5000 )); + } + break; + + case SvxPreviewObjectType::CUBE: + { + mp3DObj = new E3dCubeObj( + *mpModel, + mp3DView->Get3DDefaultAttributes(), + basegfx::B3DPoint( -2500, -2500, -2500 ), + basegfx::B3DVector( 5000, 5000, 5000 )); + } + break; + } + + if (mp3DObj) + { + mpScene->InsertObject( mp3DObj ); + mp3DObj->SetMergedItemSet(aSet); + } + + Invalidate(); + } +} + +SfxItemSet const & Svx3DPreviewControl::Get3DAttributes() const +{ + return mp3DObj->GetMergedItemSet(); +} + +void Svx3DPreviewControl::Set3DAttributes( const SfxItemSet& rAttr ) +{ + mp3DObj->SetMergedItemSet(rAttr, true); + Resize(); + Invalidate(); +} + +#define RADIUS_LAMP_PREVIEW_SIZE (4500.0) +#define RADIUS_LAMP_SMALL (600.0) +#define RADIUS_LAMP_BIG (1000.0) +#define NO_LIGHT_SELECTED (0xffffffff) +#define MAX_NUMBER_LIGHTS (8) + +static const sal_Int32 g_nInteractionStartDistance = 5 * 5 * 2; + +Svx3DLightControl::Svx3DLightControl() +: maChangeCallback(), + maSelectionChangeCallback(), + maSelectedLight(NO_LIGHT_SELECTED), + mpExpansionObject(nullptr), + mpLampBottomObject(nullptr), + mpLampShaftObject(nullptr), + maLightObjects(MAX_NUMBER_LIGHTS, nullptr), + mfRotateX(-20.0), + mfRotateY(45.0), + mfRotateZ(0.0), + maActionStartPoint(), + mfSaveActionStartHor(0.0), + mfSaveActionStartVer(0.0), + mfSaveActionStartRotZ(0.0), + mbMouseMoved(false), + mbMouseCaptured(false), + mbGeometrySelected(false) +{ +} + +void Svx3DLightControl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + Svx3DPreviewControl::SetDrawingArea(pDrawingArea); + Construct2(); +} + +void Svx3DLightControl::Construct2() +{ + { + // hide all page stuff, use control background (normally gray) + const Color aDialogColor(Application::GetSettings().GetStyleSettings().GetDialogColor()); + mp3DView->SetPageVisible(false); + mp3DView->SetApplicationBackgroundColor(aDialogColor); + mp3DView->SetApplicationDocumentColor(aDialogColor); + } + + { + // create invisible expansion object + const double fMaxExpansion(RADIUS_LAMP_BIG + RADIUS_LAMP_PREVIEW_SIZE); + mpExpansionObject = new E3dCubeObj( + *mpModel, + mp3DView->Get3DDefaultAttributes(), + basegfx::B3DPoint(-fMaxExpansion, -fMaxExpansion, -fMaxExpansion), + basegfx::B3DVector(2.0 * fMaxExpansion, 2.0 * fMaxExpansion, 2.0 * fMaxExpansion)); + mpScene->InsertObject( mpExpansionObject ); + SfxItemSet aSet(mpModel->GetItemPool()); + aSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + aSet.Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + mpExpansionObject->SetMergedItemSet(aSet); + } + + { + // create lamp control object (Yellow lined object) + // base circle + const basegfx::B2DPolygon a2DCircle(basegfx::utils::createPolygonFromCircle(basegfx::B2DPoint(0.0, 0.0), RADIUS_LAMP_PREVIEW_SIZE)); + basegfx::B3DPolygon a3DCircle(basegfx::utils::createB3DPolygonFromB2DPolygon(a2DCircle)); + basegfx::B3DHomMatrix aTransform; + + aTransform.rotate(F_PI2, 0.0, 0.0); + aTransform.translate(0.0, -RADIUS_LAMP_PREVIEW_SIZE, 0.0); + a3DCircle.transform(aTransform); + + // create object for it + mpLampBottomObject = new E3dPolygonObj( + *mpModel, + basegfx::B3DPolyPolygon(a3DCircle)); + mpScene->InsertObject( mpLampBottomObject ); + + // half circle with stand + basegfx::B2DPolygon a2DHalfCircle; + a2DHalfCircle.append(basegfx::B2DPoint(RADIUS_LAMP_PREVIEW_SIZE, 0.0)); + a2DHalfCircle.append(basegfx::B2DPoint(RADIUS_LAMP_PREVIEW_SIZE, -RADIUS_LAMP_PREVIEW_SIZE)); + a2DHalfCircle.append(basegfx::utils::createPolygonFromEllipseSegment( + basegfx::B2DPoint(0.0, 0.0), RADIUS_LAMP_PREVIEW_SIZE, RADIUS_LAMP_PREVIEW_SIZE, F_2PI - F_PI2, F_PI2)); + basegfx::B3DPolygon a3DHalfCircle(basegfx::utils::createB3DPolygonFromB2DPolygon(a2DHalfCircle)); + + // create object for it + mpLampShaftObject = new E3dPolygonObj( + *mpModel, + basegfx::B3DPolyPolygon(a3DHalfCircle)); + mpScene->InsertObject( mpLampShaftObject ); + + // initially invisible + SfxItemSet aSet(mpModel->GetItemPool()); + aSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + aSet.Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + + mpLampBottomObject->SetMergedItemSet(aSet); + mpLampShaftObject->SetMergedItemSet(aSet); + } + + { + // change camera settings + Camera3D rCamera = mpScene->GetCamera(); + const basegfx::B3DRange& rVolume = mpScene->GetBoundVolume(); + double fW = rVolume.getWidth(); + double fH = rVolume.getHeight(); + double fCamZ = rVolume.getMaxZ() + ((fW + fH) / 2.0); + + rCamera.SetAutoAdjustProjection(false); + rCamera.SetViewWindow(- fW / 2, - fH / 2, fW, fH); + basegfx::B3DPoint aLookAt; + double fDefaultCamPosZ = mp3DView->GetDefaultCamPosZ(); + basegfx::B3DPoint aCamPos(0.0, 0.0, fCamZ < fDefaultCamPosZ ? fDefaultCamPosZ : fCamZ); + rCamera.SetPosAndLookAt(aCamPos, aLookAt); + double fDefaultCamFocal = mp3DView->GetDefaultCamFocal(); + rCamera.SetFocalLength(fDefaultCamFocal); + + mpScene->SetCamera( rCamera ); + + basegfx::B3DHomMatrix aNeutral; + mpScene->SetTransform(aNeutral); + } + + // invalidate SnapRects of objects + mpScene->SetRectsDirty(); +} + +void Svx3DLightControl::ConstructLightObjects() +{ + for(sal_uInt32 a(0); a < MAX_NUMBER_LIGHTS; a++) + { + // get rid of possible existing light object + if(maLightObjects[a]) + { + mpScene->RemoveObject(maLightObjects[a]->GetOrdNum()); + // always use SdrObject::Free(...) for SdrObjects (!) + SdrObject* pTemp(maLightObjects[a]); + SdrObject::Free(pTemp); + maLightObjects[a] = nullptr; + } + + if(GetLightOnOff(a)) + { + const bool bIsSelectedLight(a == maSelectedLight); + basegfx::B3DVector aDirection(GetLightDirection(a)); + aDirection.normalize(); + aDirection *= RADIUS_LAMP_PREVIEW_SIZE; + + const double fLampSize(bIsSelectedLight ? RADIUS_LAMP_BIG : RADIUS_LAMP_SMALL); + E3dObject* pNewLight = new E3dSphereObj( + *mpModel, + mp3DView->Get3DDefaultAttributes(), + basegfx::B3DPoint( 0, 0, 0 ), + basegfx::B3DVector( fLampSize, fLampSize, fLampSize)); + mpScene->InsertObject(pNewLight); + + basegfx::B3DHomMatrix aTransform; + aTransform.translate(aDirection.getX(), aDirection.getY(), aDirection.getZ()); + pNewLight->SetTransform(aTransform); + + SfxItemSet aSet(mpModel->GetItemPool()); + aSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + aSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) ); + aSet.Put( XFillColorItem(OUString(), GetLightColor(a))); + pNewLight->SetMergedItemSet(aSet); + + maLightObjects[a] = pNewLight; + } + } +} + +void Svx3DLightControl::AdaptToSelectedLight() +{ + if(NO_LIGHT_SELECTED == maSelectedLight) + { + // make mpLampBottomObject/mpLampShaftObject invisible + SfxItemSet aSet(mpModel->GetItemPool()); + aSet.Put( XLineStyleItem( drawing::LineStyle_NONE ) ); + aSet.Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + mpLampBottomObject->SetMergedItemSet(aSet); + mpLampShaftObject->SetMergedItemSet(aSet); + } + else + { + basegfx::B3DVector aDirection(GetLightDirection(maSelectedLight)); + aDirection.normalize(); + + // make mpLampBottomObject/mpLampShaftObject visible (yellow hairline) + SfxItemSet aSet(mpModel->GetItemPool()); + aSet.Put( XLineStyleItem( drawing::LineStyle_SOLID ) ); + aSet.Put( XLineColorItem(OUString(), COL_YELLOW)); + aSet.Put( XLineWidthItem(0)); + aSet.Put( XFillStyleItem( drawing::FillStyle_NONE ) ); + mpLampBottomObject->SetMergedItemSet(aSet); + mpLampShaftObject->SetMergedItemSet(aSet); + + // adapt transformation of mpLampShaftObject + basegfx::B3DHomMatrix aTransform; + double fRotateY(0.0); + + if(!basegfx::fTools::equalZero(aDirection.getZ()) || !basegfx::fTools::equalZero(aDirection.getX())) + { + fRotateY = atan2(-aDirection.getZ(), aDirection.getX()); + } + + aTransform.rotate(0.0, fRotateY, 0.0); + mpLampShaftObject->SetTransform(aTransform); + + // adapt transformation of selected light + E3dObject* pSelectedLight = maLightObjects[sal_Int32(maSelectedLight)]; + + if(pSelectedLight) + { + aTransform.identity(); + aTransform.translate( + aDirection.getX() * RADIUS_LAMP_PREVIEW_SIZE, + aDirection.getY() * RADIUS_LAMP_PREVIEW_SIZE, + aDirection.getZ() * RADIUS_LAMP_PREVIEW_SIZE); + pSelectedLight->SetTransform(aTransform); + } + } +} + +void Svx3DLightControl::TrySelection(Point aPosPixel) +{ + if(mpScene) + { + const Point aPosLogic(GetDrawingArea()->get_ref_device().PixelToLogic(aPosPixel)); + const basegfx::B2DPoint aPoint(aPosLogic.X(), aPosLogic.Y()); + std::vector< const E3dCompoundObject* > aResult; + getAllHit3DObjectsSortedFrontToBack(aPoint, *mpScene, aResult); + + if(!aResult.empty()) + { + // exclude expansion object which will be part of + // the hits. It's invisible, but for HitTest, it's included + const E3dCompoundObject* pResult = nullptr; + + for(auto const & b: aResult) + { + if(b && b != mpExpansionObject) + { + pResult = b; + break; + } + } + + if(pResult == mp3DObj) + { + if(!mbGeometrySelected) + { + mbGeometrySelected = true; + maSelectedLight = NO_LIGHT_SELECTED; + ConstructLightObjects(); + AdaptToSelectedLight(); + Invalidate(); + + if(maSelectionChangeCallback.IsSet()) + { + maSelectionChangeCallback.Call(this); + } + } + } + else + { + sal_uInt32 aNewSelectedLight(NO_LIGHT_SELECTED); + + for(sal_uInt32 a(0); a < MAX_NUMBER_LIGHTS; a++) + { + if(maLightObjects[a] && maLightObjects[a] == pResult) + { + aNewSelectedLight = a; + } + } + + if(aNewSelectedLight != maSelectedLight) + { + SelectLight(aNewSelectedLight); + + if(maSelectionChangeCallback.IsSet()) + { + maSelectionChangeCallback.Call(this); + } + } + } + } + } +} + +void Svx3DLightControl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) +{ + Svx3DPreviewControl::Paint(rRenderContext, rRect); +} + +tools::Rectangle Svx3DLightControl::GetFocusRect() +{ + if (!HasFocus()) + return tools::Rectangle(); + Size aFocusSize = GetOutputSizePixel(); + aFocusSize.AdjustWidth( -4 ); + aFocusSize.AdjustHeight( -4 ); + return tools::Rectangle(Point(2, 2), aFocusSize); +} + +bool Svx3DLightControl::MouseButtonDown( const MouseEvent& rMEvt ) +{ + bool bCallParent(true); + + // switch state + if(rMEvt.IsLeft()) + { + if(IsSelectionValid() || mbGeometrySelected) + { + mbMouseMoved = false; + bCallParent = false; + maActionStartPoint = rMEvt.GetPosPixel(); + CaptureMouse(); + mbMouseCaptured = true; + } + else + { + // Single click without moving much trying to do a selection + TrySelection(rMEvt.GetPosPixel()); + bCallParent = false; + } + } + + // call parent + if (bCallParent) + return Svx3DPreviewControl::MouseButtonDown(rMEvt); + return true; +} + +bool Svx3DLightControl::MouseMove(const MouseEvent& rMEvt) +{ + if (!mbMouseCaptured) + return false; + + Point aDeltaPos = rMEvt.GetPosPixel() - maActionStartPoint; + + if(!mbMouseMoved) + { + if(sal_Int32(aDeltaPos.X() * aDeltaPos.X() + aDeltaPos.Y() * aDeltaPos.Y()) > g_nInteractionStartDistance) + { + if(mbGeometrySelected) + { + GetRotation(mfSaveActionStartVer, mfSaveActionStartHor, mfSaveActionStartRotZ); + } + else + { + // interaction start, save values + GetPosition(mfSaveActionStartHor, mfSaveActionStartVer); + } + + mbMouseMoved = true; + } + } + + if(mbMouseMoved) + { + if(mbGeometrySelected) + { + double fNewRotX = mfSaveActionStartVer - basegfx::deg2rad(aDeltaPos.Y()); + double fNewRotY = mfSaveActionStartHor + basegfx::deg2rad(aDeltaPos.X()); + + // cut horizontal + while(fNewRotY < 0.0) + { + fNewRotY += F_2PI; + } + + while(fNewRotY >= F_2PI) + { + fNewRotY -= F_2PI; + } + + // cut vertical + if(fNewRotX < -F_PI2) + { + fNewRotX = -F_PI2; + } + + if(fNewRotX > F_PI2) + { + fNewRotX = F_PI2; + } + + SetRotation(fNewRotX, fNewRotY, mfSaveActionStartRotZ); + + if(maChangeCallback.IsSet()) + { + maChangeCallback.Call(this); + } + } + else + { + // interaction in progress + double fNewPosHor = mfSaveActionStartHor + static_cast<double>(aDeltaPos.X()); + double fNewPosVer = mfSaveActionStartVer - static_cast<double>(aDeltaPos.Y()); + + // cut horizontal + fNewPosHor = NormAngle360(fNewPosHor); + + // cut vertical + if(fNewPosVer < -90.0) + { + fNewPosVer = -90.0; + } + + if(fNewPosVer > 90.0) + { + fNewPosVer = 90.0; + } + + SetPosition(fNewPosHor, fNewPosVer); + + if(maChangeCallback.IsSet()) + { + maChangeCallback.Call(this); + } + } + } + return true; +} + +bool Svx3DLightControl::MouseButtonUp(const MouseEvent& rMEvt) +{ + if (!mbMouseCaptured) + return false; + ReleaseMouse(); + mbMouseCaptured = false; + + if (mbMouseMoved) + { + // was change interactively + } + else + { + // simple click without much movement, try selection + TrySelection(rMEvt.GetPosPixel()); + } + + return true; +} + +void Svx3DLightControl::Resize() +{ + // set size of page + const Size aSize(GetDrawingArea()->get_ref_device().PixelToLogic(GetOutputSizePixel())); + mpFmPage->SetSize(aSize); + + // set position and size of scene + mpScene->SetSnapRect(tools::Rectangle(Point(0, 0), aSize)); +} + +void Svx3DLightControl::SetObjectType(SvxPreviewObjectType nType) +{ + // call parent + Svx3DPreviewControl::SetObjectType(nType); + + // apply object rotation + if(mp3DObj) + { + basegfx::B3DHomMatrix aObjectRotation; + aObjectRotation.rotate(mfRotateX, mfRotateY, mfRotateZ); + mp3DObj->SetTransform(aObjectRotation); + } +} + +bool Svx3DLightControl::IsSelectionValid() +{ + return (NO_LIGHT_SELECTED != maSelectedLight) && GetLightOnOff(maSelectedLight); +} + +void Svx3DLightControl::GetPosition(double& rHor, double& rVer) +{ + if(IsSelectionValid()) + { + basegfx::B3DVector aDirection(GetLightDirection(maSelectedLight)); + aDirection.normalize(); + rHor = basegfx::rad2deg(atan2(-aDirection.getX(), -aDirection.getZ()) + F_PI); // 0..360.0 + rVer = basegfx::rad2deg(atan2(aDirection.getY(), aDirection.getXZLength())); // -90.0..90.0 + } + if(IsGeometrySelected()) + { + rHor = basegfx::rad2deg(mfRotateY); // 0..360.0 + rVer = basegfx::rad2deg(mfRotateX); // -90.0..90.0 + } +} + +void Svx3DLightControl::SetPosition(double fHor, double fVer) +{ + if(IsSelectionValid()) + { + // set selected light's direction + fHor = basegfx::deg2rad(fHor) - F_PI; // -PI..PI + fVer = basegfx::deg2rad(fVer); // -PI2..PI2 + basegfx::B3DVector aDirection(cos(fVer) * -sin(fHor), sin(fVer), cos(fVer) * -cos(fHor)); + aDirection.normalize(); + + if(!aDirection.equal(GetLightDirection(maSelectedLight))) + { + // set changed light direction at SdrScene + SfxItemSet aSet(mpModel->GetItemPool()); + + switch(maSelectedLight) + { + case 0: aSet.Put(makeSvx3DLightDirection1Item(aDirection)); break; + case 1: aSet.Put(makeSvx3DLightDirection2Item(aDirection)); break; + case 2: aSet.Put(makeSvx3DLightDirection3Item(aDirection)); break; + case 3: aSet.Put(makeSvx3DLightDirection4Item(aDirection)); break; + case 4: aSet.Put(makeSvx3DLightDirection5Item(aDirection)); break; + case 5: aSet.Put(makeSvx3DLightDirection6Item(aDirection)); break; + case 6: aSet.Put(makeSvx3DLightDirection7Item(aDirection)); break; + default: + case 7: aSet.Put(makeSvx3DLightDirection8Item(aDirection)); break; + } + + mpScene->SetMergedItemSet(aSet); + + // correct 3D light's and LampFrame's geometries + AdaptToSelectedLight(); + Invalidate(); + } + } + if(IsGeometrySelected()) + { + if(mfRotateX != fVer || mfRotateY != fHor) + { + mfRotateX = basegfx::deg2rad(fVer); + mfRotateY = basegfx::deg2rad(fHor); + + if(mp3DObj) + { + basegfx::B3DHomMatrix aObjectRotation; + aObjectRotation.rotate(mfRotateX, mfRotateY, mfRotateZ); + mp3DObj->SetTransform(aObjectRotation); + + Invalidate(); + } + } + } +} + +void Svx3DLightControl::SetRotation(double fRotX, double fRotY, double fRotZ) +{ + if(IsGeometrySelected()) + { + if(fRotX != mfRotateX || fRotY != mfRotateY || fRotZ != mfRotateZ) + { + mfRotateX = fRotX; + mfRotateY = fRotY; + mfRotateZ = fRotZ; + + if(mp3DObj) + { + basegfx::B3DHomMatrix aObjectRotation; + aObjectRotation.rotate(mfRotateX, mfRotateY, mfRotateZ); + mp3DObj->SetTransform(aObjectRotation); + + Invalidate(); + } + } + } +} + +void Svx3DLightControl::GetRotation(double& rRotX, double& rRotY, double& rRotZ) +{ + rRotX = mfRotateX; + rRotY = mfRotateY; + rRotZ = mfRotateZ; +} + +void Svx3DLightControl::Set3DAttributes( const SfxItemSet& rAttr ) +{ + // call parent + Svx3DPreviewControl::Set3DAttributes(rAttr); + + if(maSelectedLight != NO_LIGHT_SELECTED && !GetLightOnOff(maSelectedLight)) + { + // selected light is no more active, select new one + maSelectedLight = NO_LIGHT_SELECTED; + } + + // local updates + ConstructLightObjects(); + AdaptToSelectedLight(); + Invalidate(); +} + +void Svx3DLightControl::SelectLight(sal_uInt32 nLightNumber) +{ + if(nLightNumber > 7) + { + nLightNumber = NO_LIGHT_SELECTED; + } + + if(NO_LIGHT_SELECTED != nLightNumber) + { + if(!GetLightOnOff(nLightNumber)) + { + nLightNumber = NO_LIGHT_SELECTED; + } + } + + if(nLightNumber != maSelectedLight) + { + maSelectedLight = nLightNumber; + mbGeometrySelected = false; + ConstructLightObjects(); + AdaptToSelectedLight(); + Invalidate(); + } +} + +bool Svx3DLightControl::GetLightOnOff(sal_uInt32 nNum) const +{ + if(nNum <= 7) + { + const SfxItemSet aLightItemSet(Get3DAttributes()); + + switch(nNum) + { + case 0 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_1).GetValue(); + case 1 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_2).GetValue(); + case 2 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_3).GetValue(); + case 3 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_4).GetValue(); + case 4 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_5).GetValue(); + case 5 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_6).GetValue(); + case 6 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_7).GetValue(); + case 7 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_8).GetValue(); + } + } + + return false; +} + +Color Svx3DLightControl::GetLightColor(sal_uInt32 nNum) const +{ + if(nNum <= 7) + { + const SfxItemSet aLightItemSet(Get3DAttributes()); + + switch(nNum) + { + case 0 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1).GetValue(); + case 1 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2).GetValue(); + case 2 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3).GetValue(); + case 3 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4).GetValue(); + case 4 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5).GetValue(); + case 5 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6).GetValue(); + case 6 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7).GetValue(); + case 7 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8).GetValue(); + } + } + + return COL_BLACK; +} + +basegfx::B3DVector Svx3DLightControl::GetLightDirection(sal_uInt32 nNum) const +{ + if(nNum <= 7) + { + const SfxItemSet aLightItemSet(Get3DAttributes()); + + switch(nNum) + { + case 0 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1).GetValue(); + case 1 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2).GetValue(); + case 2 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3).GetValue(); + case 3 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4).GetValue(); + case 4 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5).GetValue(); + case 5 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6).GetValue(); + case 6 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7).GetValue(); + case 7 : return aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8).GetValue(); + } + } + + return basegfx::B3DVector(); +} + +SvxLightCtl3D::SvxLightCtl3D(Svx3DLightControl& rLightControl, weld::Scale& rHori, + weld::Scale& rVert, weld::Button& rSwitcher) + : mrLightControl(rLightControl) + , mrHorScroller(rHori) + , mrVerScroller(rVert) + , mrSwitcher(rSwitcher) +{ + // init members + Init(); +} + +void SvxLightCtl3D::Init() +{ + Size aSize(mrLightControl.GetDrawingArea()->get_ref_device().LogicToPixel(Size(80, 100), MapMode(MapUnit::MapAppFont))); + mrLightControl.set_size_request(aSize.Width(), aSize.Height()); + + // #i58240# set HelpIDs for scrollbars and switcher + mrHorScroller.set_help_id(HID_CTRL3D_HSCROLL); + mrVerScroller.set_help_id(HID_CTRL3D_VSCROLL); + mrSwitcher.set_help_id(HID_CTRL3D_SWITCHER); + mrSwitcher.set_accessible_name(SvxResId(STR_SWITCH)); + + // Light preview + mrLightControl.Show(); + mrLightControl.SetChangeCallback( LINK(this, SvxLightCtl3D, InternalInteractiveChange) ); + mrLightControl.SetSelectionChangeCallback( LINK(this, SvxLightCtl3D, InternalSelectionChange) ); + + // Horiz Scrollbar + mrHorScroller.show(); + mrHorScroller.set_range(0, 36000); + mrHorScroller.connect_value_changed( LINK(this, SvxLightCtl3D, ScrollBarMove) ); + + // Vert Scrollbar + mrVerScroller.show(); + mrVerScroller.set_range(0, 18000); + mrVerScroller.connect_value_changed( LINK(this, SvxLightCtl3D, ScrollBarMove) ); + + // Switch Button + mrSwitcher.show(); + mrSwitcher.connect_clicked( LINK(this, SvxLightCtl3D, ButtonPress) ); + + weld::DrawingArea* pArea = mrLightControl.GetDrawingArea(); + pArea->connect_key_press(Link<const KeyEvent&, bool>()); //acknowledge we first remove the old one + pArea->connect_key_press(LINK(this, SvxLightCtl3D, KeyInput)); + + pArea->connect_focus_in(Link<weld::Widget&, void>()); //acknowledge we first remove the old one + pArea->connect_focus_in(LINK(this, SvxLightCtl3D, FocusIn)); + + // check selection + CheckSelection(); +} + +SvxLightCtl3D::~SvxLightCtl3D() +{ +} + +void SvxLightCtl3D::CheckSelection() +{ + const bool bSelectionValid(mrLightControl.IsSelectionValid() || mrLightControl.IsGeometrySelected()); + mrHorScroller.set_sensitive(bSelectionValid); + mrVerScroller.set_sensitive(bSelectionValid); + + if (bSelectionValid) + { + double fHor(0.0), fVer(0.0); + mrLightControl.GetPosition(fHor, fVer); + mrHorScroller.set_value( sal_Int32(fHor * 100.0) ); + mrVerScroller.set_value( 18000 - sal_Int32((fVer + 90.0) * 100.0) ); + } +} + +void SvxLightCtl3D::move( double fDeltaHor, double fDeltaVer ) +{ + double fHor(0.0), fVer(0.0); + + mrLightControl.GetPosition(fHor, fVer); + fHor += fDeltaHor; + fVer += fDeltaVer; + + if( fVer > 90.0 ) + return; + + if ( fVer < -90.0 ) + return; + + mrLightControl.SetPosition(fHor, fVer); + mrHorScroller.set_value( sal_Int32(fHor * 100.0) ); + mrVerScroller.set_value( 18000 - sal_Int32((fVer + 90.0) * 100.0) ); + + if(maUserInteractiveChangeCallback.IsSet()) + { + maUserInteractiveChangeCallback.Call(this); + } +} + +IMPL_LINK(SvxLightCtl3D, KeyInput, const KeyEvent&, rKEvt, bool) +{ + const vcl::KeyCode aCode(rKEvt.GetKeyCode()); + + if (aCode.GetModifier()) + return false; + + bool bHandled = true; + + switch ( aCode.GetCode() ) + { + case KEY_SPACE: + { + break; + } + case KEY_LEFT: + { + move( -4.0, 0.0 ); // #i58242# changed move direction in X + break; + } + case KEY_RIGHT: + { + move( 4.0, 0.0 ); // #i58242# changed move direction in X + break; + } + case KEY_UP: + { + move( 0.0, 4.0 ); + break; + } + case KEY_DOWN: + { + move( 0.0, -4.0 ); + break; + } + case KEY_PAGEUP: + { + sal_Int32 nLight(mrLightControl.GetSelectedLight() - 1); + + while((nLight >= 0) && !mrLightControl.GetLightOnOff(nLight)) + { + nLight--; + } + + if(nLight < 0) + { + nLight = 7; + + while((nLight >= 0) && !mrLightControl.GetLightOnOff(nLight)) + { + nLight--; + } + } + + if(nLight >= 0) + { + mrLightControl.SelectLight(nLight); + CheckSelection(); + + if(maUserSelectionChangeCallback.IsSet()) + { + maUserSelectionChangeCallback.Call(this); + } + } + + break; + } + case KEY_PAGEDOWN: + { + sal_Int32 nLight(mrLightControl.GetSelectedLight() - 1); + + while(nLight <= 7 && !mrLightControl.GetLightOnOff(nLight)) + { + nLight++; + } + + if(nLight > 7) + { + nLight = 0; + + while(nLight <= 7 && !mrLightControl.GetLightOnOff(nLight)) + { + nLight++; + } + } + + if(nLight <= 7) + { + mrLightControl.SelectLight(nLight); + CheckSelection(); + + if(maUserSelectionChangeCallback.IsSet()) + { + maUserSelectionChangeCallback.Call(this); + } + } + + break; + } + default: + { + bHandled = false; + break; + } + } + return bHandled; +} + +IMPL_LINK_NOARG(SvxLightCtl3D, FocusIn, weld::Widget&, void) +{ + if (mrLightControl.IsEnabled()) + { + CheckSelection(); + } +} + +IMPL_LINK_NOARG(SvxLightCtl3D, ScrollBarMove, weld::Scale&, void) +{ + const sal_Int32 nHor(mrHorScroller.get_value()); + const sal_Int32 nVer(mrVerScroller.get_value()); + + mrLightControl.SetPosition( + static_cast<double>(nHor) / 100.0, + static_cast<double>((18000 - nVer) - 9000) / 100.0); + + if (maUserInteractiveChangeCallback.IsSet()) + { + maUserInteractiveChangeCallback.Call(this); + } +} + +IMPL_LINK_NOARG(SvxLightCtl3D, ButtonPress, weld::Button&, void) +{ + if(SvxPreviewObjectType::SPHERE == GetSvx3DLightControl().GetObjectType()) + { + GetSvx3DLightControl().SetObjectType(SvxPreviewObjectType::CUBE); + } + else + { + GetSvx3DLightControl().SetObjectType(SvxPreviewObjectType::SPHERE); + } +} + +IMPL_LINK_NOARG(SvxLightCtl3D, InternalInteractiveChange, Svx3DLightControl*, void) +{ + double fHor(0.0), fVer(0.0); + + mrLightControl.GetPosition(fHor, fVer); + mrHorScroller.set_value( sal_Int32(fHor * 100.0) ); + mrVerScroller.set_value( 18000 - sal_Int32((fVer + 90.0) * 100.0) ); + + if(maUserInteractiveChangeCallback.IsSet()) + { + maUserInteractiveChangeCallback.Call(this); + } +} + +IMPL_LINK_NOARG(SvxLightCtl3D, InternalSelectionChange, Svx3DLightControl*, void) +{ + CheckSelection(); + + if(maUserSelectionChangeCallback.IsSet()) + { + maUserSelectionChangeCallback.Call(this); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/dlgctrl.cxx b/svx/source/dialog/dlgctrl.cxx new file mode 100644 index 000000000..75f9319fc --- /dev/null +++ b/svx/source/dialog/dlgctrl.cxx @@ -0,0 +1,1459 @@ +/* -*- 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/settings.hxx> +#include <vcl/virdev.hxx> +#include <vcl/event.hxx> +#include <sfx2/dialoghelper.hxx> +#include <sfx2/weldutils.hxx> +#include <svx/relfld.hxx> +#include <svx/xlineit0.hxx> +#include <svx/xtable.hxx> +#include <svx/strings.hrc> +#include <bitmaps.hlst> +#include <svx/dlgctrl.hxx> +#include <svx/dialmgr.hxx> +#include <tools/debug.hxx> +#include <svxpixelctlaccessiblecontext.hxx> +#include <svtools/colorcfg.hxx> +#include <svxrectctaccessiblecontext.hxx> +#include <basegfx/point/b2dpoint.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <svx/svdorect.hxx> +#include <svx/svdmodel.hxx> +#include <svx/svdopath.hxx> +#include <sdr/contact/objectcontactofobjlistpainter.hxx> +#include <svx/sdr/contact/displayinfo.hxx> +#include <vcl/BitmapTools.hxx> + +#define OUTPUT_DRAWMODE_COLOR (DrawModeFlags::Default) +#define OUTPUT_DRAWMODE_CONTRAST (DrawModeFlags::SettingsLine | DrawModeFlags::SettingsFill | DrawModeFlags::SettingsText | DrawModeFlags::SettingsGradient) + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::accessibility; + +// Control for display and selection of the corner points and +// mid point of an object + +BitmapEx& SvxRectCtl::GetRectBitmap() +{ + if( !pBitmap ) + InitRectBitmap(); + + return *pBitmap; +} + +SvxRectCtl::SvxRectCtl(SvxTabPage* pPage, RectPoint eRpt, sal_uInt16 nBorder) + : m_pPage(pPage) + , nBorderWidth(Application::GetDefaultDevice()->LogicToPixel(Size(nBorder, 0), MapMode(MapUnit::Map100thMM)).Width()) + , eRP(eRpt) + , eDefRP(eRpt) + , m_nState(CTL_STATE::NONE) + , mbCompleteDisable(false) +{ +} + +void SvxRectCtl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aSize(pDrawingArea->get_approximate_digit_width() * 25, + pDrawingArea->get_text_height() * 5); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + Resize_Impl(aSize); +} + +void SvxRectCtl::SetControlSettings(RectPoint eRpt, sal_uInt16 nBorder) +{ + nBorderWidth = Application::GetDefaultDevice()->LogicToPixel(Size(nBorder, 0), MapMode(MapUnit::Map100thMM)).Width(); + eDefRP = eRpt; + Resize(); +} + +SvxRectCtl::~SvxRectCtl() +{ + pBitmap.reset(); + pAccContext.clear(); +} + +void SvxRectCtl::Resize() +{ + Resize_Impl(GetOutputSizePixel()); +} + +void SvxRectCtl::Resize_Impl(const Size &rSize) +{ + aPtLT = Point( 0 + nBorderWidth, 0 + nBorderWidth ); + aPtMT = Point( rSize.Width() / 2, 0 + nBorderWidth ); + aPtRT = Point( rSize.Width() - nBorderWidth, 0 + nBorderWidth ); + + aPtLM = Point( 0 + nBorderWidth, rSize.Height() / 2 ); + aPtMM = Point( rSize.Width() / 2, rSize.Height() / 2 ); + aPtRM = Point( rSize.Width() - nBorderWidth, rSize.Height() / 2 ); + + aPtLB = Point( 0 + nBorderWidth, rSize.Height() - nBorderWidth ); + aPtMB = Point( rSize.Width() / 2, rSize.Height() - nBorderWidth ); + aPtRB = Point( rSize.Width() - nBorderWidth, rSize.Height() - nBorderWidth ); + + Reset(); + StyleUpdated(); +} + +void SvxRectCtl::InitRectBitmap() +{ + pBitmap.reset(); + + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + svtools::ColorConfig aColorConfig; + + pBitmap.reset(new BitmapEx(RID_SVXCTRL_RECTBTNS)); + + // set bitmap-colors + Color aColorAry1[7]; + Color aColorAry2[7]; + aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 ); // light-gray + aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 ); // yellow + aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF ); // white + aColorAry1[3] = Color( 0x80, 0x80, 0x80 ); // dark-gray + aColorAry1[4] = Color( 0x00, 0x00, 0x00 ); // black + aColorAry1[5] = Color( 0x00, 0xFF, 0x00 ); // green + aColorAry1[6] = Color( 0x00, 0x00, 0xFF ); // blue + aColorAry2[0] = rStyles.GetDialogColor(); // background + aColorAry2[1] = rStyles.GetWindowColor(); + aColorAry2[2] = rStyles.GetLightColor(); + aColorAry2[3] = rStyles.GetShadowColor(); + aColorAry2[4] = rStyles.GetDarkShadowColor(); + aColorAry2[5] = aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor; + aColorAry2[6] = rStyles.GetDialogColor(); + +#ifdef DBG_UTIL + static bool bModify = false; + bool& rModify = bModify; + if( rModify ) + { + static int n = 0; + static sal_uInt8 r = 0xFF; + static sal_uInt8 g = 0x00; + static sal_uInt8 b = 0xFF; + int& rn = n; + sal_uInt8& rr = r; + sal_uInt8& rg = g; + sal_uInt8& rb = b; + aColorAry2[ rn ] = Color( rr, rg, rb ); + } +#endif + + pBitmap->Replace( aColorAry1, aColorAry2, 7 ); +} + +void SvxRectCtl::StyleUpdated() +{ + pBitmap.reset(); // forces new creating of bitmap + CustomWidgetController::StyleUpdated(); +} + +void SvxRectCtl::InitSettings(vcl::RenderContext& rRenderContext) +{ + svtools::ColorConfig aColorConfig; + Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + rRenderContext.SetTextColor(aTextColor); + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + rRenderContext.SetBackground(rStyleSettings.GetWindowColor()); +} + +// The clicked rectangle (3 x 3) is determined and the parent (dialog) +// is notified that the item was changed +bool SvxRectCtl::MouseButtonDown(const MouseEvent& rMEvt) +{ + // CompletelyDisabled() added to have a disabled state for SvxRectCtl + if(!IsCompletelyDisabled()) + { + aPtNew = GetApproxLogPtFromPixPt( rMEvt.GetPosPixel() ); + eRP = GetRPFromPoint( aPtNew ); + SetActualRP( eRP ); + + if (m_pPage) + m_pPage->PointChanged(GetDrawingArea(), eRP); + } + return true; +} + +bool SvxRectCtl::KeyInput(const KeyEvent& rKeyEvt) +{ + // CompletelyDisabled() added to have a disabled state for SvxRectCtl + if (IsCompletelyDisabled()) + return false; + + RectPoint eNewRP = eRP; + + switch( rKeyEvt.GetKeyCode().GetCode() ) + { + case KEY_DOWN: + { + if( !(m_nState & CTL_STATE::NOVERT) ) + switch( eNewRP ) + { + case RectPoint::LT: eNewRP = RectPoint::LM; break; + case RectPoint::MT: eNewRP = RectPoint::MM; break; + case RectPoint::RT: eNewRP = RectPoint::RM; break; + case RectPoint::LM: eNewRP = RectPoint::LB; break; + case RectPoint::MM: eNewRP = RectPoint::MB; break; + case RectPoint::RM: eNewRP = RectPoint::RB; break; + default: ; //prevent warning + } + } + break; + case KEY_UP: + { + if( !(m_nState & CTL_STATE::NOVERT) ) + switch( eNewRP ) + { + case RectPoint::LM: eNewRP = RectPoint::LT; break; + case RectPoint::MM: eNewRP = RectPoint::MT; break; + case RectPoint::RM: eNewRP = RectPoint::RT; break; + case RectPoint::LB: eNewRP = RectPoint::LM; break; + case RectPoint::MB: eNewRP = RectPoint::MM; break; + case RectPoint::RB: eNewRP = RectPoint::RM; break; + default: ; //prevent warning + } + } + break; + case KEY_LEFT: + { + if( !(m_nState & CTL_STATE::NOHORZ) ) + switch( eNewRP ) + { + case RectPoint::MT: eNewRP = RectPoint::LT; break; + case RectPoint::RT: eNewRP = RectPoint::MT; break; + case RectPoint::MM: eNewRP = RectPoint::LM; break; + case RectPoint::RM: eNewRP = RectPoint::MM; break; + case RectPoint::MB: eNewRP = RectPoint::LB; break; + case RectPoint::RB: eNewRP = RectPoint::MB; break; + default: ; //prevent warning + } + } + break; + case KEY_RIGHT: + { + if( !(m_nState & CTL_STATE::NOHORZ) ) + switch( eNewRP ) + { + case RectPoint::LT: eNewRP = RectPoint::MT; break; + case RectPoint::MT: eNewRP = RectPoint::RT; break; + case RectPoint::LM: eNewRP = RectPoint::MM; break; + case RectPoint::MM: eNewRP = RectPoint::RM; break; + case RectPoint::LB: eNewRP = RectPoint::MB; break; + case RectPoint::MB: eNewRP = RectPoint::RB; break; + default: ; //prevent warning + } + } + break; + default: + return false; + } + if( eNewRP != eRP ) + { + SetActualRP( eNewRP ); + + if (m_pPage) + m_pPage->PointChanged(GetDrawingArea(), eRP); + } + return true; +} + +// the control (rectangle with 9 circles) +void SvxRectCtl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + InitSettings(rRenderContext); + + Point aPtDiff(1, 1); + + const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings(); + + rRenderContext.SetLineColor(rStyles.GetDialogColor()); + rRenderContext.SetFillColor(rStyles.GetDialogColor()); + rRenderContext.DrawRect(tools::Rectangle(Point(0,0), rRenderContext.GetOutputSize())); + + if (IsEnabled()) + rRenderContext.SetLineColor(rStyles.GetLabelTextColor()); + else + rRenderContext.SetLineColor(rStyles.GetShadowColor()); + + rRenderContext.SetFillColor(); + + if (!IsEnabled()) + { + Color aOldCol = rRenderContext.GetLineColor(); + rRenderContext.SetLineColor(rStyles.GetLightColor()); + rRenderContext.DrawRect(tools::Rectangle(aPtLT + aPtDiff, aPtRB + aPtDiff)); + rRenderContext.SetLineColor(aOldCol); + } + rRenderContext.DrawRect(tools::Rectangle(aPtLT, aPtRB)); + + rRenderContext.SetFillColor(rRenderContext.GetBackground().GetColor()); + + Size aBtnSize(11, 11); + Size aDstBtnSize(aBtnSize); + Point aToCenter(aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1); + Point aBtnPnt1(IsEnabled() ? 0 : 22, 0); + Point aBtnPnt2(11, 0); + Point aBtnPnt3(22, 0); + + bool bNoHorz = bool(m_nState & CTL_STATE::NOHORZ); + bool bNoVert = bool(m_nState & CTL_STATE::NOVERT); + + BitmapEx& rBitmap = GetRectBitmap(); + + // CompletelyDisabled() added to have a disabled state for SvxRectCtl + if (IsCompletelyDisabled()) + { + rRenderContext.DrawBitmapEx(aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtMT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtRT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtLM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtMM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtRM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtLB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtMB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtRB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap); + } + else + { + rRenderContext.DrawBitmapEx(aPtLT - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtMT - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtRT - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + + // Center for rectangle and line + rRenderContext.DrawBitmapEx(aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap); + + rRenderContext.DrawBitmapEx(aPtRM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtLB - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtMB - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + rRenderContext.DrawBitmapEx(aPtRB - aToCenter, aDstBtnSize, (bNoHorz || bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap); + } + + // draw active button, avoid center pos for angle + // CompletelyDisabled() added to have a disabled state for SvxRectCtl + if (!IsCompletelyDisabled()) + { + if (IsEnabled()) + { + Point aCenterPt(aPtNew); + aCenterPt -= aToCenter; + + rRenderContext.DrawBitmapEx(aCenterPt, aDstBtnSize, aBtnPnt2, aBtnSize, rBitmap); + } + } +} + +tools::Rectangle SvxRectCtl::GetFocusRect() +{ + tools::Rectangle aRet; + if (HasFocus()) + aRet = CalculateFocusRectangle(); + return aRet; +} + +// Convert RectPoint Point + +const Point& SvxRectCtl::GetPointFromRP( RectPoint _eRP) const +{ + switch( _eRP ) + { + case RectPoint::LT: return aPtLT; + case RectPoint::MT: return aPtMT; + case RectPoint::RT: return aPtRT; + case RectPoint::LM: return aPtLM; + case RectPoint::MM: return aPtMM; + case RectPoint::RM: return aPtRM; + case RectPoint::LB: return aPtLB; + case RectPoint::MB: return aPtMB; + case RectPoint::RB: return aPtRB; + } + return aPtMM; // default +} + +Point SvxRectCtl::SetActualRPWithoutInvalidate( RectPoint eNewRP ) +{ + Point aPtLast = aPtNew; + aPtNew = GetPointFromRP( eNewRP ); + + if( m_nState & CTL_STATE::NOHORZ ) + aPtNew.setX( aPtMM.X() ); + + if( m_nState & CTL_STATE::NOVERT ) + aPtNew.setY( aPtMM.Y() ); + + // fdo#74751 this fix reverse base point on RTL UI. + bool bRTL = AllSettings::GetLayoutRTL(); + eNewRP = GetRPFromPoint( aPtNew, bRTL ); + + eDefRP = eNewRP; + eRP = eNewRP; + + return aPtLast; +} + +void SvxRectCtl::GetFocus() +{ + Invalidate(); + + // Send accessibility event. + if (pAccContext.is()) + { + pAccContext->FireChildFocus(GetActualRP()); + } +} + +void SvxRectCtl::LoseFocus() +{ + Invalidate(); +} + +Point SvxRectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const +{ + Point aPt = rPt; + long x; + long y; + + Size aSize(GetOutputSizePixel()); + + if( !( m_nState & CTL_STATE::NOHORZ ) ) + { + if( aPt.X() < aSize.Width() / 3 ) + x = aPtLT.X(); + else if( aPt.X() < aSize.Width() * 2 / 3 ) + x = aPtMM.X(); + else + x = aPtRB.X(); + } + else + x = aPtMM.X(); + + if( !( m_nState & CTL_STATE::NOVERT ) ) + { + if( aPt.Y() < aSize.Height() / 3 ) + y = aPtLT.Y(); + else if( aPt.Y() < aSize.Height() * 2 / 3 ) + y = aPtMM.Y(); + else + y = aPtRB.Y(); + } + else + y = aPtMM.Y(); + + return Point( x, y ); +} + + +// Converts Point in RectPoint + +RectPoint SvxRectCtl::GetRPFromPoint( Point aPt, bool bRTL ) const +{ + RectPoint rPoint = RectPoint::MM; // default + + if (aPt == aPtLT) rPoint = bRTL ? RectPoint::RT : RectPoint::LT; + else if( aPt == aPtMT) rPoint = RectPoint::MT; + else if( aPt == aPtRT) rPoint = bRTL ? RectPoint::LT : RectPoint::RT; + else if( aPt == aPtLM) rPoint = bRTL ? RectPoint::RM : RectPoint::LM; + else if( aPt == aPtRM) rPoint = bRTL ? RectPoint::LM : RectPoint::RM; + else if( aPt == aPtLB) rPoint = bRTL ? RectPoint::RB : RectPoint::LB; + else if( aPt == aPtMB) rPoint = RectPoint::MB; + else if( aPt == aPtRB) rPoint = bRTL ? RectPoint::LB : RectPoint::RB; + + return rPoint; +} + +// Resets to the original state of the control + +void SvxRectCtl::Reset() +{ + aPtNew = GetPointFromRP( eDefRP ); + eRP = eDefRP; + Invalidate(); +} + +// Returns the currently selected RectPoint + + +void SvxRectCtl::SetActualRP( RectPoint eNewRP ) +{ + SetActualRPWithoutInvalidate(eNewRP); + + Invalidate(); + + // notify accessibility object about change + if (pAccContext.is()) + pAccContext->selectChild( eNewRP /* MT, bFireFocus */ ); +} + +void SvxRectCtl::SetState( CTL_STATE nState ) +{ + m_nState = nState; + + Point aPtLast( GetPointFromRP( eRP ) ); + Point _aPtNew( aPtLast ); + + if( m_nState & CTL_STATE::NOHORZ ) + _aPtNew.setX( aPtMM.X() ); + + if( m_nState & CTL_STATE::NOVERT) + _aPtNew.setY( aPtMM.Y() ); + + eRP = GetRPFromPoint( _aPtNew ); + Invalidate(); + + if (m_pPage) + m_pPage->PointChanged(GetDrawingArea(), eRP); +} + +tools::Rectangle SvxRectCtl::CalculateFocusRectangle() const +{ + Size aDstBtnSize(15, 15); + return tools::Rectangle( aPtNew - Point( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1 ), aDstBtnSize ); +} + +tools::Rectangle SvxRectCtl::CalculateFocusRectangle( RectPoint eRectPoint ) const +{ + tools::Rectangle aRet; + RectPoint eOldRectPoint = GetActualRP(); + + if( eOldRectPoint == eRectPoint ) + aRet = CalculateFocusRectangle(); + else + { + SvxRectCtl* pThis = const_cast<SvxRectCtl*>(this); + + pThis->SetActualRPWithoutInvalidate( eRectPoint ); // no invalidation because it's only temporary! + aRet = CalculateFocusRectangle(); + + pThis->SetActualRPWithoutInvalidate( eOldRectPoint ); // no invalidation because nothing has changed! + } + + return aRet; +} + +Reference< XAccessible > SvxRectCtl::CreateAccessible() +{ + pAccContext = new SvxRectCtlAccessibleContext(this); + return pAccContext.get(); +} + +RectPoint SvxRectCtl::GetApproxRPFromPixPt( const css::awt::Point& r ) const +{ + return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) ); +} + +// CompletelyDisabled() added to have a disabled state for SvxRectCtl +void SvxRectCtl::DoCompletelyDisable(bool bNew) +{ + mbCompleteDisable = bNew; + Invalidate(); +} + +// Control for editing bitmaps + +css::uno::Reference< css::accessibility::XAccessible > SvxPixelCtl::CreateAccessible() +{ + if (!m_xAccess.is()) + m_xAccess = new SvxPixelCtlAccessible(this); + return m_xAccess.get(); +} + +long SvxPixelCtl::PointToIndex(const Point &aPt) const +{ + long nX = aPt.X() * nLines / aRectSize.Width(); + long nY = aPt.Y() * nLines / aRectSize.Height(); + + return nX + nY * nLines ; +} + +Point SvxPixelCtl::IndexToPoint(long nIndex) const +{ + DBG_ASSERT(nIndex >= 0 && nIndex < nSquares ," Check Index"); + + sal_Int32 nXIndex = nIndex % nLines; + sal_Int32 nYIndex = nIndex / nLines; + + Point aPtTl; + aPtTl.setY( aRectSize.Height() * nYIndex / nLines + 1 ); + aPtTl.setX( aRectSize.Width() * nXIndex / nLines + 1 ); + + return aPtTl; +} + +long SvxPixelCtl::GetFocusPosIndex() const +{ + return aFocusPosition.getX() + aFocusPosition.getY() * nLines ; +} + +long SvxPixelCtl::ShowPosition( const Point &rPt) +{ + sal_Int32 nX = rPt.X() * nLines / aRectSize.Width(); + sal_Int32 nY = rPt.Y() * nLines / aRectSize.Height(); + + ChangePixel( nX + nY * nLines ); + + //Solution:Set new focus position and repaint + aFocusPosition.setX(nX); + aFocusPosition.setY(nY); + Invalidate(tools::Rectangle(Point(0,0),aRectSize)); + + if (m_pPage) + m_pPage->PointChanged(GetDrawingArea(), RectPoint::MM ); // RectPoint is dummy + + return GetFocusPosIndex(); + +} + +SvxPixelCtl::SvxPixelCtl(SvxTabPage* pPage) + : m_pPage(pPage) + , bPaintable(true) + , aFocusPosition(0,0) +{ + maPixelData.fill(0); +} + +void SvxPixelCtl::Resize() +{ + CustomWidgetController::Resize(); + aRectSize = GetOutputSizePixel(); +} + +void SvxPixelCtl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + pDrawingArea->set_size_request(pDrawingArea->get_approximate_digit_width() * 25, + pDrawingArea->get_text_height() * 10); +} + +SvxPixelCtl::~SvxPixelCtl() +{ +} + +// Changes the foreground or Background color + +void SvxPixelCtl::ChangePixel( sal_uInt16 nPixel ) +{ + if( maPixelData[nPixel] == 0 ) + maPixelData[nPixel] = 1; // could be extended to more colors + else + maPixelData[nPixel] = 0; +} + +// The clicked rectangle is identified, to change its color + +bool SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt ) +{ + if (!aRectSize.Width() || !aRectSize.Height()) + return true; + + //Grab focus when click in window + if (!HasFocus()) + { + GrabFocus(); + } + + long nIndex = ShowPosition(rMEvt.GetPosPixel()); + + if(m_xAccess.is()) + { + m_xAccess->NotifyChild(nIndex,true, true); + } + + return true; +} + +tools::Rectangle SvxPixelCtl::GetFocusRect() +{ + tools::Rectangle aRet; + //Draw visual focus when has focus + if (HasFocus()) + aRet = implCalFocusRect(aFocusPosition); + return aRet; +} + +// Draws the Control (Rectangle with nine circles) +void SvxPixelCtl::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& ) +{ + if (!aRectSize.Width() || !aRectSize.Height()) + return; + + sal_uInt16 i, j, nTmp; + Point aPtTl, aPtBr; + + if (bPaintable) + { + // Draw lines + rRenderContext.SetLineColor(Color()); + for (i = 1; i < nLines; i++) + { + // horizontal + nTmp = static_cast<sal_uInt16>(aRectSize.Height() * i / nLines); + rRenderContext.DrawLine(Point(0, nTmp), Point(aRectSize.Width(), nTmp)); + // vertically + nTmp = static_cast<sal_uInt16>( aRectSize.Width() * i / nLines ); + rRenderContext.DrawLine(Point(nTmp, 0), Point(nTmp, aRectSize.Height())); + } + + //Draw Rectangles (squares) + rRenderContext.SetLineColor(); + sal_uInt16 nLastPixel = maPixelData[0] ? 0 : 1; + + for (i = 0; i < nLines; i++) + { + aPtTl.setY( aRectSize.Height() * i / nLines + 1 ); + aPtBr.setY( aRectSize.Height() * (i + 1) / nLines - 1 ); + + for (j = 0; j < nLines; j++) + { + aPtTl.setX( aRectSize.Width() * j / nLines + 1 ); + aPtBr.setX( aRectSize.Width() * (j + 1) / nLines - 1 ); + + if (maPixelData[i * nLines + j] != nLastPixel) + { + nLastPixel = maPixelData[i * nLines + j]; + // Change color: 0 -> Background color + rRenderContext.SetFillColor(nLastPixel ? aPixelColor : aBackgroundColor); + } + rRenderContext.DrawRect(tools::Rectangle(aPtTl, aPtBr)); + } + } + } + else + { + rRenderContext.SetBackground(Wallpaper(COL_LIGHTGRAY)); + rRenderContext.SetLineColor(COL_LIGHTRED); + rRenderContext.DrawLine(Point(0, 0), Point(aRectSize.Width(), aRectSize.Height())); + rRenderContext.DrawLine(Point(0, aRectSize.Height()), Point(aRectSize.Width(), 0)); + } +} + +//Calculate visual focus rectangle via focus position +tools::Rectangle SvxPixelCtl::implCalFocusRect( const Point& aPosition ) +{ + long nLeft,nTop,nRight,nBottom; + long i,j; + i = aPosition.Y(); + j = aPosition.X(); + nLeft = aRectSize.Width() * j / nLines + 1; + nRight = aRectSize.Width() * (j + 1) / nLines - 1; + nTop = aRectSize.Height() * i / nLines + 1; + nBottom = aRectSize.Height() * (i + 1) / nLines - 1; + return tools::Rectangle(nLeft,nTop,nRight,nBottom); +} + +//Solution:Keyboard function +bool SvxPixelCtl::KeyInput( const KeyEvent& rKEvt ) +{ + vcl::KeyCode aKeyCode = rKEvt.GetKeyCode(); + sal_uInt16 nCode = aKeyCode.GetCode(); + bool bIsMod = aKeyCode.IsShift() || aKeyCode.IsMod1() || aKeyCode.IsMod2(); + + if( !bIsMod ) + { + Point aRepaintPoint( aRectSize.Width() *( aFocusPosition.getX() - 1)/ nLines - 1, + aRectSize.Height() *( aFocusPosition.getY() - 1)/ nLines -1 + ); + Size aRepaintSize( aRectSize.Width() *3/ nLines + 2,aRectSize.Height() *3/ nLines + 2); + tools::Rectangle aRepaintRect( aRepaintPoint, aRepaintSize ); + bool bFocusPosChanged=false; + switch(nCode) + { + case KEY_LEFT: + if(aFocusPosition.getX() >= 1) + { + aFocusPosition.setX( aFocusPosition.getX() - 1 ); + Invalidate(aRepaintRect); + bFocusPosChanged=true; + } + break; + case KEY_RIGHT: + if( aFocusPosition.getX() < (nLines - 1) ) + { + aFocusPosition.setX( aFocusPosition.getX() + 1 ); + Invalidate(aRepaintRect); + bFocusPosChanged=true; + } + break; + case KEY_UP: + if(aFocusPosition.getY() >= 1) + { + aFocusPosition.setY( aFocusPosition.getY() - 1 ); + Invalidate(aRepaintRect); + bFocusPosChanged=true; + } + break; + case KEY_DOWN: + if( aFocusPosition.getY() < ( nLines - 1 ) ) + { + aFocusPosition.setY( aFocusPosition.getY() + 1 ); + Invalidate(aRepaintRect); + bFocusPosChanged=true; + } + break; + case KEY_SPACE: + ChangePixel( sal_uInt16(aFocusPosition.getX() + aFocusPosition.getY() * nLines) ); + Invalidate( implCalFocusRect(aFocusPosition) ); + break; + default: + return CustomWidgetController::KeyInput( rKEvt ); + } + if(m_xAccess.is()) + { + long nIndex = GetFocusPosIndex(); + switch(nCode) + { + case KEY_LEFT: + case KEY_RIGHT: + case KEY_UP: + case KEY_DOWN: + if (bFocusPosChanged) + { + m_xAccess->NotifyChild(nIndex,false,false); + } + break; + case KEY_SPACE: + m_xAccess->NotifyChild(nIndex,false,true); + break; + default: + break; + } + } + return true; + } + else + { + return CustomWidgetController::KeyInput( rKEvt ); + } +} + +//Draw focus when get focus +void SvxPixelCtl::GetFocus() +{ + Invalidate(implCalFocusRect(aFocusPosition)); + + if (m_xAccess.is()) + { + m_xAccess->NotifyChild(GetFocusPosIndex(),true,false); + } +} + +void SvxPixelCtl::LoseFocus() +{ + Invalidate(); +} + +void SvxPixelCtl::SetXBitmap(const BitmapEx& rBitmapEx) +{ + if (vcl::bitmap::isHistorical8x8(rBitmapEx, aBackgroundColor, aPixelColor)) + { + for (sal_uInt16 i = 0; i < nSquares; i++) + { + Color aColor = rBitmapEx.GetPixelColor(i%8, i/8); + maPixelData[i] = (aColor == aBackgroundColor) ? 0 : 1; + } + } +} + +// Returns a specific pixel + +sal_uInt8 SvxPixelCtl::GetBitmapPixel( const sal_uInt16 nPixel ) const +{ + return maPixelData[nPixel]; +} + +// Resets to the original state of the control + +void SvxPixelCtl::Reset() +{ + // clear pixel area + maPixelData.fill(0); + Invalidate(); +} + +SvxLineLB::SvxLineLB(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) + , mbAddStandardFields(true) +{ +} + +void SvxLineLB::setAddStandardFields(bool bNew) +{ + if(getAddStandardFields() != bNew) + { + mbAddStandardFields = bNew; + } +} + +// Fills the listbox (provisional) with strings + +void SvxLineLB::Fill( const XDashListRef &pList ) +{ + m_xControl->clear(); + + if( !pList.is() ) + return; + + ScopedVclPtrInstance< VirtualDevice > pVD; + + if(getAddStandardFields()) + { + // entry for 'none' + m_xControl->append_text(pList->GetStringForUiNoLine()); + + // entry for solid line + const BitmapEx aBitmap = pList->GetBitmapForUISolidLine(); + const Size aBmpSize(aBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(aBmpSize, false); + pVD->DrawBitmapEx(Point(), aBitmap); + m_xControl->append("", pList->GetStringForUiSolidLine(), *pVD); + } + + // entries for dashed lines + + long nCount = pList->Count(); + m_xControl->freeze(); + + for( long i = 0; i < nCount; i++ ) + { + const XDashEntry* pEntry = pList->GetDash(i); + const BitmapEx aBitmap = pList->GetUiBitmap( i ); + if( !aBitmap.IsEmpty() ) + { + const Size aBmpSize(aBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(aBmpSize, false); + pVD->DrawBitmapEx(Point(), aBitmap); + m_xControl->append("", pEntry->GetName(), *pVD); + } + else + { + m_xControl->append_text(pEntry->GetName()); + } + } + + m_xControl->thaw(); +} + +void SvxLineLB::Append( const XDashEntry& rEntry, const BitmapEx& rBitmap ) +{ + if (!rBitmap.IsEmpty()) + { + ScopedVclPtrInstance< VirtualDevice > pVD; + + const Size aBmpSize(rBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(aBmpSize, false); + pVD->DrawBitmapEx(Point(), rBitmap); + m_xControl->append("", rEntry.GetName(), *pVD); + } + else + { + m_xControl->append_text(rEntry.GetName()); + } +} + +void SvxLineLB::Modify(const XDashEntry& rEntry, sal_Int32 nPos, const BitmapEx& rBitmap) +{ + m_xControl->remove(nPos); + + if (!rBitmap.IsEmpty()) + { + ScopedVclPtrInstance< VirtualDevice > pVD; + + const Size aBmpSize(rBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(aBmpSize, false); + pVD->DrawBitmapEx(Point(), rBitmap); + m_xControl->insert(nPos, rEntry.GetName(), nullptr, nullptr, pVD); + } + else + { + m_xControl->insert_text(nPos, rEntry.GetName()); + } +} + +SvxLineEndLB::SvxLineEndLB(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) +{ +} + +void SvxLineEndLB::Fill( const XLineEndListRef &pList, bool bStart ) +{ + if( !pList.is() ) + return; + + long nCount = pList->Count(); + ScopedVclPtrInstance< VirtualDevice > pVD; + m_xControl->freeze(); + + for( long i = 0; i < nCount; i++ ) + { + const XLineEndEntry* pEntry = pList->GetLineEnd(i); + const BitmapEx aBitmap = pList->GetUiBitmap( i ); + if( !aBitmap.IsEmpty() ) + { + const Size aBmpSize(aBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(Size(aBmpSize.Width() / 2, aBmpSize.Height()), false); + pVD->DrawBitmapEx(bStart ? Point() : Point(-aBmpSize.Width() / 2, 0), aBitmap); + m_xControl->append("", pEntry->GetName(), *pVD); + } + else + m_xControl->append_text(pEntry->GetName()); + } + + m_xControl->thaw(); +} + +void SvxLineEndLB::Append( const XLineEndEntry& rEntry, const BitmapEx& rBitmap ) +{ + if(!rBitmap.IsEmpty()) + { + ScopedVclPtrInstance< VirtualDevice > pVD; + + const Size aBmpSize(rBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(Size(aBmpSize.Width() / 2, aBmpSize.Height()), false); + pVD->DrawBitmapEx(Point(-aBmpSize.Width() / 2, 0), rBitmap); + m_xControl->append("", rEntry.GetName(), *pVD); + } + else + { + m_xControl->append_text(rEntry.GetName()); + } +} + +void SvxLineEndLB::Modify( const XLineEndEntry& rEntry, sal_Int32 nPos, const BitmapEx& rBitmap ) +{ + m_xControl->remove(nPos); + + if(!rBitmap.IsEmpty()) + { + ScopedVclPtrInstance< VirtualDevice > pVD; + + const Size aBmpSize(rBitmap.GetSizePixel()); + pVD->SetOutputSizePixel(Size(aBmpSize.Width() / 2, aBmpSize.Height()), false); + pVD->DrawBitmapEx(Point(-aBmpSize.Width() / 2, 0), rBitmap); + m_xControl->insert(nPos, rEntry.GetName(), nullptr, nullptr, pVD); + } + else + { + m_xControl->insert_text(nPos, rEntry.GetName()); + } +} + +void SvxXLinePreview::Resize() +{ + SvxPreviewBase::Resize(); + + const Size aOutputSize(GetOutputSize()); + const sal_Int32 nDistance(500); + const sal_Int32 nAvailableLength(aOutputSize.Width() - (4 * nDistance)); + + // create DrawObectA + const sal_Int32 aYPosA(aOutputSize.Height() / 2); + const basegfx::B2DPoint aPointA1( nDistance, aYPosA); + const basegfx::B2DPoint aPointA2( aPointA1.getX() + ((nAvailableLength * 14) / 20), aYPosA ); + basegfx::B2DPolygon aPolygonA; + aPolygonA.append(aPointA1); + aPolygonA.append(aPointA2); + mpLineObjA->SetPathPoly(basegfx::B2DPolyPolygon(aPolygonA)); + + // create DrawObectB + const sal_Int32 aYPosB1((aOutputSize.Height() * 3) / 4); + const sal_Int32 aYPosB2((aOutputSize.Height() * 1) / 4); + const basegfx::B2DPoint aPointB1( aPointA2.getX() + nDistance, aYPosB1); + const basegfx::B2DPoint aPointB2( aPointB1.getX() + ((nAvailableLength * 2) / 20), aYPosB2 ); + const basegfx::B2DPoint aPointB3( aPointB2.getX() + ((nAvailableLength * 2) / 20), aYPosB1 ); + basegfx::B2DPolygon aPolygonB; + aPolygonB.append(aPointB1); + aPolygonB.append(aPointB2); + aPolygonB.append(aPointB3); + mpLineObjB->SetPathPoly(basegfx::B2DPolyPolygon(aPolygonB)); + + // create DrawObectC + basegfx::B2DPolygon aPolygonC; + const basegfx::B2DPoint aPointC1( aPointB3.getX() + nDistance, aYPosB1); + const basegfx::B2DPoint aPointC2( aPointC1.getX() + ((nAvailableLength * 1) / 20), aYPosB2 ); + const basegfx::B2DPoint aPointC3( aPointC2.getX() + ((nAvailableLength * 1) / 20), aYPosB1 ); + aPolygonC.append(aPointC1); + aPolygonC.append(aPointC2); + aPolygonC.append(aPointC3); + mpLineObjC->SetPathPoly(basegfx::B2DPolyPolygon(aPolygonC)); +} + +SvxXLinePreview::SvxXLinePreview() + : mpLineObjA(nullptr) + , mpLineObjB(nullptr) + , mpLineObjC(nullptr) + , mpGraphic(nullptr) + , mbWithSymbol(false) +{ +} + +void SvxXLinePreview::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + SvxPreviewBase::SetDrawingArea(pDrawingArea); + + mpLineObjA = new SdrPathObj(getModel(), OBJ_LINE); + mpLineObjB = new SdrPathObj(getModel(), OBJ_PLIN); + mpLineObjC = new SdrPathObj(getModel(), OBJ_PLIN); + + Resize(); + Invalidate(); +} + +SvxXLinePreview::~SvxXLinePreview() +{ + SdrObject *pFoo = mpLineObjA; + SdrObject::Free( pFoo ); + pFoo = mpLineObjB; + SdrObject::Free( pFoo ); + pFoo = mpLineObjC; + SdrObject::Free( pFoo ); +} + +void SvxXLinePreview::SetSymbol(Graphic* p,const Size& s) +{ + mpGraphic = p; + maSymbolSize = s; +} + +void SvxXLinePreview::ResizeSymbol(const Size& s) +{ + if ( s != maSymbolSize ) + { + maSymbolSize = s; + Invalidate(); + } +} + +void SvxXLinePreview::SetLineAttributes(const SfxItemSet& rItemSet) +{ + // Set ItemSet at objects + mpLineObjA->SetMergedItemSet(rItemSet); + + // At line joints, do not use arrows + SfxItemSet aTempSet(rItemSet); + aTempSet.ClearItem(XATTR_LINESTART); + aTempSet.ClearItem(XATTR_LINEEND); + + mpLineObjB->SetMergedItemSet(aTempSet); + mpLineObjC->SetMergedItemSet(aTempSet); +} + +void SvxXLinePreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + LocalPrePaint(rRenderContext); + + // paint objects to buffer device + sdr::contact::SdrObjectVector aObjectVector; + aObjectVector.push_back(mpLineObjA); + aObjectVector.push_back(mpLineObjB); + aObjectVector.push_back(mpLineObjC); + + sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, nullptr); + sdr::contact::DisplayInfo aDisplayInfo; + + // do processing + aPainter.ProcessDisplay(aDisplayInfo); + + if ( mbWithSymbol && mpGraphic ) + { + const Size aOutputSize(GetOutputSize()); + Point aPos( aOutputSize.Width() / 3, aOutputSize.Height() / 2 ); + aPos.AdjustX( -(maSymbolSize.Width() / 2) ); + aPos.AdjustY( -(maSymbolSize.Height() / 2) ); + mpGraphic->Draw(&getBufferDevice(), aPos, maSymbolSize); + } + + LocalPostPaint(rRenderContext); +} + +SvxXShadowPreview::SvxXShadowPreview() + : mpRectangleObject(nullptr) + , mpRectangleShadow(nullptr) +{ +} + +void SvxXShadowPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + SvxPreviewBase::SetDrawingArea(pDrawingArea); + InitSettings(); + + // prepare size + Size aSize = GetPreviewSize().GetSize(); + aSize.setWidth( aSize.Width() / 3 ); + aSize.setHeight( aSize.Height() / 3 ); + + // create RectangleObject + const tools::Rectangle aObjectSize( Point( aSize.Width(), aSize.Height() ), aSize ); + mpRectangleObject = new SdrRectObj( + getModel(), + aObjectSize); + + // create ShadowObject + const tools::Rectangle aShadowSize( Point( aSize.Width(), aSize.Height() ), aSize ); + mpRectangleShadow = new SdrRectObj( + getModel(), + aShadowSize); +} + +SvxXShadowPreview::~SvxXShadowPreview() +{ + SdrObject::Free(mpRectangleObject); + SdrObject::Free(mpRectangleShadow); +} + +void SvxXShadowPreview::SetRectangleAttributes(const SfxItemSet& rItemSet) +{ + mpRectangleObject->SetMergedItemSet(rItemSet, true); + mpRectangleObject->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); +} + +void SvxXShadowPreview::SetShadowAttributes(const SfxItemSet& rItemSet) +{ + mpRectangleShadow->SetMergedItemSet(rItemSet, true); + mpRectangleShadow->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); +} + +void SvxXShadowPreview::SetShadowPosition(const Point& rPos) +{ + maShadowOffset = rPos; +} + +void SvxXShadowPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.Push(PushFlags::MAPMODE); + rRenderContext.SetMapMode(MapMode(MapUnit::Map100thMM)); + + LocalPrePaint(rRenderContext); + + // prepare size + Size aSize = rRenderContext.GetOutputSize(); + aSize.setWidth( aSize.Width() / 3 ); + aSize.setHeight( aSize.Height() / 3 ); + + tools::Rectangle aObjectRect(Point(aSize.Width(), aSize.Height()), aSize); + mpRectangleObject->SetSnapRect(aObjectRect); + aObjectRect.Move(maShadowOffset.X(), maShadowOffset.Y()); + mpRectangleShadow->SetSnapRect(aObjectRect); + + sdr::contact::SdrObjectVector aObjectVector; + + aObjectVector.push_back(mpRectangleShadow); + aObjectVector.push_back(mpRectangleObject); + + sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, nullptr); + sdr::contact::DisplayInfo aDisplayInfo; + + aPainter.ProcessDisplay(aDisplayInfo); + + LocalPostPaint(rRenderContext); + + rRenderContext.Pop(); +} + +void SvxPreviewBase::InitSettings() +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + svtools::ColorConfig aColorConfig; + Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + getBufferDevice().SetTextColor(aTextColor); + + getBufferDevice().SetBackground(rStyleSettings.GetWindowColor()); + + getBufferDevice().SetDrawMode(rStyleSettings.GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR); + + Invalidate(); +} + +SvxPreviewBase::SvxPreviewBase() + : mpModel(new SdrModel(nullptr, nullptr, true)) +{ + // init model + mpModel->GetItemPool().FreezeIdRanges(); +} + +void SvxPreviewBase::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aSize(getPreviewStripSize(pDrawingArea->get_ref_device())); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + + mpBufferDevice = VclPtr<VirtualDevice>::Create(pDrawingArea->get_ref_device()); + mpBufferDevice->SetMapMode(MapMode(MapUnit::Map100thMM)); +} + +SvxPreviewBase::~SvxPreviewBase() +{ + mpModel.reset(); + mpBufferDevice.disposeAndClear(); +} + +void SvxPreviewBase::LocalPrePaint(vcl::RenderContext const & rRenderContext) +{ + // init BufferDevice + if (mpBufferDevice->GetOutputSizePixel() != GetOutputSizePixel()) + mpBufferDevice->SetOutputSizePixel(GetOutputSizePixel()); + mpBufferDevice->SetAntialiasing(rRenderContext.GetAntialiasing()); + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + if (rStyleSettings.GetPreviewUsesCheckeredBackground()) + { + const Point aNull(0, 0); + static const sal_uInt32 nLen(8); + static const Color aW(COL_WHITE); + static const Color aG(0xef, 0xef, 0xef); + const bool bWasEnabled(mpBufferDevice->IsMapModeEnabled()); + + mpBufferDevice->EnableMapMode(false); + mpBufferDevice->DrawCheckered(aNull, mpBufferDevice->GetOutputSizePixel(), nLen, aW, aG); + mpBufferDevice->EnableMapMode(bWasEnabled); + } + else + { + mpBufferDevice->Erase(); + } +} + +void SvxPreviewBase::LocalPostPaint(vcl::RenderContext& rRenderContext) +{ + // copy to front (in pixel mode) + const bool bWasEnabledSrc(mpBufferDevice->IsMapModeEnabled()); + const bool bWasEnabledDst(rRenderContext.IsMapModeEnabled()); + const Point aEmptyPoint; + + mpBufferDevice->EnableMapMode(false); + rRenderContext.EnableMapMode(false); + + rRenderContext.DrawOutDev(aEmptyPoint, GetOutputSizePixel(), + aEmptyPoint, GetOutputSizePixel(), + *mpBufferDevice); + + mpBufferDevice->EnableMapMode(bWasEnabledSrc); + rRenderContext.EnableMapMode(bWasEnabledDst); +} + +void SvxPreviewBase::StyleUpdated() +{ + InitSettings(); + CustomWidgetController::StyleUpdated(); +} + +SvxXRectPreview::SvxXRectPreview() + : mpRectangleObject(nullptr) +{ +} + +tools::Rectangle SvxPreviewBase::GetPreviewSize() const +{ + tools::Rectangle aObjectSize(Point(), getBufferDevice().PixelToLogic(GetOutputSizePixel())); + return aObjectSize; +} + +void SvxXRectPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + SvxPreviewBase::SetDrawingArea(pDrawingArea); + InitSettings(); + + // create RectangleObject + mpRectangleObject = new SdrRectObj(getModel(), GetPreviewSize()); +} + +void SvxXRectPreview::Resize() +{ + SdrObject *pOrigObject = mpRectangleObject; + if (pOrigObject) + { + mpRectangleObject = new SdrRectObj(getModel(), GetPreviewSize()); + SetAttributes(pOrigObject->GetMergedItemSet()); + SdrObject::Free(pOrigObject); + } + SvxPreviewBase::Resize(); +} + +SvxXRectPreview::~SvxXRectPreview() +{ + SdrObject::Free(mpRectangleObject); +} + +void SvxXRectPreview::SetAttributes(const SfxItemSet& rItemSet) +{ + mpRectangleObject->SetMergedItemSet(rItemSet, true); + mpRectangleObject->SetMergedItem(XLineStyleItem(drawing::LineStyle_NONE)); +} + +void SvxXRectPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.Push(PushFlags::MAPMODE); + rRenderContext.SetMapMode(MapMode(MapUnit::Map100thMM)); + LocalPrePaint(rRenderContext); + + sdr::contact::SdrObjectVector aObjectVector; + + aObjectVector.push_back(mpRectangleObject); + + sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, nullptr); + sdr::contact::DisplayInfo aDisplayInfo; + + aPainter.ProcessDisplay(aDisplayInfo); + + LocalPostPaint(rRenderContext); + rRenderContext.Pop(); +} + +void limitWidthForSidebar(weld::SpinButton& rSpinButton) +{ + // space is limited in the sidebar, so limit MetricSpinButtons to a width of 4 digits + const int nMaxDigits = 4; + rSpinButton.set_width_chars(std::min(rSpinButton.get_width_chars(), nMaxDigits)); +} + +void limitWidthForSidebar(SvxRelativeField& rMetricSpinButton) +{ + weld::SpinButton& rSpinButton = rMetricSpinButton.get_widget(); + limitWidthForSidebar(rSpinButton); +} + +void padWidthForSidebar(weld::Toolbar& rToolbar, const css::uno::Reference<css::frame::XFrame>& rFrame) +{ + static int nColumnWidth = -1; + static vcl::ImageType eSize; + if (nColumnWidth != -1 && eSize != rToolbar.get_icon_size()) + nColumnWidth = -1; + if (nColumnWidth == -1) + { + // use the, filled-in by dispatcher, width of measurewidth as the width + // of a "standard" column in a two column panel + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(&rToolbar, "svx/ui/measurewidthbar.ui")); + std::unique_ptr<weld::Toolbar> xToolbar1(xBuilder->weld_toolbar("measurewidth1")); + std::unique_ptr<ToolbarUnoDispatcher> xDispatcher1(new ToolbarUnoDispatcher(*xToolbar1, *xBuilder, rFrame)); + std::unique_ptr<weld::Toolbar> xToolbar2(xBuilder->weld_toolbar("measurewidth2")); + std::unique_ptr<ToolbarUnoDispatcher> xDispatcher2(new ToolbarUnoDispatcher(*xToolbar2, *xBuilder, rFrame)); + nColumnWidth = std::max(xToolbar1->get_preferred_size().Width(), xToolbar2->get_preferred_size().Width()); + eSize = rToolbar.get_icon_size(); + } + rToolbar.set_size_request(nColumnWidth, -1); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/dlgunit.hxx b/svx/source/dialog/dlgunit.hxx new file mode 100644 index 000000000..108e2b5e3 --- /dev/null +++ b/svx/source/dialog/dlgunit.hxx @@ -0,0 +1,54 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_DIALOG_DLGUNIT_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_DLGUNIT_HXX + +#include <rtl/ustrbuf.hxx> +#include <svx/svdtrans.hxx> +#include <vcl/fieldvalues.hxx> + +inline OUString GetUnitString( long nVal_100, FieldUnit eFieldUnit, sal_Unicode cSep ) +{ + OUStringBuffer aVal = OUString::number( + vcl::ConvertValue(nVal_100, 2, MapUnit::Map100thMM, eFieldUnit)); + + while( aVal.getLength() < 3 ) + aVal.insert( 0, "0" ); + + aVal.insert( aVal.getLength() - 2, cSep ); + OUString aSuffix = SdrFormatter::GetUnitStr(eFieldUnit); + if (eFieldUnit != FieldUnit::NONE && eFieldUnit != FieldUnit::DEGREE && eFieldUnit != FieldUnit::INCH) + aVal.append(" "); + if (eFieldUnit == FieldUnit::INCH) + { + OUString sDoublePrime = u"\u2033"; + if (aSuffix != "\"" && aSuffix != sDoublePrime) + aVal.append(" "); + else + aSuffix = sDoublePrime; + } + aVal.append(aSuffix); + + return aVal.makeStringAndClear(); +} + +#endif // INCLUDED_SVX_SOURCE_DIALOG_DLGUNIT_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/dlgutil.cxx b/svx/source/dialog/dlgutil.cxx new file mode 100644 index 000000000..9ed2e2bdb --- /dev/null +++ b/svx/source/dialog/dlgutil.cxx @@ -0,0 +1,81 @@ +/* -*- 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/dlgutil.hxx> +#include <svl/itemset.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/module.hxx> +#include <svl/intitem.hxx> +#include <svl/eitem.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/objsh.hxx> +#include <sal/log.hxx> + + +FieldUnit GetModuleFieldUnit( const SfxItemSet& rSet ) +{ + FieldUnit eUnit = FieldUnit::INCH; + const SfxPoolItem* pItem = nullptr; + if ( SfxItemState::SET == rSet.GetItemState( SID_ATTR_METRIC, false, &pItem ) ) + eUnit = static_cast<FieldUnit>(static_cast<const SfxUInt16Item*>(pItem)->GetValue()); + else + { + return SfxModule::GetCurrentFieldUnit(); + } + + return eUnit; +} + +bool GetApplyCharUnit( const SfxItemSet& rSet ) +{ + bool bUseCharUnit = false; + const SfxPoolItem* pItem = nullptr; + if ( SfxItemState::SET == rSet.GetItemState( SID_ATTR_APPLYCHARUNIT, false, &pItem ) ) + bUseCharUnit = static_cast<const SfxBoolItem*>(pItem)->GetValue(); + else + { + // FIXME - this might be wrong, cf. the DEV300 changes in GetModuleFieldUnit() + SfxViewFrame* pFrame = SfxViewFrame::Current(); + SfxObjectShell* pSh = nullptr; + if ( pFrame ) + pSh = pFrame->GetObjectShell(); + if ( pSh ) // the object shell is not always available during reload + { + SfxModule* pModule = pSh->GetModule(); + if ( pModule ) + { + pItem = pModule->GetItem( SID_ATTR_APPLYCHARUNIT ); + if ( pItem ) + bUseCharUnit = static_cast<const SfxBoolItem*>(pItem)->GetValue(); + } + else + { + SAL_WARN( "svx.dialog", "GetApplyCharUnit(): no module found" ); + } + } + } + return bUseCharUnit; +} + +FieldUnit GetModuleFieldUnit() +{ + return SfxModule::GetCurrentFieldUnit(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/docrecovery.cxx b/svx/source/dialog/docrecovery.cxx new file mode 100644 index 000000000..f8f7c61fc --- /dev/null +++ b/svx/source/dialog/docrecovery.cxx @@ -0,0 +1,1099 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/strings.hrc> +#include <bitmaps.hlst> +#include <docrecovery.hxx> + +#include <comphelper/sequenceashashmap.hxx> +#include <comphelper/string.hxx> +#include <svtools/imagemgr.hxx> +#include <tools/urlobj.hxx> +#include <vcl/weld.hxx> +#include <vcl/svapp.hxx> + +#include <com/sun/star/util/URL.hpp> +#include <com/sun/star/util/XURLTransformer.hpp> +#include <com/sun/star/frame/theAutoRecovery.hpp> +#include <com/sun/star/ui/dialogs/FolderPicker.hpp> +#include <com/sun/star/ui/dialogs/ExecutableDialogResults.hpp> +#include <com/sun/star/util/URLTransformer.hpp> +#include <osl/file.hxx> +#include <unotools/pathoptions.hxx> + +namespace svx::DocRecovery +{ + +using namespace ::osl; + +RecoveryCore::RecoveryCore(const css::uno::Reference< css::uno::XComponentContext >& rxContext, + bool bUsedForSaving) + : m_xContext ( rxContext ) + , m_pListener ( nullptr ) + , m_bListenForSaving(bUsedForSaving) +{ + impl_startListening(); +} + + +RecoveryCore::~RecoveryCore() +{ + impl_stopListening(); +} + + +const css::uno::Reference< css::uno::XComponentContext >& RecoveryCore::getComponentContext() const +{ + return m_xContext; +} + + +TURLList& RecoveryCore::getURLListAccess() +{ + return m_lURLs; +} + + +bool RecoveryCore::isBrokenTempEntry(const TURLInfo& rInfo) +{ + if (rInfo.TempURL.isEmpty()) + return false; + + // Note: If the original files was recovery ... but a temp file + // exists ... an error inside the temp file exists! + if ( + (rInfo.RecoveryState != E_RECOVERY_FAILED ) && + (rInfo.RecoveryState != E_ORIGINAL_DOCUMENT_RECOVERED) + ) + return false; + + return true; +} + + +void RecoveryCore::saveBrokenTempEntries(const OUString& rPath) +{ + if (rPath.isEmpty()) + return; + + if (!m_xRealCore.is()) + return; + + // prepare all needed parameters for the following dispatch() request. + css::util::URL aCopyURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_BACKUP); + css::uno::Sequence< css::beans::PropertyValue > lCopyArgs(3); + lCopyArgs[0].Name = PROP_DISPATCHASYNCHRON; + lCopyArgs[0].Value <<= false; + lCopyArgs[1].Name = PROP_SAVEPATH; + lCopyArgs[1].Value <<= rPath; + lCopyArgs[2].Name = PROP_ENTRYID; + // lCopyArgs[2].Value will be changed during next loop... + + // work on a copied list only... + // Reason: We will get notifications from the core for every + // changed or removed element. And that will change our m_lURLs list. + // That's not a good idea, if we use a stl iterator inbetween .-) + TURLList lURLs = m_lURLs; + for (const TURLInfo& rInfo : lURLs) + { + if (!RecoveryCore::isBrokenTempEntry(rInfo)) + continue; + + lCopyArgs[2].Value <<= rInfo.ID; + m_xRealCore->dispatch(aCopyURL, lCopyArgs); + } +} + + +void RecoveryCore::saveAllTempEntries(const OUString& rPath) +{ + if (rPath.isEmpty()) + return; + + if (!m_xRealCore.is()) + return; + + // prepare all needed parameters for the following dispatch() request. + css::util::URL aCopyURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_BACKUP); + css::uno::Sequence< css::beans::PropertyValue > lCopyArgs(3); + lCopyArgs[0].Name = PROP_DISPATCHASYNCHRON; + lCopyArgs[0].Value <<= false; + lCopyArgs[1].Name = PROP_SAVEPATH; + lCopyArgs[1].Value <<= rPath; + lCopyArgs[2].Name = PROP_ENTRYID; + // lCopyArgs[2].Value will be changed during next loop ... + + // work on a copied list only ... + // Reason: We will get notifications from the core for every + // changed or removed element. And that will change our m_lURLs list. + // That's not a good idea, if we use a stl iterator inbetween .-) + TURLList lURLs = m_lURLs; + for (const TURLInfo& rInfo : lURLs) + { + if (rInfo.TempURL.isEmpty()) + continue; + + lCopyArgs[2].Value <<= rInfo.ID; + m_xRealCore->dispatch(aCopyURL, lCopyArgs); + } +} + + +void RecoveryCore::forgetBrokenTempEntries() +{ + if (!m_xRealCore.is()) + return; + + css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP); + css::uno::Sequence< css::beans::PropertyValue > lRemoveArgs(2); + lRemoveArgs[0].Name = PROP_DISPATCHASYNCHRON; + lRemoveArgs[0].Value <<= false; + lRemoveArgs[1].Name = PROP_ENTRYID; + // lRemoveArgs[1].Value will be changed during next loop ... + + // work on a copied list only ... + // Reason: We will get notifications from the core for every + // changed or removed element. And that will change our m_lURLs list. + // That's not a good idea, if we use a stl iterator inbetween .-) + TURLList lURLs = m_lURLs; + for (const TURLInfo& rInfo : lURLs) + { + if (!RecoveryCore::isBrokenTempEntry(rInfo)) + continue; + + lRemoveArgs[1].Value <<= rInfo.ID; + m_xRealCore->dispatch(aRemoveURL, lRemoveArgs); + } +} + + +void RecoveryCore::forgetAllRecoveryEntries() +{ + if (!m_xRealCore.is()) + return; + + css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP); + css::uno::Sequence< css::beans::PropertyValue > lRemoveArgs(2); + lRemoveArgs[0].Name = PROP_DISPATCHASYNCHRON; + lRemoveArgs[0].Value <<= false; + lRemoveArgs[1].Name = PROP_ENTRYID; + // lRemoveArgs[1].Value will be changed during next loop ... + + // work on a copied list only ... + // Reason: We will get notifications from the core for every + // changed or removed element. And that will change our m_lURLs list. + // That's not a good idea, if we use a stl iterator inbetween .-) + TURLList lURLs = m_lURLs; + for (const TURLInfo& rInfo : lURLs) + { + lRemoveArgs[1].Value <<= rInfo.ID; + m_xRealCore->dispatch(aRemoveURL, lRemoveArgs); + } +} + + +void RecoveryCore::forgetBrokenRecoveryEntries() +{ + if (!m_xRealCore.is()) + return; + + css::util::URL aRemoveURL = impl_getParsedURL(RECOVERY_CMD_DO_ENTRY_CLEANUP); + css::uno::Sequence< css::beans::PropertyValue > lRemoveArgs(2); + lRemoveArgs[0].Name = PROP_DISPATCHASYNCHRON; + lRemoveArgs[0].Value <<= false; + lRemoveArgs[1].Name = PROP_ENTRYID; + // lRemoveArgs[1].Value will be changed during next loop ... + + // work on a copied list only ... + // Reason: We will get notifications from the core for every + // changed or removed element. And that will change our m_lURLs list. + // That's not a good idea, if we use a stl iterator inbetween .-) + TURLList lURLs = m_lURLs; + for (const TURLInfo& rInfo : lURLs) + { + if (!RecoveryCore::isBrokenTempEntry(rInfo)) + continue; + + lRemoveArgs[1].Value <<= rInfo.ID; + m_xRealCore->dispatch(aRemoveURL, lRemoveArgs); + } +} + + +void RecoveryCore::setProgressHandler(const css::uno::Reference< css::task::XStatusIndicator >& xProgress) +{ + m_xProgress = xProgress; +} + + +void RecoveryCore::setUpdateListener(IRecoveryUpdateListener* pListener) +{ + m_pListener = pListener; +} + + +void RecoveryCore::doEmergencySavePrepare() +{ + if (!m_xRealCore.is()) + return; + + css::util::URL aURL = impl_getParsedURL(RECOVERY_CMD_DO_PREPARE_EMERGENCY_SAVE); + + css::uno::Sequence< css::beans::PropertyValue > lArgs(1); + lArgs[0].Name = PROP_DISPATCHASYNCHRON; + lArgs[0].Value <<= false; + + m_xRealCore->dispatch(aURL, lArgs); +} + + +void RecoveryCore::doEmergencySave() +{ + if (!m_xRealCore.is()) + return; + + css::util::URL aURL = impl_getParsedURL(RECOVERY_CMD_DO_EMERGENCY_SAVE); + + css::uno::Sequence< css::beans::PropertyValue > lArgs(2); + lArgs[0].Name = PROP_STATUSINDICATOR; + lArgs[0].Value <<= m_xProgress; + lArgs[1].Name = PROP_DISPATCHASYNCHRON; + lArgs[1].Value <<= true; + + m_xRealCore->dispatch(aURL, lArgs); +} + + +void RecoveryCore::doRecovery() +{ + if (!m_xRealCore.is()) + return; + + css::util::URL aURL = impl_getParsedURL(RECOVERY_CMD_DO_RECOVERY); + + css::uno::Sequence< css::beans::PropertyValue > lArgs(2); + lArgs[0].Name = PROP_STATUSINDICATOR; + lArgs[0].Value <<= m_xProgress; + lArgs[1].Name = PROP_DISPATCHASYNCHRON; + lArgs[1].Value <<= true; + + m_xRealCore->dispatch(aURL, lArgs); +} + + +ERecoveryState RecoveryCore::mapDocState2RecoverState(EDocStates eDocState) +{ + // ??? + ERecoveryState eRecState = E_NOT_RECOVERED_YET; + + /* Attention: + Some of the following states can occur at the + same time. So we have to check for the "worst case" first! + + DAMAGED -> INCOMPLETE -> HANDLED + */ + + // running ... + if ( + (eDocState & EDocStates::TryLoadBackup ) || + (eDocState & EDocStates::TryLoadOriginal) + ) + eRecState = E_RECOVERY_IS_IN_PROGRESS; + // red + else if (eDocState & EDocStates::Damaged) + eRecState = E_RECOVERY_FAILED; + // yellow + else if (eDocState & EDocStates::Incomplete) + eRecState = E_ORIGINAL_DOCUMENT_RECOVERED; + // green + else if (eDocState & EDocStates::Succeeded) + eRecState = E_SUCCESSFULLY_RECOVERED; + + return eRecState; +} + + +void SAL_CALL RecoveryCore::statusChanged(const css::frame::FeatureStateEvent& aEvent) +{ + // a) special notification about start/stop async dispatch! + // FeatureDescriptor = "start" || "stop" + if (aEvent.FeatureDescriptor == RECOVERY_OPERATIONSTATE_START) + { + return; + } + + if (aEvent.FeatureDescriptor == RECOVERY_OPERATIONSTATE_STOP) + { + if (m_pListener) + m_pListener->end(); + return; + } + + // b) normal notification about changed items + // FeatureDescriptor = "Update" + // State = List of information [seq< NamedValue >] + if (aEvent.FeatureDescriptor != RECOVERY_OPERATIONSTATE_UPDATE) + return; + + ::comphelper::SequenceAsHashMap lInfo(aEvent.State); + TURLInfo aNew; + + aNew.ID = lInfo.getUnpackedValueOrDefault(STATEPROP_ID , sal_Int32(0) ); + aNew.DocState = static_cast<EDocStates>(lInfo.getUnpackedValueOrDefault(STATEPROP_STATE , sal_Int32(0) )); + aNew.OrgURL = lInfo.getUnpackedValueOrDefault(STATEPROP_ORGURL , OUString()); + aNew.TempURL = lInfo.getUnpackedValueOrDefault(STATEPROP_TEMPURL , OUString()); + aNew.FactoryURL = lInfo.getUnpackedValueOrDefault(STATEPROP_FACTORYURL , OUString()); + aNew.TemplateURL = lInfo.getUnpackedValueOrDefault(STATEPROP_TEMPLATEURL, OUString()); + aNew.DisplayName = lInfo.getUnpackedValueOrDefault(STATEPROP_TITLE , OUString()); + aNew.Module = lInfo.getUnpackedValueOrDefault(STATEPROP_MODULE , OUString()); + + if (aNew.OrgURL.isEmpty()) { + // If there is no file URL, the window title is used for the display name. + // Remove any unwanted elements such as " - LibreOffice Writer". + sal_Int32 i = aNew.DisplayName.indexOf(" - "); + if (i > 0) + aNew.DisplayName = aNew.DisplayName.copy(0, i); + } else { + // If there is a file URL, parse out the filename part as the display name. + INetURLObject aOrgURL(aNew.OrgURL); + aNew.DisplayName = aOrgURL.getName(INetURLObject::LAST_SEGMENT, true, + INetURLObject::DecodeMechanism::WithCharset); + } + + // search for already existing items and update her nState value ... + for (TURLInfo& aOld : m_lURLs) + { + if (aOld.ID == aNew.ID) + { + // change existing + aOld.DocState = aNew.DocState; + aOld.RecoveryState = RecoveryCore::mapDocState2RecoverState(aOld.DocState); + if (m_pListener) + { + m_pListener->updateItems(); + m_pListener->stepNext(&aOld); + } + return; + } + } + + // append as new one + // TODO think about matching Module name to a corresponding icon + OUString sURL = aNew.OrgURL; + if (sURL.isEmpty()) + sURL = aNew.FactoryURL; + if (sURL.isEmpty()) + sURL = aNew.TempURL; + if (sURL.isEmpty()) + sURL = aNew.TemplateURL; + INetURLObject aURL(sURL); + aNew.StandardImageId = SvFileInformationManager::GetFileImageId(aURL); + + /* set the right UI state for this item to NOT_RECOVERED_YET... because nDocState shows the state of + the last emergency save operation before and is interesting for the used recovery core service only... + for now! But if there is a further notification for this item (see lines above!) we must + map the doc state to an UI state. */ + aNew.RecoveryState = E_NOT_RECOVERED_YET; + + m_lURLs.push_back(aNew); + + if (m_pListener) + m_pListener->updateItems(); +} + + +void SAL_CALL RecoveryCore::disposing(const css::lang::EventObject& /*aEvent*/) +{ + m_xRealCore.clear(); +} + + +void RecoveryCore::impl_startListening() +{ + // listening already initialized ? + if (m_xRealCore.is()) + return; + m_xRealCore = css::frame::theAutoRecovery::get(m_xContext); + + css::util::URL aURL; + if (m_bListenForSaving) + aURL.Complete = RECOVERY_CMD_DO_EMERGENCY_SAVE; + else + aURL.Complete = RECOVERY_CMD_DO_RECOVERY; + css::uno::Reference< css::util::XURLTransformer > xParser(css::util::URLTransformer::create(m_xContext)); + xParser->parseStrict(aURL); + + /* Note: addStatusListener() call us synchronous back ... so we + will get the complete list of currently open documents! */ + m_xRealCore->addStatusListener(static_cast< css::frame::XStatusListener* >(this), aURL); +} + + +void RecoveryCore::impl_stopListening() +{ + // Ignore it, if this instance doesn't listen currently + if (!m_xRealCore.is()) + return; + + css::util::URL aURL; + if (m_bListenForSaving) + aURL.Complete = RECOVERY_CMD_DO_EMERGENCY_SAVE; + else + aURL.Complete = RECOVERY_CMD_DO_RECOVERY; + css::uno::Reference< css::util::XURLTransformer > xParser(css::util::URLTransformer::create(m_xContext)); + xParser->parseStrict(aURL); + + m_xRealCore->removeStatusListener(static_cast< css::frame::XStatusListener* >(this), aURL); + m_xRealCore.clear(); +} + + +css::util::URL RecoveryCore::impl_getParsedURL(const OUString& sURL) +{ + css::util::URL aURL; + aURL.Complete = sURL; + + css::uno::Reference< css::util::XURLTransformer > xParser(css::util::URLTransformer::create(m_xContext)); + xParser->parseStrict(aURL); + + return aURL; +} + +PluginProgress::PluginProgress(weld::ProgressBar* pProgressBar) + : m_pProgressBar(pProgressBar) + , m_nRange(100) +{ +} + +PluginProgress::~PluginProgress() +{ +} + +void SAL_CALL PluginProgress::dispose() +{ + m_pProgressBar = nullptr; +} + +void SAL_CALL PluginProgress::addEventListener(const css::uno::Reference< css::lang::XEventListener >& ) +{ +} + +void SAL_CALL PluginProgress::removeEventListener( const css::uno::Reference< css::lang::XEventListener >& ) +{ +} + +void SAL_CALL PluginProgress::start(const OUString&, sal_Int32 nRange) +{ + m_nRange = nRange; + if (m_pProgressBar) + m_pProgressBar->set_percentage(0); +} + +void SAL_CALL PluginProgress::end() +{ + if (m_pProgressBar) + m_pProgressBar->set_percentage(m_nRange); +} + +void SAL_CALL PluginProgress::setText(const OUString& rText) +{ + if (m_pProgressBar) + m_pProgressBar->set_text(rText); +} + +void SAL_CALL PluginProgress::setValue(sal_Int32 nValue) +{ + if (m_pProgressBar) + m_pProgressBar->set_percentage((nValue * 100) / m_nRange); +} + +void SAL_CALL PluginProgress::reset() +{ + if (m_pProgressBar) + m_pProgressBar->set_percentage(0); +} + +SaveDialog::SaveDialog(weld::Window* pParent, RecoveryCore* pCore) + : GenericDialogController(pParent, "svx/ui/docrecoverysavedialog.ui", "DocRecoverySaveDialog") + , m_pCore(pCore) + , m_xFileListLB(m_xBuilder->weld_tree_view("filelist")) + , m_xOkBtn(m_xBuilder->weld_button("ok")) +{ + m_xFileListLB->set_size_request(-1, m_xFileListLB->get_height_rows(10)); + + // Prepare the office for the following crash save step. + // E.g. hide all open windows so the user can't influence our + // operation .-) + m_pCore->doEmergencySavePrepare(); + + m_xOkBtn->connect_clicked(LINK(this, SaveDialog, OKButtonHdl)); + + // fill listbox with current open documents + + TURLList& rURLs = m_pCore->getURLListAccess(); + + for (const TURLInfo& rInfo : rURLs) + { + m_xFileListLB->append("", rInfo.DisplayName, rInfo.StandardImageId); + } +} + +SaveDialog::~SaveDialog() +{ +} + +IMPL_LINK_NOARG(SaveDialog, OKButtonHdl, weld::Button&, void) +{ + // start crash-save with progress + std::unique_ptr<SaveProgressDialog> xProgress(new SaveProgressDialog(m_xDialog.get(), m_pCore)); + short nResult = xProgress->run(); + xProgress.reset(); + + // if "CANCEL" => return "CANCEL" + // if "OK" => "AUTOLUNCH" always ! + if (nResult == DLG_RET_OK) + nResult = DLG_RET_OK_AUTOLUNCH; + + m_xDialog->response(nResult); +} + +SaveProgressDialog::SaveProgressDialog(weld::Window* pParent, RecoveryCore* pCore) + : GenericDialogController(pParent, "svx/ui/docrecoveryprogressdialog.ui", "DocRecoveryProgressDialog") + , m_pCore(pCore) + , m_xProgressBar(m_xBuilder->weld_progress_bar("progress")) +{ + m_xProgressBar->set_size_request(m_xProgressBar->get_approximate_digit_width() * 50, -1); + PluginProgress* pProgress = new PluginProgress(m_xProgressBar.get()); + m_xProgress.set(static_cast< css::task::XStatusIndicator* >(pProgress), css::uno::UNO_QUERY_THROW); +} + +SaveProgressDialog::~SaveProgressDialog() +{ + css::uno::Reference<css::lang::XComponent> xComp(m_xProgress, css::uno::UNO_QUERY); + if (xComp) + xComp->dispose(); +} + +short SaveProgressDialog::run() +{ + ::SolarMutexGuard aLock; + + m_pCore->setProgressHandler(m_xProgress); + m_pCore->setUpdateListener(this); + m_pCore->doEmergencySave(); + short nRet = DialogController::run(); + m_pCore->setUpdateListener(nullptr); + return nRet; +} + +void SaveProgressDialog::updateItems() +{ +} + +void SaveProgressDialog::stepNext(TURLInfo* ) +{ + /* TODO + + if m_pCore would have a member m_mCurrentItem, you could see, + who is current, who is next ... You can show this information + in progress report FixText + */ +} + +void SaveProgressDialog::end() +{ + m_xDialog->response(DLG_RET_OK); +} + +static short impl_askUserForWizardCancel(weld::Widget* pParent, const char* pRes) +{ + std::unique_ptr<weld::MessageDialog> xQuery(Application::CreateMessageDialog(pParent, + VclMessageType::Question, VclButtonsType::YesNo, SvxResId(pRes))); + if (xQuery->run() == RET_YES) + return DLG_RET_OK; + else + return DLG_RET_CANCEL; +} + +RecoveryDialog::RecoveryDialog(weld::Window* pParent, RecoveryCore* pCore) + : GenericDialogController(pParent, "svx/ui/docrecoveryrecoverdialog.ui", "DocRecoveryRecoverDialog") + , m_aTitleRecoveryInProgress(SvxResId(RID_SVXSTR_RECOVERY_INPROGRESS)) + , m_aRecoveryOnlyFinish (SvxResId(RID_SVXSTR_RECOVERYONLY_FINISH)) + , m_aRecoveryOnlyFinishDescr(SvxResId(RID_SVXSTR_RECOVERYONLY_FINISH_DESCR)) + , m_pCore(pCore) + , m_eRecoveryState(RecoveryDialog::E_RECOVERY_PREPARED) + , m_bWaitForCore(false) + , m_bWasRecoveryStarted(false) + , m_aSuccessRecovStr(SvxResId(RID_SVXSTR_SUCCESSRECOV)) + , m_aOrigDocRecovStr(SvxResId(RID_SVXSTR_ORIGDOCRECOV)) + , m_aRecovFailedStr(SvxResId(RID_SVXSTR_RECOVFAILED)) + , m_aRecovInProgrStr(SvxResId(RID_SVXSTR_RECOVINPROGR)) + , m_aNotRecovYetStr(SvxResId(RID_SVXSTR_NOTRECOVYET)) + , m_xDescrFT(m_xBuilder->weld_label("desc")) + , m_xProgressBar(m_xBuilder->weld_progress_bar("progress")) + , m_xFileListLB(m_xBuilder->weld_tree_view("filelist")) + , m_xNextBtn(m_xBuilder->weld_button("next")) + , m_xCancelBtn(m_xBuilder->weld_button("cancel")) +{ + const auto nWidth = m_xFileListLB->get_approximate_digit_width() * 70; + m_xFileListLB->set_size_request(nWidth, m_xFileListLB->get_height_rows(10)); + m_xProgressBar->set_size_request(m_xProgressBar->get_approximate_digit_width() * 50, -1); + PluginProgress* pProgress = new PluginProgress(m_xProgressBar.get()); + m_xProgress.set(static_cast< css::task::XStatusIndicator* >(pProgress), css::uno::UNO_QUERY_THROW); + + std::vector<int> aWidths; + aWidths.push_back(m_xFileListLB->get_checkbox_column_width()); + aWidths.push_back(60 * nWidth / 100); + aWidths.push_back(m_xFileListLB->get_checkbox_column_width()); + m_xFileListLB->set_column_fixed_widths(aWidths); + + m_xNextBtn->set_sensitive(true); + m_xNextBtn->connect_clicked( LINK( this, RecoveryDialog, NextButtonHdl ) ); + m_xCancelBtn->connect_clicked( LINK( this, RecoveryDialog, CancelButtonHdl ) ); + + // fill list box first time + TURLList& rURLList = m_pCore->getURLListAccess(); + for (size_t i = 0, nCount = rURLList.size(); i < nCount; ++i) + { + const TURLInfo& rInfo = rURLList[i]; + m_xFileListLB->append(); + m_xFileListLB->set_id(i, OUString::number(reinterpret_cast<sal_IntPtr>(&rInfo))); + m_xFileListLB->set_image(i, rInfo.StandardImageId, 0); + m_xFileListLB->set_text(i, rInfo.DisplayName, 1); + m_xFileListLB->set_image(i, impl_getStatusImage(rInfo), 2); + m_xFileListLB->set_text(i, impl_getStatusString(rInfo), 3); + } + + // mark first item + if (m_xFileListLB->n_children()) + m_xFileListLB->set_cursor(0); +} + +RecoveryDialog::~RecoveryDialog() +{ + css::uno::Reference<css::lang::XComponent> xComp(m_xProgress, css::uno::UNO_QUERY); + if (xComp) + xComp->dispose(); +} + +short RecoveryDialog::execute() +{ + ::SolarMutexGuard aSolarLock; + + switch (m_eRecoveryState) + { + case RecoveryDialog::E_RECOVERY_IN_PROGRESS : + { + // user decided to start recovery ... + m_bWasRecoveryStarted = true; + // do it asynchronous (to allow repaints) + // and wait for this asynchronous operation. + m_xDescrFT->set_label( m_aTitleRecoveryInProgress ); + m_xNextBtn->set_sensitive(false); + m_xCancelBtn->set_sensitive(false); + m_pCore->setProgressHandler(m_xProgress); + m_pCore->setUpdateListener(this); + m_pCore->doRecovery(); + + m_bWaitForCore = true; + while(m_bWaitForCore) + Application::Yield(); + + m_pCore->setUpdateListener(nullptr); + m_eRecoveryState = RecoveryDialog::E_RECOVERY_CORE_DONE; + return execute(); + } + + case RecoveryDialog::E_RECOVERY_CORE_DONE : + { + // the core finished it's task. + // let the user decide the next step. + m_xDescrFT->set_label(m_aRecoveryOnlyFinishDescr); + m_xNextBtn->set_label(m_aRecoveryOnlyFinish); + m_xNextBtn->set_sensitive(true); + m_xCancelBtn->set_sensitive(false); + return 0; + } + + case RecoveryDialog::E_RECOVERY_DONE : + { + // All documents were recovered. + // User decided to step to the "next" wizard page. + // Do it ... but check first, if there exist some + // failed recovery documents. They must be saved to + // a user selected directory. + short nRet = DLG_RET_UNKNOWN; + BrokenRecoveryDialog aBrokenRecoveryDialog(m_xDialog.get(), m_pCore, !m_bWasRecoveryStarted); + OUString sSaveDir = aBrokenRecoveryDialog.getSaveDirURL(); // get the default dir + if (aBrokenRecoveryDialog.isExecutionNeeded()) + { + nRet = aBrokenRecoveryDialog.run(); + sSaveDir = aBrokenRecoveryDialog.getSaveDirURL(); + } + + switch(nRet) + { + // no broken temp files exists + // step to the next wizard page + case DLG_RET_UNKNOWN : + { + m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED; + return DLG_RET_OK; + } + + // user decided to save the broken temp files + // do and forget it + // step to the next wizard page + case DLG_RET_OK : + { + m_pCore->saveBrokenTempEntries(sSaveDir); + m_pCore->forgetBrokenTempEntries(); + m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED; + return DLG_RET_OK; + } + + // user decided to ignore broken temp files. + // Ask it again ... may be this decision was wrong. + // Results: + // IGNORE => remove broken temp files + // => step to the next wizard page + // CANCEL => step back to the recovery page + case DLG_RET_CANCEL : + { + // TODO ask user ... + m_pCore->forgetBrokenTempEntries(); + m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED; + return DLG_RET_OK; + } + } + + m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED; + return DLG_RET_OK; + } + + case RecoveryDialog::E_RECOVERY_CANCELED : + { + // "YES" => break recovery + // But there exist different states, where "cancel" can be called. + // Handle it different. + if (m_bWasRecoveryStarted) + m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED_AFTERWARDS; + else + m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED_BEFORE; + return execute(); + } + + case RecoveryDialog::E_RECOVERY_CANCELED_BEFORE : + case RecoveryDialog::E_RECOVERY_CANCELED_AFTERWARDS : + { + // We have to check if there exists some temp. files. + // They should be saved to a user defined location. + // If no temp files exists or user decided to ignore it ... + // we have to remove all recovery/session data anyway! + short nRet = DLG_RET_UNKNOWN; + BrokenRecoveryDialog aBrokenRecoveryDialog(m_xDialog.get(), m_pCore, !m_bWasRecoveryStarted); + OUString sSaveDir = aBrokenRecoveryDialog.getSaveDirURL(); // get the default save location + + // dialog itself checks if there is a need to copy files for this mode. + // It uses the information m_bWasRecoveryStarted doing so. + if (aBrokenRecoveryDialog.isExecutionNeeded()) + { + nRet = aBrokenRecoveryDialog.run(); + sSaveDir = aBrokenRecoveryDialog.getSaveDirURL(); + } + + // Possible states: + // a) nRet == DLG_RET_UNKNOWN + // dialog was not shown ... + // because there exists no temp file for copy. + // => remove all recovery data + // b) nRet == DLG_RET_OK + // dialog was shown ... + // user decided to save temp files + // => save all OR broken temp files (depends from the time, where cancel was called) + // => remove all recovery data + // c) nRet == DLG_RET_CANCEL + // dialog was shown ... + // user decided to ignore temp files + // => remove all recovery data + // => a)/c) are the same ... b) has one additional operation + + // b) + if (nRet == DLG_RET_OK) + { + if (m_bWasRecoveryStarted) + m_pCore->saveBrokenTempEntries(sSaveDir); + else + m_pCore->saveAllTempEntries(sSaveDir); + } + + // a,b,c) + if (m_bWasRecoveryStarted) + m_pCore->forgetBrokenRecoveryEntries(); + else + m_pCore->forgetAllRecoveryEntries(); + m_eRecoveryState = RecoveryDialog::E_RECOVERY_HANDLED; + + // THERE IS NO WAY BACK. see impl_askUserForWizardCancel()! + return DLG_RET_CANCEL; + } + } + + // should never be reached .-) + OSL_FAIL("Should never be reached!"); + return DLG_RET_OK; +} + +void RecoveryDialog::updateItems() +{ + int c = m_xFileListLB->n_children(); + for (int i = 0; i < c; ++i) + { + TURLInfo* pInfo = reinterpret_cast<TURLInfo*>(m_xFileListLB->get_id(i).toInt64()); + if ( !pInfo ) + continue; + + m_xFileListLB->set_image(i, impl_getStatusImage(*pInfo), 2); + OUString sStatus = impl_getStatusString( *pInfo ); + if (!sStatus.isEmpty()) + m_xFileListLB->set_text(i, sStatus, 3); + } +} + +void RecoveryDialog::stepNext(TURLInfo* pItem) +{ + int c = m_xFileListLB->n_children(); + for (int i=0; i < c; ++i) + { + TURLInfo* pInfo = reinterpret_cast<TURLInfo*>(m_xFileListLB->get_id(i).toInt64()); + if (pInfo->ID != pItem->ID) + continue; + + m_xFileListLB->set_cursor(i); + m_xFileListLB->scroll_to_row(i); + break; + } +} + +void RecoveryDialog::end() +{ + m_bWaitForCore = false; +} + +IMPL_LINK_NOARG(RecoveryDialog, NextButtonHdl, weld::Button&, void) +{ + switch (m_eRecoveryState) + { + case RecoveryDialog::E_RECOVERY_PREPARED: + m_eRecoveryState = RecoveryDialog::E_RECOVERY_IN_PROGRESS; + execute(); + break; + case RecoveryDialog::E_RECOVERY_CORE_DONE: + m_eRecoveryState = RecoveryDialog::E_RECOVERY_DONE; + execute(); + break; + } + + if (m_eRecoveryState == RecoveryDialog::E_RECOVERY_HANDLED) + { + m_xDialog->response(DLG_RET_OK); + } +} + +IMPL_LINK_NOARG(RecoveryDialog, CancelButtonHdl, weld::Button&, void) +{ + switch (m_eRecoveryState) + { + case RecoveryDialog::E_RECOVERY_PREPARED: + if (impl_askUserForWizardCancel(m_xDialog.get(), RID_SVXSTR_QUERY_EXIT_RECOVERY) != DLG_RET_CANCEL) + { + m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED; + execute(); + } + break; + case RecoveryDialog::E_RECOVERY_CORE_DONE: + m_eRecoveryState = RecoveryDialog::E_RECOVERY_CANCELED; + execute(); + break; + } + + if (m_eRecoveryState == RecoveryDialog::E_RECOVERY_HANDLED) + { + m_xDialog->response(RET_CANCEL); + } +} + +OUString RecoveryDialog::impl_getStatusString( const TURLInfo& rInfo ) const +{ + OUString sStatus; + switch ( rInfo.RecoveryState ) + { + case E_SUCCESSFULLY_RECOVERED : + sStatus = m_aSuccessRecovStr; + break; + case E_ORIGINAL_DOCUMENT_RECOVERED : + sStatus = m_aOrigDocRecovStr; + break; + case E_RECOVERY_FAILED : + sStatus = m_aRecovFailedStr; + break; + case E_RECOVERY_IS_IN_PROGRESS : + sStatus = m_aRecovInProgrStr; + break; + case E_NOT_RECOVERED_YET : + sStatus = m_aNotRecovYetStr; + break; + default: + break; + } + return sStatus; +} + +OUString RecoveryDialog::impl_getStatusImage( const TURLInfo& rInfo ) +{ + OUString sStatus; + switch ( rInfo.RecoveryState ) + { + case E_SUCCESSFULLY_RECOVERED : + sStatus = RID_SVXBMP_GREENCHECK; + break; + case E_ORIGINAL_DOCUMENT_RECOVERED : + sStatus = RID_SVXBMP_YELLOWCHECK; + break; + case E_RECOVERY_FAILED : + sStatus = RID_SVXBMP_REDCROSS; + break; + default: + break; + } + return sStatus; +} + +BrokenRecoveryDialog::BrokenRecoveryDialog(weld::Window* pParent, + RecoveryCore* pCore, + bool bBeforeRecovery) + : GenericDialogController(pParent, "svx/ui/docrecoverybrokendialog.ui", "DocRecoveryBrokenDialog") + , m_pCore(pCore) + , m_bBeforeRecovery(bBeforeRecovery) + , m_bExecutionNeeded(false) + , m_xFileListLB(m_xBuilder->weld_tree_view("filelist")) + , m_xSaveDirED(m_xBuilder->weld_entry("savedir")) + , m_xSaveDirBtn(m_xBuilder->weld_button("change")) + , m_xOkBtn(m_xBuilder->weld_button("ok")) + , m_xCancelBtn(m_xBuilder->weld_button("cancel")) +{ + m_xSaveDirBtn->connect_clicked( LINK( this, BrokenRecoveryDialog, SaveButtonHdl ) ); + m_xOkBtn->connect_clicked( LINK( this, BrokenRecoveryDialog, OkButtonHdl ) ); + m_xCancelBtn->connect_clicked( LINK( this, BrokenRecoveryDialog, CancelButtonHdl ) ); + + m_sSavePath = SvtPathOptions().GetWorkPath(); + INetURLObject aObj( m_sSavePath ); + OUString sPath; + osl::FileBase::getSystemPathFromFileURL(aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ), sPath); + m_xSaveDirED->set_text(sPath); + + impl_refresh(); +} + +BrokenRecoveryDialog::~BrokenRecoveryDialog() +{ +} + +void BrokenRecoveryDialog::impl_refresh() +{ + m_bExecutionNeeded = false; + TURLList& rURLList = m_pCore->getURLListAccess(); + for (const TURLInfo& rInfo : rURLList) + { + if (m_bBeforeRecovery) + { + // "Cancel" before recovery -> + // search for any temp files! + if (rInfo.TempURL.isEmpty()) + continue; + } + else + { + // "Cancel" after recovery -> + // search for broken temp files + if (!RecoveryCore::isBrokenTempEntry(rInfo)) + continue; + } + + m_bExecutionNeeded = true; + + m_xFileListLB->append(OUString::number(reinterpret_cast<sal_IntPtr>(&rInfo)), rInfo.DisplayName, rInfo.StandardImageId); + } + m_sSavePath.clear(); + m_xOkBtn->grab_focus(); +} + +bool BrokenRecoveryDialog::isExecutionNeeded() const +{ + return m_bExecutionNeeded; +} + +const OUString& BrokenRecoveryDialog::getSaveDirURL() const +{ + return m_sSavePath; +} + +IMPL_LINK_NOARG(BrokenRecoveryDialog, OkButtonHdl, weld::Button&, void) +{ + OUString sPhysicalPath = comphelper::string::strip(m_xSaveDirED->get_text(), ' '); + OUString sURL; + osl::FileBase::getFileURLFromSystemPath( sPhysicalPath, sURL ); + m_sSavePath = sURL; + while (m_sSavePath.isEmpty()) + impl_askForSavePath(); + + m_xDialog->response(DLG_RET_OK); +} + +IMPL_LINK_NOARG(BrokenRecoveryDialog, CancelButtonHdl, weld::Button&, void) +{ + m_xDialog->response(RET_CANCEL); +} + +IMPL_LINK_NOARG(BrokenRecoveryDialog, SaveButtonHdl, weld::Button&, void) +{ + impl_askForSavePath(); +} + +void BrokenRecoveryDialog::impl_askForSavePath() +{ + css::uno::Reference< css::ui::dialogs::XFolderPicker2 > xFolderPicker = + css::ui::dialogs::FolderPicker::create( m_pCore->getComponentContext() ); + + INetURLObject aURL(m_sSavePath, INetProtocol::File); + xFolderPicker->setDisplayDirectory(aURL.GetMainURL(INetURLObject::DecodeMechanism::NONE)); + short nRet = xFolderPicker->execute(); + if (nRet == css::ui::dialogs::ExecutableDialogResults::OK) + { + m_sSavePath = xFolderPicker->getDirectory(); + OUString sPath; + osl::FileBase::getSystemPathFromFileURL(m_sSavePath, sPath); + m_xSaveDirED->set_text(sPath); + } +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/fntctrl.cxx b/svx/source/dialog/fntctrl.cxx new file mode 100644 index 000000000..6dd3e62c5 --- /dev/null +++ b/svx/source/dialog/fntctrl.cxx @@ -0,0 +1,1108 @@ +/* -*- 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/dialoghelper.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/printer.hxx> +#include <vcl/metric.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <unicode/uchar.h> +#include <com/sun/star/uno/Reference.h> +#include <com/sun/star/i18n/BreakIterator.hpp> +#include <comphelper/processfactory.hxx> + +#include <com/sun/star/i18n/ScriptType.hpp> + +#include <vector> +#include <deque> +#include <svtools/colorcfg.hxx> +#include <svtools/sampletext.hxx> + +#include <svx/fntctrl.hxx> +#include <svx/svxids.hrc> + +// Item set includes +#include <svl/itemset.hxx> +#include <svl/itempool.hxx> +#include <svl/stritem.hxx> +#include <svl/languageoptions.hxx> + +#include <editeng/colritem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/editids.hrc> +#include <editeng/postitem.hxx> +#include <editeng/udlnitem.hxx> +#include <editeng/crossedoutitem.hxx> +#include <editeng/contouritem.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/brushitem.hxx> +#include <editeng/emphasismarkitem.hxx> +#include <editeng/charreliefitem.hxx> +#include <editeng/charscaleitem.hxx> +#include <editeng/langitem.hxx> + +//TODO: remove this and calculate off the actual size of text, not +//an arbitrary number of characters +#define TEXT_WIDTH 80 + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using ::com::sun::star::i18n::XBreakIterator; +using ::com::sun::star::i18n::BreakIterator; + + +// small helper functions to set fonts + +namespace +{ +void scaleFontWidth(vcl::Font& rFont, vcl::RenderContext const & rRenderContext,long& n100PercentFont) +{ + rFont.SetAverageFontWidth(0); + n100PercentFont = rRenderContext.GetFontMetric(rFont).GetAverageFontWidth(); +} + +void initFont(vcl::Font& rFont) +{ + rFont.SetTransparent(true); + rFont.SetAlignment(ALIGN_BASELINE); +} + +void setFontSize(vcl::Font& rFont) +{ + Size aSize(rFont.GetFontSize()); + aSize.setHeight( (aSize.Height() * 3) / 5 ); + aSize.setWidth( (aSize.Width() * 3) / 5 ); + rFont.SetFontSize(aSize); +} + +void calcFontHeightAnyAscent(vcl::RenderContext& rRenderContext, const vcl::Font& rFont, long& nHeight, long& nAscent) +{ + if (!nHeight) + { + rRenderContext.SetFont(rFont); + FontMetric aMetric(rRenderContext.GetFontMetric()); + nHeight = aMetric.GetLineHeight(); + nAscent = aMetric.GetAscent(); + } +} + +void setFont(const SvxFont& rNewFont, SvxFont& rImplFont) +{ + rImplFont = rNewFont; + rImplFont.SetTransparent(true); + rImplFont.SetAlignment(ALIGN_BASELINE); +} + +/* + * removes line feeds and carriage returns from string + * returns if param is empty + */ +bool CleanAndCheckEmpty(OUString& rText) +{ + bool bEmpty = true; + for (sal_Int32 i = 0; i < rText.getLength(); ++i) + { + if (0xa == rText[i] || 0xd == rText[i]) + rText = rText.replaceAt(i, 1, " "); + else + bEmpty = false; + } + return bEmpty; +} +} // end anonymous namespace + +class FontPrevWin_Impl +{ + friend class SvxFontPrevWindow; + + SvxFont maFont; + VclPtr<Printer> mpPrinter; + bool mbDelPrinter; + + Reference <XBreakIterator> mxBreak; + std::vector<long> maTextWidth; + std::deque<sal_Int32> maScriptChg; + std::vector<sal_uInt16> maScriptType; + SvxFont maCJKFont; + SvxFont maCTLFont; + OUString maText; + OUString maScriptText; + std::unique_ptr<Color> mpColor; + std::unique_ptr<Color> mpBackColor; + std::unique_ptr<Color> mpTextLineColor; + std::unique_ptr<Color> mpOverlineColor; + long mnAscent; + sal_Unicode mcStartBracket; + sal_Unicode mcEndBracket; + + long mn100PercentFontWidth; // initial -1 -> not set yet + long mn100PercentFontWidthCJK; + long mn100PercentFontWidthCTL; + sal_uInt16 mnFontWidthScale; + + bool mbSelection : 1; + bool mbGetSelection : 1; + bool mbTwoLines : 1; + bool mbUseFontNameAsText : 1; + bool mbTextInited : 1; + + bool m_bCJKEnabled; + bool m_bCTLEnabled; + + +public: + FontPrevWin_Impl() : + mpPrinter(nullptr), + mbDelPrinter(false), + mnAscent(0), + mcStartBracket(0), + mcEndBracket(0), + mnFontWidthScale(100), + mbSelection(false), + mbGetSelection(false), + mbTwoLines(false), + mbUseFontNameAsText(false), + mbTextInited(false) + { + SvtLanguageOptions aLanguageOptions; + m_bCJKEnabled = aLanguageOptions.IsAnyEnabled(); + m_bCTLEnabled = aLanguageOptions.IsCTLFontEnabled(); + + Invalidate100PercentFontWidth(); + } + + ~FontPrevWin_Impl() + { + if (mbDelPrinter) + mpPrinter.disposeAndClear(); + } + + void CheckScript(); + Size CalcTextSize(vcl::RenderContext& rRenderContext, OutputDevice const * pPrinter, const SvxFont& rFont); + void DrawPrev(vcl::RenderContext& rRenderContext, Printer* pPrinter, Point& rPt, const SvxFont& rFont); + + bool SetFontWidthScale(sal_uInt16 nScaleInPercent); + inline void Invalidate100PercentFontWidth(); + inline bool Is100PercentFontWidthValid() const; + void ScaleFontWidth(vcl::RenderContext const & rRenderContext); + // scales rNonCJKFont and aCJKFont depending on nFontWidthScale and + // sets the 100%-Font-Widths +}; + +inline void FontPrevWin_Impl::Invalidate100PercentFontWidth() +{ + mn100PercentFontWidth = mn100PercentFontWidthCJK = mn100PercentFontWidthCTL = -1; +} + +inline bool FontPrevWin_Impl::Is100PercentFontWidthValid() const +{ + DBG_ASSERT( ( mn100PercentFontWidth == -1 && mn100PercentFontWidthCJK == -1 ) || + ( mn100PercentFontWidth != -1 && mn100PercentFontWidthCJK != -1 ) || + ( mn100PercentFontWidth == -1 && mn100PercentFontWidthCTL == -1 ) || + ( mn100PercentFontWidth != -1 && mn100PercentFontWidthCTL != -1 ), + "*FontPrevWin_Impl::Is100PercentFontWidthValid(): 100PercentFontWidth's not synchronous" ); + return mn100PercentFontWidth != -1; +} + +/* + * evaluates the scripttypes of the actual string. + * Afterwards the positions of script change are notified in aScriptChg, + * the scripttypes in aScriptType. + * The aTextWidth array will be filled with zero. + */ +void FontPrevWin_Impl::CheckScript() +{ + assert(!maText.isEmpty()); // must have a preview text here! + if (maText == maScriptText) + { + return; // already initialized + } + + maScriptText = maText; + + maScriptChg.clear(); + maScriptType.clear(); + maTextWidth.clear(); + + if (!mxBreak.is()) + { + Reference<XComponentContext> xContext = ::comphelper::getProcessComponentContext(); + mxBreak = BreakIterator::create(xContext); + } + + sal_uInt16 nScript = 0; + sal_Int32 nChg = 0; + + while (nChg < maText.getLength()) + { + nScript = mxBreak->getScriptType(maText, nChg); + nChg = mxBreak->endOfScript(maText, nChg, nScript); + if (nChg < maText.getLength() && nChg > 0 && + (css::i18n::ScriptType::WEAK == + mxBreak->getScriptType(maText, nChg - 1))) + { + int8_t nType = u_charType(maText[nChg]); + if (nType == U_NON_SPACING_MARK || nType == U_ENCLOSING_MARK || + nType == U_COMBINING_SPACING_MARK) + { + maScriptChg.push_back(nChg - 1); + } + else + { + maScriptChg.push_back(nChg); + } + } + else + { + maScriptChg.push_back(nChg); + } + maScriptType.push_back(nScript); + maTextWidth.push_back(0); + } +} + +/* + * Size FontPrevWin_Impl::CalcTextSize(..) + * fills the aTextWidth array with the text width of every part + * of the actual string without a script change inside. + * For Latin parts the given rFont will be used, + * for Asian parts the aCJKFont. + * The returned size contains the whole string. + * The member nAscent is calculated to the maximal ascent of all used fonts. + */ + +Size FontPrevWin_Impl::CalcTextSize(vcl::RenderContext& rRenderContext, OutputDevice const * _pPrinter, const SvxFont& rInFont) +{ + sal_uInt16 nScript; + sal_uInt16 nIdx = 0; + sal_Int32 nStart = 0; + sal_Int32 nEnd; + size_t nCnt = maScriptChg.size(); + + if (nCnt) + { + nEnd = maScriptChg[nIdx]; + nScript = maScriptType[nIdx]; + } + else + { + nEnd = maText.getLength(); + nScript = css::i18n::ScriptType::LATIN; + } + long nTxtWidth = 0; + long nCJKHeight = 0; + long nCTLHeight = 0; + long nHeight = 0; + mnAscent = 0; + long nCJKAscent = 0; + long nCTLAscent = 0; + + do + { + const SvxFont& rFont = (nScript == css::i18n::ScriptType::ASIAN) ? + maCJKFont : + ((nScript == css::i18n::ScriptType::COMPLEX) ? + maCTLFont : + rInFont); + long nWidth = rFont.GetTextSize(_pPrinter, maText, nStart, nEnd - nStart).Width(); + if (nIdx >= maTextWidth.size()) + break; + + maTextWidth[nIdx++] = nWidth; + nTxtWidth += nWidth; + + switch (nScript) + { + case css::i18n::ScriptType::ASIAN: + calcFontHeightAnyAscent(rRenderContext, maCJKFont, nCJKHeight, nCJKAscent); + break; + case css::i18n::ScriptType::COMPLEX: + calcFontHeightAnyAscent(rRenderContext, maCTLFont, nCTLHeight, nCTLAscent); + break; + default: + calcFontHeightAnyAscent(rRenderContext, rFont, nHeight, mnAscent); + } + + if (nEnd < maText.getLength() && nIdx < nCnt) + { + nStart = nEnd; + nEnd = maScriptChg[nIdx]; + nScript = maScriptType[nIdx]; + } + else + break; + } + while(true); + + nHeight -= mnAscent; + nCJKHeight -= nCJKAscent; + nCTLHeight -= nCTLAscent; + + if (nHeight < nCJKHeight) + nHeight = nCJKHeight; + + if (mnAscent < nCJKAscent) + mnAscent = nCJKAscent; + + if (nHeight < nCTLHeight) + nHeight = nCTLHeight; + + if (mnAscent < nCTLAscent) + mnAscent = nCTLAscent; + + nHeight += mnAscent; + + Size aTxtSize(nTxtWidth, nHeight); + return aTxtSize; +} + +/* + * void FontPrevWin_Impl::DrawPrev(..) + * calls SvxFont::DrawPrev(..) for every part of the string without a script + * change inside, for Asian parts the aCJKFont will be used, otherwise the + * given rFont. + */ + +void FontPrevWin_Impl::DrawPrev(vcl::RenderContext& rRenderContext, Printer* _pPrinter, Point &rPt, const SvxFont& rInFont) +{ + vcl::Font aOldFont = _pPrinter->GetFont(); + sal_uInt16 nScript; + sal_uInt16 nIdx = 0; + sal_Int32 nStart = 0; + sal_Int32 nEnd; + size_t nCnt = maScriptChg.size(); + if (nCnt) + { + nEnd = maScriptChg[nIdx]; + nScript = maScriptType[nIdx]; + } + else + { + nEnd = maText.getLength(); + nScript = css::i18n::ScriptType::LATIN; + } + do + { + const SvxFont& rFont = (nScript == css::i18n::ScriptType::ASIAN) + ? maCJKFont + : ((nScript == css::i18n::ScriptType::COMPLEX) + ? maCTLFont + : rInFont); + _pPrinter->SetFont(rFont); + + rFont.DrawPrev(&rRenderContext, _pPrinter, rPt, maText, nStart, nEnd - nStart); + + rPt.AdjustX(maTextWidth[nIdx++] ); + if (nEnd < maText.getLength() && nIdx < nCnt) + { + nStart = nEnd; + nEnd = maScriptChg[nIdx]; + nScript = maScriptType[nIdx]; + } + else + break; + } + while(true); + _pPrinter->SetFont(aOldFont); +} + + +bool FontPrevWin_Impl::SetFontWidthScale(sal_uInt16 nScale) +{ + if (mnFontWidthScale != nScale) + { + mnFontWidthScale = nScale; + return true; + } + + return false; +} + +void FontPrevWin_Impl::ScaleFontWidth(vcl::RenderContext const & rOutDev) +{ + if (!Is100PercentFontWidthValid()) + { + scaleFontWidth(maFont, rOutDev, mn100PercentFontWidth); + scaleFontWidth(maCJKFont, rOutDev, mn100PercentFontWidthCJK); + scaleFontWidth(maCTLFont, rOutDev, mn100PercentFontWidthCTL); + } + + maFont.SetAverageFontWidth(mn100PercentFontWidth * mnFontWidthScale / 100); + maCJKFont.SetAverageFontWidth(mn100PercentFontWidthCJK * mnFontWidthScale / 100); + maCTLFont.SetAverageFontWidth(mn100PercentFontWidthCTL * mnFontWidthScale / 100); +} + +static bool GetWhich (const SfxItemSet& rSet, sal_uInt16 nSlot, sal_uInt16& rWhich) +{ + rWhich = rSet.GetPool()->GetWhich(nSlot); + return rSet.GetItemState(rWhich) >= SfxItemState::DEFAULT; +} + +static void SetPrevFont(const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont) +{ + sal_uInt16 nWhich; + if (GetWhich(rSet, nSlot, nWhich)) + { + const SvxFontItem& rFontItem = static_cast<const SvxFontItem&>(rSet.Get(nWhich)); + rFont.SetFamily(rFontItem.GetFamily()); + rFont.SetFamilyName(rFontItem.GetFamilyName()); + rFont.SetPitch(rFontItem.GetPitch()); + rFont.SetCharSet(rFontItem.GetCharSet()); + rFont.SetStyleName(rFontItem.GetStyleName()); + } +} + +static void SetPrevFontStyle( const SfxItemSet& rSet, sal_uInt16 nPosture, sal_uInt16 nWeight, SvxFont& rFont ) +{ + sal_uInt16 nWhich; + if( GetWhich( rSet, nPosture, nWhich ) ) + { + const SvxPostureItem& rItem = static_cast<const SvxPostureItem&>( rSet.Get( nWhich ) ); + rFont.SetItalic( rItem.GetValue() != ITALIC_NONE ? ITALIC_NORMAL : ITALIC_NONE ); + } + + if( GetWhich( rSet, nWeight, nWhich ) ) + { + const SvxWeightItem& rItem = static_cast<const SvxWeightItem&>( rSet.Get( nWhich ) ); + rFont.SetWeight( rItem.GetValue() != WEIGHT_NORMAL ? WEIGHT_BOLD : WEIGHT_NORMAL ); + } +} + +static void SetPrevFontEscapement(SvxFont& rFont, sal_uInt8 nProp, sal_uInt8 nEscProp, short nEsc) +{ + rFont.SetPropr(nProp); + rFont.SetProprRel(nEscProp); + rFont.SetEscapement(nEsc); +} + +void SvxFontPrevWindow::ApplySettings(vcl::RenderContext& rRenderContext) +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + + svtools::ColorConfig aColorConfig; + Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + rRenderContext.SetTextColor(aTextColor); + + rRenderContext.SetBackground(rStyleSettings.GetWindowColor()); +} + +void SvxFontPrevWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aPrefSize(getPreviewStripSize(pDrawingArea->get_ref_device())); + pDrawingArea->set_size_request(aPrefSize.Width(), aPrefSize.Height()); + + pImpl.reset(new FontPrevWin_Impl); + SfxViewShell* pSh = SfxViewShell::Current(); + + if (pSh) + pImpl->mpPrinter = pSh->GetPrinter(); + + if (!pImpl->mpPrinter) + { + pImpl->mpPrinter = VclPtr<Printer>::Create(); + pImpl->mbDelPrinter = true; + } + initFont(pImpl->maFont); + initFont(pImpl->maCJKFont); + initFont(pImpl->maCTLFont); + + Invalidate(); +} + +SvxFontPrevWindow::SvxFontPrevWindow() +{ +} + +SvxFontPrevWindow::~SvxFontPrevWindow() +{ +} + +SvxFont& SvxFontPrevWindow::GetCTLFont() +{ + return pImpl->maCTLFont; +} + +SvxFont& SvxFontPrevWindow::GetCJKFont() +{ + return pImpl->maCJKFont; +} + +SvxFont& SvxFontPrevWindow::GetFont() +{ + pImpl->Invalidate100PercentFontWidth(); // because the user might change the size + return pImpl->maFont; +} + +const SvxFont& SvxFontPrevWindow::GetFont() const +{ + return pImpl->maFont; +} + +void SvxFontPrevWindow::SetPreviewText( const OUString& rString ) +{ + pImpl->maText = rString; + pImpl->mbTextInited = true; +} + +void SvxFontPrevWindow::SetFontNameAsPreviewText() +{ + pImpl->mbUseFontNameAsText = true; +} + +void SvxFontPrevWindow::SetFont( const SvxFont& rNormalOutFont, const SvxFont& rCJKOutFont, const SvxFont& rCTLFont ) +{ + setFont(rNormalOutFont, pImpl->maFont); + setFont(rCJKOutFont, pImpl->maCJKFont); + setFont(rCTLFont, pImpl->maCTLFont); + + pImpl->Invalidate100PercentFontWidth(); + Invalidate(); +} + +void SvxFontPrevWindow::SetColor(const Color &rColor) +{ + pImpl->mpColor.reset(new Color(rColor)); + Invalidate(); +} + +void SvxFontPrevWindow::ResetColor() +{ + pImpl->mpColor.reset(); + Invalidate(); +} + +void SvxFontPrevWindow::SetBackColor(const Color &rColor) +{ + pImpl->mpBackColor.reset(new Color(rColor)); + Invalidate(); +} + +void SvxFontPrevWindow::SetTextLineColor(const Color &rColor) +{ + pImpl->mpTextLineColor.reset(new Color(rColor)); + Invalidate(); +} + +void SvxFontPrevWindow::SetOverlineColor(const Color &rColor) +{ + pImpl->mpOverlineColor.reset(new Color(rColor)); + Invalidate(); +} + +void SvxFontPrevWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.Push(PushFlags::ALL); + rRenderContext.SetMapMode(MapMode(MapUnit::MapTwip)); + + ApplySettings(rRenderContext); + + Printer* pPrinter = pImpl->mpPrinter; + const SvxFont& rFont = pImpl->maFont; + const SvxFont& rCJKFont = pImpl->maCJKFont; + const SvxFont& rCTLFont = pImpl->maCTLFont; + + if (!IsEnabled()) + { + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Size aLogSize(rRenderContext.GetOutputSize()); + + tools::Rectangle aRect(Point(0, 0), aLogSize); + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(rStyleSettings.GetWindowColor()); + rRenderContext.DrawRect(aRect); + } + else + { + if (!pImpl->mbSelection && !pImpl->mbTextInited) + { + using namespace css::i18n::ScriptType; + + SfxViewShell* pSh = SfxViewShell::Current(); + + if (pSh && !pImpl->mbGetSelection && !pImpl->mbUseFontNameAsText) + { + pImpl->maText = pSh->GetSelectionText(); + pImpl->mbGetSelection = true; + pImpl->mbSelection = !CleanAndCheckEmpty(pImpl->maText); + } + + if (!pImpl->mbSelection || pImpl->mbUseFontNameAsText) + { + //If we're showing multiple sample texts, then they're all + //sample texts. If only showing Latin, continue to use + //the fontname as the preview + if ((pImpl->m_bCJKEnabled) || (pImpl->m_bCTLEnabled)) + pImpl->maText = makeRepresentativeTextForFont(LATIN, rFont); + else + pImpl->maText = rFont.GetFamilyName(); + + if (pImpl->m_bCJKEnabled) + { + if (!pImpl->maText.isEmpty()) + pImpl->maText += " "; + pImpl->maText += makeRepresentativeTextForFont(ASIAN, rCJKFont); + + } + if (pImpl->m_bCTLEnabled) + { + if (!pImpl->maText.isEmpty()) + pImpl->maText += " "; + pImpl->maText += makeRepresentativeTextForFont(COMPLEX, rCTLFont); + } + } + + if (pImpl->maText.isEmpty()) + { // fdo#58427: still no text? let's try that one... + pImpl->maText = makeRepresentativeTextForFont(LATIN, rFont); + } + + bool bEmpty = CleanAndCheckEmpty(pImpl->maText); + if (bEmpty) + pImpl->maText = OUString(); + + if (pImpl->maText.getLength() > (TEXT_WIDTH - 1)) + { + const sal_Int32 nSpaceIdx = pImpl->maText.indexOf(" ", TEXT_WIDTH); + if (nSpaceIdx != -1) + pImpl->maText = pImpl->maText.copy(0, nSpaceIdx); + else + pImpl->maText = pImpl->maText.copy(0, (TEXT_WIDTH - 1)); + } + } + + // calculate text width scaling + pImpl->ScaleFontWidth(rRenderContext); + + pImpl->CheckScript(); + Size aTxtSize = pImpl->CalcTextSize(rRenderContext, pPrinter, rFont); + + const Size aLogSize(rRenderContext.GetOutputSize()); + + long nX = aLogSize.Width() / 2 - aTxtSize.Width() / 2; + long nY = aLogSize.Height() / 2 - aTxtSize.Height() / 2; + + if (nY + pImpl->mnAscent > aLogSize.Height()) + nY = aLogSize.Height() - pImpl->mnAscent; + + if (pImpl->mpBackColor) + { + tools::Rectangle aRect(Point(0, 0), aLogSize); + Color aLineCol = rRenderContext.GetLineColor(); + Color aFillCol = rRenderContext.GetFillColor(); + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(*pImpl->mpBackColor); + rRenderContext.DrawRect(aRect); + rRenderContext.SetLineColor(aLineCol); + rRenderContext.SetFillColor(aFillCol); + } + if (pImpl->mpColor) + { + tools::Rectangle aRect(Point(nX, nY), aTxtSize); + Color aLineCol = rRenderContext.GetLineColor(); + Color aFillCol = rRenderContext.GetFillColor(); + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(*pImpl->mpColor); + rRenderContext.DrawRect(aRect); + rRenderContext.SetLineColor(aLineCol); + rRenderContext.SetFillColor(aFillCol); + } + + if (pImpl->mpTextLineColor) + { + rRenderContext.SetTextLineColor(*pImpl->mpTextLineColor); + } + + if (pImpl->mpOverlineColor) + { + rRenderContext.SetOverlineColor(*pImpl->mpOverlineColor); + } + + long nStdAscent = pImpl->mnAscent; + nY += nStdAscent; + + if (IsTwoLines()) + { + SvxFont aSmallFont(rFont); + Size aOldSize = pImpl->maCJKFont.GetFontSize(); + setFontSize(aSmallFont); + setFontSize(pImpl->maCJKFont); + + long nStartBracketWidth = 0; + long nEndBracketWidth = 0; + long nTextWidth = 0; + if (pImpl->mcStartBracket) + { + OUString sBracket(pImpl->mcStartBracket); + nStartBracketWidth = rFont.GetTextSize(pPrinter, sBracket).Width(); + } + if (pImpl->mcEndBracket) + { + OUString sBracket(pImpl->mcEndBracket); + nEndBracketWidth = rFont.GetTextSize(pPrinter, sBracket).Width(); + } + nTextWidth = pImpl->CalcTextSize(rRenderContext, pPrinter, aSmallFont).Width(); + long nResultWidth = nStartBracketWidth; + nResultWidth += nEndBracketWidth; + nResultWidth += nTextWidth; + + long _nX = (aLogSize.Width() - nResultWidth) / 2; + rRenderContext.DrawLine(Point(0, nY), Point(_nX, nY)); + rRenderContext.DrawLine(Point(_nX + nResultWidth, nY), Point(aLogSize.Width(), nY)); + + long nSmallAscent = pImpl->mnAscent; + long nOffset = (nStdAscent - nSmallAscent) / 2; + + if (pImpl->mcStartBracket) + { + OUString sBracket(pImpl->mcStartBracket); + rFont.DrawPrev(&rRenderContext, pPrinter, Point(_nX, nY - nOffset - 4), sBracket); + _nX += nStartBracketWidth; + } + + Point aTmpPoint1(_nX, nY - nSmallAscent - 2); + Point aTmpPoint2(_nX, nY); + pImpl->DrawPrev(rRenderContext, pPrinter, aTmpPoint1, aSmallFont); + pImpl->DrawPrev(rRenderContext, pPrinter, aTmpPoint2, aSmallFont); + + _nX += nTextWidth; + if (pImpl->mcEndBracket) + { + Point aTmpPoint( _nX + 1, nY - nOffset - 4); + OUString sBracket(pImpl->mcEndBracket); + rFont.DrawPrev(&rRenderContext, pPrinter, aTmpPoint, sBracket); + } + pImpl->maCJKFont.SetFontSize(aOldSize); + } + else + { + + Color aLineCol = rRenderContext.GetLineColor(); + + rRenderContext.SetLineColor(rFont.GetColor()); + rRenderContext.DrawLine(Point(0, nY), Point(nX, nY)); + rRenderContext.DrawLine(Point(nX + aTxtSize.Width(), nY), Point(aLogSize.Width(), nY)); + rRenderContext.SetLineColor(aLineCol); + + Point aTmpPoint(nX, nY); + pImpl->DrawPrev(rRenderContext, pPrinter, aTmpPoint, rFont); + } + } + rRenderContext.Pop(); +} + +bool SvxFontPrevWindow::IsTwoLines() const +{ + return pImpl->mbTwoLines; +} + +void SvxFontPrevWindow::SetTwoLines(bool bSet) +{ + pImpl->mbTwoLines = bSet; +} + +void SvxFontPrevWindow::SetBrackets(sal_Unicode cStart, sal_Unicode cEnd) +{ + pImpl->mcStartBracket = cStart; + pImpl->mcEndBracket = cEnd; +} + +void SvxFontPrevWindow::SetFontWidthScale( sal_uInt16 n ) +{ + if (pImpl->SetFontWidthScale(n)) + Invalidate(); +} + +void SvxFontPrevWindow::AutoCorrectFontColor() +{ + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + Color aFontColor(rStyleSettings.GetWindowTextColor()); + + if (COL_AUTO == pImpl->maFont.GetColor()) + pImpl->maFont.SetColor(aFontColor); + + if (COL_AUTO == pImpl->maCJKFont.GetColor()) + pImpl->maCJKFont.SetColor(aFontColor); + + if (COL_AUTO == pImpl->maCTLFont.GetColor()) + pImpl->maCTLFont.SetColor(aFontColor); +} + +void SvxFontPrevWindow::SetFontSize( const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont ) +{ + sal_uInt16 nWhich; + long nH; + if (GetWhich(rSet, nSlot, nWhich)) + { + nH = OutputDevice::LogicToLogic(static_cast<const SvxFontHeightItem&>(rSet.Get(nWhich)).GetHeight(), + rSet.GetPool()->GetMetric(nWhich), + MapUnit::MapTwip); + } + else + nH = 240;// as default 12pt + + rFont.SetFontSize(Size(0, nH)); +} + +void SvxFontPrevWindow::SetFontLang(const SfxItemSet& rSet, sal_uInt16 nSlot, SvxFont& rFont) +{ + sal_uInt16 nWhich; + LanguageType nLang; + if( GetWhich( rSet, nSlot, nWhich ) ) + nLang = static_cast<const SvxLanguageItem&>(rSet.Get(nWhich)).GetLanguage(); + else + nLang = LANGUAGE_NONE; + rFont.SetLanguage(nLang); +} + +void SvxFontPrevWindow::SetFromItemSet(const SfxItemSet &rSet, bool bPreviewBackgroundToCharacter) +{ + sal_uInt16 nWhich; + SvxFont& rFont = GetFont(); + SvxFont& rCJKFont = GetCJKFont(); + SvxFont& rCTLFont = GetCTLFont(); + + // Preview string + if( GetWhich( rSet, SID_CHAR_DLG_PREVIEW_STRING, nWhich ) ) + { + const SfxStringItem& rItem = static_cast<const SfxStringItem&>( rSet.Get( nWhich ) ); + const OUString& aString = rItem.GetValue(); + if( !aString.isEmpty() ) + SetPreviewText( aString ); + else + SetFontNameAsPreviewText(); + } + + // Underline + FontLineStyle eUnderline; + if( GetWhich( rSet, SID_ATTR_CHAR_UNDERLINE, nWhich ) ) + { + const SvxUnderlineItem& rItem = static_cast<const SvxUnderlineItem&>( rSet.Get( nWhich ) ); + eUnderline = rItem.GetValue(); + } + else + eUnderline = LINESTYLE_NONE; + + rFont.SetUnderline( eUnderline ); + rCJKFont.SetUnderline( eUnderline ); + rCTLFont.SetUnderline( eUnderline ); + + // Overline + FontLineStyle eOverline; + if( GetWhich( rSet, SID_ATTR_CHAR_OVERLINE, nWhich ) ) + { + const SvxOverlineItem& rItem = static_cast<const SvxOverlineItem&>( rSet.Get( nWhich ) ); + eOverline = rItem.GetValue(); + } + else + eOverline = LINESTYLE_NONE; + + rFont.SetOverline( eOverline ); + rCJKFont.SetOverline( eOverline ); + rCTLFont.SetOverline( eOverline ); + + // Strikeout + FontStrikeout eStrikeout; + if( GetWhich( rSet, SID_ATTR_CHAR_STRIKEOUT, nWhich ) ) + { + const SvxCrossedOutItem& rItem = static_cast<const SvxCrossedOutItem&>( rSet.Get( nWhich ) ); + eStrikeout = rItem.GetValue(); + } + else + eStrikeout = STRIKEOUT_NONE; + + rFont.SetStrikeout( eStrikeout ); + rCJKFont.SetStrikeout( eStrikeout ); + rCTLFont.SetStrikeout( eStrikeout ); + + // WordLineMode + if( GetWhich( rSet, SID_ATTR_CHAR_WORDLINEMODE, nWhich ) ) + { + const SvxWordLineModeItem& rItem = static_cast<const SvxWordLineModeItem&>( rSet.Get( nWhich ) ); + rFont.SetWordLineMode( rItem.GetValue() ); + rCJKFont.SetWordLineMode( rItem.GetValue() ); + rCTLFont.SetWordLineMode( rItem.GetValue() ); + } + + // Emphasis + if( GetWhich( rSet, SID_ATTR_CHAR_EMPHASISMARK, nWhich ) ) + { + const SvxEmphasisMarkItem& rItem = static_cast<const SvxEmphasisMarkItem&>( rSet.Get( nWhich ) ); + FontEmphasisMark eMark = rItem.GetEmphasisMark(); + rFont.SetEmphasisMark( eMark ); + rCJKFont.SetEmphasisMark( eMark ); + rCTLFont.SetEmphasisMark( eMark ); + } + + // Relief + if( GetWhich( rSet, SID_ATTR_CHAR_RELIEF, nWhich ) ) + { + const SvxCharReliefItem& rItem = static_cast<const SvxCharReliefItem&>( rSet.Get( nWhich ) ); + FontRelief eFontRelief = rItem.GetValue(); + rFont.SetRelief( eFontRelief ); + rCJKFont.SetRelief( eFontRelief ); + rCTLFont.SetRelief( eFontRelief ); + } + + // Effects + if( GetWhich( rSet, SID_ATTR_CHAR_CASEMAP, nWhich ) ) + { + const SvxCaseMapItem& rItem = static_cast<const SvxCaseMapItem&>( rSet.Get( nWhich ) ); + SvxCaseMap eCaseMap = rItem.GetValue(); + rFont.SetCaseMap( eCaseMap ); + rCJKFont.SetCaseMap( eCaseMap ); + // #i78474# small caps do not exist in CTL fonts + rCTLFont.SetCaseMap( eCaseMap == SvxCaseMap::SmallCaps ? SvxCaseMap::NotMapped : eCaseMap ); + } + + // Outline + if( GetWhich( rSet, SID_ATTR_CHAR_CONTOUR, nWhich ) ) + { + const SvxContourItem& rItem = static_cast<const SvxContourItem&>( rSet.Get( nWhich ) ); + bool bOutline = rItem.GetValue(); + rFont.SetOutline( bOutline ); + rCJKFont.SetOutline( bOutline ); + rCTLFont.SetOutline( bOutline ); + } + + // Shadow + if( GetWhich( rSet, SID_ATTR_CHAR_SHADOWED, nWhich ) ) + { + const SvxShadowedItem& rItem = static_cast<const SvxShadowedItem&>( rSet.Get( nWhich ) ); + bool bShadow = rItem.GetValue(); + rFont.SetShadow( bShadow ); + rCJKFont.SetShadow( bShadow ); + rCTLFont.SetShadow( bShadow ); + } + + // Background + bool bTransparent; + if( GetWhich( rSet, bPreviewBackgroundToCharacter ? SID_ATTR_BRUSH : SID_ATTR_BRUSH_CHAR, nWhich ) ) + { + const SvxBrushItem& rBrush = static_cast<const SvxBrushItem&>( rSet.Get( nWhich ) ); + const Color& rColor = rBrush.GetColor(); + bTransparent = rColor.GetTransparency() > 0; + rFont.SetFillColor( rColor ); + rCJKFont.SetFillColor( rColor ); + rCTLFont.SetFillColor( rColor ); + } + else + bTransparent = true; + + rFont.SetTransparent( bTransparent ); + rCJKFont.SetTransparent( bTransparent ); + rCTLFont.SetTransparent( bTransparent ); + + Color aBackCol( COL_TRANSPARENT ); + if( !bPreviewBackgroundToCharacter ) + { + if( GetWhich( rSet, SID_ATTR_BRUSH, nWhich ) ) + { + const SvxBrushItem& rBrush = static_cast<const SvxBrushItem&>( rSet.Get( nWhich ) ); + if( GPOS_NONE == rBrush.GetGraphicPos() ) + aBackCol = rBrush.GetColor(); + } + } + SetBackColor( aBackCol ); + + // Font + SetPrevFont( rSet, SID_ATTR_CHAR_FONT, rFont ); + SetPrevFont( rSet, SID_ATTR_CHAR_CJK_FONT, rCJKFont ); + SetPrevFont( rSet, SID_ATTR_CHAR_CTL_FONT, rCTLFont ); + + // Style + SetPrevFontStyle( rSet, SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_WEIGHT, rFont ); + SetPrevFontStyle( rSet, SID_ATTR_CHAR_CJK_POSTURE, SID_ATTR_CHAR_CJK_WEIGHT, rCJKFont ); + SetPrevFontStyle( rSet, SID_ATTR_CHAR_CTL_POSTURE, SID_ATTR_CHAR_CTL_WEIGHT, rCTLFont ); + + // Size + SetFontSize( rSet, SID_ATTR_CHAR_FONTHEIGHT, rFont ); + SetFontSize( rSet, SID_ATTR_CHAR_CJK_FONTHEIGHT, rCJKFont ); + SetFontSize( rSet, SID_ATTR_CHAR_CTL_FONTHEIGHT, rCTLFont ); + + // Language + SetFontLang( rSet, SID_ATTR_CHAR_LANGUAGE, rFont ); + SetFontLang( rSet, SID_ATTR_CHAR_CJK_LANGUAGE, rCJKFont ); + SetFontLang( rSet, SID_ATTR_CHAR_CTL_LANGUAGE, rCTLFont ); + + // Color + if( GetWhich( rSet, SID_ATTR_CHAR_COLOR, nWhich ) ) + { + const SvxColorItem& rItem = static_cast<const SvxColorItem&>( rSet.Get( nWhich ) ); + Color aCol( rItem.GetValue() ); + rFont.SetColor( aCol ); + + rCJKFont.SetColor( aCol ); + rCTLFont.SetColor( aCol ); + + AutoCorrectFontColor(); // handle color COL_AUTO + } + + // Kerning + if( GetWhich( rSet, SID_ATTR_CHAR_KERNING, nWhich ) ) + { + const SvxKerningItem& rItem = static_cast<const SvxKerningItem&>( rSet.Get( nWhich ) ); + short nKern = static_cast<short>(OutputDevice::LogicToLogic(rItem.GetValue(), rSet.GetPool()->GetMetric(nWhich), MapUnit::MapTwip)); + rFont.SetFixKerning( nKern ); + rCJKFont.SetFixKerning( nKern ); + rCTLFont.SetFixKerning( nKern ); + } + + // Escapement + const sal_uInt8 nProp = 100; + short nEsc; + sal_uInt8 nEscProp; + if( GetWhich( rSet, SID_ATTR_CHAR_ESCAPEMENT, nWhich ) ) + { + const SvxEscapementItem& rItem = static_cast<const SvxEscapementItem&>( rSet.Get( nWhich ) ); + nEsc = rItem.GetEsc(); + nEscProp = rItem.GetProportionalHeight(); + + if( nEsc == DFLT_ESC_AUTO_SUPER ) + nEsc = DFLT_ESC_SUPER; + else if( nEsc == DFLT_ESC_AUTO_SUB ) + nEsc = DFLT_ESC_SUB; + } + else + { + nEsc = 0; + nEscProp = 100; + } + SetPrevFontEscapement( rFont, nProp, nEscProp, nEsc ); + SetPrevFontEscapement( rCJKFont, nProp, nEscProp, nEsc ); + SetPrevFontEscapement( rCTLFont, nProp, nEscProp, nEsc ); + + // Font width scale + if( GetWhich( rSet, SID_ATTR_CHAR_SCALEWIDTH, nWhich ) ) + { + const SvxCharScaleWidthItem&rItem = static_cast<const SvxCharScaleWidthItem&>( rSet.Get( nWhich ) ); + SetFontWidthScale( rItem.GetValue() ); + } + + Invalidate(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/fontwork.cxx b/svx/source/dialog/fontwork.cxx new file mode 100644 index 000000000..33fd244be --- /dev/null +++ b/svx/source/dialog/fontwork.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 <sfx2/module.hxx> +#include <sfx2/dispatch.hxx> + +#include <svx/colorbox.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/xftadit.hxx> +#include <svx/xftdiit.hxx> +#include <svx/xftstit.hxx> +#include <svx/xftmrit.hxx> +#include <svx/xftouit.hxx> +#include <svx/xftshit.hxx> +#include <svx/xftshcit.hxx> +#include <svx/xftshxy.hxx> +#include <svx/xtextit0.hxx> + +#include <svtools/unitconv.hxx> +#include <svx/svxids.hrc> +#include <bitmaps.hlst> +#include <svx/fontwork.hxx> + +#define WIDTH_CHARS 10 + +SFX_IMPL_DOCKINGWINDOW_WITHID( SvxFontWorkChildWindow, SID_FONTWORK ); + +// ControllerItem for Fontwork + +SvxFontWorkControllerItem::SvxFontWorkControllerItem +( + sal_uInt16 _nId, + SvxFontWorkDialog& rDlg, + SfxBindings& rBindings +) : + + SfxControllerItem( _nId, rBindings ), + + rFontWorkDlg( rDlg ) +{ +} + +// StateChanged method for FontWork items + +void SvxFontWorkControllerItem::StateChanged( sal_uInt16 /*nSID*/, SfxItemState /*eState*/, + const SfxPoolItem* pItem ) +{ + switch ( GetId() ) + { + case SID_FORMTEXT_STYLE: + { + const XFormTextStyleItem* pStateItem = + dynamic_cast<const XFormTextStyleItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextStyleItem expected"); + rFontWorkDlg.SetStyle_Impl(pStateItem); + break; + } + case SID_FORMTEXT_ADJUST: + { + const XFormTextAdjustItem* pStateItem = + dynamic_cast<const XFormTextAdjustItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextAdjustItem expected"); + rFontWorkDlg.SetAdjust_Impl(pStateItem); + break; + } + case SID_FORMTEXT_DISTANCE: + { + const XFormTextDistanceItem* pStateItem = + dynamic_cast<const XFormTextDistanceItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextDistanceItem expected"); + rFontWorkDlg.SetDistance_Impl(pStateItem); + break; + } + case SID_FORMTEXT_START: + { + const XFormTextStartItem* pStateItem = + dynamic_cast<const XFormTextStartItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextStartItem expected"); + rFontWorkDlg.SetStart_Impl(pStateItem); + break; + } + case SID_FORMTEXT_MIRROR: + { + const XFormTextMirrorItem* pStateItem = + dynamic_cast<const XFormTextMirrorItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextMirrorItem expected"); + rFontWorkDlg.SetMirror_Impl(pStateItem); + break; + } + case SID_FORMTEXT_HIDEFORM: + { + const XFormTextHideFormItem* pStateItem = + dynamic_cast<const XFormTextHideFormItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextHideFormItem expected"); + rFontWorkDlg.SetShowForm_Impl(pStateItem); + break; + } + case SID_FORMTEXT_OUTLINE: + { + const XFormTextOutlineItem* pStateItem = + dynamic_cast<const XFormTextOutlineItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextOutlineItem expected"); + rFontWorkDlg.SetOutline_Impl(pStateItem); + break; + } + case SID_FORMTEXT_SHADOW: + { + const XFormTextShadowItem* pStateItem = + dynamic_cast<const XFormTextShadowItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextShadowItem expected"); + rFontWorkDlg.SetShadow_Impl(pStateItem); + break; + } + case SID_FORMTEXT_SHDWCOLOR: + { + const XFormTextShadowColorItem* pStateItem = + dynamic_cast<const XFormTextShadowColorItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextShadowColorItem expected"); + rFontWorkDlg.SetShadowColor_Impl(pStateItem); + break; + } + case SID_FORMTEXT_SHDWXVAL: + { + const XFormTextShadowXValItem* pStateItem = + dynamic_cast<const XFormTextShadowXValItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextShadowXValItem expected"); + rFontWorkDlg.SetShadowXVal_Impl(pStateItem); + break; + } + case SID_FORMTEXT_SHDWYVAL: + { + const XFormTextShadowYValItem* pStateItem = + dynamic_cast<const XFormTextShadowYValItem*>( pItem ); + DBG_ASSERT(pStateItem || pItem == nullptr, "XFormTextShadowYValItem expected"); + rFontWorkDlg.SetShadowYVal_Impl(pStateItem); + break; + } + } +} + +// Derivation from SfxChildWindow as "containers" for Fontwork dialog + +SvxFontWorkChildWindow::SvxFontWorkChildWindow +( + vcl::Window* _pParent, + sal_uInt16 nId, + SfxBindings* pBindings, + SfxChildWinInfo* pInfo +) : + SfxChildWindow( _pParent, nId ) +{ + VclPtrInstance<SvxFontWorkDialog> pDlg(pBindings, this, _pParent); + SetWindow(pDlg); + + pDlg->Initialize( pInfo ); +} + +// Floating Window to the attribution of text effects +SvxFontWorkDialog::SvxFontWorkDialog(SfxBindings *pBindinx, + SfxChildWindow *pCW, + vcl::Window* _pParent) + : SfxDockingWindow(pBindinx, pCW, _pParent, "DockingFontwork", "svx/ui/dockingfontwork.ui") + , rBindings(*pBindinx) + , aInputIdle("SvxFontWorkDialog Input") + , nSaveShadowX(0) + , nSaveShadowY(0) + , nSaveShadowAngle(450) + , nSaveShadowSize (100) + , m_xTbxStyle(m_xBuilder->weld_toolbar("style")) + , m_xTbxAdjust(m_xBuilder->weld_toolbar("adjust")) + , m_xMtrFldDistance(m_xBuilder->weld_metric_spin_button("distance", FieldUnit::CM)) + , m_xMtrFldTextStart(m_xBuilder->weld_metric_spin_button("indent", FieldUnit::CM)) + , m_xTbxShadow(m_xBuilder->weld_toolbar("shadow")) + , m_xFbShadowX(m_xBuilder->weld_image("shadowx")) + , m_xMtrFldShadowX(m_xBuilder->weld_metric_spin_button("distancex", FieldUnit::CM)) + , m_xFbShadowY(m_xBuilder->weld_image("shadowy")) + , m_xMtrFldShadowY(m_xBuilder->weld_metric_spin_button("distancey", FieldUnit::CM)) + , m_xShadowColorLB(new ColorListBox(m_xBuilder->weld_menu_button("color"), GetFrameWeld())) +{ + SetText(SvxResId(RID_SVXSTR_FONTWORK)); + + ApplyImageList(); + + pCtrlItems[0] = new SvxFontWorkControllerItem(SID_FORMTEXT_STYLE, *this, rBindings); + pCtrlItems[1] = new SvxFontWorkControllerItem(SID_FORMTEXT_ADJUST, *this, rBindings); + pCtrlItems[2] = new SvxFontWorkControllerItem(SID_FORMTEXT_DISTANCE, *this, rBindings); + pCtrlItems[3] = new SvxFontWorkControllerItem(SID_FORMTEXT_START, *this, rBindings); + pCtrlItems[4] = new SvxFontWorkControllerItem(SID_FORMTEXT_MIRROR, *this, rBindings); + pCtrlItems[5] = new SvxFontWorkControllerItem(SID_FORMTEXT_HIDEFORM, *this, rBindings); + pCtrlItems[6] = new SvxFontWorkControllerItem(SID_FORMTEXT_OUTLINE, *this, rBindings); + pCtrlItems[7] = new SvxFontWorkControllerItem(SID_FORMTEXT_SHADOW, *this, rBindings); + pCtrlItems[8] = new SvxFontWorkControllerItem(SID_FORMTEXT_SHDWCOLOR, *this, rBindings); + pCtrlItems[9] = new SvxFontWorkControllerItem(SID_FORMTEXT_SHDWXVAL, *this, rBindings); + pCtrlItems[10] = new SvxFontWorkControllerItem(SID_FORMTEXT_SHDWYVAL, *this, rBindings); + + m_xTbxStyle->connect_clicked(LINK(this, SvxFontWorkDialog, SelectStyleHdl_Impl)); + m_xTbxAdjust->connect_clicked(LINK(this, SvxFontWorkDialog, SelectAdjustHdl_Impl)); + m_xTbxShadow->connect_clicked(LINK(this, SvxFontWorkDialog, SelectShadowHdl_Impl)); + + Link<weld::MetricSpinButton&,void> aLink = LINK(this, SvxFontWorkDialog, ModifyInputHdl_Impl); + m_xMtrFldDistance->connect_value_changed( aLink ); + m_xMtrFldTextStart->connect_value_changed( aLink ); + m_xMtrFldShadowX->connect_value_changed( aLink ); + m_xMtrFldShadowY->connect_value_changed( aLink ); + + // Set System metric + const FieldUnit eDlgUnit = rBindings.GetDispatcher()->GetModule()->GetFieldUnit(); + SetFieldUnit(*m_xMtrFldDistance, eDlgUnit, true); + SetFieldUnit(*m_xMtrFldTextStart, eDlgUnit, true); + SetFieldUnit(*m_xMtrFldShadowX, eDlgUnit, true); + SetFieldUnit(*m_xMtrFldShadowY, eDlgUnit, true); + if( eDlgUnit == FieldUnit::MM ) + { + m_xMtrFldDistance->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldTextStart->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldShadowX->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldShadowY->set_increments(50, 500, FieldUnit::NONE); + } + else + { + m_xMtrFldDistance->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldTextStart->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowX->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowY->set_increments(10, 100, FieldUnit::NONE); + } + m_xMtrFldShadowX->set_width_chars(WIDTH_CHARS); + m_xMtrFldShadowY->set_width_chars(WIDTH_CHARS); + + m_xShadowColorLB->SetSelectHdl( LINK(this, SvxFontWorkDialog, ColorSelectHdl_Impl) ); + + aInputIdle.SetPriority(TaskPriority::LOWEST); + aInputIdle.SetInvokeHandler(LINK(this, SvxFontWorkDialog, InputTimeoutHdl_Impl)); +} + +SvxFontWorkDialog::~SvxFontWorkDialog() +{ + disposeOnce(); +} + +void SvxFontWorkDialog::dispose() +{ + for (SvxFontWorkControllerItem* pCtrlItem : pCtrlItems) + pCtrlItem->dispose(); + m_xTbxStyle.reset(); + m_xTbxAdjust.reset(); + m_xMtrFldDistance.reset(); + m_xMtrFldTextStart.reset(); + m_xTbxShadow.reset(); + m_xFbShadowX.reset(); + m_xMtrFldShadowX.reset(); + m_xFbShadowY.reset(); + m_xMtrFldShadowY.reset(); + m_xShadowColorLB.reset(); + SfxDockingWindow::dispose(); +} + +SfxChildAlignment SvxFontWorkDialog::CheckAlignment( SfxChildAlignment eActAlign, + SfxChildAlignment eAlign ) +{ + SfxChildAlignment eAlignment; + + switch ( eAlign ) + { + case SfxChildAlignment::TOP: + case SfxChildAlignment::HIGHESTTOP: + case SfxChildAlignment::LOWESTTOP: + case SfxChildAlignment::BOTTOM: + case SfxChildAlignment::LOWESTBOTTOM: + case SfxChildAlignment::HIGHESTBOTTOM: + { + eAlignment = eActAlign; + } + break; + + case SfxChildAlignment::LEFT: + case SfxChildAlignment::RIGHT: + case SfxChildAlignment::FIRSTLEFT: + case SfxChildAlignment::LASTLEFT: + case SfxChildAlignment::FIRSTRIGHT: + case SfxChildAlignment::LASTRIGHT: + { + eAlignment = eAlign; + } + break; + + default: + { + eAlignment = eAlign; + } + break; + } + + return eAlignment; +} + +// Set style buttons +void SvxFontWorkDialog::SetStyle_Impl(const XFormTextStyleItem* pItem) +{ + if ( pItem ) + { + OString sId = "off"; + + switch ( pItem->GetValue() ) + { + case XFormTextStyle::Rotate : sId = "rotate"; break; + case XFormTextStyle::Upright: sId = "upright"; break; + case XFormTextStyle::SlantX : sId = "hori"; break; + case XFormTextStyle::SlantY : sId = "vert"; break; + default: ;//prevent warning + } + m_xTbxStyle->set_sensitive(true); + + // Make sure that there is always exactly one checked toolbox item. + if ( pItem->GetValue() == XFormTextStyle::NONE ) + { + m_xTbxStyle->set_item_active("rotate", false); + m_xTbxStyle->set_item_active("upright", false); + m_xTbxStyle->set_item_active("hori", false); + m_xTbxStyle->set_item_active("vert", false); + + m_xTbxStyle->set_item_active("off", true); + } + else + { + m_xTbxStyle->set_item_active("off", false); + m_xTbxStyle->set_item_active(sId, true); + } + + m_sLastStyleTbxId = sId; + } + else + m_xTbxStyle->set_sensitive(false); +} + +// Set adjust buttons + +void SvxFontWorkDialog::SetAdjust_Impl(const XFormTextAdjustItem* pItem) +{ + if ( pItem ) + { + OString sId; + + m_xTbxAdjust->set_sensitive(true); + m_xMtrFldDistance->set_sensitive(true); + + if ( pItem->GetValue() == XFormTextAdjust::Left || pItem->GetValue() == XFormTextAdjust::Right ) + { + if (pItem->GetValue() == XFormTextAdjust::Left) + sId = "left"; + else + sId = "right"; + m_xMtrFldTextStart->set_sensitive(true); + } + else + { + if (pItem->GetValue() == XFormTextAdjust::Center) + sId = "center"; + else + sId = "autosize"; + m_xMtrFldTextStart->set_sensitive(false); + } + + if (!m_xTbxAdjust->get_item_active(sId)) + m_xTbxAdjust->set_item_active(sId, true); + + m_sLastAdjustTbxId = sId; + } + else + { + m_xTbxAdjust->set_sensitive(false); + m_xMtrFldTextStart->set_sensitive(false); + m_xMtrFldDistance->set_sensitive(false); + } +} + +// Enter Distance value in the edit field + +void SvxFontWorkDialog::SetDistance_Impl(const XFormTextDistanceItem* pItem) +{ + if (pItem && !m_xMtrFldDistance->has_focus()) + { + SetMetricValue(*m_xMtrFldDistance, pItem->GetValue(), MapUnit::Map100thMM); + } +} + +// Enter indent value in the edit field + +void SvxFontWorkDialog::SetStart_Impl(const XFormTextStartItem* pItem) +{ + if (pItem && !m_xMtrFldTextStart->has_focus()) + { + SetMetricValue(*m_xMtrFldTextStart, pItem->GetValue(), MapUnit::Map100thMM); + } +} + +// Set button for reversing the direction of text + +void SvxFontWorkDialog::SetMirror_Impl(const XFormTextMirrorItem* pItem) +{ + if ( pItem ) + m_xTbxAdjust->set_item_active("orientation", pItem->GetValue()); +} + +// Set button for contour display + +void SvxFontWorkDialog::SetShowForm_Impl(const XFormTextHideFormItem* pItem) +{ + if ( pItem ) + m_xTbxShadow->set_item_active("contour", !pItem->GetValue()); +} + +// Set button for text border + +void SvxFontWorkDialog::SetOutline_Impl(const XFormTextOutlineItem* pItem) +{ + if ( pItem ) + m_xTbxShadow->set_item_active("textcontour", pItem->GetValue()); +} + +// Set shadow buttons + +void SvxFontWorkDialog::SetShadow_Impl(const XFormTextShadowItem* pItem, + bool bRestoreValues) +{ + if ( pItem ) + { + OString sId; + + m_xTbxShadow->set_sensitive(true); + + if ( pItem->GetValue() == XFormTextShadow::NONE ) + { + sId = "noshadow"; + m_xFbShadowX->hide(); + m_xFbShadowY->hide(); + m_xMtrFldShadowX->set_sensitive(false); + m_xMtrFldShadowY->set_sensitive(false); + m_xShadowColorLB->set_sensitive(false); + } + else + { + m_xFbShadowX->show(); + m_xFbShadowY->show(); + m_xMtrFldShadowX->set_sensitive(true); + m_xMtrFldShadowY->set_sensitive(true); + m_xShadowColorLB->set_sensitive(true); + + if ( pItem->GetValue() == XFormTextShadow::Normal ) + { + sId = "vertical"; + const FieldUnit eDlgUnit = rBindings.GetDispatcher()->GetModule()->GetFieldUnit(); + + m_xMtrFldShadowX->set_unit( eDlgUnit ); + m_xMtrFldShadowX->set_digits(2); + m_xMtrFldShadowX->set_range(INT_MIN, INT_MAX, FieldUnit::NONE); + if( eDlgUnit == FieldUnit::MM ) + m_xMtrFldShadowX->set_increments(50, 500, FieldUnit::NONE); + else + m_xMtrFldShadowX->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowX->set_width_chars(WIDTH_CHARS); + + m_xMtrFldShadowY->set_unit( eDlgUnit ); + m_xMtrFldShadowY->set_digits(2); + m_xMtrFldShadowY->set_range(INT_MIN, INT_MAX, FieldUnit::NONE); + if( eDlgUnit == FieldUnit::MM ) + m_xMtrFldShadowY->set_increments(50, 500, FieldUnit::NONE); + else + m_xMtrFldShadowY->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowY->set_width_chars(WIDTH_CHARS); + + if ( bRestoreValues ) + { + SetMetricValue(*m_xMtrFldShadowX, nSaveShadowX, MapUnit::Map100thMM); + SetMetricValue(*m_xMtrFldShadowY, nSaveShadowY, MapUnit::Map100thMM); + + XFormTextShadowXValItem aXItem( nSaveShadowX ); + XFormTextShadowYValItem aYItem( nSaveShadowY ); + + GetBindings().GetDispatcher()->ExecuteList( + SID_FORMTEXT_SHDWXVAL, SfxCallMode::RECORD, + { &aXItem, &aYItem }); + } + } + else + { + sId = "slant"; + + m_xMtrFldShadowX->set_unit(FieldUnit::DEGREE); + m_xMtrFldShadowX->set_digits(1); + m_xMtrFldShadowX->set_range(-1800, 1800, FieldUnit::NONE); + m_xMtrFldShadowX->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowX->set_width_chars(WIDTH_CHARS); + + m_xMtrFldShadowY->set_unit(FieldUnit::PERCENT); + m_xMtrFldShadowY->set_digits(0); + m_xMtrFldShadowY->set_range(-999, 999, FieldUnit::NONE); + m_xMtrFldShadowY->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowY->set_width_chars(WIDTH_CHARS); + + if ( bRestoreValues ) + { + m_xMtrFldShadowX->set_value(nSaveShadowAngle, FieldUnit::NONE); + m_xMtrFldShadowY->set_value(nSaveShadowSize, FieldUnit::NONE); + XFormTextShadowXValItem aXItem(nSaveShadowAngle); + XFormTextShadowYValItem aYItem(nSaveShadowSize); + GetBindings().GetDispatcher()->ExecuteList( + SID_FORMTEXT_SHDWXVAL, SfxCallMode::RECORD, + { &aXItem, &aYItem }); + } + } + } + + if (!m_xTbxShadow->get_item_active(sId)) + m_xTbxShadow->set_item_active(sId, true); + m_sLastShadowTbxId = sId; + + ApplyImageList(); + } + else + { + m_xTbxShadow->set_sensitive(false); + m_xMtrFldShadowX->set_sensitive(false); + m_xMtrFldShadowY->set_sensitive(false); + m_xShadowColorLB->set_sensitive(false); + } +} + +// Insert shadow color in listbox + +void SvxFontWorkDialog::SetShadowColor_Impl(const XFormTextShadowColorItem* pItem) +{ + if ( pItem ) + m_xShadowColorLB->SelectEntry(pItem->GetColorValue()); +} + +// Enter X-value for shadow in edit field +void SvxFontWorkDialog::SetShadowXVal_Impl(const XFormTextShadowXValItem* pItem) +{ + if (pItem && !m_xMtrFldShadowX->has_focus()) + { + // #i19251# + // sal_Int32 nValue = pItem->GetValue(); + + // #i19251# + // The two involved fields/items are used double and contain/give different + // values regarding to the access method. Thus, here we need to separate the access + // methods regarding to the kind of value accessed. + if (m_xTbxShadow->get_item_active("slant")) + { + // #i19251# + // There is no value correction necessary at all, i think this + // was only tried to be done without understanding that the two + // involved fields/items are used double and contain/give different + // values regarding to the access method. + // nValue = nValue - ( int( float( nValue ) / 360.0 ) * 360 ); + m_xMtrFldShadowX->set_value(pItem->GetValue(), FieldUnit::NONE); + } + else + { + SetMetricValue(*m_xMtrFldShadowX, pItem->GetValue(), MapUnit::Map100thMM); + } + } +} + +// Enter Y-value for shadow in edit field +void SvxFontWorkDialog::SetShadowYVal_Impl(const XFormTextShadowYValItem* pItem) +{ + if (pItem && !m_xMtrFldShadowY->has_focus()) + { + // #i19251# + // The two involved fields/items are used double and contain/give different + // values regarding to the access method. Thus, here we need to separate the access + // methods regarding to the kind of value accessed. + if (m_xTbxShadow->get_item_active("slant")) + { + m_xMtrFldShadowY->set_value(pItem->GetValue(), FieldUnit::NONE); + } + else + { + SetMetricValue(*m_xMtrFldShadowY, pItem->GetValue(), MapUnit::Map100thMM); + } + } +} + +IMPL_LINK(SvxFontWorkDialog, SelectStyleHdl_Impl, const OString&, rId, void) +{ + // Execute this block when a different toolbox item has been clicked or + // when the off item has been clicked. The later is necessary to + // override the toolbox behaviour of unchecking the item after second + // click on it: One of the items has to be checked at all times (when + // enabled that is.) + if (rId == "off" || rId != m_sLastStyleTbxId) + { + XFormTextStyle eStyle = XFormTextStyle::NONE; + + if (rId == "rotate") + eStyle = XFormTextStyle::Rotate; + else if (rId == "upright") + eStyle = XFormTextStyle::Upright; + else if (rId == "hori") + eStyle = XFormTextStyle::SlantX; + else if (rId == "vert") + eStyle = XFormTextStyle::SlantY; + + XFormTextStyleItem aItem( eStyle ); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_STYLE, + SfxCallMode::RECORD, { &aItem }); + SetStyle_Impl( &aItem ); + m_sLastStyleTbxId = rId; + } +} + +IMPL_LINK(SvxFontWorkDialog, SelectAdjustHdl_Impl, const OString&, rId, void) +{ + if (rId == "orientation") + { + XFormTextMirrorItem aItem(m_xTbxAdjust->get_item_active(rId)); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_MIRROR, + SfxCallMode::SLOT, { &aItem }); + } + else if (rId != m_sLastAdjustTbxId) + { + XFormTextAdjust eAdjust = XFormTextAdjust::AutoSize; + + if (rId == "left") + eAdjust = XFormTextAdjust::Left; + else if (rId == "center") + eAdjust = XFormTextAdjust::Center; + else if (rId == "right") + eAdjust = XFormTextAdjust::Right; + + XFormTextAdjustItem aItem(eAdjust); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_ADJUST, + SfxCallMode::RECORD, { &aItem }); + SetAdjust_Impl(&aItem); + m_sLastAdjustTbxId = rId; + } +} + +IMPL_LINK(SvxFontWorkDialog, SelectShadowHdl_Impl, const OString&, rId, void) +{ + if (rId == "contour") + { + XFormTextHideFormItem aItem(!m_xTbxShadow->get_item_active(rId)); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_HIDEFORM, + SfxCallMode::RECORD, { &aItem }); + } + else if (rId == "textcontour") + { + XFormTextOutlineItem aItem(m_xTbxShadow->get_item_active(rId)); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_OUTLINE, + SfxCallMode::RECORD, { &aItem }); + } + else if (rId != m_sLastShadowTbxId) + { + XFormTextShadow eShadow = XFormTextShadow::NONE; + + if (m_sLastShadowTbxId == "vertical") + { + nSaveShadowX = GetCoreValue(*m_xMtrFldShadowX, MapUnit::Map100thMM); + nSaveShadowY = GetCoreValue(*m_xMtrFldShadowY, MapUnit::Map100thMM); + } + else if (m_sLastShadowTbxId == "slant") + { + nSaveShadowAngle = m_xMtrFldShadowX->get_value(FieldUnit::NONE); + nSaveShadowSize = m_xMtrFldShadowY->get_value(FieldUnit::NONE); + } + m_sLastShadowTbxId = rId; + + if ( rId == "vertical") eShadow = XFormTextShadow::Normal; + else if (rId == "slant") eShadow = XFormTextShadow::Slant; + + XFormTextShadowItem aItem(eShadow); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_SHADOW, + SfxCallMode::RECORD, { &aItem }); + SetShadow_Impl(&aItem, true); + } +} + +IMPL_LINK_NOARG(SvxFontWorkDialog, ModifyInputHdl_Impl, weld::MetricSpinButton&, void) +{ + aInputIdle.Start(); +} + +IMPL_LINK_NOARG(SvxFontWorkDialog, InputTimeoutHdl_Impl, Timer*, void) +{ + // Possibly set the Metric system again. This should be done with a + // listen, this is however not possible at the moment due to compatibility + // issues. + const FieldUnit eDlgUnit = rBindings.GetDispatcher()->GetModule()->GetFieldUnit(); + if( eDlgUnit != m_xMtrFldDistance->get_unit() ) + { + SetFieldUnit(*m_xMtrFldDistance, eDlgUnit, true); + SetFieldUnit(*m_xMtrFldTextStart, eDlgUnit, true); + if (eDlgUnit == FieldUnit::MM) + { + m_xMtrFldDistance->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldTextStart->set_increments(50, 500, FieldUnit::NONE); + } + else + { + m_xMtrFldDistance->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldTextStart->set_increments(10, 100, FieldUnit::NONE); + } + } + if( eDlgUnit != m_xMtrFldShadowX->get_unit() && + m_xTbxShadow->get_item_active("vertical") ) + { + SetFieldUnit(*m_xMtrFldShadowX, eDlgUnit, true); + SetFieldUnit(*m_xMtrFldShadowY, eDlgUnit, true); + + if (eDlgUnit == FieldUnit::MM) + { + m_xMtrFldShadowX->set_increments(50, 500, FieldUnit::NONE); + m_xMtrFldShadowY->set_increments(50, 500, FieldUnit::NONE); + } + else + { + m_xMtrFldShadowX->set_increments(10, 100, FieldUnit::NONE); + m_xMtrFldShadowY->set_increments(10, 100, FieldUnit::NONE); + } + } + + long nValue = GetCoreValue(*m_xMtrFldDistance, MapUnit::Map100thMM); + XFormTextDistanceItem aDistItem( nValue ); + nValue = GetCoreValue(*m_xMtrFldTextStart, MapUnit::Map100thMM); + XFormTextStartItem aStartItem( nValue ); + + sal_Int32 nValueX(0); + sal_Int32 nValueY(0); + + // #i19251# + // The two involved fields/items are used double and contain/give different + // values regarding to the access method. Thus, here we need to separate the access + // method regarding to the kind of value accessed. + if (m_sLastShadowTbxId == "vertical") + { + nValueX = GetCoreValue(*m_xMtrFldShadowX, MapUnit::Map100thMM); + nValueY = GetCoreValue(*m_xMtrFldShadowY, MapUnit::Map100thMM); + } + else if (m_sLastShadowTbxId == "slant") + { + nValueX = m_xMtrFldShadowX->get_value(FieldUnit::NONE); + nValueY = m_xMtrFldShadowY->get_value(FieldUnit::NONE); + } + + XFormTextShadowXValItem aShadowXItem( nValueX ); + XFormTextShadowYValItem aShadowYItem( nValueY ); + + // Slot-ID does not matter, the Exec method evaluates the entire item set + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_DISTANCE, + SfxCallMode::RECORD, + { &aDistItem, &aStartItem, &aShadowXItem, &aShadowYItem }); +} + +IMPL_LINK_NOARG(SvxFontWorkDialog, ColorSelectHdl_Impl, ColorListBox&, void) +{ + XFormTextShadowColorItem aItem( "", m_xShadowColorLB->GetSelectEntryColor() ); + GetBindings().GetDispatcher()->ExecuteList(SID_FORMTEXT_SHDWCOLOR, + SfxCallMode::RECORD, { &aItem }); +} + +void SvxFontWorkDialog::ApplyImageList() +{ + if (m_sLastShadowTbxId == "slant") + { + m_xFbShadowX->set_from_icon_name(RID_SVXBMP_SHADOW_ANGLE); + m_xFbShadowY->set_from_icon_name(RID_SVXBMP_SHADOW_SIZE); + } + else + { + m_xFbShadowX->set_from_icon_name(RID_SVXBMP_SHADOW_XDIST); + m_xFbShadowY->set_from_icon_name(RID_SVXBMP_SHADOW_YDIST); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/framelink.cxx b/svx/source/dialog/framelink.cxx new file mode 100644 index 000000000..62d60094b --- /dev/null +++ b/svx/source/dialog/framelink.cxx @@ -0,0 +1,431 @@ +/* -*- 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 <rtl/math.hxx> +#include <svx/framelink.hxx> + +#include <editeng/borderline.hxx> + + +using namespace ::com::sun::star; +using namespace editeng; + +namespace svx::frame +{ + +// Classes +void Style::implEnsureImplStyle() +{ + if(!maImplStyle) + { + maImplStyle = std::make_shared<implStyle>(); + } +} + +Style::Style() : + maImplStyle() +{ +} + +Style::Style( double nP, double nD, double nS, SvxBorderLineStyle nType, double fScale ) : + maImplStyle(std::make_shared<implStyle>()) +{ + maImplStyle->mnType = nType; + maImplStyle->mfPatternScale = fScale; + Set( nP, nD, nS ); +} + +Style::Style( const Color& rColorPrim, const Color& rColorSecn, const Color& rColorGap, bool bUseGapColor, double nP, double nD, double nS, SvxBorderLineStyle nType, double fScale ) : + maImplStyle(std::make_shared<implStyle>()) +{ + maImplStyle->mnType = nType; + maImplStyle->mfPatternScale = fScale; + Set( rColorPrim, rColorSecn, rColorGap, bUseGapColor, nP, nD, nS ); +} + +Style::Style( const editeng::SvxBorderLine* pBorder, double fScale ) : + maImplStyle() +{ + if(nullptr != pBorder) + { + maImplStyle = std::make_shared<implStyle>(); + maImplStyle->mfPatternScale = fScale; + Set( pBorder, fScale ); + } +} + +void Style::Clear() +{ + if(maImplStyle) + { + maImplStyle.reset(); + } +} + +void Style::Set( double nP, double nD, double nS ) +{ + /* nP nD nS -> mfPrim mfDist mfSecn + -------------------------------------- + any any 0 nP 0 0 + 0 any >0 nS 0 0 + >0 0 >0 nP 0 0 + >0 >0 >0 nP nD nS + */ + implEnsureImplStyle(); + implStyle* pTarget = maImplStyle.get(); + pTarget->mfPrim = rtl::math::round(nP ? nP : nS, 2); + pTarget->mfDist = rtl::math::round((nP && nS) ? nD : 0, 2); + pTarget->mfSecn = rtl::math::round((nP && nD) ? nS : 0, 2); +} + +void Style::Set( const Color& rColorPrim, const Color& rColorSecn, const Color& rColorGap, bool bUseGapColor, double nP, double nD, double nS ) +{ + implEnsureImplStyle(); + implStyle* pTarget = maImplStyle.get(); + pTarget->maColorPrim = rColorPrim; + pTarget->maColorSecn = rColorSecn; + pTarget->maColorGap = rColorGap; + pTarget->mbUseGapColor = bUseGapColor; + Set( nP, nD, nS ); +} + +void Style::Set( const SvxBorderLine* pBorder, double fScale, sal_uInt16 nMaxWidth ) +{ + if(nullptr == pBorder) + { + Clear(); + return; + } + + implEnsureImplStyle(); + implStyle* pTarget = maImplStyle.get(); + pTarget->maColorPrim = pBorder->GetColorOut(); + pTarget->maColorSecn = pBorder->GetColorIn(); + pTarget->maColorGap = pBorder->GetColorGap(); + pTarget->mbUseGapColor = pBorder->HasGapColor(); + + const sal_uInt16 nPrim(pBorder->GetOutWidth()); + const sal_uInt16 nDist(pBorder->GetDistance()); + const sal_uInt16 nSecn(pBorder->GetInWidth()); + + pTarget->mnType = pBorder->GetBorderLineStyle(); + pTarget->mfPatternScale = fScale; + + if( !nSecn ) // no or single frame border + { + Set( std::min<double>(nPrim * fScale, nMaxWidth), 0, 0 ); + } + else + { + Set(std::min<double>(nPrim * fScale, nMaxWidth), std::min<double>(nDist * fScale, nMaxWidth), std::min<double>(nSecn * fScale, nMaxWidth)); + // Enlarge the style if distance is too small due to rounding losses. + double nPixWidth = std::min<double>((nPrim + nDist + nSecn) * fScale, nMaxWidth); + + if( nPixWidth > GetWidth() ) + { + pTarget->mfDist = nPixWidth - pTarget->mfPrim - pTarget->mfSecn; + } + + // Shrink the style if it is too thick for the control. + while( GetWidth() > nMaxWidth ) + { + // First decrease space between lines. + if (pTarget->mfDist) + { + --(pTarget->mfDist); + continue; + } + + // Still too thick? Decrease the line widths. + if (pTarget->mfPrim != 0.0 && rtl::math::approxEqual(pTarget->mfPrim, pTarget->mfSecn)) + { + // Both lines equal - decrease both to keep symmetry. + --(pTarget->mfPrim); + --(pTarget->mfSecn); + continue; + } + + // Decrease each line for itself + if (pTarget->mfPrim) + { + --(pTarget->mfPrim); + } + + if ((GetWidth() > nMaxWidth) && pTarget->mfSecn != 0.0) + { + --(pTarget->mfSecn); + } + } + } +} + +void Style::SetRefMode( RefMode eRefMode ) +{ + if(!maImplStyle) + { + if(RefMode::Centered == eRefMode) + { + return; + } + + implEnsureImplStyle(); + } + + maImplStyle->meRefMode = eRefMode; +} + +void Style::SetColorPrim( const Color& rColor ) +{ + if(!maImplStyle) + { + if(Color() == rColor) + { + return; + } + + implEnsureImplStyle(); + } + + maImplStyle->maColorPrim = rColor; +} + +void Style::SetColorSecn( const Color& rColor ) +{ + if(!maImplStyle) + { + if(Color() == rColor) + { + return; + } + + implEnsureImplStyle(); + } + + maImplStyle->maColorSecn = rColor; +} + +void Style::SetType( SvxBorderLineStyle nType ) +{ + if(!maImplStyle) + { + if(SvxBorderLineStyle::SOLID == nType) + { + return; + } + + implEnsureImplStyle(); + } + + maImplStyle->mnType = nType; +} + +Style& Style::MirrorSelf() +{ + if(!maImplStyle) + { + return *this; + } + + implStyle* pTarget = maImplStyle.get(); + + if (pTarget->mfSecn) + { + std::swap( pTarget->mfPrim, pTarget->mfSecn ); + // also need to swap colors + std::swap( pTarget->maColorPrim, pTarget->maColorSecn ); + } + + if( pTarget->meRefMode != RefMode::Centered ) + { + pTarget->meRefMode = (pTarget->meRefMode == RefMode::Begin) ? RefMode::End : RefMode::Begin; + } + + return *this; +} + +void Style::SetWordTableCell(bool bWordTableCell) +{ + if (!maImplStyle) + { + implEnsureImplStyle(); + } + + maImplStyle->mbWordTableCell = bWordTableCell; +} + +bool Style::operator==( const Style& rOther) const +{ + if(!maImplStyle && !rOther.maImplStyle) + { + return true; + } + + if(maImplStyle && rOther.maImplStyle && maImplStyle.get() == rOther.maImplStyle.get()) + { + return true; + } + + return (Prim() == rOther.Prim() + && Dist() == rOther.Dist() + && Secn() == rOther.Secn() + && GetColorPrim() == rOther.GetColorPrim() + && GetColorSecn() == rOther.GetColorSecn() + && GetColorGap() == rOther.GetColorGap() + && GetRefMode() == rOther.GetRefMode() + && UseGapColor() == rOther.UseGapColor() + && Type() == rOther.Type()); +} + +namespace +{ +/** + * Gets the weight of rStyle, according to [MS-OI29500] v20171130, 2.1.168 Part 1 Section 17.4.66, + * tcBorders (Table Cell Borders). + */ +double GetWordTableCellBorderWeight(const Style& rStyle) +{ + double fWidth = rStyle.GetWidth(); + int nBorderNumber = 0; + + // See lcl_convertBorderStyleFromToken() in writerfilter/ and ConvertBorderStyleFromWord() in + // editeng/, this is the opposite of the combination of those functions. + switch (rStyle.Type()) + { + case SvxBorderLineStyle::NONE: + return 0.0; + case SvxBorderLineStyle::DOTTED: + case SvxBorderLineStyle::DASHED: + return 1.0; + case SvxBorderLineStyle::SOLID: + // single = 1 + // thick = 2 + // wave = 20 + nBorderNumber = 1; + break; + case SvxBorderLineStyle::DOUBLE: + case SvxBorderLineStyle::DOUBLE_THIN: + // double = 3 + // triple = 10 + // doubleWave = 21 + // dashDotStroked = 23 + nBorderNumber = 3; + break; + case SvxBorderLineStyle::DASH_DOT: + // dotDash = 8 + nBorderNumber = 8; + break; + case SvxBorderLineStyle::DASH_DOT_DOT: + // dotDotDash = 9 + nBorderNumber = 9; + break; + case SvxBorderLineStyle::THINTHICK_SMALLGAP: + // thinThickSmallGap = 11 + nBorderNumber = 11; + break; + case SvxBorderLineStyle::THICKTHIN_SMALLGAP: + // thickThinSmallGap = 12 + // thinThickThinSmallGap = 13 + nBorderNumber = 12; + break; + case SvxBorderLineStyle::THINTHICK_MEDIUMGAP: + // thinThickMediumGap = 14 + nBorderNumber = 14; + break; + case SvxBorderLineStyle::THICKTHIN_MEDIUMGAP: + // thickThinMediumGap = 15 + // thinThickThinMediumGap = 16 + nBorderNumber = 15; + break; + case SvxBorderLineStyle::THINTHICK_LARGEGAP: + // thinThickLargeGap = 17 + nBorderNumber = 17; + break; + case SvxBorderLineStyle::THICKTHIN_LARGEGAP: + // thickThinLargeGap = 18 + // thinThickThinLargeGap = 19 + nBorderNumber = 18; + break; + case SvxBorderLineStyle::FINE_DASHED: + // dashSmallGap = 22 + nBorderNumber = 22; + break; + case SvxBorderLineStyle::EMBOSSED: + // threeDEmboss = 24 + nBorderNumber = 24; + break; + case SvxBorderLineStyle::ENGRAVED: + // threeDEngrave = 25 + nBorderNumber = 25; + break; + case SvxBorderLineStyle::OUTSET: + // outset = 26 + nBorderNumber = 25; + break; + case SvxBorderLineStyle::INSET: + // inset = 27 + nBorderNumber = 27; + break; + } + + return nBorderNumber * fWidth; +} +} + +bool Style::operator<( const Style& rOther) const +{ + if(!maImplStyle && !rOther.maImplStyle) + { + // are equal + return false; + } + + if (maImplStyle && maImplStyle->mbWordTableCell) + { + // The below code would first compare based on the border width, Word compares based on its + // calculated weight, do that in the compat case. + double fLW = GetWordTableCellBorderWeight(*this); + double fRW = GetWordTableCellBorderWeight(rOther); + if (!rtl::math::approxEqual(fLW, fRW)) + { + return fLW < fRW; + } + } + + // different total widths -> this<rOther, if this is thinner + double nLW = GetWidth(); + double nRW = rOther.GetWidth(); + if( !rtl::math::approxEqual(nLW, nRW) ) return nLW < nRW; + + // one line double, the other single -> this<rOther, if this is single + if( (Secn() == 0) != (rOther.Secn() == 0) ) return Secn() == 0; + + // both lines double with different distances -> this<rOther, if distance of this greater + if( (Secn() && rOther.Secn()) && !rtl::math::approxEqual(Dist(), rOther.Dist()) ) return Dist() > rOther.Dist(); + + // both lines single and 1 unit thick, only one is dotted -> this<rOther, if this is dotted + if ((nLW == 1) && !Secn() && !rOther.Secn() && (Type() != rOther.Type())) return Type() > rOther.Type(); + + // seem to be equal + return false; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/framelinkarray.cxx b/svx/source/dialog/framelinkarray.cxx new file mode 100644 index 000000000..dd8081bf3 --- /dev/null +++ b/svx/source/dialog/framelinkarray.cxx @@ -0,0 +1,1290 @@ +/* -*- 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/framelinkarray.hxx> + +#include <math.h> +#include <vector> +#include <set> +#include <algorithm> +#include <tools/debug.hxx> +#include <tools/gen.hxx> +#include <vcl/canvastools.hxx> +#include <svx/sdr/primitive2d/sdrframeborderprimitive2d.hxx> +#include <basegfx/matrix/b2dhommatrixtools.hxx> + +namespace svx::frame { + +namespace { + +class Cell +{ +private: + Style maLeft; + Style maRight; + Style maTop; + Style maBottom; + Style maTLBR; + Style maBLTR; + +public: + long mnAddLeft; + long mnAddRight; + long mnAddTop; + long mnAddBottom; + + SvxRotateMode meRotMode; + double mfOrientation; + + bool mbMergeOrig; + bool mbOverlapX; + bool mbOverlapY; + +public: + explicit Cell(); + + void SetStyleLeft(const Style& rStyle) { maLeft = rStyle; } + void SetStyleRight(const Style& rStyle) { maRight = rStyle; } + void SetStyleTop(const Style& rStyle) { maTop = rStyle; } + void SetStyleBottom(const Style& rStyle) { maBottom = rStyle; } + void SetStyleTLBR(const Style& rStyle) { maTLBR = rStyle; } + void SetStyleBLTR(const Style& rStyle) { maBLTR = rStyle; } + + const Style& GetStyleLeft() const { return maLeft; } + const Style& GetStyleRight() const { return maRight; } + const Style& GetStyleTop() const { return maTop; } + const Style& GetStyleBottom() const { return maBottom; } + const Style& GetStyleTLBR() const { return maTLBR; } + const Style& GetStyleBLTR() const { return maBLTR; } + + bool IsMerged() const { return mbMergeOrig || mbOverlapX || mbOverlapY; } + bool IsRotated() const { return mfOrientation != 0.0; } + + void MirrorSelfX(); + + basegfx::B2DHomMatrix CreateCoordinateSystem(const Array& rArray, size_t nCol, size_t nRow, bool bExpandMerged) const; +}; + +} + +typedef std::vector< Cell > CellVec; + +basegfx::B2DHomMatrix Cell::CreateCoordinateSystem(const Array& rArray, size_t nCol, size_t nRow, bool bExpandMerged) const +{ + basegfx::B2DHomMatrix aRetval; + const basegfx::B2DRange aRange(rArray.GetCellRange(nCol, nRow, bExpandMerged)); + + if(!aRange.isEmpty()) + { + basegfx::B2DPoint aOrigin(aRange.getMinimum()); + basegfx::B2DVector aX(aRange.getWidth(), 0.0); + basegfx::B2DVector aY(0.0, aRange.getHeight()); + + if (IsRotated() && SvxRotateMode::SVX_ROTATE_MODE_STANDARD != meRotMode) + { + // when rotated, adapt values. Get Skew (cos/sin == 1/tan) + const double fSkew(aY.getY() * (cos(mfOrientation) / sin(mfOrientation))); + + switch (meRotMode) + { + case SvxRotateMode::SVX_ROTATE_MODE_TOP: + // shear Y-Axis + aY.setX(-fSkew); + break; + case SvxRotateMode::SVX_ROTATE_MODE_CENTER: + // shear origin half, Y full + aOrigin.setX(aOrigin.getX() + (fSkew * 0.5)); + aY.setX(-fSkew); + break; + case SvxRotateMode::SVX_ROTATE_MODE_BOTTOM: + // shear origin full, Y full + aOrigin.setX(aOrigin.getX() + fSkew); + aY.setX(-fSkew); + break; + default: // SvxRotateMode::SVX_ROTATE_MODE_STANDARD, already excluded above + break; + } + } + + // use column vectors as coordinate axes, homogen column for translation + aRetval = basegfx::utils::createCoordinateSystemTransform(aOrigin, aX, aY); + } + + return aRetval; +} + +Cell::Cell() : + mnAddLeft( 0 ), + mnAddRight( 0 ), + mnAddTop( 0 ), + mnAddBottom( 0 ), + meRotMode(SvxRotateMode::SVX_ROTATE_MODE_STANDARD ), + mfOrientation( 0.0 ), + mbMergeOrig( false ), + mbOverlapX( false ), + mbOverlapY( false ) +{ +} + +void Cell::MirrorSelfX() +{ + std::swap( maLeft, maRight ); + std::swap( mnAddLeft, mnAddRight ); + maLeft.MirrorSelf(); + maRight.MirrorSelf(); + mfOrientation = -mfOrientation; +} + + +static void lclRecalcCoordVec( std::vector<long>& rCoords, const std::vector<long>& rSizes ) +{ + DBG_ASSERT( rCoords.size() == rSizes.size() + 1, "lclRecalcCoordVec - inconsistent vectors" ); + auto aCIt = rCoords.begin(); + for( const auto& rSize : rSizes ) + { + *(aCIt + 1) = *aCIt + rSize; + ++aCIt; + } +} + +static void lclSetMergedRange( CellVec& rCells, size_t nWidth, size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow ) +{ + for( size_t nCol = nFirstCol; nCol <= nLastCol; ++nCol ) + { + for( size_t nRow = nFirstRow; nRow <= nLastRow; ++nRow ) + { + Cell& rCell = rCells[ nRow * nWidth + nCol ]; + rCell.mbMergeOrig = false; + rCell.mbOverlapX = nCol > nFirstCol; + rCell.mbOverlapY = nRow > nFirstRow; + } + } + rCells[ nFirstRow * nWidth + nFirstCol ].mbMergeOrig = true; +} + + +static const Style OBJ_STYLE_NONE; +static const Cell OBJ_CELL_NONE; + +struct ArrayImpl +{ + CellVec maCells; + std::vector<long> maWidths; + std::vector<long> maHeights; + mutable std::vector<long> maXCoords; + mutable std::vector<long> maYCoords; + size_t mnWidth; + size_t mnHeight; + size_t mnFirstClipCol; + size_t mnFirstClipRow; + size_t mnLastClipCol; + size_t mnLastClipRow; + mutable bool mbXCoordsDirty; + mutable bool mbYCoordsDirty; + bool mbMayHaveCellRotation; + + explicit ArrayImpl( size_t nWidth, size_t nHeight ); + + bool IsValidPos( size_t nCol, size_t nRow ) const + { return (nCol < mnWidth) && (nRow < mnHeight); } + size_t GetIndex( size_t nCol, size_t nRow ) const + { return nRow * mnWidth + nCol; } + + const Cell& GetCell( size_t nCol, size_t nRow ) const; + Cell& GetCellAcc( size_t nCol, size_t nRow ); + + size_t GetMergedFirstCol( size_t nCol, size_t nRow ) const; + size_t GetMergedFirstRow( size_t nCol, size_t nRow ) const; + size_t GetMergedLastCol( size_t nCol, size_t nRow ) const; + size_t GetMergedLastRow( size_t nCol, size_t nRow ) const; + + const Cell& GetMergedOriginCell( size_t nCol, size_t nRow ) const; + + bool IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const; + bool IsMergedOverlappedRight( size_t nCol, size_t nRow ) const; + bool IsMergedOverlappedTop( size_t nCol, size_t nRow ) const; + bool IsMergedOverlappedBottom( size_t nCol, size_t nRow ) const; + + bool IsInClipRange( size_t nCol, size_t nRow ) const; + bool IsColInClipRange( size_t nCol ) const; + bool IsRowInClipRange( size_t nRow ) const; + + size_t GetMirrorCol( size_t nCol ) const { return mnWidth - nCol - 1; } + + long GetColPosition( size_t nCol ) const; + long GetRowPosition( size_t nRow ) const; + + bool HasCellRotation() const; +}; + +ArrayImpl::ArrayImpl( size_t nWidth, size_t nHeight ) : + mnWidth( nWidth ), + mnHeight( nHeight ), + mnFirstClipCol( 0 ), + mnFirstClipRow( 0 ), + mnLastClipCol( nWidth - 1 ), + mnLastClipRow( nHeight - 1 ), + mbXCoordsDirty( false ), + mbYCoordsDirty( false ), + mbMayHaveCellRotation( false ) +{ + // default-construct all vectors + maCells.resize( mnWidth * mnHeight ); + maWidths.resize( mnWidth, 0 ); + maHeights.resize( mnHeight, 0 ); + maXCoords.resize( mnWidth + 1, 0 ); + maYCoords.resize( mnHeight + 1, 0 ); +} + +const Cell& ArrayImpl::GetCell( size_t nCol, size_t nRow ) const +{ + return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : OBJ_CELL_NONE; +} + +Cell& ArrayImpl::GetCellAcc( size_t nCol, size_t nRow ) +{ + static Cell aDummy; + return IsValidPos( nCol, nRow ) ? maCells[ GetIndex( nCol, nRow ) ] : aDummy; +} + +size_t ArrayImpl::GetMergedFirstCol( size_t nCol, size_t nRow ) const +{ + size_t nFirstCol = nCol; + while( (nFirstCol > 0) && GetCell( nFirstCol, nRow ).mbOverlapX ) --nFirstCol; + return nFirstCol; +} + +size_t ArrayImpl::GetMergedFirstRow( size_t nCol, size_t nRow ) const +{ + size_t nFirstRow = nRow; + while( (nFirstRow > 0) && GetCell( nCol, nFirstRow ).mbOverlapY ) --nFirstRow; + return nFirstRow; +} + +size_t ArrayImpl::GetMergedLastCol( size_t nCol, size_t nRow ) const +{ + size_t nLastCol = nCol + 1; + while( (nLastCol < mnWidth) && GetCell( nLastCol, nRow ).mbOverlapX ) ++nLastCol; + return nLastCol - 1; +} + +size_t ArrayImpl::GetMergedLastRow( size_t nCol, size_t nRow ) const +{ + size_t nLastRow = nRow + 1; + while( (nLastRow < mnHeight) && GetCell( nCol, nLastRow ).mbOverlapY ) ++nLastRow; + return nLastRow - 1; +} + +const Cell& ArrayImpl::GetMergedOriginCell( size_t nCol, size_t nRow ) const +{ + return GetCell( GetMergedFirstCol( nCol, nRow ), GetMergedFirstRow( nCol, nRow ) ); +} + +bool ArrayImpl::IsMergedOverlappedLeft( size_t nCol, size_t nRow ) const +{ + const Cell& rCell = GetCell( nCol, nRow ); + return rCell.mbOverlapX || (rCell.mnAddLeft > 0); +} + +bool ArrayImpl::IsMergedOverlappedRight( size_t nCol, size_t nRow ) const +{ + return GetCell( nCol + 1, nRow ).mbOverlapX || (GetCell( nCol, nRow ).mnAddRight > 0); +} + +bool ArrayImpl::IsMergedOverlappedTop( size_t nCol, size_t nRow ) const +{ + const Cell& rCell = GetCell( nCol, nRow ); + return rCell.mbOverlapY || (rCell.mnAddTop > 0); +} + +bool ArrayImpl::IsMergedOverlappedBottom( size_t nCol, size_t nRow ) const +{ + return GetCell( nCol, nRow + 1 ).mbOverlapY || (GetCell( nCol, nRow ).mnAddBottom > 0); +} + +bool ArrayImpl::IsColInClipRange( size_t nCol ) const +{ + return (mnFirstClipCol <= nCol) && (nCol <= mnLastClipCol); +} + +bool ArrayImpl::IsRowInClipRange( size_t nRow ) const +{ + return (mnFirstClipRow <= nRow) && (nRow <= mnLastClipRow); +} + +bool ArrayImpl::IsInClipRange( size_t nCol, size_t nRow ) const +{ + return IsColInClipRange( nCol ) && IsRowInClipRange( nRow ); +} + +long ArrayImpl::GetColPosition( size_t nCol ) const +{ + if( mbXCoordsDirty ) + { + lclRecalcCoordVec( maXCoords, maWidths ); + mbXCoordsDirty = false; + } + return maXCoords[ nCol ]; +} + +long ArrayImpl::GetRowPosition( size_t nRow ) const +{ + if( mbYCoordsDirty ) + { + lclRecalcCoordVec( maYCoords, maHeights ); + mbYCoordsDirty = false; + } + return maYCoords[ nRow ]; +} + +bool ArrayImpl::HasCellRotation() const +{ + // check cell array + for (const auto& aCell : maCells) + { + if (aCell.IsRotated()) + { + return true; + } + } + + return false; +} + +namespace { + +class MergedCellIterator +{ +public: + explicit MergedCellIterator( const Array& rArray, size_t nCol, size_t nRow ); + + bool Is() const { return (mnCol <= mnLastCol) && (mnRow <= mnLastRow); } + size_t Col() const { return mnCol; } + size_t Row() const { return mnRow; } + + MergedCellIterator& operator++(); + +private: + size_t mnFirstCol; + size_t mnFirstRow; + size_t mnLastCol; + size_t mnLastRow; + size_t mnCol; + size_t mnRow; +}; + +} + +MergedCellIterator::MergedCellIterator( const Array& rArray, size_t nCol, size_t nRow ) +{ + DBG_ASSERT( rArray.IsMerged( nCol, nRow ), "svx::frame::MergedCellIterator::MergedCellIterator - not in merged range" ); + rArray.GetMergedRange( mnFirstCol, mnFirstRow, mnLastCol, mnLastRow, nCol, nRow ); + mnCol = mnFirstCol; + mnRow = mnFirstRow; +} + +MergedCellIterator& MergedCellIterator::operator++() +{ + DBG_ASSERT( Is(), "svx::frame::MergedCellIterator::operator++() - already invalid" ); + if( ++mnCol > mnLastCol ) + { + mnCol = mnFirstCol; + ++mnRow; + } + return *this; +} + + +#define DBG_FRAME_CHECK( cond, funcname, error ) DBG_ASSERT( cond, "svx::frame::Array::" funcname " - " error ) +#define DBG_FRAME_CHECK_COL( col, funcname ) DBG_FRAME_CHECK( (col) < GetColCount(), funcname, "invalid column index" ) +#define DBG_FRAME_CHECK_ROW( row, funcname ) DBG_FRAME_CHECK( (row) < GetRowCount(), funcname, "invalid row index" ) +#define DBG_FRAME_CHECK_COLROW( col, row, funcname ) DBG_FRAME_CHECK( ((col) < GetColCount()) && ((row) < GetRowCount()), funcname, "invalid cell index" ) +#define DBG_FRAME_CHECK_COL_1( col, funcname ) DBG_FRAME_CHECK( (col) <= GetColCount(), funcname, "invalid column index" ) +#define DBG_FRAME_CHECK_ROW_1( row, funcname ) DBG_FRAME_CHECK( (row) <= GetRowCount(), funcname, "invalid row index" ) + + +#define CELL( col, row ) mxImpl->GetCell( col, row ) +#define CELLACC( col, row ) mxImpl->GetCellAcc( col, row ) +#define ORIGCELL( col, row ) mxImpl->GetMergedOriginCell( col, row ) + + +Array::Array() +{ + Initialize( 0, 0 ); +} + +Array::~Array() +{ +} + +// array size and column/row indexes +void Array::Initialize( size_t nWidth, size_t nHeight ) +{ + mxImpl.reset( new ArrayImpl( nWidth, nHeight ) ); +} + +size_t Array::GetColCount() const +{ + return mxImpl->mnWidth; +} + +size_t Array::GetRowCount() const +{ + return mxImpl->mnHeight; +} + +size_t Array::GetCellCount() const +{ + return mxImpl->maCells.size(); +} + +size_t Array::GetCellIndex( size_t nCol, size_t nRow, bool bRTL ) const +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetCellIndex" ); + if (bRTL) + nCol = mxImpl->GetMirrorCol(nCol); + return mxImpl->GetIndex( nCol, nRow ); +} + +// cell border styles +void Array::SetCellStyleLeft( size_t nCol, size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleLeft" ); + CELLACC( nCol, nRow ).SetStyleLeft(rStyle); +} + +void Array::SetCellStyleRight( size_t nCol, size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleRight" ); + CELLACC( nCol, nRow ).SetStyleRight(rStyle); +} + +void Array::SetCellStyleTop( size_t nCol, size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTop" ); + CELLACC( nCol, nRow ).SetStyleTop(rStyle); +} + +void Array::SetCellStyleBottom( size_t nCol, size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBottom" ); + CELLACC( nCol, nRow ).SetStyleBottom(rStyle); +} + +void Array::SetCellStyleTLBR( size_t nCol, size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleTLBR" ); + CELLACC( nCol, nRow ).SetStyleTLBR(rStyle); +} + +void Array::SetCellStyleBLTR( size_t nCol, size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleBLTR" ); + CELLACC( nCol, nRow ).SetStyleBLTR(rStyle); +} + +void Array::SetCellStyleDiag( size_t nCol, size_t nRow, const Style& rTLBR, const Style& rBLTR ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetCellStyleDiag" ); + Cell& rCell = CELLACC( nCol, nRow ); + rCell.SetStyleTLBR(rTLBR); + rCell.SetStyleBLTR(rBLTR); +} + +void Array::SetColumnStyleLeft( size_t nCol, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleLeft" ); + for( size_t nRow = 0; nRow < mxImpl->mnHeight; ++nRow ) + SetCellStyleLeft( nCol, nRow, rStyle ); +} + +void Array::SetColumnStyleRight( size_t nCol, const Style& rStyle ) +{ + DBG_FRAME_CHECK_COL( nCol, "SetColumnStyleRight" ); + for( size_t nRow = 0; nRow < mxImpl->mnHeight; ++nRow ) + SetCellStyleRight( nCol, nRow, rStyle ); +} + +void Array::SetRowStyleTop( size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleTop" ); + for( size_t nCol = 0; nCol < mxImpl->mnWidth; ++nCol ) + SetCellStyleTop( nCol, nRow, rStyle ); +} + +void Array::SetRowStyleBottom( size_t nRow, const Style& rStyle ) +{ + DBG_FRAME_CHECK_ROW( nRow, "SetRowStyleBottom" ); + for( size_t nCol = 0; nCol < mxImpl->mnWidth; ++nCol ) + SetCellStyleBottom( nCol, nRow, rStyle ); +} + +void Array::SetCellRotation(size_t nCol, size_t nRow, SvxRotateMode eRotMode, double fOrientation) +{ + DBG_FRAME_CHECK_COLROW(nCol, nRow, "SetCellRotation"); + Cell& rTarget = CELLACC(nCol, nRow); + rTarget.meRotMode = eRotMode; + rTarget.mfOrientation = fOrientation; + + if (!mxImpl->mbMayHaveCellRotation) + { + // activate once when a cell gets actually rotated to allow fast + // answering HasCellRotation() calls + mxImpl->mbMayHaveCellRotation = rTarget.IsRotated(); + } +} + +bool Array::HasCellRotation() const +{ + if (!mxImpl->mbMayHaveCellRotation) + { + // never set, no need to check + return false; + } + + return mxImpl->HasCellRotation(); +} + +const Style& Array::GetCellStyleLeft( size_t nCol, size_t nRow ) const +{ + // outside clipping rows or overlapped in merged cells: invisible + if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedLeft( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // left clipping border: always own left style + if( nCol == mxImpl->mnFirstClipCol ) + return ORIGCELL( nCol, nRow ).GetStyleLeft(); + // right clipping border: always right style of left neighbor cell + if( nCol == mxImpl->mnLastClipCol + 1 ) + return ORIGCELL( nCol - 1, nRow ).GetStyleRight(); + // outside clipping columns: invisible + if( !mxImpl->IsColInClipRange( nCol ) ) + return OBJ_STYLE_NONE; + // inside clipping range: maximum of own left style and right style of left neighbor cell + return std::max( ORIGCELL( nCol, nRow ).GetStyleLeft(), ORIGCELL( nCol - 1, nRow ).GetStyleRight() ); +} + +const Style& Array::GetCellStyleRight( size_t nCol, size_t nRow ) const +{ + // outside clipping rows or overlapped in merged cells: invisible + if( !mxImpl->IsRowInClipRange( nRow ) || mxImpl->IsMergedOverlappedRight( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // left clipping border: always left style of right neighbor cell + if( nCol + 1 == mxImpl->mnFirstClipCol ) + return ORIGCELL( nCol + 1, nRow ).GetStyleLeft(); + // right clipping border: always own right style + if( nCol == mxImpl->mnLastClipCol ) + return ORIGCELL( nCol, nRow ).GetStyleRight(); + // outside clipping columns: invisible + if( !mxImpl->IsColInClipRange( nCol ) ) + return OBJ_STYLE_NONE; + // inside clipping range: maximum of own right style and left style of right neighbor cell + return std::max( ORIGCELL( nCol, nRow ).GetStyleRight(), ORIGCELL( nCol + 1, nRow ).GetStyleLeft() ); +} + +const Style& Array::GetCellStyleTop( size_t nCol, size_t nRow ) const +{ + // outside clipping columns or overlapped in merged cells: invisible + if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedTop( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // top clipping border: always own top style + if( nRow == mxImpl->mnFirstClipRow ) + return ORIGCELL( nCol, nRow ).GetStyleTop(); + // bottom clipping border: always bottom style of top neighbor cell + if( nRow == mxImpl->mnLastClipRow + 1 ) + return ORIGCELL( nCol, nRow - 1 ).GetStyleBottom(); + // outside clipping rows: invisible + if( !mxImpl->IsRowInClipRange( nRow ) ) + return OBJ_STYLE_NONE; + // inside clipping range: maximum of own top style and bottom style of top neighbor cell + return std::max( ORIGCELL( nCol, nRow ).GetStyleTop(), ORIGCELL( nCol, nRow - 1 ).GetStyleBottom() ); +} + +const Style& Array::GetCellStyleBottom( size_t nCol, size_t nRow ) const +{ + // outside clipping columns or overlapped in merged cells: invisible + if( !mxImpl->IsColInClipRange( nCol ) || mxImpl->IsMergedOverlappedBottom( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // top clipping border: always top style of bottom neighbor cell + if( nRow + 1 == mxImpl->mnFirstClipRow ) + return ORIGCELL( nCol, nRow + 1 ).GetStyleTop(); + // bottom clipping border: always own bottom style + if( nRow == mxImpl->mnLastClipRow ) + return ORIGCELL( nCol, nRow ).GetStyleBottom(); + // outside clipping rows: invisible + if( !mxImpl->IsRowInClipRange( nRow ) ) + return OBJ_STYLE_NONE; + // inside clipping range: maximum of own bottom style and top style of bottom neighbor cell + return std::max( ORIGCELL( nCol, nRow ).GetStyleBottom(), ORIGCELL( nCol, nRow + 1 ).GetStyleTop() ); +} + +const Style& Array::GetCellStyleTLBR( size_t nCol, size_t nRow ) const +{ + return CELL( nCol, nRow ).GetStyleTLBR(); +} + +const Style& Array::GetCellStyleBLTR( size_t nCol, size_t nRow ) const +{ + return CELL( nCol, nRow ).GetStyleBLTR(); +} + +const Style& Array::GetCellStyleTL( size_t nCol, size_t nRow ) const +{ + // not in clipping range: always invisible + if( !mxImpl->IsInClipRange( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // return style only for top-left cell + size_t nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow ); + size_t nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow ); + return ((nCol == nFirstCol) && (nRow == nFirstRow)) ? + CELL( nFirstCol, nFirstRow ).GetStyleTLBR() : OBJ_STYLE_NONE; +} + +const Style& Array::GetCellStyleBR( size_t nCol, size_t nRow ) const +{ + // not in clipping range: always invisible + if( !mxImpl->IsInClipRange( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // return style only for bottom-right cell + size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow ); + size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow ); + return ((nCol == nLastCol) && (nRow == nLastRow)) ? + CELL( mxImpl->GetMergedFirstCol( nCol, nRow ), mxImpl->GetMergedFirstRow( nCol, nRow ) ).GetStyleTLBR() : OBJ_STYLE_NONE; +} + +const Style& Array::GetCellStyleBL( size_t nCol, size_t nRow ) const +{ + // not in clipping range: always invisible + if( !mxImpl->IsInClipRange( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // return style only for bottom-left cell + size_t nFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow ); + size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow ); + return ((nCol == nFirstCol) && (nRow == nLastRow)) ? + CELL( nFirstCol, mxImpl->GetMergedFirstRow( nCol, nRow ) ).GetStyleBLTR() : OBJ_STYLE_NONE; +} + +const Style& Array::GetCellStyleTR( size_t nCol, size_t nRow ) const +{ + // not in clipping range: always invisible + if( !mxImpl->IsInClipRange( nCol, nRow ) ) + return OBJ_STYLE_NONE; + // return style only for top-right cell + size_t nFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow ); + size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow ); + return ((nCol == nLastCol) && (nRow == nFirstRow)) ? + CELL( mxImpl->GetMergedFirstCol( nCol, nRow ), nFirstRow ).GetStyleBLTR() : OBJ_STYLE_NONE; +} + +// cell merging +void Array::SetMergedRange( size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow ) +{ + DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetMergedRange" ); + DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetMergedRange" ); +#if OSL_DEBUG_LEVEL >= 2 + { + bool bFound = false; + for( size_t nCurrCol = nFirstCol; !bFound && (nCurrCol <= nLastCol); ++nCurrCol ) + for( size_t nCurrRow = nFirstRow; !bFound && (nCurrRow <= nLastRow); ++nCurrRow ) + bFound = CELL( nCurrCol, nCurrRow ).IsMerged(); + DBG_FRAME_CHECK( !bFound, "SetMergedRange", "overlapping merged ranges" ); + } +#endif + if( mxImpl->IsValidPos( nFirstCol, nFirstRow ) && mxImpl->IsValidPos( nLastCol, nLastRow ) ) + lclSetMergedRange( mxImpl->maCells, mxImpl->mnWidth, nFirstCol, nFirstRow, nLastCol, nLastRow ); +} + +void Array::SetAddMergedLeftSize( size_t nCol, size_t nRow, long nAddSize ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedLeftSize" ); + DBG_FRAME_CHECK( mxImpl->GetMergedFirstCol( nCol, nRow ) == 0, "SetAddMergedLeftSize", "additional border inside array" ); + for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt ) + CELLACC( aIt.Col(), aIt.Row() ).mnAddLeft = nAddSize; +} + +void Array::SetAddMergedRightSize( size_t nCol, size_t nRow, long nAddSize ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedRightSize" ); + DBG_FRAME_CHECK( mxImpl->GetMergedLastCol( nCol, nRow ) + 1 == mxImpl->mnWidth, "SetAddMergedRightSize", "additional border inside array" ); + for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt ) + CELLACC( aIt.Col(), aIt.Row() ).mnAddRight = nAddSize; +} + +void Array::SetAddMergedTopSize( size_t nCol, size_t nRow, long nAddSize ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedTopSize" ); + DBG_FRAME_CHECK( mxImpl->GetMergedFirstRow( nCol, nRow ) == 0, "SetAddMergedTopSize", "additional border inside array" ); + for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt ) + CELLACC( aIt.Col(), aIt.Row() ).mnAddTop = nAddSize; +} + +void Array::SetAddMergedBottomSize( size_t nCol, size_t nRow, long nAddSize ) +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "SetAddMergedBottomSize" ); + DBG_FRAME_CHECK( mxImpl->GetMergedLastRow( nCol, nRow ) + 1 == mxImpl->mnHeight, "SetAddMergedBottomSize", "additional border inside array" ); + for( MergedCellIterator aIt( *this, nCol, nRow ); aIt.Is(); ++aIt ) + CELLACC( aIt.Col(), aIt.Row() ).mnAddBottom = nAddSize; +} + +bool Array::IsMerged( size_t nCol, size_t nRow ) const +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "IsMerged" ); + return CELL( nCol, nRow ).IsMerged(); +} + +void Array::GetMergedOrigin( size_t& rnFirstCol, size_t& rnFirstRow, size_t nCol, size_t nRow ) const +{ + DBG_FRAME_CHECK_COLROW( nCol, nRow, "GetMergedOrigin" ); + rnFirstCol = mxImpl->GetMergedFirstCol( nCol, nRow ); + rnFirstRow = mxImpl->GetMergedFirstRow( nCol, nRow ); +} + +void Array::GetMergedRange( size_t& rnFirstCol, size_t& rnFirstRow, + size_t& rnLastCol, size_t& rnLastRow, size_t nCol, size_t nRow ) const +{ + GetMergedOrigin( rnFirstCol, rnFirstRow, nCol, nRow ); + rnLastCol = mxImpl->GetMergedLastCol( nCol, nRow ); + rnLastRow = mxImpl->GetMergedLastRow( nCol, nRow ); +} + +// clipping +void Array::SetClipRange( size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow ) +{ + DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "SetClipRange" ); + DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "SetClipRange" ); + mxImpl->mnFirstClipCol = nFirstCol; + mxImpl->mnFirstClipRow = nFirstRow; + mxImpl->mnLastClipCol = nLastCol; + mxImpl->mnLastClipRow = nLastRow; +} + +// cell coordinates +void Array::SetXOffset( long nXOffset ) +{ + mxImpl->maXCoords[ 0 ] = nXOffset; + mxImpl->mbXCoordsDirty = true; +} + +void Array::SetYOffset( long nYOffset ) +{ + mxImpl->maYCoords[ 0 ] = nYOffset; + mxImpl->mbYCoordsDirty = true; +} + +void Array::SetColWidth( size_t nCol, long nWidth ) +{ + DBG_FRAME_CHECK_COL( nCol, "SetColWidth" ); + mxImpl->maWidths[ nCol ] = nWidth; + mxImpl->mbXCoordsDirty = true; +} + +void Array::SetRowHeight( size_t nRow, long nHeight ) +{ + DBG_FRAME_CHECK_ROW( nRow, "SetRowHeight" ); + mxImpl->maHeights[ nRow ] = nHeight; + mxImpl->mbYCoordsDirty = true; +} + +void Array::SetAllColWidths( long nWidth ) +{ + std::fill( mxImpl->maWidths.begin(), mxImpl->maWidths.end(), nWidth ); + mxImpl->mbXCoordsDirty = true; +} + +void Array::SetAllRowHeights( long nHeight ) +{ + std::fill( mxImpl->maHeights.begin(), mxImpl->maHeights.end(), nHeight ); + mxImpl->mbYCoordsDirty = true; +} + +long Array::GetColPosition( size_t nCol ) const +{ + DBG_FRAME_CHECK_COL_1( nCol, "GetColPosition" ); + return mxImpl->GetColPosition( nCol ); +} + +long Array::GetRowPosition( size_t nRow ) const +{ + DBG_FRAME_CHECK_ROW_1( nRow, "GetRowPosition" ); + return mxImpl->GetRowPosition( nRow ); +} + +long Array::GetColWidth( size_t nFirstCol, size_t nLastCol ) const +{ + DBG_FRAME_CHECK_COL( nFirstCol, "GetColWidth" ); + DBG_FRAME_CHECK_COL( nLastCol, "GetColWidth" ); + return GetColPosition( nLastCol + 1 ) - GetColPosition( nFirstCol ); +} + +long Array::GetRowHeight( size_t nFirstRow, size_t nLastRow ) const +{ + DBG_FRAME_CHECK_ROW( nFirstRow, "GetRowHeight" ); + DBG_FRAME_CHECK_ROW( nLastRow, "GetRowHeight" ); + return GetRowPosition( nLastRow + 1 ) - GetRowPosition( nFirstRow ); +} + +long Array::GetWidth() const +{ + return GetColPosition( mxImpl->mnWidth ) - GetColPosition( 0 ); +} + +long Array::GetHeight() const +{ + return GetRowPosition( mxImpl->mnHeight ) - GetRowPosition( 0 ); +} + +basegfx::B2DRange Array::GetCellRange( size_t nCol, size_t nRow, bool bExpandMerged ) const +{ + if(bExpandMerged) + { + // get the Range of the fully expanded cell (if merged) + const size_t nFirstCol(mxImpl->GetMergedFirstCol( nCol, nRow )); + const size_t nFirstRow(mxImpl->GetMergedFirstRow( nCol, nRow )); + const size_t nLastCol(mxImpl->GetMergedLastCol( nCol, nRow )); + const size_t nLastRow(mxImpl->GetMergedLastRow( nCol, nRow )); + const Point aPoint( GetColPosition( nFirstCol ), GetRowPosition( nFirstRow ) ); + const Size aSize( GetColWidth( nFirstCol, nLastCol ) + 1, GetRowHeight( nFirstRow, nLastRow ) + 1 ); + tools::Rectangle aRect(aPoint, aSize); + + // adjust rectangle for partly visible merged cells + const Cell& rCell = CELL( nCol, nRow ); + + if( rCell.IsMerged() ) + { + // not *sure* what exactly this is good for, + // it is just a hard set extension at merged cells, + // probably *should* be included in the above extended + // GetColPosition/GetColWidth already. This might be + // added due to GetColPosition/GetColWidth not working + // correctly over PageChanges (if used), but not sure. + aRect.AdjustLeft( -(rCell.mnAddLeft) ); + aRect.AdjustRight(rCell.mnAddRight ); + aRect.AdjustTop( -(rCell.mnAddTop) ); + aRect.AdjustBottom(rCell.mnAddBottom ); + } + + return vcl::unotools::b2DRectangleFromRectangle(aRect); + } + else + { + const Point aPoint( GetColPosition( nCol ), GetRowPosition( nRow ) ); + const Size aSize( GetColWidth( nCol, nCol ) + 1, GetRowHeight( nRow, nRow ) + 1 ); + const tools::Rectangle aRect(aPoint, aSize); + + return vcl::unotools::b2DRectangleFromRectangle(aRect); + } +} + +// mirroring +void Array::MirrorSelfX() +{ + CellVec aNewCells; + aNewCells.reserve( GetCellCount() ); + + size_t nCol, nRow; + for( nRow = 0; nRow < mxImpl->mnHeight; ++nRow ) + { + for( nCol = 0; nCol < mxImpl->mnWidth; ++nCol ) + { + aNewCells.push_back( CELL( mxImpl->GetMirrorCol( nCol ), nRow ) ); + aNewCells.back().MirrorSelfX(); + } + } + for( nRow = 0; nRow < mxImpl->mnHeight; ++nRow ) + { + for( nCol = 0; nCol < mxImpl->mnWidth; ++nCol ) + { + if( CELL( nCol, nRow ).mbMergeOrig ) + { + size_t nLastCol = mxImpl->GetMergedLastCol( nCol, nRow ); + size_t nLastRow = mxImpl->GetMergedLastRow( nCol, nRow ); + lclSetMergedRange( aNewCells, mxImpl->mnWidth, + mxImpl->GetMirrorCol( nLastCol ), nRow, + mxImpl->GetMirrorCol( nCol ), nLastRow ); + } + } + } + mxImpl->maCells.swap( aNewCells ); + + std::reverse( mxImpl->maWidths.begin(), mxImpl->maWidths.end() ); + mxImpl->mbXCoordsDirty = true; +} + +// drawing +static void HelperCreateHorizontalEntry( + const Array& rArray, + const Style& rStyle, + size_t col, + size_t row, + const basegfx::B2DPoint& rOrigin, + const basegfx::B2DVector& rX, + const basegfx::B2DVector& rY, + drawinglayer::primitive2d::SdrFrameBorderDataVector& rData, + bool bUpper, + const Color* pForceColor) +{ + // prepare SdrFrameBorderData + rData.emplace_back( + bUpper ? rOrigin : basegfx::B2DPoint(rOrigin + rY), + rX, + rStyle, + pForceColor); + drawinglayer::primitive2d::SdrFrameBorderData& rInstance(rData.back()); + + // get involved styles at start + const Style& rStartFromTR(rArray.GetCellStyleBL( col, row - 1 )); + const Style& rStartLFromT(rArray.GetCellStyleLeft( col, row - 1 )); + const Style& rStartLFromL(rArray.GetCellStyleTop( col - 1, row )); + const Style& rStartLFromB(rArray.GetCellStyleLeft( col, row )); + const Style& rStartFromBR(rArray.GetCellStyleTL( col, row )); + + rInstance.addSdrConnectStyleData(true, rStartFromTR, rX - rY, false); + rInstance.addSdrConnectStyleData(true, rStartLFromT, -rY, true); + rInstance.addSdrConnectStyleData(true, rStartLFromL, -rX, true); + rInstance.addSdrConnectStyleData(true, rStartLFromB, rY, false); + rInstance.addSdrConnectStyleData(true, rStartFromBR, rX + rY, false); + + // get involved styles at end + const Style& rEndFromTL(rArray.GetCellStyleBR( col, row - 1 )); + const Style& rEndRFromT(rArray.GetCellStyleRight( col, row - 1 )); + const Style& rEndRFromR(rArray.GetCellStyleTop( col + 1, row )); + const Style& rEndRFromB(rArray.GetCellStyleRight( col, row )); + const Style& rEndFromBL(rArray.GetCellStyleTR( col, row )); + + rInstance.addSdrConnectStyleData(false, rEndFromTL, -rX - rY, true); + rInstance.addSdrConnectStyleData(false, rEndRFromT, -rY, true); + rInstance.addSdrConnectStyleData(false, rEndRFromR, rX, false); + rInstance.addSdrConnectStyleData(false, rEndRFromB, rY, false); + rInstance.addSdrConnectStyleData(false, rEndFromBL, rY - rX, true); +} + +static void HelperCreateVerticalEntry( + const Array& rArray, + const Style& rStyle, + size_t col, + size_t row, + const basegfx::B2DPoint& rOrigin, + const basegfx::B2DVector& rX, + const basegfx::B2DVector& rY, + drawinglayer::primitive2d::SdrFrameBorderDataVector& rData, + bool bLeft, + const Color* pForceColor) +{ + // prepare SdrFrameBorderData + rData.emplace_back( + bLeft ? rOrigin : basegfx::B2DPoint(rOrigin + rX), + rY, + rStyle, + pForceColor); + drawinglayer::primitive2d::SdrFrameBorderData& rInstance(rData.back()); + + // get involved styles at start + const Style& rStartFromBL(rArray.GetCellStyleTR( col - 1, row )); + const Style& rStartTFromL(rArray.GetCellStyleTop( col - 1, row )); + const Style& rStartTFromT(rArray.GetCellStyleLeft( col, row - 1 )); + const Style& rStartTFromR(rArray.GetCellStyleTop( col, row )); + const Style& rStartFromBR(rArray.GetCellStyleTL( col, row )); + + rInstance.addSdrConnectStyleData(true, rStartFromBR, rX + rY, false); + rInstance.addSdrConnectStyleData(true, rStartTFromR, rX, false); + rInstance.addSdrConnectStyleData(true, rStartTFromT, -rY, true); + rInstance.addSdrConnectStyleData(true, rStartTFromL, -rX, true); + rInstance.addSdrConnectStyleData(true, rStartFromBL, rY - rX, true); + + // get involved styles at end + const Style& rEndFromTL(rArray.GetCellStyleBR( col - 1, row )); + const Style& rEndBFromL(rArray.GetCellStyleBottom( col - 1, row )); + const Style& rEndBFromB(rArray.GetCellStyleLeft( col, row + 1 )); + const Style& rEndBFromR(rArray.GetCellStyleBottom( col, row )); + const Style& rEndFromTR(rArray.GetCellStyleBL( col, row )); + + rInstance.addSdrConnectStyleData(false, rEndFromTR, rX - rY, false); + rInstance.addSdrConnectStyleData(false, rEndBFromR, rX, false); + rInstance.addSdrConnectStyleData(false, rEndBFromB, rY, false); + rInstance.addSdrConnectStyleData(false, rEndBFromL, -rX, true); + rInstance.addSdrConnectStyleData(false, rEndFromTL, -rY - rX, true); +} + +drawinglayer::primitive2d::Primitive2DContainer Array::CreateB2DPrimitiveRange( + size_t nFirstCol, size_t nFirstRow, size_t nLastCol, size_t nLastRow, + const Color* pForceColor ) const +{ + DBG_FRAME_CHECK_COLROW( nFirstCol, nFirstRow, "CreateB2DPrimitiveRange" ); + DBG_FRAME_CHECK_COLROW( nLastCol, nLastRow, "CreateB2DPrimitiveRange" ); + + // It may be necessary to extend the loop ranges by one cell to the outside, + // when possible. This is needed e.g. when there is in Calc a Cell with an + // upper CellBorder using DoubleLine and that is right/left connected upwards + // to also DoubleLine. These upper DoubleLines will be extended to meet the + // lower of the upper CellBorder and thus have graphical parts that are + // displayed one cell below and right/left of the target cell - analog to + // other examples in all other directions. + // It would be possible to explicitly test this (if possible by indices at all) + // looping and testing the styles in the outer cells to detect this, but since + // for other usages (e.g. UI) usually nFirstRow==0 and nLastRow==GetRowCount()-1 + // (and analog for Col) it is okay to just expand the range when available. + // Do *not* change nFirstRow/nLastRow due to these needed to the boolean tests + // below (!) + // Checked usages, this method is used in Calc EditView/Print/Export stuff and + // in UI (Dialog), not for Writer Tables and Draw/Impress tables. All usages + // seem okay with this change, so I will add it. + const size_t nStartRow(nFirstRow > 0 ? nFirstRow - 1 : nFirstRow); + const size_t nEndRow(nLastRow < GetRowCount() - 1 ? nLastRow + 1 : nLastRow); + const size_t nStartCol(nFirstCol > 0 ? nFirstCol - 1 : nFirstCol); + const size_t nEndCol(nLastCol < GetColCount() - 1 ? nLastCol + 1 : nLastCol); + + // prepare SdrFrameBorderDataVector + std::shared_ptr<drawinglayer::primitive2d::SdrFrameBorderDataVector> aData( + std::make_shared<drawinglayer::primitive2d::SdrFrameBorderDataVector>()); + + // remember for which merged cells crossed lines were already created. To + // do so, hold the size_t cell index in a set for fast check + std::set< size_t > aMergedCells; + + for (size_t nRow(nStartRow); nRow <= nEndRow; ++nRow) + { + for (size_t nCol(nStartCol); nCol <= nEndCol; ++nCol) + { + // get Cell and CoordinateSystem (*only* for this Cell, do *not* expand for + // merged cells (!)), check if used (non-empty vectors) + const Cell& rCell(CELL(nCol, nRow)); + basegfx::B2DHomMatrix aCoordinateSystem(rCell.CreateCoordinateSystem(*this, nCol, nRow, false)); + basegfx::B2DVector aX(basegfx::utils::getColumn(aCoordinateSystem, 0)); + basegfx::B2DVector aY(basegfx::utils::getColumn(aCoordinateSystem, 1)); + + // get needed local values + basegfx::B2DPoint aOrigin(basegfx::utils::getColumn(aCoordinateSystem, 2)); + const bool bOverlapX(rCell.mbOverlapX); + const bool bFirstCol(nCol == nFirstCol); + + // handle rotation: If cell is rotated, handle lower/right edge inside + // this local geometry due to the created CoordinateSystem already representing + // the needed transformations. + const bool bRotated(rCell.IsRotated()); + + // Additionally avoid double-handling by suppressing handling when self not rotated, + // but above/left is rotated and thus already handled. Two directly connected + // rotated will paint/create both edges, they might be rotated differently. + const bool bSupressLeft(!bRotated && nCol > nFirstCol && CELL(nCol - 1, nRow).IsRotated()); + const bool bSuppressAbove(!bRotated && nRow > nFirstRow && CELL(nCol, nRow - 1).IsRotated()); + + if(!aX.equalZero() && !aY.equalZero()) + { + // additionally needed local values + const bool bOverlapY(rCell.mbOverlapY); + const bool bLastCol(nCol == nLastCol); + const bool bFirstRow(nRow == nFirstRow); + const bool bLastRow(nRow == nLastRow); + + // create upper line for this Cell + if ((!bOverlapY // true for first line in merged cells or cells + || bFirstRow) // true for non_Calc usages of this tooling + && !bSuppressAbove) // true when above is not rotated, so edge is already handled (see bRotated) + { + // get CellStyle - method will take care to get the correct one, e.g. + // for merged cells (it uses ORIGCELL that works with topLeft's of these) + const Style& rTop(GetCellStyleTop(nCol, nRow)); + + if(rTop.IsUsed()) + { + HelperCreateHorizontalEntry(*this, rTop, nCol, nRow, aOrigin, aX, aY, *aData, true, pForceColor); + } + } + + // create lower line for this Cell + if (bLastRow // true for non_Calc usages of this tooling + || bRotated) // true if cell is rotated, handle lower edge in local geometry + { + const Style& rBottom(GetCellStyleBottom(nCol, nRow)); + + if(rBottom.IsUsed()) + { + HelperCreateHorizontalEntry(*this, rBottom, nCol, nRow + 1, aOrigin, aX, aY, *aData, false, pForceColor); + } + } + + // create left line for this Cell + if ((!bOverlapX // true for first column in merged cells or cells + || bFirstCol) // true for non_Calc usages of this tooling + && !bSupressLeft) // true when left is not rotated, so edge is already handled (see bRotated) + { + const Style& rLeft(GetCellStyleLeft(nCol, nRow)); + + if(rLeft.IsUsed()) + { + HelperCreateVerticalEntry(*this, rLeft, nCol, nRow, aOrigin, aX, aY, *aData, true, pForceColor); + } + } + + // create right line for this Cell + if (bLastCol // true for non_Calc usages of this tooling + || bRotated) // true if cell is rotated, handle right edge in local geometry + { + const Style& rRight(GetCellStyleRight(nCol, nRow)); + + if(rRight.IsUsed()) + { + HelperCreateVerticalEntry(*this, rRight, nCol + 1, nRow, aOrigin, aX, aY, *aData, false, pForceColor); + } + } + + // check for crossed lines, these need special treatment, especially + // for merged cells, see below + const Style& rTLBR(GetCellStyleTLBR(nCol, nRow)); + const Style& rBLTR(GetCellStyleBLTR(nCol, nRow)); + + if(rTLBR.IsUsed() || rBLTR.IsUsed()) + { + bool bContinue(true); + + if(rCell.IsMerged()) + { + // first check if this merged cell was already handled. To do so, + // calculate and use the index of the TopLeft cell + const size_t _nMergedFirstCol(mxImpl->GetMergedFirstCol(nCol, nRow)); + const size_t _nMergedFirstRow(mxImpl->GetMergedFirstRow(nCol, nRow)); + const size_t nIndexOfMergedCell(mxImpl->GetIndex(_nMergedFirstCol, _nMergedFirstRow)); + bContinue = (aMergedCells.end() == aMergedCells.find(nIndexOfMergedCell)); + + if(bContinue) + { + // not found, add now to mark as handled + aMergedCells.insert(nIndexOfMergedCell); + + // when merged, get extended coordinate system and derived values + // for the full range of this merged cell + aCoordinateSystem = rCell.CreateCoordinateSystem(*this, nCol, nRow, true); + aX = basegfx::utils::getColumn(aCoordinateSystem, 0); + aY = basegfx::utils::getColumn(aCoordinateSystem, 1); + aOrigin = basegfx::utils::getColumn(aCoordinateSystem, 2); + } + } + + if(bContinue) + { + if(rTLBR.IsUsed()) + { + /// top-left and bottom-right Style Tables + aData->emplace_back( + aOrigin, + aX + aY, + rTLBR, + pForceColor); + drawinglayer::primitive2d::SdrFrameBorderData& rInstance(aData->back()); + + /// Fill top-left Style Table + const Style& rTLFromRight(GetCellStyleTop(nCol, nRow)); + const Style& rTLFromBottom(GetCellStyleLeft(nCol, nRow)); + + rInstance.addSdrConnectStyleData(true, rTLFromRight, aX, false); + rInstance.addSdrConnectStyleData(true, rTLFromBottom, aY, false); + + /// Fill bottom-right Style Table + const Style& rBRFromBottom(GetCellStyleRight(nCol, nRow)); + const Style& rBRFromLeft(GetCellStyleBottom(nCol, nRow)); + + rInstance.addSdrConnectStyleData(false, rBRFromBottom, -aY, true); + rInstance.addSdrConnectStyleData(false, rBRFromLeft, -aX, true); + } + + if(rBLTR.IsUsed()) + { + /// bottom-left and top-right Style Tables + aData->emplace_back( + aOrigin + aY, + aX - aY, + rBLTR, + pForceColor); + drawinglayer::primitive2d::SdrFrameBorderData& rInstance(aData->back()); + + /// Fill bottom-left Style Table + const Style& rBLFromTop(GetCellStyleLeft(nCol, nRow)); + const Style& rBLFromBottom(GetCellStyleBottom(nCol, nRow)); + + rInstance.addSdrConnectStyleData(true, rBLFromTop, -aY, true); + rInstance.addSdrConnectStyleData(true, rBLFromBottom, aX, false); + + /// Fill top-right Style Table + const Style& rTRFromLeft(GetCellStyleTop(nCol, nRow)); + const Style& rTRFromBottom(GetCellStyleRight(nCol, nRow)); + + rInstance.addSdrConnectStyleData(false, rTRFromLeft, -aX, true); + rInstance.addSdrConnectStyleData(false, rTRFromBottom, aY, false); + } + } + } + } + else + { + // create left line for this Cell + if ((!bOverlapX // true for first column in merged cells or cells + || bFirstCol) // true for non_Calc usages of this tooling + && !bSupressLeft) // true when left is not rotated, so edge is already handled (see bRotated) + { + const Style& rLeft(GetCellStyleLeft(nCol, nRow)); + + if (rLeft.IsUsed()) + { + HelperCreateVerticalEntry(*this, rLeft, nCol, nRow, aOrigin, aX, aY, *aData, true, pForceColor); + } + } + } + } + } + + // create instance of SdrFrameBorderPrimitive2D if + // SdrFrameBorderDataVector is used + drawinglayer::primitive2d::Primitive2DContainer aSequence; + + if(!aData->empty()) + { + aSequence.append( + drawinglayer::primitive2d::Primitive2DReference( + new drawinglayer::primitive2d::SdrFrameBorderPrimitive2D( + aData, + true))); // force visualization to minimal one discrete unit (pixel) + } + + return aSequence; +} + +drawinglayer::primitive2d::Primitive2DContainer Array::CreateB2DPrimitiveArray() const +{ + drawinglayer::primitive2d::Primitive2DContainer aPrimitives; + + if (mxImpl->mnWidth && mxImpl->mnHeight) + { + aPrimitives = CreateB2DPrimitiveRange(0, 0, mxImpl->mnWidth - 1, mxImpl->mnHeight - 1, nullptr); + } + + return aPrimitives; +} + +#undef ORIGCELL +#undef CELLACC +#undef CELL +#undef DBG_FRAME_CHECK_ROW_1 +#undef DBG_FRAME_CHECK_COL_1 +#undef DBG_FRAME_CHECK_COLROW +#undef DBG_FRAME_CHECK_ROW +#undef DBG_FRAME_CHECK_COL +#undef DBG_FRAME_CHECK + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/frmdirlbox.cxx b/svx/source/dialog/frmdirlbox.cxx new file mode 100644 index 000000000..375a41867 --- /dev/null +++ b/svx/source/dialog/frmdirlbox.cxx @@ -0,0 +1,32 @@ +/* -*- 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/frmdirlbox.hxx> + +namespace svx +{ +FrameDirectionListBox::FrameDirectionListBox(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) +{ +} + +FrameDirectionListBox::~FrameDirectionListBox() {} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/frmsel.cxx b/svx/source/dialog/frmsel.cxx new file mode 100644 index 000000000..b4d80e2f7 --- /dev/null +++ b/svx/source/dialog/frmsel.cxx @@ -0,0 +1,1277 @@ +/* -*- 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 <svx/frmsel.hxx> +#include <vcl/event.hxx> +#include <sal/log.hxx> +#include <tools/debug.hxx> + +#include <algorithm> +#include <math.h> +#include <frmselimpl.hxx> +#include <AccessibleFrameSelector.hxx> +#include <com/sun/star/accessibility/AccessibleEventId.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <drawinglayer/processor2d/processor2dtools.hxx> +#include <drawinglayer/processor2d/baseprocessor2d.hxx> + +#include <bitmaps.hlst> + +using namespace ::com::sun::star; +using namespace ::editeng; + +namespace svx { + +using ::com::sun::star::uno::Reference; +using ::com::sun::star::uno::Any; +using ::com::sun::star::accessibility::XAccessible; +using namespace ::com::sun::star::accessibility; + +// global functions from framebordertype.hxx + +FrameBorderType GetFrameBorderTypeFromIndex( size_t nIndex ) +{ + DBG_ASSERT( nIndex < o3tl::make_unsigned(FRAMEBORDERTYPE_COUNT), + "svx::GetFrameBorderTypeFromIndex - invalid index" ); + return static_cast< FrameBorderType >( nIndex + 1 ); +} + +size_t GetIndexFromFrameBorderType( FrameBorderType eBorder ) +{ + DBG_ASSERT( eBorder != FrameBorderType::NONE, + "svx::GetIndexFromFrameBorderType - invalid frame border type" ); + return static_cast< size_t >( eBorder ) - 1; +} + +namespace +{ + +/** Space between outer control border and any graphical element of the control. */ +const long FRAMESEL_GEOM_OUTER = 2; + +/** Space between arrows and usable inner area. */ +const long FRAMESEL_GEOM_INNER = 3; + +/** Maximum width to draw a frame border style. */ +const long FRAMESEL_GEOM_WIDTH = 9; + +/** Additional margin for click area of outer lines. */ +const long FRAMESEL_GEOM_ADD_CLICK_OUTER = 5; + +/** Additional margin for click area of inner lines. */ +const long FRAMESEL_GEOM_ADD_CLICK_INNER = 2; + + +/** Returns the corresponding flag for a frame border. */ +FrameSelFlags lclGetFlagFromType( FrameBorderType eBorder ) +{ + switch( eBorder ) + { + case FrameBorderType::Left: return FrameSelFlags::Left; + case FrameBorderType::Right: return FrameSelFlags::Right; + case FrameBorderType::Top: return FrameSelFlags::Top; + case FrameBorderType::Bottom: return FrameSelFlags::Bottom; + case FrameBorderType::Horizontal: return FrameSelFlags::InnerHorizontal; + case FrameBorderType::Vertical: return FrameSelFlags::InnerVertical; + case FrameBorderType::TLBR: return FrameSelFlags::DiagonalTLBR; + case FrameBorderType::BLTR: return FrameSelFlags::DiagonalBLTR; + case FrameBorderType::NONE : break; + } + return FrameSelFlags::NONE; +} + +/** Merges the rSource polypolygon into the rDest polypolygon. */ +void lclPolyPolyUnion( tools::PolyPolygon& rDest, const tools::PolyPolygon& rSource ) +{ + const tools::PolyPolygon aTmp( rDest ); + aTmp.GetUnion( rSource, rDest ); +} + +} // namespace + +FrameBorder::FrameBorder( FrameBorderType eType ) : + meType( eType ), + meState( FrameBorderState::Hide ), + meKeyLeft( FrameBorderType::NONE ), + meKeyRight( FrameBorderType::NONE ), + meKeyTop( FrameBorderType::NONE ), + meKeyBottom( FrameBorderType::NONE ), + mbEnabled( false ), + mbSelected( false ) +{ +} + +void FrameBorder::Enable( FrameSelFlags nFlags ) +{ + mbEnabled = bool(nFlags & lclGetFlagFromType( meType )); + if( !mbEnabled ) + SetState( FrameBorderState::Hide ); +} + +void FrameBorder::SetCoreStyle( const SvxBorderLine* pStyle ) +{ + if( pStyle ) + maCoreStyle = *pStyle; + else + maCoreStyle = SvxBorderLine(); + + // from twips to points + maUIStyle.Set( &maCoreStyle, FrameBorder::GetDefaultPatternScale(), FRAMESEL_GEOM_WIDTH ); + meState = maUIStyle.IsUsed() ? FrameBorderState::Show : FrameBorderState::Hide; +} + +void FrameBorder::SetState( FrameBorderState eState ) +{ + meState = eState; + switch( meState ) + { + case FrameBorderState::Show: + SAL_WARN( "svx.dialog", "svx::FrameBorder::SetState - use SetCoreStyle to make border visible" ); + break; + case FrameBorderState::Hide: + maCoreStyle = SvxBorderLine(); + maUIStyle.Clear(); + break; + case FrameBorderState::DontCare: + maCoreStyle = SvxBorderLine(); + maUIStyle = frame::Style(3, 0, 0, SvxBorderLineStyle::SOLID, FrameBorder::GetDefaultPatternScale()); //OBJ_FRAMESTYLE_DONTCARE + break; + } +} + +void FrameBorder::AddFocusPolygon( const tools::Polygon& rFocus ) +{ + lclPolyPolyUnion( maFocusArea, rFocus ); +} + +void FrameBorder::MergeFocusToPolyPolygon( tools::PolyPolygon& rPPoly ) const +{ + lclPolyPolyUnion( rPPoly, maFocusArea ); +} + +void FrameBorder::AddClickRect( const tools::Rectangle& rRect ) +{ + lclPolyPolyUnion( maClickArea, tools::Polygon( rRect ) ); +} + +bool FrameBorder::ContainsClickPoint( const Point& rPos ) const +{ + return vcl::Region( maClickArea ).IsInside( rPos ); +} + +tools::Rectangle FrameBorder::GetClickBoundRect() const +{ + return maClickArea.GetBoundRect(); +} + +void FrameBorder::SetKeyboardNeighbors( + FrameBorderType eLeft, FrameBorderType eRight, FrameBorderType eTop, FrameBorderType eBottom ) +{ + meKeyLeft = eLeft; + meKeyRight = eRight; + meKeyTop = eTop; + meKeyBottom = eBottom; +} + +FrameBorderType FrameBorder::GetKeyboardNeighbor( sal_uInt16 nKeyCode ) const +{ + FrameBorderType eBorder = FrameBorderType::NONE; + switch( nKeyCode ) + { + case KEY_LEFT: eBorder = meKeyLeft; break; + case KEY_RIGHT: eBorder = meKeyRight; break; + case KEY_UP: eBorder = meKeyTop; break; + case KEY_DOWN: eBorder = meKeyBottom; break; + default: SAL_WARN( "svx.dialog", "svx::FrameBorder::GetKeyboardNeighbor - unknown key code" ); + } + return eBorder; +} + +FrameSelectorImpl::FrameSelectorImpl( FrameSelector& rFrameSel ) : + mrFrameSel( rFrameSel ), + mpVirDev( VclPtr<VirtualDevice>::Create() ), + maLeft( FrameBorderType::Left ), + maRight( FrameBorderType::Right ), + maTop( FrameBorderType::Top ), + maBottom( FrameBorderType::Bottom ), + maHor( FrameBorderType::Horizontal ), + maVer( FrameBorderType::Vertical ), + maTLBR( FrameBorderType::TLBR ), + maBLTR( FrameBorderType::BLTR ), + mnFlags( FrameSelFlags::Outer ), + mnCtrlSize( 0 ), + mnArrowSize( 0 ), + mnLine1( 0 ), + mnLine2( 0 ), + mnLine3( 0 ), + mnFocusOffs( 0 ), + mbHor( false ), + mbVer( false ), + mbTLBR( false ), + mbBLTR( false ), + mbFullRepaint( true ), + mbAutoSelect( true ), + mbHCMode( false ), + maChildVec( 8 ) +{ + maAllBorders.resize( FRAMEBORDERTYPE_COUNT, nullptr ); + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::Left ) ] = &maLeft; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::Right ) ] = &maRight; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::Top ) ] = &maTop; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::Bottom ) ] = &maBottom; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::Horizontal ) ] = &maHor; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::Vertical ) ] = &maVer; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::TLBR ) ] = &maTLBR; + maAllBorders[ GetIndexFromFrameBorderType( FrameBorderType::BLTR ) ] = &maBLTR; +#if OSL_DEBUG_LEVEL >= 2 + { + bool bOk = true; + for( FrameBorderCIter aIt( maAllBorders ); bOk && aIt.Is(); bOk = (*aIt != 0), ++aIt ); + DBG_ASSERT( bOk, "svx::FrameSelectorImpl::FrameSelectorImpl - missing entry in maAllBorders" ); + } +#endif + // left neighbor right neighbor upper neighbor lower neighbor + maLeft.SetKeyboardNeighbors( FrameBorderType::NONE, FrameBorderType::TLBR, FrameBorderType::Top, FrameBorderType::Bottom ); + maRight.SetKeyboardNeighbors( FrameBorderType::BLTR, FrameBorderType::NONE, FrameBorderType::Top, FrameBorderType::Bottom ); + maTop.SetKeyboardNeighbors( FrameBorderType::Left, FrameBorderType::Right, FrameBorderType::NONE, FrameBorderType::TLBR ); + maBottom.SetKeyboardNeighbors( FrameBorderType::Left, FrameBorderType::Right, FrameBorderType::BLTR, FrameBorderType::NONE ); + maHor.SetKeyboardNeighbors( FrameBorderType::Left, FrameBorderType::Right, FrameBorderType::TLBR, FrameBorderType::BLTR ); + maVer.SetKeyboardNeighbors( FrameBorderType::TLBR, FrameBorderType::BLTR, FrameBorderType::Top, FrameBorderType::Bottom ); + maTLBR.SetKeyboardNeighbors( FrameBorderType::Left, FrameBorderType::Vertical, FrameBorderType::Top, FrameBorderType::Horizontal ); + maBLTR.SetKeyboardNeighbors( FrameBorderType::Vertical, FrameBorderType::Right, FrameBorderType::Horizontal, FrameBorderType::Bottom ); + + Initialize(mnFlags); +} + +FrameSelectorImpl::~FrameSelectorImpl() + +{ + for( auto& rpChild : maChildVec ) + if( rpChild.is() ) + rpChild->Invalidate(); +} + +// initialization +void FrameSelectorImpl::Initialize( FrameSelFlags nFlags ) +{ + mnFlags = nFlags; + + maEnabBorders.clear(); + for( FrameBorderIter aIt( maAllBorders ); aIt.Is(); ++aIt ) + { + (*aIt)->Enable( mnFlags ); + if( (*aIt)->IsEnabled() ) + maEnabBorders.push_back( *aIt ); + } + mbHor = maHor.IsEnabled(); + mbVer = maVer.IsEnabled(); + mbTLBR = maTLBR.IsEnabled(); + mbBLTR = maBLTR.IsEnabled(); + + InitVirtualDevice(); +} + +void FrameSelectorImpl::InitColors() +{ + const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings(); + maBackCol = rSettings.GetFieldColor(); + mbHCMode = rSettings.GetHighContrastMode(); + maArrowCol = rSettings.GetFieldTextColor(); + maMarkCol.operator=(maBackCol).Merge(maArrowCol, mbHCMode ? 0x80 : 0xC0); + maHCLineCol = rSettings.GetLabelTextColor(); +} + +static const OUStringLiteral aImageIds[] = +{ + RID_SVXBMP_FRMSEL_ARROW1, + RID_SVXBMP_FRMSEL_ARROW2, + RID_SVXBMP_FRMSEL_ARROW3, + RID_SVXBMP_FRMSEL_ARROW4, + RID_SVXBMP_FRMSEL_ARROW5, + RID_SVXBMP_FRMSEL_ARROW6, + RID_SVXBMP_FRMSEL_ARROW7, + RID_SVXBMP_FRMSEL_ARROW8, + RID_SVXBMP_FRMSEL_ARROW9, + RID_SVXBMP_FRMSEL_ARROW10, + RID_SVXBMP_FRMSEL_ARROW11, + RID_SVXBMP_FRMSEL_ARROW12, + RID_SVXBMP_FRMSEL_ARROW13, + RID_SVXBMP_FRMSEL_ARROW14, + RID_SVXBMP_FRMSEL_ARROW15, + RID_SVXBMP_FRMSEL_ARROW16 +}; + +void FrameSelectorImpl::InitArrowImageList() +{ + maArrows.clear(); + + /* Build the arrow images bitmap with current colors. */ + Color pColorAry1[3]; + Color pColorAry2[3]; + pColorAry1[0] = Color( 0, 0, 0 ); + pColorAry2[0] = maArrowCol; // black -> arrow color + pColorAry1[1] = Color( 0, 255, 0 ); + pColorAry2[1] = maMarkCol; // green -> marker color + pColorAry1[2] = Color( 255, 0, 255 ); + pColorAry2[2] = maBackCol; // magenta -> background + + assert(SAL_N_ELEMENTS(aImageIds) == 16); + for (size_t i = 0; i < SAL_N_ELEMENTS(aImageIds); ++i) + { + BitmapEx aBmpEx(aImageIds[i]); + aBmpEx.Replace(pColorAry1, pColorAry2, 3); + maArrows.emplace_back(aBmpEx); + } + assert(maArrows.size() == 16); + + mnArrowSize = maArrows[0].GetSizePixel().Height(); +} + +void FrameSelectorImpl::InitGlobalGeometry() +{ + Size aCtrlSize(mrFrameSel.GetOutputSizePixel()); + /* nMinSize is the lower of width and height (control will always be squarish). + FRAMESEL_GEOM_OUTER is the minimal distance between inner control border + and any element. */ + long nMinSize = std::min( aCtrlSize.Width(), aCtrlSize.Height() ) - 2 * FRAMESEL_GEOM_OUTER; + /* nFixedSize is the size all existing elements need in one direction: + the diag. arrow, space betw. arrow and frame border, outer frame border, + inner frame border, other outer frame border, space betw. frame border + and arrow, the other arrow. */ + long nFixedSize = 2 * mnArrowSize + 2 * FRAMESEL_GEOM_INNER + 3 * FRAMESEL_GEOM_WIDTH; + /* nBetwBordersSize contains the size between an outer and inner frame border (made odd). */ + long nBetwBordersSize = (((nMinSize - nFixedSize) / 2) - 1) | 1; + + /* The final size of the usable area. At least do not get negative */ + mnCtrlSize = 2 * nBetwBordersSize + nFixedSize; + mnCtrlSize = std::max(mnCtrlSize, static_cast<long>(0)); + mpVirDev->SetOutputSizePixel( Size( mnCtrlSize, mnCtrlSize ) ); + + /* Center the virtual device in the control. */ + maVirDevPos = Point( (aCtrlSize.Width() - mnCtrlSize) / 2, (aCtrlSize.Height() - mnCtrlSize) / 2 ); +} + +void FrameSelectorImpl::InitBorderGeometry() +{ + size_t nCol, nCols, nRow, nRows; + + // Global border geometry values + /* mnLine* is the middle point inside a frame border (i.e. mnLine1 is mid X inside left border). */ + mnLine1 = mnArrowSize + FRAMESEL_GEOM_INNER + FRAMESEL_GEOM_WIDTH / 2; + mnLine2 = mnCtrlSize / 2; + mnLine3 = 2 * mnLine2 - mnLine1; + + // Frame helper array + maArray.Initialize( mbVer ? 2 : 1, mbHor ? 2 : 1 ); + + maArray.SetXOffset( mnLine1 ); + maArray.SetAllColWidths( (mbVer ? mnLine2 : mnLine3) - mnLine1 ); + + maArray.SetYOffset( mnLine1 ); + maArray.SetAllRowHeights( (mbHor ? mnLine2 : mnLine3) - mnLine1 ); + + // Focus polygons + /* Width for focus rectangles from center of frame borders. */ + mnFocusOffs = FRAMESEL_GEOM_WIDTH / 2 + 1; + + maLeft.ClearFocusArea(); + maVer.ClearFocusArea(); + maRight.ClearFocusArea(); + maTop.ClearFocusArea(); + maHor.ClearFocusArea(); + maBottom.ClearFocusArea(); + + maLeft.AddFocusPolygon( tools::Rectangle( mnLine1 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine1 + mnFocusOffs, mnLine3 + mnFocusOffs ) ); + maVer.AddFocusPolygon( tools::Rectangle( mnLine2 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine2 + mnFocusOffs, mnLine3 + mnFocusOffs ) ); + maRight.AddFocusPolygon( tools::Rectangle( mnLine3 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine3 + mnFocusOffs ) ); + maTop.AddFocusPolygon( tools::Rectangle( mnLine1 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine1 + mnFocusOffs ) ); + maHor.AddFocusPolygon( tools::Rectangle( mnLine1 - mnFocusOffs, mnLine2 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine2 + mnFocusOffs ) ); + maBottom.AddFocusPolygon( tools::Rectangle( mnLine1 - mnFocusOffs, mnLine3 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine3 + mnFocusOffs ) ); + + for( nCol = 0, nCols = maArray.GetColCount(); nCol < nCols; ++nCol ) + { + for( nRow = 0, nRows = maArray.GetRowCount(); nRow < nRows; ++nRow ) + { + const basegfx::B2DRange aCellRange(maArray.GetCellRange( nCol, nRow, true )); + const tools::Rectangle aRect( + basegfx::fround(aCellRange.getMinX()), basegfx::fround(aCellRange.getMinY()), + basegfx::fround(aCellRange.getMaxX()), basegfx::fround(aCellRange.getMaxY())); + const double fHorDiagAngle(atan2(fabs(aCellRange.getHeight()), fabs(aCellRange.getWidth()))); + const double fVerDiagAngle(fHorDiagAngle > 0.0 ? F_PI2 - fHorDiagAngle : 0.0); + const long nDiagFocusOffsX(basegfx::fround(-mnFocusOffs / tan(fHorDiagAngle) + mnFocusOffs / sin(fHorDiagAngle))); + const long nDiagFocusOffsY(basegfx::fround(-mnFocusOffs / tan(fVerDiagAngle) + mnFocusOffs / sin(fVerDiagAngle))); + + std::vector< Point > aFocusVec; + aFocusVec.emplace_back( aRect.Left() - mnFocusOffs, aRect.Top() + nDiagFocusOffsY ); + aFocusVec.emplace_back( aRect.Left() - mnFocusOffs, aRect.Top() - mnFocusOffs ); + aFocusVec.emplace_back( aRect.Left() + nDiagFocusOffsX, aRect.Top() - mnFocusOffs ); + aFocusVec.emplace_back( aRect.Right() + mnFocusOffs, aRect.Bottom() - nDiagFocusOffsY ); + aFocusVec.emplace_back( aRect.Right() + mnFocusOffs, aRect.Bottom() + mnFocusOffs ); + aFocusVec.emplace_back( aRect.Right() - nDiagFocusOffsX, aRect.Bottom() + mnFocusOffs ); + maTLBR.AddFocusPolygon( tools::Polygon( static_cast< sal_uInt16 >( aFocusVec.size() ), aFocusVec.data() ) ); + + aFocusVec.clear(); + aFocusVec.emplace_back( aRect.Right() + mnFocusOffs, aRect.Top() + nDiagFocusOffsY ); + aFocusVec.emplace_back( aRect.Right() + mnFocusOffs, aRect.Top() - mnFocusOffs ); + aFocusVec.emplace_back( aRect.Right() - nDiagFocusOffsX, aRect.Top() - mnFocusOffs ); + aFocusVec.emplace_back( aRect.Left() - mnFocusOffs, aRect.Bottom() - nDiagFocusOffsY ); + aFocusVec.emplace_back( aRect.Left() - mnFocusOffs, aRect.Bottom() + mnFocusOffs ); + aFocusVec.emplace_back( aRect.Left() + nDiagFocusOffsX, aRect.Bottom() + mnFocusOffs ); + maBLTR.AddFocusPolygon( tools::Polygon( static_cast< sal_uInt16 >( aFocusVec.size() ), aFocusVec.data() ) ); + } + } + + // Click areas + for( FrameBorderIter aIt( maAllBorders ); aIt.Is(); ++aIt ) + (*aIt)->ClearClickArea(); + + /* Additional space for click area: is added to the space available to draw + the frame borders. For instance left frame border: + - To left, top, and bottom always big additional space (outer area). + - To right: Dependent on existence of inner vertical frame border + (if enabled, use less space). + */ + long nClO = FRAMESEL_GEOM_WIDTH / 2 + FRAMESEL_GEOM_ADD_CLICK_OUTER; + long nClI = (mbTLBR && mbBLTR) ? (FRAMESEL_GEOM_WIDTH / 2 + FRAMESEL_GEOM_ADD_CLICK_INNER) : nClO; + long nClH = mbHor ? nClI : nClO; // additional space dependent of horizontal inner border + long nClV = mbVer ? nClI : nClO; // additional space dependent of vertical inner border + + maLeft.AddClickRect( tools::Rectangle( mnLine1 - nClO, mnLine1 - nClO, mnLine1 + nClV, mnLine3 + nClO ) ); + maVer.AddClickRect( tools::Rectangle( mnLine2 - nClI, mnLine1 - nClO, mnLine2 + nClI, mnLine3 + nClO ) ); + maRight.AddClickRect( tools::Rectangle( mnLine3 - nClV, mnLine1 - nClO, mnLine3 + nClO, mnLine3 + nClO ) ); + maTop.AddClickRect( tools::Rectangle( mnLine1 - nClO, mnLine1 - nClO, mnLine3 + nClO, mnLine1 + nClH ) ); + maHor.AddClickRect( tools::Rectangle( mnLine1 - nClO, mnLine2 - nClI, mnLine3 + nClO, mnLine2 + nClI ) ); + maBottom.AddClickRect( tools::Rectangle( mnLine1 - nClO, mnLine3 - nClH, mnLine3 + nClO, mnLine3 + nClO ) ); + + /* Diagonal frame borders use the remaining space between outer and inner frame borders. */ + if( mbTLBR || mbBLTR ) + { + for( nCol = 0, nCols = maArray.GetColCount(); nCol < nCols; ++nCol ) + { + for( nRow = 0, nRows = maArray.GetRowCount(); nRow < nRows; ++nRow ) + { + // the usable area between horizontal/vertical frame borders of current quadrant + const basegfx::B2DRange aCellRange(maArray.GetCellRange( nCol, nRow, true )); + const tools::Rectangle aRect( + basegfx::fround(aCellRange.getMinX()) + nClV + 1, basegfx::fround(aCellRange.getMinY()) + nClH + 1, + basegfx::fround(aCellRange.getMaxX()) - nClV + 1, basegfx::fround(aCellRange.getMaxY()) - nClH + 1); + + /* Both diagonal frame borders enabled. */ + if( mbTLBR && mbBLTR ) + { + // single areas + Point aMid( aRect.Center() ); + maTLBR.AddClickRect( tools::Rectangle( aRect.TopLeft(), aMid ) ); + maTLBR.AddClickRect( tools::Rectangle( aMid + Point( 1, 1 ), aRect.BottomRight() ) ); + maBLTR.AddClickRect( tools::Rectangle( aRect.Left(), aMid.Y() + 1, aMid.X(), aRect.Bottom() ) ); + maBLTR.AddClickRect( tools::Rectangle( aMid.X() + 1, aRect.Top(), aRect.Right(), aMid.Y() ) ); + // centered rectangle for both frame borders + tools::Rectangle aMidRect( aRect.TopLeft(), Size( aRect.GetWidth() / 3, aRect.GetHeight() / 3 ) ); + aMidRect.Move( (aRect.GetWidth() - aMidRect.GetWidth()) / 2, (aRect.GetHeight() - aMidRect.GetHeight()) / 2 ); + maTLBR.AddClickRect( aMidRect ); + maBLTR.AddClickRect( aMidRect ); + } + /* One of the diagonal frame borders enabled - use entire rectangle. */ + else if( mbTLBR && !mbBLTR ) // top-left to bottom-right only + maTLBR.AddClickRect( aRect ); + else if( !mbTLBR && mbBLTR ) // bottom-left to top-right only + maBLTR.AddClickRect( aRect ); + } + } + } +} + +void FrameSelectorImpl::InitVirtualDevice() +{ + // initialize resources + InitColors(); + InitArrowImageList(); + + sizeChanged(); +} + +void FrameSelectorImpl::sizeChanged() +{ + // initialize geometry + InitGlobalGeometry(); + InitBorderGeometry(); + + DoInvalidate( true ); +} + +// frame border access +const FrameBorder& FrameSelectorImpl::GetBorder( FrameBorderType eBorder ) const +{ + size_t nIndex = GetIndexFromFrameBorderType( eBorder ); + if( nIndex < maAllBorders.size() ) + return *maAllBorders[ nIndex ]; + SAL_WARN( "svx.dialog", "svx::FrameSelectorImpl::GetBorder - unknown border type" ); + return maTop; +} + +FrameBorder& FrameSelectorImpl::GetBorderAccess( FrameBorderType eBorder ) +{ + return const_cast< FrameBorder& >( GetBorder( eBorder ) ); +} + +// drawing +void FrameSelectorImpl::DrawBackground() +{ + // clear the area + mpVirDev->SetLineColor(); + mpVirDev->SetFillColor( maBackCol ); + mpVirDev->DrawRect( tools::Rectangle( Point( 0, 0 ), mpVirDev->GetOutputSizePixel() ) ); + + // draw the inner gray (or whatever color) rectangle + mpVirDev->SetLineColor(); + mpVirDev->SetFillColor( maMarkCol ); + mpVirDev->DrawRect( tools::Rectangle( + mnLine1 - mnFocusOffs, mnLine1 - mnFocusOffs, mnLine3 + mnFocusOffs, mnLine3 + mnFocusOffs ) ); + + // draw the white space for enabled frame borders + tools::PolyPolygon aPPoly; + for( FrameBorderCIter aIt( maEnabBorders ); aIt.Is(); ++aIt ) + (*aIt)->MergeFocusToPolyPolygon( aPPoly ); + aPPoly.Optimize( PolyOptimizeFlags::CLOSE ); + mpVirDev->SetLineColor( maBackCol ); + mpVirDev->SetFillColor( maBackCol ); + mpVirDev->DrawPolyPolygon( aPPoly ); +} + +void FrameSelectorImpl::DrawArrows( const FrameBorder& rBorder ) +{ + DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::DrawArrows - access to disabled border" ); + + long nLinePos = 0; + switch( rBorder.GetType() ) + { + case FrameBorderType::Left: + case FrameBorderType::Top: nLinePos = mnLine1; break; + case FrameBorderType::Vertical: + case FrameBorderType::Horizontal: nLinePos = mnLine2; break; + case FrameBorderType::Right: + case FrameBorderType::Bottom: nLinePos = mnLine3; break; + default: ; //prevent warning + } + nLinePos -= mnArrowSize / 2; + + long nTLPos = 0; + long nBRPos = mnCtrlSize - mnArrowSize; + Point aPos1, aPos2; + int nImgIndex1 = -1, nImgIndex2 = -1; + switch( rBorder.GetType() ) + { + case FrameBorderType::Left: + case FrameBorderType::Right: + case FrameBorderType::Vertical: + aPos1 = Point( nLinePos, nTLPos ); nImgIndex1 = 0; + aPos2 = Point( nLinePos, nBRPos ); nImgIndex2 = 1; + break; + + case FrameBorderType::Top: + case FrameBorderType::Bottom: + case FrameBorderType::Horizontal: + aPos1 = Point( nTLPos, nLinePos ); nImgIndex1 = 2; + aPos2 = Point( nBRPos, nLinePos ); nImgIndex2 = 3; + break; + + case FrameBorderType::TLBR: + aPos1 = Point( nTLPos, nTLPos ); nImgIndex1 = 4; + aPos2 = Point( nBRPos, nBRPos ); nImgIndex2 = 5; + break; + case FrameBorderType::BLTR: + aPos1 = Point( nTLPos, nBRPos ); nImgIndex1 = 6; + aPos2 = Point( nBRPos, nTLPos ); nImgIndex2 = 7; + break; + default: ; //prevent warning + } + + // Arrow or marker? Do not draw arrows into disabled control. + sal_uInt16 nSelectAdd = (mrFrameSel.IsEnabled() && rBorder.IsSelected()) ? 0 : 8; + if (nImgIndex1 >= 0) + mpVirDev->DrawImage(aPos1, maArrows[nImgIndex1 + nSelectAdd]); + if (nImgIndex2 >= 0) + mpVirDev->DrawImage(aPos2, maArrows[nImgIndex2 + nSelectAdd]); +} + +Color FrameSelectorImpl::GetDrawLineColor( const Color& rColor ) const +{ + Color aColor( mbHCMode ? maHCLineCol : rColor ); + if( aColor == maBackCol ) + aColor.Invert(); + return aColor; +} + +void FrameSelectorImpl::DrawAllFrameBorders() +{ + // Translate core colors to current UI colors (regards current background and HC mode). + for( FrameBorderIter aIt( maEnabBorders ); aIt.Is(); ++aIt ) + { + Color aCoreColorPrim = ((*aIt)->GetState() == FrameBorderState::DontCare) ? maMarkCol : (*aIt)->GetCoreStyle().GetColorOut(); + Color aCoreColorSecn = ((*aIt)->GetState() == FrameBorderState::DontCare) ? maMarkCol : (*aIt)->GetCoreStyle().GetColorIn(); + (*aIt)->SetUIColorPrim( GetDrawLineColor( aCoreColorPrim ) ); + (*aIt)->SetUIColorSecn( GetDrawLineColor( aCoreColorSecn ) ); + } + + // Copy all frame border styles to the helper array + maArray.SetColumnStyleLeft( 0, maLeft.GetUIStyle() ); + if( mbVer ) maArray.SetColumnStyleLeft( 1, maVer.GetUIStyle() ); + + // Invert the style for the right line + const frame::Style rRightStyle = maRight.GetUIStyle( ); + frame::Style rInvertedRight( rRightStyle.GetColorPrim(), + rRightStyle.GetColorSecn(), rRightStyle.GetColorGap(), + rRightStyle.UseGapColor(), + rRightStyle.Secn(), rRightStyle.Dist(), rRightStyle.Prim( ), + rRightStyle.Type( ), rRightStyle.PatternScale() ); + maArray.SetColumnStyleRight( mbVer ? 1 : 0, rInvertedRight ); + + maArray.SetRowStyleTop( 0, maTop.GetUIStyle() ); + if( mbHor ) + { + // Invert the style for the hor line to match the real borders + const frame::Style rHorStyle = maHor.GetUIStyle(); + frame::Style rInvertedHor( rHorStyle.GetColorPrim(), + rHorStyle.GetColorSecn(), rHorStyle.GetColorGap(), + rHorStyle.UseGapColor(), + rHorStyle.Secn(), rHorStyle.Dist(), rHorStyle.Prim( ), + rHorStyle.Type(), rHorStyle.PatternScale() ); + maArray.SetRowStyleTop( 1, rInvertedHor ); + } + + // Invert the style for the bottom line + const frame::Style rBottomStyle = maBottom.GetUIStyle( ); + frame::Style rInvertedBottom( rBottomStyle.GetColorPrim(), + rBottomStyle.GetColorSecn(), rBottomStyle.GetColorGap(), + rBottomStyle.UseGapColor(), + rBottomStyle.Secn(), rBottomStyle.Dist(), rBottomStyle.Prim( ), + rBottomStyle.Type(), rBottomStyle.PatternScale() ); + maArray.SetRowStyleBottom( mbHor ? 1 : 0, rInvertedBottom ); + + for( size_t nCol = 0; nCol < maArray.GetColCount(); ++nCol ) + for( size_t nRow = 0; nRow < maArray.GetRowCount(); ++nRow ) + maArray.SetCellStyleDiag( nCol, nRow, maTLBR.GetUIStyle(), maBLTR.GetUIStyle() ); + + // This is used in the dialog/control for 'Border' attributes. When using + // the original paint below instead of primitives, the advantage currently + // is the correct visualization of diagonal line(s) including overlaying, + // but the rest is bad. Since the edit views use primitives and the preview + // should be 'real' I opt for also changing this to primitives. I will + // keep the old solution and add a switch (above) based on a static bool so + // that interested people may test this out in the debugger. + // This is one more hint to enhance the primitive visualization further to + // support diagonals better - that's the way to go. + const drawinglayer::geometry::ViewInformation2D aNewViewInformation2D; + std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D( + drawinglayer::processor2d::createPixelProcessor2DFromOutputDevice( + *mpVirDev, + aNewViewInformation2D)); + + if (pProcessor2D) + { + pProcessor2D->process(maArray.CreateB2DPrimitiveArray()); + pProcessor2D.reset(); + } +} + +void FrameSelectorImpl::DrawVirtualDevice() +{ + DrawBackground(); + for(FrameBorderCIter aIt(maEnabBorders); aIt.Is(); ++aIt) + DrawArrows(**aIt); + DrawAllFrameBorders(); + mbFullRepaint = false; +} + +void FrameSelectorImpl::CopyVirDevToControl(vcl::RenderContext& rRenderContext) +{ + if (mbFullRepaint) + DrawVirtualDevice(); + rRenderContext.DrawBitmapEx(maVirDevPos, mpVirDev->GetBitmapEx(Point(0, 0), mpVirDev->GetOutputSizePixel())); +} + +void FrameSelectorImpl::DrawAllTrackingRects(vcl::RenderContext& rRenderContext) +{ + tools::PolyPolygon aPPoly; + if (mrFrameSel.IsAnyBorderSelected()) + { + for(SelFrameBorderCIter aIt( maEnabBorders ); aIt.Is(); ++aIt) + (*aIt)->MergeFocusToPolyPolygon(aPPoly); + aPPoly.Move(maVirDevPos.X(), maVirDevPos.Y()); + } + else + // no frame border selected -> draw tracking rectangle around entire control + aPPoly.Insert( tools::Polygon(tools::Rectangle(maVirDevPos, mpVirDev->GetOutputSizePixel()))); + + aPPoly.Optimize(PolyOptimizeFlags::CLOSE); + + for(sal_uInt16 nIdx = 0, nCount = aPPoly.Count(); nIdx < nCount; ++nIdx) + rRenderContext.Invert(aPPoly.GetObject(nIdx), InvertFlags::TrackFrame); +} + +Point FrameSelectorImpl::GetDevPosFromMousePos( const Point& rMousePos ) const +{ + return rMousePos - maVirDevPos; +} + +void FrameSelectorImpl::DoInvalidate( bool bFullRepaint ) +{ + mbFullRepaint |= bFullRepaint; + mrFrameSel.Invalidate(); +} + +// frame border state and style +void FrameSelectorImpl::SetBorderState( FrameBorder& rBorder, FrameBorderState eState ) +{ + DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::SetBorderState - access to disabled border" ); + Any aOld; + Any aNew; + Any& rMod = eState == FrameBorderState::Show ? aNew : aOld; + rMod <<= AccessibleStateType::CHECKED; + rtl::Reference< a11y::AccFrameSelectorChild > xRet; + size_t nVecIdx = static_cast< size_t >( rBorder.GetType() ); + if( GetBorder(rBorder.GetType()).IsEnabled() && (1 <= nVecIdx) && (nVecIdx <= maChildVec.size()) ) + xRet = maChildVec[ --nVecIdx ].get(); + + if( eState == FrameBorderState::Show ) + SetBorderCoreStyle( rBorder, &maCurrStyle ); + else + rBorder.SetState( eState ); + if (xRet.is()) + xRet->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOld, aNew ); + DoInvalidate( true ); +} + +void FrameSelectorImpl::SetBorderCoreStyle( FrameBorder& rBorder, const SvxBorderLine* pStyle ) +{ + DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::SetBorderCoreStyle - access to disabled border" ); + rBorder.SetCoreStyle( pStyle ); + DoInvalidate( true ); +} + +void FrameSelectorImpl::ToggleBorderState( FrameBorder& rBorder ) +{ + bool bDontCare = mrFrameSel.SupportsDontCareState(); + switch( rBorder.GetState() ) + { + // same order as tristate check box: visible -> don't care -> hidden + case FrameBorderState::Show: + SetBorderState( rBorder, bDontCare ? FrameBorderState::DontCare : FrameBorderState::Hide ); + break; + case FrameBorderState::Hide: + SetBorderState( rBorder, FrameBorderState::Show ); + break; + case FrameBorderState::DontCare: + SetBorderState( rBorder, FrameBorderState::Hide ); + break; + } +} + +// frame border selection +void FrameSelectorImpl::SelectBorder( FrameBorder& rBorder, bool bSelect ) +{ + DBG_ASSERT( rBorder.IsEnabled(), "svx::FrameSelectorImpl::SelectBorder - access to disabled border" ); + rBorder.Select( bSelect ); + DrawArrows( rBorder ); + DoInvalidate( false ); +} + +void FrameSelectorImpl::SilentGrabFocus() +{ + bool bOldAuto = mbAutoSelect; + mbAutoSelect = false; + mrFrameSel.GrabFocus(); + mbAutoSelect = bOldAuto; +} + +bool FrameSelectorImpl::SelectedBordersEqual() const +{ + bool bEqual = true; + SelFrameBorderCIter aIt( maEnabBorders ); + if( aIt.Is() ) + { + const SvxBorderLine& rFirstStyle = (*aIt)->GetCoreStyle(); + for( ++aIt; bEqual && aIt.Is(); ++aIt ) + bEqual = ((*aIt)->GetCoreStyle() == rFirstStyle); + } + return bEqual; +} + +FrameSelector::FrameSelector() +{ +} + +void FrameSelector::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aPrefSize = pDrawingArea->get_ref_device().LogicToPixel(Size(61, 65), MapMode(MapUnit::MapAppFont)); + pDrawingArea->set_size_request(aPrefSize.Width(), aPrefSize.Height()); + mxImpl.reset( new FrameSelectorImpl( *this ) ); + EnableRTL( false ); // #107808# don't mirror the mouse handling +} + +FrameSelector::~FrameSelector() +{ + if( mxAccess.is() ) + mxAccess->Invalidate(); +} + +void FrameSelector::Initialize( FrameSelFlags nFlags ) +{ + mxImpl->Initialize( nFlags ); + Show(); +} + +// enabled frame borders +bool FrameSelector::IsBorderEnabled( FrameBorderType eBorder ) const +{ + return mxImpl->GetBorder( eBorder ).IsEnabled(); +} + +sal_Int32 FrameSelector::GetEnabledBorderCount() const +{ + return static_cast< sal_Int32 >( mxImpl->maEnabBorders.size() ); +} + +FrameBorderType FrameSelector::GetEnabledBorderType( sal_Int32 nIndex ) const +{ + FrameBorderType eBorder = FrameBorderType::NONE; + if( nIndex >= 0 ) + { + size_t nVecIdx = static_cast< size_t >( nIndex ); + if( nVecIdx < mxImpl->maEnabBorders.size() ) + eBorder = mxImpl->maEnabBorders[ nVecIdx ]->GetType(); + } + return eBorder; +} + +// frame border state and style +bool FrameSelector::SupportsDontCareState() const +{ + return bool(mxImpl->mnFlags & FrameSelFlags::DontCare); +} + +FrameBorderState FrameSelector::GetFrameBorderState( FrameBorderType eBorder ) const +{ + return mxImpl->GetBorder( eBorder ).GetState(); +} + +const SvxBorderLine* FrameSelector::GetFrameBorderStyle( FrameBorderType eBorder ) const +{ + const SvxBorderLine& rStyle = mxImpl->GetBorder( eBorder ).GetCoreStyle(); + // rest of the world uses null pointer for invisible frame border + return rStyle.GetOutWidth() ? &rStyle : nullptr; +} + +void FrameSelector::ShowBorder( FrameBorderType eBorder, const SvxBorderLine* pStyle ) +{ + mxImpl->SetBorderCoreStyle( mxImpl->GetBorderAccess( eBorder ), pStyle ); +} + +void FrameSelector::SetBorderDontCare( FrameBorderType eBorder ) +{ + mxImpl->SetBorderState( mxImpl->GetBorderAccess( eBorder ), FrameBorderState::DontCare ); +} + +bool FrameSelector::IsAnyBorderVisible() const +{ + bool bIsSet = false; + for( FrameBorderCIter aIt( mxImpl->maEnabBorders ); !bIsSet && aIt.Is(); ++aIt ) + bIsSet = ((*aIt)->GetState() == FrameBorderState::Show); + return bIsSet; +} + +void FrameSelector::HideAllBorders() +{ + for( FrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->SetBorderState( **aIt, FrameBorderState::Hide ); +} + +bool FrameSelector::GetVisibleWidth( long& rnWidth, SvxBorderLineStyle& rnStyle ) const +{ + VisFrameBorderCIter aIt( mxImpl->maEnabBorders ); + if( !aIt.Is() ) + return false; + + const SvxBorderLine& rStyle = (*aIt)->GetCoreStyle(); + bool bFound = true; + for( ++aIt; bFound && aIt.Is(); ++aIt ) + { + bFound = + (rStyle.GetWidth() == (*aIt)->GetCoreStyle().GetWidth()) && + (rStyle.GetBorderLineStyle() == + (*aIt)->GetCoreStyle().GetBorderLineStyle()); + } + + if( bFound ) + { + rnWidth = rStyle.GetWidth(); + rnStyle = rStyle.GetBorderLineStyle(); + } + return bFound; +} + +bool FrameSelector::GetVisibleColor( Color& rColor ) const +{ + VisFrameBorderCIter aIt( mxImpl->maEnabBorders ); + if( !aIt.Is() ) + return false; + + const SvxBorderLine& rStyle = (*aIt)->GetCoreStyle(); + bool bFound = true; + for( ++aIt; bFound && aIt.Is(); ++aIt ) + bFound = (rStyle.GetColor() == (*aIt)->GetCoreStyle().GetColor()); + + if( bFound ) + rColor = rStyle.GetColor(); + return bFound; +} + +// frame border selection +const Link<LinkParamNone*,void>& FrameSelector::GetSelectHdl() const +{ + return mxImpl->maSelectHdl; +} + +void FrameSelector::SetSelectHdl( const Link<LinkParamNone*,void>& rHdl ) +{ + mxImpl->maSelectHdl = rHdl; +} + +bool FrameSelector::IsBorderSelected( FrameBorderType eBorder ) const +{ + return mxImpl->GetBorder( eBorder ).IsSelected(); +} + +void FrameSelector::SelectBorder( FrameBorderType eBorder ) +{ + mxImpl->SelectBorder( mxImpl->GetBorderAccess( eBorder ), true/*bSelect*/ ); + // MT: bFireFox as API parameter is ugly... + // if (bFocus) + { + rtl::Reference< a11y::AccFrameSelectorChild > xRet = GetChildAccessible(eBorder); + if (xRet.is()) + { + Any aOldValue, aNewValue; + aNewValue <<= AccessibleStateType::FOCUSED; + xRet->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aOldValue, aNewValue ); + } + } +} + +bool FrameSelector::IsAnyBorderSelected() const +{ + // Construct an iterator for selected borders. If it is valid, there is a selected border. + return SelFrameBorderCIter( mxImpl->maEnabBorders ).Is(); +} + +void FrameSelector::SelectAllBorders( bool bSelect ) +{ + for( FrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->SelectBorder( **aIt, bSelect ); +} + +void FrameSelector::SelectAllVisibleBorders() +{ + for( VisFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->SelectBorder( **aIt, true/*bSelect*/ ); +} + +void FrameSelector::SetStyleToSelection( long nWidth, SvxBorderLineStyle nStyle ) +{ + mxImpl->maCurrStyle.SetBorderLineStyle( nStyle ); + mxImpl->maCurrStyle.SetWidth( nWidth ); + for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->SetBorderState( **aIt, FrameBorderState::Show ); +} + +void FrameSelector::SetColorToSelection( const Color& rColor ) +{ + mxImpl->maCurrStyle.SetColor( rColor ); + for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->SetBorderState( **aIt, FrameBorderState::Show ); +} + +// accessibility +Reference< XAccessible > FrameSelector::CreateAccessible() +{ + if( !mxAccess.is() ) + mxAccess = new a11y::AccFrameSelector(*this); + return mxAccess.get(); +} + +rtl::Reference< a11y::AccFrameSelectorChild > FrameSelector::GetChildAccessible( FrameBorderType eBorder ) +{ + rtl::Reference< a11y::AccFrameSelectorChild > xRet; + size_t nVecIdx = static_cast< size_t >( eBorder ); + if( IsBorderEnabled( eBorder ) && (1 <= nVecIdx) && (nVecIdx <= mxImpl->maChildVec.size()) ) + { + --nVecIdx; + if( !mxImpl->maChildVec[ nVecIdx ].is() ) + mxImpl->maChildVec[ nVecIdx ] = new a11y::AccFrameSelectorChild( *this, eBorder ); + xRet = mxImpl->maChildVec[ nVecIdx ].get(); + } + return xRet; +} + +Reference< XAccessible > FrameSelector::GetChildAccessible( sal_Int32 nIndex ) +{ + return GetChildAccessible( GetEnabledBorderType( nIndex ) ).get(); +} + +Reference< XAccessible > FrameSelector::GetChildAccessible( const Point& rPos ) +{ + Reference< XAccessible > xRet; + for( FrameBorderCIter aIt( mxImpl->maEnabBorders ); !xRet.is() && aIt.Is(); ++aIt ) + if( (*aIt)->ContainsClickPoint( rPos ) ) + xRet = GetChildAccessible( (*aIt)->GetType() ).get(); + return xRet; +} + +tools::Rectangle FrameSelector::GetClickBoundRect( FrameBorderType eBorder ) const +{ + tools::Rectangle aRect; + const FrameBorder& rBorder = mxImpl->GetBorder( eBorder ); + if( rBorder.IsEnabled() ) + aRect = rBorder.GetClickBoundRect(); + return aRect; +} + +// virtual functions from base class +void FrameSelector::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + mxImpl->CopyVirDevToControl(rRenderContext); + if (HasFocus()) + mxImpl->DrawAllTrackingRects(rRenderContext); +} + +bool FrameSelector::MouseButtonDown( const MouseEvent& rMEvt ) +{ + /* Mouse handling: + * Click on an unselected frame border: + Set current style/color, make frame border visible, deselect all + other frame borders. + * Click on a selected frame border: + Toggle state of the frame border (visible -> don't care -> hidden), + deselect all other frame borders. + * SHIFT+Click or CTRL+Click on an unselected frame border: + Extend selection, set current style/color to all selected frame + borders independent of the state/style/color of the borders. + * SHIFT+Click or CTRL+Click on a selected frame border: + If all frame borders have same style/color, toggle state of all + borders (see above), otherwise set current style/color to all + borders. + * Click on unused area: Do not modify selection and selected frame + borders. + */ + + // #107394# do not auto-select a frame border + mxImpl->SilentGrabFocus(); + + if( rMEvt.IsLeft() ) + { + Point aPos( mxImpl->GetDevPosFromMousePos( rMEvt.GetPosPixel() ) ); + FrameBorderPtrVec aDeselectBorders; + + bool bAnyClicked = false; // Any frame border clicked? + bool bNewSelected = false; // Any unselected frame border selected? + + /* If frame borders are set to "don't care" and the control does not + support this state, hide them on first mouse click. + DR 2004-01-30: Why are the borders set to "don't care" then?!? */ + bool bHideDontCare = !SupportsDontCareState(); + + for( FrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + { + if( (*aIt)->ContainsClickPoint( aPos ) ) + { + // frame border is clicked + bAnyClicked = true; + if( !(*aIt)->IsSelected() ) + { + bNewSelected = true; + //mxImpl->SelectBorder( **aIt, true ); + SelectBorder((**aIt).GetType()); + } + } + else + { + // hide a "don't care" frame border only if it is not clicked + if( bHideDontCare && ((*aIt)->GetState() == FrameBorderState::DontCare) ) + mxImpl->SetBorderState( **aIt, FrameBorderState::Hide ); + + // deselect frame borders not clicked (if SHIFT or CTRL are not pressed) + if( !rMEvt.IsShift() && !rMEvt.IsMod1() ) + aDeselectBorders.push_back( *aIt ); + } + } + + if( bAnyClicked ) + { + // any valid frame border clicked? -> deselect other frame borders + for( FrameBorderIter aIt( aDeselectBorders ); aIt.Is(); ++aIt ) + mxImpl->SelectBorder( **aIt, false ); + + if( bNewSelected || !mxImpl->SelectedBordersEqual() ) + { + // new frame border selected, selection extended, or selected borders different? -> show + for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + // SetBorderState() sets current style and color to the frame border + mxImpl->SetBorderState( **aIt, FrameBorderState::Show ); + } + else + { + // all selected frame borders are equal -> toggle state + for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->ToggleBorderState( **aIt ); + } + + GetSelectHdl().Call( nullptr ); + } + } + + return true; +} + +bool FrameSelector::KeyInput( const KeyEvent& rKEvt ) +{ + bool bHandled = false; + vcl::KeyCode aKeyCode = rKEvt.GetKeyCode(); + if( !aKeyCode.GetModifier() ) + { + sal_uInt16 nCode = aKeyCode.GetCode(); + switch( nCode ) + { + case KEY_SPACE: + { + for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->ToggleBorderState( **aIt ); + bHandled = true; + } + break; + + case KEY_UP: + case KEY_DOWN: + case KEY_LEFT: + case KEY_RIGHT: + { + if( !mxImpl->maEnabBorders.empty() ) + { + // start from first selected frame border + SelFrameBorderCIter aIt( mxImpl->maEnabBorders ); + FrameBorderType eBorder = aIt.Is() ? (*aIt)->GetType() : mxImpl->maEnabBorders.front()->GetType(); + + // search for next enabled frame border + do + { + eBorder = mxImpl->GetBorder( eBorder ).GetKeyboardNeighbor( nCode ); + } + while( (eBorder != FrameBorderType::NONE) && !IsBorderEnabled( eBorder ) ); + + // select the frame border + if( eBorder != FrameBorderType::NONE ) + { + DeselectAllBorders(); + SelectBorder( eBorder ); + } + bHandled = true; + } + } + break; + } + } + if (bHandled) + return true; + return CustomWidgetController::KeyInput(rKEvt); +} + +void FrameSelector::GetFocus() +{ + // auto-selection of a frame border, if focus reaches control, and nothing is selected + if( mxImpl->mbAutoSelect && !IsAnyBorderSelected() && !mxImpl->maEnabBorders.empty() ) + mxImpl->SelectBorder( *mxImpl->maEnabBorders.front(), true ); + + mxImpl->DoInvalidate( false ); + if (IsAnyBorderSelected()) + { + FrameBorderType borderType = FrameBorderType::NONE; + if (mxImpl->maLeft.IsSelected()) + borderType = FrameBorderType::Left; + else if (mxImpl->maRight.IsSelected()) + borderType = FrameBorderType::Right; + else if (mxImpl->maTop.IsSelected()) + borderType = FrameBorderType::Top; + else if (mxImpl->maBottom.IsSelected()) + borderType = FrameBorderType::Bottom; + else if (mxImpl->maHor.IsSelected()) + borderType = FrameBorderType::Horizontal; + else if (mxImpl->maVer.IsSelected()) + borderType = FrameBorderType::Vertical; + else if (mxImpl->maTLBR.IsSelected()) + borderType = FrameBorderType::TLBR; + else if (mxImpl->maBLTR.IsSelected()) + borderType = FrameBorderType::BLTR; + SelectBorder(borderType); + } + for( SelFrameBorderIter aIt( mxImpl->maEnabBorders ); aIt.Is(); ++aIt ) + mxImpl->SetBorderState( **aIt, FrameBorderState::Show ); + CustomWidgetController::GetFocus(); +} + +void FrameSelector::LoseFocus() +{ + mxImpl->DoInvalidate( false ); + CustomWidgetController::LoseFocus(); +} + +void FrameSelector::StyleUpdated() +{ + mxImpl->InitVirtualDevice(); + CustomWidgetController::StyleUpdated(); +} + +void FrameSelector::Resize() +{ + CustomWidgetController::Resize(); + mxImpl->sizeChanged(); +} + +template< typename Cont, typename Iter, typename Pred > +FrameBorderIterBase< Cont, Iter, Pred >::FrameBorderIterBase( container_type& rCont ) : + maIt( rCont.begin() ), + maEnd( rCont.end() ) +{ + while( Is() && !maPred( *maIt ) ) ++maIt; +} + +template< typename Cont, typename Iter, typename Pred > +FrameBorderIterBase< Cont, Iter, Pred >& FrameBorderIterBase< Cont, Iter, Pred >::operator++() +{ + do { ++maIt; } while( Is() && !maPred( *maIt ) ); + return *this; +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/graphctl.cxx b/svx/source/dialog/graphctl.cxx new file mode 100644 index 000000000..d3e0671e5 --- /dev/null +++ b/svx/source/dialog/graphctl.cxx @@ -0,0 +1,841 @@ +/* -*- 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 <svl/itempool.hxx> +#include <vcl/settings.hxx> +#include <vcl/ptrstyle.hxx> +#include <vcl/svapp.hxx> + +#include <svx/graphctl.hxx> +#include <svx/sdr/overlay/overlaymanager.hxx> +#include <GraphCtlAccessibleContext.hxx> +#include <svx/svxids.hrc> +#include <svx/svdpage.hxx> +#include <svx/sdrpaintwindow.hxx> + +void GraphCtrlUserCall::Changed( const SdrObject& rObj, SdrUserCallType eType, const tools::Rectangle& /*rOldBoundRect*/ ) +{ + switch( eType ) + { + case SdrUserCallType::MoveOnly: + case SdrUserCallType::Resize: + rWin.SdrObjChanged( rObj ); + break; + + case SdrUserCallType::Inserted: + rWin.SdrObjCreated( rObj ); + break; + + default: + break; + } + rWin.QueueIdleUpdate(); +} + +GraphCtrl::GraphCtrl(weld::Dialog* pDialog) + : aUpdateIdle("svx GraphCtrl Update") + , aMap100(MapUnit::Map100thMM) + , eObjKind(OBJ_NONE) + , nPolyEdit(0) + , bEditMode(false) + , mbSdrMode(false) + , mbInIdleUpdate(false) + , mpDialog(pDialog) +{ + pUserCall.reset(new GraphCtrlUserCall( *this )); + aUpdateIdle.SetPriority( TaskPriority::LOWEST ); + aUpdateIdle.SetInvokeHandler( LINK( this, GraphCtrl, UpdateHdl ) ); + aUpdateIdle.Start(); +} + +void GraphCtrl::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + weld::CustomWidgetController::SetDrawingArea(pDrawingArea); + EnableRTL(false); +} + +GraphCtrl::~GraphCtrl() +{ + aUpdateIdle.Stop(); + + if( mpAccContext.is() ) + { + mpAccContext->disposing(); + mpAccContext.clear(); + } + pView.reset(); + pModel.reset(); + pUserCall.reset(); +} + +void GraphCtrl::SetSdrMode(bool bSdrMode) +{ + mbSdrMode = bSdrMode; + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + rDevice.SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) ); + xVD->SetBackground( Wallpaper( rStyleSettings.GetWindowColor() ) ); + rDevice.SetMapMode( aMap100 ); + xVD->SetMapMode( aMap100 ); + + pView.reset(); + pModel.reset(); + + if ( mbSdrMode ) + InitSdrModel(); + + QueueIdleUpdate(); +} + +void GraphCtrl::InitSdrModel() +{ + SolarMutexGuard aGuard; + + SdrPage* pPage; + + // destroy old junk + pView.reset(); + pModel.reset(); + + // Creating a Model + pModel.reset(new SdrModel(nullptr, nullptr, true)); + pModel->GetItemPool().FreezeIdRanges(); + pModel->SetScaleUnit( aMap100.GetMapUnit() ); + pModel->SetScaleFraction( Fraction( 1, 1 ) ); + pModel->SetDefaultFontHeight( 500 ); + + pPage = new SdrPage( *pModel ); + + pPage->SetSize( aGraphSize ); + pPage->SetBorder( 0, 0, 0, 0 ); + pModel->InsertPage( pPage ); + pModel->SetChanged( false ); + + // Creating a View + pView.reset(new GraphCtrlView(*pModel, this)); + pView->SetWorkArea( tools::Rectangle( Point(), aGraphSize ) ); + pView->EnableExtendedMouseEventDispatcher( true ); + pView->ShowSdrPage(pView->GetModel()->GetPage(0)); + pView->SetFrameDragSingles(); + pView->SetMarkedPointsSmooth( SdrPathSmoothKind::Symmetric ); + pView->SetEditMode(); + + // #i72889# set needed flags + pView->SetPagePaintingAllowed(false); + pView->SetBufferedOutputAllowed(true); + pView->SetBufferedOverlayAllowed(true); + + // Tell the accessibility object about the changes. + if (mpAccContext.is()) + mpAccContext->setModelAndView (pModel.get(), pView.get()); +} + +void GraphCtrl::SetGraphic( const Graphic& rGraphic, bool bNewModel ) +{ + aGraphic = rGraphic; + xVD->SetOutputSizePixel(Size(0, 0)); //force redraw + + if ( aGraphic.GetPrefMapMode().GetMapUnit() == MapUnit::MapPixel ) + aGraphSize = Application::GetDefaultDevice()->PixelToLogic( aGraphic.GetPrefSize(), aMap100 ); + else + aGraphSize = OutputDevice::LogicToLogic( aGraphic.GetPrefSize(), aGraphic.GetPrefMapMode(), aMap100 ); + + if ( mbSdrMode && bNewModel ) + InitSdrModel(); + + aGraphSizeLink.Call( this ); + + Resize(); + + Invalidate(); + QueueIdleUpdate(); +} + +void GraphCtrl::GraphicToVD() +{ + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + xVD->SetOutputSizePixel(GetOutputSizePixel()); + xVD->SetBackground(rDevice.GetBackground()); + xVD->Erase(); + const bool bGraphicValid(GraphicType::NONE != aGraphic.GetType()); + if (bGraphicValid) + aGraphic.Draw(xVD.get(), Point(), aGraphSize); +} + +void GraphCtrl::Resize() +{ + weld::CustomWidgetController::Resize(); + + if (aGraphSize.Width() && aGraphSize.Height()) + { + MapMode aDisplayMap( aMap100 ); + Point aNewPos; + Size aNewSize; + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + const Size aWinSize = rDevice.PixelToLogic( GetOutputSizePixel(), aDisplayMap ); + const long nWidth = aWinSize.Width(); + const long nHeight = aWinSize.Height(); + double fGrfWH = static_cast<double>(aGraphSize.Width()) / aGraphSize.Height(); + double fWinWH = static_cast<double>(nWidth) / nHeight; + + // Adapt Bitmap to Thumb size + if ( fGrfWH < fWinWH) + { + aNewSize.setWidth( static_cast<long>( static_cast<double>(nHeight) * fGrfWH ) ); + aNewSize.setHeight( nHeight ); + } + else + { + aNewSize.setWidth( nWidth ); + aNewSize.setHeight( static_cast<long>( static_cast<double>(nWidth) / fGrfWH ) ); + } + + aNewPos.setX( ( nWidth - aNewSize.Width() ) >> 1 ); + aNewPos.setY( ( nHeight - aNewSize.Height() ) >> 1 ); + + // Implementing MapMode for Engine + aDisplayMap.SetScaleX( Fraction( aNewSize.Width(), aGraphSize.Width() ) ); + aDisplayMap.SetScaleY( Fraction( aNewSize.Height(), aGraphSize.Height() ) ); + + aDisplayMap.SetOrigin( OutputDevice::LogicToLogic( aNewPos, aMap100, aDisplayMap ) ); + rDevice.SetMapMode( aDisplayMap ); + xVD->SetMapMode( aDisplayMap ); + } + + Invalidate(); +} + +void GraphCtrl::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) +{ + // #i72889# used split repaint to be able to paint an own background + // even to the buffered view + const bool bGraphicValid(GraphicType::NONE != aGraphic.GetType()); + + if (GetOutputSizePixel() != xVD->GetOutputSizePixel()) + GraphicToVD(); + + if (mbSdrMode) + { + SdrPaintWindow* pPaintWindow = pView->BeginCompleteRedraw(&rRenderContext); + pPaintWindow->SetOutputToWindow(true); + + if (bGraphicValid) + { + vcl::RenderContext& rTarget = pPaintWindow->GetTargetOutputDevice(); + + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + rTarget.SetBackground(rDevice.GetBackground()); + rTarget.Erase(); + + rTarget.DrawOutDev(Point(), xVD->GetOutputSize(), Point(), xVD->GetOutputSize(), *xVD); + } + + const vcl::Region aRepaintRegion(rRect); + pView->DoCompleteRedraw(*pPaintWindow, aRepaintRegion); + pView->EndCompleteRedraw(*pPaintWindow, true); + } + else + { + // #i73381# in non-SdrMode, paint to local directly + rRenderContext.DrawOutDev(rRect.TopLeft(), rRect.GetSize(), + rRect.TopLeft(), rRect.GetSize(), + *xVD); + } +} + +void GraphCtrl::SdrObjChanged( const SdrObject& ) +{ + QueueIdleUpdate(); +} + +void GraphCtrl::SdrObjCreated( const SdrObject& ) +{ + QueueIdleUpdate(); +} + +void GraphCtrl::MarkListHasChanged() +{ + QueueIdleUpdate(); +} + +bool GraphCtrl::KeyInput( const KeyEvent& rKEvt ) +{ + vcl::KeyCode aCode( rKEvt.GetKeyCode() ); + bool bProc = false; + + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + + switch ( aCode.GetCode() ) + { + case KEY_DELETE: + case KEY_BACKSPACE: + { + if ( mbSdrMode ) + { + pView->DeleteMarked(); + bProc = true; + } + } + break; + + case KEY_ESCAPE: + { + if ( mbSdrMode ) + { + if ( pView->IsAction() ) + { + pView->BrkAction(); + bProc = true; + } + else if ( pView->AreObjectsMarked() ) + { + pView->UnmarkAllObj(); + bProc = true; + } + } + } + break; + + case KEY_F11: + case KEY_TAB: + { + if( mbSdrMode ) + { + if( !aCode.IsMod1() && !aCode.IsMod2() ) + { + bool bForward = !aCode.IsShift(); + // select next object + if ( ! pView->MarkNextObj( bForward )) + { + // At first or last object. Cycle to the other end + // of the list. + pView->UnmarkAllObj(); + pView->MarkNextObj (bForward); + } + bProc = true; + } + else if(aCode.IsMod1()) + { + // select next handle + const SdrHdlList& rHdlList = pView->GetHdlList(); + bool bForward(!aCode.IsShift()); + + const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl(bForward); + + bProc = true; + } + } + } + break; + + case KEY_END: + { + + if ( aCode.IsMod1() ) + { + // mark last object + pView->UnmarkAllObj(); + pView->MarkNextObj(); + + bProc = true; + } + } + break; + + case KEY_HOME: + { + if ( aCode.IsMod1() ) + { + pView->UnmarkAllObj(); + pView->MarkNextObj(true); + + bProc = true; + } + } + break; + + case KEY_UP: + case KEY_DOWN: + case KEY_LEFT: + case KEY_RIGHT: + { + long nX = 0; + long nY = 0; + + if (aCode.GetCode() == KEY_UP) + { + // Scroll up + nX = 0; + nY =-1; + } + else if (aCode.GetCode() == KEY_DOWN) + { + // Scroll down + nX = 0; + nY = 1; + } + else if (aCode.GetCode() == KEY_LEFT) + { + // Scroll left + nX =-1; + nY = 0; + } + else if (aCode.GetCode() == KEY_RIGHT) + { + // Scroll right + nX = 1; + nY = 0; + } + + if (pView->AreObjectsMarked() && !aCode.IsMod1() ) + { + if(aCode.IsMod2()) + { + // move in 1 pixel distance + Size aLogicSizeOnePixel = rDevice.PixelToLogic(Size(1,1)); + nX *= aLogicSizeOnePixel.Width(); + nY *= aLogicSizeOnePixel.Height(); + } + else + { + // old, fixed move distance + nX *= 100; + nY *= 100; + } + + // II + const SdrHdlList& rHdlList = pView->GetHdlList(); + SdrHdl* pHdl = rHdlList.GetFocusHdl(); + + if(nullptr == pHdl) + { + // restrict movement to WorkArea + const tools::Rectangle& rWorkArea = pView->GetWorkArea(); + + if(!rWorkArea.IsEmpty()) + { + tools::Rectangle aMarkRect(pView->GetMarkedObjRect()); + aMarkRect.Move(nX, nY); + + if(!aMarkRect.IsInside(rWorkArea)) + { + if(aMarkRect.Left() < rWorkArea.Left()) + { + nX += rWorkArea.Left() - aMarkRect.Left(); + } + + if(aMarkRect.Right() > rWorkArea.Right()) + { + nX -= aMarkRect.Right() - rWorkArea.Right(); + } + + if(aMarkRect.Top() < rWorkArea.Top()) + { + nY += rWorkArea.Top() - aMarkRect.Top(); + } + + if(aMarkRect.Bottom() > rWorkArea.Bottom()) + { + nY -= aMarkRect.Bottom() - rWorkArea.Bottom(); + } + } + } + + // no handle selected + if(0 != nX || 0 != nY) + { + pView->MoveAllMarked(Size(nX, nY)); + } + } + else + { + // move handle with index nHandleIndex + if (nX || nY) + { + // now move the Handle (nX, nY) + Point aStartPoint(pHdl->GetPos()); + Point aEndPoint(pHdl->GetPos() + Point(nX, nY)); + const SdrDragStat& rDragStat = pView->GetDragStat(); + + // start dragging + pView->BegDragObj(aStartPoint, nullptr, pHdl, 0); + + if(pView->IsDragObj()) + { + bool bWasNoSnap = rDragStat.IsNoSnap(); + bool bWasSnapEnabled = pView->IsSnapEnabled(); + + // switch snapping off + if(!bWasNoSnap) + const_cast<SdrDragStat&>(rDragStat).SetNoSnap(); + if(bWasSnapEnabled) + pView->SetSnapEnabled(false); + + pView->MovAction(aEndPoint); + pView->EndDragObj(); + + // restore snap + if(!bWasNoSnap) + const_cast<SdrDragStat&>(rDragStat).SetNoSnap(bWasNoSnap); + if(bWasSnapEnabled) + pView->SetSnapEnabled(bWasSnapEnabled); + } + } + } + + bProc = true; + } + } + break; + + case KEY_SPACE: + { + const SdrHdlList& rHdlList = pView->GetHdlList(); + SdrHdl* pHdl = rHdlList.GetFocusHdl(); + + if(pHdl) + { + if(pHdl->GetKind() == SdrHdlKind::Poly) + { + // rescue ID of point with focus + sal_uInt32 nPol(pHdl->GetPolyNum()); + sal_uInt32 nPnt(pHdl->GetPointNum()); + + if(pView->IsPointMarked(*pHdl)) + { + if(rKEvt.GetKeyCode().IsShift()) + { + pView->UnmarkPoint(*pHdl); + } + } + else + { + if(!rKEvt.GetKeyCode().IsShift()) + { + pView->UnmarkAllPoints(); + } + + pView->MarkPoint(*pHdl); + } + + if(nullptr == rHdlList.GetFocusHdl()) + { + // restore point with focus + SdrHdl* pNewOne = nullptr; + + for(size_t a = 0; !pNewOne && a < rHdlList.GetHdlCount(); ++a) + { + SdrHdl* pAct = rHdlList.GetHdl(a); + + if(pAct + && pAct->GetKind() == SdrHdlKind::Poly + && pAct->GetPolyNum() == nPol + && pAct->GetPointNum() == nPnt) + { + pNewOne = pAct; + } + } + + if(pNewOne) + { + const_cast<SdrHdlList&>(rHdlList).SetFocusHdl(pNewOne); + } + } + + bProc = true; + } + } + } + break; + + default: + break; + } + + if (bProc) + ReleaseMouse(); + + QueueIdleUpdate(); + + return bProc; +} + +bool GraphCtrl::MouseButtonDown( const MouseEvent& rMEvt ) +{ + if ( mbSdrMode && ( rMEvt.GetClicks() < 2 ) ) + { + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + + const Point aLogPt( rDevice.PixelToLogic( rMEvt.GetPosPixel() ) ); + + if ( !tools::Rectangle( Point(), aGraphSize ).IsInside( aLogPt ) && !pView->IsEditMode() ) + weld::CustomWidgetController::MouseButtonDown( rMEvt ); + else + { + // Get Focus for key inputs + GrabFocus(); + + if ( nPolyEdit ) + { + SdrViewEvent aVEvt; + SdrHitKind eHit = pView->PickAnything( rMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt ); + + if ( nPolyEdit == SID_BEZIER_INSERT && eHit == SdrHitKind::MarkedObject ) + pView->BegInsObjPoint( aLogPt, rMEvt.IsMod1()); + else + pView->MouseButtonDown( rMEvt, &rDevice ); + } + else + pView->MouseButtonDown( rMEvt, &rDevice ); + } + + SdrObject* pCreateObj = pView->GetCreateObj(); + + // We want to realize the insert + if ( pCreateObj && !pCreateObj->GetUserCall() ) + pCreateObj->SetUserCall( pUserCall.get() ); + + SetPointer( pView->GetPreferredPointer( aLogPt, &rDevice ) ); + } + else + weld::CustomWidgetController::MouseButtonDown( rMEvt ); + + QueueIdleUpdate(); + + return false; +} + +bool GraphCtrl::MouseMove(const MouseEvent& rMEvt) +{ + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + const Point aLogPos( rDevice.PixelToLogic( rMEvt.GetPosPixel() ) ); + + if ( mbSdrMode ) + { + pView->MouseMove( rMEvt, &rDevice ); + + if( ( SID_BEZIER_INSERT == nPolyEdit ) && + !pView->PickHandle( aLogPos ) && + !pView->IsInsObjPoint() ) + { + SetPointer( PointerStyle::Cross ); + } + else + SetPointer( pView->GetPreferredPointer( aLogPos, &rDevice ) ); + } + else + weld::CustomWidgetController::MouseButtonUp( rMEvt ); + + if ( aMousePosLink.IsSet() ) + { + if ( tools::Rectangle( Point(), aGraphSize ).IsInside( aLogPos ) ) + aMousePos = aLogPos; + else + aMousePos = Point(); + + aMousePosLink.Call( this ); + } + + QueueIdleUpdate(); + + return false; +} + +bool GraphCtrl::MouseButtonUp(const MouseEvent& rMEvt) +{ + if ( mbSdrMode ) + { + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + + if ( pView->IsInsObjPoint() ) + pView->EndInsObjPoint( SdrCreateCmd::ForceEnd ); + else + pView->MouseButtonUp( rMEvt, &rDevice ); + + ReleaseMouse(); + SetPointer( pView->GetPreferredPointer( rDevice.PixelToLogic( rMEvt.GetPosPixel() ), &rDevice ) ); + } + else + weld::CustomWidgetController::MouseButtonUp( rMEvt ); + + QueueIdleUpdate(); + + return false; +} + +SdrObject* GraphCtrl::GetSelectedSdrObject() const +{ + SdrObject* pSdrObj = nullptr; + + if ( mbSdrMode ) + { + const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); + + if ( rMarkList.GetMarkCount() == 1 ) + pSdrObj = rMarkList.GetMark( 0 )->GetMarkedSdrObj(); + } + + return pSdrObj; +} + +void GraphCtrl::SetEditMode( const bool _bEditMode ) +{ + if ( mbSdrMode ) + { + bEditMode = _bEditMode; + pView->SetEditMode( bEditMode ); + eObjKind = OBJ_NONE; + pView->SetCurrentObj( sal::static_int_cast< sal_uInt16 >( eObjKind ) ); + } + else + bEditMode = false; + + QueueIdleUpdate(); +} + +void GraphCtrl::SetPolyEditMode( const sal_uInt16 _nPolyEdit ) +{ + if ( mbSdrMode && ( _nPolyEdit != nPolyEdit ) ) + { + nPolyEdit = _nPolyEdit; + pView->SetFrameDragSingles( nPolyEdit == 0 ); + } + else + nPolyEdit = 0; + + QueueIdleUpdate(); +} + +void GraphCtrl::SetObjKind( const SdrObjKind _eObjKind ) +{ + if ( mbSdrMode ) + { + bEditMode = false; + pView->SetEditMode( bEditMode ); + eObjKind = _eObjKind; + pView->SetCurrentObj( sal::static_int_cast< sal_uInt16 >( eObjKind ) ); + } + else + eObjKind = OBJ_NONE; + + QueueIdleUpdate(); +} + +IMPL_LINK_NOARG(GraphCtrl, UpdateHdl, Timer *, void) +{ + mbInIdleUpdate = true; + aUpdateLink.Call( this ); + mbInIdleUpdate = false; +} + +void GraphCtrl::QueueIdleUpdate() +{ + if (!mbInIdleUpdate) + aUpdateIdle.Start(); +} + +namespace +{ + class WeldOverlayManager final : public sdr::overlay::OverlayManager + { + weld::CustomWidgetController& m_rGraphCtrl; + + public: + WeldOverlayManager(weld::CustomWidgetController& rGraphCtrl, OutputDevice& rDevice) + : OverlayManager(rDevice) + , m_rGraphCtrl(rGraphCtrl) + { + } + + // invalidate the given range at local OutputDevice + virtual void invalidateRange(const basegfx::B2DRange& rRange) override + { + tools::Rectangle aInvalidateRectangle(RangeToInvalidateRectangle(rRange)); + m_rGraphCtrl.Invalidate(aInvalidateRectangle); + } + }; +} + +rtl::Reference<sdr::overlay::OverlayManager> GraphCtrlView::CreateOverlayManager(OutputDevice& rDevice) const +{ + assert(&rDevice == &rGraphCtrl.GetDrawingArea()->get_ref_device()); + if (rDevice.GetOutDevType() == OUTDEV_VIRDEV) + { + rtl::Reference<sdr::overlay::OverlayManager> xOverlayManager(new WeldOverlayManager(rGraphCtrl, rDevice)); + InitOverlayManager(xOverlayManager); + return xOverlayManager; + } + return SdrView::CreateOverlayManager(rDevice); +} + +void GraphCtrlView::InvalidateOneWin(OutputDevice& rDevice) +{ + assert(&rDevice == &rGraphCtrl.GetDrawingArea()->get_ref_device()); + if (rDevice.GetOutDevType() == OUTDEV_VIRDEV) + { + rGraphCtrl.Invalidate(); + return; + } + SdrView::InvalidateOneWin(rDevice); +} + +void GraphCtrlView::InvalidateOneWin(OutputDevice& rDevice, const tools::Rectangle& rArea) +{ + assert(&rDevice == &rGraphCtrl.GetDrawingArea()->get_ref_device()); + if (rDevice.GetOutDevType() == OUTDEV_VIRDEV) + { + rGraphCtrl.Invalidate(rArea); + return; + } + SdrView::InvalidateOneWin(rDevice, rArea); +} + +GraphCtrlView::~GraphCtrlView() +{ + // turn SetOutputToWindow back off again before + // turning back into our baseclass during dtoring + const sal_uInt32 nWindowCount(PaintWindowCount()); + for (sal_uInt32 nWinNum(0); nWinNum < nWindowCount; nWinNum++) + { + SdrPaintWindow* pPaintWindow = GetPaintWindow(nWinNum); + pPaintWindow->SetOutputToWindow(false); + } +} + +Point GraphCtrl::GetPositionInDialog() const +{ + int x, y, width, height; + if (GetDrawingArea()->get_extents_relative_to(*mpDialog, x, y, width, height)) + return Point(x, y); + return Point(); +} + +css::uno::Reference< css::accessibility::XAccessible > GraphCtrl::CreateAccessible() +{ + if(mpAccContext == nullptr ) + { + // Disable accessibility if no model/view data available + if (pView && pModel) + mpAccContext = new SvxGraphCtrlAccessibleContext(*this); + } + return mpAccContext.get(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/grfflt.cxx b/svx/source/dialog/grfflt.cxx new file mode 100644 index 000000000..81b928900 --- /dev/null +++ b/svx/source/dialog/grfflt.cxx @@ -0,0 +1,294 @@ +/* -*- 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/BitmapSharpenFilter.hxx> +#include <vcl/BitmapMedianFilter.hxx> +#include <vcl/BitmapSobelGreyFilter.hxx> +#include <vcl/BitmapPopArtFilter.hxx> + +#include <sfx2/viewfrm.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/request.hxx> + +#include <osl/diagnose.h> +#include <svx/grfflt.hxx> +#include <svx/svxids.hrc> +#include <svx/svxdlg.hxx> + + +SvxGraphicFilterResult SvxGraphicFilter::ExecuteGrfFilterSlot( SfxRequest const & rReq, GraphicObject& rFilterObject ) +{ + const Graphic& rGraphic = rFilterObject.GetGraphic(); + SvxGraphicFilterResult nRet = SvxGraphicFilterResult::UnsupportedGraphicType; + + if( rGraphic.GetType() == GraphicType::Bitmap ) + { + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + SfxObjectShell* pShell = pViewFrame ? pViewFrame->GetObjectShell() : nullptr; + weld::Window* pFrameWeld = (pViewFrame && pViewFrame->GetViewShell()) ? pViewFrame->GetViewShell()->GetFrameWeld() : nullptr; + Graphic aGraphic; + + switch( rReq.GetSlot() ) + { + case SID_GRFFILTER_INVERT: + { + if( pShell ) + pShell->SetWaitCursor( true ); + + if( rGraphic.IsAnimated() ) + { + Animation aAnimation( rGraphic.GetAnimation() ); + + if( aAnimation.Invert() ) + aGraphic = aAnimation; + } + else + { + BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); + + if( aBmpEx.Invert() ) + aGraphic = aBmpEx; + } + + if( pShell ) + pShell->SetWaitCursor( false ); + } + break; + + case SID_GRFFILTER_SMOOTH: + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractGraphicFilterDialog> aDlg(pFact->CreateGraphicFilterSmooth(pFrameWeld, rGraphic, 0.7)); + if( aDlg->Execute() == RET_OK ) + aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); + } + break; + + case SID_GRFFILTER_SHARPEN: + { + if( pShell ) + pShell->SetWaitCursor( true ); + + if( rGraphic.IsAnimated() ) + { + Animation aAnimation( rGraphic.GetAnimation() ); + + if (BitmapFilter::Filter(aAnimation, BitmapSharpenFilter())) + aGraphic = aAnimation; + } + else + { + BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); + + if (BitmapFilter::Filter(aBmpEx, BitmapSharpenFilter())) + aGraphic = aBmpEx; + } + + if( pShell ) + pShell->SetWaitCursor( false ); + } + break; + + case SID_GRFFILTER_REMOVENOISE: + { + if( pShell ) + pShell->SetWaitCursor( true ); + + if( rGraphic.IsAnimated() ) + { + Animation aAnimation( rGraphic.GetAnimation() ); + + if (BitmapFilter::Filter(aAnimation, BitmapMedianFilter())) + aGraphic = aAnimation; + } + else + { + BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); + + if (BitmapFilter::Filter(aBmpEx, BitmapMedianFilter())) + aGraphic = aBmpEx; + } + + if( pShell ) + pShell->SetWaitCursor( false ); + } + break; + + case SID_GRFFILTER_SOBEL: + { + if( pShell ) + pShell->SetWaitCursor( true ); + + if( rGraphic.IsAnimated() ) + { + Animation aAnimation( rGraphic.GetAnimation() ); + + if (BitmapFilter::Filter(aAnimation, BitmapSobelGreyFilter())) + aGraphic = aAnimation; + } + else + { + BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); + + if (BitmapFilter::Filter(aBmpEx, BitmapSobelGreyFilter())) + aGraphic = aBmpEx; + } + + if( pShell ) + pShell->SetWaitCursor( false ); + } + break; + + case SID_GRFFILTER_MOSAIC: + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractGraphicFilterDialog> aDlg(pFact->CreateGraphicFilterMosaic(pFrameWeld, rGraphic)); + if( aDlg->Execute() == RET_OK ) + aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); + } + break; + + case SID_GRFFILTER_EMBOSS: + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractGraphicFilterDialog> aDlg(pFact->CreateGraphicFilterEmboss(pFrameWeld, rGraphic)); + if( aDlg->Execute() == RET_OK ) + aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); + } + break; + + case SID_GRFFILTER_POSTER: + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractGraphicFilterDialog> aDlg(pFact->CreateGraphicFilterPoster(pFrameWeld, rGraphic)); + if( aDlg->Execute() == RET_OK ) + aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); + } + break; + + case SID_GRFFILTER_POPART: + { + if( pShell ) + pShell->SetWaitCursor( true ); + + if( rGraphic.IsAnimated() ) + { + Animation aAnimation( rGraphic.GetAnimation() ); + + if (BitmapFilter::Filter(aAnimation, BitmapPopArtFilter())) + aGraphic = aAnimation; + } + else + { + BitmapEx aBmpEx( rGraphic.GetBitmapEx() ); + + if (BitmapFilter::Filter(aBmpEx, BitmapPopArtFilter())) + aGraphic = aBmpEx; + } + + if( pShell ) + pShell->SetWaitCursor( false ); + } + break; + + case SID_GRFFILTER_SEPIA: + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractGraphicFilterDialog> aDlg(pFact->CreateGraphicFilterSepia(pFrameWeld, rGraphic)); + if( aDlg->Execute() == RET_OK ) + aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); + } + break; + + case SID_GRFFILTER_SOLARIZE: + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractGraphicFilterDialog> aDlg(pFact->CreateGraphicFilterSolarize(pFrameWeld, rGraphic)); + if( aDlg->Execute() == RET_OK ) + aGraphic = aDlg->GetFilteredGraphic( rGraphic, 1.0, 1.0 ); + } + break; + + case SID_GRFFILTER : + { + // do nothing; no error + nRet = SvxGraphicFilterResult::NONE; + break; + } + + default: + { + OSL_FAIL( "SvxGraphicFilter: selected filter slot not yet implemented" ); + nRet = SvxGraphicFilterResult::UnsupportedSlot; + } + break; + } + + if( aGraphic.GetType() != GraphicType::NONE ) + { + rFilterObject.SetGraphic( aGraphic ); + nRet = SvxGraphicFilterResult::NONE; + } + } + + return nRet; +} + + +void SvxGraphicFilter::DisableGraphicFilterSlots( SfxItemSet& rSet ) +{ + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER ) ) + rSet.DisableItem( SID_GRFFILTER ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_INVERT ) ) + rSet.DisableItem( SID_GRFFILTER_INVERT ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_SMOOTH ) ) + rSet.DisableItem( SID_GRFFILTER_SMOOTH ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_SHARPEN ) ) + rSet.DisableItem( SID_GRFFILTER_SHARPEN ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_REMOVENOISE ) ) + rSet.DisableItem( SID_GRFFILTER_REMOVENOISE ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_SOBEL ) ) + rSet.DisableItem( SID_GRFFILTER_SOBEL ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_MOSAIC ) ) + rSet.DisableItem( SID_GRFFILTER_MOSAIC ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_EMBOSS ) ) + rSet.DisableItem( SID_GRFFILTER_EMBOSS ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_POSTER ) ) + rSet.DisableItem( SID_GRFFILTER_POSTER ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_POPART ) ) + rSet.DisableItem( SID_GRFFILTER_POPART ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_SEPIA ) ) + rSet.DisableItem( SID_GRFFILTER_SEPIA ); + + if( SfxItemState::DEFAULT <= rSet.GetItemState( SID_GRFFILTER_SOLARIZE ) ) + rSet.DisableItem( SID_GRFFILTER_SOLARIZE ); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/hdft.cxx b/svx/source/dialog/hdft.cxx new file mode 100644 index 000000000..5065d67ac --- /dev/null +++ b/svx/source/dialog/hdft.cxx @@ -0,0 +1,1060 @@ +/* -*- 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 <svl/itemiter.hxx> +#include <sfx2/objsh.hxx> +#include <svx/svxids.hrc> + +#include <svl/intitem.hxx> +#include <svtools/unitconv.hxx> + +#include <svx/hdft.hxx> +#include <svx/pageitem.hxx> + +#include <svx/dlgutil.hxx> +#include <sfx2/htmlmode.hxx> + +#include <editeng/brushitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/ulspitem.hxx> +#include <editeng/sizeitem.hxx> +#include <editeng/boxitem.hxx> + +#include <svx/svxdlg.hxx> +#include <memory> + +#include <svx/xdef.hxx> +#include <svx/xfillit0.hxx> +#include <svx/unobrushitemhelper.hxx> + +using namespace com::sun::star; + +// Word 97 incompatibility (#i19922#) +// #i19922# - tdf#126051 see cui/source/tabpages/page.cxx and sw/source/uibase/sidebar/PageMarginControl.hxx +static const long MINBODY = 56; // 1mm in twips rounded + +// default distance to Header or footer +static const long DEF_DIST_WRITER = 500; // 5mm (Writer) +static const long DEF_DIST_CALC = 250; // 2.5mm (Calc) + +const sal_uInt16 SvxHFPage::pRanges[] = +{ + SID_ATTR_BRUSH, SID_ATTR_BRUSH, + + // Support DrawingLayer FillStyles (no real call to below GetRanges() + // detected, still do the complete transition) + XATTR_FILL_FIRST, XATTR_FILL_LAST, + + SID_ATTR_BORDER_OUTER, SID_ATTR_BORDER_OUTER, + SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, + SID_ATTR_BORDER_SHADOW, SID_ATTR_BORDER_SHADOW, + SID_ATTR_LRSPACE, SID_ATTR_LRSPACE, + SID_ATTR_ULSPACE, SID_ATTR_ULSPACE, + SID_ATTR_PAGE_SIZE, SID_ATTR_PAGE_SIZE, + SID_ATTR_PAGE_HEADERSET, SID_ATTR_PAGE_HEADERSET, + SID_ATTR_PAGE_FOOTERSET, SID_ATTR_PAGE_FOOTERSET, + SID_ATTR_PAGE_ON, SID_ATTR_PAGE_ON, + SID_ATTR_PAGE_DYNAMIC, SID_ATTR_PAGE_DYNAMIC, + SID_ATTR_PAGE_SHARED, SID_ATTR_PAGE_SHARED, + SID_ATTR_PAGE_SHARED_FIRST, SID_ATTR_PAGE_SHARED_FIRST, + SID_ATTR_HDFT_DYNAMIC_SPACING, SID_ATTR_HDFT_DYNAMIC_SPACING, + 0 +}; + +namespace svx { + + bool ShowBorderBackgroundDlg(weld::Window* pParent, SfxItemSet* pBBSet) + { + bool bRes = false; + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateSvxBorderBackgroundDlg(pParent, *pBBSet, true /*bEnableDrawingLayerFillStyles*/)); + if ( pDlg->Execute() == RET_OK && pDlg->GetOutputItemSet() ) + { + SfxItemIter aIter( *pDlg->GetOutputItemSet() ); + + for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem()) + { + if ( !IsInvalidItem( pItem ) ) + pBBSet->Put( *pItem ); + } + bRes = true; + } + return bRes; + } +} + +std::unique_ptr<SfxTabPage> SvxHeaderPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet ) +{ + return std::make_unique<SvxHeaderPage>( pPage, pController, *rSet ); +} + +std::unique_ptr<SfxTabPage> SvxFooterPage::Create( weld::Container* pPage, weld::DialogController* pController, const SfxItemSet* rSet ) +{ + return std::make_unique<SvxFooterPage>( pPage, pController, *rSet ); +} + +SvxHeaderPage::SvxHeaderPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr) + : SvxHFPage( pPage, pController, rAttr, SID_ATTR_PAGE_HEADERSET ) +{ +} + +SvxFooterPage::SvxFooterPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttr) + : SvxHFPage( pPage, pController, rAttr, SID_ATTR_PAGE_FOOTERSET ) +{ +} + +SvxHFPage::SvxHFPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rSet, sal_uInt16 nSetId) + : SfxTabPage(pPage, pController, "svx/ui/headfootformatpage.ui", "HFFormatPage", &rSet) + , nId(nSetId) + , mbDisableQueryBox(false) + , mbEnableDrawingLayerFillStyles(false) + , m_xCntSharedBox(m_xBuilder->weld_check_button("checkSameLR")) + , m_xCntSharedFirstBox(m_xBuilder->weld_check_button("checkSameFP")) + , m_xLMLbl(m_xBuilder->weld_label("labelLeftMarg")) + , m_xLMEdit(m_xBuilder->weld_metric_spin_button("spinMargLeft", FieldUnit::CM)) + , m_xRMLbl(m_xBuilder->weld_label("labelRightMarg")) + , m_xRMEdit(m_xBuilder->weld_metric_spin_button("spinMargRight", FieldUnit::CM)) + , m_xDistFT(m_xBuilder->weld_label("labelSpacing")) + , m_xDistEdit(m_xBuilder->weld_metric_spin_button("spinSpacing", FieldUnit::CM)) + , m_xDynSpacingCB(m_xBuilder->weld_check_button("checkDynSpacing")) + , m_xHeightFT(m_xBuilder->weld_label("labelHeight")) + , m_xHeightEdit(m_xBuilder->weld_metric_spin_button("spinHeight", FieldUnit::CM)) + , m_xHeightDynBtn(m_xBuilder->weld_check_button("checkAutofit")) + , m_xBackgroundBtn(m_xBuilder->weld_button("buttonMore")) + , m_xBspWin(new weld::CustomWeld(*m_xBuilder, "drawingareaPageHF", m_aBspWin)) +{ + //swap header <-> footer in UI + if (nId == SID_ATTR_PAGE_FOOTERSET) + { + m_xContainer->set_help_id("svx/ui/headfootformatpage/FFormatPage"); + m_xPageLbl = m_xBuilder->weld_label("labelFooterFormat"); + m_xTurnOnBox = m_xBuilder->weld_check_button("checkFooterOn"); + + /* Set custom HIDs for the Footer help page (shared/01/05040400.xhp) + otherwise it would display the same extended help + on both the Header and Footer tabs */ + m_xCntSharedBox->set_help_id( "SVX_HID_FOOTER_CHECKSAMELR" ); + m_xCntSharedFirstBox->set_help_id( "SVX_HID_FOOTER_CHECKSAMEFP" ); + m_xLMEdit->set_help_id( "SVX_HID_FOOTER_SPINMARGLEFT" ); + m_xRMEdit->set_help_id( "SVX_HID_FOOTER_SPINMARGRIGHT" ); + m_xDistEdit->set_help_id( "SVX_HID_FOOTER_SPINSPACING" ); + m_xDynSpacingCB->set_help_id( "SVX_HID_FOOTER_CHECKDYNSPACING" ); + m_xHeightEdit->set_help_id( "SVX_HID_FOOTER_SPINHEIGHT" ); + m_xHeightDynBtn->set_help_id( "SVX_HID_FOOTER_CHECKAUTOFIT" ); + m_xBackgroundBtn->set_help_id( "SVX_HID_FOOTER_BUTTONMORE" ); + } + else //Header + { + m_xContainer->set_help_id("svx/ui/headfootformatpage/HFormatPage"); + m_xPageLbl = m_xBuilder->weld_label("labelHeaderFormat"); + m_xTurnOnBox = m_xBuilder->weld_check_button("checkHeaderOn"); + } + m_xTurnOnBox->show(); + m_xPageLbl->show(); + + InitHandler(); + m_aBspWin.EnableRTL(false); + + // This Page needs ExchangeSupport + SetExchangeSupport(); + + // Set metrics + FieldUnit eFUnit = GetModuleFieldUnit( rSet ); + SetFieldUnit( *m_xDistEdit, eFUnit ); + SetFieldUnit( *m_xHeightEdit, eFUnit ); + SetFieldUnit( *m_xLMEdit, eFUnit ); + SetFieldUnit( *m_xRMEdit, eFUnit ); +} + +SvxHFPage::~SvxHFPage() +{ +} + +bool SvxHFPage::FillItemSet( SfxItemSet* rSet ) +{ + const sal_uInt16 nWSize = GetWhich(SID_ATTR_PAGE_SIZE); + const sal_uInt16 nWLRSpace = GetWhich(SID_ATTR_LRSPACE); + const sal_uInt16 nWULSpace = GetWhich(SID_ATTR_ULSPACE); + const sal_uInt16 nWOn = GetWhich(SID_ATTR_PAGE_ON); + const sal_uInt16 nWDynamic = GetWhich(SID_ATTR_PAGE_DYNAMIC); + const sal_uInt16 nWDynSpacing = GetWhich(SID_ATTR_HDFT_DYNAMIC_SPACING); + const sal_uInt16 nWShared = GetWhich(SID_ATTR_PAGE_SHARED); + const sal_uInt16 nWSharedFirst = GetWhich( SID_ATTR_PAGE_SHARED_FIRST ); + const sal_uInt16 nWBrush = GetWhich(SID_ATTR_BRUSH); + const sal_uInt16 nWBox = GetWhich(SID_ATTR_BORDER_OUTER); + const sal_uInt16 nWBoxInfo = GetWhich(SID_ATTR_BORDER_INNER); + const sal_uInt16 nWShadow = GetWhich(SID_ATTR_BORDER_SHADOW); + + const sal_uInt16 aWhichTab[] = { + nWSize, nWSize, + nWLRSpace, nWLRSpace, + nWULSpace, nWULSpace, + nWOn, nWOn, + nWDynamic, nWDynamic, + nWShared, nWShared, + nWSharedFirst, nWSharedFirst, + nWBrush, nWBrush, + nWBoxInfo, nWBoxInfo, + nWBox, nWBox, + nWShadow, nWShadow, + nWDynSpacing, nWDynSpacing, + + // take over DrawingLayer FillStyles + XATTR_FILL_FIRST, XATTR_FILL_LAST, // [1014 + + 0, 0}; + + const SfxItemSet& rOldSet = GetItemSet(); + SfxItemPool* pPool = rOldSet.GetPool(); + DBG_ASSERT(pPool,"no pool :-("); + MapUnit eUnit = pPool->GetMetric(nWSize); + SfxItemSet aSet(*pPool,aWhichTab); + + if(mbEnableDrawingLayerFillStyles) + { + // When using the XATTR_FILLSTYLE DrawingLayer FillStyle definition + // extra action has to be done here since the pool default is drawing::FillStyle_SOLID + // instead of drawing::FillStyle_NONE (to have the default blue fill color at start). + aSet.Put(XFillStyleItem(drawing::FillStyle_NONE)); + } + + aSet.Put( SfxBoolItem( nWOn, m_xTurnOnBox->get_active() ) ); + aSet.Put( SfxBoolItem( nWDynamic, m_xHeightDynBtn->get_active() ) ); + aSet.Put( SfxBoolItem( nWShared, m_xCntSharedBox->get_active() ) ); + if(m_xCntSharedFirstBox->get_visible()) + aSet.Put(SfxBoolItem(nWSharedFirst, m_xCntSharedFirstBox->get_active())); + if (m_xDynSpacingCB->get_visible() && SfxItemPool::IsWhich(nWDynSpacing)) + { + std::unique_ptr<SfxBoolItem> pBoolItem(static_cast<SfxBoolItem*>(pPool->GetDefaultItem(nWDynSpacing).Clone())); + pBoolItem->SetValue(m_xDynSpacingCB->get_active()); + aSet.Put(std::move(pBoolItem)); + } + + // Size + SvxSizeItem aSizeItem( static_cast<const SvxSizeItem&>(rOldSet.Get( nWSize )) ); + Size aSize( aSizeItem.GetSize() ); + long nDist = GetCoreValue( *m_xDistEdit, eUnit ); + long nH = GetCoreValue( *m_xHeightEdit, eUnit ); + + nH += nDist; // add distance + aSize.setHeight( nH ); + aSizeItem.SetSize( aSize ); + aSet.Put( aSizeItem ); + + // Margins + SvxLRSpaceItem aLR( nWLRSpace ); + aLR.SetLeft( static_cast<sal_uInt16>(GetCoreValue( *m_xLMEdit, eUnit )) ); + aLR.SetRight( static_cast<sal_uInt16>(GetCoreValue( *m_xRMEdit, eUnit )) ); + aSet.Put( aLR ); + + SvxULSpaceItem aUL( nWULSpace ); + if ( nId == SID_ATTR_PAGE_HEADERSET ) + aUL.SetLower( static_cast<sal_uInt16>(nDist) ); + else + aUL.SetUpper( static_cast<sal_uInt16>(nDist) ); + aSet.Put( aUL ); + + // Background and border? + if (pBBSet) + { + aSet.Put(*pBBSet); + } + else + { + const SfxPoolItem* pItem; + + if(SfxItemState::SET == GetItemSet().GetItemState(GetWhich(nId), false, &pItem)) + { + const SfxItemSet* _pSet = &(static_cast< const SvxSetItem* >(pItem)->GetItemSet()); + + if(_pSet->GetItemState(nWBrush) == SfxItemState::SET) + { + aSet.Put(_pSet->Get(nWBrush)); + } + + if(_pSet->GetItemState(nWBoxInfo) == SfxItemState::SET) + { + aSet.Put(_pSet->Get(nWBoxInfo)); + } + + if(_pSet->GetItemState(nWBox) == SfxItemState::SET) + { + aSet.Put(_pSet->Get(nWBox)); + } + + if(_pSet->GetItemState(nWShadow) == SfxItemState::SET) + { + aSet.Put(_pSet->Get(nWShadow)); + } + + // take care of [XATTR_XATTR_FILL_FIRST .. XATTR_FILL_LAST] + for(sal_uInt16 nFillStyleId(XATTR_FILL_FIRST); nFillStyleId <= XATTR_FILL_LAST; nFillStyleId++) + { + if(_pSet->GetItemState(nFillStyleId) == SfxItemState::SET) + { + aSet.Put(_pSet->Get(nFillStyleId)); + } + } + } + } + + // Flush the SetItem + SvxSetItem aSetItem( GetWhich( nId ), aSet ); + rSet->Put( aSetItem ); + + return true; +} + + +void SvxHFPage::Reset( const SfxItemSet* rSet ) +{ + ActivatePage( *rSet ); + ResetBackground_Impl( *rSet ); + + SfxItemPool* pPool = GetItemSet().GetPool(); + DBG_ASSERT( pPool, "Where is the pool" ); + MapUnit eUnit = pPool->GetMetric( GetWhich( SID_ATTR_PAGE_SIZE ) ); + + //hide "same content on first page when this is calc + bool bIsCalc = false; + const SfxPoolItem* pExt1 = GetItem(*rSet, SID_ATTR_PAGE_EXT1); + const SfxPoolItem* pExt2 = GetItem(*rSet, SID_ATTR_PAGE_EXT2); + if (dynamic_cast<const SfxBoolItem*>(pExt1) && dynamic_cast<const SfxBoolItem*>(pExt2) ) + bIsCalc = true; + m_xCntSharedFirstBox->set_visible(!bIsCalc); + + // Evaluate header-/footer- attributes + const SvxSetItem* pSetItem = nullptr; + + if ( SfxItemState::SET == rSet->GetItemState( GetWhich(nId), false, + reinterpret_cast<const SfxPoolItem**>(&pSetItem) ) ) + { + const SfxItemSet& rHeaderSet = pSetItem->GetItemSet(); + const SfxBoolItem& rHeaderOn = + static_cast<const SfxBoolItem&>(rHeaderSet.Get(GetWhich(SID_ATTR_PAGE_ON))); + + m_xTurnOnBox->set_active(rHeaderOn.GetValue()); + + if ( rHeaderOn.GetValue() ) + { + const SfxBoolItem& rDynamic = + static_cast<const SfxBoolItem&>(rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_DYNAMIC ) )); + const SfxBoolItem& rShared = + static_cast<const SfxBoolItem&>(rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_SHARED ) )); + const SfxBoolItem* pSharedFirst = nullptr; + if (rHeaderSet.HasItem(GetWhich(SID_ATTR_PAGE_SHARED_FIRST))) + pSharedFirst = static_cast<const SfxBoolItem*>(&rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_SHARED_FIRST ) )); + const SvxSizeItem& rSize = + static_cast<const SvxSizeItem&>(rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) )); + const SvxULSpaceItem& rUL = + static_cast<const SvxULSpaceItem&>(rHeaderSet.Get( GetWhich( SID_ATTR_ULSPACE ) )); + const SvxLRSpaceItem& rLR = + static_cast<const SvxLRSpaceItem&>(rHeaderSet.Get( GetWhich( SID_ATTR_LRSPACE ) )); + if (m_xDynSpacingCB->get_visible()) + { + const SfxBoolItem& rDynSpacing = + static_cast<const SfxBoolItem&>(rHeaderSet.Get(GetWhich(SID_ATTR_HDFT_DYNAMIC_SPACING))); + m_xDynSpacingCB->set_active(rDynSpacing.GetValue()); + } + + + if ( nId == SID_ATTR_PAGE_HEADERSET ) + { // Header + SetMetricValue( *m_xDistEdit, rUL.GetLower(), eUnit ); + SetMetricValue( *m_xHeightEdit, rSize.GetSize().Height() - rUL.GetLower(), eUnit ); + } + else + { // Footer + SetMetricValue( *m_xDistEdit, rUL.GetUpper(), eUnit ); + SetMetricValue( *m_xHeightEdit, rSize.GetSize().Height() - rUL.GetUpper(), eUnit ); + } + + m_xHeightDynBtn->set_active(rDynamic.GetValue()); + SetMetricValue( *m_xLMEdit, rLR.GetLeft(), eUnit ); + SetMetricValue( *m_xRMEdit, rLR.GetRight(), eUnit ); + m_xCntSharedBox->set_active(rShared.GetValue()); + if (pSharedFirst) + m_xCntSharedFirstBox->set_active(pSharedFirst->GetValue()); + else + m_xCntSharedFirstBox->hide(); + } + else + pSetItem = nullptr; + } + else + { + // defaults for distance and height + long nDefaultDist = bIsCalc ? DEF_DIST_CALC : DEF_DIST_WRITER; + SetMetricValue( *m_xDistEdit, nDefaultDist, MapUnit::Map100thMM ); + SetMetricValue( *m_xHeightEdit, 500, MapUnit::Map100thMM ); + } + + if ( !pSetItem ) + { + m_xTurnOnBox->set_active(false); + m_xHeightDynBtn->set_active(true); + m_xCntSharedBox->set_active(true); + m_xCntSharedFirstBox->set_active(true); + } + + TurnOn(nullptr); + + m_xTurnOnBox->save_state(); + m_xDistEdit->save_value(); + m_xHeightEdit->save_value(); + m_xHeightDynBtn->save_state(); + m_xLMEdit->save_value(); + m_xRMEdit->save_value(); + m_xCntSharedBox->save_state(); + RangeHdl(); + + const SfxPoolItem* pItem = nullptr; + SfxObjectShell* pShell; + if(SfxItemState::SET == rSet->GetItemState(SID_HTML_MODE, false, &pItem) || + ( nullptr != (pShell = SfxObjectShell::Current()) && + nullptr != (pItem = pShell->GetItem(SID_HTML_MODE)))) + { + sal_uInt16 nHtmlMode = static_cast<const SfxUInt16Item*>(pItem)->GetValue(); + if (nHtmlMode & HTMLMODE_ON) + { + m_xCntSharedBox->hide(); + m_xBackgroundBtn->hide(); + } + } + +} + +void SvxHFPage::InitHandler() +{ + m_xTurnOnBox->connect_toggled(LINK(this, SvxHFPage, TurnOnHdl)); + m_xDistEdit->connect_value_changed(LINK(this, SvxHFPage, ValueChangeHdl)); + m_xHeightEdit->connect_value_changed(LINK(this,SvxHFPage,ValueChangeHdl)); + + m_xLMEdit->connect_value_changed(LINK(this, SvxHFPage, ValueChangeHdl)); + m_xRMEdit->connect_value_changed(LINK(this, SvxHFPage, ValueChangeHdl)); + m_xBackgroundBtn->connect_clicked(LINK(this,SvxHFPage, BackgroundHdl)); +} + +void SvxHFPage::TurnOn(const weld::ToggleButton* pBox) +{ + if (m_xTurnOnBox->get_active()) + { + m_xDistFT->set_sensitive(true); + m_xDistEdit->set_sensitive(true); + m_xDynSpacingCB->set_sensitive(true); + m_xHeightFT->set_sensitive(true); + m_xHeightEdit->set_sensitive(true); + m_xHeightDynBtn->set_sensitive(true); + m_xLMLbl->set_sensitive(true); + m_xLMEdit->set_sensitive(true); + m_xRMLbl->set_sensitive(true); + m_xRMEdit->set_sensitive(true); + + SvxPageUsage nUsage = m_aBspWin.GetUsage(); + + if( nUsage == SvxPageUsage::Right || nUsage == SvxPageUsage::Left ) + m_xCntSharedBox->set_sensitive(false); + else + { + m_xCntSharedBox->set_sensitive(true); + m_xCntSharedFirstBox->set_sensitive(true); + } + m_xBackgroundBtn->set_sensitive(true); + } + else + { + bool bDelete = true; + + if (!mbDisableQueryBox && pBox && m_xTurnOnBox->get_saved_state() == TRISTATE_TRUE) + { + short nResult; + if (nId == SID_ATTR_PAGE_HEADERSET) + { + DeleteHeaderDialog aDlg(GetFrameWeld()); + nResult = aDlg.run(); + } + else + { + DeleteFooterDialog aDlg(GetFrameWeld()); + nResult = aDlg.run(); + } + bDelete = nResult == RET_YES; + } + + if ( bDelete ) + { + m_xDistFT->set_sensitive(false); + m_xDistEdit->set_sensitive(false); + m_xDynSpacingCB->set_sensitive(false); + m_xHeightFT->set_sensitive(false); + m_xHeightEdit->set_sensitive(false); + m_xHeightDynBtn->set_sensitive(false); + + m_xLMLbl->set_sensitive(false); + m_xLMEdit->set_sensitive(false); + m_xRMLbl->set_sensitive(false); + m_xRMEdit->set_sensitive(false); + + m_xCntSharedBox->set_sensitive(false); + m_xBackgroundBtn->set_sensitive(false); + m_xCntSharedFirstBox->set_sensitive(false); + } + else + m_xTurnOnBox->set_active(true); + } + UpdateExample(); +} + +IMPL_LINK(SvxHFPage, TurnOnHdl, weld::ToggleButton&, rBox, void) +{ + TurnOn(&rBox); +} + +IMPL_LINK_NOARG(SvxHFPage, BackgroundHdl, weld::Button&, void) +{ + if(!pBBSet) + { + // Use only the necessary items for border and background + const sal_uInt16 nOuter(GetWhich(SID_ATTR_BORDER_OUTER)); + const sal_uInt16 nInner(GetWhich(SID_ATTR_BORDER_INNER, false)); + const sal_uInt16 nShadow(GetWhich(SID_ATTR_BORDER_SHADOW)); + + if(mbEnableDrawingLayerFillStyles) + { + pBBSet.reset(new SfxItemSet( + *GetItemSet().GetPool(), + {{XATTR_FILL_FIRST, XATTR_FILL_LAST}, // DrawingLayer FillStyle definitions + {SID_COLOR_TABLE, SID_PATTERN_LIST}, // XPropertyLists for Color, Gradient, Hatch and Graphic fills + {nOuter, nOuter}, + {nInner, nInner}, + {nShadow, nShadow}})); + + // copy items for XPropertyList entries from the DrawModel so that + // the Area TabPage can access them + static const sal_uInt16 nCopyFlags[] = { + SID_COLOR_TABLE, + SID_GRADIENT_LIST, + SID_HATCH_LIST, + SID_BITMAP_LIST, + SID_PATTERN_LIST, + 0 + }; + + for(sal_uInt16 a(0); nCopyFlags[a]; a++) + { + const SfxPoolItem* pItem = GetItemSet().GetItem(nCopyFlags[a]); + + if(pItem) + { + pBBSet->Put(*pItem); + } + else + { + OSL_ENSURE(false, "XPropertyList missing (!)"); + } + } + } + else + { + const sal_uInt16 nBrush(GetWhich(SID_ATTR_BRUSH)); + + pBBSet.reset( new SfxItemSet( + *GetItemSet().GetPool(), + {{XATTR_FILL_FIRST, XATTR_FILL_LAST}, + {nBrush, nBrush}, + {nOuter, nOuter}, + {nInner, nInner}, + {nShadow, nShadow}}) ); + } + + const SfxPoolItem* pItem; + + if(SfxItemState::SET == GetItemSet().GetItemState(GetWhich(nId), false, &pItem)) + { + // If a SfxItemSet from the SetItem for SID_ATTR_PAGE_HEADERSET or + // SID_ATTR_PAGE_FOOTERSET exists, use its content + pBBSet->Put(static_cast<const SvxSetItem*>(pItem)->GetItemSet()); + } + else + { + if(mbEnableDrawingLayerFillStyles) + { + // The style for header/footer is not yet created, need to reset + // XFillStyleItem to drawing::FillStyle_NONE which is the same as in the style + // initialization. This needs to be done since the pool default for + // XFillStyleItem is drawing::FillStyle_SOLID + pBBSet->Put(XFillStyleItem(drawing::FillStyle_NONE)); + } + } + + if(SfxItemState::SET == GetItemSet().GetItemState(nInner, false, &pItem)) + { + // The set InfoItem is always required + pBBSet->Put(*pItem); + } + } + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + + VclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateSvxBorderBackgroundDlg( + GetFrameWeld(), + *pBBSet, + mbEnableDrawingLayerFillStyles)); + + pDlg->StartExecuteAsync([pDlg, this](sal_Int32 nResult) { + if (nResult == RET_OK && pDlg->GetOutputItemSet()) + { + SfxItemIter aIter(*pDlg->GetOutputItemSet()); + + for (const SfxPoolItem* pItem = aIter.GetCurItem(); pItem; pItem = aIter.NextItem()) + { + if(!IsInvalidItem(pItem)) + { + pBBSet->Put(*pItem); + } + } + + { + drawinglayer::attribute::SdrAllFillAttributesHelperPtr aFillAttributes; + + if (mbEnableDrawingLayerFillStyles) + { + // create FillAttributes directly from DrawingLayer FillStyle entries + aFillAttributes = + std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(*pBBSet); + } + else + { + const sal_uInt16 nWhich = GetWhich(SID_ATTR_BRUSH); + + if (pBBSet->GetItemState(nWhich) == SfxItemState::SET) + { + // create FillAttributes from SvxBrushItem + const SvxBrushItem& rItem + = static_cast<const SvxBrushItem&>(pBBSet->Get(nWhich)); + SfxItemSet aTempSet(*pBBSet->GetPool(), + svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aFillAttributes = + std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + if (SID_ATTR_PAGE_HEADERSET == nId) + { + //m_aBspWin.SetHdColor(rItem.GetColor()); + m_aBspWin.setHeaderFillAttributes(aFillAttributes); + } + else + { + //m_aBspWin.SetFtColor(rItem.GetColor()); + m_aBspWin.setFooterFillAttributes(aFillAttributes); + } + } + } + pDlg->disposeOnce(); + }); + + UpdateExample(); +} + +void SvxHFPage::UpdateExample() +{ + if ( nId == SID_ATTR_PAGE_HEADERSET ) + { + m_aBspWin.SetHeader( m_xTurnOnBox->get_active() ); + m_aBspWin.SetHdHeight( GetCoreValue( *m_xHeightEdit, MapUnit::MapTwip ) ); + m_aBspWin.SetHdDist( GetCoreValue( *m_xDistEdit, MapUnit::MapTwip ) ); + m_aBspWin.SetHdLeft( GetCoreValue( *m_xLMEdit, MapUnit::MapTwip ) ); + m_aBspWin.SetHdRight( GetCoreValue( *m_xRMEdit, MapUnit::MapTwip ) ); + } + else + { + m_aBspWin.SetFooter( m_xTurnOnBox->get_active() ); + m_aBspWin.SetFtHeight( GetCoreValue( *m_xHeightEdit, MapUnit::MapTwip ) ); + m_aBspWin.SetFtDist( GetCoreValue( *m_xDistEdit, MapUnit::MapTwip ) ); + m_aBspWin.SetFtLeft( GetCoreValue( *m_xLMEdit, MapUnit::MapTwip ) ); + m_aBspWin.SetFtRight( GetCoreValue( *m_xRMEdit, MapUnit::MapTwip ) ); + } + m_aBspWin.Invalidate(); +} + +void SvxHFPage::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 = static_cast< const SfxBoolItem& >(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)); + SfxItemSet aTempSet(*rTmpSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + 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 = static_cast< const SfxBoolItem& >(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)); + SfxItemSet aTempSet(*rTmpSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + 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 + { + nWhich = GetWhich(SID_ATTR_BRUSH); + + if(rSet.GetItemState(nWhich) >= SfxItemState::DEFAULT) + { + // create FillAttributes from SvxBrushItem + const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(rSet.Get(nWhich)); + SfxItemSet aTempSet(*rSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{}); + + setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet); + aPageFillAttributes = std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(aTempSet); + } + } + + m_aBspWin.setPageFillAttributes(aPageFillAttributes); +} + +void SvxHFPage::ActivatePage( const SfxItemSet& rSet ) +{ + const SfxPoolItem* pItem = GetItem( rSet, SID_ATTR_LRSPACE ); + + if ( pItem ) + { + // Set left and right margins + const SvxLRSpaceItem& rLRSpace = static_cast<const SvxLRSpaceItem&>(*pItem); + + m_aBspWin.SetLeft( rLRSpace.GetLeft() ); + m_aBspWin.SetRight( rLRSpace.GetRight() ); + } + else + { + m_aBspWin.SetLeft( 0 ); + m_aBspWin.SetRight( 0 ); + } + + pItem = GetItem( rSet, SID_ATTR_ULSPACE ); + + if ( pItem ) + { + // Set top and bottom margins + const SvxULSpaceItem& rULSpace = static_cast<const SvxULSpaceItem&>(*pItem); + + m_aBspWin.SetTop( rULSpace.GetUpper() ); + m_aBspWin.SetBottom( rULSpace.GetLower() ); + } + else + { + m_aBspWin.SetTop( 0 ); + m_aBspWin.SetBottom( 0 ); + } + + SvxPageUsage nUsage = SvxPageUsage::All; + pItem = GetItem( rSet, SID_ATTR_PAGE ); + + if ( pItem ) + nUsage = static_cast<const SvxPageItem*>(pItem)->GetPageUsage(); + + m_aBspWin.SetUsage( nUsage ); + + if ( SvxPageUsage::Right == nUsage || SvxPageUsage::Left == nUsage ) + m_xCntSharedBox->set_sensitive(false); + else + { + m_xCntSharedBox->set_sensitive(true); + m_xCntSharedFirstBox->set_sensitive(true); + } + pItem = GetItem( rSet, SID_ATTR_PAGE_SIZE ); + + if ( pItem ) + { + // Orientation and Size from the PageItem + const SvxSizeItem& rSize = static_cast<const SvxSizeItem&>(*pItem); + // if the size is already swapped (Landscape) + m_aBspWin.SetSize( rSize.GetSize() ); + } + + // Evaluate Header attribute + const SvxSetItem* pSetItem = nullptr; + + if ( SfxItemState::SET == rSet.GetItemState( GetWhich( SID_ATTR_PAGE_HEADERSET ), + false, + reinterpret_cast<const SfxPoolItem**>(&pSetItem) ) ) + { + const SfxItemSet& rHeaderSet = pSetItem->GetItemSet(); + const SfxBoolItem& rHeaderOn = + static_cast<const SfxBoolItem&>(rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_ON ) )); + + if ( rHeaderOn.GetValue() ) + { + const SvxSizeItem& rSize = static_cast<const SvxSizeItem&>( + rHeaderSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) )); + const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>( + rHeaderSet.Get( GetWhich(SID_ATTR_ULSPACE ) )); + const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>( + rHeaderSet.Get( GetWhich( SID_ATTR_LRSPACE ) )); + long nDist = rUL.GetLower(); + + m_aBspWin.SetHdHeight( rSize.GetSize().Height() - nDist ); + m_aBspWin.SetHdDist( nDist ); + m_aBspWin.SetHdLeft( rLR.GetLeft() ); + m_aBspWin.SetHdRight( rLR.GetRight() ); + m_aBspWin.SetHeader( true ); + } + else + pSetItem = nullptr; + } + + if ( !pSetItem ) + { + m_aBspWin.SetHeader( false ); + + if ( SID_ATTR_PAGE_HEADERSET == nId ) + { + m_xCntSharedBox->set_sensitive(false); + m_xCntSharedFirstBox->set_sensitive(false); + } + } + pSetItem = nullptr; + + if ( SfxItemState::SET == rSet.GetItemState( GetWhich( SID_ATTR_PAGE_FOOTERSET ), + false, + reinterpret_cast<const SfxPoolItem**>(&pSetItem) ) ) + { + const SfxItemSet& rFooterSet = pSetItem->GetItemSet(); + const SfxBoolItem& rFooterOn = + static_cast<const SfxBoolItem&>(rFooterSet.Get( GetWhich( SID_ATTR_PAGE_ON ) )); + + if ( rFooterOn.GetValue() ) + { + const SvxSizeItem& rSize = static_cast<const SvxSizeItem&>( + rFooterSet.Get( GetWhich( SID_ATTR_PAGE_SIZE ) )); + const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>( + rFooterSet.Get( GetWhich( SID_ATTR_ULSPACE ) )); + const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>( + rFooterSet.Get( GetWhich( SID_ATTR_LRSPACE ) )); + long nDist = rUL.GetUpper(); + + m_aBspWin.SetFtHeight( rSize.GetSize().Height() - nDist ); + m_aBspWin.SetFtDist( nDist ); + m_aBspWin.SetFtLeft( rLR.GetLeft() ); + m_aBspWin.SetFtRight( rLR.GetRight() ); + m_aBspWin.SetFooter( true ); + } + else + pSetItem = nullptr; + } + + if ( !pSetItem ) + { + m_aBspWin.SetFooter( false ); + + if ( SID_ATTR_PAGE_FOOTERSET == nId ) + { + m_xCntSharedBox->set_sensitive(false); + m_xCntSharedFirstBox->set_sensitive(false); + } + } + + pItem = GetItem( rSet, SID_ATTR_PAGE_EXT1 ); + + if ( auto pBoolItem = dynamic_cast<const SfxBoolItem*>( pItem) ) + { + m_aBspWin.SetTable( true ); + m_aBspWin.SetHorz( pBoolItem->GetValue() ); + } + + pItem = GetItem( rSet, SID_ATTR_PAGE_EXT2 ); + + if ( auto pBoolItem = dynamic_cast<const SfxBoolItem*>( pItem) ) + { + m_aBspWin.SetTable( true ); + m_aBspWin.SetVert( pBoolItem->GetValue() ); + } + ResetBackground_Impl( rSet ); + RangeHdl(); +} + +DeactivateRC SvxHFPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +IMPL_LINK_NOARG(SvxHFPage, ValueChangeHdl, weld::MetricSpinButton&, void) +{ + UpdateExample(); + RangeHdl(); +} + +void SvxHFPage::RangeHdl() +{ + long nHHeight = m_aBspWin.GetHdHeight(); + long nHDist = m_aBspWin.GetHdDist(); + + long nFHeight = m_aBspWin.GetFtHeight(); + long nFDist = m_aBspWin.GetFtDist(); + + long nHeight = std::max(long(MINBODY), + static_cast<long>(m_xHeightEdit->denormalize(m_xHeightEdit->get_value(FieldUnit::TWIP)))); + long nDist = m_xTurnOnBox->get_active() ? + static_cast<long>(m_xDistEdit->denormalize(m_xDistEdit->get_value(FieldUnit::TWIP))) : 0; + + long nMin; + long nMax; + + if ( nId == SID_ATTR_PAGE_HEADERSET ) + { + nHHeight = nHeight; + nHDist = nDist; + } + else + { + nFHeight = nHeight; + nFDist = nDist; + } + + // Current values of the side edges + long nBT = m_aBspWin.GetTop(); + long nBB = m_aBspWin.GetBottom(); + long nBL = m_aBspWin.GetLeft(); + long nBR = m_aBspWin.GetRight(); + + long nH = m_aBspWin.GetSize().Height(); + long nW = m_aBspWin.GetSize().Width(); + + // Borders + if ( nId == SID_ATTR_PAGE_HEADERSET ) + { + // Header + nMin = ( nH - nBB - nBT ) / 5; // 20% + nMax = std::max( nH - nMin - nHDist - nFDist - nFHeight - nBB - nBT, + nMin ); + m_xHeightEdit->set_max(m_xHeightEdit->normalize(nMax), FieldUnit::TWIP); + nMin = ( nH - nBB - nBT ) / 5; // 20% + nDist = std::max( nH - nMin - nHHeight - nFDist - nFHeight - nBB - nBT, + long(0) ); + m_xDistEdit->set_max(m_xDistEdit->normalize(nDist), FieldUnit::TWIP); + } + else + { + // Footer + nMin = ( nH - nBT - nBB ) / 5; // 20% + nMax = std::max( nH - nMin - nFDist - nHDist - nHHeight - nBT - nBB, + nMin ); + m_xHeightEdit->set_max(m_xHeightEdit->normalize(nMax), FieldUnit::TWIP); + nMin = ( nH - nBT - nBB ) / 5; // 20% + nDist = std::max( nH - nMin - nFHeight - nHDist - nHHeight - nBT - nBB, + long(0) ); + m_xDistEdit->set_max(m_xDistEdit->normalize(nDist), FieldUnit::TWIP); + } + + // Limit Indentation + nMax = nW - nBL - nBR - + static_cast<long>(m_xRMEdit->denormalize(m_xRMEdit->get_value(FieldUnit::TWIP))) - MINBODY; + m_xLMEdit->set_max(m_xLMEdit->normalize(nMax), FieldUnit::TWIP); + + nMax = nW - nBL - nBR - + static_cast<long>(m_xLMEdit->denormalize(m_xLMEdit->get_value(FieldUnit::TWIP))) - MINBODY; + m_xRMEdit->set_max(m_xLMEdit->normalize(nMax), FieldUnit::TWIP); +} + +void SvxHFPage::EnableDynamicSpacing() +{ + m_xDynSpacingCB->show(); +} + +void SvxHFPage::PageCreated(const SfxAllItemSet &rSet) +{ + const SfxBoolItem* pSupportDrawingLayerFillStyleItem = rSet.GetItem<SfxBoolItem>(SID_DRAWINGLAYER_FILLSTYLES, false); + + if (pSupportDrawingLayerFillStyleItem) + { + const bool bNew(pSupportDrawingLayerFillStyleItem->GetValue()); + + mbEnableDrawingLayerFillStyles = bNew; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/hexcolorcontrol.cxx b/svx/source/dialog/hexcolorcontrol.cxx new file mode 100644 index 000000000..b9a4cd645 --- /dev/null +++ b/svx/source/dialog/hexcolorcontrol.cxx @@ -0,0 +1,112 @@ +/* -*- 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 <sax/tools/converter.hxx> +#include <svx/hexcolorcontrol.hxx> +#include <rtl/character.hxx> +#include <vcl/svapp.hxx> +#include <vcl/weld.hxx> + +namespace weld +{ +HexColorControl::HexColorControl(std::unique_ptr<weld::Entry> pEntry) + : m_xEntry(std::move(pEntry)) + , m_nAsyncModifyEvent(nullptr) +{ + m_xEntry->set_max_length(6); + m_xEntry->set_width_chars(6); + m_xEntry->connect_insert_text(LINK(this, HexColorControl, ImplProcessInputHdl)); + m_xEntry->connect_changed(LINK(this, HexColorControl, ImplProcessModifyHdl)); +} + +HexColorControl::~HexColorControl() +{ + if (m_nAsyncModifyEvent) + Application::RemoveUserEvent(m_nAsyncModifyEvent); +} + +IMPL_LINK_NOARG(HexColorControl, OnAsyncModifyHdl, void*, void) +{ + m_nAsyncModifyEvent = nullptr; + m_aModifyHdl.Call(*m_xEntry); +} + +// tdf#123291 resend it async so it arrives after ImplProcessInputHdl has been +// processed +IMPL_LINK_NOARG(HexColorControl, ImplProcessModifyHdl, weld::Entry&, void) +{ + if (m_nAsyncModifyEvent) + Application::RemoveUserEvent(m_nAsyncModifyEvent); + m_nAsyncModifyEvent = Application::PostUserEvent(LINK(this, HexColorControl, OnAsyncModifyHdl)); +} + +void HexColorControl::SetColor(Color nColor) +{ + OUStringBuffer aBuffer; + sax::Converter::convertColor(aBuffer, nColor); + OUString sColor = aBuffer.makeStringAndClear().copy(1); + if (sColor == m_xEntry->get_text()) + return; + m_xEntry->set_text(sColor); +} + +Color HexColorControl::GetColor() const +{ + sal_Int32 nColor = -1; + + OUString aStr = "#" + m_xEntry->get_text(); + sal_Int32 nLen = aStr.getLength(); + + if (nLen < 7) + { + static const char* const pNullStr = "000000"; + aStr += OUString::createFromAscii(&pNullStr[nLen - 1]); + } + + sax::Converter::convertColor(nColor, aStr); + +#if 0 + if (nColor == -1) + SetControlBackground(COL_RED); + else + SetControlBackground(); +#endif + + return Color(nColor); +} + +IMPL_STATIC_LINK(HexColorControl, ImplProcessInputHdl, OUString&, rTest, bool) +{ + const sal_Unicode* pTest = rTest.getStr(); + sal_Int32 nLen = rTest.getLength(); + + OUStringBuffer aFilter(nLen); + for (sal_Int32 i = 0; i < nLen; ++i) + { + if (rtl::isAsciiHexDigit(*pTest)) + aFilter.append(*pTest); + ++pTest; + } + + rTest = aFilter.makeStringAndClear(); + return true; +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/hyperdlg.cxx b/svx/source/dialog/hyperdlg.cxx new file mode 100644 index 000000000..1bbc40e75 --- /dev/null +++ b/svx/source/dialog/hyperdlg.cxx @@ -0,0 +1,85 @@ +/* -*- 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/hyperdlg.hxx> +#include <svx/svxdlg.hxx> +#include <sfx2/app.hxx> +#include <sfx2/sfxsids.hrc> + + +//# # +//# Childwindow-Wrapper-Class # +//# # + + +SFX_IMPL_CHILDWINDOW_WITHID(SvxHlinkDlgWrapper, SID_HYPERLINK_DIALOG) + +SvxHlinkDlgWrapper::SvxHlinkDlgWrapper( vcl::Window* _pParent, sal_uInt16 nId, + SfxBindings* pBindings, + SfxChildWinInfo* pInfo ) : + SfxChildWindow( _pParent, nId ), + + mpDlg( nullptr ) + +{ + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + mpDlg = pFact->CreateSvxHpLinkDlg(this, pBindings, _pParent->GetFrameWeld()); + SetController( mpDlg->GetController() ); + SetVisible_Impl(false); + + vcl::Window* pTopWindow = nullptr; + if ( !pInfo->aSize.IsEmpty() ) + { + pTopWindow = SfxGetpApp()->GetTopWindow(); + if (pTopWindow) + { + weld::Dialog* pDialog = GetController()->getDialog(); + + Size aParentSize( pTopWindow->GetSizePixel() ); + Size aDlgSize(pDialog->get_size()); + + if( aParentSize.Width() < pInfo->aPos.X() ) + pInfo->aPos.setX( aParentSize.Width()-aDlgSize.Width() < long(0.1*aParentSize.Width()) ? + long(0.1*aParentSize.Width()) : aParentSize.Width()-aDlgSize.Width() ); + if( aParentSize.Height() < pInfo->aPos. Y() ) + pInfo->aPos.setY( aParentSize.Height()-aDlgSize.Height() < long(0.1*aParentSize.Height()) ? + long(0.1*aParentSize.Height()) : aParentSize.Height()-aDlgSize.Height() ); + + pDialog->window_move(pInfo->aPos.X(), pInfo->aPos.Y()); + } + } + SetHideNotDelete( true ); +} + +SfxChildWinInfo SvxHlinkDlgWrapper::GetInfo() const +{ + return SfxChildWindow::GetInfo(); +} + +bool SvxHlinkDlgWrapper::QueryClose() +{ + return !mpDlg || mpDlg->QueryClose(); +} + +SvxHlinkDlgWrapper::~SvxHlinkDlgWrapper() +{ + mpDlg.disposeAndClear(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/imapdlg.cxx b/svx/source/dialog/imapdlg.cxx new file mode 100644 index 000000000..e015b3716 --- /dev/null +++ b/svx/source/dialog/imapdlg.cxx @@ -0,0 +1,733 @@ +/* -*- 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/errinf.hxx> +#include <tools/urlobj.hxx> +#include <unotools/ucbstreamhelper.hxx> +#include <svl/eitem.hxx> +#include <unotools/pathoptions.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/module.hxx> +#include <sfx2/filedlghelper.hxx> +#include <com/sun/star/ui/dialogs/TemplateDescription.hpp> +#include <svl/urihelper.hxx> +#include <svtools/ehdl.hxx> +#include <svtools/inettbc.hxx> +#include <svtools/sfxecode.hxx> +#include <sfx2/viewfrm.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/docfile.hxx> +#include <unotools/localedatawrapper.hxx> +#include <vcl/weld.hxx> +#include <svx/imapdlg.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include "imapwnd.hxx" +#include "imapimp.hxx" +#include <svx/svdopath.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include "dlgunit.hxx" +#include <memory> + +#define SELF_TARGET "_self" +#define IMAP_CERN_FILTER "MAP - CERN" +#define IMAP_NCSA_FILTER "MAP - NCSA" +#define IMAP_BINARY_FILTER "SIP - StarView ImageMap" +#define IMAP_ALL_TYPE "*.*" +#define IMAP_BINARY_TYPE "*.sip" +#define IMAP_CERN_TYPE "*.map" +#define IMAP_NCSA_TYPE "*.map" + +SFX_IMPL_MODELESSDIALOGCONTOLLER_WITHID( SvxIMapDlgChildWindow, SID_IMAP ); + +// ControllerItem + +SvxIMapDlgItem::SvxIMapDlgItem( SvxIMapDlg& rIMapDlg, SfxBindings& rBindings ) : + SfxControllerItem ( SID_IMAP_EXEC, rBindings ), + rIMap ( rIMapDlg ) +{ +} + +void SvxIMapDlgItem::StateChanged( sal_uInt16 nSID, SfxItemState /*eState*/, + const SfxPoolItem* pItem ) +{ + if ( ( nSID == SID_IMAP_EXEC ) && pItem ) + { + const SfxBoolItem* pStateItem = dynamic_cast<const SfxBoolItem*>( pItem ); + assert(pStateItem); //SfxBoolItem expected + if (pStateItem) + { + // Disable Float if possible + rIMap.SetExecState( !pStateItem->GetValue() ); + } + } +} + +SvxIMapDlgChildWindow::SvxIMapDlgChildWindow(vcl::Window* _pParent, sal_uInt16 nId, + SfxBindings* pBindings, + SfxChildWinInfo const * pInfo) + : SfxChildWindow( _pParent, nId ) +{ + SetController(std::make_shared<SvxIMapDlg>(pBindings, this, _pParent->GetFrameWeld())); + SvxIMapDlg* pDlg = static_cast<SvxIMapDlg*>(GetController().get()); + pDlg->Initialize( pInfo ); +} + +void SvxIMapDlgChildWindow::UpdateIMapDlg( const Graphic& rGraphic, const ImageMap* pImageMap, + const TargetList* pTargetList, void* pEditingObj ) +{ + SvxIMapDlg* pDlg = GetIMapDlg(); + if (pDlg) + pDlg->UpdateLink(rGraphic, pImageMap, pTargetList, pEditingObj); +} + +SvxIMapDlg::SvxIMapDlg(SfxBindings *_pBindings, SfxChildWindow *pCW, weld::Window* _pParent) + : SfxModelessDialogController(_pBindings, pCW, _pParent, "svx/ui/imapdialog.ui", "ImapDialog") + , pCheckObj(nullptr) + , aIMapItem(*this, *_pBindings) + , m_xIMapWnd(new IMapWindow(_pBindings->GetActiveFrame(), m_xDialog.get())) + , m_xTbxIMapDlg1(m_xBuilder->weld_toolbar("toolbar")) + , m_xFtURL(m_xBuilder->weld_label("urlft")) + , m_xURLBox(new SvtURLBox(m_xBuilder->weld_combo_box("url"))) + , m_xFtText(m_xBuilder->weld_label("textft")) + , m_xEdtText(m_xBuilder->weld_entry("text")) + , m_xFtTarget(m_xBuilder->weld_label("targetft")) + , m_xCbbTarget(m_xBuilder->weld_combo_box("target")) + , m_xCancelBtn(m_xBuilder->weld_button("cancel")) + , m_xStbStatus1(m_xBuilder->weld_label("statusurl")) + , m_xStbStatus2(m_xBuilder->weld_label("statuspos")) + , m_xStbStatus3(m_xBuilder->weld_label("statussize")) + , m_xIMapWndWeld(new weld::CustomWeld(*m_xBuilder, "container", *m_xIMapWnd)) + +{ + m_xTbxIMapDlg1->insert_separator(4, "sep1"); + m_xTbxIMapDlg1->insert_separator(10, "sep2"); + m_xTbxIMapDlg1->insert_separator(15, "sep3"); + m_xTbxIMapDlg1->insert_separator(18, "sel4"); + + //lock this down so it doesn't jump around in size + //as entries are added later on + TargetList aTmpList; + SfxFrame::GetDefaultTargetList(aTmpList); + for (const OUString & s : aTmpList) + m_xCbbTarget->append_text(s); + Size aPrefSize(m_xCbbTarget->get_preferred_size()); + m_xCbbTarget->set_size_request(aPrefSize.Width(), -1); + m_xCbbTarget->clear(); + + m_xIMapWnd->Show(); + + pOwnData.reset(new IMapOwnData); + + m_xIMapWnd->SetInfoLink( LINK( this, SvxIMapDlg, InfoHdl ) ); + m_xIMapWnd->SetMousePosLink( LINK( this, SvxIMapDlg, MousePosHdl ) ); + m_xIMapWnd->SetGraphSizeLink( LINK( this, SvxIMapDlg, GraphSizeHdl ) ); + m_xIMapWnd->SetUpdateLink( LINK( this, SvxIMapDlg, StateHdl ) ); + + m_xURLBox->connect_changed( LINK( this, SvxIMapDlg, URLModifyHdl ) ); + m_xURLBox->connect_focus_out( LINK( this, SvxIMapDlg, URLLoseFocusHdl ) ); + m_xEdtText->connect_changed( LINK( this, SvxIMapDlg, EntryModifyHdl ) ); + m_xCbbTarget->connect_focus_out( LINK( this, SvxIMapDlg, URLLoseFocusHdl ) ); + + m_xTbxIMapDlg1->connect_clicked( LINK( this, SvxIMapDlg, TbxClickHdl ) ); + OString sSelect("TBI_SELECT"); + m_xTbxIMapDlg1->set_item_active(sSelect, true); + TbxClickHdl(sSelect); + + m_xStbStatus1->set_size_request(120, -1); + const int nWidth = m_xStbStatus1->get_pixel_size(" 9999,99 cm / 9999,99 cm ").Width(); + m_xStbStatus2->set_size_request(nWidth, -1); + m_xStbStatus3->set_size_request(nWidth, -1); + + m_xFtURL->set_sensitive(false); + m_xURLBox->set_sensitive(false); + m_xFtText->set_sensitive(false); + m_xEdtText->set_sensitive(false); + m_xFtTarget->set_sensitive(false); + m_xCbbTarget->set_sensitive(false); + pOwnData->bExecState = false; + + pOwnData->aIdle.SetInvokeHandler( LINK( this, SvxIMapDlg, UpdateHdl ) ); + + m_xTbxIMapDlg1->set_item_sensitive("TBI_ACTIVE", false); + m_xTbxIMapDlg1->set_item_sensitive("TBI_MACRO", false ); + m_xTbxIMapDlg1->set_item_sensitive("TBI_PROPERTY", false ); + + m_xCancelBtn->connect_clicked(LINK(this, SvxIMapDlg, CancelHdl)); +} + +SvxIMapDlg::~SvxIMapDlg() +{ + m_xIMapWnd->SetUpdateLink( Link<GraphCtrl*,void>() ); + m_xIMapWnd.reset(); +} + +IMPL_LINK_NOARG(SvxIMapDlg, CancelHdl, weld::Button&, void) +{ + bool bRet = true; + + if ( m_xTbxIMapDlg1->get_item_sensitive("TBI_APPLY") ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xDialog.get(), "svx/ui/querymodifyimagemapchangesdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QueryModifyImageMapChangesDialog")); + const long nRet = xQBox->run(); + + if( nRet == RET_YES ) + { + SfxBoolItem aBoolItem( SID_IMAP_EXEC, true ); + GetBindings().GetDispatcher()->ExecuteList(SID_IMAP_EXEC, + SfxCallMode::SYNCHRON | SfxCallMode::RECORD, + { &aBoolItem }); + } + else if( nRet == RET_CANCEL ) + bRet = false; + } + else if( m_xIMapWnd->IsChanged() ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xDialog.get(), "svx/ui/querysaveimagemapchangesdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QuerySaveImageMapChangesDialog")); + const long nRet = xQBox->run(); + + if( nRet == RET_YES ) + bRet = DoSave(); + else if( nRet == RET_CANCEL ) + bRet = false; + } + + if (bRet) + m_xDialog->response(RET_CANCEL); +} + +// Enabled or disable all Controls + +void SvxIMapDlg::SetExecState( bool bEnable ) +{ + pOwnData->bExecState = bEnable; +} + +const ImageMap& SvxIMapDlg::GetImageMap() const +{ + return m_xIMapWnd->GetImageMap(); +} + +void SvxIMapDlg::SetTargetList( const TargetList& rTargetList ) +{ + TargetList aNewList( rTargetList ); + + m_xIMapWnd->SetTargetList( aNewList ); + + m_xCbbTarget->clear(); + + for (const OUString & s : aNewList) + m_xCbbTarget->append_text(s); +} + +void SvxIMapDlg::UpdateLink( const Graphic& rGraphic, const ImageMap* pImageMap, + const TargetList* pTargetList, void* pEditingObj ) +{ + pOwnData->aUpdateGraphic = rGraphic; + + if ( pImageMap ) + pOwnData->aUpdateImageMap = *pImageMap; + else + pOwnData->aUpdateImageMap.ClearImageMap(); + + pOwnData->pUpdateEditingObject = pEditingObj; + + // Delete UpdateTargetList, because this method can still be called several + // times before the update timer is turned on + pOwnData->aUpdateTargetList.clear(); + + // TargetList must be copied, since it is owned by the caller and can be + // deleted immediately after this call the copied list will be deleted + // again in the handler + if( pTargetList ) + { + TargetList aTargetList( *pTargetList ); + + for (const OUString & s : aTargetList) + pOwnData->aUpdateTargetList.push_back( s ); + } + + pOwnData->aIdle.Start(); +} + + +// Click-handler for ToolBox + +IMPL_LINK(SvxIMapDlg, TbxClickHdl, const OString&, rNewItemId, void) +{ + if (rNewItemId == "TBI_APPLY") + { + URLLoseFocusHdl(*m_xCbbTarget); + SfxBoolItem aBoolItem( SID_IMAP_EXEC, true ); + GetBindings().GetDispatcher()->ExecuteList(SID_IMAP_EXEC, + SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, + { &aBoolItem }); + } + else if (rNewItemId == "TBI_OPEN") + DoOpen(); + else if (rNewItemId == "TBI_SAVEAS") + DoSave(); + else if (rNewItemId == "TBI_CLOSE") + CancelHdl(*m_xCancelBtn); + else if (rNewItemId == "TBI_SELECT") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetEditMode( true ); + } + else if (rNewItemId == "TBI_RECT") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetObjKind( OBJ_RECT ); + } + else if (rNewItemId == "TBI_CIRCLE") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetObjKind( OBJ_CIRC ); + } + else if (rNewItemId == "TBI_POLY") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetObjKind( OBJ_POLY ); + } + else if (rNewItemId == "TBI_FREEPOLY") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetObjKind( OBJ_FREEFILL ); + } + else if (rNewItemId == "TBI_ACTIVE") + { + URLLoseFocusHdl(*m_xCbbTarget); + bool bNewState = !m_xTbxIMapDlg1->get_item_active(rNewItemId); + m_xTbxIMapDlg1->set_item_active(rNewItemId, bNewState); + m_xIMapWnd->SetCurrentObjState( !bNewState ); + } + else if (rNewItemId == "TBI_MACRO") + m_xIMapWnd->DoMacroAssign(); + else if (rNewItemId == "TBI_PROPERTY") + m_xIMapWnd->DoPropertyDialog(); + else if (rNewItemId == "TBI_POLYEDIT") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetPolyEditMode( m_xTbxIMapDlg1->get_item_active(rNewItemId) ? SID_BEZIER_MOVE : 0 ); + } + else if (rNewItemId == "TBI_POLYMOVE") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetPolyEditMode( SID_BEZIER_MOVE ); + } + else if (rNewItemId == "TBI_POLYINSERT") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->SetPolyEditMode( SID_BEZIER_INSERT ); + } + else if (rNewItemId == "TBI_POLYDELETE") + { + SetActiveTool( rNewItemId ); + m_xIMapWnd->GetSdrView()->DeleteMarkedPoints(); + } + else if (rNewItemId == "TBI_UNDO") + { + URLLoseFocusHdl(*m_xCbbTarget); + m_xIMapWnd->GetSdrModel()->Undo(); + } + else if (rNewItemId == "TBI_REDO") + { + URLLoseFocusHdl(*m_xCbbTarget); + m_xIMapWnd->GetSdrModel()->Redo(); + } +} + +void SvxIMapDlg::DoOpen() +{ + ::sfx2::FileDialogHelper aDlg( + css::ui::dialogs::TemplateDescription::FILEOPEN_SIMPLE, + FileDialogFlags::NONE, m_xDialog.get()); + + ImageMap aLoadIMap; + const OUString aFilter(SvxResId(RID_SVXSTR_IMAP_ALL_FILTER)); + + aDlg.AddFilter( aFilter, IMAP_ALL_TYPE ); + aDlg.AddFilter( IMAP_CERN_FILTER, IMAP_CERN_TYPE ); + aDlg.AddFilter( IMAP_NCSA_FILTER, IMAP_NCSA_TYPE ); + aDlg.AddFilter( IMAP_BINARY_FILTER, IMAP_BINARY_TYPE ); + + aDlg.SetCurrentFilter( aFilter ); + aDlg.SetDisplayDirectory( SvtPathOptions().GetWorkPath() ); + + if( aDlg.Execute() == ERRCODE_NONE ) + { + INetURLObject aURL( aDlg.GetPath() ); + DBG_ASSERT( aURL.GetProtocol() != INetProtocol::NotValid, "invalid URL" ); + std::unique_ptr<SvStream> pIStm(::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::READ )); + + if( pIStm ) + { + aLoadIMap.Read( *pIStm, IMAP_FORMAT_DETECT ); + + if( pIStm->GetError() ) + { + SfxErrorContext eEC(ERRCTX_ERROR, m_xDialog.get()); + ErrorHandler::HandleError( ERRCODE_IO_GENERAL ); + } + else + m_xIMapWnd->SetImageMap( aLoadIMap ); + } + + m_xIMapWnd->Invalidate(); + } +} + +bool SvxIMapDlg::DoSave() +{ + ::sfx2::FileDialogHelper aDlg( + css::ui::dialogs::TemplateDescription::FILESAVE_SIMPLE, + FileDialogFlags::NONE, m_xDialog.get()); + + const OUString aBinFilter( IMAP_BINARY_FILTER ); + const OUString aCERNFilter( IMAP_CERN_FILTER ); + const OUString aNCSAFilter( IMAP_NCSA_FILTER ); + SdrModel* pModel = m_xIMapWnd->GetSdrModel(); + const bool bChanged = pModel->IsChanged(); + bool bRet = false; + + aDlg.AddFilter( aCERNFilter, IMAP_CERN_TYPE ); + aDlg.AddFilter( aNCSAFilter, IMAP_NCSA_TYPE ); + aDlg.AddFilter( aBinFilter, IMAP_BINARY_TYPE ); + + aDlg.SetCurrentFilter( aCERNFilter ); + aDlg.SetDisplayDirectory( SvtPathOptions().GetWorkPath() ); + + if( aDlg.Execute() == ERRCODE_NONE ) + { + const OUString aFilter( aDlg.GetCurrentFilter() ); + OUString aExt; + sal_uIntPtr nFormat; + + if ( aFilter == aBinFilter ) + { + nFormat = IMAP_FORMAT_BIN; + aExt = "sip"; + } + else if ( aFilter == aCERNFilter ) + { + nFormat = IMAP_FORMAT_CERN; + aExt = "map"; + } + else if ( aFilter == aNCSAFilter ) + { + nFormat = IMAP_FORMAT_NCSA; + aExt = "map"; + } + else + { + return false; + } + + INetURLObject aURL( aDlg.GetPath() ); + + if( aURL.GetProtocol() == INetProtocol::NotValid ) + { + OSL_FAIL( "invalid URL" ); + } + else + { + if( aURL.getExtension().isEmpty() ) + aURL.setExtension( aExt ); + + std::unique_ptr<SvStream> pOStm(::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE ), StreamMode::WRITE | StreamMode::TRUNC )); + if( pOStm ) + { + m_xIMapWnd->GetImageMap().Write( *pOStm, nFormat ); + + if( pOStm->GetError() ) + ErrorHandler::HandleError( ERRCODE_IO_GENERAL ); + + pOStm.reset(); + pModel->SetChanged( bChanged ); + bRet = true; + } + } + } + + return bRet; +} + +void SvxIMapDlg::SetActiveTool(const OString& rId) +{ + m_xTbxIMapDlg1->set_item_active("TBI_SELECT", rId == "TBI_SELECT"); + m_xTbxIMapDlg1->set_item_active("TBI_RECT", rId == "TBI_RECT"); + m_xTbxIMapDlg1->set_item_active("TBI_CIRCLE", rId == "TBI_CIRCLE"); + m_xTbxIMapDlg1->set_item_active("TBI_POLY", rId == "TBI_POLY"); + m_xTbxIMapDlg1->set_item_active("TBI_FREEPOLY", rId == "TBI_FREEPOLY"); + + m_xTbxIMapDlg1->set_item_active("TBI_POLYINSERT", rId == "TBI_POLYINSERT"); + m_xTbxIMapDlg1->set_item_active("TBI_POLYDELETE", false); + + bool bMove = rId == "TBI_POLYMOVE" + || ( rId == "TBI_POLYEDIT" + && !m_xTbxIMapDlg1->get_item_active("TBI_POLYINSERT") + && !m_xTbxIMapDlg1->get_item_active("TBI_POLYDELETE") ); + + m_xTbxIMapDlg1->set_item_active("TBI_POLYMOVE", bMove ); + + bool bEditMode = ( rId == "TBI_POLYEDIT" ) + || ( rId == "TBI_POLYMOVE") + || ( rId == "TBI_POLYINSERT") + || ( rId == "TBI_POLYDELETE" ); + + m_xTbxIMapDlg1->set_item_active("TBI_POLYEDIT", bEditMode); +} + +IMPL_LINK( SvxIMapDlg, InfoHdl, IMapWindow&, rWnd, void ) +{ + const NotifyInfo& rInfo = rWnd.GetInfo(); + + if ( rInfo.bNewObj ) + { + if (!rInfo.aMarkURL.isEmpty() && ( m_xURLBox->find_text(rInfo.aMarkURL) == -1)) + m_xURLBox->append_text(rInfo.aMarkURL); + + m_xURLBox->set_entry_text(rInfo.aMarkURL); + m_xEdtText->set_text(rInfo.aMarkAltText); + + if ( rInfo.aMarkTarget.isEmpty() ) + m_xCbbTarget->set_entry_text( SELF_TARGET ); + else + m_xCbbTarget->set_entry_text( rInfo.aMarkTarget ); + } + + if ( !rInfo.bOneMarked ) + { + m_xTbxIMapDlg1->set_item_active("TBI_ACTIVE", false); + m_xTbxIMapDlg1->set_item_sensitive("TBI_ACTIVE", false); + m_xTbxIMapDlg1->set_item_sensitive("TBI_MACRO", false); + m_xTbxIMapDlg1->set_item_sensitive("TBI_PROPERTY", false); + m_xStbStatus1->set_label(OUString()); + + m_xFtURL->set_sensitive(false); + m_xURLBox->set_sensitive(false); + m_xFtText->set_sensitive(false); + m_xEdtText->set_sensitive(false); + m_xFtTarget->set_sensitive(false); + m_xCbbTarget->set_sensitive(false); + + m_xURLBox->set_entry_text( "" ); + m_xEdtText->set_text( "" ); + } + else + { + m_xTbxIMapDlg1->set_item_sensitive("TBI_ACTIVE", true); + m_xTbxIMapDlg1->set_item_active("TBI_ACTIVE", !rInfo.bActivated ); + m_xTbxIMapDlg1->set_item_sensitive("TBI_MACRO", true); + m_xTbxIMapDlg1->set_item_sensitive("TBI_PROPERTY", true); + + m_xFtURL->set_sensitive(true); + m_xURLBox->set_sensitive(true); + m_xFtText->set_sensitive(true); + m_xEdtText->set_sensitive(true); + m_xFtTarget->set_sensitive(true); + m_xCbbTarget->set_sensitive(true); + + m_xStbStatus1->set_label(rInfo.aMarkURL); + + if ( m_xURLBox->get_active_text() != rInfo.aMarkURL ) + m_xURLBox->set_entry_text( rInfo.aMarkURL ); + + if ( m_xEdtText->get_text() != rInfo.aMarkAltText ) + m_xEdtText->set_text( rInfo.aMarkAltText ); + + if ( rInfo.aMarkTarget.isEmpty() ) + m_xCbbTarget->set_entry_text( SELF_TARGET ); + else + m_xCbbTarget->set_entry_text( rInfo.aMarkTarget ); + } +} + +IMPL_LINK( SvxIMapDlg, MousePosHdl, GraphCtrl*, pWnd, void ) +{ + const FieldUnit eFieldUnit = GetBindings().GetDispatcher()->GetModule()->GetFieldUnit(); + const Point& rMousePos = pWnd->GetMousePos(); + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() ); + const sal_Unicode cSep = rLocaleWrapper.getNumDecimalSep()[0]; + + OUString aStr = GetUnitString( rMousePos.X(), eFieldUnit, cSep ) + + " / " + GetUnitString( rMousePos.Y(), eFieldUnit, cSep ); + + m_xStbStatus2->set_label(aStr); +} + +IMPL_LINK( SvxIMapDlg, GraphSizeHdl, GraphCtrl*, pWnd, void ) +{ + const FieldUnit eFieldUnit = GetBindings().GetDispatcher()->GetModule()->GetFieldUnit(); + const Size& rSize = pWnd->GetGraphicSize(); + const LocaleDataWrapper& rLocaleWrapper( Application::GetSettings().GetLocaleDataWrapper() ); + const sal_Unicode cSep = rLocaleWrapper.getNumDecimalSep()[0]; + + OUString aStr = GetUnitString( rSize.Width(), eFieldUnit, cSep ) + + " x " + GetUnitString( rSize.Height(), eFieldUnit, cSep ); + + m_xStbStatus3->set_label(aStr); +} + +void SvxIMapDlg::URLModify() +{ + NotifyInfo aNewInfo; + + aNewInfo.aMarkURL = m_xURLBox->get_active_text(); + aNewInfo.aMarkAltText = m_xEdtText->get_text(); + aNewInfo.aMarkTarget = m_xCbbTarget->get_active_text(); + + m_xIMapWnd->ReplaceActualIMapInfo( aNewInfo ); +} + +IMPL_LINK_NOARG(SvxIMapDlg, URLModifyHdl, weld::ComboBox&, void) +{ + URLModify(); +} + +IMPL_LINK_NOARG(SvxIMapDlg, EntryModifyHdl, weld::Entry&, void) +{ + URLModify(); +} + +IMPL_LINK_NOARG(SvxIMapDlg, URLLoseFocusHdl, weld::Widget&, void) +{ + NotifyInfo aNewInfo; + const OUString aURLText( m_xURLBox->get_active_text() ); + const OUString aTargetText( m_xCbbTarget->get_active_text() ); + + if ( !aURLText.isEmpty() ) + { + OUString aBase = GetBindings().GetDispatcher()->GetFrame()->GetObjectShell()->GetMedium()->GetBaseURL(); + aNewInfo.aMarkURL = ::URIHelper::SmartRel2Abs( INetURLObject(aBase), aURLText, URIHelper::GetMaybeFileHdl(), true, false, + INetURLObject::EncodeMechanism::WasEncoded, + INetURLObject::DecodeMechanism::Unambiguous ); + } + else + aNewInfo.aMarkURL = aURLText; + + aNewInfo.aMarkAltText = m_xEdtText->get_text(); + + if ( aTargetText.isEmpty() ) + aNewInfo.aMarkTarget = SELF_TARGET; + else + aNewInfo.aMarkTarget = aTargetText; + + m_xIMapWnd->ReplaceActualIMapInfo( aNewInfo ); +} + +IMPL_LINK_NOARG(SvxIMapDlg, UpdateHdl, Timer *, void) +{ + pOwnData->aIdle.Stop(); + + if ( pOwnData->pUpdateEditingObject != pCheckObj ) + { + if (m_xIMapWnd->IsChanged()) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(m_xDialog.get(), "svx/ui/querysaveimagemapchangesdialog.ui")); + std::unique_ptr<weld::MessageDialog> xQBox(xBuilder->weld_message_dialog("QuerySaveImageMapChangesDialog")); + if (xQBox->run() == RET_YES) + { + DoSave(); + } + } + + m_xIMapWnd->SetGraphic( pOwnData->aUpdateGraphic ); + m_xIMapWnd->SetImageMap( pOwnData->aUpdateImageMap ); + SetTargetList( pOwnData->aUpdateTargetList ); + pCheckObj = pOwnData->pUpdateEditingObject; + + // After changes => default selection + m_xTbxIMapDlg1->set_item_active("TBI_SELECT", true); + m_xIMapWnd->SetEditMode( true ); + } + + // Delete the copied list again in the Update method + pOwnData->aUpdateTargetList.clear(); + + GetBindings().Invalidate( SID_IMAP_EXEC ); + m_xIMapWnd->QueueIdleUpdate(); +} + +IMPL_LINK( SvxIMapDlg, StateHdl, GraphCtrl*, pWnd, void ) +{ + const SdrObject* pObj = pWnd->GetSelectedSdrObject(); + const SdrModel* pModel = pWnd->GetSdrModel(); + const SdrView* pView = pWnd->GetSdrView(); + const bool bPolyEdit = ( pObj != nullptr ) && dynamic_cast<const SdrPathObj*>( pObj) != nullptr; + const bool bDrawEnabled = !( bPolyEdit && m_xTbxIMapDlg1->get_item_active("TBI_POLYEDIT") ); + + m_xTbxIMapDlg1->set_item_sensitive("TBI_APPLY", pOwnData->bExecState && pWnd->IsChanged() ); + + m_xTbxIMapDlg1->set_item_sensitive("TBI_SELECT", bDrawEnabled); + m_xTbxIMapDlg1->set_item_sensitive("TBI_RECT", bDrawEnabled); + m_xTbxIMapDlg1->set_item_sensitive("TBI_CIRCLE", bDrawEnabled); + m_xTbxIMapDlg1->set_item_sensitive("TBI_POLY", bDrawEnabled); + m_xTbxIMapDlg1->set_item_sensitive("TBI_FREEPOLY", bDrawEnabled); + + // BezierEditor State + m_xTbxIMapDlg1->set_item_sensitive( "TBI_POLYEDIT", bPolyEdit ); + m_xTbxIMapDlg1->set_item_sensitive( "TBI_POLYMOVE", !bDrawEnabled ); + m_xTbxIMapDlg1->set_item_sensitive( "TBI_POLYINSERT", !bDrawEnabled ); + m_xTbxIMapDlg1->set_item_sensitive( "TBI_POLYDELETE", !bDrawEnabled && pView->IsDeleteMarkedPointsPossible() ); + + // Undo/Redo + m_xTbxIMapDlg1->set_item_sensitive( "TBI_UNDO", pModel->HasUndoActions() ); + m_xTbxIMapDlg1->set_item_sensitive( "TBI_REDO", pModel->HasRedoActions() ); + + if ( bPolyEdit ) + { + switch( pWnd->GetPolyEditMode() ) + { + case SID_BEZIER_MOVE: + m_xTbxIMapDlg1->set_item_active("TBI_POLYMOVE", true); + m_xTbxIMapDlg1->set_item_active("TBI_POLYINSERT", false); + break; + case SID_BEZIER_INSERT: + m_xTbxIMapDlg1->set_item_active("TBI_POLYINSERT", true); + m_xTbxIMapDlg1->set_item_active("TBI_POLYMOVE", false); + break; + default: + break; + } + } + else + { + m_xTbxIMapDlg1->set_item_active( "TBI_POLYEDIT", false ); + m_xTbxIMapDlg1->set_item_active( "TBI_POLYMOVE", true); + m_xTbxIMapDlg1->set_item_active( "TBI_POLYINSERT", false ); + pWnd->SetPolyEditMode( 0 ); + } + + m_xIMapWnd->QueueIdleUpdate(); +} + +SvxIMapDlg* GetIMapDlg() +{ + SfxChildWindow* pWnd = nullptr; + if (SfxViewFrame::Current() && SfxViewFrame::Current()->HasChildWindow(SvxIMapDlgChildWindow::GetChildWindowId())) + pWnd = SfxViewFrame::Current()->GetChildWindow(SvxIMapDlgChildWindow::GetChildWindowId()); + return pWnd ? static_cast<SvxIMapDlg*>(pWnd->GetController().get()) : nullptr; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/imapimp.hxx b/svx/source/dialog/imapimp.hxx new file mode 100644 index 000000000..f2a10e45e --- /dev/null +++ b/svx/source/dialog/imapimp.hxx @@ -0,0 +1,50 @@ +/* -*- 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 . + */ + + +#ifndef INCLUDED_SVX_SOURCE_DIALOG_IMAPIMP_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_IMAPIMP_HXX + +#include <svx/imapdlg.hxx> +#include <vcl/graph.hxx> +#include <vcl/idle.hxx> +#include <vcl/imap.hxx> + +class IMapOwnData +{ +public: + + Idle aIdle; + Graphic aUpdateGraphic; + ImageMap aUpdateImageMap; + TargetList aUpdateTargetList; + void* pUpdateEditingObject; + bool bExecState; + + IMapOwnData() + : pUpdateEditingObject(nullptr) + , bExecState(false) + { + } +}; + + +#endif // _IMAPIMP_HXX + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/imapwnd.cxx b/svx/source/dialog/imapwnd.cxx new file mode 100644 index 000000000..2caa529e1 --- /dev/null +++ b/svx/source/dialog/imapwnd.cxx @@ -0,0 +1,748 @@ +/* -*- 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/commandevent.hxx> +#include <vcl/imaprect.hxx> +#include <vcl/imapcirc.hxx> +#include <vcl/imappoly.hxx> +#include <vcl/svapp.hxx> +#include <svl/urlbmk.hxx> + +#include <svx/svxids.hrc> +#include "imapwnd.hxx" +#include <svx/svdpage.hxx> +#include <svx/svdorect.hxx> +#include <svx/svdocirc.hxx> +#include <svx/svdopath.hxx> +#include <svx/xfltrit.hxx> +#include <svx/svdpagv.hxx> +#include <svx/xfillit0.hxx> +#include <svx/xflclit.hxx> +#include <svx/xlnclit.hxx> + +#include <sfx2/evntconf.hxx> + +#include <sot/formats.hxx> + +#include <svx/svxdlg.hxx> +#include <basegfx/polygon/b2dpolygon.hxx> +#include <memory> + +using namespace com::sun::star; +using ::com::sun::star::frame::XFrame; +using ::com::sun::star::uno::Reference; + +#define TRANSCOL COL_WHITE + +IMapWindow::IMapWindow(const Reference< XFrame >& rxDocumentFrame, weld::Dialog* pDialog) + : GraphCtrl(pDialog) + , mxDocumentFrame(rxDocumentFrame) +{ + pIMapPool = new SfxItemPool( "IMapItemPool", + SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, maItemInfos ); + pIMapPool->FreezeIdRanges(); +} + +IMapWindow::~IMapWindow() +{ + SfxItemPool::Free(pIMapPool); +} + +void IMapWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + Size aSize(pDrawingArea->get_ref_device().LogicToPixel(Size(270, 170), MapMode(MapUnit::MapAppFont))); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + SetOutputSizePixel(aSize); + weld::CustomWidgetController::SetDrawingArea(pDrawingArea); + + SetSdrMode(true); + + mxDropTargetHelper.reset(new IMapDropTargetHelper(*this)); +} + +void IMapWindow::SetImageMap( const ImageMap& rImageMap ) +{ + ReplaceImageMap( rImageMap ); +} + +void IMapWindow::ReplaceImageMap( const ImageMap& rImageMap ) +{ + SdrPage* pPage = nullptr; + aIMap = rImageMap; + + if(GetSdrModel()) + { + // try to access page + pPage = GetSdrModel()->GetPage(0); + } + + if(pPage) + { + // clear SdrObjects with broadcasting + pPage->ClearSdrObjList(); + } + + if(GetSdrView()) + { + // #i63762# reset selection at view + GetSdrView()->UnmarkAllObj(); + } + + // create new drawing objects + const sal_uInt16 nCount(rImageMap.GetIMapObjectCount()); + + for ( sal_uInt16 i(nCount); i > 0; i-- ) + { + SdrObject* pNewObj = CreateObj( rImageMap.GetIMapObject( i - 1 ) ); + + if (pNewObj && pPage) + { + pPage->InsertObject( pNewObj ); + } + } +} + +void IMapWindow::ReplaceActualIMapInfo( const NotifyInfo& rNewInfo ) +{ + const SdrObject* pSdrObj = GetSelectedSdrObject(); + IMapObject* pIMapObj; + + if ( pSdrObj ) + { + pIMapObj = GetIMapObj( pSdrObj ); + if (pIMapObj) + { + pIMapObj->SetURL( rNewInfo.aMarkURL ); + pIMapObj->SetAltText( rNewInfo.aMarkAltText ); + pIMapObj->SetTarget( rNewInfo.aMarkTarget ); + pModel->SetChanged(); + UpdateInfo( false ); + } + } +} + +const ImageMap& IMapWindow::GetImageMap() +{ + if ( pModel->IsChanged() ) + { + SdrPage* pPage = pModel->GetPage( 0 ); + + if ( pPage ) + { + const size_t nCount = pPage->GetObjCount(); + + aIMap.ClearImageMap(); + + for ( size_t i = nCount; i; ) + { + --i; + aIMap.InsertIMapObject( *( static_cast<IMapUserData*>( pPage->GetObj( i )->GetUserData( 0 ) )->GetObject() ) ); + } + } + + pModel->SetChanged( false ); + } + + return aIMap; +} + +void IMapWindow::SetTargetList( TargetList& rTargetList ) +{ + // Delete old List + aTargetList.clear(); + + // Fill with the provided list + for(const OUString & s : rTargetList) + aTargetList.push_back( s ); + + pModel->SetChanged( false ); +} + +SdrObject* IMapWindow::CreateObj( const IMapObject* pIMapObj ) +{ + tools::Rectangle aClipRect( Point(), GetGraphicSize() ); + SdrObject* pSdrObj = nullptr; + IMapObjectPtr pCloneIMapObj; + + switch( pIMapObj->GetType() ) + { + case IMAP_OBJ_RECTANGLE: + { + const IMapRectangleObject* pIMapRectObj = static_cast<const IMapRectangleObject*>(pIMapObj); + tools::Rectangle aDrawRect( pIMapRectObj->GetRectangle( false ) ); + + // clipped on CanvasPane + aDrawRect.Intersection( aClipRect ); + + pSdrObj = new SdrRectObj(*pModel, aDrawRect); + pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapRectangleObject( *pIMapRectObj ))); + } + break; + + case IMAP_OBJ_CIRCLE: + { + const IMapCircleObject* pIMapCircleObj = static_cast<const IMapCircleObject*>(pIMapObj); + const Point aCenter( pIMapCircleObj->GetCenter( false ) ); + const long nRadius = pIMapCircleObj->GetRadius( false ); + const Point aOffset( nRadius, nRadius ); + tools::Rectangle aCircle( aCenter - aOffset, aCenter + aOffset ); + + // limited to CanvasPane + aCircle.Intersection( aClipRect ); + + pSdrObj = new SdrCircObj( + *pModel, + SdrCircKind::Full, + aCircle, + 0, + 36000); + pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapCircleObject( *pIMapCircleObj ))); + } + break; + + case IMAP_OBJ_POLYGON: + { + const IMapPolygonObject* pIMapPolyObj = static_cast<const IMapPolygonObject*>(pIMapObj); + + // If it actually is an ellipse, then another ellipse is created again + if ( pIMapPolyObj->HasExtraEllipse() ) + { + tools::Rectangle aDrawRect( pIMapPolyObj->GetExtraEllipse() ); + + // clipped on CanvasPane + aDrawRect.Intersection( aClipRect ); + + pSdrObj = new SdrCircObj( + *pModel, + SdrCircKind::Full, + aDrawRect, + 0, + 36000); + } + else + { + const tools::Polygon& rPoly = pIMapPolyObj->GetPolygon( false ); + tools::Polygon aDrawPoly( rPoly ); + + // clipped on CanvasPane + aDrawPoly.Clip( aClipRect ); + + basegfx::B2DPolygon aPolygon; + aPolygon.append(aDrawPoly.getB2DPolygon()); + pSdrObj = new SdrPathObj( + *pModel, + OBJ_POLY, + basegfx::B2DPolyPolygon(aPolygon)); + } + + pCloneIMapObj.reset(static_cast<IMapObject*>(new IMapPolygonObject( *pIMapPolyObj ))); + } + break; + + default: + break; + } + + if ( pSdrObj ) + { + SfxItemSet aSet( pModel->GetItemPool() ); + + aSet.Put( XFillStyleItem( drawing::FillStyle_SOLID ) ); + aSet.Put( XFillColorItem( "", TRANSCOL ) ); + + if ( !pIMapObj->IsActive() ) + { + aSet.Put( XFillTransparenceItem( 100 ) ); + aSet.Put( XLineColorItem( "", COL_RED ) ); + } + else + { + aSet.Put( XFillTransparenceItem( 50 ) ); + aSet.Put( XLineColorItem( "", COL_BLACK ) ); + } + + pSdrObj->SetMergedItemSetAndBroadcast(aSet); + + pSdrObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pCloneIMapObj )) ); + pSdrObj->SetUserCall( GetSdrUserCall() ); + } + + return pSdrObj; +} + +void IMapWindow::InitSdrModel() +{ + GraphCtrl::InitSdrModel(); + + SfxItemSet aSet( pModel->GetItemPool() ); + + aSet.Put( XFillColorItem( "", TRANSCOL ) ); + aSet.Put( XFillTransparenceItem( 50 ) ); + pView->SetAttributes( aSet ); + pView->SetFrameDragSingles(); +} + +void IMapWindow::SdrObjCreated( const SdrObject& rObj ) +{ + switch( rObj.GetObjIdentifier() ) + { + case OBJ_RECT: + { + SdrRectObj* pRectObj = const_cast<SdrRectObj*>(static_cast<const SdrRectObj*>(&rObj)); + auto pObj = std::make_shared<IMapRectangleObject>( pRectObj->GetLogicRect(), "", "", "", "", "", true, false ); + + pRectObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) ); + } + break; + + case OBJ_CIRC: + { + SdrCircObj* pCircObj = const_cast<SdrCircObj*>( static_cast<const SdrCircObj*>(&rObj) ); + SdrPathObj* pPathObj = static_cast<SdrPathObj*>( pCircObj->ConvertToPolyObj( false, false ).release() ); + tools::Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0)); + + // always use SdrObject::Free(...) for SdrObjects (!) + SdrObject* pTemp(pPathObj); + SdrObject::Free(pTemp); + + auto pObj = std::make_shared<IMapPolygonObject>( aPoly, "", "", "", "", "", true, false ); + pObj->SetExtraEllipse( aPoly.GetBoundRect() ); + pCircObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) ); + } + break; + + case OBJ_POLY: + case OBJ_FREEFILL: + case OBJ_PATHPOLY: + case OBJ_PATHFILL: + { + SdrPathObj* pPathObj = const_cast<SdrPathObj*>( static_cast<const SdrPathObj*>(&rObj) ); + const basegfx::B2DPolyPolygon& rXPolyPoly = pPathObj->GetPathPoly(); + + if ( rXPolyPoly.count() ) + { + tools::Polygon aPoly(rXPolyPoly.getB2DPolygon(0)); + auto pObj = std::make_shared<IMapPolygonObject>( aPoly, "", "", "", "", "", true, false ); + pPathObj->AppendUserData( std::unique_ptr<SdrObjUserData>(new IMapUserData( pObj )) ); + } + } + break; + + default: + break; + } +} + +void IMapWindow::SdrObjChanged( const SdrObject& rObj ) +{ + IMapUserData* pUserData = static_cast<IMapUserData*>( rObj.GetUserData( 0 ) ); + + if ( pUserData ) + { + OUString aURL; + OUString aAltText; + OUString aDesc; + OUString aTarget; + IMapObjectPtr pIMapObj = pUserData->GetObject(); + bool bActive = true; + + if ( pIMapObj ) + { + aURL = pIMapObj->GetURL(); + aAltText = pIMapObj->GetAltText(); + aDesc = pIMapObj->GetDesc(); + aTarget = pIMapObj->GetTarget(); + bActive = pIMapObj->IsActive(); + } + + switch( rObj.GetObjIdentifier() ) + { + case OBJ_RECT: + { + pUserData->ReplaceObject( std::make_shared<IMapRectangleObject>( static_cast<const SdrRectObj&>(rObj).GetLogicRect(), + aURL, aAltText, aDesc, aTarget, "", bActive, false ) ); + } + break; + + case OBJ_CIRC: + { + const SdrCircObj& rCircObj = static_cast<const SdrCircObj&>(rObj); + SdrPathObj* pPathObj = static_cast<SdrPathObj*>( rCircObj.ConvertToPolyObj( false, false ).release() ); + tools::Polygon aPoly(pPathObj->GetPathPoly().getB2DPolygon(0)); + + auto pObj = std::make_shared<IMapPolygonObject>( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false ); + pObj->SetExtraEllipse( aPoly.GetBoundRect() ); + + // was only created by us temporarily + // always use SdrObject::Free(...) for SdrObjects (!) + SdrObject* pTemp(pPathObj); + SdrObject::Free(pTemp); + + pUserData->ReplaceObject( pObj ); + } + break; + + case OBJ_POLY: + case OBJ_FREEFILL: + case OBJ_PATHPOLY: + case OBJ_PATHFILL: + { + const SdrPathObj& rPathObj = static_cast<const SdrPathObj&>(rObj); + const basegfx::B2DPolyPolygon& rXPolyPoly = rPathObj.GetPathPoly(); + + if ( rXPolyPoly.count() ) + { + tools::Polygon aPoly(rPathObj.GetPathPoly().getB2DPolygon(0)); + auto pObj = std::make_shared<IMapPolygonObject>( aPoly, aURL, aAltText, aDesc, aTarget, "", bActive, false ); + pUserData->ReplaceObject( pObj ); + } + } + break; + + default: + break; + } + } +} + +bool IMapWindow::MouseButtonUp(const MouseEvent& rMEvt) +{ + bool bRet = GraphCtrl::MouseButtonUp( rMEvt ); + UpdateInfo( true ); + return bRet; +} + +void IMapWindow::MarkListHasChanged() +{ + GraphCtrl::MarkListHasChanged(); + UpdateInfo( false ); +} + +SdrObject* IMapWindow::GetHitSdrObj( const Point& rPosPixel ) const +{ + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + + SdrObject* pObj = nullptr; + Point aPt = rDevice.PixelToLogic( rPosPixel ); + + if ( tools::Rectangle( Point(), GetGraphicSize() ).IsInside( aPt ) ) + { + SdrPage* pPage = pModel->GetPage( 0 ); + if ( pPage ) + { + for ( size_t i = pPage->GetObjCount(); i > 0; ) + { + --i; + SdrObject* pTestObj = pPage->GetObj( i ); + IMapObject* pIMapObj = GetIMapObj( pTestObj ); + + if ( pIMapObj && pIMapObj->IsHit( aPt ) ) + { + pObj = pTestObj; + break; + } + } + } + } + + return pObj; +} + +IMapObject* IMapWindow::GetIMapObj( const SdrObject* pSdrObj ) +{ + IMapObject* pIMapObj = nullptr; + + if ( pSdrObj ) + { + IMapUserData* pUserData = static_cast<IMapUserData*>( pSdrObj->GetUserData( 0 ) ); + + if ( pUserData ) + pIMapObj = pUserData->GetObject().get(); + } + + return pIMapObj; +} + +bool IMapWindow::Command(const CommandEvent& rCEvt) +{ + if ( rCEvt.GetCommand() == CommandEventId::ContextMenu ) + { + std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetDrawingArea(), "svx/ui/imapmenu.ui")); + mxPopupMenu = xBuilder->weld_menu("menu"); + const SdrMarkList& rMarkList = pView->GetMarkedObjectList(); + const size_t nMarked = rMarkList.GetMarkCount(); + + mxPopupMenu->set_sensitive("url", false); + mxPopupMenu->set_sensitive("active", false); + mxPopupMenu->set_sensitive("macro", false); + mxPopupMenu->set_sensitive("selectall", pModel->GetPage(0)->GetObjCount() != pView->GetMarkedObjectCount()); + + if ( !nMarked ) + { + mxPopupMenu->set_sensitive("arrange", false); + mxPopupMenu->set_sensitive("delete", false); + } + else + { + if ( nMarked == 1 ) + { + SdrObject* pSdrObj = GetSelectedSdrObject(); + + mxPopupMenu->set_sensitive("url", true); + mxPopupMenu->set_sensitive("active", true); + mxPopupMenu->set_sensitive("macro", true); + mxPopupMenu->set_active("active", GetIMapObj(pSdrObj)->IsActive()); + } + + mxPopupMenu->set_sensitive("arrange", true); + mxPopupMenu->set_sensitive("delete", true); + } + + MenuSelectHdl(mxPopupMenu->popup_at_rect(GetDrawingArea(), tools::Rectangle(rCEvt.GetMousePosPixel(), Size(1,1)))); + + mxPopupMenu.reset(); + + return true; + } + return CustomWidgetController::Command(rCEvt); +} + +IMapDropTargetHelper::IMapDropTargetHelper(IMapWindow& rImapWindow) + : DropTargetHelper(rImapWindow.GetDrawingArea()->get_drop_target()) + , m_rImapWindow(rImapWindow) +{ +} + +sal_Int8 IMapDropTargetHelper::AcceptDrop( const AcceptDropEvent& rEvt ) +{ + return m_rImapWindow.AcceptDrop(rEvt); +} + +sal_Int8 IMapDropTargetHelper::ExecuteDrop( const ExecuteDropEvent& rEvt ) +{ + return m_rImapWindow.ExecuteDrop(rEvt); +} + +sal_Int8 IMapWindow::AcceptDrop( const AcceptDropEvent& rEvt ) +{ + return( ( GetHitSdrObj( rEvt.maPosPixel ) != nullptr ) ? rEvt.mnAction : DND_ACTION_NONE ); +} + +sal_Int8 IMapWindow::ExecuteDrop( const ExecuteDropEvent& rEvt ) +{ + sal_Int8 nRet = DND_ACTION_NONE; + + if (mxDropTargetHelper->IsDropFormatSupported(SotClipboardFormatId::NETSCAPE_BOOKMARK)) + { + const OUString aString; + INetBookmark aBookMark( aString, aString ); + SdrObject* pSdrObj = GetHitSdrObj( rEvt.maPosPixel ); + + if( pSdrObj && TransferableDataHelper( rEvt.maDropEvent.Transferable ).GetINetBookmark( SotClipboardFormatId::NETSCAPE_BOOKMARK, aBookMark ) ) + { + IMapObject* pIMapObj = GetIMapObj( pSdrObj ); + + pIMapObj->SetURL( aBookMark.GetURL() ); + pIMapObj->SetAltText( aBookMark.GetDescription() ); + pModel->SetChanged(); + pView->UnmarkAll(); + pView->MarkObj( pSdrObj, pView->GetSdrPageView() ); + UpdateInfo( true ); + nRet = rEvt.mnAction; + } + } + + return nRet; +} + +OUString IMapWindow::RequestHelp(tools::Rectangle& rHelpArea) +{ + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + + Point aPos = rDevice.PixelToLogic(rHelpArea.TopLeft()); + + SdrPageView* pPageView = nullptr; + SdrObject* pSdrObj = pView->PickObj(aPos, pView->getHitTolLog(), pPageView); + if (pSdrObj) + { + const IMapObject* pIMapObj = GetIMapObj( pSdrObj ); + if ( pIMapObj ) + { + OUString aStr = pIMapObj->GetURL(); + if ( !aStr.isEmpty() ) + { + rHelpArea = rDevice.LogicToPixel(tools::Rectangle( Point(), GetGraphicSize())); + return aStr; + } + } + } + + return OUString(); +} + +void IMapWindow::SetCurrentObjState( bool bActive ) +{ + SdrObject* pObj = GetSelectedSdrObject(); + + if ( pObj ) + { + SfxItemSet aSet( pModel->GetItemPool() ); + + GetIMapObj( pObj )->SetActive( bActive ); + + aSet.Put( XFillColorItem( "", TRANSCOL ) ); + + if ( !bActive ) + { + aSet.Put( XFillTransparenceItem( 100 ) ); + aSet.Put( XLineColorItem( "", COL_RED ) ); + } + else + { + aSet.Put( XFillTransparenceItem( 50 ) ); + aSet.Put( XLineColorItem( "", COL_BLACK ) ); + } + + pView->SetAttributes( aSet ); + } +} + +void IMapWindow::UpdateInfo( bool bNewObj ) +{ + if ( aInfoLink.IsSet() ) + { + const SdrObject* pSdrObj = GetSelectedSdrObject(); + const IMapObject* pIMapObj = pSdrObj ? GetIMapObj( pSdrObj ) : nullptr; + + aInfo.bNewObj = bNewObj; + + if ( pIMapObj ) + { + aInfo.bOneMarked = true; + aInfo.aMarkURL = pIMapObj->GetURL(); + aInfo.aMarkAltText = pIMapObj->GetAltText(); + aInfo.aMarkTarget = pIMapObj->GetTarget(); + aInfo.bActivated = pIMapObj->IsActive(); + aInfoLink.Call( *this ); + } + else + { + aInfo.aMarkURL.clear(); + aInfo.aMarkAltText.clear(); + aInfo.aMarkTarget.clear(); + aInfo.bOneMarked = false; + aInfo.bActivated = false; + } + + aInfoLink.Call( *this ); + } +} + +void IMapWindow::DoMacroAssign() +{ + SdrObject* pSdrObj = GetSelectedSdrObject(); + + if ( !pSdrObj ) + return; + + SfxItemSet aSet( *pIMapPool, svl::Items<SID_ATTR_MACROITEM, SID_ATTR_MACROITEM, SID_EVENTCONFIG, SID_EVENTCONFIG>{} ); + + SfxEventNamesItem aNamesItem(SID_EVENTCONFIG); + aNamesItem.AddEvent( "MouseOver", "", SvMacroItemId::OnMouseOver ); + aNamesItem.AddEvent( "MouseOut", "", SvMacroItemId::OnMouseOut ); + aSet.Put( aNamesItem ); + + SvxMacroItem aMacroItem(SID_ATTR_MACROITEM); + IMapObject* pIMapObj = GetIMapObj( pSdrObj ); + aMacroItem.SetMacroTable( pIMapObj->GetMacroTable() ); + aSet.Put( aMacroItem ); + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<SfxAbstractDialog> pMacroDlg(pFact->CreateEventConfigDialog(GetDrawingArea(), aSet, mxDocumentFrame)); + + if ( pMacroDlg->Execute() == RET_OK ) + { + const SfxItemSet* pOutSet = pMacroDlg->GetOutputItemSet(); + pIMapObj->SetMacroTable( pOutSet->Get( SID_ATTR_MACROITEM ).GetMacroTable() ); + pModel->SetChanged(); + UpdateInfo( false ); + } +} + +void IMapWindow::DoPropertyDialog() +{ + SdrObject* pSdrObj = GetSelectedSdrObject(); + + if ( pSdrObj ) + { + IMapObject* pIMapObj = GetIMapObj( pSdrObj ); + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractURLDlg> aDlg(pFact->CreateURLDialog(GetDrawingArea(), pIMapObj->GetURL(), pIMapObj->GetAltText(), pIMapObj->GetDesc(), + pIMapObj->GetTarget(), pIMapObj->GetName(), aTargetList)); + if ( aDlg->Execute() == RET_OK ) + { + const OUString aURLText( aDlg->GetURL() ); + + if ( !aURLText.isEmpty() ) + { + INetURLObject aObj( aURLText, INetProtocol::File ); + DBG_ASSERT( aObj.GetProtocol() != INetProtocol::NotValid, "Invalid URL" ); + pIMapObj->SetURL( aObj.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); + } + else + pIMapObj->SetURL( aURLText ); + + pIMapObj->SetAltText( aDlg->GetAltText() ); + pIMapObj->SetDesc( aDlg->GetDesc() ); + pIMapObj->SetTarget( aDlg->GetTarget() ); + pIMapObj->SetName( aDlg->GetName() ); + pModel->SetChanged(); + UpdateInfo( true ); + } + } +} + +void IMapWindow::MenuSelectHdl(const OString& rId) +{ + if (rId == "url") + DoPropertyDialog(); + else if (rId == "macro") + DoMacroAssign(); + else if (rId == "active") + { + const bool bNewState = !mxPopupMenu->get_active(rId); + SetCurrentObjState(bNewState); + UpdateInfo( false ); + } + else if (rId == "front") + pView->PutMarkedToTop(); + else if (rId == "forward") + pView->MovMarkedToTop(); + else if (rId == "backward") + pView->MovMarkedToBtm(); + else if (rId == "back") + pView->PutMarkedToBtm(); + else if (rId == "selectall") + pView->MarkAll(); + else if (rId == "delete") + pView->DeleteMarked(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/imapwnd.hxx b/svx/source/dialog/imapwnd.hxx new file mode 100644 index 000000000..62a49188e --- /dev/null +++ b/svx/source/dialog/imapwnd.hxx @@ -0,0 +1,141 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_DIALOG_IMAPWND_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_IMAPWND_HXX + +#include <vcl/imapobj.hxx> +#include <vcl/transfer.hxx> +#include <vcl/imap.hxx> +#include <sfx2/frame.hxx> +#include <svx/graphctl.hxx> +#include <svl/itempool.hxx> + +#include <com/sun/star/frame/XFrame.hpp> + +struct NotifyInfo +{ + OUString aMarkURL; + OUString aMarkAltText; + OUString aMarkTarget; + bool bNewObj; + bool bOneMarked; + bool bActivated; +}; + + +#define SVD_IMAP_USERDATA 0x0001 + +typedef std::shared_ptr< IMapObject > IMapObjectPtr; + +class IMapUserData : public SdrObjUserData +{ + // #i98386# use std::shared_ptr here due to cloning possibilities + IMapObjectPtr mpObj; + +public: + + explicit IMapUserData( const IMapObjectPtr& rIMapObj ) : + SdrObjUserData ( SdrInventor::IMap, SVD_IMAP_USERDATA ), + mpObj ( rIMapObj ) {} + + IMapUserData( const IMapUserData& rIMapUserData ) : + SdrObjUserData ( SdrInventor::IMap, SVD_IMAP_USERDATA ), + mpObj ( rIMapUserData.mpObj ) {} + + virtual std::unique_ptr<SdrObjUserData> Clone( SdrObject * ) const override { return std::unique_ptr<SdrObjUserData>(new IMapUserData( *this )); } + + const IMapObjectPtr& GetObject() const { return mpObj; } + void ReplaceObject( const IMapObjectPtr& pNewIMapObject ) { mpObj = pNewIMapObject; } +}; + +class IMapWindow; + +class IMapDropTargetHelper final : public DropTargetHelper +{ + IMapWindow& m_rImapWindow; +public: + IMapDropTargetHelper(IMapWindow& rImapWindow); + + // DropTargetHelper + virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override; + virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override; +}; + +class IMapWindow final : public GraphCtrl +{ + NotifyInfo aInfo; + ImageMap aIMap; + TargetList aTargetList; + Link<IMapWindow&,void> aInfoLink; + SfxItemPool* pIMapPool; + SfxItemInfo maItemInfos[1] = {}; + css::uno::Reference< css::frame::XFrame > + mxDocumentFrame; + std::unique_ptr<IMapDropTargetHelper> mxDropTargetHelper; + std::unique_ptr<weld::Menu> mxPopupMenu; + + void MenuSelectHdl(const OString& rId); + + // GraphCtrl + virtual bool MouseButtonUp(const MouseEvent& rMEvt) override; + virtual void SetDrawingArea(weld::DrawingArea* pDrawingArea) override; + virtual bool Command(const CommandEvent& rCEvt) override; + virtual OUString RequestHelp(tools::Rectangle& rHelpArea) override; + virtual void SdrObjCreated( const SdrObject& rObj ) override; + virtual void SdrObjChanged( const SdrObject& rObj ) override; + virtual void MarkListHasChanged() override; + virtual void InitSdrModel() override; + + void ReplaceImageMap( const ImageMap& rNewImageMap ); + + SdrObject* CreateObj( const IMapObject* pIMapObj ); + static IMapObject* GetIMapObj( const SdrObject* pSdrObj ); + SdrObject* GetHitSdrObj( const Point& rPosPixel ) const; + + void UpdateInfo( bool bNewObj ); + +public: + + IMapWindow(const css::uno::Reference< css::frame::XFrame >& rxDocumentFrame, + weld::Dialog* pDialog); + virtual ~IMapWindow() override; + + sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ); + sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ); + + void ReplaceActualIMapInfo( const NotifyInfo& rNewInfo ); + + void SetImageMap( const ImageMap& rImageMap ); + const ImageMap& GetImageMap(); + + void SetCurrentObjState( bool bActive ); + void DoMacroAssign(); + void DoPropertyDialog(); + + void SetInfoLink( const Link<IMapWindow&,void>& rLink ) { aInfoLink = rLink; } + + void SetTargetList( TargetList& rTargetList ); + + const NotifyInfo& GetInfo() const { return aInfo; } +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/langbox.cxx b/svx/source/dialog/langbox.cxx new file mode 100644 index 000000000..5b7526d94 --- /dev/null +++ b/svx/source/dialog/langbox.cxx @@ -0,0 +1,503 @@ +/* -*- 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/linguistic2/XAvailableLocales.hpp> +#include <com/sun/star/linguistic2/XLinguServiceManager2.hpp> +#include <com/sun/star/linguistic2/XSpellChecker1.hpp> +#include <linguistic/misc.hxx> +#include <rtl/ustring.hxx> +#include <sal/log.hxx> +#include <unotools/localedatawrapper.hxx> +#include <tools/urlobj.hxx> +#include <svtools/langtab.hxx> +#include <i18nlangtag/mslangid.hxx> +#include <i18nlangtag/lang.h> +#include <editeng/unolingu.hxx> +#include <svl/languageoptions.hxx> +#include <svx/langbox.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <bitmaps.hlst> + +#include <comphelper/string.hxx> +#include <comphelper/processfactory.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> + +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::linguistic2; +using namespace ::com::sun::star::uno; + +OUString GetDicInfoStr( const OUString& rName, const LanguageType nLang, bool bNeg ) +{ + INetURLObject aURLObj; + aURLObj.SetSmartProtocol( INetProtocol::File ); + aURLObj.SetSmartURL( rName, INetURLObject::EncodeMechanism::All ); + OUString aTmp( aURLObj.GetBase() + " " ); + + if ( bNeg ) + { + aTmp += " (-) "; + } + + if ( LANGUAGE_NONE == nLang ) + aTmp += SvxResId(RID_SVXSTR_LANGUAGE_ALL); + else + { + aTmp += "[" + SvtLanguageTable::GetLanguageString( nLang ) + "]"; + } + + return aTmp; +} + +// misc local helper functions +static std::vector< LanguageType > lcl_LocaleSeqToLangSeq( Sequence< css::lang::Locale > const &rSeq ) +{ + sal_Int32 nCount = rSeq.getLength(); + + std::vector< LanguageType > aLangs; + aLangs.reserve(nCount); + + std::transform(rSeq.begin(), rSeq.end(), std::back_inserter(aLangs), + [](const css::lang::Locale& rLocale) -> LanguageType { + return LanguageTag::convertToLanguageType(rLocale); }); + + return aLangs; +} + +static bool lcl_SeqHasLang( const Sequence< sal_Int16 > & rLangSeq, sal_Int16 nLang ) +{ + return rLangSeq.hasElements() + && std::find(rLangSeq.begin(), rLangSeq.end(), nLang) != rLangSeq.end(); +} + +namespace { + +bool lcl_isPrerequisite( LanguageType nLangType ) +{ + return + nLangType != LANGUAGE_DONTKNOW && + nLangType != LANGUAGE_SYSTEM && + nLangType != LANGUAGE_NONE && + !MsLangId::isLegacy( nLangType) && + MsLangId::getSubLanguage( nLangType); +} + +bool lcl_isScriptTypeRequested( LanguageType nLangType, SvxLanguageListFlags nLangList ) +{ + return + bool(nLangList & SvxLanguageListFlags::ALL) || + (bool(nLangList & SvxLanguageListFlags::WESTERN) && + (SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType) == SvtScriptType::LATIN)) || + (bool(nLangList & SvxLanguageListFlags::CTL) && + (SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType) == SvtScriptType::COMPLEX)) || + (bool(nLangList & SvxLanguageListFlags::CJK) && + (SvtLanguageOptions::GetScriptTypeOfLanguage(nLangType) == SvtScriptType::ASIAN)); +} + +} + + +LanguageType SvxLanguageBox::get_active_id() const +{ + OUString sLang = m_xControl->get_active_id(); + if (!sLang.isEmpty()) + return LanguageType(sLang.toInt32()); + else + return LANGUAGE_DONTKNOW; +} + +int SvxLanguageBox::find_id(const LanguageType eLangType) const +{ + return m_xControl->find_id(OUString::number(static_cast<sal_uInt16>(eLangType))); +} + +void SvxLanguageBox::set_id(int pos, const LanguageType eLangType) +{ + m_xControl->set_id(pos, OUString::number(static_cast<sal_uInt16>(eLangType))); +} + +LanguageType SvxLanguageBox::get_id(int pos) const +{ + return LanguageType(m_xControl->get_id(pos).toInt32()); +} + +void SvxLanguageBox::remove_id(const LanguageType eLangType) +{ + m_xControl->remove_id(OUString::number(static_cast<sal_uInt16>(eLangType))); +} + +void SvxLanguageBox::append(const LanguageType eLangType, const OUString& rStr) +{ + m_xControl->append(OUString::number(static_cast<sal_uInt16>(eLangType)), rStr); +} + +void SvxLanguageBox::set_active_id(const LanguageType eLangType) +{ + // If the core uses a LangID of an imported MS document and wants to select + // a language that is replaced, we need to select the replacement instead. + LanguageType nLang = MsLangId::getReplacementForObsoleteLanguage( eLangType); + + sal_Int32 nAt = ImplTypeToPos( nLang ); + + if (nAt == -1) + { + InsertLanguage( nLang ); // on-the-fly-ID + nAt = ImplTypeToPos( nLang ); + } + + if (nAt != -1) + m_xControl->set_active(nAt); +} + +void SvxLanguageBox::AddLanguages(const std::vector< LanguageType >& rLanguageTypes, + SvxLanguageListFlags nLangList, std::vector<weld::ComboBoxEntry>& rEntries) +{ + for ( auto const & nLangType : rLanguageTypes ) + { + if (lcl_isPrerequisite( nLangType )) + { + LanguageType nLang = MsLangId::getReplacementForObsoleteLanguage( nLangType ); + if (lcl_isScriptTypeRequested( nLang, nLangList)) + { + int nAt = ImplTypeToPos(nLang); + if (nAt != -1) + continue; + weld::ComboBoxEntry aNewEntry(BuildEntry(nLang)); + if (aNewEntry.sString.isEmpty()) + continue; + if (std::find_if(rEntries.begin(), rEntries.end(), + [=](const weld::ComboBoxEntry& rEntry){ return rEntry.sId == aNewEntry.sId; }) != rEntries.end()) + continue; + rEntries.push_back(aNewEntry); + } + } + } +} + +void SvxLanguageBox::SetLanguageList(SvxLanguageListFlags nLangList, bool bHasLangNone, + bool bLangNoneIsLangAll, bool bCheckSpellAvail, + bool bDefaultLangExist, LanguageType eDefaultLangType, + sal_Int16 nDefaultType) +{ + m_bHasLangNone = bHasLangNone; + m_bLangNoneIsLangAll = bLangNoneIsLangAll; + m_bWithCheckmark = bCheckSpellAvail; + + if (SvxLanguageListFlags::EMPTY == nLangList) + { + m_xControl->clear(); + return; + } + + bool bAddAvailable = (!(nLangList & SvxLanguageListFlags::ONLY_KNOWN) && + ((nLangList & SvxLanguageListFlags::ALL) || + (nLangList & SvxLanguageListFlags::WESTERN) || + (nLangList & SvxLanguageListFlags::CTL) || + (nLangList & SvxLanguageListFlags::CJK))); + std::vector< LanguageType > aSpellAvailLang; + std::vector< LanguageType > aHyphAvailLang; + std::vector< LanguageType > aThesAvailLang; + Sequence< sal_Int16 > aSpellUsedLang; + Reference< XAvailableLocales > xAvail( LinguMgr::GetLngSvcMgr() ); + if (xAvail.is()) + { + Sequence< css::lang::Locale > aTmp; + + if (bAddAvailable) + { + aTmp = xAvail->getAvailableLocales( SN_SPELLCHECKER ); + aSpellAvailLang = lcl_LocaleSeqToLangSeq( aTmp ); + } + if (bAddAvailable) + { + aTmp = xAvail->getAvailableLocales( SN_HYPHENATOR ); + aHyphAvailLang = lcl_LocaleSeqToLangSeq( aTmp ); + } + if (bAddAvailable) + { + aTmp = xAvail->getAvailableLocales( SN_THESAURUS ); + aThesAvailLang = lcl_LocaleSeqToLangSeq( aTmp ); + } + } + if (SvxLanguageListFlags::SPELL_USED & nLangList) + { + Reference< XSpellChecker1 > xTmp1 = LinguMgr::GetSpellChecker(); + if (xTmp1.is()) + aSpellUsedLang = xTmp1->getLanguages(); + } + + std::vector<LanguageType> aKnown; + sal_uInt32 nCount; + if ( nLangList & SvxLanguageListFlags::ONLY_KNOWN ) + { + aKnown = LocaleDataWrapper::getInstalledLanguageTypes(); + nCount = aKnown.size(); + } + else + { + nCount = SvtLanguageTable::GetLanguageEntryCount(); + } + + std::vector<weld::ComboBoxEntry> aEntries; + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + LanguageType nLangType; + if ( nLangList & SvxLanguageListFlags::ONLY_KNOWN ) + nLangType = aKnown[i]; + else + nLangType = SvtLanguageTable::GetLanguageTypeAtIndex( i ); + if ( lcl_isPrerequisite( nLangType ) && + (lcl_isScriptTypeRequested( nLangType, nLangList) || + (bool(nLangList & SvxLanguageListFlags::FBD_CHARS) && + MsLangId::hasForbiddenCharacters(nLangType)) || + (bool(nLangList & SvxLanguageListFlags::SPELL_USED) && + lcl_SeqHasLang(aSpellUsedLang, static_cast<sal_uInt16>(nLangType))) + ) ) + { + aEntries.push_back(BuildEntry(nLangType)); + if (aEntries.back().sString.isEmpty()) + aEntries.pop_back(); + } + } + + if (bAddAvailable) + { + // Spell checkers, hyphenators and thesauri may add language tags + // unknown so far. + AddLanguages(aSpellAvailLang, nLangList, aEntries); + AddLanguages(aHyphAvailLang, nLangList, aEntries); + AddLanguages(aThesAvailLang, nLangList, aEntries); + } + + std::sort(aEntries.begin(), aEntries.end(), + [](const weld::ComboBoxEntry e1, const weld::ComboBoxEntry e2) { + static const auto aSorter = comphelper::string::NaturalStringSorter( + ::comphelper::getProcessComponentContext(), + Application::GetSettings().GetLanguageTag().getLocale()); + return aSorter.compare(e1.sString, e2.sString) < 0; + }); + + int nSeparatorPosition = 0; + if (bDefaultLangExist) + { + aEntries.insert(aEntries.begin(), BuildEntry(eDefaultLangType, nDefaultType)); + nSeparatorPosition++; + } + + if (bHasLangNone) + { + aEntries.insert(aEntries.begin(), BuildEntry(LANGUAGE_NONE)); + nSeparatorPosition++; + } + + m_xControl->insert_vector(aEntries, false); + if (nSeparatorPosition > 0) + m_xControl->insert_separator(nSeparatorPosition, ""); +} + +int SvxLanguageBox::ImplTypeToPos(LanguageType eType) const +{ + return m_xControl->find_id(OUString::number(static_cast<sal_uInt16>(eType))); +} + +void SvxLanguageBox::InsertLanguage(const LanguageType nLangType, sal_Int16 nType) +{ + weld::ComboBoxEntry aEntry = BuildEntry(nLangType, nType); + if (aEntry.sString.isEmpty()) + return; + if (aEntry.sImage.isEmpty()) + m_xControl->append(aEntry.sId, aEntry.sString); + else + m_xControl->append(aEntry.sId, aEntry.sString, aEntry.sImage); +} + +void SvxLanguageBox::InsertLanguage(const LanguageType nLangType) +{ + InsertLanguage(nLangType, css::i18n::ScriptType::WEAK); +} + +weld::ComboBoxEntry SvxLanguageBox::BuildEntry(const LanguageType nLangType, sal_Int16 nType) +{ + LanguageType nLang = MsLangId::getReplacementForObsoleteLanguage(nLangType); + // For obsolete and to be replaced languages check whether an entry of the + // replacement already exists and if so don't add an entry with identical + // string as would be returned by SvtLanguageTable::GetString(). + if (nLang != nLangType) + { + int nAt = ImplTypeToPos( nLang ); + if (nAt != -1) + return weld::ComboBoxEntry(""); + } + + OUString aStrEntry = SvtLanguageTable::GetLanguageString( nLang ); + if (LANGUAGE_NONE == nLang && m_bHasLangNone && m_bLangNoneIsLangAll) + aStrEntry = m_aAllString; + + LanguageType nRealLang = nLang; + if (nRealLang == LANGUAGE_SYSTEM) + { + nRealLang = MsLangId::resolveSystemLanguageByScriptType(nRealLang, nType); + aStrEntry += " - " + SvtLanguageTable::GetLanguageString( nRealLang ); + } + else if (nRealLang == LANGUAGE_USER_SYSTEM_CONFIG) + { + nRealLang = MsLangId::getSystemLanguage(); + aStrEntry += " - " + SvtLanguageTable::GetLanguageString( nRealLang ); + } + + if (m_bWithCheckmark) + { + if (!m_xSpellUsedLang) + { + Reference<XSpellChecker1> xSpell = LinguMgr::GetSpellChecker(); + if (xSpell.is()) + m_xSpellUsedLang.reset(new Sequence<sal_Int16>(xSpell->getLanguages())); + } + + bool bFound = m_xSpellUsedLang && lcl_SeqHasLang(*m_xSpellUsedLang, static_cast<sal_uInt16>(nRealLang)); + + return weld::ComboBoxEntry(aStrEntry, OUString::number(static_cast<sal_uInt16>(nLangType)), bFound ? OUString(RID_SVXBMP_CHECKED) : OUString(RID_SVXBMP_NOTCHECKED)); + } + else + return weld::ComboBoxEntry(aStrEntry, OUString::number(static_cast<sal_uInt16>(nLangType))); +} + +IMPL_LINK(SvxLanguageBox, ChangeHdl, weld::ComboBox&, rControl, void) +{ + if (rControl.has_entry()) + { + EditedAndValid eOldState = m_eEditedAndValid; + OUString aStr(rControl.get_active_text()); + if (aStr.isEmpty()) + m_eEditedAndValid = EditedAndValid::Invalid; + else + { + const int nPos = rControl.find_text(aStr); + if (nPos != -1) + { + int nStartSelectPos, nEndSelectPos; + rControl.get_entry_selection_bounds(nStartSelectPos, nEndSelectPos); + + // Select the corresponding listbox entry if not current. This + // invalidates the Edit Selection thus has to happen between + // obtaining the Selection and setting the new Selection. + int nSelPos = m_xControl->get_active(); + bool bSetEditSelection; + if (nSelPos == nPos) + bSetEditSelection = false; + else + { + m_xControl->set_active(nPos); + bSetEditSelection = true; + } + + // If typing into the Edit control led us here, advance start of a + // full selection by one so the next character will already + // continue the string instead of having to type the same character + // again to start a new string. The selection is in reverse + // when obtained from the Edit control. + if (nEndSelectPos == 0) + { + OUString aText(m_xControl->get_active_text()); + if (nStartSelectPos == aText.getLength()) + { + ++nEndSelectPos; + bSetEditSelection = true; + } + } + + if (bSetEditSelection) + rControl.select_entry_region(nStartSelectPos, nEndSelectPos); + + m_eEditedAndValid = EditedAndValid::No; + } + else + { + OUString aCanonicalized; + bool bValid = LanguageTag::isValidBcp47( aStr, &aCanonicalized, true); + m_eEditedAndValid = (bValid ? EditedAndValid::Valid : EditedAndValid::Invalid); + if (bValid && aCanonicalized != aStr) + { + m_xControl->set_entry_text(aCanonicalized); + const auto nCursorPos = aCanonicalized.getLength(); + m_xControl->select_entry_region(nCursorPos, nCursorPos); + } + } + } + if (eOldState != m_eEditedAndValid) + { + if (m_eEditedAndValid == EditedAndValid::Invalid) + rControl.set_entry_message_type(weld::EntryMessageType::Error); + else + rControl.set_entry_message_type(weld::EntryMessageType::Normal); + } + } + m_aChangeHdl.Call(rControl); +} + +SvxLanguageBox::SvxLanguageBox(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) + , m_aAllString(SvxResId(RID_SVXSTR_LANGUAGE_ALL)) + , m_eSavedLanguage(LANGUAGE_DONTKNOW) + , m_eEditedAndValid(EditedAndValid::No) + , m_bHasLangNone(false) + , m_bLangNoneIsLangAll(false) + , m_bWithCheckmark(false) +{ + m_xControl->connect_changed(LINK(this, SvxLanguageBox, ChangeHdl)); +} + +sal_Int32 SvxLanguageBox::SaveEditedAsEntry() +{ + if (m_eEditedAndValid != EditedAndValid::Valid) + return -1; + + LanguageTag aLanguageTag(m_xControl->get_active_text()); + LanguageType nLang = aLanguageTag.getLanguageType(); + if (nLang == LANGUAGE_DONTKNOW) + { + SAL_WARN( "svx.dialog", "SvxLanguageComboBox::SaveEditedAsEntry: unknown tag"); + return -1; + } + + int nPos = ImplTypeToPos( nLang); + if (nPos != -1) + return nPos; // Already present but with a different string. + + if (SvtLanguageTable::HasLanguageType( nLang)) + { + // In SvtLanguageTable but not in SvxLanguageComboBox. On purpose? This + // may be an entry with different settings or CTL instead of Western or + // ... all things we don't handle yet. + SAL_WARN( "svx.dialog", "SvxLanguageComboBox::SaveEditedAsEntry: already in SvtLanguageTable: " << + SvtLanguageTable::GetLanguageString( nLang) << ", " << nLang); + } + else + { + // Add to both, SvtLanguageTable and SvxLanguageComboBox. + /* TODO: a descriptive user comment would be a nice to have here. */ + SvtLanguageTable::AddLanguageTag( aLanguageTag ); + } + + InsertLanguage(nLang); + return ImplTypeToPos(nLang); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/linkwarn.cxx b/svx/source/dialog/linkwarn.cxx new file mode 100644 index 000000000..7df6f472f --- /dev/null +++ b/svx/source/dialog/linkwarn.cxx @@ -0,0 +1,57 @@ +/* -*- 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 <osl/file.hxx> +#include <svx/linkwarn.hxx> +#include <svtools/miscopt.hxx> + +SvxLinkWarningDialog::SvxLinkWarningDialog(weld::Widget* pParent, const OUString& _rFileName) + : MessageDialogController(pParent, "svx/ui/linkwarndialog.ui", "LinkWarnDialog", "ask") + , m_xWarningOnBox(m_xBuilder->weld_check_button("ask")) +{ + // replace filename + OUString sInfoText = m_xDialog->get_primary_text(); + OUString aPath; + if (osl::FileBase::E_None != osl::FileBase::getSystemPathFromFileURL(_rFileName, aPath)) + aPath = _rFileName; + sInfoText = sInfoText.replaceAll("%FILENAME", aPath); + m_xDialog->set_primary_text(sInfoText); + + // load state of "warning on" checkbox from misc options + SvtMiscOptions aMiscOpt; + m_xWarningOnBox->set_active(aMiscOpt.ShowLinkWarningDialog()); + m_xWarningOnBox->set_sensitive(!aMiscOpt.IsShowLinkWarningDialogReadOnly()); +} + +SvxLinkWarningDialog::~SvxLinkWarningDialog() +{ + try + { + // save value of "warning off" checkbox, if necessary + SvtMiscOptions aMiscOpt; + bool bChecked = m_xWarningOnBox->get_active(); + if (aMiscOpt.ShowLinkWarningDialog() != bChecked) + aMiscOpt.SetShowLinkWarningDialog(bChecked); + } + catch (...) + { + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/measctrl.cxx b/svx/source/dialog/measctrl.cxx new file mode 100644 index 000000000..fd237aea3 --- /dev/null +++ b/svx/source/dialog/measctrl.cxx @@ -0,0 +1,157 @@ +/* -*- 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/dialoghelper.hxx> +#include <svx/svdomeas.hxx> +#include <svx/svdmodel.hxx> +#include <svx/measctrl.hxx> +#include <svx/dlgutil.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <memory> + +SvxXMeasurePreview::SvxXMeasurePreview() + : m_aMapMode(MapUnit::Map100thMM) +{ + // Scale: 1:2 + m_aMapMode.SetScaleX(Fraction(1, 2)); + m_aMapMode.SetScaleY(Fraction(1, 2)); +} + +void SvxXMeasurePreview::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aSize(getPreviewStripSize(pDrawingArea->get_ref_device())); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + + pModel.reset(new SdrModel(nullptr, nullptr, true)); + pMeasureObj.reset(new SdrMeasureObj(*pModel, Point(), Point())); + + ResizeImpl(aSize); + Invalidate(); +} + +void SvxXMeasurePreview::ResizeImpl(const Size& rSize) +{ + OutputDevice& rRefDevice = GetDrawingArea()->get_ref_device(); + rRefDevice.Push(PushFlags::MAPMODE); + + rRefDevice.SetMapMode(m_aMapMode); + + Size aSize = rRefDevice.PixelToLogic(rSize); + Point aPt1(aSize.Width() / 5, static_cast<long>(aSize.Height() / 2)); + pMeasureObj->SetPoint(aPt1, 0); + Point aPt2(aSize.Width() * 4 / 5, static_cast<long>(aSize.Height() / 2)); + pMeasureObj->SetPoint(aPt2, 1); + + rRefDevice.Pop(); +} + +void SvxXMeasurePreview::Resize() +{ + CustomWidgetController::Resize(); + ResizeImpl(GetOutputSizePixel()); + Invalidate(); +} + +SvxXMeasurePreview::~SvxXMeasurePreview() +{ +} + +void SvxXMeasurePreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.SetBackground(rRenderContext.GetSettings().GetStyleSettings().GetWindowColor()); + rRenderContext.Erase(); + + rRenderContext.Push(PushFlags::MAPMODE); + rRenderContext.SetMapMode(m_aMapMode); + + bool bHighContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode(); + rRenderContext.SetDrawMode(bHighContrast ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR); + pMeasureObj->SingleObjectPainter(rRenderContext); + + rRenderContext.Pop(); +} + +void SvxXMeasurePreview::SetAttributes(const SfxItemSet& rInAttrs) +{ + pMeasureObj->SetMergedItemSetAndBroadcast(rInAttrs); + + Invalidate(); +} + +bool SvxXMeasurePreview::MouseButtonDown(const MouseEvent& rMEvt) +{ + bool bZoomIn = rMEvt.IsLeft() && !rMEvt.IsShift(); + bool bZoomOut = rMEvt.IsRight() || rMEvt.IsShift(); + bool bCtrl = rMEvt.IsMod1(); + + if (bZoomIn || bZoomOut) + { + Fraction aXFrac = m_aMapMode.GetScaleX(); + Fraction aYFrac = m_aMapMode.GetScaleY(); + std::unique_ptr<Fraction> pMultFrac; + + if (bZoomIn) + { + if (bCtrl) + pMultFrac.reset(new Fraction(3, 2)); + else + pMultFrac.reset(new Fraction(11, 10)); + } + else + { + if (bCtrl) + pMultFrac.reset(new Fraction(2, 3)); + else + pMultFrac.reset(new Fraction(10, 11)); + } + + aXFrac *= *pMultFrac; + aYFrac *= *pMultFrac; + + if (double(aXFrac) > 0.001 && double(aXFrac) < 1000.0 && + double(aYFrac) > 0.001 && double(aYFrac) < 1000.0) + { + m_aMapMode.SetScaleX(aXFrac); + m_aMapMode.SetScaleY(aYFrac); + + OutputDevice& rRefDevice = GetDrawingArea()->get_ref_device(); + rRefDevice.Push(PushFlags::MAPMODE); + rRefDevice.SetMapMode(m_aMapMode); + Size aOutSize(rRefDevice.PixelToLogic(GetOutputSizePixel())); + rRefDevice.Pop(); + + Point aPt(m_aMapMode.GetOrigin()); + long nX = long((double(aOutSize.Width()) - (double(aOutSize.Width()) * double(*pMultFrac))) / 2.0 + 0.5); + long nY = long((double(aOutSize.Height()) - (double(aOutSize.Height()) * double(*pMultFrac))) / 2.0 + 0.5); + aPt.AdjustX(nX ); + aPt.AdjustY(nY ); + + m_aMapMode.SetOrigin(aPt); + + Invalidate(); + } + } + + return true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/optgrid.cxx b/svx/source/dialog/optgrid.cxx new file mode 100644 index 000000000..9cf4926bf --- /dev/null +++ b/svx/source/dialog/optgrid.cxx @@ -0,0 +1,289 @@ +/* -*- 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 <svl/intitem.hxx> +#include <svtools/unitconv.hxx> + +#include <svx/svxids.hrc> +#include <svx/optgrid.hxx> +#include <svx/dlgutil.hxx> + +// local functions +static void lcl_GetMinMax(weld::MetricSpinButton const& rField, int& nMin, int& nMax) +{ + rField.get_range(nMin, nMax, FieldUnit::TWIP); + nMin = rField.denormalize(nMin); + nMax = rField.denormalize(nMax); +} + +static void lcl_SetMinMax(weld::MetricSpinButton& rField, int nMin, int nMax) +{ + rField.set_range(rField.normalize(nMin), rField.normalize(nMax), FieldUnit::TWIP); +} + +SvxOptionsGrid::SvxOptionsGrid() : + nFldDrawX ( 100 ), + nFldDivisionX ( 0 ), + nFldDrawY ( 100 ), + nFldDivisionY ( 0 ), + nFldSnapX ( 100 ), + nFldSnapY ( 100 ), + bUseGridsnap ( false ), + bSynchronize ( true ), + bGridVisible ( false ), + bEqualGrid ( true ) +{ +} + +SvxGridItem* SvxGridItem::Clone( SfxItemPool* ) const +{ + return new SvxGridItem( *this ); +} + +bool SvxGridItem::operator==( const SfxPoolItem& rAttr ) const +{ + assert(SfxPoolItem::operator==(rAttr)); + + const SvxGridItem& rItem = static_cast<const SvxGridItem&>(rAttr); + + return ( bUseGridsnap == rItem.bUseGridsnap && + bSynchronize == rItem.bSynchronize && + bGridVisible == rItem.bGridVisible && + bEqualGrid == rItem.bEqualGrid && + nFldDrawX == rItem.nFldDrawX && + nFldDivisionX== rItem.nFldDivisionX&& + nFldDrawY == rItem.nFldDrawY && + nFldDivisionY== rItem.nFldDivisionY&& + nFldSnapX == rItem.nFldSnapX && + nFldSnapY == rItem.nFldSnapY ); +} + +bool SvxGridItem::GetPresentation +( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& rText, const IntlWrapper& +) const +{ + rText = "SvxGridItem"; + return true; +} + +// TabPage Screen Settings +SvxGridTabPage::SvxGridTabPage(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rCoreSet) + : SfxTabPage(pPage, pController, "svx/ui/optgridpage.ui", "OptGridPage", &rCoreSet) + , bAttrModified(false) + , m_xCbxUseGridsnap(m_xBuilder->weld_check_button("usegridsnap")) + , m_xCbxGridVisible(m_xBuilder->weld_check_button("gridvisible")) + , m_xMtrFldDrawX(m_xBuilder->weld_metric_spin_button("mtrflddrawx", FieldUnit::CM)) + , m_xMtrFldDrawY(m_xBuilder->weld_metric_spin_button("mtrflddrawy", FieldUnit::CM)) + , m_xNumFldDivisionX(m_xBuilder->weld_spin_button("numflddivisionx")) + , m_xNumFldDivisionY(m_xBuilder->weld_spin_button("numflddivisiony")) + , m_xCbxSynchronize(m_xBuilder->weld_check_button("synchronize")) + , m_xSnapFrames(m_xBuilder->weld_widget("snapframes")) + , m_xCbxSnapHelplines(m_xBuilder->weld_check_button("snaphelplines")) + , m_xCbxSnapBorder(m_xBuilder->weld_check_button("snapborder")) + , m_xCbxSnapFrame(m_xBuilder->weld_check_button("snapframe")) + , m_xCbxSnapPoints(m_xBuilder->weld_check_button("snappoints")) + , m_xMtrFldSnapArea(m_xBuilder->weld_metric_spin_button("mtrfldsnaparea", FieldUnit::PIXEL)) + , m_xCbxOrtho(m_xBuilder->weld_check_button("ortho")) + , m_xCbxBigOrtho(m_xBuilder->weld_check_button("bigortho")) + , m_xCbxRotate(m_xBuilder->weld_check_button("rotate")) + , m_xMtrFldAngle(m_xBuilder->weld_metric_spin_button("mtrfldangle", FieldUnit::DEGREE)) + , m_xMtrFldBezAngle(m_xBuilder->weld_metric_spin_button("mtrfldbezangle", FieldUnit::DEGREE)) +{ + // This page requires exchange Support + SetExchangeSupport(); + + // Set Metrics + FieldUnit eFUnit = GetModuleFieldUnit( rCoreSet ); + int nMin, nMax; + + lcl_GetMinMax(*m_xMtrFldDrawX, nMin, nMax); + SetFieldUnit( *m_xMtrFldDrawX, eFUnit, true ); + lcl_SetMinMax(*m_xMtrFldDrawX, nMin, nMax); + + lcl_GetMinMax(*m_xMtrFldDrawY, nMin, nMax); + SetFieldUnit( *m_xMtrFldDrawY, eFUnit, true ); + lcl_SetMinMax(*m_xMtrFldDrawY, nMin, nMax); + + + m_xCbxRotate->connect_toggled(LINK(this, SvxGridTabPage, ClickRotateHdl_Impl)); + Link<weld::ToggleButton&,void> aLink = LINK(this, SvxGridTabPage, ChangeGridsnapHdl_Impl); + m_xCbxUseGridsnap->connect_toggled(aLink); + m_xCbxSynchronize->connect_toggled(aLink); + m_xCbxGridVisible->connect_toggled(aLink); + m_xMtrFldDrawX->connect_value_changed( + LINK( this, SvxGridTabPage, ChangeDrawHdl_Impl ) ); + m_xMtrFldDrawY->connect_value_changed( + LINK( this, SvxGridTabPage, ChangeDrawHdl_Impl ) ); + m_xNumFldDivisionX->connect_value_changed( + LINK( this, SvxGridTabPage, ChangeDivisionHdl_Impl ) ); + m_xNumFldDivisionY->connect_value_changed( + LINK( this, SvxGridTabPage, ChangeDivisionHdl_Impl ) ); +} + +SvxGridTabPage::~SvxGridTabPage() +{ +} + +std::unique_ptr<SfxTabPage> SvxGridTabPage::Create(weld::Container* pPage, weld::DialogController* pController, const SfxItemSet& rAttrSet) +{ + return std::make_unique<SvxGridTabPage>(pPage, pController, rAttrSet); +} + +bool SvxGridTabPage::FillItemSet( SfxItemSet* rCoreSet ) +{ + if ( bAttrModified ) + { + SvxGridItem aGridItem( SID_ATTR_GRID_OPTIONS ); + + aGridItem.bUseGridsnap = m_xCbxUseGridsnap->get_active(); + aGridItem.bSynchronize = m_xCbxSynchronize->get_active(); + aGridItem.bGridVisible = m_xCbxGridVisible->get_active(); + + MapUnit eUnit = + rCoreSet->GetPool()->GetMetric( GetWhich( SID_ATTR_GRID_OPTIONS ) ); + long nX = GetCoreValue( *m_xMtrFldDrawX, eUnit ); + long nY = GetCoreValue( *m_xMtrFldDrawY, eUnit ); + + aGridItem.nFldDrawX = static_cast<sal_uInt32>(nX); + aGridItem.nFldDrawY = static_cast<sal_uInt32>(nY); + aGridItem.nFldDivisionX = static_cast<long>(m_xNumFldDivisionX->get_value() - 1); + aGridItem.nFldDivisionY = static_cast<long>(m_xNumFldDivisionY->get_value() - 1); + + rCoreSet->Put( aGridItem ); + } + return bAttrModified; +} + +void SvxGridTabPage::Reset( const SfxItemSet* rSet ) +{ + const SfxPoolItem* pAttr = nullptr; + + if( SfxItemState::SET == rSet->GetItemState( SID_ATTR_GRID_OPTIONS , false, + &pAttr )) + { + const SvxGridItem* pGridAttr = static_cast<const SvxGridItem*>(pAttr); + m_xCbxUseGridsnap->set_active(pGridAttr->bUseGridsnap); + m_xCbxSynchronize->set_active(pGridAttr->bSynchronize); + m_xCbxGridVisible->set_active(pGridAttr->bGridVisible); + + MapUnit eUnit = + rSet->GetPool()->GetMetric( GetWhich( SID_ATTR_GRID_OPTIONS ) ); + SetMetricValue( *m_xMtrFldDrawX , pGridAttr->nFldDrawX, eUnit ); + SetMetricValue( *m_xMtrFldDrawY , pGridAttr->nFldDrawY, eUnit ); + + m_xNumFldDivisionX->set_value(pGridAttr->nFldDivisionX + 1); + m_xNumFldDivisionY->set_value(pGridAttr->nFldDivisionY + 1); + } + + ChangeGridsnapHdl_Impl(*m_xCbxUseGridsnap); + bAttrModified = false; +} + +void SvxGridTabPage::ActivatePage( const SfxItemSet& rSet ) +{ + const SfxPoolItem* pAttr = nullptr; + if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_GRID_OPTIONS , false, + &pAttr )) + { + const SvxGridItem* pGridAttr = static_cast<const SvxGridItem*>(pAttr); + m_xCbxUseGridsnap->set_active(pGridAttr->bUseGridsnap); + + ChangeGridsnapHdl_Impl(*m_xCbxUseGridsnap); + } + + // Metric Change if necessary (as TabPage is in the dialog, where the + // metric can be set + if( SfxItemState::SET == rSet.GetItemState( SID_ATTR_METRIC , false, + &pAttr )) + { + const SfxUInt16Item* pItem = static_cast<const SfxUInt16Item*>(pAttr); + + FieldUnit eFUnit = static_cast<FieldUnit>(static_cast<long>(pItem->GetValue())); + + if (eFUnit != m_xMtrFldDrawX->get_unit()) + { + // Set Metrics + int nMin, nMax; + int nVal = m_xMtrFldDrawX->denormalize(m_xMtrFldDrawX->get_value(FieldUnit::TWIP)); + + lcl_GetMinMax(*m_xMtrFldDrawX, nMin, nMax); + SetFieldUnit(*m_xMtrFldDrawX, eFUnit, true); + lcl_SetMinMax(*m_xMtrFldDrawX, nMin, nMax); + + m_xMtrFldDrawX->set_value(m_xMtrFldDrawX->normalize(nVal), FieldUnit::TWIP); + + nVal = m_xMtrFldDrawY->denormalize(m_xMtrFldDrawY->get_value(FieldUnit::TWIP)); + lcl_GetMinMax(*m_xMtrFldDrawY, nMin, nMax); + SetFieldUnit(*m_xMtrFldDrawY, eFUnit, true); + lcl_SetMinMax(*m_xMtrFldDrawY, nMin, nMax); + m_xMtrFldDrawY->set_value(m_xMtrFldDrawY->normalize(nVal), FieldUnit::TWIP); + + } + } +} + +DeactivateRC SvxGridTabPage::DeactivatePage( SfxItemSet* _pSet ) +{ + if ( _pSet ) + FillItemSet( _pSet ); + return DeactivateRC::LeavePage; +} + +IMPL_LINK(SvxGridTabPage, ChangeDrawHdl_Impl, weld::MetricSpinButton&, rField, void) +{ + bAttrModified = true; + if (m_xCbxSynchronize->get_active()) + { + if (&rField == m_xMtrFldDrawX.get()) + m_xMtrFldDrawY->set_value(m_xMtrFldDrawX->get_value(FieldUnit::NONE), FieldUnit::NONE); + else + m_xMtrFldDrawX->set_value(m_xMtrFldDrawY->get_value(FieldUnit::NONE), FieldUnit::NONE); + } +} + +IMPL_LINK_NOARG(SvxGridTabPage, ClickRotateHdl_Impl, weld::ToggleButton&, void) +{ + if (m_xCbxRotate->get_active()) + m_xMtrFldAngle->set_sensitive(true); + else + m_xMtrFldAngle->set_sensitive(false); +} + +IMPL_LINK(SvxGridTabPage, ChangeDivisionHdl_Impl, weld::SpinButton&, rField, void) +{ + bAttrModified = true; + if (m_xCbxSynchronize->get_active()) + { + if (m_xNumFldDivisionX.get() == &rField) + m_xNumFldDivisionY->set_value(m_xNumFldDivisionX->get_value()); + else + m_xNumFldDivisionX->set_value(m_xNumFldDivisionY->get_value()); + } +} + +IMPL_LINK_NOARG(SvxGridTabPage, ChangeGridsnapHdl_Impl, weld::ToggleButton&, void) +{ + bAttrModified = true; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/page.hrc b/svx/source/dialog/page.hrc new file mode 100644 index 000000000..6dc8e72f0 --- /dev/null +++ b/svx/source/dialog/page.hrc @@ -0,0 +1,99 @@ +/* -*- 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 . + */ + +#ifndef INCLUDED_SVX_SOURCE_DIALOG_PAGE_HRC +#define INCLUDED_SVX_SOURCE_DIALOG_PAGE_HRC + +#include <i18nutil/paper.hxx> +#include <utility> + +#define NC_(Context, String) reinterpret_cast<char const *>(Context "\004" u8##String) + +const std::pair<const char*, int> RID_SVXSTRARY_PAPERSIZE_STD[] = +{ + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "A6") , PAPER_A6 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "A5") , PAPER_A5 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "A4") , PAPER_A4 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "A3") , PAPER_A3 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "B6 (ISO)") , PAPER_B6_ISO }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "B5 (ISO)") , PAPER_B5_ISO }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "B4 (ISO)") , PAPER_B4_ISO }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "Letter") , PAPER_LETTER }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "Legal") , PAPER_LEGAL }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "Long Bond") , PAPER_FANFOLD_LEGAL_DE }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "Tabloid") , PAPER_TABLOID }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "B6 (JIS)") , PAPER_B6_JIS }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "B5 (JIS)") , PAPER_B5_JIS }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "B4 (JIS)") , PAPER_B4_JIS }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "16 Kai") , PAPER_KAI16}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "32 Kai") , PAPER_KAI32}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "Big 32 Kai") , PAPER_KAI32BIG}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "User") , PAPER_USER }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "DL Envelope") , PAPER_ENV_DL }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "C6 Envelope") , PAPER_ENV_C6 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "C6/5 Envelope") , PAPER_ENV_C65 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "C5 Envelope") , PAPER_ENV_C5 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "C4 Envelope") , PAPER_ENV_C4 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "#6¾ Envelope") , PAPER_ENV_PERSONAL}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "#7¾ (Monarch) Envelope") , PAPER_ENV_MONARCH}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "#9 Envelope") , PAPER_ENV_9}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "#10 Envelope") , PAPER_ENV_10}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "#11 Envelope") , PAPER_ENV_11}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "#12 Envelope") , PAPER_ENV_12}, + { NC_("RID_SVXSTRARY_PAPERSIZE_STD", "Japanese Postcard") , PAPER_POSTCARD_JP} +}; + +const std::pair<const char*, int> RID_SVXSTRARY_PAPERSIZE_DRAW[] = +{ + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A6") , PAPER_A6 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A5") , PAPER_A5 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A4") , PAPER_A4 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A3") , PAPER_A3 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A2") , PAPER_A2 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A1") , PAPER_A1 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "A0") , PAPER_A0 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "B6 (ISO)") , PAPER_B6_ISO }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "B5 (ISO)") , PAPER_B5_ISO }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "B4 (ISO)") , PAPER_B4_ISO }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Letter") , PAPER_LETTER }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Legal") , PAPER_LEGAL }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Long Bond") , PAPER_FANFOLD_LEGAL_DE }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Tabloid") , PAPER_TABLOID }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "B6 (JIS)") , PAPER_B6_JIS }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "B5 (JIS)") , PAPER_B5_JIS }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "B4 (JIS)") , PAPER_B4_JIS }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "16 Kai") , PAPER_KAI16}, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "32 Kai") , PAPER_KAI32}, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Big 32 Kai") , PAPER_KAI32BIG}, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "User") , PAPER_USER }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "DL Envelope") , PAPER_ENV_DL }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "C6 Envelope") , PAPER_ENV_C6 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "C6/5 Envelope") , PAPER_ENV_C65 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "C5 Envelope") , PAPER_ENV_C5 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "C4 Envelope") , PAPER_ENV_C4 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Dia Slide") , PAPER_SLIDE_DIA }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Screen 4:3") , PAPER_SCREEN_4_3 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Screen 16:9") , PAPER_SCREEN_16_9 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Screen 16:10") , PAPER_SCREEN_16_10 }, + { NC_("RID_SVXSTRARY_PAPERSIZE_DRAW", "Japanese Postcard") , PAPER_POSTCARD_JP} +}; + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/pagectrl.cxx b/svx/source/dialog/pagectrl.cxx new file mode 100644 index 000000000..f7eae17db --- /dev/null +++ b/svx/source/dialog/pagectrl.cxx @@ -0,0 +1,406 @@ +/* -*- 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/frmdir.hxx> +#include <vcl/canvastools.hxx> +#include <vcl/outdev.hxx> +#include <vcl/settings.hxx> +#include <tools/fract.hxx> +#include <svx/pageitem.hxx> +#include <svx/pagectrl.hxx> +#include <algorithm> +#include <basegfx/matrix/b2dhommatrix.hxx> +#include <drawinglayer/geometry/viewinformation2d.hxx> +#include <drawinglayer/processor2d/baseprocessor2d.hxx> +#include <drawinglayer/processor2d/processor2dtools.hxx> +#include <drawinglayer/primitive2d/polygonprimitive2d.hxx> +#include <basegfx/polygon/b2dpolygontools.hxx> + +#define CELL_WIDTH 1600L +#define CELL_HEIGHT 800L + +SvxPageWindow::SvxPageWindow() : + aWinSize(), + aSize(), + nTop(0), + nBottom(0), + nLeft(0), + nRight(0), + bResetBackground(false), + bFrameDirection(false), + nFrameDirection(SvxFrameDirection::Horizontal_LR_TB), + nHdLeft(0), + nHdRight(0), + nHdDist(0), + nHdHeight(0), + nFtLeft(0), + nFtRight(0), + nFtDist(0), + nFtHeight(0), + maHeaderFillAttributes(), + maFooterFillAttributes(), + maPageFillAttributes(), + bFooter(false), + bHeader(false), + bTable(false), + bHorz(false), + bVert(false), + eUsage(SvxPageUsage::All) +{ +} + +SvxPageWindow::~SvxPageWindow() +{ +} + +void SvxPageWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.Push(PushFlags::MAPMODE); + rRenderContext.SetMapMode(MapMode(MapUnit::MapTwip)); + + Fraction aXScale(aWinSize.Width(), std::max(long(aSize.Width() * 2 + aSize.Width() / 8), 1L)); + Fraction aYScale(aWinSize.Height(), std::max(aSize.Height(), 1L)); + MapMode aMapMode(rRenderContext.GetMapMode()); + + if(aYScale < aXScale) + { + aMapMode.SetScaleX(aYScale); + aMapMode.SetScaleY(aYScale); + } + else + { + aMapMode.SetScaleX(aXScale); + aMapMode.SetScaleY(aXScale); + } + rRenderContext.SetMapMode(aMapMode); + Size aSz(rRenderContext.PixelToLogic(GetOutputSizePixel())); + long nYPos = (aSz.Height() - aSize.Height()) / 2; + + if (eUsage == SvxPageUsage::All) + { + // all pages are equal -> draw one page + if (aSize.Width() > aSize.Height()) + { + // Draw Landscape page of the same size + Fraction aX = aMapMode.GetScaleX(); + Fraction aY = aMapMode.GetScaleY(); + Fraction a2(1.5); + aX *= a2; + aY *= a2; + aMapMode.SetScaleX(aX); + aMapMode.SetScaleY(aY); + rRenderContext.SetMapMode(aMapMode); + aSz = rRenderContext.PixelToLogic(GetOutputSizePixel()); + nYPos = (aSz.Height() - aSize.Height()) / 2; + long nXPos = (aSz.Width() - aSize.Width()) / 2; + DrawPage(rRenderContext, Point(nXPos,nYPos),true,true); + } + else + // Portrait + DrawPage(rRenderContext, Point((aSz.Width() - aSize.Width()) / 2,nYPos),true,true); + } + else + { + // Left and right page are different -> draw two pages if possible + DrawPage(rRenderContext, Point(0, nYPos), false, + eUsage == SvxPageUsage::Left || eUsage == SvxPageUsage::All || eUsage == SvxPageUsage::Mirror); + DrawPage(rRenderContext, Point(aSize.Width() + aSize.Width() / 8, nYPos), true, + eUsage == SvxPageUsage::Right || eUsage == SvxPageUsage::All || eUsage == SvxPageUsage::Mirror); + } + rRenderContext.Pop(); +} + +void SvxPageWindow::DrawPage(vcl::RenderContext& rRenderContext, const Point& rOrg, const bool bSecond, const bool bEnabled) +{ + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + const Color& rFieldColor = rStyleSettings.GetFieldColor(); + const Color& rFieldTextColor = rStyleSettings.GetFieldTextColor(); + const Color& rDisableColor = rStyleSettings.GetDisableColor(); + const Color& rDlgColor = rStyleSettings.GetDialogColor(); + + // background + if (!bSecond || bResetBackground) + { + rRenderContext.SetLineColor(COL_TRANSPARENT); + rRenderContext.SetFillColor(rDlgColor); + Size winSize(rRenderContext.GetOutputSize()); + rRenderContext.DrawRect(tools::Rectangle(Point(0,0), winSize)); + + if (bResetBackground) + bResetBackground = false; + } + rRenderContext.SetLineColor(rFieldTextColor); + + // Shadow + Size aTempSize = aSize; + + // Page + if (!bEnabled) + { + rRenderContext.SetFillColor(rDisableColor); + rRenderContext.DrawRect(tools::Rectangle(rOrg, aTempSize)); + return; + } + rRenderContext.SetFillColor(rFieldColor); + rRenderContext.DrawRect(tools::Rectangle(rOrg, aTempSize)); + + long nL = nLeft; + long nR = nRight; + + if (eUsage == SvxPageUsage::Mirror && !bSecond) + { + // turn for mirrored + nL = nRight; + nR = nLeft; + } + + tools::Rectangle aRect; + + aRect.SetLeft( rOrg.X() + nL ); + aRect.SetRight( rOrg.X() + aTempSize.Width() - nR ); + aRect.SetTop( rOrg.Y() + nTop ); + aRect.SetBottom( rOrg.Y() + aTempSize.Height() - nBottom ); + + tools::Rectangle aHdRect(aRect); + tools::Rectangle aFtRect(aRect); + + if (bHeader || bFooter) + { + // Header and/or footer used + const Color aLineColor(rRenderContext.GetLineColor()); + + // draw PageFill first and on the whole page, no outline + rRenderContext.SetLineColor(); + drawFillAttributes(rRenderContext, maPageFillAttributes, aRect, aRect); + rRenderContext.SetLineColor(aLineColor); + + if (bHeader) + { + // show headers if possible + aHdRect.AdjustLeft(nHdLeft ); + aHdRect.AdjustRight( -nHdRight ); + aHdRect.SetBottom( aRect.Top() + nHdHeight ); + aRect.AdjustTop(nHdHeight + nHdDist ); + + // draw header over PageFill, plus outline + drawFillAttributes(rRenderContext, maHeaderFillAttributes, aHdRect, aHdRect); + } + + if (bFooter) + { + // show footer if possible + aFtRect.AdjustLeft(nFtLeft ); + aFtRect.AdjustRight( -nFtRight ); + aFtRect.SetTop( aRect.Bottom() - nFtHeight ); + aRect.AdjustBottom( -(nFtHeight + nFtDist) ); + + // draw footer over PageFill, plus outline + drawFillAttributes(rRenderContext, maFooterFillAttributes, aFtRect, aFtRect); + } + + // draw page's reduced outline, only outline + drawFillAttributes(rRenderContext, drawinglayer::attribute::SdrAllFillAttributesHelperPtr(), aRect, aRect); + } + else + { + // draw PageFill and outline + drawFillAttributes(rRenderContext, maPageFillAttributes, aRect, aRect); + } + + if (bFrameDirection && !bTable) + { + Point aPos; + vcl::Font aFont(rRenderContext.GetFont()); + const Size aSaveSize = aFont.GetFontSize(); + Size aDrawSize(0,aRect.GetHeight() / 6); + aFont.SetFontSize(aDrawSize); + rRenderContext.SetFont(aFont); + OUString sText("ABC"); + Point aMove(1, rRenderContext.GetTextHeight()); + sal_Unicode cArrow = 0x2193; + long nAWidth = rRenderContext.GetTextWidth(sText.copy(0,1)); + switch (nFrameDirection) + { + case SvxFrameDirection::Horizontal_LR_TB: + aPos = aRect.TopLeft(); + aPos.AdjustX(rRenderContext.PixelToLogic(Point(1,1)).X() ); + aMove.setY( 0 ); + cArrow = 0x2192; + break; + case SvxFrameDirection::Horizontal_RL_TB: + aPos = aRect.TopRight(); + aPos.AdjustX( -nAWidth ); + aMove.setY( 0 ); + aMove.setX( aMove.X() * -1 ); + cArrow = 0x2190; + break; + case SvxFrameDirection::Vertical_LR_TB: + aPos = aRect.TopLeft(); + aPos.AdjustX(rRenderContext.PixelToLogic(Point(1,1)).X() ); + aMove.setX( 0 ); + break; + case SvxFrameDirection::Vertical_RL_TB: + aPos = aRect.TopRight(); + aPos.AdjustX( -nAWidth ); + aMove.setX( 0 ); + break; + default: break; + } + sText += OUStringChar(cArrow); + for (sal_Int32 i = 0; i < sText.getLength(); i++) + { + OUString sDraw(sText.copy(i,1)); + long nHDiff = 0; + long nCharWidth = rRenderContext.GetTextWidth(sDraw); + bool bHorizontal = 0 == aMove.Y(); + if (!bHorizontal) + { + nHDiff = (nAWidth - nCharWidth) / 2; + aPos.AdjustX(nHDiff ); + } + rRenderContext.DrawText(aPos,sDraw); + if (bHorizontal) + { + aPos.AdjustX(aMove.X() < 0 ? -nCharWidth : nCharWidth ); + } + else + { + aPos.AdjustX( -nHDiff ); + aPos.AdjustY(aMove.Y() ); + } + } + aFont.SetFontSize(aSaveSize); + rRenderContext.SetFont(aFont); + + } + if (bTable) + { + // Paint Table, if necessary center it + rRenderContext.SetLineColor(COL_LIGHTGRAY); + + long nW = aRect.GetWidth(); + long nH = aRect.GetHeight(); + long const nTW = CELL_WIDTH * 3; + long const nTH = CELL_HEIGHT * 3; + long _nLeft = bHorz ? aRect.Left() + ((nW - nTW) / 2) : aRect.Left(); + long _nTop = bVert ? aRect.Top() + ((nH - nTH) / 2) : aRect.Top(); + tools::Rectangle aCellRect(Point(_nLeft, _nTop),Size(CELL_WIDTH, CELL_HEIGHT)); + + for (sal_uInt16 i = 0; i < 3; ++i) + { + aCellRect.SetLeft( _nLeft ); + aCellRect.SetRight( _nLeft + CELL_WIDTH ); + if(i > 0) + aCellRect.Move(0,CELL_HEIGHT); + + for (sal_uInt16 j = 0; j < 3; ++j) + { + if (j > 0) + aCellRect.Move(CELL_WIDTH,0); + rRenderContext.DrawRect(aCellRect); + } + } + } +} + +void SvxPageWindow::drawFillAttributes(vcl::RenderContext& rRenderContext, + const drawinglayer::attribute::SdrAllFillAttributesHelperPtr& rFillAttributes, + const tools::Rectangle& rPaintRange, + const tools::Rectangle& rDefineRange) +{ + const basegfx::B2DRange aPaintRange = vcl::unotools::b2DRectangleFromRectangle(rPaintRange); + + if(!aPaintRange.isEmpty() && + !basegfx::fTools::equalZero(aPaintRange.getWidth()) && + !basegfx::fTools::equalZero(aPaintRange.getHeight())) + { + const basegfx::B2DRange aDefineRange = vcl::unotools::b2DRectangleFromRectangle(rDefineRange); + + // prepare primitive sequence + drawinglayer::primitive2d::Primitive2DContainer aSequence; + + // create fill geometry if there is something to fill + if (rFillAttributes && rFillAttributes->isUsed()) + { + aSequence = rFillAttributes->getPrimitive2DSequence(aPaintRange, aDefineRange); + } + + // create line geometry if a LineColor is set at the target device + if (rRenderContext.IsLineColor()) + { + const drawinglayer::primitive2d::Primitive2DReference xOutline( + new drawinglayer::primitive2d::PolygonHairlinePrimitive2D( + basegfx::utils::createPolygonFromRect(aPaintRange), rRenderContext.GetLineColor().getBColor())); + + aSequence.push_back(xOutline); + } + + // draw that if we have something to draw + if (!aSequence.empty()) + { + const drawinglayer::geometry::ViewInformation2D aViewInformation2D( + basegfx::B2DHomMatrix(), rRenderContext.GetViewTransformation(), aPaintRange, nullptr, + 0.0, css::uno::Sequence<css::beans::PropertyValue >()); + + std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor( + drawinglayer::processor2d::createProcessor2DFromOutputDevice(rRenderContext, aViewInformation2D)); + if (pProcessor) + { + pProcessor->process(aSequence); + } + } + } +} + + +void SvxPageWindow::EnableFrameDirection(bool bEnable) +{ + bFrameDirection = bEnable; +} + +void SvxPageWindow::SetFrameDirection(SvxFrameDirection nDirection) +{ + nFrameDirection = nDirection; +} + +void SvxPageWindow::ResetBackground() +{ + bResetBackground = true; +} + +void SvxPageWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + + OutputDevice& rRefDevice = pDrawingArea->get_ref_device(); + // Count in Twips by default + rRefDevice.Push(PushFlags::MAPMODE); + rRefDevice.SetMapMode(MapMode(MapUnit::MapTwip)); + aWinSize = rRefDevice.LogicToPixel(Size(75, 46), MapMode(MapUnit::MapAppFont)); + pDrawingArea->set_size_request(aWinSize.Width(), aWinSize.Height()); + + aWinSize.AdjustHeight( -4 ); + aWinSize.AdjustWidth( -4 ); + + aWinSize = rRefDevice.PixelToLogic(aWinSize); + rRefDevice.Pop(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/pagenumberlistbox.cxx b/svx/source/dialog/pagenumberlistbox.cxx new file mode 100644 index 000000000..076da12e1 --- /dev/null +++ b/svx/source/dialog/pagenumberlistbox.cxx @@ -0,0 +1,52 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/pagenumberlistbox.hxx> +#include <editeng/numitem.hxx> +#include <com/sun/star/style/NumberingType.hpp> +#include <numberingtype.hrc> + +SvxPageNumberListBox::SvxPageNumberListBox(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) +{ + m_xControl->set_size_request(150, -1); + + for (size_t i = 0; i < SAL_N_ELEMENTS(RID_SVXSTRARY_NUMBERINGTYPE); ++i) + { + sal_uInt16 nData = RID_SVXSTRARY_NUMBERINGTYPE[i].second; + switch (nData) + { + // String list array is also used in Writer and contains strings + // for Bullet and Graphics, ignore those here. + case css::style::NumberingType::CHAR_SPECIAL: + case css::style::NumberingType::BITMAP: + case css::style::NumberingType::BITMAP | LINK_TOKEN: + break; + default: + { + OUString aStr = SvxResId(RID_SVXSTRARY_NUMBERINGTYPE[i].first); + m_xControl->append(OUString::number(nData), aStr); + break; + } + } + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/papersizelistbox.cxx b/svx/source/dialog/papersizelistbox.cxx new file mode 100644 index 000000000..f746a023c --- /dev/null +++ b/svx/source/dialog/papersizelistbox.cxx @@ -0,0 +1,74 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/papersizelistbox.hxx> +#include "page.hrc" + +SvxPaperSizeListBox::SvxPaperSizeListBox(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) +{ + m_xControl->set_size_request(150, -1); +} + +void SvxPaperSizeListBox::FillPaperSizeEntries( PaperSizeApp eApp ) +{ + const std::pair<const char*, int>* pPaperAry = eApp == PaperSizeApp::Std ? + RID_SVXSTRARY_PAPERSIZE_STD : RID_SVXSTRARY_PAPERSIZE_DRAW; + sal_uInt32 nCnt = eApp == PaperSizeApp::Std ? + SAL_N_ELEMENTS(RID_SVXSTRARY_PAPERSIZE_STD) : SAL_N_ELEMENTS(RID_SVXSTRARY_PAPERSIZE_DRAW); + + for ( sal_uInt32 i = 0; i < nCnt; ++i ) + { + OUString aStr = SvxResId(pPaperAry[i].first); + Paper eSize = static_cast<Paper>(pPaperAry[i].second); + m_xControl->append(OUString::number(static_cast<sal_Int32>(eSize)), aStr); + } +} + +void SvxPaperSizeListBox::set_active_id( Paper ePreselectPaper ) +{ + int nEntryCount = m_xControl->get_count(); + int nSelPos = -1; + int nUserPos = -1; + + for (int i = 0; i < nEntryCount; ++i) + { + Paper eTmp = static_cast<Paper>(m_xControl->get_id(i).toInt32()); + if (eTmp == ePreselectPaper) + { + nSelPos = i; + break; + } + + if (eTmp == PAPER_USER) + nUserPos = i; + } + + // preselect current paper format - #115915#: ePaper might not be in aPaperSizeBox so use PAPER_USER instead + m_xControl->set_active((nSelPos != -1) ? nSelPos : nUserPos); +} + +Paper SvxPaperSizeListBox::get_active_id() const +{ + return static_cast<Paper>(m_xControl->get_active_id().toInt32()); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ + diff --git a/svx/source/dialog/paraprev.cxx b/svx/source/dialog/paraprev.cxx new file mode 100644 index 000000000..fb5003559 --- /dev/null +++ b/svx/source/dialog/paraprev.cxx @@ -0,0 +1,214 @@ +/* -*- 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/dialoghelper.hxx> +#include <svx/paraprev.hxx> +#include <vcl/outdev.hxx> +#include <vcl/settings.hxx> + +SvxParaPrevWindow::SvxParaPrevWindow() : + nLeftMargin ( 0 ), + nRightMargin ( 0 ), + nFirstLineOffset ( 0 ), + nUpper ( 0 ), + nLower ( 0 ), + eAdjust ( SvxAdjust::Left ), + eLastLine ( SvxAdjust::Left ), + eLine ( SvxPrevLineSpace::N1 ) +{ + aSize = Size(11905, 16837); +} + +void SvxParaPrevWindow::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + Size aOptimalSize(getParagraphPreviewOptimalSize(pDrawingArea->get_ref_device())); + pDrawingArea->set_size_request(aOptimalSize.Width(), aOptimalSize.Height()); +} + +void SvxParaPrevWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + DrawParagraph(rRenderContext); +} + +#define DEF_MARGIN 120 + +void SvxParaPrevWindow::DrawParagraph(vcl::RenderContext& rRenderContext) +{ + // Count in Twips by default + rRenderContext.Push(PushFlags::MAPMODE); + rRenderContext.SetMapMode(MapMode(MapUnit::MapTwip)); + + Size aWinSize(GetOutputSizePixel()); + aWinSize = rRenderContext.PixelToLogic(aWinSize); + Size aTmp(1, 1); + aTmp = rRenderContext.PixelToLogic(aTmp); + aWinSize.AdjustWidth( -(aTmp.Width() /2) ); + aWinSize.AdjustHeight( -(aTmp.Height() /2) ); + + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + const Color& rWinColor = rStyleSettings.GetWindowColor(); + Color aGrayColor(COL_LIGHTGRAY); + + rRenderContext.SetFillColor(rWinColor); + rRenderContext.DrawRect(tools::Rectangle(Point(), aWinSize)); + + rRenderContext.SetLineColor(); + + long nH = aWinSize.Height() / 19; + Size aLineSiz(aWinSize.Width() - DEF_MARGIN, nH); + Size aSiz = aLineSiz; + Point aPnt; + aPnt.setX( DEF_MARGIN / 2 ); + rRenderContext.SetFillColor(aGrayColor); + + for (sal_uInt16 i = 0; i < 9; ++i) + { + if (i == 3) + { + rRenderContext.SetFillColor(COL_GRAY); + auto nTop = nUpper * aLineSiz.Height() / aSize.Height(); + aPnt.AdjustY(nTop * 2 ); + } + + if (i == 6 ) + rRenderContext.SetFillColor(aGrayColor); + + if (3 <= i && 6 > i) + { + long nLeft = nLeftMargin * aLineSiz.Width() / aSize.Width(); + long nFirst = nFirstLineOffset * aLineSiz.Width() / aSize.Width(); + long nTmp = nLeft + nFirst; + + if (i == 3) + { + aPnt.AdjustX(nTmp ); + aSiz.AdjustWidth( -nTmp ); + } + else + { + aPnt.AdjustX(nLeft ); + aSiz.AdjustWidth( -nLeft ); + } + long nRight = nRightMargin * aLineSiz.Width() / aSize.Width(); + aSiz.AdjustWidth( -nRight ); + } + + if (4 == i || 5 == i || 6 == i) + { + switch (eLine) + { + case SvxPrevLineSpace::N1: + break; + case SvxPrevLineSpace::N115: + aPnt.AdjustY(nH / 6.67 ); // 1/.15 = 6.(6) + break; + case SvxPrevLineSpace::N15: + aPnt.AdjustY(nH / 2 ); + break; + case SvxPrevLineSpace::N2: + aPnt.AdjustY(nH ); + break; + case SvxPrevLineSpace::Prop: + case SvxPrevLineSpace::Min: + case SvxPrevLineSpace::Leading: + break; + } + } + + aPnt.AdjustY(nH ); + + if (3 <= i && 5 >= i) + { + long nLW = long(); + switch (i) + { + case 3: + nLW = aLineSiz.Width() * 8 / 10; + break; + case 4: + nLW = aLineSiz.Width() * 9 / 10; + break; + case 5: + nLW = aLineSiz.Width() / 2; + break; + } + + if (nLW > aSiz.Width()) + nLW = aSiz.Width(); + + switch (eAdjust) + { + case SvxAdjust::Left: + break; + case SvxAdjust::Right: + aPnt.AdjustX( aSiz.Width() - nLW ); + break; + case SvxAdjust::Center: + aPnt.AdjustX(( aSiz.Width() - nLW ) / 2 ); + break; + default: ; //prevent warning + } + if (SvxAdjust::Block == eAdjust) + { + if(5 == i) + { + switch( eLastLine ) + { + case SvxAdjust::Left: + break; + case SvxAdjust::Right: + aPnt.AdjustX( aSiz.Width() - nLW ); + break; + case SvxAdjust::Center: + aPnt.AdjustX(( aSiz.Width() - nLW ) / 2 ); + break; + case SvxAdjust::Block: + nLW = aSiz.Width(); + break; + default: ; //prevent warning + } + } + else + nLW = aSiz.Width(); + } + aSiz.setWidth( nLW ); + } + + tools::Rectangle aRect(aPnt, aSiz); + + rRenderContext.DrawRect( aRect ); + + if (5 == i) + { + auto nBottom = nLower * aLineSiz.Height() / aSize.Height(); + aPnt.AdjustY(nBottom * 2 ); + } + + aPnt.AdjustY(nH ); + // Reset, recalculate for each line + aPnt.setX( DEF_MARGIN / 2 ); + aSiz = aLineSiz; + } + rRenderContext.Pop(); +} + +#undef DEF_MARGIN + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/passwd.cxx b/svx/source/dialog/passwd.cxx new file mode 100644 index 000000000..cb7793c3d --- /dev/null +++ b/svx/source/dialog/passwd.cxx @@ -0,0 +1,91 @@ +/* -*- 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/weld.hxx> +#include <svx/passwd.hxx> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> + +IMPL_LINK_NOARG(SvxPasswordDialog, ButtonHdl, weld::Button&, void) +{ + bool bOK = true; + + if (m_xNewPasswdED->get_text() != m_xRepeatPasswdED->get_text()) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + m_aRepeatPasswdErrStr)); + xBox->run(); + m_xNewPasswdED->set_text(""); + m_xRepeatPasswdED->set_text(""); + m_xNewPasswdED->grab_focus(); + bOK = false; + } + + if (bOK && m_aCheckPasswordHdl.IsSet() && !m_aCheckPasswordHdl.Call(this)) + { + std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(m_xDialog.get(), + VclMessageType::Warning, VclButtonsType::Ok, + m_aOldPasswdErrStr)); + xBox->run(); + m_xOldPasswdED->set_text(""); + m_xOldPasswdED->grab_focus(); + bOK = false; + } + + if (bOK) + m_xDialog->response(RET_OK); +} + +IMPL_LINK_NOARG(SvxPasswordDialog, EditModifyHdl, weld::Entry&, void) +{ + if (!m_xOKBtn->get_sensitive()) + m_xOKBtn->set_sensitive(true); +} + +SvxPasswordDialog::SvxPasswordDialog(weld::Window* pParent, bool bDisableOldPassword) + : SfxDialogController(pParent, "svx/ui/passwd.ui", "PasswordDialog") + , m_aOldPasswdErrStr(SvxResId(RID_SVXSTR_ERR_OLD_PASSWD)) + , m_aRepeatPasswdErrStr(SvxResId(RID_SVXSTR_ERR_REPEAT_PASSWD )) + , m_xOldFL(m_xBuilder->weld_label("oldpass")) + , m_xOldPasswdFT(m_xBuilder->weld_label("oldpassL")) + , m_xOldPasswdED(m_xBuilder->weld_entry("oldpassEntry")) + , m_xNewPasswdED(m_xBuilder->weld_entry("newpassEntry")) + , m_xRepeatPasswdED(m_xBuilder->weld_entry("confirmpassEntry")) + , m_xOKBtn(m_xBuilder->weld_button("ok")) +{ + m_xOKBtn->connect_clicked(LINK(this, SvxPasswordDialog, ButtonHdl)); + m_xRepeatPasswdED->connect_changed(LINK(this, SvxPasswordDialog, EditModifyHdl)); + EditModifyHdl(*m_xRepeatPasswdED); + + if (bDisableOldPassword) + { + m_xOldFL->set_sensitive(false); + m_xOldPasswdFT->set_sensitive(false); + m_xOldPasswdED->set_sensitive(false); + m_xNewPasswdED->grab_focus(); + } +} + +SvxPasswordDialog::~SvxPasswordDialog() +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/relfld.cxx b/svx/source/dialog/relfld.cxx new file mode 100644 index 000000000..80340a168 --- /dev/null +++ b/svx/source/dialog/relfld.cxx @@ -0,0 +1,103 @@ +/* -*- 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/relfld.hxx> + +SvxRelativeField::SvxRelativeField(std::unique_ptr<weld::MetricSpinButton> pControl) + : m_xSpinButton(std::move(pControl)) + , nRelMin(0) + , nRelMax(0) + , bRelativeMode(false) + , bRelative(false) + , bNegativeEnabled(false) + +{ + weld::SpinButton& rSpinButton = m_xSpinButton->get_widget(); + rSpinButton.connect_changed(LINK(this, SvxRelativeField, ModifyHdl)); +} + +IMPL_LINK_NOARG(SvxRelativeField, ModifyHdl, weld::Entry&, void) +{ + if (bRelativeMode) + { + OUString aStr = m_xSpinButton->get_text(); + bool bNewMode = bRelative; + + if ( bRelative ) + { + const sal_Unicode* pStr = aStr.getStr(); + + while ( *pStr ) + { + if( ( ( *pStr < '0' ) || ( *pStr > '9' ) ) && + ( *pStr != '%' ) ) + { + bNewMode = false; + break; + } + pStr++; + } + } + else + { + if ( aStr.indexOf( "%" ) != -1 ) + bNewMode = true; + } + + if ( bNewMode != bRelative ) + SetRelative( bNewMode ); + } +} + +void SvxRelativeField::EnableRelativeMode(sal_uInt16 nMin, sal_uInt16 nMax) +{ + bRelativeMode = true; + nRelMin = nMin; + nRelMax = nMax; + m_xSpinButton->set_unit(FieldUnit::CM); +} + +void SvxRelativeField::SetRelative( bool bNewRelative ) +{ + weld::SpinButton& rSpinButton = m_xSpinButton->get_widget(); + + int nStartPos, nEndPos; + rSpinButton.get_selection_bounds(nStartPos, nEndPos); + OUString aStr = rSpinButton.get_text(); + + if ( bNewRelative ) + { + bRelative = true; + m_xSpinButton->set_digits(0); + m_xSpinButton->set_range(nRelMin, nRelMax, FieldUnit::NONE); + m_xSpinButton->set_unit(FieldUnit::PERCENT); + } + else + { + bRelative = false; + m_xSpinButton->set_digits(2); + m_xSpinButton->set_range(bNegativeEnabled ? -9999 : 0, 9999, FieldUnit::NONE); + m_xSpinButton->set_unit(FieldUnit::CM); + } + + rSpinButton.set_text(aStr); + rSpinButton.select_region(nStartPos, nEndPos); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/rlrcitem.cxx b/svx/source/dialog/rlrcitem.cxx new file mode 100644 index 000000000..f5309e843 --- /dev/null +++ b/svx/source/dialog/rlrcitem.cxx @@ -0,0 +1,148 @@ +/* -*- 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 <svl/rectitem.hxx> +#include <sal/log.hxx> +#include <osl/diagnose.h> + +#include <svx/svxids.hrc> + +#include <svx/ruler.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/tstpitem.hxx> +#include <editeng/protitem.hxx> +#include "rlrcitem.hxx" +#include <svx/rulritem.hxx> +#include <svl/eitem.hxx> + +SvxRulerItem::SvxRulerItem(sal_uInt16 _nId, SvxRuler &rRul, SfxBindings &rBindings) +: SfxControllerItem(_nId, rBindings), + rRuler(rRul) +{ +} + + +void SvxRulerItem::StateChanged( sal_uInt16 nSID, SfxItemState eState, + const SfxPoolItem* pState) +{ + // SfxItemState::DONTCARE => pState == -1 => PTR_CAST buff + if ( eState != SfxItemState::DEFAULT ) + pState = nullptr; + + switch(nSID) + { + // Left / right margin + case SID_RULER_LR_MIN_MAX: + { + const SfxRectangleItem *pItem = dynamic_cast<const SfxRectangleItem*>( pState ); + rRuler.UpdateFrameMinMax(pItem); + break; + } + case SID_ATTR_LONG_LRSPACE: + { + const SvxLongLRSpaceItem *pItem = dynamic_cast<const SvxLongLRSpaceItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxLRSpaceItem expected"); + rRuler.UpdateFrame(pItem); + break; + } + case SID_ATTR_LONG_ULSPACE: + { + const SvxLongULSpaceItem *pItem = dynamic_cast<const SvxLongULSpaceItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxULSpaceItem expected"); + rRuler.UpdateFrame(pItem); + break; + } + case SID_ATTR_TABSTOP_VERTICAL: + case SID_ATTR_TABSTOP: + { + const SvxTabStopItem *pItem = dynamic_cast<const SvxTabStopItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxTabStopItem expected"); + rRuler.Update(pItem); + break; + } + case SID_ATTR_PARA_LRSPACE_VERTICAL: + case SID_ATTR_PARA_LRSPACE: + { + const SvxLRSpaceItem *pItem = dynamic_cast<const SvxLRSpaceItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxLRSpaceItem expected"); + rRuler.UpdatePara(pItem); + break; + } + case SID_RULER_BORDERS_VERTICAL: + case SID_RULER_BORDERS: + case SID_RULER_ROWS: + case SID_RULER_ROWS_VERTICAL: + { + const SvxColumnItem *pItem = dynamic_cast<const SvxColumnItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxColumnItem expected"); +#ifdef DBG_UTIL + if(pItem) + { + if(pItem->IsConsistent()) + rRuler.Update(pItem, nSID); + else + OSL_FAIL("Column item corrupted"); + } + else + rRuler.Update(pItem, nSID); +#else + rRuler.Update(pItem, nSID); +#endif + break; + } + case SID_RULER_PAGE_POS: + { // Position page, page width + const SvxPagePosSizeItem *pItem = dynamic_cast<const SvxPagePosSizeItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxPagePosSizeItem expected"); + rRuler.Update(pItem); + break; + } + case SID_RULER_OBJECT: + { // Object selection + const SvxObjectItem *pItem = dynamic_cast<const SvxObjectItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxObjectItem expected"); + rRuler.Update(pItem); + break; + } + case SID_RULER_PROTECT: + { + const SvxProtectItem *pItem = dynamic_cast<const SvxProtectItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxProtectItem expected"); + rRuler.Update(pItem); + break; + } + case SID_RULER_BORDER_DISTANCE: + { + const SvxLRSpaceItem *pItem = dynamic_cast<const SvxLRSpaceItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SvxLRSpaceItem expected"); + rRuler.UpdateParaBorder(); + } + break; + case SID_RULER_TEXT_RIGHT_TO_LEFT : + { + const SfxBoolItem *pItem = dynamic_cast<const SfxBoolItem*>( pState ); + SAL_WARN_IF(pState != nullptr && pItem == nullptr, "svx.dialog", "SfxBoolItem expected"); + rRuler.UpdateTextRTL(pItem); + } + break; + } +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/rlrcitem.hxx b/svx/source/dialog/rlrcitem.hxx new file mode 100644 index 000000000..574d7fe91 --- /dev/null +++ b/svx/source/dialog/rlrcitem.hxx @@ -0,0 +1,42 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_DIALOG_RLRCITEM_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_RLRCITEM_HXX + +#include <sfx2/ctrlitem.hxx> + +class SvxRuler; + +class SvxRulerItem : public SfxControllerItem +{ +private: + SvxRuler& rRuler; + +protected: + virtual void StateChanged( sal_uInt16, + SfxItemState, const SfxPoolItem* pState ) override; + +public: + SvxRulerItem( sal_uInt16 nId, SvxRuler&, SfxBindings& ); +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/rubydialog.cxx b/svx/source/dialog/rubydialog.cxx new file mode 100644 index 000000000..4a73ad663 --- /dev/null +++ b/svx/source/dialog/rubydialog.cxx @@ -0,0 +1,890 @@ +/* + * 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 <sal/config.h> +#include <tools/debug.hxx> + +#include <osl/diagnose.h> +#include <svx/rubydialog.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/sfxsids.hrc> +#include <sfx2/viewfrm.hxx> +#include <sfx2/viewsh.hxx> +#include <svl/eitem.hxx> +#include <com/sun/star/frame/XController.hpp> +#include <com/sun/star/style/XStyle.hpp> +#include <com/sun/star/text/XRubySelection.hpp> +#include <com/sun/star/beans/PropertyValues.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/beans/XPropertySetInfo.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/style/XStyleFamiliesSupplier.hpp> +#include <com/sun/star/text/RubyAdjust.hpp> +#include <com/sun/star/view/XSelectionChangeListener.hpp> +#include <com/sun/star/view/XSelectionSupplier.hpp> +#include <cppuhelper/implbase.hxx> +#include <svtools/colorcfg.hxx> +#include <vcl/event.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +using namespace css::uno; +using namespace css::frame; +using namespace css::text; +using namespace css::beans; +using namespace css::style; +using namespace css::view; +using namespace css::lang; +using namespace css::container; + +SFX_IMPL_CHILDWINDOW(SvxRubyChildWindow, SID_RUBY_DIALOG); + +namespace +{ + +static const char cRubyBaseText[] = "RubyBaseText"; +static const char cRubyText[] = "RubyText"; +static const char cRubyAdjust[] = "RubyAdjust"; +static const char cRubyPosition[] = "RubyPosition"; +static const char cRubyCharStyleName[] = "RubyCharStyleName"; + +} // end anonymous namespace + +SvxRubyChildWindow::SvxRubyChildWindow(vcl::Window* _pParent, sal_uInt16 nId,SfxBindings* pBindings, SfxChildWinInfo const * pInfo) + : SfxChildWindow(_pParent, nId) +{ + auto xDlg = std::make_shared<SvxRubyDialog>(pBindings, this, _pParent->GetFrameWeld()); + SetController(xDlg); + xDlg->Initialize(pInfo); +} + +SfxChildWinInfo SvxRubyChildWindow::GetInfo() const +{ + return SfxChildWindow::GetInfo(); +} + +class SvxRubyData_Impl : public cppu::WeakImplHelper<css::view::XSelectionChangeListener> +{ + Reference<XModel> xModel; + Reference<XRubySelection> xSelection; + Sequence<PropertyValues> aRubyValues; + Reference<XController> xController; + bool bHasSelectionChanged; + +public: + SvxRubyData_Impl(); + virtual ~SvxRubyData_Impl() override; + + void SetController(const Reference<XController>& xCtrl); + Reference<XModel> const & GetModel() + { + if (!xController.is()) + xModel = nullptr; + else + xModel = xController->getModel(); + return xModel; + } + bool HasSelectionChanged() const + { + return bHasSelectionChanged; + } + Reference<XRubySelection> const & GetRubySelection() + { + xSelection.set(xController, UNO_QUERY); + return xSelection; + } + void UpdateRubyValues() + { + if (!xSelection.is()) + aRubyValues.realloc(0); + else + aRubyValues = xSelection->getRubyList(false); + bHasSelectionChanged = false; + } + Sequence<PropertyValues>& GetRubyValues() + { + return aRubyValues; + } + void AssertOneEntry(); + + virtual void SAL_CALL selectionChanged(const css::lang::EventObject& aEvent) override; + virtual void SAL_CALL disposing( const css::lang::EventObject& Source) override; + +}; + +SvxRubyData_Impl::SvxRubyData_Impl() + : bHasSelectionChanged(false) +{ +} + +SvxRubyData_Impl::~SvxRubyData_Impl() +{ +} + +void SvxRubyData_Impl::SetController(const Reference<XController>& xCtrl) +{ + if (xCtrl.get() != xController.get()) + { + try + { + Reference<XSelectionSupplier> xSelSupp(xController, UNO_QUERY); + if (xSelSupp.is()) + xSelSupp->removeSelectionChangeListener(this); + + bHasSelectionChanged = true; + xController = xCtrl; + xSelSupp.set(xController, UNO_QUERY); + if (xSelSupp.is()) + xSelSupp->addSelectionChangeListener(this); + } + catch (const Exception&) + { + } + } +} + +void SvxRubyData_Impl::selectionChanged(const EventObject& ) +{ + bHasSelectionChanged = true; +} + +void SvxRubyData_Impl::disposing(const EventObject&) +{ + try + { + Reference<XSelectionSupplier> xSelSupp(xController, UNO_QUERY); + if (xSelSupp.is()) + xSelSupp->removeSelectionChangeListener(this); + } + catch (const Exception&) + { + } + xController = nullptr; +} + +void SvxRubyData_Impl::AssertOneEntry() +{ + //create one entry + if (!aRubyValues.hasElements()) + { + aRubyValues.realloc(1); + Sequence<PropertyValue>& rValues = aRubyValues.getArray()[0]; + rValues.realloc(5); + PropertyValue* pValues = rValues.getArray(); + pValues[0].Name = cRubyBaseText; + pValues[1].Name = cRubyText; + pValues[2].Name = cRubyAdjust; + pValues[3].Name = cRubyPosition; + pValues[4].Name = cRubyCharStyleName; + } +} + +SvxRubyDialog::SvxRubyDialog(SfxBindings* pBind, SfxChildWindow* pCW, weld::Window* pParent) + : SfxModelessDialogController(pBind, pCW, pParent, + "svx/ui/asianphoneticguidedialog.ui", "AsianPhoneticGuideDialog") + , nLastPos(0) + , nCurrentEdit(0) + , bModified(false) + , pBindings(pBind) + , m_pImpl( new SvxRubyData_Impl ) + , m_xLeftFT(m_xBuilder->weld_label("basetextft")) + , m_xRightFT(m_xBuilder->weld_label("rubytextft")) + , m_xLeft1ED(m_xBuilder->weld_entry("Left1ED")) + , m_xRight1ED(m_xBuilder->weld_entry("Right1ED")) + , m_xLeft2ED(m_xBuilder->weld_entry("Left2ED")) + , m_xRight2ED(m_xBuilder->weld_entry("Right2ED")) + , m_xLeft3ED(m_xBuilder->weld_entry("Left3ED")) + , m_xRight3ED(m_xBuilder->weld_entry("Right3ED")) + , m_xLeft4ED(m_xBuilder->weld_entry("Left4ED")) + , m_xRight4ED(m_xBuilder->weld_entry("Right4ED")) + , m_xScrolledWindow(m_xBuilder->weld_scrolled_window("scrolledwindow")) + , m_xAdjustLB(m_xBuilder->weld_combo_box("adjustlb")) + , m_xPositionLB(m_xBuilder->weld_combo_box("positionlb")) + , m_xCharStyleFT(m_xBuilder->weld_label("styleft")) + , m_xCharStyleLB(m_xBuilder->weld_combo_box("stylelb")) + , m_xStylistPB(m_xBuilder->weld_button("styles")) + , m_xApplyPB(m_xBuilder->weld_button("ok")) + , m_xClosePB(m_xBuilder->weld_button("cancel")) + , m_xContentArea(m_xDialog->weld_content_area()) + , m_xGrid(m_xBuilder->weld_widget("grid")) + , m_xPreviewWin(new RubyPreview) + , m_xPreview(new weld::CustomWeld(*m_xBuilder, "preview", *m_xPreviewWin)) +{ + m_xCharStyleLB->make_sorted(); + m_xPreviewWin->setRubyDialog(this); + m_xScrolledWindow->set_user_managed_scrolling(); + m_xScrolledWindow->set_size_request(-1, m_xGrid->get_preferred_size().Height()); + m_xScrolledWindow->set_vpolicy(VclPolicyType::NEVER); + + aEditArr[0] = m_xLeft1ED.get(); aEditArr[1] = m_xRight1ED.get(); + aEditArr[2] = m_xLeft2ED.get(); aEditArr[3] = m_xRight2ED.get(); + aEditArr[4] = m_xLeft3ED.get(); aEditArr[5] = m_xRight3ED.get(); + aEditArr[6] = m_xLeft4ED.get(); aEditArr[7] = m_xRight4ED.get(); + + m_xApplyPB->connect_clicked(LINK(this, SvxRubyDialog, ApplyHdl_Impl)); + m_xClosePB->connect_clicked(LINK(this, SvxRubyDialog, CloseHdl_Impl)); + m_xStylistPB->connect_clicked(LINK(this, SvxRubyDialog, StylistHdl_Impl)); + m_xAdjustLB->connect_changed(LINK(this, SvxRubyDialog, AdjustHdl_Impl)); + m_xPositionLB->connect_changed(LINK(this, SvxRubyDialog, PositionHdl_Impl)); + m_xCharStyleLB->connect_changed(LINK(this, SvxRubyDialog, CharStyleHdl_Impl)); + + Link<weld::ScrolledWindow&, void> aScrLk(LINK(this, SvxRubyDialog, ScrollHdl_Impl)); + m_xScrolledWindow->connect_vadjustment_changed(aScrLk); + + Link<weld::Entry&,void> aEditLk(LINK(this, SvxRubyDialog, EditModifyHdl_Impl)); + Link<weld::Widget&,void> aFocusLk(LINK(this, SvxRubyDialog, EditFocusHdl_Impl)); + Link<const KeyEvent&,bool> aKeyUpDownLk(LINK(this, SvxRubyDialog, KeyUpDownHdl_Impl)); + Link<const KeyEvent&,bool> aKeyTabUpDownLk(LINK(this, SvxRubyDialog, KeyUpDownTabHdl_Impl)); + for (sal_uInt16 i = 0; i < 8; i++) + { + aEditArr[i]->connect_changed(aEditLk); + aEditArr[i]->connect_focus_in(aFocusLk); + if (!i || 7 == i) + aEditArr[i]->connect_key_press(aKeyTabUpDownLk); + else + aEditArr[i]->connect_key_press(aKeyUpDownLk); + } +} + +SvxRubyDialog::~SvxRubyDialog() +{ + ClearCharStyleList(); + EventObject aEvent; + m_pImpl->disposing(aEvent); +} + +void SvxRubyDialog::ClearCharStyleList() +{ + m_xCharStyleLB->clear(); +} + +void SvxRubyDialog::Close() +{ + if (IsClosing()) + return; + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + if (pViewFrame) + pViewFrame->ToggleChildWindow(SID_RUBY_DIALOG); +} + +void SvxRubyDialog::Activate() +{ + SfxModelessDialogController::Activate(); + //get selection from current view frame + SfxViewFrame* pCurFrm = SfxViewFrame::Current(); + Reference< XController > xCtrl = pCurFrm->GetFrame().GetController(); + m_pImpl->SetController(xCtrl); + if (m_pImpl->HasSelectionChanged()) + { + + Reference< XRubySelection > xRubySel = m_pImpl->GetRubySelection(); + m_pImpl->UpdateRubyValues(); + EnableControls(xRubySel.is()); + if (xRubySel.is()) + { + Reference< XModel > xModel = m_pImpl->GetModel(); + const OUString sCharStyleSelect = m_xCharStyleLB->get_active_text(); + ClearCharStyleList(); + Reference<XStyleFamiliesSupplier> xSupplier(xModel, UNO_QUERY); + if (xSupplier.is()) + { + try + { + Reference<XNameAccess> xFam = xSupplier->getStyleFamilies(); + Any aChar = xFam->getByName("CharacterStyles"); + Reference<XNameContainer> xChar; + aChar >>= xChar; + Reference<XIndexAccess> xCharIdx(xChar, UNO_QUERY); + if (xCharIdx.is()) + { + OUString sUIName("DisplayName"); + for (sal_Int32 nStyle = 0; nStyle < xCharIdx->getCount(); nStyle++) + { + Any aStyle = xCharIdx->getByIndex(nStyle); + Reference<XStyle> xStyle; + aStyle >>= xStyle; + Reference<XPropertySet> xPrSet(xStyle, UNO_QUERY); + OUString sName, sCoreName; + if (xPrSet.is()) + { + Reference<XPropertySetInfo> xInfo = xPrSet->getPropertySetInfo(); + if (xInfo->hasPropertyByName(sUIName)) + { + Any aName = xPrSet->getPropertyValue(sUIName); + aName >>= sName; + } + } + if (xStyle.is()) + { + sCoreName = xStyle->getName(); + if (sName.isEmpty()) + sName = sCoreName; + } + if (!sName.isEmpty()) + { + m_xCharStyleLB->append(sCoreName, sName); + + } + } + } + } + catch (const Exception&) + { + OSL_FAIL("exception in style access"); + } + if (!sCharStyleSelect.isEmpty()) + m_xCharStyleLB->set_active_text(sCharStyleSelect); + } + m_xCharStyleLB->set_sensitive(xSupplier.is()); + m_xCharStyleFT->set_sensitive(xSupplier.is()); + } + Update(); + m_xPreviewWin->Invalidate(); + } +} + +void SvxRubyDialog::SetRubyText(sal_Int32 nPos, weld::Entry& rLeft, weld::Entry& rRight) +{ + OUString sLeft, sRight; + const Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + bool bEnable = aRubyValues.getLength() > nPos; + if (bEnable) + { + const Sequence<PropertyValue> aProps = aRubyValues.getConstArray()[nPos]; + for (const PropertyValue& rProp : aProps) + { + if (rProp.Name == cRubyBaseText) + rProp.Value >>= sLeft; + else if (rProp.Name == cRubyText) + rProp.Value >>= sRight; + } + } + else if (!nPos) + { + bEnable = true; + } + rLeft.set_sensitive(bEnable); + rRight.set_sensitive(bEnable); + rLeft.set_text(sLeft); + rRight.set_text(sRight); + rLeft.save_value(); + rRight.save_value(); +} + +void SvxRubyDialog::GetRubyText() +{ + long nTempLastPos = GetLastPos(); + for (int i = 0; i < 8; i+=2) + { + if (aEditArr[i]->get_sensitive() && + (aEditArr[i]->get_value_changed_from_saved() || + aEditArr[i + 1]->get_value_changed_from_saved())) + { + Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + DBG_ASSERT(aRubyValues.getLength() > (i / 2 + nTempLastPos), "wrong index" ); + SetModified(true); + Sequence<PropertyValue>& rProps = aRubyValues.getArray()[i / 2 + nTempLastPos]; + for (PropertyValue & propVal : rProps) + { + if (propVal.Name == cRubyBaseText) + propVal.Value <<= aEditArr[i]->get_text(); + else if (propVal.Name == cRubyText) + propVal.Value <<= aEditArr[i + 1]->get_text(); + } + } + } +} + +void SvxRubyDialog::Update() +{ + const Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + sal_Int32 nLen = aRubyValues.getLength(); + m_xScrolledWindow->vadjustment_configure(0, 0, !nLen ? 1 : nLen, 1, 4, 4); + if (nLen > 4) + m_xScrolledWindow->set_vpolicy(VclPolicyType::ALWAYS); + else + m_xScrolledWindow->set_vpolicy(VclPolicyType::NEVER); + SetLastPos(0); + SetModified(false); + + sal_Int16 nAdjust = -1; + sal_Int16 nPosition = -1; + OUString sCharStyleName, sTmp; + bool bCharStyleEqual = true; + for (sal_Int32 nRuby = 0; nRuby < nLen; nRuby++) + { + const Sequence<PropertyValue> &rProps = aRubyValues.getConstArray()[nRuby]; + for (const PropertyValue& rProp : rProps) + { + if (nAdjust > -2 && rProp.Name == cRubyAdjust) + { + sal_Int16 nTmp = sal_Int16(); + rProp.Value >>= nTmp; + if (!nRuby) + nAdjust = nTmp; + else if(nAdjust != nTmp) + nAdjust = -2; + } + if (nPosition > -2 && rProp.Name == cRubyPosition ) + { + sal_Int16 nTmp = sal_Int16(); + rProp.Value >>= nTmp; + if (!nRuby) + nPosition = nTmp; + else if(nPosition != nTmp) + nPosition = -2; + } + if (bCharStyleEqual && rProp.Name == cRubyCharStyleName) + { + rProp.Value >>= sTmp; + if (!nRuby) + sCharStyleName = sTmp; + else if (sCharStyleName != sTmp) + bCharStyleEqual = false; + } + } + } + if (!nLen) + { + //enable selection if the ruby list is empty + nAdjust = 0; + nPosition = 0; + } + if (nAdjust > -1) + m_xAdjustLB->set_active(nAdjust); + else + m_xAdjustLB->set_active(-1); + if (nPosition > -1) + m_xPositionLB->set_active(nPosition); + if (!nLen || (bCharStyleEqual && sCharStyleName.isEmpty())) + sCharStyleName = "Rubies"; + if (!sCharStyleName.isEmpty()) + { + for (int i = 0, nEntryCount = m_xCharStyleLB->get_count(); i < nEntryCount; i++) + { + OUString sCoreName = m_xCharStyleLB->get_id(i); + if (sCharStyleName == sCoreName) + { + m_xCharStyleLB->set_active(i); + break; + } + } + } + else + m_xCharStyleLB->set_active(-1); + + ScrollHdl_Impl(*m_xScrolledWindow); +} + +void SvxRubyDialog::GetCurrentText(OUString& rBase, OUString& rRuby) +{ + rBase = aEditArr[nCurrentEdit * 2]->get_text(); + rRuby = aEditArr[nCurrentEdit * 2 + 1]->get_text(); +} + +IMPL_LINK(SvxRubyDialog, ScrollHdl_Impl, weld::ScrolledWindow&, rScroll, void) +{ + int nPos = rScroll.vadjustment_get_value(); + if (GetLastPos() != nPos) + { + GetRubyText(); + } + SetRubyText(nPos++, *m_xLeft1ED, *m_xRight1ED); + SetRubyText(nPos++, *m_xLeft2ED, *m_xRight2ED); + SetRubyText(nPos++, *m_xLeft3ED, *m_xRight3ED); + SetRubyText(nPos, *m_xLeft4ED, *m_xRight4ED); + SetLastPos(nPos - 3); + m_xPreviewWin->Invalidate(); +} + +IMPL_LINK_NOARG(SvxRubyDialog, ApplyHdl_Impl, weld::Button&, void) +{ + const Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + if (!aRubyValues.hasElements()) + { + AssertOneEntry(); + PositionHdl_Impl(*m_xPositionLB); + AdjustHdl_Impl(*m_xAdjustLB); + CharStyleHdl_Impl(*m_xCharStyleLB); + } + GetRubyText(); + //reset all edit fields - SaveValue is called + ScrollHdl_Impl(*m_xScrolledWindow); + + Reference<XRubySelection> xSelection = m_pImpl->GetRubySelection(); + if (IsModified() && xSelection.is()) + { + try + { + xSelection->setRubyList(aRubyValues, false); + } + catch (const Exception&) + { + OSL_FAIL("Exception caught"); + } + } +} + +IMPL_LINK_NOARG(SvxRubyDialog, CloseHdl_Impl, weld::Button&, void) +{ + Close(); +} + +IMPL_LINK_NOARG(SvxRubyDialog, StylistHdl_Impl, weld::Button&, void) +{ + std::unique_ptr<SfxPoolItem> pState; + SfxItemState eState = pBindings->QueryState(SID_STYLE_DESIGNER, pState); + if (eState <= SfxItemState::SET || !pState || !static_cast<SfxBoolItem*>(pState.get())->GetValue()) + { + pBindings->GetDispatcher()->Execute(SID_STYLE_DESIGNER, + SfxCallMode::ASYNCHRON | SfxCallMode::RECORD); + } +} + +IMPL_LINK(SvxRubyDialog, AdjustHdl_Impl, weld::ComboBox&, rBox, void) +{ + AssertOneEntry(); + sal_Int16 nAdjust = rBox.get_active(); + Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + for (PropertyValues & rProps : aRubyValues) + { + for (PropertyValue & propVal : rProps) + { + if (propVal.Name == cRubyAdjust) + propVal.Value <<= nAdjust; + } + SetModified(true); + } + m_xPreviewWin->Invalidate(); +} + +IMPL_LINK(SvxRubyDialog, PositionHdl_Impl, weld::ComboBox&, rBox, void) +{ + AssertOneEntry(); + sal_Int16 nPosition = rBox.get_active(); + Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + for (PropertyValues & rProps : aRubyValues) + { + for (PropertyValue & propVal : rProps) + { + if (propVal.Name == cRubyPosition) + propVal.Value <<= nPosition; + } + SetModified(true); + } + m_xPreviewWin->Invalidate(); +} + +IMPL_LINK_NOARG(SvxRubyDialog, CharStyleHdl_Impl, weld::ComboBox&, void) +{ + AssertOneEntry(); + OUString sStyleName; + if (m_xCharStyleLB->get_active() != -1) + sStyleName = m_xCharStyleLB->get_active_id(); + Sequence<PropertyValues>& aRubyValues = m_pImpl->GetRubyValues(); + for (PropertyValues & rProps : aRubyValues) + { + for (PropertyValue & propVal : rProps) + { + if (propVal.Name == cRubyCharStyleName) + { + propVal.Value <<= sStyleName; + } + } + SetModified(true); + } +} + +IMPL_LINK(SvxRubyDialog, EditFocusHdl_Impl, weld::Widget&, rEdit, void) +{ + for (sal_uInt16 i = 0; i < 8; i++) + { + if (&rEdit == aEditArr[i]) + { + nCurrentEdit = i / 2; + break; + } + } + m_xPreviewWin->Invalidate(); +} + +IMPL_LINK(SvxRubyDialog, EditModifyHdl_Impl, weld::Entry&, rEdit, void) +{ + EditFocusHdl_Impl(rEdit); +} + +bool SvxRubyDialog::EditScrollHdl_Impl(sal_Int32 nParam) +{ + bool bRet = false; + //scroll forward + if (nParam > 0 && (aEditArr[7]->has_focus() || aEditArr[6]->has_focus() )) + { + if (m_xScrolledWindow->vadjustment_get_upper() > + m_xScrolledWindow->vadjustment_get_value() + m_xScrolledWindow->vadjustment_get_page_size()) + { + m_xScrolledWindow->vadjustment_set_value(m_xScrolledWindow->vadjustment_get_value() + 1); + aEditArr[6]->grab_focus(); + bRet = true; + } + } + //scroll backward + else if (m_xScrolledWindow->vadjustment_get_value() && (aEditArr[0]->has_focus()||aEditArr[1]->has_focus()) ) + { + m_xScrolledWindow->vadjustment_set_value(m_xScrolledWindow->vadjustment_get_value() - 1); + aEditArr[1]->grab_focus(); + bRet = true; + } + if (bRet) + ScrollHdl_Impl(*m_xScrolledWindow); + return bRet; +} + +bool SvxRubyDialog::EditJumpHdl_Impl(sal_Int32 nParam) +{ + bool bHandled = false; + sal_uInt16 nIndex = USHRT_MAX; + for (sal_uInt16 i = 0; i < 8; i++) + { + if(aEditArr[i]->has_focus()) + nIndex = i; + } + if (nIndex < 8) + { + if (nParam > 0) + { + if (nIndex < 6) + aEditArr[nIndex + 2]->grab_focus(); + else if( EditScrollHdl_Impl(nParam)) + aEditArr[nIndex]->grab_focus(); + } + else + { + if (nIndex > 1) + aEditArr[nIndex - 2]->grab_focus(); + else if( EditScrollHdl_Impl(nParam)) + aEditArr[nIndex]->grab_focus(); + } + bHandled = true; + } + return bHandled; +} + +void SvxRubyDialog::AssertOneEntry() +{ + m_pImpl->AssertOneEntry(); +} + +void SvxRubyDialog::EnableControls(bool bEnable) +{ + m_xContentArea->set_sensitive(bEnable); + m_xApplyPB->set_sensitive(bEnable); +} + +RubyPreview::RubyPreview() + : m_pParentDlg(nullptr) +{ +} + +RubyPreview::~RubyPreview() +{ +} + +void RubyPreview::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/) +{ + rRenderContext.Push(PushFlags::ALL); + + rRenderContext.SetMapMode(MapMode(MapUnit::MapTwip)); + + Size aWinSize = rRenderContext.GetOutputSize(); + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + svtools::ColorConfig aColorConfig; + + Color aNewTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor); + Color aNewFillColor(rStyleSettings.GetWindowColor()); + + vcl::Font aFont = rRenderContext.GetFont(); + aFont.SetFontHeight(aWinSize.Height() / 4); + aFont.SetFillColor(aNewFillColor); + aFont.SetColor(aNewTextColor); + rRenderContext.SetFont(aFont); + + tools::Rectangle aRect(Point(0, 0), aWinSize); + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(aFont.GetFillColor()); + rRenderContext.DrawRect(aRect); + + OUString sBaseText, sRubyText; + m_pParentDlg->GetCurrentText(sBaseText, sRubyText); + + long nTextHeight = rRenderContext.GetTextHeight(); + long nBaseWidth = rRenderContext.GetTextWidth(sBaseText); + + vcl::Font aRubyFont(aFont); + aRubyFont.SetFontHeight(aRubyFont.GetFontHeight() * 70 / 100); + rRenderContext.SetFont(aRubyFont); + long nRubyWidth = rRenderContext.GetTextWidth(sRubyText); + rRenderContext.SetFont(aFont); + + RubyAdjust nAdjust = static_cast<RubyAdjust>(m_pParentDlg->m_xAdjustLB->get_active()); + //use center if no adjustment is available + if (nAdjust > RubyAdjust_INDENT_BLOCK) + nAdjust = RubyAdjust_CENTER; + + //which part is stretched ? + bool bRubyStretch = nBaseWidth >= nRubyWidth; + + long nCenter = aWinSize.Width() / 2; + long nHalfWidth = std::max( nBaseWidth, nRubyWidth ) /2; + long nLeftStart = nCenter - nHalfWidth; + long nRightEnd = nCenter + nHalfWidth; + + // Default values for TOP or no selection + long nYRuby = aWinSize.Height() / 4 - nTextHeight / 2; + long nYBase = aWinSize.Height() * 3 / 4 - nTextHeight / 2; + + sal_Int16 nRubyPos = m_pParentDlg->m_xPositionLB->get_active(); + if ( nRubyPos == 1 ) // BOTTOM + { + long nTmp = nYRuby; + nYRuby = nYBase; + nYBase = nTmp; + } + else if ( nRubyPos == 2 ) // RIGHT ( vertically ) + { + // Align the ruby text and base text to the vertical center. + nYBase = ( aWinSize.Height() - nTextHeight ) / 2; + nYRuby = ( aWinSize.Height() - nRubyWidth ) / 2; + + // Align the ruby text at the right side of the base text + nAdjust = RubyAdjust_RIGHT; + nHalfWidth = nBaseWidth / 2; + nLeftStart = nCenter - nHalfWidth; + nRightEnd = nCenter + nHalfWidth + nRubyWidth + nTextHeight; + // Render base text first, then render ruby text on the right. + bRubyStretch = true; + + aRubyFont.SetVertical(true); + aRubyFont.SetOrientation(2700); + } + + long nYOutput; + long nOutTextWidth; + OUString sOutputText; + + if (bRubyStretch) + { + rRenderContext.DrawText(Point(nLeftStart , nYBase), sBaseText); + nYOutput = nYRuby; + sOutputText = sRubyText; + nOutTextWidth = nRubyWidth; + rRenderContext.SetFont(aRubyFont); + } + else + { + rRenderContext.SetFont(aRubyFont); + rRenderContext.DrawText(Point(nLeftStart , nYRuby), sRubyText); + nYOutput = nYBase; + sOutputText = sBaseText; + nOutTextWidth = nBaseWidth; + rRenderContext.SetFont(aFont); + } + + switch (nAdjust) + { + case RubyAdjust_LEFT: + rRenderContext.DrawText(Point(nLeftStart , nYOutput), sOutputText); + break; + case RubyAdjust_RIGHT: + rRenderContext.DrawText(Point(nRightEnd - nOutTextWidth, nYOutput), sOutputText); + break; + case RubyAdjust_INDENT_BLOCK: + { + long nCharWidth = rRenderContext.GetTextWidth("X"); + if (nOutTextWidth < (nRightEnd - nLeftStart - nCharWidth)) + { + nCharWidth /= 2; + nLeftStart += nCharWidth; + nRightEnd -= nCharWidth; + } + [[fallthrough]]; + } + case RubyAdjust_BLOCK: + { + if (sOutputText.getLength() > 1) + { + sal_Int32 nCount = sOutputText.getLength(); + long nSpace = ((nRightEnd - nLeftStart) - rRenderContext.GetTextWidth(sOutputText)) / (nCount - 1); + for (sal_Int32 i = 0; i < nCount; i++) + { + OUString sChar(sOutputText[i]); + rRenderContext.DrawText(Point(nLeftStart , nYOutput), sChar); + long nCharWidth = rRenderContext.GetTextWidth(sChar); + nLeftStart += nCharWidth + nSpace; + } + break; + } + [[fallthrough]]; + } + case RubyAdjust_CENTER: + rRenderContext.DrawText(Point(nCenter - nOutTextWidth / 2 , nYOutput), sOutputText); + break; + default: break; + } + rRenderContext.Pop(); +} + +void RubyPreview::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + pDrawingArea->set_size_request(pDrawingArea->get_approximate_digit_width() * 40, + pDrawingArea->get_text_height() * 7); + CustomWidgetController::SetDrawingArea(pDrawingArea); +} + +IMPL_LINK(SvxRubyDialog, KeyUpDownHdl_Impl, const KeyEvent&, rKEvt, bool) +{ + bool bHandled = false; + const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode(); + sal_uInt16 nCode = rKeyCode.GetCode(); + if (KEY_UP == nCode || KEY_DOWN == nCode) + { + sal_Int32 nParam = KEY_UP == nCode ? -1 : 1; + bHandled = EditJumpHdl_Impl(nParam); + } + return bHandled; +} + +IMPL_LINK(SvxRubyDialog, KeyUpDownTabHdl_Impl, const KeyEvent&, rKEvt, bool) +{ + bool bHandled = false; + const vcl::KeyCode& rKeyCode = rKEvt.GetKeyCode(); + sal_uInt16 nMod = rKeyCode.GetModifier(); + sal_uInt16 nCode = rKeyCode.GetCode(); + if (nCode == KEY_TAB && (!nMod || KEY_SHIFT == nMod)) + { + sal_Int32 nParam = KEY_SHIFT == nMod ? -1 : 1; + if (EditScrollHdl_Impl(nParam)) + bHandled = true; + } + if (!bHandled) + bHandled = KeyUpDownHdl_Impl(rKEvt); + return bHandled; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/rulritem.cxx b/svx/source/dialog/rulritem.cxx new file mode 100644 index 000000000..eb2a0f7a6 --- /dev/null +++ b/svx/source/dialog/rulritem.cxx @@ -0,0 +1,731 @@ +/* -*- 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/rulritem.hxx> +#include <svx/unomid.hxx> +#include <tools/debug.hxx> +#include <tools/mapunit.hxx> +#include <osl/diagnose.h> +#include <sal/log.hxx> +#include <com/sun/star/awt/Rectangle.hpp> +#include <com/sun/star/frame/status/LeftRightMargin.hpp> +#include <com/sun/star/frame/status/UpperLowerMargin.hpp> + +SfxPoolItem* SvxPagePosSizeItem::CreateDefault() { return new SvxPagePosSizeItem; } +SfxPoolItem* SvxLongLRSpaceItem::CreateDefault() { return new SvxLongLRSpaceItem; } +SfxPoolItem* SvxLongULSpaceItem::CreateDefault() { return new SvxLongULSpaceItem; } +SfxPoolItem* SvxColumnItem::CreateDefault() { return new SvxColumnItem; } +SfxPoolItem* SvxObjectItem::CreateDefault() { SAL_WARN( "svx", "No SvxObjectItem factory available"); return nullptr; } + +/* SvxLongLRSpaceItem */ + +bool SvxLongLRSpaceItem::operator==( const SfxPoolItem& rCmp) const +{ + return SfxPoolItem::operator==(rCmp) && + mlLeft == static_cast<const SvxLongLRSpaceItem &>(rCmp).mlLeft && + mlRight == static_cast<const SvxLongLRSpaceItem &>(rCmp).mlRight; +} + +bool SvxLongLRSpaceItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); + nMemberId &= ~CONVERT_TWIPS; + + sal_Int32 nVal; + switch( nMemberId ) + { + case 0: + { + css::frame::status::LeftRightMargin aLeftRightMargin; + aLeftRightMargin.Left = bConvert ? convertTwipToMm100( mlLeft ) : mlLeft; + aLeftRightMargin.Right = bConvert ? convertTwipToMm100( mlRight ) : mlRight; + rVal <<= aLeftRightMargin; + return true; + } + + case MID_LEFT: + nVal = mlLeft; + break; + case MID_RIGHT: + nVal = mlRight; + break; + default: + OSL_FAIL("Wrong MemberId!"); + return false; + } + + if ( bConvert ) + nVal = convertTwipToMm100( nVal ); + + rVal <<= nVal; + return true; +} + +bool SvxLongLRSpaceItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); + nMemberId &= ~CONVERT_TWIPS; + + sal_Int32 nVal = 0; + if ( nMemberId == 0 ) + { + css::frame::status::LeftRightMargin aLeftRightMargin; + if ( rVal >>= aLeftRightMargin ) + { + mlLeft = bConvert ? convertMm100ToTwip(aLeftRightMargin.Left) : aLeftRightMargin.Left; + mlRight = bConvert ? convertMm100ToTwip(aLeftRightMargin.Right) : aLeftRightMargin.Right; + return true; + } + } + else if ( rVal >>= nVal ) + { + if ( bConvert ) + nVal = convertMm100ToTwip( nVal ); + + switch( nMemberId ) + { + case MID_LEFT: + mlLeft = nVal; + break; + case MID_RIGHT: + mlRight = nVal; + break; + default: + OSL_FAIL("Wrong MemberId!"); + return false; + } + + return true; + } + + return false; +} + +bool SvxLongLRSpaceItem::GetPresentation( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& /*rText*/, + const IntlWrapper& /*rWrapper*/) const +{ + return false; +} + +SvxLongLRSpaceItem* SvxLongLRSpaceItem::Clone(SfxItemPool *) const +{ + return new SvxLongLRSpaceItem(*this); +} + +SvxLongLRSpaceItem::SvxLongLRSpaceItem(long lLeft, long lRight, sal_uInt16 nId) : + SfxPoolItem (nId), + mlLeft (lLeft), + mlRight (lRight) +{} + +SvxLongLRSpaceItem::SvxLongLRSpaceItem() : + SfxPoolItem (0), + mlLeft (0), + mlRight (0) +{} + +void SvxLongLRSpaceItem::SetLeft(long lArgLeft) +{ + mlLeft = lArgLeft; +} + +void SvxLongLRSpaceItem::SetRight(long lArgRight) +{ + mlRight = lArgRight; +} + +/* SvxLongULSpaceItem */ + +bool SvxLongULSpaceItem::operator==( const SfxPoolItem& rCmp) const +{ + return SfxPoolItem::operator==(rCmp) && + mlLeft == static_cast<const SvxLongULSpaceItem&>(rCmp).mlLeft && + mlRight == static_cast<const SvxLongULSpaceItem&>(rCmp).mlRight; +} + +bool SvxLongULSpaceItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); + nMemberId &= ~CONVERT_TWIPS; + + sal_Int32 nVal; + switch( nMemberId ) + { + case 0: + { + css::frame::status::UpperLowerMargin aUpperLowerMargin; + aUpperLowerMargin.Upper = bConvert ? convertTwipToMm100( mlLeft ) : mlLeft; + aUpperLowerMargin.Lower = bConvert ? convertTwipToMm100( mlRight ) : mlRight; + rVal <<= aUpperLowerMargin; + return true; + } + + case MID_UPPER: + nVal = mlLeft; + break; + case MID_LOWER: + nVal = mlRight; + break; + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + if ( bConvert ) + nVal = convertTwipToMm100( nVal ); + + rVal <<= nVal; + return true; +} + +bool SvxLongULSpaceItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + bool bConvert = 0!=(nMemberId&CONVERT_TWIPS); + nMemberId &= ~CONVERT_TWIPS; + + sal_Int32 nVal = 0; + if ( nMemberId == 0 ) + { + css::frame::status::UpperLowerMargin aUpperLowerMargin; + if ( rVal >>= aUpperLowerMargin ) + { + mlLeft = bConvert ? convertMm100ToTwip( aUpperLowerMargin.Upper ) : aUpperLowerMargin.Upper; + mlRight = bConvert ? convertMm100ToTwip( aUpperLowerMargin.Lower ) : aUpperLowerMargin.Lower; + return true; + } + } + else if ( rVal >>= nVal ) + { + if ( bConvert ) + nVal = convertMm100ToTwip( nVal ); + + switch( nMemberId ) + { + case MID_UPPER: + mlLeft = nVal; + break; + case MID_LOWER: + mlRight = nVal; + break; + default: + OSL_FAIL("Wrong MemberId!"); + return false; + } + + return true; + } + + return false; +} + +bool SvxLongULSpaceItem::GetPresentation( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& /*rText*/, + const IntlWrapper& /*rWrapper*/ ) const +{ + return false; +} + +SvxLongULSpaceItem* SvxLongULSpaceItem::Clone(SfxItemPool *) const +{ + return new SvxLongULSpaceItem(*this); +} + +SvxLongULSpaceItem::SvxLongULSpaceItem(long lLeft, long lRight, sal_uInt16 nId) : + SfxPoolItem (nId), + mlLeft (lLeft), + mlRight (lRight) +{} + +SvxLongULSpaceItem::SvxLongULSpaceItem() : + SfxPoolItem (0), + mlLeft (0), + mlRight (0) +{} + + +void SvxLongULSpaceItem::SetUpper(long lArgLeft) +{ + mlLeft = lArgLeft; +} + +void SvxLongULSpaceItem::SetLower(long lArgRight) +{ + mlRight = lArgRight; +} + +/* SvxPagePosSizeItem */ + +bool SvxPagePosSizeItem::operator==( const SfxPoolItem& rCmp) const +{ + return SfxPoolItem::operator==(rCmp) && + aPos == static_cast<const SvxPagePosSizeItem &>(rCmp).aPos && + lWidth == static_cast<const SvxPagePosSizeItem &>(rCmp).lWidth && + lHeight == static_cast<const SvxPagePosSizeItem &>(rCmp).lHeight; +} + +bool SvxPagePosSizeItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + + sal_Int32 nVal; + switch ( nMemberId ) + { + case 0 : + { + css::awt::Rectangle aPagePosSize; + aPagePosSize.X = aPos.X(); + aPagePosSize.Y = aPos.Y(); + aPagePosSize.Width = lWidth; + aPagePosSize.Height = lHeight; + rVal <<= aPagePosSize; + return true; + } + + case MID_X: nVal = aPos.X(); break; + case MID_Y: nVal = aPos.Y(); break; + case MID_WIDTH: nVal = lWidth; break; + case MID_HEIGHT: nVal = lHeight; break; + + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + rVal <<= nVal; + return true; +} + +bool SvxPagePosSizeItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + + sal_Int32 nVal = 0; + if ( nMemberId == 0 ) + { + css::awt::Rectangle aPagePosSize; + if ( rVal >>= aPagePosSize ) + { + aPos.setX( aPagePosSize.X ); + aPos.setY( aPagePosSize.Y ); + lWidth = aPagePosSize.Width; + lHeight = aPagePosSize.Height; + return true; + } + else + return false; + } + else if ( rVal >>= nVal ) + { + switch ( nMemberId ) + { + case MID_X: aPos.setX( nVal ); break; + case MID_Y: aPos.setY( nVal ); break; + case MID_WIDTH: lWidth = nVal; break; + case MID_HEIGHT: lHeight = nVal; break; + + default: OSL_FAIL("Wrong MemberId!"); return false; + } + + return true; + } + + return false; +} + +bool SvxPagePosSizeItem::GetPresentation( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& /*rText*/, + const IntlWrapper& /*rWrapper*/ ) const +{ + return false; +} + +SvxPagePosSizeItem* SvxPagePosSizeItem::Clone(SfxItemPool *) const +{ + return new SvxPagePosSizeItem(*this); +} + +SvxPagePosSizeItem::SvxPagePosSizeItem(const Point &rP, long lW, long lH) : + SfxPoolItem (SID_RULER_PAGE_POS), + aPos (rP), + lWidth (lW), + lHeight (lH) +{} + +SvxPagePosSizeItem::SvxPagePosSizeItem() : + SfxPoolItem (0), + aPos (0, 0), + lWidth (0), + lHeight (0) +{} + +/* SvxColumnItem */ + +bool SvxColumnItem::operator==(const SfxPoolItem& rCmp) const +{ + if(!SfxPoolItem::operator==(rCmp) || + nActColumn != static_cast<const SvxColumnItem&>(rCmp).nActColumn || + nLeft != static_cast<const SvxColumnItem&>(rCmp).nLeft || + nRight != static_cast<const SvxColumnItem&>(rCmp).nRight || + bTable != static_cast<const SvxColumnItem&>(rCmp).bTable || + Count() != static_cast<const SvxColumnItem&>(rCmp).Count()) + return false; + + const sal_uInt16 nCount = static_cast<const SvxColumnItem&>(rCmp).Count(); + for(sal_uInt16 i = 0; i < nCount;++i) + { + if( (*this)[i] != static_cast<const SvxColumnItem&>(rCmp)[i] ) + return false; + } + return true; +} + +SvxColumnItem::SvxColumnItem( sal_uInt16 nAct ) : + SfxPoolItem (SID_RULER_BORDERS), + nLeft (0), + nRight (0), + nActColumn (nAct), + bTable (false), + bOrtho (true) + +{} + +SvxColumnItem::SvxColumnItem( sal_uInt16 nActCol, sal_uInt16 left, sal_uInt16 right ) : + SfxPoolItem (SID_RULER_BORDERS), + nLeft (left), + nRight (right), + nActColumn (nActCol), + bTable (true), + bOrtho (true) +{} + +bool SvxColumnItem::GetPresentation( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& /*rText*/, + const IntlWrapper& /*rWrapper*/ ) const +{ + return false; +} + +SvxColumnItem* SvxColumnItem::Clone(SfxItemPool* /*pPool*/) const +{ + return new SvxColumnItem(*this); +} + +bool SvxColumnItem::CalcOrtho() const +{ + const sal_uInt16 nCount = Count(); + DBG_ASSERT(nCount >= 2, "no columns"); + if(nCount < 2) + return false; + + long nColWidth = (*this)[0].GetWidth(); + for(sal_uInt16 i = 1; i < nCount; ++i) { + if( (*this)[i].GetWidth() != nColWidth) + return false; + } + //!! Wide divider + return true; +} + +bool SvxColumnItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + switch ( nMemberId ) + { + case MID_COLUMNARRAY: + return false; + case MID_RIGHT: + rVal <<= nRight; + break; + case MID_LEFT: + rVal <<= nLeft; + break; + case MID_ORTHO: + rVal <<= bOrtho; + break; + case MID_ACTUAL: + rVal <<= static_cast<sal_Int32>(nActColumn); + break; + case MID_TABLE: + rVal <<= bTable; + break; + default: + // SfxDispatchController_Impl::StateChanged calls this with hardcoded 0 triggering this; + OSL_FAIL("Wrong MemberId!"); + return false; + } + + return true; +} + +bool SvxColumnItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + sal_Int32 nVal = 0; + switch ( nMemberId ) + { + case MID_COLUMNARRAY: + { + return false; + } + case MID_RIGHT: + rVal >>= nRight; + break; + case MID_LEFT: + rVal >>= nLeft; + break; + case MID_ORTHO: + rVal >>= nVal; + bOrtho = static_cast<bool>(nVal); + break; + case MID_ACTUAL: + rVal >>= nVal; + nActColumn = static_cast<sal_uInt16>(nVal); + break; + case MID_TABLE: + rVal >>= nVal; + bTable = static_cast<bool>(nVal); + break; + default: + OSL_FAIL("Wrong MemberId!"); + return false; + } + + return true; +} + +sal_uInt16 SvxColumnItem::Count() const +{ + return aColumns.size(); +} + +SvxColumnDescription& SvxColumnItem::At(sal_uInt16 index) +{ + return aColumns[index]; +} + +SvxColumnDescription& SvxColumnItem::GetActiveColumnDescription() +{ + return aColumns[GetActColumn()]; +} + +SvxColumnDescription& SvxColumnItem::operator[](sal_uInt16 index) +{ + return aColumns[index]; +} + +const SvxColumnDescription& SvxColumnItem::operator[](sal_uInt16 index) const +{ + return aColumns[index]; +} + +void SvxColumnItem::Append(const SvxColumnDescription &rDesc) +{ + aColumns.push_back(rDesc); +} + +void SvxColumnItem::SetLeft(long left) +{ + nLeft = left; +} + +void SvxColumnItem::SetRight(long right) +{ + nRight = right; +} + + +bool SvxColumnItem::IsFirstAct() const +{ + return nActColumn == 0; +} + +bool SvxColumnItem::IsLastAct() const +{ + return nActColumn == Count() - 1; +} + +SvxColumnDescription::SvxColumnDescription(long start, long end, bool bVis) : + nStart (start), + nEnd (end), + bVisible (bVis), + nEndMin (0), + nEndMax (0) +{} + +SvxColumnDescription::SvxColumnDescription(long start, long end, long endMin, long endMax, bool bVis) : + nStart (start), + nEnd (end), + bVisible (bVis), + // fdo#85858 hack: clamp these to smaller value to prevent overflow + nEndMin(std::min<long>(endMin, std::numeric_limits<unsigned short>::max())), + nEndMax(std::min<long>(endMax, std::numeric_limits<unsigned short>::max())) +{} + +bool SvxColumnDescription::operator==(const SvxColumnDescription& rCmp) const +{ + return nStart == rCmp.nStart + && bVisible == rCmp.bVisible + && nEnd == rCmp.nEnd + && nEndMin == rCmp.nEndMin + && nEndMax == rCmp.nEndMax; +} + +bool SvxColumnDescription::operator!=(const SvxColumnDescription& rCmp) const +{ + return !operator==(rCmp); +} + +long SvxColumnDescription::GetWidth() const +{ + return nEnd - nStart; +} + +/* SvxColumnItem */ +void SvxColumnItem::SetOrtho(bool bVal) +{ + bOrtho = bVal; +} + +bool SvxColumnItem::IsConsistent() const +{ + return nActColumn < aColumns.size(); +} + +bool SvxObjectItem::operator==( const SfxPoolItem& rCmp ) const +{ + return SfxPoolItem::operator==(rCmp) && + nStartX == static_cast<const SvxObjectItem&>(rCmp).nStartX && + nEndX == static_cast<const SvxObjectItem&>(rCmp).nEndX && + nStartY == static_cast<const SvxObjectItem&>(rCmp).nStartY && + nEndY == static_cast<const SvxObjectItem&>(rCmp).nEndY && + bLimits == static_cast<const SvxObjectItem&>(rCmp).bLimits; +} + +bool SvxObjectItem::GetPresentation( + SfxItemPresentation /*ePres*/, + MapUnit /*eCoreUnit*/, + MapUnit /*ePresUnit*/, + OUString& /*rText*/, + const IntlWrapper& /*rWrapper*/ ) const +{ + return false; +} + +SvxObjectItem* SvxObjectItem::Clone(SfxItemPool *) const +{ + return new SvxObjectItem(*this); +} + +SvxObjectItem::SvxObjectItem( long nSX, long nEX, + long nSY, long nEY ) : + SfxPoolItem (SID_RULER_OBJECT), + nStartX (nSX), + nEndX (nEX), + nStartY (nSY), + nEndY (nEY), + bLimits (false) +{} + +bool SvxObjectItem::QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId ) const +{ + nMemberId &= ~CONVERT_TWIPS; + switch (nMemberId) + { + case MID_START_X: + rVal <<= nStartX; + break; + case MID_START_Y: + rVal <<= nStartY; + break; + case MID_END_X: + rVal <<= nEndX; + break; + case MID_END_Y: + rVal <<= nEndY; + break; + case MID_LIMIT: + rVal <<= bLimits; + break; + default: + OSL_FAIL( "Wrong MemberId" ); + return false; + } + + return true; +} + +bool SvxObjectItem::PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) +{ + nMemberId &= ~CONVERT_TWIPS; + bool bRet = false; + switch (nMemberId) + { + case MID_START_X: + bRet = (rVal >>= nStartX); + break; + case MID_START_Y: + bRet = (rVal >>= nStartY); + break; + case MID_END_X: + bRet = (rVal >>= nEndX); + break; + case MID_END_Y: + bRet = (rVal >>= nEndY); + break; + case MID_LIMIT: + bRet = (rVal >>= bLimits); + break; + default: OSL_FAIL( "Wrong MemberId" ); + } + + return bRet; +} + + +void SvxObjectItem::SetStartX(long lValue) +{ + nStartX = lValue; +} + +void SvxObjectItem::SetEndX(long lValue) +{ + nEndX = lValue; +} + +void SvxObjectItem::SetStartY(long lValue) +{ + nStartY = lValue; +} + +void SvxObjectItem::SetEndY(long lValue) +{ + nEndY = lValue; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/samecontentlistbox.cxx b/svx/source/dialog/samecontentlistbox.cxx new file mode 100644 index 000000000..66c628a1e --- /dev/null +++ b/svx/source/dialog/samecontentlistbox.cxx @@ -0,0 +1,39 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/samecontentlistbox.hxx> +#include <samecontent.hrc> + +namespace SameContentListBox +{ + void Fill(weld::ComboBox& rComboBox) + { + rComboBox.clear(); + for (size_t i = 0; i < SAL_N_ELEMENTS(RID_SVXSTRARY_SAMECONTENT); ++i) + { + OUString aStr = SvxResId(RID_SVXSTRARY_SAMECONTENT[i].first); + sal_uInt32 nData = RID_SVXSTRARY_SAMECONTENT[i].second; + rComboBox.append(OUString::number(nData), aStr); + } + rComboBox.set_active(0); + rComboBox.set_size_request(150, -1); + } +} +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/searchcharmap.cxx b/svx/source/dialog/searchcharmap.cxx new file mode 100644 index 000000000..1cdb3cfc0 --- /dev/null +++ b/svx/source/dialog/searchcharmap.cxx @@ -0,0 +1,430 @@ +/* -*- 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/event.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <vcl/virdev.hxx> + +#include <svx/ucsubset.hxx> +#include <unordered_map> + +#include <svx/searchcharmap.hxx> + +#include <charmapacc.hxx> + +#include <rtl/ustrbuf.hxx> + +using namespace ::com::sun::star::accessibility; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star; + + +SvxSearchCharSet::SvxSearchCharSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow, const VclPtr<VirtualDevice>& rVirDev) + : SvxShowCharSet(std::move(pScrolledWindow), rVirDev) + , nCount(0) +{ +} + +int SvxSearchCharSet::LastInView() const +{ + int nIndex = FirstInView(); + nIndex += ROW_COUNT * COLUMN_COUNT - 1; + int nCompare = nCount - 1; + if (nIndex > nCompare) + nIndex = nCompare; + return nIndex; +} + +bool SvxSearchCharSet::KeyInput(const KeyEvent& rKEvt) +{ + vcl::KeyCode aCode = rKEvt.GetKeyCode(); + + if (aCode.GetModifier()) + return false; + + int tmpSelected = nSelectedIndex; + + bool bRet = true; + + switch (aCode.GetCode()) + { + case KEY_SPACE: + aSelectHdl.Call( this ); + break; + case KEY_LEFT: + --tmpSelected; + break; + case KEY_RIGHT: + ++tmpSelected; + break; + case KEY_UP: + tmpSelected -= COLUMN_COUNT; + break; + case KEY_DOWN: + tmpSelected += COLUMN_COUNT; + break; + case KEY_PAGEUP: + tmpSelected -= ROW_COUNT * COLUMN_COUNT; + break; + case KEY_PAGEDOWN: + tmpSelected += ROW_COUNT * COLUMN_COUNT; + break; + case KEY_HOME: + tmpSelected = 0; + break; + case KEY_END: + tmpSelected = nCount - 1; + break; + case KEY_TAB: // some fonts have a character at these unicode control codes + case KEY_ESCAPE: + case KEY_RETURN: + bRet = false; + tmpSelected = - 1; // mark as invalid + break; + default: + tmpSelected = -1; + bRet = false; + break; + } + + if ( tmpSelected >= 0 ) + { + SelectIndex( tmpSelected, true ); + aPreSelectHdl.Call( this ); + } + + return bRet; +} + +void SvxSearchCharSet::SelectCharacter( const Subset* sub ) +{ + if (!mxFontCharMap.is()) + RecalculateFont(*mxVirDev); + + // get next available char of current font + sal_UCS4 cChar = sub->GetRangeMin(); + int nMapIndex = 0; + + while(cChar <= sub->GetRangeMax() && nMapIndex == 0) + { + auto it = std::find_if(m_aItemList.begin(), m_aItemList.end(), + [&cChar](const std::pair<const sal_Int32, sal_UCS4>& rItem) { return rItem.second == cChar; }); + if (it != m_aItemList.end()) + nMapIndex = it->first; + cChar++; + } + + if(nMapIndex == 0) + SelectIndex( 0 ); + else + SelectIndex( nMapIndex ); + aHighHdl.Call(this); + // move selected item to top row if not in focus + //TO.DO aVscrollSB->SetThumbPos( nMapIndex / COLUMN_COUNT ); + Invalidate(); +} + +void SvxSearchCharSet::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + InitSettings(rRenderContext); + RecalculateFont(rRenderContext); + DrawChars_Impl(rRenderContext, FirstInView(), LastInView()); +} + +void SvxSearchCharSet::DrawChars_Impl(vcl::RenderContext& rRenderContext, int n1, int n2) +{ + if (n1 > LastInView() || n2 < FirstInView()) + return; + + Size aOutputSize(GetOutputSizePixel()); + + int i; + for (i = 1; i < COLUMN_COUNT; ++i) + { + rRenderContext.DrawLine(Point(nX * i + m_nXGap, 0), + Point(nX * i + m_nXGap, aOutputSize.Height())); + } + for (i = 1; i < ROW_COUNT; ++i) + { + rRenderContext.DrawLine(Point(0, nY * i + m_nYGap), + Point(aOutputSize.Width(), nY * i + m_nYGap)); + } + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + const Color aWindowTextColor(rStyleSettings.GetFieldTextColor()); + Color aHighlightColor(rStyleSettings.GetHighlightColor()); + Color aHighlightTextColor(rStyleSettings.GetHighlightTextColor()); + Color aFaceColor(rStyleSettings.GetFaceColor()); + Color aLightColor(rStyleSettings.GetLightColor()); + Color aShadowColor(rStyleSettings.GetShadowColor()); + + int nTextHeight = rRenderContext.GetTextHeight(); + tools::Rectangle aBoundRect; + for (i = n1; i <= n2; ++i) + { + Point pix = MapIndexToPixel(i); + int x = pix.X(); + int y = pix.Y(); + + OUStringBuffer buf; + std::unordered_map<sal_Int32, sal_UCS4>::const_iterator got = m_aItemList.find (i); + sal_UCS4 sName; + + if(got == m_aItemList.end()) + continue; + else + sName = got->second; + + buf.appendUtf32(sName); + OUString aCharStr(buf.makeStringAndClear()); + int nTextWidth = rRenderContext.GetTextWidth(aCharStr); + int tx = x + (nX - nTextWidth + 1) / 2; + int ty = y + (nY - nTextHeight + 1) / 2; + Point aPointTxTy(tx, ty); + + // adjust position before it gets out of bounds + if (rRenderContext.GetTextBoundRect(aBoundRect, aCharStr) && !aBoundRect.IsEmpty()) + { + // zero advance width => use ink width to center glyph + if (!nTextWidth) + { + aPointTxTy.setX( x - aBoundRect.Left() + (nX - aBoundRect.GetWidth() + 1) / 2 ); + } + + aBoundRect += aPointTxTy; + + // shift back vertically if needed + int nYLDelta = aBoundRect.Top() - y; + int nYHDelta = (y + nY) - aBoundRect.Bottom(); + if (nYLDelta <= 0) + aPointTxTy.AdjustY( -(nYLDelta - 1) ); + else if (nYHDelta <= 0) + aPointTxTy.AdjustY(nYHDelta - 1 ); + + // shift back horizontally if needed + int nXLDelta = aBoundRect.Left() - x; + int nXHDelta = (x + nX) - aBoundRect.Right(); + if (nXLDelta <= 0) + aPointTxTy.AdjustX( -(nXLDelta - 1) ); + else if (nXHDelta <= 0) + aPointTxTy.AdjustX(nXHDelta - 1 ); + } + + Color aTextCol = rRenderContext.GetTextColor(); + if (i != nSelectedIndex) + { + rRenderContext.SetTextColor(aWindowTextColor); + rRenderContext.DrawText(aPointTxTy, aCharStr); + } + else + { + Color aLineCol = rRenderContext.GetLineColor(); + Color aFillCol = rRenderContext.GetFillColor(); + rRenderContext.SetLineColor(); + Point aPointUL(x + 1, y + 1); + if (HasFocus()) + { + rRenderContext.SetFillColor(aHighlightColor); + rRenderContext.DrawRect(getGridRectangle(aPointUL, aOutputSize)); + + rRenderContext.SetTextColor(aHighlightTextColor); + rRenderContext.DrawText(aPointTxTy, aCharStr); + } + else + { + rRenderContext.SetFillColor(aFaceColor); + rRenderContext.DrawRect(getGridRectangle(aPointUL, aOutputSize)); + + rRenderContext.SetLineColor(aLightColor); + rRenderContext.DrawLine(aPointUL, Point(x + nX - 1, y + 1)); + rRenderContext.DrawLine(aPointUL, Point(x + 1, y + nY - 1)); + + rRenderContext.SetLineColor(aShadowColor); + rRenderContext.DrawLine(Point(x + 1, y + nY - 1), Point(x + nX - 1, y + nY - 1)); + rRenderContext.DrawLine(Point(x + nX - 1, y + nY - 1), Point(x + nX - 1, y + 1)); + + rRenderContext.DrawText(aPointTxTy, aCharStr); + } + rRenderContext.SetLineColor(aLineCol); + rRenderContext.SetFillColor(aFillCol); + } + rRenderContext.SetTextColor(aTextCol); + } +} + +sal_UCS4 SvxSearchCharSet::GetSelectCharacter() const +{ + if( nSelectedIndex >= 0 ) + { + std::unordered_map<sal_Int32,sal_UCS4>::const_iterator got = m_aItemList.find (nSelectedIndex); + + if(got == m_aItemList.end()) + return 1; + else + return got->second; + } + return 1; +} + +void SvxSearchCharSet::RecalculateFont(vcl::RenderContext& rRenderContext) +{ + if (!mbRecalculateFont) + return; + + Size aSize(GetOutputSizePixel()); + + vcl::Font aFont = rRenderContext.GetFont(); + aFont.SetWeight(WEIGHT_LIGHT); + aFont.SetAlignment(ALIGN_TOP); + int nFontHeight = (aSize.Height() - 5) * 2 / (3 * ROW_COUNT); + maFontSize = rRenderContext.PixelToLogic(Size(0, nFontHeight)); + aFont.SetFontSize(maFontSize); + aFont.SetTransparent(true); + rRenderContext.SetFont(aFont); + rRenderContext.GetFontCharMap(mxFontCharMap); + getFavCharacterList(); + + nX = aSize.Width() / COLUMN_COUNT; + nY = aSize.Height() / ROW_COUNT; + + //scrollbar settings -- error + int nLastRow = (nCount - 1 + COLUMN_COUNT) / COLUMN_COUNT; + mxScrollArea->vadjustment_configure(mxScrollArea->vadjustment_get_value(), 0, nLastRow, 1, ROW_COUNT - 1, ROW_COUNT); + + // rearrange CharSet element in sync with nX- and nY-multiples + Size aDrawSize(nX * COLUMN_COUNT, nY * ROW_COUNT); + m_nXGap = (aSize.Width() - aDrawSize.Width()) / 2; + m_nYGap = (aSize.Height() - aDrawSize.Height()) / 2; + + mbRecalculateFont = false; +} + +void SvxSearchCharSet::SelectIndex(int nNewIndex, bool bFocus) +{ + if (!mxFontCharMap.is()) + RecalculateFont(*mxVirDev); + + if( nNewIndex < 0 ) + { + mxScrollArea->vadjustment_set_value(0); + nSelectedIndex = bFocus ? 0 : -1; + Invalidate(); + } + else if( nNewIndex < FirstInView() ) + { + // need to scroll up to see selected item + int nOldPos = mxScrollArea->vadjustment_get_value(); + int nDelta = (FirstInView() - nNewIndex + COLUMN_COUNT-1) / COLUMN_COUNT; + mxScrollArea->vadjustment_set_value(nOldPos - nDelta); + nSelectedIndex = nNewIndex; + Invalidate(); + } + else if( nNewIndex > LastInView() ) + { + // need to scroll down to see selected item + int nOldPos = mxScrollArea->vadjustment_get_value(); + int nDelta = (nNewIndex - LastInView() + COLUMN_COUNT) / COLUMN_COUNT; + mxScrollArea->vadjustment_set_value(nOldPos + nDelta); + + if( nNewIndex < nCount ) + { + nSelectedIndex = nNewIndex; + Invalidate(); + } + else if (nOldPos != mxScrollArea->vadjustment_get_value()) + { + Invalidate(); + } + } + else + { + nSelectedIndex = nNewIndex; + Invalidate(); + } + + if( nSelectedIndex >= 0 ) + { +#if 0 + if( m_xAccessible.is() ) + { + svx::SvxShowCharSetItem* pItem = ImplGetItem(nSelectedIndex); + // Don't fire the focus event. + if ( bFocus ) + m_xAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), makeAny(pItem->GetAccessible()) ); // this call assures that m_pItem is set + else + m_xAccessible->fireEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED_NOFOCUS, Any(), makeAny(pItem->GetAccessible()) ); // this call assures that m_pItem is set + + assert(pItem->m_xItem.is() && "No accessible created!"); + Any aOldAny, aNewAny; + aNewAny <<= AccessibleStateType::FOCUSED; + // Don't fire the focus event. + if ( bFocus ) + pItem->m_xItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny ); + + aNewAny <<= AccessibleStateType::SELECTED; + pItem->m_xItem->fireEvent( AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny ); + } +#endif + } + aHighHdl.Call( this ); +} + +SvxSearchCharSet::~SvxSearchCharSet() +{ +} + +svx::SvxShowCharSetItem* SvxSearchCharSet::ImplGetItem( int _nPos ) +{ + ItemsMap::iterator aFind = m_aItems.find(_nPos); + if ( aFind == m_aItems.end() ) + { + OSL_ENSURE(m_xAccessible.is(), "Who wants to create a child of my table without a parent?"); + auto xItem = std::make_shared<svx::SvxShowCharSetItem>(*this, + m_xAccessible.get(), sal::static_int_cast< sal_uInt16 >(_nPos)); + aFind = m_aItems.emplace(_nPos, xItem).first; + OUStringBuffer buf; + std::unordered_map<sal_Int32,sal_UCS4>::const_iterator got = m_aItemList.find (_nPos); + if (got != m_aItemList.end()) + buf.appendUtf32(got->second); + aFind->second->maText = buf.makeStringAndClear(); + Point pix = MapIndexToPixel( _nPos ); + aFind->second->maRect = tools::Rectangle( Point( pix.X() + 1, pix.Y() + 1 ), Size(nX-1,nY-1) ); + } + + return aFind->second.get(); +} + +sal_Int32 SvxSearchCharSet::getMaxCharCount() const +{ + return nCount; +} + +void SvxSearchCharSet::ClearPreviousData() +{ + m_aItemList.clear(); + nCount = 0; + Invalidate(); +} + +void SvxSearchCharSet::AppendCharToList(sal_UCS4 sChar) +{ + m_aItemList.insert(std::make_pair(nCount++, sChar)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/spacinglistbox.cxx b/svx/source/dialog/spacinglistbox.cxx new file mode 100644 index 000000000..90cc689cc --- /dev/null +++ b/svx/source/dialog/spacinglistbox.cxx @@ -0,0 +1,76 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/spacinglistbox.hxx> +#include <unotools/localedatawrapper.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> +#include <spacing.hrc> + +namespace SpacingListBox +{ + void Fill(SpacingType eType, weld::ComboBox& rComboBox) + { + auto nSelected = rComboBox.get_active(); + if (nSelected == -1) + nSelected = 0; + rComboBox.clear(); + + const LocaleDataWrapper& rLocaleData = Application::GetSettings().GetLocaleDataWrapper(); + OUString sSuffix; + + const measurement* pResources; + switch (eType) + { + case SpacingType::SPACING_INCH: + pResources = RID_SVXSTRARY_SPACING_INCH; + sSuffix = weld::MetricSpinButton::MetricToString(FieldUnit::INCH); + break; + case SpacingType::MARGINS_INCH: + pResources = RID_SVXSTRARY_MARGINS_INCH; + sSuffix = weld::MetricSpinButton::MetricToString(FieldUnit::INCH); + break; + case SpacingType::SPACING_CM: + pResources = RID_SVXSTRARY_SPACING_CM; + sSuffix = " " + weld::MetricSpinButton::MetricToString(FieldUnit::CM); + break; + default: + case SpacingType::MARGINS_CM: + sSuffix = " " + weld::MetricSpinButton::MetricToString(FieldUnit::CM); + pResources = RID_SVXSTRARY_MARGINS_CM; + break; + } + + while (pResources->key) + { + OUString sMeasurement = rLocaleData.getNum(pResources->human, 2, true, false) + sSuffix; + OUString aStr = SvxResId(pResources->key).replaceFirst("%1", sMeasurement); + sal_uInt32 nData = pResources->twips; + rComboBox.append(OUString::number(nData), aStr); + ++pResources; + } + + rComboBox.set_active(nSelected); + + rComboBox.set_size_request(150, -1); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/srchctrl.cxx b/svx/source/dialog/srchctrl.cxx new file mode 100644 index 000000000..28747acd7 --- /dev/null +++ b/svx/source/dialog/srchctrl.cxx @@ -0,0 +1,71 @@ +/* -*- 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 <svl/intitem.hxx> +#include <sfx2/objsh.hxx> + +#include <svx/svxids.hrc> + +#include "srchctrl.hxx" +#include <svx/srchdlg.hxx> +#include <svl/srchitem.hxx> + +SvxSearchController::SvxSearchController +( + sal_uInt16 _nId, + SfxBindings& rBind, + SvxSearchDialog& rDlg +) : + SfxControllerItem( _nId, rBind ), + + rSrchDlg( rDlg ) +{ +} + + +void SvxSearchController::StateChanged( sal_uInt16 nSID, SfxItemState eState, + const SfxPoolItem* pState ) +{ + if ( SfxItemState::DEFAULT == eState ) + { + if ( SID_STYLE_FAMILY1 <= nSID && nSID <= SID_STYLE_FAMILY4 ) + { + SfxObjectShell* pShell = SfxObjectShell::Current(); + + if ( pShell && pShell->GetStyleSheetPool() ) + rSrchDlg.TemplatesChanged_Impl( *pShell->GetStyleSheetPool() ); + } + else if ( SID_SEARCH_OPTIONS == nSID ) + { + DBG_ASSERT( dynamic_cast<const SfxUInt16Item* >(pState) != nullptr, "wrong item type" ); + SearchOptionFlags nFlags = static_cast<SearchOptionFlags>(static_cast<const SfxUInt16Item*>(pState)->GetValue()); + rSrchDlg.EnableControls_Impl( nFlags ); + } + else if ( SID_SEARCH_ITEM == nSID ) + { + DBG_ASSERT( dynamic_cast<const SvxSearchItem*>( pState) != nullptr, "wrong item type" ); + rSrchDlg.SetItem_Impl( static_cast<const SvxSearchItem*>(pState) ); + } + } + else if ( SID_SEARCH_OPTIONS == nSID || SID_SEARCH_ITEM == nSID ) + rSrchDlg.EnableControls_Impl( SearchOptionFlags::NONE ); +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/srchctrl.hxx b/svx/source/dialog/srchctrl.hxx new file mode 100644 index 000000000..96fe59b66 --- /dev/null +++ b/svx/source/dialog/srchctrl.hxx @@ -0,0 +1,39 @@ +/* -*- 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 . + */ +#ifndef INCLUDED_SVX_SOURCE_DIALOG_SRCHCTRL_HXX +#define INCLUDED_SVX_SOURCE_DIALOG_SRCHCTRL_HXX + +#include <sfx2/ctrlitem.hxx> +class SvxSearchDialog; + +class SvxSearchController : public SfxControllerItem +{ + SvxSearchDialog& rSrchDlg; + +protected: + virtual void StateChanged( sal_uInt16, SfxItemState, const SfxPoolItem* pState ) override; + +public: + SvxSearchController( sal_uInt16 nId, SfxBindings& rBnd, SvxSearchDialog& rDlg ); +}; + + +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/srchdlg.cxx b/svx/source/dialog/srchdlg.cxx new file mode 100644 index 000000000..6653be858 --- /dev/null +++ b/svx/source/dialog/srchdlg.cxx @@ -0,0 +1,2452 @@ +/* -*- 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 <osl/diagnose.h> +#include <vcl/timer.hxx> +#include <svl/slstitm.hxx> +#include <svl/itemiter.hxx> +#include <svl/style.hxx> +#include <unotools/intlwrapper.hxx> +#include <unotools/moduleoptions.hxx> +#include <unotools/searchopt.hxx> +#include <sfx2/dispatch.hxx> +#include <sfx2/objsh.hxx> +#include <sfx2/module.hxx> +#include <sfx2/viewsh.hxx> +#include <sfx2/basedlgs.hxx> +#include <sfx2/viewfrm.hxx> +#include <svl/cjkoptions.hxx> +#include <svl/ctloptions.hxx> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/frame/XDispatch.hpp> +#include <com/sun/star/frame/XDispatchProvider.hpp> +#include <com/sun/star/frame/XLayoutManager.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/configuration/theDefaultProvider.hpp> +#include <com/sun/star/frame/ModuleManager.hpp> +#include <com/sun/star/ui/XUIElement.hpp> +#include <comphelper/processfactory.hxx> +#include <comphelper/scopeguard.hxx> +#include <svl/itempool.hxx> + +#include <sfx2/app.hxx> +#include <toolkit/helper/vclunohelper.hxx> + +#include <svx/srchdlg.hxx> +#include <svx/strarray.hxx> + +#include <svx/strings.hrc> +#include <svx/svxids.hrc> + +#include <svl/srchitem.hxx> +#include <svx/pageitem.hxx> +#include "srchctrl.hxx" +#include <svx/dialmgr.hxx> +#include <editeng/brushitem.hxx> +#include <tools/resary.hxx> +#include <svx/svxdlg.hxx> +#include <vcl/toolbox.hxx> +#include <o3tl/typed_flags_set.hxx> + +#include <cstdlib> +#include <memory> + +#include <findtextfield.hxx> + +#include <svx/labelitemwindow.hxx> +#include <svx/xdef.hxx> +#include <officecfg/Office/Common.hxx> + +using namespace com::sun::star::i18n; +using namespace com::sun::star::uno; +using namespace com::sun::star::accessibility; +using namespace com::sun::star; +using namespace comphelper; + +enum class ModifyFlags { + NONE = 0x000000, + Search = 0x000001, + Replace = 0x000002, + Word = 0x000004, + Exact = 0x000008, + Backwards = 0x000010, + Selection = 0x000020, + Regexp = 0x000040, + Layout = 0x000080, + Similarity = 0x000100, + Formulas = 0x000200, + Values = 0x000400, + CalcNotes = 0x000800, + Rows = 0x001000, + Columns = 0x002000, + AllTables = 0x004000, + Notes = 0x008000, + Wildcard = 0x010000 +}; +namespace o3tl { + template<> struct typed_flags<ModifyFlags> : is_typed_flags<ModifyFlags, 0x01ffff> {}; +} + +namespace +{ + bool GetCheckBoxValue(const weld::CheckButton& rBox) + { + return rBox.get_sensitive() && rBox.get_active(); + } + + bool GetNegatedCheckBoxValue(const weld::CheckButton& rBox) + { + return rBox.get_sensitive() && !rBox.get_active(); + } +} + +struct SearchDlg_Impl +{ + bool bSaveToModule : 1, + bFocusOnSearch : 1; + std::unique_ptr<sal_uInt16[]> pRanges; + Timer aSelectionTimer; + + uno::Reference< frame::XDispatch > xCommand1Dispatch; + uno::Reference< frame::XDispatch > xCommand2Dispatch; + util::URL aCommand1URL; + util::URL aCommand2URL; + + SearchDlg_Impl() + : bSaveToModule(true) + , bFocusOnSearch(true) + { + aCommand1URL.Complete = aCommand1URL.Main = "vnd.sun.search:SearchViaComponent1"; + aCommand1URL.Protocol = "vnd.sun.search:"; + aCommand1URL.Path = "SearchViaComponent1"; + aCommand2URL.Complete = aCommand2URL.Main = "vnd.sun.search:SearchViaComponent2"; + aCommand2URL.Protocol = "vnd.sun.search:"; + aCommand2URL.Path = "SearchViaComponent2"; + } +}; + +static void ListToStrArr_Impl(sal_uInt16 nId, std::vector<OUString>& rStrLst, weld::ComboBox& rCBox, sal_uInt16 nRememberSize) +{ + const SfxStringListItem* pSrchItem = + static_cast<const SfxStringListItem*>(SfxGetpApp()->GetItem( nId )); + + if (pSrchItem) + { + std::vector<OUString> aLst = pSrchItem->GetList(); + + if (aLst.size() > nRememberSize) + aLst.resize(nRememberSize); + + for (const OUString & s : aLst) + { + rStrLst.push_back(s); + rCBox.append_text(s); + } + } +} + +static void StrArrToList_Impl( sal_uInt16 nId, const std::vector<OUString>& rStrLst ) +{ + DBG_ASSERT( !rStrLst.empty(), "check in advance"); + SfxGetpApp()->PutItem( SfxStringListItem( nId, &rStrLst ) ); +} + +SearchAttrItemList::SearchAttrItemList( const SearchAttrItemList& rList ) : + SrchAttrItemList(rList) +{ + for ( size_t i = 0; i < size(); ++i ) + if ( !IsInvalidItem( (*this)[i].pItem ) ) + (*this)[i].pItem = (*this)[i].pItem->Clone(); +} + +SearchAttrItemList::~SearchAttrItemList() +{ + Clear(); +} + +void SearchAttrItemList::Put( const SfxItemSet& rSet ) +{ + if ( !rSet.Count() ) + return; + + SfxItemPool* pPool = rSet.GetPool(); + SfxItemIter aIter( rSet ); + SearchAttrItem aItem; + const SfxPoolItem* pItem = aIter.GetCurItem(); + sal_uInt16 nWhich; + + do + { + // only test that it is available? + if( IsInvalidItem( pItem ) ) + { + nWhich = rSet.GetWhichByPos( aIter.GetCurPos() ); + aItem.pItem = const_cast<SfxPoolItem*>(pItem); + } + else + { + nWhich = pItem->Which(); + aItem.pItem = pItem->Clone(); + } + + aItem.nSlot = pPool->GetSlotId( nWhich ); + Insert( aItem ); + + pItem = aIter.NextItem(); + } while (pItem); +} + + +SfxItemSet& SearchAttrItemList::Get( SfxItemSet& rSet ) +{ + SfxItemPool* pPool = rSet.GetPool(); + + for ( size_t i = 0; i < size(); ++i ) + if ( IsInvalidItem( (*this)[i].pItem ) ) + rSet.InvalidateItem( pPool->GetWhich( (*this)[i].nSlot ) ); + else + rSet.Put( *(*this)[i].pItem ); + return rSet; +} + + +void SearchAttrItemList::Clear() +{ + for ( size_t i = 0; i < size(); ++i ) + if ( !IsInvalidItem( (*this)[i].pItem ) ) + delete (*this)[i].pItem; + SrchAttrItemList::clear(); +} + + +// Deletes the pointer to the items +void SearchAttrItemList::Remove(size_t nPos) +{ + size_t nLen = 1; + if ( nPos + nLen > size() ) + nLen = size() - nPos; + + for ( size_t i = nPos; i < nPos + nLen; ++i ) + if ( !IsInvalidItem( (*this)[i].pItem ) ) + delete (*this)[i].pItem; + + SrchAttrItemList::erase( begin() + nPos, begin() + nPos + nLen ); +} + +SvxSearchDialog::SvxSearchDialog(weld::Window* pParent, SfxChildWindow* pChildWin, SfxBindings& rBind) + : SfxModelessDialogController(&rBind, pChildWin, pParent, + "svx/ui/findreplacedialog.ui", "FindReplaceDialog") + , rBindings(rBind) + , m_aPresentIdle("Bring SvxSearchDialog to Foreground") + , bWriter(false) + , bSearch(true) + , bFormat(false) + , bReplaceBackwards(false) + , nOptions(SearchOptionFlags::ALL) + , bSet(false) + , bConstruct(true) + , nModifyFlag(ModifyFlags::NONE) + , pReplaceList(new SearchAttrItemList) + , nTransliterationFlags(TransliterationFlags::NONE) + , m_xSearchFrame(m_xBuilder->weld_frame("searchframe")) + , m_xSearchLB(m_xBuilder->weld_combo_box("searchterm")) + , m_xSearchTmplLB(m_xBuilder->weld_combo_box("searchlist")) + , m_xSearchAttrText(m_xBuilder->weld_label("searchdesc")) + , m_xSearchLabel(m_xBuilder->weld_label("searchlabel")) + , m_xReplaceFrame(m_xBuilder->weld_frame("replaceframe")) + , m_xReplaceLB(m_xBuilder->weld_combo_box("replaceterm")) + , m_xReplaceTmplLB(m_xBuilder->weld_combo_box("replacelist")) + , m_xReplaceAttrText(m_xBuilder->weld_label("replacedesc")) + , m_xSearchBtn(m_xBuilder->weld_button("search")) + , m_xBackSearchBtn(m_xBuilder->weld_button("backsearch")) + , m_xSearchAllBtn(m_xBuilder->weld_button("searchall")) + , m_xReplaceBtn(m_xBuilder->weld_button("replace")) + , m_xReplaceAllBtn(m_xBuilder->weld_button("replaceall")) + , m_xComponentFrame(m_xBuilder->weld_frame("componentframe")) + , m_xSearchComponent1PB(m_xBuilder->weld_button("component1")) + , m_xSearchComponent2PB(m_xBuilder->weld_button("component2")) + , m_xMatchCaseCB(m_xBuilder->weld_check_button("matchcase")) + , m_xSearchFormattedCB(m_xBuilder->weld_check_button("searchformatted")) + , m_xWordBtn(m_xBuilder->weld_check_button("wholewords")) + , m_xCloseBtn(m_xBuilder->weld_button("close")) + , m_xIncludeDiacritics(m_xBuilder->weld_check_button("includediacritics")) + , m_xIncludeKashida(m_xBuilder->weld_check_button("includekashida")) + , m_xOtherOptionsExpander(m_xBuilder->weld_expander("OptionsExpander")) + , m_xSelectionBtn(m_xBuilder->weld_check_button("selection")) + , m_xRegExpBtn(m_xBuilder->weld_check_button("regexp")) + , m_xWildcardBtn(m_xBuilder->weld_check_button("wildcard")) + , m_xSimilarityBox(m_xBuilder->weld_check_button("similarity")) + , m_xSimilarityBtn(m_xBuilder->weld_button("similaritybtn")) + , m_xLayoutBtn(m_xBuilder->weld_check_button("layout")) + , m_xNotesBtn(m_xBuilder->weld_check_button("notes")) + , m_xJapMatchFullHalfWidthCB(m_xBuilder->weld_check_button("matchcharwidth")) + , m_xJapOptionsCB(m_xBuilder->weld_check_button("soundslike")) + , m_xReplaceBackwardsCB(m_xBuilder->weld_check_button("replace_backwards")) + , m_xJapOptionsBtn(m_xBuilder->weld_button("soundslikebtn")) + , m_xAttributeBtn(m_xBuilder->weld_button("attributes")) + , m_xFormatBtn(m_xBuilder->weld_button("format")) + , m_xNoFormatBtn(m_xBuilder->weld_button("noformat")) + , m_xCalcGrid(m_xBuilder->weld_widget("calcgrid")) + , m_xCalcSearchInFT(m_xBuilder->weld_label("searchinlabel")) + , m_xCalcSearchInLB(m_xBuilder->weld_combo_box("calcsearchin")) + , m_xCalcSearchDirFT(m_xBuilder->weld_label("searchdir")) + , m_xRowsBtn(m_xBuilder->weld_radio_button("rows")) + , m_xColumnsBtn(m_xBuilder->weld_radio_button("cols")) + , m_xAllSheetsCB(m_xBuilder->weld_check_button("allsheets")) + , m_xCalcStrFT(m_xBuilder->weld_label("entirecells")) +{ + m_aPresentIdle.SetTimeout(50); + m_aPresentIdle.SetInvokeHandler(LINK(this, SvxSearchDialog, PresentTimeoutHdl_Impl)); + + m_xSearchTmplLB->make_sorted(); + m_xSearchAttrText->hide(); + m_xSearchLabel->show(); + + m_xReplaceTmplLB->make_sorted(); + m_xReplaceAttrText->hide(); + + aCalcStr = m_xCalcStrFT->get_label(); + + // m_xSimilarityBtn->set_height_request(m_xSimilarityBox->get_preferred_size().Height()); + // m_xJapOptionsBtn->set_height_request(m_xJapOptionsCB->get_preferred_size().Height()); + + //tdf#122322 + nRememberSize = officecfg::Office::Common::Misc::FindReplaceRememberedSearches::get(); + if (nRememberSize<1) + nRememberSize = 1; //0 crashes with no results found + + auto nTermWidth = m_xSearchLB->get_approximate_digit_width() * 28; + m_xSearchLB->set_size_request(nTermWidth, -1); + m_xSearchTmplLB->set_size_request(nTermWidth, -1); + m_xReplaceLB->set_size_request(nTermWidth, -1); + m_xReplaceTmplLB->set_size_request(nTermWidth, -1); + + Construct_Impl(); +} + +IMPL_LINK_NOARG(SvxSearchDialog, PresentTimeoutHdl_Impl, Timer*, void) +{ + getDialog()->present(); +} + +void SvxSearchDialog::Present() +{ + PresentTimeoutHdl_Impl(nullptr); + // tdf#133807 try again in a short timeout + m_aPresentIdle.Start(); +} + +void SvxSearchDialog::ChildWinDispose() +{ + rBindings.EnterRegistrations(); + pSearchController.reset(); + pOptionsController.reset(); + pFamilyController.reset(); + rBindings.LeaveRegistrations(); + SfxModelessDialogController::ChildWinDispose(); +} + +SvxSearchDialog::~SvxSearchDialog() +{ + m_aPresentIdle.Stop(); +} + +void SvxSearchDialog::Construct_Impl() +{ + pImpl.reset( new SearchDlg_Impl() ); + pImpl->aSelectionTimer.SetTimeout( 500 ); + pImpl->aSelectionTimer.SetInvokeHandler( + LINK( this, SvxSearchDialog, TimeoutHdl_Impl ) ); + EnableControls_Impl( SearchOptionFlags::NONE ); + + // Store old Text from m_xWordBtn + aCalcStr += "#"; + aCalcStr += m_xWordBtn->get_label(); + + aLayoutStr = SvxResId( RID_SVXSTR_SEARCH_STYLES ); + aLayoutWriterStr = SvxResId( RID_SVXSTR_WRITER_STYLES ); + aLayoutCalcStr = SvxResId( RID_SVXSTR_CALC_STYLES ); + aStylesStr = m_xLayoutBtn->get_label(); + + // Get stored search-strings from the application + ListToStrArr_Impl(SID_SEARCHDLG_SEARCHSTRINGS, + aSearchStrings, *m_xSearchLB, nRememberSize); + ListToStrArr_Impl(SID_SEARCHDLG_REPLACESTRINGS, + aReplaceStrings, *m_xReplaceLB, nRememberSize); + + InitControls_Impl(); + + // Get attribute sets only once in constructor() + const SfxPoolItem* ppArgs[] = { pSearchItem.get(), nullptr }; + const SvxSetItem* pSrchSetItem = + static_cast<const SvxSetItem*>( rBindings.GetDispatcher()->Execute( FID_SEARCH_SEARCHSET, SfxCallMode::SLOT, ppArgs ) ); + + if ( pSrchSetItem ) + InitAttrList_Impl( &pSrchSetItem->GetItemSet(), nullptr ); + + const SvxSetItem* pReplSetItem = + static_cast<const SvxSetItem*>( rBindings.GetDispatcher()->Execute( FID_SEARCH_REPLACESET, SfxCallMode::SLOT, ppArgs ) ); + + if ( pReplSetItem ) + InitAttrList_Impl( nullptr, &pReplSetItem->GetItemSet() ); + + // Create controller and update at once + rBindings.EnterRegistrations(); + pSearchController.reset( + new SvxSearchController( SID_SEARCH_ITEM, rBindings, *this ) ); + pOptionsController.reset( + new SvxSearchController( SID_SEARCH_OPTIONS, rBindings, *this ) ); + rBindings.LeaveRegistrations(); + rBindings.GetDispatcher()->Execute( FID_SEARCH_ON, SfxCallMode::SLOT, ppArgs ); + pImpl->aSelectionTimer.Start(); + + + SvtCJKOptions aCJKOptions; + if(!aCJKOptions.IsJapaneseFindEnabled()) + { + m_xJapOptionsCB->set_active( false ); + m_xJapOptionsCB->hide(); + m_xJapOptionsBtn->hide(); + } + if(!aCJKOptions.IsCJKFontEnabled()) + { + m_xJapMatchFullHalfWidthCB->hide(); + } + SvtCTLOptions aCTLOptions; + // Do not disable and hide the m_xIncludeDiacritics button. + // Include Diacritics == Not Ignore Diacritics => A does not match A-Umlaut (Diaeresis). + // Confusingly these have negated names (following the UI) but the actual + // transliteration is to *ignore* diacritics if "included" (sensitive) is + // _not_ checked. + if(!aCTLOptions.IsCTLFontEnabled()) + { + m_xIncludeDiacritics->set_active( true ); + m_xIncludeKashida->set_active( true ); + m_xIncludeKashida->hide(); + } + //component extension - show component search buttons if the commands + // vnd.sun.star::SearchViaComponent1 and 2 are supported + const uno::Reference< frame::XFrame >xFrame = rBindings.GetActiveFrame(); + const uno::Reference< frame::XDispatchProvider > xDispatchProv(xFrame, uno::UNO_QUERY); + OUString sTarget("_self"); + + bool bSearchComponent1 = false; + bool bSearchComponent2 = false; + if(xDispatchProv.is()) + { + pImpl->xCommand1Dispatch = xDispatchProv->queryDispatch(pImpl->aCommand1URL, sTarget, 0); + if (pImpl->xCommand1Dispatch.is()) + bSearchComponent1 = true; + pImpl->xCommand2Dispatch = xDispatchProv->queryDispatch(pImpl->aCommand2URL, sTarget, 0); + if (pImpl->xCommand2Dispatch.is()) + bSearchComponent2 = true; + } + + if( bSearchComponent1 || bSearchComponent2 ) + { + try + { + uno::Reference< lang::XMultiServiceFactory > xConfigurationProvider = + configuration::theDefaultProvider::get( comphelper::getProcessComponentContext() ); + uno::Sequence< uno::Any > aArgs { + Any(OUString( "/org.openoffice.Office.Common/SearchOptions/")) }; + + uno::Reference< uno::XInterface > xIFace = xConfigurationProvider->createInstanceWithArguments( + "com.sun.star.configuration.ConfigurationUpdateAccess", + aArgs); + uno::Reference< container::XNameAccess> xDirectAccess(xIFace, uno::UNO_QUERY); + if(xDirectAccess.is()) + { + OUString sTemp; + uno::Any aRet = xDirectAccess->getByName("ComponentSearchGroupLabel"); + aRet >>= sTemp; + m_xComponentFrame->set_label(sTemp); + aRet = xDirectAccess->getByName("ComponentSearchCommandLabel1"); + aRet >>= sTemp; + m_xSearchComponent1PB->set_label( sTemp ); + aRet = xDirectAccess->getByName("ComponentSearchCommandLabel2"); + aRet >>= sTemp; + m_xSearchComponent2PB->set_label( sTemp ); + } + } + catch(uno::Exception&){} + + if(!m_xSearchComponent1PB->get_label().isEmpty() && bSearchComponent1 ) + { + m_xComponentFrame->show(); + m_xSearchComponent1PB->show(); + } + if( !m_xSearchComponent2PB->get_label().isEmpty() ) + { + m_xComponentFrame->show(); + m_xSearchComponent2PB->show(); + } + } +} + +void SvxSearchDialog::Close() +{ + // remember strings + if (!aSearchStrings.empty()) + StrArrToList_Impl( SID_SEARCHDLG_SEARCHSTRINGS, aSearchStrings ); + + if (!aReplaceStrings.empty()) + StrArrToList_Impl( SID_SEARCHDLG_REPLACESTRINGS, aReplaceStrings ); + + // save settings to configuration + SvtSearchOptions aOpt; + aOpt.SetWholeWordsOnly ( m_xWordBtn->get_active() ); + aOpt.SetBackwards ( m_xReplaceBackwardsCB->get_active() ); + aOpt.SetUseRegularExpression ( m_xRegExpBtn->get_active() ); + aOpt.SetUseWildcard ( m_xWildcardBtn->get_active() ); + aOpt.SetSearchForStyles ( m_xLayoutBtn->get_active() ); + aOpt.SetSimilaritySearch ( m_xSimilarityBox->get_active() ); + aOpt.SetUseAsianOptions ( m_xJapOptionsCB->get_active() ); + aOpt.SetNotes ( m_xNotesBtn->get_active() ); + aOpt.SetIgnoreDiacritics_CTL ( !m_xIncludeDiacritics->get_active() ); + aOpt.SetIgnoreKashida_CTL ( !m_xIncludeKashida->get_active() ); + aOpt.SetSearchFormatted ( m_xSearchFormattedCB->get_active() ); + aOpt.Commit(); + + if (IsClosing()) + return; + + const SfxPoolItem* ppArgs[] = { pSearchItem.get(), nullptr }; + rBindings.GetDispatcher()->Execute( FID_SEARCH_OFF, SfxCallMode::SLOT, ppArgs ); + rBindings.Invalidate(SID_SEARCH_DLG); + + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + if (pViewFrame) + pViewFrame->ToggleChildWindow(SID_SEARCH_DLG); +} + +TransliterationFlags SvxSearchDialog::GetTransliterationFlags() const +{ + if (!m_xMatchCaseCB->get_active()) + nTransliterationFlags |= TransliterationFlags::IGNORE_CASE; + else + nTransliterationFlags &= ~TransliterationFlags::IGNORE_CASE; + if ( !m_xJapMatchFullHalfWidthCB->get_active()) + nTransliterationFlags |= TransliterationFlags::IGNORE_WIDTH; + else + nTransliterationFlags &= ~TransliterationFlags::IGNORE_WIDTH; + return nTransliterationFlags; +} + +void SvxSearchDialog::SetSaveToModule(bool b) +{ + pImpl->bSaveToModule = b; +} + +void SvxSearchDialog::SetSearchLabel(const OUString& rStr) +{ + m_xSearchLabel->set_label(rStr); + + if (rStr == SvxResId(RID_SVXSTR_SEARCH_NOT_FOUND)) + m_xSearchLB->set_entry_message_type(weld::EntryMessageType::Error); +} + +void SvxSearchDialog::ApplyTransliterationFlags_Impl( TransliterationFlags nSettings ) +{ + nTransliterationFlags = nSettings; + bool bVal(nSettings & TransliterationFlags::IGNORE_CASE); + m_xMatchCaseCB->set_active( !bVal ); + bVal = bool(nSettings & TransliterationFlags::IGNORE_WIDTH); + m_xJapMatchFullHalfWidthCB->set_active( !bVal ); +} + + +bool SvxSearchDialog::IsOtherOptionsExpanded() const +{ + return m_xReplaceBackwardsCB->get_active() || + m_xSelectionBtn->get_active() || + m_xRegExpBtn->get_active() || + m_xLayoutBtn->get_active() || + m_xSimilarityBox->get_active() || + m_xJapMatchFullHalfWidthCB->get_active() || + m_xJapOptionsCB->get_active() || + m_xWildcardBtn->get_active() || + m_xNotesBtn->get_active() || + m_xIncludeKashida->get_active() || + m_xIncludeDiacritics->get_active(); +} + +void SvxSearchDialog::Activate() +{ + // apply possible transliteration changes of the SvxSearchItem member + DBG_ASSERT( pSearchItem, "SearchItem missing" ); + if (pSearchItem) + { + m_xMatchCaseCB->set_active( pSearchItem->GetExact() ); + m_xJapMatchFullHalfWidthCB->set_active( !pSearchItem->IsMatchFullHalfWidthForms() ); + } + + SfxModelessDialogController::Activate(); +} + +void SvxSearchDialog::InitControls_Impl() +{ + // CaseSensitives AutoComplete + m_xSearchLB->set_entry_completion( true, true ); + m_xSearchLB->show(); + m_xReplaceLB->set_entry_completion( true, true ); + m_xReplaceLB->show(); + + m_xFormatBtn->set_sensitive(false); + m_xAttributeBtn->set_sensitive(false); + + m_xSearchLB->connect_changed( LINK( this, SvxSearchDialog, ModifyHdl_Impl ) ); + m_xReplaceLB->connect_changed( LINK( this, SvxSearchDialog, ModifyHdl_Impl ) ); + + Link<weld::Widget&,void> aLink = LINK( this, SvxSearchDialog, FocusHdl_Impl ); + m_xSearchLB->connect_focus_in( aLink ); + m_xReplaceLB->connect_focus_in( aLink ); + + aLink = LINK( this, SvxSearchDialog, LoseFocusHdl_Impl ); + m_xSearchLB->connect_focus_out( aLink ); + m_xReplaceLB->connect_focus_out( aLink ); + + m_xSearchTmplLB->connect_focus_out( aLink ); + m_xReplaceTmplLB->connect_focus_out( aLink ); + + Link<weld::Button&,void> aLink2 = LINK( this, SvxSearchDialog, CommandHdl_Impl ); + m_xSearchBtn->connect_clicked( aLink2 ); + m_xBackSearchBtn->connect_clicked( aLink2 ); + m_xSearchAllBtn->connect_clicked( aLink2 ); + m_xReplaceBtn->connect_clicked( aLink2 ); + m_xReplaceAllBtn->connect_clicked( aLink2 ); + m_xCloseBtn->connect_clicked( aLink2 ); + m_xSimilarityBtn->connect_clicked( aLink2 ); + m_xJapOptionsBtn->connect_clicked( aLink2 ); + m_xSearchComponent1PB->connect_clicked( aLink2 ); + m_xSearchComponent2PB->connect_clicked( aLink2 ); + + aLink2 = LINK( this, SvxSearchDialog, FlagHdl_Impl ); + m_xReplaceBackwardsCB->connect_clicked( aLink2 ); + m_xWordBtn->connect_clicked( aLink2 ); + m_xSelectionBtn->connect_clicked( aLink2 ); + m_xMatchCaseCB->connect_clicked( aLink2 ); + m_xRegExpBtn->connect_clicked( aLink2 ); + m_xWildcardBtn->connect_clicked( aLink2 ); + m_xNotesBtn->connect_clicked( aLink2 ); + m_xSimilarityBox->connect_clicked( aLink2 ); + m_xJapOptionsCB->connect_clicked( aLink2 ); + m_xJapMatchFullHalfWidthCB->connect_clicked( aLink2 ); + m_xIncludeDiacritics->connect_clicked( aLink2 ); + m_xIncludeKashida->connect_clicked( aLink2 ); + m_xLayoutBtn->connect_clicked( LINK( this, SvxSearchDialog, TemplateHdl_Impl ) ); + m_xFormatBtn->connect_clicked( LINK( this, SvxSearchDialog, FormatHdl_Impl ) ); + m_xNoFormatBtn->connect_clicked( + LINK( this, SvxSearchDialog, NoFormatHdl_Impl ) ); + m_xAttributeBtn->connect_clicked( + LINK( this, SvxSearchDialog, AttributeHdl_Impl ) ); +} + +namespace +{ + SvtModuleOptions::EFactory getModule(SfxBindings const & rBindings) + { + SvtModuleOptions::EFactory eFactory(SvtModuleOptions::EFactory::UNKNOWN_FACTORY); + try + { + const uno::Reference< frame::XFrame > xFrame = + rBindings.GetActiveFrame(); + uno::Reference< frame::XModuleManager2 > xModuleManager( + frame::ModuleManager::create(::comphelper::getProcessComponentContext())); + + OUString aModuleIdentifier = xModuleManager->identify( xFrame ); + eFactory = SvtModuleOptions::ClassifyFactoryByServiceName(aModuleIdentifier); + } + catch (const uno::Exception&) + { + } + return eFactory; + } +} + +void SvxSearchDialog::ShowOptionalControls_Impl() +{ + DBG_ASSERT( pSearchItem, "no search item" ); + + SvtCJKOptions aCJKOptions; + SvtCTLOptions aCTLOptions; + SvtModuleOptions::EFactory eFactory = getModule(rBindings); + bool bDrawApp = eFactory == SvtModuleOptions::EFactory::DRAW; + bool bWriterApp = + eFactory == SvtModuleOptions::EFactory::WRITER || + eFactory == SvtModuleOptions::EFactory::WRITERWEB || + eFactory == SvtModuleOptions::EFactory::WRITERGLOBAL; + bool bCalcApp = eFactory == SvtModuleOptions::EFactory::CALC; + + m_xLayoutBtn->set_visible(!bDrawApp); + m_xNotesBtn->set_visible(bWriterApp); + m_xRegExpBtn->set_visible(!bDrawApp); + m_xWildcardBtn->set_visible(bCalcApp); /* TODO:WILDCARD enable for other apps if hey handle it */ + m_xReplaceBackwardsCB->show(); + m_xSimilarityBox->show(); + m_xSimilarityBtn->show(); + m_xSelectionBtn->show(); + m_xIncludeDiacritics->show(); + m_xIncludeKashida->set_visible(aCTLOptions.IsCTLFontEnabled()); + m_xJapMatchFullHalfWidthCB->set_visible(aCJKOptions.IsCJKFontEnabled()); + m_xJapOptionsCB->set_visible(aCJKOptions.IsJapaneseFindEnabled()); + m_xJapOptionsBtn->set_visible(aCJKOptions.IsJapaneseFindEnabled()); + + if (bWriter) + { + m_xAttributeBtn->show(); + m_xFormatBtn->show(); + m_xNoFormatBtn->show(); + } + + if (bCalcApp) + { + m_xCalcSearchInFT->show(); + m_xCalcSearchInLB->show(); + m_xCalcSearchDirFT->show(); + m_xRowsBtn->show(); + m_xColumnsBtn->show(); + m_xAllSheetsCB->show(); + m_xSearchFormattedCB->show(); + } +} + + +namespace { + +class ToggleSaveToModule +{ +public: + ToggleSaveToModule(SvxSearchDialog& rDialog, bool bValue) : + mrDialog(rDialog), mbValue(bValue) + { + mrDialog.SetSaveToModule(mbValue); + } + + ~ToggleSaveToModule() + { + mrDialog.SetSaveToModule(!mbValue); + } +private: + SvxSearchDialog& mrDialog; + bool mbValue; +}; + +} + +void SvxSearchDialog::Init_Impl( bool bSearchPattern ) +{ + DBG_ASSERT( pSearchItem, "SearchItem == 0" ); + + // We don't want to save any intermediate state to the module while the + // dialog is being initialized. + ToggleSaveToModule aNoModuleSave(*this, false); + SvtSearchOptions aOpt; + + bWriter = ( pSearchItem->GetAppFlag() == SvxSearchApp::WRITER ); + + if ( !( nModifyFlag & ModifyFlags::Word ) ) + m_xWordBtn->set_active( pSearchItem->GetWordOnly() ); + if ( !( nModifyFlag & ModifyFlags::Exact ) ) + m_xMatchCaseCB->set_active( pSearchItem->GetExact() ); + if ( !( nModifyFlag & ModifyFlags::Backwards ) ) + m_xReplaceBackwardsCB->set_active( bReplaceBackwards ); //adjustment to replace backwards + if ( !( nModifyFlag & ModifyFlags::Notes ) ) + m_xNotesBtn->set_active( pSearchItem->GetNotes() ); + if ( !( nModifyFlag & ModifyFlags::Selection ) ) + m_xSelectionBtn->set_active( pSearchItem->GetSelection() ); + if ( !( nModifyFlag & ModifyFlags::Regexp ) ) + m_xRegExpBtn->set_active( pSearchItem->GetRegExp() ); + if ( !( nModifyFlag & ModifyFlags::Wildcard ) ) + m_xWildcardBtn->set_active( pSearchItem->GetWildcard() ); + if ( !( nModifyFlag & ModifyFlags::Layout ) ) + m_xLayoutBtn->set_active( pSearchItem->GetPattern() ); + if (m_xNotesBtn->get_active()) + m_xLayoutBtn->set_sensitive(false); + m_xSimilarityBox->set_active( pSearchItem->IsLevenshtein() ); + if ( m_xJapOptionsCB->get_visible() ) + m_xJapOptionsCB->set_active( pSearchItem->IsUseAsianOptions() ); + m_xIncludeDiacritics->set_active( !aOpt.IsIgnoreDiacritics_CTL() ); + if ( m_xIncludeKashida->get_visible() ) + m_xIncludeKashida->set_active( !aOpt.IsIgnoreKashida_CTL() ); + if ( SvxSearchDialog::IsOtherOptionsExpanded() ) + m_xOtherOptionsExpander->set_expanded( true ); + ApplyTransliterationFlags_Impl( pSearchItem->GetTransliterationFlags() ); + + ShowOptionalControls_Impl(); + + if ( pSearchItem->GetAppFlag() == SvxSearchApp::CALC ) + { + m_xCalcGrid->show(); + m_xSearchFormattedCB->set_active( aOpt.IsSearchFormatted() ); + Link<weld::Button&,void> aLink = LINK( this, SvxSearchDialog, FlagHdl_Impl ); + m_xCalcSearchInLB->connect_changed( LINK( this, SvxSearchDialog, LBSelectHdl_Impl ) ); + m_xRowsBtn->connect_clicked( aLink ); + m_xColumnsBtn->connect_clicked( aLink ); + m_xAllSheetsCB->connect_clicked( aLink ); + m_xSearchFormattedCB->connect_clicked( aLink ); + + ModifyFlags nModifyFlagCheck; + switch ( pSearchItem->GetCellType() ) + { + case SvxSearchCellType::FORMULA: + nModifyFlagCheck = ModifyFlags::Formulas; + break; + + case SvxSearchCellType::VALUE: + nModifyFlagCheck = ModifyFlags::Values; + break; + + case SvxSearchCellType::NOTE: + nModifyFlagCheck = ModifyFlags::CalcNotes; + break; + + default: + std::abort(); // cannot happen + } + if ( !(nModifyFlag & nModifyFlagCheck) ) + m_xCalcSearchInLB->set_active( static_cast<sal_Int32>(pSearchItem->GetCellType()) ); + + m_xWordBtn->set_label( aCalcStr.getToken( 0, '#' ) ); + + if ( pSearchItem->GetRowDirection() && + !( nModifyFlag & ModifyFlags::Rows ) ) + m_xRowsBtn->set_active(true); + else if ( !pSearchItem->GetRowDirection() && + !( nModifyFlag & ModifyFlags::Columns ) ) + m_xColumnsBtn->set_active(true); + + if ( !( nModifyFlag & ModifyFlags::AllTables ) ) + m_xAllSheetsCB->set_active( pSearchItem->IsAllTables() ); + + // only look for formatting in Writer + m_xFormatBtn->hide(); + m_xNoFormatBtn->hide(); + m_xAttributeBtn->hide(); + } + else + { + m_xSearchFormattedCB->hide(); + m_xWordBtn->set_label( aCalcStr.getToken( 1, '#' ) ); + + if ( pSearchItem->GetAppFlag() == SvxSearchApp::DRAW ) + { + m_xSearchAllBtn->hide(); + + m_xRegExpBtn->hide(); + m_xWildcardBtn->hide(); + m_xLayoutBtn->hide(); + + // only look for formatting in Writer + m_xFormatBtn->hide(); + m_xNoFormatBtn->hide(); + m_xAttributeBtn->hide(); + } + else + { + m_xWildcardBtn->hide(); /* TODO:WILDCARD do not hide for other apps if they handle it */ + + if ( !pSearchList ) + { + // Get attribute sets, if it not has been done already + const SfxPoolItem* ppArgs[] = { pSearchItem.get(), nullptr }; + const SvxSetItem* pSrchSetItem = + static_cast<const SvxSetItem*>(rBindings.GetDispatcher()->Execute( FID_SEARCH_SEARCHSET, SfxCallMode::SLOT, ppArgs )); + + if ( pSrchSetItem ) + InitAttrList_Impl( &pSrchSetItem->GetItemSet(), nullptr ); + + const SvxSetItem* pReplSetItem = + static_cast<const SvxSetItem*>( rBindings.GetDispatcher()->Execute( FID_SEARCH_REPLACESET, SfxCallMode::SLOT, ppArgs ) ); + + if ( pReplSetItem ) + InitAttrList_Impl( nullptr, &pReplSetItem->GetItemSet() ); + } + } + } + + // similarity search? + if ( !( nModifyFlag & ModifyFlags::Similarity ) ) + m_xSimilarityBox->set_active( pSearchItem->IsLevenshtein() ); + bSet = true; + + FlagHdl_Impl(*m_xSimilarityBox); + FlagHdl_Impl(*m_xJapOptionsCB); + + bool bDisableSearch = false; + SfxViewShell* pViewShell = SfxViewShell::Current(); + + if ( pViewShell ) + { + bool bText = !bSearchPattern; + + if ( pViewShell->HasSelection( bText ) ) + EnableControl_Impl(*m_xSelectionBtn); + else + { + m_xSelectionBtn->set_active( false ); + m_xSelectionBtn->set_sensitive(false); + } + } + + // Pattern Search and there were no AttrSets given + if ( bSearchPattern ) + { + SfxObjectShell* pShell = SfxObjectShell::Current(); + + if ( pShell && pShell->GetStyleSheetPool() ) + { + // Templates designed + m_xSearchTmplLB->clear(); + m_xReplaceTmplLB->clear(); + SfxStyleSheetBasePool* pStylePool = pShell->GetStyleSheetPool(); + SfxStyleSheetBase* pBase = pStylePool->First(pSearchItem->GetFamily()); + + while ( pBase ) + { + if ( pBase->IsUsed() ) + m_xSearchTmplLB->append_text( pBase->GetName() ); + m_xReplaceTmplLB->append_text( pBase->GetName() ); + pBase = pStylePool->Next(); + } + m_xSearchTmplLB->set_active_text( pSearchItem->GetSearchString() ); + m_xReplaceTmplLB->set_active_text( pSearchItem->GetReplaceString() ); + + } + m_xSearchTmplLB->show(); + + if ( bConstruct ) + // Grab focus only after creating + m_xSearchTmplLB->grab_focus(); + m_xReplaceTmplLB->show(); + m_xSearchLB->hide(); + m_xReplaceLB->hide(); + + m_xWordBtn->set_sensitive(false); + m_xRegExpBtn->set_sensitive(false); + m_xWildcardBtn->set_sensitive(false); + m_xMatchCaseCB->set_sensitive(false); + + bDisableSearch = !m_xSearchTmplLB->get_count(); + } + else + { + bool bSetSearch = !( nModifyFlag & ModifyFlags::Search ); + bool bSetReplace = !( nModifyFlag & ModifyFlags::Replace ); + + if ( !(pSearchItem->GetSearchString().isEmpty()) && bSetSearch ) + m_xSearchLB->set_entry_text( pSearchItem->GetSearchString() ); + else if (!aSearchStrings.empty()) + { + bool bAttributes = + ( ( pSearchList && pSearchList->Count() ) || + ( pReplaceList && pReplaceList->Count() ) ); + + if ( bSetSearch && !bAttributes ) + m_xSearchLB->set_entry_text(aSearchStrings[0]); + + OUString aReplaceTxt = pSearchItem->GetReplaceString(); + + if (!aReplaceStrings.empty()) + aReplaceTxt = aReplaceStrings[0]; + + if ( bSetReplace && !bAttributes ) + m_xReplaceLB->set_entry_text( aReplaceTxt ); + } + m_xSearchLB->show(); + + if ( bConstruct ) + // Grab focus only after creating + m_xSearchLB->grab_focus(); + m_xReplaceLB->show(); + m_xSearchTmplLB->hide(); + m_xReplaceTmplLB->hide(); + + EnableControl_Impl(*m_xRegExpBtn); + EnableControl_Impl(*m_xWildcardBtn); + EnableControl_Impl(*m_xMatchCaseCB); + + if ( m_xRegExpBtn->get_active() ) + m_xWordBtn->set_sensitive(false); + else + EnableControl_Impl(*m_xWordBtn); + + bDisableSearch = m_xSearchLB->get_active_text().isEmpty() && + m_xSearchAttrText->get_label().isEmpty(); + } + FocusHdl_Impl(*m_xSearchLB); + + if ( bDisableSearch ) + { + m_xSearchBtn->set_sensitive(false); + m_xBackSearchBtn->set_sensitive(false); + m_xSearchAllBtn->set_sensitive(false); + m_xReplaceBtn->set_sensitive(false); + m_xReplaceAllBtn->set_sensitive(false); + m_xComponentFrame->set_sensitive(false); + } + else + { + EnableControl_Impl(*m_xSearchBtn); + EnableControl_Impl(*m_xBackSearchBtn); + EnableControl_Impl(*m_xReplaceBtn); + if (!bWriter || !m_xNotesBtn->get_active()) + { + EnableControl_Impl(*m_xSearchAllBtn); + EnableControl_Impl(*m_xReplaceAllBtn); + } + if (bWriter && pSearchItem->GetNotes()) + { + m_xSearchAllBtn->set_sensitive(false); + m_xReplaceAllBtn->set_sensitive(false); + } + } + + if (!m_xSearchAttrText->get_label().isEmpty()) + EnableControl_Impl(*m_xNoFormatBtn); + else + m_xNoFormatBtn->set_sensitive(false); + + if ( !pSearchList ) + { + m_xAttributeBtn->set_sensitive(false); + m_xFormatBtn->set_sensitive(false); + } + + if ( m_xLayoutBtn->get_active() ) + { + pImpl->bSaveToModule = false; + TemplateHdl_Impl(*m_xLayoutBtn); + pImpl->bSaveToModule = true; + } +} + + +void SvxSearchDialog::InitAttrList_Impl( const SfxItemSet* pSSet, + const SfxItemSet* pRSet ) +{ + if ( !pSSet && !pRSet ) + return; + + if ( !pImpl->pRanges && pSSet ) + { + const sal_uInt16* pPtr = pSSet->GetRanges(); + const sal_uInt16* pTmp = pPtr; + + while( *pPtr ) + { + pPtr += 2; + } + sal_sSize nCnt = pPtr - pTmp + 1; + pImpl->pRanges.reset( new sal_uInt16[nCnt] ); + memcpy( pImpl->pRanges.get(), pTmp, sizeof(sal_uInt16) * nCnt ); + } + + bool bSetOptimalLayoutSize = false; + + // See to it that are the texts of the attributes are correct + OUString aDesc; + + if ( pSSet ) + { + pSearchList.reset(new SearchAttrItemList); + + if ( pSSet->Count() ) + { + pSearchList->Put( *pSSet ); + + m_xSearchAttrText->set_label( BuildAttrText_Impl( aDesc, true ) ); + + if ( !aDesc.isEmpty() ) + { + if (!m_xSearchAttrText->get_visible()) + { + m_xSearchAttrText->show(); + bSetOptimalLayoutSize = true; + } + bFormat |= true; + } + } + } + + if ( pRSet ) + { + pReplaceList.reset(new SearchAttrItemList); + + if ( pRSet->Count() ) + { + pReplaceList->Put( *pRSet ); + + m_xReplaceAttrText->set_label( BuildAttrText_Impl( aDesc, false ) ); + + if ( !aDesc.isEmpty() ) + { + if (!m_xReplaceAttrText->get_visible()) + { + m_xReplaceAttrText->show(); + bSetOptimalLayoutSize = true; + } + bFormat |= true; + } + } + } + + if (bSetOptimalLayoutSize) + m_xDialog->resize_to_request(); +} + +IMPL_LINK( SvxSearchDialog, LBSelectHdl_Impl, weld::ComboBox&, rCtrl, void ) +{ + ClickHdl_Impl(&rCtrl); +} + +IMPL_LINK( SvxSearchDialog, FlagHdl_Impl, weld::Button&, rCtrl, void ) +{ + ClickHdl_Impl(&rCtrl); +} + +void SvxSearchDialog::ClickHdl_Impl(const weld::Widget* pCtrl) +{ + if ( pCtrl && !bSet ) + SetModifyFlag_Impl(pCtrl); + else + bSet = false; + + if (pCtrl == m_xSimilarityBox.get()) + { + bool bIsChecked = m_xSimilarityBox->get_active(); + + if ( bIsChecked ) + { + m_xSimilarityBtn->set_sensitive(true); + m_xRegExpBtn->set_active( false ); + m_xRegExpBtn->set_sensitive(false); + m_xWildcardBtn->set_active( false ); + m_xWildcardBtn->set_sensitive(false); + EnableControl_Impl(*m_xWordBtn); + + if ( m_xLayoutBtn->get_active() ) + { + EnableControl_Impl(*m_xMatchCaseCB); + m_xLayoutBtn->set_active( false ); + } + m_xRegExpBtn->set_sensitive(false); + m_xWildcardBtn->set_sensitive(false); + m_xLayoutBtn->set_sensitive(false); + m_xFormatBtn->set_sensitive(false); + m_xNoFormatBtn->set_sensitive(false); + m_xAttributeBtn->set_sensitive(false); + } + else + { + EnableControl_Impl(*m_xRegExpBtn); + EnableControl_Impl(*m_xWildcardBtn); + if (!m_xNotesBtn->get_active()) + EnableControl_Impl(*m_xLayoutBtn); + EnableControl_Impl(*m_xFormatBtn); + EnableControl_Impl(*m_xAttributeBtn); + m_xSimilarityBtn->set_sensitive(false); + } + pSearchItem->SetLevenshtein( bIsChecked ); + } + else if (pCtrl == m_xNotesBtn.get()) + { + if (m_xNotesBtn->get_active()) + { + m_xLayoutBtn->set_sensitive(false); + m_xSearchAllBtn->set_sensitive(false); + m_xReplaceAllBtn->set_sensitive(false); + } + else + { + EnableControl_Impl(*m_xLayoutBtn); + ModifyHdl_Impl(*m_xSearchLB); + } + } + else + { + if ( m_xLayoutBtn->get_active() && !bFormat ) + { + m_xWordBtn->set_active( false ); + m_xWordBtn->set_sensitive(false); + m_xRegExpBtn->set_active( false ); + m_xRegExpBtn->set_sensitive(false); + m_xWildcardBtn->set_active( false ); + m_xWildcardBtn->set_sensitive(false); + m_xMatchCaseCB->set_active( false ); + m_xMatchCaseCB->set_sensitive(false); + m_xNotesBtn->set_sensitive(false); + + if ( m_xSearchTmplLB->get_count() ) + { + EnableControl_Impl(*m_xSearchBtn); + EnableControl_Impl(*m_xBackSearchBtn); + EnableControl_Impl(*m_xSearchAllBtn); + EnableControl_Impl(*m_xReplaceBtn); + EnableControl_Impl(*m_xReplaceAllBtn); + } + } + else + { + EnableControl_Impl(*m_xRegExpBtn); + EnableControl_Impl(*m_xWildcardBtn); + EnableControl_Impl(*m_xMatchCaseCB); + EnableControl_Impl(*m_xNotesBtn); + + if ( m_xRegExpBtn->get_active() ) + { + m_xWordBtn->set_active( false ); + m_xWordBtn->set_sensitive(false); + m_xWildcardBtn->set_active( false ); + m_xWildcardBtn->set_sensitive(false); + m_xSimilarityBox->set_active( false ); + m_xSimilarityBox->set_sensitive(false); + m_xSimilarityBtn->set_sensitive(false); + } + else if ( m_xWildcardBtn->get_active() ) + { + m_xRegExpBtn->set_active( false ); + m_xRegExpBtn->set_sensitive(false); + m_xSimilarityBox->set_active( false ); + m_xSimilarityBox->set_sensitive(false); + m_xSimilarityBtn->set_sensitive(false); + } + else + { + EnableControl_Impl(*m_xWordBtn); + EnableControl_Impl(*m_xSimilarityBox); + } + + // Search-string in place? then enable Buttons + bSet = true; + ModifyHdl_Impl(*m_xSearchLB); + } + } + + if (pCtrl == m_xAllSheetsCB.get()) + { + bSet = true; + ModifyHdl_Impl(*m_xSearchLB); + } + + if (pCtrl == m_xJapOptionsCB.get()) + { + bool bEnableJapOpt = m_xJapOptionsCB->get_active(); + m_xMatchCaseCB->set_sensitive(!bEnableJapOpt ); + m_xJapMatchFullHalfWidthCB->set_sensitive(!bEnableJapOpt ); + m_xJapOptionsBtn->set_sensitive( bEnableJapOpt ); + } + + if ( pImpl->bSaveToModule ) + SaveToModule_Impl(); +} + +IMPL_LINK(SvxSearchDialog, CommandHdl_Impl, weld::Button&, rBtn, void) +{ + bool bInclusive = ( m_xLayoutBtn->get_label() == aLayoutStr ); + + if ( ( &rBtn == m_xSearchBtn.get() ) || + (&rBtn == m_xBackSearchBtn.get()) || + ( &rBtn == m_xSearchAllBtn.get() )|| + ( &rBtn == m_xReplaceBtn.get() ) || + ( &rBtn == m_xReplaceAllBtn.get() ) ) + { + if ( m_xLayoutBtn->get_active() && !bInclusive ) + { + pSearchItem->SetSearchString ( m_xSearchTmplLB->get_active_text() ); + pSearchItem->SetReplaceString( m_xReplaceTmplLB->get_active_text() ); + } + else + { + pSearchItem->SetSearchString ( m_xSearchLB->get_active_text() ); + pSearchItem->SetReplaceString( m_xReplaceLB->get_active_text() ); + + if ( &rBtn == m_xReplaceBtn.get() ) + Remember_Impl( m_xReplaceLB->get_active_text(), false ); + else + { + Remember_Impl( m_xSearchLB->get_active_text(), true ); + + if ( &rBtn == m_xReplaceAllBtn.get() ) + Remember_Impl( m_xReplaceLB->get_active_text(), false ); + } + } + + pSearchItem->SetRegExp( false ); + pSearchItem->SetWildcard( false ); + pSearchItem->SetLevenshtein( false ); + if (GetCheckBoxValue(*m_xRegExpBtn)) + pSearchItem->SetRegExp( true ); + else if (GetCheckBoxValue(*m_xWildcardBtn)) + pSearchItem->SetWildcard( true ); + else if (GetCheckBoxValue(*m_xSimilarityBox)) + pSearchItem->SetLevenshtein( true ); + + pSearchItem->SetWordOnly(GetCheckBoxValue(*m_xWordBtn)); + + bool bSetBackwards = false; + if( &rBtn == m_xBackSearchBtn.get()) + { + bSetBackwards = true; + } + else if( &rBtn == m_xReplaceBtn.get()) + { + bSetBackwards = GetCheckBoxValue(*m_xReplaceBackwardsCB); + bReplaceBackwards = GetCheckBoxValue(*m_xReplaceBackwardsCB); + } + + pSearchItem->SetBackward(bSetBackwards); + + pSearchItem->SetNotes(GetCheckBoxValue(*m_xNotesBtn)); + pSearchItem->SetPattern(GetCheckBoxValue(*m_xLayoutBtn)); + pSearchItem->SetSelection(GetCheckBoxValue(*m_xSelectionBtn)); + pSearchItem->SetUseAsianOptions(GetCheckBoxValue(*m_xJapOptionsCB)); + TransliterationFlags nFlags = GetTransliterationFlags(); + if( !pSearchItem->IsUseAsianOptions()) + nFlags &= TransliterationFlags::IGNORE_CASE | + TransliterationFlags::IGNORE_WIDTH; + if (GetNegatedCheckBoxValue(*m_xIncludeDiacritics)) + nFlags |= TransliterationFlags::IGNORE_DIACRITICS_CTL; + if (GetNegatedCheckBoxValue(*m_xIncludeKashida)) + nFlags |= TransliterationFlags::IGNORE_KASHIDA_CTL; + pSearchItem->SetTransliterationFlags( nFlags ); + + if ( !bWriter ) + { + if ( m_xCalcSearchInLB->get_active() != -1) + pSearchItem->SetCellType( static_cast<SvxSearchCellType>(m_xCalcSearchInLB->get_active()) ); + + pSearchItem->SetRowDirection( m_xRowsBtn->get_active() ); + pSearchItem->SetAllTables( m_xAllSheetsCB->get_active() ); + pSearchItem->SetSearchFormatted( m_xSearchFormattedCB->get_active() ); + } + + if ((&rBtn == m_xSearchBtn.get()) || (&rBtn == m_xBackSearchBtn.get())) + pSearchItem->SetCommand( SvxSearchCmd::FIND ); + else if ( &rBtn == m_xSearchAllBtn.get() ) + pSearchItem->SetCommand( SvxSearchCmd::FIND_ALL ); + else if ( &rBtn == m_xReplaceBtn.get() ) + pSearchItem->SetCommand( SvxSearchCmd::REPLACE ); + else if ( &rBtn == m_xReplaceAllBtn.get() ) + pSearchItem->SetCommand( SvxSearchCmd::REPLACE_ALL ); + + // when looking for templates, delete format lists + if ( !bFormat && pSearchItem->GetPattern() ) + { + if ( pSearchList ) + pSearchList->Clear(); + + if ( pReplaceList ) + pReplaceList->Clear(); + } + nModifyFlag = ModifyFlags::NONE; + const SfxPoolItem* ppArgs[] = { pSearchItem.get(), nullptr }; + rBindings.ExecuteSynchron( FID_SEARCH_NOW, ppArgs ); + } + else if ( &rBtn == m_xCloseBtn.get() ) + { + if ( !m_xLayoutBtn->get_active() || bInclusive ) + { + OUString aStr( m_xSearchLB->get_active_text() ); + + if ( !aStr.isEmpty() ) + Remember_Impl( aStr, true ); + aStr = m_xReplaceLB->get_active_text(); + + if ( !aStr.isEmpty() ) + Remember_Impl( aStr, false ); + } + SaveToModule_Impl(); + Close(); + } + else if (&rBtn == m_xSimilarityBtn.get()) + { + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxSearchSimilarityDialog> pDlg(pFact->CreateSvxSearchSimilarityDialog(m_xDialog.get(), + pSearchItem->IsLEVRelaxed(), + pSearchItem->GetLEVOther(), + pSearchItem->GetLEVShorter(), + pSearchItem->GetLEVLonger() )); + if ( executeSubDialog(pDlg.get()) == RET_OK ) + { + pSearchItem->SetLEVRelaxed( pDlg->IsRelaxed() ); + pSearchItem->SetLEVOther( pDlg->GetOther() ); + pSearchItem->SetLEVShorter( pDlg->GetShorter() ); + pSearchItem->SetLEVLonger( pDlg->GetLonger() ); + SaveToModule_Impl(); + } + } + else if (&rBtn == m_xJapOptionsBtn.get()) + { + SfxItemSet aSet( SfxGetpApp()->GetPool() ); + pSearchItem->SetTransliterationFlags( GetTransliterationFlags() ); + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<AbstractSvxJSearchOptionsDialog> aDlg(pFact->CreateSvxJSearchOptionsDialog(m_xDialog.get(), aSet, + pSearchItem->GetTransliterationFlags() )); + int nRet = executeSubDialog(aDlg.get()); + if (RET_OK == nRet) //! true only if FillItemSet of SvxJSearchOptionsPage returns true + { + TransliterationFlags nFlags = aDlg->GetTransliterationFlags(); + pSearchItem->SetTransliterationFlags( nFlags ); + ApplyTransliterationFlags_Impl( nFlags ); + } + } + else if (&rBtn == m_xSearchComponent1PB.get() || &rBtn == m_xSearchComponent2PB.get()) + { + uno::Sequence < beans::PropertyValue > aArgs(2); + beans::PropertyValue* pArgs = aArgs.getArray(); + pArgs[0].Name = "SearchString"; + pArgs[0].Value <<= m_xSearchLB->get_active_text(); + pArgs[1].Name = "ParentWindow"; + pArgs[1].Value <<= m_xDialog->GetXWindow(); + if (&rBtn == m_xSearchComponent1PB.get()) + { + if ( pImpl->xCommand1Dispatch.is() ) + pImpl->xCommand1Dispatch->dispatch(pImpl->aCommand1URL, aArgs); + } + else + { + if ( pImpl->xCommand2Dispatch.is() ) + pImpl->xCommand2Dispatch->dispatch(pImpl->aCommand2URL, aArgs); + } + } +} + + +IMPL_LINK( SvxSearchDialog, ModifyHdl_Impl, weld::ComboBox&, rEd, void ) +{ + if ( !bSet ) + SetModifyFlag_Impl( &rEd ); + else + bSet = false; + + // Calc allows searching for empty cells. + bool bAllowEmptySearch = (pSearchItem->GetAppFlag() == SvxSearchApp::CALC); + + if (&rEd == m_xSearchLB.get() || &rEd == m_xReplaceLB.get()) + { + sal_Int32 nSrchTxtLen = m_xSearchLB->get_active_text().getLength(); + sal_Int32 nReplTxtLen = 0; + if (bAllowEmptySearch) + nReplTxtLen = m_xReplaceLB->get_active_text().getLength(); + sal_Int32 nAttrTxtLen = m_xSearchAttrText->get_label().getLength(); + + if (nSrchTxtLen || nReplTxtLen || nAttrTxtLen) + { + EnableControl_Impl(*m_xSearchBtn); + EnableControl_Impl(*m_xBackSearchBtn); + EnableControl_Impl(*m_xReplaceBtn); + if (!bWriter || !m_xNotesBtn->get_active()) + { + EnableControl_Impl(*m_xSearchAllBtn); + EnableControl_Impl(*m_xReplaceAllBtn); + } + } + else + { + m_xComponentFrame->set_sensitive(false); + m_xSearchBtn->set_sensitive(false); + m_xBackSearchBtn->set_sensitive(false); + m_xSearchAllBtn->set_sensitive(false); + m_xReplaceBtn->set_sensitive(false); + m_xReplaceAllBtn->set_sensitive(false); + } + } +} + +IMPL_LINK_NOARG(SvxSearchDialog, TemplateHdl_Impl, weld::Button&, void) +{ + if ( pImpl->bSaveToModule ) + SaveToModule_Impl(); + + if ( bFormat ) + return; + OUString sDesc; + + if ( m_xLayoutBtn->get_active() ) + { + if ( !pFamilyController ) + { + sal_uInt16 nId = 0; + + // Enable templates controller + switch ( pSearchItem->GetFamily() ) + { + case SfxStyleFamily::Char: + nId = SID_STYLE_FAMILY1; break; + + case SfxStyleFamily::Para: + nId = SID_STYLE_FAMILY2; break; + + case SfxStyleFamily::Frame: + nId = SID_STYLE_FAMILY3; break; + + case SfxStyleFamily::Page: + nId = SID_STYLE_FAMILY4; break; + + case SfxStyleFamily::All: + break; + + default: + OSL_FAIL( "StyleSheetFamily was changed?" ); + } + + rBindings.EnterRegistrations(); + pFamilyController.reset( + new SvxSearchController( nId, rBindings, *this ) ); + rBindings.LeaveRegistrations(); + m_xSearchTmplLB->clear(); + m_xReplaceTmplLB->clear(); + + m_xSearchTmplLB->show(); + m_xReplaceTmplLB->show(); + m_xSearchLB->hide(); + m_xReplaceLB->hide(); + + m_xSearchAttrText->set_label( sDesc ); + m_xReplaceAttrText->set_label( sDesc ); + + if(!sDesc.isEmpty()) + { + if (!m_xReplaceAttrText->get_visible() || !m_xReplaceAttrText->get_visible()) + { + m_xSearchAttrText->show(); + m_xReplaceAttrText->show(); + m_xDialog->resize_to_request(); + } + } + } + m_xFormatBtn->set_sensitive(false); + m_xNoFormatBtn->set_sensitive(false); + m_xAttributeBtn->set_sensitive(false); + m_xSimilarityBox->set_sensitive(false); + m_xSimilarityBtn->set_sensitive(false); + } + else + { + // Disable templates controller + rBindings.EnterRegistrations(); + pFamilyController.reset(); + rBindings.LeaveRegistrations(); + + m_xSearchLB->show(); + m_xReplaceLB->show(); + m_xSearchTmplLB->hide(); + m_xReplaceTmplLB->hide(); + + m_xSearchAttrText->set_label( BuildAttrText_Impl( sDesc, true ) ); + m_xReplaceAttrText->set_label( BuildAttrText_Impl( sDesc, false ) ); + + if(!sDesc.isEmpty()) + { + if (!m_xReplaceAttrText->get_visible() || !m_xReplaceAttrText->get_visible()) + { + m_xSearchAttrText->show(); + m_xReplaceAttrText->show(); + m_xDialog->resize_to_request(); + } + } + + EnableControl_Impl(*m_xFormatBtn); + EnableControl_Impl(*m_xAttributeBtn); + EnableControl_Impl(*m_xSimilarityBox); + + FocusHdl_Impl( bSearch ? *m_xSearchLB : *m_xReplaceLB ); + } + bSet = true; + pImpl->bSaveToModule = false; + FlagHdl_Impl(*m_xLayoutBtn); + pImpl->bSaveToModule = true; +} + +void SvxSearchDialog::Remember_Impl( const OUString &rStr, bool _bSearch ) +{ + if ( rStr.isEmpty() ) + return; + + std::vector<OUString>* pArr = _bSearch ? &aSearchStrings : &aReplaceStrings; + weld::ComboBox* pListBox = _bSearch ? m_xSearchLB.get() : m_xReplaceLB.get(); + + // ignore identical strings + if (std::find(pArr->begin(), pArr->end(), rStr) != pArr->end()) + return; + + pArr->insert(pArr->begin(), rStr); + pListBox->insert_text(0, rStr); + + // delete oldest entry at maximum occupancy (ListBox and Array) + size_t nArrSize = pArr->size(); + if (nArrSize > nRememberSize) + { + pListBox->remove(nArrSize - 1); + pArr->erase(pArr->begin() + nArrSize - 1); + } +} + +void SvxSearchDialog::TemplatesChanged_Impl( SfxStyleSheetBasePool& rPool ) +{ + OUString aOldSrch( m_xSearchTmplLB->get_active_text() ); + OUString aOldRepl( m_xReplaceTmplLB->get_active_text() ); + m_xSearchTmplLB->clear(); + m_xReplaceTmplLB->clear(); + m_xSearchTmplLB->freeze(); + m_xReplaceTmplLB->freeze(); + SfxStyleSheetBase* pBase = rPool.First(pSearchItem->GetFamily()); + + while ( pBase ) + { + if ( pBase->IsUsed() ) + m_xSearchTmplLB->append_text( pBase->GetName() ); + m_xReplaceTmplLB->append_text( pBase->GetName() ); + pBase = rPool.Next(); + } + m_xSearchTmplLB->thaw(); + m_xReplaceTmplLB->thaw(); + m_xSearchTmplLB->set_active(0); + + if ( !aOldSrch.isEmpty() ) + m_xSearchTmplLB->set_active_text( aOldSrch ); + m_xReplaceTmplLB->set_active(0); + + if ( !aOldRepl.isEmpty() ) + m_xReplaceTmplLB->set_active_text( aOldRepl ); + + if ( m_xSearchTmplLB->get_count() ) + { + EnableControl_Impl(*m_xSearchBtn); + EnableControl_Impl(*m_xBackSearchBtn); + EnableControl_Impl(*m_xSearchAllBtn); + EnableControl_Impl(*m_xReplaceBtn); + EnableControl_Impl(*m_xReplaceAllBtn); + } +} + + +void SvxSearchDialog::EnableControls_Impl( const SearchOptionFlags nFlags ) +{ + if ( nFlags == nOptions ) + return; + else + nOptions = nFlags; + + bool bNoSearch = true; + + bool bEnableSearch = bool( SearchOptionFlags::SEARCH & nOptions ); + m_xSearchBtn->set_sensitive(bEnableSearch); + m_xBackSearchBtn->set_sensitive(bEnableSearch); + + if( bEnableSearch ) + bNoSearch = false; + + + if ( SearchOptionFlags::SEARCHALL & nOptions ) + { + m_xSearchAllBtn->set_sensitive(true); + bNoSearch = false; + } + else + m_xSearchAllBtn->set_sensitive(false); + if ( SearchOptionFlags::REPLACE & nOptions ) + { + m_xReplaceBtn->set_sensitive(true); + m_xReplaceFrame->set_sensitive(true); + m_xReplaceLB->set_sensitive(true); + m_xReplaceTmplLB->set_sensitive(true); + bNoSearch = false; + } + else + { + m_xReplaceBtn->set_sensitive(false); + m_xReplaceFrame->set_sensitive(false); + m_xReplaceLB->set_sensitive(false); + m_xReplaceTmplLB->set_sensitive(false); + } + if ( SearchOptionFlags::REPLACE_ALL & nOptions ) + { + m_xReplaceAllBtn->set_sensitive(true); + bNoSearch = false; + } + else + m_xReplaceAllBtn->set_sensitive(false); + m_xComponentFrame->set_sensitive(!bNoSearch); + m_xSearchBtn->set_sensitive( !bNoSearch ); + m_xBackSearchBtn->set_sensitive( !bNoSearch ); + m_xSearchFrame->set_sensitive( !bNoSearch ); + m_xSearchLB->set_sensitive( !bNoSearch ); + m_xNotesBtn->set_sensitive(true); + + if ( SearchOptionFlags::WHOLE_WORDS & nOptions ) + m_xWordBtn->set_sensitive(true); + else + m_xWordBtn->set_sensitive(false); + if ( SearchOptionFlags::BACKWARDS & nOptions ) + { + m_xBackSearchBtn->set_sensitive(true); + m_xReplaceBackwardsCB->set_sensitive(true); + } + else + { + m_xBackSearchBtn->set_sensitive(false); + m_xReplaceBackwardsCB->set_sensitive(false); + } + if ( SearchOptionFlags::REG_EXP & nOptions ) + m_xRegExpBtn->set_sensitive(true); + else + m_xRegExpBtn->set_sensitive(false); + if ( SearchOptionFlags::WILDCARD & nOptions ) + m_xWildcardBtn->set_sensitive(true); + else + m_xWildcardBtn->set_sensitive(false); + if ( SearchOptionFlags::EXACT & nOptions ) + m_xMatchCaseCB->set_sensitive(true); + else + m_xMatchCaseCB->set_sensitive(false); + if ( SearchOptionFlags::SELECTION & nOptions ) + m_xSelectionBtn->set_sensitive(true); + else + m_xSelectionBtn->set_sensitive(false); + if ( SearchOptionFlags::FAMILIES & nOptions ) + m_xLayoutBtn->set_sensitive(true); + else + m_xLayoutBtn->set_sensitive(false); + if ( SearchOptionFlags::FORMAT & nOptions ) + { + m_xAttributeBtn->set_sensitive(true); + m_xFormatBtn->set_sensitive(true); + m_xNoFormatBtn->set_sensitive(true); + } + else + { + m_xAttributeBtn->set_sensitive(false); + m_xFormatBtn->set_sensitive(false); + m_xNoFormatBtn->set_sensitive(false); + } + + if ( SearchOptionFlags::SIMILARITY & nOptions ) + { + m_xSimilarityBox->set_sensitive(true); + m_xSimilarityBtn->set_sensitive(true); + } + else + { + m_xSimilarityBox->set_sensitive(false); + m_xSimilarityBtn->set_sensitive(false); + } + + if ( pSearchItem ) + Init_Impl( pSearchItem->GetPattern() && + ( !pSearchList || !pSearchList->Count() ) ); +} + +void SvxSearchDialog::EnableControl_Impl(const weld::Widget& rCtrl) +{ + if (m_xSearchBtn.get() == &rCtrl && ( SearchOptionFlags::SEARCH & nOptions ) ) + { + m_xComponentFrame->set_sensitive(true); + m_xSearchBtn->set_sensitive(true); + return; + } + if ( m_xSearchAllBtn.get() == &rCtrl && + ( SearchOptionFlags::SEARCHALL & nOptions ) ) + { + m_xSearchAllBtn->set_sensitive(true); + return; + } + if ( m_xReplaceBtn.get() == &rCtrl && ( SearchOptionFlags::REPLACE & nOptions ) ) + { + m_xReplaceBtn->set_sensitive(true); + return; + } + if ( m_xReplaceAllBtn.get() == &rCtrl && + ( SearchOptionFlags::REPLACE_ALL & nOptions ) ) + { + m_xReplaceAllBtn->set_sensitive(true); + return; + } + if ( m_xWordBtn.get() == &rCtrl && ( SearchOptionFlags::WHOLE_WORDS & nOptions ) ) + { + m_xWordBtn->set_sensitive(true); + return; + } + if ( SearchOptionFlags::BACKWARDS & nOptions ) + { + if( m_xBackSearchBtn.get() == &rCtrl ) + { + m_xBackSearchBtn->set_sensitive(true); + return; + } + else if ( m_xReplaceBackwardsCB.get() == &rCtrl ) + { + m_xReplaceBackwardsCB->set_sensitive(true); + return; + } + } + if (m_xNotesBtn.get() == &rCtrl) + { + m_xNotesBtn->set_sensitive(true); + return; + } + if ( m_xRegExpBtn.get() == &rCtrl && ( SearchOptionFlags::REG_EXP & nOptions ) + && !m_xSimilarityBox->get_active() && !m_xWildcardBtn->get_active()) + { + m_xRegExpBtn->set_sensitive(true); + return; + } + if ( m_xWildcardBtn.get() == &rCtrl && ( SearchOptionFlags::WILDCARD & nOptions ) + && !m_xSimilarityBox->get_active() && !m_xRegExpBtn->get_active()) + { + m_xWildcardBtn->set_sensitive(true); + return; + } + if ( m_xMatchCaseCB.get() == &rCtrl && ( SearchOptionFlags::EXACT & nOptions ) ) + { + if (!m_xJapOptionsCB->get_active()) + m_xMatchCaseCB->set_sensitive(true); + return; + } + if ( m_xSelectionBtn.get() == &rCtrl && ( SearchOptionFlags::SELECTION & nOptions ) ) + { + m_xSelectionBtn->set_sensitive(true); + return; + } + if ( m_xLayoutBtn.get() == &rCtrl && ( SearchOptionFlags::FAMILIES & nOptions ) ) + { + m_xLayoutBtn->set_sensitive(true); + return; + } + if ( m_xAttributeBtn.get() == &rCtrl + && ( SearchOptionFlags::FORMAT & nOptions ) + && pSearchList ) + { + m_xAttributeBtn->set_sensitive( pImpl->bFocusOnSearch ); + } + if ( m_xFormatBtn.get() == &rCtrl && ( SearchOptionFlags::FORMAT & nOptions ) ) + { + m_xFormatBtn->set_sensitive(true); + return; + } + if ( m_xNoFormatBtn.get() == &rCtrl && ( SearchOptionFlags::FORMAT & nOptions ) ) + { + m_xNoFormatBtn->set_sensitive(true); + return; + } + if ( m_xSimilarityBox.get() == &rCtrl && ( SearchOptionFlags::SIMILARITY & nOptions ) + && !m_xRegExpBtn->get_active() && !m_xWildcardBtn->get_active()) + { + m_xSimilarityBox->set_sensitive(true); + + if ( m_xSimilarityBox->get_active() ) + m_xSimilarityBtn->set_sensitive(true); + } +} + +void SvxSearchDialog::SetItem_Impl( const SvxSearchItem* pItem ) +{ + //TODO: save pItem and process later if m_executingSubDialog? + if ( pItem && !m_executingSubDialog ) + { + pSearchItem.reset(pItem->Clone()); + Init_Impl( pSearchItem->GetPattern() && + ( !pSearchList || !pSearchList->Count() ) ); + } +} + +IMPL_LINK(SvxSearchDialog, FocusHdl_Impl, weld::Widget&, rControl, void) +{ + sal_Int32 nTxtLen = m_xSearchAttrText->get_label().getLength(); + weld::Widget* pCtrl = &rControl; + if (pCtrl == m_xSearchLB.get()) + { + if (pCtrl->has_focus()) + pImpl->bFocusOnSearch = true; + pCtrl = m_xSearchLB.get(); + bSearch = true; + + if( nTxtLen ) + EnableControl_Impl(*m_xNoFormatBtn); + else + m_xNoFormatBtn->set_sensitive(false); + EnableControl_Impl(*m_xAttributeBtn); + } + else + { + pImpl->bFocusOnSearch = false; + pCtrl = m_xReplaceLB.get(); + bSearch = false; + + if (!m_xReplaceAttrText->get_label().isEmpty()) + EnableControl_Impl(*m_xNoFormatBtn); + else + m_xNoFormatBtn->set_sensitive(false); + m_xAttributeBtn->set_sensitive(false); + } + bSet = true; + + weld::ComboBox &rComboBox = dynamic_cast<weld::ComboBox&>(*pCtrl); + rComboBox.select_entry_region(0, -1); + ModifyHdl_Impl(rComboBox); + + if (bFormat && nTxtLen) + m_xLayoutBtn->set_label(aLayoutStr); + else + { + SvtModuleOptions::EFactory eFactory = getModule(rBindings); + bool bWriterApp = + eFactory == SvtModuleOptions::EFactory::WRITER || + eFactory == SvtModuleOptions::EFactory::WRITERWEB || + eFactory == SvtModuleOptions::EFactory::WRITERGLOBAL; + bool bCalcApp = eFactory == SvtModuleOptions::EFactory::CALC; + + if (bWriterApp) + m_xLayoutBtn->set_label(aLayoutWriterStr); + else + { + if (bCalcApp) + m_xLayoutBtn->set_label(aLayoutCalcStr); + else + m_xLayoutBtn->set_label(aStylesStr); + } + } +} + +IMPL_LINK_NOARG(SvxSearchDialog, LoseFocusHdl_Impl, weld::Widget&, void) +{ + SaveToModule_Impl(); +} + +IMPL_LINK_NOARG(SvxSearchDialog, FormatHdl_Impl, weld::Button&, void) +{ + SfxObjectShell* pSh = SfxObjectShell::Current(); + + DBG_ASSERT( pSh, "no DocShell" ); + + if ( !pSh || !pImpl->pRanges ) + return; + + SfxItemPool& rPool = pSh->GetPool(); + SfxItemSet aSet(rPool, pImpl->pRanges.get()); + + aSet.MergeRange(SID_ATTR_PARA_MODEL, SID_ATTR_PARA_MODEL); + + sal_uInt16 nBrushWhich = pSh->GetPool().GetWhich(SID_ATTR_BRUSH); + aSet.MergeRange(nBrushWhich, nBrushWhich); + + aSet.MergeRange(XATTR_FILL_FIRST, XATTR_FILL_LAST); + + OUString aTxt; + + aSet.InvalidateAllItems(); + aSet.Put(SvxBrushItem(nBrushWhich)); + + if ( bSearch ) + { + aTxt = SvxResId( RID_SVXSTR_SEARCH ); + pSearchList->Get( aSet ); + } + else + { + aTxt = SvxResId( RID_SVXSTR_REPLACE ); + pReplaceList->Get( aSet ); + } + aSet.DisableItem(SID_ATTR_PARA_MODEL); + aSet.DisableItem(rPool.GetWhich(SID_ATTR_PARA_PAGEBREAK)); + aSet.DisableItem(rPool.GetWhich(SID_ATTR_PARA_KEEP)); + + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateTabItemDialog(m_xDialog.get(), aSet)); + pDlg->SetText( aTxt ); + + if ( executeSubDialog(pDlg.get()) == RET_OK ) + { + DBG_ASSERT( pDlg->GetOutputItemSet(), "invalid Output-Set" ); + SfxItemSet aOutSet( *pDlg->GetOutputItemSet() ); + + SearchAttrItemList* pList = bSearch ? pSearchList.get() : pReplaceList.get(); + + const SfxPoolItem* pItem; + for( sal_uInt16 n = 0; n < pList->Count(); ++n ) + { + SearchAttrItem* pAItem = &pList->GetObject(n); + if( !IsInvalidItem( pAItem->pItem ) && + SfxItemState::SET == aOutSet.GetItemState( + pAItem->pItem->Which(), false, &pItem ) ) + { + delete pAItem->pItem; + pAItem->pItem = pItem->Clone(); + aOutSet.ClearItem( pAItem->pItem->Which() ); + } + } + + if( aOutSet.Count() ) + pList->Put( aOutSet ); + + PaintAttrText_Impl(); // Set AttributText in GroupBox + } +} + +IMPL_LINK_NOARG(SvxSearchDialog, NoFormatHdl_Impl, weld::Button&, void) +{ + SvtModuleOptions::EFactory eFactory = getModule(rBindings); + bool bWriterApp = + eFactory == SvtModuleOptions::EFactory::WRITER || + eFactory == SvtModuleOptions::EFactory::WRITERWEB || + eFactory == SvtModuleOptions::EFactory::WRITERGLOBAL; + bool bCalcApp = eFactory == SvtModuleOptions::EFactory::CALC; + + if (bCalcApp) + m_xLayoutBtn->set_label( aLayoutCalcStr ); + else + { + if (bWriterApp) + m_xLayoutBtn->set_label( aLayoutWriterStr); + else + m_xLayoutBtn->set_label( aStylesStr ); + } + + bFormat = false; + m_xLayoutBtn->set_active( false ); + + bool bSetOptimalLayoutSize = false; + + if ( bSearch ) + { + pSearchList->Clear(); + m_xSearchAttrText->set_label( "" ); + if (m_xSearchAttrText->get_visible()) + { + m_xSearchAttrText->hide(); + bSetOptimalLayoutSize = true; + } + } + else + { + pReplaceList->Clear(); + m_xReplaceAttrText->set_label( "" ); + if (m_xReplaceAttrText->get_visible()) + { + m_xReplaceAttrText->hide(); + bSetOptimalLayoutSize = true; + } + } + + if (bSetOptimalLayoutSize) + m_xDialog->resize_to_request(); + + pImpl->bSaveToModule = false; + TemplateHdl_Impl(*m_xLayoutBtn); + pImpl->bSaveToModule = true; + m_xNoFormatBtn->set_sensitive(false); +} + +IMPL_LINK_NOARG(SvxSearchDialog, AttributeHdl_Impl, weld::Button&, void) +{ + if ( !pSearchList || !pImpl->pRanges ) + return; + + SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); + ScopedVclPtr<VclAbstractDialog> pDlg(pFact->CreateSvxSearchAttributeDialog(m_xDialog.get(), *pSearchList, pImpl->pRanges.get())); + executeSubDialog(pDlg.get()); + PaintAttrText_Impl(); +} + +IMPL_LINK( SvxSearchDialog, TimeoutHdl_Impl, Timer *, pTimer, void ) +{ + SfxViewShell* pViewShell = SfxViewShell::Current(); + + if ( pViewShell ) + { + if ( pViewShell->HasSelection( m_xSearchLB->get_visible() ) ) + EnableControl_Impl(*m_xSelectionBtn); + else + { + m_xSelectionBtn->set_active( false ); + m_xSelectionBtn->set_sensitive(false); + } + } + + pTimer->Start(); +} + +OUString& SvxSearchDialog::BuildAttrText_Impl( OUString& rStr, + bool bSrchFlag ) const +{ + rStr.clear(); + + SfxObjectShell* pSh = SfxObjectShell::Current(); + DBG_ASSERT( pSh, "no DocShell" ); + + if ( !pSh ) + return rStr; + + SfxItemPool& rPool = pSh->GetPool(); + SearchAttrItemList* pList = bSrchFlag ? pSearchList.get() : pReplaceList.get(); + + if ( !pList ) + return rStr; + + // Metric query + MapUnit eMapUnit = MapUnit::MapCM; + FieldUnit eFieldUnit = pSh->GetModule()->GetFieldUnit(); + switch ( eFieldUnit ) + { + case FieldUnit::MM: eMapUnit = MapUnit::MapMM; break; + case FieldUnit::CM: + case FieldUnit::M: + case FieldUnit::KM: eMapUnit = MapUnit::MapCM; break; + case FieldUnit::TWIP: eMapUnit = MapUnit::MapTwip; break; + case FieldUnit::POINT: + case FieldUnit::PICA: eMapUnit = MapUnit::MapPoint; break; + case FieldUnit::INCH: + case FieldUnit::FOOT: + case FieldUnit::MILE: eMapUnit = MapUnit::MapInch; break; + case FieldUnit::MM_100TH: eMapUnit = MapUnit::Map100thMM; break; + default: ;//prevent warning + } + + IntlWrapper aIntlWrapper(SvtSysLocale().GetUILanguageTag()); + for ( sal_uInt16 i = 0; i < pList->Count(); ++i ) + { + const SearchAttrItem& rItem = pList->GetObject(i); + + if ( !rStr.isEmpty() ) + rStr += ", "; + + if ( !IsInvalidItem( rItem.pItem ) ) + { + OUString aStr; + rPool.GetPresentation(*rItem.pItem, eMapUnit, aStr, aIntlWrapper); + rStr += aStr; + } + else if ( rItem.nSlot == SID_ATTR_BRUSH_CHAR ) + { + // Special treatment for text background + rStr += SvxResId( RID_SVXITEMS_BRUSH_CHAR ); + } + else + { + sal_uInt32 nId = SvxAttrNameTable::FindIndex(rItem.nSlot); + if ( RESARRAY_INDEX_NOTFOUND != nId ) + rStr += SvxAttrNameTable::GetString(nId); + } + } + return rStr; +} + + +void SvxSearchDialog::PaintAttrText_Impl() +{ + OUString aDesc; + BuildAttrText_Impl( aDesc, bSearch ); + + if ( !bFormat && !aDesc.isEmpty() ) + bFormat = true; + + bool bSetOptimalLayoutSize = false; + + if ( bSearch ) + { + m_xSearchAttrText->set_label( aDesc ); + if (!aDesc.isEmpty() && !m_xSearchAttrText->get_visible()) + { + m_xSearchAttrText->show(); + bSetOptimalLayoutSize = true; + } + + FocusHdl_Impl(*m_xSearchLB); + } + else + { + m_xReplaceAttrText->set_label( aDesc ); + if (!aDesc.isEmpty() && !m_xReplaceAttrText->get_visible()) + { + m_xReplaceAttrText->show(); + bSetOptimalLayoutSize = true; + } + + FocusHdl_Impl(*m_xReplaceLB); + } + + if (bSetOptimalLayoutSize) + m_xDialog->resize_to_request(); +} + +void SvxSearchDialog::SetModifyFlag_Impl( const weld::Widget* pCtrl ) +{ + if (m_xSearchLB.get() == pCtrl) + { + nModifyFlag |= ModifyFlags::Search; + m_xSearchLB->set_entry_message_type(weld::EntryMessageType::Normal); + SvxSearchDialogWrapper::SetSearchLabel(""); + } + else if ( m_xReplaceLB.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Replace; + else if ( m_xWordBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Word; + else if ( m_xMatchCaseCB.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Exact; + else if ( m_xReplaceBackwardsCB.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Backwards; + else if ( m_xNotesBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Notes; + else if ( m_xSelectionBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Selection; + else if ( m_xRegExpBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Regexp; + else if ( m_xWildcardBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Wildcard; + else if ( m_xLayoutBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Layout; + else if ( m_xSimilarityBox.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Similarity; + else if ( m_xCalcSearchInLB.get() == pCtrl ) + { + nModifyFlag |= ModifyFlags::Formulas; + nModifyFlag |= ModifyFlags::Values; + nModifyFlag |= ModifyFlags::CalcNotes; + } + else if ( m_xRowsBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Rows; + else if ( m_xColumnsBtn.get() == pCtrl ) + nModifyFlag |= ModifyFlags::Columns; + else if ( m_xAllSheetsCB.get() == pCtrl ) + nModifyFlag |= ModifyFlags::AllTables; +} + +void SvxSearchDialog::SaveToModule_Impl() +{ + if ( !pSearchItem ) + return; + + if ( m_xLayoutBtn->get_active() ) + { + pSearchItem->SetSearchString ( m_xSearchTmplLB->get_active_text() ); + pSearchItem->SetReplaceString( m_xReplaceTmplLB->get_active_text() ); + } + else + { + pSearchItem->SetSearchString ( m_xSearchLB->get_active_text() ); + pSearchItem->SetReplaceString( m_xReplaceLB->get_active_text() ); + Remember_Impl( m_xSearchLB->get_active_text(), true ); + } + + pSearchItem->SetRegExp( false ); + pSearchItem->SetWildcard( false ); + pSearchItem->SetLevenshtein( false ); + if (GetCheckBoxValue(*m_xRegExpBtn)) + pSearchItem->SetRegExp( true ); + else if (GetCheckBoxValue(*m_xWildcardBtn)) + pSearchItem->SetWildcard( true ); + else if (GetCheckBoxValue(*m_xSimilarityBox)) + pSearchItem->SetLevenshtein( true ); + + pSearchItem->SetWordOnly(GetCheckBoxValue(*m_xWordBtn)); + pSearchItem->SetBackward(GetCheckBoxValue(*m_xReplaceBackwardsCB)); + pSearchItem->SetNotes(GetCheckBoxValue(*m_xNotesBtn)); + pSearchItem->SetPattern(GetCheckBoxValue(*m_xLayoutBtn)); + pSearchItem->SetSelection(GetCheckBoxValue(*m_xSelectionBtn)); + pSearchItem->SetUseAsianOptions(GetCheckBoxValue(*m_xJapOptionsCB)); + + SvtSearchOptions aOpt; + aOpt.SetIgnoreDiacritics_CTL(GetNegatedCheckBoxValue(*m_xIncludeDiacritics)); + aOpt.SetIgnoreKashida_CTL(GetNegatedCheckBoxValue(*m_xIncludeKashida)); + aOpt.Commit(); + + TransliterationFlags nFlags = GetTransliterationFlags(); + if( !pSearchItem->IsUseAsianOptions()) + nFlags &= TransliterationFlags::IGNORE_CASE | + TransliterationFlags::IGNORE_WIDTH; + if (GetNegatedCheckBoxValue(*m_xIncludeDiacritics)) + nFlags |= TransliterationFlags::IGNORE_DIACRITICS_CTL; + if (GetNegatedCheckBoxValue(*m_xIncludeKashida)) + nFlags |= TransliterationFlags::IGNORE_KASHIDA_CTL; + pSearchItem->SetTransliterationFlags( nFlags ); + + if ( !bWriter ) + { + if (m_xCalcSearchInLB->get_active() != -1) + pSearchItem->SetCellType( static_cast<SvxSearchCellType>(m_xCalcSearchInLB->get_active()) ); + + pSearchItem->SetRowDirection( m_xRowsBtn->get_active() ); + pSearchItem->SetAllTables( m_xAllSheetsCB->get_active() ); + pSearchItem->SetSearchFormatted( m_xSearchFormattedCB->get_active() ); + } + + pSearchItem->SetCommand( SvxSearchCmd::FIND ); + nModifyFlag = ModifyFlags::NONE; + const SfxPoolItem* ppArgs[] = { pSearchItem.get(), nullptr }; + rBindings.GetDispatcher()->Execute( SID_SEARCH_ITEM, SfxCallMode::SLOT, ppArgs ); +} + +short SvxSearchDialog::executeSubDialog(VclAbstractDialog * dialog) { + assert(!m_executingSubDialog); + comphelper::ScopeGuard g([this] { m_executingSubDialog = false; }); + m_executingSubDialog = true; + return dialog->Execute(); +} + +SFX_IMPL_CHILDWINDOW_WITHID(SvxSearchDialogWrapper, SID_SEARCH_DLG); + + +SvxSearchDialogWrapper::SvxSearchDialogWrapper( vcl::Window* _pParent, sal_uInt16 nId, + SfxBindings* pBindings, + SfxChildWinInfo const * pInfo ) + : SfxChildWindow( _pParent, nId ) + , dialog(std::make_shared<SvxSearchDialog>(_pParent->GetFrameWeld(), this, *pBindings)) +{ + SetController(dialog); + dialog->Initialize( pInfo ); + + pBindings->Update( SID_SEARCH_ITEM ); + pBindings->Update( SID_SEARCH_OPTIONS ); + pBindings->Update( SID_SEARCH_SEARCHSET ); + pBindings->Update( SID_SEARCH_REPLACESET ); + dialog->bConstruct = false; +} + +SvxSearchDialogWrapper::~SvxSearchDialogWrapper () +{ +} + + +SfxChildWinInfo SvxSearchDialogWrapper::GetInfo() const +{ + SfxChildWinInfo aInfo = SfxChildWindow::GetInfo(); + aInfo.bVisible = false; + return aInfo; +} + +static void lcl_SetSearchLabelWindow(const OUString& rStr) +{ + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + if (!pViewFrame) + return; + + bool bNotFound = rStr == SvxResId(RID_SVXSTR_SEARCH_NOT_FOUND); + + css::uno::Reference< css::beans::XPropertySet > xPropSet( + pViewFrame->GetFrame().GetFrameInterface(), css::uno::UNO_QUERY_THROW); + css::uno::Reference< css::frame::XLayoutManager > xLayoutManager; + xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager; + css::uno::Reference< css::ui::XUIElement > xUIElement = + xLayoutManager->getElement("private:resource/toolbar/findbar"); + if (!xUIElement.is()) + return; + css::uno::Reference< css::awt::XWindow > xWindow( + xUIElement->getRealInterface(), css::uno::UNO_QUERY_THROW); + VclPtr< ToolBox > pToolBox = static_cast<ToolBox*>( VCLUnoHelper::GetWindow(xWindow).get() ); + for (ToolBox::ImplToolItems::size_type i = 0; pToolBox && i < pToolBox->GetItemCount(); ++i) + { + sal_uInt16 id = pToolBox->GetItemId(i); + if (pToolBox->GetItemCommand(id) == ".uno:SearchLabel") + { + LabelItemWindow* pSearchLabel = dynamic_cast<LabelItemWindow*>(pToolBox->GetItemWindow(id)); + assert(pSearchLabel); + pSearchLabel->set_label(rStr); + if (rStr.isEmpty()) + pSearchLabel->SetSizePixel(Size(16, pSearchLabel->GetSizePixel().Height())); + else + pSearchLabel->SetOptimalSize(); + } + + if (pToolBox->GetItemCommand(id) == ".uno:FindText") + { + FindTextFieldControl* pFindText = dynamic_cast<FindTextFieldControl*>(pToolBox->GetItemWindow(id)); + assert(pFindText); + if (bNotFound) + pFindText->set_entry_message_type(weld::EntryMessageType::Error); + else + pFindText->set_entry_message_type(weld::EntryMessageType::Normal); + } + } + xLayoutManager->doLayout(); + pToolBox->Resize(); +} + +OUString SvxSearchDialogWrapper::GetSearchLabel() +{ + SfxViewFrame* pViewFrame = SfxViewFrame::Current(); + if (!pViewFrame) + return OUString(); + + css::uno::Reference< css::beans::XPropertySet > xPropSet( + pViewFrame->GetFrame().GetFrameInterface(), css::uno::UNO_QUERY_THROW); + css::uno::Reference< css::frame::XLayoutManager > xLayoutManager; + xPropSet->getPropertyValue("LayoutManager") >>= xLayoutManager; + if (!xLayoutManager.is()) + return OUString(); + css::uno::Reference< css::ui::XUIElement > xUIElement = + xLayoutManager->getElement("private:resource/toolbar/findbar"); + if (!xUIElement.is()) + return OUString(); + css::uno::Reference< css::awt::XWindow > xWindow( + xUIElement->getRealInterface(), css::uno::UNO_QUERY_THROW); + VclPtr< ToolBox > pToolBox = static_cast<ToolBox*>( VCLUnoHelper::GetWindow(xWindow).get() ); + for (ToolBox::ImplToolItems::size_type i = 0; pToolBox && i < pToolBox->GetItemCount(); ++i) + { + sal_uInt16 id = pToolBox->GetItemId(i); + if (pToolBox->GetItemCommand(id) == ".uno:SearchLabel") + { + LabelItemWindow* pSearchLabel = dynamic_cast<LabelItemWindow*>(pToolBox->GetItemWindow(id)); + return pSearchLabel ? pSearchLabel->get_label() : OUString(); + } + } + return OUString(); +} + +void SvxSearchDialogWrapper::SetSearchLabel(const SearchLabel& rSL) +{ + OUString sStr; + if (rSL == SearchLabel::End) + sStr = SvxResId(RID_SVXSTR_SEARCH_END); + else if (rSL == SearchLabel::Start) + sStr = SvxResId(RID_SVXSTR_SEARCH_START); + else if (rSL == SearchLabel::EndWrapped) + sStr = SvxResId(RID_SVXSTR_SEARCH_END_WRAPPED); + else if (rSL == SearchLabel::StartWrapped) + sStr = SvxResId(RID_SVXSTR_SEARCH_START_WRAPPED); + else if (rSL == SearchLabel::EndSheet) + sStr = SvxResId(RID_SVXSTR_SEARCH_END_SHEET); + else if (rSL == SearchLabel::NotFound) + sStr = SvxResId(RID_SVXSTR_SEARCH_NOT_FOUND); + else if (rSL == SearchLabel::NavElementNotFound) + sStr = SvxResId(RID_SVXSTR_SEARCH_NAV_ELEMENT_NOT_FOUND); + else if (rSL == SearchLabel::ReminderEndWrapped) + sStr = SvxResId(RID_SVXSTR_SEARCH_REMINDER_END_WRAPPED); + else if (rSL == SearchLabel::ReminderStartWrapped) + sStr = SvxResId(RID_SVXSTR_SEARCH_REMINDER_START_WRAPPED); + + lcl_SetSearchLabelWindow(sStr); + if (SvxSearchDialogWrapper *pWrp = static_cast<SvxSearchDialogWrapper*>( SfxViewFrame::Current()-> + GetChildWindow( SvxSearchDialogWrapper::GetChildWindowId() ))) + pWrp->getDialog()->SetSearchLabel(sStr); +} + +void SvxSearchDialogWrapper::SetSearchLabel(const OUString& sStr) +{ + + lcl_SetSearchLabelWindow(sStr); + if (SvxSearchDialogWrapper *pWrp = static_cast<SvxSearchDialogWrapper*>( SfxViewFrame::Current()-> + GetChildWindow( SvxSearchDialogWrapper::GetChildWindowId() ))) + pWrp->getDialog()->SetSearchLabel(sStr); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/strarray.cxx b/svx/source/dialog/strarray.cxx new file mode 100644 index 000000000..2742c3f95 --- /dev/null +++ b/svx/source/dialog/strarray.cxx @@ -0,0 +1,98 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/strarray.hxx> +#include <tools/resary.hxx> +#include <svx/svxitems.hrc> +#include <fieldunit.hrc> +#include <numberingtype.hrc> + +sal_uInt32 SvxFieldUnitTable::Count() +{ + return SAL_N_ELEMENTS(RID_SVXSTR_FIELDUNIT_TABLE); +} + +OUString SvxFieldUnitTable::GetString(sal_uInt32 nPos) +{ + if (RESARRAY_INDEX_NOTFOUND != nPos && nPos < Count()) + return SvxResId(RID_SVXSTR_FIELDUNIT_TABLE[nPos].first); + return OUString(); +} + +FieldUnit SvxFieldUnitTable::GetValue(sal_uInt32 nPos) +{ + if (RESARRAY_INDEX_NOTFOUND != nPos && nPos < Count()) + return RID_SVXSTR_FIELDUNIT_TABLE[nPos].second; + return FieldUnit::NONE; +} + +OUString SvxAttrNameTable::GetString(sal_uInt32 nPos) +{ + if (RESARRAY_INDEX_NOTFOUND != nPos && nPos < Count()) + return SvxResId(RID_ATTR_NAMES[nPos].first); + return OUString(); +} + +sal_uInt32 SvxAttrNameTable::Count() +{ + return SAL_N_ELEMENTS(RID_ATTR_NAMES); +} + +sal_uInt32 SvxAttrNameTable::FindIndex(int nValue) +{ + for (size_t i = 0; i < SAL_N_ELEMENTS(RID_ATTR_NAMES); ++i) + { + if (nValue == RID_ATTR_NAMES[i].second) + return i; + } + return RESARRAY_INDEX_NOTFOUND; +} + +OUString SvxNumberingTypeTable::GetString(sal_uInt32 nPos) +{ + if (RESARRAY_INDEX_NOTFOUND != nPos && nPos < Count()) + return SvxResId(RID_SVXSTRARY_NUMBERINGTYPE[nPos].first); + return OUString(); +} + +sal_uInt32 SvxNumberingTypeTable::Count() +{ + return SAL_N_ELEMENTS(RID_SVXSTRARY_NUMBERINGTYPE); +} + +int SvxNumberingTypeTable::GetValue(sal_uInt32 nPos) +{ + if (RESARRAY_INDEX_NOTFOUND != nPos && nPos < Count()) + return RID_SVXSTRARY_NUMBERINGTYPE[nPos].second; + return 0; +} + +sal_uInt32 SvxNumberingTypeTable::FindIndex(int nValue) +{ + for (size_t i = 0; i < SAL_N_ELEMENTS(RID_SVXSTRARY_NUMBERINGTYPE); ++i) + { + if (nValue == RID_SVXSTRARY_NUMBERINGTYPE[i].second) + return i; + } + return RESARRAY_INDEX_NOTFOUND; +} + + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/svxbmpnumvalueset.cxx b/svx/source/dialog/svxbmpnumvalueset.cxx new file mode 100644 index 000000000..e04ae513d --- /dev/null +++ b/svx/source/dialog/svxbmpnumvalueset.cxx @@ -0,0 +1,524 @@ +/* -*- 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 <osl/diagnose.h> +#include <svx/dialmgr.hxx> +#include <svx/strings.hrc> +#include <i18nlangtag/mslangid.hxx> +#include <svtools/valueset.hxx> +#include <editeng/numitem.hxx> +#include <svx/gallery.hxx> +#include <vcl/event.hxx> +#include <vcl/graph.hxx> +#include <vcl/virdev.hxx> +#include <svx/numvset.hxx> +#include <com/sun/star/style/NumberingType.hpp> +#include <com/sun/star/container/XIndexAccess.hpp> +#include <com/sun/star/text/XNumberingFormatter.hpp> +#include <com/sun/star/beans/PropertyValue.hpp> + +#include <algorithm> + +using namespace com::sun::star::uno; +using namespace com::sun::star::beans; +using namespace com::sun::star::lang; +using namespace com::sun::star::text; +using namespace com::sun::star::container; +using namespace com::sun::star::style; + + +// The selection of bullets from the star symbol +static const sal_Unicode aBulletTypes[] = +{ + 0x2022, + 0x25cf, + 0xe00c, + 0xe00a, + 0x2794, + 0x27a2, + 0x2717, + 0x2714 +}; + +static vcl::Font& lcl_GetDefaultBulletFont() +{ + static vcl::Font aDefBulletFont = [&]() + { + static 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; +} + +static void lcl_PaintLevel(OutputDevice* pVDev, sal_Int16 nNumberingType, + const OUString& rBulletChar, const OUString& rText, const OUString& rFontName, + Point& rLeft, vcl::Font& rRuleFont, const vcl::Font& rTextFont) +{ + + if(NumberingType::CHAR_SPECIAL == nNumberingType ) + { + rRuleFont.SetStyleName(rFontName); + pVDev->SetFont(rRuleFont); + pVDev->DrawText(rLeft, rBulletChar); + rLeft.AdjustX(pVDev->GetTextWidth(rBulletChar) ); + } + else + { + pVDev->SetFont(rTextFont); + pVDev->DrawText(rLeft, rText); + rLeft.AdjustX(pVDev->GetTextWidth(rText) ); + } +} + +static const char* RID_SVXSTR_BULLET_DESCRIPTIONS[] = +{ + RID_SVXSTR_BULLET_DESCRIPTION_0, + RID_SVXSTR_BULLET_DESCRIPTION_1, + RID_SVXSTR_BULLET_DESCRIPTION_2, + RID_SVXSTR_BULLET_DESCRIPTION_3, + RID_SVXSTR_BULLET_DESCRIPTION_4, + RID_SVXSTR_BULLET_DESCRIPTION_5, + RID_SVXSTR_BULLET_DESCRIPTION_6, + RID_SVXSTR_BULLET_DESCRIPTION_7 +}; + +static const char* RID_SVXSTR_SINGLENUM_DESCRIPTIONS[] = +{ + RID_SVXSTR_SINGLENUM_DESCRIPTION_0, + RID_SVXSTR_SINGLENUM_DESCRIPTION_1, + RID_SVXSTR_SINGLENUM_DESCRIPTION_2, + RID_SVXSTR_SINGLENUM_DESCRIPTION_3, + RID_SVXSTR_SINGLENUM_DESCRIPTION_4, + RID_SVXSTR_SINGLENUM_DESCRIPTION_5, + RID_SVXSTR_SINGLENUM_DESCRIPTION_6, + RID_SVXSTR_SINGLENUM_DESCRIPTION_7 +}; + +static const char* RID_SVXSTR_OUTLINENUM_DESCRIPTIONS[] = +{ + RID_SVXSTR_OUTLINENUM_DESCRIPTION_0, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_1, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_2, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_3, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_4, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_5, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_6, + RID_SVXSTR_OUTLINENUM_DESCRIPTION_7 +}; + +void SvxNumValueSet::UserDraw( const UserDrawEvent& rUDEvt ) +{ + static const sal_uInt16 aLinesArr[] = + { + 15, 10, + 20, 30, + 25, 50, + 30, 70, + 35, 90, // up to here line positions + 5, 10, // character positions + 10, 30, + 15, 50, + 20, 70, + 25, 90, + }; + + const Color aBackColor(COL_WHITE); + const Color aTextColor(COL_BLACK); + + vcl::RenderContext* pDev = rUDEvt.GetRenderContext(); + tools::Rectangle aRect = rUDEvt.GetRect(); + sal_uInt16 nItemId = rUDEvt.GetItemId(); + + long nRectWidth = aRect.GetWidth(); + long nRectHeight = aRect.GetHeight(); + Size aRectSize(nRectWidth, aRect.GetHeight()); + Point aBLPos = aRect.TopLeft(); + vcl::Font aOldFont = pDev->GetFont(); + Color aOldColor = pDev->GetLineColor(); + pDev->SetLineColor(aTextColor); + vcl::Font aFont(OutputDevice::GetDefaultFont( + DefaultFontType::UI_SANS, MsLangId::getSystemLanguage(), GetDefaultFontFlags::OnlyOne)); + + Size aSize = aFont.GetFontSize(); + + vcl::Font aRuleFont( lcl_GetDefaultBulletFont() ); + aSize.setHeight( nRectHeight/6 ); + aRuleFont.SetFontSize(aSize); + aRuleFont.SetColor(aTextColor); + aRuleFont.SetFillColor(aBackColor); + if(ePageType == NumberingPageType::BULLET) + aFont = aRuleFont; + else if(ePageType == NumberingPageType::OUTLINE) + { + aSize.setHeight( nRectHeight/8 ); + } + aFont.SetColor(aTextColor); + aFont.SetFillColor(aBackColor); + aFont.SetFontSize( aSize ); + pDev->SetFont(aFont); + + if(!pVDev) + { + // The lines are only one time in the virtual device, only the outline + // page is currently done + pVDev = VclPtr<VirtualDevice>::Create(*pDev); + pVDev->SetMapMode(pDev->GetMapMode()); + pVDev->EnableRTL( IsRTLEnabled() ); + pVDev->SetOutputSize( aRectSize ); + aOrgRect = aRect; + pVDev->SetFillColor( aBackColor ); + pVDev->SetLineColor(COL_LIGHTGRAY); + // Draw line only once + if(ePageType != NumberingPageType::OUTLINE) + { + Point aStart(aBLPos.X() + nRectWidth *25 / 100,0); + Point aEnd(aBLPos.X() + nRectWidth * 9 / 10,0); + for( sal_uInt16 i = 11; i < 100; i += 33) + { + aStart.setY( aBLPos.Y() + nRectHeight * i / 100 ); + aEnd.setY( aStart.Y() ); + pVDev->DrawLine(aStart, aEnd); + aStart.setY( aBLPos.Y() + nRectHeight * (i + 11) / 100 ); + aEnd.setY( aStart.Y() ); + pVDev->DrawLine(aStart, aEnd); + } + } + } + pDev->DrawOutDev( aRect.TopLeft(), aRectSize, + aOrgRect.TopLeft(), aRectSize, + *pVDev ); + // Now comes the text + const OUString sValue("Value"); + if( NumberingPageType::SINGLENUM == ePageType || + NumberingPageType::BULLET == ePageType ) + { + Point aStart(aBLPos.X() + nRectWidth / 9,0); + for( sal_uInt16 i = 0; i < 3; i++ ) + { + sal_uInt16 nY = 11 + i * 33; + aStart.setY( aBLPos.Y() + nRectHeight * nY / 100 ); + OUString sText; + if(ePageType == NumberingPageType::BULLET) + { + sText = OUString( aBulletTypes[nItemId - 1] ); + aStart.AdjustY( -(pDev->GetTextHeight()/2) ); + aStart.setX( aBLPos.X() + 5 ); + } + else + { + if(xFormatter.is() && aNumSettings.getLength() > nItemId - 1) + { + Sequence<PropertyValue> aLevel = aNumSettings.getConstArray()[nItemId - 1]; + try + { + aLevel.realloc(aLevel.getLength() + 1); + PropertyValue& rValue = aLevel.getArray()[aLevel.getLength() - 1]; + rValue.Name = sValue; + rValue.Value <<= static_cast<sal_Int32>(i + 1); + sText = xFormatter->makeNumberingString( aLevel, aLocale ); + } + catch(Exception&) + { + OSL_FAIL("Exception in DefaultNumberingProvider::makeNumberingString"); + } + } + // start just next to the left edge + aStart.setX( aBLPos.X() + 2 ); + aStart.AdjustY( -(pDev->GetTextHeight()/2) ); + } + pDev->DrawText(aStart, sText); + } + } + else if(NumberingPageType::OUTLINE == ePageType ) + { + // Outline numbering has to be painted into the virtual device + // to get correct lines + // has to be made again + pVDev->SetLineColor(aBackColor); + pVDev->DrawRect(aOrgRect); + long nStartX = aOrgRect.TopLeft().X(); + long nStartY = aOrgRect.TopLeft().Y(); + + if(xFormatter.is() && aOutlineSettings.getLength() > nItemId - 1) + { + Reference<XIndexAccess> xLevel = aOutlineSettings.getArray()[nItemId - 1]; + try + { + OUString sLevelTexts[5]; + OUString sFontNames[5]; + OUString sBulletChars[5]; + sal_Int16 aNumberingTypes[5]; + OUString sPrefixes[5]; + OUString sSuffixes[5]; + sal_Int16 aParentNumberings[5]; + + sal_Int32 nLevelCount = xLevel->getCount(); + if(nLevelCount > 5) + nLevelCount = 5; + for( sal_Int32 i = 0; i < nLevelCount; i++) + { + long nTop = nStartY + nRectHeight * (aLinesArr[2 * i + 11])/100 ; + Point aLeft(nStartX + nRectWidth * (aLinesArr[2 * i + 10])/ 100, nTop ); + + Any aLevelAny = xLevel->getByIndex(i); + Sequence<PropertyValue> aLevel; + aLevelAny >>= aLevel; + aNumberingTypes[i] = 0; + aParentNumberings[i] = 0; + for(const PropertyValue& rProp : std::as_const(aLevel)) + { + if ( rProp.Name == "NumberingType" ) + rProp.Value >>= aNumberingTypes[i]; + else if ( rProp.Name == "BulletFontName" ) + rProp.Value >>= sFontNames[i]; + else if ( rProp.Name == "BulletChar" ) + rProp.Value >>= sBulletChars[i]; + else if ( rProp.Name == "Prefix" ) + rProp.Value >>= sPrefixes[i]; + else if ( rProp.Name == "Suffix" ) + rProp.Value >>= sSuffixes[i]; + else if ( rProp.Name == "ParentNumbering" ) + rProp.Value >>= aParentNumberings[i]; + } + Sequence< PropertyValue > aProperties(2); + PropertyValue* pProperties = aProperties.getArray(); + pProperties[0].Name = "NumberingType"; + pProperties[0].Value <<= aNumberingTypes[i]; + pProperties[1].Name = "Value"; + pProperties[1].Value <<= sal_Int32(1); + try + { + sLevelTexts[i] = xFormatter->makeNumberingString( aProperties, aLocale ); + } + catch(Exception&) + { + OSL_FAIL("Exception in DefaultNumberingProvider::makeNumberingString"); + } + + aLeft.AdjustY( -(pDev->GetTextHeight()/2) ); + if(!sPrefixes[i].isEmpty() && + sPrefixes[i] != " ") + { + pVDev->SetFont(aFont); + pVDev->DrawText(aLeft, sPrefixes[i]); + aLeft.AdjustX(pDev->GetTextWidth(sPrefixes[i]) ); + } + if(aParentNumberings[i]) + { + //insert old numberings here + sal_Int32 nStartLevel = std::min(static_cast<sal_Int32>(aParentNumberings[i]), i); + for(sal_Int32 nParentLevel = i - nStartLevel; nParentLevel < i; nParentLevel++) + { + OUString sTmp = sLevelTexts[nParentLevel] + "."; + lcl_PaintLevel(pVDev, + aNumberingTypes[nParentLevel], + sBulletChars[nParentLevel], + sTmp, + sFontNames[nParentLevel], + aLeft, + aRuleFont, + aFont); + } + } + lcl_PaintLevel(pVDev, + aNumberingTypes[i], + sBulletChars[i], + sLevelTexts[i], + sFontNames[i], + aLeft, + aRuleFont, + aFont); + if(!sSuffixes[i].isEmpty() && + !sSuffixes[i].startsWith(" ")) + { + pVDev->SetFont(aFont); + pVDev->DrawText(aLeft, sSuffixes[i]); + aLeft.AdjustX(pDev->GetTextWidth(sSuffixes[i]) ); + } + + long nLineTop = nStartY + nRectHeight * aLinesArr[2 * i + 1]/100 ; + Point aLineLeft(aLeft.X(), nLineTop ); + Point aLineRight(nStartX + nRectWidth * 90 /100, nLineTop ); + pVDev->SetLineColor(COL_LIGHTGRAY); + pVDev->DrawLine(aLineLeft, aLineRight); + } + + } +#ifdef DBG_UTIL + catch(Exception&) + { + static bool bAssert = false; + if(!bAssert) + { + OSL_FAIL("exception in ::UserDraw"); + bAssert = true; + } + } +#else + catch(Exception&) + { + } +#endif + } + pDev->DrawOutDev( aRect.TopLeft(), aRectSize, + aOrgRect.TopLeft(), aRectSize, + *pVDev ); + } + + pDev->SetFont(aOldFont); + pDev->SetLineColor(aOldColor); +} + +SvxNumValueSet::SvxNumValueSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow) + : ValueSet(std::move(pScrolledWindow)) + , ePageType(NumberingPageType::BULLET) + , pVDev(nullptr) +{ +} + +void SvxNumValueSet::init(NumberingPageType eType) +{ + ePageType = eType; + pVDev = nullptr; + + SetColCount( 4 ); + SetLineCount( 2 ); + SetStyle( GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER ); + if(NumberingPageType::BULLET == eType) + { + for ( sal_uInt16 i = 0; i < 8; i++ ) + { + InsertItem( i + 1, i ); + SetItemText(i + 1, SvxResId(RID_SVXSTR_BULLET_DESCRIPTIONS[i])); + } + } +} + +SvxNumValueSet::~SvxNumValueSet() +{ +} + +void SvxNumValueSet::SetNumberingSettings( + const Sequence<Sequence<PropertyValue> >& aNum, + Reference<XNumberingFormatter> const & xFormat, + const Locale& rLocale ) +{ + aNumSettings = aNum; + xFormatter = xFormat; + aLocale = rLocale; + if(aNum.getLength() > 8) + SetStyle( GetStyle()|WB_VSCROLL); + for ( sal_Int32 i = 0; i < aNum.getLength(); i++ ) + { + InsertItem( i + 1, i ); + if( i < 8 ) + SetItemText(i + 1, SvxResId(RID_SVXSTR_SINGLENUM_DESCRIPTIONS[i])); + } +} + +void SvxNumValueSet::SetOutlineNumberingSettings( + Sequence<Reference<XIndexAccess> > const & rOutline, + Reference<XNumberingFormatter> const & xFormat, + const Locale& rLocale) +{ + aOutlineSettings = rOutline; + xFormatter = xFormat; + aLocale = rLocale; + if(aOutlineSettings.getLength() > 8) + SetStyle( GetStyle() | WB_VSCROLL ); + for ( sal_Int32 i = 0; i < aOutlineSettings.getLength(); i++ ) + { + InsertItem( i + 1, i ); + if( i < 8 ) + SetItemText(i + 1, SvxResId(RID_SVXSTR_OUTLINENUM_DESCRIPTIONS[i])); + } +} + +SvxBmpNumValueSet::SvxBmpNumValueSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow) + : SvxNumValueSet(std::move(pScrolledWindow)) + , aFormatIdle("SvxBmpNumValueSet FormatIdle") + , bGrfNotFound(false) +{ +} + +void SvxBmpNumValueSet::init() +{ + SvxNumValueSet::init(NumberingPageType::BITMAP); + bGrfNotFound = false; + GalleryExplorer::BeginLocking(GALLERY_THEME_BULLETS); + SetStyle( GetStyle() | WB_VSCROLL ); + SetLineCount( 3 ); + aFormatIdle.SetPriority(TaskPriority::LOWEST); + aFormatIdle.SetInvokeHandler(LINK(this, SvxBmpNumValueSet, FormatHdl_Impl)); +} + + +SvxBmpNumValueSet::~SvxBmpNumValueSet() +{ + GalleryExplorer::EndLocking(GALLERY_THEME_BULLETS); + aFormatIdle.Stop(); +} + +void SvxBmpNumValueSet::UserDraw(const UserDrawEvent& rUDEvt) +{ + SvxNumValueSet::UserDraw(rUDEvt); + + tools::Rectangle aRect = rUDEvt.GetRect(); + vcl::RenderContext* pDev = rUDEvt.GetRenderContext(); + sal_uInt16 nItemId = rUDEvt.GetItemId(); + Point aBLPos = aRect.TopLeft(); + + long nRectHeight = aRect.GetHeight(); + Size aSize(nRectHeight/8, nRectHeight/8); + + Graphic aGraphic; + if(!GalleryExplorer::GetGraphicObj( GALLERY_THEME_BULLETS, nItemId - 1, + &aGraphic)) + { + bGrfNotFound = true; + } + else + { + Point aPos(aBLPos.X() + 5, 0); + for( sal_uInt16 i = 0; i < 3; i++ ) + { + sal_uInt16 nY = 11 + i * 33; + aPos.setY( aBLPos.Y() + nRectHeight * nY / 100 ); + aGraphic.Draw( pDev, aPos, aSize ); + } + } +} + +IMPL_LINK_NOARG(SvxBmpNumValueSet, FormatHdl_Impl, Timer *, void) +{ + // only when a graphics was not there, it needs to be formatted + if (bGrfNotFound) + { + SetFormat(); + bGrfNotFound = false; + } + Invalidate(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/svxdlg.cxx b/svx/source/dialog/svxdlg.cxx new file mode 100644 index 000000000..152811ed8 --- /dev/null +++ b/svx/source/dialog/svxdlg.cxx @@ -0,0 +1,32 @@ +/* -*- 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/svxdlg.hxx> + +SvxAbstractDialogFactory* SvxAbstractDialogFactory::Create() +{ + return dynamic_cast< SvxAbstractDialogFactory* >( VclAbstractDialogFactory::Create() ); +} + +SvxAbstractDialogFactory::~SvxAbstractDialogFactory() +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/svxgrahicitem.cxx b/svx/source/dialog/svxgrahicitem.cxx new file mode 100644 index 000000000..6a64afba8 --- /dev/null +++ b/svx/source/dialog/svxgrahicitem.cxx @@ -0,0 +1,39 @@ +/* -*- 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/svxgrahicitem.hxx> +#include <svx/svxids.hrc> + +SvxGraphicItem::SvxGraphicItem( const Graphic& rGraphic ) + : SfxPoolItem( SID_GRAPHIC ), aGraphic( rGraphic ) +{ + +} + +bool SvxGraphicItem::operator==( const SfxPoolItem& rItem) const +{ + return SfxPoolItem::operator==(rItem) && static_cast<const SvxGraphicItem&>(rItem).aGraphic == aGraphic; +} + +SvxGraphicItem* SvxGraphicItem::Clone( SfxItemPool * ) const +{ + return new SvxGraphicItem( *this ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/svxruler.cxx b/svx/source/dialog/svxruler.cxx new file mode 100644 index 000000000..1e53d7a3a --- /dev/null +++ b/svx/source/dialog/svxruler.cxx @@ -0,0 +1,3559 @@ +/* -*- 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 <cstring> +#include <climits> + +#include <vcl/builder.hxx> +#include <vcl/commandevent.hxx> +#include <vcl/event.hxx> +#include <vcl/fieldvalues.hxx> +#include <vcl/image.hxx> +#include <vcl/settings.hxx> +#include <vcl/virdev.hxx> +#include <svl/eitem.hxx> +#include <svl/rectitem.hxx> +#include <svl/hint.hxx> +#include <sfx2/dispatch.hxx> +#include <svx/strings.hrc> +#include <svx/svxids.hrc> +#include <svx/dialmgr.hxx> +#include <svx/ruler.hxx> +#include <svx/rulritem.hxx> +#include <editeng/editids.hrc> +#include <editeng/tstpitem.hxx> +#include <editeng/lrspitem.hxx> +#include <editeng/protitem.hxx> +#include <osl/diagnose.h> +#include <rtl/math.hxx> + +#include "rlrcitem.hxx" +#include <memory> + +#define CTRL_ITEM_COUNT 14 +#define GAP 10 +#define OBJECT_BORDER_COUNT 4 +#define TAB_GAP 1 +#define INDENT_GAP 2 +#define INDENT_FIRST_LINE 2 +#define INDENT_LEFT_MARGIN 3 +#define INDENT_RIGHT_MARGIN 4 +#define INDENT_COUNT 3 //without the first two old values + +struct SvxRuler_Impl { + std::unique_ptr<sal_uInt16[]> pPercBuf; + std::unique_ptr<sal_uInt16[]> pBlockBuf; + sal_uInt16 nPercSize; + long nTotalDist; + long lOldWinPos; + long lMaxLeftLogic; + long lMaxRightLogic; + long lLastLMargin; + long lLastRMargin; + std::unique_ptr<SvxProtectItem> aProtectItem; + std::unique_ptr<SfxBoolItem> pTextRTLItem; + sal_uInt16 nControlerItems; + sal_uInt16 nIdx; + sal_uInt16 nColLeftPix; + sal_uInt16 nColRightPix; // Pixel values for left / right edge + // For columns; buffered to prevent + // recalculation errors + // May be has to be widen for future values + bool bIsTableRows : 1; // mxColumnItem contains table rows instead of columns + //#i24363# tab stops relative to indent + bool bIsTabsRelativeToIndent : 1; // Tab stops relative to paragraph indent? + // false means relative to SvxRuler::GetLeftFrameMargin() + + SvxRuler_Impl() : + nPercSize(0), nTotalDist(0), + lOldWinPos(0), lMaxLeftLogic(0), lMaxRightLogic(0), + lLastLMargin(0), lLastRMargin(0), + aProtectItem(std::make_unique<SvxProtectItem>(SID_RULER_PROTECT)), + nControlerItems(0), nIdx(0), + nColLeftPix(0), nColRightPix(0), + bIsTableRows(false), + bIsTabsRelativeToIndent(true) + { + } + + void SetPercSize(sal_uInt16 nSize); + +}; + +static RulerTabData ruler_tab_svx = +{ + 0, // DPIScaleFactor to be set + 7, // ruler_tab_width + 6, // ruler_tab_height + 0, // ruler_tab_height2 + 0, // ruler_tab_width2 + 0, // ruler_tab_cwidth + 0, // ruler_tab_cwidth2 + 0, // ruler_tab_cwidth3 + 0, // ruler_tab_cwidth4 + 0, // ruler_tab_dheight + 0, // ruler_tab_dheight2 + 0, // ruler_tab_dwidth + 0, // ruler_tab_dwidth2 + 0, // ruler_tab_dwidth3 + 0, // ruler_tab_dwidth4 + 0 // ruler_tab_textoff +}; + +void SvxRuler_Impl::SetPercSize(sal_uInt16 nSize) +{ + if(nSize > nPercSize) + { + nPercSize = nSize; + pPercBuf.reset( new sal_uInt16[nPercSize] ); + pBlockBuf.reset( new sal_uInt16[nPercSize] ); + } + size_t nSize2 = sizeof(sal_uInt16) * nPercSize; + memset(pPercBuf.get(), 0, nSize2); + memset(pBlockBuf.get(), 0, nSize2); +} + +// Constructor of the ruler + +// SID_ATTR_ULSPACE, SID_ATTR_LRSPACE +// expects as parameter SvxULSpaceItem for page edge +// (either left/right or top/bottom) +// Ruler: SetMargin1, SetMargin2 + +// SID_RULER_PAGE_POS +// expects as parameter the initial value of the page and page width +// Ruler: SetPagePos + +// SID_ATTR_TABSTOP +// expects: SvxTabStopItem +// Ruler: SetTabs + +// SID_ATTR_PARA_LRSPACE +// left, right paragraph edge in H-ruler +// Ruler: SetIndents + +// SID_RULER_BORDERS +// Table borders, columns +// expects: something like SwTabCols +// Ruler: SetBorders + +static constexpr long glMinFrame = 5; // minimal frame width in pixels + +SvxRuler::SvxRuler( + vcl::Window* pParent, // StarView Parent + vcl::Window* pWin, // Output window: is used for conversion + // logical units <-> pixels + SvxRulerSupportFlags flags, // Display flags, see ruler.hxx + SfxBindings &rBindings, // associated Bindings + WinBits nWinStyle) : // StarView WinBits + Ruler(pParent, nWinStyle), + pCtrlItems(CTRL_ITEM_COUNT), + pEditWin(pWin), + mxRulerImpl(new SvxRuler_Impl), + bAppSetNullOffset(false), // Is the 0-offset of the ruler set by the application? + lLogicNullOffset(0), + lAppNullOffset(LONG_MAX), + lInitialDragPos(0), + nFlags(flags), + nDragType(SvxRulerDragFlags::NONE), + nDefTabType(RULER_TAB_LEFT), + nTabCount(0), + nTabBufSize(0), + lDefTabDist(50), + lTabPos(-1), + mpBorders(1), // due to one column tables + pBindings(&rBindings), + nDragOffset(0), + nMaxLeft(0), + nMaxRight(0), + bValid(false), + bListening(false), + bActive(true), + mbCoarseSnapping(false), + mbSnapping(true) + +{ + /* Constructor; Initialize data buffer; controller items are created */ + + rBindings.EnterRegistrations(); + + // Create Supported Items + sal_uInt16 i = 0; + + // Page edges + pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_LR_MIN_MAX, *this, rBindings)); + if((nWinStyle & WB_VSCROLL) == WB_VSCROLL) + { + bHorz = false; + pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_LONG_ULSPACE, *this, rBindings)); + } + else + { + bHorz = true; + pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_LONG_LRSPACE, *this, rBindings)); + } + + // Page Position + pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_PAGE_POS, *this, rBindings)); + + if(nFlags & SvxRulerSupportFlags::TABS) + { + sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL; + pCtrlItems[i++].reset(new SvxRulerItem(nTabStopId, *this, rBindings)); + SetExtraType(RulerExtra::Tab, nDefTabType); + } + + if(nFlags & (SvxRulerSupportFlags::PARAGRAPH_MARGINS |SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL)) + { + if(bHorz) + pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_PARA_LRSPACE, *this, rBindings)); + else + pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_PARA_LRSPACE_VERTICAL, *this, rBindings)); + + mpIndents.resize(5 + INDENT_GAP); + + for(RulerIndent & rIndent : mpIndents) + { + rIndent.nPos = 0; + rIndent.nStyle = RulerIndentStyle::Top; + } + + mpIndents[0].nStyle = RulerIndentStyle::Top; + mpIndents[1].nStyle = RulerIndentStyle::Top; + mpIndents[INDENT_FIRST_LINE].nStyle = RulerIndentStyle::Top; + mpIndents[INDENT_LEFT_MARGIN].nStyle = RulerIndentStyle::Bottom; + mpIndents[INDENT_RIGHT_MARGIN].nStyle = RulerIndentStyle::Bottom; + } + + if( (nFlags & SvxRulerSupportFlags::BORDERS) == SvxRulerSupportFlags::BORDERS ) + { + pCtrlItems[i++].reset(new SvxRulerItem(bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL, *this, rBindings)); + pCtrlItems[i++].reset(new SvxRulerItem(bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL, *this, rBindings)); + } + + pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_TEXT_RIGHT_TO_LEFT, *this, rBindings)); + + if( (nFlags & SvxRulerSupportFlags::OBJECT) == SvxRulerSupportFlags::OBJECT ) + { + pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_OBJECT, *this, rBindings)); + mpObjectBorders.resize(OBJECT_BORDER_COUNT); + for(sal_uInt16 nBorder = 0; nBorder < OBJECT_BORDER_COUNT; ++nBorder) + { + mpObjectBorders[nBorder].nPos = 0; + mpObjectBorders[nBorder].nWidth = 0; + mpObjectBorders[nBorder].nStyle = RulerBorderStyle::Moveable; + } + } + + pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_PROTECT, *this, rBindings)); + pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_BORDER_DISTANCE, *this, rBindings)); + mxRulerImpl->nControlerItems=i; + + if( (nFlags & SvxRulerSupportFlags::SET_NULLOFFSET) == SvxRulerSupportFlags::SET_NULLOFFSET ) + SetExtraType(RulerExtra::NullOffset); + + rBindings.LeaveRegistrations(); + + ruler_tab_svx.DPIScaleFactor = pParent->GetDPIScaleFactor(); + ruler_tab_svx.height *= ruler_tab_svx.DPIScaleFactor; + ruler_tab_svx.width *= ruler_tab_svx.DPIScaleFactor; + +} + +SvxRuler::~SvxRuler() +{ + disposeOnce(); +} + +void SvxRuler::dispose() +{ + /* Destructor ruler; release internal buffer */ + if(bListening) + EndListening(*pBindings); + + pBindings->EnterRegistrations(); + + pCtrlItems.clear(); + + pBindings->LeaveRegistrations(); + + pEditWin.clear(); + Ruler::dispose(); +} + +long SvxRuler::MakePositionSticky(long aPosition, long aPointOfReference, bool aSnapToFrameMargin) const +{ + long aPointOfReferencePixel = ConvertHPosPixel(aPointOfReference); + long aLeftFramePosition = ConvertHPosPixel(GetLeftFrameMargin()); + long aRightFramePosition = ConvertHPosPixel(GetRightFrameMargin()); + + double aTick = GetCurrentRulerUnit().nTick1; + + if (mbCoarseSnapping) + aTick = GetCurrentRulerUnit().nTick2; + + long aTickPixel = pEditWin->LogicToPixel(Size(aTick, 0), GetCurrentMapMode()).Width(); + + double aHalfTick = aTick / 2.0; + double aHalfTickPixel = aTickPixel / 2.0; + + if (aSnapToFrameMargin) + { + if (aPosition > aLeftFramePosition - aHalfTickPixel && aPosition < aLeftFramePosition + aHalfTickPixel) + return aLeftFramePosition; + + if (aPosition > aRightFramePosition - aHalfTickPixel && aPosition < aRightFramePosition + aHalfTickPixel) + return aRightFramePosition; + } + + if (!mbSnapping) + return aPosition; + + // Move "coordinate system" to frame position so ticks are calculated correctly + long aTranslatedPosition = aPosition - aPointOfReferencePixel; + // Convert position to current selected map mode + long aPositionLogic = pEditWin->PixelToLogic(Size(aTranslatedPosition, 0), GetCurrentMapMode()).Width(); + // Normalize -- snap to nearest tick + aPositionLogic = rtl::math::round((aPositionLogic + aHalfTick) / aTick) * aTick; + // Convert back to pixels + aPosition = pEditWin->LogicToPixel(Size(aPositionLogic, 0), GetCurrentMapMode()).Width(); + // Move "coordinate system" back to original position + return aPosition + aPointOfReferencePixel; +} + +long SvxRuler::ConvertHPosPixel(long nVal) const +{ + return pEditWin->LogicToPixel(Size(nVal, 0)).Width(); +} + +long SvxRuler::ConvertVPosPixel(long nVal) const +{ + return pEditWin->LogicToPixel(Size(0, nVal)).Height(); +} + +long SvxRuler::ConvertHSizePixel(long nVal) const +{ + return pEditWin->LogicToPixel(Size(nVal, 0)).Width(); +} + +long SvxRuler::ConvertVSizePixel(long nVal) const +{ + return pEditWin->LogicToPixel(Size(0, nVal)).Height(); +} + +long SvxRuler::ConvertPosPixel(long nVal) const +{ + return bHorz ? ConvertHPosPixel(nVal): ConvertVPosPixel(nVal); +} + +long SvxRuler::ConvertSizePixel(long nVal) const +{ + return bHorz? ConvertHSizePixel(nVal): ConvertVSizePixel(nVal); +} + +inline long SvxRuler::ConvertHPosLogic(long nVal) const +{ + return pEditWin->PixelToLogic(Size(nVal, 0)).Width(); +} + +inline long SvxRuler::ConvertVPosLogic(long nVal) const +{ + return pEditWin->PixelToLogic(Size(0, nVal)).Height(); +} + +inline long SvxRuler::ConvertHSizeLogic(long nVal) const +{ + return pEditWin->PixelToLogic(Size(nVal, 0)).Width(); +} + +inline long SvxRuler::ConvertVSizeLogic(long nVal) const +{ + return pEditWin->PixelToLogic(Size(0, nVal)).Height(); +} + +inline long SvxRuler::ConvertPosLogic(long nVal) const +{ + return bHorz? ConvertHPosLogic(nVal): ConvertVPosLogic(nVal); +} + +inline long SvxRuler::ConvertSizeLogic(long nVal) const +{ + return bHorz? ConvertHSizeLogic(nVal): ConvertVSizeLogic(nVal); +} + +long SvxRuler::PixelHAdjust(long nVal, long nValOld) const +{ + if(ConvertHSizePixel(nVal) != ConvertHSizePixel(nValOld)) + return nVal; + else + return nValOld; +} + +long SvxRuler::PixelVAdjust(long nVal, long nValOld) const +{ + if(ConvertVSizePixel(nVal) != ConvertVSizePixel(nValOld)) + return nVal; + else + return nValOld; +} + +long SvxRuler::PixelAdjust(long nVal, long nValOld) const +{ + if(ConvertSizePixel(nVal) != ConvertSizePixel(nValOld)) + return nVal; + else + return nValOld; +} + +inline sal_uInt16 SvxRuler::GetObjectBordersOff(sal_uInt16 nIdx) const +{ + return bHorz ? nIdx : nIdx + 2; +} + +/* + Update Upper Left edge. + Items are translated into the representation of the ruler. +*/ +void SvxRuler::UpdateFrame() +{ + const RulerMarginStyle nMarginStyle = + ( mxRulerImpl->aProtectItem->IsSizeProtected() || + mxRulerImpl->aProtectItem->IsPosProtected() ) ? + RulerMarginStyle::NONE : RulerMarginStyle::Sizeable; + + if(mxLRSpaceItem && mxPagePosItem) + { + // if no initialization by default app behavior + const long nOld = lLogicNullOffset; + lLogicNullOffset = mxColumnItem ? mxColumnItem->GetLeft() : mxLRSpaceItem->GetLeft(); + + if(bAppSetNullOffset) + { + lAppNullOffset += lLogicNullOffset - nOld; + } + + if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX) + { + Ruler::SetNullOffset(ConvertHPosPixel(lLogicNullOffset)); + SetMargin1(0, nMarginStyle); + lAppNullOffset = 0; + } + else + { + SetMargin1(ConvertHPosPixel(lAppNullOffset), nMarginStyle); + } + + long lRight = 0; + + // evaluate the table right edge of the table + if(mxColumnItem && mxColumnItem->IsTable()) + lRight = mxColumnItem->GetRight(); + else + lRight = mxLRSpaceItem->GetRight(); + + long aWidth = mxPagePosItem->GetWidth() - lRight - lLogicNullOffset + lAppNullOffset; + long aWidthPixel = ConvertHPosPixel(aWidth); + + SetMargin2(aWidthPixel, nMarginStyle); + } + else if(mxULSpaceItem && mxPagePosItem) + { + // relative the upper edge of the surrounding frame + const long nOld = lLogicNullOffset; + lLogicNullOffset = mxColumnItem ? mxColumnItem->GetLeft() : mxULSpaceItem->GetUpper(); + + if(bAppSetNullOffset) + { + lAppNullOffset += lLogicNullOffset - nOld; + } + + if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX) + { + Ruler::SetNullOffset(ConvertVPosPixel(lLogicNullOffset)); + lAppNullOffset = 0; + SetMargin1(0, nMarginStyle); + } + else + { + SetMargin1(ConvertVPosPixel(lAppNullOffset), nMarginStyle); + } + + long lLower = mxColumnItem ? mxColumnItem->GetRight() : mxULSpaceItem->GetLower(); + long nMargin2 = mxPagePosItem->GetHeight() - lLower - lLogicNullOffset + lAppNullOffset; + long nMargin2Pixel = ConvertVPosPixel(nMargin2); + + SetMargin2(nMargin2Pixel, nMarginStyle); + } + else + { + // turns off the view + SetMargin1(); + SetMargin2(); + } + + if (mxColumnItem) + { + mxRulerImpl->nColLeftPix = static_cast<sal_uInt16>(ConvertSizePixel(mxColumnItem->GetLeft())); + mxRulerImpl->nColRightPix = static_cast<sal_uInt16>(ConvertSizePixel(mxColumnItem->GetRight())); + } +} + +void SvxRuler::MouseMove( const MouseEvent& rMEvt ) +{ + if( bActive ) + { + pBindings->Update( SID_RULER_LR_MIN_MAX ); + pBindings->Update( SID_ATTR_LONG_ULSPACE ); + pBindings->Update( SID_ATTR_LONG_LRSPACE ); + pBindings->Update( SID_RULER_PAGE_POS ); + pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL); + pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL); + pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL); + pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL); + pBindings->Update( SID_RULER_OBJECT ); + pBindings->Update( SID_RULER_PROTECT ); + } + + Ruler::MouseMove( rMEvt ); + + RulerSelection aSelection = GetHoverSelection(); + + if (aSelection.eType == RulerType::DontKnow) + { + SetQuickHelpText(""); + return; + } + + RulerUnitData aUnitData = GetCurrentRulerUnit(); + double aRoundingFactor = aUnitData.nTickUnit / aUnitData.nTick1; + sal_Int32 aNoDecimalPlaces = 1 + std::ceil(std::log10(aRoundingFactor)); + OUString sUnit = OUString::createFromAscii(aUnitData.aUnitStr); + + switch (aSelection.eType) + { + case RulerType::Indent: + { + if (!mxParaItem) + break; + + long nIndex = aSelection.nAryPos + INDENT_GAP; + + long nIndentValue = 0.0; + if (nIndex == INDENT_LEFT_MARGIN) + nIndentValue = mxParaItem->GetTextLeft(); + else if (nIndex == INDENT_FIRST_LINE) + nIndentValue = mxParaItem->GetTextFirstLineOffset(); + else if (nIndex == INDENT_RIGHT_MARGIN) + nIndentValue = mxParaItem->GetRight(); + + double fValue = OutputDevice::LogicToLogic(Size(nIndentValue, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width(); + fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces); + + SetQuickHelpText(OUString::number(fValue) + " " + sUnit); + break; + } + case RulerType::Border: + { + if (mxColumnItem == nullptr) + break; + + SvxColumnItem& aColumnItem = *mxColumnItem; + + if (aSelection.nAryPos + 1 >= aColumnItem.Count()) + break; + + double fStart = OutputDevice::LogicToLogic(Size(aColumnItem[aSelection.nAryPos].nEnd, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width(); + fStart = rtl::math::round(fStart / aUnitData.nTickUnit, aNoDecimalPlaces); + double fEnd = OutputDevice::LogicToLogic(Size(aColumnItem[aSelection.nAryPos + 1].nStart, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width(); + fEnd = rtl::math::round(fEnd / aUnitData.nTickUnit, aNoDecimalPlaces); + + SetQuickHelpText( + OUString::number(fStart) + " " + sUnit + " - " + + OUString::number(fEnd) + " " + sUnit ); + break; + } + case RulerType::Margin1: + { + long nLeft = 0.0; + if (mxLRSpaceItem) + nLeft = mxLRSpaceItem->GetLeft(); + else if (mxULSpaceItem) + nLeft = mxULSpaceItem->GetUpper(); + else + break; + + double fValue = OutputDevice::LogicToLogic(Size(nLeft, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width(); + fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces); + SetQuickHelpText(OUString::number(fValue) + " " + sUnit); + + break; + } + case RulerType::Margin2: + { + long nRight = 0.0; + if (mxLRSpaceItem) + nRight = mxLRSpaceItem->GetRight(); + else if (mxULSpaceItem) + nRight = mxULSpaceItem->GetLower(); + else + break; + + double fValue = OutputDevice::LogicToLogic(Size(nRight, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width(); + fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces); + SetQuickHelpText(OUString::number(fValue) + " " + sUnit); + + break; + } + default: + { + SetQuickHelpText(""); + break; + } + } +} + +void SvxRuler::StartListening_Impl() +{ + if(!bListening) + { + bValid = false; + StartListening(*pBindings); + bListening = true; + } +} + +void SvxRuler::UpdateFrame(const SvxLongLRSpaceItem *pItem) // new value LRSpace +{ + /* Store new value LRSpace; delete old ones if possible */ + if(bActive) + { + if(pItem) + mxLRSpaceItem.reset(new SvxLongLRSpaceItem(*pItem)); + else + mxLRSpaceItem.reset(); + StartListening_Impl(); + } +} + +void SvxRuler::UpdateFrameMinMax(const SfxRectangleItem *pItem) // value for MinMax +{ + /* Set new value for MinMax; delete old ones if possible */ + if(bActive) + { + if(pItem) + mxMinMaxItem.reset(new SfxRectangleItem(*pItem)); + else + mxMinMaxItem.reset(); + } +} + + +void SvxRuler::UpdateFrame(const SvxLongULSpaceItem *pItem) // new value +{ + /* Update Right/bottom margin */ + if(bActive && !bHorz) + { + if(pItem) + mxULSpaceItem.reset(new SvxLongULSpaceItem(*pItem)); + else + mxULSpaceItem.reset(); + StartListening_Impl(); + } +} + +void SvxRuler::Update( const SvxProtectItem* pItem ) +{ + if( pItem ) + mxRulerImpl->aProtectItem.reset(pItem->Clone()); +} + +void SvxRuler::UpdateTextRTL(const SfxBoolItem* pItem) +{ + if(bActive && bHorz) + { + mxRulerImpl->pTextRTLItem.reset(); + if(pItem) + mxRulerImpl->pTextRTLItem.reset(new SfxBoolItem(*pItem)); + SetTextRTL(mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue()); + StartListening_Impl(); + } +} + +void SvxRuler::Update( + const SvxColumnItem *pItem, // new value + sal_uInt16 nSID) //Slot Id to identify NULL items +{ + /* Set new value for column view */ + if(bActive) + { + if(pItem) + { + mxColumnItem.reset(new SvxColumnItem(*pItem)); + mxRulerImpl->bIsTableRows = (pItem->Which() == SID_RULER_ROWS || pItem->Which() == SID_RULER_ROWS_VERTICAL); + if(!bHorz && !mxRulerImpl->bIsTableRows) + mxColumnItem->SetWhich(SID_RULER_BORDERS_VERTICAL); + } + else if(mxColumnItem && mxColumnItem->Which() == nSID) + //there are two groups of column items table/frame columns and table rows + //both can occur in vertical or horizontal mode + //the horizontal ruler handles the SID_RULER_BORDERS and SID_RULER_ROWS_VERTICAL + //and the vertical handles SID_RULER_BORDERS_VERTICAL and SID_RULER_ROWS + //if mxColumnItem is already set with one of the ids then a NULL pItem argument + //must not delete it + { + mxColumnItem.reset(); + mxRulerImpl->bIsTableRows = false; + } + StartListening_Impl(); + } +} + + +void SvxRuler::UpdateColumns() +{ + /* Update column view */ + if(mxColumnItem && mxColumnItem->Count() > 1) + { + mpBorders.resize(mxColumnItem->Count()); + + RulerBorderStyle nStyleFlags = RulerBorderStyle::Variable; + + bool bProtectColumns = + mxRulerImpl->aProtectItem->IsSizeProtected() || + mxRulerImpl->aProtectItem->IsPosProtected(); + + if( !bProtectColumns ) + { + nStyleFlags |= RulerBorderStyle::Moveable; + if( !mxColumnItem->IsTable() ) + nStyleFlags |= RulerBorderStyle::Sizeable; + } + + sal_uInt16 nBorders = mxColumnItem->Count(); + + if(!mxRulerImpl->bIsTableRows) + --nBorders; + + for(sal_uInt16 i = 0; i < nBorders; ++i) + { + mpBorders[i].nStyle = nStyleFlags; + if(!mxColumnItem->At(i).bVisible) + mpBorders[i].nStyle |= RulerBorderStyle::Invisible; + + mpBorders[i].nPos = ConvertPosPixel(mxColumnItem->At(i).nEnd + lAppNullOffset); + + if(mxColumnItem->Count() == i + 1) + { + //with table rows the end of the table is contained in the + //column item but it has no width! + mpBorders[i].nWidth = 0; + } + else + { + mpBorders[i].nWidth = ConvertSizePixel(mxColumnItem->At(i + 1).nStart - mxColumnItem->At(i).nEnd); + } + mpBorders[i].nMinPos = ConvertPosPixel(mxColumnItem->At(i).nEndMin + lAppNullOffset); + mpBorders[i].nMaxPos = ConvertPosPixel(mxColumnItem->At(i).nEndMax + lAppNullOffset); + } + SetBorders(mxColumnItem->Count() - 1, mpBorders.data()); + } + else + { + SetBorders(); + } +} + +void SvxRuler::UpdateObject() +{ + /* Update view of object representation */ + if (mxObjectItem) + { + DBG_ASSERT(!mpObjectBorders.empty(), "no Buffer"); + // !! to the page margin + long nMargin = mxLRSpaceItem ? mxLRSpaceItem->GetLeft() : 0; + mpObjectBorders[0].nPos = + ConvertPosPixel(mxObjectItem->GetStartX() - + nMargin + lAppNullOffset); + mpObjectBorders[1].nPos = + ConvertPosPixel(mxObjectItem->GetEndX() - nMargin + lAppNullOffset); + nMargin = mxULSpaceItem ? mxULSpaceItem->GetUpper() : 0; + mpObjectBorders[2].nPos = + ConvertPosPixel(mxObjectItem->GetStartY() - + nMargin + lAppNullOffset); + mpObjectBorders[3].nPos = + ConvertPosPixel(mxObjectItem->GetEndY() - nMargin + lAppNullOffset); + + const sal_uInt16 nOffset = GetObjectBordersOff(0); + SetBorders(2, mpObjectBorders.data() + nOffset); + } + else + { + SetBorders(); + } +} + +void SvxRuler::UpdatePara() +{ + + /* Update the view for paragraph indents: + Left margin, first line indent, right margin paragraph update + mpIndents[0] = Buffer for old intent + mpIndents[1] = Buffer for old intent + mpIndents[INDENT_FIRST_LINE] = first line indent + mpIndents[INDENT_LEFT_MARGIN] = left margin + mpIndents[INDENT_RIGHT_MARGIN] = right margin + */ + + // Dependence on PagePosItem + if (mxParaItem && mxPagePosItem && !mxObjectItem) + { + bool bRTLText = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + // First-line indent is negative to the left paragraph margin + long nLeftFrameMargin = GetLeftFrameMargin(); + long nRightFrameMargin = GetRightFrameMargin(); + SetLeftFrameMargin(ConvertHPosPixel(nLeftFrameMargin)); + SetRightFrameMargin(ConvertHPosPixel(nRightFrameMargin)); + + long leftMargin; + long leftFirstLine; + long rightMargin; + + if(bRTLText) + { + leftMargin = nRightFrameMargin - mxParaItem->GetTextLeft() + lAppNullOffset; + leftFirstLine = leftMargin - mxParaItem->GetTextFirstLineOffset(); + rightMargin = nLeftFrameMargin + mxParaItem->GetRight() + lAppNullOffset; + } + else + { + leftMargin = nLeftFrameMargin + mxParaItem->GetTextLeft() + lAppNullOffset; + leftFirstLine = leftMargin + mxParaItem->GetTextFirstLineOffset(); + rightMargin = nRightFrameMargin - mxParaItem->GetRight() + lAppNullOffset; + } + + mpIndents[INDENT_LEFT_MARGIN].nPos = ConvertHPosPixel(leftMargin); + mpIndents[INDENT_FIRST_LINE].nPos = ConvertHPosPixel(leftFirstLine); + mpIndents[INDENT_RIGHT_MARGIN].nPos = ConvertHPosPixel(rightMargin); + + mpIndents[INDENT_FIRST_LINE].bInvisible = mxParaItem->IsAutoFirst(); + + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + else + { + if(!mpIndents.empty()) + { + mpIndents[INDENT_FIRST_LINE].nPos = 0; + mpIndents[INDENT_LEFT_MARGIN].nPos = 0; + mpIndents[INDENT_RIGHT_MARGIN].nPos = 0; + } + SetIndents(); // turn off + } +} + +void SvxRuler::UpdatePara(const SvxLRSpaceItem *pItem) // new value of paragraph indents +{ + /* Store new value of paragraph indents */ + if(bActive) + { + if(pItem) + mxParaItem.reset(new SvxLRSpaceItem(*pItem)); + else + mxParaItem.reset(); + StartListening_Impl(); + } +} + +void SvxRuler::UpdateParaBorder() +{ + /* Border distance */ + if(bActive) + { + StartListening_Impl(); + } +} + +void SvxRuler::UpdatePage() +{ + /* Update view of position and width of page */ + if (mxPagePosItem) + { + // all objects are automatically adjusted + if(bHorz) + { + SetPagePos( + pEditWin->LogicToPixel(mxPagePosItem->GetPos()).X(), + pEditWin->LogicToPixel(Size(mxPagePosItem->GetWidth(), 0)). + Width()); + } + else + { + SetPagePos( + pEditWin->LogicToPixel(mxPagePosItem->GetPos()).Y(), + pEditWin->LogicToPixel(Size(0, mxPagePosItem->GetHeight())). + Height()); + } + if(bAppSetNullOffset) + SetNullOffset(ConvertSizePixel(-lAppNullOffset + lLogicNullOffset)); + } + else + { + SetPagePos(); + } + + long lPos = 0; + Point aOwnPos = GetPosPixel(); + Point aEdtWinPos = pEditWin->GetPosPixel(); + if( AllSettings::GetLayoutRTL() && bHorz ) + { + //#i73321# in RTL the window and the ruler is not mirrored but the + // influence of the vertical ruler is inverted + Size aOwnSize = GetSizePixel(); + Size aEdtWinSize = pEditWin->GetSizePixel(); + lPos = aOwnSize.Width() - aEdtWinSize.Width(); + lPos -= (aEdtWinPos - aOwnPos).X(); + } + else + { + Point aPos(aEdtWinPos - aOwnPos); + lPos = bHorz ? aPos.X() : aPos.Y(); + } + + // Unfortunately, we get the offset of the edit window to the ruler never + // through a status message. So we set it ourselves if necessary. + if(lPos != mxRulerImpl->lOldWinPos) + { + mxRulerImpl->lOldWinPos=lPos; + SetWinPos(lPos); + } +} + +void SvxRuler::Update(const SvxPagePosSizeItem *pItem) // new value of page attributes +{ + /* Store new value of page attributes */ + if(bActive) + { + if(pItem) + mxPagePosItem.reset(new SvxPagePosSizeItem(*pItem)); + else + mxPagePosItem.reset(); + StartListening_Impl(); + } +} + +void SvxRuler::SetDefTabDist(long inDefTabDist) // New distance for DefaultTabs in App-Metrics +{ + if (lAppNullOffset == LONG_MAX) + UpdateFrame(); // hack: try to get lAppNullOffset initialized + /* New distance is set for DefaultTabs */ + lDefTabDist = inDefTabDist; + UpdateTabs(); +} + +static sal_uInt16 ToSvTab_Impl(SvxTabAdjust eAdj) +{ + /* Internal conversion routine between SV-Tab.-Enum and Svx */ + switch(eAdj) { + case SvxTabAdjust::Left: return RULER_TAB_LEFT; + case SvxTabAdjust::Right: return RULER_TAB_RIGHT; + case SvxTabAdjust::Decimal: return RULER_TAB_DECIMAL; + case SvxTabAdjust::Center: return RULER_TAB_CENTER; + case SvxTabAdjust::Default: return RULER_TAB_DEFAULT; + default: ; //prevent warning + } + return 0; +} + +static SvxTabAdjust ToAttrTab_Impl(sal_uInt16 eAdj) +{ + switch(eAdj) { + case RULER_TAB_LEFT: return SvxTabAdjust::Left ; + case RULER_TAB_RIGHT: return SvxTabAdjust::Right ; + case RULER_TAB_DECIMAL: return SvxTabAdjust::Decimal ; + case RULER_TAB_CENTER: return SvxTabAdjust::Center ; + case RULER_TAB_DEFAULT: return SvxTabAdjust::Default ; + } + return SvxTabAdjust::Left; +} + +void SvxRuler::UpdateTabs() +{ + if(IsDrag()) + return; + + if (mxPagePosItem && mxParaItem && mxTabStopItem && !mxObjectItem) + { + // buffer for DefaultTabStop + // Distance last Tab <-> Right paragraph margin / DefaultTabDist + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + + const long nLeftFrameMargin = GetLeftFrameMargin(); + const long nRightFrameMargin = GetRightFrameMargin(); + + //#i24363# tab stops relative to indent + const long nParaItemTxtLeft = mxParaItem->GetTextLeft(); + + const long lParaIndent = nLeftFrameMargin + nParaItemTxtLeft; + const long lRightMargin = nRightFrameMargin - nParaItemTxtLeft; + + const long lLastTab = mxTabStopItem->Count() + ? ConvertHPosPixel(mxTabStopItem->At(mxTabStopItem->Count() - 1).GetTabPos()) + : 0; + const long lPosPixel = ConvertHPosPixel(lParaIndent) + lLastTab; + const long lRightIndent = ConvertHPosPixel(nRightFrameMargin - mxParaItem->GetRight()); + + long nDefTabDist = ConvertHPosPixel(lDefTabDist); + + if( !nDefTabDist ) + nDefTabDist = 1; + + const sal_uInt16 nDefTabBuf = lPosPixel > lRightIndent || lLastTab > lRightIndent + ? 0 + : static_cast<sal_uInt16>( (lRightIndent - lPosPixel) / nDefTabDist ); + + if(mxTabStopItem->Count() + TAB_GAP + nDefTabBuf > nTabBufSize) + { + // 10 (GAP) in stock + nTabBufSize = mxTabStopItem->Count() + TAB_GAP + nDefTabBuf + GAP; + mpTabs.resize(nTabBufSize); + } + + nTabCount = 0; + sal_uInt16 j; + + const long lParaIndentPix = ConvertSizePixel(lParaIndent); + + long lTabStartLogic = (mxRulerImpl->bIsTabsRelativeToIndent ? lParaIndent : nLeftFrameMargin) + + lAppNullOffset; + if (bRTL) + { + lTabStartLogic = lParaIndent + lRightMargin - lTabStartLogic; + } + long lLastTabOffsetLogic = 0; + for(j = 0; j < mxTabStopItem->Count(); ++j) + { + const SvxTabStop* pTab = &mxTabStopItem->At(j); + lLastTabOffsetLogic = pTab->GetTabPos(); + long lPos = lTabStartLogic + (bRTL ? -lLastTabOffsetLogic : lLastTabOffsetLogic); + mpTabs[nTabCount + TAB_GAP].nPos = ConvertHPosPixel(lPos); + mpTabs[nTabCount + TAB_GAP].nStyle = ToSvTab_Impl(pTab->GetAdjustment()); + ++nTabCount; + } + + // Adjust to previous-to-first default tab stop + lLastTabOffsetLogic -= lLastTabOffsetLogic % lDefTabDist; + + // fill the rest with default Tabs + for (j = 0; j < nDefTabBuf; ++j) + { + //simply add the default distance to the last position + lLastTabOffsetLogic += lDefTabDist; + if (bRTL) + { + mpTabs[nTabCount + TAB_GAP].nPos = + ConvertHPosPixel(lTabStartLogic - lLastTabOffsetLogic); + if (mpTabs[nTabCount + TAB_GAP].nPos <= lParaIndentPix) + break; + } + else + { + mpTabs[nTabCount + TAB_GAP].nPos = + ConvertHPosPixel(lTabStartLogic + lLastTabOffsetLogic); + if (mpTabs[nTabCount + TAB_GAP].nPos >= lRightIndent) + break; + } + + mpTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT; + ++nTabCount; + } + SetTabs(nTabCount, mpTabs.data() + TAB_GAP); + DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize too small"); + } + else + { + SetTabs(); + } +} + +void SvxRuler::Update(const SvxTabStopItem *pItem) // new value for tabs +{ + /* Store new value for tabs; delete old ones if possible */ + if(bActive) + { + if(pItem) + { + mxTabStopItem.reset(new SvxTabStopItem(*pItem)); + if(!bHorz) + mxTabStopItem->SetWhich(SID_ATTR_TABSTOP_VERTICAL); + } + else + { + mxTabStopItem.reset(); + } + StartListening_Impl(); + } +} + +void SvxRuler::Update(const SvxObjectItem *pItem) // new value for objects +{ + /* Store new value for objects */ + if(bActive) + { + if(pItem) + mxObjectItem.reset(new SvxObjectItem(*pItem)); + else + mxObjectItem.reset(); + StartListening_Impl(); + } +} + +void SvxRuler::SetNullOffsetLogic(long lVal) // Setting of the logic NullOffsets +{ + lAppNullOffset = lLogicNullOffset - lVal; + bAppSetNullOffset = true; + Ruler::SetNullOffset(ConvertSizePixel(lVal)); + Update(); +} + +void SvxRuler::Update() +{ + /* Perform update of view */ + if(IsDrag()) + return; + + UpdatePage(); + UpdateFrame(); + if(nFlags & SvxRulerSupportFlags::OBJECT) + UpdateObject(); + else + UpdateColumns(); + + if(nFlags & (SvxRulerSupportFlags::PARAGRAPH_MARGINS | SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL)) + UpdatePara(); + + if(nFlags & SvxRulerSupportFlags::TABS) + UpdateTabs(); +} + +long SvxRuler::GetPageWidth() const +{ + if (!mxPagePosItem) + return 0; + return bHorz ? mxPagePosItem->GetWidth() : mxPagePosItem->GetHeight(); +} + +inline long SvxRuler::GetFrameLeft() const +{ + /* Get Left margin in Pixels */ + return bAppSetNullOffset ? + GetMargin1() + ConvertSizePixel(lLogicNullOffset) : + Ruler::GetNullOffset(); +} + +long SvxRuler::GetFirstLineIndent() const +{ + /* Get First-line indent in pixels */ + return mxParaItem ? mpIndents[INDENT_FIRST_LINE].nPos : GetMargin1(); +} + +long SvxRuler::GetLeftIndent() const +{ + /* Get Left paragraph margin in Pixels */ + return mxParaItem ? mpIndents[INDENT_LEFT_MARGIN].nPos : GetMargin1(); +} + +long SvxRuler::GetRightIndent() const +{ + /* Get Right paragraph margin in Pixels */ + return mxParaItem ? mpIndents[INDENT_RIGHT_MARGIN].nPos : GetMargin2(); +} + +long SvxRuler::GetLogicRightIndent() const +{ + /* Get Right paragraph margin in Logic */ + return mxParaItem ? GetRightFrameMargin() - mxParaItem->GetRight() : GetRightFrameMargin(); +} + +// Left margin in App values, is either the margin (= 0) or the left edge of +// the column that is set in the column attribute as current column. +long SvxRuler::GetLeftFrameMargin() const +{ + // #126721# for some unknown reason the current column is set to 0xffff + DBG_ASSERT(!mxColumnItem || mxColumnItem->GetActColumn() < mxColumnItem->Count(), + "issue #126721# - invalid current column!"); + long nLeft = 0; + if (mxColumnItem && + mxColumnItem->Count() && + mxColumnItem->IsConsistent()) + { + nLeft = mxColumnItem->GetActiveColumnDescription().nStart; + } + + return nLeft; +} + +inline long SvxRuler::GetLeftMin() const +{ + DBG_ASSERT(mxMinMaxItem, "no MinMax value set"); + if (mxMinMaxItem) + { + if (bHorz) + return mxMinMaxItem->GetValue().Left(); + else + return mxMinMaxItem->GetValue().Top(); + } + return 0; +} + +inline long SvxRuler::GetRightMax() const +{ + DBG_ASSERT(mxMinMaxItem, "no MinMax value set"); + if (mxMinMaxItem) + { + if (bHorz) + return mxMinMaxItem->GetValue().Right(); + else + return mxMinMaxItem->GetValue().Bottom(); + } + return 0; +} + + +long SvxRuler::GetRightFrameMargin() const +{ + /* Get right frame margin (in logical units) */ + if (mxColumnItem) + { + if (!IsActLastColumn(true)) + { + return mxColumnItem->At(GetActRightColumn(true)).nEnd; + } + } + + long lResult = lLogicNullOffset; + + // If possible deduct right table entry + if(mxColumnItem && mxColumnItem->IsTable()) + lResult += mxColumnItem->GetRight(); + else if(bHorz && mxLRSpaceItem) + lResult += mxLRSpaceItem->GetRight(); + else if(!bHorz && mxULSpaceItem) + lResult += mxULSpaceItem->GetLower(); + + if(bHorz) + lResult = mxPagePosItem->GetWidth() - lResult; + else + lResult = mxPagePosItem->GetHeight() - lResult; + + return lResult; +} + +#define NEG_FLAG ( (nFlags & SvxRulerSupportFlags::NEGATIVE_MARGINS) == \ + SvxRulerSupportFlags::NEGATIVE_MARGINS ) +#define TAB_FLAG ( mxColumnItem && mxColumnItem->IsTable() ) + +long SvxRuler::GetCorrectedDragPos( bool bLeft, bool bRight ) +{ + /* + Corrects the position within the calculated limits. The limit values are in + pixels relative to the page edge. + */ + + const long lNullPix = Ruler::GetNullOffset(); + long lDragPos = GetDragPos() + lNullPix; + bool bHoriRows = bHorz && mxRulerImpl->bIsTableRows; + if((bLeft || bHoriRows) && lDragPos < nMaxLeft) + lDragPos = nMaxLeft; + else if((bRight||bHoriRows) && lDragPos > nMaxRight) + lDragPos = nMaxRight; + return lDragPos - lNullPix; +} + +static void ModifyTabs_Impl( sal_uInt16 nCount, // Number of Tabs + RulerTab* pTabs, // Tab buffer + long lDiff) // difference to be added +{ + /* Helper function, move all the tabs by a fixed value */ + if( pTabs ) + { + for(sal_uInt16 i = 0; i < nCount; ++i) + { + pTabs[i].nPos += lDiff; + } + } +} + +void SvxRuler::DragMargin1() +{ + /* Dragging the left edge of frame */ + long aDragPosition = GetCorrectedDragPos( !TAB_FLAG || !NEG_FLAG ); + + aDragPosition = MakePositionSticky(aDragPosition, GetRightFrameMargin(), false); + + // Check if position changed + if (aDragPosition == 0) + return; + + DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 3 : 7, bHorz); + if (mxColumnItem && (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)) + DragBorders(); + AdjustMargin1(aDragPosition); +} + +void SvxRuler::AdjustMargin1(long lInputDiff) +{ + const long nOld = bAppSetNullOffset? GetMargin1(): GetNullOffset(); + const long lDragPos = lInputDiff; + + bool bProtectColumns = + mxRulerImpl->aProtectItem->IsSizeProtected() || + mxRulerImpl->aProtectItem->IsPosProtected(); + + const RulerMarginStyle nMarginStyle = + bProtectColumns ? RulerMarginStyle::NONE : RulerMarginStyle::Sizeable; + + if(!bAppSetNullOffset) + { + long lDiff = lDragPos; + SetNullOffset(nOld + lDiff); + if (!mxColumnItem || !(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)) + { + SetMargin2( GetMargin2() - lDiff, nMarginStyle ); + + if (!mxColumnItem && !mxObjectItem && mxParaItem) + { + // Right indent of the old position + mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + if (mxObjectItem) + { + mpObjectBorders[GetObjectBordersOff(0)].nPos -= lDiff; + mpObjectBorders[GetObjectBordersOff(1)].nPos -= lDiff; + SetBorders(2, mpObjectBorders.data() + GetObjectBordersOff(0)); + } + if (mxColumnItem) + { + for(sal_uInt16 i = 0; i < mxColumnItem->Count()-1; ++i) + mpBorders[i].nPos -= lDiff; + SetBorders(mxColumnItem->Count()-1, mpBorders.data()); + if(mxColumnItem->IsFirstAct()) + { + // Right indent of the old position + if (mxParaItem) + { + mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + } + else + { + if (mxParaItem) + { + mpIndents[INDENT_FIRST_LINE].nPos -= lDiff; + mpIndents[INDENT_LEFT_MARGIN].nPos -= lDiff; + mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + } + if(mxTabStopItem && (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL) + &&!IsActFirstColumn()) + { + ModifyTabs_Impl(nTabCount + TAB_GAP, mpTabs.data(), -lDiff); + SetTabs(nTabCount, mpTabs.data() + TAB_GAP); + } + } + } + } + else + { + long lDiff = lDragPos - nOld; + SetMargin1(nOld + lDiff, nMarginStyle); + + if (!mxColumnItem + || !(nDragType + & (SvxRulerDragFlags::OBJECT_SIZE_LINEAR + | SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL))) + { + if (!mxColumnItem && !mxObjectItem && mxParaItem) + { + // Left indent of the old position + mpIndents[INDENT_FIRST_LINE].nPos += lDiff; + mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + + if (mxColumnItem) + { + for(sal_uInt16 i = 0; i < mxColumnItem->Count() - 1; ++i) + mpBorders[i].nPos += lDiff; + SetBorders(mxColumnItem->Count() - 1, mpBorders.data()); + if (mxColumnItem->IsFirstAct()) + { + // Left indent of the old position + if (mxParaItem) + { + mpIndents[INDENT_FIRST_LINE].nPos += lDiff; + mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + } + else + { + if (mxParaItem) + { + mpIndents[INDENT_FIRST_LINE].nPos += lDiff; + mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff; + mpIndents[INDENT_RIGHT_MARGIN].nPos += lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + } + } + if (mxTabStopItem) + { + ModifyTabs_Impl(nTabCount + TAB_GAP, mpTabs.data(), lDiff); + SetTabs(nTabCount, mpTabs.data() + TAB_GAP); + } + } + } +} + +void SvxRuler::DragMargin2() +{ + /* Dragging the right edge of frame */ + long aDragPosition = GetCorrectedDragPos( true, !TAB_FLAG || !NEG_FLAG); + aDragPosition = MakePositionSticky(aDragPosition, GetLeftFrameMargin(), false); + long lDiff = aDragPosition - GetMargin2(); + + // Check if position changed + if (lDiff == 0) + return; + + if( mxRulerImpl->bIsTableRows && + !bHorz && + mxColumnItem && + (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)) + { + DragBorders(); + } + + bool bProtectColumns = + mxRulerImpl->aProtectItem->IsSizeProtected() || + mxRulerImpl->aProtectItem->IsPosProtected(); + + const RulerMarginStyle nMarginStyle = bProtectColumns ? RulerMarginStyle::NONE : RulerMarginStyle::Sizeable; + + SetMargin2( aDragPosition, nMarginStyle ); + + // Right indent of the old position + if ((!mxColumnItem || IsActLastColumn()) && mxParaItem) + { + mpIndents[INDENT_FIRST_LINE].nPos += lDiff; + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + } + + DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 5 : 7, bHorz); +} + +void SvxRuler::DragIndents() +{ + /* Dragging the paragraph indents */ + long aDragPosition = NEG_FLAG ? GetDragPos() : GetCorrectedDragPos(); + const sal_uInt16 nIndex = GetDragAryPos() + INDENT_GAP; + + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + + if(nIndex == INDENT_RIGHT_MARGIN) + aDragPosition = MakePositionSticky(aDragPosition, bRTL ? GetLeftFrameMargin() : GetRightFrameMargin()); + else + aDragPosition = MakePositionSticky(aDragPosition, bRTL ? GetRightFrameMargin() : GetLeftFrameMargin()); + + const long lDiff = mpIndents[nIndex].nPos - aDragPosition; + + // Check if position changed + if (lDiff == 0) + return; + + if((nIndex == INDENT_FIRST_LINE || nIndex == INDENT_LEFT_MARGIN ) && + !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY)) + { + mpIndents[INDENT_FIRST_LINE].nPos -= lDiff; + } + + mpIndents[nIndex].nPos = aDragPosition; + + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + DrawLine_Impl(lTabPos, 1, bHorz); +} + +void SvxRuler::DrawLine_Impl(long& lTabPosition, int nNew, bool bHorizontal) +{ + /* + Output routine for the ledger line when moving tabs, tables and other + columns + */ + if(bHorizontal) + { + const long nHeight = pEditWin->GetOutputSize().Height(); + Point aZero = pEditWin->GetMapMode().GetOrigin(); + if(lTabPosition != -1) + { + pEditWin->InvertTracking( + tools::Rectangle( Point(lTabPosition, -aZero.Y()), + Point(lTabPosition, -aZero.Y() + nHeight)), + ShowTrackFlags::Split | ShowTrackFlags::Clip ); + } + if( nNew & 1 ) + { + long nDrapPosition = GetCorrectedDragPos( ( nNew & 4 ) != 0, ( nNew & 2 ) != 0 ); + nDrapPosition = MakePositionSticky(nDrapPosition, GetLeftFrameMargin()); + lTabPosition = ConvertHSizeLogic( nDrapPosition + GetNullOffset() ); + if (mxPagePosItem) + lTabPosition += mxPagePosItem->GetPos().X(); + pEditWin->InvertTracking( + tools::Rectangle( Point(lTabPosition, -aZero.Y()), + Point(lTabPosition, -aZero.Y() + nHeight) ), + ShowTrackFlags::Clip | ShowTrackFlags::Split ); + } + } + else + { + const long nWidth = pEditWin->GetOutputSize().Width(); + Point aZero = pEditWin->GetMapMode().GetOrigin(); + if(lTabPosition != -1) + { + pEditWin->InvertTracking( + tools::Rectangle( Point(-aZero.X(), lTabPosition), + Point(-aZero.X() + nWidth, lTabPosition)), + ShowTrackFlags::Split | ShowTrackFlags::Clip ); + } + + if(nNew & 1) + { + long nDrapPosition = GetCorrectedDragPos(); + nDrapPosition = MakePositionSticky(nDrapPosition, GetLeftFrameMargin()); + lTabPosition = ConvertVSizeLogic(nDrapPosition + GetNullOffset()); + if (mxPagePosItem) + lTabPosition += mxPagePosItem->GetPos().Y(); + pEditWin->InvertTracking( + tools::Rectangle( Point(-aZero.X(), lTabPosition), + Point(-aZero.X()+nWidth, lTabPosition)), + ShowTrackFlags::Clip | ShowTrackFlags::Split ); + } + } +} + +void SvxRuler::DragTabs() +{ + /* Dragging of Tabs */ + long aDragPosition = GetCorrectedDragPos(true, false); + aDragPosition = MakePositionSticky(aDragPosition, GetLeftFrameMargin()); + + sal_uInt16 nIdx = GetDragAryPos() + TAB_GAP; + long nDiff = aDragPosition - mpTabs[nIdx].nPos; + if (nDiff == 0) + return; + + DrawLine_Impl(lTabPos, 7, bHorz); + + if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR) + { + + for(sal_uInt16 i = nIdx; i < nTabCount; ++i) + { + mpTabs[i].nPos += nDiff; + // limit on maximum + if(mpTabs[i].nPos > GetMargin2()) + mpTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE; + else + mpTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE; + } + } + else if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL) + { + mxRulerImpl->nTotalDist -= nDiff; + mpTabs[nIdx].nPos = aDragPosition; + for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i) + { + if(mpTabs[i].nStyle & RULER_TAB_DEFAULT) + // can be canceled at the DefaultTabs + break; + long nDelta = mxRulerImpl->nTotalDist * mxRulerImpl->pPercBuf[i]; + nDelta /= 1000; + mpTabs[i].nPos = mpTabs[nIdx].nPos + nDelta; + if(mpTabs[i].nPos + GetNullOffset() > nMaxRight) + mpTabs[i].nStyle |= RULER_STYLE_INVISIBLE; + else + mpTabs[i].nStyle &= ~RULER_STYLE_INVISIBLE; + } + } + else + { + mpTabs[nIdx].nPos = aDragPosition; + } + + if(IsDragDelete()) + mpTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE; + else + mpTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE; + SetTabs(nTabCount, mpTabs.data() + TAB_GAP); +} + +void SvxRuler::SetActive(bool bOn) +{ + if(bOn) + { + Activate(); + } + else + Deactivate(); + if(bActive!=bOn) + { + pBindings->EnterRegistrations(); + if(bOn) + for(sal_uInt16 i=0;i<mxRulerImpl->nControlerItems;i++) + pCtrlItems[i]->ReBind(); + else + for(sal_uInt16 j=0;j<mxRulerImpl->nControlerItems;j++) + pCtrlItems[j]->UnBind(); + pBindings->LeaveRegistrations(); + } + bActive = bOn; +} + +void SvxRuler::UpdateParaContents_Impl( + long lDifference, + UpdateType eType) // Art (all, left or right) +{ + /* Helper function; carry Tabs and Paragraph Margins */ + switch(eType) + { + case UpdateType::MoveRight: + mpIndents[INDENT_RIGHT_MARGIN].nPos += lDifference; + break; + case UpdateType::MoveLeft: + { + mpIndents[INDENT_FIRST_LINE].nPos += lDifference; + mpIndents[INDENT_LEFT_MARGIN].nPos += lDifference; + if (!mpTabs.empty()) + { + for(sal_uInt16 i = 0; i < nTabCount+TAB_GAP; ++i) + { + mpTabs[i].nPos += lDifference; + } + SetTabs(nTabCount, mpTabs.data() + TAB_GAP); + } + break; + } + } + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); +} + +void SvxRuler::DragBorders() +{ + /* Dragging of Borders (Tables and other columns) */ + bool bLeftIndentsCorrected = false; + bool bRightIndentsCorrected = false; + int nIndex; + + if(GetDragType() == RulerType::Border) + { + DrawLine_Impl(lTabPos, 7, bHorz); + nIndex = GetDragAryPos(); + } + else + { + nIndex = 0; + } + + RulerDragSize nDragSize = GetDragSize(); + long lDiff = 0; + + // the drag position has to be corrected to be able to prevent borders from passing each other + long lPos = MakePositionSticky(GetCorrectedDragPos(), GetLeftFrameMargin()); + + switch(nDragSize) + { + case RulerDragSize::Move: + { + if(GetDragType() == RulerType::Border) + lDiff = lPos - nDragOffset - mpBorders[nIndex].nPos; + else + lDiff = GetDragType() == RulerType::Margin1 ? lPos - mxRulerImpl->lLastLMargin : lPos - mxRulerImpl->lLastRMargin; + + if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR) + { + long nRight = GetMargin2() - glMinFrame; // Right limiters + for(int i = mpBorders.size() - 2; i >= nIndex; --i) + { + long l = mpBorders[i].nPos; + mpBorders[i].nPos += lDiff; + mpBorders[i].nPos = std::min(mpBorders[i].nPos, nRight - mpBorders[i].nWidth); + nRight = mpBorders[i].nPos - glMinFrame; + // RR update the column + if(i == GetActRightColumn()) + { + UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveRight); + bRightIndentsCorrected = true; + } + // LAR, EZE update the column + else if(i == GetActLeftColumn()) + { + UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveLeft); + bLeftIndentsCorrected = true; + } + } + } + else if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL) + { + int nLimit; + long lLeft; + int nStartLimit = mpBorders.size() - 2; + switch(GetDragType()) + { + default: ;//prevent warning + OSL_FAIL("svx::SvxRuler::DragBorders(), unknown drag type!" ); + [[fallthrough]]; + case RulerType::Border: + if(mxRulerImpl->bIsTableRows) + { + mpBorders[nIndex].nPos += lDiff; + if(bHorz) + { + lLeft = mpBorders[nIndex].nPos; + mxRulerImpl->nTotalDist -= lDiff; + nLimit = nIndex + 1; + } + else + { + lLeft = 0; + nStartLimit = nIndex - 1; + mxRulerImpl->nTotalDist += lDiff; + nLimit = 0; + } + } + else + { + nLimit = nIndex + 1; + mpBorders[nIndex].nPos += lDiff; + lLeft = mpBorders[nIndex].nPos; + mxRulerImpl->nTotalDist -= lDiff; + } + break; + case RulerType::Margin1: + nLimit = 0; + lLeft = mxRulerImpl->lLastLMargin + lDiff; + mxRulerImpl->nTotalDist -= lDiff; + break; + case RulerType::Margin2: + nLimit = 0; + lLeft= 0; + nStartLimit = mpBorders.size() - 2; + mxRulerImpl->nTotalDist += lDiff; + break; + } + + for(int i = nStartLimit; i >= nLimit; --i) + { + + long l = mpBorders[i].nPos; + mpBorders[i].nPos = + lLeft + + (mxRulerImpl->nTotalDist * mxRulerImpl->pPercBuf[i]) / 1000 + + mxRulerImpl->pBlockBuf[i]; + + // RR update the column + if(!mxRulerImpl->bIsTableRows) + { + if(i == GetActRightColumn()) + { + UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveRight); + bRightIndentsCorrected = true; + } + // LAR, EZE update the column + else if(i == GetActLeftColumn()) + { + UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveLeft); + bLeftIndentsCorrected = true; + } + } + } + if(mxRulerImpl->bIsTableRows) + { + //in vertical tables the left borders have to be moved + if(bHorz) + { + for(int i = 0; i < nIndex; ++i) + mpBorders[i].nPos += lDiff; + AdjustMargin1(lDiff); + } + else + { + //otherwise the right borders are moved + for(int i = mxColumnItem->Count() - 1; i > nIndex; --i) + mpBorders[i].nPos += lDiff; + SetMargin2( GetMargin2() + lDiff, RulerMarginStyle::NONE ); + } + } + } + else if(mxRulerImpl->bIsTableRows) + { + //moving rows: if a row is resized all following rows + //have to be moved by the same amount. + //This includes the left border when the table is not limited + //to a lower frame border. + int nLimit; + if(GetDragType()==RulerType::Border) + { + nLimit = nIndex + 1; + mpBorders[nIndex].nPos += lDiff; + } + else + { + nLimit=0; + } + //in vertical tables the left borders have to be moved + if(bHorz) + { + for(int i = 0; i < nIndex; ++i) + { + mpBorders[i].nPos += lDiff; + } + AdjustMargin1(lDiff); + } + else + { + //otherwise the right borders are moved + for(int i = mpBorders.size() - 2; i >= nLimit; --i) + { + mpBorders[i].nPos += lDiff; + } + SetMargin2( GetMargin2() + lDiff, RulerMarginStyle::NONE ); + } + } + else + mpBorders[nIndex].nPos += lDiff; + break; + } + case RulerDragSize::N1: + { + lDiff = lPos - mpBorders[nIndex].nPos; + mpBorders[nIndex].nWidth += mpBorders[nIndex].nPos - lPos; + mpBorders[nIndex].nPos = lPos; + break; + } + case RulerDragSize::N2: + { + const long nOld = mpBorders[nIndex].nWidth; + mpBorders[nIndex].nWidth = lPos - mpBorders[nIndex].nPos; + lDiff = mpBorders[nIndex].nWidth - nOld; + break; + } + } + if(!bRightIndentsCorrected && + GetActRightColumn() == nIndex && + nDragSize != RulerDragSize::N2 && + !mpIndents.empty() && + !mxRulerImpl->bIsTableRows) + { + UpdateParaContents_Impl(lDiff, UpdateType::MoveRight); + } + else if(!bLeftIndentsCorrected && + GetActLeftColumn() == nIndex && + nDragSize != RulerDragSize::N1 && + !mpIndents.empty()) + { + UpdateParaContents_Impl(lDiff, UpdateType::MoveLeft); + } + SetBorders(mxColumnItem->Count() - 1, mpBorders.data()); +} + +void SvxRuler::DragObjectBorder() +{ + /* Dragging of object edges */ + if(RulerDragSize::Move == GetDragSize()) + { + const long lPosition = MakePositionSticky(GetCorrectedDragPos(), GetLeftFrameMargin()); + + const sal_uInt16 nIdx = GetDragAryPos(); + mpObjectBorders[GetObjectBordersOff(nIdx)].nPos = lPosition; + SetBorders(2, mpObjectBorders.data() + GetObjectBordersOff(0)); + DrawLine_Impl(lTabPos, 7, bHorz); + + } +} + +void SvxRuler::ApplyMargins() +{ + /* Applying margins; changed by dragging. */ + const SfxPoolItem* pItem = nullptr; + sal_uInt16 nId = SID_ATTR_LONG_LRSPACE; + + if(bHorz) + { + const long lOldNull = lLogicNullOffset; + if(mxRulerImpl->lMaxLeftLogic != -1 && nMaxLeft == GetMargin1() + Ruler::GetNullOffset()) + { + lLogicNullOffset = mxRulerImpl->lMaxLeftLogic; + mxLRSpaceItem->SetLeft(lLogicNullOffset); + } + else + { + lLogicNullOffset = ConvertHPosLogic(GetFrameLeft()) - lAppNullOffset; + mxLRSpaceItem->SetLeft(PixelHAdjust(lLogicNullOffset, mxLRSpaceItem->GetLeft())); + } + + if(bAppSetNullOffset) + { + lAppNullOffset += lLogicNullOffset - lOldNull; + } + + long nRight; + if(mxRulerImpl->lMaxRightLogic != -1 + && nMaxRight == GetMargin2() + Ruler::GetNullOffset()) + { + nRight = GetPageWidth() - mxRulerImpl->lMaxRightLogic; + } + else + { + nRight = std::max(long(0), + mxPagePosItem->GetWidth() - mxLRSpaceItem->GetLeft() - + (ConvertHPosLogic(GetMargin2()) - lAppNullOffset)); + + nRight = PixelHAdjust( nRight, mxLRSpaceItem->GetRight()); + } + mxLRSpaceItem->SetRight(nRight); + + pItem = mxLRSpaceItem.get(); + +#ifdef DEBUGLIN + Debug_Impl(pEditWin, *mxLRSpaceItem); +#endif // DEBUGLIN + + } + else + { + const long lOldNull = lLogicNullOffset; + lLogicNullOffset = + ConvertVPosLogic(GetFrameLeft()) - + lAppNullOffset; + mxULSpaceItem->SetUpper( + PixelVAdjust(lLogicNullOffset, mxULSpaceItem->GetUpper())); + if(bAppSetNullOffset) + { + lAppNullOffset += lLogicNullOffset - lOldNull; + } + mxULSpaceItem->SetLower( + PixelVAdjust( + std::max(long(0), mxPagePosItem->GetHeight() - + mxULSpaceItem->GetUpper() - + (ConvertVPosLogic(GetMargin2()) - + lAppNullOffset)), mxULSpaceItem->GetLower())); + pItem = mxULSpaceItem.get(); + nId = SID_ATTR_LONG_ULSPACE; + +#ifdef DEBUGLIN + Debug_Impl(pEditWin,*mxULSpaceItem); +#endif // DEBUGLIN + + } + pBindings->GetDispatcher()->ExecuteList(nId, SfxCallMode::RECORD, { pItem }); + if (mxTabStopItem) + UpdateTabs(); +} + +long SvxRuler::RoundToCurrentMapMode(long lValue) const +{ + RulerUnitData aUnitData = GetCurrentRulerUnit(); + double aRoundingFactor = aUnitData.nTickUnit / aUnitData.nTick1; + + long lNewValue = OutputDevice::LogicToLogic(Size(lValue, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width(); + lNewValue = (rtl::math::round(lNewValue / static_cast<double>(aUnitData.nTickUnit) * aRoundingFactor) / aRoundingFactor) * aUnitData.nTickUnit; + return OutputDevice::LogicToLogic(Size(lNewValue, 0), GetCurrentMapMode(), pEditWin->GetMapMode()).Width(); +} + +void SvxRuler::ApplyIndents() +{ + /* Applying paragraph settings; changed by dragging. */ + + long nLeftFrameMargin = GetLeftFrameMargin(); + + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + + long nNewTxtLeft; + long nNewFirstLineOffset; + long nNewRight; + + long nFirstLine = ConvertPosLogic(mpIndents[INDENT_FIRST_LINE].nPos); + long nLeftMargin = ConvertPosLogic(mpIndents[INDENT_LEFT_MARGIN].nPos); + long nRightMargin = ConvertPosLogic(mpIndents[INDENT_RIGHT_MARGIN].nPos); + + if(mxColumnItem && ((bRTL && !IsActLastColumn(true)) || (!bRTL && !IsActFirstColumn(true)))) + { + if(bRTL) + { + long nRightColumn = GetActRightColumn(true); + long nRightBorder = ConvertPosLogic(mpBorders[nRightColumn].nPos); + nNewTxtLeft = nRightBorder - nLeftMargin - lAppNullOffset; + } + else + { + long nLeftColumn = GetActLeftColumn(true); + long nLeftBorder = ConvertPosLogic(mpBorders[nLeftColumn].nPos + mpBorders[nLeftColumn].nWidth); + nNewTxtLeft = nLeftMargin - nLeftBorder - lAppNullOffset; + } + } + else + { + if(bRTL) + { + long nRightBorder = ConvertPosLogic(GetMargin2()); + nNewTxtLeft = nRightBorder - nLeftMargin - lAppNullOffset; + } + else + { + long nLeftBorder = ConvertPosLogic(GetMargin1()); + nNewTxtLeft = nLeftBorder + nLeftMargin - nLeftFrameMargin - lAppNullOffset; + } + } + + if(bRTL) + nNewFirstLineOffset = nLeftMargin - nFirstLine - lAppNullOffset; + else + nNewFirstLineOffset = nFirstLine - nLeftMargin - lAppNullOffset; + + if(mxColumnItem && ((!bRTL && !IsActLastColumn(true)) || (bRTL && !IsActFirstColumn(true)))) + { + if(bRTL) + { + long nLeftColumn = GetActLeftColumn(true); + long nLeftBorder = ConvertPosLogic(mpBorders[nLeftColumn].nPos + mpBorders[nLeftColumn].nWidth); + nNewRight = nRightMargin - nLeftBorder - lAppNullOffset; + } + else + { + long nRightColumn = GetActRightColumn(true); + long nRightBorder = ConvertPosLogic(mpBorders[nRightColumn].nPos); + nNewRight = nRightBorder - nRightMargin - lAppNullOffset; + } + } + else + { + if(bRTL) + { + long nLeftBorder = ConvertPosLogic(GetMargin1()); + nNewRight = nLeftBorder + nRightMargin - nLeftFrameMargin - lAppNullOffset; + } + else + { + long nRightBorder = ConvertPosLogic(GetMargin2()); + nNewRight = nRightBorder - nRightMargin - lAppNullOffset; + } + } + + if (mbSnapping) + { + nNewTxtLeft = RoundToCurrentMapMode(nNewTxtLeft); + nNewFirstLineOffset = RoundToCurrentMapMode(nNewFirstLineOffset); + nNewRight = RoundToCurrentMapMode(nNewRight); + } + + mxParaItem->SetTextFirstLineOffset(sal::static_int_cast<short>(nNewFirstLineOffset)); + mxParaItem->SetTextLeft(nNewTxtLeft); + mxParaItem->SetRight(nNewRight); + + sal_uInt16 nParagraphId = bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL; + pBindings->GetDispatcher()->ExecuteList(nParagraphId, SfxCallMode::RECORD, + { mxParaItem.get() }); + UpdateTabs(); +} + +void SvxRuler::ApplyTabs() +{ + /* Apply tab settings, changed by dragging. */ + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + const sal_uInt16 nCoreIdx = GetDragAryPos(); + if(IsDragDelete()) + { + mxTabStopItem->Remove(nCoreIdx); + } + else if(SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType || + SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) + { + SvxTabStopItem *pItem = new SvxTabStopItem(mxTabStopItem->Which()); + //remove default tab stops + for ( sal_uInt16 i = 0; i < pItem->Count(); ) + { + if ( SvxTabAdjust::Default == (*pItem)[i].GetAdjustment() ) + { + pItem->Remove(i); + continue; + } + ++i; + } + + sal_uInt16 j; + for(j = 0; j < nCoreIdx; ++j) + { + pItem->Insert(mxTabStopItem->At(j)); + } + for(; j < mxTabStopItem->Count(); ++j) + { + SvxTabStop aTabStop = mxTabStopItem->At(j); + aTabStop.GetTabPos() = PixelHAdjust( + ConvertHPosLogic( + mpTabs[j + TAB_GAP].nPos - GetLeftIndent()) - lAppNullOffset, + aTabStop.GetTabPos()); + pItem->Insert(aTabStop); + } + mxTabStopItem.reset(pItem); + } + else if( mxTabStopItem->Count() == 0 ) + return; + else + { + SvxTabStop aTabStop = mxTabStopItem->At(nCoreIdx); + if( mxRulerImpl->lMaxRightLogic != -1 && + mpTabs[nCoreIdx + TAB_GAP].nPos + Ruler::GetNullOffset() == nMaxRight ) + { + // Set tab pos exactly at the right indent + long nTmpLeftIndentLogic + = lAppNullOffset + (bRTL ? GetRightFrameMargin() : GetLeftFrameMargin()); + if (mxRulerImpl->bIsTabsRelativeToIndent && mxParaItem) + { + nTmpLeftIndentLogic += bRTL ? mxParaItem->GetRight() : mxParaItem->GetLeft(); + } + aTabStop.GetTabPos() + = mxRulerImpl->lMaxRightLogic - lLogicNullOffset - nTmpLeftIndentLogic; + } + else + { + if(bRTL) + { + //#i24363# tab stops relative to indent + const long nTmpLeftIndent = mxRulerImpl->bIsTabsRelativeToIndent ? + GetLeftIndent() : + ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset ); + + long nNewPosition = ConvertHPosLogic(nTmpLeftIndent - mpTabs[nCoreIdx + TAB_GAP].nPos); + aTabStop.GetTabPos() = PixelHAdjust(nNewPosition - lAppNullOffset, aTabStop.GetTabPos()); + } + else + { + //#i24363# tab stops relative to indent + const long nTmpLeftIndent = mxRulerImpl->bIsTabsRelativeToIndent ? + GetLeftIndent() : + ConvertHPosPixel( GetLeftFrameMargin() + lAppNullOffset ); + + long nNewPosition = ConvertHPosLogic(mpTabs[nCoreIdx + TAB_GAP].nPos - nTmpLeftIndent); + aTabStop.GetTabPos() = PixelHAdjust(nNewPosition - lAppNullOffset, aTabStop.GetTabPos()); + } + } + mxTabStopItem->Remove(nCoreIdx); + mxTabStopItem->Insert(aTabStop); + } + sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL; + pBindings->GetDispatcher()->ExecuteList(nTabStopId, SfxCallMode::RECORD, + { mxTabStopItem.get() }); + UpdateTabs(); +} + +void SvxRuler::ApplyBorders() +{ + /* Applying (table) column settings; changed by dragging. */ + if(mxColumnItem->IsTable()) + { + long lValue = GetFrameLeft(); + if(lValue != mxRulerImpl->nColLeftPix) + { + long nLeft = PixelHAdjust( + ConvertHPosLogic(lValue) - + lAppNullOffset, + mxColumnItem->GetLeft()); + mxColumnItem->SetLeft(nLeft); + } + + lValue = GetMargin2(); + + if(lValue != mxRulerImpl->nColRightPix) + { + long nWidthOrHeight = bHorz ? mxPagePosItem->GetWidth() : mxPagePosItem->GetHeight(); + long nRight = PixelHAdjust( + nWidthOrHeight - + mxColumnItem->GetLeft() - + ConvertHPosLogic(lValue) - + lAppNullOffset, + mxColumnItem->GetRight() ); + mxColumnItem->SetRight(nRight); + } + } + + for(sal_uInt16 i = 0; i < mxColumnItem->Count() - 1; ++i) + { + long& nEnd = mxColumnItem->At(i).nEnd; + nEnd = PixelHAdjust( + ConvertPosLogic(mpBorders[i].nPos), + mxColumnItem->At(i).nEnd); + long& nStart = mxColumnItem->At(i + 1).nStart; + nStart = PixelHAdjust( + ConvertSizeLogic(mpBorders[i].nPos + + mpBorders[i].nWidth) - + lAppNullOffset, + mxColumnItem->At(i + 1).nStart); + // It may be that, due to the PixelHAdjust readjustment to old values, + // the width becomes < 0. This we readjust. + if( nEnd > nStart ) + nStart = nEnd; + } + +#ifdef DEBUGLIN + Debug_Impl(pEditWin,*mxColumnItem); +#endif // DEBUGLIN + + SfxBoolItem aFlag(SID_RULER_ACT_LINE_ONLY, + bool(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY)); + + sal_uInt16 nColId = mxRulerImpl->bIsTableRows ? (bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL) : + (bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL); + + pBindings->GetDispatcher()->ExecuteList(nColId, SfxCallMode::RECORD, + { mxColumnItem.get(), &aFlag }); +} + +void SvxRuler::ApplyObject() +{ + /* Applying object settings, changed by dragging. */ + + // to the page margin + long nMargin = mxLRSpaceItem ? mxLRSpaceItem->GetLeft() : 0; + long nStartX = PixelAdjust( + ConvertPosLogic(mpObjectBorders[0].nPos) + + nMargin - + lAppNullOffset, + mxObjectItem->GetStartX()); + mxObjectItem->SetStartX(nStartX); + + long nEndX = PixelAdjust( + ConvertPosLogic(mpObjectBorders[1].nPos) + + nMargin - + lAppNullOffset, + mxObjectItem->GetEndX()); + mxObjectItem->SetEndX(nEndX); + + nMargin = mxULSpaceItem ? mxULSpaceItem->GetUpper() : 0; + long nStartY = PixelAdjust( + ConvertPosLogic(mpObjectBorders[2].nPos) + + nMargin - + lAppNullOffset, + mxObjectItem->GetStartY()); + mxObjectItem->SetStartY(nStartY); + + long nEndY = PixelAdjust( + ConvertPosLogic(mpObjectBorders[3].nPos) + + nMargin - + lAppNullOffset, + mxObjectItem->GetEndY()); + mxObjectItem->SetEndY(nEndY); + + pBindings->GetDispatcher()->ExecuteList(SID_RULER_OBJECT, + SfxCallMode::RECORD, { mxObjectItem.get() }); +} + +void SvxRuler::PrepareProportional_Impl(RulerType eType) +{ + /* + Preparation proportional dragging, and it is calculated based on the + proportional share of the total width in parts per thousand. + */ + mxRulerImpl->nTotalDist = GetMargin2(); + switch(eType) + { + case RulerType::Margin2: + case RulerType::Margin1: + case RulerType::Border: + { + DBG_ASSERT(mxColumnItem, "no ColumnItem"); + + mxRulerImpl->SetPercSize(mxColumnItem->Count()); + + long lPos; + long lWidth=0; + sal_uInt16 nStart; + sal_uInt16 nIdx=GetDragAryPos(); + long lActWidth=0; + long lActBorderSum; + long lOrigLPos; + + if(eType != RulerType::Border) + { + lOrigLPos = GetMargin1(); + nStart = 0; + lActBorderSum = 0; + } + else + { + if(mxRulerImpl->bIsTableRows &&!bHorz) + { + lOrigLPos = GetMargin1(); + nStart = 0; + } + else + { + lOrigLPos = mpBorders[nIdx].nPos + mpBorders[nIdx].nWidth; + nStart = 1; + } + lActBorderSum = mpBorders[nIdx].nWidth; + } + + //in horizontal mode the percentage value has to be + //calculated on a "current change" position base + //because the height of the table changes while dragging + if(mxRulerImpl->bIsTableRows && RulerType::Border == eType) + { + sal_uInt16 nStartBorder; + sal_uInt16 nEndBorder; + if(bHorz) + { + nStartBorder = nIdx + 1; + nEndBorder = mxColumnItem->Count() - 1; + } + else + { + nStartBorder = 0; + nEndBorder = nIdx; + } + + lWidth = mpBorders[nIdx].nPos; + if(bHorz) + lWidth = GetMargin2() - lWidth; + mxRulerImpl->nTotalDist = lWidth; + lPos = mpBorders[nIdx].nPos; + + for(sal_uInt16 i = nStartBorder; i < nEndBorder; ++i) + { + if(bHorz) + { + lActWidth += mpBorders[i].nPos - lPos; + lPos = mpBorders[i].nPos + mpBorders[i].nWidth; + } + else + lActWidth = mpBorders[i].nPos; + mxRulerImpl->pPercBuf[i] = static_cast<sal_uInt16>((lActWidth * 1000) + / mxRulerImpl->nTotalDist); + mxRulerImpl->pBlockBuf[i] = static_cast<sal_uInt16>(lActBorderSum); + lActBorderSum += mpBorders[i].nWidth; + } + } + else + { + lPos = lOrigLPos; + for(sal_uInt16 ii = nStart; ii < mxColumnItem->Count() - 1; ++ii) + { + lWidth += mpBorders[ii].nPos - lPos; + lPos = mpBorders[ii].nPos + mpBorders[ii].nWidth; + } + + lWidth += GetMargin2() - lPos; + mxRulerImpl->nTotalDist = lWidth; + lPos = lOrigLPos; + + for(sal_uInt16 i = nStart; i < mxColumnItem->Count() - 1; ++i) + { + lActWidth += mpBorders[i].nPos - lPos; + lPos = mpBorders[i].nPos + mpBorders[i].nWidth; + mxRulerImpl->pPercBuf[i] = static_cast<sal_uInt16>((lActWidth * 1000) + / mxRulerImpl->nTotalDist); + mxRulerImpl->pBlockBuf[i] = static_cast<sal_uInt16>(lActBorderSum); + lActBorderSum += mpBorders[i].nWidth; + } + } + } + break; + case RulerType::Tab: + { + const sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP; + mxRulerImpl->nTotalDist -= mpTabs[nIdx].nPos; + mxRulerImpl->SetPercSize(nTabCount); + for(sal_uInt16 n=0;n<=nIdx;mxRulerImpl->pPercBuf[n++]=0) ; + for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i) + { + const long nDelta = mpTabs[i].nPos - mpTabs[nIdx].nPos; + mxRulerImpl->pPercBuf[i] = static_cast<sal_uInt16>((nDelta * 1000) / mxRulerImpl->nTotalDist); + } + break; + } + default: break; + } +} + +void SvxRuler::EvalModifier() +{ + /* + Eval Drag Modifier + Shift: move linear + Control: move proportional + Shift + Control: Table: only current line + Alt: disable snapping + Alt + Shift: coarse snapping + */ + + sal_uInt16 nModifier = GetDragModifier(); + if(mxRulerImpl->bIsTableRows) + { + //rows can only be moved in one way, additionally current column is possible + if(nModifier == KEY_SHIFT) + nModifier = 0; + } + + switch(nModifier) + { + case KEY_SHIFT: + nDragType = SvxRulerDragFlags::OBJECT_SIZE_LINEAR; + break; + case KEY_MOD2 | KEY_SHIFT: + mbCoarseSnapping = true; + break; + case KEY_MOD2: + mbSnapping = false; + break; + case KEY_MOD1: + { + const RulerType eType = GetDragType(); + nDragType = SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL; + if( RulerType::Tab == eType || + ( ( RulerType::Border == eType || + RulerType::Margin1 == eType || + RulerType::Margin2 == eType ) && + mxColumnItem ) ) + { + PrepareProportional_Impl(eType); + } + } + break; + case KEY_MOD1 | KEY_SHIFT: + if( GetDragType() != RulerType::Margin1 && + GetDragType() != RulerType::Margin2 ) + { + nDragType = SvxRulerDragFlags::OBJECT_ACTLINE_ONLY; + } + break; + } +} + +void SvxRuler::Click() +{ + /* Override handler SV; sets Tab per dispatcher call */ + Ruler::Click(); + if( bActive ) + { + pBindings->Update( SID_RULER_LR_MIN_MAX ); + pBindings->Update( SID_ATTR_LONG_ULSPACE ); + pBindings->Update( SID_ATTR_LONG_LRSPACE ); + pBindings->Update( SID_RULER_PAGE_POS ); + pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL); + pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL); + pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL); + pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL); + pBindings->Update( SID_RULER_OBJECT ); + pBindings->Update( SID_RULER_PROTECT ); + pBindings->Update( SID_ATTR_PARA_LRSPACE_VERTICAL ); + } + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + if(mxTabStopItem && + (nFlags & SvxRulerSupportFlags::TABS) == SvxRulerSupportFlags::TABS) + { + bool bContentProtected = mxRulerImpl->aProtectItem->IsContentProtected(); + if( bContentProtected ) return; + const long lPos = GetClickPos(); + if((bRTL && lPos < std::min(GetFirstLineIndent(), GetLeftIndent()) && lPos > GetRightIndent()) || + (!bRTL && lPos > std::min(GetFirstLineIndent(), GetLeftIndent()) && lPos < GetRightIndent())) + { + //convert position in left-to-right text + long nTabPos; + //#i24363# tab stops relative to indent + if(bRTL) + nTabPos = ( mxRulerImpl->bIsTabsRelativeToIndent ? + GetLeftIndent() : + ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset ) ) - + lPos; + else + nTabPos = lPos - + ( mxRulerImpl->bIsTabsRelativeToIndent ? + GetLeftIndent() : + ConvertHPosPixel( GetLeftFrameMargin() + lAppNullOffset )); + + SvxTabStop aTabStop(ConvertHPosLogic(nTabPos), + ToAttrTab_Impl(nDefTabType)); + mxTabStopItem->Insert(aTabStop); + UpdateTabs(); + } + } +} + +void SvxRuler::CalcMinMax() +{ + /* + Calculates the limits for dragging; which are in pixels relative to the + page edge + */ + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + const long lNullPix = ConvertPosPixel(lLogicNullOffset); + mxRulerImpl->lMaxLeftLogic=mxRulerImpl->lMaxRightLogic=-1; + switch(GetDragType()) + { + case RulerType::Margin1: + { // left edge of the surrounding Frame + // DragPos - NOf between left - right + mxRulerImpl->lMaxLeftLogic = GetLeftMin(); + nMaxLeft=ConvertSizePixel(mxRulerImpl->lMaxLeftLogic); + + if (!mxColumnItem || mxColumnItem->Count() == 1) + { + if(bRTL) + { + nMaxRight = lNullPix - GetRightIndent() + + std::max(GetFirstLineIndent(), GetLeftIndent()) - + glMinFrame; + } + else + { + nMaxRight = lNullPix + GetRightIndent() - + std::max(GetFirstLineIndent(), GetLeftIndent()) - + glMinFrame; + } + } + else if(mxRulerImpl->bIsTableRows) + { + //top border is not moveable when table rows are displayed + // protection of content means the margin is not moveable + if(bHorz && !mxRulerImpl->aProtectItem->IsContentProtected()) + { + nMaxLeft = mpBorders[0].nMinPos + lNullPix; + if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL) + nMaxRight = GetRightIndent() + lNullPix - + (mxColumnItem->Count() - 1 ) * glMinFrame; + else + nMaxRight = mpBorders[0].nPos - glMinFrame + lNullPix; + } + else + nMaxLeft = nMaxRight = lNullPix; + } + else + { + if (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL) + { + nMaxRight=lNullPix+CalcPropMaxRight(); + } + else if (nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR) + { + nMaxRight = ConvertPosPixel( + GetPageWidth() - ( + (mxColumnItem->IsTable() && mxLRSpaceItem) + ? mxLRSpaceItem->GetRight() : 0)) + - GetMargin2() + GetMargin1(); + } + else + { + nMaxRight = lNullPix - glMinFrame; + if (mxColumnItem->IsFirstAct()) + { + if(bRTL) + { + nMaxRight += std::min( + mpBorders[0].nPos, + std::max(GetFirstLineIndent(), GetLeftIndent()) - GetRightIndent()); + } + else + { + nMaxRight += std::min( + mpBorders[0].nPos, GetRightIndent() - + std::max(GetFirstLineIndent(), GetLeftIndent())); + } + } + else if ( mxColumnItem->Count() > 1 ) + { + nMaxRight += mpBorders[0].nPos; + } + else + { + nMaxRight += GetRightIndent() - std::max(GetFirstLineIndent(), GetLeftIndent()); + } + // Do not drag the left table edge over the edge of the page + if(mxLRSpaceItem && mxColumnItem->IsTable()) + { + long nTmp=ConvertSizePixel(mxLRSpaceItem->GetLeft()); + if(nTmp>nMaxLeft) + nMaxLeft=nTmp; + } + } + } + break; + } + case RulerType::Margin2: + { // right edge of the surrounding Frame + mxRulerImpl->lMaxRightLogic + = mxMinMaxItem ? GetPageWidth() - GetRightMax() : GetPageWidth(); + nMaxRight = ConvertSizePixel(mxRulerImpl->lMaxRightLogic); + + if (!mxColumnItem) + { + if(bRTL) + { + nMaxLeft = GetMargin2() + GetRightIndent() - + std::max(GetFirstLineIndent(),GetLeftIndent()) - GetMargin1()+ + glMinFrame + lNullPix; + } + else + { + nMaxLeft = GetMargin2() - GetRightIndent() + + std::max(GetFirstLineIndent(),GetLeftIndent()) - GetMargin1()+ + glMinFrame + lNullPix; + } + } + else if(mxRulerImpl->bIsTableRows) + { + // get the bottom move range from the last border position - only available for rows! + // protection of content means the margin is not moveable + if(bHorz || mxRulerImpl->aProtectItem->IsContentProtected()) + { + nMaxLeft = nMaxRight = mpBorders[mxColumnItem->Count() - 1].nMaxPos + lNullPix; + } + else + { + if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL) + { + nMaxLeft = (mxColumnItem->Count()) * glMinFrame + lNullPix; + } + else + { + if(mxColumnItem->Count() > 1) + nMaxLeft = mpBorders[mxColumnItem->Count() - 2].nPos + glMinFrame + lNullPix; + else + nMaxLeft = glMinFrame + lNullPix; + } + if(mxColumnItem->Count() > 1) + nMaxRight = mpBorders[mxColumnItem->Count() - 2].nMaxPos + lNullPix; + else + nMaxRight -= GetRightIndent() - lNullPix; + } + } + else + { + nMaxLeft = glMinFrame + lNullPix; + if(IsActLastColumn() || mxColumnItem->Count() < 2 ) //If last active column + { + if(bRTL) + { + nMaxLeft = glMinFrame + lNullPix + GetMargin2() + + GetRightIndent() - std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + else + { + nMaxLeft = glMinFrame + lNullPix + GetMargin2() - + GetRightIndent() + std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + } + if( mxColumnItem->Count() >= 2 ) + { + long nNewMaxLeft = + glMinFrame + lNullPix + + mpBorders[mxColumnItem->Count() - 2].nPos + + mpBorders[mxColumnItem->Count() - 2].nWidth; + nMaxLeft = std::max(nMaxLeft, nNewMaxLeft); + } + + } + break; + } + case RulerType::Border: + { // Table, column (Modifier) + const sal_uInt16 nIdx = GetDragAryPos(); + switch(GetDragSize()) + { + case RulerDragSize::N1 : + { + nMaxRight = mpBorders[nIdx].nPos + + mpBorders[nIdx].nWidth + lNullPix; + + if(0 == nIdx) + nMaxLeft = lNullPix; + else + nMaxLeft = mpBorders[nIdx - 1].nPos + mpBorders[nIdx - 1].nWidth + lNullPix; + if(nIdx == mxColumnItem->GetActColumn()) + { + if(bRTL) + { + nMaxLeft += mpBorders[nIdx].nPos + + GetRightIndent() - std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + else + { + nMaxLeft += mpBorders[nIdx].nPos - + GetRightIndent() + std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + if(0 != nIdx) + nMaxLeft -= mpBorders[nIdx-1].nPos + + mpBorders[nIdx-1].nWidth; + } + nMaxLeft += glMinFrame; + nMaxLeft += nDragOffset; + break; + } + case RulerDragSize::Move: + { + if (mxColumnItem) + { + //nIdx contains the position of the currently moved item + //next visible separator on the left + sal_uInt16 nLeftCol=GetActLeftColumn(false, nIdx); + //next visible separator on the right + sal_uInt16 nRightCol=GetActRightColumn(false, nIdx); + //next separator on the left - regardless if visible or not + sal_uInt16 nActLeftCol=GetActLeftColumn(); + //next separator on the right - regardless if visible or not + sal_uInt16 nActRightCol=GetActRightColumn(); + if(mxColumnItem->IsTable()) + { + if(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY) + { + //the current row/column should be modified only + //then the next/previous visible border position + //marks the min/max positions + nMaxLeft = nLeftCol == USHRT_MAX ? + 0 : + mpBorders[nLeftCol].nPos; + //rows can always be increased without a limit + if(mxRulerImpl->bIsTableRows) + nMaxRight = mpBorders[nIdx].nMaxPos; + else + nMaxRight = nRightCol == USHRT_MAX ? + GetMargin2(): + mpBorders[nRightCol].nPos; + nMaxLeft += lNullPix; + nMaxRight += lNullPix; + } + else + { + if(SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType && !bHorz && mxRulerImpl->bIsTableRows) + nMaxLeft = (nIdx + 1) * glMinFrame + lNullPix; + else + nMaxLeft = mpBorders[nIdx].nMinPos + lNullPix; + if((SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) || + (SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) ) + { + if(mxRulerImpl->bIsTableRows) + { + if(bHorz) + nMaxRight = GetRightIndent() + lNullPix - + (mxColumnItem->Count() - nIdx - 1) * glMinFrame; + else + nMaxRight = mpBorders[nIdx].nMaxPos + lNullPix; + } + else + nMaxRight=lNullPix+CalcPropMaxRight(nIdx); + } + else + nMaxRight = mpBorders[nIdx].nMaxPos + lNullPix; + } + nMaxLeft += glMinFrame; + nMaxRight -= glMinFrame; + + } + else + { + if(nLeftCol==USHRT_MAX) + nMaxLeft=lNullPix; + else + nMaxLeft = mpBorders[nLeftCol].nPos + + mpBorders[nLeftCol].nWidth + lNullPix; + + if(nActRightCol == nIdx) + { + if(bRTL) + { + nMaxLeft += mpBorders[nIdx].nPos + + GetRightIndent() - std::max(GetFirstLineIndent(), + GetLeftIndent()); + if(nActLeftCol!=USHRT_MAX) + nMaxLeft -= mpBorders[nActLeftCol].nPos + + mpBorders[nActLeftCol].nWidth; + } + else + { + nMaxLeft += mpBorders[nIdx].nPos - + GetRightIndent() + std::max(GetFirstLineIndent(), + GetLeftIndent()); + if(nActLeftCol!=USHRT_MAX) + nMaxLeft -= mpBorders[nActLeftCol].nPos + + mpBorders[nActLeftCol].nWidth; + } + } + nMaxLeft += glMinFrame; + nMaxLeft += nDragOffset; + + // nMaxRight + // linear / proportional move + if((SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) || + (SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) ) + { + nMaxRight=lNullPix+CalcPropMaxRight(nIdx); + } + else if(SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) + { + nMaxRight = lNullPix + GetMargin2() - GetMargin1() + + (mpBorders.size() - nIdx - 1) * glMinFrame; + } + else + { + if(nRightCol==USHRT_MAX) + { // last column + nMaxRight = GetMargin2() + lNullPix; + if(IsActLastColumn()) + { + if(bRTL) + { + nMaxRight -= + GetMargin2() + GetRightIndent() - + std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + else + { + nMaxRight -= + GetMargin2() - GetRightIndent() + + std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + nMaxRight += mpBorders[nIdx].nPos + + mpBorders[nIdx].nWidth; + } + } + else + { + nMaxRight = lNullPix + mpBorders[nRightCol].nPos; + sal_uInt16 nNotHiddenRightCol = + GetActRightColumn(true, nIdx); + + if( nActLeftCol == nIdx ) + { + long nBorder = nNotHiddenRightCol == + USHRT_MAX ? + GetMargin2() : + mpBorders[nNotHiddenRightCol].nPos; + if(bRTL) + { + nMaxRight -= nBorder + GetRightIndent() - + std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + else + { + nMaxRight -= nBorder - GetRightIndent() + + std::max(GetFirstLineIndent(), + GetLeftIndent()); + } + nMaxRight += mpBorders[nIdx].nPos + + mpBorders[nIdx].nWidth; + } + } + nMaxRight -= glMinFrame; + nMaxRight -= mpBorders[nIdx].nWidth; + } + } + } + // ObjectItem + else + { + nMaxLeft = LONG_MIN; + nMaxRight = LONG_MAX; + } + break; + } + case RulerDragSize::N2: + { + nMaxLeft = lNullPix + mpBorders[nIdx].nPos; + if(nIdx == mxColumnItem->Count()-2) { // last column + nMaxRight = GetMargin2() + lNullPix; + if(mxColumnItem->IsLastAct()) { + nMaxRight -= + GetMargin2() - GetRightIndent() + + std::max(GetFirstLineIndent(), + GetLeftIndent()); + nMaxRight += mpBorders[nIdx].nPos + + mpBorders[nIdx].nWidth; + } + } + else { + nMaxRight = lNullPix + mpBorders[nIdx+1].nPos; + if(mxColumnItem->GetActColumn()-1 == nIdx) { + nMaxRight -= mpBorders[nIdx+1].nPos - GetRightIndent() + + std::max(GetFirstLineIndent(), + GetLeftIndent()); + nMaxRight += mpBorders[nIdx].nPos + + mpBorders[nIdx].nWidth; + } + } + nMaxRight -= glMinFrame; + nMaxRight -= mpBorders[nIdx].nWidth; + break; + } + } + nMaxRight += nDragOffset; + break; + } + case RulerType::Indent: + { + const sal_uInt16 nIdx = GetDragAryPos(); + switch(nIdx) { + case INDENT_FIRST_LINE - INDENT_GAP: + case INDENT_LEFT_MARGIN - INDENT_GAP: + { + if(bRTL) + { + nMaxLeft = lNullPix + GetRightIndent(); + + if(mxColumnItem && !mxColumnItem->IsFirstAct()) + nMaxLeft += mpBorders[mxColumnItem->GetActColumn()-1].nPos + + mpBorders[mxColumnItem->GetActColumn()-1].nWidth; + nMaxRight = lNullPix + GetMargin2(); + + // Dragging along + if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx && + !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY)) + { + if(GetLeftIndent() > GetFirstLineIndent()) + nMaxLeft += GetLeftIndent() - GetFirstLineIndent(); + else + nMaxRight -= GetFirstLineIndent() - GetLeftIndent(); + } + } + else + { + nMaxLeft = lNullPix; + + if(mxColumnItem && !mxColumnItem->IsFirstAct()) + nMaxLeft += mpBorders[mxColumnItem->GetActColumn()-1].nPos + + mpBorders[mxColumnItem->GetActColumn()-1].nWidth; + nMaxRight = lNullPix + GetRightIndent() - glMinFrame; + + // Dragging along + if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx && + !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY)) + { + if(GetLeftIndent() > GetFirstLineIndent()) + nMaxLeft += GetLeftIndent() - GetFirstLineIndent(); + else + nMaxRight -= GetFirstLineIndent() - GetLeftIndent(); + } + } + } + break; + case INDENT_RIGHT_MARGIN - INDENT_GAP: + { + if(bRTL) + { + nMaxLeft = lNullPix; + nMaxRight = lNullPix + std::min(GetFirstLineIndent(), GetLeftIndent()) - glMinFrame; + if (mxColumnItem) + { + sal_uInt16 nRightCol=GetActRightColumn( true ); + if(!IsActLastColumn( true )) + nMaxRight += mpBorders[nRightCol].nPos; + else + nMaxRight += GetMargin2(); + } + else + { + nMaxLeft += GetMargin1(); + } + nMaxLeft += glMinFrame; + } + else + { + nMaxLeft = lNullPix + + std::max(GetFirstLineIndent(), GetLeftIndent()); + nMaxRight = lNullPix; + if (mxColumnItem) + { + sal_uInt16 nRightCol=GetActRightColumn( true ); + if(!IsActLastColumn( true )) + nMaxRight += mpBorders[nRightCol].nPos; + else + nMaxRight += GetMargin2(); + } + else + nMaxRight += GetMargin2(); + nMaxLeft += glMinFrame; + } + } + break; + } + break; + } + case RulerType::Tab: // Tabs (Modifier) + /* left = NOf + Max(LAR, EZ) + right = NOf + RAR */ + + if (bRTL) + nMaxLeft = lNullPix + GetRightIndent(); + else + nMaxLeft = lNullPix + std::min(GetFirstLineIndent(), GetLeftIndent()); + + mxRulerImpl->lMaxRightLogic = GetLogicRightIndent() + lLogicNullOffset; + nMaxRight = ConvertSizePixel(mxRulerImpl->lMaxRightLogic); + break; + default: ; //prevent warning + } +} + +bool SvxRuler::StartDrag() +{ + /* + Beginning of a drag operation (SV-handler) evaluates modifier and + calculated values + + [Cross-reference] + + <SvxRuler::EvalModifier()> + <SvxRuler::CalcMinMax()> + <SvxRuler::EndDrag()> + */ + bool bContentProtected = mxRulerImpl->aProtectItem->IsContentProtected(); + + if(!bValid) + return false; + + mxRulerImpl->lLastLMargin = GetMargin1(); + mxRulerImpl->lLastRMargin = GetMargin2(); + + bool bOk = true; + + lInitialDragPos = GetDragPos(); + switch(GetDragType()) + { + case RulerType::Margin1: // left edge of the surrounding Frame + case RulerType::Margin2: // right edge of the surrounding Frame + if((bHorz && mxLRSpaceItem) || (!bHorz && mxULSpaceItem)) + { + if (!mxColumnItem) + EvalModifier(); + else + nDragType = SvxRulerDragFlags::OBJECT; + } + else + { + bOk = false; + } + break; + case RulerType::Border: // Table, column (Modifier) + if (mxColumnItem) + { + nDragOffset = 0; + if (!mxColumnItem->IsTable()) + nDragOffset = GetDragPos() - mpBorders[GetDragAryPos()].nPos; + EvalModifier(); + } + else + nDragOffset = 0; + break; + case RulerType::Indent: // Paragraph indents (Modifier) + { + if( bContentProtected ) + return false; + if(INDENT_LEFT_MARGIN == GetDragAryPos() + INDENT_GAP) { // Left paragraph indent + mpIndents[0] = mpIndents[INDENT_FIRST_LINE]; + EvalModifier(); + } + else + { + nDragType = SvxRulerDragFlags::OBJECT; + } + mpIndents[1] = mpIndents[GetDragAryPos() + INDENT_GAP]; + break; + } + case RulerType::Tab: // Tabs (Modifier) + if( bContentProtected ) + return false; + EvalModifier(); + mpTabs[0] = mpTabs[GetDragAryPos() + 1]; + mpTabs[0].nStyle |= RULER_STYLE_DONTKNOW; + break; + default: + nDragType = SvxRulerDragFlags::NONE; + } + + if(bOk) + CalcMinMax(); + + return bOk; +} + +void SvxRuler::Drag() +{ + /* SV-Draghandler */ + if(IsDragCanceled()) + { + Ruler::Drag(); + return; + } + switch(GetDragType()) { + case RulerType::Margin1: // left edge of the surrounding Frame + DragMargin1(); + mxRulerImpl->lLastLMargin = GetMargin1(); + break; + case RulerType::Margin2: // right edge of the surrounding Frame + DragMargin2(); + mxRulerImpl->lLastRMargin = GetMargin2(); + break; + case RulerType::Indent: // Paragraph indents + DragIndents(); + break; + case RulerType::Border: // Table, columns + if (mxColumnItem) + DragBorders(); + else if (mxObjectItem) + DragObjectBorder(); + break; + case RulerType::Tab: // Tabs + DragTabs(); + break; + default: + break; //prevent warning + } + Ruler::Drag(); +} + +void SvxRuler::EndDrag() +{ + /* + SV-handler; is called when ending the dragging. Triggers the updating of data + on the application, by calling the respective Apply...() methods to send the + data to the application. + */ + const bool bUndo = IsDragCanceled(); + const long lPos = GetDragPos(); + DrawLine_Impl(lTabPos, 6, bHorz); + lTabPos = -1; + + if(!bUndo) + { + switch(GetDragType()) + { + case RulerType::Margin1: // upper left edge of the surrounding Frame + case RulerType::Margin2: // lower right edge of the surrounding Frame + { + if (!mxColumnItem || !mxColumnItem->IsTable()) + ApplyMargins(); + + if(mxColumnItem && + (mxColumnItem->IsTable() || + (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL))) + ApplyBorders(); + + } + break; + case RulerType::Border: // Table, columns + if(lInitialDragPos != lPos || + (mxRulerImpl->bIsTableRows && bHorz)) //special case - the null offset is changed here + { + if (mxColumnItem) + { + ApplyBorders(); + if(bHorz) + UpdateTabs(); + } + else if (mxObjectItem) + ApplyObject(); + } + break; + case RulerType::Indent: // Paragraph indents + if(lInitialDragPos != lPos) + ApplyIndents(); + SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP); + break; + case RulerType::Tab: // Tabs + { + ApplyTabs(); + mpTabs[GetDragAryPos()].nStyle &= ~RULER_STYLE_INVISIBLE; + SetTabs(nTabCount, mpTabs.data() + TAB_GAP); + } + break; + default: + break; //prevent warning + } + } + nDragType = SvxRulerDragFlags::NONE; + + mbCoarseSnapping = false; + mbSnapping = true; + + Ruler::EndDrag(); + if(bUndo) + { + for(sal_uInt16 i = 0; i < mxRulerImpl->nControlerItems; i++) + { + pCtrlItems[i]->ClearCache(); + pCtrlItems[i]->GetBindings().Invalidate(pCtrlItems[i]->GetId()); + } + } +} + +void SvxRuler::ExtraDown() +{ + /* Override SV method, sets the new type for the Default tab. */ + + // Switch Tab Type + if(mxTabStopItem && + (nFlags & SvxRulerSupportFlags::TABS) == SvxRulerSupportFlags::TABS) + { + ++nDefTabType; + if(RULER_TAB_DEFAULT == nDefTabType) + nDefTabType = RULER_TAB_LEFT; + SetExtraType(RulerExtra::Tab, nDefTabType); + } + Ruler::ExtraDown(); +} + +void SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint) +{ + /* + Report through the bindings that the status update is completed. The ruler + updates its appearance and gets registered again in the bindings. + */ + + // start update + if (bActive && rHint.GetId() == SfxHintId::UpdateDone) + { + Update(); + EndListening(*pBindings); + bValid = true; + bListening = false; + } +} + +IMPL_LINK( SvxRuler, MenuSelect, Menu *, pMenu, bool ) +{ + /* Handler of the context menus for switching the unit of measurement */ + SetUnit(vcl::StringToMetric(OUString::fromUtf8(pMenu->GetCurItemIdent()))); + return false; +} + +IMPL_LINK( SvxRuler, TabMenuSelect, Menu *, pMenu, bool ) +{ + /* Handler of the tab menu for setting the type */ + if(mxTabStopItem && mxTabStopItem->Count() > mxRulerImpl->nIdx) + { + SvxTabStop aTabStop = mxTabStopItem->At(mxRulerImpl->nIdx); + aTabStop.GetAdjustment() = ToAttrTab_Impl(pMenu->GetCurItemId() - 1); + mxTabStopItem->Remove(mxRulerImpl->nIdx); + mxTabStopItem->Insert(aTabStop); + sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL; + pBindings->GetDispatcher()->ExecuteList(nTabStopId, + SfxCallMode::RECORD, { mxTabStopItem.get() }); + UpdateTabs(); + mxRulerImpl->nIdx = 0; + } + return false; +} + +static const char* RID_SVXSTR_RULER_TAB[] = +{ + RID_SVXSTR_RULER_TAB_LEFT, + RID_SVXSTR_RULER_TAB_RIGHT, + RID_SVXSTR_RULER_TAB_CENTER, + RID_SVXSTR_RULER_TAB_DECIMAL +}; + +void SvxRuler::Command( const CommandEvent& rCommandEvent ) +{ + /* Mouse context menu for switching the unit of measurement */ + if ( CommandEventId::ContextMenu == rCommandEvent.GetCommand() ) + { + CancelDrag(); + bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue(); + if ( !mpTabs.empty() && + RulerType::Tab == + GetType( rCommandEvent.GetMousePosPixel(), &mxRulerImpl->nIdx ) && + mpTabs[mxRulerImpl->nIdx + TAB_GAP].nStyle < RULER_TAB_DEFAULT ) + { + ScopedVclPtrInstance<PopupMenu> aMenu; + aMenu->SetSelectHdl(LINK(this, SvxRuler, TabMenuSelect)); + ScopedVclPtrInstance< VirtualDevice > pDev; + const Size aSz(ruler_tab_svx.width + 2, ruler_tab_svx.height + 2); + pDev->SetOutputSize(aSz); + pDev->SetBackground(Wallpaper(COL_WHITE)); + Color aFillColor(pDev->GetSettings().GetStyleSettings().GetShadowColor()); + const Point aPt(aSz.Width() / 2, aSz.Height() / 2); + + for ( sal_uInt16 i = RULER_TAB_LEFT; i < RULER_TAB_DEFAULT; ++i ) + { + sal_uInt16 nStyle = bRTL ? i|RULER_TAB_RTL : i; + nStyle |= static_cast<sal_uInt16>(bHorz ? WB_HORZ : WB_VERT); + DrawTab(*pDev, aFillColor, aPt, nStyle); + BitmapEx aItemBitmapEx(pDev->GetBitmapEx(Point(), aSz)); + aItemBitmapEx.Replace(COL_WHITE, COL_TRANSPARENT); + aMenu->InsertItem(i + 1, + SvxResId(RID_SVXSTR_RULER_TAB[i]), + Image(aItemBitmapEx)); + aMenu->CheckItem(i + 1, i == mpTabs[mxRulerImpl->nIdx + TAB_GAP].nStyle); + pDev->SetOutputSize(aSz); // delete device + } + aMenu->Execute( this, rCommandEvent.GetMousePosPixel() ); + } + else + { + VclBuilder aBuilder(nullptr, VclBuilderContainer::getUIRootDir(), "svx/ui/rulermenu.ui", ""); + VclPtr<PopupMenu> aMenu(aBuilder.get_menu("menu")); + aMenu->SetSelectHdl(LINK(this, SvxRuler, MenuSelect)); + FieldUnit eUnit = GetUnit(); + const sal_uInt16 nCount = aMenu->GetItemCount(); + + bool bReduceMetric = bool(nFlags & SvxRulerSupportFlags::REDUCED_METRIC); + for ( sal_uInt16 i = nCount; i; --i ) + { + sal_uInt16 nId = aMenu->GetItemId(i - 1); + OString sIdent = aMenu->GetItemIdent(nId); + FieldUnit eMenuUnit = vcl::StringToMetric(OUString::fromUtf8(sIdent)); + aMenu->CheckItem(nId, eMenuUnit == eUnit); + if( bReduceMetric ) + { + if (eMenuUnit == FieldUnit::M || + eMenuUnit == FieldUnit::KM || + eMenuUnit == FieldUnit::FOOT || + eMenuUnit == FieldUnit::MILE) + { + aMenu->RemoveItem(i - 1); + } + else if (( eMenuUnit == FieldUnit::CHAR ) && !bHorz ) + { + aMenu->RemoveItem(i - 1); + } + else if (( eMenuUnit == FieldUnit::LINE ) && bHorz ) + { + aMenu->RemoveItem(i - 1); + } + } + } + aMenu->Execute( this, rCommandEvent.GetMousePosPixel() ); + } + } + else + { + Ruler::Command( rCommandEvent ); + } +} + +sal_uInt16 SvxRuler::GetActRightColumn( + bool bForceDontConsiderHidden, + sal_uInt16 nAct ) const +{ + if( nAct == USHRT_MAX ) + nAct = mxColumnItem->GetActColumn(); + else + nAct++; //To be able to pass on the ActDrag + + bool bConsiderHidden = !bForceDontConsiderHidden && + !(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY); + + while( nAct < mxColumnItem->Count() - 1 ) + { + if (mxColumnItem->At(nAct).bVisible || bConsiderHidden) + return nAct; + else + nAct++; + } + return USHRT_MAX; +} + +sal_uInt16 SvxRuler::GetActLeftColumn( + bool bForceDontConsiderHidden, + sal_uInt16 nAct ) const +{ + if(nAct == USHRT_MAX) + nAct = mxColumnItem->GetActColumn(); + + sal_uInt16 nLeftOffset = 1; + + bool bConsiderHidden = !bForceDontConsiderHidden && + !(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY); + + while(nAct >= nLeftOffset) + { + if (mxColumnItem->At(nAct - nLeftOffset).bVisible || bConsiderHidden) + return nAct - nLeftOffset; + else + nLeftOffset++; + } + return USHRT_MAX; +} + +bool SvxRuler::IsActLastColumn( + bool bForceDontConsiderHidden, + sal_uInt16 nAct) const +{ + return GetActRightColumn(bForceDontConsiderHidden, nAct) == USHRT_MAX; +} + +bool SvxRuler::IsActFirstColumn( + bool bForceDontConsiderHidden, + sal_uInt16 nAct) const +{ + return GetActLeftColumn(bForceDontConsiderHidden, nAct) == USHRT_MAX; +} + +long SvxRuler::CalcPropMaxRight(sal_uInt16 nCol) const +{ + + if(!(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)) + { + // Remove the minimum width for all affected columns + // starting from the right edge + long _nMaxRight = GetMargin2() - GetMargin1(); + + long lFences = 0; + long lMinSpace = USHRT_MAX; + long lOldPos; + long lColumns = 0; + + sal_uInt16 nStart; + if(!mxColumnItem->IsTable()) + { + if(nCol == USHRT_MAX) + { + lOldPos = GetMargin1(); + nStart = 0; + } + else + { + lOldPos = mpBorders[nCol].nPos + mpBorders[nCol].nWidth; + nStart = nCol + 1; + lFences = mpBorders[nCol].nWidth; + } + + for(size_t i = nStart; i < mpBorders.size() - 1; ++i) + { + long lWidth = mpBorders[i].nPos - lOldPos; + lColumns += lWidth; + if(lWidth < lMinSpace) + lMinSpace = lWidth; + lOldPos = mpBorders[i].nPos + mpBorders[i].nWidth; + lFences += mpBorders[i].nWidth; + } + long lWidth = GetMargin2() - lOldPos; + lColumns += lWidth; + if(lWidth < lMinSpace) + lMinSpace = lWidth; + } + else + { + sal_uInt16 nActCol; + if(nCol == USHRT_MAX) //CalcMinMax for LeftMargin + { + lOldPos = GetMargin1(); + } + else + { + lOldPos = mpBorders[nCol].nPos; + } + lColumns = GetMargin2()-lOldPos; + nActCol = nCol; + lFences = 0; + while(nActCol < mpBorders.size() || nActCol == USHRT_MAX) + { + sal_uInt16 nRight; + if(nActCol == USHRT_MAX) + { + nRight = 0; + while (!(*mxColumnItem)[nRight].bVisible) + { + nRight++; + } + } + else + { + nRight = GetActRightColumn(false, nActCol); + } + + long lWidth; + if(nRight != USHRT_MAX) + { + lWidth = mpBorders[nRight].nPos - lOldPos; + lOldPos = mpBorders[nRight].nPos; + } + else + { + lWidth=GetMargin2() - lOldPos; + } + nActCol = nRight; + if(lWidth < lMinSpace) + lMinSpace = lWidth; + if(nActCol == USHRT_MAX) + break; + } + } + + _nMaxRight -= static_cast<long>(lFences + glMinFrame / static_cast<float>(lMinSpace) * lColumns); + return _nMaxRight; + } + else + { + if(mxColumnItem->IsTable()) + { + sal_uInt16 nVisCols = 0; + for(size_t i = GetActRightColumn(false, nCol); i < mpBorders.size();) + { + if ((*mxColumnItem)[i].bVisible) + nVisCols++; + i = GetActRightColumn(false, i); + } + return GetMargin2() - GetMargin1() - (nVisCols + 1) * glMinFrame; + } + else + { + long lWidth = 0; + for(size_t i = nCol; i < mpBorders.size() - 1; i++) + { + lWidth += glMinFrame + mpBorders[i].nWidth; + } + return GetMargin2() - GetMargin1() - lWidth; + } + } +} + +// Tab stops relative to indent (#i24363#) +void SvxRuler::SetTabsRelativeToIndent( bool bRel ) +{ + mxRulerImpl->bIsTabsRelativeToIndent = bRel; +} + +void SvxRuler::SetValues(RulerChangeType type, long diffValue) +{ + if (diffValue == 0) + return; + + if (type == RulerChangeType::MARGIN1) + AdjustMargin1(diffValue); + else if (type == RulerChangeType::MARGIN2) + SetMargin2( GetMargin2() - diffValue); + ApplyMargins(); +} diff --git a/svx/source/dialog/swframeexample.cxx b/svx/source/dialog/swframeexample.cxx new file mode 100644 index 000000000..ab866786b --- /dev/null +++ b/svx/source/dialog/swframeexample.cxx @@ -0,0 +1,714 @@ +/* -*- 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/metric.hxx> +#include <vcl/outdev.hxx> +#include <vcl/svapp.hxx> +#include <vcl/settings.hxx> +#include <svtools/colorcfg.hxx> +#include <svx/swframeexample.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <com/sun/star/text/HoriOrientation.hpp> +#include <com/sun/star/text/VertOrientation.hpp> +#include <com/sun/star/text/RelOrientation.hpp> + +using namespace ::com::sun::star::text; + +#define FLYINFLY_BORDER 3 +#define DEMOTEXT "Ij" + +namespace { + +void DrawRect_Impl(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, + const Color &rFillColor, const Color &rLineColor) +{ + rRenderContext.SetFillColor(rFillColor); + rRenderContext.SetLineColor(rLineColor); + rRenderContext.DrawRect(rRect); +} + +} + +SwFrameExample::SwFrameExample() + : nHAlign(HoriOrientation::CENTER) + , nHRel(RelOrientation::FRAME) + , nVAlign(VertOrientation::TOP) + , nVRel(RelOrientation::PRINT_AREA) + , nWrap(WrapTextMode_NONE) + , nAnchor(RndStdIds::FLY_AT_PAGE) + , bTrans(false) + , aRelPos(Point(0,0)) +{ + InitColors_Impl(); +} + +void SwFrameExample::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + CustomWidgetController::SetDrawingArea(pDrawingArea); + pDrawingArea->set_size_request(pDrawingArea->get_approximate_digit_width() * 16, + pDrawingArea->get_text_height() * 12); +} + +void SwFrameExample::InitColors_Impl() +{ + const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings(); + m_aBgCol = rSettings.GetWindowColor(); + + bool bHC = rSettings.GetHighContrastMode(); + + m_aFrameColor = COL_LIGHTGREEN; + m_aAlignColor = COL_LIGHTRED; + m_aTransColor = COL_TRANSPARENT; + + m_aTxtCol = bHC? + svtools::ColorConfig().GetColorValue(svtools::FONTCOLOR).nColor : + COL_GRAY; + m_aPrintAreaCol = bHC? m_aTxtCol : COL_GRAY; + m_aBorderCol = m_aTxtCol; + m_aBlankCol = bHC? m_aTxtCol : COL_LIGHTGRAY; + m_aBlankFrameCol = bHC? m_aTxtCol : COL_GRAY; +} + +void SwFrameExample::StyleUpdated() +{ + InitColors_Impl(); + CustomWidgetController::StyleUpdated(); +} + +void SwFrameExample::InitAllRects_Impl(vcl::RenderContext& rRenderContext) +{ + aPage.SetSize(GetOutputSizePixel()); + + sal_uInt32 nOutWPix = aPage.GetWidth(); + sal_uInt32 nOutHPix = aPage.GetHeight(); + + // PrintArea + sal_uInt32 nLBorder; + sal_uInt32 nRBorder; + sal_uInt32 nTBorder; + sal_uInt32 nBBorder; + + sal_uInt32 nLTxtBorder; + sal_uInt32 nRTxtBorder; + sal_uInt32 nTTxtBorder; + sal_uInt32 nBTxtBorder; + + if (nAnchor != RndStdIds::FLY_AS_CHAR) + { + nLBorder = 14; + nRBorder = 10; + nTBorder = 10; + nBBorder = 15; + + nLTxtBorder = 8; + nRTxtBorder = 4; + nTTxtBorder = 2; + nBTxtBorder = 2; + } + else + { + nLBorder = 2; + nRBorder = 2; + nTBorder = 2; + nBBorder = 2; + + nLTxtBorder = 2; + nRTxtBorder = 2; + nTTxtBorder = 2; + nBTxtBorder = 2; + } + aPagePrtArea = tools::Rectangle(Point(nLBorder, nTBorder), Point((nOutWPix - 1) - nRBorder, (nOutHPix - 1) - nBBorder)); + + // Example text: Preparing for the text output + // A line of text + aTextLine = aPagePrtArea; + aTextLine.SetSize(Size(aTextLine.GetWidth(), 2)); + aTextLine.AdjustLeft(nLTxtBorder ); + aTextLine.AdjustRight( -sal_Int32(nRTxtBorder) ); + aTextLine.Move(0, nTTxtBorder); + + // Rectangle to edges including paragraph + sal_uInt16 nLines = static_cast<sal_uInt16>((aPagePrtArea.GetHeight() / 2 - nTTxtBorder - nBTxtBorder) + / (aTextLine.GetHeight() + 2)); + aPara = aPagePrtArea; + aPara.SetSize(Size(aPara.GetWidth(), + (aTextLine.GetHeight() + 2) * nLines + nTTxtBorder + nBTxtBorder)); + + // Rectangle around paragraph without borders + aParaPrtArea = aPara; + aParaPrtArea.AdjustLeft(nLTxtBorder ); + aParaPrtArea.AdjustRight( -sal_Int32(nRTxtBorder) ); + aParaPrtArea.AdjustTop(nTTxtBorder ); + aParaPrtArea.AdjustBottom( -sal_Int32(nBTxtBorder) ); + + if (nAnchor == RndStdIds::FLY_AS_CHAR || nAnchor == RndStdIds::FLY_AT_CHAR) + { + vcl::Font aFont = OutputDevice::GetDefaultFont( + DefaultFontType::LATIN_TEXT, Application::GetSettings().GetLanguageTag().getLanguageType(), + GetDefaultFontFlags::OnlyOne, &rRenderContext ); + aFont.SetColor( m_aTxtCol ); + aFont.SetFillColor( m_aBgCol ); + aFont.SetWeight(WEIGHT_NORMAL); + + if (nAnchor == RndStdIds::FLY_AS_CHAR) + { + aFont.SetFontSize(Size(0, aParaPrtArea.GetHeight() - 2)); + rRenderContext.SetFont(aFont); + aParaPrtArea.SetSize(Size(rRenderContext.GetTextWidth(DEMOTEXT), rRenderContext.GetTextHeight())); + } + else + { + aFont.SetFontSize(Size(0, aParaPrtArea.GetHeight() / 2)); + rRenderContext.SetFont(aFont); + aAutoCharFrame.SetSize(Size(rRenderContext.GetTextWidth(OUString('A')), GetTextHeight())); + aAutoCharFrame.SetPos(Point(aParaPrtArea.Left() + (aParaPrtArea.GetWidth() - aAutoCharFrame.GetWidth()) / 2, + aParaPrtArea.Top() + (aParaPrtArea.GetHeight() - aAutoCharFrame.GetHeight()) / 2)); + } + } + + // Inner Frame anchored at the Frame + aFrameAtFrame = aPara; + aFrameAtFrame.AdjustLeft(9 ); + aFrameAtFrame.AdjustRight( -5 ); + aFrameAtFrame.AdjustBottom(5 ); + aFrameAtFrame.SetPos(Point(aFrameAtFrame.Left() + 2, (aPagePrtArea.Bottom() - aFrameAtFrame.GetHeight()) / 2 + 5)); + + // Size of the frame to be positioned + if (nAnchor != RndStdIds::FLY_AS_CHAR) + { + sal_uInt32 nLFBorder = nAnchor == RndStdIds::FLY_AT_PAGE ? nLBorder : nLTxtBorder; + sal_uInt32 nRFBorder = nAnchor == RndStdIds::FLY_AT_PAGE ? nRBorder : nRTxtBorder; + + switch (nHRel) + { + case RelOrientation::PAGE_LEFT: + case RelOrientation::FRAME_LEFT: + aFrmSize = Size(nLFBorder - 4, (aTextLine.GetHeight() + 2) * 3); + break; + + case RelOrientation::PAGE_RIGHT: + case RelOrientation::FRAME_RIGHT: + aFrmSize = Size(nRFBorder - 4, (aTextLine.GetHeight() + 2) * 3); + break; + + default: + aFrmSize = Size(nLBorder - 3, (aTextLine.GetHeight() + 2) * 3); + break; + } + aFrmSize.setWidth( std::max(5L, aFrmSize.Width()) ); + aFrmSize.setHeight( std::max(5L, aFrmSize.Height()) ); + } + else + { + sal_uInt32 nFreeWidth = aPagePrtArea.GetWidth() - rRenderContext.GetTextWidth(DEMOTEXT); + + aFrmSize = Size(nFreeWidth / 2, (aTextLine.GetHeight() + 2) * 3); + aDrawObj.SetSize(Size(std::max(5L, static_cast<long>(nFreeWidth) / 3L), std::max(5L, aFrmSize.Height() * 3L))); + aDrawObj.SetPos(Point(aParaPrtArea.Right() + 1, aParaPrtArea.Bottom() / 2)); + aParaPrtArea.SetRight( aDrawObj.Right() ); + } +} + +void SwFrameExample::CalcBoundRect_Impl(const vcl::RenderContext& rRenderContext, tools::Rectangle &rRect) +{ + switch (nAnchor) + { + case RndStdIds::FLY_AT_PAGE: + { + switch (nHRel) + { + case RelOrientation::FRAME: + case RelOrientation::PAGE_FRAME: + rRect.SetLeft( aPage.Left() ); + rRect.SetRight( aPage.Right() ); + break; + + case RelOrientation::PRINT_AREA: + case RelOrientation::PAGE_PRINT_AREA: + rRect.SetLeft( aPagePrtArea.Left() ); + rRect.SetRight( aPagePrtArea.Right() ); + break; + + case RelOrientation::PAGE_LEFT: + rRect.SetLeft( aPage.Left() ); + rRect.SetRight( aPagePrtArea.Left() ); + break; + + case RelOrientation::PAGE_RIGHT: + rRect.SetLeft( aPagePrtArea.Right() ); + rRect.SetRight( aPage.Right() ); + break; + } + + switch (nVRel) + { + case RelOrientation::PRINT_AREA: + case RelOrientation::PAGE_PRINT_AREA: + rRect.SetTop( aPagePrtArea.Top() ); + rRect.SetBottom( aPagePrtArea.Bottom() ); + break; + + case RelOrientation::FRAME: + case RelOrientation::PAGE_FRAME: + rRect.SetTop( aPage.Top() ); + rRect.SetBottom( aPage.Bottom() ); + break; + } + } + break; + + case RndStdIds::FLY_AT_FLY: + { + switch (nHRel) + { + case RelOrientation::FRAME: + case RelOrientation::PAGE_FRAME: + rRect.SetLeft( aFrameAtFrame.Left() ); + rRect.SetRight( aFrameAtFrame.Right() ); + break; + + case RelOrientation::PRINT_AREA: + case RelOrientation::PAGE_PRINT_AREA: + rRect.SetLeft( aFrameAtFrame.Left() + FLYINFLY_BORDER ); + rRect.SetRight( aFrameAtFrame.Right() - FLYINFLY_BORDER ); + break; + + case RelOrientation::PAGE_RIGHT: + rRect.SetLeft( aFrameAtFrame.Left() ); + rRect.SetRight( aFrameAtFrame.Left() + FLYINFLY_BORDER ); + break; + + case RelOrientation::PAGE_LEFT: + rRect.SetLeft( aFrameAtFrame.Right() ); + rRect.SetRight( aFrameAtFrame.Right() - FLYINFLY_BORDER ); + break; + } + + switch (nVRel) + { + case RelOrientation::FRAME: + case RelOrientation::PAGE_FRAME: + rRect.SetTop( aFrameAtFrame.Top() ); + rRect.SetBottom( aFrameAtFrame.Bottom() ); + break; + + case RelOrientation::PRINT_AREA: + case RelOrientation::PAGE_PRINT_AREA: + rRect.SetTop( aFrameAtFrame.Top() + FLYINFLY_BORDER ); + rRect.SetBottom( aFrameAtFrame.Bottom() - FLYINFLY_BORDER ); + break; + } + } + break; + case RndStdIds::FLY_AT_PARA: + case RndStdIds::FLY_AT_CHAR: + { + switch (nHRel) + { + case RelOrientation::FRAME: + rRect.SetLeft( aPara.Left() ); + rRect.SetRight( aPara.Right() ); + break; + + case RelOrientation::PRINT_AREA: + rRect.SetLeft( aParaPrtArea.Left() ); + rRect.SetRight( aParaPrtArea.Right() ); + break; + + case RelOrientation::PAGE_LEFT: + rRect.SetLeft( aPage.Left() ); + rRect.SetRight( aPagePrtArea.Left() ); + break; + + case RelOrientation::PAGE_RIGHT: + rRect.SetLeft( aPagePrtArea.Right() ); + rRect.SetRight( aPage.Right() ); + break; + + case RelOrientation::PAGE_FRAME: + rRect.SetLeft( aPage.Left() ); + rRect.SetRight( aPage.Right() ); + break; + + case RelOrientation::PAGE_PRINT_AREA: + rRect.SetLeft( aPagePrtArea.Left() ); + rRect.SetRight( aPagePrtArea.Right() ); + break; + + case RelOrientation::FRAME_LEFT: + rRect.SetLeft( aPara.Left() ); + rRect.SetRight( aParaPrtArea.Left() ); + break; + + case RelOrientation::FRAME_RIGHT: + rRect.SetLeft( aParaPrtArea.Right() ); + rRect.SetRight( aPara.Right() ); + break; + + case RelOrientation::CHAR: + rRect.SetLeft( aAutoCharFrame.Left() ); + rRect.SetRight( aAutoCharFrame.Left() ); + break; + } + + switch (nVRel) + { + case RelOrientation::FRAME: + rRect.SetTop( aPara.Top() ); + rRect.SetBottom( aPara.Bottom() ); + break; + + case RelOrientation::PRINT_AREA: + rRect.SetTop( aParaPrtArea.Top() ); + rRect.SetBottom( aParaPrtArea.Bottom() ); + break; + + case RelOrientation::CHAR: + if (nVAlign != VertOrientation::NONE && + nVAlign != VertOrientation::CHAR_BOTTOM) + rRect.SetTop( aAutoCharFrame.Top() ); + else + rRect.SetTop( aAutoCharFrame.Bottom() ); + rRect.SetBottom( aAutoCharFrame.Bottom() ); + break; + // OD 12.11.2003 #i22341# + case RelOrientation::TEXT_LINE: + rRect.SetTop( aAutoCharFrame.Top() ); + rRect.SetBottom( aAutoCharFrame.Top() ); + break; + } + } + break; + + case RndStdIds::FLY_AS_CHAR: + rRect.SetLeft( aParaPrtArea.Left() ); + rRect.SetRight( aParaPrtArea.Right() ); + + switch (nVAlign) + { + case VertOrientation::NONE: + case VertOrientation::TOP: + case VertOrientation::CENTER: + case VertOrientation::BOTTOM: + { + FontMetric aMetric(rRenderContext.GetFontMetric()); + + rRect.SetTop( aParaPrtArea.Bottom() - aMetric.GetDescent() ); + rRect.SetBottom( rRect.Top() ); + } + break; + + default: + + case VertOrientation::LINE_TOP: + case VertOrientation::LINE_CENTER: + case VertOrientation::LINE_BOTTOM: + rRect.SetTop( aParaPrtArea.Top() ); + rRect.SetBottom( aDrawObj.Bottom() ); + break; + + case VertOrientation::CHAR_TOP: + case VertOrientation::CHAR_CENTER: + case VertOrientation::CHAR_BOTTOM: + rRect.SetTop( aParaPrtArea.Top() ); + rRect.SetBottom( aParaPrtArea.Bottom() ); + break; + } + break; + + default: + break; + } +} + +tools::Rectangle SwFrameExample::DrawInnerFrame_Impl(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, + const Color &rFillColor, const Color &rBorderColor) +{ + DrawRect_Impl(rRenderContext, rRect, rFillColor, rBorderColor); + + // determine the area relative to which the positioning happens + tools::Rectangle aRect(rRect); // aPagePrtArea = Default + CalcBoundRect_Impl(rRenderContext, aRect); + + if (nAnchor == RndStdIds::FLY_AT_FLY && &rRect == &aPagePrtArea) + { + // draw text paragraph + tools::Rectangle aTxt(aTextLine); + sal_Int32 nStep = aTxt.GetHeight() + 2; + sal_uInt16 nLines = static_cast<sal_uInt16>(aParaPrtArea.GetHeight() / (aTextLine.GetHeight() + 2)); + + for (sal_uInt16 i = 0; i < nLines; i++) + { + if (i == nLines - 1) + aTxt.SetSize(Size(aTxt.GetWidth() / 2, aTxt.GetHeight())); + DrawRect_Impl(rRenderContext, aTxt, m_aTxtCol, m_aTransColor); + aTxt.Move(0, nStep); + } + } + + return aRect; +} + +void SwFrameExample::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&) +{ + rRenderContext.SetMapMode(MapMode(MapUnit::MapPixel)); + + InitAllRects_Impl(rRenderContext); + + // Draw page + DrawRect_Impl(rRenderContext, aPage, m_aBgCol, m_aBorderCol); + + // Draw PrintArea + tools::Rectangle aRect = DrawInnerFrame_Impl(rRenderContext, aPagePrtArea, m_aTransColor, m_aPrintAreaCol); + + if (nAnchor == RndStdIds::FLY_AT_FLY) + aRect = DrawInnerFrame_Impl(rRenderContext, aFrameAtFrame, m_aBgCol, m_aBorderCol); + + long lXPos = 0; + long lYPos = 0; + + // Horizontal alignment + if (nAnchor != RndStdIds::FLY_AS_CHAR) + { + switch (nHAlign) + { + case HoriOrientation::RIGHT: + { + lXPos = aRect.Right() - aFrmSize.Width() + 1; + break; + } + case HoriOrientation::CENTER: + { + lXPos = aRect.Left() + (aRect.GetWidth() - aFrmSize.Width()) / 2; + break; + } + case HoriOrientation::NONE: + { + lXPos = aRect.Left() + aRelPos.X(); + break; + } + + default: // HoriOrientation::LEFT + lXPos = aRect.Left(); + break; + } + } + else + { + lXPos = aRect.Right() + 2; + } + + // Vertical Alignment + if (nAnchor != RndStdIds::FLY_AS_CHAR) + { + switch (nVAlign) + { + case VertOrientation::BOTTOM: + case VertOrientation::LINE_BOTTOM: + { + // #i22341# + if ( nVRel != RelOrientation::TEXT_LINE ) + { + lYPos = aRect.Bottom() - aFrmSize.Height() + 1; + } + else + { + lYPos = aRect.Top(); + } + break; + } + case VertOrientation::CENTER: + case VertOrientation::LINE_CENTER: + { + lYPos = aRect.Top() + (aRect.GetHeight() - aFrmSize.Height()) / 2; + break; + } + case VertOrientation::NONE: + { + // #i22341# + if ( nVRel != RelOrientation::CHAR && nVRel != RelOrientation::TEXT_LINE ) + lYPos = aRect.Top() + aRelPos.Y(); + else + lYPos = aRect.Top() - aRelPos.Y(); + break; + } + default: + // #i22341# + if ( nVRel != RelOrientation::TEXT_LINE ) + { + lYPos = aRect.Top(); + } + else + { + lYPos = aRect.Bottom() - aFrmSize.Height() + 1; + } + break; + } + } + else + { + switch(nVAlign) + { + case VertOrientation::CENTER: + case VertOrientation::CHAR_CENTER: + case VertOrientation::LINE_CENTER: + lYPos = aRect.Top() + (aRect.GetHeight() - aFrmSize.Height()) / 2; + break; + + case VertOrientation::TOP: + case VertOrientation::CHAR_BOTTOM: + case VertOrientation::LINE_BOTTOM: + lYPos = aRect.Bottom() - aFrmSize.Height() + 1; + break; + + default: + lYPos = aRect.Top() - aRelPos.Y(); + break; + } + } + + tools::Rectangle aFrmRect(Point(lXPos, lYPos), aFrmSize); + + tools::Rectangle* pOuterFrame = &aPage; + + if (nAnchor == RndStdIds::FLY_AT_FLY) + pOuterFrame = &aFrameAtFrame; + + if (aFrmRect.Left() < pOuterFrame->Left()) + aFrmRect.Move(pOuterFrame->Left() - aFrmRect.Left(), 0); + if (aFrmRect.Right() > pOuterFrame->Right()) + aFrmRect.Move(pOuterFrame->Right() - aFrmRect.Right(), 0); + + if (aFrmRect.Top() < pOuterFrame->Top()) + aFrmRect.Move(0, pOuterFrame->Top() - aFrmRect.Top()); + if (aFrmRect.Bottom() > pOuterFrame->Bottom()) + aFrmRect.Move(0, pOuterFrame->Bottom() - aFrmRect.Bottom()); + + // Draw Test paragraph + const long nTxtLineHeight = aTextLine.GetHeight(); + tools::Rectangle aTxt(aTextLine); + sal_Int32 nStep; + sal_uInt16 nLines; + + if (nAnchor == RndStdIds::FLY_AT_FLY) + { + aTxt.SetLeft( aFrameAtFrame.Left() + FLYINFLY_BORDER ); + aTxt.SetRight( aFrameAtFrame.Right() - FLYINFLY_BORDER ); + aTxt.SetTop( aFrameAtFrame.Top() + FLYINFLY_BORDER ); + aTxt.SetBottom( aTxt.Top() + aTextLine.GetHeight() - 1 ); + + nStep = aTxt.GetHeight() + 2; + nLines = static_cast<sal_uInt16>(((aFrameAtFrame.GetHeight() - 2 * FLYINFLY_BORDER) * 2 / 3) + / (aTxt.GetHeight() + 2)); + } + else + { + nStep = aTxt.GetHeight() + 2; + nLines = static_cast<sal_uInt16>(aParaPrtArea.GetHeight() / (aTextLine.GetHeight() + 2)); + } + + if (nAnchor != RndStdIds::FLY_AS_CHAR) + { + // Simulate text + const long nOldR = aTxt.Right(); + const long nOldL = aTxt.Left(); + + // #i22341# + const bool bIgnoreWrap = nAnchor == RndStdIds::FLY_AT_CHAR && + ( nHRel == RelOrientation::CHAR || nVRel == RelOrientation::CHAR || + nVRel == RelOrientation::TEXT_LINE ); + + for (sal_uInt16 i = 0; i < nLines; ++i) + { + if (i == (nLines - 1)) + aTxt.SetSize(Size(aTxt.GetWidth() / 2, aTxt.GetHeight())); + + if (aTxt.IsOver(aFrmRect) && nAnchor != RndStdIds::FLY_AS_CHAR && !bIgnoreWrap) + { + switch(nWrap) + { + case WrapTextMode_NONE: + aTxt.SetTop( aFrmRect.Bottom() + nTxtLineHeight ); + aTxt.SetBottom( aTxt.Top() + nTxtLineHeight - 1 ); + break; + + case WrapTextMode_LEFT: + aTxt.SetRight( aFrmRect.Left() ); + break; + + case WrapTextMode_RIGHT: + aTxt.SetLeft( aFrmRect.Right() ); + break; + default: break; + } + } + if (pOuterFrame->IsInside(aTxt)) + DrawRect_Impl(rRenderContext, aTxt, m_aTxtCol, m_aTransColor ); + + aTxt.Move(0, nStep); + aTxt.SetRight( nOldR ); + aTxt.SetLeft( nOldL ); + } + aTxt.Move(0, -nStep); + + if (nAnchor != RndStdIds::FLY_AT_FLY && aTxt.Bottom() > aParaPrtArea.Bottom()) + { + // Text has been replaced by frame, so adjust parameters height + sal_Int32 nDiff = aTxt.Bottom() - aParaPrtArea.Bottom(); + aParaPrtArea.AdjustBottom(nDiff ); + aPara.AdjustBottom(nDiff ); + + CalcBoundRect_Impl(rRenderContext, aRect); + + aParaPrtArea.AdjustBottom( -nDiff ); + aPara.AdjustBottom( -nDiff ); + } + if (nAnchor == RndStdIds::FLY_AT_CHAR && bIgnoreWrap) + rRenderContext.DrawText(aAutoCharFrame, OUString('A')); + } + else + { + rRenderContext.DrawText(aParaPrtArea, OUString(DEMOTEXT)); + DrawRect_Impl(rRenderContext, aDrawObj, m_aBlankCol, m_aBlankFrameCol ); + } + + // Draw rectangle on which the frame is aligned: + DrawRect_Impl(rRenderContext, aRect, m_aTransColor, m_aAlignColor); + + // Frame View + bool bDontFill = (nAnchor == RndStdIds::FLY_AT_CHAR && aFrmRect.IsOver(aAutoCharFrame)) || bTrans; + DrawRect_Impl(rRenderContext, aFrmRect, bDontFill? m_aTransColor : m_aBgCol, m_aFrameColor); +} + +void SwFrameExample::SetRelPos(const Point& rP) +{ + aRelPos = rP; + + if (aRelPos.X() > 0) + aRelPos.setX( 5 ); + if (aRelPos.X() < 0) + aRelPos.setX( -5 ); + + if (aRelPos.Y() > 0) + aRelPos.setY( 5 ); + if (aRelPos.Y() < 0) + aRelPos.setY( -5 ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/swframeposstrings.cxx b/svx/source/dialog/swframeposstrings.cxx new file mode 100644 index 000000000..29b9243f8 --- /dev/null +++ b/svx/source/dialog/swframeposstrings.cxx @@ -0,0 +1,38 @@ +/* -*- 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 <cassert> + +#include <svx/swframeposstrings.hxx> +#include <svx/dialmgr.hxx> +#include <swframeposstrings.hrc> + +OUString SvxSwFramePosString::GetString(StringId eId) +{ + static_assert( + (SAL_N_ELEMENTS(RID_SVXSW_FRAMEPOSITIONS) + == SvxSwFramePosString::STR_MAX), + "RID_SVXSW_FRAMEPOSITIONS too small"); + assert(eId >= 0 && eId < STR_MAX); + return SvxResId(RID_SVXSW_FRAMEPOSITIONS[eId]); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/txencbox.cxx b/svx/source/dialog/txencbox.cxx new file mode 100644 index 000000000..4229ea109 --- /dev/null +++ b/svx/source/dialog/txencbox.cxx @@ -0,0 +1,274 @@ +/* -*- 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 <config_features.h> + +#include <svx/txencbox.hxx> +#include <svx/dialmgr.hxx> +#include <svx/txenctab.hxx> +#if HAVE_FEATURE_DBCONNECTIVITY +#include <dbcharsethelper.hxx> +#endif +#include <unotools/syslocale.hxx> +#include <rtl/tencinfo.h> +#include <sal/log.hxx> +#include <txenctab.hrc> + +namespace +{ + std::vector<rtl_TextEncoding> FillFromDbTextEncodingMap(bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags) + { + std::vector<rtl_TextEncoding> aRet; +#if !HAVE_FEATURE_DBCONNECTIVITY + (void)bExcludeImportSubsets; + (void)nExcludeInfoFlags; +#else + rtl_TextEncodingInfo aInfo; + aInfo.StructSize = sizeof(rtl_TextEncodingInfo); + ::std::vector< rtl_TextEncoding > aEncs; + sal_Int32 nCount = svxform::charset_helper::getSupportedTextEncodings( aEncs ); + for ( sal_Int32 j=0; j<nCount; j++ ) + { + bool bInsert = true; + rtl_TextEncoding nEnc = rtl_TextEncoding( aEncs[j] ); + if ( nExcludeInfoFlags ) + { + if ( !rtl_getTextEncodingInfo( nEnc, &aInfo ) ) + bInsert = false; + else + { + if ( (aInfo.Flags & nExcludeInfoFlags) == 0 ) + { + if ( (nExcludeInfoFlags & RTL_TEXTENCODING_INFO_UNICODE) && + ((nEnc == RTL_TEXTENCODING_UCS2) || + nEnc == RTL_TEXTENCODING_UCS4) ) + bInsert = false; // InfoFlags don't work for Unicode :-( + } + else + bInsert = false; + } + } + if ( bInsert ) + { + if ( bExcludeImportSubsets ) + { + switch ( nEnc ) + { + // subsets of RTL_TEXTENCODING_GB_18030 + case RTL_TEXTENCODING_GB_2312 : + case RTL_TEXTENCODING_GBK : + case RTL_TEXTENCODING_MS_936 : + bInsert = false; + break; + } + } + // CharsetMap offers a RTL_TEXTENCODING_DONTKNOW for internal use, + // makes no sense here and would result in an empty string as list + // entry. + if ( bInsert && nEnc != RTL_TEXTENCODING_DONTKNOW ) + aRet.push_back(nEnc); + } + } +#endif + return aRet; + } +} + +void SvxTextEncodingBox::FillFromDbTextEncodingMap( + bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags ) +{ + m_xControl->freeze(); + auto aEncs = ::FillFromDbTextEncodingMap(bExcludeImportSubsets, nExcludeInfoFlags); + for (auto nEnc : aEncs) + InsertTextEncoding(nEnc); + m_xControl->thaw(); +} + +void SvxTextEncodingTreeView::FillFromDbTextEncodingMap( + bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags ) +{ + m_xControl->freeze(); + auto aEncs = ::FillFromDbTextEncodingMap(bExcludeImportSubsets, nExcludeInfoFlags); + for (auto nEnc : aEncs) + InsertTextEncoding(nEnc); + m_xControl->thaw(); +} + +SvxTextEncodingBox::SvxTextEncodingBox(std::unique_ptr<weld::ComboBox> pControl) + : m_xControl(std::move(pControl)) +{ + m_xControl->make_sorted(); +} + +SvxTextEncodingTreeView::SvxTextEncodingTreeView(std::unique_ptr<weld::TreeView> pControl) + : m_xControl(std::move(pControl)) +{ + m_xControl->make_sorted(); +} + +SvxTextEncodingBox::~SvxTextEncodingBox() +{ +} + +SvxTextEncodingTreeView::~SvxTextEncodingTreeView() +{ +} + +namespace +{ + std::vector<int> FillFromTextEncodingTable(bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags, sal_uInt32 nButIncludeInfoFlags) + { + std::vector<int> aRet; + + rtl_TextEncodingInfo aInfo; + aInfo.StructSize = sizeof(rtl_TextEncodingInfo); + const sal_uInt32 nCount = SAL_N_ELEMENTS(RID_SVXSTR_TEXTENCODING_TABLE); + for (sal_uInt32 j = 0; j < nCount; ++j) + { + bool bInsert = true; + rtl_TextEncoding nEnc = RID_SVXSTR_TEXTENCODING_TABLE[j].second; + if ( nExcludeInfoFlags ) + { + if ( !rtl_getTextEncodingInfo( nEnc, &aInfo ) ) + bInsert = false; + else + { + if ( (aInfo.Flags & nExcludeInfoFlags) == 0 ) + { + if ( (nExcludeInfoFlags & RTL_TEXTENCODING_INFO_UNICODE) && + ((nEnc == RTL_TEXTENCODING_UCS2) || + nEnc == RTL_TEXTENCODING_UCS4) ) + bInsert = false; // InfoFlags don't work for Unicode :-( + } + else if ( (aInfo.Flags & nButIncludeInfoFlags) == 0 ) + bInsert = false; + } + } + if ( bExcludeImportSubsets ) + { + switch ( nEnc ) + { + // subsets of RTL_TEXTENCODING_GB_18030 + case RTL_TEXTENCODING_GB_2312 : + case RTL_TEXTENCODING_GBK : + case RTL_TEXTENCODING_MS_936 : + bInsert = false; + break; + } + } + if ( bInsert ) + aRet.push_back(j); + } + return aRet; + } +} + +void SvxTextEncodingBox::FillFromTextEncodingTable( + bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags, + sal_uInt32 nButIncludeInfoFlags ) +{ + std::vector<int> aRet(::FillFromTextEncodingTable(bExcludeImportSubsets, nExcludeInfoFlags, nButIncludeInfoFlags)); + m_xControl->freeze(); + for (auto j : aRet) + { + rtl_TextEncoding nEnc = RID_SVXSTR_TEXTENCODING_TABLE[j].second; + InsertTextEncoding(nEnc, SvxResId(RID_SVXSTR_TEXTENCODING_TABLE[j].first)); + } + m_xControl->thaw(); +} + +void SvxTextEncodingTreeView::FillFromTextEncodingTable( + bool bExcludeImportSubsets, sal_uInt32 nExcludeInfoFlags ) +{ + std::vector<int> aRet(::FillFromTextEncodingTable(bExcludeImportSubsets, nExcludeInfoFlags, /*nButIncludeInfoFlags*/0)); + m_xControl->freeze(); + for (auto j : aRet) + { + rtl_TextEncoding nEnc = RID_SVXSTR_TEXTENCODING_TABLE[j].second; + InsertTextEncoding(nEnc, SvxResId(RID_SVXSTR_TEXTENCODING_TABLE[j].first)); + } + m_xControl->thaw(); +} + +void SvxTextEncodingBox::FillWithMimeAndSelectBest() +{ + FillFromTextEncodingTable( false, 0xffffffff, RTL_TEXTENCODING_INFO_MIME ); + rtl_TextEncoding nEnc = SvtSysLocale::GetBestMimeEncoding(); + SelectTextEncoding( nEnc ); +} + +void SvxTextEncodingBox::InsertTextEncoding( const rtl_TextEncoding nEnc, + const OUString& rEntry ) +{ + m_xControl->append(OUString::number(nEnc), rEntry); +} + +void SvxTextEncodingTreeView::InsertTextEncoding( const rtl_TextEncoding nEnc, + const OUString& rEntry ) +{ + m_xControl->append(OUString::number(nEnc), rEntry); +} + +void SvxTextEncodingBox::InsertTextEncoding( const rtl_TextEncoding nEnc ) +{ + const OUString& rEntry = SvxTextEncodingTable::GetTextString(nEnc); + if (!rEntry.isEmpty()) + InsertTextEncoding( nEnc, rEntry ); + else + SAL_WARN( "svx.dialog", "SvxTextEncodingBox::InsertTextEncoding: no resource string for text encoding: " << static_cast<sal_Int32>( nEnc ) ); +} + +void SvxTextEncodingTreeView::InsertTextEncoding( const rtl_TextEncoding nEnc ) +{ + const OUString& rEntry = SvxTextEncodingTable::GetTextString(nEnc); + if (!rEntry.isEmpty()) + InsertTextEncoding( nEnc, rEntry ); + else + SAL_WARN( "svx.dialog", "SvxTextEncodingTreeView::InsertTextEncoding: no resource string for text encoding: " << static_cast<sal_Int32>( nEnc ) ); +} + +rtl_TextEncoding SvxTextEncodingBox::GetSelectTextEncoding() const +{ + OUString sId(m_xControl->get_active_id()); + if (!sId.isEmpty()) + return rtl_TextEncoding(sId.toInt32()); + else + return RTL_TEXTENCODING_DONTKNOW; +} + +rtl_TextEncoding SvxTextEncodingTreeView::GetSelectTextEncoding() const +{ + OUString sId(m_xControl->get_selected_id()); + if (!sId.isEmpty()) + return rtl_TextEncoding(sId.toInt32()); + else + return RTL_TEXTENCODING_DONTKNOW; +} + +void SvxTextEncodingBox::SelectTextEncoding( const rtl_TextEncoding nEnc ) +{ + m_xControl->set_active_id(OUString::number(nEnc)); +} + +void SvxTextEncodingTreeView::SelectTextEncoding( const rtl_TextEncoding nEnc ) +{ + m_xControl->select_id(OUString::number(nEnc)); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/txenctab.cxx b/svx/source/dialog/txenctab.cxx new file mode 100644 index 000000000..791b8f735 --- /dev/null +++ b/svx/source/dialog/txenctab.cxx @@ -0,0 +1,49 @@ +/* -*- 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/dialmgr.hxx> +#include <svx/txenctab.hxx> +#include <txenctab.hrc> + +OUString SvxTextEncodingTable::GetTextString(const rtl_TextEncoding nEnc) +{ + const size_t nCount = SAL_N_ELEMENTS(RID_SVXSTR_TEXTENCODING_TABLE); + + for (size_t i = 0; i < nCount; ++i) + { + if (RID_SVXSTR_TEXTENCODING_TABLE[i].second == nEnc) + return SvxResId(RID_SVXSTR_TEXTENCODING_TABLE[i].first); + } + + return OUString(); +} + +rtl_TextEncoding SvxTextEncodingTable::GetTextEncoding(const OUString& rStr) +{ + const size_t nCount = SAL_N_ELEMENTS(RID_SVXSTR_TEXTENCODING_TABLE); + + for (size_t i = 0; i < nCount; ++i) + { + if (SvxResId(RID_SVXSTR_TEXTENCODING_TABLE[i].first).equals(rStr)) + return RID_SVXSTR_TEXTENCODING_TABLE[i].second; + } + return RTL_TEXTENCODING_DONTKNOW; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/source/dialog/weldeditview.cxx b/svx/source/dialog/weldeditview.cxx new file mode 100644 index 000000000..12c6a94cd --- /dev/null +++ b/svx/source/dialog/weldeditview.cxx @@ -0,0 +1,1482 @@ +/* -*- 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/accessibility/AccessibleRole.hpp> +#include <com/sun/star/accessibility/AccessibleStateType.hpp> +#include <com/sun/star/accessibility/XAccessible.hpp> +#include <com/sun/star/accessibility/XAccessibleComponent.hpp> +#include <com/sun/star/accessibility/XAccessibleContext.hpp> +#include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp> +#include <com/sun/star/lang/IndexOutOfBoundsException.hpp> +#include <editeng/eeitem.hxx> +#include <editeng/fhgtitem.hxx> +#include <editeng/fontitem.hxx> +#include <editeng/outliner.hxx> +#include <editeng/unoedhlp.hxx> +#include <editeng/unoedsrc.hxx> +#include <i18nlangtag/languagetag.hxx> +#include <osl/diagnose.h> +#include <svl/itemset.hxx> +#include <sal/log.hxx> +#include <svx/AccessibleTextHelper.hxx> +#include <svx/weldeditview.hxx> +#include <tools/diagnose_ex.h> +#include <unotools/accessiblestatesethelper.hxx> +#include <vcl/cursor.hxx> +#include <vcl/event.hxx> +#include <vcl/ptrstyle.hxx> +#include <vcl/settings.hxx> +#include <vcl/svapp.hxx> + +WeldEditView::WeldEditView() {} + +// tdf#127033 want to use UI font so override makeEditEngine to enable that +void WeldEditView::makeEditEngine() +{ + SfxItemPool* pItemPool = EditEngine::CreatePool(); + + vcl::Font aAppFont(Application::GetSettings().GetStyleSettings().GetAppFont()); + + pItemPool->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(), + "", PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW, + EE_CHAR_FONTINFO)); + pItemPool->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(), + "", PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW, + EE_CHAR_FONTINFO_CJK)); + pItemPool->SetPoolDefaultItem(SvxFontItem(aAppFont.GetFamilyType(), aAppFont.GetFamilyName(), + "", PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW, + EE_CHAR_FONTINFO_CTL)); + + pItemPool->SetPoolDefaultItem( + SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT)); + pItemPool->SetPoolDefaultItem( + SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CJK)); + pItemPool->SetPoolDefaultItem( + SvxFontHeightItem(aAppFont.GetFontHeight() * 20, 100, EE_CHAR_FONTHEIGHT_CTL)); + + m_xEditEngine.reset(new EditEngine(pItemPool)); +} + +void WeldEditView::Resize() +{ + OutputDevice& rDevice = GetDrawingArea()->get_ref_device(); + Size aOutputSize(rDevice.PixelToLogic(GetOutputSizePixel())); + Size aSize(aOutputSize); + m_xEditEngine->SetPaperSize(aSize); + m_xEditView->SetOutputArea(tools::Rectangle(Point(0, 0), aOutputSize)); + weld::CustomWidgetController::Resize(); +} + +void WeldEditView::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) +{ + //note: ScEditWindow::Paint is similar + + rRenderContext.Push(PushFlags::ALL); + rRenderContext.SetClipRegion(); + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + Color aBgColor = rStyleSettings.GetWindowColor(); + + m_xEditView->SetBackgroundColor(aBgColor); + + rRenderContext.SetBackground(aBgColor); + + tools::Rectangle aLogicRect(rRenderContext.PixelToLogic(rRect)); + m_xEditView->Paint(aLogicRect, &rRenderContext); + + if (HasFocus()) + { + m_xEditView->ShowCursor(); + vcl::Cursor* pCursor = m_xEditView->GetCursor(); + pCursor->DrawToDevice(rRenderContext); + } + + std::vector<tools::Rectangle> aLogicRects; + + // get logic selection + m_xEditView->GetSelectionRectangles(aLogicRects); + + rRenderContext.SetLineColor(); + rRenderContext.SetFillColor(COL_BLACK); + rRenderContext.SetRasterOp(RasterOp::Invert); + + for (const auto& rSelectionRect : aLogicRects) + rRenderContext.DrawRect(rSelectionRect); + + rRenderContext.Pop(); +} + +bool WeldEditView::MouseMove(const MouseEvent& rMEvt) { return m_xEditView->MouseMove(rMEvt); } + +bool WeldEditView::MouseButtonDown(const MouseEvent& rMEvt) +{ + if (!HasFocus()) + { + GrabFocus(); + GetFocus(); + } + + return m_xEditView->MouseButtonDown(rMEvt); +} + +bool WeldEditView::MouseButtonUp(const MouseEvent& rMEvt) +{ + return m_xEditView->MouseButtonUp(rMEvt); +} + +bool WeldEditView::KeyInput(const KeyEvent& rKEvt) +{ + sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode(); + + if (nKey == KEY_TAB) + { + return false; + } + else if (!m_xEditView->PostKeyEvent(rKEvt)) + { + if (rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2()) + { + if (nKey == KEY_A) + { + sal_Int32 nPar = m_xEditEngine->GetParagraphCount(); + if (nPar) + { + sal_Int32 nLen = m_xEditEngine->GetTextLen(nPar - 1); + m_xEditView->SetSelection(ESelection(0, 0, nPar - 1, nLen)); + } + return true; + } + } + + return false; + } + + return true; +} + +bool WeldEditView::Command(const CommandEvent& rCEvt) +{ + m_xEditView->Command(rCEvt); + return true; +} + +class WeldEditAccessible; + +namespace +{ +class WeldViewForwarder : public SvxViewForwarder +{ + WeldEditAccessible& m_rEditAcc; + + WeldViewForwarder(const WeldViewForwarder&) = delete; + WeldViewForwarder& operator=(const WeldViewForwarder&) = delete; + +public: + explicit WeldViewForwarder(WeldEditAccessible& rAcc) + : m_rEditAcc(rAcc) + { + } + + virtual bool IsValid() const override; + virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override; + virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override; +}; +} + +class WeldEditAccessible; + +namespace +{ +class WeldEditSource; + +/* analog to SvxEditEngineForwarder */ +class WeldTextForwarder : public SvxTextForwarder +{ + WeldEditAccessible& m_rEditAcc; + WeldEditSource& m_rEditSource; + + DECL_LINK(NotifyHdl, EENotify&, void); + + WeldTextForwarder(const WeldTextForwarder&) = delete; + WeldTextForwarder& operator=(const WeldTextForwarder&) = delete; + +public: + WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource); + virtual ~WeldTextForwarder() override; + + virtual sal_Int32 GetParagraphCount() const override; + virtual sal_Int32 GetTextLen(sal_Int32 nParagraph) const override; + virtual OUString GetText(const ESelection& rSel) const override; + virtual SfxItemSet GetAttribs(const ESelection& rSel, EditEngineAttribs nOnlyHardAttrib + = EditEngineAttribs::All) const override; + virtual SfxItemSet GetParaAttribs(sal_Int32 nPara) const override; + virtual void SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet) override; + virtual void RemoveAttribs(const ESelection& rSelection) override; + virtual void GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const override; + + virtual SfxItemState GetItemState(const ESelection& rSel, sal_uInt16 nWhich) const override; + virtual SfxItemState GetItemState(sal_Int32 nPara, sal_uInt16 nWhich) const override; + + virtual void QuickInsertText(const OUString& rText, const ESelection& rSel) override; + virtual void QuickInsertField(const SvxFieldItem& rFld, const ESelection& rSel) override; + virtual void QuickSetAttribs(const SfxItemSet& rSet, const ESelection& rSel) override; + virtual void QuickInsertLineBreak(const ESelection& rSel) override; + + virtual SfxItemPool* GetPool() const override; + + virtual OUString CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, sal_Int32 nPos, + std::optional<Color>& rpTxtColor, + std::optional<Color>& rpFldColor) override; + virtual void FieldClicked(const SvxFieldItem&) override; + virtual bool IsValid() const override; + + virtual LanguageType GetLanguage(sal_Int32, sal_Int32) const override; + virtual sal_Int32 GetFieldCount(sal_Int32 nPara) const override; + virtual EFieldInfo GetFieldInfo(sal_Int32 nPara, sal_uInt16 nField) const override; + virtual EBulletInfo GetBulletInfo(sal_Int32 nPara) const override; + virtual tools::Rectangle GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const override; + virtual tools::Rectangle GetParaBounds(sal_Int32 nPara) const override; + virtual MapMode GetMapMode() const override; + virtual OutputDevice* GetRefDevice() const override; + virtual bool GetIndexAtPoint(const Point&, sal_Int32& nPara, sal_Int32& nIndex) const override; + virtual bool GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart, + sal_Int32& nEnd) const override; + virtual bool GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex, sal_Int32 nPara, + sal_Int32 nIndex, bool bInCell = false) const override; + virtual sal_Int32 GetLineCount(sal_Int32 nPara) const override; + virtual sal_Int32 GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const override; + virtual void GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd, + sal_Int32 nParagraph, sal_Int32 nLine) const override; + virtual sal_Int32 GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nLine) const override; + virtual bool Delete(const ESelection&) override; + virtual bool InsertText(const OUString&, const ESelection&) override; + virtual bool QuickFormatDoc(bool bFull = false) override; + + virtual sal_Int16 GetDepth(sal_Int32 nPara) const override; + virtual bool SetDepth(sal_Int32 nPara, sal_Int16 nNewDepth) override; + + virtual const SfxItemSet* GetEmptyItemSetPtr() override; + // implementation functions for XParagraphAppend and XTextPortionAppend + virtual void AppendParagraph() override; + virtual sal_Int32 AppendTextPortion(sal_Int32 nPara, const OUString& rText, + const SfxItemSet& rSet) override; + + virtual void CopyText(const SvxTextForwarder& rSource) override; +}; + +/* analog to SvxEditEngineViewForwarder */ +class WeldEditViewForwarder : public SvxEditViewForwarder +{ + WeldEditAccessible& m_rEditAcc; + + WeldEditViewForwarder(const WeldEditViewForwarder&) = delete; + WeldEditViewForwarder& operator=(const WeldEditViewForwarder&) = delete; + +public: + explicit WeldEditViewForwarder(WeldEditAccessible& rAcc); + + virtual bool IsValid() const override; + + virtual Point LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const override; + virtual Point PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const override; + + virtual bool GetSelection(ESelection& rSelection) const override; + virtual bool SetSelection(const ESelection& rSelection) override; + virtual bool Copy() override; + virtual bool Cut() override; + virtual bool Paste() override; +}; + +class WeldEditSource : public SvxEditSource +{ + SfxBroadcaster m_aBroadCaster; + WeldViewForwarder m_aViewFwd; + WeldTextForwarder m_aTextFwd; + WeldEditViewForwarder m_aEditViewFwd; + WeldEditAccessible& m_rEditAcc; + + WeldEditSource(const WeldEditSource& rSrc) + : SvxEditSource() + , m_aViewFwd(rSrc.m_rEditAcc) + , m_aTextFwd(rSrc.m_rEditAcc, *this) + , m_aEditViewFwd(rSrc.m_rEditAcc) + , m_rEditAcc(rSrc.m_rEditAcc) + { + } + + WeldEditSource& operator=(const WeldEditSource&) = delete; + +public: + WeldEditSource(WeldEditAccessible& rAcc) + : m_aViewFwd(rAcc) + , m_aTextFwd(rAcc, *this) + , m_aEditViewFwd(rAcc) + , m_rEditAcc(rAcc) + { + } + + virtual std::unique_ptr<SvxEditSource> Clone() const override + { + return std::unique_ptr<SvxEditSource>(new WeldEditSource(*this)); + } + + virtual SvxTextForwarder* GetTextForwarder() override { return &m_aTextFwd; } + + virtual SvxViewForwarder* GetViewForwarder() override { return &m_aViewFwd; } + + virtual SvxEditViewForwarder* GetEditViewForwarder(bool /*bCreate*/) override + { + return &m_aEditViewFwd; + } + + virtual void UpdateData() override + { + // would possibly only by needed if the XText interface is implemented + // and its text needs to be updated. + } + virtual SfxBroadcaster& GetBroadcaster() const override + { + return const_cast<WeldEditSource*>(this)->m_aBroadCaster; + } +}; +} + +typedef cppu::WeakImplHelper< + css::accessibility::XAccessible, css::accessibility::XAccessibleComponent, + css::accessibility::XAccessibleContext, css::accessibility::XAccessibleEventBroadcaster> + WeldEditAccessibleBaseClass; + +class WeldEditAccessible : public WeldEditAccessibleBaseClass +{ + weld::CustomWidgetController* m_pController; + EditEngine* m_pEditEngine; + EditView* m_pEditView; + std::unique_ptr<::accessibility::AccessibleTextHelper> m_xTextHelper; + +public: + WeldEditAccessible(weld::CustomWidgetController* pController) + : m_pController(pController) + , m_pEditEngine(nullptr) + , m_pEditView(nullptr) + { + } + + ::accessibility::AccessibleTextHelper* GetTextHelper() { return m_xTextHelper.get(); } + + void Init(EditEngine* pEditEngine, EditView* pEditView) + { + m_pEditEngine = pEditEngine; + m_pEditView = pEditView; + m_xTextHelper.reset( + new ::accessibility::AccessibleTextHelper(std::make_unique<WeldEditSource>(*this))); + m_xTextHelper->SetEventSource(this); + } + + EditEngine* GetEditEngine() { return m_pEditEngine; } + EditView* GetEditView() { return m_pEditView; } + + void ClearWin() + { + // remove handler before current object gets destroyed + // (avoid handler being called for already dead object) + m_pEditEngine->SetNotifyHdl(Link<EENotify&, void>()); + + m_pEditEngine = nullptr; + m_pEditView = nullptr; + m_pController = nullptr; // implicitly results in AccessibleStateType::DEFUNC set + + //! make TextHelper implicitly release C++ references to some core objects + m_xTextHelper->SetEditSource(::std::unique_ptr<SvxEditSource>()); + + //! make TextHelper release references + //! (e.g. the one set by the 'SetEventSource' call) + m_xTextHelper->Dispose(); + m_xTextHelper.reset(); + } + + // XAccessible + virtual css::uno::Reference<css::accessibility::XAccessibleContext> + SAL_CALL getAccessibleContext() override + { + return this; + } + + // XAccessibleComponent + virtual sal_Bool SAL_CALL containsPoint(const css::awt::Point& rPoint) override + { + //! the arguments coordinates are relative to the current window ! + //! Thus the top left-point is (0, 0) + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + Size aSz(m_pController->GetOutputSizePixel()); + return rPoint.X >= 0 && rPoint.Y >= 0 && rPoint.X < aSz.Width() && rPoint.Y < aSz.Height(); + } + + virtual css::uno::Reference<css::accessibility::XAccessible> + SAL_CALL getAccessibleAtPoint(const css::awt::Point& rPoint) override + { + SolarMutexGuard aGuard; + if (!m_xTextHelper) + throw css::uno::RuntimeException(); + + return m_xTextHelper->GetAt(rPoint); + } + + virtual css::awt::Rectangle SAL_CALL getBounds() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + const Point aOutPos; + const Size aOutSize(m_pController->GetOutputSizePixel()); + css::awt::Rectangle aRet; + + aRet.X = aOutPos.X(); + aRet.Y = aOutPos.Y(); + aRet.Width = aOutSize.Width(); + aRet.Height = aOutSize.Height(); + + return aRet; + } + + virtual css::awt::Point SAL_CALL getLocation() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + const css::awt::Rectangle aRect(getBounds()); + css::awt::Point aRet; + + aRet.X = aRect.X; + aRet.Y = aRect.Y; + + return aRet; + } + + virtual css::awt::Point SAL_CALL getLocationOnScreen() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + css::awt::Point aScreenLoc(0, 0); + + css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent()); + if (xParent) + { + css::uno::Reference<css::accessibility::XAccessibleContext> xParentContext( + xParent->getAccessibleContext()); + css::uno::Reference<css::accessibility::XAccessibleComponent> xParentComponent( + xParentContext, css::uno::UNO_QUERY); + OSL_ENSURE(xParentComponent.is(), + "WeldEditAccessible::getLocationOnScreen: no parent component!"); + if (xParentComponent.is()) + { + css::awt::Point aParentScreenLoc(xParentComponent->getLocationOnScreen()); + css::awt::Point aOwnRelativeLoc(getLocation()); + aScreenLoc.X = aParentScreenLoc.X + aOwnRelativeLoc.X; + aScreenLoc.Y = aParentScreenLoc.Y + aOwnRelativeLoc.Y; + } + } + + return aScreenLoc; + } + + virtual css::awt::Size SAL_CALL getSize() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + Size aSz(m_pController->GetOutputSizePixel()); + return css::awt::Size(aSz.Width(), aSz.Height()); + } + + virtual void SAL_CALL grabFocus() override { m_pController->GrabFocus(); } + + virtual sal_Int32 SAL_CALL getForeground() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + Color nCol = m_pEditEngine->GetAutoColor(); + return static_cast<sal_Int32>(nCol); + } + + virtual sal_Int32 SAL_CALL getBackground() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + Color nCol = m_pEditEngine->GetBackgroundColor(); + return static_cast<sal_Int32>(nCol); + } + + // XAccessibleContext + virtual sal_Int32 SAL_CALL getAccessibleChildCount() override + { + if (m_xTextHelper) + return m_xTextHelper->GetChildCount(); + return 0; + } + + virtual css::uno::Reference<css::accessibility::XAccessible> + SAL_CALL getAccessibleChild(sal_Int32 i) override + { + if (m_xTextHelper) + return m_xTextHelper->GetChild(i); + throw css::lang::IndexOutOfBoundsException(); // there is no child... + } + + virtual css::uno::Reference<css::accessibility::XAccessible> + SAL_CALL getAccessibleParent() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + return m_pController->GetDrawingArea()->get_accessible_parent(); + } + + virtual sal_Int32 SAL_CALL getAccessibleIndexInParent() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + // -1 for child not found/no parent (according to specification) + sal_Int32 nRet = -1; + + css::uno::Reference<css::accessibility::XAccessible> xParent(getAccessibleParent()); + if (!xParent) + return nRet; + + try + { + css::uno::Reference<css::accessibility::XAccessibleContext> xParentContext( + xParent->getAccessibleContext()); + + // iterate over parent's children and search for this object + if (xParentContext.is()) + { + sal_Int32 nChildCount = xParentContext->getAccessibleChildCount(); + for (sal_Int32 nChild = 0; (nChild < nChildCount) && (-1 == nRet); ++nChild) + { + css::uno::Reference<css::accessibility::XAccessible> xChild( + xParentContext->getAccessibleChild(nChild)); + if (xChild.get() == this) + nRet = nChild; + } + } + } + catch (const css::uno::Exception&) + { + TOOLS_WARN_EXCEPTION("svx", "WeldEditAccessible::getAccessibleIndexInParent"); + } + + return nRet; + } + + virtual sal_Int16 SAL_CALL getAccessibleRole() override + { + return css::accessibility::AccessibleRole::TEXT_FRAME; + } + + virtual OUString SAL_CALL getAccessibleDescription() override + { + SolarMutexGuard aGuard; + + OUString aRet; + + if (m_pController) + { + aRet = m_pController->GetAccessibleDescription(); + } + + return aRet; + } + + virtual OUString SAL_CALL getAccessibleName() override + { + SolarMutexGuard aGuard; + + OUString aRet; + + if (m_pController) + { + aRet = m_pController->GetAccessibleName(); + } + + return aRet; + } + + virtual css::uno::Reference<css::accessibility::XAccessibleRelationSet> + SAL_CALL getAccessibleRelationSet() override + { + SolarMutexGuard aGuard; + if (!m_pController) + throw css::uno::RuntimeException(); + + return m_pController->GetDrawingArea()->get_accessible_relation_set(); + } + + virtual css::uno::Reference<css::accessibility::XAccessibleStateSet> + SAL_CALL getAccessibleStateSet() override + { + SolarMutexGuard aGuard; + ::utl::AccessibleStateSetHelper* pStateSet = new ::utl::AccessibleStateSetHelper; + + css::uno::Reference<css::accessibility::XAccessibleStateSet> xStateSet(pStateSet); + + if (!m_pController || !m_xTextHelper) + pStateSet->AddState(css::accessibility::AccessibleStateType::DEFUNC); + else + { + pStateSet->AddState(css::accessibility::AccessibleStateType::MULTI_LINE); + pStateSet->AddState(css::accessibility::AccessibleStateType::ENABLED); + pStateSet->AddState(css::accessibility::AccessibleStateType::EDITABLE); + pStateSet->AddState(css::accessibility::AccessibleStateType::FOCUSABLE); + pStateSet->AddState(css::accessibility::AccessibleStateType::SELECTABLE); + if (m_pController->HasFocus()) + pStateSet->AddState(css::accessibility::AccessibleStateType::FOCUSED); + if (m_pController->IsActive()) + pStateSet->AddState(css::accessibility::AccessibleStateType::ACTIVE); + if (m_pController->IsVisible()) + pStateSet->AddState(css::accessibility::AccessibleStateType::SHOWING); + if (m_pController->IsReallyVisible()) + pStateSet->AddState(css::accessibility::AccessibleStateType::VISIBLE); + if (COL_TRANSPARENT != m_pEditEngine->GetBackgroundColor()) + pStateSet->AddState(css::accessibility::AccessibleStateType::OPAQUE); + } + + return xStateSet; + } + + virtual css::lang::Locale SAL_CALL getLocale() override + { + SolarMutexGuard aGuard; + return LanguageTag(m_pEditEngine->GetDefaultLanguage()).getLocale(); + } + + // XAccessibleEventBroadcaster + virtual void SAL_CALL addAccessibleEventListener( + const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override + { + if (!m_xTextHelper) // not disposing (about to destroy view shell) + return; + m_xTextHelper->AddEventListener(rListener); + } + + virtual void SAL_CALL removeAccessibleEventListener( + const css::uno::Reference<css::accessibility::XAccessibleEventListener>& rListener) override + { + if (!m_xTextHelper) // not disposing (about to destroy view shell) + return; + m_xTextHelper->RemoveEventListener(rListener); + } +}; + +css::uno::Reference<css::accessibility::XAccessible> WeldEditView::CreateAccessible() +{ + if (!m_xAccessible.is()) + m_xAccessible.set(new WeldEditAccessible(this)); + return css::uno::Reference<css::accessibility::XAccessible>(m_xAccessible.get()); +} + +WeldEditView::~WeldEditView() +{ + if (m_xAccessible.is()) + { + m_xAccessible->ClearWin(); // make Accessible nonfunctional + m_xAccessible.clear(); + } +} + +bool WeldViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; } + +Point WeldViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const +{ + EditView* pEditView = m_rEditAcc.GetEditView(); + OutputDevice* pOutDev = pEditView ? pEditView->GetWindow() : nullptr; + + if (pOutDev) + { + MapMode aMapMode(pOutDev->GetMapMode()); + Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit()))); + aMapMode.SetOrigin(Point()); + return pOutDev->LogicToPixel(aPoint, aMapMode); + } + + return Point(); +} + +Point WeldViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const +{ + EditView* pEditView = m_rEditAcc.GetEditView(); + OutputDevice* pOutDev = pEditView ? pEditView->GetWindow() : nullptr; + + if (pOutDev) + { + MapMode aMapMode(pOutDev->GetMapMode()); + aMapMode.SetOrigin(Point()); + Point aPoint(pOutDev->PixelToLogic(rPoint, aMapMode)); + return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode); + } + + return Point(); +} + +WeldTextForwarder::WeldTextForwarder(WeldEditAccessible& rAcc, WeldEditSource& rSource) + : m_rEditAcc(rAcc) + , m_rEditSource(rSource) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->SetNotifyHdl(LINK(this, WeldTextForwarder, NotifyHdl)); +} + +WeldTextForwarder::~WeldTextForwarder() +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->SetNotifyHdl(Link<EENotify&, void>()); +} + +IMPL_LINK(WeldTextForwarder, NotifyHdl, EENotify&, rNotify, void) +{ + ::std::unique_ptr<SfxHint> aHint = SvxEditSourceHelper::EENotification2Hint(&rNotify); + if (aHint) + m_rEditSource.GetBroadcaster().Broadcast(*aHint); +} + +sal_Int32 WeldTextForwarder::GetParagraphCount() const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetParagraphCount() : 0; +} + +sal_Int32 WeldTextForwarder::GetTextLen(sal_Int32 nParagraph) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetTextLen(nParagraph) : 0; +} + +OUString WeldTextForwarder::GetText(const ESelection& rSel) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + OUString aRet; + if (pEditEngine) + aRet = pEditEngine->GetText(rSel); + return convertLineEnd(aRet, GetSystemLineEnd()); +} + +SfxItemSet WeldTextForwarder::GetAttribs(const ESelection& rSel, + EditEngineAttribs nOnlyHardAttrib) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + assert(pEditEngine && "EditEngine missing"); + if (rSel.nStartPara == rSel.nEndPara) + { + GetAttribsFlags nFlags = GetAttribsFlags::NONE; + switch (nOnlyHardAttrib) + { + case EditEngineAttribs::All: + nFlags = GetAttribsFlags::ALL; + break; + case EditEngineAttribs::OnlyHard: + nFlags = GetAttribsFlags::CHARATTRIBS; + break; + default: + SAL_WARN("svx", "unknown flags for WeldTextForwarder::GetAttribs"); + } + + return pEditEngine->GetAttribs(rSel.nStartPara, rSel.nStartPos, rSel.nEndPos, nFlags); + } + else + { + return pEditEngine->GetAttribs(rSel, nOnlyHardAttrib); + } +} + +SfxItemSet WeldTextForwarder::GetParaAttribs(sal_Int32 nPara) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + assert(pEditEngine && "EditEngine missing"); + + SfxItemSet aSet(pEditEngine->GetParaAttribs(nPara)); + + sal_uInt16 nWhich = EE_PARA_START; + while (nWhich <= EE_PARA_END) + { + if (aSet.GetItemState(nWhich) != SfxItemState::SET) + { + if (pEditEngine->HasParaAttrib(nPara, nWhich)) + aSet.Put(pEditEngine->GetParaAttrib(nPara, nWhich)); + } + nWhich++; + } + + return aSet; +} + +void WeldTextForwarder::SetParaAttribs(sal_Int32 nPara, const SfxItemSet& rSet) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->SetParaAttribs(nPara, rSet); +} + +SfxItemPool* WeldTextForwarder::GetPool() const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetEmptyItemSet().GetPool() : nullptr; +} + +void WeldTextForwarder::RemoveAttribs(const ESelection& rSelection) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->RemoveAttribs(rSelection, false /*bRemoveParaAttribs*/, 0); +} + +void WeldTextForwarder::GetPortions(sal_Int32 nPara, std::vector<sal_Int32>& rList) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->GetPortions(nPara, rList); +} + +void WeldTextForwarder::QuickInsertText(const OUString& rText, const ESelection& rSel) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->QuickInsertText(rText, rSel); +} + +void WeldTextForwarder::QuickInsertLineBreak(const ESelection& rSel) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->QuickInsertLineBreak(rSel); +} + +void WeldTextForwarder::QuickInsertField(const SvxFieldItem& rFld, const ESelection& rSel) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->QuickInsertField(rFld, rSel); +} + +void WeldTextForwarder::QuickSetAttribs(const SfxItemSet& rSet, const ESelection& rSel) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->QuickSetAttribs(rSet, rSel); +} + +bool WeldTextForwarder::IsValid() const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + // cannot reliably query EditEngine state + // while in the middle of an update + return pEditEngine && pEditEngine->GetUpdateMode(); +} + +OUString WeldTextForwarder::CalcFieldValue(const SvxFieldItem& rField, sal_Int32 nPara, + sal_Int32 nPos, std::optional<Color>& rpTxtColor, + std::optional<Color>& rpFldColor) +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->CalcFieldValue(rField, nPara, nPos, rpTxtColor, rpFldColor) + : OUString(); +} + +void WeldTextForwarder::FieldClicked(const SvxFieldItem&) {} + +static SfxItemState GetSvxEditEngineItemState(EditEngine const& rEditEngine, const ESelection& rSel, + sal_uInt16 nWhich) +{ + std::vector<EECharAttrib> aAttribs; + + const SfxPoolItem* pLastItem = nullptr; + + SfxItemState eState = SfxItemState::DEFAULT; + + // check all paragraphs inside the selection + for (sal_Int32 nPara = rSel.nStartPara; nPara <= rSel.nEndPara; nPara++) + { + SfxItemState eParaState = SfxItemState::DEFAULT; + + // calculate start and endpos for this paragraph + sal_Int32 nPos = 0; + if (rSel.nStartPara == nPara) + nPos = rSel.nStartPos; + + sal_Int32 nEndPos = rSel.nEndPos; + if (rSel.nEndPara != nPara) + nEndPos = rEditEngine.GetTextLen(nPara); + + // get list of char attribs + rEditEngine.GetCharAttribs(nPara, aAttribs); + + bool bEmpty = true; // we found no item inside the selection of this paragraph + bool bGaps = false; // we found items but there are gaps between them + sal_Int32 nLastEnd = nPos; + + const SfxPoolItem* pParaItem = nullptr; + + for (const auto& rAttrib : aAttribs) + { + OSL_ENSURE(rAttrib.pAttr, "GetCharAttribs gives corrupt data"); + + const bool bEmptyPortion = (rAttrib.nStart == rAttrib.nEnd); + if ((!bEmptyPortion && (rAttrib.nStart >= nEndPos)) + || (bEmptyPortion && (rAttrib.nStart > nEndPos))) + break; // break if we are already behind our selection + + if ((!bEmptyPortion && (rAttrib.nEnd <= nPos)) + || (bEmptyPortion && (rAttrib.nEnd < nPos))) + continue; // or if the attribute ends before our selection + + if (rAttrib.pAttr->Which() != nWhich) + continue; // skip if is not the searched item + + // if we already found an item + if (pParaItem) + { + // ... and its different to this one than the state is don't care + if (*pParaItem != *(rAttrib.pAttr)) + return SfxItemState::DONTCARE; + } + else + { + pParaItem = rAttrib.pAttr; + } + + if (bEmpty) + bEmpty = false; + + if (!bGaps && rAttrib.nStart > nLastEnd) + bGaps = true; + + nLastEnd = rAttrib.nEnd; + } + + if (!bEmpty && !bGaps && nLastEnd < (nEndPos - 1)) + bGaps = true; + if (bEmpty) + eParaState = SfxItemState::DEFAULT; + else if (bGaps) + eParaState = SfxItemState::DONTCARE; + else + eParaState = SfxItemState::SET; + + // if we already found an item check if we found the same + if (pLastItem) + { + if ((pParaItem == nullptr) || (*pLastItem != *pParaItem)) + return SfxItemState::DONTCARE; + } + else + { + pLastItem = pParaItem; + eState = eParaState; + } + } + + return eState; +} + +SfxItemState WeldTextForwarder::GetItemState(const ESelection& rSel, sal_uInt16 nWhich) const +{ + SfxItemState nState = SfxItemState::DISABLED; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + nState = GetSvxEditEngineItemState(*pEditEngine, rSel, nWhich); + return nState; +} + +SfxItemState WeldTextForwarder::GetItemState(sal_Int32 nPara, sal_uInt16 nWhich) const +{ + SfxItemState nState = SfxItemState::DISABLED; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + const SfxItemSet& rSet = pEditEngine->GetParaAttribs(nPara); + nState = rSet.GetItemState(nWhich); + } + return nState; +} + +LanguageType WeldTextForwarder::GetLanguage(sal_Int32 nPara, sal_Int32 nIndex) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetLanguage(nPara, nIndex) : LANGUAGE_NONE; +} + +sal_Int32 WeldTextForwarder::GetFieldCount(sal_Int32 nPara) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetFieldCount(nPara) : 0; +} + +EFieldInfo WeldTextForwarder::GetFieldInfo(sal_Int32 nPara, sal_uInt16 nField) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetFieldInfo(nPara, nField) : EFieldInfo(); +} + +EBulletInfo WeldTextForwarder::GetBulletInfo(sal_Int32 /*nPara*/) const { return EBulletInfo(); } + +tools::Rectangle WeldTextForwarder::GetCharBounds(sal_Int32 nPara, sal_Int32 nIndex) const +{ + tools::Rectangle aRect(0, 0, 0, 0); + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + + if (pEditEngine) + { + // Handle virtual position one-past-the end of the string + if (nIndex >= pEditEngine->GetTextLen(nPara)) + { + if (nIndex) + aRect = pEditEngine->GetCharacterBounds(EPosition(nPara, nIndex - 1)); + + aRect.Move(aRect.Right() - aRect.Left(), 0); + aRect.SetSize(Size(1, pEditEngine->GetTextHeight())); + } + else + { + aRect = pEditEngine->GetCharacterBounds(EPosition(nPara, nIndex)); + } + } + return aRect; +} + +tools::Rectangle WeldTextForwarder::GetParaBounds(sal_Int32 nPara) const +{ + tools::Rectangle aRect(0, 0, 0, 0); + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + + if (pEditEngine) + { + const Point aPnt = pEditEngine->GetDocPosTopLeft(nPara); + const sal_Int32 nWidth = pEditEngine->CalcTextWidth(); + const sal_Int32 nHeight = pEditEngine->GetTextHeight(nPara); + aRect = tools::Rectangle(aPnt.X(), aPnt.Y(), aPnt.X() + nWidth, aPnt.Y() + nHeight); + } + + return aRect; +} + +MapMode WeldTextForwarder::GetMapMode() const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetRefMapMode() : MapMode(MapUnit::Map100thMM); +} + +OutputDevice* WeldTextForwarder::GetRefDevice() const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetRefDevice() : nullptr; +} + +bool WeldTextForwarder::GetIndexAtPoint(const Point& rPos, sal_Int32& nPara, + sal_Int32& nIndex) const +{ + bool bRes = false; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + EPosition aDocPos = pEditEngine->FindDocPosition(rPos); + nPara = aDocPos.nPara; + nIndex = aDocPos.nIndex; + bRes = true; + } + return bRes; +} + +bool WeldTextForwarder::GetWordIndices(sal_Int32 nPara, sal_Int32 nIndex, sal_Int32& nStart, + sal_Int32& nEnd) const +{ + bool bRes = false; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + ESelection aRes = pEditEngine->GetWord(ESelection(nPara, nIndex, nPara, nIndex), + css::i18n::WordType::DICTIONARY_WORD); + + if (aRes.nStartPara == nPara && aRes.nStartPara == aRes.nEndPara) + { + nStart = aRes.nStartPos; + nEnd = aRes.nEndPos; + + bRes = true; + } + } + + return bRes; +} + +bool WeldTextForwarder::GetAttributeRun(sal_Int32& nStartIndex, sal_Int32& nEndIndex, + sal_Int32 nPara, sal_Int32 nIndex, bool bInCell) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (!pEditEngine) + return false; + SvxEditSourceHelper::GetAttributeRun(nStartIndex, nEndIndex, *pEditEngine, nPara, nIndex, + bInCell); + return true; +} + +sal_Int32 WeldTextForwarder::GetLineCount(sal_Int32 nPara) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetLineCount(nPara) : 0; +} + +sal_Int32 WeldTextForwarder::GetLineLen(sal_Int32 nPara, sal_Int32 nLine) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetLineLen(nPara, nLine) : 0; +} + +void WeldTextForwarder::GetLineBoundaries(/*out*/ sal_Int32& rStart, /*out*/ sal_Int32& rEnd, + sal_Int32 nPara, sal_Int32 nLine) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + pEditEngine->GetLineBoundaries(rStart, rEnd, nPara, nLine); + else + rStart = rEnd = 0; +} + +sal_Int32 WeldTextForwarder::GetLineNumberAtIndex(sal_Int32 nPara, sal_Int32 nIndex) const +{ + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + return pEditEngine ? pEditEngine->GetLineNumberAtIndex(nPara, nIndex) : 0; +} + +bool WeldTextForwarder::QuickFormatDoc(bool /*bFull*/) +{ + bool bRes = false; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + pEditEngine->QuickFormatDoc(); + bRes = true; + } + return bRes; +} + +sal_Int16 WeldTextForwarder::GetDepth(sal_Int32 /*nPara*/) const +{ + // math has no outliner... + return -1; +} + +bool WeldTextForwarder::SetDepth(sal_Int32 /*nPara*/, sal_Int16 nNewDepth) +{ + // math has no outliner... + return -1 == nNewDepth; // is it the value from 'GetDepth' ? +} + +bool WeldTextForwarder::Delete(const ESelection& rSelection) +{ + bool bRes = false; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + pEditEngine->QuickDelete(rSelection); + pEditEngine->QuickFormatDoc(); + bRes = true; + } + return bRes; +} + +bool WeldTextForwarder::InsertText(const OUString& rStr, const ESelection& rSelection) +{ + bool bRes = false; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + pEditEngine->QuickInsertText(rStr, rSelection); + pEditEngine->QuickFormatDoc(); + bRes = true; + } + return bRes; +} + +const SfxItemSet* WeldTextForwarder::GetEmptyItemSetPtr() +{ + const SfxItemSet* pItemSet = nullptr; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + pItemSet = &pEditEngine->GetEmptyItemSet(); + } + return pItemSet; +} + +void WeldTextForwarder::AppendParagraph() +{ + // append an empty paragraph + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine) + { + sal_Int32 nParaCount = pEditEngine->GetParagraphCount(); + pEditEngine->InsertParagraph(nParaCount, OUString()); + } +} + +sal_Int32 WeldTextForwarder::AppendTextPortion(sal_Int32 nPara, const OUString& rText, + const SfxItemSet& rSet) +{ + sal_uInt16 nRes = 0; + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine && nPara < pEditEngine->GetParagraphCount()) + { + // append text + ESelection aSel(nPara, pEditEngine->GetTextLen(nPara)); + pEditEngine->QuickInsertText(rText, aSel); + + // set attributes for new appended text + nRes = aSel.nEndPos = pEditEngine->GetTextLen(nPara); + pEditEngine->QuickSetAttribs(rSet, aSel); + } + return nRes; +} + +void WeldTextForwarder::CopyText(const SvxTextForwarder& rSource) +{ + const WeldTextForwarder* pSourceForwarder = dynamic_cast<const WeldTextForwarder*>(&rSource); + if (!pSourceForwarder) + return; + EditEngine* pSourceEditEngine = pSourceForwarder->m_rEditAcc.GetEditEngine(); + EditEngine* pEditEngine = m_rEditAcc.GetEditEngine(); + if (pEditEngine && pSourceEditEngine) + { + std::unique_ptr<EditTextObject> pNewTextObject = pSourceEditEngine->CreateTextObject(); + pEditEngine->SetText(*pNewTextObject); + } +} + +WeldEditViewForwarder::WeldEditViewForwarder(WeldEditAccessible& rAcc) + : m_rEditAcc(rAcc) +{ +} + +bool WeldEditViewForwarder::IsValid() const { return m_rEditAcc.GetEditView() != nullptr; } + +Point WeldEditViewForwarder::LogicToPixel(const Point& rPoint, const MapMode& rMapMode) const +{ + EditView* pEditView = m_rEditAcc.GetEditView(); + OutputDevice* pOutDev = pEditView ? pEditView->GetWindow() : nullptr; + + if (pOutDev) + { + MapMode aMapMode(pOutDev->GetMapMode()); + Point aPoint(OutputDevice::LogicToLogic(rPoint, rMapMode, MapMode(aMapMode.GetMapUnit()))); + aMapMode.SetOrigin(Point()); + return pOutDev->LogicToPixel(aPoint, aMapMode); + } + + return Point(); +} + +Point WeldEditViewForwarder::PixelToLogic(const Point& rPoint, const MapMode& rMapMode) const +{ + EditView* pEditView = m_rEditAcc.GetEditView(); + OutputDevice* pOutDev = pEditView ? pEditView->GetWindow() : nullptr; + + if (pOutDev) + { + MapMode aMapMode(pOutDev->GetMapMode()); + aMapMode.SetOrigin(Point()); + Point aPoint(pOutDev->PixelToLogic(rPoint, aMapMode)); + return OutputDevice::LogicToLogic(aPoint, MapMode(aMapMode.GetMapUnit()), rMapMode); + } + + return Point(); +} + +bool WeldEditViewForwarder::GetSelection(ESelection& rSelection) const +{ + bool bRes = false; + EditView* pEditView = m_rEditAcc.GetEditView(); + if (pEditView) + { + rSelection = pEditView->GetSelection(); + bRes = true; + } + return bRes; +} + +bool WeldEditViewForwarder::SetSelection(const ESelection& rSelection) +{ + bool bRes = false; + EditView* pEditView = m_rEditAcc.GetEditView(); + if (pEditView) + { + pEditView->SetSelection(rSelection); + bRes = true; + } + return bRes; +} + +bool WeldEditViewForwarder::Copy() +{ + bool bRes = false; + EditView* pEditView = m_rEditAcc.GetEditView(); + if (pEditView) + { + pEditView->Copy(); + bRes = true; + } + return bRes; +} + +bool WeldEditViewForwarder::Cut() +{ + bool bRes = false; + EditView* pEditView = m_rEditAcc.GetEditView(); + if (pEditView) + { + pEditView->Cut(); + bRes = true; + } + return bRes; +} + +bool WeldEditViewForwarder::Paste() +{ + bool bRes = false; + EditView* pEditView = m_rEditAcc.GetEditView(); + if (pEditView) + { + pEditView->Paste(); + bRes = true; + } + return bRes; +} + +void WeldEditView::SetDrawingArea(weld::DrawingArea* pDrawingArea) +{ + Size aSize(pDrawingArea->get_size_request()); + if (aSize.Width() == -1) + aSize.setWidth(500); + if (aSize.Height() == -1) + aSize.setHeight(100); + pDrawingArea->set_size_request(aSize.Width(), aSize.Height()); + + SetOutputSizePixel(aSize); + + weld::CustomWidgetController::SetDrawingArea(pDrawingArea); + + EnableRTL(false); + + const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings(); + Color aBgColor = rStyleSettings.GetWindowColor(); + + OutputDevice& rDevice = pDrawingArea->get_ref_device(); + + rDevice.SetMapMode(MapMode(MapUnit::MapTwip)); + rDevice.SetBackground(aBgColor); + + Size aOutputSize(rDevice.PixelToLogic(aSize)); + aSize = aOutputSize; + aSize.setHeight(aSize.Height()); + + makeEditEngine(); + m_xEditEngine->SetPaperSize(aSize); + m_xEditEngine->SetRefDevice(&rDevice); + + m_xEditEngine->SetControlWord(m_xEditEngine->GetControlWord() | EEControlBits::MARKFIELDS); + + m_xEditView.reset(new EditView(m_xEditEngine.get(), nullptr)); + m_xEditView->setEditViewCallbacks(this); + m_xEditView->SetOutputArea(tools::Rectangle(Point(0, 0), aOutputSize)); + + m_xEditView->SetBackgroundColor(aBgColor); + m_xEditEngine->InsertView(m_xEditView.get()); + + pDrawingArea->set_cursor(PointerStyle::Text); + + if (m_xAccessible.is()) + m_xAccessible->Init(m_xEditEngine.get(), m_xEditView.get()); +} + +int WeldEditView::GetSurroundingText(OUString& rSurrounding) +{ + rSurrounding = m_xEditView->GetSurroundingText(); + return m_xEditView->GetSurroundingTextSelection().Min(); +} + +bool WeldEditView::DeleteSurroundingText(const Selection& rRange) +{ + bool bRes(false); + EditEngine* pEditEngine = m_xEditView->GetEditEngine(); + if (pEditEngine) + { + ESelection aSel(m_xEditView->GetSelection()); + aSel.nEndPara = aSel.nStartPara; + aSel.nStartPos = rRange.Min(); + aSel.nEndPos = rRange.Max(); + pEditEngine->QuickDelete(aSel); + pEditEngine->QuickFormatDoc(); + bRes = true; + } + return bRes; +} + +void WeldEditView::GetFocus() +{ + m_xEditView->ShowCursor(); + + weld::CustomWidgetController::GetFocus(); + + if (m_xAccessible.is()) + { + // Note: will implicitly send the AccessibleStateType::FOCUSED event + ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper(); + if (pHelper) + pHelper->SetFocus(); + } +} + +void WeldEditView::LoseFocus() +{ + weld::CustomWidgetController::LoseFocus(); + Invalidate(); // redraw without cursor + + if (m_xAccessible.is()) + { + // Note: will implicitly send the AccessibleStateType::FOCUSED event + ::accessibility::AccessibleTextHelper* pHelper = m_xAccessible->GetTextHelper(); + if (pHelper) + pHelper->SetFocus(false); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |