sd/source/ui/dlg/sdtreelb.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/types.h>
  21 #include <sal/log.hxx>
  22 #include <sot/formats.hxx>
  23 #include <vcl/weld.hxx>
  24 #include <svx/svditer.hxx>
  25 #include <sfx2/docfile.hxx>
  26 #include <svx/svdoole2.hxx>
  27 #include <vcl/svapp.hxx>
  28 #include <vcl/builderfactory.hxx>
  29 #include <cusshow.hxx>
  30
  31 #include <sfx2/viewfrm.hxx>
  32
  33 #include <sdtreelb.hxx>
  34 #include <DrawDocShell.hxx>
  35 #include <drawdoc.hxx>
  36 #include <sdpage.hxx>
  37 #include <sdmod.hxx>
  38 #include <sdresid.hxx>
  39 #include <navigatr.hxx>
  40 #include <strings.hrc>
  41
  42 #include <bitmaps.hlst>
  43 #include <customshowlist.hxx>
  44 #include <ViewShell.hxx>
  45 #include <DrawController.hxx>
  46 #include <ViewShellBase.hxx>
  47
  48 #include <com/sun/star/embed/XEmbedPersist.hpp>
  49 #include <com/sun/star/frame/Desktop.hpp>
  50 #include <com/sun/star/frame/XFramesSupplier.hpp>
  51 #include <svtools/acceleratorexecute.hxx>
  52 #include <svtools/embedtransfer.hxx>
  53 #include <vcl/svlbitm.hxx>
  54 #include <vcl/treelistentry.hxx>
  55 #include <comphelper/servicehelper.hxx>
  56 #include <comphelper/processfactory.hxx>
  57 #include <tools/diagnose_ex.h>
  58 #include <comphelper/scopeguard.hxx>
  59
  60
  61 using namespace com::sun::star;
  62
  63 class SdPageObjsTLB::IconProvider
  64 {
  65 public:
  66     IconProvider();
  67
  68     // Regular icons.
  69     Image const maImgPage;
  70     Image const maImgPageExcl;
  71     Image const maImgPageObjsExcl;
  72     Image const maImgPageObjs;
  73     Image const maImgObjects;
  74     Image const maImgGroup;
  75 };
  76
  77 bool SdPageObjsTLB::bIsInDrag = false;
  78
  79 bool SdPageObjsTLB::IsInDrag()
  80 {
  81     return bIsInDrag;
  82 }
  83
  84 SotClipboardFormatId SdPageObjsTLB::SdPageObjsTransferable::mnListBoxDropFormatId = static_cast<SotClipboardFormatId>(SAL_MAX_UINT32);
  85
  86
  87 SdPageObjsTLB::SdPageObjsTransferable::SdPageObjsTransferable(
  88     SdPageObjsTLB& rParent,
  89         const INetBookmark& rBookmark,
  90     ::sd::DrawDocShell& rDocShell,
  91     NavigatorDragType eDragType)
  92     : SdTransferable(rDocShell.GetDoc(), nullptr, true),
  93       mrParent( rParent ),
  94       maBookmark( rBookmark ),
  95       mrDocShell( rDocShell ),
  96       meDragType( eDragType )
  97 {
  98     rParent.SetupDragOrigin();
  99 }
 100
 101 VCL_BUILDER_FACTORY_CONSTRUCTOR(SdPageObjsTLB, WB_TABSTOP)
 102
 103 SdPageObjsTLB::SdPageObjsTransferable::~SdPageObjsTransferable()
 104 {
 105 }
 106
 107 void SdPageObjsTLB::SdPageObjsTransferable::AddSupportedFormats()
 108 {
 109     AddFormat(SotClipboardFormatId::NETSCAPE_BOOKMARK);
 110     AddFormat(SotClipboardFormatId::TREELISTBOX);
 111     AddFormat(GetListBoxDropFormatId());
 112 }
 113
 114 bool SdPageObjsTLB::SdPageObjsTransferable::GetData( const css::datatransfer::DataFlavor& rFlavor, const OUString& /*rDestDoc*/ )
 115 {
 116     SotClipboardFormatId nFormatId = SotExchange::GetFormat( rFlavor );
 117     switch (nFormatId)
 118     {
 119         case SotClipboardFormatId::NETSCAPE_BOOKMARK:
 120             SetINetBookmark( maBookmark, rFlavor );
 121             return true;
 122
 123         case SotClipboardFormatId::TREELISTBOX:
 124         {
 125             css::uno::Any aTreeListBoxData; // empty for now
 126             SetAny(aTreeListBoxData);
 127             return true;
 128         }
 129
 130         default:
 131             return false;
 132     }
 133 }
 134
 135 void SdPageObjsTLB::SdPageObjsTransferable::DragFinished( sal_Int8 nDropAction )
 136 {
 137     mrParent.OnDragFinished();
 138     SdTransferable::DragFinished(nDropAction);
 139 }
 140
 141 sal_Int64 SAL_CALL SdPageObjsTLB::SdPageObjsTransferable::getSomething( const css::uno::Sequence< sal_Int8 >& rId )
 142 {
 143     sal_Int64 nRet;
 144
 145     if( ( rId.getLength() == 16 ) &&
 146         ( 0 == memcmp( getUnoTunnelId().getConstArray(), rId.getConstArray(), 16 ) ) )
 147     {
 148         nRet = static_cast<sal_Int64>(reinterpret_cast<sal_IntPtr>(this));
 149     }
 150     else
 151         nRet = SdTransferable::getSomething(rId);
 152
 153     return nRet;
 154 }
 155
 156 namespace
 157 {
 158     class theSdPageObjsTLBUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSdPageObjsTLBUnoTunnelId > {};
 159 }
 160
 161 const css::uno::Sequence< sal_Int8 >& SdPageObjsTLB::SdPageObjsTransferable::getUnoTunnelId()
 162 {
 163     return theSdPageObjsTLBUnoTunnelId::get().getSeq();
 164 }
 165
 166 SdPageObjsTLB::SdPageObjsTransferable* SdPageObjsTLB::SdPageObjsTransferable::getImplementation( const css::uno::Reference< css::uno::XInterface >& rxData )
 167     throw()
 168 {
 169     try
 170     {
 171         css::uno::Reference< css::lang::XUnoTunnel > xUnoTunnel( rxData, css::uno::UNO_QUERY_THROW );
 172
 173         return reinterpret_cast<SdPageObjsTLB::SdPageObjsTransferable*>(
 174                 sal::static_int_cast<sal_uIntPtr>(
 175                     xUnoTunnel->getSomething( SdPageObjsTLB::SdPageObjsTransferable::getUnoTunnelId()) ) );
 176     }
 177     catch( const css::uno::Exception& )
 178     {
 179     }
 180     return nullptr;
 181 }
 182
 183 SotClipboardFormatId SdPageObjsTLB::SdPageObjsTransferable::GetListBoxDropFormatId()
 184 {
 185     if (mnListBoxDropFormatId == static_cast<SotClipboardFormatId>(SAL_MAX_UINT32))
 186         mnListBoxDropFormatId = SotExchange::RegisterFormatMimeType("application/x-openoffice-treelistbox-moveonly;windows_formatname=\"SV_LBOX_DD_FORMAT_MOVE\"");
 187     return mnListBoxDropFormatId;
 188 }
 189
 190 SdPageObjsTLB::SdPageObjsTLB( vcl::Window* pParentWin, WinBits nStyle )
 191 :   SvTreeListBox       ( pParentWin, nStyle )
 192 ,   mpDoc               ( nullptr )
 193 ,   mpBookmarkDoc       ( nullptr )
 194 ,   mpMedium            ( nullptr )
 195 ,   mpOwnMedium         ( nullptr )
 196 ,   maImgOle            ( StockImage::Yes, BMP_OLE )
 197 ,   maImgGraphic        ( StockImage::Yes, BMP_GRAPHIC )
 198 ,   mbLinkableSelected  ( false )
 199 ,   mbSaveTreeItemState ( false )
 200 ,   mbShowAllShapes     ( false )
 201 ,   mbShowAllPages      ( false )
 202 ,   mbSelectionHandlerNavigates(false)
 203 ,   mbNavigationGrabsFocus(true)
 204 {
 205     // add lines to Tree-ListBox
 206     SetStyle( GetStyle() | WB_TABSTOP | WB_BORDER | WB_HASLINES |
 207                            WB_HASBUTTONS | // WB_HASLINESATROOT |
 208                            WB_HSCROLL |
 209                            WB_HASBUTTONSATROOT );
 210     SetQuickSearch(true); /* i31275 */;
 211     SetNodeBitmaps(Image(StockImage::Yes, BMP_EXPAND), Image(StockImage::Yes, BMP_COLLAPSE));
 212
 213     SetDragDropMode(
 214          DragDropMode::CTRL_MOVE | DragDropMode::CTRL_COPY |
 215             DragDropMode::APP_MOVE  | DragDropMode::APP_COPY  | DragDropMode::APP_DROP );
 216
 217     m_pAccel = ::svt::AcceleratorExecute::createAcceleratorHelper();
 218 }
 219
 220 void SdPageObjsTLB::SetSdNavigator(SdNavigatorWin* pNavigator)
 221 {
 222     mpNavigator = pNavigator;
 223 }
 224
 225 void SdPageObjsTLB::SetViewFrame( const SfxViewFrame* pViewFrame )
 226 {
 227     sd::ViewShellBase* pBase = sd::ViewShellBase::GetViewShellBase(pViewFrame);
 228     const css::uno::Reference< css::frame::XFrame > xFrame = pBase->GetMainViewShell()->GetViewFrame()->GetFrame().GetFrameInterface();
 229     m_pAccel->init(::comphelper::getProcessComponentContext(), xFrame);
 230 }
 231
 232
 233 SdPageObjsTLB::~SdPageObjsTLB()
 234 {
 235     disposeOnce();
 236 }
 237
 238 void SdPageObjsTLB::dispose()
 239 {
 240     if ( mpBookmarkDoc )
 241         CloseBookmarkDoc();
 242     else
 243         // no document was created from mpMedium, so this object is still the owner of it
 244         delete mpMedium;
 245     mpNavigator.clear();
 246     m_pAccel.reset();
 247     SvTreeListBox::dispose();
 248 }
 249
 250 // helper function for  GetEntryAltText and GetEntryLongDescription
 251 OUString SdPageObjsTLB::getAltLongDescText(SvTreeListEntry* pEntry , bool isAltText) const
 252 {
 253     sal_uInt16 maxPages = mpDoc->GetPageCount();
 254     sal_uInt16 pageNo;
 255     SdrObject*   pObj = nullptr;
 256
 257     OUString ParentName = GetEntryText( GetRootLevelParent( pEntry ) );
 258
 259     for( pageNo = 0;  pageNo < maxPages; pageNo++ )
 260     {
 261         const SdPage* pPage = static_cast<const SdPage*>( mpDoc->GetPage( pageNo ) );
 262         if( pPage->GetPageKind() != PageKind::Standard ) continue;
 263         if( pPage->GetName() !=  ParentName ) continue;
 264         SdrObjListIter aIter( pPage, SdrIterMode::Flat );
 265         while( aIter.IsMore() )
 266         {
 267             pObj = aIter.Next();
 268             if( GetEntryText(pEntry) ==  GetObjectName( pObj )  )
 269             {
 270                 if( isAltText )
 271                     return pObj->GetTitle();
 272                 else
 273                     return pObj->GetDescription();
 274             }
 275         }
 276     }
 277     return OUString();
 278
 279 }
 280
 281 OUString SdPageObjsTLB::GetEntryAltText( SvTreeListEntry* pEntry ) const
 282 {
 283     return getAltLongDescText( pEntry, true );
 284 }
 285
 286 OUString SdPageObjsTLB::GetEntryLongDescription( SvTreeListEntry* pEntry ) const
 287 {
 288     return getAltLongDescText( pEntry, false);
 289 }
 290
 291 void SdPageObjsTLB::InitEntry(SvTreeListEntry* pEntry,
 292     const OUString& rStr, const Image& rImg1, const Image& rImg2, SvLBoxButtonKind eButtonKind)
 293 {
 294     sal_uInt16 nColToHilite = 1; //0==Bitmap;1=="Spalte1";2=="Spalte2"
 295     SvTreeListBox::InitEntry( pEntry, rStr, rImg1, rImg2, eButtonKind );
 296     SvLBoxString& rCol = static_cast<SvLBoxString&>(pEntry->GetItem( nColToHilite ));
 297     pEntry->ReplaceItem(std::make_unique<SvLBoxString>(rCol.GetText()), nColToHilite );
 298 }
 299
 300 void SdPageObjsTLB::SaveExpandedTreeItemState(SvTreeListEntry* pEntry, std::vector<OUString>& vectTreeItem)
 301 {
 302     if (!pEntry)
 303         return;
 304
 305     SvTreeListEntry* pListEntry = pEntry;
 306     while (pListEntry)
 307     {
 308         if (pListEntry->HasChildren())
 309         {
 310             if (IsExpanded(pListEntry))
 311                 vectTreeItem.push_back(GetEntryText(pListEntry));
 312             SvTreeListEntry* pChildEntry = FirstChild(pListEntry);
 313             SaveExpandedTreeItemState(pChildEntry, vectTreeItem);
 314         }
 315         pListEntry = pListEntry->NextSibling();
 316     }
 317 }
 318 void SdPageObjsTLB::Clear()
 319 {
 320     //Save the expanded tree item
 321     if (mbSaveTreeItemState)
 322     {
 323         maSelectionEntryText.clear();
 324         maTreeItem.clear();
 325         if (GetCurEntry())
 326             maSelectionEntryText = GetSelectedEntry();
 327         SvTreeListEntry* pEntry = FirstChild(nullptr);
 328         SaveExpandedTreeItemState(pEntry, maTreeItem);
 329     }
 330     return SvTreeListBox::Clear();
 331 }
 332
 333 OUString SdPageObjsTLB::GetObjectName(
 334     const SdrObject* pObject,
 335     const bool bCreate) const
 336 {
 337     OUString aRet;
 338
 339     if ( pObject )
 340     {
 341         aRet = pObject->GetName();
 342
 343         if (aRet.isEmpty() && dynamic_cast<const SdrOle2Obj* >(pObject) !=  nullptr)
 344             aRet = static_cast< const SdrOle2Obj* >( pObject )->GetPersistName();
 345     }
 346
 347     if (bCreate
 348         && mbShowAllShapes
 349         && aRet.isEmpty()
 350         && pObject!=nullptr)
 351     {
 352         aRet = SdResId(STR_NAVIGATOR_SHAPE_BASE_NAME);
 353         aRet = aRet.replaceFirst("%1", OUString::number(pObject->GetOrdNum() + 1));
 354     }
 355
 356     return aRet;
 357 }
 358
 359 /**
 360  * select a entry in TreeLB
 361  */
 362 bool SdPageObjsTLB::SelectEntry( const OUString& rName )
 363 {
 364     bool bFound = false;
 365
 366     if( !rName.isEmpty() )
 367     {
 368         SvTreeListEntry* pEntry = nullptr;
 369         OUString aTmp;
 370
 371         for( pEntry = First(); pEntry && !bFound; pEntry = Next( pEntry ) )
 372         {
 373             aTmp = GetEntryText( pEntry );
 374             if( aTmp == rName )
 375             {
 376                 bFound = true;
 377                 SetCurEntry( pEntry );
 378             }
 379         }
 380     }
 381     return bFound;
 382 }
 383
 384 /**
 385  * @return true if children of the specified string are selected
 386  */
 387 bool SdPageObjsTLB::HasSelectedChildren( const OUString& rName )
 388 {
 389     bool bChildren = false;
 390
 391     if( !rName.isEmpty() )
 392     {
 393         bool bFound  = false;
 394         SvTreeListEntry* pEntry = nullptr;
 395         OUString aTmp;
 396
 397         for( pEntry = First(); pEntry && !bFound; pEntry = Next( pEntry ) )
 398         {
 399             aTmp = GetEntryText( pEntry );
 400             if( aTmp == rName )
 401             {
 402                 bFound = true;
 403                 bool bExpanded = IsExpanded( pEntry );
 404                 long nCount = GetChildSelectionCount( pEntry );
 405                 if( bExpanded && nCount > 0 )
 406                     bChildren = true;
 407             }
 408         }
 409     }
 410     return bChildren;
 411 }
 412
 413 /**
 414  * Fill TreeLB with pages and objects
 415  */
 416 void SdPageObjsTLB::Fill( const SdDrawDocument* pInDoc, bool bAllPages,
 417                           const OUString& rDocName)
 418 {
 419     OUString aSelection;
 420     if( GetSelectionCount() > 0 )
 421     {
 422         aSelection = GetSelectedEntry();
 423         Clear();
 424     }
 425
 426     mpDoc = pInDoc;
 427     maDocName = rDocName;
 428     mbShowAllPages = bAllPages;
 429     mpMedium = nullptr;
 430
 431     IconProvider aIconProvider;
 432
 433     // first insert all pages including objects
 434     sal_uInt16 nPage = 0;
 435     const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
 436
 437     while( nPage < nMaxPages )
 438     {
 439         const SdPage* pPage = static_cast<const SdPage*>( mpDoc->GetPage( nPage ) );
 440         if(  (mbShowAllPages || pPage->GetPageKind() == PageKind::Standard)
 441              && (pPage->GetPageKind() != PageKind::Handout)   ) //#94954# never list the normal handout page ( handout-masterpage is used instead )
 442         {
 443             bool bPageExluded = pPage->IsExcluded();
 444
 445             bool bPageBelongsToShow = PageBelongsToCurrentShow (pPage);
 446             bPageExluded |= !bPageBelongsToShow;
 447
 448             AddShapeList(*pPage, nullptr, pPage->GetName(), bPageExluded, nullptr, aIconProvider);
 449         }
 450         nPage++;
 451     }
 452
 453     // then insert all master pages including objects
 454     if( mbShowAllPages )
 455     {
 456         nPage = 0;
 457         const sal_uInt16 nMaxMasterPages = mpDoc->GetMasterPageCount();
 458
 459         while( nPage < nMaxMasterPages )
 460         {
 461             const SdPage* pPage = static_cast<const SdPage*>( mpDoc->GetMasterPage( nPage ) );
 462             AddShapeList(*pPage, nullptr, pPage->GetName(), false, nullptr, aIconProvider);
 463             nPage++;
 464         }
 465     }
 466     if( !aSelection.isEmpty() )
 467         SelectEntry( aSelection );
 468     else if (mbSaveTreeItemState && !maSelectionEntryText.isEmpty())
 469     {
 470         SelectEntry(maSelectionEntryText);
 471     }
 472 }
 473
 474 /**
 475  * We insert only the first entry. Children are created on demand.
 476  */
 477 void SdPageObjsTLB::Fill( const SdDrawDocument* pInDoc, SfxMedium* pInMedium,
 478                           const OUString& rDocName )
 479 {
 480     mpDoc = pInDoc;
 481
 482     // this object now owns the Medium
 483     mpMedium = pInMedium;
 484     maDocName = rDocName;
 485
 486     Image aImgDocOpen(StockImage::Yes, BMP_DOC_OPEN);
 487     Image aImgDocClosed(StockImage::Yes, BMP_DOC_CLOSED);
 488
 489     // insert document name
 490     InsertEntry( maDocName, aImgDocOpen, aImgDocClosed, nullptr, true, TREELIST_APPEND,
 491                  reinterpret_cast< void* >( 1 )
 492     );
 493 }
 494
 495 void SdPageObjsTLB::AddShapeList (
 496     const SdrObjList& rList,
 497     SdrObject* pShape,
 498     const OUString& rsName,
 499     const bool bIsExcluded,
 500     SvTreeListEntry* pParentEntry,
 501     const IconProvider& rIconProvider)
 502 {
 503     Image aIcon (rIconProvider.maImgPage);
 504     if (bIsExcluded)
 505         aIcon = rIconProvider.maImgPageExcl;
 506     else if (pShape != nullptr)
 507         aIcon = rIconProvider.maImgGroup;
 508
 509     void* pUserData (reinterpret_cast<void*>(1));
 510     if (pShape != nullptr)
 511         pUserData = pShape;
 512
 513     SvTreeListEntry* pEntry = InsertEntry(
 514         rsName,
 515         aIcon,
 516         aIcon,
 517         pParentEntry,
 518         false,
 519         TREELIST_APPEND,
 520         pUserData);
 521
 522     SdrObjListIter aIter(
 523         &rList,
 524         !rList.HasObjectNavigationOrder() /* use navigation order, if available */,
 525         SdrIterMode::Flat);
 526
 527     while( aIter.IsMore() )
 528     {
 529         SdrObject* pObj = aIter.Next();
 530         OSL_ASSERT(pObj!=nullptr);
 531
 532         // Get the shape name.
 533         OUString aStr (GetObjectName( pObj ) );
 534
 535         if( !aStr.isEmpty() )
 536         {
 537             if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_OLE2 )
 538             {
 539                 InsertEntry(
 540                     aStr,
 541                     maImgOle,
 542                     maImgOle,
 543                     pEntry,
 544                     false,
 545                     TREELIST_APPEND,
 546                     pObj
 547                 );
 548             }
 549             else if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_GRAF )
 550             {
 551                 InsertEntry(
 552                     aStr,
 553                     maImgGraphic,
 554                     maImgGraphic,
 555                     pEntry,
 556                     false,
 557                     TREELIST_APPEND,
 558                     pObj
 559                 );
 560             }
 561             else if (pObj->IsGroupObject())
 562             {
 563                 AddShapeList(
 564                     *pObj->GetSubList(),
 565                     pObj,
 566                     aStr,
 567                     false,
 568                     pEntry,
 569                     rIconProvider
 570                 );
 571             }
 572             else
 573             {
 574                 InsertEntry(
 575                     aStr,
 576                     rIconProvider.maImgObjects,
 577                     rIconProvider.maImgObjects,
 578                     pEntry,
 579                     false,
 580                     TREELIST_APPEND,
 581                     pObj
 582                 );
 583             }
 584         }
 585     }
 586
 587     if( !pEntry->HasChildren() )
 588         return;
 589
 590     SetExpandedEntryBmp(
 591         pEntry,
 592         bIsExcluded ? rIconProvider.maImgPageObjsExcl : rIconProvider.maImgPageObjs);
 593     SetCollapsedEntryBmp(
 594         pEntry,
 595         bIsExcluded ? rIconProvider.maImgPageObjsExcl : rIconProvider.maImgPageObjs);
 596     if (mbSaveTreeItemState)
 597     {
 598         OUString strEntry = GetEntryText(pEntry);
 599         auto it = std::find(maTreeItem.begin(), maTreeItem.end(), strEntry);
 600         if (it != maTreeItem.end())
 601             Expand( pEntry );
 602     }
 603     else
 604         Expand( pEntry );
 605 }
 606
 607 void SdPageObjsTLB::SetShowAllShapes (
 608     const bool bShowAllShapes,
 609     const bool bFillList)
 610 {
 611     mbShowAllShapes = bShowAllShapes;
 612     if (bFillList)
 613     {
 614         if (mpMedium == nullptr)
 615             Fill(mpDoc, mbShowAllPages, maDocName);
 616         else
 617             Fill(mpDoc, mpMedium, maDocName);
 618     }
 619 }
 620
 621 bool SdPageObjsTLB::IsEqualToShapeList(SvTreeListEntry*& pEntry, const SdrObjList& rList,
 622                                        const OUString& rListName)
 623 {
 624     if (!pEntry)
 625         return false;
 626     OUString aName = GetEntryText(pEntry);
 627
 628     if (rListName != aName)
 629         return false;
 630
 631     pEntry = Next(pEntry);
 632
 633     SdrObjListIter aIter(&rList,
 634                          !rList.HasObjectNavigationOrder() /* use navigation order, if available */,
 635                          SdrIterMode::Flat);
 636
 637     while (aIter.IsMore())
 638     {
 639         SdrObject* pObj = aIter.Next();
 640
 641         const OUString aObjectName(GetObjectName(pObj));
 642
 643         if (!aObjectName.isEmpty())
 644         {
 645             if (!pEntry)
 646                 return false;
 647
 648             aName = GetEntryText(pEntry);
 649
 650             if (aObjectName != aName)
 651                 return false;
 652
 653             if (pObj->IsGroupObject())
 654             {
 655                 bool bRet = IsEqualToShapeList(pEntry, *pObj->GetSubList(), aObjectName);
 656                 if (!bRet)
 657                     return false;
 658             }
 659             else
 660                 pEntry = Next(pEntry);
 661         }
 662     }
 663
 664     return true;
 665 }
 666
 667 /**
 668  * Checks if the pages (PageKind::Standard) of a doc and the objects on the pages
 669  * are identical to the TreeLB.
 670  * If a doc is provided, this will be the used doc (important by more than
 671  * one document).
 672  */
 673 bool SdPageObjsTLB::IsEqualToDoc( const SdDrawDocument* pInDoc )
 674 {
 675     if( pInDoc )
 676         mpDoc = pInDoc;
 677
 678     if( !mpDoc )
 679         return false;
 680
 681     SvTreeListEntry* pEntry = First();
 682
 683     // compare all pages including the objects
 684     sal_uInt16 nPage = 0;
 685     const sal_uInt16 nMaxPages = mpDoc->GetPageCount();
 686
 687     while( nPage < nMaxPages )
 688     {
 689         const SdPage* pPage = static_cast<const SdPage*>( mpDoc->GetPage( nPage ) );
 690         if( pPage->GetPageKind() == PageKind::Standard )
 691         {
 692             bool bRet = IsEqualToShapeList(pEntry, *pPage, pPage->GetName());
 693             if (!bRet)
 694                 return false;
 695         }
 696         nPage++;
 697     }
 698     // If there are still entries in the listbox,
 699     // then objects (with names) or pages were deleted
 700     return !pEntry;
 701 }
 702
 703 /**
 704  * @return selected string
 705  */
 706 OUString SdPageObjsTLB::GetSelectedEntry()
 707 {
 708     return GetEntryText( GetCurEntry() );
 709 }
 710
 711 /**
 712  * Entries are inserted only by request (double click)
 713  */
 714 void SdPageObjsTLB::RequestingChildren( SvTreeListEntry* pFileEntry )
 715 {
 716     if( !pFileEntry->HasChildren() )
 717     {
 718         if( GetBookmarkDoc() )
 719         {
 720             SdrObject*   pObj = nullptr;
 721             SvTreeListEntry* pPageEntry = nullptr;
 722
 723             Image aImgPage(StockImage::Yes, BMP_PAGE);
 724             Image aImgPageObjs(StockImage::Yes, BMP_PAGEOBJS);
 725             Image aImgObjects(StockImage::Yes, BMP_OBJECTS);
 726
 727             // document name already inserted
 728
 729             // only insert all "normal" ? slides with objects
 730             sal_uInt16 nPage = 0;
 731             const sal_uInt16 nMaxPages = mpBookmarkDoc->GetPageCount();
 732
 733             while( nPage < nMaxPages )
 734             {
 735                 SdPage* pPage = static_cast<SdPage*>( mpBookmarkDoc->GetPage( nPage ) );
 736                 if( pPage->GetPageKind() == PageKind::Standard )
 737                 {
 738                     pPageEntry = InsertEntry( pPage->GetName(),
 739                                               aImgPage,
 740                                               aImgPage,
 741                                               pFileEntry,
 742                                               false,
 743                                               TREELIST_APPEND,
 744                                               reinterpret_cast< void* >( 1 ) );
 745
 746                     SdrObjListIter aIter( pPage, SdrIterMode::DeepWithGroups );
 747
 748                     while( aIter.IsMore() )
 749                     {
 750                         pObj = aIter.Next();
 751                         OUString aStr( GetObjectName( pObj ) );
 752                         if( !aStr.isEmpty() )
 753                         {
 754                             if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_OLE2 )
 755                             {
 756                                 InsertEntry(aStr, maImgOle, maImgOle, pPageEntry);
 757                             }
 758                             else if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_GRAF )
 759                             {
 760                                 InsertEntry(aStr, maImgGraphic, maImgGraphic, pPageEntry);
 761                             }
 762                             else
 763                             {
 764                                 InsertEntry(aStr, aImgObjects, aImgObjects, pPageEntry);
 765                             }
 766                         }
 767                     }
 768                     if( pPageEntry->HasChildren() )
 769                     {
 770                         SetExpandedEntryBmp(  pPageEntry, aImgPageObjs );
 771                         SetCollapsedEntryBmp( pPageEntry, aImgPageObjs );
 772                     }
 773                 }
 774                 nPage++;
 775             }
 776         }
 777     }
 778     else
 779         SvTreeListBox::RequestingChildren( pFileEntry );
 780 }
 781
 782 /**
 783  * Checks if it is a draw file and opens the BookmarkDoc depending of
 784  * the provided Docs
 785  */
 786 SdDrawDocument* SdPageObjsTLB::GetBookmarkDoc(SfxMedium* pMed)
 787 {
 788     if (
 789        !mpBookmarkDoc ||
 790          (pMed && (!mpOwnMedium || mpOwnMedium->GetName() != pMed->GetName()))
 791       )
 792     {
 793         // create a new BookmarkDoc if now one exists or if a new Medium is provided
 794         if (mpOwnMedium != pMed)
 795         {
 796             CloseBookmarkDoc();
 797         }
 798
 799         if (pMed)
 800         {
 801             // it looks that it is undefined if a Medium was set by Fill() already
 802             DBG_ASSERT( !mpMedium, "SfxMedium confusion!" );
 803             delete mpMedium;
 804             mpMedium = nullptr;
 805
 806             // take over this Medium (currently used only be Navigator)
 807             mpOwnMedium = pMed;
 808         }
 809
 810         DBG_ASSERT( mpMedium || pMed, "No SfxMedium provided!" );
 811
 812         if( pMed )
 813         {
 814             // in this mode the document is also owned and controlled by this instance
 815             mxBookmarkDocShRef = new ::sd::DrawDocShell(SfxObjectCreateMode::STANDARD, true, DocumentType::Impress);
 816             if (mxBookmarkDocShRef->DoLoad(pMed))
 817                 mpBookmarkDoc = mxBookmarkDocShRef->GetDoc();
 818             else
 819                 mpBookmarkDoc = nullptr;
 820         }
 821         else if ( mpMedium )
 822             // in this mode the document is owned and controlled by the SdDrawDocument
 823             // it can be released by calling the corresponding CloseBookmarkDoc method
 824             // successful creation of a document makes this the owner of the medium
 825             mpBookmarkDoc = const_cast<SdDrawDocument*>(mpDoc)->OpenBookmarkDoc(mpMedium);
 826
 827         if ( !mpBookmarkDoc )
 828         {
 829             std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(GetFrameWeld(),
 830                                                            VclMessageType::Warning, VclButtonsType::Ok, SdResId(STR_READ_DATA_ERROR)));
 831             xErrorBox->run();
 832             mpMedium = nullptr; //On failure the SfxMedium is invalid
 833         }
 834     }
 835
 836     return mpBookmarkDoc;
 837 }
 838
 839 /**
 840  * Close and delete bookmark document
 841  */
 842 void SdPageObjsTLB::CloseBookmarkDoc()
 843 {
 844     if (mxBookmarkDocShRef.is())
 845     {
 846         mxBookmarkDocShRef->DoClose();
 847         mxBookmarkDocShRef.clear();
 848
 849         // Medium is owned by document, so it's destroyed already
 850         mpOwnMedium = nullptr;
 851     }
 852     else if ( mpBookmarkDoc )
 853     {
 854         DBG_ASSERT( !mpOwnMedium, "SfxMedium confusion!" );
 855         if ( mpDoc )
 856         {
 857             // The document owns the Medium, so the Medium will be invalid after closing the document
 858             const_cast<SdDrawDocument*>(mpDoc)->CloseBookmarkDoc();
 859             mpMedium = nullptr;
 860         }
 861     }
 862     else
 863     {
 864         // perhaps mpOwnMedium provided, but no successful creation of BookmarkDoc
 865         delete mpOwnMedium;
 866         mpOwnMedium = nullptr;
 867     }
 868
 869     mpBookmarkDoc = nullptr;
 870 }
 871
 872 void SdPageObjsTLB::SelectHdl()
 873 {
 874     SvTreeListEntry* pEntry = FirstSelected();
 875
 876     mbLinkableSelected = true;
 877
 878     while( pEntry && mbLinkableSelected )
 879     {
 880         if( nullptr == pEntry->GetUserData() )
 881             mbLinkableSelected = false;
 882
 883         pEntry = NextSelected( pEntry );
 884     }
 885
 886     SvTreeListBox::SelectHdl();
 887
 888     if (mbSelectionHandlerNavigates)
 889         DoubleClickHdl();
 890 }
 891
 892 /**
 893  * Overloads RETURN with the functionality of DoubleClick
 894  */
 895 void SdPageObjsTLB::KeyInput( const KeyEvent& rKEvt )
 896 {
 897     const vcl::KeyCode& aKeyCode = rKEvt.GetKeyCode();
 898     if ( m_pAccel->execute( aKeyCode ) )
 899         // the accelerator consumed the event
 900         return;
 901     if( rKEvt.GetKeyCode().GetCode() == KEY_RETURN )
 902     {
 903         // commented code from svtools/source/contnr/svimpbox.cxx
 904         SvTreeListEntry* pCursor = GetCurEntry();
 905         if (!pCursor)
 906             return;
 907         if( pCursor->HasChildren() || pCursor->HasChildrenOnDemand() )
 908         {
 909             if( IsExpanded( pCursor ) )
 910                 Collapse( pCursor );
 911             else
 912                 Expand( pCursor );
 913         }
 914
 915         DoubleClickHdl();
 916     }
 917     else if (rKEvt.GetKeyCode().GetCode() == KEY_SPACE)
 918     {
 919         if (mpNavigator)
 920         {
 921             SvTreeListEntry* pNewEntry = GetCurEntry();
 922             if (!pNewEntry)
 923                 return;
 924             SvTreeListEntry* pParentEntry = GetParent(pNewEntry);
 925             if (!pParentEntry)
 926                 return;
 927             Invalidate();
 928         }
 929     }
 930     else
 931         SvTreeListBox::KeyInput( rKEvt );
 932 }
 933
 934 void SdPageObjsTLB::MouseButtonDown(const MouseEvent& rMEvt)
 935 {
 936     mbSelectionHandlerNavigates = rMEvt.GetClicks() == 1;
 937     comphelper::ScopeGuard aNavigationGuard([this]() { this->mbSelectionHandlerNavigates = false; });
 938     mbNavigationGrabsFocus = rMEvt.GetClicks() != 1;
 939     comphelper::ScopeGuard aGrabGuard([this]() { this->mbNavigationGrabsFocus = true; });
 940
 941     SvTreeListBox::MouseButtonDown(rMEvt);
 942 }
 943
 944 /**
 945  * StartDrag-Request
 946  */
 947 void SdPageObjsTLB::StartDrag( sal_Int8, const Point& rPosPixel)
 948 {
 949     SvTreeListEntry* pEntry = GetEntry(rPosPixel);
 950
 951     if (!(pEntry && mpNavigator && mpNavigator->GetNavigatorDragType() != NAVIGATOR_DRAGTYPE_NONE))
 952         return;
 953
 954     // Mark only the children of the page under the mouse as drop
 955     // targets.  This prevents moving shapes from one page to another.
 956
 957     // Select all entries and disable them as drop targets.
 958     SetSelectionMode(SelectionMode::Multiple);
 959     SetCursor(static_cast<SvTreeListEntry*>(nullptr));
 960     SelectAll(true, false);
 961     EnableSelectionAsDropTarget(false);
 962
 963     // Enable only the entries as drop targets that are children of the
 964     // page under the mouse.
 965     SvTreeListEntry* pParent = GetRootLevelParent(pEntry);
 966     if (pParent != nullptr)
 967     {
 968         SelectAll(false, false);
 969         Select(pParent);
 970         //            for (SvTreeListEntry*pChild=FirstChild(pParent); pChild!=NULL; pChild=NextSibling(pChild))
 971         //                Select(pChild, sal_True);
 972         EnableSelectionAsDropTarget();//sal_False);
 973     }
 974
 975     // Set selection back to the entry under the mouse.
 976     SelectAll(false, false);
 977     SetSelectionMode(SelectionMode::Single);
 978     Select(pEntry);
 979
 980     // We can delete the Navigator from ExecuteDrag (when switching to
 981     // another document type), but that would kill the StarView MouseMove
 982     // Handler which is calling Command().
 983     // For this reason, Drag&Drop is asynchronous.
 984     Application::PostUserEvent( LINK( this, SdPageObjsTLB, ExecDragHdl ), nullptr, true );
 985 }
 986
 987 /**
 988  * Begin drag
 989  */
 990 void SdPageObjsTLB::DoDrag()
 991 {
 992     if (!mpNavigator)
 993         return;
 994
 995     ::sd::DrawDocShell* pDocShell = mpDoc->GetDocSh();
 996     OUString aURL = INetURLObject( pDocShell->GetMedium()->GetPhysicalName(), INetProtocol::File ).GetMainURL( INetURLObject::DecodeMechanism::NONE );
 997     NavigatorDragType   eDragType = mpNavigator->GetNavigatorDragType();
 998
 999     aURL += "#" + GetSelectedEntry();
1000
1001     INetBookmark    aBookmark( aURL, GetSelectedEntry() );
1002     sal_Int8        nDNDActions = DND_ACTION_COPYMOVE;
1003
1004     if( eDragType == NAVIGATOR_DRAGTYPE_LINK )
1005         nDNDActions = DND_ACTION_LINK;  // Either COPY *or* LINK, never both!
1006     else if (mpDoc->GetSdPageCount(PageKind::Standard) == 1)
1007     {
1008         // Can not move away the last slide in a document.
1009         nDNDActions = DND_ACTION_COPY;
1010     }
1011
1012     SvTreeListBox::ReleaseMouse();
1013
1014     bIsInDrag = true;
1015
1016     // Get the view.
1017     ::sd::ViewShell* pViewShell = GetViewShellForDocShell(*pDocShell);
1018     if (pViewShell == nullptr)
1019     {
1020         OSL_ASSERT(pViewShell!=nullptr);
1021         return;
1022     }
1023     sd::View* pView = pViewShell->GetView();
1024     if (pView == nullptr)
1025     {
1026         OSL_ASSERT(pView!=nullptr);
1027         return;
1028     }
1029
1030     // object is destroyed by internal reference mechanism
1031     SdTransferable* pTransferable =
1032             new SdPageObjsTLB::SdPageObjsTransferable(
1033                         *this, aBookmark, *pDocShell, eDragType);
1034
1035     SdrObject* pObject = nullptr;
1036     void* pUserData = GetCurEntry()->GetUserData();
1037     if (pUserData != nullptr && pUserData != reinterpret_cast<void*>(1))
1038         pObject = static_cast<SdrObject*>(pUserData);
1039     if (pObject != nullptr)
1040     {
1041         // For shapes without a user supplied name (the automatically
1042         // created name does not count), a different drag and drop technique
1043         // is used.
1044         if (GetObjectName(pObject, false).isEmpty())
1045         {
1046             AddShapeToTransferable(*pTransferable, *pObject);
1047             pTransferable->SetView(pView);
1048             SD_MOD()->pTransferDrag = pTransferable;
1049         }
1050
1051         // Unnamed shapes have to be selected to be recognized by the
1052         // current drop implementation.  In order to have a consistent
1053         // behaviour for all shapes, every shape that is to be dragged is
1054         // selected first.
1055         SdrPageView* pPageView = pView->GetSdrPageView();
1056         pView->UnmarkAllObj(pPageView);
1057         pView->MarkObj(pObject, pPageView);
1058     }
1059     else
1060     {
1061         pTransferable->SetView(pView);
1062         SD_MOD()->pTransferDrag = pTransferable;
1063     }
1064
1065     pTransferable->StartDrag( this, nDNDActions );
1066 }
1067
1068 void SdPageObjsTLB::OnDragFinished()
1069 {
1070     if (mpNavigator)
1071     {
1072         MouseEvent aMEvt(mpNavigator->GetPointerPosPixel());
1073         SvTreeListBox::MouseButtonUp(aMEvt);
1074     }
1075
1076     bIsInDrag = false;
1077 }
1078
1079 /**
1080  * AcceptDrop-Event
1081  */
1082 sal_Int8 SdPageObjsTLB::AcceptDrop (const AcceptDropEvent& rEvent)
1083 {
1084     sal_Int8 nResult (DND_ACTION_NONE);
1085
1086     if ( !bIsInDrag && IsDropFormatSupported( SotClipboardFormatId::SIMPLE_FILE ) )
1087     {
1088         nResult = rEvent.mnAction;
1089     }
1090     else
1091     {
1092         SvTreeListEntry* pEntry = GetDropTarget(rEvent.maPosPixel);
1093         if (rEvent.mbLeaving || !CheckDragAndDropMode( this, rEvent.mnAction ))
1094         {
1095             ImplShowTargetEmphasis( pTargetEntry, false );
1096         }
1097         else if( GetDragDropMode() == DragDropMode::NONE )
1098         {
1099             SAL_WARN( "sc.ui", "SdPageObjsTLB::AcceptDrop(): no target" );
1100         }
1101         else if (IsDropAllowed(pEntry))
1102         {
1103             nResult = DND_ACTION_MOVE;
1104
1105             // Draw emphasis.
1106             if (pEntry != pTargetEntry || !(nImpFlags & SvTreeListBoxFlags::TARGEMPH_VIS))
1107             {
1108                 ImplShowTargetEmphasis( pTargetEntry, false );
1109                 pTargetEntry = pEntry;
1110                 ImplShowTargetEmphasis( pTargetEntry, true );
1111             }
1112         }
1113     }
1114
1115     // Hide emphasis when there is no valid drop action.
1116     if (nResult == DND_ACTION_NONE)
1117         ImplShowTargetEmphasis(pTargetEntry, false);
1118
1119     return nResult;
1120 }
1121
1122 /**
1123  * ExecuteDrop-Event
1124  */
1125 sal_Int8 SdPageObjsTLB::ExecuteDrop( const ExecuteDropEvent& rEvt )
1126 {
1127     sal_Int8 nRet = DND_ACTION_NONE;
1128
1129     try
1130     {
1131         if( !bIsInDrag )
1132         {
1133             if (mpNavigator)
1134             {
1135                 TransferableDataHelper  aDataHelper( rEvt.maDropEvent.Transferable );
1136                 OUString                aFile;
1137
1138                 if( aDataHelper.GetString( SotClipboardFormatId::SIMPLE_FILE, aFile ) &&
1139                     mpNavigator->InsertFile( aFile ) )
1140                 {
1141                     nRet = rEvt.mnAction;
1142                 }
1143             }
1144         }
1145     }
1146     catch (css::uno::Exception&)
1147     {
1148         DBG_UNHANDLED_EXCEPTION("sd");
1149     }
1150
1151     if (nRet == DND_ACTION_NONE)
1152         SvTreeListBox::ExecuteDrop(rEvt, this);
1153
1154     return nRet;
1155 }
1156
1157 /**
1158  * Handler for Dragging
1159  */
1160 IMPL_LINK_NOARG(SdPageObjsTLB, ExecDragHdl, void*, void)
1161 {
1162     // as link, then it is allowed to asynchronous, without ImpMouseMoveMsg on
1163     // the stack, delete the Navigator
1164     DoDrag();
1165 }
1166
1167 bool SdPageObjsTLB::PageBelongsToCurrentShow (const SdPage* pPage) const
1168 {
1169     // Return <TRUE/> as default when there is no custom show or when none
1170     // is used.  The page does then belong to the standard show.
1171     bool bBelongsToShow = true;
1172
1173     if (mpDoc->getPresentationSettings().mbCustomShow)
1174     {
1175         // Get the current custom show.
1176         SdCustomShow* pCustomShow = nullptr;
1177         SdCustomShowList* pShowList = const_cast<SdDrawDocument*>(mpDoc)->GetCustomShowList();
1178         if (pShowList != nullptr)
1179         {
1180             sal_uLong nCurrentShowIndex = pShowList->GetCurPos();
1181             pCustomShow = (*pShowList)[nCurrentShowIndex].get();
1182         }
1183
1184         // Check whether the given page is part of that custom show.
1185         if (pCustomShow != nullptr)
1186         {
1187             bBelongsToShow = false;
1188             size_t nPageCount = pCustomShow->PagesVector().size();
1189             for (size_t i=0; i<nPageCount && !bBelongsToShow; i++)
1190                 if (pPage == pCustomShow->PagesVector()[i])
1191                     bBelongsToShow = true;
1192         }
1193     }
1194
1195     return bBelongsToShow;
1196 }
1197
1198 TriState SdPageObjsTLB::NotifyMoving(
1199     SvTreeListEntry* pTarget,
1200     SvTreeListEntry* pEntry,
1201     SvTreeListEntry*& rpNewParent,
1202     sal_uLong& rNewChildPos)
1203 {
1204     SvTreeListEntry* pDestination = pTarget;
1205     while (GetParent(pDestination) != nullptr && GetParent(GetParent(pDestination)) != nullptr)
1206         pDestination = GetParent(pDestination);
1207
1208     SdrObject* pTargetObject = static_cast<SdrObject*>(pDestination->GetUserData());
1209     SdrObject* pSourceObject = static_cast<SdrObject*>(pEntry->GetUserData());
1210     if (pSourceObject == reinterpret_cast<SdrObject*>(1))
1211         pSourceObject = nullptr;
1212
1213     if (pTargetObject != nullptr && pSourceObject != nullptr)
1214     {
1215         SdrPage* pObjectList = pSourceObject->getSdrPageFromSdrObject();
1216         if (pObjectList != nullptr)
1217         {
1218             sal_uInt32 nNewPosition;
1219             if (pTargetObject == reinterpret_cast<SdrObject*>(1))
1220                 nNewPosition = 0;
1221             else
1222                 nNewPosition = pTargetObject->GetNavigationPosition() + 1;
1223             pObjectList->SetObjectNavigationPosition(*pSourceObject, nNewPosition);
1224         }
1225
1226         // Update the tree list.
1227         if (GetParent(pDestination) == nullptr)
1228         {
1229             rpNewParent = pDestination;
1230             rNewChildPos = 0;
1231         }
1232         else
1233         {
1234             rpNewParent = GetParent(pDestination);
1235             rNewChildPos = SvTreeList::GetRelPos(pDestination) + 1;
1236             rNewChildPos += nCurEntrySelPos;
1237             nCurEntrySelPos++;
1238         }
1239         return TRISTATE_TRUE;
1240     }
1241     else
1242         return TRISTATE_FALSE;
1243 }
1244
1245 SvTreeListEntry* SdPageObjsTLB::GetDropTarget (const Point& rLocation)
1246 {
1247     SvTreeListEntry* pEntry = SvTreeListBox::GetDropTarget(rLocation);
1248     if (pEntry == nullptr)
1249         return nullptr;
1250
1251     if (GetParent(pEntry) == nullptr)
1252     {
1253         // Use page entry as insertion position.
1254     }
1255     else
1256     {
1257         // Go to second hierarchy level, i.e. top level shapes,
1258         // i.e. children of pages.
1259         while (GetParent(pEntry) != nullptr && GetParent(GetParent(pEntry)) != nullptr)
1260             pEntry = GetParent(pEntry);
1261
1262         // Advance to next sibling.
1263         SvTreeListEntry* pNext;
1264         sal_uInt16 nDepth (0);
1265         do
1266         {
1267             pNext = NextVisible(pEntry, &nDepth);
1268             if (pNext != nullptr && nDepth > 0 && nDepth!=0xffff)
1269                 pEntry = pNext;
1270             else
1271                 break;
1272         }
1273         while (pEntry != nullptr);
1274     }
1275
1276     return pEntry;
1277 }
1278
1279 bool SdPageObjsTLB::IsDropAllowed (SvTreeListEntry const * pEntry)
1280 {
1281     if (pEntry == nullptr)
1282         return false;
1283
1284     if ( ! IsDropFormatSupported(SdPageObjsTransferable::GetListBoxDropFormatId()))
1285         return false;
1286
1287     if (pEntry->GetFlags() & SvTLEntryFlags::DISABLE_DROP)
1288         return false;
1289
1290     return true;
1291 }
1292
1293 void SdPageObjsTLB::AddShapeToTransferable (
1294     SdTransferable& rTransferable,
1295     SdrObject& rObject) const
1296 {
1297     std::unique_ptr<TransferableObjectDescriptor> pObjectDescriptor(new TransferableObjectDescriptor);
1298     bool bIsDescriptorFillingPending (true);
1299
1300     const SdrOle2Obj* pOleObject = dynamic_cast<const SdrOle2Obj*>(&rObject);
1301     if (pOleObject != nullptr && pOleObject->GetObjRef().is())
1302     {
1303         // If object has no persistence it must be copied as part of the document
1304         try
1305         {
1306             uno::Reference< embed::XEmbedPersist > xPersObj (pOleObject->GetObjRef(), uno::UNO_QUERY );
1307             if (xPersObj.is() && xPersObj->hasEntry())
1308             {
1309                 SvEmbedTransferHelper::FillTransferableObjectDescriptor(
1310                     *pObjectDescriptor,
1311                     pOleObject->GetObjRef(),
1312                     pOleObject->GetGraphic(),
1313                     pOleObject->GetAspect());
1314                 bIsDescriptorFillingPending = false;
1315             }
1316         }
1317         catch( uno::Exception& )
1318         {
1319         }
1320     }
1321
1322     ::sd::DrawDocShell* pDocShell = mpDoc->GetDocSh();
1323     if (bIsDescriptorFillingPending && pDocShell!=nullptr)
1324     {
1325         pDocShell->FillTransferableObjectDescriptor(*pObjectDescriptor);
1326     }
1327
1328     Point aDragPos (rObject.GetCurrentBoundRect().Center());
1329     //Point aDragPos (0,0);
1330     pObjectDescriptor->maDragStartPos = aDragPos;
1331     //  aObjectDescriptor.maSize = GetAllMarkedRect().GetSize();
1332     if (pDocShell != nullptr)
1333         pObjectDescriptor->maDisplayName = pDocShell->GetMedium()->GetURLObject().GetURLNoPass();
1334     else
1335         pObjectDescriptor->maDisplayName.clear();
1336
1337     rTransferable.SetStartPos(aDragPos);
1338     rTransferable.SetObjectDescriptor( std::move(pObjectDescriptor) );
1339 }
1340
1341 ::sd::ViewShell* SdPageObjsTLB::GetViewShellForDocShell (::sd::DrawDocShell& rDocShell)
1342 {
1343     {
1344         ::sd::ViewShell* pViewShell = rDocShell.GetViewShell();
1345         if (pViewShell != nullptr)
1346             return pViewShell;
1347     }
1348
1349     try
1350     {
1351         // Get a component enumeration from the desktop and search it for documents.
1352         uno::Reference<uno::XComponentContext> xContext( ::comphelper::getProcessComponentContext());
1353
1354         uno::Reference<frame::XDesktop2> xDesktop = frame::Desktop::create(xContext);
1355
1356         uno::Reference<frame::XFramesSupplier> xFrameSupplier (xDesktop, uno::UNO_QUERY);
1357         if ( ! xFrameSupplier.is())
1358             return nullptr;
1359
1360         uno::Reference<container::XIndexAccess> xFrameAccess (xFrameSupplier->getFrames(), uno::UNO_QUERY);
1361         if ( ! xFrameAccess.is())
1362             return nullptr;
1363
1364         for (sal_Int32 nIndex=0,nCount=xFrameAccess->getCount(); nIndex<nCount; ++nIndex)
1365         {
1366             uno::Reference<frame::XFrame> xFrame;
1367             if ( ! (xFrameAccess->getByIndex(nIndex) >>= xFrame))
1368                 continue;
1369
1370             ::sd::DrawController* pController = dynamic_cast<sd::DrawController*>(xFrame->getController().get());
1371             if (pController == nullptr)
1372                 continue;
1373             ::sd::ViewShellBase* pBase = pController->GetViewShellBase();
1374             if (pBase == nullptr)
1375                 continue;
1376             if (pBase->GetDocShell() != &rDocShell)
1377                 continue;
1378
1379             const std::shared_ptr<sd::ViewShell> pViewShell (pBase->GetMainViewShell());
1380             if (pViewShell)
1381                 return pViewShell.get();
1382         }
1383     }
1384     catch (uno::Exception &)
1385     {
1386         // When there is an exception then simply use the default value of
1387         // bIsEnabled and disable the controls.
1388     }
1389     return nullptr;
1390 }
1391
1392 //===== IconProvider ==========================================================
1393
1394 SdPageObjsTLB::IconProvider::IconProvider()
1395     : maImgPage(StockImage::Yes, BMP_PAGE),
1396       maImgPageExcl(StockImage::Yes, BMP_PAGE_EXCLUDED),
1397       maImgPageObjsExcl(StockImage::Yes, BMP_PAGEOBJS_EXCLUDED),
1398       maImgPageObjs(StockImage::Yes, BMP_PAGEOBJS),
1399       maImgObjects(StockImage::Yes, BMP_OBJECTS),
1400       maImgGroup(StockImage::Yes, BMP_GROUP)
1401 {
1402 }
1403
1404 SdPageObjsTLV::SdPageObjsTLV(std::unique_ptr<weld::TreeView> xTreeView)
1405     : m_xTreeView(std::move(xTreeView))
1406     , m_xAccel(::svt::AcceleratorExecute::createAcceleratorHelper())
1407     , m_pDoc(nullptr)
1408     , m_pBookmarkDoc(nullptr)
1409     , m_pMedium(nullptr)
1410     , m_bLinkableSelected(false)
1411     , m_bShowAllPages(false)
1412 {
1413     m_xTreeView->connect_expanding(LINK(this, SdPageObjsTLV, RequestingChildrenHdl));
1414     m_xTreeView->connect_changed(LINK(this, SdPageObjsTLV, SelectHdl));
1415 }
1416
1417 IMPL_LINK_NOARG(SdPageObjsTLV, SelectHdl, weld::TreeView&, void)
1418 {
1419     m_bLinkableSelected = true;
1420
1421     m_xTreeView->selected_foreach([this](weld::TreeIter& rEntry){
1422         if (m_xTreeView->get_id(rEntry).toInt64() == 0)
1423             m_bLinkableSelected = false;
1424         return false;
1425     });
1426
1427     m_aChangeHdl.Call(*m_xTreeView);
1428 }
1429
1430 OUString SdPageObjsTLV::GetObjectName(const SdrObject* pObject)
1431 {
1432     if ( !pObject )
1433         return OUString();
1434
1435     OUString aRet = pObject->GetName();
1436     if (!aRet.isEmpty())
1437         return aRet;
1438
1439     if (auto pOle = dynamic_cast<const SdrOle2Obj* >(pObject))
1440         aRet = pOle->GetPersistName();
1441
1442     return aRet;
1443 }
1444
1445 std::vector<OUString> SdPageObjsTLV::GetSelectEntryList(const int nDepth) const
1446 {
1447     std::vector<OUString> aEntries;
1448
1449     m_xTreeView->selected_foreach([this, nDepth, &aEntries](weld::TreeIter& rEntry){
1450         int nListDepth = m_xTreeView->get_iter_depth(rEntry);
1451         if (nListDepth == nDepth)
1452             aEntries.push_back(m_xTreeView->get_text(rEntry));
1453         return false;
1454     });
1455
1456     return aEntries;
1457 }
1458
1459 /**
1460  * Checks if it is a draw file and opens the BookmarkDoc depending of
1461  * the provided Docs
1462  */
1463 SdDrawDocument* SdPageObjsTLV::GetBookmarkDoc()
1464 {
1465     if (!m_pBookmarkDoc)
1466     {
1467         DBG_ASSERT( m_pMedium, "No SfxMedium provided!" );
1468
1469         if ( m_pMedium )
1470             // in this mode the document is owned and controlled by the SdDrawDocument
1471             // it can be released by calling the corresponding CloseBookmarkDoc method
1472             // successful creation of a document makes this the owner of the medium
1473             m_pBookmarkDoc = const_cast<SdDrawDocument*>(m_pDoc)->OpenBookmarkDoc(m_pMedium);
1474
1475         if ( !m_pBookmarkDoc )
1476         {
1477             std::unique_ptr<weld::MessageDialog> xErrorBox(Application::CreateMessageDialog(m_xTreeView.get(),
1478                                                            VclMessageType::Warning, VclButtonsType::Ok, SdResId(STR_READ_DATA_ERROR)));
1479             xErrorBox->run();
1480             m_pMedium = nullptr; //On failure the SfxMedium is invalid
1481         }
1482     }
1483
1484     return m_pBookmarkDoc;
1485 }
1486
1487 /**
1488  * Entries are inserted only by request (double click)
1489  */
1490 IMPL_LINK(SdPageObjsTLV, RequestingChildrenHdl, const weld::TreeIter&, rFileEntry, bool)
1491 {
1492     if (!m_xTreeView->iter_has_child(rFileEntry))
1493     {
1494         if (GetBookmarkDoc())
1495         {
1496             SdrObject*   pObj = nullptr;
1497
1498             OUString sImgPage(BMP_PAGE);
1499             OUString sImgPageObjs(BMP_PAGEOBJS);
1500             OUString sImgObjects(BMP_OBJECTS);
1501             OUString sImgOle(BMP_OLE);
1502             OUString sImgGraphic(BMP_GRAPHIC);
1503
1504             // document name already inserted
1505
1506             // only insert all "normal" ? slides with objects
1507             sal_uInt16 nPage = 0;
1508             const sal_uInt16 nMaxPages = m_pBookmarkDoc->GetPageCount();
1509
1510             std::unique_ptr<weld::TreeIter> xPageEntry;
1511             while (nPage < nMaxPages)
1512             {
1513                 SdPage* pPage = static_cast<SdPage*>(m_pBookmarkDoc->GetPage(nPage));
1514                 if (pPage->GetPageKind() == PageKind::Standard)
1515                 {
1516                     OUString sId(OUString::number(1));
1517                     m_xTreeView->insert(&rFileEntry, -1, &pPage->GetName(), &sId,
1518                                         nullptr, nullptr, &sImgPage, false, nullptr);
1519
1520                     if (!xPageEntry)
1521                     {
1522                         xPageEntry = m_xTreeView->make_iterator(&rFileEntry);
1523                         m_xTreeView->iter_children(*xPageEntry);
1524                     }
1525                     else
1526                         m_xTreeView->iter_next_sibling(*xPageEntry);
1527
1528                     SdrObjListIter aIter( pPage, SdrIterMode::DeepWithGroups );
1529
1530                     while( aIter.IsMore() )
1531                     {
1532                         pObj = aIter.Next();
1533                         OUString aStr( GetObjectName( pObj ) );
1534                         if( !aStr.isEmpty() )
1535                         {
1536                             if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_OLE2 )
1537                             {
1538                                 m_xTreeView->insert(xPageEntry.get(), -1, &aStr, nullptr,
1539                                                     nullptr, nullptr, &sImgOle, false, nullptr);
1540                             }
1541                             else if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_GRAF )
1542                             {
1543                                 m_xTreeView->insert(xPageEntry.get(), -1, &aStr, nullptr,
1544                                                     nullptr, nullptr, &sImgGraphic, false, nullptr);
1545                             }
1546                             else
1547                             {
1548                                 m_xTreeView->insert(xPageEntry.get(), -1, &aStr, nullptr,
1549                                                     nullptr, nullptr, &sImgObjects, false, nullptr);
1550                             }
1551                         }
1552                     }
1553                     if (m_xTreeView->iter_has_child(*xPageEntry))
1554                     {
1555                         m_xTreeView->set_image(*xPageEntry, sImgPageObjs);
1556                     }
1557                 }
1558                 nPage++;
1559             }
1560         }
1561     }
1562     return true;
1563 }
1564
1565 void SdPageObjsTLV::SetViewFrame(const SfxViewFrame* pViewFrame)
1566 {
1567     sd::ViewShellBase* pBase = sd::ViewShellBase::GetViewShellBase(pViewFrame);
1568     const css::uno::Reference< css::frame::XFrame > xFrame = pBase->GetMainViewShell()->GetViewFrame()->GetFrame().GetFrameInterface();
1569     m_xAccel->init(::comphelper::getProcessComponentContext(), xFrame);
1570 }
1571
1572 /**
1573  * Close and delete bookmark document
1574  */
1575 void SdPageObjsTLV::CloseBookmarkDoc()
1576 {
1577     if (m_xBookmarkDocShRef.is())
1578     {
1579         m_xBookmarkDocShRef->DoClose();
1580         m_xBookmarkDocShRef.clear();
1581     }
1582     else if (m_pBookmarkDoc)
1583     {
1584         if (m_pDoc)
1585         {
1586             // The document owns the Medium, so the Medium will be invalid after closing the document
1587             const_cast<SdDrawDocument*>(m_pDoc)->CloseBookmarkDoc();
1588             m_pMedium = nullptr;
1589         }
1590     }
1591
1592     m_pBookmarkDoc = nullptr;
1593 }
1594
1595 bool SdPageObjsTLV::PageBelongsToCurrentShow(const SdPage* pPage) const
1596 {
1597     // Return <TRUE/> as default when there is no custom show or when none
1598     // is used.  The page does then belong to the standard show.
1599     bool bBelongsToShow = true;
1600
1601     if (m_pDoc->getPresentationSettings().mbCustomShow)
1602     {
1603         // Get the current custom show.
1604         SdCustomShow* pCustomShow = nullptr;
1605         SdCustomShowList* pShowList = const_cast<SdDrawDocument*>(m_pDoc)->GetCustomShowList();
1606         if (pShowList != nullptr)
1607         {
1608             sal_uLong nCurrentShowIndex = pShowList->GetCurPos();
1609             pCustomShow = (*pShowList)[nCurrentShowIndex].get();
1610         }
1611
1612         // Check whether the given page is part of that custom show.
1613         if (pCustomShow != nullptr)
1614         {
1615             bBelongsToShow = false;
1616             size_t nPageCount = pCustomShow->PagesVector().size();
1617             for (size_t i=0; i<nPageCount && !bBelongsToShow; i++)
1618                 if (pPage == pCustomShow->PagesVector()[i])
1619                     bBelongsToShow = true;
1620         }
1621     }
1622
1623     return bBelongsToShow;
1624 }
1625
1626 void SdPageObjsTLV::AddShapeList (
1627     const SdrObjList& rList,
1628     SdrObject* pShape,
1629     const OUString& rsName,
1630     const bool bIsExcluded,
1631     weld::TreeIter* pParentEntry)
1632 {
1633     OUString aIcon(BMP_PAGE);
1634     if (bIsExcluded)
1635         aIcon = BMP_PAGE_EXCLUDED;
1636     else if (pShape != nullptr)
1637         aIcon = BMP_GROUP;
1638
1639     OUString aUserData("1");
1640     if (pShape != nullptr)
1641         aUserData = OUString::number(reinterpret_cast<sal_Int64>(pShape));
1642
1643     std::unique_ptr<weld::TreeIter> xEntry = m_xTreeView->make_iterator();
1644     InsertEntry(pParentEntry, aUserData, rsName, aIcon, xEntry.get());
1645
1646     SdrObjListIter aIter(
1647         &rList,
1648         !rList.HasObjectNavigationOrder() /* use navigation order, if available */,
1649         SdrIterMode::Flat);
1650
1651     while( aIter.IsMore() )
1652     {
1653         SdrObject* pObj = aIter.Next();
1654         OSL_ASSERT(pObj!=nullptr);
1655
1656         // Get the shape name.
1657         OUString aStr (GetObjectName( pObj ) );
1658         OUString sId(OUString::number(reinterpret_cast<sal_Int64>(pObj)));
1659
1660         if( !aStr.isEmpty() )
1661         {
1662             if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_OLE2 )
1663             {
1664                 InsertEntry(xEntry.get(), sId, aStr, BMP_OLE);
1665             }
1666             else if( pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == OBJ_GRAF )
1667             {
1668                 InsertEntry(xEntry.get(), sId, aStr, BMP_GRAPHIC);
1669             }
1670             else if (pObj->IsGroupObject())
1671             {
1672                 AddShapeList(
1673                     *pObj->GetSubList(),
1674                     pObj,
1675                     aStr,
1676                     false,
1677                     xEntry.get());
1678             }
1679             else
1680             {
1681                 InsertEntry(xEntry.get(), sId, aStr, BMP_OBJECTS);
1682             }
1683         }
1684     }
1685
1686     if (!m_xTreeView->iter_has_child(*xEntry))
1687         return;
1688
1689     if (bIsExcluded)
1690         m_xTreeView->set_image(*xEntry, BMP_PAGEOBJS_EXCLUDED);
1691     else
1692         m_xTreeView->set_image(*xEntry, BMP_PAGEOBJS);
1693     m_xTreeView->expand_row(*xEntry);
1694 }
1695
1696 /**
1697  * Fill TreeLB with pages and objects
1698  */
1699 void SdPageObjsTLV::Fill(const SdDrawDocument* pInDoc, bool bAllPages, const OUString& rDocName)
1700 {
1701     OUString aSelection = m_xTreeView->get_selected_text();
1702     clear();
1703
1704     m_pDoc = pInDoc;
1705     m_aDocName = rDocName;
1706     m_bShowAllPages = bAllPages;
1707     m_pMedium = nullptr;
1708
1709     // first insert all pages including objects
1710     sal_uInt16 nPage = 0;
1711     const sal_uInt16 nMaxPages = m_pDoc->GetPageCount();
1712
1713     while( nPage < nMaxPages )
1714     {
1715         const SdPage* pPage = static_cast<const SdPage*>( m_pDoc->GetPage( nPage ) );
1716         if(  (m_bShowAllPages || pPage->GetPageKind() == PageKind::Standard)
1717              && (pPage->GetPageKind() != PageKind::Handout)   ) //#94954# never list the normal handout page ( handout-masterpage is used instead )
1718         {
1719             bool bPageExluded = pPage->IsExcluded();
1720
1721             bool bPageBelongsToShow = PageBelongsToCurrentShow (pPage);
1722             bPageExluded |= !bPageBelongsToShow;
1723
1724             AddShapeList(*pPage, nullptr, pPage->GetName(), bPageExluded, nullptr);
1725         }
1726         nPage++;
1727     }
1728
1729     // then insert all master pages including objects
1730     if( m_bShowAllPages )
1731     {
1732         nPage = 0;
1733         const sal_uInt16 nMaxMasterPages = m_pDoc->GetMasterPageCount();
1734
1735         while( nPage < nMaxMasterPages )
1736         {
1737             const SdPage* pPage = static_cast<const SdPage*>( m_pDoc->GetMasterPage( nPage ) );
1738             AddShapeList(*pPage, nullptr, pPage->GetName(), false, nullptr);
1739             nPage++;
1740         }
1741     }
1742     if (!aSelection.isEmpty())
1743         m_xTreeView->select_text(aSelection);
1744 }
1745
1746 /**
1747  * We insert only the first entry. Children are created on demand.
1748  */
1749 void SdPageObjsTLV::Fill( const SdDrawDocument* pInDoc, SfxMedium* pInMedium,
1750                           const OUString& rDocName )
1751 {
1752     m_pDoc = pInDoc;
1753
1754     // this object now owns the Medium
1755     m_pMedium = pInMedium;
1756     m_aDocName = rDocName;
1757
1758     OUString sImgDoc(BMP_DOC_OPEN);
1759
1760     OUString sId(OUString::number(1));
1761     // insert document name
1762     m_xTreeView->insert(nullptr, -1, &m_aDocName, &sId, nullptr, nullptr, &sImgDoc, true, nullptr);
1763 }
1764
1765 /**
1766  * select a entry in TreeLB
1767  */
1768 bool SdPageObjsTLV::SelectEntry( const OUString& rName )
1769 {
1770     bool bFound = false;
1771
1772     if (!rName.isEmpty())
1773     {
1774         std::unique_ptr<weld::TreeIter> xEntry(m_xTreeView->make_iterator());
1775         OUString aTmp;
1776
1777         if (m_xTreeView->get_iter_first(*xEntry))
1778         {
1779             do
1780             {
1781                 aTmp = m_xTreeView->get_text(*xEntry);
1782                 if (aTmp == rName)
1783                 {
1784                     m_xTreeView->set_cursor(*xEntry);
1785                     m_xTreeView->select(*xEntry);
1786                     bFound = true;
1787                     break;
1788                 }
1789             }
1790             while (m_xTreeView->iter_next(*xEntry));
1791         }
1792     }
1793
1794     return bFound;
1795 }
1796
1797 SdPageObjsTLV::~SdPageObjsTLV()
1798 {
1799     if (m_pBookmarkDoc)
1800         CloseBookmarkDoc();
1801     else
1802     {
1803         // no document was created from m_pMedium, so this object is still the owner of it
1804         delete m_pMedium;
1805     }
1806     m_xAccel.reset();
1807 }
1808
1809 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */