LCOV - code coverage report
Current view: top level - canvas/source/tools - verifyinput.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 41 144 28.5 %
Date: 2015-06-13 12:38:46 Functions: 8 20 40.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             : 
      21             : #include <com/sun/star/geometry/AffineMatrix2D.hpp>
      22             : #include <com/sun/star/geometry/Matrix2D.hpp>
      23             : #include <com/sun/star/geometry/RealPoint2D.hpp>
      24             : #include <com/sun/star/geometry/RealSize2D.hpp>
      25             : #include <com/sun/star/geometry/IntegerPoint2D.hpp>
      26             : #include <com/sun/star/geometry/IntegerSize2D.hpp>
      27             : #include <com/sun/star/geometry/RealRectangle2D.hpp>
      28             : #include <com/sun/star/geometry/RealBezierSegment2D.hpp>
      29             : #include <com/sun/star/rendering/RenderState.hpp>
      30             : #include <com/sun/star/rendering/ViewState.hpp>
      31             : #include <com/sun/star/rendering/XCanvas.hpp>
      32             : #include <com/sun/star/rendering/CompositeOperation.hpp>
      33             : #include <com/sun/star/rendering/TexturingMode.hpp>
      34             : #include <com/sun/star/util/Endianness.hpp>
      35             : #include <com/sun/star/rendering/PathCapType.hpp>
      36             : #include <com/sun/star/rendering/PathJoinType.hpp>
      37             : #include <com/sun/star/rendering/IntegerBitmapLayout.hpp>
      38             : #include <com/sun/star/rendering/FloatingPointBitmapFormat.hpp>
      39             : #include <com/sun/star/rendering/FloatingPointBitmapLayout.hpp>
      40             : #include <com/sun/star/beans/XPropertySet.hpp>
      41             : #include <com/sun/star/lang/XServiceInfo.hpp>
      42             : 
      43             : #include <basegfx/matrix/b2dhommatrix.hxx>
      44             : #include <basegfx/range/b2drange.hxx>
      45             : #include <basegfx/range/b2irange.hxx>
      46             : #include <basegfx/range/b2drectangle.hxx>
      47             : #include <basegfx/point/b2dpoint.hxx>
      48             : #include <basegfx/tools/canvastools.hxx>
      49             : #include <basegfx/polygon/b2dpolygon.hxx>
      50             : 
      51             : #include <canvas/verifyinput.hxx>
      52             : #include <canvas/canvastools.hxx>
      53             : 
      54             : 
      55             : using namespace ::com::sun::star;
      56             : 
      57             : namespace canvas
      58             : {
      59             :     namespace tools
      60             :     {
      61           0 :         void verifyInput( const geometry::RealPoint2D&              rPoint,
      62             :                           const char*                               pStr,
      63             :                           const uno::Reference< uno::XInterface >&  xIf,
      64             :                           ::sal_Int16                               nArgPos )
      65             :         {
      66             :             (void)pStr; (void)xIf; (void)nArgPos;
      67             : 
      68             : #if OSL_DEBUG_LEVEL > 0
      69             :             if( !::rtl::math::isFinite( rPoint.X ) )
      70             :             {
      71             :                 throw lang::IllegalArgumentException(
      72             :                     OUString::createFromAscii( pStr ) + ": verifyInput(): point X value contains infinite or NAN",
      73             :                     xIf, nArgPos );
      74             :             }
      75             : 
      76             :             if( !::rtl::math::isFinite( rPoint.Y ) )
      77             :             {
      78             :                 throw lang::IllegalArgumentException(
      79             :                     OUString::createFromAscii( pStr ) + ": verifyInput(): point X value contains infinite or NAN",
      80             :                     xIf, nArgPos );
      81             :             }
      82             : #else
      83           0 :             if( !::rtl::math::isFinite( rPoint.X ) ||
      84           0 :                 !::rtl::math::isFinite( rPoint.Y ) )
      85             :             {
      86           0 :                 throw lang::IllegalArgumentException();
      87             :             }
      88             : #endif
      89           0 :         }
      90             : 
      91           0 :         void verifyInput( const geometry::RealBezierSegment2D&      rSegment,
      92             :                           const char*                               pStr,
      93             :                           const uno::Reference< uno::XInterface >&  xIf,
      94             :                           ::sal_Int16                               nArgPos )
      95             :         {
      96             :             (void)pStr; (void)xIf; (void)nArgPos;
      97             : 
      98             : #if OSL_DEBUG_LEVEL > 0
      99             :             if( !::rtl::math::isFinite( rSegment.Px ) )
     100             :             {
     101             :                 throw lang::IllegalArgumentException(
     102             :                     OUString::createFromAscii( pStr ) +
     103             :                     ": verifyInput(): bezier segment's Px value contains infinite or NAN",
     104             :                     xIf, nArgPos );
     105             :             }
     106             : 
     107             :             if( !::rtl::math::isFinite( rSegment.Py ) )
     108             :             {
     109             :                 throw lang::IllegalArgumentException(
     110             :                     OUString::createFromAscii( pStr ) +
     111             :                     ": verifyInput(): bezier segment's Py value contains infinite or NAN",
     112             :                     xIf, nArgPos );
     113             :             }
     114             : 
     115             :             if( !::rtl::math::isFinite( rSegment.C1x ) )
     116             :             {
     117             :                 throw lang::IllegalArgumentException(
     118             :                     OUString::createFromAscii( pStr ) +
     119             :                     ": verifyInput(): bezier segment's C1x value contains infinite or NAN",
     120             :                     xIf, nArgPos );
     121             :             }
     122             : 
     123             :             if( !::rtl::math::isFinite( rSegment.C1y ) )
     124             :             {
     125             :                 throw lang::IllegalArgumentException(
     126             :                     OUString::createFromAscii( pStr ) +
     127             :                     ": verifyInput(): bezier segment's C1y value contains infinite or NAN",
     128             :                     xIf, nArgPos );
     129             :             }
     130             : 
     131             :             if( !::rtl::math::isFinite( rSegment.C2x ) )
     132             :             {
     133             :                 throw lang::IllegalArgumentException(
     134             :                     OUString::createFromAscii( pStr ) +
     135             :                     ": verifyInput(): bezier segment's C2x value contains infinite or NAN",
     136             :                     xIf, nArgPos );
     137             :             }
     138             : 
     139             :             if( !::rtl::math::isFinite( rSegment.C2y ) )
     140             :             {
     141             :                 throw lang::IllegalArgumentException(
     142             :                     OUString::createFromAscii( pStr ) +
     143             :                     ": verifyInput(): bezier segment's C2y value contains infinite or NAN",
     144             :                     xIf, nArgPos );
     145             :             }
     146             : #else
     147           0 :             if( !::rtl::math::isFinite( rSegment.Px ) ||
     148           0 :                 !::rtl::math::isFinite( rSegment.Py ) ||
     149           0 :                 !::rtl::math::isFinite( rSegment.C1x ) ||
     150           0 :                 !::rtl::math::isFinite( rSegment.C1y ) ||
     151           0 :                 !::rtl::math::isFinite( rSegment.C2x ) ||
     152           0 :                 !::rtl::math::isFinite( rSegment.C2y ) )
     153             :             {
     154           0 :                 throw lang::IllegalArgumentException();
     155             :             }
     156             : #endif
     157           0 :         }
     158             : 
     159           0 :         void verifyInput( const geometry::RealRectangle2D&          rRect,
     160             :                           const char*                               pStr,
     161             :                           const uno::Reference< uno::XInterface >&  xIf,
     162             :                           ::sal_Int16                               nArgPos )
     163             :         {
     164             :             (void)pStr; (void)xIf; (void)nArgPos;
     165             : 
     166             : #if OSL_DEBUG_LEVEL > 0
     167             :             if( !::rtl::math::isFinite( rRect.X1 ) )
     168             :             {
     169             :                 throw lang::IllegalArgumentException(
     170             :                     OUString::createFromAscii(pStr) +
     171             :                     ": verifyInput(): rectangle point X1 contains infinite or NAN",
     172             :                     xIf, nArgPos );
     173             :             }
     174             : 
     175             :             if( !::rtl::math::isFinite( rRect.Y1 ) )
     176             :             {
     177             :                 throw lang::IllegalArgumentException(
     178             :                     OUString::createFromAscii(pStr) +
     179             :                     ": verifyInput(): rectangle point Y1 contains infinite or NAN",
     180             :                     xIf, nArgPos );
     181             :             }
     182             : 
     183             :             if( !::rtl::math::isFinite( rRect.X2 ) )
     184             :             {
     185             :                 throw lang::IllegalArgumentException(
     186             :                     OUString::createFromAscii(pStr) +
     187             :                     ": verifyInput(): rectangle point X2 contains infinite or NAN",
     188             :                     xIf, nArgPos );
     189             :             }
     190             : 
     191             :             if( !::rtl::math::isFinite( rRect.Y2 ) )
     192             :             {
     193             :                 throw lang::IllegalArgumentException(
     194             :                     OUString::createFromAscii(pStr) +
     195             :                     ": verifyInput(): rectangle point Y2 contains infinite or NAN",
     196             :                     xIf, nArgPos );
     197             :             }
     198             : #else
     199           0 :             if( !::rtl::math::isFinite( rRect.X1 ) ||
     200           0 :                 !::rtl::math::isFinite( rRect.Y1 ) ||
     201           0 :                 !::rtl::math::isFinite( rRect.X2 ) ||
     202           0 :                 !::rtl::math::isFinite( rRect.Y2 ) )
     203             :             {
     204           0 :                 throw lang::IllegalArgumentException();
     205             :             }
     206             : #endif
     207           0 :         }
     208             : 
     209          24 :         void verifyInput( const geometry::AffineMatrix2D&           matrix,
     210             :                           const char*                               pStr,
     211             :                           const uno::Reference< uno::XInterface >&  xIf,
     212             :                           ::sal_Int16                               nArgPos )
     213             :         {
     214             :             (void)pStr; (void)xIf; (void)nArgPos;
     215             : 
     216             : #if OSL_DEBUG_LEVEL > 0
     217             :             const sal_Int32 nBinaryState(
     218             :                 100000 * int(!::rtl::math::isFinite( matrix.m00 )) +
     219             :                  10000 * int(!::rtl::math::isFinite( matrix.m01 )) +
     220             :                   1000 * int(!::rtl::math::isFinite( matrix.m02 )) +
     221             :                    100 * int(!::rtl::math::isFinite( matrix.m10 )) +
     222             :                     10 * int(!::rtl::math::isFinite( matrix.m11 )) +
     223             :                      1 * int(!::rtl::math::isFinite( matrix.m12 )) );
     224             : 
     225             :             if( nBinaryState )
     226             :             {
     227             :                 throw lang::IllegalArgumentException(
     228             :                     OUString::createFromAscii(pStr) +
     229             :                     ": verifyInput(): AffineMatrix2D contains infinite or NAN value(s) at the following positions (m00-m12): " +
     230             :                     OUString::number(nBinaryState),
     231             :                     xIf, nArgPos );
     232             :             }
     233             : #else
     234          72 :             if( !::rtl::math::isFinite( matrix.m00 ) ||
     235          48 :                 !::rtl::math::isFinite( matrix.m01 ) ||
     236          48 :                 !::rtl::math::isFinite( matrix.m02 ) ||
     237          48 :                 !::rtl::math::isFinite( matrix.m10 ) ||
     238          72 :                 !::rtl::math::isFinite( matrix.m11 ) ||
     239          24 :                 !::rtl::math::isFinite( matrix.m12 ) )
     240             :             {
     241           0 :                 throw lang::IllegalArgumentException();
     242             :             }
     243             : #endif
     244          24 :         }
     245             : 
     246           0 :         void verifyInput( const geometry::Matrix2D&                 matrix,
     247             :                           const char*                               pStr,
     248             :                           const uno::Reference< uno::XInterface >&  xIf,
     249             :                           ::sal_Int16                               nArgPos )
     250             :         {
     251             :             (void)pStr; (void)xIf; (void)nArgPos;
     252             : 
     253             : #if OSL_DEBUG_LEVEL > 0
     254             :             const sal_Int32 nBinaryState(
     255             :                 1000 * int(!::rtl::math::isFinite( matrix.m00 )) +
     256             :                  100 * int(!::rtl::math::isFinite( matrix.m01 )) +
     257             :                   10 * int(!::rtl::math::isFinite( matrix.m10 )) +
     258             :                    1 * int(!::rtl::math::isFinite( matrix.m11 )) );
     259             : 
     260             :             if( nBinaryState )
     261             :             {
     262             :                 throw lang::IllegalArgumentException(
     263             :                     OUString::createFromAscii(pStr) +
     264             :                     ": verifyInput(): Matrix2D contains infinite or NAN value(s) at the following positions (m00-m11): " +
     265             :                     OUString::number(nBinaryState),
     266             :                     xIf, nArgPos );
     267             :             }
     268             : #else
     269           0 :             if( !::rtl::math::isFinite( matrix.m00 ) ||
     270           0 :                 !::rtl::math::isFinite( matrix.m01 ) ||
     271           0 :                 !::rtl::math::isFinite( matrix.m10 ) ||
     272           0 :                 !::rtl::math::isFinite( matrix.m11 ) )
     273             :             {
     274           0 :                 throw lang::IllegalArgumentException();
     275             :             }
     276             : #endif
     277           0 :         }
     278             : 
     279          12 :         void verifyInput( const rendering::ViewState&               viewState,
     280             :                           const char*                               pStr,
     281             :                           const uno::Reference< uno::XInterface >&  xIf,
     282             :                           ::sal_Int16                               nArgPos )
     283             :         {
     284             :             verifyInput( viewState.AffineTransform,
     285          12 :                          pStr, xIf, nArgPos );
     286          12 :         }
     287             : 
     288          12 :         void verifyInput( const rendering::RenderState&             renderState,
     289             :                           const char*                               pStr,
     290             :                           const uno::Reference< uno::XInterface >&  xIf,
     291             :                           ::sal_Int16                               nArgPos,
     292             :                           sal_Int32                                 nMinColorComponents )
     293             :         {
     294             :             verifyInput( renderState.AffineTransform,
     295          12 :                          pStr, xIf, nArgPos );
     296             : 
     297          12 :             if( renderState.DeviceColor.getLength() < nMinColorComponents )
     298             :             {
     299             : #if OSL_DEBUG_LEVEL > 0
     300             :                 throw lang::IllegalArgumentException(
     301             :                     OUString::createFromAscii(pStr) +
     302             :                     ": verifyInput(): render state's device color has too few components (" +
     303             :                     OUString::number(nMinColorComponents) +
     304             :                     " expected, " +
     305             :                     OUString::number(renderState.DeviceColor.getLength()) +
     306             :                     " provided)",
     307             :                     xIf, nArgPos );
     308             : #else
     309           0 :                 throw lang::IllegalArgumentException();
     310             : #endif
     311             :             }
     312             : 
     313          24 :             if( renderState.CompositeOperation < rendering::CompositeOperation::CLEAR ||
     314          12 :                 renderState.CompositeOperation > rendering::CompositeOperation::SATURATE )
     315             :             {
     316             : #if OSL_DEBUG_LEVEL > 0
     317             :                 throw lang::IllegalArgumentException(
     318             :                     OUString::createFromAscii(pStr) +
     319             :                     ": verifyInput(): render state's CompositeOperation value out of range (" +
     320             :                     OUString::number(sal::static_int_cast<sal_Int32>(renderState.CompositeOperation)) +
     321             :                     " not known)",
     322             :                     xIf, nArgPos );
     323             : #else
     324           0 :                 throw lang::IllegalArgumentException();
     325             : #endif
     326             :             }
     327          12 :         }
     328             : 
     329           0 :         void verifyInput( const rendering::Texture&                 texture,
     330             :                           const char*                               pStr,
     331             :                           const uno::Reference< uno::XInterface >&  xIf,
     332             :                           ::sal_Int16                               nArgPos )
     333             :         {
     334             :             verifyInput( texture.AffineTransform,
     335           0 :                          pStr, xIf, nArgPos );
     336             : 
     337           0 :             if( !::rtl::math::isFinite( texture.Alpha ) ||
     338           0 :                 texture.Alpha < 0.0 ||
     339           0 :                 texture.Alpha > 1.0 )
     340             :             {
     341             : #if OSL_DEBUG_LEVEL > 0
     342             :                 throw lang::IllegalArgumentException(
     343             :                     OUString::createFromAscii(pStr) +
     344             :                     ": verifyInput(): textures' alpha value out of range (is " +
     345             :                     OUString::number(texture.Alpha) + ")",
     346             :                     xIf, nArgPos );
     347             : #else
     348           0 :                 throw lang::IllegalArgumentException();
     349             : #endif
     350             :             }
     351             : 
     352           0 :             if( texture.NumberOfHatchPolygons < 0 )
     353             :             {
     354             : #if OSL_DEBUG_LEVEL > 0
     355             :                 throw lang::IllegalArgumentException(
     356             :                     OUString::createFromAscii(pStr) +
     357             :                     ": verifyInput(): textures' NumberOfHatchPolygons is negative",
     358             :                     xIf, nArgPos );
     359             : #else
     360           0 :                 throw lang::IllegalArgumentException();
     361             : #endif
     362             :             }
     363             : 
     364           0 :             if( texture.RepeatModeX < rendering::TexturingMode::NONE ||
     365           0 :                 texture.RepeatModeX > rendering::TexturingMode::REPEAT )
     366             :             {
     367             : #if OSL_DEBUG_LEVEL > 0
     368             :                 throw lang::IllegalArgumentException(
     369             :                     OUString::createFromAscii(pStr) +
     370             :                     ": verifyInput(): textures' RepeatModeX value is out of range (" +
     371             :                     OUString::number(sal::static_int_cast<sal_Int32>(texture.RepeatModeX)) +
     372             :                     " not known)",
     373             :                     xIf, nArgPos );
     374             : #else
     375           0 :                 throw lang::IllegalArgumentException();
     376             : #endif
     377             :             }
     378             : 
     379           0 :             if( texture.RepeatModeY < rendering::TexturingMode::NONE ||
     380           0 :                 texture.RepeatModeY > rendering::TexturingMode::REPEAT )
     381             :             {
     382             : #if OSL_DEBUG_LEVEL > 0
     383             :                 throw lang::IllegalArgumentException(
     384             :                     OUString::createFromAscii(pStr) +
     385             :                     ": verifyInput(): textures' RepeatModeY value is out of range (" +
     386             :                     OUString::number(sal::static_int_cast<sal_Int32>(texture.RepeatModeY)) +
     387             :                     " not known)",
     388             :                     xIf, nArgPos );
     389             : #else
     390           0 :                 throw lang::IllegalArgumentException();
     391             : #endif
     392             :             }
     393           0 :         }
     394             : 
     395             :         namespace
     396             :         {
     397             :             struct VerifyDashValue
     398             :             {
     399           8 :                 VerifyDashValue( const char*                                pStr,
     400             :                                  const uno::Reference< uno::XInterface >&   xIf,
     401             :                                  ::sal_Int16                                nArgPos ) :
     402             :                     mpStr( pStr ),
     403             :                     mrIf( xIf ),
     404           8 :                     mnArgPos( nArgPos )
     405             :                 {
     406           8 :                 }
     407             : 
     408           0 :                 void operator()( const double& rVal )
     409             :                 {
     410           0 :                     if( !::rtl::math::isFinite( rVal ) || rVal < 0.0 )
     411             :                     {
     412             : #if OSL_DEBUG_LEVEL > 0
     413             :                         throw lang::IllegalArgumentException(
     414             :                             OUString::createFromAscii(mpStr) +
     415             :                             ": verifyInput(): one of stroke attributes' DashArray value out of range (is " +
     416             :                             OUString::number(rVal) + ")",
     417             :                             mrIf, mnArgPos );
     418             : #else
     419           0 :                         throw lang::IllegalArgumentException();
     420             : #endif
     421             :                     }
     422           0 :                 }
     423             : 
     424             :                 const char*                                 mpStr;
     425             :                 const uno::Reference< uno::XInterface >&    mrIf;
     426             :                 sal_Int16                                   mnArgPos;
     427             :             };
     428             :         }
     429             : 
     430           4 :         void verifyInput( const rendering::StrokeAttributes&        strokeAttributes,
     431             :                           const char*                               pStr,
     432             :                           const uno::Reference< uno::XInterface >&  xIf,
     433             :                           ::sal_Int16                               nArgPos )
     434             :         {
     435           8 :             if( !::rtl::math::isFinite( strokeAttributes.StrokeWidth ) ||
     436           4 :                 strokeAttributes.StrokeWidth < 0.0 )
     437             :             {
     438             : #if OSL_DEBUG_LEVEL > 0
     439             :                 throw lang::IllegalArgumentException(
     440             :                     OUString::createFromAscii(pStr) +
     441             :                     ": verifyInput(): stroke attributes' StrokeWidth value out of range (is " +
     442             :                     OUString::number(strokeAttributes.StrokeWidth) +
     443             :                     ")",
     444             :                     xIf, nArgPos );
     445             : #else
     446           0 :                 throw lang::IllegalArgumentException();
     447             : #endif
     448             :             }
     449             : 
     450           8 :             if( !::rtl::math::isFinite( strokeAttributes.MiterLimit ) ||
     451           4 :                 strokeAttributes.MiterLimit < 0.0 )
     452             :             {
     453             : #if OSL_DEBUG_LEVEL > 0
     454             :                 throw lang::IllegalArgumentException(
     455             :                     OUString::createFromAscii(pStr) +
     456             :                     ": verifyInput(): stroke attributes' MiterLimit value out of range (is " +
     457             :                     OUString::number(strokeAttributes.MiterLimit) + ")",
     458             :                     xIf, nArgPos );
     459             : #else
     460           0 :                 throw lang::IllegalArgumentException();
     461             : #endif
     462             :             }
     463             : 
     464             :             ::std::for_each( strokeAttributes.DashArray.getConstArray(),
     465           4 :                              strokeAttributes.DashArray.getConstArray() + strokeAttributes.DashArray.getLength(),
     466           8 :                              VerifyDashValue( pStr, xIf, nArgPos ) );
     467             : 
     468             :             ::std::for_each( strokeAttributes.LineArray.getConstArray(),
     469           4 :                              strokeAttributes.LineArray.getConstArray() + strokeAttributes.LineArray.getLength(),
     470           8 :                              VerifyDashValue( pStr, xIf, nArgPos ) );
     471             : 
     472           8 :             if( strokeAttributes.StartCapType < rendering::PathCapType::BUTT ||
     473           4 :                 strokeAttributes.StartCapType > rendering::PathCapType::SQUARE )
     474             :             {
     475             : #if OSL_DEBUG_LEVEL > 0
     476             :                 throw lang::IllegalArgumentException(
     477             :                     OUString::createFromAscii(pStr) +
     478             :                     ": verifyInput(): stroke attributes' StartCapType value is out of range (" +
     479             :                     OUString::number(sal::static_int_cast<sal_Int32>(strokeAttributes.StartCapType)) +
     480             :                     " not known)",
     481             :                     xIf, nArgPos );
     482             : #else
     483           0 :                 throw lang::IllegalArgumentException();
     484             : #endif
     485             :             }
     486             : 
     487           8 :             if( strokeAttributes.EndCapType < rendering::PathCapType::BUTT ||
     488           4 :                 strokeAttributes.EndCapType > rendering::PathCapType::SQUARE )
     489             :             {
     490             : #if OSL_DEBUG_LEVEL > 0
     491             :                 throw lang::IllegalArgumentException(
     492             :                     OUString::createFromAscii(pStr) +
     493             :                     ": verifyInput(): stroke attributes' StartCapType value is out of range (" +
     494             :                     OUString::number(sal::static_int_cast<sal_Int32>(strokeAttributes.EndCapType)) +
     495             :                     " not known)",
     496             :                     xIf, nArgPos );
     497             : #else
     498           0 :                 throw lang::IllegalArgumentException();
     499             : #endif
     500             :             }
     501             : 
     502           8 :             if( strokeAttributes.JoinType < rendering::PathJoinType::NONE ||
     503           4 :                 strokeAttributes.JoinType > rendering::PathJoinType::BEVEL )
     504             :             {
     505             : #if OSL_DEBUG_LEVEL > 0
     506             :                 throw lang::IllegalArgumentException(
     507             :                     OUString::createFromAscii(pStr) +
     508             :                     ": verifyInput(): stroke attributes' JoinType value is out of range (" +
     509             :                     OUString::number(sal::static_int_cast<sal_Int32>(strokeAttributes.JoinType)) +
     510             :                     " not known)",
     511             :                     xIf, nArgPos );
     512             : #else
     513           0 :                 throw lang::IllegalArgumentException();
     514             : #endif
     515             :             }
     516           4 :         }
     517             : 
     518           0 :         void verifyInput( const rendering::IntegerBitmapLayout&     bitmapLayout,
     519             :                           const char*                               pStr,
     520             :                           const uno::Reference< uno::XInterface >&  xIf,
     521             :                           ::sal_Int16                               nArgPos )
     522             :         {
     523             :             (void)pStr; (void)xIf; (void)nArgPos;
     524             : 
     525           0 :             if( bitmapLayout.ScanLines < 0 )
     526             :             {
     527             : #if OSL_DEBUG_LEVEL > 0
     528             :                 throw lang::IllegalArgumentException(
     529             :                     OUString::createFromAscii(pStr) +
     530             :                     ": verifyInput(): bitmap layout's ScanLines is negative",
     531             :                     xIf, nArgPos );
     532             : #else
     533           0 :                 throw lang::IllegalArgumentException();
     534             : #endif
     535             :             }
     536             : 
     537           0 :             if( bitmapLayout.ScanLineBytes < 0 )
     538             :             {
     539             : #if OSL_DEBUG_LEVEL > 0
     540             :                 throw lang::IllegalArgumentException(
     541             :                     OUString::createFromAscii(pStr) +
     542             :                     ": verifyInput(): bitmap layout's ScanLineBytes is negative",
     543             :                     xIf, nArgPos );
     544             : #else
     545           0 :                 throw lang::IllegalArgumentException();
     546             : #endif
     547             :             }
     548             : 
     549           0 :             if( !bitmapLayout.ColorSpace.is() )
     550             :             {
     551             : #if OSL_DEBUG_LEVEL > 0
     552             :                 throw lang::IllegalArgumentException(
     553             :                     OUString::createFromAscii(pStr) +
     554             :                     ": verifyInput(): bitmap layout's ColorSpace is invalid",
     555             :                     xIf, nArgPos );
     556             : #else
     557           0 :                 throw lang::IllegalArgumentException();
     558             : #endif
     559             :             }
     560             :             else
     561             :             {
     562           0 :                 if( bitmapLayout.ColorSpace->getBitsPerPixel() < 0 )
     563             :                 {
     564             : #if OSL_DEBUG_LEVEL > 0
     565             :                     throw lang::IllegalArgumentException(
     566             :                         OUString::createFromAscii(pStr) +
     567             :                         ": verifyInput(): bitmap layout's ColorSpace getBitsPerPixel() is negative",
     568             :                         xIf, nArgPos );
     569             : #else
     570           0 :                     throw lang::IllegalArgumentException();
     571             : #endif
     572             :                 }
     573             : 
     574           0 :                 if( bitmapLayout.ColorSpace->getEndianness() < util::Endianness::LITTLE ||
     575           0 :                     bitmapLayout.ColorSpace->getEndianness() > util::Endianness::BIG )
     576             :                 {
     577             : #if OSL_DEBUG_LEVEL > 0
     578             :                     throw lang::IllegalArgumentException(
     579             :                         OUString::createFromAscii(pStr) +
     580             :                         ": verifyInput(): bitmap layout's ColorSpace getEndianness() value is out of range (" +
     581             :                         OUString::number(sal::static_int_cast<sal_Int32>(bitmapLayout.ColorSpace->getEndianness())) +
     582             :                         " not known)",
     583             :                         xIf, nArgPos );
     584             : #else
     585           0 :                     throw lang::IllegalArgumentException();
     586             : #endif
     587             :                 }
     588             :             }
     589           0 :         }
     590             : 
     591           0 :         void verifyInput( const rendering::FontInfo&                /*fontInfo*/,
     592             :                           const char*                               /*pStr*/,
     593             :                           const uno::Reference< uno::XInterface >&  /*xIf*/,
     594             :                           ::sal_Int16                               /*nArgPos*/ )
     595             :         {
     596             :             // TODO(E3): Implement FontDescription checks, once the
     597             :             // Panose stuff is ready.
     598           0 :         }
     599             : 
     600           0 :         void verifyInput( const rendering::FontRequest&             fontRequest,
     601             :                           const char*                               pStr,
     602             :                           const uno::Reference< uno::XInterface >&  xIf,
     603             :                           ::sal_Int16                               nArgPos )
     604             :         {
     605             :             verifyInput( fontRequest.FontDescription,
     606           0 :                          pStr, xIf, nArgPos );
     607             : 
     608           0 :             if( !::rtl::math::isFinite( fontRequest.CellSize ) )
     609             :             {
     610             : #if OSL_DEBUG_LEVEL > 0
     611             :                 throw lang::IllegalArgumentException(
     612             :                     OUString::createFromAscii(pStr) +
     613             :                     ": verifyInput(): font request's CellSize value contains infinite or NAN",
     614             :                     xIf, nArgPos );
     615             : #else
     616           0 :                 throw lang::IllegalArgumentException();
     617             : #endif
     618             :             }
     619             : 
     620           0 :             if( !::rtl::math::isFinite( fontRequest.ReferenceAdvancement ) )
     621             :             {
     622             : #if OSL_DEBUG_LEVEL > 0
     623             :                 throw lang::IllegalArgumentException(
     624             :                     OUString::createFromAscii(pStr) +
     625             :                     ": verifyInput(): font request's ReferenceAdvancement value contains infinite or NAN",
     626             :                     xIf, nArgPos );
     627             : #else
     628           0 :                 throw lang::IllegalArgumentException();
     629             : #endif
     630             :             }
     631             : 
     632           0 :             if( fontRequest.CellSize != 0.0 &&
     633           0 :                 fontRequest.ReferenceAdvancement != 0.0 )
     634             :             {
     635             : #if OSL_DEBUG_LEVEL > 0
     636             :                 throw lang::IllegalArgumentException(
     637             :                     OUString::createFromAscii(pStr) +
     638             :                     ": verifyInput(): font request's CellSize and ReferenceAdvancement are mutually exclusive, one of them must be 0.0",
     639             :                     xIf, nArgPos );
     640             : #else
     641           0 :                 throw lang::IllegalArgumentException();
     642             : #endif
     643             :             }
     644           0 :         }
     645             : 
     646           0 :         void verifyIndexRange( const geometry::IntegerRectangle2D&  rect,
     647             :                                const geometry::IntegerSize2D&       size )
     648             :         {
     649             :             const ::basegfx::B2IRange aRect(
     650             :                 ::basegfx::unotools::b2IRectangleFromIntegerRectangle2D(
     651           0 :                     rect ) );
     652             : 
     653           0 :             if( aRect.getMinX() < 0 ||
     654           0 :                 aRect.getMaxX() > size.Width ||
     655           0 :                 aRect.getMinY() < 0 ||
     656           0 :                 aRect.getMaxY() > size.Height )
     657             :             {
     658           0 :                 throw ::com::sun::star::lang::IndexOutOfBoundsException();
     659             :             }
     660           0 :         }
     661             : 
     662           0 :         void verifyIndexRange( const geometry::IntegerPoint2D& pos,
     663             :                                const geometry::IntegerSize2D&  size )
     664             :         {
     665           0 :             if( pos.X < 0 ||
     666           0 :                 pos.X > size.Width ||
     667           0 :                 pos.Y < 0 ||
     668           0 :                 pos.Y > size.Height )
     669             :             {
     670           0 :                 throw ::com::sun::star::lang::IndexOutOfBoundsException();
     671             :             }
     672           0 :         }
     673             : 
     674           2 :         void verifyBitmapSize( const geometry::IntegerSize2D&           size,
     675             :                                const char*                              pStr,
     676             :                                const uno::Reference< uno::XInterface >& xIf )
     677             :         {
     678             :             (void)pStr; (void)xIf;
     679             : 
     680           2 :             if( size.Width <= 0 )
     681             :             {
     682             : #if OSL_DEBUG_LEVEL > 0
     683             :                 throw lang::IllegalArgumentException(
     684             :                     OUString::createFromAscii(pStr) +
     685             :                     ": verifyBitmapSize(): size has 0 or negative width (value: " +
     686             :                     OUString::number(size.Width) + ")",
     687             :                     xIf, 0 );
     688             : #else
     689           0 :                 throw lang::IllegalArgumentException();
     690             : #endif
     691             :             }
     692             : 
     693           2 :             if( size.Height <= 0 )
     694             :             {
     695             : #if OSL_DEBUG_LEVEL > 0
     696             :                 throw lang::IllegalArgumentException(
     697             :                     OUString::createFromAscii(pStr) +
     698             :                     ": verifyBitmapSize(): size has 0 or negative height (value: " +
     699             :                     OUString::number(size.Height) +
     700             :                     ")",
     701             :                     xIf, 0 );
     702             : #else
     703           0 :                 throw lang::IllegalArgumentException();
     704             : #endif
     705             :             }
     706           2 :         }
     707             : 
     708           0 :         void verifySpriteSize( const geometry::RealSize2D&              size,
     709             :                                const char*                              pStr,
     710             :                                const uno::Reference< uno::XInterface >& xIf )
     711             :         {
     712             :             (void)pStr; (void)xIf;
     713             : 
     714           0 :             if( size.Width <= 0.0 )
     715             :             {
     716             : #if OSL_DEBUG_LEVEL > 0
     717             :                 throw lang::IllegalArgumentException(
     718             :                     OUString::createFromAscii(pStr) +
     719             :                     ": verifySpriteSize(): size has 0 or negative width (value: " +
     720             :                     OUString::number(size.Width) + ")",
     721             :                     xIf, 0 );
     722             : #else
     723           0 :                 throw lang::IllegalArgumentException();
     724             : #endif
     725             :             }
     726             : 
     727           0 :             if( size.Height <= 0.0 )
     728             :             {
     729             : #if OSL_DEBUG_LEVEL > 0
     730             :                 throw lang::IllegalArgumentException(
     731             :                     OUString::createFromAscii(pStr) +
     732             :                     ": verifySpriteSize(): size has 0 or negative height (value: " +
     733             :                     OUString::number(size.Height) + ")",
     734             :                     xIf, 0 );
     735             : #else
     736           0 :                 throw lang::IllegalArgumentException();
     737             : #endif
     738             :             }
     739           0 :         }
     740             : 
     741             : 
     742             :     } // namespace tools
     743             : 
     744         753 : } // namespace canvas
     745             : 
     746             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11