/**************************************************************
*
* 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_drawinglayer.hxx"
#include <drawinglayer/primitive2d/controlprimitive2d.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/awt/XWindow2.hpp>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <vcl/virdev.hxx>
#include <vcl/svapp.hxx>
#include <com/sun/star/awt/PosSize.hpp>
#include <vcl/bitmapex.hxx>
#include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
#include <tools/diagnose_ex.h>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <svtools/optionsdrawinglayer.hxx>
#include <toolkit/awt/vclxwindow.hxx>
#include <vcl/window.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
//////////////////////////////////////////////////////////////////////////////
using namespace com::sun::star;
//////////////////////////////////////////////////////////////////////////////
namespace drawinglayer
{
namespace primitive2d
{
void ControlPrimitive2D::createXControl()
{
if(!mxXControl.is() && getControlModel().is())
{
uno::Reference< beans::XPropertySet > xSet(getControlModel(), uno::UNO_QUERY);
if(xSet.is())
{
uno::Any aValue(xSet->getPropertyValue(rtl::OUString::createFromAscii("DefaultControl")));
rtl::OUString aUnoControlTypeName;
if(aValue >>= aUnoControlTypeName)
{
if(aUnoControlTypeName.getLength())
{
uno::Reference< lang::XMultiServiceFactory > xFactory( comphelper::getProcessServiceFactory() );
if(xFactory.is())
{
uno::Reference< awt::XControl > xXControl(xFactory->createInstance(aUnoControlTypeName), uno::UNO_QUERY);
if(xXControl.is())
{
xXControl->setModel(getControlModel());
// remember XControl
mxXControl = xXControl;
}
}
}
}
}
}
}
Primitive2DReference ControlPrimitive2D::createBitmapDecomposition(const geometry::ViewInformation2D& rViewInformation) const
{
Primitive2DReference xRetval;
const uno::Reference< awt::XControl >& rXControl(getXControl());
if(rXControl.is())
{
uno::Reference< awt::XWindow > xControlWindow(rXControl, uno::UNO_QUERY);
if(xControlWindow.is())
{
// get decomposition to get size
basegfx::B2DVector aScale, aTranslate;
double fRotate, fShearX;
getTransform().decompose(aScale, aTranslate, fRotate, fShearX);
// get absolute discrete size (no mirror or rotate here)
aScale = basegfx::absolute(aScale);
basegfx::B2DVector aDiscreteSize(rViewInformation.getObjectToViewTransformation() * aScale);
// limit to a maximum square size, e.g. 300x150 pixels (45000)
const SvtOptionsDrawinglayer aDrawinglayerOpt;
const double fDiscreteMax(aDrawinglayerOpt.GetQuadraticFormControlRenderLimit());
const double fDiscreteQuadratic(aDiscreteSize.getX() * aDiscreteSize.getY());
const bool bScaleUsed(fDiscreteQuadratic > fDiscreteMax);
double fFactor(1.0);
if(bScaleUsed)
{
// get factor and adapt to scaled size
fFactor = sqrt(fDiscreteMax / fDiscreteQuadratic);
aDiscreteSize *= fFactor;
}
// go to integer
const sal_Int32 nSizeX(basegfx::fround(aDiscreteSize.getX()));
const sal_Int32 nSizeY(basegfx::fround(aDiscreteSize.getY()));
if(nSizeX > 0 && nSizeY > 0)
{
// prepare VirtualDevice
VirtualDevice aVirtualDevice(*Application::GetDefaultDevice());
const Size aSizePixel(nSizeX, nSizeY);
aVirtualDevice.SetOutputSizePixel(aSizePixel);
// set size at control
xControlWindow->setPosSize(0, 0, nSizeX, nSizeY, awt::PosSize::POSSIZE);
// get graphics and view
uno::Reference< awt::XGraphics > xGraphics(aVirtualDevice.CreateUnoGraphics());
uno::Reference< awt::XView > xControlView(rXControl, uno::UNO_QUERY);
if(xGraphics.is() && xControlView.is())
{
// link graphics and view
xControlView->setGraphics(xGraphics);
{ // #i93162# For painting the control setting a Zoom (using setZoom() at the xControlView)
// is needed to define the font size. Normally this is done in
// ViewObjectContactOfUnoControl::createPrimitive2DSequence by using positionControlForPaint().
// For some reason the difference between MAP_TWIPS and MAP_100TH_MM still plays
// a role there so that for Draw/Impress/Calc (the MAP_100TH_MM users) i need to set a zoom
// here, too. The factor includes the needed scale, but is calculated by pure comparisons. It
// is somehow related to the twips/100thmm relationship.
bool bUserIs100thmm(false);
const uno::Reference< awt::XControl > xControl(xControlView, uno::UNO_QUERY);
if(xControl.is())
{
uno::Reference< awt::XWindowPeer > xWindowPeer(xControl->getPeer());
if(xWindowPeer.is())
{
VCLXWindow* pVCLXWindow = VCLXWindow::GetImplementation(xWindowPeer);
if(pVCLXWindow)
{
Window* pWindow = pVCLXWindow->GetWindow();
if(pWindow)
{
pWindow = pWindow->GetParent();
if(pWindow)
{
if(MAP_100TH_MM == pWindow->GetMapMode().GetMapUnit())
{
bUserIs100thmm = true;
}
}
}
}
}
}
if(bUserIs100thmm)
{
// calc screen zoom for text display. fFactor is already added indirectly in aDiscreteSize
basegfx::B2DVector aScreenZoom(
basegfx::fTools::equalZero(aScale.getX()) ? 1.0 : aDiscreteSize.getX() / aScale.getX(),
basegfx::fTools::equalZero(aScale.getY()) ? 1.0 : aDiscreteSize.getY() / aScale.getY());
static double fZoomScale(28.0); // do not ask for this constant factor, but it gets the zoom right
aScreenZoom *= fZoomScale;
// set zoom at control view for text scaling
xControlView->setZoom((float)aScreenZoom.getX(), (float)aScreenZoom.getY());
}
}
try
{
// try to paint it to VirtualDevice
xControlView->draw(0, 0);
// get bitmap
const Bitmap aContent(aVirtualDevice.GetBitmap(Point(), aSizePixel));
// to avoid scaling, use the Bitmap pixel size as primitive size
const Size aBitmapSize(aContent.GetSizePixel());
basegfx::B2DVector aBitmapSizeLogic(
rViewInformation.getInverseObjectToViewTransformation() *
basegfx::B2DVector(aBitmapSize.getWidth() - 1, aBitmapSize.getHeight() - 1));
if(bScaleUsed)
{
// if scaled adapt to scaled size
aBitmapSizeLogic /= fFactor;
}
// short form for scale and translate transformation
const basegfx::B2DHomMatrix aBitmapTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(
aBitmapSizeLogic.getX(), aBitmapSizeLogic.getY(), aTranslate.getX(), aTranslate.getY()));
// create primitive
xRetval = new BitmapPrimitive2D(BitmapEx(aContent), aBitmapTransform);
}
catch( const uno::Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
}
}
}
return xRetval;
}
Primitive2DReference ControlPrimitive2D::createPlaceholderDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
{
// create a gray placeholder hairline polygon in object size
basegfx::B2DRange aObjectRange(0.0, 0.0, 1.0, 1.0);
aObjectRange.transform(getTransform());
const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aObjectRange));
const basegfx::BColor aGrayTone(0xc0 / 255.0, 0xc0 / 255.0, 0xc0 / 255.0);
// The replacement object may also get a text like 'empty group' here later
Primitive2DReference xRetval(new PolygonHairlinePrimitive2D(aOutline, aGrayTone));
return xRetval;
}
Primitive2DSequence ControlPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
{
// try to create a bitmap decomposition. If that fails for some reason,
// at least create a replacement decomposition.
Primitive2DReference xReference(createBitmapDecomposition(rViewInformation));
if(!xReference.is())
{
xReference = createPlaceholderDecomposition(rViewInformation);
}
return Primitive2DSequence(&xReference, 1L);
}
ControlPrimitive2D::ControlPrimitive2D(
const basegfx::B2DHomMatrix& rTransform,
const uno::Reference< awt::XControlModel >& rxControlModel)
: BufferedDecompositionPrimitive2D(),
maTransform(rTransform),
mxControlModel(rxControlModel),
mxXControl(),
maLastViewScaling()
{
}
ControlPrimitive2D::ControlPrimitive2D(
const basegfx::B2DHomMatrix& rTransform,
const uno::Reference< awt::XControlModel >& rxControlModel,
const uno::Reference< awt::XControl >& rxXControl)
: BufferedDecompositionPrimitive2D(),
maTransform(rTransform),
mxControlModel(rxControlModel),
mxXControl(rxXControl),
maLastViewScaling()
{
}
const uno::Reference< awt::XControl >& ControlPrimitive2D::getXControl() const
{
if(!mxXControl.is())
{
const_cast< ControlPrimitive2D* >(this)->createXControl();
}
return mxXControl;
}
bool ControlPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
{
// use base class compare operator
if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
{
const ControlPrimitive2D& rCompare = (ControlPrimitive2D&)rPrimitive;
if(getTransform() == rCompare.getTransform())
{
// check if ControlModel references both are/are not
bool bRetval(getControlModel().is() == rCompare.getControlModel().is());
if(bRetval && getControlModel().is())
{
// both exist, check for equality
bRetval = (getControlModel() == rCompare.getControlModel());
}
if(bRetval)
{
// check if XControl references both are/are not
bRetval = (getXControl().is() == rCompare.getXControl().is());
}
if(bRetval && getXControl().is())
{
// both exist, check for equality
bRetval = (getXControl() == rCompare.getXControl());
}
return bRetval;
}
}
return false;
}
basegfx::B2DRange ControlPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
{
// simply derivate from unit range
basegfx::B2DRange aRetval(0.0, 0.0, 1.0, 1.0);
aRetval.transform(getTransform());
return aRetval;
}
Primitive2DSequence ControlPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
{
// this primitive is view-dependent related to the scaling. If scaling has changed,
// destroy existing decomposition. To detect change, use size of unit size in view coordinates
::osl::MutexGuard aGuard( m_aMutex );
const basegfx::B2DVector aNewScaling(rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0));
if(getBuffered2DDecomposition().hasElements())
{
if(!maLastViewScaling.equal(aNewScaling))
{
// conditions of last local decomposition have changed, delete
const_cast< ControlPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
}
}
if(!getBuffered2DDecomposition().hasElements())
{
// remember ViewTransformation
const_cast< ControlPrimitive2D* >(this)->maLastViewScaling = aNewScaling;
}
// use parent implementation
return BufferedDecompositionPrimitive2D::get2DDecomposition(rViewInformation);
}
// provide unique ID
ImplPrimitrive2DIDBlock(ControlPrimitive2D, PRIMITIVE2D_ID_CONTROLPRIMITIVE2D)
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// eof