From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- vcl/source/image/Image.cxx | 165 ++++++++ vcl/source/image/ImageRepository.cxx | 37 ++ vcl/source/image/ImageTree.cxx | 67 ++++ vcl/source/image/ImplImage.cxx | 176 +++++++++ vcl/source/image/ImplImageTree.cxx | 714 +++++++++++++++++++++++++++++++++++ 5 files changed, 1159 insertions(+) create mode 100644 vcl/source/image/Image.cxx create mode 100644 vcl/source/image/ImageRepository.cxx create mode 100644 vcl/source/image/ImageTree.cxx create mode 100644 vcl/source/image/ImplImage.cxx create mode 100644 vcl/source/image/ImplImageTree.cxx (limited to 'vcl/source/image') diff --git a/vcl/source/image/Image.cxx b/vcl/source/image/Image.cxx new file mode 100644 index 000000000..06937ab7f --- /dev/null +++ b/vcl/source/image/Image.cxx @@ -0,0 +1,165 @@ +/* -*- 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 + +using namespace css; + +Image::Image() +{ +} + +Image::Image(const BitmapEx& rBitmapEx) +{ + ImplInit(rBitmapEx); +} + +Image::Image(uno::Reference const & rxGraphic) +{ + if (rxGraphic.is()) + { + const Graphic aGraphic(rxGraphic); + + OUString aPath; + if (aGraphic.getOriginURL().startsWith("private:graphicrepository/", &aPath)) + mpImplData = std::make_shared(aPath); + else if (aGraphic.GetType() == GraphicType::GdiMetafile) + mpImplData = std::make_shared(aGraphic.GetGDIMetaFile()); + else + ImplInit(aGraphic.GetBitmapEx()); + } +} + +Image::Image(const OUString & rFileUrl) +{ + OUString sImageName; + if (rFileUrl.startsWith("private:graphicrepository/", &sImageName)) + mpImplData = std::make_shared(sImageName); + else + { + Graphic aGraphic; + if (ERRCODE_NONE == GraphicFilter::LoadGraphic(rFileUrl, IMP_PNG, aGraphic)) + ImplInit(aGraphic.GetBitmapEx()); + } +} + +Image::Image(StockImage, const OUString & rFileUrl) + : mpImplData(std::make_shared(rFileUrl)) +{ +} + +void Image::ImplInit(const BitmapEx& rBitmapEx) +{ + if (!rBitmapEx.IsEmpty()) + mpImplData = std::make_shared(rBitmapEx); +} + +OUString Image::GetStock() const +{ + if (mpImplData) + return mpImplData->getStock(); + return OUString(); +} + +Size Image::GetSizePixel() const +{ + if (mpImplData) + return mpImplData->getSizePixel(); + else + return Size(); +} + +BitmapEx Image::GetBitmapEx() const +{ + if (mpImplData) + return mpImplData->getBitmapEx(); + else + return BitmapEx(); +} + +bool Image::operator==(const Image& rImage) const +{ + bool bRet = false; + + if (rImage.mpImplData == mpImplData) + bRet = true; + else if (!rImage.mpImplData || !mpImplData) + bRet = false; + else + bRet = rImage.mpImplData->isEqual(*mpImplData); + + return bRet; +} + +void Image::Draw(OutputDevice* pOutDev, const Point& rPos, DrawImageFlags nStyle, const Size* pSize) +{ + if (!mpImplData || (!pOutDev->IsDeviceOutputNecessary() && pOutDev->GetConnectMetaFile() == nullptr)) + return; + + Size aOutSize = pSize ? *pSize : pOutDev->PixelToLogic(mpImplData->getSizePixel()); + + BitmapEx aRenderBmp = mpImplData->getBitmapExForHiDPI(bool(nStyle & DrawImageFlags::Disable), pOutDev->GetGraphics()); + + if (!(nStyle & DrawImageFlags::Disable) && + (nStyle & (DrawImageFlags::ColorTransform | DrawImageFlags::Highlight | + DrawImageFlags::Deactive | DrawImageFlags::SemiTransparent))) + { + BitmapEx aTempBitmapEx(aRenderBmp); + + if (nStyle & (DrawImageFlags::Highlight | DrawImageFlags::Deactive)) + { + const StyleSettings& rSettings = pOutDev->GetSettings().GetStyleSettings(); + Color aColor; + if (nStyle & DrawImageFlags::Highlight) + aColor = rSettings.GetHighlightColor(); + else + aColor = rSettings.GetDeactiveColor(); + + BitmapFilter::Filter(aTempBitmapEx, BitmapColorizeFilter(aColor)); + } + + if (nStyle & DrawImageFlags::SemiTransparent) + { + if (aTempBitmapEx.IsAlpha()) + { + Bitmap aAlphaBmp(aTempBitmapEx.GetAlpha().GetBitmap()); + aAlphaBmp.Adjust(50); + aTempBitmapEx = BitmapEx(aTempBitmapEx.GetBitmap(), AlphaMask(aAlphaBmp)); + } + else + { + sal_uInt8 cErase = 128; + aTempBitmapEx = BitmapEx(aTempBitmapEx.GetBitmap(), AlphaMask(aTempBitmapEx.GetSizePixel(), &cErase)); + } + } + aRenderBmp = aTempBitmapEx; + } + + pOutDev->DrawBitmapEx(rPos, aOutSize, aRenderBmp); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/image/ImageRepository.cxx b/vcl/source/image/ImageRepository.cxx new file mode 100644 index 000000000..6bf57e699 --- /dev/null +++ b/vcl/source/image/ImageRepository.cxx @@ -0,0 +1,37 @@ +/* -*- 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 + +namespace vcl +{ + bool ImageRepository::loadImage( const OUString& _rName, BitmapEx& _out_rImage ) + { + OUString sIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme(); + + return ImageTree::get().loadImage( _rName, sIconTheme, _out_rImage, false/*_bSearchLanguageDependent*/ ); + } + +} // namespace vcl + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/image/ImageTree.cxx b/vcl/source/image/ImageTree.cxx new file mode 100644 index 000000000..fdc47cbfe --- /dev/null +++ b/vcl/source/image/ImageTree.cxx @@ -0,0 +1,67 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + */ + +#include +#include +#include +#include + +ImageTree & ImageTree::get() { + static ImageTree s_ImageTree; + return s_ImageTree; +} + +ImageTree::ImageTree() + : mpImplImageTree(new ImplImageTree) +{ +} + +OUString ImageTree::getImageUrl(OUString const & rName, OUString const & rStyle, OUString const & rLang) + +{ + return mpImplImageTree->getImageUrl(rName, rStyle, rLang); +} + +std::shared_ptr ImageTree::getImageStream(OUString const & rName, OUString const & rStyle, OUString const & rLang) +{ + return mpImplImageTree->getImageStream(rName, rStyle, rLang); +} + +css::uno::Reference ImageTree::getImageXInputStream(OUString const & rName, OUString const & rStyle, OUString const & rLang) +{ + return mpImplImageTree->getImageXInputStream(rName, rStyle, rLang); +} + +bool ImageTree::loadImage(OUString const & rName, OUString const & rStyle, + BitmapEx & rBitmap, bool bLocalized, + sal_Int32 nScalePercentage, + const ImageLoadFlags eFlags) +{ + return mpImplImageTree->loadImage(rName, rStyle, rBitmap, bLocalized, eFlags, nScalePercentage); +} + +bool ImageTree::loadImage(OUString const & rName, OUString const & rStyle, + BitmapEx & rBitmap, bool bLocalized, + const ImageLoadFlags eFlags) +{ + return loadImage(rName, rStyle, rBitmap, bLocalized, -1, eFlags); +} + +css::uno::Reference const & ImageTree::getNameAccess() +{ + return mpImplImageTree->getNameAccess(); +} + +void ImageTree::shutdown() +{ + mpImplImageTree->shutdown(); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/image/ImplImage.cxx b/vcl/source/image/ImplImage.cxx new file mode 100644 index 000000000..756b8ddcd --- /dev/null +++ b/vcl/source/image/ImplImage.cxx @@ -0,0 +1,176 @@ +/* -*- 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 + +ImplImage::ImplImage(const BitmapEx &rBitmapEx) + : maBitmapChecksum(0) + , maSizePixel(rBitmapEx.GetSizePixel()) + , maBitmapEx(rBitmapEx) +{ +} + +ImplImage::ImplImage(const OUString &aStockName) + : maBitmapChecksum(0) + , maStockName(aStockName) +{ +} + +ImplImage::ImplImage(const GDIMetaFile& rMetaFile) + : maBitmapChecksum(0) + , maSizePixel(rMetaFile.GetPrefSize()) + , mxMetaFile(new GDIMetaFile(rMetaFile)) +{ +} + +bool ImplImage::loadStockAtScale(SalGraphics* pGraphics, BitmapEx &rBitmapEx) +{ + BitmapEx aBitmapEx; + + ImageLoadFlags eScalingFlags = ImageLoadFlags::NONE; + sal_Int32 nScalePercentage = -1; + + double fScale(1.0); + if (pGraphics && pGraphics->ShouldDownscaleIconsAtSurface(&fScale)) // scale at the surface + { + nScalePercentage = fScale * 100.0; + eScalingFlags = ImageLoadFlags::IgnoreScalingFactor; + } + + OUString aIconTheme = Application::GetSettings().GetStyleSettings().DetermineIconTheme(); + if (!ImageTree::get().loadImage(maStockName, aIconTheme, aBitmapEx, true, + nScalePercentage, eScalingFlags)) + { + /* If the uno command has parameters, passed in from a toolbar, + * recover from failure by removing the parameters from the file name + */ + if (maStockName.indexOf("%3f") > 0) + { + sal_Int32 nStart = maStockName.indexOf("%3f"); + sal_Int32 nEnd = maStockName.lastIndexOf("."); + + OUString aFileName = maStockName.replaceAt(nStart, nEnd - nStart, u""); + if (!ImageTree::get().loadImage(aFileName, aIconTheme, aBitmapEx, true, + nScalePercentage, eScalingFlags)) + { + SAL_WARN("vcl", "Failed to load scaled image from " << maStockName << + " and " << aFileName << " at " << fScale); + return false; + } + } + else + { + SAL_WARN("vcl", "Failed to load scaled image from " << maStockName << + " at " << fScale); + return false; + } + } + rBitmapEx = aBitmapEx; + return true; +} + +Size ImplImage::getSizePixel() +{ + Size aRet; + if (!isSizeEmpty()) + aRet = maSizePixel; + else if (isStock()) + { + if (loadStockAtScale(nullptr, maBitmapEx)) + { + assert(maDisabledBitmapEx.IsEmpty()); + assert(maBitmapChecksum == 0); + maSizePixel = maBitmapEx.GetSizePixel(); + aRet = maSizePixel; + } + else + SAL_WARN("vcl", "Failed to load stock icon " << maStockName); + } + return aRet; +} + +/// non-HiDPI compatibility method. +BitmapEx const & ImplImage::getBitmapEx(bool bDisabled) +{ + getSizePixel(); // force load, and at unity scale. + if (bDisabled) + { + // Changed since we last generated this. + BitmapChecksum aChecksum = maBitmapEx.GetChecksum(); + if (maBitmapChecksum != aChecksum || + maDisabledBitmapEx.GetSizePixel() != maBitmapEx.GetSizePixel()) + { + maDisabledBitmapEx = maBitmapEx; + BitmapFilter::Filter(maDisabledBitmapEx, BitmapDisabledImageFilter()); + maBitmapChecksum = aChecksum; + } + return maDisabledBitmapEx; + } + + return maBitmapEx; +} + +bool ImplImage::isEqual(const ImplImage &ref) const +{ + if (isStock() != ref.isStock()) + return false; + if (isStock()) + return maStockName == ref.maStockName; + else + return maBitmapEx == ref.maBitmapEx; +} + +BitmapEx const & ImplImage::getBitmapExForHiDPI(bool bDisabled, SalGraphics* pGraphics) +{ + if ((isStock() || mxMetaFile) && pGraphics) + { // check we have the right bitmap cached. + double fScale = 1.0; + pGraphics->ShouldDownscaleIconsAtSurface(&fScale); + Size aTarget(maSizePixel.Width()*fScale, + maSizePixel.Height()*fScale); + if (maBitmapEx.GetSizePixel() != aTarget) + { + if (isStock()) + loadStockAtScale(pGraphics, maBitmapEx); + else // if (mxMetaFile) + { + ScopedVclPtrInstance aVDev(DeviceFormat::DEFAULT, DeviceFormat::DEFAULT); + aVDev->SetOutputSizePixel(aTarget); + mxMetaFile->WindStart(); + mxMetaFile->Play(*aVDev, Point(), aTarget); + maBitmapEx = aVDev->GetBitmapEx(Point(), aTarget); + } + } + } + return getBitmapEx(bDisabled); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/source/image/ImplImageTree.cxx b/vcl/source/image/ImplImageTree.cxx new file mode 100644 index 000000000..36ac5f4de --- /dev/null +++ b/vcl/source/image/ImplImageTree.cxx @@ -0,0 +1,714 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#include + +#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 + +using namespace css; + +bool ImageRequestParameters::convertToDarkTheme() +{ + static bool bIconsForDarkTheme = !!getenv("VCL_ICONS_FOR_DARK_THEME"); + + bool bConvertToDarkTheme = false; + if (!(meFlags & ImageLoadFlags::IgnoreDarkTheme)) + bConvertToDarkTheme = bIconsForDarkTheme; + + return bConvertToDarkTheme; +} + +sal_Int32 ImageRequestParameters::scalePercentage() +{ + sal_Int32 aScalePercentage = 100; + if (!(meFlags & ImageLoadFlags::IgnoreScalingFactor)) + aScalePercentage = Application::GetDefaultDevice()->GetDPIScalePercentage(); + else if (mnScalePercentage > 0) + aScalePercentage = mnScalePercentage; + return aScalePercentage; +} + +namespace +{ + +OUString convertLcTo32Path(std::u16string_view rPath) +{ + OUString aResult; + size_t nSlashPos = rPath.rfind('/'); + if (nSlashPos != std::u16string_view::npos) + { + sal_Int32 nCopyFrom = nSlashPos + 1; + std::u16string_view sFile = rPath.substr(nCopyFrom); + std::u16string_view sDir = rPath.substr(0, nSlashPos); + if (!sFile.empty() && o3tl::starts_with(sFile, u"lc_")) + { + aResult = OUString::Concat(sDir) + "/32/" + sFile.substr(3); + } + } + return aResult; +} + +OUString createPath(std::u16string_view name, sal_Int32 pos, std::u16string_view locale) +{ + return OUString::Concat(name.substr(0, pos + 1)) + locale + name.substr(pos); +} + +OUString getIconCacheUrl(std::u16string_view sVariant, ImageRequestParameters const & rParameters) +{ + // the macro expansion can be expensive in bulk, so cache that + static OUString CACHE_DIR = []() + { + OUString sDir = "${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/cache/"; + rtl::Bootstrap::expandMacros(sDir); + return sDir; + }(); + return CACHE_DIR + rParameters.msStyle + "/" + sVariant + "/" + rParameters.msName; +} + +OUString createIconCacheUrl( + std::u16string_view sVariant, ImageRequestParameters const & rParameters) +{ + OUString sUrl(getIconCacheUrl(sVariant, rParameters)); + OUString sDir = sUrl.copy(0, sUrl.lastIndexOf('/')); + osl::Directory::createPath(sDir); + return sUrl; +} + +bool urlExists(OUString const & sUrl) +{ + osl::File aFile(sUrl); + osl::FileBase::RC eRC = aFile.open(osl_File_OpenFlag_Read); + return osl::FileBase::E_None == eRC; +} + +OUString getNameNoExtension(std::u16string_view sName) +{ + size_t nDotPosition = sName.rfind('.'); + return OUString(sName.substr(0, nDotPosition)); +} + +std::shared_ptr wrapStream(uno::Reference const & rInputStream) +{ + // This could use SvInputStream instead if that did not have a broken + // SeekPos implementation for an XInputStream that is not also XSeekable + // (cf. "@@@" at tags/DEV300_m37/svtools/source/misc1/strmadpt.cxx@264807 + // l. 593): + OSL_ASSERT(rInputStream.is()); + std::shared_ptr aMemoryStream(std::make_shared()); + for (;;) + { + const sal_Int32 nSize(2048); + uno::Sequence aData(nSize); + sal_Int32 nRead = rInputStream->readBytes(aData, nSize); + aMemoryStream->WriteBytes(aData.getConstArray(), nRead); + if (nRead < nSize) + break; + } + aMemoryStream->Seek(0); + rInputStream->closeInput(); + return aMemoryStream; +} + +void loadImageFromStream(std::shared_ptr const & xStream, OUString const & rPath, ImageRequestParameters& rParameters) +{ + bool bConvertToDarkTheme = rParameters.convertToDarkTheme(); + sal_Int32 aScalePercentage = rParameters.scalePercentage(); + + if (rPath.endsWith(".png")) + { + vcl::PngImageReader aPNGReader(*xStream); + aPNGReader.read(rParameters.mrBitmap); + } + else if (rPath.endsWith(".svg")) + { + rParameters.mbWriteImageToCache = true; // We always want to cache a SVG image + vcl::bitmap::loadFromSvg(*xStream, rPath, rParameters.mrBitmap, aScalePercentage / 100.0); + + if (bConvertToDarkTheme) + BitmapFilter::Filter(rParameters.mrBitmap, BitmapLightenFilter()); + + return; + } + else + { + ReadDIBBitmapEx(rParameters.mrBitmap, *xStream); + } + + if (bConvertToDarkTheme) + { + rParameters.mbWriteImageToCache = true; // Cache the dark variant + BitmapFilter::Filter(rParameters.mrBitmap, BitmapLightenFilter()); + } + + if (aScalePercentage > 100) + { + rParameters.mbWriteImageToCache = true; // Cache the scaled variant + double aScaleFactor(aScalePercentage / 100.0); + // when scaling use the full 24bit RGB values + rParameters.mrBitmap.Convert(BmpConversion::N24Bit); + rParameters.mrBitmap.Scale(aScaleFactor, aScaleFactor, BmpScaleFlag::Fast); + } +} + +} // end anonymous namespace + +ImplImageTree::ImplImageTree() +{ +} + +ImplImageTree::~ImplImageTree() +{ +} + +std::vector ImplImageTree::getPaths(OUString const & name, LanguageTag const & rLanguageTag) +{ + std::vector sPaths; + + sal_Int32 pos = name.lastIndexOf('/'); + if (pos != -1) + { + for (const OUString& rFallback : rLanguageTag.getFallbackStrings(true)) + { + OUString aFallbackName = getNameNoExtension(getRealImageName(createPath(name, pos, rFallback))); + sPaths.emplace_back(aFallbackName + ".png"); + sPaths.emplace_back(aFallbackName + ".svg"); + } + } + + OUString aRealName = getNameNoExtension(getRealImageName(name)); + sPaths.emplace_back(aRealName + ".png"); + sPaths.emplace_back(aRealName + ".svg"); + + return sPaths; +} + +OUString ImplImageTree::getImageUrl(OUString const & rName, OUString const & rStyle, OUString const & rLang) +{ + OUString aStyle(rStyle); + + while (!aStyle.isEmpty()) + { + try + { + setStyle(aStyle); + + if (checkPathAccess()) + { + IconSet& rIconSet = getCurrentIconSet(); + const uno::Reference & rNameAccess = rIconSet.maNameAccess; + + LanguageTag aLanguageTag(rLang); + + for (const OUString& rPath: getPaths(rName, aLanguageTag)) + { + if (rNameAccess->hasByName(rPath)) + { + return "vnd.sun.star.zip://" + + rtl::Uri::encode(rIconSet.maURL, rtl_UriCharClassRegName, + rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8) + + "/" + rPath; + } + } + } + } + catch (const uno::Exception &) + { + TOOLS_INFO_EXCEPTION("vcl", ""); + } + + aStyle = fallbackStyle(aStyle); + } + return OUString(); +} + +uno::Reference ImplImageTree::getImageXInputStream(OUString const & rName, OUString const & rStyle, OUString const & rLang) +{ + OUString aStyle(rStyle); + + while (!aStyle.isEmpty()) + { + try + { + setStyle(aStyle); + + if (checkPathAccess()) + { + IconSet& rIconSet = getCurrentIconSet(); + const uno::Reference& rNameAccess = rIconSet.maNameAccess; + + LanguageTag aLanguageTag(rLang); + + for (const OUString& rPath: getPaths(rName, aLanguageTag)) + { + if (rNameAccess->hasByName(rPath)) + { + uno::Reference aStream; + bool ok = rNameAccess->getByName(rPath) >>= aStream; + assert(ok); + (void)ok; // prevent unused warning in release build + return aStream; + } + } + } + } + catch (const uno::Exception &) + { + TOOLS_INFO_EXCEPTION("vcl", ""); + } + + aStyle = fallbackStyle(aStyle); + } + return nullptr; +} + +std::shared_ptr ImplImageTree::getImageStream(OUString const & rName, OUString const & rStyle, OUString const & rLang) +{ + uno::Reference xStream = getImageXInputStream(rName, rStyle, rLang); + if (xStream) + return wrapStream(xStream); + return std::shared_ptr(); +} + +OUString ImplImageTree::fallbackStyle(std::u16string_view rsStyle) +{ + OUString sResult; + + if (rsStyle == u"colibre" || rsStyle == u"helpimg") + sResult = ""; + else if (rsStyle == u"sifr" || rsStyle == u"breeze_dark") + sResult = "breeze"; + else if (rsStyle == u"sifr_dark" ) + sResult = "breeze_dark"; + else + sResult = "colibre"; + + return sResult; +} + +bool ImplImageTree::loadImage(OUString const & rName, OUString const & rStyle, BitmapEx & rBitmap, bool localized, + const ImageLoadFlags eFlags, sal_Int32 nScalePercentage) +{ + OUString aCurrentStyle(rStyle); + while (!aCurrentStyle.isEmpty()) + { + try + { + ImageRequestParameters aParameters(rName, aCurrentStyle, rBitmap, localized, eFlags, nScalePercentage); + if (doLoadImage(aParameters)) + return true; + } + catch (uno::RuntimeException &) + {} + + aCurrentStyle = fallbackStyle(aCurrentStyle); + } + return false; +} + +namespace +{ + +OUString createVariant(ImageRequestParameters& rParameters) +{ + bool bConvertToDarkTheme = rParameters.convertToDarkTheme(); + sal_Int32 aScalePercentage = rParameters.scalePercentage(); + + OUString aVariant = OUString::number(aScalePercentage); + + if (bConvertToDarkTheme) + aVariant += "-dark"; + + return aVariant; +} + +bool loadDiskCachedVersion(std::u16string_view sVariant, ImageRequestParameters& rParameters) +{ + OUString sUrl(getIconCacheUrl(sVariant, rParameters)); + if (!urlExists(sUrl)) + return false; + SvFileStream aFileStream(sUrl, StreamMode::READ); + vcl::PngImageReader aPNGReader(aFileStream); + aPNGReader.read(rParameters.mrBitmap); + return true; +} + +void cacheBitmapToDisk(std::u16string_view sVariant, ImageRequestParameters const & rParameters) +{ + OUString sUrl(createIconCacheUrl(sVariant, rParameters)); + vcl::PNGWriter aWriter(rParameters.mrBitmap); + try + { + SvFileStream aStream(sUrl, StreamMode::WRITE); + aWriter.Write(aStream); + aStream.Close(); + } + catch (...) + {} +} + +} // end anonymous namespace + +bool ImplImageTree::doLoadImage(ImageRequestParameters& rParameters) +{ + setStyle(rParameters.msStyle); + + if (iconCacheLookup(rParameters)) + return true; + + OUString aVariant = createVariant(rParameters); + if (loadDiskCachedVersion(aVariant, rParameters)) + return true; + + if (!rParameters.mrBitmap.IsEmpty()) + rParameters.mrBitmap.SetEmpty(); + + LanguageTag aLanguageTag = Application::GetSettings().GetUILanguageTag(); + + std::vector aPaths = getPaths(rParameters.msName, aLanguageTag); + + bool bFound = false; + + try + { + bFound = findImage(aPaths, rParameters); + } + catch (uno::RuntimeException&) + { + throw; + } + catch (const uno::Exception&) + { + TOOLS_INFO_EXCEPTION("vcl", "ImplImageTree::doLoadImage"); + } + + if (bFound) + { + if (rParameters.mbWriteImageToCache) + { + cacheBitmapToDisk(aVariant, rParameters); + } + getIconCache(rParameters)[rParameters.msName] = std::make_pair(rParameters.mbLocalized, rParameters.mrBitmap); + } + + return bFound; +} + +void ImplImageTree::shutdown() +{ + maCurrentStyle.clear(); + maIconSets.clear(); +} + +void ImplImageTree::setStyle(OUString const & style) +{ + assert(!style.isEmpty()); + if (style != maCurrentStyle) + { + maCurrentStyle = style; + createStyle(); + } +} + +/** + * The vcldemo app doesn't set up all the config stuff that the main app does, so we need another + * way of finding the cursor images. + */ +static bool isVclDemo() +{ + static const bool bVclDemoOverride = std::getenv("LIBO_VCL_DEMO") != nullptr; + return bVclDemoOverride; +} + +void ImplImageTree::createStyle() +{ + if (maIconSets.find(maCurrentStyle) != maIconSets.end()) + return; + + OUString sThemeUrl; + + if (isVclDemo()) + { + if (maCurrentStyle == "default") + sThemeUrl = "file://" SRC_ROOT "/icon-themes/colibre-svg"; + else + sThemeUrl = "file://" SRC_ROOT "/icon-themes/" + maCurrentStyle; + } + else if (maCurrentStyle != "default") + { + OUString paths = vcl::IconThemeScanner::GetStandardIconThemePath(); + std::deque aPaths; + sal_Int32 nIndex = 0; + do + { + aPaths.push_front(paths.getToken(0, ';', nIndex)); + } + while (nIndex >= 0); + + for (const auto& path : aPaths) + { + INetURLObject aUrl(path); + OSL_ASSERT(!aUrl.HasError()); + + bool ok = aUrl.Append(OUStringConcatenation("images_" + maCurrentStyle), INetURLObject::EncodeMechanism::All); + OSL_ASSERT(ok); + sThemeUrl = aUrl.GetMainURL(INetURLObject::DecodeMechanism::NONE) + ".zip"; + if (urlExists(sThemeUrl)) + break; + sThemeUrl.clear(); + } + + if (sThemeUrl.isEmpty()) + return; + } + else + { + sThemeUrl += "images"; + if (!urlExists(sThemeUrl)) + return; + } + + maIconSets[maCurrentStyle] = IconSet(sThemeUrl); + + loadImageLinks(); +} + +/// Find an icon cache for the right scale factor +ImplImageTree::IconCache &ImplImageTree::getIconCache(const ImageRequestParameters& rParameters) +{ + IconSet &rSet = getCurrentIconSet(); + auto it = rSet.maScaledIconCaches.find(rParameters.mnScalePercentage); + if ( it != rSet.maScaledIconCaches.end() ) + return it->second; + rSet.maScaledIconCaches.emplace(rParameters.mnScalePercentage, IconCache()); + return rSet.maScaledIconCaches[rParameters.mnScalePercentage]; +} + +bool ImplImageTree::iconCacheLookup(ImageRequestParameters& rParameters) +{ + IconCache& rIconCache = getIconCache(rParameters); + + IconCache::iterator i(rIconCache.find(getRealImageName(rParameters.msName))); + if (i != rIconCache.end() && i->second.first == rParameters.mbLocalized) + { + rParameters.mrBitmap = i->second.second; + return true; + } + + return false; +} + +bool ImplImageTree::findImage(std::vector const & rPaths, ImageRequestParameters& rParameters) +{ + if (!checkPathAccess()) + return false; + + uno::Reference const & rNameAccess = getCurrentIconSet().maNameAccess; + + for (OUString const & rPath : rPaths) + { + if (rNameAccess->hasByName(rPath)) + { + uno::Reference aStream; + bool ok = rNameAccess->getByName(rPath) >>= aStream; + assert(ok); + (void)ok; // prevent unused warning in release build + + loadImageFromStream(wrapStream(aStream), rPath, rParameters); + + return true; + } + } + return false; +} + +void ImplImageTree::loadImageLinks() +{ + static const OUStringLiteral aLinkFilename(u"links.txt"); + + if (!checkPathAccess()) + return; + + const uno::Reference &rNameAccess = getCurrentIconSet().maNameAccess; + + if (rNameAccess->hasByName(aLinkFilename)) + { + uno::Reference xStream; + bool ok = rNameAccess->getByName(aLinkFilename) >>= xStream; + assert(ok); + (void)ok; // prevent unused warning in release build + + parseLinkFile(wrapStream(xStream)); + return; + } +} + +void ImplImageTree::parseLinkFile(std::shared_ptr const & xStream) +{ + OStringBuffer aLine; + OUString aLink, aOriginal; + int nLineNo = 0; + while (xStream->ReadLine(aLine)) + { + ++nLineNo; + if (aLine.isEmpty()) + continue; + + sal_Int32 nIndex = 0; + aLink = OStringToOUString(o3tl::getToken(aLine, 0, ' ', nIndex), RTL_TEXTENCODING_UTF8); + aOriginal = OStringToOUString(o3tl::getToken(aLine, 0, ' ', nIndex), RTL_TEXTENCODING_UTF8); + + // skip comments, or incomplete entries + if (aLink.isEmpty() || aLink[0] == '#' || aOriginal.isEmpty()) + { + if (aLink.isEmpty() || aOriginal.isEmpty()) + SAL_WARN("vcl", "ImplImageTree::parseLinkFile: icon links.txt parse error, incomplete link at line " << nLineNo); + continue; + } + + getCurrentIconSet().maLinkHash[aLink] = aOriginal; + + OUString aOriginal32 = convertLcTo32Path(aOriginal); + OUString aLink32 = convertLcTo32Path(aLink); + + if (!aOriginal32.isEmpty() && !aLink32.isEmpty()) + getCurrentIconSet().maLinkHash[aLink32] = aOriginal32; + } +} + +OUString const & ImplImageTree::getRealImageName(OUString const & rIconName) +{ + IconLinkHash & rLinkHash = maIconSets[maCurrentStyle].maLinkHash; + + OUString sNameWithNoExtension = getNameNoExtension(rIconName); + + // PNG is priority + auto it = rLinkHash.find(sNameWithNoExtension + ".png"); + if (it != rLinkHash.end()) + return it->second; + + // also check SVG name + it = rLinkHash.find(sNameWithNoExtension + ".svg"); + if (it != rLinkHash.end()) + return it->second; + + // neither was found so just return the original name + return rIconName; +} + +namespace { + +class FolderFileAccess : public ::cppu::WeakImplHelper +{ +public: + uno::Reference< uno::XComponentContext > mxContext; + OUString maURL; + FolderFileAccess(uno::Reference< uno::XComponentContext > const & context, OUString const & url) + : mxContext(context), maURL(url) {} + // XElementAccess + virtual css::uno::Type SAL_CALL getElementType() override { return cppu::UnoType::get(); } + virtual sal_Bool SAL_CALL hasElements() override { return true; } + // XNameAccess + virtual css::uno::Any SAL_CALL getByName( const OUString& aName ) override + { + uno::Reference< io::XInputStream > xInputStream = ucb::SimpleFileAccess::create(mxContext)->openFileRead( maURL + "/" + aName ); + return css::uno::Any(xInputStream); + } + virtual css::uno::Sequence< OUString > SAL_CALL getElementNames() override + { + return {}; + } + virtual sal_Bool SAL_CALL hasByName( const OUString& aName ) override + { + osl::File aBaseFile(maURL + "/" + aName); + return osl::File::E_None == aBaseFile.open(osl_File_OpenFlag_Read); + } +}; + +} + +bool ImplImageTree::checkPathAccess() +{ + IconSet& rIconSet = getCurrentIconSet(); + uno::Reference & rNameAccess = rIconSet.maNameAccess; + if (rNameAccess.is()) + return true; + + try + { + if (isVclDemo()) + rNameAccess = new FolderFileAccess(comphelper::getProcessComponentContext(), rIconSet.maURL); + else + rNameAccess = packages::zip::ZipFileAccess::createWithURL(comphelper::getProcessComponentContext(), rIconSet.maURL); + } + catch (const uno::RuntimeException &) + { + throw; + } + catch (const uno::Exception &) + { + TOOLS_INFO_EXCEPTION("vcl", "ImplImageTree::zip file location " << rIconSet.maURL); + return false; + } + return rNameAccess.is(); +} + +uno::Reference const & ImplImageTree::getNameAccess() +{ + (void)checkPathAccess(); + return getCurrentIconSet().maNameAccess; +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3