strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/svtools/source/misc/imagemgr.cxx
Stephan Bergmann 9ac86f484b Improvement on previous commit, UCB clean up 
* As UCB is only ever initialized with "Local"/"Office", remove this
  configuration vector completely.  The "create" ctor creates an instance
  internally initialized with those "Local"/"Office" keys.  Special (test) code
  can still instantiate an uninitialized one via plain createInstance.  And for
  backwards compatilibity process startup still ensures to create an initialized
  instance early, in case there is still code out there (in extensions) that
  later calls plain createInstance and expects to get the already-initialized
  (single) instance.

* XInitialization is an "implementation detail" of the UniversalContentBroker
  service, do not expose in XUniversalContentBroker.

* ucbhelper/configurationkeys.hxx is no longer needed and is removed.

* ucbhelper/contentbroker.hxx is an empty wrapper and is removed; however, that
  requires ucbhelper::Content constructors to take explicit XComponentContext
  arguments now.

* The only remaining code in ucbhelper/source/client/contentbroker.cxx is
  Android-only InitUCBHelper.  Is that relevant still?

Change-Id: I3f7bddd0456bffbcd13590c66d9011915c760f28
2012-09-14 18:24:49 +02:00

673 lines
28 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#include <svtools/imagemgr.hxx>
#include <tools/urlobj.hxx>
#include <tools/debug.hxx>
#include <vcl/svapp.hxx>
#include <vcl/wrkwin.hxx>
#include "vcl/image.hxx"
#include <sot/storage.hxx>
#include <sot/clsids.hxx>
#include <unotools/ucbhelper.hxx>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/container/XNameContainer.hpp>
#include <com/sun/star/document/XTypeDetection.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/ucb/XCommandEnvironment.hpp>
#include <ucbhelper/content.hxx>
#include <tools/rcid.h>
#include <rtl/logfile.hxx>
#include <unotools/configmgr.hxx>
#include <svtools/svtools.hrc>
#include <svtools/imagemgr.hrc>
#include <svtools/svtresid.hxx>
#include <osl/mutex.hxx>
#include <vcl/lazydelete.hxx>
// globals *******************************************************************
#define NO_INDEX ((sal_uInt16)0xFFFF)
#define CONTENT_HELPER ::utl::UCBContentHelper
#define ASCII_STRING(s) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(s) )
struct SvtExtensionResIdMapping_Impl
{
const char* _pExt;
sal_Bool _bExt;
sal_uInt16 _nStrId;
sal_uInt16 _nImgId;
};
static SvtExtensionResIdMapping_Impl const ExtensionMap_Impl[] =
{
{ "awk", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "bas", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "bat", sal_True, STR_DESCRIPTION_BATCHFILE, 0 },
{ "bmk", sal_False, STR_DESCRIPTION_BOOKMARKFILE, 0 },
{ "bmp", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_BITMAP },
{ "c", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "cfg", sal_False, STR_DESCRIPTION_CFGFILE, 0 },
{ "cmd", sal_True, STR_DESCRIPTION_BATCHFILE, 0 },
{ "cob", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "com", sal_True, STR_DESCRIPTION_APPLICATION, 0 },
{ "cxx", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "dbf", sal_True, STR_DESCRIPTION_DATABASE_TABLE, IMG_TABLE },
{ "def", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "dll", sal_True, STR_DESCRIPTION_SYSFILE, 0 },
{ "doc", sal_False, STR_DESCRIPTION_WORD_DOC, IMG_WRITER },
{ "dot", sal_False, STR_DESCRIPTION_WORD_DOC, IMG_WRITERTEMPLATE },
{ "docx", sal_False, STR_DESCRIPTION_WORD_DOC, IMG_WRITER },
{ "dxf", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_DXF },
{ "exe", sal_True, STR_DESCRIPTION_APPLICATION, 0 },
{ "gif", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_GIF },
{ "h", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "hlp", sal_False, STR_DESCRIPTION_HELP_DOC, 0 },
{ "hrc", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "htm", sal_False, STR_DESCRIPTION_HTMLFILE, IMG_HTML },
{ "html", sal_False, STR_DESCRIPTION_HTMLFILE, IMG_HTML },
{ "asp", sal_False, STR_DESCRIPTION_HTMLFILE, IMG_HTML },
{ "hxx", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "ini", sal_False, STR_DESCRIPTION_CFGFILE, 0 },
{ "java", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "jpeg", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_JPG },
{ "jpg", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_JPG },
{ "lha", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
#ifdef WNT
{ "lnk", sal_False, 0, 0 },
#endif
{ "log", sal_True, STR_DESCRIPTION_LOGFILE, 0 },
{ "lst", sal_True, STR_DESCRIPTION_LOGFILE, 0 },
{ "met", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_MET },
{ "mml", sal_False, STR_DESCRIPTION_MATHML_DOC, IMG_MATH },
{ "mod", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "odb", sal_False, STR_DESCRIPTION_OO_DATABASE_DOC, IMG_OO_DATABASE_DOC },
{ "odg", sal_False, STR_DESCRIPTION_OO_DRAW_DOC, IMG_OO_DRAW_DOC },
{ "odf", sal_False, STR_DESCRIPTION_OO_MATH_DOC, IMG_OO_MATH_DOC },
{ "odm", sal_False, STR_DESCRIPTION_OO_GLOBAL_DOC, IMG_OO_GLOBAL_DOC },
{ "odp", sal_False, STR_DESCRIPTION_OO_IMPRESS_DOC, IMG_OO_IMPRESS_DOC },
{ "ods", sal_False, STR_DESCRIPTION_OO_CALC_DOC, IMG_OO_CALC_DOC },
{ "odt", sal_False, STR_DESCRIPTION_OO_WRITER_DOC, IMG_OO_WRITER_DOC },
{ "otg", sal_False, STR_DESCRIPTION_OO_DRAW_TEMPLATE, IMG_OO_DRAW_TEMPLATE },
{ "otp", sal_False, STR_DESCRIPTION_OO_IMPRESS_TEMPLATE, IMG_OO_IMPRESS_TEMPLATE },
{ "ots", sal_False, STR_DESCRIPTION_OO_CALC_TEMPLATE, IMG_OO_CALC_TEMPLATE },
{ "ott", sal_False, STR_DESCRIPTION_OO_WRITER_TEMPLATE, IMG_OO_WRITER_TEMPLATE },
{ "pas", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "pcd", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_PCD },
{ "pct", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_PCT },
{ "pict", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_PCT },
{ "pcx", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_PCX },
{ "pl", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "png", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_PNG },
{ "rar", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "rtf", sal_False, STR_DESCRIPTION_WORD_DOC, IMG_WRITER },
{ "sbl", sal_False, 0, 0 },
{ "sch", sal_False, 0, 0 },
{ "sda", sal_False, STR_DESCRIPTION_SDRAW_DOC, IMG_DRAW },
{ "sdb", sal_False, STR_DESCRIPTION_SDATABASE_DOC, IMG_DATABASE },
{ "sdc", sal_False, STR_DESCRIPTION_SCALC_DOC, IMG_CALC },
{ "sdd", sal_False, STR_DESCRIPTION_SIMPRESS_DOC, IMG_IMPRESS },
{ "sdp", sal_False, STR_DESCRIPTION_SIMPRESS_DOC, 0 },
{ "sds", sal_False, STR_DESCRIPTION_SCHART_DOC, 0 },
{ "sdw", sal_False, STR_DESCRIPTION_SWRITER_DOC, IMG_WRITER },
{ "sga", sal_False, 0, 0 },
{ "sgf", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_SGF },
{ "sgl", sal_False, STR_DESCRIPTION_GLOBALDOC, IMG_GLOBAL_DOC },
{ "sgv", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_SGV },
{ "shtml", sal_False, STR_DESCRIPTION_HTMLFILE, IMG_HTML },
{ "sim", sal_False, STR_DESCRIPTION_SIMAGE_DOC, IMG_SIM },
{ "smf", sal_False, STR_DESCRIPTION_SMATH_DOC, IMG_MATH },
{ "src", sal_True, STR_DESCRIPTION_SOURCEFILE, 0 },
{ "svh", sal_False, STR_DESCRIPTION_HELP_DOC, 0 },
{ "svm", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_SVM },
{ "stc", sal_False, STR_DESCRIPTION_CALC_TEMPLATE, IMG_CALCTEMPLATE },
{ "std", sal_False, STR_DESCRIPTION_DRAW_TEMPLATE, IMG_DRAWTEMPLATE },
{ "sti", sal_False, STR_DESCRIPTION_IMPRESS_TEMPLATE, IMG_IMPRESSTEMPLATE },
{ "stw", sal_False, STR_DESCRIPTION_WRITER_TEMPLATE, IMG_WRITERTEMPLATE },
{ "sxc", sal_False, STR_DESCRIPTION_SXCALC_DOC, IMG_CALC },
{ "sxd", sal_False, STR_DESCRIPTION_SXDRAW_DOC, IMG_DRAW },
{ "sxg", sal_False, STR_DESCRIPTION_SXGLOBAL_DOC, IMG_GLOBAL_DOC },
{ "sxi", sal_False, STR_DESCRIPTION_SXIMPRESS_DOC, IMG_IMPRESS },
{ "sxm", sal_False, STR_DESCRIPTION_SXMATH_DOC, IMG_MATH },
{ "sxs", sal_False, STR_DESCRIPTION_SXCHART_DOC, 0 },
{ "sxw", sal_False, STR_DESCRIPTION_SXWRITER_DOC, IMG_WRITER },
{ "sys", sal_True, STR_DESCRIPTION_SYSFILE, 0 },
{ "tif", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_TIFF },
{ "tiff", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_TIFF },
{ "txt", sal_False, STR_DESCRIPTION_TEXTFILE, IMG_TEXTFILE },
{ "url", sal_False, STR_DESCRIPTION_LINK, 0 },
{ "vor", sal_False, STR_DESCRIPTION_SOFFICE_TEMPLATE_DOC, IMG_WRITERTEMPLATE },
{ "vxd", sal_True, STR_DESCRIPTION_SYSFILE, 0 },
{ "wmf", sal_True, STR_DESCRIPTION_GRAPHIC_DOC, IMG_WMF },
{ "xls", sal_False, STR_DESCRIPTION_EXCEL_DOC, IMG_CALC },
{ "xlt", sal_False, STR_DESCRIPTION_EXCEL_TEMPLATE_DOC, IMG_CALCTEMPLATE },
{ "xlsx", sal_False, STR_DESCRIPTION_EXCEL_DOC, IMG_CALC },
{ "uu", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "uue", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "z", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "zip", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "zoo", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "gz", sal_True, STR_DESCRIPTION_ARCHIVFILE, 0 },
{ "ppt", sal_False, STR_DESCRIPTION_POWERPOINT, IMG_IMPRESS },
{ "pot", sal_False, STR_DESCRIPTION_POWERPOINT_TEMPLATE, IMG_IMPRESSTEMPLATE },
{ "pps", sal_False, STR_DESCRIPTION_POWERPOINT_SHOW, IMG_IMPRESS },
{ "pptx", sal_False, STR_DESCRIPTION_POWERPOINT, IMG_IMPRESS },
{ "oxt", sal_False, STR_DESCRIPTION_EXTENSION, IMG_EXTENSION },
{ 0, sal_False, 0, 0 }
};
struct SvtFactory2ExtensionMapping_Impl
{
const char* _pFactory;
const char* _pExtension;
};
// mapping from "private:factory" url to extension
static SvtFactory2ExtensionMapping_Impl const Fac2ExtMap_Impl[] =
{
{ "swriter", "odt" },
{ "swriter/web", "html" },
{ "swriter/GlobalDocument", "odm" },
{ "scalc", "ods" },
{ "simpress", "odp" },
{ "sdraw", "odg" },
{ "smath", "odf" },
{ "sdatabase", "odb" },
{ NULL, NULL }
};
//****************************************************************************
static String GetImageExtensionByFactory_Impl( const String& rURL )
{
INetURLObject aObj( rURL );
String aPath = aObj.GetURLPath( INetURLObject::NO_DECODE );
String aExtension;
if ( aPath.Len() )
{
sal_uInt16 nIndex = 0;
while ( Fac2ExtMap_Impl[ nIndex ]._pFactory )
{
if ( aPath.EqualsAscii( Fac2ExtMap_Impl[ nIndex ]._pFactory ) )
{
// extension found
aExtension = rtl::OUString::createFromAscii(Fac2ExtMap_Impl[ nIndex ]._pExtension);
// and return it
return aExtension;
}
++nIndex;
}
}
// no extension found, so use the type detection (performance brake)
try
{
// get the TypeDetection service to access all registered types
::com::sun::star::uno::Reference < ::com::sun::star::lang::XMultiServiceFactory > xFac = ::comphelper::getProcessServiceFactory();
::com::sun::star::uno::Reference < ::com::sun::star::document::XTypeDetection > xTypeDetector(
xFac->createInstance( ASCII_STRING("com.sun.star.document.TypeDetection") ), ::com::sun::star::uno::UNO_QUERY );
::rtl::OUString aInternalType = xTypeDetector->queryTypeByURL( rURL );
::com::sun::star::uno::Reference < ::com::sun::star::container::XNameAccess > xAccess( xTypeDetector, ::com::sun::star::uno::UNO_QUERY );
::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue > aTypeProps;
if ( !aInternalType.isEmpty() && xAccess->hasByName( aInternalType ) )
{
xAccess->getByName( aInternalType ) >>= aTypeProps;
sal_Int32 nProps = aTypeProps.getLength();
for ( sal_Int32 i = 0; i < nProps; ++i )
{
const ::com::sun::star::beans::PropertyValue& rProp = aTypeProps[i];
if ( rProp.Name.compareToAscii("Extensions") == COMPARE_EQUAL )
{
::com::sun::star::uno::Sequence < ::rtl::OUString > aExtensions;
if ( ( rProp.Value >>= aExtensions ) && aExtensions.getLength() > 0 )
{
const ::rtl::OUString* pExtensions = aExtensions.getConstArray();
aExtension = String( pExtensions[0] );
break;
}
}
}
}
}
catch( const ::com::sun::star::uno::RuntimeException& )
{
throw; // dont hide it!
}
catch( const ::com::sun::star::uno::Exception& )
{
// type detection failed -> no extension
}
return aExtension;
}
static sal_uInt16 GetIndexOfExtension_Impl( const String& rExtension )
{
sal_uInt16 nRet = NO_INDEX;
if ( rExtension.Len() )
{
sal_uInt16 nIndex = 0;
String aExt = rExtension;
aExt.ToLowerAscii();
while ( ExtensionMap_Impl[ nIndex ]._pExt )
{
if ( aExt.EqualsAscii( ExtensionMap_Impl[ nIndex ]._pExt ) )
{
nRet = nIndex;
break;
}
++nIndex;
}
}
return nRet;
}
static sal_uInt16 GetImageId_Impl( const String& rExtension )
{
sal_uInt16 nImage = IMG_FILE;
if ( rExtension.Len() != NO_INDEX )
{
sal_uInt16 nIndex = GetIndexOfExtension_Impl( rExtension );
if ( nIndex != NO_INDEX )
{
nImage = ExtensionMap_Impl[ nIndex ]._nImgId;
if ( !nImage )
nImage = IMG_FILE;
}
}
return nImage;
}
static sal_Bool GetVolumeProperties_Impl( ::ucbhelper::Content& rContent, svtools::VolumeInfo& rVolumeInfo )
{
sal_Bool bRet = sal_False;
try
{
bRet = ( ( rContent.getPropertyValue( ASCII_STRING("IsVolume") ) >>= rVolumeInfo.m_bIsVolume ) &&
( rContent.getPropertyValue( ASCII_STRING("IsRemote") ) >>= rVolumeInfo.m_bIsRemote ) &&
( rContent.getPropertyValue( ASCII_STRING("IsRemoveable") ) >>= rVolumeInfo.m_bIsRemoveable ) &&
( rContent.getPropertyValue( ASCII_STRING("IsFloppy") ) >>= rVolumeInfo.m_bIsFloppy ) &&
( rContent.getPropertyValue( ASCII_STRING("IsCompactDisc") ) >>= rVolumeInfo.m_bIsCompactDisc ) );
}
catch( const ::com::sun::star::uno::RuntimeException& )
{
throw; // dont hide it!
}
catch( const ::com::sun::star::uno::Exception& )
{
// type detection failed -> no extension
}
return bRet;
}
static sal_uInt16 GetFolderImageId_Impl( const String& rURL )
{
sal_uInt16 nRet = IMG_FOLDER;
::svtools::VolumeInfo aVolumeInfo;
try
{
::ucbhelper::Content aCnt( rURL, ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
if ( GetVolumeProperties_Impl( aCnt, aVolumeInfo ) )
{
if ( aVolumeInfo.m_bIsRemote )
nRet = IMG_NETWORKDEV;
else if ( aVolumeInfo.m_bIsCompactDisc )
nRet = IMG_CDROMDEV;
else if ( aVolumeInfo.m_bIsRemoveable )
nRet = IMG_REMOVEABLEDEV;
else if ( aVolumeInfo.m_bIsVolume )
nRet = IMG_FIXEDDEV;
}
}
catch( const ::com::sun::star::uno::RuntimeException& )
{
throw; // dont hide it!
}
catch( const ::com::sun::star::uno::Exception& )
{
// ...
}
return nRet;
}
static sal_uInt16 GetImageId_Impl( const INetURLObject& rObject, sal_Bool bDetectFolder )
{
RTL_LOGFILE_CONTEXT_AUTHOR( aTimeLog, "svtools", "hb93813", "SvFileInformationManager::GetImageId_Impl()" );
String aExt, sURL = rObject.GetMainURL( INetURLObject::NO_DECODE );
sal_uInt16 nImage = IMG_FILE;
if ( rObject.GetProtocol() == INET_PROT_PRIVATE )
{
String aURLPath = sURL.Copy( URL_PREFIX_PRIV_SOFFICE_LEN );
String aType = aURLPath.GetToken( 0, INET_PATH_TOKEN );
if ( aType == String( RTL_CONSTASCII_USTRINGPARAM("factory") ) )
{
// detect an image id for our "private:factory" urls
aExt = GetImageExtensionByFactory_Impl( sURL );
if ( aExt.Len() > 0 )
nImage = GetImageId_Impl( aExt );
return nImage;
}
else if ( aType == String( RTL_CONSTASCII_USTRINGPARAM("image") ) )
nImage = (sal_uInt16)aURLPath.GetToken( 1, INET_PATH_TOKEN ).ToInt32();
}
else
{
aExt = rObject.getExtension();
if ( aExt.EqualsAscii( "vor" ) )
{
SotStorageRef aStorage = new SotStorage( sURL, STREAM_STD_READ );
sal_uInt16 nId = IMG_WRITERTEMPLATE;
if ( !aStorage->GetError() )
{
SvGlobalName aGlobalName = aStorage->GetClassName();
if ( aGlobalName == SvGlobalName(SO3_SC_CLASSID_50) || aGlobalName == SvGlobalName(SO3_SC_CLASSID_40) || aGlobalName == SvGlobalName(SO3_SC_CLASSID_30) )
nId = IMG_CALCTEMPLATE;
else if ( aGlobalName == SvGlobalName(SO3_SDRAW_CLASSID_50) )
nId = IMG_DRAWTEMPLATE;
else if ( aGlobalName == SvGlobalName(SO3_SIMPRESS_CLASSID_50) ||
aGlobalName == SvGlobalName(SO3_SIMPRESS_CLASSID_40) || aGlobalName == SvGlobalName(SO3_SIMPRESS_CLASSID_30) )
nId = IMG_IMPRESSTEMPLATE;
else if ( aGlobalName == SvGlobalName(SO3_SM_CLASSID_50) || aGlobalName == SvGlobalName(SO3_SM_CLASSID_40) || aGlobalName == SvGlobalName(SO3_SM_CLASSID_30) )
nId = IMG_MATHTEMPLATE;
}
return nId;
}
}
if ( nImage == IMG_FILE && sURL.Len() )
{
if ( bDetectFolder && CONTENT_HELPER::IsFolder( sURL ) )
nImage = GetFolderImageId_Impl( sURL );
else if ( aExt.Len() > 0 )
nImage = GetImageId_Impl( aExt );
}
return nImage;
}
static sal_uInt16 GetDescriptionId_Impl( const String& rExtension, sal_Bool& rbShowExt )
{
sal_uInt16 nId = 0;
if ( rExtension.Len() != NO_INDEX )
{
sal_uInt16 nIndex = GetIndexOfExtension_Impl( rExtension );
if ( nIndex != NO_INDEX )
{
nId = ExtensionMap_Impl[ nIndex ]._nStrId;
rbShowExt = ExtensionMap_Impl[ nIndex ]._bExt;
}
}
return nId;
}
static String GetDescriptionByFactory_Impl( const String& rFactory )
{
sal_uInt16 nResId = 0;
if ( rFactory.EqualsIgnoreCaseAscii( "swriter", 0, 7 ) )
nResId = STR_DESCRIPTION_FACTORY_WRITER;
else if ( rFactory.EqualsIgnoreCaseAscii( "scalc", 0, 5 ) )
nResId = STR_DESCRIPTION_FACTORY_CALC;
else if ( rFactory.EqualsIgnoreCaseAscii( "simpress", 0, 8 ) )
nResId = STR_DESCRIPTION_FACTORY_IMPRESS;
else if ( rFactory.EqualsIgnoreCaseAscii( "sdraw", 0, 5 ) )
nResId = STR_DESCRIPTION_FACTORY_DRAW;
else if ( rFactory.EqualsIgnoreCaseAscii( "swriter/web", 0, 11 ) )
nResId = STR_DESCRIPTION_FACTORY_WRITERWEB;
else if ( rFactory.EqualsIgnoreCaseAscii( "swriter/globaldocument", 0, 22 ) )
nResId = STR_DESCRIPTION_FACTORY_GLOBALDOC;
else if ( rFactory.EqualsIgnoreCaseAscii( "smath", 0, 5 ) )
nResId = STR_DESCRIPTION_FACTORY_MATH;
else if ( rFactory.EqualsIgnoreCaseAscii( "sdatabase", 0, 9 ) )
nResId = STR_DESCRIPTION_FACTORY_DATABASE;
if ( nResId )
{
SolarMutexGuard aGuard;
return SvtResId(nResId).toString();
}
return rtl::OUString();
}
static sal_uInt16 GetFolderDescriptionId_Impl( const String& rURL )
{
sal_uInt16 nRet = STR_DESCRIPTION_FOLDER;
svtools::VolumeInfo aVolumeInfo;
try
{
::ucbhelper::Content aCnt( rURL, ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
if ( GetVolumeProperties_Impl( aCnt, aVolumeInfo ) )
{
if ( aVolumeInfo.m_bIsRemote )
nRet = STR_DESCRIPTION_REMOTE_VOLUME;
else if ( aVolumeInfo.m_bIsFloppy )
nRet = STR_DESCRIPTION_FLOPPY_VOLUME;
else if ( aVolumeInfo.m_bIsCompactDisc )
nRet = STR_DESCRIPTION_CDROM_VOLUME;
else if ( aVolumeInfo.m_bIsRemoveable || aVolumeInfo.m_bIsVolume )
nRet = STR_DESCRIPTION_LOCALE_VOLUME;
}
}
catch( const ::com::sun::star::uno::RuntimeException& )
{
throw; // dont hide it!
}
catch( const ::com::sun::star::uno::Exception& )
{
// ...
}
return nRet;
}
static Image GetImageFromList_Impl( sal_uInt16 nImageId, sal_Bool bBig )
{
if ( !bBig && IMG_FOLDER == nImageId )
// return our new small folder image (256 colors)
return Image( SvtResId( IMG_SVT_FOLDER ) );
ImageList* pList = NULL;
static vcl::DeleteOnDeinit< ImageList > xSmallImageList( NULL );
static vcl::DeleteOnDeinit< ImageList > xBigImageList( NULL );
static sal_uLong nStyle = Application::GetSettings().GetStyleSettings().GetSymbolsStyle();
// If the style has been changed, throw away our cache of the older images
if ( nStyle != Application::GetSettings().GetStyleSettings().GetSymbolsStyle() )
{
xSmallImageList.reset();
xBigImageList.reset();
nStyle = Application::GetSettings().GetStyleSettings().GetSymbolsStyle();
}
if ( bBig )
{
if ( !xBigImageList.get() )
xBigImageList.reset(new ImageList(SvtResId(RID_SVTOOLS_IMAGELIST_BIG)));
pList = xBigImageList.get();
}
else
{
if ( !xSmallImageList.get() )
xSmallImageList.reset(new ImageList(SvtResId(RID_SVTOOLS_IMAGELIST_SMALL)));
pList = xSmallImageList.get();
}
if ( pList->HasImageAtPos( nImageId ) )
return pList->GetImage( nImageId );
return Image();
}
String SvFileInformationManager::GetDescription_Impl( const INetURLObject& rObject, sal_Bool bDetectFolder )
{
RTL_LOGFILE_CONTEXT_AUTHOR( aTimeLog, "svtools", "hb93813", "SvFileInformationManager::GetDescription_Impl()" );
String sDescription;
String sExtension( rObject.getExtension() ), sURL( rObject.GetMainURL( INetURLObject::NO_DECODE ) );
sal_uInt16 nResId = 0;
sal_Bool bShowExt = sal_False, bDetected = sal_False, bOnlyFile = sal_False;
sal_Bool bFolder = bDetectFolder ? CONTENT_HELPER::IsFolder( sURL ) : sal_False;
if ( !bFolder )
{
if ( !bDetected )
{
if ( rObject.GetProtocol() == INET_PROT_PRIVATE )
{
String aURLPath = sURL.Copy( URL_PREFIX_PRIV_SOFFICE_LEN );
String aType = aURLPath.GetToken( 0, INET_PATH_TOKEN );
if ( aType == String( RTL_CONSTASCII_USTRINGPARAM("factory") ) )
{
sDescription = GetDescriptionByFactory_Impl( aURLPath.Copy( aURLPath.Search( INET_PATH_TOKEN ) + 1 ) );
bDetected = sal_True;
}
}
if ( !bDetected )
{
// search a description by extension
sal_Bool bExt = ( sExtension.Len() > 0 );
if ( bExt )
{
sExtension.ToLowerAscii();
nResId = GetDescriptionId_Impl( sExtension, bShowExt );
}
if ( !nResId )
{
nResId = STR_DESCRIPTION_FILE;
bOnlyFile = bExt;
}
}
}
}
else
nResId = GetFolderDescriptionId_Impl( sURL );
if ( nResId > 0 )
{
if ( bOnlyFile )
{
bShowExt = sal_False;
sExtension.ToUpperAscii();
sDescription = sExtension;
sDescription += '-';
}
SolarMutexGuard aGuard;
sDescription += SvtResId(nResId).toString();
}
DBG_ASSERT( sDescription.Len() > 0, "file without description" );
if ( bShowExt )
{
sDescription += String( RTL_CONSTASCII_USTRINGPARAM(" (") );
sDescription += sExtension;
sDescription += ')';
}
return sDescription;
}
Image SvFileInformationManager::GetImage( const INetURLObject& rObject, sal_Bool bBig )
{
sal_uInt16 nImage = GetImageId_Impl( rObject, sal_True );
DBG_ASSERT( nImage, "invalid ImageId" );
return GetImageFromList_Impl( nImage, bBig );
}
Image SvFileInformationManager::GetFileImage( const INetURLObject& rObject, sal_Bool bBig )
{
sal_Int16 nImage = GetImageId_Impl( rObject, sal_False );
DBG_ASSERT( nImage, "invalid ImageId" );
return GetImageFromList_Impl( nImage, bBig );
}
Image SvFileInformationManager::GetImageNoDefault( const INetURLObject& rObject, sal_Bool bBig )
{
sal_uInt16 nImage = GetImageId_Impl( rObject, sal_True );
DBG_ASSERT( nImage, "invalid ImageId" );
if ( nImage == IMG_FILE )
return Image();
return GetImageFromList_Impl( nImage, bBig );
}
Image SvFileInformationManager::GetFolderImage( const svtools::VolumeInfo& rInfo, sal_Bool bBig )
{
sal_uInt16 nImage = IMG_FOLDER;
DBG_ASSERT( nImage, "invalid ImageId" );
if ( rInfo.m_bIsRemote )
nImage = IMG_NETWORKDEV;
else if ( rInfo.m_bIsCompactDisc )
nImage = IMG_CDROMDEV;
else if ( rInfo.m_bIsRemoveable || rInfo.m_bIsFloppy )
nImage = IMG_REMOVEABLEDEV;
else if ( rInfo.m_bIsVolume )
nImage = IMG_FIXEDDEV;
return GetImageFromList_Impl( nImage, bBig );
}
String SvFileInformationManager::GetDescription( const INetURLObject& rObject )
{
return SvFileInformationManager::GetDescription_Impl( rObject, sal_True );
}
String SvFileInformationManager::GetFileDescription( const INetURLObject& rObject )
{
return SvFileInformationManager::GetDescription_Impl( rObject, sal_False );
}
String SvFileInformationManager::GetFolderDescription( const svtools::VolumeInfo& rInfo )
{
sal_uInt16 nResId = STR_DESCRIPTION_FOLDER;
if ( rInfo.m_bIsRemote )
nResId = STR_DESCRIPTION_REMOTE_VOLUME;
else if ( rInfo.m_bIsFloppy )
nResId = STR_DESCRIPTION_FLOPPY_VOLUME;
else if ( rInfo.m_bIsCompactDisc )
nResId = STR_DESCRIPTION_CDROM_VOLUME;
else if ( rInfo.m_bIsRemoveable || rInfo.m_bIsVolume )
nResId = STR_DESCRIPTION_LOCALE_VOLUME;
return SvtResId(nResId).toString();
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink