LCOV - code coverage report
Current view: top level - drawinglayer/source/primitive2d - graphicprimitivehelper2d.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 34 143 23.8 %
Date: 2015-06-13 12:38:46 Functions: 1 12 8.3 %
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/graphicprimitivehelper2d.hxx>
      21             : #include <drawinglayer/animation/animationtiming.hxx>
      22             : #include <drawinglayer/primitive2d/bitmapprimitive2d.hxx>
      23             : #include <drawinglayer/primitive2d/animatedprimitive2d.hxx>
      24             : #include <drawinglayer/primitive2d/metafileprimitive2d.hxx>
      25             : #include <drawinglayer/primitive2d/transformprimitive2d.hxx>
      26             : #include <drawinglayer/primitive2d/maskprimitive2d.hxx>
      27             : #include <drawinglayer/primitive2d/modifiedcolorprimitive2d.hxx>
      28             : #include <basegfx/polygon/b2dpolygon.hxx>
      29             : #include <basegfx/polygon/b2dpolygontools.hxx>
      30             : #include <basegfx/numeric/ftools.hxx>
      31             : 
      32             : // helper class for animated graphics
      33             : 
      34             : #include <vcl/animate.hxx>
      35             : #include <vcl/graph.hxx>
      36             : #include <vcl/virdev.hxx>
      37             : #include <vcl/svapp.hxx>
      38             : #include <vcl/metaact.hxx>
      39             : 
      40             : namespace
      41             : {
      42           0 :     struct animationStep
      43             :     {
      44             :         BitmapEx                                maBitmapEx;
      45             :         sal_uInt32                              mnTime;
      46             :     };
      47             : 
      48           0 :     class animatedBitmapExPreparator
      49             :     {
      50             :         ::Animation                             maAnimation;
      51             :         ::std::vector< animationStep >          maSteps;
      52             : 
      53             :         sal_uInt32 generateStepTime(sal_uInt32 nIndex) const;
      54             : 
      55             :     public:
      56             :         animatedBitmapExPreparator(const Graphic& rGraphic);
      57             : 
      58           0 :         sal_uInt32 count() const { return maSteps.size(); }
      59           0 :         sal_uInt32 loopCount() const { return (sal_uInt32)maAnimation.GetLoopCount(); }
      60           0 :         sal_uInt32 stepTime(sal_uInt32 a) const { return maSteps[a].mnTime; }
      61           0 :         const BitmapEx& stepBitmapEx(sal_uInt32 a) const { return maSteps[a].maBitmapEx; }
      62             :     };
      63             : 
      64           0 :     sal_uInt32 animatedBitmapExPreparator::generateStepTime(sal_uInt32 nIndex) const
      65             :     {
      66           0 :         const AnimationBitmap& rAnimBitmap = maAnimation.Get(sal_uInt16(nIndex));
      67           0 :         sal_uInt32 nWaitTime(rAnimBitmap.nWait * 10);
      68             : 
      69             :         // #115934#
      70             :         // Take care of special value for MultiPage TIFFs. ATM these shall just
      71             :         // show their first page. Later we will offer some switching when object
      72             :         // is selected.
      73           0 :         if(ANIMATION_TIMEOUT_ON_CLICK == rAnimBitmap.nWait)
      74             :         {
      75             :             // ATM the huge value would block the timer, so
      76             :             // use a long time to show first page (whole day)
      77           0 :             nWaitTime = 100 * 60 * 60 * 24;
      78             :         }
      79             : 
      80             :         // Bad trap: There are animated gifs with no set WaitTime (!).
      81             :         // In that case use a default value.
      82           0 :         if(0L == nWaitTime)
      83             :         {
      84           0 :             nWaitTime = 100L;
      85             :         }
      86             : 
      87           0 :         return nWaitTime;
      88             :     }
      89             : 
      90           0 :     animatedBitmapExPreparator::animatedBitmapExPreparator(const Graphic& rGraphic)
      91           0 :     :   maAnimation(rGraphic.GetAnimation())
      92             :     {
      93             :         OSL_ENSURE(GRAPHIC_BITMAP == rGraphic.GetType() && rGraphic.IsAnimated(), "animatedBitmapExPreparator: graphic is not animated (!)");
      94             : 
      95             :         // #128539# secure access to Animation, looks like there exist animated GIFs out there
      96             :         // with a step count of zero
      97           0 :         if(maAnimation.Count())
      98             :         {
      99           0 :             ScopedVclPtrInstance< VirtualDevice > aVirtualDevice(*Application::GetDefaultDevice());
     100           0 :             ScopedVclPtrInstance< VirtualDevice > aVirtualDeviceMask(*Application::GetDefaultDevice(), 1L);
     101             : 
     102             :             // Prepare VirtualDevices and their states
     103           0 :             aVirtualDevice->EnableMapMode(false);
     104           0 :             aVirtualDeviceMask->EnableMapMode(false);
     105           0 :             aVirtualDevice->SetOutputSizePixel(maAnimation.GetDisplaySizePixel());
     106           0 :             aVirtualDeviceMask->SetOutputSizePixel(maAnimation.GetDisplaySizePixel());
     107           0 :             aVirtualDevice->Erase();
     108           0 :             aVirtualDeviceMask->Erase();
     109             : 
     110           0 :             for(size_t a(0); a < maAnimation.Count(); a++)
     111             :             {
     112           0 :                 animationStep aNextStep;
     113           0 :                 aNextStep.mnTime = generateStepTime(a);
     114             : 
     115             :                 // prepare step
     116           0 :                 const AnimationBitmap& rAnimBitmap = maAnimation.Get(sal_uInt16(a));
     117             : 
     118           0 :                 switch(rAnimBitmap.eDisposal)
     119             :                 {
     120             :                     case DISPOSE_NOT:
     121             :                     {
     122           0 :                         aVirtualDevice->DrawBitmapEx(rAnimBitmap.aPosPix, rAnimBitmap.aBmpEx);
     123           0 :                         Bitmap aMask = rAnimBitmap.aBmpEx.GetMask();
     124             : 
     125           0 :                         if(aMask.IsEmpty())
     126             :                         {
     127           0 :                             const Point aEmpty;
     128           0 :                             const Rectangle aRect(aEmpty, aVirtualDeviceMask->GetOutputSizePixel());
     129           0 :                             const Wallpaper aWallpaper(COL_BLACK);
     130           0 :                             aVirtualDeviceMask->DrawWallpaper(aRect, aWallpaper);
     131             :                         }
     132             :                         else
     133             :                         {
     134           0 :                             BitmapEx aExpandVisibilityMask = BitmapEx(aMask, aMask);
     135           0 :                             aVirtualDeviceMask->DrawBitmapEx(rAnimBitmap.aPosPix, aExpandVisibilityMask);
     136             :                         }
     137             : 
     138           0 :                         break;
     139             :                     }
     140             :                     case DISPOSE_BACK:
     141             :                     {
     142             :                         // #i70772# react on no mask, for primitives, too.
     143           0 :                         const Bitmap aMask(rAnimBitmap.aBmpEx.GetMask());
     144           0 :                         const Bitmap aContent(rAnimBitmap.aBmpEx.GetBitmap());
     145             : 
     146           0 :                         aVirtualDeviceMask->Erase();
     147           0 :                         aVirtualDevice->DrawBitmap(rAnimBitmap.aPosPix, aContent);
     148             : 
     149           0 :                         if(aMask.IsEmpty())
     150             :                         {
     151           0 :                             const Rectangle aRect(rAnimBitmap.aPosPix, aContent.GetSizePixel());
     152           0 :                             aVirtualDeviceMask->SetFillColor(COL_BLACK);
     153           0 :                             aVirtualDeviceMask->SetLineColor();
     154           0 :                             aVirtualDeviceMask->DrawRect(aRect);
     155             :                         }
     156             :                         else
     157             :                         {
     158           0 :                             aVirtualDeviceMask->DrawBitmap(rAnimBitmap.aPosPix, aMask);
     159             :                         }
     160             : 
     161           0 :                         break;
     162             :                     }
     163             :                     case DISPOSE_FULL:
     164             :                     {
     165           0 :                         aVirtualDevice->DrawBitmapEx(rAnimBitmap.aPosPix, rAnimBitmap.aBmpEx);
     166           0 :                         break;
     167             :                     }
     168             :                     case DISPOSE_PREVIOUS :
     169             :                     {
     170           0 :                         aVirtualDevice->DrawBitmapEx(rAnimBitmap.aPosPix, rAnimBitmap.aBmpEx);
     171           0 :                         aVirtualDeviceMask->DrawBitmap(rAnimBitmap.aPosPix, rAnimBitmap.aBmpEx.GetMask());
     172           0 :                         break;
     173             :                     }
     174             :                 }
     175             : 
     176             :                 // create BitmapEx
     177           0 :                 Bitmap aMainBitmap = aVirtualDevice->GetBitmap(Point(), aVirtualDevice->GetOutputSizePixel());
     178             : #if defined(MACOSX) || defined(IOS)
     179             :                 AlphaMask aMaskBitmap( aVirtualDeviceMask->GetBitmap( Point(), aVirtualDeviceMask->GetOutputSizePixel()));
     180             : #else
     181           0 :                 Bitmap aMaskBitmap = aVirtualDeviceMask->GetBitmap( Point(), aVirtualDeviceMask->GetOutputSizePixel());
     182             : #endif
     183           0 :                 aNextStep.maBitmapEx = BitmapEx(aMainBitmap, aMaskBitmap);
     184             : 
     185             :                 // add to vector
     186           0 :                 maSteps.push_back(aNextStep);
     187           0 :             }
     188             :         }
     189           0 :     }
     190             : } // end of anonymous namespace
     191             : 
     192             : namespace drawinglayer
     193             : {
     194             :     namespace primitive2d
     195             :     {
     196         348 :         Primitive2DSequence create2DDecompositionOfGraphic(
     197             :             const Graphic& rGraphic,
     198             :             const basegfx::B2DHomMatrix& rTransform)
     199             :         {
     200         348 :             Primitive2DSequence aRetval;
     201             : 
     202         348 :             switch(rGraphic.GetType())
     203             :             {
     204             :                 case GRAPHIC_BITMAP :
     205             :                 {
     206         189 :                     if(rGraphic.IsAnimated())
     207             :                     {
     208             :                         // prepare animation data
     209           0 :                         animatedBitmapExPreparator aData(rGraphic);
     210             : 
     211           0 :                         if(aData.count())
     212             :                         {
     213             :                             // create sub-primitives for animated bitmap and the needed animation loop
     214           0 :                             animation::AnimationEntryLoop aAnimationLoop(aData.loopCount() ? aData.loopCount() : 0xffff);
     215           0 :                             Primitive2DSequence aBitmapPrimitives(aData.count());
     216             : 
     217           0 :                             for(sal_uInt32 a(0); a < aData.count(); a++)
     218             :                             {
     219           0 :                                 animation::AnimationEntryFixed aTime((double)aData.stepTime(a), (double)a / (double)aData.count());
     220           0 :                                 aAnimationLoop.append(aTime);
     221           0 :                                 aBitmapPrimitives[a] = new BitmapPrimitive2D(
     222             :                                     aData.stepBitmapEx(a),
     223           0 :                                     rTransform);
     224           0 :                             }
     225             : 
     226             :                             // prepare animation list
     227           0 :                             animation::AnimationEntryList aAnimationList;
     228           0 :                             aAnimationList.append(aAnimationLoop);
     229             : 
     230             :                             // create and add animated switch primitive
     231           0 :                             aRetval.realloc(1);
     232           0 :                             aRetval[0] = new AnimatedSwitchPrimitive2D(
     233             :                                 aAnimationList,
     234             :                                 aBitmapPrimitives,
     235           0 :                                 false);
     236           0 :                         }
     237             :                     }
     238         189 :                     else if(rGraphic.getSvgData().get())
     239             :                     {
     240             :                         // embedded Svg fill, create embed transform
     241           1 :                         const basegfx::B2DRange& rSvgRange(rGraphic.getSvgData()->getRange());
     242             : 
     243           1 :                         if(basegfx::fTools::more(rSvgRange.getWidth(), 0.0) && basegfx::fTools::more(rSvgRange.getHeight(), 0.0))
     244             :                         {
     245             :                             // translate back to origin, scale to unit coordinates
     246             :                             basegfx::B2DHomMatrix aEmbedSvg(
     247             :                                 basegfx::tools::createTranslateB2DHomMatrix(
     248           1 :                                     -rSvgRange.getMinX(),
     249           2 :                                     -rSvgRange.getMinY()));
     250             : 
     251             :                             aEmbedSvg.scale(
     252           1 :                                 1.0 / rSvgRange.getWidth(),
     253           2 :                                 1.0 / rSvgRange.getHeight());
     254             : 
     255             :                             // apply created object transformation
     256           1 :                             aEmbedSvg = rTransform * aEmbedSvg;
     257             : 
     258             :                             // add Svg primitives embedded
     259           1 :                             aRetval.realloc(1);
     260           2 :                             aRetval[0] = new TransformPrimitive2D(
     261             :                                 aEmbedSvg,
     262           3 :                                 rGraphic.getSvgData()->getPrimitive2DSequence());
     263             :                         }
     264             :                     }
     265             :                     else
     266             :                     {
     267         188 :                         aRetval.realloc(1);
     268         564 :                         aRetval[0] = new BitmapPrimitive2D(
     269             :                             rGraphic.GetBitmapEx(),
     270         376 :                             rTransform);
     271             :                     }
     272             : 
     273         189 :                     break;
     274             :                 }
     275             : 
     276             :                 case GRAPHIC_GDIMETAFILE :
     277             :                 {
     278             :                     // create MetafilePrimitive2D
     279         129 :                     const GDIMetaFile& rMetafile = rGraphic.GetGDIMetaFile();
     280             : 
     281         129 :                     aRetval.realloc(1);
     282         258 :                     aRetval[0] = new MetafilePrimitive2D(
     283             :                         rTransform,
     284         258 :                         rMetafile);
     285             : 
     286             :                     // #i100357# find out if clipping is needed for this primitive. Unfortunately,
     287             :                     // there exist Metafiles who's content is bigger than the proposed PrefSize set
     288             :                     // at them. This is an error, but we need to work around this
     289         129 :                     const Size aMetaFilePrefSize(rMetafile.GetPrefSize());
     290             :                     const Size aMetaFileRealSize(
     291             :                         rMetafile.GetBoundRect(
     292         129 :                             *Application::GetDefaultDevice()).GetSize());
     293             : 
     294         258 :                     if(aMetaFileRealSize.getWidth() > aMetaFilePrefSize.getWidth()
     295         129 :                         || aMetaFileRealSize.getHeight() > aMetaFilePrefSize.getHeight())
     296             :                     {
     297             :                         // clipping needed. Embed to MaskPrimitive2D. Create children and mask polygon
     298          13 :                         basegfx::B2DPolygon aMaskPolygon(basegfx::tools::createUnitPolygon());
     299          13 :                         aMaskPolygon.transform(rTransform);
     300             : 
     301             :                         Primitive2DReference mask = new MaskPrimitive2D(
     302             :                             basegfx::B2DPolyPolygon(aMaskPolygon),
     303          26 :                             aRetval);
     304          26 :                         aRetval[0] = mask;
     305             :                     }
     306         129 :                     break;
     307             :                 }
     308             : 
     309             :                 default:
     310             :                 {
     311             :                     // nothing to create
     312          30 :                     break;
     313             :                 }
     314             :             }
     315             : 
     316         348 :             return aRetval;
     317             :         }
     318             : 
     319           0 :         Primitive2DSequence create2DColorModifierEmbeddingsAsNeeded(
     320             :             const Primitive2DSequence& rChildren,
     321             :             GraphicDrawMode aGraphicDrawMode,
     322             :             double fLuminance,
     323             :             double fContrast,
     324             :             double fRed,
     325             :             double fGreen,
     326             :             double fBlue,
     327             :             double fGamma,
     328             :             bool bInvert)
     329             :         {
     330           0 :             Primitive2DSequence aRetval;
     331             : 
     332           0 :             if(!rChildren.getLength())
     333             :             {
     334             :                 // no child content, done
     335           0 :                 return aRetval;
     336             :             }
     337             : 
     338             :             // set child content as retval; that is what will be used as child content in all
     339             :             // embeddings from here
     340           0 :             aRetval = rChildren;
     341             : 
     342           0 :             if(GRAPHICDRAWMODE_WATERMARK == aGraphicDrawMode)
     343             :             {
     344             :                 // this is solved by applying fixed values additionally to luminance
     345             :                 // and contrast, do it here and reset DrawMode to GRAPHICDRAWMODE_STANDARD
     346             :                 // original in svtools uses:
     347             :                 // #define WATERMARK_LUM_OFFSET        50
     348             :                 // #define WATERMARK_CON_OFFSET        -70
     349           0 :                 fLuminance = basegfx::clamp(fLuminance + 0.5, -1.0, 1.0);
     350           0 :                 fContrast = basegfx::clamp(fContrast - 0.7, -1.0, 1.0);
     351           0 :                 aGraphicDrawMode = GRAPHICDRAWMODE_STANDARD;
     352             :             }
     353             : 
     354             :             // DrawMode (GRAPHICDRAWMODE_WATERMARK already handled)
     355           0 :             switch(aGraphicDrawMode)
     356             :             {
     357             :                 case GRAPHICDRAWMODE_GREYS:
     358             :                 {
     359             :                     // convert to grey
     360             :                     const Primitive2DReference aPrimitiveGrey(
     361             :                         new ModifiedColorPrimitive2D(
     362             :                             aRetval,
     363             :                             basegfx::BColorModifierSharedPtr(
     364           0 :                                 new basegfx::BColorModifier_gray())));
     365             : 
     366           0 :                     aRetval = Primitive2DSequence(&aPrimitiveGrey, 1);
     367           0 :                     break;
     368             :                 }
     369             :                 case GRAPHICDRAWMODE_MONO:
     370             :                 {
     371             :                     // convert to mono (black/white with threshold 0.5)
     372             :                     const Primitive2DReference aPrimitiveBlackAndWhite(
     373             :                         new ModifiedColorPrimitive2D(
     374             :                             aRetval,
     375             :                             basegfx::BColorModifierSharedPtr(
     376           0 :                                 new basegfx::BColorModifier_black_and_white(0.5))));
     377             : 
     378           0 :                     aRetval = Primitive2DSequence(&aPrimitiveBlackAndWhite, 1);
     379           0 :                     break;
     380             :                 }
     381             :                 // coverity[dead_error_begin] - intentional dead case
     382             :                 case GRAPHICDRAWMODE_WATERMARK:
     383             :                 {
     384             :                     assert(false && "OOps, GRAPHICDRAWMODE_WATERMARK should already be handled (see above)");
     385             :                     // fallthrough intended
     386             :                 }
     387             :                 default: // case GRAPHICDRAWMODE_STANDARD:
     388             :                 {
     389             :                     // nothing to do
     390           0 :                     break;
     391             :                 }
     392             :             }
     393             : 
     394             :             // mnContPercent, mnLumPercent, mnRPercent, mnGPercent, mnBPercent
     395             :             // handled in a single call
     396           0 :             if(!basegfx::fTools::equalZero(fLuminance)
     397           0 :                 || !basegfx::fTools::equalZero(fContrast)
     398           0 :                 || !basegfx::fTools::equalZero(fRed)
     399           0 :                 || !basegfx::fTools::equalZero(fGreen)
     400           0 :                 || !basegfx::fTools::equalZero(fBlue))
     401             :             {
     402             :                 const Primitive2DReference aPrimitiveRGBLuminannceContrast(
     403             :                     new ModifiedColorPrimitive2D(
     404             :                         aRetval,
     405             :                         basegfx::BColorModifierSharedPtr(
     406             :                             new basegfx::BColorModifier_RGBLuminanceContrast(
     407             :                                 fRed,
     408             :                                 fGreen,
     409             :                                 fBlue,
     410             :                                 fLuminance,
     411           0 :                                 fContrast))));
     412             : 
     413           0 :                 aRetval = Primitive2DSequence(&aPrimitiveRGBLuminannceContrast, 1);
     414             :             }
     415             : 
     416             :             // gamma (boolean)
     417           0 :             if(!basegfx::fTools::equal(fGamma, 1.0))
     418             :             {
     419             :                 const Primitive2DReference aPrimitiveGamma(
     420             :                     new ModifiedColorPrimitive2D(
     421             :                         aRetval,
     422             :                         basegfx::BColorModifierSharedPtr(
     423             :                             new basegfx::BColorModifier_gamma(
     424           0 :                                 fGamma))));
     425             : 
     426           0 :                 aRetval = Primitive2DSequence(&aPrimitiveGamma, 1);
     427             :             }
     428             : 
     429             :             // invert (boolean)
     430           0 :             if(bInvert)
     431             :             {
     432             :                 const Primitive2DReference aPrimitiveInvert(
     433             :                     new ModifiedColorPrimitive2D(
     434             :                         aRetval,
     435             :                         basegfx::BColorModifierSharedPtr(
     436           0 :                             new basegfx::BColorModifier_invert())));
     437             : 
     438           0 :                 aRetval = Primitive2DSequence(&aPrimitiveInvert, 1);
     439             :             }
     440             : 
     441           0 :             return aRetval;
     442             :         }
     443             : 
     444             :     } // end of namespace primitive2d
     445             : } // end of namespace drawinglayer
     446             : 
     447             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11