sd/source/ui/dlg/navigatr.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 <tools/urlobj.hxx>
  21 #include <unotools/localfilehelper.hxx>
  22 #include <sfx2/imgmgr.hxx>
  23 #include <sfx2/fcontnr.hxx>
  24 #include <svl/eitem.hxx>
  25 #include <svl/stritem.hxx>
  26 #include <sfx2/docfilt.hxx>
  27 #include <sfx2/docfile.hxx>
  28 #include <svl/intitem.hxx>
  29 #include <sfx2/dispatch.hxx>
  30 #include <svx/svxids.hrc>
  31 #include <vcl/menu.hxx>
  32
  33 #include <sfx2/viewfrm.hxx>
  34 #include <sfx2/dockwin.hxx>
  35 #include <sfx2/sfxresid.hxx>
  36
  37 #include "pres.hxx"
  38 #include "navigatr.hxx"
  39 #include "navigatr.hrc"
  40 #include "pgjump.hxx"
  41 #include "app.hrc"
  42 #include "strings.hrc"
  43 #include "res_bmp.hrc"
  44 #include "drawdoc.hxx"
  45 #include "DrawDocShell.hxx"
  46 #include "sdresid.hxx"
  47 #include "ViewShell.hxx"
  48 #include "ViewShellBase.hxx"
  49 #include "DrawViewShell.hxx"
  50 #include "slideshow.hxx"
  51 #include "FrameView.hxx"
  52 #include "helpids.h"
  53
  54 namespace {
  55 static const sal_uInt16 nShowNamedShapesFilter=1;
  56 static const sal_uInt16 nShowAllShapesFilter=2;
  57 }
  58
  59 /**
  60  * SdNavigatorWin - FloatingWindow
  61  */
  62 SdNavigatorWin::SdNavigatorWin(
  63     ::Window* pParent,
  64     ::sd::NavigatorChildWindow* pChWinCtxt,
  65     const SdResId& rSdResId,
  66     SfxBindings* pInBindings,
  67     const UpdateRequestFunctor& rUpdateRequest)
  68     : ::Window( pParent, rSdResId )
  69     , maToolbox ( this, SdResId( 1 ) )
  70     , maTlbObjects( this, SdResId( TLB_OBJECTS ) )
  71     , maLbDocs ( this, SdResId( LB_DOCS ) )
  72     , mpChildWinContext( pChWinCtxt )
  73     , mbDocImported ( sal_False )
  74       // On changes of the DragType: adjust SelectionMode of TLB!
  75     , meDragType ( NAVIGATOR_DRAGTYPE_EMBEDDED )
  76     , mpBindings ( pInBindings )
  77     , maImageList ( SdResId( IL_NAVIGATR ) )
  78 {
  79     maTlbObjects.SetViewFrame( mpBindings->GetDispatcher()->GetFrame() );
  80
  81     FreeResource();
  82
  83     maTlbObjects.SetAccessibleName(String(SdResId(STR_OBJECTS_TREE)));
  84
  85     mpNavigatorCtrlItem = new SdNavigatorControllerItem( SID_NAVIGATOR_STATE, this, mpBindings, rUpdateRequest);
  86     mpPageNameCtrlItem = new SdPageNameControllerItem( SID_NAVIGATOR_PAGENAME, this, mpBindings, rUpdateRequest);
  87
  88     ApplyImageList(); // load images *before* calculating sizes to get something useful !!!
  89
  90     Size aTbxSize( maToolbox.CalcWindowSizePixel() );
  91     maToolbox.SetOutputSizePixel( aTbxSize );
  92     maToolbox.SetSelectHdl( LINK( this, SdNavigatorWin, SelectToolboxHdl ) );
  93     maToolbox.SetClickHdl( LINK( this, SdNavigatorWin, ClickToolboxHdl ) );
  94     maToolbox.SetDropdownClickHdl( LINK(this, SdNavigatorWin, DropdownClickToolBoxHdl) );
  95     maToolbox.SetItemBits( TBI_DRAGTYPE, maToolbox.GetItemBits( TBI_DRAGTYPE ) | TIB_DROPDOWNONLY );
  96
  97     // Shape filter drop down menu.
  98     maToolbox.SetItemBits(
  99         TBI_SHAPE_FILTER,
 100         maToolbox.GetItemBits(TBI_SHAPE_FILTER) | TIB_DROPDOWNONLY);
 101
 102     // TreeListBox
 103     // set position below toolbox
 104     long nListboxYPos = maToolbox.GetPosPixel().Y() + maToolbox.GetSizePixel().Height() + 4;
 105     maTlbObjects.setPosSizePixel( 0, nListboxYPos, 0, 0, WINDOW_POSSIZE_Y );
 106     maTlbObjects.SetDoubleClickHdl( LINK( this, SdNavigatorWin, ClickObjectHdl ) );
 107     maTlbObjects.SetSelectionMode( SINGLE_SELECTION );
 108     // set focus to listbox, otherwise it is in the toolbox which is only useful
 109     // for keyboard navigation
 110     maTlbObjects.GrabFocus();
 111
 112     // DragTypeListBox
 113     maLbDocs.SetSelectHdl( LINK( this, SdNavigatorWin, SelectDocumentHdl ) );
 114     // set position below treelistbox
 115     nListboxYPos = maTlbObjects.GetPosPixel().Y() + maTlbObjects.GetSizePixel().Height() + 4;
 116     maLbDocs.setPosSizePixel( 0, nListboxYPos, 0, 0, WINDOW_POSSIZE_Y );
 117
 118     // assure that tool box is at least as wide as the tree list box
 119     {
 120         const Size aTlbSize( maTlbObjects.GetOutputSizePixel() );
 121         if ( aTlbSize.Width() > aTbxSize.Width() )
 122         {
 123             maToolbox.setPosSizePixel( 0, 0, aTlbSize.Width(), 0, WINDOW_POSSIZE_WIDTH );
 124             aTbxSize = maToolbox.GetOutputSizePixel();
 125         }
 126     }
 127
 128     // set min outputsize after all sizes are known
 129     const long nFullHeight = nListboxYPos + maLbDocs.GetSizePixel().Height() + 4;
 130     maSize = GetOutputSizePixel();
 131     if( maSize.Height() < nFullHeight )
 132     {
 133         maSize.Height() = nFullHeight;
 134         SetOutputSizePixel( maSize );
 135     }
 136     maMinSize = maSize;
 137     const long nMinWidth = 2*maToolbox.GetPosPixel().X() + aTbxSize.Width(); // never clip the toolbox
 138     if( nMinWidth > maMinSize.Width() )
 139         maMinSize.Width() = nMinWidth;
 140     maMinSize.Height() -= 40;
 141     SfxDockingWindow* pDockingParent = dynamic_cast<SfxDockingWindow*>(GetParent());
 142     if (pDockingParent != NULL)
 143         pDockingParent->SetMinOutputSizePixel( maMinSize );
 144
 145     // InitTlb; is initiated over Slot
 146     if (rUpdateRequest)
 147         rUpdateRequest();
 148 }
 149
 150 // -----------------------------------------------------------------------
 151
 152 SdNavigatorWin::~SdNavigatorWin()
 153 {
 154     delete mpNavigatorCtrlItem;
 155     delete mpPageNameCtrlItem;
 156 }
 157
 158 // -----------------------------------------------------------------------
 159
 160 void SdNavigatorWin::InitTreeLB( const SdDrawDocument* pDoc )
 161 {
 162     SdDrawDocument* pNonConstDoc = (SdDrawDocument*) pDoc; // const as const can...
 163     ::sd::DrawDocShell* pDocShell = pNonConstDoc->GetDocSh();
 164     String aDocShName( pDocShell->GetName() );
 165     ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 166
 167     // Restore the 'ShowAllShapes' flag from the last time (in this session)
 168     // that the navigator was shown.
 169     if (pViewShell != NULL)
 170     {
 171         ::sd::FrameView* pFrameView = pViewShell->GetFrameView();
 172         if (pFrameView != NULL)
 173             maTlbObjects.SetShowAllShapes(pFrameView->IsNavigatorShowingAllShapes(), false);
 174     }
 175
 176     // Disable the shape filter drop down menu when there is a running slide
 177     // show.
 178     if (pViewShell!=NULL && sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ))
 179         maToolbox.EnableItem(TBI_SHAPE_FILTER, sal_False);
 180     else
 181         maToolbox.EnableItem(TBI_SHAPE_FILTER);
 182
 183     if( !maTlbObjects.IsEqualToDoc( pDoc ) )
 184     {
 185         String aDocName = pDocShell->GetMedium()->GetName();
 186         maTlbObjects.Clear();
 187         maTlbObjects.Fill( pDoc, (sal_Bool) sal_False, aDocName ); // only normal pages
 188
 189         RefreshDocumentLB();
 190         maLbDocs.SelectEntry( aDocShName );
 191     }
 192     else
 193     {
 194         maLbDocs.SetNoSelection();
 195         maLbDocs.SelectEntry( aDocShName );
 196
 197 // commented in order to fix 30246
 198 //        if( maLbDocs.GetSelectEntryCount() == 0 )
 199         {
 200             RefreshDocumentLB();
 201             maLbDocs.SelectEntry( aDocShName );
 202         }
 203     }
 204
 205     SfxViewFrame* pViewFrame = ( ( pViewShell && pViewShell->GetViewFrame() ) ? pViewShell->GetViewFrame() : SfxViewFrame::Current() );
 206     if( pViewFrame )
 207         pViewFrame->GetBindings().Invalidate(SID_NAVIGATOR_PAGENAME, sal_True, sal_True);
 208 }
 209
 210 /**
 211  * DragType is set on dependance if a Drag is even possible. For example,
 212  * under certain circumstances, it is not allowed to drag graphics (#31038#).
 213  */
 214 NavigatorDragType SdNavigatorWin::GetNavigatorDragType()
 215 {
 216     NavigatorDragType   eDT = meDragType;
 217     NavDocInfo*         pInfo = GetDocInfo();
 218
 219     if( ( eDT == NAVIGATOR_DRAGTYPE_LINK ) && ( ( pInfo && !pInfo->HasName() ) || !maTlbObjects.IsLinkableSelected() ) )
 220         eDT = NAVIGATOR_DRAGTYPE_NONE;
 221
 222     return( eDT );
 223 }
 224
 225 // -----------------------------------------------------------------------
 226
 227
 228 IMPL_LINK_NOARG(SdNavigatorWin, SelectToolboxHdl)
 229 {
 230     sal_uInt16 nId = maToolbox.GetCurItemId();
 231     sal_uInt16 nSId = 0;
 232     PageJump ePage = PAGE_NONE;
 233
 234     switch( nId )
 235     {
 236         case TBI_PEN:
 237         {
 238             if( nId == TBI_PEN )
 239             {
 240                 nSId = SID_NAVIGATOR_PEN;
 241             }
 242
 243             if( nSId > 0 )
 244             {
 245                 SfxBoolItem aItem( nSId, sal_True );
 246                 mpBindings->GetDispatcher()->Execute(
 247                     nSId, SFX_CALLMODE_SLOT |SFX_CALLMODE_RECORD, &aItem, 0L );
 248             }
 249         }
 250         break;
 251
 252         case TBI_FIRST:
 253         case TBI_PREVIOUS:
 254         case TBI_NEXT:
 255         case TBI_LAST:
 256         {
 257             if( nId == TBI_FIRST )
 258                 ePage = PAGE_FIRST;
 259             else if( nId == TBI_PREVIOUS )
 260                 ePage = PAGE_PREVIOUS;
 261             else if( nId == TBI_NEXT )
 262                 ePage = PAGE_NEXT;
 263             else if( nId == TBI_LAST )
 264                 ePage = PAGE_LAST;
 265
 266             if( ePage != PAGE_NONE )
 267             {
 268                 SfxUInt16Item aItem( SID_NAVIGATOR_PAGE, (sal_uInt16)ePage );
 269                 mpBindings->GetDispatcher()->Execute(
 270                     SID_NAVIGATOR_PAGE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L );
 271             }
 272         }
 273         break;
 274     }
 275     return 0;
 276 }
 277
 278 // -----------------------------------------------------------------------
 279
 280
 281 IMPL_LINK_NOARG(SdNavigatorWin, ClickToolboxHdl)
 282 {
 283     return 0;
 284 }
 285
 286 // -----------------------------------------------------------------------
 287
 288 IMPL_LINK( SdNavigatorWin, DropdownClickToolBoxHdl, ToolBox*, pBox )
 289 {
 290     sal_uInt16 nId = maToolbox.GetCurItemId();
 291
 292     switch( nId )
 293     {
 294         case TBI_DRAGTYPE:
 295         {
 296             // Popup menu is created depending if the document is saved or not
 297             PopupMenu *pMenu = new PopupMenu;
 298
 299             static const char* aHIDs[] =
 300             {
 301                  HID_SD_NAVIGATOR_MENU1,
 302                  HID_SD_NAVIGATOR_MENU2,
 303                  HID_SD_NAVIGATOR_MENU3,
 304                  0
 305             };
 306
 307             for( sal_uInt16 nID = NAVIGATOR_DRAGTYPE_URL;
 308                  nID < NAVIGATOR_DRAGTYPE_COUNT;
 309                  nID++ )
 310             {
 311                 sal_uInt16 nRId = GetDragTypeSdResId( (NavigatorDragType)nID );
 312                 if( nRId > 0 )
 313                 {
 314                     DBG_ASSERT(aHIDs[nID-NAVIGATOR_DRAGTYPE_URL],"HelpId not added!");
 315                     pMenu->InsertItem( nID, String( SdResId( nRId ) ) );
 316                     pMenu->SetHelpId( nID, aHIDs[nID - NAVIGATOR_DRAGTYPE_URL] );
 317                 }
 318
 319             }
 320             NavDocInfo* pInfo = GetDocInfo();
 321
 322             if( ( pInfo && !pInfo->HasName() ) || !maTlbObjects.IsLinkableSelected() )
 323             {
 324                 pMenu->EnableItem( NAVIGATOR_DRAGTYPE_LINK, sal_False );
 325                 pMenu->EnableItem( NAVIGATOR_DRAGTYPE_URL, sal_False );
 326                 meDragType = NAVIGATOR_DRAGTYPE_EMBEDDED;
 327             }
 328
 329             pMenu->CheckItem( (sal_uInt16)meDragType );
 330             pMenu->SetSelectHdl( LINK( this, SdNavigatorWin, MenuSelectHdl ) );
 331
 332             pMenu->Execute( this, maToolbox.GetItemRect( nId ), POPUPMENU_EXECUTE_DOWN );
 333             pBox->EndSelection();
 334             delete pMenu;
 335         }
 336         break;
 337
 338         case TBI_SHAPE_FILTER:
 339         {
 340             PopupMenu *pMenu = new PopupMenu;
 341
 342             pMenu->InsertItem(
 343                 nShowNamedShapesFilter,
 344                 String(SdResId(STR_NAVIGATOR_SHOW_NAMED_SHAPES)));
 345             pMenu->InsertItem(
 346                 nShowAllShapesFilter,
 347                 String(SdResId(STR_NAVIGATOR_SHOW_ALL_SHAPES)));
 348
 349             if (maTlbObjects.GetShowAllShapes())
 350                 pMenu->CheckItem(nShowAllShapesFilter);
 351             else
 352                 pMenu->CheckItem(nShowNamedShapesFilter);
 353             pMenu->SetSelectHdl( LINK( this, SdNavigatorWin, ShapeFilterCallback ) );
 354
 355             pMenu->Execute( this, maToolbox.GetItemRect( nId ), POPUPMENU_EXECUTE_DOWN );
 356             pBox->EndSelection();
 357             delete pMenu;
 358         }
 359         break;
 360     }
 361     return 0;
 362 }
 363
 364 // -----------------------------------------------------------------------
 365
 366 IMPL_LINK_NOARG(SdNavigatorWin, ClickObjectHdl)
 367 {
 368     if( !mbDocImported || maLbDocs.GetSelectEntryPos() != 0 )
 369     {
 370         NavDocInfo* pInfo = GetDocInfo();
 371
 372         // if it is the active window, we jump to the page
 373         if( pInfo && pInfo->IsActive() )
 374         {
 375             String aStr( maTlbObjects.GetSelectEntry() );
 376
 377             if( aStr.Len() > 0 )
 378             {
 379                 SfxStringItem aItem( SID_NAVIGATOR_OBJECT, aStr );
 380                 mpBindings->GetDispatcher()->Execute(
 381                     SID_NAVIGATOR_OBJECT, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L );
 382
 383                 // moved here from SetGetFocusHdl. Reset the
 384                 // focus only if something has been selected in the
 385                 // document.
 386                 SfxViewShell* pCurSh = SfxViewShell::Current();
 387
 388                 if ( pCurSh )
 389                 {
 390                     Window* pShellWnd = pCurSh->GetWindow();
 391                     if ( pShellWnd )
 392                         pShellWnd->GrabFocus();
 393                 }
 394             }
 395         }
 396     }
 397     return( 0L );
 398 }
 399
 400 // -----------------------------------------------------------------------
 401
 402 IMPL_LINK_NOARG(SdNavigatorWin, SelectDocumentHdl)
 403 {
 404     String aStrLb = maLbDocs.GetSelectEntry();
 405     long   nPos = maLbDocs.GetSelectEntryPos();
 406     sal_Bool   bFound = sal_False;
 407     ::sd::DrawDocShell* pDocShell = NULL;
 408     NavDocInfo* pInfo = GetDocInfo();
 409
 410     // is it a dragged object?
 411     if( mbDocImported && nPos == 0 )
 412     {
 413         // construct document in TLB
 414         InsertFile( aStrLb );
 415     }
 416     else if (pInfo)
 417     {
 418         pDocShell = pInfo->mpDocShell;
 419
 420         bFound = sal_True;
 421     }
 422
 423     if( bFound )
 424     {
 425         SdDrawDocument* pDoc = pDocShell->GetDoc();
 426         if( !maTlbObjects.IsEqualToDoc( pDoc ) )
 427         {
 428             SdDrawDocument* pNonConstDoc = (SdDrawDocument*) pDoc; // const as const can...
 429             ::sd::DrawDocShell* pNCDocShell = pNonConstDoc->GetDocSh();
 430             String aDocName = pNCDocShell->GetMedium()->GetName();
 431             maTlbObjects.Clear();
 432             maTlbObjects.Fill( pDoc, (sal_Bool) sal_False, aDocName ); // only normal pages
 433         }
 434     }
 435
 436     // check if link or url is possible
 437     if( ( pInfo && !pInfo->HasName() ) || !maTlbObjects.IsLinkableSelected() || ( meDragType != NAVIGATOR_DRAGTYPE_EMBEDDED ) )
 438     {
 439         meDragType = NAVIGATOR_DRAGTYPE_EMBEDDED;
 440         SetDragImage();
 441     }
 442
 443     return( 0L );
 444 }
 445
 446 /**
 447  * Set DrageType and set image accordingly to it.
 448  * If the handler is called with NULL, the default (URL) is set.
 449  */
 450 IMPL_LINK( SdNavigatorWin, MenuSelectHdl, Menu *, pMenu )
 451 {
 452     sal_uInt16 nMenuId;
 453     if( pMenu )
 454         nMenuId = pMenu->GetCurItemId();
 455     else
 456         nMenuId = NAVIGATOR_DRAGTYPE_URL;
 457
 458     if( nMenuId != USHRT_MAX ) // Necessary ?
 459     {
 460         NavigatorDragType eDT = (NavigatorDragType) nMenuId;
 461         if( meDragType != eDT )
 462         {
 463             meDragType = eDT;
 464             SetDragImage();
 465
 466             if( meDragType == NAVIGATOR_DRAGTYPE_URL )
 467             {
 468                 // patch, prevents endless loop
 469                 if( maTlbObjects.GetSelectionCount() > 1 )
 470                     maTlbObjects.SelectAll( sal_False );
 471
 472                 maTlbObjects.SetSelectionMode( SINGLE_SELECTION );
 473             }
 474             else
 475                 maTlbObjects.SetSelectionMode( MULTIPLE_SELECTION );
 476         }
 477     }
 478     return( 0 );
 479 }
 480
 481
 482
 483
 484 IMPL_LINK( SdNavigatorWin, ShapeFilterCallback, Menu *, pMenu )
 485 {
 486     if (pMenu != NULL)
 487     {
 488         bool bShowAllShapes (maTlbObjects.GetShowAllShapes());
 489         sal_uInt16 nMenuId (pMenu->GetCurItemId());
 490         switch (nMenuId)
 491         {
 492             case nShowNamedShapesFilter:
 493                 bShowAllShapes = false;
 494                 break;
 495
 496             case nShowAllShapesFilter:
 497                 bShowAllShapes = true;
 498                 break;
 499
 500             default:
 501                 OSL_FAIL(
 502                     "SdNavigatorWin::ShapeFilterCallback called for unknown menu entry");
 503                 break;
 504         }
 505
 506         maTlbObjects.SetShowAllShapes(bShowAllShapes, true);
 507
 508         // Remember the selection in the FrameView.
 509         NavDocInfo* pInfo = GetDocInfo();
 510         if (pInfo != NULL)
 511         {
 512             ::sd::DrawDocShell* pDocShell = pInfo->mpDocShell;
 513             if (pDocShell != NULL)
 514             {
 515                 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 516                 if (pViewShell != NULL)
 517                 {
 518                     ::sd::FrameView* pFrameView = pViewShell->GetFrameView();
 519                     if (pFrameView != NULL)
 520                     {
 521                         pFrameView->SetIsNavigatorShowingAllShapes(bShowAllShapes);
 522                     }
 523                 }
 524             }
 525         }
 526     }
 527
 528     return 0;
 529 }
 530
 531 // -----------------------------------------------------------------------
 532
 533 void SdNavigatorWin::Resize()
 534 {
 535     Size aWinSize( GetOutputSizePixel() );
 536     if( aWinSize.Height() >= maMinSize.Height() )
 537         //aWinSize.Width() >= maMinSize.Width() )
 538     {
 539         Size aDiffSize;
 540         aDiffSize.Width() = aWinSize.Width() - maSize.Width();
 541         aDiffSize.Height() = aWinSize.Height() - maSize.Height();
 542
 543         // change size of Toolbox
 544         Size aObjSize( maToolbox.GetOutputSizePixel() );
 545         aObjSize.Width() += aDiffSize.Width();
 546         maToolbox.SetOutputSizePixel( aObjSize );
 547
 548         // change size of TreeLB
 549         aObjSize = maTlbObjects.GetSizePixel();
 550         aObjSize.Width() += aDiffSize.Width();
 551         aObjSize.Height() = maLbDocs.GetPosPixel().Y() + aDiffSize.Height() -
 552             maTlbObjects.GetPosPixel().Y() - 4;
 553         maTlbObjects.SetSizePixel( aObjSize );
 554
 555         Point aPt( 0, aDiffSize.Height() );
 556
 557         // move other controls (DocumentLB)
 558         maLbDocs.Hide();
 559         aObjSize = maLbDocs.GetOutputSizePixel();
 560         aObjSize.Width() += aDiffSize.Width();
 561         maLbDocs.SetPosPixel( maLbDocs.GetPosPixel() + aPt );
 562         maLbDocs.SetOutputSizePixel( aObjSize );
 563         maLbDocs.Show();
 564
 565         maSize = aWinSize;
 566     }
 567     Window::Resize();
 568 }
 569
 570 // -----------------------------------------------------------------------
 571
 572 sal_Bool SdNavigatorWin::InsertFile(const String& rFileName)
 573 {
 574     INetURLObject   aURL( rFileName );
 575     sal_Bool            bReturn = sal_True;
 576
 577     if( aURL.GetProtocol() == INET_PROT_NOT_VALID )
 578     {
 579         OUString aURLStr;
 580         ::utl::LocalFileHelper::ConvertPhysicalNameToURL( rFileName, aURLStr );
 581         aURL = INetURLObject( aURLStr );
 582     }
 583
 584     // get adjusted FileName
 585     String aFileName( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 586
 587     if (!aFileName.Len())
 588     {
 589         // show actual document again
 590         maDropFileName = aFileName;
 591     }
 592     else
 593     {
 594         // show dragged-in document
 595         const SfxFilter* pFilter = NULL;
 596         ErrCode nErr = 0;
 597
 598         if (aFileName != maDropFileName)
 599         {
 600             SfxMedium aMed(aFileName, (STREAM_READ | STREAM_SHARE_DENYNONE));
 601             SfxFilterMatcher aMatch( OUString("simpress") );
 602             aMed.UseInteractionHandler( sal_True );
 603             nErr = aMatch.GuessFilter(aMed, &pFilter);
 604         }
 605
 606         if ((pFilter && !nErr) || aFileName == maDropFileName)
 607         {
 608             // The medium may be opened with READ/WRITE. Therefore, we first
 609             // check if it contains a Storage.
 610             SfxMedium* pMedium = new SfxMedium( aFileName,
 611                                                 STREAM_READ | STREAM_NOCREATE);
 612
 613             if (pMedium->IsStorage())
 614             {
 615                 // Now depending on mode:
 616                 // maTlbObjects.SetSelectionMode(MULTIPLE_SELECTION);
 617                 // handover of ownership of pMedium;
 618                 SdDrawDocument* pDropDoc = maTlbObjects.GetBookmarkDoc(pMedium);
 619
 620                 if (pDropDoc)
 621                 {
 622                     maTlbObjects.Clear();
 623                     maDropFileName = aFileName;
 624
 625                     if( !maTlbObjects.IsEqualToDoc( pDropDoc ) )
 626                     {
 627                         // only normal pages
 628                         maTlbObjects.Fill(pDropDoc, (sal_Bool) sal_False, maDropFileName);
 629                         RefreshDocumentLB( &maDropFileName );
 630                     }
 631                 }
 632             }
 633             else
 634             {
 635                 bReturn = sal_False;
 636                 delete pMedium;
 637             }
 638         }
 639         else
 640         {
 641             bReturn = sal_False;
 642         }
 643     }
 644
 645     return (bReturn);
 646 }
 647
 648 // -----------------------------------------------------------------------
 649
 650 void SdNavigatorWin::RefreshDocumentLB( const String* pDocName )
 651 {
 652     sal_uInt16 nPos = 0;
 653
 654     if( pDocName )
 655     {
 656         if( mbDocImported )
 657             maLbDocs.RemoveEntry( 0 );
 658
 659         maLbDocs.InsertEntry( *pDocName, 0 );
 660         mbDocImported = sal_True;
 661     }
 662     else
 663     {
 664         nPos = maLbDocs.GetSelectEntryPos();
 665         if( nPos == LISTBOX_ENTRY_NOTFOUND )
 666             nPos = 0;
 667
 668         String aStr;
 669         if( mbDocImported )
 670             aStr = maLbDocs.GetEntry( 0 );
 671
 672         maLbDocs.Clear();
 673
 674         // delete list of DocInfos
 675          maDocList.clear();
 676
 677         if( mbDocImported )
 678             maLbDocs.InsertEntry( aStr, 0 );
 679
 680         ::sd::DrawDocShell* pCurrentDocShell =
 681               PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
 682         SfxObjectShell* pSfxDocShell = SfxObjectShell::GetFirst(0, sal_False);
 683         while( pSfxDocShell )
 684         {
 685             ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, pSfxDocShell );
 686             if( pDocShell  && !pDocShell->IsInDestruction() && ( pDocShell->GetCreateMode() != SFX_CREATE_MODE_EMBEDDED ) )
 687             {
 688                 NavDocInfo aInfo ;
 689                 aInfo.mpDocShell = pDocShell;
 690
 691                 SfxMedium *pMedium = pDocShell->GetMedium();
 692                 aStr = pMedium ? pMedium->GetName() : OUString();
 693                 if( aStr.Len() )
 694                     aInfo.SetName();
 695                 else
 696                     aInfo.SetName( sal_False );
 697                 // at the moment, we use the name of the shell again (i.e.
 698                 // without path) since Koose thinks it is an error if the path
 699                 // is shown in url notation!
 700                 aStr = pDocShell->GetName();
 701
 702                 maLbDocs.InsertEntry( aStr, LISTBOX_APPEND );
 703
 704                 if( pDocShell == pCurrentDocShell )
 705                     aInfo.SetActive();
 706                 else
 707                     aInfo.SetActive( sal_False );
 708
 709                 maDocList.push_back( aInfo );
 710             }
 711             pSfxDocShell = SfxObjectShell::GetNext( *pSfxDocShell, 0 , sal_False );
 712         }
 713     }
 714     maLbDocs.SelectEntryPos( nPos );
 715 }
 716
 717 //------------------------------------------------------------------------
 718
 719 sal_uInt16 SdNavigatorWin::GetDragTypeSdResId( NavigatorDragType eDT, sal_Bool bImage )
 720 {
 721     switch( eDT )
 722     {
 723         case NAVIGATOR_DRAGTYPE_NONE:
 724                 return( bImage ? 0 : STR_NONE );
 725         case NAVIGATOR_DRAGTYPE_URL:
 726                 return( bImage ? TBI_HYPERLINK : STR_DRAGTYPE_URL );
 727         case NAVIGATOR_DRAGTYPE_EMBEDDED:
 728                 return( bImage ? TBI_EMBEDDED : STR_DRAGTYPE_EMBEDDED );
 729         case NAVIGATOR_DRAGTYPE_LINK:
 730                 return( bImage ? TBI_LINK : STR_DRAGTYPE_LINK );
 731         default: OSL_FAIL( "No resource for DragType available!" );
 732     }
 733     return( 0 );
 734 }
 735
 736 //------------------------------------------------------------------------
 737
 738 NavDocInfo* SdNavigatorWin::GetDocInfo()
 739 {
 740     sal_uInt32 nPos = maLbDocs.GetSelectEntryPos();
 741
 742     if( mbDocImported )
 743     {
 744         if( nPos == 0 )
 745         {
 746             return( NULL );
 747         }
 748         nPos--;
 749     }
 750
 751     return nPos < maDocList.size() ? &(maDocList[ nPos ]) : NULL;
 752 }
 753
 754 /**
 755  * PreNotify
 756  */
 757 long SdNavigatorWin::Notify(NotifyEvent& rNEvt)
 758 {
 759     const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 760     long            nOK = sal_False;
 761
 762     if( pKEvt )
 763     {
 764         if( KEY_ESCAPE == pKEvt->GetKeyCode().GetCode() )
 765         {
 766             if( SdPageObjsTLB::IsInDrag() )
 767             {
 768                 // during drag'n'drop we just stop the drag but do not close the navigator
 769                 nOK = sal_True;
 770             }
 771             else
 772             {
 773                 ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase( mpBindings->GetDispatcher()->GetFrame());
 774                 if( pBase )
 775                 {
 776                     sd::SlideShow::Stop( *pBase );
 777                     // Stopping the slide show may result in a synchronous
 778                     // deletion of the navigator window.  Calling the
 779                     // parents Notify after this is unsafe.  Therefore we
 780                     // return now.
 781                     return sal_True;
 782                 }
 783             }
 784         }
 785     }
 786
 787     if( !nOK )
 788         nOK = Window::Notify( rNEvt );
 789
 790     return( nOK );
 791 }
 792
 793
 794 /**
 795  * catch ESCAPE in order to end show
 796  */
 797 void SdNavigatorWin::KeyInput( const KeyEvent& rKEvt )
 798 {
 799     long nOK = sal_False;
 800
 801     if (rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE)
 802     {
 803         if( SdPageObjsTLB::IsInDrag() )
 804         {
 805             // during drag'n'drop we just stop the drag but do not close the navigator
 806             nOK = sal_True;
 807         }
 808         else
 809         {
 810             ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase( mpBindings->GetDispatcher()->GetFrame());
 811             if(pBase)
 812             {
 813                 ::sd::SlideShow::Stop( *pBase );
 814             }
 815         }
 816     }
 817
 818     if (!nOK)
 819     {
 820         Window::KeyInput(rKEvt);
 821     }
 822 }
 823
 824 void SdNavigatorWin::DataChanged( const DataChangedEvent& rDCEvt )
 825 {
 826     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 827             ApplyImageList();
 828
 829     Window::DataChanged( rDCEvt );
 830 }
 831
 832 void SdNavigatorWin::SetDragImage()
 833 {
 834     maToolbox.SetItemImage( TBI_DRAGTYPE, maToolbox.GetImageList().GetImage( GetDragTypeSdResId( meDragType, sal_True ) ) );
 835 }
 836
 837 void SdNavigatorWin::ApplyImageList()
 838 {
 839
 840     maToolbox.SetImageList( maImageList );
 841     maToolbox.SetItemImage( TBI_SHAPE_FILTER, BitmapEx( SdResId( BMP_GRAPHIC ) ) );
 842
 843     SetDragImage();
 844 }
 845
 846
 847
 848 /**
 849  * ControllerItem for Navigator
 850  */
 851 SdNavigatorControllerItem::SdNavigatorControllerItem(
 852     sal_uInt16 _nId,
 853     SdNavigatorWin* pNavWin,
 854     SfxBindings*    _pBindings,
 855     const SdNavigatorWin::UpdateRequestFunctor& rUpdateRequest)
 856     : SfxControllerItem( _nId, *_pBindings ),
 857       pNavigatorWin( pNavWin ),
 858       maUpdateRequest(rUpdateRequest)
 859 {
 860 }
 861
 862 // -----------------------------------------------------------------------
 863
 864 void SdNavigatorControllerItem::StateChanged( sal_uInt16 nSId,
 865                         SfxItemState eState, const SfxPoolItem* pItem )
 866 {
 867     if( eState >= SFX_ITEM_AVAILABLE && nSId == SID_NAVIGATOR_STATE )
 868     {
 869         const SfxUInt32Item* pStateItem = PTR_CAST( SfxUInt32Item, pItem );
 870         DBG_ASSERT( pStateItem, "SfxUInt16Item expected");
 871         sal_uInt32 nState = pStateItem->GetValue();
 872
 873         // pen
 874         if( nState & NAVBTN_PEN_ENABLED &&
 875             !pNavigatorWin->maToolbox.IsItemEnabled( TBI_PEN ) )
 876             pNavigatorWin->maToolbox.EnableItem( TBI_PEN );
 877         if( nState & NAVBTN_PEN_DISABLED &&
 878             pNavigatorWin->maToolbox.IsItemEnabled( TBI_PEN ) )
 879             pNavigatorWin->maToolbox.EnableItem( TBI_PEN, sal_False );
 880         if( nState & NAVBTN_PEN_CHECKED &&
 881             !pNavigatorWin->maToolbox.IsItemChecked( TBI_PEN ) )
 882             pNavigatorWin->maToolbox.CheckItem( TBI_PEN );
 883         if( nState & NAVBTN_PEN_UNCHECKED &&
 884             pNavigatorWin->maToolbox.IsItemChecked( TBI_PEN ) )
 885             pNavigatorWin->maToolbox.CheckItem( TBI_PEN, sal_False );
 886
 887         // only if doc in LB is the active
 888         NavDocInfo* pInfo = pNavigatorWin->GetDocInfo();
 889         if( pInfo && pInfo->IsActive() )
 890         {
 891             // First
 892             if( nState & NAVBTN_FIRST_ENABLED &&
 893                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_FIRST ) )
 894                 pNavigatorWin->maToolbox.EnableItem( TBI_FIRST );
 895             if( nState & NAVBTN_FIRST_DISABLED &&
 896                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_FIRST ) )
 897                 pNavigatorWin->maToolbox.EnableItem( TBI_FIRST, sal_False );
 898
 899             // Prev
 900             if( nState & NAVBTN_PREV_ENABLED &&
 901                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_PREVIOUS ) )
 902                 pNavigatorWin->maToolbox.EnableItem( TBI_PREVIOUS );
 903             if( nState & NAVBTN_PREV_DISABLED &&
 904                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_PREVIOUS ) )
 905                 pNavigatorWin->maToolbox.EnableItem( TBI_PREVIOUS, sal_False );
 906
 907             // Last
 908             if( nState & NAVBTN_LAST_ENABLED &&
 909                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_LAST ) )
 910                 pNavigatorWin->maToolbox.EnableItem( TBI_LAST );
 911             if( nState & NAVBTN_LAST_DISABLED &&
 912                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_LAST ) )
 913                 pNavigatorWin->maToolbox.EnableItem( TBI_LAST, sal_False );
 914
 915             // Next
 916             if( nState & NAVBTN_NEXT_ENABLED &&
 917                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_NEXT ) )
 918                 pNavigatorWin->maToolbox.EnableItem( TBI_NEXT );
 919             if( nState & NAVBTN_NEXT_DISABLED &&
 920                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_NEXT ) )
 921                 pNavigatorWin->maToolbox.EnableItem( TBI_NEXT, sal_False );
 922
 923             if( nState & NAVTLB_UPDATE )
 924             {
 925                 // InitTlb; is initiated by Slot
 926                 if (maUpdateRequest)
 927                     maUpdateRequest();
 928             }
 929         }
 930     }
 931 }
 932
 933 /**
 934  * ControllerItem for Navigator to show page in TreeLB
 935  */
 936 SdPageNameControllerItem::SdPageNameControllerItem(
 937     sal_uInt16 _nId,
 938     SdNavigatorWin* pNavWin,
 939     SfxBindings*    _pBindings,
 940     const SdNavigatorWin::UpdateRequestFunctor& rUpdateRequest)
 941     : SfxControllerItem( _nId, *_pBindings ),
 942       pNavigatorWin( pNavWin ),
 943       maUpdateRequest(rUpdateRequest)
 944 {
 945 }
 946
 947 // -----------------------------------------------------------------------
 948
 949 void SdPageNameControllerItem::StateChanged( sal_uInt16 nSId,
 950                         SfxItemState eState, const SfxPoolItem* pItem )
 951 {
 952     if( eState >= SFX_ITEM_AVAILABLE && nSId == SID_NAVIGATOR_PAGENAME )
 953     {
 954         // only if doc in LB is the active
 955         NavDocInfo* pInfo = pNavigatorWin->GetDocInfo();
 956         if( pInfo && pInfo->IsActive() )
 957         {
 958             const SfxStringItem* pStateItem = PTR_CAST( SfxStringItem, pItem );
 959             DBG_ASSERT( pStateItem, "SfxStringItem expected");
 960             String aPageName = pStateItem->GetValue();
 961
 962             if( !pNavigatorWin->maTlbObjects.HasSelectedChildren( aPageName ) )
 963             {
 964                 if( pNavigatorWin->maTlbObjects.GetSelectionMode() == MULTIPLE_SELECTION )
 965                 {
 966                     // because otherwise it is always additional select
 967                     pNavigatorWin->maTlbObjects.SelectAll( sal_False );
 968                 }
 969                 pNavigatorWin->maTlbObjects.SelectEntry( aPageName );
 970             }
 971         }
 972     }
 973 }
 974
 975 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */