    /* -*- 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 .
     */

    #include <pdfiprocessor.hxx>
    #include <xmlemitter.hxx>
    #include <pdfihelper.hxx>
    #include <imagecontainer.hxx>
    #include <genericelements.hxx>
    #include "style.hxx"
    #include <treevisiting.hxx>

    #include <rtl/string.hxx>
    #include <rtl/strbuf.hxx>
    #include <sal/log.hxx>

    #include <comphelper/sequence.hxx>
    #include <basegfx/polygon/b2dpolypolygontools.hxx>
    #include <basegfx/polygon/b2dpolygonclipper.hxx>
    #include <basegfx/polygon/b2dpolygontools.hxx>
    #include <basegfx/utils/canvastools.hxx>
    #include <basegfx/matrix/b2dhommatrix.hxx>
    #include <basegfx/range/b2irange.hxx>
    #include <basegfx/range/b2drectangle.hxx>
    #include <basegfx/matrix/b2dhommatrixtools.hxx>
    #include <vcl/svapp.hxx>

    #include <com/sun/star/rendering/XVolatileBitmap.hpp>
    #include <com/sun/star/geometry/RealSize2D.hpp>
    #include <com/sun/star/geometry/RealPoint2D.hpp>
    #include <com/sun/star/geometry/RealRectangle2D.hpp>

    using namespace com::sun::star;

    namespace pdfi
    {

     PDFIProcessor::PDFIProcessor( const uno::Reference< task::XStatusIndicator >& xStat ,
                css::uno::Reference< css::uno::XComponentContext > const & xContext) :

        m_xContext(xContext),
        prevCharWidth(0),
        m_pDocument( ElementFactory::createDocumentElement() ),
        m_pCurPage(nullptr),
        m_pCurElement(nullptr),
        m_nNextFontId( 1 ),
        m_aIdToFont(),
        m_aFontToId(),
        m_aGCStack(),
        m_nNextGCId( 1 ),
        m_aGCToId(),
        m_aImages(),
        m_nPages(0),
        m_nNextZOrder( 1 ),
        m_xStatusIndicator( xStat )
    {
        FontAttributes aDefFont;
        aDefFont.familyName = "Helvetica";
        aDefFont.isBold     = false;
        aDefFont.isItalic   = false;
        aDefFont.size       = 10*PDFI_OUTDEV_RESOLUTION/72;
        m_aIdToFont[ 0 ]    = aDefFont;
        m_aFontToId[ aDefFont ] = 0;

        GraphicsContext aDefGC;
        m_aGCStack.push_back( aDefGC );
        m_aGCToId.insert(GCToIdBiMap::relation(aDefGC, 0));
    }

    void PDFIProcessor::setPageNum( sal_Int32 nPages )
    {
        m_nPages = nPages;
    }

    void PDFIProcessor::pushState()
    {
        GraphicsContextStack::value_type const a(m_aGCStack.back());
        m_aGCStack.push_back(a);
    }

    void PDFIProcessor::popState()
    {
        m_aGCStack.pop_back();
    }

    void PDFIProcessor::setFlatness( double value )
    {
        getCurrentContext().Flatness = value;
    }

    void PDFIProcessor::setTransformation( const geometry::AffineMatrix2D& rMatrix )
    {
        basegfx::unotools::homMatrixFromAffineMatrix(
            getCurrentContext().Transformation,
            rMatrix );
    }

    void PDFIProcessor::setLineDash( const uno::Sequence<double>& dashes,
                                     double                       /*start*/ )
    {
        // TODO(F2): factor in start offset
        GraphicsContext& rContext( getCurrentContext() );
        comphelper::sequenceToContainer(rContext.DashArray,dashes);
    }

    void PDFIProcessor::setLineJoin(sal_Int8 nJoin)
    {
        getCurrentContext().LineJoin = nJoin;
    }

    void PDFIProcessor::setLineCap(sal_Int8 nCap)
    {
        getCurrentContext().LineCap = nCap;
    }

    void PDFIProcessor::setMiterLimit(double)
    {
        SAL_WARN("sdext.pdfimport", "PDFIProcessor::setMiterLimit(): not supported by ODF");
    }

    void PDFIProcessor::setLineWidth(double nWidth)
    {
        getCurrentContext().LineWidth = nWidth;
    }

    void PDFIProcessor::setFillColor( const rendering::ARGBColor& rColor )
    {
        getCurrentContext().FillColor = rColor;
    }

    void PDFIProcessor::setStrokeColor( const rendering::ARGBColor& rColor )
    {
        getCurrentContext().LineColor = rColor;
    }

    void PDFIProcessor::setFont( const FontAttributes& i_rFont )
    {
        FontAttributes aChangedFont( i_rFont );
        GraphicsContext& rGC=getCurrentContext();
        // for text render modes, please see PDF reference manual
        aChangedFont.isOutline = ( (rGC.TextRenderMode == 1) || (rGC. TextRenderMode == 2) );
        FontToIdMap::const_iterator it = m_aFontToId.find( aChangedFont );
        if( it != m_aFontToId.end() )
            rGC.FontId = it->second;
        else
        {
            m_aFontToId[ aChangedFont ] = m_nNextFontId;
            m_aIdToFont[ m_nNextFontId ] = aChangedFont;
            rGC.FontId = m_nNextFontId;
            m_nNextFontId++;
        }
    }

    void PDFIProcessor::setTextRenderMode( sal_Int32 i_nMode )
    {
        GraphicsContext& rGC=getCurrentContext();
        rGC.TextRenderMode = i_nMode;
        IdToFontMap::iterator it = m_aIdToFont.find( rGC.FontId );
        if( it != m_aIdToFont.end() )
            setFont( it->second );
    }

    sal_Int32 PDFIProcessor::getFontId( const FontAttributes& rAttr ) const
    {
        const sal_Int32 nCurFont = getCurrentContext().FontId;
        const_cast<PDFIProcessor*>(this)->setFont( rAttr );
        const sal_Int32 nFont = getCurrentContext().FontId;
        const_cast<PDFIProcessor*>(this)->getCurrentContext().FontId = nCurFont;

        return nFont;
    }

    // line diagnose block - start
    void PDFIProcessor::processGlyphLine()
    {
        if (m_GlyphsList.empty())
            return;

        double spaceDetectBoundary = 0.0;

        // Try to find space glyph and its width
        for (CharGlyph & i : m_GlyphsList)
        {
            OUString& glyph = i.getGlyph();

            sal_Unicode ch = '\0';
            if (!glyph.isEmpty())
                ch = glyph[0];

            if ((ch == 0x20) || (ch == 0xa0))
            {
                double spaceWidth = i.getWidth();
                spaceDetectBoundary = spaceWidth * 0.5;
                break;
            }
        }

        // If space glyph is not found, use average glyph width instead
        if (spaceDetectBoundary == 0.0)
        {
            double avgGlyphWidth = 0.0;
            for (CharGlyph & i : m_GlyphsList)
                avgGlyphWidth += i.getWidth();
            avgGlyphWidth /= m_GlyphsList.size();
            spaceDetectBoundary = avgGlyphWidth * 0.2;
        }

        FrameElement* frame = ElementFactory::createFrameElement(
            m_GlyphsList[0].getCurElement(),
            getGCId(m_GlyphsList[0].getGC()));
        frame->ZOrder = m_nNextZOrder++;
        frame->IsForText = true;
        frame->FontSize = getFont(m_GlyphsList[0].getGC().FontId).size;
        ParagraphElement* para = ElementFactory::createParagraphElement(frame);

        for (size_t i = 0; i < m_GlyphsList.size(); i++)
        {
            bool prependSpace = false;
            TextElement* text = ElementFactory::createTextElement(
                para,
                getGCId(m_GlyphsList[i].getGC()),
                m_GlyphsList[i].getGC().FontId);
            if (i == 0)
            {
                text->x = m_GlyphsList[0].getGC().Transformation.get(0, 2);
                text->y = m_GlyphsList[0].getGC().Transformation.get(1, 2);
                text->w = 0;
                text->h = 0;
                para->updateGeometryWith(text);
                frame->updateGeometryWith(para);
            }
            else
            {
                double spaceSize = m_GlyphsList[i].getPrevSpaceWidth();
                prependSpace = spaceSize > spaceDetectBoundary;
            }
            if (prependSpace)
                text->Text.append(" ");
            text->Text.append(m_GlyphsList[i].getGlyph());
        }

        m_GlyphsList.clear();
    }

    void PDFIProcessor::drawGlyphs( const OUString&             rGlyphs,
                                    const geometry::RealRectangle2D& rRect,
                                    const geometry::Matrix2D&        rFontMatrix,
                                    double fontSize)
    {
        double ascent = getFont(getCurrentContext().FontId).ascent;

        basegfx::B2DHomMatrix fontMatrix(
            rFontMatrix.m00, rFontMatrix.m01, 0.0,
            rFontMatrix.m10, rFontMatrix.m11, 0.0);
        fontMatrix.scale(fontSize, fontSize);

        basegfx::B2DHomMatrix totalTextMatrix1(fontMatrix);
        basegfx::B2DHomMatrix totalTextMatrix2(fontMatrix);
        totalTextMatrix1.translate(rRect.X1, rRect.Y1);
        totalTextMatrix2.translate(rRect.X2, rRect.Y2);

        basegfx::B2DHomMatrix corrMatrix;
        corrMatrix.scale(1.0, -1.0);
        corrMatrix.translate(0.0, ascent);
        totalTextMatrix1 = totalTextMatrix1 * corrMatrix;
        totalTextMatrix2 = totalTextMatrix2 * corrMatrix;

        totalTextMatrix1 *= getCurrentContext().Transformation;
        totalTextMatrix2 *= getCurrentContext().Transformation;

        basegfx::B2DHomMatrix invMatrix(totalTextMatrix1);
        basegfx::B2DHomMatrix invPrevMatrix(prevTextMatrix);
        invMatrix.invert();
        invPrevMatrix.invert();
        basegfx::B2DHomMatrix offsetMatrix1(totalTextMatrix1);
        basegfx::B2DHomMatrix offsetMatrix2(totalTextMatrix2);
        offsetMatrix1 *= invPrevMatrix;
        offsetMatrix2 *= invMatrix;

        double charWidth = offsetMatrix2.get(0, 2);
        double prevSpaceWidth = offsetMatrix1.get(0, 2) - prevCharWidth;

        if ((totalTextMatrix1.get(0, 0) != prevTextMatrix.get(0, 0)) ||
            (totalTextMatrix1.get(0, 1) != prevTextMatrix.get(0, 1)) ||
            (totalTextMatrix1.get(1, 0) != prevTextMatrix.get(1, 0)) ||
            (totalTextMatrix1.get(1, 1) != prevTextMatrix.get(1, 1)) ||
            (offsetMatrix1.get(0, 2) < 0.0) ||
            (prevSpaceWidth > prevCharWidth * 1.3) ||
            (!basegfx::fTools::equalZero(offsetMatrix1.get(1, 2), 0.0001)))
        {
            processGlyphLine();
        }

        CharGlyph aGlyph(m_pCurElement, getCurrentContext(), charWidth, prevSpaceWidth, rGlyphs);
        aGlyph.getGC().Transformation = totalTextMatrix1;
        m_GlyphsList.push_back(aGlyph);

        prevCharWidth = charWidth;
        prevTextMatrix = totalTextMatrix1;
    }

    void PDFIProcessor::endText()
    {
        TextElement* pText = dynamic_cast<TextElement*>(m_pCurElement);
        if( pText )
            m_pCurElement = pText->Parent;
    }

    void PDFIProcessor::setupImage(ImageId nImage)
    {
        const GraphicsContext& rGC(getCurrentContext());

        basegfx::B2DTuple aScale, aTranslation;
        double fRotate, fShearX;
        rGC.Transformation.decompose(aScale, aTranslation, fRotate, fShearX);

        const sal_Int32 nGCId = getGCId(rGC);
        FrameElement* pFrame = ElementFactory::createFrameElement( m_pCurElement, nGCId );
        ImageElement* pImageElement = ElementFactory::createImageElement( pFrame, nGCId, nImage );
        pFrame->x = pImageElement->x = aTranslation.getX();
        pFrame->y = pImageElement->y = aTranslation.getY();
        pFrame->w = pImageElement->w = aScale.getX();
        pFrame->h = pImageElement->h = aScale.getY();
        pFrame->ZOrder = m_nNextZOrder++;

        // Poppler wrapper takes into account that vertical axes of PDF and ODF are opposite,
        // and it flips matrix vertically (see poppler's GfxState::GfxState()).
        // But image internal vertical axis is independent of PDF vertical axis direction,
        // so arriving matrix is extra-flipped relative to image.
        // We force vertical flip here to compensate that.
        pFrame->MirrorVertical = true;
    }

    void PDFIProcessor::drawMask(const uno::Sequence<beans::PropertyValue>& xBitmap,
                                 bool                                       /*bInvert*/ )
    {
        // TODO(F3): Handle mask and inversion
        setupImage( m_aImages.addImage(xBitmap) );
    }

    void PDFIProcessor::drawImage(const uno::Sequence<beans::PropertyValue>& xBitmap )
    {
        setupImage( m_aImages.addImage(xBitmap) );
    }

    void PDFIProcessor::drawColorMaskedImage(const uno::Sequence<beans::PropertyValue>& xBitmap,
                                             const uno::Sequence<uno::Any>&             /*xMaskColors*/ )
    {
        // TODO(F3): Handle mask colors
        setupImage( m_aImages.addImage(xBitmap) );
    }

    void PDFIProcessor::drawMaskedImage(const uno::Sequence<beans::PropertyValue>& xBitmap,
                                        const uno::Sequence<beans::PropertyValue>& /*xMask*/,
                                        bool                                       /*bInvertMask*/)
    {
        // TODO(F3): Handle mask and inversion
        setupImage( m_aImages.addImage(xBitmap) );
    }

    void PDFIProcessor::drawAlphaMaskedImage(const uno::Sequence<beans::PropertyValue>& xBitmap,
                                             const uno::Sequence<beans::PropertyValue>& /*xMask*/)
    {
        // TODO(F3): Handle mask

        setupImage( m_aImages.addImage(xBitmap) );

    }

    void PDFIProcessor::strokePath( const uno::Reference< rendering::XPolyPolygon2D >& rPath )
    {
        basegfx::B2DPolyPolygon aPoly=basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(rPath);
        aPoly.transform(getCurrentContext().Transformation);

        PolyPolyElement* pPoly = ElementFactory::createPolyPolyElement(
            m_pCurElement,
            getGCId(getCurrentContext()),
            aPoly,
            PATH_STROKE );
        pPoly->updateGeometry();
        pPoly->ZOrder = m_nNextZOrder++;
    }

    void PDFIProcessor::fillPath( const uno::Reference< rendering::XPolyPolygon2D >& rPath )
    {
        basegfx::B2DPolyPolygon aPoly=basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(rPath);
        aPoly.transform(getCurrentContext().Transformation);

        PolyPolyElement* pPoly = ElementFactory::createPolyPolyElement(
            m_pCurElement,
            getGCId(getCurrentContext()),
            aPoly,
            PATH_FILL );
        pPoly->updateGeometry();
        pPoly->ZOrder = m_nNextZOrder++;
    }

    void PDFIProcessor::eoFillPath( const uno::Reference< rendering::XPolyPolygon2D >& rPath )
    {
        basegfx::B2DPolyPolygon aPoly=basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(rPath);
        aPoly.transform(getCurrentContext().Transformation);

        PolyPolyElement* pPoly = ElementFactory::createPolyPolyElement(
            m_pCurElement,
            getGCId(getCurrentContext()),
            aPoly,
            PATH_EOFILL );
        pPoly->updateGeometry();
        pPoly->ZOrder = m_nNextZOrder++;
    }

    void PDFIProcessor::intersectClip(const uno::Reference< rendering::XPolyPolygon2D >& rPath)
    {
        // TODO(F3): interpret fill mode
        basegfx::B2DPolyPolygon aNewClip = basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(rPath);
        aNewClip.transform(getCurrentContext().Transformation);
        basegfx::B2DPolyPolygon aCurClip = getCurrentContext().Clip;

        if( aCurClip.count() )  // #i92985# adapted API from (..., false, false) to (..., true, false)
            aNewClip = basegfx::utils::clipPolyPolygonOnPolyPolygon( aCurClip, aNewClip, true, false );

        getCurrentContext().Clip = aNewClip;
    }

    void PDFIProcessor::intersectEoClip(const uno::Reference< rendering::XPolyPolygon2D >& rPath)
    {
        // TODO(F3): interpret fill mode
        basegfx::B2DPolyPolygon aNewClip = basegfx::unotools::b2DPolyPolygonFromXPolyPolygon2D(rPath);
        aNewClip.transform(getCurrentContext().Transformation);
        basegfx::B2DPolyPolygon aCurClip = getCurrentContext().Clip;

        if( aCurClip.count() )  // #i92985# adapted API from (..., false, false) to (..., true, false)
            aNewClip = basegfx::utils::clipPolyPolygonOnPolyPolygon( aCurClip, aNewClip, true, false );

        getCurrentContext().Clip = aNewClip;
    }

    void PDFIProcessor::hyperLink( const geometry::RealRectangle2D& rBounds,
                                   const OUString&           rURI )
    {
        if( !rURI.isEmpty() )
        {
            HyperlinkElement* pLink = ElementFactory::createHyperlinkElement(
                &m_pCurPage->Hyperlinks,
                rURI );
            pLink->x = rBounds.X1;
            pLink->y = rBounds.Y1;
            pLink->w = rBounds.X2-rBounds.X1;
            pLink->h = rBounds.Y2-rBounds.Y1;
        }
    }

    const FontAttributes& PDFIProcessor::getFont( sal_Int32 nFontId ) const
    {
        IdToFontMap::const_iterator it = m_aIdToFont.find( nFontId );
        if( it == m_aIdToFont.end() )
            it = m_aIdToFont.find( 0 );
        return it->second;
    }

    sal_Int32 PDFIProcessor::getGCId( const GraphicsContext& rGC )
    {
        sal_Int32 nGCId = 0;
        auto it = m_aGCToId.left.find( rGC );
        if( it != m_aGCToId.left.end() )
            nGCId = it->second;
        else
        {
            m_aGCToId.insert(GCToIdBiMap::relation(rGC, m_nNextGCId));
            nGCId = m_nNextGCId;
            m_nNextGCId++;
        }

        return nGCId;
    }

    const GraphicsContext& PDFIProcessor::getGraphicsContext( sal_Int32 nGCId ) const
    {
        auto it = m_aGCToId.right.find( nGCId );
        if( it == m_aGCToId.right.end() )
            it = m_aGCToId.right.find( 0 );
        return it->second;
    }

    void PDFIProcessor::endPage()
    {
        processGlyphLine(); // draw last line
        if( m_xStatusIndicator.is()
            && m_pCurPage
            && m_pCurPage->PageNumber == m_nPages
        )
            m_xStatusIndicator->end();
    }

    void PDFIProcessor::startPage( const geometry::RealSize2D& rSize )
    {
        // initial clip is to page bounds
        getCurrentContext().Clip = basegfx::B2DPolyPolygon(
            basegfx::utils::createPolygonFromRect(
                basegfx::B2DRange( 0, 0, rSize.Width, rSize.Height )));

        sal_Int32 nNextPageNr = m_pCurPage ? m_pCurPage->PageNumber+1 : 1;
        if( m_xStatusIndicator.is() )
        {
            if( nNextPageNr == 1 )
                startIndicator( " " );
            m_xStatusIndicator->setValue( nNextPageNr );
        }
        m_pCurPage = ElementFactory::createPageElement(m_pDocument.get(), nNextPageNr);
        m_pCurElement = m_pCurPage;
        m_pCurPage->w = rSize.Width;
        m_pCurPage->h = rSize.Height;
        m_nNextZOrder = 1;

    }

    void PDFIProcessor::emit( XmlEmitter&               rEmitter,
                              const TreeVisitorFactory& rVisitorFactory )
    {
    #if OSL_DEBUG_LEVEL > 0
        m_pDocument->emitStructure( 0 );
    #endif

        ElementTreeVisitorSharedPtr optimizingVisitor(
            rVisitorFactory.createOptimizingVisitor(*this));
        // FIXME: localization
        startIndicator( " " );
        m_pDocument->visitedBy( *optimizingVisitor, std::list<std::unique_ptr<Element>>::const_iterator());

    #if OSL_DEBUG_LEVEL > 0
        m_pDocument->emitStructure( 0 );
    #endif

        // get styles
        StyleContainer aStyles;
        ElementTreeVisitorSharedPtr finalizingVisitor(
            rVisitorFactory.createStyleCollectingVisitor(aStyles,*this));
        // FIXME: localization

        m_pDocument->visitedBy( *finalizingVisitor, std::list<std::unique_ptr<Element>>::const_iterator() );

        EmitContext aContext( rEmitter, aStyles, m_aImages, *this, m_xStatusIndicator, m_xContext );
        ElementTreeVisitorSharedPtr aEmittingVisitor(
            rVisitorFactory.createEmittingVisitor(aContext));

        PropertyMap aProps;
        // document prolog
        #define OASIS_STR "urn:oasis:names:tc:opendocument:xmlns:"
        aProps[ "xmlns:office" ]      = OASIS_STR "office:1.0" ;
        aProps[ "xmlns:style" ]       = OASIS_STR "style:1.0" ;
        aProps[ "xmlns:text" ]        = OASIS_STR "text:1.0" ;
        aProps[ "xmlns:svg" ]         = OASIS_STR "svg-compatible:1.0" ;
        aProps[ "xmlns:table" ]       = OASIS_STR "table:1.0" ;
        aProps[ "xmlns:draw" ]        = OASIS_STR "drawing:1.0" ;
        aProps[ "xmlns:fo" ]          = OASIS_STR "xsl-fo-compatible:1.0" ;
        aProps[ "xmlns:xlink"]        = "http://www.w3.org/1999/xlink";
        aProps[ "xmlns:dc"]           = "http://purl.org/dc/elements/1.1/";
        aProps[ "xmlns:number"]       = OASIS_STR "datastyle:1.0" ;
        aProps[ "xmlns:presentation"] = OASIS_STR "presentation:1.0" ;
        aProps[ "xmlns:math"]         = "http://www.w3.org/1998/Math/MathML";
        aProps[ "xmlns:form"]         = OASIS_STR "form:1.0" ;
        aProps[ "xmlns:script"]       = OASIS_STR "script:1.0" ;
        aProps[ "xmlns:dom"]          = "http://www.w3.org/2001/xml-events";
        aProps[ "xmlns:xforms"]       = "http://www.w3.org/2002/xforms";
        aProps[ "xmlns:xsd"]          = "http://www.w3.org/2001/XMLSchema";
        aProps[ "xmlns:xsi"]          = "http://www.w3.org/2001/XMLSchema-instance";
        aProps[ "office:version" ]    = "1.0";

        aContext.rEmitter.beginTag( "office:document", aProps );

        // emit style list
        aStyles.emit( aContext, *aEmittingVisitor );

        m_pDocument->visitedBy( *aEmittingVisitor, std::list<std::unique_ptr<Element>>::const_iterator() );
        aContext.rEmitter.endTag( "office:document" );
        endIndicator();
    }

    void PDFIProcessor::startIndicator( const OUString& rText  )
    {
        sal_Int32 nElements = m_nPages;
        if( m_xStatusIndicator.is() )
        {
            sal_Int32 nLength = rText.getLength();
            OUStringBuffer aStr( nLength*2 );
            const sal_Unicode* pText = rText.getStr();
            for( int i = 0; i < nLength; i++ )
            {
                if( nLength-i > 1&&
                    pText[i]   == '%' &&
                    pText[i+1] == 'd'
                )
                {
                    aStr.append( nElements );
                    i++;
                }
                else
                    aStr.append( pText[i] );
            }
            m_xStatusIndicator->start( aStr.makeStringAndClear(), nElements );
        }
    }

    void PDFIProcessor::endIndicator()
    {
        if( m_xStatusIndicator.is() )
            m_xStatusIndicator->end();
    }

    static bool lr_tb_sort( std::unique_ptr<Element> const & pLeft, std::unique_ptr<Element> const & pRight )
    {
        // Ensure irreflexivity (which could be compromised if h or w is negative):
        if (pLeft == pRight)
            return false;

        // first: top-bottom sorting

        // Note: allow for 10% overlap on text lines since text lines are usually
        // of the same order as font height whereas the real paint area
        // of text is usually smaller
        double fudge_factor_left = 0.0, fudge_factor_right = 0.0;
        if( dynamic_cast< TextElement* >(pLeft.get()) )
            fudge_factor_left = 0.1;
        if (dynamic_cast< TextElement* >(pRight.get()))
            fudge_factor_right = 0.1;

        // Allow negative height
        double lower_boundary_left  = pLeft->y  + std::max(pLeft->h, 0.0)  - fabs(pLeft->h)  * fudge_factor_left;
        double lower_boundary_right = pRight->y + std::max(pRight->h, 0.0) - fabs(pRight->h) * fudge_factor_right;
        double upper_boundary_left  = pLeft->y  + std::min(pLeft->h, 0.0);
        double upper_boundary_right = pRight->y + std::min(pRight->h, 0.0);
        // if left's lower boundary is above right's upper boundary
        // then left is smaller
        if( lower_boundary_left < upper_boundary_right )
            return true;
        // if right's lower boundary is above left's upper boundary
        // then left is definitely not smaller
        if( lower_boundary_right < upper_boundary_left )
            return false;

        // Allow negative width
        double left_boundary_left   = pLeft->y  + std::min(pLeft->w, 0.0);
        double left_boundary_right  = pRight->y + std::min(pRight->w, 0.0);
        double right_boundary_left  = pLeft->y  + std::max(pLeft->w, 0.0);
        double right_boundary_right = pRight->y + std::max(pRight->w, 0.0);
        // by now we have established that left and right are inside
        // a "line", that is they have vertical overlap
        // second: left-right sorting
        // if left's right boundary is left to right's left boundary
        // then left is smaller
        if( right_boundary_left < left_boundary_right )
            return true;
        // if right's right boundary is left to left's left boundary
        // then left is definitely not smaller
        if( right_boundary_right < left_boundary_left )
            return false;

        // here we have established vertical and horizontal overlap
        // so sort left first, top second
        if( pLeft->x < pRight->x )
            return true;
        if( pRight->x < pLeft->x )
            return false;
        if( pLeft->y < pRight->y )
            return true;

        return false;
    }

    void PDFIProcessor::sortElements(Element* pEle)
    {
        if( pEle->Children.empty() )
            return;

        // sort method from std::list is equivalent to stable_sort
        // See S Meyers, Effective STL
        pEle->Children.sort(lr_tb_sort);
    }

    // helper method: get a mirrored string
    OUString PDFIProcessor::mirrorString( const OUString& i_rString )
    {
        const sal_Int32 nLen = i_rString.getLength();
        OUStringBuffer aMirror( nLen );

        sal_Int32 i = 0;
        while(i < nLen)
        {
            // read one code point
            const sal_uInt32 nCodePoint = i_rString.iterateCodePoints( &i );

            // and append it mirrored
            aMirror.appendUtf32( GetMirroredChar(nCodePoint) );
        }
        return aMirror.makeStringAndClear();
    }

    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V773 Visibility scope of the 'pPoly' pointer was exited without releasing the memory. A memory leak is possible.

↑ V773 Visibility scope of the 'pPoly' pointer was exited without releasing the memory. A memory leak is possible.

↑ V773 Visibility scope of the 'pLink' pointer was exited without releasing the memory. A memory leak is possible.

↑ V773 Visibility scope of the 'pPoly' pointer was exited without releasing the memory. A memory leak is possible.