vcl/source/image/ImplImageTree.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_folders.h>
  21
  22 #include "sal/config.h"
  23
  24 #include "com/sun/star/container/XNameAccess.hpp"
  25 #include "com/sun/star/io/XInputStream.hpp"
  26 #include "com/sun/star/lang/Locale.hpp"
  27 #include "com/sun/star/lang/XMultiServiceFactory.hpp"
  28 #include "com/sun/star/packages/zip/ZipFileAccess.hpp"
  29 #include "com/sun/star/uno/Exception.hpp"
  30 #include "com/sun/star/uno/RuntimeException.hpp"
  31 #include "com/sun/star/uno/Sequence.hxx"
  32 #include "comphelper/processfactory.hxx"
  33 #include "osl/file.hxx"
  34 #include "osl/diagnose.h"
  35 #include "rtl/bootstrap.hxx"
  36 #include "rtl/uri.hxx"
  37
  38 #include "tools/stream.hxx"
  39 #include "tools/urlobj.hxx"
  40 #include "implimagetree.hxx"
  41
  42 #include <vcl/bitmapex.hxx>
  43 #include <vcl/dibtools.hxx>
  44 #include <vcl/pngread.hxx>
  45 #include <vcl/settings.hxx>
  46 #include <vcl/svapp.hxx>
  47
  48 #include <vcl/BitmapTools.hxx>
  49 #include <vcl/pngwrite.hxx>
  50
  51 #include "BitmapProcessor.hxx"
  52
  53 bool ImageRequestParameters::convertToDarkTheme()
  54 {
  55     static bool bIconsForDarkTheme = !!getenv("VCL_ICONS_FOR_DARK_THEME");
  56
  57     bool bConvertToDarkTheme = false;
  58     if (!(meFlags & ImageLoadFlags::IgnoreDarkTheme))
  59         bConvertToDarkTheme = bIconsForDarkTheme;
  60
  61     return bConvertToDarkTheme;
  62 }
  63
  64 sal_Int32 ImageRequestParameters::scalePercentage()
  65 {
  66     sal_Int32 aScalePercentage = 100;
  67     if (!(meFlags & ImageLoadFlags::IgnoreScalingFactor))
  68         aScalePercentage = Application::GetDefaultDevice()->GetDPIScalePercentage();
  69     return aScalePercentage;
  70 }
  71
  72 namespace
  73 {
  74
  75 OUString convertLcTo32Path(OUString const & rPath)
  76 {
  77     OUString aResult;
  78     if (rPath.lastIndexOf('/') != -1)
  79     {
  80         sal_Int32 nCopyFrom = rPath.lastIndexOf('/') + 1;
  81         OUString sFile = rPath.copy(nCopyFrom);
  82         OUString sDir = rPath.copy(0, rPath.lastIndexOf('/'));
  83         if (!sFile.isEmpty() && sFile.startsWith("lc_"))
  84         {
  85             aResult = sDir + "/32/" + sFile.copy(3);
  86         }
  87     }
  88     return aResult;
  89 }
  90
  91 OUString createPath(OUString const & name, sal_Int32 pos, OUString const & locale)
  92 {
  93     return name.copy(0, pos + 1) + locale + name.copy(pos);
  94 }
  95
  96 OUString getIconThemeFolderUrl()
  97 {
  98     OUString sUrl("$BRAND_BASE_DIR/" LIBO_SHARE_FOLDER "/config/");
  99     rtl::Bootstrap::expandMacros(sUrl);
 100     return sUrl;
 101 }
 102
 103 OUString getIconCacheUrl(OUString const & sStyle, OUString const & sVariant, OUString const & sName)
 104 {
 105     OUString sUrl("${$BRAND_BASE_DIR/" LIBO_ETC_FOLDER "/" SAL_CONFIGFILE("bootstrap") ":UserInstallation}/cache/");
 106     sUrl += sStyle + "/" + sVariant + "/" + sName;
 107     rtl::Bootstrap::expandMacros(sUrl);
 108     return sUrl;
 109 }
 110
 111 OUString createIconCacheUrl(OUString const & sStyle, OUString const & sVariant, OUString const & sName)
 112 {
 113     OUString sUrl(getIconCacheUrl(sStyle, sVariant, sName));
 114     OUString sDir = sUrl.copy(0, sUrl.lastIndexOf('/'));
 115     osl::Directory::createPath(sDir);
 116     return sUrl;
 117 }
 118
 119 bool urlExists(OUString const & sUrl)
 120 {
 121     osl::File aFile(sUrl);
 122     osl::FileBase::RC eRC = aFile.open(osl_File_OpenFlag_Read);
 123     if (osl::FileBase::E_None == eRC)
 124         return true;
 125     return false;
 126 }
 127
 128 OUString getNameNoExtension(OUString const & sName)
 129 {
 130     sal_Int32 nDotPosition = sName.lastIndexOf('.');
 131     return sName.copy(0, nDotPosition);
 132 }
 133
 134 std::shared_ptr<SvStream> wrapStream(css::uno::Reference< css::io::XInputStream > const & stream)
 135 {
 136     // This could use SvInputStream instead if that did not have a broken
 137     // SeekPos implementation for an XInputStream that is not also XSeekable
 138     // (cf. "@@@" at tags/DEV300_m37/svtools/source/misc1/strmadpt.cxx@264807
 139     // l. 593):
 140     OSL_ASSERT(stream.is());
 141     std::shared_ptr<SvStream> s(std::make_shared<SvMemoryStream>());
 142     for (;;)
 143     {
 144         sal_Int32 const size = 2048;
 145         css::uno::Sequence< sal_Int8 > data(size);
 146         sal_Int32 n = stream->readBytes(data, size);
 147         s->WriteBytes(data.getConstArray(), n);
 148         if (n < size)
 149             break;
 150     }
 151     s->Seek(0);
 152     return s;
 153 }
 154
 155 void loadImageFromStream(std::shared_ptr<SvStream> const & xStream, OUString const & rPath, ImageRequestParameters& rParameters)
 156 {
 157     bool bConvertToDarkTheme = rParameters.convertToDarkTheme();
 158     sal_Int32 aScalePercentage = rParameters.scalePercentage();
 159
 160     if (rPath.endsWith(".png"))
 161     {
 162         vcl::PNGReader aPNGReader(*xStream);
 163         aPNGReader.SetIgnoreGammaChunk(true);
 164         rParameters.mrBitmap = aPNGReader.Read();
 165     }
 166     else if (rPath.endsWith(".svg"))
 167     {
 168         vcl::bitmap::loadFromSvg(*xStream.get(), rPath, rParameters.mrBitmap, aScalePercentage / 100.0);
 169         if (bConvertToDarkTheme)
 170             rParameters.mrBitmap = BitmapProcessor::createLightImage(rParameters.mrBitmap);
 171         return;
 172     }
 173     else
 174     {
 175         ReadDIBBitmapEx(rParameters.mrBitmap, *xStream);
 176     }
 177
 178     if (bConvertToDarkTheme)
 179         rParameters.mrBitmap = BitmapProcessor::createLightImage(rParameters.mrBitmap);
 180
 181     if (aScalePercentage > 100)
 182     {
 183         double aScaleFactor(aScalePercentage / 100.0);
 184         rParameters.mrBitmap.Scale(aScaleFactor, aScaleFactor, BmpScaleFlag::Fast);
 185     }
 186 }
 187
 188 } // end anonymous namespace
 189
 190 ImplImageTree::ImplImageTree()
 191 {
 192 }
 193
 194 ImplImageTree::~ImplImageTree()
 195 {
 196 }
 197
 198 std::vector<OUString> ImplImageTree::getPaths(OUString const & name, LanguageTag& rLanguageTag)
 199 {
 200     std::vector<OUString> sPaths;
 201
 202     sal_Int32 pos = name.lastIndexOf('/');
 203     if (pos != -1)
 204     {
 205         for (OUString& rFallback : rLanguageTag.getFallbackStrings(true))
 206         {
 207             OUString aFallbackName = getNameNoExtension(getRealImageName(createPath(name, pos, rFallback)));
 208             sPaths.push_back(aFallbackName + ".png");
 209             sPaths.push_back(aFallbackName + ".svg");
 210         }
 211     }
 212
 213     OUString aRealName = getNameNoExtension(getRealImageName(name));
 214     sPaths.push_back(aRealName + ".png");
 215     sPaths.push_back(aRealName + ".svg");
 216
 217     return sPaths;
 218 }
 219
 220 OUString ImplImageTree::getImageUrl(OUString const & rName, OUString const & rStyle, OUString const & rLang)
 221 {
 222     OUString aStyle(rStyle);
 223
 224     while (!aStyle.isEmpty())
 225     {
 226         try
 227         {
 228             setStyle(aStyle);
 229
 230             if (checkPathAccess())
 231             {
 232                 IconSet& rIconSet = getCurrentIconSet();
 233                 const css::uno::Reference<css::container::XNameAccess>& rNameAccess = rIconSet.maNameAccess;
 234
 235                 LanguageTag aLanguageTag(rLang);
 236
 237                 for (OUString& rPath: getPaths(rName, aLanguageTag))
 238                 {
 239                     if (rNameAccess->hasByName(rPath))
 240                     {
 241                         return "vnd.sun.star.zip://"
 242                             + rtl::Uri::encode(rIconSet.maURL, rtl_UriCharClassRegName,
 243                                                rtl_UriEncodeIgnoreEscapes, RTL_TEXTENCODING_UTF8)
 244                             + "/" + rPath;
 245                     }
 246                 }
 247             }
 248         }
 249         catch (const css::uno::Exception & e)
 250         {
 251             SAL_INFO("vcl", "exception " << e.Message);
 252         }
 253
 254         aStyle = fallbackStyle(aStyle);
 255     }
 256     return OUString();
 257 }
 258
 259 OUString ImplImageTree::fallbackStyle(const OUString& rsStyle)
 260 {
 261     OUString sResult;
 262
 263     if (rsStyle == "galaxy")
 264         sResult = "";
 265     else if (rsStyle == "industrial" || rsStyle == "tango" || rsStyle == "breeze")
 266         sResult = "galaxy";
 267     else if (rsStyle == "sifr" || rsStyle == "breeze_dark")
 268         sResult = "breeze";
 269     else
 270         sResult = "tango";
 271
 272     return sResult;
 273 }
 274
 275 bool ImplImageTree::loadImage(OUString const & name, OUString const & style, BitmapEx & rBitmap, bool localized, const ImageLoadFlags eFlags)
 276 {
 277     OUString aStyle(style);
 278     while (!aStyle.isEmpty())
 279     {
 280         try
 281         {
 282             ImageRequestParameters aParameters(name, aStyle, rBitmap, localized, eFlags);
 283             if (doLoadImage(aParameters))
 284                 return true;
 285         }
 286         catch (css::uno::RuntimeException &)
 287         {}
 288
 289         aStyle = fallbackStyle(aStyle);
 290     }
 291     return false;
 292 }
 293
 294 bool ImplImageTree::loadDefaultImage(OUString const & style, BitmapEx& bitmap, const ImageLoadFlags eFlags)
 295 {
 296     ImageRequestParameters aParameters("res/grafikde.png", style, bitmap, false, eFlags);
 297     return doLoadImage(aParameters);
 298 }
 299
 300 OUString createVariant(ImageRequestParameters& rParameters)
 301 {
 302     bool bConvertToDarkTheme = rParameters.convertToDarkTheme();
 303     sal_Int32 aScalePercentage = rParameters.scalePercentage();
 304
 305     OUString aVariant;
 306     if (aScalePercentage == 100 && !bConvertToDarkTheme)
 307         return aVariant;
 308
 309     aVariant = OUString::number(aScalePercentage);
 310
 311     if (bConvertToDarkTheme)
 312         aVariant += "-dark";
 313
 314     return aVariant;
 315 }
 316
 317 bool loadDiskCachedVersion(OUString const & sVariant, ImageRequestParameters& rParameters)
 318 {
 319     OUString sUrl(getIconCacheUrl(rParameters.msStyle, sVariant, rParameters.msName));
 320     if (!urlExists(sUrl))
 321         return false;
 322     SvFileStream aFileStream(sUrl, StreamMode::READ);
 323     vcl::PNGReader aPNGReader(aFileStream);
 324     aPNGReader.SetIgnoreGammaChunk( true );
 325     rParameters.mrBitmap = aPNGReader.Read();
 326     return true;
 327 }
 328
 329 void cacheBitmapToDisk(OUString const & sVariant, ImageRequestParameters& rParameters)
 330 {
 331     OUString sUrl(createIconCacheUrl(rParameters.msStyle, sVariant, rParameters.msName));
 332     vcl::PNGWriter aWriter(rParameters.mrBitmap);
 333     try
 334     {
 335         SvFileStream aStream(sUrl, StreamMode::WRITE);
 336         aWriter.Write(aStream);
 337         aStream.Close();
 338     }
 339     catch (...)
 340     {}
 341 }
 342
 343 bool ImplImageTree::doLoadImage(ImageRequestParameters& rParameters)
 344 {
 345     setStyle(rParameters.msStyle);
 346
 347     if (iconCacheLookup(rParameters))
 348         return true;
 349
 350     if (!rParameters.mrBitmap.IsEmpty())
 351         rParameters.mrBitmap.SetEmpty();
 352
 353     LanguageTag aLanguageTag = Application::GetSettings().GetUILanguageTag();
 354
 355     std::vector<OUString> paths = getPaths(rParameters.msName, aLanguageTag);
 356
 357     bool bFound = false;
 358
 359     try
 360     {
 361         bFound = findImage(paths, rParameters);
 362     }
 363     catch (css::uno::RuntimeException&)
 364     {
 365         throw;
 366     }
 367     catch (const css::uno::Exception& e)
 368     {
 369         SAL_INFO("vcl", "ImplImageTree::doLoadImage exception " << e.Message);
 370     }
 371
 372     if (bFound)
 373     {
 374         OUString aVariant = createVariant(rParameters);
 375         if (!aVariant.isEmpty())
 376             cacheBitmapToDisk(aVariant, rParameters);
 377         getCurrentIconSet().maIconCache[rParameters.msName] = std::make_pair(rParameters.mbLocalized, rParameters.mrBitmap);
 378     }
 379
 380     return bFound;
 381 }
 382
 383 void ImplImageTree::shutdown()
 384 {
 385     maCurrentStyle.clear();
 386     maIconSets.clear();
 387 }
 388
 389 void ImplImageTree::setStyle(OUString const & style)
 390 {
 391     assert(!style.isEmpty());
 392     if (style != maCurrentStyle)
 393     {
 394         maCurrentStyle = style;
 395         createStyle();
 396     }
 397 }
 398
 399 void ImplImageTree::createStyle()
 400 {
 401     if (maIconSets.find(maCurrentStyle) != maIconSets.end())
 402         return;
 403
 404     OUString sThemeUrl;
 405
 406     if (maCurrentStyle != "default")
 407     {
 408         INetURLObject aUrl(getIconThemeFolderUrl());
 409         OSL_ASSERT(!aUrl.HasError());
 410
 411         bool ok = aUrl.Append("images_" + maCurrentStyle, INetURLObject::EncodeMechanism::All);
 412         OSL_ASSERT(ok); (void) ok;
 413         sThemeUrl = aUrl.GetMainURL(INetURLObject::DecodeMechanism::NONE) + ".zip";
 414
 415     }
 416     else
 417         sThemeUrl += "images";
 418
 419     if (!urlExists(sThemeUrl))
 420         return;
 421
 422     maIconSets[maCurrentStyle] = IconSet(sThemeUrl);
 423
 424     loadImageLinks();
 425 }
 426
 427 bool ImplImageTree::iconCacheLookup(ImageRequestParameters& rParameters)
 428 {
 429     IconCache& rIconCache = getCurrentIconSet().maIconCache;
 430
 431     IconCache::iterator i(rIconCache.find(getRealImageName(rParameters.msName)));
 432     if (i != rIconCache.end() && i->second.first == rParameters.mbLocalized)
 433     {
 434         rParameters.mrBitmap = i->second.second;
 435         return true;
 436     }
 437
 438     OUString aVariant = createVariant(rParameters);
 439     if (!aVariant.isEmpty() && loadDiskCachedVersion(aVariant, rParameters))
 440         return true;
 441
 442     return false;
 443 }
 444
 445 bool ImplImageTree::findImage(std::vector<OUString> const & paths, ImageRequestParameters& rParameters)
 446 {
 447     if (!checkPathAccess())
 448         return false;
 449
 450     const css::uno::Reference<css::container::XNameAccess>& rNameAccess = getCurrentIconSet().maNameAccess;
 451
 452     for (const OUString& rPath : paths)
 453     {
 454         if (rNameAccess->hasByName(rPath))
 455         {
 456             css::uno::Reference<css::io::XInputStream> aStream;
 457             bool ok = rNameAccess->getByName(rPath) >>= aStream;
 458             assert(ok);
 459             (void)ok; // prevent unused warning in release build
 460
 461             loadImageFromStream(wrapStream(aStream), rPath, rParameters);
 462             return true;
 463         }
 464     }
 465     return false;
 466 }
 467
 468 void ImplImageTree::loadImageLinks()
 469 {
 470     const OUString aLinkFilename("links.txt");
 471
 472     if (!checkPathAccess())
 473         return;
 474
 475     const css::uno::Reference<css::container::XNameAccess> &rNameAccess = getCurrentIconSet().maNameAccess;
 476
 477     if (rNameAccess->hasByName(aLinkFilename))
 478     {
 479         css::uno::Reference< css::io::XInputStream > s;
 480         bool ok = rNameAccess->getByName(aLinkFilename) >>= s;
 481         assert(ok);
 482         (void)ok; // prevent unused warning in release build
 483
 484         parseLinkFile( wrapStream(s) );
 485         return;
 486     }
 487 }
 488
 489 void ImplImageTree::parseLinkFile(std::shared_ptr<SvStream> const & xStream)
 490 {
 491     OString aLine;
 492     OUString aLink, aOriginal;
 493     int nLineNo = 0;
 494     while (xStream->ReadLine(aLine))
 495     {
 496         ++nLineNo;
 497         if ( aLine.isEmpty() )
 498             continue;
 499
 500         sal_Int32 nIndex = 0;
 501         aLink = OStringToOUString( aLine.getToken(0, ' ', nIndex), RTL_TEXTENCODING_UTF8 );
 502         aOriginal = OStringToOUString( aLine.getToken(0, ' ', nIndex), RTL_TEXTENCODING_UTF8 );
 503
 504         // skip comments, or incomplete entries
 505         if (aLink.isEmpty() || aLink[0] == '#' || aOriginal.isEmpty())
 506         {
 507             if (aLink.isEmpty() || aOriginal.isEmpty())
 508                 SAL_WARN("vcl", "ImplImageTree::parseLinkFile: icon links.txt parse error, incomplete link at line " << nLineNo);
 509             continue;
 510         }
 511
 512         getCurrentIconSet().maLinkHash[aLink] = aOriginal;
 513
 514         OUString aOriginal32 = convertLcTo32Path(aOriginal);
 515         OUString aLink32 = convertLcTo32Path(aLink);
 516
 517         if (!aOriginal32.isEmpty() && !aLink32.isEmpty())
 518             getCurrentIconSet().maLinkHash[aLink32] = aOriginal32;
 519     }
 520 }
 521
 522 OUString const & ImplImageTree::getRealImageName(OUString const & name)
 523 {
 524     IconLinkHash &rLinkHash = maIconSets[maCurrentStyle].maLinkHash;
 525
 526     IconLinkHash::iterator it(rLinkHash.find(name));
 527     if (it == rLinkHash.end())
 528         return name;
 529
 530     return it->second;
 531 }
 532
 533 bool ImplImageTree::checkPathAccess()
 534 {
 535     IconSet& rIconSet = getCurrentIconSet();
 536     css::uno::Reference<css::container::XNameAccess> &rNameAccess = rIconSet.maNameAccess;
 537     if (rNameAccess.is())
 538         return true;
 539
 540     try
 541     {
 542         rNameAccess = css::packages::zip::ZipFileAccess::createWithURL(comphelper::getProcessComponentContext(), rIconSet.maURL);
 543     }
 544     catch (const css::uno::RuntimeException &) {
 545         throw;
 546     }
 547     catch (const css::uno::Exception & e) {
 548         SAL_INFO("vcl", "ImplImageTree::zip file location exception " << e.Message << " for " << rIconSet.maURL);
 549         return false;
 550     }
 551     return rNameAccess.is();
 552 }
 553
 554 css::uno::Reference<css::container::XNameAccess> ImplImageTree::getNameAccess()
 555 {
 556     checkPathAccess();
 557     return getCurrentIconSet().maNameAccess;
 558 }
 559
 560 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */