LCOV - code coverage report
Current view: top level - include/canvas - canvastools.hxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 4 36 11.1 %
Date: 2014-11-03 Functions: 5 16 31.2 %
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             : #ifndef INCLUDED_CANVAS_CANVASTOOLS_HXX
      21             : #define INCLUDED_CANVAS_CANVASTOOLS_HXX
      22             : 
      23             : #include <rtl/math.hxx>
      24             : #include <com/sun/star/uno/Reference.hxx>
      25             : #include <com/sun/star/uno/Sequence.hxx>
      26             : #include <com/sun/star/uno/RuntimeException.hpp>
      27             : #include <com/sun/star/lang/IllegalArgumentException.hpp>
      28             : #include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
      29             : #include <osl/diagnose.h>
      30             : #include <rtl/ustring.hxx>
      31             : 
      32             : #include <string.h>
      33             : #include <vector>
      34             : #include <limits>
      35             : #include <algorithm>
      36             : 
      37             : #include <canvas/canvastoolsdllapi.h>
      38             : 
      39             : namespace basegfx
      40             : {
      41             :     class B2DHomMatrix;
      42             :     class B2DRange;
      43             :     class B2IRange;
      44             :     class B2IPoint;
      45             :     class B2DPolyPolygon;
      46             : }
      47             : 
      48             : namespace com { namespace sun { namespace star { namespace geometry
      49             : {
      50             :     struct RealSize2D;
      51             :     struct IntegerSize2D;
      52             :     struct AffineMatrix2D;
      53             :     struct Matrix2D;
      54             : } } } }
      55             : 
      56             : namespace com { namespace sun { namespace star { namespace rendering
      57             : {
      58             :     struct RenderState;
      59             :     struct ViewState;
      60             :     struct IntegerBitmapLayout;
      61             :     class  XCanvas;
      62             :     struct Texture;
      63             :     class  XIntegerBitmapColorSpace;
      64             :     class  XPolyPolygon2D;
      65             : 
      66             :     bool operator==( const RenderState& rLHS,
      67             :                      const RenderState& rRHS );
      68             : 
      69             :     bool operator==( const ViewState& rLHS,
      70             :                      const ViewState& rRHS );
      71             : } } } }
      72             : 
      73             : namespace com { namespace sun { namespace star { namespace awt
      74             : {
      75             :     struct Rectangle;
      76             :     class  XWindow2;
      77             : } } } }
      78             : 
      79             : class Color;
      80             : 
      81             : namespace canvas
      82             : {
      83             :     namespace tools
      84             :     {
      85             :         /** Compute the next highest power of 2 of a 32-bit value
      86             : 
      87             :             Code devised by Sean Anderson, in good ole HAKMEM
      88             :             tradition.
      89             : 
      90             :             @return 1 << (lg(x - 1) + 1)
      91             :         */
      92           0 :         inline sal_uInt32 nextPow2( sal_uInt32 x )
      93             :         {
      94           0 :             --x;
      95           0 :             x |= x >> 1;
      96           0 :             x |= x >> 2;
      97           0 :             x |= x >> 4;
      98           0 :             x |= x >> 8;
      99           0 :             x |= x >> 16;
     100             : 
     101           0 :             return ++x;
     102             :         }
     103             : 
     104             :         /**
     105             :          *
     106             :          * Count the number of 1-bits of an n-bit value
     107             :          *
     108             :          */
     109             : 
     110             :         // mickey's math tricks...
     111             :         inline unsigned int pow2( unsigned int c ) { return 0x1 << c; }
     112             :         inline unsigned int mask( unsigned int c ) { return ((unsigned int)(-1)) / (pow2(pow2(c)) + 1); }
     113             :         inline unsigned int count( unsigned int x, unsigned int c ) { return ((x) & mask(c)) + (((x) >> (pow2(c))) & mask(c)); }
     114             :         template<typename T>
     115             :         inline unsigned int bitcount( T c ) {
     116             :             unsigned int nByteIndex = 0;
     117             :             unsigned int nNumBytes = sizeof(T)<<2;
     118             :             do {
     119             :                 c=count(c,nByteIndex++);
     120             :                 nNumBytes >>= 1;
     121             :             } while(nNumBytes);
     122             :             return c;
     123             :         }
     124             :         inline sal_uInt32 bitcount32( sal_uInt32 c ) {
     125             :             c=count(c,0);
     126             :             c=count(c,1);
     127             :             c=count(c,2);
     128             :             c=count(c,3);
     129             :             c=count(c,4);
     130             :             return c;
     131             :         }
     132             : 
     133             :         /** Round given floating point value down to next integer
     134             :          */
     135           0 :         inline sal_Int32 roundDown( const double& rVal )
     136             :         {
     137           0 :             return static_cast< sal_Int32 >( floor( rVal ) );
     138             :         }
     139             : 
     140             :         /** Round given floating point value up to next integer
     141             :          */
     142           0 :         inline sal_Int32 roundUp( const double& rVal )
     143             :         {
     144           0 :             return static_cast< sal_Int32 >( ceil( rVal ) );
     145             :         }
     146             : 
     147             :         /** Create a RealSize2D with both coordinate values set to +infinity
     148             :          */
     149             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::geometry::RealSize2D createInfiniteSize2D();
     150             : 
     151             : 
     152             :         // View- and RenderState utilities
     153             : 
     154             : 
     155             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::RenderState&
     156             :             initRenderState( ::com::sun::star::rendering::RenderState&                      renderState );
     157             : 
     158             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::ViewState&
     159             :             initViewState( ::com::sun::star::rendering::ViewState&                          viewState );
     160             : 
     161             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix&
     162             :             getViewStateTransform( ::basegfx::B2DHomMatrix&                                 transform,
     163             :                                    const ::com::sun::star::rendering::ViewState&            viewState );
     164             : 
     165             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::ViewState&
     166             :             setViewStateTransform( ::com::sun::star::rendering::ViewState&                  viewState,
     167             :                                    const ::basegfx::B2DHomMatrix&                           transform );
     168             : 
     169             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix&
     170             :             getRenderStateTransform( ::basegfx::B2DHomMatrix&                               transform,
     171             :                                      const ::com::sun::star::rendering::RenderState&        renderState );
     172             : 
     173             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::RenderState&
     174             :             setRenderStateTransform( ::com::sun::star::rendering::RenderState&              renderState,
     175             :                                      const ::basegfx::B2DHomMatrix&                         transform );
     176             : 
     177             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::RenderState&
     178             :             appendToRenderState( ::com::sun::star::rendering::RenderState&                  renderState,
     179             :                                  const ::basegfx::B2DHomMatrix&                             transform );
     180             : 
     181             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::RenderState&
     182             :             prependToRenderState( ::com::sun::star::rendering::RenderState&                 renderState,
     183             :                                   const ::basegfx::B2DHomMatrix&                            transform );
     184             : 
     185             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix&
     186             :             mergeViewAndRenderTransform( ::basegfx::B2DHomMatrix&                           transform,
     187             :                                          const ::com::sun::star::rendering::ViewState&      viewState,
     188             :                                          const ::com::sun::star::rendering::RenderState&    renderState );
     189             : 
     190             : 
     191             :         // Matrix utilities
     192             : 
     193             : 
     194             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::geometry::AffineMatrix2D&
     195             :             setIdentityAffineMatrix2D( ::com::sun::star::geometry::AffineMatrix2D&  matrix );
     196             : 
     197             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::geometry::Matrix2D&
     198             :             setIdentityMatrix2D( ::com::sun::star::geometry::Matrix2D&              matrix );
     199             : 
     200             : 
     201             :         // Special utilities
     202             : 
     203             : 
     204             :         /** Calc the bounding rectangle of a transformed rectangle.
     205             : 
     206             :             The method applies the given transformation to the
     207             :             specified input rectangle, and returns the bounding box of
     208             :             the resulting output area.
     209             : 
     210             :             @param o_Rect
     211             :             Output rectangle
     212             : 
     213             :             @param i_Rect
     214             :             Input rectangle
     215             : 
     216             :             @param i_Transformation
     217             :             Transformation to apply to the input rectangle
     218             : 
     219             :             @return a reference to the resulting rectangle
     220             :          */
     221             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DRange& calcTransformedRectBounds( ::basegfx::B2DRange&          o_Rect,
     222             :                                                         const ::basegfx::B2DRange&      i_Rect,
     223             :                                                         const ::basegfx::B2DHomMatrix&  i_Transformation );
     224             : 
     225             :         /** Calc a transform that maps the upper, left corner of a
     226             :              rectangle to the origin.
     227             : 
     228             :             The method is a specialized version of
     229             :             calcRectToRectTransform() (Removed now), mapping the input rectangle's
     230             :             the upper, left corner to the origin, and leaving the size
     231             :             untouched.
     232             : 
     233             :             @param o_transform
     234             :             Output parameter, to receive the resulting transformation
     235             :             matrix.
     236             : 
     237             :             @param i_srcRect
     238             :             Input parameter, specifies the original source
     239             :             rectangle. The resulting transformation will exactly map
     240             :             the source rectangle's upper, left corner to the origin.
     241             : 
     242             :             @param i_transformation
     243             :             The original transformation matrix. This is changed with
     244             :             translations (if necessary), to exactly map the source
     245             :             rectangle to the origin.
     246             : 
     247             :             @return a reference to the resulting transformation matrix
     248             : 
     249             :             @see calcRectToRectTransform()
     250             :             @see calcTransformedRectBounds()
     251             :         */
     252             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix& calcRectToOriginTransform( ::basegfx::B2DHomMatrix&      o_transform,
     253             :                                                             const ::basegfx::B2DRange&      i_srcRect,
     254             :                                                             const ::basegfx::B2DHomMatrix&  i_transformation );
     255             : 
     256             :         /** Check whether a given rectangle is within another
     257             :             transformed rectangle.
     258             : 
     259             :             This method checks for polygonal containedness, i.e. the
     260             :             transformed rectangle is not represented as an axis-alignd
     261             :             rectangle anymore (like calcTransformedRectBounds()), but
     262             :             polygonal. Thus, the insideness test is based on tight
     263             :             bounds.
     264             : 
     265             :             @param rContainedRect
     266             :             This rectangle is checked, whether it is fully within the
     267             :             transformed rTransformRect.
     268             : 
     269             :             @param rTransformRect
     270             :             This rectangle is transformed, and then checked whether it
     271             :             fully contains rContainedRect.
     272             : 
     273             :             @param rTransformation
     274             :             This transformation is applied to rTransformRect
     275             :          */
     276             :         CANVASTOOLS_DLLPUBLIC bool isInside( const ::basegfx::B2DRange&         rContainedRect,
     277             :                        const ::basegfx::B2DRange&       rTransformRect,
     278             :                        const ::basegfx::B2DHomMatrix&   rTransformation );
     279             : 
     280             :         /** Clip a scroll to the given bound rect
     281             : 
     282             :             @param io_rSourceArea
     283             :             Source area to scroll. The resulting clipped source area
     284             :             is returned therein.
     285             : 
     286             :             @param io_rDestPoint
     287             :             Destination point of the scroll (upper, left corner of
     288             :             rSourceArea after the scroll). The new, resulting
     289             :             destination point is returned therein.q
     290             : 
     291             :             @param o_ClippedAreas
     292             :             Vector of rectangles in the <em>destination</em> area
     293             :             coordinate system, which are clipped away from the source
     294             :             area, and thus need extra updates (i.e. they are not
     295             :             correctly copy from the scroll operation, since there was
     296             :             no information about them in the source).
     297             : 
     298             :             @param rBounds
     299             :             Bounds to clip against.
     300             : 
     301             :             @return false, if the resulting scroll area is empty
     302             :          */
     303             :         CANVASTOOLS_DLLPUBLIC bool clipScrollArea( ::basegfx::B2IRange&                  io_rSourceArea,
     304             :                              ::basegfx::B2IPoint&                  io_rDestPoint,
     305             :                              ::std::vector< ::basegfx::B2IRange >& o_ClippedAreas,
     306             :                              const ::basegfx::B2IRange&            rBounds );
     307             : 
     308             :         /** Clip a blit between two differently surfaces.
     309             : 
     310             :             This method clips source and dest rect for a clip between
     311             :             two differently clipped surfaces, such that the resulting
     312             :             blit rects are fully within both clip areas.
     313             : 
     314             :             @param io_rSourceArea
     315             :             Source area of the blit. Returned therein is the computed
     316             :             clipped source area.
     317             : 
     318             :             @param io_rDestPoint
     319             :             Dest area of the blit. Returned therein is the computed
     320             :             clipped dest area.
     321             : 
     322             :             @param rSourceBounds
     323             :             Clip bounds of the source surface
     324             : 
     325             :             @param rDestBounds
     326             :             Clip bounds of the dest surface
     327             : 
     328             :             @return false, if the resulting blit is empty, i.e. fully
     329             :             clipped away.
     330             :          */
     331             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2IRange spritePixelAreaFromB2DRange( const ::basegfx::B2DRange& rRange );
     332             : 
     333             :         /** Retrieve various internal properties of the actual canvas implementation.
     334             : 
     335             :             This method retrieves a bunch of internal, implementation-
     336             :             and platform-dependent values from the canvas
     337             :             implementation. Among them are for example operating
     338             :             system window handles. The actual layout and content of
     339             :             the returned sequence is dependent on the component
     340             :             implementation, undocumented and subject to change.
     341             : 
     342             :             @param i_rxCanvas
     343             :             Input parameter, the canvas representation for which the device information
     344             :             is to be retrieveds
     345             : 
     346             :             @param o_rxParams
     347             :             Output parameter, the sequence of Anys that hold the device parameters. Layout is as described above
     348             : 
     349             :             @return A reference to the resulting sequence of parameters
     350             :         */
     351             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& getDeviceInfo(
     352             :             const ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XCanvas >& i_rxCanvas,
     353             :             ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& o_rxParams );
     354             : 
     355             :         /** Return a color space for a default RGBA integer format
     356             : 
     357             :             Use this method for dead-simple bitmap implementations,
     358             :             that map all their formats to 8888 RGBA color.
     359             :          */
     360             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XIntegerBitmapColorSpace> getStdColorSpace();
     361             : 
     362             :         /** Return a color space for a default RGB integer format
     363             : 
     364             :             Use this method for dead-simple bitmap implementations,
     365             :             that map all their formats to 8888 RGB color (the last byte
     366             :             is unused).
     367             :          */
     368             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::rendering::XIntegerBitmapColorSpace> getStdColorSpaceWithoutAlpha();
     369             : 
     370             :         /** Return a memory layout for a default RGBA integer format
     371             : 
     372             :             Use this method for dead-simple bitmap implementations,
     373             :             that map all their formats to 8888 RGBA color.
     374             :          */
     375             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::rendering::IntegerBitmapLayout getStdMemoryLayout(
     376             :             const ::com::sun::star::geometry::IntegerSize2D& rBitmapSize );
     377             : 
     378             :         /// Convert standard 8888 RGBA color to vcl color
     379             :         CANVASTOOLS_DLLPUBLIC ::Color stdIntSequenceToColor( const ::com::sun::star::uno::Sequence<sal_Int8>& rColor );
     380             : 
     381             :         /// Convert standard 8888 RGBA color to vcl color
     382             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::uno::Sequence<sal_Int8> colorToStdIntSequence( const ::Color& rColor );
     383             : 
     384             :         // Modelled closely after boost::numeric_cast, only that we
     385             :         // issue some trace output here and throw a RuntimeException
     386             : 
     387             :         /** Cast numeric value into another (numeric) data type
     388             : 
     389             :             Apart from converting the numeric value, this template
     390             :             also checks if any overflow, underflow, or sign
     391             :             information is lost (if yes, it throws an
     392             :             uno::RuntimeException.
     393             :          */
     394           0 :         template< typename Target, typename Source > inline Target numeric_cast( Source arg )
     395             :         {
     396             :             // typedefs abbreviating respective trait classes
     397             :             typedef ::std::numeric_limits< Source > SourceLimits;
     398             :             typedef ::std::numeric_limits< Target > TargetLimits;
     399             : 
     400             : #undef min
     401             : #undef max
     402             : 
     403           0 :             if( ( arg<0 && !TargetLimits::is_signed) ||                     // losing the sign here
     404           0 :                 ( SourceLimits::is_signed && arg<TargetLimits::min()) ||    // underflow will happen
     405           0 :                 ( arg>TargetLimits::max() ) )                               // overflow will happen
     406             :             {
     407             : # if OSL_DEBUG_LEVEL > 2
     408             :                 OSL_TRACE("numeric_cast detected data loss");
     409             : #endif
     410           0 :                 throw ::com::sun::star::uno::RuntimeException(
     411             :                     "numeric_cast detected data loss",
     412           0 :                     NULL );
     413             :             }
     414             : 
     415           0 :             return static_cast<Target>(arg);
     416             :         }
     417             : 
     418             :         CANVASTOOLS_DLLPUBLIC ::com::sun::star::awt::Rectangle getAbsoluteWindowRect(
     419             :             const ::com::sun::star::awt::Rectangle&                                    rRect,
     420             :             const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow2 >& xWin  );
     421             : 
     422             :         /** Retrieve for small bound marks around each corner of the given rectangle
     423             :          */
     424             :         CANVASTOOLS_DLLPUBLIC ::basegfx::B2DPolyPolygon getBoundMarksPolyPolygon( const ::basegfx::B2DRange& rRange );
     425             : 
     426             :         /** Calculate number of gradient "strips" to generate (takes
     427             :            into account device resolution)
     428             : 
     429             :            @param nColorSteps
     430             :            Maximal integer difference between all color stops, needed
     431             :            for smooth gradient color differences
     432             :          */
     433             :         CANVASTOOLS_DLLPUBLIC int calcGradientStepCount( ::basegfx::B2DHomMatrix&                        rTotalTransform,
     434             :                                    const ::com::sun::star::rendering::ViewState&   viewState,
     435             :                                    const ::com::sun::star::rendering::RenderState& renderState,
     436             :                                    const ::com::sun::star::rendering::Texture&     texture,
     437             :                                    int                                             nColorSteps );
     438             : 
     439             :         /** A very simplistic map for ASCII strings and arbitrary value
     440             :             types.
     441             : 
     442             :             This class internally references a constant, static array of
     443             :             sorted MapEntries, and performs a binary search to look up
     444             :             values for a given query string. Note that this map is static,
     445             :             i.e. not meant to be extented at runtime.
     446             : 
     447             :             @tpl ValueType
     448             :             The value type this map should store, associated with an ASCII
     449             :             string.
     450             :         */
     451             :         template< typename ValueType > class ValueMap
     452             :         {
     453             :         public:
     454          76 :             struct MapEntry
     455             :             {
     456             :                 const char*     maKey;
     457             :                 ValueType       maValue;
     458             :             };
     459             : 
     460             :             /** Create a ValueMap for the given array of MapEntries.
     461             : 
     462             :                 @param pMap
     463             :                 Pointer to a <em>static</em> array of MapEntries. Must
     464             :                 live longer than this object! Make absolutely sure that
     465             :                 the string entries passed via pMap are ASCII-only -
     466             :                 everything else might not yield correct string
     467             :                 comparisons, and thus will result in undefined behaviour.
     468             : 
     469             :                 @param nEntries
     470             :                 Number of entries for pMap
     471             : 
     472             :                 @param bCaseSensitive
     473             :                 Whether the map query should be performed case sensitive
     474             :                 or not. When bCaseSensitive is false, all MapEntry strings
     475             :                 must be lowercase!
     476             :             */
     477           2 :             ValueMap( const MapEntry*   pMap,
     478             :                       ::std::size_t     nEntries,
     479             :                       bool              bCaseSensitive ) :
     480             :                 mpMap( pMap ),
     481             :                 mnEntries( nEntries ),
     482           2 :                 mbCaseSensitive( bCaseSensitive )
     483             :             {
     484             : #ifdef DBG_UTIL
     485             :                 // Ensure that map entries are sorted (and all lowercase, if this
     486             :                 // map is case insensitive)
     487             :                 const OString aStr( pMap->maKey );
     488             :                 if( !mbCaseSensitive &&
     489             :                     aStr != aStr.toAsciiLowerCase() )
     490             :                 {
     491             :                     OSL_TRACE("ValueMap::ValueMap(): Key %s is not lowercase",
     492             :                               pMap->maKey);
     493             :                     OSL_FAIL( "ValueMap::ValueMap(): Key is not lowercase" );
     494             :                 }
     495             : 
     496             :                 if( mnEntries > 1 )
     497             :                 {
     498             :                     for( ::std::size_t i=0; i<mnEntries-1; ++i, ++pMap )
     499             :                     {
     500             :                         if( !mapComparator(pMap[0], pMap[1]) &&
     501             :                             mapComparator(pMap[1], pMap[0]) )
     502             :                         {
     503             :                             OSL_TRACE("ValueMap::ValueMap(): Map is not sorted, keys %s and %s are wrong",
     504             :                                       pMap[0].maKey,
     505             :                                       pMap[1].maKey);
     506             :                             OSL_FAIL( "ValueMap::ValueMap(): Map is not sorted" );
     507             :                         }
     508             : 
     509             :                         const OString aStr2( pMap[1].maKey );
     510             :                         if( !mbCaseSensitive &&
     511             :                             aStr2 != aStr2.toAsciiLowerCase() )
     512             :                         {
     513             :                             OSL_TRACE("ValueMap::ValueMap(): Key %s is not lowercase",
     514             :                                       pMap[1].maKey);
     515             :                             OSL_FAIL( "ValueMap::ValueMap(): Key is not lowercase" );
     516             :                         }
     517             :                     }
     518             :                 }
     519             : #endif
     520           2 :             }
     521             : 
     522             :             /** Lookup a value for the given query string
     523             : 
     524             :                 @param rName
     525             :                 The string to lookup. If the map was created with the case
     526             :                 insensitive flag, the lookup is performed
     527             :                 case-insensitive, otherwise, case-sensitive.
     528             : 
     529             :                 @param o_rResult
     530             :                 Output parameter, which receives the value associated with
     531             :                 the query string. If no value was found, the referenced
     532             :                 object is kept unmodified.
     533             : 
     534             :                 @return true, if a matching entry was found.
     535             :             */
     536           0 :             bool lookup( const OUString& rName,
     537             :                          ValueType&             o_rResult ) const
     538             :             {
     539             :                 // rName is required to contain only ASCII characters.
     540             :                 // TODO(Q1): Enforce this at upper layers
     541             :                 OString aKey( OUStringToOString( mbCaseSensitive ? rName : rName.toAsciiLowerCase(),
     542           0 :                                                                RTL_TEXTENCODING_ASCII_US ) );
     543             :                 MapEntry aSearchKey =
     544             :                     {
     545           0 :                         aKey.getStr(),
     546             :                         ValueType()
     547           0 :                     };
     548             : 
     549             :                 const MapEntry* pRes;
     550           0 :                 const MapEntry* pEnd = mpMap+mnEntries;
     551           0 :                 if( (pRes=::std::lower_bound( mpMap,
     552             :                                               pEnd,
     553             :                                               aSearchKey,
     554           0 :                                               &mapComparator )) != pEnd )
     555             :                 {
     556             :                     // place to _insert before_ found - is it equal to
     557             :                     // the search key?
     558           0 :                     if( strcmp( pRes->maKey, aSearchKey.maKey ) == 0 )
     559             :                     {
     560             :                         // yep, correct entry found
     561           0 :                         o_rResult = pRes->maValue;
     562           0 :                         return true;
     563             :                     }
     564             :                 }
     565             : 
     566             :                 // not found
     567           0 :                 return false;
     568             :             }
     569             : 
     570             :         private:
     571           0 :             static bool mapComparator( const MapEntry& rLHS,
     572             :                                        const MapEntry& rRHS )
     573             :             {
     574             :                 return strcmp( rLHS.maKey,
     575           0 :                                rRHS.maKey ) < 0;
     576             :             }
     577             : 
     578             :             const MapEntry*     mpMap;
     579             :             ::std::size_t       mnEntries;
     580             :             bool                mbCaseSensitive;
     581             :         };
     582             :     }
     583             : }
     584             : 
     585             : #endif /* INCLUDED_CANVAS_CANVASTOOLS_HXX */
     586             : 
     587             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10