canvastools.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
#ifndef INCLUDED_CANVAS_CANVASTOOLS_HXX
#define INCLUDED_CANVAS_CANVASTOOLS_HXX
 
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/uno/Sequence.hxx>
#include <com/sun/star/uno/RuntimeException.hpp>
#include <osl/diagnose.h>
#include <rtl/ustring.hxx>
#include <sal/log.hxx>
 
#include <math.h>
#include <string.h>
#include <vector>
#include <limits>
 
#include <canvas/canvastoolsdllapi.h>
 
namespace basegfx
{
    class B2DHomMatrix;
    class B2DRange;
    class B2IRange;
    class B2IPoint;
    class B2DPolyPolygon;
}
 
namespace com::sun::star::geometry
{
    struct RealSize2D;
    struct IntegerSize2D;
    struct AffineMatrix2D;
    struct Matrix2D;
}
 
namespace com::sun::star::rendering
{
    struct RenderState;
    struct ViewState;
    struct IntegerBitmapLayout;
    class  XCanvas;
    struct Texture;
    class  XIntegerBitmapColorSpace;
}
 
namespace com::sun::star::awt
{
    struct Rectangle;
    class  XWindow2;
}
 
namespace com::sun::star::beans {
    struct PropertyValue;
}
 
class Color;
class OutputDevice;
 
namespace canvas
{
    namespace tools
    {
        inline sal_uInt32 nextPow2( sal_uInt32 x )
        {
            --x;
            x |= x >> 1;
            x |= x >> 2;
            x |= x >> 4;
            x |= x >> 8;
            x |= x >> 16;
 
            return ++x;
        }
 
        inline sal_Int32 roundDown( const double& rVal )
        {
            return static_cast< sal_Int32 >( floor( rVal ) );
        }
 
        inline sal_Int32 roundUp( const double& rVal )
        {
            return static_cast< sal_Int32 >( ceil( rVal ) );
        }
 
        CANVASTOOLS_DLLPUBLIC css::geometry::RealSize2D createInfiniteSize2D();
 
 
        // View- and RenderState utilities
 
 
        CANVASTOOLS_DLLPUBLIC css::rendering::RenderState&
            initRenderState( css::rendering::RenderState&                      renderState );
 
        CANVASTOOLS_DLLPUBLIC css::rendering::ViewState&
            initViewState( css::rendering::ViewState&                          viewState );
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix&
            getViewStateTransform( ::basegfx::B2DHomMatrix&                    transform,
                                   const css::rendering::ViewState&            viewState );
 
        CANVASTOOLS_DLLPUBLIC css::rendering::ViewState&
            setViewStateTransform( css::rendering::ViewState&                  viewState,
                                   const ::basegfx::B2DHomMatrix&              transform );
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix&
            getRenderStateTransform( ::basegfx::B2DHomMatrix&                  transform,
                                     const css::rendering::RenderState&        renderState );
 
        CANVASTOOLS_DLLPUBLIC css::rendering::RenderState&
            setRenderStateTransform( css::rendering::RenderState&              renderState,
                                     const ::basegfx::B2DHomMatrix&            transform );
 
        CANVASTOOLS_DLLPUBLIC css::rendering::RenderState&
            appendToRenderState( css::rendering::RenderState&                  renderState,
                                 const ::basegfx::B2DHomMatrix&                transform );
 
        CANVASTOOLS_DLLPUBLIC css::rendering::RenderState&
            prependToRenderState( css::rendering::RenderState&                 renderState,
                                  const ::basegfx::B2DHomMatrix&               transform );
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix&
            mergeViewAndRenderTransform( ::basegfx::B2DHomMatrix&              transform,
                                         const css::rendering::ViewState&      viewState,
                                         const css::rendering::RenderState&    renderState );
 
 
        // Matrix utilities
 
 
        CANVASTOOLS_DLLPUBLIC css::geometry::AffineMatrix2D&
            setIdentityAffineMatrix2D( css::geometry::AffineMatrix2D&  matrix );
 
        CANVASTOOLS_DLLPUBLIC css::geometry::Matrix2D&
            setIdentityMatrix2D( css::geometry::Matrix2D&              matrix );
 
 
        // Special utilities
 
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DRange& calcTransformedRectBounds( ::basegfx::B2DRange&          o_Rect,
                                                        const ::basegfx::B2DRange&      i_Rect,
                                                        const ::basegfx::B2DHomMatrix&  i_Transformation );
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DHomMatrix& calcRectToOriginTransform( ::basegfx::B2DHomMatrix&      o_transform,
                                                            const ::basegfx::B2DRange&      i_srcRect,
                                                            const ::basegfx::B2DHomMatrix&  i_transformation );
 
        CANVASTOOLS_DLLPUBLIC bool isInside( const ::basegfx::B2DRange&         rContainedRect,
                       const ::basegfx::B2DRange&       rTransformRect,
                       const ::basegfx::B2DHomMatrix&   rTransformation );
 
        CANVASTOOLS_DLLPUBLIC bool clipScrollArea( ::basegfx::B2IRange&                  io_rSourceArea,
                             ::basegfx::B2IPoint&                  io_rDestPoint,
                             ::std::vector< ::basegfx::B2IRange >& o_ClippedAreas,
                             const ::basegfx::B2IRange&            rBounds );
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2IRange spritePixelAreaFromB2DRange( const ::basegfx::B2DRange& rRange );
 
        CANVASTOOLS_DLLPUBLIC css::uno::Sequence< css::uno::Any >& getDeviceInfo(
            const css::uno::Reference< css::rendering::XCanvas >& i_rxCanvas,
            css::uno::Sequence< css::uno::Any >& o_rxParams );
 
        CANVASTOOLS_DLLPUBLIC css::uno::Reference< css::rendering::XIntegerBitmapColorSpace> const & getStdColorSpace();
 
        CANVASTOOLS_DLLPUBLIC css::uno::Reference< css::rendering::XIntegerBitmapColorSpace> const & getStdColorSpaceWithoutAlpha();
 
        CANVASTOOLS_DLLPUBLIC css::rendering::IntegerBitmapLayout getStdMemoryLayout(
            const css::geometry::IntegerSize2D& rBitmapSize );
 
        CANVASTOOLS_DLLPUBLIC css::uno::Sequence<sal_Int8> colorToStdIntSequence( const ::Color& rColor );
 
        // Modelled closely after boost::numeric_cast, only that we
        // issue some trace output here and throw a RuntimeException
 
        template< typename Target, typename Source > inline Target numeric_cast( Source arg )
        {
            // typedefs abbreviating respective trait classes
            typedef ::std::numeric_limits< Source > SourceLimits;
            typedef ::std::numeric_limits< Target > TargetLimits;
 
#undef min
#undef max
 
            if( ( arg<0 && !TargetLimits::is_signed) ||                     // losing the sign here
                ( SourceLimits::is_signed && arg<TargetLimits::min()) ||    // underflow will happen
                ( arg>TargetLimits::max() ) )                               // overflow will happen
            {
# if OSL_DEBUG_LEVEL > 2
                SAL_WARN("canvas", "numeric_cast detected data loss");
#endif
                throw css::uno::RuntimeException(
                    "numeric_cast detected data loss",
                    nullptr );
            }
 
            return static_cast<Target>(arg);
        }
 
        CANVASTOOLS_DLLPUBLIC css::awt::Rectangle getAbsoluteWindowRect(
            const css::awt::Rectangle&                       rRect,
            const css::uno::Reference< css::awt::XWindow2 >& xWin  );
 
        CANVASTOOLS_DLLPUBLIC ::basegfx::B2DPolyPolygon getBoundMarksPolyPolygon( const ::basegfx::B2DRange& rRange );
 
        CANVASTOOLS_DLLPUBLIC int calcGradientStepCount( ::basegfx::B2DHomMatrix&   rTotalTransform,
                                   const css::rendering::ViewState&   viewState,
                                   const css::rendering::RenderState& renderState,
                                   const css::rendering::Texture&     texture,
                                   int                                nColorSteps );
 
        template< typename ValueType > class ValueMap
        {
        public:
            struct MapEntry
            {
                const char*     maKey;
                ValueType       maValue;
            };
 
            ValueMap( const MapEntry*   pMap,
                      ::std::size_t     nEntries,
                      bool              bCaseSensitive ) :
                mpMap( pMap ),
                mnEntries( nEntries ),
                mbCaseSensitive( bCaseSensitive )
            {
#ifdef DBG_UTIL
                // Ensure that map entries are sorted (and all lowercase, if this
                // map is case insensitive)
                const OString aStr( pMap->maKey );
                if( !mbCaseSensitive &&
                    aStr != aStr.toAsciiLowerCase() )
                {
                    SAL_WARN("canvas", "ValueMap::ValueMap(): Key is not lowercase " << pMap->maKey);
                }
 
                if( mnEntries <= 1 )
                    return;
 
                for( ::std::size_t i=0; i<mnEntries-1; ++i, ++pMap )
                {
                    if( !mapComparator(pMap[0], pMap[1]) &&
                        mapComparator(pMap[1], pMap[0]) )
                    {
                        SAL_WARN("canvas", "ValueMap::ValueMap(): Map is not sorted, keys are wrong, "
                                  << pMap[0].maKey << " and " << pMap[1].maKey);
                        OSL_FAIL( "ValueMap::ValueMap(): Map is not sorted" );
                    }
 
                    const OString aStr2( pMap[1].maKey );
                    if( !mbCaseSensitive &&
                        aStr2 != aStr2.toAsciiLowerCase() )
                    {
                        SAL_WARN("canvas", "ValueMap::ValueMap(): Key is not lowercase" << pMap[1].maKey);
                    }
                }
#endif
            }
 
            bool lookup( const OUString& rName,
                         ValueType&             o_rResult ) const
            {
                // rName is required to contain only ASCII characters.
                // TODO(Q1): Enforce this at upper layers
                OString aKey( OUStringToOString( mbCaseSensitive ? rName : rName.toAsciiLowerCase(),
                                                               RTL_TEXTENCODING_ASCII_US ) );
                MapEntry aSearchKey =
                    {
                        aKey.getStr(),
                        ValueType()
                    };
 
                const MapEntry* pEnd = mpMap+mnEntries;
                const MapEntry* pRes = ::std::lower_bound( mpMap,
                                              pEnd,
                                              aSearchKey,
                                              &mapComparator );
                if( pRes != pEnd )
                {
                    // place to _insert before_ found - is it equal to
                    // the search key?
                    if( strcmp( pRes->maKey, aSearchKey.maKey ) == 0 )
                    {
                        // yep, correct entry found
                        o_rResult = pRes->maValue;
                        return true;
                    }
                }
 
                // not found
                return false;
            }
 
        private:
            static bool mapComparator( const MapEntry& rLHS,
                                       const MapEntry& rRHS )
            {
                return strcmp( rLHS.maKey,
                               rRHS.maKey ) < 0;
            }
 
            const MapEntry*     mpMap;
            ::std::size_t       mnEntries;
            bool                mbCaseSensitive;
        };
 
        CANVASTOOLS_DLLPUBLIC void clipOutDev(const css::rendering::ViewState& viewState,
                        const css::rendering::RenderState& renderState,
                        OutputDevice& rOutDev,
                        OutputDevice* p2ndOutDev=nullptr);
 
        CANVASTOOLS_DLLPUBLIC void extractExtraFontProperties(const css::uno::Sequence<css::beans::PropertyValue>& rExtraFontProperties,
                        sal_uInt32& rEmphasisMark);
    }
}
 
#endif /* INCLUDED_CANVAS_CANVASTOOLS_HXX */
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */