| /************************************************************** |
| * |
| * 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 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmloff.hxx" |
| |
| #include <tools/debug.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <tools/fontenum.hxx> |
| #include <com/sun/star/uno/Any.hxx> |
| #include <com/sun/star/style/DropCapFormat.hpp> |
| #include <com/sun/star/text/FontRelief.hpp> |
| #include <com/sun/star/text/WrapTextMode.hpp> |
| #include <com/sun/star/text/XTextColumns.hpp> |
| #include <com/sun/star/text/TextColumn.hpp> |
| #include <com/sun/star/text/RelOrientation.hpp> |
| #include <com/sun/star/text/HoriOrientation.hpp> |
| #include <com/sun/star/text/VertOrientation.hpp> |
| #include <com/sun/star/text/RubyAdjust.hpp> |
| #include <com/sun/star/text/FontEmphasis.hpp> |
| #include <com/sun/star/text/ParagraphVertAlign.hpp> |
| #include <xmloff/xmltypes.hxx> |
| #include <xmloff/xmluconv.hxx> |
| #include <xmloff/xmltoken.hxx> |
| #include "XMLAnchorTypePropHdl.hxx" |
| #include <xmloff/XMLConstantsPropertyHandler.hxx> |
| #include "XMLClipPropertyHandler.hxx" |
| #include "XMLTextColumnsPropertyHandler.hxx" |
| #include <xmloff/NamedBoolPropertyHdl.hxx> |
| #include "txtprhdl.hxx" |
| #include <com/sun/star/text/WrapInfluenceOnPosition.hpp> |
| |
| //UUUU |
| #include <xmloff/EnumPropertyHdl.hxx> |
| #include <com/sun/star/drawing/FillStyle.hpp> |
| #include "XMLFillBitmapSizePropertyHandler.hxx" |
| #include "XMLBitmapLogicalSizePropertyHandler.hxx" |
| #include <com/sun/star/drawing/RectanglePoint.hpp> |
| #include <com/sun/star/drawing/BitmapMode.hpp> |
| #include "XMLBitmapRepeatOffsetPropertyHandler.hxx" |
| |
| using ::rtl::OUString; |
| using ::rtl::OUStringBuffer; |
| |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::style; |
| using namespace ::com::sun::star::text; |
| using namespace ::xmloff::token; |
| |
| //UUUU |
| using namespace ::com::sun::star::drawing; |
| |
| //UUUU |
| extern SvXMLEnumMapEntry aXML_FillStyle_EnumMap[]; |
| extern SvXMLEnumMapEntry aXML_RefPoint_EnumMap[]; |
| extern SvXMLEnumMapEntry aXML_BitmapMode_EnumMap[]; |
| |
| #define CONSTASCII_USTRINGPARAM_CMP(s) s, sizeof(s)-1 |
| |
| // --------------------------------------------------------------------------- |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_HoriPos_Enum[] = |
| { |
| { XML_FROM_LEFT, HoriOrientation::NONE }, |
| { XML_FROM_INSIDE, HoriOrientation::NONE }, // import only |
| { XML_LEFT, HoriOrientation::LEFT }, |
| { XML_INSIDE, HoriOrientation::LEFT }, // import only |
| { XML_CENTER, HoriOrientation::CENTER }, |
| { XML_RIGHT, HoriOrientation::RIGHT }, |
| { XML_OUTSIDE, HoriOrientation::RIGHT }, // import only |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_HoriPosMirrored_Enum[] = |
| { |
| { XML_FROM_INSIDE, HoriOrientation::NONE }, |
| { XML_INSIDE, HoriOrientation::LEFT }, |
| { XML_CENTER, HoriOrientation::CENTER }, |
| { XML_OUTSIDE, HoriOrientation::RIGHT }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_HoriRel_Enum[] = |
| { |
| { XML_PARAGRAPH, RelOrientation::FRAME }, |
| { XML_PARAGRAPH_CONTENT, RelOrientation::PRINT_AREA }, |
| { XML_PAGE, RelOrientation::PAGE_FRAME }, |
| { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA }, |
| { XML_PARAGRAPH_START_MARGIN, RelOrientation::FRAME_LEFT }, |
| { XML_PARAGRAPH_END_MARGIN, RelOrientation::FRAME_RIGHT }, |
| { XML_PAGE_START_MARGIN, RelOrientation::PAGE_LEFT }, |
| { XML_PAGE_END_MARGIN, RelOrientation::PAGE_RIGHT }, |
| { XML_CHAR, RelOrientation::CHAR }, |
| { XML_FRAME, RelOrientation::FRAME }, // import only |
| { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA }, // import only |
| { XML_FRAME_START_MARGIN, RelOrientation::FRAME_LEFT }, // import only |
| { XML_FRAME_END_MARGIN, RelOrientation::FRAME_RIGHT }, // import only |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_HoriRelFrame_Enum[] = |
| { |
| { XML_FRAME, RelOrientation::FRAME }, |
| { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA }, |
| { XML_PAGE, RelOrientation::PAGE_FRAME }, |
| { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA }, |
| { XML_FRAME_START_MARGIN, RelOrientation::FRAME_LEFT }, |
| { XML_FRAME_END_MARGIN, RelOrientation::FRAME_RIGHT }, |
| { XML_PAGE_START_MARGIN, RelOrientation::PAGE_LEFT }, |
| { XML_PAGE_END_MARGIN, RelOrientation::PAGE_RIGHT }, |
| { XML_CHAR, RelOrientation::CHAR }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_HoriMirror_Enum[] = |
| { |
| { XML_FROM_LEFT, sal_False }, |
| { XML_FROM_INSIDE, sal_True }, |
| { XML_LEFT, sal_False }, |
| { XML_INSIDE, sal_True }, |
| { XML_CENTER, sal_False }, |
| { XML_RIGHT, sal_False }, |
| { XML_OUTSIDE, sal_True }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VertPos_Enum[] = |
| { |
| { XML_FROM_TOP, VertOrientation::NONE }, |
| { XML_TOP, VertOrientation::TOP }, |
| { XML_TOP, VertOrientation::CHAR_TOP }, // export only |
| { XML_TOP, VertOrientation::LINE_TOP }, // export only |
| { XML_MIDDLE, VertOrientation::CENTER }, |
| { XML_MIDDLE, VertOrientation::CHAR_CENTER }, // export only |
| { XML_MIDDLE, VertOrientation::LINE_CENTER }, // export only |
| { XML_BOTTOM, VertOrientation::BOTTOM }, |
| { XML_BOTTOM, VertOrientation::CHAR_BOTTOM }, // export only |
| { XML_BOTTOM, VertOrientation::LINE_BOTTOM }, // export only |
| { XML_BELOW, VertOrientation::CHAR_BOTTOM }, // import only |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VertPosAtChar_Enum[] = |
| { |
| { XML_FROM_TOP, VertOrientation::NONE }, |
| { XML_TOP, VertOrientation::TOP }, |
| { XML_TOP, VertOrientation::CHAR_TOP }, // export only |
| { XML_TOP, VertOrientation::LINE_TOP }, // export only |
| { XML_MIDDLE, VertOrientation::CENTER }, |
| { XML_MIDDLE, VertOrientation::CHAR_CENTER }, // export only |
| { XML_MIDDLE, VertOrientation::LINE_CENTER }, // export only |
| { XML_BOTTOM, VertOrientation::BOTTOM }, |
| { XML_BELOW, VertOrientation::CHAR_BOTTOM }, // export only |
| { XML_BOTTOM, VertOrientation::LINE_BOTTOM }, // export only |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VertRel_Enum[] = |
| { |
| { XML_PARAGRAPH, RelOrientation::FRAME }, |
| { XML_PARAGRAPH_CONTENT, RelOrientation::PRINT_AREA }, |
| { XML_CHAR, RelOrientation::CHAR }, |
| // DVO, OD 17.09.2003 #i18732# - allow vertical alignment at page |
| { XML_PAGE, RelOrientation::PAGE_FRAME }, |
| { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA }, |
| { XML_FRAME, RelOrientation::FRAME }, // import only |
| { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA }, // import only |
| // OD 13.11.2003 #i22341# - new vertical alignment at top of line |
| { XML_LINE, RelOrientation::TEXT_LINE }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VertRelPage_Enum[] = |
| { |
| { XML_PAGE, RelOrientation::FRAME }, |
| { XML_PAGE_CONTENT, RelOrientation::PRINT_AREA }, |
| { XML_PAGE, RelOrientation::PAGE_FRAME }, |
| { XML_PAGE_CONTENT, RelOrientation::PAGE_PRINT_AREA }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VertRelFrame_Enum[] = |
| { |
| { XML_FRAME, RelOrientation::FRAME }, |
| { XML_FRAME_CONTENT, RelOrientation::PRINT_AREA }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VertRelAsChar_Enum[] = |
| { |
| { XML_BASELINE, VertOrientation::TOP }, |
| { XML_BASELINE, VertOrientation::CENTER }, // export only |
| { XML_BASELINE, VertOrientation::BOTTOM }, // export only |
| { XML_TEXT, VertOrientation::CHAR_TOP }, |
| { XML_TEXT, VertOrientation::CHAR_CENTER }, // export only |
| { XML_TEXT, VertOrientation::CHAR_BOTTOM }, // export only |
| { XML_LINE, VertOrientation::LINE_TOP }, |
| { XML_LINE, VertOrientation::LINE_CENTER }, // export only |
| { XML_LINE, VertOrientation::LINE_BOTTOM }, // export only |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_RubyAdjust_Enum[] = |
| { |
| { XML_LEFT, RubyAdjust_LEFT }, |
| { XML_CENTER, RubyAdjust_CENTER }, |
| { XML_RIGHT, RubyAdjust_RIGHT }, |
| { XML_DISTRIBUTE_LETTER, RubyAdjust_BLOCK }, |
| { XML_DISTRIBUTE_SPACE, RubyAdjust_INDENT_BLOCK }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_FontRelief_Enum[] = |
| { |
| { XML_NONE, FontRelief::NONE }, |
| { XML_ENGRAVED, FontRelief::ENGRAVED }, |
| { XML_EMBOSSED, FontRelief::EMBOSSED }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_VerticalAlign_Enum[] = |
| { |
| { XML_TOP, ParagraphVertAlign::TOP }, |
| { XML_MIDDLE, ParagraphVertAlign::CENTER }, |
| { XML_BOTTOM, ParagraphVertAlign::BOTTOM }, |
| { XML_BASELINE, ParagraphVertAlign::BASELINE }, |
| { XML_AUTO, ParagraphVertAlign::AUTOMATIC }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| // OD 2004-05-05 #i28701# |
| SvXMLEnumMapEntry __READONLY_DATA pXML_WrapInfluenceOnPosition_Enum[] = |
| { |
| // --> OD 2004-10-18 #i35017# - tokens have been renamed and |
| // <XML_ITERATIVE> has been added |
| { XML_ONCE_SUCCESSIVE, WrapInfluenceOnPosition::ONCE_SUCCESSIVE }, |
| { XML_ONCE_CONCURRENT, WrapInfluenceOnPosition::ONCE_CONCURRENT }, |
| { XML_ITERATIVE, WrapInfluenceOnPosition::ITERATIVE }, |
| // <-- |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLDropCapPropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| virtual ~XMLDropCapPropHdl_Impl (); |
| |
| virtual bool equals( |
| const ::com::sun::star::uno::Any& r1, |
| const ::com::sun::star::uno::Any& r2 ) const; |
| |
| /// TabStops will be imported/exported as XML-Elements. So the Import/Export-work must be done at another place. |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| XMLDropCapPropHdl_Impl::~XMLDropCapPropHdl_Impl () |
| { |
| } |
| |
| bool XMLDropCapPropHdl_Impl::equals( |
| const Any& r1, |
| const Any& r2 ) const |
| { |
| DropCapFormat aFormat1, aFormat2; |
| r1 >>= aFormat1; |
| r2 >>= aFormat2; |
| |
| return (aFormat1.Lines <=1 && aFormat2.Lines <=1) || |
| (aFormat1.Lines == aFormat2.Lines && |
| aFormat1.Count == aFormat2.Count && |
| aFormat1.Distance == aFormat2.Distance); |
| } |
| |
| sal_Bool XMLDropCapPropHdl_Impl::importXML( |
| const OUString&, |
| Any&, |
| const SvXMLUnitConverter& ) const |
| { |
| DBG_ASSERT( sal_False, "drop caps are an element import property" ); |
| return sal_False; |
| } |
| |
| sal_Bool XMLDropCapPropHdl_Impl::exportXML( |
| OUString&, |
| const Any&, |
| const SvXMLUnitConverter& ) const |
| { |
| DBG_ASSERT( sal_False, "drop caps are an element export property" ); |
| return sal_False; |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLOpaquePropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| virtual ~XMLOpaquePropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLOpaquePropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_True; |
| sal_Bool bVal = sal_False; |
| if( IsXMLToken( rStrImpValue, XML_FOREGROUND ) ) |
| bVal = sal_True; |
| else if( !IsXMLToken( rStrImpValue, XML_BACKGROUND ) ) |
| bRet = sal_False; |
| |
| if( bRet ) |
| rValue.setValue( &bVal, ::getBooleanCppuType() ); |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLOpaquePropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| if( *(sal_Bool *)rValue.getValue() ) |
| rStrExpValue = GetXMLToken( XML_FOREGROUND ); |
| else |
| rStrExpValue = GetXMLToken( XML_BACKGROUND ); |
| |
| return sal_True; |
| } |
| |
| XMLOpaquePropHdl_Impl::~XMLOpaquePropHdl_Impl () |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLContourModePropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| virtual ~XMLContourModePropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLContourModePropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_True; |
| sal_Bool bVal = sal_False; |
| if( IsXMLToken( rStrImpValue, XML_OUTSIDE ) ) |
| bVal = sal_True; |
| else if( ! IsXMLToken( rStrImpValue, XML_FULL ) ) |
| bRet = sal_False; |
| |
| if( bRet ) |
| rValue.setValue( &bVal, ::getBooleanCppuType() ); |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLContourModePropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| if( *(sal_Bool *)rValue.getValue() ) |
| rStrExpValue = GetXMLToken( XML_OUTSIDE ); |
| else |
| rStrExpValue = GetXMLToken( XML_FULL ); |
| |
| return sal_True; |
| } |
| |
| XMLContourModePropHdl_Impl::~XMLContourModePropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLParagraphOnlyPropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| virtual ~XMLParagraphOnlyPropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLParagraphOnlyPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_True; |
| sal_Bool bVal = sal_False; |
| |
| if( ! IsXMLToken( rStrImpValue, XML_NO_LIMIT ) ) |
| { |
| sal_Int32 nValue = 0; |
| bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue ); |
| bVal = 1 == nValue; |
| } |
| |
| if( bRet ) |
| rValue.setValue( &bVal, ::getBooleanCppuType() ); |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLParagraphOnlyPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| if( *(sal_Bool *)rValue.getValue() ) |
| rStrExpValue = GetXMLToken( XML_1 ); |
| else |
| rStrExpValue = GetXMLToken( XML_NO_LIMIT ); |
| |
| return sal_True; |
| } |
| |
| XMLParagraphOnlyPropHdl_Impl::~XMLParagraphOnlyPropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_Wrap_Enum[] = |
| { |
| { XML_NONE, WrapTextMode_NONE }, |
| { XML_RUN_THROUGH, WrapTextMode_THROUGHT }, |
| { XML_PARALLEL, WrapTextMode_PARALLEL }, |
| { XML_DYNAMIC, WrapTextMode_DYNAMIC }, |
| { XML_LEFT, WrapTextMode_LEFT }, |
| { XML_RIGHT, WrapTextMode_RIGHT }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| class XMLWrapPropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| virtual ~XMLWrapPropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLWrapPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_uInt16 nWrap; |
| sal_Bool bRet = SvXMLUnitConverter::convertEnum( nWrap, rStrImpValue, |
| pXML_Wrap_Enum ); |
| |
| if( bRet ) |
| rValue <<= (WrapTextMode)nWrap; |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLWrapPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| OUStringBuffer aOut; |
| WrapTextMode eVal; |
| |
| rValue >>= eVal; |
| |
| sal_Bool bRet = SvXMLUnitConverter::convertEnum( aOut, eVal, pXML_Wrap_Enum, XML_NONE ); |
| |
| rStrExpValue = aOut.makeStringAndClear(); |
| |
| return bRet; |
| } |
| |
| XMLWrapPropHdl_Impl::~XMLWrapPropHdl_Impl () |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLFrameProtectPropHdl_Impl : public XMLPropertyHandler |
| { |
| const OUString sVal; |
| public: |
| XMLFrameProtectPropHdl_Impl( enum XMLTokenEnum eVal ) : |
| sVal( GetXMLToken(eVal) ) {} |
| virtual ~XMLFrameProtectPropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLFrameProtectPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_True; |
| sal_Bool bVal = sal_False; |
| if( ! IsXMLToken( rStrImpValue, XML_NONE ) ) |
| { |
| bRet = sal_False; |
| SvXMLTokenEnumerator aTokenEnum( rStrImpValue ); |
| OUString aToken; |
| while( aTokenEnum.getNextToken( aToken ) ) |
| { |
| bRet = sal_True; |
| if( aToken == sVal ) |
| { |
| bVal = sal_True; |
| break; |
| } |
| } |
| } |
| |
| if( bRet ) |
| rValue.setValue( &bVal, ::getBooleanCppuType() ); |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLFrameProtectPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| if( *(sal_Bool *)rValue.getValue() ) |
| { |
| if( !rStrExpValue.getLength() || |
| IsXMLToken( rStrExpValue, XML_NONE ) ) |
| { |
| rStrExpValue = sVal; |
| } |
| else |
| { |
| OUStringBuffer aOut( rStrExpValue.getLength() + 1 + |
| sVal.getLength() ); |
| aOut.append( rStrExpValue ); |
| aOut.append( (sal_Unicode)' ' ); |
| aOut.append( sVal ); |
| rStrExpValue = aOut.makeStringAndClear(); |
| } |
| } |
| else if( !rStrExpValue.getLength() ) |
| { |
| rStrExpValue = GetXMLToken( XML_NONE ); |
| } |
| |
| return sal_True; |
| } |
| |
| XMLFrameProtectPropHdl_Impl::~XMLFrameProtectPropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_Anchor_Enum[] = |
| { |
| { XML_CHAR, TextContentAnchorType_AT_CHARACTER }, |
| { XML_PAGE, TextContentAnchorType_AT_PAGE }, |
| { XML_FRAME, TextContentAnchorType_AT_FRAME }, |
| { XML_PARAGRAPH, TextContentAnchorType_AT_PARAGRAPH }, |
| { XML_AS_CHAR, TextContentAnchorType_AS_CHARACTER }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| |
| |
| sal_Bool XMLAnchorTypePropHdl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_uInt16 nAnchor; |
| sal_Bool bRet = SvXMLUnitConverter::convertEnum( nAnchor, rStrImpValue, |
| pXML_Anchor_Enum ); |
| |
| if( bRet ) |
| rValue <<= (TextContentAnchorType)nAnchor; |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLAnchorTypePropHdl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| OUStringBuffer aOut; |
| TextContentAnchorType eVal; |
| |
| rValue >>= eVal; |
| |
| sal_Bool bRet = SvXMLUnitConverter::convertEnum( aOut, eVal, pXML_Anchor_Enum, XML_PARAGRAPH ); |
| |
| rStrExpValue = aOut.makeStringAndClear(); |
| |
| return bRet; |
| } |
| |
| XMLAnchorTypePropHdl::~XMLAnchorTypePropHdl() |
| { |
| } |
| |
| sal_Bool XMLAnchorTypePropHdl::convert( const OUString& rStrImpValue, |
| TextContentAnchorType& rType ) |
| { |
| sal_uInt16 nAnchor; |
| sal_Bool bRet = SvXMLUnitConverter::convertEnum( nAnchor, rStrImpValue, |
| pXML_Anchor_Enum ); |
| if( bRet ) |
| rType = (TextContentAnchorType)nAnchor; |
| return bRet; |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| |
| XMLTextColumnsPropertyHandler::~XMLTextColumnsPropertyHandler () |
| { |
| } |
| |
| bool XMLTextColumnsPropertyHandler::equals( |
| const Any& r1, |
| const Any& r2 ) const |
| { |
| Reference < XTextColumns > xColumns1; |
| r1 >>= xColumns1; |
| |
| Reference < XTextColumns > xColumns2; |
| r2 >>= xColumns2; |
| |
| if( xColumns1->getColumnCount() != xColumns2->getColumnCount() || |
| xColumns1->getReferenceValue() != xColumns2->getReferenceValue() ) |
| return sal_False; |
| |
| Sequence < TextColumn > aColumns1 = xColumns1->getColumns(); |
| Sequence < TextColumn > aColumns2 = xColumns2->getColumns(); |
| sal_Int32 nCount = aColumns1.getLength(); |
| if( aColumns2.getLength() != nCount ) |
| return sal_False; |
| |
| const TextColumn *pColumns1 = aColumns1.getArray(); |
| const TextColumn *pColumns2 = aColumns2.getArray(); |
| |
| while( nCount-- ) |
| { |
| if( pColumns1->Width != pColumns2->Width || |
| pColumns1->LeftMargin != pColumns2->LeftMargin || |
| pColumns1->RightMargin != pColumns2->RightMargin ) |
| return sal_False; |
| |
| pColumns1++; |
| pColumns2++; |
| } |
| |
| return sal_True; |
| } |
| |
| sal_Bool XMLTextColumnsPropertyHandler::importXML( |
| const OUString&, |
| Any&, |
| const SvXMLUnitConverter& ) const |
| { |
| DBG_ASSERT( sal_False, "columns are an element import property" ); |
| return sal_False; |
| } |
| |
| sal_Bool XMLTextColumnsPropertyHandler::exportXML( |
| OUString&, |
| const Any&, |
| const SvXMLUnitConverter& ) const |
| { |
| DBG_ASSERT( sal_False, "columns are an element export property" ); |
| return sal_False; |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLHoriMirrorPropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| virtual ~XMLHoriMirrorPropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLHoriMirrorPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_uInt16 nHoriMirror; |
| sal_Bool bRet = SvXMLUnitConverter::convertEnum( nHoriMirror, rStrImpValue, |
| pXML_HoriMirror_Enum ); |
| |
| if( bRet ) |
| { |
| sal_Bool bTmp = nHoriMirror != 0; |
| rValue.setValue( &bTmp, ::getBooleanCppuType() ); |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLHoriMirrorPropHdl_Impl::exportXML( |
| OUString&, |
| const Any&, |
| const SvXMLUnitConverter& ) const |
| { |
| DBG_ASSERT( sal_False, "HorMirror property shouldn't be exported" ); |
| |
| return sal_False; |
| } |
| |
| XMLHoriMirrorPropHdl_Impl::~XMLHoriMirrorPropHdl_Impl () |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLGrfMirrorPropHdl_Impl : public XMLPropertyHandler |
| { |
| const OUString sVal; |
| sal_Bool bHori; |
| |
| public: |
| XMLGrfMirrorPropHdl_Impl( enum XMLTokenEnum eVal, sal_Bool bH ) : |
| sVal( GetXMLToken( eVal ) ), |
| bHori( bH ) {} |
| virtual ~XMLGrfMirrorPropHdl_Impl (); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLGrfMirrorPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_True; |
| sal_Bool bVal = sal_False; |
| if( ! IsXMLToken( rStrImpValue, XML_NONE ) ) |
| { |
| bRet = sal_False; |
| SvXMLTokenEnumerator aTokenEnum( rStrImpValue ); |
| OUString aToken; |
| while( aTokenEnum.getNextToken( aToken ) ) |
| { |
| bRet = sal_True; |
| if( aToken == sVal || |
| (bHori && IsXMLToken( aToken, XML_HORIZONTAL ) ) ) |
| { |
| bVal = sal_True; |
| break; |
| } |
| } |
| } |
| |
| if( bRet ) |
| rValue.setValue( &bVal, ::getBooleanCppuType() ); |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLGrfMirrorPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| if( *(sal_Bool *)rValue.getValue() ) |
| { |
| if( !rStrExpValue.getLength() || |
| IsXMLToken( rStrExpValue, XML_NONE ) ) |
| { |
| rStrExpValue = sVal; |
| } |
| else if( bHori && |
| // --> OD 2005-05-12 #i49139# |
| // XML_HORIZONTAL_ON_LEFT_PAGES and XML_HORIZONTAL_ON_RIGHT_PAGES |
| // are replaced by XML_HORIZONTAL_ON_EVEN and XML_HORIZONTAL_ON_ODD. |
| ( IsXMLToken( rStrExpValue, XML_HORIZONTAL_ON_EVEN ) || |
| IsXMLToken( rStrExpValue, XML_HORIZONTAL_ON_ODD ) )) |
| // <-- |
| { |
| rStrExpValue = GetXMLToken( XML_HORIZONTAL ); |
| } |
| else |
| { |
| OUStringBuffer aOut( rStrExpValue.getLength() + 1 + |
| sVal.getLength() ); |
| aOut.append( rStrExpValue ); |
| aOut.append( (sal_Unicode)' ' ); |
| aOut.append( sVal ); |
| rStrExpValue = aOut.makeStringAndClear(); |
| } |
| } |
| else if( !rStrExpValue.getLength() ) |
| { |
| rStrExpValue = GetXMLToken( XML_NONE ); |
| } |
| |
| return sal_True; |
| } |
| |
| XMLGrfMirrorPropHdl_Impl::~XMLGrfMirrorPropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| SvXMLEnumMapEntry __READONLY_DATA pXML_Emphasize_Enum[] = |
| { |
| { XML_NONE, FontEmphasis::NONE }, |
| { XML_DOT, FontEmphasis::DOT_ABOVE }, |
| { XML_CIRCLE, FontEmphasis::CIRCLE_ABOVE }, |
| { XML_DISC, FontEmphasis::DISK_ABOVE }, |
| { XML_ACCENT, FontEmphasis::ACCENT_ABOVE }, |
| { XML_TOKEN_INVALID, 0 } |
| }; |
| class XMLTextEmphasizePropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| XMLTextEmphasizePropHdl_Impl() {} |
| virtual ~XMLTextEmphasizePropHdl_Impl(); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLTextEmphasizePropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_True; |
| sal_uInt16 nVal = FontEmphasis::NONE; |
| sal_Bool bBelow = sal_False; |
| sal_Bool bHasPos = sal_False, bHasType = sal_False; |
| OUString aToken; |
| |
| SvXMLTokenEnumerator aTokenEnum( rStrImpValue ); |
| while( aTokenEnum.getNextToken( aToken ) ) |
| { |
| if( !bHasPos && IsXMLToken( aToken, XML_ABOVE ) ) |
| { |
| bBelow = sal_False; |
| bHasPos = sal_True; |
| } |
| else if( !bHasPos && IsXMLToken( aToken, XML_BELOW ) ) |
| { |
| bBelow = sal_True; |
| bHasPos = sal_True; |
| } |
| else if( !bHasType && |
| SvXMLUnitConverter::convertEnum( nVal, aToken, |
| pXML_Emphasize_Enum )) |
| { |
| bHasType = sal_True; |
| } |
| else |
| { |
| bRet = sal_False; |
| break; |
| } |
| } |
| |
| if( bRet ) |
| { |
| if( FontEmphasis::NONE != nVal && bBelow ) |
| nVal += 10; |
| rValue <<= (sal_Int16)nVal; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTextEmphasizePropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| OUStringBuffer aOut( 15 ); |
| sal_Bool bRet = sal_True; |
| sal_Int16 nType = sal_Int16(); |
| if( rValue >>= nType ) |
| { |
| sal_Bool bBelow = sal_False; |
| if( nType > 10 ) |
| { |
| bBelow = sal_True; |
| nType -= 10; |
| } |
| bRet = SvXMLUnitConverter::convertEnum( aOut, nType, |
| pXML_Emphasize_Enum, |
| XML_DOT ); |
| if( bRet ) |
| { |
| if( nType != 0 ) |
| { |
| enum XMLTokenEnum ePos = bBelow ? XML_BELOW : XML_ABOVE; |
| aOut.append( (sal_Unicode)' ' ); |
| aOut.append( GetXMLToken(ePos) ); |
| } |
| rStrExpValue = aOut.makeStringAndClear(); |
| } |
| } |
| |
| return bRet; |
| } |
| |
| XMLTextEmphasizePropHdl_Impl::~XMLTextEmphasizePropHdl_Impl() |
| { |
| } |
| |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLTextCombineCharPropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| XMLTextCombineCharPropHdl_Impl() {} |
| virtual ~XMLTextCombineCharPropHdl_Impl(); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLTextCombineCharPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| if( rStrImpValue.getLength() ) |
| rValue <<= rStrImpValue.copy( 0, 1 ); |
| else |
| rValue <<= rStrImpValue; |
| |
| return sal_True; |
| } |
| |
| sal_Bool XMLTextCombineCharPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| rValue >>= rStrExpValue; |
| |
| // #i114107# attribute of type "character": export only if length is 1 |
| return (1 == rStrExpValue.getLength()) ? sal_True : sal_False; |
| } |
| |
| XMLTextCombineCharPropHdl_Impl::~XMLTextCombineCharPropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLTextRelWidthHeightPropHdl_Impl : public XMLPropertyHandler |
| { |
| public: |
| XMLTextRelWidthHeightPropHdl_Impl() {} |
| virtual ~XMLTextRelWidthHeightPropHdl_Impl(); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLTextRelWidthHeightPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet; |
| sal_Int32 nValue; |
| bRet = SvXMLUnitConverter::convertPercent( nValue, rStrImpValue ); |
| if( bRet ) |
| rValue <<= (sal_Int16)nValue; |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTextRelWidthHeightPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_False; |
| sal_Int16 nValue = sal_Int16(); |
| if( (rValue >>= nValue) && nValue > 0 ) |
| { |
| OUStringBuffer aOut; |
| SvXMLUnitConverter::convertPercent( aOut, nValue ); |
| rStrExpValue = aOut.makeStringAndClear(); |
| |
| bRet = sal_True; |
| } |
| |
| return bRet; |
| } |
| |
| XMLTextRelWidthHeightPropHdl_Impl::~XMLTextRelWidthHeightPropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLTextSyncWidthHeightPropHdl_Impl : public XMLPropertyHandler |
| { |
| const OUString sValue; |
| |
| public: |
| XMLTextSyncWidthHeightPropHdl_Impl( enum XMLTokenEnum eValue ) : |
| sValue( GetXMLToken(eValue) ) {} |
| virtual ~XMLTextSyncWidthHeightPropHdl_Impl(); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLTextSyncWidthHeightPropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bValue = (rStrImpValue == sValue ); |
| rValue.setValue( &bValue, ::getBooleanCppuType() ); |
| |
| return sal_True; |
| } |
| |
| sal_Bool XMLTextSyncWidthHeightPropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Bool bRet = sal_False; |
| if( *(sal_Bool *)rValue.getValue() ) |
| { |
| rStrExpValue = sValue; |
| bRet = sal_True; |
| } |
| |
| return bRet; |
| } |
| |
| XMLTextSyncWidthHeightPropHdl_Impl::~XMLTextSyncWidthHeightPropHdl_Impl() |
| { |
| } |
| |
| // --------------------------------------------------------------------------- |
| |
| class XMLTextRotationAnglePropHdl_Impl : public XMLPropertyHandler |
| { |
| |
| public: |
| XMLTextRotationAnglePropHdl_Impl() {} |
| virtual ~XMLTextRotationAnglePropHdl_Impl(); |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLTextRotationAnglePropHdl_Impl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Int32 nValue; |
| sal_Bool bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue ); |
| if( bRet ) |
| { |
| nValue = (nValue % 360 ); |
| if( nValue < 0 ) |
| nValue = 360 + nValue; |
| sal_Int16 nAngle; |
| if( nValue < 45 || nValue > 315 ) |
| nAngle = 0; |
| else if( nValue < 180 ) |
| nAngle = 900; |
| else /* if nValalue <= 315 ) */ |
| nAngle = 2700; |
| rValue <<= nAngle; |
| } |
| |
| return bRet; |
| } |
| |
| sal_Bool XMLTextRotationAnglePropHdl_Impl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Int16 nAngle = sal_Int16(); |
| sal_Bool bRet = ( rValue >>= nAngle ); |
| if( bRet ) |
| { |
| OUStringBuffer aOut; |
| SvXMLUnitConverter::convertNumber( aOut, nAngle / 10 ); |
| rStrExpValue = aOut.makeStringAndClear(); |
| } |
| OSL_ENSURE( bRet, "illegal rotation angle" ); |
| |
| return bRet; |
| } |
| |
| XMLTextRotationAnglePropHdl_Impl::~XMLTextRotationAnglePropHdl_Impl() |
| { |
| } |
| // --------------------------------------------------------------------------- |
| class XMLNumber8OneBasedHdl : public XMLPropertyHandler |
| { |
| |
| public: |
| XMLNumber8OneBasedHdl() {} |
| virtual ~XMLNumber8OneBasedHdl() {}; |
| |
| virtual sal_Bool importXML( |
| const ::rtl::OUString& rStrImpValue, |
| ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| virtual sal_Bool exportXML( |
| ::rtl::OUString& rStrExpValue, |
| const ::com::sun::star::uno::Any& rValue, |
| const SvXMLUnitConverter& ) const; |
| }; |
| |
| sal_Bool XMLNumber8OneBasedHdl::importXML( |
| const OUString& rStrImpValue, |
| Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Int32 nValue = 0; |
| sal_Bool bRet = SvXMLUnitConverter::convertNumber( nValue, rStrImpValue ); |
| if( bRet ) |
| rValue <<= static_cast<sal_Int8>( nValue - 1 ); |
| return bRet; |
| } |
| |
| sal_Bool XMLNumber8OneBasedHdl::exportXML( |
| OUString& rStrExpValue, |
| const Any& rValue, |
| const SvXMLUnitConverter& ) const |
| { |
| sal_Int8 nValue = sal_Int8(); |
| sal_Bool bRet = ( rValue >>= nValue ); |
| if( bRet ) |
| { |
| OUStringBuffer aOut; |
| SvXMLUnitConverter::convertNumber( aOut, nValue + 1 ); |
| rStrExpValue = aOut.makeStringAndClear(); |
| } |
| return bRet; |
| } |
| // --------------------------------------------------------------------------- |
| class XMLTextPropertyHandlerFactory_Impl |
| { |
| public: |
| const XMLPropertyHandler *GetPropertyHandler( sal_Int32 nType ) const; |
| |
| XMLTextPropertyHandlerFactory_Impl(); |
| ~XMLTextPropertyHandlerFactory_Impl(); |
| }; |
| |
| const XMLPropertyHandler *XMLTextPropertyHandlerFactory_Impl::GetPropertyHandler |
| ( sal_Int32 nType ) const |
| { |
| const XMLPropertyHandler* pHdl = 0; |
| switch( nType ) |
| { |
| case XML_TYPE_TEXT_DROPCAP: |
| pHdl = new XMLDropCapPropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_WRAP: |
| pHdl = new XMLWrapPropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_PARAGRAPH_ONLY: |
| pHdl = new XMLParagraphOnlyPropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_WRAP_OUTSIDE: |
| pHdl = new XMLContourModePropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_OPAQUE: |
| pHdl = new XMLOpaquePropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_PROTECT_CONTENT: |
| pHdl = new XMLFrameProtectPropHdl_Impl( XML_CONTENT ); |
| break; |
| case XML_TYPE_TEXT_PROTECT_SIZE: |
| pHdl = new XMLFrameProtectPropHdl_Impl( XML_SIZE ); |
| break; |
| case XML_TYPE_TEXT_PROTECT_POSITION: |
| pHdl = new XMLFrameProtectPropHdl_Impl( XML_POSITION ); |
| break; |
| case XML_TYPE_TEXT_ANCHOR_TYPE: |
| pHdl = new XMLAnchorTypePropHdl; |
| break; |
| case XML_TYPE_TEXT_COLUMNS: |
| pHdl = new XMLTextColumnsPropertyHandler; |
| break; |
| case XML_TYPE_TEXT_HORIZONTAL_POS: |
| pHdl = new XMLConstantsPropertyHandler( pXML_HoriPos_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_HORIZONTAL_POS_MIRRORED: |
| pHdl = new XMLConstantsPropertyHandler( pXML_HoriPosMirrored_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_HORIZONTAL_REL: |
| pHdl = new XMLConstantsPropertyHandler( pXML_HoriRel_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_HORIZONTAL_REL_FRAME: |
| pHdl = new XMLConstantsPropertyHandler( pXML_HoriRelFrame_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_HORIZONTAL_MIRROR: |
| pHdl = new XMLHoriMirrorPropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_VERTICAL_POS: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VertPos_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_VERTICAL_POS_AT_CHAR: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VertPosAtChar_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_VERTICAL_REL: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VertRel_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_VERTICAL_REL_PAGE: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VertRelPage_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_VERTICAL_REL_FRAME: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VertRelFrame_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_VERTICAL_REL_AS_CHAR: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VertRelAsChar_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_MIRROR_VERTICAL: |
| pHdl = new XMLGrfMirrorPropHdl_Impl( XML_VERTICAL, sal_False ); |
| break; |
| case XML_TYPE_TEXT_MIRROR_HORIZONTAL_LEFT: |
| // --> OD 2005-05-12 #i49139# |
| // XML_HORIZONTAL_ON_LEFT_PAGES is replaced by XML_HORIZONTAL_ON_EVEN. |
| pHdl = new XMLGrfMirrorPropHdl_Impl( XML_HORIZONTAL_ON_EVEN, sal_True ); |
| // <-- |
| break; |
| case XML_TYPE_TEXT_MIRROR_HORIZONTAL_RIGHT: |
| // --> OD 2005-05-12 #i49139# |
| // XML_HORIZONTAL_ON_RIGHT_PAGES is replaced by XML_HORIZONTAL_ON_ODD. |
| pHdl = new XMLGrfMirrorPropHdl_Impl( XML_HORIZONTAL_ON_ODD, sal_True ); |
| // <-- |
| break; |
| case XML_TYPE_TEXT_CLIP: |
| pHdl = new XMLClipPropertyHandler( sal_False ); |
| break; |
| case XML_TYPE_TEXT_CLIP11: |
| pHdl = new XMLClipPropertyHandler( sal_True ); |
| break; |
| case XML_TYPE_TEXT_EMPHASIZE: |
| pHdl = new XMLTextEmphasizePropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_COMBINE: |
| pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_LINES ), |
| GetXMLToken( XML_NONE ) ); |
| break; |
| case XML_TYPE_TEXT_COMBINE_CHARACTERS: |
| pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_LETTERS ), |
| GetXMLToken( XML_NONE ) ); |
| break; |
| case XML_TYPE_TEXT_COMBINECHAR: |
| pHdl = new XMLTextCombineCharPropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_AUTOSPACE: |
| pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_IDEOGRAPH_ALPHA ), |
| GetXMLToken( XML_NONE ) ); |
| break; |
| case XML_TYPE_TEXT_PUNCTUATION_WRAP: |
| pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_HANGING ), |
| GetXMLToken( XML_SIMPLE ) ); |
| break; |
| case XML_TYPE_TEXT_LINE_BREAK: |
| pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_STRICT ), |
| GetXMLToken( XML_NORMAL ) ); |
| break; |
| case XML_TYPE_TEXT_REL_WIDTH_HEIGHT: |
| pHdl = new XMLTextRelWidthHeightPropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_SYNC_WIDTH_HEIGHT: |
| pHdl = new XMLTextSyncWidthHeightPropHdl_Impl( XML_SCALE ); |
| break; |
| case XML_TYPE_TEXT_SYNC_WIDTH_HEIGHT_MIN: |
| pHdl = new XMLTextSyncWidthHeightPropHdl_Impl( XML_SCALE_MIN ); |
| break; |
| case XML_TYPE_TEXT_RUBY_ADJUST: |
| pHdl = new XMLConstantsPropertyHandler( pXML_RubyAdjust_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_FONT_RELIEF: |
| pHdl = new XMLConstantsPropertyHandler( pXML_FontRelief_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_ROTATION_ANGLE: |
| pHdl = new XMLTextRotationAnglePropHdl_Impl; |
| break; |
| case XML_TYPE_TEXT_ROTATION_SCALE: |
| pHdl = new XMLNamedBoolPropertyHdl( GetXMLToken( XML_FIXED ), |
| GetXMLToken( XML_LINE_HEIGHT ) ); |
| break; |
| case XML_TYPE_TEXT_VERTICAL_ALIGN: |
| pHdl = new XMLConstantsPropertyHandler( pXML_VerticalAlign_Enum, XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_TEXT_RUBY_POSITION: |
| pHdl = new XMLNamedBoolPropertyHdl( ::xmloff::token::XML_ABOVE, |
| ::xmloff::token::XML_BELOW ); |
| break; |
| // OD 2004-05-05 #i28701# |
| case XML_TYPE_WRAP_INFLUENCE_ON_POSITION: |
| pHdl = new XMLConstantsPropertyHandler( pXML_WrapInfluenceOnPosition_Enum, |
| XML_TOKEN_INVALID ); |
| break; |
| case XML_TYPE_BORDER_MODEL: |
| pHdl = new XMLNamedBoolPropertyHdl( xmloff::token::XML_COLLAPSING, |
| xmloff::token::XML_SEPARATING ); |
| break; |
| case XML_TYPE_TEXT_LINE_MODE: |
| pHdl = new XMLNamedBoolPropertyHdl( |
| ::xmloff::token::XML_SKIP_WHITE_SPACE, |
| ::xmloff::token::XML_CONTINUOUS); |
| break; |
| case XML_TYPE_TEXT_KEEP: |
| pHdl = new XMLNamedBoolPropertyHdl( |
| ::xmloff::token::XML_ALWAYS, |
| ::xmloff::token::XML_AUTO); |
| break; |
| case XML_TYPE_TEXT_NKEEP: |
| pHdl = new XMLNamedBoolPropertyHdl( |
| ::xmloff::token::XML_AUTO, |
| ::xmloff::token::XML_ALWAYS); |
| break; |
| case XML_TYPE_TEXT_NUMBER8_ONE_BASED: |
| pHdl = new XMLNumber8OneBasedHdl(); |
| break; |
| |
| //UUUU |
| case XML_SW_TYPE_FILLSTYLE: |
| pHdl = new XMLEnumPropertyHdl( aXML_FillStyle_EnumMap, ::getCppuType((const FillStyle*)0) ); |
| break; |
| case XML_SW_TYPE_FILLBITMAPSIZE: |
| pHdl = new XMLFillBitmapSizePropertyHandler(); |
| break; |
| case XML_SW_TYPE_LOGICAL_SIZE: |
| pHdl = new XMLBitmapLogicalSizePropertyHandler(); |
| break; |
| case XML_SW_TYPE_BITMAP_REFPOINT: |
| pHdl = new XMLEnumPropertyHdl( aXML_RefPoint_EnumMap, getCppuType((const RectanglePoint*)0) ); |
| break; |
| case XML_SW_TYPE_BITMAP_MODE: |
| pHdl = new XMLEnumPropertyHdl( aXML_BitmapMode_EnumMap, getCppuType((const BitmapMode*)0) ); |
| break; |
| case XML_SW_TYPE_BITMAPREPOFFSETX: |
| case XML_SW_TYPE_BITMAPREPOFFSETY: |
| pHdl = new XMLBitmapRepeatOffsetPropertyHandler(XML_SW_TYPE_BITMAPREPOFFSETX == nType); |
| break; |
| |
| //UUUU |
| default: |
| { |
| OSL_ENSURE(false, "XMLPropertyHandler missing (!)"); |
| break; |
| } |
| } |
| |
| return pHdl; |
| } |
| |
| XMLTextPropertyHandlerFactory_Impl::XMLTextPropertyHandlerFactory_Impl() |
| { |
| } |
| |
| XMLTextPropertyHandlerFactory_Impl::~XMLTextPropertyHandlerFactory_Impl() |
| { |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| XMLTextPropertyHandlerFactory::XMLTextPropertyHandlerFactory() : |
| XMLPropertyHandlerFactory(), |
| pImpl( new XMLTextPropertyHandlerFactory_Impl ) |
| { |
| } |
| |
| XMLTextPropertyHandlerFactory::~XMLTextPropertyHandlerFactory() |
| { |
| delete pImpl; |
| } |
| |
| const XMLPropertyHandler *XMLTextPropertyHandlerFactory::GetPropertyHandler( |
| sal_Int32 nType ) const |
| { |
| const XMLPropertyHandler *pHdl = |
| XMLPropertyHandlerFactory::GetPropertyHandler( nType ); |
| |
| if( !pHdl ) |
| { |
| const XMLPropertyHandler *pNewHdl = pImpl->GetPropertyHandler( nType ); |
| |
| if( pNewHdl ) |
| PutHdlCache( nType, pNewHdl ); |
| |
| pHdl = pNewHdl; |
| } |
| |
| return pHdl; |
| } |
| |
| |
