/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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_FONTINFO);

            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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_UNDERLINE);

            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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_OVERLINE);

            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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_ITALIC);

            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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_WEIGHT);

            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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_FONTHEIGHT);

            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-09-28 10:59

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 = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_FONTINFO);
326
327	0	if( rItem.QueryValue( aValue, MID_FONT_FAMILY_NAME ))
328	0	{
329	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontName" + aPostfix ))
330	0	{
331	0	GetPropertySet()->setPropertyValue( "CharFontName" + aPostfix, aValue );
332	0	bChanged = true;
333	0	}
334	0	}
335	0	if( rItem.QueryValue( aValue, MID_FONT_FAMILY ))
336	0	{
337	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontFamily" + aPostfix ))
338	0	{
339	0	GetPropertySet()->setPropertyValue( "CharFontFamily" + aPostfix, aValue );
340	0	bChanged = true;
341	0	}
342	0	}
343	0	if( rItem.QueryValue( aValue, MID_FONT_STYLE_NAME ))
344	0	{
345	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontStyleName" + aPostfix ))
346	0	{
347	0	GetPropertySet()->setPropertyValue( "CharFontStyleName" + aPostfix, aValue );
348	0	bChanged = true;
349	0	}
350	0	}
351	0	if( rItem.QueryValue( aValue, MID_FONT_CHAR_SET ))
352	0	{
353	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontCharSet" + aPostfix ))
354	0	{
355	0	GetPropertySet()->setPropertyValue( "CharFontCharSet" + aPostfix, aValue );
356	0	bChanged = true;
357	0	}
358	0	}
359	0	if( rItem.QueryValue( aValue, MID_FONT_PITCH ))
360	0	{
361	0	if( aValue != GetPropertySet()->getPropertyValue( "CharFontPitch" + aPostfix ))
362	0	{
363	0	GetPropertySet()->setPropertyValue( "CharFontPitch" + aPostfix, aValue );
364	0	bChanged = true;
365	0	}
366	0	}
367	0	}
368	0	break;
369
370	0	case EE_CHAR_UNDERLINE:
371	0	{
372	0	const SvxUnderlineItem & rItem = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_UNDERLINE);
373
374	0	if( rItem.QueryValue( aValue, MID_TL_STYLE ))
375	0	{
376	0	if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderline"_ustr ))
377	0	{
378	0	GetPropertySet()->setPropertyValue( u"CharUnderline"_ustr , aValue );
379	0	bChanged = true;
380	0	}
381	0	}
382
383	0	if( rItem.QueryValue( aValue, MID_TL_COLOR ))
384	0	{
385	0	if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderlineColor"_ustr ))
386	0	{
387	0	GetPropertySet()->setPropertyValue( u"CharUnderlineColor"_ustr , aValue );
388	0	bChanged = true;
389	0	}
390	0	}
391
392	0	if( rItem.QueryValue( aValue, MID_TL_HASCOLOR ))
393	0	{
394	0	if( aValue != GetPropertySet()->getPropertyValue( u"CharUnderlineHasColor"_ustr ))
395	0	{
396	0	GetPropertySet()->setPropertyValue( u"CharUnderlineHasColor"_ustr , aValue );
397	0	bChanged = true;
398	0	}
399	0	}
400	0	}
401	0	break;
402
403	0	case EE_CHAR_OVERLINE:
404	0	{
405	0	const SvxOverlineItem & rItem = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_OVERLINE);
406
407	0	if ( rItem.QueryValue( aValue, MID_TL_STYLE ) )
408	0	{
409	0	if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverline"_ustr ) )
410	0	{
411	0	GetPropertySet()->setPropertyValue( u"CharOverline"_ustr , aValue );
412	0	bChanged = true;
413	0	}
414	0	}
415
416	0	if ( rItem.QueryValue( aValue, MID_TL_COLOR ) )
417	0	{
418	0	if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverlineColor"_ustr ) )
419	0	{
420	0	GetPropertySet()->setPropertyValue( u"CharOverlineColor"_ustr , aValue );
421	0	bChanged = true;
422	0	}
423	0	}
424
425	0	if ( rItem.QueryValue( aValue, MID_TL_HASCOLOR ) )
426	0	{
427	0	if ( aValue != GetPropertySet()->getPropertyValue( u"CharOverlineHasColor"_ustr ) )
428	0	{
429	0	GetPropertySet()->setPropertyValue( u"CharOverlineHasColor"_ustr , aValue );
430	0	bChanged = true;
431	0	}
432	0	}
433	0	}
434	0	break;
435
436	0	case EE_CHAR_ITALIC:
437	0	case EE_CHAR_ITALIC_CJK:
438	0	case EE_CHAR_ITALIC_CTL:
439	0	{
440	0	OUString aPostfix;
441	0	if( nWhichId == EE_CHAR_ITALIC_CJK )
442	0	aPostfix = "Asian";
443	0	else if( nWhichId == EE_CHAR_ITALIC_CTL )
444	0	aPostfix = "Complex";
445
446	0	const SvxPostureItem & rItem = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_ITALIC);
447
448	0	if( rItem.QueryValue( aValue, MID_POSTURE ))
449	0	{
450	0	if( aValue != GetPropertySet()->getPropertyValue( "CharPosture" + aPostfix))
451	0	{
452	0	GetPropertySet()->setPropertyValue( "CharPosture" + aPostfix, aValue );
453	0	bChanged = true;
454	0	}
455	0	}
456	0	}
457	0	break;
458
459	0	case EE_CHAR_WEIGHT:
460	0	case EE_CHAR_WEIGHT_CJK:
461	0	case EE_CHAR_WEIGHT_CTL:
462	0	{
463	0	OUString aPostfix;
464	0	if( nWhichId == EE_CHAR_WEIGHT_CJK )
465	0	aPostfix = "Asian" ;
466	0	else if( nWhichId == EE_CHAR_WEIGHT_CTL )
467	0	aPostfix = "Complex";
468
469	0	const SvxWeightItem & rItem = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_WEIGHT);
470
471	0	if( rItem.QueryValue( aValue, MID_WEIGHT ))
472	0	{
473	0	if( aValue != GetPropertySet()->getPropertyValue( "CharWeight" + aPostfix))
474	0	{
475	0	GetPropertySet()->setPropertyValue( "CharWeight" + aPostfix, aValue );
476	0	bChanged = true;
477	0	}
478	0	}
479	0	}
480	0	break;
481
482	0	case EE_CHAR_FONTHEIGHT:
483	0	case EE_CHAR_FONTHEIGHT_CJK:
484	0	case EE_CHAR_FONTHEIGHT_CTL:
485	0	{
486	0	OUString aPostfix;
487	0	if( nWhichId == EE_CHAR_FONTHEIGHT_CJK )
488	0	aPostfix = "Asian";
489	0	else if( nWhichId == EE_CHAR_FONTHEIGHT_CTL )
490	0	aPostfix = "Complex";
491
492	0	const SvxFontHeightItem & rItem = rItemSet.Get( nWhichId ).StaticWhichCast(EE_CHAR_FONTHEIGHT);
493
494	0	try
495	0	{
496	0	if( rItem.QueryValue( aValue, MID_FONTHEIGHT ) )
497	0	{
498	0	bool bSetValue = false;
499	0	if( aValue != GetPropertySet()->getPropertyValue( "CharHeight" + aPostfix ))
500	0	bSetValue = true;
501	0	else
502	0	{
503	0	if (m_pRefSize)
504	0	{
505	0	awt::Size aNewRefSize = *m_pRefSize;
506	0	awt::Size aOldRefSize;
507	0	if( GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ) >>= aOldRefSize )
508	0	{
509	0	if( aNewRefSize.Width != aOldRefSize.Width
510	0	\|\| aNewRefSize.Height != aOldRefSize.Height )
511	0	bSetValue = true;
512	0	}
513	0	}
514	0	}
515	0	if( bSetValue )
516	0	{
517		// set new reference size only if there was a reference size before (auto-scaling on)
518	0	if (m_pRefSize && GetRefSizePropertySet()->getPropertyValue( m_aRefSizePropertyName ).hasValue())
519	0	{
520	0	GetRefSizePropertySet()->setPropertyValue(
521	0	m_aRefSizePropertyName, uno::Any(*m_pRefSize));
522	0	}
523
524	0	GetPropertySet()->setPropertyValue( "CharHeight" + aPostfix, aValue );
525	0	bChanged = true;
526	0	}
527	0	}
528	0	}
529	0	catch( const uno::Exception & )
530	0	{
531	0	DBG_UNHANDLED_EXCEPTION("chart2");
532	0	}
533	0	}
534	0	break;
535	0	}
536
537	0	return bChanged;
538	0	}
539
540		const uno::Reference<beans::XPropertySet>& CharacterPropertyItemConverter::GetRefSizePropertySet() const
541	0	{
542	0	return m_xRefSizePropSet;
543	0	}
544
545		}
546
547		/* vim:set shiftwidth=4 softtabstop=4 expandtab: */