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