| /************************************************************** |
| * |
| * 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. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "oox/drawingml/customshapegeometry.hxx" |
| |
| #include <com/sun/star/xml/sax/FastToken.hpp> |
| #include <comphelper/stl_types.hxx> |
| #include <hash_map> |
| #include "oox/helper/helper.hxx" |
| #include "oox/helper/attributelist.hxx" |
| #include "oox/helper/propertymap.hxx" |
| |
| using ::rtl::OUString; |
| using namespace ::oox::core; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::drawing; |
| using namespace ::com::sun::star::xml::sax; |
| |
| namespace oox { namespace drawingml { |
| |
| enum FormularCommand |
| { |
| FC_MULDIV = 0, |
| FC_PLUSMINUS, |
| FC_PLUSDIV, |
| FC_IFELSE, |
| FC_ABS, |
| FC_AT2, |
| FC_CAT2, |
| FC_COS, |
| FC_MAX, |
| FC_MIN, |
| FC_MOD, |
| FC_PIN, |
| FC_SAT2, |
| FC_SIN, |
| FC_SQRT, |
| FC_TAN, |
| FC_VAL, |
| FC_LAST |
| }; |
| struct FormularCommandNameTable |
| { |
| const char* pS; |
| FormularCommand pE; |
| }; |
| static FormularCommandNameTable pFormularCommandNameTable[] = |
| { |
| { "*/", FC_MULDIV }, |
| { "+-", FC_PLUSMINUS }, |
| { "+/", FC_PLUSDIV }, |
| { "ifelse", FC_IFELSE }, |
| { "abs", FC_ABS }, |
| { "at2", FC_AT2 }, |
| { "cat2", FC_CAT2 }, |
| { "cos", FC_COS }, |
| { "max", FC_MAX }, |
| { "min", FC_MIN }, |
| { "mod", FC_MOD }, |
| { "pin", FC_PIN }, |
| { "sat2", FC_SAT2 }, |
| { "sin", FC_SIN }, |
| { "sqrt", FC_SQRT }, |
| { "tan", FC_TAN }, |
| { "val", FC_VAL } |
| |
| }; |
| typedef std::hash_map< rtl::OUString, FormularCommand, comphelper::UStringHash, comphelper::UStringEqual > FormulaCommandHMap; |
| |
| static const FormulaCommandHMap* pCommandHashMap; |
| |
| // |
| rtl::OUString GetFormulaParameter( const EnhancedCustomShapeParameter& rParameter ) |
| { |
| rtl::OUString aRet; |
| switch( rParameter.Type ) |
| { |
| case EnhancedCustomShapeParameterType::NORMAL : |
| { |
| if ( rParameter.Value.getValueTypeClass() == TypeClass_DOUBLE ) |
| { |
| double fValue = 0.0; |
| if ( rParameter.Value >>= fValue ) |
| aRet = rtl::OUString::valueOf( fValue ); |
| } |
| else |
| { |
| sal_Int32 nValue = 0; |
| if ( rParameter.Value >>= nValue ) |
| aRet = rtl::OUString::valueOf( nValue ); |
| } |
| } |
| break; |
| case EnhancedCustomShapeParameterType::EQUATION : |
| { |
| if ( rParameter.Value.getValueTypeClass() == TypeClass_LONG ) |
| { |
| sal_Int32 nFormulaIndex; |
| if ( rParameter.Value >>= nFormulaIndex ) |
| { |
| aRet = CREATE_OUSTRING( "?" ) |
| + rtl::OUString::valueOf( nFormulaIndex ) |
| + CREATE_OUSTRING( " " ); |
| } |
| } |
| else |
| { |
| // ups... we should have an index here and not the formula name |
| } |
| } |
| break; |
| case EnhancedCustomShapeParameterType::ADJUSTMENT : |
| { |
| if ( rParameter.Value.getValueTypeClass() == TypeClass_LONG ) |
| { |
| sal_Int32 nAdjustmentIndex; |
| if ( rParameter.Value >>= nAdjustmentIndex ) |
| { |
| aRet = CREATE_OUSTRING( "$" ) |
| + rtl::OUString::valueOf( nAdjustmentIndex ) |
| + CREATE_OUSTRING( " " ); |
| } |
| } |
| else |
| { |
| // ups... we should have an index here and not the formula name |
| } |
| } |
| break; |
| case EnhancedCustomShapeParameterType::LEFT : |
| { |
| const rtl::OUString sLeft( CREATE_OUSTRING( "left" ) ); |
| aRet = sLeft; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::TOP : |
| { |
| const rtl::OUString sTop( CREATE_OUSTRING( "top" ) ); |
| aRet = sTop; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::RIGHT : |
| { |
| const rtl::OUString sRight( CREATE_OUSTRING( "right" ) ); |
| aRet = sRight; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::BOTTOM : |
| { |
| const rtl::OUString sBottom( CREATE_OUSTRING( "bottom" ) ); |
| aRet = sBottom; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::XSTRETCH : |
| { |
| const rtl::OUString sXStretch( CREATE_OUSTRING( "xstretch" ) ); |
| aRet = sXStretch; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::YSTRETCH : |
| { |
| const rtl::OUString sYStretch( CREATE_OUSTRING( "ystretch" ) ); |
| aRet = sYStretch; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::HASSTROKE : |
| { |
| const rtl::OUString sHasStroke( CREATE_OUSTRING( "hasstroke" ) ); |
| aRet = sHasStroke; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::HASFILL : |
| { |
| const rtl::OUString sHasFill( CREATE_OUSTRING( "hasfill" ) ); |
| aRet = sHasFill; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::WIDTH : |
| { |
| const rtl::OUString sWidth( CREATE_OUSTRING( "width" ) ); |
| aRet = sWidth; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::HEIGHT : |
| { |
| const rtl::OUString sHeight( CREATE_OUSTRING( "height" ) ); |
| aRet = sHeight; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::LOGWIDTH : |
| { |
| const rtl::OUString sLogWidth( CREATE_OUSTRING( "logwidth" ) ); |
| aRet = sLogWidth; |
| } |
| break; |
| case EnhancedCustomShapeParameterType::LOGHEIGHT : |
| { |
| const rtl::OUString sLogHeight( CREATE_OUSTRING( "logheight" ) ); |
| aRet = sLogHeight; |
| } |
| break; |
| } |
| return aRet; |
| } |
| |
| // --------------------------------------------------------------------- |
| |
| static EnhancedCustomShapeParameter GetAdjCoordinate( CustomShapeProperties& rCustomShapeProperties, const::rtl::OUString& rValue, sal_Bool bNoSymbols ) |
| { |
| com::sun::star::drawing::EnhancedCustomShapeParameter aRet; |
| if ( rValue.getLength() ) |
| { |
| sal_Bool bConstant = sal_True; |
| sal_Int32 nConstant = 0; |
| sal_Char nVal = 0; |
| |
| // first check if its a constant value |
| switch( AttributeConversion::decodeToken( rValue ) ) |
| { |
| case XML_3cd4 : nConstant = 270 * 60000; break; |
| case XML_3cd8 : nConstant = 135 * 60000; break; |
| case XML_5cd8 : nConstant = 225 * 60000; break; |
| case XML_7cd8 : nConstant = 315 * 60000; break; |
| case XML_cd2 : nConstant = 180 * 60000; break; |
| case XML_cd4 : nConstant = 90 * 60000; break; |
| case XML_cd8 : nConstant = 45 * 60000; break; |
| |
| case XML_b : // variable height of the shape defined in spPr |
| case XML_h : |
| { |
| if ( bNoSymbols ) |
| { |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "height" ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| else |
| aRet.Type = EnhancedCustomShapeParameterType::HEIGHT; // TODO: HEIGHT needs to be implemented |
| } |
| break; |
| |
| |
| case XML_hd8 : // !!PASSTHROUGH INTENDED |
| nVal += 2; // */ h 1.0 8.0 |
| case XML_hd6 : // */ h 1.0 6.0 |
| nVal++; |
| case XML_hd5 : // */ h 1.0 5.0 |
| nVal++; |
| case XML_hd4 : // */ h 1.0 4.0 |
| nVal += 2; |
| case XML_hd2 : // */ h 1.0 2.0 |
| case XML_vc : // */ h 1.0 2.0 |
| { |
| nVal += '2'; |
| |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "height/" ) + rtl::OUString( nVal ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| break; |
| |
| case XML_t : |
| case XML_l : |
| { |
| nConstant = 0; |
| aRet.Type = EnhancedCustomShapeParameterType::NORMAL; |
| } |
| break; |
| |
| case XML_ls : // longest side: max w h |
| { |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "max(width,height)" ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| break; |
| case XML_ss : // shortest side: min w h |
| { |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "min(width,height)" ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| break; |
| case XML_ssd8 : // */ ss 1.0 8.0 |
| nVal += 2; |
| case XML_ssd6 : // */ ss 1.0 6.0 |
| nVal += 2; |
| case XML_ssd4 : // */ ss 1.0 4.0 |
| nVal += 2; |
| case XML_ssd2 : // */ ss 1.0 2.0 |
| { |
| nVal += '2'; |
| |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "min(width,height)/" ) + rtl::OUString( nVal ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| break; |
| |
| case XML_r : // variable width of the shape defined in spPr |
| case XML_w : |
| { |
| if ( bNoSymbols ) |
| { |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "width" ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| else |
| aRet.Type = EnhancedCustomShapeParameterType::WIDTH; |
| } |
| break; |
| |
| case XML_wd10 : // */ w 1.0 10.0 |
| nVal += 2; |
| case XML_wd8 : // */ w 1.0 8.0 |
| nVal += 2; |
| case XML_wd6 : // */ w 1.0 6.0 |
| nVal++; |
| case XML_wd5 : // */ w 1.0 5.0 |
| nVal++; |
| case XML_wd4 : // */ w 1.0 4.0 |
| nVal += 2; |
| case XML_hc : // */ w 1.0 2.0 |
| case XML_wd2 : // */ w 1.0 2.0 |
| { |
| nVal += '2'; |
| |
| CustomShapeGuide aGuide; |
| aGuide.maName = rValue; |
| aGuide.maFormula = CREATE_OUSTRING( "width/" ) + rtl::OUString( nVal ); |
| |
| aRet.Value = Any( CustomShapeProperties::SetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), aGuide ) ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| break; |
| |
| default: |
| bConstant = sal_False; |
| break; |
| } |
| if ( bConstant ) |
| { |
| if ( nConstant ) |
| { |
| aRet.Value = Any( nConstant ); |
| aRet.Type = EnhancedCustomShapeParameterType::NORMAL; |
| } |
| } |
| else |
| { |
| sal_Unicode n = rValue[ 0 ]; |
| if ( ( n == '+' ) || ( n == '-' ) ) |
| { |
| if ( rValue.getLength() > 0 ) |
| n = rValue[ 1 ]; |
| } |
| if ( ( n >= '0' ) && ( n <= '9' ) ) |
| { // seems to be a ST_Coordinate |
| aRet.Value = Any( rValue.toInt32() ); |
| aRet.Type = EnhancedCustomShapeParameterType::NORMAL; |
| } |
| else |
| { |
| sal_Int32 nGuideIndex = CustomShapeProperties::GetCustomShapeGuideValue( rCustomShapeProperties.getAdjustmentGuideList(), rValue ); |
| if ( nGuideIndex >= 0 ) |
| { |
| aRet.Value = Any( nGuideIndex ); |
| aRet.Type = EnhancedCustomShapeParameterType::ADJUSTMENT; |
| } |
| else |
| { |
| nGuideIndex = CustomShapeProperties::GetCustomShapeGuideValue( rCustomShapeProperties.getGuideList(), rValue ); |
| if ( nGuideIndex >= 0 ) |
| { |
| aRet.Value = Any( nGuideIndex ); |
| aRet.Type = EnhancedCustomShapeParameterType::EQUATION; |
| } |
| else |
| aRet.Value = Any( rValue ); |
| } |
| } |
| } |
| } |
| return aRet; |
| } |
| |
| static EnhancedCustomShapeParameter GetAdjAngle( CustomShapeProperties& rCustomShapeProperties, const ::rtl::OUString& rValue ) |
| { |
| EnhancedCustomShapeParameter aAngle( GetAdjCoordinate( rCustomShapeProperties, rValue, sal_True ) ); |
| if ( aAngle.Type == EnhancedCustomShapeParameterType::NORMAL ) |
| { |
| sal_Int32 nValue = 0; |
| aAngle.Value >>= nValue; |
| double fValue = ( static_cast< double >( nValue ) / 60000.0 ) * 360.0; |
| aAngle.Value <<= fValue; |
| } |
| return aAngle; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_GeomGuideList |
| class GeomGuideListContext : public ContextHandler |
| { |
| public: |
| GeomGuideListContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< CustomShapeGuide >& rGuideList ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| std::vector< CustomShapeGuide >& mrGuideList; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| GeomGuideListContext::GeomGuideListContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< CustomShapeGuide >& rGuideList ) |
| : ContextHandler( rParent ) |
| , mrGuideList( rGuideList ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| } |
| |
| static rtl::OUString convertToOOEquation( CustomShapeProperties& rCustomShapeProperties, const rtl::OUString& rSource ) |
| { |
| if ( !pCommandHashMap ) |
| { |
| FormulaCommandHMap* pHM = new FormulaCommandHMap(); |
| for( sal_Int32 i = 0; i < FC_LAST; i++ ) |
| (*pHM)[ OUString::createFromAscii( pFormularCommandNameTable[ i ].pS ) ] = pFormularCommandNameTable[ i ].pE; |
| pCommandHashMap = pHM; |
| } |
| |
| std::vector< rtl::OUString > aTokens; |
| sal_Int32 nIndex = 0; |
| do |
| { |
| rtl::OUString aToken( rSource.getToken( 0, ' ', nIndex ) ); |
| if ( aToken.getLength() ) |
| aTokens.push_back( aToken ); |
| } |
| while ( nIndex >= 0 ); |
| |
| rtl::OUString aEquation; |
| if ( aTokens.size() ) |
| { |
| sal_Int32 i, nParameters = aTokens.size() - 1; |
| if ( nParameters > 3 ) |
| nParameters = 3; |
| |
| rtl::OUString sParameters[ 3 ]; |
| |
| for ( i = 0; i < nParameters; i++ ) |
| sParameters[ i ] = GetFormulaParameter( GetAdjCoordinate( rCustomShapeProperties, aTokens[ i + 1 ], sal_False ) ); |
| |
| const FormulaCommandHMap::const_iterator aIter( pCommandHashMap->find( aTokens[ 0 ] ) ); |
| if ( aIter != pCommandHashMap->end() ) |
| { |
| switch( aIter->second ) |
| { |
| case FC_MULDIV : |
| { |
| if ( nParameters == 3 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "*" ) + sParameters[ 1 ] |
| + CREATE_OUSTRING( "/" ) + sParameters[ 2 ]; |
| } |
| break; |
| case FC_PLUSMINUS : |
| { |
| if ( nParameters == 3 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "+" ) + sParameters[ 1 ] |
| + CREATE_OUSTRING( "-" ) + sParameters[ 2 ]; |
| } |
| break; |
| case FC_PLUSDIV : |
| { |
| if ( nParameters == 3 ) |
| aEquation = CREATE_OUSTRING( "(" ) + sParameters[ 0 ] + CREATE_OUSTRING( "+" ) |
| + sParameters[ 1 ] + CREATE_OUSTRING( ")/" ) + sParameters[ 2 ]; |
| } |
| break; |
| case FC_IFELSE : |
| { |
| if ( nParameters == 3 ) |
| aEquation = CREATE_OUSTRING( "if(" ) + sParameters[ 0 ] + CREATE_OUSTRING( "," ) |
| + sParameters[ 1 ] + CREATE_OUSTRING( "," ) + sParameters[ 2 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_ABS : |
| { |
| if ( nParameters == 1 ) |
| aEquation = CREATE_OUSTRING( "abs(" ) + sParameters[ 0 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_AT2 : |
| { |
| if ( nParameters == 2 ) |
| aEquation = CREATE_OUSTRING( "atan2(" ) + sParameters[ 0 ] + CREATE_OUSTRING( "," ) |
| + sParameters[ 1 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_CAT2 : |
| { |
| if ( nParameters == 3 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "*(cos(arctan(" ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( "," ) + sParameters[ 2 ] + CREATE_OUSTRING( ")))" ); |
| } |
| break; |
| case FC_COS : |
| { |
| if ( nParameters == 2 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "*cos(" ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_MAX : |
| { |
| if ( nParameters == 2 ) |
| aEquation = CREATE_OUSTRING( "max(" ) + sParameters[ 0 ] + CREATE_OUSTRING( "," ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_MIN : |
| { |
| if ( nParameters == 2 ) |
| aEquation = CREATE_OUSTRING( "min(" ) + sParameters[ 0 ] + CREATE_OUSTRING( "," ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_MOD : |
| { |
| if ( nParameters == 3 ) |
| aEquation = CREATE_OUSTRING( "sqrt(" ) |
| + sParameters[ 0 ] + CREATE_OUSTRING( "*" ) + sParameters[ 0 ] + CREATE_OUSTRING( "+" ) |
| + sParameters[ 1 ] + CREATE_OUSTRING( "*" ) + sParameters[ 1 ] + CREATE_OUSTRING( "+" ) |
| + sParameters[ 2 ] + CREATE_OUSTRING( "*" ) + sParameters[ 2 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_PIN : |
| { |
| if ( nParameters == 3 ) // if(x-y,x,if(y-z,z,y)) |
| aEquation = CREATE_OUSTRING( "if(" ) + sParameters[ 0 ] + CREATE_OUSTRING( "-" ) + sParameters[ 1 ] |
| + CREATE_OUSTRING( "," ) + sParameters[ 0 ] + CREATE_OUSTRING( ",if(" ) + sParameters[ 2 ] |
| + CREATE_OUSTRING( "-" ) + sParameters[ 1 ] + CREATE_OUSTRING( "," ) + sParameters[ 1 ] |
| + CREATE_OUSTRING( "," ) + sParameters[ 2 ] + CREATE_OUSTRING( "))" ); |
| } |
| break; |
| case FC_SAT2 : |
| { |
| if ( nParameters == 3 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "*(sin(arctan(" ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( "," ) + sParameters[ 2 ] + CREATE_OUSTRING( ")))" ); |
| } |
| break; |
| case FC_SIN : |
| { |
| if ( nParameters == 2 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "*sin(" ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_SQRT : |
| { |
| if ( nParameters == 1 ) |
| aEquation = CREATE_OUSTRING( "sqrt(" ) + sParameters[ 0 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_TAN : |
| { |
| if ( nParameters == 2 ) |
| aEquation = sParameters[ 0 ] + CREATE_OUSTRING( "*tan(" ) + |
| sParameters[ 1 ] + CREATE_OUSTRING( ")" ); |
| } |
| break; |
| case FC_VAL : |
| { |
| if ( nParameters == 1 ) |
| aEquation = sParameters[ 0 ]; |
| } |
| break; |
| default : |
| break; |
| } |
| } |
| } |
| return aEquation; |
| } |
| |
| Reference< XFastContextHandler > GeomGuideListContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| if ( aElementToken == A_TOKEN( gd ) ) // CT_GeomGuide |
| { |
| CustomShapeGuide aGuide; |
| aGuide.maName = xAttribs->getOptionalValue( XML_name ); |
| aGuide.maFormula = convertToOOEquation( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_fmla ) ); |
| mrGuideList.push_back( aGuide ); |
| } |
| return this; |
| } |
| |
| // --------------------------------------------------------------------- |
| |
| static const rtl::OUString GetGeomGuideName( const ::rtl::OUString& rValue ) |
| { |
| return rValue; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_AdjPoint2D |
| class AdjPoint2DContext : public ContextHandler |
| { |
| public: |
| AdjPoint2DContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D ); |
| }; |
| |
| AdjPoint2DContext::AdjPoint2DContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D ) |
| : ContextHandler( rParent ) |
| { |
| rAdjPoint2D.First = GetAdjCoordinate( rCustomShapeProperties, xAttribs->getOptionalValue( XML_x ), sal_True ); |
| rAdjPoint2D.Second = GetAdjCoordinate( rCustomShapeProperties, xAttribs->getOptionalValue( XML_y ), sal_True ); |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_XYAdjustHandle |
| class XYAdjustHandleContext : public ContextHandler |
| { |
| public: |
| XYAdjustHandleContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| AdjustHandle& mrAdjustHandle; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| XYAdjustHandleContext::XYAdjustHandleContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle ) |
| : ContextHandler( rParent ) |
| , mrAdjustHandle( rAdjustHandle ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| const rtl::OUString aEmptyDefault; |
| AttributeList aAttribs( xAttribs ); |
| if ( aAttribs.hasAttribute( XML_gdRefX ) ) |
| { |
| mrAdjustHandle.gdRef1 = GetGeomGuideName( aAttribs.getString( XML_gdRefX, aEmptyDefault ) ); |
| } |
| if ( aAttribs.hasAttribute( XML_minX ) ) |
| { |
| mrAdjustHandle.min1 = GetAdjCoordinate( mrCustomShapeProperties, aAttribs.getString( XML_minX, aEmptyDefault ), sal_True ); |
| } |
| if ( aAttribs.hasAttribute( XML_maxX ) ) |
| { |
| mrAdjustHandle.max1 = GetAdjCoordinate( mrCustomShapeProperties, aAttribs.getString( XML_maxX, aEmptyDefault ), sal_True ); |
| } |
| if ( aAttribs.hasAttribute( XML_gdRefY ) ) |
| { |
| mrAdjustHandle.gdRef2 = GetGeomGuideName( aAttribs.getString( XML_gdRefY, aEmptyDefault ) ); |
| } |
| if ( aAttribs.hasAttribute( XML_minY ) ) |
| { |
| mrAdjustHandle.min2 = GetAdjCoordinate( mrCustomShapeProperties, aAttribs.getString( XML_minY, aEmptyDefault ), sal_True ); |
| } |
| if ( aAttribs.hasAttribute( XML_maxY ) ) |
| { |
| mrAdjustHandle.max2 = GetAdjCoordinate( mrCustomShapeProperties, aAttribs.getString( XML_maxY, aEmptyDefault ), sal_True ); |
| } |
| } |
| |
| Reference< XFastContextHandler > XYAdjustHandleContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pos ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, mrAdjustHandle.pos ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_PolarAdjustHandle |
| class PolarAdjustHandleContext : public ContextHandler |
| { |
| public: |
| PolarAdjustHandleContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| AdjustHandle& mrAdjustHandle; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| PolarAdjustHandleContext::PolarAdjustHandleContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, AdjustHandle& rAdjustHandle ) |
| : ContextHandler( rParent ) |
| , mrAdjustHandle( rAdjustHandle ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| const rtl::OUString aEmptyDefault; |
| AttributeList aAttribs( xAttribs ); |
| if ( aAttribs.hasAttribute( XML_gdRefR ) ) |
| { |
| mrAdjustHandle.gdRef1 = GetGeomGuideName( aAttribs.getString( XML_gdRefR, aEmptyDefault ) ); |
| } |
| if ( aAttribs.hasAttribute( XML_minR ) ) |
| { |
| mrAdjustHandle.min1 = GetAdjCoordinate( mrCustomShapeProperties, aAttribs.getString( XML_minR, aEmptyDefault ), sal_True ); |
| } |
| if ( aAttribs.hasAttribute( XML_maxR ) ) |
| { |
| mrAdjustHandle.max1 = GetAdjCoordinate( mrCustomShapeProperties, aAttribs.getString( XML_maxR, aEmptyDefault ), sal_True ); |
| } |
| if ( aAttribs.hasAttribute( XML_gdRefAng ) ) |
| { |
| mrAdjustHandle.gdRef2 = GetGeomGuideName( aAttribs.getString( XML_gdRefAng, aEmptyDefault ) ); |
| } |
| if ( aAttribs.hasAttribute( XML_minAng ) ) |
| { |
| mrAdjustHandle.min2 = GetAdjAngle( mrCustomShapeProperties, aAttribs.getString( XML_minAng, aEmptyDefault ) ); |
| } |
| if ( aAttribs.hasAttribute( XML_maxAng ) ) |
| { |
| mrAdjustHandle.max2 = GetAdjAngle( mrCustomShapeProperties, aAttribs.getString( XML_maxAng, aEmptyDefault ) ); |
| } |
| } |
| |
| Reference< XFastContextHandler > PolarAdjustHandleContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pos ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, mrAdjustHandle.pos ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_AdjustHandleList |
| class AdjustHandleListContext : public ContextHandler |
| { |
| public: |
| AdjustHandleListContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< AdjustHandle >& rAdjustHandleList ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| std::vector< AdjustHandle >& mrAdjustHandleList; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| AdjustHandleListContext::AdjustHandleListContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< AdjustHandle >& rAdjustHandleList ) |
| : ContextHandler( rParent ) |
| , mrAdjustHandleList( rAdjustHandleList ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| } |
| |
| Reference< XFastContextHandler > AdjustHandleListContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( ahXY ) ) // CT_XYAdjustHandle |
| { |
| AdjustHandle aAdjustHandle( sal_False ); |
| mrAdjustHandleList.push_back( aAdjustHandle ); |
| xContext = new XYAdjustHandleContext( *this, xAttribs, mrCustomShapeProperties, mrAdjustHandleList.back() ); |
| } |
| else if ( aElementToken == A_TOKEN( ahPolar ) ) // CT_PolarAdjustHandle |
| { |
| AdjustHandle aAdjustHandle( sal_True ); |
| mrAdjustHandleList.push_back( aAdjustHandle ); |
| xContext = new PolarAdjustHandleContext( *this, xAttribs, mrCustomShapeProperties, mrAdjustHandleList.back() ); |
| } |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_ConnectionSite |
| class ConnectionSiteContext : public ContextHandler |
| { |
| public: |
| ConnectionSiteContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, ConnectionSite& rConnectionSite ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| ConnectionSite& mrConnectionSite; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| ConnectionSiteContext::ConnectionSiteContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, ConnectionSite& rConnectionSite ) |
| : ContextHandler( rParent ) |
| , mrConnectionSite( rConnectionSite ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| mrConnectionSite.ang = GetAdjAngle( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_ang ) ); |
| } |
| |
| Reference< XFastContextHandler > ConnectionSiteContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pos ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, mrConnectionSite.pos ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_Path2DMoveTo |
| class Path2DMoveToContext : public ContextHandler |
| { |
| public: |
| Path2DMoveToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| EnhancedCustomShapeParameterPair& mrAdjPoint2D; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| Path2DMoveToContext::Path2DMoveToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D ) |
| : ContextHandler( rParent ) |
| , mrAdjPoint2D( rAdjPoint2D ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| } |
| |
| Reference< XFastContextHandler > Path2DMoveToContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pt ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, mrAdjPoint2D ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_Path2DLineTo |
| class Path2DLineToContext : public ContextHandler |
| { |
| public: |
| Path2DLineToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| EnhancedCustomShapeParameterPair& mrAdjPoint2D; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| Path2DLineToContext::Path2DLineToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rAdjPoint2D ) |
| : ContextHandler( rParent ) |
| , mrAdjPoint2D( rAdjPoint2D ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| } |
| |
| Reference< XFastContextHandler > Path2DLineToContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pt ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, mrAdjPoint2D ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_Path2DQuadBezierTo |
| class Path2DQuadBezierToContext : public ContextHandler |
| { |
| public: |
| Path2DQuadBezierToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, EnhancedCustomShapeParameterPair& rPt1, EnhancedCustomShapeParameterPair& rPt2 ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| EnhancedCustomShapeParameterPair& mrPt1; |
| EnhancedCustomShapeParameterPair& mrPt2; |
| int nCount; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| Path2DQuadBezierToContext::Path2DQuadBezierToContext( ContextHandler& rParent, |
| CustomShapeProperties& rCustomShapeProperties, |
| EnhancedCustomShapeParameterPair& rPt1, |
| EnhancedCustomShapeParameterPair& rPt2 ) |
| : ContextHandler( rParent ) |
| , mrPt1( rPt1 ) |
| , mrPt2( rPt2 ) |
| , nCount( 0 ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| } |
| |
| Reference< XFastContextHandler > Path2DQuadBezierToContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pt ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, nCount++ ? mrPt2 : mrPt1 ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_Path2DCubicBezierTo |
| class Path2DCubicBezierToContext : public ContextHandler |
| { |
| public: |
| Path2DCubicBezierToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, |
| EnhancedCustomShapeParameterPair&, EnhancedCustomShapeParameterPair&, EnhancedCustomShapeParameterPair& ); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| CustomShapeProperties& mrCustomShapeProperties; |
| EnhancedCustomShapeParameterPair& mrControlPt1; |
| EnhancedCustomShapeParameterPair& mrControlPt2; |
| EnhancedCustomShapeParameterPair& mrEndPt; |
| int nCount; |
| }; |
| |
| Path2DCubicBezierToContext::Path2DCubicBezierToContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, |
| EnhancedCustomShapeParameterPair& rControlPt1, |
| EnhancedCustomShapeParameterPair& rControlPt2, |
| EnhancedCustomShapeParameterPair& rEndPt ) |
| : ContextHandler( rParent ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| , mrControlPt1( rControlPt1 ) |
| , mrControlPt2( rControlPt2 ) |
| , mrEndPt( rEndPt ) |
| , nCount( 0 ) |
| { |
| } |
| |
| Reference< XFastContextHandler > Path2DCubicBezierToContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( pt ) ) |
| xContext = new AdjPoint2DContext( *this, xAttribs, mrCustomShapeProperties, |
| nCount++ ? nCount == 2 ? mrControlPt2 : mrEndPt : mrControlPt1 ); // CT_AdjPoint2D |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_Path2DContext |
| class Path2DContext : public ContextHandler |
| { |
| public: |
| Path2DContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments, Path2D& rPath2D ); |
| virtual ~Path2DContext(); |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL |
| createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) |
| throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| Path2D& mrPath2D; |
| std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >& mrSegments; |
| CustomShapeProperties& mrCustomShapeProperties; |
| }; |
| |
| Path2DContext::Path2DContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties, std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >& rSegments, Path2D& rPath2D ) |
| : ContextHandler( rParent ) |
| , mrPath2D( rPath2D ) |
| , mrSegments( rSegments ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| const rtl::OUString aEmptyString; |
| |
| AttributeList aAttribs( xAttribs ); |
| rPath2D.w = aAttribs.getString( XML_w, aEmptyString ).toInt64(); |
| rPath2D.h = aAttribs.getString( XML_h, aEmptyString ).toInt64(); |
| rPath2D.fill = aAttribs.getToken( XML_fill, XML_norm ); |
| rPath2D.stroke = aAttribs.getBool( XML_stroke, sal_True ); |
| rPath2D.extrusionOk = aAttribs.getBool( XML_extrusionOk, sal_True ); |
| } |
| |
| Path2DContext::~Path2DContext() |
| { |
| EnhancedCustomShapeSegment aNewSegment; |
| if ( mrPath2D.fill == XML_none ) |
| { |
| aNewSegment.Command = EnhancedCustomShapeSegmentCommand::NOFILL; |
| aNewSegment.Count = 0; |
| mrSegments.push_back( aNewSegment ); |
| } |
| aNewSegment.Command = EnhancedCustomShapeSegmentCommand::ENDSUBPATH; |
| aNewSegment.Count = 0; |
| mrSegments.push_back( aNewSegment ); |
| } |
| |
| Reference< XFastContextHandler > Path2DContext::createFastChildContext( sal_Int32 aElementToken, |
| const Reference< XFastAttributeList >& xAttribs ) throw ( SAXException, RuntimeException ) |
| { |
| Reference< XFastContextHandler > xContext; |
| switch( aElementToken ) |
| { |
| case A_TOKEN( close ) : |
| { |
| EnhancedCustomShapeSegment aNewSegment; |
| aNewSegment.Command = EnhancedCustomShapeSegmentCommand::CLOSESUBPATH; |
| aNewSegment.Count = 0; |
| mrSegments.push_back( aNewSegment ); |
| } |
| break; |
| case A_TOKEN( moveTo ) : |
| { |
| EnhancedCustomShapeSegment aNewSegment; |
| aNewSegment.Command = EnhancedCustomShapeSegmentCommand::MOVETO; |
| aNewSegment.Count = 1; |
| mrSegments.push_back( aNewSegment ); |
| |
| EnhancedCustomShapeParameterPair aAdjPoint2D; |
| mrPath2D.parameter.push_back( aAdjPoint2D ); |
| xContext = new Path2DMoveToContext( *this, mrCustomShapeProperties, mrPath2D.parameter.back() ); |
| } |
| break; |
| case A_TOKEN( lnTo ) : |
| { |
| |
| if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::LINETO ) ) |
| mrSegments.back().Count++; |
| else |
| { |
| EnhancedCustomShapeSegment aSegment; |
| aSegment.Command = EnhancedCustomShapeSegmentCommand::LINETO; |
| aSegment.Count = 1; |
| mrSegments.push_back( aSegment ); |
| } |
| EnhancedCustomShapeParameterPair aAdjPoint2D; |
| mrPath2D.parameter.push_back( aAdjPoint2D ); |
| xContext = new Path2DLineToContext( *this, mrCustomShapeProperties, mrPath2D.parameter.back() ); |
| } |
| break; |
| case A_TOKEN( arcTo ) : // CT_Path2DArcTo |
| { |
| if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::ARCTO ) ) |
| mrSegments.back().Count++; |
| else |
| { |
| EnhancedCustomShapeSegment aSegment; |
| aSegment.Command = EnhancedCustomShapeSegmentCommand::ARCTO; |
| aSegment.Count = 1; |
| mrSegments.push_back( aSegment ); |
| } |
| EnhancedCustomShapeParameter aWidth = GetAdjCoordinate( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_wR ), sal_True ); |
| EnhancedCustomShapeParameter aHeight = GetAdjCoordinate( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_hR ), sal_True ); |
| EnhancedCustomShapeParameter aStartAngle = GetAdjAngle( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_stAng ) ); |
| EnhancedCustomShapeParameter swAngle = GetAdjAngle( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_swAng ) ); |
| |
| EnhancedCustomShapeParameterPair aPt1; // TODO: conversion from (wr hr stAng swAng) |
| EnhancedCustomShapeParameterPair aPt2; // to (x1 y1 x2 y2 x3 y3 x y) needed |
| EnhancedCustomShapeParameterPair aPt3; |
| EnhancedCustomShapeParameterPair aPt; |
| mrPath2D.parameter.push_back( aPt1 ); |
| mrPath2D.parameter.push_back( aPt2 ); |
| mrPath2D.parameter.push_back( aPt3 ); |
| mrPath2D.parameter.push_back( aPt ); |
| } |
| break; |
| case A_TOKEN( quadBezTo ) : |
| { |
| if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO ) ) |
| mrSegments.back().Count++; |
| else |
| { |
| EnhancedCustomShapeSegment aSegment; |
| aSegment.Command = EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO; |
| aSegment.Count = 1; |
| mrSegments.push_back( aSegment ); |
| } |
| EnhancedCustomShapeParameterPair aPt1; |
| EnhancedCustomShapeParameterPair aPt2; |
| mrPath2D.parameter.push_back( aPt1 ); |
| mrPath2D.parameter.push_back( aPt2 ); |
| xContext = new Path2DQuadBezierToContext( *this, mrCustomShapeProperties, |
| mrPath2D.parameter[ mrPath2D.parameter.size() - 2 ], |
| mrPath2D.parameter.back() ); |
| } |
| break; |
| case A_TOKEN( cubicBezTo ) : |
| { |
| if ( !mrSegments.empty() && ( mrSegments.back().Command == EnhancedCustomShapeSegmentCommand::CURVETO ) ) |
| mrSegments.back().Count++; |
| else |
| { |
| EnhancedCustomShapeSegment aSegment; |
| aSegment.Command = EnhancedCustomShapeSegmentCommand::CURVETO; |
| aSegment.Count = 1; |
| mrSegments.push_back( aSegment ); |
| } |
| EnhancedCustomShapeParameterPair aControlPt1; |
| EnhancedCustomShapeParameterPair aControlPt2; |
| EnhancedCustomShapeParameterPair aEndPt; |
| mrPath2D.parameter.push_back( aControlPt1 ); |
| mrPath2D.parameter.push_back( aControlPt2 ); |
| mrPath2D.parameter.push_back( aEndPt ); |
| xContext = new Path2DCubicBezierToContext( *this, mrCustomShapeProperties, |
| mrPath2D.parameter[ mrPath2D.parameter.size() - 3 ], |
| mrPath2D.parameter[ mrPath2D.parameter.size() - 2 ], |
| mrPath2D.parameter.back() ); |
| } |
| break; |
| } |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_Path2DList |
| class Path2DListContext : public ContextHandler |
| { |
| public: |
| Path2DListContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< EnhancedCustomShapeSegment >& rSegments, |
| std::vector< Path2D >& rPath2DList ); |
| |
| virtual ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException); |
| |
| protected: |
| |
| CustomShapeProperties& mrCustomShapeProperties; |
| std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >& mrSegments; |
| std::vector< Path2D >& mrPath2DList; |
| }; |
| |
| Path2DListContext::Path2DListContext( ContextHandler& rParent, CustomShapeProperties& rCustomShapeProperties, std::vector< EnhancedCustomShapeSegment >& rSegments, |
| std::vector< Path2D >& rPath2DList ) |
| : ContextHandler( rParent ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| , mrSegments( rSegments ) |
| , mrPath2DList( rPath2DList ) |
| { |
| } |
| |
| ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastContextHandler > SAL_CALL Path2DListContext::createFastChildContext( sal_Int32 aElementToken, const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastAttributeList >& xAttribs ) throw (::com::sun::star::xml::sax::SAXException, ::com::sun::star::uno::RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| if ( aElementToken == A_TOKEN( path ) ) |
| { |
| Path2D aPath2D; |
| mrPath2DList.push_back( aPath2D ); |
| xContext = new Path2DContext( *this, xAttribs, mrCustomShapeProperties, mrSegments, mrPath2DList.back() ); |
| } |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| |
| OUString GetShapeType( sal_Int32 nType ) |
| { |
| OUString sType; |
| switch( nType ) |
| { |
| case XML_lineInv: // TODO |
| case XML_line: { |
| static const OUString sLine = CREATE_OUSTRING( "mso-spt20" ); |
| sType = sLine; |
| } break; |
| case XML_triangle: { |
| static const OUString sTriangle = CREATE_OUSTRING( "isosceles-triangle" ); |
| sType = sTriangle; |
| } break; |
| case XML_rtTriangle: { |
| static const OUString sRtTriangle = CREATE_OUSTRING( "right-triangle" ); |
| sType = sRtTriangle; |
| } break; |
| case XML_rect: { |
| static const OUString sRectangle = CREATE_OUSTRING( "rectangle" ); |
| sType = sRectangle; |
| } break; |
| case XML_diamond: { |
| static const OUString sDiamond = CREATE_OUSTRING( "diamond" ); |
| sType = sDiamond; |
| } break; |
| case XML_parallelogram: { |
| static const OUString sParallelogram = CREATE_OUSTRING( "parallelogram" ); |
| sType = sParallelogram; |
| } break; |
| case XML_nonIsoscelesTrapezoid: // TODO |
| case XML_trapezoid: { |
| static const OUString sTrapezoid = CREATE_OUSTRING( "trapezoid" ); |
| sType = sTrapezoid; |
| } break; |
| case XML_pentagon: { |
| static const OUString sPentagon = CREATE_OUSTRING( "pentagon" ); |
| sType = sPentagon; |
| } break; |
| case XML_heptagon: // TODO |
| case XML_hexagon: { |
| static const OUString sHexagon = CREATE_OUSTRING( "hexagon" ); |
| sType = sHexagon; |
| } break; |
| case XML_decagon: // TODO |
| case XML_dodecagon: // TODO |
| case XML_octagon: { |
| static const OUString sOctagon = CREATE_OUSTRING( "octagon" ); |
| sType = sOctagon; |
| } break; |
| case XML_star4: { |
| static const OUString sStar4 = CREATE_OUSTRING( "star4" ); |
| sType = sStar4; |
| } break; |
| case XML_star6: // TODO |
| case XML_star7: // TODO |
| case XML_star5: { |
| static const OUString sStar5 = CREATE_OUSTRING( "star5" ); |
| sType = sStar5; |
| } break; |
| case XML_star10: // TODO |
| case XML_star12: // TODO |
| case XML_star16: // TODO |
| case XML_star8: { |
| static const OUString sStar8 = CREATE_OUSTRING( "star8" ); |
| sType = sStar8; |
| } break; |
| case XML_star32: // TODO |
| case XML_star24: { |
| static const OUString sStar24 = CREATE_OUSTRING( "star24" ); |
| sType = sStar24; |
| } break; |
| case XML_round1Rect: // TODO |
| case XML_round2SameRect: // TODO |
| case XML_round2DiagRect: // TODO |
| case XML_snipRoundRect: // TODO |
| case XML_snip1Rect: // TODO |
| case XML_snip2SameRect: // TODO |
| case XML_snip2DiagRect: // TODO |
| case XML_roundRect: { |
| static const OUString sRoundRect = CREATE_OUSTRING( "round-rectangle" ); |
| sType = sRoundRect; |
| } break; |
| case XML_plaque: { |
| static const OUString sPlaque = CREATE_OUSTRING( "mso-spt21" ); |
| sType = sPlaque; |
| } break; |
| case XML_teardrop:{ |
| static const OUString sTearDrop = CREATE_OUSTRING( "teardrop" ); |
| sType = sTearDrop; |
| } break; |
| case XML_ellipse: { |
| static const OUString sEllipse = CREATE_OUSTRING( "ellipse" ); |
| sType = sEllipse; |
| } break; |
| case XML_homePlate: { |
| static const OUString sHomePlate = CREATE_OUSTRING( "pentagon-right" ); |
| sType = sHomePlate; |
| } break; |
| case XML_chevron: { |
| static const OUString sChevron = CREATE_OUSTRING( "chevron" ); |
| sType = sChevron; |
| } break; |
| case XML_pieWedge: // TODO |
| case XML_pie: // TODO |
| case XML_blockArc: { |
| static const OUString sBlockArc = CREATE_OUSTRING( "block-arc" ); |
| sType = sBlockArc; |
| } break; |
| case XML_donut: { |
| static const OUString sDonut = CREATE_OUSTRING( "ring" ); |
| sType = sDonut; |
| } break; |
| case XML_noSmoking: { |
| static const OUString sNoSmoking = CREATE_OUSTRING( "forbidden" ); |
| sType = sNoSmoking; |
| } break; |
| case XML_rightArrow: { |
| static const OUString sRightArrow = CREATE_OUSTRING( "right-arrow" ); |
| sType = sRightArrow; |
| } break; |
| case XML_leftArrow: { |
| static const OUString sLeftArrow = CREATE_OUSTRING( "left-arrow" ); |
| sType = sLeftArrow; |
| } break; |
| case XML_upArrow: { |
| static const OUString sUpArrow = CREATE_OUSTRING( "up-arrow" ); |
| sType = sUpArrow; |
| } break; |
| case XML_downArrow: { |
| static const OUString sDownArrow = CREATE_OUSTRING( "down-arrow" ); |
| sType = sDownArrow; |
| } break; |
| case XML_stripedRightArrow: { |
| static const OUString sStripedRightArrow = CREATE_OUSTRING( "striped-right-arrow" ); |
| sType = sStripedRightArrow; |
| } break; |
| case XML_notchedRightArrow: { |
| static const OUString sNotchedRightArrow = CREATE_OUSTRING( "notched-right-arrow" ); |
| sType = sNotchedRightArrow; |
| } break; |
| case XML_bentUpArrow: { |
| static const OUString sBentUpArrow = CREATE_OUSTRING( "mso-spt90" ); |
| sType = sBentUpArrow; |
| } break; |
| case XML_leftRightArrow: { |
| static const OUString sLeftRightArrow = CREATE_OUSTRING( "left-right-arrow" ); |
| sType = sLeftRightArrow; |
| } break; |
| case XML_upDownArrow: { |
| static const OUString sUpDownArrow = CREATE_OUSTRING( "up-down-arrow" ); |
| sType = sUpDownArrow; |
| } break; |
| case XML_leftUpArrow: { |
| static const OUString sLeftUpArrow = CREATE_OUSTRING( "mso-spt89" ); |
| sType = sLeftUpArrow; |
| } break; |
| case XML_leftRightUpArrow: { |
| static const OUString sLeftRightUpArrow = CREATE_OUSTRING( "mso-spt182" ); |
| sType = sLeftRightUpArrow; |
| } break; |
| case XML_quadArrow: { |
| static const OUString sQuadArrow = CREATE_OUSTRING( "quad-arrow" ); |
| sType = sQuadArrow; |
| } break; |
| case XML_leftArrowCallout: { |
| static const OUString sLeftArrowCallout = CREATE_OUSTRING( "left-arrow-callout" ); |
| sType = sLeftArrowCallout; |
| } break; |
| case XML_rightArrowCallout: { |
| static const OUString sRightArrowCallout = CREATE_OUSTRING( "right-arrow-callout" ); |
| sType = sRightArrowCallout; |
| } break; |
| case XML_upArrowCallout: { |
| static const OUString sUpArrowCallout = CREATE_OUSTRING( "up-arrow-callout" ); |
| sType = sUpArrowCallout; |
| } break; |
| case XML_downArrowCallout: { |
| static const OUString sDownArrowCallout = CREATE_OUSTRING( "down-arrow-callout" ); |
| sType = sDownArrowCallout; |
| } break; |
| case XML_leftRightArrowCallout: { |
| static const OUString sLeftRightArrowCallout = CREATE_OUSTRING( "left-right-arrow-callout" ); |
| sType = sLeftRightArrowCallout; |
| } break; |
| case XML_upDownArrowCallout: { |
| static const OUString sUpDownArrowCallout = CREATE_OUSTRING( "up-down-arrow-callout" ); |
| sType = sUpDownArrowCallout; |
| } break; |
| case XML_quadArrowCallout: { |
| static const OUString sQuadArrowCallout = CREATE_OUSTRING( "quad-arrow-callout" ); |
| sType = sQuadArrowCallout; |
| } break; |
| case XML_bentArrow: { |
| static const OUString sBentArrow = CREATE_OUSTRING( "mso-spt91" ); |
| sType = sBentArrow; |
| } break; |
| case XML_uturnArrow: { |
| static const OUString sUTurnArrow = CREATE_OUSTRING( "mso-spt101" ); |
| sType = sUTurnArrow; |
| } break; |
| case XML_leftCircularArrow: // TODO |
| case XML_leftRightCircularArrow: // TODO |
| case XML_circularArrow: { |
| static const OUString sCircularArrow = CREATE_OUSTRING( "circular-arrow" ); |
| sType = sCircularArrow; |
| } break; |
| case XML_curvedRightArrow: { |
| static const OUString sCurvedRightArrow = CREATE_OUSTRING( "mso-spt102" ); |
| sType = sCurvedRightArrow; |
| } break; |
| case XML_curvedLeftArrow: { |
| static const OUString sCurvedLeftArrow = CREATE_OUSTRING( "mso-spt103" ); |
| sType = sCurvedLeftArrow; |
| } break; |
| case XML_curvedUpArrow: { |
| static const OUString sCurvedUpArrow = CREATE_OUSTRING( "mso-spt104" ); |
| sType = sCurvedUpArrow; |
| } break; |
| case XML_swooshArrow: // TODO |
| case XML_curvedDownArrow: { |
| static const OUString sCurvedDownArrow = CREATE_OUSTRING( "mso-spt105" ); |
| sType = sCurvedDownArrow; |
| } break; |
| case XML_cube: { |
| static const OUString sCube = CREATE_OUSTRING( "cube" ); |
| sType = sCube; |
| } break; |
| case XML_can: { |
| static const OUString sCan = CREATE_OUSTRING( "can" ); |
| sType = sCan; |
| } break; |
| case XML_lightningBolt: { |
| static const OUString sLightningBolt = CREATE_OUSTRING( "lightning" ); |
| sType = sLightningBolt; |
| } break; |
| case XML_heart: { |
| static const OUString sHeart = CREATE_OUSTRING( "heart" ); |
| sType = sHeart; |
| } break; |
| case XML_sun: { |
| static const OUString sSun = CREATE_OUSTRING( "sun" ); |
| sType = sSun; |
| } break; |
| case XML_moon: { |
| static const OUString sMoon = CREATE_OUSTRING( "moon" ); |
| sType = sMoon; |
| } break; |
| case XML_smileyFace: { |
| static const OUString sSmileyFace = CREATE_OUSTRING( "smiley" ); |
| sType = sSmileyFace; |
| } break; |
| case XML_irregularSeal1: { |
| static const OUString sIrregularSeal1 = CREATE_OUSTRING( "mso-spt71" ); |
| sType = sIrregularSeal1; |
| } break; |
| case XML_irregularSeal2: { |
| static const OUString sIrregularSeal2 = CREATE_OUSTRING( "bang" ); |
| sType = sIrregularSeal2; |
| } break; |
| case XML_foldedCorner: { |
| static const OUString sFoldedCorner = CREATE_OUSTRING( "paper" ); |
| sType = sFoldedCorner; |
| } break; |
| case XML_bevel: { |
| static const OUString sBevel = CREATE_OUSTRING( "quad-bevel" ); |
| sType = sBevel; |
| } break; |
| case XML_halfFrame: // TODO |
| case XML_corner: // TODO |
| case XML_diagStripe: // TODO |
| case XML_chord: // TODO |
| case XML_frame: { |
| static const OUString sFrame = CREATE_OUSTRING( "mso-spt75" ); |
| sType = sFrame; |
| } break; |
| case XML_arc: { |
| static const OUString sArc = CREATE_OUSTRING( "mso-spt19" ); |
| sType = sArc; |
| } break; |
| case XML_leftBracket: { |
| static const OUString sLeftBracket = CREATE_OUSTRING( "left-bracket" ); |
| sType = sLeftBracket; |
| } break; |
| case XML_rightBracket: { |
| static const OUString sRightBracket = CREATE_OUSTRING( "right-bracket" ); |
| sType = sRightBracket; |
| } break; |
| case XML_leftBrace: { |
| static const OUString sLeftBrace = CREATE_OUSTRING( "left-brace" ); |
| sType = sLeftBrace; |
| } break; |
| case XML_rightBrace: { |
| static const OUString sRightBrace = CREATE_OUSTRING( "right-brace" ); |
| sType = sRightBrace; |
| } break; |
| case XML_bracketPair: { |
| static const OUString sBracketPair = CREATE_OUSTRING( "bracket-pair" ); |
| sType = sBracketPair; |
| } break; |
| case XML_bracePair: { |
| static const OUString sBracePair = CREATE_OUSTRING( "brace-pair" ); |
| sType = sBracePair; |
| } break; |
| case XML_straightConnector1: { |
| static const OUString sStraightConnector1 = CREATE_OUSTRING( "mso-spt32" ); |
| sType = sStraightConnector1; |
| } break; |
| case XML_bentConnector2: { |
| static const OUString sBentConnector2 = CREATE_OUSTRING( "mso-spt33" ); |
| sType = sBentConnector2; |
| } break; |
| case XML_bentConnector3: { |
| static const OUString sBentConnector3 = CREATE_OUSTRING( "mso-spt34" ); |
| sType = sBentConnector3; |
| } break; |
| case XML_bentConnector4: { |
| static const OUString sBentConnector4 = CREATE_OUSTRING( "mso-spt35" ); |
| sType = sBentConnector4; |
| } break; |
| case XML_bentConnector5: { |
| static const OUString sBentConnector5 = CREATE_OUSTRING( "mso-spt36" ); |
| sType = sBentConnector5; |
| } break; |
| case XML_curvedConnector2: { |
| static const OUString sCurvedConnector2 = CREATE_OUSTRING( "mso-spt37" ); |
| sType = sCurvedConnector2; |
| } break; |
| case XML_curvedConnector3: { |
| static const OUString sCurvedConnector3 = CREATE_OUSTRING( "mso-spt38" ); |
| sType = sCurvedConnector3; |
| } break; |
| case XML_curvedConnector4: { |
| static const OUString sCurvedConnector4 = CREATE_OUSTRING( "mso-spt39" ); |
| sType = sCurvedConnector4; |
| } break; |
| case XML_curvedConnector5: { |
| static const OUString sCurvedConnector5 = CREATE_OUSTRING( "mso-spt40" ); |
| sType = sCurvedConnector5; |
| } break; |
| case XML_callout1: { |
| static const OUString sCallout1 = CREATE_OUSTRING( "mso-spt41" ); |
| sType = sCallout1; |
| } break; |
| case XML_callout2: { |
| static const OUString sCallout2 = CREATE_OUSTRING( "mso-spt42" ); |
| sType = sCallout2; |
| } break; |
| case XML_callout3: { |
| static const OUString sCallout3 = CREATE_OUSTRING( "mso-spt43" ); |
| sType = sCallout3; |
| } break; |
| case XML_accentCallout1: { |
| static const OUString sAccentCallout1 = CREATE_OUSTRING( "mso-spt44" ); |
| sType = sAccentCallout1; |
| } break; |
| case XML_accentCallout2: { |
| static const OUString sAccentCallout2 = CREATE_OUSTRING( "mso-spt45" ); |
| sType = sAccentCallout2; |
| } break; |
| case XML_accentCallout3: { |
| static const OUString sAccentCallout3 = CREATE_OUSTRING( "mso-spt46" ); |
| sType = sAccentCallout3; |
| } break; |
| case XML_borderCallout1: { |
| static const OUString sBorderCallout1 = CREATE_OUSTRING( "line-callout-1" ); |
| sType = sBorderCallout1; |
| } break; |
| case XML_borderCallout2: { |
| static const OUString sBorderCallout2 = CREATE_OUSTRING( "line-callout-2" ); |
| sType = sBorderCallout2; |
| } break; |
| case XML_borderCallout3: { |
| static const OUString sBorderCallout3 = CREATE_OUSTRING( "mso-spt49" ); |
| sType = sBorderCallout3; |
| } break; |
| case XML_accentBorderCallout1: { |
| static const OUString sAccentBorderCallout1 = CREATE_OUSTRING( "mso-spt50" ); |
| sType = sAccentBorderCallout1; |
| } break; |
| case XML_accentBorderCallout2: { |
| static const OUString sAccentBorderCallout2 = CREATE_OUSTRING( "mso-spt51" ); |
| sType = sAccentBorderCallout2; |
| } break; |
| case XML_accentBorderCallout3: { |
| static const OUString sAccentBorderCallout3 = CREATE_OUSTRING( "mso-spt52" ); |
| sType = sAccentBorderCallout3; |
| } break; |
| case XML_wedgeRectCallout: { |
| static const OUString sWedgeRectCallout = CREATE_OUSTRING( "rectangular-callout" ); |
| sType = sWedgeRectCallout; |
| } break; |
| case XML_wedgeRoundRectCallout: { |
| static const OUString sWedgeRoundRectCallout = CREATE_OUSTRING( "round-rectangular-callout" ); |
| sType = sWedgeRoundRectCallout; |
| } break; |
| case XML_wedgeEllipseCallout: { |
| static const OUString sWedgeEllipseCallout = CREATE_OUSTRING( "round-callout" ); |
| sType = sWedgeEllipseCallout; |
| } break; |
| case XML_cloud: // TODO |
| case XML_cloudCallout: { |
| static const OUString sCloudCallout = CREATE_OUSTRING( "cloud-callout" ); |
| sType = sCloudCallout; |
| } break; |
| case XML_ribbon: { |
| static const OUString sRibbon = CREATE_OUSTRING( "mso-spt53" ); |
| sType = sRibbon; |
| } break; |
| case XML_ribbon2: { |
| static const OUString sRibbon2 = CREATE_OUSTRING( "mso-spt54" ); |
| sType = sRibbon2; |
| } break; |
| case XML_ellipseRibbon: { |
| static const OUString sEllipseRibbon = CREATE_OUSTRING( "mso-spt107" ); |
| sType = sEllipseRibbon; |
| } break; |
| case XML_leftRightRibbon: // TODO |
| case XML_ellipseRibbon2: { |
| static const OUString sEllipseRibbon2 = CREATE_OUSTRING( "mso-spt108" ); |
| sType = sEllipseRibbon2; |
| } break; |
| case XML_verticalScroll: { |
| static const OUString sVerticalScroll = CREATE_OUSTRING( "vertical-scroll" ); |
| sType = sVerticalScroll; |
| } break; |
| case XML_horizontalScroll: { |
| static const OUString sHorizontalScroll = CREATE_OUSTRING( "horizontal-scroll" ); |
| sType = sHorizontalScroll; |
| } break; |
| case XML_wave: { |
| static const OUString sWave = CREATE_OUSTRING( "mso-spt64" ); |
| sType = sWave; |
| } break; |
| case XML_doubleWave: { |
| static const OUString sDoubleWave = CREATE_OUSTRING( "mso-spt188" ); |
| sType = sDoubleWave; |
| } break; |
| case XML_plus: { |
| static const OUString sPlus = CREATE_OUSTRING( "cross" ); |
| sType = sPlus; |
| } break; |
| case XML_flowChartProcess: { |
| static const OUString sFlowChartProcess = CREATE_OUSTRING( "flowchart-process" ); |
| sType = sFlowChartProcess; |
| } break; |
| case XML_flowChartDecision: { |
| static const OUString sFlowChartDecision = CREATE_OUSTRING( "flowchart-decision" ); |
| sType = sFlowChartDecision; |
| } break; |
| case XML_flowChartInputOutput: { |
| static const OUString sFlowChartInputOutput = CREATE_OUSTRING( "flowchart-data" ); |
| sType = sFlowChartInputOutput; |
| } break; |
| case XML_flowChartPredefinedProcess: { |
| static const OUString sFlowChartPredefinedProcess = CREATE_OUSTRING( "flowchart-predefined-process" ); |
| sType = sFlowChartPredefinedProcess; |
| } break; |
| case XML_flowChartInternalStorage: { |
| static const OUString sFlowChartInternalStorage = CREATE_OUSTRING( "flowchart-internal-storage" ); |
| sType = sFlowChartInternalStorage; |
| } break; |
| case XML_flowChartDocument: { |
| static const OUString sFlowChartDocument = CREATE_OUSTRING( "flowchart-document" ); |
| sType = sFlowChartDocument; |
| } break; |
| case XML_flowChartMultidocument: { |
| static const OUString sFlowChartMultidocument = CREATE_OUSTRING( "flowchart-multidocument" ); |
| sType = sFlowChartMultidocument; |
| } break; |
| case XML_flowChartTerminator: { |
| static const OUString sFlowChartTerminator = CREATE_OUSTRING( "flowchart-terminator" ); |
| sType = sFlowChartTerminator; |
| } break; |
| case XML_flowChartPreparation : { |
| static const OUString sFlowChartPreparation = CREATE_OUSTRING( "flowchart-preparation" ); |
| sType = sFlowChartPreparation; |
| } break; |
| case XML_flowChartManualInput: { |
| static const OUString sFlowChartManualInput = CREATE_OUSTRING( "flowchart-manual-input" ); |
| sType = sFlowChartManualInput; |
| } break; |
| case XML_flowChartManualOperation: { |
| static const OUString sFlowChartManualOperation = CREATE_OUSTRING( "flowchart-manual-operation" ); |
| sType = sFlowChartManualOperation; |
| } break; |
| case XML_flowChartConnector: { |
| static const OUString sFlowChartConnector = CREATE_OUSTRING( "flowchart-connector" ); |
| sType = sFlowChartConnector; |
| } break; |
| case XML_flowChartPunchedCard: { |
| static const OUString sFlowChartPunchedCard = CREATE_OUSTRING( "flowchart-card" ); |
| sType = sFlowChartPunchedCard; |
| } break; |
| case XML_flowChartPunchedTape: { |
| static const OUString sFlowChartPunchedTape = CREATE_OUSTRING( "flowchart-punched-tape" ); |
| sType = sFlowChartPunchedTape; |
| } break; |
| case XML_flowChartSummingJunction: { |
| static const OUString sFlowChartSummingJunction = CREATE_OUSTRING( "flowchart-summing-junction" ); |
| sType = sFlowChartSummingJunction; |
| } break; |
| case XML_flowChartOr: { |
| static const OUString sFlowChartOr = CREATE_OUSTRING( "flowchart-or" ); |
| sType = sFlowChartOr; |
| } break; |
| case XML_flowChartCollate: { |
| static const OUString sFlowChartCollate = CREATE_OUSTRING( "flowchart-collate" ); |
| sType = sFlowChartCollate; |
| } break; |
| case XML_flowChartSort: { |
| static const OUString sFlowChartSort = CREATE_OUSTRING( "flowchart-sort" ); |
| sType = sFlowChartSort; |
| } break; |
| case XML_flowChartExtract: { |
| static const OUString sFlowChartExtract = CREATE_OUSTRING( "flowchart-extract" ); |
| sType = sFlowChartExtract; |
| } break; |
| case XML_flowChartMerge: { |
| static const OUString sFlowChartMerge = CREATE_OUSTRING( "flowchart-merge" ); |
| sType = sFlowChartMerge; |
| } break; |
| case XML_flowChartOfflineStorage: { |
| static const OUString sFlowChartOfflineStorage = CREATE_OUSTRING( "mso-spt129" ); |
| sType = sFlowChartOfflineStorage; |
| } break; |
| case XML_flowChartOnlineStorage: { |
| static const OUString sFlowChartOnlineStorage = CREATE_OUSTRING( "flowchart-stored-data" ); |
| sType = sFlowChartOnlineStorage; |
| } break; |
| case XML_flowChartMagneticTape: { |
| static const OUString sFlowChartMagneticTape = CREATE_OUSTRING( "flowchart-sequential-access" ); |
| sType = sFlowChartMagneticTape; |
| } break; |
| case XML_flowChartMagneticDisk: { |
| static const OUString sFlowChartMagneticDisk = CREATE_OUSTRING( "flowchart-magnetic-disk" ); |
| sType = sFlowChartMagneticDisk; |
| } break; |
| case XML_flowChartMagneticDrum: { |
| static const OUString sFlowChartMagneticDrum = CREATE_OUSTRING( "flowchart-direct-access-storage" ); |
| sType = sFlowChartMagneticDrum; |
| } break; |
| case XML_flowChartDisplay: { |
| static const OUString sFlowChartDisplay = CREATE_OUSTRING( "flowchart-display" ); |
| sType = sFlowChartDisplay; |
| } break; |
| case XML_flowChartDelay: { |
| static const OUString sFlowChartDelay = CREATE_OUSTRING( "flowchart-delay" ); |
| sType = sFlowChartDelay; |
| } break; |
| case XML_flowChartAlternateProcess: { |
| static const OUString sFlowChartAlternateProcess = CREATE_OUSTRING( "flowchart-alternate-process" ); |
| sType = sFlowChartAlternateProcess; |
| } break; |
| case XML_flowChartOffpageConnector: { |
| static const OUString sFlowChartOffpageConnector = CREATE_OUSTRING( "flowchart-off-page-connector" ); |
| sType = sFlowChartOffpageConnector; |
| } break; |
| case XML_actionButtonBlank: { |
| static const OUString sActionButtonBlank = CREATE_OUSTRING( "mso-spt189" ); |
| sType = sActionButtonBlank; |
| } break; |
| case XML_actionButtonHome: { |
| static const OUString sActionButtonHome = CREATE_OUSTRING( "mso-spt190" ); |
| sType = sActionButtonHome; |
| } break; |
| case XML_actionButtonHelp: { |
| static const OUString sActionButtonHelp = CREATE_OUSTRING( "mso-spt191" ); |
| sType = sActionButtonHelp; |
| } break; |
| case XML_actionButtonInformation: { |
| static const OUString sActionButtonInformation = CREATE_OUSTRING( "mso-spt192" ); |
| sType = sActionButtonInformation; |
| } break; |
| case XML_actionButtonForwardNext: { |
| static const OUString sActionButtonForwardNext = CREATE_OUSTRING( "mso-spt193" ); |
| sType = sActionButtonForwardNext; |
| } break; |
| case XML_actionButtonBackPrevious: { |
| static const OUString sActionButtonBackPrevious = CREATE_OUSTRING( "mso-spt194" ); |
| sType = sActionButtonBackPrevious; |
| } break; |
| case XML_actionButtonEnd: { |
| static const OUString sActionButtonEnd = CREATE_OUSTRING( "mso-spt195" ); |
| sType = sActionButtonEnd; |
| } break; |
| case XML_actionButtonBeginning: { |
| static const OUString sActionButtonBeginning = CREATE_OUSTRING( "mso-spt196" ); |
| sType = sActionButtonBeginning; |
| } break; |
| case XML_actionButtonReturn: { |
| static const OUString sActionButtonReturn = CREATE_OUSTRING( "mso-spt197" ); |
| sType = sActionButtonReturn; |
| } break; |
| case XML_actionButtonDocument: { |
| static const OUString sActionButtonDocument = CREATE_OUSTRING( "mso-spt198" ); |
| sType = sActionButtonDocument; |
| } break; |
| case XML_actionButtonSound: { |
| static const OUString sActionButtonSound = CREATE_OUSTRING( "mso-spt199" ); |
| sType = sActionButtonSound; |
| } break; |
| case XML_actionButtonMovie: { |
| static const OUString sActionButtonMovie = CREATE_OUSTRING( "mso-spt200" ); |
| sType = sActionButtonMovie; |
| } break; |
| case XML_gear6: // TODO |
| case XML_gear9: // TODO |
| case XML_funnel: // TODO |
| case XML_mathPlus: // TODO |
| case XML_mathMinus: // TODO |
| case XML_mathMultiply: // TODO |
| case XML_mathDivide: // TODO |
| case XML_mathEqual: // TODO |
| case XML_mathNotEqual: // TODO |
| case XML_cornerTabs: // TODO |
| case XML_squareTabs: // TODO |
| case XML_plaqueTabs: // TODO |
| case XML_chartX: // TODO |
| case XML_chartStar: // TODO |
| case XML_chartPlus: { // TODO |
| static const OUString sRectangle = CREATE_OUSTRING( "rectangle" ); |
| sType = sRectangle; |
| } break; |
| default: |
| break; |
| } |
| return sType; |
| } |
| |
| static OUString GetTextShapeType( sal_Int32 nType ) |
| { |
| OUString sType; |
| switch( nType ) |
| { |
| case XML_textNoShape: // TODO |
| case XML_textPlain: { |
| static const OUString sTextPlain = CREATE_OUSTRING( "fontwork-plain-text" ); |
| sType = sTextPlain; |
| } break; |
| case XML_textStop: { |
| static const OUString sTextStop = CREATE_OUSTRING( "fontwork-stop" ); |
| sType = sTextStop; |
| } break; |
| case XML_textTriangle: { |
| static const OUString sTextTriangle = CREATE_OUSTRING( "fontwork-triangle-up" ); |
| sType = sTextTriangle; |
| } break; |
| case XML_textTriangleInverted: { |
| static const OUString sTextTriangleInverted = CREATE_OUSTRING( "fontwork-triangle-down" ); |
| sType = sTextTriangleInverted; |
| } break; |
| case XML_textChevron: { |
| static const OUString sTextChevron = CREATE_OUSTRING( "fontwork-chevron-up" ); |
| sType = sTextChevron; |
| } break; |
| case XML_textChevronInverted: { |
| static const OUString sTextChevronInverted = CREATE_OUSTRING( "fontwork-chevron-down" ); |
| sType = sTextChevronInverted; |
| } break; |
| case XML_textRingInside: { |
| static const OUString sTextRingInside = CREATE_OUSTRING( "mso-spt142" ); |
| sType = sTextRingInside; |
| } break; |
| case XML_textRingOutside: { |
| static const OUString sTextRingOutside = CREATE_OUSTRING( "mso-spt143" ); |
| sType = sTextRingOutside; |
| } break; |
| case XML_textArchUp: { |
| static const OUString sTextArchUp = CREATE_OUSTRING( "fontwork-arch-up-curve" ); |
| sType = sTextArchUp; |
| } break; |
| case XML_textArchDown: { |
| static const OUString sTextArchDown = CREATE_OUSTRING( "fontwork-arch-down-curve" ); |
| sType = sTextArchDown; |
| } break; |
| case XML_textCircle: { |
| static const OUString sTextCircle = CREATE_OUSTRING( "fontwork-circle-curve" ); |
| sType = sTextCircle; |
| } break; |
| case XML_textButton: { |
| static const OUString sTextButton = CREATE_OUSTRING( "fontwork-open-circle-curve" ); |
| sType = sTextButton; |
| } break; |
| case XML_textArchUpPour: { |
| static const OUString sTextArchUpPour = CREATE_OUSTRING( "fontwork-arch-up-pour" ); |
| sType = sTextArchUpPour; |
| } break; |
| case XML_textArchDownPour: { |
| static const OUString sTextArchDownPour = CREATE_OUSTRING( "fontwork-arch-down-pour" ); |
| sType = sTextArchDownPour; |
| } break; |
| case XML_textCirclePour: { |
| static const OUString sTextCirclePour = CREATE_OUSTRING( "fontwork-circle-pour" ); |
| sType = sTextCirclePour; |
| } break; |
| case XML_textButtonPour: { |
| static const OUString sTextButtonPour = CREATE_OUSTRING( "fontwork-open-circle-pour" ); |
| sType = sTextButtonPour; |
| } break; |
| case XML_textCurveUp: { |
| static const OUString sTextCurveUp = CREATE_OUSTRING( "fontwork-curve-up" ); |
| sType = sTextCurveUp; |
| } break; |
| case XML_textCurveDown: { |
| static const OUString sTextCurveDown = CREATE_OUSTRING( "fontwork-curve-down" ); |
| sType = sTextCurveDown; |
| } break; |
| case XML_textCanUp: { |
| static const OUString sTextCanUp = CREATE_OUSTRING( "mso-spt174" ); |
| sType = sTextCanUp; |
| } break; |
| case XML_textCanDown: { |
| static const OUString sTextCanDown = CREATE_OUSTRING( "mso-spt175" ); |
| sType = sTextCanDown; |
| } break; |
| case XML_textWave1: { |
| static const OUString sTextWave1 = CREATE_OUSTRING( "fontwork-wave" ); |
| sType = sTextWave1; |
| } break; |
| case XML_textWave2: { |
| static const OUString sTextWave2 = CREATE_OUSTRING( "mso-spt157" ); |
| sType = sTextWave2; |
| } break; |
| case XML_textDoubleWave1: { |
| static const OUString sTextDoubleWave1 = CREATE_OUSTRING( "mso-spt158" ); |
| sType = sTextDoubleWave1; |
| } break; |
| case XML_textWave4: { |
| static const OUString sTextWave4 = CREATE_OUSTRING( "mso-spt159" ); |
| sType = sTextWave4; |
| } break; |
| case XML_textInflate: { |
| static const OUString sTextInflate = CREATE_OUSTRING( "fontwork-inflate" ); |
| sType = sTextInflate; |
| } break; |
| case XML_textDeflate: { |
| static const OUString sTextDeflate = CREATE_OUSTRING( "mso-spt161" ); |
| sType = sTextDeflate; |
| } break; |
| case XML_textInflateBottom: { |
| static const OUString sTextInflateBottom = CREATE_OUSTRING( "mso-spt162" ); |
| sType = sTextInflateBottom; |
| } break; |
| case XML_textDeflateBottom: { |
| static const OUString sTextDeflateBottom = CREATE_OUSTRING( "mso-spt163" ); |
| sType = sTextDeflateBottom; |
| } break; |
| case XML_textInflateTop: { |
| static const OUString sTextInflateTop = CREATE_OUSTRING( "mso-spt164" ); |
| sType = sTextInflateTop; |
| } break; |
| case XML_textDeflateTop: { |
| static const OUString sTextDeflateTop = CREATE_OUSTRING( "mso-spt165" ); |
| sType = sTextDeflateTop; |
| } break; |
| case XML_textDeflateInflate: { |
| static const OUString sTextDeflateInflate = CREATE_OUSTRING( "mso-spt166" ); |
| sType = sTextDeflateInflate; |
| } break; |
| case XML_textDeflateInflateDeflate: { |
| static const OUString sTextDeflateInflateDeflate = CREATE_OUSTRING( "mso-spt167" ); |
| sType = sTextDeflateInflateDeflate; |
| } break; |
| case XML_textFadeRight: { |
| static const OUString sTextFadeRight = CREATE_OUSTRING( "fontwork-fade-right" ); |
| sType = sTextFadeRight; |
| } break; |
| case XML_textFadeLeft: { |
| static const OUString sTextFadeLeft = CREATE_OUSTRING( "fontwork-fade-left" ); |
| sType = sTextFadeLeft; |
| } break; |
| case XML_textFadeUp: { |
| static const OUString sTextFadeUp = CREATE_OUSTRING( "fontwork-fade-up" ); |
| sType = sTextFadeUp; |
| } break; |
| case XML_textFadeDown: { |
| static const OUString sTextFadeDown = CREATE_OUSTRING( "fontwork-fade-down" ); |
| sType = sTextFadeDown; |
| } break; |
| case XML_textSlantUp: { |
| static const OUString sTextSlantUp = CREATE_OUSTRING( "fontwork-slant-up" ); |
| sType = sTextSlantUp; |
| } break; |
| case XML_textSlantDown: { |
| static const OUString sTextSlantDown = CREATE_OUSTRING( "fontwork-slant-down" ); |
| sType = sTextSlantDown; |
| } break; |
| case XML_textCascadeUp: { |
| static const OUString sTextCascadeUp = CREATE_OUSTRING( "fontwork-fade-up-and-right" ); |
| sType = sTextCascadeUp; |
| } break; |
| case XML_textCascadeDown: { |
| static const OUString sTextCascadeDown = CREATE_OUSTRING( "fontwork-fade-up-and-left" ); |
| sType = sTextCascadeDown; |
| } break; |
| default: |
| break; |
| } |
| return sType; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_CustomGeometry2D |
| CustomShapeGeometryContext::CustomShapeGeometryContext( ContextHandler& rParent, const Reference< XFastAttributeList >& /* xAttribs */, CustomShapeProperties& rCustomShapeProperties ) |
| : ContextHandler( rParent ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| } |
| |
| Reference< XFastContextHandler > CustomShapeGeometryContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& xAttribs ) throw (SAXException, RuntimeException) |
| { |
| Reference< XFastContextHandler > xContext; |
| switch( aElementToken ) |
| { |
| case A_TOKEN( avLst ): // CT_GeomGuideList adjust value list |
| xContext = new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustmentGuideList() ); |
| break; |
| case A_TOKEN( gdLst ): // CT_GeomGuideList guide list |
| xContext = new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getGuideList() ); |
| break; |
| case A_TOKEN( ahLst ): // CT_AdjustHandleList adjust handle list |
| xContext = new AdjustHandleListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustHandleList() ); |
| break; |
| case A_TOKEN( cxnLst ): // CT_ConnectionSiteList connection site list |
| xContext = this; |
| break; |
| case A_TOKEN( rect ): // CT_GeomRectList geometry rect list |
| { |
| GeomRect aGeomRect; |
| aGeomRect.l = GetAdjCoordinate( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_l ), sal_True ); |
| aGeomRect.t = GetAdjCoordinate( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_t ), sal_True ); |
| aGeomRect.r = GetAdjCoordinate( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_r ), sal_True ); |
| aGeomRect.b = GetAdjCoordinate( mrCustomShapeProperties, xAttribs->getOptionalValue( XML_b ), sal_True ); |
| mrCustomShapeProperties.getTextRect() = aGeomRect; |
| } |
| break; |
| case A_TOKEN( pathLst ): // CT_Path2DList 2d path list |
| xContext = new Path2DListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getSegments(), mrCustomShapeProperties.getPath2DList() ); |
| break; |
| |
| // from cxnLst: |
| case A_TOKEN( cxn ): // CT_ConnectionSite |
| { |
| ConnectionSite aConnectionSite; |
| mrCustomShapeProperties.getConnectionSiteList().push_back( aConnectionSite ); |
| xContext = new ConnectionSiteContext( *this, xAttribs, mrCustomShapeProperties, mrCustomShapeProperties.getConnectionSiteList().back() ); |
| } |
| break; |
| } |
| return xContext; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_PresetGeometry2D |
| PresetShapeGeometryContext::PresetShapeGeometryContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties ) |
| : ContextHandler( rParent ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| OUString sShapeType; |
| sal_Int32 nShapeType = xAttribs->getOptionalValueToken( XML_prst, FastToken::DONTKNOW ); |
| if ( nShapeType != FastToken::DONTKNOW ) |
| sShapeType = GetShapeType( nShapeType ); |
| OSL_ENSURE( sShapeType.getLength(), "oox::drawingml::CustomShapeCustomGeometryContext::CustomShapeCustomGeometryContext(), unknown shape type" ); |
| mrCustomShapeProperties.setShapePresetType( sShapeType ); |
| } |
| |
| Reference< XFastContextHandler > PresetShapeGeometryContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& ) throw (SAXException, RuntimeException) |
| { |
| if ( aElementToken == A_TOKEN( avLst ) ) |
| return new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustmentGuideList() ); |
| else |
| return this; |
| } |
| |
| // --------------------------------------------------------------------- |
| // CT_PresetTextShape |
| PresetTextShapeContext::PresetTextShapeContext( ContextHandler& rParent, const Reference< XFastAttributeList >& xAttribs, CustomShapeProperties& rCustomShapeProperties ) |
| : ContextHandler( rParent ) |
| , mrCustomShapeProperties( rCustomShapeProperties ) |
| { |
| OUString sShapeType; |
| sal_Int32 nShapeType = xAttribs->getOptionalValueToken( XML_prst, FastToken::DONTKNOW ); |
| if ( nShapeType != FastToken::DONTKNOW ) |
| sShapeType = GetTextShapeType( nShapeType ); |
| OSL_ENSURE( sShapeType.getLength(), "oox::drawingml::CustomShapeCustomGeometryContext::CustomShapeCustomGeometryContext(), unknown shape type" ); |
| mrCustomShapeProperties.setShapePresetType( sShapeType ); |
| } |
| |
| Reference< XFastContextHandler > PresetTextShapeContext::createFastChildContext( sal_Int32 aElementToken, const Reference< XFastAttributeList >& ) throw (SAXException, RuntimeException) |
| { |
| if ( aElementToken == A_TOKEN( avLst ) ) |
| return new GeomGuideListContext( *this, mrCustomShapeProperties, mrCustomShapeProperties.getAdjustmentGuideList() ); |
| else |
| return this; |
| } |
| |
| } } |
