LCOV - code coverage report
Current view: top level - sd/source/ui/view - outlnvsh.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 13 902 1.4 %
Date: 2015-06-13 12:38:46 Functions: 6 54 11.1 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "OutlineViewShell.hxx"
      21             : 
      22             : #include "ViewShellImplementation.hxx"
      23             : #include "helpids.h"
      24             : #include "app.hrc"
      25             : #include <svx/hyperdlg.hxx>
      26             : #include <svx/zoomslideritem.hxx>
      27             : 
      28             : #include <sfx2/infobar.hxx>
      29             : #include <sfx2/objface.hxx>
      30             : #include <sot/exchange.hxx>
      31             : #include <svx/ruler.hxx>
      32             : #include <sfx2/zoomitem.hxx>
      33             : #include <editeng/eeitem.hxx>
      34             : #include <editeng/flditem.hxx>
      35             : #include <sfx2/shell.hxx>
      36             : #include <sfx2/templdlg.hxx>
      37             : #include <sfx2/viewfac.hxx>
      38             : #include <sfx2/request.hxx>
      39             : #include <svx/hlnkitem.hxx>
      40             : #include <svx/svdotext.hxx>
      41             : #include <sfx2/dispatch.hxx>
      42             : #include <vcl/scrbar.hxx>
      43             : #include <vcl/settings.hxx>
      44             : 
      45             : #include <svl/whiter.hxx>
      46             : #include <editeng/editstat.hxx>
      47             : #include <svl/itempool.hxx>
      48             : #include <sfx2/tplpitem.hxx>
      49             : #include <sfx2/sidebar/SidebarChildWindow.hxx>
      50             : #include <sfx2/sidebar/EnumContext.hxx>
      51             : #include <svx/svdorect.hxx>
      52             : #include <sot/formats.hxx>
      53             : #include <com/sun/star/linguistic2/XThesaurus.hpp>
      54             : #include <com/sun/star/i18n/TransliterationModules.hpp>
      55             : #include <com/sun/star/i18n/TransliterationModulesExtra.hpp>
      56             : #include <editeng/unolingu.hxx>
      57             : #include <comphelper/processfactory.hxx>
      58             : #include <editeng/outlobj.hxx>
      59             : #include <svl/cjkoptions.hxx>
      60             : #include <svtools/cliplistener.hxx>
      61             : #include <svl/srchitem.hxx>
      62             : #include <editeng/editobj.hxx>
      63             : #include "fubullet.hxx"
      64             : #include "optsitem.hxx"
      65             : 
      66             : #include "strings.hrc"
      67             : #include "glob.hrc"
      68             : #include "res_bmp.hrc"
      69             : #include "Outliner.hxx"
      70             : #include "Window.hxx"
      71             : #include "TextObjectBar.hxx"
      72             : #include "drawdoc.hxx"
      73             : #include "sdresid.hxx"
      74             : #include "sdpage.hxx"
      75             : #include "fuoltext.hxx"
      76             : #include "FrameView.hxx"
      77             : #include "zoomlist.hxx"
      78             : #include "stlsheet.hxx"
      79             : #include "slideshow.hxx"
      80             : #include "SdUnoOutlineView.hxx"
      81             : #include "SpellDialogChildWindow.hxx"
      82             : 
      83             : #include "AccessibleOutlineView.hxx"
      84             : #include "ViewShellBase.hxx"
      85             : #include "ViewShellManager.hxx"
      86             : #include "DrawController.hxx"
      87             : #include "framework/FrameworkHelper.hxx"
      88             : 
      89             : #include <boost/scoped_ptr.hpp>
      90             : 
      91             : using namespace ::com::sun::star;
      92             : using namespace ::com::sun::star::uno;
      93             : using namespace ::com::sun::star::lang;
      94             : using namespace ::com::sun::star::linguistic2;
      95             : 
      96             : using namespace sd;
      97             : 
      98             : #define OutlineViewShell
      99             : #include "sdslots.hxx"
     100             : 
     101             : namespace sd {
     102             : 
     103             : #define MIN_ZOOM           10      // minimum zoom factor
     104             : #define MAX_ZOOM         1000      // maximum zoom factor
     105             : 
     106             : /**
     107             :  * Declare SFX-Slotmap and standard interface
     108             :  */
     109         210 : SFX_IMPL_INTERFACE(OutlineViewShell, SfxShell)
     110             : 
     111          21 : void OutlineViewShell::InitInterface_Impl()
     112             : {
     113          21 :     GetStaticInterface()->RegisterPopupMenu(SdResId(RID_OUTLINE_POPUP));
     114             : 
     115             :     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_TOOLS | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_FULLSCREEN | SFX_VISIBILITY_SERVER,
     116          21 :                                             RID_OUTLINE_TOOLBOX);
     117             :     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_APPLICATION | SFX_VISIBILITY_DESKTOP | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_CLIENT | SFX_VISIBILITY_VIEWER | SFX_VISIBILITY_READONLYDOC,
     118          21 :                                             RID_DRAW_VIEWER_TOOLBOX);
     119             : 
     120          21 :     GetStaticInterface()->RegisterChildWindow(SfxInfoBarContainerChild::GetChildWindowId());
     121          21 :     GetStaticInterface()->RegisterChildWindow(SvxHlinkDlgWrapper::GetChildWindowId());
     122          21 :     GetStaticInterface()->RegisterChildWindow(::sd::SpellDialogChildWindow::GetChildWindowId());
     123          21 :     GetStaticInterface()->RegisterChildWindow(SID_SEARCH_DLG);
     124          21 :     GetStaticInterface()->RegisterChildWindow(::sfx2::sidebar::SidebarChildWindow::GetChildWindowId());
     125          21 : }
     126             : 
     127         786 : TYPEINIT1( OutlineViewShell, ViewShell );
     128             : 
     129             : /**
     130             :  * common initialization part of both constructors
     131             :  */
     132           0 : void OutlineViewShell::Construct(DrawDocShell* )
     133             : {
     134           0 :     bool bModified = GetDoc()->IsChanged();
     135             : 
     136           0 :     meShellType = ST_OUTLINE;
     137           0 :     Size aSize(29700, 21000);
     138           0 :     Point aWinPos (0, 0);
     139           0 :     Point aViewOrigin(0, 0);
     140           0 :     GetActiveWindow()->SetMinZoomAutoCalc(false);
     141           0 :     GetActiveWindow()->SetMinZoom( MIN_ZOOM );
     142           0 :     GetActiveWindow()->SetMaxZoom( MAX_ZOOM );
     143           0 :     InitWindows(aViewOrigin, aSize, aWinPos);
     144           0 :     pOlView = new OutlineView(*GetDocSh(), GetActiveWindow(), *this);
     145           0 :     mpView = pOlView;            // Pointer of base class ViewShell
     146             : 
     147           0 :     SetPool( &GetDoc()->GetPool() );
     148             : 
     149           0 :     SetZoom(69);
     150             : 
     151             :     // Apply settings of FrameView
     152           0 :     ReadFrameViewData(mpFrameView);
     153             : 
     154           0 :     ::Outliner& rOutl = pOlView->GetOutliner();
     155           0 :     rOutl.SetUpdateMode(true);
     156             : 
     157           0 :     if (!bModified)
     158             :     {
     159           0 :         rOutl.ClearModifyFlag();
     160             :     }
     161             : 
     162           0 :     pLastPage = GetActualPage();
     163             : 
     164           0 :     SetName( OUString( "OutlineViewShell" ) );
     165             : 
     166           0 :     SetHelpId( SD_IF_SDOUTLINEVIEWSHELL );
     167           0 :     GetActiveWindow()->SetHelpId( HID_SDOUTLINEVIEWSHELL );
     168           0 :     GetActiveWindow()->SetUniqueId( HID_SDOUTLINEVIEWSHELL );
     169           0 : }
     170             : 
     171           0 : Reference<drawing::XDrawSubController> OutlineViewShell::CreateSubController()
     172             : {
     173           0 :     Reference<drawing::XDrawSubController> xSubController;
     174             : 
     175           0 :     if (IsMainViewShell())
     176             :     {
     177             :         // Create uno sub controller for the main view shell.
     178           0 :         xSubController = Reference<drawing::XDrawSubController>(
     179             :             new SdUnoOutlineView (
     180           0 :                 *this));
     181             :     }
     182             : 
     183           0 :     return xSubController;
     184             : }
     185             : 
     186             : /**
     187             :  * Default constructor, windows must not center themselves automatically
     188             :  */
     189           0 : OutlineViewShell::OutlineViewShell (
     190             :     SfxViewFrame* pFrame,
     191             :     ViewShellBase& rViewShellBase,
     192             :     vcl::Window* pParentWindow,
     193             :     FrameView* pFrameViewArgument)
     194             :     : ViewShell(pFrame, pParentWindow, rViewShellBase),
     195             :       pOlView(NULL),
     196             :       pLastPage( NULL ),
     197             :       pClipEvtLstnr(NULL),
     198             :       bPastePossible(false),
     199           0 :       mbInitialized(false)
     200             : 
     201             : {
     202           0 :     if (pFrameViewArgument != NULL)
     203           0 :         mpFrameView = pFrameViewArgument;
     204             :     else
     205           0 :         mpFrameView = new FrameView(GetDoc());
     206             : 
     207           0 :     mpFrameView->Connect();
     208             : 
     209           0 :     Construct(GetDocSh());
     210             : 
     211           0 :     SetContextName(sfx2::sidebar::EnumContext::GetContextName(sfx2::sidebar::EnumContext::Context_OutlineText));
     212             : 
     213           0 :     m_StrOldPageName.clear();
     214             : 
     215           0 :     doShow();
     216           0 : }
     217             : 
     218           0 : OutlineViewShell::~OutlineViewShell()
     219             : {
     220           0 :     DisposeFunctions();
     221             : 
     222           0 :     delete pOlView;
     223             : 
     224           0 :     mpFrameView->Disconnect();
     225             : 
     226           0 :     if ( pClipEvtLstnr )
     227             :     {
     228           0 :         pClipEvtLstnr->AddRemoveListener( GetActiveWindow(), false );
     229           0 :         pClipEvtLstnr->ClearCallbackLink();     // prevent callback if another thread is waiting
     230           0 :         pClipEvtLstnr->release();
     231             :     }
     232           0 : }
     233             : 
     234           0 : void OutlineViewShell::Shutdown()
     235             : {
     236           0 :     ViewShell::Shutdown();
     237             : 
     238           0 :     PrepareClose();
     239           0 : }
     240             : 
     241             : /**
     242             :  * Paint method: the event gets forwarded from pWindow to the Viewshell
     243             :  * and the current function
     244             :  */
     245           0 : void OutlineViewShell::Paint(const Rectangle& rRect, ::sd::Window* pWin)
     246             : {
     247           0 :     if (pOlView)
     248             :     {
     249           0 :         pOlView->Paint(rRect, pWin);
     250             :     }
     251           0 : }
     252             : 
     253           0 : void OutlineViewShell::ArrangeGUIElements ()
     254             : {
     255             :     // Retrieve the current size (thickness) of the scroll bars.  That is
     256             :     // the width of the vertical and the height of the horizontal scroll
     257             :     // bar.
     258             :     int nScrollBarSize =
     259           0 :         GetParentWindow()->GetSettings().GetStyleSettings().GetScrollBarSize();
     260           0 :     maScrBarWH = Size (nScrollBarSize, nScrollBarSize);
     261             : 
     262           0 :     ViewShell::ArrangeGUIElements ();
     263             : 
     264           0 :     ::sd::Window* pWindow = mpContentWindow.get();
     265           0 :     if (pWindow != NULL)
     266             :     {
     267           0 :         pWindow->SetMinZoomAutoCalc(false);
     268             : 
     269             :         // change OuputArea of the OutlinerView
     270           0 :         OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
     271             : 
     272           0 :         Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
     273             : 
     274           0 :         aWin = pWindow->PixelToLogic(aWin);
     275           0 :         pOutlinerView->SetOutputArea(aWin);
     276             : 
     277           0 :         Rectangle aVis = pOutlinerView->GetVisArea();
     278             : 
     279             :         Rectangle aText = Rectangle(Point(0,0),
     280           0 :             Size(pOlView->GetPaperWidth(),
     281           0 :                 pOlView->GetOutliner().GetTextHeight()));
     282           0 :         if (aWin.GetHeight() > aText.Bottom())
     283           0 :             aText.Bottom() = aWin.GetHeight();
     284             : 
     285           0 :         if (!aWin.IsEmpty())            // not when opening
     286             :         {
     287           0 :             InitWindows(Point(0,0), aText.GetSize(), Point(aVis.TopLeft()));
     288           0 :             UpdateScrollBars();
     289             :         }
     290             :     }
     291           0 : }
     292             : 
     293             : /**
     294             :  * Handle SfxRequest for the Controller
     295             :  */
     296           0 : void OutlineViewShell::ExecCtrl(SfxRequest &rReq)
     297             : {
     298           0 :     sal_uInt16 nSlot = rReq.GetSlot();
     299           0 :     switch ( nSlot )
     300             :     {
     301             :         case SID_MAIL_SCROLLBODY_PAGEDOWN:
     302             :         {
     303           0 :             ExecReq( rReq );
     304           0 :             break;
     305             :         }
     306             : 
     307             :         case SID_OPT_LOCALE_CHANGED:
     308             :         {
     309           0 :             pOlView->GetOutliner().UpdateFields();
     310           0 :             UpdatePreview( GetActualPage() );
     311           0 :             rReq.Done();
     312           0 :             break;
     313             :         }
     314             : 
     315             :         default:
     316           0 :         break;
     317             :     }
     318           0 : }
     319             : 
     320             : /**
     321             :  * Activate(): during the first invocation the fields get updated
     322             :  */
     323           0 : void OutlineViewShell::Activate( bool bIsMDIActivate )
     324             : {
     325           0 :     if ( ! mbInitialized)
     326             :     {
     327           0 :         mbInitialized = true;
     328           0 :         SfxRequest aRequest (SID_EDIT_OUTLINER, SfxCallMode::SLOT, GetDoc()->GetItemPool());
     329           0 :         FuPermanent (aRequest);
     330             :     }
     331             : 
     332           0 :     ViewShell::Activate( bIsMDIActivate );
     333           0 :     SfxShell::BroadcastContextForActivation(true);
     334             : 
     335           0 :     pOlView->SetLinks();
     336           0 :     pOlView->ConnectToApplication();
     337             : 
     338           0 :     if( bIsMDIActivate )
     339             :     {
     340           0 :         OutlinerView* pOutlinerView = pOlView->GetViewByWindow( GetActiveWindow() );
     341           0 :         ::Outliner* pOutl = pOutlinerView->GetOutliner();
     342           0 :         pOutl->UpdateFields();
     343             :     }
     344           0 : }
     345             : 
     346           0 : void OutlineViewShell::Deactivate( bool bIsMDIActivate )
     347             : {
     348           0 :     pOlView->DisconnectFromApplication();
     349             : 
     350             :     // Links must be kept also on deactivated viewshell, to allow drag'n'drop
     351             :     // to function properly
     352           0 :     ViewShell::Deactivate( bIsMDIActivate );
     353           0 : }
     354             : 
     355             : /**
     356             :  * Set status of Controller-SfxSlots
     357             :  */
     358           0 : void OutlineViewShell::GetCtrlState(SfxItemSet &rSet)
     359             : {
     360           0 :     if (SfxItemState::DEFAULT == rSet.GetItemState(SID_HYPERLINK_GETLINK))
     361             :     {
     362           0 :         SvxHyperlinkItem aHLinkItem;
     363             : 
     364           0 :         OutlinerView* pOLV = pOlView->GetViewByWindow(GetActiveWindow());
     365           0 :         if (pOLV)
     366             :         {
     367           0 :             const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection();
     368           0 :             if (pFieldItem)
     369             :             {
     370           0 :                 ESelection aSel = pOLV->GetSelection();
     371           0 :                 if ( abs( aSel.nEndPos - aSel.nStartPos ) == 1 )
     372             :                 {
     373           0 :                     const SvxFieldData* pField = pFieldItem->GetField();
     374           0 :                     if ( pField->ISA(SvxURLField) )
     375             :                     {
     376           0 :                         aHLinkItem.SetName(static_cast<const SvxURLField*>(pField)->GetRepresentation());
     377           0 :                         aHLinkItem.SetURL(static_cast<const SvxURLField*>(pField)->GetURL());
     378           0 :                         aHLinkItem.SetTargetFrame(static_cast<const SvxURLField*>(pField)->GetTargetFrame());
     379             :                     }
     380             :                 }
     381             :             }
     382             :         }
     383           0 :         rSet.Put(aHLinkItem);
     384             :     }
     385           0 :     rSet.Put( SfxBoolItem( SID_READONLY_MODE, GetDocSh()->IsReadOnly() ) );
     386             : 
     387           0 :     if ( SfxItemState::DEFAULT == rSet.GetItemState(SID_MAIL_SCROLLBODY_PAGEDOWN) )
     388           0 :         rSet.Put( SfxBoolItem( SID_MAIL_SCROLLBODY_PAGEDOWN, true ) );
     389             : 
     390           0 :     if ( SfxItemState::DEFAULT == rSet.GetItemState(SID_TRANSLITERATE_HALFWIDTH) ||
     391           0 :          SfxItemState::DEFAULT == rSet.GetItemState(SID_TRANSLITERATE_FULLWIDTH) ||
     392           0 :          SfxItemState::DEFAULT == rSet.GetItemState(SID_TRANSLITERATE_HIRAGANA) ||
     393           0 :          SfxItemState::DEFAULT == rSet.GetItemState(SID_TRANSLITERATE_KATAGANA) )
     394             :     {
     395           0 :         SvtCJKOptions aCJKOptions;
     396           0 :         if( !aCJKOptions.IsChangeCaseMapEnabled() )
     397             :         {
     398           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, false );
     399           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, false );
     400           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, false );
     401           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, false );
     402           0 :             rSet.DisableItem( SID_TRANSLITERATE_HALFWIDTH );
     403           0 :             rSet.DisableItem( SID_TRANSLITERATE_FULLWIDTH );
     404           0 :             rSet.DisableItem( SID_TRANSLITERATE_HIRAGANA );
     405           0 :             rSet.DisableItem( SID_TRANSLITERATE_KATAGANA );
     406             :         }
     407             :         else
     408             :         {
     409           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HALFWIDTH, true );
     410           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_FULLWIDTH, true );
     411           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_HIRAGANA, true );
     412           0 :             GetViewFrame()->GetBindings().SetVisibleState( SID_TRANSLITERATE_KATAGANA, true );
     413           0 :         }
     414             :     }
     415           0 : }
     416             : 
     417             : /**
     418             :  * SfxRequests for support functions
     419             :  */
     420           0 : void OutlineViewShell::FuSupport(SfxRequest &rReq)
     421             : {
     422           0 :     if( rReq.GetSlot() == SID_STYLE_FAMILY && rReq.GetArgs())
     423           0 :         GetDocSh()->SetStyleFamily(static_cast<const SfxUInt16Item&>(rReq.GetArgs()->Get( SID_STYLE_FAMILY )).GetValue());
     424             : 
     425           0 :     bool bPreviewState = false;
     426           0 :     sal_uLong nSlot = rReq.GetSlot();
     427             : 
     428           0 :     boost::scoped_ptr< OutlineViewModelChangeGuard > aGuard;
     429           0 :     if( pOlView && (
     430           0 :         (nSlot == SID_TRANSLITERATE_SENTENCE_CASE) ||
     431           0 :         (nSlot == SID_TRANSLITERATE_TITLE_CASE) ||
     432           0 :         (nSlot == SID_TRANSLITERATE_TOGGLE_CASE) ||
     433           0 :         (nSlot == SID_TRANSLITERATE_UPPER) ||
     434           0 :         (nSlot == SID_TRANSLITERATE_LOWER) ||
     435           0 :         (nSlot == SID_TRANSLITERATE_HALFWIDTH) ||
     436           0 :         (nSlot == SID_TRANSLITERATE_FULLWIDTH) ||
     437           0 :         (nSlot == SID_TRANSLITERATE_HIRAGANA) ||
     438           0 :         (nSlot == SID_TRANSLITERATE_KATAGANA) ||
     439           0 :         (nSlot == SID_CUT) ||
     440           0 :         (nSlot == SID_PASTE) ||
     441           0 :         (nSlot == SID_PASTE_UNFORMATTED) ||
     442             :         (nSlot == SID_DELETE)))
     443             :     {
     444           0 :         aGuard.reset( new OutlineViewModelChangeGuard( *pOlView ) );
     445             :     }
     446             : 
     447           0 :     switch ( nSlot )
     448             :     {
     449             :         case SID_CUT:
     450             :         {
     451           0 :             if(HasCurrentFunction())
     452             :             {
     453           0 :                 GetCurrentFunction()->DoCut();
     454             :             }
     455           0 :             else if (pOlView)
     456             :             {
     457           0 :                 pOlView->DoCut();
     458             :             }
     459           0 :             rReq.Done();
     460           0 :             bPreviewState = true;
     461             :         }
     462           0 :         break;
     463             : 
     464             :         case SID_COPY:
     465             :         {
     466           0 :             if(HasCurrentFunction())
     467             :             {
     468           0 :                 GetCurrentFunction()->DoCopy();
     469             :             }
     470           0 :             else if (pOlView)
     471             :             {
     472           0 :                 pOlView->DoCopy();
     473             :             }
     474           0 :             rReq.Done();
     475           0 :             bPreviewState = true;
     476             :         }
     477           0 :         break;
     478             : 
     479             :         case SID_PASTE:
     480             :         {
     481           0 :             OutlineViewPageChangesGuard aGuard2(pOlView);
     482             : 
     483           0 :             if(HasCurrentFunction())
     484             :             {
     485           0 :                 GetCurrentFunction()->DoPaste();
     486             :             }
     487           0 :             else if (pOlView)
     488             :             {
     489           0 :                 pOlView->DoPaste();
     490             :             }
     491           0 :             rReq.Done();
     492           0 :             bPreviewState = true;
     493             :         }
     494           0 :         break;
     495             : 
     496             :         case SID_PASTE_UNFORMATTED:
     497             :         {
     498           0 :             OutlineViewPageChangesGuard aGuard2(pOlView);
     499             : 
     500           0 :             if(HasCurrentFunction())
     501             :             {
     502           0 :                 GetCurrentFunction()->DoPasteUnformatted();
     503             :             }
     504           0 :             else if(pOlView)
     505             :             {
     506           0 :                 sal_Int8 nAction = DND_ACTION_COPY;
     507           0 :                 TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) );
     508           0 :                 if (aDataHelper.GetTransferable().is())
     509             :                 {
     510             :                     pOlView->InsertData( aDataHelper,
     511           0 :                                          GetActiveWindow()->PixelToLogic( Rectangle( Point(), GetActiveWindow()->GetOutputSizePixel() ).Center() ),
     512           0 :                                          nAction, false, SotClipboardFormatId::STRING);
     513           0 :                 }
     514             :             }
     515             : 
     516           0 :             rReq.Ignore ();
     517             :         }
     518           0 :         break;
     519             :         case SID_DELETE:
     520             :         {
     521           0 :             if( pOlView )
     522             :             {
     523           0 :                 OutlinerView* pOutlView = pOlView->GetViewByWindow(GetActiveWindow());
     524           0 :                 if (pOutlView)
     525             :                 {
     526           0 :                     OutlineViewPageChangesGuard aGuard2(pOlView);
     527             : 
     528           0 :                     vcl::KeyCode aKCode(KEY_DELETE);
     529           0 :                     KeyEvent aKEvt( 0, aKCode );
     530           0 :                     pOutlView->PostKeyEvent(aKEvt);
     531             : 
     532           0 :                     rtl::Reference<FuPoor> xFunc( GetCurrentFunction() );
     533           0 :                     FuOutlineText* pFuOutlineText = dynamic_cast< FuOutlineText* >( xFunc.get() );
     534           0 :                     if( pFuOutlineText )
     535           0 :                         pFuOutlineText->UpdateForKeyPress (aKEvt);
     536             :                 }
     537             :             }
     538           0 :             rReq.Done();
     539           0 :             bPreviewState = true;
     540             :         }
     541           0 :         break;
     542             : 
     543             :         case SID_DRAWINGMODE:
     544             :         case SID_NOTESMODE:
     545             :         case SID_HANDOUTMODE:
     546             :         case SID_DIAMODE:
     547             :         case SID_OUTLINEMODE:
     548           0 :             framework::FrameworkHelper::Instance(GetViewShellBase())->HandleModeChangeSlot(
     549             :                 nSlot,
     550           0 :                 rReq);
     551           0 :             rReq.Done();
     552           0 :             break;
     553             : 
     554             :         case SID_RULER:
     555           0 :             SetRuler( !HasRuler() );
     556           0 :             Invalidate( SID_RULER );
     557           0 :             rReq.Done();
     558           0 :         break;
     559             : 
     560             :         case SID_ZOOM_PREV:
     561             :         {
     562           0 :             if (mpZoomList->IsPreviousPossible())
     563             :             {
     564           0 :                 SetZoomRect(mpZoomList->GetPreviousZoomRect());
     565             :             }
     566           0 :             rReq.Done ();
     567             :         }
     568           0 :         break;
     569             : 
     570             :         case SID_ZOOM_NEXT:
     571             :         {
     572           0 :             if (mpZoomList->IsNextPossible())
     573             :             {
     574           0 :                 SetZoomRect(mpZoomList->GetNextZoomRect());
     575             :             }
     576           0 :             rReq.Done ();
     577             :         }
     578           0 :         break;
     579             : 
     580             :         case SID_AUTOSPELL_CHECK:
     581             :         {
     582           0 :             GetDoc()->SetOnlineSpell(!GetDoc()->GetOnlineSpell());
     583           0 :             rReq.Done ();
     584             :         }
     585           0 :         break;
     586             : 
     587             :         case SID_TRANSLITERATE_SENTENCE_CASE:
     588             :         case SID_TRANSLITERATE_TITLE_CASE:
     589             :         case SID_TRANSLITERATE_TOGGLE_CASE:
     590             :         case SID_TRANSLITERATE_UPPER:
     591             :         case SID_TRANSLITERATE_LOWER:
     592             :         case SID_TRANSLITERATE_HALFWIDTH:
     593             :         case SID_TRANSLITERATE_FULLWIDTH:
     594             :         case SID_TRANSLITERATE_HIRAGANA:
     595             :         case SID_TRANSLITERATE_KATAGANA:
     596             :         {
     597           0 :             OutlinerView* pOLV = pOlView ? pOlView->GetViewByWindow( GetActiveWindow() ) : 0;
     598           0 :             if( pOLV )
     599             :             {
     600             :                 using namespace ::com::sun::star::i18n;
     601           0 :                 sal_Int32 nType = 0;
     602             : 
     603           0 :                 switch( nSlot )
     604             :                 {
     605             :                     case SID_TRANSLITERATE_SENTENCE_CASE:
     606           0 :                         nType = TransliterationModulesExtra::SENTENCE_CASE;
     607           0 :                         break;
     608             :                     case SID_TRANSLITERATE_TITLE_CASE:
     609           0 :                         nType = TransliterationModulesExtra::TITLE_CASE;
     610           0 :                         break;
     611             :                     case SID_TRANSLITERATE_TOGGLE_CASE:
     612           0 :                         nType = TransliterationModulesExtra::TOGGLE_CASE;
     613           0 :                         break;
     614             :                     case SID_TRANSLITERATE_UPPER:
     615           0 :                         nType = TransliterationModules_LOWERCASE_UPPERCASE;
     616           0 :                         break;
     617             :                     case SID_TRANSLITERATE_LOWER:
     618           0 :                         nType = TransliterationModules_UPPERCASE_LOWERCASE;
     619           0 :                         break;
     620             :                     case SID_TRANSLITERATE_HALFWIDTH:
     621           0 :                         nType = TransliterationModules_FULLWIDTH_HALFWIDTH;
     622           0 :                         break;
     623             :                     case SID_TRANSLITERATE_FULLWIDTH:
     624           0 :                         nType = TransliterationModules_HALFWIDTH_FULLWIDTH;
     625           0 :                         break;
     626             :                     case SID_TRANSLITERATE_HIRAGANA:
     627           0 :                         nType = TransliterationModules_KATAKANA_HIRAGANA;
     628           0 :                         break;
     629             :                     case SID_TRANSLITERATE_KATAGANA:
     630           0 :                         nType = TransliterationModules_HIRAGANA_KATAKANA;
     631           0 :                         break;
     632             :                 }
     633             : 
     634           0 :                 pOLV->TransliterateText( nType );
     635             :             }
     636             : 
     637           0 :             rReq.Done();
     638           0 :             bPreviewState = true;
     639             :         }
     640           0 :         break;
     641             : 
     642             :         // added Undo/Redo handling
     643             :         case SID_UNDO :
     644             :         {
     645           0 :             OutlineViewPageChangesGuard aGuard2(pOlView);
     646           0 :             ImpSidUndo(false, rReq);
     647             :         }
     648           0 :         break;
     649             :         case SID_REDO :
     650             :         {
     651           0 :             OutlineViewPageChangesGuard aGuard2(pOlView);
     652           0 :             ImpSidRedo(false, rReq);
     653             :         }
     654           0 :         break;
     655             : 
     656             :         default:
     657           0 :         break;
     658             :     }
     659             : 
     660           0 :     if( bPreviewState )
     661           0 :         Invalidate( SID_PREVIEW_STATE );
     662             : 
     663           0 :     Invalidate(SID_CUT);
     664           0 :     Invalidate(SID_COPY);
     665           0 :     Invalidate(SID_PASTE);
     666           0 : }
     667             : 
     668             : /**
     669             :  * SfxRequests for permanent functions
     670             :  */
     671           0 : void OutlineViewShell::FuPermanent(SfxRequest &rReq)
     672             : {
     673           0 :     if(HasCurrentFunction())
     674             :     {
     675           0 :         DeactivateCurrentFunction(true);
     676             :     }
     677             : 
     678           0 :     switch ( rReq.GetSlot() )
     679             :     {
     680             :         case SID_EDIT_OUTLINER:
     681             :         {
     682           0 :             ::Outliner& rOutl = pOlView->GetOutliner();
     683           0 :             rOutl.GetUndoManager().Clear();
     684           0 :             rOutl.UpdateFields();
     685             : 
     686           0 :             SetCurrentFunction( FuOutlineText::Create(this,GetActiveWindow(),pOlView,GetDoc(),rReq) );
     687             : 
     688           0 :             rReq.Done();
     689             :         }
     690           0 :         break;
     691             : 
     692             :       default:
     693           0 :       break;
     694             :     }
     695             : 
     696           0 :     if(HasOldFunction())
     697             :     {
     698           0 :         GetOldFunction()->Deactivate();
     699           0 :         SetOldFunction(0);
     700             :     }
     701             : 
     702           0 :     if(HasCurrentFunction())
     703             :     {
     704           0 :         GetCurrentFunction()->Activate();
     705           0 :         SetOldFunction(GetCurrentFunction());
     706             :     }
     707           0 : }
     708             : 
     709           0 : IMPL_LINK( OutlineViewShell, ClipboardChanged, TransferableDataHelper*, pDataHelper )
     710             : {
     711           0 :     if ( pDataHelper )
     712             :     {
     713           0 :         bPastePossible = ( pDataHelper->GetFormatCount() != 0 &&
     714           0 :                             ( pDataHelper->HasFormat( SotClipboardFormatId::STRING ) ||
     715           0 :                               pDataHelper->HasFormat( SotClipboardFormatId::RTF ) ||
     716           0 :                               pDataHelper->HasFormat( SotClipboardFormatId::HTML ) ) );
     717             : 
     718           0 :         SfxBindings& rBindings = GetViewFrame()->GetBindings();
     719           0 :         rBindings.Invalidate( SID_PASTE );
     720           0 :         rBindings.Invalidate( SID_PASTE_SPECIAL );
     721           0 :         rBindings.Invalidate( SID_PASTE_UNFORMATTED );
     722           0 :         rBindings.Invalidate( SID_CLIPBOARD_FORMAT_ITEMS );
     723             :     }
     724           0 :     return 0;
     725             : }
     726             : 
     727             : /**
     728             :  * Set Status (Enabled/Disabled) of Menu-SfxSlots
     729             :  */
     730           0 : void OutlineViewShell::GetMenuState( SfxItemSet &rSet )
     731             : {
     732           0 :     ViewShell::GetMenuState(rSet);
     733             : 
     734           0 :     rSet.Put(SfxBoolItem(SID_DIAMODE, false));
     735           0 :     rSet.Put(SfxBoolItem(SID_DRAWINGMODE, false));
     736           0 :     rSet.Put(SfxBoolItem(SID_OUTLINEMODE, true));
     737           0 :     rSet.Put(SfxBoolItem(SID_NOTESMODE, false));
     738           0 :     rSet.Put(SfxBoolItem(SID_HANDOUTMODE, false));
     739             : 
     740           0 :     if (!mpZoomList->IsNextPossible())
     741             :     {
     742           0 :        rSet.DisableItem(SID_ZOOM_NEXT);
     743             :     }
     744           0 :     if (!mpZoomList->IsPreviousPossible())
     745             :     {
     746           0 :        rSet.DisableItem(SID_ZOOM_PREV);
     747             :     }
     748             : 
     749           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_ZOOM_IN ) ||
     750           0 :         SfxItemState::DEFAULT == rSet.GetItemState( SID_ZOOM_OUT ) )
     751             :     {
     752           0 :         if( GetActiveWindow()->GetZoom() <= GetActiveWindow()->GetMinZoom() || GetDocSh()->IsUIActive() )
     753           0 :             rSet.DisableItem( SID_ZOOM_IN );
     754           0 :         if( GetActiveWindow()->GetZoom() >= GetActiveWindow()->GetMaxZoom() || GetDocSh()->IsUIActive() )
     755           0 :             rSet.DisableItem( SID_ZOOM_OUT );
     756             :     }
     757             : 
     758           0 :     ::Outliner& rOutl = pOlView->GetOutliner();
     759             : 
     760             :     // allow 'Select All'?
     761           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_SELECTALL ) )
     762             :     {
     763           0 :         sal_Int32 nParaCount = rOutl.GetParagraphCount();
     764           0 :         bool bDisable = nParaCount == 0;
     765           0 :         if (!bDisable && nParaCount == 1)
     766             :         {
     767           0 :             OUString aTest = rOutl.GetText(rOutl.GetParagraph(0));
     768           0 :             if (aTest.isEmpty())
     769             :             {
     770           0 :                 bDisable = true;
     771           0 :             }
     772             :         }
     773           0 :         if (bDisable)
     774           0 :             rSet.DisableItem(SID_SELECTALL);
     775             :     }
     776             : 
     777             :     // set status of Ruler
     778           0 :     rSet.Put( SfxBoolItem( SID_RULER, HasRuler() ) );
     779             : 
     780             :     // Enable formatting?
     781           0 :     rSet.Put( SfxBoolItem( SID_OUTLINE_FORMAT, !rOutl.IsFlatMode() ) );
     782             : 
     783           0 :     if( rOutl.IsFlatMode() )
     784           0 :         rSet.DisableItem( SID_COLORVIEW );
     785             :     else
     786             :     {
     787             :         // Enable color view?
     788           0 :         EEControlBits nCntrl = rOutl.GetControlWord();
     789           0 :         bool bNoColor = false;
     790           0 :         if (nCntrl & EEControlBits::NOCOLORS)
     791           0 :             bNoColor = true;
     792             : 
     793           0 :         rSet.Put( SfxBoolItem( SID_COLORVIEW, bNoColor ) );
     794             :     }
     795             : 
     796             :     // Buttons of toolbar
     797             :     // first the selection dependent ones: COLLAPSE, EXPAND
     798           0 :     bool bDisableCollapse = true;
     799           0 :     bool bDisableExpand   = true;
     800           0 :     bool bUnique          = true;
     801           0 :     OutlinerView* pOutlinerView = pOlView->GetViewByWindow(GetActiveWindow());
     802             : 
     803           0 :     std::vector<Paragraph*> aSelList;
     804           0 :     pOutlinerView->CreateSelectionList(aSelList);
     805             : 
     806           0 :     if (!aSelList.empty())
     807             :     {
     808           0 :         std::vector<Paragraph*>::const_iterator iter = aSelList.begin();
     809           0 :         Paragraph* pPara = *iter;
     810             : 
     811             :         sal_Int16 nDepth;
     812           0 :         sal_Int16 nTmpDepth = rOutl.GetDepth( rOutl.GetAbsPos( pPara ) );
     813           0 :         bool bPage = ::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE );
     814             : 
     815           0 :         while (iter != aSelList.begin())
     816             :         {
     817           0 :             pPara = *iter;
     818             : 
     819           0 :             nDepth = rOutl.GetDepth( rOutl.GetAbsPos( pPara ) );
     820             : 
     821           0 :             if( nDepth != nTmpDepth || bPage != ::Outliner::HasParaFlag( pPara, ParaFlag::ISPAGE ))
     822           0 :                 bUnique = false;
     823             : 
     824           0 :             if (rOutl.HasChildren(pPara))
     825             :             {
     826           0 :                 if (!rOutl.IsExpanded(pPara))
     827           0 :                     bDisableExpand = false;
     828             :                 else
     829           0 :                     bDisableCollapse = false;
     830             :             }
     831             : 
     832           0 :             ++iter;
     833             :         }
     834             :     }
     835             : 
     836           0 :     if (bDisableExpand)
     837           0 :         rSet.DisableItem(SID_OUTLINE_EXPAND);
     838           0 :     if (bDisableCollapse)
     839           0 :         rSet.DisableItem(SID_OUTLINE_COLLAPSE);
     840             : 
     841             :     // does the selection provide a unique presentation layout?
     842             :     // if not, the templates must not be edited
     843           0 :     SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT);
     844           0 :     GetStatusBarState(aSet);
     845           0 :     OUString aTest = static_cast<const SfxStringItem&>(aSet.Get(SID_STATUS_LAYOUT)).GetValue();
     846           0 :     if (aTest.isEmpty())
     847             :     {
     848           0 :         bUnique = false;
     849           0 :         rSet.DisableItem(SID_PRESENTATION_TEMPLATES);
     850             :     }
     851             : 
     852           0 :     if (!bUnique)
     853           0 :         rSet.DisableItem( SID_PRESENTATIONOBJECT );
     854             : 
     855             :     // now the selection independent ones: COLLAPSE_ALL, EXPAND_ALL
     856           0 :     bool bDisableCollapseAll = true;
     857           0 :     bool bDisableExpandAll   = true;
     858             : 
     859             :     // does the selection contain something collapsable/expandable?
     860           0 :     if (!bDisableCollapse)
     861           0 :         bDisableCollapseAll = false;
     862           0 :     if (!bDisableExpand)
     863           0 :         bDisableExpandAll = false;
     864             : 
     865             :     // otherwise look through all paragraphs
     866           0 :     if (bDisableCollapseAll || bDisableExpandAll)
     867             :     {
     868           0 :         sal_Int32 nParaPos = 0;
     869           0 :         Paragraph* pPara = rOutl.GetParagraph( nParaPos );
     870           0 :         while (pPara && (bDisableCollapseAll || bDisableExpandAll))
     871             :         {
     872           0 :             if (!rOutl.IsExpanded(pPara) && rOutl.HasChildren(pPara))
     873           0 :                 bDisableExpandAll = false;
     874             : 
     875           0 :             if (rOutl.IsExpanded(pPara) && rOutl.HasChildren(pPara))
     876           0 :                 bDisableCollapseAll = false;
     877             : 
     878           0 :             pPara = rOutl.GetParagraph( ++nParaPos );
     879             :         }
     880             :     }
     881             : 
     882           0 :     if (bDisableExpandAll)
     883           0 :         rSet.DisableItem(SID_OUTLINE_EXPAND_ALL);
     884           0 :     if (bDisableCollapseAll)
     885           0 :         rSet.DisableItem(SID_OUTLINE_COLLAPSE_ALL);
     886             : 
     887           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_PASTE ) )
     888             :     {
     889           0 :         if ( !pClipEvtLstnr )
     890             :         {
     891             :             // create listener
     892           0 :             pClipEvtLstnr = new TransferableClipboardListener( LINK( this, OutlineViewShell, ClipboardChanged ) );
     893           0 :             pClipEvtLstnr->acquire();
     894           0 :             pClipEvtLstnr->AddRemoveListener( GetActiveWindow(), true );
     895             : 
     896             :             // get initial state
     897           0 :             TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( GetActiveWindow() ) );
     898           0 :             bPastePossible = ( aDataHelper.GetFormatCount() != 0 &&
     899           0 :                                 ( aDataHelper.HasFormat( SotClipboardFormatId::STRING ) ||
     900           0 :                                   aDataHelper.HasFormat( SotClipboardFormatId::RTF ) ||
     901           0 :                                   aDataHelper.HasFormat( SotClipboardFormatId::HTML ) ) );
     902             :         }
     903             : 
     904           0 :         if( !bPastePossible )
     905             :         {
     906           0 :             rSet.DisableItem( SID_PASTE );
     907             :         }
     908             :     }
     909             : 
     910           0 :     if (!pOlView->GetViewByWindow(GetActiveWindow())->HasSelection())
     911             :     {
     912           0 :         rSet.DisableItem(SID_CUT);
     913           0 :         rSet.DisableItem(SID_COPY);
     914             :     }
     915             : 
     916           0 :     if (pOlView->GetOutliner().IsModified())
     917             :     {
     918           0 :         GetDoc()->SetChanged(true);
     919             :     }
     920             : 
     921             :     // the status has to be set here because of overriding
     922           0 :     if( !GetDocSh()->IsModified() )
     923             :     {
     924           0 :         rSet.DisableItem( SID_SAVEDOC );
     925             :     }
     926             : 
     927           0 :     if ( GetDocSh()->IsReadOnly() )
     928             :     {
     929           0 :         rSet.DisableItem( SID_AUTOSPELL_CHECK );
     930             :     }
     931             :     else
     932             :     {
     933           0 :         if (GetDoc()->GetOnlineSpell())
     934             :         {
     935           0 :             rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, true));
     936             :         }
     937             :         else
     938             :         {
     939           0 :             rSet.Put(SfxBoolItem(SID_AUTOSPELL_CHECK, false));
     940             :         }
     941             :     }
     942             : 
     943             :     // field commands
     944           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_MODIFY_FIELD ) )
     945             :     {
     946           0 :         const SvxFieldItem* pFldItem = pOutlinerView->GetFieldAtSelection();
     947             : 
     948           0 :         if( !( pFldItem && (pFldItem->GetField()->ISA( SvxDateField ) ||
     949           0 :                             pFldItem->GetField()->ISA( SvxAuthorField ) ||
     950           0 :                             pFldItem->GetField()->ISA( SvxExtFileField ) ||
     951           0 :                             pFldItem->GetField()->ISA( SvxExtTimeField ) ) ) )
     952             :         {
     953           0 :             rSet.DisableItem( SID_MODIFY_FIELD );
     954             :         }
     955             :     }
     956             : 
     957           0 :     if (SfxItemState::DEFAULT == rSet.GetItemState(SID_EXPAND_PAGE))
     958             :     {
     959           0 :         bool bDisable = true;
     960           0 :         sal_uInt16 i = 0;
     961           0 :         sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
     962           0 :         pOlView->SetSelectedPages();
     963             : 
     964           0 :         while (i < nCount && bDisable)
     965             :         {
     966           0 :             SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);
     967             : 
     968           0 :             if (pPage->IsSelected())
     969             :             {
     970           0 :                 SdrObject* pObj = pPage->GetPresObj(PRESOBJ_OUTLINE);
     971             : 
     972           0 :                 if (pObj!=NULL )
     973             :                 {
     974           0 :                     if( !pObj->IsEmptyPresObj() )
     975             :                     {
     976           0 :                         bDisable = false;
     977             :                     }
     978             :                     else
     979             :                     {
     980             :                         // check if the object is in edit, than its temporarely not empty
     981           0 :                         SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObj );
     982           0 :                         if( pTextObj )
     983             :                         {
     984           0 :                             OutlinerParaObject* pParaObj = pTextObj->GetEditOutlinerParaObject();
     985           0 :                             if( pParaObj )
     986             :                             {
     987           0 :                                 delete pParaObj;
     988           0 :                                 bDisable = false;
     989             :                             }
     990             :                         }
     991             :                     }
     992             :                 }
     993             :             }
     994             : 
     995           0 :             i++;
     996             :         }
     997             : 
     998           0 :         if (bDisable)
     999             :         {
    1000           0 :             rSet.DisableItem(SID_EXPAND_PAGE);
    1001             :         }
    1002             :     }
    1003             : 
    1004           0 :     if (SfxItemState::DEFAULT == rSet.GetItemState(SID_SUMMARY_PAGE))
    1005             :     {
    1006           0 :         bool bDisable = true;
    1007           0 :         sal_uInt16 i = 0;
    1008           0 :         sal_uInt16 nCount = GetDoc()->GetSdPageCount(PK_STANDARD);
    1009           0 :         pOlView->SetSelectedPages();
    1010             : 
    1011           0 :         while (i < nCount && bDisable)
    1012             :         {
    1013           0 :             SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);
    1014             : 
    1015           0 :             if (pPage->IsSelected())
    1016             :             {
    1017           0 :                 SdrObject* pObj = pPage->GetPresObj(PRESOBJ_TITLE);
    1018             : 
    1019           0 :                 if (pObj && !pObj->IsEmptyPresObj())
    1020             :                 {
    1021           0 :                     bDisable = false;
    1022             :                 }
    1023             :             }
    1024             : 
    1025           0 :             i++;
    1026             :         }
    1027             : 
    1028           0 :         if (bDisable)
    1029             :         {
    1030           0 :             rSet.DisableItem(SID_SUMMARY_PAGE);
    1031             :         }
    1032             :     }
    1033             : 
    1034           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_THESAURUS ) )
    1035             :     {
    1036           0 :         if ( !pOlView->IsTextEdit() )
    1037             :         {
    1038           0 :             rSet.DisableItem( SID_THESAURUS );
    1039             :         }
    1040             :         else
    1041             :         {
    1042           0 :             LanguageType            eLang = GetDoc()->GetLanguage( EE_CHAR_LANGUAGE );
    1043           0 :             Reference< XThesaurus > xThesaurus( LinguMgr::GetThesaurus() );
    1044             : 
    1045           0 :             if (!xThesaurus.is() || eLang == LANGUAGE_NONE || !xThesaurus->hasLocale( LanguageTag::convertToLocale( eLang)))
    1046           0 :                 rSet.DisableItem( SID_THESAURUS );
    1047             :         }
    1048             :     }
    1049             : 
    1050             :     // is starting the presentation possible?
    1051           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_PRESENTATION ) )
    1052             :     {
    1053           0 :         bool bDisable = true;
    1054           0 :         sal_uInt16 nCount = GetDoc()->GetSdPageCount( PK_STANDARD );
    1055             : 
    1056           0 :         for( sal_uInt16 i = 0; i < nCount && bDisable; i++ )
    1057             :         {
    1058           0 :             SdPage* pPage = GetDoc()->GetSdPage(i, PK_STANDARD);
    1059             : 
    1060           0 :             if( !pPage->IsExcluded() )
    1061           0 :                 bDisable = false;
    1062             :         }
    1063           0 :         if( bDisable || GetDocSh()->IsPreview())
    1064             :         {
    1065           0 :             rSet.DisableItem( SID_PRESENTATION );
    1066             :         }
    1067             :     }
    1068             : 
    1069           0 :     FuBullet::GetSlotState( rSet, this, GetViewFrame() );
    1070             : 
    1071           0 : }
    1072             : 
    1073             : /**
    1074             :  * gets invoked when ScrollBar is used
    1075             :  */
    1076           0 : long OutlineViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
    1077             : {
    1078           0 :     long   nThumb = pHScroll->GetThumbPos();
    1079           0 :     long   nRange = pHScroll->GetRange().Len();
    1080           0 :     double fX     = (double) nThumb / nRange;
    1081             : 
    1082           0 :     Window*       pWin          = mpContentWindow.get();
    1083           0 :     OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWin);
    1084             :     long          nViewWidth    = pWin->PixelToLogic(
    1085           0 :         pWin->GetSizePixel()).Width();
    1086           0 :     long          nTextWidth    = pOlView->GetPaperWidth();
    1087           0 :     nViewWidth                  = std::max(nViewWidth, nTextWidth);
    1088           0 :     long          nCurrentPos   = pOutlinerView->GetVisArea().Left();
    1089           0 :     long          nTargetPos    = (long)(fX * nViewWidth);
    1090           0 :     long          nDelta        = nTargetPos - nCurrentPos;
    1091             : 
    1092           0 :     pOutlinerView->HideCursor();
    1093           0 :     pOutlinerView->Scroll(-nDelta, 0);
    1094           0 :     pOutlinerView->ShowCursor(false);
    1095             : 
    1096           0 :     return 0;
    1097             : }
    1098             : 
    1099           0 : long OutlineViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
    1100             : {
    1101           0 :     long nThumb = pVScroll->GetThumbPos();
    1102           0 :     long nRange = pVScroll->GetRange().Len();
    1103           0 :     double fY = (double) nThumb / nRange;
    1104             : 
    1105           0 :     Window*       pWin          = mpContentWindow.get();
    1106           0 :     OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWin);
    1107             :     long          nViewHeight   = pWin->PixelToLogic(
    1108           0 :         pWin->GetSizePixel()).Height();
    1109           0 :     long          nTextHeight   = pOlView->GetOutliner().GetTextHeight();
    1110           0 :     nViewHeight                += nTextHeight;
    1111           0 :     long          nCurrentPos   = pOutlinerView->GetVisArea().Top();
    1112           0 :     long          nTargetPos    = (long)(fY * nViewHeight);
    1113           0 :     long          nDelta        = nTargetPos - nCurrentPos;
    1114             : 
    1115           0 :     pOutlinerView->HideCursor();
    1116           0 :     pOutlinerView->Scroll(0, -nDelta);
    1117           0 :     pOutlinerView->ShowCursor(false);
    1118             : 
    1119           0 :     return 0;
    1120             : }
    1121             : 
    1122             : /**
    1123             :  * PrepareClose, gets called when the Shell shall be destroyed.
    1124             :  * Forwards the invocation to the View
    1125             :  */
    1126           0 : bool OutlineViewShell::PrepareClose( bool bUI )
    1127             : {
    1128           0 :     if( !ViewShell::PrepareClose(bUI) )
    1129           0 :         return false;
    1130             : 
    1131           0 :     return pOlView == NULL || pOlView->PrepareClose(bUI);
    1132             : }
    1133             : 
    1134             : /**
    1135             :  * Zoom with zoom factor. Inform OutlinerView
    1136             :  */
    1137           0 : void OutlineViewShell::SetZoom(long nZoom)
    1138             : {
    1139           0 :     ViewShell::SetZoom(nZoom);
    1140             : 
    1141           0 :     ::sd::Window* pWindow = mpContentWindow.get();
    1142           0 :     if (pWindow)
    1143             :     {
    1144             :         // change OutputArea of OutlinerView
    1145           0 :         OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
    1146           0 :         Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
    1147           0 :         aWin = pWindow->PixelToLogic(aWin);
    1148           0 :         pOutlinerView->SetOutputArea(aWin);
    1149             :     }
    1150             : 
    1151           0 :     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
    1152           0 :     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
    1153           0 : }
    1154             : 
    1155             : /**
    1156             :  * Zoom with zoom rectangle. Inform OutlinerView
    1157             :  */
    1158           0 : void OutlineViewShell::SetZoomRect(const Rectangle& rZoomRect)
    1159             : {
    1160           0 :     ViewShell::SetZoomRect(rZoomRect);
    1161             : 
    1162           0 :     ::sd::Window* pWindow = mpContentWindow.get();
    1163           0 :     if (pWindow)
    1164             :     {
    1165             :         // change OutputArea of OutlinerView
    1166           0 :         OutlinerView* pOutlinerView = pOlView->GetViewByWindow(pWindow);
    1167           0 :         Rectangle aWin(Point(0,0), pWindow->GetOutputSizePixel());
    1168           0 :         aWin = pWindow->PixelToLogic(aWin);
    1169           0 :         pOutlinerView->SetOutputArea(aWin);
    1170             :     }
    1171             : 
    1172           0 :     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
    1173           0 :     GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
    1174           0 : }
    1175             : 
    1176             : /**
    1177             :  * Before saving: Update Model of the Drawing Engine, then forward the
    1178             :  * invocation to the ObjectShell.
    1179             :  */
    1180           0 : void OutlineViewShell::Execute(SfxRequest& rReq)
    1181             : {
    1182           0 :     bool bForwardCall = true;
    1183             : 
    1184           0 :     switch(rReq.GetSlot())
    1185             :     {
    1186             :         case SID_SAVEDOC:
    1187             :         case SID_SAVEASDOC:
    1188           0 :             PrepareClose();
    1189           0 :             break;
    1190             : 
    1191             :         case SID_SEARCH_ITEM:
    1192             :             // Forward this request to the common (old) code of the
    1193             :             // document shell.
    1194           0 :             GetDocSh()->Execute (rReq);
    1195           0 :             bForwardCall = false;
    1196           0 :             break;
    1197             : 
    1198             :         case SID_SPELL_DIALOG:
    1199             :         {
    1200           0 :             SfxViewFrame* pViewFrame = GetViewFrame();
    1201           0 :             if (rReq.GetArgs() != NULL)
    1202             :                 pViewFrame->SetChildWindow (SID_SPELL_DIALOG,
    1203             :                     static_cast<const SfxBoolItem&>(rReq.GetArgs()->
    1204           0 :                         Get(SID_SPELL_DIALOG)).GetValue());
    1205             :             else
    1206           0 :                 pViewFrame->ToggleChildWindow(SID_SPELL_DIALOG);
    1207             : 
    1208           0 :             pViewFrame->GetBindings().Invalidate(SID_SPELL_DIALOG);
    1209           0 :             rReq.Done ();
    1210             : 
    1211           0 :             bForwardCall = false;
    1212             :         }
    1213           0 :         break;
    1214             : 
    1215             :         default:
    1216             :             OSL_TRACE ("OutlineViewShell::Execute(): can not handle slot %d", rReq.GetSlot());
    1217           0 :             break;
    1218             : 
    1219             :     }
    1220             : 
    1221           0 :     if (bForwardCall)
    1222           0 :         static_cast<DrawDocShell*>(GetViewFrame()->GetObjectShell())->ExecuteSlot( rReq );
    1223           0 : }
    1224             : 
    1225             : /**
    1226             :  * Read FrameViews data and set actual views data
    1227             :  */
    1228           0 : void OutlineViewShell::ReadFrameViewData(FrameView* pView)
    1229             : {
    1230           0 :     ::Outliner& rOutl = pOlView->GetOutliner();
    1231             : 
    1232           0 :     rOutl.SetFlatMode( pView->IsNoAttribs() );
    1233             : 
    1234           0 :     EEControlBits nCntrl = rOutl.GetControlWord();
    1235             : 
    1236           0 :     if ( pView->IsNoColors() )
    1237           0 :         rOutl.SetControlWord(nCntrl | EEControlBits::NOCOLORS);
    1238             :     else
    1239           0 :         rOutl.SetControlWord(nCntrl & ~EEControlBits::NOCOLORS);
    1240             : 
    1241           0 :     sal_uInt16 nPage = mpFrameView->GetSelectedPage();
    1242           0 :     pLastPage = GetDoc()->GetSdPage( nPage, PK_STANDARD );
    1243           0 :     pOlView->SetActualPage(pLastPage);
    1244           0 : }
    1245             : 
    1246             : /**
    1247             :  * Write actual views data to FrameView
    1248             :  */
    1249           0 : void OutlineViewShell::WriteFrameViewData()
    1250             : {
    1251           0 :     ::Outliner& rOutl = pOlView->GetOutliner();
    1252             : 
    1253           0 :     EEControlBits nCntrl = rOutl.GetControlWord();
    1254           0 :     bool bNoColor = false;
    1255           0 :     if (nCntrl & EEControlBits::NOCOLORS)
    1256           0 :         bNoColor = true;
    1257           0 :     mpFrameView->SetNoColors(bNoColor);
    1258           0 :     mpFrameView->SetNoAttribs( rOutl.IsFlatMode() );
    1259           0 :     SdPage* pActualPage = pOlView->GetActualPage();
    1260             :     DBG_ASSERT(pActualPage, "No current page");
    1261           0 :     if( pActualPage )
    1262           0 :         mpFrameView->SetSelectedPage((pActualPage->GetPageNum() - 1) / 2);
    1263           0 : }
    1264             : 
    1265             : /**
    1266             :  * Handle SfxRequests for the StatusBar
    1267             :  */
    1268           0 : void OutlineViewShell::ExecStatusBar(SfxRequest&)
    1269             : {
    1270           0 : }
    1271             : 
    1272           0 : void OutlineViewShell::GetStatusBarState(SfxItemSet& rSet)
    1273             : {
    1274             :     // Zoom-Item
    1275           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_ATTR_ZOOM ) )
    1276             :     {
    1277           0 :         sal_uInt16 nZoom = (sal_uInt16) GetActiveWindow()->GetZoom();
    1278             : 
    1279           0 :         boost::scoped_ptr<SvxZoomItem> pZoomItem(new SvxZoomItem( SvxZoomType::PERCENT, nZoom ));
    1280             : 
    1281             :         // limit area
    1282           0 :         SvxZoomEnableFlags nZoomValues = SvxZoomEnableFlags::ALL;
    1283           0 :         nZoomValues &= ~SvxZoomEnableFlags::OPTIMAL;
    1284           0 :         nZoomValues &= ~SvxZoomEnableFlags::WHOLEPAGE;
    1285           0 :         nZoomValues &= ~SvxZoomEnableFlags::PAGEWIDTH;
    1286             : 
    1287           0 :         pZoomItem->SetValueSet( nZoomValues );
    1288           0 :         rSet.Put( *pZoomItem );
    1289             :     }
    1290             : 
    1291           0 :     if( SfxItemState::DEFAULT == rSet.GetItemState( SID_ATTR_ZOOMSLIDER ) )
    1292             :     {
    1293           0 :         if (GetDocSh()->IsUIActive() || !GetActiveWindow() )
    1294             :         {
    1295           0 :             rSet.DisableItem( SID_ATTR_ZOOMSLIDER );
    1296             :         }
    1297             :         else
    1298             :         {
    1299           0 :             sd::Window * pActiveWindow = GetActiveWindow();
    1300           0 :             SvxZoomSliderItem aZoomItem( (sal_uInt16) pActiveWindow->GetZoom(), (sal_uInt16)pActiveWindow->GetMinZoom(), (sal_uInt16)pActiveWindow->GetMaxZoom() ) ;
    1301           0 :             aZoomItem.AddSnappingPoint(100);
    1302           0 :             rSet.Put( aZoomItem );
    1303             :         }
    1304             :     }
    1305             : 
    1306             :     // page view and layout
    1307             : 
    1308           0 :     sal_uInt16  nPageCount = GetDoc()->GetSdPageCount( PK_STANDARD );
    1309           0 :     OUString  aPageStr, aLayoutStr;
    1310             : 
    1311           0 :     ::sd::Window*   pWin        = GetActiveWindow();
    1312           0 :     OutlinerView*   pActiveView = pOlView->GetViewByWindow( pWin );
    1313             : 
    1314           0 :     std::vector<Paragraph*> aSelList;
    1315           0 :     pActiveView->CreateSelectionList(aSelList);
    1316             : 
    1317           0 :     Paragraph *pFirstPara = NULL;
    1318           0 :     Paragraph *pLastPara = NULL;
    1319             : 
    1320           0 :     if (!aSelList.empty())
    1321             :     {
    1322           0 :         pFirstPara = *(aSelList.begin());
    1323           0 :         pLastPara = *(aSelList.rbegin());
    1324             :     }
    1325             : 
    1326           0 :     if( !::Outliner::HasParaFlag(pFirstPara,ParaFlag::ISPAGE) )
    1327           0 :         pFirstPara = pOlView->GetPrevTitle( pFirstPara );
    1328             : 
    1329           0 :     if( !::Outliner::HasParaFlag(pLastPara, ParaFlag::ISPAGE) )
    1330           0 :         pLastPara = pOlView->GetPrevTitle( pLastPara );
    1331             : 
    1332             :     // only one page selected?
    1333           0 :     if( pFirstPara == pLastPara )
    1334             :     {
    1335             :         // how many pages are we before the selected page?
    1336           0 :         sal_uLong nPos = 0L;
    1337           0 :         while( pFirstPara )
    1338             :         {
    1339           0 :             pFirstPara = pOlView->GetPrevTitle( pFirstPara );
    1340           0 :             if( pFirstPara )
    1341           0 :                 nPos++;
    1342             :         }
    1343             : 
    1344           0 :         if( nPos >= GetDoc()->GetSdPageCount( PK_STANDARD ) )
    1345           0 :             nPos = 0;
    1346             : 
    1347           0 :         SdrPage* pPage = GetDoc()->GetSdPage( (sal_uInt16) nPos, PK_STANDARD );
    1348             : 
    1349           0 :         aPageStr = SD_RESSTR(STR_SD_PAGE_COUNT);
    1350             : 
    1351           0 :         aPageStr = aPageStr.replaceFirst("%1", OUString::number((sal_Int32)(nPos + 1)));
    1352           0 :         aPageStr = aPageStr.replaceFirst("%2", OUString::number(nPageCount));
    1353             : 
    1354           0 :         aLayoutStr = pPage->GetLayoutName();
    1355           0 :         sal_Int32 nIndex = aLayoutStr.indexOf(SD_LT_SEPARATOR);
    1356           0 :         if (nIndex != -1)
    1357           0 :             aLayoutStr = aLayoutStr.copy(0, nIndex);
    1358             :         //Now, CurrentPage property change is already sent for DrawView and OutlineView, so it is not necessary to send again here
    1359           0 :         if(m_StrOldPageName!=aPageStr)
    1360             :         {
    1361           0 :             GetViewShellBase().GetDrawController().fireSwitchCurrentPage(nPos);
    1362           0 :             m_StrOldPageName = aPageStr;
    1363             :         }
    1364             :     }
    1365           0 :     rSet.Put( SfxStringItem( SID_STATUS_PAGE, aPageStr ) );
    1366           0 :     rSet.Put( SfxStringItem( SID_STATUS_LAYOUT, aLayoutStr ) );
    1367           0 : }
    1368             : 
    1369           0 : void OutlineViewShell::Command( const CommandEvent& rCEvt, ::sd::Window* pWin )
    1370             : {
    1371           0 :     if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
    1372             :     {
    1373           0 :         GetActiveWindow()->ReleaseMouse();
    1374             : 
    1375           0 :         OutlinerView* pOLV = pOlView->GetViewByWindow(GetActiveWindow());
    1376           0 :         Point aPos(rCEvt.GetMousePosPixel());
    1377             : 
    1378           0 :         if (pOLV && pOLV->IsWrongSpelledWordAtPos(aPos))
    1379             :         {
    1380             :             // Popup for Online-Spelling now handled by DrawDocShell
    1381           0 :             Link<> aLink = LINK(GetDocSh(), DrawDocShell, OnlineSpellCallback);
    1382             : 
    1383           0 :             pOLV->ExecuteSpellPopup(aPos, &aLink);
    1384             :         }
    1385             :         else
    1386             :         {
    1387           0 :            GetViewFrame()->GetDispatcher()->ExecutePopup(SdResId(RID_OUTLINE_POPUP));
    1388             :         }
    1389             :     }
    1390             :     else
    1391             :     {
    1392           0 :         ViewShell::Command( rCEvt, pWin );
    1393             : 
    1394             :         // if necessary communicate the new context to the Preview
    1395           0 :         Invalidate( SID_PREVIEW_STATE );
    1396             : 
    1397             :     }
    1398           0 : }
    1399             : 
    1400           0 : bool OutlineViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin)
    1401             : {
    1402           0 :     bool bReturn = false;
    1403           0 :     OutlineViewPageChangesGuard aGuard(pOlView);
    1404             : 
    1405           0 :     if (pWin == NULL && HasCurrentFunction())
    1406             :     {
    1407           0 :         bReturn = GetCurrentFunction()->KeyInput(rKEvt);
    1408             :     }
    1409             : 
    1410             :     // no, forward to base class
    1411             :     else
    1412             :     {
    1413           0 :         bReturn = ViewShell::KeyInput(rKEvt, pWin);
    1414             :     }
    1415             : 
    1416           0 :     Invalidate(SID_STYLE_EDIT);
    1417           0 :     Invalidate(SID_STYLE_NEW);
    1418           0 :     Invalidate(SID_STYLE_DELETE);
    1419           0 :     Invalidate(SID_STYLE_HIDE);
    1420           0 :     Invalidate(SID_STYLE_SHOW);
    1421           0 :     Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE);
    1422           0 :     Invalidate(SID_STYLE_NEW_BY_EXAMPLE);
    1423           0 :     Invalidate(SID_STYLE_WATERCAN);
    1424           0 :     Invalidate(SID_STYLE_FAMILY5);
    1425             : 
    1426             :     // check and distinguish cursor movements- or input-keys
    1427           0 :     vcl::KeyCode aKeyGroup( rKEvt.GetKeyCode().GetGroup() );
    1428           0 :     if( (aKeyGroup != KEYGROUP_CURSOR && aKeyGroup != KEYGROUP_FKEYS) ||
    1429           0 :         (GetActualPage() != pLastPage) )
    1430             :     {
    1431           0 :         Invalidate( SID_PREVIEW_STATE );
    1432             :     }
    1433             : 
    1434           0 :     return bReturn;
    1435             : }
    1436             : 
    1437             : /**
    1438             :  * Status of Attribute-Items
    1439             :  */
    1440           0 : void OutlineViewShell::GetAttrState( SfxItemSet& rSet )
    1441             : {
    1442           0 :     SfxWhichIter  aIter( rSet );
    1443           0 :     sal_uInt16        nWhich = aIter.FirstWhich();
    1444           0 :     SfxAllItemSet aAllSet( *rSet.GetPool() );
    1445             : 
    1446           0 :     while ( nWhich )
    1447             :     {
    1448           0 :         sal_uInt16 nSlotId = SfxItemPool::IsWhich(nWhich)
    1449           0 :             ? GetPool().GetSlotId(nWhich)
    1450           0 :             : nWhich;
    1451             : 
    1452           0 :         switch ( nSlotId )
    1453             :         {
    1454             :             case SID_STYLE_FAMILY2:
    1455             :             case SID_STYLE_FAMILY3:
    1456             :             {
    1457           0 :                 rSet.DisableItem( nWhich );
    1458             :             }
    1459           0 :             break;
    1460             : 
    1461             :             case SID_STYLE_FAMILY5:
    1462             :             {
    1463           0 :                 SfxStyleSheet* pStyleSheet = pOlView->GetViewByWindow(GetActiveWindow())->GetStyleSheet();
    1464             : 
    1465           0 :                 if( pStyleSheet )
    1466             :                 {
    1467           0 :                     pStyleSheet = static_cast<SdStyleSheet*>(pStyleSheet)->GetPseudoStyleSheet();
    1468             : 
    1469           0 :                     if (pStyleSheet)
    1470             :                     {
    1471           0 :                         SfxTemplateItem aItem( nWhich, pStyleSheet->GetName() );
    1472           0 :                         aAllSet.Put( aItem, aItem.Which()  );
    1473             :                     }
    1474             :                 }
    1475             : 
    1476           0 :                 if( !pStyleSheet )
    1477             :                 {
    1478           0 :                     SfxTemplateItem aItem( nWhich, OUString() );
    1479           0 :                     aAllSet.Put( aItem, aItem.Which() );
    1480             :                     // rSet.DisableItem( nWhich );
    1481             :                 }
    1482             :             }
    1483           0 :             break;
    1484             : 
    1485             :             case SID_STYLE_EDIT:
    1486             :             {
    1487           0 :                 SfxPoolItem* pItem = NULL;
    1488           0 :                 GetViewFrame()->GetBindings().QueryState(SID_STYLE_FAMILY, pItem);
    1489           0 :                 SfxUInt16Item* pFamilyItem = dynamic_cast<SfxUInt16Item*>(pItem);
    1490           0 :                 if (pFamilyItem && SfxTemplate::NIdToSfxFamilyId(pFamilyItem->GetValue()) == SD_STYLE_FAMILY_PSEUDO)
    1491             :                 {
    1492           0 :                     SfxItemSet aSet(*rSet.GetPool(), SID_STATUS_LAYOUT, SID_STATUS_LAYOUT);
    1493           0 :                     GetStatusBarState(aSet);
    1494           0 :                     OUString aRealStyle = static_cast<const SfxStringItem&>(aSet.Get(SID_STATUS_LAYOUT)).GetValue();
    1495           0 :                     if (aRealStyle.isEmpty())
    1496             :                     {
    1497             :                         // no unique layout name found
    1498           0 :                         rSet.DisableItem(nWhich);
    1499           0 :                     }
    1500             :                 }
    1501           0 :                 delete pItem;
    1502             :             }
    1503           0 :             break;
    1504             : 
    1505             :             case SID_STYLE_UPDATE_BY_EXAMPLE:
    1506             :             {
    1507           0 :                 ::sd::Window*     pActWin = GetActiveWindow();
    1508           0 :                 OutlinerView* pOV = pOlView->GetViewByWindow(pActWin);
    1509           0 :                 ESelection aESel(pOV->GetSelection());
    1510             : 
    1511           0 :                 if (aESel.nStartPara != aESel.nEndPara ||
    1512           0 :                     aESel.nStartPos  != aESel.nEndPos)
    1513             :                     // spanned selection, i.e. StyleSheet and/or
    1514             :                     // attribution not necessarily unqiue
    1515           0 :                     rSet.DisableItem(nWhich);
    1516             :             }
    1517           0 :             break;
    1518             : 
    1519             :             case SID_STYLE_NEW:
    1520             :             case SID_STYLE_DELETE:
    1521             :             case SID_STYLE_HIDE:
    1522             :             case SID_STYLE_SHOW:
    1523             :             case SID_STYLE_NEW_BY_EXAMPLE:
    1524             :             case SID_STYLE_WATERCAN:
    1525             :             {
    1526           0 :                 rSet.DisableItem(nWhich);
    1527             :             }
    1528           0 :             break;
    1529             :         }
    1530             : 
    1531           0 :         nWhich = aIter.NextWhich();
    1532             :     }
    1533             : 
    1534           0 :     rSet.Put( aAllSet, false );
    1535           0 : }
    1536             : 
    1537           0 : void OutlineViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin)
    1538             : {
    1539             :     // first the base classes
    1540           0 :     ViewShell::MouseButtonUp(rMEvt, pWin);
    1541             : 
    1542           0 :     Invalidate(SID_STYLE_EDIT);
    1543           0 :     Invalidate(SID_STYLE_NEW);
    1544           0 :     Invalidate(SID_STYLE_DELETE);
    1545           0 :     Invalidate(SID_STYLE_HIDE);
    1546           0 :     Invalidate(SID_STYLE_SHOW);
    1547           0 :     Invalidate(SID_STYLE_UPDATE_BY_EXAMPLE);
    1548           0 :     Invalidate(SID_STYLE_NEW_BY_EXAMPLE);
    1549           0 :     Invalidate(SID_STYLE_WATERCAN);
    1550           0 :     Invalidate(SID_STYLE_FAMILY5);
    1551             : 
    1552             :     // if necessary communicate the new context to the Preview
    1553           0 :     if( GetActualPage() != pLastPage )
    1554           0 :         Invalidate( SID_PREVIEW_STATE );
    1555           0 : }
    1556             : 
    1557           0 : SdPage* OutlineViewShell::getCurrentPage() const
    1558             : {
    1559             :     // since there are no master pages in outline view, we can
    1560             :     // for now use the GetActualPage method
    1561           0 :     return const_cast<OutlineViewShell*>(this)->GetActualPage();
    1562             : }
    1563             : 
    1564             : /**
    1565             :  * Returns the first selected page.
    1566             :  * If nothing is selected, the first page is returned.
    1567             :  */
    1568           0 : SdPage* OutlineViewShell::GetActualPage()
    1569             : {
    1570           0 :     return pOlView->GetActualPage();
    1571             : }
    1572             : 
    1573           0 : void OutlineViewShell::UpdatePreview( SdPage* pPage, bool )
    1574             : {
    1575           0 :     const bool bNewPage = pPage != pLastPage;
    1576           0 :     pLastPage = pPage;
    1577           0 :     if (bNewPage)
    1578             :     {
    1579           0 :         OutlineViewPageChangesGuard aGuard(pOlView);
    1580           0 :         SetCurrentPage(pPage);
    1581             :     }
    1582           0 : }
    1583             : 
    1584           0 : bool OutlineViewShell::UpdateTitleObject( SdPage* pPage, Paragraph* pPara )
    1585             : {
    1586             :     DBG_ASSERT( pPage, "sd::OutlineViewShell::UpdateTitleObject(), pPage == 0?" );
    1587             :     DBG_ASSERT( pPara, "sd::OutlineViewShell::UpdateTitleObject(), pPara == 0?" );
    1588             : 
    1589           0 :     if( !pPage || !pPara )
    1590           0 :         return false;
    1591             : 
    1592           0 :     ::Outliner&         rOutliner = pOlView->GetOutliner();
    1593           0 :     SdrTextObj*         pTO  = OutlineView::GetTitleTextObject( pPage );
    1594             : 
    1595           0 :     OUString aTest = rOutliner.GetText(pPara);
    1596           0 :     bool    bText = !aTest.isEmpty();
    1597           0 :     bool    bNewObject = false;
    1598             : 
    1599           0 :     if( bText )
    1600             :     {
    1601             :         // create a title object if we don't have one but have text
    1602           0 :         if( !pTO )
    1603             :         {
    1604             :             DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
    1605           0 :             pTO = OutlineView::CreateTitleTextObject(pPage);
    1606           0 :             bNewObject = true;
    1607             :         }
    1608             : 
    1609             :         // if we have a title object and a text, set the text
    1610           0 :         OutlinerParaObject* pOPO = pTO ? rOutliner.CreateParaObject(rOutliner.GetAbsPos(pPara), 1) : NULL;
    1611           0 :         if (pOPO)
    1612             :         {
    1613           0 :             pOPO->SetOutlinerMode( OUTLINERMODE_TITLEOBJECT );
    1614           0 :             pOPO->SetVertical( pTO->IsVerticalWriting() );
    1615           0 :             if( pTO->GetOutlinerParaObject() && (pOPO->GetTextObject() == pTO->GetOutlinerParaObject()->GetTextObject()) )
    1616             :             {
    1617             :                 // do nothing, same text already set
    1618           0 :                 delete pOPO;
    1619             :             }
    1620             :             else
    1621             :             {
    1622             :                 DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
    1623           0 :                 if( !bNewObject && pOlView->isRecordingUndo() )
    1624           0 :                     pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
    1625             : 
    1626           0 :                 pTO->SetOutlinerParaObject( pOPO );
    1627           0 :                 pTO->SetEmptyPresObj( false );
    1628           0 :                 pTO->ActionChanged();
    1629             :             }
    1630             :         }
    1631             :     }
    1632           0 :     else if( pTO )
    1633             :     {
    1634             :         // no text but object available?
    1635             :         // outline object available, but we have no text
    1636           0 :         if(pPage->IsPresObj(pTO))
    1637             :         {
    1638             :             // if it is not already empty
    1639           0 :             if( !pTO->IsEmptyPresObj() )
    1640             :             {
    1641             :                 DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
    1642             : 
    1643             :                 // make it empty
    1644           0 :                 if( pOlView->isRecordingUndo() )
    1645           0 :                     pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
    1646           0 :                 pPage->RestoreDefaultText( pTO );
    1647           0 :                 pTO->SetEmptyPresObj(true);
    1648           0 :                 pTO->ActionChanged();
    1649             :             }
    1650             :         }
    1651             :         else
    1652             :         {
    1653             :             DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateTitleObject(), no undo for model change!?" );
    1654             :             // outline object is not part of the layout, delete it
    1655           0 :             if( pOlView->isRecordingUndo() )
    1656           0 :                 pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoRemoveObject(*pTO));
    1657           0 :             pPage->RemoveObject(pTO->GetOrdNum());
    1658             :         }
    1659             :     }
    1660             : 
    1661           0 :     return bNewObject;
    1662             : }
    1663             : 
    1664           0 : bool OutlineViewShell::UpdateOutlineObject( SdPage* pPage, Paragraph* pPara )
    1665             : {
    1666             :     DBG_ASSERT( pPage, "sd::OutlineViewShell::UpdateOutlineObject(), pPage == 0?" );
    1667             :     DBG_ASSERT( pPara, "sd::OutlineViewShell::UpdateOutlineObject(), pPara == 0?" );
    1668             : 
    1669           0 :     if( !pPage || !pPara )
    1670           0 :         return false;
    1671             : 
    1672           0 :     ::Outliner&         rOutliner = pOlView->GetOutliner();
    1673           0 :     OutlinerParaObject* pOPO = NULL;
    1674           0 :     SdrTextObj*         pTO  = NULL;
    1675             : 
    1676           0 :     bool bNewObject = false;
    1677             : 
    1678           0 :     sal_uInt16 eOutlinerMode = OUTLINERMODE_TITLEOBJECT;
    1679           0 :     pTO = static_cast<SdrTextObj*>(pPage->GetPresObj( PRESOBJ_TEXT ));
    1680           0 :     if( !pTO )
    1681             :     {
    1682           0 :         eOutlinerMode = OUTLINERMODE_OUTLINEOBJECT;
    1683           0 :         pTO = OutlineView::GetOutlineTextObject( pPage );
    1684             :     }
    1685             : 
    1686             :     // how many paragraphs in the outline?
    1687           0 :     sal_Int32 nTitlePara     = rOutliner.GetAbsPos( pPara );
    1688           0 :     sal_Int32 nPara          = nTitlePara + 1;
    1689           0 :     sal_Int32 nParasInLayout = 0L;
    1690           0 :     pPara = rOutliner.GetParagraph( nPara );
    1691           0 :     while( pPara && !::Outliner::HasParaFlag(pPara, ParaFlag::ISPAGE) )
    1692             :     {
    1693           0 :         nParasInLayout++;
    1694           0 :         pPara = rOutliner.GetParagraph( ++nPara );
    1695             :     }
    1696           0 :     if( nParasInLayout )
    1697             :     {
    1698             :         // create an OutlinerParaObject
    1699           0 :         pOPO  = rOutliner.CreateParaObject( nTitlePara + 1, nParasInLayout );
    1700             :     }
    1701             : 
    1702           0 :     if( pOPO )
    1703             :     {
    1704             :         DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );
    1705             : 
    1706             :         // do we need an outline text object?
    1707           0 :         if( !pTO )
    1708             :         {
    1709           0 :             pTO = OutlineView::CreateOutlineTextObject( pPage );
    1710           0 :             bNewObject = true;
    1711             :         }
    1712             : 
    1713             :         // page object, outline text in Outliner:
    1714             :         // apply text
    1715           0 :         if( pTO )
    1716             :         {
    1717           0 :             pOPO->SetVertical( pTO->IsVerticalWriting() );
    1718           0 :             pOPO->SetOutlinerMode( eOutlinerMode );
    1719           0 :             if( pTO->GetOutlinerParaObject() && (pOPO->GetTextObject() == pTO->GetOutlinerParaObject()->GetTextObject()) )
    1720             :             {
    1721             :                 // do nothing, same text already set
    1722           0 :                 delete pOPO;
    1723             :             }
    1724             :             else
    1725             :             {
    1726           0 :                 if( !bNewObject && pOlView->isRecordingUndo() )
    1727           0 :                     pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
    1728             : 
    1729           0 :                 pTO->SetOutlinerParaObject( pOPO );
    1730           0 :                 pTO->SetEmptyPresObj( false );
    1731           0 :                 pTO->ActionChanged();
    1732             :             }
    1733             :         }
    1734             :         else
    1735           0 :             delete pOPO;
    1736             :     }
    1737           0 :     else if( pTO )
    1738             :     {
    1739             :         // page object but no outline text:
    1740             :         // if the object is in the outline of the page -> default text
    1741             : 
    1742             :         // otherwise delete object
    1743           0 :         if( pPage->IsPresObj(pTO) )
    1744             :         {
    1745           0 :             if( !pTO->IsEmptyPresObj() )
    1746             :             {
    1747             :                 DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );
    1748             : 
    1749             :                 // delete old OutlinerParaObject, too
    1750           0 :                 if( pOlView->isRecordingUndo() )
    1751           0 :                     pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoObjectSetText(*pTO,0));
    1752           0 :                 pPage->RestoreDefaultText( pTO );
    1753           0 :                 pTO->SetEmptyPresObj(true);
    1754           0 :                 pTO->ActionChanged();
    1755             :             }
    1756             :         }
    1757             :         else
    1758             :         {
    1759             :             DBG_ASSERT( pOlView->isRecordingUndo(), "sd::OutlineViewShell::UpdateOutlineObject(), no undo for model change!?" );
    1760           0 :             if( pOlView->isRecordingUndo() )
    1761           0 :                 pOlView->AddUndo(GetDoc()->GetSdrUndoFactory().CreateUndoRemoveObject(*pTO));
    1762           0 :             pPage->RemoveObject(pTO->GetOrdNum());
    1763             :         }
    1764             :     }
    1765             : 
    1766           0 :     return bNewObject;
    1767             : }
    1768             : 
    1769             : /**
    1770             :  * Fill Outliner from Stream
    1771             :  */
    1772           0 : sal_uLong OutlineViewShell::Read(SvStream& rInput, const OUString& rBaseURL, sal_uInt16 eFormat)
    1773             : {
    1774           0 :     sal_uLong bRet = 0;
    1775             : 
    1776           0 :     ::Outliner& rOutl = pOlView->GetOutliner();
    1777             : 
    1778           0 :     OutlineViewPageChangesGuard aGuard( pOlView );
    1779           0 :     OutlineViewModelChangeGuard aGuard2( *pOlView );
    1780             : 
    1781           0 :     bRet = rOutl.Read( rInput, rBaseURL, eFormat, GetDocSh()->GetHeaderAttributes() );
    1782             : 
    1783           0 :     SdPage* pPage = GetDoc()->GetSdPage( GetDoc()->GetSdPageCount(PK_STANDARD) - 1, PK_STANDARD );;
    1784           0 :     SfxStyleSheet* pTitleSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_TITLE );
    1785           0 :     SfxStyleSheet* pOutlSheet = pPage->GetStyleSheetForPresObj( PRESOBJ_OUTLINE );
    1786             : 
    1787           0 :     sal_Int32 nParaCount = rOutl.GetParagraphCount();
    1788           0 :     if ( nParaCount > 0 )
    1789             :     {
    1790           0 :         for ( sal_Int32 nPara = 0; nPara < nParaCount; nPara++ )
    1791             :         {
    1792           0 :             pOlView->UpdateParagraph( nPara );
    1793             : 
    1794           0 :             sal_Int16 nDepth = rOutl.GetDepth( nPara );
    1795             : 
    1796           0 :             if( (nDepth == 0) || !nPara )
    1797             :             {
    1798           0 :                 Paragraph* pPara = rOutl.GetParagraph( nPara );
    1799           0 :                 rOutl.SetDepth(pPara, -1);
    1800           0 :                 rOutl.SetParaFlag(pPara, ParaFlag::ISPAGE);
    1801             : 
    1802           0 :                 rOutl.SetStyleSheet( nPara, pTitleSheet );
    1803             : 
    1804           0 :                 if( nPara ) // first slide already exists
    1805           0 :                     pOlView->InsertSlideForParagraph( pPara );
    1806             :             }
    1807             :             else
    1808             :             {
    1809           0 :                 rOutl.SetDepth( rOutl.GetParagraph( nPara ), nDepth - 1 );
    1810           0 :                 OUString aStyleSheetName = pOutlSheet->GetName();
    1811           0 :                 if (!aStyleSheetName.isEmpty())
    1812           0 :                     aStyleSheetName = aStyleSheetName.copy(0, aStyleSheetName.getLength() - 1);
    1813           0 :                 aStyleSheetName += OUString::number( nDepth );
    1814           0 :                 SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool();
    1815           0 :                 SfxStyleSheet* pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pOutlSheet->GetFamily() ) );
    1816             :                 DBG_ASSERT( pStyle, "AutoStyleSheetName - Style not found!" );
    1817           0 :                 if ( pStyle )
    1818           0 :                     rOutl.SetStyleSheet( nPara, pStyle );
    1819             :             }
    1820             :         }
    1821             :     }
    1822             : 
    1823           0 :     rOutl.GetUndoManager().Clear();
    1824             : 
    1825           0 :     return bRet;
    1826             : }
    1827             : 
    1828           0 : void OutlineViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, bool bBrowse )
    1829             : {
    1830           0 :     WriteFrameViewData();
    1831             : 
    1832           0 :     ViewShell::WriteUserDataSequence( rSequence, bBrowse );
    1833           0 : }
    1834             : 
    1835           0 : void OutlineViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, bool bBrowse )
    1836             : {
    1837           0 :     WriteFrameViewData();
    1838             : 
    1839           0 :     ViewShell::ReadUserDataSequence( rSequence, bBrowse );
    1840             : 
    1841           0 :     ReadFrameViewData( mpFrameView );
    1842           0 : }
    1843             : 
    1844           0 : void OutlineViewShell::VisAreaChanged(const Rectangle& rRect)
    1845             : {
    1846           0 :     ViewShell::VisAreaChanged( rRect );
    1847             : 
    1848           0 :     GetViewShellBase().GetDrawController().FireVisAreaChanged(rRect);
    1849           0 : }
    1850             : 
    1851             : /** If there is a valid controller then create a new instance of
    1852             :     <type>AccessibleDrawDocumentView</type>.  Otherwise return an empty
    1853             :     reference.
    1854             : */
    1855             : ::com::sun::star::uno::Reference<
    1856             :     ::com::sun::star::accessibility::XAccessible>
    1857           0 :     OutlineViewShell::CreateAccessibleDocumentView (::sd::Window* pWindow)
    1858             : {
    1859             :     OSL_ASSERT (GetViewShell()!=NULL);
    1860           0 :     if (GetViewShell()->GetController() != NULL)
    1861             :     {
    1862             :         ::accessibility::AccessibleOutlineView* pDocumentView =
    1863             :             new ::accessibility::AccessibleOutlineView (
    1864             :                 pWindow,
    1865             :                 this,
    1866             :                 GetViewShell()->GetController(),
    1867           0 :                 pWindow->GetAccessibleParentWindow()->GetAccessible());
    1868           0 :         pDocumentView->Init();
    1869             :         return ::com::sun::star::uno::Reference<
    1870             :             ::com::sun::star::accessibility::XAccessible>
    1871             :             (static_cast< ::com::sun::star::uno::XWeak*>(pDocumentView),
    1872           0 :                 ::com::sun::star::uno::UNO_QUERY);
    1873             :     }
    1874             : 
    1875             :     OSL_TRACE ("OutlineViewShell::CreateAccessibleDocumentView: no controller");
    1876           0 :     return ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible >();
    1877             : }
    1878             : 
    1879           0 : void OutlineViewShell::GetState (SfxItemSet& rSet)
    1880             : {
    1881             :     // Iterate over all requested items in the set.
    1882           0 :     SfxWhichIter aIter( rSet );
    1883           0 :     sal_uInt16 nWhich = aIter.FirstWhich();
    1884           0 :     while (nWhich)
    1885             :     {
    1886           0 :         switch (nWhich)
    1887             :         {
    1888             :             case SID_SEARCH_ITEM:
    1889             :             case SID_SEARCH_OPTIONS:
    1890             :                 // Call common (old) implementation in the document shell.
    1891           0 :                 GetDocSh()->GetState (rSet);
    1892           0 :                 break;
    1893             :             default:
    1894             :                 OSL_TRACE ("OutlineViewShell::GetState(): can not handle which id %d", nWhich);
    1895           0 :                 break;
    1896             :         }
    1897           0 :         nWhich = aIter.NextWhich();
    1898           0 :     }
    1899           0 : }
    1900             : 
    1901           0 : void OutlineViewShell::SetCurrentPage (SdPage* pPage)
    1902             : {
    1903             :     // Adapt the selection of the model.
    1904           0 :     for (sal_uInt16 i=0; i<GetDoc()->GetSdPageCount(PK_STANDARD); i++)
    1905             :         GetDoc()->SetSelected(
    1906             :             GetDoc()->GetSdPage(i, PK_STANDARD),
    1907           0 :             false);
    1908           0 :     GetDoc()->SetSelected (pPage, true);
    1909             : 
    1910           0 :     DrawController& rController(GetViewShellBase().GetDrawController());
    1911           0 :     rController.FireSelectionChangeListener();
    1912           0 :     rController.FireSwitchCurrentPage (pPage);
    1913             : 
    1914           0 :     pOlView->SetActualPage(pPage);
    1915           0 : }
    1916             : 
    1917          66 : } // end of namespace sd
    1918             : 
    1919             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11