office-gobmx/svx/source/sdr/overlay/overlaymanagerbuffered.cxx
Caolán McNamara 7060192b6f tdf#149322 apparent distortion of glyphs on scrolling
sometimes there's a 1 pixel difference here vs to the amount seen in
Window::Scroll. The little misplaced tails of glyphs are actually in the
right place, and it is the large rectangle of copied text above those
that is in the wrong place.

Subtract these origins while in logic space, before turning that
result back to pixels to get consistent results for equal distances.

Change-Id: I37e77f38b95456cee32ff44cde2893986d52cde3
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/142789
Tested-by: Jenkins
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
2022-11-16 20:35:46 +01:00

441 lines
20 KiB
C++

/* -*- 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 .
*/
#include <sdr/overlay/overlaymanagerbuffered.hxx>
#include <svx/sdrpaintwindow.hxx>
#include <vcl/outdev.hxx>
#include <basegfx/range/b2drange.hxx>
#include <vcl/window.hxx>
#include <tools/fract.hxx>
#include <vcl/cursor.hxx>
#include <svtools/optionsdrawinglayer.hxx>
namespace sdr::overlay
{
void OverlayManagerBuffered::ImpPrepareBufferDevice()
{
// compare size of mpBufferDevice with size of visible area
if(mpBufferDevice->GetOutputSizePixel() != getOutputDevice().GetOutputSizePixel())
{
// set new buffer size, copy as much content as possible (use bool parameter for vcl).
// Newly uncovered regions will be repainted.
mpBufferDevice->SetOutputSizePixel(getOutputDevice().GetOutputSizePixel(), false);
}
// compare the MapModes for zoom/scroll changes
if(mpBufferDevice->GetMapMode() != getOutputDevice().GetMapMode())
{
const bool bZoomed(
mpBufferDevice->GetMapMode().GetScaleX() != getOutputDevice().GetMapMode().GetScaleX()
|| mpBufferDevice->GetMapMode().GetScaleY() != getOutputDevice().GetMapMode().GetScaleY());
if(!bZoomed)
{
const Point& rOriginOld = mpBufferDevice->GetMapMode().GetOrigin();
const Point& rOriginNew = getOutputDevice().GetMapMode().GetOrigin();
const bool bScrolled(rOriginOld != rOriginNew);
if(bScrolled)
{
// get pixel bounds (tdf#149322 do subtraction in logic units before converting result back to pixel)
const Point aLogicOriginDiff(rOriginNew - rOriginOld);
const Size aPixelOriginDiff(mpBufferDevice->LogicToPixel(Size(aLogicOriginDiff.X(), aLogicOriginDiff.Y())));
const Point aDestinationOffsetPixel(aPixelOriginDiff.Width(), aPixelOriginDiff.Height());
const Size aOutputSizePixel(mpBufferDevice->GetOutputSizePixel());
// remember and switch off MapMode
const bool bMapModeWasEnabled(mpBufferDevice->IsMapModeEnabled());
mpBufferDevice->EnableMapMode(false);
// scroll internally buffered stuff
mpBufferDevice->DrawOutDev(
aDestinationOffsetPixel, aOutputSizePixel, // destination
Point(), aOutputSizePixel); // source
// restore MapMode
mpBufferDevice->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
mpBufferDevice->SetMapMode(getOutputDevice().GetMapMode());
}
// #i29186#
mpBufferDevice->SetDrawMode(getOutputDevice().GetDrawMode());
mpBufferDevice->SetSettings(getOutputDevice().GetSettings());
mpBufferDevice->SetAntialiasing(getOutputDevice().GetAntialiasing());
}
void OverlayManagerBuffered::ImpRestoreBackground() const
{
const tools::Rectangle aRegionRectanglePixel(
maBufferRememberedRangePixel.getMinX(), maBufferRememberedRangePixel.getMinY(),
maBufferRememberedRangePixel.getMaxX(), maBufferRememberedRangePixel.getMaxY());
const vcl::Region aRegionPixel(aRegionRectanglePixel);
ImpRestoreBackground(aRegionPixel);
}
void OverlayManagerBuffered::ImpRestoreBackground(const vcl::Region& rRegionPixel) const
{
// MapModes off
const bool bMapModeWasEnabledDest(getOutputDevice().IsMapModeEnabled());
const bool bMapModeWasEnabledSource(mpBufferDevice->IsMapModeEnabled());
getOutputDevice().EnableMapMode(false);
const_cast<OverlayManagerBuffered*>(this)->mpBufferDevice->EnableMapMode(false);
// local region
RectangleVector aRectangles;
rRegionPixel.GetRegionRectangles(aRectangles);
for(const auto& rRect : aRectangles)
{
// restore the area
const Point aTopLeft(rRect.TopLeft());
const Size aSize(rRect.GetSize());
getOutputDevice().DrawOutDev(
aTopLeft, aSize, // destination
aTopLeft, aSize, // source
*mpBufferDevice);
}
// restore MapModes
getOutputDevice().EnableMapMode(bMapModeWasEnabledDest);
const_cast<OverlayManagerBuffered*>(this)->mpBufferDevice->EnableMapMode(bMapModeWasEnabledSource);
}
void OverlayManagerBuffered::ImpSaveBackground(const vcl::Region& rRegion, OutputDevice* pPreRenderDevice)
{
// prepare source
OutputDevice& rSource = pPreRenderDevice ? *pPreRenderDevice : getOutputDevice();
// Ensure buffer is valid
ImpPrepareBufferDevice();
// build region which needs to be copied
vcl::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())
{
vcl::Window& rWindow = *rSource.GetOwnerWindow();
vcl::Region aPaintRegionPixel = rWindow.LogicToPixel(rWindow.GetPaintRegion());
aRegion.Intersect(aPaintRegionPixel);
// #i72754# Make sure content is completely rendered, the window
// will be used as source of a DrawOutDev soon
rWindow.GetOutDev()->Flush();
}
// also limit to buffer size
const tools::Rectangle aBufferDeviceRectanglePixel(Point(), mpBufferDevice->GetOutputSizePixel());
aRegion.Intersect(aBufferDeviceRectanglePixel);
// MapModes off
const bool bMapModeWasEnabledDest(rSource.IsMapModeEnabled());
const bool bMapModeWasEnabledSource(mpBufferDevice->IsMapModeEnabled());
rSource.EnableMapMode(false);
mpBufferDevice->EnableMapMode(false);
// prepare to iterate over the rectangles from the region in pixels
RectangleVector aRectangles;
aRegion.GetRegionRectangles(aRectangles);
for(const auto& rRect : aRectangles)
{
// for each rectangle, save the area
const Point aTopLeft(rRect.TopLeft());
const Size aSize(rRect.GetSize());
mpBufferDevice->DrawOutDev(
aTopLeft, aSize, // destination
aTopLeft, aSize, // source
rSource);
}
// restore MapModes
rSource.EnableMapMode(bMapModeWasEnabledDest);
mpBufferDevice->EnableMapMode(bMapModeWasEnabledSource);
}
IMPL_LINK_NOARG(OverlayManagerBuffered, ImpBufferTimerHandler, Timer*, void)
{
//Resolves: fdo#46728 ensure this exists until end of scope
rtl::Reference<OverlayManager> xKeepAlive(this);
// stop timer
maBufferIdle.Stop();
if(maBufferRememberedRangePixel.isEmpty())
return;
// 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 == mrOutputDevice.GetOutDevType());
bool bCursorWasEnabled(false);
// #i80730# switch off VCL cursor during overlay refresh
if(bTargetIsWindow)
{
vcl::Window& rWindow = *mrOutputDevice.GetOwnerWindow();
vcl::Cursor* pCursor = rWindow.GetCursor();
if(pCursor && pCursor->IsVisible())
{
pCursor->Hide();
bCursorWasEnabled = true;
}
}
// refresh with prerendering
{
// #i73602# ensure valid and sized mpOutputBufferDevice
const Size aDestinationSizePixel(mpBufferDevice->GetOutputSizePixel());
const Size aOutputBufferSizePixel(mpOutputBufferDevice->GetOutputSizePixel());
if(aDestinationSizePixel != aOutputBufferSizePixel)
{
mpOutputBufferDevice->SetOutputSizePixel(aDestinationSizePixel);
}
mpOutputBufferDevice->SetMapMode(getOutputDevice().GetMapMode());
mpOutputBufferDevice->EnableMapMode(false);
mpOutputBufferDevice->SetDrawMode(mpBufferDevice->GetDrawMode());
mpOutputBufferDevice->SetSettings(mpBufferDevice->GetSettings());
mpOutputBufferDevice->SetAntialiasing(mpBufferDevice->GetAntialiasing());
// calculate sizes
tools::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() < 0)
{
aRegionRectanglePixel.SetLeft( 0 );
}
if(aRegionRectanglePixel.Top() < 0)
{
aRegionRectanglePixel.SetTop( 0 );
}
if(aRegionRectanglePixel.Right() > aDestinationSizePixel.getWidth())
{
aRegionRectanglePixel.SetRight( aDestinationSizePixel.getWidth() );
}
if(aRegionRectanglePixel.Bottom() > aDestinationSizePixel.getHeight())
{
aRegionRectanglePixel.SetBottom( aDestinationSizePixel.getHeight() );
}
// get sizes
const Point aTopLeft(aRegionRectanglePixel.TopLeft());
const Size aSize(aRegionRectanglePixel.GetSize());
{
const bool bMapModeWasEnabledDest(mpBufferDevice->IsMapModeEnabled());
mpBufferDevice->EnableMapMode(false);
mpOutputBufferDevice->DrawOutDev(
aTopLeft, aSize, // destination
aTopLeft, aSize, // source
*mpBufferDevice);
// restore MapModes
mpBufferDevice->EnableMapMode(bMapModeWasEnabledDest);
}
// paint overlay content for remembered region, use
// method from base class directly
mpOutputBufferDevice->EnableMapMode();
OverlayManager::ImpDrawMembers(aBufferRememberedRangeLogic, *mpOutputBufferDevice);
mpOutputBufferDevice->EnableMapMode(false);
// copy to output
{
const bool bMapModeWasEnabledDest(getOutputDevice().IsMapModeEnabled());
getOutputDevice().EnableMapMode(false);
getOutputDevice().DrawOutDev(
aTopLeft, aSize, // destination
aTopLeft, aSize, // source
*mpOutputBufferDevice);
// debug
/*getOutputDevice().SetLineCOL_RED);
getOutputDevice().SetFillColor();
getOutputDevice().DrawRect(Rectangle(aTopLeft, aSize));*/
// restore MapModes
getOutputDevice().EnableMapMode(bMapModeWasEnabledDest);
}
}
// VCL hack for transparent child windows
// Problem is e.g. a radiobutton 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 manually here.
if(bTargetIsWindow)
{
vcl::Window& rWindow = *mrOutputDevice.GetOwnerWindow();
const tools::Rectangle aRegionRectanglePixel(
maBufferRememberedRangePixel.getMinX(),
maBufferRememberedRangePixel.getMinY(),
maBufferRememberedRangePixel.getMaxX(),
maBufferRememberedRangePixel.getMaxY());
PaintTransparentChildren(rWindow, aRegionRectanglePixel);
}
// #i80730# restore visibility of VCL cursor
if(bCursorWasEnabled)
{
vcl::Window& rWindow = *mrOutputDevice.GetOwnerWindow();
vcl::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();
}
OverlayManagerBuffered::OverlayManagerBuffered(
OutputDevice& rOutputDevice)
: OverlayManager(rOutputDevice),
mpBufferDevice(VclPtr<VirtualDevice>::Create()),
mpOutputBufferDevice(VclPtr<VirtualDevice>::Create()),
maBufferIdle( "sdr::overlay::OverlayManagerBuffered maBufferIdle" )
{
// Init timer
maBufferIdle.SetPriority( TaskPriority::POST_PAINT );
maBufferIdle.SetInvokeHandler(LINK(this, OverlayManagerBuffered, ImpBufferTimerHandler));
}
rtl::Reference<OverlayManager> OverlayManagerBuffered::create(
OutputDevice& rOutputDevice)
{
return rtl::Reference<OverlayManager>(new OverlayManagerBuffered(rOutputDevice));
}
OverlayManagerBuffered::~OverlayManagerBuffered()
{
// Clear timer
maBufferIdle.Stop();
if(!maBufferRememberedRangePixel.isEmpty())
{
// Restore all rectangles for remembered region from buffer
ImpRestoreBackground();
}
}
void OverlayManagerBuffered::completeRedraw(const vcl::Region& rRegion, OutputDevice* pPreRenderDevice) const
{
if(!rRegion.IsEmpty())
{
// save new background
const_cast<OverlayManagerBuffered*>(this)->ImpSaveBackground(rRegion, pPreRenderDevice);
}
// call parent
OverlayManager::completeRedraw(rRegion, pPreRenderDevice);
}
void OverlayManagerBuffered::flush()
{
// call timer handler direct
ImpBufferTimerHandler(nullptr);
}
void OverlayManagerBuffered::invalidateRange(const basegfx::B2DRange& rRange)
{
if(rRange.isEmpty())
return;
// buffered output, do not invalidate but use the timer
// to trigger a timer event for refresh
maBufferIdle.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(getCurrentViewInformation2D().getUseAntiAliasing())
{
// assume AA needs one pixel more and invalidate one pixel more
const double fDiscreteOne(getDiscreteOne());
const basegfx::B2IPoint aTopLeft(
static_cast<sal_Int32>(floor(aDiscreteRange.getMinX() - fDiscreteOne)),
static_cast<sal_Int32>(floor(aDiscreteRange.getMinY() - fDiscreteOne)));
const basegfx::B2IPoint aBottomRight(
static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxX() + fDiscreteOne)),
static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxY() + fDiscreteOne)));
maBufferRememberedRangePixel.expand(aTopLeft);
maBufferRememberedRangePixel.expand(aBottomRight);
}
else
{
const basegfx::B2IPoint aTopLeft(static_cast<sal_Int32>(floor(aDiscreteRange.getMinX())), static_cast<sal_Int32>(floor(aDiscreteRange.getMinY())));
const basegfx::B2IPoint aBottomRight(static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxX())), static_cast<sal_Int32>(ceil(aDiscreteRange.getMaxY())));
maBufferRememberedRangePixel.expand(aTopLeft);
maBufferRememberedRangePixel.expand(aBottomRight);
}
}
} // end of namespace
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */