xref: /aoo41x/main/drawinglayer/source/primitive2d/textprimitive2d.cxx (revision cdf0e10c)

/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_drawinglayer.hxx"

#include <drawinglayer/primitive2d/textprimitive2d.hxx>
#include <drawinglayer/primitive2d/textlayoutdevice.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <drawinglayer/primitive2d/texteffectprimitive2d.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>

//////////////////////////////////////////////////////////////////////////////

using namespace com::sun::star;

//////////////////////////////////////////////////////////////////////////////

namespace
{
	// adapts fontScale for usage with TextLayouter. Input is rScale which is the extracted
	// scale from a text transformation. A copy is modified so that it contains only positive
    // scalings and XY-equal scalings to allow to get a non-X-scaled Vcl-Font for TextLayouter.
    // rScale is adapted accordingly to contain the corrected scale which would need to be
    // applied to e.g. outlines received from TextLayouter under usage of fontScale. This
    // includes Y-Scale, X-Scale-correction and mirrorings.
    basegfx::B2DVector getCorrectedScaleAndFontScale(basegfx::B2DVector& rScale)
	{
        // copy input value
        basegfx::B2DVector aFontScale(rScale);

        // correct FontHeight settings
        if(basegfx::fTools::equalZero(aFontScale.getY()))
        {
            // no font height; choose one and adapt scale to get back to original scaling
            static double fDefaultFontScale(100.0);
            rScale.setY(1.0 / fDefaultFontScale);
            aFontScale.setY(fDefaultFontScale);
        }
        else if(basegfx::fTools::less(aFontScale.getY(), 0.0))
        {
            // negative font height; invert and adapt scale to get back to original scaling
            aFontScale.setY(-aFontScale.getY());
            rScale.setY(-1.0);
        }
        else
        {
            // positive font height; adapt scale; scaling will be part of the polygons
            rScale.setY(1.0);
        }

        // correct FontWidth settings
        if(basegfx::fTools::equal(aFontScale.getX(), aFontScale.getY()))
        {
            // no FontScale, adapt scale
            rScale.setX(1.0);
        }
        else
        {
            // If FontScale is used, force to no FontScale to get a non-scaled VCL font.
            // Adapt scaling in X accordingly.
            rScale.setX(aFontScale.getX() / aFontScale.getY());
            aFontScale.setX(aFontScale.getY());
        }

        return aFontScale;
	}
} // end of anonymous namespace

//////////////////////////////////////////////////////////////////////////////

namespace drawinglayer
{
	namespace primitive2d
	{
        void TextSimplePortionPrimitive2D::getTextOutlinesAndTransformation(basegfx::B2DPolyPolygonVector& rTarget, basegfx::B2DHomMatrix& rTransformation) const
        {
			if(getTextLength())
			{
				// decompose object transformation to single values
				basegfx::B2DVector aScale, aTranslate;
				double fRotate, fShearX;

				// if decomposition returns false, create no geometry since e.g. scaling may
				// be zero
				if(getTextTransform().decompose(aScale, aTranslate, fRotate, fShearX))
				{
					// handle special case: If scale is negative in (x,y) (3rd quadrant), it can
					// be expressed as rotation by PI
					if(basegfx::fTools::less(aScale.getX(), 0.0) && basegfx::fTools::less(aScale.getY(), 0.0))
					{
						aScale = basegfx::absolute(aScale);
						fRotate += F_PI;
					}

					// for the TextLayouterDevice, it is necessary to have a scaling representing
					// the font size. Since we want to extract polygons here, it is okay to
					// work just with scaling and to ignore shear, rotation and translation,
					// all that can be applied to the polygons later
					const basegfx::B2DVector aFontScale(getCorrectedScaleAndFontScale(aScale));

					// prepare textlayoutdevice
					TextLayouterDevice aTextLayouter;
					aTextLayouter.setFontAttribute(
                        getFontAttribute(),
                        aFontScale.getX(),
                        aFontScale.getY(),
                        getLocale());

                    // When getting outlines from stretched text (aScale.getX() != 1.0) it
                    // is necessary to inverse-scale the DXArray (if used) to not get the
                    // outlines already aligned to given, but wrong DXArray
                    if(getDXArray().size() && !basegfx::fTools::equal(aScale.getX(), 1.0))
                    {
            			::std::vector< double > aScaledDXArray = getDXArray();
                        const double fDXArrayScale(1.0 / aScale.getX());

                        for(sal_uInt32 a(0); a < aScaledDXArray.size(); a++)
                        {
                            aScaledDXArray[a] *= fDXArrayScale;
                        }

                        // get the text outlines
					    aTextLayouter.getTextOutlines(
                            rTarget,
                            getText(),
                            getTextPosition(),
                            getTextLength(),
                            aScaledDXArray);
                    }
                    else
                    {
                        // get the text outlines
					    aTextLayouter.getTextOutlines(
                            rTarget,
                            getText(),
                            getTextPosition(),
                            getTextLength(),
                            getDXArray());
                    }

					// create primitives for the outlines
					const sal_uInt32 nCount(rTarget.size());

					if(nCount)
					{
						// prepare object transformation for polygons
						rTransformation = basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
							aScale, fShearX, fRotate, aTranslate);
					}
				}
			}
        }

        Primitive2DSequence TextSimplePortionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
		{
			Primitive2DSequence aRetval;

			if(getTextLength())
			{
				basegfx::B2DPolyPolygonVector aB2DPolyPolyVector;
			    basegfx::B2DHomMatrix aPolygonTransform;

                // get text outlines and their object transformation
                getTextOutlinesAndTransformation(aB2DPolyPolyVector, aPolygonTransform);

				// create primitives for the outlines
				const sal_uInt32 nCount(aB2DPolyPolyVector.size());

				if(nCount)
				{
					// alloc space for the primitives
					aRetval.realloc(nCount);

					// color-filled polypolygons
					for(sal_uInt32 a(0L); a < nCount; a++)
					{
						// prepare polypolygon
						basegfx::B2DPolyPolygon& rPolyPolygon = aB2DPolyPolyVector[a];
						rPolyPolygon.transform(aPolygonTransform);
						aRetval[a] = new PolyPolygonColorPrimitive2D(rPolyPolygon, getFontColor());
					}

					if(getFontAttribute().getOutline())
					{
				        // decompose polygon transformation to single values
				        basegfx::B2DVector aScale, aTranslate;
				        double fRotate, fShearX;
				        aPolygonTransform.decompose(aScale, aTranslate, fRotate, fShearX);

                        // create outline text effect with current content and replace
						Primitive2DReference aNewTextEffect(new TextEffectPrimitive2D(
							aRetval,
							aTranslate,
							fRotate,
							TEXTEFFECTSTYLE2D_OUTLINE));

						aRetval = Primitive2DSequence(&aNewTextEffect, 1);
					}
				}
			}

			return aRetval;
		}

		TextSimplePortionPrimitive2D::TextSimplePortionPrimitive2D(
			const basegfx::B2DHomMatrix& rNewTransform,
			const String& rText,
			xub_StrLen aTextPosition,
			xub_StrLen aTextLength,
			const ::std::vector< double >& rDXArray,
            const attribute::FontAttribute& rFontAttribute,
            const ::com::sun::star::lang::Locale& rLocale,
			const basegfx::BColor& rFontColor)
		:	BufferedDecompositionPrimitive2D(),
			maTextTransform(rNewTransform),
			maText(rText),
			maTextPosition(aTextPosition),
			maTextLength(aTextLength),
			maDXArray(rDXArray),
			maFontAttribute(rFontAttribute),
            maLocale(rLocale),
			maFontColor(rFontColor),
			maB2DRange()
		{
#ifdef DBG_UTIL
			const xub_StrLen aStringLength(getText().Len());
			OSL_ENSURE(aStringLength >= getTextPosition() && aStringLength >= getTextPosition() + getTextLength(),
				"TextSimplePortionPrimitive2D with text out of range (!)");
#endif
		}

        bool LocalesAreEqual(const ::com::sun::star::lang::Locale& rA, const ::com::sun::star::lang::Locale& rB)
        {
            return (rA.Language == rB.Language
                && rA.Country == rB.Country
                && rA.Variant == rB.Variant);
        }

		bool TextSimplePortionPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
		{
			if(BufferedDecompositionPrimitive2D::operator==(rPrimitive))
			{
				const TextSimplePortionPrimitive2D& rCompare = (TextSimplePortionPrimitive2D&)rPrimitive;

				return (getTextTransform() == rCompare.getTextTransform()
					&& getText() == rCompare.getText()
					&& getTextPosition() == rCompare.getTextPosition()
					&& getTextLength() == rCompare.getTextLength()
					&& getDXArray() == rCompare.getDXArray()
					&& getFontAttribute() == rCompare.getFontAttribute()
                    && LocalesAreEqual(getLocale(), rCompare.getLocale())
					&& getFontColor() == rCompare.getFontColor());
			}

			return false;
		}

		basegfx::B2DRange TextSimplePortionPrimitive2D::getB2DRange(const geometry::ViewInformation2D& /*rViewInformation*/) const
		{
			if(maB2DRange.isEmpty() && getTextLength())
			{
				// get TextBoundRect as base size
				// decompose object transformation to single values
				basegfx::B2DVector aScale, aTranslate;
				double fRotate, fShearX;

				if(getTextTransform().decompose(aScale, aTranslate, fRotate, fShearX))
				{
					// for the TextLayouterDevice, it is necessary to have a scaling representing
					// the font size. Since we want to extract polygons here, it is okay to
					// work just with scaling and to ignore shear, rotation and translation,
					// all that can be applied to the polygons later
					const basegfx::B2DVector aFontScale(getCorrectedScaleAndFontScale(aScale));

					// prepare textlayoutdevice
					TextLayouterDevice aTextLayouter;
					aTextLayouter.setFontAttribute(
                        getFontAttribute(),
                        aFontScale.getX(),
                        aFontScale.getY(),
                        getLocale());

					// get basic text range
					basegfx::B2DRange aNewRange(aTextLayouter.getTextBoundRect(getText(), getTextPosition(), getTextLength()));

                    // #i104432#, #i102556# take empty results into account
                    if(!aNewRange.isEmpty())
                    {
					    // prepare object transformation for range
						const basegfx::B2DHomMatrix aRangeTransformation(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
							aScale, fShearX, fRotate, aTranslate));

					    // apply range transformation to it
					    aNewRange.transform(aRangeTransformation);

					    // assign to buffered value
					    const_cast< TextSimplePortionPrimitive2D* >(this)->maB2DRange = aNewRange;
                    }
				}
			}

			return maB2DRange;
		}

		// provide unique ID
		ImplPrimitrive2DIDBlock(TextSimplePortionPrimitive2D, PRIMITIVE2D_ID_TEXTSIMPLEPORTIONPRIMITIVE2D)

	} // end of namespace primitive2d
} // end of namespace drawinglayer

//////////////////////////////////////////////////////////////////////////////
// eof