LCOV - code coverage report
Current view: top level - svtools/source/contnr - fileview.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 1 1093 0.1 %
Date: 2014-04-14 Functions: 2 132 1.5 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "fileview.hxx"
      21             : #include "sal/config.h"
      22             : #include "svtools/treelistentry.hxx"
      23             : #include <svtools/fileview.hxx>
      24             : #include <svtools/svtresid.hxx>
      25             : #include <svtools/imagemgr.hxx>
      26             : #include <svtools/headbar.hxx>
      27             : #include <svtools/svtabbx.hxx>
      28             : #include <svtools/svtools.hrc>
      29             : #include "svtools/viewdataentry.hxx"
      30             : #include "fileview.hrc"
      31             : #include "contentenumeration.hxx"
      32             : #include <svtools/AccessibleBrowseBoxObjType.hxx>
      33             : #include <com/sun/star/util/DateTime.hpp>
      34             : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
      35             : #include <com/sun/star/task/InteractionHandler.hpp>
      36             : #include <com/sun/star/ucb/XProgressHandler.hpp>
      37             : #include <com/sun/star/sdbc/XResultSet.hpp>
      38             : #include <com/sun/star/ucb/XAnyCompareFactory.hpp>
      39             : #include <com/sun/star/ucb/XContentAccess.hpp>
      40             : #include <com/sun/star/ucb/XDynamicResultSet.hpp>
      41             : #include <com/sun/star/ucb/XSortedDynamicResultSetFactory.hpp>
      42             : #include <com/sun/star/sdbc/XRow.hpp>
      43             : #include <com/sun/star/container/XChild.hpp>
      44             : #include <com/sun/star/ucb/CommandAbortedException.hpp>
      45             : #include <com/sun/star/ucb/ContentCreationException.hpp>
      46             : #include <vcl/waitobj.hxx>
      47             : #include <vcl/settings.hxx>
      48             : #include <com/sun/star/io/XPersist.hpp>
      49             : #include <com/sun/star/beans/XPropertySet.hpp>
      50             : #include <com/sun/star/ucb/XCommandInfo.hpp>
      51             : #include <com/sun/star/beans/XPropertySetInfo.hpp>
      52             : #include <com/sun/star/beans/PropertyAttribute.hpp>
      53             : 
      54             : #include <algorithm>
      55             : #include <vector>
      56             : #include <tools/urlobj.hxx>
      57             : #include <comphelper/processfactory.hxx>
      58             : #include <comphelper/string.hxx>
      59             : #include <unotools/localfilehelper.hxx>
      60             : #include <ucbhelper/content.hxx>
      61             : #include <ucbhelper/commandenvironment.hxx>
      62             : #include <vcl/layout.hxx>
      63             : #include <rtl/math.hxx>
      64             : #include <tools/config.hxx>
      65             : #include <osl/mutex.hxx>
      66             : #include <osl/conditn.hxx>
      67             : #include <salhelper/timer.hxx>
      68             : #include <vcl/svapp.hxx>
      69             : #include <unotools/ucbhelper.hxx>
      70             : #include <unotools/intlwrapper.hxx>
      71             : #include <unotools/syslocale.hxx>
      72             : #include <svl/urlfilter.hxx>
      73             : #include <boost/ptr_container/ptr_set.hpp>
      74             : #include <boost/scoped_ptr.hpp>
      75             : 
      76             : using namespace ::com::sun::star::lang;
      77             : using namespace ::com::sun::star::sdbc;
      78             : using namespace ::com::sun::star::task;
      79             : using namespace ::com::sun::star::ucb;
      80             : using namespace ::com::sun::star::uno;
      81             : using namespace ::com::sun::star::io;
      82             : using namespace ::com::sun::star::beans;
      83             : using namespace ::comphelper;
      84             : using ::svt::SortingData_Impl;
      85             : using ::svt::FolderDescriptor;
      86             : 
      87             : #define ALL_FILES_FILTER    "*.*"
      88             : 
      89             : #define COLUMN_TITLE        1
      90             : #define COLUMN_TYPE         2
      91             : #define COLUMN_SIZE         3
      92             : #define COLUMN_DATE         4
      93             : 
      94             : #define SEPARATOR_STR  "----------------------------------"
      95             : 
      96             : #define ROW_HEIGHT                17    // the height of a row has to be a little higher than the bitmap
      97             : #define QUICK_SEARCH_TIMEOUT    1500    // time in mSec before the quicksearch string will be reseted
      98             : 
      99             : namespace
     100             : {
     101             : 
     102             :     //= ITimeoutHandler
     103             : 
     104             :     class CallbackTimer;
     105           0 :     class ITimeoutHandler
     106             :     {
     107             :     public:
     108             :         virtual void onTimeout( CallbackTimer* _pInstigator ) = 0;
     109             : 
     110             :     protected:
     111           0 :         ~ITimeoutHandler() {}
     112             :     };
     113             : 
     114             : 
     115             :     //= CallbackTimer
     116             : 
     117           0 :     class CallbackTimer : public ::salhelper::Timer
     118             :     {
     119             :     protected:
     120             :         ITimeoutHandler* m_pTimeoutHandler;
     121             : 
     122             :     public:
     123           0 :         CallbackTimer( ITimeoutHandler* _pHandler ) : m_pTimeoutHandler( _pHandler ) { }
     124             : 
     125             :     protected:
     126             :         virtual void SAL_CALL onShot() SAL_OVERRIDE;
     127             :     };
     128             : 
     129             : 
     130           0 :     void SAL_CALL CallbackTimer::onShot()
     131             :     {
     132             :         OSL_ENSURE( m_pTimeoutHandler, "CallbackTimer::onShot: nobody interested in?" );
     133           0 :         ITimeoutHandler* pHandler( m_pTimeoutHandler );
     134           0 :         if ( pHandler )
     135           0 :             pHandler->onTimeout( this );
     136           0 :     }
     137             : 
     138             : }
     139             : 
     140             : 
     141             : 
     142           0 : void FilterMatch::createWildCardFilterList(const OUString& _rFilterList,::std::vector< WildCard >& _rFilters)
     143             : {
     144           0 :     if( _rFilterList.getLength() )
     145             :     {
     146             :         // filter is given
     147           0 :         sal_Int32 nIndex = 0;
     148           0 :         OUString sToken;
     149           0 :         do
     150             :         {
     151           0 :             sToken = _rFilterList.getToken( 0, ';', nIndex );
     152           0 :             if ( !sToken.isEmpty() )
     153             :             {
     154           0 :                 _rFilters.push_back( WildCard( sToken.toAsciiUpperCase() ) );
     155             :             }
     156             :         }
     157           0 :         while ( nIndex >= 0 );
     158             :     }
     159             :     else
     160             :     {
     161             :         // no filter is given -> match all
     162           0 :         _rFilters.push_back( WildCard(OUString("*")) );
     163             :     }
     164           0 : }
     165             : // class ViewTabListBox_Impl ---------------------------------------------
     166             : 
     167             : class ViewTabListBox_Impl : public SvHeaderTabListBox
     168             : {
     169             : private:
     170             :     Reference< XCommandEnvironment >    mxCmdEnv;
     171             : 
     172             :     ::osl::Mutex            maMutex;
     173             :     HeaderBar*              mpHeaderBar;
     174             :     SvtFileView_Impl*       mpParent;
     175             :     Timer                   maResetQuickSearch;
     176             :     OUString                maQuickSearchText;
     177             :     OUString                msAccessibleDescText;
     178             :     OUString                msFolder;
     179             :     OUString                msFile;
     180             :     sal_uInt32              mnSearchIndex;
     181             :     bool                    mbResizeDisabled        : 1;
     182             :     bool                    mbAutoResize            : 1;
     183             :     bool                    mbEnableDelete          : 1;
     184             :     bool                    mbEnableRename          : 1;
     185             :     bool                    mbShowHeader;
     186             : 
     187             :     void            DeleteEntries();
     188             :     void            DoQuickSearch( const sal_Unicode& rChar );
     189             :     bool            Kill( const OUString& rURL );
     190             : 
     191             : protected:
     192             :     virtual bool     DoubleClickHdl() SAL_OVERRIDE;
     193             :     virtual OUString GetAccessibleObjectDescription( ::svt::AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos ) const SAL_OVERRIDE;
     194             : 
     195             : public:
     196             :     ViewTabListBox_Impl( Window* pParentWin, SvtFileView_Impl* pParent, sal_Int16 nFlags );
     197             :    virtual ~ViewTabListBox_Impl();
     198             : 
     199             :     virtual void    Resize() SAL_OVERRIDE;
     200             :     virtual void    KeyInput( const KeyEvent& rKEvt ) SAL_OVERRIDE;
     201             :     virtual bool    EditedEntry( SvTreeListEntry* pEntry, const OUString& rNewText ) SAL_OVERRIDE;
     202             : 
     203             :     void            ClearAll();
     204           0 :     HeaderBar*      GetHeaderBar() const { return mpHeaderBar; }
     205             : 
     206           0 :     void            EnableAutoResize() { mbAutoResize = true; }
     207           0 :     void            EnableDelete( bool bEnable ) { mbEnableDelete = bEnable; }
     208           0 :     void            EnableRename( bool bEnable ) { mbEnableRename = bEnable; }
     209           0 :     bool            IsDeleteOrContextMenuEnabled() { return mbEnableDelete || IsContextMenuHandlingEnabled(); }
     210             : 
     211           0 :     Reference< XCommandEnvironment >    GetCommandEnvironment() const { return mxCmdEnv; }
     212             : 
     213             :     DECL_LINK(ResetQuickSearch_Impl, void *);
     214             : 
     215             :     virtual PopupMenu*  CreateContextMenu( void ) SAL_OVERRIDE;
     216             :     virtual void        ExcecuteContextMenuAction( sal_uInt16 nSelectedPopentry ) SAL_OVERRIDE;
     217             : };
     218             : 
     219             : // class HashedEntry --------------------------------------------------
     220             : 
     221             : class HashedEntry
     222             : {   // just a special String which can be compared on equality much faster
     223             : protected:
     224             :     OUString                maName;
     225             :     sal_Int32               mnHashCode;
     226             : public:
     227             :     inline                  HashedEntry( const OUString& rName );
     228             :     inline                  HashedEntry( const INetURLObject& rURL );
     229             :     virtual                 ~HashedEntry();
     230             : 
     231             :     inline bool operator    ==( const HashedEntry& rRef ) const;
     232             :     inline bool operator    !=( const HashedEntry& rRef ) const;
     233             :     inline bool operator    <( const HashedEntry& rRef ) const;
     234             : };
     235             : 
     236           0 : inline HashedEntry::HashedEntry( const OUString& rName ): maName( rName ), mnHashCode( rName.hashCode() )
     237             : {
     238           0 : }
     239             : 
     240           0 : inline HashedEntry::HashedEntry( const INetURLObject& rURL ):
     241             :     maName( rURL.GetMainURL( INetURLObject::NO_DECODE ) ),
     242           0 :     mnHashCode( maName.hashCode() )
     243             : {
     244           0 : }
     245             : 
     246           0 : HashedEntry::~HashedEntry()
     247             : {
     248           0 : }
     249             : 
     250           0 : inline bool HashedEntry::operator ==( const HashedEntry& rRef ) const
     251             : {
     252           0 :     return mnHashCode == rRef.mnHashCode && maName.reverseCompareTo( rRef.maName ) == 0;
     253             : }
     254             : 
     255           0 : inline bool HashedEntry::operator !=( const HashedEntry& rRef ) const
     256             : {
     257           0 :     return mnHashCode != rRef.mnHashCode || maName.reverseCompareTo( rRef.maName ) != 0;
     258             : }
     259             : 
     260           0 : inline bool HashedEntry::operator <( const HashedEntry& rRef ) const
     261             : {
     262           0 :     if( mnHashCode == rRef.mnHashCode )
     263           0 :         return maName.reverseCompareTo( rRef.maName ) < 0;
     264             :     else
     265           0 :        return mnHashCode < rRef.mnHashCode;
     266             : }
     267             : 
     268             : // class HashedEntryList ----------------------------------------------
     269             : // provides a list of _unique_ Entries
     270           0 : class HashedEntryList : public boost::ptr_set<HashedEntry> {};
     271             : 
     272             : // class NameTranslationEntry -----------------------------------------
     273             : 
     274           0 : class NameTranslationEntry : public HashedEntry
     275             : {// a fast compareble String and another String, which is used to get a substitution for a given String
     276             : protected:
     277             :     OUString                maTranslatedName;
     278             : public:
     279             :     inline                  NameTranslationEntry( const OString& rOriginalName, const OString& rTranslatedName );
     280             : 
     281             :     inline const OUString&  GetTranslation() const;
     282             : };
     283             : 
     284           0 : inline NameTranslationEntry::NameTranslationEntry( const OString& rOrg, const OString& rTrans )
     285             :     : HashedEntry(OStringToOUString(rOrg, RTL_TEXTENCODING_ASCII_US))
     286           0 :     , maTranslatedName(OStringToOUString(rTrans, RTL_TEXTENCODING_UTF8))
     287             : {
     288           0 : }
     289             : 
     290           0 : inline const OUString& NameTranslationEntry::GetTranslation() const
     291             : {
     292           0 :     return maTranslatedName;
     293             : }
     294             : 
     295             : // class NameTranslationList -----------------------------------------
     296             : 
     297           0 : class NameTranslationList : protected HashedEntryList
     298             : {   // contains a list of substitutes of strings for a given folder (as URL)
     299             :     // explanation of the circumstances see in remarks for Init();
     300             : protected:
     301             :     INetURLObject               maTransFile;    // URL of file with translation entries
     302             :     HashedEntry                 maHashedURL;    // for future purposes when dealing with a set of cached
     303             :                                                 //  NameTranslationLists
     304             : private:
     305             :     const OUString          maTransFileName;
     306             :     void                    Init();             // reads the translation file and fills the (internal) list
     307             : 
     308             : public:
     309             :                             NameTranslationList( const INetURLObject& rBaseURL );
     310             :                                             // rBaseURL: path to folder for which the translation of the entries
     311             :                                             //  should be done
     312             : 
     313             :     using HashedEntryList::operator==;
     314             :     using HashedEntryList::operator!=;
     315             :     inline bool operator       !=( const HashedEntry& rRef ) const;
     316             : 
     317             :     const OUString*             Translate( const OUString& rName ) const;
     318             :                                             // returns NULL, if rName can't be found
     319             : 
     320             :     inline const OUString&      GetTransTableFileName() const;
     321             :                                             // returns the name for the file, which contains the translation strings
     322             : };
     323             : 
     324           0 : inline const OUString& NameTranslationList::GetTransTableFileName() const
     325             : {
     326           0 :     return maTransFileName;
     327             : }
     328             : 
     329           0 : void NameTranslationList::Init()
     330             : {
     331             : // Tries to read the file ".nametranslation.table" in the base folder. Complete path/name is in maTransFile.
     332             : // Further on, the found entries in the section "TRANSLATIONNAMES" are used to replace names in the
     333             : // base folder by translated ones. The translation must be given in UTF8
     334             : // See examples of such a files in the samples-folder of an Office installation
     335             : 
     336             :     try
     337             :     {
     338           0 :         ::ucbhelper::Content aTestContent( maTransFile.GetMainURL( INetURLObject::NO_DECODE ), Reference< XCommandEnvironment >(), comphelper::getProcessComponentContext() );
     339             : 
     340           0 :         if( aTestContent.isDocument() )
     341             :         {
     342             :             // ... also tests the existence of maTransFile by throwing an Exception
     343           0 :             OUString        aFsysName( maTransFile.getFSysPath( INetURLObject::FSYS_DETECT ) );
     344           0 :             Config          aConfig( aFsysName );
     345             : 
     346           0 :             aConfig.SetGroup( OString("TRANSLATIONNAMES") );
     347             : 
     348           0 :             sal_uInt16          nKeyCnt = aConfig.GetKeyCount();
     349             : 
     350           0 :             for( sal_uInt16 nCnt = 0 ; nCnt < nKeyCnt ; ++nCnt )
     351           0 :                 insert( new NameTranslationEntry( aConfig.GetKeyName( nCnt ), aConfig.ReadKey( nCnt ) ) );
     352           0 :         }
     353             :     }
     354           0 :     catch( Exception const & ) {}
     355           0 : }
     356             : 
     357           0 : NameTranslationList::NameTranslationList( const INetURLObject& rBaseURL ):
     358             :     maTransFile( rBaseURL ),
     359             :     maHashedURL( rBaseURL ),
     360           0 :     maTransFileName( OUString(".nametranslation.table") )
     361             : {
     362           0 :     maTransFile.insertName( maTransFileName );
     363           0 :     Init();
     364           0 : }
     365             : 
     366           0 : inline bool NameTranslationList::operator !=( const HashedEntry& rRef ) const
     367             : {
     368           0 :     return maHashedURL != rRef;
     369             : }
     370             : 
     371           0 : const OUString* NameTranslationList::Translate( const OUString& rName ) const
     372             : {
     373           0 :     HashedEntry  aRef( rName );
     374           0 :     const NameTranslationEntry* pSearch = NULL;
     375           0 :     for( const_iterator it = begin(); it != end(); ++it )
     376           0 :         if( (*it) == aRef )
     377             :         {
     378           0 :             pSearch = static_cast<const NameTranslationEntry*>(&*it);
     379             :         }
     380             : 
     381           0 :     return pSearch ? &pSearch->GetTranslation() : NULL;
     382             : }
     383             : 
     384             : // class NameTranslator_Impl ------------------------------------------
     385             : 
     386             : // enables the user to get string substitutions (translations for the content) for a given folder
     387             : // see more explanations above in the description for NameTranslationList
     388             : class NameTranslator_Impl : public ::svt::IContentTitleTranslation
     389             : {
     390             : private:
     391             :     NameTranslationList*    mpActFolder;
     392             : public:
     393             :                             NameTranslator_Impl( const INetURLObject& rActualFolder );
     394             :                             virtual ~NameTranslator_Impl();
     395             : 
     396             :      // IContentTitleTranslation
     397             :     virtual sal_Bool            GetTranslation( const OUString& rOriginalName, OUString& rTranslatedName ) const SAL_OVERRIDE;
     398             : 
     399             :     void                    SetActualFolder( const INetURLObject& rActualFolder );
     400             :     const OUString*         GetTransTableFileName() const;
     401             :                                             // returns the name for the file, which contains the translation strings
     402             : };
     403             : 
     404             : 
     405             : //= SvtFileView_Impl
     406             : 
     407             : 
     408             : class SvtFileView_Impl  :public ::svt::IEnumerationResultHandler
     409             :                         ,public ITimeoutHandler
     410             : {
     411             : protected:
     412             :     SvtFileView*                mpAntiImpl;
     413             :     Link                        m_aSelectHandler;
     414             : 
     415             :     ::rtl::Reference< ::svt::FileViewContentEnumerator >
     416             :                                         m_pContentEnumerator;
     417             :     Link                                m_aCurrentAsyncActionHandler;
     418             :     ::osl::Condition                    m_aAsyncActionFinished;
     419             :     ::rtl::Reference< ::salhelper::Timer > m_pCancelAsyncTimer;
     420             :     ::svt::EnumerationResult            m_eAsyncActionResult;
     421             :     bool                                m_bRunningAsyncAction;
     422             :     bool                                m_bAsyncActionCancelled;
     423             : 
     424             : 
     425             : public:
     426             : 
     427             :     ::std::vector< SortingData_Impl* >  maContent;
     428             :     ::osl::Mutex                        maMutex;
     429             : 
     430             :     ViewTabListBox_Impl*    mpView;
     431             :     NameTranslator_Impl*    mpNameTrans;
     432             :     sal_uInt16              mnSortColumn;
     433             :     bool                    mbAscending     : 1;
     434             :     bool                    mbOnlyFolder    : 1;
     435             :     bool                    mbReplaceNames  : 1;    // translate folder names or display doc-title instead of file name
     436             :     sal_Int16               mnSuspendSelectCallback : 1;
     437             :     bool                    mbIsFirstResort : 1;
     438             : 
     439             :     IntlWrapper             aIntlWrapper;
     440             : 
     441             :     OUString                maViewURL;
     442             :     OUString                maAllFilter;
     443             :     OUString                maCurrentFilter;
     444             :     Image                   maFolderImage;
     445             :     Link                    maOpenDoneLink;
     446             :     Reference< XCommandEnvironment >    mxCmdEnv;
     447             : 
     448             :     SvtFileView_Impl( SvtFileView* pAntiImpl, Reference < XCommandEnvironment > xEnv,
     449             :                                               sal_Int16 nFlags,
     450             :                                               bool bOnlyFolder );
     451             :     virtual                ~SvtFileView_Impl();
     452             : 
     453             :     void                    Clear();
     454             : 
     455             :     FileViewResult          GetFolderContent_Impl(
     456             :         const OUString& rFolder,
     457             :         const FileViewAsyncAction* pAsyncDescriptor,
     458             :         const ::com::sun::star::uno::Sequence< OUString >& rBlackList = ::com::sun::star::uno::Sequence< OUString >() );
     459             : 
     460             :     FileViewResult          GetFolderContent_Impl(
     461             :         const FolderDescriptor& _rFolder,
     462             :         const FileViewAsyncAction* pAsyncDescriptor,
     463             :         const ::com::sun::star::uno::Sequence< OUString >& rBlackList = ::com::sun::star::uno::Sequence< OUString >());
     464             :     void                    FilterFolderContent_Impl( const OUString &rFilter );
     465             :     void                    CancelRunningAsyncAction();
     466             : 
     467             :     void                    OpenFolder_Impl();
     468             :     // #83004# -------
     469             :     void                        ReplaceTabWithString( OUString& aValue );
     470             :     void                    CreateDisplayText_Impl();
     471             :     void                    CreateVector_Impl( const Sequence < OUString > &rList );
     472             :     void                    SortFolderContent_Impl();
     473             : 
     474             :     void                    EntryRemoved( const OUString& rURL );
     475             :     void                    EntryRenamed( OUString& rURL,
     476             :                                           const OUString& rName );
     477             :     OUString                FolderInserted( const OUString& rURL,
     478             :                                             const OUString& rTitle );
     479             : 
     480             :     sal_uLong               GetEntryPos( const OUString& rURL );
     481             : 
     482             :     inline void             EnableContextMenu( bool bEnable );
     483             :     inline void             EnableDelete( bool bEnable );
     484             : 
     485             :     void                    Resort_Impl( sal_Int16 nColumn, bool bAscending );
     486             :     bool                    SearchNextEntry( sal_uInt32 &nIndex,
     487             :                                              const OUString& rTitle,
     488             :                                              bool bWrapAround );
     489             : 
     490             :     inline bool             EnableNameReplacing( bool bEnable = true ); // returns false, if action wasn't possible
     491             :     void                    SetActualFolder( const INetURLObject& rActualFolder );
     492             : 
     493             :     void                    SetSelectHandler( const Link& _rHdl );
     494             : 
     495             :     void                    InitSelection();
     496             :     void                    ResetCursor();
     497             : 
     498             :     inline void             EndEditing( bool _bCancel );
     499             : 
     500             : protected:
     501             :     DECL_LINK( SelectionMultiplexer, void* );
     502             : 
     503             : protected:
     504             :     // IEnumerationResultHandler overridables
     505             :     virtual void        enumerationDone( ::svt::EnumerationResult eResult ) SAL_OVERRIDE;
     506             :             void        implEnumerationSuccess();
     507             : 
     508             :     // ITimeoutHandler
     509             :     virtual void onTimeout( CallbackTimer* _pInstigator ) SAL_OVERRIDE;
     510             : };
     511             : 
     512           0 : inline void SvtFileView_Impl::EnableContextMenu( bool bEnable )
     513             : {
     514           0 :     mpView->EnableContextMenuHandling( bEnable );
     515           0 :     if( bEnable )
     516           0 :         mbReplaceNames = false;
     517           0 : }
     518             : 
     519           0 : inline void SvtFileView_Impl::EnableDelete( bool bEnable )
     520             : {
     521           0 :     mpView->EnableDelete( bEnable );
     522           0 :     if( bEnable )
     523           0 :         mbReplaceNames = false;
     524           0 : }
     525             : 
     526           0 : inline bool SvtFileView_Impl::EnableNameReplacing( bool bEnable )
     527             : {
     528           0 :     mpView->EnableRename( bEnable );
     529             : 
     530             :     bool bRet;
     531           0 :     if( mpView->IsDeleteOrContextMenuEnabled() )
     532             :     {
     533             :         DBG_ASSERT( !mbReplaceNames, "SvtFileView_Impl::EnableNameReplacing(): state should be not possible!" );
     534           0 :         bRet = !bEnable; // only for enabling this is an unsuccessful result
     535             :     }
     536             :     else
     537             :     {
     538           0 :         mbReplaceNames = bEnable;
     539           0 :         bRet = true;
     540             :     }
     541             : 
     542           0 :     return bRet;
     543             : }
     544             : 
     545           0 : inline void SvtFileView_Impl::EndEditing( bool _bCancel )
     546             : {
     547           0 :     if ( mpView->IsEditingActive() )
     548           0 :         mpView->EndEditing( _bCancel != false );
     549           0 : }
     550             : 
     551             : // functions -------------------------------------------------------------
     552             : 
     553           0 : OUString CreateExactSizeText( sal_Int64 nSize )
     554             : {
     555           0 :     double fSize( ( double ) nSize );
     556             :     int nDec;
     557             : 
     558           0 :     long nMega = 1024 * 1024;
     559           0 :     long nGiga = nMega * 1024;
     560             : 
     561           0 :     OUString aUnitStr(' ');
     562             : 
     563           0 :     if ( nSize < 10000 )
     564             :     {
     565           0 :         aUnitStr += SVT_RESSTR(STR_SVT_BYTES );
     566           0 :         nDec = 0;
     567             :     }
     568           0 :     else if ( nSize < nMega )
     569             :     {
     570           0 :         fSize /= 1024;
     571           0 :         aUnitStr += SVT_RESSTR(STR_SVT_KB);
     572           0 :         nDec = 1;
     573             :     }
     574           0 :     else if ( nSize < nGiga )
     575             :     {
     576           0 :         fSize /= nMega;
     577           0 :         aUnitStr += SVT_RESSTR(STR_SVT_MB);
     578           0 :         nDec = 2;
     579             :     }
     580             :     else
     581             :     {
     582           0 :         fSize /= nGiga;
     583           0 :         aUnitStr += SVT_RESSTR(STR_SVT_GB);
     584           0 :         nDec = 3;
     585             :     }
     586             : 
     587             :     OUString aSizeStr( ::rtl::math::doubleToUString( fSize,
     588             :                 rtl_math_StringFormat_F, nDec,
     589           0 :                 SvtSysLocale().GetLocaleData().getNumDecimalSep()[0]) );
     590           0 :     aSizeStr += aUnitStr;
     591             : 
     592           0 :     return aSizeStr;
     593             : }
     594             : 
     595             : 
     596             : // class ViewTabListBox_Impl ---------------------------------------------
     597             : 
     598             : 
     599           0 : ViewTabListBox_Impl::ViewTabListBox_Impl( Window* pParentWin,
     600             :                                           SvtFileView_Impl* pParent,
     601             :                                           sal_Int16 nFlags ) :
     602             : 
     603             :     SvHeaderTabListBox( pParentWin, WB_TABSTOP ),
     604             : 
     605             :     mpHeaderBar         ( NULL ),
     606             :     mpParent            ( pParent ),
     607             :     msAccessibleDescText( SVT_RESSTR(STR_SVT_ACC_DESC_FILEVIEW) ),
     608             :     msFolder            ( SVT_RESSTR(STR_SVT_ACC_DESC_FOLDER) ),
     609             :     msFile              ( SVT_RESSTR(STR_SVT_ACC_DESC_FILE) ),
     610             :     mnSearchIndex       ( 0 ),
     611             :     mbResizeDisabled    ( false ),
     612             :     mbAutoResize        ( false ),
     613             :     mbEnableDelete      ( false ),
     614             :     mbEnableRename      ( true ),
     615           0 :     mbShowHeader        ( (nFlags & FILEVIEW_SHOW_NONE) == 0 )
     616             : {
     617           0 :     Size aBoxSize = pParentWin->GetSizePixel();
     618           0 :     mpHeaderBar = new HeaderBar( pParentWin, WB_BUTTONSTYLE | WB_BOTTOMBORDER );
     619           0 :     mpHeaderBar->SetPosSizePixel( Point( 0, 0 ), mpHeaderBar->CalcWindowSizePixel() );
     620             : 
     621           0 :     HeaderBarItemBits nBits = ( HIB_LEFT | HIB_VCENTER | HIB_CLICKABLE );
     622           0 :     if (nFlags & FILEVIEW_SHOW_ONLYTITLE)
     623             :     {
     624           0 :         long pTabs[] = { 2, 20, 600 };
     625           0 :         SetTabs(&pTabs[0], MAP_PIXEL);
     626             : 
     627           0 :         mpHeaderBar->InsertItem(COLUMN_TITLE, SVT_RESSTR(STR_SVT_FILEVIEW_COLUMN_TITLE), 600, nBits | HIB_UPARROW);
     628             :     }
     629             :     else
     630             :     {
     631           0 :         long pTabs[] = { 5, 20, 180, 320, 400, 600 };
     632           0 :         SetTabs(&pTabs[0], MAP_PIXEL);
     633           0 :         SetTabJustify(2, AdjustRight); // column "Size"
     634             : 
     635           0 :         mpHeaderBar->InsertItem(COLUMN_TITLE, SVT_RESSTR(STR_SVT_FILEVIEW_COLUMN_TITLE), 180, nBits | HIB_UPARROW);
     636           0 :         mpHeaderBar->InsertItem(COLUMN_TYPE, SVT_RESSTR(STR_SVT_FILEVIEW_COLUMN_TYPE), 140, nBits);
     637           0 :         mpHeaderBar->InsertItem(COLUMN_SIZE, SVT_RESSTR(STR_SVT_FILEVIEW_COLUMN_SIZE), 80, nBits);
     638           0 :         mpHeaderBar->InsertItem(COLUMN_DATE, SVT_RESSTR(STR_SVT_FILEVIEW_COLUMN_DATE), 500, nBits);
     639             :     }
     640             : 
     641           0 :     Size aHeadSize = mpHeaderBar->GetSizePixel();
     642           0 :     SetPosSizePixel( Point( 0, aHeadSize.Height() ),
     643           0 :                      Size( aBoxSize.Width(), aBoxSize.Height() - aHeadSize.Height() ) );
     644           0 :     InitHeaderBar( mpHeaderBar );
     645           0 :     SetHighlightRange();
     646           0 :     SetEntryHeight( ROW_HEIGHT );
     647           0 :     if (nFlags & FILEVIEW_MULTISELECTION)
     648           0 :         SetSelectionMode( MULTIPLE_SELECTION );
     649             : 
     650           0 :     Show();
     651           0 :     if( mbShowHeader )
     652           0 :         mpHeaderBar->Show();
     653             : 
     654           0 :     maResetQuickSearch.SetTimeout( QUICK_SEARCH_TIMEOUT );
     655           0 :     maResetQuickSearch.SetTimeoutHdl( LINK( this, ViewTabListBox_Impl, ResetQuickSearch_Impl ) );
     656             : 
     657           0 :     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
     658             :     Reference< XInteractionHandler > xInteractionHandler(
     659           0 :         InteractionHandler::createWithParent(xContext, 0), UNO_QUERY_THROW );
     660             : 
     661           0 :     mxCmdEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, Reference< XProgressHandler >() );
     662             : 
     663           0 :     EnableContextMenuHandling();
     664           0 : }
     665             : 
     666             : 
     667             : 
     668           0 : ViewTabListBox_Impl::~ViewTabListBox_Impl()
     669             : {
     670           0 :     maResetQuickSearch.Stop();
     671             : 
     672           0 :     delete mpHeaderBar;
     673           0 : }
     674             : 
     675             : 
     676             : 
     677           0 : IMPL_LINK_NOARG(ViewTabListBox_Impl, ResetQuickSearch_Impl)
     678             : {
     679           0 :     ::osl::MutexGuard aGuard( maMutex );
     680             : 
     681           0 :     maQuickSearchText = "";
     682           0 :     mnSearchIndex = 0;
     683             : 
     684           0 :     return 0;
     685             : }
     686             : 
     687             : 
     688             : 
     689           0 : void ViewTabListBox_Impl::Resize()
     690             : {
     691           0 :     SvTabListBox::Resize();
     692           0 :     Size aBoxSize = Control::GetParent()->GetOutputSizePixel();
     693             : 
     694           0 :     if ( mbResizeDisabled || !aBoxSize.Width() )
     695           0 :         return;
     696             : 
     697           0 :     Size aBarSize;
     698           0 :     if ( mbShowHeader )
     699             :     {
     700           0 :         aBarSize = mpHeaderBar->GetSizePixel();
     701           0 :         aBarSize.Width() = mbAutoResize ? aBoxSize.Width() : GetSizePixel().Width();
     702           0 :         mpHeaderBar->SetSizePixel( aBarSize );
     703             :     }
     704             : 
     705           0 :     if ( mbAutoResize )
     706             :     {
     707           0 :         mbResizeDisabled = true;
     708           0 :         SetPosSizePixel( Point( 0, aBarSize.Height() ),
     709           0 :                         Size( aBoxSize.Width(), aBoxSize.Height() - aBarSize.Height() ) );
     710           0 :         mbResizeDisabled = false;
     711             :     }
     712             : }
     713             : 
     714             : 
     715             : 
     716           0 : void ViewTabListBox_Impl::KeyInput( const KeyEvent& rKEvt )
     717             : {
     718           0 :     bool bHandled = false;
     719             : 
     720           0 :     const KeyCode& rKeyCode = rKEvt.GetKeyCode();
     721           0 :     if ( 0 == rKeyCode.GetModifier() )
     722             :     {
     723           0 :         if ( rKeyCode.GetCode() == KEY_RETURN )
     724             :         {
     725           0 :             ResetQuickSearch_Impl( NULL );
     726           0 :             GetDoubleClickHdl().Call( this );
     727           0 :             bHandled = true;
     728             :         }
     729           0 :         else if ( ( rKeyCode.GetCode() == KEY_DELETE ) &&
     730             :                   mbEnableDelete )
     731             :         {
     732           0 :             ResetQuickSearch_Impl( NULL );
     733           0 :             DeleteEntries();
     734           0 :             bHandled = true;
     735             :         }
     736           0 :         else if ( ( rKEvt.GetKeyCode().GetGroup() == KEYGROUP_NUM ) ||
     737           0 :                   ( rKEvt.GetKeyCode().GetGroup() == KEYGROUP_ALPHA ) )
     738             :         {
     739           0 :             DoQuickSearch( rKEvt.GetCharCode() );
     740           0 :             bHandled = true;
     741             :         }
     742             :     }
     743             : 
     744           0 :     if ( !bHandled )
     745             :     {
     746           0 :         ResetQuickSearch_Impl( NULL );
     747           0 :         SvHeaderTabListBox::KeyInput( rKEvt );
     748             :     }
     749           0 : }
     750             : 
     751             : 
     752             : 
     753           0 : PopupMenu* ViewTabListBox_Impl::CreateContextMenu( void )
     754             : {
     755           0 :     bool bEnableDelete = mbEnableDelete;
     756           0 :     bool bEnableRename = mbEnableRename;
     757             : 
     758           0 :     if ( bEnableDelete || bEnableRename )
     759             :     {
     760           0 :         sal_Int32 nSelectedEntries = GetSelectionCount();
     761           0 :         bEnableDelete &= nSelectedEntries > 0;
     762           0 :         bEnableRename &= nSelectedEntries == 1;
     763             :     }
     764             : 
     765           0 :     if ( bEnableDelete || bEnableRename )
     766             :     {
     767           0 :         SvTreeListEntry* pEntry = FirstSelected();
     768           0 :         while ( pEntry )
     769             :         {
     770           0 :             ::ucbhelper::Content aCnt;
     771             :             try
     772             :             {
     773             :                 OUString aURL( static_cast< SvtContentEntry * >(
     774           0 :                     pEntry->GetUserData() )->maURL );
     775           0 :                 aCnt = ::ucbhelper::Content( aURL, mxCmdEnv, comphelper::getProcessComponentContext() );
     776             :             }
     777           0 :             catch( Exception const & )
     778             :             {
     779           0 :                 bEnableDelete = bEnableRename = false;
     780             :             }
     781             : 
     782           0 :             if ( bEnableDelete )
     783             :             {
     784             :                 try
     785             :                 {
     786           0 :                     Reference< XCommandInfo > aCommands = aCnt.getCommands();
     787           0 :                     if ( aCommands.is() )
     788             :                         bEnableDelete
     789           0 :                             = aCommands->hasCommandByName(
     790           0 :                                 OUString( "delete" ) );
     791             :                     else
     792           0 :                         bEnableDelete = false;
     793             :                 }
     794           0 :                 catch( Exception const & )
     795             :                 {
     796           0 :                     bEnableDelete = false;
     797             :                 }
     798             :             }
     799             : 
     800           0 :             if ( bEnableRename )
     801             :             {
     802             :                 try
     803             :                 {
     804           0 :                     Reference< XPropertySetInfo > aProps = aCnt.getProperties();
     805           0 :                     if ( aProps.is() )
     806             :                     {
     807             :                         Property aProp
     808           0 :                             = aProps->getPropertyByName(
     809           0 :                                 OUString( "Title" ) );
     810             :                         bEnableRename
     811           0 :                             = !( aProp.Attributes & PropertyAttribute::READONLY );
     812             :                     }
     813             :                     else
     814           0 :                         bEnableRename = false;
     815             :                 }
     816           0 :                 catch( Exception const & )
     817             :                 {
     818           0 :                     bEnableRename = false;
     819             :                 }
     820             :             }
     821             : 
     822           0 :             pEntry = ( bEnableDelete || bEnableRename )
     823           0 :                 ? NextSelected( pEntry )
     824           0 :                 : 0;
     825           0 :         }
     826             :     }
     827             : 
     828           0 :     if ( bEnableDelete || bEnableRename )
     829             :     {
     830             :         PopupMenu * pRet
     831           0 :             = new PopupMenu( SvtResId( RID_FILEVIEW_CONTEXTMENU ) );
     832           0 :         pRet->EnableItem( MID_FILEVIEW_DELETE, bEnableDelete );
     833           0 :         pRet->EnableItem( MID_FILEVIEW_RENAME, bEnableRename );
     834           0 :         pRet->RemoveDisabledEntries( true, true );
     835           0 :         return pRet;
     836             :     }
     837             : 
     838           0 :     return NULL;
     839             : }
     840             : 
     841             : 
     842             : 
     843           0 : void ViewTabListBox_Impl::ExcecuteContextMenuAction( sal_uInt16 nSelectedPopupEntry )
     844             : {
     845           0 :     switch ( nSelectedPopupEntry )
     846             :     {
     847             :         case MID_FILEVIEW_DELETE :
     848           0 :             DeleteEntries();
     849           0 :             break;
     850             : 
     851             :         case MID_FILEVIEW_RENAME :
     852           0 :             EditEntry( FirstSelected() );
     853           0 :             break;
     854             :     }
     855           0 : }
     856             : 
     857             : 
     858             : 
     859           0 : void ViewTabListBox_Impl::ClearAll()
     860             : {
     861           0 :     for ( sal_uInt16 i = 0; i < GetEntryCount(); ++i )
     862           0 :         delete (SvtContentEntry*)GetEntry(i)->GetUserData();
     863           0 :     Clear();
     864           0 : }
     865             : 
     866             : 
     867           0 : void ViewTabListBox_Impl::DeleteEntries()
     868             : {
     869           0 :     short eResult = svtools::QUERYDELETE_YES;
     870           0 :     SvTreeListEntry* pEntry = FirstSelected();
     871           0 :     OUString aURL;
     872             : 
     873           0 :     OString sDialogPosition;
     874           0 :     while ( pEntry && ( eResult != svtools::QUERYDELETE_CANCEL ) )
     875             :     {
     876           0 :         SvTreeListEntry *pCurEntry = pEntry;
     877           0 :         pEntry = NextSelected( pEntry );
     878             : 
     879           0 :         if ( pCurEntry->GetUserData() )
     880           0 :             aURL = ( (SvtContentEntry*)pCurEntry->GetUserData() )->maURL;
     881             : 
     882           0 :         if ( aURL.isEmpty() )
     883           0 :             continue;
     884             : 
     885           0 :         bool canDelete = true;
     886             :         try
     887             :         {
     888           0 :             ::ucbhelper::Content aCnt( aURL, mxCmdEnv, comphelper::getProcessComponentContext() );
     889           0 :             Reference< XCommandInfo > aCommands = aCnt.getCommands();
     890           0 :             if ( aCommands.is() )
     891             :                 canDelete
     892           0 :                     = aCommands->hasCommandByName(
     893           0 :                         OUString( "delete" ) );
     894             :             else
     895           0 :                 canDelete = false;
     896             :         }
     897           0 :         catch( Exception const & )
     898             :         {
     899           0 :             canDelete = false;
     900             :         }
     901             : 
     902           0 :         if (!canDelete)
     903           0 :             continue; // process next entry
     904             : 
     905           0 :         if ( eResult != svtools::QUERYDELETE_ALL )
     906             :         {
     907           0 :             INetURLObject aObj( aURL );
     908           0 :             svtools::QueryDeleteDlg_Impl aDlg( NULL, aObj.GetName( INetURLObject::DECODE_WITH_CHARSET ) );
     909           0 :             if ( sDialogPosition.getLength() )
     910           0 :                 aDlg.SetWindowState( sDialogPosition );
     911             : 
     912           0 :             if ( GetSelectionCount() > 1 )
     913           0 :                 aDlg.EnableAllButton();
     914             : 
     915           0 :             eResult = aDlg.Execute();
     916             : 
     917           0 :             sDialogPosition = aDlg.GetWindowState( );
     918             :         }
     919             : 
     920           0 :         if ( ( eResult == svtools::QUERYDELETE_ALL ) ||
     921             :              ( eResult == svtools::QUERYDELETE_YES ) )
     922             :         {
     923           0 :             if ( Kill( aURL ) )
     924             :             {
     925           0 :                 delete (SvtContentEntry*)pCurEntry->GetUserData();
     926           0 :                 GetModel()->Remove( pCurEntry );
     927           0 :                 mpParent->EntryRemoved( aURL );
     928             :             }
     929             :         }
     930           0 :     }
     931           0 : }
     932             : 
     933             : 
     934           0 : bool ViewTabListBox_Impl::EditedEntry( SvTreeListEntry* pEntry,
     935             :                                  const OUString& rNewText )
     936             : {
     937           0 :     bool bRet = false;
     938             : 
     939           0 :     OUString aURL;
     940           0 :     SvtContentEntry* pData = (SvtContentEntry*)pEntry->GetUserData();
     941             : 
     942           0 :     if ( pData )
     943           0 :         aURL = pData->maURL;
     944             : 
     945           0 :     if ( aURL.isEmpty() )
     946           0 :         return bRet;
     947             : 
     948             :     try
     949             :     {
     950           0 :         OUString aPropName( "Title" );
     951           0 :         bool canRename = true;
     952           0 :         ::ucbhelper::Content aContent( aURL, mxCmdEnv, comphelper::getProcessComponentContext() );
     953             : 
     954             :         try
     955             :         {
     956           0 :             Reference< XPropertySetInfo > aProps = aContent.getProperties();
     957           0 :             if ( aProps.is() )
     958             :             {
     959           0 :                 Property aProp = aProps->getPropertyByName( aPropName );
     960           0 :                 canRename = !( aProp.Attributes & PropertyAttribute::READONLY );
     961             :             }
     962             :             else
     963             :             {
     964           0 :                 canRename = false;
     965           0 :             }
     966             :         }
     967           0 :         catch ( Exception const & )
     968             :         {
     969           0 :             canRename = false;
     970             :         }
     971             : 
     972           0 :         if ( canRename )
     973             :         {
     974           0 :             Any aValue;
     975           0 :             aValue <<= rNewText;
     976           0 :             aContent.setPropertyValue( aPropName, aValue );
     977           0 :             mpParent->EntryRenamed( aURL, rNewText );
     978             : 
     979           0 :             if (pData)
     980           0 :                 pData->maURL = aURL;
     981             : 
     982           0 :             pEntry->SetUserData( pData );
     983             : 
     984           0 :             bRet = true;
     985           0 :         }
     986             :     }
     987           0 :     catch( Exception const & )
     988             :     {
     989             :     }
     990             : 
     991           0 :     return bRet;
     992             : }
     993             : 
     994             : 
     995           0 : void ViewTabListBox_Impl::DoQuickSearch( const sal_Unicode& rChar )
     996             : {
     997           0 :     ::osl::MutexGuard aGuard( maMutex );
     998             : 
     999           0 :     maResetQuickSearch.Stop();
    1000             : 
    1001           0 :     OUString    aLastText = maQuickSearchText;
    1002           0 :     sal_uInt32  aLastPos = mnSearchIndex;
    1003             : 
    1004           0 :     maQuickSearchText += OUString(rChar).toAsciiLowerCase();
    1005             : 
    1006           0 :     bool bFound = mpParent->SearchNextEntry( mnSearchIndex, maQuickSearchText, false );
    1007             : 
    1008           0 :     if ( !bFound && ( aLastText.getLength() == 1 ) &&
    1009           0 :          ( aLastText == OUString(rChar) ) )
    1010             :     {
    1011           0 :         mnSearchIndex = aLastPos + 1;
    1012           0 :         maQuickSearchText = aLastText;
    1013           0 :         bFound = mpParent->SearchNextEntry( mnSearchIndex, maQuickSearchText, true );
    1014             :     }
    1015             : 
    1016           0 :     if ( bFound )
    1017             :     {
    1018           0 :         SvTreeListEntry* pEntry = GetEntry( mnSearchIndex );
    1019           0 :         if ( pEntry )
    1020             :         {
    1021           0 :             SelectAll( false );
    1022           0 :             Select( pEntry );
    1023           0 :             SetCurEntry( pEntry );
    1024           0 :             MakeVisible( pEntry );
    1025             :         }
    1026             :     }
    1027             : 
    1028           0 :     maResetQuickSearch.Start();
    1029           0 : }
    1030             : 
    1031             : 
    1032           0 : bool ViewTabListBox_Impl::DoubleClickHdl()
    1033             : {
    1034           0 :     SvHeaderTabListBox::DoubleClickHdl();
    1035           0 :     return false;
    1036             :         // this means "do no additional handling". Especially this means that the SvImpLBox does not
    1037             :         // recognize that the entry at the double click position change after the handler call (which is
    1038             :         // the case if in the handler, our content was replaced)
    1039             :         // If it _would_ recognize this change, it would take this as a reason to select the entry, again
    1040             :         // - which is not what in the case of content replace
    1041             :         // (I really doubt that this behaviour of the SvImpLBox does make any sense at all, but
    1042             :         // who knows ...)
    1043             : }
    1044             : 
    1045           0 : OUString ViewTabListBox_Impl::GetAccessibleObjectDescription( ::svt::AccessibleBrowseBoxObjType _eType, sal_Int32 _nPos ) const
    1046             : {
    1047           0 :     OUString sRet = SvHeaderTabListBox::GetAccessibleObjectDescription( _eType, _nPos );
    1048           0 :     if ( ::svt::BBTYPE_TABLECELL == _eType )
    1049             :     {
    1050           0 :         sal_Int32 nRow = -1;
    1051           0 :         const sal_uInt16 nColumnCount = GetColumnCount();
    1052           0 :         if (nColumnCount > 0)
    1053           0 :             nRow = _nPos / nColumnCount;
    1054           0 :         SvTreeListEntry* pEntry = GetEntry( nRow );
    1055           0 :         if ( pEntry )
    1056             :         {
    1057           0 :             SvtContentEntry* pData = (SvtContentEntry*)pEntry->GetUserData();
    1058           0 :             if ( pData )
    1059             :             {
    1060           0 :                 const OUString sVar1( "%1" );
    1061           0 :                 const OUString sVar2( "%2" );
    1062           0 :                 OUString aText( msAccessibleDescText );
    1063           0 :                 aText = aText.replaceAll( sVar1, pData->mbIsFolder ? msFolder : msFile );
    1064           0 :                 aText = aText.replaceAll( sVar2, pData->maURL );
    1065           0 :                 sRet += aText;
    1066             :             }
    1067             :         }
    1068             :     }
    1069             : 
    1070           0 :     return sRet;
    1071             : }
    1072             : 
    1073             : 
    1074           0 : bool ViewTabListBox_Impl::Kill( const OUString& rContent )
    1075             : {
    1076           0 :     bool bRet = true;
    1077             : 
    1078             :     try
    1079             :     {
    1080           0 :         ::ucbhelper::Content aCnt( rContent, mxCmdEnv, comphelper::getProcessComponentContext() );
    1081           0 :         aCnt.executeCommand( OUString( "delete" ), makeAny( sal_Bool( sal_True ) ) );
    1082             :     }
    1083           0 :     catch( ::com::sun::star::ucb::CommandAbortedException const & )
    1084             :     {
    1085             :         DBG_WARNING( "CommandAbortedException" );
    1086           0 :         bRet = false;
    1087             :     }
    1088           0 :     catch( Exception const & )
    1089             :     {
    1090             :         DBG_WARNING( "Any other exception" );
    1091           0 :         bRet = false;
    1092             :     }
    1093             : 
    1094           0 :     return bRet;
    1095             : }
    1096             : 
    1097             : 
    1098             : 
    1099             : 
    1100             : 
    1101             : // class SvtFileView -----------------------------------------------------
    1102             : 
    1103             : 
    1104           0 : SvtFileView::SvtFileView( Window* pParent, const ResId& rResId,
    1105             :                           bool bOnlyFolder, bool bMultiSelection ) :
    1106             : 
    1107           0 :     Control( pParent, rResId )
    1108             : {
    1109           0 :     sal_Int8 nFlags = 0;
    1110           0 :     if ( bOnlyFolder )
    1111           0 :         nFlags |= FILEVIEW_ONLYFOLDER;
    1112           0 :     if ( bMultiSelection )
    1113           0 :         nFlags |= FILEVIEW_MULTISELECTION;
    1114             : 
    1115           0 :     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
    1116             :     Reference< XInteractionHandler > xInteractionHandler(
    1117           0 :         InteractionHandler::createWithParent(xContext, 0), UNO_QUERY_THROW );
    1118           0 :     Reference < XCommandEnvironment > xCmdEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, Reference< XProgressHandler >() );
    1119             : 
    1120           0 :     mpImp = new SvtFileView_Impl( this, xCmdEnv, nFlags, bOnlyFolder );
    1121           0 :     mpImp->mpView->ForbidEmptyText();
    1122           0 :     SetSortColumn( true );
    1123             : 
    1124           0 :     HeaderBar* pHeaderBar = mpImp->mpView->GetHeaderBar();
    1125           0 :     pHeaderBar->SetSelectHdl( LINK( this, SvtFileView, HeaderSelect_Impl ) );
    1126           0 :     pHeaderBar->SetEndDragHdl( LINK( this, SvtFileView, HeaderEndDrag_Impl ) );
    1127           0 : }
    1128             : 
    1129           0 : SvtFileView::SvtFileView( Window* pParent, const ResId& rResId, sal_uInt8 nFlags ) :
    1130             : 
    1131           0 :     Control( pParent, rResId )
    1132             : {
    1133           0 :     Reference< XComponentContext > xContext = ::comphelper::getProcessComponentContext();
    1134             :     Reference< XInteractionHandler > xInteractionHandler(
    1135           0 :         InteractionHandler::createWithParent(xContext, 0), UNO_QUERY_THROW );
    1136           0 :     Reference < XCommandEnvironment > xCmdEnv = new ::ucbhelper::CommandEnvironment( xInteractionHandler, Reference< XProgressHandler >() );
    1137             : 
    1138           0 :     mpImp = new SvtFileView_Impl( this, xCmdEnv, nFlags, nFlags & FILEVIEW_ONLYFOLDER );
    1139             : 
    1140           0 :     SetSortColumn( (nFlags & FILEVIEW_SHOW_NONE) == 0 );
    1141             : 
    1142           0 :     HeaderBar *pHeaderBar = mpImp->mpView->GetHeaderBar();
    1143           0 :     pHeaderBar->SetSelectHdl( LINK( this, SvtFileView, HeaderSelect_Impl ) );
    1144           0 :     pHeaderBar->SetEndDragHdl( LINK( this, SvtFileView, HeaderEndDrag_Impl ) );
    1145           0 : }
    1146             : 
    1147             : 
    1148             : 
    1149           0 : SvtFileView::~SvtFileView()
    1150             : {
    1151             :     // use temp pointer to prevent access of deleted member (GetFocus())
    1152           0 :     SvtFileView_Impl* pTemp = mpImp;
    1153           0 :     mpImp = NULL;
    1154           0 :     delete pTemp;
    1155           0 : }
    1156             : 
    1157             : 
    1158             : 
    1159           0 : OUString SvtFileView::GetURL( SvTreeListEntry* pEntry ) const
    1160             : {
    1161           0 :     OUString aURL;
    1162           0 :     if ( pEntry && pEntry->GetUserData() )
    1163           0 :         aURL = ( (SvtContentEntry*)pEntry->GetUserData() )->maURL;
    1164           0 :     return aURL;
    1165             : }
    1166             : 
    1167             : 
    1168             : 
    1169           0 : OUString SvtFileView::GetCurrentURL() const
    1170             : {
    1171           0 :     OUString aURL;
    1172           0 :     SvTreeListEntry* pEntry = mpImp->mpView->FirstSelected();
    1173           0 :     if ( pEntry && pEntry->GetUserData() )
    1174           0 :         aURL = ( (SvtContentEntry*)pEntry->GetUserData() )->maURL;
    1175           0 :     return aURL;
    1176             : }
    1177             : 
    1178             : 
    1179           0 : void SvtFileView::CreatedFolder( const OUString& rUrl, const OUString& rNewFolder )
    1180             : {
    1181           0 :     OUString sEntry = mpImp->FolderInserted( rUrl, rNewFolder );
    1182           0 :     SvTreeListEntry* pEntry = mpImp->mpView->InsertEntry( sEntry, mpImp->maFolderImage, mpImp->maFolderImage );
    1183           0 :     SvtContentEntry* pUserData = new SvtContentEntry( rUrl, true );
    1184           0 :     pEntry->SetUserData( pUserData );
    1185           0 :     mpImp->mpView->MakeVisible( pEntry );
    1186           0 : }
    1187             : 
    1188             : 
    1189             : 
    1190           0 : FileViewResult SvtFileView::PreviousLevel( const FileViewAsyncAction* pAsyncDescriptor )
    1191             : {
    1192           0 :     FileViewResult eResult = eFailure;
    1193             : 
    1194           0 :     OUString sParentURL;
    1195           0 :     if ( GetParentURL( sParentURL ) )
    1196           0 :         eResult = Initialize( sParentURL, mpImp->maCurrentFilter, pAsyncDescriptor, mpBlackList );
    1197             : 
    1198           0 :     return eResult;
    1199             : }
    1200             : 
    1201             : 
    1202             : 
    1203           0 : bool SvtFileView::GetParentURL( OUString& rParentURL ) const
    1204             : {
    1205           0 :     bool bRet = false;
    1206             :     try
    1207             :     {
    1208           0 :         ::ucbhelper::Content aCnt( mpImp->maViewURL, mpImp->mxCmdEnv, comphelper::getProcessComponentContext() );
    1209           0 :         Reference< XContent > xContent( aCnt.get() );
    1210           0 :         Reference< com::sun::star::container::XChild > xChild( xContent, UNO_QUERY );
    1211           0 :         if ( xChild.is() )
    1212             :         {
    1213           0 :             Reference< XContent > xParent( xChild->getParent(), UNO_QUERY );
    1214           0 :             if ( xParent.is() )
    1215             :             {
    1216           0 :                 rParentURL = xParent->getIdentifier()->getContentIdentifier();
    1217           0 :                 bRet = !rParentURL.isEmpty() && rParentURL != mpImp->maViewURL;
    1218           0 :             }
    1219           0 :         }
    1220             :     }
    1221           0 :     catch( Exception const & )
    1222             :     {
    1223             :         // perhaps an unknown url protocol (e.g. "private:newdoc")
    1224             :     }
    1225             : 
    1226           0 :     return bRet;
    1227             : }
    1228             : 
    1229             : 
    1230             : 
    1231           0 : const OString& SvtFileView::GetHelpId( ) const
    1232             : {
    1233           0 :     return mpImp->mpView->GetHelpId( );
    1234             : }
    1235             : 
    1236             : 
    1237             : 
    1238           0 : void SvtFileView::SetHelpId( const OString& rHelpId )
    1239             : {
    1240           0 :     mpImp->mpView->SetHelpId( rHelpId );
    1241           0 : }
    1242             : 
    1243             : 
    1244             : 
    1245           0 : void SvtFileView::SetSizePixel( const Size& rNewSize )
    1246             : {
    1247           0 :     Control::SetSizePixel( rNewSize );
    1248           0 :     mpImp->mpView->SetSizePixel( rNewSize );
    1249           0 : }
    1250             : 
    1251             : 
    1252             : 
    1253           0 : void SvtFileView::SetPosSizePixel( const Point& rNewPos, const Size& rNewSize )
    1254             : {
    1255           0 :     SetPosPixel( rNewPos );
    1256           0 :     SetSizePixel( rNewSize );
    1257           0 : }
    1258             : 
    1259             : 
    1260           0 : bool SvtFileView::Initialize( const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XContent>& _xContent, const OUString& rFilter  )
    1261             : {
    1262           0 :     WaitObject aWaitCursor( this );
    1263             : 
    1264           0 :     mpImp->Clear();
    1265           0 :     ::ucbhelper::Content aContent(_xContent, mpImp->mxCmdEnv, comphelper::getProcessComponentContext() );
    1266           0 :     FileViewResult eResult = mpImp->GetFolderContent_Impl( FolderDescriptor( aContent ), NULL );
    1267             :     OSL_ENSURE( eResult != eStillRunning, "SvtFileView::Initialize: this was expected to be synchronous!" );
    1268           0 :     if ( eResult != eSuccess )
    1269           0 :         return false;
    1270             : 
    1271           0 :     mpImp->FilterFolderContent_Impl( rFilter );
    1272             : 
    1273           0 :     mpImp->SortFolderContent_Impl(); // possibly not necessary!!!!!!!!!!
    1274           0 :     mpImp->CreateDisplayText_Impl();
    1275           0 :     mpImp->OpenFolder_Impl();
    1276             : 
    1277           0 :     mpImp->maOpenDoneLink.Call( this );
    1278           0 :     return true;
    1279             : }
    1280             : 
    1281             : 
    1282           0 : FileViewResult SvtFileView::Initialize(
    1283             :     const OUString& rURL,
    1284             :     const OUString& rFilter,
    1285             :     const FileViewAsyncAction* pAsyncDescriptor,
    1286             :     const ::com::sun::star::uno::Sequence< OUString >& rBlackList  )
    1287             : {
    1288           0 :     WaitObject aWaitCursor( this );
    1289           0 :     mpBlackList = rBlackList;
    1290             : 
    1291           0 :     OUString sPushURL( mpImp->maViewURL );
    1292             : 
    1293           0 :     mpImp->maViewURL = rURL;
    1294           0 :     FileViewResult eResult = ExecuteFilter( rFilter, pAsyncDescriptor );
    1295           0 :     switch ( eResult )
    1296             :     {
    1297             :     case eFailure:
    1298             :     case eTimeout:
    1299           0 :         mpImp->maViewURL = sPushURL;
    1300           0 :         return eResult;
    1301             : 
    1302             :     case eStillRunning:
    1303             :         OSL_ENSURE( pAsyncDescriptor, "SvtFileView::Initialize: we told it to read synchronously!" );
    1304             :     case eSuccess:
    1305           0 :         return eResult;
    1306             :     }
    1307             : 
    1308             :     OSL_FAIL( "SvtFileView::Initialize: unreachable!" );
    1309           0 :     return eFailure;
    1310             : }
    1311             : 
    1312             : 
    1313           0 : FileViewResult SvtFileView::Initialize(
    1314             :     const OUString& rURL,
    1315             :     const OUString& rFilter,
    1316             :     const FileViewAsyncAction* pAsyncDescriptor )
    1317             : {
    1318           0 :     return Initialize( rURL, rFilter, pAsyncDescriptor, ::com::sun::star::uno::Sequence< OUString >());
    1319             : }
    1320             : 
    1321             : 
    1322             : 
    1323             : 
    1324           0 : bool SvtFileView::Initialize( const Sequence< OUString >& aContents )
    1325             : {
    1326           0 :     WaitObject aWaitCursor( this );
    1327             : 
    1328           0 :     mpImp->maViewURL = "";
    1329           0 :     mpImp->maCurrentFilter = mpImp->maAllFilter;
    1330             : 
    1331           0 :     mpImp->Clear();
    1332           0 :     mpImp->CreateVector_Impl( aContents );
    1333           0 :     if( GetSortColumn() )
    1334           0 :         mpImp->SortFolderContent_Impl();
    1335             : 
    1336           0 :     mpImp->OpenFolder_Impl();
    1337             : 
    1338           0 :     mpImp->maOpenDoneLink.Call( this );
    1339             : 
    1340           0 :     return true;
    1341             : }
    1342             : 
    1343             : 
    1344             : 
    1345           0 : FileViewResult SvtFileView::ExecuteFilter( const OUString& rFilter, const FileViewAsyncAction* pAsyncDescriptor )
    1346             : {
    1347           0 :     mpImp->maCurrentFilter = rFilter.toAsciiLowerCase();
    1348             : 
    1349           0 :     mpImp->Clear();
    1350           0 :     FileViewResult eResult = mpImp->GetFolderContent_Impl( mpImp->maViewURL, pAsyncDescriptor, mpBlackList );
    1351             :     OSL_ENSURE( ( eResult != eStillRunning ) || pAsyncDescriptor, "SvtFileView::ExecuteFilter: we told it to read synchronously!" );
    1352           0 :     return eResult;
    1353             : }
    1354             : 
    1355             : 
    1356             : 
    1357           0 : void SvtFileView::CancelRunningAsyncAction()
    1358             : {
    1359           0 :     mpImp->CancelRunningAsyncAction();
    1360           0 : }
    1361             : 
    1362             : 
    1363             : 
    1364           0 : void SvtFileView::SetNoSelection()
    1365             : {
    1366           0 :     mpImp->mpView->SelectAll( false );
    1367           0 : }
    1368             : 
    1369             : 
    1370             : 
    1371           0 : void SvtFileView::GetFocus()
    1372             : {
    1373           0 :     Control::GetFocus();
    1374           0 :     if ( mpImp && mpImp->mpView )
    1375           0 :         mpImp->mpView->GrabFocus();
    1376           0 : }
    1377             : 
    1378             : 
    1379             : 
    1380           0 : void SvtFileView::SetSelectHdl( const Link& rHdl )
    1381             : {
    1382           0 :     mpImp->SetSelectHandler( rHdl );
    1383           0 : }
    1384             : 
    1385             : 
    1386             : 
    1387           0 : void SvtFileView::SetDoubleClickHdl( const Link& rHdl )
    1388             : {
    1389           0 :     mpImp->mpView->SetDoubleClickHdl( rHdl );
    1390           0 : }
    1391             : 
    1392             : 
    1393             : 
    1394           0 : sal_uLong SvtFileView::GetSelectionCount() const
    1395             : {
    1396           0 :     return mpImp->mpView->GetSelectionCount();
    1397             : }
    1398             : 
    1399             : 
    1400             : 
    1401           0 : SvTreeListEntry* SvtFileView::FirstSelected() const
    1402             : {
    1403           0 :     return mpImp->mpView->FirstSelected();
    1404             : }
    1405             : 
    1406             : 
    1407             : 
    1408           0 : SvTreeListEntry* SvtFileView::NextSelected( SvTreeListEntry* pEntry ) const
    1409             : {
    1410           0 :     return mpImp->mpView->NextSelected( pEntry );
    1411             : }
    1412             : 
    1413             : 
    1414             : 
    1415           0 : void SvtFileView::EnableAutoResize()
    1416             : {
    1417           0 :     mpImp->mpView->EnableAutoResize();
    1418           0 : }
    1419             : 
    1420             : 
    1421             : 
    1422           0 : void SvtFileView::SetFocus()
    1423             : {
    1424           0 :     mpImp->mpView->GrabFocus();
    1425           0 : }
    1426             : 
    1427             : 
    1428           0 : const OUString& SvtFileView::GetViewURL() const
    1429             : {
    1430           0 :     return mpImp->maViewURL;
    1431             : }
    1432             : 
    1433             : 
    1434           0 : void SvtFileView::SetOpenDoneHdl( const Link& rHdl )
    1435             : {
    1436           0 :     mpImp->maOpenDoneLink = rHdl;
    1437           0 : }
    1438             : 
    1439             : 
    1440           0 : void SvtFileView::EnableContextMenu( bool bEnable )
    1441             : {
    1442           0 :     mpImp->EnableContextMenu( bEnable );
    1443           0 : }
    1444             : 
    1445             : 
    1446           0 : void SvtFileView::EnableDelete( bool bEnable )
    1447             : {
    1448           0 :     mpImp->EnableDelete( bEnable );
    1449           0 : }
    1450             : 
    1451           0 : void SvtFileView::EnableNameReplacing( bool bEnable )
    1452             : {
    1453           0 :     mpImp->EnableNameReplacing( bEnable );
    1454           0 : }
    1455             : 
    1456             : 
    1457           0 : void SvtFileView::EndInplaceEditing( bool _bCancel )
    1458             : {
    1459           0 :     return mpImp->EndEditing( _bCancel );
    1460             : }
    1461             : 
    1462             : 
    1463           0 : IMPL_LINK( SvtFileView, HeaderSelect_Impl, HeaderBar*, pBar )
    1464             : {
    1465             :     DBG_ASSERT( pBar, "no headerbar" );
    1466           0 :     sal_uInt16 nItemID = pBar->GetCurItemId();
    1467             : 
    1468             :     HeaderBarItemBits nBits;
    1469             : 
    1470             :     // clear the arrow of the recently used column
    1471           0 :     if ( nItemID != mpImp->mnSortColumn )
    1472             :     {
    1473           0 :         if ( !nItemID )
    1474             :         {
    1475             :             // first call -> remove arrow from title column,
    1476             :             // because another column is the sort column
    1477           0 :             nItemID = mpImp->mnSortColumn;
    1478           0 :             mpImp->mnSortColumn = COLUMN_TITLE;
    1479             :         }
    1480           0 :         nBits = pBar->GetItemBits( mpImp->mnSortColumn );
    1481           0 :         nBits &= ~( HIB_UPARROW | HIB_DOWNARROW );
    1482           0 :         pBar->SetItemBits( mpImp->mnSortColumn, nBits );
    1483             :     }
    1484             : 
    1485           0 :     nBits = pBar->GetItemBits( nItemID );
    1486             : 
    1487           0 :     bool bUp = ( ( nBits & HIB_UPARROW ) == HIB_UPARROW );
    1488             : 
    1489           0 :     if ( bUp )
    1490             :     {
    1491           0 :         nBits &= ~HIB_UPARROW;
    1492           0 :         nBits |= HIB_DOWNARROW;
    1493             :     }
    1494             :     else
    1495             :     {
    1496           0 :         nBits &= ~HIB_DOWNARROW;
    1497           0 :         nBits |= HIB_UPARROW;
    1498             :     }
    1499             : 
    1500           0 :     pBar->SetItemBits( nItemID, nBits );
    1501           0 :     mpImp->Resort_Impl( nItemID, !bUp );
    1502           0 :     return 1;
    1503             : }
    1504             : 
    1505             : 
    1506           0 : IMPL_LINK( SvtFileView, HeaderEndDrag_Impl, HeaderBar*, pBar )
    1507             : {
    1508           0 :     if ( !pBar->IsItemMode() )
    1509             :     {
    1510           0 :         Size aSize;
    1511           0 :         sal_uInt16 nTabs = pBar->GetItemCount();
    1512           0 :         long nTmpSize = 0;
    1513             : 
    1514           0 :         for ( sal_uInt16 i = 1; i <= nTabs; ++i )
    1515             :         {
    1516           0 :             long nWidth = pBar->GetItemSize(i);
    1517           0 :             aSize.Width() =  nWidth + nTmpSize;
    1518           0 :             nTmpSize += nWidth;
    1519           0 :             mpImp->mpView->SetTab( i, aSize.Width(), MAP_PIXEL );
    1520             :         }
    1521             :     }
    1522             : 
    1523           0 :     return 0;
    1524             : }
    1525             : 
    1526             : 
    1527           0 : OUString SvtFileView::GetConfigString() const
    1528             : {
    1529           0 :     OUString sRet;
    1530           0 :     HeaderBar* pBar = mpImp->mpView->GetHeaderBar();
    1531             :     DBG_ASSERT( pBar, "invalid headerbar" );
    1532             : 
    1533             :     // sort order
    1534           0 :     sRet += OUString::number( mpImp->mnSortColumn );
    1535           0 :     sRet += ";";
    1536           0 :     HeaderBarItemBits nBits = pBar->GetItemBits( mpImp->mnSortColumn );
    1537           0 :     bool bUp = ( ( nBits & HIB_UPARROW ) == HIB_UPARROW );
    1538           0 :     sRet += bUp ? OUString("1") : OUString("0");
    1539           0 :     sRet += ";";
    1540             : 
    1541           0 :     sal_uInt16 nCount = pBar->GetItemCount();
    1542           0 :     for ( sal_uInt16 i = 0; i < nCount; ++i )
    1543             :     {
    1544           0 :         sal_uInt16 nId = pBar->GetItemId(i);
    1545           0 :         sRet += OUString::number( nId );
    1546           0 :         sRet += ";";
    1547           0 :         sRet += OUString::number( pBar->GetItemSize( nId ) );
    1548           0 :         sRet += ";";
    1549             :     }
    1550             : 
    1551           0 :     sRet = comphelper::string::stripEnd(sRet, ';');
    1552           0 :     return sRet;
    1553             : }
    1554             : 
    1555             : 
    1556           0 : void SvtFileView::SetConfigString( const OUString& rCfgStr )
    1557             : {
    1558           0 :     HeaderBar* pBar = mpImp->mpView->GetHeaderBar();
    1559             :     DBG_ASSERT( pBar, "invalid headerbar" );
    1560             : 
    1561           0 :     sal_Int32 nIdx = 0;
    1562           0 :     mpImp->mnSortColumn = (sal_uInt16)rCfgStr.getToken( 0, ';', nIdx ).toInt32();
    1563           0 :     bool bUp = (bool)(sal_uInt16)rCfgStr.getToken( 0, ';', nIdx ).toInt32();
    1564           0 :     HeaderBarItemBits nBits = pBar->GetItemBits( mpImp->mnSortColumn );
    1565             : 
    1566           0 :     if ( bUp )
    1567             :     {
    1568           0 :         nBits &= ~HIB_UPARROW;
    1569           0 :         nBits |= HIB_DOWNARROW;
    1570             :     }
    1571             :     else
    1572             :     {
    1573           0 :         nBits &= ~HIB_DOWNARROW;
    1574           0 :         nBits |= HIB_UPARROW;
    1575             :     }
    1576           0 :     pBar->SetItemBits( mpImp->mnSortColumn, nBits );
    1577             : 
    1578           0 :     while ( nIdx != -1 )
    1579             :     {
    1580           0 :         sal_uInt16 nItemId = (sal_uInt16)rCfgStr.getToken( 0, ';', nIdx ).toInt32();
    1581           0 :         pBar->SetItemSize( nItemId, rCfgStr.getToken( 0, ';', nIdx ).toInt32() );
    1582             :     }
    1583             : 
    1584           0 :     HeaderSelect_Impl( pBar );
    1585           0 :     HeaderEndDrag_Impl( pBar );
    1586           0 : }
    1587             : 
    1588             : 
    1589           0 : void SvtFileView::StateChanged( StateChangedType nStateChange )
    1590             : {
    1591           0 :     if ( nStateChange == STATE_CHANGE_ENABLE )
    1592           0 :         Invalidate();
    1593           0 :     Control::StateChanged( nStateChange );
    1594           0 : }
    1595             : 
    1596             : 
    1597             : // class NameTranslator_Impl
    1598             : 
    1599             : 
    1600           0 : NameTranslator_Impl::NameTranslator_Impl( const INetURLObject& rActualFolder )
    1601             : {
    1602           0 :     mpActFolder = new NameTranslationList( rActualFolder );
    1603           0 : }
    1604             : 
    1605           0 : NameTranslator_Impl::~NameTranslator_Impl()
    1606             : {
    1607           0 :     if( mpActFolder )
    1608           0 :         delete mpActFolder;
    1609           0 : }
    1610             : 
    1611           0 : void NameTranslator_Impl::SetActualFolder( const INetURLObject& rActualFolder )
    1612             : {
    1613           0 :     HashedEntry aActFolder( rActualFolder );
    1614             : 
    1615           0 :     if( mpActFolder )
    1616             :     {
    1617           0 :         if( *mpActFolder != aActFolder )
    1618             :         {
    1619           0 :             delete mpActFolder;
    1620           0 :             mpActFolder = new NameTranslationList( rActualFolder );
    1621             :         }
    1622             :     }
    1623             :     else
    1624           0 :         mpActFolder = new NameTranslationList( rActualFolder );
    1625           0 : }
    1626             : 
    1627           0 : sal_Bool NameTranslator_Impl::GetTranslation( const OUString& rOrg, OUString& rTrans ) const
    1628             : {
    1629           0 :     sal_Bool bRet = sal_False;
    1630             : 
    1631           0 :     if( mpActFolder )
    1632             :     {
    1633           0 :         const OUString* pTrans = mpActFolder->Translate( rOrg );
    1634           0 :         if( pTrans )
    1635             :         {
    1636           0 :             rTrans = *pTrans;
    1637           0 :             bRet = sal_True;
    1638             :         }
    1639             :     }
    1640             : 
    1641           0 :     return bRet;
    1642             : }
    1643             : 
    1644           0 : const OUString* NameTranslator_Impl::GetTransTableFileName() const
    1645             : {
    1646           0 :     return mpActFolder? &mpActFolder->GetTransTableFileName() : NULL;
    1647             : }
    1648             : 
    1649             : 
    1650             : // class SvtFileView_Impl
    1651             : 
    1652             : 
    1653           0 : SvtFileView_Impl::SvtFileView_Impl( SvtFileView* pAntiImpl, Reference < XCommandEnvironment > xEnv, sal_Int16 nFlags, bool bOnlyFolder )
    1654             : 
    1655             :     :mpAntiImpl                 ( pAntiImpl )
    1656             :     ,m_eAsyncActionResult       ( ::svt::ERROR )
    1657             :     ,m_bRunningAsyncAction      ( false )
    1658             :     ,m_bAsyncActionCancelled    ( false )
    1659             :     ,mpNameTrans                ( NULL )
    1660             :     ,mnSortColumn               ( COLUMN_TITLE )
    1661             :     ,mbAscending                ( true )
    1662             :     ,mbOnlyFolder               ( bOnlyFolder )
    1663             :     ,mbReplaceNames             ( false )
    1664             :     ,mnSuspendSelectCallback    ( 0 )
    1665             :     ,mbIsFirstResort            ( true )
    1666           0 :     ,aIntlWrapper               ( Application::GetSettings().GetLanguageTag() )
    1667             :     ,maFolderImage              ( SvtResId( IMG_SVT_FOLDER ) )
    1668           0 :     ,mxCmdEnv ( xEnv )
    1669             : 
    1670             : {
    1671           0 :     maAllFilter = "*.*";
    1672           0 :     mpView = new ViewTabListBox_Impl( mpAntiImpl, this, nFlags );
    1673           0 :     mpView->EnableCellFocus();
    1674           0 : }
    1675             : 
    1676             : 
    1677           0 : SvtFileView_Impl::~SvtFileView_Impl()
    1678             : {
    1679           0 :     Clear();
    1680             : 
    1681             :     // use temp pointer to prevent access of deleted member (GetFocus())
    1682           0 :     ViewTabListBox_Impl* pTemp = mpView;
    1683           0 :     mpView = NULL;
    1684           0 :     delete pTemp;
    1685           0 : }
    1686             : 
    1687             : 
    1688           0 : void SvtFileView_Impl::Clear()
    1689             : {
    1690           0 :     ::osl::MutexGuard aGuard( maMutex );
    1691             : 
    1692           0 :     std::vector< SortingData_Impl* >::iterator aIt;
    1693             : 
    1694           0 :     for ( aIt = maContent.begin(); aIt != maContent.end(); ++aIt )
    1695           0 :         delete (*aIt);
    1696             : 
    1697           0 :     maContent.clear();
    1698             : 
    1699           0 :     if( mpNameTrans )
    1700           0 :         DELETEZ( mpNameTrans );
    1701           0 : }
    1702             : 
    1703             : 
    1704           0 : FileViewResult SvtFileView_Impl::GetFolderContent_Impl(
    1705             :     const OUString& rFolder,
    1706             :     const FileViewAsyncAction* pAsyncDescriptor,
    1707             :     const ::com::sun::star::uno::Sequence< OUString >& rBlackList )
    1708             : {
    1709           0 :     ::osl::ClearableMutexGuard aGuard( maMutex );
    1710           0 :     INetURLObject aFolderObj( rFolder );
    1711             :     DBG_ASSERT( aFolderObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" );
    1712             : 
    1713             :     // prepare name translation
    1714           0 :     SetActualFolder( aFolderObj );
    1715             : 
    1716           0 :     FolderDescriptor aFolder( aFolderObj.GetMainURL( INetURLObject::NO_DECODE ) );
    1717             : 
    1718           0 :     aGuard.clear();
    1719           0 :     return GetFolderContent_Impl( aFolder, pAsyncDescriptor, rBlackList );
    1720             : }
    1721             : 
    1722             : 
    1723           0 : FileViewResult SvtFileView_Impl::GetFolderContent_Impl(
    1724             :     const FolderDescriptor& _rFolder,
    1725             :     const FileViewAsyncAction* pAsyncDescriptor,
    1726             :     const ::com::sun::star::uno::Sequence< OUString >& rBlackList )
    1727             : {
    1728             :     DBG_TESTSOLARMUTEX();
    1729           0 :     ::osl::ClearableMutexGuard aGuard( maMutex );
    1730             : 
    1731             :     OSL_ENSURE( !m_pContentEnumerator.is(), "SvtFileView_Impl::GetFolderContent_Impl: still running another enumeration!" );
    1732           0 :     m_pContentEnumerator = new ::svt::FileViewContentEnumerator(
    1733           0 :         mpView->GetCommandEnvironment(), maContent, maMutex, mbReplaceNames ? mpNameTrans : NULL );
    1734             :         // TODO: should we cache and re-use this thread?
    1735             : 
    1736           0 :     if ( !pAsyncDescriptor )
    1737             :     {
    1738           0 :         ::svt::EnumerationResult eResult = m_pContentEnumerator->enumerateFolderContentSync( _rFolder, rBlackList );
    1739           0 :         if ( ::svt::SUCCESS == eResult )
    1740             :         {
    1741           0 :             implEnumerationSuccess();
    1742           0 :             m_pContentEnumerator.clear();
    1743           0 :             return eSuccess;
    1744             :         }
    1745           0 :         m_pContentEnumerator.clear();
    1746           0 :         return eFailure;
    1747             :     }
    1748             : 
    1749           0 :     m_bRunningAsyncAction = true;
    1750           0 :     m_bAsyncActionCancelled = false;
    1751           0 :     m_eAsyncActionResult = ::svt::ERROR;
    1752           0 :     m_aAsyncActionFinished.reset();
    1753             : 
    1754             :     // don't (yet) set m_aCurrentAsyncActionHandler to pTimeout->aFinishHandler.
    1755             :     // By definition, this handler *only* get's called when the result cannot be obtained
    1756             :     // during the minimum wait time, so it is only set below, when needed.
    1757           0 :     m_aCurrentAsyncActionHandler = Link();
    1758             : 
    1759             :     // minimum time to wait
    1760           0 :     boost::scoped_ptr< TimeValue > pTimeout( new TimeValue );
    1761           0 :     sal_Int32 nMinTimeout = pAsyncDescriptor->nMinTimeout;
    1762             :     OSL_ENSURE( nMinTimeout > 0, "SvtFileView_Impl::GetFolderContent_Impl: invalid minimum timeout!" );
    1763           0 :     if ( nMinTimeout <= 0 )
    1764           0 :         nMinTimeout = sal_Int32( 1000L );
    1765           0 :     pTimeout->Seconds = nMinTimeout / 1000L;
    1766           0 :     pTimeout->Nanosec = ( nMinTimeout % 1000L ) * 1000000L;
    1767             : 
    1768           0 :     m_pContentEnumerator->enumerateFolderContent( _rFolder, this );
    1769             : 
    1770             :     // wait until the enumeration is finished
    1771             :     // for this, release our own mutex (which is used by the enumerator thread)
    1772           0 :     aGuard.clear();
    1773             : 
    1774           0 :     ::osl::Condition::Result eResult = ::osl::Condition::result_ok;
    1775             :     {
    1776             :         // also release the SolarMutex. Not all code which is needed during the enumeration
    1777             :         // is Solar-Thread-Safe, in particular there is some code which needs to access
    1778             :         // string resources (and our resource system relies on the SolarMutex :()
    1779           0 :         SolarMutexReleaser aSolarRelease;
    1780             : 
    1781             :         // now wait. Note that if we didn't get an pAsyncDescriptor, then this is an infinite wait.
    1782           0 :         eResult = m_aAsyncActionFinished.wait( pTimeout.get() );
    1783             :     }
    1784             : 
    1785           0 :     ::osl::MutexGuard aGuard2( maMutex );
    1786           0 :     if ( ::osl::Condition::result_timeout == eResult )
    1787             :     {
    1788             :         // maximum time to wait
    1789             :         OSL_ENSURE( !m_pCancelAsyncTimer.get(), "SvtFileView_Impl::GetFolderContent_Impl: there's still a previous timer!" );
    1790           0 :         m_pCancelAsyncTimer = new CallbackTimer( this );
    1791           0 :         sal_Int32 nMaxTimeout = pAsyncDescriptor->nMaxTimeout;
    1792             :         OSL_ENSURE( nMaxTimeout > nMinTimeout,
    1793             :             "SvtFileView_Impl::GetFolderContent_Impl: invalid maximum timeout!" );
    1794           0 :         if ( nMaxTimeout <= nMinTimeout )
    1795           0 :             nMaxTimeout = nMinTimeout + 5000;
    1796           0 :         m_pCancelAsyncTimer->setRemainingTime( salhelper::TTimeValue( nMaxTimeout - nMinTimeout ) );
    1797             :             // we already waited for nMinTimeout milliseconds, so take this into account
    1798           0 :         m_pCancelAsyncTimer->start();
    1799             : 
    1800           0 :         m_aCurrentAsyncActionHandler = pAsyncDescriptor->aFinishHandler;
    1801             :         DBG_ASSERT( m_aCurrentAsyncActionHandler.IsSet(), "SvtFileView_Impl::GetFolderContent_Impl: nobody interested when it's finished?" );
    1802           0 :         mpView->ClearAll();
    1803           0 :         return eStillRunning;
    1804             :     }
    1805             : 
    1806           0 :     m_bRunningAsyncAction = false;
    1807           0 :     switch ( m_eAsyncActionResult )
    1808             :     {
    1809             :     case ::svt::SUCCESS:
    1810           0 :         return eSuccess;
    1811             : 
    1812             :     case ::svt::ERROR:
    1813           0 :         return eFailure;
    1814             : 
    1815             :     case ::svt::RUNNING:
    1816           0 :         return eStillRunning;
    1817             :     }
    1818             : 
    1819             :     SAL_WARN( "svtools.contnr", "SvtFileView_Impl::GetFolderContent_Impl: unreachable!" );
    1820           0 :     return eFailure;
    1821             : }
    1822             : 
    1823             : 
    1824           0 : void SvtFileView_Impl::FilterFolderContent_Impl( const OUString &rFilter )
    1825             : {
    1826           0 :     bool bHideTransFile = mbReplaceNames && mpNameTrans;
    1827             : 
    1828           0 :     OUString sHideEntry;
    1829           0 :     if( bHideTransFile )
    1830             :     {
    1831           0 :         const OUString* pTransTableFileName = mpNameTrans->GetTransTableFileName();
    1832           0 :         if( pTransTableFileName )
    1833             :         {
    1834           0 :             sHideEntry = *pTransTableFileName;
    1835           0 :             sHideEntry = sHideEntry.toAsciiUpperCase();
    1836             :         }
    1837             :         else
    1838           0 :             bHideTransFile = false;
    1839             :     }
    1840             : 
    1841           0 :     if ( !bHideTransFile &&
    1842           0 :         ( rFilter.isEmpty() || ( rFilter == ALL_FILES_FILTER ) ) )
    1843             :         // when replacing names, there is always something to filter (no view of ".nametranslation.table")
    1844           0 :         return;
    1845             : 
    1846           0 :     ::osl::MutexGuard aGuard( maMutex );
    1847             : 
    1848           0 :     if ( maContent.empty() )
    1849           0 :         return;
    1850             : 
    1851             :     // count (estimate) the number of filter tokens
    1852           0 :     sal_Int32 nTokens=0;
    1853           0 :     const sal_Unicode* pStart = rFilter.getStr();
    1854           0 :     const sal_Unicode* pEnd = pStart + rFilter.getLength();
    1855           0 :     while ( pStart != pEnd )
    1856           0 :         if ( *pStart++ == ';' )
    1857           0 :             ++nTokens;
    1858             : 
    1859             :     // collect the filter tokens
    1860           0 :     ::std::vector< WildCard > aFilters;
    1861           0 :     FilterMatch::createWildCardFilterList(rFilter,aFilters);
    1862             : 
    1863             : 
    1864             :     // do the filtering
    1865           0 :     ::std::vector< SortingData_Impl* >::iterator aContentLoop = maContent.begin();
    1866           0 :     OUString sCompareString;
    1867           0 :     do
    1868             :     {
    1869           0 :         if ( (*aContentLoop)->mbIsFolder )
    1870           0 :             ++aContentLoop;
    1871             :         else
    1872             :         {
    1873             :             // normalize the content title (we always match case-insensitive)
    1874             :             // 91872 - 11.09.2001 - frank.schoenheit@sun.com
    1875           0 :             sCompareString = (*aContentLoop)->GetFileName(); // filter works on file name, not on title!
    1876             :             bool bDelete;
    1877             : 
    1878           0 :             if( bHideTransFile && sCompareString == sHideEntry )
    1879           0 :                 bDelete = true;
    1880             :             else
    1881             :             {
    1882             :                 // search for the first filter which matches
    1883             :                 ::std::vector< WildCard >::const_iterator pMatchingFilter =
    1884             :                     ::std::find_if(
    1885             :                         aFilters.begin(),
    1886             :                         aFilters.end(),
    1887             :                         FilterMatch( sCompareString )
    1888           0 :                     );
    1889             : 
    1890           0 :                 bDelete = aFilters.end() == pMatchingFilter;
    1891             :             }
    1892             : 
    1893           0 :             if( bDelete )
    1894             :             {
    1895             :                 // none of the filters did match
    1896           0 :                 delete (*aContentLoop);
    1897             : 
    1898           0 :                 if ( maContent.begin() == aContentLoop )
    1899             :                 {
    1900           0 :                     maContent.erase( aContentLoop );
    1901           0 :                     aContentLoop = maContent.begin();
    1902             :                 }
    1903             :                 else
    1904             :                 {
    1905           0 :                     std::vector< SortingData_Impl* >::iterator aDelete = aContentLoop;
    1906           0 :                     --aContentLoop; // move the iterator to a position which is not invalidated by the erase
    1907           0 :                     maContent.erase( aDelete );
    1908           0 :                     ++aContentLoop; // this is now the next one ....
    1909             :                 }
    1910             :             }
    1911             :             else
    1912           0 :                 ++aContentLoop;
    1913             :         }
    1914             :     }
    1915           0 :     while ( aContentLoop != maContent.end() );
    1916             : }
    1917             : 
    1918             : 
    1919           0 : IMPL_LINK( SvtFileView_Impl, SelectionMultiplexer, void*, _pSource )
    1920             : {
    1921           0 :     return mnSuspendSelectCallback ? 0L : m_aSelectHandler.Call( _pSource );
    1922             : }
    1923             : 
    1924             : 
    1925           0 : void SvtFileView_Impl::SetSelectHandler( const Link& _rHdl )
    1926             : {
    1927           0 :     m_aSelectHandler = _rHdl;
    1928             : 
    1929           0 :     Link aMasterHandler;
    1930           0 :     if ( m_aSelectHandler.IsSet() )
    1931           0 :         aMasterHandler = LINK( this, SvtFileView_Impl, SelectionMultiplexer );
    1932             : 
    1933           0 :     mpView->SetSelectHdl( aMasterHandler );
    1934           0 : }
    1935             : 
    1936             : 
    1937           0 : void SvtFileView_Impl::InitSelection()
    1938             : {
    1939           0 :     mpView->SelectAll( false );
    1940           0 :     SvTreeListEntry* pFirst = mpView->First();
    1941           0 :     if ( pFirst )
    1942           0 :         mpView->SetCursor( pFirst, true );
    1943           0 : }
    1944             : 
    1945             : 
    1946           0 : void SvtFileView_Impl::OpenFolder_Impl()
    1947             : {
    1948           0 :     ::osl::MutexGuard aGuard( maMutex );
    1949             : 
    1950           0 :     mpView->SetUpdateMode( false );
    1951           0 :     mpView->ClearAll();
    1952             : 
    1953           0 :     std::vector< SortingData_Impl* >::iterator aIt;
    1954             : 
    1955           0 :     for ( aIt = maContent.begin(); aIt != maContent.end(); ++aIt )
    1956             :     {
    1957           0 :         if ( mbOnlyFolder && ! (*aIt)->mbIsFolder )
    1958           0 :             continue;
    1959             : 
    1960             :         // insert entry and set user data
    1961           0 :         SvTreeListEntry* pEntry = mpView->InsertEntry( (*aIt)->maDisplayText,
    1962           0 :                                                    (*aIt)->maImage,
    1963           0 :                                                    (*aIt)->maImage );
    1964             : 
    1965           0 :         SvtContentEntry* pUserData = new SvtContentEntry( (*aIt)->maTargetURL,
    1966           0 :                                                           (*aIt)->mbIsFolder );
    1967           0 :         pEntry->SetUserData( pUserData );
    1968             :     }
    1969             : 
    1970           0 :     InitSelection();
    1971             : 
    1972           0 :     ++mnSuspendSelectCallback;
    1973           0 :     mpView->SetUpdateMode( true );
    1974           0 :     --mnSuspendSelectCallback;
    1975             : 
    1976           0 :     ResetCursor();
    1977           0 : }
    1978             : 
    1979             : 
    1980           0 : void SvtFileView_Impl::ResetCursor()
    1981             : {
    1982             :     // deselect
    1983           0 :     SvTreeListEntry* pEntry = mpView->FirstSelected();
    1984           0 :     if ( pEntry )
    1985           0 :         mpView->Select( pEntry, false );
    1986             :     // set cursor to the first entry
    1987           0 :     mpView->SetCursor( mpView->First(), true );
    1988           0 :     mpView->Update();
    1989           0 : }
    1990             : 
    1991             : 
    1992           0 : void SvtFileView_Impl::CancelRunningAsyncAction()
    1993             : {
    1994             :     DBG_TESTSOLARMUTEX();
    1995           0 :     ::osl::MutexGuard aGuard( maMutex );
    1996           0 :     if ( !m_pContentEnumerator.is() )
    1997           0 :         return;
    1998             : 
    1999           0 :     m_bAsyncActionCancelled = true;
    2000           0 :     m_pContentEnumerator->cancel();
    2001           0 :     m_bRunningAsyncAction = false;
    2002             : 
    2003           0 :     m_pContentEnumerator.clear();
    2004           0 :     if ( m_pCancelAsyncTimer.is() && m_pCancelAsyncTimer->isTicking() )
    2005           0 :         m_pCancelAsyncTimer->stop();
    2006           0 :     m_pCancelAsyncTimer = NULL;
    2007             : }
    2008             : 
    2009             : 
    2010           0 : void SvtFileView_Impl::onTimeout( CallbackTimer* )
    2011             : {
    2012           0 :     SolarMutexGuard aSolarGuard;
    2013           0 :     ::osl::MutexGuard aGuard( maMutex );
    2014           0 :     if ( !m_bRunningAsyncAction )
    2015             :         // there might have been a race condition while we waited for the mutex
    2016           0 :         return;
    2017             : 
    2018           0 :     CancelRunningAsyncAction();
    2019             : 
    2020           0 :     if ( m_aCurrentAsyncActionHandler.IsSet() )
    2021             :     {
    2022           0 :         Application::PostUserEvent( m_aCurrentAsyncActionHandler, reinterpret_cast< void* >( eTimeout ) );
    2023           0 :         m_aCurrentAsyncActionHandler = Link();
    2024           0 :     }
    2025             : }
    2026             : 
    2027             : 
    2028           0 : void SvtFileView_Impl::enumerationDone( ::svt::EnumerationResult eResult )
    2029             : {
    2030           0 :     SolarMutexGuard aSolarGuard;
    2031           0 :     ::osl::MutexGuard aGuard( maMutex );
    2032             : 
    2033           0 :     m_pContentEnumerator.clear();
    2034           0 :     if ( m_pCancelAsyncTimer.is() && m_pCancelAsyncTimer->isTicking() )
    2035           0 :         m_pCancelAsyncTimer->stop();
    2036           0 :     m_pCancelAsyncTimer = NULL;
    2037             : 
    2038           0 :     if ( m_bAsyncActionCancelled )
    2039             :         // this is to prevent race conditions
    2040           0 :         return;
    2041             : 
    2042           0 :     m_eAsyncActionResult = eResult;
    2043           0 :     m_bRunningAsyncAction = false;
    2044             : 
    2045           0 :     m_aAsyncActionFinished.set();
    2046             : 
    2047           0 :     if ( svt::SUCCESS == eResult )
    2048           0 :         implEnumerationSuccess();
    2049             : 
    2050           0 :     if ( m_aCurrentAsyncActionHandler.IsSet() )
    2051             :     {
    2052           0 :         Application::PostUserEvent( m_aCurrentAsyncActionHandler, reinterpret_cast< void* >( m_eAsyncActionResult ) );
    2053           0 :         m_aCurrentAsyncActionHandler = Link();
    2054           0 :     }
    2055             : }
    2056             : 
    2057             : 
    2058           0 : void SvtFileView_Impl::implEnumerationSuccess()
    2059             : {
    2060           0 :     FilterFolderContent_Impl( maCurrentFilter );
    2061           0 :     SortFolderContent_Impl();
    2062           0 :     CreateDisplayText_Impl();
    2063           0 :     OpenFolder_Impl();
    2064           0 :     maOpenDoneLink.Call( mpAntiImpl );
    2065           0 : }
    2066             : 
    2067             : 
    2068           0 : void SvtFileView_Impl::ReplaceTabWithString( OUString& aValue )
    2069             : {
    2070           0 :     OUString aTab( "\t" );
    2071           0 :     OUString aTabString( "%09" );
    2072             :     sal_Int32 iPos;
    2073             : 
    2074           0 :     while ( ( iPos = aValue.indexOf( aTab ) ) >= 0 )
    2075           0 :        aValue = aValue.replaceAt( iPos, 1, aTabString );
    2076           0 : }
    2077             : 
    2078             : 
    2079           0 : void SvtFileView_Impl::CreateDisplayText_Impl()
    2080             : {
    2081           0 :     ::osl::MutexGuard aGuard( maMutex );
    2082             : 
    2083           0 :     OUString aValue;
    2084           0 :     OUString aTab( "\t" );
    2085           0 :     OUString aDateSep( ", " );
    2086             : 
    2087           0 :     std::vector< SortingData_Impl* >::iterator aIt;
    2088             : 
    2089           0 :     for ( aIt = maContent.begin(); aIt != maContent.end(); ++aIt )
    2090             :     {
    2091             :         // title, type, size, date
    2092           0 :         aValue = (*aIt)->GetTitle();
    2093             :         // #83004# --------------------
    2094           0 :         ReplaceTabWithString( aValue );
    2095           0 :         aValue += aTab;
    2096           0 :         aValue += (*aIt)->maType;
    2097           0 :         aValue += aTab;
    2098             :         // folders don't have a size
    2099           0 :         if ( ! (*aIt)->mbIsFolder )
    2100           0 :             aValue += CreateExactSizeText( (*aIt)->maSize );
    2101           0 :         aValue += aTab;
    2102             :         // set the date, but volumes have no date
    2103           0 :         if ( ! (*aIt)->mbIsFolder || ! (*aIt)->mbIsVolume )
    2104             :         {
    2105           0 :             SvtSysLocale aSysLocale;
    2106           0 :             const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
    2107           0 :             aValue += rLocaleData.getDate( (*aIt)->maModDate );
    2108           0 :             aValue += aDateSep;
    2109           0 :             aValue += rLocaleData.getTime( (*aIt)->maModDate );
    2110             :         }
    2111           0 :         (*aIt)->maDisplayText = aValue;
    2112             : 
    2113             :         // detect image
    2114           0 :         if ( (*aIt)->mbIsFolder )
    2115             :         {
    2116           0 :             ::svtools::VolumeInfo aVolInfo( (*aIt)->mbIsVolume, (*aIt)->mbIsRemote,
    2117           0 :                                             (*aIt)->mbIsRemoveable, (*aIt)->mbIsFloppy,
    2118           0 :                                             (*aIt)->mbIsCompactDisc );
    2119           0 :             (*aIt)->maImage = SvFileInformationManager::GetFolderImage( aVolInfo, false );
    2120             :         }
    2121             :         else
    2122           0 :             (*aIt)->maImage = SvFileInformationManager::GetFileImage( INetURLObject( (*aIt)->maTargetURL ), false );
    2123           0 :     }
    2124           0 : }
    2125             : 
    2126             : 
    2127             : // this function converts the sequence of strings into a vector of SortingData
    2128             : // the string should have the form :
    2129             : // title \t type \t size \t date \t target url \t is folder \t image url
    2130             : 
    2131           0 : void SvtFileView_Impl::CreateVector_Impl( const Sequence < OUString > &rList )
    2132             : {
    2133           0 :     ::osl::MutexGuard aGuard( maMutex );
    2134             : 
    2135           0 :     OUString aTab( "\t" );
    2136             : 
    2137           0 :     sal_uInt32 nCount = (sal_uInt32) rList.getLength();
    2138             : 
    2139           0 :     for( sal_uInt32 i = 0; i < nCount; i++ )
    2140             :     {
    2141           0 :         SortingData_Impl*   pEntry = new SortingData_Impl;
    2142           0 :         OUString            aValue = rList[i];
    2143           0 :         OUString            aDisplayText;
    2144           0 :         sal_Int32           nIndex = 0;
    2145             : 
    2146             :         // get the title
    2147           0 :         pEntry->SetNewTitle( aValue.getToken( 0, '\t', nIndex ) );
    2148           0 :         aDisplayText = pEntry->GetTitle();
    2149           0 :         ReplaceTabWithString( aDisplayText );
    2150           0 :         aDisplayText += aTab;
    2151             : 
    2152             :         // get the type
    2153           0 :         if ( nIndex >= 0 )
    2154             :         {
    2155           0 :             pEntry->maType = aValue.getToken( 0, '\t', nIndex );
    2156           0 :             aDisplayText += pEntry->maType;
    2157             :         }
    2158           0 :         aDisplayText += aTab;
    2159             : 
    2160             :         // get the size
    2161           0 :         if ( nIndex >= 0 )
    2162             :         {
    2163           0 :             OUString aSize = aValue.getToken( 0, '\t', nIndex );
    2164           0 :             aDisplayText += aSize;
    2165             : 
    2166           0 :             if ( !aSize.isEmpty() )
    2167           0 :                 pEntry->maSize = aSize.toInt64();
    2168             :         }
    2169           0 :         aDisplayText += aTab;
    2170             : 
    2171             :         // get the date
    2172           0 :         if ( nIndex >= 0 )
    2173             :         {
    2174           0 :             OUString aDate = aValue.getToken( 0, '\t', nIndex );
    2175           0 :             aDisplayText += aDate;
    2176             : 
    2177           0 :             if ( !aDate.isEmpty() )
    2178             :             {
    2179             :                 SAL_WARN( "svtools.contnr", "Don't know, how to convert date" );
    2180             :                 ;// convert date string to date
    2181           0 :             }
    2182             :         }
    2183             :         // get the target url
    2184           0 :         if ( nIndex >= 0 )
    2185             :         {
    2186           0 :             pEntry->maTargetURL = aValue.getToken( 0, '\t', nIndex );
    2187             :         }
    2188             :         // get the size
    2189           0 :         if ( nIndex >= 0 )
    2190             :         {
    2191           0 :             OUString aBool = aValue.getToken( 0, '\t', nIndex );
    2192           0 :             if ( !aBool.isEmpty() )
    2193           0 :                 pEntry->mbIsFolder = aBool.toBoolean();
    2194             :         }
    2195             :         // get the image url
    2196           0 :         if ( nIndex >= 0 )
    2197             :         {
    2198           0 :             pEntry->maImageURL = aValue.getToken( 0, '\t', nIndex );
    2199             :         }
    2200             : 
    2201             :         // set the display text
    2202           0 :         pEntry->maDisplayText = aDisplayText;
    2203             : 
    2204             :         // detect the image
    2205           0 :         if( aValue != SEPARATOR_STR )
    2206             :         {
    2207           0 :             INetURLObject aObj( !pEntry->maImageURL.isEmpty() ? pEntry->maImageURL : pEntry->maTargetURL );
    2208           0 :             pEntry->maImage = SvFileInformationManager::GetImage( aObj, false );
    2209             :         }
    2210           0 :         maContent.push_back( pEntry );
    2211           0 :     }
    2212           0 : }
    2213             : 
    2214             : 
    2215           0 : void SvtFileView_Impl::Resort_Impl( sal_Int16 nColumn, bool bAscending )
    2216             : {
    2217           0 :     ::osl::MutexGuard aGuard( maMutex );
    2218             : 
    2219           0 :     if ( ( nColumn == mnSortColumn ) &&
    2220           0 :          ( bAscending == mbAscending ) )
    2221           0 :          return;
    2222             : 
    2223             :     // reset the quick search index
    2224           0 :     mpView->ResetQuickSearch_Impl( NULL );
    2225             : 
    2226           0 :     OUString aEntryURL;
    2227           0 :     SvTreeListEntry* pEntry = mpView->GetCurEntry();
    2228           0 :     if ( pEntry && pEntry->GetUserData() )
    2229           0 :         aEntryURL = ( (SvtContentEntry*)pEntry->GetUserData() )->maURL;
    2230             : 
    2231           0 :     mnSortColumn = nColumn;
    2232           0 :     mbAscending = bAscending;
    2233             : 
    2234           0 :     SortFolderContent_Impl();
    2235           0 :     OpenFolder_Impl();
    2236             : 
    2237           0 :     if ( !mbIsFirstResort )
    2238             :     {
    2239           0 :         sal_uLong nPos = GetEntryPos( aEntryURL );
    2240           0 :         if ( nPos < mpView->GetEntryCount() )
    2241             :         {
    2242           0 :             pEntry = mpView->GetEntry( nPos );
    2243             : 
    2244           0 :             ++mnSuspendSelectCallback;  // #i15668#
    2245           0 :             mpView->SetCurEntry( pEntry );
    2246           0 :             --mnSuspendSelectCallback;
    2247             :         }
    2248             :     }
    2249             :     else
    2250           0 :         mbIsFirstResort = false;
    2251             : }
    2252             : 
    2253             : 
    2254             : static bool                     gbAscending = true;
    2255             : static sal_Int16                gnColumn = COLUMN_TITLE;
    2256             : static const CollatorWrapper*   pCollatorWrapper = NULL;
    2257             : 
    2258             : /* this functions returns true, if aOne is less then aTwo
    2259             : */
    2260           0 : bool CompareSortingData_Impl( SortingData_Impl* const aOne, SortingData_Impl* const aTwo )
    2261             : {
    2262             :     DBG_ASSERT( pCollatorWrapper, "*CompareSortingData_Impl(): Can't work this way!" );
    2263             : 
    2264             :     sal_Int32 nComp;
    2265           0 :     bool      bRet = false;
    2266           0 :     bool      bEqual = false;
    2267             : 
    2268           0 :     if ( aOne->mbIsFolder != aTwo->mbIsFolder )
    2269             :     {
    2270           0 :         if ( aOne->mbIsFolder )
    2271           0 :             bRet = true;
    2272             :         else
    2273           0 :             bRet = false;
    2274             : 
    2275             :         // !!! pb: #100376# folder always on top
    2276           0 :         if ( !gbAscending )
    2277           0 :             bRet = !bRet;
    2278             :     }
    2279             :     else
    2280             :     {
    2281           0 :         switch ( gnColumn )
    2282             :         {
    2283             :             case COLUMN_TITLE:
    2284             :                 // compare case insensitive first
    2285           0 :                 nComp = pCollatorWrapper->compareString( aOne->GetLowerTitle(), aTwo->GetLowerTitle() );
    2286             : 
    2287           0 :                 if ( nComp == 0 )
    2288           0 :                     nComp = pCollatorWrapper->compareString( aOne->GetTitle(), aTwo->GetTitle() );
    2289             : 
    2290           0 :                 if ( nComp < 0 )
    2291           0 :                     bRet = true;
    2292           0 :                 else if ( nComp > 0 )
    2293           0 :                     bRet = false;
    2294             :                 else
    2295           0 :                     bEqual = true;
    2296           0 :                 break;
    2297             :             case COLUMN_TYPE:
    2298           0 :                 nComp = pCollatorWrapper->compareString( aOne->maType, aTwo->maType );
    2299           0 :                 if ( nComp < 0 )
    2300           0 :                     bRet = true;
    2301           0 :                 else if ( nComp > 0 )
    2302           0 :                     bRet = false;
    2303             :                 else
    2304           0 :                     bEqual = true;
    2305           0 :                 break;
    2306             :             case COLUMN_SIZE:
    2307           0 :                 if ( aOne->maSize < aTwo->maSize )
    2308           0 :                     bRet = true;
    2309           0 :                 else if ( aOne->maSize > aTwo->maSize )
    2310           0 :                     bRet = false;
    2311             :                 else
    2312           0 :                     bEqual = true;
    2313           0 :                 break;
    2314             :             case COLUMN_DATE:
    2315           0 :                 if ( aOne->maModDate < aTwo->maModDate )
    2316           0 :                     bRet = true;
    2317           0 :                 else if ( aOne->maModDate > aTwo->maModDate )
    2318           0 :                     bRet = false;
    2319             :                 else
    2320           0 :                     bEqual = true;
    2321           0 :                 break;
    2322             :             default:
    2323             :                 DBG_WARNING( "CompareSortingData_Impl: Compare unknown type!" );
    2324           0 :                 bRet = false;
    2325             :         }
    2326             :     }
    2327             : 
    2328             :     // when the two elements are equal, we must not return sal_True (which would
    2329             :     // happen if we just return ! ( a < b ) when not sorting ascending )
    2330           0 :     if ( bEqual )
    2331           0 :         return false;
    2332             : 
    2333           0 :     return gbAscending ? bRet : !bRet;
    2334             : }
    2335             : 
    2336             : 
    2337           0 : void SvtFileView_Impl::SortFolderContent_Impl()
    2338             : {
    2339           0 :     ::osl::MutexGuard aGuard( maMutex );
    2340             : 
    2341           0 :     sal_uInt32 nSize = maContent.size();
    2342             : 
    2343           0 :     if ( nSize > 1 )
    2344             :     {
    2345           0 :         gbAscending = mbAscending;
    2346           0 :         gnColumn = mnSortColumn;
    2347           0 :         pCollatorWrapper = aIntlWrapper.getCaseCollator();
    2348             : 
    2349           0 :         std::stable_sort( maContent.begin(), maContent.end(), CompareSortingData_Impl );
    2350             : 
    2351           0 :         pCollatorWrapper = NULL;
    2352           0 :     }
    2353           0 : }
    2354             : 
    2355             : 
    2356           0 : void SvtFileView_Impl::EntryRemoved( const OUString& rURL )
    2357             : {
    2358           0 :     ::osl::MutexGuard aGuard( maMutex );
    2359             : 
    2360           0 :     std::vector< SortingData_Impl* >::iterator aIt;
    2361             : 
    2362           0 :     for ( aIt = maContent.begin(); aIt != maContent.end(); ++aIt )
    2363             :     {
    2364           0 :         if ( (*aIt)->maTargetURL == rURL )
    2365             :         {
    2366           0 :             maContent.erase( aIt );
    2367           0 :             break;
    2368             :         }
    2369           0 :     }
    2370           0 : }
    2371             : 
    2372             : 
    2373           0 : void SvtFileView_Impl::EntryRenamed( OUString& rURL,
    2374             :                                      const OUString& rTitle )
    2375             : {
    2376           0 :     ::osl::MutexGuard aGuard( maMutex );
    2377             : 
    2378           0 :     std::vector< SortingData_Impl* >::iterator aIt;
    2379             : 
    2380           0 :     for ( aIt = maContent.begin(); aIt != maContent.end(); ++aIt )
    2381             :     {
    2382           0 :         if ( (*aIt)->maTargetURL == rURL )
    2383             :         {
    2384           0 :             (*aIt)->SetNewTitle( rTitle );
    2385           0 :             OUString aDisplayText = (*aIt)->maDisplayText;
    2386           0 :             sal_Int32 nIndex = aDisplayText.indexOf( '\t' );
    2387             : 
    2388           0 :             if ( nIndex > 0 )
    2389           0 :                 (*aIt)->maDisplayText = aDisplayText.replaceAt( 0, nIndex, rTitle );
    2390             : 
    2391           0 :             INetURLObject aURLObj( rURL );
    2392           0 :             aURLObj.SetName( rTitle, INetURLObject::ENCODE_ALL );
    2393             : 
    2394           0 :             rURL = aURLObj.GetMainURL( INetURLObject::NO_DECODE );
    2395             : 
    2396           0 :             (*aIt)->maTargetURL = rURL;
    2397           0 :             break;
    2398             :         }
    2399           0 :     }
    2400           0 : }
    2401             : 
    2402             : 
    2403           0 : OUString SvtFileView_Impl::FolderInserted( const OUString& rURL, const OUString& rTitle )
    2404             : {
    2405           0 :     ::osl::MutexGuard aGuard( maMutex );
    2406             : 
    2407           0 :     SortingData_Impl* pData = new SortingData_Impl;
    2408             : 
    2409           0 :     pData->SetNewTitle( rTitle );
    2410           0 :     pData->maSize     = 0;
    2411           0 :     pData->mbIsFolder = sal_True;
    2412           0 :     pData->maTargetURL   = rURL;
    2413             : 
    2414           0 :     ::svtools::VolumeInfo aVolInfo;
    2415           0 :     pData->maType = SvFileInformationManager::GetFolderDescription( aVolInfo );
    2416           0 :     pData->maImage = SvFileInformationManager::GetFolderImage( aVolInfo, false );
    2417             : 
    2418           0 :     OUString aValue;
    2419           0 :     OUString aTab( "\t" );
    2420           0 :     OUString aDateSep( ", " );
    2421             : 
    2422             :     // title, type, size, date
    2423           0 :     aValue = pData->GetTitle();
    2424           0 :     ReplaceTabWithString( aValue );
    2425           0 :     aValue += aTab;
    2426           0 :     aValue += pData->maType;
    2427           0 :     aValue += aTab;
    2428             :     // folders don't have a size
    2429           0 :     aValue += aTab;
    2430             :     // set the date
    2431           0 :     SvtSysLocale aSysLocale;
    2432           0 :     const LocaleDataWrapper& rLocaleData = aSysLocale.GetLocaleData();
    2433           0 :     aValue += rLocaleData.getDate( pData->maModDate );
    2434           0 :     aValue += aDateSep;
    2435           0 :     aValue += rLocaleData.getTime( pData->maModDate );
    2436             : 
    2437           0 :     pData->maDisplayText = aValue;
    2438           0 :     maContent.push_back( pData );
    2439             : 
    2440           0 :     return aValue;
    2441             : }
    2442             : 
    2443             : 
    2444           0 : sal_uLong SvtFileView_Impl::GetEntryPos( const OUString& rURL )
    2445             : {
    2446           0 :     ::osl::MutexGuard aGuard( maMutex );
    2447             : 
    2448           0 :     std::vector< SortingData_Impl* >::iterator aIt;
    2449           0 :     sal_uLong   nPos = 0;
    2450             : 
    2451           0 :     for ( aIt = maContent.begin(); aIt != maContent.end(); ++aIt )
    2452             :     {
    2453           0 :         if ( (*aIt)->maTargetURL == rURL )
    2454           0 :             return nPos;
    2455           0 :         nPos += 1;
    2456             :     }
    2457             : 
    2458           0 :     return nPos;
    2459             : }
    2460             : 
    2461             : 
    2462           0 : bool SvtFileView_Impl::SearchNextEntry( sal_uInt32& nIndex, const OUString& rTitle, bool bWrapAround )
    2463             : {
    2464           0 :     ::osl::MutexGuard aGuard( maMutex );
    2465             : 
    2466           0 :     sal_uInt32 nEnd = maContent.size();
    2467           0 :     sal_uInt32 nStart = nIndex;
    2468           0 :     while ( nIndex < nEnd )
    2469             :     {
    2470           0 :         SortingData_Impl* pData = maContent[ nIndex ];
    2471           0 :         if ( rTitle.compareTo( pData->GetLowerTitle(), rTitle.getLength() ) == 0 )
    2472           0 :             return true;
    2473           0 :         nIndex += 1;
    2474             :     }
    2475             : 
    2476           0 :     if ( bWrapAround )
    2477             :     {
    2478           0 :         nIndex = 0;
    2479           0 :         while ( nIndex < nEnd && nIndex <= nStart )
    2480             :         {
    2481           0 :             SortingData_Impl* pData = maContent[ nIndex ];
    2482           0 :             if ( rTitle.compareTo( pData->GetLowerTitle(), rTitle.getLength() ) == 0 )
    2483           0 :                 return true;
    2484           0 :             nIndex += 1;
    2485             :         }
    2486             :     }
    2487             : 
    2488           0 :     return false;
    2489             : }
    2490             : 
    2491             : 
    2492           0 : void SvtFileView_Impl::SetActualFolder( const INetURLObject& rActualFolder )
    2493             : {
    2494           0 :     if( mbReplaceNames )
    2495             :     {
    2496           0 :         if( mpNameTrans )
    2497           0 :             mpNameTrans->SetActualFolder( rActualFolder );
    2498             :         else
    2499           0 :             mpNameTrans = new NameTranslator_Impl( rActualFolder );
    2500             :     }
    2501           0 : }
    2502             : 
    2503             : namespace svtools {
    2504             : 
    2505           0 : QueryDeleteDlg_Impl::QueryDeleteDlg_Impl(Window* pParent, const OUString& rName)
    2506           0 :     : MessageDialog(pParent, "QueryDeleteDialog", "svt/ui/querydeletedialog.ui")
    2507             : {
    2508           0 :     get(m_pAllButton, "all");
    2509             : 
    2510             :     // display specified texts
    2511           0 :     set_secondary_text(get_secondary_text().replaceFirst("%s", rName));
    2512           0 : }
    2513             : 
    2514           3 : }
    2515             : 
    2516             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10