unotools/source/config/historyoptions.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 <osl/file.hxx>
  21 #include <unotools/historyoptions.hxx>
  22 #include <unotools/configmgr.hxx>
  23 #include <unotools/configitem.hxx>
  24 #include <com/sun/star/uno/Any.hxx>
  25 #include <com/sun/star/uno/Sequence.hxx>
  26
  27 #include <cassert>
  28 #include <deque>
  29 #include <algorithm>
  30
  31 #include "itemholder1.hxx"
  32
  33 #include <com/sun/star/beans/XPropertySet.hpp>
  34 #include <com/sun/star/container/XNameAccess.hpp>
  35 #include <com/sun/star/container/XNameContainer.hpp>
  36 #include <com/sun/star/lang/XSingleServiceFactory.hpp>
  37 #include <comphelper/configurationhelper.hxx>
  38 #include <comphelper/processfactory.hxx>
  39
  40 using namespace ::std;
  41 using namespace ::utl;
  42 using namespace ::osl;
  43 using namespace ::com::sun::star;
  44 using namespace ::com::sun::star::uno;
  45 using namespace ::com::sun::star::beans;
  46
  47 namespace {
  48     static const ::sal_Int32 s_nOffsetURL               = 0;
  49     static const ::sal_Int32 s_nOffsetFilter            = 1;
  50     static const ::sal_Int32 s_nOffsetTitle             = 2;
  51     static const ::sal_Int32 s_nOffsetPassword          = 3;
  52     static const ::sal_Int32 s_nOffsetThumbnail         = 4;
  53
  54     const char s_sCommonHistory[] = "org.openoffice.Office.Common/History";
  55     const char s_sHistories[] = "org.openoffice.Office.Histories/Histories";
  56     const char s_sPickListSize[] = "PickListSize";
  57     const char s_sHelpBookmarksSize[] = "HelpBookmarkSize";
  58     const char s_sPickList[] = "PickList";
  59     const char s_sHelpBookmarks[] = "HelpBookmarks";
  60     const char s_sItemList[] = "ItemList";
  61     const char s_sOrderList[] = "OrderList";
  62     const char s_sHistoryItemRef[] = "HistoryItemRef";
  63     const char s_sFilter[] = "Filter";
  64     const char s_sTitle[] = "Title";
  65     const char s_sPassword[] = "Password";
  66     const char s_sThumbnail[] = "Thumbnail";
  67
  68     class theHistoryOptionsMutex : public rtl::Static<osl::Mutex, theHistoryOptionsMutex>{};
  69 }
  70
  71 /// Internal implementation of the SvtHistoryOptions.
  72 class SvtHistoryOptions_Impl
  73 {
  74 public:
  75     SvtHistoryOptions_Impl();
  76     ~SvtHistoryOptions_Impl();
  77
  78     /// Returns the maximum size of the internal lists, ie. the capacity not the size.
  79     sal_uInt32 GetCapacity(EHistoryType eHistory);
  80
  81     /// Clear the specified history list.
  82     void Clear(EHistoryType eHistory);
  83
  84     /// Get a sequence list from the items.
  85     Sequence< Sequence<PropertyValue> > GetList(EHistoryType eHistory);
  86
  87     void AppendItem(EHistoryType eHistory,
  88         const OUString& sURL, const OUString& sFilter, const OUString& sTitle,
  89         const OUString& sPassword, const OUString& sThumbnail);
  90
  91     void DeleteItem(EHistoryType eHistory, const OUString& sURL);
  92
  93 private:
  94     /// Return the appropriate list of recent documents (based on eHistory).
  95     uno::Reference<container::XNameAccess> GetListAccess(EHistoryType eHistory) const;
  96
  97     void impl_truncateList(EHistoryType eHistory, sal_uInt32 nSize);
  98
  99 private:
 100     uno::Reference<container::XNameAccess> m_xCfg;
 101     uno::Reference<container::XNameAccess> m_xCommonXCU;
 102 };
 103
 104 SvtHistoryOptions_Impl::SvtHistoryOptions_Impl()
 105 {
 106     try
 107     {
 108         m_xCfg = Reference<container::XNameAccess> (
 109             ::comphelper::ConfigurationHelper::openConfig(
 110             ::comphelper::getProcessComponentContext(),
 111             s_sHistories,
 112             ::comphelper::ConfigurationHelper::E_STANDARD),
 113             uno::UNO_QUERY);
 114
 115         m_xCommonXCU = Reference<container::XNameAccess> (
 116             ::comphelper::ConfigurationHelper::openConfig(
 117             ::comphelper::getProcessComponentContext(),
 118             s_sCommonHistory,
 119             ::comphelper::ConfigurationHelper::E_STANDARD),
 120             uno::UNO_QUERY);
 121     }
 122     catch(const uno::Exception& ex)
 123     {
 124         m_xCfg.clear();
 125         m_xCommonXCU.clear();
 126
 127         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 128     }
 129 }
 130
 131 SvtHistoryOptions_Impl::~SvtHistoryOptions_Impl()
 132 {
 133 }
 134
 135 sal_uInt32 SvtHistoryOptions_Impl::GetCapacity(EHistoryType eHistory)
 136 {
 137     uno::Reference<beans::XPropertySet> xListAccess(m_xCommonXCU, uno::UNO_QUERY);
 138
 139     if (!xListAccess.is())
 140         return 0;
 141
 142     sal_uInt32 nSize = 0;
 143
 144     try
 145     {
 146         switch (eHistory)
 147         {
 148         case ePICKLIST:
 149             xListAccess->getPropertyValue(s_sPickListSize) >>= nSize;
 150             break;
 151
 152         case eHELPBOOKMARKS:
 153             xListAccess->getPropertyValue(s_sHelpBookmarksSize) >>= nSize;
 154             break;
 155
 156         default:
 157             break;
 158         }
 159     }
 160     catch (const uno::Exception& ex)
 161     {
 162         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 163     }
 164
 165     return nSize;
 166 }
 167
 168 uno::Reference<container::XNameAccess> SvtHistoryOptions_Impl::GetListAccess(EHistoryType eHistory) const
 169 {
 170     uno::Reference<container::XNameAccess> xListAccess;
 171
 172     try
 173     {
 174         switch (eHistory)
 175         {
 176         case ePICKLIST:
 177             m_xCfg->getByName(s_sPickList) >>= xListAccess;
 178             break;
 179
 180         case eHELPBOOKMARKS:
 181             m_xCfg->getByName(s_sHelpBookmarks) >>= xListAccess;
 182             break;
 183
 184         default:
 185             break;
 186         }
 187     }
 188     catch (const uno::Exception& ex)
 189     {
 190         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 191     }
 192
 193     return xListAccess;
 194 }
 195
 196 void SvtHistoryOptions_Impl::impl_truncateList(EHistoryType eHistory, sal_uInt32 nSize)
 197 {
 198     uno::Reference<container::XNameAccess> xList(GetListAccess(eHistory));
 199     if (!xList.is())
 200         return;
 201
 202     uno::Reference<container::XNameContainer> xItemList;
 203     uno::Reference<container::XNameContainer> xOrderList;
 204     uno::Reference<beans::XPropertySet>       xSet;
 205
 206     try
 207     {
 208         xList->getByName(s_sOrderList) >>= xOrderList;
 209         xList->getByName(s_sItemList)  >>= xItemList;
 210
 211         const sal_uInt32 nLength = xOrderList->getElementNames().getLength();
 212         if (nSize < nLength)
 213         {
 214             for (sal_uInt32 i=nLength-1; i>=nSize; --i)
 215             {
 216                 OUString sTmp;
 217                 const OUString sRemove = OUString::number(i);
 218                 xOrderList->getByName(sRemove) >>= xSet;
 219                 xSet->getPropertyValue(s_sHistoryItemRef) >>= sTmp;
 220                 xItemList->removeByName(sTmp);
 221                 xOrderList->removeByName(sRemove);
 222             }
 223
 224             ::comphelper::ConfigurationHelper::flush(m_xCfg);
 225         }
 226     }
 227     catch(const uno::Exception& ex)
 228     {
 229         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 230     }
 231 }
 232
 233 void SvtHistoryOptions_Impl::Clear( EHistoryType eHistory )
 234 {
 235     uno::Reference<container::XNameAccess> xListAccess(GetListAccess(eHistory));
 236     if (!xListAccess.is())
 237         return;
 238
 239     uno::Reference<container::XNameContainer> xNode;
 240
 241     try
 242     {
 243         // clear ItemList
 244         xListAccess->getByName(s_sItemList) >>= xNode;
 245         Sequence<OUString> aStrings(xNode->getElementNames());
 246
 247         const sal_Int32 nLength = aStrings.getLength();
 248         for (sal_Int32 i = 0; i < nLength; ++i)
 249             xNode->removeByName(aStrings[i]);
 250
 251         // clear OrderList
 252         xListAccess->getByName(s_sOrderList) >>= xNode;
 253         aStrings = xNode->getElementNames();
 254
 255         for (sal_Int32 j = 0; j < nLength; ++j)
 256             xNode->removeByName(aStrings[j]);
 257
 258         ::comphelper::ConfigurationHelper::flush(m_xCfg);
 259     }
 260     catch(const uno::Exception& ex)
 261     {
 262         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 263     }
 264 }
 265
 266 static bool lcl_fileOpenable(const OUString &rURL)
 267 {
 268     osl::File aRecentFile(rURL);
 269     if(!aRecentFile.open(osl_File_OpenFlag_Read))
 270     {
 271         aRecentFile.close();
 272         return true;
 273     }
 274     else
 275         return false;
 276 }
 277
 278 Sequence< Sequence<PropertyValue> > SvtHistoryOptions_Impl::GetList(EHistoryType eHistory)
 279 {
 280     uno::Reference<container::XNameAccess> xListAccess(GetListAccess(eHistory));
 281     if (!xListAccess.is())
 282         return Sequence< Sequence<PropertyValue> >();
 283
 284     impl_truncateList(eHistory, GetCapacity(eHistory));
 285
 286     Sequence<PropertyValue> seqProperties(5);
 287     seqProperties[s_nOffsetURL       ].Name = HISTORY_PROPERTYNAME_URL;
 288     seqProperties[s_nOffsetFilter    ].Name = HISTORY_PROPERTYNAME_FILTER;
 289     seqProperties[s_nOffsetTitle     ].Name = HISTORY_PROPERTYNAME_TITLE;
 290     seqProperties[s_nOffsetPassword  ].Name = HISTORY_PROPERTYNAME_PASSWORD;
 291     seqProperties[s_nOffsetThumbnail ].Name = HISTORY_PROPERTYNAME_THUMBNAIL;
 292
 293     uno::Reference<container::XNameAccess> xItemList;
 294     uno::Reference<container::XNameAccess> xOrderList;
 295     try
 296     {
 297         xListAccess->getByName(s_sItemList)  >>= xItemList;
 298         xListAccess->getByName(s_sOrderList) >>= xOrderList;
 299     }
 300     catch(const uno::Exception& ex)
 301     {
 302         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 303     }
 304
 305     const sal_Int32 nLength = xOrderList->getElementNames().getLength();
 306     Sequence< Sequence<PropertyValue> > aRet(nLength);
 307     sal_Int32 nCount = 0;
 308
 309     for (sal_Int32 nItem = 0; nItem < nLength; ++nItem)
 310     {
 311         try
 312         {
 313             OUString sUrl;
 314             uno::Reference<beans::XPropertySet> xSet;
 315             xOrderList->getByName(OUString::number(nItem)) >>= xSet;
 316             xSet->getPropertyValue(s_sHistoryItemRef) >>= sUrl;
 317
 318             if (!sUrl.startsWith("file://") || lcl_fileOpenable(sUrl))
 319             {
 320                 xItemList->getByName(sUrl) >>= xSet;
 321                 seqProperties[s_nOffsetURL  ].Value <<= sUrl;
 322
 323                 xSet->getPropertyValue(s_sFilter)   >>= seqProperties[s_nOffsetFilter   ].Value;
 324                 xSet->getPropertyValue(s_sTitle)    >>= seqProperties[s_nOffsetTitle    ].Value;
 325                 xSet->getPropertyValue(s_sPassword) >>= seqProperties[s_nOffsetPassword ].Value;
 326                 xSet->getPropertyValue(s_sThumbnail)>>= seqProperties[s_nOffsetThumbnail].Value;
 327                 aRet[nCount++] = seqProperties;
 328             }
 329         }
 330         catch(const uno::Exception& ex)
 331         {
 332             // <https://bugs.libreoffice.org/show_bug.cgi?id=46074>
 333             // "FILEOPEN: No Recent Documents..." discusses a problem
 334             // with corrupted /org.openoffice.Office/Histories/Histories
 335             // configuration items; to work around that problem, simply
 336             // ignore such corrupted individual items here, so that at
 337             // least newly added items are successfully reported back
 338             // from this function:
 339             SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 340         }
 341     }
 342     assert(nCount <= nLength);
 343     aRet.realloc(nCount);
 344     return aRet;
 345 }
 346
 347 void SvtHistoryOptions_Impl::AppendItem(EHistoryType eHistory,
 348         const OUString& sURL, const OUString& sFilter, const OUString& sTitle,
 349         const OUString& sPassword, const OUString& sThumbnail)
 350 {
 351     uno::Reference<container::XNameAccess> xListAccess(GetListAccess(eHistory));
 352     if (!xListAccess.is())
 353         return;
 354
 355     impl_truncateList(eHistory, GetCapacity(eHistory));
 356
 357     sal_Int32 nMaxSize = GetCapacity(eHistory);
 358     if (nMaxSize == 0)
 359         return;
 360
 361     uno::Reference<container::XNameContainer> xItemList;
 362     uno::Reference<container::XNameContainer> xOrderList;
 363     uno::Reference<beans::XPropertySet>       xSet;
 364
 365     try
 366     {
 367         xListAccess->getByName(s_sItemList)  >>= xItemList;
 368         xListAccess->getByName(s_sOrderList) >>= xOrderList;
 369         sal_Int32 nLength = xOrderList->getElementNames().getLength();
 370
 371         // The item to be appended already exists
 372         if (xItemList->hasByName(sURL))
 373         {
 374             if (!sThumbnail.isEmpty())
 375             {
 376                 // update the thumbnail
 377                 xItemList->getByName(sURL) >>= xSet;
 378                 xSet->setPropertyValue(s_sThumbnail, uno::makeAny(sThumbnail));
 379             }
 380
 381             for (sal_Int32 i=0; i<nLength; ++i)
 382             {
 383                 OUString aItem;
 384                 xOrderList->getByName(OUString::number(i)) >>= xSet;
 385                 xSet->getPropertyValue(s_sHistoryItemRef) >>= aItem;
 386
 387                 if (aItem == sURL)
 388                 {
 389                     for (sal_Int32 j = i - 1; j >= 0; --j)
 390                     {
 391                         uno::Reference<beans::XPropertySet> xPrevSet;
 392                         uno::Reference<beans::XPropertySet> xNextSet;
 393                         xOrderList->getByName(OUString::number(j+1)) >>= xPrevSet;
 394                         xOrderList->getByName(OUString::number(j))   >>= xNextSet;
 395
 396                         OUString sTemp;
 397                         xNextSet->getPropertyValue(s_sHistoryItemRef) >>= sTemp;
 398                         xPrevSet->setPropertyValue(s_sHistoryItemRef, uno::makeAny(sTemp));
 399                     }
 400                     xOrderList->getByName(OUString::number(0)) >>= xSet;
 401                     xSet->setPropertyValue(s_sHistoryItemRef, uno::makeAny(aItem));
 402                     break;
 403                 }
 404             }
 405
 406             ::comphelper::ConfigurationHelper::flush(m_xCfg);
 407         }
 408         else // The item to be appended does not exist yet
 409         {
 410             uno::Reference<lang::XSingleServiceFactory> xFac;
 411             uno::Reference<uno::XInterface>             xInst;
 412             uno::Reference<beans::XPropertySet> xPrevSet;
 413             uno::Reference<beans::XPropertySet> xNextSet;
 414
 415             // Append new item to OrderList.
 416             if ( nLength == nMaxSize )
 417             {
 418                 OUString sRemove;
 419                 xOrderList->getByName(OUString::number(nLength-1)) >>= xSet;
 420                 xSet->getPropertyValue(s_sHistoryItemRef) >>= sRemove;
 421                 try
 422                 {
 423                     xItemList->removeByName(sRemove);
 424                 }
 425                 catch (container::NoSuchElementException &)
 426                 {
 427                     // <https://bugs.libreoffice.org/show_bug.cgi?id=46074>
 428                     // "FILEOPEN: No Recent Documents..." discusses a problem
 429                     // with corrupted /org.openoffice.Office/Histories/Histories
 430                     // configuration items; to work around that problem, simply
 431                     // ignore such corrupted individual items here, so that at
 432                     // least newly added items are successfully added:
 433                     if (!sRemove.isEmpty())
 434                     {
 435                         throw;
 436                     }
 437                 }
 438             }
 439             if (nLength != nMaxSize)
 440             {
 441                 xFac = uno::Reference<lang::XSingleServiceFactory>(xOrderList, uno::UNO_QUERY);
 442                 xInst = xFac->createInstance();
 443                 OUString sPush = OUString::number(nLength++);
 444                 xOrderList->insertByName(sPush, uno::makeAny(xInst));
 445             }
 446             for (sal_Int32 j=nLength-1; j>0; --j)
 447             {
 448                 xOrderList->getByName( OUString::number(j) )   >>= xPrevSet;
 449                 xOrderList->getByName( OUString::number(j-1) ) >>= xNextSet;
 450                 OUString sTemp;
 451                 xNextSet->getPropertyValue(s_sHistoryItemRef) >>= sTemp;
 452                 xPrevSet->setPropertyValue(s_sHistoryItemRef, uno::makeAny(sTemp));
 453             }
 454             xOrderList->getByName( OUString::number(0) ) >>= xSet;
 455             xSet->setPropertyValue(s_sHistoryItemRef, uno::makeAny(sURL));
 456
 457             // Append the item to ItemList.
 458             xFac = uno::Reference<lang::XSingleServiceFactory>(xItemList, uno::UNO_QUERY);
 459             xInst = xFac->createInstance();
 460             xItemList->insertByName(sURL, uno::makeAny(xInst));
 461
 462             xSet = uno::Reference<beans::XPropertySet>(xInst, uno::UNO_QUERY);
 463             xSet->setPropertyValue(s_sFilter, uno::makeAny(sFilter));
 464             xSet->setPropertyValue(s_sTitle, uno::makeAny(sTitle));
 465             xSet->setPropertyValue(s_sPassword, uno::makeAny(sPassword));
 466             xSet->setPropertyValue(s_sThumbnail, uno::makeAny(sThumbnail));
 467
 468             ::comphelper::ConfigurationHelper::flush(m_xCfg);
 469         }
 470     }
 471     catch(const uno::Exception& ex)
 472     {
 473         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 474     }
 475 }
 476
 477 void SvtHistoryOptions_Impl::DeleteItem(EHistoryType eHistory, const OUString& sURL)
 478 {
 479     uno::Reference<container::XNameAccess> xListAccess(GetListAccess(eHistory));
 480     if (!xListAccess.is())
 481         return;
 482
 483     uno::Reference<container::XNameContainer> xItemList;
 484     uno::Reference<container::XNameContainer> xOrderList;
 485     uno::Reference<beans::XPropertySet>       xSet;
 486
 487     try
 488     {
 489         xListAccess->getByName(s_sItemList)  >>= xItemList;
 490         xListAccess->getByName(s_sOrderList) >>= xOrderList;
 491         sal_Int32 nLength = xOrderList->getElementNames().getLength();
 492
 493         // if it does not exist, nothing to do
 494         if (!xItemList->hasByName(sURL))
 495             return;
 496
 497         // it's the last one, just clear the lists
 498         if (nLength == 1)
 499         {
 500             Clear(eHistory);
 501             return;
 502         }
 503
 504         // find it in the OrderList
 505         sal_Int32 nFromWhere = 0;
 506         for (; nFromWhere < nLength - 1; ++nFromWhere)
 507         {
 508             OUString aItem;
 509             xOrderList->getByName(OUString::number(nFromWhere)) >>= xSet;
 510             xSet->getPropertyValue(s_sHistoryItemRef) >>= aItem;
 511
 512             if (aItem == sURL)
 513                 break;
 514         }
 515
 516         // and shift the rest of the items in OrderList accordingly
 517         for (sal_Int32 i = nFromWhere; i < nLength - 1; ++i)
 518         {
 519             uno::Reference<beans::XPropertySet> xPrevSet;
 520             uno::Reference<beans::XPropertySet> xNextSet;
 521             xOrderList->getByName(OUString::number(i))     >>= xPrevSet;
 522             xOrderList->getByName(OUString::number(i + 1)) >>= xNextSet;
 523
 524             OUString sTemp;
 525             xNextSet->getPropertyValue(s_sHistoryItemRef) >>= sTemp;
 526             xPrevSet->setPropertyValue(s_sHistoryItemRef, uno::makeAny(sTemp));
 527         }
 528         xOrderList->removeByName(OUString::number(nLength - 1));
 529
 530         // and finally remove it from the ItemList
 531         xItemList->removeByName(sURL);
 532
 533         ::comphelper::ConfigurationHelper::flush(m_xCfg);
 534     }
 535     catch (const uno::Exception& ex)
 536     {
 537         SAL_WARN("unotools.config", "Caught unexpected: " << ex.Message);
 538     }
 539 }
 540
 541 // initialize static member
 542 // DON'T DO IT IN YOUR HEADER!
 543 // see definition for further information
 544
 545 SvtHistoryOptions_Impl*  SvtHistoryOptions::m_pDataContainer = NULL;
 546 sal_Int32     SvtHistoryOptions::m_nRefCount  = 0;
 547
 548 // constructor
 549
 550 SvtHistoryOptions::SvtHistoryOptions()
 551 {
 552     MutexGuard aGuard(theHistoryOptionsMutex::get());
 553
 554     // Increase our refcount ...
 555     ++m_nRefCount;
 556     // ... and initialize our data container only if it not already exist!
 557     if( m_pDataContainer == NULL )
 558     {
 559         m_pDataContainer = new SvtHistoryOptions_Impl;
 560
 561         ItemHolder1::holdConfigItem(E_HISTORYOPTIONS);
 562     }
 563 }
 564
 565 // destructor
 566
 567 SvtHistoryOptions::~SvtHistoryOptions()
 568 {
 569     MutexGuard aGuard(theHistoryOptionsMutex::get());
 570
 571     // Decrease our refcount.
 572     --m_nRefCount;
 573     // If last instance was deleted ...
 574     // we must destroy our static data container!
 575     if( m_nRefCount <= 0 )
 576     {
 577         delete m_pDataContainer;
 578         m_pDataContainer = NULL;
 579     }
 580 }
 581
 582 sal_uInt32 SvtHistoryOptions::GetSize( EHistoryType eHistory ) const
 583 {
 584     MutexGuard aGuard(theHistoryOptionsMutex::get());
 585
 586     return m_pDataContainer->GetCapacity(eHistory);
 587 }
 588
 589 void SvtHistoryOptions::Clear( EHistoryType eHistory )
 590 {
 591     MutexGuard aGuard(theHistoryOptionsMutex::get());
 592
 593     m_pDataContainer->Clear( eHistory );
 594 }
 595
 596 Sequence< Sequence< PropertyValue > > SvtHistoryOptions::GetList( EHistoryType eHistory ) const
 597 {
 598     MutexGuard aGuard(theHistoryOptionsMutex::get());
 599
 600     return m_pDataContainer->GetList( eHistory );
 601 }
 602
 603 void SvtHistoryOptions::AppendItem(EHistoryType eHistory,
 604         const OUString& sURL, const OUString& sFilter, const OUString& sTitle,
 605         const OUString& sPassword, const OUString& sThumbnail)
 606 {
 607     MutexGuard aGuard(theHistoryOptionsMutex::get());
 608
 609     m_pDataContainer->AppendItem(eHistory, sURL, sFilter, sTitle, sPassword, sThumbnail);
 610 }
 611
 612 void SvtHistoryOptions::DeleteItem(EHistoryType eHistory, const OUString& sURL)
 613 {
 614     MutexGuard aGuard(theHistoryOptionsMutex::get());
 615
 616     m_pDataContainer->DeleteItem(eHistory, sURL);
 617 }
 618
 619 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */