LCOV - code coverage report
Current view: top level - drawinglayer/source/primitive2d - controlprimitive2d.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 115 129 89.1 %
Date: 2015-06-13 12:38:46 Functions: 11 11 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <drawinglayer/primitive2d/controlprimitive2d.hxx>
      21             : #include <com/sun/star/beans/XPropertySet.hpp>
      22             : #include <comphelper/processfactory.hxx>
      23             : #include <com/sun/star/awt/XWindow2.hpp>
      24             : #include <drawinglayer/geometry/viewinformation2d.hxx>
      25             : #include <vcl/virdev.hxx>
      26             : #include <vcl/svapp.hxx>
      27             : #include <com/sun/star/awt/PosSize.hpp>
      28             : #include <vcl/bitmapex.hxx>
      29             : #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
      30             : #include <tools/diagnose_ex.h>
      31             : #include <basegfx/polygon/b2dpolygontools.hxx>
      32             : #include <basegfx/polygon/b2dpolygon.hxx>
      33             : #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
      34             : #include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
      35             : #include <svtools/optionsdrawinglayer.hxx>
      36             : #include <toolkit/awt/vclxwindow.hxx>
      37             : #include <vcl/window.hxx>
      38             : #include <basegfx/matrix/b2dhommatrixtools.hxx>
      39             : 
      40             : using namespace com::sun::star;
      41             : 
      42             : namespace drawinglayer
      43             : {
      44             :     namespace primitive2d
      45             :     {
      46        3081 :         void ControlPrimitive2D::createXControl()
      47             :         {
      48        3081 :             if(!mxXControl.is() && getControlModel().is())
      49             :             {
      50        3081 :                 uno::Reference< beans::XPropertySet > xSet(getControlModel(), uno::UNO_QUERY);
      51             : 
      52        3081 :                 if(xSet.is())
      53             :                 {
      54        3081 :                     uno::Any aValue(xSet->getPropertyValue("DefaultControl"));
      55        6162 :                     OUString aUnoControlTypeName;
      56             : 
      57        3081 :                     if(aValue >>= aUnoControlTypeName)
      58             :                     {
      59        3081 :                         if(!aUnoControlTypeName.isEmpty())
      60             :                         {
      61        3081 :                             uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
      62             :                             uno::Reference< awt::XControl > xXControl(
      63        6162 :                                 xContext->getServiceManager()->createInstanceWithContext(aUnoControlTypeName, xContext), uno::UNO_QUERY);
      64             : 
      65        3081 :                             if(xXControl.is())
      66             :                             {
      67          81 :                                 xXControl->setModel(getControlModel());
      68             : 
      69             :                                 // remember XControl
      70          81 :                                 mxXControl = xXControl;
      71        3081 :                             }
      72             :                         }
      73        3081 :                     }
      74        3081 :                 }
      75             :             }
      76        3081 :         }
      77             : 
      78          71 :         Primitive2DReference ControlPrimitive2D::createBitmapDecomposition(const geometry::ViewInformation2D& rViewInformation) const
      79             :         {
      80          71 :             Primitive2DReference xRetval;
      81          71 :             const uno::Reference< awt::XControl >& rXControl(getXControl());
      82             : 
      83          71 :             if(rXControl.is())
      84             :             {
      85           1 :                 uno::Reference< awt::XWindow > xControlWindow(rXControl, uno::UNO_QUERY);
      86             : 
      87           1 :                 if(xControlWindow.is())
      88             :                 {
      89             :                     // get decomposition to get size
      90           2 :                     basegfx::B2DVector aScale, aTranslate;
      91             :                     double fRotate, fShearX;
      92           1 :                     getTransform().decompose(aScale, aTranslate, fRotate, fShearX);
      93             : 
      94             :                     // get absolute discrete size (no mirror or rotate here)
      95           1 :                     aScale = basegfx::absolute(aScale);
      96           2 :                     basegfx::B2DVector aDiscreteSize(rViewInformation.getObjectToViewTransformation() * aScale);
      97             : 
      98             :                     // limit to a maximum square size, e.g. 300x150 pixels (45000)
      99           2 :                     const SvtOptionsDrawinglayer aDrawinglayerOpt;
     100           1 :                     const double fDiscreteMax(aDrawinglayerOpt.GetQuadraticFormControlRenderLimit());
     101           1 :                     const double fDiscreteQuadratic(aDiscreteSize.getX() * aDiscreteSize.getY());
     102           1 :                     const bool bScaleUsed(fDiscreteQuadratic > fDiscreteMax);
     103           1 :                     double fFactor(1.0);
     104             : 
     105           1 :                     if(bScaleUsed)
     106             :                     {
     107             :                         // get factor and adapt to scaled size
     108           1 :                         fFactor = sqrt(fDiscreteMax / fDiscreteQuadratic);
     109           1 :                         aDiscreteSize *= fFactor;
     110             :                     }
     111             : 
     112             :                     // go to integer
     113           1 :                     const sal_Int32 nSizeX(basegfx::fround(aDiscreteSize.getX()));
     114           1 :                     const sal_Int32 nSizeY(basegfx::fround(aDiscreteSize.getY()));
     115             : 
     116           1 :                     if(nSizeX > 0 && nSizeY > 0)
     117             :                     {
     118             :                         // prepare VirtualDevice
     119           1 :                         ScopedVclPtrInstance< VirtualDevice > aVirtualDevice(*Application::GetDefaultDevice());
     120           1 :                         const Size aSizePixel(nSizeX, nSizeY);
     121           1 :                         aVirtualDevice->SetOutputSizePixel(aSizePixel);
     122             : 
     123             :                         // set size at control
     124           1 :                         xControlWindow->setPosSize(0, 0, nSizeX, nSizeY, awt::PosSize::POSSIZE);
     125             : 
     126             :                         // get graphics and view
     127           2 :                         uno::Reference< awt::XGraphics > xGraphics(aVirtualDevice->CreateUnoGraphics());
     128           2 :                         uno::Reference< awt::XView > xControlView(rXControl, uno::UNO_QUERY);
     129             : 
     130           1 :                         if(xGraphics.is() && xControlView.is())
     131             :                         {
     132             :                             // link graphics and view
     133           1 :                             xControlView->setGraphics(xGraphics);
     134             : 
     135             :                             {   // #i93162# For painting the control setting a Zoom (using setZoom() at the xControlView)
     136             :                                 // is needed to define the font size. Normally this is done in
     137             :                                 // ViewObjectContactOfUnoControl::createPrimitive2DSequence by using positionControlForPaint().
     138             :                                 // For some reason the difference between MAP_TWIPS and MAP_100TH_MM still plays
     139             :                                 // a role there so that for Draw/Impress/Calc (the MAP_100TH_MM users) i need to set a zoom
     140             :                                 // here, too. The factor includes the needed scale, but is calculated by pure comparisons. It
     141             :                                 // is somehow related to the twips/100thmm relationship.
     142           1 :                                 bool bUserIs100thmm(false);
     143           1 :                                 const uno::Reference< awt::XControl > xControl(xControlView, uno::UNO_QUERY);
     144             : 
     145           1 :                                 if(xControl.is())
     146             :                                 {
     147           1 :                                     uno::Reference< awt::XWindowPeer > xWindowPeer(xControl->getPeer());
     148             : 
     149           1 :                                     if(xWindowPeer.is())
     150             :                                     {
     151           0 :                                         VCLXWindow* pVCLXWindow = VCLXWindow::GetImplementation(xWindowPeer);
     152             : 
     153           0 :                                         if(pVCLXWindow)
     154             :                                         {
     155           0 :                                             vcl::Window* pWindow = pVCLXWindow->GetWindow();
     156             : 
     157           0 :                                             if(pWindow)
     158             :                                             {
     159           0 :                                                 pWindow = pWindow->GetParent();
     160             : 
     161           0 :                                                 if(pWindow)
     162             :                                                 {
     163           0 :                                                     if(MAP_100TH_MM == pWindow->GetMapMode().GetMapUnit())
     164             :                                                     {
     165           0 :                                                         bUserIs100thmm = true;
     166             :                                                     }
     167             :                                                 }
     168             :                                             }
     169             :                                         }
     170           1 :                                     }
     171             :                                 }
     172             : 
     173           1 :                                 if(bUserIs100thmm)
     174             :                                 {
     175             :                                     // calc screen zoom for text display. fFactor is already added indirectly in aDiscreteSize
     176             :                                     basegfx::B2DVector aScreenZoom(
     177           0 :                                         basegfx::fTools::equalZero(aScale.getX()) ? 1.0 : aDiscreteSize.getX() / aScale.getX(),
     178           0 :                                         basegfx::fTools::equalZero(aScale.getY()) ? 1.0 : aDiscreteSize.getY() / aScale.getY());
     179             :                                     static double fZoomScale(28.0); // do not ask for this constant factor, but it gets the zoom right
     180           0 :                                     aScreenZoom *= fZoomScale;
     181             : 
     182             :                                     // set zoom at control view for text scaling
     183           0 :                                     xControlView->setZoom((float)aScreenZoom.getX(), (float)aScreenZoom.getY());
     184           1 :                                 }
     185             :                             }
     186             : 
     187             :                             try
     188             :                             {
     189             :                                 // try to paint it to VirtualDevice
     190           1 :                                 xControlView->draw(0, 0);
     191             : 
     192             :                                 // get bitmap
     193           1 :                                 const Bitmap aContent(aVirtualDevice->GetBitmap(Point(), aSizePixel));
     194             : 
     195             :                                 // to avoid scaling, use the Bitmap pixel size as primitive size
     196           1 :                                 const Size aBitmapSize(aContent.GetSizePixel());
     197             :                                 basegfx::B2DVector aBitmapSizeLogic(
     198           1 :                                     rViewInformation.getInverseObjectToViewTransformation() *
     199           3 :                                     basegfx::B2DVector(aBitmapSize.getWidth() - 1, aBitmapSize.getHeight() - 1));
     200             : 
     201           1 :                                 if(bScaleUsed)
     202             :                                 {
     203             :                                     // if scaled adapt to scaled size
     204           1 :                                     aBitmapSizeLogic /= fFactor;
     205             :                                 }
     206             : 
     207             :                                 // short form for scale and translate transformation
     208             :                                 const basegfx::B2DHomMatrix aBitmapTransform(basegfx::tools::createScaleTranslateB2DHomMatrix(
     209           2 :                                     aBitmapSizeLogic.getX(), aBitmapSizeLogic.getY(), aTranslate.getX(), aTranslate.getY()));
     210             : 
     211             :                                 // create primitive
     212           2 :                                 xRetval = new BitmapPrimitive2D(BitmapEx(aContent), aBitmapTransform);
     213             :                             }
     214           0 :                             catch( const uno::Exception& )
     215             :                             {
     216             :                                 DBG_UNHANDLED_EXCEPTION();
     217             :                             }
     218           1 :                         }
     219           1 :                     }
     220           1 :                 }
     221             :             }
     222             : 
     223          71 :             return xRetval;
     224             :         }
     225             : 
     226          70 :         Primitive2DReference ControlPrimitive2D::createPlaceholderDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
     227             :         {
     228             :             // create a gray placeholder hairline polygon in object size
     229          70 :             basegfx::B2DRange aObjectRange(0.0, 0.0, 1.0, 1.0);
     230          70 :             aObjectRange.transform(getTransform());
     231          70 :             const basegfx::B2DPolygon aOutline(basegfx::tools::createPolygonFromRect(aObjectRange));
     232         140 :             const basegfx::BColor aGrayTone(0xc0 / 255.0, 0xc0 / 255.0, 0xc0 / 255.0);
     233             : 
     234             :             // The replacement object may also get a text like 'empty group' here later
     235          70 :             Primitive2DReference xRetval(new PolygonHairlinePrimitive2D(aOutline, aGrayTone));
     236             : 
     237         140 :             return xRetval;
     238             :         }
     239             : 
     240          71 :         Primitive2DSequence ControlPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
     241             :         {
     242             :             // try to create a bitmap decomposition. If that fails for some reason,
     243             :             // at least create a replacement decomposition.
     244          71 :             Primitive2DReference xReference(createBitmapDecomposition(rViewInformation));
     245             : 
     246          71 :             if(!xReference.is())
     247             :             {
     248          70 :                 xReference = createPlaceholderDecomposition(rViewInformation);
     249             :             }
     250             : 
     251          71 :             return Primitive2DSequence(&xReference, 1L);
     252             :         }
     253             : 
     254         584 :         ControlPrimitive2D::ControlPrimitive2D(
     255             :             const basegfx::B2DHomMatrix& rTransform,
     256             :             const uno::Reference< awt::XControlModel >& rxControlModel)
     257             :         :   BufferedDecompositionPrimitive2D(),
     258             :             maTransform(rTransform),
     259             :             mxControlModel(rxControlModel),
     260             :             mxXControl(),
     261         584 :             maLastViewScaling()
     262             :         {
     263         584 :         }
     264             : 
     265        3728 :         ControlPrimitive2D::ControlPrimitive2D(
     266             :             const basegfx::B2DHomMatrix& rTransform,
     267             :             const uno::Reference< awt::XControlModel >& rxControlModel,
     268             :             const uno::Reference< awt::XControl >& rxXControl)
     269             :         :   BufferedDecompositionPrimitive2D(),
     270             :             maTransform(rTransform),
     271             :             mxControlModel(rxControlModel),
     272             :             mxXControl(rxXControl),
     273        3728 :             maLastViewScaling()
     274             :         {
     275        3728 :         }
     276             : 
     277        8351 :         const uno::Reference< awt::XControl >& ControlPrimitive2D::getXControl() const
     278             :         {
     279        8351 :             if(!mxXControl.is())
     280             :             {
     281        3081 :                 const_cast< ControlPrimitive2D* >(this)->createXControl();
     282             :             }
     283             : 
     284        8351 :             return mxXControl;
     285             :         }
     286             : 
     287         351 :         bool ControlPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
     288             :         {
     289             :             // use base class compare operator
     290         351 :             if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
     291             :             {
     292         334 :                 const ControlPrimitive2D& rCompare = static_cast<const ControlPrimitive2D&>(rPrimitive);
     293             : 
     294         334 :                 if(getTransform() == rCompare.getTransform())
     295             :                 {
     296             :                     // check if ControlModel references both are/are not
     297         167 :                     bool bRetval(getControlModel().is() == rCompare.getControlModel().is());
     298             : 
     299         167 :                     if(bRetval && getControlModel().is())
     300             :                     {
     301             :                         // both exist, check for equality
     302         167 :                         bRetval = (getControlModel() == rCompare.getControlModel());
     303             :                     }
     304             : 
     305         167 :                     if(bRetval)
     306             :                     {
     307             :                         // check if XControl references both are/are not
     308         167 :                         bRetval = (getXControl().is() == rCompare.getXControl().is());
     309             :                     }
     310             : 
     311         167 :                     if(bRetval && getXControl().is())
     312             :                     {
     313             :                         // both exist, check for equality
     314         101 :                         bRetval = (getXControl() == rCompare.getXControl());
     315             :                     }
     316             : 
     317         167 :                     return bRetval;
     318             :                 }
     319             :             }
     320             : 
     321         184 :             return false;
     322             :         }
     323             : 
     324         582 :         basegfx::B2DRange ControlPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
     325             :         {
     326             :             // simply derivate from unit range
     327         582 :             basegfx::B2DRange aRetval(0.0, 0.0, 1.0, 1.0);
     328         582 :             aRetval.transform(getTransform());
     329         582 :             return aRetval;
     330             :         }
     331             : 
     332        2733 :         Primitive2DSequence ControlPrimitive2D::get2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const
     333             :         {
     334             :             // this primitive is view-dependent related to the scaling. If scaling has changed,
     335             :             // destroy existing decomposition. To detect change, use size of unit size in view coordinates
     336        2733 :             ::osl::MutexGuard aGuard( m_aMutex );
     337        5466 :             const basegfx::B2DVector aNewScaling(rViewInformation.getObjectToViewTransformation() * basegfx::B2DVector(1.0, 1.0));
     338             : 
     339        2733 :             if(getBuffered2DDecomposition().hasElements())
     340             :             {
     341        2662 :                 if(!maLastViewScaling.equal(aNewScaling))
     342             :                 {
     343             :                     // conditions of last local decomposition have changed, delete
     344           0 :                     const_cast< ControlPrimitive2D* >(this)->setBuffered2DDecomposition(Primitive2DSequence());
     345             :                 }
     346             :             }
     347             : 
     348        2733 :             if(!getBuffered2DDecomposition().hasElements())
     349             :             {
     350             :                 // remember ViewTransformation
     351          71 :                 const_cast< ControlPrimitive2D* >(this)->maLastViewScaling = aNewScaling;
     352             :             }
     353             : 
     354             :             // use parent implementation
     355        5466 :             return BufferedDecompositionPrimitive2D::get2DDecomposition(rViewInformation);
     356             :         }
     357             : 
     358             :         // provide unique ID
     359        8289 :         ImplPrimitive2DIDBlock(ControlPrimitive2D, PRIMITIVE2D_ID_CONTROLPRIMITIVE2D)
     360             : 
     361             :     } // end of namespace primitive2d
     362             : } // end of namespace drawinglayer
     363             : 
     364             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11