498 lines
19 KiB
C++
Executable file
498 lines
19 KiB
C++
Executable file
/*************************************************************************
|
|
*
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* Copyright 2000, 2010 Oracle and/or its affiliates.
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* This file is part of OpenOffice.org.
|
|
*
|
|
* OpenOffice.org is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License version 3
|
|
* only, as published by the Free Software Foundation.
|
|
*
|
|
* OpenOffice.org 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 version 3 for more details
|
|
* (a copy is included in the LICENSE file that accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* version 3 along with OpenOffice.org. If not, see
|
|
* <http://www.openoffice.org/license.html>
|
|
* for a copy of the LGPLv3 License.
|
|
*
|
|
************************************************************************/
|
|
|
|
#ifndef SD_DRAW_VIEW_SHELL_HXX
|
|
#define SD_DRAW_VIEW_SHELL_HXX
|
|
|
|
#include "ViewShell.hxx"
|
|
#include "tools/AsynchronousCall.hxx"
|
|
#include <sfx2/viewfac.hxx>
|
|
#include <sfx2/viewsh.hxx>
|
|
#include "TabControl.hxx"
|
|
#include "pres.hxx"
|
|
#include <com/sun/star/lang/XEventListener.hpp>
|
|
#include <com/sun/star/scanner/XScannerManager.hpp>
|
|
|
|
class SdPage;
|
|
class DrawDocShell;
|
|
class SdAnimationWin;
|
|
class SdRuler;
|
|
class TabBar;
|
|
class SdrObject;
|
|
class SdrPageView;
|
|
class TransferableDataHelper;
|
|
class TransferableClipboardListener;
|
|
class AbstractSvxNameDialog;
|
|
class SdrLayer;
|
|
class SvxClipboardFmtItem;
|
|
|
|
namespace sd {
|
|
|
|
class DrawView;
|
|
class LayerTabBar;
|
|
class Ruler;
|
|
class SdUnoDrawView;
|
|
class AnnotationManager;
|
|
class ViewOverlayManager;
|
|
|
|
#define CHECK_RANGE(nMin, nValue, nMax) ((nValue >= nMin) && (nValue <= nMax))
|
|
|
|
/** Base class of the stacked shells that provide graphical views to
|
|
Draw and Impress documents and editing functionality. In contrast
|
|
to this other stacked shells are responsible for showing an
|
|
overview over several slides (SlideViewShell) or a textual
|
|
overview over the text in an Impress document (OutlineViewShell).
|
|
*/
|
|
class DrawViewShell
|
|
: public ViewShell,
|
|
public SfxListener
|
|
{
|
|
public:
|
|
static const int SLOTARRAY_COUNT = 24;
|
|
|
|
TYPEINFO();
|
|
|
|
SFX_DECL_INTERFACE(SD_IF_SDDRAWVIEWSHELL)
|
|
|
|
/** Create a new stackable shell that may take some information
|
|
(e.g. the frame view) from the given previous shell.
|
|
@param ePageKind
|
|
This parameter gives the initial page kind that the new shell
|
|
will show.
|
|
@param pFrameView
|
|
The frame view that makes it possible to pass information from
|
|
one view shell to the next.
|
|
*/
|
|
DrawViewShell (
|
|
SfxViewFrame* pFrame,
|
|
ViewShellBase& rViewShellBase,
|
|
::Window* pParentWindow,
|
|
PageKind ePageKind = PK_STANDARD,
|
|
FrameView* pFrameView = NULL);
|
|
|
|
virtual ~DrawViewShell (void);
|
|
|
|
virtual void Init (bool bIsMainViewShell);
|
|
|
|
virtual void Shutdown (void);
|
|
|
|
void PrePaint();
|
|
virtual void Paint(const Rectangle& rRect, ::sd::Window* pWin);
|
|
|
|
/** Set the position and size of the area which contains the GUI
|
|
elements like rulers, sliders, and buttons as well as the document
|
|
view. Both size and position are expected to be in pixel
|
|
coordinates. The positions and sizes of the mentioned GUI elements
|
|
are updated as well.
|
|
|
|
<p> This method is implemented by first setting copying the given
|
|
values to internal variables and then calling the
|
|
<type>ArrangeGUIElements</type> method which performs the actual
|
|
work of sizeing and arranging the UI elements accordingly.</p>
|
|
@param rPos
|
|
The position of the enclosing window relative to the document
|
|
window. This is only interesting if a Draw/Impress document
|
|
view is embedded as OLE object into another document view. For
|
|
normal documents this position is (0,0).
|
|
@param rSize
|
|
The new size in pixel.
|
|
*/
|
|
// virtual void AdjustPosSizePixel(const Point &rPos, const Size &rSize);
|
|
|
|
/** Arrange and resize the GUI elements like rulers, sliders, and
|
|
buttons as well as the actual document view according to the size of
|
|
the enclosing window and current sizes of buttons, rulers, and
|
|
sliders.
|
|
*/
|
|
virtual void ArrangeGUIElements (void);
|
|
|
|
void HidePage();
|
|
|
|
virtual BOOL KeyInput(const KeyEvent& rKEvt, ::sd::Window* pWin);
|
|
virtual void MouseMove(const MouseEvent& rMEvt, ::sd::Window* pWin);
|
|
virtual void MouseButtonUp(const MouseEvent& rMEvt, ::sd::Window* pWin);
|
|
virtual void MouseButtonDown(const MouseEvent& rMEvt, ::sd::Window* pWin);
|
|
virtual void Command(const CommandEvent& rCEvt, ::sd::Window* pWin);
|
|
|
|
virtual void Resize (void);
|
|
|
|
void ShowMousePosInfo(const Rectangle& rRect, ::sd::Window* pWin);
|
|
|
|
virtual void AddWindow(::sd::Window* pWin);
|
|
virtual void RemoveWindow(::sd::Window* pWin);
|
|
|
|
virtual void ChangeEditMode (EditMode eMode, bool bIsLayerModeActive);
|
|
|
|
virtual void SetZoom( long nZoom );
|
|
virtual void SetZoomRect( const Rectangle& rZoomRect );
|
|
|
|
void InsertURLField(const String& rURL, const String& rText, const String& rTarget,
|
|
const Point* pPos);
|
|
void InsertURLButton(const String& rURL, const String& rText, const String& rTarget,
|
|
const Point* pPos);
|
|
|
|
virtual void SetUIUnit(FieldUnit eUnit);
|
|
|
|
void SelectionHasChanged();
|
|
void ModelHasChanged();
|
|
virtual void Activate(BOOL bIsMDIActivate);
|
|
virtual void Deactivate(BOOL IsMDIActivate);
|
|
virtual void UIActivating( SfxInPlaceClient* );
|
|
virtual void UIDeactivated( SfxInPlaceClient* );
|
|
virtual String GetSelectionText( BOOL bCompleteWords = FALSE );
|
|
virtual BOOL HasSelection( BOOL bText = TRUE ) const;
|
|
|
|
void ExecCtrl(SfxRequest& rReq);
|
|
void GetCtrlState(SfxItemSet& rSet);
|
|
void GetMenuState(SfxItemSet& rSet);
|
|
void GetTableMenuState(SfxItemSet& rSet);
|
|
/** Set the items of the given item set that are related to
|
|
switching the editing mode to the correct values.
|
|
<p>This function also sets the states of the mode buttons
|
|
(those at the upper right corner) accordingly.</p>
|
|
*/
|
|
void GetModeSwitchingMenuState (SfxItemSet &rSet);
|
|
void GetAttrState(SfxItemSet& rSet);
|
|
void GetSnapItemState(SfxItemSet& rSet);
|
|
|
|
void GetState (SfxItemSet& rSet);
|
|
void Execute (SfxRequest& rReq);
|
|
|
|
void ExecStatusBar(SfxRequest& rReq);
|
|
void GetStatusBarState(SfxItemSet& rSet);
|
|
|
|
void ExecOptionsBar(SfxRequest& rReq);
|
|
void GetOptionsBarState(SfxItemSet& rSet);
|
|
|
|
void ExecRuler(SfxRequest& rReq);
|
|
void GetRulerState(SfxItemSet& rSet);
|
|
|
|
void ExecFormText(SfxRequest& rReq);
|
|
void GetFormTextState(SfxItemSet& rSet);
|
|
|
|
void ExecAnimationWin(SfxRequest& rReq);
|
|
void GetAnimationWinState(SfxItemSet& rSet);
|
|
|
|
void ExecNavigatorWin(SfxRequest& rReq);
|
|
void GetNavigatorWinState(SfxItemSet& rSet);
|
|
|
|
void ExecEffectWin(SfxRequest& rReq);
|
|
|
|
void Update3DWindow();
|
|
void AssignFrom3DWindow();
|
|
|
|
void ExecGallery(SfxRequest& rReq);
|
|
void GetGalleryState(SfxItemSet& rSet);
|
|
|
|
void ExecBmpMask( SfxRequest& rReq );
|
|
void GetBmpMaskState( SfxItemSet& rSet );
|
|
|
|
void ExecIMap( SfxRequest& rReq );
|
|
void GetIMapState( SfxItemSet& rSet );
|
|
|
|
void FuTemporary(SfxRequest& rReq);
|
|
void FuPermanent(SfxRequest& rReq);
|
|
void FuSupport(SfxRequest& rReq);
|
|
void FuTable(SfxRequest& rReq);
|
|
|
|
void AttrExec (SfxRequest& rReq);
|
|
void AttrState (SfxItemSet& rSet);
|
|
|
|
void ExecuteAnnotation (SfxRequest& rRequest);
|
|
void GetAnnotationState (SfxItemSet& rItemSet);
|
|
|
|
void StartRulerDrag (
|
|
const Ruler& rRuler,
|
|
const MouseEvent& rMEvt);
|
|
|
|
virtual USHORT PrepareClose( BOOL bUI = TRUE, BOOL bForBrowsing = FALSE );
|
|
|
|
PageKind GetPageKind() { return mePageKind; }
|
|
|
|
Point GetMousePos() { return maMousePos; }
|
|
BOOL IsMousePosFreezed() { return mbMousePosFreezed; }
|
|
void SetMousePosFreezed( BOOL bIn ) { mbMousePosFreezed = bIn; }
|
|
|
|
EditMode GetEditMode() const { return meEditMode; }
|
|
virtual SdPage* GetActualPage() { return mpActualPage; }
|
|
|
|
/// inherited from sd::ViewShell
|
|
virtual SdPage* getCurrentPage() const;
|
|
|
|
void ResetActualPage();
|
|
void ResetActualLayer();
|
|
BOOL SwitchPage(USHORT nPage);
|
|
BOOL IsSwitchPageAllowed() const;
|
|
|
|
BOOL GotoBookmark(const String& rBookmark);
|
|
void MakeVisible(const Rectangle& rRect, ::Window& rWin);
|
|
|
|
virtual void ReadFrameViewData(FrameView* pView);
|
|
virtual void WriteFrameViewData();
|
|
|
|
virtual ErrCode DoVerb(long nVerb);
|
|
virtual BOOL ActivateObject(SdrOle2Obj* pObj, long nVerb);
|
|
|
|
void SetZoomOnPage( BOOL bZoom = TRUE ) { mbZoomOnPage = bZoom; }
|
|
BOOL IsZoomOnPage() { return mbZoomOnPage; }
|
|
void CheckLineTo (SfxRequest& rReq);
|
|
void FuTemp01(SfxRequest& rReq);
|
|
void FuTemp02(SfxRequest& rReq);
|
|
void FuTemp03(SfxRequest& rReq);
|
|
void FuTemp04(SfxRequest& rReq);
|
|
void SetChildWindowState( SfxItemSet& rSet );
|
|
|
|
void UpdateIMapDlg( SdrObject* pObj );
|
|
|
|
void LockInput();
|
|
void UnlockInput();
|
|
BOOL IsInputLocked() const { return mnLockCount > 0UL; }
|
|
|
|
USHORT GetCurPageId() { return( maTabControl.GetCurPageId() ); }
|
|
|
|
/** Show controls of the UI or hide them, depending on the given flag.
|
|
Do not call this method directly. Call the method at ViewShellBase
|
|
instead.
|
|
*/
|
|
virtual void ShowUIControls (bool bVisible = true);
|
|
|
|
void ScannerEvent( const ::com::sun::star::lang::EventObject& rEventObject );
|
|
|
|
bool IsLayerModeActive (void) const;
|
|
|
|
USHORT* GetSlotArray() const { return mpSlotArray; }
|
|
|
|
virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt, DropTargetHelper& rTargetHelper,
|
|
::sd::Window* pTargetWindow, USHORT nPage, USHORT nLayer );
|
|
virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt, DropTargetHelper& rTargetHelper,
|
|
::sd::Window* pTargetWindow, USHORT nPage, USHORT nLayer );
|
|
|
|
virtual void WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool bBrowse = sal_False );
|
|
virtual void ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >&, sal_Bool bBrowse = sal_False );
|
|
|
|
virtual void VisAreaChanged(const Rectangle& rRect);
|
|
|
|
/** Create an accessible object representing the specified window.
|
|
@param pWindow
|
|
The returned object makes the document displayed in this window
|
|
accessible.
|
|
@return
|
|
Returns an <type>AccessibleDrawDocumentView</type> object.
|
|
*/
|
|
virtual ::com::sun::star::uno::Reference<
|
|
::com::sun::star::accessibility::XAccessible>
|
|
CreateAccessibleDocumentView (::sd::Window* pWindow);
|
|
|
|
/** Return the number of layers managed by the layer tab control. This
|
|
will usually differ from the number of layers managed by the layer
|
|
administrator.
|
|
@return
|
|
The number of layers managed by the layer tab control. The
|
|
returned value is independent of whether the layer modus is
|
|
currently active and the tab control is visible.
|
|
*/
|
|
virtual int GetTabLayerCount (void) const;
|
|
|
|
/** Return the numerical id of the currently active layer as seen by the
|
|
layer tab control.
|
|
@return
|
|
The returned id is a number between zero (inclusive) and the
|
|
number of layers as returned by the
|
|
<member>GetTabLayerCount</member> method (exclusive).
|
|
*/
|
|
virtual int GetActiveTabLayerIndex (void) const;
|
|
|
|
/** Set the active layer at the layer tab control and update the control
|
|
accordingly to reflect the change on screen.
|
|
@param nId
|
|
The id is expected to be a number between zero (inclusive) and
|
|
the number of layers as returned by the
|
|
<member>GetTabLayerCount</member> method (exclusive). Note that
|
|
Invalid values are ignored. No excpetion is thrown in that case.
|
|
*/
|
|
virtual void SetActiveTabLayerIndex (int nId);
|
|
|
|
/** Return a pointer to the tab control for pages.
|
|
*/
|
|
TabControl* GetPageTabControl (void);
|
|
|
|
/** Return a pointer to the tab control for layers.
|
|
*/
|
|
LayerTabBar* GetLayerTabControl (void);
|
|
|
|
/** Renames the given slide using an SvxNameDialog
|
|
|
|
@param nPageId the index of the page in the SdTabControl.
|
|
@param rName the new name of the slide.
|
|
|
|
@return false, if the new name is invalid for some reason.
|
|
|
|
<p>Implemented in <code>drviews8.cxx</code>.</p>
|
|
*/
|
|
bool RenameSlide( USHORT nPageId, const String & rName );
|
|
|
|
/** modifies the given layer with the given values */
|
|
void ModifyLayer( SdrLayer* pLayer, const String& rLayerName, const String& rLayerTitle, const String& rLayerDesc, bool bIsVisible, bool bIsLocked, bool bIsPrintable );
|
|
|
|
virtual css::uno::Reference<css::drawing::XDrawSubController> CreateSubController (void);
|
|
|
|
DrawView* GetDrawView() const { return mpDrawView; }
|
|
|
|
/** Relocation to a new parent window is not supported for DrawViewShell
|
|
objects so this method always returns <FALSE/>.
|
|
*/
|
|
virtual bool RelocateToParentWindow (::Window* pParentWindow);
|
|
|
|
protected:
|
|
DrawView* mpDrawView;
|
|
SdPage* mpActualPage;
|
|
Rectangle maMarkRect;
|
|
Point maMousePos;
|
|
BOOL mbMousePosFreezed;
|
|
TabControl maTabControl;
|
|
EditMode meEditMode;
|
|
PageKind mePageKind;
|
|
BOOL mbZoomOnPage;
|
|
BOOL mbIsRulerDrag;
|
|
ULONG mnLockCount;
|
|
Timer maCloseTimer;
|
|
BOOL mbReadOnly;
|
|
USHORT* mpSlotArray;
|
|
|
|
static BOOL mbPipette;
|
|
|
|
DECL_LINK( ClipboardChanged, TransferableDataHelper* );
|
|
DECL_LINK( CloseHdl, Timer* pTimer );
|
|
DECL_LINK( TabSplitHdl, TabBar * );
|
|
DECL_LINK( NameObjectHdl, AbstractSvxNameDialog* );
|
|
DECL_LINK( RenameSlideHdl, AbstractSvxNameDialog* );
|
|
|
|
void DeleteActualPage();
|
|
void DeleteActualLayer();
|
|
|
|
virtual SvxRuler* CreateHRuler(::sd::Window* pWin, BOOL bIsFirst);
|
|
virtual SvxRuler* CreateVRuler(::sd::Window* pWin);
|
|
virtual void UpdateHRuler();
|
|
virtual void UpdateVRuler();
|
|
virtual long GetHCtrlWidth();
|
|
virtual void SetZoomFactor(const Fraction& rZoomX, const Fraction& rZoomY);
|
|
virtual Size GetOptimalSizePixel() const;
|
|
|
|
void SetupPage( Size &rSize, long nLeft, long nRight, long nUpper, long nLower,
|
|
BOOL bSize, BOOL bMargin, BOOL bScaleAll );
|
|
|
|
USHORT GetIdBySubId( USHORT nSId );
|
|
void MapSlot( USHORT nSId );
|
|
void UpdateToolboxImages( SfxItemSet &rSet, BOOL bPermanent = TRUE );
|
|
USHORT GetMappedSlot( USHORT nSId );
|
|
USHORT GetArrayId( USHORT nSId );
|
|
|
|
void GetMenuStateSel(SfxItemSet& rSet);
|
|
|
|
private:
|
|
/** This flag controls whether the layer mode is active, i.e. the layer
|
|
dialog is visible.
|
|
*/
|
|
bool mbIsLayerModeActive;
|
|
|
|
/** This item contains the clipboard formats of the current clipboard
|
|
content that are supported both by that content and by the
|
|
DrawViewShell.
|
|
*/
|
|
::std::auto_ptr<SvxClipboardFmtItem> mpCurrentClipboardFormats;
|
|
|
|
/** On some occasions it is necessary to make SwitchPage calls
|
|
asynchronously.
|
|
*/
|
|
tools::AsynchronousCall maAsynchronousSwitchPageCall;
|
|
|
|
/** This flag is used to prevent nested calls to SwitchPage().
|
|
*/
|
|
bool mbIsInSwitchPage;
|
|
|
|
void Construct (DrawDocShell* pDocSh, PageKind ePageKind);
|
|
|
|
/** Depending on the given request create a new page or duplicate an
|
|
existing one. See ViewShell::CreateOrDuplicatePage() for more
|
|
information.
|
|
*/
|
|
virtual SdPage* CreateOrDuplicatePage (
|
|
SfxRequest& rRequest,
|
|
PageKind ePageKind,
|
|
SdPage* pPage);
|
|
|
|
::com::sun::star::uno::Reference< ::com::sun::star::scanner::XScannerManager > mxScannerManager;
|
|
::com::sun::star::uno::Reference< ::com::sun::star::lang::XEventListener > mxScannerListener;
|
|
TransferableClipboardListener* mpClipEvtLstnr;
|
|
BOOL mbPastePossible;
|
|
|
|
virtual void Notify (SfxBroadcaster& rBC, const SfxHint& rHint);
|
|
|
|
/** Stop a running slide show. The frame the show is running in is
|
|
destroyed if
|
|
a) it is running in its own frame, i.e. is a full screen show and
|
|
b) the given flag bCloseFrame is true.
|
|
@param bCloseFrame
|
|
Be carefull with this flag when stopping a full screen show.
|
|
When called from the destructor the flag has to be <FALSE/> or
|
|
otherwise we run into a loop of calls to destructors of the view
|
|
and the frame.
|
|
When called from other places the flag should be <TRUE/> so that
|
|
not an empty frame remains. When called with <TRUE/> it is the
|
|
responsibility of the caller to avoid an illegal reentrant
|
|
call.
|
|
*/
|
|
void StopSlideShow (bool bCloseFrame);
|
|
|
|
/** Show the context menu for snap lines and points. Because snap lines
|
|
can not be selected the index of the snap line/point for which the
|
|
popup menu is opened has to be passed to the processing slot
|
|
handlers. This can be done only by manually showing the popup menu.
|
|
@param rPageView
|
|
The page view is used to access the help lines.
|
|
@param nSnapLineIndex
|
|
Index of the snap line or snap point for which to show the
|
|
context menu.
|
|
@param rMouseLocation
|
|
The mouse location defines the location at which to display the
|
|
context menu.
|
|
*/
|
|
void ShowSnapLineContextMenu (
|
|
SdrPageView& rPageView,
|
|
const USHORT nSnapLineIndex,
|
|
const Point& rMouseLocation);
|
|
|
|
using ViewShell::Notify;
|
|
|
|
::std::auto_ptr< AnnotationManager > mpAnnotationManager;
|
|
::std::auto_ptr< ViewOverlayManager > mpViewOverlayManager;
|
|
};
|
|
|
|
|
|
} // end of namespace sd
|
|
|
|
#endif
|