/************************************************************** * * 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_sd.hxx" #include #include #include #include #include #include #include #include #include #include "cusshow.hxx" #include #include #include "strmname.h" #include "sdtreelb.hxx" #include "DrawDocShell.hxx" #include "drawdoc.hxx" #include "sdpage.hxx" #include "sdresid.hxx" #include "navigatr.hxx" #ifndef _SD_CFGID_HXX #include "strings.hrc" #endif #include "res_bmp.hrc" #include "ViewShell.hxx" #include "DrawController.hxx" #include "ViewShellBase.hxx" #include #include #include #include #include #include using namespace com::sun::star; class SdPageObjsTLB::IconProvider { public: IconProvider (void); // Regular icons. Image maImgPage; Image maImgPageExcl; Image maImgPageObjsExcl; Image maImgPageObjs; Image maImgObjects; Image maImgGroup; // High contrast icons. Image maImgPageH; Image maImgPageExclH; Image maImgPageObjsExclH; Image maImgPageObjsH; Image maImgObjectsH; Image maImgGroupH; }; sal_Bool SD_DLLPRIVATE SdPageObjsTLB::bIsInDrag = sal_False; sal_Bool SdPageObjsTLB::IsInDrag() { return bIsInDrag; } sal_uInt32 SdPageObjsTLB::SdPageObjsTransferable::mnListBoxDropFormatId = SAL_MAX_UINT32; // ----------------------------------------- // - SdPageObjsTLB::SdPageObjsTransferable - // ----------------------------------------- SdPageObjsTLB::SdPageObjsTransferable::SdPageObjsTransferable( SdPageObjsTLB& rParent, const INetBookmark& rBookmark, ::sd::DrawDocShell& rDocShell, NavigatorDragType eDragType, const ::com::sun::star::uno::Any& rTreeListBoxData ) : SdTransferable(rDocShell.GetDoc(), NULL, sal_True), mrParent( rParent ), maBookmark( rBookmark ), mrDocShell( rDocShell ), meDragType( eDragType ), maTreeListBoxData( rTreeListBoxData ) { } SdPageObjsTLB::SdPageObjsTransferable::~SdPageObjsTransferable() { } // ----------------------------------------------------------------------------- void SdPageObjsTLB::SdPageObjsTransferable::AddSupportedFormats() { AddFormat(SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK); AddFormat(SOT_FORMATSTR_ID_TREELISTBOX); AddFormat(GetListBoxDropFormatId()); } // ----------------------------------------------------------------------------- sal_Bool SdPageObjsTLB::SdPageObjsTransferable::GetData( const ::com::sun::star::datatransfer::DataFlavor& rFlavor ) { sal_uLong nFormatId = SotExchange::GetFormat( rFlavor ); switch (nFormatId) { case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK: SetINetBookmark( maBookmark, rFlavor ); return sal_True; case SOT_FORMATSTR_ID_TREELISTBOX: SetAny(maTreeListBoxData, rFlavor); return sal_True; default: return sal_False; } } // ----------------------------------------------------------------------------- void SdPageObjsTLB::SdPageObjsTransferable::DragFinished( sal_Int8 nDropAction ) { mrParent.OnDragFinished( nDropAction ); SdTransferable::DragFinished(nDropAction); } // ----------------------------------------------------------------------------- ::sd::DrawDocShell& SdPageObjsTLB::SdPageObjsTransferable::GetDocShell() const { return mrDocShell; } // ----------------------------------------------------------------------------- NavigatorDragType SdPageObjsTLB::SdPageObjsTransferable::GetDragType() const { return meDragType; } // ----------------------------------------------------------------------------- sal_Int64 SAL_CALL SdPageObjsTLB::SdPageObjsTransferable::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw( ::com::sun::star::uno::RuntimeException ) { sal_Int64 nRet; if( ( rId.getLength() == 16 ) && ( 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) ) { nRet = (sal_Int64)(sal_IntPtr)this; } else nRet = SdTransferable::getSomething(rId); return nRet; } // ----------------------------------------------------------------------------- const ::com::sun::star::uno::Sequence< sal_Int8 >& SdPageObjsTLB::SdPageObjsTransferable::getUnoTunnelId() { static ::com::sun::star::uno::Sequence< sal_Int8 > aSeq; if( !aSeq.getLength() ) { static osl::Mutex aCreateMutex; osl::MutexGuard aGuard( aCreateMutex ); aSeq.realloc( 16 ); rtl_createUuid( reinterpret_cast< sal_uInt8* >( aSeq.getArray() ), 0, sal_True ); } return aSeq; } // ----------------------------------------------------------------------------- SdPageObjsTLB::SdPageObjsTransferable* SdPageObjsTLB::SdPageObjsTransferable::getImplementation( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& rxData ) throw() { try { ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUnoTunnel( rxData, ::com::sun::star::uno::UNO_QUERY_THROW ); return reinterpret_cast( sal::static_int_cast( xUnoTunnel->getSomething( SdPageObjsTLB::SdPageObjsTransferable::getUnoTunnelId()) ) ); } catch( const ::com::sun::star::uno::Exception& ) { } return 0; } sal_uInt32 SdPageObjsTLB::SdPageObjsTransferable::GetListBoxDropFormatId (void) { if (mnListBoxDropFormatId == SAL_MAX_UINT32) mnListBoxDropFormatId = SotExchange::RegisterFormatMimeType( ::rtl::OUString::createFromAscii( "application/x-openoffice-treelistbox-moveonly;" "windows_formatname=\"SV_LBOX_DD_FORMAT_MOVE\"")); return mnListBoxDropFormatId; } /************************************************************************* |* |* Ctor1 SdPageObjsTLB |* \************************************************************************/ SdPageObjsTLB::SdPageObjsTLB( Window* pParentWin, const SdResId& rSdResId ) : SvTreeListBox ( pParentWin, rSdResId ) , mpParent ( pParentWin ) , mpDoc ( NULL ) , mpBookmarkDoc ( NULL ) , mpMedium ( NULL ) , mpOwnMedium ( NULL ) , maImgOle ( BitmapEx( SdResId( BMP_OLE ) ) ) , maImgGraphic ( BitmapEx( SdResId( BMP_GRAPHIC ) ) ) , maImgOleH ( BitmapEx( SdResId( BMP_OLE_H ) ) ) , maImgGraphicH ( BitmapEx( SdResId( BMP_GRAPHIC_H ) ) ) , mbLinkableSelected ( sal_False ) , mpDropNavWin ( NULL ) , mbShowAllShapes ( false ) , mbShowAllPages ( false ) { // Tree-ListBox mit Linien versehen SetStyle( GetStyle() | WB_TABSTOP | WB_BORDER | WB_HASLINES | WB_HASBUTTONS | // WB_HASLINESATROOT | WB_HSCROLL | // #31562# WB_HASBUTTONSATROOT | WB_QUICK_SEARCH /* i31275 */ ); SetNodeBitmaps( Bitmap( SdResId( BMP_EXPAND ) ), Bitmap( SdResId( BMP_COLLAPSE ) ) ); SetNodeBitmaps( Bitmap( SdResId( BMP_EXPAND_H ) ), Bitmap( SdResId( BMP_COLLAPSE_H ) ), BMP_COLOR_HIGHCONTRAST ); SetDragDropMode( SV_DRAGDROP_CTRL_MOVE | SV_DRAGDROP_CTRL_COPY | SV_DRAGDROP_APP_MOVE | SV_DRAGDROP_APP_COPY | SV_DRAGDROP_APP_DROP ); } /************************************************************************* |* |* Dtor SdPageObjsTLB |* \************************************************************************/ SdPageObjsTLB::~SdPageObjsTLB() { if ( mpBookmarkDoc ) CloseBookmarkDoc(); else // no document was created from mpMedium, so this object is still the owner of it delete mpMedium; } /************************************************************************* |* |* return name of object |* \************************************************************************/ String SdPageObjsTLB::GetObjectName( const SdrObject* pObject, const bool bCreate) const { String aRet; if ( pObject ) { aRet = pObject->GetName(); if( !aRet.Len() && pObject->ISA( SdrOle2Obj ) ) aRet = static_cast< const SdrOle2Obj* >( pObject )->GetPersistName(); } if (bCreate && mbShowAllShapes && aRet.Len() == 0 && pObject!=NULL) { aRet = SdResId(STR_NAVIGATOR_SHAPE_BASE_NAME); aRet.SearchAndReplaceAscii("%1", String::CreateFromInt32(pObject->GetOrdNum() + 1)); } return aRet; } /************************************************************************* |* |* In TreeLB Eintrag selektieren |* \************************************************************************/ sal_Bool SdPageObjsTLB::SelectEntry( const String& rName ) { sal_Bool bFound = sal_False; if( rName.Len() ) { SvLBoxEntry* pEntry = NULL; String aTmp; for( pEntry = First(); pEntry && !bFound; pEntry = Next( pEntry ) ) { aTmp = GetEntryText( pEntry ); if( aTmp == rName ) { bFound = sal_True; SetCurEntry( pEntry ); } } } return( bFound ); } /************************************************************************* |* |* Gibt zurueck, ob Childs des uebergebenen Strings selektiert sind |* \************************************************************************/ sal_Bool SdPageObjsTLB::HasSelectedChilds( const String& rName ) { sal_Bool bFound = sal_False; sal_Bool bChilds = sal_False; if( rName.Len() ) { SvLBoxEntry* pEntry = NULL; String aTmp; for( pEntry = First(); pEntry && !bFound; pEntry = Next( pEntry ) ) { aTmp = GetEntryText( pEntry ); if( aTmp == rName ) { bFound = sal_True; sal_Bool bExpanded = IsExpanded( pEntry ); long nCount = GetChildSelectionCount( pEntry ); if( bExpanded && nCount > 0 ) bChilds = sal_True; } } } return( bChilds ); } /************************************************************************* |* |* TreeLB mit Seiten und Objekten fuellen |* \************************************************************************/ void SdPageObjsTLB::Fill( const SdDrawDocument* pInDoc, sal_Bool bAllPages, const String& rDocName) { String aSelection; if( GetSelectionCount() > 0 ) { aSelection = GetSelectEntry(); Clear(); } mpDoc = pInDoc; maDocName = rDocName; mbShowAllPages = (bAllPages == sal_True); mpMedium = NULL; SdPage* pPage = NULL; IconProvider aIconProvider; // first insert all pages including objects sal_uInt16 nPage = 0; const sal_uInt16 nMaxPages = mpDoc->GetPageCount(); while( nPage < nMaxPages ) { pPage = (SdPage*) mpDoc->GetPage( nPage ); if( (mbShowAllPages || pPage->GetPageKind() == PK_STANDARD) && !(pPage->GetPageKind()==PK_HANDOUT) ) //#94954# never list the normal handout page ( handout-masterpage is used instead ) { sal_Bool bPageExluded = pPage->IsExcluded(); bool bPageBelongsToShow = PageBelongsToCurrentShow (pPage); bPageExluded |= !bPageBelongsToShow; AddShapeList(*pPage, NULL, pPage->GetName(), bPageExluded, NULL, aIconProvider); } nPage++; } // dann alle MasterPages incl. Objekte einfuegen if( mbShowAllPages ) { nPage = 0; const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterPageCount(); while( nPage < nMaxMasterPages ) { pPage = (SdPage*) mpDoc->GetMasterPage( nPage ); AddShapeList(*pPage, NULL, pPage->GetName(), false, NULL, aIconProvider); nPage++; } } if( aSelection.Len() ) SelectEntry( aSelection ); } /************************************************************************* |* |* Es wird nur der erste Eintrag eingefuegt. Childs werden OnDemand erzeugt |* \************************************************************************/ void SdPageObjsTLB::Fill( const SdDrawDocument* pInDoc, SfxMedium* pInMedium, const String& rDocName ) { mpDoc = pInDoc; // this object now owns the Medium mpMedium = pInMedium; maDocName = rDocName; Image aImgDocOpen=Image( BitmapEx( SdResId( BMP_DOC_OPEN ) ) ); Image aImgDocClosed=Image( BitmapEx( SdResId( BMP_DOC_CLOSED ) ) ); Image aImgDocOpenH=Image( BitmapEx( SdResId( BMP_DOC_OPEN_H ) ) ); Image aImgDocClosedH=Image( BitmapEx( SdResId( BMP_DOC_CLOSED_H ) ) ); // Dokumentnamen einfuegen SvLBoxEntry* pFileEntry = InsertEntry( maDocName, aImgDocOpen, aImgDocClosed, NULL, sal_True, LIST_APPEND, reinterpret_cast< void* >( 1 ) ); SetExpandedEntryBmp( pFileEntry, aImgDocOpenH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pFileEntry, aImgDocClosedH, BMP_COLOR_HIGHCONTRAST ); } void SdPageObjsTLB::AddShapeList ( const SdrObjList& rList, SdrObject* pShape, const ::rtl::OUString& rsName, const bool bIsExcluded, SvLBoxEntry* pParentEntry, const IconProvider& rIconProvider) { Image aIcon (rIconProvider.maImgPage); if (bIsExcluded) aIcon = rIconProvider.maImgPageExcl; else if (pShape != NULL) aIcon = rIconProvider.maImgGroup; void* pUserData (reinterpret_cast(1)); if (pShape != NULL) pUserData = pShape; SvLBoxEntry* pEntry = InsertEntry( rsName, aIcon, aIcon, pParentEntry, sal_False, LIST_APPEND, pUserData); SetExpandedEntryBmp( pEntry, bIsExcluded ? rIconProvider.maImgPageExclH : rIconProvider.maImgPageH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pEntry, bIsExcluded ? rIconProvider.maImgPageExclH : rIconProvider.maImgPageH, BMP_COLOR_HIGHCONTRAST ); SdrObjListIter aIter( rList, !rList.HasObjectNavigationOrder() /* use navigation order, if available */, IM_FLAT, sal_False /*not reverse*/); while( aIter.IsMore() ) { SdrObject* pObj = aIter.Next(); OSL_ASSERT(pObj!=NULL); // Get the shape name. String aStr (GetObjectName( pObj ) ); if( aStr.Len() ) { if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_OLE2 ) { SvLBoxEntry* pNewEntry = InsertEntry( aStr, maImgOle, maImgOle, pEntry, sal_False, LIST_APPEND, pObj); SetExpandedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST ); } else if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_GRAF ) { SvLBoxEntry* pNewEntry = InsertEntry( aStr, maImgGraphic, maImgGraphic, pEntry, sal_False, LIST_APPEND, pObj ); SetExpandedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST ); } else if (pObj->IsGroupObject()) { AddShapeList( *pObj->GetSubList(), pObj, aStr, false, pEntry, rIconProvider); } else { SvLBoxEntry* pNewEntry = InsertEntry( aStr, rIconProvider.maImgObjects, rIconProvider.maImgObjects, pEntry, sal_False, LIST_APPEND, pObj ); SetExpandedEntryBmp( pNewEntry, rIconProvider.maImgObjectsH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pNewEntry, rIconProvider.maImgObjectsH, BMP_COLOR_HIGHCONTRAST ); } } } if( pEntry->HasChilds() ) { SetExpandedEntryBmp( pEntry, bIsExcluded ? rIconProvider.maImgPageObjsExcl : rIconProvider.maImgPageObjs); SetCollapsedEntryBmp( pEntry, bIsExcluded ? rIconProvider.maImgPageObjsExcl : rIconProvider.maImgPageObjs); SetExpandedEntryBmp( pEntry, bIsExcluded ? rIconProvider.maImgPageObjsExclH : rIconProvider.maImgPageObjsH, BMP_COLOR_HIGHCONTRAST); SetCollapsedEntryBmp( pEntry, bIsExcluded ? rIconProvider.maImgPageObjsExclH : rIconProvider.maImgPageObjsH, BMP_COLOR_HIGHCONTRAST); } } void SdPageObjsTLB::SetShowAllShapes ( const bool bShowAllShapes, const bool bFillList) { mbShowAllShapes = bShowAllShapes; if (bFillList) { if (mpMedium == NULL) Fill(mpDoc, mbShowAllPages, maDocName); else Fill(mpDoc, mpMedium, maDocName); } } bool SdPageObjsTLB::GetShowAllShapes (void) const { return mbShowAllShapes; } /************************************************************************* |* |* Prueft, ob die Seiten (PK_STANDARD) und die darauf befindlichen Objekte |* des Docs und der TreeLB identisch sind. |* Wird ein Doc uebergeben, wird dieses zum aktuellem Doc (Wichtig bei |* mehreren Documenten). |* \************************************************************************/ sal_Bool SdPageObjsTLB::IsEqualToDoc( const SdDrawDocument* pInDoc ) { if( pInDoc ) mpDoc = pInDoc; if( !mpDoc ) return( sal_False ); SdrObject* pObj = NULL; SdPage* pPage = NULL; SvLBoxEntry* pEntry = First(); String aName; // Alle Pages incl. Objekte vergleichen sal_uInt16 nPage = 0; const sal_uInt16 nMaxPages = mpDoc->GetPageCount(); while( nPage < nMaxPages ) { pPage = (SdPage*) mpDoc->GetPage( nPage ); if( pPage->GetPageKind() == PK_STANDARD ) { if( !pEntry ) return( sal_False ); aName = GetEntryText( pEntry ); if( pPage->GetName() != aName ) return( sal_False ); pEntry = Next( pEntry ); SdrObjListIter aIter( *pPage, !pPage->HasObjectNavigationOrder() /* use navigation order, if available */, IM_DEEPWITHGROUPS ); while( aIter.IsMore() ) { pObj = aIter.Next(); const String aObjectName( GetObjectName( pObj ) ); if( aObjectName.Len() ) { if( !pEntry ) return( sal_False ); aName = GetEntryText( pEntry ); if( aObjectName != aName ) return( sal_False ); pEntry = Next( pEntry ); } } } nPage++; } // Wenn noch Eintraege in der Listbox vorhanden sind, wurden // Objekte (mit Namen) oder Seiten geloescht return( !pEntry ); } /************************************************************************* |* |* Selectierten String zurueckgeben |* \************************************************************************/ String SdPageObjsTLB::GetSelectEntry() { return( GetEntryText( GetCurEntry() ) ); } /************************************************************************* |* |* Selektierte Eintrage zurueckgeben |* nDepth == 0 -> Seiten |* nDepth == 1 -> Objekte |* \************************************************************************/ List* SdPageObjsTLB::GetSelectEntryList( sal_uInt16 nDepth ) { List* pList = NULL; SvLBoxEntry* pEntry = FirstSelected(); while( pEntry ) { sal_uInt16 nListDepth = GetModel()->GetDepth( pEntry ); if( nListDepth == nDepth ) { if( !pList ) pList = new List(); const String aEntryText( GetEntryText( pEntry ) ); pList->Insert( new String( aEntryText ), LIST_APPEND ); } pEntry = NextSelected( pEntry ); } return( pList ); } /************************************************************************* |* |* Eintraege werden erst auf Anforderung (Doppelklick) eingefuegt |* \************************************************************************/ void SdPageObjsTLB::RequestingChilds( SvLBoxEntry* pFileEntry ) { if( !pFileEntry->HasChilds() ) { if( GetBookmarkDoc() ) { SdrObject* pObj = NULL; SdPage* pPage = NULL; SvLBoxEntry* pPageEntry = NULL; Image aImgPage=Image( BitmapEx( SdResId( BMP_PAGE ) ) ); Image aImgPageObjs=Image( BitmapEx( SdResId( BMP_PAGEOBJS ) ) ); Image aImgObjects=Image( BitmapEx( SdResId( BMP_OBJECTS ) ) ); Image aImgPageH=Image( BitmapEx( SdResId( BMP_PAGE_H ) ) ); Image aImgPageObjsH=Image( BitmapEx( SdResId( BMP_PAGEOBJS_H ) ) ); Image aImgObjectsH=Image( BitmapEx( SdResId( BMP_OBJECTS_H ) ) ); // document name already inserted // only insert all "normal" ? slides with objects sal_uInt16 nPage = 0; const sal_uInt16 nMaxPages = mpBookmarkDoc->GetPageCount(); while( nPage < nMaxPages ) { pPage = (SdPage*) mpBookmarkDoc->GetPage( nPage ); if( pPage->GetPageKind() == PK_STANDARD ) { pPageEntry = InsertEntry( pPage->GetName(), aImgPage, aImgPage, pFileEntry, sal_False, LIST_APPEND, reinterpret_cast< void* >( 1 ) ); SetExpandedEntryBmp( pPageEntry, aImgPageH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pPageEntry, aImgPageH, BMP_COLOR_HIGHCONTRAST ); SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS ); while( aIter.IsMore() ) { pObj = aIter.Next(); String aStr( GetObjectName( pObj ) ); if( aStr.Len() ) { if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_OLE2 ) { SvLBoxEntry* pNewEntry = InsertEntry(aStr, maImgOle, maImgOle, pPageEntry); SetExpandedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST ); } else if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_GRAF ) { SvLBoxEntry* pNewEntry = InsertEntry(aStr, maImgGraphic, maImgGraphic, pPageEntry); SetExpandedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST ); } else { SvLBoxEntry* pNewEntry = InsertEntry(aStr, aImgObjects, aImgObjects, pPageEntry); SetExpandedEntryBmp( pNewEntry, aImgObjectsH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pNewEntry, aImgObjectsH, BMP_COLOR_HIGHCONTRAST ); } } } if( pPageEntry->HasChilds() ) { SetExpandedEntryBmp( pPageEntry, aImgPageObjs ); SetCollapsedEntryBmp( pPageEntry, aImgPageObjs ); SetExpandedEntryBmp( pPageEntry, aImgPageObjsH, BMP_COLOR_HIGHCONTRAST ); SetCollapsedEntryBmp( pPageEntry, aImgPageObjsH, BMP_COLOR_HIGHCONTRAST ); } } nPage++; } } } else SvTreeListBox::RequestingChilds( pFileEntry ); } /************************************************************************* |* |* Prueft, ob es sich um eine Draw-Datei handelt und oeffnet anhand des |* uebergebenen Docs das BookmarkDoc |* \************************************************************************/ SdDrawDocument* SdPageObjsTLB::GetBookmarkDoc(SfxMedium* pMed) { if ( !mpBookmarkDoc || (pMed && (!mpOwnMedium || mpOwnMedium->GetName() != pMed->GetName())) ) { // create a new BookmarkDoc if now one exists or if a new Medium is provided if (mpOwnMedium != pMed) { CloseBookmarkDoc(); } if (pMed) { // it looks that it is undefined if a Medium was set by Fill() allready DBG_ASSERT( !mpMedium, "SfxMedium confusion!" ); delete mpMedium; mpMedium = NULL; // take over this Medium (currently used only be Navigator) mpOwnMedium = pMed; } DBG_ASSERT( mpMedium || pMed, "No SfxMedium provided!" ); if( pMed ) { // in this mode the document is also owned and controlled by this instance mxBookmarkDocShRef = new ::sd::DrawDocShell(SFX_CREATE_MODE_STANDARD, sal_True); if (mxBookmarkDocShRef->DoLoad(pMed)) mpBookmarkDoc = mxBookmarkDocShRef->GetDoc(); else mpBookmarkDoc = NULL; } else if ( mpMedium ) // in this mode the document is owned and controlled by the SdDrawDocument // it can be released by calling the corresponding CloseBookmarkDoc method // successfull creation of a document makes this the owner of the medium mpBookmarkDoc = ((SdDrawDocument*) mpDoc)->OpenBookmarkDoc(*mpMedium); if ( !mpBookmarkDoc ) { ErrorBox aErrorBox( this, WB_OK, String( SdResId( STR_READ_DATA_ERROR ) ) ); aErrorBox.Execute(); mpMedium = 0; //On failure the SfxMedium is invalid } } return( mpBookmarkDoc ); } /************************************************************************* |* |* Bookmark-Dokument schlieáen und loeschen |* \************************************************************************/ void SdPageObjsTLB::CloseBookmarkDoc() { if (mxBookmarkDocShRef.Is()) { mxBookmarkDocShRef->DoClose(); mxBookmarkDocShRef.Clear(); // Medium is owned by document, so it's destroyed already mpOwnMedium = 0; } else if ( mpBookmarkDoc ) { DBG_ASSERT( !mpOwnMedium, "SfxMedium confusion!" ); if ( mpDoc ) { // The document owns the Medium, so the Medium will be invalid after closing the document ((SdDrawDocument*) mpDoc)->CloseBookmarkDoc(); mpMedium = 0; } } else { // perhaps mpOwnMedium provided, but no successfull creation of BookmarkDoc delete mpOwnMedium; mpOwnMedium = NULL; } mpBookmarkDoc = NULL; } /************************************************************************* |* |* |* \************************************************************************/ void SdPageObjsTLB::SelectHdl() { SvLBoxEntry* pEntry = FirstSelected(); mbLinkableSelected = sal_True; while( pEntry && mbLinkableSelected ) { if( NULL == pEntry->GetUserData() ) mbLinkableSelected = sal_False; pEntry = NextSelected( pEntry ); } SvTreeListBox::SelectHdl(); } /************************************************************************* |* |* Ueberlaedt RETURN mit der Funktionsweise von DoubleClick |* \************************************************************************/ void SdPageObjsTLB::KeyInput( const KeyEvent& rKEvt ) { if( rKEvt.GetKeyCode().GetCode() == KEY_RETURN ) { // Auskommentierter Code aus svtools/source/contnr/svimpbox.cxx SvLBoxEntry* pCursor = GetCurEntry(); if( pCursor->HasChilds() || pCursor->HasChildsOnDemand() ) { if( IsExpanded( pCursor ) ) Collapse( pCursor ); else Expand( pCursor ); } DoubleClickHdl(); } else SvTreeListBox::KeyInput( rKEvt ); } /************************************************************************* |* |* StartDrag-Request |* \************************************************************************/ void SdPageObjsTLB::StartDrag( sal_Int8 nAction, const Point& rPosPixel) { (void)nAction; (void)rPosPixel; SdNavigatorWin* pNavWin = NULL; SvLBoxEntry* pEntry = GetEntry(rPosPixel); if( mpFrame->HasChildWindow( SID_NAVIGATOR ) ) pNavWin = (SdNavigatorWin*) ( mpFrame->GetChildWindow( SID_NAVIGATOR )->GetContextWindow( SD_MOD() ) ); if (pEntry != NULL && pNavWin !=NULL && pNavWin == mpParent && pNavWin->GetNavigatorDragType() != NAVIGATOR_DRAGTYPE_NONE ) { // Mark only the children of the page under the mouse as drop // targets. This prevents moving shapes from one page to another. // Select all entries and disable them as drop targets. SetSelectionMode(MULTIPLE_SELECTION); SetCursor(NULL, sal_False); SelectAll(sal_True, sal_False); EnableSelectionAsDropTarget(sal_False, sal_True); // Enable only the entries as drop targets that are children of the // page under the mouse. SvLBoxEntry* pParent = GetRootLevelParent(pEntry); if (pParent != NULL) { SelectAll(sal_False, sal_False); Select(pParent, sal_True); // for (SvLBoxEntry*pChild=FirstChild(pParent); pChild!=NULL; pChild=NextSibling(pChild)) // Select(pChild, sal_True); EnableSelectionAsDropTarget(sal_True, sal_True);//sal_False); } // Set selection back to the entry under the mouse. SelectAll(sal_False,sal_False); SetSelectionMode(SINGLE_SELECTION); Select(pEntry, sal_True); // Aus dem ExecuteDrag heraus kann der Navigator geloescht werden // (beim Umschalten auf einen anderen Dokument-Typ), das wuerde aber // den StarView MouseMove-Handler, der Command() aufruft, umbringen. // Deshalb Drag&Drop asynchron: Application::PostUserEvent( STATIC_LINK( this, SdPageObjsTLB, ExecDragHdl ) ); } } /************************************************************************* |* |* Begin drag |* \************************************************************************/ void SdPageObjsTLB::DoDrag() { mpDropNavWin = ( mpFrame->HasChildWindow( SID_NAVIGATOR ) ) ? (SdNavigatorWin*)( mpFrame->GetChildWindow( SID_NAVIGATOR )->GetContextWindow( SD_MOD() ) ) : NULL; if( mpDropNavWin ) { ::sd::DrawDocShell* pDocShell = mpDoc->GetDocSh(); String aURL = INetURLObject( pDocShell->GetMedium()->GetPhysicalName(), INET_PROT_FILE ).GetMainURL( INetURLObject::NO_DECODE ); NavigatorDragType eDragType = mpDropNavWin->GetNavigatorDragType(); aURL.Append( '#' ); aURL.Append( GetSelectEntry() ); INetBookmark aBookmark( aURL, GetSelectEntry() ); sal_Int8 nDNDActions = DND_ACTION_COPYMOVE; if( eDragType == NAVIGATOR_DRAGTYPE_LINK ) nDNDActions = DND_ACTION_LINK; // #93240# Either COPY *or* LINK, never both! else if (mpDoc->GetSdPageCount(PK_STANDARD) == 1) { // Can not move away the last slide in a document. nDNDActions = DND_ACTION_COPY; } SvTreeListBox::ReleaseMouse(); bIsInDrag = sal_True; SvLBoxDDInfo aDDInfo; memset(&aDDInfo,0,sizeof(SvLBoxDDInfo)); aDDInfo.pApp = GetpApp(); aDDInfo.pSource = this; // aDDInfo.pDDStartEntry = pEntry; ::com::sun::star::uno::Sequence aSequence (sizeof(SvLBoxDDInfo)); memcpy(aSequence.getArray(), (sal_Char*)&aDDInfo, sizeof(SvLBoxDDInfo)); ::com::sun::star::uno::Any aTreeListBoxData (aSequence); // object is destroyed by internal reference mechanism SdTransferable* pTransferable = new SdPageObjsTLB::SdPageObjsTransferable( *this, aBookmark, *pDocShell, eDragType, aTreeListBoxData); // Get the view. ::sd::ViewShell* pViewShell = GetViewShellForDocShell(*pDocShell); if (pViewShell == NULL) { OSL_ASSERT(pViewShell!=NULL); return; } sd::View* pView = pViewShell->GetView(); if (pView == NULL) { OSL_ASSERT(pView!=NULL); return; } SdrObject* pObject = NULL; void* pUserData = GetCurEntry()->GetUserData(); if (pUserData != NULL && pUserData != (void*)1) pObject = reinterpret_cast(pUserData); if (pObject != NULL) { // For shapes without a user supplied name (the automatically // created name does not count), a different drag and drop technique // is used. if (GetObjectName(pObject, false).Len() == 0) { AddShapeToTransferable(*pTransferable, *pObject); pTransferable->SetView(pView); SD_MOD()->pTransferDrag = pTransferable; } // Unnamed shapes have to be selected to be recognized by the // current drop implementation. In order to have a consistent // behaviour for all shapes, every shape that is to be dragged is // selected first. SdrPageView* pPageView = pView->GetSdrPageView(); pView->UnmarkAllObj(pPageView); pView->MarkObj(pObject, pPageView); } else { pTransferable->SetView(pView); SD_MOD()->pTransferDrag = pTransferable; } pTransferable->StartDrag( this, nDNDActions ); } } /************************************************************************* |* |* Drag finished |* \************************************************************************/ void SdPageObjsTLB::OnDragFinished( sal_uInt8 ) { if( mpFrame->HasChildWindow( SID_NAVIGATOR ) ) { SdNavigatorWin* pNewNavWin = (SdNavigatorWin*) ( mpFrame->GetChildWindow( SID_NAVIGATOR )->GetContextWindow( SD_MOD() ) ); if( mpDropNavWin == pNewNavWin) { MouseEvent aMEvt( mpDropNavWin->GetPointerPosPixel() ); SvTreeListBox::MouseButtonUp( aMEvt ); } } mpDropNavWin = NULL; bIsInDrag = sal_False; } /************************************************************************* |* |* AcceptDrop-Event |* \************************************************************************/ sal_Int8 SdPageObjsTLB::AcceptDrop (const AcceptDropEvent& rEvent) { sal_Int8 nResult (DND_ACTION_NONE); if ( !bIsInDrag && IsDropFormatSupported( FORMAT_FILE ) ) { nResult = rEvent.mnAction; } else { SvLBoxEntry* pEntry = GetDropTarget(rEvent.maPosPixel); if (rEvent.mbLeaving || !CheckDragAndDropMode( this, rEvent.mnAction )) { ImplShowTargetEmphasis( pTargetEntry, sal_False ); } else if( !nDragDropMode ) { DBG_ERRORFILE( "SdPageObjsTLB::AcceptDrop(): no target" ); } else if (IsDropAllowed(pEntry)) { nResult = DND_ACTION_MOVE; // Draw emphasis. if (pEntry != pTargetEntry || !(nImpFlags & SVLBOX_TARGEMPH_VIS)) { ImplShowTargetEmphasis( pTargetEntry, sal_False ); pTargetEntry = pEntry; ImplShowTargetEmphasis( pTargetEntry, sal_True ); } } } // Hide emphasis when there is no valid drop action. if (nResult == DND_ACTION_NONE) ImplShowTargetEmphasis(pTargetEntry, sal_False); return nResult; } /************************************************************************* |* |* ExecuteDrop-Event |* \************************************************************************/ sal_Int8 SdPageObjsTLB::ExecuteDrop( const ExecuteDropEvent& rEvt ) { sal_Int8 nRet = DND_ACTION_NONE; try { if( !bIsInDrag ) { SdNavigatorWin* pNavWin = NULL; sal_uInt16 nId = SID_NAVIGATOR; if( mpFrame->HasChildWindow( nId ) ) pNavWin = (SdNavigatorWin*)( mpFrame->GetChildWindow( nId )->GetContextWindow( SD_MOD() ) ); if( pNavWin && ( pNavWin == mpParent ) ) { TransferableDataHelper aDataHelper( rEvt.maDropEvent.Transferable ); String aFile; if( aDataHelper.GetString( FORMAT_FILE, aFile ) && ( (SdNavigatorWin*) mpParent)->InsertFile( aFile ) ) { nRet = rEvt.mnAction; } } } } catch (com::sun::star::uno::Exception&) { DBG_UNHANDLED_EXCEPTION(); } if (nRet == DND_ACTION_NONE) SvTreeListBox::ExecuteDrop(rEvt, this); return nRet; } /************************************************************************* |* |* Handler fuers Dragging |* \************************************************************************/ IMPL_STATIC_LINK(SdPageObjsTLB, ExecDragHdl, void*, EMPTYARG) { // als Link, damit asynchron ohne ImpMouseMoveMsg auf dem Stack auch der // Navigator geloescht werden darf pThis->DoDrag(); return 0; } bool SdPageObjsTLB::PageBelongsToCurrentShow (const SdPage* pPage) const { // Return as default when there is no custom show or when none // is used. The page does then belong to the standard show. bool bBelongsToShow = true; if (mpDoc->getPresentationSettings().mbCustomShow) { // Get the current custom show. SdCustomShow* pCustomShow = NULL; List* pShowList = const_cast(mpDoc)->GetCustomShowList(); if (pShowList != NULL) { sal_uLong nCurrentShowIndex = pShowList->GetCurPos(); void* pObject = pShowList->GetObject(nCurrentShowIndex); pCustomShow = static_cast(pObject); } // Check whether the given page is part of that custom show. if (pCustomShow != NULL) { bBelongsToShow = false; sal_uLong nPageCount = pCustomShow->Count(); for (sal_uInt16 i=0; i(pCustomShow->GetObject (i))) bBelongsToShow = true; } } return bBelongsToShow; } sal_Bool SdPageObjsTLB::NotifyMoving( SvLBoxEntry* pTarget, SvLBoxEntry* pEntry, SvLBoxEntry*& rpNewParent, sal_uLong& rNewChildPos) { SvLBoxEntry* pDestination = pTarget; while (GetParent(pDestination) != NULL && GetParent(GetParent(pDestination)) != NULL) pDestination = GetParent(pDestination); SdrObject* pTargetObject = reinterpret_cast(pDestination->GetUserData()); SdrObject* pSourceObject = reinterpret_cast(pEntry->GetUserData()); if (pSourceObject == reinterpret_cast(1)) pSourceObject = NULL; if (pTargetObject != NULL && pSourceObject != NULL) { SdrPage* pObjectList = pSourceObject->GetPage(); if (pObjectList != NULL) { sal_uInt32 nNewPosition; if (pTargetObject == reinterpret_cast(1)) nNewPosition = 0; else nNewPosition = pTargetObject->GetNavigationPosition() + 1; pObjectList->SetObjectNavigationPosition(*pSourceObject, nNewPosition); } // Update the tree list. if (pTarget == NULL) { rpNewParent = 0; rNewChildPos = 0; return sal_True; } else if (GetParent(pDestination) == NULL) { rpNewParent = pDestination; rNewChildPos = 0; } else { rpNewParent = GetParent(pDestination); rNewChildPos = pModel->GetRelPos(pDestination) + 1; rNewChildPos += nCurEntrySelPos; nCurEntrySelPos++; } return sal_True; } else return sal_False; } SvLBoxEntry* SdPageObjsTLB::GetDropTarget (const Point& rLocation) { SvLBoxEntry* pEntry = SvTreeListBox::GetDropTarget(rLocation); if (pEntry == NULL) return NULL; if (GetParent(pEntry) == NULL) { // Use page entry as insertion position. } else { // Go to second hierarchy level, i.e. top level shapes, // i.e. children of pages. while (GetParent(pEntry) != NULL && GetParent(GetParent(pEntry)) != NULL) pEntry = GetParent(pEntry); // Advance to next sibling. SvLBoxEntry* pNext; sal_uInt16 nDepth (0); while (pEntry != NULL) { pNext = dynamic_cast(NextVisible(pEntry, &nDepth)); if (pNext != NULL && nDepth > 0 && nDepth!=0xffff) pEntry = pNext; else break; } } return pEntry; } bool SdPageObjsTLB::IsDropAllowed (SvLBoxEntry* pEntry) { if (pEntry == NULL) return false; if ( ! IsDropFormatSupported(SdPageObjsTransferable::GetListBoxDropFormatId())) return false; if ((pEntry->GetFlags() & SV_ENTRYFLAG_DISABLE_DROP) != 0) return false; return true; } void SdPageObjsTLB::AddShapeToTransferable ( SdTransferable& rTransferable, SdrObject& rObject) const { TransferableObjectDescriptor aObjectDescriptor; bool bIsDescriptorFillingPending (true); const SdrOle2Obj* pOleObject = dynamic_cast(&rObject); if (pOleObject != NULL && pOleObject->GetObjRef().is()) { // If object has no persistence it must be copied as part of the document try { uno::Reference< embed::XEmbedPersist > xPersObj (pOleObject->GetObjRef(), uno::UNO_QUERY ); if (xPersObj.is() && xPersObj->hasEntry()) { SvEmbedTransferHelper::FillTransferableObjectDescriptor( aObjectDescriptor, pOleObject->GetObjRef(), pOleObject->GetGraphic(), pOleObject->GetAspect()); bIsDescriptorFillingPending = false; } } catch( uno::Exception& ) { } } ::sd::DrawDocShell* pDocShell = mpDoc->GetDocSh(); if (bIsDescriptorFillingPending && pDocShell!=NULL) { bIsDescriptorFillingPending = false; pDocShell->FillTransferableObjectDescriptor(aObjectDescriptor); } Point aDragPos (rObject.GetCurrentBoundRect().Center()); //Point aDragPos (0,0); aObjectDescriptor.maDragStartPos = aDragPos; // aObjectDescriptor.maSize = GetAllMarkedRect().GetSize(); if (pDocShell != NULL) aObjectDescriptor.maDisplayName = pDocShell->GetMedium()->GetURLObject().GetURLNoPass(); else aObjectDescriptor.maDisplayName = String(); aObjectDescriptor.mbCanLink = sal_False; rTransferable.SetStartPos(aDragPos); rTransferable.SetObjectDescriptor( aObjectDescriptor ); } ::sd::ViewShell* SdPageObjsTLB::GetViewShellForDocShell (::sd::DrawDocShell& rDocShell) { { ::sd::ViewShell* pViewShell = rDocShell.GetViewShell(); if (pViewShell != NULL) return pViewShell; } try { // Get a component enumeration from the desktop and search it for documents. uno::Reference xFactory ( ::comphelper::getProcessServiceFactory ()); if ( ! xFactory.is()) return NULL; uno::Reference xDesktop (xFactory->createInstance ( ::rtl::OUString::createFromAscii("com.sun.star.frame.Desktop")), uno::UNO_QUERY); if ( ! xDesktop.is()) return NULL; uno::Reference xFrameSupplier (xDesktop, uno::UNO_QUERY); if ( ! xFrameSupplier.is()) return NULL; uno::Reference xFrameAccess (xFrameSupplier->getFrames(), uno::UNO_QUERY); if ( ! xFrameAccess.is()) return NULL; for (sal_Int32 nIndex=0,nCount=xFrameAccess->getCount(); nIndex xFrame; if ( ! (xFrameAccess->getByIndex(nIndex) >>= xFrame)) continue; ::sd::DrawController* pController = dynamic_cast(xFrame->getController().get()); if (pController == NULL) continue; ::sd::ViewShellBase* pBase = pController->GetViewShellBase(); if (pBase == NULL) continue; if (pBase->GetDocShell() != &rDocShell) continue; const ::boost::shared_ptr pViewShell (pBase->GetMainViewShell()); if (pViewShell) return pViewShell.get(); } } catch (uno::Exception e) { // When there is an exception then simply use the default value of // bIsEnabled and disable the controls. } return NULL; } //===== IconProvider ========================================================== SdPageObjsTLB::IconProvider::IconProvider (void) : maImgPage( BitmapEx( SdResId( BMP_PAGE ) ) ), maImgPageExcl( BitmapEx( SdResId( BMP_PAGE_EXCLUDED ) ) ), maImgPageObjsExcl( BitmapEx( SdResId( BMP_PAGEOBJS_EXCLUDED ) ) ), maImgPageObjs( BitmapEx( SdResId( BMP_PAGEOBJS ) ) ), maImgObjects( BitmapEx( SdResId( BMP_OBJECTS ) ) ), maImgGroup( BitmapEx( SdResId( BMP_GROUP ) ) ), maImgPageH( BitmapEx( SdResId( BMP_PAGE_H ) ) ), maImgPageExclH( BitmapEx( SdResId( BMP_PAGE_EXCLUDED_H ) ) ), maImgPageObjsExclH( BitmapEx( SdResId( BMP_PAGEOBJS_EXCLUDED_H ) ) ), maImgPageObjsH( BitmapEx( SdResId( BMP_PAGEOBJS_H ) ) ), maImgObjectsH( BitmapEx( SdResId( BMP_OBJECTS_H ) ) ), maImgGroupH( BitmapEx( SdResId( BMP_GROUP_H ) ) ) { }