From 940b4d1848e8c70ab7642901a68594e8016caffc Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 18:51:28 +0200 Subject: Adding upstream version 1:7.0.4. Signed-off-by: Daniel Baumann --- vcl/source/app/ITiledRenderable.cxx | 81 + vcl/source/app/IconThemeInfo.cxx | 188 + vcl/source/app/IconThemeScanner.cxx | 215 ++ vcl/source/app/IconThemeSelector.cxx | 175 + vcl/source/app/brand.cxx | 73 + vcl/source/app/customweld.cxx | 105 + vcl/source/app/dbggui.cxx | 50 + vcl/source/app/dndhelp.cxx | 139 + vcl/source/app/help.cxx | 677 ++++ vcl/source/app/i18nhelp.cxx | 160 + vcl/source/app/idle.cxx | 65 + vcl/source/app/salplug.cxx | 355 ++ vcl/source/app/salusereventlist.cxx | 171 + vcl/source/app/salvtables.cxx | 6777 ++++++++++++++++++++++++++++++++++ vcl/source/app/scheduler.cxx | 659 ++++ vcl/source/app/session.cxx | 414 +++ vcl/source/app/settings.cxx | 3233 ++++++++++++++++ vcl/source/app/sound.cxx | 38 + vcl/source/app/stdtext.cxx | 124 + vcl/source/app/svapp.cxx | 1707 +++++++++ vcl/source/app/svdata.cxx | 491 +++ vcl/source/app/svmain.cxx | 684 ++++ vcl/source/app/timer.cxx | 102 + vcl/source/app/unohelp.cxx | 233 ++ vcl/source/app/unohelp2.cxx | 98 + vcl/source/app/vclevent.cxx | 104 + vcl/source/app/watchdog.cxx | 165 + vcl/source/app/weldutils.cxx | 129 + vcl/source/app/winscheduler.cxx | 46 + 29 files changed, 17458 insertions(+) create mode 100644 vcl/source/app/ITiledRenderable.cxx create mode 100644 vcl/source/app/IconThemeInfo.cxx create mode 100644 vcl/source/app/IconThemeScanner.cxx create mode 100644 vcl/source/app/IconThemeSelector.cxx create mode 100644 vcl/source/app/brand.cxx create mode 100644 vcl/source/app/customweld.cxx create mode 100644 vcl/source/app/dbggui.cxx create mode 100644 vcl/source/app/dndhelp.cxx create mode 100644 vcl/source/app/help.cxx create mode 100644 vcl/source/app/i18nhelp.cxx create mode 100644 vcl/source/app/idle.cxx create mode 100644 vcl/source/app/salplug.cxx create mode 100644 vcl/source/app/salusereventlist.cxx create mode 100644 vcl/source/app/salvtables.cxx create mode 100644 vcl/source/app/scheduler.cxx create mode 100644 vcl/source/app/session.cxx create mode 100644 vcl/source/app/settings.cxx create mode 100644 vcl/source/app/sound.cxx create mode 100644 vcl/source/app/stdtext.cxx create mode 100644 vcl/source/app/svapp.cxx create mode 100644 vcl/source/app/svdata.cxx create mode 100644 vcl/source/app/svmain.cxx create mode 100644 vcl/source/app/timer.cxx create mode 100644 vcl/source/app/unohelp.cxx create mode 100644 vcl/source/app/unohelp2.cxx create mode 100644 vcl/source/app/vclevent.cxx create mode 100644 vcl/source/app/watchdog.cxx create mode 100644 vcl/source/app/weldutils.cxx create mode 100644 vcl/source/app/winscheduler.cxx (limited to 'vcl/source/app') diff --git a/vcl/source/app/ITiledRenderable.cxx b/vcl/source/app/ITiledRenderable.cxx new file mode 100644 index 000000000..e2a639dec --- /dev/null +++ b/vcl/source/app/ITiledRenderable.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 + +namespace vcl +{ + + /* + * Map directly to css cursor styles to avoid further mapping in the client. + * Gtk (via gdk_cursor_new_from_name) also supports the same css cursor styles. + * + * This was created partially with help of the mappings in gtkdata.cxx. + * The list is incomplete as some cursor style simply aren't supported + * by css, it might turn out to be worth mapping some of these missing cursors + * to available cursors? + */ +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning( disable : 4592) +#endif + const std::map gaLOKPointerMap { + { PointerStyle::Arrow, "default" }, + // PointerStyle::Null ? + { PointerStyle::Wait, "wait" }, + { PointerStyle::Text, "text" }, + { PointerStyle::Help, "help" }, + { PointerStyle::Cross, "crosshair" }, + { PointerStyle::Fill, "fill" }, + { PointerStyle::Move, "move" }, + { PointerStyle::NSize, "n-resize" }, + { PointerStyle::SSize, "s-resize" }, + { PointerStyle::WSize, "w-resize" }, + { PointerStyle::ESize, "e-resize" }, + { PointerStyle::NWSize, "ne-resize" }, + { PointerStyle::NESize, "ne-resize" }, + { PointerStyle::SWSize, "sw-resize" }, + { PointerStyle::SESize, "se-resize" }, + // WindowNSize through WindowSESize + { PointerStyle::HSplit, "col-resize" }, + { PointerStyle::VSplit, "row-resize" }, + { PointerStyle::HSizeBar, "col-resize" }, + { PointerStyle::VSizeBar, "row-resize" }, + { PointerStyle::Hand, "grab" }, + { PointerStyle::RefHand, "pointer" }, + // Pen, Magnify, Fill, Rotate + // HShear, VShear + // Mirror, Crook, Crop, MovePoint, MoveBezierWeight + // MoveData + { PointerStyle::CopyData, "copy" }, + { PointerStyle::LinkData, "alias" }, + // MoveDataLink, CopyDataLink + //MoveFile, CopyFile, LinkFile + // MoveFileLink, CopyFileLink, MoveFiless, CopyFiles + { PointerStyle::NotAllowed, "not-allowed" }, + // DrawLine through DrawCaption + // Chart, Detective, PivotCol, PivotRow, PivotField, Chain, ChainNotAllowed + // TimeEventMove, TimeEventSize + // AutoScrollN through AutoScrollNSWE + // Airbrush + { PointerStyle::TextVertical, "vertical-text" } + // Pivot Delete, TabSelectS through TabSelectSW + // PaintBrush, HideWhiteSpace, ShowWhiteSpace + }; +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +ITiledRenderable::~ITiledRenderable() +{ +} + +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/IconThemeInfo.cxx b/vcl/source/app/IconThemeInfo.cxx new file mode 100644 index 000000000..84d85883b --- /dev/null +++ b/vcl/source/app/IconThemeInfo.cxx @@ -0,0 +1,188 @@ +/* -*- 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 +#include + +#include +#include + +// constants for theme ids and display names. Only the theme id for high contrast is used +// outside of this class and hence made public. + +const OUStringLiteral vcl::IconThemeInfo::HIGH_CONTRAST_ID("sifr"); + +namespace { + +static const OUStringLiteral KARASA_JAGA_ID("karasa_jaga"); +static const OUStringLiteral KARASA_JAGA_DISPLAY_NAME("Karasa Jaga"); +static const OUStringLiteral HELPIMG_FAKE_THEME("helpimg"); + +OUString +filename_from_url(const OUString& url) +{ + sal_Int32 slashPosition = url.lastIndexOf( '/' ); + if (slashPosition < 0) { + return OUString(); + } + OUString filename = url.copy( slashPosition+1 ); + return filename; +} + +} // end anonymous namespace + +namespace vcl { + +static const char ICON_THEME_PACKAGE_PREFIX[] = "images_"; + +static const char EXTENSION_FOR_ICON_PACKAGES[] = ".zip"; + +IconThemeInfo::IconThemeInfo() +{ +} + +IconThemeInfo::IconThemeInfo(const OUString& urlToFile) +: mUrlToFile(urlToFile) +{ + OUString filename = filename_from_url(urlToFile); + if (filename.isEmpty()) { + throw std::runtime_error("invalid URL passed to IconThemeInfo()"); + } + + mThemeId = FileNameToThemeId(filename); + mDisplayName = ThemeIdToDisplayName(mThemeId); + +} + +/*static*/ Size +IconThemeInfo::SizeByThemeName(const OUString& themeName) +{ + if (themeName == "galaxy") { //kept for compiler because of unused parameter 'themeName' + return Size( 26, 26 ); + } + else { + return Size( 24, 24 ); + } +} + +/*static*/ bool +IconThemeInfo::UrlCanBeParsed(const OUString& url) +{ + OUString fname = filename_from_url(url); + if (fname.isEmpty()) { + return false; + } + + if (!fname.startsWithIgnoreAsciiCase(ICON_THEME_PACKAGE_PREFIX)) { + return false; + } + + if (!fname.endsWithIgnoreAsciiCase(EXTENSION_FOR_ICON_PACKAGES)) { + return false; + } + + if (fname.indexOf(HELPIMG_FAKE_THEME) != -1 ) { + return false; + } + + return true; +} + +/*static*/ OUString +IconThemeInfo::FileNameToThemeId(const OUString& filename) +{ + OUString r; + sal_Int32 positionOfLastDot = filename.lastIndexOf(EXTENSION_FOR_ICON_PACKAGES); + if (positionOfLastDot < 0) { // -1 means index not found + throw std::runtime_error("IconThemeInfo::FileNameToThemeId() called with invalid filename."); + } + sal_Int32 positionOfFirstUnderscore = filename.indexOf(ICON_THEME_PACKAGE_PREFIX); + if (positionOfFirstUnderscore < 0) { // -1 means index not found. Use the whole name instead + throw std::runtime_error("IconThemeInfo::FileNameToThemeId() called with invalid filename."); + } + positionOfFirstUnderscore += RTL_CONSTASCII_LENGTH(ICON_THEME_PACKAGE_PREFIX); + r = filename.copy(positionOfFirstUnderscore, positionOfLastDot - positionOfFirstUnderscore); + return r; +} + +/*static*/ OUString +IconThemeInfo::ThemeIdToDisplayName(const OUString& themeId) +{ + if (themeId.isEmpty()) { + throw std::runtime_error("IconThemeInfo::ThemeIdToDisplayName() called with invalid id."); + } + + // Strip _svg and _dark filename "extensions" + OUString aDisplayName = themeId; + + bool bIsSvg = aDisplayName.endsWith("_svg", &aDisplayName); + bool bIsDark = aDisplayName.endsWith("_dark", &aDisplayName); + if (!bIsSvg && bIsDark) + bIsSvg = aDisplayName.endsWith("_svg", &aDisplayName); + + // special cases + if (aDisplayName.equalsIgnoreAsciiCase(KARASA_JAGA_ID)) { + aDisplayName = KARASA_JAGA_DISPLAY_NAME; + } + else + { + // make the first letter uppercase + sal_Unicode firstLetter = aDisplayName[0]; + if (rtl::isAsciiLowerCase(firstLetter)) + { + aDisplayName = OUStringChar(sal_Unicode(rtl::toAsciiUpperCase(firstLetter))) + aDisplayName.copy(1); + } + } + + if (bIsSvg && bIsDark) + aDisplayName += " (SVG + dark)"; + else if (bIsSvg) + aDisplayName += " (SVG)"; + else if (bIsDark) + aDisplayName += " (dark)"; + + return aDisplayName; +} + +namespace +{ + class SameTheme + { + private: + const OUString& m_rThemeId; + public: + explicit SameTheme(const OUString &rThemeId) : m_rThemeId(rThemeId) {} + bool operator()(const vcl::IconThemeInfo &rInfo) + { + return m_rThemeId == rInfo.GetThemeId(); + } + }; +} + +/*static*/ const vcl::IconThemeInfo& +IconThemeInfo::FindIconThemeById(const std::vector& themes, const OUString& themeId) +{ + std::vector::const_iterator it = std::find_if(themes.begin(), themes.end(), + SameTheme(themeId)); + if (it == themes.end()) + { + throw std::runtime_error("Could not find theme id in theme vector."); + } + return *it; +} + +/*static*/ bool +IconThemeInfo::IconThemeIsInVector(const std::vector& themes, const OUString& themeId) +{ + return std::any_of(themes.begin(), themes.end(), SameTheme(themeId)); +} + +} // end namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/IconThemeScanner.cxx b/vcl/source/app/IconThemeScanner.cxx new file mode 100644 index 000000000..a9163af3c --- /dev/null +++ b/vcl/source/app/IconThemeScanner.cxx @@ -0,0 +1,215 @@ +/* -*- 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 +#include + +#include + +#include + +#include +#include +#include +#include + +namespace vcl { + +namespace { + +// set the status of a file. Returns false if the status could not be determined. +bool set_file_status(osl::FileStatus& status, const OUString& file) +{ + osl::DirectoryItem dirItem; + osl::FileBase::RC retvalGet = osl::DirectoryItem::get(file, dirItem); + if (retvalGet != osl::FileBase::E_None) { + SAL_WARN("vcl.app", "Could not determine status for file '" << file << "'."); + return false; + } + osl::FileBase::RC retvalStatus = dirItem.getFileStatus(status); + if (retvalStatus != osl::FileBase::E_None) { + SAL_WARN("vcl.app", "Could not determine status for file '" << file << "'."); + return false; + } + return true; +} + +OUString convert_to_absolute_path(const OUString& path) +{ + salhelper::LinkResolver resolver(0); + osl::FileBase::RC rc = resolver.fetchFileStatus(path); + if (rc != osl::FileBase::E_None) { + SAL_WARN("vcl.app", "Could not resolve path '" << path << "' to search for icon themes."); + if (rc == osl::FileBase::E_MULTIHOP) + { + throw std::runtime_error("Provided a recursive symlink to an icon theme directory that could not be resolved."); + } + } + return resolver.m_aStatus.getFileURL(); +} + +} + +IconThemeScanner::IconThemeScanner() +{} + +void IconThemeScanner::ScanDirectoryForIconThemes(const OUString& paths) +{ + mFoundIconThemes.clear(); + + std::deque aPaths; + + sal_Int32 nIndex = 0; + do + { + aPaths.push_front(paths.getToken(0, ';', nIndex)); + } + while (nIndex >= 0); + + for (const auto& path : aPaths) + { + osl::FileStatus fileStatus(osl_FileStatus_Mask_Type); + bool couldSetFileStatus = set_file_status(fileStatus, path); + if (!couldSetFileStatus) { + continue; + } + + if (!fileStatus.isDirectory()) { + SAL_INFO("vcl.app", "Cannot search for icon themes in '"<< path << "'. It is not a directory."); + continue; + } + + std::vector iconThemePaths = ReadIconThemesFromPath(path); + if (iconThemePaths.empty()) { + SAL_WARN("vcl.app", "Could not find any icon themes in the provided directory ('" < +IconThemeScanner::ReadIconThemesFromPath(const OUString& dir) +{ + std::vector found; + SAL_INFO("vcl.app", "Scanning directory '" << dir << " for icon themes."); + + osl::Directory dirToScan(dir); + osl::FileBase::RC retvalOpen = dirToScan.open(); + if (retvalOpen != osl::FileBase::E_None) { + return found; + } + + osl::DirectoryItem directoryItem; + while (dirToScan.getNextItem(directoryItem) == osl::FileBase::E_None) { + osl::FileStatus status(osl_FileStatus_Mask_Type | osl_FileStatus_Mask_FileURL | osl_FileStatus_Mask_FileName); + osl::FileBase::RC retvalStatus = directoryItem.getFileStatus(status); + if (retvalStatus != osl::FileBase::E_None) { + continue; + } + + OUString filename = convert_to_absolute_path(status.getFileURL()); + if (!FileIsValidIconTheme(filename)) { + continue; + } + found.push_back(filename); + } + return found; +} + +/*static*/ bool +IconThemeScanner::FileIsValidIconTheme(const OUString& filename) +{ + // check whether we can construct an IconThemeInfo from it + if (!IconThemeInfo::UrlCanBeParsed(filename)) { + SAL_INFO("vcl.app", "File '" << filename << "' does not seem to be an icon theme."); + return false; + } + + osl::FileStatus fileStatus(osl_FileStatus_Mask_Type); + bool couldSetFileStatus = set_file_status(fileStatus, filename); + if (!couldSetFileStatus) { + return false; + } + + if (!fileStatus.isRegular()) { + return false; + } + return true; +} + +bool +IconThemeScanner::IconThemeIsInstalled(const OUString& themeId) const +{ + return IconThemeInfo::IconThemeIsInVector(mFoundIconThemes, themeId); +} + +/*static*/ std::shared_ptr +IconThemeScanner::Create(const OUString &path) +{ + std::shared_ptr retval(new IconThemeScanner); + retval->ScanDirectoryForIconThemes(path); + return retval; +} + +/*static*/ OUString +IconThemeScanner::GetStandardIconThemePath() +{ + SvtPathOptions aPathOptions; + return aPathOptions.GetIconsetPath(); +} + +namespace +{ + class SameTheme + { + private: + const OUString& m_rThemeId; + public: + explicit SameTheme(const OUString &rThemeId) : m_rThemeId(rThemeId) {} + bool operator()(const vcl::IconThemeInfo &rInfo) + { + return m_rThemeId == rInfo.GetThemeId(); + } + }; +} + +const vcl::IconThemeInfo& +IconThemeScanner::GetIconThemeInfo(const OUString& themeId) +{ + std::vector::iterator info = std::find_if(mFoundIconThemes.begin(), mFoundIconThemes.end(), + SameTheme(themeId)); + if (info == mFoundIconThemes.end()) { + SAL_WARN("vcl.app", "Requested information for icon theme with id '" << themeId + << "' which does not exist."); + throw std::runtime_error("Requested information on not-installed icon theme"); + } + return *info; +} + +} // end namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/IconThemeSelector.cxx b/vcl/source/app/IconThemeSelector.cxx new file mode 100644 index 000000000..e98d63657 --- /dev/null +++ b/vcl/source/app/IconThemeSelector.cxx @@ -0,0 +1,175 @@ +/* -*- 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 + +#include + +#include +#include + +#include + +namespace vcl { + +/*static*/ const OUStringLiteral IconThemeSelector::FALLBACK_ICON_THEME_ID("colibre"); + +namespace { + + class SameTheme + { + private: + const OUString& m_rThemeId; + public: + explicit SameTheme(const OUString &rThemeId) : m_rThemeId(rThemeId) {} + bool operator()(const vcl::IconThemeInfo &rInfo) + { + return m_rThemeId == rInfo.GetThemeId(); + } + }; + +bool icon_theme_is_in_installed_themes(const OUString& theme, + const std::vector& installedThemes) +{ + return std::any_of(installedThemes.begin(), installedThemes.end(), + SameTheme(theme)); +} + +} // end anonymous namespace + +IconThemeSelector::IconThemeSelector() + : mUseHighContrastTheme(false) + , mPreferDarkIconTheme(false) +{ +} + +/*static*/ OUString +IconThemeSelector::GetIconThemeForDesktopEnvironment(const OUString& desktopEnvironment) +{ + if (comphelper::LibreOfficeKit::isActive()) + return "colibre"; + +#ifdef _WIN32 + (void)desktopEnvironment; + return "colibre"; +#else + OUString r; + if ( desktopEnvironment.equalsIgnoreAsciiCase("plasma5") || + desktopEnvironment.equalsIgnoreAsciiCase("lxqt") ) { + r = "breeze"; + } + else if ( desktopEnvironment.equalsIgnoreAsciiCase("macosx") ) { + r = "sukapura"; + } + else if ( desktopEnvironment.equalsIgnoreAsciiCase("gnome") || + desktopEnvironment.equalsIgnoreAsciiCase("mate") || + desktopEnvironment.equalsIgnoreAsciiCase("unity") ) { + r = "elementary"; + } else + { + r = FALLBACK_ICON_THEME_ID; + } + return r; +#endif // _WIN32 +} + +OUString +IconThemeSelector::SelectIconThemeForDesktopEnvironment( + const std::vector& installedThemes, + const OUString& desktopEnvironment) const +{ + if (!mPreferredIconTheme.isEmpty()) { + if (icon_theme_is_in_installed_themes(mPreferredIconTheme, installedThemes)) { + return mPreferredIconTheme; + } + //if a dark variant is preferred, and we didn't have an exact match, then try our one and only dark theme + if (mPreferDarkIconTheme && icon_theme_is_in_installed_themes("breeze_dark", installedThemes)) { + return "breeze_dark"; + } + } + + OUString themeForDesktop = GetIconThemeForDesktopEnvironment(desktopEnvironment); + if (icon_theme_is_in_installed_themes(themeForDesktop, installedThemes)) { + return themeForDesktop; + } + + return ReturnFallback(installedThemes); +} + +OUString +IconThemeSelector::SelectIconTheme( + const std::vector& installedThemes, + const OUString& theme) const +{ + if (mUseHighContrastTheme) { + if (icon_theme_is_in_installed_themes(IconThemeInfo::HIGH_CONTRAST_ID, installedThemes)) { + return IconThemeInfo::HIGH_CONTRAST_ID; + } + } + + if (icon_theme_is_in_installed_themes(theme, installedThemes)) { + return theme; + } + + return ReturnFallback(installedThemes); +} + +void +IconThemeSelector::SetUseHighContrastTheme(bool v) +{ + mUseHighContrastTheme = v; +} + +void +IconThemeSelector::SetPreferredIconTheme(const OUString& theme, bool bDarkIconTheme) +{ + // lower case theme name, and (tdf#120175) replace - with _ + // see icon-themes/README + mPreferredIconTheme = theme.toAsciiLowerCase().replace('-','_'); + mPreferDarkIconTheme = bDarkIconTheme; +} + +bool +IconThemeSelector::operator==(const vcl::IconThemeSelector& other) const +{ + if (this == &other) { + return true; + } + if (mPreferredIconTheme != other.mPreferredIconTheme) { + return false; + } + if (mPreferDarkIconTheme != other.mPreferDarkIconTheme) { + return false; + } + if (mUseHighContrastTheme != other.mUseHighContrastTheme) { + return false; + } + return true; +} + +bool +IconThemeSelector::operator!=(const vcl::IconThemeSelector& other) const +{ + return !(*this == other); +} + +/*static*/ OUString +IconThemeSelector::ReturnFallback(const std::vector& installedThemes) +{ + if (!installedThemes.empty()) { + return installedThemes.front().GetThemeId(); + } + else { + return FALLBACK_ICON_THEME_ID; + } +} + +} /* namespace vcl */ + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/brand.cxx b/vcl/source/app/brand.cxx new file mode 100644 index 000000000..290606106 --- /dev/null +++ b/vcl/source/app/brand.cxx @@ -0,0 +1,73 @@ +/* -*- 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 + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { + bool loadPng( const OUString & rPath, BitmapEx &rBitmap) + { + INetURLObject aObj( rPath ); + SvFileStream aStrm( aObj.PathToFileName(), StreamMode::STD_READ ); + if ( !aStrm.GetError() ) { + vcl::PNGReader aReader( aStrm ); + rBitmap = aReader.Read(); + return !rBitmap.IsEmpty(); + } + else + return false; + } + bool tryLoadPng( const OUString& rBaseDir, const OUString& rName, BitmapEx& rBitmap ) + { + return loadPng( rBaseDir + "/" LIBO_ETC_FOLDER + rName, rBitmap); + } +} + +bool Application::LoadBrandBitmap (const char* pName, BitmapEx &rBitmap) +{ + // TODO - if we want more flexibility we could add a branding path + // in an rc file perhaps fallback to "about.bmp" + OUString aBaseDir( "$BRAND_BASE_DIR"); + rtl::Bootstrap::expandMacros( aBaseDir ); + OUString aBaseName( "/" + OUString::createFromAscii( pName ) ); + OUString aPng( ".png" ); + + rtl_Locale *pLoc = nullptr; + osl_getProcessLocale (&pLoc); + LanguageTag aLanguageTag( *pLoc); + + ::std::vector< OUString > aFallbacks( aLanguageTag.getFallbackStrings( true)); + for (const OUString & aFallback : aFallbacks) + { + if (tryLoadPng( aBaseDir, aBaseName + "-" + aFallback + aPng, rBitmap)) + return true; + } + + return tryLoadPng( aBaseDir, aBaseName + aPng, rBitmap); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/customweld.cxx b/vcl/source/app/customweld.cxx new file mode 100644 index 000000000..c08a38208 --- /dev/null +++ b/vcl/source/app/customweld.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 + +namespace weld +{ +CustomWidgetController::~CustomWidgetController() {} + +IMPL_LINK_NOARG(CustomWidgetController, DragBeginHdl, weld::DrawingArea&, bool) +{ + return StartDrag(); +} + +CustomWeld::CustomWeld(weld::Builder& rBuilder, const OString& rDrawingId, + CustomWidgetController& rWidgetController) + : m_rWidgetController(rWidgetController) + , m_xDrawingArea(rBuilder.weld_drawing_area(rDrawingId, rWidgetController.CreateAccessible(), + rWidgetController.GetUITestFactory(), + &rWidgetController)) +{ + m_xDrawingArea->connect_size_allocate(LINK(this, CustomWeld, DoResize)); + m_xDrawingArea->connect_draw(LINK(this, CustomWeld, DoPaint)); + m_xDrawingArea->connect_mouse_press(LINK(this, CustomWeld, DoMouseButtonDown)); + m_xDrawingArea->connect_mouse_move(LINK(this, CustomWeld, DoMouseMove)); + m_xDrawingArea->connect_mouse_release(LINK(this, CustomWeld, DoMouseButtonUp)); + m_xDrawingArea->connect_focus_in(LINK(this, CustomWeld, DoGetFocus)); + m_xDrawingArea->connect_focus_out(LINK(this, CustomWeld, DoLoseFocus)); + m_xDrawingArea->connect_key_press(LINK(this, CustomWeld, DoKeyPress)); + m_xDrawingArea->connect_focus_rect(LINK(this, CustomWeld, DoFocusRect)); + m_xDrawingArea->connect_style_updated(LINK(this, CustomWeld, DoStyleUpdated)); + m_xDrawingArea->connect_command(LINK(this, CustomWeld, DoCommand)); + m_xDrawingArea->connect_query_tooltip(LINK(this, CustomWeld, DoRequestHelp)); + m_xDrawingArea->connect_im_context_get_surrounding(LINK(this, CustomWeld, DoGetSurrounding)); + m_rWidgetController.SetDrawingArea(m_xDrawingArea.get()); +} + +IMPL_LINK(CustomWeld, DoResize, const Size&, rSize, void) +{ + m_rWidgetController.SetOutputSizePixel(rSize); + m_rWidgetController.Resize(); +} + +IMPL_LINK(CustomWeld, DoPaint, weld::DrawingArea::draw_args, aPayload, void) +{ + m_rWidgetController.Paint(aPayload.first, aPayload.second); +} + +IMPL_LINK(CustomWeld, DoMouseButtonDown, const MouseEvent&, rMEvt, bool) +{ + return m_rWidgetController.MouseButtonDown(rMEvt); +} + +IMPL_LINK(CustomWeld, DoMouseMove, const MouseEvent&, rMEvt, bool) +{ + return m_rWidgetController.MouseMove(rMEvt); +} + +IMPL_LINK(CustomWeld, DoMouseButtonUp, const MouseEvent&, rMEvt, bool) +{ + return m_rWidgetController.MouseButtonUp(rMEvt); +} + +IMPL_LINK_NOARG(CustomWeld, DoGetFocus, weld::Widget&, void) { m_rWidgetController.GetFocus(); } + +IMPL_LINK_NOARG(CustomWeld, DoLoseFocus, weld::Widget&, void) { m_rWidgetController.LoseFocus(); } + +IMPL_LINK(CustomWeld, DoKeyPress, const KeyEvent&, rKEvt, bool) +{ + return m_rWidgetController.KeyInput(rKEvt); +} + +IMPL_LINK_NOARG(CustomWeld, DoFocusRect, weld::Widget&, tools::Rectangle) +{ + return m_rWidgetController.GetFocusRect(); +} + +IMPL_LINK_NOARG(CustomWeld, DoStyleUpdated, weld::Widget&, void) +{ + m_rWidgetController.StyleUpdated(); +} + +IMPL_LINK(CustomWeld, DoCommand, const CommandEvent&, rPos, bool) +{ + return m_rWidgetController.Command(rPos); +} + +IMPL_LINK(CustomWeld, DoRequestHelp, tools::Rectangle&, rHelpArea, OUString) +{ + return m_rWidgetController.RequestHelp(rHelpArea); +} + +IMPL_LINK(CustomWeld, DoGetSurrounding, OUString&, rSurrounding, int) +{ + return m_rWidgetController.GetSurroundingText(rSurrounding); +} +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/dbggui.cxx b/vcl/source/app/dbggui.cxx new file mode 100644 index 000000000..cfeeeaf5d --- /dev/null +++ b/vcl/source/app/dbggui.cxx @@ -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 . + */ + +#include + +#ifndef NDEBUG + +#include + +#include +#include + +#include + +using namespace ::com::sun::star; + +static void ImplDbgTestSolarMutex() +{ + assert(ImplGetSVData()->mpDefInst->GetYieldMutex()->IsCurrentThread() && "SolarMutex not owned!"); +} + +void DbgGUIInitSolarMutexCheck() +{ + DbgSetTestSolarMutex( ImplDbgTestSolarMutex ); +} + +void DbgGUIDeInitSolarMutexCheck() +{ + DbgSetTestSolarMutex( nullptr ); +} + +#endif // NDEBUG + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/dndhelp.cxx b/vcl/source/app/dndhelp.cxx new file mode 100644 index 000000000..ff4beb789 --- /dev/null +++ b/vcl/source/app/dndhelp.cxx @@ -0,0 +1,139 @@ +/* -*- 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 + +#include + +using namespace ::com::sun::star; + +vcl::unohelper::DragAndDropClient::~DragAndDropClient() COVERITY_NOEXCEPT_FALSE {} + +void vcl::unohelper::DragAndDropClient::dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& /*dge*/ ) +{ +} + +void vcl::unohelper::DragAndDropClient::dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& /*dsde*/ ) +{ +} + +void vcl::unohelper::DragAndDropClient::drop( const css::datatransfer::dnd::DropTargetDropEvent& /*dtde*/ ) +{ +} + +void vcl::unohelper::DragAndDropClient::dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& /*dtdee*/ ) +{ +} + +void vcl::unohelper::DragAndDropClient::dragExit( const css::datatransfer::dnd::DropTargetEvent& /*dte*/ ) +{ +} + +void vcl::unohelper::DragAndDropClient::dragOver( const css::datatransfer::dnd::DropTargetDragEvent& /*dtde*/ ) +{ +} + +vcl::unohelper::DragAndDropWrapper::DragAndDropWrapper( DragAndDropClient* pClient ) +{ + mpClient = pClient; +} + +vcl::unohelper::DragAndDropWrapper::~DragAndDropWrapper() +{ +} + +// uno::XInterface +uno::Any vcl::unohelper::DragAndDropWrapper::queryInterface( const uno::Type & rType ) +{ + uno::Any aRet = ::cppu::queryInterface( rType, + static_cast< css::lang::XEventListener* >( static_cast(this) ), + static_cast< css::datatransfer::dnd::XDragGestureListener* >(this), + static_cast< css::datatransfer::dnd::XDragSourceListener* >(this), + static_cast< css::datatransfer::dnd::XDropTargetListener* >(this) ); + return (aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType )); +} + +// css::lang::XEventListener +void vcl::unohelper::DragAndDropWrapper::disposing( const css::lang::EventObject& rEvent ) +{ + // Empty Source means it's the client, because the client is not a XInterface + if ( !rEvent.Source.is() ) + mpClient = nullptr; +} + +// css::datatransfer::dnd::XDragGestureListener +void vcl::unohelper::DragAndDropWrapper::dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& rDGE ) +{ + if ( mpClient ) + mpClient->dragGestureRecognized( rDGE ); +} + +// css::datatransfer::dnd::XDragSourceListener +void vcl::unohelper::DragAndDropWrapper::dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& rDSDE ) +{ + if ( mpClient ) + mpClient->dragDropEnd( rDSDE ); +} + +void vcl::unohelper::DragAndDropWrapper::dragEnter( const css::datatransfer::dnd::DragSourceDragEvent& ) +{ +} + +void vcl::unohelper::DragAndDropWrapper::dragExit( const css::datatransfer::dnd::DragSourceEvent& ) +{ +} + +void vcl::unohelper::DragAndDropWrapper::dragOver( const css::datatransfer::dnd::DragSourceDragEvent& ) +{ +} + +void vcl::unohelper::DragAndDropWrapper::dropActionChanged( const css::datatransfer::dnd::DragSourceDragEvent& ) +{ +} + +// css::datatransfer::dnd::XDropTargetListener +void vcl::unohelper::DragAndDropWrapper::drop( const css::datatransfer::dnd::DropTargetDropEvent& rDTDE ) +{ + if ( mpClient ) + mpClient->drop( rDTDE ); +} + +void vcl::unohelper::DragAndDropWrapper::dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& rDTDEE ) +{ + if ( mpClient ) + mpClient->dragEnter( rDTDEE ); +} + +void vcl::unohelper::DragAndDropWrapper::dragExit( const css::datatransfer::dnd::DropTargetEvent& dte ) +{ + if ( mpClient ) + mpClient->dragExit( dte ); +} + +void vcl::unohelper::DragAndDropWrapper::dragOver( const css::datatransfer::dnd::DropTargetDragEvent& rDTDE ) +{ + if ( mpClient ) + mpClient->dragOver( rDTDE ); +} + +void vcl::unohelper::DragAndDropWrapper::dropActionChanged( const css::datatransfer::dnd::DropTargetDragEvent& ) +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/help.cxx b/vcl/source/app/help.cxx new file mode 100644 index 000000000..ebe7588c5 --- /dev/null +++ b/vcl/source/app/help.cxx @@ -0,0 +1,677 @@ +/* -*- 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 +#include + +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define HELPWINSTYLE_QUICK 0 +#define HELPWINSTYLE_BALLOON 1 + +#define HELPTEXTMARGIN_QUICK 3 +#define HELPTEXTMARGIN_BALLOON 6 + +#define HELPTEXTMAXLEN 150 + +Help::Help() +{ +} + +Help::~Help() +{ +} + +bool Help::Start( const OUString&, const vcl::Window* ) +{ + return false; +} + +bool Help::Start(const OUString&, weld::Widget*) +{ + return false; +} + +void Help::SearchKeyword( const OUString& ) +{ +} + +OUString Help::GetHelpText( const OUString&, const vcl::Window* ) +{ + return OUString(); +} + +OUString Help::GetHelpText( const OUString&, const weld::Widget* ) +{ + return OUString(); +} + +void Help::EnableContextHelp() +{ + ImplGetSVHelpData().mbContextHelp = true; +} + +void Help::DisableContextHelp() +{ + ImplGetSVHelpData().mbContextHelp = false; +} + +bool Help::IsContextHelpEnabled() +{ + return ImplGetSVHelpData().mbContextHelp; +} + +void Help::EnableExtHelp() +{ + ImplGetSVHelpData().mbExtHelp = true; +} + +void Help::DisableExtHelp() +{ + ImplGetSVHelpData().mbExtHelp = false; +} + +bool Help::IsExtHelpEnabled() +{ + return ImplGetSVHelpData().mbExtHelp; +} + +bool Help::StartExtHelp() +{ + ImplSVData* pSVData = ImplGetSVData(); + ImplSVHelpData& aHelpData = ImplGetSVHelpData(); + + if ( aHelpData.mbExtHelp && !aHelpData.mbExtHelpMode ) + { + aHelpData.mbExtHelpMode = true; + aHelpData.mbOldBalloonMode = aHelpData.mbBalloonHelp; + aHelpData.mbBalloonHelp = true; + if (pSVData->maFrameData.mpAppWin) + pSVData->maFrameData.mpAppWin->ImplGenerateMouseMove(); + return true; + } + + return false; +} + +bool Help::EndExtHelp() +{ + ImplSVData* pSVData = ImplGetSVData(); + ImplSVHelpData& aHelpData = ImplGetSVHelpData(); + + if ( aHelpData.mbExtHelp && aHelpData.mbExtHelpMode ) + { + aHelpData.mbExtHelpMode = false; + aHelpData.mbBalloonHelp = aHelpData.mbOldBalloonMode; + if (pSVData->maFrameData.mpAppWin) + pSVData->maFrameData.mpAppWin->ImplGenerateMouseMove(); + return true; + } + + return false; +} + +void Help::EnableBalloonHelp() +{ + ImplGetSVHelpData().mbBalloonHelp = true; +} + +void Help::DisableBalloonHelp() +{ + ImplGetSVHelpData().mbBalloonHelp = false; +} + +bool Help::IsBalloonHelpEnabled() +{ + return ImplGetSVHelpData().mbBalloonHelp; +} + +void Help::ShowBalloon( vcl::Window* pParent, + const Point& rScreenPos, const tools::Rectangle& rRect, + const OUString& rHelpText ) +{ + ImplShowHelpWindow( pParent, HELPWINSTYLE_BALLOON, QuickHelpFlags::NONE, + rHelpText, rScreenPos, rRect ); +} + +void Help::EnableQuickHelp() +{ + ImplGetSVHelpData().mbQuickHelp = true; +} + +void Help::DisableQuickHelp() +{ + ImplGetSVHelpData().mbQuickHelp = false; +} + +bool Help::IsQuickHelpEnabled() +{ + return ImplGetSVHelpData().mbQuickHelp; +} + +void Help::ShowQuickHelp( vcl::Window* pParent, + const tools::Rectangle& rScreenRect, + const OUString& rHelpText, + QuickHelpFlags nStyle ) +{ + sal_uInt16 nHelpWinStyle = ( nStyle & QuickHelpFlags::TipStyleBalloon ) ? HELPWINSTYLE_BALLOON : HELPWINSTYLE_QUICK; + ImplShowHelpWindow( pParent, nHelpWinStyle, nStyle, + rHelpText, + pParent->OutputToScreenPixel( pParent->GetPointerPosPixel() ), rScreenRect ); +} + +void Help::HideBalloonAndQuickHelp() +{ + HelpTextWindow const * pHelpWin = ImplGetSVHelpData().mpHelpWin; + bool const bIsVisible = ( pHelpWin != nullptr ) && pHelpWin->IsVisible(); + ImplDestroyHelpWindow( bIsVisible ); +} + +void* Help::ShowPopover(vcl::Window* pParent, const tools::Rectangle& rScreenRect, + const OUString& rText, QuickHelpFlags nStyle) +{ + void* nId = pParent->ImplGetFrame()->ShowPopover(rText, pParent, rScreenRect, nStyle); + if (nId) + { + //popovers are handled natively, return early + return nId; + } + + sal_uInt16 nHelpWinStyle = ( nStyle & QuickHelpFlags::TipStyleBalloon ) ? HELPWINSTYLE_BALLOON : HELPWINSTYLE_QUICK; + VclPtrInstance pHelpWin( pParent, rText, nHelpWinStyle, nStyle ); + + nId = pHelpWin.get(); + UpdatePopover(nId, pParent, rScreenRect, rText); + + pHelpWin->ShowHelp(true); + return nId; +} + +void Help::UpdatePopover(void* nId, vcl::Window* pParent, const tools::Rectangle& rScreenRect, + const OUString& rText) +{ + if (pParent->ImplGetFrame()->UpdatePopover(nId, rText, pParent, rScreenRect)) + { + //popovers are handled natively, return early + return; + } + + HelpTextWindow* pHelpWin = static_cast< HelpTextWindow* >( nId ); + ENSURE_OR_RETURN_VOID( pHelpWin != nullptr, "Help::UpdatePopover: invalid ID!" ); + + Size aSz = pHelpWin->CalcOutSize(); + pHelpWin->SetOutputSizePixel( aSz ); + ImplSetHelpWindowPos( pHelpWin, pHelpWin->GetWinStyle(), pHelpWin->GetStyle(), + pParent->OutputToScreenPixel( pParent->GetPointerPosPixel() ), rScreenRect ); + + pHelpWin->SetHelpText( rText ); + pHelpWin->Invalidate(); +} + +void Help::HidePopover(vcl::Window const * pParent, void* nId) +{ + if (pParent->ImplGetFrame()->HidePopover(nId)) + { + //popovers are handled natively, return early + return; + } + + VclPtr pHelpWin = static_cast(nId); + vcl::Window* pFrameWindow = pHelpWin->ImplGetFrameWindow(); + pHelpWin->Hide(); + // trigger update, so that a Paint is instantly triggered since we do not save the background + pFrameWindow->ImplUpdateAll(); + pHelpWin.disposeAndClear(); + ImplGetSVHelpData().mnLastHelpHideTime = tools::Time::GetSystemTicks(); +} + +HelpTextWindow::HelpTextWindow( vcl::Window* pParent, const OUString& rText, sal_uInt16 nHelpWinStyle, QuickHelpFlags nStyle ) : + FloatingWindow( pParent, WB_SYSTEMWINDOW|WB_TOOLTIPWIN ), // #105827# if we change the parent, mirroring will not work correctly when positioning this window + maHelpText( rText ) +{ + SetType( WindowType::HELPTEXTWINDOW ); + ImplSetMouseTransparent( true ); + mnHelpWinStyle = nHelpWinStyle; + mnStyle = nStyle; + + if( mnStyle & QuickHelpFlags::BiDiRtl ) + { + ComplexTextLayoutFlags nLayoutMode = GetLayoutMode(); + nLayoutMode |= ComplexTextLayoutFlags::BiDiRtl | ComplexTextLayoutFlags::TextOriginLeft; + SetLayoutMode( nLayoutMode ); + } + SetHelpText( rText ); + Window::SetHelpText( rText ); + + if ( ImplGetSVHelpData().mbSetKeyboardHelp ) + ImplGetSVHelpData().mbKeyboardHelp = true; + + + maShowTimer.SetInvokeHandler( LINK( this, HelpTextWindow, TimerHdl ) ); + maShowTimer.SetDebugName( "vcl::HelpTextWindow maShowTimer" ); + + const HelpSettings& rHelpSettings = pParent->GetSettings().GetHelpSettings(); + maHideTimer.SetTimeout( rHelpSettings.GetTipTimeout() ); + maHideTimer.SetInvokeHandler( LINK( this, HelpTextWindow, TimerHdl ) ); + maHideTimer.SetDebugName( "vcl::HelpTextWindow maHideTimer" ); +} + +void HelpTextWindow::ApplySettings(vcl::RenderContext& rRenderContext) +{ + const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings(); + SetPointFont(rRenderContext, rStyleSettings.GetHelpFont()); + rRenderContext.SetTextColor(rStyleSettings.GetHelpTextColor()); + rRenderContext.SetTextAlign(ALIGN_TOP); + + if (rRenderContext.IsNativeControlSupported(ControlType::Tooltip, ControlPart::Entire)) + { + EnableChildTransparentMode(); + SetParentClipMode(ParentClipMode::NoClip); + SetPaintTransparent(true); + rRenderContext.SetBackground(); + } + else + rRenderContext.SetBackground(Wallpaper(rStyleSettings.GetHelpColor())); + + if (rStyleSettings.GetHelpColor().IsDark()) + rRenderContext.SetLineColor(COL_WHITE); + else + rRenderContext.SetLineColor(COL_BLACK); + rRenderContext.SetFillColor(); +} + +HelpTextWindow::~HelpTextWindow() +{ + disposeOnce(); +} + +void HelpTextWindow::dispose() +{ + maShowTimer.Stop(); + maHideTimer.Stop(); + + if( this == ImplGetSVHelpData().mpHelpWin ) + ImplGetSVHelpData().mpHelpWin = nullptr; + FloatingWindow::dispose(); +} + +void HelpTextWindow::SetHelpText( const OUString& rHelpText ) +{ + maHelpText = rHelpText; + ApplySettings(*this); + if ( mnHelpWinStyle == HELPWINSTYLE_QUICK && maHelpText.getLength() < HELPTEXTMAXLEN && maHelpText.indexOf('\n') < 0) + { + Size aSize; + aSize.setHeight( GetTextHeight() ); + if ( mnStyle & QuickHelpFlags::CtrlText ) + aSize.setWidth( GetCtrlTextWidth( maHelpText ) ); + else + aSize.setWidth( GetTextWidth( maHelpText ) ); + maTextRect = tools::Rectangle( Point( HELPTEXTMARGIN_QUICK, HELPTEXTMARGIN_QUICK ), aSize ); + } + else // HELPWINSTYLE_BALLOON + { + sal_Int32 nCharsInLine = 35 + ((maHelpText.getLength()/100)*5); + // average width to have all windows consistent + OUStringBuffer aBuf; + comphelper::string::padToLength(aBuf, nCharsInLine, 'x'); + OUString aXXX = aBuf.makeStringAndClear(); + long nWidth = GetTextWidth( aXXX ); + Size aTmpSize( nWidth, 0x7FFFFFFF ); + tools::Rectangle aTry1( Point(), aTmpSize ); + DrawTextFlags nDrawFlags = DrawTextFlags::MultiLine | DrawTextFlags::WordBreak | + DrawTextFlags::Left | DrawTextFlags::Top; + if ( mnStyle & QuickHelpFlags::CtrlText ) + nDrawFlags |= DrawTextFlags::Mnemonic; + tools::Rectangle aTextRect = GetTextRect( aTry1, maHelpText, nDrawFlags ); + + // get a better width later... + maTextRect = aTextRect; + + // safety distance... + maTextRect.SetPos( Point( HELPTEXTMARGIN_BALLOON, HELPTEXTMARGIN_BALLOON ) ); + } + + Size aSize( CalcOutSize() ); + SetOutputSizePixel( aSize ); +} + +void HelpTextWindow::ImplShow() +{ + VclPtr xWindow( this ); + Show( true, ShowFlags::NoActivate ); + if( !xWindow->IsDisposed() ) + PaintImmediately(); +} + +void HelpTextWindow::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& ) +{ + // paint native background + bool bNativeOK = false; + if (rRenderContext.IsNativeControlSupported(ControlType::Tooltip, ControlPart::Entire)) + { + tools::Rectangle aCtrlRegion(Point(0, 0), GetOutputSizePixel()); + ImplControlValue aControlValue; + bNativeOK = rRenderContext.DrawNativeControl(ControlType::Tooltip, ControlPart::Entire, aCtrlRegion, + ControlState::NONE, aControlValue, OUString()); + } + + // paint text + if (mnHelpWinStyle == HELPWINSTYLE_QUICK && maHelpText.getLength() < HELPTEXTMAXLEN && maHelpText.indexOf('\n') < 0) + { + if ( mnStyle & QuickHelpFlags::CtrlText ) + rRenderContext.DrawCtrlText(maTextRect.TopLeft(), maHelpText); + else + rRenderContext.DrawText(maTextRect.TopLeft(), maHelpText); + } + else // HELPWINSTYLE_BALLOON + { + DrawTextFlags nDrawFlags = DrawTextFlags::MultiLine|DrawTextFlags::WordBreak| + DrawTextFlags::Left|DrawTextFlags::Top; + if (mnStyle & QuickHelpFlags::CtrlText) + nDrawFlags |= DrawTextFlags::Mnemonic; + rRenderContext.DrawText(maTextRect, maHelpText, nDrawFlags); + } + + // border + if (!bNativeOK) + { + Size aSz = GetOutputSizePixel(); + rRenderContext.DrawRect(tools::Rectangle(Point(), aSz)); + if (mnHelpWinStyle == HELPWINSTYLE_BALLOON) + { + aSz.AdjustWidth( -2 ); + aSz.AdjustHeight( -2 ); + Color aColor(rRenderContext.GetLineColor()); + rRenderContext.SetLineColor(COL_GRAY); + rRenderContext.DrawRect(tools::Rectangle(Point(1, 1), aSz)); + rRenderContext.SetLineColor(aColor); + } + } +} + +void HelpTextWindow::ShowHelp(bool bNoDelay) +{ + sal_uLong nTimeout = 0; + if (!bNoDelay) + { + // In case of ExtendedHelp display help sooner + if ( ImplGetSVHelpData().mbExtHelpMode ) + nTimeout = 15; + else + { + if ( mnHelpWinStyle == HELPWINSTYLE_QUICK ) + nTimeout = HelpSettings::GetTipDelay(); + else + nTimeout = HelpSettings::GetBalloonDelay(); + } + } + + maShowTimer.SetTimeout( nTimeout ); + maShowTimer.Start(); +} + +IMPL_LINK( HelpTextWindow, TimerHdl, Timer*, pTimer, void) +{ + if ( pTimer == &maShowTimer ) + { + if ( mnHelpWinStyle == HELPWINSTYLE_QUICK ) + { + // start auto-hide-timer for non-ShowTip windows + if ( this == ImplGetSVHelpData().mpHelpWin ) + maHideTimer.Start(); + } + ImplShow(); + } + else + { + SAL_WARN_IF( pTimer != &maHideTimer, "vcl", "HelpTextWindow::TimerHdl with bad Timer" ); + ImplDestroyHelpWindow( true ); + } +} + +Size HelpTextWindow::CalcOutSize() const +{ + Size aSz = maTextRect.GetSize(); + aSz.AdjustWidth(2*maTextRect.Left() ); + aSz.AdjustHeight(2*maTextRect.Top() ); + return aSz; +} + +void HelpTextWindow::RequestHelp( const HelpEvent& /*rHEvt*/ ) +{ + // Just to assure that Window::RequestHelp() is not called by + // ShowQuickHelp/ShowBalloonHelp in the HelpTextWindow. +} + +OUString HelpTextWindow::GetText() const +{ + return maHelpText; +} + +void ImplShowHelpWindow( vcl::Window* pParent, sal_uInt16 nHelpWinStyle, QuickHelpFlags nStyle, + const OUString& rHelpText, + const Point& rScreenPos, const tools::Rectangle& rHelpArea ) +{ + if (pParent->ImplGetFrame()->ShowTooltip(rHelpText, rHelpArea)) + { + //tooltips are handled natively, return early + return; + } + + ImplSVHelpData& aHelpData = ImplGetSVHelpData(); + + if (rHelpText.isEmpty() && !aHelpData.mbRequestingHelp) + return; + + VclPtr pHelpWin = aHelpData.mpHelpWin; + bool bNoDelay = false; + if ( pHelpWin ) + { + SAL_WARN_IF( pHelpWin == pParent, "vcl", "HelpInHelp ?!" ); + + if ( ( rHelpText.isEmpty() + || ( pHelpWin->GetWinStyle() != nHelpWinStyle ) + ) + && aHelpData.mbRequestingHelp + ) + { + // remove help window if no HelpText or + // other help mode. but keep it if we are scrolling, ie not requesting help + bool bWasVisible = pHelpWin->IsVisible(); + if ( bWasVisible ) + bNoDelay = true; // display it quickly if we were already in quick help mode + pHelpWin = nullptr; + ImplDestroyHelpWindow( bWasVisible ); + } + else + { + bool const bUpdate = (pHelpWin->GetHelpText() != rHelpText) || + ((pHelpWin->GetHelpArea() != rHelpArea) && aHelpData.mbRequestingHelp); + if (bUpdate) + { + pHelpWin->SetHelpText( rHelpText ); + // approach mouse position + ImplSetHelpWindowPos( pHelpWin, nHelpWinStyle, nStyle, rScreenPos, rHelpArea ); + if( pHelpWin->IsVisible() ) + pHelpWin->Invalidate(); + } + } + } + + if (pHelpWin || rHelpText.isEmpty()) + return; + + sal_uInt64 nCurTime = tools::Time::GetSystemTicks(); + if ( ( nCurTime - aHelpData.mnLastHelpHideTime ) < HelpSettings::GetTipDelay() ) + bNoDelay = true; + + pHelpWin = VclPtr::Create( pParent, rHelpText, nHelpWinStyle, nStyle ); + aHelpData.mpHelpWin = pHelpWin; + pHelpWin->SetHelpArea( rHelpArea ); + + // positioning + Size aSz = pHelpWin->CalcOutSize(); + pHelpWin->SetOutputSizePixel( aSz ); + ImplSetHelpWindowPos( pHelpWin, nHelpWinStyle, nStyle, rScreenPos, rHelpArea ); + // if not called from Window::RequestHelp, then without delay... + if ( !aHelpData.mbRequestingHelp ) + bNoDelay = true; + pHelpWin->ShowHelp(bNoDelay); + +} + +void ImplDestroyHelpWindow( bool bUpdateHideTime ) +{ + ImplDestroyHelpWindow(ImplGetSVHelpData(), bUpdateHideTime); +} + +void ImplDestroyHelpWindow(ImplSVHelpData& rHelpData, bool bUpdateHideTime) +{ + VclPtr pHelpWin = rHelpData.mpHelpWin; + if( pHelpWin ) + { + rHelpData.mpHelpWin = nullptr; + rHelpData.mbKeyboardHelp = false; + pHelpWin->Hide(); + pHelpWin.disposeAndClear(); + if( bUpdateHideTime ) + rHelpData.mnLastHelpHideTime = tools::Time::GetSystemTicks(); + } +} + +void ImplSetHelpWindowPos( vcl::Window* pHelpWin, sal_uInt16 nHelpWinStyle, QuickHelpFlags nStyle, + const Point& rPos, const tools::Rectangle& rHelpArea ) +{ + Point aPos = rPos; + Size aSz = pHelpWin->GetSizePixel(); + tools::Rectangle aScreenRect = pHelpWin->ImplGetFrameWindow()->GetDesktopRectPixel(); + aPos = pHelpWin->GetParent()->ImplGetFrameWindow()->OutputToAbsoluteScreenPixel( aPos ); + // get mouse screen coords + Point aMousePos( pHelpWin->GetParent()->ImplGetFrameWindow()->GetPointerPosPixel() ); + aMousePos = pHelpWin->GetParent()->ImplGetFrameWindow()->OutputToAbsoluteScreenPixel( aMousePos ); + + if ( nHelpWinStyle == HELPWINSTYLE_QUICK ) + { + if ( !(nStyle & QuickHelpFlags::NoAutoPos) ) + { + long nScreenHeight = aScreenRect.GetHeight(); + aPos.AdjustX( -4 ); + if ( aPos.Y() > aScreenRect.Top()+nScreenHeight-(nScreenHeight/4) ) + aPos.AdjustY( -(aSz.Height()+4) ); + else + aPos.AdjustY(21 ); + } + } + else + { + // If it's the mouse position, move the window slightly + // so the mouse pointer does not cover it + if ( aPos == aMousePos ) + { + aPos.AdjustX(12 ); + aPos.AdjustY(16 ); + } + } + + if ( nStyle & QuickHelpFlags::NoAutoPos ) + { + // convert help area to screen coords + tools::Rectangle devHelpArea( + pHelpWin->GetParent()->ImplGetFrameWindow()->OutputToAbsoluteScreenPixel( rHelpArea.TopLeft() ), + pHelpWin->GetParent()->ImplGetFrameWindow()->OutputToAbsoluteScreenPixel( rHelpArea.BottomRight() ) ); + + // which position of the rectangle? + aPos = devHelpArea.Center(); + + if ( nStyle & QuickHelpFlags::Left ) + aPos.setX( devHelpArea.Left() ); + else if ( nStyle & QuickHelpFlags::Right ) + aPos.setX( devHelpArea.Right() ); + + if ( nStyle & QuickHelpFlags::Top ) + aPos.setY( devHelpArea.Top() ); + else if ( nStyle & QuickHelpFlags::Bottom ) + aPos.setY( devHelpArea.Bottom() ); + + // which direction? + if ( nStyle & QuickHelpFlags::Left ) + ; + else if ( nStyle & QuickHelpFlags::Right ) + aPos.AdjustX( -(aSz.Width()) ); + else + aPos.AdjustX( -(aSz.Width()/2) ); + + if ( nStyle & QuickHelpFlags::Top ) + ; + else if ( nStyle & QuickHelpFlags::Bottom ) + aPos.AdjustY( -(aSz.Height()) ); + else + aPos.AdjustY( -(aSz.Height()/2) ); + } + + if ( aPos.X() < aScreenRect.Left() ) + aPos.setX( aScreenRect.Left() ); + else if ( ( aPos.X() + aSz.Width() ) > aScreenRect.Right() ) + aPos.setX( aScreenRect.Right() - aSz.Width() ); + if ( aPos.Y() < aScreenRect.Top() ) + aPos.setY( aScreenRect.Top() ); + else if ( ( aPos.Y() + aSz.Height() ) > aScreenRect.Bottom() ) + aPos.setY( aScreenRect.Bottom() - aSz.Height() ); + + if( ! (nStyle & QuickHelpFlags::NoEvadePointer) ) + { + /* the remark below should be obsolete by now as the helpwindow should + not be focusable, leaving it as a hint. However it is sensible in most + conditions to evade the mouse pointer so the content window is fully visible. + + // the popup must not appear under the mouse + // otherwise it would directly be closed due to a focus change... + */ + tools::Rectangle aHelpRect( aPos, aSz ); + if( aHelpRect.IsInside( aMousePos ) ) + { + Point delta(2,2); + Point aSize( aSz.Width(), aSz.Height() ); + Point aTest( aMousePos - aSize - delta ); + if( aTest.X() > aScreenRect.Left() && aTest.Y() > aScreenRect.Top() ) + aPos = aTest; + else + aPos = aMousePos + delta; + } + } + + vcl::Window* pWindow = pHelpWin->GetParent()->ImplGetFrameWindow(); + aPos = pWindow->AbsoluteScreenToOutputPixel( aPos ); + pHelpWin->SetPosPixel( aPos ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/i18nhelp.cxx b/vcl/source/app/i18nhelp.cxx new file mode 100644 index 000000000..ae7eed0e2 --- /dev/null +++ b/vcl/source/app/i18nhelp.cxx @@ -0,0 +1,160 @@ +/* -*- 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 +#include + +#include +#include + +#include + +#include + +using namespace ::com::sun::star; + +vcl::I18nHelper::I18nHelper( const css::uno::Reference< css::uno::XComponentContext >& rxContext, const LanguageTag& rLanguageTag ) + : + maLanguageTag( rLanguageTag) +{ + m_xContext = rxContext; + mpLocaleDataWrapper = nullptr; + mpTransliterationWrapper= nullptr; + mbTransliterateIgnoreCase = false; +} + +vcl::I18nHelper::~I18nHelper() +{ + ImplDestroyWrappers(); +} + +void vcl::I18nHelper::ImplDestroyWrappers() +{ + mpLocaleDataWrapper.reset(); + mpTransliterationWrapper.reset(); +} + +utl::TransliterationWrapper& vcl::I18nHelper::ImplGetTransliterationWrapper() const +{ + if ( !mpTransliterationWrapper ) + { + TransliterationFlags nModules = TransliterationFlags::IGNORE_WIDTH; + if ( mbTransliterateIgnoreCase ) + nModules |= TransliterationFlags::IGNORE_CASE; + + const_cast(this)->mpTransliterationWrapper.reset(new utl::TransliterationWrapper( m_xContext, nModules )); + const_cast(this)->mpTransliterationWrapper->loadModuleIfNeeded( maLanguageTag.getLanguageType() ); + } + return *mpTransliterationWrapper; +} + +LocaleDataWrapper& vcl::I18nHelper::ImplGetLocaleDataWrapper() const +{ + if ( !mpLocaleDataWrapper ) + { + const_cast(this)->mpLocaleDataWrapper.reset(new LocaleDataWrapper( m_xContext, maLanguageTag )); + } + return *mpLocaleDataWrapper; +} + +static bool is_formatting_mark( sal_Unicode c ) +{ + if( (c >= 0x200B) && (c <= 0x200F) ) // BiDi and zero-width-markers + return true; + if( (c >= 0x2028) && (c <= 0x202E) ) // BiDi and paragraph-markers + return true; + return false; +} + +/* #i100057# filter formatting marks out of strings before passing them to + the transliteration. The real solution would have been an additional TransliterationModule + to ignore these marks during transliteration; however changing the code in i18npool that actually + implements this could produce unwanted side effects. + + Of course this copying around is not really good, but looking at i18npool, one more time + will not hurt. +*/ +OUString vcl::I18nHelper::filterFormattingChars( const OUString& rStr ) +{ + sal_Int32 nLength = rStr.getLength(); + OUStringBuffer aBuf( nLength ); + const sal_Unicode* pStr = rStr.getStr(); + while( nLength-- ) + { + if( ! is_formatting_mark( *pStr ) ) + aBuf.append( *pStr ); + pStr++; + } + return aBuf.makeStringAndClear(); +} + +sal_Int32 vcl::I18nHelper::CompareString( const OUString& rStr1, const OUString& rStr2 ) const +{ + ::osl::Guard< ::osl::Mutex > aGuard( const_cast(this)->maMutex ); + + if ( mbTransliterateIgnoreCase ) + { + // Change mbTransliterateIgnoreCase and destroy the wrapper, next call to + // ImplGetTransliterationWrapper() will create a wrapper with the correct bIgnoreCase + const_cast(this)->mbTransliterateIgnoreCase = false; + const_cast(this)->mpTransliterationWrapper.reset(); + } + + OUString aStr1( filterFormattingChars(rStr1) ); + OUString aStr2( filterFormattingChars(rStr2) ); + return ImplGetTransliterationWrapper().compareString( aStr1, aStr2 ); +} + +bool vcl::I18nHelper::MatchString( const OUString& rStr1, const OUString& rStr2 ) const +{ + ::osl::Guard< ::osl::Mutex > aGuard( const_cast(this)->maMutex ); + + if ( !mbTransliterateIgnoreCase ) + { + // Change mbTransliterateIgnoreCase and destroy the wrapper, next call to + // ImplGetTransliterationWrapper() will create a wrapper with the correct bIgnoreCase + const_cast(this)->mbTransliterateIgnoreCase = true; + const_cast(this)->mpTransliterationWrapper.reset(); + } + + OUString aStr1( filterFormattingChars(rStr1) ); + OUString aStr2( filterFormattingChars(rStr2) ); + return ImplGetTransliterationWrapper().isMatch( aStr1, aStr2 ); +} + +bool vcl::I18nHelper::MatchMnemonic( const OUString& rString, sal_Unicode cMnemonicChar ) const +{ + ::osl::Guard< ::osl::Mutex > aGuard( const_cast(this)->maMutex ); + + bool bEqual = false; + sal_Int32 n = rString.indexOf( '~' ); + if ( n != -1 ) + { + OUString aMatchStr = rString.copy( n+1 ); // not only one char, because of transliteration... + bEqual = MatchString( OUString(cMnemonicChar), aMatchStr ); + } + return bEqual; +} + +OUString vcl::I18nHelper::GetNum( long nNumber, sal_uInt16 nDecimals, bool bUseThousandSep, bool bTrailingZeros ) const +{ + return ImplGetLocaleDataWrapper().getNum( nNumber, nDecimals, bUseThousandSep, bTrailingZeros ); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/idle.cxx b/vcl/source/app/idle.cxx new file mode 100644 index 000000000..26e1e5f22 --- /dev/null +++ b/vcl/source/app/idle.cxx @@ -0,0 +1,65 @@ +/* -*- 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 +#include + +Idle::Idle( bool bAuto, const char *pDebugName ) + : Timer( bAuto, pDebugName ) +{ + SetPriority( TaskPriority::DEFAULT_IDLE ); +} + +Idle::Idle( const char *pDebugName ) + : Idle( false, pDebugName ) +{ +} + +void Idle::Start() +{ + Task::Start(); + + sal_uInt64 nPeriod = Scheduler::ImmediateTimeoutMs; + if (Scheduler::GetDeterministicMode()) + { + switch ( GetPriority() ) + { + case TaskPriority::DEFAULT_IDLE: + case TaskPriority::LOWEST: + nPeriod = Scheduler::InfiniteTimeoutMs; + break; + default: + break; + } + } + + Task::StartTimer(nPeriod); +} + +sal_uInt64 Idle::UpdateMinPeriod( sal_uInt64 /* nTimeNow */ ) const +{ + return Scheduler::ImmediateTimeoutMs; +} + +AutoIdle::AutoIdle( const char *pDebugName ) + : Idle( true, pDebugName ) +{ +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/salplug.cxx b/vcl/source/app/salplug.cxx new file mode 100644 index 000000000..1868853e9 --- /dev/null +++ b/vcl/source/app/salplug.cxx @@ -0,0 +1,355 @@ +/* -*- 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 + +#include +#include +#include + +#include +#include +#include +#include + +#ifndef _WIN32 +#include +#include +#include + +#include +#else +#include +#include +#endif + +#include + +#ifdef ANDROID +#error "Android has no plugin infrastructure!" +#endif + +#if !(defined _WIN32 || defined MACOSX) +#define DESKTOPDETECT +#define HEADLESS_VCLPLUG +#endif + +extern "C" { +typedef SalInstance*(*salFactoryProc)(); +} + +namespace { + +oslModule pCloseModule = nullptr; + +SalInstance* tryInstance( const OUString& rModuleBase, bool bForce = false ) +{ +#ifdef HEADLESS_VCLPLUG + if (rModuleBase == "svp") + return svp_create_SalInstance(); +#endif + + SalInstance* pInst = nullptr; + OUString aUsedModuleBase(rModuleBase); + if (aUsedModuleBase == "kde5") + aUsedModuleBase = "kf5"; + OUString aModule( +#ifdef SAL_DLLPREFIX + SAL_DLLPREFIX +#endif + "vclplug_" + aUsedModuleBase + "lo" SAL_DLLEXTENSION ); + + osl::Module aMod; + if (aMod.loadRelative(reinterpret_cast(&tryInstance), aModule, SAL_LOADMODULE_GLOBAL)) + { + salFactoryProc aProc = reinterpret_cast(aMod.getFunctionSymbol("create_SalInstance")); + if (aProc) + { + pInst = aProc(); + SAL_INFO( + "vcl.plugadapt", + "sal plugin " << aModule << " produced instance " << pInst); + if (pInst) + { + pCloseModule = static_cast(aMod); + aMod.release(); + + /* + * Recent GTK+ versions load their modules with RTLD_LOCAL, so we can + * not access the 'gnome_accessibility_module_shutdown' anymore. + * So make sure libgtk+ & co are still mapped into memory when + * atk-bridge's atexit handler gets called. + */ + if( aUsedModuleBase == "gtk3" || aUsedModuleBase == "gtk3_kde5" || aUsedModuleBase == "win" ) + { + pCloseModule = nullptr; + } + } + } + else + { + SAL_WARN( + "vcl.plugadapt", + "could not load symbol create_SalInstance from shared object " + << aModule); + } + } + else if (bForce) + { + SAL_WARN("vcl.plugadapt", "could not load shared object " << aModule); + } + else + { + SAL_INFO("vcl.plugadapt", "could not load shared object " << aModule); + } + + // coverity[leaked_storage] - this is on purpose + return pInst; +} + +#ifdef DESKTOPDETECT +extern "C" typedef DesktopType Fn_get_desktop_environment(); + +DesktopType get_desktop_environment() +{ + OUString aModule(DESKTOP_DETECTOR_DLL_NAME); + oslModule aMod = osl_loadModuleRelative( + reinterpret_cast< oslGenericFunction >( &tryInstance ), aModule.pData, + SAL_LOADMODULE_DEFAULT ); + DesktopType ret = DESKTOP_UNKNOWN; + if( aMod ) + { + Fn_get_desktop_environment * pSym + = reinterpret_cast( + osl_getAsciiFunctionSymbol(aMod, "get_desktop_environment")); + if( pSym ) + ret = pSym(); + } + osl_unloadModule( aMod ); + return ret; +} + +SalInstance* autodetect_plugin() +{ + static const char* const pKDEFallbackList[] = + { +#if ENABLE_KF5 + "kf5", +#endif +#if ENABLE_GTK3_KDE5 + "gtk3_kde5", +#endif + "gtk3", "gen", nullptr + }; + + static const char* const pStandardFallbackList[] = + { + "gtk3", "gen", nullptr + }; + +#ifdef HEADLESS_VCLPLUG + static const char* const pHeadlessFallbackList[] = + { + "svp", nullptr + }; +#endif + + DesktopType desktop = get_desktop_environment(); + const char * const * pList = pStandardFallbackList; + int nListEntry = 0; + +#ifdef HEADLESS_VCLPLUG + // no server at all: dummy plugin + if ( desktop == DESKTOP_NONE ) + pList = pHeadlessFallbackList; + else +#endif + if ( desktop == DESKTOP_GNOME || + desktop == DESKTOP_UNITY || + desktop == DESKTOP_XFCE || + desktop == DESKTOP_MATE ) + pList = pStandardFallbackList; + else if (desktop == DESKTOP_PLASMA5 || desktop == DESKTOP_LXQT) + pList = pKDEFallbackList; + + SalInstance* pInst = nullptr; + while( pList[nListEntry] && pInst == nullptr ) + { + OUString aTry( OUString::createFromAscii( pList[nListEntry] ) ); + pInst = tryInstance( aTry ); + SAL_INFO_IF( + pInst, "vcl.plugadapt", + "plugin autodetection: " << pList[nListEntry]); + nListEntry++; + } + + return pInst; +} +#endif // DESKTOPDETECT + +#ifdef HEADLESS_VCLPLUG +// HACK to obtain Application::IsHeadlessModeEnabled early on, before +// Application::EnableHeadlessMode has potentially been called: +bool IsHeadlessModeRequested() +{ + if (Application::IsHeadlessModeEnabled()) { + return true; + } + sal_uInt32 n = rtl_getAppCommandArgCount(); + for (sal_uInt32 i = 0; i < n; ++i) { + OUString arg; + rtl_getAppCommandArg(i, &arg.pData); + if ( arg == "--headless" || arg == "-headless" ) { + return true; + } + } + return false; +} +#endif + +} // anonymous namespace + +SalInstance *CreateSalInstance() +{ + SalInstance *pInst = nullptr; + + OUString aUsePlugin; + rtl::Bootstrap::get("SAL_USE_VCLPLUGIN", aUsePlugin); + SAL_INFO_IF(!aUsePlugin.isEmpty(), "vcl", "Requested VCL plugin: " << aUsePlugin); +#ifdef HEADLESS_VCLPLUG + if (Application::IsBitmapRendering() || (aUsePlugin.isEmpty() && IsHeadlessModeRequested())) + aUsePlugin = "svp"; +#endif + + if (aUsePlugin == "svp") + { + Application::EnableBitmapRendering(); +#ifndef HEADLESS_VCLPLUG + aUsePlugin.clear(); +#endif + } + if( !aUsePlugin.isEmpty() ) + pInst = tryInstance( aUsePlugin, true ); + +#ifdef DESKTOPDETECT + if( ! pInst ) + pInst = autodetect_plugin(); +#endif + + // fallback, try everything + static const char* const pPlugin[] = { +#ifdef _WIN32 + "win" +#else +#ifdef MACOSX + "osx" +#else + "gtk3", "kf5", "gen" +#endif +#endif + }; + + for ( int i = 0; !pInst && i != SAL_N_ELEMENTS(pPlugin); ++i ) + pInst = tryInstance( OUString::createFromAscii( pPlugin[ i ] ) ); + + if( ! pInst ) + { + std::fprintf( stderr, "no suitable windowing system found, exiting.\n" ); + _exit( 1 ); + } + + // acquire SolarMutex + pInst->AcquireYieldMutex(); + + return pInst; +} + +void DestroySalInstance( SalInstance *pInst ) +{ + // release SolarMutex + pInst->ReleaseYieldMutexAll(); + + delete pInst; + if( pCloseModule ) + osl_unloadModule( pCloseModule ); +} + +void SalAbort( const OUString& rErrorText, bool bDumpCore ) +{ + if( rErrorText.isEmpty() ) + std::fprintf( stderr, "Application Error\n" ); + else + { + CrashReporter::addKeyValue("AbortMessage", rErrorText, CrashReporter::Write); + std::fprintf( stderr, "%s\n", OUStringToOString(rErrorText, osl_getThreadTextEncoding()).getStr() ); + } + if( bDumpCore ) + abort(); + else + _exit(1); +} + +const OUString& SalGetDesktopEnvironment() +{ +#ifdef _WIN32 + static OUString aDesktopEnvironment( "Windows" ); + +#else +#ifdef MACOSX + static OUString aDesktopEnvironment( "MacOSX" ); +#else + // Order to match desktops.hxx' DesktopType + static const char * const desktop_strings[] = { + "none", "unknown", "GNOME", "UNITY", + "XFCE", "MATE", "PLASMA5", "LXQT" }; + static OUString aDesktopEnvironment; + if( aDesktopEnvironment.isEmpty()) + { + aDesktopEnvironment = OUString::createFromAscii( + desktop_strings[get_desktop_environment()]); + } +#endif +#endif + return aDesktopEnvironment; +} + +SalData::SalData() : + m_pInstance(nullptr), + m_pPIManager(nullptr) +{ +} + +SalData::~SalData() COVERITY_NOEXCEPT_FALSE +{ +#if (defined UNX && !defined MACOSX) + psp::PrinterInfoManager::release(); +#endif +} + +#ifdef _WIN32 +bool HasAtHook() +{ + BOOL bIsRunning = FALSE; + // pvParam must be BOOL + return SystemParametersInfoW(SPI_GETSCREENREADER, 0, &bIsRunning, 0) + && bIsRunning; +} +#endif + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/salusereventlist.cxx b/vcl/source/app/salusereventlist.cxx new file mode 100644 index 000000000..088bc141f --- /dev/null +++ b/vcl/source/app/salusereventlist.cxx @@ -0,0 +1,171 @@ +/* -*- 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 +#include + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +SalUserEventList::SalUserEventList() + : m_bAllUserEventProcessedSignaled( true ) + , m_aProcessingThread(0) +{ +} + +SalUserEventList::~SalUserEventList() COVERITY_NOEXCEPT_FALSE +{ +} + +void SalUserEventList::insertFrame( SalFrame* pFrame ) +{ + auto aPair = m_aFrames.insert( pFrame ); + assert( aPair.second ); (void) aPair; +} + +void SalUserEventList::eraseFrame( SalFrame* pFrame ) +{ + auto it = m_aFrames.find( pFrame ); + assert( it != m_aFrames.end() ); + if ( it != m_aFrames.end() ) + m_aFrames.erase( it ); +} + +bool SalUserEventList::DispatchUserEvents( bool bHandleAllCurrentEvents ) +{ + bool bWasEvent = false; + oslThreadIdentifier aCurId = osl::Thread::getCurrentIdentifier(); + + DBG_TESTSOLARMUTEX(); + osl::ResettableMutexGuard aResettableListGuard(m_aUserEventsMutex); + + if (!m_aUserEvents.empty()) + { + if (bHandleAllCurrentEvents) + { + if (m_aProcessingUserEvents.empty()) + m_aProcessingUserEvents.swap(m_aUserEvents); + else + m_aProcessingUserEvents.splice(m_aProcessingUserEvents.end(), m_aUserEvents); + } + else if (m_aProcessingUserEvents.empty()) + { + m_aProcessingUserEvents.push_back( m_aUserEvents.front() ); + m_aUserEvents.pop_front(); + } + } + + if (HasUserEvents()) + { + bWasEvent = true; + m_aProcessingThread = aCurId; + + SalUserEvent aEvent( nullptr, nullptr, SalEvent::NONE ); + do { + if (m_aProcessingUserEvents.empty() || aCurId != m_aProcessingThread) + break; + aEvent = m_aProcessingUserEvents.front(); + m_aProcessingUserEvents.pop_front(); + + // remember to reset the guard before break or continue the loop + aResettableListGuard.clear(); + + if ( !isFrameAlive( aEvent.m_pFrame ) ) + { + if ( aEvent.m_nEvent == SalEvent::UserEvent ) + delete static_cast< ImplSVEvent* >( aEvent.m_pData ); + aResettableListGuard.reset(); + continue; + } + +#ifndef IOS + try +#endif + { + ProcessEvent( aEvent ); + } +#ifndef IOS + catch (css::uno::Exception&) + { + TOOLS_WARN_EXCEPTION("vcl", "Uncaught"); + std::abort(); + } + catch (std::exception& e) + { + SAL_WARN("vcl", "Uncaught " << typeid(e).name() << " " << e.what()); + std::abort(); + } + catch (...) + { + SAL_WARN("vcl", "Uncaught exception during DispatchUserEvents!"); + std::abort(); + } +#endif + aResettableListGuard.reset(); + if (!bHandleAllCurrentEvents) + break; + } + while( true ); + } + + if ( !m_bAllUserEventProcessedSignaled && !HasUserEvents() ) + { + m_bAllUserEventProcessedSignaled = true; + TriggerAllUserEventsProcessed(); + } + + return bWasEvent; +} + +void SalUserEventList::RemoveEvent( SalFrame* pFrame, void* pData, SalEvent nEvent ) +{ + SalUserEvent aEvent( pFrame, pData, nEvent ); + + osl::MutexGuard aGuard( m_aUserEventsMutex ); + auto it = std::find( m_aUserEvents.begin(), m_aUserEvents.end(), aEvent ); + if ( it != m_aUserEvents.end() ) + { + m_aUserEvents.erase( it ); + } + else + { + it = std::find( m_aProcessingUserEvents.begin(), m_aProcessingUserEvents.end(), aEvent ); + if ( it != m_aProcessingUserEvents.end() ) + { + m_aProcessingUserEvents.erase( it ); + } + } + + if ( !m_bAllUserEventProcessedSignaled && !HasUserEvents() ) + { + m_bAllUserEventProcessedSignaled = true; + TriggerAllUserEventsProcessed(); + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/app/salvtables.cxx b/vcl/source/app/salvtables.cxx new file mode 100644 index 000000000..d7c93164a --- /dev/null +++ b/vcl/source/app/salvtables.cxx @@ -0,0 +1,6777 @@ +/* -*- 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +SalFrame::SalFrame() + : m_pWindow(nullptr) + , m_pProc(nullptr) +{ +} + +// this file contains the virtual destructors of the sal interface +// compilers usually put their vtables where the destructor is + +SalFrame::~SalFrame() {} + +void SalFrame::SetCallback(vcl::Window* pWindow, SALFRAMEPROC pProc) +{ + m_pWindow = pWindow; + m_pProc = pProc; +} + +// default to full-frame flushes +// on ports where partial-flushes are much cheaper this method should be overridden +void SalFrame::Flush(const tools::Rectangle&) { Flush(); } + +void SalFrame::SetRepresentedURL(const OUString&) +{ + // currently this is Mac only functionality +} + +SalInstance::SalInstance(std::unique_ptr pMutex) + : m_pYieldMutex(std::move(pMutex)) +{ +} + +SalInstance::~SalInstance() {} + +comphelper::SolarMutex* SalInstance::GetYieldMutex() { return m_pYieldMutex.get(); } + +sal_uInt32 SalInstance::ReleaseYieldMutexAll() { return m_pYieldMutex->release(true); } + +void SalInstance::AcquireYieldMutex(sal_uInt32 nCount) { m_pYieldMutex->acquire(nCount); } + +std::unique_ptr SalInstance::CreateSalSession() { return nullptr; } + +std::unique_ptr SalInstance::CreateMenu(bool, Menu*) +{ + // default: no native menus + return nullptr; +} + +std::unique_ptr SalInstance::CreateMenuItem(const SalItemParams&) { return nullptr; } + +bool SalInstance::CallEventCallback(void const* pEvent, int nBytes) +{ + return m_pEventInst.is() && m_pEventInst->dispatchEvent(pEvent, nBytes); +} + +SalTimer::~SalTimer() COVERITY_NOEXCEPT_FALSE {} + +void SalBitmap::DropScaledCache() +{ + if (ImplSVData* pSVData = ImplGetSVData()) + { + auto& rCache = pSVData->maGDIData.maScaleCache; + + rCache.remove_if([this] (const lru_scale_cache::key_value_pair_t& rKeyValuePair) + { return rKeyValuePair.first.mpBitmap == this; }); + } +} + +SalBitmap::~SalBitmap() { DropScaledCache(); } + +SalSystem::~SalSystem() {} + +SalPrinter::~SalPrinter() {} + +bool SalPrinter::StartJob(const OUString*, const OUString&, const OUString&, ImplJobSetup*, + vcl::PrinterController&) +{ + return false; +} + +SalInfoPrinter::~SalInfoPrinter() {} + +SalVirtualDevice::~SalVirtualDevice() {} + +SalObject::~SalObject() {} + +SalMenu::~SalMenu() {} + +bool SalMenu::ShowNativePopupMenu(FloatingWindow*, const tools::Rectangle&, FloatWinPopupFlags) +{ + return false; +} + +void SalMenu::ShowCloseButton(bool) {} + +bool SalMenu::AddMenuBarButton(const SalMenuButtonItem&) { return false; } + +void SalMenu::RemoveMenuBarButton(sal_uInt16) {} + +tools::Rectangle SalMenu::GetMenuBarButtonRectPixel(sal_uInt16, SalFrame*) +{ + return tools::Rectangle(); +} + +int SalMenu::GetMenuBarHeight() const { return 0; } + +void SalMenu::ApplyPersona() {} + +SalMenuItem::~SalMenuItem() {} + +void SalInstanceWidget::ensure_event_listener() +{ + if (!m_bEventListener) + { + m_xWidget->AddEventListener(LINK(this, SalInstanceWidget, EventListener)); + m_bEventListener = true; + } +} + +// we want the ability to mark key events as handled, so use this variant +// for those, we get all keystrokes in this case, so we will need to filter +// them later +void SalInstanceWidget::ensure_key_listener() +{ + if (!m_bKeyEventListener) + { + Application::AddKeyListener(LINK(this, SalInstanceWidget, KeyEventListener)); + m_bKeyEventListener = true; + } +} + +// we want the ability to know about mouse events that happen in our children +// so use this variant, we will need to filter them later +void SalInstanceWidget::ensure_mouse_listener() +{ + if (!m_bMouseEventListener) + { + Application::AddEventListener(LINK(this, SalInstanceWidget, MouseEventListener)); + m_bMouseEventListener = true; + } +} + +void SalInstanceWidget::set_background(const Color& rColor) +{ + m_xWidget->SetControlBackground(rColor); + m_xWidget->SetBackground(m_xWidget->GetControlBackground()); + // turn off WB_CLIPCHILDREN otherwise the bg won't extend "under" + // transparent children of the widget + m_xWidget->SetStyle(m_xWidget->GetStyle() & ~WB_CLIPCHILDREN); +} + +SalInstanceWidget::SalInstanceWidget(vcl::Window* pWidget, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : m_xWidget(pWidget) + , m_pBuilder(pBuilder) + , m_bTakeOwnership(bTakeOwnership) + , m_bEventListener(false) + , m_bKeyEventListener(false) + , m_bMouseEventListener(false) + , m_nBlockNotify(0) +{ +} + +void SalInstanceWidget::set_sensitive(bool sensitive) { m_xWidget->Enable(sensitive); } + +bool SalInstanceWidget::get_sensitive() const { return m_xWidget->IsEnabled(); } + +bool SalInstanceWidget::get_visible() const { return m_xWidget->IsVisible(); } + +bool SalInstanceWidget::is_visible() const { return m_xWidget->IsReallyVisible(); } + +void SalInstanceWidget::set_can_focus(bool bCanFocus) +{ + auto nStyle = m_xWidget->GetStyle() & ~(WB_TABSTOP | WB_NOTABSTOP); + if (bCanFocus) + nStyle |= WB_TABSTOP; + else + nStyle |= WB_NOTABSTOP; + m_xWidget->SetStyle(nStyle); +} + +void SalInstanceWidget::grab_focus() { m_xWidget->GrabFocus(); } + +bool SalInstanceWidget::has_focus() const { return m_xWidget->HasFocus(); } + +bool SalInstanceWidget::is_active() const { return m_xWidget->IsActive(); } + +void SalInstanceWidget::set_has_default(bool has_default) +{ + m_xWidget->set_property("has-default", OUString::boolean(has_default)); +} + +bool SalInstanceWidget::get_has_default() const { return m_xWidget->GetStyle() & WB_DEFBUTTON; } + +void SalInstanceWidget::show() { m_xWidget->Show(); } + +void SalInstanceWidget::hide() { m_xWidget->Hide(); } + +void SalInstanceWidget::set_size_request(int nWidth, int nHeight) +{ + m_xWidget->set_width_request(nWidth); + m_xWidget->set_height_request(nHeight); +} + +Size SalInstanceWidget::get_size_request() const +{ + return Size(m_xWidget->get_width_request(), m_xWidget->get_height_request()); +} + +Size SalInstanceWidget::get_preferred_size() const { return m_xWidget->get_preferred_size(); } + +float SalInstanceWidget::get_approximate_digit_width() const +{ + return m_xWidget->approximate_digit_width(); +} + +int SalInstanceWidget::get_text_height() const { return m_xWidget->GetTextHeight(); } + +Size SalInstanceWidget::get_pixel_size(const OUString& rText) const +{ + //TODO, or do I want GetTextBoundRect ?, just using width at the moment anyway + return Size(m_xWidget->GetTextWidth(rText), m_xWidget->GetTextHeight()); +} + +vcl::Font SalInstanceWidget::get_font() { return m_xWidget->GetPointFont(*m_xWidget); } + +OString SalInstanceWidget::get_buildable_name() const { return m_xWidget->get_id().toUtf8(); } + +void SalInstanceWidget::set_help_id(const OString& rId) { return m_xWidget->SetHelpId(rId); } + +OString SalInstanceWidget::get_help_id() const { return m_xWidget->GetHelpId(); } + +void SalInstanceWidget::set_grid_left_attach(int nAttach) +{ + m_xWidget->set_grid_left_attach(nAttach); +} + +int SalInstanceWidget::get_grid_left_attach() const { return m_xWidget->get_grid_left_attach(); } + +void SalInstanceWidget::set_grid_width(int nCols) { m_xWidget->set_grid_width(nCols); } + +void SalInstanceWidget::set_grid_top_attach(int nAttach) +{ + m_xWidget->set_grid_top_attach(nAttach); +} + +int SalInstanceWidget::get_grid_top_attach() const { return m_xWidget->get_grid_top_attach(); } + +void SalInstanceWidget::set_hexpand(bool bExpand) { m_xWidget->set_hexpand(bExpand); } + +bool SalInstanceWidget::get_hexpand() const { return m_xWidget->get_hexpand(); } + +void SalInstanceWidget::set_vexpand(bool bExpand) { m_xWidget->set_vexpand(bExpand); } + +bool SalInstanceWidget::get_vexpand() const { return m_xWidget->get_vexpand(); } + +void SalInstanceWidget::set_secondary(bool bSecondary) { m_xWidget->set_secondary(bSecondary); } + +void SalInstanceWidget::set_margin_top(int nMargin) { m_xWidget->set_margin_top(nMargin); } + +void SalInstanceWidget::set_margin_bottom(int nMargin) { m_xWidget->set_margin_bottom(nMargin); } + +void SalInstanceWidget::set_margin_left(int nMargin) { m_xWidget->set_margin_left(nMargin); } + +void SalInstanceWidget::set_margin_right(int nMargin) { m_xWidget->set_margin_bottom(nMargin); } + +int SalInstanceWidget::get_margin_top() const { return m_xWidget->get_margin_top(); } + +int SalInstanceWidget::get_margin_bottom() const { return m_xWidget->get_margin_bottom(); } + +int SalInstanceWidget::get_margin_left() const { return m_xWidget->get_margin_left(); } + +int SalInstanceWidget::get_margin_right() const { return m_xWidget->get_margin_bottom(); } + +void SalInstanceWidget::set_accessible_name(const OUString& rName) +{ + m_xWidget->SetAccessibleName(rName); +} + +OUString SalInstanceWidget::get_accessible_name() const { return m_xWidget->GetAccessibleName(); } + +OUString SalInstanceWidget::get_accessible_description() const +{ + return m_xWidget->GetAccessibleDescription(); +} + +void SalInstanceWidget::set_accessible_relation_labeled_by(weld::Widget* pLabel) +{ + vcl::Window* pAtkLabel + = pLabel ? dynamic_cast(*pLabel).getWidget() : nullptr; + m_xWidget->SetAccessibleRelationLabeledBy(pAtkLabel); +} + +void SalInstanceWidget::set_accessible_relation_label_for(weld::Widget* pLabeled) +{ + vcl::Window* pAtkLabeled + = pLabeled ? dynamic_cast(*pLabeled).getWidget() : nullptr; + m_xWidget->SetAccessibleRelationLabelFor(pAtkLabeled); +} + +void SalInstanceWidget::set_tooltip_text(const OUString& rTip) +{ + m_xWidget->SetQuickHelpText(rTip); +} + +OUString SalInstanceWidget::get_tooltip_text() const { return m_xWidget->GetQuickHelpText(); } + +void SalInstanceWidget::connect_focus_in(const Link& rLink) +{ + ensure_event_listener(); + weld::Widget::connect_focus_in(rLink); +} + +void SalInstanceWidget::connect_mnemonic_activate(const Link& rLink) +{ + m_xWidget->SetMnemonicActivateHdl(LINK(this, SalInstanceWidget, MnemonicActivateHdl)); + weld::Widget::connect_mnemonic_activate(rLink); +} + +void SalInstanceWidget::connect_focus_out(const Link& rLink) +{ + ensure_event_listener(); + weld::Widget::connect_focus_out(rLink); +} + +void SalInstanceWidget::connect_size_allocate(const Link& rLink) +{ + ensure_event_listener(); + weld::Widget::connect_size_allocate(rLink); +} + +void SalInstanceWidget::connect_mouse_press(const Link& rLink) +{ + ensure_mouse_listener(); + weld::Widget::connect_mouse_press(rLink); +} + +void SalInstanceWidget::connect_mouse_move(const Link& rLink) +{ + ensure_mouse_listener(); + weld::Widget::connect_mouse_move(rLink); +} + +void SalInstanceWidget::connect_mouse_release(const Link& rLink) +{ + ensure_mouse_listener(); + weld::Widget::connect_mouse_release(rLink); +} + +void SalInstanceWidget::connect_key_press(const Link& rLink) +{ + ensure_key_listener(); + weld::Widget::connect_key_press(rLink); +} + +void SalInstanceWidget::connect_key_release(const Link& rLink) +{ + ensure_key_listener(); + weld::Widget::connect_key_release(rLink); +} + +bool SalInstanceWidget::get_extents_relative_to(Widget& rRelative, int& x, int& y, int& width, + int& height) +{ + tools::Rectangle aRect(m_xWidget->GetWindowExtentsRelative( + dynamic_cast(rRelative).getWidget())); + x = aRect.Left(); + y = aRect.Top(); + width = aRect.GetWidth(); + height = aRect.GetHeight(); + return true; +} + +void SalInstanceWidget::grab_add() { m_xWidget->CaptureMouse(); } + +bool SalInstanceWidget::has_grab() const { return m_xWidget->IsMouseCaptured(); } + +void SalInstanceWidget::grab_remove() { m_xWidget->ReleaseMouse(); } + +bool SalInstanceWidget::get_direction() const { return m_xWidget->IsRTLEnabled(); } + +void SalInstanceWidget::set_direction(bool bRTL) { m_xWidget->EnableRTL(bRTL); } + +void SalInstanceWidget::freeze() { m_xWidget->SetUpdateMode(false); } + +void SalInstanceWidget::thaw() { m_xWidget->SetUpdateMode(true); } + +SalInstanceWidget::~SalInstanceWidget() +{ + if (m_aMnemonicActivateHdl.IsSet()) + m_xWidget->SetMnemonicActivateHdl(Link()); + if (m_bMouseEventListener) + Application::RemoveEventListener(LINK(this, SalInstanceWidget, MouseEventListener)); + if (m_bKeyEventListener) + Application::RemoveKeyListener(LINK(this, SalInstanceWidget, KeyEventListener)); + if (m_bEventListener) + m_xWidget->RemoveEventListener(LINK(this, SalInstanceWidget, EventListener)); + if (m_bTakeOwnership) + m_xWidget.disposeAndClear(); +} + +vcl::Window* SalInstanceWidget::getWidget() { return m_xWidget; } + +void SalInstanceWidget::disable_notify_events() { ++m_nBlockNotify; } + +bool SalInstanceWidget::notify_events_disabled() { return m_nBlockNotify != 0; } + +void SalInstanceWidget::enable_notify_events() { --m_nBlockNotify; } + +OUString SalInstanceWidget::strip_mnemonic(const OUString& rLabel) const +{ + return rLabel.replaceFirst("~", ""); +} + +VclPtr SalInstanceWidget::create_virtual_device() const +{ + // create with (annoying) separate alpha layer that LibreOffice itself uses + return VclPtr::Create(*Application::GetDefaultDevice(), DeviceFormat::DEFAULT, + DeviceFormat::DEFAULT); +} + +css::uno::Reference SalInstanceWidget::get_drop_target() +{ + return m_xWidget->GetDropTarget(); +} + +void SalInstanceWidget::connect_get_property_tree( + const Link& rLink) +{ + m_xWidget->SetDumpAsPropertyTreeHdl(rLink); +} + +void SalInstanceWidget::set_stack_background() +{ + set_background(m_xWidget->GetSettings().GetStyleSettings().GetWindowColor()); +} + +void SalInstanceWidget::set_toolbar_background() +{ + m_xWidget->SetBackground(); + m_xWidget->SetPaintTransparent(true); +} + +void SalInstanceWidget::set_highlight_background() +{ + set_background(m_xWidget->GetSettings().GetStyleSettings().GetHighlightColor()); +} + +SystemWindow* SalInstanceWidget::getSystemWindow() { return m_xWidget->GetSystemWindow(); } + +void SalInstanceWidget::HandleEventListener(VclWindowEvent& rEvent) +{ + if (rEvent.GetId() == VclEventId::WindowGetFocus) + m_aFocusInHdl.Call(*this); + else if (rEvent.GetId() == VclEventId::WindowLoseFocus) + m_aFocusOutHdl.Call(*this); + else if (rEvent.GetId() == VclEventId::WindowResize) + m_aSizeAllocateHdl.Call(m_xWidget->GetSizePixel()); +} + +void SalInstanceWidget::HandleMouseEventListener(VclSimpleEvent& rEvent) +{ + if (rEvent.GetId() == VclEventId::WindowMouseButtonDown) + { + auto& rWinEvent = static_cast(rEvent); + if (m_xWidget->IsWindowOrChild(rWinEvent.GetWindow())) + { + const MouseEvent* pMouseEvent = static_cast(rWinEvent.GetData()); + m_aMousePressHdl.Call(*pMouseEvent); + } + } + else if (rEvent.GetId() == VclEventId::WindowMouseButtonUp) + { + auto& rWinEvent = static_cast(rEvent); + if (m_xWidget->IsWindowOrChild(rWinEvent.GetWindow())) + { + const MouseEvent* pMouseEvent = static_cast(rWinEvent.GetData()); + m_aMouseReleaseHdl.Call(*pMouseEvent); + } + } + else if (rEvent.GetId() == VclEventId::WindowMouseMove) + { + auto& rWinEvent = static_cast(rEvent); + if (m_xWidget->IsWindowOrChild(rWinEvent.GetWindow())) + { + const MouseEvent* pMouseEvent = static_cast(rWinEvent.GetData()); + m_aMouseMotionHdl.Call(*pMouseEvent); + } + } +} + +bool SalInstanceWidget::HandleKeyEventListener(VclWindowEvent& rEvent) +{ + // we get all key events here, ignore them unless we have focus + if (!has_focus()) + return false; + if (rEvent.GetId() == VclEventId::WindowKeyInput) + { + const KeyEvent* pKeyEvent = static_cast(rEvent.GetData()); + return m_aKeyPressHdl.Call(*pKeyEvent); + } + else if (rEvent.GetId() == VclEventId::WindowKeyUp) + { + const KeyEvent* pKeyEvent = static_cast(rEvent.GetData()); + return m_aKeyReleaseHdl.Call(*pKeyEvent); + } + return false; +} + +IMPL_LINK(SalInstanceWidget, EventListener, VclWindowEvent&, rEvent, void) +{ + HandleEventListener(rEvent); +} + +IMPL_LINK(SalInstanceWidget, KeyEventListener, VclWindowEvent&, rEvent, bool) +{ + return HandleKeyEventListener(rEvent); +} + +IMPL_LINK(SalInstanceWidget, MouseEventListener, VclSimpleEvent&, rEvent, void) +{ + HandleMouseEventListener(rEvent); +} + +IMPL_LINK_NOARG(SalInstanceWidget, MnemonicActivateHdl, vcl::Window&, bool) +{ + return m_aMnemonicActivateHdl.Call(*this); +} + +namespace +{ +Image createImage(const OUString& rImage) +{ + if (rImage.isEmpty()) + return Image(); + if (rImage.lastIndexOf('.') != rImage.getLength() - 4) + { + assert((rImage == "dialog-warning" || rImage == "dialog-error" + || rImage == "dialog-information") + && "unknown stock image"); + if (rImage == "dialog-warning") + return Image(StockImage::Yes, IMG_WARN); + else if (rImage == "dialog-error") + return Image(StockImage::Yes, IMG_ERROR); + else if (rImage == "dialog-information") + return Image(StockImage::Yes, IMG_INFO); + } + return Image(StockImage::Yes, rImage); +} + +Image createImage(const VirtualDevice& rDevice) +{ + return Image(rDevice.GetBitmapEx(Point(), rDevice.GetOutputSizePixel())); +} + +sal_uInt16 insert_to_menu(sal_uInt16 nLastId, PopupMenu* pMenu, int pos, const OUString& rId, + const OUString& rStr, const OUString* pIconName, + const VirtualDevice* pImageSurface, TriState eCheckRadioFalse) +{ + const sal_uInt16 nNewid = nLastId + 1; + + MenuItemBits nBits; + if (eCheckRadioFalse == TRISTATE_TRUE) + nBits = MenuItemBits::CHECKABLE; + else if (eCheckRadioFalse == TRISTATE_FALSE) + nBits = MenuItemBits::CHECKABLE | MenuItemBits::RADIOCHECK; + else + nBits = MenuItemBits::NONE; + + pMenu->InsertItem(nNewid, rStr, nBits, + OUStringToOString(rId, RTL_TEXTENCODING_UTF8), pos == -1 ? MENU_APPEND : pos); + if (pIconName) + { + pMenu->SetItemImage(nNewid, createImage(*pIconName)); + } + else if (pImageSurface) + { + pMenu->SetItemImage(nNewid, createImage(*pImageSurface)); + } + return nNewid; +} +} + +SalInstanceMenu::SalInstanceMenu(PopupMenu* pMenu, bool bTakeOwnership) + : m_xMenu(pMenu) + , m_bTakeOwnership(bTakeOwnership) +{ + const auto nCount = m_xMenu->GetItemCount(); + m_nLastId = nCount ? pMenu->GetItemId(nCount - 1) : 0; + m_xMenu->SetSelectHdl(LINK(this, SalInstanceMenu, SelectMenuHdl)); +} +OString SalInstanceMenu::popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect) +{ + SalInstanceWidget* pVclWidget = dynamic_cast(pParent); + assert(pVclWidget); + m_xMenu->Execute(pVclWidget->getWidget(), rRect, + PopupMenuFlags::ExecuteDown | PopupMenuFlags::NoMouseUpClose); + return m_xMenu->GetCurItemIdent(); +} +void SalInstanceMenu::set_sensitive(const OString& rIdent, bool bSensitive) +{ + m_xMenu->EnableItem(rIdent, bSensitive); +} +void SalInstanceMenu::set_active(const OString& rIdent, bool bActive) +{ + m_xMenu->CheckItem(rIdent, bActive); +} +bool SalInstanceMenu::get_active(const OString& rIdent) const +{ + return m_xMenu->IsItemChecked(m_xMenu->GetItemId(rIdent)); +} +void SalInstanceMenu::set_label(const OString& rIdent, const OUString& rLabel) +{ + m_xMenu->SetItemText(m_xMenu->GetItemId(rIdent), rLabel); +} +OUString SalInstanceMenu::get_label(const OString& rIdent) const +{ + return m_xMenu->GetItemText(m_xMenu->GetItemId(rIdent)); +} +void SalInstanceMenu::set_visible(const OString& rIdent, bool bShow) +{ + m_xMenu->ShowItem(m_xMenu->GetItemId(rIdent), bShow); +} +void SalInstanceMenu::clear() { m_xMenu->Clear(); } +void SalInstanceMenu::insert(int pos, const OUString& rId, const OUString& rStr, + const OUString* pIconName, VirtualDevice* pImageSurface, + TriState eCheckRadioFalse) +{ + m_nLastId + = insert_to_menu(m_nLastId, m_xMenu, pos, rId, rStr, pIconName, pImageSurface, eCheckRadioFalse); +} +void SalInstanceMenu::insert_separator(int pos, const OUString& rId) +{ + auto nInsertPos = pos == -1 ? MENU_APPEND : pos; + m_xMenu->InsertSeparator(rId.toUtf8(), nInsertPos); +} +void SalInstanceMenu::remove(const OString& rId) +{ + m_xMenu->RemoveItem(m_xMenu->GetItemPos(m_xMenu->GetItemId(rId))); +} +int SalInstanceMenu::n_children() const { return m_xMenu->GetItemCount(); } +PopupMenu* SalInstanceMenu::getMenu() const { return m_xMenu.get(); } +SalInstanceMenu::~SalInstanceMenu() +{ + m_xMenu->SetSelectHdl(Link<::Menu*, bool>()); + if (m_bTakeOwnership) + m_xMenu.disposeAndClear(); +} + +IMPL_LINK_NOARG(SalInstanceMenu, SelectMenuHdl, ::Menu*, bool) +{ + signal_activate(m_xMenu->GetCurItemIdent()); + /* tdf#131333 Menu::Select depends on a false here to allow + propagating a submens's selected id to its parent menu to become its + selected id. + + without this, while gen menus already have propagated this to its parent + in MenuFloatingWindow::EndExecute, SalMenus as used under kf5/macOS + won't propagate the selected id + */ + return false; +} + +namespace +{ +class SalInstanceToolbar : public SalInstanceWidget, public virtual weld::Toolbar +{ +private: + VclPtr m_xToolBox; + std::map> m_aFloats; + std::map> m_aMenus; + + OString m_sStartShowIdent; + + DECL_LINK(ClickHdl, ToolBox*, void); + DECL_LINK(DropdownClick, ToolBox*, void); + DECL_LINK(MenuToggleListener, VclWindowEvent&, void); + +public: + SalInstanceToolbar(ToolBox* pToolBox, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceWidget(pToolBox, pBuilder, bTakeOwnership) + , m_xToolBox(pToolBox) + { + m_xToolBox->SetSelectHdl(LINK(this, SalInstanceToolbar, ClickHdl)); + m_xToolBox->SetDropdownClickHdl(LINK(this, SalInstanceToolbar, DropdownClick)); + } + + virtual void set_item_sensitive(const OString& rIdent, bool bSensitive) override + { + m_xToolBox->EnableItem(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), bSensitive); + } + + virtual bool get_item_sensitive(const OString& rIdent) const override + { + return m_xToolBox->IsItemEnabled(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent))); + } + + virtual void set_item_visible(const OString& rIdent, bool bVisible) override + { + m_xToolBox->ShowItem(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), bVisible); + } + + virtual void set_item_help_id(const OString& rIdent, const OString& rHelpId) override + { + m_xToolBox->SetHelpId(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), rHelpId); + } + + virtual bool get_item_visible(const OString& rIdent) const override + { + return m_xToolBox->IsItemVisible(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent))); + } + + virtual void set_item_active(const OString& rIdent, bool bActive) override + { + sal_uInt16 nItemId = m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)); + m_xToolBox->CheckItem(nItemId, bActive); + } + + virtual bool get_item_active(const OString& rIdent) const override + { + return m_xToolBox->IsItemChecked(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent))); + } + + void set_menu_item_active(const OString& rIdent, bool bActive) override + { + sal_uInt16 nItemId = m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)); + assert(m_xToolBox->GetItemBits(nItemId) & ToolBoxItemBits::DROPDOWN); + + if (bActive) + { + m_sStartShowIdent = m_xToolBox->GetItemCommand(nItemId).toUtf8(); + signal_toggle_menu(m_sStartShowIdent); + } + + auto pFloat = m_aFloats[nItemId]; + if (pFloat) + { + if (bActive) + vcl::Window::GetDockingManager()->StartPopupMode(m_xToolBox, pFloat, + FloatWinPopupFlags::GrabFocus); + else + vcl::Window::GetDockingManager()->EndPopupMode(pFloat); + } + auto pPopup = m_aMenus[nItemId]; + if (pPopup) + { + if (bActive) + { + tools::Rectangle aRect = m_xToolBox->GetItemRect(nItemId); + pPopup->Execute(m_xToolBox, aRect, PopupMenuFlags::ExecuteDown); + } + else + pPopup->EndExecute(); + } + + m_sStartShowIdent.clear(); + } + + bool get_menu_item_active(const OString& rIdent) const override + { + sal_uInt16 nItemId = m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)); + assert(m_xToolBox->GetItemBits(nItemId) & ToolBoxItemBits::DROPDOWN); + + if (rIdent == m_sStartShowIdent) + return true; + + auto aFloat = m_aFloats.find(nItemId); + if (aFloat != m_aFloats.end()) + { + return vcl::Window::GetDockingManager()->IsInPopupMode(aFloat->second); + } + + auto aPopup = m_aMenus.find(nItemId); + if (aPopup != m_aMenus.end()) + { + return PopupMenu::GetActivePopupMenu() == aPopup->second; + } + + return false; + } + + virtual void set_item_popover(const OString& rIdent, weld::Widget* pPopover) override + { + SalInstanceWidget* pPopoverWidget = dynamic_cast(pPopover); + + vcl::Window* pFloat = pPopoverWidget ? pPopoverWidget->getWidget() : nullptr; + if (pFloat) + { + pFloat->AddEventListener(LINK(this, SalInstanceToolbar, MenuToggleListener)); + pFloat->EnableDocking(); + } + + sal_uInt16 nId = m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)); + auto xOldFloat = m_aFloats[nId]; + if (xOldFloat) + { + xOldFloat->RemoveEventListener(LINK(this, SalInstanceToolbar, MenuToggleListener)); + } + m_aFloats[nId] = pFloat; + m_aMenus[nId] = nullptr; + } + + virtual void set_item_menu(const OString& rIdent, weld::Menu* pMenu) override + { + SalInstanceMenu* pInstanceMenu = dynamic_cast(pMenu); + + PopupMenu* pPopup = pInstanceMenu ? pInstanceMenu->getMenu() : nullptr; + + sal_uInt16 nId = m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)); + m_aMenus[nId] = pPopup; + m_aFloats[nId] = nullptr; + } + + virtual void insert_separator(int pos, const OUString& /*rId*/) override + { + auto nInsertPos = pos == -1 ? ToolBox::APPEND : pos; + m_xToolBox->InsertSeparator(nInsertPos, 5); + } + + virtual int get_n_items() const override { return m_xToolBox->GetItemCount(); } + + virtual OString get_item_ident(int nIndex) const override + { + return m_xToolBox->GetItemCommand(m_xToolBox->GetItemId(nIndex)).toUtf8(); + } + + virtual void set_item_ident(int nIndex, const OString& rIdent) override + { + return m_xToolBox->SetItemCommand(m_xToolBox->GetItemId(nIndex), + OUString::fromUtf8(rIdent)); + } + + virtual void set_item_label(int nIndex, const OUString& rLabel) override + { + m_xToolBox->SetItemText(m_xToolBox->GetItemId(nIndex), rLabel); + } + + virtual OUString get_item_label(const OString& rIdent) const override + { + return m_xToolBox->GetItemText(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent))); + } + + virtual void set_item_label(const OString& rIdent, const OUString& rLabel) override + { + m_xToolBox->SetItemText(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), rLabel); + } + + virtual void set_item_icon_name(const OString& rIdent, const OUString& rIconName) override + { + m_xToolBox->SetItemImage(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), + Image(StockImage::Yes, rIconName)); + } + + virtual void set_item_image(const OString& rIdent, + const css::uno::Reference& rIcon) override + { + m_xToolBox->SetItemImage(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), Image(rIcon)); + } + + virtual void set_item_image(const OString& rIdent, VirtualDevice* pDevice) override + { + if (pDevice) + m_xToolBox->SetItemImage(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), + createImage(*pDevice)); + else + m_xToolBox->SetItemImage(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), Image()); + } + + virtual void set_item_image(int nIndex, + const css::uno::Reference& rIcon) override + { + m_xToolBox->SetItemImage(m_xToolBox->GetItemId(nIndex), Image(rIcon)); + } + + virtual void set_item_tooltip_text(int nIndex, const OUString& rTip) override + { + m_xToolBox->SetQuickHelpText(m_xToolBox->GetItemId(nIndex), rTip); + } + + virtual void set_item_tooltip_text(const OString& rIdent, const OUString& rTip) override + { + m_xToolBox->SetQuickHelpText(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent)), rTip); + } + + virtual OUString get_item_tooltip_text(const OString& rIdent) const override + { + return m_xToolBox->GetQuickHelpText(m_xToolBox->GetItemId(OUString::fromUtf8(rIdent))); + } + + virtual vcl::ImageType get_icon_size() const override { return m_xToolBox->GetImageSize(); } + + virtual void set_icon_size(vcl::ImageType eType) override + { + ToolBoxButtonSize eButtonSize = ToolBoxButtonSize::DontCare; + switch (eType) + { + case vcl::ImageType::Size16: + eButtonSize = ToolBoxButtonSize::Small; + break; + case vcl::ImageType::Size26: + eButtonSize = ToolBoxButtonSize::Large; + break; + case vcl::ImageType::Size32: + eButtonSize = ToolBoxButtonSize::Size32; + break; + } + if (m_xToolBox->GetToolboxButtonSize() != eButtonSize) + { + m_xToolBox->SetToolboxButtonSize(eButtonSize); + m_xToolBox->queue_resize(); + } + } + + virtual sal_uInt16 get_modifier_state() const override + { + return m_xToolBox->GetModifier(); + } + + int get_drop_index(const Point& rPoint) const override + { + auto nRet = m_xToolBox->GetItemPos(rPoint); + if (nRet == ToolBox::ITEM_NOTFOUND) + return 0; + return nRet; + } + + virtual ~SalInstanceToolbar() override + { + m_xToolBox->SetDropdownClickHdl(Link()); + m_xToolBox->SetSelectHdl(Link()); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceToolbar, ClickHdl, ToolBox*, void) +{ + sal_uInt16 nItemId = m_xToolBox->GetCurItemId(); + signal_clicked(m_xToolBox->GetItemCommand(nItemId).toUtf8()); +} + +IMPL_LINK_NOARG(SalInstanceToolbar, DropdownClick, ToolBox*, void) +{ + sal_uInt16 nItemId = m_xToolBox->GetCurItemId(); + set_menu_item_active(m_xToolBox->GetItemCommand(nItemId).toUtf8(), true); +} + +IMPL_LINK(SalInstanceToolbar, MenuToggleListener, VclWindowEvent&, rEvent, void) +{ + if (rEvent.GetId() == VclEventId::WindowEndPopupMode) + { + for (auto& rFloat : m_aFloats) + { + if (rEvent.GetWindow() == rFloat.second) + { + sal_uInt16 nItemId = rFloat.first; + signal_toggle_menu(m_xToolBox->GetItemCommand(nItemId).toUtf8()); + break; + } + } + } +} + +namespace +{ +class SalInstanceSizeGroup : public weld::SizeGroup +{ +private: + std::shared_ptr m_xGroup; + +public: + SalInstanceSizeGroup() + : m_xGroup(std::make_shared()) + { + } + virtual void add_widget(weld::Widget* pWidget) override + { + SalInstanceWidget* pVclWidget = dynamic_cast(pWidget); + assert(pVclWidget && pVclWidget->getWidget()); + pVclWidget->getWidget()->add_to_size_group(m_xGroup); + } + virtual void set_mode(VclSizeGroupMode eMode) override { m_xGroup->set_mode(eMode); } +}; +} + +void SalInstanceContainer::implResetDefault(const vcl::Window* _pWindow) +{ + vcl::Window* pChildLoop = _pWindow->GetWindow(GetWindowType::FirstChild); + while (pChildLoop) + { + // does the window participate in the tabbing order? + if (pChildLoop->GetStyle() & WB_DIALOGCONTROL) + implResetDefault(pChildLoop); + + // is it a button? + WindowType eType = pChildLoop->GetType(); + if ((WindowType::PUSHBUTTON == eType) || (WindowType::OKBUTTON == eType) + || (WindowType::CANCELBUTTON == eType) || (WindowType::HELPBUTTON == eType) + || (WindowType::IMAGEBUTTON == eType) || (WindowType::MENUBUTTON == eType) + || (WindowType::MOREBUTTON == eType)) + { + pChildLoop->SetStyle(pChildLoop->GetStyle() & ~WB_DEFBUTTON); + } + + // the next one ... + pChildLoop = pChildLoop->GetWindow(GetWindowType::Next); + } +} + +SalInstanceContainer::SalInstanceContainer(vcl::Window* pContainer, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceWidget(pContainer, pBuilder, bTakeOwnership) + , m_xContainer(pContainer) +{ +} + +void SalInstanceContainer::move(weld::Widget* pWidget, weld::Container* pNewParent) +{ + SalInstanceWidget* pVclWidget = dynamic_cast(pWidget); + assert(pVclWidget); + SalInstanceContainer* pNewVclParent = dynamic_cast(pNewParent); + assert(!pNewParent || pNewVclParent); + if (pNewVclParent) + pVclWidget->getWidget()->SetParent(pNewVclParent->getWidget()); + else + pVclWidget->getWidget()->SetParentToDefaultWindow(); +} + +void SalInstanceContainer::recursively_unset_default_buttons() +{ + implResetDefault(m_xContainer.get()); +} + +css::uno::Reference SalInstanceContainer::CreateChildFrame() +{ + auto xPage = VclPtr::Create(m_xContainer.get()); + xPage->set_expand(true); + xPage->Show(); + return css::uno::Reference(xPage->GetComponentInterface(), + css::uno::UNO_QUERY); +} + +std::unique_ptr SalInstanceWidget::weld_parent() const +{ + vcl::Window* pParent = m_xWidget->GetParent(); + if (!pParent) + return nullptr; + return std::make_unique(pParent, m_pBuilder, false); +} + +void SalInstanceWidget::draw(VirtualDevice& rOutput) +{ + rOutput.SetOutputSizePixel(m_xWidget->GetSizePixel()); + m_xWidget->PaintToDevice(&rOutput, Point()); +} + +namespace +{ +class SalInstanceBox : public SalInstanceContainer, public virtual weld::Box +{ +public: + SalInstanceBox(vcl::Window* pContainer, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pContainer, pBuilder, bTakeOwnership) + { + } + virtual void reorder_child(weld::Widget* pWidget, int nNewPosition) override + { + SalInstanceWidget* pVclWidget = dynamic_cast(pWidget); + assert(pVclWidget); + pVclWidget->getWidget()->reorderWithinParent(nNewPosition); + } +}; + +void CollectChildren(const vcl::Window& rCurrent, const basegfx::B2IPoint& rTopLeft, + weld::ScreenShotCollection& rControlDataCollection) +{ + if (rCurrent.IsVisible()) + { + const Point aCurrentPos(rCurrent.GetPosPixel()); + const Size aCurrentSize(rCurrent.GetSizePixel()); + const basegfx::B2IPoint aCurrentTopLeft(rTopLeft.getX() + aCurrentPos.X(), + rTopLeft.getY() + aCurrentPos.Y()); + const basegfx::B2IRange aCurrentRange( + aCurrentTopLeft, + aCurrentTopLeft + basegfx::B2IPoint(aCurrentSize.Width(), aCurrentSize.Height())); + + if (!aCurrentRange.isEmpty()) + { + rControlDataCollection.emplace_back(rCurrent.GetHelpId(), aCurrentRange); + } + + for (sal_uInt16 a(0); a < rCurrent.GetChildCount(); a++) + { + vcl::Window* pChild = rCurrent.GetChild(a); + if (nullptr != pChild) + { + CollectChildren(*pChild, aCurrentTopLeft, rControlDataCollection); + } + } + } +} + +} + +void SalInstanceWindow::override_child_help(vcl::Window* pParent) +{ + for (vcl::Window* pChild = pParent->GetWindow(GetWindowType::FirstChild); pChild; + pChild = pChild->GetWindow(GetWindowType::Next)) + override_child_help(pChild); + pParent->SetHelpHdl(LINK(this, SalInstanceWindow, HelpHdl)); +} + +void SalInstanceWindow::clear_child_help(vcl::Window* pParent) +{ + for (vcl::Window* pChild = pParent->GetWindow(GetWindowType::FirstChild); pChild; + pChild = pChild->GetWindow(GetWindowType::Next)) + clear_child_help(pChild); + pParent->SetHelpHdl(Link()); +} + +SalInstanceWindow::SalInstanceWindow(vcl::Window* pWindow, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceContainer(pWindow, pBuilder, bTakeOwnership) + , m_xWindow(pWindow) +{ + override_child_help(m_xWindow); +} + +void SalInstanceWindow::set_title(const OUString& rTitle) { m_xWindow->SetText(rTitle); } + +OUString SalInstanceWindow::get_title() const { return m_xWindow->GetText(); } + +void SalInstanceWindow::set_busy_cursor(bool bBusy) +{ + if (bBusy) + m_xWindow->EnterWait(); + else + m_xWindow->LeaveWait(); +} + +css::uno::Reference SalInstanceWindow::GetXWindow() +{ + css::uno::Reference xWindow(m_xWindow->GetComponentInterface(), + css::uno::UNO_QUERY); + return xWindow; +} + +void SalInstanceWindow::resize_to_request() +{ + if (SystemWindow* pSysWin = dynamic_cast(m_xWindow.get())) + { + pSysWin->setOptimalLayoutSize(); + return; + } + if (DockingWindow* pDockWin = dynamic_cast(m_xWindow.get())) + { + pDockWin->setOptimalLayoutSize(); + return; + } + assert(false && "must be system or docking window"); +} + +void SalInstanceWindow::set_modal(bool bModal) { m_xWindow->ImplGetFrame()->SetModal(bModal); } + +bool SalInstanceWindow::get_modal() const { return m_xWindow->ImplGetFrame()->GetModal(); } + +void SalInstanceWindow::window_move(int x, int y) { m_xWindow->SetPosPixel(Point(x, y)); } + +Size SalInstanceWindow::get_size() const { return m_xWindow->GetSizePixel(); } + +Point SalInstanceWindow::get_position() const { return m_xWindow->GetPosPixel(); } + +tools::Rectangle SalInstanceWindow::get_monitor_workarea() const +{ + return m_xWindow->GetDesktopRectPixel(); +} + +void SalInstanceWindow::set_centered_on_parent(bool /*bTrackGeometryRequests*/) +{ + if (vcl::Window* pParent = m_xWidget->GetParent()) + { + Size aParentGeometry(pParent->GetSizePixel()); + Size aGeometry(m_xWidget->get_preferred_size()); + auto nX = (aParentGeometry.Width() - aGeometry.Width()) / 2; + auto nY = (aParentGeometry.Height() - aGeometry.Height()) / 2; + m_xWidget->SetPosPixel(Point(nX, nY)); + } +} + +bool SalInstanceWindow::get_resizable() const { return m_xWindow->GetStyle() & WB_SIZEABLE; } + +bool SalInstanceWindow::has_toplevel_focus() const { return m_xWindow->HasChildPathFocus(); } + +void SalInstanceWindow::present() +{ + m_xWindow->ToTop(ToTopFlags::RestoreWhenMin | ToTopFlags::ForegroundTask); +} + +void SalInstanceWindow::set_window_state(const OString& rStr) +{ + SystemWindow* pSysWin = dynamic_cast(m_xWindow.get()); + assert(pSysWin); + pSysWin->SetWindowState(rStr); +} + +OString SalInstanceWindow::get_window_state(WindowStateMask nMask) const +{ + SystemWindow* pSysWin = dynamic_cast(m_xWindow.get()); + assert(pSysWin); + return pSysWin->GetWindowState(nMask); +} + +SystemEnvData SalInstanceWindow::get_system_data() const { return *m_xWindow->GetSystemData(); } + +void SalInstanceWindow::connect_toplevel_focus_changed(const Link& rLink) +{ + ensure_event_listener(); + weld::Window::connect_toplevel_focus_changed(rLink); +} + +void SalInstanceWindow::HandleEventListener(VclWindowEvent& rEvent) +{ + if (rEvent.GetId() == VclEventId::WindowActivate + || rEvent.GetId() == VclEventId::WindowDeactivate) + { + signal_toplevel_focus_changed(); + return; + } + SalInstanceContainer::HandleEventListener(rEvent); +} + +void SalInstanceWindow::draw(VirtualDevice& rOutput) +{ + SystemWindow* pSysWin = dynamic_cast(m_xWindow.get()); + assert(pSysWin); + pSysWin->createScreenshot(rOutput); +} + +weld::ScreenShotCollection SalInstanceWindow::collect_screenshot_data() +{ + weld::ScreenShotCollection aRet; + + // collect all children. Choose start pos to be negative + // of target dialog's position to get all positions relative to (0,0) + const Point aParentPos(m_xWindow->GetPosPixel()); + const basegfx::B2IPoint aTopLeft(-aParentPos.X(), -aParentPos.Y()); + CollectChildren(*m_xWindow, aTopLeft, aRet); + + return aRet; +} + +SalInstanceWindow::~SalInstanceWindow() { clear_child_help(m_xWindow); } + +IMPL_LINK_NOARG(SalInstanceWindow, HelpHdl, vcl::Window&, bool) +{ + help(); + return false; +} + +typedef std::set> winset; + +namespace +{ +void hideUnless(const vcl::Window* pTop, const winset& rVisibleWidgets, + std::vector>& rWasVisibleWidgets) +{ + for (vcl::Window* pChild = pTop->GetWindow(GetWindowType::FirstChild); pChild; + pChild = pChild->GetWindow(GetWindowType::Next)) + { + if (!pChild->IsVisible()) + continue; + if (rVisibleWidgets.find(pChild) == rVisibleWidgets.end()) + { + rWasVisibleWidgets.emplace_back(pChild); + pChild->Hide(); + } + else if (isContainerWindow(pChild)) + { + hideUnless(pChild, rVisibleWidgets, rWasVisibleWidgets); + } + } +} +} + +SalInstanceDialog::SalInstanceDialog(::Dialog* pDialog, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceWindow(pDialog, pBuilder, bTakeOwnership) + , m_xDialog(pDialog) + , m_nOldEditWidthReq(0) + , m_nOldBorderWidth(0) +{ + const bool bScreenshotMode(officecfg::Office::Common::Misc::ScreenshotMode::get()); + if (bScreenshotMode) + { + m_xDialog->SetPopupMenuHdl(LINK(this, SalInstanceDialog, PopupScreenShotMenuHdl)); + } +} + +bool SalInstanceDialog::runAsync(std::shared_ptr aOwner, + const std::function& rEndDialogFn) +{ + VclAbstractDialog::AsyncContext aCtx; + aCtx.mxOwnerDialogController = aOwner; + aCtx.maEndDialogFn = rEndDialogFn; + VclButtonBox* pActionArea = m_xDialog->get_action_area(); + if (pActionArea) + pActionArea->sort_native_button_order(); + return m_xDialog->StartExecuteAsync(aCtx); +} + +bool SalInstanceDialog::runAsync(std::shared_ptr const& rxSelf, + const std::function& rEndDialogFn) +{ + assert(rxSelf.get() == this); + VclAbstractDialog::AsyncContext aCtx; + // In order to store a shared_ptr to ourself, we have to have been constructed by make_shared, + // which is that rxSelf enforces. + aCtx.mxOwnerSelf = rxSelf; + aCtx.maEndDialogFn = rEndDialogFn; + VclButtonBox* pActionArea = m_xDialog->get_action_area(); + if (pActionArea) + pActionArea->sort_native_button_order(); + return m_xDialog->StartExecuteAsync(aCtx); +} + +void SalInstanceDialog::collapse(weld::Widget* pEdit, weld::Widget* pButton) +{ + SalInstanceWidget* pVclEdit = dynamic_cast(pEdit); + assert(pVclEdit); + SalInstanceWidget* pVclButton = dynamic_cast(pButton); + + vcl::Window* pRefEdit = pVclEdit->getWidget(); + vcl::Window* pRefBtn = pVclButton ? pVclButton->getWidget() : nullptr; + + auto nOldEditWidth = pRefEdit->GetSizePixel().Width(); + m_nOldEditWidthReq = pRefEdit->get_width_request(); + + //We want just pRefBtn and pRefEdit to be shown + //mark widgets we want to be visible, starting with pRefEdit + //and all its direct parents. + winset aVisibleWidgets; + vcl::Window* pContentArea = m_xDialog->get_content_area(); + for (vcl::Window* pCandidate = pRefEdit; + pCandidate && (pCandidate != pContentArea && pCandidate->IsVisible()); + pCandidate = pCandidate->GetWindow(GetWindowType::RealParent)) + { + aVisibleWidgets.insert(pCandidate); + } + //same again with pRefBtn, except stop if there's a + //shared parent in the existing widgets + for (vcl::Window* pCandidate = pRefBtn; + pCandidate && (pCandidate != pContentArea && pCandidate->IsVisible()); + pCandidate = pCandidate->GetWindow(GetWindowType::RealParent)) + { + if (aVisibleWidgets.insert(pCandidate).second) + break; + } + + //hide everything except the aVisibleWidgets + hideUnless(pContentArea, aVisibleWidgets, m_aHiddenWidgets); + + // the insert function case has an initially hidden edit widget, so it has + // not start size, so take larger of actual size and size request + pRefEdit->set_width_request(std::max(nOldEditWidth, m_nOldEditWidthReq)); + m_nOldBorderWidth = m_xDialog->get_border_width(); + m_xDialog->set_border_width(0); + if (vcl::Window* pActionArea = m_xDialog->get_action_area()) + pActionArea->Hide(); + m_xDialog->setOptimalLayoutSize(); + m_xRefEdit = pRefEdit; +} + +void SalInstanceDialog::undo_collapse() +{ + // All others: Show(); + for (VclPtr const& pWindow : m_aHiddenWidgets) + { + pWindow->Show(); + } + m_aHiddenWidgets.clear(); + + m_xRefEdit->set_width_request(m_nOldEditWidthReq); + m_xRefEdit.clear(); + m_xDialog->set_border_width(m_nOldBorderWidth); + if (vcl::Window* pActionArea = m_xDialog->get_action_area()) + pActionArea->Show(); + m_xDialog->setOptimalLayoutSize(); +} + +void SalInstanceDialog::SetInstallLOKNotifierHdl( + const Link& rLink) +{ + m_xDialog->SetInstallLOKNotifierHdl(rLink); +} + +int SalInstanceDialog::run() +{ + VclButtonBox* pActionArea = m_xDialog->get_action_area(); + if (pActionArea) + pActionArea->sort_native_button_order(); + return m_xDialog->Execute(); +} + +void SalInstanceDialog::response(int nResponse) { m_xDialog->EndDialog(nResponse); } + +void SalInstanceDialog::add_button(const OUString& rText, int nResponse, const OString& rHelpId) +{ + VclButtonBox* pBox = m_xDialog->get_action_area(); + VclPtr xButton( + VclPtr::Create(pBox, WB_CLIPCHILDREN | WB_CENTER | WB_VCENTER)); + xButton->SetText(rText); + xButton->SetHelpId(rHelpId); + + switch (nResponse) + { + case RET_OK: + xButton->set_id("ok"); + break; + case RET_CLOSE: + xButton->set_id("close"); + break; + case RET_CANCEL: + xButton->set_id("cancel"); + break; + case RET_YES: + xButton->set_id("yes"); + break; + case RET_NO: + xButton->set_id("no"); + break; + } + + xButton->Show(); + m_xDialog->add_button(xButton, nResponse, true); +} + +void SalInstanceDialog::set_modal(bool bModal) +{ + if (get_modal() == bModal) + return; + m_xDialog->SetModalInputMode(bModal); +} + +bool SalInstanceDialog::get_modal() const { return m_xDialog->IsModalInputMode(); } + +void SalInstanceDialog::set_default_response(int nResponse) +{ + m_xDialog->set_default_response(nResponse); +} + +weld::Container* SalInstanceDialog::weld_content_area() +{ + return new SalInstanceContainer(m_xDialog->get_content_area(), m_pBuilder, false); +} + +IMPL_LINK(SalInstanceDialog, PopupScreenShotMenuHdl, const CommandEvent&, rCEvt, bool) +{ + if (CommandEventId::ContextMenu == rCEvt.GetCommand()) + { + const Point aMenuPos(rCEvt.GetMousePosPixel()); + ScopedVclPtrInstance aMenu; + sal_uInt16 nLocalID(1); + + aMenu->InsertItem(nLocalID, VclResId(SV_BUTTONTEXT_SCREENSHOT)); + aMenu->SetHelpText(nLocalID, VclResId(SV_HELPTEXT_SCREENSHOT)); + aMenu->SetHelpId(nLocalID, "InteractiveScreenshotMode"); + aMenu->EnableItem(nLocalID); + + const sal_uInt16 nId(aMenu->Execute(m_xDialog, aMenuPos)); + + // 0 == no selection (so not usable as ID) + if (0 != nId) + { + // open screenshot annotation dialog + VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create(); + VclPtr pTmp + = pFact->CreateScreenshotAnnotationDlg(*this); + ScopedVclPtr pDialog(pTmp); + + if (pDialog) + { + // currently just execute the dialog, no need to do + // different things for ok/cancel. This may change later, + // for that case use 'if (pDlg->Execute() == RET_OK)' + pDialog->Execute(); + } + } + + // consume event when: + // - CommandEventId::ContextMenu + // - bScreenshotMode + return true; + } + + return false; +} + +SalInstanceMessageDialog::SalInstanceMessageDialog(::MessageDialog* pDialog, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceDialog(pDialog, pBuilder, bTakeOwnership) + , m_xMessageDialog(pDialog) +{ +} + +void SalInstanceMessageDialog::set_primary_text(const OUString& rText) +{ + m_xMessageDialog->set_primary_text(rText); +} + +OUString SalInstanceMessageDialog::get_primary_text() const +{ + return m_xMessageDialog->get_primary_text(); +} + +void SalInstanceMessageDialog::set_secondary_text(const OUString& rText) +{ + m_xMessageDialog->set_secondary_text(rText); +} + +OUString SalInstanceMessageDialog::get_secondary_text() const +{ + return m_xMessageDialog->get_secondary_text(); +} + +weld::Container* SalInstanceMessageDialog::weld_message_area() +{ + return new SalInstanceContainer(m_xMessageDialog->get_message_area(), m_pBuilder, false); +} + +namespace +{ + +class SalInstanceAssistant : public SalInstanceDialog, public virtual weld::Assistant +{ +private: + VclPtr m_xWizard; + std::vector> m_aPages; + std::vector> m_aAddedPages; + std::vector m_aIds; + std::vector> m_aAddedGrids; + Idle m_aUpdateRoadmapIdle; + + int find_page(const OString& rIdent) const + { + for (size_t i = 0; i < m_aAddedPages.size(); ++i) + { + if (m_aAddedPages[i]->get_id().toUtf8() == rIdent) + return i; + } + return -1; + } + + int find_id(int nId) const + { + for (size_t i = 0; i < m_aIds.size(); ++i) + { + if (nId == m_aIds[i]) + return i; + } + return -1; + } + + DECL_LINK(OnRoadmapItemSelected, LinkParamNone*, void); + DECL_LINK(UpdateRoadmap_Hdl, Timer*, void); + +public: + SalInstanceAssistant(vcl::RoadmapWizard* pDialog, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceDialog(pDialog, pBuilder, bTakeOwnership) + , m_xWizard(pDialog) + { + m_xWizard->SetItemSelectHdl(LINK(this, SalInstanceAssistant, OnRoadmapItemSelected)); + + m_aUpdateRoadmapIdle.SetInvokeHandler(LINK(this, SalInstanceAssistant, UpdateRoadmap_Hdl)); + m_aUpdateRoadmapIdle.SetPriority(TaskPriority::HIGHEST); + } + + virtual int get_current_page() const override { return find_id(m_xWizard->GetCurLevel()); } + + virtual int get_n_pages() const override { return m_aAddedPages.size(); } + + virtual OString get_page_ident(int nPage) const override + { + return m_aAddedPages[nPage]->get_id().toUtf8(); + } + + virtual OString get_current_page_ident() const override + { + return get_page_ident(get_current_page()); + } + + virtual void set_current_page(int nPage) override + { + disable_notify_events(); + + // take the first shown page as the size for all pages + if (m_xWizard->GetPageSizePixel().Width() == 0) + { + Size aFinalSize; + for (int i = 0, nPages = get_n_pages(); i < nPages; ++i) + { + TabPage* pPage = m_xWizard->GetPage(m_aIds[i]); + assert(pPage); + Size aPageSize(pPage->get_preferred_size()); + if (aPageSize.Width() > aFinalSize.Width()) + aFinalSize.setWidth(aPageSize.Width()); + if (aPageSize.Height() > aFinalSize.Height()) + aFinalSize.setHeight(aPageSize.Height()); + } + m_xWizard->SetPageSizePixel(aFinalSize); + } + + (void)m_xWizard->ShowPage(m_aIds[nPage]); + enable_notify_events(); + } + + virtual void set_current_page(const OString& rIdent) override + { + int nIndex = find_page(rIdent); + if (nIndex == -1) + return; + set_current_page(nIndex); + } + + virtual void set_page_index(const OString& rIdent, int nNewIndex) override + { + int nOldIndex = find_page(rIdent); + + if (nOldIndex == -1) + return; + + if (nOldIndex == nNewIndex) + return; + + disable_notify_events(); + + auto entry = std::move(m_aAddedPages[nOldIndex]); + m_aAddedPages.erase(m_aAddedPages.begin() + nOldIndex); + m_aAddedPages.insert(m_aAddedPages.begin() + nNewIndex, std::move(entry)); + + int nId = m_aIds[nOldIndex]; + m_aIds.erase(m_aIds.begin() + nOldIndex); + m_aIds.insert(m_aIds.begin() + nNewIndex, nId); + + m_aUpdateRoadmapIdle.Start(); + + enable_notify_events(); + } + + virtual weld::Container* append_page(const OString& rIdent) override + { + VclPtrInstance xPage(m_xWizard); + VclPtrInstance xGrid(xPage); + xPage->set_id(OUString::fromUtf8(rIdent)); + xPage->Show(); + xGrid->set_hexpand(true); + xGrid->set_vexpand(true); + xGrid->Show(); + m_xWizard->AddPage(xPage); + m_aIds.push_back(m_aAddedPages.size()); + m_xWizard->SetPage(m_aIds.back(), xPage); + m_aAddedPages.push_back(xPage); + m_aAddedGrids.push_back(xGrid); + + m_aUpdateRoadmapIdle.Start(); + + m_aPages.emplace_back(new SalInstanceContainer(xGrid, m_pBuilder, false)); + return m_aPages.back().get(); + } + + virtual OUString get_page_title(const OString& rIdent) const override + { + int nIndex = find_page(rIdent); + if (nIndex == -1) + return OUString(); + return m_aAddedPages[nIndex]->GetText(); + } + + virtual void set_page_title(const OString& rIdent, const OUString& rTitle) override + { + int nIndex = find_page(rIdent); + if (nIndex == -1) + return; + if (m_aAddedPages[nIndex]->GetText() != rTitle) + { + disable_notify_events(); + m_aAddedPages[nIndex]->SetText(rTitle); + m_aUpdateRoadmapIdle.Start(); + enable_notify_events(); + } + } + + virtual void set_page_sensitive(const OString& rIdent, bool bSensitive) override + { + int nIndex = find_page(rIdent); + if (nIndex == -1) + return; + if (m_aAddedPages[nIndex]->IsEnabled() != bSensitive) + { + disable_notify_events(); + m_aAddedPages[nIndex]->Enable(bSensitive); + m_aUpdateRoadmapIdle.Start(); + enable_notify_events(); + } + } + + virtual void set_page_side_help_id(const OString& rHelpId) override + { + m_xWizard->SetRoadmapHelpId(rHelpId); + } + + weld::Button* weld_widget_for_response(int nResponse) override; + + virtual ~SalInstanceAssistant() override + { + for (auto& rGrid : m_aAddedGrids) + rGrid.disposeAndClear(); + for (auto& rPage : m_aAddedPages) + rPage.disposeAndClear(); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceAssistant, OnRoadmapItemSelected, LinkParamNone*, void) +{ + if (notify_events_disabled()) + return; + auto nCurItemId = m_xWizard->GetCurrentRoadmapItemID(); + int nPageIndex(find_id(nCurItemId)); + if (!signal_jump_page(get_page_ident(nPageIndex)) && nCurItemId != m_xWizard->GetCurLevel()) + m_xWizard->SelectRoadmapItemByID(m_xWizard->GetCurLevel()); +} + +IMPL_LINK_NOARG(SalInstanceAssistant, UpdateRoadmap_Hdl, Timer*, void) +{ + disable_notify_events(); + + m_xWizard->DeleteRoadmapItems(); + + int nPos = 0; + for (size_t i = 0; i < m_aAddedPages.size(); ++i) + { + const OUString& rLabel = m_aAddedPages[i]->GetText(); + bool bSensitive = m_aAddedPages[i]->IsEnabled(); + if (rLabel.isEmpty()) + continue; + m_xWizard->InsertRoadmapItem(nPos++, rLabel, m_aIds[i], bSensitive); + } + + m_xWizard->SelectRoadmapItemByID(m_aIds[get_current_page()]); + + m_xWizard->ShowRoadmap(nPos != 0); + + enable_notify_events(); +} + +namespace +{ +class SalInstanceFrame : public SalInstanceContainer, public virtual weld::Frame +{ +private: + VclPtr m_xFrame; + +public: + SalInstanceFrame(VclFrame* pFrame, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pFrame, pBuilder, bTakeOwnership) + , m_xFrame(pFrame) + { + } + + virtual void set_label(const OUString& rText) override { m_xFrame->set_label(rText); } + + virtual OUString get_label() const override { return m_xFrame->get_label(); } + + virtual std::unique_ptr weld_label_widget() const override; +}; + +class SalInstancePaned : public SalInstanceContainer, public virtual weld::Paned +{ +private: + VclPtr m_xPaned; + +public: + SalInstancePaned(VclPaned* pPaned, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pPaned, pBuilder, bTakeOwnership) + , m_xPaned(pPaned) + { + } + + virtual void set_position(int nPos) override + { + m_xPaned->set_position(nPos); + } + + virtual int get_position() const override + { + return m_xPaned->get_position(); + } +}; + +class SalInstanceScrolledWindow : public SalInstanceContainer, public virtual weld::ScrolledWindow +{ +private: + VclPtr m_xScrolledWindow; + Link m_aOrigVScrollHdl; + Link m_aOrigHScrollHdl; + bool m_bUserManagedScrolling; + + DECL_LINK(VscrollHdl, ScrollBar*, void); + DECL_LINK(HscrollHdl, ScrollBar*, void); + +public: + SalInstanceScrolledWindow(VclScrolledWindow* pScrolledWindow, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceContainer(pScrolledWindow, pBuilder, bTakeOwnership) + , m_xScrolledWindow(pScrolledWindow) + , m_bUserManagedScrolling(false) + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + m_aOrigVScrollHdl = rVertScrollBar.GetScrollHdl(); + rVertScrollBar.SetScrollHdl(LINK(this, SalInstanceScrolledWindow, VscrollHdl)); + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + m_aOrigHScrollHdl = rHorzScrollBar.GetScrollHdl(); + rHorzScrollBar.SetScrollHdl(LINK(this, SalInstanceScrolledWindow, HscrollHdl)); + } + + virtual void hadjustment_configure(int value, int lower, int upper, int step_increment, + int page_increment, int page_size) override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + rHorzScrollBar.SetRangeMin(lower); + rHorzScrollBar.SetRangeMax(upper); + rHorzScrollBar.SetLineSize(step_increment); + rHorzScrollBar.SetPageSize(page_increment); + rHorzScrollBar.SetThumbPos(value); + rHorzScrollBar.SetVisibleSize(page_size); + } + + virtual int hadjustment_get_value() const override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + return rHorzScrollBar.GetThumbPos(); + } + + virtual void hadjustment_set_value(int value) override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + rHorzScrollBar.SetThumbPos(value); + if (!m_bUserManagedScrolling) + m_aOrigHScrollHdl.Call(&rHorzScrollBar); + } + + virtual int hadjustment_get_upper() const override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + return rHorzScrollBar.GetRangeMax(); + } + + virtual void hadjustment_set_upper(int upper) override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + rHorzScrollBar.SetRangeMax(upper); + } + + virtual int hadjustment_get_page_size() const override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + return rHorzScrollBar.GetVisibleSize(); + } + + virtual void hadjustment_set_page_size(int size) override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + return rHorzScrollBar.SetVisibleSize(size); + } + + virtual void hadjustment_set_page_increment(int size) override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + return rHorzScrollBar.SetPageSize(size); + } + + virtual void hadjustment_set_step_increment(int size) override + { + ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar(); + return rHorzScrollBar.SetLineSize(size); + } + + virtual void set_hpolicy(VclPolicyType eHPolicy) override + { + WinBits nWinBits = m_xScrolledWindow->GetStyle() & ~(WB_AUTOHSCROLL | WB_HSCROLL); + if (eHPolicy == VclPolicyType::ALWAYS) + nWinBits |= WB_HSCROLL; + else if (eHPolicy == VclPolicyType::AUTOMATIC) + nWinBits |= WB_AUTOHSCROLL; + m_xScrolledWindow->SetStyle(nWinBits); + m_xScrolledWindow->queue_resize(); + } + + virtual VclPolicyType get_hpolicy() const override + { + WinBits nWinBits = m_xScrolledWindow->GetStyle(); + if (nWinBits & WB_AUTOHSCROLL) + return VclPolicyType::AUTOMATIC; + else if (nWinBits & WB_HSCROLL) + return VclPolicyType::ALWAYS; + return VclPolicyType::NEVER; + } + + virtual int get_hscroll_height() const override + { + return m_xScrolledWindow->getHorzScrollBar().get_preferred_size().Height(); + } + + virtual void vadjustment_configure(int value, int lower, int upper, int step_increment, + int page_increment, int page_size) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + rVertScrollBar.SetRangeMin(lower); + rVertScrollBar.SetRangeMax(upper); + rVertScrollBar.SetLineSize(step_increment); + rVertScrollBar.SetPageSize(page_increment); + rVertScrollBar.SetThumbPos(value); + rVertScrollBar.SetVisibleSize(page_size); + } + + virtual int vadjustment_get_value() const override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.GetThumbPos(); + } + + virtual void vadjustment_set_value(int value) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + rVertScrollBar.SetThumbPos(value); + if (!m_bUserManagedScrolling) + m_aOrigVScrollHdl.Call(&rVertScrollBar); + } + + virtual int vadjustment_get_upper() const override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.GetRangeMax(); + } + + virtual void vadjustment_set_upper(int upper) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + rVertScrollBar.SetRangeMax(upper); + } + + virtual int vadjustment_get_lower() const override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.GetRangeMin(); + } + + virtual void vadjustment_set_lower(int lower) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + rVertScrollBar.SetRangeMin(lower); + } + + virtual int vadjustment_get_page_size() const override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.GetVisibleSize(); + } + + virtual void vadjustment_set_page_size(int size) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.SetVisibleSize(size); + } + + virtual void vadjustment_set_page_increment(int size) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.SetPageSize(size); + } + + virtual void vadjustment_set_step_increment(int size) override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + return rVertScrollBar.SetLineSize(size); + } + + virtual void set_vpolicy(VclPolicyType eVPolicy) override + { + WinBits nWinBits = m_xScrolledWindow->GetStyle() & ~(WB_AUTOVSCROLL | WB_VSCROLL); + if (eVPolicy == VclPolicyType::ALWAYS) + nWinBits |= WB_VSCROLL; + else if (eVPolicy == VclPolicyType::AUTOMATIC) + nWinBits |= WB_AUTOVSCROLL; + m_xScrolledWindow->SetStyle(nWinBits); + m_xScrolledWindow->queue_resize(); + } + + virtual VclPolicyType get_vpolicy() const override + { + WinBits nWinBits = m_xScrolledWindow->GetStyle(); + if (nWinBits & WB_AUTOVSCROLL) + return VclPolicyType::AUTOMATIC; + else if (nWinBits & WB_VSCROLL) + return VclPolicyType::ALWAYS; + return VclPolicyType::NEVER; + } + + virtual int get_vscroll_width() const override + { + return m_xScrolledWindow->getVertScrollBar().get_preferred_size().Width(); + } + + virtual void set_user_managed_scrolling() override + { + m_bUserManagedScrolling = true; + m_xScrolledWindow->setUserManagedScrolling(true); + } + + virtual ~SalInstanceScrolledWindow() override + { + ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar(); + rVertScrollBar.SetScrollHdl(m_aOrigVScrollHdl); + } +}; + +} + +IMPL_LINK(SalInstanceScrolledWindow, VscrollHdl, ScrollBar*, pScrollBar, void) +{ + signal_vadjustment_changed(); + if (!m_bUserManagedScrolling) + m_aOrigVScrollHdl.Call(pScrollBar); +} + +IMPL_LINK_NOARG(SalInstanceScrolledWindow, HscrollHdl, ScrollBar*, void) +{ + signal_hadjustment_changed(); + if (!m_bUserManagedScrolling) + m_aOrigHScrollHdl.Call(&m_xScrolledWindow->getHorzScrollBar()); +} + +SalInstanceNotebook::SalInstanceNotebook(TabControl* pNotebook, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pNotebook, pBuilder, bTakeOwnership) + , m_xNotebook(pNotebook) +{ + m_xNotebook->SetActivatePageHdl(LINK(this, SalInstanceNotebook, ActivatePageHdl)); + m_xNotebook->SetDeactivatePageHdl(LINK(this, SalInstanceNotebook, DeactivatePageHdl)); +} + +int SalInstanceNotebook::get_current_page() const +{ + return m_xNotebook->GetPagePos(m_xNotebook->GetCurPageId()); +} + +OString SalInstanceNotebook::get_page_ident(int nPage) const +{ + return m_xNotebook->GetPageName(m_xNotebook->GetPageId(nPage)); +} + +OString SalInstanceNotebook::get_current_page_ident() const +{ + return m_xNotebook->GetPageName(m_xNotebook->GetCurPageId()); +} + +weld::Container* SalInstanceNotebook::get_page(const OString& rIdent) const +{ + sal_uInt16 nPageId = m_xNotebook->GetPageId(rIdent); + sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(nPageId); + if (nPageIndex == TAB_PAGE_NOTFOUND) + return nullptr; + TabPage* pPage = m_xNotebook->GetTabPage(nPageId); + vcl::Window* pChild = pPage->GetChild(0); + if (m_aPages.size() < nPageIndex + 1U) + m_aPages.resize(nPageIndex + 1U); + if (!m_aPages[nPageIndex]) + m_aPages[nPageIndex] = std::make_shared(pChild, m_pBuilder, false); + return m_aPages[nPageIndex].get(); +} + +void SalInstanceNotebook::set_current_page(int nPage) +{ + m_xNotebook->SetCurPageId(m_xNotebook->GetPageId(nPage)); +} + +void SalInstanceNotebook::set_current_page(const OString& rIdent) +{ + m_xNotebook->SetCurPageId(m_xNotebook->GetPageId(rIdent)); +} + +void SalInstanceNotebook::remove_page(const OString& rIdent) +{ + sal_uInt16 nPageId = m_xNotebook->GetPageId(rIdent); + sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(nPageId); + if (nPageIndex == TAB_PAGE_NOTFOUND) + return; + + m_xNotebook->RemovePage(nPageId); + if (nPageIndex < m_aPages.size()) + m_aPages.erase(m_aPages.begin() + nPageIndex); + + auto iter = m_aAddedPages.find(rIdent); + if (iter != m_aAddedPages.end()) + { + iter->second.second.disposeAndClear(); + iter->second.first.disposeAndClear(); + m_aAddedPages.erase(iter); + } +} + +void SalInstanceNotebook::insert_page(const OString& rIdent, const OUString& rLabel, int nPos) +{ + sal_uInt16 nPageCount = m_xNotebook->GetPageCount(); + sal_uInt16 nLastPageId = nPageCount ? m_xNotebook->GetPageId(nPageCount - 1) : 0; + sal_uInt16 nNewPageId = nLastPageId + 1; + m_xNotebook->InsertPage(nNewPageId, rLabel, nPos == -1 ? TAB_APPEND : nPos); + VclPtrInstance xPage(m_xNotebook); + VclPtrInstance xGrid(xPage); + xPage->Show(); + xGrid->set_hexpand(true); + xGrid->set_vexpand(true); + xGrid->Show(); + m_xNotebook->SetTabPage(nNewPageId, xPage); + m_xNotebook->SetPageName(nNewPageId, rIdent); + m_aAddedPages.try_emplace(rIdent, xPage, xGrid); +} + +int SalInstanceNotebook::get_n_pages() const { return m_xNotebook->GetPageCount(); } + +OUString SalInstanceNotebook::get_tab_label_text(const OString& rIdent) const +{ + return m_xNotebook->GetPageText(m_xNotebook->GetPageId(rIdent)); +} + +void SalInstanceNotebook::set_tab_label_text(const OString& rIdent, const OUString& rText) +{ + return m_xNotebook->SetPageText(m_xNotebook->GetPageId(rIdent), rText); +} + +SalInstanceNotebook::~SalInstanceNotebook() +{ + for (auto& rItem : m_aAddedPages) + { + rItem.second.second.disposeAndClear(); + rItem.second.first.disposeAndClear(); + } + m_xNotebook->SetActivatePageHdl(Link()); + m_xNotebook->SetDeactivatePageHdl(Link()); +} + +IMPL_LINK_NOARG(SalInstanceNotebook, DeactivatePageHdl, TabControl*, bool) +{ + return !m_aLeavePageHdl.IsSet() || m_aLeavePageHdl.Call(get_current_page_ident()); +} + +IMPL_LINK_NOARG(SalInstanceNotebook, ActivatePageHdl, TabControl*, void) +{ + m_aEnterPageHdl.Call(get_current_page_ident()); +} + +namespace +{ +class SalInstanceVerticalNotebook : public SalInstanceContainer, public virtual weld::Notebook +{ +private: + VclPtr m_xNotebook; + mutable std::vector> m_aPages; + + DECL_LINK(DeactivatePageHdl, VerticalTabControl*, bool); + DECL_LINK(ActivatePageHdl, VerticalTabControl*, void); + +public: + SalInstanceVerticalNotebook(VerticalTabControl* pNotebook, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceContainer(pNotebook, pBuilder, bTakeOwnership) + , m_xNotebook(pNotebook) + { + m_xNotebook->SetActivatePageHdl(LINK(this, SalInstanceVerticalNotebook, ActivatePageHdl)); + m_xNotebook->SetDeactivatePageHdl( + LINK(this, SalInstanceVerticalNotebook, DeactivatePageHdl)); + } + + virtual int get_current_page() const override + { + return m_xNotebook->GetPagePos(m_xNotebook->GetCurPageId()); + } + + virtual OString get_page_ident(int nPage) const override + { + return m_xNotebook->GetPageId(nPage); + } + + virtual OString get_current_page_ident() const override { return m_xNotebook->GetCurPageId(); } + + virtual weld::Container* get_page(const OString& rIdent) const override + { + sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(rIdent); + if (nPageIndex == TAB_PAGE_NOTFOUND) + return nullptr; + auto pChild = m_xNotebook->GetPage(rIdent); + if (m_aPages.size() < nPageIndex + 1U) + m_aPages.resize(nPageIndex + 1U); + if (!m_aPages[nPageIndex]) + m_aPages[nPageIndex].reset(new SalInstanceContainer(pChild, m_pBuilder, false)); + return m_aPages[nPageIndex].get(); + } + + virtual void set_current_page(int nPage) override + { + m_xNotebook->SetCurPageId(m_xNotebook->GetPageId(nPage)); + } + + virtual void set_current_page(const OString& rIdent) override + { + m_xNotebook->SetCurPageId(rIdent); + } + + virtual void remove_page(const OString& rIdent) override + { + sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(rIdent); + if (nPageIndex == TAB_PAGE_NOTFOUND) + return; + m_xNotebook->RemovePage(rIdent); + if (nPageIndex < m_aPages.size()) + m_aPages.erase(m_aPages.begin() + nPageIndex); + } + + virtual void insert_page(const OString& rIdent, const OUString& rLabel, int nPos) override + { + VclPtrInstance xGrid(m_xNotebook->GetPageParent()); + xGrid->set_hexpand(true); + xGrid->set_vexpand(true); + m_xNotebook->InsertPage(rIdent, rLabel, Image(), "", xGrid, nPos); + } + + virtual int get_n_pages() const override { return m_xNotebook->GetPageCount(); } + + virtual void set_tab_label_text(const OString& rIdent, const OUString& rText) override + { + return m_xNotebook->SetPageText(rIdent, rText); + } + + virtual OUString get_tab_label_text(const OString& rIdent) const override + { + return m_xNotebook->GetPageText(rIdent); + } + + virtual ~SalInstanceVerticalNotebook() override + { + m_xNotebook->SetActivatePageHdl(Link()); + m_xNotebook->SetDeactivatePageHdl(Link()); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceVerticalNotebook, DeactivatePageHdl, VerticalTabControl*, bool) +{ + return !m_aLeavePageHdl.IsSet() || m_aLeavePageHdl.Call(get_current_page_ident()); +} + +IMPL_LINK_NOARG(SalInstanceVerticalNotebook, ActivatePageHdl, VerticalTabControl*, void) +{ + m_aEnterPageHdl.Call(get_current_page_ident()); +} + +SalInstanceButton::SalInstanceButton(::Button* pButton, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pButton, pBuilder, bTakeOwnership) + , m_xButton(pButton) + , m_aOldClickHdl(pButton->GetClickHdl()) +{ + m_xButton->SetClickHdl(LINK(this, SalInstanceButton, ClickHdl)); +} + +void SalInstanceButton::set_label(const OUString& rText) { m_xButton->SetText(rText); } + +void SalInstanceButton::set_image(VirtualDevice* pDevice) +{ + m_xButton->SetImageAlign(ImageAlign::Left); + if (pDevice) + m_xButton->SetModeImage(createImage(*pDevice)); + else + m_xButton->SetModeImage(Image()); +} + +void SalInstanceButton::set_image(const css::uno::Reference& rImage) +{ + m_xButton->SetImageAlign(ImageAlign::Left); + m_xButton->SetModeImage(Image(rImage)); +} + +void SalInstanceButton::set_from_icon_name(const OUString& rIconName) +{ + m_xButton->SetModeImage(Image(StockImage::Yes, rIconName)); +} + +void SalInstanceButton::set_label_line_wrap(bool wrap) +{ + WinBits nBits = m_xButton->GetStyle(); + nBits &= ~WB_WORDBREAK; + if (wrap) + nBits |= WB_WORDBREAK; + m_xButton->SetStyle(nBits); + m_xButton->queue_resize(); +} + +OUString SalInstanceButton::get_label() const { return m_xButton->GetText(); } + +SalInstanceButton::~SalInstanceButton() { m_xButton->SetClickHdl(Link<::Button*, void>()); } + +IMPL_LINK(SalInstanceButton, ClickHdl, ::Button*, pButton, void) +{ + //if there's no handler set, disengage our intercept and + //run the click again to get default behaviour for cancel/ok + //etc buttons. + if (!m_aClickHdl.IsSet()) + { + pButton->SetClickHdl(m_aOldClickHdl); + pButton->Click(); + pButton->SetClickHdl(LINK(this, SalInstanceButton, ClickHdl)); + return; + } + signal_clicked(); +} + +weld::Button* SalInstanceDialog::weld_widget_for_response(int nResponse) +{ + PushButton* pButton = dynamic_cast(m_xDialog->get_widget_for_response(nResponse)); + return pButton ? new SalInstanceButton(pButton, nullptr, false) : nullptr; +} + +weld::Button* SalInstanceAssistant::weld_widget_for_response(int nResponse) +{ + PushButton* pButton = nullptr; + if (nResponse == RET_YES) + pButton = m_xWizard->m_pNextPage; + else if (nResponse == RET_NO) + pButton = m_xWizard->m_pPrevPage; + else if (nResponse == RET_OK) + pButton = m_xWizard->m_pFinish; + else if (nResponse == RET_CANCEL) + pButton = m_xWizard->m_pCancel; + else if (nResponse == RET_HELP) + pButton = m_xWizard->m_pHelp; + if (pButton) + return new SalInstanceButton(pButton, nullptr, false); + return nullptr; +} + +namespace +{ +class SalInstanceMenuButton : public SalInstanceButton, public virtual weld::MenuButton +{ +private: + VclPtr<::MenuButton> m_xMenuButton; + sal_uInt16 m_nLastId; + + DECL_LINK(MenuSelectHdl, ::MenuButton*, void); + DECL_LINK(ActivateHdl, ::MenuButton*, void); + +public: + SalInstanceMenuButton(::MenuButton* pButton, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceButton(pButton, pBuilder, bTakeOwnership) + , m_xMenuButton(pButton) + , m_nLastId(0) + { + m_xMenuButton->SetActivateHdl(LINK(this, SalInstanceMenuButton, ActivateHdl)); + m_xMenuButton->SetSelectHdl(LINK(this, SalInstanceMenuButton, MenuSelectHdl)); + if (PopupMenu* pMenu = m_xMenuButton->GetPopupMenu()) + { + pMenu->SetMenuFlags(MenuFlags::NoAutoMnemonics); + const auto nCount = pMenu->GetItemCount(); + m_nLastId = nCount ? pMenu->GetItemId(nCount - 1) : 0; + } + } + + virtual void set_active(bool active) override + { + if (active == get_active()) + return; + if (active) + m_xMenuButton->ExecuteMenu(); + else + m_xMenuButton->CancelMenu(); + } + + virtual bool get_active() const override { return m_xMenuButton->InPopupMode(); } + + virtual void set_inconsistent(bool /*inconsistent*/) override + { + //not available + } + + virtual bool get_inconsistent() const override { return false; } + + virtual void insert_item(int pos, const OUString& rId, const OUString& rStr, + const OUString* pIconName, VirtualDevice* pImageSurface, + TriState eCheckRadioFalse) override + { + m_nLastId = insert_to_menu(m_nLastId, m_xMenuButton->GetPopupMenu(), pos, rId, rStr, + pIconName, pImageSurface, eCheckRadioFalse); + } + + virtual void insert_separator(int pos, const OUString& rId) override + { + auto nInsertPos = pos == -1 ? MENU_APPEND : pos; + m_xMenuButton->GetPopupMenu()->InsertSeparator(rId.toUtf8(), nInsertPos); + } + + virtual void set_item_sensitive(const OString& rIdent, bool bSensitive) override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->EnableItem(rIdent, bSensitive); + } + + virtual void remove_item(const OString& rId) override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->RemoveItem(pMenu->GetItemPos(pMenu->GetItemId(rId))); + } + + virtual void clear() override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->Clear(); + } + + virtual void set_item_active(const OString& rIdent, bool bActive) override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->CheckItem(rIdent, bActive); + } + + virtual void set_item_label(const OString& rIdent, const OUString& rText) override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->SetItemText(pMenu->GetItemId(rIdent), rText); + } + + virtual OUString get_item_label(const OString& rIdent) const override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + return pMenu->GetItemText(pMenu->GetItemId(rIdent)); + } + + virtual void set_item_visible(const OString& rIdent, bool bShow) override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->ShowItem(pMenu->GetItemId(rIdent), bShow); + } + + virtual void set_item_help_id(const OString& rIdent, const OString& rHelpId) override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + pMenu->SetHelpId(pMenu->GetItemId(rIdent), rHelpId); + } + + virtual OString get_item_help_id(const OString& rIdent) const override + { + PopupMenu* pMenu = m_xMenuButton->GetPopupMenu(); + return pMenu->GetHelpId(pMenu->GetItemId(rIdent)); + } + + virtual void set_popover(weld::Widget* pPopover) override + { + SalInstanceWidget* pPopoverWidget = dynamic_cast(pPopover); + m_xMenuButton->SetPopover(pPopoverWidget ? pPopoverWidget->getWidget() : nullptr); + } + + virtual ~SalInstanceMenuButton() override + { + m_xMenuButton->SetSelectHdl(Link<::MenuButton*, void>()); + m_xMenuButton->SetActivateHdl(Link<::MenuButton*, void>()); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceMenuButton, MenuSelectHdl, ::MenuButton*, void) +{ + signal_selected(m_xMenuButton->GetCurItemIdent()); +} + +IMPL_LINK_NOARG(SalInstanceMenuButton, ActivateHdl, ::MenuButton*, void) +{ + if (notify_events_disabled()) + return; + signal_toggled(); +} + +namespace +{ +class SalInstanceLinkButton : public SalInstanceContainer, public virtual weld::LinkButton +{ +private: + VclPtr m_xButton; + Link m_aOrigClickHdl; + + DECL_LINK(ClickHdl, FixedHyperlink&, void); + +public: + SalInstanceLinkButton(FixedHyperlink* pButton, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceContainer(pButton, pBuilder, bTakeOwnership) + , m_xButton(pButton) + { + m_aOrigClickHdl = m_xButton->GetClickHdl(); + m_xButton->SetClickHdl(LINK(this, SalInstanceLinkButton, ClickHdl)); + } + + virtual void set_label(const OUString& rText) override { m_xButton->SetText(rText); } + + virtual OUString get_label() const override { return m_xButton->GetText(); } + + virtual void set_uri(const OUString& rUri) override { m_xButton->SetURL(rUri); } + + virtual OUString get_uri() const override { return m_xButton->GetURL(); } + + virtual ~SalInstanceLinkButton() override { m_xButton->SetClickHdl(m_aOrigClickHdl); } +}; + +} + +IMPL_LINK(SalInstanceLinkButton, ClickHdl, FixedHyperlink&, rButton, void) +{ + bool bConsumed = signal_activate_link(); + if (!bConsumed) + m_aOrigClickHdl.Call(rButton); +} + +namespace +{ +class SalInstanceRadioButton : public SalInstanceButton, public virtual weld::RadioButton +{ +private: + VclPtr<::RadioButton> m_xRadioButton; + + DECL_LINK(ToggleHdl, ::RadioButton&, void); + +public: + SalInstanceRadioButton(::RadioButton* pButton, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceButton(pButton, pBuilder, bTakeOwnership) + , m_xRadioButton(pButton) + { + m_xRadioButton->SetToggleHdl(LINK(this, SalInstanceRadioButton, ToggleHdl)); + } + + virtual void set_active(bool active) override + { + disable_notify_events(); + m_xRadioButton->Check(active); + enable_notify_events(); + } + + virtual bool get_active() const override { return m_xRadioButton->IsChecked(); } + + virtual void set_image(VirtualDevice* pDevice) override + { + m_xRadioButton->SetImageAlign(ImageAlign::Center); + if (pDevice) + m_xRadioButton->SetModeImage(createImage(*pDevice)); + else + m_xRadioButton->SetModeImage(Image()); + } + + virtual void set_image(const css::uno::Reference& rImage) override + { + m_xRadioButton->SetImageAlign(ImageAlign::Center); + m_xRadioButton->SetModeImage(Image(rImage)); + } + + virtual void set_from_icon_name(const OUString& rIconName) override + { + m_xRadioButton->SetModeRadioImage(Image(StockImage::Yes, rIconName)); + } + + virtual void set_inconsistent(bool /*inconsistent*/) override + { + //not available + } + + virtual bool get_inconsistent() const override { return false; } + + virtual ~SalInstanceRadioButton() override + { + m_xRadioButton->SetToggleHdl(Link<::RadioButton&, void>()); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceRadioButton, ToggleHdl, ::RadioButton&, void) +{ + if (notify_events_disabled()) + return; + signal_toggled(); +} + +namespace +{ +class SalInstanceToggleButton : public SalInstanceButton, public virtual weld::ToggleButton +{ +private: + VclPtr m_xToggleButton; + + DECL_LINK(ToggleListener, VclWindowEvent&, void); + +public: + SalInstanceToggleButton(PushButton* pButton, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceButton(pButton, pBuilder, bTakeOwnership) + , m_xToggleButton(pButton) + { + } + + virtual void connect_toggled(const Link& rLink) override + { + assert(!m_aToggleHdl.IsSet()); + m_xToggleButton->AddEventListener(LINK(this, SalInstanceToggleButton, ToggleListener)); + weld::ToggleButton::connect_toggled(rLink); + } + + virtual void set_active(bool active) override + { + disable_notify_events(); + m_xToggleButton->Check(active); + enable_notify_events(); + } + + virtual bool get_active() const override { return m_xToggleButton->IsChecked(); } + + virtual void set_inconsistent(bool inconsistent) override + { + disable_notify_events(); + m_xToggleButton->SetState(inconsistent ? TRISTATE_INDET : TRISTATE_FALSE); + enable_notify_events(); + } + + virtual bool get_inconsistent() const override + { + return m_xToggleButton->GetState() == TRISTATE_INDET; + } + + virtual ~SalInstanceToggleButton() override + { + if (m_aToggleHdl.IsSet()) + m_xToggleButton->RemoveEventListener( + LINK(this, SalInstanceToggleButton, ToggleListener)); + } +}; + +} + +IMPL_LINK(SalInstanceToggleButton, ToggleListener, VclWindowEvent&, rEvent, void) +{ + if (notify_events_disabled()) + return; + if (rEvent.GetId() == VclEventId::PushbuttonToggle) + signal_toggled(); +} + +SalInstanceCheckButton::SalInstanceCheckButton(CheckBox* pButton, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceButton(pButton, pBuilder, bTakeOwnership) + , m_xCheckButton(pButton) +{ + m_xCheckButton->SetToggleHdl(LINK(this, SalInstanceCheckButton, ToggleHdl)); +} + +void SalInstanceCheckButton::set_active(bool active) +{ + disable_notify_events(); + m_xCheckButton->EnableTriState(false); + m_xCheckButton->Check(active); + enable_notify_events(); +} + +bool SalInstanceCheckButton::get_active() const { return m_xCheckButton->IsChecked(); } + +void SalInstanceCheckButton::set_inconsistent(bool inconsistent) +{ + disable_notify_events(); + m_xCheckButton->EnableTriState(true); + m_xCheckButton->SetState(inconsistent ? TRISTATE_INDET : TRISTATE_FALSE); + enable_notify_events(); +} + +bool SalInstanceCheckButton::get_inconsistent() const +{ + return m_xCheckButton->GetState() == TRISTATE_INDET; +} + +SalInstanceCheckButton::~SalInstanceCheckButton() +{ + m_xCheckButton->SetToggleHdl(Link()); +} + +IMPL_LINK_NOARG(SalInstanceCheckButton, ToggleHdl, CheckBox&, void) +{ + if (notify_events_disabled()) + return; + m_xCheckButton->EnableTriState(false); + signal_toggled(); +} + +namespace +{ +class SalInstanceScale : public SalInstanceWidget, public virtual weld::Scale +{ +private: + VclPtr m_xScale; + + DECL_LINK(SlideHdl, Slider*, void); + +public: + SalInstanceScale(Slider* pScale, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceWidget(pScale, pBuilder, bTakeOwnership) + , m_xScale(pScale) + { + m_xScale->SetSlideHdl(LINK(this, SalInstanceScale, SlideHdl)); + } + + virtual void set_value(int value) override { m_xScale->SetThumbPos(value); } + + virtual void set_range(int min, int max) override + { + m_xScale->SetRangeMin(min); + m_xScale->SetRangeMax(max); + } + + virtual int get_value() const override { return m_xScale->GetThumbPos(); } + + virtual void set_increments(int step, int page) override + { + m_xScale->SetLineSize(step); + m_xScale->SetPageSize(page); + } + + virtual void get_increments(int& step, int& page) const override + { + step = m_xScale->GetLineSize(); + page = m_xScale->GetPageSize(); + } + + virtual ~SalInstanceScale() override { m_xScale->SetSlideHdl(Link()); } +}; + +} + +IMPL_LINK_NOARG(SalInstanceScale, SlideHdl, Slider*, void) { signal_value_changed(); } + +namespace +{ +class SalInstanceSpinner : public SalInstanceWidget, public virtual weld::Spinner +{ +private: + VclPtr m_xThrobber; + +public: + SalInstanceSpinner(Throbber* pThrobber, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceWidget(pThrobber, pBuilder, bTakeOwnership) + , m_xThrobber(pThrobber) + { + } + + virtual void start() override { m_xThrobber->start(); } + + virtual void stop() override { m_xThrobber->stop(); } +}; + +class SalInstanceProgressBar : public SalInstanceWidget, public virtual weld::ProgressBar +{ +private: + VclPtr<::ProgressBar> m_xProgressBar; + +public: + SalInstanceProgressBar(::ProgressBar* pProgressBar, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceWidget(pProgressBar, pBuilder, bTakeOwnership) + , m_xProgressBar(pProgressBar) + { + } + + virtual void set_percentage(int value) override { m_xProgressBar->SetValue(value); } + + virtual OUString get_text() const override { return m_xProgressBar->GetText(); } + + virtual void set_text(const OUString& rText) override { m_xProgressBar->SetText(rText); } +}; + +class SalInstanceImage : public SalInstanceWidget, public virtual weld::Image +{ +private: + VclPtr m_xImage; + +public: + SalInstanceImage(FixedImage* pImage, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceWidget(pImage, pBuilder, bTakeOwnership) + , m_xImage(pImage) + { + } + + virtual void set_from_icon_name(const OUString& rIconName) override + { + m_xImage->SetImage(::Image(StockImage::Yes, rIconName)); + } + + virtual void set_image(VirtualDevice* pDevice) override + { + if (pDevice) + m_xImage->SetImage(createImage(*pDevice)); + else + m_xImage->SetImage(::Image()); + } + + virtual void set_image(const css::uno::Reference& rImage) override + { + m_xImage->SetImage(::Image(rImage)); + } +}; + +class SalInstanceCalendar : public SalInstanceWidget, public virtual weld::Calendar +{ +private: + VclPtr<::Calendar> m_xCalendar; + + DECL_LINK(SelectHdl, ::Calendar*, void); + DECL_LINK(ActivateHdl, ::Calendar*, void); + +public: + SalInstanceCalendar(::Calendar* pCalendar, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceWidget(pCalendar, pBuilder, bTakeOwnership) + , m_xCalendar(pCalendar) + { + m_xCalendar->SetSelectHdl(LINK(this, SalInstanceCalendar, SelectHdl)); + m_xCalendar->SetActivateHdl(LINK(this, SalInstanceCalendar, ActivateHdl)); + } + + virtual void set_date(const Date& rDate) override { m_xCalendar->SetCurDate(rDate); } + + virtual Date get_date() const override { return m_xCalendar->GetFirstSelectedDate(); } + + virtual ~SalInstanceCalendar() override + { + m_xCalendar->SetSelectHdl(Link<::Calendar*, void>()); + m_xCalendar->SetActivateHdl(Link<::Calendar*, void>()); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceCalendar, SelectHdl, ::Calendar*, void) +{ + if (notify_events_disabled()) + return; + signal_selected(); +} + +IMPL_LINK_NOARG(SalInstanceCalendar, ActivateHdl, ::Calendar*, void) +{ + if (notify_events_disabled()) + return; + signal_activated(); +} + +WeldTextFilter::WeldTextFilter(Link& rInsertTextHdl) + : TextFilter(OUString()) + , m_rInsertTextHdl(rInsertTextHdl) +{ +} + +OUString WeldTextFilter::filter(const OUString& rText) +{ + if (!m_rInsertTextHdl.IsSet()) + return rText; + OUString sText(rText); + const bool bContinue = m_rInsertTextHdl.Call(sText); + if (!bContinue) + return OUString(); + return sText; +} + +SalInstanceEntry::SalInstanceEntry(Edit* pEntry, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceWidget(pEntry, pBuilder, bTakeOwnership) + , m_xEntry(pEntry) + , m_aTextFilter(m_aInsertTextHdl) +{ + m_xEntry->SetModifyHdl(LINK(this, SalInstanceEntry, ChangeHdl)); + m_xEntry->SetActivateHdl(LINK(this, SalInstanceEntry, ActivateHdl)); + m_xEntry->SetTextFilter(&m_aTextFilter); +} + +void SalInstanceEntry::set_text(const OUString& rText) +{ + disable_notify_events(); + m_xEntry->SetText(rText); + enable_notify_events(); +} + +OUString SalInstanceEntry::get_text() const +{ + return m_xEntry->GetText(); +} + +void SalInstanceEntry::set_width_chars(int nChars) +{ + m_xEntry->SetWidthInChars(nChars); +} + +int SalInstanceEntry::get_width_chars() const +{ + return m_xEntry->GetWidthInChars(); +} + +void SalInstanceEntry::set_max_length(int nChars) +{ + m_xEntry->SetMaxTextLen(nChars); +} + +void SalInstanceEntry::select_region(int nStartPos, int nEndPos) +{ + disable_notify_events(); + m_xEntry->SetSelection(Selection(nStartPos, nEndPos < 0 ? SELECTION_MAX : nEndPos)); + enable_notify_events(); +} + +bool SalInstanceEntry::get_selection_bounds(int& rStartPos, int& rEndPos) +{ + const Selection& rSelection = m_xEntry->GetSelection(); + rStartPos = rSelection.Min(); + rEndPos = rSelection.Max(); + return rSelection.Len(); +} + +void SalInstanceEntry::replace_selection(const OUString& rText) +{ + m_xEntry->ReplaceSelected(rText); +} + +void SalInstanceEntry::set_position(int nCursorPos) +{ + disable_notify_events(); + if (nCursorPos < 0) + m_xEntry->SetCursorAtLast(); + else + m_xEntry->SetSelection(Selection(nCursorPos, nCursorPos)); + enable_notify_events(); +} + +int SalInstanceEntry::get_position() const +{ + return m_xEntry->GetSelection().Max(); +} + +void SalInstanceEntry::set_editable(bool bEditable) +{ + m_xEntry->SetReadOnly(!bEditable); +} + +bool SalInstanceEntry::get_editable() const +{ + return !m_xEntry->IsReadOnly(); +} + +void SalInstanceEntry::set_message_type(weld::EntryMessageType eType) +{ + if (eType == weld::EntryMessageType::Error) + { + // tdf#114603: enable setting the background to a different color; + // relevant for GTK; see also #i75179# + m_xEntry->SetForceControlBackground(true); + m_xEntry->SetControlForeground(COL_WHITE); + m_xEntry->SetControlBackground(0xff6563); + } + else if (eType == weld::EntryMessageType::Warning) + { + // tdf#114603: enable setting the background to a different color; + // relevant for GTK; see also #i75179# + m_xEntry->SetForceControlBackground(true); + m_xEntry->SetControlForeground(); + m_xEntry->SetControlBackground(COL_YELLOW); + } + else + { + m_xEntry->SetForceControlBackground(false); + m_xEntry->SetControlForeground(); + m_xEntry->SetControlBackground(); + } +} + +void SalInstanceEntry::set_font(const vcl::Font& rFont) +{ + m_xEntry->SetPointFont(*m_xEntry, rFont); + m_xEntry->Invalidate(); +} + +void SalInstanceEntry::connect_cursor_position(const Link& rLink) +{ + assert(!m_aCursorPositionHdl.IsSet()); + m_xEntry->AddEventListener(LINK(this, SalInstanceEntry, CursorListener)); + weld::Entry::connect_cursor_position(rLink); +} + +void SalInstanceEntry::set_placeholder_text(const OUString& rText) +{ + m_xEntry->SetPlaceholderText(rText); +} + +Edit& SalInstanceEntry::getEntry() +{ + return *m_xEntry; +} + +void SalInstanceEntry::fire_signal_changed() +{ + signal_changed(); +} + +void SalInstanceEntry::cut_clipboard() +{ + m_xEntry->Cut(); +} + +void SalInstanceEntry::copy_clipboard() +{ + m_xEntry->Copy(); +} + +void SalInstanceEntry::paste_clipboard() +{ + m_xEntry->Paste(); +} + +SalInstanceEntry::~SalInstanceEntry() +{ + if (m_aCursorPositionHdl.IsSet()) + m_xEntry->RemoveEventListener(LINK(this, SalInstanceEntry, CursorListener)); + m_xEntry->SetTextFilter(nullptr); + m_xEntry->SetActivateHdl(Link()); + m_xEntry->SetModifyHdl(Link()); +} + +IMPL_LINK_NOARG(SalInstanceEntry, ChangeHdl, Edit&, void) { signal_changed(); } + +IMPL_LINK(SalInstanceEntry, CursorListener, VclWindowEvent&, rEvent, void) +{ + if (notify_events_disabled()) + return; + if (rEvent.GetId() == VclEventId::EditSelectionChanged + || rEvent.GetId() == VclEventId::EditCaretChanged) + signal_cursor_position(); +} + +IMPL_LINK_NOARG(SalInstanceEntry, ActivateHdl, Edit&, bool) { return m_aActivateHdl.Call(*this); } + +namespace +{ +struct SalInstanceTreeIter : public weld::TreeIter +{ + SalInstanceTreeIter(const SalInstanceTreeIter* pOrig) + : iter(pOrig ? pOrig->iter : nullptr) + { + } + SalInstanceTreeIter(SvTreeListEntry* pIter) + : iter(pIter) + { + } + virtual bool equal(const TreeIter& rOther) const override + { + return iter == static_cast(rOther).iter; + } + SvTreeListEntry* iter; +}; + +TriState get_toggle(SvTreeListEntry* pEntry, int col) +{ + ++col; //skip dummy/expander column + + if (static_cast(col) == pEntry->ItemCount()) + return TRISTATE_FALSE; + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + SvLBoxButton& rToggle = static_cast(rItem); + if (rToggle.IsStateTristate()) + return TRISTATE_INDET; + else if (rToggle.IsStateChecked()) + return TRISTATE_TRUE; + return TRISTATE_FALSE; +} + +bool get_text_emphasis(SvTreeListEntry* pEntry, int col) +{ + ++col; //skip dummy/expander column + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + return static_cast(rItem).IsEmphasized(); +} +} + +class SalInstanceTreeView; + +static SalInstanceTreeView* g_DragSource; + +namespace +{ + // tdf#131581 if the TreeView is hidden then there are possibly additional + // optimizations available + class UpdateGuardIfHidden + { + private: + SvTabListBox& m_rTreeView; + bool m_bOrigUpdate; + bool m_bOrigEnableInvalidate; + + public: + UpdateGuardIfHidden(SvTabListBox& rTreeView) + : m_rTreeView(rTreeView) + // tdf#136962 only do SetUpdateMode(false) optimization if the widget is currently hidden + , m_bOrigUpdate(!m_rTreeView.IsVisible() && m_rTreeView.IsUpdateMode()) + // tdf#137432 only do EnableInvalidate(false) optimization if the widget is currently hidden + , m_bOrigEnableInvalidate(!m_rTreeView.IsVisible() && m_rTreeView.GetModel()->IsEnableInvalidate()) + { + if (m_bOrigUpdate) + m_rTreeView.SetUpdateMode(false); + if (m_bOrigEnableInvalidate) + m_rTreeView.GetModel()->EnableInvalidate(false); + } + + ~UpdateGuardIfHidden() + { + if (m_bOrigEnableInvalidate) + m_rTreeView.GetModel()->EnableInvalidate(true); + if (m_bOrigUpdate) + m_rTreeView.SetUpdateMode(true); + } + }; +} + +class SalInstanceTreeView : public SalInstanceContainer, public virtual weld::TreeView +{ +private: + // owner for UserData + std::vector> m_aUserData; + VclPtr m_xTreeView; + SvLBoxButtonData m_aCheckButtonData; + SvLBoxButtonData m_aRadioButtonData; + // currently expanding parent that logically, but not currently physically, + // contain placeholders + o3tl::sorted_vector m_aExpandingPlaceHolderParents; + // which columns should be custom rendered + o3tl::sorted_vector m_aCustomRenders; + bool m_bDisableCheckBoxAutoWidth; + int m_nSortColumn; + + DECL_LINK(SelectHdl, SvTreeListBox*, void); + DECL_LINK(DeSelectHdl, SvTreeListBox*, void); + DECL_LINK(DoubleClickHdl, SvTreeListBox*, bool); + DECL_LINK(ExpandingHdl, SvTreeListBox*, bool); + DECL_LINK(EndDragHdl, HeaderBar*, void); + DECL_LINK(HeaderBarClickedHdl, HeaderBar*, void); + DECL_LINK(ToggleHdl, SvLBoxButtonData*, void); + DECL_LINK(ModelChangedHdl, SvTreeListBox*, void); + DECL_LINK(StartDragHdl, SvTreeListBox*, bool); + DECL_STATIC_LINK(SalInstanceTreeView, FinishDragHdl, SvTreeListBox*, void); + DECL_LINK(EditingEntryHdl, SvTreeListEntry*, bool); + typedef std::pair IterString; + DECL_LINK(EditedEntryHdl, IterString, bool); + DECL_LINK(VisibleRangeChangedHdl, SvTreeListBox*, void); + DECL_LINK(CompareHdl, const SvSortData&, sal_Int32); + DECL_LINK(PopupMenuHdl, const CommandEvent&, bool); + DECL_LINK(TooltipHdl, const HelpEvent&, bool); + DECL_LINK(CustomRenderHdl, svtree_render_args, void); + DECL_LINK(CustomMeasureHdl, svtree_measure_args, Size); + + bool IsDummyEntry(SvTreeListEntry* pEntry) const + { + return m_xTreeView->GetEntryText(pEntry).trim() == ""; + } + + SvTreeListEntry* GetPlaceHolderChild(SvTreeListEntry* pEntry) const + { + if (pEntry->HasChildren()) + { + auto pChild = m_xTreeView->FirstChild(pEntry); + assert(pChild); + if (IsDummyEntry(pChild)) + return pChild; + } + return nullptr; + } + + static void set_font_color(SvTreeListEntry* pEntry, const Color& rColor) + { + if (rColor == COL_AUTO) + pEntry->SetTextColor(std::optional()); + else + pEntry->SetTextColor(rColor); + } + + void AddStringItem(SvTreeListEntry* pEntry, const OUString& rStr, int nCol) + { + auto xCell = std::make_unique(rStr); + if (m_aCustomRenders.count(nCol)) + xCell->SetCustomRender(); + pEntry->AddItem(std::move(xCell)); + } + + void InvalidateModelEntry(SvTreeListEntry* pEntry) + { + if (!m_xTreeView->GetModel()->IsEnableInvalidate()) + return; + m_xTreeView->ModelHasEntryInvalidated(pEntry); + } + +public: + SalInstanceTreeView(SvTabListBox* pTreeView, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pTreeView, pBuilder, bTakeOwnership) + , m_xTreeView(pTreeView) + , m_aCheckButtonData(pTreeView, false) + , m_aRadioButtonData(pTreeView, true) + , m_bDisableCheckBoxAutoWidth(false) + , m_nSortColumn(-1) + { + m_xTreeView->SetNodeDefaultImages(); + m_xTreeView->SetForceMakeVisible(true); + m_xTreeView->SetSelectHdl(LINK(this, SalInstanceTreeView, SelectHdl)); + m_xTreeView->SetDeselectHdl(LINK(this, SalInstanceTreeView, DeSelectHdl)); + m_xTreeView->SetDoubleClickHdl(LINK(this, SalInstanceTreeView, DoubleClickHdl)); + m_xTreeView->SetExpandingHdl(LINK(this, SalInstanceTreeView, ExpandingHdl)); + m_xTreeView->SetPopupMenuHdl(LINK(this, SalInstanceTreeView, PopupMenuHdl)); + m_xTreeView->SetCustomRenderHdl(LINK(this, SalInstanceTreeView, CustomRenderHdl)); + m_xTreeView->SetCustomMeasureHdl(LINK(this, SalInstanceTreeView, CustomMeasureHdl)); + const long aTabPositions[] = { 0 }; + m_xTreeView->SetTabs(SAL_N_ELEMENTS(aTabPositions), aTabPositions); + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + + if (pHeaderBox) + { + if (HeaderBar* pHeaderBar = pHeaderBox->GetHeaderBar()) + { + //make the last entry fill available space + pHeaderBar->SetItemSize(pHeaderBar->GetItemId(pHeaderBar->GetItemCount() - 1), + HEADERBAR_FULLSIZE); + pHeaderBar->SetEndDragHdl(LINK(this, SalInstanceTreeView, EndDragHdl)); + pHeaderBar->SetSelectHdl(LINK(this, SalInstanceTreeView, HeaderBarClickedHdl)); + } + pHeaderBox->SetEditingEntryHdl(LINK(this, SalInstanceTreeView, EditingEntryHdl)); + pHeaderBox->SetEditedEntryHdl(LINK(this, SalInstanceTreeView, EditedEntryHdl)); + } + else + { + static_cast(*m_xTreeView) + .SetModelChangedHdl(LINK(this, SalInstanceTreeView, ModelChangedHdl)); + static_cast(*m_xTreeView) + .SetStartDragHdl(LINK(this, SalInstanceTreeView, StartDragHdl)); + static_cast(*m_xTreeView) + .SetEndDragHdl(LINK(this, SalInstanceTreeView, FinishDragHdl)); + static_cast(*m_xTreeView) + .SetEditingEntryHdl(LINK(this, SalInstanceTreeView, EditingEntryHdl)); + static_cast(*m_xTreeView) + .SetEditedEntryHdl(LINK(this, SalInstanceTreeView, EditedEntryHdl)); + } + m_aCheckButtonData.SetLink(LINK(this, SalInstanceTreeView, ToggleHdl)); + m_aRadioButtonData.SetLink(LINK(this, SalInstanceTreeView, ToggleHdl)); + } + + virtual void connect_query_tooltip(const Link& rLink) override + { + weld::TreeView::connect_query_tooltip(rLink); + m_xTreeView->SetTooltipHdl(LINK(this, SalInstanceTreeView, TooltipHdl)); + } + + virtual void columns_autosize() override + { + std::vector aWidths; + m_xTreeView->getPreferredDimensions(aWidths); + if (aWidths.size() > 2) + { + std::vector aColWidths; + for (size_t i = 1; i < aWidths.size() - 1; ++i) + aColWidths.push_back(aWidths[i] - aWidths[i - 1]); + set_column_fixed_widths(aColWidths); + } + } + + virtual void freeze() override + { + SalInstanceWidget::freeze(); + m_xTreeView->SetUpdateMode(false); + } + + virtual void thaw() override + { + m_xTreeView->SetUpdateMode(true); + SalInstanceWidget::thaw(); + } + + virtual void set_column_fixed_widths(const std::vector& rWidths) override + { + m_bDisableCheckBoxAutoWidth = true; + std::vector aTabPositions; + aTabPositions.push_back(0); + for (size_t i = 0; i < rWidths.size(); ++i) + aTabPositions.push_back(aTabPositions[i] + rWidths[i]); + m_xTreeView->SetTabs(aTabPositions.size(), aTabPositions.data(), MapUnit::MapPixel); + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr) + { + for (size_t i = 0; i < rWidths.size(); ++i) + pHeaderBar->SetItemSize(pHeaderBar->GetItemId(i), rWidths[i]); + } + // call Resize to recalculate based on the new tabs + m_xTreeView->Resize(); + } + + virtual void set_column_editables(const std::vector& rEditables) override + { + size_t nTabCount = rEditables.size(); + for (size_t i = 0 ; i < nTabCount; ++i) + m_xTreeView->SetTabEditable(i, rEditables[i]); + } + + virtual void set_centered_column(int nCol) override + { + m_xTreeView->SetTabJustify(nCol, SvTabJustify::AdjustCenter); + } + + virtual int get_column_width(int nColumn) const override + { + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr) + return pHeaderBar->GetItemSize(pHeaderBar->GetItemId(nColumn)); + // GetTab(0) gives the position of the bitmap which is automatically inserted by the TabListBox. + // So the first text column's width is Tab(2)-Tab(1). + auto nWidthPixel + = m_xTreeView->GetLogicTab(nColumn + 2) - m_xTreeView->GetLogicTab(nColumn + 1); + nWidthPixel -= SV_TAB_BORDER; + return nWidthPixel; + } + + virtual OUString get_column_title(int nColumn) const override + { + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr) + { + return pHeaderBar->GetItemText(pHeaderBar->GetItemId(nColumn)); + } + return OUString(); + } + + virtual void set_column_title(int nColumn, const OUString& rTitle) override + { + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr) + { + return pHeaderBar->SetItemText(pHeaderBar->GetItemId(nColumn), rTitle); + } + } + + virtual void set_column_custom_renderer(int nColumn, bool bEnable) override + { + assert(n_children() == 0 && "tree must be empty"); + if (bEnable) + m_aCustomRenders.insert(nColumn); + else + m_aCustomRenders.erase(nColumn); + } + + virtual void show() override + { + if (LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get())) + pHeaderBox->GetParent()->Show(); + SalInstanceContainer::show(); + } + + virtual void hide() override + { + if (LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get())) + pHeaderBox->GetParent()->Hide(); + SalInstanceContainer::hide(); + } + + virtual void insert(const weld::TreeIter* pParent, int pos, const OUString* pStr, + const OUString* pId, const OUString* pIconName, + VirtualDevice* pImageSurface, const OUString* pExpanderName, + bool bChildrenOnDemand, weld::TreeIter* pRet) override + { + disable_notify_events(); + const SalInstanceTreeIter* pVclIter = static_cast(pParent); + SvTreeListEntry* iter = pVclIter ? pVclIter->iter : nullptr; + auto nInsertPos = pos == -1 ? TREELIST_APPEND : pos; + void* pUserData; + if (pId) + { + m_aUserData.emplace_back(std::make_unique(*pId)); + pUserData = m_aUserData.back().get(); + } + else + pUserData = nullptr; + + SvTreeListEntry* pEntry = new SvTreeListEntry; + if (pIconName || pImageSurface) + { + Image aImage(pIconName ? createImage(*pIconName) : createImage(*pImageSurface)); + pEntry->AddItem(std::make_unique(aImage, aImage, false)); + } + else + { + Image aDummy; + pEntry->AddItem(std::make_unique(aDummy, aDummy, false)); + } + if (pStr) + AddStringItem(pEntry, *pStr, 0); + pEntry->SetUserData(pUserData); + m_xTreeView->Insert(pEntry, iter, nInsertPos); + + if (pExpanderName) + { + Image aImage(createImage(*pExpanderName)); + m_xTreeView->SetExpandedEntryBmp(pEntry, aImage); + m_xTreeView->SetCollapsedEntryBmp(pEntry, aImage); + } + + if (pRet) + { + SalInstanceTreeIter* pVclRetIter = static_cast(pRet); + pVclRetIter->iter = pEntry; + } + + if (bChildrenOnDemand) + { + SvTreeListEntry* pPlaceHolder = m_xTreeView->InsertEntry("", pEntry, false, 0, nullptr); + SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pPlaceHolder); + pViewData->SetSelectable(false); + } + enable_notify_events(); + } + + virtual void + bulk_insert_for_each(int nSourceCount, + const std::function& func, + const std::vector* pFixedWidths) override + { + freeze(); + clear(); + SalInstanceTreeIter aVclIter(static_cast(nullptr)); + + m_xTreeView->nTreeFlags |= SvTreeFlags::MANINS; + + if (pFixedWidths) + set_column_fixed_widths(*pFixedWidths); + + Image aDummy; + for (int i = 0; i < nSourceCount; ++i) + { + aVclIter.iter = new SvTreeListEntry; + aVclIter.iter->AddItem(std::make_unique(aDummy, aDummy, false)); + m_xTreeView->Insert(aVclIter.iter, nullptr, TREELIST_APPEND); + func(aVclIter, i); + + if (!pFixedWidths) + continue; + + size_t nFixedWidths = std::min(pFixedWidths->size(), aVclIter.iter->ItemCount()); + for (size_t j = 0; j < nFixedWidths; ++j) + { + SvLBoxItem& rItem = aVclIter.iter->GetItem(j); + SvViewDataItem* pViewDataItem = m_xTreeView->GetViewDataItem(aVclIter.iter, &rItem); + pViewDataItem->mnWidth = (*pFixedWidths)[j]; + } + } + + m_xTreeView->nTreeFlags &= ~SvTreeFlags::MANINS; + + thaw(); + } + + virtual void set_font_color(int pos, const Color& rColor) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_font_color(pEntry, rColor); + } + + virtual void set_font_color(const weld::TreeIter& rIter, const Color& rColor) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_font_color(rVclIter.iter, rColor); + } + + virtual void remove(int pos) override + { + disable_notify_events(); + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + m_xTreeView->RemoveEntry(pEntry); + enable_notify_events(); + } + + virtual int find_text(const OUString& rText) const override + { + for (SvTreeListEntry* pEntry = m_xTreeView->First(); pEntry; + pEntry = m_xTreeView->Next(pEntry)) + { + if (SvTabListBox::GetEntryText(pEntry, 0) == rText) + return SvTreeList::GetRelPos(pEntry); + } + return -1; + } + + virtual int find_id(const OUString& rId) const override + { + for (SvTreeListEntry* pEntry = m_xTreeView->First(); pEntry; + pEntry = m_xTreeView->Next(pEntry)) + { + const OUString* pId = static_cast(pEntry->GetUserData()); + if (!pId) + continue; + if (rId == *pId) + return SvTreeList::GetRelPos(pEntry); + } + return -1; + } + + virtual void swap(int pos1, int pos2) override + { + int min = std::min(pos1, pos2); + int max = std::max(pos1, pos2); + SvTreeList* pModel = m_xTreeView->GetModel(); + SvTreeListEntry* pEntry1 = pModel->GetEntry(nullptr, min); + SvTreeListEntry* pEntry2 = pModel->GetEntry(nullptr, max); + pModel->Move(pEntry1, pEntry2); + } + + virtual void clear() override + { + disable_notify_events(); + m_xTreeView->Clear(); + m_aUserData.clear(); + enable_notify_events(); + } + + virtual int n_children() const override + { + return m_xTreeView->GetModel()->GetChildList(nullptr).size(); + } + + virtual int iter_n_children(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return m_xTreeView->GetModel()->GetChildList(rVclIter.iter).size(); + } + + virtual void select(int pos) override + { + assert(m_xTreeView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + if (pos == -1 || (pos == 0 && n_children() == 0)) + m_xTreeView->SelectAll(false); + else + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + m_xTreeView->Select(pEntry, true); + m_xTreeView->MakeVisible(pEntry); + } + enable_notify_events(); + } + + virtual int get_cursor_index() const override + { + SvTreeListEntry* pEntry = m_xTreeView->GetCurEntry(); + if (!pEntry) + return -1; + return SvTreeList::GetRelPos(pEntry); + } + + virtual void set_cursor(int pos) override + { + disable_notify_events(); + if (pos == -1) + m_xTreeView->SetCurEntry(nullptr); + else + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + m_xTreeView->SetCurEntry(pEntry); + } + enable_notify_events(); + } + + virtual void scroll_to_row(int pos) override + { + assert(m_xTreeView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + m_xTreeView->MakeVisible(pEntry); + enable_notify_events(); + } + + virtual bool is_selected(int pos) const override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + return m_xTreeView->IsSelected(pEntry); + } + + virtual void unselect(int pos) override + { + assert(m_xTreeView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + if (pos == -1) + m_xTreeView->SelectAll(true); + else + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + m_xTreeView->Select(pEntry, false); + } + enable_notify_events(); + } + + virtual std::vector get_selected_rows() const override + { + std::vector aRows; + + aRows.reserve(m_xTreeView->GetSelectionCount()); + for (SvTreeListEntry* pEntry = m_xTreeView->FirstSelected(); pEntry; + pEntry = m_xTreeView->NextSelected(pEntry)) + aRows.push_back(SvTreeList::GetRelPos(pEntry)); + + return aRows; + } + + static OUString get_text(SvTreeListEntry* pEntry, int col) + { + if (col == -1) + return SvTabListBox::GetEntryText(pEntry, 0); + + ++col; //skip dummy/expander column + + if (static_cast(col) == pEntry->ItemCount()) + return OUString(); + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + return static_cast(rItem).GetText(); + } + + virtual OUString get_text(int pos, int col) const override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + return get_text(pEntry, col); + } + + void set_text(SvTreeListEntry* pEntry, const OUString& rText, int col) + { + if (col == -1) + { + m_xTreeView->SetEntryText(pEntry, rText); + return; + } + + ++col; //skip dummy/expander column + + // blank out missing entries + for (int i = pEntry->ItemCount(); i < col; ++i) + AddStringItem(pEntry, "", i - 1); + + if (static_cast(col) == pEntry->ItemCount()) + { + AddStringItem(pEntry, rText, col - 1); + SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry); + m_xTreeView->InitViewData(pViewData, pEntry); + } + else + { + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + static_cast(rItem).SetText(rText); + } + InvalidateModelEntry(pEntry); + } + + virtual void set_text(int pos, const OUString& rText, int col) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_text(pEntry, rText, col); + } + + void set_sensitive(SvTreeListEntry* pEntry, bool bSensitive, int col) + { + if (col == -1) + { + auto nFlags = pEntry->GetFlags() & ~SvTLEntryFlags::SEMITRANSPARENT; + if (!bSensitive) + nFlags = nFlags | SvTLEntryFlags::SEMITRANSPARENT; + pEntry->SetFlags(nFlags); + const sal_uInt16 nCount = pEntry->ItemCount(); + for (sal_uInt16 nCur = 0; nCur < nCount; ++nCur) + { + SvLBoxItem& rItem = pEntry->GetItem(nCur); + if (rItem.GetType() == SvLBoxItemType::String) + { + rItem.Enable(bSensitive); + InvalidateModelEntry(pEntry); + break; + } + } + return; + } + + ++col; //skip dummy/expander column + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + rItem.Enable(bSensitive); + + InvalidateModelEntry(pEntry); + } + + using SalInstanceWidget::set_sensitive; + + virtual void set_sensitive(int pos, bool bSensitive, int col) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_sensitive(pEntry, bSensitive, col); + } + + virtual void set_sensitive(const weld::TreeIter& rIter, bool bSensitive, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_sensitive(rVclIter.iter, bSensitive, col); + } + + virtual TriState get_toggle(int pos, int col) const override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + return ::get_toggle(pEntry, col); + } + + virtual TriState get_toggle(const weld::TreeIter& rIter, int col) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return ::get_toggle(rVclIter.iter, col); + } + + void set_toggle(SvTreeListEntry* pEntry, TriState eState, int col) + { + bool bRadio = std::find(m_aRadioIndexes.begin(), m_aRadioIndexes.end(), col) + != m_aRadioIndexes.end(); + ++col; //skip dummy/expander column + + // blank out missing entries + for (int i = pEntry->ItemCount(); i < col; ++i) + AddStringItem(pEntry, "", i - 1); + + if (static_cast(col) == pEntry->ItemCount()) + { + SvLBoxButtonData* pData = bRadio ? &m_aRadioButtonData : &m_aCheckButtonData; + + // if we want to have the implicit auto-sizing of the checkbox + // column we need to call EnableCheckButton and CheckBoxInserted to + // let it figure out that width. But we don't want to override any + // explicitly set column width, so disable this if we've set + // explicit column widths + if (!m_bDisableCheckBoxAutoWidth) + { + if (!(m_xTreeView->GetTreeFlags() & SvTreeFlags::CHKBTN)) + { + m_xTreeView->EnableCheckButton(pData); + // EnableCheckButton clobbered this, restore it + pData->SetLink(LINK(this, SalInstanceTreeView, ToggleHdl)); + } + } + + pEntry->AddItem(std::make_unique(pData)); + SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry); + m_xTreeView->InitViewData(pViewData, pEntry); + + if (!m_bDisableCheckBoxAutoWidth) + m_xTreeView->CheckBoxInserted(pEntry); + } + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + switch (eState) + { + case TRISTATE_TRUE: + static_cast(rItem).SetStateChecked(); + break; + case TRISTATE_FALSE: + static_cast(rItem).SetStateUnchecked(); + break; + case TRISTATE_INDET: + static_cast(rItem).SetStateTristate(); + break; + } + + InvalidateModelEntry(pEntry); + } + + virtual void set_toggle(int pos, TriState eState, int col) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_toggle(pEntry, eState, col); + } + + virtual void set_toggle(const weld::TreeIter& rIter, TriState eState, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_toggle(rVclIter.iter, eState, col); + } + + virtual void set_extra_row_indent(const weld::TreeIter& rIter, int nIndentLevel) override + { + weld::TreeIter& rNonConstIter = const_cast(rIter); + SalInstanceTreeIter& rVclIter = static_cast(rNonConstIter); + rVclIter.iter->SetExtraIndent(nIndentLevel); + } + + void set_text_emphasis(SvTreeListEntry* pEntry, bool bOn, int col) + { + ++col; //skip dummy/expander column + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + static_cast(rItem).Emphasize(bOn); + + InvalidateModelEntry(pEntry); + } + + virtual void set_text_emphasis(const weld::TreeIter& rIter, bool bOn, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_text_emphasis(rVclIter.iter, bOn, col); + } + + virtual void set_text_emphasis(int pos, bool bOn, int col) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_text_emphasis(pEntry, bOn, col); + } + + virtual bool get_text_emphasis(const weld::TreeIter& rIter, int col) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return ::get_text_emphasis(rVclIter.iter, col); + } + + virtual bool get_text_emphasis(int pos, int col) const override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + return ::get_text_emphasis(pEntry, col); + } + + void set_text_align(SvTreeListEntry* pEntry, double fAlign, int col) + { + ++col; //skip dummy/expander column + + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + static_cast(rItem).Align(fAlign); + + InvalidateModelEntry(pEntry); + } + + virtual void set_text_align(const weld::TreeIter& rIter, double fAlign, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_text_align(rVclIter.iter, fAlign, col); + } + + virtual void set_text_align(int pos, double fAlign, int col) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_text_align(pEntry, fAlign, col); + } + + virtual void connect_editing( + const Link& rStartLink, + const Link&, bool>& rEndLink) override + { + m_xTreeView->EnableInplaceEditing(rStartLink.IsSet() || rEndLink.IsSet()); + weld::TreeView::connect_editing(rStartLink, rEndLink); + } + + virtual void start_editing(const weld::TreeIter& rIter) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + m_xTreeView->EditEntry(rVclIter.iter); + } + + virtual void end_editing() override { m_xTreeView->EndEditing(); } + + void set_image(SvTreeListEntry* pEntry, const Image& rImage, int col) + { + if (col == -1) + { + m_xTreeView->SetExpandedEntryBmp(pEntry, rImage); + m_xTreeView->SetCollapsedEntryBmp(pEntry, rImage); + return; + } + + ++col; //skip dummy/expander column + + // blank out missing entries + for (int i = pEntry->ItemCount(); i < col; ++i) + AddStringItem(pEntry, "", i - 1); + + if (static_cast(col) == pEntry->ItemCount()) + { + pEntry->AddItem(std::make_unique(rImage, rImage, false)); + SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry); + m_xTreeView->InitViewData(pViewData, pEntry); + } + else + { + assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount()); + SvLBoxItem& rItem = pEntry->GetItem(col); + assert(dynamic_cast(&rItem)); + static_cast(rItem).SetBitmap1(rImage); + static_cast(rItem).SetBitmap2(rImage); + } + + m_xTreeView->SetEntryHeight(pEntry); + InvalidateModelEntry(pEntry); + } + + virtual void set_image(int pos, const OUString& rImage, int col) override + { + set_image(m_xTreeView->GetEntry(nullptr, pos), createImage(rImage), col); + } + + virtual void set_image(int pos, const css::uno::Reference& rImage, + int col) override + { + set_image(m_xTreeView->GetEntry(nullptr, pos), Image(rImage), col); + } + + virtual void set_image(int pos, VirtualDevice& rImage, int col) override + { + set_image(m_xTreeView->GetEntry(nullptr, pos), createImage(rImage), col); + } + + virtual void set_image(const weld::TreeIter& rIter, const OUString& rImage, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_image(rVclIter.iter, createImage(rImage), col); + } + + virtual void set_image(const weld::TreeIter& rIter, + const css::uno::Reference& rImage, + int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_image(rVclIter.iter, Image(rImage), col); + } + + virtual void set_image(const weld::TreeIter& rIter, VirtualDevice& rImage, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_image(rVclIter.iter, createImage(rImage), col); + } + + const OUString* getEntryData(int index) const + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, index); + return pEntry ? static_cast(pEntry->GetUserData()) : nullptr; + } + + virtual OUString get_id(int pos) const override + { + const OUString* pRet = getEntryData(pos); + if (!pRet) + return OUString(); + return *pRet; + } + + void set_id(SvTreeListEntry* pEntry, const OUString& rId) + { + m_aUserData.emplace_back(std::make_unique(rId)); + pEntry->SetUserData(m_aUserData.back().get()); + } + + virtual void set_id(int pos, const OUString& rId) override + { + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos); + set_id(pEntry, rId); + } + + virtual int get_selected_index() const override + { + assert(m_xTreeView->IsUpdateMode() && "don't request selection when frozen"); + SvTreeListEntry* pEntry = m_xTreeView->FirstSelected(); + if (!pEntry) + return -1; + return SvTreeList::GetRelPos(pEntry); + } + + virtual OUString get_selected_text() const override + { + assert(m_xTreeView->IsUpdateMode() && "don't request selection when frozen"); + if (SvTreeListEntry* pEntry = m_xTreeView->FirstSelected()) + return m_xTreeView->GetEntryText(pEntry); + return OUString(); + } + + virtual OUString get_selected_id() const override + { + assert(m_xTreeView->IsUpdateMode() && "don't request selection when frozen"); + if (SvTreeListEntry* pEntry = m_xTreeView->FirstSelected()) + { + if (const OUString* pStr = static_cast(pEntry->GetUserData())) + return *pStr; + } + return OUString(); + } + + virtual std::unique_ptr + make_iterator(const weld::TreeIter* pOrig) const override + { + return std::unique_ptr( + new SalInstanceTreeIter(static_cast(pOrig))); + } + + virtual void copy_iterator(const weld::TreeIter& rSource, weld::TreeIter& rDest) const override + { + const SalInstanceTreeIter& rVclSource(static_cast(rSource)); + SalInstanceTreeIter& rVclDest(static_cast(rDest)); + rVclDest.iter = rVclSource.iter; + } + + virtual bool get_selected(weld::TreeIter* pIter) const override + { + SvTreeListEntry* pEntry = m_xTreeView->FirstSelected(); + auto pVclIter = static_cast(pIter); + if (pVclIter) + pVclIter->iter = pEntry; + return pEntry != nullptr; + } + + virtual bool get_cursor(weld::TreeIter* pIter) const override + { + SvTreeListEntry* pEntry = m_xTreeView->GetCurEntry(); + auto pVclIter = static_cast(pIter); + if (pVclIter) + pVclIter->iter = pEntry; + return pEntry != nullptr; + } + + virtual void set_cursor(const weld::TreeIter& rIter) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + disable_notify_events(); + m_xTreeView->SetCurEntry(rVclIter.iter); + enable_notify_events(); + } + + virtual bool get_iter_first(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xTreeView->GetEntry(0); + return rVclIter.iter != nullptr; + } + + virtual bool iter_next_sibling(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = rVclIter.iter->NextSibling(); + return rVclIter.iter != nullptr; + } + + virtual bool iter_previous_sibling(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = rVclIter.iter->PrevSibling(); + return rVclIter.iter != nullptr; + } + + virtual bool iter_next(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xTreeView->Next(rVclIter.iter); + if (rVclIter.iter && IsDummyEntry(rVclIter.iter)) + return iter_next(rVclIter); + return rVclIter.iter != nullptr; + } + + virtual bool iter_previous(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xTreeView->Prev(rVclIter.iter); + if (rVclIter.iter && IsDummyEntry(rVclIter.iter)) + return iter_previous(rVclIter); + return rVclIter.iter != nullptr; + } + + virtual bool iter_next_visible(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xTreeView->NextVisible(rVclIter.iter); + if (rVclIter.iter && IsDummyEntry(rVclIter.iter)) + return iter_next_visible(rVclIter); + return rVclIter.iter != nullptr; + } + + virtual bool iter_children(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xTreeView->FirstChild(rVclIter.iter); + bool bRet = rVclIter.iter != nullptr; + if (bRet) + { + //on-demand dummy entry doesn't count + return !IsDummyEntry(rVclIter.iter); + } + return bRet; + } + + virtual bool iter_parent(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xTreeView->GetParent(rVclIter.iter); + return rVclIter.iter != nullptr; + } + + virtual void remove(const weld::TreeIter& rIter) override + { + disable_notify_events(); + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + m_xTreeView->RemoveEntry(rVclIter.iter); + enable_notify_events(); + } + + virtual void select(const weld::TreeIter& rIter) override + { + assert(m_xTreeView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + m_xTreeView->Select(rVclIter.iter, true); + enable_notify_events(); + } + + virtual void scroll_to_row(const weld::TreeIter& rIter) override + { + assert(m_xTreeView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + m_xTreeView->MakeVisible(rVclIter.iter); + enable_notify_events(); + } + + virtual void unselect(const weld::TreeIter& rIter) override + { + assert(m_xTreeView->IsUpdateMode() && "don't unselect when frozen"); + disable_notify_events(); + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + m_xTreeView->Select(rVclIter.iter, false); + enable_notify_events(); + } + + virtual int get_iter_depth(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return m_xTreeView->GetModel()->GetDepth(rVclIter.iter); + } + + virtual bool iter_has_child(const weld::TreeIter& rIter) const override + { + weld::TreeIter& rNonConstIter = const_cast(rIter); + SalInstanceTreeIter& rVclIter = static_cast(rNonConstIter); + SvTreeListEntry* restore(rVclIter.iter); + bool ret = iter_children(rNonConstIter); + rVclIter.iter = restore; + return ret; + } + + virtual bool get_row_expanded(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return m_xTreeView->IsExpanded(rVclIter.iter); + } + + virtual bool get_children_on_demand(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + if (m_aExpandingPlaceHolderParents.count(rVclIter.iter)) + return true; + return GetPlaceHolderChild(rVclIter.iter) != nullptr; + } + + virtual void set_children_on_demand(const weld::TreeIter& rIter, bool bChildrenOnDemand) override + { + disable_notify_events(); + + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + + SvTreeListEntry* pPlaceHolder = GetPlaceHolderChild(rVclIter.iter); + + if (bChildrenOnDemand && !pPlaceHolder) + { + pPlaceHolder = m_xTreeView->InsertEntry("", rVclIter.iter, false, 0, nullptr); + SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pPlaceHolder); + pViewData->SetSelectable(false); + } + else if (!bChildrenOnDemand && pPlaceHolder) + m_xTreeView->RemoveEntry(pPlaceHolder); + + enable_notify_events(); + } + + virtual void expand_row(const weld::TreeIter& rIter) override + { + assert(m_xTreeView->IsUpdateMode() && "don't expand when frozen"); + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + if (!m_xTreeView->IsExpanded(rVclIter.iter) && signal_expanding(rIter)) + m_xTreeView->Expand(rVclIter.iter); + } + + virtual void collapse_row(const weld::TreeIter& rIter) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + if (m_xTreeView->IsExpanded(rVclIter.iter) && signal_collapsing(rIter)) + m_xTreeView->Collapse(rVclIter.iter); + } + + virtual OUString get_text(const weld::TreeIter& rIter, int col) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return get_text(rVclIter.iter, col); + } + + virtual void set_text(const weld::TreeIter& rIter, const OUString& rText, int col) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_text(rVclIter.iter, rText, col); + } + + virtual OUString get_id(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + const OUString* pStr = static_cast(rVclIter.iter->GetUserData()); + if (pStr) + return *pStr; + return OUString(); + } + + virtual void set_id(const weld::TreeIter& rIter, const OUString& rId) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + set_id(rVclIter.iter, rId); + } + + virtual void enable_drag_source(rtl::Reference& rHelper, + sal_uInt8 eDNDConstants) override + { + m_xTreeView->SetDragHelper(rHelper, eDNDConstants); + } + + virtual void set_selection_mode(SelectionMode eMode) override + { + m_xTreeView->SetSelectionMode(eMode); + } + + virtual void all_foreach(const std::function& func) override + { + UpdateGuardIfHidden aGuard(*m_xTreeView); + + SalInstanceTreeIter aVclIter(m_xTreeView->First()); + while (aVclIter.iter) + { + if (func(aVclIter)) + return; + iter_next(aVclIter); + } + } + + virtual void selected_foreach(const std::function& func) override + { + SalInstanceTreeIter aVclIter(m_xTreeView->FirstSelected()); + while (aVclIter.iter) + { + if (func(aVclIter)) + return; + aVclIter.iter = m_xTreeView->NextSelected(aVclIter.iter); + } + } + + virtual void visible_foreach(const std::function& func) override + { + SalInstanceTreeIter aVclIter(m_xTreeView->GetFirstEntryInView()); + while (aVclIter.iter) + { + if (func(aVclIter)) + return; + aVclIter.iter = m_xTreeView->GetNextEntryInView(aVclIter.iter); + } + } + + virtual void connect_visible_range_changed(const Link& rLink) override + { + weld::TreeView::connect_visible_range_changed(rLink); + m_xTreeView->SetScrolledHdl(LINK(this, SalInstanceTreeView, VisibleRangeChangedHdl)); + } + + virtual void remove_selection() override + { + disable_notify_events(); + SvTreeListEntry* pSelected = m_xTreeView->FirstSelected(); + while (pSelected) + { + SvTreeListEntry* pNextSelected = m_xTreeView->NextSelected(pSelected); + m_xTreeView->RemoveEntry(pSelected); + pSelected = pNextSelected; + } + enable_notify_events(); + } + + virtual bool is_selected(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return m_xTreeView->IsSelected(rVclIter.iter); + } + + virtual int get_iter_index_in_parent(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + return SvTreeList::GetRelPos(rVclIter.iter); + } + + virtual int iter_compare(const weld::TreeIter& a, const weld::TreeIter& b) const override + { + const SalInstanceTreeIter& rVclIterA = static_cast(a); + const SalInstanceTreeIter& rVclIterB = static_cast(b); + const SvTreeList* pModel = m_xTreeView->GetModel(); + auto nAbsPosA = pModel->GetAbsPos(rVclIterA.iter); + auto nAbsPosB = pModel->GetAbsPos(rVclIterB.iter); + if (nAbsPosA < nAbsPosB) + return -1; + if (nAbsPosA > nAbsPosB) + return 1; + return 0; + } + + virtual void move_subtree(weld::TreeIter& rNode, const weld::TreeIter* pNewParent, + int nIndexInNewParent) override + { + SalInstanceTreeIter& rVclIter = static_cast(rNode); + const SalInstanceTreeIter* pVclParentIter + = static_cast(pNewParent); + m_xTreeView->GetModel()->Move( + rVclIter.iter, pVclParentIter ? pVclParentIter->iter : nullptr, nIndexInNewParent); + } + + virtual int count_selected_rows() const override { return m_xTreeView->GetSelectionCount(); } + + virtual int get_height_rows(int nRows) const override + { + return m_xTreeView->GetEntryHeight() * nRows; + } + + virtual void make_sorted() override + { + assert(m_xTreeView->IsUpdateMode() && "don't sort when frozen"); + m_xTreeView->SetStyle(m_xTreeView->GetStyle() | WB_SORT); + m_xTreeView->GetModel()->SetCompareHdl(LINK(this, SalInstanceTreeView, CompareHdl)); + set_sort_order(true); + } + + virtual void set_sort_func( + const std::function& func) override + { + weld::TreeView::set_sort_func(func); + SvTreeList* pListModel = m_xTreeView->GetModel(); + pListModel->Resort(); + } + + virtual void make_unsorted() override + { + m_xTreeView->SetStyle(m_xTreeView->GetStyle() & ~WB_SORT); + } + + virtual void set_sort_order(bool bAscending) override + { + SvTreeList* pListModel = m_xTreeView->GetModel(); + pListModel->SetSortMode(bAscending ? SortAscending : SortDescending); + pListModel->Resort(); + } + + virtual bool get_sort_order() const override + { + return m_xTreeView->GetModel()->GetSortMode() == SortAscending; + } + + virtual void set_sort_indicator(TriState eState, int col) override + { + if (col == -1) + col = 0; + + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr) + { + sal_uInt16 nTextId = pHeaderBar->GetItemId(col); + HeaderBarItemBits nBits = pHeaderBar->GetItemBits(nTextId); + nBits &= ~HeaderBarItemBits::UPARROW; + nBits &= ~HeaderBarItemBits::DOWNARROW; + if (eState != TRISTATE_INDET) + { + if (eState == TRISTATE_TRUE) + nBits |= HeaderBarItemBits::DOWNARROW; + else + nBits |= HeaderBarItemBits::UPARROW; + } + pHeaderBar->SetItemBits(nTextId, nBits); + } + } + + virtual TriState get_sort_indicator(int col) const override + { + if (col == -1) + col = 0; + + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr) + { + sal_uInt16 nTextId = pHeaderBar->GetItemId(col); + HeaderBarItemBits nBits = pHeaderBar->GetItemBits(nTextId); + if (nBits & HeaderBarItemBits::DOWNARROW) + return TRISTATE_TRUE; + if (nBits & HeaderBarItemBits::UPARROW) + return TRISTATE_FALSE; + } + + return TRISTATE_INDET; + } + + virtual int get_sort_column() const override { return m_nSortColumn; } + + virtual void set_sort_column(int nColumn) override + { + if (nColumn == -1) + { + make_unsorted(); + m_nSortColumn = -1; + return; + } + + if (nColumn != m_nSortColumn) + { + m_nSortColumn = nColumn; + m_xTreeView->GetModel()->Resort(); + } + } + + SvTabListBox& getTreeView() { return *m_xTreeView; } + + virtual bool get_dest_row_at_pos(const Point& rPos, weld::TreeIter* pResult, bool bHighLightTarget) override + { + LclTabListBox* pTreeView = !bHighLightTarget ? dynamic_cast(m_xTreeView.get()) : nullptr; + SvTreeListEntry* pTarget = pTreeView ? pTreeView->GetTargetAtPoint(rPos, false) : m_xTreeView->GetDropTarget(rPos); + + if (pTarget && pResult) + { + SalInstanceTreeIter& rSalIter = static_cast(*pResult); + rSalIter.iter = pTarget; + } + + return pTarget != nullptr; + } + + virtual void unset_drag_dest_row() override + { + m_xTreeView->UnsetDropTarget(); + } + + virtual tools::Rectangle get_row_area(const weld::TreeIter& rIter) const override + { + return m_xTreeView->GetBoundingRect(static_cast(rIter).iter); + } + + virtual TreeView* get_drag_source() const override { return g_DragSource; } + + virtual int vadjustment_get_value() const override + { + int nValue = -1; + const SvTreeListEntry* pEntry = m_xTreeView->GetFirstEntryInView(); + if (pEntry) + nValue = m_xTreeView->GetAbsPos(pEntry); + return nValue; + } + + virtual void vadjustment_set_value(int nValue) override + { + if (nValue == -1) + return; + bool bUpdate = m_xTreeView->IsUpdateMode(); + if (bUpdate) + m_xTreeView->SetUpdateMode(false); + m_xTreeView->ScrollToAbsPos(nValue); + if (bUpdate) + m_xTreeView->SetUpdateMode(true); + } + + virtual ~SalInstanceTreeView() override + { + LclHeaderTabListBox* pHeaderBox = dynamic_cast(m_xTreeView.get()); + if (pHeaderBox) + { + if (HeaderBar* pHeaderBar = pHeaderBox->GetHeaderBar()) + { + pHeaderBar->SetSelectHdl(Link()); + pHeaderBar->SetEndDragHdl(Link()); + } + } + else + { + static_cast(*m_xTreeView).SetEndDragHdl(Link()); + static_cast(*m_xTreeView).SetStartDragHdl(Link()); + static_cast(*m_xTreeView) + .SetModelChangedHdl(Link()); + } + m_xTreeView->SetPopupMenuHdl(Link()); + m_xTreeView->SetExpandingHdl(Link()); + m_xTreeView->SetDoubleClickHdl(Link()); + m_xTreeView->SetSelectHdl(Link()); + m_xTreeView->SetDeselectHdl(Link()); + m_xTreeView->SetScrolledHdl(Link()); + m_xTreeView->SetTooltipHdl(Link()); + m_xTreeView->SetCustomRenderHdl(Link()); + m_xTreeView->SetCustomMeasureHdl(Link()); + } +}; + +IMPL_LINK(SalInstanceTreeView, TooltipHdl, const HelpEvent&, rHEvt, bool) +{ + if (notify_events_disabled()) + return false; + Point aPos(m_xTreeView->ScreenToOutputPixel(rHEvt.GetMousePosPixel())); + SvTreeListEntry* pEntry = m_xTreeView->GetEntry(aPos); + if (pEntry) + { + SalInstanceTreeIter aIter(pEntry); + OUString aTooltip = signal_query_tooltip(aIter); + if (aTooltip.isEmpty()) + return false; + Size aSize(m_xTreeView->GetOutputSizePixel().Width(), m_xTreeView->GetEntryHeight()); + tools::Rectangle aScreenRect( + m_xTreeView->OutputToScreenPixel(m_xTreeView->GetEntryPosition(pEntry)), aSize); + Help::ShowQuickHelp(m_xTreeView, aScreenRect, aTooltip); + } + return true; +} + +IMPL_LINK(SalInstanceTreeView, CustomRenderHdl, svtree_render_args, payload, void) +{ + vcl::RenderContext& rRenderDevice = std::get<0>(payload); + const tools::Rectangle& rRect = std::get<1>(payload); + const SvTreeListEntry& rEntry = std::get<2>(payload); + const OUString* pId = static_cast(rEntry.GetUserData()); + if (!pId) + return; + signal_custom_render(rRenderDevice, rRect, m_xTreeView->IsSelected(&rEntry), *pId); +} + +IMPL_LINK(SalInstanceTreeView, CustomMeasureHdl, svtree_measure_args, payload, Size) +{ + vcl::RenderContext& rRenderDevice = payload.first; + const SvTreeListEntry& rEntry = payload.second; + const OUString* pId = static_cast(rEntry.GetUserData()); + if (!pId) + return Size(); + return signal_custom_get_size(rRenderDevice, *pId); +} + +IMPL_LINK(SalInstanceTreeView, CompareHdl, const SvSortData&, rSortData, sal_Int32) +{ + const SvTreeListEntry* pLHS = rSortData.pLeft; + const SvTreeListEntry* pRHS = rSortData.pRight; + assert(pLHS && pRHS); + + if (m_aCustomSort) + return m_aCustomSort(SalInstanceTreeIter(const_cast(pLHS)), + SalInstanceTreeIter(const_cast(pRHS))); + + const SvLBoxString* pLeftTextItem; + const SvLBoxString* pRightTextItem; + + if (m_nSortColumn != -1) + { + size_t col = m_nSortColumn; + + ++col; //skip dummy/expander column + + if (col < pLHS->ItemCount()) + { + const SvLBoxString& rLeftTextItem + = static_cast(pLHS->GetItem(col)); + pLeftTextItem = &rLeftTextItem; + } + else + pLeftTextItem = nullptr; + if (col < pRHS->ItemCount()) + { + const SvLBoxString& rRightTextItem + = static_cast(pRHS->GetItem(col)); + pRightTextItem = &rRightTextItem; + } + else + pRightTextItem = nullptr; + } + else + { + pLeftTextItem + = static_cast(pLHS->GetFirstItem(SvLBoxItemType::String)); + pRightTextItem + = static_cast(pRHS->GetFirstItem(SvLBoxItemType::String)); + } + + return m_xTreeView->DefaultCompare(pLeftTextItem, pRightTextItem); +} + +IMPL_LINK_NOARG(SalInstanceTreeView, VisibleRangeChangedHdl, SvTreeListBox*, void) +{ + if (notify_events_disabled()) + return; + signal_visible_range_changed(); +} + +IMPL_LINK_NOARG(SalInstanceTreeView, ModelChangedHdl, SvTreeListBox*, void) +{ + if (notify_events_disabled()) + return; + signal_model_changed(); +} + +IMPL_LINK_NOARG(SalInstanceTreeView, StartDragHdl, SvTreeListBox*, bool) +{ + bool bUnsetDragIcon(false); // ignored for vcl + if (m_aDragBeginHdl.Call(bUnsetDragIcon)) + return true; + g_DragSource = this; + return false; +} + +IMPL_STATIC_LINK_NOARG(SalInstanceTreeView, FinishDragHdl, SvTreeListBox*, void) +{ + g_DragSource = nullptr; +} + +IMPL_LINK(SalInstanceTreeView, ToggleHdl, SvLBoxButtonData*, pData, void) +{ + SvTreeListEntry* pEntry = pData->GetActEntry(); + SvLBoxButton* pBox = pData->GetActBox(); + + // tdf#122874 Select the row, calling SelectHdl, before handling + // the toggle + if (!m_xTreeView->IsSelected(pEntry)) + { + m_xTreeView->SelectAll(false); + m_xTreeView->Select(pEntry, true); + } + + // toggled signal handlers can query get_cursor to get which + // node was clicked + m_xTreeView->pImpl->m_pCursor = pEntry; + + for (int i = 1, nCount = pEntry->ItemCount(); i < nCount; ++i) + { + SvLBoxItem& rItem = pEntry->GetItem(i); + if (&rItem == pBox) + { + int nRow = SvTreeList::GetRelPos(pEntry); + int nCol = i - 1; // less dummy/expander column + signal_toggled(std::make_pair(nRow, nCol)); + break; + } + } +} + +IMPL_LINK_NOARG(SalInstanceTreeView, SelectHdl, SvTreeListBox*, void) +{ + if (notify_events_disabled()) + return; + signal_changed(); +} + +IMPL_LINK_NOARG(SalInstanceTreeView, DeSelectHdl, SvTreeListBox*, void) +{ + if (notify_events_disabled()) + return; + if (m_xTreeView->GetSelectionMode() == SelectionMode::Single) + return; + signal_changed(); +} + +IMPL_LINK_NOARG(SalInstanceTreeView, DoubleClickHdl, SvTreeListBox*, bool) +{ + if (notify_events_disabled()) + return false; + return !signal_row_activated(); +} + +IMPL_LINK(SalInstanceTreeView, EndDragHdl, HeaderBar*, pHeaderBar, void) +{ + std::vector aTabPositions; + aTabPositions.push_back(0); + for (int i = 0; i < pHeaderBar->GetItemCount() - 1; ++i) + aTabPositions.push_back(aTabPositions[i] + + pHeaderBar->GetItemSize(pHeaderBar->GetItemId(i))); + m_xTreeView->SetTabs(aTabPositions.size(), aTabPositions.data(), MapUnit::MapPixel); +} + +IMPL_LINK(SalInstanceTreeView, HeaderBarClickedHdl, HeaderBar*, pHeaderBar, void) +{ + sal_uInt16 nId = pHeaderBar->GetCurItemId(); + if (!(pHeaderBar->GetItemBits(nId) & HeaderBarItemBits::CLICKABLE)) + return; + signal_column_clicked(pHeaderBar->GetItemPos(nId)); +} + +IMPL_LINK_NOARG(SalInstanceTreeView, ExpandingHdl, SvTreeListBox*, bool) +{ + SvTreeListEntry* pEntry = m_xTreeView->GetHdlEntry(); + SalInstanceTreeIter aIter(pEntry); + + if (m_xTreeView->IsExpanded(pEntry)) + { + //collapsing; + return signal_collapsing(aIter); + } + + // expanding + + // if there's a preexisting placeholder child, required to make this + // potentially expandable in the first place, now we remove it + SvTreeListEntry* pPlaceHolder = GetPlaceHolderChild(pEntry); + if (pPlaceHolder) + { + m_aExpandingPlaceHolderParents.insert(pEntry); + m_xTreeView->RemoveEntry(pPlaceHolder); + } + + bool bRet = signal_expanding(aIter); + + if (pPlaceHolder) + { + //expand disallowed, restore placeholder + if (!bRet) + { + pPlaceHolder = m_xTreeView->InsertEntry("", pEntry, false, 0, nullptr); + SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pPlaceHolder); + pViewData->SetSelectable(false); + } + m_aExpandingPlaceHolderParents.erase(pEntry); + } + + return bRet; +} + +IMPL_LINK(SalInstanceTreeView, PopupMenuHdl, const CommandEvent&, rEvent, bool) +{ + return m_aPopupMenuHdl.Call(rEvent); +} + +IMPL_LINK(SalInstanceTreeView, EditingEntryHdl, SvTreeListEntry*, pEntry, bool) +{ + return signal_editing_started(SalInstanceTreeIter(pEntry)); +} + +IMPL_LINK(SalInstanceTreeView, EditedEntryHdl, IterString, rIterString, bool) +{ + return signal_editing_done(std::pair( + SalInstanceTreeIter(rIterString.first), rIterString.second)); +} + +class SalInstanceIconView : public SalInstanceContainer, public virtual weld::IconView +{ +private: + // owner for UserData + std::vector> m_aUserData; + VclPtr<::IconView> m_xIconView; + + DECL_LINK(SelectHdl, SvTreeListBox*, void); + DECL_LINK(DeSelectHdl, SvTreeListBox*, void); + DECL_LINK(DoubleClickHdl, SvTreeListBox*, bool); + +public: + SalInstanceIconView(::IconView* pIconView, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pIconView, pBuilder, bTakeOwnership) + , m_xIconView(pIconView) + { + m_xIconView->SetSelectHdl(LINK(this, SalInstanceIconView, SelectHdl)); + m_xIconView->SetDeselectHdl(LINK(this, SalInstanceIconView, DeSelectHdl)); + m_xIconView->SetDoubleClickHdl(LINK(this, SalInstanceIconView, DoubleClickHdl)); + } + + virtual void freeze() override + { + SalInstanceWidget::freeze(); + m_xIconView->SetUpdateMode(false); + } + + virtual void thaw() override + { + m_xIconView->SetUpdateMode(true); + SalInstanceWidget::thaw(); + } + + virtual void insert(int pos, const OUString* pStr, const OUString* pId, + const OUString* pIconName, weld::TreeIter* pRet) override + { + disable_notify_events(); + auto nInsertPos = pos == -1 ? TREELIST_APPEND : pos; + void* pUserData; + if (pId) + { + m_aUserData.emplace_back(std::make_unique(*pId)); + pUserData = m_aUserData.back().get(); + } + else + pUserData = nullptr; + + SvTreeListEntry* pEntry = new SvTreeListEntry; + if (pIconName) + { + Image aImage(createImage(*pIconName)); + pEntry->AddItem(std::make_unique(aImage, aImage, false)); + } + else + { + Image aDummy; + pEntry->AddItem(std::make_unique(aDummy, aDummy, false)); + } + if (pStr) + pEntry->AddItem(std::make_unique(*pStr)); + pEntry->SetUserData(pUserData); + m_xIconView->Insert(pEntry, nullptr, nInsertPos); + + if (pRet) + { + SalInstanceTreeIter* pVclRetIter = static_cast(pRet); + pVclRetIter->iter = pEntry; + } + + enable_notify_events(); + } + + virtual OUString get_selected_id() const override + { + assert(m_xIconView->IsUpdateMode() && "don't request selection when frozen"); + if (SvTreeListEntry* pEntry = m_xIconView->FirstSelected()) + { + if (const OUString* pStr = static_cast(pEntry->GetUserData())) + return *pStr; + } + return OUString(); + } + + virtual OUString get_selected_text() const override + { + assert(m_xIconView->IsUpdateMode() && "don't request selection when frozen"); + if (SvTreeListEntry* pEntry = m_xIconView->FirstSelected()) + return m_xIconView->GetEntryText(pEntry); + return OUString(); + } + + virtual int count_selected_items() const override { return m_xIconView->GetSelectionCount(); } + + virtual void select(int pos) override + { + assert(m_xIconView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + if (pos == -1 || (pos == 0 && n_children() == 0)) + m_xIconView->SelectAll(false); + else + { + SvTreeListEntry* pEntry = m_xIconView->GetEntry(nullptr, pos); + m_xIconView->Select(pEntry, true); + m_xIconView->MakeVisible(pEntry); + } + enable_notify_events(); + } + + virtual void unselect(int pos) override + { + assert(m_xIconView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + if (pos == -1) + m_xIconView->SelectAll(true); + else + { + SvTreeListEntry* pEntry = m_xIconView->GetEntry(nullptr, pos); + m_xIconView->Select(pEntry, false); + } + enable_notify_events(); + } + + virtual int n_children() const override + { + return m_xIconView->GetModel()->GetChildList(nullptr).size(); + } + + virtual std::unique_ptr + make_iterator(const weld::TreeIter* pOrig) const override + { + return std::unique_ptr( + new SalInstanceTreeIter(static_cast(pOrig))); + } + + virtual bool get_selected(weld::TreeIter* pIter) const override + { + SvTreeListEntry* pEntry = m_xIconView->FirstSelected(); + auto pVclIter = static_cast(pIter); + if (pVclIter) + pVclIter->iter = pEntry; + return pEntry != nullptr; + } + + virtual bool get_cursor(weld::TreeIter* pIter) const override + { + SvTreeListEntry* pEntry = m_xIconView->GetCurEntry(); + auto pVclIter = static_cast(pIter); + if (pVclIter) + pVclIter->iter = pEntry; + return pEntry != nullptr; + } + + virtual void set_cursor(const weld::TreeIter& rIter) override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + disable_notify_events(); + m_xIconView->SetCurEntry(rVclIter.iter); + enable_notify_events(); + } + + virtual bool get_iter_first(weld::TreeIter& rIter) const override + { + SalInstanceTreeIter& rVclIter = static_cast(rIter); + rVclIter.iter = m_xIconView->GetEntry(0); + return rVclIter.iter != nullptr; + } + + virtual void scroll_to_item(const weld::TreeIter& rIter) override + { + assert(m_xIconView->IsUpdateMode() && "don't select when frozen, select after thaw. Note selection doesn't survive a freeze"); + disable_notify_events(); + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + m_xIconView->MakeVisible(rVclIter.iter); + enable_notify_events(); + } + + virtual void selected_foreach(const std::function& func) override + { + SalInstanceTreeIter aVclIter(m_xIconView->FirstSelected()); + while (aVclIter.iter) + { + if (func(aVclIter)) + return; + aVclIter.iter = m_xIconView->NextSelected(aVclIter.iter); + } + } + + virtual OUString get_id(const weld::TreeIter& rIter) const override + { + const SalInstanceTreeIter& rVclIter = static_cast(rIter); + const OUString* pStr = static_cast(rVclIter.iter->GetUserData()); + if (pStr) + return *pStr; + return OUString(); + } + + virtual void clear() override + { + disable_notify_events(); + m_xIconView->Clear(); + m_aUserData.clear(); + enable_notify_events(); + } + + virtual ~SalInstanceIconView() override + { + m_xIconView->SetDoubleClickHdl(Link()); + m_xIconView->SetSelectHdl(Link()); + m_xIconView->SetDeselectHdl(Link()); + } +}; + +IMPL_LINK_NOARG(SalInstanceIconView, SelectHdl, SvTreeListBox*, void) +{ + if (notify_events_disabled()) + return; + signal_selection_changed(); +} + +IMPL_LINK_NOARG(SalInstanceIconView, DeSelectHdl, SvTreeListBox*, void) +{ + if (notify_events_disabled()) + return; + if (m_xIconView->GetSelectionMode() == SelectionMode::Single) + return; + signal_selection_changed(); +} + +IMPL_LINK_NOARG(SalInstanceIconView, DoubleClickHdl, SvTreeListBox*, bool) +{ + if (notify_events_disabled()) + return false; + return !signal_item_activated(); +} + +double SalInstanceSpinButton::toField(int nValue) const +{ + return static_cast(nValue) / Power10(get_digits()); + } + +int SalInstanceSpinButton::fromField(double fValue) const +{ + return FRound(fValue * Power10(get_digits())); +} + +SalInstanceSpinButton::SalInstanceSpinButton(FormattedField* pButton, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceEntry(pButton, pBuilder, bTakeOwnership) + , m_xButton(pButton) +{ + m_xButton->SetThousandsSep(false); //off by default, MetricSpinButton enables it + m_xButton->SetUpHdl(LINK(this, SalInstanceSpinButton, UpDownHdl)); + m_xButton->SetDownHdl(LINK(this, SalInstanceSpinButton, UpDownHdl)); + m_xButton->SetLoseFocusHdl(LINK(this, SalInstanceSpinButton, LoseFocusHdl)); + m_xButton->SetOutputHdl(LINK(this, SalInstanceSpinButton, OutputHdl)); + m_xButton->SetInputHdl(LINK(this, SalInstanceSpinButton, InputHdl)); + if (Edit* pEdit = m_xButton->GetSubEdit()) + pEdit->SetActivateHdl(LINK(this, SalInstanceSpinButton, ActivateHdl)); + else + m_xButton->SetActivateHdl(LINK(this, SalInstanceSpinButton, ActivateHdl)); +} + +int SalInstanceSpinButton::get_value() const +{ + return fromField(m_xButton->GetValue()); + } + +void SalInstanceSpinButton::set_value(int value) +{ + m_xButton->SetValue(toField(value)); + } + +void SalInstanceSpinButton::set_range(int min, int max) +{ + m_xButton->SetMinValue(toField(min)); + m_xButton->SetMaxValue(toField(max)); +} + +void SalInstanceSpinButton::get_range(int& min, int& max) const +{ + min = fromField(m_xButton->GetMinValue()); + max = fromField(m_xButton->GetMaxValue()); +} + +void SalInstanceSpinButton::set_increments(int step, int /*page*/) +{ + m_xButton->SetSpinSize(toField(step)); +} + +void SalInstanceSpinButton::get_increments(int& step, int& page) const +{ + step = fromField(m_xButton->GetSpinSize()); + page = fromField(m_xButton->GetSpinSize()); +} + +void SalInstanceSpinButton::set_digits(unsigned int digits) +{ + m_xButton->SetDecimalDigits(digits); +} + +// SpinButton may be comprised of multiple subwidgets, consider the lot as +// one thing for focus +bool SalInstanceSpinButton::has_focus() const +{ + return m_xWidget->HasChildPathFocus(); +} + +//so with hh::mm::ss, incrementing mm will not reset ss +void SalInstanceSpinButton::DisableRemainderFactor() +{ + m_xButton->DisableRemainderFactor(); +} + +//off by default for direct SpinButtons, MetricSpinButton enables it +void SalInstanceSpinButton::SetUseThousandSep() +{ + m_xButton->SetThousandsSep(true); +} + +unsigned int SalInstanceSpinButton::get_digits() const +{ + return m_xButton->GetDecimalDigits(); +} + +SalInstanceSpinButton::~SalInstanceSpinButton() +{ + if (Edit* pEdit = m_xButton->GetSubEdit()) + pEdit->SetActivateHdl(Link()); + else + m_xButton->SetActivateHdl(Link()); + m_xButton->SetInputHdl(Link()); + m_xButton->SetOutputHdl(Link()); + m_xButton->SetLoseFocusHdl(Link()); + m_xButton->SetDownHdl(Link()); + m_xButton->SetUpHdl(Link()); +} + +IMPL_LINK_NOARG(SalInstanceSpinButton, ActivateHdl, Edit&, bool) +{ + // tdf#122348 return pressed to end dialog + signal_value_changed(); + return m_aActivateHdl.Call(*this); +} + +IMPL_LINK_NOARG(SalInstanceSpinButton, UpDownHdl, SpinField&, void) { signal_value_changed(); } + +IMPL_LINK_NOARG(SalInstanceSpinButton, LoseFocusHdl, Control&, void) { signal_value_changed(); } + +IMPL_LINK_NOARG(SalInstanceSpinButton, OutputHdl, Edit&, bool) { return signal_output(); } + +IMPL_LINK(SalInstanceSpinButton, InputHdl, sal_Int64*, pResult, TriState) +{ + int nResult; + TriState eRet = signal_input(&nResult); + if (eRet == TRISTATE_TRUE) + *pResult = nResult; + return eRet; +} + +namespace +{ +class SalInstanceFormattedSpinButton : public SalInstanceEntry, + public virtual weld::FormattedSpinButton +{ +private: + VclPtr m_xButton; + +public: + SalInstanceFormattedSpinButton(FormattedField* pButton, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceEntry(pButton, pBuilder, bTakeOwnership) + , m_xButton(pButton) + { + // #i6278# allow more decimal places than the output format. As + // the numbers shown in the edit fields are used for input, it makes more + // sense to display the values in the input format rather than the output + // format. + m_xButton->UseInputStringForFormatting(); + } + + virtual double get_value() const override { return m_xButton->GetValue(); } + + virtual void set_value(double value) override { m_xButton->SetValue(value); } + + virtual void set_range(double min, double max) override + { + m_xButton->SetMinValue(min); + m_xButton->SetMaxValue(max); + } + + virtual void get_range(double& min, double& max) const override + { + min = m_xButton->GetMinValue(); + max = m_xButton->GetMaxValue(); + } + + virtual void set_formatter(SvNumberFormatter* pFormatter) override + { + m_xButton->SetFormatter(pFormatter); + } + + virtual SvNumberFormatter* get_formatter() override { return m_xButton->GetFormatter(); } + + virtual sal_Int32 get_format_key() const override { return m_xButton->GetFormatKey(); } + + virtual void set_format_key(sal_Int32 nFormatKey) override + { + m_xButton->SetFormatKey(nFormatKey); + } + + virtual void treat_as_number(bool bSet) override { m_xButton->TreatAsNumber(bSet); } + + virtual void set_digits(unsigned int digits) override { m_xButton->SetDecimalDigits(digits); } +}; + +} + +SalInstanceLabel::SalInstanceLabel(Control* pLabel, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceWidget(pLabel, pBuilder, bTakeOwnership) + , m_xLabel(pLabel) +{ +} + +void SalInstanceLabel::set_label(const OUString& rText) { m_xLabel->SetText(rText); } + +OUString SalInstanceLabel::get_label() const { return m_xLabel->GetText(); } + +void SalInstanceLabel::set_mnemonic_widget(Widget* pTarget) +{ + FixedText* pLabel = dynamic_cast(m_xLabel.get()); + assert(pLabel && "can't use set_mnemonic_widget on SelectableFixedText"); + SalInstanceWidget* pTargetWidget = dynamic_cast(pTarget); + pLabel->set_mnemonic_widget(pTargetWidget ? pTargetWidget->getWidget() : nullptr); +} + +void SalInstanceLabel::set_message_type(weld::EntryMessageType eType) +{ + if (eType == weld::EntryMessageType::Error) + m_xLabel->SetControlBackground( + m_xLabel->GetSettings().GetStyleSettings().GetHighlightColor()); + else if (eType == weld::EntryMessageType::Warning) + m_xLabel->SetControlBackground(COL_YELLOW); + else + m_xLabel->SetControlBackground(); +} + +void SalInstanceLabel::set_font(const vcl::Font& rFont) +{ + m_xLabel->SetPointFont(*m_xLabel, rFont); + m_xLabel->Invalidate(); +} + +std::unique_ptr SalInstanceFrame::weld_label_widget() const +{ + FixedText* pLabel = dynamic_cast(m_xFrame->get_label_widget()); + if (!pLabel) + return nullptr; + return std::make_unique(pLabel, m_pBuilder, false); +} + +namespace +{ +class SalInstanceTextView : public SalInstanceContainer, public virtual weld::TextView +{ +private: + VclPtr m_xTextView; + Link m_aOrigVScrollHdl; + + DECL_LINK(ChangeHdl, Edit&, void); + DECL_LINK(VscrollHdl, ScrollBar*, void); + DECL_LINK(CursorListener, VclWindowEvent&, void); + +public: + SalInstanceTextView(VclMultiLineEdit* pTextView, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceContainer(pTextView, pBuilder, bTakeOwnership) + , m_xTextView(pTextView) + { + m_xTextView->SetModifyHdl(LINK(this, SalInstanceTextView, ChangeHdl)); + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + m_aOrigVScrollHdl = rVertScrollBar.GetScrollHdl(); + rVertScrollBar.SetScrollHdl(LINK(this, SalInstanceTextView, VscrollHdl)); + } + + virtual void set_text(const OUString& rText) override + { + disable_notify_events(); + m_xTextView->SetText(rText); + enable_notify_events(); + } + + virtual void replace_selection(const OUString& rText) override + { + disable_notify_events(); + m_xTextView->ReplaceSelected(rText); + enable_notify_events(); + } + + virtual OUString get_text() const override { return m_xTextView->GetText(); } + + bool get_selection_bounds(int& rStartPos, int& rEndPos) override + { + const Selection& rSelection = m_xTextView->GetSelection(); + rStartPos = rSelection.Min(); + rEndPos = rSelection.Max(); + return rSelection.Len(); + } + + virtual void select_region(int nStartPos, int nEndPos) override + { + disable_notify_events(); + m_xTextView->SetSelection(Selection(nStartPos, nEndPos < 0 ? SELECTION_MAX : nEndPos)); + enable_notify_events(); + } + + virtual void set_editable(bool bEditable) override { m_xTextView->SetReadOnly(!bEditable); } + + virtual void set_monospace(bool bMonospace) override + { + vcl::Font aOrigFont = m_xTextView->GetControlFont(); + vcl::Font aFont; + if (bMonospace) + aFont = OutputDevice::GetDefaultFont(DefaultFontType::UI_FIXED, LANGUAGE_DONTKNOW, + GetDefaultFontFlags::OnlyOne, m_xTextView); + else + aFont = Application::GetSettings().GetStyleSettings().GetFieldFont(); + aFont.SetFontHeight(aOrigFont.GetFontHeight()); + m_xTextView->SetFont(aFont); + m_xTextView->SetControlFont(aFont); + } + + virtual void connect_cursor_position(const Link& rLink) override + { + assert(!m_aCursorPositionHdl.IsSet()); + m_xTextView->AddEventListener(LINK(this, SalInstanceTextView, CursorListener)); + weld::TextView::connect_cursor_position(rLink); + } + + virtual int vadjustment_get_value() const override + { + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + return rVertScrollBar.GetThumbPos(); + } + + virtual void vadjustment_set_value(int value) override + { + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + rVertScrollBar.SetThumbPos(value); + m_aOrigVScrollHdl.Call(&rVertScrollBar); + } + + virtual int vadjustment_get_upper() const override + { + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + return rVertScrollBar.GetRangeMax(); + } + + virtual int vadjustment_get_lower() const override + { + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + return rVertScrollBar.GetRangeMin(); + } + + virtual int vadjustment_get_page_size() const override + { + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + return rVertScrollBar.GetVisibleSize(); + } + + virtual ~SalInstanceTextView() override + { + if (!m_xTextView->IsDisposed()) + { + if (m_aCursorPositionHdl.IsSet()) + m_xTextView->RemoveEventListener(LINK(this, SalInstanceTextView, CursorListener)); + m_xTextView->SetModifyHdl(Link()); + ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar(); + rVertScrollBar.SetScrollHdl(m_aOrigVScrollHdl); + } + } +}; + +} + +IMPL_LINK(SalInstanceTextView, VscrollHdl, ScrollBar*, pScrollBar, void) +{ + signal_vadjustment_changed(); + m_aOrigVScrollHdl.Call(pScrollBar); +} + +IMPL_LINK_NOARG(SalInstanceTextView, ChangeHdl, Edit&, void) { signal_changed(); } + +IMPL_LINK(SalInstanceTextView, CursorListener, VclWindowEvent&, rEvent, void) +{ + if (notify_events_disabled()) + return; + if (rEvent.GetId() == VclEventId::EditSelectionChanged + || rEvent.GetId() == VclEventId::EditCaretChanged) + signal_cursor_position(); +} + +namespace +{ +class SalInstanceExpander : public SalInstanceContainer, public virtual weld::Expander +{ +private: + VclPtr m_xExpander; + + DECL_LINK(ExpandedHdl, VclExpander&, void); + +public: + SalInstanceExpander(VclExpander* pExpander, SalInstanceBuilder* pBuilder, bool bTakeOwnership) + : SalInstanceContainer(pExpander, pBuilder, bTakeOwnership) + , m_xExpander(pExpander) + { + m_xExpander->SetExpandedHdl(LINK(this, SalInstanceExpander, ExpandedHdl)); + } + + virtual bool get_expanded() const override { return m_xExpander->get_expanded(); } + + virtual void set_expanded(bool bExpand) override { m_xExpander->set_expanded(bExpand); } + + virtual ~SalInstanceExpander() override + { + m_xExpander->SetExpandedHdl(Link()); + } +}; + +} + +IMPL_LINK_NOARG(SalInstanceExpander, ExpandedHdl, VclExpander&, void) { signal_expanded(); } + +namespace +{ +class SalInstanceDrawingArea : public SalInstanceWidget, public virtual weld::DrawingArea +{ +private: + VclPtr m_xDrawingArea; + + typedef std::pair target_and_area; + DECL_LINK(PaintHdl, target_and_area, void); + DECL_LINK(ResizeHdl, const Size&, void); + DECL_LINK(MousePressHdl, const MouseEvent&, bool); + DECL_LINK(MouseMoveHdl, const MouseEvent&, bool); + DECL_LINK(MouseReleaseHdl, const MouseEvent&, bool); + DECL_LINK(KeyPressHdl, const KeyEvent&, bool); + DECL_LINK(KeyReleaseHdl, const KeyEvent&, bool); + DECL_LINK(StyleUpdatedHdl, VclDrawingArea&, void); + DECL_LINK(CommandHdl, const CommandEvent&, bool); + DECL_LINK(QueryTooltipHdl, tools::Rectangle&, OUString); + DECL_LINK(GetSurroundingHdl, OUString&, int); + DECL_LINK(StartDragHdl, VclDrawingArea*, bool); + + // SalInstanceWidget has a generic listener for all these + // events, ignore the ones we have specializations for + // in VclDrawingArea + virtual void HandleEventListener(VclWindowEvent& rEvent) override + { + if (rEvent.GetId() == VclEventId::WindowResize) + return; + SalInstanceWidget::HandleEventListener(rEvent); + } + + virtual void HandleMouseEventListener(VclSimpleEvent& rEvent) override + { + if (rEvent.GetId() == VclEventId::WindowMouseButtonDown + || rEvent.GetId() == VclEventId::WindowMouseButtonUp + || rEvent.GetId() == VclEventId::WindowMouseMove) + { + return; + } + SalInstanceWidget::HandleMouseEventListener(rEvent); + } + + virtual bool HandleKeyEventListener(VclWindowEvent& /*rEvent*/) override { return false; } + +public: + SalInstanceDrawingArea(VclDrawingArea* pDrawingArea, SalInstanceBuilder* pBuilder, + const a11yref& rAlly, FactoryFunction pUITestFactoryFunction, + void* pUserData, bool bTakeOwnership) + : SalInstanceWidget(pDrawingArea, pBuilder, bTakeOwnership) + , m_xDrawingArea(pDrawingArea) + { + m_xDrawingArea->SetAccessible(rAlly); + m_xDrawingArea->SetUITestFactory(std::move(pUITestFactoryFunction), pUserData); + m_xDrawingArea->SetPaintHdl(LINK(this, SalInstanceDrawingArea, PaintHdl)); + m_xDrawingArea->SetResizeHdl(LINK(this, SalInstanceDrawingArea, ResizeHdl)); + m_xDrawingArea->SetMousePressHdl(LINK(this, SalInstanceDrawingArea, MousePressHdl)); + m_xDrawingArea->SetMouseMoveHdl(LINK(this, SalInstanceDrawingArea, MouseMoveHdl)); + m_xDrawingArea->SetMouseReleaseHdl(LINK(this, SalInstanceDrawingArea, MouseReleaseHdl)); + m_xDrawingArea->SetKeyPressHdl(LINK(this, SalInstanceDrawingArea, KeyPressHdl)); + m_xDrawingArea->SetKeyReleaseHdl(LINK(this, SalInstanceDrawingArea, KeyReleaseHdl)); + m_xDrawingArea->SetStyleUpdatedHdl(LINK(this, SalInstanceDrawingArea, StyleUpdatedHdl)); + m_xDrawingArea->SetCommandHdl(LINK(this, SalInstanceDrawingArea, CommandHdl)); + m_xDrawingArea->SetQueryTooltipHdl(LINK(this, SalInstanceDrawingArea, QueryTooltipHdl)); + m_xDrawingArea->SetGetSurroundingHdl(LINK(this, SalInstanceDrawingArea, GetSurroundingHdl)); + m_xDrawingArea->SetStartDragHdl(LINK(this, SalInstanceDrawingArea, StartDragHdl)); + } + + virtual void queue_draw() override { m_xDrawingArea->Invalidate(); } + + virtual void queue_draw_area(int x, int y, int width, int height) override + { + m_xDrawingArea->Invalidate(tools::Rectangle(Point(x, y), Size(width, height))); + } + + virtual void queue_resize() override { m_xDrawingArea->queue_resize(); } + + virtual void connect_size_allocate(const Link& rLink) override + { + weld::Widget::connect_size_allocate(rLink); + } + + virtual void connect_key_press(const Link& rLink) override + { + weld::Widget::connect_key_press(rLink); + } + + virtual void connect_key_release(const Link& rLink) override + { + weld::Widget::connect_key_release(rLink); + } + + virtual void set_cursor(PointerStyle ePointerStyle) override + { + m_xDrawingArea->SetPointer(ePointerStyle); + } + + virtual void set_input_context(const InputContext& rInputContext) override + { + m_xDrawingArea->SetInputContext(rInputContext); + } + + virtual void im_context_set_cursor_location(const tools::Rectangle& rCursorRect, int nExtTextInputWidth) override + { + tools::Rectangle aCursorRect = m_xDrawingArea->PixelToLogic(rCursorRect); + m_xDrawingArea->SetCursorRect(&aCursorRect, m_xDrawingArea->PixelToLogic(Size(nExtTextInputWidth, 0)).Width()); + } + + virtual a11yref get_accessible_parent() override + { + vcl::Window* pParent = m_xDrawingArea->GetParent(); + if (pParent) + return pParent->GetAccessible(); + return css::uno::Reference(); + } + + virtual a11yrelationset get_accessible_relation_set() override + { + utl::AccessibleRelationSetHelper* pRelationSetHelper = new utl::AccessibleRelationSetHelper; + css::uno::Reference xSet = pRelationSetHelper; + vcl::Window* pWindow = m_xDrawingArea.get(); + if (pWindow) + { + vcl::Window* pLabeledBy = pWindow->GetAccessibleRelationLabeledBy(); + if (pLabeledBy && pLabeledBy != pWindow) + { + css::uno::Sequence> aSequence{ + pLabeledBy->GetAccessible() + }; + pRelationSetHelper->AddRelation(css::accessibility::AccessibleRelation( + css::accessibility::AccessibleRelationType::LABELED_BY, aSequence)); + } + vcl::Window* pMemberOf = pWindow->GetAccessibleRelationMemberOf(); + if (pMemberOf && pMemberOf != pWindow) + { + css::uno::Sequence> aSequence{ + pMemberOf->GetAccessible() + }; + pRelationSetHelper->AddRelation(css::accessibility::AccessibleRelation( + css::accessibility::AccessibleRelationType::MEMBER_OF, aSequence)); + } + } + return xSet; + } + + virtual Point get_accessible_location() override + { + return m_xDrawingArea->OutputToAbsoluteScreenPixel(Point()); + } + + virtual void enable_drag_source(rtl::Reference& rHelper, + sal_uInt8 eDNDConstants) override + { + m_xDrawingArea->SetDragHelper(rHelper, eDNDConstants); + } + + virtual ~SalInstanceDrawingArea() override + { + m_xDrawingArea->SetGetSurroundingHdl(Link()); + m_xDrawingArea->SetQueryTooltipHdl(Link()); + m_xDrawingArea->SetCommandHdl(Link()); + m_xDrawingArea->SetStyleUpdatedHdl(Link()); + m_xDrawingArea->SetMousePressHdl(Link()); + m_xDrawingArea->SetMouseMoveHdl(Link()); + m_xDrawingArea->SetMouseReleaseHdl(Link()); + m_xDrawingArea->SetKeyPressHdl(Link()); + m_xDrawingArea->SetKeyReleaseHdl(Link()); + m_xDrawingArea->SetResizeHdl(Link()); + m_xDrawingArea->SetPaintHdl( + Link, void>()); + } + + virtual OutputDevice& get_ref_device() override { return *m_xDrawingArea; } +}; + +} + +IMPL_LINK(SalInstanceDrawingArea, PaintHdl, target_and_area, aPayload, void) +{ + m_aDrawHdl.Call(aPayload); + tools::Rectangle aFocusRect(m_aGetFocusRectHdl.Call(*this)); + if (!aFocusRect.IsEmpty()) + DrawFocusRect(aPayload.first, aFocusRect); +} + +IMPL_LINK(SalInstanceDrawingArea, ResizeHdl, const Size&, rSize, void) +{ + m_aSizeAllocateHdl.Call(rSize); +} + +IMPL_LINK(SalInstanceDrawingArea, MousePressHdl, const MouseEvent&, rEvent, bool) +{ + return m_aMousePressHdl.Call(rEvent); +} + +IMPL_LINK(SalInstanceDrawingArea, MouseMoveHdl, const MouseEvent&, rEvent, bool) +{ + return m_aMouseMotionHdl.Call(rEvent); +} + +IMPL_LINK(SalInstanceDrawingArea, MouseReleaseHdl, const MouseEvent&, rEvent, bool) +{ + return m_aMouseReleaseHdl.Call(rEvent); +} + +IMPL_LINK(SalInstanceDrawingArea, KeyPressHdl, const KeyEvent&, rEvent, bool) +{ + return m_aKeyPressHdl.Call(rEvent); +} + +IMPL_LINK(SalInstanceDrawingArea, KeyReleaseHdl, const KeyEvent&, rEvent, bool) +{ + return m_aKeyReleaseHdl.Call(rEvent); +} + +IMPL_LINK_NOARG(SalInstanceDrawingArea, StyleUpdatedHdl, VclDrawingArea&, void) +{ + m_aStyleUpdatedHdl.Call(*this); +} + +IMPL_LINK(SalInstanceDrawingArea, CommandHdl, const CommandEvent&, rEvent, bool) +{ + return m_aCommandHdl.Call(rEvent); +} + +IMPL_LINK(SalInstanceDrawingArea, GetSurroundingHdl, OUString&, rSurrounding, int) +{ + return m_aGetSurroundingHdl.Call(rSurrounding); +} + +IMPL_LINK(SalInstanceDrawingArea, QueryTooltipHdl, tools::Rectangle&, rHelpArea, OUString) +{ + return m_aQueryTooltipHdl.Call(rHelpArea); +} + +IMPL_LINK_NOARG(SalInstanceDrawingArea, StartDragHdl, VclDrawingArea*, bool) +{ + if (m_aDragBeginHdl.Call(*this)) + return true; + return false; +} + +SalInstanceComboBoxWithoutEdit::SalInstanceComboBoxWithoutEdit(ListBox* pListBox, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceComboBox(pListBox, pBuilder, bTakeOwnership) +{ + m_xComboBox->SetSelectHdl(LINK(this, SalInstanceComboBoxWithoutEdit, SelectHdl)); +} + +OUString SalInstanceComboBoxWithoutEdit::get_active_text() const { return m_xComboBox->GetSelectedEntry(); } + +void SalInstanceComboBoxWithoutEdit::remove(int pos) { m_xComboBox->RemoveEntry(pos); } + +void SalInstanceComboBoxWithoutEdit::insert(int pos, const OUString& rStr, const OUString* pId, + const OUString* pIconName, VirtualDevice* pImageSurface) +{ + auto nInsertPos = pos == -1 ? COMBOBOX_APPEND : pos; + sal_Int32 nInsertedAt; + if (!pIconName && !pImageSurface) + nInsertedAt = m_xComboBox->InsertEntry(rStr, nInsertPos); + else if (pIconName) + nInsertedAt = m_xComboBox->InsertEntry(rStr, createImage(*pIconName), nInsertPos); + else + nInsertedAt = m_xComboBox->InsertEntry(rStr, createImage(*pImageSurface), nInsertPos); + if (pId) + { + m_aUserData.emplace_back(std::make_unique(*pId)); + m_xComboBox->SetEntryData(nInsertedAt, m_aUserData.back().get()); + } +} + +void SalInstanceComboBoxWithoutEdit::insert_separator(int pos, const OUString& /*rId*/) +{ + auto nInsertPos = pos == -1 ? m_xComboBox->GetEntryCount() : pos; + m_xComboBox->AddSeparator(nInsertPos - 1); +} + +bool SalInstanceComboBoxWithoutEdit::has_entry() const { return false; } + +bool SalInstanceComboBoxWithoutEdit::changed_by_direct_pick() const { return true; } + +void SalInstanceComboBoxWithoutEdit::set_entry_message_type(weld::EntryMessageType /*eType*/) +{ + assert(false); +} + +void SalInstanceComboBoxWithoutEdit::set_entry_text(const OUString& /*rText*/) { assert(false); } + +void SalInstanceComboBoxWithoutEdit::select_entry_region(int /*nStartPos*/, int /*nEndPos*/) { assert(false); } + +bool SalInstanceComboBoxWithoutEdit::get_entry_selection_bounds(int& /*rStartPos*/, int& /*rEndPos*/) +{ + assert(false); + return false; +} + +void SalInstanceComboBoxWithoutEdit::set_entry_width_chars(int /*nChars*/) { assert(false); } + +void SalInstanceComboBoxWithoutEdit::set_entry_max_length(int /*nChars*/) { assert(false); } + +void SalInstanceComboBoxWithoutEdit::set_entry_completion(bool, bool) { assert(false); } + +void SalInstanceComboBoxWithoutEdit::set_entry_placeholder_text(const OUString&) { assert(false); } + +void SalInstanceComboBoxWithoutEdit::set_entry_editable(bool /*bEditable*/) { assert(false); } + +void SalInstanceComboBoxWithoutEdit::cut_entry_clipboard() { assert(false); } + +void SalInstanceComboBoxWithoutEdit::copy_entry_clipboard() { assert(false); } + +void SalInstanceComboBoxWithoutEdit::paste_entry_clipboard() { assert(false); } + +void SalInstanceComboBoxWithoutEdit::set_entry_font(const vcl::Font&) { assert(false); } + +vcl::Font SalInstanceComboBoxWithoutEdit::get_entry_font() { assert(false); return vcl::Font(); } + +void SalInstanceComboBoxWithoutEdit::set_custom_renderer(bool /*bOn*/) +{ + assert(false && "not implemented"); +} + +int SalInstanceComboBoxWithoutEdit::get_max_mru_count() const +{ + assert(false && "not implemented"); + return 0; +} + +void SalInstanceComboBoxWithoutEdit::set_max_mru_count(int) +{ + assert(false && "not implemented"); +} + +OUString SalInstanceComboBoxWithoutEdit::get_mru_entries() const +{ + assert(false && "not implemented"); + return OUString(); +} + +void SalInstanceComboBoxWithoutEdit::set_mru_entries(const OUString&) +{ + assert(false && "not implemented"); +} + +void SalInstanceComboBoxWithoutEdit::HandleEventListener(VclWindowEvent& rEvent) +{ + CallHandleEventListener(rEvent); +} + +SalInstanceComboBoxWithoutEdit::~SalInstanceComboBoxWithoutEdit() +{ + m_xComboBox->SetSelectHdl(Link()); +} + +IMPL_LINK_NOARG(SalInstanceComboBoxWithoutEdit, SelectHdl, ListBox&, void) +{ + return signal_changed(); +} + +SalInstanceComboBoxWithEdit::SalInstanceComboBoxWithEdit(::ComboBox* pComboBox, SalInstanceBuilder* pBuilder, + bool bTakeOwnership) + : SalInstanceComboBox<::ComboBox>(pComboBox, pBuilder, bTakeOwnership) + , m_aTextFilter(m_aEntryInsertTextHdl) + , m_bInSelect(false) +{ + m_xComboBox->SetModifyHdl(LINK(this, SalInstanceComboBoxWithEdit, ChangeHdl)); + m_xComboBox->SetSelectHdl(LINK(this, SalInstanceComboBoxWithEdit, SelectHdl)); + m_xComboBox->SetEntryActivateHdl(LINK(this, SalInstanceComboBoxWithEdit, EntryActivateHdl)); + m_xComboBox->SetTextFilter(&m_aTextFilter); +} + +bool SalInstanceComboBoxWithEdit::has_entry() const { return true; } + +bool SalInstanceComboBoxWithEdit::changed_by_direct_pick() const +{ + return m_bInSelect && !m_xComboBox->IsModifyByKeyboard() && !m_xComboBox->IsTravelSelect(); +} + +void SalInstanceComboBoxWithEdit::set_entry_message_type(weld::EntryMessageType eType) +{ + if (eType == weld::EntryMessageType::Error) + m_xComboBox->SetControlForeground(Color(0xf0, 0, 0)); + else if (eType == weld::EntryMessageType::Warning) + m_xComboBox->SetControlForeground(COL_YELLOW); + else + m_xComboBox->SetControlForeground(); +} + +OUString SalInstanceComboBoxWithEdit::get_active_text() const { return m_xComboBox->GetText(); } + +void SalInstanceComboBoxWithEdit::remove(int pos) { m_xComboBox->RemoveEntryAt(pos); } + +void SalInstanceComboBoxWithEdit::insert(int pos, const OUString& rStr, const OUString* pId, + const OUString* pIconName, VirtualDevice* pImageSurface) +{ + auto nInsertPos = pos == -1 ? COMBOBOX_APPEND : pos; + sal_Int32 nInsertedAt; + if (!pIconName && !pImageSurface) + nInsertedAt = m_xComboBox->InsertEntry(rStr, nInsertPos); + else if (pIconName) + nInsertedAt + = m_xComboBox->InsertEntryWithImage(rStr, createImage(*pIconName), nInsertPos); + else + nInsertedAt + = m_xComboBox->InsertEntryWithImage(rStr, createImage(*pImageSurface), nInsertPos); + if (pId) + { + m_aUserData.emplace_back(std::make_unique(*pId)); + m_xComboBox->SetEntryData(nInsertedAt, m_aUserData.back().get()); + } +} + +void SalInstanceComboBoxWithEdit::insert_separator(int pos, const OUString& /*rId*/) +{ + auto nInsertPos = pos == -1 ? m_xComboBox->GetEntryCount() : pos; + m_xComboBox->AddSeparator(nInsertPos - 1); +} + +void SalInstanceComboBoxWithEdit::set_entry_text(const OUString& rText) { m_xComboBox->SetText(rText); } + +void SalInstanceComboBoxWithEdit::set_entry_width_chars(int nChars) +{ + m_xComboBox->SetWidthInChars(nChars); +} + +void SalInstanceComboBoxWithEdit::set_entry_max_length(int nChars) { m_xComboBox->SetMaxTextLen(nChars); } + +void SalInstanceComboBoxWithEdit::set_entry_completion(bool bEnable, bool bCaseSensitive) +{ + m_xComboBox->EnableAutocomplete(bEnable, bCaseSensitive); +} + +void SalInstanceComboBoxWithEdit::set_entry_placeholder_text(const OUString& rText) +{ + m_xComboBox->SetPlaceholderText(rText); +} + +void SalInstanceComboBoxWithEdit::set_entry_editable(bool bEditable) +{ + m_xComboBox->SetReadOnly(!bEditable); +} + +void SalInstanceComboBoxWithEdit::cut_entry_clipboard() +{ + m_xComboBox->Cut(); +} + +void SalInstanceComboBoxWithEdit::copy_entry_clipboard() +{ + m_xComboBox->Copy(); +} + +void SalInstanceComboBoxWithEdit::paste_entry_clipboard() +{ + m_xComboBox->Paste(); +} + +void SalInstanceComboBoxWithEdit::select_entry_region(int nStartPos, int nEndPos) +{ + m_xComboBox->SetSelection(Selection(nStartPos, nEndPos < 0 ? SELECTION_MAX : nEndPos)); +} + +bool SalInstanceComboBoxWithEdit::get_entry_selection_bounds(int& rStartPos, int& rEndPos) +{ + const Selection& rSelection = m_xComboBox->GetSelection(); + rStartPos = rSelection.Min(); + rEndPos = rSelection.Max(); + return rSelection.Len(); +} + +void SalInstanceComboBoxWithEdit::set_entry_font(const vcl::Font& rFont) +{ + Edit* pEdit = m_xComboBox->GetSubEdit(); + assert(pEdit); + pEdit->SetPointFont(*pEdit, rFont); + m_xComboBox->SetControlFont(rFont); // tdf#134601 set it as control font to take effect properly + pEdit->Invalidate(); +} + +vcl::Font SalInstanceComboBoxWithEdit::get_entry_font() +{ + Edit* pEdit = m_xComboBox->GetSubEdit(); + assert(pEdit); + return pEdit->GetPointFont(*pEdit); +} + +void SalInstanceComboBoxWithEdit::set_custom_renderer(bool bOn) +{ + if (m_xComboBox->IsUserDrawEnabled() == bOn) + return; + + auto nOldEntryHeight = m_xComboBox->GetDropDownEntryHeight(); + auto nDropDownLineCount = m_xComboBox->GetDropDownLineCount(); + + m_xComboBox->EnableUserDraw(bOn); + if (bOn) + m_xComboBox->SetUserDrawHdl(LINK(this, SalInstanceComboBoxWithEdit, UserDrawHdl)); + else + m_xComboBox->SetUserDrawHdl(Link()); + + // adjust the line count to fit approx the height it would have been before + // changing the renderer + auto nNewEntryHeight = m_xComboBox->GetDropDownEntryHeight(); + double fRatio = nOldEntryHeight / static_cast(nNewEntryHeight); + m_xComboBox->SetDropDownLineCount(nDropDownLineCount * fRatio); +} + +int SalInstanceComboBoxWithEdit::get_max_mru_count() const +{ + return m_xComboBox->GetMaxMRUCount(); +} + +void SalInstanceComboBoxWithEdit::set_max_mru_count(int nCount) +{ + return m_xComboBox->SetMaxMRUCount(nCount); +} + +OUString SalInstanceComboBoxWithEdit::get_mru_entries() const +{ + return m_xComboBox->GetMRUEntries(); +} + +void SalInstanceComboBoxWithEdit::set_mru_entries(const OUString& rEntries) +{ + m_xComboBox->SetMRUEntries(rEntries); +} + +void SalInstanceComboBoxWithEdit::HandleEventListener(VclWindowEvent& rEvent) +{ + if (rEvent.GetId() == VclEventId::DropdownPreOpen) + { + Size aRowSize(signal_custom_get_size(*m_xComboBox)); + m_xComboBox->SetUserItemSize(aRowSize); + } + CallHandleEventListener(rEvent); +} + +SalInstanceComboBoxWithEdit::~SalInstanceComboBoxWithEdit() +{ + m_xComboBox->SetTextFilter(nullptr); + m_xComboBox->SetEntryActivateHdl(Link()); + m_xComboBox->SetModifyHdl(Link()); + m_xComboBox->SetSelectHdl(Link<::ComboBox&, void>()); +} + +IMPL_LINK_NOARG(SalInstanceComboBoxWithEdit, ChangeHdl, Edit&, void) +{ + if (!m_xComboBox->IsSyntheticModify()) // SelectHdl will be called + signal_changed(); +} + +IMPL_LINK_NOARG(SalInstanceComboBoxWithEdit, SelectHdl, ::ComboBox&, void) +{ + m_bInSelect = true; + signal_changed(); + m_bInSelect = false; +} + +IMPL_LINK_NOARG(SalInstanceComboBoxWithEdit, EntryActivateHdl, Edit&, bool) +{ + return m_aEntryActivateHdl.Call(*this); +} + +IMPL_LINK(SalInstanceComboBoxWithEdit, UserDrawHdl, UserDrawEvent*, pEvent, void) +{ + call_signal_custom_render(pEvent); +} + +class SalInstanceEntryTreeView : public SalInstanceContainer, public virtual weld::EntryTreeView +{ +private: + DECL_LINK(AutocompleteHdl, Edit&, void); + DECL_LINK(KeyPressListener, VclWindowEvent&, void); + SalInstanceEntry* m_pEntry; + SalInstanceTreeView* m_pTreeView; + bool m_bTreeChange; + +public: + SalInstanceEntryTreeView(vcl::Window* pContainer, SalInstanceBuilder* pBuilder, + bool bTakeOwnership, std::unique_ptr xEntry, + std::unique_ptr xTreeView) + : EntryTreeView(std::move(xEntry), std::move(xTreeView)) + , SalInstanceContainer(pContainer, pBuilder, bTakeOwnership) + , m_pEntry(dynamic_cast(m_xEntry.get())) + , m_pTreeView(dynamic_cast(m_xTreeView.get())) + , m_bTreeChange(false) + { + assert(m_pEntry && m_pTreeView); + + Edit& rEntry = m_pEntry->getEntry(); + rEntry.SetAutocompleteHdl(LINK(this, SalInstanceEntryTreeView, AutocompleteHdl)); + rEntry.AddEventListener(LINK(this, SalInstanceEntryTreeView, KeyPressListener)); + } + + virtual void insert_separator(int /*pos*/, const OUString& /*rId*/) override { assert(false); } + + virtual void make_sorted() override + { + vcl::Window* pTreeView = m_pTreeView->getWidget(); + pTreeView->SetStyle(pTreeView->GetStyle() | WB_SORT); + } + + virtual void set_entry_completion(bool bEnable, bool /*bCaseSensitive*/) override + { + assert(!bEnable && "not implemented yet"); + (void)bEnable; + Edit& rEntry = m_pEntry->getEntry(); + rEntry.SetAutocompleteHdl(Link()); + } + + virtual void set_entry_font(const vcl::Font& rFont) override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.SetPointFont(rEntry, rFont); + rEntry.Invalidate(); + } + + virtual vcl::Font get_entry_font() override + { + Edit& rEntry = m_pEntry->getEntry(); + return rEntry.GetPointFont(rEntry); + } + + virtual void set_entry_placeholder_text(const OUString& rText) override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.SetPlaceholderText(rText); + } + + virtual void set_entry_editable(bool bEditable) override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.SetReadOnly(!bEditable); + } + + virtual void cut_entry_clipboard() override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.Cut(); + } + + virtual void copy_entry_clipboard() override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.Copy(); + } + + virtual void paste_entry_clipboard() override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.Paste(); + } + + virtual void grab_focus() override { m_xEntry->grab_focus(); } + + virtual void connect_focus_in(const Link& rLink) override + { + m_xEntry->connect_focus_in(rLink); + } + + virtual void connect_focus_out(const Link& rLink) override + { + m_xEntry->connect_focus_out(rLink); + } + + virtual bool changed_by_direct_pick() const override { return m_bTreeChange; } + + virtual void set_custom_renderer(bool /*bOn*/) override + { + assert(false && "not implemented"); + } + + virtual int get_max_mru_count() const override + { + assert(false && "not implemented"); + return 0; + } + + virtual void set_max_mru_count(int) override + { + assert(false && "not implemented"); + } + + virtual OUString get_mru_entries() const override + { + assert(false && "not implemented"); + return OUString(); + } + + virtual void set_mru_entries(const OUString&) override + { + assert(false && "not implemented"); + } + + virtual void set_item_menu(const OString&, weld::Menu*) override + { + assert(false && "not implemented"); + } + + int get_menu_button_width() const override + { + assert(false && "not implemented"); + return 0; + } + + VclPtr create_render_virtual_device() const override + { + return VclPtr::Create(); + } + + virtual ~SalInstanceEntryTreeView() override + { + Edit& rEntry = m_pEntry->getEntry(); + rEntry.RemoveEventListener(LINK(this, SalInstanceEntryTreeView, KeyPressListener)); + rEntry.SetAutocompleteHdl(Link()); + } +}; + +IMPL_LINK(SalInstanceEntryTreeView, KeyPressListener, VclWindowEvent&, rEvent, void) +{ + if (rEvent.GetId() != VclEventId::WindowKeyInput) + return; + const KeyEvent& rKeyEvent = *static_cast(rEvent.GetData()); + sal_uInt16 nKeyCode = rKeyEvent.GetKeyCode().GetCode(); + if (nKeyCode == KEY_UP || nKeyCode == KEY_DOWN || nKeyCode == KEY_PAGEUP + || nKeyCode == KEY_PAGEDOWN) + { + m_pTreeView->disable_notify_events(); + auto& rListBox = m_pTreeView->getTreeView(); + if (!rListBox.FirstSelected()) + { + if (SvTreeListEntry* pEntry = rListBox.First()) + rListBox.Select(pEntry, true); + } + else + rListBox.KeyInput(rKeyEvent); + m_xEntry->set_text(m_xTreeView->get_selected_text()); + m_xEntry->select_region(0, -1); + m_pTreeView->enable_notify_events(); + m_bTreeChange = true; + m_pEntry->fire_signal_changed(); + m_bTreeChange = false; + } +} + +IMPL_LINK(SalInstanceEntryTreeView, AutocompleteHdl, Edit&, rEdit, void) +{ + Selection aSel = rEdit.GetSelection(); + + OUString aFullText = rEdit.GetText(); + OUString aStartText = aFullText.copy(0, static_cast(aSel.Max())); + + int nPos = -1; + int nCount = m_xTreeView->n_children(); + for (int i = 0; i < nCount; ++i) + { + if (m_xTreeView->get_text(i).startsWithIgnoreAsciiCase(aStartText)) + { + nPos = i; + break; + } + } + + m_xTreeView->select(nPos); + + if (nPos != -1) + { + OUString aText = m_xTreeView->get_text(nPos); + Selection aSelection(aText.getLength(), aStartText.getLength()); + rEdit.SetText(aText, aSelection); + } +} + +SalInstanceBuilder::SalInstanceBuilder(vcl::Window* pParent, const OUString& rUIRoot, + const OUString& rUIFile) + : weld::Builder() + , m_xBuilder(new VclBuilder(pParent, rUIRoot, rUIFile, OString(), + css::uno::Reference(), false)) +{ +} + +std::unique_ptr SalInstanceBuilder::weld_message_dialog(const OString& id, + bool bTakeOwnership) +{ + MessageDialog* pMessageDialog = m_xBuilder->get(id); + std::unique_ptr pRet( + pMessageDialog ? new SalInstanceMessageDialog(pMessageDialog, this, false) : nullptr); + if (bTakeOwnership && pMessageDialog) + { + assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed"); + m_aOwnedToplevel.set(pMessageDialog); + m_xBuilder->drop_ownership(pMessageDialog); + } + return pRet; +} + +std::unique_ptr SalInstanceBuilder::weld_dialog(const OString& id, + bool bTakeOwnership) +{ + Dialog* pDialog = m_xBuilder->get(id); + std::unique_ptr pRet(pDialog ? new SalInstanceDialog(pDialog, this, false) + : nullptr); + if (bTakeOwnership && pDialog) + { + assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed"); + m_aOwnedToplevel.set(pDialog); + m_xBuilder->drop_ownership(pDialog); + } + return pRet; +} + +std::unique_ptr SalInstanceBuilder::weld_assistant(const OString& id, + bool bTakeOwnership) +{ + vcl::RoadmapWizard* pDialog = m_xBuilder->get(id); + std::unique_ptr pRet(pDialog ? new SalInstanceAssistant(pDialog, this, false) + : nullptr); + if (bTakeOwnership && pDialog) + { + assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed"); + m_aOwnedToplevel.set(pDialog); + m_xBuilder->drop_ownership(pDialog); + } + return pRet; +} + +std::unique_ptr SalInstanceBuilder::create_screenshot_window() +{ + assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed"); + + vcl::Window* pRoot = m_xBuilder->get_widget_root(); + if (SystemWindow* pWindow = dynamic_cast(pRoot)) + { + std::unique_ptr xRet(new SalInstanceWindow(pWindow, this, false)); + m_aOwnedToplevel.set(pWindow); + m_xBuilder->drop_ownership(pWindow); + return xRet; + } + + VclPtrInstance xDialog(nullptr, WB_HIDE | WB_STDDIALOG | WB_SIZEABLE | WB_CLOSEABLE, + Dialog::InitFlag::NoParent); + xDialog->SetText(utl::ConfigManager::getProductName()); + + auto xContentArea = VclPtr::Create(xDialog, false, 12); + pRoot->SetParent(xContentArea); + assert(pRoot == xContentArea->GetWindow(GetWindowType::FirstChild)); + xContentArea->Show(); + pRoot->Show(); + xDialog->SetHelpId(pRoot->GetHelpId()); + + m_aOwnedToplevel.set(xDialog); + + return std::unique_ptr(new SalInstanceDialog(xDialog, this, false)); +} + +std::unique_ptr SalInstanceBuilder::weld_window(const OString& id, + bool bTakeOwnership) +{ + SystemWindow* pWindow = m_xBuilder->get(id); + return pWindow ? std::make_unique(pWindow, this, bTakeOwnership) : nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_widget(const OString& id, + bool bTakeOwnership) +{ + vcl::Window* pWidget = m_xBuilder->get(id); + return pWidget ? std::make_unique(pWidget, this, bTakeOwnership) : nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_container(const OString& id, + bool bTakeOwnership) +{ + vcl::Window* pContainer = m_xBuilder->get(id); + return pContainer ? std::make_unique(pContainer, this, bTakeOwnership) + : nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_box(const OString& id, bool bTakeOwnership) +{ + vcl::Window* pContainer = m_xBuilder->get(id); + return pContainer ? std::make_unique(pContainer, this, bTakeOwnership) + : nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_paned(const OString& id, + bool bTakeOwnership) +{ + VclPaned* pPaned = m_xBuilder->get(id); + return pPaned ? std::make_unique(pPaned, this, bTakeOwnership) + : nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_frame(const OString& id, bool bTakeOwnership) +{ + VclFrame* pFrame = m_xBuilder->get(id); + std::unique_ptr pRet(pFrame ? new SalInstanceFrame(pFrame, this, false) : nullptr); + if (bTakeOwnership && pFrame) + { + assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed"); + m_aOwnedToplevel.set(pFrame); + m_xBuilder->drop_ownership(pFrame); + } + return pRet; +} + +std::unique_ptr SalInstanceBuilder::weld_scrolled_window(const OString& id, + bool bTakeOwnership) +{ + VclScrolledWindow* pScrolledWindow = m_xBuilder->get(id); + return pScrolledWindow + ? std::make_unique(pScrolledWindow, this, bTakeOwnership) + : nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_notebook(const OString& id, + bool bTakeOwnership) +{ + vcl::Window* pNotebook = m_xBuilder->get(id); + if (!pNotebook) + return nullptr; + if (pNotebook->GetType() == WindowType::TABCONTROL) + return std::make_unique(static_cast(pNotebook), this, + bTakeOwnership); + if (pNotebook->GetType() == WindowType::VERTICALTABCONTROL) + return std::make_unique( + static_cast(pNotebook), this, bTakeOwnership); + return nullptr; +} + +std::unique_ptr SalInstanceBuilder::weld_button(const OString& id, + bool bTakeOwnership) +{ + Button* pButton = m_xBuilder->get