svx/source/gallery2/galmisc.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/config.h>
  21
  22 #include <sot/storage.hxx>
  23 #include <unotools/streamwrap.hxx>
  24 #include <unotools/ucbstreamhelper.hxx>
  25 #include <comphelper/processfactory.hxx>
  26 #include <comphelper/string.hxx>
  27 #include <ucbhelper/content.hxx>
  28 #include <tools/resmgr.hxx>
  29 #include <tools/urlobj.hxx>
  30 #include <svl/solar.hrc>
  31 #include <svl/urihelper.hxx>
  32 #include <vcl/graphicfilter.hxx>
  33 #include <svl/itempool.hxx>
  34 #include <sfx2/docfile.hxx>
  35 #include <avmedia/mediawindow.hxx>
  36 #include <vcl/svapp.hxx>
  37 #include <vcl/settings.hxx>
  38 #include <svx/svdpage.hxx>
  39 #include <svx/svdograf.hxx>
  40 #include <svx/fmmodel.hxx>
  41 #include <svx/fmview.hxx>
  42 #include <svx/unomodel.hxx>
  43 #include "codec.hxx"
  44 #include "gallery.hrc"
  45 #include "svx/gallery1.hxx"
  46 #include "svx/galtheme.hxx"
  47 #include "svx/galmisc.hxx"
  48 #include <com/sun/star/sdbc/XResultSet.hpp>
  49 #include <com/sun/star/ucb/XContentAccess.hpp>
  50 #include <com/sun/star/ucb/TransferInfo.hpp>
  51 #include <com/sun/star/ucb/NameClash.hpp>
  52 #include <boost/scoped_ptr.hpp>
  53
  54 using namespace ::com::sun::star;
  55
  56 ResMgr* GetGalleryResMgr()
  57 {
  58     static ResMgr* pGalleryResMgr = NULL;
  59
  60     if( !pGalleryResMgr )
  61     {
  62         pGalleryResMgr = ResMgr::CreateResMgr(
  63             "gal", Application::GetSettings().GetUILanguageTag() );
  64     }
  65
  66     return pGalleryResMgr;
  67 }
  68
  69 BitmapEx GalleryResGetBitmapEx( sal_uInt32 nId )
  70 {
  71     BitmapEx aBmpEx( GAL_RES( nId ) );
  72
  73     if( !aBmpEx.IsTransparent() )
  74             aBmpEx = BitmapEx( aBmpEx.GetBitmap(), COL_LIGHTMAGENTA );
  75
  76     return aBmpEx;
  77 }
  78
  79 IMPL_STATIC_LINK(
  80     SgaUserDataFactory, MakeUserData, SdrObjFactory*, pObjFactory )
  81 {
  82     if ( pObjFactory->nInventor == IV_IMAPINFO && pObjFactory->nIdentifier == ID_IMAPINFO )
  83         pObjFactory->pNewData = new SgaIMapInfo;
  84
  85     return 0L;
  86 }
  87
  88 GalleryGraphicImportRet GalleryGraphicImport( const INetURLObject& rURL, Graphic& rGraphic,
  89                              OUString& rFilterName, bool bShowProgress )
  90 {
  91     GalleryGraphicImportRet  nRet = GalleryGraphicImportRet::IMPORT_NONE;
  92     SfxMedium   aMedium( rURL.GetMainURL( INetURLObject::NO_DECODE ), StreamMode::READ );
  93
  94     aMedium.Download();
  95
  96     SvStream* pIStm = aMedium.GetInStream();
  97
  98     if( pIStm )
  99     {
 100         GraphicFilter& rGraphicFilter = GraphicFilter::GetGraphicFilter();
 101         boost::scoped_ptr<GalleryProgress> pProgress(bShowProgress ? new GalleryProgress( &rGraphicFilter ) : NULL);
 102         sal_uInt16              nFormat;
 103
 104         if( !rGraphicFilter.ImportGraphic( rGraphic, rURL.GetMainURL( INetURLObject::NO_DECODE ), *pIStm, GRFILTER_FORMAT_DONTKNOW, &nFormat ) )
 105         {
 106             rFilterName = rGraphicFilter.GetImportFormatName( nFormat );
 107             nRet = GalleryGraphicImportRet::IMPORT_FILE;
 108         }
 109     }
 110
 111     return nRet;
 112 }
 113
 114 bool GallerySvDrawImport( SvStream& rIStm, SdrModel& rModel )
 115 {
 116     sal_uInt32  nVersion;
 117     bool        bRet = false;
 118
 119     if( GalleryCodec::IsCoded( rIStm, nVersion ) )
 120     {
 121         SvMemoryStream  aMemStm( 65535, 65535 );
 122         GalleryCodec    aCodec( rIStm );
 123
 124         aCodec.Read( aMemStm );
 125         aMemStm.Seek( 0UL );
 126
 127         if( 1 == nVersion )
 128         {
 129             OSL_FAIL( "staroffice binary file formats are no longer supported inside the gallery!" );
 130             bRet = false;
 131         }
 132         else if( 2 == nVersion )
 133         {
 134             // recall to read as XML
 135             bRet = GallerySvDrawImport( aMemStm, rModel );
 136         }
 137      }
 138     else
 139     {
 140         // read as XML
 141         uno::Reference< io::XInputStream > xInputStream( new utl::OInputStreamWrapper( rIStm ) );
 142
 143         rModel.GetItemPool().SetDefaultMetric( SFX_MAPUNIT_100TH_MM );
 144         uno::Reference< lang::XComponent > xComponent;
 145
 146         bRet = SvxDrawingLayerImport( &rModel, xInputStream, xComponent, "com.sun.star.comp.Draw.XMLOasisImporter" );
 147         if( !bRet || (rModel.GetPageCount() == 0) )
 148         {
 149             rIStm.Seek(0);
 150             bRet = SvxDrawingLayerImport( &rModel, xInputStream, xComponent, "com.sun.star.comp.Draw.XMLImporter" );
 151         }
 152
 153     }
 154
 155     return bRet;
 156 }
 157
 158 bool CreateIMapGraphic( const FmFormModel& rModel, Graphic& rGraphic, ImageMap& rImageMap )
 159 {
 160     bool bRet = false;
 161
 162     if ( rModel.GetPageCount() )
 163     {
 164         const SdrPage*      pPage = rModel.GetPage( 0 );
 165         const SdrObject*    pObj = pPage->GetObj( 0 );
 166
 167         if ( pPage->GetObjCount() == 1 && pObj->ISA( SdrGrafObj ) )
 168         {
 169             const sal_uInt16 nCount = pObj->GetUserDataCount();
 170
 171             // Exist in the user data an IMap information?
 172             for ( sal_uInt16 i = 0; i < nCount; i++ )
 173             {
 174                 const SdrObjUserData* pUserData = pObj->GetUserData( i );
 175
 176                 if ( ( pUserData->GetInventor() == IV_IMAPINFO ) && ( pUserData->GetId() == ID_IMAPINFO ) )
 177                 {
 178                     rGraphic = static_cast<const SdrGrafObj*>( pObj )->GetGraphic();
 179                     rImageMap = static_cast<const SgaIMapInfo*>( pUserData )->GetImageMap();
 180                     bRet = true;
 181                     break;
 182                 }
 183             }
 184         }
 185     }
 186
 187     return bRet;
 188 }
 189
 190 OUString GetReducedString( const INetURLObject& rURL, sal_Int32 nMaxLen )
 191 {
 192     OUString aReduced( rURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ) );
 193
 194     aReduced = aReduced.getToken( comphelper::string::getTokenCount(aReduced, '/') - 1, '/' );
 195
 196     if( INetProtocol::PrivSoffice != rURL.GetProtocol() )
 197     {
 198         sal_Unicode     aDelimiter;
 199         const OUString  aPath( rURL.getFSysPath( INetURLObject::FSYS_DETECT, &aDelimiter ) );
 200         const OUString  aName( aReduced );
 201
 202         if( aPath.getLength() > nMaxLen )
 203         {
 204             sal_Int32 nPathPrefixLen = nMaxLen - aName.getLength() - 4;
 205
 206             if (nPathPrefixLen >= 0)
 207             {
 208                 aReduced = aPath.copy(0, nPathPrefixLen);
 209                 aReduced += "...";
 210                 aReduced += OUString(aDelimiter);
 211                 aReduced += aName;
 212             }
 213             else
 214             {
 215                 aReduced += "...";
 216                 aReduced += OUString(aDelimiter);
 217                 aReduced += "...";
 218                 aReduced += aName.copy( aName.getLength() - (nMaxLen - 7) );
 219             }
 220         }
 221         else
 222             aReduced = aPath;
 223     }
 224
 225     return aReduced;
 226 }
 227
 228 OUString GetSvDrawStreamNameFromURL( const INetURLObject& rSvDrawObjURL )
 229 {
 230     OUString aRet;
 231
 232     if( rSvDrawObjURL.GetProtocol() == INetProtocol::PrivSoffice &&
 233         comphelper::string::getTokenCount(rSvDrawObjURL.GetMainURL( INetURLObject::NO_DECODE ), '/') == 3 )
 234     {
 235         aRet = rSvDrawObjURL.GetMainURL( INetURLObject::NO_DECODE ).getToken( 2, '/' );
 236     }
 237
 238     return aRet;
 239 }
 240
 241 bool FileExists( const INetURLObject& rURL )
 242 {
 243     bool bRet = false;
 244
 245     if( rURL.GetProtocol() != INetProtocol::NotValid )
 246     {
 247         try
 248         {
 249             ::ucbhelper::Content        aCnt( rURL.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
 250             OUString    aTitle;
 251
 252             aCnt.getPropertyValue("Title") >>= aTitle;
 253             bRet = ( !aTitle.isEmpty() );
 254         }
 255         catch( const ucb::ContentCreationException& )
 256         {
 257         }
 258         catch( const uno::RuntimeException& )
 259         {
 260         }
 261         catch( const uno::Exception& )
 262         {
 263         }
 264     }
 265
 266     return bRet;
 267 }
 268
 269 bool CreateDir( const INetURLObject& rURL )
 270 {
 271     bool bRet = FileExists( rURL );
 272
 273     if( !bRet )
 274     {
 275         try
 276         {
 277             uno::Reference< ucb::XCommandEnvironment >  aCmdEnv;
 278             INetURLObject                           aNewFolderURL( rURL );
 279             INetURLObject                           aParentURL( aNewFolderURL ); aParentURL.removeSegment();
 280             ::ucbhelper::Content                    aParent( aParentURL.GetMainURL( INetURLObject::NO_DECODE ), aCmdEnv, comphelper::getProcessComponentContext() );
 281             uno::Sequence< OUString >               aProps( 1 );
 282             uno::Sequence< uno::Any >               aValues( 1 );
 283
 284             aProps[0] = "Title";
 285             aValues[0] = uno::makeAny( OUString( aNewFolderURL.GetName() ) );
 286
 287         ::ucbhelper::Content aContent( aNewFolderURL.GetMainURL( INetURLObject::NO_DECODE ), aCmdEnv, comphelper::getProcessComponentContext() );
 288         bRet = aParent.insertNewContent( OUString("application/vnd.sun.staroffice.fsys-folder"), aProps, aValues, aContent );
 289         }
 290         catch( const ucb::ContentCreationException& )
 291         {
 292         }
 293         catch( const uno::RuntimeException& )
 294         {
 295         }
 296         catch( const uno::Exception& )
 297         {
 298         }
 299     }
 300
 301     return bRet;
 302 }
 303
 304 bool CopyFile(  const INetURLObject& rSrcURL, const INetURLObject& rDstURL )
 305 {
 306     bool bRet = false;
 307
 308     try
 309     {
 310         ::ucbhelper::Content aDestPath( rDstURL.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
 311
 312         aDestPath.executeCommand( OUString("transfer"),
 313                                   uno::makeAny( ucb::TransferInfo( sal_False, rSrcURL.GetMainURL( INetURLObject::NO_DECODE ),
 314                                                 rDstURL.GetName(), ucb::NameClash::OVERWRITE ) ) );
 315         bRet = true;
 316     }
 317     catch( const ucb::ContentCreationException& )
 318     {
 319     }
 320     catch( const uno::RuntimeException& )
 321     {
 322     }
 323     catch( const uno::Exception& )
 324     {
 325     }
 326
 327     return bRet;
 328 }
 329
 330 bool KillFile( const INetURLObject& rURL )
 331 {
 332     bool bRet = FileExists( rURL );
 333
 334     if( bRet )
 335     {
 336         try
 337         {
 338             ::ucbhelper::Content aCnt( rURL.GetMainURL( INetURLObject::NO_DECODE ), uno::Reference< ucb::XCommandEnvironment >(), comphelper::getProcessComponentContext() );
 339             aCnt.executeCommand( OUString("delete"), uno::makeAny( true ) );
 340         }
 341         catch( const ucb::ContentCreationException& )
 342         {
 343             bRet = false;
 344         }
 345         catch( const uno::RuntimeException& )
 346         {
 347             bRet = false;
 348         }
 349         catch( const uno::Exception& )
 350         {
 351             bRet = false;
 352         }
 353     }
 354
 355     return bRet;
 356 }
 357
 358
 359 GalleryProgress::GalleryProgress( GraphicFilter* pFilter ) :
 360     mpFilter( pFilter )
 361 {
 362
 363     uno::Reference< lang::XMultiServiceFactory > xMgr( ::comphelper::getProcessServiceFactory() );
 364
 365     uno::Reference< awt::XProgressMonitor > xMonitor( xMgr->createInstance(
 366                                                       OUString("com.sun.star.awt.XProgressMonitor") ),
 367                                                       uno::UNO_QUERY );
 368
 369     if ( xMonitor.is() )
 370     {
 371         mxProgressBar = uno::Reference< awt::XProgressBar >( xMonitor, uno::UNO_QUERY );
 372
 373         if( mxProgressBar.is() )
 374         {
 375             OUString aProgressText;
 376
 377             if( mpFilter )
 378             {
 379                 aProgressText = GAL_RESSTR(RID_SVXSTR_GALLERY_FILTER);
 380 //              mpFilter->SetUpdatePercentHdl( LINK( this, GalleryProgress, Update ) );     // sj: progress wasn't working up from SO7 at all
 381 //                                                                                          // so I am removing this. The gallery progress should
 382 //                                                                                          // be changed to use the XStatusIndicator instead of XProgressMonitor
 383             }
 384             else
 385                 aProgressText = "Gallery";
 386
 387             xMonitor->addText( "Gallery", aProgressText, sal_False ) ;
 388             mxProgressBar->setRange( 0, GALLERY_PROGRESS_RANGE );
 389         }
 390     }
 391 }
 392
 393 GalleryProgress::~GalleryProgress()
 394 {
 395 }
 396
 397 void GalleryProgress::Update( sal_uIntPtr nVal, sal_uIntPtr nMaxVal )
 398 {
 399     if( mxProgressBar.is() && nMaxVal )
 400         mxProgressBar->setValue( std::min( (sal_uIntPtr)( (double) nVal / nMaxVal * GALLERY_PROGRESS_RANGE ), (sal_uIntPtr) GALLERY_PROGRESS_RANGE ) );
 401 }
 402
 403
 404 GalleryTransferable::GalleryTransferable( GalleryTheme* pTheme, sal_uIntPtr nObjectPos, bool bLazy ) :
 405     mpTheme( pTheme ),
 406     meObjectKind( mpTheme->GetObjectKind( nObjectPos ) ),
 407     mnObjectPos( nObjectPos ),
 408     mpGraphicObject( NULL ),
 409     mpImageMap( NULL ),
 410     mpURL( NULL )
 411 {
 412
 413     InitData( bLazy );
 414 }
 415
 416 GalleryTransferable::~GalleryTransferable()
 417 {
 418 }
 419
 420 void GalleryTransferable::InitData( bool bLazy )
 421 {
 422     switch( meObjectKind )
 423     {
 424         case( SGA_OBJ_SVDRAW ):
 425         {
 426             if( !bLazy )
 427             {
 428                 if( !mpGraphicObject )
 429                 {
 430                     Graphic aGraphic;
 431
 432                     if( mpTheme->GetGraphic( mnObjectPos, aGraphic ) )
 433                         mpGraphicObject = new GraphicObject( aGraphic );
 434                 }
 435
 436                 if( !mxModelStream.Is() )
 437                 {
 438                     mxModelStream = new SotStorageStream( "" );
 439                     mxModelStream->SetBufferSize( 16348 );
 440
 441                     if( !mpTheme->GetModelStream( mnObjectPos, mxModelStream ) )
 442                         mxModelStream.Clear();
 443                     else
 444                         mxModelStream->Seek( 0 );
 445                 }
 446             }
 447         }
 448         break;
 449
 450         case( SGA_OBJ_ANIM ):
 451         case( SGA_OBJ_BMP ):
 452         case( SGA_OBJ_INET ):
 453         case( SGA_OBJ_SOUND ):
 454         {
 455             if( !mpURL )
 456             {
 457                 mpURL = new INetURLObject;
 458
 459                 if( !mpTheme->GetURL( mnObjectPos, *mpURL ) )
 460                     delete mpURL, mpURL = NULL;
 461             }
 462
 463             if( ( SGA_OBJ_SOUND != meObjectKind ) && !mpGraphicObject )
 464             {
 465                 Graphic aGraphic;
 466
 467                 if( mpTheme->GetGraphic( mnObjectPos, aGraphic ) )
 468                     mpGraphicObject = new GraphicObject( aGraphic );
 469             }
 470         }
 471         break;
 472
 473         default:
 474             OSL_FAIL( "GalleryTransferable::GalleryTransferable: invalid object type" );
 475         break;
 476     }
 477 }
 478
 479 void GalleryTransferable::AddSupportedFormats()
 480 {
 481     if( SGA_OBJ_SVDRAW == meObjectKind )
 482     {
 483         AddFormat( SotClipboardFormatId::DRAWING );
 484         AddFormat( SotClipboardFormatId::SVXB );
 485         AddFormat( SotClipboardFormatId::GDIMETAFILE );
 486         AddFormat( SotClipboardFormatId::BITMAP );
 487     }
 488     else
 489     {
 490         if( mpURL )
 491             AddFormat( SotClipboardFormatId::SIMPLE_FILE );
 492
 493         if( mpGraphicObject )
 494         {
 495             AddFormat( SotClipboardFormatId::SVXB );
 496
 497             if( mpGraphicObject->GetType() == GRAPHIC_GDIMETAFILE )
 498             {
 499                 AddFormat( SotClipboardFormatId::GDIMETAFILE );
 500                 AddFormat( SotClipboardFormatId::BITMAP );
 501             }
 502             else
 503             {
 504                 AddFormat( SotClipboardFormatId::BITMAP );
 505                 AddFormat( SotClipboardFormatId::GDIMETAFILE );
 506             }
 507         }
 508     }
 509 }
 510
 511 bool GalleryTransferable::GetData( const datatransfer::DataFlavor& rFlavor, const OUString& /*rDestDoc*/ )
 512 {
 513     SotClipboardFormatId nFormat = SotExchange::GetFormat( rFlavor );
 514     bool        bRet = false;
 515
 516     InitData( false );
 517
 518     if( ( SotClipboardFormatId::DRAWING == nFormat ) && ( SGA_OBJ_SVDRAW == meObjectKind ) )
 519     {
 520         bRet = ( mxModelStream.Is() && SetObject( &mxModelStream, SotClipboardFormatId::NONE, rFlavor ) );
 521     }
 522     else if( ( SotClipboardFormatId::SVIM == nFormat ) && mpImageMap )
 523     {
 524         // TODO/MBA: do we need a BaseURL here?!
 525         bRet = SetImageMap( *mpImageMap, rFlavor );
 526     }
 527     else if( ( SotClipboardFormatId::SIMPLE_FILE == nFormat ) && mpURL )
 528     {
 529         bRet = SetString( mpURL->GetMainURL( INetURLObject::NO_DECODE ), rFlavor );
 530     }
 531     else if( ( SotClipboardFormatId::SVXB == nFormat ) && mpGraphicObject )
 532     {
 533         bRet = SetGraphic( mpGraphicObject->GetGraphic(), rFlavor );
 534     }
 535     else if( ( SotClipboardFormatId::GDIMETAFILE == nFormat ) && mpGraphicObject )
 536     {
 537         bRet = SetGDIMetaFile( mpGraphicObject->GetGraphic().GetGDIMetaFile(), rFlavor );
 538     }
 539     else if( ( SotClipboardFormatId::BITMAP == nFormat ) && mpGraphicObject )
 540     {
 541         bRet = SetBitmapEx( mpGraphicObject->GetGraphic().GetBitmapEx(), rFlavor );
 542     }
 543
 544     return bRet;
 545 }
 546
 547 bool GalleryTransferable::WriteObject( tools::SvRef<SotStorageStream>& rxOStm, void* pUserObject,
 548                                            SotClipboardFormatId, const datatransfer::DataFlavor& )
 549 {
 550     bool bRet = false;
 551
 552     if( pUserObject )
 553     {
 554         rxOStm->WriteStream( *static_cast< SotStorageStream* >( pUserObject ) );
 555         bRet = ( rxOStm->GetError() == ERRCODE_NONE );
 556     }
 557
 558     return bRet;
 559 }
 560
 561 void GalleryTransferable::DragFinished( sal_Int8 nDropAction )
 562 {
 563     mpTheme->SetDragging( false );
 564     mpTheme->SetDragPos( 0 );
 565     if ( nDropAction )
 566     {
 567         vcl::Window *pFocusWindow = Application::GetFocusWindow();
 568         if ( pFocusWindow )
 569             pFocusWindow->GrabFocusToDocument();
 570     }
 571 }
 572
 573 void GalleryTransferable::ObjectReleased()
 574 {
 575     mxModelStream.Clear();
 576     delete mpGraphicObject, mpGraphicObject = NULL;
 577     delete mpImageMap, mpImageMap = NULL;
 578     delete mpURL, mpURL = NULL;
 579 }
 580
 581 void GalleryTransferable::CopyToClipboard( vcl::Window* pWindow )
 582 {
 583     TransferableHelper::CopyToClipboard( pWindow );
 584 }
 585
 586 void GalleryTransferable::StartDrag( vcl::Window* pWindow, sal_Int8 nDragSourceActions,
 587                                      sal_Int32 nDragPointer, sal_Int32 nDragImage )
 588 {
 589     INetURLObject aURL;
 590
 591     if( mpTheme->GetURL( mnObjectPos, aURL ) && ( aURL.GetProtocol() != INetProtocol::NotValid ) )
 592     {
 593         mpTheme->SetDragging( true );
 594         mpTheme->SetDragPos( mnObjectPos );
 595         TransferableHelper::StartDrag( pWindow, nDragSourceActions, nDragPointer, nDragImage );
 596     }
 597 }
 598
 599 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */