vcl/source/app/svdata.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 <string.h>
  21
  22 #include <comphelper/lok.hxx>
  23 #include <comphelper/processfactory.hxx>
  24 #include <comphelper/diagnose_ex.hxx>
  25 #include <o3tl/string_view.hxx>
  26 #include <unotools/resmgr.hxx>
  27 #include <sal/log.hxx>
  28
  29 #include <configsettings.hxx>
  30 #include <vcl/QueueInfo.hxx>
  31 #include <vcl/cvtgrf.hxx>
  32 #include <vcl/dockwin.hxx>
  33 #include <vcl/fieldvalues.hxx>
  34 #include <vcl/menu.hxx>
  35 #include <vcl/print.hxx>
  36 #include <vcl/settings.hxx>
  37 #include <vcl/svapp.hxx>
  38 #include <vcl/virdev.hxx>
  39 #include <vcl/wrkwin.hxx>
  40 #include <vcl/uitest/logger.hxx>
  41 #include <salframe.hxx>
  42 #include <scrwnd.hxx>
  43 #include <helpwin.hxx>
  44 #include <vcl/toolkit/dialog.hxx>
  45 #include <salinst.hxx>
  46 #include <salgdi.hxx>
  47 #include <svdata.hxx>
  48 #include <salsys.hxx>
  49 #include <windowdev.hxx>
  50 #include <units.hrc>
  51 #include <print.h>
  52
  53 #include <config_features.h>
  54 #include <basegfx/utils/systemdependentdata.hxx>
  55 #include <mutex>
  56
  57 using namespace com::sun::star::uno;
  58
  59 namespace
  60 {
  61     struct private_aImplSVData :
  62         public rtl::Static<ImplSVData, private_aImplSVData> {};
  63     /// Default instance ensures that ImplSVData::mpHelpData is never null.
  64     struct private_aImplSVHelpData :
  65         public rtl::Static<ImplSVHelpData, private_aImplSVHelpData> {};
  66
  67     /// Default instance ensures that ImplSVData::mpWinData is never null.
  68     struct private_aImplSVWinData :
  69         public rtl::Static<ImplSVWinData, private_aImplSVWinData> {};
  70
  71 }
  72
  73 ImplSVData* ImplGetSVData() {
  74     return &private_aImplSVData::get();
  75 }
  76
  77 SalSystem* ImplGetSalSystem()
  78 {
  79     ImplSVData* pSVData = ImplGetSVData();
  80     if( ! pSVData->mpSalSystem )
  81         pSVData->mpSalSystem.reset( pSVData->mpDefInst->CreateSalSystem() );
  82     return pSVData->mpSalSystem.get();
  83 }
  84
  85 void ImplDeInitSVData()
  86 {
  87     ImplSVData* pSVData = ImplGetSVData();
  88
  89     // delete global instance data
  90     pSVData->mpSettingsConfigItem.reset();
  91
  92     pSVData->mpDockingManager.reset();
  93
  94     pSVData->maCtrlData.maFieldUnitStrings.clear();
  95     pSVData->maCtrlData.maCleanUnitStrings.clear();
  96     pSVData->maPaperNames.clear();
  97 }
  98
  99 namespace
 100 {
 101     typedef ::std::unordered_map< basegfx::SystemDependentData_SharedPtr, sal_uInt32 > EntryMap;
 102
 103     class SystemDependentDataBuffer final : public basegfx::SystemDependentDataManager
 104     {
 105     private:
 106         std::mutex m_aMutex;
 107         std::unique_ptr<AutoTimer> maTimer;
 108         EntryMap maEntries;
 109
 110         DECL_LINK(implTimeoutHdl, Timer *, void);
 111
 112     public:
 113         SystemDependentDataBuffer(const char* pDebugName)
 114         :   maTimer(std::make_unique<AutoTimer>(pDebugName))
 115         {
 116             maTimer->SetTimeout(1000);
 117             maTimer->SetInvokeHandler(LINK(this, SystemDependentDataBuffer, implTimeoutHdl));
 118         }
 119
 120         virtual ~SystemDependentDataBuffer() override
 121         {
 122             flushAll();
 123         }
 124
 125         void startUsage(basegfx::SystemDependentData_SharedPtr& rData) override
 126         {
 127             std::unique_lock aGuard(m_aMutex);
 128             EntryMap::iterator aFound(maEntries.find(rData));
 129
 130             if(aFound == maEntries.end())
 131             {
 132                 if(maTimer && !maTimer->IsActive())
 133                 {
 134                     maTimer->Start();
 135                 }
 136
 137                 maEntries[rData] = rData->calculateCombinedHoldCyclesInSeconds();
 138             }
 139         }
 140
 141         void endUsage(basegfx::SystemDependentData_SharedPtr& rData) override
 142         {
 143             // tdf#163428 prepare space for entry to hold to avoid early deletion
 144             basegfx::SystemDependentData_SharedPtr aToBeDeletedEntry;
 145
 146             {
 147                 // lock m_aMutex in own scope
 148                 std::unique_lock aGuard(m_aMutex);
 149                 EntryMap::iterator aFound(maEntries.find(rData));
 150
 151                 if(aFound != maEntries.end())
 152                 {
 153                     // tdf#163428 ensure to hold/not delete entry while m_aMutex is locked
 154                     aToBeDeletedEntry = aFound->first;
 155
 156                     // remove from list
 157                     maEntries.erase(aFound);
 158                 }
 159             }
 160
 161             // tdf#163428  aToBeDeletedEntry will be destructed, thus the
 162             // entry referenced by SharedPtr may be deleted now
 163         }
 164
 165         void touchUsage(basegfx::SystemDependentData_SharedPtr& rData) override
 166         {
 167             std::unique_lock aGuard(m_aMutex);
 168             EntryMap::iterator aFound(maEntries.find(rData));
 169
 170             if(aFound != maEntries.end())
 171             {
 172                 aFound->second = rData->calculateCombinedHoldCyclesInSeconds();
 173             }
 174         }
 175
 176         void flushAll() override
 177         {
 178             std::unique_lock aGuard(m_aMutex);
 179
 180             if(maTimer)
 181             {
 182                 maTimer->Stop();
 183                 maTimer.reset();
 184             }
 185
 186             maEntries.clear();
 187         }
 188     };
 189
 190     IMPL_LINK_NOARG(SystemDependentDataBuffer, implTimeoutHdl, Timer *, void)
 191     {
 192         // tdf#163428 prepare a temporary list for SystemDependentData_SharedPtr
 193         // entries that need to be removed from the unordered_map, but do not need
 194         // locking m_aMutex
 195         ::std::vector<basegfx::SystemDependentData_SharedPtr> aToBeDeletedEntries;
 196
 197         {
 198             // lock m_aMutex in own scope
 199             std::unique_lock aGuard(m_aMutex);
 200             EntryMap::iterator aIter(maEntries.begin());
 201
 202             while(aIter != maEntries.end())
 203             {
 204                 if(aIter->second)
 205                 {
 206                     aIter->second--;
 207                     ++aIter;
 208                 }
 209                 else
 210                 {
 211                     // tdf#163428 Do not potentially directly delete SystemDependentData_SharedPtr
 212                     // entries in the unordered_map (maEntries). That can/would happen when the shared_ptr
 213                     // has only one reference left. This can cause problems, e.g. we have
 214                     // BufferedData_ModifiedBitmapEx which can contain a Bitmap with added
 215                     // DataBuffers itself, thus deleting this here *directly* would trigger e.g.
 216                     // endUsage above. That would then block when we would still hold m_aMutex.
 217                     // This can potentially be the case with other derivations of
 218                     // basegfx::SystemDependentData, too.
 219                     // To avoid this, protect the part that needs protection by the m_aMutex, that
 220                     // is the modification of the unordered_map itself. Cleaning up the list entries can be
 221                     // done after this, without holding the lock.
 222                     // Thus, remember the SystemDependentData_SharedPtr in a temporary list by adding
 223                     // a reference/shared_ptr to it to guarantee it gets not deleted when it gets removed
 224                     // from the unordered_map.
 225                     // Anyways, only locking while manipulating the list is better, destruction of
 226                     // objects may be expensive and hold m_aMutex longer than necessary.
 227                     aToBeDeletedEntries.push_back(aIter->first);
 228
 229                     // remove from list. This decrements the shared_ptr, but delete is avoided
 230                     aIter = maEntries.erase(aIter);
 231                 }
 232             }
 233
 234             if (maEntries.empty())
 235                 maTimer->Stop();
 236         }
 237
 238         // tdf#163428 here aToBeDeletedEntries will be destroyed, the entries will be
 239         // decremented and potentially deleted. These are of type SystemDependentData_SharedPtr,
 240         // so we do not need to do anything explicitly here
 241     }
 242 }
 243
 244 basegfx::SystemDependentDataManager& ImplGetSystemDependentDataManager()
 245 {
 246     static SystemDependentDataBuffer aSystemDependentDataBuffer("vcl SystemDependentDataBuffer aSystemDependentDataBuffer");
 247
 248     return aSystemDependentDataBuffer;
 249 }
 250
 251 /// Returns either the application window, or the default GL context window
 252 vcl::Window* ImplGetDefaultWindow()
 253 {
 254     ImplSVData* pSVData = ImplGetSVData();
 255     if (pSVData->maFrameData.mpAppWin)
 256         return pSVData->maFrameData.mpAppWin;
 257     else
 258         return ImplGetDefaultContextWindow();
 259 }
 260
 261 /// returns the default window created to hold the persistent VCL GL context.
 262 vcl::Window *ImplGetDefaultContextWindow()
 263 {
 264     ImplSVData* pSVData = ImplGetSVData();
 265
 266     // Double check locking on mpDefaultWin.
 267     if ( !pSVData->mpDefaultWin )
 268     {
 269         SolarMutexGuard aGuard;
 270
 271         if (!pSVData->mpDefaultWin && !pSVData->mbDeInit)
 272         {
 273             try
 274             {
 275                 SAL_INFO( "vcl", "ImplGetDefaultWindow(): No AppWindow" );
 276
 277                 pSVData->mpDefaultWin = VclPtr<WorkWindow>::Create(nullptr, WB_DEFAULTWIN);
 278                 pSVData->mpDefaultWin->SetText( u"VCL ImplGetDefaultWindow"_ustr );
 279             }
 280             catch (const css::uno::Exception&)
 281             {
 282                 TOOLS_WARN_EXCEPTION("vcl", "unable to create Default Window");
 283             }
 284         }
 285     }
 286
 287     return pSVData->mpDefaultWin;
 288 }
 289
 290 const std::locale& ImplGetResLocale()
 291 {
 292     ImplSVData* pSVData = ImplGetSVData();
 293     if (!pSVData->mbResLocaleSet || comphelper::LibreOfficeKit::isActive())
 294     {
 295         pSVData->maResLocale = Translate::Create("vcl");
 296         pSVData->mbResLocaleSet = true;
 297     }
 298     return pSVData->maResLocale;
 299 }
 300
 301 OUString VclResId(TranslateId aId)
 302 {
 303     return Translate::get(aId, ImplGetResLocale());
 304 }
 305
 306 const FieldUnitStringList& ImplGetFieldUnits()
 307 {
 308     ImplSVData* pSVData = ImplGetSVData();
 309     if( pSVData->maCtrlData.maFieldUnitStrings.empty() )
 310     {
 311         sal_uInt32 nUnits = std::size(SV_FUNIT_STRINGS);
 312         pSVData->maCtrlData.maFieldUnitStrings.reserve( nUnits );
 313         for (sal_uInt32 i = 0; i < nUnits; i++)
 314         {
 315             std::pair<OUString, FieldUnit> aElement(VclResId(SV_FUNIT_STRINGS[i].first), SV_FUNIT_STRINGS[i].second);
 316             pSVData->maCtrlData.maFieldUnitStrings.push_back( aElement );
 317         }
 318     }
 319     return pSVData->maCtrlData.maFieldUnitStrings;
 320 }
 321
 322 namespace vcl
 323 {
 324     FieldUnit EnglishStringToMetric(std::u16string_view rEnglishMetricString)
 325     {
 326         sal_uInt32 nUnits = std::size(SV_FUNIT_STRINGS);
 327         for (sal_uInt32 i = 0; i < nUnits; ++i)
 328         {
 329             if (o3tl::equalsAscii(rEnglishMetricString, SV_FUNIT_STRINGS[i].first.getId()))
 330                 return SV_FUNIT_STRINGS[i].second;
 331         }
 332         return FieldUnit::NONE;
 333     }
 334 }
 335
 336 const FieldUnitStringList& ImplGetCleanedFieldUnits()
 337 {
 338     ImplSVData* pSVData = ImplGetSVData();
 339     if( pSVData->maCtrlData.maCleanUnitStrings.empty() )
 340     {
 341         const FieldUnitStringList& rUnits = ImplGetFieldUnits();
 342         size_t nUnits = rUnits.size();
 343         pSVData->maCtrlData.maCleanUnitStrings.reserve(nUnits);
 344         for (size_t i = 0; i < nUnits; ++i)
 345         {
 346             OUString aUnit(rUnits[i].first);
 347             aUnit = aUnit.replaceAll(" ", "");
 348             aUnit = aUnit.toAsciiLowerCase();
 349             std::pair<OUString, FieldUnit> aElement(aUnit, rUnits[i].second);
 350             pSVData->maCtrlData.maCleanUnitStrings.push_back(aElement);
 351         }
 352     }
 353     return pSVData->maCtrlData.maCleanUnitStrings;
 354 }
 355
 356 DockingManager* ImplGetDockingManager()
 357 {
 358     ImplSVData* pSVData = ImplGetSVData();
 359     if ( !pSVData->mpDockingManager )
 360         pSVData->mpDockingManager.reset(new DockingManager());
 361
 362     return pSVData->mpDockingManager.get();
 363 }
 364
 365 BlendFrameCache* ImplGetBlendFrameCache()
 366 {
 367     ImplSVData* pSVData = ImplGetSVData();
 368     if ( !pSVData->mpBlendFrameCache)
 369         pSVData->mpBlendFrameCache.reset( new BlendFrameCache() );
 370
 371     return pSVData->mpBlendFrameCache.get();
 372 }
 373
 374 void LocaleConfigurationListener::ConfigurationChanged( utl::ConfigurationBroadcaster*, ConfigurationHints nHint )
 375 {
 376     AllSettings::LocaleSettingsChanged( nHint );
 377 }
 378
 379 ImplSVWinData* CreateSVWinData()
 380 {
 381     if (!comphelper::LibreOfficeKit::isActive())
 382         return nullptr;
 383
 384     ImplSVWinData* p = new ImplSVWinData;
 385
 386     ImplSVData* pSVData = ImplGetSVData();
 387     assert(pSVData && pSVData->mpWinData);
 388
 389     p->mpFocusWin = pSVData->mpWinData->mpFocusWin;
 390     return p;
 391 }
 392
 393 void DestroySVWinData(ImplSVWinData* pData)
 394 {
 395     delete pData;
 396 }
 397
 398 void SetSVWinData(ImplSVWinData* pSVWinData)
 399 {
 400     if (!comphelper::LibreOfficeKit::isActive())
 401         return;
 402
 403     ImplSVData* pSVData = ImplGetSVData();
 404     assert(pSVData != nullptr);
 405
 406     if (pSVData->mpWinData == pSVWinData)
 407         return;
 408
 409     // If current one is the static, clean it up to avoid having lingering references.
 410     if (pSVData->mpWinData == &private_aImplSVWinData::get())
 411     {
 412         pSVData->mpWinData->mpFocusWin.reset();
 413     }
 414
 415     pSVData->mpWinData = pSVWinData;
 416     if (pSVData->mpWinData == nullptr)
 417     {
 418         pSVData->mpWinData = &private_aImplSVWinData::get(); // Never leave it null.
 419     }
 420 }
 421
 422 ImplSVData::ImplSVData()
 423 {
 424     mpHelpData = &private_aImplSVHelpData::get();
 425     mpWinData = &private_aImplSVWinData::get();
 426 }
 427
 428 void ImplSVData::dropCaches()
 429 {
 430     // we are iterating over a map and doing erase while inside a loop which is doing erase
 431     // hence we can't use clear() here
 432     maGDIData.maScaleCache.remove_if([](const lru_scale_cache::key_value_pair_t&)
 433                                                 { return true; });
 434
 435     maGDIData.maThemeDrawCommandsCache.clear();
 436     maGDIData.maThemeImageCache.clear();
 437 }
 438
 439 void ImplSVData::dumpState(rtl::OStringBuffer &rState)
 440 {
 441     rState.append("\nScaleCache:\t");
 442     rState.append(static_cast<sal_Int32>(maGDIData.maScaleCache.size()));
 443     rState.append("\t items:");
 444
 445     for (auto it = maGDIData.maScaleCache.begin();
 446          it != maGDIData.maScaleCache.end(); ++it)
 447     {
 448         rState.append("\n\t");
 449         rState.append(static_cast<sal_Int32>(it->first.maDestSize.Width()));
 450         rState.append("x");
 451         rState.append(static_cast<sal_Int32>(it->first.maDestSize.Height()));
 452     }
 453 }
 454
 455 ImplSVHelpData* CreateSVHelpData()
 456 {
 457     if (!comphelper::LibreOfficeKit::isActive())
 458         return nullptr;
 459
 460     ImplSVHelpData* pNewData = new ImplSVHelpData;
 461
 462     // Set options set globally
 463     ImplSVHelpData& aStaticHelpData = private_aImplSVHelpData::get();
 464     pNewData->mbContextHelp = aStaticHelpData.mbContextHelp;
 465     pNewData->mbExtHelp = aStaticHelpData.mbExtHelp;
 466     pNewData->mbExtHelpMode = aStaticHelpData.mbExtHelpMode;
 467     pNewData->mbOldBalloonMode = aStaticHelpData.mbOldBalloonMode;
 468     pNewData->mbBalloonHelp = aStaticHelpData.mbBalloonHelp;
 469     pNewData->mbQuickHelp = aStaticHelpData.mbQuickHelp;
 470
 471     return pNewData;
 472 }
 473
 474 void DestroySVHelpData(ImplSVHelpData* pSVHelpData)
 475 {
 476     if (!comphelper::LibreOfficeKit::isActive())
 477         return;
 478
 479     // Change the SVData's help date if necessary
 480     if(ImplGetSVData()->mpHelpData == pSVHelpData)
 481     {
 482         ImplGetSVData()->mpHelpData = &private_aImplSVHelpData::get();
 483     }
 484
 485     if(pSVHelpData)
 486     {
 487         ImplDestroyHelpWindow(*pSVHelpData, false);
 488         delete pSVHelpData;
 489     }
 490 }
 491
 492 void SetSVHelpData(ImplSVHelpData* pSVHelpData)
 493 {
 494     if (!comphelper::LibreOfficeKit::isActive())
 495         return;
 496
 497     ImplSVData* pSVData = ImplGetSVData();
 498     if (pSVData->mpHelpData == pSVHelpData)
 499         return;
 500
 501     // If current one is the static, clean it up to avoid having lingering references.
 502     if (pSVData->mpHelpData == &private_aImplSVHelpData::get())
 503     {
 504         pSVData->mpHelpData->mpHelpWin.reset();
 505     }
 506
 507     pSVData->mpHelpData = pSVHelpData;
 508     if (pSVData->mpHelpData == nullptr)
 509     {
 510         pSVData->mpHelpData = &private_aImplSVHelpData::get(); // Never leave it null.
 511     }
 512 }
 513
 514 ImplSVHelpData& ImplGetSVHelpData()
 515 {
 516     ImplSVData* pSVData = ImplGetSVData();
 517     if(pSVData->mpHelpData)
 518     {
 519         return *pSVData->mpHelpData;
 520     }
 521     else
 522     {
 523         return private_aImplSVHelpData::get();
 524     }
 525 }
 526
 527 ImplSVData::~ImplSVData() {}
 528
 529 ImplSVAppData::ImplSVAppData()
 530 {
 531     m_bUseSystemLoop = getenv("SAL_USE_SYSTEM_LOOP") != nullptr;
 532     SAL_WARN_IF(m_bUseSystemLoop, "vcl.schedule", "Overriding to run LO on system event loop!");
 533 }
 534
 535 ImplSVAppData::~ImplSVAppData() {}
 536 ImplSVGDIData::~ImplSVGDIData() {}
 537 ImplSVFrameData::~ImplSVFrameData() {}
 538 ImplSVWinData::~ImplSVWinData() {}
 539 ImplSVHelpData::~ImplSVHelpData() {}
 540
 541 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */