/src/libreoffice/chart2/source/controller/itemsetwrapper/CharacterPropertyItemConverter.cxx

Source
/* -*- 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 <CharacterPropertyItemConverter.hxx>
#include "SchWhichPairs.hxx"
#include <ItemPropertyMap.hxx>
#include <RelativeSizeHelper.hxx>
#include <editeng/memberids.h>
#include <editeng/eeitem.hxx>
#include <editeng/udlnitem.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/postitem.hxx>
#include <editeng/wghtitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <o3tl/any.hxx>
#include <svl/stritem.hxx>

#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/chart2/XFormattedString.hpp>
#include <utility>
#include <comphelper/diagnose_ex.hxx>

using namespace ::com::sun::star;

namespace chart::wrapper {

namespace {

ItemPropertyMapType & lcl_GetCharacterPropertyPropertyMap()
{
    static ItemPropertyMapType aCharacterPropertyMap{
        {EE_CHAR_COLOR, {"CharColor", 0}},
        {EE_CHAR_LANGUAGE, {"CharLocale", MID_LANG_LOCALE}},
        {EE_CHAR_LANGUAGE_CJK, {"CharLocaleAsian", MID_LANG_LOCALE}},
        {EE_CHAR_LANGUAGE_CTL, {"CharLocaleComplex", MID_LANG_LOCALE}},

        {EE_CHAR_STRIKEOUT, {"CharStrikeout", MID_CROSS_OUT}},
        {EE_CHAR_WLM, {"CharWordMode", 0}},
        {EE_CHAR_SHADOW, {"CharShadowed", 0}},
        {EE_CHAR_RELIEF, {"CharRelief", 0}},
        {EE_CHAR_OUTLINE, {"CharContoured", 0}},
        {EE_CHAR_EMPHASISMARK, {"CharEmphasis", 0}},

        {EE_PARA_WRITINGDIR, {"WritingMode", 0}},

        {EE_PARA_ASIANCJKSPACING, {"ParaIsCharacterDistance", 0}}};

    return aCharacterPropertyMap;
}
} // anonymous namespace

CharacterPropertyItemConverter::CharacterPropertyItemConverter(
    const uno::Reference< beans::XPropertySet > & rPropertySet,
    SfxItemPool& rItemPool ) :
        ItemConverter( rPropertySet, rItemPool )
{}

CharacterPropertyItemConverter::CharacterPropertyItemConverter(
    const uno::Reference< beans::XPropertySet > & rPropertySet,
    SfxItemPool& rItemPool,
    const std::optional<awt::Size>& pRefSize,
    OUString aRefSizePropertyName,
    const uno::Reference< beans::XPropertySet > & rRefSizePropSet ) :
        ItemConverter( rPropertySet, rItemPool ),
        m_aRefSizePropertyName(std::move( aRefSizePropertyName )),
        m_xRefSizePropSet( rRefSizePropSet.is() ? rRefSizePropSet : rPropertySet )
{
    if (pRefSize)
        m_pRefSize = *pRefSize;
}

CharacterPropertyItemConverter::~CharacterPropertyItemConverter()
{}

const WhichRangesContainer& CharacterPropertyItemConverter::GetWhichPairs() const
{
    return nCharacterPropertyWhichPairs;
}

bool CharacterPropertyItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
{
    ItemPropertyMapType & rMap( lcl_GetCharacterPropertyPropertyMap());
    ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId ));

    if( aIt == rMap.end())
        return false;

    rOutProperty =(*aIt).second;
    return true;
}

void CharacterPropertyItemConverter::FillSpecialItem(
    sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
{
    switch( nWhichId )
    {
        case EE_CHAR_FONTINFO:
        case EE_CHAR_FONTINFO_CJK:
        case EE_CHAR_FONTINFO_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_FONTINFO_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_FONTINFO_CTL )
                aPostfix = "Complex";

            SvxFontItem aItem( nWhichId );

            aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix),
                            MID_FONT_FAMILY_NAME );
            aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix),
                            MID_FONT_FAMILY );
            aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix),
                            MID_FONT_STYLE_NAME );
            aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix),
                            MID_FONT_CHAR_SET );
            aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix),
                            MID_FONT_PITCH );

            rOutItemSet.Put( aItem );
        }
        break;

        case EE_CHAR_UNDERLINE:
        {
            SvxUnderlineItem aItem(LINESTYLE_NONE, EE_CHAR_UNDERLINE);
            bool bModified = false;

            uno::Any aValue( GetPropertySet()->getPropertyValue( u"CharUnderline"_ustr ));
            if( aValue.hasValue())
            {
                aItem.PutValue( aValue, MID_TL_STYLE );
                bModified = true;
            }

            aValue = GetPropertySet()->getPropertyValue( u"CharUnderlineHasColor"_ustr );
            if( aValue.hasValue() && *o3tl::doAccess<bool>(aValue) )
            {
                aItem.PutValue( aValue, MID_TL_HASCOLOR );
                bModified = true;
            }

            aValue = GetPropertySet()->getPropertyValue( u"CharUnderlineColor"_ustr );
            if( aValue.hasValue())
            {
                aItem.PutValue( aValue, MID_TL_COLOR );
                bModified = true;
            }

            if( bModified )
                rOutItemSet.Put( aItem );
        }
        break;

        case EE_CHAR_OVERLINE:
        {
            SvxOverlineItem aItem( LINESTYLE_NONE, EE_CHAR_OVERLINE );
            bool bModified = false;

            uno::Any aValue( GetPropertySet()->getPropertyValue( u"CharOverline"_ustr ) );
            if ( aValue.hasValue() )
            {
                aItem.PutValue( aValue, MID_TL_STYLE );
                bModified = true;
            }

            aValue = GetPropertySet()->getPropertyValue( u"CharOverlineHasColor"_ustr );
            if ( aValue.hasValue() && *o3tl::doAccess<bool>(aValue) )
            {
                aItem.PutValue( aValue, MID_TL_HASCOLOR );
                bModified = true;
            }

            aValue = GetPropertySet()->getPropertyValue( u"CharOverlineColor"_ustr );
            if ( aValue.hasValue() )
            {
                aItem.PutValue( aValue, MID_TL_COLOR );
                bModified = true;
            }

            if ( bModified )
            {
                rOutItemSet.Put( aItem );
            }
        }
        break;

        case EE_CHAR_ITALIC:
        case EE_CHAR_ITALIC_CJK:
        case EE_CHAR_ITALIC_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_ITALIC_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_ITALIC_CTL )
                aPostfix = "Complex";

            SvxPostureItem aItem( ITALIC_NONE, nWhichId );

            uno::Any aValue( GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix));
            if( aValue.hasValue())
            {
                aItem.PutValue( aValue, MID_POSTURE );
                rOutItemSet.Put( aItem );
            }
        }
        break;

        case EE_CHAR_WEIGHT:
        case EE_CHAR_WEIGHT_CJK:
        case EE_CHAR_WEIGHT_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_WEIGHT_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_WEIGHT_CTL )
                aPostfix = "Complex";

            SvxWeightItem aItem( WEIGHT_NORMAL, nWhichId );

            uno::Any aValue( GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix));
            if( aValue.hasValue())
            {
                aItem.PutValue( aValue, MID_WEIGHT );
                rOutItemSet.Put( aItem );
            }
        }
        break;

        case EE_CHAR_FONTHEIGHT:
        case EE_CHAR_FONTHEIGHT_CJK:
        case EE_CHAR_FONTHEIGHT_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
                aPostfix = "Complex";

            SvxFontHeightItem aItem( 240, 100, nWhichId );

            try
            {
                uno::Any aValue( GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ));
                float fHeight;
                if( aValue >>= fHeight )
                {
                    if (m_pRefSize)
                    {
                        awt::Size aOldRefSize;
                        if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
                        {
                            // calculate font height in view
                            fHeight = static_cast< float >(
                                RelativeSizeHelper::calculate( fHeight, aOldRefSize, *m_pRefSize ));
                            aValue <<= fHeight;
                        }
                    }

                    aItem.PutValue( aValue, MID_FONTHEIGHT );
                    rOutItemSet.Put( aItem );
                }
            }
            catch( const uno::Exception & )
            {
                DBG_UNHANDLED_EXCEPTION("chart2");
            }
        }
        break;

        case SID_CHAR_DLG_PREVIEW_STRING:
        {
            uno::Reference< chart2::XFormattedString > xFormattedString( GetPropertySet(), uno::UNO_QUERY );
            if( xFormattedString.is() )
            {
                OUString aString = xFormattedString->getString();
                rOutItemSet.Put( SfxStringItem( nWhichId, aString ) );
            }
            else
                rOutItemSet.Put( SfxStringItem( nWhichId, OUString() ) );
        }
        break;

        case EE_PARA_FORBIDDENRULES:
        case EE_PARA_HANGINGPUNCTUATION:
            rOutItemSet.DisableItem( nWhichId );
            break;
    }
}

bool CharacterPropertyItemConverter::ApplySpecialItem(
    sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
{
    bool bChanged = false;
    uno::Any aValue;

    switch( nWhichId )
    {
        case EE_CHAR_FONTINFO:
        case EE_CHAR_FONTINFO_CJK:
        case EE_CHAR_FONTINFO_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_FONTINFO_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_FONTINFO_CTL )
                aPostfix = "Complex";

            const SvxFontItem & rItem =
                static_cast< const SvxFontItem & >(
                    rItemSet.Get( nWhichId ));

            if( rItem.QueryValue( aValue, MID_FONT_FAMILY_NAME ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix ))
                {
                    GetPropertySet()->setPropertyValue( "CharFontName" + aPostfix, aValue );
                    bChanged = true;
                }
            }
            if( rItem.QueryValue( aValue, MID_FONT_FAMILY ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix ))
                {
                    GetPropertySet()->setPropertyValue( "CharFontFamily" + aPostfix, aValue );
                    bChanged = true;
                }
            }
            if( rItem.QueryValue( aValue, MID_FONT_STYLE_NAME ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix ))
                {
                    GetPropertySet()->setPropertyValue( "CharFontStyleName" + aPostfix, aValue );
                    bChanged = true;
                }
            }
            if( rItem.QueryValue( aValue, MID_FONT_CHAR_SET ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix ))
                {
                    GetPropertySet()->setPropertyValue( "CharFontCharSet" + aPostfix, aValue );
                    bChanged = true;
                }
            }
            if( rItem.QueryValue( aValue, MID_FONT_PITCH ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix ))
                {
                    GetPropertySet()->setPropertyValue( "CharFontPitch" + aPostfix, aValue );
                    bChanged = true;
                }
            }
        }
        break;

        case EE_CHAR_UNDERLINE:
        {
            const SvxUnderlineItem & rItem =
               static_cast< const SvxUnderlineItem & >(
                    rItemSet.Get( nWhichId ));

            if( rItem.QueryValue( aValue, MID_TL_STYLE ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderline"_ustr ))
                {
                    GetPropertySet()->setPropertyValue( u"CharUnderline"_ustr , aValue );
                    bChanged = true;
                }
            }

            if( rItem.QueryValue( aValue, MID_TL_COLOR ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderlineColor"_ustr ))
                {
                    GetPropertySet()->setPropertyValue( u"CharUnderlineColor"_ustr , aValue );
                    bChanged = true;
                }
            }

            if( rItem.QueryValue( aValue, MID_TL_HASCOLOR ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderlineHasColor"_ustr ))
                {
                    GetPropertySet()->setPropertyValue( u"CharUnderlineHasColor"_ustr , aValue );
                    bChanged = true;
                }
            }
        }
        break;

        case EE_CHAR_OVERLINE:
        {
            const SvxOverlineItem& rItem = static_cast< const SvxOverlineItem & >( rItemSet.Get( nWhichId ) );

            if ( rItem.QueryValue( aValue, MID_TL_STYLE ) )
            {
                if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverline"_ustr ) )
                {
                    GetPropertySet()->setPropertyValue( u"CharOverline"_ustr , aValue );
                    bChanged = true;
                }
            }

            if ( rItem.QueryValue( aValue, MID_TL_COLOR ) )
            {
                if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverlineColor"_ustr ) )
                {
                    GetPropertySet()->setPropertyValue( u"CharOverlineColor"_ustr , aValue );
                    bChanged = true;
                }
            }

            if ( rItem.QueryValue( aValue, MID_TL_HASCOLOR ) )
            {
                if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverlineHasColor"_ustr ) )
                {
                    GetPropertySet()->setPropertyValue( u"CharOverlineHasColor"_ustr , aValue );
                    bChanged = true;
                }
            }
        }
        break;

        case EE_CHAR_ITALIC:
        case EE_CHAR_ITALIC_CJK:
        case EE_CHAR_ITALIC_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_ITALIC_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_ITALIC_CTL )
                aPostfix = "Complex";

            const SvxPostureItem & rItem =
                static_cast< const SvxPostureItem & >(
                    rItemSet.Get( nWhichId ));

            if( rItem.QueryValue( aValue, MID_POSTURE ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix))
                {
                    GetPropertySet()->setPropertyValue( "CharPosture" + aPostfix, aValue );
                    bChanged = true;
                }
            }
        }
        break;

        case EE_CHAR_WEIGHT:
        case EE_CHAR_WEIGHT_CJK:
        case EE_CHAR_WEIGHT_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_WEIGHT_CJK )
                aPostfix = "Asian" ;
            else if( nWhichId == EE_CHAR_WEIGHT_CTL )
                aPostfix = "Complex";

            const SvxWeightItem & rItem =
                static_cast< const SvxWeightItem & >(
                    rItemSet.Get( nWhichId ));

            if( rItem.QueryValue( aValue, MID_WEIGHT ))
            {
                if( aValue != GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix))
                {
                    GetPropertySet()->setPropertyValue( "CharWeight" + aPostfix, aValue );
                    bChanged = true;
                }
            }
        }
        break;

        case EE_CHAR_FONTHEIGHT:
        case EE_CHAR_FONTHEIGHT_CJK:
        case EE_CHAR_FONTHEIGHT_CTL:
        {
            OUString aPostfix;
            if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
                aPostfix = "Asian";
            else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
                aPostfix = "Complex";

            const SvxFontHeightItem & rItem =
                static_cast< const SvxFontHeightItem & >(
                    rItemSet.Get( nWhichId ));

            try
            {
                if( rItem.QueryValue( aValue, MID_FONTHEIGHT ) )
                {
                    bool bSetValue = false;
                    if( aValue != GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ))
                        bSetValue = true;
                    else
                    {
                        if (m_pRefSize)
                        {
                            awt::Size aNewRefSize = *m_pRefSize;
                            awt::Size aOldRefSize;
                            if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
                            {
                                if( aNewRefSize.Width != aOldRefSize.Width
                                    || aNewRefSize.Height != aOldRefSize.Height )
                                    bSetValue = true;
                            }
                        }
                    }
                    if( bSetValue )
                    {
                        // set new reference size only if there was a reference size before (auto-scaling on)
                        if (m_pRefSize && GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ).hasValue())
                        {
                            GetRefSizePropertySet()->setPropertyValue(
                                m_aRefSizePropertyName, uno::Any(*m_pRefSize));
                        }

                        GetPropertySet()->setPropertyValue( "CharHeight" + aPostfix, aValue );
                        bChanged = true;
                    }
                }
            }
            catch( const uno::Exception & )
            {
                DBG_UNHANDLED_EXCEPTION("chart2");
            }
        }
        break;
    }

    return bChanged;
}

const uno::Reference<beans::XPropertySet>& CharacterPropertyItemConverter::GetRefSizePropertySet() const
{
    return m_xRefSizePropSet;
}

}

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

Coverage Report

Created: 2026-04-09 11:41

Line	Count	Source
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		#include <CharacterPropertyItemConverter.hxx>
21		#include "SchWhichPairs.hxx"
22		#include <ItemPropertyMap.hxx>
23		#include <RelativeSizeHelper.hxx>
24		#include <editeng/memberids.h>
25		#include <editeng/eeitem.hxx>
26		#include <editeng/udlnitem.hxx>
27		#include <editeng/fontitem.hxx>
28		#include <editeng/postitem.hxx>
29		#include <editeng/wghtitem.hxx>
30		#include <editeng/fhgtitem.hxx>
31		#include <o3tl/any.hxx>
32		#include <svl/stritem.hxx>
33
34		#include <com/sun/star/beans/XPropertySet.hpp>
35		#include <com/sun/star/chart2/XFormattedString.hpp>
36		#include <utility>
37		#include <comphelper/diagnose_ex.hxx>
38
39		using namespace ::com::sun::star;
40
41		namespace chart::wrapper {
42
43		namespace {
44
45		ItemPropertyMapType & lcl_GetCharacterPropertyPropertyMap()
46	0	{
47	0	static ItemPropertyMapType aCharacterPropertyMap{
48	0	{EE_CHAR_COLOR, {"CharColor", 0}},
49	0	{EE_CHAR_LANGUAGE, {"CharLocale", MID_LANG_LOCALE}},
50	0	{EE_CHAR_LANGUAGE_CJK, {"CharLocaleAsian", MID_LANG_LOCALE}},
51	0	{EE_CHAR_LANGUAGE_CTL, {"CharLocaleComplex", MID_LANG_LOCALE}},
52
53	0	{EE_CHAR_STRIKEOUT, {"CharStrikeout", MID_CROSS_OUT}},
54	0	{EE_CHAR_WLM, {"CharWordMode", 0}},
55	0	{EE_CHAR_SHADOW, {"CharShadowed", 0}},
56	0	{EE_CHAR_RELIEF, {"CharRelief", 0}},
57	0	{EE_CHAR_OUTLINE, {"CharContoured", 0}},
58	0	{EE_CHAR_EMPHASISMARK, {"CharEmphasis", 0}},
59
60	0	{EE_PARA_WRITINGDIR, {"WritingMode", 0}},
61
62	0	{EE_PARA_ASIANCJKSPACING, {"ParaIsCharacterDistance", 0}}};
63
64	0	return aCharacterPropertyMap;
65	0	}
66		} // anonymous namespace
67
68		CharacterPropertyItemConverter::CharacterPropertyItemConverter(
69		const uno::Reference< beans::XPropertySet > & rPropertySet,
70		SfxItemPool& rItemPool ) :
71	0	ItemConverter( rPropertySet, rItemPool )
72	0	{}
73
74		CharacterPropertyItemConverter::CharacterPropertyItemConverter(
75		const uno::Reference< beans::XPropertySet > & rPropertySet,
76		SfxItemPool& rItemPool,
77		const std::optional<awt::Size>& pRefSize,
78		OUString aRefSizePropertyName,
79		const uno::Reference< beans::XPropertySet > & rRefSizePropSet ) :
80	0	ItemConverter( rPropertySet, rItemPool ),
81	0	m_aRefSizePropertyName(std::move( aRefSizePropertyName )),
82	0	m_xRefSizePropSet( rRefSizePropSet.is() ? rRefSizePropSet : rPropertySet )
83	0	{
84	0	if (pRefSize)
85	0	m_pRefSize = *pRefSize;
86	0	}
87
88		CharacterPropertyItemConverter::~CharacterPropertyItemConverter()
89	0	{}
90
91		const WhichRangesContainer& CharacterPropertyItemConverter::GetWhichPairs() const
92	0	{
93	0	return nCharacterPropertyWhichPairs;
94	0	}
95
96		bool CharacterPropertyItemConverter::GetItemProperty( tWhichIdType nWhichId, tPropertyNameWithMemberId & rOutProperty ) const
97	0	{
98	0	ItemPropertyMapType & rMap( lcl_GetCharacterPropertyPropertyMap());
99	0	ItemPropertyMapType::const_iterator aIt( rMap.find( nWhichId ));
100
101	0	if( aIt == rMap.end())
102	0	return false;
103
104	0	rOutProperty =(*aIt).second;
105	0	return true;
106	0	}
107
108		void CharacterPropertyItemConverter::FillSpecialItem(
109		sal_uInt16 nWhichId, SfxItemSet & rOutItemSet ) const
110	0	{
111	0	switch( nWhichId )
112	0	{
113	0	case EE_CHAR_FONTINFO:
114	0	case EE_CHAR_FONTINFO_CJK:
115	0	case EE_CHAR_FONTINFO_CTL:
116	0	{
117	0	OUString aPostfix;
118	0	if( nWhichId == EE_CHAR_FONTINFO_CJK )
119	0	aPostfix = "Asian";
120	0	else if( nWhichId == EE_CHAR_FONTINFO_CTL )
121	0	aPostfix = "Complex";
122
123	0	SvxFontItem aItem( nWhichId );
124
125	0	aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix),
126	0	MID_FONT_FAMILY_NAME );
127	0	aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix),
128	0	MID_FONT_FAMILY );
129	0	aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix),
130	0	MID_FONT_STYLE_NAME );
131	0	aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix),
132	0	MID_FONT_CHAR_SET );
133	0	aItem.PutValue( GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix),
134	0	MID_FONT_PITCH );
135
136	0	rOutItemSet.Put( aItem );
137	0	}
138	0	break;
139
140	0	case EE_CHAR_UNDERLINE:
141	0	{
142	0	SvxUnderlineItem aItem(LINESTYLE_NONE, EE_CHAR_UNDERLINE);
143	0	bool bModified = false;
144
145	0	uno::Any aValue( GetPropertySet()->getPropertyValue( u"CharUnderline"_ustr ));
146	0	if( aValue.hasValue())
147	0	{
148	0	aItem.PutValue( aValue, MID_TL_STYLE );
149	0	bModified = true;
150	0	}
151
152	0	aValue = GetPropertySet()->getPropertyValue( u"CharUnderlineHasColor"_ustr );
153	0	if( aValue.hasValue() && *o3tl::doAccess<bool>(aValue) )
154	0	{
155	0	aItem.PutValue( aValue, MID_TL_HASCOLOR );
156	0	bModified = true;
157	0	}
158
159	0	aValue = GetPropertySet()->getPropertyValue( u"CharUnderlineColor"_ustr );
160	0	if( aValue.hasValue())
161	0	{
162	0	aItem.PutValue( aValue, MID_TL_COLOR );
163	0	bModified = true;
164	0	}
165
166	0	if( bModified )
167	0	rOutItemSet.Put( aItem );
168	0	}
169	0	break;
170
171	0	case EE_CHAR_OVERLINE:
172	0	{
173	0	SvxOverlineItem aItem( LINESTYLE_NONE, EE_CHAR_OVERLINE );
174	0	bool bModified = false;
175
176	0	uno::Any aValue( GetPropertySet()->getPropertyValue( u"CharOverline"_ustr ) );
177	0	if ( aValue.hasValue() )
178	0	{
179	0	aItem.PutValue( aValue, MID_TL_STYLE );
180	0	bModified = true;
181	0	}
182
183	0	aValue = GetPropertySet()->getPropertyValue( u"CharOverlineHasColor"_ustr );
184	0	if ( aValue.hasValue() && *o3tl::doAccess<bool>(aValue) )
185	0	{
186	0	aItem.PutValue( aValue, MID_TL_HASCOLOR );
187	0	bModified = true;
188	0	}
189
190	0	aValue = GetPropertySet()->getPropertyValue( u"CharOverlineColor"_ustr );
191	0	if ( aValue.hasValue() )
192	0	{
193	0	aItem.PutValue( aValue, MID_TL_COLOR );
194	0	bModified = true;
195	0	}
196
197	0	if ( bModified )
198	0	{
199	0	rOutItemSet.Put( aItem );
200	0	}
201	0	}
202	0	break;
203
204	0	case EE_CHAR_ITALIC:
205	0	case EE_CHAR_ITALIC_CJK:
206	0	case EE_CHAR_ITALIC_CTL:
207	0	{
208	0	OUString aPostfix;
209	0	if( nWhichId == EE_CHAR_ITALIC_CJK )
210	0	aPostfix = "Asian";
211	0	else if( nWhichId == EE_CHAR_ITALIC_CTL )
212	0	aPostfix = "Complex";
213
214	0	SvxPostureItem aItem( ITALIC_NONE, nWhichId );
215
216	0	uno::Any aValue( GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix));
217	0	if( aValue.hasValue())
218	0	{
219	0	aItem.PutValue( aValue, MID_POSTURE );
220	0	rOutItemSet.Put( aItem );
221	0	}
222	0	}
223	0	break;
224
225	0	case EE_CHAR_WEIGHT:
226	0	case EE_CHAR_WEIGHT_CJK:
227	0	case EE_CHAR_WEIGHT_CTL:
228	0	{
229	0	OUString aPostfix;
230	0	if( nWhichId == EE_CHAR_WEIGHT_CJK )
231	0	aPostfix = "Asian";
232	0	else if( nWhichId == EE_CHAR_WEIGHT_CTL )
233	0	aPostfix = "Complex";
234
235	0	SvxWeightItem aItem( WEIGHT_NORMAL, nWhichId );
236
237	0	uno::Any aValue( GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix));
238	0	if( aValue.hasValue())
239	0	{
240	0	aItem.PutValue( aValue, MID_WEIGHT );
241	0	rOutItemSet.Put( aItem );
242	0	}
243	0	}
244	0	break;
245
246	0	case EE_CHAR_FONTHEIGHT:
247	0	case EE_CHAR_FONTHEIGHT_CJK:
248	0	case EE_CHAR_FONTHEIGHT_CTL:
249	0	{
250	0	OUString aPostfix;
251	0	if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
252	0	aPostfix = "Asian";
253	0	else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
254	0	aPostfix = "Complex";
255
256	0	SvxFontHeightItem aItem( 240, 100, nWhichId );
257
258	0	try
259	0	{
260	0	uno::Any aValue( GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ));
261	0	float fHeight;
262	0	if( aValue >>= fHeight )
263	0	{
264	0	if (m_pRefSize)
265	0	{
266	0	awt::Size aOldRefSize;
267	0	if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
268	0	{
269		// calculate font height in view
270	0	fHeight = static_cast< float >(
271	0	RelativeSizeHelper::calculate( fHeight, aOldRefSize, *m_pRefSize ));
272	0	aValue <<= fHeight;
273	0	}
274	0	}
275
276	0	aItem.PutValue( aValue, MID_FONTHEIGHT );
277	0	rOutItemSet.Put( aItem );
278	0	}
279	0	}
280	0	catch( const uno::Exception & )
281	0	{
282	0	DBG_UNHANDLED_EXCEPTION("chart2");
283	0	}
284	0	}
285	0	break;
286
287	0	case SID_CHAR_DLG_PREVIEW_STRING:
288	0	{
289	0	uno::Reference< chart2::XFormattedString > xFormattedString( GetPropertySet(), uno::UNO_QUERY );
290	0	if( xFormattedString.is() )
291	0	{
292	0	OUString aString = xFormattedString->getString();
293	0	rOutItemSet.Put( SfxStringItem( nWhichId, aString ) );
294	0	}
295	0	else
296	0	rOutItemSet.Put( SfxStringItem( nWhichId, OUString() ) );
297	0	}
298	0	break;
299
300	0	case EE_PARA_FORBIDDENRULES:
301	0	case EE_PARA_HANGINGPUNCTUATION:
302	0	rOutItemSet.DisableItem( nWhichId );
303	0	break;
304	0	}
305	0	}
306
307		bool CharacterPropertyItemConverter::ApplySpecialItem(
308		sal_uInt16 nWhichId, const SfxItemSet & rItemSet )
309	0	{
310	0	bool bChanged = false;
311	0	uno::Any aValue;
312
313	0	switch( nWhichId )
314	0	{
315	0	case EE_CHAR_FONTINFO:
316	0	case EE_CHAR_FONTINFO_CJK:
317	0	case EE_CHAR_FONTINFO_CTL:
318	0	{
319	0	OUString aPostfix;
320	0	if( nWhichId == EE_CHAR_FONTINFO_CJK )
321	0	aPostfix = "Asian";
322	0	else if( nWhichId == EE_CHAR_FONTINFO_CTL )
323	0	aPostfix = "Complex";
324
325	0	const SvxFontItem & rItem =
326	0	static_cast< const SvxFontItem & >(
327	0	rItemSet.Get( nWhichId ));
328
329	0	if( rItem.QueryValue( aValue, MID_FONT_FAMILY_NAME ))
330	0	{
331	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix ))
332	0	{
333	0	GetPropertySet()->setPropertyValue( "CharFontName" + aPostfix, aValue );
334	0	bChanged = true;
335	0	}
336	0	}
337	0	if( rItem.QueryValue( aValue, MID_FONT_FAMILY ))
338	0	{
339	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix ))
340	0	{
341	0	GetPropertySet()->setPropertyValue( "CharFontFamily" + aPostfix, aValue );
342	0	bChanged = true;
343	0	}
344	0	}
345	0	if( rItem.QueryValue( aValue, MID_FONT_STYLE_NAME ))
346	0	{
347	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix ))
348	0	{
349	0	GetPropertySet()->setPropertyValue( "CharFontStyleName" + aPostfix, aValue );
350	0	bChanged = true;
351	0	}
352	0	}
353	0	if( rItem.QueryValue( aValue, MID_FONT_CHAR_SET ))
354	0	{
355	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix ))
356	0	{
357	0	GetPropertySet()->setPropertyValue( "CharFontCharSet" + aPostfix, aValue );
358	0	bChanged = true;
359	0	}
360	0	}
361	0	if( rItem.QueryValue( aValue, MID_FONT_PITCH ))
362	0	{
363	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix ))
364	0	{
365	0	GetPropertySet()->setPropertyValue( "CharFontPitch" + aPostfix, aValue );
366	0	bChanged = true;
367	0	}
368	0	}
369	0	}
370	0	break;
371
372	0	case EE_CHAR_UNDERLINE:
373	0	{
374	0	const SvxUnderlineItem & rItem =
375	0	static_cast< const SvxUnderlineItem & >(
376	0	rItemSet.Get( nWhichId ));
377
378	0	if( rItem.QueryValue( aValue, MID_TL_STYLE ))
379	0	{
380	0	if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderline"_ustr ))
381	0	{
382	0	GetPropertySet()->setPropertyValue( u"CharUnderline"_ustr , aValue );
383	0	bChanged = true;
384	0	}
385	0	}
386
387	0	if( rItem.QueryValue( aValue, MID_TL_COLOR ))
388	0	{
389	0	if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderlineColor"_ustr ))
390	0	{
391	0	GetPropertySet()->setPropertyValue( u"CharUnderlineColor"_ustr , aValue );
392	0	bChanged = true;
393	0	}
394	0	}
395
396	0	if( rItem.QueryValue( aValue, MID_TL_HASCOLOR ))
397	0	{
398	0	if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderlineHasColor"_ustr ))
399	0	{
400	0	GetPropertySet()->setPropertyValue( u"CharUnderlineHasColor"_ustr , aValue );
401	0	bChanged = true;
402	0	}
403	0	}
404	0	}
405	0	break;
406
407	0	case EE_CHAR_OVERLINE:
408	0	{
409	0	const SvxOverlineItem& rItem = static_cast< const SvxOverlineItem & >( rItemSet.Get( nWhichId ) );
410
411	0	if ( rItem.QueryValue( aValue, MID_TL_STYLE ) )
412	0	{
413	0	if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverline"_ustr ) )
414	0	{
415	0	GetPropertySet()->setPropertyValue( u"CharOverline"_ustr , aValue );
416	0	bChanged = true;
417	0	}
418	0	}
419
420	0	if ( rItem.QueryValue( aValue, MID_TL_COLOR ) )
421	0	{
422	0	if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverlineColor"_ustr ) )
423	0	{
424	0	GetPropertySet()->setPropertyValue( u"CharOverlineColor"_ustr , aValue );
425	0	bChanged = true;
426	0	}
427	0	}
428
429	0	if ( rItem.QueryValue( aValue, MID_TL_HASCOLOR ) )
430	0	{
431	0	if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverlineHasColor"_ustr ) )
432	0	{
433	0	GetPropertySet()->setPropertyValue( u"CharOverlineHasColor"_ustr , aValue );
434	0	bChanged = true;
435	0	}
436	0	}
437	0	}
438	0	break;
439
440	0	case EE_CHAR_ITALIC:
441	0	case EE_CHAR_ITALIC_CJK:
442	0	case EE_CHAR_ITALIC_CTL:
443	0	{
444	0	OUString aPostfix;
445	0	if( nWhichId == EE_CHAR_ITALIC_CJK )
446	0	aPostfix = "Asian";
447	0	else if( nWhichId == EE_CHAR_ITALIC_CTL )
448	0	aPostfix = "Complex";
449
450	0	const SvxPostureItem & rItem =
451	0	static_cast< const SvxPostureItem & >(
452	0	rItemSet.Get( nWhichId ));
453
454	0	if( rItem.QueryValue( aValue, MID_POSTURE ))
455	0	{
456	0	if( aValue != GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix))
457	0	{
458	0	GetPropertySet()->setPropertyValue( "CharPosture" + aPostfix, aValue );
459	0	bChanged = true;
460	0	}
461	0	}
462	0	}
463	0	break;
464
465	0	case EE_CHAR_WEIGHT:
466	0	case EE_CHAR_WEIGHT_CJK:
467	0	case EE_CHAR_WEIGHT_CTL:
468	0	{
469	0	OUString aPostfix;
470	0	if( nWhichId == EE_CHAR_WEIGHT_CJK )
471	0	aPostfix = "Asian" ;
472	0	else if( nWhichId == EE_CHAR_WEIGHT_CTL )
473	0	aPostfix = "Complex";
474
475	0	const SvxWeightItem & rItem =
476	0	static_cast< const SvxWeightItem & >(
477	0	rItemSet.Get( nWhichId ));
478
479	0	if( rItem.QueryValue( aValue, MID_WEIGHT ))
480	0	{
481	0	if( aValue != GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix))
482	0	{
483	0	GetPropertySet()->setPropertyValue( "CharWeight" + aPostfix, aValue );
484	0	bChanged = true;
485	0	}
486	0	}
487	0	}
488	0	break;
489
490	0	case EE_CHAR_FONTHEIGHT:
491	0	case EE_CHAR_FONTHEIGHT_CJK:
492	0	case EE_CHAR_FONTHEIGHT_CTL:
493	0	{
494	0	OUString aPostfix;
495	0	if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
496	0	aPostfix = "Asian";
497	0	else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
498	0	aPostfix = "Complex";
499
500	0	const SvxFontHeightItem & rItem =
501	0	static_cast< const SvxFontHeightItem & >(
502	0	rItemSet.Get( nWhichId ));
503
504	0	try
505	0	{
506	0	if( rItem.QueryValue( aValue, MID_FONTHEIGHT ) )
507	0	{
508	0	bool bSetValue = false;
509	0	if( aValue != GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ))
510	0	bSetValue = true;
511	0	else
512	0	{
513	0	if (m_pRefSize)
514	0	{
515	0	awt::Size aNewRefSize = *m_pRefSize;
516	0	awt::Size aOldRefSize;
517	0	if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
518	0	{
519	0	if( aNewRefSize.Width != aOldRefSize.Width
520	0	\|\| aNewRefSize.Height != aOldRefSize.Height )
521	0	bSetValue = true;
522	0	}
523	0	}
524	0	}
525	0	if( bSetValue )
526	0	{
527		// set new reference size only if there was a reference size before (auto-scaling on)
528	0	if (m_pRefSize && GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ).hasValue())
529	0	{
530	0	GetRefSizePropertySet()->setPropertyValue(
531	0	m_aRefSizePropertyName, uno::Any(*m_pRefSize));
532	0	}
533
534	0	GetPropertySet()->setPropertyValue( "CharHeight" + aPostfix, aValue );
535	0	bChanged = true;
536	0	}
537	0	}
538	0	}
539	0	catch( const uno::Exception & )
540	0	{
541	0	DBG_UNHANDLED_EXCEPTION("chart2");
542	0	}
543	0	}
544	0	break;
545	0	}
546
547	0	return bChanged;
548	0	}
549
550		const uno::Reference<beans::XPropertySet>& CharacterPropertyItemConverter::GetRefSizePropertySet() const
551	0	{
552	0	return m_xRefSizePropSet;
553	0	}
554
555		}
556
557		/* vim:set shiftwidth=4 softtabstop=4 expandtab: */