/************************************************************************* * * OpenOffice.org - a multi-platform office productivity suite * * $RCSfile: viewshel.cxx,v $ * * $Revision: 1.57 $ * * last change: $Author: obo $ $Date: 2006-03-21 17:49:01 $ * * The Contents of this file are made available subject to * the terms of GNU Lesser General Public License Version 2.1. * * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2005 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * ************************************************************************/ #include "ViewShell.hxx" #include "ViewShellImplementation.hxx" #ifndef _COM_SUN_STAR_EMBED_EMBEDSTATE_HPP_ #include #endif #ifndef SD_VIEW_SHELL_BASE_HXX #include "ViewShellBase.hxx" #endif #include "ShellFactory.hxx" #include "DrawController.hxx" #include "LayerTabBar.hxx" #include #ifndef _SFX_BINDINGS_HXX //autogen #include #endif #ifndef _SFXDISPATCH_HXX //autogen #include #endif #ifndef _SCRBAR_HXX //autogen #include #endif #ifndef _SFXENUMITEM_HXX //autogen #include #endif #ifndef _SVX_RULER_HXX //autogen #include #endif #ifndef _SVXIDS_HXX #include #endif #ifndef _B3D_BASE3D_HXX #include "goodies/base3d.hxx" #endif #ifndef _SVX_FMSHELL_HXX #include #endif #ifndef SD_WINDOW_UPDATER_HXX #include "WindowUpdater.hxx" #endif #ifndef SD_GRAPHIC_VIEW_SHELL_HXX #include "GraphicViewShell.hxx" #endif #ifndef _SFX_CHILDWIN_HXX #include #endif #ifndef _SD_SDXFER_HXX #include #endif #ifndef SD_GRAPHIC_VIEW_SHELL_HXX #include "GraphicViewShell.hxx" #endif #ifndef _SFX_CHILDWIN_HXX #include #endif #include "app.hrc" #include "helpids.h" #include "strings.hrc" #include "res_bmp.hrc" #ifndef SD_OUTLINE_VIEW_HXX #include "OutlineView.hxx" #endif #ifndef SD_CLIENT_HXX #include "Client.hxx" #endif #include "sdresid.hxx" #include "DrawDocShell.hxx" #ifndef _SD_SLIDESHOW_HXX #include "slideshow.hxx" #endif #include "drawdoc.hxx" #include "sdpage.hxx" #include "zoomlist.hxx" #ifndef SD_FRAME_VIEW_HXX #include "FrameView.hxx" #endif #include "optsitem.hxx" #include "BezierObjectBar.hxx" #include "TextObjectBar.hxx" #include "GraphicObjectBar.hxx" #include "MediaObjectBar.hxx" #include "ViewShellManager.hxx" #include "FormShellManager.hxx" #include #include "ViewTabBar.hxx" #include #include #include #include // #96090# #ifndef _SFXSLSTITM_HXX #include #endif #ifndef _SFXREQUEST_HXX #include #endif #include "SpellDialogChildWindow.hxx" #include "Window.hxx" #include "fupoor.hxx" #ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED #define SO2_DECL_SVINPLACEOBJECT_DEFINED SO2_DECL_REF(SvInPlaceObject) #endif using namespace ::com::sun::star; using namespace ::com::sun::star::uno; namespace { class ViewShellObjectBarFactory : public ::sd::ShellFactory { public: ViewShellObjectBarFactory (::sd::ViewShell& rViewShell); virtual ~ViewShellObjectBarFactory (void); virtual SfxShell* CreateShell ( ::sd::ShellId nId, ::Window* pParentWindow, ::sd::FrameView* pFrameView); virtual void ReleaseShell (SfxShell* pShell); private: ::sd::ViewShell& mrViewShell; /** This cache holds the already created object bars. */ typedef ::std::map< ::sd::ShellId,SfxShell*> ShellCache; ShellCache maShellCache; }; } // end of anonymous namespace namespace sd { static const int DELTA_ZOOM = 10; BOOL ViewShell::IsPageFlipMode(void) const { return this->ISA(DrawViewShell) && mpContentWindow.get() != NULL && mpContentWindow->GetVisibleHeight() >= 1.0; } SfxViewFrame* ViewShell::GetViewFrame (void) const { OSL_ASSERT (GetViewShell()!=NULL); return GetViewShell()->GetViewFrame(); } /************************************************************************* |* |* SFX-Slotmap und Standardinterface deklarieren |* \************************************************************************/ TYPEINIT1(ViewShell, SfxShell); ViewShell::ViewShell ( SfxViewFrame* pFrame, ::Window* pParentWindow, ViewShellBase& rViewShellBase, bool bAllowCenter) : SfxShell (&rViewShellBase), mpContentWindow(NULL), mpHorizontalScrollBar(NULL), mpVerticalScrollBar(NULL), mpHorizontalRuler(NULL), mpVerticalRuler(NULL), mpScrollBarBox(NULL), mbHasRulers(false), mpActiveWindow(NULL), mpView(NULL), pFrameView(NULL), mpSlideShow(NULL), pZoomList(NULL), aViewPos(), aViewSize(), aScrBarWH(), bCenterAllowed(bAllowCenter), bStartShowWithDialog(FALSE), nPrintedHandoutPageNum(1), maAllWindowRectangle(), meShellType(ST_NONE), mpParentWindow(pParentWindow), mpWindowUpdater (new ::sd::WindowUpdater()), mpImpl(new Implementation(*this)) { Construct(); } ViewShell::ViewShell( SfxViewFrame* pFrame, ::Window* pParentWindow, const ViewShell& rShell) : SfxShell (rShell.GetViewShell()), mpContentWindow(NULL), mpHorizontalScrollBar(NULL), mpVerticalScrollBar(NULL), mpHorizontalRuler(NULL), mpVerticalRuler(NULL), mpScrollBarBox(NULL), mbHasRulers(false), mpActiveWindow(NULL), mpView(NULL), pFrameView(NULL), mpSlideShow(NULL), pZoomList(NULL), aViewPos(), aViewSize(), aScrBarWH(), bCenterAllowed(rShell.bCenterAllowed), bStartShowWithDialog(FALSE), nPrintedHandoutPageNum(1), maAllWindowRectangle(), meShellType(ST_NONE), mpParentWindow(pParentWindow), mpWindowUpdater (new ::sd::WindowUpdater()), mpImpl(new Implementation(*this)), mpLayerTabBar(NULL) { Construct(); } ViewShell::~ViewShell() { SfxViewShell* pViewShell = GetViewShell(); OSL_ASSERT (pViewShell!=NULL); // Call SfxViewShell::SetWindow() directly instead of the local // SetActiveWindow() because the later one accesses the view that // usually has been destroyed already in a derived destructor. if (IsMainViewShell()) pViewShell->SetWindow (NULL); // Keep the content window from accessing in its destructor the // WindowUpdater. mpContentWindow->SetViewShell(NULL); // Stop listening for window events. // GetParentWindow()->RemoveEventListener ( // LINK(this,ViewShell,FrameWindowEventListener)); if (IsMainViewShell()) GetDocSh()->Disconnect(this); delete pZoomList; mpLayerTabBar.reset(); if (mpImpl->mpSubShellFactory.get() != NULL) GetViewShellBase().GetViewShellManager().RemoveSubShellFactory( this,mpImpl->mpSubShellFactory); } /************************************************************************* |* |* gemeinsamer Initialiserungsanteil der beiden Konstruktoren |* \************************************************************************/ void ViewShell::Construct(void) { SfxViewShell* pViewShell = GetViewShell(); OSL_ASSERT (pViewShell!=NULL); if (IsMainViewShell()) GetDocSh()->Connect (this); pZoomList = new ZoomList( this ); mpContentWindow.reset(new ::sd::Window(GetParentWindow())); SetActiveWindow (mpContentWindow.get()); GetParentWindow()->SetBackground (Wallpaper()); mpContentWindow->SetBackground (Wallpaper()); mpContentWindow->SetCenterAllowed(bCenterAllowed); mpContentWindow->SetViewShell(this); mpContentWindow->Show(); if ( ! GetDocSh()->IsPreview()) { // Create scroll bars and the filler between the scroll bars. mpHorizontalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_HSCROLL | WB_DRAG))); mpHorizontalScrollBar->EnableRTL (FALSE); mpHorizontalScrollBar->SetRange(Range(0, 32000)); mpHorizontalScrollBar->SetScrollHdl(LINK(this, ViewShell, HScrollHdl)); mpHorizontalScrollBar->Show(); mpVerticalScrollBar.reset (new ScrollBar(GetParentWindow(), WinBits(WB_VSCROLL | WB_DRAG))); mpVerticalScrollBar->SetRange(Range(0, 32000)); mpVerticalScrollBar->SetScrollHdl(LINK(this, ViewShell, VScrollHdl)); mpVerticalScrollBar->Show(); aScrBarWH = Size( mpVerticalScrollBar->GetSizePixel().Width(), mpHorizontalScrollBar->GetSizePixel().Height()); mpScrollBarBox.reset(new ScrollBarBox(GetParentWindow(), WB_SIZEABLE)); mpScrollBarBox->Show(); } String aName( RTL_CONSTASCII_USTRINGPARAM( "ViewShell" )); SetName (aName); GetDoc()->StartOnlineSpelling(FALSE); mpWindowUpdater->SetViewShell (*this); mpWindowUpdater->SetDocument (GetDoc()); // Re-initialize the spell dialog. ::sd::SpellDialogChildWindow* pSpellDialog = static_cast< ::sd::SpellDialogChildWindow*> ( GetViewFrame()->GetChildWindow ( ::sd::SpellDialogChildWindow::GetChildWindowId())); if (pSpellDialog != NULL) pSpellDialog->InvalidateSpellDialog(); // Register the sub shell factory. mpImpl->mpSubShellFactory.reset(new ViewShellObjectBarFactory(*this)); GetViewShellBase().GetViewShellManager().AddSubShellFactory(this,mpImpl->mpSubShellFactory); } void ViewShell::Init (bool bIsMainViewShell) { mpImpl->mbIsInitialized = true; SetIsMainViewShell(bIsMainViewShell); } void ViewShell::Exit (void) { sd::View* pView = GetView(); if (pView!=NULL && pView->IsTextEdit()) { pView->EndTextEdit(); pView->UnmarkAll(); } Deactivate (TRUE); SetIsMainViewShell(false); } /************************************************************************* |* |* Aktivierung: Arbeitsfenster den Fokus zuweisen |* \************************************************************************/ void ViewShell::Activate(BOOL bIsMDIActivate) { SfxShell::Activate(bIsMDIActivate); // Laut MI darf keiner GrabFocus rufen, der nicht genau weiss von // welchem Window der Focus gegrabt wird. Da Activate() vom SFX teilweise // asynchron verschickt wird, kann es sein, dass ein falsches Window // den Focus hat (#29682#): //GetViewFrame()->GetWindow().GrabFocus(); if (mpHorizontalRuler.get() != NULL) mpHorizontalRuler->SetActive(TRUE); if (mpVerticalRuler.get() != NULL) mpVerticalRuler->SetActive(TRUE); if (bIsMDIActivate) { // Damit der Navigator auch einen aktuellen Status bekommt SfxBoolItem aItem( SID_NAVIGATOR_INIT, TRUE ); if (GetDispatcher() != NULL) GetDispatcher()->Execute( SID_NAVIGATOR_INIT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L); SfxViewShell* pViewShell = GetViewShell(); OSL_ASSERT (pViewShell!=NULL); SfxBindings& rBindings = pViewShell->GetViewFrame()->GetBindings(); rBindings.Invalidate( SID_3D_STATE, TRUE, FALSE ); if (mpSlideShow && !mpSlideShow->isTerminated() ) { mpSlideShow->activate(); } if(HasCurrentFunction()) { GetCurrentFunction()->Activate(); } if(!GetDocSh()->IsUIActive()) UpdatePreview( GetActualPage(), TRUE ); ::sd::View* pView = GetView(); if (pView) { pView->ShowMarkHdl(NULL); } } ReadFrameViewData( pFrameView ); if (IsMainViewShell()) GetDocSh()->Connect(this); } void ViewShell::UIActivating( SfxInPlaceClient* pCli ) { OSL_ASSERT (GetViewShell()!=NULL); } void ViewShell::UIDeactivated( SfxInPlaceClient* pCli ) { OSL_ASSERT (GetViewShell()!=NULL); } /************************************************************************* |* |* Deaktivierung |* \************************************************************************/ void ViewShell::Deactivate(BOOL bIsMDIActivate) { // remove view from a still active drag'n'drop session SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag; if (IsMainViewShell()) GetDocSh()->Disconnect(this); if( pDragTransferable ) pDragTransferable->SetView( NULL ); SfxViewShell* pViewShell = GetViewShell(); OSL_ASSERT (pViewShell!=NULL); // View-Attribute an der FrameView merken WriteFrameViewData(); if (bIsMDIActivate) { if (mpSlideShow) { mpSlideShow->deactivate(); } if(HasCurrentFunction()) { GetCurrentFunction()->Deactivate(); } ::sd::View* pView = GetView(); if (pView) { pView->HideMarkHdl(NULL); } } if (mpHorizontalRuler.get() != NULL) mpHorizontalRuler->SetActive(FALSE); if (mpVerticalRuler.get() != NULL) mpVerticalRuler->SetActive(FALSE); SfxShell::Deactivate(bIsMDIActivate); } void ViewShell::Shutdown (void) { Exit (); } /************************************************************************* |* |* Keyboard event |* \************************************************************************/ BOOL ViewShell::KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin) { BOOL bReturn(FALSE); if(pWin) { SetActiveWindow(pWin); } if(!bReturn) { // #76008# // give key input first to SfxViewShell to give CTRL+Key // (e.g. CTRL+SHIFT+'+', to front) priority. OSL_ASSERT (GetViewShell()!=NULL); bReturn = GetViewShell()->KeyInput(rKEvt); } if(!bReturn) { if(mpSlideShow) { bReturn = mpSlideShow->keyInput(rKEvt); } else if(HasCurrentFunction()) { bReturn = GetCurrentFunction()->KeyInput(rKEvt); } } if(!bReturn && GetActiveWindow()) { KeyCode aKeyCode = rKEvt.GetKeyCode(); if (aKeyCode.IsMod1() && aKeyCode.IsShift() && aKeyCode.GetCode() == KEY_R) { // 3D-Kontext wieder zerstoeren Base3D* pBase3D = (Base3D*) GetActiveWindow()->Get3DContext(); if (pBase3D) { pBase3D->Destroy(GetActiveWindow()); } InvalidateWindows(); bReturn = TRUE; } } return(bReturn); } /************************************************************************* |* |* MouseButtonDown event |* \************************************************************************/ void ViewShell::MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin) { // We have to lock tool bar updates while the mouse button is pressed in // order to prevent the shape under the mouse to be moved (this happens // when the number of docked tool bars changes as result of a changed // selection; this changes the window size and thus the mouse position // in model coordinates: with respect to model coordinates the mouse // moves.) OSL_ASSERT(mpImpl->mpUpdateLockForMouse.expired()); mpImpl->mpUpdateLockForMouse = ViewShell::Implementation::ToolBarManagerLock::Create( GetViewShellBase().GetToolBarManager()); if ( pWin && !pWin->HasFocus() ) { pWin->GrabFocus(); SetActiveWindow(pWin); // GetViewFrame()->GetWindow().GrabFocus(); } // MouseEvent in E3dView eintragen if (GetView() != NULL) GetView()->SetMouseEvent(rMEvt); if(mpSlideShow) { mpSlideShow->mouseButtonDown(rMEvt); } else if (HasCurrentFunction()) { GetCurrentFunction()->MouseButtonDown(rMEvt); } } /************************************************************************* |* |* MouseMove event |* \************************************************************************/ void ViewShell::MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin) { if (rMEvt.IsLeaveWindow()) { if ( ! mpImpl->mpUpdateLockForMouse.expired()) { ::boost::shared_ptr pLock( mpImpl->mpUpdateLockForMouse); if (pLock.get() != NULL) pLock->Release(); } } if ( pWin ) { SetActiveWindow(pWin); } // MouseEvent in E3dView eintragen if (GetView() != NULL) GetView()->SetMouseEvent(rMEvt); Point aPosition = pWin->OutputToAbsoluteScreenPixel(rMEvt.GetPosPixel()); // if (saMousePosition != aPosition) { if(mpSlideShow) { mpSlideShow->mouseMove(rMEvt); } else if(HasCurrentFunction()) { GetCurrentFunction()->MouseMove(rMEvt); } } } /************************************************************************* |* |* MouseButtonUp event |* \************************************************************************/ void ViewShell::MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin) { if ( pWin ) { SetActiveWindow(pWin); } // MouseEvent in E3dView eintragen if (GetView() != NULL) GetView()->SetMouseEvent(rMEvt); if(mpSlideShow) { mpSlideShow->mouseButtonUp(rMEvt); } else if(HasCurrentFunction()) { GetCurrentFunction()->MouseButtonUp(rMEvt); } if ( ! mpImpl->mpUpdateLockForMouse.expired()) { ::boost::shared_ptr pLock( mpImpl->mpUpdateLockForMouse); if (pLock.get() != NULL) pLock->Release(); } } /************************************************************************* |* |* Command event |* \************************************************************************/ void ViewShell::Command(const CommandEvent& rCEvt, ::sd::Window* pWin) { BOOL bDone = HandleScrollCommand (rCEvt, pWin); if( !bDone ) { if( rCEvt.GetCommand() == COMMAND_INPUTLANGUAGECHANGE ) { //#i42732# update state of fontname if input language changes GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONT ); GetViewFrame()->GetBindings().Invalidate( SID_ATTR_CHAR_FONTHEIGHT ); } else if(mpSlideShow) { mpSlideShow->command(rCEvt); } else if(HasCurrentFunction()) { GetCurrentFunction()->Command(rCEvt); } } } long ViewShell::Notify(NotifyEvent& rNEvt, ::sd::Window* pWin) { // handle scroll commands when they arrived at child windows long nRet = FALSE; if( rNEvt.GetType() == EVENT_COMMAND ) { // note: dynamic_cast is not possible as GetData() returns a void* CommandEvent* pCmdEvent = reinterpret_cast< CommandEvent* >(rNEvt.GetData()); nRet = HandleScrollCommand(*pCmdEvent, pWin); } return nRet; } BOOL ViewShell::HandleScrollCommand(const CommandEvent& rCEvt, ::sd::Window* pWin) { BOOL bDone = FALSE; switch( rCEvt.GetCommand() ) { case COMMAND_WHEEL: case COMMAND_STARTAUTOSCROLL: case COMMAND_AUTOSCROLL: { const CommandWheelData* pData = rCEvt.GetWheelData(); if (pData != NULL) { if (pData->IsMod1()) { if( !GetDocSh()->IsUIActive() ) { const long nOldZoom = GetActiveWindow()->GetZoom(); long nNewZoom; if( pData->GetDelta() < 0L ) nNewZoom = Max( (long) pWin->GetMinZoom(), (long)(nOldZoom - DELTA_ZOOM) ); else nNewZoom = Min( (long) pWin->GetMaxZoom(), (long)(nOldZoom + DELTA_ZOOM) ); SetZoom( nNewZoom ); Invalidate( SID_ATTR_ZOOM ); bDone = TRUE; } } else { if( mpContentWindow.get() == pWin ) { ULONG nScrollLines = pData->GetScrollLines(); if(IsPageFlipMode()) nScrollLines = COMMAND_WHEEL_PAGESCROLL; CommandWheelData aWheelData( pData->GetDelta(),pData->GetNotchDelta(), nScrollLines,pData->GetMode(),pData->GetModifier(),pData->IsHorz() ); CommandEvent aReWrite( rCEvt.GetMousePosPixel(),rCEvt.GetCommand(), rCEvt.IsMouseEvent(),(const void *) &aWheelData ); bDone = pWin->HandleScrollCommand( aReWrite, mpHorizontalScrollBar.get(), mpVerticalScrollBar.get()); } } } } break; default: break; } return bDone; } void ViewShell::SetupRulers (void) { if (mbHasRulers && (mpContentWindow.get() != NULL) && (mpSlideShow==NULL) ) { long nHRulerOfs = 0; if ( mpVerticalRuler.get() == NULL ) { mpVerticalRuler.reset(CreateVRuler(GetActiveWindow())); if ( mpVerticalRuler.get() != NULL ) { nHRulerOfs = mpVerticalRuler->GetSizePixel().Width(); mpVerticalRuler->SetActive(TRUE); mpVerticalRuler->Show(); } } if ( mpHorizontalRuler.get() == NULL ) { mpHorizontalRuler.reset(CreateHRuler(GetActiveWindow(), TRUE)); if ( mpHorizontalRuler.get() != NULL ) { mpHorizontalRuler->SetWinPos(nHRulerOfs); mpHorizontalRuler->SetActive(TRUE); mpHorizontalRuler->Show(); } } } /* SvBorder aBorder ( bHasRuler && pVRulerArray[0]!=NULL ? pVRulerArray[0]->GetSizePixel().Width() : 0, bHasRuler && pHRulerArray[0]!=NULL ? pHRulerArray[0]->GetSizePixel().Height() : 0, aScrBarWH.Width(), aScrBarWH.Height()); GetViewShellBase().SetBorderPixel (aBorder); */ } BOOL ViewShell::HasRuler (void) { return mbHasRulers; } void ViewShell::Resize (const Point& rPos, const Size& rSize) { SetupRulers (); // AdjustPosSizePixel(rPos, rSize); // Make sure that the new size is not degenerate. if ( !rSize.Width() || !rSize.Height() ) return; // Remember the new position and size. aViewPos = rPos; aViewSize = rSize; // Rearrange the UI elements to take care of the new position and size. ArrangeGUIElements (); // end of included AdjustPosSizePixel. Size aS (GetParentWindow()->GetOutputSizePixel()); Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel(); Rectangle aVisArea = GetParentWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel)); Rectangle aCurrentVisArea (GetDocSh()->GetVisArea(ASPECT_CONTENT)); Rectangle aWindowRect = GetActiveWindow()->LogicToPixel(aCurrentVisArea); if (GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED && IsMainViewShell()) { // GetDocSh()->SetVisArea(aVisArea); } // VisAreaChanged(aVisArea); ::sd::View* pView = GetView(); if (pView) { pView->VisAreaChanged(GetActiveWindow()); } } SvBorder ViewShell::GetBorder (bool bOuterResize) { SvBorder aBorder; // Horizontal scrollbar. if (mpHorizontalScrollBar.get()!=NULL && mpHorizontalScrollBar->IsVisible()) { aBorder.Bottom() = aScrBarWH.Height(); } // Vertical scrollbar. if (mpVerticalScrollBar.get()!=NULL && mpVerticalScrollBar->IsVisible()) { aBorder.Right() = aScrBarWH.Width(); } // Place horizontal ruler below tab bar. if (mbHasRulers && mpContentWindow.get() != NULL) { SetupRulers(); if (mpHorizontalRuler.get() != NULL) aBorder.Top() = mpHorizontalRuler->GetSizePixel().Height(); if (mpVerticalRuler.get() != NULL) aBorder.Left() = mpVerticalRuler->GetSizePixel().Width(); } return aBorder; } void ViewShell::ArrangeGUIElements (void) { bool bVisible = mpContentWindow->IsVisible(); if (mpImpl->mbArrangeActive) return; mpImpl->mbArrangeActive = true; // Calculate border for in-place editing. long nLeft = aViewPos.X(); long nTop = aViewPos.Y(); long nRight = aViewPos.X() + aViewSize.Width(); long nBottom = aViewPos.Y() + aViewSize.Height(); // Horizontal scrollbar. if (mpHorizontalScrollBar.get()!=NULL && mpHorizontalScrollBar->IsVisible()) { int nLocalLeft = nLeft; if (mpLayerTabBar.get()!=NULL && mpLayerTabBar->IsVisible()) nLocalLeft += mpLayerTabBar->GetSizePixel().Width(); nBottom -= aScrBarWH.Height(); mpHorizontalScrollBar->SetPosSizePixel ( Point(nLocalLeft,nBottom), Size(nRight-nLocalLeft-aScrBarWH.Width(),aScrBarWH.Height())); } // Vertical scrollbar. if (mpVerticalScrollBar.get()!=NULL && mpVerticalScrollBar->IsVisible()) { nRight -= aScrBarWH.Width(); mpVerticalScrollBar->SetPosSizePixel ( Point(nRight,nTop), Size (aScrBarWH.Width(),nBottom-nTop)); } // Filler in the lower right corner. if (mpScrollBarBox.get() != NULL) if (mpHorizontalScrollBar.get()!=NULL && mpHorizontalScrollBar->IsVisible() && mpVerticalScrollBar.get()!=NULL && mpVerticalScrollBar->IsVisible()) { mpScrollBarBox->Show(); mpScrollBarBox->SetPosSizePixel(Point(nRight, nBottom), aScrBarWH); } else mpScrollBarBox->Hide(); // Place horizontal ruler below tab bar. if (mbHasRulers && mpContentWindow.get() != NULL) { if (mpHorizontalRuler.get() != NULL) { Size aRulerSize = mpHorizontalRuler->GetSizePixel(); aRulerSize.Width() = nRight - nLeft; mpHorizontalRuler->SetPosSizePixel ( Point(nLeft,nTop), aRulerSize); if (mpVerticalRuler.get() != NULL) mpHorizontalRuler->SetBorderPos( mpVerticalRuler->GetSizePixel().Width()-1); nTop += aRulerSize.Height(); } if (mpVerticalRuler.get() != NULL) { Size aRulerSize = mpVerticalRuler->GetSizePixel(); aRulerSize.Height() = nBottom - nTop; mpVerticalRuler->SetPosSizePixel ( Point (nLeft,nTop), aRulerSize); nLeft += aRulerSize.Width(); } } // The size of the window of the center pane is set differently from // that of the windows in the docking windows. bool bSlideShowActive = mpSlideShow != NULL && ! mpSlideShow->isTerminated() && ! mpSlideShow->isFullScreen() && mpSlideShow->getAnimationMode() == ANIMATIONMODE_SHOW; if ( ! bSlideShowActive) { SfxViewShell* pViewShell = GetViewShell(); OSL_ASSERT (pViewShell!=NULL); mpContentWindow->SetPosSizePixel( Point(nLeft,nTop), Size(nRight-nLeft,nBottom-nTop)); } // Windows in the center and rulers at the left and top side. maAllWindowRectangle = Rectangle( aViewPos, Size(aViewSize.Width()-aScrBarWH.Width(), aViewSize.Height()-aScrBarWH.Height())); if (mpContentWindow.get() != NULL) { mpContentWindow->UpdateMapOrigin(); } UpdateScrollBars(); mpImpl->mbArrangeActive = false; } void ViewShell::SetUIUnit(FieldUnit eUnit) { // Set unit at horizontal and vertical rulers. if (mpHorizontalRuler.get() != NULL) mpHorizontalRuler->SetUnit(eUnit); if (mpVerticalRuler.get() != NULL) mpVerticalRuler->SetUnit(eUnit); } /************************************************************************* |* |* DefTab an den horizontalen Linealen setzen |* \************************************************************************/ void ViewShell::SetDefTabHRuler( UINT16 nDefTab ) { if (mpHorizontalRuler.get() != NULL) mpHorizontalRuler->SetDefTabDist( nDefTab ); } /** Tell the FmFormShell that the view shell is closing. Give it the oportunity to prevent that. */ USHORT ViewShell::PrepareClose (BOOL bUI, BOOL bForBrowsing) { USHORT nResult = TRUE; FmFormShell* pFormShell = GetViewShellBase().GetFormShellManager().GetFormShell(); if (pFormShell != NULL) nResult = pFormShell->PrepareClose (bUI, bForBrowsing); return nResult; } void ViewShell::UpdatePreview (SdPage* pPage, BOOL bInit) { // Do nothing. After the actual preview has been removed, // OutlineViewShell::UpdatePreview() is the place where something // usefull is still done. } SfxUndoManager* ViewShell::ImpGetUndoManager (void) const { const ViewShell* pMainViewShell = GetViewShellBase().GetMainViewShell(); if( pMainViewShell == 0 ) pMainViewShell = this; ::sd::View* pView = pMainViewShell->GetView(); // check for text edit our outline view if( pView ) { if( pMainViewShell->GetShellType() == ViewShell::ST_OUTLINE ) { OutlineView* pOlView = dynamic_cast< OutlineView* >( pView ); if( pOlView ) { ::Outliner* pOutl = pOlView->GetOutliner(); if( pOutl ) return &pOutl->GetUndoManager(); } } else if( pView->IsTextEdit() ) { SdrOutliner* pOL = pView->GetTextEditOutliner(); if( pOL ) return &pOL->GetUndoManager(); } } if( GetDocSh() ) return GetDocSh()->GetUndoManager(); return NULL; } void ViewShell::ImpGetUndoStrings(SfxItemSet &rSet) const { SfxUndoManager* pUndoManager = ImpGetUndoManager(); if(pUndoManager) { sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); if(nCount) { // prepare list List aStringList; sal_uInt16 a; for( a = 0; a < nCount; a++) { // generate one String in list per undo step String* pInsertString = new String(pUndoManager->GetUndoActionComment(a)); aStringList.Insert(pInsertString, LIST_APPEND); } // set item rSet.Put(SfxStringListItem(SID_GETUNDOSTRINGS, &aStringList)); // delete Strings again for(a = 0; a < nCount; a++) delete (String*)aStringList.GetObject(a); } else { rSet.DisableItem(SID_GETUNDOSTRINGS); } } } // ----------------------------------------------------------------------------- void ViewShell::ImpGetRedoStrings(SfxItemSet &rSet) const { SfxUndoManager* pUndoManager = ImpGetUndoManager(); if(pUndoManager) { sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); if(nCount) { // prepare list List aStringList; sal_uInt16 a; for( a = 0; a < nCount; a++) { // generate one String in list per undo step String* pInsertString = new String(pUndoManager->GetRedoActionComment(a)); aStringList.Insert(pInsertString, LIST_APPEND); } // set item rSet.Put(SfxStringListItem(SID_GETREDOSTRINGS, &aStringList)); // delete Strings again for(a = 0; a < nCount; a++) delete (String*)aStringList.GetObject(a); } else { rSet.DisableItem(SID_GETREDOSTRINGS); } } } // ----------------------------------------------------------------------------- void ViewShell::ImpSidUndo(BOOL bDrawViewShell, SfxRequest& rReq) { SfxUndoManager* pUndoManager = ImpGetUndoManager(); sal_uInt16 nNumber(1); const SfxItemSet* pReqArgs = rReq.GetArgs(); if(pReqArgs) { SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_UNDO); nNumber = pUIntItem->GetValue(); } if(nNumber && pUndoManager) { sal_uInt16 nCount(pUndoManager->GetUndoActionCount()); if(nCount >= nNumber) { // #94637# when UndoStack is cleared by ModifyPageUndoAction // the nCount may have changed, so test GetUndoActionCount() while(nNumber-- && pUndoManager->GetUndoActionCount()) { pUndoManager->Undo(); } } // #91081# refresh rulers, maybe UNDO was move of TAB marker in ruler if (mbHasRulers) { Invalidate(SID_ATTR_TABSTOP); } } // This one is corresponding to the default handling // of SID_UNDO in sfx2 GetViewFrame()->GetBindings().InvalidateAll(sal_False); rReq.Done(); } // ----------------------------------------------------------------------------- void ViewShell::ImpSidRedo(BOOL bDrawViewShell, SfxRequest& rReq) { SfxUndoManager* pUndoManager = ImpGetUndoManager(); sal_uInt16 nNumber(1); const SfxItemSet* pReqArgs = rReq.GetArgs(); if(pReqArgs) { SfxUInt16Item* pUIntItem = (SfxUInt16Item*)&pReqArgs->Get(SID_REDO); nNumber = pUIntItem->GetValue(); } if(nNumber && pUndoManager) { sal_uInt16 nCount(pUndoManager->GetRedoActionCount()); if(nCount >= nNumber) { // #94637# when UndoStack is cleared by ModifyPageRedoAction // the nCount may have changed, so test GetRedoActionCount() while(nNumber-- && pUndoManager->GetRedoActionCount()) { pUndoManager->Redo(); } } // #91081# refresh rulers, maybe REDO was move of TAB marker in ruler if (mbHasRulers) { Invalidate(SID_ATTR_TABSTOP); } } // This one is corresponding to the default handling // of SID_UNDO in sfx2 GetViewFrame()->GetBindings().InvalidateAll(sal_False); rReq.Done(); } // ----------------------------------------------------------------------------- void ViewShell::ExecReq( SfxRequest& rReq ) { USHORT nSlot = rReq.GetSlot(); switch( nSlot ) { case SID_MAIL_SCROLLBODY_PAGEDOWN: { FunctionReference xFunc( GetCurrentFunction() ); if( xFunc.is() ) { xFunc->ScrollStart(); ScrollLines( 0, -1 ); xFunc->ScrollEnd(); } rReq.Done(); } break; case SID_OUTPUT_QUALITY_COLOR: case SID_OUTPUT_QUALITY_GRAYSCALE: case SID_OUTPUT_QUALITY_BLACKWHITE: case SID_OUTPUT_QUALITY_CONTRAST: { ULONG nMode = OUTPUT_DRAWMODE_COLOR; switch( nSlot ) { case SID_OUTPUT_QUALITY_COLOR: nMode = OUTPUT_DRAWMODE_COLOR; break; case SID_OUTPUT_QUALITY_GRAYSCALE: nMode = OUTPUT_DRAWMODE_GRAYSCALE; break; case SID_OUTPUT_QUALITY_BLACKWHITE: nMode = OUTPUT_DRAWMODE_BLACKWHITE; break; case SID_OUTPUT_QUALITY_CONTRAST: nMode = OUTPUT_DRAWMODE_CONTRAST; break; } GetActiveWindow()->SetDrawMode( nMode ); pFrameView->SetDrawMode( nMode ); // #110094#-7 // GetView()->ReleaseMasterPagePaintCache(); GetActiveWindow()->Invalidate(); Invalidate(); rReq.Done(); break; } } } /** This default implemenation returns only an empty reference. See derived classes for more interesting examples. */ ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible> ViewShell::CreateAccessibleDocumentView (::sd::Window* pWindow) { return ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible> (); } ::sd::WindowUpdater* ViewShell::GetWindowUpdater (void) const { return mpWindowUpdater.get(); } ViewShellBase& ViewShell::GetViewShellBase (void) const { return *static_cast(GetViewShell()); } ViewShell::ShellType ViewShell::GetShellType (void) const { return meShellType; } DrawDocShell* ViewShell::GetDocSh (void) const { return GetViewShellBase().GetDocShell(); } SdDrawDocument* ViewShell::GetDoc (void) const { return GetViewShellBase().GetDocument(); } ErrCode ViewShell::DoVerb (long nVerb) { return ERRCODE_NONE; } void ViewShell::SetCurrentFunction( const FunctionReference& xFunction) { if( mxCurrentFunction.is() && (mxOldFunction != mxCurrentFunction) ) mxCurrentFunction->Dispose(); FunctionReference xTemp( mxCurrentFunction ); mxCurrentFunction = xFunction; } void ViewShell::SetOldFunction(const FunctionReference& xFunction) { if( mxOldFunction.is() && (xFunction != mxOldFunction) && (mxCurrentFunction != mxOldFunction) ) mxOldFunction->Dispose(); FunctionReference xTemp( mxOldFunction ); mxOldFunction = xFunction; } /** this method deactivates the current function. If an old function is saved, this will become activated and current function. */ void ViewShell::Cancel() { if(mxCurrentFunction.is() && (mxCurrentFunction != mxOldFunction )) { FunctionReference xTemp( mxCurrentFunction ); mxCurrentFunction.clear(); xTemp->Deactivate(); xTemp->Dispose(); } if(mxOldFunction.is()) { mxCurrentFunction = mxOldFunction; mxCurrentFunction->Activate(); } } void ViewShell::DeactivateCurrentFunction( bool bPermanent /* == false */ ) { if( mxCurrentFunction.is() ) { if(bPermanent && (mxOldFunction == mxCurrentFunction)) mxOldFunction.clear(); mxCurrentFunction->Deactivate(); if( mxCurrentFunction != mxOldFunction ) mxCurrentFunction->Dispose(); FunctionReference xTemp( mxCurrentFunction ); mxCurrentFunction.clear(); } } void ViewShell::DisposeFunctions() { if(mxCurrentFunction.is()) { FunctionReference xTemp( mxCurrentFunction ); mxCurrentFunction.clear(); xTemp->Deactivate(); xTemp->Dispose(); } if(mxOldFunction.is()) { FunctionReference xTemp( mxOldFunction ); mxOldFunction->Dispose(); mxOldFunction.clear(); } } void ViewShell::SetSlideShow(sd::Slideshow* pSlideShow) { if( mpSlideShow ) delete mpSlideShow; mpSlideShow = pSlideShow; } bool ViewShell::IsMainViewShell (void) const { return GetViewShellBase().GetMainViewShell() == this; } void ViewShell::SetIsMainViewShell (bool bIsMainViewShell) { if (bIsMainViewShell != mpImpl->mbIsMainViewShell) { mpImpl->mbIsMainViewShell = bIsMainViewShell; if (bIsMainViewShell) { GetDocSh()->Connect (this); } else { GetDocSh()->Disconnect (this); } } } ::sd::Window* ViewShell::GetActiveWindow (void) const { return mpActiveWindow; } void ViewShell::Paint (const Rectangle& rRect, ::sd::Window* pWin) { } void ViewShell::Draw(OutputDevice &rDev, const Region &rReg) { } ZoomList* ViewShell::GetZoomList (void) { return pZoomList; } void ViewShell::ShowUIControls (bool bVisible) { mpImpl->mbIsShowingUIControls = bVisible; if (mbHasRulers) { if (mpHorizontalRuler.get() != NULL) mpHorizontalRuler->Show( bVisible ); if (mpVerticalRuler.get() != NULL) mpVerticalRuler->Show( bVisible ); } if (mpVerticalScrollBar.get() != NULL) mpVerticalScrollBar->Show( bVisible ); if (mpHorizontalScrollBar.get() != NULL) mpHorizontalScrollBar->Show( bVisible ); if (mpScrollBarBox.get() != NULL) mpScrollBarBox->Show(bVisible); if (mpContentWindow.get() != NULL) mpContentWindow->Show( bVisible ); } } // end of namespace sd //===== ViewShellObjectBarFactory ============================================= namespace { ViewShellObjectBarFactory::ViewShellObjectBarFactory ( ::sd::ViewShell& rViewShell) : mrViewShell (rViewShell) { } ViewShellObjectBarFactory::~ViewShellObjectBarFactory (void) { for (ShellCache::iterator aI(maShellCache.begin()); aI!=maShellCache.end(); aI++) { delete aI->second; } } SfxShell* ViewShellObjectBarFactory::CreateShell ( ::sd::ShellId nId, ::Window* pParentWindow, ::sd::FrameView* pFrameView) { SfxShell* pShell = NULL; ShellCache::iterator aI (maShellCache.find(nId)); if (aI == maShellCache.end() || aI->second==NULL) { ::sd::View* pView = mrViewShell.GetView(); switch (nId) { case RID_BEZIER_TOOLBOX: pShell = new ::sd::BezierObjectBar(&mrViewShell, pView); break; case RID_DRAW_TEXT_TOOLBOX: pShell = new ::sd::TextObjectBar( &mrViewShell, mrViewShell.GetDoc()->GetPool(), pView); break; case RID_DRAW_GRAF_TOOLBOX: pShell = new ::sd::GraphicObjectBar(&mrViewShell, pView); break; case RID_DRAW_MEDIA_TOOLBOX: pShell = new ::sd::MediaObjectBar(&mrViewShell, pView); break; case RID_SVX_EXTRUSION_BAR: pShell = new ::svx::ExtrusionBar( &mrViewShell.GetViewShellBase()); break; case RID_SVX_FONTWORK_BAR: pShell = new ::svx::FontworkBar( &mrViewShell.GetViewShellBase()); break; default: pShell = NULL; break; } } else pShell = aI->second; return pShell; } void ViewShellObjectBarFactory::ReleaseShell (SfxShell* pShell) { if (pShell != NULL) delete pShell; } } // end of anonymous namespace