Attachment #77254 for issue #118905

View | Details | Raw Unified | Return to issue 118905
Collapse All | Expand All




			aClipRec = pView->pImpEditView->GetWindowPos( aClipRec );

			if ( ( pView == pCurView )  )
				Paint( pView->pImpEditView, aClipRec, 0, sal_True );
			else
				pView->GetWindow()->Invalidate( aClipRec );
		}

		pOutDev->SetFont( aOldFont );
}

void ImpEditEngine::Paint( ImpEditView* pView, const Rectangle& rRec, OutputDevice* pTargetDevice, sal_Bool bUseVirtDev )
{
	DBG_ASSERT( pView, "Keine View - Kein Paint!" );
	DBG_CHKOBJ( GetEditEnginePtr(), EditEngine, 0 );

	Rectangle aClipRec( pView->GetOutputArea() );
	aClipRec.Intersection( rRec );

	OutputDevice* pTarget = pTargetDevice ? pTargetDevice : pView->GetWindow();

	if ( bUseVirtDev )
	{
		Rectangle aClipRecPixel( pTarget->LogicToPixel( aClipRec ) );
		if ( !IsVertical() )
		{
			// etwas mehr, falls abgerundet!


		// Wenn aClipRecPixel > XXXX, dann invalidieren ?!

		VirtualDevice* pVDev = GetVirtualDevice( pTarget->GetMapMode(), pTarget->GetDrawMode() );
		pVDev->SetDigitLanguage( GetRefDevice()->GetDigitLanguage() );

		{

		// da sonst die Zeile darunter auch ausgegeben werden muss:
		Rectangle aTmpRec( Point( 0, 0 ), aClipRec.GetSize() );

		aClipRec = pTarget->PixelToLogic( aClipRecPixel );
		Point aStartPos;
		if ( !IsVertical() )
		{

		if ( GetTextRanger() )
		{
			// Some problems here with push/pop, why?!
//			pTarget->Push( PUSH_CLIPREGION|PUSH_MAPMODE );
			bClipRegion = pTarget->IsClipRegion();
			aOldRegion = pTarget->GetClipRegion();
			// Wie bekomme ich das Polygon an die richtige Stelle????
			// Das Polygon bezieht sich auf die View, nicht auf das Window
			// => Origin umsetzen...
			aOldMapMode = pTarget->GetMapMode();
			Point aOrigin = aOldMapMode.GetOrigin();
			Point aViewPos = pView->GetOutputArea().TopLeft();
			aOrigin.Move( aViewPos.X(), aViewPos.Y() );
			aClipRec.Move( -aViewPos.X(), -aViewPos.Y() );
			MapMode aNewMapMode( aOldMapMode );
			aNewMapMode.SetOrigin( aOrigin );
			pTarget->SetMapMode( aNewMapMode );
			pTarget->SetClipRegion( Region( GetTextRanger()->GetPolyPolygon() ) );
		}

		pTarget->DrawOutDev( aClipRec.TopLeft(), aClipRec.GetSize(),
							Point(0,0), aClipRec.GetSize(), *pVDev );

		if ( GetTextRanger() )
		{
//			pTarget->Pop();
			if ( bClipRegion )
				pTarget->SetClipRegion( aOldRegion );
			else
				pTarget->SetClipRegion();
			pTarget->SetMapMode( aOldMapMode );
		}


		pView->DrawSelection(pView->GetEditSelection(), 0, pTarget);
	}
	else
	{

				aClipRec.Right() = nMaxX;
		}

		sal_Bool bClipRegion = pTarget->IsClipRegion();
		Region aOldRegion = pTarget->GetClipRegion();
		pTarget->IntersectClipRegion( aClipRec );

		Paint( pTarget, aClipRec, aStartPos );

		if ( bClipRegion )
			pTarget->SetClipRegion( aOldRegion );
		else
			pTarget->SetClipRegion();

		pView->DrawSelection(pView->GetEditSelection(), 0, pTarget);
	}

}

Lines 2573-2579 Link Here

(-)editeng/source/editeng/impedit4.cxx (-1 / +1 lines)
2573	// in Fensterkoordinaten umwandeln....	2573	// in Fensterkoordinaten umwandeln....
2574	aClipRec.SetPos( pView->pImpEditView->GetWindowPos( aClipRec.TopLeft() ) );	2574	aClipRec.SetPos( pView->pImpEditView->GetWindowPos( aClipRec.TopLeft() ) );
2575	// Wenn Selektion, dann VDev...	2575	// Wenn Selektion, dann VDev...
2576	Paint( pView->pImpEditView, aClipRec, pView->HasSelection() );	2576	Paint( pView->pImpEditView, aClipRec, 0, pView->HasSelection() );
2577	}	2577	}
2578	}	2578	}
2579	}	2579	}

Lines 296-306 Link Here

(-)editeng/source/editeng/editview.cxx (-2 / +2 lines)
296	return PIMPEE->GetScriptType( pImpEditView->GetEditSelection() );	296	return PIMPEE->GetScriptType( pImpEditView->GetEditSelection() );
297	}	297	}
298		298
299	void EditView::Paint( const Rectangle& rRect )	299	void EditView::Paint( const Rectangle& rRect, OutputDevice* pTargetDevice )
300	{	300	{
301	DBG_CHKTHIS( EditView, 0 );	301	DBG_CHKTHIS( EditView, 0 );
302	DBG_CHKOBJ( pImpEditView->pEditEngine, EditEngine, 0 );	302	DBG_CHKOBJ( pImpEditView->pEditEngine, EditEngine, 0 );
303	PIMPEE->Paint( pImpEditView, rRect );	303	PIMPEE->Paint( pImpEditView, rRect, pTargetDevice );
304	}	304	}
305		305
306	void EditView::SetEditEngine( EditEngine* pEditEng )	306	void EditView::SetEditEngine( EditEngine* pEditEng )




	void ShowDDCursor( const Rectangle& rRect );
	void HideDDCursor();

    void ImplDrawHighlightRect( OutputDevice* _pTarget, const Point& rDocPosTopLeft, const Point& rDocPosBottomRight, PolyPolygon* pPolyPoly );

public:
					ImpEditView( EditView* pView, EditEngine* pEng, Window* pWindow );

	sal_Bool		HasSelection() const { return aEditSelection.HasRange(); }

	void			DrawSelection() { DrawSelection( aEditSelection ); }
	void			DrawSelection( EditSelection, Region* pRegion = NULL, OutputDevice* pTargetDevice = NULL );
	Region*			CalcSelectedRegion();

	Window*			GetWindow()	const 			{ return pOutWin; }

	void					FormatDoc();
	void					FormatFullDoc();
	void					UpdateViews( EditView* pCurView = 0 );
	void					Paint( ImpEditView* pView, const Rectangle& rRect, OutputDevice* pTargetDevice = 0, sal_Bool bUseVirtDev = sal_False );
	void					Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aStartPos, sal_Bool bStripOnly = sal_False, short nOrientation = 0 );

	sal_Bool				MouseButtonUp( const MouseEvent& rMouseEvent, EditView* pView );




}


void ImpEditView::DrawSelection( EditSelection aTmpSel, Region* pRegion, OutputDevice* pTargetDevice )
{
    if ( GetSelectionMode() == EE_SELMODE_HIDDEN )
        return;

	if ( pRegion )
		pPolyPoly = new PolyPolygon;

	OutputDevice* pTarget = pTargetDevice ? pTargetDevice : pOutWin;
	sal_Bool bClipRegion = pTarget->IsClipRegion();
	Region aOldRegion = pTarget->GetClipRegion();

	if ( !pRegion )
	{

	    Rectangle aTmpOutArea( aOutArea );
	    if ( aTmpOutArea.GetWidth() > pEditEngine->pImpEditEngine->GetPaperSize().Width() )
		    aTmpOutArea.Right() = aTmpOutArea.Left() + pEditEngine->pImpEditEngine->GetPaperSize().Width();
		pTarget->IntersectClipRegion( aTmpOutArea );

		if ( pOutWin->GetCursor() )
			pOutWin->GetCursor()->Hide();

                Range aLineXPosStartEnd = pEditEngine->pImpEditEngine->GetLineXPosStartEnd( pTmpPortion, pLine );
                aTopLeft.X() = aLineXPosStartEnd.Min();
                aBottomRight.X() = aLineXPosStartEnd.Max();
                ImplDrawHighlightRect( pTarget, aTopLeft, aBottomRight, pPolyPoly );
            }
            else
            {

                    Point aPt1( Min( nX1, nX2 ), aTopLeft.Y() );
                    Point aPt2( Max( nX1, nX2 ), aBottomRight.Y() );

                    ImplDrawHighlightRect( pTarget, aPt1, aPt2, pPolyPoly );

                    nTmpStartIndex = nTmpEndIndex;
                }

			pOutWin->GetCursor()->Show();

		if ( bClipRegion )
			pTarget->SetClipRegion( aOldRegion );
		else
			pTarget->SetClipRegion();
	}
}

void ImpEditView::ImplDrawHighlightRect( OutputDevice* _pTarget, const Point& rDocPosTopLeft, const Point& rDocPosBottomRight, PolyPolygon* pPolyPoly )
{
	if ( rDocPosTopLeft.X() != rDocPosBottomRight.X() )
	{
	    sal_Bool bPixelMode = _pTarget->GetMapMode() == MAP_PIXEL;

        Point aPnt1( GetWindowPos( rDocPosTopLeft ) );
		Point aPnt2( GetWindowPos( rDocPosBottomRight ) );

		if ( !IsVertical() )
		{
			lcl_AllignToPixel( aPnt1, _pTarget, +1, 0 );
			lcl_AllignToPixel( aPnt2, _pTarget, 0, ( bPixelMode ? 0 : -1 ) );
		}
		else
		{
			lcl_AllignToPixel( aPnt1, _pTarget, 0, +1 );
			lcl_AllignToPixel( aPnt2, _pTarget, ( bPixelMode ? 0 : +1 ), 0 );
		}

		Rectangle aRect( aPnt1, aPnt2 );

		}
		else
		{
			Window* pWindow = dynamic_cast< Window* >(_pTarget);

			if(pWindow)
			{
				pWindow->Invert( aRect );
			}
			else
			{
				_pTarget->Push(PUSH_LINECOLOR|PUSH_FILLCOLOR|PUSH_RASTEROP);
				_pTarget->SetLineColor();
				_pTarget->SetFillColor(COL_BLACK);
				_pTarget->SetRasterOp(ROP_INVERT);
				_pTarget->DrawRect(aRect);
				_pTarget->Pop();
			}
		}
	}
}

Lines 87-93 Link Here

(-)editeng/source/outliner/outlvw.cxx (-2 / +2 lines)
87	delete pEditView;	87	delete pEditView;
88	}	88	}
89		89
90	void OutlinerView::Paint( const Rectangle& rRect )	90	void OutlinerView::Paint( const Rectangle& rRect, OutputDevice* pTargetDevice )
91	{	91	{
92	DBG_CHKTHIS(OutlinerView,0);	92	DBG_CHKTHIS(OutlinerView,0);
93		93
Lines 96-102 Link Here
96	if( pOwner->bFirstParaIsEmpty )	96	if( pOwner->bFirstParaIsEmpty )
97	pOwner->Insert( String() );	97	pOwner->Insert( String() );
98		98
99	pEditView->Paint( rRect );	99	pEditView->Paint( rRect, pTargetDevice );
100	}	100	}
101		101
102	sal_Bool OutlinerView::PostKeyEvent( const KeyEvent& rKEvt )	102	sal_Bool OutlinerView::PostKeyEvent( const KeyEvent& rKEvt )

Lines 259-265 Link Here

(-)editeng/inc/editeng/outliner.hxx (-1 / +1 lines)
259		259
260	void Scroll( long nHorzScroll, long nVertScroll );	260	void Scroll( long nHorzScroll, long nVertScroll );
261		261
262	void Paint( const Rectangle& rRect );	262	void Paint( const Rectangle& rRect, OutputDevice* pTargetDevice = 0 );
263	sal_Bool PostKeyEvent( const KeyEvent& rKEvt );	263	sal_Bool PostKeyEvent( const KeyEvent& rKEvt );
264	sal_Bool MouseButtonDown( const MouseEvent& );	264	sal_Bool MouseButtonDown( const MouseEvent& );
265	sal_Bool MouseButtonUp( const MouseEvent& );	265	sal_Bool MouseButtonUp( const MouseEvent& );

Lines 53-58 Link Here

(-)editeng/inc/editeng/editview.hxx (-1 / +2 lines)
53	class SfxStyleSheet;	53	class SfxStyleSheet;
54	class Font;	54	class Font;
55	class FontList;	55	class FontList;
		56	class OutputDevice;
56		57
57	#ifndef _EDITDATA_HXX	58	#ifndef _EDITDATA_HXX
58	#include <editeng/editdata.hxx>	59	#include <editeng/editdata.hxx>
Lines 93-99 Link Here
93	void SetWindow( Window* pWin );	94	void SetWindow( Window* pWin );
94	Window* GetWindow() const;	95	Window* GetWindow() const;
95		96
96	void Paint( const Rectangle& rRect );	97	void Paint( const Rectangle& rRect, OutputDevice* pTargetDevice = 0 );
97	void Invalidate();	98	void Invalidate();
98	Pair Scroll( long nHorzScroll, long nVertScroll, sal_uInt8 nRangeCheck = RGCHK_NEG );	99	Pair Scroll( long nHorzScroll, long nVertScroll, sal_uInt8 nRangeCheck = RGCHK_NEG );
99		100




            return mfDiscreteOne; 
        }

		OverlayManager::OverlayManager(OutputDevice& rOutputDevice)
			OutputDevice& rOutputDevice,
			OverlayManager* pOldOverlayManager)
		:	Scheduler(),
			rmOutputDevice(rOutputDevice),
			maOverlayObjects(),

			    xProperties[0].Value <<= true;
                maViewInformation2D = drawinglayer::geometry::ViewInformation2D(xProperties);
            }

			if(pOldOverlayManager)
			{
				// take over OverlayObjects from given OverlayManager. Copy
				// the vector of pointers
				maOverlayObjects = pOldOverlayManager->maOverlayObjects;
				const sal_uInt32 nSize(maOverlayObjects.size());

				if(nSize)
				{
					for(OverlayObjectVector::iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); aIter++)
					{
						OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
						OverlayObject& rCandidate = **aIter;

						// remove from old and add to new OverlayManager
						pOldOverlayManager->impApplyRemoveActions(rCandidate);
						impApplyAddActions(rCandidate);
					}

					pOldOverlayManager->maOverlayObjects.clear();
				}
			}
		}

		const drawinglayer::geometry::ViewInformation2D OverlayManager::getCurrentViewInformation2D() const

Lines 421-429 Link Here

(-)svx/source/sdr/overlay/overlaymanagerbuffered.cxx (-2 / +1 lines)
421		421
422	OverlayManagerBuffered::OverlayManagerBuffered(	422	OverlayManagerBuffered::OverlayManagerBuffered(
423	OutputDevice& rOutputDevice,	423	OutputDevice& rOutputDevice,
424	OverlayManager* pOldOverlayManager,
425	bool bRefreshWithPreRendering)	424	bool bRefreshWithPreRendering)
426	: OverlayManager(rOutputDevice, pOldOverlayManager),	425	: OverlayManager(rOutputDevice),
427	mbRefreshWithPreRendering(bRefreshWithPreRendering)	426	mbRefreshWithPreRendering(bRefreshWithPreRendering)
428	{	427	{
429	// Init timer	428	// Init timer




		// look for active TextEdit. As long as this cannot be painted to a VDev,
		// it cannot get part of buffering. In that case, output evtl. prerender
		// early and paint text edit to window.
		if(IsTextEdit() && GetSdrPageView())

		if(bTextEditActive)
		{
			static_cast< SdrView* >(this)->TextEditDrawing(rPaintWindow);
		}
			rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());

		// draw Overlay, also to PreRender device if exists
		rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion());
			// is not an easy thing to do, see BegTextEdit and the OutlinerView stuff used...
			if(bTextEditActive)
			{
				ImpTextEditDrawing(rPaintWindow);
			}

		// output PreRendering
		rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
			// This may lead to problems when reading from the screen is slow from the
			// graphics driver/graphiccard combination.
			rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion(), false);
		}
		else
		{
			// draw Overlay, also to PreRender device if exists
			rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion(), true);

			// output PreRendering
			rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
		}
	}
}



////////////////////////////////////////////////////////////////////////////////////////////////////

void SdrPaintView::ImpTextEditDrawing(SdrPaintWindow& rPaintWindow) const
{
	// draw old text edit stuff
	if(IsTextEdit())
	{
		SdrPageView* pPageView = GetTextEditPageView();

		if(pPageView)
		{
			// paint TextEdit directly to the destination OutDev
			const Region& rRedrawRegion = rPaintWindow.GetRedrawRegion();
			const Rectangle aCheckRect(rRedrawRegion.GetBoundRect());
			pPageView->PaintOutlinerView(&rPaintWindow.GetOutputDevice(), aCheckRect);
		}
	}
}

void SdrPaintView::ImpFormLayerDrawing(SdrPaintWindow& rPaintWindow) const
{
	if(mpPageView)




#include "svx/svditer.hxx"
#include <svx/svdogrp.hxx>
#include <svx/svdtypes.hxx>

#include <svx/svdotext.hxx> // fuer PaintOutlinerView
#include <svx/svdoole2.hxx>

// #110094#

	}
}

void SdrPageView::PaintOutlinerView(OutputDevice* pOut, const Rectangle& rRect) const
{
	if (GetView().pTextEditOutliner==NULL) return;
	//const SdrObject* pTextObjTmp=GetView().GetTextEditObject();
	//const SdrTextObj* pText=PTR_CAST(SdrTextObj,pTextObjTmp);
	//FASTBOOL bTextFrame=pText!=NULL && pText->IsTextFrame();
	sal_uIntPtr nViewAnz=GetView().pTextEditOutliner->GetViewCount();
	for (sal_uIntPtr i=0; i<nViewAnz; i++) {
		OutlinerView* pOLV=GetView().pTextEditOutliner->GetView(i);
		if (pOLV->GetWindow()==pOut) {
			GetView().ImpPaintOutlinerView(*pOLV, rRect);
			return;
		}
	}
}

////////////////////////////////////////////////////////////////////////////////////////////////////

void SdrPageView::PrePaint()




//
////////////////////////////////////////////////////////////////////////////////////////////////////

void SdrObjEditView::TextEditDrawing(SdrPaintWindow& rPaintWindow) const
{
	// draw old text edit stuff
	if(IsTextEdit())
	if(pWin)
	{
		const SdrOutliner* pActiveOutliner = GetTextEditOutliner();
		bool bTextFrame(pText && pText->IsTextFrame());
		bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING));
		bool bModifyMerk(pTextEditOutliner->IsModified()); // #43095#
		Rectangle aBlankRect(rOutlView.GetOutputArea());
		aBlankRect.Union(aMinTextEditArea);
		Rectangle aPixRect(pWin->LogicToPixel(aBlankRect));
		aBlankRect.Intersection(rRect);
		rOutlView.GetOutliner()->SetUpdateMode(sal_True); // Bugfix #22596#
		rOutlView.Paint(aBlankRect);

		if(pActiveOutliner)
		{
			const sal_uInt32 nViewAnz(pActiveOutliner->GetViewCount());

			if(nViewAnz)
			{
				const Region& rRedrawRegion = rPaintWindow.GetRedrawRegion();
				const Rectangle aCheckRect(rRedrawRegion.GetBoundRect());

				for(sal_uInt32 i(0); i < nViewAnz; i++) 
				{
					OutlinerView* pOLV = pActiveOutliner->GetView(i);

					if(pOLV->GetWindow() == &rPaintWindow.GetOutputDevice()) 
					{
						ImpPaintOutlinerView(*pOLV, aCheckRect, rPaintWindow.GetTargetOutputDevice());
						return;
					}
				}
			}
		}
	}
}

void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect, OutputDevice& rTargetDevice) const
{
	const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject());
	bool bTextFrame(pText && pText->IsTextFrame());
	bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING));
	bool bModifyMerk(pTextEditOutliner->IsModified()); // #43095#
	Rectangle aBlankRect(rOutlView.GetOutputArea());
	aBlankRect.Union(aMinTextEditArea);
	Rectangle aPixRect(rTargetDevice.LogicToPixel(aBlankRect));
	aBlankRect.Intersection(rRect);
	rOutlView.GetOutliner()->SetUpdateMode(sal_True); // Bugfix #22596#
	rOutlView.Paint(aBlankRect, &rTargetDevice);

	if(!bModifyMerk) 
	{
		// #43095#
		pTextEditOutliner->ClearModifyFlag(); 
	}

	if(bTextFrame && !bFitToSize) 
	{
		aPixRect.Left()--;
		aPixRect.Top()--;
		aPixRect.Right()++;
		aPixRect.Bottom()++;
		sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
			
		{ 
			// xPixRect Begrenzen, wegen Treiberproblem bei zu weit hinausragenden Pixelkoordinaten
			Size aMaxXY(rTargetDevice.GetOutputSizePixel());
			long a(2 * nPixSiz);
			long nMaxX(aMaxXY.Width() + a);
			long nMaxY(aMaxXY.Height() + a);

			if (aPixRect.Left  ()<-a) aPixRect.Left()=-a;
			if (aPixRect.Top   ()<-a) aPixRect.Top ()=-a;
			if (aPixRect.Right ()>nMaxX) aPixRect.Right ()=nMaxX;
			if (aPixRect.Bottom()>nMaxY) aPixRect.Bottom()=nMaxY;
		}

		Rectangle aOuterPix(aPixRect);
		aOuterPix.Left()-=nPixSiz;
		aOuterPix.Top()-=nPixSiz;
		aOuterPix.Right()+=nPixSiz;
		aOuterPix.Bottom()+=nPixSiz;

		bool bMerk(rTargetDevice.IsMapModeEnabled());
		rTargetDevice.EnableMapMode(sal_False);
		PolyPolygon aPolyPoly( 2 );

		svtools::ColorConfig aColorConfig;
		Color aHatchCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
		const Hatch aHatch( HATCH_SINGLE, aHatchCol, 3, 450 );

		aPolyPoly.Insert( aOuterPix );
		aPolyPoly.Insert( aPixRect );
		rTargetDevice.DrawHatch( aPolyPoly, aHatch );

		rTargetDevice.EnableMapMode(bMerk);
	}
		
	rOutlView.ShowCursor();
	}
}

void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView& rOutlView) const





////////////////////////////////////////////////////////////////////////////////////////////////////

void SdrPaintWindow::impCreateOverlayManager()
{
    // When the buffer usage has changed then we have to create a new
    // overlay manager.  Save the current one so that later we can move its
    // overlay objects to the new one.
    sdr::overlay::OverlayManager* pOldOverlayManager = NULL;
    
	if(mbUseBuffer != bUseBuffer)
    {
        mbUseBuffer = bUseBuffer;
        pOldOverlayManager = mpOverlayManager;
        mpOverlayManager = NULL;
    }

	// not yet one created?
	if(!mpOverlayManager)
	{

				// if that refresh itself will use a 2nd vdev to avoid flickering.
				// Also hand over the evtl. existing old OverlayManager; this means to take over 
				// the registered OverlayObjects from it
				mpOverlayManager = new ::sdr::overlay::OverlayManagerBuffered(GetOutputDevice(), true);
			}
			else
			{

				// take place
				// Also hand over the evtl. existing old OverlayManager; this means to take over 
				// the registered OverlayObjects from it
				mpOverlayManager = new ::sdr::overlay::OverlayManager(GetOutputDevice());
			}

			OSL_ENSURE(mpOverlayManager, "SdrPaintWindow::SdrPaintWindow: Could not allocate an overlayManager (!)");

			mpOverlayManager->setStripeLengthPixel(GetPaintView().getOptionsDrawinglayer().GetStripeLength());
		}
	}

	// OverlayObjects are transfered for the evtl. newly created OverlayManager by handing over
	// at construction time
	if(pOldOverlayManager)
    {
        // The old overlay manager is not used anymore and can be (has to be) deleted.
        delete pOldOverlayManager;
    }
}

SdrPaintWindow::SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut)

	if(!mpOverlayManager)
	{
        // Create buffered overlay manager by default.
		const_cast< SdrPaintWindow* >(this)->impCreateOverlayManager();
	}

	return mpOverlayManager;

}

// #i73602# add flag if buffer shall be used
void SdrPaintWindow::DrawOverlay(const Region& rRegion)
{
	// ## force creation of OverlayManager since the first repaint needs to
	// save the background to get a controlled start into overlay mechanism
	impCreateOverlayManager();

	if(mpOverlayManager && !OutputToPrinter())
	{
		if(mpPreRenderDevice)
		{
			mpOverlayManager->completeRedraw(rRegion, &mpPreRenderDevice->GetPreRenderDevice());
		}

Lines 122-128 Link Here

(-)svx/inc/svx/svdedxv.hxx (-1 / +6 lines)
122	// Eine neue OutlinerView auf dem Heap anlegen und alle erforderlichen Parameter setzen.	122	// Eine neue OutlinerView auf dem Heap anlegen und alle erforderlichen Parameter setzen.
123	// pTextEditObj, pTextEditPV und pTextEditOutliner muessen initiallisiert sein.	123	// pTextEditObj, pTextEditPV und pTextEditOutliner muessen initiallisiert sein.
124	OutlinerView* ImpMakeOutlinerView(Window* pWin, sal_Bool bNoPaint, OutlinerView* pGivenView) const;	124	OutlinerView* ImpMakeOutlinerView(Window* pWin, sal_Bool bNoPaint, OutlinerView* pGivenView) const;
125	void ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect) const;	125	void ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect, OutputDevice& rTargetDevice) const;
126	void ImpInvalidateOutlinerView(OutlinerView& rOutlView) const;	126	void ImpInvalidateOutlinerView(OutlinerView& rOutlView) const;
127		127
128	// Feststellen, ob der gesamte Text markiert ist. Liefert auch sal_True wenn	128	// Feststellen, ob der gesamte Text markiert ist. Liefert auch sal_True wenn
Lines 146-151 Link Here
146	virtual ~SdrObjEditView();	146	virtual ~SdrObjEditView();
147		147
148	public:	148	public:
		149	////////////////////////////////////////////////////////////////////////////////////////////////////
		150	// used to call the old ImpPaintOutlinerView. Will be replaced when the
		151	// outliner will be displayed on the overlay in edit mode.
		152	void TextEditDrawing(SdrPaintWindow& rPaintWindow) const;
		153
149	// Actionhandling fuer Macromodus	154	// Actionhandling fuer Macromodus
150	virtual sal_Bool IsAction() const;	155	virtual sal_Bool IsAction() const;
151	virtual void MovAction(const Point& rPnt);	156	virtual void MovAction(const Point& rPnt);

Lines 119-125 Link Here

(-)svx/inc/svx/svdpagv.hxx (-1 lines)
119	*/	119	*/
120	const SdrPageWindow* FindPatchedPageWindow( const OutputDevice& rOutDev ) const;	120	const SdrPageWindow* FindPatchedPageWindow( const OutputDevice& rOutDev ) const;
121		121
122	void PaintOutlinerView(OutputDevice* pOut, const Rectangle& rRect) const;
123	private:	122	private:
124	SVX_DLLPRIVATE SdrPageWindow& CreateNewPageWindowEntry(SdrPaintWindow& rPaintWindow);	123	SVX_DLLPRIVATE SdrPageWindow& CreateNewPageWindowEntry(SdrPaintWindow& rPaintWindow);
125		124




    bool mbUseBuffer;

	// helpers
    void impCreateOverlayManager();
        @param bUseBuffer
            Specifies whether to use the buffered (OverlayManagerBuffered)
            or the unbuffered (OverlayManager) version of the overlay
            manager.  When this values is different from that of the
            previous call then the overlay manager is replaced by the
            specified one.

            The bUseBuffer flag will typically change its value when text
            editing is started or stopped.
    */
    void impCreateOverlayManager(const bool bUseBuffer);

public:
	SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut);
	~SdrPaintWindow();

	// OVERLAYMANAGER
	::sdr::overlay::OverlayManager* GetOverlayManager() const;
	// #i73602# add flag if buffer shall be used
	void DrawOverlay(const Region& rRegion);
	void HideOverlay(const Region& rRegion);

	// calculate visible area and return




            double getDiscreteOne() const;

		public:
			OverlayManager(OutputDevice& rOutputDevice);
			// will be taken over from it. The new one will have added all OverlayObjects
			// while the handed over one will have none
			OverlayManager(
				OutputDevice& rOutputDevice,
				OverlayManager* pOldOverlayManager = 0);
			virtual ~OverlayManager();

			// access to current ViewInformation2D; this call checks and evtl. updates ViewInformation2D




			void ImpSaveBackground(const Region& rRegion, OutputDevice* pPreRenderDevice = 0L);

		public:
			// when handing over another OverlayManager at construction, the OverlayObjects
			// will be taken over from it. The new one will have added all OverlayObjects
			// while the handed over one will have none
			OverlayManagerBuffered(
                OutputDevice& rOutputDevice,
				OverlayManager* pOldOverlayManager = 0,
				bool bRefreshWithPreRendering = false);
			virtual ~OverlayManagerBuffered();


Lines 399-409 Link Here

(-)svx/inc/svx/svdpntv.hxx (-5 lines)
399		399
400	protected:	400	protected:
401	////////////////////////////////////////////////////////////////////////////////////////////////////	401	////////////////////////////////////////////////////////////////////////////////////////////////////
402	// used to call the old PaintOutlinerView at the single PageViews. Will be replaced when the
403	// outliner will be displayed on the overlay in edit mode.
404	void ImpTextEditDrawing(SdrPaintWindow& rPaintWindow) const;
405
406	////////////////////////////////////////////////////////////////////////////////////////////////////
407	// used to paint the form layer after the PreRender device is flushed (painted) to the window.	402	// used to paint the form layer after the PreRender device is flushed (painted) to the window.
408	void ImpFormLayerDrawing(SdrPaintWindow& rPaintWindow) const;	403	void ImpFormLayerDrawing(SdrPaintWindow& rPaintWindow) const;
409		404

Return to issue 118905

Lines 305-311 Link Here

(-)editeng/source/editeng/impedit3.cxx (-25 / +25 lines)
305	aClipRec = pView->pImpEditView->GetWindowPos( aClipRec );	305	aClipRec = pView->pImpEditView->GetWindowPos( aClipRec );
306		306
307	if ( ( pView == pCurView ) )	307	if ( ( pView == pCurView ) )
308	Paint( pView->pImpEditView, aClipRec, sal_True );	308	Paint( pView->pImpEditView, aClipRec, 0, sal_True );
309	else	309	else
310	pView->GetWindow()->Invalidate( aClipRec );	310	pView->GetWindow()->Invalidate( aClipRec );
311	}	311	}
Lines 3589-3595 Link Here
3589	pOutDev->SetFont( aOldFont );	3589	pOutDev->SetFont( aOldFont );
3590	}	3590	}
3591		3591
3592	void ImpEditEngine::Paint( ImpEditView* pView, const Rectangle& rRec, sal_Bool bUseVirtDev )	3592	void ImpEditEngine::Paint( ImpEditView* pView, const Rectangle& rRec, OutputDevice* pTargetDevice, sal_Bool bUseVirtDev )
3593	{	3593	{
3594	DBG_ASSERT( pView, "Keine View - Kein Paint!" );	3594	DBG_ASSERT( pView, "Keine View - Kein Paint!" );
3595	DBG_CHKOBJ( GetEditEnginePtr(), EditEngine, 0 );	3595	DBG_CHKOBJ( GetEditEnginePtr(), EditEngine, 0 );
Lines 3601-3611 Link Here
3601	Rectangle aClipRec( pView->GetOutputArea() );	3601	Rectangle aClipRec( pView->GetOutputArea() );
3602	aClipRec.Intersection( rRec );	3602	aClipRec.Intersection( rRec );
3603		3603
3604	Window* pOutWin = pView->GetWindow();	3604	OutputDevice* pTarget = pTargetDevice ? pTargetDevice : pView->GetWindow();
3605		3605
3606	if ( bUseVirtDev )	3606	if ( bUseVirtDev )
3607	{	3607	{
3608	Rectangle aClipRecPixel( pOutWin->LogicToPixel( aClipRec ) );	3608	Rectangle aClipRecPixel( pTarget->LogicToPixel( aClipRec ) );
3609	if ( !IsVertical() )	3609	if ( !IsVertical() )
3610	{	3610	{
3611	// etwas mehr, falls abgerundet!	3611	// etwas mehr, falls abgerundet!
Lines 3620-3626 Link Here
3620		3620
3621	// Wenn aClipRecPixel > XXXX, dann invalidieren ?!	3621	// Wenn aClipRecPixel > XXXX, dann invalidieren ?!
3622		3622
3623	VirtualDevice* pVDev = GetVirtualDevice( pOutWin->GetMapMode(), pOutWin->GetDrawMode() );	3623	VirtualDevice* pVDev = GetVirtualDevice( pTarget->GetMapMode(), pTarget->GetDrawMode() );
3624	pVDev->SetDigitLanguage( GetRefDevice()->GetDigitLanguage() );	3624	pVDev->SetDigitLanguage( GetRefDevice()->GetDigitLanguage() );
3625		3625
3626	{	3626	{
Lines 3683-3689 Link Here
3683	// da sonst die Zeile darunter auch ausgegeben werden muss:	3683	// da sonst die Zeile darunter auch ausgegeben werden muss:
3684	Rectangle aTmpRec( Point( 0, 0 ), aClipRec.GetSize() );	3684	Rectangle aTmpRec( Point( 0, 0 ), aClipRec.GetSize() );
3685		3685
3686	aClipRec = pOutWin->PixelToLogic( aClipRecPixel );	3686	aClipRec = pTarget->PixelToLogic( aClipRecPixel );
3687	Point aStartPos;	3687	Point aStartPos;
3688	if ( !IsVertical() )	3688	if ( !IsVertical() )
3689	{	3689	{
Lines 3708-3745 Link Here
3708	if ( GetTextRanger() )	3708	if ( GetTextRanger() )
3709	{	3709	{
3710	// Some problems here with push/pop, why?!	3710	// Some problems here with push/pop, why?!
3711	// pOutWin->Push( PUSH_CLIPREGION\|PUSH_MAPMODE );	3711	// pTarget->Push( PUSH_CLIPREGION\|PUSH_MAPMODE );
3712	bClipRegion = pOutWin->IsClipRegion();	3712	bClipRegion = pTarget->IsClipRegion();
3713	aOldRegion = pOutWin->GetClipRegion();	3713	aOldRegion = pTarget->GetClipRegion();
3714	// Wie bekomme ich das Polygon an die richtige Stelle????	3714	// Wie bekomme ich das Polygon an die richtige Stelle????
3715	// Das Polygon bezieht sich auf die View, nicht auf das Window	3715	// Das Polygon bezieht sich auf die View, nicht auf das Window
3716	// => Origin umsetzen...	3716	// => Origin umsetzen...
3717	aOldMapMode = pOutWin->GetMapMode();	3717	aOldMapMode = pTarget->GetMapMode();
3718	Point aOrigin = aOldMapMode.GetOrigin();	3718	Point aOrigin = aOldMapMode.GetOrigin();
3719	Point aViewPos = pView->GetOutputArea().TopLeft();	3719	Point aViewPos = pView->GetOutputArea().TopLeft();
3720	aOrigin.Move( aViewPos.X(), aViewPos.Y() );	3720	aOrigin.Move( aViewPos.X(), aViewPos.Y() );
3721	aClipRec.Move( -aViewPos.X(), -aViewPos.Y() );	3721	aClipRec.Move( -aViewPos.X(), -aViewPos.Y() );
3722	MapMode aNewMapMode( aOldMapMode );	3722	MapMode aNewMapMode( aOldMapMode );
3723	aNewMapMode.SetOrigin( aOrigin );	3723	aNewMapMode.SetOrigin( aOrigin );
3724	pOutWin->SetMapMode( aNewMapMode );	3724	pTarget->SetMapMode( aNewMapMode );
3725	pOutWin->SetClipRegion( Region( GetTextRanger()->GetPolyPolygon() ) );	3725	pTarget->SetClipRegion( Region( GetTextRanger()->GetPolyPolygon() ) );
3726	}	3726	}
3727		3727
3728	pOutWin->DrawOutDev( aClipRec.TopLeft(), aClipRec.GetSize(),	3728	pTarget->DrawOutDev( aClipRec.TopLeft(), aClipRec.GetSize(),
3729	Point(0,0), aClipRec.GetSize(), *pVDev );	3729	Point(0,0), aClipRec.GetSize(), *pVDev );
3730		3730
3731	if ( GetTextRanger() )	3731	if ( GetTextRanger() )
3732	{	3732	{
3733	// pOutWin->Pop();	3733	// pTarget->Pop();
3734	if ( bClipRegion )	3734	if ( bClipRegion )
3735	pOutWin->SetClipRegion( aOldRegion );	3735	pTarget->SetClipRegion( aOldRegion );
3736	else	3736	else
3737	pOutWin->SetClipRegion();	3737	pTarget->SetClipRegion();
3738	pOutWin->SetMapMode( aOldMapMode );	3738	pTarget->SetMapMode( aOldMapMode );
3739	}	3739	}
3740		3740
3741		3741
3742	pView->DrawSelection();	3742	pView->DrawSelection(pView->GetEditSelection(), 0, pTarget);
3743	}	3743	}
3744	else	3744	else
3745	{	3745	{
Lines 3769-3786 Link Here
3769	aClipRec.Right() = nMaxX;	3769	aClipRec.Right() = nMaxX;
3770	}	3770	}
3771		3771
3772	sal_Bool bClipRegion = pOutWin->IsClipRegion();	3772	sal_Bool bClipRegion = pTarget->IsClipRegion();
3773	Region aOldRegion = pOutWin->GetClipRegion();	3773	Region aOldRegion = pTarget->GetClipRegion();
3774	pOutWin->IntersectClipRegion( aClipRec );	3774	pTarget->IntersectClipRegion( aClipRec );
3775		3775
3776	Paint( pOutWin, aClipRec, aStartPos );	3776	Paint( pTarget, aClipRec, aStartPos );
3777		3777
3778	if ( bClipRegion )	3778	if ( bClipRegion )
3779	pOutWin->SetClipRegion( aOldRegion );	3779	pTarget->SetClipRegion( aOldRegion );
3780	else	3780	else
3781	pOutWin->SetClipRegion();	3781	pTarget->SetClipRegion();
3782		3782
3783	pView->DrawSelection();	3783	pView->DrawSelection(pView->GetEditSelection(), 0, pTarget);
3784	}	3784	}
3785		3785
3786	}	3786	}

Lines 131-137 Link Here

(-)editeng/source/editeng/impedit.cxx (-15 / +30 lines)
131	}	131	}
132		132
133		133
134	void ImpEditView::DrawSelection( EditSelection aTmpSel, Region* pRegion )	134	void ImpEditView::DrawSelection( EditSelection aTmpSel, Region* pRegion, OutputDevice* pTargetDevice )
135	{	135	{
136	if ( GetSelectionMode() == EE_SELMODE_HIDDEN )	136	if ( GetSelectionMode() == EE_SELMODE_HIDDEN )
137	return;	137	return;
Lines 148-155 Link Here
148	if ( pRegion )	148	if ( pRegion )
149	pPolyPoly = new PolyPolygon;	149	pPolyPoly = new PolyPolygon;
150		150
151	sal_Bool bClipRegion = pOutWin->IsClipRegion();	151	OutputDevice* pTarget = pTargetDevice ? pTargetDevice : pOutWin;
152	Region aOldRegion = pOutWin->GetClipRegion();	152	sal_Bool bClipRegion = pTarget->IsClipRegion();
		153	Region aOldRegion = pTarget->GetClipRegion();
153		154
154	if ( !pRegion )	155	if ( !pRegion )
155	{	156	{
Lines 166-172 Link Here
166	Rectangle aTmpOutArea( aOutArea );	167	Rectangle aTmpOutArea( aOutArea );
167	if ( aTmpOutArea.GetWidth() > pEditEngine->pImpEditEngine->GetPaperSize().Width() )	168	if ( aTmpOutArea.GetWidth() > pEditEngine->pImpEditEngine->GetPaperSize().Width() )
168	aTmpOutArea.Right() = aTmpOutArea.Left() + pEditEngine->pImpEditEngine->GetPaperSize().Width();	169	aTmpOutArea.Right() = aTmpOutArea.Left() + pEditEngine->pImpEditEngine->GetPaperSize().Width();
169	pOutWin->IntersectClipRegion( aTmpOutArea );	170	pTarget->IntersectClipRegion( aTmpOutArea );
170		171
171	if ( pOutWin->GetCursor() )	172	if ( pOutWin->GetCursor() )
172	pOutWin->GetCursor()->Hide();	173	pOutWin->GetCursor()->Hide();
Lines 246-252 Link Here
246	Range aLineXPosStartEnd = pEditEngine->pImpEditEngine->GetLineXPosStartEnd( pTmpPortion, pLine );	247	Range aLineXPosStartEnd = pEditEngine->pImpEditEngine->GetLineXPosStartEnd( pTmpPortion, pLine );
247	aTopLeft.X() = aLineXPosStartEnd.Min();	248	aTopLeft.X() = aLineXPosStartEnd.Min();
248	aBottomRight.X() = aLineXPosStartEnd.Max();	249	aBottomRight.X() = aLineXPosStartEnd.Max();
249	ImplDrawHighlightRect( pOutWin, aTopLeft, aBottomRight, pPolyPoly );	250	ImplDrawHighlightRect( pTarget, aTopLeft, aBottomRight, pPolyPoly );
250	}	251	}
251	else	252	else
252	{	253	{
Lines 267-273 Link Here
267	Point aPt1( Min( nX1, nX2 ), aTopLeft.Y() );	268	Point aPt1( Min( nX1, nX2 ), aTopLeft.Y() );
268	Point aPt2( Max( nX1, nX2 ), aBottomRight.Y() );	269	Point aPt2( Max( nX1, nX2 ), aBottomRight.Y() );
269		270
270	ImplDrawHighlightRect( pOutWin, aPt1, aPt2, pPolyPoly );	271	ImplDrawHighlightRect( pTarget, aPt1, aPt2, pPolyPoly );
271		272
272	nTmpStartIndex = nTmpEndIndex;	273	nTmpStartIndex = nTmpEndIndex;
273	}	274	}
Lines 287-316 Link Here
287	pOutWin->GetCursor()->Show();	288	pOutWin->GetCursor()->Show();
288		289
289	if ( bClipRegion )	290	if ( bClipRegion )
290	pOutWin->SetClipRegion( aOldRegion );	291	pTarget->SetClipRegion( aOldRegion );
291	else	292	else
292	pOutWin->SetClipRegion();	293	pTarget->SetClipRegion();
293	}	294	}
294	}	295	}
295		296
296	void ImpEditView::ImplDrawHighlightRect( Window* _pOutWin, const Point& rDocPosTopLeft, const Point& rDocPosBottomRight, PolyPolygon* pPolyPoly )	297	void ImpEditView::ImplDrawHighlightRect( OutputDevice* _pTarget, const Point& rDocPosTopLeft, const Point& rDocPosBottomRight, PolyPolygon* pPolyPoly )
297	{	298	{
298	if ( rDocPosTopLeft.X() != rDocPosBottomRight.X() )	299	if ( rDocPosTopLeft.X() != rDocPosBottomRight.X() )
299	{	300	{
300	sal_Bool bPixelMode = _pOutWin->GetMapMode() == MAP_PIXEL;	301	sal_Bool bPixelMode = _pTarget->GetMapMode() == MAP_PIXEL;
301		302
302	Point aPnt1( GetWindowPos( rDocPosTopLeft ) );	303	Point aPnt1( GetWindowPos( rDocPosTopLeft ) );
303	Point aPnt2( GetWindowPos( rDocPosBottomRight ) );	304	Point aPnt2( GetWindowPos( rDocPosBottomRight ) );
304		305
305	if ( !IsVertical() )	306	if ( !IsVertical() )
306	{	307	{
307	lcl_AllignToPixel( aPnt1, _pOutWin, +1, 0 );	308	lcl_AllignToPixel( aPnt1, _pTarget, +1, 0 );
308	lcl_AllignToPixel( aPnt2, _pOutWin, 0, ( bPixelMode ? 0 : -1 ) );	309	lcl_AllignToPixel( aPnt2, _pTarget, 0, ( bPixelMode ? 0 : -1 ) );
309	}	310	}
310	else	311	else
311	{	312	{
312	lcl_AllignToPixel( aPnt1, _pOutWin, 0, +1 );	313	lcl_AllignToPixel( aPnt1, _pTarget, 0, +1 );
313	lcl_AllignToPixel( aPnt2, _pOutWin, ( bPixelMode ? 0 : +1 ), 0 );	314	lcl_AllignToPixel( aPnt2, _pTarget, ( bPixelMode ? 0 : +1 ), 0 );
314	}	315	}
315		316
316	Rectangle aRect( aPnt1, aPnt2 );	317	Rectangle aRect( aPnt1, aPnt2 );
Lines 325-331 Link Here
325	}	326	}
326	else	327	else
327	{	328	{
328	_pOutWin->Invert( aRect );	329	Window* pWindow = dynamic_cast< Window* >(_pTarget);
		330
		331	if(pWindow)
		332	{
		333	pWindow->Invert( aRect );
		334	}
		335	else
		336	{
		337	_pTarget->Push(PUSH_LINECOLOR\|PUSH_FILLCOLOR\|PUSH_RASTEROP);
		338	_pTarget->SetLineColor();
		339	_pTarget->SetFillColor(COL_BLACK);
		340	_pTarget->SetRasterOp(ROP_INVERT);
		341	_pTarget->DrawRect(aRect);
		342	_pTarget->Pop();
		343	}
329	}	344	}
330	}	345	}
331	}	346	}

Lines 912-947 Link Here

(-)svx/source/svdraw/svdpntv.cxx (-44 / +7 lines)
912	// look for active TextEdit. As long as this cannot be painted to a VDev,	912	// look for active TextEdit. As long as this cannot be painted to a VDev,
913	// it cannot get part of buffering. In that case, output evtl. prerender	913	// it cannot get part of buffering. In that case, output evtl. prerender
914	// early and paint text edit to window.	914	// early and paint text edit to window.
915	const bool bTextEditActive(IsTextEdit() && GetTextEditPageView());	915	if(IsTextEdit() && GetSdrPageView())
916
917	if(bTextEditActive)
918	{	916	{
919	// output PreRendering and destroy it so that it is not used for FormLayer	917	static_cast< SdrView* >(this)->TextEditDrawing(rPaintWindow);
920	// or overlay	918	}
921	rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
922		919
923	// draw old text edit stuff before overlay to have it as part of the background	920	// draw Overlay, also to PreRender device if exists
924	// ATM. This will be changed to have the text editing on the overlay, bit it	921	rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion());
925	// is not an easy thing to do, see BegTextEdit and the OutlinerView stuff used...
926	if(bTextEditActive)
927	{
928	ImpTextEditDrawing(rPaintWindow);
929	}
930		922
931	// draw Overlay directly to window. This will save the contents of the window	923	// output PreRendering
932	// in the RedrawRegion to the overlay background buffer, too.	924	rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
933	// This may lead to problems when reading from the screen is slow from the
934	// graphics driver/graphiccard combination.
935	rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion(), false);
936	}
937	else
938	{
939	// draw Overlay, also to PreRender device if exists
940	rPaintWindow.DrawOverlay(rPaintWindow.GetRedrawRegion(), true);
941
942	// output PreRendering
943	rPaintWindow.OutputPreRenderDevice(rPaintWindow.GetRedrawRegion());
944	}
945	}	925	}
946	}	926	}
947		927
Lines 1026-1048 Link Here
1026		1006
1027	////////////////////////////////////////////////////////////////////////////////////////////////////	1007	////////////////////////////////////////////////////////////////////////////////////////////////////
1028		1008
1029	void SdrPaintView::ImpTextEditDrawing(SdrPaintWindow& rPaintWindow) const
1030	{
1031	// draw old text edit stuff
1032	if(IsTextEdit())
1033	{
1034	SdrPageView* pPageView = GetTextEditPageView();
1035
1036	if(pPageView)
1037	{
1038	// paint TextEdit directly to the destination OutDev
1039	const Region& rRedrawRegion = rPaintWindow.GetRedrawRegion();
1040	const Rectangle aCheckRect(rRedrawRegion.GetBoundRect());
1041	pPageView->PaintOutlinerView(&rPaintWindow.GetOutputDevice(), aCheckRect);
1042	}
1043	}
1044	}
1045
1046	void SdrPaintView::ImpFormLayerDrawing(SdrPaintWindow& rPaintWindow) const	1009	void SdrPaintView::ImpFormLayerDrawing(SdrPaintWindow& rPaintWindow) const
1047	{	1010	{
1048	if(mpPageView)	1011	if(mpPageView)

Lines 304-376 Link Here

(-)svx/source/svdraw/svdedxv.cxx (-53 / +79 lines)
304	//	304	//
305	////////////////////////////////////////////////////////////////////////////////////////////////////	305	////////////////////////////////////////////////////////////////////////////////////////////////////
306		306
307	void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect) const	307	void SdrObjEditView::TextEditDrawing(SdrPaintWindow& rPaintWindow) const
308	{	308	{
309	Window* pWin = rOutlView.GetWindow();	309	// draw old text edit stuff
310		310	if(IsTextEdit())
311	if(pWin)
312	{	311	{
313	const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject());	312	const SdrOutliner* pActiveOutliner = GetTextEditOutliner();
314	bool bTextFrame(pText && pText->IsTextFrame());
315	bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING));
316	bool bModifyMerk(pTextEditOutliner->IsModified()); // #43095#
317	Rectangle aBlankRect(rOutlView.GetOutputArea());
318	aBlankRect.Union(aMinTextEditArea);
319	Rectangle aPixRect(pWin->LogicToPixel(aBlankRect));
320	aBlankRect.Intersection(rRect);
321	rOutlView.GetOutliner()->SetUpdateMode(sal_True); // Bugfix #22596#
322	rOutlView.Paint(aBlankRect);
323		313
324	if(!bModifyMerk)	314	if(pActiveOutliner)
325	{	315	{
326	// #43095#	316	const sal_uInt32 nViewAnz(pActiveOutliner->GetViewCount());
327	pTextEditOutliner->ClearModifyFlag();	317
		318	if(nViewAnz)
		319	{
		320	const Region& rRedrawRegion = rPaintWindow.GetRedrawRegion();
		321	const Rectangle aCheckRect(rRedrawRegion.GetBoundRect());
		322
		323	for(sal_uInt32 i(0); i < nViewAnz; i++)
		324	{
		325	OutlinerView* pOLV = pActiveOutliner->GetView(i);
		326
		327	if(pOLV->GetWindow() == &rPaintWindow.GetOutputDevice())
		328	{
		329	ImpPaintOutlinerView(*pOLV, aCheckRect, rPaintWindow.GetTargetOutputDevice());
		330	return;
		331	}
		332	}
		333	}
328	}	334	}
		335	}
		336	}
329		337
330	if(bTextFrame && !bFitToSize)	338	void SdrObjEditView::ImpPaintOutlinerView(OutlinerView& rOutlView, const Rectangle& rRect, OutputDevice& rTargetDevice) const
331	{	339	{
332	aPixRect.Left()--;	340	const SdrTextObj* pText = PTR_CAST(SdrTextObj,GetTextEditObject());
333	aPixRect.Top()--;	341	bool bTextFrame(pText && pText->IsTextFrame());
334	aPixRect.Right()++;	342	bool bFitToSize(0 != (pTextEditOutliner->GetControlWord() & EE_CNTRL_STRETCHING));
335	aPixRect.Bottom()++;	343	bool bModifyMerk(pTextEditOutliner->IsModified()); // #43095#
336	sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);	344	Rectangle aBlankRect(rOutlView.GetOutputArea());
		345	aBlankRect.Union(aMinTextEditArea);
		346	Rectangle aPixRect(rTargetDevice.LogicToPixel(aBlankRect));
		347	aBlankRect.Intersection(rRect);
		348	rOutlView.GetOutliner()->SetUpdateMode(sal_True); // Bugfix #22596#
		349	rOutlView.Paint(aBlankRect, &rTargetDevice);
		350
		351	if(!bModifyMerk)
		352	{
		353	// #43095#
		354	pTextEditOutliner->ClearModifyFlag();
		355	}
		356
		357	if(bTextFrame && !bFitToSize)
		358	{
		359	aPixRect.Left()--;
		360	aPixRect.Top()--;
		361	aPixRect.Right()++;
		362	aPixRect.Bottom()++;
		363	sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
337		364
338	{	365	{
339	// xPixRect Begrenzen, wegen Treiberproblem bei zu weit hinausragenden Pixelkoordinaten	366	// xPixRect Begrenzen, wegen Treiberproblem bei zu weit hinausragenden Pixelkoordinaten
340	Size aMaxXY(pWin->GetOutputSizePixel());	367	Size aMaxXY(rTargetDevice.GetOutputSizePixel());
341	long a(2 * nPixSiz);	368	long a(2 * nPixSiz);
342	long nMaxX(aMaxXY.Width() + a);	369	long nMaxX(aMaxXY.Width() + a);
343	long nMaxY(aMaxXY.Height() + a);	370	long nMaxY(aMaxXY.Height() + a);
344		371
345	if (aPixRect.Left ()<-a) aPixRect.Left()=-a;	372	if (aPixRect.Left ()<-a) aPixRect.Left()=-a;
346	if (aPixRect.Top ()<-a) aPixRect.Top ()=-a;	373	if (aPixRect.Top ()<-a) aPixRect.Top ()=-a;
347	if (aPixRect.Right ()>nMaxX) aPixRect.Right ()=nMaxX;	374	if (aPixRect.Right ()>nMaxX) aPixRect.Right ()=nMaxX;
348	if (aPixRect.Bottom()>nMaxY) aPixRect.Bottom()=nMaxY;	375	if (aPixRect.Bottom()>nMaxY) aPixRect.Bottom()=nMaxY;
349	}	376	}
350		377
351	Rectangle aOuterPix(aPixRect);	378	Rectangle aOuterPix(aPixRect);
352	aOuterPix.Left()-=nPixSiz;	379	aOuterPix.Left()-=nPixSiz;
353	aOuterPix.Top()-=nPixSiz;	380	aOuterPix.Top()-=nPixSiz;
354	aOuterPix.Right()+=nPixSiz;	381	aOuterPix.Right()+=nPixSiz;
355	aOuterPix.Bottom()+=nPixSiz;	382	aOuterPix.Bottom()+=nPixSiz;
356		383
357	bool bMerk(pWin->IsMapModeEnabled());	384	bool bMerk(rTargetDevice.IsMapModeEnabled());
358	pWin->EnableMapMode(sal_False);	385	rTargetDevice.EnableMapMode(sal_False);
359	PolyPolygon aPolyPoly( 2 );	386	PolyPolygon aPolyPoly( 2 );
360		387
361	svtools::ColorConfig aColorConfig;	388	svtools::ColorConfig aColorConfig;
362	Color aHatchCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );	389	Color aHatchCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
363	const Hatch aHatch( HATCH_SINGLE, aHatchCol, 3, 450 );	390	const Hatch aHatch( HATCH_SINGLE, aHatchCol, 3, 450 );
364		391
365	aPolyPoly.Insert( aOuterPix );	392	aPolyPoly.Insert( aOuterPix );
366	aPolyPoly.Insert( aPixRect );	393	aPolyPoly.Insert( aPixRect );
367	pWin->DrawHatch( aPolyPoly, aHatch );	394	rTargetDevice.DrawHatch( aPolyPoly, aHatch );
368		395
369	pWin->EnableMapMode(bMerk);	396	rTargetDevice.EnableMapMode(bMerk);
370	}	397	}
371		398
372	rOutlView.ShowCursor();	399	rOutlView.ShowCursor();
373	}
374	}	400	}
375		401
376	void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView& rOutlView) const	402	void SdrObjEditView::ImpInvalidateOutlinerView(OutlinerView& rOutlView) const

Lines 104-123 Link Here

(-)svx/source/svdraw/sdrpaintwindow.cxx (-27 / +7 lines)
104		104
105	////////////////////////////////////////////////////////////////////////////////////////////////////	105	////////////////////////////////////////////////////////////////////////////////////////////////////
106		106
107	void SdrPaintWindow::impCreateOverlayManager(const bool bUseBuffer)	107	void SdrPaintWindow::impCreateOverlayManager()
108	{	108	{
109	// When the buffer usage has changed then we have to create a new
110	// overlay manager. Save the current one so that later we can move its
111	// overlay objects to the new one.
112	sdr::overlay::OverlayManager* pOldOverlayManager = NULL;
113
114	if(mbUseBuffer != bUseBuffer)
115	{
116	mbUseBuffer = bUseBuffer;
117	pOldOverlayManager = mpOverlayManager;
118	mpOverlayManager = NULL;
119	}
120
121	// not yet one created?	109	// not yet one created?
122	if(!mpOverlayManager)	110	if(!mpOverlayManager)
123	{	111	{
Lines 132-138 Link Here
132	// if that refresh itself will use a 2nd vdev to avoid flickering.	120	// if that refresh itself will use a 2nd vdev to avoid flickering.
133	// Also hand over the evtl. existing old OverlayManager; this means to take over	121	// Also hand over the evtl. existing old OverlayManager; this means to take over
134	// the registered OverlayObjects from it	122	// the registered OverlayObjects from it
135	mpOverlayManager = new ::sdr::overlay::OverlayManagerBuffered(GetOutputDevice(), pOldOverlayManager, true);	123	mpOverlayManager = new ::sdr::overlay::OverlayManagerBuffered(GetOutputDevice(), true);
136	}	124	}
137	else	125	else
138	{	126	{
Lines 140-146 Link Here
140	// take place	128	// take place
141	// Also hand over the evtl. existing old OverlayManager; this means to take over	129	// Also hand over the evtl. existing old OverlayManager; this means to take over
142	// the registered OverlayObjects from it	130	// the registered OverlayObjects from it
143	mpOverlayManager = new ::sdr::overlay::OverlayManager(GetOutputDevice(), pOldOverlayManager);	131	mpOverlayManager = new ::sdr::overlay::OverlayManager(GetOutputDevice());
144	}	132	}
145		133
146	OSL_ENSURE(mpOverlayManager, "SdrPaintWindow::SdrPaintWindow: Could not allocate an overlayManager (!)");	134	OSL_ENSURE(mpOverlayManager, "SdrPaintWindow::SdrPaintWindow: Could not allocate an overlayManager (!)");
Lines 166-179 Link Here
166	mpOverlayManager->setStripeLengthPixel(GetPaintView().getOptionsDrawinglayer().GetStripeLength());	154	mpOverlayManager->setStripeLengthPixel(GetPaintView().getOptionsDrawinglayer().GetStripeLength());
167	}	155	}
168	}	156	}
169
170	// OverlayObjects are transfered for the evtl. newly created OverlayManager by handing over
171	// at construction time
172	if(pOldOverlayManager)
173	{
174	// The old overlay manager is not used anymore and can be (has to be) deleted.
175	delete pOldOverlayManager;
176	}
177	}	157	}
178		158
179	SdrPaintWindow::SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut)	159	SdrPaintWindow::SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut)
Lines 202-208 Link Here
202	if(!mpOverlayManager)	182	if(!mpOverlayManager)
203	{	183	{
204	// Create buffered overlay manager by default.	184	// Create buffered overlay manager by default.
205	const_cast< SdrPaintWindow* >(this)->impCreateOverlayManager(true);	185	const_cast< SdrPaintWindow* >(this)->impCreateOverlayManager();
206	}	186	}
207		187
208	return mpOverlayManager;	188	return mpOverlayManager;
Lines 264-278 Link Here
264	}	244	}
265		245
266	// #i73602# add flag if buffer shall be used	246	// #i73602# add flag if buffer shall be used
267	void SdrPaintWindow::DrawOverlay(const Region& rRegion, bool bUseBuffer)	247	void SdrPaintWindow::DrawOverlay(const Region& rRegion)
268	{	248	{
269	// ## force creation of OverlayManager since the first repaint needs to	249	// ## force creation of OverlayManager since the first repaint needs to
270	// save the background to get a controlled start into overlay mechanism	250	// save the background to get a controlled start into overlay mechanism
271	impCreateOverlayManager(bUseBuffer);	251	impCreateOverlayManager();
272		252
273	if(mpOverlayManager && !OutputToPrinter())	253	if(mpOverlayManager && !OutputToPrinter())
274	{	254	{
275	if(mpPreRenderDevice && bUseBuffer)	255	if(mpPreRenderDevice)
276	{	256	{
277	mpOverlayManager->completeRedraw(rRegion, &mpPreRenderDevice->GetPreRenderDevice());	257	mpOverlayManager->completeRedraw(rRegion, &mpPreRenderDevice->GetPreRenderDevice());
278	}	258	}

Lines 261-267 Link Here

(-)editeng/source/editeng/impedit.hxx (-3 / +3 lines)
261	void ShowDDCursor( const Rectangle& rRect );	261	void ShowDDCursor( const Rectangle& rRect );
262	void HideDDCursor();	262	void HideDDCursor();
263		263
264	void ImplDrawHighlightRect( Window* pOutWin, const Point& rDocPosTopLeft, const Point& rDocPosBottomRight, PolyPolygon* pPolyPoly );	264	void ImplDrawHighlightRect( OutputDevice* _pTarget, const Point& rDocPosTopLeft, const Point& rDocPosBottomRight, PolyPolygon* pPolyPoly );
265		265
266	public:	266	public:
267	ImpEditView( EditView* pView, EditEngine* pEng, Window* pWindow );	267	ImpEditView( EditView* pView, EditEngine* pEng, Window* pWindow );
Lines 309-315 Link Here
309	sal_Bool HasSelection() const { return aEditSelection.HasRange(); }	309	sal_Bool HasSelection() const { return aEditSelection.HasRange(); }
310		310
311	void DrawSelection() { DrawSelection( aEditSelection ); }	311	void DrawSelection() { DrawSelection( aEditSelection ); }
312	void DrawSelection( EditSelection, Region* pRegion = NULL );	312	void DrawSelection( EditSelection, Region* pRegion = NULL, OutputDevice* pTargetDevice = NULL );
313	Region* CalcSelectedRegion();	313	Region* CalcSelectedRegion();
314		314
315	Window* GetWindow() const { return pOutWin; }	315	Window* GetWindow() const { return pOutWin; }
Lines 749-755 Link Here
749	void FormatDoc();	749	void FormatDoc();
750	void FormatFullDoc();	750	void FormatFullDoc();
751	void UpdateViews( EditView* pCurView = 0 );	751	void UpdateViews( EditView* pCurView = 0 );
752	void Paint( ImpEditView* pView, const Rectangle& rRect, sal_Bool bUseVirtDev = sal_False );	752	void Paint( ImpEditView* pView, const Rectangle& rRect, OutputDevice* pTargetDevice = 0, sal_Bool bUseVirtDev = sal_False );
753	void Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aStartPos, sal_Bool bStripOnly = sal_False, short nOrientation = 0 );	753	void Paint( OutputDevice* pOutDev, Rectangle aClipRec, Point aStartPos, sal_Bool bStripOnly = sal_False, short nOrientation = 0 );
754		754
755	sal_Bool MouseButtonUp( const MouseEvent& rMouseEvent, EditView* pView );	755	sal_Bool MouseButtonUp( const MouseEvent& rMouseEvent, EditView* pView );

Lines 123-131 Link Here

(-)svx/source/sdr/overlay/overlaymanager.cxx (-26 / +1 lines)
123	return mfDiscreteOne;	123	return mfDiscreteOne;
124	}	124	}
125		125
126	OverlayManager::OverlayManager(	126	OverlayManager::OverlayManager(OutputDevice& rOutputDevice)
127	OutputDevice& rOutputDevice,
128	OverlayManager* pOldOverlayManager)
129	: Scheduler(),	127	: Scheduler(),
130	rmOutputDevice(rOutputDevice),	128	rmOutputDevice(rOutputDevice),
131	maOverlayObjects(),	129	maOverlayObjects(),
Lines 148-176 Link Here
148	xProperties[0].Value <<= true;	146	xProperties[0].Value <<= true;
149	maViewInformation2D = drawinglayer::geometry::ViewInformation2D(xProperties);	147	maViewInformation2D = drawinglayer::geometry::ViewInformation2D(xProperties);
150	}	148	}
151
152	if(pOldOverlayManager)
153	{
154	// take over OverlayObjects from given OverlayManager. Copy
155	// the vector of pointers
156	maOverlayObjects = pOldOverlayManager->maOverlayObjects;
157	const sal_uInt32 nSize(maOverlayObjects.size());
158
159	if(nSize)
160	{
161	for(OverlayObjectVector::iterator aIter(maOverlayObjects.begin()); aIter != maOverlayObjects.end(); aIter++)
162	{
163	OSL_ENSURE(*aIter, "Corrupted OverlayObject List (!)");
164	OverlayObject& rCandidate = **aIter;
165
166	// remove from old and add to new OverlayManager
167	pOldOverlayManager->impApplyRemoveActions(rCandidate);
168	impApplyAddActions(rCandidate);
169	}
170
171	pOldOverlayManager->maOverlayObjects.clear();
172	}
173	}
174	}	149	}
175		150
176	const drawinglayer::geometry::ViewInformation2D OverlayManager::getCurrentViewInformation2D() const	151	const drawinglayer::geometry::ViewInformation2D OverlayManager::getCurrentViewInformation2D() const

Lines 46-53 Link Here

(-)svx/source/svdraw/svdpagv.cxx (-18 lines)
46	#include "svx/svditer.hxx"	46	#include "svx/svditer.hxx"
47	#include <svx/svdogrp.hxx>	47	#include <svx/svdogrp.hxx>
48	#include <svx/svdtypes.hxx>	48	#include <svx/svdtypes.hxx>
49
50	#include <svx/svdotext.hxx> // fuer PaintOutlinerView
51	#include <svx/svdoole2.hxx>	49	#include <svx/svdoole2.hxx>
52		50
53	// #110094#	51	// #110094#
Lines 321-342 Link Here
321	}	319	}
322	}	320	}
323		321
324	void SdrPageView::PaintOutlinerView(OutputDevice* pOut, const Rectangle& rRect) const
325	{
326	if (GetView().pTextEditOutliner==NULL) return;
327	//const SdrObject* pTextObjTmp=GetView().GetTextEditObject();
328	//const SdrTextObj* pText=PTR_CAST(SdrTextObj,pTextObjTmp);
329	//FASTBOOL bTextFrame=pText!=NULL && pText->IsTextFrame();
330	sal_uIntPtr nViewAnz=GetView().pTextEditOutliner->GetViewCount();
331	for (sal_uIntPtr i=0; i<nViewAnz; i++) {
332	OutlinerView* pOLV=GetView().pTextEditOutliner->GetView(i);
333	if (pOLV->GetWindow()==pOut) {
334	GetView().ImpPaintOutlinerView(*pOLV, rRect);
335	return;
336	}
337	}
338	}
339
340	////////////////////////////////////////////////////////////////////////////////////////////////////	322	////////////////////////////////////////////////////////////////////////////////////////////////////
341		323
342	void SdrPageView::PrePaint()	324	void SdrPageView::PrePaint()

Lines 94-112 Link Here

(-)svx/inc/svx/sdrpaintwindow.hxx (-13 / +2 lines)
94	bool mbUseBuffer;	94	bool mbUseBuffer;
95		95
96	// helpers	96	// helpers
97	/** Create mpOverlayManager member on demand.	97	void impCreateOverlayManager();
98	@param bUseBuffer
99	Specifies whether to use the buffered (OverlayManagerBuffered)
100	or the unbuffered (OverlayManager) version of the overlay
101	manager. When this values is different from that of the
102	previous call then the overlay manager is replaced by the
103	specified one.
104		98
105	The bUseBuffer flag will typically change its value when text
106	editing is started or stopped.
107	*/
108	void impCreateOverlayManager(const bool bUseBuffer);
109
110	public:	99	public:
111	SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut);	100	SdrPaintWindow(SdrPaintView& rNewPaintView, OutputDevice& rOut);
112	~SdrPaintWindow();	101	~SdrPaintWindow();
Lines 118-124 Link Here
118	// OVERLAYMANAGER	107	// OVERLAYMANAGER
119	::sdr::overlay::OverlayManager* GetOverlayManager() const;	108	::sdr::overlay::OverlayManager* GetOverlayManager() const;
120	// #i73602# add flag if buffer shall be used	109	// #i73602# add flag if buffer shall be used
121	void DrawOverlay(const Region& rRegion, bool bUseBuffer);	110	void DrawOverlay(const Region& rRegion);
122	void HideOverlay(const Region& rRegion);	111	void HideOverlay(const Region& rRegion);
123		112
124	// calculate visible area and return	113	// calculate visible area and return

Lines 88-99 Link Here

(-)svx/inc/svx/sdr/overlay/overlaymanager.hxx (-6 / +1 lines)
88	double getDiscreteOne() const;	88	double getDiscreteOne() const;
89		89
90	public:	90	public:
91	// when handing over another OverlayManager at construction, the OverlayObjects	91	OverlayManager(OutputDevice& rOutputDevice);
92	// will be taken over from it. The new one will have added all OverlayObjects
93	// while the handed over one will have none
94	OverlayManager(
95	OutputDevice& rOutputDevice,
96	OverlayManager* pOldOverlayManager = 0);
97	virtual ~OverlayManager();	92	virtual ~OverlayManager();
98		93
99	// access to current ViewInformation2D; this call checks and evtl. updates ViewInformation2D	94	// access to current ViewInformation2D; this call checks and evtl. updates ViewInformation2D

Lines 71-82 Link Here

(-)svx/inc/svx/sdr/overlay/overlaymanagerbuffered.hxx (-5 / +1 lines)
71	void ImpSaveBackground(const Region& rRegion, OutputDevice* pPreRenderDevice = 0L);	71	void ImpSaveBackground(const Region& rRegion, OutputDevice* pPreRenderDevice = 0L);
72		72
73	public:	73	public:
74	// when handing over another OverlayManager at construction, the OverlayObjects
75	// will be taken over from it. The new one will have added all OverlayObjects
76	// while the handed over one will have none
77	OverlayManagerBuffered(	74	OverlayManagerBuffered(
78	OutputDevice& rOutputDevice,	75	OutputDevice& rOutputDevice,
79	OverlayManager* pOldOverlayManager = 0,
80	bool bRefreshWithPreRendering = false);	76	bool bRefreshWithPreRendering = false);
81	virtual ~OverlayManagerBuffered();	77	virtual ~OverlayManagerBuffered();
82		78