text: /**************************************************************
   * 
   * 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/sdrpagewindow.hxx>
  #include <com/sun/star/awt/XWindow.hpp>
  #include <com/sun/star/beans/XPropertySet.hpp>
  #include <com/sun/star/awt/PosSize.hpp>
  #include <com/sun/star/util/XModeChangeBroadcaster.hpp>
  #include <comphelper/processfactory.hxx>
  #include <vcl/svapp.hxx>
  #include <toolkit/helper/vclunohelper.hxx>
  #include <svx/svdouno.hxx>
  #include <svx/svdpage.hxx>
  #include <svx/svdview.hxx>
  #include <svx/svdpagv.hxx>
  #include <svx/sdrpaintwindow.hxx>
  #include <svx/sdr/contact/objectcontactofpageview.hxx>
  #include <svx/sdr/contact/displayinfo.hxx>
  #include <vos/mutex.hxx>
  #include <svx/fmview.hxx>
  #include <basegfx/matrix/b2dhommatrix.hxx>
  
  ////////////////////////////////////////////////////////////////////////////////////////////////////
  
  using namespace ::rtl;
  using namespace ::com::sun::star;
  
  ////////////////////////////////////////////////////////////////////////////////////////////////////
  
  ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlContainer > SdrPageWindow::GetControlContainer( bool _bCreateIfNecessary ) const
  {
      if ( !mxControlContainer.is() && _bCreateIfNecessary )
  	{
  		SdrView& rView = GetPageView().GetView();
  
          const SdrPaintWindow& rPaintWindow( GetOriginalPaintWindow() ? *GetOriginalPaintWindow() : GetPaintWindow() );
  		if ( rPaintWindow.OutputToWindow() && !rView.IsPrintPreview() )
  		{
  			Window& rWindow = dynamic_cast< Window& >( rPaintWindow.GetOutputDevice() );
              const_cast< SdrPageWindow* >( this )->mxControlContainer = VCLUnoHelper::CreateControlContainer( &rWindow );
  
  			// #100394# xC->setVisible triggers window->Show() and this has
  			// problems when the view is not completely constructed which may
  			// happen when loading. This leads to accessibility broadcasts which
  			// throw asserts due to the not finished view. All this chan be avoided
  			// since xC->setVisible is here called only for the side effect in
  			// UnoControlContainer::setVisible(...) which calls createPeer(...).
  			// This will now be called directly from here.
  
  			// UnoContainerModel erzeugen
  			// uno::Reference< awt::XWindow > xC(mxControlContainer, uno::UNO_QUERY);
  			// CreateControlContainer() is only used from
  			// , thus it seems not necessary to make
  			// it visible her at all.
  			// #58917# Das Show darf nicht am VCL-Fenster landen, weil dann Assertion vom SFX
  			// sal_Bool bVis = pWindow->IsVisible();
  			// xC->setVisible(sal_True);
  			// if ( !bVis )
  			// 	pWindow->Hide();
  			//	if( !mxContext.is() && bVisible )
  			//		// Es ist ein TopWindow, also automatisch anzeigen
  			//		createPeer( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > (), ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > () );
  
  			uno::Reference< awt::XControl > xControl(mxControlContainer, uno::UNO_QUERY);
  			if(xControl.is())
  			{
  				uno::Reference< uno::XInterface > xContext = xControl->getContext();
  				if(!xContext.is())
  				{
  					xControl->createPeer( ::com::sun::star::uno::Reference< ::com::sun::star::awt::XToolkit > (),
  						::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > () );
  				}
  			}
  		}
  		else
  		{
  			// Printer und VirtualDevice, bzw. kein OutDev
  			uno::Reference< lang::XMultiServiceFactory > xFactory( ::comphelper::getProcessServiceFactory() );
  			if( xFactory.is() )
  			{
                  const_cast< SdrPageWindow* >( this )->mxControlContainer = uno::Reference< awt::XControlContainer >(xFactory->createInstance(rtl::OUString::createFromAscii("com.sun.star.awt.UnoControlContainer")), uno::UNO_QUERY);
  				uno::Reference< awt::XControlModel > xModel(xFactory->createInstance(rtl::OUString::createFromAscii("com.sun.star.awt.UnoControlContainerModel")), uno::UNO_QUERY);
  				uno::Reference< awt::XControl > xControl(mxControlContainer, uno::UNO_QUERY);
  				if (xControl.is())
  					xControl->setModel(xModel);
  
  				OutputDevice& rOutDev = rPaintWindow.GetOutputDevice();
  				Point aPosPix = rOutDev.GetMapMode().GetOrigin();
  				Size aSizePix = rOutDev.GetOutputSizePixel();
  
  				uno::Reference< awt::XWindow > xContComp(mxControlContainer, uno::UNO_QUERY);
  				if( xContComp.is() )
  					xContComp->setPosSize(aPosPix.X(), aPosPix.Y(), aSizePix.Width(), aSizePix.Height(), awt::PosSize::POSSIZE);
  			}
  		}
  
          FmFormView* pViewAsFormView = dynamic_cast< FmFormView* >( &rView );
          if ( pViewAsFormView )
  		    pViewAsFormView->InsertControlContainer(mxControlContainer);
  	}
      return mxControlContainer;
  }
  
  SdrPageWindow::SdrPageWindow(SdrPageView& rPageView, SdrPaintWindow& rPaintWindow)
  :	mpObjectContact(0L),
  	mrPageView(rPageView),
  	mpPaintWindow(&rPaintWindow),
      mpOriginalPaintWindow(NULL)
  {
  }
  
  SdrPageWindow::~SdrPageWindow()
  {
  	// #110094#, #i26631#
  	ResetObjectContact();
  
  	if (mxControlContainer.is())
  	{
  		SdrView& rView = GetPageView().GetView();
  
  		// notify derived views
          FmFormView* pViewAsFormView = dynamic_cast< FmFormView* >( &rView );
          if ( pViewAsFormView )
  		    pViewAsFormView->RemoveControlContainer(mxControlContainer);
  
  		// dispose the control container
  		uno::Reference< lang::XComponent > xComponent(mxControlContainer, uno::UNO_QUERY);
  		xComponent->dispose();
  	}
  }
  
  // #110094# ObjectContact section
  sdr::contact::ObjectContact* SdrPageWindow::CreateViewSpecificObjectContact()
  {
  	return new sdr::contact::ObjectContactOfPageView(*this);
  }
  
  // OVERLAYMANAGER
  ::sdr::overlay::OverlayManager* SdrPageWindow::GetOverlayManager() const 
  { 
  	return GetPaintWindow().GetOverlayManager(); 
  }
  
  void SdrPageWindow::patchPaintWindow(SdrPaintWindow& rPaintWindow)
  {
      mpOriginalPaintWindow = mpPaintWindow;
      mpPaintWindow = &rPaintWindow;
  }
  
  void SdrPageWindow::unpatchPaintWindow()
  {
      DBG_ASSERT(mpOriginalPaintWindow, "SdrPageWindow::unpatchPaintWindow: paint window not patched!" );
      if ( mpOriginalPaintWindow )
      {
          mpPaintWindow = mpOriginalPaintWindow;
          mpOriginalPaintWindow = NULL;
      }
  }
  
  void SdrPageWindow::PrePaint()
  {
  	// give OC the chance to do ProcessDisplay preparations
  	if(HasObjectContact())
  	{
  		GetObjectContact().PrepareProcessDisplay();
  	}
  }
  
  void SdrPageWindow::PostPaint()
  {
  }
  
  void SdrPageWindow::PrepareRedraw(const Region& rReg)
  {
  	// evtl. give OC the chance to do ProcessDisplay preparations
  	if(HasObjectContact())
  	{
  		GetObjectContact().PrepareProcessDisplay();
  	}
  
  	// remember eventually changed RedrawArea at PaintWindow for usage with
  	// overlay and PreRenderDevice stuff
  	GetPaintWindow().SetRedrawRegion(rReg);
  }
  
  //////////////////////////////////////////////////////////////////////////////
  // clip test
  #ifdef CLIPPER_TEST
  #include <svx/svdopath.hxx>
  #include <basegfx/polygon/b2dpolygon.hxx>
  #include <vcl/salbtype.hxx>		// FRound
  #include <basegfx/polygon/b2dpolygoncutandtouch.hxx>
  #include <basegfx/polygon/b2dpolypolygontools.hxx>
  #include <basegfx/polygon/b2dpolygontools.hxx>
  #include <basegfx/polygon/b2dpolygonclipper.hxx>
  
  // for ::std::sort
  #include <algorithm>
  
  namespace
  {
  	void impPaintStrokePolygon(const basegfx::B2DPolygon& rCandidate, OutputDevice& rOutDev, Color aColor)
  	{
  		basegfx::B2DPolygon aCandidate(rCandidate);
  
  		if(aCandidate.areControlPointsUsed())
  		{
  			aCandidate = basegfx::tools::adaptiveSubdivideByAngle(rCandidate);
  		}
  
  		if(aCandidate.count())
  		{
  			const sal_uInt32 nLoopCount(aCandidate.isClosed() ? aCandidate.count() : aCandidate.count() - 1L);
  			rOutDev.SetFillColor();
  			rOutDev.SetLineColor(aColor);
  
  			for(sal_uInt32 a(0L); a < nLoopCount; a++)
  			{
  				const basegfx::B2DPoint aBStart(aCandidate.getB2DPoint(a));
  				const basegfx::B2DPoint aBEnd(aCandidate.getB2DPoint((a + 1) % aCandidate.count()));
  				const Point aStart(FRound(aBStart.getX()), FRound(aBStart.getY()));
  				const Point aEnd(FRound(aBEnd.getX()), FRound(aBEnd.getY()));
  				rOutDev.DrawLine(aStart, aEnd);
  			}
  		}
  	}
  
  	void impTryTest(const SdrPageView& rPageView, OutputDevice& rOutDev)
  	{
  		if(rPageView.GetPage() && rPageView.GetPage()->GetObjCount() >= 2L)
  		{
  			SdrPage* pPage = rPageView.GetPage();
  			SdrObject* pObjA = pPage->GetObj(0L);
  
  			if(pObjA && pObjA->ISA(SdrPathObj))
  			{
  				basegfx::B2DPolyPolygon aPolyA(((SdrPathObj*)pObjA)->GetPathPoly());
  				aPolyA = basegfx::tools::correctOrientations(aPolyA);
  
  				basegfx::B2DPolyPolygon aPolyB;
  
  				for(sal_uInt32 a(1L); a < rPageView.GetPage()->GetObjCount(); a++)
  				{
  					SdrObject* pObjB = pPage->GetObj(a);
  
  					if(pObjB && pObjB->ISA(SdrPathObj))
  					{
  						basegfx::B2DPolyPolygon aCandidate(((SdrPathObj*)pObjB)->GetPathPoly());
  						aCandidate = basegfx::tools::correctOrientations(aCandidate);
  						aPolyB.append(aCandidate);
  					}
  				}
  
  				if(aPolyA.count() && aPolyA.isClosed() && aPolyB.count())
  				{
  					// poly A is the clipregion, clip poly b against it. Algo depends on
  					// poly b being closed.
  					basegfx::B2DPolyPolygon aResult(basegfx::tools::clipPolyPolygonOnPolyPolygon(aPolyB, aPolyA));
  
  					for(sal_uInt32 a(0L); a < aResult.count(); a++)
  					{
  						Color aColor(rand()%255, rand()%255, rand()%255);
  						impPaintStrokePolygon(aResult.getB2DPolygon(a), rOutDev, aColor);
  					}
  
  					bool bBla = true;
  				}
  			}
  		}
  	}
  } // end of anonymous namespace
  #endif // CLIPPER_TEST
  
  //////////////////////////////////////////////////////////////////////////////
  
  void SdrPageWindow::RedrawAll(sdr::contact::ViewObjectContactRedirector* pRedirector) const
  {
  	// set Redirector
  	GetObjectContact().SetViewObjectContactRedirector(pRedirector);
  
  	// set PaintingPageView
  	const SdrView& rView = mrPageView.GetView();
  	SdrModel& rModel = *((SdrModel*)rView.GetModel());
  
  	// get to be processed layers
  	const sal_Bool bPrinter(GetPaintWindow().OutputToPrinter());
  	SetOfByte aProcessLayers = bPrinter ? mrPageView.GetPrintableLayers() : mrPageView.GetVisibleLayers();
  
  	// create PaintInfoRec, #114359# use Rectangle only temporarily
  	const Region& rRegion = GetPaintWindow().GetRedrawRegion();
  
  	// create processing data
  	sdr::contact::DisplayInfo aDisplayInfo;
  
  	// Draw all layers. do NOT draw form layer from CompleteRedraw, this is done separate
  	// as a single layer paint
  	const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin();
  	const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName(), sal_False);
  	aProcessLayers.Clear(nControlLayerId);
  
  	// still something to paint?
  	if(!aProcessLayers.IsEmpty())
  	{
  		aDisplayInfo.SetProcessLayers(aProcessLayers);
  
  		// Set region as redraw area
  		aDisplayInfo.SetRedrawArea(rRegion);
  
  		// Draw/Impress
  		aDisplayInfo.SetPageProcessingActive(rView.IsPagePaintingAllowed()); // #i72889#
  
  		// paint page
  		GetObjectContact().ProcessDisplay(aDisplayInfo);
  	}
  
  	// reset redirector
  	GetObjectContact().SetViewObjectContactRedirector(0L);
  
  	// LineClip test
  #ifdef CLIPPER_TEST
  	if(true)
  	{
  		impTryTest(GetPageView(), GetPaintWindow().GetOutputDevice());
  	}
  #endif // CLIPPER_TEST
  }
  
  void SdrPageWindow::RedrawLayer(const SdrLayerID* pId, sdr::contact::ViewObjectContactRedirector* pRedirector) const
  {
  	// set redirector
  	GetObjectContact().SetViewObjectContactRedirector(pRedirector);
  
  	// set PaintingPageView
  	const SdrView& rView = mrPageView.GetView();
  	SdrModel& rModel = *((SdrModel*)rView.GetModel());
  
  	// get the layers to process
  	const sal_Bool bPrinter(GetPaintWindow().OutputToPrinter());
  	SetOfByte aProcessLayers = bPrinter ? mrPageView.GetPrintableLayers() : mrPageView.GetVisibleLayers();
  
  	// is the given layer visible at all?
  	if(aProcessLayers.IsSet(*pId))
  	{
  		// find out if we are painting the ControlLayer
  		const SdrLayerAdmin& rLayerAdmin = rModel.GetLayerAdmin();
  		const SdrLayerID nControlLayerId = rLayerAdmin.GetLayerID(rLayerAdmin.GetControlLayerName(), sal_False);
  		const sal_Bool bControlLayerProcessingActive(pId && nControlLayerId == *pId);
  
  		// create PaintInfoRec, use Rectangle only temporarily
  		const Region& rRegion = GetPaintWindow().GetRedrawRegion();
  
  		// create processing data
  		sdr::contact::DisplayInfo aDisplayInfo;
  
  		// is it the control layer? If Yes, set flag
  		aDisplayInfo.SetControlLayerProcessingActive(bControlLayerProcessingActive);
  
  		// Draw just the one given layer
  		aProcessLayers.ClearAll();
  		aProcessLayers.Set(*pId);
  
  		aDisplayInfo.SetProcessLayers(aProcessLayers);
  
  		// Set region as redraw area
  		aDisplayInfo.SetRedrawArea(rRegion);
  
  		// Writer or calc, coming from original RedrawOneLayer.
          // #i72889# no page painting for layer painting
  		aDisplayInfo.SetPageProcessingActive(false);
  
  		// paint page
  		GetObjectContact().ProcessDisplay(aDisplayInfo);
  	}
  
  	// reset redirector
  	GetObjectContact().SetViewObjectContactRedirector(0L);
  }
  
  // Invalidate call, used from ObjectContact(OfPageView) in InvalidatePartOfView(...)
  void SdrPageWindow::InvalidatePageWindow(const basegfx::B2DRange& rRange)
  {
  	if(GetPageView().IsVisible() && GetPaintWindow().OutputToWindow())
  	{
          const SvtOptionsDrawinglayer aDrawinglayerOpt;
          Window& rWindow(static_cast< Window& >(GetPaintWindow().GetOutputDevice()));
          basegfx::B2DRange aDiscreteRange(rRange);
          aDiscreteRange.transform(rWindow.GetViewTransformation());
  
          if(aDrawinglayerOpt.IsAntiAliasing())
          {
              // invalidate one discrete unit more under the assumption that AA
              // needs one pixel more
              aDiscreteRange.grow(1.0);
          }
  
  		const Rectangle aVCLDiscreteRectangle(
  				(sal_Int32)floor(aDiscreteRange.getMinX()), (sal_Int32)floor(aDiscreteRange.getMinY()), 
  				(sal_Int32)ceil(aDiscreteRange.getMaxX()), (sal_Int32)ceil(aDiscreteRange.getMaxY()));
          const bool bWasMapModeEnabled(rWindow.IsMapModeEnabled());
  
          rWindow.EnableMapMode(false);
  		rWindow.Invalidate(aVCLDiscreteRectangle, INVALIDATE_NOERASE);
          rWindow.EnableMapMode(bWasMapModeEnabled);
  	}
  }
  
  // #110094# ObjectContact section
  sdr::contact::ObjectContact& SdrPageWindow::GetObjectContact() const
  {
  	if(!mpObjectContact)
  	{
  		((SdrPageWindow*)this)->mpObjectContact = ((SdrPageWindow*)this)->CreateViewSpecificObjectContact();
  	}
  
  	return *mpObjectContact;
  }
  
  bool SdrPageWindow::HasObjectContact() const
  {
      return ( mpObjectContact != NULL );
  }
  
  // #i26631#
  void SdrPageWindow::ResetObjectContact() 
  { 
  	if(mpObjectContact) 
  	{ 
  		delete mpObjectContact; 
  		mpObjectContact = 0L; 
  	}
  }
  
  void SdrPageWindow::SetDesignMode( bool _bDesignMode ) const
  {
      const ::sdr::contact::ObjectContactOfPageView* pOC = dynamic_cast< const ::sdr::contact::ObjectContactOfPageView* >( &GetObjectContact() );
      DBG_ASSERT( pOC, "SdrPageWindow::SetDesignMode: invalid object contact!" );
      if ( pOC )
          pOC->SetUNOControlsDesignMode( _bDesignMode );
  }
  
  ////////////////////////////////////////////////////////////////////////////////////////////////////
  // eof
  