diff options
Diffstat (limited to '')
| -rw-r--r-- | include/svx/svdpntv.hxx | 504 |
1 files changed, 504 insertions, 0 deletions
diff --git a/include/svx/svdpntv.hxx b/include/svx/svdpntv.hxx new file mode 100644 index 000000000..557846fe0 --- /dev/null +++ b/include/svx/svdpntv.hxx @@ -0,0 +1,504 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include <svl/SfxBroadcaster.hxx> +#include <svl/lstner.hxx> +#include <svl/undo.hxx> +#include <svx/svddrag.hxx> +#include <svx/svdlayer.hxx> +#include <svtools/colorcfg.hxx> +#include <svl/itemset.hxx> +#include <svx/svxdllapi.h> +#include <unotools/options.hxx> +#include <vcl/event.hxx> +#include <vcl/idle.hxx> +#include <vcl/timer.hxx> +#include <memory> + + +// Pre defines +class SdrPageWindow; + +namespace com::sun::star::awt { + class XControlContainer; +} +namespace sdr::overlay { class OverlayManager; } + +class SdrPage; +class SdrView; +class SfxItemSet; +class SfxStyleSheet; +class SdrOle2Obj; +class SdrModel; +class SdrObject; +enum class GraphicManagerDrawFlags; + +namespace sdr::contact { + class ViewObjectContactRedirector; +} + +// Defines for AnimationMode +enum class SdrAnimationMode +{ + Animate, + Disable +}; + +class SdrPaintView; +namespace sdr::contact { class ViewObjectContactRedirector; } + +namespace vcl { + class Window; +} + + +class SvxViewChangedHint final : public SfxHint +{ +public: + explicit SvxViewChangedHint(); +}; + +class SdrPaintWindow; + +/** + * Helper to convert any GDIMetaFile to a good quality BitmapEx, + * using default parameters and graphic::XPrimitive2DRenderer + */ +BitmapEx convertMetafileToBitmapEx( + const GDIMetaFile& rMtf, + const basegfx::B2DRange& rTargetRange, + const sal_uInt32 nMaximumQuadraticPixels); + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// +// SdrPaintView +// SdrSnapView +// SdrMarkView +// SdrEditView +// SdrPolyEditView +// SdrGlueEditView +// SdrObjEditView +// SdrExchangeView +// SdrDragView +// SdrCreateView +// SdrView +// DlgEdView +// GraphCtrlView +// E3dView +// DrawViewWrapper +// FmFormView +// ScDrawView +// sd::View (may have more?) +// sd::DrawView +// SwDrawView +// OSectionView + +class SVXCORE_DLLPUBLIC SdrPaintView : public SfxListener, public SfxRepeatTarget, public SfxBroadcaster, public ::utl::ConfigurationListener +{ +private: + friend class SdrPageView; + friend class SdrGrafObj; + + // the SdrModel this view was created with, unchanged during lifetime + SdrModel& mrSdrModelFromSdrView; + + std::unique_ptr<SdrPageView> mpPageView; +protected: + SdrModel* mpModel; + VclPtr<OutputDevice> mpActualOutDev; // Only for comparison + VclPtr<OutputDevice> mpDragWin; + SfxStyleSheet* mpDefaultStyleSheet; + + OUString maActualLayer; // Current drawing layer + OUString maMeasureLayer; // Current layer for measurements + +// Container aPagV; // List of SdrPageViews + + // All windows this view is displayed on + std::vector< std::unique_ptr<SdrPaintWindow> > maPaintWindows; + + Size maGridBig; // FIXME: We need to get rid of this eventually + Size maGridFin; // FIXME: We need to get rid of this eventually + SdrDragStat maDragStat; + tools::Rectangle maMaxWorkArea; + SfxItemSet maDefaultAttr; + Idle maComeBackIdle; + + SdrAnimationMode meAnimationMode; + + sal_uInt16 mnHitTolPix; + sal_uInt16 mnMinMovPix; + sal_uInt16 mnHitTolLog; + sal_uInt16 mnMinMovLog; + + bool mbPageVisible : 1; + bool mbPageShadowVisible : 1; + bool mbPageBorderVisible : 1; + bool mbBordVisible : 1; + bool mbGridVisible : 1; + bool mbGridFront : 1; + bool mbHlplVisible : 1; + bool mbHlplFront : 1; + bool mbGlueVisible : 1; // Persistent; show gluepoints + bool mbGlueVisible2 : 1; // Also show gluepoints for GluePointEdit + bool mbGlueVisible3 : 1; // Also show gluepoints for EdgeTool + bool mbGlueVisible4 : 1; // Show gluepoints, if one edge is selected + bool mbSomeObjChgdFlag : 1; + bool mbSwapAsynchron : 1; + bool mbPrintPreview : 1; + + // These bools manage, the status that is displayed + // + bool mbAnimationPause : 1; + + // Flag which decides if buffered output for this view is allowed. When + // set, PreRendering for PageView rendering will be used. Default is sal_False + bool mbBufferedOutputAllowed : 1; + + // Flag which decides if buffered overlay for this view is allowed. When + // set, the output will be buffered in an overlay vdev. When not, overlay is + // directly painted to OutDev. Default is sal_False. + bool mbBufferedOverlayAllowed : 1; + + // Allow page painting at all? + bool mbPagePaintingAllowed : 1; + + // Is this a preview renderer? + bool mbPreviewRenderer : 1; + + // Flags for calc and sw for suppressing OLE, CHART or DRAW objects + bool mbHideOle : 1; + bool mbHideChart : 1; + bool mbHideDraw : 1; // hide draw objects other than form controls + bool mbHideFormControl : 1; // hide form controls only + +public: + // Interface for PagePaintingAllowed flag + bool IsBufferedOutputAllowed() const; + void SetBufferedOutputAllowed(bool bNew); + + // Interface for BufferedOverlayAllowed flag + bool IsBufferedOverlayAllowed() const; + void SetBufferedOverlayAllowed(bool bNew); + + // Allow page painting at all? + bool IsPagePaintingAllowed() const { return mbPagePaintingAllowed;} + void SetPagePaintingAllowed(bool bNew); + + virtual rtl::Reference<sdr::overlay::OverlayManager> CreateOverlayManager(OutputDevice& rDevice) const; + +protected: + svtools::ColorConfig maColorConfig; + Color maGridColor; + + // Interface to SdrPaintWindow + void DeletePaintWindow(const SdrPaintWindow& rOld); + void ConfigurationChanged( ::utl::ConfigurationBroadcaster*, ConfigurationHints ) override; + static void InitOverlayManager(rtl::Reference<sdr::overlay::OverlayManager> xOverlayManager); + +public: + sal_uInt32 PaintWindowCount() const { return maPaintWindows.size(); } + SdrPaintWindow* FindPaintWindow(const OutputDevice& rOut) const; + SdrPaintWindow* GetPaintWindow(sal_uInt32 nIndex) const; + // Replacement for GetWin(0), may return 0L (!) + OutputDevice* GetFirstOutputDevice() const; + +private: + DECL_DLLPRIVATE_LINK(ImpComeBackHdl, Timer*, void); + +protected: + sal_uInt16 ImpGetMinMovLogic(short nMinMov, const OutputDevice* pOut) const; + sal_uInt16 ImpGetHitTolLogic(short nHitTol, const OutputDevice* pOut) const; + + // If one does not want to wait for the IdleState of the system (cheated as const) + void FlushComeBackTimer() const; + void TheresNewMapMode(); + void ImpSetGlueVisible2(bool bOn) { if (mbGlueVisible2!=bOn) { mbGlueVisible2=bOn; if (!mbGlueVisible && !mbGlueVisible3 && !mbGlueVisible4) GlueInvalidate(); } } + void ImpSetGlueVisible3(bool bOn) { if (mbGlueVisible3!=bOn) { mbGlueVisible3=bOn; if (!mbGlueVisible && !mbGlueVisible2 && !mbGlueVisible4) GlueInvalidate(); } } + void ImpSetGlueVisible4(bool bOn) { if (mbGlueVisible4!=bOn) { mbGlueVisible4=bOn; if (!mbGlueVisible && !mbGlueVisible2 && !mbGlueVisible3) GlueInvalidate(); } } + +public: + bool ImpIsGlueVisible() const { return mbGlueVisible || mbGlueVisible2 || mbGlueVisible3 || mbGlueVisible4; } + +protected: + virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint) override; + void GlueInvalidate() const; + + // ModelHasChanged is called, as soon as the system is idle again after many SdrHintKind::ObjectChange. + // + // Any sub-class override this method, MUST call the base class' ModelHasChanged() method + virtual void ModelHasChanged(); + + // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView + // A SdrView always needs a SdrModel for lifetime (Pool, ...) + SdrPaintView(SdrModel& rSdrModel, OutputDevice* pOut); + virtual ~SdrPaintView() override; + +public: + // SdrModel access on SdrView level + SdrModel& getSdrModelFromSdrView() const { return mrSdrModelFromSdrView; } + + virtual void ClearPageView(); + SdrModel* GetModel() const { return mpModel; } + + virtual bool IsAction() const; + virtual void MovAction(const Point& rPnt); + virtual void EndAction(); + virtual void BckAction(); + virtual void BrkAction(); // Cancel all Actions (e.g. cancel dragging) + virtual void TakeActionRect(tools::Rectangle& rRect) const; + + // Info about TextEdit. Default is sal_False. + virtual bool IsTextEdit() const; + + // Must be called for every Window change as well as MapMode (Scaling) change: + // If the SdrView is shown in multiple windows at the same time (e.g. + // using the split pane), so that I can convert my pixel values to logical + // values. + void SetActualWin(const OutputDevice* pWin); + void SetMinMoveDistancePixel(sal_uInt16 nVal) { mnMinMovPix=nVal; TheresNewMapMode(); } + void SetHitTolerancePixel(sal_uInt16 nVal) { mnHitTolPix=nVal; TheresNewMapMode(); } + sal_uInt16 GetHitTolerancePixel() const { return mnHitTolPix; } + + // Data read access on logic HitTolerance and MinMoveTolerance + sal_uInt16 getHitTolLog() const { return mnHitTolLog; } + + // Using the DragState we can tell e.g. which distance was + // already dragged + const SdrDragStat& GetDragStat() const { return maDragStat; } + + // Registering/de-registering a PageView at a View + // + // The same Page cannot be registered multiple times. + // + // Methods ending in PgNum expect being passed a Page number. + // Methods ending in PvNum, instead, expect the number of the + // PageView at the SdrView (iterating over all registered Pages). + virtual SdrPageView* ShowSdrPage(SdrPage* pPage); + virtual void HideSdrPage(); + + // Iterate over all registered PageViews + SdrPageView* GetSdrPageView() const { return mpPageView.get(); } + + // A SdrView can be displayed on multiple Windows at the same time + virtual void AddWindowToPaintView(OutputDevice* pNewWin, vcl::Window* pWindow); + virtual void DeleteWindowFromPaintView(OutputDevice* pOldWin); + + void SetLayerVisible(const OUString& rName, bool bShow); + bool IsLayerVisible(const OUString& rName) const; + + void SetLayerLocked(const OUString& rName, bool bLock=true); + bool IsLayerLocked(const OUString& rName) const; + + void SetLayerPrintable(const OUString& rName, bool bPrn); + bool IsLayerPrintable(const OUString& rName) const; + + // PrePaint call forwarded from app windows + void PrePaint(); + + + // Used internally for Draw/Impress/sch/chart2 + virtual void CompleteRedraw(OutputDevice* pOut, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector = nullptr); + + // #i72889# used from CompleteRedraw() implementation internally, added to be able to do a complete redraw in single steps + + // BeginCompleteRedraw returns (or even creates) a SdrPaintWindow which will then be used as the + // target for paints. Since paints may be buffered, use its GetTargetOutputDevice() method which will + // return the buffer in case it's buffered. + // + // DoCompleteRedraw then draws the DrawingLayer hierarchy + // EndCompleteRedraw does the necessary refreshes, paints text edit and overlay as well as destroys the + // SdrPaintWindow again, if needed. + // This means: the SdrPaintWindow is no longer safe after this closing call. + virtual SdrPaintWindow* BeginCompleteRedraw(OutputDevice* pOut); + void DoCompleteRedraw(SdrPaintWindow& rPaintWindow, const vcl::Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector = nullptr); + virtual void EndCompleteRedraw(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer); + + + // Used for the other applications basctl/sc/sw which call DrawLayer at PageViews + // #i74769# Interface change to use common BeginCompleteRedraw/EndCompleteRedraw + // #i76114# bDisableIntersect disables intersecting rReg with the Window's paint region + SdrPaintWindow* BeginDrawLayers(OutputDevice* pOut, const vcl::Region& rReg, bool bDisableIntersect = false); + + // Used when the region passed to BeginDrawLayers needs to be changed + void UpdateDrawLayersRegion(const OutputDevice* pOut, const vcl::Region& rReg); + void EndDrawLayers(SdrPaintWindow& rPaintWindow, bool bPaintFormLayer); + +protected: + + // Used to paint the form layer after the PreRender device is flushed (painted) to the window. + void ImpFormLayerDrawing( SdrPaintWindow& rPaintWindow ); + + static vcl::Region OptimizeDrawLayersRegion(const OutputDevice* pOut, const vcl::Region& rReg, bool bDisableIntersect); + +public: + /// Draw Page as a white area or not + bool IsPageVisible() const { return mbPageVisible; } + + /// Draw Page shadow or not + bool IsPageShadowVisible() const { return mbPageShadowVisible; } + + /// Draw Page as a white area or not + bool IsPageBorderVisible() const { return mbPageBorderVisible; } + + /// Draw Border line or not + bool IsBordVisible() const { return mbBordVisible; } + + /// Draw Grid or not + bool IsGridVisible() const { return mbGridVisible; } + + /// Draw Grid in front of objects or behind them + bool IsGridFront() const { return mbGridFront ; } + + /// Draw Help line of the Page or not + bool IsHlplVisible() const { return mbHlplVisible; } + + /// Draw Help line in front of the objects or behind them + bool IsHlplFront() const { return mbHlplFront ; } + + const Color& GetGridColor() const { return maGridColor;} + void SetPageVisible(bool bOn = true) { mbPageVisible=bOn; InvalidateAllWin(); } + void SetPageShadowVisible(bool bOn) { mbPageShadowVisible=bOn; InvalidateAllWin(); } + void SetPageBorderVisible(bool bOn = true) { mbPageBorderVisible=bOn; InvalidateAllWin(); } + void SetBordVisible(bool bOn = true) { mbBordVisible=bOn; InvalidateAllWin(); } + void SetGridVisible(bool bOn) { mbGridVisible=bOn; InvalidateAllWin(); } + void SetGridFront(bool bOn) { mbGridFront =bOn; InvalidateAllWin(); } + void SetHlplVisible(bool bOn = true) { mbHlplVisible=bOn; InvalidateAllWin(); } + void SetHlplFront(bool bOn) { mbHlplFront =bOn; InvalidateAllWin(); } + void SetGlueVisible(bool bOn = true) { if (mbGlueVisible!=bOn) { mbGlueVisible=bOn; if (!mbGlueVisible2 && !mbGlueVisible3 && !mbGlueVisible4) GlueInvalidate(); } } + + bool IsPreviewRenderer() const { return mbPreviewRenderer; } + void SetPreviewRenderer(bool bOn) { mbPreviewRenderer=bOn; } + + // Access methods for calc and sw hide object modes + bool getHideOle() const { return mbHideOle; } + bool getHideChart() const { return mbHideChart; } + bool getHideDraw() const { return mbHideDraw; } + bool getHideFormControl() const { return mbHideFormControl; } + void setHideOle(bool bNew) { if(bNew != mbHideOle) mbHideOle = bNew; } + void setHideChart(bool bNew) { if(bNew != mbHideChart) mbHideChart = bNew; } + void setHideDraw(bool bNew) { if(bNew != mbHideDraw) mbHideDraw = bNew; } + void setHideFormControl(bool bNew) { if(bNew != mbHideFormControl) mbHideFormControl = bNew; } + + void SetGridCoarse(const Size& rSiz) { maGridBig=rSiz; } + void SetGridFine(const Size& rSiz) { + maGridFin=rSiz; + if (maGridFin.Height()==0) maGridFin.setHeight(maGridFin.Width()); + if (mbGridVisible) InvalidateAllWin(); + } + const Size& GetGridCoarse() const { return maGridBig; } + const Size& GetGridFine() const { return maGridFin; } + + void InvalidateAllWin(); + void InvalidateAllWin(const tools::Rectangle& rRect); + + /// If the View should not call Invalidate() on the windows, override + /// the following 2 methods and do something else. + virtual void InvalidateOneWin(OutputDevice& rWin); + virtual void InvalidateOneWin(OutputDevice& rWin, const tools::Rectangle& rRect); + + void SetActiveLayer(const OUString& rName) { maActualLayer=rName; } + const OUString& GetActiveLayer() const { return maActualLayer; } + + /// Leave an object group of all visible Pages (like `chdir ..` in MS-DOS) + void LeaveOneGroup(); + + /// Leave all entered object groups of all visible Pages (like `chdir \` in MS-DOS) + void LeaveAllGroup(); + + /// Determine, whether Leave is useful or not + bool IsGroupEntered() const; + + /// Default attributes at the View + /// Newly created objects are assigned these attributes by default when they are created. + void SetDefaultAttr(const SfxItemSet& rAttr, bool bReplaceAll); + const SfxItemSet& GetDefaultAttr() const { return maDefaultAttr; } + void SetDefaultStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr); + + void SetNotPersistDefaultAttr(const SfxItemSet& rAttr); + void MergeNotPersistDefaultAttr(SfxItemSet& rAttr) const; + + /// Execute a swap-in of e.g. graphics asynchronously. + /// This does not reload all graphics like Paint does, but kicks off + /// the loading there. When such an object is done loading, it is displayed. + /// TODO: Only works at the moment, if SwapGraphics is enabled in the model. + /// The default = false flag is non-persistent + bool IsSwapAsynchron() const { return mbSwapAsynchron; } + void SetSwapAsynchron(bool bJa=true) { mbSwapAsynchron=bJa; } + virtual bool KeyInput(const KeyEvent& rKEvt, vcl::Window* pWin); + + virtual bool MouseButtonDown(const MouseEvent& /*rMEvt*/, OutputDevice* /*pWin*/) { return false; } + virtual bool MouseButtonUp(const MouseEvent& /*rMEvt*/, OutputDevice* /*pWin*/) { return false; } + virtual bool MouseMove(const MouseEvent& /*rMEvt*/, OutputDevice* /*pWin*/) { return false; } + virtual bool RequestHelp(const HelpEvent& /*rHEvt*/) { return false; } + virtual bool Command(const CommandEvent& /*rCEvt*/, vcl::Window* /*pWin*/) { return false; } + + void GetAttributes(SfxItemSet& rTargetSet, bool bOnlyHardAttr) const; + + void SetAttributes(const SfxItemSet& rSet, bool bReplaceAll); + SfxStyleSheet* GetStyleSheet() const; // SfxStyleSheet* GetStyleSheet(bool& rOk) const; + void SetStyleSheet(SfxStyleSheet* pStyleSheet, bool bDontRemoveHardAttr); + + virtual void MakeVisible(const tools::Rectangle& rRect, vcl::Window& rWin); + + /// For Plugins + /// Is called by the Paint of the OLE object + virtual void DoConnect(SdrOle2Obj* pOleObj); + + /// Enable/disable animations for ::Paint + /// Is used by e.g. SdrGrafObj, if it contains an animation + /// Preventing automatic animation is needed for e.g. the presentation view + bool IsAnimationEnabled() const { return ( SdrAnimationMode::Animate == meAnimationMode ); } + void SetAnimationEnabled( bool bEnable=true ); + + /// Set/unset pause state for animations + void SetAnimationPause( bool bSet ); + + /// Mode when starting an animation in the Paint Handler: + /// 1. SdrAnimationMode::Animate (default): start animation normally + /// 2. SDR_ANIMATION_DONT_ANIMATE: only show the replacement picture + /// 3. SdrAnimationMode::Disable: don't start and don't show any replacement + void SetAnimationMode( const SdrAnimationMode eMode ); + + /// Must be called by the App when scrolling etc. in order for + /// an active FormControl to be moved too + void VisAreaChanged(const OutputDevice* pOut); + void VisAreaChanged(); + + bool IsPrintPreview() const { return mbPrintPreview; } + void SetPrintPreview(bool bOn = true) { mbPrintPreview=bOn; } + + const svtools::ColorConfig& getColorConfig() const { return maColorConfig;} + + void onChangeColorConfig(); + + // #103834# Set background color for svx at SdrPageViews + void SetApplicationBackgroundColor(Color aBackgroundColor); + + // #103911# Set document color for svx at SdrPageViews + void SetApplicationDocumentColor(Color aDocumentColor); + + // #i38135# + // Sets the timer for Object animations and restarts. + void SetAnimationTimer(sal_uInt32 nTime); +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |