Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 716 insertions, 0 deletions

diff --git a/vcl/source/image/ImplImageTree.cxx b/vcl/source/image/ImplImageTree.cxx
new file mode 100644
index 0000000000..94ce3b94cf
--- /dev/null
+++ b/vcl/source/image/ImplImageTree.cxx
@@ -0,0 +1,716 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <config_folders.h>
+
+#include <sal/config.h>
+#include <sal/log.hxx>
+
+#include <deque>
+#include <string_view>
+
+#include <com/sun/star/container/XNameAccess.hpp>
+#include <com/sun/star/io/XInputStream.hpp>
+#include <com/sun/star/packages/zip/ZipFileAccess.hpp>
+#include <com/sun/star/ucb/SimpleFileAccess.hpp>
+#include <com/sun/star/uno/Exception.hpp>
+#include <com/sun/star/uno/RuntimeException.hpp>
+#include <com/sun/star/uno/Sequence.hxx>
+#include <comphelper/processfactory.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <osl/file.hxx>
+#include <osl/diagnose.h>
+#include <osl/process.h>
+#include <rtl/bootstrap.hxx>
+#include <rtl/uri.hxx>
+#include <rtl/strbuf.hxx>
+
+#include <comphelper/diagnose_ex.hxx>
+#include <tools/stream.hxx>
+#include <tools/urlobj.hxx>
+#include <implimagetree.hxx>
+
+#include <utility>
+#include <vcl/bitmapex.hxx>
+#include <vcl/dibtools.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/BitmapTools.hxx>
+#include <IconThemeScanner.hxx>
+#include <vcl/filter/PngImageReader.hxx>
+#include <vcl/outdev.hxx>
+#include <vcl/filter/PngImageWriter.hxx>
+#include <o3tl/string_view.hxx>
+#include <bitmap/BitmapLightenFilter.hxx>
+
+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;
+    OutputDevice* pDevice = Application::GetDefaultDevice();
+    if (!(meFlags & ImageLoadFlags::IgnoreScalingFactor) && pDevice != nullptr)
+        aScalePercentage = pDevice->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<SvMemoryStream> wrapStream(uno::Reference<io::XInputStream> 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<SvMemoryStream> aMemoryStream(std::make_shared<SvMemoryStream>());
+    for (;;)
+    {
+        const sal_Int32 nSize(2048);
+        uno::Sequence<sal_Int8> 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<SvStream> 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<OUString> ImplImageTree::getPaths(OUString const & name, LanguageTag const & rLanguageTag)
+{
+    std::vector<OUString> 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<container::XNameAccess> & 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<io::XInputStream> 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<container::XNameAccess>& rNameAccess = rIconSet.maNameAccess;
+
+                LanguageTag aLanguageTag(rLang);
+
+                for (const OUString& rPath: getPaths(rName, aLanguageTag))
+                {
+                    if (rNameAccess->hasByName(rPath))
+                    {
+                        uno::Reference<io::XInputStream> 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<SvMemoryStream> ImplImageTree::getImageStream(OUString const & rName, OUString const & rStyle, OUString const & rLang)
+{
+    uno::Reference<io::XInputStream> xStream = getImageXInputStream(rName, rStyle, rLang);
+    if (xStream)
+        return wrapStream(xStream);
+    return std::shared_ptr<SvMemoryStream>();
+}
+
+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));
+    try
+    {
+        SvFileStream aStream(sUrl, StreamMode::WRITE);
+        vcl::PngImageWriter aWriter(aStream);
+        aWriter.write(rParameters.mrBitmap);
+        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<OUString> 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<OUString> 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(Concat2View("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<OUString> const & rPaths, ImageRequestParameters& rParameters)
+{
+    if (!checkPathAccess())
+        return false;
+
+    uno::Reference<container::XNameAccess> const & rNameAccess = getCurrentIconSet().maNameAccess;
+
+    for (OUString const & rPath : rPaths)
+    {
+        if (rNameAccess->hasByName(rPath))
+        {
+            uno::Reference<io::XInputStream> 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 constexpr OUString aLinkFilename(u"links.txt"_ustr);
+
+    if (!checkPathAccess())
+        return;
+
+    const uno::Reference<container::XNameAccess> &rNameAccess = getCurrentIconSet().maNameAccess;
+
+    if (rNameAccess->hasByName(aLinkFilename))
+    {
+        uno::Reference<io::XInputStream> 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<SvStream> 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<css::container::XNameAccess>
+{
+public:
+    uno::Reference< uno::XComponentContext > mxContext;
+    OUString maURL;
+    FolderFileAccess(uno::Reference< uno::XComponentContext > context, OUString url)
+        : mxContext(std::move(context)), maURL(std::move(url)) {}
+    // XElementAccess
+    virtual css::uno::Type SAL_CALL getElementType() override { return cppu::UnoType<io::XInputStream>::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<container::XNameAccess> & 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<container::XNameAccess> const & ImplImageTree::getNameAccess()
+{
+    (void)checkPathAccess();
+    return getCurrentIconSet().maNameAccess;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */