| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| |
| |
| #include <sot/formats.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svtools/valueset.hxx> |
| #include <svl/urlbmk.hxx> |
| #include <svl/stritem.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/eitem.hxx> |
| #include <svtools/transfer.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <sfx2/sfxsids.hrc> |
| #include "svtools/filter.hxx" |
| #include <editeng/brshitem.hxx> |
| #include "helpid.hrc" |
| #include "svx/gallery.hxx" |
| #include "galobj.hxx" |
| #include "svx/gallery1.hxx" |
| #include "svx/galtheme.hxx" |
| #include "svx/galctrl.hxx" |
| #include "svx/galmisc.hxx" |
| #include "galbrws2.hxx" |
| #include "gallery.hrc" |
| #include <vcl/svapp.hxx> |
| #include <svx/fmmodel.hxx> |
| #include <svx/dialmgr.hxx> |
| #include <svx/svxdlg.hxx> |
| #include <svx/dialogs.hrc> |
| #include "GalleryControl.hxx" |
| |
| #include <svx/svxcommands.h> |
| #include <svx/galleryitem.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include <com/sun/star/frame/FrameSearchFlag.hpp> |
| #include <com/sun/star/gallery/GalleryItemType.hpp> |
| #include <com/sun/star/graphic/XGraphic.hpp> |
| #include <com/sun/star/style/GraphicLocation.hpp> |
| #include <map> |
| |
| // ----------- |
| // - Defines - |
| // ----------- |
| |
| #undef GALLERY_USE_CLIPBOARD |
| |
| #define TBX_ID_ICON 1 |
| #define TBX_ID_LIST 2 |
| |
| #define C2U( cstr ) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(cstr))) |
| |
| namespace css = ::com::sun::star; |
| using rtl::OUString; |
| |
| // ----------- |
| // - statics - |
| // ----------- |
| |
| GalleryBrowserMode GalleryBrowser2::meInitMode = GALLERYBROWSERMODE_ICON; |
| |
| struct DispatchInfo |
| { |
| css::util::URL TargetURL; |
| css::uno::Sequence< css::beans::PropertyValue > Arguments; |
| css::uno::Reference< css::frame::XDispatch > Dispatch; |
| }; |
| |
| IMPL_STATIC_LINK_NOINSTANCE( GalleryBrowser2, AsyncDispatch_Impl, DispatchInfo*, pDispatchInfo ) |
| { |
| if ( pDispatchInfo && pDispatchInfo->Dispatch.is() ) |
| { |
| try |
| { |
| pDispatchInfo->Dispatch->dispatch( pDispatchInfo->TargetURL, |
| pDispatchInfo->Arguments ); |
| } |
| catch ( const css::uno::Exception& ) |
| { |
| } |
| } |
| |
| delete pDispatchInfo; |
| return 0; |
| } |
| |
| namespace |
| { |
| |
| struct CommandInfo |
| { |
| css::util::URL URL; |
| css::uno::Reference< css::frame::XDispatch > Dispatch; |
| |
| CommandInfo( const OUString &rURL ) |
| { |
| URL.Complete = rURL; |
| } |
| }; |
| |
| class GalleryThemePopup : public ::cppu::WeakImplHelper1< css::frame::XStatusListener > |
| { |
| private: |
| const GalleryTheme* mpTheme; |
| sal_uIntPtr mnObjectPos; |
| sal_Bool mbPreview; |
| PopupMenu maPopupMenu; |
| PopupMenu maBackgroundPopup; |
| GalleryBrowser2* mpBrowser; |
| |
| typedef std::map< int, CommandInfo > CommandInfoMap; |
| CommandInfoMap m_aCommandInfo; |
| |
| void Execute( const CommandInfo &rCmdInfo, |
| const css::uno::Sequence< css::beans::PropertyValue > &rArguments ); |
| |
| DECL_LINK( MenuSelectHdl, Menu* pMenu ); |
| DECL_LINK( BackgroundMenuSelectHdl, Menu* pMenu ); |
| public: |
| GalleryThemePopup( const GalleryTheme* pTheme, |
| sal_uIntPtr nObjectPos, |
| sal_Bool bPreview, |
| GalleryBrowser2* pBrowser ); |
| ~GalleryThemePopup(); |
| |
| void ExecutePopup( Window *pParent, const ::Point &aPos ); |
| |
| virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent &rEvent) throw ( css::uno::RuntimeException ); |
| virtual void SAL_CALL disposing( const css::lang::EventObject &rSource) throw ( css::uno::RuntimeException ); |
| }; |
| |
| DBG_NAME(GalleryThemePopup) |
| |
| GalleryThemePopup::GalleryThemePopup( |
| const GalleryTheme* pTheme, |
| sal_uIntPtr nObjectPos, |
| sal_Bool bPreview, |
| GalleryBrowser2* pBrowser ) |
| : mpTheme( pTheme ) |
| , mnObjectPos( nObjectPos ) |
| , mbPreview( bPreview ) |
| , maPopupMenu( GAL_RESID( RID_SVXMN_GALLERY2 ) ) |
| , maBackgroundPopup() |
| , mpBrowser( pBrowser ) |
| { |
| DBG_CTOR(GalleryThemePopup,NULL); |
| |
| // SID_GALLERY_ENABLE_ADDCOPY |
| m_aCommandInfo.insert( |
| CommandInfoMap::value_type( |
| SID_GALLERY_ENABLE_ADDCOPY, |
| CommandInfo( C2U(CMD_SID_GALLERY_ENABLE_ADDCOPY )))); |
| // SID_GALLERY_BG_BRUSH |
| m_aCommandInfo.insert( |
| CommandInfoMap::value_type( |
| SID_GALLERY_BG_BRUSH, |
| CommandInfo(C2U(CMD_SID_GALLERY_BG_BRUSH )))); |
| // SID_GALLERY_FORMATS |
| m_aCommandInfo.insert( |
| CommandInfoMap::value_type( |
| SID_GALLERY_FORMATS, |
| CommandInfo(C2U(CMD_SID_GALLERY_FORMATS )))); |
| |
| } |
| |
| GalleryThemePopup::~GalleryThemePopup() |
| { |
| DBG_DTOR(GalleryThemePopup,NULL); |
| } |
| |
| void SAL_CALL GalleryThemePopup::statusChanged( |
| const css::frame::FeatureStateEvent &rEvent ) |
| throw ( css::uno::RuntimeException ) |
| { |
| const OUString &rURL = rEvent.FeatureURL.Complete; |
| if ( rURL.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( CMD_SID_GALLERY_ENABLE_ADDCOPY ) ) ) |
| { |
| if ( !rEvent.IsEnabled ) |
| { |
| PopupMenu *pAddMenu = maPopupMenu.GetPopupMenu( MN_ADDMENU ); |
| pAddMenu->EnableItem( MN_ADD, sal_False ); |
| pAddMenu->EnableItem( MN_ADD_LINK, sal_False ); |
| } |
| } |
| else if ( rURL.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( CMD_SID_GALLERY_BG_BRUSH ) ) ) |
| { |
| maBackgroundPopup.Clear(); |
| if ( rEvent.IsEnabled ) |
| { |
| OUString sItem; |
| css::uno::Sequence< OUString > sItems; |
| if ( ( rEvent.State >>= sItem ) && sItem.getLength() ) |
| { |
| maBackgroundPopup.InsertItem( 1, sItem ); |
| } |
| else if ( ( rEvent.State >>= sItems ) && sItems.getLength() ) |
| { |
| const OUString *pStr = sItems.getConstArray(); |
| const OUString *pEnd = pStr + sItems.getLength(); |
| for ( sal_uInt16 nId = 1; pStr != pEnd; pStr++, nId++ ) |
| { |
| maBackgroundPopup.InsertItem( nId, *pStr ); |
| } |
| } |
| } |
| } |
| } |
| |
| void SAL_CALL GalleryThemePopup::disposing( |
| const css::lang::EventObject &/*rSource*/) |
| throw ( css::uno::RuntimeException ) |
| { |
| } |
| |
| void GalleryThemePopup::Execute( |
| const CommandInfo &rCmdInfo, |
| const css::uno::Sequence< css::beans::PropertyValue > &rArguments ) |
| { |
| if ( rCmdInfo.Dispatch.is() ) |
| { |
| DispatchInfo *pInfo = new DispatchInfo; |
| pInfo->TargetURL = rCmdInfo.URL; |
| pInfo->Arguments = rArguments; |
| pInfo->Dispatch = rCmdInfo.Dispatch; |
| |
| if ( !Application::PostUserEvent( |
| STATIC_LINK( 0, GalleryBrowser2, AsyncDispatch_Impl), pInfo ) ) |
| delete pInfo; |
| } |
| } |
| |
| void GalleryThemePopup::ExecutePopup( Window *pWindow, const ::Point &aPos ) |
| { |
| css::uno::Reference< css::frame::XStatusListener > xThis( this ); |
| |
| const SgaObjKind eObjKind = mpTheme->GetObjectKind( mnObjectPos ); |
| PopupMenu* pAddMenu = maPopupMenu.GetPopupMenu( MN_ADDMENU ); |
| INetURLObject aURL; |
| |
| const_cast< GalleryTheme* >( mpTheme )->GetURL( mnObjectPos, aURL ); |
| const sal_Bool bValidURL = ( aURL.GetProtocol() != INET_PROT_NOT_VALID ); |
| |
| pAddMenu->EnableItem( MN_ADD, bValidURL && SGA_OBJ_SOUND != eObjKind ); |
| pAddMenu->EnableItem( MN_ADD_LINK, bValidURL && SGA_OBJ_SVDRAW != eObjKind ); |
| |
| maPopupMenu.EnableItem( MN_ADDMENU, pAddMenu->IsItemEnabled( MN_ADD ) || pAddMenu->IsItemEnabled( MN_ADD_LINK ) ); |
| maPopupMenu.EnableItem( MN_PREVIEW, bValidURL ); |
| |
| maPopupMenu.CheckItem( MN_PREVIEW, mbPreview ); |
| |
| if( mpTheme->IsReadOnly() || !mpTheme->GetObjectCount() ) |
| { |
| maPopupMenu.EnableItem( MN_DELETE, sal_False ); |
| maPopupMenu.EnableItem( MN_TITLE, sal_False ); |
| |
| if( mpTheme->IsReadOnly() ) |
| maPopupMenu.EnableItem( MN_PASTECLIPBOARD, sal_False ); |
| |
| if( !mpTheme->GetObjectCount() ) |
| maPopupMenu.EnableItem( MN_COPYCLIPBOARD, sal_False ); |
| } |
| else |
| { |
| maPopupMenu.EnableItem( MN_DELETE, !mbPreview ); |
| maPopupMenu.EnableItem( MN_TITLE, sal_True ); |
| maPopupMenu.EnableItem( MN_COPYCLIPBOARD, sal_True ); |
| maPopupMenu.EnableItem( MN_PASTECLIPBOARD, sal_True ); |
| } |
| |
| #ifdef GALLERY_USE_CLIPBOARD |
| if( maPopupMenu.IsItemEnabled( MN_PASTECLIPBOARD ) ) |
| { |
| TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( this ) ); |
| sal_Bool bEnable = sal_False; |
| |
| if( aDataHelper.GetFormatCount() ) |
| { |
| if( aDataHelper.HasFormat( SOT_FORMATSTR_ID_DRAWING ) || |
| aDataHelper.HasFormat( SOT_FORMAT_FILE_LIST ) || |
| aDataHelper.HasFormat( FORMAT_FILE ) || |
| aDataHelper.HasFormat( SOT_FORMATSTR_ID_SVXB ) || |
| aDataHelper.HasFormat( FORMAT_GDIMETAFILE ) || |
| aDataHelper.HasFormat( FORMAT_BITMAP ) ) |
| { |
| bEnable = sal_True; |
| } |
| } |
| |
| if( !bEnable ) |
| maPopupMenu.EnableItem( MN_PASTECLIPBOARD, sal_False ); |
| } |
| #else |
| maPopupMenu.EnableItem( MN_COPYCLIPBOARD, sal_False ); |
| maPopupMenu.EnableItem( MN_PASTECLIPBOARD, sal_False ); |
| #endif |
| |
| // update status |
| css::uno::Reference< css::frame::XDispatchProvider> xDispatchProvider( |
| mpBrowser->GetFrame(), css::uno::UNO_QUERY ); |
| css::uno::Reference< css::util::XURLTransformer > xTransformer( |
| mpBrowser->GetURLTransformer() ); |
| for ( CommandInfoMap::iterator it = m_aCommandInfo.begin(); |
| it != m_aCommandInfo.end(); it++ ) |
| { |
| try |
| { |
| CommandInfo &rCmdInfo = it->second; |
| if ( xTransformer.is() ) |
| xTransformer->parseStrict( rCmdInfo.URL ); |
| |
| if ( xDispatchProvider.is() ) |
| { |
| rCmdInfo.Dispatch = xDispatchProvider->queryDispatch( |
| rCmdInfo.URL, |
| C2U( "_self" ), |
| css::frame::FrameSearchFlag::SELF ); |
| } |
| |
| if ( rCmdInfo.Dispatch.is() ) |
| { |
| rCmdInfo.Dispatch->addStatusListener( this, rCmdInfo.URL ); |
| rCmdInfo.Dispatch->removeStatusListener( this, rCmdInfo.URL ); |
| } |
| } |
| catch ( ... ) |
| {} |
| } |
| |
| if( !maBackgroundPopup.GetItemCount() || ( eObjKind == SGA_OBJ_SVDRAW ) || ( eObjKind == SGA_OBJ_SOUND ) ) |
| pAddMenu->EnableItem( MN_BACKGROUND, sal_False ); |
| else |
| { |
| pAddMenu->EnableItem( MN_BACKGROUND, sal_True ); |
| pAddMenu->SetPopupMenu( MN_BACKGROUND, &maBackgroundPopup ); |
| maBackgroundPopup.SetSelectHdl( LINK( this, GalleryThemePopup, BackgroundMenuSelectHdl ) ); |
| } |
| |
| pAddMenu->RemoveDisabledEntries(); |
| if ( !pAddMenu->GetItemCount() ) |
| maPopupMenu.EnableItem( MN_ADDMENU, sal_False ); |
| maPopupMenu.RemoveDisabledEntries(); |
| |
| maPopupMenu.SetSelectHdl( LINK( this, GalleryThemePopup, MenuSelectHdl ) ); |
| maPopupMenu.Execute( pWindow, aPos ); |
| } |
| |
| IMPL_LINK( GalleryThemePopup, MenuSelectHdl, Menu*, pMenu ) |
| { |
| if( !pMenu ) |
| return 0; |
| |
| sal_uInt16 nId( pMenu->GetCurItemId() ); |
| switch ( nId ) |
| { |
| case( MN_ADD ): |
| case( MN_ADD_LINK ): |
| { |
| const CommandInfoMap::const_iterator it = m_aCommandInfo.find( SID_GALLERY_FORMATS ); |
| if ( it != m_aCommandInfo.end() ) |
| mpBrowser->Dispatch( nId, |
| it->second.Dispatch, |
| it->second.URL ); |
| } |
| break; |
| |
| default: |
| mpBrowser->Execute( nId ); |
| } |
| |
| return 0; |
| } |
| |
| IMPL_LINK( GalleryThemePopup, BackgroundMenuSelectHdl, Menu*, pMenu ) |
| { |
| if( !pMenu ) |
| return 0; |
| |
| sal_uInt16 nPos( pMenu->GetCurItemId() - 1 ); |
| OUString aURL( mpBrowser->GetURL().GetMainURL( INetURLObject::NO_DECODE ) ); |
| OUString aFilterName( mpBrowser->GetFilterName() ); |
| |
| css::uno::Sequence< css::beans::PropertyValue > aArgs( 6 ); |
| aArgs[0].Name = C2U( "Background.Transparent" ); |
| aArgs[0].Value <<= sal_Int32( 0 ); // 0 - 100 |
| aArgs[1].Name = C2U( "Background.BackColor" ); |
| aArgs[1].Value <<= sal_Int32( - 1 ); |
| aArgs[2].Name = C2U( "Background.URL" ); |
| aArgs[2].Value <<= aURL; |
| aArgs[3].Name = C2U( "Background.Filtername" ); // FIXME should be FilterName |
| aArgs[3].Value <<= aFilterName; |
| aArgs[4].Name = C2U( "Background.Position" ); |
| aArgs[4].Value <<= css::style::GraphicLocation_TILED; |
| aArgs[5].Name = C2U( "Position" ); |
| aArgs[5].Value <<= nPos; |
| |
| const CommandInfoMap::const_iterator it = m_aCommandInfo.find( SID_GALLERY_BG_BRUSH ); |
| if ( it != m_aCommandInfo.end() ) |
| Execute( it->second, aArgs ); |
| |
| return 0; |
| } |
| |
| } // end anonymous namespace |
| |
| // ------------------ |
| // - GalleryToolBox - |
| // ------------------ |
| DBG_NAME(GalleryToolBox) |
| |
| GalleryToolBox::GalleryToolBox( GalleryBrowser2* pParent ) : |
| ToolBox( pParent, WB_TABSTOP ) |
| { |
| DBG_CTOR(GalleryToolBox,NULL); |
| |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| GalleryToolBox::~GalleryToolBox() |
| { |
| |
| DBG_DTOR(GalleryToolBox,NULL); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void GalleryToolBox::KeyInput( const KeyEvent& rKEvt ) |
| { |
| if( !static_cast< GalleryBrowser2* >( GetParent() )->KeyInput( rKEvt, this ) ) |
| ToolBox::KeyInput( rKEvt ); |
| } |
| |
| // ------------------- |
| // - GalleryBrowser2 - |
| // ------------------- |
| DBG_NAME(GalleryBrowser2) |
| |
| GalleryBrowser2::GalleryBrowser2( Window* pParent, const ResId& rResId, Gallery* pGallery ) : |
| Control ( pParent, rResId ), |
| mpGallery ( pGallery ), |
| mpCurTheme ( NULL ), |
| mpIconView ( new GalleryIconView( this, NULL ) ), |
| mpListView ( new GalleryListView( this, NULL ) ), |
| mpPreview ( new GalleryPreview( this, NULL ) ), |
| maViewBox ( this ), |
| maSeparator ( this, WB_VERT ), |
| maInfoBar ( this, WB_LEFT | WB_VCENTER ), |
| mnCurActionPos ( 0xffffffff ), |
| meMode ( GALLERYBROWSERMODE_NONE ), |
| meLastMode ( GALLERYBROWSERMODE_NONE ) |
| { |
| DBG_CTOR(GalleryBrowser2,NULL); |
| |
| m_xContext.set( ::comphelper::getProcessComponentContext() ); |
| |
| m_xTransformer.set( |
| m_xContext->getServiceManager()->createInstanceWithContext( |
| C2U( "com.sun.star.util.URLTransformer" ), m_xContext ), |
| css::uno::UNO_QUERY ); |
| |
| Image aDummyImage; |
| const Link aSelectHdl( LINK( this, GalleryBrowser2, SelectObjectHdl ) ); |
| Font aInfoFont( maInfoBar.GetControlFont() ); |
| |
| maMiscOptions.AddListenerLink( LINK( this, GalleryBrowser2, MiscHdl ) ); |
| |
| maViewBox.InsertItem( TBX_ID_ICON, aDummyImage ); |
| maViewBox.SetItemBits( TBX_ID_ICON, TIB_RADIOCHECK | TIB_AUTOCHECK ); |
| maViewBox.SetHelpId( TBX_ID_ICON, HID_GALLERY_ICONVIEW ); |
| maViewBox.SetQuickHelpText( TBX_ID_ICON, String( GAL_RESID( RID_SVXSTR_GALLERY_ICONVIEW ) ) ); |
| |
| maViewBox.InsertItem( TBX_ID_LIST, aDummyImage ); |
| maViewBox.SetItemBits( TBX_ID_LIST, TIB_RADIOCHECK | TIB_AUTOCHECK ); |
| maViewBox.SetHelpId( TBX_ID_LIST, HID_GALLERY_LISTVIEW ); |
| maViewBox.SetQuickHelpText( TBX_ID_LIST, String( GAL_RESID( RID_SVXSTR_GALLERY_LISTVIEW ) ) ); |
| |
| maViewBox.SetBorder( 0, 1 ); |
| MiscHdl( NULL ); |
| maViewBox.SetSelectHdl( LINK( this, GalleryBrowser2, SelectTbxHdl ) ); |
| maViewBox.Show(); |
| |
| mpIconView->SetAccessibleName(String( SVX_RES( RID_SVXSTR_GALLERY_THEMEITEMS ) )); |
| mpListView->SetAccessibleName(String( SVX_RES( RID_SVXSTR_GALLERY_THEMEITEMS ) )); |
| |
| maInfoBar.Show(); |
| maSeparator.Show(); |
| |
| mpIconView->SetSelectHdl( aSelectHdl ); |
| mpListView->SetSelectHdl( aSelectHdl ); |
| |
| InitSettings(); |
| |
| SetMode( ( GALLERYBROWSERMODE_PREVIEW != GalleryBrowser2::meInitMode ) ? GalleryBrowser2::meInitMode : GALLERYBROWSERMODE_ICON ); |
| |
| if(maInfoBar.GetText().Len() == 0) |
| mpIconView->SetAccessibleRelationLabeledBy(mpIconView); |
| else |
| mpIconView->SetAccessibleRelationLabeledBy(&maInfoBar); |
| mpIconView->SetAccessibleRelationMemberOf(mpIconView); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| GalleryBrowser2::~GalleryBrowser2() |
| { |
| maMiscOptions.RemoveListenerLink( LINK( this, GalleryBrowser2, MiscHdl ) ); |
| |
| delete mpPreview; |
| delete mpListView; |
| delete mpIconView; |
| |
| if( mpCurTheme ) |
| mpGallery->ReleaseTheme( mpCurTheme, *this ); |
| |
| DBG_DTOR(GalleryBrowser2,NULL); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::InitSettings() |
| { |
| Font aInfoFont( maInfoBar.GetControlFont() ); |
| |
| aInfoFont.SetWeight( WEIGHT_BOLD ); |
| aInfoFont.SetColor( GALLERY_FG_COLOR ); |
| maInfoBar.SetControlFont( aInfoFont ); |
| |
| maInfoBar.SetBackground( Wallpaper( GALLERY_DLG_COLOR ) ); |
| maInfoBar.SetControlBackground( GALLERY_DLG_COLOR ); |
| |
| maSeparator.SetBackground( Wallpaper( GALLERY_BG_COLOR ) ); |
| maSeparator.SetControlBackground( GALLERY_BG_COLOR ); |
| maSeparator.SetControlForeground( GALLERY_FG_COLOR ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| if ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) ) |
| InitSettings(); |
| else |
| Control::DataChanged( rDCEvt ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::Resize() |
| { |
| Control::Resize(); |
| |
| mpIconView->Hide(); |
| mpListView->Hide(); |
| mpPreview->Hide(); |
| |
| const Size aOutSize( GetOutputSizePixel() ); |
| const Size aBoxSize( maViewBox.GetOutputSizePixel() ); |
| const long nOffset = 2, nSepWidth = 2; |
| const long nInfoBarX = aBoxSize.Width() + ( nOffset * 3 ) + nSepWidth; |
| const Point aPt( 0, aBoxSize.Height() + 3 ); |
| const Size aSz( aOutSize.Width(), aOutSize.Height() - aPt.Y() ); |
| |
| maSeparator.SetPosSizePixel( Point( aBoxSize.Width() + nOffset, 0 ), Size( nSepWidth, aBoxSize.Height() ) ); |
| maInfoBar.SetPosSizePixel( Point( nInfoBarX, 0 ), Size( aOutSize.Width() - nInfoBarX, aBoxSize.Height() ) ); |
| |
| mpIconView->SetPosSizePixel( aPt, aSz ); |
| mpListView->SetPosSizePixel( aPt, aSz ); |
| mpPreview->SetPosSizePixel( aPt, aSz ); |
| |
| switch( GetMode() ) |
| { |
| case( GALLERYBROWSERMODE_ICON ): mpIconView->Show(); break; |
| case( GALLERYBROWSERMODE_LIST ): mpListView->Show(); break; |
| case( GALLERYBROWSERMODE_PREVIEW ): mpPreview->Show(); break; |
| |
| default: |
| break; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| const GalleryHint& rGalleryHint = (const GalleryHint&) rHint; |
| |
| switch( rGalleryHint.GetType() ) |
| { |
| case( GALLERY_HINT_THEME_UPDATEVIEW ): |
| { |
| if( GALLERYBROWSERMODE_PREVIEW == GetMode() ) |
| SetMode( meLastMode ); |
| |
| ImplUpdateViews( (sal_uInt16) rGalleryHint.GetData1() + 1 ); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int8 GalleryBrowser2::AcceptDrop( DropTargetHelper& rTarget, const AcceptDropEvent& ) |
| { |
| sal_Int8 nRet = DND_ACTION_NONE; |
| |
| if( mpCurTheme && !mpCurTheme->IsReadOnly() && !mpCurTheme ->IsImported() ) |
| { |
| if( !mpCurTheme->IsDragging() ) |
| { |
| if( rTarget.IsDropFormatSupported( SOT_FORMATSTR_ID_DRAWING ) || |
| rTarget.IsDropFormatSupported( SOT_FORMAT_FILE_LIST ) || |
| rTarget.IsDropFormatSupported( FORMAT_FILE ) || |
| rTarget.IsDropFormatSupported( SOT_FORMATSTR_ID_SVXB ) || |
| rTarget.IsDropFormatSupported( FORMAT_GDIMETAFILE ) || |
| rTarget.IsDropFormatSupported( FORMAT_BITMAP ) ) |
| { |
| nRet = DND_ACTION_COPY; |
| } |
| } |
| else |
| nRet = DND_ACTION_COPY; |
| } |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Int8 GalleryBrowser2::ExecuteDrop( DropTargetHelper&, const ExecuteDropEvent& rEvt ) |
| { |
| sal_Int8 nRet = DND_ACTION_NONE; |
| |
| if( mpCurTheme ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( &rEvt.maPosPixel, aSelPos ); |
| const sal_uIntPtr nInsertPos = ( nItemId ? ( nItemId - 1 ) : LIST_APPEND ); |
| |
| if( mpCurTheme->IsDragging() ) |
| mpCurTheme->ChangeObjectPos( mpCurTheme->GetDragPos(), nInsertPos ); |
| else |
| nRet = mpCurTheme->InsertTransferable( rEvt.maDropEvent.Transferable, nInsertPos ); |
| } |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::StartDrag( Window*, const Point* pDragPoint ) |
| { |
| if( mpCurTheme ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( pDragPoint, aSelPos ); |
| |
| if( nItemId ) |
| mpCurTheme->StartDrag( this, nItemId - 1 ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::TogglePreview( Window*, const Point* ) |
| { |
| SetMode( ( GALLERYBROWSERMODE_PREVIEW != GetMode() ) ? GALLERYBROWSERMODE_PREVIEW : meLastMode ); |
| GetViewWindow()->GrabFocus(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::ShowContextMenu( Window*, const Point* pContextPoint ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( pContextPoint, aSelPos ); |
| |
| if( mpCurTheme && nItemId && ( nItemId <= mpCurTheme->GetObjectCount() ) ) |
| { |
| ImplSelectItemId( nItemId ); |
| |
| css::uno::Reference< css::frame::XFrame > xFrame( GetFrame() ); |
| if ( xFrame.is() ) |
| { |
| mnCurActionPos = nItemId - 1; |
| rtl::Reference< GalleryThemePopup > rPopup( |
| new GalleryThemePopup( |
| mpCurTheme, |
| mnCurActionPos, |
| GALLERYBROWSERMODE_PREVIEW == GetMode(), |
| this ) ); |
| rPopup->ExecutePopup( this, aSelPos ); |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool GalleryBrowser2::KeyInput( const KeyEvent& rKEvt, Window* pWindow ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( NULL, aSelPos ); |
| GalleryBrowser* pParentBrowser = dynamic_cast<GalleryBrowser*>(GetParent()); |
| sal_Bool bRet = sal_False; |
| if (pParentBrowser != NULL) |
| bRet = pParentBrowser->KeyInput( rKEvt, pWindow ); |
| else |
| { |
| svx::sidebar::GalleryControl* pParentControl = dynamic_cast<svx::sidebar::GalleryControl*>(GetParent()); |
| if (pParentControl != NULL) |
| bRet = pParentControl->KeyInput(rKEvt, pWindow); |
| } |
| |
| if( !bRet && !maViewBox.HasFocus() && nItemId && mpCurTheme ) |
| { |
| sal_uInt16 nExecuteId = 0; |
| const SgaObjKind eObjKind = mpCurTheme->GetObjectKind( nItemId - 1 ); |
| INetURLObject aURL; |
| |
| const_cast< GalleryTheme* >( mpCurTheme )->GetURL( nItemId - 1, aURL ); |
| |
| const sal_Bool bValidURL = ( aURL.GetProtocol() != INET_PROT_NOT_VALID ); |
| sal_Bool bPreview = bValidURL; |
| sal_Bool bAdd = bValidURL; |
| sal_Bool bAddLink = ( bValidURL && SGA_OBJ_SVDRAW != eObjKind ); |
| sal_Bool bDelete = sal_False; |
| sal_Bool bTitle = sal_False; |
| |
| if( !mpCurTheme->IsReadOnly() && mpCurTheme->GetObjectCount() ) |
| { |
| bDelete = ( GALLERYBROWSERMODE_PREVIEW != GetMode() ); |
| bTitle = sal_True; |
| } |
| |
| switch( rKEvt.GetKeyCode().GetCode() ) |
| { |
| case( KEY_SPACE ): |
| case( KEY_RETURN ): |
| case( KEY_P ): |
| { |
| if( bPreview ) |
| { |
| TogglePreview( pWindow ); |
| bRet = sal_True; |
| } |
| } |
| break; |
| |
| case( KEY_INSERT ): |
| case( KEY_I ): |
| { |
| // Inserting a gallery item in the document must be dispatched |
| if( bAddLink && rKEvt.GetKeyCode().IsShift() && rKEvt.GetKeyCode().IsMod1() ) |
| nExecuteId = MN_ADD_LINK; |
| else if( bAdd ) |
| nExecuteId = MN_ADD; |
| if( nExecuteId ) |
| { |
| Dispatch( nExecuteId ); |
| return sal_True; |
| } |
| } |
| break; |
| |
| case( KEY_DELETE ): |
| case( KEY_D ): |
| { |
| if( bDelete ) |
| nExecuteId = MN_DELETE; |
| } |
| break; |
| |
| case( KEY_T ): |
| { |
| if( bTitle ) |
| nExecuteId = MN_TITLE; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| if( nExecuteId ) |
| { |
| Execute( nExecuteId ); |
| bRet = sal_True; |
| } |
| } |
| |
| return bRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::SelectTheme( const String& rThemeName ) |
| { |
| delete mpIconView, mpIconView = NULL; |
| delete mpListView, mpListView = NULL; |
| delete mpPreview, mpPreview = NULL; |
| |
| if( mpCurTheme ) |
| mpGallery->ReleaseTheme( mpCurTheme, *this ); |
| |
| mpCurTheme = mpGallery->AcquireTheme( rThemeName, *this ); |
| |
| mpIconView = new GalleryIconView( this, mpCurTheme ); |
| mpListView = new GalleryListView( this, mpCurTheme ); |
| mpPreview = new GalleryPreview( this, mpCurTheme ); |
| |
| mpIconView->SetAccessibleName(String( SVX_RES( RID_SVXSTR_GALLERY_THEMEITEMS ) )); |
| mpListView->SetAccessibleName(String( SVX_RES( RID_SVXSTR_GALLERY_THEMEITEMS ) )); |
| mpPreview->SetAccessibleName(String( SVX_RES( RID_SVXSTR_GALLERY_PREVIEW ) )); |
| |
| const Link aSelectHdl( LINK( this, GalleryBrowser2, SelectObjectHdl ) ); |
| |
| mpIconView->SetSelectHdl( aSelectHdl ); |
| mpListView->SetSelectHdl( aSelectHdl ); |
| |
| if( GALLERYBROWSERMODE_PREVIEW == GetMode() ) |
| meMode = meLastMode; |
| |
| Resize(); |
| ImplUpdateViews( 1 ); |
| |
| maViewBox.EnableItem( TBX_ID_ICON, sal_True ); |
| maViewBox.EnableItem( TBX_ID_LIST, sal_True ); |
| maViewBox.CheckItem( ( GALLERYBROWSERMODE_ICON == GetMode() ) ? TBX_ID_ICON : TBX_ID_LIST, sal_True ); |
| |
| if(maInfoBar.GetText().Len() == 0) |
| mpIconView->SetAccessibleRelationLabeledBy(mpIconView); |
| else |
| mpIconView->SetAccessibleRelationLabeledBy(&maInfoBar); |
| mpIconView->SetAccessibleRelationMemberOf(mpIconView); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::SetMode( GalleryBrowserMode eMode ) |
| { |
| if( GetMode() != eMode ) |
| { |
| meLastMode = GetMode(); |
| |
| switch( eMode ) |
| { |
| case( GALLERYBROWSERMODE_ICON ): |
| { |
| mpListView->Hide(); |
| |
| mpPreview->Hide(); |
| mpPreview->SetGraphic( Graphic() ); |
| mpPreview->PreviewMedia( INetURLObject() ); |
| |
| mpIconView->Show(); |
| |
| maViewBox.EnableItem( TBX_ID_ICON, sal_True ); |
| maViewBox.EnableItem( TBX_ID_LIST, sal_True ); |
| |
| maViewBox.CheckItem( TBX_ID_ICON, sal_True ); |
| maViewBox.CheckItem( TBX_ID_LIST, sal_False ); |
| } |
| break; |
| |
| case( GALLERYBROWSERMODE_LIST ): |
| { |
| mpIconView->Hide(); |
| |
| mpPreview->Hide(); |
| mpPreview->SetGraphic( Graphic() ); |
| mpPreview->PreviewMedia( INetURLObject() ); |
| |
| mpListView->Show(); |
| |
| maViewBox.EnableItem( TBX_ID_ICON, sal_True ); |
| maViewBox.EnableItem( TBX_ID_LIST, sal_True ); |
| |
| maViewBox.CheckItem( TBX_ID_ICON, sal_False ); |
| maViewBox.CheckItem( TBX_ID_LIST, sal_True ); |
| } |
| break; |
| |
| case( GALLERYBROWSERMODE_PREVIEW ): |
| { |
| Graphic aGraphic; |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( NULL, aSelPos ); |
| |
| if( nItemId ) |
| { |
| const sal_uIntPtr nPos = nItemId - 1; |
| |
| mpIconView->Hide(); |
| mpListView->Hide(); |
| |
| if( mpCurTheme ) |
| mpCurTheme->GetGraphic( nPos, aGraphic ); |
| |
| mpPreview->SetGraphic( aGraphic ); |
| mpPreview->Show(); |
| |
| if( mpCurTheme && mpCurTheme->GetObjectKind( nPos ) == SGA_OBJ_SOUND ) |
| mpPreview->PreviewMedia( mpCurTheme->GetObjectURL( nPos ) ); |
| |
| maViewBox.EnableItem( TBX_ID_ICON, sal_False ); |
| maViewBox.EnableItem( TBX_ID_LIST, sal_False ); |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| GalleryBrowser2::meInitMode = meMode = eMode; |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Window* GalleryBrowser2::GetViewWindow() const |
| { |
| Window* pRet; |
| |
| switch( GetMode() ) |
| { |
| case( GALLERYBROWSERMODE_LIST ): pRet = mpListView; break; |
| case( GALLERYBROWSERMODE_PREVIEW ): pRet = mpPreview; break; |
| |
| default: |
| pRet = mpIconView; |
| break; |
| } |
| |
| return pRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::Travel( GalleryBrowserTravel eTravel ) |
| { |
| if( mpCurTheme ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( NULL, aSelPos ); |
| |
| if( nItemId ) |
| { |
| sal_uIntPtr nNewItemId = nItemId; |
| |
| switch( eTravel ) |
| { |
| case( GALLERYBROWSERTRAVEL_FIRST ): nNewItemId = 1; break; |
| case( GALLERYBROWSERTRAVEL_LAST ): nNewItemId = mpCurTheme->GetObjectCount(); break; |
| case( GALLERYBROWSERTRAVEL_PREVIOUS ): nNewItemId--; break; |
| case( GALLERYBROWSERTRAVEL_NEXT ): nNewItemId++; break; |
| default: |
| break; |
| } |
| |
| if( nNewItemId < 1 ) |
| nNewItemId = 1; |
| else if( nNewItemId > mpCurTheme->GetObjectCount() ) |
| nNewItemId = mpCurTheme->GetObjectCount(); |
| |
| if( nNewItemId != nItemId ) |
| { |
| ImplSelectItemId( nNewItemId ); |
| ImplUpdateInfoBar(); |
| |
| if( GALLERYBROWSERMODE_PREVIEW == GetMode() ) |
| { |
| Graphic aGraphic; |
| const sal_uIntPtr nPos = nNewItemId - 1; |
| |
| mpCurTheme->GetGraphic( nPos, aGraphic ); |
| mpPreview->SetGraphic( aGraphic ); |
| |
| if( SGA_OBJ_SOUND == mpCurTheme->GetObjectKind( nPos ) ) |
| mpPreview->PreviewMedia( mpCurTheme->GetObjectURL( nPos ) ); |
| |
| mpPreview->Invalidate(); |
| } |
| } |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::ImplUpdateViews( sal_uInt16 nSelectionId ) |
| { |
| mpIconView->Hide(); |
| mpListView->Hide(); |
| mpPreview->Hide(); |
| |
| mpIconView->Clear(); |
| mpListView->Clear(); |
| |
| if( mpCurTheme ) |
| { |
| for( sal_uIntPtr i = 0, nCount = mpCurTheme->GetObjectCount(); i < nCount; ) |
| { |
| mpListView->RowInserted( i++ ); |
| mpIconView->InsertItem( (sal_uInt16) i ); |
| } |
| |
| ImplSelectItemId( ( ( nSelectionId > mpCurTheme->GetObjectCount() ) ? mpCurTheme->GetObjectCount() : nSelectionId ) ); |
| } |
| |
| switch( GetMode() ) |
| { |
| case( GALLERYBROWSERMODE_ICON ): mpIconView->Show(); break; |
| case( GALLERYBROWSERMODE_LIST ): mpListView->Show(); break; |
| case( GALLERYBROWSERMODE_PREVIEW ): mpPreview->Show(); break; |
| |
| default: |
| break; |
| } |
| |
| ImplUpdateInfoBar(); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::ImplUpdateInfoBar() |
| { |
| String aInfoText; |
| |
| if( mpCurTheme ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( NULL, aSelPos ); |
| |
| if( nItemId ) |
| { |
| const sal_uIntPtr nPos = nItemId - 1; |
| |
| aInfoText = mpCurTheme->GetName(); |
| |
| if( nPos < mpCurTheme->GetObjectCount() ) |
| { |
| SgaObject* pObj = mpCurTheme->AcquireObject( nPos ); |
| |
| if( pObj ) |
| { |
| aInfoText = GetItemText( *mpCurTheme, *pObj, GALLERY_ITEM_THEMENAME | GALLERY_ITEM_TITLE | GALLERY_ITEM_PATH ); |
| mpCurTheme->ReleaseObject( pObj ); |
| } |
| } |
| } |
| } |
| |
| maInfoBar.SetText( aInfoText ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_uIntPtr GalleryBrowser2::ImplGetSelectedItemId( const Point* pSelPos, Point& rSelPos ) |
| { |
| const Size aOutputSizePixel( GetOutputSizePixel() ); |
| sal_uIntPtr nRet = 0; |
| |
| if( GALLERYBROWSERMODE_PREVIEW == GetMode() ) |
| { |
| nRet = ( ( GALLERYBROWSERMODE_ICON == meLastMode ) ? mpIconView->GetSelectItemId() : ( mpListView->FirstSelectedRow() + 1 ) ); |
| |
| if( pSelPos ) |
| rSelPos = GetPointerPosPixel(); |
| else |
| rSelPos = Point( aOutputSizePixel.Width() >> 1, aOutputSizePixel.Height() >> 1 ); |
| } |
| else if( GALLERYBROWSERMODE_ICON == GetMode() ) |
| { |
| if( pSelPos ) |
| { |
| nRet = mpIconView->GetItemId( *pSelPos ); |
| rSelPos = GetPointerPosPixel(); |
| } |
| else |
| { |
| nRet = mpIconView->GetSelectItemId(); |
| rSelPos = mpIconView->GetItemRect( (sal_uInt16) nRet ).Center(); |
| } |
| } |
| else |
| { |
| if( pSelPos ) |
| { |
| nRet = mpListView->GetRowAtYPosPixel( pSelPos->Y() ) + 1; |
| rSelPos = GetPointerPosPixel(); |
| } |
| else |
| { |
| nRet = mpListView->FirstSelectedRow() + 1; |
| rSelPos = mpListView->GetFieldRectPixel( (sal_uInt16) nRet, 1 ).Center(); |
| } |
| } |
| |
| rSelPos.X() = Max( Min( rSelPos.X(), aOutputSizePixel.Width() - 1L ), 0L ); |
| rSelPos.Y() = Max( Min( rSelPos.Y(), aOutputSizePixel.Height() - 1L ), 0L ); |
| |
| if( nRet && ( !mpCurTheme || ( nRet > mpCurTheme->GetObjectCount() ) ) ) |
| { |
| nRet = 0; |
| } |
| |
| return nRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void GalleryBrowser2::ImplSelectItemId( sal_uIntPtr nItemId ) |
| { |
| if( nItemId ) |
| { |
| |
| mpIconView->SelectItem( (sal_uInt16) nItemId ); |
| mpListView->SelectRow( nItemId - 1 ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| css::uno::Reference< css::frame::XFrame > |
| GalleryBrowser2::GetFrame() const |
| { |
| css::uno::Reference< css::frame::XFrame > xFrame; |
| SfxViewFrame* pCurrentViewFrame = SfxViewFrame::Current(); |
| if ( pCurrentViewFrame ) |
| { |
| SfxBindings& rBindings = pCurrentViewFrame->GetBindings(); |
| xFrame.set( rBindings.GetActiveFrame() ); |
| } |
| |
| return xFrame; |
| } |
| |
| void GalleryBrowser2::Dispatch( |
| sal_uInt16 nId, |
| const css::uno::Reference< css::frame::XDispatch > &rxDispatch, |
| const css::util::URL &rURL ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( NULL, aSelPos ); |
| |
| if( !mpCurTheme || !nItemId ) |
| return; |
| |
| mnCurActionPos = nItemId - 1; |
| |
| switch( nId ) |
| { |
| case( MN_ADD ): |
| case( MN_ADD_LINK ): |
| { |
| css::uno::Reference< css::frame::XDispatch > xDispatch( rxDispatch ); |
| css::util::URL aURL = rURL; |
| |
| if ( !xDispatch.is() ) |
| { |
| css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider( |
| GetFrame(), css::uno::UNO_QUERY ); |
| if ( !xDispatchProvider.is() || !m_xTransformer.is() ) |
| return; |
| |
| aURL.Complete = C2U( CMD_SID_GALLERY_FORMATS ); |
| m_xTransformer->parseStrict( aURL ); |
| xDispatch = xDispatchProvider->queryDispatch( |
| aURL, |
| C2U( "_self" ), |
| css::frame::FrameSearchFlag::SELF ); |
| } |
| |
| if ( !xDispatch.is() ) |
| return; |
| |
| sal_Int8 nType = 0; |
| sal_Bool bIsLink( MN_ADD_LINK == nId ); |
| OUString aFileURL, aFilterName; |
| css::uno::Reference< css::lang::XComponent > xDrawing; |
| css::uno::Reference< css::graphic::XGraphic > xGraphic; |
| |
| aFilterName = GetFilterName(); |
| |
| switch( mpCurTheme->GetObjectKind( mnCurActionPos ) ) |
| { |
| case( SGA_OBJ_BMP ): |
| case( SGA_OBJ_ANIM ): |
| case( SGA_OBJ_INET ): |
| // TODO drawing objects are inserted as drawings only via drag&drop |
| case( SGA_OBJ_SVDRAW ): |
| nType = css::gallery::GalleryItemType::GRAPHIC; |
| break; |
| |
| case ( SGA_OBJ_SOUND ) : |
| nType = css::gallery::GalleryItemType::MEDIA; |
| break; |
| |
| default: |
| nType = css::gallery::GalleryItemType::EMPTY; |
| break; |
| } |
| |
| if ( bIsLink ) |
| { |
| aFileURL = mpCurTheme->GetObjectURL( mnCurActionPos ).GetMainURL( INetURLObject::NO_DECODE ); |
| OSL_ENSURE( aFileURL.getLength(), "gallery item is link but no URL!" ); |
| } |
| |
| Graphic aGraphic; |
| sal_Bool bGraphic = mpCurTheme->GetGraphic( mnCurActionPos, aGraphic ); |
| if ( bGraphic && !!aGraphic ) |
| xGraphic.set( aGraphic.GetXGraphic() ); |
| OSL_ENSURE( xGraphic.is(), "gallery item is graphic, but the reference is invalid!" ); |
| |
| css::uno::Sequence< css::beans::PropertyValue > aSeq( SVXGALLERYITEM_PARAMS ); |
| |
| aSeq[0].Name = C2U( SVXGALLERYITEM_TYPE ); |
| aSeq[0].Value <<= nType; |
| aSeq[1].Name = C2U( SVXGALLERYITEM_LINK ); |
| aSeq[1].Value <<= bIsLink; |
| aSeq[2].Name = C2U( SVXGALLERYITEM_URL ); |
| aSeq[2].Value <<= aFileURL; |
| aSeq[3].Name = C2U( SVXGALLERYITEM_FILTER ); |
| aSeq[3].Value <<= aFilterName; |
| aSeq[4].Name = C2U( SVXGALLERYITEM_DRAWING ); |
| aSeq[4].Value <<= xDrawing; |
| aSeq[5].Name = C2U( SVXGALLERYITEM_GRAPHIC ); |
| aSeq[5].Value <<= xGraphic; |
| |
| css::uno::Sequence< css::beans::PropertyValue > aArgs( 1 ); |
| aArgs[0].Name = C2U( SVXGALLERYITEM_ARGNAME ); |
| aArgs[0].Value <<= aSeq; |
| |
| DispatchInfo *pInfo = new DispatchInfo; |
| pInfo->TargetURL = aURL; |
| pInfo->Arguments = aArgs; |
| pInfo->Dispatch = xDispatch; |
| |
| if ( !Application::PostUserEvent( |
| STATIC_LINK( 0, GalleryBrowser2, AsyncDispatch_Impl), pInfo ) ) |
| delete pInfo; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| void GalleryBrowser2::Execute( sal_uInt16 nId ) |
| { |
| Point aSelPos; |
| const sal_uIntPtr nItemId = ImplGetSelectedItemId( NULL, aSelPos ); |
| |
| if( mpCurTheme && nItemId ) |
| { |
| mnCurActionPos = nItemId - 1; |
| |
| switch( nId ) |
| { |
| case( MN_PREVIEW ): |
| SetMode( ( GALLERYBROWSERMODE_PREVIEW != GetMode() ) ? GALLERYBROWSERMODE_PREVIEW : meLastMode ); |
| break; |
| |
| case( MN_DELETE ): |
| { |
| if( !mpCurTheme->IsReadOnly() && |
| QueryBox( NULL, WB_YES_NO, String( GAL_RESID( RID_SVXSTR_GALLERY_DELETEOBJ ) ) ).Execute() == RET_YES ) |
| { |
| mpCurTheme->RemoveObject( mnCurActionPos ); |
| } |
| } |
| break; |
| |
| case( MN_TITLE ): |
| { |
| SgaObject* pObj = mpCurTheme->AcquireObject( mnCurActionPos ); |
| |
| if( pObj ) |
| { |
| const String aOldTitle( GetItemText( *mpCurTheme, *pObj, GALLERY_ITEM_TITLE ) ); |
| //CHINA001 TitleDialog aDlg( this, aOldTitle ); |
| SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); |
| if(pFact) |
| { |
| AbstractTitleDialog* aDlg = pFact->CreateTitleDialog( this, aOldTitle ); |
| DBG_ASSERT(aDlg, "Dialogdiet fail!");//CHINA001 |
| if( aDlg->Execute() == RET_OK )//CHINA001 if( aDlg.Execute() == RET_OK ) |
| { |
| String aNewTitle( aDlg->GetTitle() );//CHINA001 String aNewTitle( aDlg.GetTitle() ); |
| |
| if( ( !aNewTitle.Len() && pObj->GetTitle().Len() ) || ( aNewTitle != aOldTitle ) ) |
| { |
| if( !aNewTitle.Len() ) |
| aNewTitle = String( RTL_CONSTASCII_USTRINGPARAM( "__<empty>__" ) ); |
| |
| pObj->SetTitle( aNewTitle ); |
| mpCurTheme->InsertObject( *pObj ); |
| } |
| } |
| |
| mpCurTheme->ReleaseObject( pObj ); |
| delete aDlg; //add CHINA001 |
| } |
| } |
| } |
| break; |
| |
| case( MN_COPYCLIPBOARD ): |
| { |
| Window* pWindow; |
| |
| switch( GetMode() ) |
| { |
| case( GALLERYBROWSERMODE_ICON ): pWindow = (Window*) mpIconView; break; |
| case( GALLERYBROWSERMODE_LIST ): pWindow = (Window*) mpListView; break; |
| case( GALLERYBROWSERMODE_PREVIEW ): pWindow = (Window*) mpPreview; break; |
| |
| default: |
| pWindow = NULL; |
| break; |
| } |
| |
| mpCurTheme->CopyToClipboard( pWindow, mnCurActionPos ); |
| } |
| break; |
| |
| case( MN_PASTECLIPBOARD ): |
| { |
| if( !mpCurTheme->IsReadOnly() ) |
| { |
| TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( this ) ); |
| mpCurTheme->InsertTransferable( aDataHelper.GetTransferable(), mnCurActionPos ); |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| String GalleryBrowser2::GetItemText( const GalleryTheme& rTheme, const SgaObject& rObj, sal_uIntPtr nItemTextFlags ) |
| { |
| INetURLObject aURL; |
| String aRet; |
| |
| if( rTheme.IsImported() ) |
| { |
| aURL = rTheme.GetParent()->GetImportURL( rTheme.GetName() ); |
| |
| aURL.removeSegment(); |
| aURL.Append( rObj.GetURL().GetName() ); |
| } |
| else |
| aURL = rObj.GetURL(); |
| |
| if( nItemTextFlags & GALLERY_ITEM_THEMENAME ) |
| { |
| aRet += rTheme.GetName(); |
| aRet += String( RTL_CONSTASCII_USTRINGPARAM( " - " ) ); |
| } |
| |
| if( nItemTextFlags & GALLERY_ITEM_TITLE ) |
| { |
| String aTitle( rObj.GetTitle() ); |
| |
| if( !aTitle.Len() ) |
| aTitle = aURL.getBase( INetURLObject::LAST_SEGMENT, true, INetURLObject::DECODE_UNAMBIGUOUS ); |
| |
| if( !aTitle.Len() ) |
| { |
| aTitle = aURL.GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS ); |
| aTitle = aTitle.GetToken( aTitle.GetTokenCount( '/' ) - 1, '/' ); |
| } |
| |
| aRet += aTitle; |
| } |
| |
| if( nItemTextFlags & GALLERY_ITEM_PATH ) |
| { |
| const String aPath( aURL.getFSysPath( INetURLObject::FSYS_DETECT ) ); |
| |
| if( aPath.Len() && ( nItemTextFlags & GALLERY_ITEM_TITLE ) ) |
| aRet += String( RTL_CONSTASCII_USTRINGPARAM( " (" ) ); |
| |
| aRet += String(aURL.getFSysPath( INetURLObject::FSYS_DETECT )); |
| |
| if( aPath.Len() && ( nItemTextFlags & GALLERY_ITEM_TITLE ) ) |
| aRet += ')'; |
| } |
| |
| return aRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| INetURLObject GalleryBrowser2::GetURL() const |
| { |
| INetURLObject aURL; |
| |
| if( mpCurTheme && mnCurActionPos != 0xffffffff ) |
| aURL = mpCurTheme->GetObjectURL( mnCurActionPos ); |
| |
| return aURL; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| String GalleryBrowser2::GetFilterName() const |
| { |
| String aFilterName; |
| |
| if( mpCurTheme && mnCurActionPos != 0xffffffff ) |
| { |
| const SgaObjKind eObjKind = mpCurTheme->GetObjectKind( mnCurActionPos ); |
| |
| if( ( SGA_OBJ_BMP == eObjKind ) || ( SGA_OBJ_ANIM == eObjKind ) ) |
| { |
| GraphicFilter* pFilter = GraphicFilter::GetGraphicFilter(); |
| INetURLObject aURL; mpCurTheme->GetURL( mnCurActionPos, aURL ); |
| sal_uInt16 nFilter = pFilter->GetImportFormatNumberForShortName( aURL.GetExtension() ); |
| |
| if( GRFILTER_FORMAT_DONTKNOW != nFilter ) |
| aFilterName = pFilter->GetImportFormatName( nFilter ); |
| } |
| } |
| |
| return aFilterName; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| Graphic GalleryBrowser2::GetGraphic() const |
| { |
| Graphic aGraphic; |
| |
| if( mpCurTheme && mnCurActionPos != 0xffffffff ) |
| mpCurTheme->GetGraphic( mnCurActionPos, aGraphic ); |
| |
| return aGraphic; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| sal_Bool GalleryBrowser2::GetVCDrawModel( FmFormModel& rModel ) const |
| { |
| sal_Bool bRet = sal_False; |
| |
| if( mpCurTheme && mnCurActionPos != 0xffffffff ) |
| bRet = mpCurTheme->GetModel( mnCurActionPos, rModel ); |
| |
| return bRet; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| IMPL_LINK( GalleryBrowser2, SelectObjectHdl, void*, EMPTYARG ) |
| { |
| ImplUpdateInfoBar(); |
| return 0L; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| IMPL_LINK( GalleryBrowser2, SelectTbxHdl, ToolBox*, pBox ) |
| { |
| if( pBox->GetCurItemId() == TBX_ID_ICON ) |
| SetMode( GALLERYBROWSERMODE_ICON ); |
| else if( pBox->GetCurItemId() == TBX_ID_LIST ) |
| SetMode( GALLERYBROWSERMODE_LIST ); |
| |
| return 0L; |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| IMPL_LINK( GalleryBrowser2, MiscHdl, void*, EMPTYARG ) |
| { |
| const sal_Bool bHC = maViewBox.GetSettings().GetStyleSettings().GetHighContrastMode(); |
| |
| maViewBox.SetOutStyle( maMiscOptions.GetToolboxStyle() ); |
| |
| BitmapEx aIconBmpEx = BitmapEx( Image( GAL_RESID( bHC? RID_SVXIMG_GALLERY_VIEW_ICON_HC : RID_SVXIMG_GALLERY_VIEW_ICON ) ).GetBitmapEx() ); |
| BitmapEx aListBmpEx = BitmapEx( Image( GAL_RESID( bHC? RID_SVXIMG_GALLERY_VIEW_LIST_HC : RID_SVXIMG_GALLERY_VIEW_LIST ) ).GetBitmapEx() ); |
| |
| if( maMiscOptions.AreCurrentSymbolsLarge() ) |
| { |
| const Size aLargeSize( 24, 24); |
| |
| aIconBmpEx.Scale( aLargeSize ); |
| aListBmpEx.Scale( aLargeSize ); |
| } |
| |
| maViewBox.SetItemImage( TBX_ID_ICON, aIconBmpEx ); |
| maViewBox.SetItemImage( TBX_ID_LIST, aListBmpEx ); |
| maViewBox.SetSizePixel( maViewBox.CalcWindowSizePixel() ); |
| |
| Resize(); |
| |
| return 0L; |
| } |
