sd/source/ui/dlg/navigatr.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: navigatr.cxx,v $
  10  * $Revision: 1.40.70.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34
  35 #include <tools/urlobj.hxx>
  36 #include <unotools/localfilehelper.hxx>
  37 #include <sfx2/imgmgr.hxx>
  38 #include <sfx2/fcontnr.hxx>
  39 #include <svtools/eitem.hxx>
  40 #include <svtools/stritem.hxx>
  41 #include <sfx2/docfilt.hxx>
  42 #include <sfx2/docfile.hxx>
  43 #include <svtools/intitem.hxx>
  44 #include <sfx2/dispatch.hxx>
  45 #include <svx/svxids.hrc>
  46 #include <vcl/menu.hxx>
  47
  48 #include <sfx2/viewfrm.hxx>
  49 #include <sfx2/dockwin.hxx>
  50
  51 #include "pres.hxx"
  52 #include "navigatr.hxx"
  53 //#include "navichld.hxx"
  54 #include "navigatr.hrc"
  55 #include "pgjump.hxx"
  56 #include "app.hrc"
  57 #include "strings.hrc"
  58 #include "res_bmp.hrc"
  59 #include "drawdoc.hxx"
  60 #include "DrawDocShell.hxx"
  61 #include "sdresid.hxx"
  62 #include "ViewShell.hxx"
  63 #include "ViewShellBase.hxx"
  64 #include "DrawViewShell.hxx"
  65 #include "slideshow.hxx"
  66 #include "FrameView.hxx"
  67 #include "helpids.h"
  68
  69 namespace {
  70 static const sal_uInt16 nShowNamedShapesFilter=1;
  71 static const sal_uInt16 nShowAllShapesFilter=2;
  72 }
  73
  74 /*************************************************************************
  75 |*      SdNavigatorWin - FloatingWindow
  76 \************************************************************************/
  77
  78 SdNavigatorWin::SdNavigatorWin(
  79     ::Window* pParent,
  80     ::sd::NavigatorChildWindow* pChWinCtxt,
  81     const SdResId& rSdResId,
  82     SfxBindings* pInBindings )
  83 :       ::Window( pParent, rSdResId )
  84 ,       maToolbox        ( this, SdResId( 1 ) )
  85 ,       maTlbObjects( this, SdResId( TLB_OBJECTS ) )
  86 ,       maLbDocs         ( this, SdResId( LB_DOCS ) )
  87 ,       mpChildWinContext( pChWinCtxt )
  88 ,       mbDocImported   ( FALSE )
  89     // Bei Aenderung des DragTypes: SelectionMode der TLB anpassen!
  90 ,       meDragType              ( NAVIGATOR_DRAGTYPE_EMBEDDED )
  91 ,       mpBindings              ( pInBindings )
  92 ,       maImageList             ( SdResId( IL_NAVIGATR ) )
  93 ,       maImageListH    ( SdResId( ILH_NAVIGATR ) )
  94 {
  95     maTlbObjects.SetViewFrame( mpBindings->GetDispatcher()->GetFrame() );
  96
  97     FreeResource();
  98
  99     mpNavigatorCtrlItem = new SdNavigatorControllerItem( SID_NAVIGATOR_STATE, this, mpBindings );
 100     mpPageNameCtrlItem = new SdPageNameControllerItem( SID_NAVIGATOR_PAGENAME, this, mpBindings );
 101     mpDocList = new List();
 102
 103     ApplyImageList(); // load images *before* calculating sizes to get something useful !!!
 104
 105     Size aTbxSize( maToolbox.CalcWindowSizePixel() );
 106     maToolbox.SetOutputSizePixel( aTbxSize );
 107     maToolbox.SetSelectHdl( LINK( this, SdNavigatorWin, SelectToolboxHdl ) );
 108     maToolbox.SetClickHdl( LINK( this, SdNavigatorWin, ClickToolboxHdl ) );
 109     maToolbox.SetDropdownClickHdl( LINK(this, SdNavigatorWin, DropdownClickToolBoxHdl) );
 110     maToolbox.SetItemBits( TBI_DRAGTYPE, maToolbox.GetItemBits( TBI_DRAGTYPE ) | TIB_DROPDOWNONLY );
 111
 112     // Shape filter drop down menu.
 113     maToolbox.SetItemBits(TBI_SHAPE_FILTER,
 114         maToolbox.GetItemBits(TBI_SHAPE_FILTER) | TIB_DROPDOWNONLY);
 115
 116     // TreeListBox
 117     // set position below toolbox
 118     long nListboxYPos = maToolbox.GetPosPixel().Y() + maToolbox.GetSizePixel().Height() + 4;
 119     maTlbObjects.SetPosSizePixel( 0, nListboxYPos, 0, 0, WINDOW_POSSIZE_Y );
 120     maTlbObjects.SetDoubleClickHdl( LINK( this, SdNavigatorWin, ClickObjectHdl ) );
 121     maTlbObjects.SetSelectionMode( SINGLE_SELECTION );
 122     // set focus to listbox, otherwise it is in the toolbox which is only useful
 123     // for keyboard navigation
 124     maTlbObjects.GrabFocus();
 125
 126     // DragTypeListBox
 127     maLbDocs.SetSelectHdl( LINK( this, SdNavigatorWin, SelectDocumentHdl ) );
 128     // set position below treelistbox
 129     nListboxYPos = maTlbObjects.GetPosPixel().Y() + maTlbObjects.GetSizePixel().Height() + 4;
 130     maLbDocs.SetPosSizePixel( 0, nListboxYPos, 0, 0, WINDOW_POSSIZE_Y );
 131
 132     // set min outputsize after all sizes are known
 133     long nFullHeight = nListboxYPos + maLbDocs.GetSizePixel().Height() + 4;
 134     maSize = GetOutputSizePixel();
 135     if( maSize.Height() < nFullHeight )
 136     {
 137         maSize.Height() = nFullHeight;
 138         SetOutputSizePixel( maSize );
 139     }
 140     maMinSize = maSize;
 141     long nMinWidth = 2*maToolbox.GetPosPixel().X() + aTbxSize.Width(); // never clip the toolbox
 142     if( nMinWidth > maMinSize.Width() )
 143         maMinSize.Width() = nMinWidth;
 144     maMinSize.Height() -= 40;
 145     ((SfxDockingWindow*)GetParent())->SetMinOutputSizePixel( maMinSize );
 146
 147     // InitTlb; Wird ueber Slot initiiert
 148     SfxBoolItem aItem( SID_NAVIGATOR_INIT, TRUE );
 149     mpBindings->GetDispatcher()->Execute(
 150         SID_NAVIGATOR_INIT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
 151
 152 }
 153
 154 // -----------------------------------------------------------------------
 155
 156 SdNavigatorWin::~SdNavigatorWin()
 157 {
 158     delete mpNavigatorCtrlItem;
 159     delete mpPageNameCtrlItem;
 160
 161     // Liste der DocInfos loeschen
 162     long nCount = mpDocList->Count();
 163     while( nCount-- )
 164         delete (NavDocInfo*) mpDocList->Remove( (ULONG)0 );
 165
 166     delete mpDocList;
 167 }
 168
 169 // -----------------------------------------------------------------------
 170
 171 void SdNavigatorWin::InitTreeLB( const SdDrawDocument* pDoc )
 172 {
 173     SdDrawDocument* pNonConstDoc = (SdDrawDocument*) pDoc; // const as const can...
 174     ::sd::DrawDocShell* pDocShell = pNonConstDoc->GetDocSh();
 175     String aDocShName( pDocShell->GetName() );
 176     ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 177
 178     // Restore the 'ShowAllShapes' flag from the last time (in this session)
 179     // that the navigator was shown.
 180     if (pViewShell != NULL)
 181     {
 182         ::sd::FrameView* pFrameView = pViewShell->GetFrameView();
 183         if (pFrameView != NULL)
 184             maTlbObjects.SetShowAllShapes(pFrameView->IsNavigatorShowingAllShapes(), false);
 185     }
 186
 187     // Disable the shape filter drop down menu when there is a running slide
 188     // show.
 189     if (pViewShell!=NULL && sd::SlideShow::IsRunning( pViewShell->GetViewShellBase() ))
 190         maToolbox.EnableItem(TBI_SHAPE_FILTER, FALSE);
 191     else
 192         maToolbox.EnableItem(TBI_SHAPE_FILTER);
 193
 194     if( !maTlbObjects.IsEqualToDoc( pDoc ) )
 195     {
 196         String aDocName = pDocShell->GetMedium()->GetName();
 197         maTlbObjects.Clear();
 198         maTlbObjects.Fill( pDoc, (BOOL) FALSE, aDocName ); // Nur normale Seiten
 199
 200         RefreshDocumentLB();
 201         maLbDocs.SelectEntry( aDocShName );
 202     }
 203     else
 204     {
 205         maLbDocs.SetNoSelection();
 206         maLbDocs.SelectEntry( aDocShName );
 207
 208 // auskommentiert um 30246 zu fixen
 209 //                if( maLbDocs.GetSelectEntryCount() == 0 )
 210         {
 211             RefreshDocumentLB();
 212             maLbDocs.SelectEntry( aDocShName );
 213         }
 214     }
 215
 216     SfxViewFrame* pViewFrame = ( ( pViewShell && pViewShell->GetViewFrame() ) ? pViewShell->GetViewFrame() : SfxViewFrame::Current() );
 217     if( pViewFrame )
 218         pViewFrame->GetBindings().Invalidate(SID_NAVIGATOR_PAGENAME, TRUE, TRUE);
 219 }
 220
 221 /*************************************************************************
 222 |*
 223 |* DragType wird in Abhaengigkeit davon gesetzt, ob ein Drag ueberhaupt
 224 |* moeglich ist. Graphiken duerfen beispielsweise unter gewissen Umstaenden
 225 |* nicht gedragt werden (#31038#).
 226 |*
 227 \************************************************************************/
 228
 229 NavigatorDragType SdNavigatorWin::GetNavigatorDragType()
 230 {
 231     NavigatorDragType   eDT = meDragType;
 232     NavDocInfo*         pInfo = GetDocInfo();
 233
 234     if( ( eDT == NAVIGATOR_DRAGTYPE_LINK ) && ( ( pInfo && !pInfo->HasName() ) || !maTlbObjects.IsLinkableSelected() ) )
 235         eDT = NAVIGATOR_DRAGTYPE_NONE;
 236
 237     return( eDT );
 238 }
 239
 240 // -----------------------------------------------------------------------
 241
 242
 243 IMPL_LINK( SdNavigatorWin, SelectToolboxHdl, void *, EMPTYARG )
 244 {
 245     USHORT nId = maToolbox.GetCurItemId();
 246     USHORT nSId = 0;
 247     PageJump ePage = PAGE_NONE;
 248
 249     switch( nId )
 250     {
 251         case TBI_PEN:
 252         {
 253             if( nId == TBI_PEN )
 254             {
 255                 nSId = SID_NAVIGATOR_PEN;
 256             }
 257
 258             if( nSId > 0 )
 259             {
 260                 SfxBoolItem aItem( nSId, TRUE );
 261                 mpBindings->GetDispatcher()->Execute(
 262                     nSId, SFX_CALLMODE_SLOT |SFX_CALLMODE_RECORD, &aItem, 0L );
 263             }
 264         }
 265         break;
 266
 267         case TBI_FIRST:
 268         case TBI_PREVIOUS:
 269         case TBI_NEXT:
 270         case TBI_LAST:
 271         {
 272             if( nId == TBI_FIRST )
 273                 ePage = PAGE_FIRST;
 274             else if( nId == TBI_PREVIOUS )
 275                 ePage = PAGE_PREVIOUS;
 276             else if( nId == TBI_NEXT )
 277                 ePage = PAGE_NEXT;
 278             else if( nId == TBI_LAST )
 279                 ePage = PAGE_LAST;
 280
 281             if( ePage != PAGE_NONE )
 282             {
 283                 SfxUInt16Item aItem( SID_NAVIGATOR_PAGE, (UINT16)ePage );
 284                 mpBindings->GetDispatcher()->Execute(
 285                     SID_NAVIGATOR_PAGE, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L );
 286             }
 287         }
 288         break;
 289     }
 290     return 0;
 291 }
 292
 293 // -----------------------------------------------------------------------
 294
 295
 296 IMPL_LINK( SdNavigatorWin, ClickToolboxHdl, ToolBox*, EMPTYARG )
 297 {
 298     return 0;
 299 }
 300
 301 // -----------------------------------------------------------------------
 302
 303 IMPL_LINK( SdNavigatorWin, DropdownClickToolBoxHdl, ToolBox*, pBox )
 304 {
 305     USHORT nId = maToolbox.GetCurItemId();
 306
 307     switch( nId )
 308     {
 309         case TBI_DRAGTYPE:
 310         {
 311             // Popup-Menu wird in Abhaengigkeit davon erzeugt, ob Dokument
 312             // gespeichert ist oder nicht
 313             PopupMenu *pMenu = new PopupMenu;
 314
 315             for( USHORT nID = NAVIGATOR_DRAGTYPE_URL;
 316                  nID < NAVIGATOR_DRAGTYPE_COUNT;
 317                  nID++ )
 318             {
 319                 USHORT nRId = GetDragTypeSdResId( (NavigatorDragType)nID );
 320                 if( nRId > 0 )
 321                 {
 322                     pMenu->InsertItem( nID, String( SdResId( nRId ) ) );
 323                     pMenu->SetHelpId( nID, HID_SD_NAVIGATOR_MENU1 +
 324                                             nID - NAVIGATOR_DRAGTYPE_URL );
 325                 }
 326
 327             }
 328             NavDocInfo* pInfo = GetDocInfo();
 329
 330             if( ( pInfo && !pInfo->HasName() ) || !maTlbObjects.IsLinkableSelected() )
 331             {
 332                 pMenu->EnableItem( NAVIGATOR_DRAGTYPE_LINK, FALSE );
 333                 pMenu->EnableItem( NAVIGATOR_DRAGTYPE_URL, FALSE );
 334                 meDragType = NAVIGATOR_DRAGTYPE_EMBEDDED;
 335             }
 336
 337             pMenu->CheckItem( (UINT16)meDragType );
 338             pMenu->SetSelectHdl( LINK( this, SdNavigatorWin, MenuSelectHdl ) );
 339
 340             pMenu->Execute( this, maToolbox.GetItemRect( nId ), POPUPMENU_EXECUTE_DOWN );
 341             pBox->EndSelection();
 342             delete pMenu;
 343             //pBox->Invalidate();
 344         }
 345         break;
 346
 347         case TBI_SHAPE_FILTER:
 348         {
 349             PopupMenu *pMenu = new PopupMenu;
 350
 351             pMenu->InsertItem(
 352                 nShowNamedShapesFilter,
 353                 String(SdResId(STR_NAVIGATOR_SHOW_NAMED_SHAPES)));
 354             pMenu->InsertItem(
 355                 nShowAllShapesFilter,
 356                 String(SdResId(STR_NAVIGATOR_SHOW_ALL_SHAPES)));
 357
 358             if (maTlbObjects.GetShowAllShapes())
 359                 pMenu->CheckItem(nShowAllShapesFilter);
 360             else
 361                 pMenu->CheckItem(nShowNamedShapesFilter);
 362             pMenu->SetSelectHdl( LINK( this, SdNavigatorWin, ShapeFilterCallback ) );
 363
 364             pMenu->Execute( this, maToolbox.GetItemRect( nId ), POPUPMENU_EXECUTE_DOWN );
 365             pBox->EndSelection();
 366             delete pMenu;
 367         }
 368         break;
 369     }
 370     return 0;
 371 }
 372
 373 // -----------------------------------------------------------------------
 374
 375 IMPL_LINK( SdNavigatorWin, ClickObjectHdl, void *, EMPTYARG )
 376 {
 377     if( !mbDocImported || maLbDocs.GetSelectEntryPos() != 0 )
 378     {
 379         NavDocInfo* pInfo = GetDocInfo();
 380
 381         // Nur wenn es sich um das aktive Fenster handelt, wird
 382         // auf die Seite gesprungen
 383         if( pInfo && pInfo->IsActive() )
 384         {
 385             String aStr( maTlbObjects.GetSelectEntry() );
 386
 387             if( aStr.Len() > 0 )
 388             {
 389                 SfxStringItem aItem( SID_NAVIGATOR_OBJECT, aStr );
 390                 mpBindings->GetDispatcher()->Execute(
 391                     SID_NAVIGATOR_OBJECT, SFX_CALLMODE_SLOT | SFX_CALLMODE_RECORD, &aItem, 0L );
 392
 393                 // #98821# moved here from SetGetFocusHdl. Reset the
 394                 // focus only if something has been selected in the
 395                 // document.
 396                 SfxViewShell* pCurSh = SfxViewShell::Current();
 397
 398                 if ( pCurSh )
 399                 {
 400                     Window* pShellWnd = pCurSh->GetWindow();
 401                     if ( pShellWnd )
 402                         pShellWnd->GrabFocus();
 403                 }
 404             }
 405         }
 406     }
 407     return( 0L );
 408 }
 409
 410 // -----------------------------------------------------------------------
 411
 412 IMPL_LINK( SdNavigatorWin, SelectDocumentHdl, void *, EMPTYARG )
 413 {
 414     String aStrLb = maLbDocs.GetSelectEntry();
 415     long   nPos = maLbDocs.GetSelectEntryPos();
 416     BOOL   bFound = FALSE;
 417     ::sd::DrawDocShell* pDocShell = NULL;
 418     NavDocInfo* pInfo = GetDocInfo();
 419
 420     // Handelt es sich um ein gedragtes Objekt?
 421     if( mbDocImported && nPos == 0 )
 422     {
 423         // Dokument in TLB aufbauen
 424         InsertFile( aStrLb );
 425     }
 426     else if (pInfo)
 427     {
 428         pDocShell = pInfo->mpDocShell;
 429
 430         bFound = TRUE;
 431     }
 432
 433     if( bFound )
 434     {
 435         SdDrawDocument* pDoc = pDocShell->GetDoc();
 436         if( !maTlbObjects.IsEqualToDoc( pDoc ) )
 437         {
 438             SdDrawDocument* pNonConstDoc = (SdDrawDocument*) pDoc; // const as const can...
 439             ::sd::DrawDocShell* pNCDocShell = pNonConstDoc->GetDocSh();
 440             String aDocName = pNCDocShell->GetMedium()->GetName();
 441             maTlbObjects.Clear();
 442             maTlbObjects.Fill( pDoc, (BOOL) FALSE, aDocName ); // Nur normale Seiten
 443         }
 444     }
 445
 446     // Pruefen, ob Link oder URL moeglich ist
 447     if( ( pInfo && !pInfo->HasName() ) || !maTlbObjects.IsLinkableSelected() || ( meDragType != NAVIGATOR_DRAGTYPE_EMBEDDED ) )
 448     {
 449         meDragType = NAVIGATOR_DRAGTYPE_EMBEDDED;
 450         SetDragImage();
 451     }
 452
 453     return( 0L );
 454 }
 455
 456 /*************************************************************************
 457 |*
 458 |* DrageType wird gesetzt und Image wird entspr. gesetzt.
 459 |* Sollte Handler mit NULL gerufen werden, so wird der Default (URL) gesetzt.
 460 |*
 461 \************************************************************************/
 462
 463 IMPL_LINK( SdNavigatorWin, MenuSelectHdl, Menu *, pMenu )
 464 {
 465     USHORT nMenuId;
 466     if( pMenu )
 467         nMenuId = pMenu->GetCurItemId();
 468     else
 469         nMenuId = NAVIGATOR_DRAGTYPE_URL;
 470
 471     if( nMenuId != USHRT_MAX ) // Notwendig ?
 472     {
 473         NavigatorDragType eDT = (NavigatorDragType) nMenuId;
 474         if( meDragType != eDT )
 475         {
 476             meDragType = eDT;
 477             SetDragImage();
 478
 479             if( meDragType == NAVIGATOR_DRAGTYPE_URL )
 480             {
 481                 // Fix, um Endlosschleife zu unterbinden
 482                 if( maTlbObjects.GetSelectionCount() > 1 )
 483                     maTlbObjects.SelectAll( FALSE );
 484
 485                 maTlbObjects.SetSelectionMode( SINGLE_SELECTION );
 486             }
 487             else
 488                 maTlbObjects.SetSelectionMode( MULTIPLE_SELECTION );
 489         }
 490     }
 491     return( 0 );
 492 }
 493
 494
 495
 496
 497 IMPL_LINK( SdNavigatorWin, ShapeFilterCallback, Menu *, pMenu )
 498 {
 499     if (pMenu != NULL)
 500     {
 501         bool bShowAllShapes (maTlbObjects.GetShowAllShapes());
 502         USHORT nMenuId (pMenu->GetCurItemId());
 503         switch (nMenuId)
 504         {
 505             case nShowNamedShapesFilter:
 506                 bShowAllShapes = false;
 507                 break;
 508
 509             case nShowAllShapesFilter:
 510                 bShowAllShapes = true;
 511                 break;
 512
 513             default:
 514                 OSL_ENSURE(
 515                     false, "SdNavigatorWin::ShapeFilterCallback called for unknown menu entry");
 516                 break;
 517         }
 518
 519         maTlbObjects.SetShowAllShapes(bShowAllShapes, true);
 520
 521         // Remember the selection in the FrameView.
 522         NavDocInfo* pInfo = GetDocInfo();
 523         if (pInfo != NULL)
 524         {
 525             ::sd::DrawDocShell* pDocShell = pInfo->mpDocShell;
 526             if (pDocShell != NULL)
 527             {
 528                 ::sd::ViewShell* pViewShell = pDocShell->GetViewShell();
 529                 if (pViewShell != NULL)
 530                 {
 531                     ::sd::FrameView* pFrameView = pViewShell->GetFrameView();
 532                     if (pFrameView != NULL)
 533                     {
 534                         pFrameView->SetIsNavigatorShowingAllShapes(bShowAllShapes);
 535                     }
 536                 }
 537             }
 538         }
 539     }
 540
 541     return 0;
 542 }
 543
 544 // -----------------------------------------------------------------------
 545
 546 void SdNavigatorWin::Resize()
 547 {
 548     Size aWinSize( GetOutputSizePixel() );
 549     if( aWinSize.Height() >= maMinSize.Height() )
 550         //aWinSize.Width() >= maMinSize.Width() )
 551     {
 552         Size aDiffSize;
 553         aDiffSize.Width() = aWinSize.Width() - maSize.Width();
 554         aDiffSize.Height() = aWinSize.Height() - maSize.Height();
 555
 556         // Umgroessern der Toolbox
 557         Size aObjSize( maToolbox.GetOutputSizePixel() );
 558         aObjSize.Width() += aDiffSize.Width();
 559         maToolbox.SetOutputSizePixel( aObjSize );
 560
 561         // Umgroessern der TreeLB
 562         aObjSize = maTlbObjects.Control::GetOutputSizePixel();
 563         aObjSize.Width() += aDiffSize.Width();
 564         aObjSize.Height() += aDiffSize.Height();
 565         maTlbObjects.SetOutputSizePixel( aObjSize );
 566
 567         Point aPt( 0, aDiffSize.Height() );
 568
 569         // Verschieben der anderen Controls (DocumentLB)
 570         maLbDocs.Hide();
 571         aObjSize = maLbDocs.GetOutputSizePixel();
 572         aObjSize.Width() += aDiffSize.Width();
 573         maLbDocs.SetPosPixel( maLbDocs.GetPosPixel() + aPt );
 574         maLbDocs.SetOutputSizePixel( aObjSize );
 575         maLbDocs.Show();
 576
 577         maSize = aWinSize;
 578     }
 579     Window::Resize();
 580 }
 581
 582 // -----------------------------------------------------------------------
 583
 584 BOOL SdNavigatorWin::InsertFile(const String& rFileName)
 585 {
 586     INetURLObject       aURL( rFileName );
 587     BOOL                        bReturn = TRUE;
 588
 589     if( aURL.GetProtocol() == INET_PROT_NOT_VALID )
 590     {
 591         String aURLStr;
 592         ::utl::LocalFileHelper::ConvertPhysicalNameToURL( rFileName, aURLStr );
 593         aURL = INetURLObject( aURLStr );
 594     }
 595
 596     // get adjusted FileName
 597     String aFileName( aURL.GetMainURL( INetURLObject::NO_DECODE ) );
 598
 599     if (!aFileName.Len())
 600     {
 601         /**********************************************************************
 602         * Wieder aktuelles Dokument anzeigen
 603         **********************************************************************/
 604         maDropFileName = aFileName;
 605     }
 606     else
 607     {
 608         /**********************************************************************
 609         * Hineingedraggtes Dokument anzeigen
 610         **********************************************************************/
 611         const SfxFilter* pFilter = NULL;
 612         ErrCode nErr = 0;
 613
 614         if (aFileName != maDropFileName)
 615         {
 616             SfxMedium aMed(aFileName, (STREAM_READ | STREAM_SHARE_DENYNONE), FALSE);
 617             SfxFilterMatcher aMatch( String::CreateFromAscii("simpress") );
 618             aMed.UseInteractionHandler( TRUE );
 619             nErr = aMatch.GuessFilter(aMed, &pFilter);
 620         }
 621
 622         if ((pFilter && !nErr) || aFileName == maDropFileName)
 623         {
 624             // Das Medium muss ggf. mit READ/WRITE geoeffnet werden, daher wird
 625             // ersteinmal nachgeschaut, ob es einen Storage enthaelt
 626             SfxMedium* pMedium = new SfxMedium( aFileName,
 627                                                 STREAM_READ | STREAM_NOCREATE,
 628                                                 TRUE);                            // Download
 629
 630             if (pMedium->IsStorage())
 631             {
 632                 // Jetzt modusabhaengig:
 633                 // maTlbObjects.SetSelectionMode(MULTIPLE_SELECTION);
 634                 // Eigentuemeruebergabe von pMedium;
 635                 SdDrawDocument* pDropDoc = maTlbObjects.GetBookmarkDoc(pMedium);
 636
 637                 if (pDropDoc)
 638                 {
 639                     maTlbObjects.Clear();
 640                     maDropFileName = aFileName;
 641
 642                     if( !maTlbObjects.IsEqualToDoc( pDropDoc ) )
 643                     {
 644                         // Nur normale Seiten
 645                         maTlbObjects.Fill(pDropDoc, (BOOL) FALSE, maDropFileName);
 646                         RefreshDocumentLB( &maDropFileName );
 647                     }
 648                 }
 649             }
 650             else
 651             {
 652                 bReturn = FALSE;
 653                 delete pMedium;
 654             }
 655         }
 656         else
 657         {
 658             bReturn = FALSE;
 659         }
 660     }
 661
 662     return (bReturn);
 663 }
 664
 665 // -----------------------------------------------------------------------
 666
 667 void SdNavigatorWin::RefreshDocumentLB( const String* pDocName )
 668 {
 669     USHORT nPos = 0;
 670
 671     if( pDocName )
 672     {
 673         if( mbDocImported )
 674             maLbDocs.RemoveEntry( 0 );
 675
 676         maLbDocs.InsertEntry( *pDocName, 0 );
 677         mbDocImported = TRUE;
 678     }
 679     else
 680     {
 681         nPos = maLbDocs.GetSelectEntryPos();
 682         if( nPos == LISTBOX_ENTRY_NOTFOUND )
 683             nPos = 0;
 684
 685         String aStr;
 686         if( mbDocImported )
 687             aStr = maLbDocs.GetEntry( 0 );
 688
 689         maLbDocs.Clear();
 690
 691         // Liste der DocInfos loeschen
 692         long nCount = mpDocList->Count();
 693         while( nCount-- )
 694             delete (NavDocInfo*) mpDocList->Remove( (ULONG)0 );
 695
 696         if( mbDocImported )
 697             maLbDocs.InsertEntry( aStr, 0 );
 698
 699         ::sd::DrawDocShell* pCurrentDocShell =
 700               PTR_CAST(::sd::DrawDocShell, SfxObjectShell::Current() );
 701         SfxObjectShell* pSfxDocShell = SfxObjectShell::GetFirst(0, FALSE);
 702         while( pSfxDocShell )
 703         {
 704             ::sd::DrawDocShell* pDocShell = PTR_CAST(::sd::DrawDocShell, pSfxDocShell );
 705             if( pDocShell  && !pDocShell->IsInDestruction() && ( pDocShell->GetCreateMode() != SFX_CREATE_MODE_EMBEDDED ) )
 706             {
 707                 NavDocInfo* pInfo = new NavDocInfo();
 708                 pInfo->mpDocShell = pDocShell;
 709
 710                 aStr = pDocShell->GetMedium()->GetName();
 711                 if( aStr.Len() )
 712                     pInfo->SetName();
 713                 else
 714                     pInfo->SetName( FALSE );
 715                 // z.Z. wird wieder der Name der Shell genommen (also ohne Pfad)
 716                 // da Koose es als Fehler ansieht, wenn er Pfad in URL-Notation
 717                 // angezeigt wird!
 718                 aStr = pDocShell->GetName();
 719
 720                 maLbDocs.InsertEntry( aStr, LISTBOX_APPEND );
 721
 722                 //
 723                 if( pDocShell == pCurrentDocShell )
 724                     pInfo->SetActive();
 725                 else
 726                     pInfo->SetActive( FALSE );
 727
 728                 mpDocList->Insert( pInfo, LIST_APPEND );
 729             }
 730             pSfxDocShell = SfxObjectShell::GetNext( *pSfxDocShell, 0 , FALSE );
 731         }
 732     }
 733     maLbDocs.SelectEntryPos( nPos );
 734 }
 735
 736 //------------------------------------------------------------------------
 737
 738 USHORT SdNavigatorWin::GetDragTypeSdResId( NavigatorDragType eDT, BOOL bImage )
 739 {
 740     switch( eDT )
 741     {
 742         case NAVIGATOR_DRAGTYPE_NONE:
 743                 return( bImage ? 0 : STR_NONE );
 744         case NAVIGATOR_DRAGTYPE_URL:
 745                 return( bImage ? TBI_HYPERLINK : STR_DRAGTYPE_URL );
 746         case NAVIGATOR_DRAGTYPE_EMBEDDED:
 747                 return( bImage ? TBI_EMBEDDED : STR_DRAGTYPE_EMBEDDED );
 748         case NAVIGATOR_DRAGTYPE_LINK:
 749                 return( bImage ? TBI_LINK : STR_DRAGTYPE_LINK );
 750         default: DBG_ERROR( "Keine Resource fuer DragType vorhanden!" );
 751     }
 752     return( 0 );
 753 }
 754
 755 //------------------------------------------------------------------------
 756
 757 NavDocInfo* SdNavigatorWin::GetDocInfo()
 758 {
 759     long nPos = maLbDocs.GetSelectEntryPos();
 760
 761     if( mbDocImported )
 762     {
 763         if( nPos == 0 )
 764         {
 765             return( NULL );
 766         }
 767         nPos--;
 768     }
 769
 770     NavDocInfo* pInfo = (NavDocInfo*)mpDocList->GetObject( nPos );
 771
 772     return( pInfo );
 773 }
 774
 775 /*************************************************************************
 776 |*
 777 |* PreNotify
 778 |*
 779 \************************************************************************/
 780
 781 long SdNavigatorWin::Notify(NotifyEvent& rNEvt)
 782 {
 783     const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
 784     long                        nOK = FALSE;
 785
 786     if( pKEvt )
 787     {
 788         if( KEY_ESCAPE == pKEvt->GetKeyCode().GetCode() )
 789         {
 790             if( SdPageObjsTLB::IsInDrag() )
 791             {
 792                 // during drag'n'drop we just stop the drag but do not close the navigator
 793                 nOK = TRUE;
 794             }
 795             else
 796             {
 797                 ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase( mpBindings->GetDispatcher()->GetFrame());
 798                 if( pBase )
 799                 {
 800                     sd::SlideShow::Stop( *pBase );
 801                     // Stopping the slide show may result in a synchronous
 802                     // deletion of the navigator window.  Calling the
 803                     // parents Notify after this is unsafe.  Therefore we
 804                     // return now.
 805                     return TRUE;
 806                 }
 807             }
 808         }
 809     }
 810
 811     if( !nOK )
 812         nOK = Window::Notify( rNEvt );
 813
 814     return( nOK );
 815 }
 816
 817
 818 /*************************************************************************
 819 |*
 820 |* KeyInput: ESCAPE abfangen, um Show zu beenden
 821 |*
 822 \************************************************************************/
 823
 824 void SdNavigatorWin::KeyInput( const KeyEvent& rKEvt )
 825 {
 826     long nOK = FALSE;
 827
 828     if (rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE)
 829     {
 830         if( SdPageObjsTLB::IsInDrag() )
 831         {
 832             // during drag'n'drop we just stop the drag but do not close the navigator
 833             nOK = TRUE;
 834         }
 835         else
 836         {
 837             ::sd::ViewShellBase* pBase = ::sd::ViewShellBase::GetViewShellBase( mpBindings->GetDispatcher()->GetFrame());
 838             if(pBase)
 839             {
 840                 ::sd::SlideShow::Stop( *pBase );
 841             }
 842         }
 843     }
 844
 845     if (!nOK)
 846     {
 847         Window::KeyInput(rKEvt);
 848     }
 849 }
 850
 851 void SdNavigatorWin::DataChanged( const DataChangedEvent& rDCEvt )
 852 {
 853     if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) )
 854             ApplyImageList();
 855
 856     Window::DataChanged( rDCEvt );
 857 }
 858
 859 void SdNavigatorWin::SetDragImage()
 860 {
 861     maToolbox.SetItemImage( TBI_DRAGTYPE, maToolbox.GetImageList().GetImage( GetDragTypeSdResId( meDragType, TRUE ) ) );
 862 }
 863
 864 void SdNavigatorWin::ApplyImageList()
 865 {
 866     const bool bHighContrast = GetDisplayBackground().GetColor().IsDark() != 0;
 867
 868     maToolbox.SetImageList( bHighContrast ? maImageListH : maImageList );
 869
 870     maToolbox.SetItemImage(TBI_SHAPE_FILTER, BitmapEx(SdResId( bHighContrast ? BMP_GRAPHIC_H : BMP_GRAPHIC)));
 871
 872     SetDragImage();
 873 }
 874
 875
 876
 877 /*************************************************************************
 878 |*
 879 |* ControllerItem fuer Navigator
 880 |*
 881 \************************************************************************/
 882
 883 SdNavigatorControllerItem::SdNavigatorControllerItem( USHORT _nId,
 884                                 SdNavigatorWin* pNavWin,
 885                                 SfxBindings*    _pBindings) :
 886     SfxControllerItem( _nId, *_pBindings ),
 887     pNavigatorWin( pNavWin )
 888 {
 889 }
 890
 891 // -----------------------------------------------------------------------
 892
 893 void SdNavigatorControllerItem::StateChanged( USHORT nSId,
 894                         SfxItemState eState, const SfxPoolItem* pItem )
 895 {
 896     if( eState >= SFX_ITEM_AVAILABLE && nSId == SID_NAVIGATOR_STATE )
 897     {
 898         const SfxUInt32Item* pStateItem = PTR_CAST( SfxUInt32Item, pItem );
 899         DBG_ASSERT( pStateItem, "SfxUInt16Item erwartet");
 900         UINT32 nState = pStateItem->GetValue();
 901
 902         // Stift
 903         if( nState & NAVBTN_PEN_ENABLED &&
 904             !pNavigatorWin->maToolbox.IsItemEnabled( TBI_PEN ) )
 905             pNavigatorWin->maToolbox.EnableItem( TBI_PEN );
 906         if( nState & NAVBTN_PEN_DISABLED &&
 907             pNavigatorWin->maToolbox.IsItemEnabled( TBI_PEN ) )
 908             pNavigatorWin->maToolbox.EnableItem( TBI_PEN, FALSE );
 909         if( nState & NAVBTN_PEN_CHECKED &&
 910             !pNavigatorWin->maToolbox.IsItemChecked( TBI_PEN ) )
 911             pNavigatorWin->maToolbox.CheckItem( TBI_PEN );
 912         if( nState & NAVBTN_PEN_UNCHECKED &&
 913             pNavigatorWin->maToolbox.IsItemChecked( TBI_PEN ) )
 914             pNavigatorWin->maToolbox.CheckItem( TBI_PEN, FALSE );
 915
 916         // Nur wenn Doc in LB das Aktive ist
 917         NavDocInfo* pInfo = pNavigatorWin->GetDocInfo();
 918         if( pInfo && pInfo->IsActive() )
 919         {
 920             // First
 921             if( nState & NAVBTN_FIRST_ENABLED &&
 922                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_FIRST ) )
 923                 pNavigatorWin->maToolbox.EnableItem( TBI_FIRST );
 924             if( nState & NAVBTN_FIRST_DISABLED &&
 925                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_FIRST ) )
 926                 pNavigatorWin->maToolbox.EnableItem( TBI_FIRST, FALSE );
 927
 928             // Prev
 929             if( nState & NAVBTN_PREV_ENABLED &&
 930                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_PREVIOUS ) )
 931                 pNavigatorWin->maToolbox.EnableItem( TBI_PREVIOUS );
 932             if( nState & NAVBTN_PREV_DISABLED &&
 933                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_PREVIOUS ) )
 934                 pNavigatorWin->maToolbox.EnableItem( TBI_PREVIOUS, FALSE );
 935
 936             // Last
 937             if( nState & NAVBTN_LAST_ENABLED &&
 938                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_LAST ) )
 939                 pNavigatorWin->maToolbox.EnableItem( TBI_LAST );
 940             if( nState & NAVBTN_LAST_DISABLED &&
 941                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_LAST ) )
 942                 pNavigatorWin->maToolbox.EnableItem( TBI_LAST, FALSE );
 943
 944             // Next
 945             if( nState & NAVBTN_NEXT_ENABLED &&
 946                 !pNavigatorWin->maToolbox.IsItemEnabled( TBI_NEXT ) )
 947                 pNavigatorWin->maToolbox.EnableItem( TBI_NEXT );
 948             if( nState & NAVBTN_NEXT_DISABLED &&
 949                 pNavigatorWin->maToolbox.IsItemEnabled( TBI_NEXT ) )
 950                 pNavigatorWin->maToolbox.EnableItem( TBI_NEXT, FALSE );
 951
 952             if( nState & NAVTLB_UPDATE )
 953             {
 954                 // InitTlb; Wird ueber Slot initiiert
 955                 SfxBoolItem aItem( SID_NAVIGATOR_INIT, TRUE );
 956                 GetBindings().GetDispatcher()->Execute(
 957                     SID_NAVIGATOR_INIT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L );
 958             }
 959         }
 960     }
 961 }
 962
 963 /*************************************************************************
 964 |*
 965 |* ControllerItem fuer Navigator, um die Seite in der TreeLB anzuzeigen
 966 |*
 967 \************************************************************************/
 968
 969 SdPageNameControllerItem::SdPageNameControllerItem( USHORT _nId,
 970                                 SdNavigatorWin* pNavWin,
 971                                 SfxBindings*    _pBindings) :
 972     SfxControllerItem( _nId, *_pBindings ),
 973     pNavigatorWin( pNavWin )
 974 {
 975 }
 976
 977 // -----------------------------------------------------------------------
 978
 979 void SdPageNameControllerItem::StateChanged( USHORT nSId,
 980                         SfxItemState eState, const SfxPoolItem* pItem )
 981 {
 982     if( eState >= SFX_ITEM_AVAILABLE && nSId == SID_NAVIGATOR_PAGENAME )
 983     {
 984         // Nur wenn Doc in LB das Aktive ist
 985         NavDocInfo* pInfo = pNavigatorWin->GetDocInfo();
 986         if( pInfo && pInfo->IsActive() )
 987         {
 988             const SfxStringItem* pStateItem = PTR_CAST( SfxStringItem, pItem );
 989             DBG_ASSERT( pStateItem, "SfxStringItem erwartet");
 990             String aPageName = pStateItem->GetValue();
 991
 992             if( !pNavigatorWin->maTlbObjects.HasSelectedChilds( aPageName ) )
 993             {
 994                 if( pNavigatorWin->maTlbObjects.GetSelectionMode() == MULTIPLE_SELECTION )
 995                 {
 996                     // Weil sonst immer dazuselektiert wird
 997                     pNavigatorWin->maTlbObjects.SelectAll( FALSE );
 998                 }
 999                 pNavigatorWin->maTlbObjects.SelectEntry( aPageName );
1000             }
1001         }
1002     }
1003 }