?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update ooo310-m15
[ooovba.git] / svx / source / msfilter / msashape.cxx
blob4d3d21867a5784417dbf3fa8198325365383ba32
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: msashape.cxx,v $
10 * $Revision: 1.44 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svx.hxx"
33 #include <osl/endian.h>
34 #include <msashape.hxx>
35 #include <svx/svdocirc.hxx>
36 #include <svx/svdogrp.hxx>
37 #include <svx/svdopath.hxx>
38 #include <svx/svdpage.hxx>
39 #include <svx/xflclit.hxx>
40 #include <svx/sdasaitm.hxx>
41 #include <svtools/itemset.hxx>
42 #include <svx/svdmodel.hxx>
43 #include <rtl/crc.h>
44 #include <svx/xlnstit.hxx>
45 #include <svx/xlnedit.hxx>
46 #include <svx/xlnstwit.hxx>
47 #include <svx/xlnedwit.hxx>
48 #include <svx/xlnstcit.hxx>
49 #include <svx/xlnedcit.hxx>
50
51 #include <math.h>
52 #include <basegfx/polygon/b2dpolypolygon.hxx>
53 #include <basegfx/polygon/b2dpolygon.hxx>
54
55 struct SvxMSDffVertPair
56 {
57 sal_Int32 nValA;
58 sal_Int32 nValB;
59 };
60 struct SvxMSDffCalculationData
61 {
62 sal_uInt16 nFlags;
63 sal_Int16 nVal1;
64 sal_Int16 nVal2;
65 sal_Int16 nVal3;
66 };
67 struct SvxMSDffTextRectangles
68 {
69 SvxMSDffVertPair nPairA;
70 SvxMSDffVertPair nPairB;
71 };
72
73 struct mso_CustomShape
74 {
75 SvxMSDffVertPair* pVertices;
76 sal_uInt32 nVertices;
77 sal_uInt16* pElements;
78 sal_uInt32 nElements;
79 SvxMSDffCalculationData* pCalculation;
80 sal_uInt32 nCalculation;
81 sal_Int32* pDefData;
82 SvxMSDffTextRectangles* pTextRect;
83 sal_uInt32 nTextRect;
84 sal_Int32 nCoordWidth;
85 sal_Int32 nCoordHeight;
86 sal_Int32 nXRef;
87 sal_Int32 nYRef;
88 SvxMSDffVertPair* pGluePoints;
89 sal_uInt32 nGluePoints;
90 };
91
92 #define GEOMETRY_USED_LEFT 1
93 #define GEOMETRY_USED_TOP 2
94 #define GEOMETRY_USED_RIGHT 4
95 #define GEOMETRY_USED_BOTTOM 8
96
97 /*
98 static const SvxMSDffVertPair Vert[] =
99 {
100 { 0, 0, }
101 };
102 static const sal_uInt16 Segm[] =
103 {
104 0x4000,
105 0x8000
106 };
107 static const SvxMSDffCalculationData Calc[] =
108 {
109 { 0x0000, 0, 0, 0 }
110 };
111 static const sal_Int32 Default[] =
112 {
113 0
114 };
115 static const SvxMSDffTextRect TextRect[] =
116 {
117 { { 0, 0 }, { 0, 0 } }
118 };
119 static const sal_Int32 BoundRect[] =
120 {
121 0, 0, 21600, 21600
122 };
123 static const mso_CustomShape mso =
124 {
125 (SvxMSDffVertPair*)mso_sptVert, sizeof( mso_sptVert ) / sizeof( SvxMSDffVertPair ),
126 (sal_uInt16*)mso_sptSegm, sizeof( mso_sptSegm ) >> 1,
127 (SvxMSDffCalculationData*)mso_sptCalc, sizeof( mso_sptCalc ) / sizeof( SvxMSDffCalculationData ),
128 (sal_Int32*)mso_sptDefault,
129 (SvxMSDffTextRectangles*)mso_sptTextRect, sizeof( mso_sptTextRect ) / sizeof( SvxMSDffTextRectangles ),
130 21600, 21600,
131 0x80000000, 0x80000000,
132 (SvxMSDffVertPair*)mso_sptVert, sizeof( mso_sptVert ) / sizeof( SvxMSDffVertPair )
133 };
134 */
135
136 #define MSO_I | (sal_Int32)0x80000000
137
138 static const sal_Int32 mso_sptDefault0[] =
139 {
140 1, 0
141 };
142 static const sal_Int32 mso_sptDefault1400[] =
143 {
144 1, 1400
145 };
146 static const sal_Int32 mso_sptDefault1800[] =
147 {
148 1, 1800
149 };
150 static const sal_Int32 mso_sptDefault2500[] =
151 {
152 1, 2500
153 };
154 static const sal_Int32 mso_sptDefault2700[] =
155 {
156 1, 2700
157 };
158 static const sal_Int32 mso_sptDefault3600[] =
159 {
160 1, 3600
161 };
162 static const sal_Int32 mso_sptDefault3700[] =
163 {
164 1, 3700
165 };
166 static const sal_Int32 mso_sptDefault5400[] =
167 {
168 1, 5400
169 };
170 static const sal_Int32 mso_sptDefault8100[] =
171 {
172 1, 5400
173 };
174 static const sal_Int32 mso_sptDefault10800[] =
175 {
176 1, 10800
177 };
178 static const sal_Int32 mso_sptDefault16200and5400[] =
179 {
180 2, 16200, 5400
181 };
182
183 static const sal_Int32 mso_sptArcDefault[] =
184 {
185 2, 270 << 16, 0
186 };
187 static const SvxMSDffVertPair mso_sptStandardGluePoints[] =
188 {
189 { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }
190 };
191 static const mso_CustomShape msoArc =
192 {
193 NULL, 0,
194 NULL, 0,
195 NULL, 0,
196 (sal_Int32*)mso_sptArcDefault,
197 NULL, 0,
198 21600, 21600,
199 0x80000000, 0x80000000,
200 NULL, 0
201 };
202
203 static const mso_CustomShape msoRectangle =
204 {
205 NULL, 0,
206 NULL, 0,
207 NULL, 0,
208 NULL,
209 NULL, 0,
210 21600, 21600,
211 0x80000000, 0x80000000,
212 NULL, 0
213 };
214
215 static const SvxMSDffCalculationData mso_sptRoundRectangleCalc[] = // adjustment1 : 0 - 10800
216 {
217 { 0x2001, DFF_Prop_adjustValue, 1, 3 },
218 { 0xa000, DFF_Prop_geoRight, 0, 0x400},
219 { 0xa000, DFF_Prop_geoBottom, 0, 0x400},
220 { 0x6000, DFF_Prop_geoLeft, 0x400, 0 },
221 { 0x6000, DFF_Prop_geoTop, 0x400, 0 }
222 };
223 static const SvxMSDffTextRectangles mso_sptRoundRectangleTextRect[] =
224 {
225 { { 3 MSO_I, 4 MSO_I }, { 1 MSO_I, 2 MSO_I } }
226 };
227 static const mso_CustomShape msoRoundRectangle =
228 {
229 NULL, 0,
230 NULL, 0,
231 (SvxMSDffCalculationData*)mso_sptRoundRectangleCalc, sizeof( mso_sptRoundRectangleCalc ) / sizeof( SvxMSDffCalculationData ),
232 (sal_Int32*)mso_sptDefault3600,
233 (SvxMSDffTextRectangles*)mso_sptRoundRectangleTextRect, sizeof( mso_sptRoundRectangleTextRect ) / sizeof( SvxMSDffTextRectangles ),
234 21600, 21600,
235 0x80000000, 0x80000000,
236 NULL, 0
237 };
238
239 static const SvxMSDffVertPair mso_sptRightTriangleVert[] =
240 {
241 { 0, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
242 };
243 static const SvxMSDffTextRectangles mso_sptRightTriangleTextRect[] =
244 {
245 { { 1900, 12700 }, { 12700, 19700 } }
246 };
247 static const SvxMSDffVertPair mso_sptRightTriangleGluePoints[] =
248 {
249 { 10800, 0 }, { 5400, 10800 }, { 0, 21600 }, { 10800, 21600 }, { 21600, 21600 }, { 16200, 10800 }
250 };
251 static const mso_CustomShape msoRightTriangle =
252 {
253 (SvxMSDffVertPair*)mso_sptRightTriangleVert, sizeof( mso_sptRightTriangleVert ) / sizeof( SvxMSDffVertPair ),
254 NULL, 0,
255 NULL, 0,
256 NULL,
257 (SvxMSDffTextRectangles*)mso_sptRightTriangleTextRect, sizeof( mso_sptRightTriangleTextRect ) / sizeof( SvxMSDffTextRectangles ),
258 21600, 21600,
259 0x80000000, 0x80000000,
260 (SvxMSDffVertPair*)mso_sptRightTriangleGluePoints, sizeof( mso_sptRightTriangleGluePoints ) / sizeof( SvxMSDffVertPair )
261 };
262
263 static const SvxMSDffTextRectangles mso_sptEllipseTextRect[] =
264 {
265 { { 3200, 3200 }, { 18400, 18400 } }
266 };
267 static const SvxMSDffVertPair mso_sptEllipseGluePoints[] =
268 {
269 { 10800, 0 }, { 3160, 3160 }, { 0, 10800 }, { 3160, 18440 }, { 10800, 21600 }, { 18440, 18440 }, { 21600, 10800 }, { 18440, 3160 }
270 };
271 static const mso_CustomShape msoEllipse =
272 {
273 NULL, 0,
274 NULL, 0,
275 NULL, 0,
276 NULL,
277 (SvxMSDffTextRectangles*)mso_sptEllipseTextRect, sizeof( mso_sptEllipseTextRect ) / sizeof( SvxMSDffTextRectangles ),
278 21600, 21600,
279 0x80000000, 0x80000000,
280 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
281 };
282
283 static const SvxMSDffVertPair mso_sptParallelogramVert[] = // adjustment1 : 0 - 21600
284 {
285 { 0 MSO_I, 0 }, { 21600, 0 }, { 1 MSO_I, 21600 }, { 0, 21600 }
286 };
287 static const sal_uInt16 mso_sptParallelogramSegm[] =
288 {
289 0x4000, 0x0003, 0x6001, 0x8000
290 };
291 static const SvxMSDffCalculationData mso_sptParallelogramCalc[] =
292 {
293 { 0x4000, 0, DFF_Prop_adjustValue, 0 },
294 { 0x8000, 0, 21600, DFF_Prop_adjustValue },
295 { 0x2001, DFF_Prop_adjustValue, 10, 24 },
296 { 0x2000, 0x0402, 1750, 0 },
297 { 0x8000, 21600, 0, 0x0403 },
298 { 0x2001, 0x400, 1, 2 },
299 { 0x4000, 10800, 0x405, 0 },
300 { 0x2000, 0x400, 0, 10800 },
301 { 0x6006, 0x407, 0x40d, 0 },
302 { 0x8000, 10800, 0, 0x405 },
303 { 0x6006, 0x407, 0x40c, 21600 },
304 { 0x8000, 21600, 0, 0x405 },
305 { 0x8001, 21600, 10800, 0x400 },
306 { 0x8000, 21600, 0, 0x40c }
307 };
308 static const SvxMSDffTextRectangles mso_sptParallelogramTextRect[] =
309 {
310 { { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
311 };
312 static const SvxMSDffVertPair mso_sptParallelogramGluePoints[] =
313 {
314 { 6 MSO_I, 0 }, { 10800, 8 MSO_I }, { 11 MSO_I, 10800 }, { 9 MSO_I, 21600 }, { 10800, 10 MSO_I }, { 5 MSO_I, 10800 }
315 };
316 static const mso_CustomShape msoParallelogram =
317 {
318 (SvxMSDffVertPair*)mso_sptParallelogramVert, sizeof( mso_sptParallelogramVert ) / sizeof( SvxMSDffVertPair ),
319 (sal_uInt16*)mso_sptParallelogramSegm, sizeof( mso_sptParallelogramSegm ) >> 1,
320 (SvxMSDffCalculationData*)mso_sptParallelogramCalc, sizeof( mso_sptParallelogramCalc ) / sizeof( SvxMSDffCalculationData ),
321 (sal_Int32*)mso_sptDefault5400,
322 (SvxMSDffTextRectangles*)mso_sptParallelogramTextRect, sizeof( mso_sptParallelogramTextRect ) / sizeof( SvxMSDffTextRectangles ),
323 21600, 21600,
324 0x80000000, 0x80000000,
325 (SvxMSDffVertPair*)mso_sptParallelogramGluePoints, sizeof( mso_sptParallelogramGluePoints ) / sizeof( SvxMSDffVertPair )
326 };
327
328 static const SvxMSDffVertPair mso_sptDiamondVert[] =
329 {
330 { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 10800 }, { 10800, 0 }
331 };
332 static const SvxMSDffTextRectangles mso_sptDiamondTextRect[] =
333 {
334 { { 5400, 5400 }, { 16200, 16200 } }
335 };
336 static const mso_CustomShape msoDiamond =
337 {
338 (SvxMSDffVertPair*)mso_sptDiamondVert, sizeof( mso_sptDiamondVert ) / sizeof( SvxMSDffVertPair ),
339 NULL, 0,
340 NULL, 0,
341 NULL,
342 (SvxMSDffTextRectangles*)mso_sptDiamondTextRect, sizeof( mso_sptDiamondTextRect ) / sizeof( SvxMSDffTextRectangles ),
343 21600, 21600,
344 0x80000000, 0x80000000,
345 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
346 };
347
348 static const SvxMSDffVertPair mso_sptTrapezoidVert[] = // adjustment1 : 0 - 10800
349 {
350 { 0, 0 }, { 21600, 0 }, {0 MSO_I, 21600 }, { 1 MSO_I, 21600 }
351 };
352 static const sal_uInt16 mso_sptTrapezoidSegm[] =
353 {
354 0x4000, 0x0003, 0x6001, 0x8000
355 };
356 static const SvxMSDffCalculationData mso_sptTrapezoidCalc[] =
357 {
358 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
359 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
360 { 0x2001, DFF_Prop_adjustValue, 10, 18 },
361 { 0x2000, 0x0402, 1750, 0 },
362 { 0x8000, 21600, 0, 0x403 },
363 { 0x2001, DFF_Prop_adjustValue, 1, 2 },
364 { 0x8000, 21600, 0, 0x405 }
365 };
366 static const SvxMSDffTextRectangles mso_sptTrapezoidTextRect[] =
367 {
368 { { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
369 };
370 static const SvxMSDffVertPair mso_sptTrapezoidGluePoints[] =
371 {
372 { 6 MSO_I, 10800 }, { 10800, 21600 }, { 5 MSO_I, 10800 }, { 10800, 0 }
373 };
374 static const mso_CustomShape msoTrapezoid =
375 {
376 (SvxMSDffVertPair*)mso_sptTrapezoidVert, sizeof( mso_sptTrapezoidVert ) / sizeof( SvxMSDffVertPair ),
377 (sal_uInt16*)mso_sptTrapezoidSegm, sizeof( mso_sptTrapezoidSegm ) >> 1,
378 (SvxMSDffCalculationData*)mso_sptTrapezoidCalc, sizeof( mso_sptTrapezoidCalc ) / sizeof( SvxMSDffCalculationData ),
379 (sal_Int32*)mso_sptDefault5400,
380 (SvxMSDffTextRectangles*)mso_sptTrapezoidTextRect, sizeof( mso_sptTrapezoidTextRect ) / sizeof( SvxMSDffTextRectangles ),
381 21600, 21600,
382 0x80000000, 0x80000000,
383 (SvxMSDffVertPair*)mso_sptTrapezoidGluePoints, sizeof( mso_sptTrapezoidGluePoints ) / sizeof( SvxMSDffVertPair )
384 };
385
386 static const SvxMSDffVertPair mso_sptOctagonVert[] = // adjustment1 : 0 - 10800
387 {
388 { 0 MSO_I, 0 }, { 2 MSO_I, 0 }, { 21600, 1 MSO_I }, { 21600, 3 MSO_I },
389 { 2 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0, 3 MSO_I }, { 0, 1 MSO_I }
390 };
391 static const sal_uInt16 mso_sptOctagonSegm[] =
392 {
393 0x4000, 0x0007, 0x6001, 0x8000
394 };
395 static const SvxMSDffCalculationData mso_sptOctagonCalc[] =
396 {
397 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
398 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
399 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
400 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
401 { 0x2001, DFF_Prop_adjustValue, 1, 2 },
402 { 0x6000, DFF_Prop_geoLeft, 0x404, 0 },
403 { 0x6000, DFF_Prop_geoTop, 0x404, 0 },
404 { 0xa000, DFF_Prop_geoRight, 0, 0x404 },
405 { 0xa000, DFF_Prop_geoBottom, 0, 0x404 }
406 };
407 static const sal_Int32 mso_sptOctagonDefault[] =
408 {
409 1, 5000
410 };
411 static const SvxMSDffTextRectangles mso_sptOctagonTextRect[] =
412 {
413 { { 5 MSO_I, 6 MSO_I }, { 7 MSO_I, 8 MSO_I } }
414 };
415 static const mso_CustomShape msoOctagon =
416 {
417 (SvxMSDffVertPair*)mso_sptOctagonVert, sizeof( mso_sptOctagonVert ) / sizeof( SvxMSDffVertPair ),
418 (sal_uInt16*)mso_sptOctagonSegm, sizeof( mso_sptOctagonSegm ) >> 1,
419 (SvxMSDffCalculationData*)mso_sptOctagonCalc, sizeof( mso_sptOctagonCalc ) / sizeof( SvxMSDffCalculationData ),
420 (sal_Int32*)mso_sptOctagonDefault,
421 (SvxMSDffTextRectangles*)mso_sptOctagonTextRect, sizeof( mso_sptOctagonTextRect ) / sizeof( SvxMSDffTextRectangles ),
422 21600, 21600,
423 0x80000000, 0x80000000,
424 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
425 };
426
427 static const SvxMSDffVertPair mso_sptIsocelesTriangleVert[] = // adjustment1 : 0 - 21600
428 {
429 { 0 MSO_I, 0 }, { 21600, 21600 }, { 0, 21600 }
430 };
431 static const sal_uInt16 mso_sptIsocelesTriangleSegm[] =
432 {
433 0x4000, 0x0002, 0x6001, 0x8000
434 };
435 static const SvxMSDffCalculationData mso_sptIsocelesTriangleCalc[] =
436 {
437 { 0x4000, 0, DFF_Prop_adjustValue, 0 },
438 { 0x2001, DFF_Prop_adjustValue, 1, 2 },
439 { 0x2000, 0x401, 10800, 0 },
440 { 0x2001, DFF_Prop_adjustValue, 2, 3 },
441 { 0x2000, 0x403, 7200, 0 },
442 { 0x8000, 21600, 0, 0x400 },
443 { 0x2001, 0x405, 1, 2 },
444 { 0x8000, 21600, 0, 0x406 }
445 };
446 static const SvxMSDffTextRectangles mso_sptIsocelesTriangleTextRect[] =
447 {
448 { { 1 MSO_I, 10800 }, { 2 MSO_I, 18000 } },
449 { { 3 MSO_I, 7200 }, { 4 MSO_I, 21600 } }
450 };
451 static const SvxMSDffVertPair mso_sptIsocelesTriangleGluePoints[] =
452 {
453 { 10800, 0 }, { 1 MSO_I, 10800 }, { 0, 21600 }, { 10800, 21600 }, { 21600, 21600 }, { 7 MSO_I, 10800 }
454 };
455 static const mso_CustomShape msoIsocelesTriangle =
456 {
457 (SvxMSDffVertPair*)mso_sptIsocelesTriangleVert, sizeof( mso_sptIsocelesTriangleVert ) / sizeof( SvxMSDffVertPair ),
458 (sal_uInt16*)mso_sptIsocelesTriangleSegm, sizeof( mso_sptIsocelesTriangleSegm ) >> 1,
459 (SvxMSDffCalculationData*)mso_sptIsocelesTriangleCalc, sizeof( mso_sptIsocelesTriangleCalc ) / sizeof( SvxMSDffCalculationData ),
460 (sal_Int32*)mso_sptDefault10800,
461 (SvxMSDffTextRectangles*)mso_sptIsocelesTriangleTextRect, sizeof( mso_sptIsocelesTriangleTextRect ) / sizeof( SvxMSDffTextRectangles ),
462 21600, 21600,
463 0x80000000, 0x80000000,
464 (SvxMSDffVertPair*)mso_sptIsocelesTriangleGluePoints, sizeof( mso_sptIsocelesTriangleGluePoints ) / sizeof( SvxMSDffVertPair )
465 };
466
467 static const SvxMSDffVertPair mso_sptHexagonVert[] = // adjustment1 : 0 - 10800
468 {
469 { 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 21600, 10800 }, { 1 MSO_I, 21600 },
470 { 0 MSO_I, 21600 }, { 0, 10800 }
471 };
472 static const sal_uInt16 mso_sptHexagonSegm[] =
473 {
474 0x4000, 0x0005, 0x6001, 0x8000
475 };
476 static const SvxMSDffCalculationData mso_sptHexagonCalc[] =
477 {
478 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
479 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
480 { 0x2001, DFF_Prop_adjustValue, 100, 234 },
481 { 0x2000, 0x402, 1700, 0 },
482 { 0x8000, 21600, 0, 0x403 }
483 };
484 static const SvxMSDffTextRectangles mso_sptHexagonTextRect[] =
485 {
486 { { 3 MSO_I, 3 MSO_I }, { 4 MSO_I, 4 MSO_I } }
487 };
488 static const mso_CustomShape msoHexagon =
489 {
490 (SvxMSDffVertPair*)mso_sptHexagonVert, sizeof( mso_sptHexagonVert ) / sizeof( SvxMSDffVertPair ),
491 (sal_uInt16*)mso_sptHexagonSegm, sizeof( mso_sptHexagonSegm ) >> 1,
492 (SvxMSDffCalculationData*)mso_sptHexagonCalc, sizeof( mso_sptHexagonCalc ) / sizeof( SvxMSDffCalculationData ),
493 (sal_Int32*)mso_sptDefault5400,
494 (SvxMSDffTextRectangles*)mso_sptHexagonTextRect, sizeof( mso_sptHexagonTextRect ) / sizeof( SvxMSDffTextRectangles ),
495 21600, 21600,
496 0x80000000, 0x80000000,
497 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
498 };
499
500 static const SvxMSDffVertPair mso_sptPentagonVert[] =
501 {
502 { 10800, 0 }, { 0, 8260 }, { 4230, 21600 }, { 17370, 21600 },
503 { 21600, 8260 }, { 10800, 0 }
504 };
505 static const SvxMSDffTextRectangles mso_sptPentagonTextRect[] =
506 {
507 { { 4230, 5080 }, { 17370, 21600 } }
508 };
509 static const SvxMSDffVertPair mso_sptPentagonGluePoints[] =
510 {
511 { 10800, 0 }, { 0, 8260 }, { 4230, 21600 }, { 10800, 21600 },
512 { 17370, 21600 }, { 21600, 8260 }
513 };
514 static const mso_CustomShape msoPentagon =
515 {
516 (SvxMSDffVertPair*)mso_sptPentagonVert, sizeof( mso_sptPentagonVert ) / sizeof( SvxMSDffVertPair ),
517 NULL, 0,
518 NULL, 0,
519 NULL,
520 (SvxMSDffTextRectangles*)mso_sptPentagonTextRect, sizeof( mso_sptPentagonTextRect ) / sizeof( SvxMSDffTextRectangles ),
521 21600, 21600,
522 0x80000000, 0x80000000,
523 (SvxMSDffVertPair*)mso_sptPentagonGluePoints, sizeof( mso_sptPentagonGluePoints ) / sizeof( SvxMSDffVertPair )
524 };
525
526 static const SvxMSDffVertPair mso_sptPlusVert[] = // adjustment1 : 0 - 10800
527 {
528 { 1 MSO_I, 0 }, { 2 MSO_I, 0 }, { 2 MSO_I, 1 MSO_I }, { 21600, 1 MSO_I },
529 { 21600, 2 MSO_I }, { 2 MSO_I, 2 MSO_I }, { 2 MSO_I, 21600 }, { 1 MSO_I, 21600 },
530 { 1 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }, { 0, 1 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 0 }
531 };
532 static const SvxMSDffCalculationData mso_sptPlusCalc[] =
533 {
534 { 0x2001, DFF_Prop_adjustValue, 10799, 10800 },
535 { 0x2000, 0x400, 0, 0 },
536 { 0x8000, 21600, 0, 0x400 }
537 };
538 static const SvxMSDffTextRectangles mso_sptPlusTextRect[] =
539 {
540 { { 1 MSO_I, 1 MSO_I }, { 2 MSO_I, 2 MSO_I } }
541 };
542 static const mso_CustomShape msoPlus =
543 {
544 (SvxMSDffVertPair*)mso_sptPlusVert, sizeof( mso_sptPlusVert ) / sizeof( SvxMSDffVertPair ),
545 NULL, 0,
546 (SvxMSDffCalculationData*)mso_sptPlusCalc, sizeof( mso_sptPlusCalc ) / sizeof( SvxMSDffCalculationData ),
547 (sal_Int32*)mso_sptDefault5400,
548 (SvxMSDffTextRectangles*)mso_sptPlusTextRect, sizeof( mso_sptPlusTextRect ) / sizeof( SvxMSDffTextRectangles ),
549 21600, 21600,
550 10800, 10800,
551 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
552 };
553
554 static const SvxMSDffVertPair mso_sptCanVert[] = // adjustment1 : 0 - 10800
555 {
556 { 44, 0 },
557 { 20, 0 }, { 0, 2 MSO_I }, { 0, 0 MSO_I }, // ccp
558 { 0, 3 MSO_I }, // p
559 { 0, 4 MSO_I }, { 20, 10800 }, { 44, 10800 }, // ccp
560 { 68, 10800 }, { 88, 4 MSO_I }, { 88, 3 MSO_I }, // ccp
561 { 88, 0 MSO_I }, // p
562 { 88, 2 MSO_I }, { 68, 0 }, { 44, 0 }, // ccp
563 { 44, 0 }, // p
564 { 20, 0 }, { 0, 2 MSO_I }, { 0, 0 MSO_I }, // ccp
565 { 0, 5 MSO_I }, { 20, 6 MSO_I }, { 44, 6 MSO_I }, // ccp
566 { 68, 6 MSO_I },{ 88, 5 MSO_I }, { 88, 0 MSO_I }, // ccp
567 { 88, 2 MSO_I },{ 68, 0 }, { 44, 0 } // ccp
568 };
569 static const sal_uInt16 mso_sptCanSegm[] =
570 {
571 0x4000, 0x2001, 0x0001, 0x2002, 0x0001, 0x2001, 0x6001, 0x8000,
572 0x4000, 0x2004, 0x6001, 0x8000
573 };
574 static const SvxMSDffCalculationData mso_sptCanCalc[] =
575 {
576 { 0x2001, DFF_Prop_adjustValue, 1, 4 }, // 1/4
577 { 0x2001, 0x0400, 6, 11 },
578 { 0xa000, 0x0400, 0, 0x0401 },
579 { 0x8000, 10800, 0, 0x0400 },
580 { 0x6000, 0x0403, 0x0401, 0 },
581 { 0x6000, 0x0400, 0x0401, 0 },
582 { 0x2001, DFF_Prop_adjustValue, 1, 2 }
583 };
584 static const SvxMSDffTextRectangles mso_sptCanTextRect[] =
585 {
586 { { 0, 6 MSO_I }, { 88, 3 MSO_I } }
587 };
588 static const SvxMSDffVertPair mso_sptCanGluePoints[] =
589 {
590 { 44, 6 MSO_I }, { 44, 0 }, { 0, 5400 }, { 44, 10800 }, { 88, 5400 }
591 };
592 static const sal_Int32 mso_sptCanBoundRect[] =
593 {
594 0, 0, 88, 10800
595 };
596 static const mso_CustomShape msoCan =
597 {
598 (SvxMSDffVertPair*)mso_sptCanVert, sizeof( mso_sptCanVert ) / sizeof( SvxMSDffVertPair ),
599 (sal_uInt16*)mso_sptCanSegm, sizeof( mso_sptCanSegm ) >> 1,
600 (SvxMSDffCalculationData*)mso_sptCanCalc, sizeof( mso_sptCanCalc ) / sizeof( SvxMSDffCalculationData ),
601 (sal_Int32*)mso_sptDefault5400,
602 (SvxMSDffTextRectangles*)mso_sptCanTextRect, sizeof( mso_sptCanTextRect ) / sizeof( SvxMSDffTextRectangles ),
603 88, 10800,
604 0x80000000, 0x80000000,
605 (SvxMSDffVertPair*)mso_sptCanGluePoints, sizeof( mso_sptCanGluePoints ) / sizeof( SvxMSDffVertPair )
606 };
607
608 static const SvxMSDffVertPair mso_sptArrowVert[] = // adjustment1: x 0 - 21600
609 { // adjustment2: y 0 - 10800
610 { 0, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 21600, 10800 },
611 { 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }
612 };
613 static const sal_uInt16 mso_sptArrowSegm[] =
614 {
615 0x4000, 0x0006, 0x6001, 0x8000
616 };
617 static const SvxMSDffCalculationData mso_sptArrowCalc[] =
618 {
619 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
620 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
621 { 0x8000, 21600, 0, DFF_Prop_adjust2Value },
622 { 0x8000, 21600, 0, 0x401 },
623 { 0x6001, 0x403, 0x400, 10800 },
624 { 0x6000, 0x401, 0x404, 0 },
625 { 0x6001, 0x401, 0x400, 10800 },
626 { 0xa000, 0x401, 0, 0x406 }
627 };
628 static const SvxMSDffTextRectangles mso_sptArrowTextRect[] =
629 {
630 { { 0, 0 MSO_I }, { 5 MSO_I, 2 MSO_I } }
631 };
632 static const mso_CustomShape msoArrow =
633 {
634 (SvxMSDffVertPair*)mso_sptArrowVert, sizeof( mso_sptArrowVert ) / sizeof( SvxMSDffVertPair ),
635 (sal_uInt16*)mso_sptArrowSegm, sizeof( mso_sptArrowSegm ) >> 1,
636 (SvxMSDffCalculationData*)mso_sptArrowCalc, sizeof( mso_sptArrowCalc ) / sizeof( SvxMSDffCalculationData ),
637 (sal_Int32*)mso_sptDefault16200and5400,
638 (SvxMSDffTextRectangles*)mso_sptArrowTextRect, sizeof( mso_sptArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
639 21600, 21600,
640 0x80000000, 0x80000000,
641 NULL, 0
642 };
643
644 static const SvxMSDffVertPair mso_sptLeftArrowVert[] = // adjustment1: x 0 - 21600
645 { // adjustment2: y 0 - 10800
646 { 21600, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 0, 10800 },
647 { 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 21600, 2 MSO_I }
648 };
649 static const sal_uInt16 mso_sptLeftArrowSegm[] =
650 {
651 0x4000, 0x0006, 0x6001, 0x8000
652 };
653 static const sal_Int32 mso_sptLeftArrowDefault[] =
654 {
655 2, 5400, 5400
656 };
657 static const SvxMSDffTextRectangles mso_sptLeftArrowTextRect[] =
658 {
659 { { 7 MSO_I, 0 MSO_I }, { 21600, 2 MSO_I } }
660 };
661 static const mso_CustomShape msoLeftArrow =
662 {
663 (SvxMSDffVertPair*)mso_sptLeftArrowVert, sizeof( mso_sptLeftArrowVert ) / sizeof( SvxMSDffVertPair ),
664 (sal_uInt16*)mso_sptLeftArrowSegm, sizeof( mso_sptLeftArrowSegm ) >> 1,
665 (SvxMSDffCalculationData*)mso_sptArrowCalc, sizeof( mso_sptArrowCalc ) / sizeof( SvxMSDffCalculationData ),
666 (sal_Int32*)mso_sptLeftArrowDefault,
667 (SvxMSDffTextRectangles*)mso_sptLeftArrowTextRect, sizeof( mso_sptLeftArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
668 21600, 21600,
669 0x80000000, 0x80000000,
670 NULL, 0
671 };
672
673 static const SvxMSDffVertPair mso_sptDownArrowVert[] = // adjustment1: x 0 - 21600
674 { // adjustment2: y 0 - 10800
675 { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0, 1 MSO_I }, { 10800, 21600 },
676 { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 0 }
677 };
678 static const sal_uInt16 mso_sptDownArrowSegm[] =
679 {
680 0x4000, 0x0006, 0x6001, 0x8000
681 };
682 static const SvxMSDffTextRectangles mso_sptDownArrowTextRect[] =
683 {
684 { { 0 MSO_I, 0 }, { 2 MSO_I, 5 MSO_I } }
685 };
686 static const mso_CustomShape msoDownArrow =
687 {
688 (SvxMSDffVertPair*)mso_sptDownArrowVert, sizeof( mso_sptDownArrowVert ) / sizeof( SvxMSDffVertPair ),
689 (sal_uInt16*)mso_sptDownArrowSegm, sizeof( mso_sptDownArrowSegm ) >> 1,
690 (SvxMSDffCalculationData*)mso_sptArrowCalc, sizeof( mso_sptArrowCalc ) / sizeof( SvxMSDffCalculationData ),
691 (sal_Int32*)mso_sptDefault16200and5400,
692 (SvxMSDffTextRectangles*)mso_sptDownArrowTextRect, sizeof( mso_sptDownArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
693 21600, 21600,
694 0x80000000, 0x80000000,
695 NULL, 0
696 };
697
698 static const SvxMSDffVertPair mso_sptUpArrowVert[] = // adjustment1: x 0 - 21600
699 { // adjustment2: y 0 - 10800
700 { 0 MSO_I, 21600 }, { 0 MSO_I, 1 MSO_I }, { 0, 1 MSO_I }, { 10800, 0 },
701 { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 21600 }
702 };
703 static const sal_uInt16 mso_sptUpArrowSegm[] =
704 {
705 0x4000, 0x0006, 0x6001, 0x8000
706 };
707 static const sal_Int32 mso_sptUpArrowDefault[] =
708 {
709 2, 5400, 5400
710 };
711 static const SvxMSDffTextRectangles mso_sptUpArrowTextRect[] =
712 {
713 { { 0 MSO_I, 7 MSO_I }, { 2 MSO_I, 21600 } }
714 };
715 static const mso_CustomShape msoUpArrow =
716 {
717 (SvxMSDffVertPair*)mso_sptUpArrowVert, sizeof( mso_sptUpArrowVert ) / sizeof( SvxMSDffVertPair ),
718 (sal_uInt16*)mso_sptUpArrowSegm, sizeof( mso_sptUpArrowSegm ) >> 1,
719 (SvxMSDffCalculationData*)mso_sptArrowCalc, sizeof( mso_sptArrowCalc ) / sizeof( SvxMSDffCalculationData ),
720 (sal_Int32*)mso_sptUpArrowDefault,
721 (SvxMSDffTextRectangles*)mso_sptUpArrowTextRect, sizeof( mso_sptUpArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
722 21600, 21600,
723 0x80000000, 0x80000000,
724 NULL, 0
725 };
726
727 static const SvxMSDffVertPair mso_sptLeftRightArrowVert[] = // adjustment1: x 0 - 10800
728 { // adjustment2: y 0 - 10800
729 { 0, 10800 }, { 0 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I },
730 { 2 MSO_I, 0 }, { 21600, 10800 }, { 2 MSO_I, 21600 }, { 2 MSO_I, 3 MSO_I },
731 { 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 21600 }
732 };
733 static const sal_uInt16 mso_sptLeftRightArrowSegm[] =
734 {
735 0x4000, 0x0009, 0x6001, 0x8000
736 };
737 static const SvxMSDffCalculationData mso_sptDoubleArrowCalc[] =
738 {
739 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
740 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
741 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
742 { 0x8000, 21600, 0, DFF_Prop_adjust2Value },
743 { 0x8000, 10800, 0, DFF_Prop_adjust2Value },
744 { 0x6001, DFF_Prop_adjustValue, 0x404, 10800 },
745 { 0x8000, 21600, 0, 0x405 },
746 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
747 { 0x6001, DFF_Prop_adjust2Value, 0x407, 10800 },
748 { 0x8000, 21600, 0, 0x408 }
749 };
750 static const sal_Int32 mso_sptLeftRightArrowDefault[] =
751 {
752 2, 4300, 5400
753 };
754 static const SvxMSDffTextRectangles mso_sptLeftRightArrowTextRect[] =
755 {
756 { { 5 MSO_I, 1 MSO_I }, { 6 MSO_I, 3 MSO_I } }
757 };
758 static const mso_CustomShape msoLeftRightArrow =
759 {
760 (SvxMSDffVertPair*)mso_sptLeftRightArrowVert, sizeof( mso_sptLeftRightArrowVert ) / sizeof( SvxMSDffVertPair ),
761 (sal_uInt16*)mso_sptLeftRightArrowSegm, sizeof( mso_sptLeftRightArrowSegm ) >> 1,
762 (SvxMSDffCalculationData*)mso_sptDoubleArrowCalc, sizeof( mso_sptDoubleArrowCalc ) / sizeof( SvxMSDffCalculationData ),
763 (sal_Int32*)mso_sptLeftRightArrowDefault,
764 (SvxMSDffTextRectangles*)mso_sptLeftRightArrowTextRect, sizeof( mso_sptLeftRightArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
765 21600, 21600,
766 0x80000000, 0x80000000,
767 NULL, 0
768 };
769
770 static const SvxMSDffVertPair mso_sptUpDownArrowVert[] = // adjustment1: x 0 - 10800
771 { // adjustment2: y 0 - 10800
772 { 0, 1 MSO_I }, { 10800, 0 }, { 21600, 1 MSO_I }, { 2 MSO_I, 1 MSO_I },
773 { 2 MSO_I, 3 MSO_I }, { 21600, 3 MSO_I }, { 10800, 21600 }, { 0, 3 MSO_I },
774 { 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 1 MSO_I }
775 };
776 static const sal_uInt16 mso_sptUpDownArrowSegm[] =
777 {
778 0x4000, 0x0009, 0x6001, 0x8000
779 };
780 static const sal_Int32 mso_sptUpDownArrowDefault[] =
781 {
782 2, 5400, 4300
783 };
784 static const SvxMSDffTextRectangles mso_sptUpDownArrowTextRect[] =
785 {
786 { { 0 MSO_I, 8 MSO_I }, { 2 MSO_I, 9 MSO_I } }
787 };
788 static const mso_CustomShape msoUpDownArrow =
789 {
790 (SvxMSDffVertPair*)mso_sptUpDownArrowVert, sizeof( mso_sptUpDownArrowVert ) / sizeof( SvxMSDffVertPair ),
791 (sal_uInt16*)mso_sptUpDownArrowSegm, sizeof( mso_sptUpDownArrowSegm ) >> 1,
792 (SvxMSDffCalculationData*)mso_sptDoubleArrowCalc, sizeof( mso_sptDoubleArrowCalc ) / sizeof( SvxMSDffCalculationData ),
793 (sal_Int32*)mso_sptUpDownArrowDefault,
794 (SvxMSDffTextRectangles*)mso_sptUpDownArrowTextRect, sizeof( mso_sptUpDownArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
795 21600, 21600,
796 0x80000000, 0x80000000,
797 NULL, 0
798 };
799
800 static const SvxMSDffVertPair mso_sptQuadArrowVert[] = // adjustment1: x 0 - 10800, adjustment2: x 0 - 10800
801 { // adjustment3: y 0 - 10800
802 { 0, 10800 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 2 MSO_I, 2 MSO_I },
803 { 2 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 10800, 0 }, { 3 MSO_I, 0 MSO_I },
804 { 4 MSO_I, 0 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 5 MSO_I, 1 MSO_I },
805 { 21600, 10800 }, { 5 MSO_I, 3 MSO_I }, { 5 MSO_I, 4 MSO_I }, { 4 MSO_I, 4 MSO_I },
806 { 4 MSO_I, 5 MSO_I }, { 3 MSO_I, 5 MSO_I }, { 10800, 21600 }, { 1 MSO_I, 5 MSO_I },
807 { 2 MSO_I, 5 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 0 MSO_I, 4 MSO_I }, { 0 MSO_I, 3 MSO_I }
808 };
809 static const sal_uInt16 mso_sptQuadArrowSegm[] =
810 {
811 0x4000, 0x0017, 0x6001, 0x8000
812 };
813 static const SvxMSDffCalculationData mso_sptQuadArrowCalc[] =
814 {
815 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
816 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
817 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
818 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
819 { 0x8000, 21600, 0, DFF_Prop_adjust2Value },
820 { 0x8000, 21600, 0, DFF_Prop_adjust3Value }
821 };
822 static const sal_Int32 mso_sptQuadArrowDefault[] =
823 {
824 3, 6500, 8600, 4300
825 };
826 static const SvxMSDffTextRectangles mso_sptQuadArrowTextRect[] = // todo
827 {
828 { { 0, 0 }, { 21600, 21600 } }
829 };
830 static const mso_CustomShape msoQuadArrow =
831 {
832 (SvxMSDffVertPair*)mso_sptQuadArrowVert, sizeof( mso_sptQuadArrowVert ) / sizeof( SvxMSDffVertPair ),
833 (sal_uInt16*)mso_sptQuadArrowSegm, sizeof( mso_sptQuadArrowSegm ) >> 1,
834 (SvxMSDffCalculationData*)mso_sptQuadArrowCalc, sizeof( mso_sptQuadArrowCalc ) / sizeof( SvxMSDffCalculationData ),
835 (sal_Int32*)mso_sptQuadArrowDefault,
836 (SvxMSDffTextRectangles*)mso_sptQuadArrowTextRect, sizeof( mso_sptQuadArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
837 21600, 21600,
838 0x80000000, 0x80000000,
839 NULL, 0
840 };
841
842 static const SvxMSDffVertPair mso_sptLeftRightUpArrowVert[] = // adjustment1: x 0 - 10800, adjustment2: x 0 - 10800
843 { // adjustment3: y 0 - 21600
844 { 10800, 0 }, { 3 MSO_I, 2 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 4 MSO_I, 1 MSO_I },
845 { 5 MSO_I, 1 MSO_I }, { 5 MSO_I, 0 MSO_I }, { 21600, 10800 }, { 5 MSO_I, 3 MSO_I },
846 { 5 MSO_I, 4 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0, 10800 },
847 { 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 2 MSO_I },
848 { 0 MSO_I, 2 MSO_I }
849 };
850 static const sal_uInt16 mso_sptLeftRightUpArrowSegm[] =
851 {
852 0x4000, 0x0010, 0x6001, 0x8000
853 };
854 static const SvxMSDffCalculationData mso_sptLeftRightUpArrowCalc[] =
855 {
856 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0
857 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 1
858 { 0x6001, 0x0403, DFF_Prop_adjust3Value, 21600 }, // 2
859 { 0x8000, 21600, 0, DFF_Prop_adjustValue }, // 3
860 { 0x8000, 21600, 0, DFF_Prop_adjust2Value }, // 4
861 { 0x8000, 21600, 0, 0x0402 } // 5
862 };
863 static const sal_Int32 mso_sptLeftRightUpArrowDefault[] =
864 {
865 3, 6500, 8600, 6200
866 };
867 static const SvxMSDffTextRectangles mso_sptLeftRightUpArrowTextRect[] = // todo
868 {
869 { { 0, 0 }, { 21600, 21600 } }
870 };
871 static const mso_CustomShape msoLeftRightUpArrow =
872 {
873 (SvxMSDffVertPair*)mso_sptLeftRightUpArrowVert, sizeof( mso_sptLeftRightUpArrowVert ) / sizeof( SvxMSDffVertPair ),
874 (sal_uInt16*)mso_sptLeftRightUpArrowSegm, sizeof( mso_sptLeftRightUpArrowSegm ) >> 1,
875 (SvxMSDffCalculationData*)mso_sptLeftRightUpArrowCalc, sizeof( mso_sptLeftRightUpArrowCalc ) / sizeof( SvxMSDffCalculationData ),
876 (sal_Int32*)mso_sptLeftRightUpArrowDefault,
877 (SvxMSDffTextRectangles*)mso_sptLeftRightUpArrowTextRect, sizeof( mso_sptLeftRightUpArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
878 21600, 21600,
879 0x80000000, 0x80000000,
880 NULL, 0
881 };
882
883 static const SvxMSDffVertPair mso_sptBentArrowVert[] = // adjustment1 : x 12427 - 21600
884 { // adjustment2 : y 0 - 6079
885 { 0, 21600 }, { 0, 12160 }, { 12427, 1 MSO_I }, { 0 MSO_I, 1 MSO_I },
886 { 0 MSO_I, 0 }, { 21600, 6079 }, { 0 MSO_I, 12158 }, { 0 MSO_I, 2 MSO_I },
887 { 12427, 2 MSO_I }, { 4 MSO_I, 12160 }, { 4 MSO_I, 21600 }
888 };
889 static const sal_uInt16 mso_sptBentArrowSegm[] =
890 {
891 0x4000, 0x0001, 0xa801, 0x0006, 0xa701, 0x0001, 0x6001, 0x8000
892 };
893 static const SvxMSDffCalculationData mso_sptBentArrowCalc[] =
894 {
895 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
896 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
897 { 0x8000, 12158, 0, DFF_Prop_adjust2Value },
898 { 0x8000, 6079, 0, DFF_Prop_adjust2Value },
899 { 0x2001, 0x0403, 2, 1 }
900 };
901 static const sal_Int32 mso_sptBentArrowDefault[] =
902 {
903 2, 15100, 2900
904 };
905 static const SvxMSDffTextRectangles mso_sptBentArrowTextRect[] = // todo
906 {
907 { { 0, 0 }, { 21600, 21600 } }
908 };
909 static const mso_CustomShape msoBentArrow =
910 {
911 (SvxMSDffVertPair*)mso_sptBentArrowVert, sizeof( mso_sptBentArrowVert ) / sizeof( SvxMSDffVertPair ),
912 (sal_uInt16*)mso_sptBentArrowSegm, sizeof( mso_sptBentArrowSegm ) >> 1,
913 (SvxMSDffCalculationData*)mso_sptBentArrowCalc, sizeof( mso_sptBentArrowCalc ) / sizeof( SvxMSDffCalculationData ),
914 (sal_Int32*)mso_sptBentArrowDefault,
915 (SvxMSDffTextRectangles*)mso_sptBentArrowTextRect, sizeof( mso_sptBentArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
916 21600, 21600,
917 0x80000000, 0x80000000,
918 NULL, 0
919 };
920
921 static const SvxMSDffVertPair mso_sptUturnArrowVert[] =
922 {
923 { 0, 21600 }, { 0, 8550 }, // pp
924 { 0, 3540 }, { 4370, 0 }, { 9270, 0 }, // ccp
925 { 13890, 0 }, { 18570, 3230 }, { 18600, 8300 }, // ccp
926 { 21600, 8300 }, { 15680, 14260 }, { 9700, 8300 }, { 12500, 8300 }, // pppp
927 { 12320, 6380 }, { 10870, 5850 }, { 9320, 5850 }, // ccp
928 { 7770, 5850 }, { 6040, 6410 }, { 6110, 8520 }, // ccp
929 { 6110, 21600 }
930 };
931 static const sal_uInt16 mso_sptUturnArrowSegm[] =
932 {
933 0x4000, 0x0001, 0x2002, 0x0004, 0x2002, 0x0001, 0x6000, 0x8000
934 };
935 static const SvxMSDffTextRectangles mso_sptUturnArrowTextRect[] =
936 {
937 { { 0, 8280 }, { 6110, 21600 } }
938 };
939 static const mso_CustomShape msoUturnArrow =
940 {
941 (SvxMSDffVertPair*)mso_sptUturnArrowVert, sizeof( mso_sptUturnArrowVert ) / sizeof( SvxMSDffVertPair ),
942 (sal_uInt16*)mso_sptUturnArrowSegm, sizeof( mso_sptUturnArrowSegm ) >> 1,
943 NULL, 0,
944 NULL,
945 (SvxMSDffTextRectangles*)mso_sptUturnArrowTextRect, sizeof( mso_sptUturnArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
946 21600, 21600,
947 0x80000000, 0x80000000,
948 NULL, 0
949 };
950
951 static const SvxMSDffVertPair mso_sptLeftUpArrowVert[] = // adjustment1 : x 0 - 21600, adjustment2 : x 0 - 21600
952 { // adjustment3 : y 0 - 21600
953 { 0, 5 MSO_I }, { 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 7 MSO_I }, { 7 MSO_I, 7 MSO_I },
954 { 7 MSO_I, 2 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 5 MSO_I, 0 }, { 21600, 2 MSO_I },
955 { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 21600 }
956 };
957 static const sal_uInt16 mso_sptLeftUpArrowSegm[] =
958 {
959 0x4000, 0x000b, 0x6001, 0x8000
960 };
961 static const SvxMSDffCalculationData mso_sptLeftUpArrowCalc[] =
962 {
963 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0
964 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 1
965 { 0x2000, DFF_Prop_adjust3Value, 0, 0 }, // 2
966 { 0x8000, 21600, 0, DFF_Prop_adjustValue }, // 3
967 { 0x2001, 0x0403, 1, 2 }, // 4
968 { 0x6000, DFF_Prop_adjustValue, 0x0404, 0 }, // 5
969 { 0x8000, 21600, 0, DFF_Prop_adjust2Value }, // 6
970 { 0x6000, DFF_Prop_adjustValue, 0x0406, 0 } // 7
971 };
972 static const sal_Int32 mso_sptLeftUpArrowDefault[] =
973 {
974 3, 9340, 18500, 6200
975 };
976 static const SvxMSDffTextRectangles mso_sptLeftUpArrowTextRect[] =
977 {
978 { { 2 MSO_I, 7 MSO_I }, { 1 MSO_I, 1 MSO_I } },
979 { { 7 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I } }
980 };
981 static const mso_CustomShape msoLeftUpArrow =
982 {
983 (SvxMSDffVertPair*)mso_sptLeftUpArrowVert, sizeof( mso_sptLeftUpArrowVert ) / sizeof( SvxMSDffVertPair ),
984 (sal_uInt16*)mso_sptLeftUpArrowSegm, sizeof( mso_sptLeftUpArrowSegm ) >> 1,
985 (SvxMSDffCalculationData*)mso_sptLeftUpArrowCalc, sizeof( mso_sptLeftUpArrowCalc ) / sizeof( SvxMSDffCalculationData ),
986 (sal_Int32*)mso_sptLeftUpArrowDefault,
987 (SvxMSDffTextRectangles*)mso_sptLeftUpArrowTextRect, sizeof( mso_sptLeftUpArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
988 21600, 21600,
989 0x80000000, 0x80000000,
990 NULL, 0
991 };
992
993 static const SvxMSDffVertPair mso_sptBentUpArrowVert[] = // adjustment1 : x 0 - 21600, adjustment2 : x 0 - 21600
994 { // adjustment3 : y 0 - 21600
995 { 0, 8 MSO_I }, { 7 MSO_I, 8 MSO_I }, { 7 MSO_I, 2 MSO_I }, { 0 MSO_I, 2 MSO_I },
996 { 5 MSO_I, 0 }, { 21600, 2 MSO_I }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 21600 },
997 { 0, 21600 }
998 };
999 static const sal_uInt16 mso_sptBentUpArrowSegm[] =
1000 {
1001 0x4000, 0x0008, 0x6001, 0x8000
1002 };
1003 static const SvxMSDffCalculationData mso_sptBentUpArrowCalc[] =
1004 {
1005 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0
1006 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 1
1007 { 0x2000, DFF_Prop_adjust3Value, 0, 0 }, // 2
1008 { 0x8000, 21600, 0, DFF_Prop_adjustValue }, // 3
1009 { 0x2001, 0x0403, 1, 2 }, // 4
1010 { 0x6000, DFF_Prop_adjustValue, 0x0404, 0 }, // 5
1011 { 0x8000, 21600, 0, DFF_Prop_adjust2Value }, // 6
1012 { 0x6000, DFF_Prop_adjustValue, 0x0406, 0 }, // 7
1013 { 0x6000, 0x0407, 0x0406, 0 } // 8
1014 };
1015 static const sal_Int32 mso_sptBentUpArrowDefault[] =
1016 {
1017 3, 9340, 18500, 7200
1018 };
1019 static const SvxMSDffTextRectangles mso_sptBentUpArrowTextRect[] =
1020 {
1021 { { 2 MSO_I, 7 MSO_I }, { 1 MSO_I, 1 MSO_I } },
1022 { { 7 MSO_I, 2 MSO_I }, { 1 MSO_I, 1 MSO_I } }
1023 };
1024 static const mso_CustomShape msoBentUpArrow =
1025 {
1026 (SvxMSDffVertPair*)mso_sptBentUpArrowVert, sizeof( mso_sptBentUpArrowVert ) / sizeof( SvxMSDffVertPair ),
1027 (sal_uInt16*)mso_sptBentUpArrowSegm, sizeof( mso_sptBentUpArrowSegm ) >> 1,
1028 (SvxMSDffCalculationData*)mso_sptBentUpArrowCalc, sizeof( mso_sptBentUpArrowCalc ) / sizeof( SvxMSDffCalculationData ),
1029 (sal_Int32*)mso_sptBentUpArrowDefault,
1030 (SvxMSDffTextRectangles*)mso_sptBentUpArrowTextRect, sizeof( mso_sptBentUpArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
1031 21600, 21600,
1032 0x80000000, 0x80000000,
1033 NULL, 0
1034 };
1035
1036 static const SvxMSDffVertPair mso_sptCurvedArrowVert[] = // adjustment1 : y 10800 - 21600, adjustment2 : y 16424 - 21600
1037 { // adjustment3 : x 0 - 21600
1038 { 21600, 0 },
1039 { 9675, 0 }, { 0, 10 MSO_I }, { 0, 9 MSO_I }, // ccp
1040 { 0, 11 MSO_I },
1041 { 0, 14 MSO_I }, { 15 MSO_I, 1 MSO_I }, { 2 MSO_I, 1 MSO_I }, // ccp
1042 { 2 MSO_I, 21600 }, { 21600, 7 MSO_I }, { 2 MSO_I, 0 MSO_I }, { 2 MSO_I, 16 MSO_I },// pppp
1043 { 2 MSO_I, 16 MSO_I }, { 80, 8 MSO_I }, { 80, 8 MSO_I }, // ccp
1044 { 80, 8 MSO_I }, { 21600, 5 MSO_I }, { 21600, 0 } // ccp
1045 };
1046 static const sal_uInt16 mso_sptCurvedArrowSegm[] =
1047 {
1048 0x4000, 0x2001, 0x0001, 0x2001, 0x0004, 0x2002, 0x6001, 0x8000
1049 };
1050 static const SvxMSDffCalculationData mso_sptCurvedArrowCalc[] =
1051 {
1052 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0
1053 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 1
1054 { 0x2000, DFF_Prop_adjust3Value, 0, 0 }, // 2
1055 { 0x8000, 21600, 0, DFF_Prop_adjust2Value }, // 3
1056 { 0xa000, DFF_Prop_adjust2Value, 0, DFF_Prop_adjustValue }, // 4
1057 { 0xa000, 0x0404, 0, 0x0403 }, // 5
1058 { 0x2001, 0x0405, 1, 2 }, // 6
1059 { 0xa000, DFF_Prop_adjust2Value, 0, 0x0406 }, // 7
1060 { 0x2001, DFF_Prop_adjust2Value, 1, 2 }, // 8
1061 { 0xa000, 0x0408, 0, 0x0406 }, // 9
1062 { 0x2001, 0x0409, 10000, 22326 }, // 10
1063 { 0x6000, 0x0409, 0x0405, 0 }, // 11
1064 { 0xa000, DFF_Prop_adjust2Value, 0, 0x040b }, // 12
1065 { 0x2001, 0x040c, 10000, 23148 }, // 13
1066 { 0x6000, 0x040d, 0x040b, 0 }, // 14
1067 { 0x2001, DFF_Prop_adjust3Value, 10000, 25467 }, // 15
1068 { 0x6000, DFF_Prop_adjustValue, 0x0403, 0 } // 16
1069 };
1070 static const sal_Int32 mso_sptCurvedArrowDefault[] =
1071 {
1072 3, 13000, 19400, 14400
1073 };
1074 static const SvxMSDffTextRectangles mso_sptCurvedArrowTextRect[] = // todo
1075 {
1076 { { 0, 0 }, { 21600, 21600 } }
1077 };
1078 static const mso_CustomShape msoCurvedArrow =
1079 {
1080 (SvxMSDffVertPair*)mso_sptCurvedArrowVert, sizeof( mso_sptCurvedArrowVert ) / sizeof( SvxMSDffVertPair ),
1081 (sal_uInt16*)mso_sptCurvedArrowSegm, sizeof( mso_sptCurvedArrowSegm ) >> 1,
1082 (SvxMSDffCalculationData*)mso_sptCurvedArrowCalc, sizeof( mso_sptCurvedArrowCalc ) / sizeof( SvxMSDffCalculationData ),
1083 (sal_Int32*)mso_sptCurvedArrowDefault,
1084 (SvxMSDffTextRectangles*)mso_sptCurvedArrowTextRect, sizeof( mso_sptCurvedArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
1085 21600, 21600,
1086 0x80000000, 0x80000000,
1087 NULL, 0
1088 };
1089
1090 static const SvxMSDffVertPair mso_sptStripedRightArrowVert[] = // adjustment1 : x 3375 - 21600
1091 { // adjustment2 : y 0 - 10800
1092 { 3375, 0 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 1 MSO_I, 0 }, { 21600, 10800 },
1093 { 1 MSO_I, 21600 }, { 1 MSO_I, 2 MSO_I }, { 3375, 2 MSO_I }, { 0, 0 MSO_I },
1094 { 675, 0 MSO_I }, { 675, 2 MSO_I }, { 0, 2 MSO_I }, { 1350, 0 MSO_I },
1095 { 2700, 0 MSO_I }, { 2700, 2 MSO_I }, { 1350, 2 MSO_I }
1096 };
1097 static const sal_uInt16 mso_sptStripedRightArrowSegm[] =
1098 {
1099 0x4000, 0x0006, 0x6001, 0x8000,
1100 0x4000, 0x0003, 0x6001, 0x8000,
1101 0x4000, 0x0003, 0x6001, 0x8000
1102 };
1103 static const SvxMSDffCalculationData mso_sptStripedRightArrowCalc[] =
1104 {
1105 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1106 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1107 { 0x8000, 21600, 0, DFF_Prop_adjust2Value },
1108 { 0x8000, 21600, 0, 0x401 },
1109 { 0x6001, 0x403, 0x400, 10800 },
1110 { 0x6000, 0x401, 0x404, 0 }
1111 };
1112 static const SvxMSDffTextRectangles mso_sptStripedRightArrowTextRect[] =
1113 {
1114 { { 3375, 0 MSO_I }, { 5 MSO_I, 2 MSO_I } }
1115 };
1116 static const mso_CustomShape msoStripedRightArrow =
1117 {
1118 (SvxMSDffVertPair*)mso_sptStripedRightArrowVert, sizeof( mso_sptStripedRightArrowVert ) / sizeof( SvxMSDffVertPair ),
1119 (sal_uInt16*)mso_sptStripedRightArrowSegm, sizeof( mso_sptStripedRightArrowSegm ) >> 1,
1120 (SvxMSDffCalculationData*)mso_sptStripedRightArrowCalc, sizeof( mso_sptStripedRightArrowCalc ) / sizeof( SvxMSDffCalculationData ),
1121 (sal_Int32*)mso_sptDefault16200and5400,
1122 (SvxMSDffTextRectangles*)mso_sptStripedRightArrowTextRect, sizeof( mso_sptStripedRightArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
1123 21600, 21600,
1124 0x80000000, 0x80000000,
1125 NULL, 0
1126 };
1127
1128 static const SvxMSDffVertPair mso_sptNotchedRightArrowVert[] = // adjustment1 : x 0 - 21600 (default 16200)
1129 { // adjustment2 : y 0 - 10800 (default 5400)
1130 { 0, 1 MSO_I }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 0 }, { 21600, 10800 },
1131 { 0 MSO_I, 21600 }, { 0 MSO_I, 2 MSO_I }, { 0, 2 MSO_I }, { 5 MSO_I, 10800 }, { 0, 1 MSO_I }
1132 };
1133 static const SvxMSDffCalculationData mso_sptNotchedRightArrowCalc[] =
1134 {
1135 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1136 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1137 { 0x8000, 21600, 0, DFF_Prop_adjust2Value },
1138 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
1139 { 0x8000, 10800, 0, DFF_Prop_adjust2Value },
1140 { 0x6001, 0x403, 0x404, 10800 }
1141 };
1142 static const SvxMSDffTextRectangles mso_sptNotchedRightArrowTextRect[] = // todo
1143 {
1144 { { 0, 0 }, { 21600, 21600 } }
1145 };
1146 static const mso_CustomShape msoNotchedRightArrow =
1147 {
1148 (SvxMSDffVertPair*)mso_sptNotchedRightArrowVert, sizeof( mso_sptNotchedRightArrowVert ) / sizeof( SvxMSDffVertPair ),
1149 (sal_uInt16*)NULL, 0,
1150 (SvxMSDffCalculationData*)mso_sptNotchedRightArrowCalc, sizeof( mso_sptNotchedRightArrowCalc ) / sizeof( SvxMSDffCalculationData ),
1151 (sal_Int32*)mso_sptDefault16200and5400,
1152 (SvxMSDffTextRectangles*)mso_sptNotchedRightArrowTextRect, sizeof( mso_sptNotchedRightArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
1153 21600, 21600,
1154 0x80000000, 0x80000000,
1155 NULL, 0
1156 };
1157
1158 static const SvxMSDffVertPair mso_sptHomePlateVert[] = // adjustment1 : x 0 - 21600
1159 {
1160 { 0, 0 }, { 0 MSO_I, 0 }, { 21600, 10800 }, { 0 MSO_I, 21600 },
1161 { 0, 21600 }
1162 };
1163 static const sal_uInt16 mso_sptHomePlateSegm[] =
1164 {
1165 0x4000, 0x0004, 0x6001, 0x8000
1166 };
1167 static const SvxMSDffCalculationData mso_sptHomePlateCalc[] =
1168 {
1169 { 0x2000, DFF_Prop_adjustValue, 0, 0 }
1170 };
1171 static const sal_Int32 mso_sptHomePlateDefault[] =
1172 {
1173 1, 16200
1174 };
1175 static const SvxMSDffTextRectangles mso_sptHomePlateTextRect[] = // todo
1176 {
1177 { { 0, 0 }, { 21600, 21600 } }
1178 };
1179 static const mso_CustomShape msoHomePlate =
1180 {
1181 (SvxMSDffVertPair*)mso_sptHomePlateVert, sizeof( mso_sptHomePlateVert ) / sizeof( SvxMSDffVertPair ),
1182 (sal_uInt16*)mso_sptHomePlateSegm, sizeof( mso_sptHomePlateSegm ) >> 1,
1183 (SvxMSDffCalculationData*)mso_sptHomePlateCalc, sizeof( mso_sptHomePlateCalc ) / sizeof( SvxMSDffCalculationData ),
1184 (sal_Int32*)mso_sptHomePlateDefault,
1185 (SvxMSDffTextRectangles*)mso_sptHomePlateTextRect, sizeof( mso_sptHomePlateTextRect ) / sizeof( SvxMSDffTextRectangles ),
1186 21600, 21600,
1187 0x80000000, 0x80000000,
1188 NULL, 0
1189 };
1190
1191 static const SvxMSDffVertPair mso_sptChevronVert[] = // adjustment1 : x 0 - 21600
1192 {
1193 { 0, 0 }, { 0 MSO_I, 0 }, { 21600, 10800 }, { 0 MSO_I, 21600 },
1194 { 0, 21600 }, { 1 MSO_I, 10800 }
1195 };
1196 static const sal_uInt16 mso_sptChevronSegm[] =
1197 {
1198 0x4000, 0x0005, 0x6001, 0x8000
1199 };
1200 static const SvxMSDffCalculationData mso_sptChevronCalc[] =
1201 {
1202 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1203 { 0x8000, 21600, 0, 0x0400 }
1204 };
1205 static const sal_Int32 mso_sptChevronDefault[] =
1206 {
1207 1, 16200
1208 };
1209 static const SvxMSDffTextRectangles mso_sptChevronTextRect[] = // todo
1210 {
1211 { { 0, 0 }, { 21600, 21600 } }
1212 };
1213 static const mso_CustomShape msoChevron =
1214 {
1215 (SvxMSDffVertPair*)mso_sptChevronVert, sizeof( mso_sptChevronVert ) / sizeof( SvxMSDffVertPair ),
1216 (sal_uInt16*)mso_sptChevronSegm, sizeof( mso_sptChevronSegm ) >> 1,
1217 (SvxMSDffCalculationData*)mso_sptChevronCalc, sizeof( mso_sptChevronCalc ) / sizeof( SvxMSDffCalculationData ),
1218 (sal_Int32*)mso_sptChevronDefault,
1219 (SvxMSDffTextRectangles*)mso_sptChevronTextRect, sizeof( mso_sptChevronTextRect ) / sizeof( SvxMSDffTextRectangles ),
1220 21600, 21600,
1221 0x80000000, 0x80000000,
1222 NULL, 0
1223 };
1224
1225 static const SvxMSDffVertPair mso_sptRightArrowCalloutVert[] = // adjustment1 : x 0 - 21000
1226 { // adjustment2 : y 0 - 10800
1227 { 0, 0 }, { 0 MSO_I, 0 }, { 0 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I },
1228 { 2 MSO_I, 1 MSO_I }, { 21600, 10800 }, { 2 MSO_I, 4 MSO_I }, { 2 MSO_I, 5 MSO_I },
1229 { 0 MSO_I, 5 MSO_I }, { 0 MSO_I, 21600 }, { 0, 21600 }
1230 };
1231 static const sal_uInt16 mso_sptRightArrowCalloutSegm[] =
1232 {
1233 0x4000, 0x000a, 0x6001, 0x8000
1234 };
1235 static const SvxMSDffCalculationData mso_sptRightArrowCalloutCalc[] =
1236 {
1237 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1238 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1239 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1240 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1241 { 0x8000, 21600, 0, 0x0401 },
1242 { 0x8000, 21600, 0, 0x0403 }
1243 };
1244 static const sal_Int32 mso_sptRightArrowCalloutDefault[] =
1245 {
1246 4, 14400, 5400, 18000, 8100
1247 };
1248 static const SvxMSDffTextRectangles mso_sptRightArrowCalloutTextRect[] =
1249 {
1250 { { 0, 0 }, { 0 MSO_I, 21600 } }
1251 };
1252 static const mso_CustomShape msoRightArrowCallout =
1253 {
1254 (SvxMSDffVertPair*)mso_sptRightArrowCalloutVert, sizeof( mso_sptRightArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1255 (sal_uInt16*)mso_sptRightArrowCalloutSegm, sizeof( mso_sptRightArrowCalloutSegm ) >> 1,
1256 (SvxMSDffCalculationData*)mso_sptRightArrowCalloutCalc, sizeof( mso_sptRightArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1257 (sal_Int32*)mso_sptRightArrowCalloutDefault,
1258 (SvxMSDffTextRectangles*)mso_sptRightArrowCalloutTextRect, sizeof( mso_sptRightArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1259 21600, 21600,
1260 0x80000000, 0x80000000,
1261 NULL, 0
1262 };
1263
1264 static const SvxMSDffVertPair mso_sptLeftArrowCalloutVert[] = // adjustment1 : x 0 - 21600, adjustment2 : y 0 - 10800
1265 { // adjustment3 : x 0 - 21600, adjustment4 : y 0 - 10800
1266 { 0 MSO_I, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0 MSO_I, 21600 },
1267 { 0 MSO_I, 5 MSO_I }, { 2 MSO_I, 5 MSO_I }, { 2 MSO_I, 4 MSO_I }, { 0, 10800 },
1268 { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
1269 };
1270 static const sal_uInt16 mso_sptLeftArrowCalloutSegm[] =
1271 {
1272 0x4000, 0x000a, 0x6001, 0x8000
1273 };
1274 static const SvxMSDffCalculationData mso_sptLeftArrowCalloutCalc[] =
1275 {
1276 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1277 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1278 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1279 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1280 { 0x8000, 21600, 0, 0x0401 },
1281 { 0x8000, 21600, 0, 0x0403 }
1282 };
1283 static const sal_Int32 mso_sptLeftArrowCalloutDefault[] =
1284 {
1285 4, 7200, 5400, 3600, 8100
1286 };
1287 static const SvxMSDffTextRectangles mso_sptLeftArrowCalloutTextRect[] =
1288 {
1289 { { 0 MSO_I, 0 }, { 21600, 21600 } }
1290 };
1291 static const mso_CustomShape msoLeftArrowCallout =
1292 {
1293 (SvxMSDffVertPair*)mso_sptLeftArrowCalloutVert, sizeof( mso_sptLeftArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1294 (sal_uInt16*)mso_sptLeftArrowCalloutSegm, sizeof( mso_sptLeftArrowCalloutSegm ) >> 1,
1295 (SvxMSDffCalculationData*)mso_sptLeftArrowCalloutCalc, sizeof( mso_sptLeftArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1296 (sal_Int32*)mso_sptLeftArrowCalloutDefault,
1297 (SvxMSDffTextRectangles*)mso_sptLeftArrowCalloutTextRect, sizeof( mso_sptLeftArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1298 21600, 21600,
1299 0x80000000, 0x80000000,
1300 NULL, 0
1301 };
1302
1303 static const SvxMSDffVertPair mso_sptUpArrowCalloutVert[] =
1304 {
1305 { 21600, 0 MSO_I }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 MSO_I },
1306 { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I }, { 10800, 0 },
1307 { 4 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 5 MSO_I, 0 MSO_I }
1308 };
1309 static const sal_uInt16 mso_sptUpArrowCalloutSegm[] =
1310 {
1311 0x4000, 0x000a, 0x6001, 0x8000
1312 };
1313 static const SvxMSDffCalculationData mso_sptUpArrowCalloutCalc[] =
1314 {
1315 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1316 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1317 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1318 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1319 { 0x8000, 21600, 0, 0x0401 },
1320 { 0x8000, 21600, 0, 0x0403 }
1321 };
1322 static const sal_Int32 mso_sptUpArrowCalloutDefault[] =
1323 {
1324 4, 7200, 5400, 3600, 8100
1325 };
1326 static const SvxMSDffTextRectangles mso_sptUpArrowCalloutTextRect[] =
1327 {
1328 { { 0, 0 MSO_I }, { 21600, 21600 } }
1329 };
1330 static const mso_CustomShape msoUpArrowCallout =
1331 {
1332 (SvxMSDffVertPair*)mso_sptUpArrowCalloutVert, sizeof( mso_sptUpArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1333 (sal_uInt16*)mso_sptUpArrowCalloutSegm, sizeof( mso_sptUpArrowCalloutSegm ) >> 1,
1334 (SvxMSDffCalculationData*)mso_sptUpArrowCalloutCalc, sizeof( mso_sptUpArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1335 (sal_Int32*)mso_sptUpArrowCalloutDefault,
1336 (SvxMSDffTextRectangles*)mso_sptUpArrowCalloutTextRect, sizeof( mso_sptUpArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1337 21600, 21600,
1338 0x80000000, 0x80000000,
1339 NULL, 0
1340 };
1341
1342 static const SvxMSDffVertPair mso_sptDownArrowCalloutVert[] =
1343 {
1344 { 0, 0 MSO_I }, { 0, 0 }, { 21600, 0 }, { 21600, 0 MSO_I },
1345 { 5 MSO_I, 0 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 4 MSO_I, 2 MSO_I }, { 10800, 21600 },
1346 { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 0 MSO_I }
1347 };
1348 static const sal_uInt16 mso_sptDownArrowCalloutSegm[] =
1349 {
1350 0x4000, 0x000a, 0x6001, 0x8000
1351 };
1352 static const SvxMSDffCalculationData mso_sptDownArrowCalloutCalc[] =
1353 {
1354 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1355 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1356 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1357 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1358 { 0x8000, 21600, 0, 0x0401 },
1359 { 0x8000, 21600, 0, 0x0403 }
1360 };
1361 static const sal_Int32 mso_sptDownArrowCalloutDefault[] =
1362 {
1363 4, 14400, 5400, 18000, 8100
1364 };
1365 static const SvxMSDffTextRectangles mso_sptDownArrowCalloutTextRect[] =
1366 {
1367 { { 0, 0 }, { 21600, 0 MSO_I } }
1368 };
1369 static const mso_CustomShape msoDownArrowCallout =
1370 {
1371 (SvxMSDffVertPair*)mso_sptDownArrowCalloutVert, sizeof( mso_sptDownArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1372 (sal_uInt16*)mso_sptDownArrowCalloutSegm, sizeof( mso_sptDownArrowCalloutSegm ) >> 1,
1373 (SvxMSDffCalculationData*)mso_sptDownArrowCalloutCalc, sizeof( mso_sptDownArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1374 (sal_Int32*)mso_sptDownArrowCalloutDefault,
1375 (SvxMSDffTextRectangles*)mso_sptDownArrowCalloutTextRect, sizeof( mso_sptDownArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1376 21600, 21600,
1377 0x80000000, 0x80000000,
1378 NULL, 0
1379 };
1380
1381 static const SvxMSDffVertPair mso_sptLeftRightArrowCalloutVert[] =
1382 {
1383 { 0 MSO_I, 0 }, { 4 MSO_I, 0 }, { 4 MSO_I, 3 MSO_I }, { 6 MSO_I, 3 MSO_I },
1384 { 6 MSO_I, 1 MSO_I }, { 21600, 10800 }, { 6 MSO_I, 5 MSO_I }, { 6 MSO_I, 7 MSO_I },
1385 { 4 MSO_I, 7 MSO_I }, { 4 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0 MSO_I, 7 MSO_I },
1386 { 2 MSO_I, 7 MSO_I }, { 2 MSO_I, 5 MSO_I }, { 0, 10800 }, { 2 MSO_I, 1 MSO_I },
1387 { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
1388 };
1389 static const sal_uInt16 mso_sptLeftRightArrowCalloutSegm[] =
1390 {
1391 0x4000, 0x0011, 0x6001, 0x8000
1392 };
1393 static const SvxMSDffCalculationData mso_sptLeftRightArrowCalloutCalc[] =
1394 {
1395 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1396 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1397 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1398 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1399 { 0x8000, 21600, 0, 0x0400 },
1400 { 0x8000, 21600, 0, 0x0401 },
1401 { 0x8000, 21600, 0, 0x0402 },
1402 { 0x8000, 21600, 0, 0x0403 }
1403 };
1404 static const sal_Int32 mso_sptLeftRightArrowCalloutDefault[] =
1405 {
1406 4, 5400, 5500, 2700, 8100
1407 };
1408 static const SvxMSDffTextRectangles mso_sptLeftRightArrowCalloutTextRect[] =
1409 {
1410 { { 0 MSO_I, 0 }, { 4 MSO_I, 21600 } }
1411 };
1412 static const mso_CustomShape msoLeftRightArrowCallout =
1413 {
1414 (SvxMSDffVertPair*)mso_sptLeftRightArrowCalloutVert, sizeof( mso_sptLeftRightArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1415 (sal_uInt16*)mso_sptLeftRightArrowCalloutSegm, sizeof( mso_sptLeftRightArrowCalloutSegm ) >> 1,
1416 (SvxMSDffCalculationData*)mso_sptLeftRightArrowCalloutCalc, sizeof( mso_sptLeftRightArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1417 (sal_Int32*)mso_sptLeftRightArrowCalloutDefault,
1418 (SvxMSDffTextRectangles*)mso_sptLeftRightArrowCalloutTextRect, sizeof( mso_sptLeftRightArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1419 21600, 21600,
1420 0x80000000, 0x80000000,
1421 NULL, 0
1422 };
1423
1424 static const SvxMSDffVertPair mso_sptUpDownArrowCalloutVert[] =
1425 {
1426 { 0, 0 MSO_I }, { 0, 4 MSO_I }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 6 MSO_I },
1427 { 1 MSO_I, 6 MSO_I }, { 10800, 21600 }, { 5 MSO_I, 6 MSO_I }, { 7 MSO_I, 6 MSO_I },
1428 { 7 MSO_I, 4 MSO_I }, { 21600, 4 MSO_I }, { 21600, 0 MSO_I }, { 7 MSO_I, 0 MSO_I },
1429 { 7 MSO_I, 2 MSO_I }, { 5 MSO_I, 2 MSO_I }, { 10800, 0 }, { 1 MSO_I, 2 MSO_I },
1430 { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 0 MSO_I }
1431 };
1432 static const sal_uInt16 mso_sptUpDownArrowCalloutSegm[] =
1433 {
1434 0x4000, 0x0011, 0x6001, 0x8000
1435 };
1436 static const SvxMSDffCalculationData mso_sptUpDownArrowCalloutCalc[] =
1437 {
1438 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1439 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1440 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1441 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1442 { 0x8000, 21600, 0, 0x0400 },
1443 { 0x8000, 21600, 0, 0x0401 },
1444 { 0x8000, 21600, 0, 0x0402 },
1445 { 0x8000, 21600, 0, 0x0403 }
1446 };
1447 static const sal_Int32 mso_sptUpDownArrowCalloutDefault[] =
1448 {
1449 4, 5400, 5500, 2700, 8100
1450 };
1451 static const SvxMSDffTextRectangles mso_sptUpDownArrowCalloutTextRect[] =
1452 {
1453 { { 0, 0 MSO_I }, { 21600, 4 MSO_I } }
1454 };
1455 static const mso_CustomShape msoUpDownArrowCallout =
1456 {
1457 (SvxMSDffVertPair*)mso_sptUpDownArrowCalloutVert, sizeof( mso_sptUpDownArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1458 (sal_uInt16*)mso_sptUpDownArrowCalloutSegm, sizeof( mso_sptUpDownArrowCalloutSegm ) >> 1,
1459 (SvxMSDffCalculationData*)mso_sptUpDownArrowCalloutCalc, sizeof( mso_sptUpDownArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1460 (sal_Int32*)mso_sptUpDownArrowCalloutDefault,
1461 (SvxMSDffTextRectangles*)mso_sptUpDownArrowCalloutTextRect, sizeof( mso_sptUpDownArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1462 21600, 21600,
1463 0x80000000, 0x80000000,
1464 NULL, 0
1465 };
1466
1467 static const SvxMSDffVertPair mso_sptQuadArrowCalloutVert[] =
1468 {
1469 { 0 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
1470 { 10800, 0 }, { 5 MSO_I, 2 MSO_I }, { 7 MSO_I, 2 MSO_I }, { 7 MSO_I, 0 MSO_I },
1471 { 4 MSO_I, 0 MSO_I }, { 4 MSO_I, 3 MSO_I }, { 6 MSO_I, 3 MSO_I }, { 6 MSO_I, 1 MSO_I },
1472 { 21600, 10800 }, { 6 MSO_I, 5 MSO_I }, { 6 MSO_I, 7 MSO_I }, { 4 MSO_I, 7 MSO_I },
1473 { 4 MSO_I, 4 MSO_I }, { 7 MSO_I, 4 MSO_I }, { 7 MSO_I, 6 MSO_I }, { 5 MSO_I, 6 MSO_I },
1474 { 10800, 21600 }, { 1 MSO_I, 6 MSO_I }, { 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 4 MSO_I },
1475 { 0 MSO_I, 4 MSO_I }, { 0 MSO_I, 7 MSO_I }, { 2 MSO_I, 7 MSO_I }, { 2 MSO_I, 5 MSO_I },
1476 { 0, 10800 }, { 2 MSO_I, 1 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I }
1477 };
1478 static const sal_uInt16 mso_sptQuadArrowCalloutSegm[] =
1479 {
1480 0x4000, 0x001f, 0x6001, 0x8000
1481 };
1482 static const SvxMSDffCalculationData mso_sptQuadArrowCalloutCalc[] =
1483 {
1484 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1485 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
1486 { 0x2000, DFF_Prop_adjust3Value, 0, 0 },
1487 { 0x2000, DFF_Prop_adjust4Value, 0, 0 },
1488 { 0x8000, 21600, 0, 0x0400 },
1489 { 0x8000, 21600, 0, 0x0401 },
1490 { 0x8000, 21600, 0, 0x0402 },
1491 { 0x8000, 21600, 0, 0x0403 }
1492 };
1493 static const sal_Int32 mso_sptQuadArrowCalloutDefault[] =
1494 {
1495 4, 5400, 8100, 2700, 9400
1496 };
1497 static const SvxMSDffTextRectangles mso_sptQuadArrowCalloutTextRect[] =
1498 {
1499 { { 0 MSO_I, 0 MSO_I }, { 4 MSO_I, 4 MSO_I } }
1500 };
1501 static const mso_CustomShape msoQuadArrowCallout =
1502 {
1503 (SvxMSDffVertPair*)mso_sptQuadArrowCalloutVert, sizeof( mso_sptQuadArrowCalloutVert ) / sizeof( SvxMSDffVertPair ),
1504 (sal_uInt16*)mso_sptQuadArrowCalloutSegm, sizeof( mso_sptQuadArrowCalloutSegm ) >> 1,
1505 (SvxMSDffCalculationData*)mso_sptQuadArrowCalloutCalc, sizeof( mso_sptQuadArrowCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
1506 (sal_Int32*)mso_sptQuadArrowCalloutDefault,
1507 (SvxMSDffTextRectangles*)mso_sptQuadArrowCalloutTextRect, sizeof( mso_sptQuadArrowCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
1508 21600, 21600,
1509 0x80000000, 0x80000000,
1510 NULL, 0
1511 };
1512
1513 static const SvxMSDffVertPair mso_sptCircularArrowVert[] =
1514 {
1515 { 3 MSO_I, 3 MSO_I }, { 20 MSO_I, 20 MSO_I }, { 19 MSO_I, 18 MSO_I }, { 17 MSO_I, 16 MSO_I },
1516 { 0, 0 }, { 21600, 21600 }, { 9 MSO_I, 8 MSO_I }, { 11 MSO_I, 10 MSO_I },
1517 { 24 MSO_I, 23 MSO_I }, { 40 MSO_I, 39 MSO_I }, { 29 MSO_I, 28 MSO_I }
1518 };
1519 static const sal_uInt16 mso_sptCircularArrowSegm[] =
1520 {
1521 0xa404, 0xa504, 0x0003, 0x6001, 0x8000
1522 };
1523 static const SvxMSDffCalculationData mso_sptCircularArrowCalc[] =
1524 {
1525 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0
1526 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 1
1527 { 0x2000, DFF_Prop_adjust3Value, 0, 0 }, // 2
1528 { 0x8000, 10800, 0,DFF_Prop_adjust3Value }, // 3
1529 { 0x4009, 10800, DFF_Prop_adjustValue, 0 }, // 4
1530 { 0x400a, 10800, DFF_Prop_adjustValue, 0 }, // 5
1531 { 0x4009, 10800, DFF_Prop_adjust2Value, 0 }, // 6
1532 { 0x400a, 10800, DFF_Prop_adjust2Value, 0 }, // 7
1533 { 0x2000, 0x0404, 10800, 0 }, // 8
1534 { 0x2000, 0x0405, 10800, 0 }, // 9
1535 { 0x2000, 0x0406, 10800, 0 }, // 10
1536 { 0x2000, 0x0407, 10800, 0 }, // 11
1537 { 0x6009, 0x0403, DFF_Prop_adjustValue, 0 }, // 12
1538 { 0x600a, 0x0403, DFF_Prop_adjustValue, 0 }, // 13
1539 { 0x6009, 0x0403, DFF_Prop_adjust2Value, 0 }, // 14
1540 { 0x600a, 0x0403, DFF_Prop_adjust2Value, 0 }, // 15
1541 { 0x2000, 0x040c, 10800, 0 }, // 16
1542 { 0x2000, 0x040d, 10800, 0 }, // 17
1543 { 0x2000, 0x040e, 10800, 0 }, // 18
1544 { 0x2000, 0x040f, 10800, 0 }, // 19
1545 { 0x8000, 21600, 0, 0x0403 }, // 20
1546 { 0x4009, 12600, DFF_Prop_adjust2Value, 0 }, // 21
1547 { 0x400a, 12600, DFF_Prop_adjust2Value, 0 }, // 22
1548 { 0x2000, 0x0415, 10800, 0 }, // 23
1549 { 0x2000, 0x0416, 10800, 0 }, // 24
1550 { 0x2000, DFF_Prop_adjust3Value, 0, 1800 }, // 25
1551 { 0x6009, 0x0419, DFF_Prop_adjust2Value, 0 }, // 26
1552 { 0x600a, 0x0419, DFF_Prop_adjust2Value, 0 }, // 27
1553 { 0x2000, 0x041a, 10800, 0 }, // 28
1554 { 0x2000, 0x041b, 10800, 0 }, // 29
1555 { 0x2001, 0x0403, 1, 2 }, // 30
1556 { 0x8000, 10800, 0, 0x041e }, // 31
1557 { 0x4001, 35, 0x0403, 10800 }, // 32
1558 { 0x2000, 0x0420, 10, 0 }, // 33
1559 { 0x2001, 0x0421, 256, 1 }, // 34
1560 { 0x2001, 0x0422, 256, 1 }, // 35
1561 { 0x6000, 0x0423, DFF_Prop_adjust2Value, 0 }, // 36
1562 { 0x6009, 0x041f, 0x0424, 0 }, // 37
1563 { 0x600a, 0x041f, 0x0424, 0 }, // 38
1564 { 0x2000, 0x0425, 10800, 0 }, // 39
1565 { 0x2000, 0x0426, 10800, 0 } // 40
1566 };
1567 static const sal_Int32 mso_sptCircularArrowDefault[] =
1568 {
1569 3, 180 << 16, 0, 5500
1570 };
1571 static const SvxMSDffTextRectangles mso_sptCircularArrowTextRect[] = // todo
1572 {
1573 { { 0, 0 }, { 21600, 21600 } }
1574 };
1575 static const mso_CustomShape msoCircularArrow =
1576 {
1577 (SvxMSDffVertPair*)mso_sptCircularArrowVert, sizeof( mso_sptCircularArrowVert ) / sizeof( SvxMSDffVertPair ),
1578 (sal_uInt16*)mso_sptCircularArrowSegm, sizeof( mso_sptCircularArrowSegm ) >> 1,
1579 (SvxMSDffCalculationData*)mso_sptCircularArrowCalc, sizeof( mso_sptCircularArrowCalc ) / sizeof( SvxMSDffCalculationData ),
1580 (sal_Int32*)mso_sptCircularArrowDefault,
1581 (SvxMSDffTextRectangles*)mso_sptCircularArrowTextRect, sizeof( mso_sptCircularArrowTextRect ) / sizeof( SvxMSDffTextRectangles ),
1582 21600, 21600,
1583 0x80000000, 0x80000000,
1584 NULL, 0
1585 };
1586
1587 static const SvxMSDffVertPair mso_sptCubeVert[] =
1588 {
1589 { 0, 21600 }, { 0, 1 MSO_I }, { 2 MSO_I, 0 }, { 21600, 0 },
1590 { 21600, 3 MSO_I }, { 4 MSO_I, 21600 }, { 0, 1 MSO_I }, { 2 MSO_I, 0 },
1591 { 21600, 0 }, { 4 MSO_I, 1 MSO_I }, { 4 MSO_I, 21600 }, { 4 MSO_I, 1 MSO_I },
1592 { 21600, 0 }, { 21600, 3 MSO_I }
1593 };
1594 static const sal_uInt16 mso_sptCubeSegm[] =
1595 {
1596 0x4000, 0x0005, 0x6001, 0x8000,
1597 0x4000, 0x0003, 0x6001, 0x8000,
1598 0x4000, 0x0003, 0x6001, 0x8000
1599 };
1600 static const SvxMSDffCalculationData mso_sptCubeCalc[] =
1601 {
1602 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1603 { 0x6000, DFF_Prop_geoTop, 0x400, 0 },
1604 { 0x6000, DFF_Prop_geoLeft, 0x400, 0 },
1605 { 0xa000, DFF_Prop_geoBottom, 0, 0x400 },
1606 { 0xa000, DFF_Prop_geoRight, 0, 0x400 },
1607 { 0x8000, 21600, 0, 0x402 }, // 5
1608 { 0x2001, 0x405, 1, 2 }, // 6
1609 { 0x6000, 0x402, 0x406, 0 }, // 7
1610 { 0x2001, 0x404, 1, 2 } // 8
1611
1612 };
1613 static const SvxMSDffTextRectangles mso_sptCubeTextRect[] =
1614 {
1615 { { 0, 1 MSO_I }, { 4 MSO_I, 21600 } }
1616 };
1617 static const mso_CustomShape msoCube =
1618 {
1619 (SvxMSDffVertPair*)mso_sptCubeVert, sizeof( mso_sptCubeVert ) / sizeof( SvxMSDffVertPair ),
1620 (sal_uInt16*)mso_sptCubeSegm, sizeof( mso_sptCubeSegm ) >> 1,
1621 (SvxMSDffCalculationData*)mso_sptCubeCalc, sizeof( mso_sptCubeCalc ) / sizeof( SvxMSDffCalculationData ),
1622 (sal_Int32*)mso_sptDefault5400,
1623 (SvxMSDffTextRectangles*)mso_sptCubeTextRect, sizeof( mso_sptCubeTextRect ) / sizeof( SvxMSDffTextRectangles ),
1624 21600, 21600,
1625 10800, 10800,
1626 NULL, 0
1627 };
1628
1629 static const SvxMSDffVertPair mso_sptBevelVert[] =
1630 {
1631 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
1632 { 0, 0 }, { 21600, 0 }, { 1 MSO_I, 0 MSO_I }, { 0 MSO_I, 0 MSO_I },
1633 { 21600, 0 }, { 21600, 21600 }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 0 MSO_I },
1634 { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 1 MSO_I, 1 MSO_I },
1635 { 0, 21600 }, { 0, 0 }, { 0 MSO_I, 0 MSO_I }, { 0 MSO_I, 1 MSO_I }
1636 };
1637 static const sal_uInt16 mso_sptBevelSegm[] =
1638 {
1639 0x4000, 0x0003, 0x6001, 0x8000,
1640 0x4000, 0x0003, 0x6001, 0x8000,
1641 0x4000, 0x0003, 0x6001, 0x8000,
1642 0x4000, 0x0003, 0x6001, 0x8000,
1643 0x4000, 0x0003, 0x6001, 0x8000
1644 };
1645 static const SvxMSDffCalculationData mso_sptBevelCalc[] =
1646 {
1647 { 0x2001, DFF_Prop_adjustValue, 21599, 21600 },
1648 { 0x8000, 21600, 0, 0x400 }
1649 };
1650 static const SvxMSDffTextRectangles mso_sptBevelTextRect[] =
1651 {
1652 { { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I } }
1653 };
1654 static const mso_CustomShape msoBevel =
1655 {
1656 (SvxMSDffVertPair*)mso_sptBevelVert, sizeof( mso_sptBevelVert ) / sizeof( SvxMSDffVertPair ),
1657 (sal_uInt16*)mso_sptBevelSegm, sizeof( mso_sptBevelSegm ) >> 1,
1658 (SvxMSDffCalculationData*)mso_sptBevelCalc, sizeof( mso_sptBevelCalc ) / sizeof( SvxMSDffCalculationData ),
1659 (sal_Int32*)mso_sptDefault2700,
1660 (SvxMSDffTextRectangles*)mso_sptBevelTextRect, sizeof( mso_sptBevelTextRect ) / sizeof( SvxMSDffTextRectangles ),
1661 21600, 21600,
1662 10800, 10800,
1663 NULL, 0
1664 };
1665
1666 static const SvxMSDffVertPair mso_sptFoldedCornerVert[] = // adjustment1 : x 10800 - 21600
1667 {
1668 { 0, 0 }, { 21600, 0 }, { 21600, 0 MSO_I }, { 0 MSO_I, 21600 },
1669 { 0, 21600 }, { 0 MSO_I, 21600 }, { 3 MSO_I, 0 MSO_I }, { 8 MSO_I, 9 MSO_I },
1670 { 10 MSO_I, 11 MSO_I }, { 21600, 0 MSO_I }
1671 };
1672 static const sal_uInt16 mso_sptFoldedCornerSegm[] =
1673 {
1674 0x4000, 0x0004, 0x6001, 0x8000,
1675 0x4000, 0x0001, 0x2001, 0x6001, 0x8000
1676 };
1677 static const SvxMSDffCalculationData mso_sptFoldedCornerCalc[] =
1678 {
1679 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1680 { 0x8000, 21600, 0, 0x400 },
1681 { 0x2001, 0x0401, 8000, 10800 },
1682 { 0x8000, 21600, 0, 0x0402 },
1683 { 0x2001, 0x0401, 1, 2 },
1684 { 0x2001, 0x0401, 1, 4 },
1685 { 0x2001, 0x0401, 1, 7 },
1686 { 0x2001, 0x0401, 1, 16 },
1687 { 0x6000, 0x0403, 0x405, 0 },
1688 { 0x6000, 0x0400, 0x406, 0 },
1689 { 0x8000, 21600, 0, 0x404 },
1690 { 0x6000, 0x400, 0x407, 0 }
1691 };
1692 static const sal_Int32 mso_sptFoldedCornerDefault[] =
1693 {
1694 1, 18900
1695 };
1696 static const SvxMSDffTextRectangles mso_sptFoldedCornerTextRect[] =
1697 {
1698 { { 0, 0 }, { 21600, 11 MSO_I } }
1699 };
1700 static const mso_CustomShape msoFoldedCorner =
1701 {
1702 (SvxMSDffVertPair*)mso_sptFoldedCornerVert, sizeof( mso_sptFoldedCornerVert ) / sizeof( SvxMSDffVertPair ),
1703 (sal_uInt16*)mso_sptFoldedCornerSegm, sizeof( mso_sptFoldedCornerSegm ) >> 1,
1704 (SvxMSDffCalculationData*)mso_sptFoldedCornerCalc, sizeof( mso_sptFoldedCornerCalc ) / sizeof( SvxMSDffCalculationData ),
1705 (sal_Int32*)mso_sptFoldedCornerDefault,
1706 (SvxMSDffTextRectangles*)mso_sptFoldedCornerTextRect, sizeof( mso_sptFoldedCornerTextRect ) / sizeof( SvxMSDffTextRectangles ),
1707 21600, 21600,
1708 0x80000000, 0x80000000,
1709 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
1710 };
1711
1712 static const SvxMSDffVertPair mso_sptActionButtonBlankVert[] =
1713 {
1714 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
1715 { 0, 0 }, { 21600, 0 }, { 1 MSO_I, 0 MSO_I }, { 0 MSO_I, 0 MSO_I },
1716 { 21600, 0 }, { 21600, 21600 }, { 1 MSO_I, 1 MSO_I }, { 1 MSO_I, 0 MSO_I },
1717 { 21600, 21600 }, { 0, 21600 }, { 0 MSO_I, 1 MSO_I }, { 1 MSO_I, 1 MSO_I },
1718 { 0, 21600 }, { 0, 0 }, { 0 MSO_I, 0 MSO_I }, { 0 MSO_I, 1 MSO_I }
1719 };
1720 static const sal_uInt16 mso_sptActionButtonBlankSegm[] =
1721 {
1722 0x4000, 0x0003, 0x6001, 0x8000,
1723 0x4000, 0x0003, 0x6001, 0x8000,
1724 0x4000, 0x0003, 0x6001, 0x8000,
1725 0x4000, 0x0003, 0x6001, 0x8000,
1726 0x4000, 0x0003, 0x6001, 0x8000
1727 };
1728 static const SvxMSDffCalculationData mso_sptActionButtonBlankCalc[] =
1729 {
1730 { 0x2001, DFF_Prop_adjustValue, 21599, 21600 },
1731 { 0x8000, 21600, 0, 0x400 }
1732 };
1733 static const SvxMSDffTextRectangles mso_sptActionButtonBlankTextRect[] =
1734 {
1735 { { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I } }
1736 };
1737 static const mso_CustomShape msoActionButtonBlank =
1738 {
1739 (SvxMSDffVertPair*)mso_sptActionButtonBlankVert, sizeof( mso_sptActionButtonBlankVert ) / sizeof( SvxMSDffVertPair ),
1740 (sal_uInt16*)mso_sptActionButtonBlankSegm, sizeof( mso_sptActionButtonBlankSegm ) >> 1,
1741 (SvxMSDffCalculationData*)mso_sptActionButtonBlankCalc, sizeof( mso_sptActionButtonBlankCalc ) / sizeof( SvxMSDffCalculationData ),
1742 (sal_Int32*)mso_sptDefault1400,
1743 (SvxMSDffTextRectangles*)mso_sptActionButtonBlankTextRect, sizeof( mso_sptActionButtonBlankTextRect ) / sizeof( SvxMSDffTextRectangles ),
1744 21600, 21600,
1745 10800, 10800,
1746 NULL, 0
1747 };
1748
1749 static const SvxMSDffTextRectangles mso_sptActionButtonTextRect[] =
1750 {
1751 { { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 4 MSO_I } }
1752 };
1753 static const SvxMSDffVertPair mso_sptActionButtonHomeVert[] =
1754 {
1755 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
1756 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
1757 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
1758 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
1759 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
1760
1761 { 10800, 0xa MSO_I }, { 0xc MSO_I, 0xe MSO_I }, { 0xc MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I },
1762 { 0x12 MSO_I, 0x14 MSO_I }, { 0x16 MSO_I, 10800 }, { 0x18 MSO_I, 10800 }, { 0x18 MSO_I, 0x1a MSO_I },
1763 { 0x1c MSO_I, 0x1a MSO_I }, { 0x1c MSO_I, 10800 }, { 0x1e MSO_I, 10800 },
1764
1765 { 0xc MSO_I, 0xe MSO_I }, { 0xc MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I },{ 0x12 MSO_I, 0x14 MSO_I },
1766
1767 { 0x20 MSO_I, 0x24 MSO_I }, { 0x22 MSO_I, 0x24 MSO_I }, { 0x22 MSO_I, 0x1a MSO_I }, { 0x18 MSO_I, 0x1a MSO_I },
1768 { 0x18 MSO_I, 10800 }, { 0x1c MSO_I, 10800 }, { 0x1c MSO_I, 0x1a MSO_I }, { 0x20 MSO_I, 0x1a MSO_I }
1769
1770 };
1771 static const sal_uInt16 mso_sptActionButtonHomeSegm[] =
1772 {
1773 0x4000, 0x0003, 0x6001, 0x8000,
1774 0x4000, 0x0003, 0x6001, 0x8000,
1775 0x4000, 0x0003, 0x6001, 0x8000,
1776 0x4000, 0x0003, 0x6001, 0x8000,
1777 0x4000, 0x0003, 0x6001, 0x8000,
1778 0x4000, 0x000a, 0x6001, 0x8000,
1779 0x4000, 0x0003, 0x6001, 0x8000,
1780 0x4000, 0x0007, 0x6001, 0x8000
1781 };
1782 static const SvxMSDffCalculationData mso_sptActionButtonHomeCalc[] = // adj value 0 - 5400
1783 {
1784 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1785 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
1786 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
1787 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
1788 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
1789 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
1790 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
1791 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
1792 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
1793
1794 { 0x4001, -8000, 0x0406, 1 }, // 9
1795 { 0x6000, 0x0409, 0x0408, 0 }, // a
1796 { 0x4001, 2960, 0x0406, 1 }, // b
1797 { 0x6000, 0x040b, 0x0407, 0 }, // c
1798 { 0x4001, -5000, 0x0406, 1 }, // d
1799 { 0x6000, 0x040d, 0x0408, 0 }, // e
1800 { 0x4001, -7000, 0x0406, 1 }, // f
1801 { 0x6000, 0x040f, 0x0408, 0 }, // 10
1802 { 0x4001, 5000, 0x0406, 1 }, // 11
1803 { 0x6000, 0x0411, 0x0407, 0 }, // 12
1804 { 0x4001, -2960, 0x0406, 1 }, // 13
1805 { 0x6000, 0x0413, 0x0408, 0 }, // 14
1806 { 0x4001, 8000, 0x0406, 1 }, // 15
1807 { 0x6000, 0x0415,0x0407, 0 }, // 16
1808 { 0x4001, 6100, 0x0406, 1 }, // 17
1809 { 0x6000, 0x0417,0x0407, 0 }, // 18
1810 { 0x4001, 8260, 0x0406, 1 }, // 19
1811 { 0x6000, 0x0419, 0x0408, 0 }, // 1a
1812 { 0x4001, -6100, 0x0406, 1 }, // 1b
1813 { 0x6000, 0x041b, 0x0407, 0 }, // 1c
1814 { 0x4001, -8000, 0x0406, 1 }, // 1d
1815 { 0x6000, 0x041d, 0x0407, 0 }, // 1e
1816 { 0x4001, -1060, 0x0406, 1 }, // 1f
1817 { 0x6000, 0x041f, 0x0407, 0 }, // 20
1818 { 0x4001, 1060, 0x0406, 1 }, // 21
1819 { 0x6000, 0x0421, 0x0407, 0 }, // 22
1820 { 0x4001, 4020, 0x0406, 1 }, // 23
1821 { 0x6000, 0x0423, 0x0408, 0 } // 24
1822
1823 };
1824 static const mso_CustomShape msoActionButtonHome =
1825 {
1826 (SvxMSDffVertPair*)mso_sptActionButtonHomeVert, sizeof( mso_sptActionButtonHomeVert ) / sizeof( SvxMSDffVertPair ),
1827 (sal_uInt16*)mso_sptActionButtonHomeSegm, sizeof( mso_sptActionButtonHomeSegm ) >> 1,
1828 (SvxMSDffCalculationData*)mso_sptActionButtonHomeCalc, sizeof( mso_sptActionButtonHomeCalc ) / sizeof( SvxMSDffCalculationData ),
1829 (sal_Int32*)mso_sptDefault1400,
1830 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
1831 21600, 21600,
1832 0x80000000, 0x80000000,
1833 NULL, 0
1834 };
1835
1836 static const SvxMSDffVertPair mso_sptActionButtonHelpVert[] =
1837 {
1838 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
1839 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
1840 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
1841 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
1842 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I,4 MSO_I },
1843
1844 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I },
1845
1846 { 0x12 MSO_I, 0x14 MSO_I }, { 0x12 MSO_I, 0x16 MSO_I }, // pp
1847 { 0x12 MSO_I, 0x18 MSO_I }, { 0x1a MSO_I, 10800 }, { 0x1c MSO_I, 10800 }, // ccp
1848 { 0x1e MSO_I, 10800 }, { 0x20 MSO_I, 0x22 MSO_I }, { 0x20 MSO_I, 0x24 MSO_I }, // ccp
1849 { 0x20 MSO_I, 0x26 MSO_I }, { 0x28 MSO_I, 0x2a MSO_I }, { 10800, 0x2a MSO_I }, // ccp
1850 { 0x2c MSO_I, 0x2a MSO_I }, { 0x2e MSO_I, 0x26 MSO_I }, { 0x2e MSO_I, 0x24 MSO_I }, // ccp
1851 { 0x30 MSO_I, 0x24 MSO_I }, { 0x30 MSO_I, 0x32 MSO_I }, { 0x34 MSO_I, 0x36 MSO_I }, // ccp
1852 { 10800, 0x36 MSO_I }, // p
1853 { 0x12 MSO_I, 0x36 MSO_I }, { 0x1c MSO_I, 0x32 MSO_I }, { 0x1c MSO_I, 0x24 MSO_I }, // ccp
1854 { 0x1c MSO_I, 0x38 MSO_I }, { 0x3a MSO_I, 0x3c MSO_I }, { 0x12 MSO_I, 0x3c MSO_I }, // ccp
1855 { 10800, 0x3c MSO_I }, { 0x34 MSO_I, 10800 }, { 0x34 MSO_I, 0x16 MSO_I }, // ccp
1856 { 0x34 MSO_I, 0x14 MSO_I }
1857 };
1858 static const sal_uInt16 mso_sptActionButtonHelpSegm[] =
1859 {
1860 0x4000, 0x0003, 0x6001, 0x8000,
1861 0x4000, 0x0003, 0x6001, 0x8000,
1862 0x4000, 0x0003, 0x6001, 0x8000,
1863 0x4000, 0x0003, 0x6001, 0x8000,
1864 0x4000, 0x0003, 0x6001, 0x8000,
1865 0xa302, 0x6000, 0x8000,
1866 0x4000, 0x0001, 0x2004, 0x0001, 0x2004, 0x0001, 0x6001, 0x8000
1867 };
1868 static const SvxMSDffCalculationData mso_sptActionButtonHelpCalc[] = // adj value 0 - 5400
1869 {
1870 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1871 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
1872 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
1873 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
1874 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
1875 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
1876 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
1877 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
1878 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
1879
1880 { 0x4001, -1690, 0x0406, 1 }, // 9
1881 { 0x6000, 0x0409, 0x0407, 0 }, // a
1882 { 0x4001, 4600, 0x0406, 1 }, // b
1883 { 0x6000, 0x040b, 0x0408, 0 }, // c
1884 { 0x4001, 1690, 0x0406, 1 }, // d
1885 { 0x6000, 0x040d, 0x0407, 0 }, // e
1886 { 0x4001, 7980, 0x0406, 1 }, // f
1887 { 0x6000, 0x040f, 0x0408, 0 }, // 10
1888 { 0x4001, 1270, 0x0406, 1 }, // 11
1889 { 0x6000, 0x0411, 0x0407, 0 }, // 12
1890 { 0x4001, 4000, 0x0406, 1 }, // 13
1891 { 0x6000, 0x0413, 0x0408, 0 }, // 14
1892 { 0x4001, 1750, 0x0406, 1 }, // 15
1893 { 0x6000, 0x0415, 0x0408, 0 }, // 16
1894 { 0x4001, 800, 0x0406, 1 }, // 17
1895 { 0x6000, 0x0417, 0x0408, 0 }, // 18
1896 { 0x4001, 1650, 0x0406, 1 }, // 19
1897 { 0x6000, 0x0419, 0x0407, 0 }, // 1a
1898 { 0x4001, 2340, 0x0406, 1 }, // 1b
1899 { 0x6000, 0x041b, 0x0407, 0 }, // 1c
1900 { 0x4001, 3640, 0x0406, 1 }, // 1d
1901 { 0x6000, 0x041d, 0x0407, 0 }, // 1e
1902 { 0x4001, 4670, 0x0406, 1 }, // 1f
1903 { 0x6000, 0x041f, 0x0407, 0 }, // 20
1904 { 0x4001, -1570, 0x0406, 1 }, // 21
1905 { 0x6000, 0x0421, 0x0408, 0 }, // 22
1906 { 0x4001, -3390, 0x0406, 1 }, // 23
1907 { 0x6000, 0x0423, 0x0408, 0 }, // 24
1908 { 0x4001, -6050, 0x0406, 1 }, // 25
1909 { 0x6000, 0x0425, 0x0408, 0 }, // 26
1910 { 0x4001, 2540, 0x0406, 1 }, // 27
1911 { 0x6000, 0x0427, 0x0407, 0 }, // 28
1912 { 0x4001, -8050, 0x0406, 1 }, // 29
1913 { 0x6000, 0x0429, 0x0408, 0 }, // 2a
1914 { 0x4001, -2540, 0x0406, 1 }, // 2b
1915 { 0x6000, 0x042b, 0x0407, 0 }, // 2c
1916 { 0x4001, -4460, 0x0406, 1 }, // 2d
1917 { 0x6000, 0x042d, 0x0407, 0 }, // 2e
1918 { 0x4001, -2330, 0x0406, 1 }, // 2f
1919 { 0x6000, 0x042f, 0x0407, 0 }, // 30
1920 { 0x4001, -4700, 0x0406, 1 }, // 31
1921 { 0x6000, 0x0431, 0x0408, 0 }, // 32
1922 { 0x4001, -1270, 0x0406, 1 }, // 33
1923 { 0x6000, 0x0433, 0x0407, 0 }, // 34
1924 { 0x4001, -5720, 0x0406, 1 }, // 35
1925 { 0x6000, 0x0435, 0x0408, 0 }, // 36
1926 { 0x4001, -2540, 0x0406, 1 }, // 37
1927 { 0x6000, 0x0437, 0x0408, 0 }, // 38
1928 { 0x4001, 1800, 0x0406, 1 }, // 39
1929 { 0x6000, 0x0439, 0x0407, 0 }, // 3a
1930 { 0x4001, -1700, 0x0406, 1 }, // 3b
1931 { 0x6000, 0x043b, 0x0408, 0 } // 3c
1932 };
1933 static const mso_CustomShape msoActionButtonHelp =
1934 {
1935 (SvxMSDffVertPair*)mso_sptActionButtonHelpVert, sizeof( mso_sptActionButtonHelpVert ) / sizeof( SvxMSDffVertPair ),
1936 (sal_uInt16*)mso_sptActionButtonHelpSegm, sizeof( mso_sptActionButtonHelpSegm ) >> 1,
1937 (SvxMSDffCalculationData*)mso_sptActionButtonHelpCalc, sizeof( mso_sptActionButtonHelpCalc ) / sizeof( SvxMSDffCalculationData ),
1938 (sal_Int32*)mso_sptDefault1400,
1939 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
1940 21600, 21600,
1941 0x80000000, 0x80000000,
1942 NULL, 0
1943 };
1944
1945 static const SvxMSDffVertPair mso_sptActionButtonInformationVert[] =
1946 {
1947 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
1948 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
1949 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
1950 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
1951 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
1952
1953 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I },
1954
1955 { 0x12 MSO_I, 0x14 MSO_I }, { 0x16 MSO_I, 0x18 MSO_I },
1956
1957 { 0x1a MSO_I, 0x1c MSO_I }, { 0x1e MSO_I, 0x1c MSO_I }, { 0x1e MSO_I, 0x20 MSO_I }, { 0x22 MSO_I, 0x20 MSO_I },
1958 { 0x22 MSO_I, 0x24 MSO_I }, { 0x1a MSO_I, 0x24 MSO_I }, { 0x1a MSO_I, 0x20 MSO_I }, { 0x26 MSO_I, 0x20 MSO_I },
1959 { 0x26 MSO_I, 0x28 MSO_I }, { 0x1a MSO_I, 0x28 MSO_I }
1960 };
1961 static const sal_uInt16 mso_sptActionButtonInformationSegm[] =
1962 {
1963 0x4000, 0x0003, 0x6001, 0x8000,
1964 0x4000, 0x0003, 0x6001, 0x8000,
1965 0x4000, 0x0003, 0x6001, 0x8000,
1966 0x4000, 0x0003, 0x6001, 0x8000,
1967 0x4000, 0x0003, 0x6001, 0x8000,
1968 0xa302, 0x6000, 0x8000,
1969 0xa302, 0x6000, 0x8000,
1970 0x4000, 0x0009, 0x6001, 0x8000
1971 };
1972 static const SvxMSDffCalculationData mso_sptActionButtonInformationCalc[] = // adj value 0 - 5400
1973 {
1974 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
1975 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
1976 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
1977 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
1978 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
1979 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
1980 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
1981 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
1982 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
1983
1984 { 0x4001, -8050, 0x0406, 1 }, // 9
1985 { 0x6000, 0x0409, 0x0407, 0 }, // a
1986 { 0x4001, -8050, 0x0406, 1 }, // b
1987 { 0x6000, 0x040b, 0x0408, 0 }, // c
1988 { 0x4001, 8050, 0x0406, 1 }, // d
1989 { 0x6000, 0x040d, 0x0407, 0 }, // e
1990 { 0x4001, 8050, 0x0406, 1 }, // f
1991 { 0x6000, 0x040f, 0x0408, 0 }, // 10
1992
1993 { 0x4001, -2060, 0x0406, 1 }, // 11
1994 { 0x6000, 0x0411, 0x0407, 0 }, // 12
1995 { 0x4001, -7620, 0x0406, 1 }, // 13
1996 { 0x6000, 0x0413, 0x0408, 0 }, // 14
1997 { 0x4001, 2060, 0x0406, 1 }, // 15
1998 { 0x6000, 0x0415, 0x0407, 0 }, // 16
1999 { 0x4001, -3500, 0x0406, 1 }, // 17
2000 { 0x6000, 0x0417, 0x0408, 0 }, // 18
2001
2002 { 0x4001, -2960, 0x0406, 1 }, // 19
2003 { 0x6000, 0x0419, 0x0407, 0 }, // 1a
2004 { 0x4001, -2960, 0x0406, 1 }, // 1b
2005 { 0x6000, 0x041b, 0x0408, 0 }, // 1c
2006 { 0x4001, 1480, 0x0406, 1 }, // 1d
2007 { 0x6000, 0x041d, 0x0407, 0 }, // 1e
2008 { 0x4001, 5080, 0x0406, 1 }, // 1f
2009 { 0x6000, 0x041f, 0x0408, 0 }, // 20
2010 { 0x4001, 2960, 0x0406, 1 }, // 21
2011 { 0x6000, 0x0421, 0x0407, 0 }, // 22
2012 { 0x4001, 6140, 0x0406, 1 }, // 23
2013 { 0x6000, 0x0423, 0x0408, 0 }, // 24
2014 { 0x4001, -1480, 0x0406, 1 }, // 25
2015 { 0x6000, 0x0425, 0x0407, 0 }, // 26
2016 { 0x4001, -1920, 0x0406, 1 }, // 27
2017 { 0x6000, 0x0427, 0x0408, 0 } // 28
2018 };
2019 static const mso_CustomShape msoActionButtonInformation =
2020 {
2021 (SvxMSDffVertPair*)mso_sptActionButtonInformationVert, sizeof( mso_sptActionButtonInformationVert ) / sizeof( SvxMSDffVertPair ),
2022 (sal_uInt16*)mso_sptActionButtonInformationSegm, sizeof( mso_sptActionButtonInformationSegm ) >> 1,
2023 (SvxMSDffCalculationData*)mso_sptActionButtonInformationCalc, sizeof( mso_sptActionButtonInformationCalc ) / sizeof( SvxMSDffCalculationData ),
2024 (sal_Int32*)mso_sptDefault1400,
2025 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2026 21600, 21600,
2027 0x80000000, 0x80000000,
2028 NULL, 0
2029 };
2030
2031 static const SvxMSDffVertPair mso_sptActionButtonBackPreviousVert[] =
2032 {
2033 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2034 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2035 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2036 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I,4 MSO_I },
2037 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2038
2039 { 0xa MSO_I, 10800 }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }
2040 };
2041 static const sal_uInt16 mso_sptActionButtonForwardBackSegm[] =
2042 {
2043 0x4000, 0x0003, 0x6001, 0x8000,
2044 0x4000, 0x0003, 0x6001, 0x8000,
2045 0x4000, 0x0003, 0x6001, 0x8000,
2046 0x4000, 0x0003, 0x6001, 0x8000,
2047 0x4000, 0x0003, 0x6001, 0x8000,
2048 0x4000, 0x0002, 0x6001, 0x8000
2049 };
2050 static const SvxMSDffCalculationData mso_sptActionButtonForwardBackCalc[] = // adj value 0 - 5400
2051 {
2052 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2053 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2054 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2055 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2056 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2057 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
2058 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
2059 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
2060 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
2061
2062 { 0x4001, -8050, 0x0406, 1 }, // 9
2063 { 0x6000, 0x0409, 0x0407, 0 }, // a
2064 { 0x4001, -8050, 0x0406, 1 }, // b
2065 { 0x6000, 0x040b, 0x0408, 0 }, // c
2066 { 0x4001, 8050, 0x0406, 1 }, // d
2067 { 0x6000, 0x040d, 0x0407, 0 }, // e
2068 { 0x4001, 8050, 0x0406, 1 }, // f
2069 { 0x6000, 0x040f, 0x0408, 0 } // 10
2070 };
2071 static const mso_CustomShape msoActionButtonBackPrevious =
2072 {
2073 (SvxMSDffVertPair*)mso_sptActionButtonBackPreviousVert, sizeof( mso_sptActionButtonBackPreviousVert ) / sizeof( SvxMSDffVertPair ),
2074 (sal_uInt16*)mso_sptActionButtonForwardBackSegm, sizeof( mso_sptActionButtonForwardBackSegm ) >> 1,
2075 (SvxMSDffCalculationData*)mso_sptActionButtonForwardBackCalc, sizeof( mso_sptActionButtonForwardBackCalc ) / sizeof( SvxMSDffCalculationData ),
2076 (sal_Int32*)mso_sptDefault1400,
2077 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2078 21600, 21600,
2079 0x80000000, 0x80000000,
2080 NULL, 0
2081 };
2082
2083 static const SvxMSDffVertPair mso_sptActionButtonForwardNextVert[] =
2084 {
2085 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2086 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2087 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2088 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2089 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2090
2091 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 10800 }, { 0xa MSO_I, 0x10 MSO_I }
2092 };
2093 static const mso_CustomShape msoActionButtonForwardNext =
2094 {
2095 (SvxMSDffVertPair*)mso_sptActionButtonForwardNextVert, sizeof( mso_sptActionButtonForwardNextVert ) / sizeof( SvxMSDffVertPair ),
2096 (sal_uInt16*)mso_sptActionButtonForwardBackSegm, sizeof( mso_sptActionButtonForwardBackSegm ) >> 1,
2097 (SvxMSDffCalculationData*)mso_sptActionButtonForwardBackCalc, sizeof( mso_sptActionButtonForwardBackCalc ) / sizeof( SvxMSDffCalculationData ),
2098 (sal_Int32*)mso_sptDefault1400,
2099 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2100 21600, 21600,
2101 0x80000000, 0x80000000,
2102 NULL, 0
2103 };
2104
2105 static const SvxMSDffVertPair mso_sptActionButtonBeginningVert[] =
2106 {
2107 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2108 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2109 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2110 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2111 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2112
2113 { 0xa MSO_I, 10800 }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0xc MSO_I },
2114 { 0x14 MSO_I, 0xc MSO_I }, { 0x14 MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0x10 MSO_I }
2115 };
2116 static const sal_uInt16 mso_sptActionButtonBeginningEndSegm[] =
2117 {
2118 0x4000, 0x0003, 0x6001, 0x8000,
2119 0x4000, 0x0003, 0x6001, 0x8000,
2120 0x4000, 0x0003, 0x6001, 0x8000,
2121 0x4000, 0x0003, 0x6001, 0x8000,
2122 0x4000, 0x0003, 0x6001, 0x8000,
2123
2124 0x4000, 0x0002, 0x6001, 0x8000,
2125 0x4000, 0x0003, 0x6001, 0x8000
2126 };
2127 static const SvxMSDffCalculationData mso_sptActionButtonBeginningEndCalc[] = // adj value 0 - 5400
2128 {
2129 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2130 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2131 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2132 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2133 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2134 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
2135 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
2136 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
2137 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
2138
2139 { 0x4001, -4020, 0x0406, 1 }, // 9
2140 { 0x6000, 0x0409, 0x0407, 0 }, // a
2141 { 0x4001, -8050, 0x0406, 1 }, // b
2142 { 0x6000, 0x040b, 0x0408, 0 }, // c
2143 { 0x4001, 8050, 0x0406, 1 }, // d
2144 { 0x6000, 0x040d, 0x0407, 0 }, // e
2145 { 0x4001, 8050, 0x0406, 1 }, // f
2146 { 0x6000, 0x040f, 0x0408, 0 }, // 10
2147
2148 { 0x4001, -8050, 0x0406, 1 }, // 11
2149 { 0x6000, 0x0411, 0x0407, 0 }, // 12
2150 { 0x4001, -6140, 0x0406, 1 }, // 13
2151 { 0x6000, 0x0413, 0x0407, 0 }, // 14
2152
2153
2154 { 0x4001, 4020, 0x0406, 1 }, // 15
2155 { 0x6000, 0x0415, 0x0407, 0 }, // 16
2156 { 0x4001, 6140, 0x0406, 1 }, // 17
2157 { 0x6000, 0x0417, 0x0407, 0 } // 18
2158 };
2159 static const mso_CustomShape msoActionButtonBeginning =
2160 {
2161 (SvxMSDffVertPair*)mso_sptActionButtonBeginningVert, sizeof( mso_sptActionButtonBeginningVert ) / sizeof( SvxMSDffVertPair ),
2162 (sal_uInt16*)mso_sptActionButtonBeginningEndSegm, sizeof( mso_sptActionButtonBeginningEndSegm ) >> 1,
2163 (SvxMSDffCalculationData*)mso_sptActionButtonBeginningEndCalc, sizeof( mso_sptActionButtonBeginningEndCalc ) / sizeof( SvxMSDffCalculationData ),
2164 (sal_Int32*)mso_sptDefault1400,
2165 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2166 21600, 21600,
2167 0x80000000, 0x80000000,
2168 NULL, 0
2169 };
2170
2171 static const SvxMSDffVertPair mso_sptActionButtonEndVert[] =
2172 {
2173 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2174 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2175 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2176 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2177 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2178
2179 { 0x16 MSO_I, 10800 }, { 0x12 MSO_I, 0x10 MSO_I }, { 0x12 MSO_I, 0xc MSO_I },
2180
2181 { 0x18 MSO_I, 0xc MSO_I }, { 0x18 MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, { 0xe MSO_I, 0xc MSO_I }
2182 };
2183 static const mso_CustomShape msoActionButtonEnd =
2184 {
2185 (SvxMSDffVertPair*)mso_sptActionButtonEndVert, sizeof( mso_sptActionButtonEndVert ) / sizeof( SvxMSDffVertPair ),
2186 (sal_uInt16*)mso_sptActionButtonBeginningEndSegm, sizeof( mso_sptActionButtonBeginningEndSegm ) >> 1,
2187 (SvxMSDffCalculationData*)mso_sptActionButtonBeginningEndCalc, sizeof( mso_sptActionButtonBeginningEndCalc ) / sizeof( SvxMSDffCalculationData ),
2188 (sal_Int32*)mso_sptDefault1400,
2189 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2190 21600, 21600,
2191 0x80000000, 0x80000000,
2192 NULL, 0
2193 };
2194
2195 static const SvxMSDffVertPair mso_sptActionButtonReturnVert[] =
2196 {
2197 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2198 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2199 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2200 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2201 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2202
2203 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0x10 MSO_I }, // ppp
2204 { 0xe MSO_I, 0x12 MSO_I }, { 0x14 MSO_I, 0x16 MSO_I }, { 0x18 MSO_I, 0x16 MSO_I }, // ccp
2205 { 10800, 0x16 MSO_I }, // p
2206 { 0x1a MSO_I, 0x16 MSO_I }, { 0x1c MSO_I, 0x12 MSO_I }, { 0x1c MSO_I, 0x10 MSO_I }, // ccp
2207 { 0x1c MSO_I, 0xc MSO_I }, { 10800, 0xc MSO_I }, { 0x1e MSO_I, 0x20 MSO_I }, { 0x22 MSO_I, 0xc MSO_I }, // pppp
2208 { 0x24 MSO_I, 0xc MSO_I }, { 0x24 MSO_I, 0x10 MSO_I }, // pp
2209 { 0x24 MSO_I, 0x26 MSO_I }, { 0x28 MSO_I, 0x2a MSO_I }, { 10800, 0x2a MSO_I }, // ccp
2210 { 0x18 MSO_I, 0x2a MSO_I }, // p
2211 { 0x2c MSO_I, 0x2a MSO_I }, { 0xa MSO_I, 0x26 MSO_I }, { 0xa MSO_I, 0x10 MSO_I } // ccp
2212 };
2213 static const sal_uInt16 mso_sptActionButtonReturnSegm[] =
2214 {
2215 0x4000, 0x0003, 0x6001, 0x8000,
2216 0x4000, 0x0003, 0x6001, 0x8000,
2217 0x4000, 0x0003, 0x6001, 0x8000,
2218 0x4000, 0x0003, 0x6001, 0x8000,
2219 0x4000, 0x0003, 0x6001, 0x8000,
2220 0x4000, 0x0002, 0x2001, 0x0001, 0x2001, 0x0006,0x2001, 0x0001, 0x2001, 0x6001, 0x8000
2221 };
2222 static const SvxMSDffCalculationData mso_sptActionButtonReturnCalc[] = // adj value 0 - 5400
2223 {
2224 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2225 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2226 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2227 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2228 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2229 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
2230 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
2231 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
2232 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
2233
2234 { 0x4001, -8050, 0x0406, 1 }, // 9
2235 { 0x6000, 0x0409, 0x0407, 0 }, // a
2236 { 0x4001, -3800, 0x0406, 1 }, // b
2237 { 0x6000, 0x040b, 0x0408, 0 }, // c
2238 { 0x4001, -4020, 0x0406, 1 }, // d
2239 { 0x6000, 0x040d, 0x0407, 0 }, // e
2240 { 0x4001, 2330, 0x0406, 1 }, // f
2241 { 0x6000, 0x040f, 0x0408, 0 }, // 10
2242 { 0x4001, 3390, 0x0406, 1 }, // 11
2243 { 0x6000, 0x0411, 0x0408, 0 }, // 12
2244 { 0x4001, -3100, 0x0406, 1 }, // 13
2245 { 0x6000, 0x0413, 0x0407, 0 }, // 14
2246 { 0x4001, 4230, 0x0406, 1 }, // 15
2247 { 0x6000, 0x0415, 0x0408, 0 }, // 16
2248 { 0x4001, -1910, 0x0406, 1 }, // 17
2249 { 0x6000, 0x0417, 0x0407, 0 }, // 18
2250 { 0x4001, 1190, 0x0406, 1 }, // 19
2251 { 0x6000, 0x0419, 0x0407, 0 }, // 1a
2252 { 0x4001, 2110, 0x0406, 1 }, // 1b
2253 { 0x6000, 0x041b, 0x0407, 0 }, // 1c
2254 { 0x4001, 4030, 0x0406, 1 }, // 1d
2255 { 0x6000, 0x041d, 0x0407, 0 }, // 1e
2256 { 0x4001, -7830, 0x0406, 1 }, // 1f
2257 { 0x6000, 0x041f, 0x0408, 0 }, // 20
2258 { 0x4001, 8250, 0x0406, 1 }, // 21
2259 { 0x6000, 0x0421, 0x0407, 0 }, // 22
2260 { 0x4001, 6140, 0x0406, 1 }, // 23
2261 { 0x6000, 0x0423, 0x0407, 0 }, // 24
2262 { 0x4001, 5510, 0x0406, 1 }, // 25
2263 { 0x6000, 0x0425, 0x0408, 0 }, // 26
2264 { 0x4001, 3180, 0x0406, 1 }, // 27
2265 { 0x6000, 0x0427, 0x0407, 0 }, // 28
2266 { 0x4001, 8450, 0x0406, 1 }, // 29
2267 { 0x6000, 0x0429, 0x0408, 0 }, // 2a
2268 { 0x4001, -5090, 0x0406, 1 }, // 2b
2269 { 0x6000, 0x042b, 0x0407, 0 } // 2c
2270 };
2271 static const mso_CustomShape msoActionButtonReturn =
2272 {
2273 (SvxMSDffVertPair*)mso_sptActionButtonReturnVert, sizeof( mso_sptActionButtonReturnVert ) / sizeof( SvxMSDffVertPair ),
2274 (sal_uInt16*)mso_sptActionButtonReturnSegm, sizeof( mso_sptActionButtonReturnSegm ) >> 1,
2275 (SvxMSDffCalculationData*)mso_sptActionButtonReturnCalc, sizeof( mso_sptActionButtonReturnCalc ) / sizeof( SvxMSDffCalculationData ),
2276 (sal_Int32*)mso_sptDefault1400,
2277 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2278 21600, 21600,
2279 0x80000000, 0x80000000,
2280 NULL, 0
2281 };
2282
2283 static const SvxMSDffVertPair mso_sptActionButtonDocumentVert[] =
2284 {
2285 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2286 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2287 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2288 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2289 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2290
2291 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x10 MSO_I, 0x14 MSO_I },
2292 { 0xa MSO_I, 0x14 MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0xe MSO_I, 0x12 MSO_I }
2293 };
2294 static const sal_uInt16 mso_sptActionButtonDocumentSegm[] =
2295 {
2296 0x4000, 0x0003, 0x6001, 0x8000,
2297 0x4000, 0x0003, 0x6001, 0x8000,
2298 0x4000, 0x0003, 0x6001, 0x8000,
2299 0x4000, 0x0003, 0x6001, 0x8000,
2300 0x4000, 0x0003, 0x6001, 0x8000,
2301
2302 0x4000, 0x0004, 0x6001, 0x8000,
2303 0x4000, 0x0002, 0x6001, 0x8000
2304 };
2305 static const SvxMSDffCalculationData mso_sptActionButtonDocumentCalc[] = // adj value 0 - 5400
2306 {
2307 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2308 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2309 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2310 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2311 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2312 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
2313 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
2314 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
2315 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
2316
2317 { 0x4001, -6350, 0x0406, 1 }, // 9
2318 { 0x6000, 0x0409, 0x0407, 0 }, // a
2319 { 0x4001, -7830, 0x0406, 1 }, // b
2320 { 0x6000, 0x040b, 0x0408, 0 }, // c
2321 { 0x4001, 1690, 0x0406, 1 }, // d
2322 { 0x6000, 0x040d, 0x0407, 0 }, // e
2323 { 0x4001, 6350, 0x0406, 1 }, // f
2324 { 0x6000, 0x040f, 0x0407, 0 }, // 10
2325 { 0x4001, -3810, 0x0406, 1 }, // 11
2326 { 0x6000, 0x0411, 0x0408, 0 }, // 12
2327 { 0x4001, 7830, 0x0406, 1 }, // 13
2328 { 0x6000, 0x0413, 0x0408, 0 } // 14
2329 };
2330 static const mso_CustomShape msoActionButtonDocument =
2331 {
2332 (SvxMSDffVertPair*)mso_sptActionButtonDocumentVert, sizeof( mso_sptActionButtonDocumentVert ) / sizeof( SvxMSDffVertPair ),
2333 (sal_uInt16*)mso_sptActionButtonDocumentSegm, sizeof( mso_sptActionButtonDocumentSegm ) >> 1,
2334 (SvxMSDffCalculationData*)mso_sptActionButtonDocumentCalc, sizeof( mso_sptActionButtonDocumentCalc ) / sizeof( SvxMSDffCalculationData ),
2335 (sal_Int32*)mso_sptDefault1400,
2336 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2337 21600, 21600,
2338 0x80000000, 0x80000000,
2339 NULL, 0
2340 };
2341
2342 static const SvxMSDffVertPair mso_sptActionButtonSoundVert[] =
2343 {
2344 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2345 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2346 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2347 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2348 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2349
2350 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x10 MSO_I, 0x14 MSO_I },
2351 { 0xe MSO_I, 0x16 MSO_I }, { 0xa MSO_I, 0x16 MSO_I }, { 0x18 MSO_I, 10800 }, { 0x1a MSO_I, 10800 },
2352
2353 { 0x18 MSO_I, 0xc MSO_I }, { 0x1a MSO_I, 0x1c MSO_I },
2354
2355 { 0x18 MSO_I, 0x16 MSO_I }, { 0x1a MSO_I, 0x1e MSO_I }
2356 };
2357 static const sal_uInt16 mso_sptActionButtonSoundSegm[] =
2358 {
2359 0x4000, 0x0003, 0x6001, 0x8000,
2360 0x4000, 0x0003, 0x6001, 0x8000,
2361 0x4000, 0x0003, 0x6001, 0x8000,
2362 0x4000, 0x0003, 0x6001, 0x8000,
2363 0x4000, 0x0003, 0x6001, 0x8000,
2364
2365 0x4000, 0x0005, 0x6001, 0x8000,
2366 0x4000, 0x0001, 0x8000,
2367 0x4000, 0x0001, 0x8000,
2368 0x4000, 0x0001, 0x8000
2369 };
2370 static const SvxMSDffCalculationData mso_sptActionButtonSoundCalc[] = // adj value 0 - 5400
2371 {
2372 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2373 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2374 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2375 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2376 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2377 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
2378 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
2379 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
2380 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
2381
2382 { 0x4001, -8050, 0x0406, 1 }, // 9
2383 { 0x6000, 0x0409, 0x0407, 0 }, // a
2384 { 0x4001, -2750, 0x0406, 1 }, // b
2385 { 0x6000, 0x040b, 0x0408, 0 }, // c
2386 { 0x4001, -2960, 0x0406, 1 }, // d
2387 { 0x6000, 0x040d, 0x0407, 0 }, // e
2388 { 0x4001, 2120, 0x0406, 1 }, // f
2389 { 0x6000, 0x040f, 0x0407, 0 }, // 10
2390 { 0x4001, -8050, 0x0406, 1 }, // 11
2391 { 0x6000, 0x0411, 0x0408, 0 }, // 12
2392 { 0x4001, 8050, 0x0406, 1 }, // 13
2393 { 0x6000, 0x0413, 0x0408, 0 }, // 14
2394 { 0x4001, 2750, 0x0406, 1 }, // 15
2395 { 0x6000, 0x0415, 0x0408, 0 }, // 16
2396 { 0x4001, 4020, 0x0406, 1 }, // 17
2397 { 0x6000, 0x0417, 0x0407, 0 }, // 18
2398 { 0x4001, 8050, 0x0406, 1 }, // 19
2399 { 0x6000, 0x0419, 0x0407, 0 }, // 1a
2400 { 0x4001, -5930, 0x0406, 1 }, // 1b
2401 { 0x6000, 0x041b, 0x0408, 0 }, // 1c
2402 { 0x4001, 5930, 0x0406, 1 }, // 1d
2403 { 0x6000, 0x041d, 0x0408, 0 } // 1e
2404 };
2405 static const mso_CustomShape msoActionButtonSound =
2406 {
2407 (SvxMSDffVertPair*)mso_sptActionButtonSoundVert, sizeof( mso_sptActionButtonSoundVert ) / sizeof( SvxMSDffVertPair ),
2408 (sal_uInt16*)mso_sptActionButtonSoundSegm, sizeof( mso_sptActionButtonSoundSegm ) >> 1,
2409 (SvxMSDffCalculationData*)mso_sptActionButtonSoundCalc, sizeof( mso_sptActionButtonSoundCalc ) / sizeof( SvxMSDffCalculationData ),
2410 (sal_Int32*)mso_sptDefault1400,
2411 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2412 21600, 21600,
2413 0x80000000, 0x80000000,
2414 NULL, 0
2415 };
2416
2417 static const SvxMSDffVertPair mso_sptActionButtonMovieVert[] =
2418 {
2419 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
2420 { 0, 0 }, { 21600, 0 }, { 3 MSO_I, 2 MSO_I }, { 1 MSO_I, 2 MSO_I },
2421 { 21600, 0 }, { 21600, 21600 }, { 3 MSO_I, 4 MSO_I }, { 3 MSO_I, 2 MSO_I },
2422 { 21600, 21600 }, { 0, 21600 }, { 1 MSO_I, 4 MSO_I }, { 3 MSO_I, 4 MSO_I },
2423 { 0, 21600 }, { 0, 0 }, { 1 MSO_I, 2 MSO_I }, { 1 MSO_I, 4 MSO_I },
2424
2425 { 0xa MSO_I, 0xc MSO_I }, { 0xe MSO_I, 0xc MSO_I }, { 0x10 MSO_I, 0x12 MSO_I }, { 0x14 MSO_I, 0x12 MSO_I },
2426 { 0x16 MSO_I, 0x18 MSO_I }, { 0x16 MSO_I, 0x1a MSO_I }, { 0x1c MSO_I, 0x1a MSO_I }, { 0x1e MSO_I, 0x18 MSO_I },
2427 { 0x20 MSO_I, 0x18 MSO_I }, { 0x20 MSO_I, 0x22 MSO_I }, { 0x1e MSO_I, 0x22 MSO_I }, { 0x1c MSO_I, 0x24 MSO_I },
2428 { 0x16 MSO_I, 0x24 MSO_I }, { 0x16 MSO_I, 0x26 MSO_I }, { 0x2a MSO_I, 0x26 MSO_I }, { 0x2a MSO_I, 0x28 MSO_I },
2429 { 0x10 MSO_I, 0x28 MSO_I }, { 0xe MSO_I, 0x2c MSO_I }, { 0xa MSO_I, 0x2c MSO_I }
2430 };
2431 static const sal_uInt16 mso_sptActionButtonMovieSegm[] =
2432 {
2433 0x4000, 0x0003, 0x6001, 0x8000,
2434 0x4000, 0x0003, 0x6001, 0x8000,
2435 0x4000, 0x0003, 0x6001, 0x8000,
2436 0x4000, 0x0003, 0x6001, 0x8000,
2437 0x4000, 0x0003, 0x6001, 0x8000,
2438 0x4000, 0x0012, 0x6001, 0x8000
2439 };
2440 static const SvxMSDffCalculationData mso_sptActionButtonMovieCalc[] = // adj value 0 - 5400
2441 {
2442 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2443 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2444 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2445 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2446 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2447 { 0x8000, 10800, 0, DFF_Prop_adjustValue },
2448 { 0x2001, 0x0405, 1, 10800 }, // scaling 6
2449 { 0x6000, DFF_Prop_geoRight, DFF_Prop_geoLeft, 10800 }, // lr center 7
2450 { 0x6000, DFF_Prop_geoBottom, DFF_Prop_geoTop, 10800 }, // ul center 8
2451
2452 { 0x4001, -8050, 0x0406, 1 }, // 9
2453 { 0x6000, 0x0409, 0x0407, 0 }, // a
2454 { 0x4001, -4020, 0x0406, 1 }, // b
2455 { 0x6000, 0x040b, 0x0408, 0 }, // c
2456 { 0x4001, -7000, 0x0406, 1 }, // d
2457 { 0x6000, 0x040d, 0x0407, 0 }, // e
2458 { 0x4001, -6560, 0x0406, 1 }, // f
2459 { 0x6000, 0x040f, 0x0407, 0 }, // 10
2460 { 0x4001, -3600, 0x0406, 1 }, // 11
2461 { 0x6000, 0x0411, 0x0408, 0 }, // 12
2462 { 0x4001, 4020, 0x0406, 1 }, // 13
2463 { 0x6000, 0x0413, 0x0407, 0 }, // 14
2464 { 0x4001, 4660, 0x0406, 1 }, // 15
2465 { 0x6000, 0x0415, 0x0407, 0 }, // 16
2466 { 0x4001, -2960, 0x0406, 1 }, // 17
2467 { 0x6000, 0x0417, 0x0408, 0 }, // 18
2468 { 0x4001, -2330, 0x0406, 1 }, // 19
2469 { 0x6000, 0x0419, 0x0408, 0 }, // 1a
2470 { 0x4001, 6780, 0x0406, 1 }, // 1b
2471 { 0x6000, 0x041b, 0x0407, 0 }, // 1c
2472 { 0x4001, 7200, 0x0406, 1 }, // 1d
2473 { 0x6000, 0x041d, 0x0407, 0 }, // 1e
2474 { 0x4001, 8050, 0x0406, 1 }, // 1f
2475 { 0x6000, 0x041f, 0x0407, 0 }, // 20
2476 { 0x4001, 2960, 0x0406, 1 }, // 21
2477 { 0x6000, 0x0421, 0x0408, 0 }, // 22
2478 { 0x4001, 2330, 0x0406, 1 }, // 23
2479 { 0x6000, 0x0423, 0x0408, 0 }, // 24
2480 { 0x4001, 3800, 0x0406, 1 }, // 25
2481 { 0x6000, 0x0425, 0x0408, 0 }, // 26
2482 { 0x4001, -1060, 0x0406, 1 }, // 27
2483 { 0x6000, 0x0427, 0x0408, 0 }, // 28
2484 { 0x4001, -6350, 0x0406, 1 }, // 29
2485 { 0x6000, 0x0429, 0x0407, 0 }, // 2a
2486 { 0x4001, -640, 0x0406, 1 }, // 2b
2487 { 0x6000, 0x042b, 0x0408, 0 } // 2c
2488 };
2489 static const mso_CustomShape msoActionButtonMovie =
2490 {
2491 (SvxMSDffVertPair*)mso_sptActionButtonMovieVert, sizeof( mso_sptActionButtonMovieVert ) / sizeof( SvxMSDffVertPair ),
2492 (sal_uInt16*)mso_sptActionButtonMovieSegm, sizeof( mso_sptActionButtonMovieSegm ) >> 1,
2493 (SvxMSDffCalculationData*)mso_sptActionButtonMovieCalc, sizeof( mso_sptActionButtonMovieCalc ) / sizeof( SvxMSDffCalculationData ),
2494 (sal_Int32*)mso_sptDefault1400,
2495 (SvxMSDffTextRectangles*)mso_sptActionButtonTextRect, sizeof( mso_sptActionButtonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2496 21600, 21600,
2497 0x80000000, 0x80000000,
2498 NULL, 0
2499 };
2500
2501 static const SvxMSDffVertPair mso_sptSmileyFaceVert[] = // adj value 15510 - 17520
2502 {
2503 { 0, 0 }, { 21600, 21600 }, { 6140, 6350 }, { 8470, 8680 },
2504 { 13130, 6350 }, { 15460, 8680 }, { 4870, 1 MSO_I }, { 8680, 2 MSO_I },
2505 { 12920, 2 MSO_I }, { 16730, 1 MSO_I }
2506 };
2507 static const sal_uInt16 mso_sptSmileyFaceSegm[] =
2508 {
2509 0xa302, 0x6000, 0x8000,
2510 0xa302, 0x6000, 0x8000,
2511 0xa302, 0x6000, 0x8000,
2512 0x4000, 0x2001, 0x8000
2513 };
2514 static const SvxMSDffCalculationData mso_sptSmileyFaceCalc[] =
2515 {
2516 { 0x2000, DFF_Prop_adjustValue, 0, 15510 },
2517 { 0x8000, 17520, 0, 0x400 },
2518 { 0x4000, 15510, 0x400, 0 }
2519 };
2520
2521 static const SvxMSDffTextRectangles mso_sptSmileyFaceTextRect[] =
2522 {
2523 { { 0, 1 MSO_I }, { 4 MSO_I, 21600 } }
2524 };
2525 static const sal_Int32 mso_sptSmileyFaceDefault[] =
2526 {
2527 1, 17520
2528 };
2529 static const mso_CustomShape msoSmileyFace =
2530 {
2531 (SvxMSDffVertPair*)mso_sptSmileyFaceVert, sizeof( mso_sptSmileyFaceVert ) / sizeof( SvxMSDffVertPair ),
2532 (sal_uInt16*)mso_sptSmileyFaceSegm, sizeof( mso_sptSmileyFaceSegm ) >> 1,
2533 (SvxMSDffCalculationData*)mso_sptSmileyFaceCalc, sizeof( mso_sptSmileyFaceCalc ) / sizeof( SvxMSDffCalculationData ),
2534 (sal_Int32*)mso_sptSmileyFaceDefault,
2535 (SvxMSDffTextRectangles*)mso_sptEllipseTextRect, sizeof( mso_sptEllipseTextRect ) / sizeof( SvxMSDffTextRectangles ),
2536 21600, 21600,
2537 0x80000000, 0x80000000,
2538 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
2539 };
2540
2541 static const SvxMSDffVertPair mso_sptDonutVert[] = // adj value 0 - 10800
2542 {
2543 { 0, 0 }, { 21600, 21600 }, { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I }
2544 };
2545 static const sal_uInt16 mso_sptDonutSegm[] =
2546 {
2547 0xa302, 0xf8fe, 0xa302, 0x8000
2548 };
2549 static const SvxMSDffCalculationData mso_sptDonutCalc[] =
2550 {
2551 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2552 { 0x8000, 21600, 0, DFF_Prop_adjustValue }
2553 };
2554 static const mso_CustomShape msoDonut =
2555 {
2556 (SvxMSDffVertPair*)mso_sptDonutVert, sizeof( mso_sptDonutVert ) / sizeof( SvxMSDffVertPair ),
2557 (sal_uInt16*)mso_sptDonutSegm, sizeof( mso_sptDonutSegm ) >> 1,
2558 (SvxMSDffCalculationData*)mso_sptDonutCalc, sizeof( mso_sptDonutCalc ) / sizeof( SvxMSDffCalculationData ),
2559 (sal_Int32*)mso_sptDefault5400,
2560 (SvxMSDffTextRectangles*)mso_sptEllipseTextRect, sizeof( mso_sptEllipseTextRect ) / sizeof( SvxMSDffTextRectangles ),
2561 21600, 21600,
2562 0x80000000, 0x80000000,
2563 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
2564 };
2565
2566 static const SvxMSDffVertPair mso_sptNoSmokingVert[] = // adj value 0 - 7200
2567 {
2568 { 0, 0 }, { 21600, 21600 }, { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I },
2569 { 9 MSO_I, 0xa MSO_I }, { 0xb MSO_I, 0xc MSO_I }, { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I },
2570 { 0xd MSO_I, 0xe MSO_I }, { 0xf MSO_I, 0x10 MSO_I }
2571 };
2572 static const sal_uInt16 mso_sptNoSmokingSegm[] =
2573 {
2574 0xa302, 0xf8fe, 0xa404, 0xf8fe, 0xa404, 0x6000, 0x8000
2575 };
2576 static const SvxMSDffCalculationData mso_sptNoSmokingCalc[] =
2577 {
2578 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0
2579 { 0x8000, 21600, 0, DFF_Prop_adjustValue }, // 1
2580 { 0x8000, 10800, 0, DFF_Prop_adjustValue }, // 2
2581 { 0x2001, DFF_Prop_adjustValue, 1, 2 }, // 3
2582 { 0xa080, 0x403, 0, 0x402 }, // 4
2583 { 0x8000, 10800, 0, 0x403 }, // 5 x1
2584 { 0x4000, 10800, 0x403, 0 }, // 6 x2
2585 { 0x8000, 10800, 0, 0x404 }, // 7 y1
2586 { 0x4000, 10800, 0x404, 0 }, // 8 y2
2587 { 0x6081, 0x405, 0x407, 450 }, // 9
2588 { 0x6082, 0x405, 0x407, 450 }, // a
2589 { 0x6081, 0x405, 0x408, 450 }, // b
2590 { 0x6082, 0x405, 0x408, 450 }, // c
2591 { 0x6081, 0x406, 0x408, 450 }, // d
2592 { 0x6082, 0x406, 0x408, 450 }, // e
2593 { 0x6081, 0x406, 0x407, 450 }, // f
2594 { 0x6082, 0x406, 0x407, 450 } // 10
2595 };
2596 static const mso_CustomShape msoNoSmoking =
2597 {
2598 (SvxMSDffVertPair*)mso_sptNoSmokingVert, sizeof( mso_sptNoSmokingVert ) / sizeof( SvxMSDffVertPair ),
2599 (sal_uInt16*)mso_sptNoSmokingSegm, sizeof( mso_sptNoSmokingSegm ) >> 1,
2600 (SvxMSDffCalculationData*)mso_sptNoSmokingCalc, sizeof( mso_sptNoSmokingCalc ) / sizeof( SvxMSDffCalculationData ),
2601 (sal_Int32*)mso_sptDefault2700,
2602 (SvxMSDffTextRectangles*)mso_sptEllipseTextRect, sizeof( mso_sptEllipseTextRect ) / sizeof( SvxMSDffTextRectangles ),
2603 21600, 21600,
2604 0x80000000, 0x80000000,
2605 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
2606 };
2607
2608 static const SvxMSDffVertPair mso_sptBlockArcVert[] = // adj value 0 (degrees)
2609 { // adj value 1: 0 -> 10800;
2610 { 0, 0 }, { 21600, 21600 }, { 4 MSO_I, 3 MSO_I }, { 2 MSO_I, 3 MSO_I },
2611 { 5 MSO_I, 5 MSO_I }, { 6 MSO_I, 6 MSO_I }, { 2 MSO_I, 3 MSO_I }, { 4 MSO_I, 3 MSO_I },
2612 { 0, 0 }, { 21600, 21600 }
2613 };
2614 static const sal_uInt16 mso_sptBlockArcSegm[] =
2615 {
2616 0xA404, 0xa504, 0x6001, 0x8000, 0x0002, 0x8000, 0xf8ff
2617 };
2618 static const sal_Int32 mso_sptBlockArcDefault[] =
2619 {
2620 2, 180 << 16, 5400
2621 };
2622 static const SvxMSDffCalculationData mso_sptBlockArcCalc[] =
2623 {
2624 { 0x400a, 10800, DFF_Prop_adjustValue, 0 },
2625 { 0x4009, 10800, DFF_Prop_adjustValue, 0 },
2626 { 0x2000, 0x400, 10800, 0 },
2627 { 0x2000, 0x401, 10800, 0 },
2628 { 0x8000, 21600, 0, 0x402 },
2629 { 0x8000, 10800, 0, DFF_Prop_adjust2Value },
2630 { 0x4000, 10800, DFF_Prop_adjust2Value, 0 },
2631 { 0x600a, 0x405, DFF_Prop_adjustValue, 0 },
2632 { 0x6009, 0x405, DFF_Prop_adjustValue, 0 }
2633 };
2634 static const mso_CustomShape msoBlockArc =
2635 {
2636 (SvxMSDffVertPair*)mso_sptBlockArcVert, sizeof( mso_sptBlockArcVert ) / sizeof( SvxMSDffVertPair ),
2637 (sal_uInt16*)mso_sptBlockArcSegm, sizeof( mso_sptBlockArcSegm ) >> 1,
2638 (SvxMSDffCalculationData*)mso_sptBlockArcCalc, sizeof( mso_sptBlockArcCalc ) / sizeof( SvxMSDffCalculationData ),
2639 (sal_Int32*)mso_sptBlockArcDefault,
2640 NULL, 0,
2641 21600, 21600,
2642 0x80000000, 0x80000000,
2643 NULL, 0
2644 };
2645
2646 // aware : control points are always part of the bounding box
2647 static const SvxMSDffVertPair mso_sptHeartVert[] =
2648 {
2649 { 10800, 21599 }, { 321, 6886 }, { 70, 6036 }, // ppp
2650 { -9, 5766 }, { -1, 5474 }, { 2, 5192 }, // ccp
2651 { 6, 4918 }, { 43, 4641 }, { 101, 4370 }, // ccp
2652 { 159, 4103 }, { 245, 3837 }, { 353, 3582 }, // ccp
2653 { 460, 3326 }, { 591, 3077 }, { 741, 2839 }, // ccp
2654 { 892, 2598 }, { 1066, 2369 }, { 1253, 2155 }, // ccp
2655 { 1443, 1938 }, { 1651, 1732 }, { 1874, 1543 }, // ccp
2656 { 2097, 1351 }, { 2337, 1174 }, { 2587, 1014 }, // ccp
2657 { 2839, 854 }, { 3106, 708 }, { 3380, 584 }, // ccp
2658 { 3656, 459 }, { 3945, 350 }, { 4237, 264 }, // ccp
2659 { 4533, 176 }, { 4838, 108 }, { 5144, 66 }, // ccp
2660 { 5454, 22 }, { 5771, 1 }, { 6086, 3 }, // ccp
2661 { 6407, 7 }, { 6731, 35 }, { 7048, 89 }, // ccp
2662 { 7374, 144 }, { 7700, 226 }, { 8015, 335 }, // ccp
2663 { 8344, 447 }, { 8667, 590 }, { 8972, 756 }, // ccp
2664 { 9297, 932 }, { 9613, 1135 }, { 9907, 1363 }, // ccp
2665 { 10224, 1609 }, { 10504, 1900 }, { 10802, 2169 }, // ccp
2666 { 11697, 1363 }, // p
2667 { 11971, 1116 }, { 12304, 934 }, { 12630, 756 }, // ccp
2668 { 12935, 590 }, { 13528, 450 }, { 13589, 335 }, // ccp
2669 { 13901, 226 }, { 14227, 144 }, { 14556, 89 }, // ccp
2670 { 14872, 35 }, { 15195, 7 }, { 15517, 3 }, // ccp
2671 { 15830, 0 }, { 16147, 22 }, { 16458, 66 }, // ccp
2672 { 16764, 109 }, { 17068, 177 }, { 17365, 264 }, // ccp
2673 { 17658, 349 }, { 17946, 458 }, { 18222, 584 }, // ccp
2674 { 18496, 708 }, { 18762, 854 }, { 19015, 1014 }, // ccp
2675 { 19264, 1172 }, { 19504, 1349 }, { 19730, 1543 }, // ccp
2676 { 19950, 1731 }, { 20158, 1937 }, { 20350, 2155 }, // ccp
2677 { 20536, 2369 }, { 20710, 2598 }, { 20861, 2839 }, // ccp
2678 { 21010, 3074 }, { 21143, 3323 }, { 21251, 3582 }, // ccp
2679 { 21357, 3835 }, { 21443, 4099 }, { 21502, 4370 }, // ccp
2680 { 21561, 4639 }, { 21595, 4916 }, { 21600, 5192 }, // ccp
2681 { 21606, 5474 }, { 21584, 5760 }, { 21532, 6036 }, // ccp
2682 { 21478, 6326 }, { 21366, 6603 }, { 21282, 6887 }, // ccp
2683 { 10802, 21602 } // p
2684 };
2685 static const sal_uInt16 mso_sptHeartSegm[] =
2686 {
2687 0x4000, 0x0002, 0x2010, 0x0001, 0x2010, 0x0001, 0x6001, 0x8000
2688 };
2689 static const SvxMSDffTextRectangles mso_sptHeartTextRect[] =
2690 {
2691 { { 5080, 2540 }, { 16520, 13550 } }
2692 };
2693 static const SvxMSDffVertPair mso_sptHeartGluePoints[] =
2694 {
2695 { 10800, 2180 }, { 3090, 10800 }, { 10800, 21600 }, { 18490, 10800 }
2696 };
2697 static const sal_Int32 mso_sptHeartBoundRect[] =
2698 {
2699 -9, 0, 21606, 21602
2700 };
2701 static const mso_CustomShape msoHeart =
2702 {
2703 (SvxMSDffVertPair*)mso_sptHeartVert, sizeof( mso_sptHeartVert ) / sizeof( SvxMSDffVertPair ),
2704 (sal_uInt16*)mso_sptHeartSegm, sizeof( mso_sptHeartSegm ) >> 1,
2705 NULL, 0,
2706 NULL,
2707 (SvxMSDffTextRectangles*)mso_sptHeartTextRect, sizeof( mso_sptHeartTextRect ) / sizeof( SvxMSDffTextRectangles ),
2708 21615, 21602,
2709 0x80000000, 0x80000000,
2710 (SvxMSDffVertPair*)mso_sptHeartGluePoints, sizeof( mso_sptHeartGluePoints ) / sizeof( SvxMSDffVertPair )
2711 };
2712
2713 static const SvxMSDffVertPair mso_sptLightningBoldVert[] =
2714 {
2715 { 8458, 0 }, { 0, 3923 }, { 7564, 8416 }, { 4993, 9720 },
2716 { 12197, 13904 }, { 9987, 14934 }, { 21600, 21600 }, { 14768, 12911 },
2717 { 16558, 12016 }, { 11030, 6840 }, { 12831, 6120 }, { 8458, 0 }
2718 };
2719 static const SvxMSDffTextRectangles mso_sptLightningBoldTextRect[] =
2720 {
2721 { { 8680, 7410 }, { 13970, 14190 } }
2722 };
2723 static const SvxMSDffVertPair mso_sptLightningBoldGluePoints[] =
2724 {
2725 { 8458, 0 }, { 0, 3923 }, { 4993, 9720 }, { 9987, 14934 }, { 21600, 21600 },
2726 { 16558, 12016 }, { 12831, 6120 }
2727 };
2728 static const mso_CustomShape msoLightningBold =
2729 {
2730 (SvxMSDffVertPair*)mso_sptLightningBoldVert, sizeof( mso_sptLightningBoldVert ) / sizeof( SvxMSDffVertPair ),
2731 NULL, 0,
2732 NULL, 0,
2733 NULL,
2734 (SvxMSDffTextRectangles*)mso_sptLightningBoldTextRect, sizeof( mso_sptLightningBoldTextRect ) / sizeof( SvxMSDffTextRectangles ),
2735 21600, 21600,
2736 0x80000000, 0x80000000,
2737 (SvxMSDffVertPair*)mso_sptLightningBoldGluePoints, sizeof( mso_sptLightningBoldGluePoints ) / sizeof( SvxMSDffVertPair )
2738 };
2739
2740 static const SvxMSDffVertPair mso_sptSunVert[] = // adj value 2700 -> 10125
2741 {
2742 { 0, 10800 }, { 4 MSO_I, 8 MSO_I }, { 4 MSO_I, 9 MSO_I },
2743 { 0x0a MSO_I, 0x0b MSO_I }, { 0x0c MSO_I, 0x0d MSO_I }, { 0x0e MSO_I, 0x0f MSO_I },
2744 { 0x10 MSO_I, 0x11 MSO_I }, { 0x12 MSO_I, 0x13 MSO_I }, { 0x14 MSO_I, 0x15 MSO_I },
2745 { 0x16 MSO_I, 0x17 MSO_I }, { 0x18 MSO_I, 0x19 MSO_I }, { 0x1a MSO_I, 0x1b MSO_I },
2746 { 0x1c MSO_I, 0x1d MSO_I }, { 0x1e MSO_I, 0x1f MSO_I }, { 0x20 MSO_I, 0x21 MSO_I },
2747 { 0x22 MSO_I, 0x23 MSO_I }, { 0x24 MSO_I, 0x25 MSO_I }, { 0x26 MSO_I, 0x27 MSO_I },
2748 { 0x28 MSO_I, 0x29 MSO_I }, { 0x2a MSO_I, 0x2b MSO_I }, { 0x2c MSO_I, 0x2d MSO_I },
2749 { 0x2e MSO_I, 0x2f MSO_I }, { 0x30 MSO_I, 0x31 MSO_I }, { 0x32 MSO_I, 0x33 MSO_I },
2750 { 0 MSO_I, 0 MSO_I }, { 1 MSO_I, 1 MSO_I }
2751 };
2752 static const sal_uInt16 mso_sptSunSegm[] =
2753 {
2754 0x4000, 0x0002, 0x6001, 0x8000,
2755 0x4000, 0x0002, 0x6001, 0x8000,
2756 0x4000, 0x0002, 0x6001, 0x8000,
2757 0x4000, 0x0002, 0x6001, 0x8000,
2758 0x4000, 0x0002, 0x6001, 0x8000,
2759 0x4000, 0x0002, 0x6001, 0x8000,
2760 0x4000, 0x0002, 0x6001, 0x8000,
2761 0x4000, 0x0002, 0x6001, 0x8000,
2762 0xa302, 0x6000, 0x8000
2763 };
2764 static const SvxMSDffCalculationData mso_sptSunCalc[] =
2765 {
2766 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2767 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
2768 { 0x2000, DFF_Prop_adjustValue, 0, 2700 },
2769 { 0x2001, 0x402, 5080, 7425 },
2770 { 0x2000, 0x403, 2540, 0 },
2771 { 0x8000, 10125, 0, DFF_Prop_adjustValue },
2772 { 0x2001, 0x405, 2120, 7425 },
2773 { 0x2000, 0x406, 210, 0 },
2774 { 0x4000, 10800, 0x407, 0 }, // y1 (0x8)
2775 { 0x8000, 10800, 0, 0x407 }, // y2 (0x9)
2776 { 0x0081, 0, 10800, 450 }, // 0xa
2777 { 0x0082, 0, 10800, 450 }, // 0xb
2778 { 0x6081, 0x404, 0x408, 450 }, // 0xc
2779 { 0x6082, 0x404, 0x408, 450 }, // 0xd
2780 { 0x6081, 0x404, 0x409, 450 }, // 0xe
2781 { 0x6082, 0x404, 0x409, 450 }, // 0xf
2782 { 0x0081, 0, 10800, 900 }, // 0x10
2783 { 0x0082, 0, 10800, 900 }, // 0x11
2784 { 0x6081, 0x404, 0x408, 900 }, // 0x12
2785 { 0x6082, 0x404, 0x408, 900 }, // 0x13
2786 { 0x6081, 0x404, 0x409, 900 }, // 0x14
2787 { 0x6082, 0x404, 0x409, 900 }, // 0x15
2788 { 0x0081, 0, 10800, 1350 }, // 0x16
2789 { 0x0082, 0, 10800, 1350 }, // 0x17
2790 { 0x6081, 0x404, 0x408, 1350 }, // 0x18
2791 { 0x6082, 0x404, 0x408, 1350 }, // 0x19
2792 { 0x6081, 0x404, 0x409, 1350 }, // 0x1a
2793 { 0x6082, 0x404, 0x409, 1350 }, // 0x1b
2794 { 0x0081, 0, 10800, 1800 }, // 0x1c
2795 { 0x0082, 0, 10800, 1800 }, // 0x1d
2796 { 0x6081, 0x404, 0x408, 1800 }, // 0x1e
2797 { 0x6082, 0x404, 0x408, 1800 }, // 0x1f
2798 { 0x6081, 0x404, 0x409, 1800 }, // 0x20
2799 { 0x6082, 0x404, 0x409, 1800 }, // 0x21
2800 { 0x0081, 0, 10800, 2250 }, // 0x22
2801 { 0x0082, 0, 10800, 2250 }, // 0x23
2802 { 0x6081, 0x404, 0x408, 2250 }, // 0x24
2803 { 0x6082, 0x404, 0x408, 2250 }, // 0x25
2804 { 0x6081, 0x404, 0x409, 2250 }, // 0x26
2805 { 0x6082, 0x404, 0x409, 2250 }, // 0x27
2806 { 0x0081, 0, 10800, 2700 }, // 0x28
2807 { 0x0082, 0, 10800, 2700 }, // 0x29
2808 { 0x6081, 0x404, 0x408, 2700 }, // 0x2a
2809 { 0x6082, 0x404, 0x408, 2700 }, // 0x2b
2810 { 0x6081, 0x404, 0x409, 2700 }, // 0x2c
2811 { 0x6082, 0x404, 0x409, 2700 }, // 0x2d
2812 { 0x0081, 0, 10800, 3150 }, // 0x2e
2813 { 0x0082, 0, 10800, 3150 }, // 0x2f
2814 { 0x6081, 0x404, 0x408, 3150 }, // 0x30
2815 { 0x6082, 0x404, 0x408, 3150 }, // 0x31
2816 { 0x6081, 0x404, 0x409, 3150 }, // 0x32
2817 { 0x6082, 0x404, 0x409, 3150 }, // 0x33
2818 { 0x2081, DFF_Prop_adjustValue, 10800, 450 }, // 0x34 ( textbox )
2819 { 0x2081, DFF_Prop_adjustValue, 10800, 2250 } // 0x35
2820
2821 };
2822 static const SvxMSDffTextRectangles mso_sptSunTextRect[] =
2823 {
2824 { { 0x34 MSO_I, 0x34 MSO_I }, { 0x35 MSO_I, 0x35 MSO_I } }
2825 };
2826 static const mso_CustomShape msoSun =
2827 {
2828 (SvxMSDffVertPair*)mso_sptSunVert, sizeof( mso_sptSunVert ) / sizeof( SvxMSDffVertPair ),
2829 (sal_uInt16*)mso_sptSunSegm, sizeof( mso_sptSunSegm ) >> 1,
2830 (SvxMSDffCalculationData*)mso_sptSunCalc, sizeof( mso_sptSunCalc ) / sizeof( SvxMSDffCalculationData ),
2831 (sal_Int32*)mso_sptDefault5400,
2832 (SvxMSDffTextRectangles*)mso_sptSunTextRect, sizeof( mso_sptSunTextRect ) / sizeof( SvxMSDffTextRectangles ),
2833 21600, 21600,
2834 0x80000000, 0x80000000,
2835 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
2836 };
2837
2838 static const SvxMSDffVertPair mso_sptMoonVert[] = // adj value 0 -> 18900
2839 {
2840 { 21600, 0 },
2841 { 3 MSO_I, 4 MSO_I }, { 0 MSO_I, 5080 }, { 0 MSO_I, 10800 }, // ccp
2842 { 0 MSO_I, 16520 }, { 3 MSO_I, 5 MSO_I }, { 21600, 21600 }, // ccp
2843 { 9740, 21600 }, { 0, 16730 }, { 0, 10800 }, // ccp
2844 { 0, 4870 }, { 9740, 0 }, { 21600, 0 } // ccp
2845 };
2846 static const sal_uInt16 mso_sptMoonSegm[] =
2847 {
2848 0x4000, 0x2004, 0x6000, 0x8000
2849 };
2850 static const SvxMSDffCalculationData mso_sptMoonCalc[] =
2851 {
2852 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
2853 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
2854 { 0x2001, 0x401, 1, 2 },
2855 { 0x6000, 0x402, DFF_Prop_adjustValue, 0 },
2856 { 0x2001, DFF_Prop_adjustValue, 1794, 10000 },
2857 { 0x8000, 21600, 0, 0x0404 },
2858 { 0x2001, DFF_Prop_adjustValue, 4000, 18900 },
2859 { 0x8081, 0, 10800, 0x406 },
2860 { 0x8082, 0, 10800, 0x406 },
2861 { 0x6000, 0x407, 0x407, 0 },
2862 { 0x8000, 21600, 0, 0x408 }
2863 };
2864 static const SvxMSDffTextRectangles mso_sptMoonTextRect[] =
2865 {
2866 { { 9 MSO_I, 8 MSO_I }, { 0 MSO_I, 0xa MSO_I } }
2867 };
2868 static const SvxMSDffVertPair mso_sptMoonGluePoints[] =
2869 {
2870 { 21600, 0 }, { 0, 10800 }, { 21600, 21600 }, { 0 MSO_I, 10800 }
2871 };
2872 static const mso_CustomShape msoMoon =
2873 {
2874 (SvxMSDffVertPair*)mso_sptMoonVert, sizeof( mso_sptMoonVert ) / sizeof( SvxMSDffVertPair ),
2875 (sal_uInt16*)mso_sptMoonSegm, sizeof( mso_sptMoonSegm ) >> 1,
2876 (SvxMSDffCalculationData*)mso_sptMoonCalc, sizeof( mso_sptMoonCalc ) / sizeof( SvxMSDffCalculationData ),
2877 (sal_Int32*)mso_sptDefault10800,
2878 (SvxMSDffTextRectangles*)mso_sptMoonTextRect, sizeof( mso_sptMoonTextRect ) / sizeof( SvxMSDffTextRectangles ),
2879 21600, 21600,
2880 0x80000000, 0x80000000,
2881 (SvxMSDffVertPair*)mso_sptMoonGluePoints, sizeof( mso_sptMoonGluePoints ) / sizeof( SvxMSDffVertPair )
2882 };
2883
2884 static const SvxMSDffVertPair mso_sptBracketPairVert[] = // adj value 0 -> 10800
2885 {
2886 { 0 MSO_I, 0 }, { 0, 1 MSO_I }, // left top alignment
2887 { 0, 2 MSO_I }, { 0 MSO_I, 21600 }, // left bottom "
2888 { 3 MSO_I, 21600 }, { 21600, 2 MSO_I }, // right bottom "
2889 { 21600, 1 MSO_I }, { 3 MSO_I, 0 } // right top "
2890 };
2891 static const sal_uInt16 mso_sptBracketPairSegm[] =
2892 {
2893 0x4000, 0xa701, 0x0001, 0xa801, 0x8000,
2894 0x4000, 0xa701, 0x0001, 0xa801, 0x8000
2895 };
2896 static const SvxMSDffCalculationData mso_sptBracketPairCalc[] =
2897 {
2898 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2899 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2900 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2901 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2902 { 0x2082, DFF_Prop_adjustValue, 0, 450 },
2903 { 0x2000, 0x404, 0, 10800 },
2904 { 0x8000, 0, 0, DFF_Prop_adjustValue },
2905 { 0xa000, 0x406, 0, 0x405 },
2906 { 0xa000, DFF_Prop_geoLeft, 0, 0x407 },
2907 { 0xa000, DFF_Prop_geoTop, 0, 0x407 },
2908 { 0x6000, DFF_Prop_geoRight, 0x407, 0 },
2909 { 0x6000, DFF_Prop_geoBottom, 0x407, 0 },
2910 { 0xa000, DFF_Prop_geoLeft, 0, 0x405 },
2911 { 0xa000, DFF_Prop_geoTop, 0, 0x405 },
2912 { 0x6000, DFF_Prop_geoRight, 0x405, 0 },
2913 { 0x6000, DFF_Prop_geoBottom, 0x405, 0 }
2914 };
2915 static const SvxMSDffTextRectangles mso_sptBracketPairTextRect[] =
2916 {
2917 { { 8 MSO_I, 9 MSO_I }, { 0xa MSO_I, 0xb MSO_I } }
2918 };
2919 static const mso_CustomShape msoBracketPair =
2920 {
2921 (SvxMSDffVertPair*)mso_sptBracketPairVert, sizeof( mso_sptBracketPairVert ) / sizeof( SvxMSDffVertPair ),
2922 (sal_uInt16*)mso_sptBracketPairSegm, sizeof( mso_sptBracketPairSegm ) >> 1,
2923 (SvxMSDffCalculationData*)mso_sptBracketPairCalc, sizeof( mso_sptBracketPairCalc ) / sizeof( SvxMSDffCalculationData ),
2924 (sal_Int32*)mso_sptDefault3700,
2925 (SvxMSDffTextRectangles*)mso_sptBracketPairTextRect, sizeof( mso_sptBracketPairTextRect ) / sizeof( SvxMSDffTextRectangles ),
2926 21600, 21600,
2927 0x80000000, 0x80000000,
2928 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
2929 };
2930
2931 static const sal_uInt16 mso_sptPlaqueSegm[] =
2932 {
2933 0x4000, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x6000, 0x8000
2934 };
2935 static const SvxMSDffTextRectangles mso_sptPlaqueTextRect[] =
2936 {
2937 { { 0xc MSO_I, 0xd MSO_I }, { 0xe MSO_I, 0xf MSO_I } }
2938 };
2939 static const mso_CustomShape msoPlaque =
2940 {
2941 (SvxMSDffVertPair*)mso_sptBracketPairVert, sizeof( mso_sptBracketPairVert ) / sizeof( SvxMSDffVertPair ),
2942 (sal_uInt16*)mso_sptPlaqueSegm, sizeof( mso_sptPlaqueSegm ) >> 1,
2943 (SvxMSDffCalculationData*)mso_sptBracketPairCalc, sizeof( mso_sptBracketPairCalc ) / sizeof( SvxMSDffCalculationData ),
2944 (sal_Int32*)mso_sptDefault3600,
2945 (SvxMSDffTextRectangles*)mso_sptPlaqueTextRect, sizeof( mso_sptPlaqueTextRect ) / sizeof( SvxMSDffTextRectangles ),
2946 21600, 21600,
2947 0x80000000, 0x80000000,
2948 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
2949 };
2950
2951 static const SvxMSDffVertPair mso_sptBracePairVert[] = // adj value 0 -> 5400
2952 {
2953 { 4 MSO_I, 0 }, { 0 MSO_I, 1 MSO_I }, { 0 MSO_I, 6 MSO_I }, { 0 ,10800 }, // left bracket
2954 { 0 MSO_I, 7 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 4 MSO_I, 21600 },
2955 { 8 MSO_I, 21600 }, { 3 MSO_I, 2 MSO_I }, { 3 MSO_I, 7 MSO_I }, { 21600, 10800 }, // right bracket
2956 { 3 MSO_I, 6 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 8 MSO_I, 0 }
2957 };
2958 static const sal_uInt16 mso_sptBracePairSegm[] =
2959 {
2960 0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0x8000,
2961 0x4000, 0xa701, 0x0001, 0xa801, 0xa701, 0x0001, 0xa801, 0x8000
2962 };
2963 static const SvxMSDffCalculationData mso_sptBracePairCalc[] =
2964 {
2965 { 0x6000, DFF_Prop_geoLeft, DFF_Prop_adjustValue, 0 },
2966 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
2967 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
2968 { 0xa000, DFF_Prop_geoRight, 0, DFF_Prop_adjustValue },
2969 { 0x2001, 0x400, 2, 1 }, // 4
2970 { 0x2001, DFF_Prop_adjustValue, 2, 1 }, // 5
2971 { 0x8000, 10800, 0, DFF_Prop_adjustValue }, // 6
2972 { 0x8000, 21600, 0, 0x406 }, // 7
2973 { 0xa000, DFF_Prop_geoRight, 0, 0x405 }, // 8
2974 { 0x2001, DFF_Prop_adjustValue, 1, 3 }, // 9
2975 { 0x6000, 0x409, DFF_Prop_adjustValue, 0 }, // xa
2976 { 0x6000, DFF_Prop_geoLeft, 0x40a, 0 }, // xb
2977 { 0x6000, DFF_Prop_geoTop, 0x409, 0 }, // xc
2978 { 0xa000, DFF_Prop_geoRight, 0, 0x40a }, // xd
2979 { 0xa000, DFF_Prop_geoBottom, 0, 0x409 } // xe
2980
2981 };
2982 static const SvxMSDffTextRectangles mso_sptBracePairTextRect[] =
2983 {
2984 { { 0xb MSO_I, 0xc MSO_I }, { 0xd MSO_I, 0xe MSO_I } }
2985 };
2986 static const mso_CustomShape msoBracePair =
2987 {
2988 (SvxMSDffVertPair*)mso_sptBracePairVert, sizeof( mso_sptBracePairVert ) / sizeof( SvxMSDffVertPair ),
2989 (sal_uInt16*)mso_sptBracePairSegm, sizeof( mso_sptBracePairSegm ) >> 1,
2990 (SvxMSDffCalculationData*)mso_sptBracePairCalc, sizeof( mso_sptBracePairCalc ) / sizeof( SvxMSDffCalculationData ),
2991 (sal_Int32*)mso_sptDefault1800,
2992 (SvxMSDffTextRectangles*)mso_sptBracePairTextRect, sizeof( mso_sptBracePairTextRect ) / sizeof( SvxMSDffTextRectangles ),
2993 21600, 21600,
2994 0x80000000, 0x80000000,
2995 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
2996 };
2997
2998 static const SvxMSDffCalculationData mso_sptBracketCalc[] =
2999 {
3000 { 0x2001, DFF_Prop_adjustValue, 1, 2 },
3001 { 0x6000, DFF_Prop_geoTop, DFF_Prop_adjustValue, 0 },
3002 { 0xa000, DFF_Prop_geoBottom, 0, DFF_Prop_adjustValue },
3003 { 0x6000, DFF_Prop_geoTop, 0x400, 0 },
3004 { 0xa000, DFF_Prop_geoBottom, 0, 0x400 }
3005 };
3006 static const sal_uInt16 mso_sptBracketSegm[] =
3007 {
3008 0x4000, 0x2001, 0x0001, 0x2001, 0x8000
3009 };
3010 static const SvxMSDffVertPair mso_sptLeftBracketVert[] = // adj value 0 -> 10800
3011 {
3012 { 21600, 0 }, { 10800, 0 }, { 0, 3 MSO_I }, { 0, 1 MSO_I },
3013 { 0, 2 MSO_I }, { 0, 4 MSO_I }, { 10800, 21600 }, { 21600, 21600 }
3014 };
3015 static const SvxMSDffTextRectangles mso_sptLeftBracketTextRect[] =
3016 {
3017 { { 6350, 3 MSO_I }, { 21600, 4 MSO_I } }
3018 };
3019 static const SvxMSDffVertPair mso_sptLeftBracketGluePoints[] =
3020 {
3021 { 21600, 0 }, { 0, 10800 }, { 21600, 21600 }
3022 };
3023 static const mso_CustomShape msoLeftBracket =
3024 {
3025 (SvxMSDffVertPair*)mso_sptLeftBracketVert, sizeof( mso_sptLeftBracketVert ) / sizeof( SvxMSDffVertPair ),
3026 (sal_uInt16*)mso_sptBracketSegm, sizeof( mso_sptBracketSegm ) >> 1,
3027 (SvxMSDffCalculationData*)mso_sptBracketCalc, sizeof( mso_sptBracketCalc ) / sizeof( SvxMSDffCalculationData ),
3028 (sal_Int32*)mso_sptDefault1800,
3029 (SvxMSDffTextRectangles*)mso_sptLeftBracketTextRect, sizeof( mso_sptLeftBracketTextRect ) / sizeof( SvxMSDffTextRectangles ),
3030 21600, 21600,
3031 0x80000000, 0x80000000,
3032 (SvxMSDffVertPair*)mso_sptLeftBracketGluePoints, sizeof( mso_sptLeftBracketGluePoints ) / sizeof( SvxMSDffVertPair )
3033 };
3034 static const SvxMSDffVertPair mso_sptRightBracketVert[] = // adj value 0 -> 10800
3035 {
3036 { 0, 0 }, { 10800, 0 }, { 21600, 3 MSO_I }, { 21600, 1 MSO_I },
3037 { 21600, 2 MSO_I }, { 21600, 4 MSO_I }, { 10800, 21600 }, { 0, 21600 }
3038 };
3039 static const SvxMSDffTextRectangles mso_sptRightBracketTextRect[] =
3040 {
3041 { { 0, 3 MSO_I }, { 15150, 4 MSO_I } }
3042 };
3043 static const SvxMSDffVertPair mso_sptRightBracketGluePoints[] =
3044 {
3045 { 0, 0 }, { 0, 21600 }, { 21600, 10800 }
3046 };
3047 static const mso_CustomShape msoRightBracket =
3048 {
3049 (SvxMSDffVertPair*)mso_sptRightBracketVert, sizeof( mso_sptRightBracketVert ) / sizeof( SvxMSDffVertPair ),
3050 (sal_uInt16*)mso_sptBracketSegm, sizeof( mso_sptBracketSegm ) >> 1,
3051 (SvxMSDffCalculationData*)mso_sptBracketCalc, sizeof( mso_sptBracketCalc ) / sizeof( SvxMSDffCalculationData ),
3052 (sal_Int32*)mso_sptDefault1800,
3053 (SvxMSDffTextRectangles*)mso_sptRightBracketTextRect, sizeof( mso_sptRightBracketTextRect ) / sizeof( SvxMSDffTextRectangles ),
3054 21600, 21600,
3055 0x80000000, 0x80000000,
3056 (SvxMSDffVertPair*)mso_sptRightBracketGluePoints, sizeof( mso_sptRightBracketGluePoints ) / sizeof( SvxMSDffVertPair )
3057 };
3058
3059 static const SvxMSDffCalculationData mso_sptBraceCalc[] =
3060 {
3061 { 0x2001, DFF_Prop_adjustValue, 1, 2 },
3062 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
3063 { 0xa000, 0x404, 0, DFF_Prop_adjustValue },
3064 { 0xa000, 0x404, 0, 0x400 },
3065 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },
3066 { 0x6000, 0x404, 0x400, 0 },
3067 { 0x6000, 0x404, DFF_Prop_adjustValue, 0 },
3068 { 0x8000, 21600, 0, DFF_Prop_adjustValue },
3069 { 0x8000, 21600, 0, 0x400 },
3070 { 0x2001, DFF_Prop_adjustValue, 10000, 31953 },
3071 { 0x8000, 21600, 0, 0x409 }
3072 };
3073 static const sal_uInt16 mso_sptBraceSegm[] =
3074 {
3075 0x4000, 0x2001, 0x0001, 0x2002, 0x0001, 0x2001, 0x8000
3076 };
3077 static const sal_Int32 mso_sptBraceDefault[] =
3078 {
3079 2, 1800, 10800
3080 };
3081 static const SvxMSDffVertPair mso_sptLeftBraceVert[] =
3082 {
3083 { 21600, 0 }, // p
3084 { 16200, 0 }, { 10800, 0 MSO_I }, { 10800, 1 MSO_I }, // ccp
3085 { 10800, 2 MSO_I }, // p
3086 { 10800, 3 MSO_I }, { 5400, 4 MSO_I }, { 0, 4 MSO_I }, // ccp
3087 { 5400, 4 MSO_I }, { 10800, 5 MSO_I }, { 10800, 6 MSO_I }, // ccp
3088 { 10800, 7 MSO_I }, // p
3089 { 10800, 8 MSO_I }, { 16200, 21600 }, { 21600, 21600 } // ccp
3090 };
3091 static const SvxMSDffTextRectangles mso_sptLeftBraceTextRect[] =
3092 {
3093 { { 13800, 9 MSO_I }, { 21600, 10 MSO_I } }
3094 };
3095 static const mso_CustomShape msoLeftBrace = // adj value0 0 -> 5400
3096 { // adj value1 0 -> 21600
3097 (SvxMSDffVertPair*)mso_sptLeftBraceVert, sizeof( mso_sptLeftBraceVert ) / sizeof( SvxMSDffVertPair ),
3098 (sal_uInt16*)mso_sptBraceSegm, sizeof( mso_sptBraceSegm ) >> 1,
3099 (SvxMSDffCalculationData*)mso_sptBraceCalc, sizeof( mso_sptBraceCalc ) / sizeof( SvxMSDffCalculationData ),
3100 (sal_Int32*)mso_sptBraceDefault,
3101 (SvxMSDffTextRectangles*)mso_sptLeftBraceTextRect, sizeof( mso_sptLeftBraceTextRect ) / sizeof( SvxMSDffTextRectangles ),
3102 21600, 21600,
3103 0x80000000, 0x80000000,
3104 (SvxMSDffVertPair*)mso_sptLeftBracketGluePoints, sizeof( mso_sptLeftBracketGluePoints ) / sizeof( SvxMSDffVertPair )
3105 };
3106 static const SvxMSDffVertPair mso_sptRightBraceVert[] =
3107 {
3108 { 0, 0 }, // p
3109 { 5400, 0 }, { 10800, 0 MSO_I }, { 10800, 1 MSO_I }, // ccp
3110 { 10800, 2 MSO_I }, // p
3111 { 10800, 3 MSO_I }, { 16200, 4 MSO_I }, { 21600, 4 MSO_I }, // ccp
3112 { 16200, 4 MSO_I }, { 10800, 5 MSO_I }, { 10800, 6 MSO_I }, // ccp
3113 { 10800, 7 MSO_I }, // p
3114 { 10800, 8 MSO_I }, { 5400, 21600 }, { 0, 21600 } // ccp
3115 };
3116 static const SvxMSDffTextRectangles mso_sptRightBraceTextRect[] =
3117 {
3118 { { 0, 9 MSO_I }, { 7800, 10 MSO_I } }
3119 };
3120 static const mso_CustomShape msoRightBrace = // adj value0 0 -> 5400
3121 { // adj value1 0 -> 21600
3122 (SvxMSDffVertPair*)mso_sptRightBraceVert, sizeof( mso_sptRightBraceVert ) / sizeof( SvxMSDffVertPair ),
3123 (sal_uInt16*)mso_sptBraceSegm, sizeof( mso_sptBraceSegm ) >> 1,
3124 (SvxMSDffCalculationData*)mso_sptBraceCalc, sizeof( mso_sptBraceCalc ) / sizeof( SvxMSDffCalculationData ),
3125 (sal_Int32*)mso_sptBraceDefault,
3126 (SvxMSDffTextRectangles*)mso_sptRightBraceTextRect, sizeof( mso_sptRightBraceTextRect ) / sizeof( SvxMSDffTextRectangles ),
3127 21600, 21600,
3128 0x80000000, 0x80000000,
3129 (SvxMSDffVertPair*)mso_sptRightBracketGluePoints, sizeof( mso_sptRightBracketGluePoints ) / sizeof( SvxMSDffVertPair )
3130 };
3131
3132 static const SvxMSDffVertPair mso_sptIrregularSeal1Vert[] =
3133 {
3134 { 10901, 5905 }, { 8458, 2399 }, { 7417, 6425 }, { 476, 2399 },
3135 { 4732, 7722 }, { 106, 8718 }, { 3828, 11880 }, { 243, 14689 },
3136 { 5772, 14041 }, { 4868, 17719 }, { 7819, 15730 }, { 8590, 21600 },
3137 { 10637, 15038 }, { 13349, 19840 }, { 14125, 14561 }, { 18248, 18195 },
3138 { 16938, 13044 }, { 21600, 13393 }, { 17710, 10579 }, { 21198, 8242 },
3139 { 16806, 7417 }, { 18482, 4560 }, { 14257, 5429 }, { 14623, 106 }, { 10901, 5905 }
3140 };
3141 static const SvxMSDffTextRectangles mso_sptIrregularSeal1TextRect[] =
3142 {
3143 { { 4680, 6570 }, { 16140, 13280 } }
3144 };
3145 static const SvxMSDffVertPair mso_sptIrregularSeal1GluePoints[] =
3146 {
3147 { 14623, 106 }, { 106, 8718 }, { 8590, 21600 }, { 21600, 13393 }
3148 };
3149 static const mso_CustomShape msoIrregularSeal1 =
3150 {
3151 (SvxMSDffVertPair*)mso_sptIrregularSeal1Vert, sizeof( mso_sptIrregularSeal1Vert ) / sizeof( SvxMSDffVertPair ),
3152 NULL, 0,
3153 NULL, 0,
3154 NULL,
3155 (SvxMSDffTextRectangles*)mso_sptIrregularSeal1TextRect, sizeof( mso_sptIrregularSeal1TextRect ) / sizeof( SvxMSDffTextRectangles ),
3156 21600, 21600,
3157 0x80000000, 0x80000000,
3158 (SvxMSDffVertPair*)mso_sptIrregularSeal1GluePoints, sizeof( mso_sptIrregularSeal1GluePoints ) / sizeof( SvxMSDffVertPair )
3159 };
3160
3161 static const SvxMSDffVertPair mso_sptIrregularSeal2Vert[] =
3162 {
3163 { 11464, 4340 }, { 9722, 1887 }, { 8548, 6383 }, { 4503, 3626 },
3164 { 5373, 7816 }, { 1174, 8270 }, { 3934, 11592 }, { 0, 12875 },
3165 { 3329, 15372 }, { 1283, 17824 }, { 4804, 18239 }, { 4918, 21600 },
3166 { 7525, 18125 }, { 8698, 19712 }, { 9871, 17371 }, { 11614, 18844 },
3167 { 12178, 15937 }, { 14943, 17371 }, { 14640, 14348 }, { 18878, 15632 },
3168 { 16382, 12311 }, { 18270, 11292 }, { 16986, 9404 }, { 21600, 6646 },
3169 { 16382, 6533 }, { 18005, 3172 }, { 14524, 5778 }, { 14789, 0 },
3170 { 11464, 4340 }
3171 };
3172 static const SvxMSDffTextRectangles mso_sptIrregularSeal2TextRect[] =
3173 {
3174 { { 5400, 6570 }, { 14160, 15290 } }
3175 };
3176 static const SvxMSDffVertPair mso_sptIrregularSeal2GluePoints[] =
3177 {
3178 { 9722, 1887 }, { 0, 12875 }, { 11614, 18844 }, { 21600, 6646 }
3179 };
3180 static const mso_CustomShape msoIrregularSeal2 =
3181 {
3182 (SvxMSDffVertPair*)mso_sptIrregularSeal2Vert, sizeof( mso_sptIrregularSeal2Vert ) / sizeof( SvxMSDffVertPair ),
3183 NULL, 0,
3184 NULL, 0,
3185 NULL,
3186 (SvxMSDffTextRectangles*)mso_sptIrregularSeal2TextRect, sizeof( mso_sptIrregularSeal2TextRect ) / sizeof( SvxMSDffTextRectangles ),
3187 21600, 21600,
3188 0x80000000, 0x80000000,
3189 (SvxMSDffVertPair*)mso_sptIrregularSeal2GluePoints, sizeof( mso_sptIrregularSeal2GluePoints ) / sizeof( SvxMSDffVertPair )
3190 };
3191
3192 static const SvxMSDffVertPair mso_sptSeal4Vert[] = // adjustment1 : 0 - 10800
3193 {
3194 { 0, 10800 }, { 4 MSO_I, 4 MSO_I }, { 10800, 0 }, { 3 MSO_I, 4 MSO_I },
3195 { 21600, 10800 }, { 3 MSO_I, 3 MSO_I }, { 10800, 21600 }, { 4 MSO_I, 3 MSO_I },
3196 { 0, 10800 }
3197 };
3198 static const SvxMSDffCalculationData mso_sptSeal4Calc[] =
3199 {
3200 { 0x0000, 7600, 0, 0 },
3201 { 0x6001, 0x400, DFF_Prop_adjustValue, 10800 },
3202 { 0xa000, 0x400, 0, 0x401 },
3203 { 0x4000, 10800, 0x402, 0 },
3204 { 0x8000, 10800, 0, 0x402 }
3205 };
3206 static const SvxMSDffTextRectangles mso_sptSeal4TextRect[] =
3207 {
3208 { { 4 MSO_I, 4 MSO_I }, { 3 MSO_I, 3 MSO_I } }
3209 };
3210 static const mso_CustomShape msoSeal4 =
3211 {
3212 (SvxMSDffVertPair*)mso_sptSeal4Vert, sizeof( mso_sptSeal4Vert ) / sizeof( SvxMSDffVertPair ),
3213 NULL, 0,
3214 (SvxMSDffCalculationData*)mso_sptSeal4Calc, sizeof( mso_sptSeal4Calc ) / sizeof( SvxMSDffCalculationData ),
3215 (sal_Int32*)mso_sptDefault8100,
3216 (SvxMSDffTextRectangles*)mso_sptSeal4TextRect, sizeof( mso_sptSeal4TextRect ) / sizeof( SvxMSDffTextRectangles ),
3217 21600, 21600,
3218 0x80000000, 0x80000000,
3219 NULL, 0
3220 };
3221
3222 static const SvxMSDffVertPair mso_sptStarVert[] =
3223 {
3224 { 10797, 0 }, { 8278, 8256 }, { 0, 8256 }, { 6722, 13405 },
3225 { 4198, 21600 }, { 10797, 16580 }, { 17401, 21600 }, { 14878, 13405 },
3226 { 21600, 8256 }, { 13321, 8256 }, { 10797, 0 }
3227 };
3228 static const SvxMSDffTextRectangles mso_sptStarTextRect[] =
3229 {
3230 { { 6722, 8256 }, { 14878, 15460 } }
3231 };
3232 static const mso_CustomShape msoStar =
3233 {
3234 (SvxMSDffVertPair*)mso_sptStarVert, sizeof( mso_sptStarVert ) / sizeof( SvxMSDffVertPair ),
3235 NULL, 0,
3236 NULL, 0,
3237 NULL,
3238 (SvxMSDffTextRectangles*)mso_sptStarTextRect, sizeof( mso_sptStarTextRect ) / sizeof( SvxMSDffTextRectangles ),
3239 21600, 21600,
3240 0x80000000, 0x80000000,
3241 NULL, 0
3242 };
3243
3244 static const SvxMSDffCalculationData mso_sptSeal24Calc[] =
3245 {
3246 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0x00
3247 { 0x2081, 0x400, 10800, 3150 }, // 0x01 ( textframe )
3248 { 0x2082, 0x400, 10800, 3150 }, // 0x02
3249 { 0x2081, 0x400, 10800, 1350 }, // 0x03
3250 { 0x2082, 0x400, 10800, 1350 }, // 0x04
3251 { 0x0081, 0, 10800, 0 },
3252 { 0x0082, 0, 10800, 0 },
3253 { 0x2081, 0x400, 10800, 75 },
3254 { 0x2082, 0x400, 10800, 75 },
3255 { 0x0081, 0, 10800, 150 },
3256 { 0x0082, 0, 10800, 150 },
3257 { 0x2081, 0x400, 10800, 225 },
3258 { 0x2082, 0x400, 10800, 225 },
3259 { 0x0081, 0, 10800, 300 },
3260 { 0x0082, 0, 10800, 300 },
3261 { 0x2081, 0x400, 10800, 375 },
3262 { 0x2082, 0x400, 10800, 375 },
3263 { 0x0081, 0, 10800, 450 },
3264 { 0x0082, 0, 10800, 450 },
3265 { 0x2081, 0x400, 10800, 525 },
3266 { 0x2082, 0x400, 10800, 525 },
3267 { 0x0081, 0, 10800, 600 },
3268 { 0x0082, 0, 10800, 600 },
3269 { 0x2081, 0x400, 10800, 675 },
3270 { 0x2082, 0x400, 10800, 675 },
3271 { 0x0081, 0, 10800, 750 },
3272 { 0x0082, 0, 10800, 750 },
3273 { 0x2081, 0x400, 10800, 825 },
3274 { 0x2082, 0x400, 10800, 825 },
3275 { 0x0081, 0, 10800, 900 },
3276 { 0x0082, 0, 10800, 900 },
3277 { 0x2081, 0x400, 10800, 975 },
3278 { 0x2082, 0x400, 10800, 975 },
3279 { 0x0081, 0, 10800, 1050 },
3280 { 0x0082, 0, 10800, 1050 },
3281 { 0x2081, 0x400, 10800, 1125 },
3282 { 0x2082, 0x400, 10800, 1125 },
3283 { 0x0081, 0, 10800, 1200 },
3284 { 0x0082, 0, 10800, 1200 },
3285 { 0x2081, 0x400, 10800, 1275 },
3286 { 0x2082, 0x400, 10800, 1275 },
3287 { 0x0081, 0, 10800, 1350 },
3288 { 0x0082, 0, 10800, 1350 },
3289 { 0x2081, 0x400, 10800, 1425 },
3290 { 0x2082, 0x400, 10800, 1425 },
3291 { 0x0081, 0, 10800, 1500 },
3292 { 0x0082, 0, 10800, 1500 },
3293 { 0x2081, 0x400, 10800, 1575 },
3294 { 0x2082, 0x400, 10800, 1575 },
3295 { 0x0081, 0, 10800, 1650 },
3296 { 0x0082, 0, 10800, 1650 },
3297 { 0x2081, 0x400, 10800, 1725 },
3298 { 0x2082, 0x400, 10800, 1725 },
3299 { 0x0081, 0, 10800, 1800 },
3300 { 0x0082, 0, 10800, 1800 },
3301 { 0x2081, 0x400, 10800, 1875 },
3302 { 0x2082, 0x400, 10800, 1875 },
3303 { 0x0081, 0, 10800, 1950 },
3304 { 0x0082, 0, 10800, 1950 },
3305 { 0x2081, 0x400, 10800, 2025 },
3306 { 0x2082, 0x400, 10800, 2025 },
3307 { 0x0081, 0, 10800, 2100 },
3308 { 0x0082, 0, 10800, 2100 },
3309 { 0x2081, 0x400, 10800, 2175 },
3310 { 0x2082, 0x400, 10800, 2175 },
3311 { 0x0081, 0, 10800, 2250 },
3312 { 0x0082, 0, 10800, 2250 },
3313 { 0x2081, 0x400, 10800, 2325 },
3314 { 0x2082, 0x400, 10800, 2325 },
3315 { 0x0081, 0, 10800, 2400 },
3316 { 0x0082, 0, 10800, 2400 },
3317 { 0x2081, 0x400, 10800, 2475 },
3318 { 0x2082, 0x400, 10800, 2475 },
3319 { 0x0081, 0, 10800, 2550 },
3320 { 0x0082, 0, 10800, 2550 },
3321 { 0x2081, 0x400, 10800, 2625 },
3322 { 0x2082, 0x400, 10800, 2625 },
3323 { 0x0081, 0, 10800, 2700 },
3324 { 0x0082, 0, 10800, 2700 },
3325 { 0x2081, 0x400, 10800, 2775 },
3326 { 0x2082, 0x400, 10800, 2775 },
3327 { 0x0081, 0, 10800, 2850 },
3328 { 0x0082, 0, 10800, 2850 },
3329 { 0x2081, 0x400, 10800, 2925 },
3330 { 0x2082, 0x400, 10800, 2925 },
3331 { 0x0081, 0, 10800, 3000 },
3332 { 0x0082, 0, 10800, 3000 },
3333 { 0x2081, 0x400, 10800, 3075 },
3334 { 0x2082, 0x400, 10800, 3075 },
3335 { 0x0081, 0, 10800, 3150 },
3336 { 0x0082, 0, 10800, 3150 },
3337 { 0x2081, 0x400, 10800, 3225 },
3338 { 0x2082, 0x400, 10800, 3225 },
3339 { 0x0081, 0, 10800, 3300 },
3340 { 0x0082, 0, 10800, 3300 },
3341 { 0x2081, 0x400, 10800, 3375 },
3342 { 0x2082, 0x400, 10800, 3375 },
3343 { 0x0081, 0, 10800, 3450 },
3344 { 0x0082, 0, 10800, 3450 },
3345 { 0x2081, 0x400, 10800, 3525 },
3346 { 0x2082, 0x400, 10800, 3525 }
3347 };
3348 static const SvxMSDffVertPair mso_sptSeal8Vert[] = // adj value 0 -> 10800
3349 {
3350 { 5 MSO_I, 6 MSO_I }, { 11 MSO_I, 12 MSO_I }, { 17 MSO_I, 18 MSO_I }, { 23 MSO_I, 24 MSO_I },
3351 { 29 MSO_I, 30 MSO_I }, { 35 MSO_I, 36 MSO_I }, { 41 MSO_I, 42 MSO_I }, { 47 MSO_I, 48 MSO_I },
3352 { 53 MSO_I, 54 MSO_I }, { 59 MSO_I, 60 MSO_I }, { 65 MSO_I, 66 MSO_I }, { 71 MSO_I, 72 MSO_I },
3353 { 77 MSO_I, 78 MSO_I }, { 83 MSO_I, 84 MSO_I }, { 89 MSO_I, 90 MSO_I }, { 95 MSO_I, 96 MSO_I },
3354 { 5 MSO_I, 6 MSO_I }
3355 };
3356 static const SvxMSDffTextRectangles mso_sptSealTextRect[] =
3357 {
3358 { { 1 MSO_I, 2 MSO_I }, { 3 MSO_I, 4 MSO_I } }
3359 };
3360 static const mso_CustomShape msoSeal8 =
3361 {
3362 (SvxMSDffVertPair*)mso_sptSeal8Vert, sizeof( mso_sptSeal8Vert ) / sizeof( SvxMSDffVertPair ),
3363 NULL, 0,
3364 (SvxMSDffCalculationData*)mso_sptSeal24Calc, sizeof( mso_sptSeal24Calc ) / sizeof( SvxMSDffCalculationData ),
3365 (sal_Int32*)mso_sptDefault2500,
3366 (SvxMSDffTextRectangles*)mso_sptSealTextRect, sizeof( mso_sptSealTextRect ) / sizeof( SvxMSDffTextRectangles ),
3367 21600, 21600,
3368 0x80000000, 0x80000000,
3369 NULL, 0
3370 };
3371 static const SvxMSDffVertPair mso_sptSeal16Vert[] = // adj value 0 -> 10800
3372 {
3373 { 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
3374 { 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
3375 { 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
3376 { 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
3377 { 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
3378 { 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
3379 { 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
3380 { 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
3381 { 0x05 MSO_I, 0x06 MSO_I }
3382 };
3383 static const SvxMSDffCalculationData mso_sptSeal16Calc[] =
3384 {
3385 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0x00
3386 { 0x2081, 0x400, 10800, 3150 }, // 0x01 ( textframe )
3387 { 0x2082, 0x400, 10800, 3150 }, // 0x02
3388 { 0x2081, 0x400, 10800, 1350 }, // 0x03
3389 { 0x2082, 0x400, 10800, 1350 }, // 0x04
3390 { 0x0081, 0, 10800, 0 },
3391 { 0x0082, 0, 10800, 0 },
3392 { 0x2081, 0x400, 10800, 113 },
3393 { 0x2082, 0x400, 10800, 113 },
3394 { 0x0081, 0, 10800, 225 },
3395 { 0x0082, 0, 10800, 225 },
3396 { 0x2081, 0x400, 10800, 338 },
3397 { 0x2082, 0x400, 10800, 338 },
3398 { 0x0081, 0, 10800, 450 },
3399 { 0x0082, 0, 10800, 450 },
3400 { 0x2081, 0x400, 10800, 563 },
3401 { 0x2082, 0x400, 10800, 563 },
3402 { 0x0081, 0, 10800, 675 },
3403 { 0x0082, 0, 10800, 675 },
3404 { 0x2081, 0x400, 10800, 788 },
3405 { 0x2082, 0x400, 10800, 788 },
3406 { 0x0081, 0, 10800, 900 },
3407 { 0x0082, 0, 10800, 900 },
3408 { 0x2081, 0x400, 10800, 1013 },
3409 { 0x2082, 0x400, 10800, 1013 },
3410 { 0x0081, 0, 10800, 1125 },
3411 { 0x0082, 0, 10800, 1125 },
3412 { 0x2081, 0x400, 10800, 1238 },
3413 { 0x2082, 0x400, 10800, 1238 },
3414 { 0x0081, 0, 10800, 1350 },
3415 { 0x0082, 0, 10800, 1350 },
3416 { 0x2081, 0x400, 10800, 1463 },
3417 { 0x2082, 0x400, 10800, 1463 },
3418 { 0x0081, 0, 10800, 1575 },
3419 { 0x0082, 0, 10800, 1575 },
3420 { 0x2081, 0x400, 10800, 1688 },
3421 { 0x2082, 0x400, 10800, 1688 },
3422 { 0x0081, 0, 10800, 1800 },
3423 { 0x0082, 0, 10800, 1800 },
3424 { 0x2081, 0x400, 10800, 1913 },
3425 { 0x2082, 0x400, 10800, 1913 },
3426 { 0x0081, 0, 10800, 2025 },
3427 { 0x0082, 0, 10800, 2025 },
3428 { 0x2081, 0x400, 10800, 2138 },
3429 { 0x2082, 0x400, 10800, 2138 },
3430 { 0x0081, 0, 10800, 2250 },
3431 { 0x0082, 0, 10800, 2250 },
3432 { 0x2081, 0x400, 10800, 2363 },
3433 { 0x2082, 0x400, 10800, 2363 },
3434 { 0x0081, 0, 10800, 2475 },
3435 { 0x0082, 0, 10800, 2475 },
3436 { 0x2081, 0x400, 10800, 2588 },
3437 { 0x2082, 0x400, 10800, 2588 },
3438 { 0x0081, 0, 10800, 2700 },
3439 { 0x0082, 0, 10800, 2700 },
3440 { 0x2081, 0x400, 10800, 2813 },
3441 { 0x2082, 0x400, 10800, 2813 },
3442 { 0x0081, 0, 10800, 2925 },
3443 { 0x0082, 0, 10800, 2925 },
3444 { 0x2081, 0x400, 10800, 3038 },
3445 { 0x2082, 0x400, 10800, 3038 },
3446 { 0x0081, 0, 10800, 3150 },
3447 { 0x0082, 0, 10800, 3150 },
3448 { 0x2081, 0x400, 10800, 3263 },
3449 { 0x2082, 0x400, 10800, 3263 },
3450 { 0x0081, 0, 10800, 3375 },
3451 { 0x0082, 0, 10800, 3375 },
3452 { 0x2081, 0x400, 10800, 3488 },
3453 { 0x2082, 0x400, 10800, 3488 }
3454 };
3455 static const mso_CustomShape msoSeal16 =
3456 {
3457 (SvxMSDffVertPair*)mso_sptSeal16Vert, sizeof( mso_sptSeal16Vert ) / sizeof( SvxMSDffVertPair ),
3458 NULL, 0,
3459 (SvxMSDffCalculationData*)mso_sptSeal16Calc, sizeof( mso_sptSeal16Calc ) / sizeof( SvxMSDffCalculationData ),
3460 (sal_Int32*)mso_sptDefault2500,
3461 (SvxMSDffTextRectangles*)mso_sptSealTextRect, sizeof( mso_sptSealTextRect ) / sizeof( SvxMSDffTextRectangles ),
3462 21600, 21600,
3463 0x80000000, 0x80000000,
3464 NULL, 0
3465 };
3466 static const SvxMSDffVertPair mso_sptSeal24Vert[] =
3467 {
3468 { 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
3469 { 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
3470 { 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
3471 { 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
3472 { 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
3473 { 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
3474 { 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
3475 { 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
3476 { 0x45 MSO_I, 0x46 MSO_I }, { 0x47 MSO_I, 0x48 MSO_I }, { 0x49 MSO_I, 0x4a MSO_I }, { 0x4b MSO_I, 0x4c MSO_I },
3477 { 0x4d MSO_I, 0x4e MSO_I }, { 0x4f MSO_I, 0x50 MSO_I }, { 0x51 MSO_I, 0x52 MSO_I }, { 0x53 MSO_I, 0x54 MSO_I },
3478 { 0x55 MSO_I, 0x56 MSO_I }, { 0x57 MSO_I, 0x58 MSO_I }, { 0x59 MSO_I, 0x5a MSO_I }, { 0x5b MSO_I, 0x5c MSO_I },
3479 { 0x5d MSO_I, 0x5e MSO_I }, { 0x5f MSO_I, 0x60 MSO_I }, { 0x61 MSO_I, 0x62 MSO_I }, { 0x63 MSO_I, 0x64 MSO_I },
3480 { 0x05 MSO_I, 0x06 MSO_I }
3481 };
3482 static const mso_CustomShape msoSeal24 =
3483 {
3484 (SvxMSDffVertPair*)mso_sptSeal24Vert, sizeof( mso_sptSeal24Vert ) / sizeof( SvxMSDffVertPair ),
3485 NULL, 0,
3486 (SvxMSDffCalculationData*)mso_sptSeal24Calc, sizeof( mso_sptSeal24Calc ) / sizeof( SvxMSDffCalculationData ),
3487 (sal_Int32*)mso_sptDefault2500,
3488 (SvxMSDffTextRectangles*)mso_sptSealTextRect, sizeof( mso_sptSealTextRect ) / sizeof( SvxMSDffTextRectangles ),
3489 21600, 21600,
3490 0x80000000, 0x80000000,
3491 NULL, 0
3492 };
3493 static const SvxMSDffCalculationData mso_sptSeal32Calc[] =
3494 {
3495 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0x00
3496 { 0x2081, 0x400, 10800, 3150 }, // 0x01 ( textframe )
3497 { 0x2082, 0x400, 10800, 3150 }, // 0x02
3498 { 0x2081, 0x400, 10800, 1350 }, // 0x03
3499 { 0x2082, 0x400, 10800, 1350 }, // 0x04
3500 { 0x0081, 0, 10800, 0 },
3501 { 0x0082, 0, 10800, 0 },
3502 { 0x2081, 0x400, 10800, 56 },
3503 { 0x2082, 0x400, 10800, 56 },
3504 { 0x0081, 0, 10800, 113 },
3505 { 0x0082, 0, 10800, 113 },
3506 { 0x2081, 0x400, 10800, 169 },
3507 { 0x2082, 0x400, 10800, 169 },
3508 { 0x0081, 0, 10800, 225 },
3509 { 0x0082, 0, 10800, 225 },
3510 { 0x2081, 0x400, 10800, 281 },
3511 { 0x2082, 0x400, 10800, 281 },
3512 { 0x0081, 0, 10800, 338 },
3513 { 0x0082, 0, 10800, 338 },
3514 { 0x2081, 0x400, 10800, 394 },
3515 { 0x2082, 0x400, 10800, 394 },
3516 { 0x0081, 0, 10800, 450 },
3517 { 0x0082, 0, 10800, 450 },
3518 { 0x2081, 0x400, 10800, 506 },
3519 { 0x2082, 0x400, 10800, 506 },
3520 { 0x0081, 0, 10800, 563 },
3521 { 0x0082, 0, 10800, 563 },
3522 { 0x2081, 0x400, 10800, 619 },
3523 { 0x2082, 0x400, 10800, 619 },
3524 { 0x0081, 0, 10800, 675 },
3525 { 0x0082, 0, 10800, 675 },
3526 { 0x2081, 0x400, 10800, 731 },
3527 { 0x2082, 0x400, 10800, 731 },
3528 { 0x0081, 0, 10800, 788 },
3529 { 0x0082, 0, 10800, 788 },
3530 { 0x2081, 0x400, 10800, 843 },
3531 { 0x2082, 0x400, 10800, 843 },
3532 { 0x0081, 0, 10800, 900 },
3533 { 0x0082, 0, 10800, 900 },
3534 { 0x2081, 0x400, 10800, 956 },
3535 { 0x2082, 0x400, 10800, 956 },
3536 { 0x0081, 0, 10800, 1013 },
3537 { 0x0082, 0, 10800, 1013 },
3538 { 0x2081, 0x400, 10800, 1069 },
3539 { 0x2082, 0x400, 10800, 1069 },
3540 { 0x0081, 0, 10800, 1125 },
3541 { 0x0082, 0, 10800, 1125 },
3542 { 0x2081, 0x400, 10800, 1181 },
3543 { 0x2082, 0x400, 10800, 1181 },
3544 { 0x0081, 0, 10800, 1238 },
3545 { 0x0082, 0, 10800, 1238 },
3546 { 0x2081, 0x400, 10800, 1294 },
3547 { 0x2082, 0x400, 10800, 1294 },
3548 { 0x0081, 0, 10800, 1350 },
3549 { 0x0082, 0, 10800, 1350 },
3550 { 0x2081, 0x400, 10800, 1406 },
3551 { 0x2082, 0x400, 10800, 1406 },
3552 { 0x0081, 0, 10800, 1462 },
3553 { 0x0082, 0, 10800, 1462 },
3554 { 0x2081, 0x400, 10800, 1519 },
3555 { 0x2082, 0x400, 10800, 1519 },
3556 { 0x0081, 0, 10800, 1575 },
3557 { 0x0082, 0, 10800, 1575 },
3558 { 0x2081, 0x400, 10800, 1631 },
3559 { 0x2082, 0x400, 10800, 1631 },
3560 { 0x0081, 0, 10800, 1688 },
3561 { 0x0082, 0, 10800, 1688 },
3562 { 0x2081, 0x400, 10800, 1744 },
3563 { 0x2082, 0x400, 10800, 1744 },
3564 { 0x0081, 0, 10800, 1800 },
3565 { 0x0082, 0, 10800, 1800 },
3566 { 0x2081, 0x400, 10800, 1856 },
3567 { 0x2082, 0x400, 10800, 1856 },
3568 { 0x0081, 0, 10800, 1913 },
3569 { 0x0082, 0, 10800, 1913 },
3570 { 0x2081, 0x400, 10800, 1969 },
3571 { 0x2082, 0x400, 10800, 1969 },
3572 { 0x0081, 0, 10800, 2025 },
3573 { 0x0082, 0, 10800, 2025 },
3574 { 0x2081, 0x400, 10800, 2081 },
3575 { 0x2082, 0x400, 10800, 2081 },
3576 { 0x0081, 0, 10800, 2138 },
3577 { 0x0082, 0, 10800, 2138 },
3578 { 0x2081, 0x400, 10800, 2194 },
3579 { 0x2082, 0x400, 10800, 2194 },
3580 { 0x0081, 0, 10800, 2250 },
3581 { 0x0082, 0, 10800, 2250 },
3582 { 0x2081, 0x400, 10800, 2306 },
3583 { 0x2082, 0x400, 10800, 2306 },
3584 { 0x0081, 0, 10800, 2362 },
3585 { 0x0082, 0, 10800, 2362 },
3586 { 0x2081, 0x400, 10800, 2418 },
3587 { 0x2082, 0x400, 10800, 2418 },
3588 { 0x0081, 0, 10800, 2475 },
3589 { 0x0082, 0, 10800, 2475 },
3590 { 0x2081, 0x400, 10800, 2531 },
3591 { 0x2082, 0x400, 10800, 2531 },
3592 { 0x0081, 0, 10800, 2587 },
3593 { 0x0082, 0, 10800, 2587 },
3594 { 0x2081, 0x400, 10800, 2643 },
3595 { 0x2082, 0x400, 10800, 2643 },
3596 { 0x0081, 0, 10800, 2700 },
3597 { 0x0082, 0, 10800, 2700 },
3598 { 0x2081, 0x400, 10800, 2756 },
3599 { 0x2082, 0x400, 10800, 2756 },
3600 { 0x0081, 0, 10800, 2812 },
3601 { 0x0082, 0, 10800, 2812 },
3602 { 0x2081, 0x400, 10800, 2868 },
3603 { 0x2082, 0x400, 10800, 2868 },
3604 { 0x0081, 0, 10800, 2925 },
3605 { 0x0082, 0, 10800, 2925 },
3606 { 0x2081, 0x400, 10800, 2981 },
3607 { 0x2082, 0x400, 10800, 2981 },
3608 { 0x0081, 0, 10800, 3037 },
3609 { 0x0082, 0, 10800, 3037 },
3610 { 0x2081, 0x400, 10800, 3093 },
3611 { 0x2082, 0x400, 10800, 3093 },
3612 { 0x0081, 0, 10800, 3150 },
3613 { 0x0082, 0, 10800, 3150 },
3614 { 0x2081, 0x400, 10800, 3206 },
3615 { 0x2082, 0x400, 10800, 3206 },
3616 { 0x0081, 0, 10800, 3262 },
3617 { 0x0082, 0, 10800, 3262 },
3618 { 0x2081, 0x400, 10800, 3318 },
3619 { 0x2082, 0x400, 10800, 3318 },
3620 { 0x0081, 0, 10800, 3375 },
3621 { 0x0082, 0, 10800, 3375 },
3622 { 0x2081, 0x400, 10800, 3431 },
3623 { 0x2082, 0x400, 10800, 3431 },
3624 { 0x0081, 0, 10800, 3487 },
3625 { 0x0082, 0, 10800, 3487 },
3626 { 0x2081, 0x400, 10800, 3543 },
3627 { 0x2082, 0x400, 10800, 3543 }
3628 };
3629 static const SvxMSDffVertPair mso_sptSeal32Vert[] =
3630 {
3631 { 0x05 MSO_I, 0x06 MSO_I }, { 0x07 MSO_I, 0x08 MSO_I }, { 0x09 MSO_I, 0x0a MSO_I }, { 0x0b MSO_I, 0x0c MSO_I },
3632 { 0x0d MSO_I, 0x0e MSO_I }, { 0x0f MSO_I, 0x10 MSO_I }, { 0x11 MSO_I, 0x12 MSO_I }, { 0x13 MSO_I, 0x14 MSO_I },
3633 { 0x15 MSO_I, 0x16 MSO_I }, { 0x17 MSO_I, 0x18 MSO_I }, { 0x19 MSO_I, 0x1a MSO_I }, { 0x1b MSO_I, 0x1c MSO_I },
3634 { 0x1d MSO_I, 0x1e MSO_I }, { 0x1f MSO_I, 0x20 MSO_I }, { 0x21 MSO_I, 0x22 MSO_I }, { 0x23 MSO_I, 0x24 MSO_I },
3635 { 0x25 MSO_I, 0x26 MSO_I }, { 0x27 MSO_I, 0x28 MSO_I }, { 0x29 MSO_I, 0x2a MSO_I }, { 0x2b MSO_I, 0x2c MSO_I },
3636 { 0x2d MSO_I, 0x2e MSO_I }, { 0x2f MSO_I, 0x30 MSO_I }, { 0x31 MSO_I, 0x32 MSO_I }, { 0x33 MSO_I, 0x34 MSO_I },
3637 { 0x35 MSO_I, 0x36 MSO_I }, { 0x37 MSO_I, 0x38 MSO_I }, { 0x39 MSO_I, 0x3a MSO_I }, { 0x3b MSO_I, 0x3c MSO_I },
3638 { 0x3d MSO_I, 0x3e MSO_I }, { 0x3f MSO_I, 0x40 MSO_I }, { 0x41 MSO_I, 0x42 MSO_I }, { 0x43 MSO_I, 0x44 MSO_I },
3639 { 0x45 MSO_I, 0x46 MSO_I }, { 0x47 MSO_I, 0x48 MSO_I }, { 0x49 MSO_I, 0x4a MSO_I }, { 0x4b MSO_I, 0x4c MSO_I },
3640 { 0x4d MSO_I, 0x4e MSO_I }, { 0x4f MSO_I, 0x50 MSO_I }, { 0x51 MSO_I, 0x52 MSO_I }, { 0x53 MSO_I, 0x54 MSO_I },
3641 { 0x55 MSO_I, 0x56 MSO_I }, { 0x57 MSO_I, 0x58 MSO_I }, { 0x59 MSO_I, 0x5a MSO_I }, { 0x5b MSO_I, 0x5c MSO_I },
3642 { 0x5d MSO_I, 0x5e MSO_I }, { 0x5f MSO_I, 0x60 MSO_I }, { 0x61 MSO_I, 0x62 MSO_I }, { 0x63 MSO_I, 0x64 MSO_I },
3643 { 0x65 MSO_I, 0x66 MSO_I }, { 0x67 MSO_I, 0x68 MSO_I }, { 0x69 MSO_I, 0x6a MSO_I }, { 0x6b MSO_I, 0x6c MSO_I },
3644 { 0x6d MSO_I, 0x6e MSO_I }, { 0x6f MSO_I, 0x70 MSO_I }, { 0x71 MSO_I, 0x72 MSO_I }, { 0x73 MSO_I, 0x74 MSO_I },
3645 { 0x75 MSO_I, 0x76 MSO_I }, { 0x77 MSO_I, 0x78 MSO_I }, { 0x79 MSO_I, 0x7a MSO_I }, { 0x7b MSO_I, 0x7c MSO_I },
3646 { 0x7d MSO_I, 0x7e MSO_I }, { 0x7f MSO_I, 0x80 MSO_I }, { 0x81 MSO_I, 0x82 MSO_I }, { 0x83 MSO_I, 0x84 MSO_I },
3647 { 0x05 MSO_I, 0x06 MSO_I }
3648 };
3649 static const mso_CustomShape msoSeal32 =
3650 {
3651 (SvxMSDffVertPair*)mso_sptSeal32Vert, sizeof( mso_sptSeal32Vert ) / sizeof( SvxMSDffVertPair ),
3652 NULL, 0,
3653 (SvxMSDffCalculationData*)mso_sptSeal32Calc, sizeof( mso_sptSeal32Calc ) / sizeof( SvxMSDffCalculationData ),
3654 (sal_Int32*)mso_sptDefault2500,
3655 (SvxMSDffTextRectangles*)mso_sptSealTextRect, sizeof( mso_sptSealTextRect ) / sizeof( SvxMSDffTextRectangles ),
3656 21600, 21600,
3657 0x80000000, 0x80000000,
3658 NULL, 0
3659 };
3660
3661 static const SvxMSDffVertPair mso_sptRibbon2Vert[] = // adjustment1 : x 2700 - 8100 def 5400
3662 { // adjustment2 : y 14400 - 21600 def 18900
3663 { 12 MSO_I, 1 MSO_I }, { 12 MSO_I, 13 MSO_I }, // pp
3664 { 12 MSO_I, 14 MSO_I }, { 15 MSO_I, 21600 }, { 16 MSO_I, 21600 }, // ccp
3665 { 0, 21600 }, { 2750, 7 MSO_I }, { 0, 2 MSO_I }, { 0 MSO_I, 2 MSO_I }, // pppp
3666 { 0 MSO_I, 4 MSO_I }, // p
3667 { 0 MSO_I, 5 MSO_I }, { 10 MSO_I, 0 }, { 11 MSO_I, 0 }, // ccp
3668 { 17 MSO_I, 0 }, // p
3669 { 18 MSO_I, 0 }, { 19 MSO_I, 5 MSO_I }, { 19 MSO_I, 4 MSO_I }, // ccp
3670 { 19 MSO_I, 2 MSO_I }, { 21600, 2 MSO_I }, { 18850, 7 MSO_I }, { 21600, 21600 }, // pppp
3671 { 20 MSO_I, 21600 }, // p
3672 { 21 MSO_I, 21600 }, { 22 MSO_I, 14 MSO_I }, { 22 MSO_I, 13 MSO_I }, // ccp
3673 { 22 MSO_I, 1 MSO_I }, { 12 MSO_I, 1 MSO_I }, { 12 MSO_I, 13 MSO_I }, // ppp
3674 { 12 MSO_I, 23 MSO_I }, { 15 MSO_I, 24 MSO_I }, { 16 MSO_I, 24 MSO_I }, // ccp
3675 { 11 MSO_I, 24 MSO_I }, // p
3676 { 10 MSO_I, 24 MSO_I }, { 0 MSO_I, 26 MSO_I }, { 0 MSO_I, 25 MSO_I }, // ccp
3677 { 0 MSO_I, 27 MSO_I }, { 10 MSO_I, 1 MSO_I }, { 11 MSO_I, 1 MSO_I }, // ccp
3678
3679 { 22 MSO_I, 1 MSO_I }, { 22 MSO_I, 13 MSO_I }, // pp
3680 { 22 MSO_I, 23 MSO_I }, { 21 MSO_I, 24 MSO_I }, { 20 MSO_I, 24 MSO_I }, // ccp
3681 { 17 MSO_I, 24 MSO_I }, // p
3682 { 18 MSO_I, 24 MSO_I }, { 19 MSO_I, 26 MSO_I }, { 19 MSO_I, 25 MSO_I }, // ccp
3683 { 19 MSO_I, 27 MSO_I }, { 18 MSO_I, 1 MSO_I }, { 17 MSO_I, 1 MSO_I }, // ccp
3684
3685 { 0 MSO_I, 25 MSO_I }, { 0 MSO_I, 2 MSO_I }, // pp
3686
3687 { 19 MSO_I, 25 MSO_I }, { 19 MSO_I, 2 MSO_I } // pp
3688 };
3689 static const sal_uInt16 mso_sptRibbon2Segm[] =
3690 {
3691 0x4000, 0x0001, 0x2001, 0x0005, 0x2001, 0x0001, 0x2001, 0x0005, 0x2001, 0x0001, 0x6001, 0x8000,
3692 0x4000, 0x0001, 0x2001, 0x0001, 0x2002, 0x6001, 0x8000,
3693 0x4000, 0x0001, 0x2001, 0x0001, 0x2002, 0x6001, 0x8000,
3694 0x4000, 0x0001, 0x8000,
3695 0x4000, 0x0001, 0x8000
3696 };
3697 static const SvxMSDffCalculationData mso_sptRibbon2Calc[] =
3698 {
3699 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 00
3700 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 01
3701 { 0x8000, 21600, 0, 0x401 }, // 02
3702 { 0x2001, 0x402, 1, 2 }, // 03
3703 { 0x2001, 0x403, 1, 2 }, // 04
3704 { 0x2001, 0x404, 1, 2 }, // 05
3705 { 0x2001, 0x401, 1, 2 }, // 06
3706 { 0x8000, 21600, 0, 0x406 }, // 07
3707 { 0x0000, 420, 0, 0 }, // 08
3708 { 0x2001, 0x408, 2, 1 }, // 09
3709 { 0x6000, 0x400, 0x408, 0 }, // 10
3710 { 0x6000, 0x400, 0x409, 0 }, // 11
3711 { 0x2000, 0x400, 2700, 0 }, // 12
3712 { 0x8000, 21600, 0, 0x404 }, // 13
3713 { 0x8000, 21600, 0, 0x405 }, // 14
3714 { 0xa000, 0x40c, 0, 0x408 }, // 15
3715 { 0xa000, 0x40c, 0, 0x409 }, // 16
3716
3717 { 0x8000, 21600, 0, 0x40b }, // 17
3718 { 0x8000, 21600, 0, 0x40a }, // 18
3719 { 0x8000, 21600, 0, 0x400 }, // 19
3720 { 0x8000, 21600, 0, 0x410 }, // 20
3721 { 0x8000, 21600, 0, 0x40f }, // 21
3722 { 0x8000, 21600, 0, 0x40c }, // 22
3723
3724 { 0xa000, 0x40d, 0, 0x405 }, // 23
3725 { 0x6000, 0x401, 0x403, 0 }, // 24
3726 { 0x6000, 0x401, 0x404, 0 }, // 25
3727 { 0x6000, 0x419, 0x405, 0 }, // 26
3728 { 0xa000, 0x419, 0, 0x405 } // 27
3729 };
3730 static const sal_Int32 mso_sptRibbon2Default[] =
3731 {
3732 2, 5400, 18900
3733 };
3734 static const SvxMSDffTextRectangles mso_sptRibbon2TextRect[] =
3735 {
3736 { { 0 MSO_I, 0 }, { 19 MSO_I, 1 MSO_I } }
3737 };
3738 static const mso_CustomShape msoRibbon2 =
3739 {
3740 (SvxMSDffVertPair*)mso_sptRibbon2Vert, sizeof( mso_sptRibbon2Vert ) / sizeof( SvxMSDffVertPair ),
3741 (sal_uInt16*)mso_sptRibbon2Segm, sizeof( mso_sptRibbon2Segm ) >> 1,
3742 (SvxMSDffCalculationData*)mso_sptRibbon2Calc, sizeof( mso_sptRibbon2Calc ) / sizeof( SvxMSDffCalculationData ),
3743 (sal_Int32*)mso_sptRibbon2Default,
3744 (SvxMSDffTextRectangles*)mso_sptRibbon2TextRect, sizeof( mso_sptRibbon2TextRect ) / sizeof( SvxMSDffTextRectangles ),
3745 21600, 21600,
3746 0x80000000, 0x80000000,
3747 NULL, 0
3748 };
3749
3750 static const SvxMSDffVertPair mso_sptVerticalScrollVert[] = // adjustment1 : 0 - 5400
3751 {
3752 { 1 MSO_I, 21600 }, { 0, 2 MSO_I }, { 1 MSO_I, 3 MSO_I }, { 0 MSO_I, 3 MSO_I },
3753 { 0 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 }, { 2 MSO_I, 0 }, { 21600, 1 MSO_I },
3754 { 2 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 2 MSO_I }, { 5 MSO_I, 21600 },
3755
3756 { 6 MSO_I, 1 MSO_I }, { 4 MSO_I, 0 MSO_I }, { 8 MSO_I, 9 MSO_I }, { 4 MSO_I, 1 MSO_I },
3757
3758 { 0 MSO_I, 2 MSO_I }, { 1 MSO_I, 21600 }, { 0, 2 MSO_I }, { 1 MSO_I, 3 MSO_I },
3759 { 9 MSO_I, 10 MSO_I }, { 1 MSO_I, 2 MSO_I },
3760
3761 { 4 MSO_I, 0 }, { 6 MSO_I, 1 MSO_I },
3762
3763 { 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 2 MSO_I },
3764
3765 { 4 MSO_I, 0 MSO_I },
3766 { 2 MSO_I, 0 MSO_I }
3767 };
3768 static const sal_uInt16 mso_sptVerticalScrollSegm[] =
3769 {
3770 0x4000, 0xa702, 0x0002, 0xa801, 0x0001, 0xa702, 0x0002, 0xa801, 0x6001, 0x8000,
3771 0x4000, 0xa801, 0xa702, 0x6000, 0x8000,
3772 0x4000, 0xa803, 0xa702, 0x6001, 0x8000,
3773 0x4000, 0xa701, 0x8000,
3774 0x4000, 0x0001, 0x8000,
3775 0x4000, 0x0001, 0x8000
3776 };
3777 static const SvxMSDffCalculationData mso_sptScrollCalc[] =
3778 {
3779 { 0x2000, DFF_Prop_adjustValue, 0, 0 },
3780 { 0x2001, 0x400, 1, 2 },
3781 { 0x8000, 21600, 0, 0x401 },
3782 { 0x8000, 21600, 0, 0x400 },
3783 { 0x6000, 0x400, 0x401, 0 },
3784 { 0x8000, 21600, 0, 0x404 },
3785 { 0x2001, 0x400, 2, 1 },
3786 { 0x2001, 0x401, 1, 2 },
3787 { 0x6000, 0x400, 0x407, 0 },
3788 { 0x6000, 0x401, 0x407, 0 },
3789 { 0x8000, 21600, 0, 0x409 }
3790 };
3791 static const SvxMSDffTextRectangles mso_sptScrollTextRect[] =
3792 {
3793 { { 0 MSO_I, 0 MSO_I }, { 3 MSO_I, 3 MSO_I } }
3794 };
3795 static const mso_CustomShape msoVerticalScroll =
3796 {
3797 (SvxMSDffVertPair*)mso_sptVerticalScrollVert, sizeof( mso_sptVerticalScrollVert ) / sizeof( SvxMSDffVertPair ),
3798 (sal_uInt16*)mso_sptVerticalScrollSegm, sizeof( mso_sptVerticalScrollSegm ) >> 1,
3799 (SvxMSDffCalculationData*)mso_sptScrollCalc, sizeof( mso_sptScrollCalc ) / sizeof( SvxMSDffCalculationData ),
3800 (sal_Int32*)mso_sptDefault2700,
3801 (SvxMSDffTextRectangles*)mso_sptScrollTextRect, sizeof( mso_sptScrollTextRect ) / sizeof( SvxMSDffTextRectangles ),
3802 21600, 21600,
3803 11000, 10800,
3804 NULL, 0
3805 };
3806 static const SvxMSDffVertPair mso_sptHorizontalScrollVert[] = // adjustment1 : 0 - 5400
3807 {
3808 { 0, 4 MSO_I }, { 1 MSO_I, 0 MSO_I }, { 3 MSO_I, 0 MSO_I }, { 3 MSO_I, 1 MSO_I },
3809 { 2 MSO_I, 0 }, { 21600, 1 MSO_I }, { 21600, 5 MSO_I }, { 2 MSO_I, 3 MSO_I },
3810 { 0 MSO_I, 3 MSO_I }, { 0 MSO_I, 2 MSO_I }, { 1 MSO_I, 21600 }, { 0, 2 MSO_I },
3811
3812 { 1 MSO_I, 4 MSO_I }, { 9 MSO_I, 8 MSO_I }, { 0 MSO_I, 4 MSO_I }, { 1 MSO_I, 6 MSO_I },
3813
3814 { 2 MSO_I, 1 MSO_I }, { 10 MSO_I,9 MSO_I }, { 3 MSO_I, 1 MSO_I }, { 2 MSO_I, 0 },
3815 { 21600, 1 MSO_I }, { 2 MSO_I, 0 MSO_I },
3816
3817 { 1 MSO_I, 6 MSO_I },
3818 { 0, 4 MSO_I },
3819
3820 { 2 MSO_I, 0 MSO_I },
3821 { 3 MSO_I, 0 MSO_I },
3822
3823 { 0 MSO_I, 4 MSO_I },
3824 { 0 MSO_I, 2 MSO_I }
3825 };
3826 static const sal_uInt16 mso_sptHorizontalScrollSegm[] =
3827 {
3828 0x4000, 0xa801, 0x0002, 0xa802, 0x0001, 0xa801, 0x0002, 0xa802, 0x6001, 0x8000,
3829 0x4000, 0xa803, 0x6000, 0x8000,
3830 0x4000, 0xa803, 0xa702, 0x6000, 0x8000,
3831 0x4000, 0xa701, 0x8000,
3832 0x4000, 0x0001, 0x8000,
3833 0x4000, 0x0001, 0x8000
3834 };
3835 static const mso_CustomShape msoHorizontalScroll =
3836 {
3837 (SvxMSDffVertPair*)mso_sptHorizontalScrollVert, sizeof( mso_sptHorizontalScrollVert ) / sizeof( SvxMSDffVertPair ),
3838 (sal_uInt16*)mso_sptHorizontalScrollSegm, sizeof( mso_sptHorizontalScrollSegm ) >> 1,
3839 (SvxMSDffCalculationData*)mso_sptScrollCalc, sizeof( mso_sptScrollCalc ) / sizeof( SvxMSDffCalculationData ),
3840 (sal_Int32*)mso_sptDefault2700,
3841 (SvxMSDffTextRectangles*)mso_sptScrollTextRect, sizeof( mso_sptScrollTextRect ) / sizeof( SvxMSDffTextRectangles ),
3842 21600, 21600,
3843 10800, 11000,
3844 NULL, 0
3845 };
3846
3847 static const SvxMSDffVertPair mso_sptFlowChartProcessVert[] =
3848 {
3849 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 0 }
3850 };
3851 static const mso_CustomShape msoFlowChartProcess =
3852 {
3853 (SvxMSDffVertPair*)mso_sptFlowChartProcessVert, sizeof( mso_sptFlowChartProcessVert ) / sizeof( SvxMSDffVertPair ),
3854 NULL, 0,
3855 NULL, 0,
3856 NULL,
3857 NULL, 0,
3858 21600, 21600,
3859 0x80000000, 0x80000000,
3860 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
3861 };
3862
3863 static const SvxMSDffVertPair mso_sptFlowChartAlternateProcessVert[] =
3864 {
3865 { 0, 2 MSO_I }, { 0 MSO_I, 0 }, { 1 MSO_I, 0 }, { 21600, 2 MSO_I },
3866 { 21600, 3 MSO_I }, { 1 MSO_I, 21600 }, { 0 MSO_I, 21600 }, { 0, 3 MSO_I }
3867 };
3868 static const sal_uInt16 mso_sptFlowChartAlternateProcessSegm[] =
3869 {
3870 0x4000, 0xa801, 0x0001, 0xa701, 0x0001, 0xa801, 0x0001, 0xa701, 0x6000, 0x8000
3871 };
3872 static const SvxMSDffCalculationData mso_sptFlowChartAlternateProcessCalc[] =
3873 {
3874 { 0x2000, DFF_Prop_geoLeft, 2540, 0 },
3875 { 0x2000, DFF_Prop_geoRight, 0, 2540 },
3876 { 0x2000, DFF_Prop_geoTop, 2540, 0 },
3877 { 0x2000, DFF_Prop_geoBottom, 0, 2540 },
3878 { 0x2000, DFF_Prop_geoLeft, 800, 0 },
3879 { 0x2000, DFF_Prop_geoRight, 0, 800 },
3880 { 0x2000, DFF_Prop_geoTop, 800, 0 },
3881 { 0x2000, DFF_Prop_geoBottom,0, 800 }
3882 };
3883 static const SvxMSDffTextRectangles mso_sptFlowChartAlternateProcessTextRect[] =
3884 {
3885 { { 4 MSO_I, 6 MSO_I }, { 5 MSO_I, 7 MSO_I } }
3886 };
3887 static const mso_CustomShape msoFlowChartAlternateProcess =
3888 {
3889 (SvxMSDffVertPair*)mso_sptFlowChartAlternateProcessVert, sizeof( mso_sptFlowChartAlternateProcessVert ) / sizeof( SvxMSDffVertPair ),
3890 (sal_uInt16*)mso_sptFlowChartAlternateProcessSegm, sizeof( mso_sptFlowChartAlternateProcessSegm ) >> 1,
3891 (SvxMSDffCalculationData*)mso_sptFlowChartAlternateProcessCalc, sizeof( mso_sptFlowChartAlternateProcessCalc ) / sizeof( SvxMSDffCalculationData ),
3892 NULL,
3893 (SvxMSDffTextRectangles*)mso_sptFlowChartAlternateProcessTextRect, sizeof( mso_sptFlowChartAlternateProcessTextRect ) / sizeof( SvxMSDffTextRectangles ),
3894 21600, 21600,
3895 0x80000000, 0x80000000,
3896 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
3897 };
3898
3899 static const SvxMSDffVertPair mso_sptFlowChartDecisionVert[] =
3900 {
3901 { 0, 10800 }, { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 10800 }
3902 };
3903 static const SvxMSDffTextRectangles mso_sptFlowChartDecisionTextRect[] =
3904 {
3905 { { 5400, 5400 }, { 16200, 16200 } }
3906 };
3907 static const mso_CustomShape msoFlowChartDecision =
3908 {
3909 (SvxMSDffVertPair*)mso_sptFlowChartDecisionVert, sizeof( mso_sptFlowChartDecisionVert ) / sizeof( SvxMSDffVertPair ),
3910 NULL, 0,
3911 NULL, 0,
3912 NULL,
3913 (SvxMSDffTextRectangles*)mso_sptFlowChartDecisionTextRect, sizeof( mso_sptFlowChartDecisionTextRect ) / sizeof( SvxMSDffTextRectangles ),
3914 21600, 21600,
3915 0x80000000, 0x80000000,
3916 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
3917 };
3918
3919 static const SvxMSDffVertPair mso_sptFlowChartInputOutputVert[] =
3920 {
3921 { 4230, 0 }, { 21600, 0 }, { 17370, 21600 }, { 0, 21600 }, { 4230, 0 }
3922 };
3923 static const SvxMSDffTextRectangles mso_sptFlowChartInputOutputTextRect[] =
3924 {
3925 { { 4230, 0 }, { 17370, 21600 } }
3926 };
3927 static const SvxMSDffVertPair mso_sptFlowChartInputOutputGluePoints[] =
3928 {
3929 { 12960, 0 }, { 10800, 0 }, { 2160, 10800 }, { 8600, 21600 }, { 10800, 21600 }, { 19400, 10800 }
3930 };
3931 static const mso_CustomShape msoFlowChartInputOutput =
3932 {
3933 (SvxMSDffVertPair*)mso_sptFlowChartInputOutputVert, sizeof( mso_sptFlowChartInputOutputVert ) / sizeof( SvxMSDffVertPair ),
3934 NULL, 0,
3935 NULL, 0,
3936 NULL,
3937 (SvxMSDffTextRectangles*)mso_sptFlowChartInputOutputTextRect, sizeof( mso_sptFlowChartInputOutputTextRect ) / sizeof( SvxMSDffTextRectangles ),
3938 21600, 21600,
3939 0x80000000, 0x80000000,
3940 (SvxMSDffVertPair*)mso_sptFlowChartInputOutputGluePoints, sizeof( mso_sptFlowChartInputOutputGluePoints ) / sizeof( SvxMSDffVertPair )
3941 };
3942
3943 static const SvxMSDffVertPair mso_sptFlowChartPredefinedProcessVert[] =
3944 {
3945 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
3946
3947 { 2540, 0 }, { 2540, 21600 },
3948
3949 { 21600 - 2540, 0 }, { 21600 - 2540, 21600 }
3950 };
3951 static const sal_uInt16 mso_sptFlowChartPredefinedProcessSegm[] =
3952 {
3953 0x4000, 0x0003, 0x6000, 0x8000,
3954 0x4000, 0x0001, 0x8000,
3955 0x4000, 0x0001, 0x8000
3956 };
3957 static const SvxMSDffTextRectangles mso_sptFlowChartPredefinedProcessTextRect[] =
3958 {
3959 { { 2540, 0 }, { 21600 - 2540, 21600 } }
3960 };
3961 static const mso_CustomShape msoFlowChartPredefinedProcess =
3962 {
3963 (SvxMSDffVertPair*)mso_sptFlowChartPredefinedProcessVert, sizeof( mso_sptFlowChartPredefinedProcessVert ) / sizeof( SvxMSDffVertPair ),
3964 (sal_uInt16*)mso_sptFlowChartPredefinedProcessSegm, sizeof( mso_sptFlowChartPredefinedProcessSegm ) >> 1,
3965 NULL, 0,
3966 NULL,
3967 (SvxMSDffTextRectangles*)mso_sptFlowChartPredefinedProcessTextRect, sizeof( mso_sptFlowChartPredefinedProcessTextRect ) / sizeof( SvxMSDffTextRectangles ),
3968 21600, 21600,
3969 0x80000000, 0x80000000,
3970 NULL, 0
3971 };
3972
3973 static const SvxMSDffVertPair mso_sptFlowChartInternalStorageVert[] =
3974 {
3975 { 0, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
3976
3977 { 4230, 0 }, { 4230, 21600 },
3978
3979 { 0, 4230 }, { 21600, 4230 }
3980 };
3981 static const sal_uInt16 mso_sptFlowChartInternalStorageSegm[] =
3982 {
3983 0x4000, 0x0003, 0x6000, 0x8000,
3984 0x4000, 0x0001, 0x8000,
3985 0x4000, 0x0001, 0x8000
3986 };
3987 static const SvxMSDffTextRectangles mso_sptFlowChartInternalStorageTextRect[] =
3988 {
3989 { { 4230, 4230 }, { 21600, 21600 } }
3990 };
3991 static const mso_CustomShape msoFlowChartInternalStorage =
3992 {
3993 (SvxMSDffVertPair*)mso_sptFlowChartInternalStorageVert, sizeof( mso_sptFlowChartInternalStorageVert ) / sizeof( SvxMSDffVertPair ),
3994 (sal_uInt16*)mso_sptFlowChartInternalStorageSegm, sizeof( mso_sptFlowChartInternalStorageSegm ) >> 1,
3995 NULL, 0,
3996 NULL,
3997 (SvxMSDffTextRectangles*)mso_sptFlowChartInternalStorageTextRect, sizeof( mso_sptFlowChartInternalStorageTextRect ) / sizeof( SvxMSDffTextRectangles ),
3998 21600, 21600,
3999 0x80000000, 0x80000000,
4000 NULL, 0
4001 };
4002
4003 static const SvxMSDffVertPair mso_sptFlowChartDocumentVert[] =
4004 {
4005 { 0, 0 }, { 21600, 0 }, { 21600, 17360 },
4006 { 13050, 17220 }, { 13340, 20770 }, { 5620, 21600 }, // ccp
4007 { 2860, 21100 }, { 1850, 20700 }, { 0, 20120 } // ccp
4008 };
4009 static const sal_uInt16 mso_sptFlowChartDocumentSegm[] =
4010 {
4011 0x4000, 0x0002, 0x2002, 0x6000, 0x8000
4012 };
4013 static const SvxMSDffTextRectangles mso_sptFlowChartDocumentTextRect[] =
4014 {
4015 { { 0, 0 }, { 21600, 17360 } }
4016 };
4017 static const SvxMSDffVertPair mso_sptFlowChartDocumentGluePoints[] =
4018 {
4019 { 10800, 0 }, { 0, 10800 }, { 10800, 20320 }, { 21600, 10800 }
4020 };
4021 static const mso_CustomShape msoFlowChartDocument =
4022 {
4023 (SvxMSDffVertPair*)mso_sptFlowChartDocumentVert, sizeof( mso_sptFlowChartDocumentVert ) / sizeof( SvxMSDffVertPair ),
4024 (sal_uInt16*)mso_sptFlowChartDocumentSegm, sizeof( mso_sptFlowChartDocumentSegm ) >> 1,
4025 NULL, 0,
4026 NULL,
4027 (SvxMSDffTextRectangles*)mso_sptFlowChartDocumentTextRect, sizeof( mso_sptFlowChartDocumentTextRect ) / sizeof( SvxMSDffTextRectangles ),
4028 21600, 21600,
4029 0x80000000, 0x80000000,
4030 (SvxMSDffVertPair*)mso_sptFlowChartDocumentGluePoints, sizeof( mso_sptFlowChartDocumentGluePoints ) / sizeof( SvxMSDffVertPair )
4031 };
4032
4033 static const SvxMSDffVertPair mso_sptFlowChartMultidocumentVert[] =
4034 {
4035 { 0, 3600 }, { 1500, 3600 }, { 1500, 1800 }, { 3000, 1800 },
4036 { 3000, 0 }, { 21600, 0 }, { 21600, 14409 }, { 21600 - 1500, 14409 },
4037 { 21600 - 1500, 14409 + 1800 }, { 21600 - 3000, 14409 + 1800 }, { 21600 - 3000, 14409 + 3600 },
4038 { 11610, 14293 + 3600 }, { 11472, 17239 + 3600 }, { 4833, 17928 + 3600 }, // ccp
4039 { 2450, 17513 + 3600 }, { 1591, 17181 + 3600 }, { 0, 16700 + 3600 }, // ccp
4040
4041 { 1500, 3600 }, { 21600 - 3000, 3600 }, { 21600 - 3000, 14409 + 1800 },
4042
4043 { 3000, 1800 }, { 21600 - 1500, 1800 }, { 21600 - 1500, 14409 }
4044 };
4045 static const sal_uInt16 mso_sptFlowChartMultidocumentSegm[] =
4046 {
4047 0x4000, 0x000a, 0x2002, 0x6000, 0x8000,
4048 0x4000, 0x0002, 0x8000,
4049 0x4000, 0x0002, 0x8000
4050 };
4051 static const SvxMSDffTextRectangles mso_sptFlowChartMultidocumentTextRect[] =
4052 {
4053 { { 0, 3600 }, { 21600 - 3000, 14409 + 3600 } }
4054 };
4055 static const SvxMSDffVertPair mso_sptFlowChartMultidocumentGluePoints[] =
4056 {
4057 { 10800, 0 }, { 0, 10800 }, { 10800, 19890 }, { 21600, 10800 }
4058 };
4059 static const mso_CustomShape msoFlowChartMultidocument =
4060 {
4061 (SvxMSDffVertPair*)mso_sptFlowChartMultidocumentVert, sizeof( mso_sptFlowChartMultidocumentVert ) / sizeof( SvxMSDffVertPair ),
4062 (sal_uInt16*)mso_sptFlowChartMultidocumentSegm, sizeof( mso_sptFlowChartMultidocumentSegm ) >> 1,
4063 NULL, 0,
4064 NULL,
4065 (SvxMSDffTextRectangles*)mso_sptFlowChartMultidocumentTextRect, sizeof( mso_sptFlowChartMultidocumentTextRect ) / sizeof( SvxMSDffTextRectangles ),
4066 21600, 21600,
4067 0x80000000, 0x80000000,
4068 (SvxMSDffVertPair*)mso_sptFlowChartMultidocumentGluePoints, sizeof( mso_sptFlowChartMultidocumentGluePoints ) / sizeof( SvxMSDffVertPair )
4069 };
4070
4071 static const SvxMSDffVertPair mso_sptFlowChartTerminatorVert[] =
4072 {
4073 { 3470, 21600 }, { 0, 10800 }, { 3470, 0 }, { 18130, 0 },
4074 { 21600, 10800 }, { 18130, 21600 }
4075 };
4076 static const sal_uInt16 mso_sptFlowChartTerminatorSegm[] =
4077 {
4078 0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000
4079 };
4080 static const SvxMSDffTextRectangles mso_sptFlowChartTerminatorTextRect[] =
4081 {
4082 { { 1060, 3180 }, { 20540, 18420 } }
4083 };
4084 static const mso_CustomShape msoFlowChartTerminator =
4085 {
4086 (SvxMSDffVertPair*)mso_sptFlowChartTerminatorVert, sizeof( mso_sptFlowChartTerminatorVert ) / sizeof( SvxMSDffVertPair ),
4087 (sal_uInt16*)mso_sptFlowChartTerminatorSegm, sizeof( mso_sptFlowChartTerminatorSegm ) >> 1,
4088 NULL, 0,
4089 NULL,
4090 (SvxMSDffTextRectangles*)mso_sptFlowChartTerminatorTextRect, sizeof( mso_sptFlowChartTerminatorTextRect ) / sizeof( SvxMSDffTextRectangles ),
4091 21600, 21600,
4092 0x80000000, 0x80000000,
4093 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4094 };
4095
4096 static const SvxMSDffVertPair mso_sptFlowChartPreparationVert[] =
4097 {
4098 { 4350, 0 }, { 17250, 0 }, { 21600, 10800 }, { 17250, 21600 },
4099 { 4350, 21600 }, { 0, 10800 }, { 4350, 0 }
4100 };
4101 static const SvxMSDffTextRectangles mso_sptFlowChartPreparationTextRect[] =
4102 {
4103 { { 4350, 0 }, { 17250, 21600 } }
4104 };
4105 static const mso_CustomShape msoFlowChartPreparation =
4106 {
4107 (SvxMSDffVertPair*)mso_sptFlowChartPreparationVert, sizeof( mso_sptFlowChartPreparationVert ) / sizeof( SvxMSDffVertPair ),
4108 NULL, 0,
4109 NULL, 0,
4110 NULL,
4111 (SvxMSDffTextRectangles*)mso_sptFlowChartPreparationTextRect, sizeof( mso_sptFlowChartPreparationTextRect ) / sizeof( SvxMSDffTextRectangles ),
4112 21600, 21600,
4113 0x80000000, 0x80000000,
4114 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4115 };
4116
4117 static const SvxMSDffVertPair mso_sptFlowChartManualInputVert[] =
4118 {
4119 { 0, 4300 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 }, { 0, 4300 }
4120 };
4121 static const SvxMSDffTextRectangles mso_sptFlowChartManualInputTextRect[] =
4122 {
4123 { { 0, 4300 }, { 21600, 21600 } }
4124 };
4125 static const SvxMSDffVertPair mso_sptFlowChartManualInputGluePoints[] =
4126 {
4127 { 10800, 2150 }, { 0, 10800 }, { 10800, 19890 }, { 21600, 10800 }
4128 };
4129 static const mso_CustomShape msoFlowChartManualInput =
4130 {
4131 (SvxMSDffVertPair*)mso_sptFlowChartManualInputVert, sizeof( mso_sptFlowChartManualInputVert ) / sizeof( SvxMSDffVertPair ),
4132 NULL, 0,
4133 NULL, 0,
4134 NULL,
4135 (SvxMSDffTextRectangles*)mso_sptFlowChartManualInputTextRect, sizeof( mso_sptFlowChartManualInputTextRect ) / sizeof( SvxMSDffTextRectangles ),
4136 21600, 21600,
4137 0x80000000, 0x80000000,
4138 (SvxMSDffVertPair*)mso_sptFlowChartManualInputGluePoints, sizeof( mso_sptFlowChartManualInputGluePoints ) / sizeof( SvxMSDffVertPair )
4139 };
4140
4141 static const SvxMSDffVertPair mso_sptFlowChartManualOperationVert[] =
4142 {
4143 { 0, 0 }, { 21600, 0 }, { 17250, 21600 }, { 4350, 21600 }, { 0, 0 }
4144 };
4145 static const SvxMSDffTextRectangles mso_sptFlowChartManualOperationTextRect[] =
4146 {
4147 { { 4350, 0 }, { 17250, 21600 } }
4148 };
4149 static const SvxMSDffVertPair mso_sptFlowChartManualOperationGluePoints[] =
4150 {
4151 { 10800, 0 }, { 2160, 10800 }, { 10800, 21600 }, { 19440, 10800 }
4152 };
4153 static const mso_CustomShape msoFlowChartManualOperation =
4154 {
4155 (SvxMSDffVertPair*)mso_sptFlowChartManualOperationVert, sizeof( mso_sptFlowChartManualOperationVert ) / sizeof( SvxMSDffVertPair ),
4156 NULL, 0,
4157 NULL, 0,
4158 NULL,
4159 (SvxMSDffTextRectangles*)mso_sptFlowChartManualOperationTextRect, sizeof( mso_sptFlowChartManualOperationTextRect ) / sizeof( SvxMSDffTextRectangles ),
4160 21600, 21600,
4161 0x80000000, 0x80000000,
4162 (SvxMSDffVertPair*)mso_sptFlowChartManualOperationGluePoints, sizeof( mso_sptFlowChartManualOperationGluePoints ) / sizeof( SvxMSDffVertPair )
4163 };
4164
4165 static const SvxMSDffVertPair mso_sptFlowChartConnectorVert[] =
4166 {
4167 { 0, 0 }, { 21600, 21600 }
4168 };
4169 static const sal_uInt16 mso_sptFlowChartConnectorSegm[] =
4170 {
4171 0xa302, 0x6000, 0x8000
4172 };
4173 static const SvxMSDffTextRectangles mso_sptFlowChartConnectorTextRect[] =
4174 {
4175 { { 3180, 3180 }, { 18420, 18420 } }
4176 };
4177 static const mso_CustomShape msoFlowChartConnector =
4178 {
4179 (SvxMSDffVertPair*)mso_sptFlowChartConnectorVert, sizeof( mso_sptFlowChartConnectorVert ) / sizeof( SvxMSDffVertPair ),
4180 (sal_uInt16*)mso_sptFlowChartConnectorSegm, sizeof( mso_sptFlowChartConnectorSegm ) >> 1,
4181 NULL, 0,
4182 NULL,
4183 (SvxMSDffTextRectangles*)mso_sptFlowChartConnectorTextRect, sizeof( mso_sptFlowChartConnectorTextRect ) / sizeof( SvxMSDffTextRectangles ),
4184 21600, 21600,
4185 0x80000000, 0x80000000,
4186 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
4187 };
4188
4189 static const SvxMSDffVertPair mso_sptFlowChartOffpageConnectorVert[] =
4190 {
4191 { 0, 0 }, { 21600, 0 }, { 21600, 17150 }, { 10800, 21600 },
4192 { 0, 17150 }, { 0, 0 }
4193 };
4194 static const SvxMSDffTextRectangles mso_sptFlowChartOffpageConnectorTextRect[] =
4195 {
4196 { { 0, 0 }, { 21600, 17150 } }
4197 };
4198 static const mso_CustomShape msoFlowChartOffpageConnector =
4199 {
4200 (SvxMSDffVertPair*)mso_sptFlowChartOffpageConnectorVert, sizeof( mso_sptFlowChartOffpageConnectorVert ) / sizeof( SvxMSDffVertPair ),
4201 NULL, 0,
4202 NULL, 0,
4203 NULL,
4204 (SvxMSDffTextRectangles*)mso_sptFlowChartOffpageConnectorTextRect, sizeof( mso_sptFlowChartOffpageConnectorTextRect ) / sizeof( SvxMSDffTextRectangles ),
4205 21600, 21600,
4206 0x80000000, 0x80000000,
4207 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4208 };
4209
4210 static const SvxMSDffVertPair mso_sptFlowChartPunchedCardVert[] =
4211 {
4212 { 4300, 0 }, { 21600, 0 }, { 21600, 21600 }, { 0, 21600 },
4213 { 0, 4300 }, { 4300, 0 }
4214 };
4215 static const SvxMSDffTextRectangles mso_sptFlowChartPunchedCardTextRect[] =
4216 {
4217 { { 0, 4300 }, { 21600, 21600 } }
4218 };
4219 static const mso_CustomShape msoFlowChartPunchedCard =
4220 {
4221 (SvxMSDffVertPair*)mso_sptFlowChartPunchedCardVert, sizeof( mso_sptFlowChartPunchedCardVert ) / sizeof( SvxMSDffVertPair ),
4222 NULL, 0,
4223 NULL, 0,
4224 NULL,
4225 (SvxMSDffTextRectangles*)mso_sptFlowChartPunchedCardTextRect, sizeof( mso_sptFlowChartPunchedCardTextRect ) / sizeof( SvxMSDffTextRectangles ),
4226 21600, 21600,
4227 0x80000000, 0x80000000,
4228 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4229 };
4230
4231 static const SvxMSDffVertPair mso_sptFlowChartPunchedTapeVert[] =
4232 {
4233 { 0, 2230 }, // p
4234 { 820, 3990 }, { 3410, 3980 }, { 5370, 4360 }, // ccp
4235 { 7430, 4030 }, { 10110, 3890 }, { 10690, 2270 }, // ccp
4236 { 11440, 300 }, { 14200, 160 }, { 16150, 0 }, // ccp
4237 { 18670, 170 }, { 20690, 390 }, { 21600, 2230 }, // ccp
4238 { 21600, 19420 }, // p
4239 { 20640, 17510 }, { 18320, 17490 }, { 16140, 17240 }, // ccp
4240 { 14710, 17370 }, { 11310, 17510 }, { 10770, 19430 }, // ccp
4241 { 10150, 21150 }, { 7380, 21290 }, { 5290, 21600 }, // ccp
4242 { 3220, 21250 }, { 610, 21130 }, { 0, 19420 } // ccp
4243 };
4244 static const sal_uInt16 mso_sptFlowChartPunchedTapeSegm[] =
4245 {
4246 0x4000, 0x2004, 0x0001, 0x2004, 0x6000, 0x8000
4247 };
4248 static const SvxMSDffTextRectangles mso_sptFlowChartPunchedTapeTextRect[] =
4249 {
4250 { { 0, 4360 }, { 21600, 17240 } }
4251 };
4252 static const SvxMSDffVertPair mso_sptFlowChartPunchedTapeGluePoints[] =
4253 {
4254 { 10800, 2020 }, { 0, 10800 }, { 10800, 19320 }, { 21600, 10800 }
4255 };
4256 static const mso_CustomShape msoFlowChartPunchedTape =
4257 {
4258 (SvxMSDffVertPair*)mso_sptFlowChartPunchedTapeVert, sizeof( mso_sptFlowChartPunchedTapeVert ) / sizeof( SvxMSDffVertPair ),
4259 (sal_uInt16*)mso_sptFlowChartPunchedTapeSegm, sizeof( mso_sptFlowChartPunchedTapeSegm ) >> 1,
4260 NULL, 0,
4261 NULL,
4262 (SvxMSDffTextRectangles*)mso_sptFlowChartPunchedTapeTextRect, sizeof( mso_sptFlowChartPunchedTapeTextRect ) / sizeof( SvxMSDffTextRectangles ),
4263 21600, 21600,
4264 0x80000000, 0x80000000,
4265 (SvxMSDffVertPair*)mso_sptFlowChartPunchedTapeGluePoints, sizeof( mso_sptFlowChartPunchedTapeGluePoints ) / sizeof( SvxMSDffVertPair )
4266 };
4267
4268 static const SvxMSDffVertPair mso_sptFlowChartSummingJunctionVert[] =
4269 {
4270 { 0, 0 }, { 21600, 21600 },
4271
4272 { 3100, 3100 },
4273 { 18500, 18500 },
4274
4275 { 3100, 18500 },
4276 { 18500, 3100 }
4277 };
4278 static const sal_uInt16 mso_sptFlowChartSummingJunctionSegm[] =
4279 {
4280 0xa302, 0x6000, 0x8000,
4281 0x4000, 0x0001, 0x8000,
4282 0x4000, 0x0001, 0x8000
4283 };
4284 static const SvxMSDffTextRectangles mso_sptFlowChartSummingJunctionTextRect[] =
4285 {
4286 { { 3100, 3100 }, { 18500, 18500 } }
4287 };
4288 static const mso_CustomShape msoFlowChartSummingJunction =
4289 {
4290 (SvxMSDffVertPair*)mso_sptFlowChartSummingJunctionVert, sizeof( mso_sptFlowChartSummingJunctionVert ) / sizeof( SvxMSDffVertPair ),
4291 (sal_uInt16*)mso_sptFlowChartSummingJunctionSegm, sizeof( mso_sptFlowChartSummingJunctionSegm ) >> 1,
4292 NULL, 0,
4293 NULL,
4294 (SvxMSDffTextRectangles*)mso_sptFlowChartSummingJunctionTextRect, sizeof( mso_sptFlowChartSummingJunctionTextRect ) / sizeof( SvxMSDffTextRectangles ),
4295 21600, 21600,
4296 0x80000000, 0x80000000,
4297 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
4298 };
4299
4300 static const SvxMSDffVertPair mso_sptFlowChartOrVert[] =
4301 {
4302 { 0, 0 }, { 21600, 21600 },
4303
4304 { 0, 10800 }, { 21600, 10800 },
4305
4306 { 10800, 0 }, { 10800, 21600 }
4307 };
4308 static const sal_uInt16 mso_sptFlowChartOrSegm[] =
4309 {
4310 0xa302, 0x6000, 0x8000,
4311 0x4000, 0x0001, 0x8000,
4312 0x4000, 0x0001, 0x8000
4313 };
4314 static const SvxMSDffTextRectangles mso_sptFlowChartOrTextRect[] =
4315 {
4316 { { 3100, 3100 }, { 18500, 18500 } }
4317 };
4318 static const mso_CustomShape msoFlowChartOr =
4319 {
4320 (SvxMSDffVertPair*)mso_sptFlowChartOrVert, sizeof( mso_sptFlowChartOrVert ) / sizeof( SvxMSDffVertPair ),
4321 (sal_uInt16*)mso_sptFlowChartOrSegm, sizeof( mso_sptFlowChartOrSegm ) >> 1,
4322 NULL, 0,
4323 NULL,
4324 (SvxMSDffTextRectangles*)mso_sptFlowChartOrTextRect, sizeof( mso_sptFlowChartOrTextRect ) / sizeof( SvxMSDffTextRectangles ),
4325 21600, 21600,
4326 0x80000000, 0x80000000,
4327 (SvxMSDffVertPair*)mso_sptEllipseGluePoints, sizeof( mso_sptEllipseGluePoints ) / sizeof( SvxMSDffVertPair )
4328 };
4329
4330 static const SvxMSDffVertPair mso_sptFlowChartCollateVert[] =
4331 {
4332 { 0, 0 }, { 21600, 21600 }, { 0, 21600 }, { 21600, 0 }, { 0, 0 }
4333 };
4334 static const SvxMSDffTextRectangles mso_sptFlowChartCollateTextRect[] =
4335 {
4336 { { 5400, 5400 }, { 16200, 16200 } }
4337 };
4338 static const SvxMSDffVertPair mso_sptFlowChartCollateGluePoints[] =
4339 {
4340 { 10800, 0 }, { 10800, 10800 }, { 10800, 21600 }
4341 };
4342 static const mso_CustomShape msoFlowChartCollate =
4343 {
4344 (SvxMSDffVertPair*)mso_sptFlowChartCollateVert, sizeof( mso_sptFlowChartCollateVert ) / sizeof( SvxMSDffVertPair ),
4345 NULL, 0,
4346 NULL, 0,
4347 NULL,
4348 (SvxMSDffTextRectangles*)mso_sptFlowChartCollateTextRect, sizeof( mso_sptFlowChartCollateTextRect ) / sizeof( SvxMSDffTextRectangles ),
4349 21600, 21600,
4350 0x80000000, 0x80000000,
4351 (SvxMSDffVertPair*)mso_sptFlowChartCollateGluePoints, sizeof( mso_sptFlowChartCollateGluePoints ) / sizeof( SvxMSDffVertPair )
4352 };
4353
4354 static const SvxMSDffVertPair mso_sptFlowChartSortVert[] =
4355 {
4356 { 0, 10800 }, { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 },
4357
4358 { 0, 10800 }, { 21600, 10800 }
4359 };
4360 static const sal_uInt16 mso_sptFlowChartSortSegm[] =
4361 {
4362 0x4000, 0x0003, 0x6000, 0x8000,
4363 0x4000, 0x0001, 0x8000
4364 };
4365 static const SvxMSDffTextRectangles mso_sptFlowChartSortTextRect[] =
4366 {
4367 { { 5400, 5400 }, { 16200, 16200 } }
4368 };
4369 static const mso_CustomShape msoFlowChartSort =
4370 {
4371 (SvxMSDffVertPair*)mso_sptFlowChartSortVert, sizeof( mso_sptFlowChartSortVert ) / sizeof( SvxMSDffVertPair ),
4372 (sal_uInt16*)mso_sptFlowChartSortSegm, sizeof( mso_sptFlowChartSortSegm ) >> 1,
4373 NULL, 0,
4374 NULL,
4375 (SvxMSDffTextRectangles*)mso_sptFlowChartSortTextRect, sizeof( mso_sptFlowChartSortTextRect ) / sizeof( SvxMSDffTextRectangles ),
4376 21600, 21600,
4377 0x80000000, 0x80000000,
4378 NULL, 0
4379 };
4380
4381 static const SvxMSDffVertPair mso_sptFlowChartExtractVert[] =
4382 {
4383 { 10800, 0 }, { 21600, 21600 }, { 0, 21600 }, { 10800, 0 }
4384 };
4385 static const SvxMSDffTextRectangles mso_sptFlowChartExtractTextRect[] =
4386 {
4387 { { 5400, 10800 }, { 16200, 21600 } }
4388 };
4389 static const SvxMSDffVertPair mso_sptFlowChartExtractGluePoints[] =
4390 {
4391 { 10800, 0 }, { 5400, 10800 }, { 10800, 21600 }, { 16200, 10800 }
4392 };
4393 static const mso_CustomShape msoFlowChartExtract =
4394 {
4395 (SvxMSDffVertPair*)mso_sptFlowChartExtractVert, sizeof( mso_sptFlowChartExtractVert ) / sizeof( SvxMSDffVertPair ),
4396 NULL, 0,
4397 NULL, 0,
4398 NULL,
4399 (SvxMSDffTextRectangles*)mso_sptFlowChartExtractTextRect, sizeof( mso_sptFlowChartExtractTextRect ) / sizeof( SvxMSDffTextRectangles ),
4400 21600, 21600,
4401 0x80000000, 0x80000000,
4402 (SvxMSDffVertPair*)mso_sptFlowChartExtractGluePoints, sizeof( mso_sptFlowChartExtractGluePoints ) / sizeof( SvxMSDffVertPair )
4403 };
4404
4405 static const SvxMSDffVertPair mso_sptFlowChartMergeVert[] =
4406 {
4407 { 0, 0 }, { 21600, 0 }, { 10800, 21600 }, { 0, 0 }
4408 };
4409 static const SvxMSDffTextRectangles mso_sptFlowChartMergeTextRect[] =
4410 {
4411 { { 5400, 0 }, { 16200, 10800 } }
4412 };
4413 static const mso_CustomShape msoFlowChartMerge =
4414 {
4415 (SvxMSDffVertPair*)mso_sptFlowChartMergeVert, sizeof( mso_sptFlowChartMergeVert ) / sizeof( SvxMSDffVertPair ),
4416 NULL, 0,
4417 NULL, 0,
4418 NULL,
4419 (SvxMSDffTextRectangles*)mso_sptFlowChartMergeTextRect, sizeof( mso_sptFlowChartMergeTextRect ) / sizeof( SvxMSDffTextRectangles ),
4420 21600, 21600,
4421 0x80000000, 0x80000000,
4422 (SvxMSDffVertPair*)mso_sptFlowChartExtractGluePoints, sizeof( mso_sptFlowChartExtractGluePoints ) / sizeof( SvxMSDffVertPair )
4423 };
4424
4425 static const SvxMSDffVertPair mso_sptFlowChartOnlineStorageVert[] =
4426 {
4427 { 3600, 21600 }, { 0, 10800 }, { 3600, 0 }, { 21600, 0 },
4428 { 18000, 10800 }, { 21600, 21600 }
4429 };
4430 static const sal_uInt16 mso_sptFlowChartOnlineStorageSegm[] =
4431 {
4432 0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000
4433 };
4434 static const SvxMSDffTextRectangles mso_sptFlowChartOnlineStorageTextRect[] =
4435 {
4436 { { 3600, 0 }, { 18000, 21600 } }
4437 };
4438 static const SvxMSDffVertPair mso_sptFlowChartOnlineStorageGluePoints[] =
4439 {
4440 { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 18000, 10800 }
4441 };
4442 static const mso_CustomShape msoFlowChartOnlineStorage =
4443 {
4444 (SvxMSDffVertPair*)mso_sptFlowChartOnlineStorageVert, sizeof( mso_sptFlowChartOnlineStorageVert ) / sizeof( SvxMSDffVertPair ),
4445 (sal_uInt16*)mso_sptFlowChartOnlineStorageSegm, sizeof( mso_sptFlowChartOnlineStorageSegm ) >> 1,
4446 NULL, 0,
4447 NULL,
4448 (SvxMSDffTextRectangles*)mso_sptFlowChartOnlineStorageTextRect, sizeof( mso_sptFlowChartOnlineStorageTextRect ) / sizeof( SvxMSDffTextRectangles ),
4449 21600, 21600,
4450 0x80000000, 0x80000000,
4451 (SvxMSDffVertPair*)mso_sptFlowChartOnlineStorageGluePoints, sizeof( mso_sptFlowChartOnlineStorageGluePoints ) / sizeof( SvxMSDffVertPair )
4452 };
4453
4454 static const SvxMSDffVertPair mso_sptFlowChartDelayVert[] =
4455 {
4456 { 10800, 0 }, { 21600, 10800 }, { 10800, 21600 }, { 0, 21600 },
4457 { 0, 0 }
4458 };
4459 static const sal_uInt16 mso_sptFlowChartDelaySegm[] =
4460 {
4461 0x4000, 0xa702, 0x0002, 0x6000, 0x8000
4462 };
4463 static const SvxMSDffTextRectangles mso_sptFlowChartDelayTextRect[] =
4464 {
4465 { { 0, 3100 }, { 18500, 18500 } }
4466 };
4467 static const mso_CustomShape msoFlowChartDelay =
4468 {
4469 (SvxMSDffVertPair*)mso_sptFlowChartDelayVert, sizeof( mso_sptFlowChartDelayVert ) / sizeof( SvxMSDffVertPair ),
4470 (sal_uInt16*)mso_sptFlowChartDelaySegm, sizeof( mso_sptFlowChartDelaySegm ) >> 1,
4471 NULL, 0,
4472 NULL,
4473 (SvxMSDffTextRectangles*)mso_sptFlowChartDelayTextRect, sizeof( mso_sptFlowChartDelayTextRect ) / sizeof( SvxMSDffTextRectangles ),
4474 21600, 21600,
4475 0x80000000, 0x80000000,
4476 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4477 };
4478
4479 static const SvxMSDffVertPair mso_sptFlowChartMagneticTapeVert[] =
4480 {
4481 { 20980, 18150 }, { 20980, 21600 }, { 10670, 21600 },
4482 { 4770, 21540 }, { 0, 16720 }, { 0, 10800 }, // ccp
4483 { 0, 4840 }, { 4840, 0 }, { 10800, 0 }, // ccp
4484 { 16740, 0 }, { 21600, 4840 }, { 21600, 10800 }, // ccp
4485 { 21600, 13520 }, { 20550, 16160 }, { 18670, 18170 } // ccp
4486 };
4487 static const sal_uInt16 mso_sptFlowChartMagneticTapeSegm[] =
4488 {
4489 0x4000, 0x0002, 0x2004, 0x6000, 0x8000
4490 };
4491 static const SvxMSDffTextRectangles mso_sptFlowChartMagneticTapeTextRect[] =
4492 {
4493 { { 3100, 3100 }, { 18500, 18500 } }
4494 };
4495 static const mso_CustomShape msoFlowChartMagneticTape =
4496 {
4497 (SvxMSDffVertPair*)mso_sptFlowChartMagneticTapeVert, sizeof( mso_sptFlowChartMagneticTapeVert ) / sizeof( SvxMSDffVertPair ),
4498 (sal_uInt16*)mso_sptFlowChartMagneticTapeSegm, sizeof( mso_sptFlowChartMagneticTapeSegm ) >> 1,
4499 NULL, 0,
4500 NULL,
4501 (SvxMSDffTextRectangles*)mso_sptFlowChartMagneticTapeTextRect, sizeof( mso_sptFlowChartMagneticTapeTextRect ) / sizeof( SvxMSDffTextRectangles ),
4502 21600, 21600,
4503 0x80000000, 0x80000000,
4504 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4505 };
4506
4507 static const SvxMSDffVertPair mso_sptFlowChartMagneticDiskVert[] =
4508 {
4509 { 0, 3400 }, { 10800, 0 }, { 21600, 3400 }, { 21600, 18200 },
4510 { 10800, 21600 }, { 0, 18200 },
4511
4512 { 0, 3400 }, { 10800, 6800 }, { 21600, 3400 }
4513 };
4514 static const sal_uInt16 mso_sptFlowChartMagneticDiskSegm[] =
4515 {
4516 0x4000, 0xa802, 0x0001, 0xa802, 0x6000, 0x8000,
4517 0x4000, 0xa802, 0x8000
4518 };
4519 static const SvxMSDffTextRectangles mso_sptFlowChartMagneticDiskTextRect[] =
4520 {
4521 { { 0, 6800 }, { 21600, 18200 } }
4522 };
4523 static const SvxMSDffVertPair mso_sptFlowChartMagneticDiskGluePoints[] =
4524 {
4525 { 10800, 6800 }, { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }
4526 };
4527 static const mso_CustomShape msoFlowChartMagneticDisk =
4528 {
4529 (SvxMSDffVertPair*)mso_sptFlowChartMagneticDiskVert, sizeof( mso_sptFlowChartMagneticDiskVert ) / sizeof( SvxMSDffVertPair ),
4530 (sal_uInt16*)mso_sptFlowChartMagneticDiskSegm, sizeof( mso_sptFlowChartMagneticDiskSegm ) >> 1,
4531 NULL, 0,
4532 NULL,
4533 (SvxMSDffTextRectangles*)mso_sptFlowChartMagneticDiskTextRect, sizeof( mso_sptFlowChartMagneticDiskTextRect ) / sizeof( SvxMSDffTextRectangles ),
4534 21600, 21600,
4535 0x80000000, 0x80000000,
4536 (SvxMSDffVertPair*)mso_sptFlowChartMagneticDiskGluePoints, sizeof( mso_sptFlowChartMagneticDiskGluePoints ) / sizeof( SvxMSDffVertPair )
4537 };
4538
4539 static const SvxMSDffVertPair mso_sptFlowChartMagneticDrumVert[] =
4540 {
4541 { 18200, 0 }, { 21600, 10800 }, { 18200, 21600 }, { 3400, 21600 },
4542 { 0, 10800 }, { 3400, 0 },
4543
4544 { 18200, 0 }, { 14800, 10800 }, { 18200, 21600 }
4545 };
4546 static const sal_uInt16 mso_sptFlowChartMagneticDrumSegm[] =
4547 {
4548 0x4000, 0xa702, 0x0001, 0xa702, 0x6000, 0x8000,
4549 0x4000, 0xa702, 0x8000
4550 };
4551 static const SvxMSDffTextRectangles mso_sptFlowChartMagneticDrumTextRect[] =
4552 {
4553 { { 3400, 0 }, { 14800, 21600 } }
4554 };
4555 static const SvxMSDffVertPair mso_sptFlowChartMagneticDrumGluePoints[] =
4556 {
4557 { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 14800, 10800 }, { 21600, 10800 }
4558 };
4559 static const mso_CustomShape msoFlowChartMagneticDrum =
4560 {
4561 (SvxMSDffVertPair*)mso_sptFlowChartMagneticDrumVert, sizeof( mso_sptFlowChartMagneticDrumVert ) / sizeof( SvxMSDffVertPair ),
4562 (sal_uInt16*)mso_sptFlowChartMagneticDrumSegm, sizeof( mso_sptFlowChartMagneticDrumSegm ) >> 1,
4563 NULL, 0,
4564 NULL,
4565 (SvxMSDffTextRectangles*)mso_sptFlowChartMagneticDrumTextRect, sizeof( mso_sptFlowChartMagneticDrumTextRect ) / sizeof( SvxMSDffTextRectangles ),
4566 21600, 21600,
4567 0x80000000, 0x80000000,
4568 (SvxMSDffVertPair*)mso_sptFlowChartMagneticDrumGluePoints, sizeof( mso_sptFlowChartMagneticDrumGluePoints ) / sizeof( SvxMSDffVertPair )
4569 };
4570
4571 static const SvxMSDffVertPair mso_sptFlowChartDisplayVert[] =
4572 {
4573 { 3600, 0 }, { 17800, 0 }, { 21600, 10800 }, { 17800, 21600 },
4574 { 3600, 21600 }, { 0, 10800 }
4575 };
4576 static const sal_uInt16 mso_sptFlowChartDisplaySegm[] =
4577 {
4578 0x4000, 0x0001, 0xa702, 0x0002, 0x6000, 0x8000
4579 };
4580 static const SvxMSDffTextRectangles mso_sptFlowChartDisplayTextRect[] =
4581 {
4582 { { 3600, 0 }, { 17800, 21600 } }
4583 };
4584 static const mso_CustomShape msoFlowChartDisplay =
4585 {
4586 (SvxMSDffVertPair*)mso_sptFlowChartDisplayVert, sizeof( mso_sptFlowChartDisplayVert ) / sizeof( SvxMSDffVertPair ),
4587 (sal_uInt16*)mso_sptFlowChartDisplaySegm, sizeof( mso_sptFlowChartDisplaySegm ) >> 1,
4588 NULL, 0,
4589 NULL,
4590 (SvxMSDffTextRectangles*)mso_sptFlowChartDisplayTextRect, sizeof( mso_sptFlowChartDisplayTextRect ) / sizeof( SvxMSDffTextRectangles ),
4591 21600, 21600,
4592 0x80000000, 0x80000000,
4593 (SvxMSDffVertPair*)mso_sptStandardGluePoints, sizeof( mso_sptStandardGluePoints ) / sizeof( SvxMSDffVertPair )
4594 };
4595
4596 static const SvxMSDffVertPair mso_sptWedgeRectCalloutVert[] =
4597 {
4598 { 0, 0 },
4599 { 0, 3590 }, { 2 MSO_I, 3 MSO_I }, { 0, 8970 },
4600 { 0, 12630 },{ 4 MSO_I, 5 MSO_I }, { 0, 18010 },
4601 { 0, 21600 },
4602 { 3590, 21600 }, { 6 MSO_I, 7 MSO_I }, { 8970, 21600 },
4603 { 12630, 21600 }, { 8 MSO_I, 9 MSO_I }, { 18010, 21600 },
4604 { 21600, 21600 },
4605 { 21600, 18010 }, { 10 MSO_I, 11 MSO_I }, { 21600, 12630 },
4606 { 21600, 8970 }, { 12 MSO_I, 13 MSO_I }, { 21600, 3590 },
4607 { 21600, 0 },
4608 { 18010, 0 }, { 14 MSO_I, 15 MSO_I }, { 12630, 0 },
4609 { 8970, 0 }, { 16 MSO_I, 17 MSO_I }, { 3590, 0 },
4610 { 0, 0 }
4611 };
4612 static const SvxMSDffCalculationData mso_sptWedgeRectCalloutCalc[] =
4613 {
4614 { 0x2000, DFF_Prop_adjustValue, 0, 10800 }, //0x400
4615 { 0x2000, DFF_Prop_adjust2Value, 0,10800 },
4616 { 0x6006, 0x412, DFF_Prop_adjustValue, 0 }, //0x402
4617 { 0x6006, 0x412, DFF_Prop_adjust2Value, 6280 },
4618 { 0x6006, 0x417, DFF_Prop_adjustValue, 0 }, //0x404
4619 { 0x6006, 0x417, DFF_Prop_adjust2Value, 15320 },
4620 { 0x6006, 0x41a, DFF_Prop_adjustValue, 6280 }, //0x406
4621 { 0x6006, 0x41a, DFF_Prop_adjust2Value, 21600 },
4622 { 0x6006, 0x41d, DFF_Prop_adjustValue, 15320 }, //0x408
4623 { 0x6006, 0x41d, DFF_Prop_adjust2Value, 21600 },
4624 { 0x6006, 0x420, DFF_Prop_adjustValue, 21600 }, //0x40a
4625 { 0x6006, 0x420, DFF_Prop_adjust2Value, 15320 },
4626 { 0x6006, 0x422, DFF_Prop_adjustValue, 21600 }, //0x40c
4627 { 0x6006, 0x422, DFF_Prop_adjust2Value, 6280 },
4628 { 0x6006, 0x424, DFF_Prop_adjustValue, 15320 }, //0x40e
4629 { 0x6006, 0x424, DFF_Prop_adjust2Value, 0 },
4630 { 0x6006, 0x426, DFF_Prop_adjustValue, 6280 }, //0x410
4631 { 0x6006, 0x426, DFF_Prop_adjust2Value, 0 },
4632 { 0xa006, DFF_Prop_adjustValue, -1, 0x413 }, //0x412
4633 { 0xa006, 0x401, -1, 0x416 },
4634 { 0x2003, 0x400, 0, 0 }, //0x414
4635 { 0x2003, 0x401, 0, 0 },
4636 { 0xa000, 0x414, 0, 0x415 }, //0x416
4637 { 0xa006, DFF_Prop_adjustValue, -1, 0x418 },
4638 { 0x6006, 0x401, 0x416, -1 }, //0x418
4639 { 0x2000, DFF_Prop_adjust2Value, 0, 21600 },
4640 { 0x6006, 0x419, 0x41b, -1 }, //0x41a
4641 { 0xa006, 0x400, -1, 0x41c },
4642 { 0xa000, 0x415, 0, 0x414 }, //0x41c
4643 { 0x6006, 0x419, 0x41e, -1 },
4644 { 0x6006, 0x400, 0x41c, -1 }, //0x41e
4645 { 0x2000, DFF_Prop_adjustValue, 0, 21600 },
4646 { 0x6006, 0x41f, 0x421, -1 }, //0x420
4647 { 0x6006, 0x401, 0x416, -1 },
4648 { 0x6006, 0x41f, 0x423, -1 }, //0x422
4649 { 0xa006, 0x401, -1, 0x416 },
4650 { 0xa006, DFF_Prop_adjust2Value, -1, 0x425 }, //0x424
4651 { 0x6006, 0x400, 0x41c, -1 },
4652 { 0xa006, DFF_Prop_adjust2Value, -1, 0x427 }, //0x426
4653 { 0xa006, 0x400, -1, 0x41c },
4654 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, //0x428
4655 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }
4656 };
4657 static const sal_Int32 mso_sptWedgeRectCalloutDefault[] =
4658 {
4659 2, 1400, 25920
4660 };
4661 static const SvxMSDffTextRectangles mso_sptWedgeRectCalloutTextRect[] =
4662 {
4663 { { 0, 0 }, { 21600, 21600 } }
4664 };
4665 static const SvxMSDffVertPair mso_sptWedgeRectCalloutGluePoints[] =
4666 {
4667 { 10800, 0 }, { 0, 10800 }, { 10800, 21600 }, { 21600, 10800 }, { 40 MSO_I, 41 MSO_I }
4668 };
4669 static const mso_CustomShape msoWedgeRectCallout =
4670 {
4671 (SvxMSDffVertPair*)mso_sptWedgeRectCalloutVert, sizeof( mso_sptWedgeRectCalloutVert ) / sizeof( SvxMSDffVertPair ),
4672 NULL, 0,
4673 (SvxMSDffCalculationData*)mso_sptWedgeRectCalloutCalc, sizeof( mso_sptWedgeRectCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
4674 (sal_Int32*)mso_sptWedgeRectCalloutDefault,
4675 (SvxMSDffTextRectangles*)mso_sptWedgeRectCalloutTextRect, sizeof( mso_sptWedgeRectCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
4676 21600, 21600,
4677 0x80000000, 0x80000000,
4678 (SvxMSDffVertPair*)mso_sptWedgeRectCalloutGluePoints, sizeof( mso_sptWedgeRectCalloutGluePoints ) / sizeof( SvxMSDffVertPair )
4679 };
4680
4681 static const SvxMSDffVertPair mso_sptWaveVert[] = // adjustment1 : 0 - 4460
4682 { // adjustment2 : 8640 - 12960
4683 { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
4684 { 24 MSO_I, 1 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 29 MSO_I, 1 MSO_I }
4685 };
4686 static const SvxMSDffCalculationData mso_sptWaveCalc[] =
4687 {
4688 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, //400 (vert.adj)
4689 { 0x8000, 21600, 0, 0x400 }, //401
4690 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },//402 (horz.adj)
4691 { 0x2000, 0x402, 0, 10800 }, //403 -2160 -> 2160 (horz.adj)
4692 { 0x2001, 0x403, 2, 1 }, //404 -4320 -> 4320 (horz.adj)
4693 { 0x2003, 0x404, 0, 0 }, //405 abs( 0x404 ) (horz.adj)
4694 { 0x8000, 4320, 0, 0x405 }, //406
4695 { 0xa006, 0x403, 0, 0x405 }, //407
4696 { 0x4001, 15800, 0x400, 4460 }, //408 0 -> 15800 (vert.adj)
4697 { 0xa000, 0x400, 0, 0x408 }, //409
4698 { 0x6000, 0x400, 0x408, 0 }, //40a
4699 { 0x8000, 21600, 0, 0x404 }, //40b
4700 { 0x6006, 0x403, 0x40b, 21600 }, //40c
4701 { 0xa000, 0x40c, 0, 0x407 }, //40d width between p0 and p1
4702 { 0x2001, 0x405, 1, 2 }, //40e
4703 { 0xa000, 0x407, 7200, 0x40e }, //40f
4704 { 0x6000, 0x40c, 0x40e, 7200 }, //410
4705 { 0x2001, 0x40d, 1, 2 }, //411 1/2 width
4706 { 0x6000, 0x407, 0x411, 0 }, //412 top center glue xpos
4707 { 0x8000, 21600, 0, 0x412 }, //413 bottom center glue xpos
4708 { 0x2001, 0x405, 1, 2 }, //414 left glue x pos
4709 { 0x8000, 21600, 0, 0x414 }, //415 right glue x pos
4710 { 0x2001, 0x400, 2, 1 }, //416 y1 (textbox)
4711 { 0x8000, 21600, 0, 0x416 }, //417 y2 (textbox)
4712
4713 { 0x8000, 21600, 0, 0x407 }, //418 p2
4714
4715 { 0x8000, 21600, 0, 0x40f }, //419 c
4716 { 0x6000, 0x401, 0x408, 0 }, //41a
4717
4718 { 0x8000, 21600, 0, 0x410 }, //41b c
4719 { 0xa000, 0x401, 0, 0x408 }, //41c
4720
4721 { 0x8000, 21600, 0, 0x40c } //41d p3
4722 };
4723 static const SvxMSDffVertPair mso_sptWaveGluePoints[] =
4724 {
4725 { 0x12 MSO_I, 0 MSO_I }, { 0x14 MSO_I, 10800 }, { 0x13 MSO_I, 1 MSO_I }, { 0x15 MSO_I, 10800 }
4726 };
4727 static const sal_uInt16 mso_sptWaveSegm[] =
4728 {
4729 0x4000, 0x2001, 0x0001, 0x2001, 0x6000, 0x8000
4730 };
4731 static const sal_Int32 mso_sptWaveDefault[] =
4732 {
4733 2, 1400, 10800
4734 };
4735 static const SvxMSDffTextRectangles mso_sptWaveTextRect[] =
4736 {
4737 { { 5 MSO_I, 22 MSO_I }, { 11 MSO_I, 23 MSO_I } }
4738 };
4739 static const mso_CustomShape msoWave =
4740 {
4741 (SvxMSDffVertPair*)mso_sptWaveVert, sizeof( mso_sptWaveVert ) / sizeof( SvxMSDffVertPair ),
4742 (sal_uInt16*)mso_sptWaveSegm, sizeof( mso_sptWaveSegm ) >> 1,
4743 (SvxMSDffCalculationData*)mso_sptWaveCalc, sizeof( mso_sptWaveCalc ) / sizeof( SvxMSDffCalculationData ),
4744 (sal_Int32*)mso_sptWaveDefault,
4745 (SvxMSDffTextRectangles*)mso_sptWaveTextRect, sizeof( mso_sptWaveTextRect ) / sizeof( SvxMSDffTextRectangles ),
4746 21600, 21600,
4747 0x80000000, 0x80000000,
4748 (SvxMSDffVertPair*)mso_sptWaveGluePoints, sizeof( mso_sptWaveGluePoints ) / sizeof( SvxMSDffVertPair )
4749 };
4750 static const SvxMSDffVertPair mso_sptDoubleWaveVert[] = // adjustment1 : 0 - 2230
4751 { // adjustment2 : 8640 - 12960
4752 { 7 MSO_I, 0 MSO_I }, { 15 MSO_I, 9 MSO_I }, { 0x1e MSO_I, 10 MSO_I }, { 0x12 MSO_I, 0 MSO_I }, { 0x1f MSO_I, 9 MSO_I }, { 16 MSO_I, 10 MSO_I }, { 12 MSO_I, 0 MSO_I },
4753 { 24 MSO_I, 1 MSO_I }, { 25 MSO_I, 26 MSO_I }, { 0x21 MSO_I, 28 MSO_I }, { 0x13 MSO_I, 1 MSO_I }, { 0x20 MSO_I, 26 MSO_I }, { 27 MSO_I, 28 MSO_I }, { 29 MSO_I, 1 MSO_I }
4754 };
4755 static const SvxMSDffCalculationData mso_sptDoubleWaveCalc[] =
4756 {
4757 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, //400 (vert.adj)
4758 { 0x8000, 21600, 0, 0x400 }, //401
4759 { 0x2000, DFF_Prop_adjust2Value, 0, 0 },//402 (horz.adj)
4760 { 0x2000, 0x402, 0, 10800 }, //403 -2160 -> 2160 (horz.adj)
4761 { 0x2001, 0x403, 2, 1 }, //404 -4320 -> 4320 (horz.adj)
4762 { 0x2003, 0x404, 0, 0 }, //405 abs( 0x404 ) (horz.adj)
4763 { 0x8000, 4320, 0, 0x405 }, //406 -> not used
4764 { 0xa006, 0x403, 0, 0x405 }, //407
4765 { 0x4001, 7900, 0x400, 2230 }, //408 0 -> 7900 (vert.adj)
4766 { 0xa000, 0x400, 0, 0x408 }, //409
4767 { 0x6000, 0x400, 0x408, 0 }, //40a
4768 { 0x8000, 21600, 0, 0x404 }, //40b
4769 { 0x6006, 0x403, 0x40b, 21600 }, //40c
4770 { 0xa000, 0x40c, 0, 0x407 }, //40d width between p0 and p1
4771 { 0x2001, 0x405, 1, 2 }, //40e
4772 { 0xa000, 0x407, 3600, 0x40e }, //40f
4773 { 0x6000, 0x40c, 0x40e, 3600 }, //410
4774 { 0x2001, 0x40d, 1, 2 }, //411 1/2 width
4775 { 0x6000, 0x407, 0x411, 0 }, //412 top center glue xpos
4776 { 0x8000, 21600, 0, 0x412 }, //413 bottom center glue xpos
4777 { 0x2001, 0x405, 1, 2 }, //414 left glue x pos
4778 { 0x8000, 21600, 0, 0x414 }, //415 right glue x pos
4779 { 0x2001, 0x400, 2, 1 }, //416 y1 (textbox)
4780 { 0x8000, 21600, 0, 0x416 }, //417 y2 (textbox)
4781
4782 { 0x8000, 21600, 0, 0x407 }, //418 p2
4783
4784 { 0x8000, 21600, 0, 0x40f }, //419 c
4785 { 0x6000, 0x401, 0x408, 0 }, //41a
4786
4787 { 0x8000, 21600, 0, 0x410 }, //41b c
4788 { 0xa000, 0x401, 0, 0x408 }, //41c
4789
4790 { 0x8000, 21600, 0, 0x40c }, //41d p3
4791 { 0xa000, 0x412, 0, 0x40e }, //41e
4792 { 0x6000, 0x412, 0x40e, 0 }, //41f
4793 { 0xa000, 0x413, 0, 0x40e }, //420
4794 { 0x6000, 0x413, 0x40e, 0 } //421
4795 };
4796 static const SvxMSDffVertPair mso_sptDoubleWaveGluePoints[] =
4797 {
4798 { 0x12 MSO_I, 0 MSO_I }, { 0x14 MSO_I, 10800 }, { 0x13 MSO_I, 1 MSO_I }, { 0x15 MSO_I, 10800 }
4799 };
4800 static const sal_uInt16 mso_sptDoubleWaveSegm[] =
4801 {
4802 0x4000, 0x2002, 0x0001, 0x2002, 0x6000, 0x8000
4803 };
4804 static const sal_Int32 mso_sptDoubleWaveDefault[] =
4805 {
4806 2, 1400, 10800
4807 };
4808 static const SvxMSDffTextRectangles mso_sptDoubleWaveTextRect[] =
4809 {
4810 { { 5 MSO_I, 22 MSO_I }, { 11 MSO_I, 23 MSO_I } }
4811 };
4812 static const mso_CustomShape msoDoubleWave =
4813 {
4814 (SvxMSDffVertPair*)mso_sptDoubleWaveVert, sizeof( mso_sptDoubleWaveVert ) / sizeof( SvxMSDffVertPair ),
4815 (sal_uInt16*)mso_sptDoubleWaveSegm, sizeof( mso_sptDoubleWaveSegm ) >> 1,
4816 (SvxMSDffCalculationData*)mso_sptDoubleWaveCalc, sizeof( mso_sptDoubleWaveCalc ) / sizeof( SvxMSDffCalculationData ),
4817 (sal_Int32*)mso_sptDoubleWaveDefault,
4818 (SvxMSDffTextRectangles*)mso_sptDoubleWaveTextRect, sizeof( mso_sptDoubleWaveTextRect ) / sizeof( SvxMSDffTextRectangles ),
4819 21600, 21600,
4820 0x80000000, 0x80000000,
4821 (SvxMSDffVertPair*)mso_sptDoubleWaveGluePoints, sizeof( mso_sptDoubleWaveGluePoints ) / sizeof( SvxMSDffVertPair )
4822 };
4823 static const SvxMSDffVertPair mso_sptWedgeRRectCalloutVert[] =
4824 {
4825 { 3590, 0 },
4826 { 0, 3590 },
4827 { 2 MSO_I, 3 MSO_I }, { 0, 8970 },
4828 { 0, 12630 },{ 4 MSO_I, 5 MSO_I }, { 0, 18010 },
4829 { 3590, 21600 },
4830 { 6 MSO_I, 7 MSO_I }, { 8970, 21600 },
4831 { 12630, 21600 }, { 8 MSO_I, 9 MSO_I }, { 18010, 21600 },
4832 { 21600, 18010 },
4833 { 10 MSO_I, 11 MSO_I }, { 21600, 12630 },
4834 { 21600, 8970 }, { 12 MSO_I, 13 MSO_I }, { 21600, 3590 },
4835 { 18010, 0 },
4836 { 14 MSO_I, 15 MSO_I }, { 12630, 0 },
4837 { 8970, 0 }, { 16 MSO_I, 17 MSO_I }
4838 };
4839 static const sal_uInt16 mso_sptWedgeRRectCalloutSegm[] =
4840 {
4841 0x4000, 0xa701, 0x0005, 0xa801, 0x0005, 0xa701, 0x0005, 0xa801, 0x0004, 0x6001, 0x8000
4842 };
4843 static const SvxMSDffTextRectangles mso_sptWedgeRRectCalloutTextRect[] =
4844 {
4845 { { 800, 800 }, { 20800, 20800 } }
4846 };
4847 static const mso_CustomShape msoWedgeRRectCallout =
4848 {
4849 (SvxMSDffVertPair*)mso_sptWedgeRRectCalloutVert, sizeof( mso_sptWedgeRRectCalloutVert ) / sizeof( SvxMSDffVertPair ),
4850 (sal_uInt16*)mso_sptWedgeRRectCalloutSegm, sizeof( mso_sptWedgeRRectCalloutSegm ) >> 1,
4851 (SvxMSDffCalculationData*)mso_sptWedgeRectCalloutCalc, sizeof( mso_sptWedgeRectCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
4852 (sal_Int32*)mso_sptWedgeRectCalloutDefault,
4853 (SvxMSDffTextRectangles*)mso_sptWedgeRRectCalloutTextRect, sizeof( mso_sptWedgeRRectCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
4854 21600, 21600,
4855 0x80000000, 0x80000000,
4856 NULL, 0
4857 };
4858
4859 static const SvxMSDffVertPair mso_sptWedgeEllipseCalloutVert[] =
4860 {
4861 { 0, 0 }, { 21600, 21600 }, { 0x16 MSO_I, 0x17 MSO_I }, { 0x12 MSO_I, 0x13 MSO_I }, { 0xe MSO_I, 0xf MSO_I }
4862 };
4863 static const sal_uInt16 mso_sptWedgeEllipseCalloutSegm[] =
4864 {
4865 0xa504, 0x0001, 0x6001, 0x8000
4866 };
4867 static const SvxMSDffCalculationData mso_sptWedgeEllipseCalloutCalc[] =
4868 {
4869 { 0x2000, DFF_Prop_adjustValue, 0, 10800 }, // 00 rad x
4870 { 0x2000, DFF_Prop_adjust2Value, 0, 10800 }, // 01 rad y
4871 { 0x6001, 0x400, 0x400, 1 }, // 02 rad x^2
4872 { 0x6001, 0x401, 0x401, 1 }, // 03 rad y^2
4873 { 0x6000, 0x402, 0x403, 0 }, // 04
4874 { 0x200d, 0x404, 0, 0 }, // 05
4875 { 0x2000, 0x405, 0, 10800 }, // 06 > 0 ? spur needs to be drawn : 10800
4876 { 0x6008, 0x400, 0x401, 0 }, // 07 atan2 -> angle
4877 { 0x2000, 0x407, 0, 10 }, // 08
4878 { 0x2000, 0x407, 10, 0 }, // 09
4879 { 0x400a, 10800, 0x407, 0 }, // 0a
4880 { 0x4009, 10800, 0x407, 0 }, // 0b
4881 { 0x2000, 0x40a, 10800, 0 }, // 0c
4882 { 0x2000, 0x40b, 10800, 0 }, // 0d
4883 { 0xe006, 0x406, DFF_Prop_adjustValue, 0x40c }, // 0e
4884 { 0xe006, 0x406, DFF_Prop_adjust2Value, 0x40d },// 0f
4885 { 0x400a, 10800, 0x408, 0 }, // 10
4886 { 0x4009, 10800, 0x408, 0 }, // 11
4887 { 0x2000, 0x410, 10800, 0 }, // 12
4888 { 0x2000, 0x411, 10800, 0 }, // 13
4889 { 0x400a, 10800, 0x409, 0 }, // 14
4890 { 0x4009, 10800, 0x409, 0 }, // 15
4891 { 0x2000, 0x414, 10800, 0 }, // 16
4892 { 0x2000, 0x415, 10800, 0 }, // 17
4893 };
4894 static const sal_Int32 mso_sptWedgeEllipseCalloutDefault[] =
4895 {
4896 2, 1350, 25920
4897 };
4898 static const SvxMSDffVertPair mso_sptWedgeEllipseCalloutGluePoints[] =
4899 {
4900 { 10800, 0 }, { 3160, 3160 }, { 0, 10800 }, { 3160, 18440 }, { 10800, 21600 }, { 18440, 18440 }, { 21600, 10800 }, { 18440, 3160 }, { 0xe MSO_I, 0xf MSO_I }
4901 };
4902 static const SvxMSDffTextRectangles mso_sptWedgeEllipseCalloutTextRect[] =
4903 {
4904 { { 3200, 3200 }, { 18400, 18400 } }
4905 };
4906 static const mso_CustomShape msoWedgeEllipseCallout =
4907 {
4908 (SvxMSDffVertPair*)mso_sptWedgeEllipseCalloutVert, sizeof( mso_sptWedgeEllipseCalloutVert ) / sizeof( SvxMSDffVertPair ),
4909 (sal_uInt16*)mso_sptWedgeEllipseCalloutSegm, sizeof( mso_sptWedgeEllipseCalloutSegm ) >> 1,
4910 (SvxMSDffCalculationData*)mso_sptWedgeEllipseCalloutCalc, sizeof( mso_sptWedgeEllipseCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
4911 (sal_Int32*)mso_sptWedgeEllipseCalloutDefault,
4912 (SvxMSDffTextRectangles*)mso_sptWedgeEllipseCalloutTextRect, sizeof( mso_sptWedgeEllipseCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
4913 21600, 21600,
4914 0x80000000, 0x80000000,
4915 (SvxMSDffVertPair*)mso_sptWedgeEllipseCalloutGluePoints, sizeof( mso_sptWedgeEllipseCalloutGluePoints ) / sizeof( SvxMSDffVertPair )
4916 };
4917
4918 static const SvxMSDffVertPair mso_sptCloudCalloutVert[] =
4919 {
4920 { 1930,7160 }, // p
4921 { 1530,4490 }, { 3400,1970 }, { 5270,1970 }, // ccp
4922 { 5860,1950 }, { 6470,2210 }, { 6970,2600 }, // ccp
4923 { 7450,1390 }, { 8340,650 }, { 9340,650 }, // ccp
4924 { 10004,690 }, { 10710,1050 }, { 11210,1700 }, // ccp
4925 { 11570,630 }, { 12330,0 }, { 13150,0 }, // ccp
4926 { 13840,0 }, { 14470,460 }, { 14870,1160 }, // ccp
4927 { 15330,440 }, { 16020,0 }, { 16740,0 }, // ccp
4928 { 17910,0 }, { 18900,1130 }, { 19110,2710 }, // ccp
4929 { 20240,3150 }, { 21060,4580 }, { 21060,6220 }, // ccp
4930 { 21060,6720 }, { 21000,7200 }, { 20830,7660 }, // ccp
4931 { 21310,8460 }, { 21600,9450 }, { 21600,10460 }, // ccp
4932 { 21600,12750 }, { 20310,14680 }, { 18650,15010 }, // ccp
4933 { 18650,17200 }, { 17370,18920 }, { 15770,18920 }, // ccp
4934 { 15220,18920 }, { 14700,18710 }, { 14240,18310 }, // ccp
4935 { 13820,20240 }, { 12490,21600 }, { 11000,21600 }, // ccp
4936 { 9890,21600 }, { 8840,20790 }, { 8210,19510 }, // ccp
4937 { 7620,20000 }, { 7930,20290 }, { 6240,20290 }, // ccp
4938 { 4850,20290 }, { 3570,19280 }, { 2900,17640 }, // ccp
4939 { 1300,17600 }, { 480,16300 }, { 480,14660 }, // ccp
4940 { 480,13900 }, { 690,13210 }, { 1070,12640 }, // ccp
4941 { 380,12160 }, { 0,11210 }, { 0,10120 }, // ccp
4942 { 0,8590 }, { 840,7330 }, { 1930,7160 }, // ccp
4943
4944 { 1930, 7160 }, { 1950, 7410 }, { 2040, 7690 }, { 2090, 7920 }, // pccp
4945 { 6970, 2600 }, { 7200, 2790 }, { 7480, 3050 }, { 7670, 3310 }, // pccp
4946 { 11210, 1700 }, { 11130, 1910 }, { 11080, 2160 }, { 11030, 2400 }, // pccp
4947 { 14870, 1160 }, { 14720, 1400 }, { 14640, 1720 }, { 14540, 2010 }, // pccp
4948 { 19110, 2710 }, { 19130, 2890 }, { 19230, 3290 }, { 19190, 3380 }, // pccp
4949 { 20830, 7660 }, { 20660, 8170 }, { 20430, 8620 }, { 20110, 8990 }, // pccp
4950 { 18660, 15010 }, { 18740, 14200 }, { 18280, 12200 }, { 17000, 11450 }, // pccp
4951 { 14240, 18310 }, { 14320, 17980 }, { 14350, 17680 }, { 14370, 17360 }, // pccp
4952 { 8220, 19510 }, { 8060, 19250 }, { 7960, 18950 }, { 7860, 18640 }, // pccp
4953 { 2900, 17640 }, { 3090, 17600 }, { 3280, 17540 }, { 3460, 17450 }, // pccp
4954 { 1070, 12640 }, { 1400, 12900 }, { 1780, 13130 }, { 2330, 13040 } // pccp
4955 };
4956 static const sal_uInt16 mso_sptCloudCalloutSegm[] =
4957 {
4958 0x4000, 0x2016, 0x6001, 0x8000,
4959 0x4000, 0x2001, 0xaa00, 0x8000,
4960 0x4000, 0x2001, 0xaa00, 0x8000,
4961 0x4000, 0x2001, 0xaa00, 0x8000,
4962 0x4000, 0x2001, 0xaa00, 0x8000,
4963 0x4000, 0x2001, 0xaa00, 0x8000,
4964 0x4000, 0x2001, 0xaa00, 0x8000,
4965 0x4000, 0x2001, 0xaa00, 0x8000,
4966 0x4000, 0x2001, 0xaa00, 0x8000,
4967 0x4000, 0x2001, 0xaa00, 0x8000,
4968 0x4000, 0x2001, 0xaa00, 0x8000,
4969 0x4000, 0x2001, 0xaa00, 0x8000
4970 };
4971 static const SvxMSDffCalculationData mso_sptCloudCalloutCalc[] =
4972 {
4973 { 0x2000, DFF_Prop_adjustValue, 0, 10800 },
4974 { 0x2000, DFF_Prop_adjust2Value, 0, 10800 },
4975 { 0x6008, 0x400, 0x401, 0 },
4976 { 0x400a, 10800, 0x402, 0 }, // 3
4977 { 0x4009, 10800, 0x402, 0 }, // 4
4978 { 0x2000, 0x403, 10800, 0 }, // 5
4979 { 0x2000, 0x404, 10800, 0 }, // 6
4980 { 0xa000, DFF_Prop_adjustValue, 0, 0x405 }, // 7
4981 { 0xa000, DFF_Prop_adjust2Value,0, 0x406 }, // 8
4982 { 0x2001, 0x407, 1, 3 }, // 9
4983 { 0x2001, 0x408, 1, 3 }, // 0xa
4984 { 0x2001, 0x407, 2, 3 }, // 0xb
4985 { 0x2001, 0x408, 2, 3 }, // 0xc
4986 { 0x2000, DFF_Prop_adjustValue, 0, 0 }, // 0xd
4987 { 0x2000, DFF_Prop_adjust2Value, 0, 0 }, // 0xe
4988 { 0x2001, 0x403, 1, 10800 / 900 }, // 0xf taking half x distance of the radius from the first bobble
4989 { 0x2001, 0x404, 1, 10800 / 900 }, // 0x10
4990 { 0xe000, 0x409, 0x405, 0x40f }, // 0x11
4991 { 0xe000, 0x40a, 0x406, 0x410 }, // 0x12
4992 { 0x6000, 0x40b, 0x405, 0 }, // 0x13
4993 { 0x6000, 0x40c, 0x406, 0 } // 0x14
4994 };
4995 static const sal_Int32 mso_sptCloudCalloutDefault[] =
4996 {
4997 2, 1350, 25920
4998 };
4999 static const SvxMSDffTextRectangles mso_sptCloudCalloutTextRect[] =
5000 {
5001 { { 3000, 3320 }, { 17110, 17330 } }
5002 };
5003 static const mso_CustomShape msoCloudCallout =
5004 {
5005 (SvxMSDffVertPair*)mso_sptCloudCalloutVert, sizeof( mso_sptCloudCalloutVert ) / sizeof( SvxMSDffVertPair ),
5006 (sal_uInt16*)mso_sptCloudCalloutSegm, sizeof( mso_sptCloudCalloutSegm ) >> 1,
5007 (SvxMSDffCalculationData*)mso_sptCloudCalloutCalc, sizeof( mso_sptCloudCalloutCalc ) / sizeof( SvxMSDffCalculationData ),
5008 (sal_Int32*)mso_sptCloudCalloutDefault,
5009 (SvxMSDffTextRectangles*)mso_sptCloudCalloutTextRect, sizeof( mso_sptCloudCalloutTextRect ) / sizeof( SvxMSDffTextRectangles ),
5010 21600, 21600,
5011 0x80000000, 0x80000000,
5012 NULL, 0
5013 };
5014
5015
5016 class SvxMSDffAdjustmentHandle
5017 {
5018 sal_Int32 nAdjustValue;
5019 sal_Int32 nDefaultValue;
5020 sal_Bool bIsDefault;
5021
5022 public :
5023 SvxMSDffAdjustmentHandle() : nAdjustValue( 0 ), nDefaultValue( 0 ), bIsDefault( TRUE ) {};
5024
5025 void SetAdjustValue( sal_Int32 nVal ) { nAdjustValue = nVal; bIsDefault = FALSE; };
5026 sal_Int32 GetAdjustValue() const { return bIsDefault ? nDefaultValue : nAdjustValue; };
5027 void SetDefaultValue( sal_Int32 nVal ) { nDefaultValue = nVal; };
5028 sal_Bool IsDefault() const { return bIsDefault; };
5029 };
5030
5031 const mso_CustomShape* GetCustomShapeContent2( MSO_SPT eSpType )
5032 {
5033 const mso_CustomShape* pCustomShape = NULL;
5034 switch( eSpType )
5035 {
5036 case mso_sptArc : pCustomShape = &msoArc; break;
5037 case mso_sptRectangle : pCustomShape = &msoRectangle; break;
5038 case mso_sptParallelogram : pCustomShape = &msoParallelogram; break;
5039 case mso_sptTrapezoid : pCustomShape = &msoTrapezoid; break;
5040 case mso_sptDiamond : pCustomShape = &msoDiamond; break;
5041 case mso_sptRoundRectangle : pCustomShape = &msoRoundRectangle; break;
5042 case mso_sptOctagon : pCustomShape = &msoOctagon; break;
5043 case mso_sptIsocelesTriangle : pCustomShape = &msoIsocelesTriangle; break;
5044 case mso_sptRightTriangle : pCustomShape = &msoRightTriangle; break;
5045 case mso_sptEllipse : pCustomShape = &msoEllipse; break;
5046 case mso_sptHexagon : pCustomShape = &msoHexagon; break;
5047 case mso_sptPlus : pCustomShape = &msoPlus; break;
5048 case mso_sptPentagon : pCustomShape = &msoPentagon; break;
5049 case mso_sptCan : pCustomShape = &msoCan; break;
5050 case mso_sptCube : pCustomShape = &msoCube; break;
5051 case mso_sptActionButtonBlank : pCustomShape = &msoActionButtonBlank; break;
5052 case mso_sptActionButtonHome : pCustomShape = &msoActionButtonHome; break;
5053 case mso_sptActionButtonHelp : pCustomShape = &msoActionButtonHelp; break;
5054 case mso_sptActionButtonInformation : pCustomShape = &msoActionButtonInformation; break;
5055 case mso_sptActionButtonBackPrevious : pCustomShape = &msoActionButtonBackPrevious; break;
5056 case mso_sptActionButtonForwardNext : pCustomShape = &msoActionButtonForwardNext; break;
5057 case mso_sptActionButtonBeginning : pCustomShape = &msoActionButtonBeginning; break;
5058 case mso_sptActionButtonEnd : pCustomShape = &msoActionButtonEnd; break;
5059 case mso_sptActionButtonReturn : pCustomShape = &msoActionButtonReturn; break;
5060 case mso_sptActionButtonDocument : pCustomShape = &msoActionButtonDocument; break;
5061 case mso_sptActionButtonSound : pCustomShape = &msoActionButtonSound; break;
5062 case mso_sptActionButtonMovie : pCustomShape = &msoActionButtonMovie; break;
5063 case mso_sptBevel : pCustomShape = &msoBevel; break;
5064 case mso_sptFoldedCorner : pCustomShape = &msoFoldedCorner; break;
5065 case mso_sptSmileyFace : pCustomShape = &msoSmileyFace; break;
5066 case mso_sptDonut : pCustomShape = &msoDonut; break;
5067 case mso_sptNoSmoking : pCustomShape = &msoNoSmoking; break;
5068 case mso_sptBlockArc : pCustomShape = &msoBlockArc; break;
5069 case mso_sptHeart : pCustomShape = &msoHeart; break;
5070 case mso_sptLightningBolt : pCustomShape = &msoLightningBold; break;
5071 case mso_sptSun : pCustomShape = &msoSun; break;
5072 case mso_sptMoon : pCustomShape = &msoMoon; break;
5073 case mso_sptBracketPair : pCustomShape = &msoBracketPair; break;
5074 case mso_sptBracePair : pCustomShape = &msoBracePair; break;
5075 case mso_sptPlaque : pCustomShape = &msoPlaque; break;
5076 case mso_sptLeftBracket : pCustomShape = &msoLeftBracket; break;
5077 case mso_sptRightBracket : pCustomShape = &msoRightBracket; break;
5078 case mso_sptLeftBrace : pCustomShape = &msoLeftBrace; break;
5079 case mso_sptRightBrace : pCustomShape = &msoRightBrace; break;
5080 case mso_sptArrow : pCustomShape = &msoArrow; break;
5081 case mso_sptUpArrow : pCustomShape = &msoUpArrow; break;
5082 case mso_sptDownArrow : pCustomShape = &msoDownArrow; break;
5083 case mso_sptLeftArrow : pCustomShape = &msoLeftArrow; break;
5084 case mso_sptLeftRightArrow : pCustomShape = &msoLeftRightArrow; break;
5085 case mso_sptUpDownArrow : pCustomShape = &msoUpDownArrow; break;
5086 case mso_sptQuadArrow : pCustomShape = &msoQuadArrow; break;
5087 case mso_sptLeftRightUpArrow : pCustomShape = &msoLeftRightUpArrow; break;
5088 case mso_sptBentArrow : pCustomShape = &msoBentArrow; break;
5089 case mso_sptUturnArrow : pCustomShape = &msoUturnArrow; break;
5090 case mso_sptLeftUpArrow : pCustomShape = &msoLeftUpArrow; break;
5091 case mso_sptBentUpArrow : pCustomShape = &msoBentUpArrow; break;
5092 case mso_sptCurvedRightArrow : pCustomShape = &msoCurvedArrow; break;
5093 case mso_sptCurvedLeftArrow : pCustomShape = &msoCurvedArrow; break;
5094 case mso_sptCurvedUpArrow : pCustomShape = &msoCurvedArrow; break;
5095 case mso_sptCurvedDownArrow : pCustomShape = &msoCurvedArrow; break;
5096 case mso_sptStripedRightArrow : pCustomShape = &msoStripedRightArrow; break;
5097 case mso_sptNotchedRightArrow : pCustomShape = &msoNotchedRightArrow; break;
5098 case mso_sptHomePlate : pCustomShape = &msoHomePlate; break;
5099 case mso_sptChevron : pCustomShape = &msoChevron; break;
5100 case mso_sptRightArrowCallout : pCustomShape = &msoRightArrowCallout; break;
5101 case mso_sptLeftArrowCallout : pCustomShape = &msoLeftArrowCallout; break;
5102 case mso_sptUpArrowCallout : pCustomShape = &msoUpArrowCallout; break;
5103 case mso_sptDownArrowCallout : pCustomShape = &msoDownArrowCallout; break;
5104 case mso_sptLeftRightArrowCallout : pCustomShape = &msoLeftRightArrowCallout; break;
5105 case mso_sptUpDownArrowCallout : pCustomShape = &msoUpDownArrowCallout; break;
5106 case mso_sptQuadArrowCallout : pCustomShape = &msoQuadArrowCallout; break;
5107 case mso_sptCircularArrow : pCustomShape = &msoCircularArrow; break;
5108 case mso_sptIrregularSeal1 : pCustomShape = &msoIrregularSeal1; break;
5109 case mso_sptIrregularSeal2 : pCustomShape = &msoIrregularSeal2; break;
5110 case mso_sptSeal4 : pCustomShape = &msoSeal4; break;
5111 case mso_sptStar : pCustomShape = &msoStar; break;
5112 case mso_sptSeal8 : pCustomShape = &msoSeal8; break;
5113 case mso_sptSeal16 : pCustomShape = &msoSeal16; break;
5114 case mso_sptSeal24 : pCustomShape = &msoSeal24; break;
5115 case mso_sptSeal32 : pCustomShape = &msoSeal32; break;
5116 case mso_sptRibbon2 : pCustomShape = &msoRibbon2; break;
5117 case mso_sptRibbon : pCustomShape = &msoRibbon2; break;
5118 case mso_sptEllipseRibbon2 : pCustomShape = &msoRibbon2; break; //!!!!!
5119 case mso_sptEllipseRibbon : pCustomShape = &msoRibbon2; break; //!!!!!
5120 case mso_sptVerticalScroll : pCustomShape = &msoVerticalScroll; break;
5121 case mso_sptHorizontalScroll : pCustomShape = &msoHorizontalScroll; break;
5122 case mso_sptFlowChartProcess : pCustomShape = &msoFlowChartProcess; break;
5123 case mso_sptFlowChartAlternateProcess : pCustomShape = &msoFlowChartAlternateProcess; break;
5124 case mso_sptFlowChartDecision : pCustomShape = &msoFlowChartDecision; break;
5125 case mso_sptFlowChartInputOutput : pCustomShape = &msoFlowChartInputOutput; break;
5126 case mso_sptFlowChartPredefinedProcess :pCustomShape = &msoFlowChartPredefinedProcess; break;
5127 case mso_sptFlowChartInternalStorage : pCustomShape = &msoFlowChartInternalStorage; break;
5128 case mso_sptFlowChartDocument : pCustomShape = &msoFlowChartDocument; break;
5129 case mso_sptFlowChartMultidocument : pCustomShape = &msoFlowChartMultidocument; break;
5130 case mso_sptFlowChartTerminator : pCustomShape = &msoFlowChartTerminator; break;
5131 case mso_sptFlowChartPreparation : pCustomShape = &msoFlowChartPreparation; break;
5132 case mso_sptFlowChartManualInput : pCustomShape = &msoFlowChartManualInput; break;
5133 case mso_sptFlowChartManualOperation : pCustomShape = &msoFlowChartManualOperation; break;
5134 case mso_sptFlowChartConnector : pCustomShape = &msoFlowChartConnector; break;
5135 case mso_sptFlowChartOffpageConnector : pCustomShape = &msoFlowChartOffpageConnector; break;
5136 case mso_sptFlowChartPunchedCard : pCustomShape = &msoFlowChartPunchedCard; break;
5137 case mso_sptFlowChartPunchedTape : pCustomShape = &msoFlowChartPunchedTape; break;
5138 case mso_sptFlowChartSummingJunction : pCustomShape = &msoFlowChartSummingJunction; break;
5139 case mso_sptFlowChartOr : pCustomShape = &msoFlowChartOr; break;
5140 case mso_sptFlowChartCollate : pCustomShape = &msoFlowChartCollate; break;
5141 case mso_sptFlowChartSort : pCustomShape = &msoFlowChartSort; break;
5142 case mso_sptFlowChartExtract : pCustomShape = &msoFlowChartExtract; break;
5143 case mso_sptFlowChartMerge : pCustomShape = &msoFlowChartMerge; break;
5144 case mso_sptFlowChartOnlineStorage : pCustomShape = &msoFlowChartOnlineStorage; break;
5145 case mso_sptFlowChartDelay : pCustomShape = &msoFlowChartDelay; break;
5146 case mso_sptFlowChartMagneticTape : pCustomShape = &msoFlowChartMagneticTape; break;
5147 case mso_sptFlowChartMagneticDisk : pCustomShape = &msoFlowChartMagneticDisk; break;
5148 case mso_sptFlowChartMagneticDrum : pCustomShape = &msoFlowChartMagneticDrum; break;
5149 case mso_sptFlowChartDisplay : pCustomShape = &msoFlowChartDisplay; break;
5150 case mso_sptWave : pCustomShape = &msoWave; break;
5151 case mso_sptDoubleWave : pCustomShape = &msoDoubleWave; break;
5152 case mso_sptWedgeRectCallout : pCustomShape = &msoWedgeRectCallout; break;
5153 case mso_sptBalloon :
5154 case mso_sptWedgeRRectCallout : pCustomShape = &msoWedgeRRectCallout; break;
5155 case mso_sptWedgeEllipseCallout : pCustomShape = &msoWedgeEllipseCallout; break;
5156 case mso_sptCloudCallout : pCustomShape = &msoCloudCallout; break;
5157
5158 default :
5159 break;
5160 }
5161 return pCustomShape;
5162 }
5163
5164 SvxMSDffCustomShape::~SvxMSDffCustomShape()
5165 {
5166 if ( bVertAlloc )
5167 delete[] pVertData;
5168 if ( bSegAlloc )
5169 delete[] pSegData;
5170 if ( bTextRectAlloc )
5171 delete[] pTextRectData;
5172 if ( bCalcAlloc )
5173 delete[] pCalculationData;
5174 delete[] pAdjustmentHandles;
5175 }
5176
5177 SvxMSDffCustomShape::SvxMSDffCustomShape( const DffPropertyReader& rPropReader, SvStream& rSt,
5178 DffObjData& rData, Rectangle& rSnapRect, sal_Int32 nAngle, MSFilterTracer* pT ) :
5179 pTracer ( pT ),
5180 eSpType ( rData.eShapeType ),
5181 aSnapRect ( rSnapRect ),
5182 nFix16Angle ( nAngle ),
5183 nXRef ( 0x80000000 ),
5184 nYRef ( 0x80000000 ),
5185 nFlags ( 0 ),
5186 nColorData ( 0 ),
5187 pVertData ( NULL ),
5188 pSegData ( NULL ),
5189 nTextRectData ( 0 ),
5190 pTextRectData ( NULL ),
5191 nCalculationData ( 0 ),
5192 pCalculationData ( NULL ),
5193 nAdjustmentHandles ( 0 ),
5194 pAdjustmentHandles ( NULL ),
5195 nGluePoints ( 0 ),
5196 pGluePoints ( NULL ),
5197 bIsEmpty ( TRUE ),
5198 bVertAlloc ( FALSE ),
5199 bSegAlloc ( FALSE ),
5200 bCalcAlloc ( FALSE ),
5201 bTextRectAlloc ( FALSE ),
5202 bTextFlow ( ( (MSO_TextFlow)rPropReader.GetPropertyValue( DFF_Prop_txflTextFlow ) ) == mso_txflTtoBA ),
5203 bFilled ( ( rPropReader.GetPropertyValue( DFF_Prop_fNoFillHitTest ) & 0x10 ) != 0 ), // pie <-> arc
5204 bFlipH ( ( rData.nSpFlags & SP_FFLIPH ) != 0 ),
5205 bFlipV ( ( rData.nSpFlags & SP_FFLIPV ) != 0 )
5206 {
5207 const sal_Int32* pDefData = NULL;
5208 const mso_CustomShape* pDefCustomShape = NULL;
5209
5210
5211 // cloning DFF_Prop_adjustValues from DffPropertyReader to be able
5212 // to manipulate them and not destroying the original properties
5213
5214 sal_uInt32 nHandles[ 10 ];
5215 sal_uInt32 nHandlesSet = 0;
5216 sal_uInt32 i, nHandlesUsed = 0;
5217
5218 for ( i = DFF_Prop_adjustValue; i < DFF_Prop_adjust10Value; i++ )
5219 {
5220 if ( rPropReader.IsProperty( i ) )
5221 {
5222 sal_Int32 nIndex = i - DFF_Prop_adjustValue;
5223 nHandles[ nIndex ] = rPropReader.GetPropertyValue( i );
5224 nHandlesSet |= 1 << nIndex;
5225 nHandlesUsed = nIndex + 1;
5226 }
5227 }
5228 pDefCustomShape = GetCustomShapeContent2( eSpType );
5229 if ( pDefCustomShape )
5230 {
5231 switch( eSpType )
5232 {
5233 case mso_sptCan : nColorData = 0x20200000; break;
5234 case mso_sptCube : nColorData = 0x302d0000; break;
5235 case mso_sptActionButtonBlank : nColorData = 0x502ad400; break;
5236 case mso_sptActionButtonHome : nColorData = 0x702ad4ad; break;
5237 case mso_sptActionButtonHelp : nColorData = 0x602ad4a0; break;
5238 case mso_sptActionButtonInformation : nColorData = 0x702ad4a5; break;
5239 case mso_sptActionButtonBackPrevious : nColorData = 0x602ad4a0; break;
5240 case mso_sptActionButtonForwardNext : nColorData = 0x602ad4a0; break;
5241 case mso_sptActionButtonBeginning : nColorData = 0x602ad4a0; break;
5242 case mso_sptActionButtonEnd : nColorData = 0x602ad4a0; break;
5243 case mso_sptActionButtonReturn : nColorData = 0x602ad4a0; break;
5244 case mso_sptActionButtonDocument : nColorData = 0x702ad4da; break;
5245 case mso_sptActionButtonSound : nColorData = 0x602ad4a0; break;
5246 case mso_sptActionButtonMovie : nColorData = 0x602ad4a0; break;
5247 case mso_sptBevel : nColorData = 0x502ad400; break;
5248 case mso_sptFoldedCorner : nColorData = 0x20d00000; break;
5249 case mso_sptSmileyFace : nColorData = 0x20d00000; break;
5250 case mso_sptCurvedLeftArrow :
5251 {
5252 if ( nHandlesSet & 4 )
5253 nHandles[ 2 ] = 21600 - nHandles[ 2 ];
5254 nFlags |= DFF_CUSTOMSHAPE_FLIP_H;
5255 }
5256 break;
5257 case mso_sptCurvedUpArrow :
5258 {
5259 if ( nHandlesSet & 4 )
5260 nHandles[ 2 ] = 21600 - nHandles[ 2 ];
5261 nFlags |= DFF_CUSTOMSHAPE_FLIP_V | DFF_CUSTOMSHAPE_EXCH;
5262 }
5263 break;
5264 case mso_sptCurvedDownArrow : nFlags |= DFF_CUSTOMSHAPE_EXCH; break;
5265 case mso_sptRibbon2 : nColorData = 0x30dd0000; break;
5266 case mso_sptRibbon :
5267 {
5268 if ( nHandlesSet & 2 )
5269 nHandles[ 1 ] = 21600 - nHandles[ 1 ];
5270 nFlags |= DFF_CUSTOMSHAPE_FLIP_V;
5271 nColorData = 0x30dd0000;
5272 }
5273 break;
5274 case mso_sptEllipseRibbon2 : nColorData = 0x30dd0000; break;
5275 case mso_sptEllipseRibbon : // !!!!!!!!!!
5276 {
5277 if ( nHandlesSet & 2 )
5278 nHandles[ 1 ] = 21600 - nHandles[ 1 ];
5279 nFlags |= DFF_CUSTOMSHAPE_FLIP_V;
5280 nColorData = 0x30dd0000;
5281 }
5282 break;
5283 case mso_sptVerticalScroll : nColorData = 0x30dd0000; break;
5284 case mso_sptHorizontalScroll : nColorData = 0x30dd0000; break;
5285 default: break;
5286 }
5287 }
5288 nCoordHeight = nCoordWidth = 21600;
5289 if ( pDefCustomShape )
5290 {
5291 bIsEmpty = FALSE;
5292 nNumElemVert = pDefCustomShape->nVertices;
5293 pVertData = pDefCustomShape->pVertices;
5294 nNumElemSeg = pDefCustomShape->nElements;
5295 pSegData = pDefCustomShape->pElements;
5296 nCalculationData = pDefCustomShape->nCalculation;
5297 pCalculationData = pDefCustomShape->pCalculation;
5298 pDefData = pDefCustomShape->pDefData;
5299 pTextRectData = pDefCustomShape->pTextRect;
5300 nTextRectData = pDefCustomShape->nTextRect;
5301 nCoordWidth = pDefCustomShape->nCoordWidth;
5302 nCoordHeight = pDefCustomShape->nCoordHeight;
5303 nXRef = pDefCustomShape->nXRef;
5304 nYRef = pDefCustomShape->nYRef;
5305 pGluePoints = pDefCustomShape->pGluePoints;
5306 nGluePoints = pDefCustomShape->nGluePoints;
5307 }
5308 sal_Int32 nGeoRight = rPropReader.GetPropertyValue( DFF_Prop_geoRight, 0 );
5309 if ( nGeoRight )
5310 {
5311 nGeoRight -= rPropReader.GetPropertyValue( DFF_Prop_geoLeft, 0 );
5312 nCoordWidth = labs( nGeoRight );
5313 }
5314 sal_Int32 nGeoBottom = rPropReader.GetPropertyValue( DFF_Prop_geoBottom, 0 );
5315 if ( nGeoBottom )
5316 {
5317 nGeoBottom -= rPropReader.GetPropertyValue( DFF_Prop_geoTop, 0 );
5318 nCoordHeight = labs( nGeoBottom );
5319 }
5320
5321 if ( rPropReader.SeekToContent( DFF_Prop_pVertices, rSt ) )
5322 {
5323 sal_uInt16 nTmp16, nNumElemMemVert, nElemSizeVert;
5324 rSt >> nTmp16 >> nNumElemMemVert >> nElemSizeVert;
5325 if ( nTmp16 )
5326 {
5327 bIsEmpty = FALSE;
5328 nNumElemVert = nTmp16;
5329 sal_uInt32 k = nNumElemVert;
5330 bVertAlloc = TRUE;
5331 pVertData = new SvxMSDffVertPair[ nNumElemVert ];
5332 SvxMSDffVertPair* pTmp = pVertData;
5333 if ( nElemSizeVert == 8 )
5334 {
5335 while( k-- )
5336 {
5337 rSt >> pTmp->nValA
5338 >> pTmp->nValB;
5339 pTmp++;
5340 }
5341 }
5342 else
5343 {
5344 sal_Int16 nTmpA, nTmpB;
5345 while ( k-- )
5346 {
5347 rSt >> nTmpA
5348 >> nTmpB;
5349
5350 pTmp->nValA = nTmpA;
5351 pTmp->nValB = nTmpB;
5352 pTmp++;
5353 }
5354 }
5355 }
5356 }
5357 if ( !bIsEmpty ) // we can import an customshape if either pVertData or pDefCustomShape is set
5358 {
5359 if ( rPropReader.SeekToContent( DFF_Prop_pSegmentInfo, rSt ) )
5360 {
5361 sal_uInt16 nTmp16, nNumElemMemSeg, nElemSizeSeg;
5362 rSt >> nTmp16 >> nNumElemMemSeg >> nElemSizeSeg;
5363 if ( nTmp16 )
5364 {
5365 nNumElemSeg = nTmp16;
5366 bSegAlloc = TRUE;
5367 pSegData = new sal_uInt16[ nNumElemSeg + 1 ]; // #97948# allocate one more element,
5368 #ifdef OSL_BIGENDIAN // so it won't be difficult to append
5369 sal_uInt32 k = nNumElemSeg; // a missing end segment action
5370 sal_uInt16* pTmp = pSegData;
5371 while( k-- )
5372 {
5373 rSt >> *pTmp++;
5374 }
5375 #else
5376 rSt.Read( pSegData, nNumElemSeg << 1 );
5377 #endif
5378 if ( pSegData[ nNumElemSeg - 1 ] != 0x8000 ) // #97948# append the missing segm action
5379 pSegData[ nNumElemSeg++ ] = 0x8000;
5380 }
5381 }
5382 if ( rPropReader.SeekToContent( 342, rSt ) )
5383 {
5384 sal_uInt16 nTmp16, nNumElemMem, nElemSize;
5385 rSt >> nTmp16 >> nNumElemMem >> nElemSize;
5386 if ( nTmp16 && ( nElemSize == 8 ) )
5387 {
5388 nCalculationData = nTmp16;
5389 pCalculationData = new SvxMSDffCalculationData[ nCalculationData ];
5390 bCalcAlloc = TRUE;
5391 sal_uInt32 k;
5392 sal_uInt16 nVal0, nVal1, nVal2;
5393 for ( k = 0; k < nCalculationData; k++ )
5394 {
5395 SvxMSDffCalculationData& rDat = pCalculationData[ k ];
5396 rSt >> rDat.nFlags
5397 >> nVal0 >> nVal1 >> nVal2;
5398 rDat.nVal1 = nVal0;
5399 rDat.nVal2 = nVal1;
5400 rDat.nVal3 = nVal2;
5401 }
5402 }
5403 }
5404
5405 if ( rPropReader.SeekToContent( 343, rSt ) )
5406 {
5407 sal_uInt16 nTmp16, nNumElemMem, nElemSize;
5408 rSt >> nTmp16 >> nNumElemMem >> nElemSize;
5409 if ( nTmp16 && ( nElemSize == 16 ) )
5410 {
5411 sal_uInt32 nNumElem = nTmp16;
5412 if ( nNumElem > 1 )
5413 nNumElem = 2;
5414 bTextRectAlloc = sal_True;
5415 nTextRectData = nNumElem;
5416 pTextRectData = new SvxMSDffTextRectangles[ nNumElem ];
5417 SvxMSDffTextRectangles* pTmp = pTextRectData;
5418 for ( i = 0; i < nNumElem; i++ )
5419 {
5420 rSt >> pTmp->nPairA.nValA
5421 >> pTmp->nPairA.nValB
5422 >> pTmp->nPairB.nValA
5423 >> pTmp->nPairB.nValB;
5424 pTmp++;
5425 }
5426 }
5427 }
5428
5429 const sal_Int32* pTmp = pDefData;
5430 sal_uInt32 nDefaults = 0;
5431 if ( pTmp )
5432 nDefaults = nAdjustmentHandles = *pTmp++;
5433
5434 if ( nHandlesUsed > nAdjustmentHandles )
5435 nAdjustmentHandles = nHandlesUsed;
5436
5437 if ( nAdjustmentHandles )
5438 {
5439 pAdjustmentHandles = new SvxMSDffAdjustmentHandle[ nAdjustmentHandles ];
5440 for ( i = 0; i < nAdjustmentHandles; i++ )
5441 {
5442 if ( i < nDefaults )
5443 pAdjustmentHandles[ i ].SetDefaultValue( *pTmp++ );
5444 if ( nHandlesSet & ( 1 << i ) )
5445 pAdjustmentHandles[ i ].SetAdjustValue( nHandles[ i ] );
5446 }
5447 }
5448
5449 fXScale = (double)aSnapRect.GetWidth() / (double)nCoordWidth;
5450 fYScale = (double)aSnapRect.GetHeight() / (double)nCoordHeight;
5451
5452 if ( rPropReader.IsProperty( 339 ) )
5453 nXRef = rPropReader.GetPropertyValue( 339 );
5454 if ( rPropReader.IsProperty( 340 ) )
5455 nYRef = rPropReader.GetPropertyValue( 340 );
5456 }
5457 }
5458
5459 sal_Int32 SvxMSDffCustomShape::Fix16ToAngle( sal_Int32 nAngle ) const
5460 {
5461 if ( nAngle )
5462 {
5463 nAngle = ( (sal_Int16)( nAngle >> 16) * 100L ) + ( ( ( nAngle & 0x0000ffff) * 100L ) >> 16 );
5464 nAngle = NormAngle360( -nAngle );
5465 }
5466 return nAngle;
5467 }
5468
5469 sal_Int32 SvxMSDffCustomShape::GetAdjustValue( sal_uInt32 nIndex ) const
5470 {
5471 return ( nIndex < nAdjustmentHandles ) ? pAdjustmentHandles[ nIndex ].GetAdjustValue() : 0;
5472 }
5473
5474 sal_Int32 SvxMSDffCustomShape::GetAdjustValue( sal_uInt32 nIndex, sal_Int32 nDefault ) const
5475 {
5476 if ( ( nIndex >= nAdjustmentHandles ) || pAdjustmentHandles[ nIndex ].IsDefault() )
5477 return nDefault;
5478 else
5479 return pAdjustmentHandles[ nIndex ].GetAdjustValue();
5480 }
5481
5482 Point SvxMSDffCustomShape::GetPoint( const SvxMSDffVertPair& rPair, sal_Bool bScale ) const
5483 {
5484 Point aRetValue;
5485 sal_Bool bExchange = ( nFlags & DFF_CUSTOMSHAPE_EXCH ) != 0; // x <-> y
5486 sal_uInt32 nPass = 0;
5487 do
5488 {
5489 sal_uInt32 nIndex = nPass;
5490
5491 if ( bExchange )
5492 nIndex ^= 1;
5493
5494 sal_uInt32 nDat = nIndex ? (sal_uInt32)rPair.nValB : (sal_uInt32)rPair.nValA;
5495 sal_Bool bScaleWidth = nPass == 0;
5496
5497 double fVal;
5498 sal_uInt32 nGeometryFlags = 0;
5499 if ( ( nDat >> 16 ) == 0x8000 )
5500 fVal = ImplGetValue( (sal_uInt16)nDat, nGeometryFlags );
5501 else
5502 fVal = (sal_Int32)nDat;
5503
5504 if ( bScale )
5505 {
5506 if ( nGeometryFlags & bExchange ) // left <-> top, right <-> bottom
5507 {
5508 nGeometryFlags = ( ( nGeometryFlags & 1 ) << 1 ) | ( ( nGeometryFlags & 2 ) >> 1 ) |
5509 ( ( nGeometryFlags & 4 ) << 1 ) | ( ( nGeometryFlags & 8 ) >> 1 );
5510 }
5511 if ( bScaleWidth )
5512 {
5513 if ( ( aSnapRect.GetWidth() > aSnapRect.GetHeight() ) && ( ( nXRef != (sal_Int32)0x80000000 ) || nGeometryFlags ) )
5514 {
5515 sal_Bool bGeo = ( ( ( nGeometryFlags & GEOMETRY_USED_LEFT ) == 0 ) && ( fVal > nXRef ) )
5516 || ( ( nGeometryFlags & GEOMETRY_USED_RIGHT ) != 0 );
5517 if ( ( nGeometryFlags & ( GEOMETRY_USED_LEFT | GEOMETRY_USED_RIGHT ) ) == ( GEOMETRY_USED_LEFT | GEOMETRY_USED_RIGHT ) )
5518 {
5519 fVal -= (double)nCoordWidth * 0.5;
5520 fVal *= fYScale;
5521 fVal += (double)aSnapRect.GetWidth() * 0.5;
5522 }
5523 else
5524 {
5525 fVal *= fYScale;
5526 if ( bGeo )
5527 fVal += (double)nCoordWidth * fXScale - (double)nCoordWidth * fYScale;
5528 }
5529 }
5530 else
5531 fVal *= fXScale;
5532 if ( nFlags & DFF_CUSTOMSHAPE_FLIP_H )
5533 fVal = aSnapRect.GetWidth() - fVal;
5534 }
5535 else
5536 {
5537 if ( ( aSnapRect.GetHeight() > aSnapRect.GetWidth() ) && ( ( nYRef != (sal_Int32)0x80000000 ) || nGeometryFlags ) )
5538 {
5539 sal_Bool bGeo = ( ( ( nGeometryFlags & GEOMETRY_USED_TOP ) == 0 ) && ( fVal > nYRef ) )
5540 || ( ( nGeometryFlags & GEOMETRY_USED_BOTTOM ) != 0 );
5541 if ( ( nGeometryFlags & ( GEOMETRY_USED_TOP | GEOMETRY_USED_BOTTOM ) ) == ( GEOMETRY_USED_TOP | GEOMETRY_USED_BOTTOM ) )
5542 {
5543 fVal -= (double)nCoordHeight * 0.5;
5544 fVal *= fXScale;
5545 fVal += (double)aSnapRect.GetHeight() * 0.5;
5546 }
5547 else
5548 {
5549 fVal *= fXScale;
5550 if ( bGeo )
5551 fVal += (double)nCoordHeight * fYScale - (double)nCoordHeight * fXScale;
5552 }
5553 }
5554 else
5555 fVal *= fYScale;
5556 if ( nFlags & DFF_CUSTOMSHAPE_FLIP_V )
5557 fVal = aSnapRect.GetHeight() - fVal;
5558 }
5559 }
5560 if ( nPass )
5561 aRetValue.Y() = (sal_Int32)fVal;
5562 else
5563 aRetValue.X() = (sal_Int32)fVal;
5564 }
5565 while ( ++nPass < 2 );
5566 return aRetValue;
5567 }
5568
5569 double SvxMSDffCustomShape::ImplGetValue( sal_uInt16 nIndex, sal_uInt32& nGeometryFlags ) const
5570 {
5571 if ( !pCalculationData )
5572 return 0;
5573 if ( nCalculationData <= nIndex )
5574 return 0;
5575
5576 double fVal[ 3 ];
5577 sal_Int16 i, nF = pCalculationData[ nIndex ].nFlags;
5578 for ( i = 0; i < 3; i++ )
5579 {
5580 if ( nF & ( 0x2000 << i ) )
5581 {
5582 sal_Int16 nVal = 0;
5583 switch( i )
5584 {
5585 case 0: nVal = pCalculationData[ nIndex ].nVal1; break;
5586 case 1: nVal = pCalculationData[ nIndex ].nVal2; break;
5587 case 2: nVal = pCalculationData[ nIndex ].nVal3; break;
5588 }
5589 if ( nVal & 0x400 )
5590 fVal[ i ] = ImplGetValue( nVal & 0xff, nGeometryFlags );
5591 else
5592 {
5593 switch ( nVal )
5594 {
5595 case DFF_Prop_adjustValue :
5596 case DFF_Prop_adjust2Value :
5597 case DFF_Prop_adjust3Value :
5598 case DFF_Prop_adjust4Value :
5599 case DFF_Prop_adjust5Value :
5600 case DFF_Prop_adjust6Value :
5601 case DFF_Prop_adjust7Value :
5602 case DFF_Prop_adjust8Value :
5603 case DFF_Prop_adjust9Value :
5604 case DFF_Prop_adjust10Value :
5605 fVal[ i ] = GetAdjustValue( nVal - DFF_Prop_adjustValue );
5606 break;
5607 case DFF_Prop_geoLeft :
5608 {
5609 nGeometryFlags |= GEOMETRY_USED_LEFT;
5610 fVal[ i ] = 0.0;
5611 }
5612 break;
5613 case DFF_Prop_geoTop :
5614 {
5615 nGeometryFlags |= GEOMETRY_USED_TOP;
5616 fVal[ i ] = 0.0;
5617 }
5618 break;
5619 case DFF_Prop_geoRight :
5620 {
5621 nGeometryFlags |= GEOMETRY_USED_RIGHT;
5622 fVal[ i ] = nCoordWidth;
5623 }
5624 break;
5625 case DFF_Prop_geoBottom :
5626 {
5627 nGeometryFlags |= GEOMETRY_USED_BOTTOM;
5628 fVal[ i ] = nCoordWidth;
5629 }
5630 break;
5631 default:
5632 fVal[ i ] = 0.0;
5633 break;
5634 }
5635 }
5636 }
5637 else
5638 {
5639 switch( i )
5640 {
5641 case 0 : fVal[ 0 ] = pCalculationData[ nIndex ].nVal1; break;
5642 case 1 : fVal[ 1 ] = pCalculationData[ nIndex ].nVal2; break;
5643 case 2 : fVal[ 2 ] = pCalculationData[ nIndex ].nVal3; break;
5644 }
5645
5646
5647 }
5648 }
5649
5650 switch ( nF & 0xff )
5651 {
5652 case 0 : // sum
5653 {
5654 fVal[ 0 ] += fVal[ 1 ];
5655 fVal[ 0 ] -= fVal[ 2 ];
5656 }
5657 break;
5658
5659 case 1 : // product
5660 {
5661 if ( fVal[ 1 ] != 0.0 )
5662 fVal[ 0 ] *= fVal[ 1 ];
5663 if ( fVal[ 2 ] != 0.0 )
5664 fVal[ 0 ] /= fVal[ 2 ];
5665 }
5666 break;
5667
5668 case 2 : // mid
5669 {
5670 fVal[ 0 ] += fVal[ 1 ];
5671 fVal[ 0 ] /= 2.0;
5672 }
5673 break;
5674
5675 case 3 : // abs
5676 {
5677 fVal[ 0 ] = fabs( fVal[ 0 ] );
5678 }
5679 break;
5680
5681 case 4 : // min
5682 {
5683 if ( fVal[ 1 ] < fVal[ 0 ] )
5684 fVal[ 0 ] = fVal[ 1 ];
5685 }
5686 break;
5687
5688 case 5 :
5689 {
5690 if ( fVal[ 1 ] > fVal[ 0 ] ) // max
5691 fVal[ 0 ] = fVal[ 1 ];
5692 }
5693 break;
5694
5695 case 6 : // if > 0 ? a : b
5696 {
5697 if ( fVal[ 0 ] > 0.0 )
5698 fVal[ 0 ] = fVal[ 1 ];
5699 else
5700 fVal[ 0 ] = fVal[ 2 ];
5701 }
5702 break;
5703
5704 case 7 : // mod
5705 {
5706 fVal[ 0 ] = sqrt( fVal[ 0 ] * fVal[ 0 ] + fVal[ 1 ] * fVal[ 1 ]
5707 + fVal[ 2 ] * fVal[ 2 ] );
5708 }
5709 break;
5710
5711 case 8 : // atan2
5712 {
5713 fVal[ 0 ] = atan2( fVal[ 1 ], fVal[ 0 ] ) / F_PI180;
5714 fVal[ 0 ] *= 65536.0;
5715 }
5716 break;
5717
5718 case 9 : // in this special case the second parameter is a fixed fload
5719 { // which has to be divided by 0x10000
5720 fVal[ 0 ] *= sin( ( fVal[ 1 ] / 65536 ) * F_PI180 );
5721 }
5722 break;
5723
5724 case 0xa : // in this special case the second parameter is a fixed fload
5725 { // which has to be divided by 0x10000
5726 fVal[ 0 ] *= cos( ( fVal[ 1 ] / 65536 ) * F_PI180 );
5727 }
5728 break;
5729
5730 case 0xb : // cosatan2
5731 {
5732 fVal[ 0 ] *= cos( atan2( fVal[ 2 ], fVal[ 1 ] ) );
5733 }
5734 break;
5735
5736 case 0xc : // sinatan2
5737 {
5738 fVal[ 0 ] *= sin( atan2( fVal[ 2 ], fVal[ 1 ] ) );
5739 }
5740 break;
5741
5742 case 0xd : // sqrt
5743 {
5744 fVal[ 0 ] = sqrt( fVal[ 0 ] );
5745 }
5746 break;
5747
5748 case 0xe : // sumangle
5749 {
5750 fVal[ 0 ] += fVal[ 1 ] * 65536.0;
5751 fVal[ 0 ] -= fVal[ 2 ] * 65536.0;
5752 }
5753 break;
5754
5755 case 0xf : // ellipse
5756 {
5757 if ( fVal[ 1 ] != 0.0 )
5758 {
5759 fVal[ 0 ] /= fVal[ 1 ];
5760 fVal[ 0 ] = fVal[ 2 ] * sqrt( 1 - fVal[ 0 ] * fVal[ 0 ] );
5761 }
5762 }
5763 break;
5764
5765 case 0x10 : // tan
5766 {
5767 fVal[ 0 ] *= tan( fVal[ 1 ] );
5768 }
5769 break;
5770
5771 case 0x80 :
5772 {
5773 // fVal[0]^2 + fVal[1]^2 = fVal[2]^2
5774 if ( fVal[ 2 ] == 0.0 )
5775 fVal[ 0 ] = sqrt( fVal[ 0 ] * fVal[ 0 ] + fVal[ 1 ] * fVal[ 1 ] );
5776 else
5777 {
5778 double fA = fVal[ 0 ] != 0.0 ? fVal[ 0 ] : fVal[ 1 ];
5779 fVal[ 0 ] = sqrt( fVal[ 2 ] * fVal[ 2 ] - fA * fA );
5780 }
5781 }
5782 break;
5783 case 0x81 :
5784 {
5785 double fAngle = F_PI1800 * fVal[ 2 ];
5786 fVal[ 0 ] = ( cos( fAngle ) * ( fVal[ 0 ] - 10800 )
5787 + sin( fAngle ) * ( fVal[ 1 ] - 10800 ) ) + 10800;
5788 }
5789 break;
5790 case 0x82 :
5791 {
5792 double fAngle = F_PI1800 * fVal[ 2 ];
5793 fVal[ 0 ] = - ( sin( fAngle ) * ( fVal[ 0 ] - 10800 )
5794 - cos( fAngle ) * ( fVal[ 1 ] - 10800 ) ) + 10800;
5795 }
5796 break;
5797 default :
5798 {
5799 // sal_Bool bStop = sal_True;
5800 }
5801 break;
5802 }
5803 return fVal[ 0 ];
5804 }
5805
5806 // nLumDat 28-31 = number of luminance entries in nLumDat
5807 // nLumDat 27-24 = nLumDatEntry 0
5808 // nLumDat 23-20 = nLumDatEntry 1 ...
5809 // each 4bit entry is to be interpreted as a 10 percent signed luminance changing
5810 Color SvxMSDffCustomShape::ImplGetColorData( const Color& rFillColor, sal_uInt32 nIndex )
5811 {
5812 Color aRetColor;
5813
5814 sal_uInt32 i, nColor, nTmp, nCount = nColorData >> 28;
5815
5816 if ( nCount )
5817 {
5818 if ( nIndex >= nCount )
5819 nIndex = nCount - 1;
5820
5821 sal_uInt32 nFillColor = (sal_uInt32)rFillColor.GetRed() |
5822 ((sal_uInt32)rFillColor.GetGreen() << 8 ) |
5823 ((sal_uInt32)rFillColor.GetBlue() << 16 );
5824
5825 sal_Int32 nLumDat = nColorData << ( ( 1 + nIndex ) << 2 );
5826 sal_Int32 nLuminance = ( nLumDat >> 28 ) * 12;
5827
5828 nTmp = nFillColor;
5829 nColor = 0;
5830 for ( i = 0; i < 3; i++ )
5831 {
5832 sal_Int32 nC = (sal_uInt8)nTmp;
5833 nTmp >>= 8;
5834 nC += ( ( nLuminance * nC ) >> 8 );
5835 if ( nC < 0 )
5836 nC = 0;
5837 else if ( nC &~ 0xff )
5838 nC = 0xff;
5839 nColor >>= 8;
5840 nColor |= nC << 16;
5841 }
5842 aRetColor = Color( (sal_uInt8)nColor, (sal_uInt8)( nColor >> 8 ), (sal_uInt8)( nColor >> 16 ) );
5843 }
5844 return aRetColor;
5845 }
5846
5847 sal_Bool SvxMSDffCustomShape::IsEmpty() const
5848 {
5849 return bIsEmpty;
5850 }
5851
5852 Rectangle SvxMSDffCustomShape::GetTextRect() const
5853 {
5854 if ( !nTextRectData )
5855 return aSnapRect;
5856
5857 sal_uInt32 nIndex = 0;
5858 if ( bTextFlow && ( nTextRectData > 1 ) )
5859 nIndex++;
5860
5861 Point aTopLeft( GetPoint( pTextRectData[ nIndex ].nPairA, sal_True ) );
5862 Point aBottomRight( GetPoint( pTextRectData[ nIndex ].nPairB, sal_True ) );
5863 Rectangle aRect( aTopLeft, aBottomRight );
5864 aRect.Move( aSnapRect.Left(), aSnapRect.Top() );
5865 if ( bFlipH )
5866 {
5867 sal_Int32 nXDist = aSnapRect.Right() - aRect.Right();
5868 aRect = Rectangle( Point( nXDist + aSnapRect.Left(), aRect.Top() ), aRect.GetSize() );
5869 }
5870 if ( bFlipV )
5871 {
5872 sal_Int32 nYDist = aSnapRect.Bottom() - aRect.Bottom();
5873 aRect = Rectangle( Point( aRect.Left(), nYDist + aSnapRect.Top() ), aRect.GetSize() );
5874 }
5875 return aRect;
5876 }
5877
5878 sal_Bool SvxMSDffCustomShape::HasGluePointList( const MSO_SPT eShapeType )
5879 {
5880 const mso_CustomShape* pCustomShape = GetCustomShapeContent2( eShapeType );
5881 return pCustomShape && pCustomShape->nGluePoints;
5882 }
5883
5884 MSO_SPT SvxMSDffCustomShape::GetShapeTypeFromSdrObject( const SdrObject* pObj )
5885 {
5886 MSO_SPT eShapeType = mso_sptNil;
5887 const SfxPoolItem* pAdjustItem = NULL;
5888 const SfxItemSet& rItemSet = pObj->GetMergedItemSet();
5889 rItemSet.GetItemState( SDRATTR_CUSTOMSHAPE_ADJUSTMENT, FALSE, &pAdjustItem );
5890 if ( pAdjustItem )
5891 {
5892 SdrCustomShapeAdjustmentItem& rAdjustItem = *(SdrCustomShapeAdjustmentItem*)pAdjustItem;
5893 sal_uInt32 nCount = rAdjustItem.GetCount();
5894 if ( nCount >= 3 )
5895 {
5896 /* checking magic number, so we can get sure that the SdrObject was a customshape
5897 and we can get the customshape type */
5898 if ( rAdjustItem.GetValue( nCount - 1 ).GetValue() == (sal_Int32)0x80001234 )
5899 eShapeType = (MSO_SPT)((sal_uInt32)(rAdjustItem.GetValue( nCount - 2 ).GetValue()) >> 16);
5900 }
5901 }
5902 return eShapeType;
5903 }
5904
5905 void SvxMSDffCustomShape::SwapStartAndEndArrow( SdrObject* pObj ) //#108274
5906 {
5907 XLineStartItem aLineStart;
5908 const SfxItemSet& rObjItemSet = pObj->GetMergedItemSet();
5909
5910 aLineStart.SetLineStartValue(((XLineStartItem&)rObjItemSet.Get( XATTR_LINEEND )).GetLineStartValue());
5911 XLineStartWidthItem aLineStartWidth(((XLineStartWidthItem&)rObjItemSet.Get( XATTR_LINEENDWIDTH )).GetValue());
5912 XLineStartCenterItem aLineStartCenter(((XLineStartCenterItem&)rObjItemSet.Get( XATTR_LINEENDCENTER )).GetValue());
5913
5914 XLineEndItem aLineEnd;
5915 aLineEnd.SetLineEndValue(((XLineEndItem&)rObjItemSet.Get( XATTR_LINESTART )).GetLineEndValue());
5916 XLineEndWidthItem aLineEndWidth(((XLineEndWidthItem&)rObjItemSet.Get( XATTR_LINESTARTWIDTH )).GetValue());
5917 XLineEndCenterItem aLineEndCenter(((XLineEndCenterItem&)rObjItemSet.Get( XATTR_LINESTARTCENTER )).GetValue());
5918
5919 SfxItemSet aNew(*rObjItemSet.GetPool());
5920
5921 aNew.Put( aLineStart );
5922 aNew.Put( aLineStartWidth );
5923 aNew.Put( aLineStartCenter );
5924 aNew.Put( aLineEnd );
5925 aNew.Put( aLineEndWidth );
5926 aNew.Put( aLineEndCenter );
5927
5928 pObj->SetMergedItemSet(aNew);
5929 }
5930
5931 SdrObject* SvxMSDffCustomShape::GetObject( SdrModel* pSdrModel, SfxItemSet& rSet, sal_Bool bSetCustomShapeAdjustItem )
5932 {
5933 SdrObject* pRet = NULL;
5934
5935 if ( !IsEmpty() )
5936 {
5937 if ( eSpType == mso_sptRectangle )
5938 {
5939 pRet = new SdrRectObj( aSnapRect );
5940 pRet->SetModel( pSdrModel );
5941 pRet->SetMergedItemSet(rSet);
5942 }
5943 else if ( eSpType == mso_sptRoundRectangle )
5944 {
5945 sal_Int32 nW = aSnapRect.Right() - aSnapRect.Left();
5946 sal_Int32 nH = aSnapRect.Bottom() - aSnapRect.Top();
5947 if ( nH < nW )
5948 nW = nH;
5949 double fAdjust = (double)GetAdjustValue( 0, 3600 ) / 21600.0;
5950 nW = (sal_Int32)( (double)nW * fAdjust );
5951 rSet.Put( SdrEckenradiusItem( nW ) );
5952 pRet = new SdrRectObj( aSnapRect );
5953 pRet->SetModel( pSdrModel );
5954 pRet->SetMergedItemSet(rSet);
5955 }
5956 else if ( eSpType == mso_sptEllipse )
5957 {
5958 pRet = new SdrCircObj( OBJ_CIRC, aSnapRect );
5959 pRet->SetModel( pSdrModel );
5960 pRet->SetMergedItemSet(rSet);
5961 }
5962 else if ( eSpType == mso_sptArc )
5963 { // the arc is something special, because sometimes the snaprect does not match
5964 Rectangle aPolyBoundRect;
5965 if ( nNumElemVert )
5966 {
5967 XPolygon aXP( (sal_uInt16)nNumElemVert );
5968 const SvxMSDffVertPair* pTmp = pVertData;
5969 sal_uInt32 nPtNum;
5970 for ( nPtNum = 0; nPtNum < nNumElemVert; nPtNum++ )
5971 aXP[ (sal_uInt16)nPtNum ] = GetPoint( *pTmp++, sal_False );
5972 aPolyBoundRect = Rectangle( aXP.GetBoundRect() );
5973 }
5974 else
5975 aPolyBoundRect = aSnapRect;
5976
5977 sal_Int32 nEndAngle = Fix16ToAngle( GetAdjustValue( 0 ) );
5978 sal_Int32 nStartAngle = Fix16ToAngle( GetAdjustValue( 1 ) );
5979
5980 if ( nStartAngle == nEndAngle )
5981 return NULL;
5982
5983 if ( bFilled ) // ( filled ) ? we have to import an pie : we have to construct an arc
5984 {
5985 pRet = new SdrCircObj( OBJ_SECT, aPolyBoundRect, nStartAngle, nEndAngle );
5986 pRet->NbcSetSnapRect( aSnapRect );
5987 pRet->SetModel( pSdrModel );
5988 pRet->SetMergedItemSet(rSet);
5989 }
5990 else
5991 {
5992 Point aStart, aEnd, aCenter( aPolyBoundRect.Center() );
5993 aStart.X() = (sal_Int32)( ( cos( ( (double)nStartAngle * F_PI18000 ) ) * 1000.0 ) );
5994 aStart.Y() = - (sal_Int32)( ( sin( ( (double)nStartAngle * F_PI18000 ) ) * 1000.0 ) );
5995 aEnd.X() = (sal_Int32)( ( cos( ( (double)nEndAngle * F_PI18000 ) ) * 1000.0 ) );
5996 aEnd.Y() = - (sal_Int32)( ( sin( ( (double)nEndAngle * F_PI18000 ) ) * 1000.0 ) );
5997 aStart.X() += aCenter.X();
5998 aStart.Y() += aCenter.Y();
5999 aEnd.X() += aCenter.X();
6000 aEnd.Y() += aCenter.Y();
6001
6002 Polygon aPolygon( aPolyBoundRect, aStart, aEnd, POLY_PIE );
6003 Rectangle aPolyPieRect( aPolygon.GetBoundRect() );
6004
6005 USHORT nPt = aPolygon.GetSize();
6006
6007 if ( nPt < 4 )
6008 return NULL;
6009
6010 aPolygon[ 0 ] = aPolygon[ 1 ]; // try to get the arc boundrect
6011 aPolygon[ nPt - 1 ] = aPolygon[ nPt - 2 ];
6012 Rectangle aPolyArcRect( aPolygon.GetBoundRect() );
6013
6014 double fYSc, fXSc;
6015 double fYOfs, fXOfs;
6016 int nCond;
6017
6018 fYOfs = fXOfs = 0.0;
6019 if ( aPolyPieRect.GetWidth() != aPolyArcRect.GetWidth() )
6020 {
6021 nCond = ( (sal_uInt32)( nStartAngle - 9000 ) > 18000 ) && ( (sal_uInt32)( nEndAngle - 9000 ) > 18000 ) ? 1 : 0;
6022 nCond ^= bFlipH ? 1 : 0;
6023 if ( nCond )
6024 {
6025 fXSc = (double)aSnapRect.GetWidth() / (double)aPolyPieRect.GetWidth();
6026 fXOfs = ( (double)aPolyPieRect.GetWidth() - (double)aPolyArcRect.GetWidth() ) * fXSc;
6027 }
6028 }
6029 if ( aPolyPieRect.GetHeight() != aPolyArcRect.GetHeight() )
6030 {
6031 nCond = ( ( nStartAngle > 18000 ) && ( nEndAngle > 18000 ) ) ? 1 : 0;
6032 nCond ^= bFlipV ? 1 : 0;
6033 if ( nCond )
6034 {
6035 fYSc = (double)aSnapRect.GetHeight() / (double)aPolyPieRect.GetHeight();
6036 fYOfs = ( (double)aPolyPieRect.GetHeight() - (double)aPolyArcRect.GetHeight() ) * fYSc;
6037 }
6038 }
6039 fXSc = (double)aPolyArcRect.GetWidth() / (double)aPolyPieRect.GetWidth();
6040 fYSc = (double)aPolyArcRect.GetHeight() / (double)aPolyPieRect.GetHeight();
6041
6042 aPolyArcRect = Rectangle( Point( aSnapRect.Left() + (sal_Int32)fXOfs, aSnapRect.Top() + (sal_Int32)fYOfs ),
6043 Size( (sal_Int32)( aSnapRect.GetWidth() * fXSc ), (sal_Int32)( aSnapRect.GetHeight() * fYSc ) ) );
6044
6045 SdrCircObj* pObjCirc = new SdrCircObj( OBJ_CARC, aPolyBoundRect, nStartAngle, nEndAngle );
6046 pObjCirc->SetSnapRect( aPolyArcRect );
6047 pObjCirc->SetModel( pSdrModel );
6048 pObjCirc->SetMergedItemSet( rSet );
6049
6050 int nSwap = bFlipH ? 1 : 0;
6051 nSwap ^= bFlipV ? 1 : 0;
6052 if ( nSwap )
6053 SwapStartAndEndArrow( pObjCirc );
6054
6055 SdrRectObj* pRect = new SdrRectObj( aPolyArcRect );
6056 pRect->SetSnapRect( aPolyArcRect );
6057 pRect->SetModel( pSdrModel );
6058 pRect->SetMergedItemSet( rSet );
6059 pRect->SetMergedItem( XLineStyleItem( XLINE_NONE ) );
6060 pRect->SetMergedItem( XFillStyleItem( XFILL_NONE ) );
6061
6062 pRet = new SdrObjGroup();
6063 pRet->SetModel( pSdrModel );
6064 ((SdrObjGroup*)pRet)->GetSubList()->NbcInsertObject( pRect );
6065 ((SdrObjGroup*)pRet)->GetSubList()->NbcInsertObject( pObjCirc );
6066 }
6067 }
6068 if ( !pRet && nNumElemVert )
6069 {
6070 // Header auswerten
6071 XPolygon aXP( (sal_uInt16)nNumElemVert );
6072 const SvxMSDffVertPair* pT = pVertData;
6073 sal_uInt32 nPtNum;
6074 for ( nPtNum = 0; nPtNum < nNumElemVert; nPtNum++ )
6075 aXP[ (sal_uInt16)nPtNum ] = GetPoint( *pT++, sal_True );
6076 Rectangle aPolyBoundRect( aXP.GetBoundRect() );
6077
6078 if ( !pSegData )
6079 {
6080 FASTBOOL bClosed = aXP[ 0 ] == aXP[ (sal_uInt16)( aXP.GetPointCount() - 1 ) ];
6081 Rectangle aUnion( aXP.GetBoundRect() );
6082 pRet = new SdrPathObj( bClosed ? OBJ_POLY : OBJ_PLIN, basegfx::B2DPolyPolygon(aXP.getB2DPolygon()));
6083 pRet->NbcSetSnapRect( Rectangle( Point( aSnapRect.Left() + aUnion.Left(),
6084 aSnapRect.Top() + aUnion.Top() ),
6085 aUnion.GetSize() ) );
6086 pRet->SetModel( pSdrModel );
6087 pRet->SetMergedItemSet(rSet);
6088 }
6089 else
6090 {
6091 SdrObjGroup* pGrp = NULL;
6092 SdrObject* pSdrPathObj = NULL;
6093
6094 XPolyPolygon aPolyPoly;
6095 XPolygon aPoly;
6096
6097 XPolyPolygon aEmptyPolyPoly;
6098 XPolygon aEmptyPoly;
6099
6100 BOOL bClosed = FALSE;
6101 sal_uInt16 nPolyFlags;
6102
6103 Color aFillColor( COL_WHITE );
6104 sal_uInt32 nColorCount = nColorData >> 28;
6105 sal_uInt32 nColorIndex = 0;
6106 sal_uInt16 nSrcPt = 0;
6107
6108 Rectangle aUnion;
6109
6110 const sal_uInt16* pS = pSegData;
6111
6112 if ( nColorCount )
6113 {
6114 const SfxPoolItem* pPoolItem = NULL;
6115 SfxItemState eState = rSet.GetItemState( XATTR_FILLCOLOR, FALSE, &pPoolItem );
6116 if( SFX_ITEM_SET == eState )
6117 {
6118 if ( pPoolItem )
6119 aFillColor = ((XFillColorItem*)pPoolItem)->GetColorValue();
6120 }
6121 }
6122 for ( sal_uInt16 i = 0; i < nNumElemSeg; i++ )
6123 {
6124 nPolyFlags = *pS++;
6125 switch ( nPolyFlags >> 12 )
6126 {
6127 case 0x4 :
6128 {
6129 if ( aPoly.GetPointCount() > 1 )
6130 {
6131 if ( bClosed )
6132 aPoly[ aPoly.GetPointCount() ] = aPoly[ 0 ];
6133 aPolyPoly.Insert( aPoly );
6134 }
6135 bClosed = FALSE;
6136 aPoly = aEmptyPoly;
6137 aPoly[ 0 ] = aXP[ nSrcPt++ ];
6138 }
6139 break;
6140 case 0x8 :
6141 {
6142 if ( aPoly.GetPointCount() > 1 )
6143 {
6144 if ( bClosed )
6145 aPoly[ aPoly.GetPointCount() ] = aPoly[ 0 ];
6146 aPolyPoly.Insert( aPoly );
6147 }
6148 aPoly = aEmptyPoly;
6149 if ( aPolyPoly.Count() )
6150 {
6151 if ( pSdrPathObj )
6152 {
6153 pGrp = new SdrObjGroup();
6154 pGrp->SetModel( pSdrModel );
6155 pGrp->NbcSetLogicRect( aSnapRect );
6156 pGrp->GetSubList()->NbcInsertObject( pSdrPathObj );
6157 }
6158 aUnion.Union( aPolyPoly.GetBoundRect() );
6159 pSdrPathObj = new SdrPathObj( bClosed ? OBJ_POLY : OBJ_PLIN, aPolyPoly.getB2DPolyPolygon() );
6160 pSdrPathObj->SetModel( pSdrModel );
6161 if ( !bClosed )
6162 rSet.Put( SdrShadowItem( FALSE ) );
6163 else
6164 {
6165 if ( nColorIndex < nColorCount )
6166 {
6167 Color aColor( ImplGetColorData( aFillColor, nColorIndex++ ) );
6168 rSet.Put( XFillColorItem( String(), aColor ) );
6169 }
6170 }
6171 pSdrPathObj->SetMergedItemSet(rSet);
6172 if ( pGrp )
6173 {
6174 if ( pSdrPathObj )
6175 {
6176 pGrp->GetSubList()->NbcInsertObject( pSdrPathObj );
6177 pSdrPathObj = NULL;
6178 }
6179 }
6180 aPolyPoly = aEmptyPolyPoly;
6181 }
6182 }
6183 break;
6184 case 0x6 :
6185 {
6186 bClosed = TRUE;
6187 }
6188 break;
6189 case 0x2 :
6190 {
6191 sal_uInt16 nDstPt = aPoly.GetPointCount();
6192 for ( sal_uInt16 k = 0; k < ( nPolyFlags & 0xfff ); k++ )
6193 {
6194 aPoly[ nDstPt ] = aXP[ nSrcPt++ ];
6195 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6196 aPoly[ nDstPt ] = aXP[ nSrcPt++ ];
6197 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6198 aPoly[ nDstPt++ ] = aXP[ nSrcPt++ ];
6199 }
6200 }
6201 break;
6202 case 0xa :
6203 case 0xb :
6204 {
6205 sal_uInt16 nPntCount = (BYTE)nPolyFlags;
6206 if ( nPntCount )
6207 {
6208 sal_uInt32 nMod = ( nPolyFlags >> 8 ) & 0xf;
6209 switch ( nMod )
6210 {
6211 case 3 :
6212 case 4 :
6213 case 5 :
6214 {
6215 sal_uInt16 nDstPt = aPoly.GetPointCount();
6216 if ( nPntCount == 2 )
6217 { // create a circle
6218 Rectangle aRect( aXP[ nSrcPt ], aXP[ nSrcPt + 1 ] );
6219 sal_Int32 nXControl = (sal_Int32)((double)aRect.GetWidth() * 0.2835 );
6220 sal_Int32 nYControl = (sal_Int32)((double)aRect.GetHeight() * 0.2835 );
6221 Point aCenter( aRect.Center() );
6222 aPoly[ nDstPt++ ] = Point( aCenter.X(), aRect.Top() );
6223 aPoly[ nDstPt ] = Point( aCenter.X() + nXControl, aRect.Top() );
6224 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6225 aPoly[ nDstPt ] = Point( aRect.Right(), aCenter.Y() - nYControl );
6226 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6227 aPoly[ nDstPt++ ] = Point( aRect.Right(), aCenter.Y() );
6228 aPoly[ nDstPt ] = Point( aRect.Right(), aCenter.Y() + nYControl );
6229 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6230 aPoly[ nDstPt ] = Point( aCenter.X() + nXControl, aRect.Bottom() );
6231 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6232 aPoly[ nDstPt++ ] = Point( aCenter.X(), aRect.Bottom() );
6233 aPoly[ nDstPt ] = Point( aCenter.X() - nXControl, aRect.Bottom() );
6234 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6235 aPoly[ nDstPt ] = Point( aRect.Left(), aCenter.Y() + nYControl );
6236 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6237 aPoly[ nDstPt++ ] = Point( aRect.Left(), aCenter.Y() );
6238 aPoly[ nDstPt ] = Point( aRect.Left(), aCenter.Y() - nYControl );
6239 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6240 aPoly[ nDstPt ] = Point( aCenter.X() - nXControl, aRect.Top() );
6241 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6242 aPoly[ nDstPt++ ] = Point( aCenter.X(), aRect.Top() );
6243 nSrcPt += 2;
6244 }
6245 else
6246 {
6247 sal_uInt32 nXor = ( nMod == 5 ) ? 3 : 2;
6248 for ( sal_uInt16 k = 0; k < ( nPntCount >> 2 ); k++ )
6249 {
6250 PolyStyle ePolyStyle = POLY_ARC;
6251 Rectangle aRect( aXP[ nSrcPt ], aXP[ nSrcPt + 1 ] );
6252 Point aCenter( aRect.Center() );
6253 Point aStart( aXP[ (sal_uInt16)( nSrcPt + nXor ) ] );
6254 Point aEnd( aXP[ (sal_uInt16)( nSrcPt + ( nXor ^ 1 ) ) ] );
6255 aStart.X() = (sal_Int32)( ( (double)( aStart.X() - aCenter.X() ) / fXScale ) ) + aCenter.X();
6256 aStart.Y() = (sal_Int32)( ( (double)( aStart.Y() - aCenter.Y() ) / fYScale ) ) + aCenter.Y();
6257 aEnd.X() = (sal_Int32)( ( (double)( aEnd.X() - aCenter.X() ) / fXScale ) ) + aCenter.X();
6258 aEnd.Y() = (sal_Int32)( ( (double)( aEnd.Y() - aCenter.Y() ) / fYScale ) ) + aCenter.Y();
6259
6260 Polygon aTempPoly( aRect, aStart, aEnd, ePolyStyle );
6261 if ( nMod == 5 )
6262 {
6263 for ( sal_uInt16 j = aTempPoly.GetSize(); j--; )
6264 aPoly[ nDstPt++ ] = aTempPoly[ j ];
6265 }
6266 else
6267 {
6268 for ( sal_uInt16 j = 0; j < aTempPoly.GetSize(); j++ )
6269 aPoly[ nDstPt++ ] = aTempPoly[ j ];
6270 }
6271 nSrcPt += 4;
6272 }
6273 }
6274 }
6275 break;
6276 case 0 :
6277 case 1 :
6278 case 2 :
6279 case 6 :
6280 case 9 :
6281 case 0xa :
6282 case 0xb :
6283 case 0xc :
6284 case 0xd :
6285 case 0xe :
6286 case 0xf :
6287
6288 case 7 :
6289 case 8 :
6290 {
6291 BOOL bFirstDirection = TRUE;
6292 sal_uInt16 nDstPt = aPoly.GetPointCount();
6293 for ( sal_uInt16 k = 0; k < ( nPolyFlags & 0xff ); k++ )
6294 {
6295 sal_uInt32 nModT = ( nMod == 7 ) ? 1 : 0;
6296 Point aCurrent( aXP[ nSrcPt ] );
6297 if ( nSrcPt ) // we need a previous point
6298 {
6299 Point aPrev( aXP[ nSrcPt - 1 ] );
6300 sal_Int32 nX, nY;
6301 nX = aCurrent.X() - aPrev.X();
6302 nY = aCurrent.Y() - aPrev.Y();
6303 if ( ( nY ^ nX ) & 0x80000000 )
6304 {
6305 if ( !k )
6306 bFirstDirection = TRUE;
6307 else if ( !bFirstDirection )
6308 nModT ^= 1;
6309 }
6310 else
6311 {
6312 if ( !k )
6313 bFirstDirection = FALSE;
6314 else if ( bFirstDirection )
6315 nModT ^= 1;
6316 }
6317 if ( nModT ) // get the right corner
6318 {
6319 nX = aCurrent.X();
6320 nY = aPrev.Y();
6321 }
6322 else
6323 {
6324 nX = aPrev.X();
6325 nY = aCurrent.Y();
6326 }
6327 sal_Int32 nXVec = ( nX - aPrev.X() ) >> 1;
6328 sal_Int32 nYVec = ( nY - aPrev.Y() ) >> 1;
6329 Point aControl1( aPrev.X() + nXVec, aPrev.Y() + nYVec );
6330 aPoly[ nDstPt ] = aControl1;
6331 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6332 nXVec = ( nX - aCurrent.X() ) >> 1;
6333 nYVec = ( nY - aCurrent.Y() ) >> 1;
6334 Point aControl2( aCurrent.X() + nXVec, aCurrent.Y() + nYVec );
6335 aPoly[ nDstPt ] = aControl2;
6336 aPoly.SetFlags( nDstPt++, XPOLY_CONTROL );
6337 }
6338 aPoly[ nDstPt ] = aCurrent;
6339 nSrcPt++;
6340 nDstPt++;
6341 }
6342 }
6343 break;
6344 }
6345 }
6346 }
6347 break;
6348 case 0x0 :
6349 {
6350 sal_uInt16 nDstPt = aPoly.GetPointCount();
6351 for ( sal_uInt16 k = 0; k < ( nPolyFlags & 0xfff ); k++ )
6352 aPoly[ nDstPt++ ] = aXP[ nSrcPt++ ];
6353 }
6354 break;
6355 case 0xf :
6356 {
6357 sal_Bool bOwn = TRUE;
6358 switch ( nPolyFlags )
6359 {
6360 case 0xf8ff : // This value is not ms specific and is used
6361 { // to create a dummy object that is not visible.
6362 SdrObject* pLast = pSdrPathObj; // This solves the problem of customshapes that
6363 if ( !pLast ) // did not use the whole space of the boundrect.
6364 { // eg. the BlockArc
6365 if ( pGrp )
6366 {
6367 SdrObjList* pList = pGrp->GetSubList();
6368 if ( pList && pList->GetObjCount() )
6369 pLast = pList->GetObj( pList->GetObjCount() - 1 );
6370 }
6371 }
6372 if ( pLast )
6373 {
6374 pLast->SetMergedItem( XLineStyleItem( XLINE_NONE ) );
6375 pLast->SetMergedItem( XFillStyleItem( XFILL_NONE ) );
6376 }
6377 }
6378 break;
6379 case 0xf8fe : // nearly the same as 0x4000
6380 { // but the first point is ignored
6381 if ( aPoly.GetPointCount() > 1 )
6382 {
6383 if ( bClosed )
6384 aPoly[ aPoly.GetPointCount() ] = aPoly[ 0 ];
6385 aPolyPoly.Insert( aPoly );
6386 }
6387 aPoly = aEmptyPoly;
6388 }
6389 break;
6390 default :
6391 bOwn = FALSE;
6392 }
6393 if ( bOwn )
6394 break;
6395 }
6396 #ifdef DBG_CUSTOMSHAPE
6397 default :
6398 {
6399 ByteString aString( "customshapes::unknown PolyFlagValue :" );
6400 aString.Append( ByteString::CreateFromInt32( nPolyFlags ) );
6401 DBG_ERROR( aString.GetBuffer() );
6402 }
6403 break;
6404 #endif
6405 }
6406 }
6407 if ( pGrp )
6408 pRet = pGrp;
6409 else
6410 pRet = pSdrPathObj;
6411 if ( pRet )
6412 {
6413 pRet->NbcSetSnapRect( Rectangle( Point( aSnapRect.Left() + aUnion.Left(),
6414 aSnapRect.Top() + aUnion.Top() ),
6415 aUnion.GetSize() ) );
6416 }
6417 }
6418 }
6419 }
6420 if ( pRet )
6421 {
6422 // some objects needs to have their own GluePoint list
6423 if ( HasGluePointList( eSpType ) )
6424 {
6425 sal_uInt32 i;
6426 const SvxMSDffVertPair* pTmp = pGluePoints;
6427 for ( i = 0; i < nGluePoints; i++ )
6428 {
6429 SdrGluePoint aGluePoint;
6430 Rectangle aNewSnapRect( pRet->GetSnapRect() );
6431 sal_Int32 nXMove = aSnapRect.Left() - aNewSnapRect.Left();
6432 sal_Int32 nYMove = aSnapRect.Top() - aNewSnapRect.Top();
6433
6434 const Point& rPoint = GetPoint( *pTmp++, sal_True );
6435 double fXRel = rPoint.X() + nXMove;
6436 double fYRel = rPoint.Y() + nYMove;
6437 fXRel = fXRel / aNewSnapRect.GetWidth() * 10000;
6438 fYRel = fYRel / aNewSnapRect.GetHeight() * 10000;
6439 aGluePoint.SetPos( Point( (sal_Int32)fXRel, (sal_Int32)fYRel ) );
6440 aGluePoint.SetPercent( sal_True );
6441 aGluePoint.SetAlign( SDRVERTALIGN_TOP | SDRHORZALIGN_LEFT );
6442 aGluePoint.SetEscDir( SDRESC_SMART );
6443 SdrGluePointList* pList = pRet->ForceGluePointList();
6444 if( pList )
6445 /* sal_uInt16 nId = */ pList->Insert( aGluePoint );
6446 }
6447 }
6448 if ( bSetCustomShapeAdjustItem )
6449 {
6450 if ( pRet->ISA( SdrObjGroup ) || pRet->ISA( SdrPathObj ) )
6451 {
6452 sal_uInt32 i, nCount = 0;
6453 SdrObject* pFirstObject = pRet;
6454 SdrObjList* pObjectList = NULL;
6455 if ( pRet->ISA( SdrPathObj ) )
6456 nCount = 1;
6457 else
6458 {
6459 pObjectList = ((SdrObjGroup*)pRet)->GetSubList();
6460 if ( pObjectList )
6461 nCount = pObjectList->GetObjCount();
6462 if ( nCount )
6463 pFirstObject = pObjectList->GetObj( 0 );
6464 }
6465 if ( nCount )
6466 {
6467 SdrCustomShapeAdjustmentItem aAdjustItem;
6468 SdrCustomShapeAdjustmentValue aAdjustValue;
6469 if ( nAdjustmentHandles )
6470 {
6471 for ( i = 0; i < nAdjustmentHandles; i++ )
6472 {
6473 aAdjustValue.SetValue( pAdjustmentHandles[ i ].GetAdjustValue() );
6474 aAdjustItem.SetValue( i, aAdjustValue );
6475 }
6476 }
6477 if ( bVertAlloc == FALSE )
6478 {
6479 sal_uInt32 nMagicNumber = 0x80001234; // this magic number identifies ms objects
6480 sal_uInt32 nType = (sal_uInt32)eSpType << 16 // hiword is the shapetype
6481 | nCount; // loword the number of Path objects
6482 sal_uInt32 nChecksum = 0; // checksum is used later to be sure that
6483 // the object is not changed
6484
6485 // here we are calculating the checksum
6486 Rectangle aTRect( pRet->GetSnapRect() );
6487 sal_Int32 nLeft = aTRect.Left();
6488 sal_Int32 nTop = aTRect.Top();
6489
6490 SdrObject* pNext = pFirstObject;
6491 for ( i = 0; i < nCount; i++ )
6492 {
6493 if ( i )
6494 pNext = pObjectList->GetObj( i );
6495
6496 if ( !pNext->ISA( SdrPathObj ) ) // just only SdrPathObjs are valid as Customshapes
6497 {
6498 nChecksum = 0;
6499 break;
6500 }
6501
6502 // #i74631# use explicit constructor here. Also XPolyPolygon is not necessary,
6503 // reducing to PolyPolygon
6504 const PolyPolygon aPolyPolygon(((SdrPathObj*)pNext)->GetPathPoly());
6505
6506 sal_uInt16 j, k = aPolyPolygon.Count();
6507 sal_Int32 aVal[ 3 ];
6508 while( k )
6509 {
6510 const Polygon& rPoly = aPolyPolygon[ --k ];
6511 j = rPoly.GetSize();
6512 while( j )
6513 {
6514 const Point& rPoint = rPoly[ --j ];
6515 #ifdef OSL_LITENDIAN
6516 aVal[ 0 ] = SWAPLONG( rPoint.X() - nLeft );
6517 aVal[ 1 ] = SWAPLONG( rPoint.Y() - nTop );
6518 aVal[ 2 ] = SWAPLONG( rPoly.GetFlags( j ) );
6519 #else
6520 aVal[ 0 ] = rPoint.X() - nLeft;
6521 aVal[ 1 ] = rPoint.Y() - nTop;
6522 aVal[ 2 ] = rPoly.GetFlags( j );
6523 #endif
6524 nChecksum = rtl_crc32( nChecksum, &aVal[ 0 ], 12 );
6525 }
6526 }
6527 }
6528
6529 if ( nChecksum )
6530 {
6531 i = aAdjustItem.GetCount();
6532 aAdjustValue.SetValue( nChecksum ); // the last 3 entries in the adjustment item must be in this
6533 aAdjustItem.SetValue( i++, aAdjustValue ); // order, otherwise it will be not possible to recreate the original
6534 aAdjustValue.SetValue( nType ); // customshape when exporting into ms formats
6535 aAdjustItem.SetValue( i++, aAdjustValue );
6536 aAdjustValue.SetValue( nMagicNumber );
6537 aAdjustItem.SetValue( i++, aAdjustValue );
6538 }
6539 }
6540 SfxItemSet aSet( pSdrModel->GetItemPool() );
6541 aSet.Put( aAdjustItem );
6542 pFirstObject->SetMergedItemSet(aSet);
6543 }
6544 }
6545 }
6546 }
6547 return pRet;
6548 }
vba interoperability for OOo