Quelle TitleHelper.cxx

Sprache: C

/* -*- 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 <TitleHelper.hxx>
#include <Title.hxx>
#include <ChartModel.hxx>
#include <Axis.hxx>
#include <AxisHelper.hxx>
#include <Diagram.hxx>
#include <ReferenceSizeProvider.hxx>
#include <com/sun/star/chart2/FormattedString.hpp>
#include <rtl/ustrbuf.hxx>
#include <comphelper/diagnose_ex.hxx>
#include <sal/log.hxx>

namespace chart
{

using namespace ::com::sun::star;
using namespace ::com::sun::star::chart2;
using ::com::sun::star::uno::Reference;

namespace {

uno::Reference< XTitled > lcl_getTitleParentFromDiagram(
      TitleHelper::eTitleType nTitleIndex
    , const rtl::Reference< Diagram >& xDiagram )
{
    uno::Reference< XTitled > xResult;

    if( nTitleIndex == TitleHelper::TITLE_AT_STANDARD_X_AXIS_POSITION ||
        nTitleIndex == TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION )
    {
        bool bDummy = false;
        bool bIsVertical = xDiagram && xDiagram->getVertical( bDummy, bDummy );

        if( nTitleIndex == TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION )
            nTitleIndex = bIsVertical ? TitleHelper::X_AXIS_TITLE : TitleHelper::Y_AXIS_TITLE;
        else
            nTitleIndex = bIsVertical ? TitleHelper::Y_AXIS_TITLE : TitleHelper::X_AXIS_TITLE;
    }

    switch( nTitleIndex )
    {
        case TitleHelper::SUB_TITLE:
            if( xDiagram.is())
                xResult = xDiagram;
            break;
        case TitleHelper::X_AXIS_TITLE:
            if( xDiagram.is())
                xResult = AxisHelper::getAxis( 0, true, xDiagram );
            break;
        case TitleHelper::Y_AXIS_TITLE:
            if( xDiagram.is())
                xResult = AxisHelper::getAxis( 1, true, xDiagram );
            break;
        case TitleHelper::Z_AXIS_TITLE:
            if( xDiagram.is())
                xResult = AxisHelper::getAxis( 2, true, xDiagram );
            break;
        case TitleHelper::SECONDARY_X_AXIS_TITLE:
            if( xDiagram.is())
                xResult = AxisHelper::getAxis( 0, false, xDiagram );
            break;
        case TitleHelper::SECONDARY_Y_AXIS_TITLE:
            if( xDiagram.is())
                xResult = AxisHelper::getAxis( 1, false, xDiagram );
            break;

        case TitleHelper::MAIN_TITLE:
        default:
            OSL_FAIL( "Unsupported Title-Type requested" );
            break;
    }

    return xResult;
}

uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleIndex
                                              , const rtl::Reference< Diagram >& xDiagram )
{
    uno::Reference< XTitled > xResult;
    switch( nTitleIndex )
    {
        case TitleHelper::MAIN_TITLE:
            SAL_WARN("chart2", "should not be reached");
            break;
        case TitleHelper::SUB_TITLE:
        case TitleHelper::X_AXIS_TITLE:
        case TitleHelper::Y_AXIS_TITLE:
        case TitleHelper::Z_AXIS_TITLE:
        case TitleHelper::TITLE_AT_STANDARD_X_AXIS_POSITION:
        case TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION:
        case TitleHelper::SECONDARY_X_AXIS_TITLE:
        case TitleHelper::SECONDARY_Y_AXIS_TITLE:
            xResult.set( lcl_getTitleParentFromDiagram( nTitleIndex, xDiagram ));
            break;
        default:
            OSL_FAIL( "Unsupported Title-Type requested" );
            break;
    }

    return xResult;
}

uno::Reference< XTitled > lcl_getTitleParent( TitleHelper::eTitleType nTitleIndex
                                              , const rtl::Reference<::chart::ChartModel>& xModel )
{
    if(nTitleIndex == TitleHelper::MAIN_TITLE)
    {
        return xModel;
    }

    rtl::Reference< Diagram > xDiagram;

    if( xModel.is())
        xDiagram = xModel->getFirstChartDiagram();

    return lcl_getTitleParent( nTitleIndex, xDiagram );
}

}

rtl::Reference< Title > TitleHelper::getTitle( TitleHelper::eTitleType nTitleIndex
                            , ChartModel& rModel )
{
    if(nTitleIndex == TitleHelper::MAIN_TITLE)
        return rModel.getTitleObject2();

    rtl::Reference< Diagram > xDiagram = rModel.getFirstChartDiagram();
    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xDiagram ) );
    if( !xTitled )
        return nullptr;
    uno::Reference<XTitle> xTitle = xTitled->getTitleObject();
    auto pTitle = dynamic_cast<Title*>(xTitle.get());
    assert(!xTitle || pTitle);
    return pTitle;
}

rtl::Reference< Title > TitleHelper::getTitle( TitleHelper::eTitleType nTitleIndex
                            , const rtl::Reference<ChartModel>& xModel )
{
    uno::Reference< XTitled > xTitled;
    if(nTitleIndex == TitleHelper::MAIN_TITLE)
    {
        xTitled = xModel;
    }
    else
    {
        rtl::Reference< Diagram > xDiagram;
        if( xModel.is())
            xDiagram = xModel->getFirstChartDiagram();
        xTitled = lcl_getTitleParent( nTitleIndex, xDiagram );
    }
    if( !xTitled )
        return nullptr;
    uno::Reference<XTitle> xTitle = xTitled->getTitleObject();
    Title* pTitle = dynamic_cast<Title*>(xTitle.get());
    assert(!xTitle || pTitle);
    return pTitle;
}

rtl::Reference< Title > TitleHelper::createOrShowTitle(
      TitleHelper::eTitleType eTitleType
    , const OUString& rTitleText
    , const rtl::Reference<ChartModel>& xModel
    , const uno::Reference< uno::XComponentContext > & xContext )
{
    rtl::Reference< Title > xTitled( TitleHelper::getTitle( eTitleType, xModel ) );
    if( xTitled.is())
    {
        xTitled->setPropertyValue(u"Visible"_ustr,css::uno::Any(true));
        return xTitled;
    }
    else
    {
        return createTitle(eTitleType, rTitleText, xModel, xContext, nullptr/*pRefSizeProvider*/);
    }
}

rtl::Reference< Title > TitleHelper::createTitle(
      TitleHelper::eTitleType eTitleType
    , const OUString& rTitleText
    , const rtl::Reference<ChartModel>& xModel
    , const uno::Reference< uno::XComponentContext > & xContext
    , ReferenceSizeProvider * pRefSizeProvider )
{
    rtl::Reference< ::chart::Title > xTitle;
    uno::Reference< XTitled > xTitled( lcl_getTitleParent( eTitleType, xModel ) );

    if( !xTitled.is() )
    {
        rtl::Reference< Diagram > xDiagram( xModel->getFirstChartDiagram() );
        rtl::Reference< Axis > xAxis;
        switch( eTitleType )
        {
            case TitleHelper::SECONDARY_X_AXIS_TITLE:
                xAxis = AxisHelper::createAxis( 0, false, xDiagram, xContext );
                break;
            case TitleHelper::SECONDARY_Y_AXIS_TITLE:
                xAxis = AxisHelper::createAxis( 1, false, xDiagram, xContext );
               break;
            default:
               break;
        }
        if( xAxis.is() )
        {
            xAxis->setPropertyValue( u"Show"_ustr, uno::Any( false ) );
            xTitled = lcl_getTitleParent( eTitleType, xModel );
        }
    }

    if(xTitled.is())
    {
        rtl::Reference< Diagram > xDiagram( xModel->getFirstChartDiagram() );

        xTitle = new ::chart::Title();

        // default char height (main: 13.0 == default)
        float fDefaultCharHeightSub = 11.0;
        float fDefaultCharHeightAxis = 9.0;
        switch( eTitleType )
        {
            case TitleHelper::SUB_TITLE:
                TitleHelper::setCompleteString(
                    rTitleText, xTitle, xContext, & fDefaultCharHeightSub );
                break;
            case TitleHelper::X_AXIS_TITLE:
            case TitleHelper::Y_AXIS_TITLE:
            case TitleHelper::Z_AXIS_TITLE:
            case TitleHelper::TITLE_AT_STANDARD_X_AXIS_POSITION:
            case TitleHelper::TITLE_AT_STANDARD_Y_AXIS_POSITION:
            case TitleHelper::SECONDARY_X_AXIS_TITLE:
            case TitleHelper::SECONDARY_Y_AXIS_TITLE:
                TitleHelper::setCompleteString(
                    rTitleText, xTitle, xContext, & fDefaultCharHeightAxis );
                break;
            default:
                TitleHelper::setCompleteString( rTitleText, xTitle, xContext );
                break;
        }

        // set/clear autoscale
        if( pRefSizeProvider )
            pRefSizeProvider->setValuesAtTitle( xTitle );

        xTitled->setTitleObject( xTitle );

        //default rotation 90 degree for y axis title in normal coordinatesystems or for x axis title for swapped coordinatesystems
        if( eTitleType == TitleHelper::X_AXIS_TITLE ||
            eTitleType == TitleHelper::Y_AXIS_TITLE ||
            eTitleType == TitleHelper::SECONDARY_X_AXIS_TITLE ||
            eTitleType == TitleHelper::SECONDARY_Y_AXIS_TITLE )

        {
            try
            {
                bool bDummy = false;
                bool bIsVertical = xDiagram->getVertical( bDummy, bDummy );

                if( (!bIsVertical && eTitleType == TitleHelper::Y_AXIS_TITLE)
                    || (bIsVertical && eTitleType == TitleHelper::X_AXIS_TITLE)
                    || (!bIsVertical && eTitleType == TitleHelper::SECONDARY_Y_AXIS_TITLE)
                    || (bIsVertical && eTitleType == TitleHelper::SECONDARY_X_AXIS_TITLE) )
                {
                    xTitle->setPropertyValue( u"TextRotation"_ustr, uno::Any( 90.0 ));
                }
            }
            catch( const uno::Exception & )
            {
                DBG_UNHANDLED_EXCEPTION("chart2");
            }
        }
    }
    return xTitle;

}

OUString TitleHelper::getCompleteString( const rtl::Reference< Title >& xTitle )
{
    if(!xTitle.is())
        return OUString();
    OUStringBuffer aRet;
    const uno::Sequence< uno::Reference< XFormattedString > > aStringList = xTitle->getText();
    for( uno::Reference< XFormattedString > const & formattedStr : aStringList )
        aRet.append( formattedStr->getString() );
    return aRet.makeStringAndClear();
}

OUString TitleHelper::getUnstackedStr(const OUString& rNewText)
{
    //#i99841# remove linebreaks that were added for vertical stacking
    OUStringBuffer aUnstackedStr;
    OUStringBuffer aSource(rNewText);

    bool bBreakIgnored = false;
    sal_Int32 nLen = rNewText.getLength();
    for (sal_Int32 nPos = 0; nPos < nLen; ++nPos)
    {
        sal_Unicode aChar = aSource[nPos];
        if (aChar != '\n')
        {
            aUnstackedStr.append(aChar);
            bBreakIgnored = false;
        }
        else if (aChar == '\n' && bBreakIgnored)
            aUnstackedStr.append(aChar);
        else
            bBreakIgnored = true;
    }
    return aUnstackedStr.makeStringAndClear();
}

void TitleHelper::setFormattedString( const rtl::Reference< Title >& xTitle,
    const css::uno::Sequence< css::uno::Reference< css::chart2::XFormattedString > >& aNewFormattedTitle )
{
    if (!xTitle.is() || !aNewFormattedTitle.hasElements())
        return;

    bool bStacked = false;
    xTitle->getPropertyValue(u"StackCharacters"_ustr) >>= bStacked;

    if (bStacked)
    {
        for (uno::Reference< chart2::XFormattedString >const& formattedStr : aNewFormattedTitle)
        {
            formattedStr->setString(TitleHelper::getUnstackedStr(formattedStr->getString()));
        }
    }

    xTitle->setText(aNewFormattedTitle);
}

void TitleHelper::setCompleteString( const OUString& rNewText
                    , const rtl::Reference< Title >& xTitle
                    , const uno::Reference< uno::XComponentContext > & xContext
                    , const float * pDefaultCharHeight /* = 0 */
                    , bool bDialogTitle /*= false*/ )
{
    if (!xTitle.is())
        return;

    bool bStacked = false;
    if( xTitle.is() )
        xTitle->getPropertyValue( u"StackCharacters"_ustr ) >>= bStacked;

    OUString aNewText = rNewText;
    if( bStacked )
    {
        aNewText = getUnstackedStr(rNewText);
    }

    uno::Sequence< uno::Reference< XFormattedString > > aNewStringList;
    uno::Sequence< uno::Reference< XFormattedString > > aOldStringList = xTitle->getText();
    if( aOldStringList.hasElements())
    {
        const OUString aFullString = getCompleteString(xTitle);
        if (bDialogTitle && aNewText.equals(getUnstackedStr(aFullString)))
        {
            // If the new title setted from a dialog window to a new string
            // the first old text portion will be maintained if it's a new string,
            // otherwise we use the original one.
            aNewStringList = std::move(aOldStringList);
        }
        else
        {
            // If the new title setted from a dialog to a new string the first
            // old text portion will be maintained if there was any. Also in case of ODF
            // import which still not support non-uniform formatted titles
            aNewStringList = { aOldStringList[0] };
            aNewStringList[0]->setString(aNewText);
        }
    }
    else
    {
        uno::Reference< chart2::XFormattedString2 > xFormattedString =
            chart2::FormattedString::create( xContext );

        xFormattedString->setString( aNewText );
        aNewStringList = { xFormattedString };
        if( pDefaultCharHeight != nullptr )
        {
            try
            {
                uno::Any aFontSize( *pDefaultCharHeight );
                xFormattedString->setPropertyValue( u"CharHeight"_ustr, aFontSize );
                xFormattedString->setPropertyValue( u"CharHeightAsian"_ustr, aFontSize );
                xFormattedString->setPropertyValue( u"CharHeightComplex"_ustr, aFontSize );
            }
            catch( const uno::Exception & )
            {
                DBG_UNHANDLED_EXCEPTION("chart2");
            }
        }
    }
    xTitle->setText( aNewStringList );
}

void TitleHelper::removeTitle( TitleHelper::eTitleType nTitleIndex
                    , const rtl::Reference<ChartModel>& xModel )
{
    uno::Reference< XTitled > xTitled( lcl_getTitleParent( nTitleIndex, xModel ) );
    if( xTitled.is())
    {
        xTitled->setTitleObject(nullptr);
    }
}

bool TitleHelper::getTitleType( eTitleType& rType
                    , const rtl::Reference< Title >& xTitle
                    , const rtl::Reference<ChartModel>& xModel )
{
    if( !xTitle.is() || !xModel.is() )
        return false;

    rtl::Reference< Title > xCurrentTitle;
    for( sal_Int32 nTitleType = TITLE_BEGIN; nTitleType < NORMAL_TITLE_END; nTitleType++ )
    {
        xCurrentTitle = TitleHelper::getTitle( static_cast<eTitleType>(nTitleType), xModel );
        if( xCurrentTitle == xTitle )
        {
            rType = static_cast<eTitleType>(nTitleType);
            return true;
        }
    }

    return false;
}

void TitleHelper::hideTitle( TitleHelper::eTitleType nTitleIndex
        , const rtl::Reference<ChartModel>& xModel)
{
    rtl::Reference< Title > xTitled( TitleHelper::getTitle( nTitleIndex, xModel ) );
    if( xTitled.is())
        xTitled->setPropertyValue(u"Visible"_ustr,css::uno::Any(false));
}

} //namespace chart

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

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.5 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.