framework/source/fwe/helper/titlehelper.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 <framework/titlehelper.hxx>
  21 #include <classes/fwkresid.hxx>
  22 #include <strings.hrc>
  23 #include <properties.h>
  24
  25 #include <com/sun/star/frame/UntitledNumbersConst.hpp>
  26 #include <com/sun/star/frame/XStorable.hpp>
  27 #include <com/sun/star/frame/ModuleManager.hpp>
  28 #include <com/sun/star/frame/XUntitledNumbers.hpp>
  29 #include <com/sun/star/frame/XModel3.hpp>
  30 #include <com/sun/star/document/XDocumentEventBroadcaster.hpp>
  31
  32 #include <comphelper/configuration.hxx>
  33 #include <unotools/configmgr.hxx>
  34 #include <unotools/bootstrap.hxx>
  35 #include <unotools/mediadescriptor.hxx>
  36 #include <comphelper/sequenceashashmap.hxx>
  37 #include <rtl/ustrbuf.hxx>
  38 #include <osl/mutex.hxx>
  39 #include <tools/urlobj.hxx>
  40 #include <utility>
  41 #include <vcl/svapp.hxx>
  42
  43
  44 using namespace css;
  45 using namespace css::uno;
  46 using namespace css::frame;
  47
  48 namespace framework{
  49
  50 TitleHelper::TitleHelper(css::uno::Reference< css::uno::XComponentContext > xContext,
  51                         const css::uno::Reference< css::uno::XInterface >& xOwner,
  52                         const css::uno::Reference< css::frame::XUntitledNumbers >& xNumbers)
  53     :
  54       m_xContext        (std::move(xContext))
  55     , m_xOwner          (xOwner)
  56     , m_xUntitledNumbers(xNumbers)
  57     , m_bExternalTitle  (false)
  58     , m_nLeasedNumber   (css::frame::UntitledNumbersConst::INVALID_NUMBER)
  59 {
  60     if (css::uno::Reference<css::frame::XModel> xModel{ xOwner, css::uno::UNO_QUERY })
  61     {
  62         impl_startListeningForModel (xModel);
  63     }
  64     else if (css::uno::Reference<css::frame::XController> xController{ xOwner,
  65                                                                        css::uno::UNO_QUERY })
  66     {
  67         impl_startListeningForController (xController);
  68     }
  69     else if (css::uno::Reference<css::frame::XFrame> xFrame{ xOwner, css::uno::UNO_QUERY })
  70     {
  71         impl_startListeningForFrame (xFrame);
  72     }
  73 }
  74
  75 TitleHelper::~TitleHelper()
  76 {
  77 }
  78
  79 OUString SAL_CALL TitleHelper::getTitle()
  80 {
  81     // SYNCHRONIZED ->
  82     std::unique_lock aLock(m_aMutex);
  83
  84     // An external title will win always and disable all internal logic about
  85     // creating/using a title value.
  86     // Even an empty string will be accepted as valid title !
  87     if (m_bExternalTitle)
  88         return m_sTitle;
  89
  90     // Title seems to be up-to-date. Return it directly.
  91     if (!m_sTitle.isEmpty())
  92         return m_sTitle;
  93
  94     // Title seems to be unused till now ... do bootstrapping
  95     aLock.unlock();
  96     impl_updateTitle (true);
  97     aLock.lock();
  98
  99     return m_sTitle;
 100     // <- SYNCHRONIZED
 101 }
 102
 103 void SAL_CALL TitleHelper::setTitle(const OUString& sTitle)
 104 {
 105     // SYNCHRONIZED ->
 106     {
 107         std::unique_lock aLock(m_aMutex);
 108
 109         m_bExternalTitle = true;
 110         m_sTitle         = sTitle;
 111     }
 112     // <- SYNCHRONIZED
 113
 114     impl_sendTitleChangedEvent ();
 115 }
 116
 117 void SAL_CALL TitleHelper::addTitleChangeListener(const css::uno::Reference< css::frame::XTitleChangeListener >& xListener)
 118 {
 119     std::unique_lock aLock(m_aMutex);
 120     m_aTitleChangeListeners.addInterface( aLock, xListener );
 121 }
 122
 123 void SAL_CALL TitleHelper::removeTitleChangeListener(const css::uno::Reference< css::frame::XTitleChangeListener >& xListener)
 124 {
 125     std::unique_lock aLock(m_aMutex);
 126     m_aTitleChangeListeners.removeInterface( aLock, xListener );
 127 }
 128
 129 void SAL_CALL TitleHelper::titleChanged(const css::frame::TitleChangedEvent& aEvent)
 130 {
 131     css::uno::Reference< css::frame::XTitle > xSubTitle;
 132     // SYNCHRONIZED ->
 133     {
 134         std::unique_lock aLock(m_aMutex);
 135
 136         xSubTitle = m_xSubTitle;
 137     }
 138     // <- SYNCHRONIZED
 139
 140     if (aEvent.Source != xSubTitle)
 141         return;
 142
 143     impl_updateTitle ();
 144 }
 145
 146 void SAL_CALL TitleHelper::documentEventOccured(const css::document::DocumentEvent& aEvent)
 147 {
 148     if ( ! aEvent.EventName.equalsIgnoreAsciiCase("OnSaveAsDone")
 149       && ! aEvent.EventName.equalsIgnoreAsciiCase("OnModeChanged")
 150       && ! aEvent.EventName.equalsIgnoreAsciiCase("OnTitleChanged"))
 151         return;
 152
 153     css::uno::Reference< css::frame::XModel > xOwner;
 154     // SYNCHRONIZED ->
 155     {
 156         std::unique_lock aLock(m_aMutex);
 157
 158         xOwner.set(m_xOwner, css::uno::UNO_QUERY);
 159     }
 160     // <- SYNCHRONIZED
 161
 162     if (aEvent.Source != xOwner
 163         || ((aEvent.EventName.equalsIgnoreAsciiCase("OnModeChanged")
 164              || aEvent.EventName.equalsIgnoreAsciiCase("OnTitleChanged"))
 165             && !xOwner.is()))
 166     {
 167         return;
 168     }
 169
 170     impl_updateTitle ();
 171 }
 172
 173 void SAL_CALL TitleHelper::frameAction(const css::frame::FrameActionEvent& aEvent)
 174 {
 175     css::uno::Reference< css::frame::XFrame > xOwner;
 176     // SYNCHRONIZED ->
 177     {
 178         std::unique_lock aLock(m_aMutex);
 179
 180         xOwner.set(m_xOwner, css::uno::UNO_QUERY);
 181     }
 182     // <- SYNCHRONIZED
 183
 184     if (aEvent.Source != xOwner)
 185         return;
 186
 187     // we are interested on events only, which must trigger a title bar update
 188     // because component was changed.
 189     if (
 190         (aEvent.Action == css::frame::FrameAction_COMPONENT_ATTACHED  ) ||
 191         (aEvent.Action == css::frame::FrameAction_COMPONENT_REATTACHED) ||
 192         (aEvent.Action == css::frame::FrameAction_COMPONENT_DETACHING )
 193        )
 194     {
 195         impl_updateListeningForFrame (xOwner);
 196         impl_updateTitle ();
 197     }
 198 }
 199
 200 void SAL_CALL TitleHelper::disposing(const css::lang::EventObject& aEvent)
 201 {
 202     css::uno::Reference< css::uno::XInterface >         xOwner;
 203     css::uno::Reference< css::frame::XUntitledNumbers > xNumbers;
 204     ::sal_Int32                                         nLeasedNumber;
 205     // SYNCHRONIZED ->
 206     {
 207         std::unique_lock aLock(m_aMutex);
 208
 209         xOwner = m_xOwner;
 210         xNumbers = m_xUntitledNumbers;
 211         nLeasedNumber = m_nLeasedNumber;
 212     }
 213     // <- SYNCHRONIZED
 214
 215     if ( ! xOwner.is ())
 216         return;
 217
 218     css::uno::Reference< css::frame::XFrame > xFrame(xOwner, css::uno::UNO_QUERY);
 219     if (xFrame.is())
 220         xFrame->removeFrameActionListener(this);
 221
 222     if (xOwner != aEvent.Source)
 223         return;
 224
 225     if (
 226         (xNumbers.is ()                                                   ) &&
 227         (nLeasedNumber != css::frame::UntitledNumbersConst::INVALID_NUMBER)
 228        )
 229        xNumbers->releaseNumber (nLeasedNumber);
 230
 231     // SYNCHRONIZED ->
 232     {
 233         std::unique_lock aLock(m_aMutex);
 234
 235         m_xOwner.clear();
 236         m_sTitle.clear();
 237         m_nLeasedNumber = css::frame::UntitledNumbersConst::INVALID_NUMBER;
 238     }
 239     // <- SYNCHRONIZED
 240 }
 241
 242 void TitleHelper::impl_sendTitleChangedEvent ()
 243 {
 244     css::uno::Reference<css::uno::XInterface> xOwner;
 245     OUString sTitle;
 246     // SYNCHRONIZED ->
 247     {
 248         std::unique_lock aLock(m_aMutex);
 249
 250         xOwner = m_xOwner;
 251
 252         sTitle = m_sTitle;
 253     }
 254     // <- SYNCHRONIZED
 255
 256     css::frame::TitleChangedEvent aEvent(xOwner, sTitle);
 257
 258     if( ! aEvent.Source.is() )
 259         return;
 260
 261     std::unique_lock aLock(m_aMutex);
 262     comphelper::OInterfaceIteratorHelper4 pIt( aLock, m_aTitleChangeListeners );
 263     while ( pIt.hasMoreElements() )
 264     {
 265         aLock.unlock();
 266         try
 267         {
 268             uno::Reference<css::frame::XTitleChangeListener> i = pIt.next();
 269             i->titleChanged( aEvent );
 270         }
 271         catch(const css::uno::Exception&)
 272         {
 273             aLock.lock();
 274             pIt.remove(aLock);
 275             aLock.unlock();
 276         }
 277         aLock.lock();
 278     }
 279 }
 280
 281 void TitleHelper::impl_updateTitle (bool init)
 282 {
 283     css::uno::Reference<css::uno::XInterface> xOwner;
 284
 285     // SYNCHRONIZED ->
 286     {
 287         std::unique_lock aLock(m_aMutex);
 288
 289         xOwner = m_xOwner;
 290     }
 291     // <- SYNCHRONIZED
 292
 293     if (css::uno::Reference<css::frame::XModel3> xModel{ xOwner, css::uno::UNO_QUERY })
 294     {
 295         impl_updateTitleForModel (xModel, init);
 296     }
 297     else if (css::uno::Reference<css::frame::XController> xController{ xOwner,
 298                                                                        css::uno::UNO_QUERY })
 299     {
 300         impl_updateTitleForController (xController, init);
 301     }
 302     else if (css::uno::Reference<css::frame::XFrame> xFrame{ xOwner, css::uno::UNO_QUERY })
 303     {
 304         impl_updateTitleForFrame (xFrame, init);
 305     }
 306 }
 307
 308 static OUString getURLFromModel(const css::uno::Reference< css::frame::XModel3 >& xModel)
 309 {
 310     if (css::uno::Reference<css::frame::XStorable> xURLProvider{ xModel, css::uno::UNO_QUERY })
 311         return xURLProvider->getLocation();
 312     return {};
 313 }
 314
 315 void TitleHelper::impl_updateTitleForModel (const css::uno::Reference< css::frame::XModel3 >& xModel, bool init)
 316 {
 317     css::uno::Reference< css::uno::XInterface >         xOwner;
 318     css::uno::Reference< css::frame::XUntitledNumbers > xNumbers;
 319     ::sal_Int32                                         nLeasedNumber;
 320     // SYNCHRONIZED ->
 321     {
 322         std::unique_lock aLock(m_aMutex);
 323
 324         // external title won't be updated internally!
 325         // It has to be set from outside new.
 326         if (m_bExternalTitle)
 327             return;
 328
 329         xOwner = m_xOwner;
 330         xNumbers = m_xUntitledNumbers;
 331         nLeasedNumber = m_nLeasedNumber;
 332     }
 333     // <- SYNCHRONIZED
 334
 335     if (
 336         ( ! xOwner.is    ()) ||
 337         ( ! xNumbers.is  ()) ||
 338         ( ! xModel.is    ())
 339        )
 340         return;
 341
 342     OUString sTitle;
 343
 344     utl::MediaDescriptor aDescriptor(
 345         xModel->getArgs2({ utl::MediaDescriptor::PROP_DOCUMENTTITLE,
 346                            utl::MediaDescriptor::PROP_SUGGESTEDSAVEASNAME }));
 347
 348     if (const OUString sMediaTitle = aDescriptor.getUnpackedValueOrDefault(
 349             utl::MediaDescriptor::PROP_DOCUMENTTITLE, OUString());
 350         !sMediaTitle.isEmpty())
 351     {
 352         sTitle = sMediaTitle;
 353     }
 354     else if (const OUString sURL = getURLFromModel(xModel); !sURL.isEmpty())
 355     {
 356         sTitle = impl_convertURL2Title(sURL);
 357         if (nLeasedNumber != css::frame::UntitledNumbersConst::INVALID_NUMBER)
 358             xNumbers->releaseNumber (nLeasedNumber);
 359         nLeasedNumber = css::frame::UntitledNumbersConst::INVALID_NUMBER;
 360     }
 361     else if (const OUString sSuggestedSaveAsName = aDescriptor.getUnpackedValueOrDefault(
 362                  utl::MediaDescriptor::PROP_SUGGESTEDSAVEASNAME, OUString());
 363              !sSuggestedSaveAsName.isEmpty())
 364     {
 365         // tdf#121537 Use suggested save as name for title if file has not yet been saved
 366         sTitle = sSuggestedSaveAsName;
 367     }
 368     else
 369     {
 370         if (nLeasedNumber == css::frame::UntitledNumbersConst::INVALID_NUMBER)
 371             nLeasedNumber = xNumbers->leaseNumber (xOwner);
 372
 373         if (nLeasedNumber != css::frame::UntitledNumbersConst::INVALID_NUMBER)
 374             sTitle = xNumbers->getUntitledPrefix() + OUString::number(nLeasedNumber);
 375         else
 376             sTitle = xNumbers->getUntitledPrefix() + "?";
 377     }
 378
 379     bool     bChanged;
 380     // SYNCHRONIZED ->
 381     {
 382         std::unique_lock aLock(m_aMutex);
 383
 384         // WORKAROUND: the notification is currently sent always,
 385         //             can be changed after shared mode is supported per UNO API
 386         bChanged        = !init; // && m_sTitle != sTitle
 387
 388         m_sTitle        = sTitle;
 389         m_nLeasedNumber = nLeasedNumber;
 390     }
 391     // <- SYNCHRONIZED
 392
 393     if (bChanged)
 394         impl_sendTitleChangedEvent ();
 395 }
 396
 397 void TitleHelper::impl_updateTitleForController (const css::uno::Reference< css::frame::XController >& xController, bool init)
 398 {
 399     css::uno::Reference< css::uno::XInterface >         xOwner;
 400     css::uno::Reference< css::frame::XUntitledNumbers > xNumbers;
 401     ::sal_Int32                                         nLeasedNumber;
 402     // SYNCHRONIZED ->
 403     {
 404         std::unique_lock aLock(m_aMutex);
 405
 406         // external title won't be updated internally!
 407         // It has to be set from outside new.
 408         if (m_bExternalTitle)
 409             return;
 410
 411         xOwner = m_xOwner;
 412         xNumbers = m_xUntitledNumbers;
 413         nLeasedNumber = m_nLeasedNumber;
 414     }
 415     // <- SYNCHRONIZED
 416
 417     if (
 418         ( ! xOwner.is      ()) ||
 419         ( ! xNumbers.is    ()) ||
 420         ( ! xController.is ())
 421        )
 422         return;
 423
 424     OUStringBuffer sTitle(256);
 425
 426     if (nLeasedNumber == css::frame::UntitledNumbersConst::INVALID_NUMBER)
 427         nLeasedNumber = xNumbers->leaseNumber (xOwner);
 428
 429     css::uno::Reference< css::frame::XTitle > xModelTitle(xController->getModel (), css::uno::UNO_QUERY);
 430     css::uno::Reference< css::frame::XModel > xModel = xController->getModel ();
 431     if (!xModelTitle.is ())
 432         xModelTitle.set(xController, css::uno::UNO_QUERY);
 433     if (xModelTitle.is ())
 434     {
 435         sTitle.append      (xModelTitle->getTitle ());
 436         if ( nLeasedNumber > 1 )
 437         {
 438             sTitle.append(" : " + OUString::number(nLeasedNumber));
 439         }
 440         if (xModel.is ())
 441         {
 442             INetURLObject aURL (xModel->getURL ());
 443             if (aURL.GetProtocol () != INetProtocol::File
 444                 && aURL.GetProtocol() != INetProtocol::PrivSoffice
 445                 && aURL.GetProtocol () != INetProtocol::NotValid)
 446             {
 447                 OUString sRemoteText (FwkResId (STR_REMOTE_TITLE));
 448                 sTitle.append (sRemoteText);
 449             }
 450         }
 451     }
 452     else
 453     {
 454         sTitle.append (xNumbers->getUntitledPrefix ());
 455         if ( nLeasedNumber > 1 )
 456         {
 457             sTitle.append(nLeasedNumber  );
 458         }
 459     }
 460
 461     bool     bChanged;
 462     // SYNCHRONIZED ->
 463     {
 464         std::unique_lock aLock(m_aMutex);
 465
 466         OUString sNewTitle       = sTitle.makeStringAndClear ();
 467         bChanged        = !init && m_sTitle != sNewTitle;
 468         m_sTitle        = sNewTitle;
 469         m_nLeasedNumber = nLeasedNumber;
 470     }
 471     // <- SYNCHRONIZED
 472
 473     if (bChanged)
 474         impl_sendTitleChangedEvent ();
 475 }
 476
 477 void TitleHelper::impl_updateTitleForFrame (const css::uno::Reference< css::frame::XFrame >& xFrame, bool init)
 478 {
 479     if ( ! xFrame.is ())
 480         return;
 481
 482     // SYNCHRONIZED ->
 483     {
 484         std::unique_lock aLock(m_aMutex);
 485
 486         // external title won't be updated internally!
 487         // It has to be set from outside new.
 488         if (m_bExternalTitle)
 489             return;
 490     }
 491     // <- SYNCHRONIZED
 492
 493     css::uno::Reference< css::uno::XInterface > xComponent = xFrame->getController ();
 494     if ( ! xComponent.is ())
 495         xComponent = xFrame->getComponentWindow ();
 496
 497     OUStringBuffer sTitle (256);
 498
 499     impl_appendComponentTitle   (sTitle, xComponent);
 500 #ifndef MACOSX
 501     if (!comphelper::IsFuzzing())
 502     {
 503         // fdo#70376: We want the window title to contain just the
 504         // document name (from the above "component title").
 505         impl_appendProductName      (sTitle);
 506         impl_appendModuleName       (sTitle);
 507         impl_appendDebugVersion     (sTitle);
 508     }
 509 #endif
 510     impl_appendSafeMode         (sTitle);
 511
 512     bool     bChanged;
 513     // SYNCHRONIZED ->
 514     {
 515         std::unique_lock aLock(m_aMutex);
 516
 517         OUString sNewTitle = sTitle.makeStringAndClear ();
 518         bChanged  = !init && m_sTitle != sNewTitle;
 519         m_sTitle  = sNewTitle;
 520     }
 521     // <- SYNCHRONIZED
 522
 523     if (bChanged)
 524         impl_sendTitleChangedEvent ();
 525 }
 526
 527 // static
 528 void TitleHelper::impl_appendComponentTitle (      OUStringBuffer&                       sTitle    ,
 529                                              const css::uno::Reference< css::uno::XInterface >& xComponent)
 530 {
 531     css::uno::Reference< css::frame::XTitle > xTitle(xComponent, css::uno::UNO_QUERY);
 532
 533     // Note: Title has to be used (even if it's empty) if the right interface is supported.
 534     if (xTitle.is ())
 535         sTitle.append (xTitle->getTitle ());
 536 }
 537
 538 // static
 539 void TitleHelper::impl_appendProductName (OUStringBuffer& sTitle)
 540 {
 541     OUString name(utl::ConfigManager::getProductName());
 542     if (!name.isEmpty())
 543     {
 544         if (!sTitle.isEmpty())
 545         {
 546             OUString separator (FwkResId (STR_EMDASH_SEPARATOR));
 547             sTitle.append(separator);
 548         }
 549         sTitle.append(name);
 550     }
 551 }
 552
 553 void TitleHelper::impl_appendModuleName (OUStringBuffer& sTitle)
 554 {
 555     css::uno::Reference< css::uno::XInterface >        xOwner;
 556     css::uno::Reference< css::uno::XComponentContext > xContext;
 557     // SYNCHRONIZED ->
 558     {
 559         std::unique_lock aLock(m_aMutex);
 560
 561         xOwner   = m_xOwner;
 562         xContext = m_xContext;
 563     }
 564     // <- SYNCHRONIZED
 565
 566     try
 567     {
 568         css::uno::Reference< css::frame::XModuleManager2 > xModuleManager =
 569             css::frame::ModuleManager::create(xContext);
 570
 571         const OUString                 sID     = xModuleManager->identify(xOwner);
 572         ::comphelper::SequenceAsHashMap lProps  = xModuleManager->getByName (sID);
 573         const OUString                 sUIName = lProps.getUnpackedValueOrDefault (OFFICEFACTORY_PROPNAME_ASCII_UINAME, OUString());
 574
 575         // An UIname property is an optional value !
 576         // So please add it to the title in case it does really exists only.
 577         if (!sUIName.isEmpty())
 578         {
 579             sTitle.append (" "    );
 580             sTitle.append      (sUIName);
 581         }
 582     }
 583     catch(const css::uno::Exception&)
 584     {}
 585 }
 586
 587 #ifdef DBG_UTIL
 588 // static
 589 void TitleHelper::impl_appendDebugVersion (OUStringBuffer& sTitle)
 590 {
 591     OUString version(utl::ConfigManager::getProductVersion());
 592     sTitle.append(' ');
 593     sTitle.append(version);
 594     OUString sVersion = ::utl::Bootstrap::getBuildIdData(u"development"_ustr);
 595     sTitle.append(" [");
 596     sTitle.append(sVersion);
 597     sTitle.append("]");
 598 }
 599 #else
 600 void TitleHelper::impl_appendDebugVersion (OUStringBuffer&)
 601 {
 602 }
 603 #endif
 604
 605 // static
 606 void TitleHelper::impl_appendSafeMode (OUStringBuffer& sTitle)
 607 {
 608     if (Application::IsSafeModeEnabled())
 609         sTitle.append(FwkResId (STR_SAFEMODE_TITLE));
 610 }
 611
 612 void TitleHelper::impl_startListeningForModel (const css::uno::Reference< css::frame::XModel >& xModel)
 613 {
 614     css::uno::Reference< css::document::XDocumentEventBroadcaster > xBroadcaster(xModel, css::uno::UNO_QUERY);
 615     if ( ! xBroadcaster.is ())
 616         return;
 617
 618     xBroadcaster->addDocumentEventListener (static_cast< css::document::XDocumentEventListener* >(this));
 619 }
 620
 621 void TitleHelper::impl_startListeningForController (const css::uno::Reference< css::frame::XController >& xController)
 622 {
 623     xController->addEventListener (static_cast< css::lang::XEventListener* > (static_cast< css::frame::XFrameActionListener* > (this) ) );
 624     css::uno::Reference< css::frame::XTitle > xSubTitle(xController->getModel (), css::uno::UNO_QUERY);
 625     impl_setSubTitle (xSubTitle);
 626 }
 627
 628 void TitleHelper::impl_startListeningForFrame (const css::uno::Reference< css::frame::XFrame >& xFrame)
 629 {
 630     xFrame->addFrameActionListener(this  );
 631     impl_updateListeningForFrame  (xFrame);
 632 }
 633
 634 void TitleHelper::impl_updateListeningForFrame (const css::uno::Reference< css::frame::XFrame >& xFrame)
 635 {
 636     css::uno::Reference< css::frame::XTitle > xSubTitle(xFrame->getController (), css::uno::UNO_QUERY);
 637     impl_setSubTitle (xSubTitle);
 638 }
 639
 640 void TitleHelper::impl_setSubTitle (const css::uno::Reference< css::frame::XTitle >& xSubTitle)
 641 {
 642     css::uno::Reference< css::frame::XTitle > xOldSubTitle;
 643     // SYNCHRONIZED ->
 644     {
 645         std::unique_lock aLock(m_aMutex);
 646
 647         // ignore duplicate calls. Makes outside using of this helper more easy :-)
 648         xOldSubTitle = m_xSubTitle;
 649         if (xOldSubTitle == xSubTitle)
 650             return;
 651
 652         m_xSubTitle = xSubTitle;
 653     }
 654     // <- SYNCHRONIZED
 655
 656     css::uno::Reference< css::frame::XTitleChangeBroadcaster > xOldBroadcaster(xOldSubTitle                                          , css::uno::UNO_QUERY      );
 657     css::uno::Reference< css::frame::XTitleChangeBroadcaster > xNewBroadcaster(xSubTitle                                             , css::uno::UNO_QUERY      );
 658     css::uno::Reference< css::frame::XTitleChangeListener >    xThis(this);
 659
 660     if (xOldBroadcaster.is())
 661         xOldBroadcaster->removeTitleChangeListener (xThis);
 662
 663     if (xNewBroadcaster.is())
 664         xNewBroadcaster->addTitleChangeListener (xThis);
 665 }
 666
 667 // static
 668 OUString TitleHelper::impl_convertURL2Title(std::u16string_view sURL)
 669 {
 670     INetURLObject   aURL (sURL);
 671     OUString sTitle;
 672
 673     if (aURL.GetProtocol() == INetProtocol::File)
 674     {
 675         if (aURL.HasMark())
 676             aURL = INetURLObject(aURL.GetURLNoMark());
 677
 678         sTitle = aURL.getName(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset);
 679     }
 680     else
 681     {
 682         if (aURL.hasExtension())
 683             sTitle = aURL.getName(INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::WithCharset);
 684
 685         if ( sTitle.isEmpty() )
 686             sTitle = aURL.GetHostPort(INetURLObject::DecodeMechanism::WithCharset);
 687
 688         if ( sTitle.isEmpty() )
 689             sTitle = aURL.GetURLNoPass(INetURLObject::DecodeMechanism::WithCharset);
 690     }
 691
 692     return sTitle;
 693 }
 694
 695 } // namespace framework
 696
 697 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */