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 <svtools/imagemgr.hxx> 21 #include <tools/diagnose_ex.h> 22 #include <tools/urlobj.hxx> 23 #include <tools/debug.hxx> 24 #include <vcl/image.hxx> 25 #include <sot/storage.hxx> 26 #include <comphelper/classids.hxx> 27 #include <unotools/ucbhelper.hxx> 28 #include <comphelper/processfactory.hxx> 29 #include <com/sun/star/beans/PropertyValue.hpp> 30 #include <com/sun/star/container/XNameAccess.hpp> 31 #include <com/sun/star/document/XTypeDetection.hpp> 32 #include <com/sun/star/ucb/CommandAbortedException.hpp> 33 #include <com/sun/star/ucb/ContentCreationException.hpp> 34 #include <com/sun/star/ucb/XCommandEnvironment.hpp> 35 #include <com/sun/star/uno/XComponentContext.hpp> 36 #include <ucbhelper/content.hxx> 37 #include <svtools/strings.hrc> 38 #include <svtools/svtresid.hxx> 39 #include <bitmaps.hlst> 40 #include <strings.hxx> 41 42 // globals ******************************************************************* 43 44 #define NO_INDEX (-1) 45 #define CONTENT_HELPER ::utl::UCBContentHelper 46 47 namespace { 48 49 struct SvtExtensionResIdMapping_Impl 50 { 51 const char* _pExt; 52 bool _bExt; 53 TranslateId pStrId; 54 SvImageId _nImgId; 55 }; 56 57 } 58 59 SvtExtensionResIdMapping_Impl const ExtensionMap_Impl[] = 60 { 61 { "awk", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 62 { "bas", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 63 { "bat", true, STR_DESCRIPTION_BATCHFILE, SvImageId::NONE }, 64 { "bmk", false, STR_DESCRIPTION_BOOKMARKFILE, SvImageId::NONE }, 65 { "bmp", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::Bitmap }, 66 { "c", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 67 { "cfg", false, STR_DESCRIPTION_CFGFILE, SvImageId::NONE }, 68 { "cmd", true, STR_DESCRIPTION_BATCHFILE, SvImageId::NONE }, 69 { "cob", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 70 { "com", true, STR_DESCRIPTION_APPLICATION, SvImageId::NONE }, 71 { "cxx", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 72 { "dbf", true, STR_DESCRIPTION_DATABASE_TABLE, SvImageId::Table }, 73 { "def", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 74 { "dll", true, STR_DESCRIPTION_SYSFILE, SvImageId::NONE }, 75 { "doc", false, STR_DESCRIPTION_WORD_DOC, SvImageId::Writer }, 76 { "dot", false, STR_DESCRIPTION_WORD_DOC, SvImageId::WriterTemplate }, 77 { "docx", false, STR_DESCRIPTION_WORD_DOC, SvImageId::Writer }, 78 { "dxf", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::DXF }, 79 { "exe", true, STR_DESCRIPTION_APPLICATION, SvImageId::NONE }, 80 { "gif", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::GIF }, 81 { "h", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 82 { "hlp", false, STR_DESCRIPTION_HELP_DOC, SvImageId::NONE }, 83 { "hrc", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 84 { "htm", false, STR_DESCRIPTION_HTMLFILE, SvImageId::HTML }, 85 { "html", false, STR_DESCRIPTION_HTMLFILE, SvImageId::HTML }, 86 { "asp", false, STR_DESCRIPTION_HTMLFILE, SvImageId::HTML }, 87 { "hxx", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 88 { "ini", false, STR_DESCRIPTION_CFGFILE, SvImageId::NONE }, 89 { "java", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 90 { "jpeg", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::JPG }, 91 { "jpg", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::JPG }, 92 { "lha", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 93 #ifdef _WIN32 94 { "lnk", false, {}, SvImageId::NONE }, 95 #endif 96 { "log", true, STR_DESCRIPTION_LOGFILE, SvImageId::NONE }, 97 { "lst", true, STR_DESCRIPTION_LOGFILE, SvImageId::NONE }, 98 { "met", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::MET }, 99 { "mml", false, STR_DESCRIPTION_MATHML_DOC, SvImageId::Math }, 100 { "mod", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 101 { "odb", false, STR_DESCRIPTION_OO_DATABASE_DOC, SvImageId::OO_DatabaseDoc }, 102 { "odg", false, STR_DESCRIPTION_OO_DRAW_DOC, SvImageId::OO_DrawDoc }, 103 { "odf", false, STR_DESCRIPTION_OO_MATH_DOC, SvImageId::OO_MathDoc }, 104 { "odm", false, STR_DESCRIPTION_OO_GLOBAL_DOC, SvImageId::OO_GlobalDoc }, 105 { "odp", false, STR_DESCRIPTION_OO_IMPRESS_DOC, SvImageId::OO_ImpressDoc }, 106 { "ods", false, STR_DESCRIPTION_OO_CALC_DOC, SvImageId::OO_CalcDoc }, 107 { "odt", false, STR_DESCRIPTION_OO_WRITER_DOC, SvImageId::OO_WriterDoc }, 108 { "otg", false, STR_DESCRIPTION_OO_DRAW_TEMPLATE, SvImageId::OO_DrawTemplate }, 109 { "otp", false, STR_DESCRIPTION_OO_IMPRESS_TEMPLATE, SvImageId::OO_ImpressTemplate }, 110 { "ots", false, STR_DESCRIPTION_OO_CALC_TEMPLATE, SvImageId::OO_CalcTemplate }, 111 { "ott", false, STR_DESCRIPTION_OO_WRITER_TEMPLATE, SvImageId::OO_WriterTemplate }, 112 { "pas", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 113 { "pcd", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::PCD }, 114 { "pct", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::PCT }, 115 { "pict", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::PCT }, 116 { "pcx", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::PCX }, 117 { "pl", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 118 { "png", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::PNG }, 119 { "rar", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 120 { "rtf", false, STR_DESCRIPTION_WORD_DOC, SvImageId::Writer }, 121 { "sbl", false, {}, SvImageId::NONE }, 122 { "sch", false, {}, SvImageId::NONE }, 123 { "sda", false, { nullptr, STR_DESCRIPTION_SDRAW_DOC}, SvImageId::Draw }, 124 { "sdb", false, STR_DESCRIPTION_SDATABASE_DOC, SvImageId::Database }, 125 { "sdc", false, { nullptr, STR_DESCRIPTION_SCALC_DOC}, SvImageId::Calc }, 126 { "sdd", false, { nullptr, STR_DESCRIPTION_SIMPRESS_DOC}, SvImageId::Impress }, 127 { "sdp", false, { nullptr, STR_DESCRIPTION_SIMPRESS_DOC}, SvImageId::NONE }, 128 { "sds", false, { nullptr, STR_DESCRIPTION_SCHART_DOC}, SvImageId::NONE }, 129 { "sdw", false, { nullptr, STR_DESCRIPTION_SWRITER_DOC}, SvImageId::Writer }, 130 { "sga", false, {}, SvImageId::NONE }, 131 { "sgl", false, STR_DESCRIPTION_GLOBALDOC, SvImageId::GlobalDoc }, 132 { "shtml", false, STR_DESCRIPTION_HTMLFILE, SvImageId::HTML }, 133 { "sim", false, STR_DESCRIPTION_SIMAGE_DOC, SvImageId::SIM }, 134 { "smf", false, { nullptr, STR_DESCRIPTION_SMATH_DOC}, SvImageId::Math }, 135 { "src", true, STR_DESCRIPTION_SOURCEFILE, SvImageId::NONE }, 136 { "svh", false, STR_DESCRIPTION_HELP_DOC, SvImageId::NONE }, 137 { "svm", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::SVM }, 138 { "stc", false, STR_DESCRIPTION_CALC_TEMPLATE, SvImageId::CalcTemplate }, 139 { "std", false, STR_DESCRIPTION_DRAW_TEMPLATE, SvImageId::DrawTemplate }, 140 { "sti", false, STR_DESCRIPTION_IMPRESS_TEMPLATE, SvImageId::ImpressTemplate }, 141 { "stw", false, STR_DESCRIPTION_WRITER_TEMPLATE, SvImageId::WriterTemplate }, 142 { "sxc", false, STR_DESCRIPTION_SXCALC_DOC, SvImageId::Calc }, 143 { "sxd", false, STR_DESCRIPTION_SXDRAW_DOC, SvImageId::Draw }, 144 { "sxg", false, STR_DESCRIPTION_SXGLOBAL_DOC, SvImageId::GlobalDoc }, 145 { "sxi", false, STR_DESCRIPTION_SXIMPRESS_DOC, SvImageId::Impress }, 146 { "sxm", false, STR_DESCRIPTION_SXMATH_DOC, SvImageId::Math }, 147 { "sxs", false, STR_DESCRIPTION_SXCHART_DOC, SvImageId::NONE }, 148 { "sxw", false, STR_DESCRIPTION_SXWRITER_DOC, SvImageId::Writer }, 149 { "sys", true, STR_DESCRIPTION_SYSFILE, SvImageId::NONE }, 150 { "tif", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::TIFF }, 151 { "tiff", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::TIFF }, 152 { "txt", false, STR_DESCRIPTION_TEXTFILE, SvImageId::TextFile }, 153 { "url", false, STR_DESCRIPTION_LINK, SvImageId::NONE }, 154 { "vor", false, STR_DESCRIPTION_SOFFICE_TEMPLATE_DOC, SvImageId::WriterTemplate }, 155 { "vxd", true, STR_DESCRIPTION_SYSFILE, SvImageId::NONE }, 156 { "webp", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::WEBP }, 157 { "wmf", true, STR_DESCRIPTION_GRAPHIC_DOC, SvImageId::WMF }, 158 { "xls", false, STR_DESCRIPTION_EXCEL_DOC, SvImageId::Calc }, 159 { "xlt", false, STR_DESCRIPTION_EXCEL_TEMPLATE_DOC, SvImageId::CalcTemplate }, 160 { "xlsx", false, STR_DESCRIPTION_EXCEL_DOC, SvImageId::Calc }, 161 { "uu", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 162 { "uue", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 163 { "z", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 164 { "zip", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 165 { "zoo", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 166 { "gz", true, STR_DESCRIPTION_ARCHIVFILE, SvImageId::NONE }, 167 { "ppt", false, STR_DESCRIPTION_POWERPOINT, SvImageId::Impress }, 168 { "pot", false, STR_DESCRIPTION_POWERPOINT_TEMPLATE, SvImageId::ImpressTemplate }, 169 { "pps", false, STR_DESCRIPTION_POWERPOINT_SHOW, SvImageId::Impress }, 170 { "pptx", false, STR_DESCRIPTION_POWERPOINT, SvImageId::Impress }, 171 { "oxt", false, STR_DESCRIPTION_EXTENSION, SvImageId::Extension }, 172 { nullptr, false, {}, SvImageId::NONE } 173 }; 174 175 namespace { 176 177 struct SvtFactory2ExtensionMapping_Impl 178 { 179 const char* _pFactory; 180 const char* _pExtension; 181 }; 182 183 } 184 185 // mapping from "private:factory" url to extension 186 187 SvtFactory2ExtensionMapping_Impl const Fac2ExtMap_Impl[] = 188 { 189 { "swriter", "odt" }, 190 { "swriter/web", "html" }, 191 { "swriter/GlobalDocument", "odm" }, 192 { "scalc", "ods" }, 193 { "simpress", "odp" }, 194 { "sdraw", "odg" }, 195 { "smath", "odf" }, 196 { "sdatabase", "odb" }, 197 { nullptr, nullptr } 198 }; 199 200 201 static OUString GetImageExtensionByFactory_Impl( const OUString& rURL ) 202 { 203 INetURLObject aObj( rURL ); 204 OUString aPath = aObj.GetURLPath( INetURLObject::DecodeMechanism::NONE ); 205 OUString aExtension; 206 207 if ( !aPath.isEmpty() ) 208 { 209 sal_uInt16 nIndex = 0; 210 while ( Fac2ExtMap_Impl[ nIndex ]._pFactory ) 211 { 212 if ( aPath.equalsAscii( Fac2ExtMap_Impl[ nIndex ]._pFactory ) ) 213 { 214 // extension found 215 aExtension = OUString::createFromAscii(Fac2ExtMap_Impl[ nIndex ]._pExtension); 216 // and return it 217 return aExtension; 218 } 219 ++nIndex; 220 } 221 } 222 223 // no extension found, so use the type detection (performance brake) 224 225 try 226 { 227 // get the TypeDetection service to access all registered types 228 css::uno::Reference < css::uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext(); 229 css::uno::Reference < css::document::XTypeDetection > xTypeDetector( 230 xContext->getServiceManager()->createInstanceWithContext("com.sun.star.document.TypeDetection", xContext), 231 css::uno::UNO_QUERY ); 232 233 OUString aInternalType = xTypeDetector->queryTypeByURL( rURL ); 234 css::uno::Reference < css::container::XNameAccess > xAccess( xTypeDetector, css::uno::UNO_QUERY ); 235 css::uno::Sequence < css::beans::PropertyValue > aTypeProps; 236 if ( !aInternalType.isEmpty() && xAccess->hasByName( aInternalType ) ) 237 { 238 xAccess->getByName( aInternalType ) >>= aTypeProps; 239 for ( const css::beans::PropertyValue& rProp : std::as_const(aTypeProps) ) 240 { 241 if (rProp.Name == "Extensions") 242 { 243 css::uno::Sequence < OUString > aExtensions; 244 if ( ( rProp.Value >>= aExtensions ) && aExtensions.hasElements() ) 245 { 246 const OUString* pExtensions = aExtensions.getConstArray(); 247 aExtension = pExtensions[0]; 248 break; 249 } 250 } 251 } 252 } 253 } 254 catch( const css::uno::RuntimeException& ) 255 { 256 throw; // don't hide it! 257 } 258 catch( const css::uno::Exception& ) 259 { 260 // type detection failed -> no extension 261 } 262 263 return aExtension; 264 } 265 266 static sal_Int32 GetIndexOfExtension_Impl( const OUString& rExtension ) 267 { 268 sal_Int32 nRet = NO_INDEX; 269 if ( !rExtension.isEmpty() ) 270 { 271 sal_Int32 nIndex = 0; 272 OUString aExt = rExtension.toAsciiLowerCase(); 273 while ( ExtensionMap_Impl[ nIndex ]._pExt ) 274 { 275 if ( aExt.equalsAscii( ExtensionMap_Impl[ nIndex ]._pExt ) ) 276 { 277 nRet = nIndex; 278 break; 279 } 280 ++nIndex; 281 } 282 } 283 284 return nRet; 285 } 286 287 static SvImageId GetImageId_Impl( const OUString& rExtension ) 288 { 289 SvImageId nImage = SvImageId::File; 290 sal_Int32 nIndex = GetIndexOfExtension_Impl( rExtension ); 291 if ( nIndex != NO_INDEX ) 292 { 293 nImage = ExtensionMap_Impl[ nIndex ]._nImgId; 294 if ( nImage == SvImageId::NONE ) 295 nImage = SvImageId::File; 296 } 297 298 return nImage; 299 } 300 301 static bool GetVolumeProperties_Impl( ::ucbhelper::Content& rContent, svtools::VolumeInfo& rVolumeInfo ) 302 { 303 bool bRet = false; 304 305 try 306 { 307 bRet = ( ( rContent.getPropertyValue( "IsVolume" ) >>= rVolumeInfo.m_bIsVolume ) && 308 ( rContent.getPropertyValue( "IsRemote" ) >>= rVolumeInfo.m_bIsRemote ) && 309 ( rContent.getPropertyValue( "IsRemoveable" ) >>= rVolumeInfo.m_bIsRemoveable ) && 310 ( rContent.getPropertyValue( "IsFloppy" ) >>= rVolumeInfo.m_bIsFloppy ) && 311 ( rContent.getPropertyValue( "IsCompactDisc" ) >>= rVolumeInfo.m_bIsCompactDisc ) ); 312 } 313 catch( const css::uno::RuntimeException& ) 314 { 315 throw; // don't hide it! 316 } 317 catch( const css::uno::Exception& ) 318 { 319 // type detection failed -> no extension 320 } 321 322 return bRet; 323 } 324 325 static SvImageId GetFolderImageId_Impl( const OUString& rURL ) 326 { 327 SvImageId nRet = SvImageId::Folder; 328 try 329 { 330 ::svtools::VolumeInfo aVolumeInfo; 331 ::ucbhelper::Content aCnt( rURL, css::uno::Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() ); 332 if ( GetVolumeProperties_Impl( aCnt, aVolumeInfo ) ) 333 { 334 if ( aVolumeInfo.m_bIsRemote ) 335 nRet = SvImageId::NetworkDevice; 336 else if ( aVolumeInfo.m_bIsCompactDisc ) 337 nRet = SvImageId::CDRomDevice; 338 else if ( aVolumeInfo.m_bIsRemoveable ) 339 nRet = SvImageId::RemoveableDevice; 340 else if ( aVolumeInfo.m_bIsVolume ) 341 nRet = SvImageId::FixedDevice; 342 } 343 } 344 catch( const css::uno::RuntimeException& ) 345 { 346 throw; // don't hide it! 347 } 348 catch( const css::uno::Exception& ) 349 { 350 351 } 352 return nRet; 353 } 354 355 static bool isFolder( 356 OUString const & url, css::uno::Reference<css::ucb::XCommandEnvironment> const & env) 357 { 358 try { 359 return ucbhelper::Content(url, env, comphelper::getProcessComponentContext()).isFolder(); 360 } catch (css::uno::RuntimeException &) { 361 throw; 362 } catch (css::ucb::CommandAbortedException &) { 363 assert(false); // this cannot happen 364 throw; 365 } catch (css::uno::Exception &) { 366 TOOLS_INFO_EXCEPTION("svtools.misc", "isFolder(" << url << ")"); 367 return false; 368 } 369 } 370 371 static SvImageId GetImageId_Impl( 372 const INetURLObject& rObject, bool bDetectFolder, 373 css::uno::Reference<css::ucb::XCommandEnvironment> const & env ) 374 { 375 OUString aExt, sURL = rObject.GetMainURL( INetURLObject::DecodeMechanism::NONE ); 376 SvImageId nImage = SvImageId::File; 377 378 if ( rObject.GetProtocol() == INetProtocol::PrivSoffice ) 379 { 380 OUString aURLPath = sURL.copy( strlen(URL_PREFIX_PRIV_SOFFICE) ); 381 OUString aType = aURLPath.getToken( 0, '/' ); 382 if ( aType == "factory" ) 383 { 384 // detect an image id for our "private:factory" urls 385 aExt = GetImageExtensionByFactory_Impl( sURL ); 386 if ( !aExt.isEmpty() ) 387 nImage = GetImageId_Impl( aExt ); 388 return nImage; 389 } 390 else if ( aType == "image" ) 391 nImage = static_cast<SvImageId>(aURLPath.getToken( 1, '/' ).toInt32()); 392 } 393 else 394 { 395 aExt = rObject.getExtension(); 396 if ( aExt == "vor" ) 397 { 398 SvImageId nId = SvImageId::WriterTemplate; 399 try 400 { 401 tools::SvRef<SotStorage> aStorage = new SotStorage( sURL, StreamMode::STD_READ ); 402 if ( !aStorage->GetError() ) 403 { 404 SvGlobalName aGlobalName = aStorage->GetClassName(); 405 if ( aGlobalName == SvGlobalName(SO3_SC_CLASSID_50) || aGlobalName == SvGlobalName(SO3_SC_CLASSID_40) || aGlobalName == SvGlobalName(SO3_SC_CLASSID_30) ) 406 nId = SvImageId::CalcTemplate; 407 else if ( aGlobalName == SvGlobalName(SO3_SDRAW_CLASSID_50) ) 408 nId = SvImageId::DrawTemplate; 409 else if ( aGlobalName == SvGlobalName(SO3_SIMPRESS_CLASSID_50) || 410 aGlobalName == SvGlobalName(SO3_SIMPRESS_CLASSID_40) || aGlobalName == SvGlobalName(SO3_SIMPRESS_CLASSID_30) ) 411 nId = SvImageId::ImpressTemplate; 412 else if ( aGlobalName == SvGlobalName(SO3_SM_CLASSID_50) || aGlobalName == SvGlobalName(SO3_SM_CLASSID_40) || aGlobalName == SvGlobalName(SO3_SM_CLASSID_30) ) 413 nId = SvImageId::MathTemplate; 414 } 415 } 416 catch (const css::ucb::ContentCreationException&) 417 { 418 TOOLS_WARN_EXCEPTION("svtools.misc", "GetImageId_Impl"); 419 } 420 421 return nId; 422 } 423 } 424 425 if ( nImage == SvImageId::File && !sURL.isEmpty() ) 426 { 427 if ( bDetectFolder && isFolder( sURL, env ) ) 428 nImage = GetFolderImageId_Impl( sURL ); 429 else if ( !aExt.isEmpty() ) 430 nImage = GetImageId_Impl( aExt ); 431 } 432 return nImage; 433 } 434 435 static TranslateId GetDescriptionId_Impl( const OUString& rExtension, bool& rbShowExt ) 436 { 437 TranslateId pId; 438 sal_Int32 nIndex = GetIndexOfExtension_Impl( rExtension ); 439 if ( nIndex != NO_INDEX ) 440 { 441 pId = ExtensionMap_Impl[ nIndex ].pStrId; 442 rbShowExt = ExtensionMap_Impl[ nIndex ]._bExt; 443 } 444 445 return pId; 446 } 447 448 static OUString GetDescriptionByFactory_Impl( const OUString& rFactory ) 449 { 450 TranslateId pResId; 451 if ( rFactory.startsWithIgnoreAsciiCase( "swriter" ) ) 452 pResId = STR_DESCRIPTION_FACTORY_WRITER; 453 else if ( rFactory.startsWithIgnoreAsciiCase( "scalc" ) ) 454 pResId = STR_DESCRIPTION_FACTORY_CALC; 455 else if ( rFactory.startsWithIgnoreAsciiCase( "simpress" ) ) 456 pResId = STR_DESCRIPTION_FACTORY_IMPRESS; 457 else if ( rFactory.startsWithIgnoreAsciiCase( "sdraw" ) ) 458 pResId = STR_DESCRIPTION_FACTORY_DRAW; 459 else if ( rFactory.startsWithIgnoreAsciiCase( "swriter/web" ) ) 460 pResId = STR_DESCRIPTION_FACTORY_WRITERWEB; 461 else if ( rFactory.startsWithIgnoreAsciiCase( "swriter/globaldocument" ) ) 462 pResId = STR_DESCRIPTION_FACTORY_GLOBALDOC; 463 else if ( rFactory.startsWithIgnoreAsciiCase( "smath" ) ) 464 pResId = STR_DESCRIPTION_FACTORY_MATH; 465 else if ( rFactory.startsWithIgnoreAsciiCase( "sdatabase" ) ) 466 pResId = STR_DESCRIPTION_FACTORY_DATABASE; 467 468 if (pResId) 469 { 470 return SvtResId(pResId); 471 } 472 return OUString(); 473 } 474 475 static TranslateId GetFolderDescriptionId_Impl( const OUString& rURL ) 476 { 477 TranslateId pRet = STR_DESCRIPTION_FOLDER; 478 try 479 { 480 ::ucbhelper::Content aCnt( rURL, css::uno::Reference< css::ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() ); 481 svtools::VolumeInfo aVolumeInfo; 482 if ( GetVolumeProperties_Impl( aCnt, aVolumeInfo ) ) 483 { 484 if ( aVolumeInfo.m_bIsRemote ) 485 pRet = STR_DESCRIPTION_REMOTE_VOLUME; 486 else if ( aVolumeInfo.m_bIsFloppy ) 487 pRet = STR_DESCRIPTION_FLOPPY_VOLUME; 488 else if ( aVolumeInfo.m_bIsCompactDisc ) 489 pRet = STR_DESCRIPTION_CDROM_VOLUME; 490 else if ( aVolumeInfo.m_bIsRemoveable || aVolumeInfo.m_bIsVolume ) 491 pRet = STR_DESCRIPTION_LOCALE_VOLUME; 492 } 493 } 494 catch( const css::uno::RuntimeException& ) 495 { 496 throw; // don't hide it! 497 } 498 catch( const css::uno::Exception& ) 499 { 500 501 } 502 return pRet; 503 } 504 505 static OUString GetImageNameFromList_Impl( SvImageId nImageId, vcl::ImageType eImageType ) 506 { 507 if (eImageType == vcl::ImageType::Size32) 508 { 509 switch (nImageId) 510 { 511 case SvImageId::HTML: 512 return BMP_HTML_32; 513 case SvImageId::OO_DatabaseDoc: 514 return BMP_OO_DATABASE_DOC_32; 515 case SvImageId::OO_DrawDoc: 516 return BMP_OO_DRAW_DOC_32; 517 case SvImageId::OO_MathDoc: 518 return BMP_OO_MATH_DOC_32; 519 case SvImageId::OO_GlobalDoc: 520 return BMP_OO_GLOBAL_DOC_32; 521 case SvImageId::OO_ImpressDoc: 522 return BMP_OO_IMPRESS_DOC_32; 523 case SvImageId::OO_CalcDoc: 524 return BMP_OO_CALC_DOC_32; 525 case SvImageId::OO_WriterDoc: 526 return BMP_OO_WRITER_DOC_32; 527 case SvImageId::OO_WriterTemplate: 528 return BMP_OO_WRITER_TEMPLATE_32; 529 default: break; 530 } 531 } 532 else if (eImageType == vcl::ImageType::Size26) 533 { 534 switch (nImageId) 535 { 536 case SvImageId::Impress: 537 return BMP_IMPRESS_LC; 538 case SvImageId::Bitmap: 539 return BMP_BITMAP_LC; 540 case SvImageId::Calc: 541 return BMP_CALC_LC; 542 case SvImageId::CalcTemplate: 543 return BMP_CALCTEMPLATE_LC; 544 case SvImageId::Database: 545 return BMP_DATABASE_LC; 546 case SvImageId::ImpressTemplate: 547 return BMP_IMPRESSTEMPLATE_LC; 548 case SvImageId::GIF: 549 return BMP_GIF_LC; 550 case SvImageId::HTML: 551 return BMP_HTML_LC; 552 case SvImageId::JPG: 553 return BMP_JPG_LC; 554 case SvImageId::Math: 555 return BMP_MATH_LC; 556 case SvImageId::MathTemplate: 557 return BMP_MATHTEMPLATE_LC; 558 case SvImageId::File: 559 return BMP_FILE_LC; 560 case SvImageId::PCD: 561 return BMP_PCD_LC; 562 case SvImageId::PCT: 563 return BMP_PCT_LC; 564 case SvImageId::PCX: 565 return BMP_PCX_LC; 566 case SvImageId::SIM: 567 return BMP_SIM_LC; 568 case SvImageId::TextFile: 569 return BMP_TEXTFILE_LC; 570 case SvImageId::TIFF: 571 return BMP_TIFF_LC; 572 case SvImageId::WEBP: 573 return BMP_WEBP_LC; 574 case SvImageId::WMF: 575 return BMP_WMF_LC; 576 case SvImageId::Writer: 577 return BMP_WRITER_LC; 578 case SvImageId::WriterTemplate: 579 return BMP_WRITERTEMPLATE_LC; 580 case SvImageId::FixedDevice: 581 return BMP_FIXEDDEV_LC; 582 case SvImageId::RemoveableDevice: 583 return BMP_REMOVABLEDEV_LC; 584 case SvImageId::CDRomDevice: 585 return BMP_CDROMDEV_LC; 586 case SvImageId::NetworkDevice: 587 return BMP_NETWORKDEV_LC; 588 case SvImageId::Table: 589 return BMP_TABLE_LC; 590 case SvImageId::Folder: 591 return BMP_FOLDER_LC; 592 case SvImageId::DXF: 593 return BMP_DXF_LC; 594 case SvImageId::MET: 595 return BMP_MET_LC; 596 case SvImageId::PNG: 597 return BMP_PNG_LC; 598 case SvImageId::SVM: 599 return BMP_SVM_LC; 600 case SvImageId::GlobalDoc: 601 return BMP_GLOBAL_DOC_LC; 602 case SvImageId::Draw: 603 return BMP_DRAW_LC; 604 case SvImageId::DrawTemplate: 605 return BMP_DRAWTEMPLATE_LC; 606 case SvImageId::OO_DatabaseDoc: 607 return BMP_OO_DATABASE_DOC_LC; 608 case SvImageId::OO_DrawDoc: 609 return BMP_OO_DRAW_DOC_LC; 610 case SvImageId::OO_MathDoc: 611 return BMP_OO_MATH_DOC_LC; 612 case SvImageId::OO_GlobalDoc: 613 return BMP_OO_GLOBAL_DOC_LC; 614 case SvImageId::OO_ImpressDoc: 615 return BMP_OO_IMPRESS_DOC_LC; 616 case SvImageId::OO_CalcDoc: 617 return BMP_OO_CALC_DOC_LC; 618 case SvImageId::OO_WriterDoc: 619 return BMP_OO_WRITER_DOC_LC; 620 case SvImageId::OO_DrawTemplate: 621 return BMP_OO_DRAW_TEMPLATE_LC; 622 case SvImageId::OO_ImpressTemplate: 623 return BMP_OO_IMPRESS_TEMPLATE_LC; 624 case SvImageId::OO_CalcTemplate: 625 return BMP_OO_CALC_TEMPLATE_LC; 626 case SvImageId::OO_WriterTemplate: 627 return BMP_OO_WRITER_TEMPLATE_LC; 628 case SvImageId::Extension: 629 return BMP_EXTENSION_LC; 630 default: break; 631 } 632 } 633 else 634 { 635 switch (nImageId) 636 { 637 case SvImageId::Impress: 638 return BMP_IMPRESS_SC; 639 case SvImageId::Bitmap: 640 return BMP_BITMAP_SC; 641 case SvImageId::Calc: 642 return BMP_CALC_SC; 643 case SvImageId::CalcTemplate: 644 return BMP_CALCTEMPLATE_SC; 645 case SvImageId::Database: 646 return BMP_DATABASE_SC; 647 case SvImageId::ImpressTemplate: 648 return BMP_IMPRESSTEMPLATE_SC; 649 case SvImageId::GIF: 650 return BMP_GIF_SC; 651 case SvImageId::HTML: 652 return BMP_HTML_SC; 653 case SvImageId::JPG: 654 return BMP_JPG_SC; 655 case SvImageId::Math: 656 return BMP_MATH_SC; 657 case SvImageId::MathTemplate: 658 return BMP_MATHTEMPLATE_SC; 659 case SvImageId::File: 660 return BMP_FILE_SC; 661 case SvImageId::PCD: 662 return BMP_PCD_SC; 663 case SvImageId::PCT: 664 return BMP_PCT_SC; 665 case SvImageId::PCX: 666 return BMP_PCX_SC; 667 case SvImageId::SIM: 668 return BMP_SIM_SC; 669 case SvImageId::TextFile: 670 return BMP_TEXTFILE_SC; 671 case SvImageId::TIFF: 672 return BMP_TIFF_SC; 673 case SvImageId::WEBP: 674 return BMP_WEBP_SC; 675 case SvImageId::WMF: 676 return BMP_WMF_SC; 677 case SvImageId::Writer: 678 return BMP_WRITER_SC; 679 case SvImageId::WriterTemplate: 680 return BMP_WRITERTEMPLATE_SC; 681 case SvImageId::FixedDevice: 682 return BMP_FIXEDDEV_SC; 683 case SvImageId::RemoveableDevice: 684 return BMP_REMOVABLEDEV_SC; 685 case SvImageId::CDRomDevice: 686 return BMP_CDROMDEV_SC; 687 case SvImageId::NetworkDevice: 688 return BMP_NETWORKDEV_SC; 689 case SvImageId::Table: 690 return BMP_TABLE_SC; 691 case SvImageId::Folder: 692 return RID_BMP_FOLDER; 693 case SvImageId::DXF: 694 return BMP_DXF_SC; 695 case SvImageId::MET: 696 return BMP_MET_SC; 697 case SvImageId::PNG: 698 return BMP_PNG_SC; 699 case SvImageId::SVM: 700 return BMP_SVM_SC; 701 case SvImageId::GlobalDoc: 702 return BMP_GLOBAL_DOC_SC; 703 case SvImageId::Draw: 704 return BMP_DRAW_SC; 705 case SvImageId::DrawTemplate: 706 return BMP_DRAWTEMPLATE_SC; 707 case SvImageId::OO_DatabaseDoc: 708 return BMP_OO_DATABASE_DOC_SC; 709 case SvImageId::OO_DrawDoc: 710 return BMP_OO_DRAW_DOC_SC; 711 case SvImageId::OO_MathDoc: 712 return BMP_OO_MATH_DOC_SC; 713 case SvImageId::OO_GlobalDoc: 714 return BMP_OO_GLOBAL_DOC_SC; 715 case SvImageId::OO_ImpressDoc: 716 return BMP_OO_IMPRESS_DOC_SC; 717 case SvImageId::OO_CalcDoc: 718 return BMP_OO_CALC_DOC_SC; 719 case SvImageId::OO_WriterDoc: 720 return BMP_OO_WRITER_DOC_SC; 721 case SvImageId::OO_DrawTemplate: 722 return BMP_OO_DRAW_TEMPLATE_SC; 723 case SvImageId::OO_ImpressTemplate: 724 return BMP_OO_IMPRESS_TEMPLATE_SC; 725 case SvImageId::OO_CalcTemplate: 726 return BMP_OO_CALC_TEMPLATE_SC; 727 case SvImageId::OO_WriterTemplate: 728 return BMP_OO_WRITER_TEMPLATE_SC; 729 case SvImageId::Extension: 730 return BMP_EXTENSION_SC; 731 default: break; 732 } 733 } 734 735 return OUString(); 736 } 737 738 static Image GetImageFromList_Impl( SvImageId nImageId, vcl::ImageType eImageType) 739 { 740 OUString sImageName(GetImageNameFromList_Impl(nImageId, eImageType)); 741 if (!sImageName.isEmpty()) 742 return Image(StockImage::Yes, sImageName); 743 return Image(); 744 } 745 746 OUString SvFileInformationManager::GetDescription_Impl( const INetURLObject& rObject, bool bDetectFolder ) 747 { 748 OUString sExtension(rObject.getExtension()); 749 OUString sDescription, sURL( rObject.GetMainURL( INetURLObject::DecodeMechanism::NONE ) ); 750 TranslateId pResId; 751 bool bShowExt = false, bOnlyFile = false; 752 bool bFolder = bDetectFolder && CONTENT_HELPER::IsFolder( sURL ); 753 if ( !bFolder ) 754 { 755 bool bDetected = false; 756 757 if ( rObject.GetProtocol() == INetProtocol::PrivSoffice ) 758 { 759 OUString aURLPath = sURL.copy( strlen(URL_PREFIX_PRIV_SOFFICE) ); 760 OUString aType = aURLPath.getToken( 0, '/' ); 761 if ( aType == "factory" ) 762 { 763 sDescription = GetDescriptionByFactory_Impl( aURLPath.copy( aURLPath.indexOf( '/' ) + 1 ) ); 764 bDetected = true; 765 } 766 } 767 768 if (!bDetected) 769 { 770 // search a description by extension 771 bool bExt = !sExtension.isEmpty(); 772 if ( bExt ) 773 { 774 sExtension = sExtension.toAsciiLowerCase(); 775 pResId = GetDescriptionId_Impl( sExtension, bShowExt ); 776 } 777 if (!pResId) 778 { 779 pResId = STR_DESCRIPTION_FILE; 780 bOnlyFile = bExt; 781 } 782 } 783 } 784 else 785 pResId = GetFolderDescriptionId_Impl( sURL ); 786 787 if (pResId) 788 { 789 if ( bOnlyFile ) 790 { 791 bShowExt = false; 792 sExtension = sExtension.toAsciiUpperCase(); 793 sDescription = sExtension + "-"; 794 } 795 sDescription += SvtResId(pResId); 796 } 797 798 DBG_ASSERT( !sDescription.isEmpty(), "file without description" ); 799 800 if ( bShowExt ) 801 { 802 sDescription += " (" + sExtension + ")"; 803 } 804 805 return sDescription; 806 } 807 808 OUString SvFileInformationManager::GetImageId(const INetURLObject& rObject, bool bBig) 809 { 810 SvImageId nImage = GetImageId_Impl( 811 rObject, true, utl::UCBContentHelper::getDefaultCommandEnvironment() ); 812 DBG_ASSERT( nImage != SvImageId::NONE, "invalid ImageId" ); 813 return GetImageNameFromList_Impl(nImage, bBig ? vcl::ImageType::Size26 : vcl::ImageType::Size16); 814 } 815 816 Image SvFileInformationManager::GetImage( 817 const INetURLObject& rObject, bool bBig, 818 css::uno::Reference<css::ucb::XCommandEnvironment> const & env) 819 { 820 SvImageId nImage = GetImageId_Impl( rObject, true, env ); 821 DBG_ASSERT( nImage != SvImageId::NONE, "invalid ImageId" ); 822 return GetImageFromList_Impl(nImage, bBig ? vcl::ImageType::Size26 : vcl::ImageType::Size16); 823 } 824 825 OUString SvFileInformationManager::GetFileImageId(const INetURLObject& rObject) 826 { 827 SvImageId nImage = GetImageId_Impl( 828 rObject, false, utl::UCBContentHelper::getDefaultCommandEnvironment() ); 829 DBG_ASSERT( nImage != SvImageId::NONE, "invalid ImageId" ); 830 return GetImageNameFromList_Impl(nImage, vcl::ImageType::Size16); 831 } 832 833 Image SvFileInformationManager::GetImageNoDefault(const INetURLObject& rObject, vcl::ImageType eImageType) 834 { 835 SvImageId nImage = GetImageId_Impl( 836 rObject, true, utl::UCBContentHelper::getDefaultCommandEnvironment()); 837 DBG_ASSERT( nImage != SvImageId::NONE, "invalid ImageId" ); 838 839 if ( nImage == SvImageId::File ) 840 return Image(); 841 842 return GetImageFromList_Impl(nImage, eImageType); 843 } 844 845 OUString SvFileInformationManager::GetFolderImageId( const svtools::VolumeInfo& rInfo ) 846 { 847 SvImageId nImage = SvImageId::Folder; 848 DBG_ASSERT( nImage != SvImageId::NONE, "invalid ImageId" ); 849 850 if ( rInfo.m_bIsRemote ) 851 nImage = SvImageId::NetworkDevice; 852 else if ( rInfo.m_bIsCompactDisc ) 853 nImage = SvImageId::CDRomDevice; 854 else if ( rInfo.m_bIsRemoveable || rInfo.m_bIsFloppy ) 855 nImage = SvImageId::RemoveableDevice; 856 else if ( rInfo.m_bIsVolume ) 857 nImage = SvImageId::FixedDevice; 858 859 return GetImageNameFromList_Impl(nImage, vcl::ImageType::Size16); 860 } 861 862 OUString SvFileInformationManager::GetDescription( const INetURLObject& rObject ) 863 { 864 return SvFileInformationManager::GetDescription_Impl( rObject, true ); 865 } 866 867 OUString SvFileInformationManager::GetFileDescription( const INetURLObject& rObject ) 868 { 869 return SvFileInformationManager::GetDescription_Impl( rObject, false ); 870 } 871 872 OUString SvFileInformationManager::GetFolderDescription( const svtools::VolumeInfo& rInfo ) 873 { 874 TranslateId pResId = STR_DESCRIPTION_FOLDER; 875 if ( rInfo.m_bIsRemote ) 876 pResId = STR_DESCRIPTION_REMOTE_VOLUME; 877 else if ( rInfo.m_bIsFloppy ) 878 pResId = STR_DESCRIPTION_FLOPPY_VOLUME; 879 else if ( rInfo.m_bIsCompactDisc ) 880 pResId = STR_DESCRIPTION_CDROM_VOLUME; 881 else if ( rInfo.m_bIsRemoveable || rInfo.m_bIsVolume ) 882 pResId = STR_DESCRIPTION_LOCALE_VOLUME; 883 884 return SvtResId(pResId); 885 } 886 887 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ 888