| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| #include <svx/sdr/overlay/overlaymanagerbuffered.hxx> |
| #include <vcl/outdev.hxx> |
| #include <basegfx/point/b2dpoint.hxx> |
| #include <basegfx/range/b2drange.hxx> |
| #include <vcl/salbtype.hxx> |
| #include <vcl/window.hxx> |
| #include <vcl/bitmap.hxx> |
| #include <tools/stream.hxx> |
| #include <basegfx/matrix/b2dhommatrix.hxx> |
| #include <vcl/cursor.hxx> |
| #include <vcl/dibtools.hxx> |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| namespace sdr |
| { |
| namespace overlay |
| { |
| void OverlayManagerBuffered::ImpPrepareBufferDevice() |
| { |
| // compare size of maBufferDevice with size of visible area |
| if(maBufferDevice.GetOutputSizePixel() != getOutputDevice().GetOutputSizePixel()) |
| { |
| // set new buffer size, copy as much content as possible (use bool parameter for vcl). |
| // Newly uncovered regions will be repainted. |
| maBufferDevice.SetOutputSizePixel(getOutputDevice().GetOutputSizePixel(), false); |
| } |
| |
| // compare the MapModes for zoom/scroll changes |
| if(maBufferDevice.GetMapMode() != getOutputDevice().GetMapMode()) |
| { |
| const bool bZoomed( |
| maBufferDevice.GetMapMode().GetScaleX() != getOutputDevice().GetMapMode().GetScaleX() |
| || maBufferDevice.GetMapMode().GetScaleY() != getOutputDevice().GetMapMode().GetScaleY()); |
| |
| if(!bZoomed) |
| { |
| const Point& rOriginOld = maBufferDevice.GetMapMode().GetOrigin(); |
| const Point& rOriginNew = getOutputDevice().GetMapMode().GetOrigin(); |
| const bool bScrolled(rOriginOld != rOriginNew); |
| |
| if(bScrolled) |
| { |
| // get pixel bounds |
| const Point aOriginOldPixel(maBufferDevice.LogicToPixel(rOriginOld)); |
| const Point aOriginNewPixel(maBufferDevice.LogicToPixel(rOriginNew)); |
| const Size aOutputSizePixel(maBufferDevice.GetOutputSizePixel()); |
| |
| // remember and switch off MapMode |
| const bool bMapModeWasEnabled(maBufferDevice.IsMapModeEnabled()); |
| maBufferDevice.EnableMapMode(false); |
| |
| // scroll internally buffered stuff |
| const Point aDestinationOffsetPixel(aOriginNewPixel - aOriginOldPixel); |
| maBufferDevice.DrawOutDev( |
| aDestinationOffsetPixel, aOutputSizePixel, // destination |
| Point(), aOutputSizePixel); // source |
| |
| // restore MapMode |
| maBufferDevice.EnableMapMode(bMapModeWasEnabled); |
| |
| // scroll remembered region, too. |
| if(!maBufferRememberedRangePixel.isEmpty()) |
| { |
| const basegfx::B2IPoint aIPointDestinationOffsetPixel(aDestinationOffsetPixel.X(), aDestinationOffsetPixel.Y()); |
| const basegfx::B2IPoint aNewMinimum(maBufferRememberedRangePixel.getMinimum() + aIPointDestinationOffsetPixel); |
| const basegfx::B2IPoint aNewMaximum(maBufferRememberedRangePixel.getMaximum() + aIPointDestinationOffsetPixel); |
| maBufferRememberedRangePixel = basegfx::B2IRange(aNewMinimum, aNewMaximum); |
| } |
| } |
| } |
| |
| // copy new MapMode |
| maBufferDevice.SetMapMode(getOutputDevice().GetMapMode()); |
| } |
| |
| // #i29186# |
| maBufferDevice.SetDrawMode(getOutputDevice().GetDrawMode()); |
| maBufferDevice.SetSettings(getOutputDevice().GetSettings()); |
| maBufferDevice.SetAntialiasing(getOutputDevice().GetAntialiasing()); |
| } |
| |
| void OverlayManagerBuffered::ImpRestoreBackground() const |
| { |
| const Rectangle aRegionRectanglePixel( |
| maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), |
| maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); |
| const Region aRegionPixel(aRegionRectanglePixel); |
| |
| ImpRestoreBackground(aRegionPixel); |
| } |
| |
| void OverlayManagerBuffered::ImpRestoreBackground(const Region& rRegionPixel) const |
| { |
| // MapModes off |
| const bool bMapModeWasEnabledDest(getOutputDevice().IsMapModeEnabled()); |
| const bool bMapModeWasEnabledSource(maBufferDevice.IsMapModeEnabled()); |
| getOutputDevice().EnableMapMode(false); |
| ((OverlayManagerBuffered*)this)->maBufferDevice.EnableMapMode(false); |
| |
| // local region |
| RectangleVector aRectangles; |
| rRegionPixel.GetRegionRectangles(aRectangles); |
| |
| for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++) |
| { |
| #ifdef DBG_UTIL |
| // #i72754# possible graphical region test only with non-pro |
| static bool bDoPaintForVisualControl(false); |
| |
| if(bDoPaintForVisualControl) |
| { |
| getOutputDevice().SetLineColor(COL_LIGHTGREEN); |
| getOutputDevice().SetFillColor(); |
| getOutputDevice().DrawRect(*aRectIter); |
| } |
| #endif |
| |
| // restore the area |
| const Point aTopLeft(aRectIter->TopLeft()); |
| const Size aSize(aRectIter->GetSize()); |
| |
| getOutputDevice().DrawOutDev( |
| aTopLeft, aSize, // destination |
| aTopLeft, aSize, // source |
| maBufferDevice); |
| } |
| |
| //Region aRegionPixel(rRegionPixel); |
| //RegionHandle aRegionHandle(aRegionPixel.BeginEnumRects()); |
| //Rectangle aRegionRectanglePixel; |
| // |
| //while(aRegionPixel.GetEnumRects(aRegionHandle, aRegionRectanglePixel)) |
| //{ |
| #ifdef DBG_U//TIL |
| // // #i72754# possible graphical region test only with non-pro |
| // static bool bDoPaintForVisualControl(false); |
| // if(bDoPaintForVisualControl) |
| // { |
| // getOutputDevice().SetLineColor(COL_LIGHTGREEN); |
| // getOutputDevice().SetFillColor(); |
| // getOutputDevice().DrawRect(aRegionRectanglePixel); |
| // } |
| #endif // |
| // // restore the area |
| // const Point aTopLeft(aRegionRectanglePixel.TopLeft()); |
| // const Size aSize(aRegionRectanglePixel.GetSize()); |
| // |
| // getOutputDevice().DrawOutDev( |
| // aTopLeft, aSize, // destination |
| // aTopLeft, aSize, // source |
| // maBufferDevice); |
| //} |
| // |
| //aRegionPixel.EndEnumRects(aRegionHandle); |
| |
| // restore MapModes |
| getOutputDevice().EnableMapMode(bMapModeWasEnabledDest); |
| ((OverlayManagerBuffered*)this)->maBufferDevice.EnableMapMode(bMapModeWasEnabledSource); |
| } |
| |
| void OverlayManagerBuffered::ImpSaveBackground(const Region& rRegion, OutputDevice* pPreRenderDevice) |
| { |
| // prepare source |
| OutputDevice& rSource = (pPreRenderDevice) ? *pPreRenderDevice : getOutputDevice(); |
| |
| // Ensure buffer is valid |
| ImpPrepareBufferDevice(); |
| |
| // build region which needs to be copied |
| Region aRegion(rSource.LogicToPixel(rRegion)); |
| |
| // limit to PaintRegion if it's a window. This will be evtl. the expanded one, |
| // but always the exact redraw area |
| if(OUTDEV_WINDOW == rSource.GetOutDevType()) |
| { |
| Window& rWindow = (Window&)rSource; |
| Region aPaintRegionPixel = rWindow.LogicToPixel(rWindow.GetPaintRegion()); |
| aRegion.Intersect(aPaintRegionPixel); |
| |
| // #i72754# Make sure content is completetly rendered, the window |
| // will be used as source of a DrawOutDev soon |
| rWindow.Flush(); |
| } |
| |
| // also limit to buffer size |
| const Rectangle aBufferDeviceRectanglePixel(Point(), maBufferDevice.GetOutputSizePixel()); |
| aRegion.Intersect(aBufferDeviceRectanglePixel); |
| |
| // MapModes off |
| const bool bMapModeWasEnabledDest(rSource.IsMapModeEnabled()); |
| const bool bMapModeWasEnabledSource(maBufferDevice.IsMapModeEnabled()); |
| rSource.EnableMapMode(false); |
| maBufferDevice.EnableMapMode(false); |
| |
| // prepare to iterate over the rectangles from the region in pixels |
| RectangleVector aRectangles; |
| aRegion.GetRegionRectangles(aRectangles); |
| |
| for(RectangleVector::const_iterator aRectIter(aRectangles.begin()); aRectIter != aRectangles.end(); aRectIter++) |
| { |
| // for each rectangle, save the area |
| const Point aTopLeft(aRectIter->TopLeft()); |
| const Size aSize(aRectIter->GetSize()); |
| |
| maBufferDevice.DrawOutDev( |
| aTopLeft, aSize, // destination |
| aTopLeft, aSize, // source |
| rSource); |
| |
| #ifdef DBG_UTIL |
| // #i72754# possible graphical region test only with non-pro |
| static bool bDoPaintForVisualControl(false); |
| |
| if(bDoPaintForVisualControl) |
| { |
| const bool bMapModeWasEnabledTest(getOutputDevice().IsMapModeEnabled()); |
| |
| getOutputDevice().EnableMapMode(false); |
| getOutputDevice().SetLineColor(COL_LIGHTRED); |
| getOutputDevice().SetFillColor(); |
| getOutputDevice().DrawRect(*aRectIter); |
| getOutputDevice().EnableMapMode(bMapModeWasEnabledTest); |
| } |
| |
| static bool bDoSaveForVisualControl(false); |
| |
| if(bDoSaveForVisualControl) |
| { |
| const Bitmap aBitmap(maBufferDevice.GetBitmap(aTopLeft, aSize)); |
| SvFileStream aNew((const String&)String(ByteString( "c:\\test.bmp" ), RTL_TEXTENCODING_UTF8), STREAM_WRITE|STREAM_TRUNC); |
| WriteDIB(aBitmap, aNew, false, true); |
| } |
| #endif |
| } |
| |
| //RegionHandle aRegionHandle(aRegion.BeginEnumRects()); |
| //Rectangle aRegionRectanglePixel; |
| // |
| //while(aRegion.GetEnumRects(aRegionHandle, aRegionRectanglePixel)) |
| //{ |
| // // for each rectangle, save the area |
| // Point aTopLeft(aRegionRectanglePixel.TopLeft()); |
| // Size aSize(aRegionRectanglePixel.GetSize()); |
| // |
| // maBufferDevice.DrawOutDev( |
| // aTopLeft, aSize, // destination |
| // aTopLeft, aSize, // source |
| // rSource); |
| // |
| #ifdef DBG_U//TIL |
| // // #i72754# possible graphical region test only with non-pro |
| // static bool bDoPaintForVisualControl(false); |
| // if(bDoPaintForVisualControl) |
| // { |
| // const bool bMapModeWasEnabledTest(getOutputDevice().IsMapModeEnabled()); |
| // getOutputDevice().EnableMapMode(false); |
| // getOutputDevice().SetLineColor(COL_LIGHTRED); |
| // getOutputDevice().SetFillColor(); |
| // getOutputDevice().DrawRect(aRegionRectanglePixel); |
| // getOutputDevice().EnableMapMode(bMapModeWasEnabledTest); |
| // } |
| // |
| // static bool bDoSaveForVisualControl(false); |
| // if(bDoSaveForVisualControl) |
| // { |
| // const Bitmap aBitmap(maBufferDevice.GetBitmap(aTopLeft, aSize)); |
| // SvFileStream aNew((const String&)String(ByteString( "c:\\test.bmp" ), RTL_TEXTENCODING_UTF8), STREAM_WRITE|STREAM_TRUNC); |
| // aNew << aBitmap; |
| // } |
| #endif // |
| //} |
| // |
| //aRegion.EndEnumRects(aRegionHandle); |
| |
| // restore MapModes |
| rSource.EnableMapMode(bMapModeWasEnabledDest); |
| maBufferDevice.EnableMapMode(bMapModeWasEnabledSource); |
| } |
| |
| IMPL_LINK(OverlayManagerBuffered, ImpBufferTimerHandler, AutoTimer*, /*pTimer*/) |
| { |
| // stop timer |
| maBufferTimer.Stop(); |
| |
| if(!maBufferRememberedRangePixel.isEmpty()) |
| { |
| // logic size for impDrawMember call |
| basegfx::B2DRange aBufferRememberedRangeLogic( |
| maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), |
| maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); |
| aBufferRememberedRangeLogic.transform(getOutputDevice().GetInverseViewTransformation()); |
| |
| // prepare cursor handling |
| const bool bTargetIsWindow(OUTDEV_WINDOW == rmOutputDevice.GetOutDevType()); |
| bool bCursorWasEnabled(false); |
| |
| // #i80730# switch off VCL cursor during overlay refresh |
| if(bTargetIsWindow) |
| { |
| Window& rWindow = static_cast< Window& >(rmOutputDevice); |
| Cursor* pCursor = rWindow.GetCursor(); |
| |
| if(pCursor && pCursor->IsVisible()) |
| { |
| pCursor->Hide(); |
| bCursorWasEnabled = true; |
| } |
| } |
| |
| if(DoRefreshWithPreRendering()) |
| { |
| // #i73602# ensure valid and sized maOutputBufferDevice |
| const Size aDestinationSizePixel(maBufferDevice.GetOutputSizePixel()); |
| const Size aOutputBufferSizePixel(maOutputBufferDevice.GetOutputSizePixel()); |
| |
| if(aDestinationSizePixel != aOutputBufferSizePixel) |
| { |
| maOutputBufferDevice.SetOutputSizePixel(aDestinationSizePixel); |
| } |
| |
| maOutputBufferDevice.SetMapMode(getOutputDevice().GetMapMode()); |
| maOutputBufferDevice.EnableMapMode(false); |
| maOutputBufferDevice.SetDrawMode(maBufferDevice.GetDrawMode()); |
| maOutputBufferDevice.SetSettings(maBufferDevice.GetSettings()); |
| maOutputBufferDevice.SetAntialiasing(maBufferDevice.GetAntialiasing()); |
| |
| // calculate sizes |
| Rectangle aRegionRectanglePixel( |
| maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), |
| maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); |
| |
| // truncate aRegionRectanglePixel to destination pixel size, more does |
| // not need to be prepared since destination is a buffer for a window. So, |
| // maximum size indirectly shall be limited to getOutputDevice().GetOutputSizePixel() |
| if(aRegionRectanglePixel.Left() < 0L) |
| { |
| aRegionRectanglePixel.Left() = 0L; |
| } |
| |
| if(aRegionRectanglePixel.Top() < 0L) |
| { |
| aRegionRectanglePixel.Top() = 0L; |
| } |
| |
| if(aRegionRectanglePixel.Right() > aDestinationSizePixel.getWidth()) |
| { |
| aRegionRectanglePixel.Right() = aDestinationSizePixel.getWidth(); |
| } |
| |
| if(aRegionRectanglePixel.Bottom() > aDestinationSizePixel.getHeight()) |
| { |
| aRegionRectanglePixel.Bottom() = aDestinationSizePixel.getHeight(); |
| } |
| |
| // get sizes |
| const Point aTopLeft(aRegionRectanglePixel.TopLeft()); |
| const Size aSize(aRegionRectanglePixel.GetSize()); |
| |
| { |
| const bool bMapModeWasEnabledDest(maBufferDevice.IsMapModeEnabled()); |
| maBufferDevice.EnableMapMode(false); |
| |
| maOutputBufferDevice.DrawOutDev( |
| aTopLeft, aSize, // destination |
| aTopLeft, aSize, // source |
| maBufferDevice); |
| |
| // restore MapModes |
| maBufferDevice.EnableMapMode(bMapModeWasEnabledDest); |
| } |
| |
| // paint overlay content for remembered region, use |
| // method from base class directly |
| maOutputBufferDevice.EnableMapMode(true); |
| OverlayManager::ImpDrawMembers(aBufferRememberedRangeLogic, maOutputBufferDevice); |
| maOutputBufferDevice.EnableMapMode(false); |
| |
| // copy to output |
| { |
| const bool bMapModeWasEnabledDest(getOutputDevice().IsMapModeEnabled()); |
| getOutputDevice().EnableMapMode(false); |
| |
| getOutputDevice().DrawOutDev( |
| aTopLeft, aSize, // destination |
| aTopLeft, aSize, // source |
| maOutputBufferDevice); |
| |
| // debug |
| /*getOutputDevice().SetLineColor(COL_RED); |
| getOutputDevice().SetFillColor(); |
| getOutputDevice().DrawRect(Rectangle(aTopLeft, aSize));*/ |
| |
| // restore MapModes |
| getOutputDevice().EnableMapMode(bMapModeWasEnabledDest); |
| } |
| } |
| else |
| { |
| // Restore all rectangles for remembered region from buffer |
| ImpRestoreBackground(); |
| |
| // paint overlay content for remembered region, use |
| // method from base class directly |
| OverlayManager::ImpDrawMembers(aBufferRememberedRangeLogic, getOutputDevice()); |
| } |
| |
| // VCL hack for transparent child windows |
| // Problem is e.g. a radiobuttion form control in life mode. The used window |
| // is a transparence vcl childwindow. This flag only allows the parent window to |
| // paint into the child windows area, but there is no mechanism which takes |
| // care for a repaint of the child window. A transparent child window is NOT |
| // a window which always keeps it's content consistent over the parent, but it's |
| // more like just a paint flag for the parent. |
| // To get the update, the windows in question are updated manulally here. |
| if(bTargetIsWindow) |
| { |
| Window& rWindow = static_cast< Window& >(rmOutputDevice); |
| |
| if(rWindow.IsChildTransparentModeEnabled() && rWindow.GetChildCount()) |
| { |
| const Rectangle aRegionRectanglePixel( |
| maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(), |
| maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY()); |
| |
| for(sal_uInt16 a(0); a < rWindow.GetChildCount(); a++) |
| { |
| Window* pCandidate = rWindow.GetChild(a); |
| |
| if(pCandidate && pCandidate->IsPaintTransparent()) |
| { |
| const Rectangle aCandidatePosSizePixel(pCandidate->GetPosPixel(), pCandidate->GetSizePixel()); |
| |
| if(aCandidatePosSizePixel.IsOver(aRegionRectanglePixel)) |
| { |
| pCandidate->Invalidate(INVALIDATE_NOTRANSPARENT|INVALIDATE_CHILDREN); |
| pCandidate->Update(); |
| } |
| } |
| } |
| } |
| } |
| |
| // #i80730# restore visibility of VCL cursor |
| if(bCursorWasEnabled) |
| { |
| Window& rWindow = static_cast< Window& >(rmOutputDevice); |
| Cursor* pCursor = rWindow.GetCursor(); |
| |
| if(pCursor) |
| { |
| // check if cursor still exists. It may have been deleted from someone |
| pCursor->Show(); |
| } |
| } |
| |
| // forget remembered Region |
| maBufferRememberedRangePixel.reset(); |
| } |
| |
| return 0; |
| } |
| |
| OverlayManagerBuffered::OverlayManagerBuffered( |
| OutputDevice& rOutputDevice, |
| bool bRefreshWithPreRendering) |
| : OverlayManager(rOutputDevice), |
| mbRefreshWithPreRendering(bRefreshWithPreRendering) |
| { |
| // Init timer |
| maBufferTimer.SetTimeout(1); |
| maBufferTimer.SetTimeoutHdl(LINK(this, OverlayManagerBuffered, ImpBufferTimerHandler)); |
| } |
| |
| OverlayManagerBuffered::~OverlayManagerBuffered() |
| { |
| // Clear timer |
| maBufferTimer.Stop(); |
| |
| if(!maBufferRememberedRangePixel.isEmpty()) |
| { |
| // Restore all rectangles for remembered region from buffer |
| ImpRestoreBackground(); |
| } |
| } |
| |
| void OverlayManagerBuffered::completeRedraw(const Region& rRegion, OutputDevice* pPreRenderDevice) const |
| { |
| if(!rRegion.IsEmpty()) |
| { |
| // save new background |
| ((OverlayManagerBuffered*)this)->ImpSaveBackground(rRegion, pPreRenderDevice); |
| } |
| |
| // call parent |
| OverlayManager::completeRedraw(rRegion, pPreRenderDevice); |
| } |
| |
| void OverlayManagerBuffered::flush() |
| { |
| // call timer handler direct |
| ImpBufferTimerHandler(0); |
| } |
| |
| // #i68597# part of content gets copied, react on it |
| void OverlayManagerBuffered::copyArea(const Point& rDestPt, const Point& rSrcPt, const Size& rSrcSize) |
| { |
| // scroll local buffered area |
| maBufferDevice.CopyArea(rDestPt, rSrcPt, rSrcSize); |
| } |
| |
| void OverlayManagerBuffered::restoreBackground(const Region& rRegion) const |
| { |
| // restore |
| const Region aRegionPixel(getOutputDevice().LogicToPixel(rRegion)); |
| ImpRestoreBackground(aRegionPixel); |
| |
| // call parent |
| OverlayManager::restoreBackground(rRegion); |
| } |
| |
| void OverlayManagerBuffered::invalidateRange(const basegfx::B2DRange& rRange) |
| { |
| if(!rRange.isEmpty()) |
| { |
| // buffered output, do not invalidate but use the timer |
| // to trigger a timer event for refresh |
| maBufferTimer.Start(); |
| |
| // add the discrete range to the remembered region |
| // #i75163# use double precision and floor/ceil rounding to get overlapped pixel region, even |
| // when the given logic region has a width/height of 0.0. This does NOT work with LogicToPixel |
| // since it just transforms the top left and bottom right points equally without taking |
| // discrete pixel coverage into account. An empty B2DRange and thus empty logic Rectangle translated |
| // to an also empty discrete pixel rectangle - what is wrong. |
| basegfx::B2DRange aDiscreteRange(rRange); |
| aDiscreteRange.transform(getOutputDevice().GetViewTransformation()); |
| |
| if(maDrawinglayerOpt.IsAntiAliasing()) |
| { |
| // assume AA needs one pixel more and invalidate one pixel more |
| const double fDiscreteOne(getDiscreteOne()); |
| const basegfx::B2IPoint aTopLeft( |
| (sal_Int32)floor(aDiscreteRange.getMinX() - fDiscreteOne), |
| (sal_Int32)floor(aDiscreteRange.getMinY() - fDiscreteOne)); |
| const basegfx::B2IPoint aBottomRight( |
| (sal_Int32)ceil(aDiscreteRange.getMaxX() + fDiscreteOne), |
| (sal_Int32)ceil(aDiscreteRange.getMaxY() + fDiscreteOne)); |
| |
| maBufferRememberedRangePixel.expand(aTopLeft); |
| maBufferRememberedRangePixel.expand(aBottomRight); |
| } |
| else |
| { |
| const basegfx::B2IPoint aTopLeft((sal_Int32)floor(aDiscreteRange.getMinX()), (sal_Int32)floor(aDiscreteRange.getMinY())); |
| const basegfx::B2IPoint aBottomRight((sal_Int32)ceil(aDiscreteRange.getMaxX()), (sal_Int32)ceil(aDiscreteRange.getMaxY())); |
| |
| maBufferRememberedRangePixel.expand(aTopLeft); |
| maBufferRememberedRangePixel.expand(aBottomRight); |
| } |
| } |
| } |
| |
| void OverlayManagerBuffered::SetRefreshWithPreRendering(bool bNew) |
| { |
| if((bool)mbRefreshWithPreRendering != bNew) |
| { |
| mbRefreshWithPreRendering = bNew; |
| } |
| } |
| } // end of namespace overlay |
| } // end of namespace sdr |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // eof |
