| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef _SVDPNTV_HXX |
| #define _SVDPNTV_HXX |
| |
| #include <svl/brdcst.hxx> |
| #include <svl/lstner.hxx> |
| #include <svl/smplhint.hxx> |
| #include <svl/undo.hxx> |
| #include <svx/svddrag.hxx> |
| #include <svx/svdlayer.hxx> // fuer SetOfByte |
| #include <vcl/window.hxx> |
| #include <svtools/colorcfg.hxx> |
| #include <com/sun/star/awt/XControlContainer.hpp> |
| #include <svl/itemset.hxx> |
| #include <vcl/timer.hxx> |
| #include "svx/svxdllapi.h" |
| #include <svtools/optionsdrawinglayer.hxx> |
| #include <unotools/options.hxx> |
| |
| //************************************************************ |
| // Pre-Defines |
| //************************************************************ |
| |
| class SdrPageWindow; |
| |
| namespace com { namespace sun { namespace star { namespace awt { |
| class XControlContainer; |
| }}}} |
| |
| class SdrPage; |
| class SdrView; |
| class SfxItemSet; |
| class SfxStyleSheet; |
| class SdrOle2Obj; |
| class SdrModel; |
| class SdrObject; |
| class SdrViewUserMarker; |
| class B2dIAOManager; |
| |
| #ifdef DBG_UTIL |
| class SdrItemBrowser; |
| #endif |
| |
| namespace sdr { namespace contact { |
| class ViewObjectContactRedirector; |
| }} |
| |
| //************************************************************ |
| // Defines for AnimationMode |
| //************************************************************ |
| |
| enum SdrAnimationMode |
| { |
| SDR_ANIMATION_ANIMATE, |
| SDR_ANIMATION_DONT_ANIMATE, |
| SDR_ANIMATION_DISABLE |
| }; |
| |
| //************************************************************ |
| // Typedef's und defines |
| //************************************************************ |
| |
| typedef unsigned char TRISTATE; |
| #define FUZZY (2) |
| #define SDR_ANYFORMAT (0xFFFFFFFF) |
| #define SDR_ANYITEM (0xFFFF) |
| #define SDRVIEWWIN_NOTFOUND (0xFFFF) |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| class SdrPaintView; |
| |
| namespace sdr |
| { |
| namespace contact |
| { |
| class ViewObjectContactRedirector; |
| } // end of namespace contact |
| } // end of namespace sdr |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| |
| class SVX_DLLPUBLIC SvxViewHint : public SfxHint |
| { |
| public: |
| enum HintType { SVX_HINT_VIEWCHANGED }; |
| TYPEINFO(); |
| SvxViewHint (HintType eType); |
| HintType GetHintType (void) const; |
| |
| private: |
| HintType meHintType; |
| }; |
| |
| // typedefs for a list of SdrPaintWindows |
| class SdrPaintWindow; |
| typedef ::std::vector< SdrPaintWindow* > SdrPaintWindowVector; |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // helper to convert any GDIMetaFile to a good quality BitmapEx, |
| // using default parameters and graphic::XPrimitive2DRenderer |
| |
| BitmapEx SVX_DLLPUBLIC convertMetafileToBitmapEx( |
| const GDIMetaFile& rMtf, |
| const basegfx::B2DRange& rTargetRange, |
| const sal_uInt32 nMaximumQuadraticPixels = 500000); |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| class SVX_DLLPUBLIC SdrPaintView : public SfxListener, public SfxRepeatTarget, public SfxBroadcaster, public ::utl::ConfigurationListener |
| { |
| friend class SdrPageView; |
| friend class FrameAnimator; |
| friend class SdrGrafObj; |
| |
| protected: |
| // #114409#-2 Migrate Encirclement |
| class ImplEncirclementOverlay* mpEncirclementOverlay; |
| |
| SdrModel* pMod; |
| #ifdef DBG_UTIL |
| SdrItemBrowser* pItemBrowser; |
| #endif |
| const OutputDevice* pActualOutDev; // Nur zum vergleichen |
| OutputDevice* pDragWin; |
| SfxStyleSheet* pDefaultStyleSheet; |
| |
| String aAktLayer; // Aktueller Zeichenlayer |
| String aMeasureLayer; // Aktueller Layer fuer Bemassung |
| |
| // Container aPagV; // Liste von SdrPageViews |
| SdrPageView* mpPageView; |
| |
| // All windows this view is displayed on |
| SdrPaintWindowVector maPaintWindows; |
| |
| MapMode aActualMapMode; |
| Size aGridBig; // muss dann mal raus |
| Size aGridFin; // muss dann mal raus |
| SdrDragStat aDragStat; |
| Rectangle aMaxWorkArea; |
| SfxItemSet aDefaultAttr; |
| Timer aComeBackTimer; |
| |
| SdrAnimationMode eAnimationMode; |
| |
| sal_uInt16 nHitTolPix; |
| sal_uInt16 nMinMovPix; |
| sal_uInt16 nHitTolLog; |
| sal_uInt16 nMinMovLog; |
| sal_uIntPtr nMasterCacheMode; |
| sal_uIntPtr nGraphicManagerDrawMode; |
| |
| // hold an incarnation of Drawinglayer configuration options |
| SvtOptionsDrawinglayer maDrawinglayerOpt; |
| |
| unsigned bPageVisible : 1; |
| unsigned bPageBorderVisible : 1; |
| unsigned bBordVisible : 1; |
| unsigned bGridVisible : 1; |
| unsigned bGridFront : 1; |
| unsigned bHlplVisible : 1; |
| unsigned bHlplFront : 1; |
| unsigned bGlueVisible : 1; // Persistent. Klebepunkte anzeigen |
| unsigned bGlueVisible2 : 1; // Klebepunkte auch bei GluePointEdit anzeigen |
| unsigned bGlueVisible3 : 1; // Klebepunkte auch bei EdgeTool anzeigen |
| unsigned bGlueVisible4 : 1; // Klebepunkte anzeigen, wenn 1 Edge markiert |
| unsigned bRestoreColors : 1; // Pens und Brushes werden zurueckgesetzt. |
| unsigned bSomeObjChgdFlag : 1; |
| unsigned bSwapAsynchron : 1; |
| unsigned bPrintPreview : 1; |
| |
| // sal_Bool fuer die Verwaltung des anzuzeigenden Status |
| // Gruppe Betreten/Verlassen. Default ist sal_True, wird aber |
| // beispielsweise beim Chart auf sal_False gesetzt, da dort |
| // die Ghosted-Effekte zur Darstellug unerwuenscht sind. |
| unsigned bVisualizeEnteredGroup : 1; |
| unsigned bAnimationPause : 1; |
| |
| // #114898# |
| // Flag which decides if buffered output for this view is allowed. When |
| // set, PreRendering for PageView rendering will be used. Default is sal_False |
| unsigned mbBufferedOutputAllowed : 1; |
| |
| // #114898# |
| // 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. |
| unsigned mbBufferedOverlayAllowed : 1; |
| |
| // allow page painting at all? |
| unsigned mbPagePaintingAllowed : 1; |
| |
| // is this a preview renderer? |
| unsigned mbPreviewRenderer : 1; |
| |
| // flags for calc and sw for suppressing OLE, CHART or DRAW objects |
| unsigned mbHideOle : 1; |
| unsigned mbHideChart : 1; |
| unsigned mbHideDraw : 1; // hide draw objects other than form controls |
| unsigned mbHideFormControl : 1; // hide form controls only |
| |
| public: |
| // #114898# |
| // 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? |
| sal_Bool IsPagePaintingAllowed() const; |
| void SetPagePaintingAllowed(bool bNew); |
| |
| protected: |
| svtools::ColorConfig maColorConfig; |
| Color maGridColor; |
| |
| // interface to SdrPaintWindow |
| protected: |
| void AppendPaintWindow(SdrPaintWindow& rNew); |
| SdrPaintWindow* RemovePaintWindow(SdrPaintWindow& rOld); |
| void ConfigurationChanged( ::utl::ConfigurationBroadcaster*, sal_uInt32 ); |
| |
| 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: |
| SVX_DLLPRIVATE void ImpClearVars(); |
| DECL_LINK(ImpComeBackHdl,Timer*); |
| |
| protected: |
| sal_uInt16 ImpGetMinMovLogic(short nMinMov, const OutputDevice* pOut) const; |
| sal_uInt16 ImpGetHitTolLogic(short nHitTol, const OutputDevice* pOut) const; |
| |
| // Wenn man den IdleStatus des Systems nicht abwarten will (auf const geschummelt): |
| void FlushComeBackTimer() const; |
| void TheresNewMapMode(); |
| void ImpSetGlueVisible2(bool bOn) { if (bGlueVisible2!=(unsigned)bOn) { bGlueVisible2=bOn; if (!bGlueVisible && !bGlueVisible3 && !bGlueVisible4) GlueInvalidate(); } } |
| void ImpSetGlueVisible3(bool bOn) { if (bGlueVisible3!=(unsigned)bOn) { bGlueVisible3=bOn; if (!bGlueVisible && !bGlueVisible2 && !bGlueVisible4) GlueInvalidate(); } } |
| void ImpSetGlueVisible4(bool bOn) { if (bGlueVisible4!=(unsigned)bOn) { bGlueVisible4=bOn; if (!bGlueVisible && !bGlueVisible2 && !bGlueVisible3) GlueInvalidate(); } } |
| sal_Bool ImpIsGlueVisible2() const { return bGlueVisible2; } |
| sal_Bool ImpIsGlueVisible3() const { return bGlueVisible3; } |
| sal_Bool ImpIsGlueVisible4() const { return bGlueVisible4; } |
| |
| public: |
| sal_Bool ImpIsGlueVisible() { return bGlueVisible || bGlueVisible2 || bGlueVisible3 || bGlueVisible4; } |
| protected: |
| |
| virtual void Notify(SfxBroadcaster& rBC, const SfxHint& rHint); |
| void GlueInvalidate() const; |
| |
| void ShowEncirclement(OutputDevice* pOut); |
| void HideEncirclement(OutputDevice* pOut); |
| void DrawEncirclement(OutputDevice* pOut) const; |
| |
| // ModelHasChanged wird gerufen, sobald nach beliebig vielen HINT_OBJCHG |
| // das System wieder idle ist (StarView-Timer). Wer diese Methode ueberlaed, |
| // muss unbedingt ModelHasChanged() der Basisklasse rufen. |
| virtual void ModelHasChanged(); |
| |
| protected: |
| // #i71538# make constructors of SdrView sub-components protected to avoid incomplete incarnations which may get casted to SdrView |
| SdrPaintView(SdrModel* pModel1, OutputDevice* pOut = 0L); |
| virtual ~SdrPaintView(); |
| |
| public: |
| TYPEINFO(); |
| |
| virtual void ClearPageView(); |
| // virtual void ClearAll(); |
| // virtual void Clear(); // PageViews loeschen, Markierungen weg, ... |
| SdrModel* GetModel() const { return pMod; } |
| |
| virtual sal_Bool IsAction() const; |
| virtual void MovAction(const Point& rPnt); |
| virtual void EndAction(); |
| virtual void BckAction(); |
| virtual void BrkAction(); // Alle Actions z.B. Draggen abbrechen. |
| virtual void TakeActionRect(Rectangle& rRect) const; |
| |
| // info about TextEdit. Default is sal_False. |
| virtual bool IsTextEdit() const; |
| |
| // info about TextEditPageView. Default is 0L. |
| virtual SdrPageView* GetTextEditPageView() const; |
| |
| // Muss dann bei jedem Fensterwechsel (wenn die SdrView in mehreren |
| // Fenstern gleichzeitig dargestellt wird (->z.B. Splitter)) und bei |
| // jedem MapMode(Scaling)-wechsel gerufen werden, damit ich aus meinen |
| // Pixelwerten logische Werte berechnen kann. |
| void SetActualWin(const OutputDevice* pWin); |
| void SetMinMoveDistancePixel(sal_uInt16 nVal) { nMinMovPix=nVal; TheresNewMapMode(); } |
| sal_uInt16 GetMinMoveDistancePixel() const { return (sal_uInt16)nMinMovPix; } |
| void SetHitTolerancePixel(sal_uInt16 nVal) { nHitTolPix=nVal; TheresNewMapMode(); } |
| sal_uInt16 GetHitTolerancePixel() const { return (sal_uInt16)nHitTolPix; } |
| |
| // data read access on logic HitTolerance and MinMoveTolerance |
| sal_uInt16 getHitTolLog() const { return nHitTolLog; } |
| sal_uInt16 getMinMovLog() const { return nMinMovLog; } |
| |
| // Flag zur Visualisierung von Gruppen abfragen/testen |
| sal_Bool DoVisualizeEnteredGroup() const { return bVisualizeEnteredGroup; } |
| void SetVisualizeEnteredGroup(sal_Bool bNew) { bVisualizeEnteredGroup = bNew; } |
| |
| // Am DragStatus laesst sich beispielsweise erfragen, welche |
| // entfernung bereits gedraggd wurde, etc. |
| const SdrDragStat& GetDragStat() const { return aDragStat; } |
| |
| // Anmelden/Abmelden einer PageView an der View. |
| // Dieselbe // Seite kann nicht mehrfach angemeldet werden. |
| // Methoden mit dem Suffix PgNum erwarten als numerischen Parameter |
| // eine Seitennummer (0...). Methoden mit dem Suffix PvNum erwarten |
| // degagen als numerischen Parameter die Nummer der PageView an der |
| // SdrView (Iterieren ueber alle angemeldeten Pages). |
| virtual SdrPageView* ShowSdrPage(SdrPage* pPage); |
| virtual void HideSdrPage(); |
| |
| // Iterieren ueber alle angemeldeten PageViews |
| // sal_uInt16 GetPageViewCount() const { return sal_uInt16(aPagV.Count()); } |
| // SdrPageView* GetPageViewByIndex(sal_uInt16 nPvNum) const { return ((SdrPageView*)aPagV.GetObject(nPvNum)); } |
| SdrPageView* GetSdrPageView() const { return mpPageView; } |
| |
| // Pageview einer bestimmten Seite ermitteln |
| // SdrPageView* GetPageViewByPage(const SdrPage* pPage) const; |
| // sal_uInt16 GetIndexByPageView(const SdrPageView* pPV) const; |
| |
| // Test, ob eine Seite getroffen |
| // SdrPageView* HitPage(const Point& rPnt) const; |
| |
| // Die Seite, die dem Punkt am naechsten ist. Liefert nur NULL, |
| // wenn absolut keine Seite angemeldet ist. |
| // SdrPageView* GetPageViewByPosition(const Point& rPnt) const; |
| |
| // Eine SdrView kann auf mehreren Fenstern gleichzeitig abgebiltet sein: |
| virtual void AddWindowToPaintView(OutputDevice* pNewWin); |
| virtual void DeleteWindowFromPaintView(OutputDevice* pOldWin); |
| |
| void SetLayerVisible(const String& rName, sal_Bool bShow=sal_True); |
| bool IsLayerVisible(const String& rName) const; |
| void SetAllLayersVisible(sal_Bool bShow=sal_True); |
| |
| void SetLayerLocked(const String& rName, sal_Bool bLock=sal_True); |
| bool IsLayerLocked(const String& rName) const; |
| void SetAllLayersLocked(sal_Bool bLock=sal_True); |
| |
| void SetLayerPrintable(const String& rName, sal_Bool bPrn=sal_True); |
| bool IsLayerPrintable(const String& rName) const; |
| void SetAllLayersPrintable(sal_Bool bPrn=sal_True); |
| |
| // PrePaint call forwarded from app windows |
| void PrePaint(); |
| |
| // PostPaint call forwarded from app windows |
| void PostPaint(); |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // used internally for Draw/Impress/sch/chart2 |
| virtual void CompleteRedraw(OutputDevice* pOut, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector = 0); |
| |
| // #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 whcih shall then be used as |
| // target for paints. Since paints may be buffered, use it's GetTargetOutputDevice() method which will |
| // return the buffer in case of bufered. |
| // DoCompleteRedraw draws the DrawingLayer hierarchy then. |
| // EndCompleteRedraw does the necessary refreshes, evtl. paints text edit and overlay and evtl destroys the |
| // SdrPaintWindow again. This means: the SdrPaintWindow is no longer safe after this closing call. |
| virtual SdrPaintWindow* BeginCompleteRedraw(OutputDevice* pOut); |
| virtual void DoCompleteRedraw(SdrPaintWindow& rPaintWindow, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector = 0); |
| 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 Region& rReg, bool bDisableIntersect = false); |
| 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) const; |
| |
| public: |
| sal_Bool IsPageVisible() const { return bPageVisible; } // Seite (weisse Flaeche) malen oder nicht |
| sal_Bool IsPageBorderVisible() const { return bPageBorderVisible; } // Seite (weisse Flaeche) malen oder nicht |
| sal_Bool IsBordVisible() const { return bBordVisible; } // Seitenrandlinie malen oder nicht |
| sal_Bool IsGridVisible() const { return bGridVisible; } // Rastergitter malen oder nicht |
| sal_Bool IsGridFront() const { return bGridFront ; } // Rastergitter ueber die Objekte druebermalen oder dahinter |
| sal_Bool IsHlplVisible() const { return bHlplVisible; } // Hilfslinien der Seiten malen oder nicht |
| sal_Bool IsHlplFront() const { return bHlplFront ; } // Hilfslinie ueber die Objekte druebermalen oder dahinter |
| sal_Bool IsGlueVisible() const { return bGlueVisible; } // Konnektoren der objekte sichtbar oder nicht |
| Color GetGridColor() const; |
| void SetPageVisible(bool bOn = true) { bPageVisible=bOn; InvalidateAllWin(); } |
| void SetPageBorderVisible(bool bOn = true) { bPageBorderVisible=bOn; InvalidateAllWin(); } |
| void SetBordVisible(bool bOn = true) { bBordVisible=bOn; InvalidateAllWin(); } |
| void SetGridVisible(bool bOn = true) { bGridVisible=bOn; InvalidateAllWin(); } |
| void SetGridFront(bool bOn = true) { bGridFront =bOn; InvalidateAllWin(); } |
| void SetHlplVisible(bool bOn = true) { bHlplVisible=bOn; InvalidateAllWin(); } |
| void SetHlplFront(bool bOn = true) { bHlplFront =bOn; InvalidateAllWin(); } |
| void SetGlueVisible(bool bOn = true) { if (bGlueVisible!=(unsigned)bOn) { bGlueVisible=bOn; if (!bGlueVisible2 && !bGlueVisible3 && !bGlueVisible4) GlueInvalidate(); } } |
| void SetGridColor( Color aColor ); |
| |
| sal_Bool IsPreviewRenderer() const { return (sal_Bool )mbPreviewRenderer; } |
| void SetPreviewRenderer(bool bOn) { if((unsigned)bOn != mbPreviewRenderer) { 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 != (bool)mbHideOle) mbHideOle = bNew; } |
| void setHideChart(bool bNew) { if(bNew != (bool)mbHideChart) mbHideChart = bNew; } |
| void setHideDraw(bool bNew) { if(bNew != (bool)mbHideDraw) mbHideDraw = bNew; } |
| void setHideFormControl(bool bNew) { if(bNew != (bool)mbHideFormControl) mbHideFormControl = bNew; } |
| |
| void SetGridCoarse(const Size& rSiz) { aGridBig=rSiz; } |
| void SetGridFine(const Size& rSiz) { aGridFin=rSiz; if (aGridFin.Height()==0) aGridFin.Height()=aGridFin.Width(); if (bGridVisible) InvalidateAllWin(); } // #40479# |
| const Size& GetGridCoarse() const { return aGridBig; } |
| const Size& GetGridFine() const { return aGridFin; } |
| |
| void InvalidateAllWin(); |
| void InvalidateAllWin(const Rectangle& rRect, sal_Bool bPlus1Pix=sal_False); |
| |
| // Wenn die View kein Invalidate() an den Fenstern durchfuehren soll, muss |
| // man diese beiden folgenden Methoden ueberladen und entsprechend anders |
| // reagieren. |
| virtual void InvalidateOneWin(Window& rWin); |
| virtual void InvalidateOneWin(Window& rWin, const Rectangle& rRect); |
| |
| void SetActiveLayer(const String& rName) { aAktLayer=rName; } |
| const String& GetActiveLayer() const { return aAktLayer; } |
| |
| // Verlassen einer betretenen Objektgruppe aller sichtbaren Seiten. |
| // (wie MsDos chdir ..) |
| void LeaveOneGroup(); |
| |
| // Verlassen aller betretenen Objektgruppen aller sichtbaren Seiten. |
| // (wie MsDos chdir \) |
| void LeaveAllGroup(); |
| |
| // Feststellen, ob Leave sinnvoll ist. |
| bool IsGroupEntered() const; |
| |
| // DefaultAttribute an der View: Neu erzeugte Objekte bekommen diese |
| // Attribute direkt nach dem Erzeugen erstmal zugewiesen. |
| void SetDefaultAttr(const SfxItemSet& rAttr, sal_Bool bReplaceAll); |
| const SfxItemSet& GetDefaultAttr() const { return aDefaultAttr; } |
| void SetDefaultStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr); |
| SfxStyleSheet* GetDefaultStyleSheet() const { return pDefaultStyleSheet; } |
| |
| void SetNotPersistDefaultAttr(const SfxItemSet& rAttr, sal_Bool bReplaceAll); |
| void MergeNotPersistDefaultAttr(SfxItemSet& rAttr, sal_Bool bOnlyHardAttr) const; |
| |
| // Aufziehen eines animierten Rechtecks fuer Applikationsspeziefische |
| // Verwendung. Alle Positionsangaben in logischen View-Koordinaten. |
| // pOut bezeichnet das OutputDevice, in das animierte Rechteck dargestellt |
| // werden soll. Wird NULL uebergeben, wird es in allen an der View |
| // angemeldeten OutputDevices gleichzeitig dargestellt. |
| void BegEncirclement(const Point& rPnt); |
| void MovEncirclement(const Point& rPnt); |
| Rectangle EndEncirclement(sal_Bool bNoJustify = sal_False); |
| void BrkEncirclement(); |
| sal_Bool IsEncirclement() const { return (0L != mpEncirclementOverlay); } |
| |
| // use this mode as mode to draw all internal GraphicManager objects with |
| sal_uIntPtr GetGraphicManagerDrawMode() const { return nGraphicManagerDrawMode; } |
| void SetGraphicManagerDrawMode( sal_uIntPtr nMode ) { nGraphicManagerDrawMode = nMode; } |
| |
| // SwapIn (z.B. von Grafiken) asynchron durchfuehren. Also nicht |
| // beim Paint sofort nachladen, sondern dort das Nachladen anstossen. |
| // Nach Abschluss des Nachladens wird das Objekt dann angezeigt. |
| // Hat nur z.Zt. Wirkung, wenn SwapGraphics am Model eingeschaltet ist. |
| // Default=FALSE. Flag ist nicht persistent. |
| sal_Bool IsSwapAsynchron() const { return bSwapAsynchron; } |
| void SetSwapAsynchron(sal_Bool bJa=sal_True) { bSwapAsynchron=bJa; } |
| virtual sal_Bool KeyInput(const KeyEvent& rKEvt, Window* pWin); |
| |
| virtual sal_Bool MouseButtonDown(const MouseEvent& /*rMEvt*/, Window* /*pWin*/) { return sal_False; } |
| virtual sal_Bool MouseButtonUp(const MouseEvent& /*rMEvt*/, Window* /*pWin*/) { return sal_False; } |
| virtual sal_Bool MouseMove(const MouseEvent& /*rMEvt*/, Window* /*pWin*/) { return sal_False; } |
| virtual sal_Bool Command(const CommandEvent& /*rCEvt*/, Window* /*pWin*/) { return sal_False; } |
| sal_Bool Cut(sal_uIntPtr /*nFormat*/=SDR_ANYFORMAT) { return sal_False; } |
| sal_Bool Yank(sal_uIntPtr /*nFormat*/=SDR_ANYFORMAT) { return sal_False; } |
| sal_Bool Paste(Window* /*pWin*/=NULL, sal_uIntPtr /*nFormat*/=SDR_ANYFORMAT) { return sal_False; } |
| |
| /* new interface src537 */ |
| sal_Bool GetAttributes(SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr=sal_False) const; |
| |
| sal_Bool SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll); |
| SfxStyleSheet* GetStyleSheet() const; // SfxStyleSheet* GetStyleSheet(sal_Bool& rOk) const; |
| sal_Bool SetStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr); |
| |
| virtual void MakeVisible(const Rectangle& rRect, Window& rWin); |
| |
| // Fuer PlugIn. Wird vom Paint des OLE-Obj gerufen. |
| virtual void DoConnect(SdrOle2Obj* pOleObj); |
| |
| // Animation aktivieren/deaktivieren fuer ::Paint |
| // wird z.Zt. ausgewertet von SdrGrafObj, wenn in dem eine Animation steckt |
| // Das Unterbinden der automatischen Animation wird z.B. fuer die Dia-Show benoetigt |
| sal_Bool IsAnimationEnabled() const { return ( SDR_ANIMATION_ANIMATE == eAnimationMode ); } |
| void SetAnimationEnabled( sal_Bool bEnable=sal_True ); |
| |
| // set/unset pause state for animations |
| bool IsAnimationPause() const { return bAnimationPause; } |
| void SetAnimationPause( bool bSet ); |
| |
| // Verhalten beim Starten von Animation im Paint-Handler: |
| // 1. Animation normal starten( SDR_ANIMATION_ANIMATE ) => DEFAULT |
| // 2. Nur die Ersatzdarstellung der Animation zeichnen ( SDR_ANIMATION_DONT_ANIMATE ) |
| // 3. Nicht starten und nichts ersatzweise ausgeben ( SDR_ANIMATION_DISABLE ) |
| void SetAnimationMode( const SdrAnimationMode eMode ); |
| SdrAnimationMode GetAnimationMode() const { return eAnimationMode; } |
| |
| // bei bShow=sal_False wird der Browser destruiert |
| #ifdef DBG_UTIL |
| void ShowItemBrowser(sal_Bool bShow=sal_True); |
| sal_Bool IsItemBrowserVisible() const { return pItemBrowser!=NULL && ((Window*)pItemBrowser)->IsVisible(); } |
| Window* GetItemBrowser() const { return (Window*)pItemBrowser; } |
| #endif |
| |
| // Muss von App beim Scrollen usw. gerufen werden, damit ein u.U. |
| // aktives FormularControl mitverschoben werden kann |
| void VisAreaChanged(const OutputDevice* pOut=NULL); |
| void VisAreaChanged(const SdrPageWindow& rWindow); |
| |
| sal_Bool IsPrintPreview() const { return bPrintPreview; } |
| void SetPrintPreview(bool bOn = true) { bPrintPreview=bOn; } |
| |
| const svtools::ColorConfig& getColorConfig() const; |
| |
| virtual 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); |
| |
| // access to Drawinglayer configuration options |
| const SvtOptionsDrawinglayer& getOptionsDrawinglayer() const { return maDrawinglayerOpt; } |
| }; |
| |
| #endif //_SVDPNTV_HXX |
| |
