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