1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_xmloff.hxx"
26 #include "ximpcustomshape.hxx"
27 #include "ximpshap.hxx"
28 #include "xmlehelp.hxx"
29 #include <rtl/math.hxx>
30 #include <rtl/ustrbuf.hxx>
31 #include <rtl/ustring.hxx>
32 #include <com/sun/star/uno/Reference.h>
33 #include <com/sun/star/beans/XPropertySet.hpp>
34 #include <com/sun/star/xml/sax/XAttributeList.hpp>
35 #include <com/sun/star/container/XIndexContainer.hpp>
36 #include <xmloff/xmltoken.hxx>
37 #include "EnhancedCustomShapeToken.hxx"
38 #include <xmloff/xmlimp.hxx>
39 #include <xmloff/xmltkmap.hxx>
40 #include "xmloff/xmlnmspe.hxx"
41 #include <xmloff/nmspmap.hxx>
42 #include <xmloff/xmluconv.hxx>
43 #include "xexptran.hxx"
44 #include "xmloff/xmlerror.hxx"
45 #include <tools/debug.hxx>
46 #include <com/sun/star/drawing/Direction3D.hpp>
47 #include <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
48 #include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
49 #include <com/sun/star/drawing/EnhancedCustomShapeTextFrame.hpp>
50 #include <com/sun/star/drawing/EnhancedCustomShapeAdjustmentValue.hpp>
51 #include <com/sun/star/drawing/EnhancedCustomShapeSegment.hpp>
52 #include <com/sun/star/drawing/EnhancedCustomShapeSegmentCommand.hpp>
53 #include <com/sun/star/drawing/EnhancedCustomShapeTextPathMode.hpp>
54 #include <com/sun/star/drawing/ProjectionMode.hpp>
55 #include <com/sun/star/drawing/HomogenMatrix3.hpp>
56 #include <basegfx/vector/b2dvector.hxx>
57 #include <hash_map>
58 
59 using namespace ::com::sun::star;
60 using namespace ::xmloff::token;
61 using namespace ::xmloff::EnhancedCustomShapeToken;
62 
63 TYPEINIT1( XMLEnhancedCustomShapeContext, SvXMLImportContext );
64 
65 XMLEnhancedCustomShapeContext::XMLEnhancedCustomShapeContext( SvXMLImport& rImport,
66 			::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >& rxShape,
67 				sal_uInt16 nPrefix, const rtl::OUString& rLocalName,
68 					std::vector< com::sun::star::beans::PropertyValue >& rCustomShapeGeometry ) :
69 		SvXMLImportContext( rImport, nPrefix, rLocalName ),
70 		mrUnitConverter( rImport.GetMM100UnitConverter() ),
71 		mrxShape( rxShape ),
72 		mrCustomShapeGeometry( rCustomShapeGeometry )
73 {
74 }
75 
76 const SvXMLEnumMapEntry aXML_GluePointEnumMap[] =
77 {
78 	{ XML_NONE,			0 },
79 	{ XML_SEGMENTS, 	1 },
80 	{ XML_NONE,			2 },
81 	{ XML_RECTANGLE,	3 },
82 	{ XML_TOKEN_INVALID, 0 }
83 };
84 void GetBool( std::vector< com::sun::star::beans::PropertyValue >& rDest,
85 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
86 {
87 	sal_Bool bAttrBool;
88 	if ( SvXMLUnitConverter::convertBool( bAttrBool, rValue ) )
89 	{
90 		beans::PropertyValue aProp;
91 		aProp.Name = EASGet( eDestProp );
92 		aProp.Value <<= bAttrBool;
93 		rDest.push_back( aProp );
94 	}
95 }
96 
97 void GetInt32( std::vector< com::sun::star::beans::PropertyValue >& rDest,
98 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
99 {
100 	sal_Int32 nAttrNumber;
101 	if ( SvXMLUnitConverter::convertNumber( nAttrNumber, rValue ) )
102 	{
103 		beans::PropertyValue aProp;
104 		aProp.Name = EASGet( eDestProp );
105 		aProp.Value <<= nAttrNumber;
106 		rDest.push_back( aProp );
107 	}
108 }
109 
110 void GetDouble( std::vector< com::sun::star::beans::PropertyValue >& rDest,
111 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
112 {
113 	double fAttrDouble;
114 	if ( SvXMLUnitConverter::convertDouble( fAttrDouble, rValue ) )
115 	{
116 		beans::PropertyValue aProp;
117 		aProp.Name = EASGet( eDestProp );
118 		aProp.Value <<= fAttrDouble;
119 		rDest.push_back( aProp );
120 	}
121 }
122 
123 void GetDistance( std::vector< com::sun::star::beans::PropertyValue >& rDest,
124 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
125 {
126 	double fAttrDouble;
127 	MapUnit eSrcUnit( SvXMLExportHelper::GetUnitFromString( rValue, MAP_100TH_MM ) );
128 	if ( SvXMLUnitConverter::convertDouble( fAttrDouble, rValue, eSrcUnit, MAP_100TH_MM ) )
129 	{
130 		beans::PropertyValue aProp;
131 		aProp.Name = EASGet( eDestProp );
132 		aProp.Value <<= fAttrDouble;
133 		rDest.push_back( aProp );
134 	}
135 }
136 
137 void GetString( std::vector< com::sun::star::beans::PropertyValue >& rDest,
138 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
139 {
140 	beans::PropertyValue aProp;
141 	aProp.Name = EASGet( eDestProp );
142 	aProp.Value <<= rValue;
143 	rDest.push_back( aProp );
144 }
145 
146 void GetEnum( std::vector< com::sun::star::beans::PropertyValue >& rDest,
147 			 			const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp,
148 						const SvXMLEnumMapEntry& rMap )
149 {
150 	sal_uInt16 eKind;
151 	if( SvXMLUnitConverter::convertEnum( eKind, rValue, &rMap ) )
152 	{
153 		sal_Int16 nEnum = (sal_Int16)eKind;
154 		beans::PropertyValue aProp;
155 		aProp.Name = EASGet( eDestProp );
156 		aProp.Value <<= nEnum;
157 		rDest.push_back( aProp );
158 	}
159 }
160 
161 void GetDoublePercentage( std::vector< com::sun::star::beans::PropertyValue >& rDest,
162 						 const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
163 {
164 	MapUnit eSrcUnit = SvXMLExportHelper::GetUnitFromString( rValue, MAP_100TH_MM );
165 	if ( eSrcUnit == MAP_RELATIVE )
166 	{
167 		rtl_math_ConversionStatus eStatus;
168 		double fAttrDouble = ::rtl::math::stringToDouble( rValue,
169 			(sal_Unicode)('.'), (sal_Unicode)(','), &eStatus, NULL );
170 		if ( eStatus == rtl_math_ConversionStatus_Ok )
171 		{
172 			beans::PropertyValue aProp;
173 			aProp.Name = EASGet( eDestProp );
174 			aProp.Value <<= fAttrDouble;
175 			rDest.push_back( aProp );
176 		}
177 	}
178 }
179 
180 void GetB3DVector( std::vector< com::sun::star::beans::PropertyValue >& rDest,
181 						 const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
182 {
183 	::basegfx::B3DVector aB3DVector;
184 	if ( SvXMLUnitConverter::convertB3DVector( aB3DVector, rValue ) )
185 	{
186 		drawing::Direction3D aDirection3D( aB3DVector.getX(), aB3DVector.getY(), aB3DVector.getZ() );
187 		beans::PropertyValue aProp;
188 		aProp.Name = EASGet( eDestProp );
189 		aProp.Value <<= aDirection3D;
190 		rDest.push_back( aProp );
191 	}
192 }
193 
194 sal_Bool GetEquationName( const rtl::OUString& rEquation, const sal_Int32 nStart, rtl::OUString& rEquationName )
195 {
196 	sal_Int32 nIndex = nStart;
197 	while( nIndex < rEquation.getLength() )
198 	{
199 		sal_Unicode nChar = rEquation[ nIndex ];
200 		if (
201 			( ( nChar >= 'a' ) && ( nChar <= 'z' ) )
202 			|| ( ( nChar >= 'A' ) && ( nChar <= 'Z' ) )
203 			|| ( ( nChar >= '0' ) && ( nChar <= '9' ) )
204 			)
205 		{
206 			nIndex++;
207 		}
208 		else
209 			break;
210 	}
211 	sal_Bool bValid = ( nIndex - nStart ) != 0;
212 	if ( bValid )
213 		rEquationName = rEquation.copy( nStart, nIndex - nStart );
214 	return bValid;
215 }
216 
217 sal_Bool GetNextParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rParameter, sal_Int32& nIndex, const rtl::OUString& rParaString )
218 {
219 	if ( nIndex >= rParaString.getLength() )
220 		return sal_False;
221 
222 	sal_Bool bValid = sal_True;
223 	sal_Bool bNumberRequired = sal_True;
224 	sal_Bool bMustBePositiveWholeNumbered = sal_False;
225 
226 	rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL;
227 	if ( rParaString[ nIndex ] == (sal_Unicode)'$' )
228 	{
229 		rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::ADJUSTMENT;
230 		bMustBePositiveWholeNumbered = sal_True;
231 		nIndex++;
232 	}
233 	else if ( rParaString[ nIndex ] == (sal_Unicode)'?' )
234 	{
235 		nIndex++;
236 		bNumberRequired = sal_False;
237 		rtl::OUString aEquationName;
238 		bValid = GetEquationName( rParaString, nIndex, aEquationName );
239 		if ( bValid )
240 		{
241 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION;
242 			rParameter.Value <<= aEquationName;
243 			nIndex += aEquationName.getLength();
244 		}
245 	}
246 	else if ( rParaString[ nIndex ] > (sal_Unicode)'9' )
247 	{
248 		bNumberRequired = sal_False;
249 		if ( rParaString.matchIgnoreAsciiCaseAsciiL( "left", 4, nIndex ) )
250 		{
251 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LEFT;
252 			nIndex += 4;
253 		}
254 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "top", 3, nIndex ) )
255 		{
256 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::TOP;
257 			nIndex += 3;
258 		}
259 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "right", 5, nIndex ) )
260 		{
261 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::RIGHT;
262 			nIndex += 5;
263 		}
264 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "bottom", 6, nIndex ) )
265 		{
266 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::BOTTOM;
267 			nIndex += 6;
268 		}
269 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "xstretch", 8, nIndex ) )
270 		{
271 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::XSTRETCH;
272 			nIndex += 8;
273 		}
274 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "ystretch", 8, nIndex ) )
275 		{
276 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::YSTRETCH;
277 			nIndex += 8;
278 		}
279 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "hasstroke", 9, nIndex ) )
280 		{
281 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HASSTROKE;
282 			nIndex += 9;
283 		}
284 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "hasfill", 7, nIndex ) )
285 		{
286 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HASFILL;
287 			nIndex += 7;
288 		}
289 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "width", 5, nIndex ) )
290 		{
291 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::WIDTH;
292 			nIndex += 5;
293 		}
294 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "height", 6, nIndex ) )
295 		{
296 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::HEIGHT;
297 			nIndex += 6;
298 		}
299 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "logwidth", 8, nIndex ) )
300 		{
301 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGWIDTH;
302 			nIndex += 8;
303 		}
304 		else if ( rParaString.matchIgnoreAsciiCaseAsciiL( "logheight", 9, nIndex ) )
305 		{
306 			rParameter.Type = com::sun::star::drawing::EnhancedCustomShapeParameterType::LOGHEIGHT;
307 			nIndex += 9;
308 		}
309 		else
310 			bValid = sal_False;
311 	}
312 	if ( bValid )
313 	{
314 		if ( bNumberRequired )
315 		{
316 			sal_Int32 nStartIndex = nIndex;
317 
318 			sal_Bool bM = sal_False;	// set if the value is negative
319 			sal_Bool bE = sal_False;	// set if a double is including a "E" statement
320 			sal_Bool bEM = sal_False;	// set if a double is including a "E-"statement
321 			sal_Bool bDot = sal_False;	// set if there is a dot included
322 			sal_Bool bEnd = sal_False;	// set for each value that can not be part of a double/integer
323 
324 			while( ( nIndex < rParaString.getLength() ) && bValid )
325 			{
326 				switch( rParaString[ nIndex ] )
327 				{
328 					case '.' :
329 					{
330 						if ( bMustBePositiveWholeNumbered )
331 							bValid = sal_False;
332 						else
333 						{
334 							if ( bDot )
335 								bValid = sal_False;
336 							else
337 								bDot = sal_True;
338 						}
339 					}
340 					break;
341 					case '-' :
342 					{
343 						if ( bMustBePositiveWholeNumbered )
344 							bValid = sal_False;
345 						else
346 						{
347 							if ( nStartIndex == nIndex )
348 								bM = sal_True;
349 							else if ( bE )
350 								bEM = sal_True;
351 							else
352 								bValid = sal_False;
353 						}
354 					}
355 					break;
356 
357 					case 'e' :
358 					case 'E' :
359 					{
360 						if ( bMustBePositiveWholeNumbered )
361 							bEnd = sal_True;
362 						else
363 						{
364 							if ( !bE )
365 								bE = sal_True;
366 							else
367 								bEnd = sal_True;
368 						}
369 					}
370 					break;
371 					case '0' :
372 					case '1' :
373 					case '2' :
374 					case '3' :
375 					case '4' :
376 					case '5' :
377 					case '6' :
378 					case '7' :
379 					case '8' :
380 					case '9' :
381 					break;
382 					default:
383 						bEnd = sal_True;
384 				}
385 				if ( !bEnd )
386 					nIndex++;
387 				else
388 					break;
389 			}
390 			if ( nIndex == nStartIndex )
391 				bValid = sal_False;
392 			if ( bValid )
393 			{
394 				rtl::OUString aNumber( rParaString.copy( nStartIndex, nIndex - nStartIndex ) );
395 				if ( bE || bDot )
396 				{
397 					double fAttrDouble;
398 					if ( SvXMLUnitConverter::convertDouble( fAttrDouble, aNumber ) )
399 						rParameter.Value <<= fAttrDouble;
400 					else
401 						bValid = sal_False;
402 				}
403 				else
404 				{
405 					sal_Int32 nValue;
406 					if ( SvXMLUnitConverter::convertNumber( nValue, aNumber ) )
407 						rParameter.Value <<= nValue;
408 					else
409 						bValid = sal_False;
410 				}
411 			}
412 		}
413 	}
414 	if ( bValid )
415 	{
416         // skipping white spaces and commatas (#121507#)
417         const sal_Unicode aSpace(sal_Unicode(' '));
418         const sal_Unicode aCommata(sal_Unicode(','));
419 
420         while(nIndex < rParaString.getLength())
421         {
422             const sal_Unicode aCandidate(rParaString[nIndex]);
423 
424             if(aSpace == aCandidate || aCommata == aCandidate)
425             {
426                 nIndex++;
427             }
428             else
429             {
430                 break;
431             }
432         }
433 	}
434 	return bValid;
435 }
436 
437 void GetPosition3D( std::vector< com::sun::star::beans::PropertyValue >& rDest,						// e.g. draw:extrusion-viewpoint
438 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp,
439 						SvXMLUnitConverter& rUnitConverter )
440 {
441 	drawing::Position3D aPosition3D;
442 	if ( rUnitConverter.convertPosition3D( aPosition3D, rValue ) )
443 	{
444 		beans::PropertyValue aProp;
445 		aProp.Name = EASGet( eDestProp );
446 		aProp.Value <<= aPosition3D;
447 		rDest.push_back( aProp );
448 	}
449 }
450 
451 void GetDoubleSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,					// e.g. draw:glue-point-leaving-directions
452 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
453 {
454 	std::vector< double > vDirection;
455     sal_Int32 nIndex = 0;
456     do
457     {
458 		double fAttrDouble;
459 		rtl::OUString aToken( rValue.getToken( 0, ',', nIndex ) );
460 		if ( !SvXMLUnitConverter::convertDouble( fAttrDouble, aToken ) )
461 			break;
462 		else
463 			vDirection.push_back( fAttrDouble );
464     }
465     while ( nIndex >= 0 );
466 
467 	if ( !vDirection.empty() )
468 	{
469 		uno::Sequence< double > aDirectionsSeq( vDirection.size() );
470 		std::vector< double >::const_iterator aIter = vDirection.begin();
471 		std::vector< double >::const_iterator aEnd = vDirection.end();
472 		double* pValues = aDirectionsSeq.getArray();
473 
474 		while ( aIter != aEnd )
475 			*pValues++ = *aIter++;
476 
477 		beans::PropertyValue aProp;
478 		aProp.Name = EASGet( eDestProp );
479 		aProp.Value <<= aDirectionsSeq;
480 		rDest.push_back( aProp );
481 	}
482 }
483 
484 void GetEnhancedParameter( std::vector< com::sun::star::beans::PropertyValue >& rDest,				// e.g. draw:handle-position
485 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
486 {
487 	sal_Int32 nIndex = 0;
488 	com::sun::star::drawing::EnhancedCustomShapeParameter aParameter;
489 	if ( GetNextParameter( aParameter, nIndex, rValue ) )
490 	{
491 		beans::PropertyValue aProp;
492 		aProp.Name = EASGet( eDestProp );
493 		aProp.Value <<= aParameter;
494 		rDest.push_back( aProp );
495 	}
496 }
497 
498 void GetEnhancedParameterPair( std::vector< com::sun::star::beans::PropertyValue >& rDest,			// e.g. draw:handle-position
499 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
500 {
501 	sal_Int32 nIndex = 0;
502 	com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameterPair;
503 	if ( GetNextParameter( aParameterPair.First, nIndex, rValue )
504 		&& GetNextParameter( aParameterPair.Second, nIndex, rValue ) )
505 	{
506 		beans::PropertyValue aProp;
507 		aProp.Name = EASGet( eDestProp );
508 		aProp.Value <<= aParameterPair;
509 		rDest.push_back( aProp );
510 	}
511 }
512 
513 sal_Int32 GetEnhancedParameterPairSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,		// e.g. draw:glue-points
514 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
515 {
516 	std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair > vParameter;
517 	com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameter;
518 
519 	sal_Int32 nIndex = 0;
520 	while ( GetNextParameter( aParameter.First, nIndex, rValue )
521 			&& GetNextParameter( aParameter.Second, nIndex, rValue ) )
522 	{
523 		vParameter.push_back( aParameter );
524 	}
525 	if ( !vParameter.empty() )
526 	{
527 		uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > aParameterSeq( vParameter.size() );
528 		std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aIter = vParameter.begin();
529 		std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aEnd = vParameter.end();
530 		com::sun::star::drawing::EnhancedCustomShapeParameterPair* pValues = aParameterSeq.getArray();
531 
532 		while ( aIter != aEnd )
533 			*pValues++ = *aIter++;
534 
535 		beans::PropertyValue aProp;
536 		aProp.Name = EASGet( eDestProp );
537 		aProp.Value <<= aParameterSeq;
538 		rDest.push_back( aProp );
539 	}
540 	return vParameter.size();
541 }
542 
543 void GetEnhancedRectangleSequence( std::vector< com::sun::star::beans::PropertyValue >& rDest,		// e.g. draw:text-areas
544 						const rtl::OUString& rValue, const EnhancedCustomShapeTokenEnum eDestProp )
545 {
546 	std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame > vTextFrame;
547 	com::sun::star::drawing::EnhancedCustomShapeTextFrame aParameter;
548 
549 	sal_Int32 nIndex = 0;
550 
551 	while ( GetNextParameter( aParameter.TopLeft.First, nIndex, rValue )
552 			&& GetNextParameter( aParameter.TopLeft.Second, nIndex, rValue )
553 			&& GetNextParameter( aParameter.BottomRight.First, nIndex, rValue )
554 			&& GetNextParameter( aParameter.BottomRight.Second, nIndex, rValue ) )
555 	{
556 		vTextFrame.push_back( aParameter );
557 	}
558 	if ( !vTextFrame.empty() )
559 	{
560 		uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame > aTextFrameSeq( vTextFrame.size() );
561 		std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame >::const_iterator aIter = vTextFrame.begin();
562 		std::vector< com::sun::star::drawing::EnhancedCustomShapeTextFrame >::const_iterator aEnd = vTextFrame.end();
563 		com::sun::star::drawing::EnhancedCustomShapeTextFrame* pValues = aTextFrameSeq.getArray();
564 
565 		while ( aIter != aEnd )
566 			*pValues++ = *aIter++;
567 
568 		beans::PropertyValue aProp;
569 		aProp.Name = EASGet( eDestProp );
570 		aProp.Value <<= aTextFrameSeq;
571 		rDest.push_back( aProp );
572 	}
573 }
574 
575 void GetEnhancedPath( std::vector< com::sun::star::beans::PropertyValue >& rDest,					// e.g. draw:enhanced-path
576 						const rtl::OUString& rValue )
577 {
578 	std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >	vCoordinates;
579 	std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >		vSegments;
580 
581 	sal_Int32 nIndex = 0;
582 	sal_Int32 nParameterCount = 0;
583 
584 	sal_Int32 nParametersNeeded = 1;
585 	sal_Int16 nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
586 
587 	sal_Bool bValid = sal_True;
588 
589 	while( bValid && ( nIndex < rValue.getLength() ) )
590 	{
591 		switch( rValue[ nIndex ] )
592 		{
593 			case 'M' :
594 			{
595 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::MOVETO;
596 				nParametersNeeded = 1;
597 				nIndex++;
598 			}
599 			break;
600 			case 'L' :
601 			{
602 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::LINETO;
603 				nParametersNeeded = 1;
604 				nIndex++;
605 			}
606 			break;
607 			case 'C' :
608 			{
609 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CURVETO;
610 				nParametersNeeded = 3;
611 				nIndex++;
612 			}
613 			break;
614 			case 'Z' :
615 			{
616 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOSESUBPATH;
617 				nParametersNeeded = 0;
618 				nIndex++;
619 			}
620 			break;
621 			case 'N' :
622 			{
623 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ENDSUBPATH;
624 				nParametersNeeded = 0;
625 				nIndex++;
626 			}
627 			break;
628 			case 'F' :
629 			{
630 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOFILL;
631 				nParametersNeeded = 0;
632 				nIndex++;
633 			}
634 			break;
635 			case 'S' :
636 			{
637 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::NOSTROKE;
638 				nParametersNeeded = 0;
639 				nIndex++;
640 			}
641 			break;
642 			case 'T' :
643 			{
644 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSETO;
645 				nParametersNeeded = 3;
646 				nIndex++;
647 			}
648 			break;
649 			case 'U' :
650 			{
651 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ANGLEELLIPSE;
652 				nParametersNeeded = 3;
653 				nIndex++;
654 			}
655 			break;
656 			case 'A' :
657 			{
658 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARCTO;
659 				nParametersNeeded = 4;
660 				nIndex++;
661 			}
662 			break;
663 			case 'B' :
664 			{
665 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ARC;
666 				nParametersNeeded = 4;
667 				nIndex++;
668 			}
669 			break;
670 			case 'W' :
671 			{
672 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARCTO;
673 				nParametersNeeded = 4;
674 				nIndex++;
675 			}
676 			break;
677 			case 'V' :
678 			{
679 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::CLOCKWISEARC;
680 				nParametersNeeded = 4;
681 				nIndex++;
682 			}
683 			break;
684 			case 'X' :
685 			{
686 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTX;
687 				nParametersNeeded = 1;
688 				nIndex++;
689 			}
690 			break;
691 			case 'Y' :
692 			{
693 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::ELLIPTICALQUADRANTY;
694 				nParametersNeeded = 1;
695 				nIndex++;
696 			}
697 			break;
698 			case 'Q' :
699 			{
700 				nLatestSegmentCommand = com::sun::star::drawing::EnhancedCustomShapeSegmentCommand::QUADRATICCURVETO;
701 				nParametersNeeded = 2;
702 				nIndex++;
703 			}
704 			break;
705 			case ' ' :
706 			{
707 				nIndex++;
708 			}
709 			break;
710 
711 			case '$' :
712 			case '?' :
713 			case '0' :
714 			case '1' :
715 			case '2' :
716 			case '3' :
717 			case '4' :
718 			case '5' :
719 			case '6' :
720 			case '7' :
721 			case '8' :
722 			case '9' :
723 			case '.' :
724 			case '-' :
725 			{
726 				com::sun::star::drawing::EnhancedCustomShapeParameterPair aPair;
727 				if ( GetNextParameter( aPair.First, nIndex, rValue ) &&
728 						GetNextParameter( aPair.Second, nIndex, rValue ) )
729 				{
730 					vCoordinates.push_back( aPair );
731 					nParameterCount++;
732 				}
733 				else
734 					bValid = sal_False;
735 			}
736 			break;
737 			default:
738 				nIndex++;
739 			break;
740 		}
741 		if ( !nParameterCount && !nParametersNeeded )
742 		{
743 			com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
744 			aSegment.Command = nLatestSegmentCommand;
745 			aSegment.Count = 0;
746 			vSegments.push_back( aSegment );
747 			nParametersNeeded = 0x7fffffff;
748 		}
749 		else if ( nParameterCount >= nParametersNeeded )
750 		{
751 			// check if the last command is identical,
752 			// if so, we just need to increment the count
753 			if ( !vSegments.empty() && ( vSegments[ vSegments.size() - 1 ].Command == nLatestSegmentCommand ) )
754 				vSegments[ vSegments.size() -1 ].Count++;
755 			else
756 			{
757 				com::sun::star::drawing::EnhancedCustomShapeSegment aSegment;
758 				aSegment.Command = nLatestSegmentCommand;
759 				aSegment.Count = 1;
760 				vSegments.push_back( aSegment );
761 			}
762 			nParameterCount = 0;
763 		}
764 	}
765 	// adding the Coordinates property
766 	uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair > seqCoordinates( vCoordinates.size() );
767 	std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aCoordinatesIter = vCoordinates.begin();
768 	std::vector< com::sun::star::drawing::EnhancedCustomShapeParameterPair >::const_iterator aCoordinatesEnd = vCoordinates.end();
769 	com::sun::star::drawing::EnhancedCustomShapeParameterPair* pCoordinateValues = seqCoordinates.getArray();
770 
771 	while ( aCoordinatesIter != aCoordinatesEnd )
772 		*pCoordinateValues++ = *aCoordinatesIter++;
773 
774 	beans::PropertyValue aProp;
775 	aProp.Name = EASGet( EAS_Coordinates );
776 	aProp.Value <<= seqCoordinates;
777 	rDest.push_back( aProp );
778 
779 
780 	// adding the Segments property
781 	uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeSegment > seqSegments( vSegments.size() );
782 	std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >::const_iterator aSegmentsIter = vSegments.begin();
783 	std::vector< com::sun::star::drawing::EnhancedCustomShapeSegment >::const_iterator aSegmentsEnd = vSegments.end();
784 	com::sun::star::drawing::EnhancedCustomShapeSegment* pSegmentValues = seqSegments.getArray();
785 
786 	while ( aSegmentsIter != aSegmentsEnd )
787 		*pSegmentValues++ = *aSegmentsIter++;
788 
789 	aProp.Name = EASGet( EAS_Segments );
790 	aProp.Value <<= seqSegments;
791 	rDest.push_back( aProp );
792 }
793 
794 void GetAdjustmentValues( std::vector< com::sun::star::beans::PropertyValue >& rDest,				// draw:adjustments
795 						const rtl::OUString& rValue )
796 {
797 	std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > vAdjustmentValue;
798 	com::sun::star::drawing::EnhancedCustomShapeParameter aParameter;
799 	sal_Int32 nIndex = 0;
800 	while ( GetNextParameter( aParameter, nIndex, rValue ) )
801 	{
802 		com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue aAdj;
803 		if ( aParameter.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::NORMAL )
804 		{
805 			aAdj.Value <<= aParameter.Value;
806 			aAdj.State = beans::PropertyState_DIRECT_VALUE;
807 		}
808 		else
809 			aAdj.State = beans::PropertyState_DEFAULT_VALUE;	// this should not be, but better than setting nothing
810 
811 		vAdjustmentValue.push_back( aAdj );
812 	}
813 
814 	sal_Int32 nAdjustmentValues = vAdjustmentValue.size();
815 	if ( nAdjustmentValues )
816 	{
817 		uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue > aAdjustmentValues( nAdjustmentValues );
818 		std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue >::const_iterator aIter = vAdjustmentValue.begin();
819 		std::vector< com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue >::const_iterator aEnd = vAdjustmentValue.end();
820 		com::sun::star::drawing::EnhancedCustomShapeAdjustmentValue* pValues = aAdjustmentValues.getArray();
821 
822 		while ( aIter != aEnd )
823 			*pValues++ = *aIter++;
824 
825 		beans::PropertyValue aProp;
826 		aProp.Name = EASGet( EAS_AdjustmentValues );
827 		aProp.Value <<= aAdjustmentValues;
828 		rDest.push_back( aProp );
829 	}
830 }
831 
832 void XMLEnhancedCustomShapeContext::StartElement( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
833 {
834 	sal_Int16 nLength = xAttrList->getLength();
835 	if ( nLength )
836 	{
837 		sal_Int32				nAttrNumber;
838 		for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
839 		{
840 			rtl::OUString aLocalName;
841 			const rtl::OUString& rValue = xAttrList->getValueByIndex( nAttr );
842 			/* sven fixme, this must be checked! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
843 
844 			switch( EASGet( aLocalName ) )
845 			{
846 				case EAS_type :
847 					GetString( mrCustomShapeGeometry, rValue, EAS_Type );
848 				break;
849 				case EAS_mirror_horizontal :
850 					GetBool( mrCustomShapeGeometry, rValue, EAS_MirroredX );
851 				break;
852 				case EAS_mirror_vertical :
853 					GetBool( mrCustomShapeGeometry, rValue, EAS_MirroredY );
854 				break;
855 				case EAS_viewBox :
856 				{
857 					SdXMLImExViewBox aViewBox( rValue, GetImport().GetMM100UnitConverter() );
858                     awt::Rectangle aRect(
859                         basegfx::fround(aViewBox.GetX()),
860                         basegfx::fround(aViewBox.GetY()),
861                         basegfx::fround(aViewBox.GetWidth()),
862                         basegfx::fround(aViewBox.GetHeight()));
863 
864                     if(0 == aRect.Width && 0 == aRect.Height)
865                     {
866                         // #124452# If in svg:viewBox no width and height is given the objects should normally
867                         // not be visible at all, but in this case it is a bug in LO to write empty svg:viewBox
868                         // entries for CustomShapes. To allow for a better ODF user experience, just correct this
869                         // here by getting the real object scale from the already set transformation from the xShape.
870                         // Hopefully LO will fix that bug (but this will still leave the files with the error), but
871                         // even when not this will do no harm as long no one uses this state explicitely for some
872                         // purpose (e.g. to really have CustomShapes without content, but unlikely).
873                         // When they do fix this they will need this fix anyways to read their own misformed ODF files
874                         // again, so I guess it will be taken, too...
875                         uno::Reference< beans::XPropertySet > xProps(mrxShape, uno::UNO_QUERY_THROW);
876                         uno::Any aObjectTransform = xProps->getPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Transformation")));
877                         drawing::HomogenMatrix3 aTransformMatrix;
878                         aObjectTransform >>= aTransformMatrix;
879                         basegfx::B2DHomMatrix aMatrix;
880 
881                         aMatrix.set(0, 0, aTransformMatrix.Line1.Column1);
882                         aMatrix.set(0, 1, aTransformMatrix.Line1.Column2);
883                         aMatrix.set(0, 2, aTransformMatrix.Line1.Column3);
884                         aMatrix.set(1, 0, aTransformMatrix.Line2.Column1);
885                         aMatrix.set(1, 1, aTransformMatrix.Line2.Column2);
886                         aMatrix.set(1, 2, aTransformMatrix.Line2.Column3);
887                         aMatrix.set(2, 0, aTransformMatrix.Line3.Column1);
888                         aMatrix.set(2, 1, aTransformMatrix.Line3.Column2);
889                         aMatrix.set(2, 2, aTransformMatrix.Line3.Column3);
890 
891                         basegfx::B2DVector aScale, aTranslate;
892                         double fRotate, fShearX;
893 
894                         aMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
895 
896                         aRect.Width = basegfx::fround(fabs(aScale.getX()));
897                         aRect.Height = basegfx::fround(fabs(aScale.getY()));
898                     }
899 
900 					beans::PropertyValue aProp;
901 					aProp.Name = EASGet( EAS_ViewBox );
902 					aProp.Value <<= aRect;
903 					mrCustomShapeGeometry.push_back( aProp );
904 				}
905 				break;
906 				case EAS_text_rotate_angle :
907 					GetDouble( mrCustomShapeGeometry, rValue, EAS_TextRotateAngle );
908 				break;
909 				case EAS_extrusion_allowed :
910 					GetBool( maPath, rValue, EAS_ExtrusionAllowed );
911 				break;
912 				case EAS_text_path_allowed :
913 					GetBool( maPath, rValue, EAS_TextPathAllowed );
914 				break;
915 				case EAS_concentric_gradient_fill_allowed :
916 					GetBool( maPath, rValue, EAS_ConcentricGradientFillAllowed );
917 				break;
918 				case EAS_extrusion :
919 					GetBool( maExtrusion, rValue, EAS_Extrusion );
920 				break;
921 				case EAS_extrusion_brightness :
922 					GetDoublePercentage( maExtrusion, rValue, EAS_Brightness );
923 				break;
924 				case EAS_extrusion_depth :
925 				{
926 					sal_Int32 nIndex = 0;
927 					com::sun::star::drawing::EnhancedCustomShapeParameterPair aParameterPair;
928 					com::sun::star::drawing::EnhancedCustomShapeParameter& rDepth = aParameterPair.First;
929 					com::sun::star::drawing::EnhancedCustomShapeParameter& rFraction = aParameterPair.Second;
930 					if ( GetNextParameter( rDepth, nIndex, rValue ) )
931 					{
932 						// try to catch the unit for the depth
933 						MapUnit eSrcUnit( SvXMLExportHelper::GetUnitFromString( rValue, MAP_100TH_MM ) );
934 
935 						rtl::OUStringBuffer aUnitStr;
936 						double fFactor = SvXMLExportHelper::GetConversionFactor( aUnitStr, MAP_100TH_MM, eSrcUnit );
937 						if ( ( fFactor != 1.0 ) && ( fFactor != 0.0 ) )
938 						{
939 							double fDepth;
940 							if ( rDepth.Value >>= fDepth )
941 							{
942 								fDepth /= fFactor;
943 								rDepth.Value <<= fDepth;
944 							}
945 						}
946 						if ( rValue.matchIgnoreAsciiCase( rtl::OUString( aUnitStr ), nIndex ) )
947 							nIndex += aUnitStr.getLength();
948 
949 						// skipping white spaces
950 						while( ( nIndex < rValue.getLength() ) && rValue[ nIndex ] == (sal_Unicode)' ' )
951 							nIndex++;
952 
953 						if ( GetNextParameter( rFraction, nIndex, rValue ) )
954 						{
955 							beans::PropertyValue aProp;
956 							aProp.Name = EASGet( EAS_Depth );
957 							aProp.Value <<= aParameterPair;
958 							maExtrusion.push_back( aProp );
959 						}
960 					}
961 				}
962 				break;
963 				case EAS_extrusion_diffusion :
964 					GetDoublePercentage( maExtrusion, rValue, EAS_Diffusion );
965 				break;
966 				case EAS_extrusion_number_of_line_segments :
967 					GetInt32( maExtrusion, rValue, EAS_NumberOfLineSegments );
968 				break;
969 				case EAS_extrusion_light_face :
970 					GetBool( maExtrusion, rValue, EAS_LightFace );
971 				break;
972 				case EAS_extrusion_first_light_harsh :
973 					GetBool( maExtrusion, rValue, EAS_FirstLightHarsh );
974 				break;
975 				case EAS_extrusion_second_light_harsh :
976 					GetBool( maExtrusion, rValue, EAS_SecondLightHarsh );
977 				break;
978 				case EAS_extrusion_first_light_level :
979 					GetDoublePercentage( maExtrusion, rValue, EAS_FirstLightLevel );
980 				break;
981 				case EAS_extrusion_second_light_level :
982 					GetDoublePercentage( maExtrusion, rValue, EAS_SecondLightLevel );
983 				break;
984 				case EAS_extrusion_first_light_direction :
985 					GetB3DVector( maExtrusion, rValue, EAS_FirstLightDirection );
986 				break;
987 				case EAS_extrusion_second_light_direction :
988 					GetB3DVector( maExtrusion, rValue, EAS_SecondLightDirection );
989 				break;
990 				case EAS_extrusion_metal :
991 					GetBool( maExtrusion, rValue, EAS_Metal );
992 				break;
993 				case EAS_shade_mode :
994 				{
995 					drawing::ShadeMode eShadeMode( drawing::ShadeMode_FLAT );
996 					if( IsXMLToken( rValue, XML_PHONG ) )
997 						eShadeMode = drawing::ShadeMode_PHONG;
998 					else if ( IsXMLToken( rValue, XML_GOURAUD ) )
999 						eShadeMode = drawing::ShadeMode_SMOOTH;
1000 					else if ( IsXMLToken( rValue, XML_DRAFT ) )
1001 						eShadeMode = drawing::ShadeMode_DRAFT;
1002 
1003 					beans::PropertyValue aProp;
1004 					aProp.Name = EASGet( EAS_ShadeMode );
1005 					aProp.Value <<= eShadeMode;
1006 					maExtrusion.push_back( aProp );
1007 				}
1008 				break;
1009 				case EAS_extrusion_rotation_angle :
1010 					GetEnhancedParameterPair( maExtrusion, rValue, EAS_RotateAngle );
1011 				break;
1012 				case EAS_extrusion_rotation_center :
1013 					GetB3DVector( maExtrusion, rValue, EAS_RotationCenter );
1014 				break;
1015 				case EAS_extrusion_shininess :
1016 					GetDoublePercentage( maExtrusion, rValue, EAS_Shininess );
1017 				break;
1018 				case EAS_extrusion_skew :
1019 					GetEnhancedParameterPair( maExtrusion, rValue, EAS_Skew );
1020 				break;
1021 				case EAS_extrusion_specularity :
1022 					GetDoublePercentage( maExtrusion, rValue, EAS_Specularity );
1023 				break;
1024 				case EAS_projection :
1025 				{
1026 					drawing::ProjectionMode eProjectionMode( drawing::ProjectionMode_PERSPECTIVE );
1027 					if( IsXMLToken( rValue, XML_PARALLEL ) )
1028 						eProjectionMode = drawing::ProjectionMode_PARALLEL;
1029 
1030 					beans::PropertyValue aProp;
1031 					aProp.Name = EASGet( EAS_ProjectionMode );
1032 					aProp.Value <<= eProjectionMode;
1033 					maExtrusion.push_back( aProp );
1034 				}
1035 				break;
1036 				case EAS_extrusion_viewpoint :
1037 					GetPosition3D( maExtrusion, rValue, EAS_ViewPoint, mrUnitConverter );
1038 				break;
1039 				case EAS_extrusion_origin :
1040 					GetEnhancedParameterPair( maExtrusion, rValue, EAS_Origin );
1041 				break;
1042 				case EAS_extrusion_color :
1043 					GetBool( maExtrusion, rValue, EAS_Color );
1044 				break;
1045 				case EAS_enhanced_path :
1046 					GetEnhancedPath( maPath, rValue );
1047 				break;
1048 				case EAS_path_stretchpoint_x :
1049 				{
1050 					if ( SvXMLUnitConverter::convertNumber( nAttrNumber, rValue ) )
1051 					{
1052 						beans::PropertyValue aProp;
1053 						aProp.Name = EASGet( EAS_StretchX );
1054 						aProp.Value <<= nAttrNumber;
1055 						maPath.push_back( aProp );
1056 					}
1057 				}
1058 				break;
1059 				case EAS_path_stretchpoint_y :
1060 				{
1061 					if ( SvXMLUnitConverter::convertNumber( nAttrNumber, rValue ) )
1062 					{
1063 						beans::PropertyValue aProp;
1064 						aProp.Name = EASGet( EAS_StretchY );
1065 						aProp.Value <<= nAttrNumber;
1066 						maPath.push_back( aProp );
1067 					}
1068 				}
1069 				break;
1070 				case EAS_text_areas :
1071 					GetEnhancedRectangleSequence( maPath, rValue, EAS_TextFrames );
1072 				break;
1073 				case EAS_glue_points :
1074 				{
1075 					sal_Int32 i, nPairs = GetEnhancedParameterPairSequence( maPath, rValue, EAS_GluePoints );
1076 					GetImport().GetShapeImport()->moveGluePointMapping( mrxShape, nPairs );
1077 					for ( i = 0; i < nPairs; i++ )
1078 						GetImport().GetShapeImport()->addGluePointMapping( mrxShape, i + 4, i + 4 );
1079 				}
1080 				break;
1081 				case EAS_glue_point_type :
1082 					GetEnum( maPath, rValue, EAS_GluePointType, *aXML_GluePointEnumMap );
1083 				break;
1084 				case EAS_glue_point_leaving_directions :
1085 					GetDoubleSequence( maPath, rValue, EAS_GluePointLeavingDirections );
1086 				break;
1087 				case EAS_text_path :
1088 					GetBool( maTextPath, rValue, EAS_TextPath );
1089 				break;
1090 				case EAS_text_path_mode :
1091 				{
1092 					com::sun::star::drawing::EnhancedCustomShapeTextPathMode eTextPathMode( com::sun::star::drawing::EnhancedCustomShapeTextPathMode_NORMAL );
1093 					if( IsXMLToken( rValue, XML_PATH ) )
1094 						eTextPathMode = com::sun::star::drawing::EnhancedCustomShapeTextPathMode_PATH;
1095 					else if ( IsXMLToken( rValue, XML_SHAPE ) )
1096 						eTextPathMode = com::sun::star::drawing::EnhancedCustomShapeTextPathMode_SHAPE;
1097 
1098 					beans::PropertyValue aProp;
1099 					aProp.Name = EASGet( EAS_TextPathMode );
1100 					aProp.Value <<= eTextPathMode;
1101 					maTextPath.push_back( aProp );
1102 				}
1103 				break;
1104 				case EAS_text_path_scale :
1105 				{
1106 					sal_Bool bScaleX = IsXMLToken( rValue, XML_SHAPE );
1107 					beans::PropertyValue aProp;
1108 					aProp.Name = EASGet( EAS_ScaleX );
1109 					aProp.Value <<= bScaleX;
1110 					maTextPath.push_back( aProp );
1111 				}
1112 				break;
1113 				case EAS_text_path_same_letter_heights :
1114 					GetBool( maTextPath, rValue, EAS_SameLetterHeights );
1115 				break;
1116 				case EAS_modifiers :
1117 					GetAdjustmentValues( mrCustomShapeGeometry, rValue );
1118 				break;
1119 				default:
1120 					break;
1121 			}
1122 		}
1123 	}
1124 }
1125 
1126 void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
1127 									const std::vector< beans::PropertyValues >& rElement,
1128 										const rtl::OUString& rElementName )
1129 {
1130 	if ( !rElement.empty() )
1131 	{
1132 		uno::Sequence< beans::PropertyValues > aPropSeq( rElement.size() );
1133 		std::vector< beans::PropertyValues >::const_iterator aIter = rElement.begin();
1134 		std::vector< beans::PropertyValues >::const_iterator aEnd = rElement.end();
1135 		beans::PropertyValues* pValues = aPropSeq.getArray();
1136 
1137 		while ( aIter != aEnd )
1138 			*pValues++ = *aIter++;
1139 
1140 		beans::PropertyValue aProp;
1141 		aProp.Name = rElementName;
1142 		aProp.Value <<= aPropSeq;
1143 		rPropVec.push_back( aProp );
1144 	}
1145 }
1146 
1147 void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
1148 									const std::vector< rtl::OUString >& rElement,
1149 										const rtl::OUString& rElementName )
1150 {
1151 	if ( !rElement.empty() )
1152 	{
1153 		uno::Sequence< rtl::OUString > aPropSeq( rElement.size() );
1154 		std::vector< rtl::OUString >::const_iterator aIter = rElement.begin();
1155 		std::vector< rtl::OUString >::const_iterator aEnd = rElement.end();
1156 		rtl::OUString* pValues = aPropSeq.getArray();
1157 
1158 		while ( aIter != aEnd )
1159 			*pValues++ = *aIter++;
1160 
1161 		beans::PropertyValue aProp;
1162 		aProp.Name = rElementName;
1163 		aProp.Value <<= aPropSeq;
1164 		rPropVec.push_back( aProp );
1165 	}
1166 }
1167 
1168 void SdXMLCustomShapePropertyMerge( std::vector< com::sun::star::beans::PropertyValue >& rPropVec,
1169 									const std::vector< com::sun::star::beans::PropertyValue >& rElement,
1170 										const rtl::OUString& rElementName )
1171 {
1172 	if ( !rElement.empty() )
1173 	{
1174 		uno::Sequence< beans::PropertyValue > aPropSeq( rElement.size() );
1175 		std::vector< beans::PropertyValue >::const_iterator aIter = rElement.begin();
1176 		std::vector< beans::PropertyValue >::const_iterator aEnd = rElement.end();
1177 		beans::PropertyValue* pValues = aPropSeq.getArray();
1178 
1179 		while ( aIter != aEnd )
1180 			*pValues++ = *aIter++;
1181 
1182 		beans::PropertyValue aProp;
1183 		aProp.Name = rElementName;
1184 		aProp.Value <<= aPropSeq;
1185 		rPropVec.push_back( aProp );
1186 	}
1187 }
1188 
1189 typedef std::hash_map< rtl::OUString, sal_Int32, rtl::OUStringHash, OUStringEqFunc> EquationHashMap;
1190 
1191 /* if rPara.Type is from type EnhancedCustomShapeParameterType::EQUATION, the name of the equation
1192    will be converted from rtl::OUString to index */
1193 void CheckAndResolveEquationParameter( com::sun::star::drawing::EnhancedCustomShapeParameter& rPara, EquationHashMap* pH )
1194 {
1195 	if ( rPara.Type == com::sun::star::drawing::EnhancedCustomShapeParameterType::EQUATION )
1196 	{
1197 		rtl::OUString aEquationName;
1198 		if ( rPara.Value >>= aEquationName )
1199 		{
1200 			sal_Int32 nIndex = 0;
1201 			EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
1202 			if ( aHashIter != pH->end() )
1203 				nIndex = (*aHashIter).second;
1204 			rPara.Value <<= nIndex;
1205 		}
1206 	}
1207 }
1208 
1209 void XMLEnhancedCustomShapeContext::EndElement()
1210 {
1211 	// resolve properties that are indexing a Equation
1212 	if ( !maEquations.empty() )
1213 	{
1214 		// creating hash map containing the name and index of each equation
1215 		EquationHashMap* pH = new EquationHashMap;
1216 		std::vector< rtl::OUString >::iterator aEquationNameIter = maEquationNames.begin();
1217 		std::vector< rtl::OUString >::iterator aEquationNameEnd  = maEquationNames.end();
1218 		while( aEquationNameIter != aEquationNameEnd )
1219 		{
1220 			(*pH)[ *aEquationNameIter ] = (sal_Int32)( aEquationNameIter - maEquationNames.begin() );
1221 			aEquationNameIter++;
1222 		}
1223 
1224 		// resolve equation
1225 		std::vector< rtl::OUString >::iterator aEquationIter = maEquations.begin();
1226 		std::vector< rtl::OUString >::iterator aEquationEnd  = maEquations.end();
1227 		while( aEquationIter != aEquationEnd )
1228 		{
1229 			sal_Int32 nIndexOf = 0;
1230 			do
1231 			{
1232 				nIndexOf = aEquationIter->indexOf( '?', nIndexOf );
1233 				if ( nIndexOf != -1 )
1234 				{
1235 					rtl::OUString aEquationName;
1236 					if ( GetEquationName( *aEquationIter, nIndexOf + 1, aEquationName ) )
1237 					{
1238 						// copying first characters inclusive '?'
1239 						rtl::OUString aNew( aEquationIter->copy( 0, nIndexOf + 1 ) );
1240 						sal_Int32 nIndex = 0;
1241 						EquationHashMap::iterator aHashIter( pH->find( aEquationName ) );
1242 						if ( aHashIter != pH->end() )
1243 							nIndex = (*aHashIter).second;
1244 						aNew += rtl::OUString::valueOf( nIndex );
1245 						aNew += aEquationIter->copy( nIndexOf + aEquationName.getLength() + 1 );
1246 						*aEquationIter = aNew;
1247 					}
1248 					nIndexOf++;
1249 				}
1250 			}
1251 			while( nIndexOf != -1 );
1252 			aEquationIter++;
1253 		}
1254 
1255 		// Path
1256 		sal_Int32 i;
1257 		std::vector< beans::PropertyValue >::iterator aPathIter = maPath.begin();
1258 		std::vector< beans::PropertyValue >::iterator aPathEnd  = maPath.end();
1259 		while ( aPathIter != aPathEnd )
1260 		{
1261 			switch( EASGet( aPathIter->Name ) )
1262 			{
1263 				case EAS_Coordinates :
1264 				case EAS_GluePoints :
1265 				{
1266 					uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >& rSeq =
1267 						*((uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeParameterPair >*)
1268 							aPathIter->Value.getValue());
1269 					for ( i = 0; i < rSeq.getLength(); i++ )
1270 					{
1271 						CheckAndResolveEquationParameter( rSeq[ i ].First, pH );
1272 						CheckAndResolveEquationParameter( rSeq[ i ].Second, pH );
1273 					}
1274 				}
1275 				break;
1276 				case EAS_TextFrames :
1277 				{
1278 					uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame >& rSeq =
1279 						*((uno::Sequence< com::sun::star::drawing::EnhancedCustomShapeTextFrame >*)
1280 							aPathIter->Value.getValue());
1281 					for ( i = 0; i < rSeq.getLength(); i++ )
1282 					{
1283 						CheckAndResolveEquationParameter( rSeq[ i ].TopLeft.First, pH );
1284 						CheckAndResolveEquationParameter( rSeq[ i ].TopLeft.Second, pH );
1285 						CheckAndResolveEquationParameter( rSeq[ i ].BottomRight.First, pH );
1286 						CheckAndResolveEquationParameter( rSeq[ i ].BottomRight.Second, pH );
1287 					}
1288 				}
1289 				break;
1290 				default:
1291 					break;
1292 			}
1293 			aPathIter++;
1294 		}
1295 		std::vector< beans::PropertyValues >::iterator aHandleIter = maHandles.begin();
1296 		std::vector< beans::PropertyValues >::iterator aHandleEnd  = maHandles.end();
1297 		while ( aHandleIter != aHandleEnd )
1298 		{
1299 			beans::PropertyValue* pValues = aHandleIter->getArray();
1300 			for ( i = 0; i < aHandleIter->getLength(); i++ )
1301 			{
1302 				switch( EASGet( pValues->Name ) )
1303 				{
1304 					case EAS_RangeYMinimum :
1305 					case EAS_RangeYMaximum :
1306 					case EAS_RangeXMinimum :
1307 					case EAS_RangeXMaximum :
1308 					case EAS_RadiusRangeMinimum :
1309 					case EAS_RadiusRangeMaximum :
1310 					{
1311 						CheckAndResolveEquationParameter( *((com::sun::star::drawing::EnhancedCustomShapeParameter*)
1312 							pValues->Value.getValue()), pH );
1313 					}
1314 					break;
1315 
1316 					case EAS_Position :
1317 					case EAS_Polar :
1318 					{
1319 						CheckAndResolveEquationParameter( (*((com::sun::star::drawing::EnhancedCustomShapeParameterPair*)
1320 							pValues->Value.getValue())).First, pH );
1321 						CheckAndResolveEquationParameter( (*((com::sun::star::drawing::EnhancedCustomShapeParameterPair*)
1322 							pValues->Value.getValue())).Second, pH );
1323 					}
1324 					break;
1325 					default:
1326 						break;
1327 				}
1328 				pValues++;
1329 			}
1330 			aHandleIter++;
1331 		}
1332 		delete pH;
1333 	}
1334 
1335 	SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maExtrusion, EASGet( EAS_Extrusion ) );
1336 	SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maPath,      EASGet( EAS_Path ) );
1337 	SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maTextPath,  EASGet( EAS_TextPath ) );
1338 	SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maEquations, EASGet( EAS_Equations ) );
1339 	if  ( !maHandles.empty() )
1340 		SdXMLCustomShapePropertyMerge( mrCustomShapeGeometry, maHandles, EASGet( EAS_Handles ) );
1341 }
1342 
1343 SvXMLImportContext* XMLEnhancedCustomShapeContext::CreateChildContext( sal_uInt16 nPrefix,const rtl::OUString& rLocalName,
1344 																	const uno::Reference< xml::sax::XAttributeList> & xAttrList )
1345 {
1346 	EnhancedCustomShapeTokenEnum aTokenEnum = EASGet( rLocalName );
1347 	if ( aTokenEnum == EAS_equation )
1348 	{
1349 		sal_Int16 nLength = xAttrList->getLength();
1350 		if ( nLength )
1351 		{
1352 			rtl::OUString aFormula;
1353 			rtl::OUString aFormulaName;
1354 			for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
1355 			{
1356 				rtl::OUString aLocalName;
1357 				const rtl::OUString& rValue = xAttrList->getValueByIndex( nAttr );
1358 				/* fixme sven, this needs to be chekced! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
1359 
1360 				switch( EASGet( aLocalName ) )
1361 				{
1362 					case EAS_formula :
1363 						aFormula = rValue;
1364 					break;
1365 					case EAS_name :
1366 						aFormulaName = rValue;
1367 					break;
1368 					default:
1369 						break;
1370 				}
1371 			}
1372 			if ( aFormulaName.getLength() || aFormula.getLength() )
1373 			{
1374 				maEquations.push_back( aFormula );
1375 				maEquationNames.push_back( aFormulaName );
1376 			}
1377 		}
1378 	}
1379 	else if ( aTokenEnum == EAS_handle )
1380 	{
1381 		std::vector< com::sun::star::beans::PropertyValue > aHandle;
1382         const sal_Int16 nLength = xAttrList->getLength();
1383 		for( sal_Int16 nAttr = 0; nAttr < nLength; nAttr++ )
1384 		{
1385 			rtl::OUString aLocalName;
1386 			const rtl::OUString& rValue = xAttrList->getValueByIndex( nAttr );
1387 			/* fixme sven, this needs to be chekced! sal_uInt16 nPrefix = */ GetImport().GetNamespaceMap().GetKeyByAttrName( xAttrList->getNameByIndex( nAttr ), &aLocalName );
1388 			switch( EASGet( aLocalName ) )
1389 			{
1390 				case EAS_handle_mirror_vertical :
1391 					GetBool( aHandle, rValue, EAS_MirroredY );
1392 				break;
1393 				case EAS_handle_mirror_horizontal :
1394 					GetBool( aHandle, rValue, EAS_MirroredX );
1395 				break;
1396 				case EAS_handle_switched :
1397 					GetBool( aHandle, rValue, EAS_Switched );
1398 				break;
1399 				case EAS_handle_position :
1400 					GetEnhancedParameterPair( aHandle, rValue, EAS_Position );
1401 				break;
1402 				case EAS_handle_range_x_minimum :
1403 					GetEnhancedParameter( aHandle, rValue, EAS_RangeXMinimum );
1404 				break;
1405 				case EAS_handle_range_x_maximum :
1406 					GetEnhancedParameter( aHandle, rValue, EAS_RangeXMaximum );
1407 				break;
1408 				case EAS_handle_range_y_minimum :
1409 					GetEnhancedParameter( aHandle, rValue, EAS_RangeYMinimum );
1410 				break;
1411 				case EAS_handle_range_y_maximum :
1412 					GetEnhancedParameter( aHandle, rValue, EAS_RangeYMaximum );
1413 				break;
1414 				case EAS_handle_polar :
1415 					GetEnhancedParameterPair( aHandle, rValue, EAS_Polar );
1416 				break;
1417 				case EAS_handle_radius_range_minimum :
1418 					GetEnhancedParameter( aHandle, rValue, EAS_RadiusRangeMinimum );
1419 				break;
1420 				case EAS_handle_radius_range_maximum :
1421 					GetEnhancedParameter( aHandle, rValue, EAS_RadiusRangeMaximum );
1422 				break;
1423 				default:
1424 					break;
1425 			}
1426 		}
1427 		beans::PropertyValues aPropSeq( aHandle.size() );
1428 		std::vector< beans::PropertyValue >::const_iterator aIter = aHandle.begin();
1429 		std::vector< beans::PropertyValue >::const_iterator aEnd = aHandle.end();
1430 		beans::PropertyValue* pValues = aPropSeq.getArray();
1431 
1432 		while ( aIter != aEnd )
1433 			*pValues++ = *aIter++;
1434 
1435 		maHandles.push_back( aPropSeq );
1436 	}
1437 	return SvXMLImportContext::CreateChildContext( nPrefix, rLocalName, xAttrList );
1438 }
1439