sd/source/ui/dlg/sdtreelb.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: sdtreelb.cxx,v $
  10  * $Revision: 1.32 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include <sal/types.h>
  35 #include <sot/formats.hxx>
  36 #include <sot/storage.hxx>
  37 #include <vcl/msgbox.hxx>
  38 #include <svtools/urihelper.hxx>
  39 #include <svx/svditer.hxx>
  40 #include <sfx2/docfile.hxx>
  41 #include <svx/svdoole2.hxx>
  42 #include <vcl/svapp.hxx>
  43 #include "cusshow.hxx"
  44 #include <sfx2/childwin.hxx>
  45
  46 #include <sfx2/viewfrm.hxx>
  47
  48 #include "strmname.h"
  49 #include "sdtreelb.hxx"
  50 #include "DrawDocShell.hxx"
  51 #include "drawdoc.hxx"
  52 #include "sdpage.hxx"
  53 #include "sdresid.hxx"
  54 #include "navigatr.hxx"
  55 #ifndef _SD_CFGID_HXX
  56 #include "strings.hrc"
  57 #endif
  58 #include "res_bmp.hrc"
  59
  60 #include <com/sun/star/embed/XEmbedPersist.hpp>
  61 #include <svtools/embedtransfer.hxx>
  62 #include <ViewShell.hxx>
  63
  64 using namespace com::sun::star;
  65
  66 class SdPageObjsTLB::IconProvider
  67 {
  68 public:
  69     IconProvider (void);
  70
  71     // Regular icons.
  72     Image maImgPage;
  73     Image maImgPageExcl;
  74     Image maImgPageObjsExcl;
  75     Image maImgPageObjs;
  76     Image maImgObjects;
  77     Image maImgGroup;
  78
  79     // High contrast icons.
  80     Image maImgPageH;
  81     Image maImgPageExclH;
  82     Image maImgPageObjsExclH;
  83     Image maImgPageObjsH;
  84     Image maImgObjectsH;
  85     Image maImgGroupH;
  86 };
  87
  88
  89 BOOL SD_DLLPRIVATE SdPageObjsTLB::bIsInDrag = FALSE;
  90
  91 BOOL SdPageObjsTLB::IsInDrag()
  92 {
  93     return bIsInDrag;
  94 }
  95
  96 sal_uInt32 SdPageObjsTLB::SdPageObjsTransferable::mnListBoxDropFormatId = SAL_MAX_UINT32;
  97
  98 // -----------------------------------------
  99 // - SdPageObjsTLB::SdPageObjsTransferable -
 100 // -----------------------------------------
 101
 102 SdPageObjsTLB::SdPageObjsTransferable::SdPageObjsTransferable(
 103     SdPageObjsTLB& rParent,
 104         const INetBookmark& rBookmark,
 105     ::sd::DrawDocShell& rDocShell,
 106     NavigatorDragType eDragType,
 107     const ::com::sun::star::uno::Any& rTreeListBoxData )
 108     : SdTransferable(rDocShell.GetDoc(), NULL, TRUE),
 109       mrParent( rParent ),
 110       maBookmark( rBookmark ),
 111       mrDocShell( rDocShell ),
 112       meDragType( eDragType ),
 113       maTreeListBoxData( rTreeListBoxData )
 114 {
 115 }
 116
 117
 118
 119
 120 SdPageObjsTLB::SdPageObjsTransferable::~SdPageObjsTransferable()
 121 {
 122 }
 123
 124 // -----------------------------------------------------------------------------
 125
 126 void SdPageObjsTLB::SdPageObjsTransferable::AddSupportedFormats()
 127 {
 128     AddFormat(SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK);
 129     AddFormat(SOT_FORMATSTR_ID_TREELISTBOX);
 130     AddFormat(GetListBoxDropFormatId());
 131 }
 132
 133 // -----------------------------------------------------------------------------
 134
 135 sal_Bool SdPageObjsTLB::SdPageObjsTransferable::GetData( const ::com::sun::star::datatransfer::DataFlavor& rFlavor )
 136 {
 137     ULONG nFormatId = SotExchange::GetFormat( rFlavor );
 138     switch (nFormatId)
 139     {
 140         case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK:
 141             SetINetBookmark( maBookmark, rFlavor );
 142             return sal_True;
 143
 144         case SOT_FORMATSTR_ID_TREELISTBOX:
 145             SetAny(maTreeListBoxData, rFlavor);
 146             return sal_True;
 147
 148         default:
 149             return sal_False;
 150     }
 151 }
 152
 153 // -----------------------------------------------------------------------------
 154
 155 void SdPageObjsTLB::SdPageObjsTransferable::DragFinished( sal_Int8 nDropAction )
 156 {
 157     mrParent.OnDragFinished( nDropAction );
 158 }
 159
 160 // -----------------------------------------------------------------------------
 161
 162 ::sd::DrawDocShell& SdPageObjsTLB::SdPageObjsTransferable::GetDocShell() const
 163 {
 164     return mrDocShell;
 165 }
 166
 167 // -----------------------------------------------------------------------------
 168
 169 NavigatorDragType SdPageObjsTLB::SdPageObjsTransferable::GetDragType() const
 170 {
 171     return meDragType;
 172 }
 173
 174 // -----------------------------------------------------------------------------
 175
 176 sal_Int64 SAL_CALL SdPageObjsTLB::SdPageObjsTransferable::getSomething( const ::com::sun::star::uno::Sequence< sal_Int8 >& rId ) throw( ::com::sun::star::uno::RuntimeException )
 177 {
 178     sal_Int64 nRet;
 179
 180     if( ( rId.getLength() == 16 ) &&
 181         ( 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 182     {
 183         nRet = (sal_Int64)(sal_IntPtr)this;
 184     }
 185     else
 186         nRet = SdTransferable::getSomething(rId);
 187
 188     return nRet;
 189 }
 190
 191 // -----------------------------------------------------------------------------
 192
 193 const ::com::sun::star::uno::Sequence< sal_Int8 >& SdPageObjsTLB::SdPageObjsTransferable::getUnoTunnelId()
 194 {
 195     static ::com::sun::star::uno::Sequence< sal_Int8 > aSeq;
 196
 197     if( !aSeq.getLength() )
 198     {
 199         static osl::Mutex   aCreateMutex;
 200         osl::MutexGuard     aGuard( aCreateMutex );
 201
 202         aSeq.realloc( 16 );
 203         rtl_createUuid( reinterpret_cast< sal_uInt8* >( aSeq.getArray() ), 0, sal_True );
 204     }
 205
 206     return aSeq;
 207 }
 208
 209 // -----------------------------------------------------------------------------
 210
 211 SdPageObjsTLB::SdPageObjsTransferable* SdPageObjsTLB::SdPageObjsTransferable::getImplementation( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& rxData )
 212     throw()
 213 {
 214     try
 215     {
 216         ::com::sun::star::uno::Reference< ::com::sun::star::lang::XUnoTunnel > xUnoTunnel( rxData, ::com::sun::star::uno::UNO_QUERY_THROW );
 217
 218         return reinterpret_cast<SdPageObjsTLB::SdPageObjsTransferable*>(
 219                 sal::static_int_cast<sal_uIntPtr>(
 220                     xUnoTunnel->getSomething( SdPageObjsTLB::SdPageObjsTransferable::getUnoTunnelId()) ) );
 221     }
 222     catch( const ::com::sun::star::uno::Exception& )
 223     {
 224     }
 225     return 0;
 226 }
 227
 228
 229 sal_uInt32 SdPageObjsTLB::SdPageObjsTransferable::GetListBoxDropFormatId (void)
 230 {
 231     if (mnListBoxDropFormatId == SAL_MAX_UINT32)
 232         mnListBoxDropFormatId = SotExchange::RegisterFormatMimeType(
 233             ::rtl::OUString::createFromAscii(
 234                 "application/x-openoffice-treelistbox-moveonly;"
 235                     "windows_formatname=\"SV_LBOX_DD_FORMAT_MOVE\""));
 236     return mnListBoxDropFormatId;
 237 }
 238
 239 /*************************************************************************
 240 |*
 241 |* Ctor1 SdPageObjsTLB
 242 |*
 243 \************************************************************************/
 244
 245 SdPageObjsTLB::SdPageObjsTLB( Window* pParentWin, const SdResId& rSdResId )
 246 :       SvTreeListBox       ( pParentWin, rSdResId )
 247 ,       mpParent                    ( pParentWin )
 248 ,       mpDoc                       ( NULL )
 249 ,       mpBookmarkDoc       ( NULL )
 250 ,       mpMedium                ( NULL )
 251 ,       mpOwnMedium                 ( NULL )
 252 ,       maImgOle             ( BitmapEx( SdResId( BMP_OLE ) ) )
 253 ,       maImgGraphic         ( BitmapEx( SdResId( BMP_GRAPHIC ) ) )
 254 ,       maImgOleH            ( BitmapEx( SdResId( BMP_OLE_H ) ) )
 255 ,       maImgGraphicH        ( BitmapEx( SdResId( BMP_GRAPHIC_H ) ) )
 256 ,       mbLinkableSelected  ( FALSE )
 257 ,       mpDropNavWin            ( NULL )
 258 ,   mbShowAllShapes     ( false )
 259 ,   mbShowAllPages      ( false )
 260
 261 {
 262     // Tree-ListBox mit Linien versehen
 263     SetWindowBits( WinBits( WB_TABSTOP | WB_BORDER | WB_HASLINES |
 264                             WB_HASBUTTONS | // WB_HASLINESATROOT |
 265                             WB_HSCROLL | // #31562#
 266                             WB_HASBUTTONSATROOT ) );
 267     SetNodeBitmaps( Bitmap( SdResId( BMP_EXPAND ) ),
 268                     Bitmap( SdResId( BMP_COLLAPSE ) ) );
 269
 270     SetNodeBitmaps( Bitmap( SdResId( BMP_EXPAND_H ) ),
 271                     Bitmap( SdResId( BMP_COLLAPSE_H ) ),
 272                     BMP_COLOR_HIGHCONTRAST );
 273
 274     SetDragDropMode(
 275          SV_DRAGDROP_CTRL_MOVE | SV_DRAGDROP_CTRL_COPY |
 276             SV_DRAGDROP_APP_MOVE  | SV_DRAGDROP_APP_COPY  | SV_DRAGDROP_APP_DROP );
 277 }
 278
 279 /*************************************************************************
 280 |*
 281 |* Dtor SdPageObjsTLB
 282 |*
 283 \************************************************************************/
 284
 285 SdPageObjsTLB::~SdPageObjsTLB()
 286 {
 287     if ( mpBookmarkDoc )
 288         CloseBookmarkDoc();
 289     else
 290         // no document was created from mpMedium, so this object is still the owner of it
 291         delete mpMedium;
 292 }
 293
 294 /*************************************************************************
 295 |*
 296 |* return name of object
 297 |*
 298 \************************************************************************/
 299
 300 String SdPageObjsTLB::GetObjectName(
 301     const SdrObject* pObject,
 302     const bool bCreate) const
 303 {
 304     String aRet;
 305
 306     if ( pObject )
 307     {
 308         aRet = pObject->GetName();
 309
 310         if( !aRet.Len() && pObject->ISA( SdrOle2Obj ) )
 311             aRet = static_cast< const SdrOle2Obj* >( pObject )->GetPersistName();
 312     }
 313
 314     if (bCreate
 315         && mbShowAllShapes
 316         && aRet.Len() == 0
 317         && pObject!=NULL)
 318     {
 319         aRet = SdResId(STR_NAVIGATOR_SHAPE_BASE_NAME);
 320         aRet.SearchAndReplaceAscii("%1", String::CreateFromInt32(pObject->GetOrdNum() + 1));
 321     }
 322
 323     return aRet;
 324 }
 325
 326 /*************************************************************************
 327 |*
 328 |* In TreeLB Eintrag selektieren
 329 |*
 330 \************************************************************************/
 331
 332 BOOL SdPageObjsTLB::SelectEntry( const String& rName )
 333 {
 334     BOOL bFound = FALSE;
 335
 336     if( rName.Len() )
 337     {
 338         SvLBoxEntry* pEntry = NULL;
 339         String aTmp;
 340
 341         for( pEntry = First(); pEntry && !bFound; pEntry = Next( pEntry ) )
 342         {
 343             aTmp = GetEntryText( pEntry );
 344             if( aTmp == rName )
 345             {
 346                 bFound = TRUE;
 347                 SetCurEntry( pEntry );
 348             }
 349         }
 350     }
 351     return( bFound );
 352 }
 353
 354 /*************************************************************************
 355 |*
 356 |* Gibt zurueck, ob Childs des uebergebenen Strings selektiert sind
 357 |*
 358 \************************************************************************/
 359
 360 BOOL SdPageObjsTLB::HasSelectedChilds( const String& rName )
 361 {
 362     BOOL bFound  = FALSE;
 363     BOOL bChilds = FALSE;
 364
 365     if( rName.Len() )
 366     {
 367         SvLBoxEntry* pEntry = NULL;
 368         String aTmp;
 369
 370         for( pEntry = First(); pEntry && !bFound; pEntry = Next( pEntry ) )
 371         {
 372             aTmp = GetEntryText( pEntry );
 373             if( aTmp == rName )
 374             {
 375                 bFound = TRUE;
 376                 BOOL bExpanded = IsExpanded( pEntry );
 377                 long nCount = GetChildSelectionCount( pEntry );
 378                 if( bExpanded && nCount > 0 )
 379                     bChilds = TRUE;
 380             }
 381         }
 382     }
 383     return( bChilds );
 384 }
 385
 386
 387 /*************************************************************************
 388 |*
 389 |* TreeLB mit Seiten und Objekten fuellen
 390 |*
 391 \************************************************************************/
 392
 393 void SdPageObjsTLB::Fill( const SdDrawDocument* pInDoc, BOOL bAllPages,
 394                           const String& rDocName)
 395 {
 396     String aSelection;
 397     if( GetSelectionCount() > 0 )
 398     {
 399         aSelection = GetSelectEntry();
 400         Clear();
 401     }
 402
 403     mpDoc = pInDoc;
 404     maDocName = rDocName;
 405     mbShowAllPages = (bAllPages == TRUE);
 406     mpMedium = NULL;
 407
 408     SdPage*      pPage = NULL;
 409
 410     IconProvider aIconProvider;
 411
 412     // first insert all pages including objects
 413     USHORT nPage = 0;
 414     const USHORT nMaxPages = mpDoc->GetPageCount();
 415
 416     while( nPage < nMaxPages )
 417     {
 418         pPage = (SdPage*) mpDoc->GetPage( nPage );
 419         if(  (mbShowAllPages || pPage->GetPageKind() == PK_STANDARD)
 420              && !(pPage->GetPageKind()==PK_HANDOUT)   ) //#94954# never list the normal handout page ( handout-masterpage is used instead )
 421         {
 422             BOOL bPageExluded = pPage->IsExcluded();
 423
 424             bool bPageBelongsToShow = PageBelongsToCurrentShow (pPage);
 425             bPageExluded |= !bPageBelongsToShow;
 426
 427             AddShapeList(*pPage, NULL, pPage->GetName(), bPageExluded, NULL, aIconProvider);
 428         }
 429         nPage++;
 430     }
 431
 432     // dann alle MasterPages incl. Objekte einfuegen
 433     if( mbShowAllPages )
 434     {
 435         nPage = 0;
 436         const USHORT nMaxMasterPages = mpDoc->GetMasterPageCount();
 437
 438         while( nPage < nMaxMasterPages )
 439         {
 440             pPage = (SdPage*) mpDoc->GetMasterPage( nPage );
 441             AddShapeList(*pPage, NULL, pPage->GetName(), false, NULL, aIconProvider);
 442             nPage++;
 443         }
 444     }
 445     if( aSelection.Len() )
 446         SelectEntry( aSelection );
 447 }
 448
 449 /*************************************************************************
 450 |*
 451 |* Es wird nur der erste Eintrag eingefuegt. Childs werden OnDemand erzeugt
 452 |*
 453 \************************************************************************/
 454
 455 void SdPageObjsTLB::Fill( const SdDrawDocument* pInDoc, SfxMedium* pInMedium,
 456                           const String& rDocName )
 457 {
 458     mpDoc = pInDoc;
 459
 460     // this object now owns the Medium
 461     mpMedium = pInMedium;
 462     maDocName = rDocName;
 463
 464     Image aImgDocOpen=Image( BitmapEx( SdResId( BMP_DOC_OPEN ) ) );
 465     Image aImgDocClosed=Image( BitmapEx( SdResId( BMP_DOC_CLOSED ) ) );
 466     Image aImgDocOpenH=Image( BitmapEx( SdResId( BMP_DOC_OPEN_H ) ) );
 467     Image aImgDocClosedH=Image( BitmapEx( SdResId( BMP_DOC_CLOSED_H ) ) );
 468
 469     // Dokumentnamen einfuegen
 470     SvLBoxEntry* pFileEntry = InsertEntry( maDocName,
 471                               aImgDocOpen,
 472                               aImgDocClosed,
 473                               NULL,
 474                               TRUE,
 475                               LIST_APPEND,
 476                               reinterpret_cast< void* >( 1 ) );
 477
 478     SetExpandedEntryBmp( pFileEntry, aImgDocOpenH, BMP_COLOR_HIGHCONTRAST );
 479     SetCollapsedEntryBmp( pFileEntry, aImgDocClosedH, BMP_COLOR_HIGHCONTRAST );
 480 }
 481
 482
 483
 484
 485 void SdPageObjsTLB::AddShapeList (
 486     const SdrObjList& rList,
 487     SdrObject* pShape,
 488     const ::rtl::OUString& rsName,
 489     const bool bIsExcluded,
 490     SvLBoxEntry* pParentEntry,
 491     const IconProvider& rIconProvider)
 492 {
 493     Image aIcon (rIconProvider.maImgPage);
 494     if (bIsExcluded)
 495         aIcon = rIconProvider.maImgPageExcl;
 496     else if (pShape != NULL)
 497         aIcon = rIconProvider.maImgGroup;
 498
 499     void* pUserData (reinterpret_cast<void*>(1));
 500     if (pShape != NULL)
 501         pUserData = pShape;
 502
 503     SvLBoxEntry* pEntry = InsertEntry(
 504         rsName,
 505         aIcon,
 506         aIcon,
 507         pParentEntry,
 508         FALSE,
 509         LIST_APPEND,
 510         pUserData);
 511
 512     SetExpandedEntryBmp(
 513         pEntry,
 514         bIsExcluded ? rIconProvider.maImgPageExclH : rIconProvider.maImgPageH,
 515         BMP_COLOR_HIGHCONTRAST );
 516     SetCollapsedEntryBmp(
 517         pEntry,
 518         bIsExcluded ? rIconProvider.maImgPageExclH : rIconProvider.maImgPageH,
 519         BMP_COLOR_HIGHCONTRAST );
 520
 521     SdrObjListIter aIter(
 522         rList,
 523         !rList.HasObjectNavigationOrder() /* use navigation order, if available */,
 524         IM_FLAT,
 525         FALSE /*not reverse*/);
 526
 527     while( aIter.IsMore() )
 528     {
 529         SdrObject* pObj = aIter.Next();
 530         OSL_ASSERT(pObj!=NULL);
 531
 532         // Get the shape name.
 533         String aStr (GetObjectName( pObj ) );
 534
 535         if( aStr.Len() )
 536         {
 537             if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_OLE2 )
 538             {
 539                 SvLBoxEntry* pNewEntry = InsertEntry( aStr, maImgOle, maImgOle, pEntry,
 540                     FALSE, LIST_APPEND, pObj);
 541
 542                 SetExpandedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST );
 543                 SetCollapsedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST );
 544             }
 545             else if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_GRAF )
 546             {
 547                 SvLBoxEntry* pNewEntry = InsertEntry( aStr, maImgGraphic, maImgGraphic, pEntry,
 548                     FALSE, LIST_APPEND, pObj );
 549
 550                 SetExpandedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST );
 551                 SetCollapsedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST );
 552             }
 553             else if (pObj->IsGroupObject())
 554             {
 555                 AddShapeList(
 556                     *pObj->GetSubList(),
 557                     pObj,
 558                     aStr,
 559                     false,
 560                     pEntry,
 561                     rIconProvider);
 562             }
 563             else
 564             {
 565                 SvLBoxEntry* pNewEntry = InsertEntry( aStr, rIconProvider.maImgObjects, rIconProvider.maImgObjects, pEntry,
 566                     FALSE, LIST_APPEND, pObj );
 567
 568                 SetExpandedEntryBmp( pNewEntry, rIconProvider.maImgObjectsH, BMP_COLOR_HIGHCONTRAST );
 569                 SetCollapsedEntryBmp( pNewEntry, rIconProvider.maImgObjectsH, BMP_COLOR_HIGHCONTRAST );
 570             }
 571         }
 572     }
 573
 574     if( pEntry->HasChilds() )
 575     {
 576         SetExpandedEntryBmp(
 577             pEntry,
 578             bIsExcluded ? rIconProvider.maImgPageObjsExcl : rIconProvider.maImgPageObjs);
 579         SetCollapsedEntryBmp(
 580             pEntry,
 581             bIsExcluded ? rIconProvider.maImgPageObjsExcl : rIconProvider.maImgPageObjs);
 582         SetExpandedEntryBmp(
 583             pEntry,
 584             bIsExcluded ? rIconProvider.maImgPageObjsExclH : rIconProvider.maImgPageObjsH,
 585             BMP_COLOR_HIGHCONTRAST);
 586         SetCollapsedEntryBmp(
 587             pEntry,
 588             bIsExcluded ? rIconProvider.maImgPageObjsExclH : rIconProvider.maImgPageObjsH,
 589             BMP_COLOR_HIGHCONTRAST);
 590     }
 591 }
 592
 593
 594
 595
 596 void SdPageObjsTLB::SetShowAllShapes (
 597     const bool bShowAllShapes,
 598     const bool bFillList)
 599 {
 600     mbShowAllShapes = bShowAllShapes;
 601     if (bFillList)
 602     {
 603         if (mpMedium == NULL)
 604             Fill(mpDoc, mbShowAllPages, maDocName);
 605         else
 606             Fill(mpDoc, mpMedium, maDocName);
 607     }
 608 }
 609
 610
 611
 612
 613 bool SdPageObjsTLB::GetShowAllShapes (void) const
 614 {
 615     return mbShowAllShapes;
 616 }
 617
 618
 619
 620
 621 /*************************************************************************
 622 |*
 623 |* Prueft, ob die Seiten (PK_STANDARD) und die darauf befindlichen Objekte
 624 |* des Docs und der TreeLB identisch sind.
 625 |* Wird ein Doc uebergeben, wird dieses zum aktuellem Doc (Wichtig bei
 626 |* mehreren Documenten).
 627 |*
 628 \************************************************************************/
 629
 630 BOOL SdPageObjsTLB::IsEqualToDoc( const SdDrawDocument* pInDoc )
 631 {
 632     if( pInDoc )
 633         mpDoc = pInDoc;
 634
 635     if( !mpDoc )
 636         return( FALSE );
 637
 638     SdrObject*   pObj = NULL;
 639     SdPage*      pPage = NULL;
 640     SvLBoxEntry* pEntry = First();
 641     String               aName;
 642
 643     // Alle Pages incl. Objekte vergleichen
 644     USHORT nPage = 0;
 645     const USHORT nMaxPages = mpDoc->GetPageCount();
 646
 647     while( nPage < nMaxPages )
 648     {
 649         pPage = (SdPage*) mpDoc->GetPage( nPage );
 650         if( pPage->GetPageKind() == PK_STANDARD )
 651         {
 652             if( !pEntry )
 653                 return( FALSE );
 654             aName = GetEntryText( pEntry );
 655
 656             if( pPage->GetName() != aName )
 657                 return( FALSE );
 658
 659             pEntry = Next( pEntry );
 660
 661             SdrObjListIter aIter(
 662                 *pPage,
 663                 !pPage->HasObjectNavigationOrder() /* use navigation order, if available */,
 664                 IM_DEEPWITHGROUPS );
 665
 666             while( aIter.IsMore() )
 667             {
 668                 pObj = aIter.Next();
 669
 670                 const String aObjectName( GetObjectName( pObj ) );
 671
 672                 if( aObjectName.Len() )
 673                 {
 674                     if( !pEntry )
 675                         return( FALSE );
 676
 677                     aName = GetEntryText( pEntry );
 678
 679                     if( aObjectName != aName )
 680                         return( FALSE );
 681
 682                     pEntry = Next( pEntry );
 683                 }
 684             }
 685         }
 686         nPage++;
 687     }
 688     // Wenn noch Eintraege in der Listbox vorhanden sind, wurden
 689     // Objekte (mit Namen) oder Seiten geloescht
 690     return( !pEntry );
 691 }
 692
 693 /*************************************************************************
 694 |*
 695 |* Selectierten String zurueckgeben
 696 |*
 697 \************************************************************************/
 698
 699 String SdPageObjsTLB::GetSelectEntry()
 700 {
 701     return( GetEntryText( GetCurEntry() ) );
 702 }
 703
 704 /*************************************************************************
 705 |*
 706 |* Selektierte Eintrage zurueckgeben
 707 |* nDepth == 0 -> Seiten
 708 |* nDepth == 1 -> Objekte
 709 |*
 710 \************************************************************************/
 711
 712 List* SdPageObjsTLB::GetSelectEntryList( USHORT nDepth )
 713 {
 714     List*                pList  = NULL;
 715     SvLBoxEntry* pEntry = FirstSelected();
 716
 717     while( pEntry )
 718     {
 719         USHORT nListDepth = GetModel()->GetDepth( pEntry );
 720         if( nListDepth == nDepth )
 721         {
 722             if( !pList )
 723                 pList = new List();
 724
 725             const String aEntryText( GetEntryText( pEntry ) );
 726             pList->Insert( new String( aEntryText ), LIST_APPEND );
 727         }
 728         pEntry = NextSelected( pEntry );
 729     }
 730
 731     return( pList );
 732 }
 733
 734 /*************************************************************************
 735 |*
 736 |* Alle Pages (und Objekte) des Docs zurueckgeben
 737 |* nType == 0 -> Seiten
 738 |* nType == 1 -> Objekte
 739 |*
 740 \************************************************************************/
 741
 742 List* SdPageObjsTLB::GetBookmarkList( USHORT nType )
 743 {
 744     List* pList = NULL;
 745
 746     if( GetBookmarkDoc() )
 747     {
 748         SdPage*          pPage = NULL;
 749         String*          pName = NULL;
 750         USHORT           nPage = 0;
 751         const USHORT nMaxPages = mpBookmarkDoc->GetSdPageCount( PK_STANDARD );
 752
 753         while( nPage < nMaxPages )
 754         {
 755             pPage = mpBookmarkDoc->GetSdPage( nPage, PK_STANDARD );
 756
 757             if( nType == 0 ) // Seitennamen einfuegen
 758             {
 759                 if( !pList )
 760                     pList = new List();
 761
 762                 pName = new String( pPage->GetRealName() );
 763                 pList->Insert( pName, LIST_APPEND );
 764             }
 765             else // Objektnamen einfuegen
 766             {
 767                 // Ueber Objekte der Seite iterieren
 768                 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
 769                 while( aIter.IsMore() )
 770                 {
 771                     SdrObject* pObj = aIter.Next();
 772                     String aStr( GetObjectName( pObj ) );
 773                     if( aStr.Len() )
 774                     {
 775                         if( !pList )
 776                             pList = new List();
 777
 778                         pName = new String( aStr );
 779                         pList->Insert( pName, LIST_APPEND );
 780                     }
 781                 }
 782             }
 783             nPage++;
 784         }
 785     }
 786     return( pList );
 787 }
 788
 789 /*************************************************************************
 790 |*
 791 |* Eintraege werden erst auf Anforderung (Doppelklick) eingefuegt
 792 |*
 793 \************************************************************************/
 794
 795 void SdPageObjsTLB::RequestingChilds( SvLBoxEntry* pFileEntry )
 796 {
 797     if( !pFileEntry->HasChilds() )
 798     {
 799         if( GetBookmarkDoc() )
 800         {
 801             SdrObject*   pObj = NULL;
 802             SdPage*      pPage = NULL;
 803             SvLBoxEntry* pPageEntry = NULL;
 804
 805             Image aImgPage=Image( BitmapEx( SdResId( BMP_PAGE ) ) );
 806             Image aImgPageObjs=Image( BitmapEx( SdResId( BMP_PAGEOBJS ) ) );
 807             Image aImgObjects=Image( BitmapEx( SdResId( BMP_OBJECTS ) ) );
 808             Image aImgPageH=Image( BitmapEx( SdResId( BMP_PAGE_H ) ) );
 809             Image aImgPageObjsH=Image( BitmapEx( SdResId( BMP_PAGEOBJS_H ) ) );
 810             Image aImgObjectsH=Image( BitmapEx( SdResId( BMP_OBJECTS_H ) ) );
 811
 812             // document name already inserted
 813
 814             // only insert all "normal" ? slides with objects
 815             USHORT nPage = 0;
 816             const USHORT nMaxPages = mpBookmarkDoc->GetPageCount();
 817
 818             while( nPage < nMaxPages )
 819             {
 820                 pPage = (SdPage*) mpBookmarkDoc->GetPage( nPage );
 821                 if( pPage->GetPageKind() == PK_STANDARD )
 822                 {
 823                     pPageEntry = InsertEntry( pPage->GetName(),
 824                                               aImgPage,
 825                                               aImgPage,
 826                                               pFileEntry,
 827                                               FALSE,
 828                                               LIST_APPEND,
 829                                               reinterpret_cast< void* >( 1 ) );
 830
 831                     SetExpandedEntryBmp( pPageEntry, aImgPageH, BMP_COLOR_HIGHCONTRAST );
 832                     SetCollapsedEntryBmp( pPageEntry, aImgPageH, BMP_COLOR_HIGHCONTRAST );
 833
 834                     SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
 835
 836                     while( aIter.IsMore() )
 837                     {
 838                         pObj = aIter.Next();
 839                         String aStr( GetObjectName( pObj ) );
 840                         if( aStr.Len() )
 841                         {
 842                             if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_OLE2 )
 843                             {
 844                                 SvLBoxEntry* pNewEntry = InsertEntry(aStr, maImgOle, maImgOle, pPageEntry);
 845
 846
 847                                 SetExpandedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST );
 848                                 SetCollapsedEntryBmp( pNewEntry, maImgOleH, BMP_COLOR_HIGHCONTRAST );
 849                             }
 850                             else if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_GRAF )
 851                             {
 852                                 SvLBoxEntry* pNewEntry = InsertEntry(aStr, maImgGraphic, maImgGraphic, pPageEntry);
 853
 854                                 SetExpandedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST );
 855                                 SetCollapsedEntryBmp( pNewEntry, maImgGraphicH, BMP_COLOR_HIGHCONTRAST );
 856                             }
 857                             else
 858                             {
 859                                 SvLBoxEntry* pNewEntry = InsertEntry(aStr, aImgObjects, aImgObjects, pPageEntry);
 860
 861                                 SetExpandedEntryBmp( pNewEntry, aImgObjectsH, BMP_COLOR_HIGHCONTRAST );
 862                                 SetCollapsedEntryBmp( pNewEntry, aImgObjectsH, BMP_COLOR_HIGHCONTRAST );
 863                             }
 864                         }
 865                     }
 866                     if( pPageEntry->HasChilds() )
 867                     {
 868                         SetExpandedEntryBmp( pPageEntry, aImgPageObjs );
 869                         SetCollapsedEntryBmp( pPageEntry, aImgPageObjs );
 870                         SetExpandedEntryBmp( pPageEntry, aImgPageObjsH, BMP_COLOR_HIGHCONTRAST );
 871                         SetCollapsedEntryBmp( pPageEntry, aImgPageObjsH, BMP_COLOR_HIGHCONTRAST );
 872                     }
 873                 }
 874                 nPage++;
 875             }
 876         }
 877     }
 878     else
 879         SvTreeListBox::RequestingChilds( pFileEntry );
 880 }
 881
 882 /*************************************************************************
 883 |*
 884 |*      Prueft, ob es sich um eine Draw-Datei handelt und oeffnet anhand des
 885 |*      uebergebenen Docs das BookmarkDoc
 886 |*
 887 \************************************************************************/
 888
 889 SdDrawDocument* SdPageObjsTLB::GetBookmarkDoc(SfxMedium* pMed)
 890 {
 891     if (
 892        !mpBookmarkDoc ||
 893          (pMed && (!mpOwnMedium || mpOwnMedium->GetName() != pMed->GetName()))
 894       )
 895     {
 896         // create a new BookmarkDoc if now one exists or if a new Medium is provided
 897         if (mpOwnMedium != pMed)
 898         {
 899             CloseBookmarkDoc();
 900         }
 901
 902         if (pMed)
 903         {
 904             // it looks that it is undefined if a Medium was set by Fill() allready
 905             DBG_ASSERT( !mpMedium, "SfxMedium confusion!" );
 906             delete mpMedium;
 907             mpMedium = NULL;
 908
 909             // take over this Medium (currently used only be Navigator)
 910             mpOwnMedium = pMed;
 911         }
 912
 913         DBG_ASSERT( mpMedium || pMed, "No SfxMedium provided!" );
 914
 915         if( pMed )
 916         {
 917             // in this mode the document is also owned and controlled by this instance
 918             mxBookmarkDocShRef = new ::sd::DrawDocShell(SFX_CREATE_MODE_STANDARD, TRUE);
 919             if (mxBookmarkDocShRef->DoLoad(pMed))
 920                 mpBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 921             else
 922                 mpBookmarkDoc = NULL;
 923         }
 924         else if ( mpMedium )
 925             // in this mode the document is owned and controlled by the SdDrawDocument
 926             // it can be released by calling the corresponding CloseBookmarkDoc method
 927             // successfull creation of a document makes this the owner of the medium
 928             mpBookmarkDoc = ((SdDrawDocument*) mpDoc)->OpenBookmarkDoc(*mpMedium);
 929
 930         if ( !mpBookmarkDoc )
 931         {
 932             ErrorBox aErrorBox( this, WB_OK, String( SdResId( STR_READ_DATA_ERROR ) ) );
 933             aErrorBox.Execute();
 934             mpMedium = 0; //On failure the SfxMedium is invalid
 935         }
 936     }
 937
 938     return( mpBookmarkDoc );
 939 }
 940
 941 /*************************************************************************
 942 |*
 943 |* Bookmark-Dokument schlieáen und loeschen
 944 |*
 945 \************************************************************************/
 946
 947 void SdPageObjsTLB::CloseBookmarkDoc()
 948 {
 949     if (mxBookmarkDocShRef.Is())
 950     {
 951         mxBookmarkDocShRef->DoClose();
 952         mxBookmarkDocShRef.Clear();
 953
 954         // Medium is owned by document, so it's destroyed already
 955         mpOwnMedium = 0;
 956     }
 957     else if ( mpBookmarkDoc )
 958     {
 959         DBG_ASSERT( !mpOwnMedium, "SfxMedium confusion!" );
 960         if ( mpDoc )
 961         {
 962             // The document owns the Medium, so the Medium will be invalid after closing the document
 963             ((SdDrawDocument*) mpDoc)->CloseBookmarkDoc();
 964             mpMedium = 0;
 965         }
 966     }
 967     else
 968     {
 969         // perhaps mpOwnMedium provided, but no successfull creation of BookmarkDoc
 970         delete mpOwnMedium;
 971         mpOwnMedium = NULL;
 972     }
 973
 974     mpBookmarkDoc = NULL;
 975 }
 976
 977 /*************************************************************************
 978 |*
 979 |*
 980 |*
 981 \************************************************************************/
 982
 983 void SdPageObjsTLB::SelectHdl()
 984 {
 985     SvLBoxEntry* pEntry = FirstSelected();
 986
 987     mbLinkableSelected = TRUE;
 988
 989     while( pEntry && mbLinkableSelected )
 990     {
 991         if( NULL == pEntry->GetUserData() )
 992             mbLinkableSelected = FALSE;
 993
 994         pEntry = NextSelected( pEntry );
 995     }
 996
 997     SvTreeListBox::SelectHdl();
 998 }
 999
1000 /*************************************************************************
1001 |*
1002 |* Ueberlaedt RETURN mit der Funktionsweise von DoubleClick
1003 |*
1004 \************************************************************************/
1005
1006 void SdPageObjsTLB::KeyInput( const KeyEvent& rKEvt )
1007 {
1008     if( rKEvt.GetKeyCode().GetCode() == KEY_RETURN )
1009     {
1010         // Auskommentierter Code aus svtools/source/contnr/svimpbox.cxx
1011         SvLBoxEntry* pCursor = GetCurEntry();
1012         if( pCursor->HasChilds() || pCursor->HasChildsOnDemand() )
1013         {
1014             if( IsExpanded( pCursor ) )
1015                 Collapse( pCursor );
1016             else
1017                 Expand( pCursor );
1018         }
1019
1020         DoubleClickHdl();
1021     }
1022     else
1023         SvTreeListBox::KeyInput( rKEvt );
1024 }
1025
1026 /*************************************************************************
1027 |*
1028 |* StartDrag-Request
1029 |*
1030 \************************************************************************/
1031
1032 void SdPageObjsTLB::StartDrag( sal_Int8 nAction, const Point& rPosPixel)
1033 {
1034     (void)nAction;
1035     (void)rPosPixel;
1036
1037     SdNavigatorWin* pNavWin = NULL;
1038     SvLBoxEntry* pEntry = GetEntry(rPosPixel);
1039
1040     if( mpFrame->HasChildWindow( SID_NAVIGATOR ) )
1041         pNavWin = (SdNavigatorWin*) ( mpFrame->GetChildWindow( SID_NAVIGATOR )->GetContextWindow( SD_MOD() ) );
1042
1043     if (pEntry != NULL
1044         && pNavWin !=NULL
1045         && pNavWin == mpParent
1046         && pNavWin->GetNavigatorDragType() != NAVIGATOR_DRAGTYPE_NONE )
1047     {
1048         // Mark only the children of the page under the mouse as drop
1049         // targets.  This prevents moving shapes from one page to another.
1050
1051         // Select all entries and disable them as drop targets.
1052         SetSelectionMode(MULTIPLE_SELECTION);
1053         SetCursor(NULL, FALSE);
1054         SelectAll(TRUE, FALSE);
1055         EnableSelectionAsDropTarget(FALSE, TRUE);
1056
1057         // Enable only the entries as drop targets that are children of the
1058         // page under the mouse.
1059         SvLBoxEntry* pParent = GetRootLevelParent(pEntry);
1060         if (pParent != NULL)
1061         {
1062             SelectAll(FALSE, FALSE);
1063             Select(pParent, TRUE);
1064             //            for (SvLBoxEntry*pChild=FirstChild(pParent); pChild!=NULL; pChild=NextSibling(pChild))
1065             //                Select(pChild, TRUE);
1066             EnableSelectionAsDropTarget(TRUE, TRUE);//FALSE);
1067         }
1068
1069         // Set selection back to the entry under the mouse.
1070         SelectAll(FALSE,FALSE);
1071         SetSelectionMode(SINGLE_SELECTION);
1072         Select(pEntry, TRUE);
1073
1074         //  Aus dem ExecuteDrag heraus kann der Navigator geloescht werden
1075         //  (beim Umschalten auf einen anderen Dokument-Typ), das wuerde aber
1076         //  den StarView MouseMove-Handler, der Command() aufruft, umbringen.
1077         //  Deshalb Drag&Drop asynchron:
1078         Application::PostUserEvent( STATIC_LINK( this, SdPageObjsTLB, ExecDragHdl ) );
1079     }
1080 }
1081
1082 /*************************************************************************
1083 |*
1084 |* Begin drag
1085 |*
1086 \************************************************************************/
1087
1088 void SdPageObjsTLB::DoDrag()
1089 {
1090     mpDropNavWin = ( mpFrame->HasChildWindow( SID_NAVIGATOR ) ) ?
1091                   (SdNavigatorWin*)( mpFrame->GetChildWindow( SID_NAVIGATOR )->GetContextWindow( SD_MOD() ) ) :
1092                   NULL;
1093
1094     if( mpDropNavWin )
1095     {
1096         ::sd::DrawDocShell* pDocShell = mpDoc->GetDocSh();
1097         String aURL = INetURLObject( pDocShell->GetMedium()->GetPhysicalName(), INET_PROT_FILE ).GetMainURL( INetURLObject::NO_DECODE );
1098         NavigatorDragType       eDragType = mpDropNavWin->GetNavigatorDragType();
1099
1100         aURL.Append( '#' );
1101         aURL.Append( GetSelectEntry() );
1102
1103         INetBookmark    aBookmark( aURL, GetSelectEntry() );
1104         sal_Int8                nDNDActions = DND_ACTION_COPYMOVE;
1105
1106         if( eDragType == NAVIGATOR_DRAGTYPE_LINK )
1107             nDNDActions = DND_ACTION_LINK;      // #93240# Either COPY *or* LINK, never both!
1108
1109         SvTreeListBox::ReleaseMouse();
1110
1111         bIsInDrag = TRUE;
1112
1113         SvLBoxDDInfo aDDInfo;
1114         memset(&aDDInfo,0,sizeof(SvLBoxDDInfo));
1115         aDDInfo.pApp = GetpApp();
1116         aDDInfo.pSource = this;
1117         //            aDDInfo.pDDStartEntry = pEntry;
1118         ::com::sun::star::uno::Sequence<sal_Int8> aSequence (sizeof(SvLBoxDDInfo));
1119         memcpy(aSequence.getArray(), (sal_Char*)&aDDInfo, sizeof(SvLBoxDDInfo));
1120         ::com::sun::star::uno::Any aTreeListBoxData (aSequence);
1121
1122         // object is destroyed by internal reference mechanism
1123         SdTransferable* pTransferable = new SdPageObjsTLB::SdPageObjsTransferable(
1124             *this, aBookmark, *pDocShell, eDragType, aTreeListBoxData);
1125         OSL_TRACE("created new SdPageObjsTransferable at %x", pTransferable);
1126
1127         // Get the view.
1128         sd::View* pView = NULL;
1129         if (pDocShell != NULL)
1130         {
1131             ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
1132             if (pViewShell != NULL)
1133                 pView = pViewShell->GetView();
1134         }
1135         if (pView == NULL)
1136         {
1137             OSL_ASSERT(pView!=NULL);
1138             return;
1139         }
1140
1141         SdrObject* pObject = NULL;
1142         void* pUserData = GetCurEntry()->GetUserData();
1143         if (pUserData != NULL && pUserData != (void*)1)
1144             pObject = reinterpret_cast<SdrObject*>(pUserData);
1145         if (pObject == NULL)
1146             return;
1147
1148         // For shapes without a user supplied name (the automatically
1149         // created name does not count), a different drag and drop technique
1150         // is used.
1151         if (GetObjectName(pObject, false).Len() == 0)
1152         {
1153             AddShapeToTransferable(*pTransferable, *pObject);
1154             pTransferable->SetView(pView);
1155             SD_MOD()->pTransferDrag = pTransferable;
1156         }
1157
1158         // Unnamed shapes have to be selected to be recognized by the
1159         // current drop implementation.  In order to have a consistent
1160         // behaviour for all shapes, every shape that is to be dragged is
1161         // selected first.
1162         SdrPageView* pPageView = pView->GetSdrPageView();
1163         pView->UnmarkAllObj(pPageView);
1164         pView->MarkObj(pObject, pPageView);
1165
1166         pTransferable->StartDrag( this, nDNDActions );
1167     }
1168 }
1169
1170 /*************************************************************************
1171 |*
1172 |* Drag finished
1173 |*
1174 \************************************************************************/
1175
1176 void SdPageObjsTLB::OnDragFinished( sal_uInt8 )
1177 {
1178     if( mpFrame->HasChildWindow( SID_NAVIGATOR ) )
1179     {
1180         SdNavigatorWin* pNewNavWin = (SdNavigatorWin*) ( mpFrame->GetChildWindow( SID_NAVIGATOR )->GetContextWindow( SD_MOD() ) );
1181
1182         if( mpDropNavWin == pNewNavWin)
1183         {
1184             MouseEvent aMEvt( mpDropNavWin->GetPointerPosPixel() );
1185             SvTreeListBox::MouseButtonUp( aMEvt );
1186         }
1187     }
1188
1189     mpDropNavWin = NULL;
1190     bIsInDrag = FALSE;
1191 }
1192
1193 /*************************************************************************
1194 |*
1195 |* AcceptDrop-Event
1196 |*
1197 \************************************************************************/
1198
1199 sal_Int8 SdPageObjsTLB::AcceptDrop (const AcceptDropEvent& rEvent)
1200 {
1201     sal_Int8 nResult (DND_ACTION_NONE);
1202
1203     if ( !bIsInDrag && IsDropFormatSupported( FORMAT_FILE ) )
1204     {
1205         nResult = rEvent.mnAction;
1206     }
1207     else
1208     {
1209         SvLBoxEntry* pEntry = GetDropTarget(rEvent.maPosPixel);
1210         if (rEvent.mbLeaving || !CheckDragAndDropMode( this, rEvent.mnAction ))
1211         {
1212             ImplShowTargetEmphasis( pTargetEntry, FALSE );
1213         }
1214         else if( !nDragDropMode )
1215         {
1216             DBG_ERRORFILE( "SdPageObjsTLB::AcceptDrop(): no target" );
1217         }
1218         else if (IsDropAllowed(pEntry))
1219         {
1220             nResult = DND_ACTION_MOVE;
1221
1222             // Draw emphasis.
1223             if (pEntry != pTargetEntry || !(nImpFlags & SVLBOX_TARGEMPH_VIS))
1224             {
1225                 ImplShowTargetEmphasis( pTargetEntry, FALSE );
1226                 pTargetEntry = pEntry;
1227                 ImplShowTargetEmphasis( pTargetEntry, TRUE );
1228             }
1229         }
1230     }
1231
1232     // Hide emphasis when there is no valid drop action.
1233     if (nResult == DND_ACTION_NONE)
1234         ImplShowTargetEmphasis(pTargetEntry, FALSE);
1235
1236     return nResult;
1237 }
1238
1239 /*************************************************************************
1240 |*
1241 |* ExecuteDrop-Event
1242 |*
1243 \************************************************************************/
1244
1245 sal_Int8 SdPageObjsTLB::ExecuteDrop( const ExecuteDropEvent& rEvt )
1246 {
1247     sal_Int8 nRet = DND_ACTION_NONE;
1248
1249     try
1250     {
1251         if( !bIsInDrag )
1252         {
1253             SdNavigatorWin* pNavWin = NULL;
1254             USHORT                      nId = SID_NAVIGATOR;
1255
1256             if( mpFrame->HasChildWindow( nId ) )
1257                 pNavWin = (SdNavigatorWin*)( mpFrame->GetChildWindow( nId )->GetContextWindow( SD_MOD() ) );
1258
1259             if( pNavWin && ( pNavWin == mpParent ) )
1260             {
1261                 TransferableDataHelper  aDataHelper( rEvt.maDropEvent.Transferable );
1262                 String                                  aFile;
1263
1264                 if( aDataHelper.GetString( FORMAT_FILE, aFile ) &&
1265                     ( (SdNavigatorWin*) mpParent)->InsertFile( aFile ) )
1266                 {
1267                     nRet = rEvt.mnAction;
1268                 }
1269             }
1270         }
1271     }
1272     catch (com::sun::star::uno::Exception&)
1273     {
1274         OSL_ASSERT(false);
1275     }
1276
1277     if (nRet == DND_ACTION_NONE)
1278         SvTreeListBox::ExecuteDrop(rEvt, this);
1279
1280
1281     return nRet;
1282 }
1283
1284 /*************************************************************************
1285 |*
1286 |* Handler fuers Dragging
1287 |*
1288 \************************************************************************/
1289
1290 IMPL_STATIC_LINK(SdPageObjsTLB, ExecDragHdl, void*, EMPTYARG)
1291 {
1292     //  als Link, damit asynchron ohne ImpMouseMoveMsg auf dem Stack auch der
1293     //  Navigator geloescht werden darf
1294     pThis->DoDrag();
1295     return 0;
1296 }
1297
1298
1299 bool SdPageObjsTLB::PageBelongsToCurrentShow (const SdPage* pPage) const
1300 {
1301     // Return <TRUE/> as default when there is no custom show or when none
1302     // is used.  The page does then belong to the standard show.
1303     bool bBelongsToShow = true;
1304
1305     if (mpDoc->getPresentationSettings().mbCustomShow)
1306     {
1307         // Get the current custom show.
1308         SdCustomShow* pCustomShow = NULL;
1309         List* pShowList = const_cast<SdDrawDocument*>(mpDoc)->GetCustomShowList();
1310         if (pShowList != NULL)
1311         {
1312             ULONG nCurrentShowIndex = pShowList->GetCurPos();
1313             void* pObject = pShowList->GetObject(nCurrentShowIndex);
1314             pCustomShow = static_cast<SdCustomShow*>(pObject);
1315         }
1316
1317         // Check whether the given page is part of that custom show.
1318         if (pCustomShow != NULL)
1319         {
1320             bBelongsToShow = false;
1321             ULONG nPageCount = pCustomShow->Count();
1322             for (USHORT i=0; i<nPageCount && !bBelongsToShow; i++)
1323                 if (pPage == static_cast<SdPage*>(pCustomShow->GetObject (i)))
1324                     bBelongsToShow = true;
1325         }
1326     }
1327
1328     return bBelongsToShow;
1329 }
1330
1331
1332
1333
1334 BOOL SdPageObjsTLB::NotifyMoving(
1335     SvLBoxEntry* pTarget,
1336     SvLBoxEntry* pEntry,
1337     SvLBoxEntry*& rpNewParent,
1338     ULONG& rNewChildPos)
1339 {
1340     SvLBoxEntry* pDestination = pTarget;
1341     while (GetParent(pDestination) != NULL && GetParent(GetParent(pDestination)) != NULL)
1342         pDestination = GetParent(pDestination);
1343
1344     SdrObject* pTargetObject = reinterpret_cast<SdrObject*>(pDestination->GetUserData());
1345     SdrObject* pSourceObject = reinterpret_cast<SdrObject*>(pEntry->GetUserData());
1346     if (pSourceObject == reinterpret_cast<SdrObject*>(1))
1347         pSourceObject = NULL;
1348
1349     if (pTargetObject != NULL && pSourceObject != NULL)
1350     {
1351         SdrPage* pObjectList = pSourceObject->GetPage();
1352         if (pObjectList != NULL)
1353         {
1354             sal_uInt32 nNewPosition;
1355             if (pTargetObject == reinterpret_cast<SdrObject*>(1))
1356                 nNewPosition = 0;
1357             else
1358                 nNewPosition = pTargetObject->GetNavigationPosition() + 1;
1359             pObjectList->SetObjectNavigationPosition(*pSourceObject, nNewPosition);
1360         }
1361
1362         // Update the tree list.
1363         if (pTarget == NULL)
1364         {
1365             rpNewParent = 0;
1366             rNewChildPos = 0;
1367             return TRUE;
1368         }
1369         else if (GetParent(pDestination) == NULL)
1370         {
1371             rpNewParent = pDestination;
1372             rNewChildPos = 0;
1373         }
1374         else
1375         {
1376             rpNewParent = GetParent(pDestination);
1377             rNewChildPos = pModel->GetRelPos(pDestination) + 1;
1378             rNewChildPos += nCurEntrySelPos;
1379             nCurEntrySelPos++;
1380         }
1381         return TRUE;
1382     }
1383     else
1384         return FALSE;
1385 }
1386
1387
1388
1389
1390 SvLBoxEntry* SdPageObjsTLB::GetDropTarget (const Point& rLocation)
1391 {
1392     SvLBoxEntry* pEntry = SvTreeListBox::GetDropTarget(rLocation);
1393     if (pEntry == NULL)
1394         return NULL;
1395
1396         OSL_TRACE("entry is %s",
1397             ::rtl::OUStringToOString(GetEntryText(pEntry), RTL_TEXTENCODING_UTF8).getStr());
1398     if (GetParent(pEntry) == NULL)
1399     {
1400         // Use page entry as insertion position.
1401     }
1402     else
1403     {
1404         // Go to second hierarchy level, i.e. top level shapes,
1405         // i.e. children of pages.
1406         while (GetParent(pEntry) != NULL && GetParent(GetParent(pEntry)) != NULL)
1407             pEntry = GetParent(pEntry);
1408
1409         // Advance to next sibling.
1410         SvLBoxEntry* pNext;
1411         sal_uInt16 nDepth (0);
1412         while (pEntry != NULL)
1413         {
1414             pNext = dynamic_cast<SvLBoxEntry*>(NextVisible(pEntry, &nDepth));
1415             if (pNext != NULL && nDepth > 0 && nDepth!=0xffff)
1416                 pEntry = pNext;
1417             else
1418                 break;
1419         }
1420         OSL_TRACE("returning %s",
1421             ::rtl::OUStringToOString(GetEntryText(pEntry), RTL_TEXTENCODING_UTF8).getStr());
1422     }
1423
1424     return pEntry;
1425 }
1426
1427
1428
1429
1430 bool SdPageObjsTLB::IsDropAllowed (SvLBoxEntry* pEntry)
1431 {
1432     if (pEntry == NULL)
1433         return false;
1434
1435     if ( ! IsDropFormatSupported(SdPageObjsTransferable::GetListBoxDropFormatId()))
1436         return false;
1437
1438     if ((pEntry->GetFlags() & SV_ENTRYFLAG_DISABLE_DROP) != 0)
1439         return false;
1440
1441     return true;
1442 }
1443
1444
1445
1446
1447 void SdPageObjsTLB::AddShapeToTransferable (
1448     SdTransferable& rTransferable,
1449     SdrObject& rObject) const
1450 {
1451     TransferableObjectDescriptor aObjectDescriptor;
1452     bool bIsDescriptorFillingPending (true);
1453
1454     const SdrOle2Obj* pOleObject = dynamic_cast<const SdrOle2Obj*>(&rObject);
1455     if (pOleObject != NULL && pOleObject->GetObjRef().is())
1456     {
1457         // If object has no persistence it must be copied as part of the document
1458         try
1459         {
1460             uno::Reference< embed::XEmbedPersist > xPersObj (pOleObject->GetObjRef(), uno::UNO_QUERY );
1461             if (xPersObj.is() && xPersObj->hasEntry())
1462             {
1463                 SvEmbedTransferHelper::FillTransferableObjectDescriptor(
1464                     aObjectDescriptor,
1465                     pOleObject->GetObjRef(),
1466                     pOleObject->GetGraphic(),
1467                     pOleObject->GetAspect());
1468                 bIsDescriptorFillingPending = false;
1469             }
1470         }
1471         catch( uno::Exception& )
1472         {
1473         }
1474     }
1475
1476     ::sd::DrawDocShell* pDocShell = mpDoc->GetDocSh();
1477     if (bIsDescriptorFillingPending && pDocShell!=NULL)
1478     {
1479         bIsDescriptorFillingPending = false;
1480         pDocShell->FillTransferableObjectDescriptor(aObjectDescriptor);
1481     }
1482
1483     Point aDragPos (rObject.GetCurrentBoundRect().Center());
1484     //Point aDragPos (0,0);
1485     aObjectDescriptor.maDragStartPos = aDragPos;
1486     //  aObjectDescriptor.maSize = GetAllMarkedRect().GetSize();
1487     if (pDocShell != NULL)
1488         aObjectDescriptor.maDisplayName = pDocShell->GetMedium()->GetURLObject().GetURLNoPass();
1489     else
1490         aObjectDescriptor.maDisplayName = String();
1491     aObjectDescriptor.mbCanLink = FALSE;
1492
1493     rTransferable.SetStartPos(aDragPos);
1494     rTransferable.SetObjectDescriptor( aObjectDescriptor );
1495 }
1496
1497
1498
1499
1500 //===== IconProvider ==========================================================
1501
1502 SdPageObjsTLB::IconProvider::IconProvider (void)
1503     : maImgPage( BitmapEx( SdResId( BMP_PAGE ) ) ),
1504       maImgPageExcl( BitmapEx( SdResId( BMP_PAGE_EXCLUDED ) ) ),
1505       maImgPageObjsExcl( BitmapEx( SdResId( BMP_PAGEOBJS_EXCLUDED ) ) ),
1506       maImgPageObjs( BitmapEx( SdResId( BMP_PAGEOBJS ) ) ),
1507       maImgObjects( BitmapEx( SdResId( BMP_OBJECTS ) ) ),
1508       maImgGroup( BitmapEx( SdResId( BMP_GROUP ) ) ),
1509
1510       maImgPageH( BitmapEx( SdResId( BMP_PAGE_H ) ) ),
1511       maImgPageExclH( BitmapEx( SdResId( BMP_PAGE_EXCLUDED_H ) ) ),
1512       maImgPageObjsExclH( BitmapEx( SdResId( BMP_PAGEOBJS_EXCLUDED_H ) ) ),
1513       maImgPageObjsH( BitmapEx( SdResId( BMP_PAGEOBJS_H ) ) ),
1514       maImgObjectsH( BitmapEx( SdResId( BMP_OBJECTS_H ) ) ),
1515       maImgGroupH( BitmapEx( SdResId( BMP_GROUP_H ) ) )
1516 {
1517 }