From 644dd4954feddfcd194aeba614221ea9f23c23fd Mon Sep 17 00:00:00 2001 From: Rüdiger Timm Date: Mon, 24 Nov 2003 15:44:37 +0000 Subject: INTEGRATION: CWS aw003 (1.1.2); FILE ADDED 2003/10/16 08:27:46 aw 1.1.2.9: #111111# 2003/10/07 12:11:40 aw 1.1.2.8: #111097# 2003/08/19 16:46:14 aw 1.1.2.7: #111096# 2003/07/30 16:05:29 aw 1.1.2.6: #110094# Further DrawingLayer adaptions 2003/07/25 16:31:39 aw 1.1.2.5: #110094# Changed Paint() to DoPaintObject() for identifying reasons 2003/07/25 10:13:13 aw 1.1.2.4: #110094# Further changes 2003/07/24 14:25:28 aw 1.1.2.3: #110094# Adaptions for DrawingLayer changes 2003/07/01 14:45:25 aw 1.1.2.2: #110094# Necessary changes for GCC 2003/06/30 13:26:50 aw 1.1.2.1: #110094# --- svx/source/sdr/contact/objectcontactofpageview.cxx | 552 +++++++++++++++++++++ 1 file changed, 552 insertions(+) create mode 100644 svx/source/sdr/contact/objectcontactofpageview.cxx (limited to 'svx/source') diff --git a/svx/source/sdr/contact/objectcontactofpageview.cxx b/svx/source/sdr/contact/objectcontactofpageview.cxx new file mode 100644 index 000000000000..ac391048d7fc --- /dev/null +++ b/svx/source/sdr/contact/objectcontactofpageview.cxx @@ -0,0 +1,552 @@ +/************************************************************************* + * + * $RCSfile: objectcontactofpageview.cxx,v $ + * + * $Revision: 1.2 $ + * + * last change: $Author: rt $ $Date: 2003-11-24 16:44:37 $ + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 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 + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (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.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: Sun Microsystems, Inc. + * + * Copyright: 2000 by Sun Microsystems, Inc. + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ + +#ifndef _SDR_CONTACT_OBJECTCONTACTOFPAGEVIEW_HXX +#include +#endif + +#ifndef _SVDPAGV_HXX +#include +#endif + +#ifndef _SVDPAGE_HXX +#include +#endif + +#ifndef _SDR_CONTACT_DISPLAYINFO_HXX +#include +#endif + +#ifndef _SVDMODEL_HXX +#include +#endif + +#ifndef _SDR_CONTACT_VIEWOBJECTCONTACT_HXX +#include +#endif + +#ifndef _SVDVIEW_HXX +#include +#endif + +#ifndef _SDR_CONTACT_VIEWCONTACT_HXX +#include +#endif + +#ifndef _SDR_ANIMATION_OBJECTANIMATOR_HXX +#include +#endif + +#ifndef _XOUTX_HXX +#include +#endif + +#ifndef _SDR_EVENT_EVENTHANDLER_HXX +#include +#endif + +////////////////////////////////////////////////////////////////////////////// + +namespace sdr +{ + namespace contact + { + // internal access to SdrPageView + SdrPageView& ObjectContactOfPageView::GetPageView() const + { + return mrPageView; + } + + // internal access to SdrPage of SdrPageView + SdrPage* ObjectContactOfPageView::GetSdrPage() const + { + return GetPageView().GetPage(); + } + + ObjectContactOfPageView::ObjectContactOfPageView(SdrPageView& rPageView) + : ObjectContact(), + mrPageView(rPageView), + mpRememberedStartPage(0L) + { + } + + // The destructor. When PrepareDelete() was not called before (see there) + // warnings will be generated in debug version if there are still contacts + // existing. + ObjectContactOfPageView::~ObjectContactOfPageView() + { + } + + // Update Draw Hierarchy data. Take care of everything that is inside + // of rDisplayInfo.GetRedrawArea(), that is the necessary part. + void ObjectContactOfPageView::EnsureValidDrawHierarchy(DisplayInfo& rDisplayInfo) + { + // get StartNode + SdrPage* pStartPage = GetSdrPage(); + + // test for start point change + if(pStartPage != mpRememberedStartPage) + { + // Clear whole DrawHierarchy, needs complete rebuild + ClearDrawHierarchy(); + + // remember new StartPoint + mpRememberedStartPage = pStartPage; + + // build hierarchy for local draw page. This will include the + // MasterPages as sub-hierarchy of the DrawPage because + // ViewContactOfSdrPage::GetObjectCount() and ::GetViewContact() + // support that. + ViewContact& rViewContact = pStartPage->GetViewContact(); + + // Get the ViewObjectContact for this ViewContact and this DrawContact. This creates such an object + // on demand and adds it to the ViewObjectContactList of the ViewContact. + ViewObjectContact& rViewObjectContact = rViewContact.GetViewObjectContact(*this); + + // set parent at ViewObjectContact. For pages, there is no parent. + rViewObjectContact.SetParent(0L); + + // build sub-hierarchy + if(rViewContact.GetObjectCount()) + { + rViewObjectContact.BuildDrawHierarchy(*this, rViewContact); + } + + // Add to list + maDrawHierarchy.Append(&rViewObjectContact); + + // set DrawHierarchy valid + mbDrawHierarchyValid = sal_True; + } + else + { + // no new StartPoint, is the invalid flag set which means + // somewhere the sub-hierarchy is invalid? + if(!IsDrawHierarchyValid()) + { + // Yes, check the sub-hierarchies + const sal_uInt32 nCount(maDrawHierarchy.Count()); + + for(sal_uInt32 a(0L); a < nCount; a++) + { + ViewObjectContact& rVOContact = *(maDrawHierarchy.GetObject(a)); + + rVOContact.CheckDrawHierarchy(*this); + } + + // set DrawHierarchy valid + mbDrawHierarchyValid = sal_True; + } + } + } + + // Create and set the ExpandPaintClipRegion. This needs to be done before + // any of the objects gets really painted because it relies on the invalidated + // and not painted state of the single objects. + void ObjectContactOfPageView::ExpandPaintClipRegion(DisplayInfo& rDisplayInfo) + { + if(rDisplayInfo.GetPaintInfoRec() && rDisplayInfo.GetOutputDevice()) + { + OutputDevice* pOut = rDisplayInfo.GetOutputDevice(); + + if(OUTDEV_WINDOW == pOut->GetOutDevType()) + { + Window* pWin = (Window*)pOut; + Region aExpandRegion; + + // For this purpose test against visible area, not against + // paint rectangle. Thus, Remember DrawArea and set visible area instead. + Region aOriginalDrawArea = rDisplayInfo.GetRedrawArea(); + Point aEmptyPoint; + Rectangle aVisiblePixel(aEmptyPoint, pOut->GetOutputSizePixel()); + Region aVisibleLogic = Region(pOut->PixelToLogic(aVisiblePixel)); + rDisplayInfo.SetRedrawArea(aVisibleLogic); + + for(sal_uInt32 a(0L); a < maDrawHierarchy.Count(); a++) + { + ViewObjectContact& rVOContact = *(maDrawHierarchy.GetObject(a)); + + // Recursively Build Clip Region for ViewObjectContacts + rVOContact.BuildClipRegion(rDisplayInfo, aExpandRegion); + } + + if(!(aExpandRegion.IsEmpty() || aExpandRegion.IsNull())) + { + // expand the ClipRegion + pWin->ExpandPaintClipRegion(aExpandRegion); + + // also expand the DrawArea, more needs to be redrawn now. + aOriginalDrawArea.Union(aExpandRegion.GetBoundRect()); + } + + // restore original DrawArea + rDisplayInfo.SetRedrawArea(aOriginalDrawArea); + } + } + } + + // The PreRenderer + void ObjectContactOfPageView::PreRender(DisplayInfo& rDisplayInfo) + { + // get and remember OutputDevices + OutputDevice* pOriginalOutDev = rDisplayInfo.GetOutputDevice(); + ExtOutputDevice* pOriginalExtOutDev = rDisplayInfo.GetExtendedOutputDevice(); + + // compare size of maPreRenderDevice with size of visible area + if(maPreRenderDevice.GetOutputSizePixel() != pOriginalOutDev->GetOutputSizePixel()) + { + maPreRenderDevice.SetOutputSizePixel(pOriginalOutDev->GetOutputSizePixel()); + } + + // Also compare the MapModes for zoom/scroll changes + if(maPreRenderDevice.GetMapMode() != pOriginalOutDev->GetMapMode()) + { + maPreRenderDevice.SetMapMode(pOriginalOutDev->GetMapMode()); + } + + // replace values at rDisplayInfo for rendering to PreRenderDevice + pOriginalExtOutDev->SetOutDev(&maPreRenderDevice); + rDisplayInfo.SetOutputDevice(&maPreRenderDevice); + + // paint in PreRenderDevice + DoProcessDisplay(rDisplayInfo); + + // set back to old OutDev, restore rDisplayInfo + pOriginalExtOutDev->SetOutDev(pOriginalOutDev); + rDisplayInfo.SetOutputDevice(pOriginalOutDev); + } + + // Pre-Process the whole displaying. + void ObjectContactOfPageView::PreProcessDisplay(DisplayInfo& rDisplayInfo) + { + // call parent to ensure a valid draw hierarchy. + ObjectContact::PreProcessDisplay(rDisplayInfo); + + // also expand the paint clip region in the pre-paint phase + if(IsDrawHierarchyValid()) + { + ExpandPaintClipRegion(rDisplayInfo); + } + } + + // Process the whole displaying + void ObjectContactOfPageView::ProcessDisplay(DisplayInfo& rDisplayInfo) + { + SdrPage* pStartPage = GetSdrPage(); + + if(IsDrawHierarchyValid() + && pStartPage + && rDisplayInfo.GetPaintInfoRec() + && rDisplayInfo.GetOutputDevice() + && maDrawHierarchy.Count()) + { + // First look if pre-rendering should be done. If Yes, use it. If no, + // do a normal ProcessDisplay() using DoProcessDiaply(). The second one + // is called in any case, maybe for pre-rendering or for direct output. + if(DoPreRender(rDisplayInfo)) + { + // Get OutputDevice + OutputDevice* pOut = rDisplayInfo.GetOutputDevice(); + + // update pre-rendered VirtualDevice + PreRender(rDisplayInfo); + + // calculate the to-be-refreshed rectangle + Rectangle aPaintRect(rDisplayInfo.GetRedrawArea().GetBoundRect()); + Rectangle aPaintRectPixel = pOut->LogicToPixel(aPaintRect); + + // paint using prepared, pre-rendered VirtualDevice + sal_Bool bMapModeWasEnabledDest(pOut->IsMapModeEnabled()); + sal_Bool bMapModeWasEnabledSource(maPreRenderDevice.IsMapModeEnabled()); + pOut->EnableMapMode(sal_False); + maPreRenderDevice.EnableMapMode(sal_False); + + Size aPaintSizePixel = aPaintRectPixel.GetSize(); + pOut->DrawOutDev( + aPaintRectPixel.TopLeft(), aPaintSizePixel, + aPaintRectPixel.TopLeft(), aPaintSizePixel, + maPreRenderDevice); + + pOut->EnableMapMode(bMapModeWasEnabledDest); + maPreRenderDevice.EnableMapMode(bMapModeWasEnabledSource); + } + else + { + // paint direct + DoProcessDisplay(rDisplayInfo); + } + } + + // after paint take care of the evtl. scheduled asynchronious commands. + // Do this by resetting the timer contained there. Thus, after the paint + // that timer will be triggered and the events will be executed. + if(HasEventHandler()) + { + sdr::event::TimerEventHandler& rEventHandler = GetEventHandler(); + + if(!rEventHandler.IsEmpty()) + { + rEventHandler.Restart(); + } + } + +#ifdef DBG_UTIL + // Do some test painting for the given rectangles + if(sal_False && rDisplayInfo.GetPaintInfoRec() && rDisplayInfo.GetOutputDevice()) + { + OutputDevice* pOut = rDisplayInfo.GetOutputDevice(); + pOut->SetFillColor(); + pOut->SetLineColor(COL_RED); + pOut->DrawRect(rDisplayInfo.GetRedrawArea().GetBoundRect()); + + sal_Bool bWasEnabled(pOut->IsMapModeEnabled()); + pOut->EnableMapMode(sal_False); + + // Test ExpandPaintClipRegion + Point aEmptyPoint; + Rectangle aVisiblePixel(aEmptyPoint, pOut->GetOutputSizePixel()); + pOut->Push( PUSH_CLIPREGION ); + + if(OUTDEV_WINDOW == pOut->GetOutDevType()) + { + Window* pWin = (Window*)pOut; + Region aExpandRegion(pOut->PixelToLogic(aVisiblePixel)); + pWin->ExpandPaintClipRegion(aExpandRegion); + } + + sal_uInt32 nTime(Time::GetSystemTicks()); + pOut->SetLineColor(Color(sal_uInt8(nTime), sal_uInt8(nTime >> 3), sal_uInt8(nTime >> 6))); + pOut->DrawRect(aVisiblePixel); + + pOut->Pop(); + pOut->EnableMapMode(bWasEnabled); + } +#endif DBG_UTIL + } + + // Decide if to PreRender + sal_Bool ObjectContactOfPageView::DoPreRender(DisplayInfo& rDisplayInfo) const + { + return (rDisplayInfo.IsPreRenderingAllowed() + && !rDisplayInfo.OutputToPrinter() + && !rDisplayInfo.OutputToVirtualDevice() + && !rDisplayInfo.OutputToRecordingMetaFile()); + } + + // Process the whole displaying + void ObjectContactOfPageView::DoProcessDisplay(DisplayInfo& rDisplayInfo) + { + // test if ControlLayer is to be painted + SdrPage* pStartPage = GetSdrPage(); + const SdrModel& rModel = *(pStartPage->GetModel()); + const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin(); + const sal_uInt32 nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName(), sal_False); + SetOfByte aProcessLayers = rDisplayInfo.GetProcessLayers(); + sal_Bool bDrawControlLayer(aProcessLayers.IsSet((sal_uInt8)nControlLayerId)); + ViewObjectContact& rDrawPageVOContact = *(maDrawHierarchy.GetObject(0L)); + + // visualize entered group when that feature is switched on and it's not + // a print output + sal_Bool bVisualizeEnteredGroup(DoVisualizeEnteredGroup() && !rDisplayInfo.OutputToPrinter()); + + // Always save original DRawMode, it's used by the renderers + // when they need to paint into a bitmap. + rDisplayInfo.SaveOriginalDrawMode(); + + // Visualize entered groups: Set to ghosted as default + // start. Do this only for the DrawPage, not for MasterPages + if(bVisualizeEnteredGroup) + { + rDisplayInfo.SetGhostedDrawMode(); + } + + // Clear ControlLayer + if(bDrawControlLayer) + { + // clear for normal paint + aProcessLayers.Clear((sal_uInt8)nControlLayerId); + } + + // Draw DrawPage without controls + if(!aProcessLayers.IsEmpty()) + { + // standard paint + rDisplayInfo.SetProcessLayers(aProcessLayers); + rDisplayInfo.SetTemporaryPaintPage(sal_True); + rDrawPageVOContact.PaintObjectHierarchy(rDisplayInfo); + } + + // Draw DrawPage, Controls only + if(bDrawControlLayer) + { + // paint ControlLayer + aProcessLayers.ClearAll(); + aProcessLayers.Set((sal_uInt8)nControlLayerId); + rDisplayInfo.SetProcessLayers(aProcessLayers); + rDisplayInfo.SetTemporaryPaintPage(sal_False); + rDrawPageVOContact.PaintObjectHierarchy(rDisplayInfo); + } + + // Visualize entered groups: Reset to original DrawMode + if(bVisualizeEnteredGroup) + { + rDisplayInfo.RestoreOriginalDrawMode(); + } + + // Test if paint was interrupted. If Yes, we need to invalidate the + // PageView where the paint region was defined + if(!rDisplayInfo.DoContinuePaint()) + { + Rectangle aRect = rDisplayInfo.GetRedrawArea().GetBoundRect(); + GetPageView().InvalidateAllWin(aRect); + } + + // If a ObjectAnimator exists, execute it. This will only do anything + // if the ObjectAnimator's timer is not yet running and if there are + // events scheduled. + if(HasObjectAnimator()) + { + GetObjectAnimator().Execute(); + } + } + + // test if visualizing of entered groups is switched on at all + sal_Bool ObjectContactOfPageView::DoVisualizeEnteredGroup() const + { + SdrView& rView = GetPageView().GetView(); + return rView.DoVisualizeEnteredGroup(); + } + + // Get the active group (the entered group). To get independent + // from the old object/view classes return values use the new + // classes. + ViewContact* ObjectContactOfPageView::GetActiveGroupContact() const + { + SdrObjList* pActiveGroupList = GetPageView().GetObjList(); + ViewContact* pRetval = 0L; + + if(pActiveGroupList) + { + if(pActiveGroupList->ISA(SdrPage)) + { + // It's a Page itself + pRetval = &(((SdrPage*)pActiveGroupList)->GetViewContact()); + } + else if(pActiveGroupList->GetOwnerObj()) + { + // Group object + return &(pActiveGroupList->GetOwnerObj()->GetViewContact()); + } + } + + if(!pRetval) + { + if(GetSdrPage()) + { + // use page of associated SdrPageView + pRetval = &(GetSdrPage()->GetViewContact()); + } + } + + return pRetval; + } + + // Invalidate given rectangle at the window/output which is represented by + // this ObjectContact. + void ObjectContactOfPageView::InvalidatePartOfView(const Rectangle& rRectangle) const + { + // invalidate all associated windows. + GetPageView().InvalidateAllWin(rRectangle); + } + + // Get info about the need to visualize GluePoints + sal_Bool ObjectContactOfPageView::AreGluePointsVisible() const + { + return GetPageView().GetView().ImpIsGlueVisible(); + } + + // check if text animation is allowed. + sal_Bool ObjectContactOfPageView::IsTextAnimationAllowed() const + { + SdrView& rView = GetPageView().GetView(); + const SvtAccessibilityOptions& rOpt = rView.getAccessibilityOptions(); + return rOpt.GetIsAllowAnimatedText(); + } + + // check if graphic animation is allowed. + sal_Bool ObjectContactOfPageView::IsGraphicAnimationAllowed() const + { + SdrView& rView = GetPageView().GetView(); + const SvtAccessibilityOptions& rOpt = rView.getAccessibilityOptions(); + return rOpt.GetIsAllowAnimatedGraphics(); + } + + // check if asynchronious graphis loading is allowed. Default is sal_False. + sal_Bool ObjectContactOfPageView::IsAsynchronGraphicsLoadingAllowed() const + { + SdrView& rView = GetPageView().GetView(); + return rView.IsSwapAsynchron(); + } + } // end of namespace contact +} // end of namespace sdr + +////////////////////////////////////////////////////////////////////////////// +// eof -- cgit